From 053bc174dec8170b5d4f2edc9e22fbe8d813eca3 Mon Sep 17 00:00:00 2001 From: Mumfrey Date: Tue, 14 Jun 2016 23:11:30 +0100 Subject: [PATCH] Add Unique, relax target checks, closes #130, fixes #134, bump to 0.5.7 --- gradle.properties | 2 +- .../tools/obfuscation/AnnotatedMixin.java | 2 +- .../asm/launch/MixinBootstrap.java | 2 +- .../asm/launch/MixinTweaker.java | 1 + .../spongepowered/asm/mixin/Interface.java | 8 + .../asm/mixin/MixinEnvironment.java | 29 ++- .../org/spongepowered/asm/mixin/Unique.java | 71 +++++++ .../modify/LocalVariableDiscriminator.java | 4 +- .../mixin/injection/struct/InjectionInfo.java | 2 +- .../asm/mixin/transformer/ClassInfo.java | 21 +- .../asm/mixin/transformer/InterfaceInfo.java | 65 ++++++- .../asm/mixin/transformer/MixinConfig.java | 2 +- .../asm/mixin/transformer/MixinInfo.java | 66 +++++-- .../MixinPreProcessorStandard.java | 179 ++++++++---------- .../mixin/transformer/MixinTargetContext.java | 73 ++++++- .../mixin/transformer/TargetClassContext.java | 62 +++++- .../org/spongepowered/asm/util/ASMHelper.java | 4 + 17 files changed, 459 insertions(+), 134 deletions(-) create mode 100644 src/main/java/org/spongepowered/asm/mixin/Unique.java diff --git a/gradle.properties b/gradle.properties index 030b3362..1b376e24 100644 --- a/gradle.properties +++ b/gradle.properties @@ -4,5 +4,5 @@ packaging=jar description=Mixin url=https://www.spongepowered.org organization=SpongePowered -buildVersion=0.5.6 +buildVersion=0.5.7 buildType=SNAPSHOT diff --git a/src/ap/java/org/spongepowered/tools/obfuscation/AnnotatedMixin.java b/src/ap/java/org/spongepowered/tools/obfuscation/AnnotatedMixin.java index 69bd7590..2714c7c6 100644 --- a/src/ap/java/org/spongepowered/tools/obfuscation/AnnotatedMixin.java +++ b/src/ap/java/org/spongepowered/tools/obfuscation/AnnotatedMixin.java @@ -212,7 +212,7 @@ class AnnotatedMixin { this.printMessage(Kind.ERROR, "Mixin target " + privateTarget + " could not be found", this); return null; } else if (type.isPublic()) { - this.printMessage(Kind.ERROR, "Mixin target " + privateTarget + " is public and must be specified in value", this); + this.printMessage(Kind.WARNING, "Mixin target " + privateTarget + " is public and must be specified in value", this); return null; } this.addSoftTarget(type, privateTarget); diff --git a/src/main/java/org/spongepowered/asm/launch/MixinBootstrap.java b/src/main/java/org/spongepowered/asm/launch/MixinBootstrap.java index 67b8c7c7..4eade2ab 100644 --- a/src/main/java/org/spongepowered/asm/launch/MixinBootstrap.java +++ b/src/main/java/org/spongepowered/asm/launch/MixinBootstrap.java @@ -60,7 +60,7 @@ public abstract class MixinBootstrap { /** * Subsystem version */ - public static final String VERSION = "0.5.6"; + public static final String VERSION = "0.5.7"; /** * Blackboard key where the subsystem version will be stored to indicate diff --git a/src/main/java/org/spongepowered/asm/launch/MixinTweaker.java b/src/main/java/org/spongepowered/asm/launch/MixinTweaker.java index 1de3731c..e4ba4d5a 100644 --- a/src/main/java/org/spongepowered/asm/launch/MixinTweaker.java +++ b/src/main/java/org/spongepowered/asm/launch/MixinTweaker.java @@ -233,6 +233,7 @@ public class MixinTweaker implements ITweaker { * * @param config config resource name, does not require a leading / */ + @SuppressWarnings("deprecation") static void addConfig(String config) { if (config.endsWith(".json")) { MixinTweaker.logger.debug("Registering mixin config: {}", config); diff --git a/src/main/java/org/spongepowered/asm/mixin/Interface.java b/src/main/java/org/spongepowered/asm/mixin/Interface.java index 9c9be4c4..791c9286 100644 --- a/src/main/java/org/spongepowered/asm/mixin/Interface.java +++ b/src/main/java/org/spongepowered/asm/mixin/Interface.java @@ -53,4 +53,12 @@ public @interface Interface { */ public String prefix(); + /** + * If set to true, all methods implementing this interface are + * treated as if they were individually decorated with {@link Unique} + * + * @return true to mark all implementing methods as unique + */ + public boolean unique() default false; + } diff --git a/src/main/java/org/spongepowered/asm/mixin/MixinEnvironment.java b/src/main/java/org/spongepowered/asm/mixin/MixinEnvironment.java index 99ea0dcb..2803f17e 100644 --- a/src/main/java/org/spongepowered/asm/mixin/MixinEnvironment.java +++ b/src/main/java/org/spongepowered/asm/mixin/MixinEnvironment.java @@ -276,7 +276,9 @@ public final class MixinEnvironment implements ITokenProvider { }, /** - * Run the CheckClassAdapter on all classes after mixins are applied + * Run the CheckClassAdapter on all classes after mixins are applied, + * also enables stricter checks on mixins for use at dev-time, promotes + * some warning-level messages to exceptions */ DEBUG_VERIFY(Option.DEBUG_ALL, "verify"), @@ -292,6 +294,28 @@ public final class MixinEnvironment implements ITokenProvider { */ DEBUG_INJECTORS(Option.DEBUG_ALL, "countInjections"), + /** + * Enable strict checks + */ + DEBUG_STRICT(Option.DEBUG_ALL, "strict") { + @Override + boolean getBooleanValue() { + return Booleans.parseBoolean(System.getProperty(this.property), false); + } + }, + + /** + * If false (default), {@link Unique} public methods merely raise a + * warning when encountered and are not merged into the target. If true, + * an exception is thrown instead + */ + DEBUG_UNIQUE(Option.DEBUG_STRICT, "unique"), + + /** + * Enable strict checking for mixin targets + */ + DEBUG_TARGETS(Option.DEBUG_STRICT, "targets"), + /** * Disable the injector handler remapper */ @@ -802,6 +826,7 @@ public final class MixinEnvironment implements ITokenProvider { */ @Deprecated public MixinEnvironment addConfiguration(String config) { + MixinEnvironment.logger.warn("MixinEnvironment::addConfiguration is deprecated and will be removed. Use Mixins::addConfiguration instead!"); Mixins.addConfiguration(config, this); return this; } @@ -1199,6 +1224,8 @@ public final class MixinEnvironment implements ITokenProvider { */ @Deprecated public static void setCompatibilityLevel(CompatibilityLevel level) throws IllegalArgumentException { + MixinEnvironment.logger.warn("MixinEnvironment::setCompatibilityLevel is deprecated and will be removed. Set level via config instead!"); + if (level != MixinEnvironment.compatibility && level.isAtLeast(MixinEnvironment.compatibility)) { if (!level.isSupported()) { throw new IllegalArgumentException("The requested compatibility level " + level + " could not be set. Level is not supported"); diff --git a/src/main/java/org/spongepowered/asm/mixin/Unique.java b/src/main/java/org/spongepowered/asm/mixin/Unique.java new file mode 100644 index 00000000..c798e7fe --- /dev/null +++ b/src/main/java/org/spongepowered/asm/mixin/Unique.java @@ -0,0 +1,71 @@ +/* + * This file is part of Mixin, licensed under the MIT License (MIT). + * + * Copyright (c) SpongePowered + * 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.asm.mixin; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * This annotation, when applied to a member method in a mixin, indicates that + * the method should never overwrite a matching method in the target + * class. This indicates that the method differs from the normal "overlay-like" + * behaviour of mixins in general, and should only ever be added to the + * target. + * + *

