mirror of
https://github.com/LegacyModdingMC/UniMix.git
synced 2026-11-21 04:32:33 +00:00
Handle remapping of field/method/cast/whatever insns in inherited mixins
This commit is contained in:
1 parent
f4c80263e9
commit
55653f325d
11 files changed
+589
-323
No files matched your search
@@ -158,7 +158,7 @@ public class MixinEnvironment {
|
||||
}
|
||||
|
||||
public void setActiveTransformer(IClassTransformer transformer) {
|
||||
Launch.blackboard.put(MixinEnvironment.TRANSFORMER_KEY, this);
|
||||
Launch.blackboard.put(MixinEnvironment.TRANSFORMER_KEY, transformer);
|
||||
}
|
||||
|
||||
public MixinEnvironment setSide(Side side) {
|
||||
|
||||
+2
-2
@@ -28,12 +28,12 @@ import org.objectweb.asm.tree.AnnotationNode;
|
||||
import org.objectweb.asm.tree.MethodNode;
|
||||
import org.spongepowered.asm.mixin.injection.callback.CallbackInjector;
|
||||
import org.spongepowered.asm.mixin.injection.code.Injector;
|
||||
import org.spongepowered.asm.mixin.transformer.MixinData;
|
||||
import org.spongepowered.asm.mixin.transformer.MixinTargetContext;
|
||||
import org.spongepowered.asm.util.ASMHelper;
|
||||
|
||||
public class CallbackInjectionInfo extends InjectionInfo {
|
||||
|
||||
protected CallbackInjectionInfo(MixinData mixin, MethodNode method, AnnotationNode annotation) {
|
||||
protected CallbackInjectionInfo(MixinTargetContext mixin, MethodNode method, AnnotationNode annotation) {
|
||||
super(mixin, method, annotation);
|
||||
}
|
||||
|
||||
|
||||
@@ -40,7 +40,7 @@ import org.spongepowered.asm.mixin.injection.InvalidInjectionException;
|
||||
import org.spongepowered.asm.mixin.injection.ModifyArg;
|
||||
import org.spongepowered.asm.mixin.injection.Redirect;
|
||||
import org.spongepowered.asm.mixin.injection.code.Injector;
|
||||
import org.spongepowered.asm.mixin.transformer.MixinData;
|
||||
import org.spongepowered.asm.mixin.transformer.MixinTargetContext;
|
||||
import org.spongepowered.asm.util.ASMHelper;
|
||||
|
||||
|
||||
@@ -65,7 +65,7 @@ public abstract class InjectionInfo {
|
||||
/**
|
||||
* Mixin data
|
||||
*/
|
||||
protected final MixinData mixin;
|
||||
protected final MixinTargetContext mixin;
|
||||
|
||||
|
||||
/**
|
||||
@@ -96,7 +96,7 @@ public abstract class InjectionInfo {
|
||||
* @param method Injector method
|
||||
* @param annotation Annotation to parse
|
||||
*/
|
||||
protected InjectionInfo(MixinData mixin, MethodNode method, AnnotationNode annotation) {
|
||||
protected InjectionInfo(MixinTargetContext mixin, MethodNode method, AnnotationNode annotation) {
|
||||
this.annotation = annotation;
|
||||
this.method = method;
|
||||
this.mixin = mixin;
|
||||
@@ -236,7 +236,7 @@ public abstract class InjectionInfo {
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
public static InjectionInfo parse(MixinData mixin, MethodNode method) {
|
||||
public static InjectionInfo parse(MixinTargetContext mixin, MethodNode method) {
|
||||
AnnotationNode annotation = null;
|
||||
try {
|
||||
annotation = ASMHelper.getSingleVisibleAnnotation(method, Inject.class, ModifyArg.class, Redirect.class);
|
||||
|
||||
+2
-2
@@ -28,12 +28,12 @@ import org.objectweb.asm.tree.AnnotationNode;
|
||||
import org.objectweb.asm.tree.MethodNode;
|
||||
import org.spongepowered.asm.mixin.injection.code.Injector;
|
||||
import org.spongepowered.asm.mixin.injection.invoke.ModifyArgInjector;
|
||||
import org.spongepowered.asm.mixin.transformer.MixinData;
|
||||
import org.spongepowered.asm.mixin.transformer.MixinTargetContext;
|
||||
import org.spongepowered.asm.util.ASMHelper;
|
||||
|
||||
public class ModifyArgInjectionInfo extends InjectionInfo {
|
||||
|
||||
public ModifyArgInjectionInfo(MixinData mixin, MethodNode method, AnnotationNode annotation) {
|
||||
public ModifyArgInjectionInfo(MixinTargetContext mixin, MethodNode method, AnnotationNode annotation) {
|
||||
super(mixin, method, annotation);
|
||||
}
|
||||
|
||||
|
||||
+2
-2
@@ -28,11 +28,11 @@ import org.objectweb.asm.tree.AnnotationNode;
|
||||
import org.objectweb.asm.tree.MethodNode;
|
||||
import org.spongepowered.asm.mixin.injection.code.Injector;
|
||||
import org.spongepowered.asm.mixin.injection.invoke.RedirectInjector;
|
||||
import org.spongepowered.asm.mixin.transformer.MixinData;
|
||||
import org.spongepowered.asm.mixin.transformer.MixinTargetContext;
|
||||
|
||||
public class RedirectInjectionInfo extends InjectionInfo {
|
||||
|
||||
public RedirectInjectionInfo(MixinData mixin, MethodNode method, AnnotationNode annotation) {
|
||||
public RedirectInjectionInfo(MixinTargetContext mixin, MethodNode method, AnnotationNode annotation) {
|
||||
super(mixin, method, annotation);
|
||||
}
|
||||
|
||||
|
||||
@@ -262,6 +262,12 @@ class ClassInfo extends TreeInfo {
|
||||
*/
|
||||
private final Set<MixinInfo> mixins = new HashSet<MixinInfo>();
|
||||
|
||||
/**
|
||||
* Map of mixin types to corresponding supertypes, to avoid repeated
|
||||
* lookups
|
||||
*/
|
||||
private final Map<ClassInfo, ClassInfo> correspondingTypes = new HashMap<ClassInfo, ClassInfo>();
|
||||
|
||||
/**
|
||||
* Mixin info if this class is a mixin itself
|
||||
*/
|
||||
@@ -592,6 +598,73 @@ class ClassInfo extends TreeInfo {
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Walks up this class's hierarchy to find the first class targetted by the
|
||||
* specified mixin. This is used during mixin application to translate a
|
||||
* mixin reference to a "real class" reference <em>in the context of <b>this
|
||||
* </b> class</em>.
|
||||
*
|
||||
* @param mixin Mixin class to search for
|
||||
* @return corresponding (target) class for the specified mixin or null if
|
||||
* no corresponding mixin was found
|
||||
*/
|
||||
ClassInfo findCorrespondingType(ClassInfo mixin) {
|
||||
if (mixin == null || !mixin.isMixin || this.isMixin) {
|
||||
return null;
|
||||
}
|
||||
|
||||
ClassInfo correspondingType = this.correspondingTypes.get(mixin);
|
||||
if (correspondingType == null) {
|
||||
correspondingType = this.findSuperTypeForMixin(mixin);
|
||||
this.correspondingTypes.put(mixin, correspondingType);
|
||||
}
|
||||
return correspondingType;
|
||||
}
|
||||
|
||||
/* (non-Javadoc)
|
||||
* Only used by findCorrespondingType(), used as a convenience so that
|
||||
* sanity checks and caching can be handled more elegantly
|
||||
*/
|
||||
private ClassInfo findSuperTypeForMixin(ClassInfo mixin) {
|
||||
ClassInfo superClass = this;
|
||||
|
||||
while (superClass != null && superClass != ClassInfo.OBJECT) {
|
||||
for (MixinInfo minion : superClass.mixins) {
|
||||
if (minion.getClassInfo().equals(mixin)) {
|
||||
return superClass;
|
||||
}
|
||||
}
|
||||
|
||||
superClass = superClass.getSuperClass();
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Find out whether this (mixin) class has another mixin in its superclass
|
||||
* hierarchy. This method always returns false for non-mixin classes.
|
||||
*
|
||||
* @return true if and only if one or more mixins are found in the hierarchy
|
||||
* of this mixin
|
||||
*/
|
||||
public boolean hasMixinInHierarchy() {
|
||||
if (!this.isMixin) {
|
||||
return false;
|
||||
}
|
||||
|
||||
ClassInfo superClass = this.getSuperClass();
|
||||
|
||||
while (superClass != null && superClass != ClassInfo.OBJECT) {
|
||||
if (superClass.isMixin) {
|
||||
return true;
|
||||
}
|
||||
superClass = superClass.getSuperClass();
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Finds the specified private or protected method in this class's hierarchy
|
||||
*
|
||||
|
||||
@@ -174,8 +174,6 @@ class MixinConfig implements Comparable<MixinConfig> {
|
||||
this.mixinPackage += ".";
|
||||
}
|
||||
|
||||
Launch.classLoader.addClassLoaderExclusion(this.mixinPackage);
|
||||
|
||||
if (this.refMapperConfig == null) {
|
||||
if (this.plugin != null) {
|
||||
this.refMapperConfig = this.plugin.getRefMapperConfig();
|
||||
|
||||
@@ -1,223 +0,0 @@
|
||||
/*
|
||||
* This file is part of Sponge, licensed under the MIT License (MIT).
|
||||
*
|
||||
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
|
||||
* Copyright (c) contributors
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
package org.spongepowered.asm.mixin.transformer;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
|
||||
import org.objectweb.asm.tree.ClassNode;
|
||||
import org.objectweb.asm.tree.MethodNode;
|
||||
import org.spongepowered.asm.mixin.injection.struct.ReferenceMapper;
|
||||
import org.spongepowered.asm.mixin.injection.struct.Target;
|
||||
|
||||
|
||||
/**
|
||||
* Data for applying a mixin. Keeps a copy of the mixin tree and also handles
|
||||
* any pre-transformations required by the mixin class itself such as method
|
||||
* renaming and any other pre-processing of the mixin bytecode.
|
||||
*/
|
||||
public class MixinData implements IReferenceMapperContext {
|
||||
|
||||
/**
|
||||
* Mixin info
|
||||
*/
|
||||
private final MixinInfo mixin;
|
||||
|
||||
/**
|
||||
* Tree
|
||||
*/
|
||||
private final ClassNode classNode;
|
||||
|
||||
/**
|
||||
*
|
||||
*/
|
||||
private final ClassNode targetClass;
|
||||
|
||||
/**
|
||||
* Target ClassInfo
|
||||
*/
|
||||
private final ClassInfo targetClassInfo;
|
||||
|
||||
/**
|
||||
* Information about methods in the target class, used to keep track of
|
||||
* transformations we apply
|
||||
*/
|
||||
private final Map<String, Target> targetMethods = new HashMap<String, Target>();
|
||||
|
||||
/**
|
||||
* ctor
|
||||
*
|
||||
* @param info Mixin information
|
||||
* @param mixin Mixin classnode
|
||||
* @param target target class
|
||||
*/
|
||||
MixinData(MixinInfo info, ClassNode mixin, ClassNode target) {
|
||||
this.mixin = info;
|
||||
this.classNode = mixin;
|
||||
this.targetClass = target;
|
||||
this.targetClassInfo = ClassInfo.forName(target.name);
|
||||
}
|
||||
|
||||
/* (non-Javadoc)
|
||||
* @see java.lang.Object#toString()
|
||||
*/
|
||||
@Override
|
||||
public String toString() {
|
||||
return this.mixin.toString();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the mixin tree
|
||||
*
|
||||
* @return mixin tree
|
||||
*/
|
||||
public ClassNode getClassNode() {
|
||||
return this.classNode;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the mixin class name
|
||||
*
|
||||
* @return the mixin class name
|
||||
*/
|
||||
public String getClassName() {
|
||||
return this.mixin.getClassName();
|
||||
}
|
||||
|
||||
/* (non-Javadoc)
|
||||
* @see org.spongepowered.asm.mixin.transformer.IReferenceMapperContext
|
||||
* #getClassRef()
|
||||
*/
|
||||
@Override
|
||||
public String getClassRef() {
|
||||
return this.mixin.getClassRef();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the target class reference
|
||||
*
|
||||
* @return the reference of the target class (only valid on single-target
|
||||
* mixins)
|
||||
*/
|
||||
public String getTargetClassRef() {
|
||||
return this.targetClass.name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the target class
|
||||
*
|
||||
* @return the target class
|
||||
*/
|
||||
public ClassNode getTargetClass() {
|
||||
return this.targetClass;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the target classinfo
|
||||
*
|
||||
* @return the target class info
|
||||
*/
|
||||
public ClassInfo getTargetClassInfo() {
|
||||
return this.targetClassInfo;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a target method handle from the target class
|
||||
*
|
||||
* @param method method to get a target handle for
|
||||
* @return new or existing target handle for the supplied method
|
||||
*/
|
||||
public Target getTargetMethod(MethodNode method) {
|
||||
if (!this.targetClass.methods.contains(method)) {
|
||||
throw new IllegalArgumentException("Invalid target method supplied to getTargetMethod()");
|
||||
}
|
||||
|
||||
String targetName = method.name + method.desc;
|
||||
Target target = this.targetMethods.get(targetName);
|
||||
if (target == null) {
|
||||
target = new Target(method);
|
||||
this.targetMethods.put(targetName, target);
|
||||
}
|
||||
return target;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the mixin priority
|
||||
*
|
||||
* @return the priority (only meaningful in relation to other mixins)
|
||||
*/
|
||||
public int getPriority() {
|
||||
return this.mixin.getPriority();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get all interfaces for this mixin
|
||||
*
|
||||
* @return mixin interfaces
|
||||
*/
|
||||
public Set<String> getInterfaces() {
|
||||
return this.mixin.getInterfaces();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get whether to propogate the source file attribute from a mixin onto the
|
||||
* target class
|
||||
*
|
||||
* @return true if the sourcefile property should be set on the target class
|
||||
*/
|
||||
public boolean shouldSetSourceFile() {
|
||||
return this.mixin.getParent().shouldSetSourceFile();
|
||||
}
|
||||
|
||||
/* (non-Javadoc)
|
||||
* @see org.spongepowered.asm.mixin.transformer.IReferenceMapperContext
|
||||
* #getReferenceMapper()
|
||||
*/
|
||||
@Override
|
||||
public ReferenceMapper getReferenceMapper() {
|
||||
return this.mixin.getParent().getReferenceMapper();
|
||||
}
|
||||
|
||||
/**
|
||||
* Called immediately before the mixin is applied to targetClass
|
||||
*
|
||||
* @param transformedName Target class's transformed name
|
||||
* @param targetClass Target class
|
||||
*/
|
||||
public void preApply(String transformedName, ClassNode targetClass) {
|
||||
this.mixin.preApply(transformedName, targetClass);
|
||||
}
|
||||
|
||||
/**
|
||||
* Called immediately after the mixin is applied to targetClass
|
||||
*
|
||||
* @param transformedName Target class's transformed name
|
||||
* @param targetClass Target class
|
||||
*/
|
||||
public void postApply(String transformedName, ClassNode targetClass) {
|
||||
this.mixin.postApply(transformedName, targetClass);
|
||||
}
|
||||
}
|
||||
@@ -25,6 +25,7 @@
|
||||
package org.spongepowered.asm.mixin.transformer;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.lang.reflect.Field;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.HashSet;
|
||||
@@ -32,6 +33,9 @@ import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import java.util.Set;
|
||||
|
||||
import net.minecraft.launchwrapper.Launch;
|
||||
import net.minecraft.launchwrapper.LaunchClassLoader;
|
||||
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
import org.objectweb.asm.ClassReader;
|
||||
@@ -68,6 +72,8 @@ class MixinInfo extends TreeInfo implements Comparable<MixinInfo>, IMixinInfo {
|
||||
*/
|
||||
static int mixinOrder = 0;
|
||||
|
||||
static final Set<String> invalidClasses = MixinInfo.$getInvalidClassesSet();
|
||||
|
||||
/**
|
||||
* Logger
|
||||
*/
|
||||
@@ -465,14 +471,14 @@ class MixinInfo extends TreeInfo implements Comparable<MixinInfo>, IMixinInfo {
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a new mixin data container for this info
|
||||
* Get a new mixin target context object for the specified target
|
||||
*
|
||||
* @param target
|
||||
* @return
|
||||
*/
|
||||
public MixinData createData(ClassNode target) {
|
||||
public MixinTargetContext createContextForTarget(ClassNode target) {
|
||||
ClassNode classNode = this.getClassNode(ClassReader.EXPAND_FRAMES);
|
||||
return new MixinData(this, this.prepare(classNode), target);
|
||||
return new MixinTargetContext(this, this.prepare(classNode), target);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -492,6 +498,13 @@ class MixinInfo extends TreeInfo implements Comparable<MixinInfo>, IMixinInfo {
|
||||
this.logger.warn("Failed to load mixin %s, the specified mixin will not be applied", mixinClassName);
|
||||
throw new InvalidMixinException("An error was encountered whilst loading the mixin class", ex);
|
||||
}
|
||||
|
||||
// Inject the mixin class name into the LaunchClassLoader's invalid
|
||||
// classes set so that any classes referencing the mixin directly will
|
||||
// cause the game to crash
|
||||
if (MixinInfo.invalidClasses != null) {
|
||||
MixinInfo.invalidClasses.add(mixinClassName);
|
||||
}
|
||||
|
||||
return mixinBytes;
|
||||
}
|
||||
@@ -535,4 +548,16 @@ class MixinInfo extends TreeInfo implements Comparable<MixinInfo>, IMixinInfo {
|
||||
public String toString() {
|
||||
return String.format("%s:%s", this.parent.getName(), this.name);
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
private static Set<String> $getInvalidClassesSet() {
|
||||
try {
|
||||
Field invalidClasses = LaunchClassLoader.class.getDeclaredField("invalidClasses");
|
||||
invalidClasses.setAccessible(true);
|
||||
return (Set<String>)invalidClasses.get(Launch.classLoader);
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace();
|
||||
}
|
||||
return null;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,445 @@
|
||||
/*
|
||||
* This file is part of Sponge, licensed under the MIT License (MIT).
|
||||
*
|
||||
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
|
||||
* Copyright (c) contributors
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
package org.spongepowered.asm.mixin.transformer;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.Iterator;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
|
||||
import org.objectweb.asm.Opcodes;
|
||||
import org.objectweb.asm.Type;
|
||||
import org.objectweb.asm.tree.AbstractInsnNode;
|
||||
import org.objectweb.asm.tree.ClassNode;
|
||||
import org.objectweb.asm.tree.FieldInsnNode;
|
||||
import org.objectweb.asm.tree.FieldNode;
|
||||
import org.objectweb.asm.tree.MethodInsnNode;
|
||||
import org.objectweb.asm.tree.MethodNode;
|
||||
import org.objectweb.asm.tree.TypeInsnNode;
|
||||
import org.spongepowered.asm.mixin.InvalidMixinException;
|
||||
import org.spongepowered.asm.mixin.MixinTransformerError;
|
||||
import org.spongepowered.asm.mixin.injection.struct.ReferenceMapper;
|
||||
import org.spongepowered.asm.mixin.injection.struct.Target;
|
||||
import org.spongepowered.asm.mixin.transformer.ClassInfo.Method;
|
||||
import org.spongepowered.asm.mixin.transformer.ClassInfo.Traversal;
|
||||
|
||||
|
||||
/**
|
||||
* This object keeps track of data for applying a mixin to a specific target
|
||||
* class <em>during</em> a mixin application. This is a single-use object which
|
||||
* acts as both a handle information we need when applying the mixin (such as
|
||||
* the actual mixin ClassNode and the target ClassNode) and a gateway to
|
||||
* context-sensitive operations such as re-targetting method and field accesses
|
||||
* in the mixin to the appropriate members in the target class hierarchy.
|
||||
*/
|
||||
public class MixinTargetContext implements IReferenceMapperContext {
|
||||
|
||||
private static final String INIT = "<init>";
|
||||
|
||||
/**
|
||||
* Mixin info
|
||||
*/
|
||||
private final MixinInfo mixin;
|
||||
|
||||
/**
|
||||
* Tree
|
||||
*/
|
||||
private final ClassNode classNode;
|
||||
|
||||
/**
|
||||
*
|
||||
*/
|
||||
private final ClassNode targetClass;
|
||||
|
||||
/**
|
||||
* Target ClassInfo
|
||||
*/
|
||||
private final ClassInfo targetClassInfo;
|
||||
|
||||
/**
|
||||
* Information about methods in the target class, used to keep track of
|
||||
* transformations we apply
|
||||
*/
|
||||
private final Map<String, Target> targetMethods = new HashMap<String, Target>();
|
||||
|
||||
/**
|
||||
* True if this mixin inherits from a mixin at any point in its hierarchy
|
||||
*/
|
||||
private final boolean inheritsFromMixin;
|
||||
|
||||
/**
|
||||
* ctor
|
||||
*
|
||||
* @param info Mixin information
|
||||
* @param mixin Mixin classnode
|
||||
* @param target target class
|
||||
*/
|
||||
MixinTargetContext(MixinInfo info, ClassNode mixin, ClassNode target) {
|
||||
this.mixin = info;
|
||||
this.classNode = mixin;
|
||||
this.targetClass = target;
|
||||
this.targetClassInfo = ClassInfo.forName(target.name);
|
||||
this.inheritsFromMixin = info.getClassInfo().hasMixinInHierarchy();
|
||||
}
|
||||
|
||||
/* (non-Javadoc)
|
||||
* @see java.lang.Object#toString()
|
||||
*/
|
||||
@Override
|
||||
public String toString() {
|
||||
return this.mixin.toString();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the mixin tree
|
||||
*
|
||||
* @return mixin tree
|
||||
*/
|
||||
public ClassNode getClassNode() {
|
||||
return this.classNode;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the mixin class name
|
||||
*
|
||||
* @return the mixin class name
|
||||
*/
|
||||
public String getClassName() {
|
||||
return this.mixin.getClassName();
|
||||
}
|
||||
|
||||
/* (non-Javadoc)
|
||||
* @see org.spongepowered.asm.mixin.transformer.IReferenceMapperContext
|
||||
* #getClassRef()
|
||||
*/
|
||||
@Override
|
||||
public String getClassRef() {
|
||||
return this.mixin.getClassRef();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the target class reference
|
||||
*
|
||||
* @return the reference of the target class (only valid on single-target
|
||||
* mixins)
|
||||
*/
|
||||
public String getTargetClassRef() {
|
||||
return this.targetClass.name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the target class
|
||||
*
|
||||
* @return the target class
|
||||
*/
|
||||
public ClassNode getTargetClass() {
|
||||
return this.targetClass;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the target classinfo
|
||||
*
|
||||
* @return the target class info
|
||||
*/
|
||||
public ClassInfo getTargetClassInfo() {
|
||||
return this.targetClassInfo;
|
||||
}
|
||||
|
||||
/**
|
||||
* Find the corresponding class type for the supplied mixin class in this
|
||||
* mixin target's hierarchy
|
||||
*
|
||||
* @param mixin Mixin class to discover
|
||||
* @return Transformed
|
||||
*/
|
||||
public ClassInfo findRealType(ClassInfo mixin) {
|
||||
if (mixin == this.mixin.getClassInfo()) {
|
||||
return this.targetClassInfo;
|
||||
}
|
||||
|
||||
ClassInfo type = this.targetClassInfo.findCorrespondingType(mixin);
|
||||
if (type == null) {
|
||||
throw new InvalidMixinException("Resolution error: unable to find corresponding type for "
|
||||
+ mixin + " in hierarchy of " + this.targetClassInfo);
|
||||
}
|
||||
|
||||
return type;
|
||||
}
|
||||
|
||||
/**
|
||||
* Transforms field descriptors which contain mixin types to their
|
||||
* appropriate target type
|
||||
*
|
||||
* @param field
|
||||
*/
|
||||
public void transformField(FieldNode field) {
|
||||
this.transformDescriptor(field);
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles "re-parenting" the method supplied, changes all references to the
|
||||
* mixin class to refer to the target class (for field accesses and method
|
||||
* invokations) and also handles fixing up the targets of INVOKESPECIAL
|
||||
* opcodes for mixins with detached targets.
|
||||
*
|
||||
* @param targetClass
|
||||
* @param mixin
|
||||
* @param method
|
||||
*/
|
||||
public void transformMethod(MethodNode method) {
|
||||
this.transformDescriptor(method);
|
||||
|
||||
String fromClass = this.getClassRef();
|
||||
boolean detached = !this.getClassNode().superName.equals(this.targetClass.superName);
|
||||
|
||||
Iterator<AbstractInsnNode> iter = method.instructions.iterator();
|
||||
while (iter.hasNext()) {
|
||||
AbstractInsnNode insn = iter.next();
|
||||
|
||||
if (insn instanceof MethodInsnNode) {
|
||||
MethodInsnNode methodInsn = (MethodInsnNode)insn;
|
||||
this.transformDescriptor(methodInsn);
|
||||
if (methodInsn.owner.equals(fromClass)) {
|
||||
methodInsn.owner = this.targetClass.name;
|
||||
} else if (detached && methodInsn.getOpcode() == Opcodes.INVOKESPECIAL) {
|
||||
this.updateStaticBindings(this.targetClass, this, method, methodInsn);
|
||||
}
|
||||
} else if (insn instanceof FieldInsnNode) {
|
||||
FieldInsnNode fieldInsn = (FieldInsnNode)insn;
|
||||
this.transformDescriptor(fieldInsn);
|
||||
if (fieldInsn.owner.equals(fromClass)) {
|
||||
fieldInsn.owner = this.targetClass.name;
|
||||
}
|
||||
} else if (insn instanceof TypeInsnNode) {
|
||||
this.transformDescriptor((TypeInsnNode)insn);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Update INVOKESPECIAL opcodes to target the topmost class in the hierarchy
|
||||
* which contains the specified method.
|
||||
*
|
||||
* @param targetClass
|
||||
* @param mixin
|
||||
* @param method
|
||||
* @param insn
|
||||
*/
|
||||
private void updateStaticBindings(ClassNode targetClass, MixinTargetContext mixin, MethodNode method, MethodInsnNode insn) {
|
||||
if (INIT.equals(method.name) || insn.owner.equals(targetClass.name) || targetClass.name.startsWith("<")) {
|
||||
return;
|
||||
}
|
||||
|
||||
ClassInfo targetClassInfo = ClassInfo.forName(targetClass.name);
|
||||
Method superMethod = targetClassInfo.findMethodInHierarchy(insn.name, insn.desc, false, Traversal.SUPER);
|
||||
if (superMethod != null) {
|
||||
if (superMethod.getOwner().isMixin()) {
|
||||
throw new InvalidMixinException("Invalid INVOKESPECIAL in " + mixin + " resolved " + insn.owner + " -> " + superMethod.getOwner()
|
||||
+ " for " + insn.name + insn.desc);
|
||||
}
|
||||
insn.owner = superMethod.getOwner().getName();
|
||||
} else if (ClassInfo.forName(insn.owner).isMixin()) {
|
||||
throw new MixinTransformerError("Error resolving INVOKESPECIAL target for " + insn.owner + "." + insn.name + " in " + mixin);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Transforms a field descriptor in the context of this mixin target
|
||||
*
|
||||
* @param field
|
||||
*/
|
||||
public void transformDescriptor(FieldNode field) {
|
||||
if (!this.inheritsFromMixin) {
|
||||
return;
|
||||
}
|
||||
field.desc = this.transformSingleDescriptor(field.desc, false);
|
||||
}
|
||||
|
||||
/**
|
||||
* Transforms a field insn descriptor in the context of this mixin target
|
||||
*
|
||||
* @param field
|
||||
*/
|
||||
public void transformDescriptor(FieldInsnNode field) {
|
||||
if (!this.inheritsFromMixin) {
|
||||
return;
|
||||
}
|
||||
field.desc = this.transformSingleDescriptor(field.desc, false);
|
||||
}
|
||||
|
||||
/**
|
||||
* Transforms a method descriptor in the context of this mixin target
|
||||
*
|
||||
* @param method
|
||||
*/
|
||||
public void transformDescriptor(MethodNode method) {
|
||||
if (!this.inheritsFromMixin) {
|
||||
return;
|
||||
}
|
||||
method.desc = this.transformMethodDescriptor(method.desc);
|
||||
}
|
||||
|
||||
/**
|
||||
* Transforms a method insn descriptor in the context of this mixin target
|
||||
*
|
||||
* @param method
|
||||
*/
|
||||
public void transformDescriptor(MethodInsnNode method) {
|
||||
if (!this.inheritsFromMixin) {
|
||||
return;
|
||||
}
|
||||
method.desc = this.transformMethodDescriptor(method.desc);
|
||||
}
|
||||
|
||||
/**
|
||||
* Transforms a type insn descriptor in the context of this mixin target
|
||||
*
|
||||
* @param typeInsn
|
||||
*/
|
||||
public void transformDescriptor(TypeInsnNode typeInsn) {
|
||||
if (!this.inheritsFromMixin) {
|
||||
return;
|
||||
}
|
||||
typeInsn.desc = this.transformSingleDescriptor(typeInsn.desc, true);
|
||||
}
|
||||
|
||||
private String transformSingleDescriptor(Type type) {
|
||||
if (type.getSort() < Type.ARRAY) {
|
||||
return type.toString();
|
||||
}
|
||||
|
||||
return this.transformSingleDescriptor(type.toString(), false);
|
||||
}
|
||||
|
||||
private String transformSingleDescriptor(String desc, boolean isObject) {
|
||||
String type = desc;
|
||||
while (type.startsWith("[") || type.startsWith("L")) {
|
||||
if (type.startsWith("[")) {
|
||||
type = type.substring(1);
|
||||
continue;
|
||||
}
|
||||
type = type.substring(1, type.indexOf(";"));
|
||||
isObject = true;
|
||||
}
|
||||
|
||||
if (!isObject) {
|
||||
return desc;
|
||||
}
|
||||
|
||||
ClassInfo typeInfo = ClassInfo.forName(type);
|
||||
|
||||
if (!typeInfo.isMixin()) {
|
||||
return desc;
|
||||
}
|
||||
|
||||
return desc.replace(type, this.findRealType(typeInfo).toString());
|
||||
}
|
||||
|
||||
private String transformMethodDescriptor(String desc) {
|
||||
StringBuilder newDesc = new StringBuilder();
|
||||
newDesc.append('(');
|
||||
for (Type arg : Type.getArgumentTypes(desc)) {
|
||||
newDesc.append(this.transformSingleDescriptor(arg));
|
||||
}
|
||||
return newDesc.append(')').append(this.transformSingleDescriptor(Type.getReturnType(desc))).toString();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a target method handle from the target class
|
||||
*
|
||||
* @param method method to get a target handle for
|
||||
* @return new or existing target handle for the supplied method
|
||||
*/
|
||||
public Target getTargetMethod(MethodNode method) {
|
||||
if (!this.targetClass.methods.contains(method)) {
|
||||
throw new IllegalArgumentException("Invalid target method supplied to getTargetMethod()");
|
||||
}
|
||||
|
||||
String targetName = method.name + method.desc;
|
||||
Target target = this.targetMethods.get(targetName);
|
||||
if (target == null) {
|
||||
target = new Target(method);
|
||||
this.targetMethods.put(targetName, target);
|
||||
}
|
||||
return target;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the mixin priority
|
||||
*
|
||||
* @return the priority (only meaningful in relation to other mixins)
|
||||
*/
|
||||
public int getPriority() {
|
||||
return this.mixin.getPriority();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get all interfaces for this mixin
|
||||
*
|
||||
* @return mixin interfaces
|
||||
*/
|
||||
public Set<String> getInterfaces() {
|
||||
return this.mixin.getInterfaces();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get whether to propogate the source file attribute from a mixin onto the
|
||||
* target class
|
||||
*
|
||||
* @return true if the sourcefile property should be set on the target class
|
||||
*/
|
||||
public boolean shouldSetSourceFile() {
|
||||
return this.mixin.getParent().shouldSetSourceFile();
|
||||
}
|
||||
|
||||
/* (non-Javadoc)
|
||||
* @see org.spongepowered.asm.mixin.transformer.IReferenceMapperContext
|
||||
* #getReferenceMapper()
|
||||
*/
|
||||
@Override
|
||||
public ReferenceMapper getReferenceMapper() {
|
||||
return this.mixin.getParent().getReferenceMapper();
|
||||
}
|
||||
|
||||
/**
|
||||
* Called immediately before the mixin is applied to targetClass
|
||||
*
|
||||
* @param transformedName Target class's transformed name
|
||||
* @param targetClass Target class
|
||||
*/
|
||||
public void preApply(String transformedName, ClassNode targetClass) {
|
||||
this.mixin.preApply(transformedName, targetClass);
|
||||
}
|
||||
|
||||
/**
|
||||
* Called immediately after the mixin is applied to targetClass
|
||||
*
|
||||
* @param transformedName Target class's transformed name
|
||||
* @param targetClass Target class
|
||||
*/
|
||||
public void postApply(String transformedName, ClassNode targetClass) {
|
||||
this.mixin.postApply(transformedName, targetClass);
|
||||
}
|
||||
}
|
||||
@@ -48,7 +48,6 @@ import org.objectweb.asm.Type;
|
||||
import org.objectweb.asm.tree.AbstractInsnNode;
|
||||
import org.objectweb.asm.tree.AnnotationNode;
|
||||
import org.objectweb.asm.tree.ClassNode;
|
||||
import org.objectweb.asm.tree.FieldInsnNode;
|
||||
import org.objectweb.asm.tree.FieldNode;
|
||||
import org.objectweb.asm.tree.InsnList;
|
||||
import org.objectweb.asm.tree.LabelNode;
|
||||
@@ -62,8 +61,6 @@ import org.spongepowered.asm.mixin.Overwrite;
|
||||
import org.spongepowered.asm.mixin.Shadow;
|
||||
import org.spongepowered.asm.mixin.extensibility.IMixinConfigPlugin;
|
||||
import org.spongepowered.asm.mixin.injection.struct.InjectionInfo;
|
||||
import org.spongepowered.asm.mixin.transformer.ClassInfo.Method;
|
||||
import org.spongepowered.asm.mixin.transformer.ClassInfo.Traversal;
|
||||
import org.spongepowered.asm.transformers.TreeTransformer;
|
||||
import org.spongepowered.asm.util.ASMHelper;
|
||||
|
||||
@@ -352,7 +349,7 @@ public class MixinTransformer extends TreeTransformer {
|
||||
|
||||
for (MixinInfo mixin : mixins) {
|
||||
this.logger.info("Mixing {} into {}", mixin.getName(), transformedName);
|
||||
this.applyMixin(transformedName, targetClass, mixin.createData(targetClass));
|
||||
this.applyMixin(transformedName, targetClass, mixin.createContextForTarget(targetClass));
|
||||
}
|
||||
|
||||
// Extension point
|
||||
@@ -389,7 +386,7 @@ public class MixinTransformer extends TreeTransformer {
|
||||
* @param targetClass Target class
|
||||
* @param mixin Mixin to apply
|
||||
*/
|
||||
protected void applyMixin(String transformedName, ClassNode targetClass, MixinData mixin) {
|
||||
protected void applyMixin(String transformedName, ClassNode targetClass, MixinTargetContext mixin) {
|
||||
try {
|
||||
mixin.preApply(transformedName, targetClass);
|
||||
this.applyMixinInterfaces(targetClass, mixin);
|
||||
@@ -410,7 +407,7 @@ public class MixinTransformer extends TreeTransformer {
|
||||
* @param targetClass
|
||||
* @param mixin
|
||||
*/
|
||||
private void applyMixinInterfaces(ClassNode targetClass, MixinData mixin) {
|
||||
private void applyMixinInterfaces(ClassNode targetClass, MixinTargetContext mixin) {
|
||||
for (String interfaceName : mixin.getInterfaces()) {
|
||||
if (!targetClass.interfaces.contains(interfaceName)) {
|
||||
targetClass.interfaces.add(interfaceName);
|
||||
@@ -424,7 +421,7 @@ public class MixinTransformer extends TreeTransformer {
|
||||
* @param targetClass
|
||||
* @param mixin
|
||||
*/
|
||||
private void applyMixinAttributes(ClassNode targetClass, MixinData mixin) {
|
||||
private void applyMixinAttributes(ClassNode targetClass, MixinTargetContext mixin) {
|
||||
if (mixin.shouldSetSourceFile()) {
|
||||
targetClass.sourceFile = mixin.getClassNode().sourceFile;
|
||||
}
|
||||
@@ -439,18 +436,11 @@ public class MixinTransformer extends TreeTransformer {
|
||||
* @param targetClass
|
||||
* @param mixin
|
||||
*/
|
||||
private void applyMixinFields(ClassNode targetClass, MixinData mixin) {
|
||||
private void applyMixinFields(ClassNode targetClass, MixinTargetContext mixin) {
|
||||
for (FieldNode field : mixin.getClassNode().fields) {
|
||||
// Public static fields will fall foul of early static binding in java, including them in a mixin is an error condition
|
||||
if (MixinTransformer.hasFlag(field, Opcodes.ACC_STATIC) && !MixinTransformer.hasFlag(field, Opcodes.ACC_PRIVATE)) {
|
||||
throw new InvalidMixinException(String.format("Mixin classes cannot contain visible static methods or fields, found %s", field.name));
|
||||
}
|
||||
|
||||
AnnotationNode shadow = ASMHelper.getVisibleAnnotation(field, Shadow.class);
|
||||
String prefix = ASMHelper.<String>getAnnotationValue(shadow, "prefix", Shadow.class);
|
||||
if (field.name.startsWith(prefix)) {
|
||||
throw new InvalidMixinException(String.format("Shadow field %s in %s has a shadow prefix. This is not allowed.", field.name, mixin));
|
||||
}
|
||||
this.validateField(mixin, field, shadow);
|
||||
mixin.transformField(field);
|
||||
|
||||
FieldNode target = this.findTargetField(targetClass, field);
|
||||
if (target == null) {
|
||||
@@ -470,16 +460,35 @@ public class MixinTransformer extends TreeTransformer {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Field sanity checks
|
||||
* @param mixin
|
||||
* @param field
|
||||
* @param shadow
|
||||
*/
|
||||
private void validateField(MixinTargetContext mixin, FieldNode field, AnnotationNode shadow) {
|
||||
// Public static fields will fall foul of early static binding in java, including them in a mixin is an error condition
|
||||
if (MixinTransformer.hasFlag(field, Opcodes.ACC_STATIC) && !MixinTransformer.hasFlag(field, Opcodes.ACC_PRIVATE)) {
|
||||
throw new InvalidMixinException(String.format("Mixin classes cannot contain visible static methods or fields, found %s", field.name));
|
||||
}
|
||||
|
||||
// Shadow fields can't have prefixes, it's meaningless for them anyway
|
||||
String prefix = ASMHelper.<String>getAnnotationValue(shadow, "prefix", Shadow.class);
|
||||
if (field.name.startsWith(prefix)) {
|
||||
throw new InvalidMixinException(String.format("Shadow field %s in %s has a shadow prefix. This is not allowed.", field.name, mixin));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Mixin methods from the mixin class into the target class
|
||||
*
|
||||
* @param targetClass
|
||||
* @param mixin
|
||||
*/
|
||||
private void applyMixinMethods(ClassNode targetClass, MixinData mixin) {
|
||||
private void applyMixinMethods(ClassNode targetClass, MixinTargetContext mixin) {
|
||||
for (MethodNode mixinMethod : mixin.getClassNode().methods) {
|
||||
// Reparent all mixin methods into the target class
|
||||
this.transformMethod(mixin, targetClass, mixinMethod);
|
||||
mixin.transformMethod(mixinMethod);
|
||||
|
||||
boolean isShadow = ASMHelper.getVisibleAnnotation(mixinMethod, Shadow.class) != null;
|
||||
boolean isOverwrite = ASMHelper.getVisibleAnnotation(mixinMethod, Overwrite.class) != null;
|
||||
@@ -508,67 +517,6 @@ public class MixinTransformer extends TreeTransformer {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles "re-parenting" the method supplied, changes all references to the
|
||||
* mixin class to refer to the target class (for field accesses and method
|
||||
* invokations) and also handles fixing up the targets of INVOKESPECIAL
|
||||
* opcodes for mixins with detached targets.
|
||||
*
|
||||
* @param mixin
|
||||
* @param target
|
||||
* @param method
|
||||
*/
|
||||
private void transformMethod(MixinData mixin, ClassNode target, MethodNode method) {
|
||||
String fromClass = mixin.getClassRef();
|
||||
boolean detached = !mixin.getClassNode().superName.equals(target.superName);
|
||||
|
||||
Iterator<AbstractInsnNode> iter = method.instructions.iterator();
|
||||
while (iter.hasNext()) {
|
||||
AbstractInsnNode insn = iter.next();
|
||||
|
||||
if (insn instanceof MethodInsnNode) {
|
||||
MethodInsnNode methodInsn = (MethodInsnNode) insn;
|
||||
if (methodInsn.owner.equals(fromClass)) {
|
||||
methodInsn.owner = target.name;
|
||||
} else if (detached && methodInsn.getOpcode() == Opcodes.INVOKESPECIAL) {
|
||||
this.updateStaticBindings(mixin, target, method, methodInsn);
|
||||
}
|
||||
} else if (insn instanceof FieldInsnNode) {
|
||||
FieldInsnNode fieldInsn = (FieldInsnNode) insn;
|
||||
if (fieldInsn.owner.equals(fromClass)) {
|
||||
fieldInsn.owner = target.name;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Update INVOKESPECIAL opcodes to target the topmost class in the hierarchy
|
||||
* which contains the specified method.
|
||||
*
|
||||
* @param mixin
|
||||
* @param target
|
||||
* @param method
|
||||
* @param insn
|
||||
*/
|
||||
private void updateStaticBindings(MixinData mixin, ClassNode target, MethodNode method, MethodInsnNode insn) {
|
||||
if (INIT.equals(method.name) || insn.owner.equals(target.name) || target.name.startsWith("<")) {
|
||||
return;
|
||||
}
|
||||
|
||||
ClassInfo targetClass = ClassInfo.forName(target.name);
|
||||
Method superMethod = targetClass.findMethodInHierarchy(insn.name, insn.desc, false, Traversal.SUPER);
|
||||
if (superMethod != null) {
|
||||
if (superMethod.getOwner().isMixin()) {
|
||||
throw new InvalidMixinException("Invalid INVOKESPECIAL in " + mixin + " resolved " + insn.owner + " -> " + superMethod.getOwner()
|
||||
+ " for " + insn.name + insn.desc);
|
||||
}
|
||||
insn.owner = superMethod.getOwner().getName();
|
||||
} else if (ClassInfo.forName(insn.owner).isMixin()) {
|
||||
throw new MixinTransformerError("Error resolving INVOKESPECIAL target for " + insn.owner + "." + insn.name + " in " + mixin);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Attempts to merge the supplied method into the target class
|
||||
*
|
||||
@@ -578,7 +526,7 @@ public class MixinTransformer extends TreeTransformer {
|
||||
* @param isOverwrite true if the method is annotated with an
|
||||
* {@link Overwrite} annotation
|
||||
*/
|
||||
private void mergeMethod(ClassNode targetClass, MixinData mixin, MethodNode method, boolean isOverwrite) {
|
||||
private void mergeMethod(ClassNode targetClass, MixinTargetContext mixin, MethodNode method, boolean isOverwrite) {
|
||||
MethodNode target = this.findTargetMethod(targetClass, method);
|
||||
|
||||
if (target != null) {
|
||||
@@ -667,7 +615,7 @@ public class MixinTransformer extends TreeTransformer {
|
||||
* @param targetClass
|
||||
* @param mixin
|
||||
*/
|
||||
private void applyInitialisers(ClassNode targetClass, MixinData mixin) {
|
||||
private void applyInitialisers(ClassNode targetClass, MixinTargetContext mixin) {
|
||||
// Try to find a suitable constructor, we need a constructor with line numbers in order to extract the initialiser
|
||||
MethodNode ctor = this.getConstructor(mixin);
|
||||
if (ctor == null) {
|
||||
@@ -691,7 +639,7 @@ public class MixinTransformer extends TreeTransformer {
|
||||
/**
|
||||
* Finds a suitable ctor for reading the instance initialiser bytecode
|
||||
*/
|
||||
private MethodNode getConstructor(MixinData mixin) {
|
||||
private MethodNode getConstructor(MixinTargetContext mixin) {
|
||||
MethodNode ctor = null;
|
||||
|
||||
for (MethodNode mixinMethod : mixin.getClassNode().methods) {
|
||||
@@ -828,7 +776,7 @@ public class MixinTransformer extends TreeTransformer {
|
||||
* @param targetClass
|
||||
* @param mixin
|
||||
*/
|
||||
private void applyInjections(ClassNode targetClass, MixinData mixin) {
|
||||
private void applyInjections(ClassNode targetClass, MixinTargetContext mixin) {
|
||||
for (MethodNode method : targetClass.methods) {
|
||||
InjectionInfo injectInfo = InjectionInfo.parse(mixin, method);
|
||||
if (injectInfo == null) {
|
||||
|
||||
Reference in new issue
Block a user