From dacac515d9cd401e432ebe8d88d96f7254a01d62 Mon Sep 17 00:00:00 2001 From: Mumfrey Date: Sun, 14 Dec 2014 16:45:00 +0000 Subject: [PATCH] Migrating mixin functionality from Sponge to new project --- .gitignore | 6 + .travis.yml | 8 + HEADER.txt | 22 + LICENSE.txt | 19 + build.gradle | 183 +++++++ checkstyle.xml | 162 ++++++ gradle.properties | 6 + settings.gradle | 1 + .../spongepowered/asm/mixin/Implements.java | 43 ++ .../spongepowered/asm/mixin/Interface.java | 50 ++ .../asm/mixin/InvalidMixinException.java | 42 ++ .../org/spongepowered/asm/mixin/Mixin.java | 48 ++ .../asm/mixin/MixinEnvironment.java | 90 ++++ .../spongepowered/asm/mixin/Overwrite.java | 39 ++ .../org/spongepowered/asm/mixin/Shadow.java | 68 +++ .../asm/mixin/transformer/InterfaceInfo.java | 170 +++++++ .../asm/mixin/transformer/MixinConfig.java | 171 +++++++ .../asm/mixin/transformer/MixinData.java | 202 ++++++++ .../asm/mixin/transformer/MixinInfo.java | 292 +++++++++++ .../mixin/transformer/MixinTransformer.java | 429 ++++++++++++++++ .../asm/transformers/TreeTransformer.java | 83 +++ .../org/spongepowered/asm/util/ASMHelper.java | 473 ++++++++++++++++++ 22 files changed, 2607 insertions(+) create mode 100644 .gitignore create mode 100644 .travis.yml create mode 100644 HEADER.txt create mode 100644 LICENSE.txt create mode 100644 build.gradle create mode 100644 checkstyle.xml create mode 100644 gradle.properties create mode 100644 settings.gradle create mode 100644 src/main/java/org/spongepowered/asm/mixin/Implements.java create mode 100644 src/main/java/org/spongepowered/asm/mixin/Interface.java create mode 100644 src/main/java/org/spongepowered/asm/mixin/InvalidMixinException.java create mode 100644 src/main/java/org/spongepowered/asm/mixin/Mixin.java create mode 100644 src/main/java/org/spongepowered/asm/mixin/MixinEnvironment.java create mode 100644 src/main/java/org/spongepowered/asm/mixin/Overwrite.java create mode 100644 src/main/java/org/spongepowered/asm/mixin/Shadow.java create mode 100644 src/main/java/org/spongepowered/asm/mixin/transformer/InterfaceInfo.java create mode 100644 src/main/java/org/spongepowered/asm/mixin/transformer/MixinConfig.java create mode 100644 src/main/java/org/spongepowered/asm/mixin/transformer/MixinData.java create mode 100644 src/main/java/org/spongepowered/asm/mixin/transformer/MixinInfo.java create mode 100644 src/main/java/org/spongepowered/asm/mixin/transformer/MixinTransformer.java create mode 100644 src/main/java/org/spongepowered/asm/transformers/TreeTransformer.java create mode 100644 src/main/java/org/spongepowered/asm/util/ASMHelper.java diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..ae0de099 --- /dev/null +++ b/.gitignore @@ -0,0 +1,6 @@ +/bin +.gradle +/build +.classpath +.project +.settings diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 00000000..e28241af --- /dev/null +++ b/.travis.yml @@ -0,0 +1,8 @@ +language: java +notifications: + email: false +install: true +matrix: + include: + - jdk: openjdk6 + script: gradle build \ No newline at end of file diff --git a/HEADER.txt b/HEADER.txt new file mode 100644 index 00000000..be04201c --- /dev/null +++ b/HEADER.txt @@ -0,0 +1,22 @@ +This file is part of Sponge, licensed under the MIT License (MIT). + +Copyright (c) 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. \ No newline at end of file diff --git a/LICENSE.txt b/LICENSE.txt new file mode 100644 index 00000000..72dc60d8 --- /dev/null +++ b/LICENSE.txt @@ -0,0 +1,19 @@ +The MIT License (MIT) + +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. diff --git a/build.gradle b/build.gradle new file mode 100644 index 00000000..5b9b7114 --- /dev/null +++ b/build.gradle @@ -0,0 +1,183 @@ +// Gradle repositories and dependencies +buildscript { + repositories { + jcenter() + } + dependencies { + classpath 'nl.javadude.gradle.plugins:license-gradle-plugin:0.11.0' + } +} + +// Apply plugin +apply plugin: 'java' +apply plugin: 'license' +apply plugin: 'checkstyle' +apply plugin: 'maven' +apply plugin: 'eclipse' +apply plugin: 'idea' + +// Default tasks +defaultTasks 'licenseFormat', 'check', 'build' + +// Basic project information +group = 'org.spongepowered' +archivesBaseName = 'mixin' +version = '0.1-SNAPSHOT' + +// Extended project information +ext.projectName = 'Mixin' +ext.inceptionYear = '2014' +ext.packaging = 'jar' +ext.url = 'http://spongepowered.org' +ext.description = 'Mixin' +ext.organization = 'SpongePowered' + +// Define variables +ext.buildNumber = project.hasProperty("buildNumber") ? buildNumber : '0' +ext.ciSystem = project.hasProperty("ciSystem") ? ciSystem : 'unknown' +ext.commit = project.hasProperty("commit") ? commit : 'unknown' + +// Minimum version of Java required +sourceCompatibility = '1.6' +targetCompatibility = '1.6' + +// Project repositories +repositories { + mavenCentral() + maven { + name = 'minecraft' + url = 'https://libraries.minecraft.net/' + } +} + +configurations { + deployerJars // maven stuff +} + +// Project dependencies +dependencies { + compile 'org.slf4j:slf4j-api:1.7.7' + compile 'com.google.guava:guava:17.0' + compile 'org.ow2.asm:asm-debug-all:5.0.3' + compile 'net.minecraft:launchwrapper:1.11' + compile 'com.google.code.gson:gson:2.2.4' + compile 'commons-io:commons-io:2.4' + testCompile 'junit:junit:4.11' + testCompile 'org.hamcrest:hamcrest-library:1.3' + testCompile 'org.mockito:mockito-core:1.9.0' + + // maven + deployerJars 'org.apache.maven.wagon:wagon-ftp:2.7' +} + +// Filter, process, and include resources +processResources { + // Include in final JAR + from 'LICENSE.txt' +} + +// License header formatting +license { + ext.name = project.name + ext.organization = project.organization + ext.url = project.url + ext.year = project.inceptionYear + exclude "**/*.info" + exclude "assets/**" + header file("HEADER.txt") + sourceSets = project.sourceSets + ignoreFailures false + strictCheck false + mapping { + java = 'SLASHSTAR_STYLE' + } +} + +checkstyle { + configProperties = [ + "name" : project.name, + "organization": project.organization, + "url" : project.url, + "year" : project.inceptionYear + ] + configFile = file("checkstyle.xml") +} + +// Source compiler configuration +configure([compileJava, compileTestJava]) { + options.compilerArgs += ['-Xlint:all', '-Xlint:-path'] + options.deprecation = true + options.encoding = 'utf8' +} + +// JAR manifest configuration +jar.manifest.mainAttributes( + "Built-By": System.properties['user.name'], + "Created-By": System.properties['java.vm.version'] + " (" + System.properties['java.vm.vendor'] + ")", + "Implementation-Title": name, + "Implementation-Version": version + "+" + ciSystem + "-b" + buildNumber + ".git-" + commit, + "Implementation-Vendor": url) + +task sourceJar(type: Jar) { + from sourceSets.main.java + from sourceSets.main.resources + classifier = "sources" +} + +task javadocJar(type: Jar, dependsOn: javadoc) { + from javadoc.destinationDir + classifier = "javadoc" +} + +artifacts { + archives jar + archives sourceJar + archives javadocJar +} + +uploadArchives { + repositories { + + mavenDeployer { + configuration = configurations.deployerJars + + if (project.hasProperty("chRepo")) + { + repository(url: project.chRepo) { + authentication(userName: project.chUsername, password: project.chPassword) + } + } + + pom { + groupId = project.group + version = project.version + artifactId = project.archivesBaseName + project { + name project.archivesBaseName + packaging 'jar' + description 'Sponge API' + url 'http://www.spongepowered.org/' + + scm { + url 'https://github.com/SpongePowered/SpongeAPI' + connection 'scm:git:git://github.com/SpongePowered/SpongeAPI.git' + developerConnection 'scm:git:git@github.com:SpongePowered/SpongeAPI.git' + } + + issueManagement { + system 'youtrack' + url 'https://issues.spongepowered.org/' + } + + licenses { + license { + name 'MIT license' + url 'http://opensource.org/licenses/MIT' + distribution 'repo' + } + } + } + } + } + } +} diff --git a/checkstyle.xml b/checkstyle.xml new file mode 100644 index 00000000..3cdcd424 --- /dev/null +++ b/checkstyle.xml @@ -0,0 +1,162 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/gradle.properties b/gradle.properties new file mode 100644 index 00000000..fbb044b9 --- /dev/null +++ b/gradle.properties @@ -0,0 +1,6 @@ +theName=Mixin +inceptionYear=2014 +packaging=jar +url=http://spongepowered.org +description=SpongeAPI +organization=SpongePowered diff --git a/settings.gradle b/settings.gradle new file mode 100644 index 00000000..a809ba95 --- /dev/null +++ b/settings.gradle @@ -0,0 +1 @@ +rootProject.name = theName diff --git a/src/main/java/org/spongepowered/asm/mixin/Implements.java b/src/main/java/org/spongepowered/asm/mixin/Implements.java new file mode 100644 index 00000000..d7a31622 --- /dev/null +++ b/src/main/java/org/spongepowered/asm/mixin/Implements.java @@ -0,0 +1,43 @@ +/** + * This file is part of Sponge, licensed under the MIT License (MIT). + * + * Copyright (c) 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(); +} diff --git a/src/main/java/org/spongepowered/asm/mixin/Interface.java b/src/main/java/org/spongepowered/asm/mixin/Interface.java new file mode 100644 index 00000000..a4c5b52a --- /dev/null +++ b/src/main/java/org/spongepowered/asm/mixin/Interface.java @@ -0,0 +1,50 @@ +/** + * This file is part of Sponge, licensed under the MIT License (MIT). + * + * Copyright (c) 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 must end with a dollar sign ($) + */ + public String prefix(); + +} diff --git a/src/main/java/org/spongepowered/asm/mixin/InvalidMixinException.java b/src/main/java/org/spongepowered/asm/mixin/InvalidMixinException.java new file mode 100644 index 00000000..147739d8 --- /dev/null +++ b/src/main/java/org/spongepowered/asm/mixin/InvalidMixinException.java @@ -0,0 +1,42 @@ +/** + * This file is part of Sponge, licensed under the MIT License (MIT). + * + * Copyright (c) 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); + } +} diff --git a/src/main/java/org/spongepowered/asm/mixin/Mixin.java b/src/main/java/org/spongepowered/asm/mixin/Mixin.java new file mode 100644 index 00000000..210f0310 --- /dev/null +++ b/src/main/java/org/spongepowered/asm/mixin/Mixin.java @@ -0,0 +1,48 @@ +/** + * This file is part of Sponge, licensed under the MIT License (MIT). + * + * Copyright (c) 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; +} diff --git a/src/main/java/org/spongepowered/asm/mixin/MixinEnvironment.java b/src/main/java/org/spongepowered/asm/mixin/MixinEnvironment.java new file mode 100644 index 00000000..ab5d740a --- /dev/null +++ b/src/main/java/org/spongepowered/asm/mixin/MixinEnvironment.java @@ -0,0 +1,90 @@ +/** + * This file is part of Sponge, licensed under the MIT License (MIT). + * + * Copyright (c) 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 getMixinConfigs() { + @SuppressWarnings("unchecked") + List mixinConfigs = (List) Launch.blackboard.get(MixinEnvironment.CONFIGS_KEY); + if (mixinConfigs == null) { + mixinConfigs = new ArrayList(); + 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; + } +} diff --git a/src/main/java/org/spongepowered/asm/mixin/Overwrite.java b/src/main/java/org/spongepowered/asm/mixin/Overwrite.java new file mode 100644 index 00000000..8121b46f --- /dev/null +++ b/src/main/java/org/spongepowered/asm/mixin/Overwrite.java @@ -0,0 +1,39 @@ +/** + * This file is part of Sponge, licensed under the MIT License (MIT). + * + * Copyright (c) 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 { + +} diff --git a/src/main/java/org/spongepowered/asm/mixin/Shadow.java b/src/main/java/org/spongepowered/asm/mixin/Shadow.java new file mode 100644 index 00000000..13a6925b --- /dev/null +++ b/src/main/java/org/spongepowered/asm/mixin/Shadow.java @@ -0,0 +1,68 @@ +/** + * This file is part of Sponge, licensed under the MIT License (MIT). + * + * Copyright (c) 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 { + + /** + *

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.

