mirror of
https://github.com/LegacyModdingMC/UniMix.git
synced 2026-11-22 01:32:12 +00:00
Resolve anonymous inner classes in AP via classpath + ASM where possible
Fixes #518
This commit is contained in:
1 parent
a9581dd7d9
commit
1e1aa7fb52
24 files changed
+606
-79
No files matched your search
@@ -33,8 +33,6 @@ import javax.lang.model.element.ElementKind;
|
||||
import javax.lang.model.element.ExecutableElement;
|
||||
import javax.lang.model.element.TypeElement;
|
||||
import javax.lang.model.element.VariableElement;
|
||||
import javax.lang.model.type.DeclaredType;
|
||||
import javax.lang.model.type.TypeMirror;
|
||||
|
||||
import org.spongepowered.asm.mixin.Mixin;
|
||||
import org.spongepowered.asm.mixin.MixinEnvironment.Option;
|
||||
@@ -62,6 +60,7 @@ import org.spongepowered.tools.obfuscation.interfaces.IObfuscationManager;
|
||||
import org.spongepowered.tools.obfuscation.interfaces.ITypeHandleProvider;
|
||||
import org.spongepowered.tools.obfuscation.mapping.IMappingConsumer;
|
||||
import org.spongepowered.tools.obfuscation.mirror.AnnotationHandle;
|
||||
import org.spongepowered.tools.obfuscation.mirror.MethodHandle;
|
||||
import org.spongepowered.tools.obfuscation.mirror.TypeHandle;
|
||||
import org.spongepowered.tools.obfuscation.mirror.TypeUtils;
|
||||
import org.spongepowered.tools.obfuscation.struct.InjectorRemap;
|
||||
@@ -76,7 +75,7 @@ class AnnotatedMixin implements IMixinContext, IAnnotatedElement {
|
||||
/**
|
||||
* Mixin annotation
|
||||
*/
|
||||
private final AnnotationHandle annotation;
|
||||
private final IAnnotationHandle annotation;
|
||||
|
||||
/**
|
||||
* Messager
|
||||
@@ -106,7 +105,7 @@ class AnnotatedMixin implements IMixinContext, IAnnotatedElement {
|
||||
/**
|
||||
* Methods
|
||||
*/
|
||||
private final List<ExecutableElement> methods;
|
||||
private final List<MethodHandle> methods;
|
||||
|
||||
/**
|
||||
* Mixin class
|
||||
@@ -178,7 +177,7 @@ class AnnotatedMixin implements IMixinContext, IAnnotatedElement {
|
||||
this.messager = ap;
|
||||
this.mixin = type;
|
||||
this.handle = new TypeHandle(type);
|
||||
this.methods = new ArrayList<ExecutableElement>(this.handle.<ExecutableElement>getEnclosedElements(ElementKind.METHOD));
|
||||
this.methods = new ArrayList<MethodHandle>(this.handle.getMethods());
|
||||
this.virtual = this.handle.getAnnotation(Pseudo.class).exists();
|
||||
this.annotation = this.handle.getAnnotation(Mixin.class);
|
||||
this.classRef = TypeUtils.getInternalName(type);
|
||||
@@ -212,9 +211,9 @@ class AnnotatedMixin implements IMixinContext, IAnnotatedElement {
|
||||
|
||||
// Public targets, referenced by class
|
||||
try {
|
||||
for (TypeMirror target : this.annotation.<TypeMirror>getList()) {
|
||||
TypeHandle type = new TypeHandle((DeclaredType)target);
|
||||
if (this.targets.contains(type)) {
|
||||
for (Object target : this.annotation.<Object>getList()) {
|
||||
TypeHandle type = this.typeProvider.getTypeHandle(target);
|
||||
if (type == null || this.targets.contains(type)) {
|
||||
continue;
|
||||
}
|
||||
this.addTarget(type);
|
||||
@@ -237,16 +236,24 @@ class AnnotatedMixin implements IMixinContext, IAnnotatedElement {
|
||||
type = this.typeProvider.getSimulatedHandle(softTarget, this.mixin.asType());
|
||||
} else if (type == null) {
|
||||
this.printMessage(MessageType.MIXIN_SOFT_TARGET_NOT_FOUND, "Mixin target " + softTarget + " could not be found");
|
||||
return null;
|
||||
if (MessageType.MIXIN_SOFT_TARGET_NOT_FOUND.isError()) {
|
||||
return null;
|
||||
}
|
||||
type = this.typeProvider.getSimulatedHandle(softTarget, this.mixin.asType());
|
||||
} else if (type.isImaginary()) {
|
||||
this.printMessage(MessageType.MIXIN_SOFT_TARGET_NOT_RESOLVED, "Mixin target " + softTarget + " could not be fully resolved.",
|
||||
SuppressedBy.UNRESOLVABLE_TARGET);
|
||||
return null;
|
||||
if (MessageType.MIXIN_SOFT_TARGET_NOT_RESOLVED.isError()) {
|
||||
return null;
|
||||
}
|
||||
} else if (type.isPublic()) {
|
||||
SuppressedBy suppressedBy = (type.getPackage().isUnnamed()) ? SuppressedBy.DEFAULT_PACKAGE : SuppressedBy.PUBLIC_TARGET;
|
||||
String must = MessageType.MIXIN_SOFT_TARGET_IS_PUBLIC.isError() ? "must" : "should";
|
||||
this.printMessage(MessageType.MIXIN_SOFT_TARGET_IS_PUBLIC, "Mixin target " + softTarget
|
||||
+ " is public and must be specified in value", suppressedBy);
|
||||
return null;
|
||||
+ " is public and " + must + " be specified in value", suppressedBy);
|
||||
if (MessageType.MIXIN_SOFT_TARGET_IS_PUBLIC.isError()) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
this.addSoftTarget(type, softTarget);
|
||||
if (primaryTarget == null) {
|
||||
@@ -268,14 +275,14 @@ class AnnotatedMixin implements IMixinContext, IAnnotatedElement {
|
||||
* Print a message to the AP messager
|
||||
*/
|
||||
private void printMessage(MessageType type, CharSequence msg) {
|
||||
this.messager.printMessage(type, msg, this.mixin, this.annotation.asMirror());
|
||||
this.messager.printMessage(type, msg, this.mixin, AnnotationHandle.asMirror(this.annotation));
|
||||
}
|
||||
|
||||
/**
|
||||
* Print a suppressible message to the AP messager
|
||||
*/
|
||||
private void printMessage(MessageType type, CharSequence msg, SuppressedBy suppressedBy) {
|
||||
this.messager.printMessage(type, msg, this.mixin, this.annotation.asMirror(), suppressedBy);
|
||||
this.messager.printMessage(type, msg, this.mixin, AnnotationHandle.asMirror(this.annotation), suppressedBy);
|
||||
}
|
||||
|
||||
private void addSoftTarget(TypeHandle type, String reference) {
|
||||
@@ -296,7 +303,7 @@ class AnnotatedMixin implements IMixinContext, IAnnotatedElement {
|
||||
return this.mixin.getSimpleName().toString();
|
||||
}
|
||||
|
||||
public AnnotationHandle getAnnotation() {
|
||||
public IAnnotationHandle getAnnotation() {
|
||||
return this.annotation;
|
||||
}
|
||||
|
||||
@@ -363,13 +370,25 @@ class AnnotatedMixin implements IMixinContext, IAnnotatedElement {
|
||||
}
|
||||
|
||||
private void runFinalValidation() {
|
||||
for (ExecutableElement method : this.methods) {
|
||||
for (MethodHandle method : this.methods) {
|
||||
this.overwrites.registerMerge(method);
|
||||
}
|
||||
}
|
||||
|
||||
private void removeMethod(ExecutableElement method) {
|
||||
MethodHandle handle = null;
|
||||
for (MethodHandle methodHandle : this.methods) {
|
||||
if (methodHandle.getElement() == method) {
|
||||
handle = methodHandle;
|
||||
}
|
||||
}
|
||||
if (handle != null) {
|
||||
this.methods.remove(handle);
|
||||
}
|
||||
}
|
||||
|
||||
public void registerOverwrite(ExecutableElement method, AnnotationHandle overwrite, boolean shouldRemap) {
|
||||
this.methods.remove(method);
|
||||
this.removeMethod(method);
|
||||
this.overwrites.registerOverwrite(new AnnotatedElementOverwrite(method, overwrite, shouldRemap));
|
||||
}
|
||||
|
||||
@@ -378,12 +397,12 @@ class AnnotatedMixin implements IMixinContext, IAnnotatedElement {
|
||||
}
|
||||
|
||||
public void registerShadow(ExecutableElement method, AnnotationHandle shadow, boolean shouldRemap) {
|
||||
this.methods.remove(method);
|
||||
this.removeMethod(method);
|
||||
this.shadows.registerShadow(this.shadows.new AnnotatedElementShadowMethod(method, shadow, shouldRemap));
|
||||
}
|
||||
|
||||
public void registerInjector(ExecutableElement method, AnnotationHandle inject, InjectorRemap remap) {
|
||||
this.methods.remove(method);
|
||||
this.removeMethod(method);
|
||||
AnnotatedElementInjector injectorElement = new AnnotatedElementInjector(method, inject, this, remap);
|
||||
this.injectors.registerInjector(injectorElement);
|
||||
|
||||
@@ -426,12 +445,12 @@ class AnnotatedMixin implements IMixinContext, IAnnotatedElement {
|
||||
}
|
||||
|
||||
public void registerAccessor(ExecutableElement element, AnnotationHandle accessor, boolean shouldRemap) {
|
||||
this.methods.remove(element);
|
||||
this.removeMethod(element);
|
||||
this.accessors.registerAccessor(new AnnotatedElementAccessor(element, accessor, this, shouldRemap));
|
||||
}
|
||||
|
||||
public void registerInvoker(ExecutableElement element, AnnotationHandle invoker, boolean shouldRemap) {
|
||||
this.methods.remove(element);
|
||||
this.removeMethod(element);
|
||||
this.accessors.registerAccessor(new AnnotatedElementInvoker(element, invoker, this, shouldRemap));
|
||||
}
|
||||
|
||||
|
||||
@@ -38,6 +38,7 @@ import org.spongepowered.asm.mixin.refmap.IMixinContext;
|
||||
import org.spongepowered.asm.obfuscation.mapping.IMapping;
|
||||
import org.spongepowered.asm.obfuscation.mapping.common.MappingField;
|
||||
import org.spongepowered.asm.obfuscation.mapping.common.MappingMethod;
|
||||
import org.spongepowered.asm.util.Bytecode.Visibility;
|
||||
import org.spongepowered.asm.util.ConstraintParser;
|
||||
import org.spongepowered.asm.util.ConstraintParser.Constraint;
|
||||
import org.spongepowered.asm.util.asm.IAnnotatedElement;
|
||||
@@ -55,7 +56,6 @@ import org.spongepowered.tools.obfuscation.mirror.FieldHandle;
|
||||
import org.spongepowered.tools.obfuscation.mirror.MethodHandle;
|
||||
import org.spongepowered.tools.obfuscation.mirror.TypeHandle;
|
||||
import org.spongepowered.tools.obfuscation.mirror.TypeUtils;
|
||||
import org.spongepowered.tools.obfuscation.mirror.Visibility;
|
||||
|
||||
/**
|
||||
* Base class for module for {@link AnnotatedMixin} which handle different
|
||||
@@ -194,6 +194,11 @@ abstract class AnnotatedMixinElementHandler {
|
||||
this.aliases = annotation.<String>getList("aliases");
|
||||
}
|
||||
|
||||
public AliasedElementName(MethodHandle method, AnnotationHandle annotation) {
|
||||
this.originalName = method.getName();
|
||||
this.aliases = annotation.<String>getList("aliases");
|
||||
}
|
||||
|
||||
public AliasedElementName setCaseSensitive(boolean caseSensitive) {
|
||||
this.caseSensitive = caseSensitive;
|
||||
return this;
|
||||
|
||||
+3
-3
@@ -304,17 +304,17 @@ class AnnotatedMixinElementHandlerAccessor extends AnnotatedMixinElementHandler
|
||||
}
|
||||
|
||||
private void registerFactoryForTarget(AnnotatedElementInvoker elem, TypeHandle target) {
|
||||
EquivalencyResult equivalency = TypeUtils.isEquivalentType(this.ap.getProcessingEnvironment(), elem.getReturnType(), target.getType());
|
||||
EquivalencyResult equivalency = TypeUtils.isEquivalentType(this.ap.getProcessingEnvironment(), elem.getReturnType(), target.getTypeMirror());
|
||||
if (equivalency.type != Equivalency.EQUIVALENT) {
|
||||
if (equivalency.type == Equivalency.EQUIVALENT_BUT_RAW && equivalency.rawType == 1) {
|
||||
elem.printMessage(this.ap, MessageType.INVOKER_RAW_RETURN_TYPE, "Raw return type for Factory @Invoker", SuppressedBy.RAW_TYPES);
|
||||
} else if (equivalency.type == Equivalency.BOUNDS_MISMATCH) {
|
||||
elem.printMessage(this.ap, MessageType.FACTORY_INVOKER_GENERIC_ARGS, "Invalid Factory @Invoker return type, generic type args of "
|
||||
+ target.getType() + " are incompatible with " + elem.getReturnType() + ". " + equivalency);
|
||||
+ target.getTypeMirror() + " are incompatible with " + elem.getReturnType() + ". " + equivalency);
|
||||
return;
|
||||
} else {
|
||||
elem.printMessage(this.ap, MessageType.FACTORY_INVOKER_RETURN_TYPE, "Invalid Factory @Invoker return type, expected "
|
||||
+ target.getType() + " but found " + elem.getReturnType());
|
||||
+ target.getTypeMirror() + " but found " + elem.getReturnType());
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
+5
-2
@@ -34,6 +34,7 @@ import org.spongepowered.tools.obfuscation.Mappings.MappingConflictException;
|
||||
import org.spongepowered.tools.obfuscation.interfaces.IMessagerEx.MessageType;
|
||||
import org.spongepowered.tools.obfuscation.interfaces.IMixinAnnotationProcessor;
|
||||
import org.spongepowered.tools.obfuscation.mirror.AnnotationHandle;
|
||||
import org.spongepowered.tools.obfuscation.mirror.MethodHandle;
|
||||
import org.spongepowered.tools.obfuscation.mirror.TypeHandle;
|
||||
|
||||
/**
|
||||
@@ -63,8 +64,10 @@ class AnnotatedMixinElementHandlerOverwrite extends AnnotatedMixinElementHandler
|
||||
super(ap, mixin);
|
||||
}
|
||||
|
||||
public void registerMerge(ExecutableElement method) {
|
||||
this.validateTargetMethod(method, null, new AliasedElementName(method, AnnotationHandle.MISSING), "overwrite", true, true);
|
||||
public void registerMerge(MethodHandle method) {
|
||||
if (!method.isImaginary()) {
|
||||
this.validateTargetMethod(method.getElement(), null, new AliasedElementName(method, AnnotationHandle.MISSING), "overwrite", true, true);
|
||||
}
|
||||
}
|
||||
|
||||
public void registerOverwrite(AnnotatedElementOverwrite elem) {
|
||||
|
||||
+5
-8
@@ -26,8 +26,6 @@ package org.spongepowered.tools.obfuscation;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import javax.lang.model.element.ElementKind;
|
||||
import javax.lang.model.element.ExecutableElement;
|
||||
import javax.lang.model.type.DeclaredType;
|
||||
|
||||
import org.spongepowered.asm.mixin.Interface.Remap;
|
||||
@@ -37,7 +35,6 @@ import org.spongepowered.tools.obfuscation.interfaces.IMessagerEx.MessageType;
|
||||
import org.spongepowered.tools.obfuscation.interfaces.IMixinAnnotationProcessor;
|
||||
import org.spongepowered.tools.obfuscation.mirror.AnnotationHandle;
|
||||
import org.spongepowered.tools.obfuscation.mirror.MethodHandle;
|
||||
import org.spongepowered.tools.obfuscation.mirror.TypeUtils;
|
||||
import org.spongepowered.tools.obfuscation.mirror.TypeHandle;
|
||||
|
||||
/**
|
||||
@@ -99,7 +96,7 @@ class AnnotatedMixinElementHandlerSoftImplements extends AnnotatedMixinElementHa
|
||||
* @param prefix Prefix declared in the soft-implements decoration
|
||||
*/
|
||||
private void processSoftImplements(Remap remap, TypeHandle iface, String prefix) {
|
||||
for (ExecutableElement method : iface.<ExecutableElement>getEnclosedElements(ElementKind.METHOD)) {
|
||||
for (MethodHandle method : iface.getMethods()) {
|
||||
this.processMethod(remap, iface, prefix, method);
|
||||
}
|
||||
|
||||
@@ -118,10 +115,10 @@ class AnnotatedMixinElementHandlerSoftImplements extends AnnotatedMixinElementHa
|
||||
* @param prefix Prefix declared in the soft-implements decoration
|
||||
* @param method Interface method to search for
|
||||
*/
|
||||
private void processMethod(Remap remap, TypeHandle iface, String prefix, ExecutableElement method) {
|
||||
String name = method.getSimpleName().toString();
|
||||
String sig = TypeUtils.getJavaSignature(method);
|
||||
String desc = TypeUtils.getDescriptor(method);
|
||||
private void processMethod(Remap remap, TypeHandle iface, String prefix, MethodHandle method) {
|
||||
String name = method.getName();
|
||||
String sig = method.getJavaSignature();
|
||||
String desc = method.getDesc();
|
||||
|
||||
if (remap != Remap.ONLY_PREFIXED) {
|
||||
MethodHandle mixinMethod = this.mixin.getHandle().findMethod(name, sig);
|
||||
|
||||
@@ -54,6 +54,7 @@ import javax.tools.Diagnostic.Kind;
|
||||
import javax.tools.FileObject;
|
||||
import javax.tools.StandardLocation;
|
||||
|
||||
import org.objectweb.asm.Type;
|
||||
import org.spongepowered.asm.launch.MixinBootstrap;
|
||||
import org.spongepowered.asm.mixin.Overwrite;
|
||||
import org.spongepowered.asm.mixin.gen.Accessor;
|
||||
@@ -69,6 +70,7 @@ import org.spongepowered.tools.obfuscation.interfaces.IObfuscationManager;
|
||||
import org.spongepowered.tools.obfuscation.interfaces.ITypeHandleProvider;
|
||||
import org.spongepowered.tools.obfuscation.mirror.AnnotationHandle;
|
||||
import org.spongepowered.tools.obfuscation.mirror.TypeHandle;
|
||||
import org.spongepowered.tools.obfuscation.mirror.TypeHandleASM;
|
||||
import org.spongepowered.tools.obfuscation.mirror.TypeHandleSimulated;
|
||||
import org.spongepowered.tools.obfuscation.mirror.TypeReference;
|
||||
import org.spongepowered.tools.obfuscation.struct.InjectorRemap;
|
||||
@@ -377,8 +379,8 @@ final class AnnotatedMixins implements IMixinAnnotationProcessor, ITokenProvider
|
||||
|
||||
for (TypeReference mixin : this.targets.getMixinsTargeting(targetType)) {
|
||||
TypeHandle handle = mixin.getHandle(this.processingEnv);
|
||||
if (handle != null) {
|
||||
minions.add(handle.getType());
|
||||
if (handle != null && handle.hasTypeMirror()) {
|
||||
minions.add(handle.getTypeMirror());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -697,13 +699,43 @@ final class AnnotatedMixins implements IMixinAnnotationProcessor, ITokenProvider
|
||||
|
||||
int lastDotPos = name.lastIndexOf('.');
|
||||
if (lastDotPos > -1) {
|
||||
String pkg = name.substring(0, lastDotPos);
|
||||
PackageElement packageElement = elements.getPackageElement(pkg);
|
||||
if (packageElement != null) {
|
||||
return new TypeHandle(packageElement, name);
|
||||
String pkgName = name.substring(0, lastDotPos);
|
||||
PackageElement pkg = elements.getPackageElement(pkgName);
|
||||
if (pkg != null) {
|
||||
// If we can resolve the package but not the class, it's possible
|
||||
// we're dealing with a class that mirror can't access, such as
|
||||
// an anonymous class. The class might be available via the
|
||||
// classpath though, so let's attempt to read the class with ASM
|
||||
TypeHandle asmTypeHandle = TypeHandleASM.of(pkg, name.substring(lastDotPos + 1), this);
|
||||
if (asmTypeHandle != null) {
|
||||
return asmTypeHandle;
|
||||
}
|
||||
|
||||
// Couldn't resolve the class, so just return an imaginary handle
|
||||
return new TypeHandle(pkg, name);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a TypeHandle representing the supplied type in the current processing
|
||||
* environment
|
||||
*/
|
||||
@Override
|
||||
public TypeHandle getTypeHandle(Object type) {
|
||||
if (type instanceof TypeHandle) {
|
||||
return (TypeHandle)type;
|
||||
} else if (type instanceof DeclaredType) {
|
||||
return new TypeHandle((DeclaredType)type);
|
||||
} else if (type instanceof Type) {
|
||||
return this.getTypeHandle(((Type)type).getClassName());
|
||||
} else if (type instanceof TypeElement) {
|
||||
return new TypeHandle((DeclaredType)((TypeElement)type).asType());
|
||||
} else if (type instanceof String) {
|
||||
return this.getTypeHandle(type.toString());
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
|
||||
@@ -30,11 +30,11 @@ import javax.annotation.processing.ProcessingEnvironment;
|
||||
import javax.lang.model.element.TypeElement;
|
||||
import javax.lang.model.type.TypeMirror;
|
||||
|
||||
import org.spongepowered.asm.util.asm.IAnnotationHandle;
|
||||
import org.spongepowered.tools.obfuscation.interfaces.IMessagerSuppressible;
|
||||
import org.spongepowered.tools.obfuscation.interfaces.IMixinAnnotationProcessor;
|
||||
import org.spongepowered.tools.obfuscation.interfaces.IMixinValidator;
|
||||
import org.spongepowered.tools.obfuscation.interfaces.IOptionProvider;
|
||||
import org.spongepowered.tools.obfuscation.mirror.AnnotationHandle;
|
||||
import org.spongepowered.tools.obfuscation.mirror.TypeHandle;
|
||||
|
||||
/**
|
||||
@@ -84,7 +84,7 @@ public abstract class MixinValidator implements IMixinValidator {
|
||||
* java.util.Collection)
|
||||
*/
|
||||
@Override
|
||||
public final boolean validate(ValidationPass pass, TypeElement mixin, AnnotationHandle annotation, Collection<TypeHandle> targets) {
|
||||
public final boolean validate(ValidationPass pass, TypeElement mixin, IAnnotationHandle annotation, Collection<TypeHandle> targets) {
|
||||
if (pass != this.pass) {
|
||||
return true;
|
||||
}
|
||||
@@ -92,7 +92,7 @@ public abstract class MixinValidator implements IMixinValidator {
|
||||
return this.validate(mixin, annotation, targets);
|
||||
}
|
||||
|
||||
protected abstract boolean validate(TypeElement mixin, AnnotationHandle annotation, Collection<TypeHandle> targets);
|
||||
protected abstract boolean validate(TypeElement mixin, IAnnotationHandle annotation, Collection<TypeHandle> targets);
|
||||
|
||||
protected final Collection<TypeMirror> getMixinsTargeting(TypeMirror targetType) {
|
||||
return AnnotatedMixins.getMixinsForEnvironment(this.processingEnv).getMixinsTargeting(targetType);
|
||||
|
||||
@@ -25,7 +25,6 @@
|
||||
package org.spongepowered.tools.obfuscation.interfaces;
|
||||
|
||||
import java.util.HashSet;
|
||||
import java.util.Locale;
|
||||
import java.util.Set;
|
||||
|
||||
import javax.annotation.processing.Messager;
|
||||
@@ -304,6 +303,13 @@ public interface IMessagerEx extends Messager {
|
||||
this.originalKind = this.kind = kind;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get whether the message is treated as an error
|
||||
*/
|
||||
public boolean isError() {
|
||||
return this.kind == Kind.ERROR;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the current message kind
|
||||
*/
|
||||
|
||||
@@ -28,7 +28,7 @@ import java.util.Collection;
|
||||
|
||||
import javax.lang.model.element.TypeElement;
|
||||
|
||||
import org.spongepowered.tools.obfuscation.mirror.AnnotationHandle;
|
||||
import org.spongepowered.asm.util.asm.IAnnotationHandle;
|
||||
import org.spongepowered.tools.obfuscation.mirror.TypeHandle;
|
||||
|
||||
/**
|
||||
@@ -56,6 +56,6 @@ public interface IMixinValidator {
|
||||
*
|
||||
* @return False to halt processing of further validators
|
||||
*/
|
||||
public abstract boolean validate(ValidationPass pass, TypeElement mixin, AnnotationHandle annotation, Collection<TypeHandle> targets);
|
||||
public abstract boolean validate(ValidationPass pass, TypeElement mixin, IAnnotationHandle annotation, Collection<TypeHandle> targets);
|
||||
|
||||
}
|
||||
@@ -40,6 +40,15 @@ public interface ITypeHandleProvider {
|
||||
* @return A new type handle or null if the type could not be found
|
||||
*/
|
||||
public abstract TypeHandle getTypeHandle(String name);
|
||||
|
||||
/**
|
||||
* Get a type handle for the specified type
|
||||
*
|
||||
* @param type Type source, can be a String, TypeMirror, TypeElement or an
|
||||
* existing TypeHandle
|
||||
* @return TypeHandle
|
||||
*/
|
||||
public abstract TypeHandle getTypeHandle(Object type);
|
||||
|
||||
/**
|
||||
* Generate a type handle for the specified type, simulate the target using
|
||||
|
||||
@@ -164,6 +164,7 @@ public final class AnnotationHandle implements IAnnotationHandle {
|
||||
* @param defaultValue default value to return if value is not present
|
||||
* @return value or default if not present or not set
|
||||
*/
|
||||
@Override
|
||||
public boolean getBoolean(String key, boolean defaultValue) {
|
||||
return this.<Boolean>getValue(key, Boolean.valueOf(defaultValue)).booleanValue();
|
||||
}
|
||||
@@ -195,6 +196,7 @@ public final class AnnotationHandle implements IAnnotationHandle {
|
||||
* @param <T> list element duck type
|
||||
* @return list of values
|
||||
*/
|
||||
@Override
|
||||
public <T> List<T> getList() {
|
||||
return this.<T>getList("value");
|
||||
}
|
||||
@@ -306,6 +308,10 @@ public final class AnnotationHandle implements IAnnotationHandle {
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
public static AnnotationMirror asMirror(IAnnotationHandle handle) {
|
||||
return handle instanceof AnnotationHandle ? ((AnnotationHandle)handle).asMirror() : null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a new annotation handle for the supplied annotation mirror
|
||||
@@ -329,4 +335,5 @@ public final class AnnotationHandle implements IAnnotationHandle {
|
||||
public static AnnotationHandle of(Element elem, Class<? extends Annotation> annotationClass) {
|
||||
return new AnnotationHandle(AnnotationHandle.getAnnotation(elem, annotationClass));
|
||||
}
|
||||
|
||||
}
|
||||
@@ -28,6 +28,7 @@ import javax.lang.model.element.TypeElement;
|
||||
import javax.lang.model.element.VariableElement;
|
||||
|
||||
import org.spongepowered.asm.obfuscation.mapping.common.MappingField;
|
||||
import org.spongepowered.asm.util.Bytecode.Visibility;
|
||||
|
||||
import com.google.common.base.Strings;
|
||||
|
||||
@@ -63,10 +64,18 @@ public class FieldHandle extends MemberHandle<MappingField> {
|
||||
this(owner, element, rawType, TypeUtils.getName(element), TypeUtils.getInternalName(element));
|
||||
}
|
||||
|
||||
public FieldHandle(TypeHandle owner, String name, String desc) {
|
||||
this(owner, null, false, name, desc);
|
||||
}
|
||||
|
||||
public FieldHandle(String owner, String name, String desc) {
|
||||
this(owner, null, false, name, desc);
|
||||
}
|
||||
|
||||
public FieldHandle(TypeHandle owner, VariableElement element, boolean rawType, String name, String desc) {
|
||||
this(owner != null ? owner.getName() : null, element, rawType, name, desc);
|
||||
}
|
||||
|
||||
private FieldHandle(String owner, VariableElement element, boolean rawType, String name, String desc) {
|
||||
super(owner, name, desc);
|
||||
this.element = element;
|
||||
|
||||
+21
-8
@@ -24,15 +24,28 @@
|
||||
*/
|
||||
package org.spongepowered.tools.obfuscation.mirror;
|
||||
|
||||
import org.objectweb.asm.tree.FieldNode;
|
||||
import org.spongepowered.asm.util.Bytecode;
|
||||
import org.spongepowered.asm.util.Bytecode.Visibility;
|
||||
|
||||
/**
|
||||
* Ordinal member visibility level. This is used to represent visibility of
|
||||
* a member in a formal way from lowest to highest.
|
||||
* A {@link FieldHandle} for classpath classes being read with ASM
|
||||
*/
|
||||
public enum Visibility {
|
||||
|
||||
PRIVATE,
|
||||
PROTECTED,
|
||||
PACKAGE,
|
||||
PUBLIC
|
||||
public class FieldHandleASM extends FieldHandle {
|
||||
|
||||
/**
|
||||
* The field from ASM
|
||||
*/
|
||||
private final FieldNode field;
|
||||
|
||||
public FieldHandleASM(TypeHandle owner, FieldNode field) {
|
||||
super(owner, field.name, field.desc);
|
||||
this.field = field;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Visibility getVisibility() {
|
||||
return Bytecode.getVisibility(this.field);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -25,6 +25,7 @@
|
||||
package org.spongepowered.tools.obfuscation.mirror;
|
||||
|
||||
import org.spongepowered.asm.obfuscation.mapping.IMapping;
|
||||
import org.spongepowered.asm.util.Bytecode.Visibility;
|
||||
|
||||
/**
|
||||
* Abstract base class for element handles
|
||||
|
||||
@@ -27,6 +27,7 @@ package org.spongepowered.tools.obfuscation.mirror;
|
||||
import javax.lang.model.element.ExecutableElement;
|
||||
|
||||
import org.spongepowered.asm.obfuscation.mapping.common.MappingMethod;
|
||||
import org.spongepowered.asm.util.Bytecode.Visibility;
|
||||
import org.spongepowered.tools.obfuscation.mirror.mapping.MappingMethodResolvable;
|
||||
|
||||
import com.google.common.base.Strings;
|
||||
@@ -74,6 +75,14 @@ public class MethodHandle extends MemberHandle<MappingMethod> {
|
||||
return this.element;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the java signature (similar to descriptor but with java types in
|
||||
* source form) for this element
|
||||
*/
|
||||
public String getJavaSignature() {
|
||||
return TypeUtils.getJavaSignature(this.element);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Visibility getVisibility() {
|
||||
return TypeUtils.getVisibility(this.element);
|
||||
@@ -97,4 +106,5 @@ public class MethodHandle extends MemberHandle<MappingMethod> {
|
||||
String desc = Strings.nullToEmpty(this.getDesc());
|
||||
return String.format("%s%s%s", owner, name, desc);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
/*
|
||||
* This file is part of Mixin, licensed under the MIT License (MIT).
|
||||
*
|
||||
* Copyright (c) SpongePowered <https://www.spongepowered.org>
|
||||
* Copyright (c) contributors
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
package org.spongepowered.tools.obfuscation.mirror;
|
||||
|
||||
import org.objectweb.asm.tree.MethodNode;
|
||||
import org.spongepowered.asm.util.Bytecode;
|
||||
import org.spongepowered.asm.util.Bytecode.Visibility;
|
||||
|
||||
/**
|
||||
* A {@link MethodHandle} for classpath classes being read with ASM
|
||||
*/
|
||||
public class MethodHandleASM extends MethodHandle {
|
||||
|
||||
/**
|
||||
* The method from ASM
|
||||
*/
|
||||
private final MethodNode method;
|
||||
|
||||
public MethodHandleASM(TypeHandle owner, MethodNode method) {
|
||||
super(owner, method.name, method.desc);
|
||||
this.method = method;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getJavaSignature() {
|
||||
return TypeUtils.getJavaSignature(this.method.desc);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Visibility getVisibility() {
|
||||
return Bytecode.getVisibility(this.method);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -25,6 +25,7 @@
|
||||
package org.spongepowered.tools.obfuscation.mirror;
|
||||
|
||||
import java.lang.annotation.Annotation;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
|
||||
@@ -42,6 +43,7 @@ import javax.lang.model.type.TypeMirror;
|
||||
import org.spongepowered.asm.mixin.injection.selectors.ITargetSelectorByName;
|
||||
import org.spongepowered.asm.obfuscation.mapping.common.MappingMethod;
|
||||
import org.spongepowered.asm.util.Bytecode;
|
||||
import org.spongepowered.asm.util.asm.IAnnotationHandle;
|
||||
import org.spongepowered.tools.obfuscation.mirror.mapping.MappingMethodResolvable;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
@@ -159,14 +161,14 @@ public class TypeHandle {
|
||||
* @return new annotation handle, call <tt>exists</tt> on the returned
|
||||
* handle to determine whether the annotation is present
|
||||
*/
|
||||
public AnnotationHandle getAnnotation(Class<? extends Annotation> annotationClass) {
|
||||
public IAnnotationHandle getAnnotation(Class<? extends Annotation> annotationClass) {
|
||||
return AnnotationHandle.of(this.getTargetElement(), annotationClass);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns enclosed elements (methods, fields, etc.)
|
||||
*/
|
||||
public final List<? extends Element> getEnclosedElements() {
|
||||
protected final List<? extends Element> getEnclosedElements() {
|
||||
return TypeHandle.getEnclosedElements(this.getTargetElement());
|
||||
}
|
||||
|
||||
@@ -176,15 +178,25 @@ public class TypeHandle {
|
||||
* @param kind types of element to return
|
||||
* @param <T> list element type
|
||||
*/
|
||||
public <T extends Element> List<T> getEnclosedElements(ElementKind... kind) {
|
||||
protected <T extends Element> List<T> getEnclosedElements(ElementKind... kind) {
|
||||
return TypeHandle.getEnclosedElements(this.getTargetElement(), kind);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get whether the type handle can return a type mirror for the represented
|
||||
* type. This is true only for types returned by mirror and is not available
|
||||
* for simulated types or classpath types inaccessible via mirror (eg. anon
|
||||
* classes)
|
||||
*/
|
||||
public boolean hasTypeMirror() {
|
||||
return this.getTargetElement() != null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the enclosed element as a type mirror, or null if this is an
|
||||
* imaginary type
|
||||
*/
|
||||
public TypeMirror getType() {
|
||||
public TypeMirror getTypeMirror() {
|
||||
return this.getTargetElement() != null ? this.getTargetElement().asType() : null;
|
||||
}
|
||||
|
||||
@@ -218,9 +230,20 @@ public class TypeHandle {
|
||||
for (TypeMirror iface : this.getTargetElement().getInterfaces()) {
|
||||
list.add(new TypeHandle((DeclaredType)iface));
|
||||
}
|
||||
|
||||
return list.build();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get methods in this type
|
||||
*/
|
||||
public List<MethodHandle> getMethods() {
|
||||
List<MethodHandle> methods = new ArrayList<MethodHandle>();
|
||||
for (ExecutableElement method : this.<ExecutableElement>getEnclosedElements(ElementKind.METHOD)) {
|
||||
MethodHandle handle = new MethodHandle(this, method);
|
||||
methods.add(handle);
|
||||
}
|
||||
return methods;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get whether the element is probably public
|
||||
@@ -239,7 +262,8 @@ public class TypeHandle {
|
||||
}
|
||||
|
||||
/**
|
||||
* Get whether the element is imaginary (inaccessible via mirror)
|
||||
* Get whether the element is imaginary (inaccessible via mirror or
|
||||
* classpath)
|
||||
*/
|
||||
public boolean isImaginary() {
|
||||
return this.getTargetElement() == null;
|
||||
@@ -310,11 +334,11 @@ public class TypeHandle {
|
||||
* of the supplied element
|
||||
*
|
||||
* @param element Element to match
|
||||
* @param caseSensitive True if case-sensitive comparison should be used
|
||||
* @param matchCase True if case-sensitive comparison should be used
|
||||
* @return handle to the discovered field if matched or null if no match
|
||||
*/
|
||||
public final FieldHandle findField(VariableElement element, boolean caseSensitive) {
|
||||
return this.findField(element.getSimpleName().toString(), TypeUtils.getTypeName(element.asType()), caseSensitive);
|
||||
public final FieldHandle findField(VariableElement element, boolean matchCase) {
|
||||
return this.findField(element.getSimpleName().toString(), TypeUtils.getTypeName(element.asType()), matchCase);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -335,16 +359,16 @@ public class TypeHandle {
|
||||
*
|
||||
* @param name Field name to search for
|
||||
* @param type Field descriptor (java-style)
|
||||
* @param caseSensitive True if case-sensitive comparison should be used
|
||||
* @param matchCase True if case-sensitive comparison should be used
|
||||
* @return handle to the discovered field if matched or null if no match
|
||||
*/
|
||||
public FieldHandle findField(String name, String type, boolean caseSensitive) {
|
||||
public FieldHandle findField(String name, String type, boolean matchCase) {
|
||||
String rawType = TypeUtils.stripGenerics(type);
|
||||
|
||||
for (VariableElement field : this.<VariableElement>getEnclosedElements(ElementKind.FIELD)) {
|
||||
if (TypeHandle.compareElement(field, name, type, caseSensitive)) {
|
||||
if (TypeHandle.compareElement(field, name, type, matchCase)) {
|
||||
return new FieldHandle(this.getTargetElement(), field);
|
||||
} else if (TypeHandle.compareElement(field, name, rawType, caseSensitive)) {
|
||||
} else if (TypeHandle.compareElement(field, name, rawType, matchCase)) {
|
||||
return new FieldHandle(this.getTargetElement(), field, true);
|
||||
}
|
||||
}
|
||||
@@ -368,11 +392,11 @@ public class TypeHandle {
|
||||
* type of the supplied element
|
||||
*
|
||||
* @param element Element to match
|
||||
* @param caseSensitive True if case-sensitive comparison should be used
|
||||
* @param matchCase True if case-sensitive comparison should be used
|
||||
* @return handle to the discovered method if matched or null if no match
|
||||
*/
|
||||
public final MethodHandle findMethod(ExecutableElement element, boolean caseSensitive) {
|
||||
return this.findMethod(element.getSimpleName().toString(), TypeUtils.getJavaSignature(element), caseSensitive);
|
||||
public final MethodHandle findMethod(ExecutableElement element, boolean matchCase) {
|
||||
return this.findMethod(element.getSimpleName().toString(), TypeUtils.getJavaSignature(element), matchCase);
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -0,0 +1,302 @@
|
||||
/*
|
||||
* This file is part of Mixin, licensed under the MIT License (MIT).
|
||||
*
|
||||
* Copyright (c) SpongePowered <https://www.spongepowered.org>
|
||||
* Copyright (c) contributors
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
package org.spongepowered.tools.obfuscation.mirror;
|
||||
|
||||
import java.io.FileNotFoundException;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.lang.annotation.Annotation;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
import javax.annotation.processing.Filer;
|
||||
import javax.lang.model.element.Element;
|
||||
import javax.lang.model.element.ElementKind;
|
||||
import javax.lang.model.element.PackageElement;
|
||||
import javax.lang.model.type.TypeMirror;
|
||||
import javax.tools.StandardLocation;
|
||||
|
||||
import org.objectweb.asm.ClassReader;
|
||||
import org.objectweb.asm.Opcodes;
|
||||
import org.objectweb.asm.tree.AnnotationNode;
|
||||
import org.objectweb.asm.tree.ClassNode;
|
||||
import org.objectweb.asm.tree.FieldNode;
|
||||
import org.objectweb.asm.tree.MethodNode;
|
||||
import org.spongepowered.asm.mixin.injection.selectors.ITargetSelectorByName;
|
||||
import org.spongepowered.asm.util.Annotations;
|
||||
import org.spongepowered.asm.util.asm.IAnnotationHandle;
|
||||
import org.spongepowered.tools.obfuscation.interfaces.IMixinAnnotationProcessor;
|
||||
import org.spongepowered.tools.obfuscation.interfaces.ITypeHandleProvider;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
import com.google.common.collect.ImmutableList.Builder;
|
||||
|
||||
/**
|
||||
* The specs of JSR 269 mean that mirror will only give us things visible down
|
||||
* to the method level and no further. This means that classes declared inside
|
||||
* method bodies (anonymous classes) cannot be accessed via mirror. However for
|
||||
* classpath classes we can at least retrieve the class bytecode via the AP
|
||||
* Filer, so this class is used to wrap an ASM {@link ClassNode} up as a
|
||||
* {@link TypeHandle} so that the mixin AP can use it to resolve things. It
|
||||
* delegates back to {@link ITypeHandleProvider} where appropriate so that
|
||||
* related classes (superclasses, interfaces, etc.) will be backed by mirror
|
||||
* TypeElements wherever possible.
|
||||
*/
|
||||
public class TypeHandleASM extends TypeHandle {
|
||||
|
||||
/**
|
||||
* Cache ASM type handles to avoid unnecessary churn
|
||||
*/
|
||||
private static final Map<String, TypeHandleASM> cache = new HashMap<String, TypeHandleASM>();
|
||||
|
||||
/**
|
||||
* ClassNode used for accessing information when not accessible via mirror
|
||||
*/
|
||||
private final ClassNode classNode;
|
||||
|
||||
/**
|
||||
* Type handle provider, we need this since we have to resolve type handles
|
||||
* for related classes (eg. superclass) without using mirror
|
||||
*/
|
||||
private final ITypeHandleProvider typeProvider;
|
||||
|
||||
/**
|
||||
* Ctor for imaginary elements, require the enclosing package and the FQ
|
||||
* name
|
||||
*
|
||||
* @param pkg Package
|
||||
* @param name FQ class name
|
||||
*/
|
||||
protected TypeHandleASM(PackageElement pkg, String name, ClassNode classNode, ITypeHandleProvider typeProvider) {
|
||||
super(pkg, name);
|
||||
this.classNode = classNode;
|
||||
this.typeProvider = typeProvider;
|
||||
}
|
||||
|
||||
/* (non-Javadoc)
|
||||
* @see org.spongepowered.tools.obfuscation.mirror.TypeHandle
|
||||
* #getAnnotation(java.lang.Class)
|
||||
*/
|
||||
@Override
|
||||
public IAnnotationHandle getAnnotation(Class<? extends Annotation> annotationClass) {
|
||||
AnnotationNode visibleAnnotation = Annotations.getVisible(this.classNode, annotationClass);
|
||||
if (visibleAnnotation != null) {
|
||||
return Annotations.handleOf(visibleAnnotation);
|
||||
}
|
||||
AnnotationNode invisibleAnnotation = Annotations.getInvisible(this.classNode, annotationClass);
|
||||
if (invisibleAnnotation != null) {
|
||||
return Annotations.handleOf(invisibleAnnotation);
|
||||
}
|
||||
return AnnotationHandle.of(null);
|
||||
}
|
||||
|
||||
/* (non-Javadoc)
|
||||
* @see org.spongepowered.tools.obfuscation.mirror.TypeHandle
|
||||
* #getEnclosedElements(javax.lang.model.element.ElementKind[])
|
||||
*/
|
||||
@Override
|
||||
public <T extends Element> List<T> getEnclosedElements(ElementKind... kind) {
|
||||
return super.getEnclosedElements(kind);
|
||||
}
|
||||
|
||||
/* (non-Javadoc)
|
||||
* @see org.spongepowered.tools.obfuscation.mirror.TypeHandle
|
||||
* #hasTypeMirror()
|
||||
*/
|
||||
@Override
|
||||
public boolean hasTypeMirror() {
|
||||
return false;
|
||||
}
|
||||
|
||||
/* (non-Javadoc)
|
||||
* @see org.spongepowered.tools.obfuscation.mirror.TypeHandle
|
||||
* #getTypeMirror()
|
||||
*/
|
||||
@Override
|
||||
public TypeMirror getTypeMirror() {
|
||||
return null;
|
||||
}
|
||||
|
||||
/* (non-Javadoc)
|
||||
* @see org.spongepowered.tools.obfuscation.mirror.TypeHandle
|
||||
* #getSuperclass()
|
||||
*/
|
||||
@Override
|
||||
public TypeHandle getSuperclass() {
|
||||
TypeHandle superClass = this.typeProvider.getTypeHandle(this.classNode.superName);
|
||||
return superClass;
|
||||
}
|
||||
|
||||
/* (non-Javadoc)
|
||||
* @see org.spongepowered.tools.obfuscation.mirror.TypeHandle
|
||||
* #getInterfaces()
|
||||
*/
|
||||
@Override
|
||||
public List<TypeHandle> getInterfaces() {
|
||||
Builder<TypeHandle> list = ImmutableList.<TypeHandle>builder();
|
||||
for (String ifaceName : this.classNode.interfaces) {
|
||||
TypeHandle iface = this.typeProvider.getTypeHandle(ifaceName);
|
||||
if (iface != null) {
|
||||
list.add(iface);
|
||||
}
|
||||
}
|
||||
return list.build();
|
||||
}
|
||||
|
||||
/* (non-Javadoc)
|
||||
* @see org.spongepowered.tools.obfuscation.mirror.TypeHandle#getMethods()
|
||||
*/
|
||||
@Override
|
||||
public List<MethodHandle> getMethods() {
|
||||
Builder<MethodHandle> methods = ImmutableList.<MethodHandle>builder();
|
||||
try {
|
||||
for (MethodNode method : this.classNode.methods) {
|
||||
if (!method.name.startsWith("<") && (method.access & Opcodes.ACC_SYNTHETIC) == 0) {
|
||||
methods.add(new MethodHandleASM(this, method));
|
||||
}
|
||||
}
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace();
|
||||
}
|
||||
return methods.build();
|
||||
}
|
||||
|
||||
/* (non-Javadoc)
|
||||
* @see org.spongepowered.tools.obfuscation.mirror.TypeHandle#isPublic()
|
||||
*/
|
||||
@Override
|
||||
public boolean isPublic() {
|
||||
return (this.classNode.access & Opcodes.ACC_PUBLIC) != 0;
|
||||
}
|
||||
|
||||
/* (non-Javadoc)
|
||||
* @see org.spongepowered.tools.obfuscation.mirror.TypeHandle#isImaginary()
|
||||
*/
|
||||
@Override
|
||||
public boolean isImaginary() {
|
||||
return false;
|
||||
}
|
||||
|
||||
/* (non-Javadoc)
|
||||
* @see org.spongepowered.tools.obfuscation.mirror.TypeHandle#findDescriptor
|
||||
* (org.spongepowered.asm.mixin.injection.selectors.ITargetSelectorByName)
|
||||
*/
|
||||
@Override
|
||||
public String findDescriptor(ITargetSelectorByName selector) {
|
||||
String desc = selector.getDesc();
|
||||
if (desc == null) {
|
||||
for (MethodNode method : this.classNode.methods) {
|
||||
if (method.name.equals(selector.getName())) {
|
||||
desc = method.desc;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return desc;
|
||||
}
|
||||
|
||||
/* (non-Javadoc)
|
||||
* @see org.spongepowered.tools.obfuscation.mirror.TypeHandle#findField(
|
||||
* java.lang.String, java.lang.String, boolean)
|
||||
*/
|
||||
@Override
|
||||
public FieldHandle findField(String name, String type, boolean matchCase) {
|
||||
for (FieldNode field : this.classNode.fields) {
|
||||
if (TypeHandleASM.compareElement(field.name, TypeUtils.getJavaSignature(field.desc), name, type, matchCase)) {
|
||||
return new FieldHandleASM(this, field);
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/* (non-Javadoc)
|
||||
* @see org.spongepowered.tools.obfuscation.mirror.TypeHandle#findMethod(
|
||||
* java.lang.String, java.lang.String, boolean)
|
||||
*/
|
||||
@Override
|
||||
public MethodHandle findMethod(String name, String signature, boolean matchCase) {
|
||||
for (MethodNode method : this.classNode.methods) {
|
||||
if (TypeHandleASM.compareElement(method.name, TypeUtils.getJavaSignature(method.desc), name, signature, matchCase)) {
|
||||
return new MethodHandleASM(this, method);
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
protected static boolean compareElement(String elementName, String elementType, String name, String type, boolean matchCase) {
|
||||
try {
|
||||
boolean compared = matchCase ? name.equals(elementName) : name.equalsIgnoreCase(elementName);
|
||||
return compared && (type.length() == 0 || type.equals(elementType));
|
||||
} catch (NullPointerException ex) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Attempts to read a class from the compile classpath using ASM. This at
|
||||
* least lets us determine whether the class exists and inspect the methods
|
||||
* and fields it contains. Returns <tt>null</tt> if the class resource could
|
||||
* not be resolved via the compile classpath.
|
||||
*
|
||||
* @param pkg Containing package
|
||||
* @param name Class name
|
||||
* @param ap Annotation Processor, used to access Filer and
|
||||
* TypeHandleProvider
|
||||
* @return ASM TypeHandle or null if the class could not be read
|
||||
*/
|
||||
public static TypeHandle of(PackageElement pkg, String name, IMixinAnnotationProcessor ap) {
|
||||
String fqName = pkg.getQualifiedName() + "." + name;
|
||||
if (TypeHandleASM.cache.containsKey(fqName)) {
|
||||
return TypeHandleASM.cache.get(fqName);
|
||||
}
|
||||
|
||||
InputStream is = null;
|
||||
try {
|
||||
Filer filer = ap.getProcessingEnvironment().getFiler();
|
||||
is = filer.getResource(StandardLocation.CLASS_PATH, pkg.getQualifiedName(), name + ".class").openInputStream();
|
||||
ClassNode classNode = new ClassNode();
|
||||
new ClassReader(is).accept(classNode, 0);
|
||||
TypeHandleASM typeHandle = new TypeHandleASM(pkg, fqName, classNode, ap.getTypeProvider());
|
||||
TypeHandleASM.cache.put(fqName, typeHandle);
|
||||
return typeHandle;
|
||||
} catch (FileNotFoundException fnfe) {
|
||||
// This is expected if the resource doesn't exist
|
||||
TypeHandleASM.cache.put(fqName, null);
|
||||
} catch (Exception ex) {
|
||||
// This isn't expected but there's not a lot we can do about it, so just give up
|
||||
} finally {
|
||||
if (is != null) {
|
||||
try {
|
||||
is.close();
|
||||
} catch (IOException ex) {
|
||||
ex.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -128,7 +128,7 @@ public class TypeHandleSimulated extends TypeHandle {
|
||||
*/
|
||||
@Override
|
||||
public FieldHandle findField(String name, String type, boolean caseSensitive) {
|
||||
return new FieldHandle(null, name, type);
|
||||
return new FieldHandle((String)null, name, type);
|
||||
}
|
||||
|
||||
/* (non-Javadoc)
|
||||
|
||||
@@ -41,6 +41,7 @@ import javax.lang.model.type.TypeKind;
|
||||
import javax.lang.model.type.TypeMirror;
|
||||
import javax.lang.model.type.TypeVariable;
|
||||
|
||||
import org.spongepowered.asm.util.Bytecode.Visibility;
|
||||
import org.spongepowered.asm.util.Constants;
|
||||
import org.spongepowered.asm.util.SignaturePrinter;
|
||||
|
||||
@@ -246,6 +247,9 @@ public abstract class TypeUtils {
|
||||
* @return java signature
|
||||
*/
|
||||
public static String getJavaSignature(Element element) {
|
||||
if (element == null) {
|
||||
return "";
|
||||
}
|
||||
if (element instanceof ExecutableElement) {
|
||||
ExecutableElement method = (ExecutableElement)element;
|
||||
StringBuilder desc = new StringBuilder().append("(");
|
||||
|
||||
@@ -30,10 +30,10 @@ import javax.lang.model.element.ElementKind;
|
||||
import javax.lang.model.element.Modifier;
|
||||
import javax.lang.model.element.TypeElement;
|
||||
|
||||
import org.spongepowered.asm.util.asm.IAnnotationHandle;
|
||||
import org.spongepowered.tools.obfuscation.MixinValidator;
|
||||
import org.spongepowered.tools.obfuscation.interfaces.IMessagerEx.MessageType;
|
||||
import org.spongepowered.tools.obfuscation.interfaces.IMixinAnnotationProcessor;
|
||||
import org.spongepowered.tools.obfuscation.mirror.AnnotationHandle;
|
||||
import org.spongepowered.tools.obfuscation.mirror.TypeHandle;
|
||||
|
||||
/**
|
||||
@@ -57,7 +57,7 @@ public class ParentValidator extends MixinValidator {
|
||||
* java.util.Collection)
|
||||
*/
|
||||
@Override
|
||||
public boolean validate(TypeElement mixin, AnnotationHandle annotation, Collection<TypeHandle> targets) {
|
||||
public boolean validate(TypeElement mixin, IAnnotationHandle annotation, Collection<TypeHandle> targets) {
|
||||
if (mixin.getEnclosingElement().getKind() != ElementKind.PACKAGE && !mixin.getModifiers().contains(Modifier.STATIC)) {
|
||||
this.messager.printMessage(MessageType.PARENT_VALIDATOR, "Inner class mixin must be declared static", mixin);
|
||||
}
|
||||
|
||||
@@ -35,13 +35,14 @@ import javax.lang.model.type.TypeMirror;
|
||||
|
||||
import org.spongepowered.asm.mixin.gen.Accessor;
|
||||
import org.spongepowered.asm.mixin.gen.Invoker;
|
||||
import org.spongepowered.asm.util.asm.IAnnotationHandle;
|
||||
import org.spongepowered.tools.obfuscation.MixinValidator;
|
||||
import org.spongepowered.tools.obfuscation.SupportedOptions;
|
||||
import org.spongepowered.tools.obfuscation.interfaces.IMixinAnnotationProcessor;
|
||||
import org.spongepowered.tools.obfuscation.interfaces.IMessagerEx.MessageType;
|
||||
import org.spongepowered.tools.obfuscation.interfaces.IMixinAnnotationProcessor;
|
||||
import org.spongepowered.tools.obfuscation.mirror.AnnotationHandle;
|
||||
import org.spongepowered.tools.obfuscation.mirror.TypeUtils;
|
||||
import org.spongepowered.tools.obfuscation.mirror.TypeHandle;
|
||||
import org.spongepowered.tools.obfuscation.mirror.TypeUtils;
|
||||
|
||||
/**
|
||||
* Validator which checks that the mixin targets are sane
|
||||
@@ -64,7 +65,7 @@ public class TargetValidator extends MixinValidator {
|
||||
* java.util.Collection)
|
||||
*/
|
||||
@Override
|
||||
public boolean validate(TypeElement mixin, AnnotationHandle annotation, Collection<TypeHandle> targets) {
|
||||
public boolean validate(TypeElement mixin, IAnnotationHandle annotation, Collection<TypeHandle> targets) {
|
||||
if ("true".equalsIgnoreCase(this.options.getOption(SupportedOptions.DISABLE_TARGET_VALIDATOR))) {
|
||||
return true;
|
||||
}
|
||||
@@ -105,7 +106,7 @@ public class TargetValidator extends MixinValidator {
|
||||
TypeMirror superClass = mixin.getSuperclass();
|
||||
|
||||
for (TypeHandle target : targets) {
|
||||
TypeMirror targetType = target.getType();
|
||||
TypeMirror targetType = target.getTypeMirror();
|
||||
if (targetType != null && !this.validateSuperClass(targetType, superClass)) {
|
||||
this.messager.printMessage(MessageType.TARGET_VALIDATOR, "Superclass " + superClass + " of " + mixin
|
||||
+ " was not found in the hierarchy of target class " + targetType, mixin);
|
||||
|
||||
Reference in new issue
Block a user