Merge remote-tracking branch 'origin/pr/638'

This commit is contained in:
Mumfrey committed 2024-01-21 18:34:15 +00:00
commit 69487585a6
14 files changed
+157 -144

No files matched your search

@@ -176,7 +176,7 @@ class AnnotatedMixin implements IMixinContext, IAnnotatedElement {
this.mappings = this.obf.createMappingConsumer();
this.messager = ap;
this.mixin = type;
this.handle = new TypeHandle(type);
this.handle = new TypeHandle(type, ap.getTypeProvider());
this.methods = new ArrayList<MethodHandle>(this.handle.getMethods());
this.virtual = this.handle.getAnnotation(Pseudo.class).exists();
this.annotation = this.handle.getAnnotation(Mixin.class);
@@ -46,8 +46,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.TypeUtils.Equivalency;
import org.spongepowered.tools.obfuscation.mirror.TypeUtils.EquivalencyResult;
import com.google.common.base.Strings;
@@ -304,19 +302,11 @@ class AnnotatedMixinElementHandlerAccessor extends AnnotatedMixinElementHandler
}
private void registerFactoryForTarget(AnnotatedElementInvoker elem, TypeHandle target) {
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.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.getTypeMirror() + " but found " + elem.getReturnType());
return;
}
String returnType = TypeUtils.getTypeName(elem.getReturnType());
if (!returnType.equals(target.toString())) {
elem.printMessage(this.ap, MessageType.FACTORY_INVOKER_RETURN_TYPE, "Invalid Factory @Invoker return type, expected "
+ target + " but found " + returnType);
return;
}
if (!elem.isStatic()) {
elem.printMessage(this.ap, MessageType.FACTORY_INVOKER_NONSTATIC, "Factory @Invoker must be static");
@@ -77,7 +77,7 @@ class AnnotatedMixinElementHandlerSoftImplements extends AnnotatedMixinElementHa
}
try {
TypeHandle iface = new TypeHandle(interfaceAnnotation.<DeclaredType>getValue("iface"));
TypeHandle iface = this.ap.getTypeProvider().getTypeHandle(interfaceAnnotation.<DeclaredType>getValue("iface"));
String prefix = interfaceAnnotation.<String>getValue("prefix");
this.processSoftImplements(remap, iface, prefix);
} catch (Exception ex) {
@@ -73,6 +73,7 @@ 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.mirror.TypeUtils;
import org.spongepowered.tools.obfuscation.struct.InjectorRemap;
import org.spongepowered.tools.obfuscation.validation.ParentValidator;
import org.spongepowered.tools.obfuscation.validation.TargetValidator;
@@ -158,7 +159,7 @@ final class AnnotatedMixins implements IMixinAnnotationProcessor, ITokenProvider
this.targets = this.initTargetMap();
this.obf = new ObfuscationManager(this);
this.obf.init();
this.validators = ImmutableList.<IMixinValidator>of(
new ParentValidator(this),
new TargetValidator(this)
@@ -243,7 +244,7 @@ final class AnnotatedMixins implements IMixinAnnotationProcessor, ITokenProvider
public CompilerEnvironment getCompilerEnvironment() {
return this.env;
}
@Override
public Integer getToken(String token) {
if (this.tokenCache.containsKey(token)) {
@@ -370,17 +371,13 @@ final class AnnotatedMixins implements IMixinAnnotationProcessor, ITokenProvider
return this.mixins.get(mixinType);
}
public Collection<TypeMirror> getMixinsTargeting(TypeMirror targetType) {
return this.getMixinsTargeting((TypeElement)((DeclaredType)targetType).asElement());
}
public Collection<TypeMirror> getMixinsTargeting(TypeElement targetType) {
List<TypeMirror> minions = new ArrayList<TypeMirror>();
public Collection<TypeHandle> getMixinsTargeting(TypeHandle targetType) {
List<TypeHandle> minions = new ArrayList<TypeHandle>();
for (TypeReference mixin : this.targets.getMixinsTargeting(targetType)) {
TypeHandle handle = mixin.getHandle(this.processingEnv);
if (handle != null && handle.hasTypeMirror()) {
minions.add(handle.getTypeMirror());
TypeHandle handle = mixin.getHandle(this);
if (handle != null) {
minions.add(handle);
}
}
@@ -590,7 +587,7 @@ final class AnnotatedMixins implements IMixinAnnotationProcessor, ITokenProvider
this.printMessage(type.getKind(), type.decorate(msg), element, suppressedBy);
}
}
/**
* Print a message to the AP messager
*/
@@ -648,7 +645,7 @@ final class AnnotatedMixins implements IMixinAnnotationProcessor, ITokenProvider
this.printMessage(type.getKind(), type.decorate(msg), element, annotation, value);
}
}
/**
* Print a message to the AP messager
*/
@@ -688,37 +685,42 @@ final class AnnotatedMixins implements IMixinAnnotationProcessor, ITokenProvider
name = name.replace('/', '.');
Elements elements = this.processingEnv.getElementUtils();
PackageElement pkg = null;
int lastDotPos = name.lastIndexOf('.');
if (lastDotPos > -1) {
String pkgName = name.substring(0, lastDotPos);
pkg = elements.getPackageElement(pkgName);
}
if (pkg != null) {
// ASM gives the most and most accurate information. Try that first.
TypeHandle asmTypeHandle = TypeHandleASM.of(pkg, name.substring(lastDotPos + 1), this);
if (asmTypeHandle != null) {
return asmTypeHandle;
}
}
// ASM may be unable to resolve the class, for example if it's currently being compiled.
// Mirror is our next best bet.
TypeElement element = this.getTypeElement(name, elements);
if (element != null) {
try {
return new TypeHandle(element);
return new TypeHandle(element, this);
} catch (NullPointerException ex) {
// probably bad package
}
}
int lastDotPos = name.lastIndexOf('.');
if (lastDotPos > -1) {
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);
}
if (pkg != null) {
// Couldn't resolve the class, but could resolve the package, so just return an imaginary handle.
return new TypeHandle(pkg, name, this);
}
// Couldn't even resolve the package, all hope is lost.
return null;
}
/**
* Get a TypeHandle representing the supplied type in the current processing
* environment
@@ -728,11 +730,11 @@ final class AnnotatedMixins implements IMixinAnnotationProcessor, ITokenProvider
if (type instanceof TypeHandle) {
return (TypeHandle)type;
} else if (type instanceof DeclaredType) {
return new TypeHandle((DeclaredType)type);
return this.getTypeHandle(TypeUtils.getInternalName((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());
return this.getTypeHandle(TypeUtils.getInternalName((TypeElement) type));
} else if (type instanceof String) {
return this.getTypeHandle(type.toString());
}
@@ -810,11 +812,11 @@ final class AnnotatedMixins implements IMixinAnnotationProcessor, ITokenProvider
String pkg = name.substring(0, lastDotPos);
PackageElement packageElement = this.processingEnv.getElementUtils().getPackageElement(pkg);
if (packageElement != null) {
return new TypeHandleSimulated(packageElement, name, simulatedTarget);
return new TypeHandleSimulated(packageElement, name, simulatedTarget, this);
}
}
return new TypeHandleSimulated(name, simulatedTarget);
return new TypeHandleSimulated(name, simulatedTarget, this);
}
/* (non-Javadoc)
@@ -28,13 +28,13 @@ import java.util.Collection;
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.interfaces.ITypeHandleProvider;
import org.spongepowered.tools.obfuscation.mirror.TypeHandle;
/**
@@ -57,7 +57,12 @@ public abstract class MixinValidator implements IMixinValidator {
* Option provider
*/
protected final IOptionProvider options;
/**
* Type handle provider
*/
protected final ITypeHandleProvider typeHandleProvider;
/**
* Pass to run this validator in
*/
@@ -73,6 +78,7 @@ public abstract class MixinValidator implements IMixinValidator {
this.processingEnv = ap.getProcessingEnvironment();
this.messager = ap;
this.options = ap;
this.typeHandleProvider = ap.getTypeProvider();
this.pass = pass;
}
@@ -94,7 +100,7 @@ public abstract class MixinValidator implements IMixinValidator {
protected abstract boolean validate(TypeElement mixin, IAnnotationHandle annotation, Collection<TypeHandle> targets);
protected final Collection<TypeMirror> getMixinsTargeting(TypeMirror targetType) {
protected final Collection<TypeHandle> getMixinsTargeting(TypeHandle targetType) {
return AnnotatedMixins.getMixinsForEnvironment(this.processingEnv).getMixinsTargeting(targetType);
}
}
@@ -196,13 +196,13 @@ public abstract class ObfuscationEnvironment implements IObfuscationEnvironment
}
// See if we can get the superclass from the reference
TypeMirror superClass = type.getElement().getSuperclass();
if (superClass.getKind() != TypeKind.DECLARED) {
TypeHandle superClass = type.getSuperclass();
if (superClass == null) {
return null;
}
// Well we found it, let's inflect the class name and recurse the search
String superClassName = ((TypeElement)((DeclaredType)superClass).asElement()).getQualifiedName().toString();
String superClassName = superClass.getSimpleName();
return this.getObfMethod(method.move(superClassName.replace('.', '/')));
}
@@ -132,16 +132,6 @@ public final class TargetMap extends HashMap<TypeReference, Set<TypeReference>>
Set<TypeReference> mixins = this.getMixinsFor(target);
mixins.add(mixin);
}
/**
* Get mixin classes which target the specified class
*
* @param target Target class
* @return Collection of mixins registered as targetting the specified class
*/
Collection<TypeReference> getMixinsTargeting(TypeElement target) {
return this.getMixinsTargeting(new TypeHandle(target));
}
/**
* Get mixin classes which target the specified class
@@ -44,6 +44,7 @@ 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.interfaces.ITypeHandleProvider;
import org.spongepowered.tools.obfuscation.mirror.mapping.MappingMethodResolvable;
import com.google.common.collect.ImmutableList;
@@ -71,6 +72,12 @@ public class TypeHandle {
* Actual type element, this is null for inaccessible classes
*/
private final TypeElement element;
/**
* Type handle provider, we need this since we have to resolve type handles
* for related classes (eg. superclass) without using mirror
*/
protected final ITypeHandleProvider typeProvider;
/**
* Reference to this handle, for serialisation
@@ -84,10 +91,11 @@ public class TypeHandle {
* @param pkg Package
* @param name FQ class name
*/
public TypeHandle(PackageElement pkg, String name) {
public TypeHandle(PackageElement pkg, String name, ITypeHandleProvider typeProvider) {
this.name = name.replace('.', '/');
this.pkg = pkg;
this.element = null;
this.typeProvider = typeProvider;
}
/**
@@ -95,10 +103,11 @@ public class TypeHandle {
*
* @param element ze element
*/
public TypeHandle(TypeElement element) {
public TypeHandle(TypeElement element, ITypeHandleProvider typeProvider) {
this.pkg = TypeUtils.getPackage(element);
this.name = TypeUtils.getInternalName(element);
this.element = element;
this.typeProvider = typeProvider;
}
/**
@@ -106,8 +115,8 @@ public class TypeHandle {
*
* @param type type
*/
public TypeHandle(DeclaredType type) {
this((TypeElement)type.asElement());
public TypeHandle(DeclaredType type, ITypeHandleProvider typeProvider) {
this((TypeElement)type.asElement(), typeProvider);
}
/* (non-Javadoc)
@@ -215,7 +224,7 @@ public class TypeHandle {
return null;
}
return new TypeHandle((DeclaredType)superClass);
return typeProvider.getTypeHandle(superClass);
}
/**
@@ -228,7 +237,7 @@ public class TypeHandle {
Builder<TypeHandle> list = ImmutableList.<TypeHandle>builder();
for (TypeMirror iface : this.getTargetElement().getInterfaces()) {
list.add(new TypeHandle((DeclaredType)iface));
list.add(typeProvider.getTypeHandle(iface));
}
return list.build();
}
@@ -275,6 +284,31 @@ public class TypeHandle {
public boolean isSimulated() {
return false;
}
/**
* Gets whether this handle definitely does not represent an interface
*/
public boolean isNotInterface() {
TypeElement target = this.getTargetElement();
return target != null && !target.getKind().isInterface();
}
/**
* Gets whether this handle is a supertype of the other handle
*/
public boolean isSuperTypeOf(TypeHandle other) {
List<TypeHandle> superTypes = new ArrayList<>();
if (other.getSuperclass() != null) {
superTypes.add(other.getSuperclass());
}
superTypes.addAll(other.getInterfaces());
for (TypeHandle superType : superTypes) {
if (this.name.equals(superType.name) || this.isSuperTypeOf(superType)) {
return true;
}
}
return false;
}
/**
* Get the TypeReference for this type, used for serialisation
@@ -76,12 +76,6 @@ public class TypeHandleASM extends TypeHandle {
* 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
@@ -91,9 +85,8 @@ public class TypeHandleASM extends TypeHandle {
* @param name FQ class name
*/
protected TypeHandleASM(PackageElement pkg, String name, ClassNode classNode, ITypeHandleProvider typeProvider) {
super(pkg, name);
super(pkg, name, typeProvider);
this.classNode = classNode;
this.typeProvider = typeProvider;
}
/* (non-Javadoc)
@@ -146,8 +139,10 @@ public class TypeHandleASM extends TypeHandle {
*/
@Override
public TypeHandle getSuperclass() {
TypeHandle superClass = this.typeProvider.getTypeHandle(this.classNode.superName);
return superClass;
if (this.classNode.superName == null) {
return null;
}
return this.typeProvider.getTypeHandle(this.classNode.superName);
}
/* (non-Javadoc)
@@ -196,6 +191,14 @@ public class TypeHandleASM extends TypeHandle {
return false;
}
/* (non-Javadoc)
* @see org.spongepowered.tools.obfuscation.mirror.TypeHandle#isInterface()
*/
@Override
public boolean isNotInterface() {
return (this.classNode.access & Opcodes.ACC_INTERFACE) == 0;
}
/* (non-Javadoc)
* @see org.spongepowered.tools.obfuscation.mirror.TypeHandle#findDescriptor
* (org.spongepowered.asm.mixin.injection.selectors.ITargetSelectorByName)
@@ -272,7 +275,11 @@ public class TypeHandleASM extends TypeHandle {
InputStream is = null;
try {
Filer filer = ap.getProcessingEnvironment().getFiler();
is = filer.getResource(StandardLocation.CLASS_PATH, pkg.getQualifiedName(), name + ".class").openInputStream();
try {
is = filer.getResource(StandardLocation.CLASS_PATH, pkg.getQualifiedName(), name + ".class").openInputStream();
} catch (FileNotFoundException ignored) {
is = filer.getResource(StandardLocation.PLATFORM_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());
@@ -35,6 +35,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.SignaturePrinter;
import org.spongepowered.tools.obfuscation.interfaces.ITypeHandleProvider;
/**
* A simulated type handle, used with virtual (pseudo) mixins. For obfuscation
@@ -48,12 +49,12 @@ public class TypeHandleSimulated extends TypeHandle {
private final TypeElement simulatedType;
public TypeHandleSimulated(String name, TypeMirror type) {
this(TypeUtils.getPackage(type), name, type);
public TypeHandleSimulated(String name, TypeMirror type, ITypeHandleProvider typeProvider) {
this(TypeUtils.getPackage(type), name, type, typeProvider);
}
public TypeHandleSimulated(PackageElement pkg, String name, TypeMirror type) {
super(pkg, name);
public TypeHandleSimulated(PackageElement pkg, String name, TypeMirror type, ITypeHandleProvider typeProvider) {
super(pkg, name, typeProvider);
this.simulatedType = (TypeElement)((DeclaredType)type).asElement();
}
@@ -152,14 +153,14 @@ public class TypeHandleSimulated extends TypeHandle {
String rawSignature = TypeUtils.stripGenerics(signature);
// Try to locate a member anywhere in the hierarchy which matches
MethodHandle method = TypeHandleSimulated.findMethodRecursive(this, name, signature, rawSignature, true);
MethodHandle method = TypeHandleSimulated.findMethodRecursive(this, name, signature, rawSignature, true, this.typeProvider);
// If we find one, return it otherwise just simulate the method
return method != null ? method.asMapping(true) : super.getMappingMethod(name, desc);
}
private static MethodHandle findMethodRecursive(TypeHandle target, String name, String signature, String rawSignature, boolean matchCase) {
private static MethodHandle findMethodRecursive(TypeHandle target, String name, String signature, String rawSignature, boolean matchCase, ITypeHandleProvider typeProvider) {
TypeElement elem = target.getTargetElement();
if (elem == null) {
return null;
@@ -171,7 +172,7 @@ public class TypeHandleSimulated extends TypeHandle {
}
for (TypeMirror iface : elem.getInterfaces()) {
method = TypeHandleSimulated.findMethodRecursive(iface, name, signature, rawSignature, matchCase);
method = TypeHandleSimulated.findMethodRecursive(iface, name, signature, rawSignature, matchCase, typeProvider);
if (method != null) {
return method;
}
@@ -182,15 +183,14 @@ public class TypeHandleSimulated extends TypeHandle {
return null;
}
return TypeHandleSimulated.findMethodRecursive(superClass, name, signature, rawSignature, matchCase);
return TypeHandleSimulated.findMethodRecursive(superClass, name, signature, rawSignature, matchCase, typeProvider);
}
private static MethodHandle findMethodRecursive(TypeMirror target, String name, String signature, String rawSignature, boolean matchCase) {
private static MethodHandle findMethodRecursive(TypeMirror target, String name, String signature, String rawSignature, boolean matchCase, ITypeHandleProvider typeProvider) {
if (!(target instanceof DeclaredType)) {
return null;
}
TypeElement element = (TypeElement)((DeclaredType)target).asElement();
return TypeHandleSimulated.findMethodRecursive(new TypeHandle(element), name, signature, rawSignature, matchCase);
return TypeHandleSimulated.findMethodRecursive(typeProvider.getTypeHandle(target), name, signature, rawSignature, matchCase, typeProvider);
}
}
@@ -24,6 +24,8 @@
*/
package org.spongepowered.tools.obfuscation.mirror;
import org.spongepowered.tools.obfuscation.interfaces.ITypeHandleProvider;
import java.io.Serializable;
import javax.annotation.processing.ProcessingEnvironment;
@@ -82,15 +84,14 @@ public class TypeReference implements Serializable, Comparable<TypeReference> {
/**
* Fetch or attempt to generate the type handle
*
* @param processingEnv environment to create handle if it needs to be
* @param typeHandleProvider provider to create handle if it needs to be
* regenerated
* @return type handle
*/
public TypeHandle getHandle(ProcessingEnvironment processingEnv) {
public TypeHandle getHandle(ITypeHandleProvider typeHandleProvider) {
if (this.handle == null) {
TypeElement element = processingEnv.getElementUtils().getTypeElement(this.getClassName());
try {
this.handle = new TypeHandle(element);
this.handle = typeHandleProvider.getTypeHandle(this.name);
} catch (Exception ex) {
// Class probably doesn't exist in scope :/
ex.printStackTrace();
@@ -37,6 +37,7 @@ import javax.lang.model.element.TypeParameterElement;
import javax.lang.model.element.VariableElement;
import javax.lang.model.type.ArrayType;
import javax.lang.model.type.DeclaredType;
import javax.lang.model.type.IntersectionType;
import javax.lang.model.type.TypeKind;
import javax.lang.model.type.TypeMirror;
import javax.lang.model.type.TypeVariable;
@@ -274,6 +275,9 @@ public abstract class TypeUtils {
* @return java signature
*/
public static String getJavaSignature(String descriptor) {
if (!descriptor.contains("(")) {
return SignaturePrinter.getTypeName(org.objectweb.asm.Type.getType(descriptor), false, true);
}
return new SignaturePrinter("", descriptor).setFullyQualified(true).toDescriptor();
}
@@ -448,6 +452,10 @@ public abstract class TypeUtils {
throw new IllegalStateException("Generic symbol \"" + type + "\" is too complex, exceeded "
+ TypeUtils.MAX_GENERIC_RECURSION_DEPTH + " iterations attempting to determine upper bound");
}
if (type instanceof IntersectionType) {
TypeMirror first = ((IntersectionType) type).getBounds().get(0);
return TypeUtils.getUpperBound0(first, --depth);
}
if (type instanceof DeclaredType) {
return (DeclaredType)type;
}
@@ -29,10 +29,8 @@ import java.util.Collection;
import javax.lang.model.element.Element;
import javax.lang.model.element.ElementKind;
import javax.lang.model.element.TypeElement;
import javax.lang.model.type.DeclaredType;
import javax.lang.model.type.TypeKind;
import javax.lang.model.type.TypeMirror;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.gen.Accessor;
import org.spongepowered.asm.mixin.gen.Invoker;
import org.spongepowered.asm.util.asm.IAnnotationHandle;
@@ -94,8 +92,7 @@ public class TargetValidator extends MixinValidator {
}
for (TypeHandle target : targets) {
TypeElement targetType = target.getElement();
if (targetType != null && !(targetType.getKind() == ElementKind.INTERFACE)) {
if (target != null && target.isNotInterface()) {
this.messager.printMessage(MessageType.TARGET_VALIDATOR, "Targetted type '" + target + " of " + mixin + " is not an interface",
mixin);
}
@@ -103,54 +100,32 @@ public class TargetValidator extends MixinValidator {
}
private void validateClassMixin(TypeElement mixin, Collection<TypeHandle> targets) {
TypeMirror superClass = mixin.getSuperclass();
TypeHandle superClass = this.typeHandleProvider.getTypeHandle(TypeUtils.getInternalName(mixin)).getSuperclass();
for (TypeHandle target : targets) {
TypeMirror targetType = target.getTypeMirror();
if (targetType != null && !this.validateSuperClass(targetType, superClass)) {
if (target != null && !this.validateSuperClass(target, superClass)) {
this.messager.printMessage(MessageType.TARGET_VALIDATOR, "Superclass " + superClass + " of " + mixin
+ " was not found in the hierarchy of target class " + targetType, mixin);
+ " was not found in the hierarchy of target class " + target, mixin);
}
}
}
private boolean validateSuperClass(TypeMirror targetType, TypeMirror superClass) {
if (TypeUtils.isAssignable(this.processingEnv, targetType, superClass)) {
return true;
}
return this.validateSuperClassRecursive(targetType, superClass);
private boolean validateSuperClass(TypeHandle targetType, TypeHandle superClass) {
return targetType.isImaginary() || targetType.isSimulated() || superClass.isSuperTypeOf(targetType) || this.checkMixinsFor(targetType, superClass);
}
private boolean validateSuperClassRecursive(TypeMirror targetType, TypeMirror superClass) {
if (!(targetType instanceof DeclaredType)) {
return false;
}
if (TypeUtils.isAssignable(this.processingEnv, targetType, superClass)) {
return true;
}
TypeElement targetElement = (TypeElement)((DeclaredType)targetType).asElement();
TypeMirror targetSuper = targetElement.getSuperclass();
if (targetSuper.getKind() == TypeKind.NONE) {
return false;
}
if (this.checkMixinsFor(targetSuper, superClass)) {
return true;
}
return this.validateSuperClassRecursive(targetSuper, superClass);
}
private boolean checkMixinsFor(TypeMirror targetType, TypeMirror superClass) {
for (TypeMirror mixinType : this.getMixinsTargeting(targetType)) {
if (TypeUtils.isAssignable(this.processingEnv, mixinType, superClass)) {
private boolean checkMixinsFor(TypeHandle targetType, TypeHandle superMixin) {
IAnnotationHandle annotation = superMixin.getAnnotation(Mixin.class);
for (Object target : annotation.getList()) {
if (this.typeHandleProvider.getTypeHandle(target).isSuperTypeOf(targetType)) {
return true;
}
}
for (String target : annotation.<String>getList("targets")) {
if (this.typeHandleProvider.getTypeHandle(target).isSuperTypeOf(targetType)) {
return true;
}
}
return false;
}
}