Typical usage of this annotation would be to decorate a utility method in + * a mixin, or mark an interface-implementing method which must not overwrite a + * target if it exists (consider appropriate use of {@link Intrinsic} in these + * situations).

+ * + *

Because of the mixed usage, this annotation has different implications for + * methods with differing visibility:

+ * + *
+ *
public methods
+ *
public methods marked with this annotation are discarded if a + * matching target exists. A warning-level message is generated.
+ *
private and protected methods
+ *
non-public methods are renamed if a matching target method is + * found, this allows utility methods to be safely assigned meaningful names + * in code, but renamed if a conflict occurs when a mixin is applied.
+ *
+ * + *

Notes

+ * + * + */ +@Target({ ElementType.METHOD, ElementType.TYPE }) +@Retention(RetentionPolicy.RUNTIME) +public @interface Unique { + +} diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/modify/LocalVariableDiscriminator.java b/src/main/java/org/spongepowered/asm/mixin/injection/modify/LocalVariableDiscriminator.java index 48d68c61..6691ca91 100644 --- a/src/main/java/org/spongepowered/asm/mixin/injection/modify/LocalVariableDiscriminator.java +++ b/src/main/java/org/spongepowered/asm/mixin/injection/modify/LocalVariableDiscriminator.java @@ -259,8 +259,8 @@ public class LocalVariableDiscriminator { } /** - * If the user specifies no values for {@link #ordinal}, {@link #index} or - * {@link #names} then we are considered to be operating in "implicit mode" + * If the user specifies no values for ordinal, index or + * names then we are considered to be operating in "implicit mode" * where only a single local variable of the specified type is expected to * exist. * diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/struct/InjectionInfo.java b/src/main/java/org/spongepowered/asm/mixin/injection/struct/InjectionInfo.java index 9bb21819..9de737f8 100644 --- a/src/main/java/org/spongepowered/asm/mixin/injection/struct/InjectionInfo.java +++ b/src/main/java/org/spongepowered/asm/mixin/injection/struct/InjectionInfo.java @@ -141,7 +141,7 @@ public abstract class InjectionInfo { this.mixin = mixin; this.method = method; this.annotation = annotation; - this.classNode = mixin.getTargetClass(); + this.classNode = mixin.getTargetClassNode(); this.isStatic = ASMHelper.methodIsStatic(method); this.readAnnotation(); } diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/ClassInfo.java b/src/main/java/org/spongepowered/asm/mixin/transformer/ClassInfo.java index 500676f1..60f61eb4 100644 --- a/src/main/java/org/spongepowered/asm/mixin/transformer/ClassInfo.java +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/ClassInfo.java @@ -46,8 +46,10 @@ import org.spongepowered.asm.lib.tree.MethodNode; import org.spongepowered.asm.mixin.Final; import org.spongepowered.asm.mixin.MixinEnvironment; import org.spongepowered.asm.mixin.Mutable; +import org.spongepowered.asm.mixin.Unique; import org.spongepowered.asm.mixin.transformer.ClassInfo.Member.Type; import org.spongepowered.asm.mixin.transformer.MixinInfo.MixinClassNode; +import org.spongepowered.asm.util.ASMHelper; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableSet; @@ -59,8 +61,8 @@ import com.google.common.collect.ImmutableSet; */ public class ClassInfo extends TreeInfo { - public static final int INCLUDE_PRIVATE = 0x0002; - public static final int INCLUDE_STATIC = 0x0008; + public static final int INCLUDE_PRIVATE = Opcodes.ACC_PRIVATE; + public static final int INCLUDE_STATIC = Opcodes.ACC_STATIC; public static final int INCLUDE_ALL = ClassInfo.INCLUDE_PRIVATE | ClassInfo.INCLUDE_STATIC; /** @@ -334,10 +336,13 @@ public class ClassInfo extends TreeInfo { public class Method extends Member { private final List frames; + + private boolean unique; public Method(Member member) { super(member); this.frames = member instanceof Method ? ((Method)member).frames : null; + this.unique = member instanceof Method ? ((Method)member).unique : false; } public Method(MethodNode method) { @@ -347,21 +352,25 @@ public class ClassInfo extends TreeInfo { public Method(MethodNode method, boolean injected) { super(Type.METHOD, method.name, method.desc, method.access, injected); this.frames = this.gatherFrames(method); + this.unique = ASMHelper.getVisibleAnnotation(method, Unique.class) != null; } public Method(String name, String desc) { super(Type.METHOD, name, desc, Opcodes.ACC_PUBLIC, false); this.frames = null; + this.unique = false; } public Method(String name, String desc, int access) { super(Type.METHOD, name, desc, access, false); this.frames = null; + this.unique = false; } public Method(String name, String desc, int access, boolean injected) { super(Type.METHOD, name, desc, access, injected); this.frames = null; + this.unique = false; } private List gatherFrames(MethodNode method) { @@ -378,6 +387,14 @@ public class ClassInfo extends TreeInfo { public List getFrames() { return this.frames; } + + public boolean isUnique() { + return this.unique; + } + + public void setUnique(boolean unique) { + this.unique = unique; + } @Override public ClassInfo getOwner() { diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/InterfaceInfo.java b/src/main/java/org/spongepowered/asm/mixin/transformer/InterfaceInfo.java index ce7360e8..c0b04240 100644 --- a/src/main/java/org/spongepowered/asm/mixin/transformer/InterfaceInfo.java +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/InterfaceInfo.java @@ -31,15 +31,22 @@ import org.spongepowered.asm.lib.Type; import org.spongepowered.asm.lib.tree.AnnotationNode; import org.spongepowered.asm.lib.tree.MethodNode; import org.spongepowered.asm.mixin.Interface; +import org.spongepowered.asm.mixin.Unique; import org.spongepowered.asm.mixin.transformer.ClassInfo.Method; import org.spongepowered.asm.mixin.transformer.meta.MixinRenamed; import org.spongepowered.asm.mixin.transformer.throwables.InvalidMixinException; import org.spongepowered.asm.util.ASMHelper; +import com.sun.xml.internal.ws.org.objectweb.asm.Opcodes; + /** * Information about an interface being runtime-patched onto a mixin target * class, see {@link org.spongepowered.asm.mixin.Implements Implements} */ +/** + * @author adam + * + */ public class InterfaceInfo extends TreeInfo { /** @@ -58,6 +65,12 @@ public class InterfaceInfo extends TreeInfo { */ private final Type iface; + /** + * True if all methods implementing this interface should be treated as + * unique + */ + private final boolean unique; + /** * Method signatures in the interface, lazy loaded */ @@ -70,7 +83,7 @@ public class InterfaceInfo extends TreeInfo { * @param prefix Method prefix * @param iface Interface to load */ - private InterfaceInfo(MixinInfo mixin, String prefix, Type iface) { + private InterfaceInfo(MixinInfo mixin, String prefix, Type iface, boolean unique) { if (prefix == null || prefix.length() < 2 || !prefix.endsWith("$")) { throw new InvalidMixinException(mixin, String.format("Prefix %s for iface %s is not valid", prefix, iface.toString())); } @@ -78,6 +91,7 @@ public class InterfaceInfo extends TreeInfo { this.mixin = mixin; this.prefix = prefix; this.iface = iface; + this.unique = unique; } /** @@ -123,6 +137,15 @@ public class InterfaceInfo extends TreeInfo { public Type getIface() { return this.iface; } + + /** + * Get the internal name of the interface + * + * @return the internal name for the interface + */ + public String getName() { + return this.iface.getClassName(); + } /** * Get the internal name of the interface @@ -132,6 +155,15 @@ public class InterfaceInfo extends TreeInfo { public String getInternalName() { return this.iface.getInternalName(); } + + /** + * Get whether all methods for this interface should be treated as unique + * + * @return true to treat all member methods as unique + */ + public boolean isUnique() { + return this.unique; + } /** * Processes a method node in the mixin and renames it if necessary. If the @@ -148,20 +180,46 @@ public class InterfaceInfo extends TreeInfo { } if (!method.name.startsWith(this.prefix)) { + if (this.methods.contains(method.name + method.desc)) { + this.decorateUniqueMethod(method); + } return false; } String realName = method.name.substring(this.prefix.length()); String signature = realName + method.desc; + if (!this.methods.contains(signature)) { - throw new InvalidMixinException(this.mixin, String.format("%s does not exist in target interface %s", realName, this.iface.toString())); + throw new InvalidMixinException(this.mixin, String.format("%s does not exist in target interface %s", realName, this.getName())); + } + + if ((method.access & Opcodes.ACC_PUBLIC) == 0) { + throw new InvalidMixinException(this.mixin, String.format("%s cannot implement %s because it is not visible", realName, this.getName())); } ASMHelper.setVisibleAnnotation(method, MixinRenamed.class, "originalName", method.name, "isInterfaceMember", true); + this.decorateUniqueMethod(method); method.name = realName; return true; } + /** + * Decorate the target method with {@link Unique} if the interface is marked + * as unique + * + * @param method method to decorate + */ + private void decorateUniqueMethod(MethodNode method) { + if (!this.unique) { + return; + } + + if (ASMHelper.getVisibleAnnotation(method, Unique.class) == null) { + ASMHelper.setVisibleAnnotation(method, Unique.class); + this.mixin.getClassInfo().findMethod(method).setUnique(true); + } + } + /** * Convert an {@link Interface} annotation node into an * {@link InterfaceInfo} @@ -173,12 +231,13 @@ public class InterfaceInfo extends TreeInfo { static InterfaceInfo fromAnnotation(MixinInfo mixin, AnnotationNode node) { String prefix = ASMHelper.getAnnotationValue(node, "prefix"); Type iface = ASMHelper.getAnnotationValue(node, "iface"); + Boolean unique = ASMHelper.getAnnotationValue(node, "unique"); if (prefix == null || iface == null) { throw new InvalidMixinException(mixin, String.format("@Interface annotation on %s is missing a required parameter", mixin)); } - return new InterfaceInfo(mixin, prefix, iface); + return new InterfaceInfo(mixin, prefix, iface, unique != null ? unique.booleanValue() : false); } @Override diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinConfig.java b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinConfig.java index 67bc5f98..9a7b6545 100644 --- a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinConfig.java +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinConfig.java @@ -756,7 +756,7 @@ class MixinConfig implements Comparable, IMixinConfig { * * @param configFile * @param outer fallback environment - * @return + * @return new Config */ static Config create(String configFile, MixinEnvironment outer) { try { diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinInfo.java b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinInfo.java index 364adbbe..359e84da 100644 --- a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinInfo.java +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinInfo.java @@ -47,9 +47,11 @@ import org.spongepowered.asm.mixin.Implements; import org.spongepowered.asm.mixin.Mixin; import org.spongepowered.asm.mixin.MixinEnvironment; import org.spongepowered.asm.mixin.MixinEnvironment.CompatibilityLevel; +import org.spongepowered.asm.mixin.MixinEnvironment.Option; import org.spongepowered.asm.mixin.MixinEnvironment.Phase; import org.spongepowered.asm.mixin.Overwrite; import org.spongepowered.asm.mixin.Shadow; +import org.spongepowered.asm.mixin.Unique; import org.spongepowered.asm.mixin.extensibility.IMixinConfig; import org.spongepowered.asm.mixin.extensibility.IMixinConfigPlugin; import org.spongepowered.asm.mixin.extensibility.IMixinInfo; @@ -109,6 +111,11 @@ class MixinInfo extends TreeInfo implements Comparable, IMixinInfo { */ private boolean detachedSuper; + /** + * True if this mixin is decorated with {@link Unique} + */ + private boolean unique; + /** * All interfaces implemented by this mixin, including soft * implementations @@ -137,8 +144,16 @@ class MixinInfo extends TreeInfo implements Comparable, IMixinInfo { State(byte[] mixinBytes, ClassInfo classInfo) { this.mixinBytes = mixinBytes; + this.connect(); + this.classInfo = classInfo != null ? classInfo : ClassInfo.fromClassNode(this.getClassNode()); + } + + private void connect() { this.classNode = this.createClassNode(0); - this.classInfo = classInfo != null ? classInfo : ClassInfo.fromClassNode(this.classNode); + } + + private void complete() { + this.classNode = null; } ClassInfo getClassInfo() { @@ -156,6 +171,10 @@ class MixinInfo extends TreeInfo implements Comparable, IMixinInfo { boolean isDetachedSuper() { return this.detachedSuper; } + + boolean isUnique() { + return this.unique; + } List getSoftImplements() { return this.softImplements; @@ -192,6 +211,7 @@ class MixinInfo extends TreeInfo implements Comparable, IMixinInfo { type.validate(this, targetClasses); this.detachedSuper = type.isDetachedSuper(); + this.unique = ASMHelper.getVisibleAnnotation(this.getClassNode(), Unique.class) != null; // Pre-flight checks this.validateInner(); @@ -206,7 +226,7 @@ class MixinInfo extends TreeInfo implements Comparable, IMixinInfo { this.validateChanges(type, targetClasses); // Null out the validation classnode - this.classNode = null; + this.complete(); } private void validateInner() { @@ -380,7 +400,7 @@ class MixinInfo extends TreeInfo implements Comparable, IMixinInfo { * Get whether this mixin is detached super, must call {@link #validate} * first * - * @return + * @return true if super is detached */ boolean isDetachedSuper() { return this.detached; @@ -547,6 +567,11 @@ class MixinInfo extends TreeInfo implements Comparable, IMixinInfo { * Mixin type */ private final transient SubType type; + + /** + * Strict target checks enabled + */ + private final transient boolean strict; /** * Holds state that currently is not fully initialised or validated @@ -566,18 +591,19 @@ class MixinInfo extends TreeInfo implements Comparable, IMixinInfo { * @param runTransformers * @param plugin * @param suppressPlugin - * @throws ClassNotFoundException */ MixinInfo(MixinConfig parent, String mixinName, boolean runTransformers, IMixinConfigPlugin plugin, boolean suppressPlugin) { this.parent = parent; this.name = mixinName; this.className = parent.getMixinPackage() + mixinName; this.plugin = plugin; - this.phase = MixinEnvironment.getCurrentEnvironment().getPhase(); + this.phase = parent.getEnvironment().getPhase(); + this.strict = parent.getEnvironment().getOption(Option.DEBUG_TARGETS); // Read the class bytes and transform try { - this.pendingState = new State(this.loadMixinClass(this.className, runTransformers)); + byte[] mixinBytes = this.loadMixinClass(this.className, runTransformers); + this.pendingState = new State(mixinBytes); this.info = this.pendingState.getClassInfo(); this.type = this.initType(); } catch (Exception ex) { @@ -627,7 +653,7 @@ class MixinInfo extends TreeInfo implements Comparable, IMixinInfo { * * @param classNode * @param suppressPlugin - * @return + * @return target class list read from classNode */ protected List readTargetClasses(ClassNode classNode, boolean suppressPlugin) { if (classNode == null) { @@ -672,7 +698,7 @@ class MixinInfo extends TreeInfo implements Comparable, IMixinInfo { targetName = targetName.replace('/', '.'); if (this.plugin == null || suppressPlugin || this.plugin.shouldApplyMixin(targetName, this.className)) { ClassInfo targetInfo = this.getTarget(targetName, checkPublic); - if (!outTargets.contains(targetInfo)) { + if (targetInfo != null && !outTargets.contains(targetInfo)) { outTargets.add(targetInfo); targetInfo.addMixin(this); } @@ -683,21 +709,29 @@ class MixinInfo extends TreeInfo implements Comparable, IMixinInfo { private ClassInfo getTarget(String targetName, boolean checkPublic) throws InvalidMixinException { ClassInfo targetInfo = ClassInfo.forName(targetName); if (targetInfo == null) { - throw new InvalidMixinException(this, "@Mixin target " + targetName + " was not found " + this); + this.handleTargetError("@Mixin target " + targetName + " was not found " + this); + return null; } this.type.validateTarget(targetName, targetInfo); if (checkPublic && targetInfo.isPublic()) { - throw new InvalidMixinException(this, "@Mixin target " + targetName + " is public in " + this - + " and must be specified in value"); + this.handleTargetError("@Mixin target " + targetName + " is public in " + this + " and should be specified in value"); } return targetInfo; } + private void handleTargetError(String message) { + if (this.strict) { + this.logger.error(message); + throw new InvalidMixinException(this, message); + } + this.logger.warn(message); + } + /** * Read the priority from the {@link Mixin} annotation * * @param classNode - * @return + * @return priority read from classNode */ protected int readPriority(ClassNode classNode) { if (classNode == null) { @@ -792,6 +826,13 @@ class MixinInfo extends TreeInfo implements Comparable, IMixinInfo { return this.getState().isDetachedSuper(); } + /** + * True if this mixin is decorated with {@link Unique} + */ + public boolean isUnique() { + return this.getState().isUnique(); + } + /** * Get the logging level for this mixin */ @@ -958,4 +999,5 @@ class MixinInfo extends TreeInfo implements Comparable, IMixinInfo { } return null; } + } diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinPreProcessorStandard.java b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinPreProcessorStandard.java index 19e500be..12d1d1c7 100644 --- a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinPreProcessorStandard.java +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinPreProcessorStandard.java @@ -25,10 +25,7 @@ package org.spongepowered.asm.mixin.transformer; import java.lang.annotation.Annotation; -import java.util.Deque; import java.util.Iterator; -import java.util.LinkedList; -import java.util.List; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; @@ -52,7 +49,6 @@ import org.spongepowered.asm.mixin.transformer.ClassInfo.Field; import org.spongepowered.asm.mixin.transformer.ClassInfo.Method; import org.spongepowered.asm.mixin.transformer.meta.MixinRenamed; import org.spongepowered.asm.mixin.transformer.throwables.InvalidMixinException; -import org.spongepowered.asm.obfuscation.RemapperChain; import org.spongepowered.asm.util.ASMHelper; import org.spongepowered.asm.util.Constants; @@ -92,14 +88,16 @@ class MixinPreProcessorStandard { */ protected final ClassNode classNode; - private final boolean verboseLogging; + private final boolean verboseLogging, strictUnique; private boolean prepared, attached; MixinPreProcessorStandard(MixinInfo mixin, ClassNode classNode) { this.mixin = mixin; this.classNode = classNode; - this.verboseLogging = mixin.getParent().getEnvironment().getOption(Option.DEBUG_VERBOSE); + MixinEnvironment env = mixin.getParent().getEnvironment(); + this.verboseLogging = env.getOption(Option.DEBUG_VERBOSE); + this.strictUnique = env.getOption(Option.DEBUG_UNIQUE); } /** @@ -195,13 +193,18 @@ class MixinPreProcessorStandard { continue; } - if (this.processMemberMethod(context, mixinMethod, Shadow.class, true, true)) { + if (this.processShadowMethod(context, mixinMethod)) { iter.remove(); context.addShadowMethod(mixinMethod); continue; } - if (this.processMemberMethod(context, mixinMethod, Overwrite.class, false, false)) { + if (this.processOverwriteMethod(context, mixinMethod)) { + continue; + } + + if (this.processUniqueMethod(context, mixinMethod)) { + iter.remove(); continue; } @@ -222,28 +225,50 @@ class MixinPreProcessorStandard { String handlerName = context.getHandlerName(annotation, mixinMethod, surrogate); Method method = this.mixin.getClassInfo().findMethod(mixinMethod, ClassInfo.INCLUDE_ALL); + + if (method.isUnique()) { + MixinPreProcessorStandard.logger.warn("Redundant @Unique on injector method {} in {}. Injectors are implicitly unique", method, context); + } + method.renameTo(handlerName); mixinMethod.name = handlerName; + return true; } - protected boolean processMemberMethod(MixinTargetContext context, MethodNode mixinMethod, Class annotationType, - boolean mustExist, boolean mustBePrivate) { - AnnotationNode annotation = ASMHelper.getVisibleAnnotation(mixinMethod, annotationType); + protected boolean processShadowMethod(MixinTargetContext context, MethodNode mixinMethod) { + return this.processSpecialMethod(context, mixinMethod, Shadow.class, false); + } + + protected boolean processOverwriteMethod(MixinTargetContext context, MethodNode mixinMethod) { + return this.processSpecialMethod(context, mixinMethod, Overwrite.class, true); + } + + protected boolean processSpecialMethod(MixinTargetContext context, MethodNode mixinMethod, Class type, boolean overwrite) { + + AnnotationNode annotation = ASMHelper.getVisibleAnnotation(mixinMethod, type); if (annotation == null) { return false; } + if (this.mixin.isUnique() && overwrite) { + throw new InvalidMixinException(this.mixin, "@Overwrite method " + mixinMethod.name + " found in a @Unique mixin"); + } + Method method = this.mixin.getClassInfo().findMethod(mixinMethod, ClassInfo.INCLUDE_ALL); - MethodNode target = MixinPreProcessorStandard.findMethod(context.getTargetClass(), mixinMethod, annotation); + MethodNode target = context.findMethod(mixinMethod, annotation); + + if (method.isUnique()) { + throw new InvalidMixinException(this.mixin, ASMHelper.getSimpleName(type) + " method " + mixinMethod.name + " cannot be @Unique"); + } if (target == null) { - if (!mustExist) { + if (overwrite) { return false; } - target = MixinPreProcessorStandard.findRemappedMethod(context.getTargetClass(), mixinMethod); + target = context.findRemappedMethod(mixinMethod); if (target == null) { - throw new InvalidMixinException(this.mixin, annotationType.getSimpleName() + " method " + mixinMethod.name + throw new InvalidMixinException(this.mixin, ASMHelper.getSimpleName(type) + " method " + mixinMethod.name + " was not located in the target class"); } mixinMethod.name = target.name; @@ -255,7 +280,7 @@ class MixinPreProcessorStandard { } if (!target.name.equals(mixinMethod.name)) { - if (mustBePrivate && (target.access & Opcodes.ACC_PRIVATE) == 0) { + if (!overwrite && (target.access & Opcodes.ACC_PRIVATE) == 0) { throw new InvalidMixinException(this.mixin, "Non-private method cannot be aliased. Found " + target.name); } @@ -266,6 +291,37 @@ class MixinPreProcessorStandard { return true; } + protected boolean processUniqueMethod(MixinTargetContext context, MethodNode mixinMethod) { + Method method = this.mixin.getClassInfo().findMethod(mixinMethod, ClassInfo.INCLUDE_ALL); + if (method == null || (!method.isUnique() && !this.mixin.isUnique())) { + return false; + } + + MethodNode target = context.findMethod(mixinMethod, null); + if (target == null) { + return false; + } + + if ((mixinMethod.access & (Opcodes.ACC_PRIVATE | Opcodes.ACC_PROTECTED)) != 0) { + String uniqueName = context.getUniqueName(mixinMethod); + MixinPreProcessorStandard.logger.log(this.mixin.getLoggingLevel(), "Renaming @Unique method {}{} to {} in {}", + mixinMethod.name, mixinMethod.desc, uniqueName, this.mixin); + mixinMethod.name = uniqueName; + method.renameTo(uniqueName); + return false; + } + + if (this.strictUnique) { + throw new InvalidMixinException(this.mixin, "Method conflict, @Unique method " + mixinMethod.name + " in " + this.mixin + + " cannot overwrite " + target.name + target.desc + " in " + context.getTarget()); + } + + MixinPreProcessorStandard.logger.warn("Discarding @Unique public method {} in {} because it already exists in {}", mixinMethod.name, + this.mixin, context.getTarget()); + + return true; + } + protected void processMethod(MethodNode mixinMethod) { Method method = this.mixin.getClassInfo().findMethod(mixinMethod); if (method == null) { @@ -293,12 +349,12 @@ class MixinPreProcessorStandard { context.transformDescriptor(mixinField); Field field = this.mixin.getClassInfo().findField(mixinField); - FieldNode target = MixinPreProcessorStandard.findField(context.getTargetClass(), mixinField, shadow); + FieldNode target = context.findField(mixinField, shadow); if (target == null) { if (shadow == null) { continue; } - target = MixinPreProcessorStandard.findRemappedField(context.getTargetClass(), mixinField); + target = context.findRemappedField(mixinField); if (target == null) { // If this field is a shadow field but is NOT found in the target class, that's bad, mmkay throw new InvalidMixinException(this.mixin, "Shadow field " + mixinField.name + " was not located in the target class"); @@ -400,91 +456,4 @@ class MixinPreProcessorStandard { } } - protected static MethodNode findMethod(ClassNode classNode, MethodNode method, AnnotationNode annotation) { - Deque aliases = new LinkedList(); - aliases.add(method.name); - if (annotation != null) { - List aka = ASMHelper.>getAnnotationValue(annotation, "aliases"); - if (aka != null) { - aliases.addAll(aka); - } - } - - return MixinPreProcessorStandard.findMethodRecursive(classNode, aliases, method.desc); - } - - protected static MethodNode findRemappedMethod(ClassNode classNode, MethodNode method) { - RemapperChain remapperChain = MixinEnvironment.getCurrentEnvironment().getRemappers(); - String remappedName = remapperChain.mapMethodName(classNode.name, method.name, method.desc); - if (remappedName.equals(method.name)) { - return null; - } - - Deque aliases = new LinkedList(); - aliases.add(remappedName); - - return MixinPreProcessorStandard.findMethodRecursive(classNode, aliases, method.desc); - } - - private static MethodNode findMethodRecursive(ClassNode classNode, Deque aliases, String desc) { - String alias = aliases.poll(); - if (alias == null) { - return null; - } - - for (MethodNode target : classNode.methods) { - if (target.name.equals(alias) && target.desc.equals(desc)) { - return target; - } - } - - return MixinPreProcessorStandard.findMethodRecursive(classNode, aliases, desc); - } - - protected static FieldNode findField(ClassNode classNode, FieldNode field, AnnotationNode shadow) { - Deque aliases = new LinkedList(); - aliases.add(field.name); - if (shadow != null) { - List aka = ASMHelper.>getAnnotationValue(shadow, "aliases"); - if (aka != null) { - aliases.addAll(aka); - } - } - - return MixinPreProcessorStandard.findFieldRecursive(classNode, aliases, field.desc); - } - - protected static FieldNode findRemappedField(ClassNode classNode, FieldNode field) { - RemapperChain remapperChain = MixinEnvironment.getCurrentEnvironment().getRemappers(); - String remappedName = remapperChain.mapFieldName(classNode.name, field.name, field.desc); - if (remappedName.equals(field.name)) { - return null; - } - - Deque aliases = new LinkedList(); - aliases.add(remappedName); - return MixinPreProcessorStandard.findFieldRecursive(classNode, aliases, field.desc); - } - - /** - * Finds a field in the target class - * - * @param aliases - * @param desc - * @return Target field or null if not found - */ - private static FieldNode findFieldRecursive(ClassNode classNode, Deque aliases, String desc) { - String alias = aliases.poll(); - if (alias == null) { - return null; - } - - for (FieldNode target : classNode.fields) { - if (target.name.equals(alias) && target.desc.equals(desc)) { - return target; - } - } - - return MixinPreProcessorStandard.findFieldRecursive(classNode, aliases, desc); - } } diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTargetContext.java b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTargetContext.java index 76b8bdac..3e689a6e 100644 --- a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTargetContext.java +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTargetContext.java @@ -26,8 +26,10 @@ package org.spongepowered.asm.mixin.transformer; import java.util.ArrayList; import java.util.Collection; +import java.util.Deque; import java.util.Iterator; import java.util.LinkedHashMap; +import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.Map.Entry; @@ -58,6 +60,7 @@ import org.spongepowered.asm.mixin.transformer.ClassInfo.Traversal; import org.spongepowered.asm.mixin.transformer.meta.MixinMerged; import org.spongepowered.asm.mixin.transformer.throwables.InvalidMixinException; import org.spongepowered.asm.mixin.transformer.throwables.MixinTransformerError; +import org.spongepowered.asm.obfuscation.RemapperChain; import org.spongepowered.asm.util.ASMHelper; import org.spongepowered.asm.util.Constants; @@ -148,7 +151,7 @@ public class MixinTargetContext implements IReferenceMapperContext { * * @param mixin Mixin information * @param classNode Mixin classnode - * @param target target class + * @param context target class */ MixinTargetContext(MixinInfo mixin, ClassNode classNode, TargetClassContext context) { this.mixin = mixin; @@ -233,6 +236,15 @@ public class MixinTargetContext implements IReferenceMapperContext { public String getClassRef() { return this.mixin.getClassRef(); } + + /** + * Get the target class context + * + * @return the target class context + */ + public TargetClassContext getTarget() { + return this.targetClass; + } /** * Get the target class reference @@ -249,7 +261,7 @@ public class MixinTargetContext implements IReferenceMapperContext { * * @return the target class */ - public ClassNode getTargetClass() { + public ClassNode getTargetClassNode() { return this.targetClass.getClassNode(); } @@ -755,6 +767,57 @@ public class MixinTargetContext implements IReferenceMapperContext { return this.targetClass.getTargetMethod(method); } + MethodNode findMethod(MethodNode method, AnnotationNode annotation) { + Deque aliases = new LinkedList(); + aliases.add(method.name); + if (annotation != null) { + List aka = ASMHelper.>getAnnotationValue(annotation, "aliases"); + if (aka != null) { + aliases.addAll(aka); + } + } + + return this.targetClass.findAliasedMethod(aliases, method.desc); + } + + MethodNode findRemappedMethod(MethodNode method) { + RemapperChain remapperChain = MixinEnvironment.getCurrentEnvironment().getRemappers(); + String remappedName = remapperChain.mapMethodName(this.targetClass.getName(), method.name, method.desc); + if (remappedName.equals(method.name)) { + return null; + } + + Deque aliases = new LinkedList(); + aliases.add(remappedName); + + return this.targetClass.findAliasedMethod(aliases, method.desc); + } + + FieldNode findField(FieldNode field, AnnotationNode shadow) { + Deque aliases = new LinkedList(); + aliases.add(field.name); + if (shadow != null) { + List aka = ASMHelper.>getAnnotationValue(shadow, "aliases"); + if (aka != null) { + aliases.addAll(aka); + } + } + + return this.targetClass.findAliasedField(aliases, field.desc); + } + + FieldNode findRemappedField(FieldNode field) { + RemapperChain remapperChain = MixinEnvironment.getCurrentEnvironment().getRemappers(); + String remappedName = remapperChain.mapFieldName(this.targetClass.getName(), field.name, field.desc); + if (remappedName.equals(field.name)) { + return null; + } + + Deque aliases = new LinkedList(); + aliases.add(remappedName); + return this.targetClass.findAliasedField( aliases, field.desc); + } + /** * Mark this mixin as requiring the specified class version in the context * of the current target @@ -907,11 +970,15 @@ public class MixinTargetContext implements IReferenceMapperContext { this.mixin.postApply(transformedName, targetClass); } - + public String getHandlerName(AnnotationNode annotation, MethodNode method, boolean surrogate) { return this.targetClass.getHandlerName(annotation, method, surrogate); } + public String getUniqueName(MethodNode method) { + return this.targetClass.getUniqueName(method); + } + /** * Scans the target class for injector methods and prepares discovered * injectors diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/TargetClassContext.java b/src/main/java/org/spongepowered/asm/mixin/transformer/TargetClassContext.java index 32ec4cfc..ff5335f7 100644 --- a/src/main/java/org/spongepowered/asm/mixin/transformer/TargetClassContext.java +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/TargetClassContext.java @@ -24,6 +24,7 @@ */ package org.spongepowered.asm.mixin.transformer; +import java.util.Deque; import java.util.HashMap; import java.util.List; import java.util.Map; @@ -31,6 +32,7 @@ import java.util.SortedSet; import org.spongepowered.asm.lib.tree.AnnotationNode; import org.spongepowered.asm.lib.tree.ClassNode; +import org.spongepowered.asm.lib.tree.FieldNode; import org.spongepowered.asm.lib.tree.MethodNode; import org.spongepowered.asm.mixin.Debug; import org.spongepowered.asm.mixin.MixinEnvironment; @@ -91,6 +93,11 @@ class TargetClassContext { * Do not remap injector handler methods (debug option) */ private final boolean disableHandlerRemap; + + /** + * Unique method index + */ + private int nextUniqueMethodIndex = 0; /** * True once mixins have been applied to this class @@ -112,6 +119,11 @@ class TargetClassContext { this.disableHandlerRemap = MixinEnvironment.getCurrentEnvironment().getOption(Option.DEBUG_DISABLE_HANDLER_REMAP); } + @Override + public String toString() { + return this.className; + } + public boolean isApplied() { return this.applied; } @@ -154,6 +166,13 @@ class TargetClassContext { public List getMethods() { return this.classNode.methods; } + + /** + * Get the class fields (from the tree) + */ + public List getFields() { + return this.classNode.fields; + } /** * Get the target class metadata @@ -168,7 +187,44 @@ class TargetClassContext { public SortedSet getMixins() { return this.mixins; } + + MethodNode findAliasedMethod(Deque aliases, String desc) { + String alias = aliases.poll(); + if (alias == null) { + return null; + } + + for (MethodNode target : this.classNode.methods) { + if (target.name.equals(alias) && target.desc.equals(desc)) { + return target; + } + } + + return this.findAliasedMethod(aliases, desc); + } + /** + * Finds a field in the target class + * + * @param aliases + * @param desc + * @return Target field or null if not found + */ + FieldNode findAliasedField(Deque aliases, String desc) { + String alias = aliases.poll(); + if (alias == null) { + return null; + } + + for (FieldNode target : this.classNode.fields) { + if (target.name.equals(alias) && target.desc.equals(desc)) { + return target; + } + } + + return this.findAliasedField(aliases, desc); + } + /** * Get a target method handle from the target class * @@ -204,6 +260,10 @@ class TargetClassContext { } return String.format("%s$%s$%d", InjectionInfo.getInjectorPrefix(annotation), method.name, id.value); } + + public String getUniqueName(MethodNode method) { + return String.format("md%s$%s$%d", this.sessionId.substring(30), method.name, this.nextUniqueMethodIndex++); + } /** * Apply mixins to this class @@ -226,7 +286,7 @@ class TargetClassContext { /** - * Process {@link Debug) annotations on the class after application + * Process {@link Debug} annotations on the class after application */ public void processDebugTasks() { if (!MixinEnvironment.getCurrentEnvironment().getOption(Option.DEBUG_VERBOSE)) { diff --git a/src/main/java/org/spongepowered/asm/util/ASMHelper.java b/src/main/java/org/spongepowered/asm/util/ASMHelper.java index 9fece0dc..ac6d8e34 100644 --- a/src/main/java/org/spongepowered/asm/util/ASMHelper.java +++ b/src/main/java/org/spongepowered/asm/util/ASMHelper.java @@ -1025,6 +1025,10 @@ public class ASMHelper { return arg == null ? "" : arg.toString(); } + public static String getSimpleName(Class annotationType) { + return String.format("@%s", annotationType.getSimpleName()); + } + public static String getSimpleName(AnnotationNode annotation) { return ASMHelper.getSimpleName(annotation.desc); }