Migrating mixin functionality from Sponge to new project

This commit is contained in:
Mumfrey committed 2014-12-14 16:45:00 +00:00
commit dacac515d9
22 files changed
+2607

No files matched your search

@@ -0,0 +1,43 @@
/**
* 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;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Pseudo-implements decorator for Mixins with conflicting methods in a superclass to soft-implement an interface
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.CLASS)
public @interface Implements {
/**
* Interfaces implemented, see javadoc in {@link Interface}
*/
public Interface[] value();
}
@@ -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;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* I'm probably going to the special hell for this
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.CLASS)
public @interface Interface {
/**
* Interface that the parent {@link Implements} indicates the mixin implements. The interface will be hot-patched onto the target class as part
* of the mixin application.
*/
public Class<?> iface();
/**
* [Required] prefix for implementing interface methods. Works similarly to {@link Shadow} prefixes, but <b>must</b> end with a dollar sign ($)
*/
public String prefix();
}
@@ -0,0 +1,42 @@
/**
* 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;
public class InvalidMixinException extends RuntimeException {
private static final long serialVersionUID = 1L;
public InvalidMixinException(String message) {
super(message);
}
public InvalidMixinException(Throwable message) {
super(message);
}
public InvalidMixinException(String message, Throwable cause) {
super(message, cause);
}
}
@@ -0,0 +1,48 @@
/**
* 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;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Decorator for mixin classes
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.CLASS)
public @interface Mixin {
/**
* Target class(es) for this mixin
*/
public Class<?>[] value();
/**
* Priority for the mixin, relative to other mixins targetting the same classes
*/
public int priority() default 1000;
}
@@ -0,0 +1,90 @@
/**
* 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;
import java.util.ArrayList;
import java.util.List;
import net.minecraft.launchwrapper.IClassTransformer;
import net.minecraft.launchwrapper.Launch;
/**
* Env interaction for mixins
*/
public class MixinEnvironment {
public static final String CONFIGS_KEY = "mixin.configs";
public static final String TRANSFORMER_KEY = "mixin.transformer";
public static final String MIXIN_TRANSFORMER_PACKAGE = "org.spongepowered.asm.mixin.transformer.";
public static final String MIXIN_TRANSFORMER_CLASS = MixinEnvironment.MIXIN_TRANSFORMER_PACKAGE + "MixinTransformer";
private static MixinEnvironment env;
private MixinEnvironment() {
// Sanity check
if (this.getClass().getClassLoader() != Launch.class.getClassLoader()) {
throw new RuntimeException("Attempted to init the mixin environment in the wrong classloader");
}
Launch.classLoader.addClassLoaderExclusion(MixinEnvironment.MIXIN_TRANSFORMER_PACKAGE);
}
/**
* Get mixin configurations from the blackboard
*/
public List<String> getMixinConfigs() {
@SuppressWarnings("unchecked")
List<String> mixinConfigs = (List<String>) Launch.blackboard.get(MixinEnvironment.CONFIGS_KEY);
if (mixinConfigs == null) {
mixinConfigs = new ArrayList<String>();
Launch.blackboard.put(MixinEnvironment.CONFIGS_KEY, mixinConfigs);
}
return mixinConfigs;
}
/**
* Add a mixin configuration to the blackboard
*/
public void addConfiguration(String config) {
this.getMixinConfigs().add(config);
}
public Object getActiveTransformer() {
return Launch.blackboard.get(MixinEnvironment.TRANSFORMER_KEY);
}
public void setActiveTransformer(IClassTransformer transformer) {
Launch.blackboard.put(MixinEnvironment.TRANSFORMER_KEY, this);
}
public static MixinEnvironment getCurrentEnvironment() {
if (MixinEnvironment.env == null) {
MixinEnvironment.env = new MixinEnvironment();
}
return MixinEnvironment.env;
}
}
@@ -0,0 +1,39 @@
/**
* 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;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Used to indicate a Mixin class member which should overwrite a method in the target class
*/
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Overwrite {
}
@@ -0,0 +1,68 @@
/**
* 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;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Used to indicate a Mixin class member which is acting as a placeholder for a method or field in the target class
*/
@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Shadow {
/**
* <p>In general, shadow methods can be declared using their name in the target class as you would expect, however we run into a problem when we
* want to mix in a method with the same name and arguments, but a different return type to the shadow method. While the JVM itself will happily
* support methods with signatures that differ only on return type, the compiler itself does not. This poses a problem, since we have no way to
* leverage this behaviour since our mixin class will not compile.</p>
*
* <p>To circumvent this compiler limitation, the prefix option can be used. By specifying a prefix for the shadow method, it is subsequently
* possible to compile the mixin class, the specified prefix will then be stripped from the method name prior to applying the mixin, and
* everything will work as expected. You may either use the default prefix: "shadow$", or you may specify your own. It is good practice to
* specify the prefix if you are using it, regardless of whether you use the default or not. For example consider the intrinsic readability of
* the following snippets</p>:
*
* <blockquote><pre>
* &#64;Shadow abstract void someMethod(int arg1, int arg2);
* &#64;Shadow abstract void shadow$someMethod(int arg1, int arg2);
* &#64;Shadow(prefix = "shadow$") abstract void shadow$someMethod(int arg1, int arg2);
* &#64;Shadow(prefix = "foo$") abstract void foo$someMethod(int arg1, int arg2);
* </pre></blockquote>
*
* <p>All of these declarations are semantically equivalent, however the third and fourth are the most expressive in terms of making their
* intentions clear, and thus specifying prefix is recommended, since it aids readability and maintainability.<p>
*
* <p>Note that specifying a <em>prefix</em> does not <b>enforce</b> use of the prefix, the behaviour of <em>prefix</em> is such that the prefix
* will be stripped from the start of the method name <em>as long as the method name actually starts with the prefix</em>! This has important
* repercussions since if the annotation value does not match the method prefix then <em>no renaming will take place</em> likey resulting in
* a failure state indicated by an {@link InvalidMixinException} at run time.</p>
*/
public String prefix() default "shadow$";
}
@@ -0,0 +1,170 @@
/**
* 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.io.IOException;
import java.util.HashSet;
import java.util.Set;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.Type;
import org.objectweb.asm.tree.AnnotationNode;
import org.objectweb.asm.tree.ClassNode;
import org.objectweb.asm.tree.MethodNode;
import org.spongepowered.asm.mixin.Implements;
import org.spongepowered.asm.mixin.InvalidMixinException;
import org.spongepowered.asm.util.ASMHelper;
/**
* Information about an interface being runtime-patched onto a mixin target class, see {@link Implements}
*/
public class InterfaceInfo {
/**
* Prefix for interface methods. Any methods using this prefix must exist in the target interface
*/
private final String prefix;
/**
* Interface being patched
*/
private final Type iface;
/**
* Method signatures in the interface, lazy loaded
*/
private Set<String> methods;
/**
* Make with the new thing already
*/
private InterfaceInfo(String prefix, Type iface) {
if (prefix == null || prefix.length() < 2 || !prefix.endsWith("$")) {
throw new InvalidMixinException(String.format("Prefix %s for iface %s is not valid", prefix, iface.toString()));
}
this.prefix = prefix;
this.iface = iface;
}
/**
* Lazy-loaded methods collection initialiser
*/
private void initMethods() {
this.methods = new HashSet<String>();
this.readInterface(this.iface.getClassName());
}
/**
* Reads an interface and its super-interfaces and gathers method names in to the local "methods" collection
*/
private void readInterface(String ifaceName) {
ClassNode ifaceNode = new ClassNode();
try {
ClassReader classReader = new ClassReader(this.loadInterface(ifaceName));
classReader.accept(ifaceNode, 0);
} catch (IOException ex) {
throw new InvalidMixinException("An error was encountered parsing the interface " + this.iface.toString());
}
for (MethodNode ifaceMethod : ifaceNode.methods) {
String signature = ifaceMethod.name + ifaceMethod.desc;
this.methods.add(signature);
}
for (String superIface : ifaceNode.interfaces) {
String sif = superIface.replace('/', '.');
this.readInterface(sif);
}
}
/**
* Fires ze missiles
*/
private byte[] loadInterface(String ifaceName) throws IOException {
byte[] ifaceBytes = MixinInfo.getClassBytes(ifaceName);
ifaceBytes = MixinInfo.applyTransformers(ifaceName, ifaceBytes);
return ifaceBytes;
}
/**
* Get the prefix string (non null)
*/
public String getPrefix() {
return this.prefix;
}
/**
* Get the interface type
*/
public Type getIface() {
return this.iface;
}
/**
* Get the internal name of the interface
*/
public String getInternalName() {
return this.iface.getInternalName();
}
/**
* Processes a method node in the mixin and renames it if necessary. If the prefix is found then we verify that the method exists in the target
* interface and throw our teddies out of the pram if that's not the case (replacement behaviour for {@link Override} essentially.
*/
public boolean renameMethod(MethodNode method) {
if (this.methods == null) {
this.initMethods();
}
if (!method.name.startsWith(this.prefix)) {
return false;
}
String realName = method.name.substring(this.prefix.length());
String signature = realName + method.desc;
if (!this.methods.contains(signature)) {
throw new InvalidMixinException(String.format("%s does not exist in target interface %s", realName, this.iface.toString()));
}
method.name = realName;
return true;
}
/**
* Convert an {@link Interface} annotation node into an {@link InterfaceInfo}
*/
static InterfaceInfo fromAnnotation(AnnotationNode node) {
String prefix = ASMHelper.<String>getAnnotationValue(node, "prefix");
Type iface = ASMHelper.<Type>getAnnotationValue(node, "iface");
if (prefix == null || iface == null) {
throw new InvalidMixinException(String.format("@Interface annotation on is missing a required parameter"));
}
return new InterfaceInfo(prefix, iface);
}
}
@@ -0,0 +1,171 @@
/**
* 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.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.google.gson.Gson;
import com.google.gson.annotations.SerializedName;
/**
* Mixin configuration bundle
*/
class MixinConfig {
/**
* Map of mixin target classes to mixin infos
*/
private final transient Map<String, List<MixinInfo>> mixinMapping = new HashMap<String, List<MixinInfo>>();
/**
* 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.
*/
@SerializedName("package")
private String mixinPackage;
/**
* Mixin classes to load, mixinPackage will be prepended
*/
@SerializedName("mixins")
private List<String> mixinClasses;
/**
* True to set the sourceFile property when applying mixins
*/
@SerializedName("setSourceFile")
private boolean setSourceFile = false;
/**
* Keep track of initialisation state
*/
private transient boolean initialised = false;
/**
* Spawn via GSON, no public ctor for you
*/
private MixinConfig() {}
/**
* <p>Initialisation routine. It's important that we call this routine as late as possible. In general we want to call it on the first call to
* transform() in the parent transformer. At the very least we want to be called <em>after</em> all the transformers for the current environment
* have been spawned, because we will run the mixin bytecode through the transformer chain and naturally we want this to happen at a point when
* we can be reasonably sure that all transfomers have loaded.</p>
*
* <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() {
this.initialised = true;
if (!this.mixinPackage.endsWith(".")) {
this.mixinPackage += ".";
}
for (String mixinClass : this.mixinClasses) {
try {
MixinInfo mixin = new MixinInfo(this, mixinClass, true);
for (String targetClass : mixin.getTargetClasses()) {
this.getMixinsFor(targetClass).add(mixin);
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
/**
* Get the package containing all mixin classes
*/
public String getMixinPackage() {
return this.mixinPackage;
}
/**
* Get the list of mixin classes we will be applying
*/
public List<String> getClasses() {
return this.mixinClasses;
}
/**
* Get whether to propogate the source file attribute from a mixin onto the target class
*/
public boolean shouldSetSourceFile() {
return this.setSourceFile;
}
/**
* Check whether this configuration bundle has a mixin for the specified class
*
* @param targetClass
* @return
*/
public boolean hasMixinsFor(String targetClass) {
if (!this.initialised) {
this.initialise();
}
return this.mixinMapping.containsKey(targetClass);
}
/**
* Get mixins for the specified target class
*
* @param targetClass
* @return
*/
public List<MixinInfo> getMixinsFor(String targetClass) {
if (!this.initialised) {
this.initialise();
}
List<MixinInfo> mixins = this.mixinMapping.get(targetClass);
if (mixins == null) {
mixins = new ArrayList<MixinInfo>();
this.mixinMapping.put(targetClass, mixins);
}
return mixins;
}
/**
* Factory method, creates a new mixin configuration bundle from the specified configFile, which must be accessible on the classpath
*
* @param configFile
* @return
*/
static MixinConfig create(String configFile) {
try {
return new Gson().fromJson(new InputStreamReader(MixinConfig.class.getResourceAsStream("/" + configFile)), MixinConfig.class);
} catch (Exception ex) {
ex.printStackTrace();
throw new IllegalArgumentException(String.format("The specified configuration file '%s' was invalid or could not be read", configFile));
}
}
}
@@ -0,0 +1,202 @@
/**
* 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.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.tree.AbstractInsnNode;
import org.objectweb.asm.tree.AnnotationNode;
import org.objectweb.asm.tree.ClassNode;
import org.objectweb.asm.tree.MethodInsnNode;
import org.objectweb.asm.tree.MethodNode;
import org.spongepowered.asm.mixin.Implements;
import org.spongepowered.asm.mixin.Shadow;
import org.spongepowered.asm.util.ASMHelper;
/**
* Data for applying a mixin. Keeps a copy of the mixin tree and also handles any pre-transformations required by the mixin class itself such as
* method renaming and any other pre-processing of the mixin bytecode.
*/
public class MixinData {
/**
* Mixin info
*/
private final MixinInfo info;
/**
* Tree
*/
private final ClassNode classNode;
/**
* Methods we need to rename
*/
private final Map<String, String> renamedMethods = new HashMap<String, String>();
/**
* Interfaces soft-implemented using {@link Implements}
*/
private final List<InterfaceInfo> softImplements = new ArrayList<InterfaceInfo>();
/**
* All interfaces implemented by this mixin, including soft implementations
*/
private final Set<String> interfaces = new HashSet<String>();
/**
* ctor
*
* @param info
*/
MixinData(MixinInfo info) {
this.info = info;
this.classNode = info.getClassNode(ClassReader.EXPAND_FRAMES);
this.prepare();
}
/**
* Get the mixin tree
*/
public ClassNode getClassNode() {
return this.classNode;
}
/**
* Get all interfaces for this mixin
*/
public Set<String> getInterfaces() {
return this.interfaces;
}
/**
* Get whether to propogate the source file attribute from a mixin onto the target class
*/
public boolean shouldSetSourceFile() {
return this.info.getParent().shouldSetSourceFile();
}
/**
* Prepare the mixin, applies any pre-processing transformations
*/
private void prepare() {
this.readImplementations();
this.findRenamedMethods();
this.transformMethods();
}
/**
* Read and process any {@link Implements} annotations on the mixin
*/
private void readImplementations() {
this.interfaces.addAll(this.classNode.interfaces);
AnnotationNode implementsAnnotation = ASMHelper.getInvisibleAnnotation(this.classNode, Implements.class);
if (implementsAnnotation == null) {
return;
}
List<AnnotationNode> interfaces = ASMHelper.getAnnotationValue(implementsAnnotation);
if (interfaces == null) {
return;
}
for (AnnotationNode interfaceNode : interfaces) {
InterfaceInfo interfaceInfo = InterfaceInfo.fromAnnotation(interfaceNode);
this.softImplements.add(interfaceInfo);
this.interfaces.add(interfaceInfo.getInternalName());
}
}
/**
* Let's do this
*/
private void findRenamedMethods() {
for (MethodNode mixinMethod : this.classNode.methods) {
String oldSignature = mixinMethod.name + mixinMethod.desc;
AnnotationNode shadowAnnotation = ASMHelper.getVisibleAnnotation(mixinMethod, Shadow.class);
if (shadowAnnotation != null) {
String prefix = MixinData.getAnnotationValue(shadowAnnotation, "prefix", Shadow.class);
if (mixinMethod.name.startsWith(prefix)) {
String newName = mixinMethod.name.substring(prefix.length());
this.renamedMethods.put(oldSignature, newName);
mixinMethod.name = newName;
}
}
for (InterfaceInfo iface : this.softImplements) {
if (iface.renameMethod(mixinMethod)) {
this.renamedMethods.put(oldSignature, mixinMethod.name);
}
}
}
}
/**
* Apply discovered method renames to method invokations in the mixin
*/
private void transformMethods() {
for (MethodNode mixinMethod : this.classNode.methods) {
for (Iterator<AbstractInsnNode> iter = mixinMethod.instructions.iterator(); iter.hasNext();) {
AbstractInsnNode insn = iter.next();
if (insn instanceof MethodInsnNode) {
MethodInsnNode methodNode = (MethodInsnNode)insn;
String newName = this.renamedMethods.get(methodNode.name + methodNode.desc);
if (newName != null) {
methodNode.name = newName;
}
}
}
}
}
/**
* Gets an annotation value or returns the default if the annotation value is not present
*
* @param annotation
* @param key
* @param annotationClass
* @return
*/
private static String getAnnotationValue(AnnotationNode annotation, String key, Class<?> annotationClass) {
String value = ASMHelper.getAnnotationValue(annotation, key);
if (value == null) {
try {
value = (String)Shadow.class.getDeclaredMethod(key).getDefaultValue();
} catch (NoSuchMethodException ex) {
// Don't care
}
}
return value;
}
}
@@ -0,0 +1,292 @@
/**
* 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.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import net.minecraft.launchwrapper.IClassTransformer;
import net.minecraft.launchwrapper.Launch;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.Type;
import org.objectweb.asm.tree.AnnotationNode;
import org.objectweb.asm.tree.ClassNode;
import org.spongepowered.asm.mixin.InvalidMixinException;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.util.ASMHelper;
/**
* Runtime information bundle about a mixin
*/
class MixinInfo implements Comparable<MixinInfo> {
/**
* Global order of mixin infos, used to determine ordering between mixins with equivalent priority
*/
static int mixinOrder = 0;
/**
* Logger
*/
private final transient Logger logger = LogManager.getLogger("sponge");
/**
* Parent configuration which declares this mixin
*/
private final transient MixinConfig parent;
/**
* Simple name
*/
private final String name;
/**
* Name of the mixin class itself, dotted notation
*/
private final String className;
/**
* Name of the mixin class, internal notation
*/
private final transient String classRef;
/**
* Mixin priority, read from the {@link Mixin} annotation on the mixin class
*/
private final int priority;
/**
* Mixin targets, read from the {@link Mixin} annotation on the mixin class
*/
private final List<String> targetClasses;
/**
* Intrinsic order (for sorting mixins with identical priority)
*/
private final transient int order = MixinInfo.mixinOrder++;
/**
* Mixin bytes (read once, generate tree on demand)
*/
private final transient byte[] mixinBytes;
/**
* Internal ctor, called by {@link MixinConfig}
*
* @param parent
* @param mixinName
* @param runTransformers
*/
MixinInfo(MixinConfig parent, String mixinName, boolean runTransformers) {
this.parent = parent;
this.name = mixinName;
this.className = parent.getMixinPackage() + mixinName;
this.classRef = this.className.replace('.', '/');
// Read the class bytes and transform
this.mixinBytes = this.loadMixinClass(this.className, runTransformers);
ClassNode classNode = this.getClassNode(0);
this.targetClasses = this.readTargetClasses(classNode);
this.priority = this.readPriority(classNode);
}
/**
* Read the target class names from the {@link Mixin} annotation
*
* @param classNode
* @return
*/
private List<String> readTargetClasses(ClassNode classNode) {
AnnotationNode mixin = ASMHelper.getInvisibleAnnotation(classNode, Mixin.class);
if (mixin == null) {
throw new InvalidMixinException(String.format("The mixin '%s' is missing an @Mixin annotation", this.className));
}
List<Type> targetClasses = ASMHelper.getAnnotationValue(mixin);
List<String> targetClassNames = new ArrayList<String>();
for (Type targetClass : targetClasses) {
targetClassNames.add(targetClass.getClassName());
}
return targetClassNames;
}
/**
* Read the priority from the {@link Mixin} annotation
*
* @param classNode
* @return
*/
private int readPriority(ClassNode classNode) {
AnnotationNode mixin = ASMHelper.getInvisibleAnnotation(classNode, Mixin.class);
if (mixin == null) {
throw new InvalidMixinException(String.format("The mixin '%s' is missing an @Mixin annotation", this.className));
}
Integer priority = ASMHelper.getAnnotationValue(mixin, "priority");
return priority == null ? 1000 : priority.intValue();
}
/**
* Get the parent config which declares this mixin
*/
public MixinConfig getParent() {
return this.parent;
}
/**
* Get the simple name of the mixin
*/
public String getName() {
return this.name;
}
/**
* Get the name of the mixin class
*/
public String getClassName() {
return this.className;
}
/**
* Get the ref (internal name) of the mixin class
*/
public String getClassRef() {
return this.classRef;
}
/**
* Get the class bytecode
*/
public byte[] getClassBytes() {
return this.mixinBytes;
}
/**
* Get a new tree for the class bytecode
*/
public ClassNode getClassNode(int flags) {
ClassNode classNode = new ClassNode();
ClassReader classReader = new ClassReader(this.mixinBytes);
classReader.accept(classNode, flags);
return classNode;
}
/**
* Get a new mixin data container for this info
*
* @return
*/
public MixinData getData() {
return new MixinData(this);
}
/**
* Get the target classes for this mixin
*/
public List<String> getTargetClasses() {
return Collections.unmodifiableList(this.targetClasses);
}
/**
* Get the mixin priority
*/
public int getPriority() {
return this.priority;
}
/**
* @param mixinClassName
* @param runTransformers
* @return
*/
private byte[] loadMixinClass(String mixinClassName, boolean runTransformers) {
byte[] mixinBytes = null;
try {
if ((mixinBytes = MixinInfo.getClassBytes(mixinClassName)) == null) {
throw new InvalidMixinException(String.format("The specified mixin '%s' was not found", mixinClassName));
}
if (runTransformers) {
mixinBytes = MixinInfo.applyTransformers(mixinClassName, mixinBytes);
}
} catch (IOException ex) {
this.logger.warn("Failed to load mixin %s, the specified mixin will not be applied", mixinClassName);
throw new InvalidMixinException("An error was encountered whilst loading the mixin class", ex);
}
return mixinBytes;
}
/**
* @param mixinClassName
* @return
* @throws IOException
*/
static byte[] getClassBytes(String mixinClassName) throws IOException {
return Launch.classLoader.getClassBytes(mixinClassName);
}
/**
* Since we obtain the mixin class bytes with getClassBytes(), we need to
* apply the transformers ourself
*
* @param name
* @param basicClass
* @return
*/
static byte[] applyTransformers(String name, byte[] basicClass) {
final List<IClassTransformer> transformers = Launch.classLoader.getTransformers();
for (final IClassTransformer transformer : transformers) {
if (!(transformer instanceof MixinTransformer)) {
basicClass = transformer.transform(name, name, basicClass);
}
}
return basicClass;
}
/* (non-Javadoc)
* @see java.lang.Comparable#compareTo(java.lang.Object)
*/
@Override
public int compareTo(MixinInfo other) {
if (other == null) {
return 0;
}
if (other.priority == this.priority) {
return this.order - other.order;
}
return (this.priority - other.priority);
}
}
@@ -0,0 +1,429 @@
/**
* 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.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import net.minecraft.launchwrapper.IClassTransformer;
import net.minecraft.launchwrapper.Launch;
import org.apache.commons.io.FileUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
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.ClassNode;
import org.objectweb.asm.tree.FieldInsnNode;
import org.objectweb.asm.tree.FieldNode;
import org.objectweb.asm.tree.LineNumberNode;
import org.objectweb.asm.tree.MethodInsnNode;
import org.objectweb.asm.tree.MethodNode;
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.transformers.TreeTransformer;
import org.spongepowered.asm.util.ASMHelper;
/**
* Transformer which applies Mixin classes to their declared target classes
*/
public class MixinTransformer extends TreeTransformer {
private static final boolean DEBUG_EXPORT = Booleans.parseBoolean(System.getProperty("mixin.debug.export"), false);
/**
* Log all the things
*/
private final Logger logger = LogManager.getLogger("sponge");
/**
* Mixin configuration bundle
*/
private final List<MixinConfig> configs = new ArrayList<MixinConfig>();
/**
* ctor
*/
public MixinTransformer() {
// Go via blackboard to create FORWARD compatibility if Mixins get pulled into FML
Object globalMixinTransformer = MixinEnvironment.getCurrentEnvironment().getActiveTransformer();
if (globalMixinTransformer instanceof IClassTransformer) {
throw new RuntimeException("Terminating MixinTransformer instance " + this);
}
// I am a leaf on the wind
MixinEnvironment.getCurrentEnvironment().setActiveTransformer(this);
List<String> configs = MixinEnvironment.getCurrentEnvironment().getMixinConfigs();
if (configs != null) {
for (String configFile : configs) {
try {
this.configs.add(MixinConfig.create(configFile));
} catch (Exception ex) {
this.logger.warn(String.format("Failed to load mixin config: %s", configFile), ex);
}
}
}
}
/* (non-Javadoc)
* @see net.minecraft.launchwrapper.IClassTransformer#transform(java.lang.String, java.lang.String, byte[])
*/
@Override
public byte[] transform(String name, String transformedName, byte[] basicClass) {
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();
}
}
}
return basicClass;
}
/**
* Apply mixins for specified target class to the class described by the supplied byte array
*
* @param config
* @param transformedName
* @param basicClass
* @return
*/
private byte[] applyMixins(MixinConfig config, String transformedName, byte[] basicClass) {
// 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(targetClass, mixin.getData());
}
// Extension point
this.postTransform(transformedName, targetClass, mixins);
// Collapse tree to bytes
byte[] bytes = this.writeClass(targetClass);
// Export transformed class for debugging purposes
if (MixinTransformer.DEBUG_EXPORT) {
try {
FileUtils.writeByteArrayToFile(new File(".mixin.out/" + transformedName.replace('.', '/') + ".class"), bytes);
}
catch (IOException ex) {}
}
return bytes;
}
/**
* @param transformedName
* @param targetClass
* @param mixins
*/
protected void postTransform(String transformedName, ClassNode targetClass, List<MixinInfo> mixins) {
// Stub for subclasses
}
/**
* Apply the mixin described by mixin to the supplied classNode
*
* @param targetClass
* @param mixin
*/
protected void applyMixin(ClassNode targetClass, MixinData mixin) {
try {
this.verifyClasses(targetClass, mixin);
this.applyMixinInterfaces(targetClass, mixin);
this.applyMixinAttributes(targetClass, mixin);
this.applyMixinFields(targetClass, mixin);
this.applyMixinMethods(targetClass, mixin);
} catch (Exception ex) {
throw new InvalidMixinException("Unexpecteded error whilst applying the mixin class", ex);
}
}
/**
* Perform pre-flight checks on the mixin and target classes
*
* @param targetClass
* @param mixin
*/
protected void verifyClasses(ClassNode targetClass, MixinData mixin) {
String superName = mixin.getClassNode().superName;
if (targetClass.superName == null || superName == null || !targetClass.superName.equals(superName)) {
throw new InvalidMixinException("Mixin classes must have the same superclass as their target class");
}
}
/**
* Mixin interfaces implemented by the mixin class onto the target class
*
* @param targetClass
* @param mixin
*/
private void applyMixinInterfaces(ClassNode targetClass, MixinData mixin) {
for (String interfaceName : mixin.getInterfaces()) {
if (!targetClass.interfaces.contains(interfaceName)) {
targetClass.interfaces.add(interfaceName);
}
}
}
/**
* Mixin misc attributes from mixin class onto the target class
*
* @param targetClass
* @param mixin
*/
private void applyMixinAttributes(ClassNode targetClass, MixinData mixin) {
if (mixin.shouldSetSourceFile()) {
targetClass.sourceFile = mixin.getClassNode().sourceFile;
}
}
/**
* Mixin fields from mixin class into the target class. It is vital that this is done before mixinMethods because we need to compute renamed
* fields so that transformMethod can rename field references in the method body
*
* @param targetClass
* @param mixin
*/
private void applyMixinFields(ClassNode targetClass, MixinData mixin) {
for (FieldNode field : mixin.getClassNode().fields) {
// Public static fields will fall foul of early static binding in java, including them in a mixin is an error condition
if (MixinTransformer.hasFlag(field, Opcodes.ACC_STATIC) && !MixinTransformer.hasFlag(field, Opcodes.ACC_PRIVATE)) {
throw new InvalidMixinException(String.format("Mixin classes cannot contain visible static methods or fields, found %s", field.name));
}
FieldNode target = this.findTargetField(targetClass, field);
if (target == null) {
// If this field is a shadow field but is NOT found in the target class, that's bad, mmkay
boolean isShadow = ASMHelper.getVisibleAnnotation(field, Shadow.class) != null;
if (isShadow) {
throw new InvalidMixinException(String.format("Shadow field %s was not located in the target class", field.name));
}
// This is just a local field, so add it
targetClass.fields.add(field);
} else {
// Check that the shadow field has a matching descriptor
if (!target.desc.equals(field.desc)) {
throw new InvalidMixinException(String.format("The field %s in the target class has a conflicting signature", field.name));
}
}
}
}
/**
* Mixin methods from the mixin class into the target class
*
* @param targetClass
* @param mixin
*/
private void applyMixinMethods(ClassNode targetClass, MixinData mixin) {
for (MethodNode mixinMethod : mixin.getClassNode().methods) {
// Reparent all mixin methods into the target class
this.transformMethod(mixinMethod, mixin.getClassNode().name, targetClass.name);
boolean isShadow = ASMHelper.getVisibleAnnotation(mixinMethod, Shadow.class) != null;
boolean isOverwrite = ASMHelper.getVisibleAnnotation(mixinMethod, Overwrite.class) != null;
boolean isAbstract = MixinTransformer.hasFlag(mixinMethod, Opcodes.ACC_ABSTRACT);
if (isShadow || isAbstract) {
// For shadow (and abstract, which can be used as a shorthand for Shadow) methods, we just check they're present
MethodNode target = this.findTargetMethod(targetClass, mixinMethod);
if (target == null) {
throw new InvalidMixinException(String.format("Shadow method %s was not located in the target class", mixinMethod.name));
}
} else if (!mixinMethod.name.startsWith("<")) {
if (MixinTransformer.hasFlag(mixinMethod, Opcodes.ACC_STATIC)
&& !MixinTransformer.hasFlag(mixinMethod, Opcodes.ACC_PRIVATE)
&& !MixinTransformer.hasFlag(mixinMethod, Opcodes.ACC_SYNTHETIC)
&& !isOverwrite) {
throw new InvalidMixinException(
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);
} else if ("<clinit>".equals(mixinMethod.name)) {
// Class initialiser insns get appended
this.appendInsns(targetClass, mixinMethod.name, mixinMethod);
}
}
}
/**
* Handles "re-parenting" the method supplied, changes all references to the mixin class to refer to the target class (for field accesses and
* method invokations) and also renames fields accesses to their obfuscated versions
*
* @param method
* @param fromClass
* @param toClass
* @return
*/
private void transformMethod(MethodNode method, String fromClass, String toClass) {
Iterator<AbstractInsnNode> iter = method.instructions.iterator();
while (iter.hasNext()) {
AbstractInsnNode insn = iter.next();
if (insn instanceof MethodInsnNode) {
MethodInsnNode methodInsn = (MethodInsnNode) insn;
if (methodInsn.owner.equals(fromClass)) {
methodInsn.owner = toClass;
}
}
if (insn instanceof FieldInsnNode) {
FieldInsnNode fieldInsn = (FieldInsnNode) insn;
if (fieldInsn.owner.equals(fromClass)) {
fieldInsn.owner = toClass;
}
}
}
}
/**
* Handles appending instructions from the source method to the target method
*
* @param targetClass
* @param targetMethodName
* @param sourceMethod
*/
private void appendInsns(ClassNode targetClass, String targetMethodName, MethodNode sourceMethod) {
if (Type.getReturnType(sourceMethod.desc) != Type.VOID_TYPE) {
throw new IllegalArgumentException("Attempted to merge insns into a method which does not return void");
}
if (targetMethodName == null || targetMethodName.length() == 0) {
targetMethodName = sourceMethod.name;
}
for (MethodNode method : targetClass.methods) {
if ((targetMethodName.equals(method.name)) && sourceMethod.desc.equals(method.desc)) {
AbstractInsnNode returnNode = null;
Iterator<AbstractInsnNode> findReturnIter = method.instructions.iterator();
while (findReturnIter.hasNext()) {
AbstractInsnNode insn = findReturnIter.next();
if (insn.getOpcode() == Opcodes.RETURN) {
returnNode = insn;
break;
}
}
Iterator<AbstractInsnNode> injectIter = sourceMethod.instructions.iterator();
while (injectIter.hasNext()) {
AbstractInsnNode insn = injectIter.next();
if (!(insn instanceof LineNumberNode) && insn.getOpcode() != Opcodes.RETURN) {
method.instructions.insertBefore(returnNode, insn);
}
}
}
}
}
/**
* Finds a method in the target class
*
* @param targetClass
* @param searchFor
* @return
*/
private MethodNode findTargetMethod(ClassNode targetClass, MethodNode searchFor) {
for (MethodNode target : targetClass.methods) {
if (target.name.equals(searchFor.name) && target.desc.equals(searchFor.desc)) {
return target;
}
}
return null;
}
/**
* Finds a field in the target class
*
* @param targetClass
* @param searchFor
* @return
*/
private FieldNode findTargetField(ClassNode targetClass, FieldNode searchFor) {
for (FieldNode target : targetClass.fields) {
if (target.name.equals(searchFor.name)) {
return target;
}
}
return null;
}
/**
* Check whether the specified flag is set on the specified method
*
* @param method
* @param flag
* @return
*/
private static boolean hasFlag(MethodNode method, int flag) {
return (method.access & flag) == flag;
}
/**
* Check whether the specified flag is set on the specified field
*
* @param field
* @param flag
* @return
*/
private static boolean hasFlag(FieldNode field, int flag) {
return (field.access & flag) == flag;
}
}
@@ -0,0 +1,83 @@
/**
* 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.transformers;
import net.minecraft.launchwrapper.IClassTransformer;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.tree.ClassNode;
/**
* Base class for transformers which work with ASM tree model
*/
public abstract class TreeTransformer implements IClassTransformer {
private ClassReader classReader;
private ClassNode classNode;
/**
* @param basicClass
* @return tree
*/
protected final ClassNode readClass(byte[] basicClass) {
return this.readClass(basicClass, true);
}
/**
* @param basicClass
* @return tree
*/
protected final ClassNode readClass(byte[] basicClass, boolean cacheReader) {
ClassReader classReader = new ClassReader(basicClass);
if (cacheReader) {
this.classReader = classReader;
}
ClassNode classNode = new ClassNode();
classReader.accept(classNode, ClassReader.EXPAND_FRAMES);
return classNode;
}
/**
* @param classNode
*/
protected final byte[] writeClass(ClassNode classNode) {
// Use optimised writer for speed
if (this.classReader != null && this.classNode == classNode) {
this.classNode = null;
ClassWriter writer = new ClassWriter(this.classReader, ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES);
this.classReader = null;
classNode.accept(writer);
return writer.toByteArray();
}
this.classNode = null;
ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES);
classNode.accept(writer);
return writer.toByteArray();
}
}
@@ -0,0 +1,473 @@
/**
* 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.util;
import static org.objectweb.asm.ClassWriter.COMPUTE_FRAMES;
import static org.objectweb.asm.ClassWriter.COMPUTE_MAXS;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassWriter;
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.FieldNode;
import org.objectweb.asm.tree.InsnList;
import org.objectweb.asm.tree.InsnNode;
import org.objectweb.asm.tree.IntInsnNode;
import org.objectweb.asm.tree.LdcInsnNode;
import org.objectweb.asm.tree.MethodInsnNode;
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.Iterator;
import java.util.List;
public class ASMHelper {
private static final int[] intConstants = new int[]
{Opcodes.ICONST_0, Opcodes.ICONST_1, Opcodes.ICONST_2, Opcodes.ICONST_3, Opcodes.ICONST_4, Opcodes.ICONST_5};
/**
* Generate a new method "boolean name()", which returns a constant value.
*
* @param clazz Class to add method to
* @param name Name of method
* @param retval Return value of method
*/
public static void generateBooleanMethodConst(ClassNode clazz, String name, boolean retval) {
MethodNode method = new MethodNode(Opcodes.ASM5, Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC, name, "()Z", null, null);
InsnList code = method.instructions;
code.add(pushIntConstant(retval ? 1 : 0));
code.add(new InsnNode(Opcodes.IRETURN));
clazz.methods.add(method);
}
/**
* Generate a new method "int name()", which returns a constant value.
*
* @param clazz Class to add method to
* @param name Name of method
* @param retval Return value of method
*/
public static void generateIntegerMethodConst(ClassNode clazz, String name, short retval) {
MethodNode method = new MethodNode(Opcodes.ASM5, Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC, name, "()I", null, null);
InsnList code = method.instructions;
code.add(pushIntConstant(retval));
code.add(new InsnNode(Opcodes.IRETURN));
clazz.methods.add(method);
}
/**
* Generate a forwarding method of the form
* "T name() { return this.forward(); }".
*
* @param clazz Class to generate new method on
* @param name Name of method to generate
* @param forwardname Name of method to call
* @param rettype Return type of method
*/
public static void generateSelfForwardingMethod(ClassNode clazz, String name, String forwardname, Type rettype) {
MethodNode method =
new MethodNode(Opcodes.ASM5, Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC, name, "()" + rettype.getDescriptor(), null, null);
populateSelfForwardingMethod(method, forwardname, rettype, Type.getObjectType(clazz.name));
clazz.methods.add(method);
}
/**
* Generate a forwarding method of the form
* "static T name(S object) { return object.forward(); }".
*
* @param clazz Class to generate new method on
* @param name Name of method to generate
* @param forwardname Name of method to call
* @param rettype Return type of method
*/
public static void generateStaticForwardingMethod(ClassNode clazz, String name, String forwardname, Type rettype, Type argtype) {
MethodNode method = new MethodNode(Opcodes.ASM5,
Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC, name,
"()" + rettype.getDescriptor(), null, null);
populateSelfForwardingMethod(method, forwardname, rettype, argtype);
clazz.methods.add(method);
}
/**
* Generate a forwarding method of the form
* "T name() { return Class.forward(this); }".
*
* @param clazz Class to generate new method on
* @param name Name of method to generate
* @param forwardname Name of method to call
* @param rettype Return type of method
*/
public static void generateForwardingToStaticMethod(ClassNode clazz, String name, String forwardname, Type rettype, Type fowardtype) {
MethodNode method = new MethodNode(Opcodes.ASM5, Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC, name,
"()" + rettype.getDescriptor(), null, null);
populateForwardingToStaticMethod(method, forwardname, rettype, Type.getObjectType(clazz.name), fowardtype);
clazz.methods.add(method);
}
/**
* Generate a forwarding method of the form
* "T name() { return Class.forward(this); }".
*
* @param clazz Class to generate new method on
* @param name Name of method to generate
* @param forwardname Name of method to call
* @param rettype Return type of method
* @param thistype Type to treat 'this' as for overload searching purposes
*/
public static void generateForwardingToStaticMethod(ClassNode clazz, String name, String forwardname, Type rettype, Type fowardtype,
Type thistype) {
MethodNode
method =
new MethodNode(Opcodes.ASM5, Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC, name, "()" + rettype.getDescriptor(), null, null);
populateForwardingToStaticMethod(method, forwardname, rettype, thistype, fowardtype);
clazz.methods.add(method);
}
/**
* Replace a method's code with a forward to another method on itself
* or the first argument of a static method, as the argument takes the
* place of this.
*
* @param method Method to replace code of
* @param forwardname Name of method to forward to
* @param thistype Type of object method is being replaced on
*/
public static void replaceSelfForwardingMethod(MethodNode method, String forwardname, Type thistype) {
Type methodType = Type.getMethodType(method.desc);
method.instructions.clear();
populateSelfForwardingMethod(method, forwardname, methodType.getReturnType(), thistype);
}
/**
* Generate a forwarding method of the form
* "T name(S object) { return object.forward(); }".
*
* @param clazz Class to generate new method on
* @param name Name of method to generate
* @param forwardname Name of method to call
* @param rettype Return type of method
* @param argtype Type of object to call method on
*/
public static void generateForwardingMethod(ClassNode clazz, String name, String forwardname, Type rettype, Type argtype) {
MethodNode
method =
new MethodNode(Opcodes.ASM5, Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC, name, "()" + rettype.getDescriptor(), null, null);
populateForwardingMethod(method, forwardname, rettype, argtype, Type.getObjectType(clazz.name));
clazz.methods.add(method);
}
/**
* Replace a method's code with a forward to an method on its first argument.
*
* @param method Method to replace code of
* @param forwardname Name of method to forward to
* @param thistype Type of object method is being replaced on
*/
public static void replaceForwardingMethod(MethodNode method, String forwardname, Type thistype) {
Type methodType = Type.getMethodType(method.desc);
method.instructions.clear();
populateForwardingMethod(method, forwardname, methodType.getReturnType(), methodType.getArgumentTypes()[0], thistype);
}
/**
* Populate a forwarding method of the form
* "T name() { return Class.forward(this); }".
*
* @param method Method to generate code for
* @param forwardname Name of method to call
* @param rettype Return type of method
* @param thistype Type of object method is being generated on
* @param forwardtype Type to forward method to
*/
public static void populateForwardingToStaticMethod(MethodNode method, String forwardname, Type rettype, Type thistype, Type forwardtype) {
InsnList code = method.instructions;
code.add(new VarInsnNode(thistype.getOpcode(Opcodes.ILOAD), 0));
code.add(new MethodInsnNode(Opcodes.INVOKESTATIC, forwardtype.getInternalName(), forwardname, Type.getMethodDescriptor(rettype, thistype),
false));
code.add(new InsnNode(rettype.getOpcode(Opcodes.IRETURN)));
}
/**
* Populate a forwarding method of the form
* "T name() { return this.forward(); }". This is also valid for methods of
* the form "static T name(S object) { return object.forward() }".
*
* @param method Method to generate code for
* @param forwardname Name of method to call
* @param rettype Return type of method
* @param thistype Type of object method is being generated on
*/
public static void populateSelfForwardingMethod(MethodNode method, String forwardname, Type rettype, Type thistype) {
InsnList code = method.instructions;
code.add(new VarInsnNode(thistype.getOpcode(Opcodes.ILOAD), 0));
code.add(new MethodInsnNode(Opcodes.INVOKEVIRTUAL, thistype.getInternalName(), forwardname, "()" + rettype.getDescriptor(), false));
code.add(new InsnNode(rettype.getOpcode(Opcodes.IRETURN)));
}
/**
* Populate a forwarding method of the form
* "T name(S object) { return object.forward(); }".
*
* @param method Method to generate code for
* @param forwardname Name of method to call
* @param rettype Return type of method
* @param argtype Type of object to call method on
* @param thistype Type of object method is being generated on
*/
public static void populateForwardingMethod(MethodNode method, String forwardname, Type rettype, Type argtype, Type thistype) {
InsnList code = method.instructions;
code.add(new VarInsnNode(argtype.getOpcode(Opcodes.ILOAD), 1));
code.add(new MethodInsnNode(Opcodes.INVOKEVIRTUAL, argtype.getInternalName(), forwardname, "()" + rettype.getDescriptor(), false));
code.add(new InsnNode(rettype.getOpcode(Opcodes.IRETURN)));
}
/**
* Gets an instruction that pushes a integer onto the stack. The instruction uses
* the smallest push possible (ICONST_*, BIPUSH, SIPUSH or Integer constant).
*
* @param c the integer to push onto the stack
*/
public static AbstractInsnNode pushIntConstant(int c) {
if (c == -1) {
return new InsnNode(Opcodes.ICONST_M1);
} else if (c >= 0 && c <= 5) {
return new InsnNode(intConstants[c]);
} else if (c >= Byte.MIN_VALUE && c <= Byte.MAX_VALUE) {
return new IntInsnNode(Opcodes.BIPUSH, c);
} else if (c >= Short.MIN_VALUE && c <= Short.MAX_VALUE) {
return new IntInsnNode(Opcodes.SIPUSH, c);
} else {
return new LdcInsnNode(c);
}
}
/**
* Finds a method given the method descriptor
*
* @param clazz the class to scan
* @param name the method name
* @param desc the method descriptor
*/
public static MethodNode findMethod(ClassNode clazz, String name, String desc) {
Iterator<MethodNode> i = clazz.methods.iterator();
while (i.hasNext()) {
MethodNode m = i.next();
if (m.name.equals(name) && m.desc.equals(desc)) {
return m;
}
}
return null;
}
/**
* Adds a method to a class, overwriting any matching method.
*
* @param clazz the class to scan
* @param method the method to add
*/
public static void addAndReplaceMethod(ClassNode clazz, MethodNode method) {
MethodNode m = findMethod(clazz, method.name, method.desc);
if (m != null) {
clazz.methods.remove(m);
}
clazz.methods.add(method);
}
/**
* Dumps the output of CheckClassAdapter.verify to System.out
*
* @param classNode the classNode to verify
*/
public static void dumpClass(ClassNode classNode) {
ClassWriter cw = new ClassWriter(COMPUTE_MAXS | COMPUTE_FRAMES);
classNode.accept(cw);
dumpClass(cw.toByteArray());
}
/**
* Dumps the output of CheckClassAdapter.verify to System.out
*
* @param bytes the bytecode of the class to check
*/
public static void dumpClass(byte[] bytes) {
ClassReader cr = new ClassReader(bytes);
CheckClassAdapter.verify(cr, true, new PrintWriter(System.out));
}
/**
* Get a runtime-visible 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 AnnotationNode getVisibleAnnotation(FieldNode field, Class<? extends Annotation> annotationClass) {
return ASMHelper.getAnnotation(field.visibleAnnotations, Type.getDescriptor(annotationClass));
}
/**
* 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 AnnotationNode getInvisibleAnnotation(FieldNode field, Class<? extends Annotation> annotationClass) {
return ASMHelper.getAnnotation(field.invisibleAnnotations, Type.getDescriptor(annotationClass));
}
/**
* Get a runtime-visible annotation of the specified class from the supplied method node
*
* @param method Source method
* @param annotationClass Type of annotation to search for
* @return the annotation, or null if not present
*/
public static AnnotationNode getVisibleAnnotation(MethodNode method, Class<? extends Annotation> annotationClass) {
return ASMHelper.getAnnotation(method.visibleAnnotations, Type.getDescriptor(annotationClass));
}
/**
* Get an invisible annotation of the specified class from the supplied method node
*
* @param method Source method
* @param annotationClass Type of annotation to search for
* @return the annotation, or null if not present
*/
public static AnnotationNode getInvisibleAnnotation(MethodNode method, Class<? extends Annotation> annotationClass) {
return ASMHelper.getAnnotation(method.invisibleAnnotations, Type.getDescriptor(annotationClass));
}
/**
* Get a runtime-visible annotation of the specified class from the supplied class node
*
* @param classNode Source classNode
* @param annotationClass Type of annotation to search for
* @return the annotation, or null if not present
*/
public static AnnotationNode getVisibleAnnotation(ClassNode classNode, Class<? extends Annotation> annotationClass) {
return ASMHelper.getAnnotation(classNode.visibleAnnotations, Type.getDescriptor(annotationClass));
}
/**
* Get an invisible annotation of the specified class from the supplied class node
*
* @param classNode Source classNode
* @param annotationClass Type of annotation to search for
* @return the annotation, or null if not present
*/
public static AnnotationNode getInvisibleAnnotation(ClassNode classNode, Class<? extends Annotation> annotationClass) {
return ASMHelper.getAnnotation(classNode.invisibleAnnotations, Type.getDescriptor(annotationClass));
}
/**
* Search for and return an annotation node matching the specified type within the supplied
* collection of annotation nodes
*
* @param annotations Haystack
* @param annotationType Needle
* @return matching annotation node or null if the annotation doesn't exist
*/
public static AnnotationNode getAnnotation(List<AnnotationNode> annotations, String annotationType) {
if (annotations == null) {
return null;
}
for (AnnotationNode annotation : annotations) {
if (annotationType.equals(annotation.desc)) {
return annotation;
}
}
return null;
}
/**
* Duck type the "value" entry (if any) of the specified annotation node
*
* @param annotation Annotation node to query
* @return duck-typed annotation value, null if missing, or inevitable ClassCastException if your duck is actually a rooster
*/
public static <T> T getAnnotationValue(AnnotationNode annotation) {
return ASMHelper.getAnnotationValue(annotation, "value");
}
/**
* Get the value of an annotation node and do pseudo-duck-typing via Java's crappy generics
*
* @param annotation Annotation node to query
* @param key Key to search for
* @return duck-typed annotation value, null if missing, or inevitable ClassCastException if your duck is actually a rooster
*/
@SuppressWarnings("unchecked")
public static <T> T getAnnotationValue(AnnotationNode annotation, String key) {
boolean getNextValue = false;
if (annotation.values == null) {
return null;
}
// Keys and value are stored in successive pairs, search for the key and if found return the following entry
for (Object value : annotation.values) {
if (getNextValue) {
return (T) value;
}
if (value.equals(key)) {
getNextValue = true;
}
}
return null;
}
}