diff --git a/build.gradle b/build.gradle index 79714819..ec291667 100644 --- a/build.gradle +++ b/build.gradle @@ -44,6 +44,16 @@ targetCompatibility = '1.6' // Project repositories repositories { mavenCentral() + maven { + // for srg2source + name = "forge" + url = "http://files.minecraftforge.net/maven" + } + maven { + // because Srg2Source needs an eclipse dependency. + name = "eclipse" + url = "https://repo.eclipse.org/content/groups/eclipse/" + } maven { name = 'minecraft' url = 'https://libraries.minecraft.net/' @@ -54,6 +64,14 @@ configurations { deployerJars // maven stuff } + +// Include annotation processor sourceSet +sourceSets { + ap { + compileClasspath += main.output + } +} + // Project dependencies dependencies { compile 'org.slf4j:slf4j-api:1.7.7' @@ -68,6 +86,10 @@ dependencies { // maven deployerJars 'org.apache.maven.wagon:wagon-ftp:2.7' + + // for annotation processor + compile 'net.minecraftforge.srg2source:Srg2Source:3.2-SNAPSHOT' + apCompile 'net.minecraftforge.srg2source:Srg2Source:3.2-SNAPSHOT' } // Filter, process, and include resources @@ -104,23 +126,30 @@ checkstyle { } // Source compiler configuration -configure([compileJava, compileTestJava]) { +tasks.withType(JavaCompile) { options.compilerArgs += ['-Xlint:all', '-Xlint:-path'] options.deprecation = true options.encoding = 'utf8' } -// JAR manifest configuration -jar.manifest.mainAttributes( +jar { + // Include annotation processor + from sourceSets.ap.output + + // JAR manifest configuration + 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 + from sourceSets.ap.java + from sourceSets.ap.resources classifier = "sources" } diff --git a/src/ap/java/org/spongepowered/tools/MirrorUtils.java b/src/ap/java/org/spongepowered/tools/MirrorUtils.java new file mode 100644 index 00000000..c9070117 --- /dev/null +++ b/src/ap/java/org/spongepowered/tools/MirrorUtils.java @@ -0,0 +1,212 @@ +/* + * 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.tools; + +import java.lang.annotation.Annotation; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +import javax.lang.model.element.AnnotationMirror; +import javax.lang.model.element.AnnotationValue; +import javax.lang.model.element.Element; +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.PackageElement; +import javax.lang.model.element.TypeElement; +import javax.lang.model.element.TypeParameterElement; +import javax.lang.model.element.VariableElement; +import javax.lang.model.type.ArrayType; +import javax.lang.model.type.DeclaredType; +import javax.lang.model.type.TypeMirror; + + +/** + * Convenience functions for mirror + */ +public abstract class MirrorUtils { + + // No instances for you + private MirrorUtils() {} + + public static AnnotationMirror getAnnotation(Element elem, Class annotationClass) { + List annotations = elem.getAnnotationMirrors(); + + if (annotations == null) { + return null; + } + + for (AnnotationMirror annotation : annotations) { + Element element = annotation.getAnnotationType().asElement(); + if (!(element instanceof TypeElement)) { + continue; + } + TypeElement annotationElement = (TypeElement)element; + if (annotationElement.getQualifiedName().contentEquals(annotationClass.getName())) { + return annotation; + } + } + + return null; + } + + @SuppressWarnings("unchecked") + public static T getAnnotationValue(AnnotationMirror annotation, String key, T defaultValue) { + if (annotation == null) { + return defaultValue; + } + + AnnotationValue value = MirrorUtils.getAnnotationValue0(annotation, key); + return value != null ? (T)value.getValue() : defaultValue; + } + + public static T getAnnotationValue(TypeElement elem, Class annotationClass, String key, T defaultValue) { + AnnotationMirror annotation = MirrorUtils.getAnnotation(elem, annotationClass); + return MirrorUtils.getAnnotationValue(annotation, key, defaultValue); + } + + public static T getAnnotationValue(AnnotationMirror annotation) { + return MirrorUtils.getAnnotationValue(annotation, "value", null); + } + + public static T getAnnotationValue(AnnotationMirror annotation, String key) { + return MirrorUtils.getAnnotationValue(annotation, key, null); + } + + public static T getAnnotationValue(TypeElement elem, Class annotationClass) { + return MirrorUtils.getAnnotationValue(elem, annotationClass, "value"); + } + + public static T getAnnotationValue(TypeElement elem, Class annotationClass, String key) { + AnnotationMirror annotation = MirrorUtils.getAnnotation(elem, annotationClass); + return MirrorUtils.getAnnotationValue(annotation, key, null); + } + + private static AnnotationValue getAnnotationValue0(AnnotationMirror annotation, String key) { + for (ExecutableElement elem : annotation.getElementValues().keySet()) { + if (elem.getSimpleName().contentEquals(key)) { + return annotation.getElementValues().get(elem); + } + } + + return null; + } + + @SuppressWarnings("unchecked") + public static List unfold(List list) { + if (list == null) { + return Collections.emptyList(); + } + + List unfolded = new ArrayList(list.size()); + for (AnnotationValue value : list) { + unfolded.add((T)value.getValue()); + } + + return unfolded; + } + + public static PackageElement getPackage(TypeElement elem) { + Element parent = elem.getEnclosingElement(); + while (parent != null && !(parent instanceof PackageElement)) { + parent = parent.getEnclosingElement(); + } + return (PackageElement)parent; + } + + public static String getElementType(Element parent) { + if (parent instanceof TypeElement) { + return "TypeElement"; + } else if (parent instanceof ExecutableElement) { + return "ExecutableElement"; + } else if (parent instanceof VariableElement) { + return "VariableElement"; + } else if (parent instanceof PackageElement) { + return "PackageElement"; + } else if (parent instanceof TypeParameterElement) { + return "TypeParameterElement"; + } + + return parent.getClass().getSimpleName(); + } + + public static String generateSignature(ExecutableElement method) { + StringBuilder signature = new StringBuilder(); + + for (VariableElement var : method.getParameters()) { + signature.append(MirrorUtils.getInternalName(var)); + } + + return String.format("(%s)%s", signature, MirrorUtils.getInternalName(method.getReturnType())); + } + + public static String getInternalName(VariableElement var) { + return MirrorUtils.getInternalName(var.asType()); + } + + public static String getInternalName(TypeMirror type) { + switch (type.getKind()) { + case ARRAY: return "[" + MirrorUtils.getInternalName(((ArrayType)type).getComponentType()); + case BOOLEAN: + return "Z"; + case BYTE: + return "B"; + case CHAR: + return "C"; + case DOUBLE: + return "D"; + case FLOAT: + return "F"; + case INT: + return "I"; + case LONG: + return "J"; + case SHORT: + return "S"; + case DECLARED: + return "L" + MirrorUtils.getInternalName((DeclaredType)type) + ";"; + case VOID: + return "V"; + default: + } + + throw new IllegalArgumentException("Unable to parse type symbol " + type + " to equivalent bytecode type"); + } + + public static String getInternalName(DeclaredType type) { + TypeElement elem = (TypeElement)type.asElement(); + StringBuilder reference = new StringBuilder(); + reference.append(elem.getSimpleName()); + Element parent = elem.getEnclosingElement(); + while (parent != null) { + if (parent instanceof TypeElement) { + reference.insert(0, "$").insert(0, parent.getSimpleName()); + } else if (parent instanceof PackageElement) { + reference.insert(0, "/").insert(0, ((PackageElement)parent).getQualifiedName().toString().replace('.', '/')); + } + parent = parent.getEnclosingElement(); + } + return reference.toString(); + } +} diff --git a/src/ap/java/org/spongepowered/tools/obfuscation/AnnotatedMixin.java b/src/ap/java/org/spongepowered/tools/obfuscation/AnnotatedMixin.java new file mode 100644 index 00000000..5e5d7539 --- /dev/null +++ b/src/ap/java/org/spongepowered/tools/obfuscation/AnnotatedMixin.java @@ -0,0 +1,421 @@ +/* + * 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.tools.obfuscation; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import javax.lang.model.element.AnnotationMirror; +import javax.lang.model.element.AnnotationValue; +import javax.lang.model.element.Element; +import javax.lang.model.element.ElementKind; +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.TypeElement; +import javax.lang.model.element.VariableElement; +import javax.lang.model.type.DeclaredType; +import javax.lang.model.type.TypeMirror; +import javax.tools.Diagnostic.Kind; + +import net.minecraftforge.srg2source.rangeapplier.MethodData; + +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.injection.struct.MemberInfo; +import org.spongepowered.tools.MirrorUtils; + + +/** + * Information about a mixin stored during processing + */ +class AnnotatedMixin { + + /** + * Convenience class to store information about an {@link org.spongepowered.asm.mixin.Shadow}ed member's names + */ + class ShadowElementName { + private final boolean hasPrefix; + + private final String prefix; + + private final String baseName; + + private final String originalName; + + private String obfuscated; + + ShadowElementName(Element method, AnnotationMirror shadow) { + boolean hasPrefix = false; + this.prefix = MirrorUtils.getAnnotationValue(shadow, "prefix", "shadow$"); + String name = this.originalName = method.getSimpleName().toString(); + if (name.startsWith(this.prefix)) { + hasPrefix = true; + name = name.substring(this.prefix.length()); + } + this.hasPrefix = hasPrefix; + this.obfuscated = this.baseName = name; + } + + @Override + public String toString() { + return this.baseName; + } + + public ShadowElementName setObfuscatedName(String name) { + this.obfuscated = name.substring(name.lastIndexOf('/') + 1); + return this; + } + + public String originalName() { + return this.originalName; + } + + public String prefix() { + return this.hasPrefix ? this.prefix : ""; + } + + public String name() { + return this.prefix(this.baseName); + } + + public String obfuscated() { + return this.prefix(this.obfuscated); + } + + public String prefix(String name) { + return this.hasPrefix ? this.prefix + name : name; + } + } + + /** + * Manager + */ + private final AnnotatedMixins mixins; + + /** + * Mixin class + */ + private final TypeElement mixin; + + /** + * Specified targets + */ + private final List targets = new ArrayList(); + + /** + * Target "reference" (bytecode name) + */ + private final String targetRef; + + /** + * Target type (for single-target mixins) + */ + private final TypeElement targetType; + + /** + * Mixin class "reference" (bytecode name) + */ + private final String classRef; + + /** + * Stored (ordered) field mappings + */ + private final Set fieldMappings = new LinkedHashSet(); + + /** + * Stored (ordered) method mappings + */ + private final Set methodMappings = new LinkedHashSet(); + + public AnnotatedMixin(AnnotatedMixins mixins, TypeElement type) { + this.mixins = mixins; + this.mixin = type; + this.classRef = type.getQualifiedName().toString().replace('.', '/'); + + String targetRef = null; + TypeElement targetType = null; + List targetList = MirrorUtils.>getAnnotationValue(type, Mixin.class); + for (TypeMirror target : MirrorUtils.unfold(targetList)) { + Element element = ((DeclaredType)target).asElement(); + String targetName = ((TypeElement)element).getQualifiedName().toString(); + this.targets.add(targetName); + if (targetRef == null) { + targetRef = MirrorUtils.getInternalName((DeclaredType)target); + targetType = (TypeElement) ((DeclaredType)target).asElement(); + } + } + + this.targetRef = targetRef; + this.targetType = targetType; + } + + /** + * Get the mixin class + */ + public TypeElement getMixin() { + return this.mixin; + } + + /** + * Get the mixin's targets + */ + public List getTargets() { + return this.targets; + } + + /** + * Get stored field mappings + */ + public Set getFieldMappings() { + return this.fieldMappings; + } + + /** + * Get stored method mappings + */ + public Set getMethodMappings() { + return this.methodMappings; + } + + /** + * Clear all stored mappings + */ + public void clear() { + this.fieldMappings.clear(); + this.methodMappings.clear(); + } + + /** + * Validate method for {@link org.spongepowered.asm.mixin.Shadow} and {@link org.spongepowered.asm.mixin.Overwrite} registrations to check that + * only a single target is registered. Mixins containing annotated methods with these annotations cannot be multi-targetted. + */ + private boolean validateSingleTarget(String annotation) { + if (this.targetRef == null) { + this.mixins.printMessage(Kind.ERROR, "Mixin class " + this.mixin + " has multiple targets. " + annotation + " is not supported!"); + return false; + } + return true; + } + + /** + * Register an {@link org.spongepowered.asm.mixin.Overwrite} method + */ + public void registerOverwrite(ExecutableElement method) { + if (!this.validateSingleTarget("@Overwrite")) { + return; + } + + String mcpName = method.getSimpleName().toString(); + String mcpSignature = MirrorUtils.generateSignature(method); + MethodData obfMethod = this.mixins.getObfMethod(new MethodData(this.targetRef + "/" + mcpName, mcpSignature)); + + if (obfMethod == null) { + this.mixins.printMessage(Kind.ERROR, "No obfuscation mapping for @Overwrite method " + mcpName + " in " + this.mixin); + return; + } + + this.addMethodMapping(mcpName, obfMethod.name, mcpSignature, obfMethod.sig); + } + + /** + * Register a {@link org.spongepowered.asm.mixin.Shadow} field + */ + public void registerShadow(VariableElement field, AnnotationMirror shadow) { + if (!this.validateSingleTarget("@Shadow")) { + return; + } + + ShadowElementName name = new ShadowElementName(field, shadow); + String obfField = this.mixins.getObfField(this.targetRef + "/" + name); + + if (obfField == null) { + this.mixins.printMessage(Kind.WARNING, "Unable to locate obfuscation mapping for @Shadow field " + name + " in " + this.mixin); + return; + } + + this.addFieldMapping(name.setObfuscatedName(obfField)); + } + + /** + * Register a {@link org.spongepowered.asm.mixin.Shadow} method + */ + public void registerShadow(ExecutableElement method, AnnotationMirror shadow) { + if (!this.validateSingleTarget("@Shadow")) { + return; + } + + ShadowElementName name = new ShadowElementName(method, shadow); + String mcpSignature = MirrorUtils.generateSignature(method); + MethodData obfMethod = this.mixins.getObfMethod(new MethodData(this.targetRef + "/" + name, mcpSignature)); + + if (obfMethod == null) { + this.mixins.printMessage(Kind.WARNING, "Unable to locate obfuscation mapping for @Shadow method " + name + " in " + this.mixin); + return; + } + + this.addMethodMapping(name.setObfuscatedName(obfMethod.name), mcpSignature, obfMethod.sig); + } + + /** + * Register a {@link org.spongepowered.asm.mixin.injection.Inject} method + */ + public void registerInjector(ExecutableElement method, AnnotationMirror inject) { + if (!this.validateSingleTarget("@Inject")) { + return; + } + + String originalReference = MirrorUtils.getAnnotationValue(inject, "method"); + MemberInfo targetMember = MemberInfo.parse(originalReference); + if (targetMember.name == null) { + return; + } + + String desc = AnnotatedMixin.findDescriptor(this.targetType, targetMember); + if (desc == null) { + this.mixins.printMessage(Kind.WARNING, "Unable to parse signature for @Inject target " + targetMember.name + " in " + this.mixin); + return; + } + + MethodData obfMethod = this.mixins.getObfMethod(new MethodData(this.targetRef + "/" + targetMember.name, desc)); + if (obfMethod == null) { + this.mixins.printMessage(Kind.ERROR, "No obfuscation mapping for @Inject target " + targetMember.name + " in " + this.mixin); + return; + } + + String obfName = obfMethod.name.substring(obfMethod.name.lastIndexOf('/') + 1); + MemberInfo remappedReference = new MemberInfo(obfName, this.targetRef, obfMethod.sig, false); + + this.mixins.getReferenceMapper().addMapping(this.classRef, originalReference, remappedReference.toString()); + } + + /** + * Register a {@link org.spongepowered.asm.mixin.injection.At} annotation and process the references + */ + public void registerInjectionPoint(AnnotationMirror at) { + String type = MirrorUtils.getAnnotationValue(at, "value"); + String target = MirrorUtils.getAnnotationValue(at, "target"); + this.remapReference(type + ".", target); + + // Pattern for replacing references in args, not used yet +// if ("SOMETYPE".equals(type)) { +// Map args = AnnotatedMixin.getAtArgs(at); +// this.remapReference(type + ".args[target]", args.get("target")); +// } + } + + private void remapReference(String key, String target) { + if (target == null) { + return; + } + + MemberInfo targetMember = MemberInfo.parse(target); + if (!targetMember.isFullyQualified()) { + String missing = "missing " + (targetMember.owner == null ? (targetMember.desc == null ? "owner and signature" : "owner") : "signature"); + this.mixins.printMessage(Kind.ERROR, "@At(" + key + ") is not fully qualified, " + missing + " in \"" + target + "\" in " + this.mixin); + return; + } + + MemberInfo remappedReference = null; + if (targetMember.isField()) { + String obfField = this.mixins.getObfField(targetMember.toSrg()); + if (obfField == null) { + this.mixins.printMessage(Kind.WARNING, "Cannot find field mapping for @At(" + key + ") \"" + target + "\" in " + this.mixin); + return; + } + remappedReference = MemberInfo.fromSrgField(obfField, targetMember.desc); + } else { + MethodData obfMethod = this.mixins.getObfMethod(targetMember.asMethodData()); + if (obfMethod == null) { + this.mixins.printMessage(Kind.WARNING, "Cannot find method mapping for @At(" + key + ") \"" + target + "\" in " + this.mixin); + return; + } + remappedReference = MemberInfo.fromSrgMethod(obfMethod); + } + + this.mixins.getReferenceMapper().addMapping(this.classRef, target, remappedReference.toString()); + } + + /** + * Add a field mapping to the local table + */ + private void addFieldMapping(ShadowElementName name) { + String mapping = String.format("FD: %s %s", this.classRef + "/" + name.name(), this.classRef + "/" + name.obfuscated()); + this.fieldMappings.add(mapping); + } + + /** + * Add a method mapping to the local table + */ + private void addMethodMapping(ShadowElementName name, String mcpSignature, String obfSignature) { + this.addMethodMapping(name.name(), name.obfuscated(), mcpSignature, obfSignature); + } + + /** + * Add a method mapping to the local table + */ + private void addMethodMapping(String mcpName, String obfName, String mcpSignature, String obfSignature) { + String mapping = String.format("MD: %s %s %s %s", this.classRef + "/" + mcpName, mcpSignature, this.classRef + "/" + obfName, obfSignature); + this.methodMappings.add(mapping); + } + + static String findDescriptor(TypeElement targetType, MemberInfo memberInfo) { + String desc = memberInfo.desc; + if (desc == null) { + for (Element child : targetType.getEnclosedElements()) { + if (child.getKind() != ElementKind.METHOD) { + continue; + } + + if (child.getSimpleName().toString().equals(memberInfo.name)) { + desc = MirrorUtils.generateSignature((ExecutableElement)child); + break; + } + } + } + return desc; + } + + static Map getAtArgs(AnnotationMirror at) { + Map args = new HashMap(); + List argv = MirrorUtils.>getAnnotationValue(at, "args"); + if (argv != null) { + for (AnnotationValue av : argv) { + String arg = (String)av.getValue(); + if (arg == null) { + continue; + } + int eqPos = arg.indexOf('='); + if (eqPos > -1) { + args.put(arg.substring(0, eqPos), arg.substring(eqPos + 1)); + } else { + args.put(arg, ""); + } + } + } + return args; + } +} diff --git a/src/ap/java/org/spongepowered/tools/obfuscation/AnnotatedMixins.java b/src/ap/java/org/spongepowered/tools/obfuscation/AnnotatedMixins.java new file mode 100644 index 00000000..3de82d85 --- /dev/null +++ b/src/ap/java/org/spongepowered/tools/obfuscation/AnnotatedMixins.java @@ -0,0 +1,328 @@ +/* + * 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.tools.obfuscation; + +import java.io.File; +import java.io.IOException; +import java.io.PrintWriter; +import java.util.HashMap; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import javax.annotation.processing.Filer; +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.AnnotationMirror; +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.TypeElement; +import javax.lang.model.element.VariableElement; +import javax.tools.Diagnostic; +import javax.tools.Diagnostic.Kind; +import javax.tools.FileObject; +import javax.tools.StandardLocation; + +import org.spongepowered.asm.mixin.injection.struct.ReferenceMapper; +import org.spongepowered.tools.MirrorUtils; + +import net.minecraftforge.srg2source.rangeapplier.MethodData; +import net.minecraftforge.srg2source.rangeapplier.SrgContainer; + + +/** + * Mixin info manager, stores all of the mixin info during processing and also manages access to the srgs + */ +class AnnotatedMixins { + + /** + * Singleton instances for each ProcessingEnvironment + */ + private static Map instances = new HashMap(); + + /** + * Local processing environment + */ + private final ProcessingEnvironment processingEnv; + + /** + * Mixins during processing phase + */ + private final Map mixins = new HashMap(); + + /** + * Name of the resource to write generated srgs to + */ + private final String outSrgFileName; + + /** + * File containing the reobfd srgs + */ + private final File reobfSrgFile; + + /** + * SRG container for mcp->srg mappings + */ + private final SrgContainer srgs = new SrgContainer(); + + /** + * Reference mapper for reference mapping + */ + private final ReferenceMapper refMapper = new ReferenceMapper(); + + /** + * Private constructor, get instances using {@link #getMixinsForEnvironment} + */ + private AnnotatedMixins(ProcessingEnvironment processingEnv) { + String outSrgFileName = processingEnv.getOptions().get("outSrgFile"); + this.outSrgFileName = (outSrgFileName != null) ? outSrgFileName : "mixins.srg"; + + String reobfSrgFileName = processingEnv.getOptions().get("reobfSrgFile"); + if (reobfSrgFileName == null) { + processingEnv.getMessager().printMessage(Kind.ERROR, "The reobfSrgFile argument was not supplied, processing cannot continue"); + } + + this.processingEnv = processingEnv; + this.reobfSrgFile = new File(reobfSrgFileName); + + try { + this.srgs.readSrg(this.reobfSrgFile); + } catch (Exception ex) { + ex.printStackTrace(); + processingEnv.getMessager().printMessage(Kind.ERROR, "The specified SRG file could not be read, processing cannot continue"); + } + } + + /** + * Write out generated srgs + */ + public void writeSrgs() { + Set fieldMappings = new LinkedHashSet(); + Set methodMappings = new LinkedHashSet(); + + for (AnnotatedMixin mixin : this.mixins.values()) { + fieldMappings.addAll(mixin.getFieldMappings()); + methodMappings.addAll(mixin.getMethodMappings()); + } + + PrintWriter writer = null; + + try { + Filer filer = this.processingEnv.getFiler(); + FileObject outSrg = filer.createResource(StandardLocation.CLASS_OUTPUT, "", this.outSrgFileName); + writer = new PrintWriter(outSrg.openWriter()); + for (String fieldMapping : fieldMappings) { + writer.println(fieldMapping); + } + for (String methodMapping : methodMappings) { + writer.println(methodMapping); + } + } catch (IOException ex) { + ex.printStackTrace(); + } finally { + if (writer != null) { + try { + writer.close(); + } catch (Exception ex) { + // oh well + } + } + } + } + + /** + * Write out stored mappings + */ + public void writeRefs() { + PrintWriter writer = null; + + try { + Filer filer = this.processingEnv.getFiler(); + FileObject outSrg = filer.createResource(StandardLocation.CLASS_OUTPUT, "", ReferenceMapper.DEFAULT_RESOURCE); + writer = new PrintWriter(outSrg.openWriter()); + this.refMapper.write(writer); + } catch (IOException ex) { + ex.printStackTrace(); + } finally { + if (writer != null) { + try { + writer.close(); + } catch (Exception ex) { + // oh well + } + } + } + + } + + /** + * Get the reference mapper + */ + public ReferenceMapper getReferenceMapper() { + return this.refMapper; + } + + /** + * Clear all registered mixins + */ + public void clear() { + this.mixins.clear(); + } + + /** + * Register a new mixin class + */ + public void registerMixin(TypeElement mixinType) { + String name = mixinType.getQualifiedName().toString(); + + if (!this.mixins.containsKey(name)) { + this.mixins.put(name, new AnnotatedMixin(this, mixinType)); + } + } + + /** + * Get a registered mixin + */ + public AnnotatedMixin getMixin(TypeElement mixinType) { + return this.getMixin(mixinType.getQualifiedName().toString()); + } + + /** + * Get a registered mixin + */ + public AnnotatedMixin getMixin(String mixinType) { + return this.mixins.get(mixinType); + } + + /** + * Register an {@link org.spongepowered.asm.mixin.Overwrite} method + * + * @param mixinType Mixin class + * @param method Overwrite method + */ + public void registerOverwrite(TypeElement mixinType, ExecutableElement method) { + AnnotatedMixin mixinClass = this.getMixin(mixinType); + if (mixinClass == null) { + this.processingEnv.getMessager().printMessage(Kind.ERROR, + "Found @Overwrite annotation on a non-mixin method " + method + " in " + mixinType); + return; + } + mixinClass.registerOverwrite(method); + } + + /** + * Register a {@link org.spongepowered.asm.mixin.Shadow} field + * + * @param mixinType Mixin class + * @param method Shadow field + * @param shadow {@link org.spongepowered.asm.mixin.Shadow} annotation + */ + public void registerShadow(TypeElement mixinType, VariableElement field, AnnotationMirror shadow) { + AnnotatedMixin mixinClass = this.getMixin(mixinType); + if (mixinClass == null) { + this.processingEnv.getMessager().printMessage(Kind.ERROR, + "Found @Shadow annotation on a non-mixin field " + field + " in " + mixinType); + return; + } + mixinClass.registerShadow(field, shadow); + } + + /** + * Register a {@link org.spongepowered.asm.mixin.Shadow} method + * + * @param mixinType Mixin class + * @param method Shadow method + * @param shadow {@link org.spongepowered.asm.mixin.Shadow} annotation + */ + public void registerShadow(TypeElement mixinType, ExecutableElement method, AnnotationMirror shadow) { + AnnotatedMixin mixinClass = this.getMixin(mixinType); + if (mixinClass == null) { + this.processingEnv.getMessager().printMessage(Kind.ERROR, + "Found @Shadow annotation on a non-mixin method " + method + " in " + mixinType); + return; + } + mixinClass.registerShadow(method, shadow); + } + + /** + * Register a {@link org.spongepowered.asm.mixin.injection.Inject} method + * + * @param mixinType Mixin class + * @param method Injector method + * @param inject {@link org.spongepowered.asm.mixin.injection.Inject} annotation + */ + public void registerInjector(TypeElement mixinType, ExecutableElement method, AnnotationMirror inject) { + AnnotatedMixin mixinClass = this.getMixin(mixinType); + if (mixinClass == null) { + this.processingEnv.getMessager().printMessage(Kind.ERROR, + "Found @Inject annotation on a non-mixin method " + method + " in " + mixinType); + return; + } + mixinClass.registerInjector(method, inject); + + List annotationValue = MirrorUtils.>getAnnotationValue(inject, "at"); + for (AnnotationMirror at : annotationValue) { + mixinClass.registerInjectionPoint(at); + } + } + + /** + * Print a message to the AP messager + */ + public void printMessage(Diagnostic.Kind kind, CharSequence msg) { + this.processingEnv.getMessager().printMessage(kind, msg); + } + + /** + * Get an obfuscation mapping for a method + */ + public MethodData getObfMethod(MethodData method) { + if (this.srgs == null) { + return null; + } + return this.srgs.methodMap.get(method); + } + + /** + * Get an obfuscation mapping for a field + */ + public String getObfField(String field) { + if (this.srgs == null) { + return null; + } + return this.srgs.fieldMap.get(field); + } + + /** + * Get the mixin manager instance for this environment + */ + public static AnnotatedMixins getMixinsForEnvironment(ProcessingEnvironment processingEnv) { + AnnotatedMixins mixins = AnnotatedMixins.instances.get(processingEnv); + if (mixins == null) { + mixins = new AnnotatedMixins(processingEnv); + AnnotatedMixins.instances.put(processingEnv, mixins); + } + return mixins; + } +} diff --git a/src/ap/java/org/spongepowered/tools/obfuscation/InjectionObfuscationProcessor.java b/src/ap/java/org/spongepowered/tools/obfuscation/InjectionObfuscationProcessor.java new file mode 100644 index 00000000..4994eb3c --- /dev/null +++ b/src/ap/java/org/spongepowered/tools/obfuscation/InjectionObfuscationProcessor.java @@ -0,0 +1,94 @@ +/* + * 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.tools.obfuscation; + +import java.util.Set; + +import javax.annotation.processing.RoundEnvironment; +import javax.annotation.processing.SupportedAnnotationTypes; +import javax.annotation.processing.SupportedOptions; +import javax.annotation.processing.SupportedSourceVersion; +import javax.lang.model.SourceVersion; +import javax.lang.model.element.AnnotationMirror; +import javax.lang.model.element.Element; +import javax.lang.model.element.ElementKind; +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.TypeElement; +import javax.tools.Diagnostic.Kind; + +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.tools.MirrorUtils; + +/** + * Annotation processor which finds {@link Inject} and {@link At} annotations in mixin classes and generates SRG mappings + */ +@SupportedSourceVersion(SourceVersion.RELEASE_6) +@SupportedAnnotationTypes({ "org.spongepowered.asm.mixin.injection.Inject", "org.spongepowered.asm.mixin.injection.At" }) +@SupportedOptions({ "reobfSrgFile", "outSrgFile" }) +public class InjectionObfuscationProcessor extends MixinProcessor { + + /* (non-Javadoc) + * @see javax.annotation.processing.AbstractProcessor#process(java.util.Set, javax.annotation.processing.RoundEnvironment) + */ + @Override + public boolean process(Set annotations, RoundEnvironment roundEnv) { + if (roundEnv.processingOver()) { + return false; + } + + this.processMixins(roundEnv); + this.processInjectors(roundEnv); + + try { + this.mixins.writeRefs(); + } catch (Exception ex) { + ex.printStackTrace(); + } + + return true; + } + + /** + * Searches for {@link Inject} annotations and registers them with their parent mixins + */ + private void processInjectors(RoundEnvironment roundEnv) { + for (Element elem : roundEnv.getElementsAnnotatedWith(Inject.class)) { + Element parent = elem.getEnclosingElement(); + if (!(parent instanceof TypeElement)) { + throw new IllegalStateException("@Shadow element has unexpected parent with type " + MirrorUtils.getElementType(parent)); + } + + AnnotationMirror inject = MirrorUtils.getAnnotation(elem, Inject.class); + + if (elem.getKind() == ElementKind.METHOD) { + this.mixins.registerInjector((TypeElement)parent, (ExecutableElement)elem, inject); + } else { + this.processingEnv.getMessager().printMessage(Kind.WARNING, + "Found an @Inject annotation on an element which is not a method: " + elem.toString()); + } + } + } +} diff --git a/src/ap/java/org/spongepowered/tools/obfuscation/MixinProcessor.java b/src/ap/java/org/spongepowered/tools/obfuscation/MixinProcessor.java new file mode 100644 index 00000000..6085825c --- /dev/null +++ b/src/ap/java/org/spongepowered/tools/obfuscation/MixinProcessor.java @@ -0,0 +1,67 @@ +/* + * 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.tools.obfuscation; + +import javax.annotation.processing.AbstractProcessor; +import javax.annotation.processing.ProcessingEnvironment; +import javax.annotation.processing.RoundEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.ElementKind; +import javax.lang.model.element.TypeElement; +import javax.tools.Diagnostic.Kind; + +import org.spongepowered.asm.mixin.Mixin; + +public abstract class MixinProcessor extends AbstractProcessor { + + /** + * Mixin info manager + */ + protected AnnotatedMixins mixins; + + /* (non-Javadoc) + * @see javax.annotation.processing.AbstractProcessor#init(javax.annotation.processing.ProcessingEnvironment) + */ + @Override + public synchronized void init(ProcessingEnvironment processingEnv) { + super.init(processingEnv); + this.mixins = AnnotatedMixins.getMixinsForEnvironment(processingEnv); + } + + /** + * Searches and catalogues all annotated mixin classes + */ + protected void processMixins(RoundEnvironment roundEnv) { + for (Element elem1 : roundEnv.getElementsAnnotatedWith(Mixin.class)) { + if (elem1.getKind() == ElementKind.CLASS) { + this.mixins.registerMixin((TypeElement)elem1); + } else { + this.processingEnv.getMessager().printMessage(Kind.WARNING, + "Found an @Mixin annotation on an element which is not a class: " + elem1.toString()); + } + } + } + +} diff --git a/src/ap/java/org/spongepowered/tools/obfuscation/TargetObfuscationProcessor.java b/src/ap/java/org/spongepowered/tools/obfuscation/TargetObfuscationProcessor.java new file mode 100644 index 00000000..9b62d37d --- /dev/null +++ b/src/ap/java/org/spongepowered/tools/obfuscation/TargetObfuscationProcessor.java @@ -0,0 +1,117 @@ +/* + * 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.tools.obfuscation; + +import java.util.Set; + +import javax.annotation.processing.RoundEnvironment; +import javax.annotation.processing.SupportedAnnotationTypes; +import javax.annotation.processing.SupportedOptions; +import javax.annotation.processing.SupportedSourceVersion; +import javax.lang.model.SourceVersion; +import javax.lang.model.element.AnnotationMirror; +import javax.lang.model.element.Element; +import javax.lang.model.element.ElementKind; +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.TypeElement; +import javax.lang.model.element.VariableElement; +import javax.tools.Diagnostic.Kind; + +import org.spongepowered.asm.mixin.Overwrite; +import org.spongepowered.asm.mixin.Shadow; +import org.spongepowered.tools.MirrorUtils; + +/** + * Annotation processor which finds {@link Shadow} and {@link Overwrite} annotations in mixin classes and generates SRG mappings + */ +@SupportedSourceVersion(SourceVersion.RELEASE_6) +@SupportedAnnotationTypes({ "org.spongepowered.asm.mixin.Mixin", "org.spongepowered.asm.mixin.Shadow", "org.spongepowered.asm.mixin.Overwrite" }) +@SupportedOptions({ "reobfSrgFile", "outSrgFile" }) +public class TargetObfuscationProcessor extends MixinProcessor { + + /* (non-Javadoc) + * @see javax.annotation.processing.AbstractProcessor#process(java.util.Set, javax.annotation.processing.RoundEnvironment) + */ + @Override + public boolean process(Set annotations, RoundEnvironment roundEnv) { + if (roundEnv.processingOver()) { + return false; + } + + this.processMixins(roundEnv); + this.processShadows(roundEnv); + this.processOverwrites(roundEnv); + + try { + this.mixins.writeSrgs(); + } catch (Exception ex) { + ex.printStackTrace(); + } + + return true; + } + + /** + * Searches for {@link Shadow} annotations and registers them with their parent mixins + */ + private void processShadows(RoundEnvironment roundEnv) { + for (Element elem : roundEnv.getElementsAnnotatedWith(Shadow.class)) { + Element parent = elem.getEnclosingElement(); + if (!(parent instanceof TypeElement)) { + throw new IllegalStateException("@Shadow element has unexpected parent with type " + MirrorUtils.getElementType(parent)); + } + + AnnotationMirror shadow = MirrorUtils.getAnnotation(elem, Shadow.class); + + if (elem.getKind() == ElementKind.FIELD) { + this.mixins.registerShadow((TypeElement)parent, (VariableElement)elem, shadow); + } else if (elem.getKind() == ElementKind.METHOD) { + this.mixins.registerShadow((TypeElement)parent, (ExecutableElement)elem, shadow); + } else { + this.processingEnv.getMessager().printMessage(Kind.WARNING, + "Found an @Shadow annotation on an element which is not a method or field: " + elem.toString()); + } + } + } + + /** + * Searches for {@link Overwrite} annotations and registers them with their parent mixins + */ + private void processOverwrites(RoundEnvironment roundEnv) { + for (Element elem : roundEnv.getElementsAnnotatedWith(Overwrite.class)) { + Element parent = elem.getEnclosingElement(); + if (!(parent instanceof TypeElement)) { + throw new IllegalStateException("@Overwrite element has unexpected parent with type " + MirrorUtils.getElementType(parent)); + } + + if (elem.getKind() == ElementKind.METHOD) { + this.mixins.registerOverwrite((TypeElement)parent, (ExecutableElement)elem); + } else { + this.processingEnv.getMessager().printMessage(Kind.WARNING, + "Found an @Overwrite annotation on an element which is not a method: " + elem.toString()); + } + } + } +} diff --git a/src/ap/resources/META-INF/services/javax.annotation.processing.Processor b/src/ap/resources/META-INF/services/javax.annotation.processing.Processor new file mode 100644 index 00000000..5c54ba68 --- /dev/null +++ b/src/ap/resources/META-INF/services/javax.annotation.processing.Processor @@ -0,0 +1,2 @@ +org.spongepowered.tools.obfuscation.TargetObfuscationProcessor +org.spongepowered.tools.obfuscation.InjectionObfuscationProcessor \ No newline at end of file diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/At.java b/src/main/java/org/spongepowered/asm/mixin/injection/At.java index 60c10dc1..46c5f0b4 100644 --- a/src/main/java/org/spongepowered/asm/mixin/injection/At.java +++ b/src/main/java/org/spongepowered/asm/mixin/injection/At.java @@ -81,7 +81,8 @@ public @interface At { public String[] args() default { }; /** - * Target member used by INVOKE, INVOKE_STRING and FIELD + * Target member used by INVOKE, INVOKE_STRING and FIELD. This must be specified as a fully-qualified member path including the class name + * and signature. Failing to fully-qualify the target member will result in an error at obfuscation time. */ public String target() default ""; diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/InjectionPoint.java b/src/main/java/org/spongepowered/asm/mixin/injection/InjectionPoint.java index 63ec450c..43de439c 100644 --- a/src/main/java/org/spongepowered/asm/mixin/injection/InjectionPoint.java +++ b/src/main/java/org/spongepowered/asm/mixin/injection/InjectionPoint.java @@ -42,6 +42,7 @@ import org.spongepowered.asm.mixin.injection.points.BeforeStringInvoke; import org.spongepowered.asm.mixin.injection.points.JumpInsnPoint; import org.spongepowered.asm.mixin.injection.points.MethodHead; import org.spongepowered.asm.mixin.injection.struct.InjectionPointData; +import org.spongepowered.asm.mixin.transformer.MixinData; import org.spongepowered.asm.util.ASMHelper; import com.google.common.base.Joiner; @@ -262,14 +263,14 @@ public abstract class InjectionPoint { /** * Parse an InjectionPoint from the supplied {@link At} annotation */ - public static InjectionPoint parse(At at) { - return InjectionPoint.parse(at.value(), at.shift(), at.by(), Arrays.asList(at.args()), at.target(), at.ordinal(), at.opcode()); + public static InjectionPoint parse(MixinData mixin, At at) { + return InjectionPoint.parse(mixin, at.value(), at.shift(), at.by(), Arrays.asList(at.args()), at.target(), at.ordinal(), at.opcode()); } /** * Parse an InjectionPoint from the supplied {@link At} annotation supplied as an AnnotationNode instance */ - public static InjectionPoint parse(AnnotationNode node) { + public static InjectionPoint parse(MixinData mixin, AnnotationNode node) { String at = ASMHelper.getAnnotationValue(node, "value"); List args = ASMHelper.>getAnnotationValue(node, "args"); String target = ASMHelper.getAnnotationValue(node, "target", ""); @@ -282,14 +283,14 @@ public abstract class InjectionPoint { args = ImmutableList.of(); } - return InjectionPoint.parse(at, shift, by, args, target, ordinal, opcode); + return InjectionPoint.parse(mixin, at, shift, by, args, target, ordinal, opcode); } /** * Parse and instantiate an InjectionPoint from the supplied information. Returns null if an InjectionPoint could not be created. */ - public static InjectionPoint parse(String at, At.Shift shift, int by, List args, String target, int ordinal, int opcode) { - InjectionPointData data = new InjectionPointData(args, target, ordinal, opcode); + public static InjectionPoint parse(MixinData mixin, String at, At.Shift shift, int by, List args, String target, int ordinal, int opcode) { + InjectionPointData data = new InjectionPointData(mixin, args, target, ordinal, opcode); InjectionPoint point = null; if (BeforeFieldAccess.CODE.equals(at)) { diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/struct/InjectionInfo.java b/src/main/java/org/spongepowered/asm/mixin/injection/struct/InjectionInfo.java index 33d86551..f8f424a9 100644 --- a/src/main/java/org/spongepowered/asm/mixin/injection/struct/InjectionInfo.java +++ b/src/main/java/org/spongepowered/asm/mixin/injection/struct/InjectionInfo.java @@ -38,6 +38,7 @@ import org.spongepowered.asm.mixin.injection.Inject; import org.spongepowered.asm.mixin.injection.InjectionPoint; import org.spongepowered.asm.mixin.injection.InvalidInjectionException; import org.spongepowered.asm.mixin.injection.callback.CallbackInjector; +import org.spongepowered.asm.mixin.transformer.MixinData; import org.spongepowered.asm.util.ASMHelper; @@ -55,7 +56,7 @@ public class InjectionInfo { * Annotated method */ private final MethodNode method; - + /** * Annotated method is static */ @@ -93,17 +94,17 @@ public class InjectionInfo { * @param method Method * @param injectAnnotation Annotation to parse */ - public InjectionInfo(ClassNode classNode, MethodNode method, AnnotationNode injectAnnotation) { + public InjectionInfo(ClassNode classNode, MethodNode method, MixinData mixin, AnnotationNode injectAnnotation) { this.classNode = classNode; this.method = method; this.isStatic = ASMHelper.methodIsStatic(method); - this.parse(injectAnnotation); + this.parse(mixin, injectAnnotation); } /** * Parse the info from the supplied annotation */ - private void parse(AnnotationNode injectAnnotation) { + private void parse(MixinData mixin, AnnotationNode injectAnnotation) { if (injectAnnotation == null) { return; } @@ -118,9 +119,9 @@ public class InjectionInfo { throw new InvalidInjectionException("@Inject annotation on " + this.method.name + " is missing 'at' value(s)"); } - MemberInfo targetMember = MemberInfo.parse(method); + MemberInfo targetMember = MemberInfo.parse(method, mixin); - if (targetMember.owner != null) { + if (targetMember.owner != null && targetMember.owner.equals(mixin.getTargetClassRef())) { throw new InvalidInjectionException("@Inject annotation on " + this.method.name + " specifies a target class '" + targetMember.owner + "', which is not supported"); } @@ -128,14 +129,14 @@ public class InjectionInfo { this.findMethods(targetMember); if (this.targets.size() == 0) { - throw new InvalidInjectionException("@Inject annotation on " + this.method.name + " could not find specified method '" + method + "'"); + throw new InvalidInjectionException("@Inject annotation on " + this.method.name + " could not find '" + targetMember.name + "'"); } this.cancellable = ASMHelper.getAnnotationValue(injectAnnotation, "cancellable", false); this.captureLocals = ASMHelper.getAnnotationValue(injectAnnotation, "captureLocals", false); for (AnnotationNode at : ats) { - InjectionPoint injectionPoint = InjectionPoint.parse(at); + InjectionPoint injectionPoint = InjectionPoint.parse(mixin, at); if (injectionPoint != null) { this.injectionPoints.add(injectionPoint); } diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/struct/InjectionPointData.java b/src/main/java/org/spongepowered/asm/mixin/injection/struct/InjectionPointData.java index e440667f..b855f632 100644 --- a/src/main/java/org/spongepowered/asm/mixin/injection/struct/InjectionPointData.java +++ b/src/main/java/org/spongepowered/asm/mixin/injection/struct/InjectionPointData.java @@ -29,6 +29,7 @@ import java.util.List; import java.util.Map; import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.transformer.MixinData; /** @@ -41,6 +42,11 @@ public class InjectionPointData { */ private final Map args = new HashMap(); + /** + * Mixin + */ + private final MixinData mixin; + /** * Target */ @@ -56,7 +62,8 @@ public class InjectionPointData { */ private final int opcode; - public InjectionPointData(List args, String target, int ordinal, int opcode) { + public InjectionPointData(MixinData mixin, List args, String target, int ordinal, int opcode) { + this.mixin = mixin; this.target = target; this.ordinal = Math.max(-1, ordinal); this.opcode = opcode; @@ -95,7 +102,7 @@ public class InjectionPointData { } public MemberInfo get(String key) { - return MemberInfo.parse(this.get(key, "")); + return MemberInfo.parse(this.get(key, ""), this.mixin); } private int parseInt(String string, int defaultValue) { @@ -115,7 +122,7 @@ public class InjectionPointData { } public MemberInfo getTarget() { - return MemberInfo.parse(this.target); + return MemberInfo.parse(this.target, this.mixin); } public int getOrdinal() { diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/struct/MemberInfo.java b/src/main/java/org/spongepowered/asm/mixin/injection/struct/MemberInfo.java index 257ae3ea..8ae6dfbb 100644 --- a/src/main/java/org/spongepowered/asm/mixin/injection/struct/MemberInfo.java +++ b/src/main/java/org/spongepowered/asm/mixin/injection/struct/MemberInfo.java @@ -24,9 +24,12 @@ */ package org.spongepowered.asm.mixin.injection.struct; +import net.minecraftforge.srg2source.rangeapplier.MethodData; + import org.objectweb.asm.tree.AbstractInsnNode; import org.objectweb.asm.tree.FieldInsnNode; import org.objectweb.asm.tree.MethodInsnNode; +import org.spongepowered.asm.mixin.transformer.MixinData; /** @@ -137,12 +140,69 @@ public class MemberInfo { } } + /** + * Initialise a MemberInfo using the supplied MethodData object + */ + public MemberInfo(MethodData methodData) { + int slashPos = methodData.name.lastIndexOf('/'); + this.owner = methodData.name.substring(0, slashPos); + this.name = methodData.name.substring(slashPos + 1); + this.desc = methodData.sig; + this.matchAll = false; + } + /* (non-Javadoc) * @see java.lang.Object#toString() */ @Override public String toString() { - return String.format("[OWNER=%s,NAME=%s,DESC=%s,ALL=%s]", this.owner, this.name, this.desc, this.matchAll); + String owner = this.owner != null ? "L" + this.owner + ";" : ""; + String name = this.name != null ? this.name : ""; + String qualifier = this.matchAll ? "*" : ""; + String desc = this.desc != null ? this.desc : ""; + String separator = desc.startsWith("(") ? "" : (this.desc != null ? ":" : ""); + return owner + name + qualifier + separator + desc; + } + + /** + * Return this MemberInfo as an SRG mapping + */ + public String toSrg() { + if (!this.isFullyQualified()) { + throw new RuntimeException("Cannot convert unqalified reference to SRG mapping"); + } + + if (this.desc.startsWith("(")) { + return this.owner + "/" + this.name + " " + this.desc; + } + + return this.owner + "/" + this.name; + } + + public MethodData asMethodData() { + if (!this.isFullyQualified()) { + throw new RuntimeException("Cannot convert unqalified reference to MethodData"); + } + + if (this.isField()) { + throw new RuntimeException("Cannot convert a non-method reference to MethodData"); + } + + return new MethodData(this.owner + "/" + this.name, this.desc); + } + + /** + * Get whether this reference is fully qualified + */ + public boolean isFullyQualified() { + return this.owner != null && this.name != null && this.desc != null; + } + + /** + * Get whether this MemberInfo is definitely a field, the output of this method is undefined if {@link #isFullyQualified} returns false + */ + public boolean isField() { + return this.desc != null && !this.desc.startsWith("("); } /** @@ -188,9 +248,36 @@ public class MemberInfo { * Parse a MemberInfo from a string */ public static MemberInfo parse(String name) { + return MemberInfo.parse(name, null, null); + } + + /** + * Parse a MemberInfo from a string + */ + public static MemberInfo parse(String name, MixinData mixin) { + return MemberInfo.parse(name, mixin.getReferenceMapper(), mixin.getClassRef()); + } + + /** + * Parse a MemberInfo from a string + */ + public static MemberInfo parse(String name, ReferenceMapper refMapper, String mixinClass) { String desc = null; String owner = null; + String n = name; + if (refMapper != null) { + name = refMapper.remap(mixinClass, name); + } + + System.err.println("=============================================================================="); + System.err.println("=============================================================================="); + System.err.println("=============================================================================="); + System.err.println("Remapped [" + n + "] to [" + name + "] for " + mixinClass); + System.err.println("=============================================================================="); + System.err.println("=============================================================================="); + System.err.println("=============================================================================="); + int lastDotPos = name.lastIndexOf('.'); int semiColonPos = name.indexOf(';'); if (lastDotPos > -1) { @@ -207,7 +294,7 @@ public class MemberInfo { desc = name.substring(parenPos); name = name.substring(0, parenPos); } else if (colonPos > -1) { - desc = name.substring(colonPos); + desc = name.substring(colonPos + 1); name = name.substring(0, colonPos); } @@ -222,4 +309,15 @@ public class MemberInfo { return new MemberInfo(name, owner, desc, matchAll); } + + public static MemberInfo fromSrgField(String srgName, String desc) { + int slashPos = srgName.lastIndexOf('/'); + String owner = srgName.substring(0, slashPos); + String name = srgName.substring(slashPos + 1); + return new MemberInfo(name, owner, desc, false); + } + + public static MemberInfo fromSrgMethod(MethodData methodData) { + return new MemberInfo(methodData); + } } diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/struct/ReferenceMapper.java b/src/main/java/org/spongepowered/asm/mixin/injection/struct/ReferenceMapper.java new file mode 100644 index 00000000..b579c178 --- /dev/null +++ b/src/main/java/org/spongepowered/asm/mixin/injection/struct/ReferenceMapper.java @@ -0,0 +1,103 @@ +/* + * 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.injection.struct; + +import java.io.IOException; +import java.io.InputStreamReader; +import java.io.Reader; +import java.io.Serializable; +import java.util.HashMap; +import java.util.Map; + +import com.google.gson.Gson; +import com.google.gson.GsonBuilder; + +public final class ReferenceMapper implements Serializable { + + private static final long serialVersionUID = 1L; + + public static final String DEFAULT_RESOURCE = "mixin.refmap.json"; + + private final Map> mappings; + + public ReferenceMapper() { + this(new HashMap>()); + } + + public ReferenceMapper(Map> mappings) { + this.mappings = mappings; + } + + public String remap(String className, String reference) { + if (className == null) { + for (Map mappings : this.mappings.values()) { + if (mappings.containsKey(reference)) { + return mappings.get(reference); + } + } + } + + Map classMappings = this.mappings.get(className); + if (classMappings == null) { + return reference; + } + return classMappings.get(reference); + } + + public void addMapping(String className, String reference, String newReference) { + Map classMappings = this.mappings.get(className); + if (classMappings == null) { + classMappings = new HashMap(); + this.mappings.put(className, classMappings); + } + classMappings.put(reference, newReference); + } + + public void write(Appendable writer) { + new GsonBuilder().setPrettyPrinting().create().toJson(this, writer); + } + + public static ReferenceMapper read(String resource) { + Reader reader = null; + try { + reader = new InputStreamReader(ReferenceMapper.class.getResourceAsStream("/" + resource)); + return ReferenceMapper.read(reader); + } catch (Exception ex) { + return new ReferenceMapper(); + } finally { + if (reader != null) { + try { + reader.close(); + } catch (IOException ex) { + // don't really care + } + } + } + } + + public static ReferenceMapper read(Reader reader) { + return new Gson().fromJson(reader, ReferenceMapper.class); + } +} diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinConfig.java b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinConfig.java index 9b755821..f0c7b9b3 100644 --- a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinConfig.java +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinConfig.java @@ -30,6 +30,8 @@ import java.util.HashMap; import java.util.List; import java.util.Map; +import org.spongepowered.asm.mixin.injection.struct.ReferenceMapper; + import com.google.gson.Gson; import com.google.gson.annotations.SerializedName; @@ -62,6 +64,17 @@ class MixinConfig { @SerializedName("setSourceFile") private boolean setSourceFile = false; + /** + * True to set the sourceFile property when applying mixins + */ + @SerializedName("referenceMap") + private String refMapperConfig; + + /** + * Reference mapper for injectors + */ + private transient ReferenceMapper refMapper; + /** * Keep track of initialisation state */ @@ -98,6 +111,12 @@ class MixinConfig { ex.printStackTrace(); } } + + if (this.refMapperConfig == null) { + this.refMapperConfig = ReferenceMapper.DEFAULT_RESOURCE; + } + + this.refMapper = ReferenceMapper.read(this.refMapperConfig); } /** @@ -121,6 +140,13 @@ class MixinConfig { return this.setSourceFile; } + /** + * Get the reference remapper for injectors + */ + public ReferenceMapper getReferenceMapper() { + return this.refMapper; + } + /** * Check whether this configuration bundle has a mixin for the specified class * diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinData.java b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinData.java index eba90a39..206a8220 100644 --- a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinData.java +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinData.java @@ -39,7 +39,9 @@ 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.InvalidMixinException; import org.spongepowered.asm.mixin.Shadow; +import org.spongepowered.asm.mixin.injection.struct.ReferenceMapper; import org.spongepowered.asm.util.ASMHelper; @@ -91,6 +93,31 @@ public class MixinData { public ClassNode getClassNode() { return this.classNode; } + + /** + * Get the mixin class name + */ + public String getClassName() { + return this.info.getClassName(); + } + + /** + * Get the internal mixin class name + */ + public String getClassRef() { + return this.info.getClassRef(); + } + + /** + * Get the target class reference + */ + public String getTargetClassRef() { + List targetClasses = this.info.getTargetClasses(); + if (targetClasses.size() != 1) { + throw new InvalidMixinException("Multiple targets found for " + this.getClassName() + " but exactly one is required"); + } + return targetClasses.get(0); + } /** * Get all interfaces for this mixin @@ -105,6 +132,13 @@ public class MixinData { public boolean shouldSetSourceFile() { return this.info.getParent().shouldSetSourceFile(); } + + /** + * Get the reference mapper for this mixin + */ + public ReferenceMapper getReferenceMapper() { + return this.info.getParent().getReferenceMapper(); + } /** * Prepare the mixin, applies any pre-processing transformations diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTransformer.java b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTransformer.java index d82f9578..99456acf 100644 --- a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTransformer.java +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTransformer.java @@ -390,7 +390,7 @@ public class MixinTransformer extends TreeTransformer { continue; } - InjectionInfo injectInfo = new InjectionInfo(targetClass, method, injectAnnotation); + InjectionInfo injectInfo = new InjectionInfo(targetClass, method, mixin, injectAnnotation); if (injectInfo.isValid()) { injectInfo.inject(); }