zaaarf/lillero-processor
1
0
Fork 0
mirror of https://github.com/zaaarf/lillero-processor.git synced 2024-11-22 14:44:51 +01:00
Code Issues Projects Releases Packages Wiki Activity

fix: now only obfuscate name after finding real method

Browse source
This commit is contained in:
zaaarf 2023-03-15 16:27:50 +01:00
parent f54854a42f
commit f4b43e77be
No known key found for this signature in database
GPG key ID: 82240E075E31FA4C
1 changed files with 39 additions and 44 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

83
src/main/java/ftbsc/lll/processor/LilleroProcessor.java
View file

@ -149,10 +149,6 @@ public class LilleroProcessor extends AbstractProcessor {
* Finds the class name and maps it to the correct format. * Finds the class name and maps it to the correct format.
* @param name the fully qualified name of the class to convert * @param name the fully qualified name of the class to convert
* @param mapper the {@link ObfuscationMapper} to use, may be null * @param mapper the {@link ObfuscationMapper} to use, may be null
* @implNote De facto, there is never any difference between the SRG and MCP name of a class.
* In theory, differences only arise between SRG/MCP names and Notch (fully obfuscated)
* names. However, this method still performs a conversion - just in case there is an
* odd one out.
* @return the fully qualified class name * @return the fully qualified class name
* @since 0.3.0 * @since 0.3.0
*/ */
@ -165,10 +161,6 @@ public class LilleroProcessor extends AbstractProcessor {
* @param patchAnn the {@link Patch} annotation containing target class info * @param patchAnn the {@link Patch} annotation containing target class info
* @param methodAnn the {@link FindMethod} annotation to fall back on, may be null * @param methodAnn the {@link FindMethod} annotation to fall back on, may be null
* @param mapper the {@link ObfuscationMapper} to use, may be null * @param mapper the {@link ObfuscationMapper} to use, may be null
* @implNote De facto, there is never any difference between the SRG and MCP name of a class.
* In theory, differences only arise between SRG/MCP names and Notch (fully obfuscated)
* names. However, this method still performs a conversion - just in case there is an
* odd one out.
* @return the fully qualified class name * @return the fully qualified class name
* @since 0.3.0 * @since 0.3.0
*/ */
@ -205,43 +197,30 @@ public class LilleroProcessor extends AbstractProcessor {
/** /**
* Finds the method name and maps it to the correct format. * Finds the method name and maps it to the correct format.
*
* @param parentFQN the already mapped FQN of the parent class * @param parentFQN the already mapped FQN of the parent class
* @param methodAnn the {@link FindMethod} annotation to fall back on, may be null * @param methodAnn the {@link FindMethod} annotation to fall back on, may be null
* @param stub the {@link ExecutableElement} for the stub * @param stub the {@link ExecutableElement} for the stub
* @param mapper the {@link ObfuscationMapper} to use, may be null
* @return the internal class name * @return the internal class name
* @since 0.3.0 * @since 0.3.0
*/ */
private String findMethodName(String parentFQN, FindMethod methodAnn, ExecutableElement stub, ObfuscationMapper mapper) { private String findMethodName(String parentFQN, FindMethod methodAnn, ExecutableElement stub) {
String methodName = methodAnn == null ? stub.getSimpleName().toString() : methodAnn.name(); String methodName = methodAnn == null ? stub.getSimpleName().toString() : methodAnn.name();
String methodDescriptor; String methodDescriptor;
if(methodAnn == null) if(methodAnn == null)
methodDescriptor = descriptorFromExecutableElement(stub); methodDescriptor = descriptorFromExecutableElement(stub);
else methodDescriptor = methodDescriptorFromParams(methodAnn, FindMethod::params, processingEnv.getElementUtils()); else methodDescriptor = methodDescriptorFromParams(methodAnn, FindMethod::params, processingEnv.getElementUtils());
try { try {
methodName = findMemberName(parentFQN, methodName, methodDescriptor, mapper); methodName = findMemberName(parentFQN, methodName, methodDescriptor, null);
} catch(MappingNotFoundException e) { } catch(MappingNotFoundException e) {
//not found: try again with the name of the annotated method //not found: try again with the name of the annotated method
if(methodAnn == null) { if(methodAnn == null) {
methodName = findMemberName(parentFQN, stub.getSimpleName().toString(), methodDescriptor, mapper); methodName = findMemberName(parentFQN, stub.getSimpleName().toString(), methodDescriptor, null);
} else throw e; } else throw e;
} }
return methodName; return methodName;
} }
/**
* Finds the method name and maps it to the correct format.
* @param patchAnn the {@link Patch} annotation containing target class info
* @param methodAnn the {@link FindMethod} annotation to fall back on, may be null
* @param stub the {@link ExecutableElement} for the stub
* @param mapper the {@link ObfuscationMapper} to use
* @return the internal class name
* @since 0.3.0
*/
private String findMethodName(Patch patchAnn, FindMethod methodAnn, ExecutableElement stub, ObfuscationMapper mapper) {
return findMethodName(findClassName(patchAnn, methodAnn, mapper), methodAnn, stub, mapper);
}
/** /**
* Finds a method given name, container and descriptor. * Finds a method given name, container and descriptor.
* @param fullyQualifiedNameParent the fully qualified name of the parent class of the method * @param fullyQualifiedNameParent the fully qualified name of the parent class of the method
@ -292,18 +271,17 @@ public class LilleroProcessor extends AbstractProcessor {
/** /**
* Finds the real method corresponding to a stub. * Finds the real method corresponding to a stub.
* @param stub the {@link ExecutableElement} for the stub * @param stub the {@link ExecutableElement} for the stub
* @param mapper the {@link ObfuscationMapper} to use
* @return the desired method, if it exists * @return the desired method, if it exists
* @throws AmbiguousDefinitionException if it finds more than one candidate * @throws AmbiguousDefinitionException if it finds more than one candidate
* @throws TargetNotFoundException if it finds no valid candidate * @throws TargetNotFoundException if it finds no valid candidate
* @since 0.3.0 * @since 0.3.0
*/ */
private ExecutableElement findRealMethod(ExecutableElement stub, ObfuscationMapper mapper) { private ExecutableElement findRealMethodFromStub(ExecutableElement stub) {
Patch patchAnn = stub.getEnclosingElement().getAnnotation(Patch.class); Patch patchAnn = stub.getEnclosingElement().getAnnotation(Patch.class);
FindMethod findAnn = stub.getAnnotation(FindMethod.class); //this may be null, it means no fallback info FindMethod findAnn = stub.getAnnotation(FindMethod.class); //this may be null, it means no fallback info
Target target = stub.getAnnotation(Target.class); //if this is null strict mode is always disabled Target target = stub.getAnnotation(Target.class); //if this is null strict mode is always disabled
String parentFQN = findClassName(patchAnn, findAnn, mapper); String parentFQN = findClassName(patchAnn, findAnn, null);
String methodName = findMethodName(patchAnn, findAnn, stub, mapper); String methodName = findMethodName(findClassName(patchAnn, findAnn, null), findAnn, stub);
return findMethod( return findMethod(
parentFQN, parentFQN,
methodName, methodName,
@ -314,19 +292,18 @@ public class LilleroProcessor extends AbstractProcessor {
/** /**
* Finds the real field corresponding to a stub. * Finds the real field corresponding to a stub.
* @param stub the {@link ExecutableElement} for the stub * @param stub the {@link ExecutableElement} for the stub
* @param mapper the {@link ObfuscationMapper} to use
* @return the desired method, if it exists * @return the desired method, if it exists
* @throws TargetNotFoundException if it finds no valid candidate * @throws TargetNotFoundException if it finds no valid candidate
* @since 0.3.0 * @since 0.3.0
*/ */
private VariableElement findField(ExecutableElement stub, ObfuscationMapper mapper) { private VariableElement findField(ExecutableElement stub) {
Patch patchAnn = stub.getEnclosingElement().getAnnotation(Patch.class); Patch patchAnn = stub.getEnclosingElement().getAnnotation(Patch.class);
FindField fieldAnn = stub.getAnnotation(FindField.class); FindField fieldAnn = stub.getAnnotation(FindField.class);
String parentName; String parentName;
if(fieldAnn.parent().equals(Object.class)) if(fieldAnn.parent().equals(Object.class))
parentName = getClassFullyQualifiedName(patchAnn, Patch::value); parentName = getClassFullyQualifiedName(patchAnn, Patch::value);
else parentName = getClassFullyQualifiedName(fieldAnn, FindField::parent); else parentName = getClassFullyQualifiedName(fieldAnn, FindField::parent);
parentName = findClassName(parentName, mapper); parentName = findClassName(parentName, null);
String name = fieldAnn.name().equals("") String name = fieldAnn.name().equals("")
? stub.getSimpleName().toString() ? stub.getSimpleName().toString()
: fieldAnn.name(); : fieldAnn.name();
@ -351,7 +328,7 @@ public class LilleroProcessor extends AbstractProcessor {
private void generateInjectors(TypeElement cl) { private void generateInjectors(TypeElement cl) {
//find class information //find class information
Patch patchAnn = cl.getAnnotation(Patch.class); Patch patchAnn = cl.getAnnotation(Patch.class);
String targetClassSrgName = findClassName(patchAnn, mapper); String targetClassFQN = findClassName(patchAnn, mapper).replace('/', '.');
//find package information //find package information
Element packageElement = cl.getEnclosingElement(); Element packageElement = cl.getEnclosingElement();
@ -435,7 +412,7 @@ public class LilleroProcessor extends AbstractProcessor {
throw new AmbiguousDefinitionException(String.format("Unclear target for injector %s::%s!", cl.getSimpleName(), inj.getSimpleName())); throw new AmbiguousDefinitionException(String.format("Unclear target for injector %s::%s!", cl.getSimpleName(), inj.getSimpleName()));
else toGenerate.put( else toGenerate.put(
String.format("%sInjector%d", cl.getSimpleName(), iterationNumber), String.format("%sInjector%d", cl.getSimpleName(), iterationNumber),
new InjectorInfo(inj, findRealMethod(injectionTarget, mapper)) new InjectorInfo(inj, findRealMethodFromStub(injectionTarget))
); );
iterationNumber++; iterationNumber++;
} }
@ -443,6 +420,9 @@ public class LilleroProcessor extends AbstractProcessor {
//iterate over the map and generate the classes //iterate over the map and generate the classes
for(String injName : toGenerate.keySet()) { for(String injName : toGenerate.keySet()) {
String targetMethodDescriptor = descriptorFromExecutableElement(toGenerate.get(injName).target);
String targetMethodName = findMemberName(targetClassFQN, toGenerate.get(injName).target.getSimpleName().toString(), targetMethodDescriptor, this.mapper);
MethodSpec stubOverride = MethodSpec.overriding(toGenerate.get(injName).target) MethodSpec stubOverride = MethodSpec.overriding(toGenerate.get(injName).target)
.addStatement("throw new $T($S)", RuntimeException.class, "This is a stub and should not have been called") .addStatement("throw new $T($S)", RuntimeException.class, "This is a stub and should not have been called")
.build(); .build();
@ -468,10 +448,10 @@ public class LilleroProcessor extends AbstractProcessor {
.addSuperinterface(ClassName.get(IInjector.class)) .addSuperinterface(ClassName.get(IInjector.class))
.addMethod(buildStringReturnMethod("name", cl.getSimpleName().toString())) .addMethod(buildStringReturnMethod("name", cl.getSimpleName().toString()))
.addMethod(buildStringReturnMethod("reason", patchAnn.reason())) .addMethod(buildStringReturnMethod("reason", patchAnn.reason()))
.addMethod(buildStringReturnMethod("targetClass", targetClassSrgName.replace('/', '.'))) .addMethod(buildStringReturnMethod("targetClass", targetClassFQN))
.addMethod(buildStringReturnMethod("methodName", toGenerate.get(injName).target.getSimpleName().toString())) .addMethod(buildStringReturnMethod("methodName", targetMethodName))
.addMethod(buildStringReturnMethod("methodDesc", descriptorFromExecutableElement(toGenerate.get(injName).target))) .addMethod(buildStringReturnMethod("methodDesc", targetMethodDescriptor))
.addMethods(generateRequestedProxies(cl, mapper)) .addMethods(generateRequestedProxies(cl, this.mapper))
.addMethod(stubOverride) .addMethod(stubOverride)
.addMethod(inject) .addMethod(inject)
.build(); .build();
@ -521,20 +501,28 @@ public class LilleroProcessor extends AbstractProcessor {
.filter(m -> !m.getModifiers().contains(Modifier.STATIC)) //skip static stuff as we can't override it .filter(m -> !m.getModifiers().contains(Modifier.STATIC)) //skip static stuff as we can't override it
.filter(m -> !m.getModifiers().contains(Modifier.FINAL)) //in case someone is trying to be funny .filter(m -> !m.getModifiers().contains(Modifier.FINAL)) //in case someone is trying to be funny
.forEach(m -> { .forEach(m -> {
ExecutableElement targetMethod = findRealMethod(m, mapper); ExecutableElement targetMethod = findRealMethodFromStub(m);
MethodSpec.Builder b = MethodSpec.overriding(m); MethodSpec.Builder b = MethodSpec.overriding(m);
String targetParentFQN = findClassName(((TypeElement) targetMethod.getEnclosingElement()).getQualifiedName().toString(), mapper);
b.addStatement("$T bd = $T.builder($S)", b.addStatement("$T bd = $T.builder($S)",
MethodProxy.Builder.class, MethodProxy.Builder.class,
MethodProxy.class, MethodProxy.class,
m.getSimpleName().toString() findMemberName(targetParentFQN, targetMethod.getSimpleName().toString(), descriptorFromExecutableElement(targetMethod), mapper)
); );
b.addStatement("bd.setParent($S)", ((TypeElement) targetMethod.getEnclosingElement()).getQualifiedName().toString());
b.addStatement("bd.setParent($S)", targetParentFQN);
for(Modifier mod : targetMethod.getModifiers()) for(Modifier mod : targetMethod.getModifiers())
b.addStatement("bd.addModifier($L)", mapModifier(mod)); b.addStatement("bd.addModifier($L)", mapModifier(mod));
for(TypeParameterElement p : targetMethod.getTypeParameters()) for(TypeParameterElement p : targetMethod.getTypeParameters())
b.addStatement("bd.addParameter($T.class)", p.asType()); b.addStatement("bd.addParameter($T.class)", p.asType());
b.addStatement("bd.setReturnType($T.class)", targetMethod.getReturnType()); b.addStatement("bd.setReturnType($T.class)", targetMethod.getReturnType());
b.addStatement("return bd.build()"); b.addStatement("return bd.build()");
generated.add(b.build()); generated.add(b.build());
}); });
findAnnotatedMethods(cl, FindField.class) findAnnotatedMethods(cl, FindField.class)
@ -542,18 +530,25 @@ public class LilleroProcessor extends AbstractProcessor {
.filter(m -> !m.getModifiers().contains(Modifier.STATIC)) .filter(m -> !m.getModifiers().contains(Modifier.STATIC))
.filter(m -> !m.getModifiers().contains(Modifier.FINAL)) .filter(m -> !m.getModifiers().contains(Modifier.FINAL))
.forEach(m -> { .forEach(m -> {
VariableElement targetField = findField(m, mapper); VariableElement targetField = findField(m);
MethodSpec.Builder b = MethodSpec.overriding(m); MethodSpec.Builder b = MethodSpec.overriding(m);
String targetParentFQN = findClassName(((TypeElement) targetField.getEnclosingElement()).getQualifiedName().toString(), mapper);
b.addStatement("$T bd = $T.builder($S)", b.addStatement("$T bd = $T.builder($S)",
FieldProxy.Builder.class, FieldProxy.Builder.class,
FieldProxy.class, FieldProxy.class,
targetField.getSimpleName().toString() findMemberName(targetParentFQN, targetField.getSimpleName().toString(), null, mapper)
); );
b.addStatement("bd.setParent($S)", ((TypeElement) targetField.getEnclosingElement()).getQualifiedName().toString()); b.addStatement("bd.setParent($S)", ((TypeElement) targetField.getEnclosingElement()).getQualifiedName().toString());
for(Modifier mod : targetField.getModifiers()) for(Modifier mod : targetField.getModifiers())
b.addStatement("bd.addModifier($L)", mapModifier(mod)); b.addStatement("bd.addModifier($L)", mapModifier(mod));
b.addStatement("bd.setType($T.class)", targetField.asType()); b.addStatement("bd.setType($T.class)", targetField.asType());
b.addStatement("return bd.build()"); b.addStatement("return bd.build()");
generated.add(b.build()); generated.add(b.build());
}); });
return generated; return generated;