From 00fcd0550fcdda621c2e4662f6ddd55ce673b931 Mon Sep 17 00:00:00 2001 From: Gegy Date: Thu, 24 Jan 2019 14:48:32 +0200 Subject: [WIP] Mapping rework (#91) * Move packages * Mapping & entry refactor: first pass * Fix deobf -> obf tree remapping * Resolve various issues * Give all entries the potential for parents and treat inner classes as children * Deobf UI tree elements * Tests pass * Sort mapping output * Fix delta tracking * Index separation and first pass for #97 * Keep track of remapped jar index * Fix child entries not being remapped * Drop non-root entries * Track dropped mappings * Fix enigma mapping ordering * EntryTreeNode interface * Small tweaks * Naive full index remap on rename * Entries can resolve to more than one root entry * Support alternative resolution strategies * Bridge method resolution * Tests pass * Fix mappings being used where there are none * Fix methods with different descriptors being considered unique. closes #89 --- .../java/cuchaz/enigma/bytecode/AccessFlags.java | 105 --------------------- .../bytecode/translators/AsmObjectTranslator.java | 46 +++++++++ .../translators/TranslationAnnotationVisitor.java | 20 ++-- .../translators/TranslationClassVisitor.java | 74 +++++++-------- .../translators/TranslationFieldVisitor.java | 10 +- .../translators/TranslationMethodVisitor.java | 55 ++++++----- 6 files changed, 123 insertions(+), 187 deletions(-) delete mode 100644 src/main/java/cuchaz/enigma/bytecode/AccessFlags.java create mode 100644 src/main/java/cuchaz/enigma/bytecode/translators/AsmObjectTranslator.java (limited to 'src/main/java/cuchaz/enigma/bytecode') diff --git a/src/main/java/cuchaz/enigma/bytecode/AccessFlags.java b/src/main/java/cuchaz/enigma/bytecode/AccessFlags.java deleted file mode 100644 index 31c8691..0000000 --- a/src/main/java/cuchaz/enigma/bytecode/AccessFlags.java +++ /dev/null @@ -1,105 +0,0 @@ -package cuchaz.enigma.bytecode; - -import cuchaz.enigma.analysis.Access; -import org.objectweb.asm.Opcodes; - -import java.lang.reflect.Modifier; - -public class AccessFlags { - private int flags; - - public AccessFlags(int flags) { - this.flags = flags; - } - - public boolean isPrivate() { - return Modifier.isPrivate(this.flags); - } - - public boolean isProtected() { - return Modifier.isProtected(this.flags); - } - - public boolean isPublic() { - return Modifier.isPublic(this.flags); - } - - public boolean isSynthetic() { - return (this.flags & Opcodes.ACC_SYNTHETIC) != 0; - } - - public boolean isStatic() { - return Modifier.isStatic(this.flags); - } - - public boolean isEnum() { - return (flags & Opcodes.ACC_ENUM) != 0; - } - - public boolean isBridge() { - return (flags & Opcodes.ACC_BRIDGE) != 0; - } - - public AccessFlags setPrivate() { - this.setVisibility(Opcodes.ACC_PRIVATE); - return this; - } - - public AccessFlags setProtected() { - this.setVisibility(Opcodes.ACC_PROTECTED); - return this; - } - - public AccessFlags setPublic() { - this.setVisibility(Opcodes.ACC_PUBLIC); - return this; - } - - public AccessFlags setBridge() { - flags |= Opcodes.ACC_BRIDGE; - return this; - } - - @Deprecated - public AccessFlags setBridged() { - return setBridge(); - } - - public void setVisibility(int visibility) { - this.resetVisibility(); - this.flags |= visibility; - } - - private void resetVisibility() { - this.flags &= ~(Opcodes.ACC_PRIVATE | Opcodes.ACC_PROTECTED | Opcodes.ACC_PUBLIC); - } - - public int getFlags() { - return this.flags; - } - - @Override - public boolean equals(Object obj) { - return obj instanceof AccessFlags && ((AccessFlags) obj).flags == flags; - } - - @Override - public int hashCode() { - return flags; - } - - @Override - public String toString() { - StringBuilder builder = new StringBuilder(Access.get(this).toString().toLowerCase()); - if (isStatic()) { - builder.append(" static"); - } - if (isSynthetic()) { - builder.append(" synthetic"); - } - if (isBridge()) { - builder.append(" bridge"); - } - return builder.toString(); - } -} diff --git a/src/main/java/cuchaz/enigma/bytecode/translators/AsmObjectTranslator.java b/src/main/java/cuchaz/enigma/bytecode/translators/AsmObjectTranslator.java new file mode 100644 index 0000000..1a2b47f --- /dev/null +++ b/src/main/java/cuchaz/enigma/bytecode/translators/AsmObjectTranslator.java @@ -0,0 +1,46 @@ +package cuchaz.enigma.bytecode.translators; + +import cuchaz.enigma.translation.Translator; +import cuchaz.enigma.translation.representation.MethodDescriptor; +import cuchaz.enigma.translation.representation.TypeDescriptor; +import cuchaz.enigma.translation.representation.entry.ClassEntry; +import cuchaz.enigma.translation.representation.entry.MethodEntry; +import org.objectweb.asm.Handle; +import org.objectweb.asm.Type; + +public class AsmObjectTranslator { + public static Type translateType(Translator translator, Type type) { + String descString = type.getDescriptor(); + switch (type.getSort()) { + case Type.OBJECT: { + ClassEntry classEntry = new ClassEntry(type.getInternalName()); + return Type.getObjectType(translator.translate(classEntry).getFullName()); + } + case Type.ARRAY: { + TypeDescriptor descriptor = new TypeDescriptor(descString); + return Type.getType(translator.translate(descriptor).toString()); + } + case Type.METHOD: { + MethodDescriptor descriptor = new MethodDescriptor(descString); + return Type.getMethodType(translator.translate(descriptor).toString()); + } + } + return type; + } + + public static Handle translateHandle(Translator translator, Handle handle) { + MethodEntry entry = new MethodEntry(new ClassEntry(handle.getOwner()), handle.getName(), new MethodDescriptor(handle.getDesc())); + MethodEntry translatedMethod = translator.translate(entry); + ClassEntry ownerClass = translatedMethod.getParent(); + return new Handle(handle.getTag(), ownerClass.getFullName(), translatedMethod.getName(), translatedMethod.getDesc().toString(), handle.isInterface()); + } + + public static Object translateValue(Translator translator, Object value) { + if (value instanceof Type) { + return translateType(translator, (Type) value); + } else if (value instanceof Handle) { + return translateHandle(translator, (Handle) value); + } + return value; + } +} diff --git a/src/main/java/cuchaz/enigma/bytecode/translators/TranslationAnnotationVisitor.java b/src/main/java/cuchaz/enigma/bytecode/translators/TranslationAnnotationVisitor.java index 2e5b54d..cb843ad 100644 --- a/src/main/java/cuchaz/enigma/bytecode/translators/TranslationAnnotationVisitor.java +++ b/src/main/java/cuchaz/enigma/bytecode/translators/TranslationAnnotationVisitor.java @@ -1,9 +1,9 @@ package cuchaz.enigma.bytecode.translators; -import cuchaz.enigma.mapping.Translator; -import cuchaz.enigma.mapping.TypeDescriptor; -import cuchaz.enigma.mapping.entry.ClassEntry; -import cuchaz.enigma.mapping.entry.FieldEntry; +import cuchaz.enigma.translation.Translator; +import cuchaz.enigma.translation.representation.TypeDescriptor; +import cuchaz.enigma.translation.representation.entry.ClassEntry; +import cuchaz.enigma.translation.representation.entry.FieldEntry; import org.objectweb.asm.AnnotationVisitor; public class TranslationAnnotationVisitor extends AnnotationVisitor { @@ -18,7 +18,7 @@ public class TranslationAnnotationVisitor extends AnnotationVisitor { @Override public void visit(String name, Object value) { - super.visit(name, translator.getTranslatedValue(value)); + super.visit(name, AsmObjectTranslator.translateValue(translator, value)); } @Override @@ -30,22 +30,22 @@ public class TranslationAnnotationVisitor extends AnnotationVisitor { public AnnotationVisitor visitAnnotation(String name, String desc) { TypeDescriptor type = new TypeDescriptor(desc); if (name != null) { - FieldEntry annotationField = translator.getTranslatedField(new FieldEntry(annotationEntry, name, type)); + FieldEntry annotationField = translator.translate(new FieldEntry(annotationEntry, name, type)); return super.visitAnnotation(annotationField.getName(), annotationField.getDesc().toString()); } else { - return super.visitAnnotation(null, translator.getTranslatedTypeDesc(type).toString()); + return super.visitAnnotation(null, translator.translate(type).toString()); } } @Override public void visitEnum(String name, String desc, String value) { TypeDescriptor type = new TypeDescriptor(desc); - FieldEntry enumField = translator.getTranslatedField(new FieldEntry(type.getTypeEntry(), value, type)); + FieldEntry enumField = translator.translate(new FieldEntry(type.getTypeEntry(), value, type)); if (name != null) { - FieldEntry annotationField = translator.getTranslatedField(new FieldEntry(annotationEntry, name, type)); + FieldEntry annotationField = translator.translate(new FieldEntry(annotationEntry, name, type)); super.visitEnum(annotationField.getName(), annotationField.getDesc().toString(), enumField.getName()); } else { - super.visitEnum(null, translator.getTranslatedTypeDesc(type).toString(), enumField.getName()); + super.visitEnum(null, translator.translate(type).toString(), enumField.getName()); } } } diff --git a/src/main/java/cuchaz/enigma/bytecode/translators/TranslationClassVisitor.java b/src/main/java/cuchaz/enigma/bytecode/translators/TranslationClassVisitor.java index 5b16138..53d09bb 100644 --- a/src/main/java/cuchaz/enigma/bytecode/translators/TranslationClassVisitor.java +++ b/src/main/java/cuchaz/enigma/bytecode/translators/TranslationClassVisitor.java @@ -11,61 +11,53 @@ package cuchaz.enigma.bytecode.translators; -import cuchaz.enigma.analysis.JarIndex; -import cuchaz.enigma.bytecode.AccessFlags; -import cuchaz.enigma.mapping.MethodDescriptor; -import cuchaz.enigma.mapping.Signature; -import cuchaz.enigma.mapping.Translator; -import cuchaz.enigma.mapping.TypeDescriptor; -import cuchaz.enigma.mapping.entry.*; +import cuchaz.enigma.translation.Translator; +import cuchaz.enigma.translation.representation.MethodDescriptor; +import cuchaz.enigma.translation.representation.ReferencedEntryPool; +import cuchaz.enigma.translation.representation.TypeDescriptor; +import cuchaz.enigma.translation.representation.entry.*; import org.objectweb.asm.*; +import java.util.Arrays; + public class TranslationClassVisitor extends ClassVisitor { private final Translator translator; - private final JarIndex jarIndex; private final ReferencedEntryPool entryPool; private ClassDefEntry obfClassEntry; - private Signature obfSignature; - public TranslationClassVisitor(Translator translator, JarIndex jarIndex, ReferencedEntryPool entryPool, int api, ClassVisitor cv) { + public TranslationClassVisitor(Translator translator, ReferencedEntryPool entryPool, int api, ClassVisitor cv) { super(api, cv); this.translator = translator; - this.jarIndex = jarIndex; this.entryPool = entryPool; } @Override public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) { - obfSignature = Signature.createSignature(signature); - obfClassEntry = new ClassDefEntry(name, obfSignature, new AccessFlags(access)); - ClassDefEntry translatedEntry = translator.getTranslatedClassDef(obfClassEntry); - ClassEntry superEntry = translator.getTranslatedClass(entryPool.getClass(superName)); - String[] translatedInterfaces = new String[interfaces.length]; - for (int i = 0; i < interfaces.length; i++) { - translatedInterfaces[i] = translator.getTranslatedClass(entryPool.getClass(interfaces[i])).getName(); - } - super.visit(version, translatedEntry.getAccess().getFlags(), translatedEntry.getName(), translatedEntry.getSignature().toString(), superEntry.getName(), translatedInterfaces); + obfClassEntry = ClassDefEntry.parse(access, name, signature, superName, interfaces); + + ClassDefEntry translatedEntry = translator.translate(obfClassEntry); + String translatedSuper = translatedEntry.getSuperClass() != null ? translatedEntry.getSuperClass().getFullName() : null; + String[] translatedInterfaces = Arrays.stream(translatedEntry.getInterfaces()).map(ClassEntry::getFullName).toArray(String[]::new); + + super.visit(version, translatedEntry.getAccess().getFlags(), translatedEntry.getFullName(), translatedEntry.getSignature().toString(), translatedSuper, translatedInterfaces); } @Override public FieldVisitor visitField(int access, String name, String desc, String signature, Object value) { - FieldDefEntry entry = new FieldDefEntry(obfClassEntry, name, new TypeDescriptor(desc), Signature.createTypedSignature(signature), new AccessFlags(access)); - FieldDefEntry translatedEntry = translator.getTranslatedFieldDef(entry); + FieldDefEntry entry = FieldDefEntry.parse(obfClassEntry, access, name, desc, signature); + FieldDefEntry translatedEntry = translator.translate(entry); FieldVisitor fv = super.visitField(translatedEntry.getAccess().getFlags(), translatedEntry.getName(), translatedEntry.getDesc().toString(), translatedEntry.getSignature().toString(), value); return new TranslationFieldVisitor(translator, translatedEntry, api, fv); } @Override public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { - MethodDefEntry entry = new MethodDefEntry(obfClassEntry, name, new MethodDescriptor(desc), Signature.createSignature(signature), new AccessFlags(access)); - MethodDefEntry translatedEntry = translator.getTranslatedMethodDef(entry); - if (jarIndex.getBridgedMethod(entry) != null) { - translatedEntry.getAccess().setBridge(); - } + MethodDefEntry entry = MethodDefEntry.parse(obfClassEntry, access, name, desc, signature); + MethodDefEntry translatedEntry = translator.translate(entry); String[] translatedExceptions = new String[exceptions.length]; for (int i = 0; i < exceptions.length; i++) { - translatedExceptions[i] = translator.getTranslatedClass(entryPool.getClass(exceptions[i])).getName(); + translatedExceptions[i] = translator.translate(entryPool.getClass(exceptions[i])).getFullName(); } MethodVisitor mv = super.visitMethod(translatedEntry.getAccess().getFlags(), translatedEntry.getName(), translatedEntry.getDesc().toString(), translatedEntry.getSignature().toString(), translatedExceptions); return new TranslationMethodVisitor(translator, obfClassEntry, entry, api, mv); @@ -73,25 +65,25 @@ public class TranslationClassVisitor extends ClassVisitor { @Override public void visitInnerClass(String name, String outerName, String innerName, int access) { - ClassDefEntry translatedEntry = translator.getTranslatedClassDef(new ClassDefEntry(name, obfSignature, new AccessFlags(access))); - String translatedName = translatedEntry.getName(); - int separatorIndex = translatedName.lastIndexOf("$"); - String parentName = translatedName.substring(0, separatorIndex); - String childName = translatedName.substring(separatorIndex + 1); - - ClassEntry outerEntry = translator.getTranslatedClass(entryPool.getClass(parentName)); + ClassDefEntry classEntry = ClassDefEntry.parse(access, name, obfClassEntry.getSignature().toString(), null, new String[0]); + ClassDefEntry translatedEntry = translator.translate(classEntry); + ClassEntry translatedOuterClass = translatedEntry.getOuterClass(); + if (translatedOuterClass == null) { + throw new IllegalStateException("Translated inner class did not have outer class"); + } // Anonymous classes do not specify an outer or inner name. As we do not translate from the given parameter, ignore if the input is null - String translatedOuterName = outerName != null ? outerEntry.getName() : null; - String translatedInnerName = innerName != null ? childName : null; + String translatedName = translatedEntry.getFullName(); + String translatedOuterName = outerName != null ? translatedOuterClass.getFullName() : null; + String translatedInnerName = innerName != null ? translatedEntry.getName() : null; super.visitInnerClass(translatedName, translatedOuterName, translatedInnerName, translatedEntry.getAccess().getFlags()); } @Override public void visitOuterClass(String owner, String name, String desc) { if (desc != null) { - MethodEntry translatedEntry = translator.getTranslatedMethod(new MethodEntry(new ClassEntry(owner), name, new MethodDescriptor(desc))); - super.visitOuterClass(translatedEntry.getClassName(), translatedEntry.getName(), translatedEntry.getDesc().toString()); + MethodEntry translatedEntry = translator.translate(new MethodEntry(new ClassEntry(owner), name, new MethodDescriptor(desc))); + super.visitOuterClass(translatedEntry.getParent().getFullName(), translatedEntry.getName(), translatedEntry.getDesc().toString()); } else { super.visitOuterClass(owner, name, desc); } @@ -99,14 +91,14 @@ public class TranslationClassVisitor extends ClassVisitor { @Override public AnnotationVisitor visitAnnotation(String desc, boolean visible) { - TypeDescriptor translatedDesc = translator.getTranslatedTypeDesc(new TypeDescriptor(desc)); + TypeDescriptor translatedDesc = translator.translate(new TypeDescriptor(desc)); AnnotationVisitor av = super.visitAnnotation(translatedDesc.toString(), visible); return new TranslationAnnotationVisitor(translator, translatedDesc.getTypeEntry(), api, av); } @Override public AnnotationVisitor visitTypeAnnotation(int typeRef, TypePath typePath, String desc, boolean visible) { - TypeDescriptor translatedDesc = translator.getTranslatedTypeDesc(new TypeDescriptor(desc)); + TypeDescriptor translatedDesc = translator.translate(new TypeDescriptor(desc)); AnnotationVisitor av = super.visitTypeAnnotation(typeRef, typePath, translatedDesc.toString(), visible); return new TranslationAnnotationVisitor(translator, translatedDesc.getTypeEntry(), api, av); } diff --git a/src/main/java/cuchaz/enigma/bytecode/translators/TranslationFieldVisitor.java b/src/main/java/cuchaz/enigma/bytecode/translators/TranslationFieldVisitor.java index e4695fb..28fc199 100644 --- a/src/main/java/cuchaz/enigma/bytecode/translators/TranslationFieldVisitor.java +++ b/src/main/java/cuchaz/enigma/bytecode/translators/TranslationFieldVisitor.java @@ -1,8 +1,8 @@ package cuchaz.enigma.bytecode.translators; -import cuchaz.enigma.mapping.Translator; -import cuchaz.enigma.mapping.TypeDescriptor; -import cuchaz.enigma.mapping.entry.FieldDefEntry; +import cuchaz.enigma.translation.Translator; +import cuchaz.enigma.translation.representation.TypeDescriptor; +import cuchaz.enigma.translation.representation.entry.FieldDefEntry; import org.objectweb.asm.AnnotationVisitor; import org.objectweb.asm.FieldVisitor; import org.objectweb.asm.TypePath; @@ -19,14 +19,14 @@ public class TranslationFieldVisitor extends FieldVisitor { @Override public AnnotationVisitor visitAnnotation(String desc, boolean visible) { - TypeDescriptor typeDesc = translator.getTranslatedTypeDesc(new TypeDescriptor(desc)); + TypeDescriptor typeDesc = translator.translate(new TypeDescriptor(desc)); AnnotationVisitor av = super.visitAnnotation(typeDesc.toString(), visible); return new TranslationAnnotationVisitor(translator, typeDesc.getTypeEntry(), api, av); } @Override public AnnotationVisitor visitTypeAnnotation(int typeRef, TypePath typePath, String desc, boolean visible) { - TypeDescriptor typeDesc = translator.getTranslatedTypeDesc(new TypeDescriptor(desc)); + TypeDescriptor typeDesc = translator.translate(new TypeDescriptor(desc)); AnnotationVisitor av = super.visitAnnotation(typeDesc.toString(), visible); return new TranslationAnnotationVisitor(translator, typeDesc.getTypeEntry(), api, av); } diff --git a/src/main/java/cuchaz/enigma/bytecode/translators/TranslationMethodVisitor.java b/src/main/java/cuchaz/enigma/bytecode/translators/TranslationMethodVisitor.java index 6d0d550..a5a33e6 100644 --- a/src/main/java/cuchaz/enigma/bytecode/translators/TranslationMethodVisitor.java +++ b/src/main/java/cuchaz/enigma/bytecode/translators/TranslationMethodVisitor.java @@ -1,7 +1,11 @@ package cuchaz.enigma.bytecode.translators; -import cuchaz.enigma.mapping.*; -import cuchaz.enigma.mapping.entry.*; +import cuchaz.enigma.translation.Translator; +import cuchaz.enigma.translation.mapping.NameValidator; +import cuchaz.enigma.translation.representation.MethodDescriptor; +import cuchaz.enigma.translation.representation.Signature; +import cuchaz.enigma.translation.representation.TypeDescriptor; +import cuchaz.enigma.translation.representation.entry.*; import org.objectweb.asm.*; import java.util.Collection; @@ -26,15 +30,15 @@ public class TranslationMethodVisitor extends MethodVisitor { @Override public void visitFieldInsn(int opcode, String owner, String name, String desc) { FieldEntry entry = new FieldEntry(new ClassEntry(owner), name, new TypeDescriptor(desc)); - FieldEntry translatedEntry = translator.getTranslatedField(entry); - super.visitFieldInsn(opcode, translatedEntry.getClassName(), translatedEntry.getName(), translatedEntry.getDesc().toString()); + FieldEntry translatedEntry = translator.translate(entry); + super.visitFieldInsn(opcode, translatedEntry.getParent().getFullName(), translatedEntry.getName(), translatedEntry.getDesc().toString()); } @Override public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) { MethodEntry entry = new MethodEntry(new ClassEntry(owner), name, new MethodDescriptor(desc)); - MethodEntry translatedEntry = translator.getTranslatedMethod(entry); - super.visitMethodInsn(opcode, translatedEntry.getClassName(), translatedEntry.getName(), translatedEntry.getDesc().toString(), itf); + MethodEntry translatedEntry = translator.translate(entry); + super.visitMethodInsn(opcode, translatedEntry.getParent().getFullName(), translatedEntry.getName(), translatedEntry.getDesc().toString(), itf); } @Override @@ -52,7 +56,7 @@ public class TranslationMethodVisitor extends MethodVisitor { Object object = array[i]; if (object instanceof String) { String type = (String) object; - array[i] = translator.getTranslatedClass(new ClassEntry(type)).getName(); + array[i] = translator.translate(new ClassEntry(type)).getFullName(); } } return array; @@ -60,21 +64,21 @@ public class TranslationMethodVisitor extends MethodVisitor { @Override public AnnotationVisitor visitAnnotation(String desc, boolean visible) { - TypeDescriptor typeDesc = translator.getTranslatedTypeDesc(new TypeDescriptor(desc)); + TypeDescriptor typeDesc = translator.translate(new TypeDescriptor(desc)); AnnotationVisitor av = super.visitAnnotation(typeDesc.toString(), visible); return new TranslationAnnotationVisitor(translator, typeDesc.getTypeEntry(), api, av); } @Override public AnnotationVisitor visitParameterAnnotation(int parameter, String desc, boolean visible) { - TypeDescriptor typeDesc = translator.getTranslatedTypeDesc(new TypeDescriptor(desc)); + TypeDescriptor typeDesc = translator.translate(new TypeDescriptor(desc)); AnnotationVisitor av = super.visitParameterAnnotation(parameter, typeDesc.toString(), visible); return new TranslationAnnotationVisitor(translator, typeDesc.getTypeEntry(), api, av); } @Override public AnnotationVisitor visitTypeAnnotation(int typeRef, TypePath typePath, String desc, boolean visible) { - TypeDescriptor typeDesc = translator.getTranslatedTypeDesc(new TypeDescriptor(desc)); + TypeDescriptor typeDesc = translator.translate(new TypeDescriptor(desc)); AnnotationVisitor av = super.visitTypeAnnotation(typeRef, typePath, typeDesc.toString(), visible); return new TranslationAnnotationVisitor(translator, typeDesc.getTypeEntry(), api, av); } @@ -83,19 +87,18 @@ public class TranslationMethodVisitor extends MethodVisitor { public void visitLocalVariable(String name, String desc, String signature, Label start, Label end, int index) { hasParameterMeta = true; - String translatedSignature = translator.getTranslatedSignature(Signature.createTypedSignature(signature)).toString(); + String translatedSignature = translator.translate(Signature.createTypedSignature(signature)).toString(); int argumentIndex = methodEntry.getArgumentIndex(ownerEntry, index); if (argumentIndex >= 0) { - LocalVariableDefEntry entry = new LocalVariableDefEntry(methodEntry, index, name, new TypeDescriptor(desc)); - LocalVariableDefEntry translatedEntry = translator.getTranslatedVariableDef(entry); + LocalVariableDefEntry entry = new LocalVariableDefEntry(methodEntry, index, name, true, new TypeDescriptor(desc)); + LocalVariableDefEntry translatedEntry = translator.translate(entry); String translatedName = translatedEntry.getName(); - // TODO: Better name inference if (translatedName.equals(entry.getName())) { List arguments = methodEntry.getDesc().getArgumentDescs(); List translatedArguments = arguments.stream() - .map(translator::getTranslatedTypeDesc) + .map(translator::translate) .collect(Collectors.toList()); boolean argument = argumentIndex < arguments.size(); @@ -109,42 +112,42 @@ public class TranslationMethodVisitor extends MethodVisitor { super.visitLocalVariable(translatedName, translatedEntry.getDesc().toString(), translatedSignature, start, end, index); } else { // Handle "this" variable - TypeDescriptor translatedDesc = translator.getTranslatedTypeDesc(new TypeDescriptor(desc)); + TypeDescriptor translatedDesc = translator.translate(new TypeDescriptor(desc)); super.visitLocalVariable(name, translatedDesc.toString(), translatedSignature, start, end, index); } } @Override public void visitTypeInsn(int opcode, String type) { - ClassEntry translatedEntry = translator.getTranslatedClass(new ClassEntry(type)); - super.visitTypeInsn(opcode, translatedEntry.getName()); + ClassEntry translatedEntry = translator.translate(new ClassEntry(type)); + super.visitTypeInsn(opcode, translatedEntry.getFullName()); } @Override public void visitInvokeDynamicInsn(String name, String desc, Handle bsm, Object... bsmArgs) { - MethodDescriptor translatedMethodDesc = translator.getTranslatedMethodDesc(new MethodDescriptor(desc)); + MethodDescriptor translatedMethodDesc = translator.translate(new MethodDescriptor(desc)); Object[] translatedBsmArgs = new Object[bsmArgs.length]; for (int i = 0; i < bsmArgs.length; i++) { - translatedBsmArgs[i] = translator.getTranslatedValue(bsmArgs[i]); + translatedBsmArgs[i] = AsmObjectTranslator.translateValue(translator, bsmArgs[i]); } - super.visitInvokeDynamicInsn(name, translatedMethodDesc.toString(), translator.getTranslatedHandle(bsm), translatedBsmArgs); + super.visitInvokeDynamicInsn(name, translatedMethodDesc.toString(), AsmObjectTranslator.translateHandle(translator, bsm), translatedBsmArgs); } @Override public void visitLdcInsn(Object cst) { - super.visitLdcInsn(translator.getTranslatedValue(cst)); + super.visitLdcInsn(AsmObjectTranslator.translateValue(translator, cst)); } @Override public void visitMultiANewArrayInsn(String desc, int dims) { - super.visitMultiANewArrayInsn(translator.getTranslatedTypeDesc(new TypeDescriptor(desc)).toString(), dims); + super.visitMultiANewArrayInsn(translator.translate(new TypeDescriptor(desc)).toString(), dims); } @Override public void visitTryCatchBlock(Label start, Label end, Label handler, String type) { if (type != null) { - ClassEntry translatedEntry = translator.getTranslatedClass(new ClassEntry(type)); - super.visitTryCatchBlock(start, end, handler, translatedEntry.getName()); + ClassEntry translatedEntry = translator.translate(new ClassEntry(type)); + super.visitTryCatchBlock(start, end, handler, translatedEntry.getFullName()); } else { super.visitTryCatchBlock(start, end, handler, type); } @@ -159,7 +162,7 @@ public class TranslationMethodVisitor extends MethodVisitor { for (int argumentIndex = 0; argumentIndex < arguments.size(); argumentIndex++) { LocalVariableEntry entry = new LocalVariableEntry(methodEntry, offset, "", true); - LocalVariableEntry translatedEntry = translator.getTranslatedVariable(entry); + LocalVariableEntry translatedEntry = translator.translate(entry); String translatedName = translatedEntry.getName(); if (translatedName.equals(entry.getName())) { super.visitParameter(inferArgumentName(argumentIndex, arguments.get(argumentIndex), arguments), 0); -- cgit v1.2.3