From 404f5da0b6b18980b4e44c7f1cfeddcd47fe4aa6 Mon Sep 17 00:00:00 2001 From: Mumfrey Date: Wed, 18 Oct 2017 13:14:46 +0100 Subject: [PATCH] 0.7.5 - Add support for Coerce annotation on redirect handler args --- README.MD | 9 + gradle.properties | 2 +- .../asm/launch/MixinBootstrap.java | 2 +- .../asm/mixin/injection/Coerce.java | 25 ++- .../injection/invoke/RedirectInjector.java | 165 +++++++++++++----- 5 files changed, 146 insertions(+), 57 deletions(-) diff --git a/README.MD b/README.MD index 6bacbe48..c5a6598f 100644 --- a/README.MD +++ b/README.MD @@ -592,5 +592,14 @@ plugin developed by [DemonWav](https://github.com/demonwav). September 2017 + + 0.7.5 + + + + October 2017 + diff --git a/gradle.properties b/gradle.properties index 75580b6d..32bc6fbd 100644 --- a/gradle.properties +++ b/gradle.properties @@ -4,5 +4,5 @@ packaging=jar description=Mixin url=https://www.spongepowered.org organization=SpongePowered -buildVersion=0.7.4 +buildVersion=0.7.5 buildType=SNAPSHOT diff --git a/src/main/java/org/spongepowered/asm/launch/MixinBootstrap.java b/src/main/java/org/spongepowered/asm/launch/MixinBootstrap.java index 3d8ebf1b..70043c1a 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.7.4"; + public static final String VERSION = "0.7.5"; /** * Log all the things diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/Coerce.java b/src/main/java/org/spongepowered/asm/mixin/injection/Coerce.java index 8bdb9bd3..d512d18a 100644 --- a/src/main/java/org/spongepowered/asm/mixin/injection/Coerce.java +++ b/src/main/java/org/spongepowered/asm/mixin/injection/Coerce.java @@ -28,14 +28,16 @@ import java.lang.annotation.ElementType; import java.lang.annotation.Target; /** - * This annotation has two usages applicable to Callback Injectors (defined - * using {@link Inject}. For local capture injectors, it indicates that the - * injector should coerce top-level primitive types to covariant types defined - * on the handler. For other injectors, it can be used on a reference type to - * indicate that the intended type is covariant over the argument type (or that - * the argument type is contravariant on the target class type). This can be - * used for multi-target injectors with a bounded type argument on the class or - * target method. + *

Usage with callback injectors (@Inject)

+ * + *

This annotation has two usages applicable to Callback Injectors (defined + * using {@link Inject @Inject}. For local capture injectors, it indicates + * that the injector should coerce top-level primitive types (int) to covariant + * types defined on the handler. For other injectors, it can be used on a + * reference type to indicate that the intended type is covariant over the + * argument type (or that the argument type is contravariant on the target class + * type). This can be used for multi-target injectors with a bounded type + * argument on the class or target method.

* *

During LVT generation it is not always possible to inflect the exact local * type for types represented internally as integers, for example booleans and @@ -47,6 +49,13 @@ import java.lang.annotation.Target; *

This annotation allows a covariant type parameter to be marked, and thus * coerced to the correct type when the LVT generation would otherwise mark the * type as invalid.

+ * + *

Usage with redirect injectors (@Redirect)

+ * + *

Similarly to callback injectors, @Coerce can be used to + * indicate that an incoming parameter can be consumed as a valid supertype, up + * to and including {@link Object}. This is particularly useful when an argument + * on the target method invocation is inaccessible or unknown.

*/ @Target({ ElementType.PARAMETER }) public @interface Coerce { diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/invoke/RedirectInjector.java b/src/main/java/org/spongepowered/asm/mixin/injection/invoke/RedirectInjector.java index ce34f41a..f558d55b 100644 --- a/src/main/java/org/spongepowered/asm/mixin/injection/invoke/RedirectInjector.java +++ b/src/main/java/org/spongepowered/asm/mixin/injection/invoke/RedirectInjector.java @@ -31,24 +31,18 @@ import java.util.Set; import org.spongepowered.asm.lib.Opcodes; import org.spongepowered.asm.lib.Type; -import org.spongepowered.asm.lib.tree.AbstractInsnNode; -import org.spongepowered.asm.lib.tree.FieldInsnNode; -import org.spongepowered.asm.lib.tree.InsnList; -import org.spongepowered.asm.lib.tree.InsnNode; -import org.spongepowered.asm.lib.tree.JumpInsnNode; -import org.spongepowered.asm.lib.tree.LabelNode; -import org.spongepowered.asm.lib.tree.MethodInsnNode; -import org.spongepowered.asm.lib.tree.TypeInsnNode; -import org.spongepowered.asm.lib.tree.VarInsnNode; +import org.spongepowered.asm.lib.tree.*; import org.spongepowered.asm.mixin.Final; +import org.spongepowered.asm.mixin.MixinEnvironment.Option; +import org.spongepowered.asm.mixin.injection.Coerce; import org.spongepowered.asm.mixin.injection.InjectionPoint; import org.spongepowered.asm.mixin.injection.Redirect; import org.spongepowered.asm.mixin.injection.code.Injector; import org.spongepowered.asm.mixin.injection.points.BeforeFieldAccess; import org.spongepowered.asm.mixin.injection.points.BeforeNew; import org.spongepowered.asm.mixin.injection.struct.InjectionInfo; -import org.spongepowered.asm.mixin.injection.struct.Target; import org.spongepowered.asm.mixin.injection.struct.InjectionNodes.InjectionNode; +import org.spongepowered.asm.mixin.injection.struct.Target; import org.spongepowered.asm.mixin.injection.throwables.InvalidInjectionException; import org.spongepowered.asm.util.Annotations; import org.spongepowered.asm.util.Bytecode; @@ -129,7 +123,7 @@ public class RedirectInjector extends InvokeInjector { /** * Meta decoration for wildcard ctor redirects */ - class ConstructorRedirectData { + static class ConstructorRedirectData { public static final String KEY = "ctor"; @@ -137,6 +131,30 @@ public class RedirectInjector extends InvokeInjector { } + /** + * Data bundle for invoke redirectors + */ + static class RedirectedInvoke { + + final Target target; + final MethodInsnNode node; + final Type returnType; + final Type[] args; + final Type[] locals; + + boolean captureTargetArgs = false; + + RedirectedInvoke(Target target, MethodInsnNode node) { + this.target = target; + this.node = node; + this.returnType = Type.getReturnType(node.desc); + this.args = Type.getArgumentTypes(node.desc); + this.locals = node.getOpcode() == Opcodes.INVOKESTATIC + ? this.args + : ObjectArrays.concat(Type.getType("L" + node.owner + ";"), this.args); + } + } + protected Meta meta; private Map ctorRedirectors = new HashMap(); @@ -181,8 +199,8 @@ public class RedirectInjector extends InvokeInjector { this.annotationType, this.info, this.meta.priority, other.name, other.priority); return; } else if (other.isFinal) { - throw new InvalidInjectionException(this.info, this.annotationType + " conflict: " + this - + " failed because target was already remapped by " + other.name); + throw new InvalidInjectionException(this.info, String.format("%s conflict: %s failed because target was already remapped by %s", + this.annotationType, this, other.name)); } } } @@ -243,14 +261,15 @@ public class RedirectInjector extends InvokeInjector { if (node.getCurrentTarget() instanceof TypeInsnNode && node.getCurrentTarget().getOpcode() == Opcodes.NEW) { if (!this.isStatic && target.isStatic) { - throw new InvalidInjectionException(this.info, "non-static callback method " + this + " has a static target which is not supported"); + throw new InvalidInjectionException(this.info, String.format( + "non-static callback method %s has a static target which is not supported", this)); } this.injectAtConstructor(target, node); return; } - throw new InvalidInjectionException(this.info, this.annotationType + " annotation on is targetting an invalid insn in " - + target + " in " + this); + throw new InvalidInjectionException(this.info, String.format("%s annotation on is targetting an invalid insn in %s in %s", + this.annotationType, target, this)); } protected boolean preInject(InjectionNode node) { @@ -270,7 +289,7 @@ public class RedirectInjector extends InvokeInjector { ConstructorRedirectData meta = node.getDecoration(ConstructorRedirectData.KEY); boolean wildcard = node.getDecoration(RedirectInjector.KEY_WILD).booleanValue(); if (wildcard && meta.injected == 0) { - throw new InvalidInjectionException(this.info, this.annotationType + " ctor invocation was not found in " + target); + throw new InvalidInjectionException(this.info, String.format("%s ctor invocation was not found in %s", this.annotationType, target)); } } } @@ -280,41 +299,91 @@ public class RedirectInjector extends InvokeInjector { */ @Override protected void injectAtInvoke(Target target, InjectionNode node) { - final MethodInsnNode methodNode = (MethodInsnNode)node.getCurrentTarget(); - final boolean targetIsStatic = methodNode.getOpcode() == Opcodes.INVOKESTATIC; - final Type ownerType = Type.getType("L" + methodNode.owner + ";"); - final Type returnType = Type.getReturnType(methodNode.desc); - final Type[] args = Type.getArgumentTypes(methodNode.desc); - final Type[] stackVars = targetIsStatic ? args : ObjectArrays.concat(ownerType, args); - boolean injectTargetParams = false; + RedirectedInvoke invoke = new RedirectedInvoke(target, (MethodInsnNode)node.getCurrentTarget()); - String desc = Bytecode.getDescriptor(stackVars, returnType); - if (!desc.equals(this.methodNode.desc)) { - String alternateDesc = Bytecode.getDescriptor(ObjectArrays.concat(stackVars, target.arguments, Type.class), returnType); - if (alternateDesc.equals(this.methodNode.desc)) { - injectTargetParams = true; - } else { - throw new InvalidInjectionException(this.info, this.annotationType + " handler method " + this - + " has an invalid signature, expected " + desc + " found " + this.methodNode.desc); - } - } + this.validateParams(invoke); InsnList insns = new InsnList(); - int extraLocals = Bytecode.getArgsSize(stackVars) + 1; + int extraLocals = Bytecode.getArgsSize(invoke.locals) + 1; int extraStack = 1; // Normally only need 1 extra stack pos to store target ref - int[] argMap = this.storeArgs(target, stackVars, insns, 0); - if (injectTargetParams) { + int[] argMap = this.storeArgs(target, invoke.locals, insns, 0); + if (invoke.captureTargetArgs) { int argSize = Bytecode.getArgsSize(target.arguments); extraLocals += argSize; extraStack += argSize; argMap = Ints.concat(argMap, target.getArgIndices()); } AbstractInsnNode insn = this.invokeHandlerWithArgs(this.methodArgs, insns, argMap); - target.replaceNode(methodNode, insn, insns); + target.replaceNode(invoke.node, insn, insns); target.addToLocals(extraLocals); target.addToStack(extraStack); } + /** + * Perform validation of an invoke handler parameters, each parameter in the + * handler must match the expected type or be annotated with {@link Coerce} + * and be a supported supertype of the incoming type. + * + * @param invoke invocation being redirected + */ + protected void validateParams(RedirectedInvoke invoke) { + int argc = this.methodArgs.length; + + String description = String.format("%s handler method %s", this.annotationType, this); + if (!invoke.returnType.equals(this.returnType)) { + throw new InvalidInjectionException(this.info, String.format("%s has an invalid signature. Expected return type %s found %s", + description, this.returnType, invoke.returnType)); + } + + for (int index = 0; index < argc; index++) { + Type toType = null; + if (index >= this.methodArgs.length) { + throw new InvalidInjectionException(this.info, String.format( + "%s has an invalid signature. Not enough arguments found for capture of target method args, expected %d but found %d", + description, argc, this.methodArgs.length)); + } + + Type fromType = this.methodArgs[index]; + + if (index < invoke.locals.length) { + toType = invoke.locals[index]; + } else { + invoke.captureTargetArgs = true; + argc = Math.max(argc, invoke.locals.length + invoke.target.arguments.length); + int arg = index - invoke.locals.length; + if (arg >= invoke.target.arguments.length) { + throw new InvalidInjectionException(this.info, String.format( + "%s has an invalid signature. Found unexpected additional target argument with type %s at index %d", + description, fromType, index)); + } + toType = invoke.target.arguments[arg]; + } + + AnnotationNode coerce = Annotations.getInvisibleParameter(this.methodNode, Coerce.class, index); + + if (fromType.equals(toType)) { + if (coerce != null && this.info.getContext().getOption(Option.DEBUG_VERBOSE)) { + Injector.logger.warn("Redundant @Coerce on {} argument {}, {} is identical to {}", description, index, toType, fromType); + } + + continue; + } + + boolean canCoerce = Injector.canCoerce(fromType, toType); + if (coerce == null) { + throw new InvalidInjectionException(this.info, String.format( + "%s has an invalid signature. Found unexpected argument type %s at index %d, expected %s", + description, fromType, index, toType)); + } + + if (!canCoerce) { + throw new InvalidInjectionException(this.info, String.format( + "%s has an invalid signature. Cannot @Coerce argument type %s at index %d to %s", + description, toType, index, fromType)); + } + } + } + /** * Redirect a field get or set operation, or an array element access */ @@ -344,7 +413,8 @@ public class RedirectInjector extends InvokeInjector { private void injectAtArrayField(Target target, FieldInsnNode fieldNode, int opCode, Type ownerType, Type fieldType, int fuzz, int opcode) { Type elementType = fieldType.getElementType(); if (opCode != Opcodes.GETSTATIC && opCode != Opcodes.GETFIELD) { - throw new InvalidInjectionException(this.info, "Unspported opcode " + Bytecode.getOpcodeName(opCode) + " for array access " + this.info); + throw new InvalidInjectionException(this.info, String.format("Unspported opcode %s for array access %s", + Bytecode.getOpcodeName(opCode), this.info)); } else if (this.returnType.getSort() != Type.VOID) { if (opcode != Opcodes.ARRAYLENGTH) { opcode = elementType.getOpcode(Opcodes.IALOAD); @@ -391,8 +461,9 @@ public class RedirectInjector extends InvokeInjector { public void injectArrayRedirect(Target target, FieldInsnNode fieldNode, AbstractInsnNode varNode, boolean withArgs, String type) { if (varNode == null) { String advice = ""; - throw new InvalidInjectionException(this.info, "Array element " + this.annotationType + " on " + this + " could not locate a matching " - + type + " instruction in " + target + ". " + advice); + throw new InvalidInjectionException(this.info, String.format( + "Array element %s on %s could not locate a matching %s instruction in %s. %s", + this.annotationType, this, type, target, advice)); } if (!this.isStatic) { @@ -425,7 +496,7 @@ public class RedirectInjector extends InvokeInjector { } else if (opCode == Opcodes.PUTSTATIC || opCode == Opcodes.PUTFIELD) { invoke = this.injectAtPutField(insns, target, fieldNode, opCode == Opcodes.PUTSTATIC, ownerType, fieldType); } else { - throw new InvalidInjectionException(this.info, "Unspported opcode " + Bytecode.getOpcodeName(opCode) + " for " + this.info); + throw new InvalidInjectionException(this.info, String.format("Unspported opcode %s for %s", Bytecode.getOpcodeName(opCode), this.info)); } target.replaceNode(fieldNode, invoke, insns); @@ -510,8 +581,8 @@ public class RedirectInjector extends InvokeInjector { return true; } - throw new InvalidInjectionException(this.info, this.annotationType + " method " + type + " " + this - + " has an invalid signature. Expected " + desc + " but found " + this.methodNode.desc); + throw new InvalidInjectionException(this.info, String.format("%s method %s %s has an invalid signature. Expected %s but found %s", + this.annotationType, type, this, desc, this.methodNode.desc)); } protected void injectAtConstructor(Target target, InjectionNode node) { @@ -524,7 +595,7 @@ public class RedirectInjector extends InvokeInjector { if (initNode == null) { if (!wildcard) { - throw new InvalidInjectionException(this.info, this.annotationType + " ctor invocation was not found in " + target); + throw new InvalidInjectionException(this.info, String.format("%s ctor invocation was not found in %s", this.annotationType, target)); } return; } @@ -567,8 +638,8 @@ public class RedirectInjector extends InvokeInjector { LabelNode nullCheckSucceeded = new LabelNode(); insns.add(new InsnNode(Opcodes.DUP)); insns.add(new JumpInsnNode(Opcodes.IFNONNULL, nullCheckSucceeded)); - this.throwException(insns, "java/lang/NullPointerException", this.annotationType + " constructor handler " + this - + " returned null for " + newNode.desc.replace('/', '.')); + this.throwException(insns, "java/lang/NullPointerException", String.format("%s constructor handler %s returned null for %s", + this.annotationType, this, newNode.desc.replace('/', '.'))); insns.add(nullCheckSucceeded); target.addToStack(1); } else {