From 923e2300e65e8f958a694d4e83041f116b7c4775 Mon Sep 17 00:00:00 2001 From: modmuss50 Date: Fri, 19 Mar 2021 18:39:05 +0000 Subject: WIP full record support --- .../translators/TranslationClassVisitor.java | 9 ++++ .../TranslationRecordComponentVisitor.java | 30 ++++++++++++ .../cuchaz/enigma/source/cfr/EnigmaDumper.java | 57 ++++++++++++++++++++-- .../enigma/translation/mapping/EntryRemapper.java | 45 +++++++++++++++++ .../translation/representation/AccessFlags.java | 4 ++ .../cuchaz/enigma/utils/validation/Message.java | 1 + 6 files changed, 142 insertions(+), 4 deletions(-) create mode 100644 enigma/src/main/java/cuchaz/enigma/bytecode/translators/TranslationRecordComponentVisitor.java (limited to 'enigma/src/main/java') diff --git a/enigma/src/main/java/cuchaz/enigma/bytecode/translators/TranslationClassVisitor.java b/enigma/src/main/java/cuchaz/enigma/bytecode/translators/TranslationClassVisitor.java index e4c41d3..0b2ca9a 100644 --- a/enigma/src/main/java/cuchaz/enigma/bytecode/translators/TranslationClassVisitor.java +++ b/enigma/src/main/java/cuchaz/enigma/bytecode/translators/TranslationClassVisitor.java @@ -99,4 +99,13 @@ public class TranslationClassVisitor extends ClassVisitor { AnnotationVisitor av = super.visitTypeAnnotation(typeRef, typePath, translatedDesc.toString(), visible); return new TranslationAnnotationVisitor(translator, translatedDesc.getTypeEntry(), api, av); } + + @Override + public RecordComponentVisitor visitRecordComponent(String name, String desc, String signature) { + // Record component names are remapped via the field mapping. + FieldDefEntry entry = FieldDefEntry.parse(obfClassEntry, 0, name, desc, signature); + FieldDefEntry translatedEntry = translator.translate(entry); + RecordComponentVisitor fv = super.visitRecordComponent(translatedEntry.getName(), translatedEntry.getDesc().toString(), translatedEntry.getSignature().toString()); + return new TranslationRecordComponentVisitor(translator, api, fv); + } } diff --git a/enigma/src/main/java/cuchaz/enigma/bytecode/translators/TranslationRecordComponentVisitor.java b/enigma/src/main/java/cuchaz/enigma/bytecode/translators/TranslationRecordComponentVisitor.java new file mode 100644 index 0000000..06fd22b --- /dev/null +++ b/enigma/src/main/java/cuchaz/enigma/bytecode/translators/TranslationRecordComponentVisitor.java @@ -0,0 +1,30 @@ +package cuchaz.enigma.bytecode.translators; + +import cuchaz.enigma.translation.Translator; +import cuchaz.enigma.translation.representation.TypeDescriptor; +import org.objectweb.asm.AnnotationVisitor; +import org.objectweb.asm.RecordComponentVisitor; +import org.objectweb.asm.TypePath; + +public class TranslationRecordComponentVisitor extends RecordComponentVisitor { + private final Translator translator; + + public TranslationRecordComponentVisitor(Translator translator, int api, RecordComponentVisitor rcv) { + super(api, rcv); + this.translator = translator; + } + + @Override + public AnnotationVisitor visitAnnotation(String desc, boolean visible) { + 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.translate(new TypeDescriptor(desc)); + AnnotationVisitor av = super.visitAnnotation(typeDesc.toString(), visible); + return new TranslationAnnotationVisitor(translator, typeDesc.getTypeEntry(), api, av); + } +} diff --git a/enigma/src/main/java/cuchaz/enigma/source/cfr/EnigmaDumper.java b/enigma/src/main/java/cuchaz/enigma/source/cfr/EnigmaDumper.java index 2c6ec15..d0734c5 100644 --- a/enigma/src/main/java/cuchaz/enigma/source/cfr/EnigmaDumper.java +++ b/enigma/src/main/java/cuchaz/enigma/source/cfr/EnigmaDumper.java @@ -19,6 +19,9 @@ import org.benf.cfr.reader.bytecode.analysis.types.JavaTypeInstance; import org.benf.cfr.reader.bytecode.analysis.types.MethodPrototype; import org.benf.cfr.reader.bytecode.analysis.types.RawJavaType; import org.benf.cfr.reader.bytecode.analysis.variables.NamedVariable; +import org.benf.cfr.reader.entities.AccessFlag; +import org.benf.cfr.reader.entities.ClassFile; +import org.benf.cfr.reader.entities.ClassFileField; import org.benf.cfr.reader.entities.Field; import org.benf.cfr.reader.state.TypeUsageInformation; import org.benf.cfr.reader.util.getopt.Options; @@ -33,6 +36,7 @@ import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.HashMap; +import java.util.LinkedList; import java.util.List; import java.util.Map; @@ -129,16 +133,51 @@ public class EnigmaDumper extends StringStreamDumper { @Override public Dumper dumpClassDoc(JavaTypeInstance owner) { if (mapper != null) { + List recordComponentDocs = new LinkedList<>(); + + if (isRecord(owner)) { + ClassFile classFile = ((JavaRefTypeInstance) owner).getClassFile(); + for (ClassFileField field : classFile.getFields()) { + if (field.getField().testAccessFlag(AccessFlag.ACC_STATIC)) { + continue; + } + + EntryMapping mapping = mapper.getDeobfMapping(getFieldEntry(owner, field.getFieldName(), field.getField().getDescriptor())); + if (mapping == null) { + continue; + } + + String javaDoc = mapping.getJavadoc(); + if (javaDoc != null) { + recordComponentDocs.add(String.format("@param %s %s", field.getFieldName(), javaDoc)); + } + } + } + EntryMapping mapping = mapper.getDeobfMapping(getClassEntry(owner)); + + String javadoc = null; if (mapping != null) { - String javadoc = mapping.getJavadoc(); + javadoc = mapping.getJavadoc(); + } + + if (javadoc != null || !recordComponentDocs.isEmpty()) { + print("/**").newln(); if (javadoc != null) { - print("/**").newln(); for (String line : javadoc.split("\\R")) { print(" * ").print(line).newln(); } - print(" */").newln(); + + if (!recordComponentDocs.isEmpty()) { + print(" * ").newln(); + } } + + for (String componentDoc : recordComponentDocs) { + print(" * ").print(componentDoc).newln(); + } + + print(" */").newln(); } } return this; @@ -186,7 +225,8 @@ public class EnigmaDumper extends StringStreamDumper { @Override public Dumper dumpFieldDoc(Field field, JavaTypeInstance owner) { - if (mapper != null) { + boolean recordComponent = isRecord(owner) && !field.testAccessFlag(AccessFlag.ACC_STATIC); + if (mapper != null && !recordComponent) { EntryMapping mapping = mapper.getDeobfMapping(getFieldEntry(owner, field.getFieldName(), field.getDescriptor())); if (mapping != null) { String javadoc = mapping.getJavadoc(); @@ -336,4 +376,13 @@ public class EnigmaDumper extends StringStreamDumper { return sb.toString(); } + private boolean isRecord(JavaTypeInstance javaTypeInstance) { + if (javaTypeInstance instanceof JavaRefTypeInstance) { + ClassFile classFile = ((JavaRefTypeInstance) javaTypeInstance).getClassFile(); + return classFile.getClassSignature().getSuperClass().getRawName().equals("java.lang.Record"); + } + + return false; + } + } diff --git a/enigma/src/main/java/cuchaz/enigma/translation/mapping/EntryRemapper.java b/enigma/src/main/java/cuchaz/enigma/translation/mapping/EntryRemapper.java index a183d2b..ef904d7 100644 --- a/enigma/src/main/java/cuchaz/enigma/translation/mapping/EntryRemapper.java +++ b/enigma/src/main/java/cuchaz/enigma/translation/mapping/EntryRemapper.java @@ -1,6 +1,8 @@ package cuchaz.enigma.translation.mapping; import java.util.Collection; +import java.util.List; +import java.util.stream.Collectors; import java.util.stream.Stream; import javax.annotation.Nullable; @@ -13,7 +15,12 @@ import cuchaz.enigma.translation.Translator; import cuchaz.enigma.translation.mapping.tree.DeltaTrackingTree; import cuchaz.enigma.translation.mapping.tree.EntryTree; import cuchaz.enigma.translation.mapping.tree.HashEntryTree; +import cuchaz.enigma.translation.representation.entry.ClassEntry; import cuchaz.enigma.translation.representation.entry.Entry; +import cuchaz.enigma.translation.representation.entry.FieldEntry; + +import cuchaz.enigma.translation.representation.entry.MethodEntry; +import cuchaz.enigma.utils.validation.Message; import cuchaz.enigma.utils.validation.ValidationContext; public class EntryRemapper { @@ -21,6 +28,7 @@ public class EntryRemapper { private final EntryResolver obfResolver; private final Translator deobfuscator; + private final JarIndex jarIndex; private final MappingValidator validator; @@ -30,6 +38,7 @@ public class EntryRemapper { this.obfResolver = jarIndex.getEntryResolver(); this.deobfuscator = new MappingTranslator(obfToDeobf, obfResolver); + this.jarIndex = jarIndex; this.validator = new MappingValidator(obfToDeobf, deobfuscator, jarIndex); } @@ -51,6 +60,13 @@ public class EntryRemapper { } public > void mapFromObf(ValidationContext vc, E obfuscatedEntry, @Nullable EntryMapping deobfMapping, boolean renaming, boolean validateOnly) { + if (obfuscatedEntry instanceof FieldEntry) { + FieldEntry fieldEntry = (FieldEntry) obfuscatedEntry; + ClassEntry classEntry = fieldEntry.getParent(); + + mapRecordComponentGetter(vc, classEntry, fieldEntry, deobfMapping); + } + Collection resolvedEntries = obfResolver.resolveEntry(obfuscatedEntry, renaming ? ResolutionStrategy.RESOLVE_ROOT : ResolutionStrategy.RESOLVE_CLOSEST); if (renaming && deobfMapping != null) { @@ -70,6 +86,35 @@ public class EntryRemapper { mapFromObf(vc, obfuscatedEntry, null); } + // A little bit of a hack to also map the getter method for record fields/components. + private void mapRecordComponentGetter(ValidationContext vc, ClassEntry classEntry, FieldEntry fieldEntry, EntryMapping fieldMapping) { + if (!jarIndex.getEntryIndex().getClassAccess(classEntry).isRecord() || jarIndex.getEntryIndex().getFieldAccess(fieldEntry).isStatic()) { + return; + } + + // Find all the methods in this record class + List classMethods = jarIndex.getEntryIndex().getMethods().stream() + .filter(entry -> classEntry.equals(entry.getParent())) + .collect(Collectors.toList()); + + MethodEntry methodEntry = null; + + for (MethodEntry method : classMethods) { + // Find the matching record component getter via matching the names. My understanding is this is safe, failing this it may need to be a bit more intelligent + if (method.getName().equals(fieldEntry.getName()) && method.getDesc().toString().equals("()" + fieldEntry.getDesc())) { + methodEntry = method; + break; + } + } + + if (methodEntry == null && fieldMapping != null) { + vc.raise(Message.UNKNOWN_RECORD_GETTER, fieldMapping.getTargetName()); + return; + } + + mapFromObf(vc, methodEntry, fieldMapping != null ? new EntryMapping(fieldMapping.getTargetName()) : null); + } + @Nullable public EntryMapping getDeobfMapping(Entry entry) { return obfToDeobf.get(entry); diff --git a/enigma/src/main/java/cuchaz/enigma/translation/representation/AccessFlags.java b/enigma/src/main/java/cuchaz/enigma/translation/representation/AccessFlags.java index e8480a2..21e6ef4 100644 --- a/enigma/src/main/java/cuchaz/enigma/translation/representation/AccessFlags.java +++ b/enigma/src/main/java/cuchaz/enigma/translation/representation/AccessFlags.java @@ -39,6 +39,10 @@ public class AccessFlags { return (flags & Opcodes.ACC_ENUM) != 0; } + public boolean isRecord() { + return (flags & Opcodes.ACC_RECORD) != 0; + } + public boolean isBridge() { return (flags & Opcodes.ACC_BRIDGE) != 0; } diff --git a/enigma/src/main/java/cuchaz/enigma/utils/validation/Message.java b/enigma/src/main/java/cuchaz/enigma/utils/validation/Message.java index 113199a..6bcdbde 100644 --- a/enigma/src/main/java/cuchaz/enigma/utils/validation/Message.java +++ b/enigma/src/main/java/cuchaz/enigma/utils/validation/Message.java @@ -15,6 +15,7 @@ public class Message { public static final Message ILLEGAL_IDENTIFIER = create(Type.ERROR, "illegal_identifier"); public static final Message RESERVED_IDENTIFIER = create(Type.ERROR, "reserved_identifier"); public static final Message ILLEGAL_DOC_COMMENT_END = create(Type.ERROR, "illegal_doc_comment_end"); + public static final Message UNKNOWN_RECORD_GETTER = create(Type.ERROR, "unknown_record_getter"); public static final Message STYLE_VIOLATION = create(Type.WARNING, "style_violation"); -- cgit v1.2.3