diff options
Diffstat (limited to 'src/main/java/ftbsc/lll/processor/utils')
| -rw-r--r-- | src/main/java/ftbsc/lll/processor/utils/ASTUtils.java | 409 | ||||
| -rw-r--r-- | src/main/java/ftbsc/lll/processor/utils/JavaPoetUtils.java | 171 |
2 files changed, 580 insertions, 0 deletions
diff --git a/src/main/java/ftbsc/lll/processor/utils/ASTUtils.java b/src/main/java/ftbsc/lll/processor/utils/ASTUtils.java new file mode 100644 index 0000000..04da70e --- /dev/null +++ b/src/main/java/ftbsc/lll/processor/utils/ASTUtils.java @@ -0,0 +1,409 @@ +package ftbsc.lll.processor.utils; + +import ftbsc.lll.exceptions.AmbiguousDefinitionException; +import ftbsc.lll.exceptions.MappingNotFoundException; +import ftbsc.lll.exceptions.NotAProxyException; +import ftbsc.lll.exceptions.TargetNotFoundException; +import ftbsc.lll.mapper.tools.Mapper; +import ftbsc.lll.mapper.tools.data.ClassData; +import ftbsc.lll.mapper.tools.data.FieldData; +import ftbsc.lll.mapper.tools.data.MethodData; +import ftbsc.lll.processor.annotations.Target; +import ftbsc.lll.processor.containers.ClassContainer; +import ftbsc.lll.proxies.ProxyType; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.*; +import javax.lang.model.type.*; +import java.lang.annotation.Annotation; +import java.util.Collection; +import java.util.List; +import java.util.function.Function; +import java.util.stream.Collectors; + +/** + * Collection of AST-related static utils that didn't really fit into the main class. + */ +public class ASTUtils { + /** + * Finds, among the methods of a class cl, the one annotated with ann, and tries to build + * an {@link Element} from it. + * @param parent the parent {@link Element} to the desired element + * @param ann the {@link Class} corresponding to the desired annotation + * @param <T> the type of {@link Element} to use + * @return a {@link List} of {@link Element}s annotated with the given annotation + * @since 0.2.0 + */ + @SuppressWarnings("unchecked") + public static <T extends Element> List<T> findAnnotatedElement(Element parent, Class<? extends Annotation> ann) { + return parent.getEnclosedElements() + .stream() + .filter(e -> e.getAnnotationsByType(ann).length != 0) + .map(e -> (T) e) + .collect(Collectors.toList()); + } + + /** + * Maps a {@link javax.lang.model.element.Modifier} to its reflective + * {@link java.lang.reflect.Modifier} equivalent. + * @param m the {@link Modifier} to map + * @return an integer representing the modifier + * @see java.lang.reflect.Modifier + * @since 0.2.0 + */ + public static int mapModifier(Modifier m) { + switch(m) { + case PUBLIC: + return java.lang.reflect.Modifier.PUBLIC; + case PROTECTED: + return java.lang.reflect.Modifier.PROTECTED; + case PRIVATE: + return java.lang.reflect.Modifier.PRIVATE; + case ABSTRACT: + return java.lang.reflect.Modifier.ABSTRACT; + case STATIC: + return java.lang.reflect.Modifier.STATIC; + case FINAL: + return java.lang.reflect.Modifier.FINAL; + case TRANSIENT: + return java.lang.reflect.Modifier.TRANSIENT; + case VOLATILE: + return java.lang.reflect.Modifier.VOLATILE; + case SYNCHRONIZED: + return java.lang.reflect.Modifier.SYNCHRONIZED; + case NATIVE: + return java.lang.reflect.Modifier.NATIVE; + case STRICTFP: + return java.lang.reflect.Modifier.STRICT; + default: + return 0; + } + } + + /** + * Takes in a {@link Collection} of AST {@link Modifier}s and + * returns them mapped to their reflective integer equivalent. + * @param modifiers the {@link Modifier}s + * @return an integer value representing them + * @since 0.5.0 + */ + public static int mapModifiers(Collection<Modifier> modifiers) { + int i = 0; + for(Modifier m : modifiers) + i |= mapModifier(m); + return i; + } + + /** + * Safely extracts a {@link Class} from an annotation and gets a {@link TypeMirror} representing it. + * @param ann the annotation containing the class + * @param classFunction the annotation function returning the class + * @param env the {@link ProcessingEnvironment} to perform the operation in + * @param <T> the type of the annotation carrying the information + * @return a {@link TypeMirror} representing the requested {@link Class} + * @since 0.3.0 + */ + public static <T extends Annotation> TypeMirror getTypeFromAnnotation( + T ann, Function<T, Class<?>> classFunction, ProcessingEnvironment env) { + try { + String fqn = classFunction.apply(ann).getCanonicalName(); + if(fqn == null) + fqn = ""; + return env.getElementUtils().getTypeElement(fqn).asType(); + } catch(MirroredTypeException e) { + return e.getTypeMirror(); + } + } + + /** + * Gets the internal name from an {@link TypeMirror}. + * @param type the {@link TypeMirror} in question + * @param env the {@link ProcessingEnvironment} to perform the operation in + * @return the internal name at compile time, or null if it wasn't a qualifiable + * @since 0.5.1 + */ + public static String internalNameFromType(TypeMirror type, ProcessingEnvironment env) { + //needed to actually turn elem into a TypeVariable, find it ignoring generics + Element elem = env.getTypeUtils().asElement(env.getTypeUtils().erasure(type)); + StringBuilder fqnBuilder = new StringBuilder(); + while(elem.getEnclosingElement() != null && elem.getEnclosingElement().getKind() != ElementKind.PACKAGE) { + fqnBuilder + .insert(0, elem.getSimpleName().toString()) + .insert(0, "$"); + elem = elem.getEnclosingElement(); + } + return fqnBuilder + .insert(0, env.getTypeUtils().erasure(elem.asType()).toString()) + .toString() + .replace('.', '/'); + } + + /** + * Builds a type descriptor from the given {@link TypeMirror}. + * @param t the {@link TypeMirror} representing the desired type + * @param env the {@link ProcessingEnvironment} to perform the operation in + * @return a {@link String} containing the relevant descriptor + */ + public static String descriptorFromType(TypeMirror t, ProcessingEnvironment env) { + t = env.getTypeUtils().erasure(t); //type erasure + + StringBuilder desc = new StringBuilder(); + //add array brackets + while(t.getKind() == TypeKind.ARRAY) { + desc.append("["); + t = ((ArrayType) t).getComponentType(); + } + + if(t.getKind() == TypeKind.TYPEVAR) + t = ((TypeVariable) t).getUpperBound(); + + if(t.getKind() == TypeKind.DECLARED) + desc + .append("L") + .append(internalNameFromType(t, env)) + .append(";"); + else { + switch(t.getKind()) { + case BOOLEAN: + desc.append("Z"); + break; + case CHAR: + desc.append("C"); + break; + case BYTE: + desc.append("B"); + break; + case SHORT: + desc.append("S"); + break; + case INT: + desc.append("I"); + break; + case FLOAT: + desc.append("F"); + break; + case LONG: + desc.append("J"); + break; + case DOUBLE: + desc.append("D"); + break; + case VOID: + desc.append("V"); + break; + } + } + + return desc.toString(); + } + + /** + * Builds a method descriptor from the given {@link ExecutableElement}. + * @param m the {@link ExecutableElement} for the method + * @param env the {@link ProcessingEnvironment} to perform the operation in + * @return a {@link String} containing the relevant descriptor + */ + public static String descriptorFromExecutableElement(ExecutableElement m, ProcessingEnvironment env) { + StringBuilder methodSignature = new StringBuilder(); + methodSignature.append("("); + m.getParameters().forEach(p -> methodSignature.append(descriptorFromType(p.asType(), env))); + methodSignature.append(")"); + methodSignature.append(descriptorFromType(m.getReturnType(), env)); + return methodSignature.toString(); + } + + /** + * Gets the {@link ClassData} corresponding to the given fully-qualified name, + * or creates a false one with the same, non-obfuscated name twice. + * @param name the internal name of the class to convert + * @param mapper the {@link Mapper} to use, may be null + * @return the fully qualified class name + * @since 0.6.1 + */ + public static ClassData getClassData(String name, Mapper mapper) { + try { + name = name.replace('.', '/'); //just in case + if(mapper != null) + return mapper.getClassData(name); + } catch(MappingNotFoundException ignored) {} + return new ClassData(name, name); + } + + /** + * Gets the {@link MethodData} corresponding to the method matching the given + * name, parent and descriptor, or creates a dummy one with fake data if no + * valid mapping is found. + * @param parent the internal name of the parent class + * @param name the name of the member + * @param descriptor the descriptor of the method + * @param mapper the {@link Mapper} to use, may be null + * @return the fully qualified class name + * @since 0.6.1 + */ + public static MethodData getMethodData(String parent, String name, String descriptor, Mapper mapper) { + try { + name = name.replace('.', '/'); //just in case + if(mapper != null) + return mapper.getMethodData(parent, name, descriptor); + } catch(MappingNotFoundException ignored) {} + return new MethodData(getClassData(name, mapper), name, name, descriptor); + } + + /** + * Gets the {@link FieldData} corresponding to the field matching the given + * name and parent, or creates a dummy one with fake data if no valid + * mapping is found. + * @param parent the internal name of the parent class + * @param name the name of the member + * @param mapper the {@link Mapper} to use, may be null + * @return the fully qualified class name + * @since 0.6.1 + */ + public static FieldData getFieldData(String parent, String name, Mapper mapper) { + try { + name = name.replace('.', '/'); //just in case + if(mapper != null) + return mapper.getFieldData(parent, name); + } catch(MappingNotFoundException ignored) {} + return new FieldData(getClassData(name, mapper), name, name); + } + + /** + * Finds a member given the name, the container class and (if it's a method) the descriptor. + * @param parent the {@link ClassContainer} representing the parent + * @param name the name to search for + * @param descr the descriptor to search for, or null if it's not a method + * @param strict whether to perform lookup in strict mode (see {@link Target#strict()} for more information) + * @param field whether the member being searched is a field + * @param env the {@link ProcessingEnvironment} to perform the operation in + * @return the desired member, if it exists + * @throws AmbiguousDefinitionException if it finds more than one candidate + * @throws TargetNotFoundException if it finds no valid candidate + * @since 0.3.0 + */ + public static Element findMember( + ClassContainer parent, String name, String descr, + boolean strict, boolean field, ProcessingEnvironment env) { + if(parent.elem == null) + throw new TargetNotFoundException("parent class", parent.data.name); + //try to find by name + List<Element> candidates = parent.elem.getEnclosedElements() + .stream() + .filter(e -> (field && e instanceof VariableElement) || e instanceof ExecutableElement) + .filter(e -> e.getSimpleName().contentEquals(name)) + .collect(Collectors.toList()); + + if(candidates.isEmpty()) + throw new TargetNotFoundException(field ? "field" : "method", name, parent.data.name); + + if(candidates.size() == 1 && (!strict || descr == null)) + return candidates.get(0); + + if(descr == null) { + throw new AmbiguousDefinitionException(String.format( + "Found %d members named %s in class %s!", candidates.size(), name, parent.data.name)); + } else { + if(field) { + //fields can verify the signature for extra safety + //but there can only be 1 field with a given name + if(!descriptorFromType(candidates.get(0).asType(), env).equals(descr)) + throw new TargetNotFoundException("field", String.format( + "%s with descriptor %s", name, descr), parent.data.name); + } else { + candidates = candidates.stream() + .map(e -> (ExecutableElement) e) + .filter(strict + ? c -> descr.equals(descriptorFromExecutableElement(c, env)) + : c -> descr.split("\\)")[0].equalsIgnoreCase( + descriptorFromExecutableElement(c, env).split("\\)")[0]) + ).collect(Collectors.toList()); + } + if(candidates.isEmpty()) + throw new TargetNotFoundException("method", String.format( + "%s %s", name, descr), parent.data.name); + if(candidates.size() > 1) + throw new AmbiguousDefinitionException(String.format( + "Found %d methods named %s in class %s!", candidates.size(), name, parent.data.name)); + return candidates.get(0); + } + } + + /** + * Tries to find the method being overloaded by the given {@link ExecutableElement}. + * In case of multiple layers of overloading, it finds the original one. In case of + * no overloading, it returns the given method. + * @param context the {@link TypeElement} representing the parent class + * @param method an {@link ExecutableElement} representing the overloading method + * @param env the {@link ProcessingEnvironment} to perform the operation in + * @return the original overloaded method, or the given method if it was not found + * @since 0.5.2 + */ + public static ExecutableElement findOverloadedMethod( + TypeElement context, ExecutableElement method, ProcessingEnvironment env) { + if (context.getSuperclass().getKind() == TypeKind.NONE) + return method; + + for (Element elem : context.getEnclosedElements()) { + if (elem.getKind() != ElementKind.METHOD) + continue; + if (env.getElementUtils().overrides(method, (ExecutableElement) elem, context)) { + method = (ExecutableElement) elem; + break; //found + } + } + + return findOverloadedMethod( + (TypeElement) env.getTypeUtils().asElement(context.getSuperclass()), + method, env + ); + } + + /** + * Tries to find the "synthetic bridge" generated by the compiler for a certain overridden + * method. A "bridge" only exists in cases where type erasure is involved (i.e. when the + * method being overridden uses a generic parameter that is not preserved in the overriding + * method). + * @param context the {@link TypeElement} representing the parent class + * @param method an {@link ExecutableElement} stub representing the overloading method + * @param env the {@link ProcessingEnvironment} to perform the operation in + * @return the "bridge" + * @throws TargetNotFoundException if the method in question was not overriding anything, or + * if the method it was overriding does not require a bridge + * @since 0.5.2 + */ + public static ExecutableElement findSyntheticBridge( + TypeElement context, ExecutableElement method, ProcessingEnvironment env) throws TargetNotFoundException { + ExecutableElement overridding = findOverloadedMethod(context, method, env); + if(descriptorFromExecutableElement(overridding, env).equals(descriptorFromExecutableElement(method, env))) + throw new TargetNotFoundException( + "bridge method for", + overridding.getSimpleName().toString(), + context.getQualifiedName().toString() + ); + else return overridding; + } + + /** + * Utility method for finding out what type of proxy a field is. + * It will fail if the return type is not a known type of proxy. + * @param v the annotated {@link VariableElement} + * @return the {@link ProxyType} for the element + * @throws NotAProxyException if it's neither + * @since 0.4.0 + */ + public static ProxyType getProxyType(VariableElement v) { + String returnTypeFQN = v.asType().toString(); + switch(returnTypeFQN) { + case "ftbsc.lll.proxies.impl.FieldProxy": + return ProxyType.FIELD; + case "ftbsc.lll.proxies.impl.MethodProxy": + return ProxyType.METHOD; + case "ftbsc.lll.proxies.impl.TypeProxy": + return ProxyType.TYPE; + case "ftbsc.lll.proxies.impl.PackageProxy": + return ProxyType.PACKAGE; + default: + throw new NotAProxyException(v.getEnclosingElement().getSimpleName().toString(), v.getSimpleName().toString()); + } + } +} diff --git a/src/main/java/ftbsc/lll/processor/utils/JavaPoetUtils.java b/src/main/java/ftbsc/lll/processor/utils/JavaPoetUtils.java new file mode 100644 index 0000000..629f77a --- /dev/null +++ b/src/main/java/ftbsc/lll/processor/utils/JavaPoetUtils.java @@ -0,0 +1,171 @@ +package ftbsc.lll.processor.utils; + +import com.squareup.javapoet.*; +import ftbsc.lll.processor.ProcessorOptions; +import ftbsc.lll.processor.annotations.Find; +import ftbsc.lll.processor.annotations.Target; +import ftbsc.lll.processor.containers.ClassContainer; +import ftbsc.lll.processor.containers.FieldContainer; +import ftbsc.lll.processor.containers.InjectorInfo; +import ftbsc.lll.processor.containers.MethodContainer; +import ftbsc.lll.proxies.ProxyType; +import ftbsc.lll.proxies.impl.FieldProxy; +import ftbsc.lll.proxies.impl.MethodProxy; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.*; +import java.util.HashSet; + +import static ftbsc.lll.processor.utils.ASTUtils.getProxyType; +import static ftbsc.lll.processor.utils.ASTUtils.mapModifiers; + +/** + * Collection of static utils that rely on JavaPoet to function. + */ +public class JavaPoetUtils { + /** + * Builds a {@link MethodSpec} for a public method whose body simply returns a {@link String}. + * @param name the name of the method + * @param returnString the {@link String} to return + * @return the built {@link MethodSpec} + */ + public static MethodSpec buildStringReturnMethod(String name, String returnString) { + return MethodSpec.methodBuilder(name) + .addModifiers(Modifier.PUBLIC) + .addAnnotation(Override.class) + .returns(String.class) + .addStatement("return $S", returnString) + .build(); + } + + /** + * Appends to a given {@link MethodSpec.Builder} definitions for a proxy. + * @param var the {@link VariableElement} representing the proxy + * @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 options the {@link ProcessorOptions} to be used + * @since 0.5.0 + */ + public static void appendMemberFinderDefinition( + VariableElement var, ExecutableElement stub, Target t, + MethodSpec.Builder con, ProcessorOptions options) { + ProxyType type = getProxyType(var); + if(type != ProxyType.METHOD && type != ProxyType.FIELD) + return; //this method is irrelevant to everyone else + + //we need this stuff + Find f = var.getAnnotation(Find.class); + final boolean isMethod = type == ProxyType.METHOD; + final String builderName = var.getSimpleName().toString() + "Builder"; + + String descriptorObf, nameObf; + ClassContainer parent; + Element target; + + if(isMethod) { + MethodContainer mc = MethodContainer.from(stub, t, f, options); + descriptorObf = mc.descriptorObf; + nameObf = mc.data.nameMapped; + parent = mc.parent; + target = mc.elem; + } else { + FieldContainer fc = FieldContainer.from(var, options); + descriptorObf = fc.descriptorObf; + nameObf = fc.data.nameMapped; + parent = fc.parent; + target = fc.elem; + } + + //initialize builder + con.addStatement("$T $L = $T.builder($S)", + isMethod ? MethodProxy.Builder.class : FieldProxy.Builder.class, + builderName, //variable name is always unique by definition + isMethod ? MethodProxy.class : FieldProxy.class, + nameObf + ); + + //set parent + con.addStatement( + "$L.setParent($S, $L)", + builderName, + parent.data.nameMapped.replace('/', '.'), + parent.elem == null ? 0 : mapModifiers(parent.elem.getModifiers()) + ); + + //set modifiers + con.addStatement( + "$L.setModifiers($L)", + builderName, + target == null ? 0 : mapModifiers(target.getModifiers()) + ); + + //set type(s) + con.addStatement( + "$L.setDescriptor($S)", + builderName, + descriptorObf + ); + + //build and set + con.addStatement( + "super.$L = $L.build()", + var.getSimpleName().toString(), + builderName + ); + } + + /** + * Generates a {@link HashSet} of dummy overrides for every abstract method in a given class, + * represented as a {@link TypeElement}. + * @param clazz the given class + * @return a {@link HashSet} containing the generated {@link MethodSpec}s + * @since 0.5.0 + */ + public static HashSet<MethodSpec> generateDummies(TypeElement clazz) { + HashSet<MethodSpec> specs = new HashSet<>(); + clazz + .getEnclosedElements() + .stream() + .filter(e -> e instanceof ExecutableElement) + .map(e -> (ExecutableElement) e) + .forEach(e -> { + if(e.getModifiers().contains(Modifier.ABSTRACT)) + specs.add(MethodSpec.overriding(e) + .addStatement("throw new $T($S)", RuntimeException.class, "This is a stub and should not have been called") + .build() + ); + }); + return specs; + } + + /** + * Generates the wrapper around a certain injector. + * @param inj the {@link InjectorInfo} carrying the information about the target injector + * @param env the {@link ProcessingEnvironment} to perform the operation in + * @return the generated {@link MethodSpec} for the injector + * @since 0.6.0 + */ + public static MethodSpec generateInjector(InjectorInfo inj, ProcessingEnvironment env) { + MethodSpec.Builder injectBuilder = MethodSpec.methodBuilder("inject") + .addModifiers(Modifier.PUBLIC) + .returns(void.class) + .addAnnotation(Override.class) + .addParameter(ParameterSpec.builder( + TypeName.get(env + .getElementUtils() + .getTypeElement("org.objectweb.asm.tree.ClassNode").asType()), "clazz") + .build()) + .addParameter(ParameterSpec.builder( + TypeName.get(env + .getElementUtils() + .getTypeElement("org.objectweb.asm.tree.MethodNode").asType()), "main") + .build()); + + if(inj.injector.getParameters().size() == 2) + injectBuilder.addStatement("super.$L(clazz, main)", inj.injector.getSimpleName()); + else injectBuilder.addStatement("super.$L(main)", inj.injector.getSimpleName()); + + return injectBuilder.build(); + } +} |