From d3ebad7260bb273ddbba3286f91510c01d835268 Mon Sep 17 00:00:00 2001 From: zaaarf Date: Fri, 26 May 2023 17:13:48 +0200 Subject: [PATCH] chore: added container class for options --- .../ftbsc/lll/processor/LilleroProcessor.java | 113 +++--------------- .../ftbsc/lll/processor/tools/ASTUtils.java | 6 +- .../lll/processor/tools/JavaPoetUtils.java | 10 +- .../lll/processor/tools/ProcessorOptions.java | 90 ++++++++++++++ .../tools/containers/ClassContainer.java | 53 ++++---- .../tools/containers/FieldContainer.java | 37 +++--- .../tools/containers/InjectorInfo.java | 10 +- .../tools/containers/MethodContainer.java | 36 +++--- 8 files changed, 170 insertions(+), 185 deletions(-) create mode 100644 src/main/java/ftbsc/lll/processor/tools/ProcessorOptions.java diff --git a/src/main/java/ftbsc/lll/processor/LilleroProcessor.java b/src/main/java/ftbsc/lll/processor/LilleroProcessor.java index 111d068..1b710b0 100644 --- a/src/main/java/ftbsc/lll/processor/LilleroProcessor.java +++ b/src/main/java/ftbsc/lll/processor/LilleroProcessor.java @@ -1,15 +1,17 @@ package ftbsc.lll.processor; -import com.squareup.javapoet.*; +import com.squareup.javapoet.ClassName; +import com.squareup.javapoet.JavaFile; +import com.squareup.javapoet.MethodSpec; +import com.squareup.javapoet.TypeSpec; import ftbsc.lll.IInjector; import ftbsc.lll.exceptions.AmbiguousDefinitionException; -import ftbsc.lll.exceptions.InvalidResourceException; import ftbsc.lll.exceptions.OrphanElementException; import ftbsc.lll.processor.annotations.*; +import ftbsc.lll.processor.tools.ProcessorOptions; import ftbsc.lll.processor.tools.containers.ClassContainer; import ftbsc.lll.processor.tools.containers.InjectorInfo; import ftbsc.lll.processor.tools.containers.MethodContainer; -import ftbsc.lll.processor.tools.obfuscation.ObfuscationMapper; import ftbsc.lll.proxies.ProxyType; import ftbsc.lll.proxies.impl.TypeProxy; @@ -22,10 +24,8 @@ import javax.tools.Diagnostic; import javax.tools.FileObject; import javax.tools.JavaFileObject; import javax.tools.StandardLocation; -import java.io.*; -import java.net.URI; -import java.net.URISyntaxException; -import java.nio.charset.StandardCharsets; +import java.io.IOException; +import java.io.PrintWriter; import java.util.*; import java.util.stream.Collectors; @@ -47,79 +47,9 @@ public class LilleroProcessor extends AbstractProcessor { private final Set injectors = new HashSet<>(); /** - * The {@link ObfuscationMapper} used to convert classes and variables - * to their obfuscated equivalent. Will be null when no mapper is in use. + * An object representing the various options passed to the processor. */ - private ObfuscationMapper mapper = null; - - /** - * Whether the processor should issue warnings when compiling code anonymous - * classes which can't be checked for validity. - */ - public static boolean anonymousClassWarning = true; - - /** - * Whether injector metadata (what is returned by the functions of {@link IInjector}) - * is to use obfuscated names instead of its normal names. - */ - public static boolean obfuscateInjectorMetadata = true; - - /** - * Initializes the processor with the processing environment by setting the - * {@code processingEnv} field to the value of the {@code processingEnv} argument. - * @param processingEnv environment to access facilities the tool framework - * provides to the processor - * @throws IllegalStateException if this method is called more than once. - * @since 0.3.0 - */ - @Override - public synchronized void init(ProcessingEnvironment processingEnv) { - super.init(processingEnv); - String location = processingEnv.getOptions().get("mappingsFile"); - if(location == null) - mapper = null; - else { - InputStream targetStream; - try { - URI target = new URI(location); - targetStream = target.toURL().openStream(); - } catch(URISyntaxException | IOException e) { - //may be a local file path - File f = new File(location); - if(!f.exists()) - throw new InvalidResourceException(location); - try { - targetStream = new FileInputStream(f); - } catch(FileNotFoundException ex) { - throw new InvalidResourceException(location); - } - } - //assuming its tsrg file - //todo: replace crappy homebaked parser with actual library - this.mapper = new ObfuscationMapper(new BufferedReader(new InputStreamReader(targetStream, - StandardCharsets.UTF_8)).lines()); - } - String anonymousClassWarn = processingEnv.getOptions().get("anonymousClassWarning"); - if(anonymousClassWarn != null) - anonymousClassWarning = parseBooleanArg(anonymousClassWarn); - String obfuscateInj = processingEnv.getOptions().get("obfuscateInjectorMetadata"); - if(obfuscateInj != null) - obfuscateInjectorMetadata = parseBooleanArg(obfuscateInj); - } - - /** - * Parses a boolean arg from a String. - * @param arg the arg to parse - * @return the parsed boolean - */ - private static boolean parseBooleanArg(String arg) { - try { // 0 = false, any other integer = true - int i = Integer.parseInt(arg); - return i != 0; - } catch(NumberFormatException ignored) { - return Boolean.parseBoolean(arg); - } - } + public final ProcessorOptions options = new ProcessorOptions(processingEnv); /** * Where the actual processing happens. @@ -196,11 +126,7 @@ public class LilleroProcessor extends AbstractProcessor { //find class information Patch patchAnn = cl.getAnnotation(Patch.class); ClassContainer targetClass = ClassContainer.from( - patchAnn, - Patch::value, - patchAnn.innerName(), - this.processingEnv, - this.mapper + patchAnn, Patch::value, patchAnn.innerName(), this.options ); //find package information Element packageElement = cl.getEnclosingElement(); @@ -231,11 +157,10 @@ public class LilleroProcessor extends AbstractProcessor { if(type == ProxyType.TYPE) { //find and validate ClassContainer clazz = ClassContainer.findOrFallback( - ClassContainer.from(cl, this.processingEnv, this.mapper), + ClassContainer.from(cl, this.options), patchAnn, proxyVar.getAnnotation(Find.class), - this.processingEnv, - this.mapper + this.options ); //types can be generated with a single instruction constructorBuilder.addStatement( @@ -251,8 +176,7 @@ public class LilleroProcessor extends AbstractProcessor { null, null, constructorBuilder, - this.processingEnv, - this.mapper + this.options ); } @@ -311,7 +235,7 @@ public class LilleroProcessor extends AbstractProcessor { matchedInjectors.add(injector); toGenerate.put( String.format("%sInjector%d", cl.getSimpleName(), iterationNumber), - new InjectorInfo(injector, tg, targetAnn, this.processingEnv, this.mapper) + new InjectorInfo(injector, tg, targetAnn, this.options) ); iterationNumber++; //increment is only used by injectors } else { @@ -323,8 +247,7 @@ public class LilleroProcessor extends AbstractProcessor { tg, targetAnn, constructorBuilder, - this.processingEnv, - this.mapper + this.options ); } } @@ -349,9 +272,9 @@ public class LilleroProcessor extends AbstractProcessor { .addMethod(constructorBuilder.build()) .addMethod(buildStringReturnMethod("name", injName)) .addMethod(buildStringReturnMethod("reason", toGenerate.get(injName).reason)) - .addMethod(buildStringReturnMethod("targetClass", obfuscateInjectorMetadata ? targetClass.fqnObf : targetClass.fqn)) - .addMethod(buildStringReturnMethod("methodName", obfuscateInjectorMetadata ? target.nameObf : target.name)) - .addMethod(buildStringReturnMethod("methodDesc", obfuscateInjectorMetadata ? target.descriptorObf : target.descriptor)) + .addMethod(buildStringReturnMethod("targetClass", this.options.obfuscateInjectorMetadata ? targetClass.fqnObf : targetClass.fqn)) + .addMethod(buildStringReturnMethod("methodName", this.options.obfuscateInjectorMetadata ? target.nameObf : target.name)) + .addMethod(buildStringReturnMethod("methodDesc", this.options.obfuscateInjectorMetadata ? target.descriptorObf : target.descriptor)) .addMethods(generateDummies(cl)) .addMethod(generateInjector(toGenerate.get(injName), this.processingEnv)) .build(); diff --git a/src/main/java/ftbsc/lll/processor/tools/ASTUtils.java b/src/main/java/ftbsc/lll/processor/tools/ASTUtils.java index 6bd5864..0037886 100644 --- a/src/main/java/ftbsc/lll/processor/tools/ASTUtils.java +++ b/src/main/java/ftbsc/lll/processor/tools/ASTUtils.java @@ -212,13 +212,13 @@ public class ASTUtils { /** * Finds the class name and maps it to the correct format. * @param name the fully qualified name of the class to convert - * @param mapper the {@link ObfuscationMapper} to use, may be null + * @param options the {@link ProcessorOptions} to be used * @return the fully qualified class name * @since 0.3.0 */ - public static String findClassName(String name, ObfuscationMapper mapper) { + public static String findClassName(String name, ProcessorOptions options) { try { - return mapper == null ? name : mapper.obfuscateClass(name).replace('/', '.'); + return options.mapper == null ? name : options.mapper.obfuscateClass(name).replace('/', '.'); } catch(MappingNotFoundException e) { return name; } diff --git a/src/main/java/ftbsc/lll/processor/tools/JavaPoetUtils.java b/src/main/java/ftbsc/lll/processor/tools/JavaPoetUtils.java index 875ea67..77bbc2b 100644 --- a/src/main/java/ftbsc/lll/processor/tools/JavaPoetUtils.java +++ b/src/main/java/ftbsc/lll/processor/tools/JavaPoetUtils.java @@ -7,7 +7,6 @@ import ftbsc.lll.processor.tools.containers.ClassContainer; import ftbsc.lll.processor.tools.containers.FieldContainer; import ftbsc.lll.processor.tools.containers.InjectorInfo; import ftbsc.lll.processor.tools.containers.MethodContainer; -import ftbsc.lll.processor.tools.obfuscation.ObfuscationMapper; import ftbsc.lll.proxies.ProxyType; import ftbsc.lll.proxies.impl.FieldProxy; import ftbsc.lll.proxies.impl.MethodProxy; @@ -44,13 +43,12 @@ public class JavaPoetUtils { * @param stub the stub {@link ExecutableElement} if present or relevant, null otherwise * @param t the {@link Target} relevant to this finder if present or relevant, null otherwise * @param con the {@link MethodSpec.Builder} to append to - * @param env the {@link ProcessingEnvironment} to perform the operation in - * @param mapper the {@link ObfuscationMapper} to use, may be null + * @param options the {@link ProcessorOptions} to be used * @since 0.5.0 */ public static void appendMemberFinderDefinition( VariableElement var, ExecutableElement stub, Target t, - MethodSpec.Builder con, ProcessingEnvironment env, ObfuscationMapper mapper) { + MethodSpec.Builder con, ProcessorOptions options) { ProxyType type = getProxyType(var); if(type != ProxyType.METHOD && type != ProxyType.FIELD) return; //this method is irrelevant to everyone else @@ -65,13 +63,13 @@ public class JavaPoetUtils { Element target; if(isMethod) { - MethodContainer mc = MethodContainer.from(stub, t, f, env, mapper); + MethodContainer mc = MethodContainer.from(stub, t, f, options); descriptorObf = mc.descriptorObf; nameObf = mc.nameObf; parent = mc.parent; target = mc.elem; } else { - FieldContainer fc = FieldContainer.from(var, env, mapper); + FieldContainer fc = FieldContainer.from(var, options); descriptorObf = fc.descriptorObf; nameObf = fc.nameObf; parent = fc.parent; diff --git a/src/main/java/ftbsc/lll/processor/tools/ProcessorOptions.java b/src/main/java/ftbsc/lll/processor/tools/ProcessorOptions.java new file mode 100644 index 0000000..9bbdd10 --- /dev/null +++ b/src/main/java/ftbsc/lll/processor/tools/ProcessorOptions.java @@ -0,0 +1,90 @@ +package ftbsc.lll.processor.tools; + +import ftbsc.lll.IInjector; +import ftbsc.lll.exceptions.InvalidResourceException; +import ftbsc.lll.processor.tools.obfuscation.ObfuscationMapper; + +import javax.annotation.processing.ProcessingEnvironment; +import java.io.*; +import java.net.URI; +import java.net.URISyntaxException; +import java.nio.charset.StandardCharsets; + +/** + * Class in charge of containing, parsing and processing all processor options, + * from the simpler booleans to the more complicated mapper. + */ +public class ProcessorOptions { + /** + * The environment the processor is acting in. + */ + public final ProcessingEnvironment env; + + /** + * The {@link ObfuscationMapper} used to convert classes and variables + * to their obfuscated equivalent. Will be null when no mapper is in use. + */ + public final ObfuscationMapper mapper; + + /** + * Whether the processor should issue warnings when compiling code anonymous + * classes which can't be checked for validity. + */ + public final boolean anonymousClassWarning; + + /** + * Whether injector metadata (what is returned by the functions of {@link IInjector}) + * is to use obfuscated names instead of its normal names. + */ + public final boolean obfuscateInjectorMetadata; + + + /** + * The public constructor, parses and stores all given arguments. + * @param env the environment the processor is working in + */ + public ProcessorOptions(ProcessingEnvironment env) { + this.env = env; + String location = env.getOptions().get("mappingsFile"); + if(location == null) + this.mapper = null; + else { + InputStream targetStream; + try { + URI target = new URI(location); + targetStream = target.toURL().openStream(); + } catch(URISyntaxException | IOException e) { + //may be a local file path + File f = new File(location); + if(!f.exists()) + throw new InvalidResourceException(location); + try { + targetStream = new FileInputStream(f); + } catch(FileNotFoundException ex) { + throw new InvalidResourceException(location); + } + } + //assuming its tsrg file + //todo: replace crappy homebaked parser with actual library + this.mapper = new ObfuscationMapper(new BufferedReader(new InputStreamReader(targetStream, + StandardCharsets.UTF_8)).lines()); + } + this.anonymousClassWarning = parseBooleanArg(env.getOptions().get("anonymousClassWarning"), true); + this.obfuscateInjectorMetadata = parseBooleanArg(env.getOptions().get("obfuscateInjectorMetadata"), true); + } + + /** + * Parses a boolean arg from a String. + * @param arg the arg to parse + * @return the parsed boolean + */ + private static boolean parseBooleanArg(String arg, boolean defaultValue) { + if(arg == null) return defaultValue; + try { // 0 = false, any other integer = true + int i = Integer.parseInt(arg); + return i != 0; + } catch(NumberFormatException ignored) { + return Boolean.parseBoolean(arg); + } + } +} diff --git a/src/main/java/ftbsc/lll/processor/tools/containers/ClassContainer.java b/src/main/java/ftbsc/lll/processor/tools/containers/ClassContainer.java index 889b027..2c10dd6 100644 --- a/src/main/java/ftbsc/lll/processor/tools/containers/ClassContainer.java +++ b/src/main/java/ftbsc/lll/processor/tools/containers/ClassContainer.java @@ -1,12 +1,10 @@ package ftbsc.lll.processor.tools.containers; import ftbsc.lll.exceptions.TargetNotFoundException; -import ftbsc.lll.processor.LilleroProcessor; import ftbsc.lll.processor.annotations.Find; import ftbsc.lll.processor.annotations.Patch; -import ftbsc.lll.processor.tools.obfuscation.ObfuscationMapper; +import ftbsc.lll.processor.tools.ProcessorOptions; -import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; import javax.lang.model.element.TypeElement; import javax.tools.Diagnostic; @@ -40,21 +38,20 @@ public class ClassContainer { public final Element elem; /** - * Private constructor, called from {@link #from(Annotation, Function, String, ProcessingEnvironment, ObfuscationMapper)}. + * Private constructor, called from {@link #from(Annotation, Function, String, ProcessorOptions)}. * @param fqn the fully-qualified name of the target class * @param innerNames an array of Strings containing the path to the inner class, may be null - * @param env the {@link ProcessingEnvironment} to be used to locate the class - * @param mapper the {@link ObfuscationMapper} to be used, may be null + * @param options the {@link ProcessorOptions} to be used */ - private ClassContainer(String fqn, String[] innerNames, ProcessingEnvironment env, ObfuscationMapper mapper) { + private ClassContainer(String fqn, String[] innerNames, ProcessorOptions options) { //find and validate - Element elem = env.getElementUtils().getTypeElement(fqn); + Element elem = options.env.getElementUtils().getTypeElement(fqn); if(elem == null) throw new TargetNotFoundException("class", fqn); StringBuilder fqnBuilder = new StringBuilder( - internalNameFromType(elem.asType(), env).replace('/', '.') + internalNameFromType(elem.asType(), options.env).replace('/', '.') ); if(innerNames != null) { @@ -64,8 +61,8 @@ public class ClassContainer { try { int anonClassCounter = Integer.parseInt(inner); //anonymous classes cannot be validated! - if(LilleroProcessor.anonymousClassWarning) - env.getMessager().printMessage( + if(options.anonymousClassWarning) + options.env.getMessager().printMessage( Diagnostic.Kind.WARNING, String.format( "Anonymous classes cannot be verified by the processor. The existence of %s$%s is not guaranteed!", @@ -88,7 +85,7 @@ public class ClassContainer { } } this.fqn = fqnBuilder.toString(); - this.fqnObf = findClassName(this.fqn, mapper); + this.fqnObf = findClassName(this.fqn, options); this.elem = elem; } @@ -97,33 +94,28 @@ public class ClassContainer { * @param ann the annotation containing the class * @param classFunction the annotation function returning the class * @param innerName a string containing the inner class name or nothing - * @param env the {@link ProcessingEnvironment} to be used to locate the class - * @param mapper the {@link ObfuscationMapper} to be used, may be null + * @param options the {@link ProcessorOptions} to be used * @param the type of the annotation carrying the information * @return the fully qualified name of the given class * @since 0.5.0 */ - public static ClassContainer from(T ann, Function> classFunction, String innerName, - ProcessingEnvironment env, ObfuscationMapper mapper) { + public static ClassContainer from(T ann, Function> classFunction, String innerName, ProcessorOptions options) { String fqn; String[] inner; - fqn = getTypeFromAnnotation(ann, classFunction, env).toString(); + fqn = getTypeFromAnnotation(ann, classFunction, options.env).toString(); inner = innerName.equals("") ? null : innerName.split("//$"); - return new ClassContainer(fqn, inner, env, mapper); + return new ClassContainer(fqn, inner, options); } /** * Safely extracts a {@link Class} from an annotation and gets its fully qualified name. * @param cl the {@link TypeElement} representing the class - * @param env the {@link ProcessingEnvironment} to be used to locate the class - * @param mapper the {@link ObfuscationMapper} to be used, may be null - * @param the type of the annotation carrying the information + * @param options the {@link ProcessorOptions} to be used * @return the fully qualified name of the given class * @since 0.6.0 */ - public static ClassContainer from( - TypeElement cl, ProcessingEnvironment env, ObfuscationMapper mapper) { - return new ClassContainer(cl.getQualifiedName().toString(), null, env, mapper); + public static ClassContainer from(TypeElement cl, ProcessorOptions options) { + return new ClassContainer(cl.getQualifiedName().toString(), null, options); } /** @@ -132,16 +124,13 @@ public class ClassContainer { * @param fallback the {@link ClassContainer} it falls back on * @param p the {@link Patch} annotation to get info from * @param f the {@link Find} annotation to get info from - * @param env the {@link ProcessingEnvironment} to perform the operation in - * @param mapper the {@link ObfuscationMapper} to use, may be null + * @param options the {@link ProcessorOptions} to be used * @return the built {@link ClassContainer} or the fallback if not enough information was present * @since 0.5.0 */ - public static ClassContainer findOrFallback(ClassContainer fallback, Patch p, Find f, ProcessingEnvironment env, ObfuscationMapper mapper) { - if(f == null) return ClassContainer.from(p, Patch::value, p.innerName(), env, mapper); - ClassContainer cl = ClassContainer.from(f, Find::value, f.innerName(), env, mapper); - return cl.fqn.equals("java.lang.Object") - ? fallback - : cl; + public static ClassContainer findOrFallback(ClassContainer fallback, Patch p, Find f, ProcessorOptions options) { + if(f == null) return ClassContainer.from(p, Patch::value, p.innerName(), options); + ClassContainer cl = ClassContainer.from(f, Find::value, f.innerName(), options); + return cl.fqn.equals("java.lang.Object") ? fallback : cl; } } diff --git a/src/main/java/ftbsc/lll/processor/tools/containers/FieldContainer.java b/src/main/java/ftbsc/lll/processor/tools/containers/FieldContainer.java index 57d8c29..2dd2ecb 100644 --- a/src/main/java/ftbsc/lll/processor/tools/containers/FieldContainer.java +++ b/src/main/java/ftbsc/lll/processor/tools/containers/FieldContainer.java @@ -3,17 +3,15 @@ package ftbsc.lll.processor.tools.containers; import ftbsc.lll.exceptions.AmbiguousDefinitionException; import ftbsc.lll.processor.annotations.Find; import ftbsc.lll.processor.annotations.Patch; -import ftbsc.lll.processor.tools.obfuscation.ObfuscationMapper; +import ftbsc.lll.processor.tools.ProcessorOptions; import org.objectweb.asm.Type; -import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.TypeElement; import javax.lang.model.element.VariableElement; import javax.lang.model.type.TypeKind; import javax.lang.model.type.TypeMirror; import static ftbsc.lll.processor.tools.ASTUtils.*; -import static ftbsc.lll.processor.tools.ASTUtils.descriptorFromType; /** * Container for information about a field. @@ -56,16 +54,13 @@ public class FieldContainer { public final VariableElement elem; /** - * Private constructor, called from {@link #from(VariableElement, ProcessingEnvironment, ObfuscationMapper)}. + * Private constructor, called from {@link #from(VariableElement, ProcessorOptions)}. * @param parent the {@link ClassContainer} representing the parent * @param name the fully-qualified name of the target field * @param descriptor the descriptor of the target field, may be null for verifiable fields - * @param env the {@link ProcessingEnvironment} to perform the operation in - * @param mapper the {@link ObfuscationMapper} to be used, may be null + * @param options the {@link ProcessorOptions} to be used */ - private FieldContainer( - ClassContainer parent, String name, String descriptor, - ProcessingEnvironment env, ObfuscationMapper mapper) { + private FieldContainer(ClassContainer parent, String name, String descriptor, ProcessorOptions options) { this.parent = parent; if(parent.elem == null) { //unverified if(descriptor == null) @@ -74,47 +69,45 @@ public class FieldContainer { this.name = name; this.descriptor = descriptor; } else { - this.elem = (VariableElement) findMember(parent, name, descriptor, descriptor != null, true, env); + this.elem = (VariableElement) findMember(parent, name, descriptor, descriptor != null, true, options.env); this.name = this.elem.getSimpleName().toString(); - this.descriptor = descriptorFromType(this.elem.asType(), env); + this.descriptor = descriptorFromType(this.elem.asType(), options.env); } - this.descriptorObf = mapper == null ? this.descriptor : mapper.obfuscateType(Type.getType(this.descriptor)).getDescriptor(); - this.nameObf = findMemberName(parent.fqn, this.name, null, mapper); + this.descriptorObf = options.mapper == null ? this.descriptor : options.mapper.obfuscateType(Type.getType(this.descriptor)).getDescriptor(); + this.nameObf = findMemberName(parent.fqn, this.name, null, options.mapper); } /** * Finds a {@link FieldContainer} from a finder. * @param finder the {@link VariableElement} annotated with {@link Find} for this field - * @param env the {@link ProcessingEnvironment} to perform the operation in - * @param mapper the {@link ObfuscationMapper} to be used, may be null + * @param options the {@link ProcessorOptions} to be used * @return the built {@link FieldContainer} * @since 0.5.0 */ - public static FieldContainer from(VariableElement finder, ProcessingEnvironment env, ObfuscationMapper mapper) { + public static FieldContainer from(VariableElement finder, ProcessorOptions options) { //the parent always has a @Patch annotation Patch patchAnn = finder.getEnclosingElement().getAnnotation(Patch.class); //the finder always has a @Find annotation Find f = finder.getAnnotation(Find.class); ClassContainer parent = ClassContainer.findOrFallback( - ClassContainer.from((TypeElement) finder.getEnclosingElement(), env, mapper), - patchAnn, f, env, mapper + ClassContainer.from((TypeElement) finder.getEnclosingElement(), options), patchAnn, f, options ); String name = f.name().equals("") ? finder.getSimpleName().toString() : f.name(); String descriptor; - TypeMirror fieldType = getTypeFromAnnotation(f, Find::type, env); + TypeMirror fieldType = getTypeFromAnnotation(f, Find::type, options.env); if(fieldType.toString().equals("java.lang.Object")) { descriptor = null; } else { if(fieldType.getKind() != TypeKind.VOID && !fieldType.getKind().isPrimitive()) descriptor = //jank af but this is temporary anyway "L" + ClassContainer.from( - f, Find::type, f.typeInner(), env, mapper + f, Find::type, f.typeInner(), options ).fqnObf.replace('.', '/') + ";"; - else descriptor = descriptorFromType(fieldType, env); + else descriptor = descriptorFromType(fieldType, options.env); } - return new FieldContainer(parent, name, descriptor, env, mapper); + return new FieldContainer(parent, name, descriptor, options); } } diff --git a/src/main/java/ftbsc/lll/processor/tools/containers/InjectorInfo.java b/src/main/java/ftbsc/lll/processor/tools/containers/InjectorInfo.java index e2d7ec8..460401b 100644 --- a/src/main/java/ftbsc/lll/processor/tools/containers/InjectorInfo.java +++ b/src/main/java/ftbsc/lll/processor/tools/containers/InjectorInfo.java @@ -2,9 +2,8 @@ package ftbsc.lll.processor.tools.containers; import ftbsc.lll.processor.annotations.Injector; import ftbsc.lll.processor.annotations.Target; -import ftbsc.lll.processor.tools.obfuscation.ObfuscationMapper; +import ftbsc.lll.processor.tools.ProcessorOptions; -import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.ExecutableElement; /** @@ -36,13 +35,12 @@ public class InjectorInfo { * @param injector the injector {@link ExecutableElement} * @param targetStub the target {@link ExecutableElement} * @param targetAnn the relevant {@link Target} annotation - * @param env the {@link ProcessingEnvironment} to be used to locate the class - * @param mapper the {@link ObfuscationMapper} to be used, may be null + * @param options the {@link ProcessorOptions} to be used */ - public InjectorInfo(ExecutableElement injector, ExecutableElement targetStub, Target targetAnn, ProcessingEnvironment env, ObfuscationMapper mapper) { + public InjectorInfo(ExecutableElement injector, ExecutableElement targetStub, Target targetAnn, ProcessorOptions options) { this.injector = injector; this.targetStub = targetStub; this.reason = injector.getAnnotation(Injector.class).reason(); - this.target = MethodContainer.from(targetStub, targetAnn, null, env, mapper); + this.target = MethodContainer.from(targetStub, targetAnn, null, options); } } \ No newline at end of file diff --git a/src/main/java/ftbsc/lll/processor/tools/containers/MethodContainer.java b/src/main/java/ftbsc/lll/processor/tools/containers/MethodContainer.java index 441b882..714ee54 100644 --- a/src/main/java/ftbsc/lll/processor/tools/containers/MethodContainer.java +++ b/src/main/java/ftbsc/lll/processor/tools/containers/MethodContainer.java @@ -5,9 +5,8 @@ import ftbsc.lll.exceptions.TargetNotFoundException; import ftbsc.lll.processor.annotations.Find; import ftbsc.lll.processor.annotations.Patch; import ftbsc.lll.processor.annotations.Target; -import ftbsc.lll.processor.tools.obfuscation.ObfuscationMapper; +import ftbsc.lll.processor.tools.ProcessorOptions; -import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.ExecutableElement; import javax.lang.model.element.TypeElement; @@ -55,18 +54,15 @@ public class MethodContainer { /** * Private constructor, called from - * {@link #from(ExecutableElement, Target, Find, ProcessingEnvironment, ObfuscationMapper)}. + * {@link #from(ExecutableElement, Target, Find, ProcessorOptions)}. * @param parent the {@link ClassContainer} representing the parent * @param name the fully-qualified name of the target method * @param descriptor the descriptor of the target method * @param strict whether the matching should be strict (see {@link Target#strict()} for more info) - * @param bridge whether the "bridge" should be matched isntead (see {@link Target#bridge()} for more info) - * @param env the {@link ProcessingEnvironment} to perform the operation in - * @param mapper the {@link ObfuscationMapper} to be used, may be null + * @param bridge whether the "bridge" should be matched instead (see {@link Target#bridge()} for more info) + * @param options the {@link ProcessorOptions} to be used */ - private MethodContainer( - ClassContainer parent, String name, String descriptor, boolean strict, - boolean bridge, ProcessingEnvironment env, ObfuscationMapper mapper) { + private MethodContainer(ClassContainer parent, String name, String descriptor, boolean strict, boolean bridge, ProcessorOptions options) { this.parent = parent; if(parent.elem == null) { //unverified if(descriptor == null) @@ -76,14 +72,14 @@ public class MethodContainer { this.descriptor = descriptor; } else { ExecutableElement tmp = (ExecutableElement) findMember( - parent, name, descriptor, descriptor != null && strict,false, env + parent, name, descriptor, descriptor != null && strict,false, options.env ); - this.elem = bridge ? findSyntheticBridge((TypeElement) this.parent.elem, tmp, env) : tmp; + this.elem = bridge ? findSyntheticBridge((TypeElement) this.parent.elem, tmp, options.env) : tmp; this.name = this.elem.getSimpleName().toString(); - this.descriptor = descriptorFromExecutableElement(this.elem, env); + this.descriptor = descriptorFromExecutableElement(this.elem, options.env); } - this.descriptorObf = mapper == null ? this.descriptor : mapper.obfuscateMethodDescriptor(this.descriptor); - this.nameObf = findMemberName(parent.fqn, this.name, this.descriptor, mapper); + this.descriptorObf = options.mapper == null ? this.descriptor : options.mapper.obfuscateMethodDescriptor(this.descriptor); + this.nameObf = findMemberName(parent.fqn, this.name, this.descriptor, options.mapper); } /** @@ -91,27 +87,25 @@ public class MethodContainer { * @param stub the {@link ExecutableElement} for the stub * @param t the {@link Target} annotation relevant to this case * @param f the {@link Find} annotation containing fallback data, may be null - * @param env the {@link ProcessingEnvironment} to perform the operation in - * @param mapper the {@link ObfuscationMapper} to be used, may be null + * @param options the {@link ProcessorOptions} to be used * @return the {@link MethodContainer} corresponding to the method * @throws AmbiguousDefinitionException if it finds more than one candidate * @throws TargetNotFoundException if it finds no valid candidate * @since 0.3.0 */ - public static MethodContainer from(ExecutableElement stub, Target t, Find f, ProcessingEnvironment env, ObfuscationMapper mapper) { + public static MethodContainer from(ExecutableElement stub, Target t, Find f, ProcessorOptions options) { //the parent always has a @Patch annotation Patch patchAnn = stub.getEnclosingElement().getAnnotation(Patch.class); ClassContainer parent = ClassContainer.findOrFallback( - ClassContainer.from((TypeElement) stub.getEnclosingElement(), env, mapper), - patchAnn, f, env, mapper + ClassContainer.from((TypeElement) stub.getEnclosingElement(), options), patchAnn, f, options ); String name = !t.methodName().equals("") ? t.methodName() //name was specified in target : stub.getSimpleName().toString(); String descriptor = t.strict() - ? descriptorFromExecutableElement(stub, env) + ? descriptorFromExecutableElement(stub, options.env) : null; - return new MethodContainer(parent, name, descriptor, t.strict(), t.bridge(), env, mapper); + return new MethodContainer(parent, name, descriptor, t.strict(), t.bridge(), options); } }