+ * + *

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

: + * + *
+     *     @Shadow abstract void someMethod(int arg1, int arg2);
+     *     @Shadow abstract void shadow$someMethod(int arg1, int arg2);
+     *     @Shadow(prefix = "shadow$") abstract void shadow$someMethod(int arg1, int arg2);
+     *     @Shadow(prefix = "foo$") abstract void foo$someMethod(int arg1, int arg2);
+     * 
+ * + *

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.

+ * + *

Note that specifying a prefix does not enforce use of the prefix, the behaviour of prefix is such that the prefix + * will be stripped from the start of the method name as long as the method name actually starts with the prefix! This has important + * repercussions since if the annotation value does not match the method prefix then no renaming will take place likey resulting in + * a failure state indicated by an {@link InvalidMixinException} at run time.

+ */ + public String prefix() default "shadow$"; + +} diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/InterfaceInfo.java b/src/main/java/org/spongepowered/asm/mixin/transformer/InterfaceInfo.java new file mode 100644 index 00000000..1039b7dd --- /dev/null +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/InterfaceInfo.java @@ -0,0 +1,170 @@ +/** + * This file is part of Sponge, licensed under the MIT License (MIT). + * + * Copyright (c) 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 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(); + 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.getAnnotationValue(node, "prefix"); + Type iface = ASMHelper.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); + } +} diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinConfig.java b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinConfig.java new file mode 100644 index 00000000..bb15ab9a --- /dev/null +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinConfig.java @@ -0,0 +1,171 @@ +/** + * This file is part of Sponge, licensed under the MIT License (MIT). + * + * Copyright (c) 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> mixinMapping = new HashMap>(); + + /** + * 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 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() {} + + /** + *

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 after 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.

+ * + *

For this reason we will invoke the initialisation on the first call to either the hasMixinsFor() or getMixinsFor() + * methods.

+ */ + 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 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 getMixinsFor(String targetClass) { + if (!this.initialised) { + this.initialise(); + } + + List mixins = this.mixinMapping.get(targetClass); + if (mixins == null) { + mixins = new ArrayList(); + 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)); + } + } +} diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinData.java b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinData.java new file mode 100644 index 00000000..14500ffd --- /dev/null +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinData.java @@ -0,0 +1,202 @@ +/** + * This file is part of Sponge, licensed under the MIT License (MIT). + * + * Copyright (c) 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 renamedMethods = new HashMap(); + + /** + * Interfaces soft-implemented using {@link Implements} + */ + private final List softImplements = new ArrayList(); + + /** + * All interfaces implemented by this mixin, including soft implementations + */ + private final Set interfaces = new HashSet(); + + /** + * 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 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 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 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; + } +} diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinInfo.java b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinInfo.java new file mode 100644 index 00000000..678a7e37 --- /dev/null +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinInfo.java @@ -0,0 +1,292 @@ +/** + * This file is part of Sponge, licensed under the MIT License (MIT). + * + * Copyright (c) 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 { + + /** + * 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 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 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 targetClasses = ASMHelper.getAnnotationValue(mixin); + List targetClassNames = new ArrayList(); + 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 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 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); + } +} diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTransformer.java b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTransformer.java new file mode 100644 index 00000000..d7801bf9 --- /dev/null +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTransformer.java @@ -0,0 +1,429 @@ +/** + * This file is part of Sponge, licensed under the MIT License (MIT). + * + * Copyright (c) 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 configs = new ArrayList(); + + /** + * 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 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 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 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 ("".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 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 findReturnIter = method.instructions.iterator(); + while (findReturnIter.hasNext()) { + AbstractInsnNode insn = findReturnIter.next(); + if (insn.getOpcode() == Opcodes.RETURN) { + returnNode = insn; + break; + } + } + + Iterator 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; + } +} diff --git a/src/main/java/org/spongepowered/asm/transformers/TreeTransformer.java b/src/main/java/org/spongepowered/asm/transformers/TreeTransformer.java new file mode 100644 index 00000000..c2c0a769 --- /dev/null +++ b/src/main/java/org/spongepowered/asm/transformers/TreeTransformer.java @@ -0,0 +1,83 @@ +/** + * This file is part of Sponge, licensed under the MIT License (MIT). + * + * Copyright (c) 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(); + } +} diff --git a/src/main/java/org/spongepowered/asm/util/ASMHelper.java b/src/main/java/org/spongepowered/asm/util/ASMHelper.java new file mode 100644 index 00000000..7e876535 --- /dev/null +++ b/src/main/java/org/spongepowered/asm/util/ASMHelper.java @@ -0,0 +1,473 @@ +/** + * This file is part of Sponge, licensed under the MIT License (MIT). + * + * Copyright (c) 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 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 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 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 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 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 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 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 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 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 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; + } +}