Extra callback for cfg plugins, sort configs & overwrites, references #8

This commit is contained in:
Mumfrey committed 2015-01-14 16:22:15 +00:00
1 parent 3f3950d7f4
commit c73ba14656
6 files changed
+328 -38

No files matched your search

@@ -25,6 +25,7 @@
package org.spongepowered.asm.mixin.extensibility;
import java.util.List;
import java.util.Set;
import org.objectweb.asm.tree.ClassNode;
@@ -65,6 +66,16 @@ public interface IMixinConfigPlugin {
*/
public abstract boolean shouldApplyMixin(String targetClassName, String mixinClassName);
/**
* Called after all configurations are initialised, this allows this plugin to observe classes targetted by other mixin configs and optionally
* remove targets from its own set. The set myTargets is a direct view of the targets collection in this companion config and keys may be removed
* from this set to suppress mixins in this config which target the specified class. Adding keys to the set will have no effect.
*
* @param myTargets Target class set from the companion config
* @param otherTargets Target class set incorporating targets from all other configs, read-only
*/
public abstract void acceptTargets(Set<String> myTargets, Set<String> otherTargets);
/**
* After mixins specified in the configuration have been processed, this method is called to allow the plugin to add any additional mixins to
* load. It should return a list of mixin class names or return null if the plugin does not wish to append any mixins of its own.
@@ -46,8 +46,13 @@ import com.google.gson.annotations.SerializedName;
/**
* Mixin configuration bundle
*/
class MixinConfig {
class MixinConfig implements Comparable<MixinConfig> {
/**
* Global order of mixin configs, used to determine ordering between configs with equivalent priority
*/
private static int configOrder = 0;
/**
* Global list of mixin classes, so we can skip any duplicates
*/
@@ -63,6 +68,12 @@ class MixinConfig {
*/
private final transient Map<String, List<MixinInfo>> mixinMapping = new HashMap<String, List<MixinInfo>>();
/**
* Configuration priority
*/
@SerializedName("priority")
private final int priority = 1000;
/**
* Package containing all mixins. This package will be monitored by the transformer so that we can explode if some dummy tries to reference a
* mixin class directly.
@@ -100,6 +111,11 @@ class MixinConfig {
@SerializedName("referenceMap")
private String refMapperConfig;
/**
* Intrinsic order (for sorting configurations with identical priority)
*/
private final transient int order = MixinConfig.configOrder++;
/**
* Name of the file this config was initialised from
*/
@@ -179,7 +195,10 @@ class MixinConfig {
* <p>For this reason we will invoke the initialisation on the first call to either the <em>hasMixinsFor()</em> or <em>getMixinsFor()</em>
* methods.</p>
*/
private void initialise() {
void initialise() {
if (this.initialised) {
return;
}
this.initialised = true;
this.initialiseMixins(this.mixinClasses, false);
@@ -195,7 +214,9 @@ class MixinConfig {
this.logger.warn("Mixin environment was unable to detect the current side, sided mixins will not be applied");
break;
}
}
void postInitialise() {
if (this.plugin != null) {
List<String> pluginMixins = this.plugin.getMixins();
this.initialiseMixins(pluginMixins, true);
@@ -261,6 +282,20 @@ class MixinConfig {
return this.refMapper;
}
/**
* Get the companion plugin, if available
*/
public IMixinConfigPlugin getPlugin() {
return this.plugin;
}
/**
* Get targets for this configuration
*/
public Set<String> getTargets() {
return this.mixinMapping.keySet();
}
/**
* Check whether this configuration bundle has a mixin for the specified class
*
@@ -268,10 +303,6 @@ class MixinConfig {
* @return
*/
public boolean hasMixinsFor(String targetClass) {
if (!this.initialised) {
this.initialise();
}
return this.mixinMapping.containsKey(targetClass);
}
@@ -282,10 +313,6 @@ class MixinConfig {
* @return
*/
public List<MixinInfo> getMixinsFor(String targetClass) {
if (!this.initialised) {
this.initialise();
}
return this.mixinsFor(targetClass);
}
@@ -297,6 +324,20 @@ class MixinConfig {
}
return mixins;
}
/* (non-Javadoc)
* @see java.lang.Comparable#compareTo(java.lang.Object)
*/
@Override
public int compareTo(MixinConfig other) {
if (other == null) {
return 0;
}
if (other.priority == this.priority) {
return this.order - other.order;
}
return (this.priority - other.priority);
}
/**
* Factory method, creates a new mixin configuration bundle from the specified configFile, which must be accessible on the classpath
@@ -163,6 +163,13 @@ public class MixinData {
return target;
}
/**
* Get the mixin priority
*/
public int getPriority() {
return this.info.getPriority();
}
/**
* Get all interfaces for this mixin
*/
@@ -0,0 +1,50 @@
/*
* This file is part of Sponge, licensed under the MIT License (MIT).
*
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
* Copyright (c) contributors
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.spongepowered.asm.mixin.transformer;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* <p><b>For internal use only!</b> Contains small parts. Keep out of reach of children.</p>
*
* <p>Decoration annotation used by the {@link MixinTransformer} to mark methods in a class which have been added or overwritten by a mixin.</p>
*/
@Target({ ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
public @interface MixinMerged {
/**
* Mixin which merged this method
*/
public String mixin();
/**
* Prioriy of the mixin which merged this method, used to allow mixins with higher priority to overwrite methods already overwritten by those
* with a lower priority.
*/
public int priority();
}
@@ -32,6 +32,9 @@ import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.UUID;
import net.minecraft.launchwrapper.IClassTransformer;
import net.minecraft.launchwrapper.Launch;
@@ -43,6 +46,7 @@ import org.apache.logging.log4j.core.helpers.Booleans;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
import org.objectweb.asm.tree.AbstractInsnNode;
import org.objectweb.asm.tree.AnnotationNode;
import org.objectweb.asm.tree.ClassNode;
import org.objectweb.asm.tree.FieldInsnNode;
import org.objectweb.asm.tree.FieldNode;
@@ -55,6 +59,8 @@ import org.spongepowered.asm.mixin.InvalidMixinException;
import org.spongepowered.asm.mixin.MixinEnvironment;
import org.spongepowered.asm.mixin.Overwrite;
import org.spongepowered.asm.mixin.Shadow;
import org.spongepowered.asm.mixin.extensibility.IMixinConfigPlugin;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.struct.InjectionInfo;
import org.spongepowered.asm.transformers.TreeTransformer;
import org.spongepowered.asm.util.ASMHelper;
@@ -130,11 +136,24 @@ public class MixinTransformer extends TreeTransformer {
*/
private final List<MixinConfig> configs = new ArrayList<MixinConfig>();
/**
* True once initialisation is done. All mixin configs needs to be initialised as late as possible in startup (so that other transformers have
* had time to register) but before any game classes are transformed. To do this we initialise the configs on the first call to {@link #transform}
* and this flag keeps track of when we've done this.
*/
private boolean initDone;
/**
* Sanity check for this transformer. The transformer should never be re-entrant by design so we need to detect and warn when it happens.
*/
private int reEntranceCheck = 0;
/**
* Session ID, used as a check when parsing {@link MixinMerged} annotations to prevent them being applied at compile time by people trying to
* circumvent mixin application
*/
private final String sessionId = UUID.randomUUID().toString();
/**
* ctor
*/
@@ -159,6 +178,8 @@ public class MixinTransformer extends TreeTransformer {
}
}
}
Collections.sort(this.configs);
}
/* (non-Javadoc)
@@ -172,19 +193,35 @@ public class MixinTransformer extends TreeTransformer {
this.detectReEntrance();
}
if (!this.initDone) {
this.initConfigs();
this.initDone = true;
}
try {
SortedSet<MixinInfo> mixins = null;
for (MixinConfig config : this.configs) {
if (transformedName != null && transformedName.startsWith(config.getMixinPackage())) {
throw new RuntimeException(String.format("%s is a mixin class and cannot be referenced directly", transformedName));
}
if (config.hasMixinsFor(transformedName)) {
try {
basicClass = this.applyMixins(config, transformedName, basicClass);
} catch (InvalidMixinException th) {
this.logger.warn(String.format("Class mixin failed: %s %s", th.getClass().getName(), th.getMessage()), th);
th.printStackTrace();
if (mixins == null) {
mixins = new TreeSet<MixinInfo>();
}
// Get and sort mixins for the class
mixins.addAll(config.getMixinsFor(transformedName));
}
}
if (mixins != null) {
try {
basicClass = this.applyMixins(transformedName, basicClass, mixins);
} catch (InvalidMixinException th) {
this.logger.warn(String.format("Class mixin failed: %s %s", th.getClass().getName(), th.getMessage()), th);
th.printStackTrace();
}
}
@@ -194,6 +231,43 @@ public class MixinTransformer extends TreeTransformer {
}
}
/**
* Initialise mixin configs
*/
private void initConfigs() {
for (MixinConfig config : this.configs) {
try {
config.initialise();
} catch (Exception ex) {
this.logger.error("Error encountered whilst initialising mixin config '" + config.getName() + "': " + ex.getMessage(), ex);
}
}
for (MixinConfig config : this.configs) {
IMixinConfigPlugin plugin = config.getPlugin();
if (plugin == null) {
continue;
}
Set<String> otherTargets = new HashSet<String>();
for (MixinConfig otherConfig : this.configs) {
if (!otherConfig.equals(config)) {
otherTargets.addAll(otherConfig.getTargets());
}
}
plugin.acceptTargets(config.getTargets(), Collections.unmodifiableSet(otherTargets));
}
for (MixinConfig config : this.configs) {
try {
config.postInitialise();
} catch (Exception ex) {
this.logger.error("Error encountered during mixin config postInit setp'" + config.getName() + "': " + ex.getMessage(), ex);
}
}
}
/**
* If re-entrance is detected, attempt to find the source and log a warning
*/
@@ -218,19 +292,15 @@ public class MixinTransformer extends TreeTransformer {
/**
* Apply mixins for specified target class to the class described by the supplied byte array
*
* @param config
* @param transformedName
* @param basicClass
* @param mixins
* @return
*/
private byte[] applyMixins(MixinConfig config, String transformedName, byte[] basicClass) {
private byte[] applyMixins(String transformedName, byte[] basicClass, SortedSet<MixinInfo> mixins) {
// Tree for target class
ClassNode targetClass = this.readClass(basicClass, true);
// Get and sort mixins for the class
List<MixinInfo> mixins = config.getMixinsFor(transformedName);
Collections.sort(mixins);
for (MixinInfo mixin : mixins) {
this.logger.info("Mixing {} into {}", mixin.getName(), transformedName);
this.applyMixin(transformedName, targetClass, mixin.createData(targetClass));
@@ -259,7 +329,7 @@ public class MixinTransformer extends TreeTransformer {
* @param targetClass
* @param mixins
*/
protected void postTransform(String transformedName, ClassNode targetClass, List<MixinInfo> mixins) {
protected void postTransform(String transformedName, ClassNode targetClass, SortedSet<MixinInfo> mixins) {
// Stub for subclasses
}
@@ -374,13 +444,7 @@ public class MixinTransformer extends TreeTransformer {
String.format("Mixin classes cannot contain visible static methods or fields, found %s", mixinMethod.name));
}
MethodNode target = this.findTargetMethod(targetClass, mixinMethod);
if (target != null) {
targetClass.methods.remove(target);
} else if (isOverwrite) {
throw new InvalidMixinException(String.format("Overwrite target %s was not located in the target class", mixinMethod.name));
}
targetClass.methods.add(mixinMethod);
this.mergeMethod(targetClass, mixin, mixinMethod, isOverwrite);
} else if (MixinTransformer.CLINIT.equals(mixinMethod.name)) {
// Class initialiser insns get appended
this.appendInsns(targetClass, mixinMethod.name, mixinMethod);
@@ -441,6 +505,48 @@ public class MixinTransformer extends TreeTransformer {
}
}
/**
* Attempts to merge the supplied method into the target class
*
* @param targetClass Target class to merge into
* @param mixin Mixin being applied
* @param method Method to merge
* @param isOverwrite true if the method is annotated with an {@link Overwrite} annotation
*/
private void mergeMethod(ClassNode targetClass, MixinData mixin, MethodNode method, boolean isOverwrite) {
MethodNode target = this.findTargetMethod(targetClass, method);
if (target != null) {
AnnotationNode merged = ASMHelper.getVisibleAnnotation(target, MixinMerged.class);
if (merged != null) {
String sessionId = ASMHelper.getAnnotationValue(merged, "sessionId");
if (!this.sessionId.equals(sessionId)) {
throw new ClassFormatError("Invalid @MixinMerged annotation found in" + mixin + " at " + method.name + " in " + targetClass.name);
}
String owner = ASMHelper.getAnnotationValue(merged, "mixin");
int priority = ASMHelper.getAnnotationValue(merged, "priority");
if (priority >= mixin.getPriority() && !owner.equals(mixin.getClassName())) {
this.logger.warn("Method overwrite conflict for {}, previously written by {}. Skipping method.", method.name, owner);
return;
}
}
targetClass.methods.remove(target);
} else if (isOverwrite) {
throw new InvalidMixinException(String.format("Overwrite target %s was not located in the target class", method.name));
}
targetClass.methods.add(method);
ASMHelper.setVisibleAnnotation(method, MixinMerged.class,
"mixin", mixin.getClassName(),
"priority", mixin.getPriority(),
"sessionId", this.sessionId);
}
/**
* Handles appending instructions from the source method to the target method
*
@@ -24,8 +24,13 @@
*/
package org.spongepowered.asm.util;
import static org.objectweb.asm.ClassWriter.COMPUTE_FRAMES;
import static org.objectweb.asm.ClassWriter.COMPUTE_MAXS;
import static org.objectweb.asm.ClassWriter.*;
import java.io.PrintWriter;
import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassWriter;
@@ -44,12 +49,6 @@ import org.objectweb.asm.tree.MethodNode;
import org.objectweb.asm.tree.VarInsnNode;
import org.objectweb.asm.util.CheckClassAdapter;
import java.io.PrintWriter;
import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ASMHelper {
private static final int[] intConstants = new int[]
@@ -345,6 +344,82 @@ public class ASMHelper {
CheckClassAdapter.verify(cr, true, new PrintWriter(System.out));
}
/**
* Set a runtime-visible annotation of the specified class on the supplied field node
*
* @param field Target field
* @param annotationClass Type of annotation to search for
* @param value Values (interleaved key/value pairs) to set
*/
public static void setVisibleAnnotation(FieldNode field, Class<? extends Annotation> annotationClass, Object... value) {
AnnotationNode node = ASMHelper.makeAnnotationNode(Type.getDescriptor(annotationClass), value);
field.visibleAnnotations = ASMHelper.addAnnotation(field.visibleAnnotations, node);
}
/**
* Set an invisible annotation of the specified class on the supplied field node
*
* @param field Target field
* @param annotationClass Type of annotation to search for
* @param value Values (interleaved key/value pairs) to set
*/
public static void setInvisibleAnnotation(FieldNode field, Class<? extends Annotation> annotationClass, Object... value) {
AnnotationNode node = ASMHelper.makeAnnotationNode(Type.getDescriptor(annotationClass), value);
field.invisibleAnnotations = ASMHelper.addAnnotation(field.invisibleAnnotations, node);
}
/**
* Set a runtime-visible annotation of the specified class on the supplied method node
*
* @param method Target method
* @param annotationClass Type of annotation to search for
* @param value Values (interleaved key/value pairs) to set
*/
public static void setVisibleAnnotation(MethodNode method, Class<? extends Annotation> annotationClass, Object... value) {
AnnotationNode node = ASMHelper.makeAnnotationNode(Type.getDescriptor(annotationClass), value);
method.visibleAnnotations = ASMHelper.addAnnotation(method.visibleAnnotations, node);
}
/**
* Set a invisible annotation of the specified class on the supplied method node
*
* @param method Target method
* @param annotationClass Type of annotation to search for
* @param value Values (interleaved key/value pairs) to set
*/
public static void setInvisibleAnnotation(MethodNode method, Class<? extends Annotation> annotationClass, Object... value) {
AnnotationNode node = ASMHelper.makeAnnotationNode(Type.getDescriptor(annotationClass), value);
method.invisibleAnnotations = ASMHelper.addAnnotation(method.invisibleAnnotations, node);
}
private static AnnotationNode makeAnnotationNode(String annotationType, Object... value) {
AnnotationNode node = new AnnotationNode(annotationType);
for (int pos = 0; pos < value.length - 1; pos += 2) {
node.visit((String)value[pos], value[pos + 1]);
}
return node;
}
private static List<AnnotationNode> addAnnotation(List<AnnotationNode> annotations, AnnotationNode node) {
if (annotations == null) {
annotations = new ArrayList<AnnotationNode>(1);
} else {
annotations.remove(ASMHelper.getAnnotation(annotations, node.desc));
}
annotations.add(node);
return annotations;
}
/**
* Get an invisible annotation of the specified class from the supplied field node
*
* @param field Source field
* @param annotationClass Type of annotation to search for
* @return the annotation, or null if not present
*/
public static void setInvisibleAnnotation(FieldNode field, Class<? extends Annotation> annotationClass) {
}
/**
* Get a runtime-visible annotation of the specified class from the supplied field node
*