diff --git a/gradle.properties b/gradle.properties index 57019429..7dbd839d 100644 --- a/gradle.properties +++ b/gradle.properties @@ -4,5 +4,5 @@ packaging=jar description=Mixin url=https://www.spongepowered.org organization=SpongePowered -buildVersion=0.6.14 +buildVersion=0.7 buildType=SNAPSHOT diff --git a/src/main/java/org/spongepowered/asm/launch/MixinBootstrap.java b/src/main/java/org/spongepowered/asm/launch/MixinBootstrap.java index aafa5569..6476f1e9 100644 --- a/src/main/java/org/spongepowered/asm/launch/MixinBootstrap.java +++ b/src/main/java/org/spongepowered/asm/launch/MixinBootstrap.java @@ -62,7 +62,7 @@ public abstract class MixinBootstrap { /** * Subsystem version */ - public static final String VERSION = "0.6.14"; + public static final String VERSION = "0.7"; // Consts private static final String LAUNCH_PACKAGE = "org.spongepowered.asm.launch."; diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/invoke/arg/ArgsClassGenerator.java b/src/main/java/org/spongepowered/asm/mixin/injection/invoke/arg/ArgsClassGenerator.java index d6d36ee2..982a6e54 100644 --- a/src/main/java/org/spongepowered/asm/mixin/injection/invoke/arg/ArgsClassGenerator.java +++ b/src/main/java/org/spongepowered/asm/mixin/injection/invoke/arg/ArgsClassGenerator.java @@ -59,7 +59,7 @@ public final class ArgsClassGenerator implements IClassGenerator { public static final String GETTER_PREFIX = "$"; - private static final String CLASS_NAME_BASE = "org.spongepowered.asm.synthetic.Args$"; + private static final String CLASS_NAME_BASE = Constants.SYNTHETIC_PACKAGE + ".args.Args$"; private static final String OBJECT = "java/lang/Object"; private static final String OBJECT_ARRAY = "[L" + ArgsClassGenerator.OBJECT + ";"; diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/ClassInfo.java b/src/main/java/org/spongepowered/asm/mixin/transformer/ClassInfo.java index 25ab852f..3050e950 100644 --- a/src/main/java/org/spongepowered/asm/mixin/transformer/ClassInfo.java +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/ClassInfo.java @@ -245,6 +245,12 @@ public final class ClassInfo extends TreeInfo { */ private String currentName; + /** + * Current descriptor of the member, may be different from + * {@link #memberDesc} if the member has been remapped + */ + private String currentDesc; + /** * True if this member is decorated with {@link Final} */ @@ -263,6 +269,7 @@ public final class ClassInfo extends TreeInfo { protected Member(Member member) { this(member.type, member.memberName, member.memberDesc, member.modifiers, member.isInjected); this.currentName = member.currentName; + this.currentDesc = member.currentDesc; this.unique = member.unique; } @@ -276,6 +283,7 @@ public final class ClassInfo extends TreeInfo { this.memberDesc = desc; this.isInjected = injected; this.currentName = name; + this.currentDesc = desc; this.modifiers = access; } @@ -287,18 +295,26 @@ public final class ClassInfo extends TreeInfo { return this.currentName; } - public String getDesc() { + public String getOriginalDesc() { return this.memberDesc; } + public String getDesc() { + return this.currentDesc; + } + public boolean isInjected() { return this.isInjected; } public boolean isRenamed() { - return this.currentName != this.memberName; + return !this.currentName.equals(this.memberName); } + public boolean isRemapped() { + return !this.currentDesc.equals(this.memberDesc); + } + public boolean isPrivate() { return (this.modifiers & Opcodes.ACC_PRIVATE) != 0; } @@ -364,11 +380,15 @@ public final class ClassInfo extends TreeInfo { this.currentName = name; return name; } + + public String remapTo(String desc) { + this.currentDesc = desc; + return desc; + } public boolean equals(String name, String desc) { - return (this.memberName.equals(name) - || this.currentName.equals(name)) - && this.memberDesc.equals(desc); + return (this.memberName.equals(name) || this.currentName.equals(name)) + && (this.memberDesc.equals(desc) || this.currentDesc.equals(desc)); } @Override @@ -378,9 +398,8 @@ public final class ClassInfo extends TreeInfo { } Member other = (Member)obj; - return (other.memberName.equals(this.memberName) - || other.currentName.equals(this.currentName)) - && other.memberDesc.equals(this.memberDesc); + return (other.memberName.equals(this.memberName) || other.currentName.equals(this.currentName)) + && (other.memberDesc.equals(this.memberDesc) || other.currentDesc.equals(this.currentDesc)); } @Override @@ -396,6 +415,7 @@ public final class ClassInfo extends TreeInfo { protected String getDisplayFormat() { return "%s%s"; } + } /** @@ -709,20 +729,20 @@ public final class ClassInfo extends TreeInfo { boolean isProbablyStatic = true; String outerName = classNode.outerClass; - if (outerName == null) { - for (FieldNode field : classNode.fields) { - if ((field.access & Opcodes.ACC_SYNTHETIC) != 0) { - if (field.name.startsWith("this$")) { - isProbablyStatic = false; + for (FieldNode field : classNode.fields) { + if ((field.access & Opcodes.ACC_SYNTHETIC) != 0) { + if (field.name.startsWith("this$")) { + isProbablyStatic = false; + if (outerName == null) { outerName = field.desc; - if (outerName.startsWith("L")) { + if (outerName != null && outerName.startsWith("L")) { outerName = outerName.substring(1, outerName.length() - 1); } } } - - this.fields.add(new Field(field, this.isMixin)); } + + this.fields.add(new Field(field, this.isMixin)); } this.isProbablyStatic = isProbablyStatic; diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/InnerClassGenerator.java b/src/main/java/org/spongepowered/asm/mixin/transformer/InnerClassGenerator.java new file mode 100644 index 00000000..6c5f9f8a --- /dev/null +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/InnerClassGenerator.java @@ -0,0 +1,311 @@ +/* + * This file is part of Mixin, licensed under the MIT License (MIT). + * + * Copyright (c) SpongePowered + * 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.HashMap; +import java.util.Map; +import java.util.UUID; + +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import org.spongepowered.asm.lib.AnnotationVisitor; +import org.spongepowered.asm.lib.ClassReader; +import org.spongepowered.asm.lib.ClassVisitor; +import org.spongepowered.asm.lib.ClassWriter; +import org.spongepowered.asm.lib.Opcodes; +import org.spongepowered.asm.lib.commons.Remapper; +import org.spongepowered.asm.lib.commons.RemappingClassAdapter; +import org.spongepowered.asm.mixin.transformer.ClassInfo.Method; +import org.spongepowered.asm.mixin.transformer.throwables.InvalidMixinException; + +/** + * Class generator which creates unique copies of inner classes within mixins + * which are specialised to the target class. + */ +final class InnerClassGenerator implements IClassGenerator { + + /** + * Information about an inner class instance. Implements {@link Remapper} so + * that it can participate in the remapping process. + */ + static class InnerClassInfo extends Remapper { + + /** + * Generated class name + */ + private final String name; + + /** + * Original class name + */ + private final String originalName; + + /** + * Mixin which owns this inner class + */ + private final MixinInfo owner; + + /** + * Mixin target context + */ + private final MixinTargetContext target; + + /** + * Name of the owner mixin (class ref) + */ + private final String ownerName; + + /** + * Name of the target class (class ref) + */ + private final String targetName; + + InnerClassInfo(String name, String originalName, MixinInfo owner, MixinTargetContext target) { + this.name = name; + this.originalName = originalName; + this.owner = owner; + this.ownerName = owner.getClassRef(); + this.target = target; + this.targetName = target.getTargetClassRef(); + } + + String getName() { + return this.name; + } + + String getOriginalName() { + return this.originalName; + } + + MixinInfo getOwner() { + return this.owner; + } + + MixinTargetContext getTarget() { + return this.target; + } + + String getOwnerName() { + return this.ownerName; + } + + String getTargetName() { + return this.targetName; + } + + byte[] getClassBytes() throws ClassNotFoundException, IOException { + return TreeInfo.loadClass(this.originalName, true); + } + + /** + * Used to remap synthetic accessor methods which have been renamed when + * being applied to the target class. + */ + @Override + public String mapMethodName(String owner, String name, String desc) { + if (this.ownerName.equalsIgnoreCase(owner)) { + Method method = this.owner.getClassInfo().findMethod(name, desc, ClassInfo.INCLUDE_ALL); + if (method != null) { + return method.getName(); + } + } + return super.mapMethodName(owner, name, desc); + } + + /* (non-Javadoc) + * @see org.spongepowered.asm.lib.commons.Remapper#map(java.lang.String) + */ + @Override + public String map(String key) { + if (this.originalName.equals(key)) { + return this.name; + } else if (this.ownerName.equals(key)) { + return this.targetName; + } + return key; + } + + /* (non-Javadoc) + * @see java.lang.Object#toString() + */ + @Override + public String toString() { + return this.name; + } + + } + + /** + * Just a basic remapping adapter, but we also decorate the transformed + * class with a meta annotation describing the original class. + */ + static class InnerClassAdapter extends RemappingClassAdapter { + + private final InnerClassInfo info; + + public InnerClassAdapter(ClassVisitor cv, InnerClassInfo info) { + super(Opcodes.ASM5, cv, info); + this.info = info; + } + + /* (non-Javadoc) + * @see org.spongepowered.asm.lib.ClassVisitor + * #visitSource(java.lang.String, java.lang.String) + */ + @Override + public void visitSource(String source, String debug) { + super.visitSource(source, debug); + AnnotationVisitor av = this.cv.visitAnnotation("Lorg/spongepowered/asm/mixin/transformer/meta/MixinInner;", false); + av.visit("mixin", this.info.getOwner().toString()); + av.visit("name", this.info.getOriginalName().substring(this.info.getOriginalName().lastIndexOf('/') + 1)); + av.visitEnd(); + } + + /* (non-Javadoc) + * @see org.spongepowered.asm.lib.commons.RemappingClassAdapter + * #visitInnerClass(java.lang.String, java.lang.String, + * java.lang.String, int) + */ + @Override + public void visitInnerClass(String name, String outerName, String innerName, int access) { + if (name.startsWith(this.info.getOriginalName() + "$")) { + throw new InvalidMixinException(this.info.getOwner(), "Found unsupported nested inner class " + name + " in " + + this.info.getOriginalName()); + } + + super.visitInnerClass(name, outerName, innerName, access); + } + + } + + /** + * Logger + */ + private static final Logger logger = LogManager.getLogger("mixin"); + + /** + * Singleton instance (for now) + */ + private static InnerClassGenerator instance; + + /** + * Mapping of target class context ids to generated inner class names, used + * so we don't accidentally conform the same class twice. + */ + private final Map innerClassNames = new HashMap(); + + /** + * Mapping of generated class names to the respective inner class info + */ + private final Map innerClasses = new HashMap(); + + private InnerClassGenerator() { + // private, use factory + } + + /** + * @param owner Mixin which owns the original inner class + * @param originalName Original inner class name + * @param context Target class + * @return new name + */ + public String registerInnerClass(MixinInfo owner, String originalName, MixinTargetContext context) { + String id = String.format("%s%s", originalName, context); + String ref = this.innerClassNames.get(id); + if (ref == null) { + ref = InnerClassGenerator.getUniqueReference(originalName, context); + this.innerClassNames.put(id, ref); + this.innerClasses.put(ref, new InnerClassInfo(ref, originalName, owner, context)); + InnerClassGenerator.logger.debug("Inner class {} in {} on {} gets unique name {}", originalName, owner.getClassRef(), + context.getTargetClassRef(), ref); + } + return ref; + } + + /* (non-Javadoc) + * @see org.spongepowered.asm.mixin.transformer.IClassGenerator + * #generate(java.lang.String) + */ + @Override + public byte[] generate(String name) { + String ref = name.replace('.', '/'); + InnerClassInfo info = this.innerClasses.get(ref); + if (info != null) { + return this.generate(info); + } + return null; + } + + /** + * Generates a specialised inner class by taking the original class bytecode + * and remapping it against the target class. + * + * @param info inner class info to process + * @return generated class or null if generation failed + */ + private byte[] generate(InnerClassInfo info) { + try { + InnerClassGenerator.logger.debug("Generating mapped inner class {} (originally {})", info.getName(), info.getOriginalName()); + ClassReader cr = new ClassReader(info.getClassBytes()); + ClassWriter cw = new MixinClassWriter(cr, 0); + cr.accept(new InnerClassAdapter(cw, info), ClassReader.EXPAND_FRAMES); + return cw.toByteArray(); + } catch (InvalidMixinException ex) { + throw ex; + } catch (Exception ex) { + InnerClassGenerator.logger.catching(ex); + } + + return null; + } + + /** + * To avoid accidental clashes with existing target classes, or classes from + * multiple mixins, each remapped class gets a unique name. + * + * @param originalName Original inner class name + * @param context Target context + * @return unique class name + */ + private static String getUniqueReference(String originalName, MixinTargetContext context) { + String name = originalName.substring(originalName.lastIndexOf('$') + 1); + if (name.matches("^[0-9]+$")) { + name = "Anonymous"; + } + return String.format("%s$%s$%s", context.getTargetClassRef(), name, UUID.randomUUID().toString().replace("-", "")); + } + + /** + * Get the singleton instance + */ + public static InnerClassGenerator getInstance() { + if (InnerClassGenerator.instance == null) { + InnerClassGenerator.instance = new InnerClassGenerator(); + } + return InnerClassGenerator.instance; + } + +} diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinInfo.java b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinInfo.java index 88b333ca..eb33cccc 100644 --- a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinInfo.java +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinInfo.java @@ -64,6 +64,7 @@ import org.spongepowered.asm.mixin.transformer.throwables.InvalidMixinException; import org.spongepowered.asm.mixin.transformer.throwables.MixinReloadException; import org.spongepowered.asm.mixin.transformer.throwables.MixinTargetAlreadyLoadedException; import org.spongepowered.asm.util.Annotations; +import org.spongepowered.asm.util.Bytecode; import org.spongepowered.asm.util.launchwrapper.LaunchClassLoaderUtil; import com.google.common.base.Function; @@ -106,6 +107,10 @@ class MixinInfo extends TreeInfo implements Comparable, IMixinInfo { return this.getVisibleAnnotation(Surrogate.class) != null; } + public boolean isSynthetic() { + return Bytecode.hasFlag(this, Opcodes.ACC_SYNTHETIC); + } + public AnnotationNode getVisibleAnnotation(Class annotationClass) { return Annotations.getVisible(this, annotationClass); } @@ -191,6 +196,11 @@ class MixinInfo extends TreeInfo implements Comparable, IMixinInfo { * Synthetic inner classes */ protected final Set syntheticInnerClasses = new HashSet(); + + /** + * Non-synthetic inner classes + */ + protected final Set innerClasses = new HashSet(); /** * Initial ClassNode created for mixin validation, not used for actual @@ -243,6 +253,10 @@ class MixinInfo extends TreeInfo implements Comparable, IMixinInfo { Set getSyntheticInnerClasses() { return this.syntheticInnerClasses; } + + Set getInnerClasses() { + return this.innerClasses; + } Set getInterfaces() { return this.interfaces; @@ -325,7 +339,7 @@ class MixinInfo extends TreeInfo implements Comparable, IMixinInfo { this.validateRemappable(Shadow.class, method.name, Annotations.getVisible(method, Shadow.class)); AnnotationNode overwrite = Annotations.getVisible(method, Overwrite.class); if (overwrite != null && ((method.access & Opcodes.ACC_STATIC) == 0 || (method.access & Opcodes.ACC_PUBLIC) == 0)) { - throw new InvalidMixinException(MixinInfo.this, "Found @Overwrite annotation on " + method.name + " in " + this); + throw new InvalidMixinException(MixinInfo.this, "Found @Overwrite annotation on " + method.name + " in " + MixinInfo.this); } } } @@ -374,12 +388,12 @@ class MixinInfo extends TreeInfo implements Comparable, IMixinInfo { void readInnerClasses() { for (InnerClassNode inner : this.classNode.innerClasses) { ClassInfo innerClass = ClassInfo.forName(inner.name); - if (innerClass.isSynthetic() && innerClass.isProbablyStatic()) { - if ((inner.outerName != null && inner.outerName.equals(this.classInfo.getName())) - || inner.name.startsWith(this.classNode.name + "$")) { + if ((inner.outerName != null && inner.outerName.equals(this.classInfo.getName())) + || inner.name.startsWith(this.classNode.name + "$")) { + if (innerClass.isProbablyStatic() && innerClass.isSynthetic()) { this.syntheticInnerClasses.add(inner.name); } else { - throw new InvalidMixinException(MixinInfo.this, "Unhandled synthetic inner class found: " + inner.name); + this.innerClasses.add(inner.name); } } } @@ -1076,6 +1090,13 @@ class MixinInfo extends TreeInfo implements Comparable, IMixinInfo { return Collections.unmodifiableSet(this.getState().getSyntheticInnerClasses()); } + /** + * Get the user-defined inner classes for this mixin + */ + Set getInnerClasses() { + return Collections.unmodifiableSet(this.getState().getInnerClasses()); + } + /** * Get the target class list for this mixin */ diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinPostProcessor.java b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinPostProcessor.java index fb1a546a..c7e62d8f 100644 --- a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinPostProcessor.java +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinPostProcessor.java @@ -30,11 +30,14 @@ import java.util.Iterator; import java.util.Map; import java.util.Set; +import org.spongepowered.asm.lib.ClassReader; +import org.spongepowered.asm.lib.ClassVisitor; +import org.spongepowered.asm.lib.ClassWriter; +import org.spongepowered.asm.lib.FieldVisitor; +import org.spongepowered.asm.lib.MethodVisitor; import org.spongepowered.asm.lib.Opcodes; import org.spongepowered.asm.lib.Type; import org.spongepowered.asm.lib.tree.AnnotationNode; -import org.spongepowered.asm.lib.tree.ClassNode; -import org.spongepowered.asm.lib.tree.FieldNode; import org.spongepowered.asm.lib.tree.InsnNode; import org.spongepowered.asm.lib.tree.MethodInsnNode; import org.spongepowered.asm.lib.tree.MethodNode; @@ -50,7 +53,9 @@ import org.spongepowered.asm.transformers.TreeTransformer; import org.spongepowered.asm.util.Bytecode; /** - * TODO Description for MixinPostProcessor + * Performs post-processing tasks required for certain classes which pass + * through the mixin transformer, such as transforming synthetic inner classes + * and populating accessor methods in accessor mixins. */ class MixinPostProcessor extends TreeTransformer implements MixinConfig.IListener { @@ -138,26 +143,37 @@ class MixinPostProcessor extends TreeTransformer implements MixinConfig.IListene * new home in the target class */ private byte[] processSyntheticInner(byte[] bytes) { - ClassNode classNode = this.readClass(bytes, true); + ClassReader cr = new ClassReader(bytes); + ClassWriter cw = new MixinClassWriter(cr, 0); - // Make the class public - classNode.access |= Opcodes.ACC_PUBLIC; - - // Make package-private fields public - for (FieldNode field : classNode.fields) { - if ((field.access & (Opcodes.ACC_PRIVATE | Opcodes.ACC_PROTECTED)) == 0) { - field.access |= Opcodes.ACC_PUBLIC; + ClassVisitor visibilityVisitor = new ClassVisitor(Opcodes.ASM5, cw) { + + @Override + public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) { + super.visit(version, access | Opcodes.ACC_PUBLIC, name, signature, superName, interfaces); } - } - - // Make package-private methods public - for (MethodNode method : classNode.methods) { - if ((method.access & (Opcodes.ACC_PRIVATE | Opcodes.ACC_PROTECTED)) == 0) { - method.access |= Opcodes.ACC_PUBLIC; + + + @Override + public FieldVisitor visitField(int access, String name, String desc, String signature, Object value) { + if ((access & (Opcodes.ACC_PRIVATE | Opcodes.ACC_PROTECTED)) == 0) { + access |= Opcodes.ACC_PUBLIC; + } + return super.visitField(access, name, desc, signature, value); } - } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { + if ((access & (Opcodes.ACC_PRIVATE | Opcodes.ACC_PROTECTED)) == 0) { + access |= Opcodes.ACC_PUBLIC; + } + return super.visitMethod(access, name, desc, signature, exceptions); + } + + }; - return this.writeClass(classNode); + cr.accept(visibilityVisitor, ClassReader.EXPAND_FRAMES); + return cw.toByteArray(); } private byte[] processAccessor(byte[] bytes, MixinInfo mixin) { diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinPreProcessorStandard.java b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinPreProcessorStandard.java index a2c76ce0..7c4098c3 100644 --- a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinPreProcessorStandard.java +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinPreProcessorStandard.java @@ -405,6 +405,11 @@ class MixinPreProcessorStandard { return false; } + if (method.isSynthetic()) { + context.transformDescriptor(mixinMethod); + method.remapTo(mixinMethod.desc); + } + MethodNode target = context.findMethod(mixinMethod, null); if (target == null) { return false; @@ -412,7 +417,7 @@ class MixinPreProcessorStandard { String type = method.isUnique() ? "@Unique" : "synthetic"; - if ((mixinMethod.access & (Opcodes.ACC_PRIVATE | Opcodes.ACC_PROTECTED)) != 0) { + if (Bytecode.getVisibility(mixinMethod).ordinal() < Visibility.PUBLIC.ordinal()) { String uniqueName = context.getUniqueName(mixinMethod, false); MixinPreProcessorStandard.logger.log(this.mixin.getLoggingLevel(), "Renaming {} method {}{} to {} in {}", type, mixinMethod.name, mixinMethod.desc, uniqueName, this.mixin); @@ -458,10 +463,11 @@ class MixinPreProcessorStandard { iter.remove(); continue; } - - context.transformDescriptor(mixinField); - + Field field = this.mixin.getClassInfo().findField(mixinField); + context.transformDescriptor(mixinField); + field.remapTo(mixinField.desc); + if (field.isUnique() && isShadow) { throw new InvalidMixinException(this.mixin, "@Shadow field " + mixinField.name + " cannot be @Unique"); } diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTargetContext.java b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTargetContext.java index 717c0958..2d5394a0 100644 --- a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTargetContext.java +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTargetContext.java @@ -63,6 +63,9 @@ import org.spongepowered.asm.util.Bytecode; import org.spongepowered.asm.util.ClassSignature; import org.spongepowered.asm.util.Constants; +import com.google.common.collect.BiMap; +import com.google.common.collect.HashBiMap; + /** * This object keeps track of data for applying a mixin to a specific target * class during a mixin application. This is a single-use object which @@ -102,6 +105,11 @@ public class MixinTargetContext extends ClassContext implements IMixinContext { * Target ClassInfo */ private final ClassInfo targetClassInfo; + + /** + * + */ + private final BiMap innerClasses = HashBiMap.create(); /** * Shadow method list @@ -171,6 +179,11 @@ public class MixinTargetContext extends ClassContext implements IMixinContext { this.detachedSuper = !this.classNode.superName.equals(this.getTarget().getClassNode().superName); this.sessionId = context.getSessionId(); this.requireVersion(classNode.version); + + InnerClassGenerator icg = InnerClassGenerator.getInstance(); + for (String innerClass : this.mixin.getInnerClasses()) { + this.innerClasses.put(innerClass, icg.registerInnerClass(this.mixin, innerClass, this)); + } } /** @@ -396,7 +409,7 @@ public class MixinTargetContext extends ClassContext implements IMixinContext { return type; } - + /** * Handles "re-parenting" the method supplied, changes all references to the * mixin class to refer to the target class (for field accesses and method @@ -408,6 +421,7 @@ public class MixinTargetContext extends ClassContext implements IMixinContext { public void transformMethod(MethodNode method) { this.validateMethod(method); this.transformDescriptor(method); + this.transformLVT(method); // Offset line numbers per the stratum this.stratum.applyOffset(method); @@ -451,6 +465,25 @@ public class MixinTargetContext extends ClassContext implements IMixinContext { } } + /** + * Transform the Local Variable Table (LVT) for the specified mixin method. + * + * @param method Method node to transform + */ + private void transformLVT(MethodNode method) { + if (method.localVariables == null) { + return; + } + + for (LocalVariableNode local : method.localVariables) { + if (local == null || local.desc == null) { + continue; + } + + local.desc = this.transformSingleDescriptor(Type.getType(local.desc)); + } + } + /** * Transforms a method invocation/reference in the method. Updates static * and dynamic bindings. @@ -469,6 +502,9 @@ public class MixinTargetContext extends ClassContext implements IMixinContext { methodRef.setName(md.getName()); } this.upgradeMethodRef(method, methodRef, md); + } else if (this.innerClasses.containsKey(methodRef.getOwner())) { + methodRef.setOwner(this.innerClasses.get(methodRef.getOwner())); + methodRef.setDesc(this.transformMethodDescriptor(methodRef.getDesc())); } else if (this.detachedSuper || this.inheritsFromMixin) { if (methodRef.getOpcode() == Opcodes.INVOKESPECIAL) { this.updateStaticBinding(method, methodRef); @@ -576,6 +612,11 @@ public class MixinTargetContext extends ClassContext implements IMixinContext { if (typeInsn.desc.equals(this.getClassRef())) { typeInsn.desc = this.getTarget().getClassRef(); + } else { + String newName = this.innerClasses.get(typeInsn.desc); + if (newName != null) { + typeInsn.desc = newName; + } } this.transformDescriptor(typeInsn); @@ -745,7 +786,7 @@ public class MixinTargetContext extends ClassContext implements IMixinContext { * @param field Field node to transform */ public void transformDescriptor(FieldNode field) { - if (!this.inheritsFromMixin) { + if (!this.inheritsFromMixin && this.innerClasses.size() == 0) { return; } field.desc = this.transformSingleDescriptor(field.desc, false); @@ -757,7 +798,7 @@ public class MixinTargetContext extends ClassContext implements IMixinContext { * @param method Method node to transform */ public void transformDescriptor(MethodNode method) { - if (!this.inheritsFromMixin) { + if (!this.inheritsFromMixin && this.innerClasses.size() == 0) { return; } method.desc = this.transformMethodDescriptor(method.desc); @@ -770,7 +811,7 @@ public class MixinTargetContext extends ClassContext implements IMixinContext { * @param member Reference to the method or field */ public void transformDescriptor(MemberRef member) { - if (!this.inheritsFromMixin) { + if (!this.inheritsFromMixin && this.innerClasses.size() == 0) { return; } if (member.isField()) { @@ -786,7 +827,7 @@ public class MixinTargetContext extends ClassContext implements IMixinContext { * @param typeInsn Type instruction node to transform */ public void transformDescriptor(TypeInsnNode typeInsn) { - if (!this.inheritsFromMixin) { + if (!this.inheritsFromMixin && this.innerClasses.size() == 0) { return; } typeInsn.desc = this.transformSingleDescriptor(typeInsn.desc, true); @@ -822,6 +863,15 @@ public class MixinTargetContext extends ClassContext implements IMixinContext { return desc; } + String innerClassName = this.innerClasses.get(type); + if (innerClassName != null) { + return desc.replace(type, innerClassName); + } + + if (this.innerClasses.inverse().containsKey(type)) { + return desc; + } + ClassInfo typeInfo = ClassInfo.forName(type); if (!typeInfo.isMixin()) { 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 361efb0b..a521aec1 100644 --- a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTransformer.java +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTransformer.java @@ -477,6 +477,7 @@ public class MixinTransformer extends TreeTransformer { this.postProcessor = new MixinPostProcessor(); this.generators.add(ArgsClassGenerator.getInstance()); + this.generators.add(InnerClassGenerator.getInstance()); } private IHotSwap initHotSwapper() { diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/TreeInfo.java b/src/main/java/org/spongepowered/asm/mixin/transformer/TreeInfo.java index 0cc92f71..d8e69c04 100644 --- a/src/main/java/org/spongepowered/asm/mixin/transformer/TreeInfo.java +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/TreeInfo.java @@ -67,7 +67,7 @@ abstract class TreeInfo { * @param flags ClassReader flags * @return ASM Tree view of the specified class */ - protected static ClassNode getClassNode(byte[] classBytes, int flags) { + static ClassNode getClassNode(byte[] classBytes, int flags) { ClassNode classNode = new ClassNode(); ClassReader classReader = new ClassReader(classBytes); classReader.accept(classNode, flags); @@ -84,7 +84,7 @@ abstract class TreeInfo { * @throws ClassNotFoundException if the specified class could not be loaded * @throws IOException if an error occurs whilst reading the specified class */ - protected static byte[] loadClass(String className, boolean runTransformers) throws ClassNotFoundException, IOException { + static byte[] loadClass(String className, boolean runTransformers) throws ClassNotFoundException, IOException { String transformedName = className.replace('/', '.'); String name = MixinEnvironment.getCurrentEnvironment().unmap(transformedName); byte[] classBytes = TreeInfo.getClassBytes(name, transformedName); diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/meta/MixinInner.java b/src/main/java/org/spongepowered/asm/mixin/transformer/meta/MixinInner.java new file mode 100644 index 00000000..8eb18428 --- /dev/null +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/meta/MixinInner.java @@ -0,0 +1,50 @@ +/* + * This file is part of Mixin, licensed under the MIT License (MIT). + * + * Copyright (c) SpongePowered + * 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.meta; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * Decoration annotation used by the mixin inner class generator to mark inner + * classes which have been generated from an existing inner class in a mixin + */ +@Target(ElementType.TYPE) +@Retention(RetentionPolicy.CLASS) +public @interface MixinInner { + + /** + * The mixin which owns the original inner class + */ + public String mixin(); + + /** + * The original name of the inner class + */ + public String name(); + +} diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/meta/MixinMerged.java b/src/main/java/org/spongepowered/asm/mixin/transformer/meta/MixinMerged.java index 2a597bf7..b38aac7c 100644 --- a/src/main/java/org/spongepowered/asm/mixin/transformer/meta/MixinMerged.java +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/meta/MixinMerged.java @@ -55,4 +55,5 @@ public @interface MixinMerged { * @return mixin priority */ public int priority(); + } diff --git a/src/main/java/org/spongepowered/asm/util/Constants.java b/src/main/java/org/spongepowered/asm/util/Constants.java index e3cb559d..0e72d21a 100644 --- a/src/main/java/org/spongepowered/asm/util/Constants.java +++ b/src/main/java/org/spongepowered/asm/util/Constants.java @@ -42,6 +42,8 @@ public abstract class Constants { public static final String OBJECT = "Ljava/lang/Object;"; public static final String CLASS = "Ljava/lang/Class;"; + public static final String SYNTHETIC_PACKAGE = "org.spongepowered.asm.synthetic"; + private Constants() {} /**