diff --git a/build.gradle b/build.gradle index d3a9f17a..ef5b0790 100644 --- a/build.gradle +++ b/build.gradle @@ -94,7 +94,7 @@ sourceSets { ap { compileClasspath += main.output ext.languageVersion = 8 - ext.compatibility = '1.6' + ext.compatibility = '1.8' } fernflower { compileClasspath += main.output diff --git a/src/ap/java/org/spongepowered/tools/obfuscation/AnnotatedMixin.java b/src/ap/java/org/spongepowered/tools/obfuscation/AnnotatedMixin.java index 5e85e421..f10832b7 100644 --- a/src/ap/java/org/spongepowered/tools/obfuscation/AnnotatedMixin.java +++ b/src/ap/java/org/spongepowered/tools/obfuscation/AnnotatedMixin.java @@ -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(this.handle.getMethods()); this.virtual = this.handle.getAnnotation(Pseudo.class).exists(); this.annotation = this.handle.getAnnotation(Mixin.class); diff --git a/src/ap/java/org/spongepowered/tools/obfuscation/AnnotatedMixinElementHandlerAccessor.java b/src/ap/java/org/spongepowered/tools/obfuscation/AnnotatedMixinElementHandlerAccessor.java index d8dc4862..d5bfd802 100644 --- a/src/ap/java/org/spongepowered/tools/obfuscation/AnnotatedMixinElementHandlerAccessor.java +++ b/src/ap/java/org/spongepowered/tools/obfuscation/AnnotatedMixinElementHandlerAccessor.java @@ -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"); diff --git a/src/ap/java/org/spongepowered/tools/obfuscation/AnnotatedMixinElementHandlerSoftImplements.java b/src/ap/java/org/spongepowered/tools/obfuscation/AnnotatedMixinElementHandlerSoftImplements.java index f9e7dfb2..82be0f1b 100644 --- a/src/ap/java/org/spongepowered/tools/obfuscation/AnnotatedMixinElementHandlerSoftImplements.java +++ b/src/ap/java/org/spongepowered/tools/obfuscation/AnnotatedMixinElementHandlerSoftImplements.java @@ -77,7 +77,7 @@ class AnnotatedMixinElementHandlerSoftImplements extends AnnotatedMixinElementHa } try { - TypeHandle iface = new TypeHandle(interfaceAnnotation.getValue("iface")); + TypeHandle iface = this.ap.getTypeProvider().getTypeHandle(interfaceAnnotation.getValue("iface")); String prefix = interfaceAnnotation.getValue("prefix"); this.processSoftImplements(remap, iface, prefix); } catch (Exception ex) { diff --git a/src/ap/java/org/spongepowered/tools/obfuscation/AnnotatedMixins.java b/src/ap/java/org/spongepowered/tools/obfuscation/AnnotatedMixins.java index 0835ead5..ec6670b7 100644 --- a/src/ap/java/org/spongepowered/tools/obfuscation/AnnotatedMixins.java +++ b/src/ap/java/org/spongepowered/tools/obfuscation/AnnotatedMixins.java @@ -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.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 getMixinsTargeting(TypeMirror targetType) { - return this.getMixinsTargeting((TypeElement)((DeclaredType)targetType).asElement()); - } - - public Collection getMixinsTargeting(TypeElement targetType) { - List minions = new ArrayList(); + public Collection getMixinsTargeting(TypeHandle targetType) { + List minions = new ArrayList(); 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) diff --git a/src/ap/java/org/spongepowered/tools/obfuscation/MixinValidator.java b/src/ap/java/org/spongepowered/tools/obfuscation/MixinValidator.java index ab10529a..85f68512 100644 --- a/src/ap/java/org/spongepowered/tools/obfuscation/MixinValidator.java +++ b/src/ap/java/org/spongepowered/tools/obfuscation/MixinValidator.java @@ -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 targets); - protected final Collection getMixinsTargeting(TypeMirror targetType) { + protected final Collection getMixinsTargeting(TypeHandle targetType) { return AnnotatedMixins.getMixinsForEnvironment(this.processingEnv).getMixinsTargeting(targetType); } } diff --git a/src/ap/java/org/spongepowered/tools/obfuscation/ObfuscationEnvironment.java b/src/ap/java/org/spongepowered/tools/obfuscation/ObfuscationEnvironment.java index 2f55a873..fa42dcb8 100644 --- a/src/ap/java/org/spongepowered/tools/obfuscation/ObfuscationEnvironment.java +++ b/src/ap/java/org/spongepowered/tools/obfuscation/ObfuscationEnvironment.java @@ -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('.', '/'))); } diff --git a/src/ap/java/org/spongepowered/tools/obfuscation/TargetMap.java b/src/ap/java/org/spongepowered/tools/obfuscation/TargetMap.java index 1cd2fbad..80c8e214 100644 --- a/src/ap/java/org/spongepowered/tools/obfuscation/TargetMap.java +++ b/src/ap/java/org/spongepowered/tools/obfuscation/TargetMap.java @@ -132,16 +132,6 @@ public final class TargetMap extends HashMap> Set 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 getMixinsTargeting(TypeElement target) { - return this.getMixinsTargeting(new TypeHandle(target)); - } /** * Get mixin classes which target the specified class diff --git a/src/ap/java/org/spongepowered/tools/obfuscation/mirror/TypeHandle.java b/src/ap/java/org/spongepowered/tools/obfuscation/mirror/TypeHandle.java index 3b92cb08..5c2f1e6a 100644 --- a/src/ap/java/org/spongepowered/tools/obfuscation/mirror/TypeHandle.java +++ b/src/ap/java/org/spongepowered/tools/obfuscation/mirror/TypeHandle.java @@ -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 list = ImmutableList.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 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 diff --git a/src/ap/java/org/spongepowered/tools/obfuscation/mirror/TypeHandleASM.java b/src/ap/java/org/spongepowered/tools/obfuscation/mirror/TypeHandleASM.java index aa745b40..00ae928f 100644 --- a/src/ap/java/org/spongepowered/tools/obfuscation/mirror/TypeHandleASM.java +++ b/src/ap/java/org/spongepowered/tools/obfuscation/mirror/TypeHandleASM.java @@ -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()); diff --git a/src/ap/java/org/spongepowered/tools/obfuscation/mirror/TypeHandleSimulated.java b/src/ap/java/org/spongepowered/tools/obfuscation/mirror/TypeHandleSimulated.java index e34c7298..bdb44612 100644 --- a/src/ap/java/org/spongepowered/tools/obfuscation/mirror/TypeHandleSimulated.java +++ b/src/ap/java/org/spongepowered/tools/obfuscation/mirror/TypeHandleSimulated.java @@ -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); } } diff --git a/src/ap/java/org/spongepowered/tools/obfuscation/mirror/TypeReference.java b/src/ap/java/org/spongepowered/tools/obfuscation/mirror/TypeReference.java index e2a0b979..41ea5f45 100644 --- a/src/ap/java/org/spongepowered/tools/obfuscation/mirror/TypeReference.java +++ b/src/ap/java/org/spongepowered/tools/obfuscation/mirror/TypeReference.java @@ -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 { /** * 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(); diff --git a/src/ap/java/org/spongepowered/tools/obfuscation/mirror/TypeUtils.java b/src/ap/java/org/spongepowered/tools/obfuscation/mirror/TypeUtils.java index cbc88820..709a6eaf 100644 --- a/src/ap/java/org/spongepowered/tools/obfuscation/mirror/TypeUtils.java +++ b/src/ap/java/org/spongepowered/tools/obfuscation/mirror/TypeUtils.java @@ -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; } diff --git a/src/ap/java/org/spongepowered/tools/obfuscation/validation/TargetValidator.java b/src/ap/java/org/spongepowered/tools/obfuscation/validation/TargetValidator.java index 3db43e90..00a0e41d 100644 --- a/src/ap/java/org/spongepowered/tools/obfuscation/validation/TargetValidator.java +++ b/src/ap/java/org/spongepowered/tools/obfuscation/validation/TargetValidator.java @@ -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 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.getList("targets")) { + if (this.typeHandleProvider.getTypeHandle(target).isSuperTypeOf(targetType)) { return true; } } - return false; } }