Merge remote-tracking branch 'remotes/upstream/master' into fabric-0.8

# Conflicts:
#	src/main/java/org/spongepowered/asm/util/asm/ASM.java
This commit is contained in:
Ridan Vandenbergh committed 2019-12-17 00:02:06 +01:00
commit 910d479864
23 files changed
+428 -96

No files matched your search

@@ -226,7 +226,7 @@ class AnnotatedMixin {
this.printMessage(Kind.ERROR, "Mixin target " + softTarget + " could not be found", this);
return null;
} else if (type.isPublic()) {
SuppressedBy suppressedBy = (type.getPackage().isUnnamed()) ? SuppressedBy.DEFAULT_PACKAGE : null;
SuppressedBy suppressedBy = (type.getPackage().isUnnamed()) ? SuppressedBy.DEFAULT_PACKAGE : SuppressedBy.PUBLIC_TARGET;
this.printMessage(Kind.WARNING, "Mixin target " + softTarget + " is public and must be specified in value", this, suppressedBy);
return null;
}
@@ -42,6 +42,7 @@ import org.spongepowered.asm.util.ConstraintParser;
import org.spongepowered.asm.util.ConstraintParser.Constraint;
import org.spongepowered.asm.util.throwables.ConstraintViolationException;
import org.spongepowered.asm.util.throwables.InvalidConstraintException;
import org.spongepowered.tools.obfuscation.interfaces.IMessagerSuppressible;
import org.spongepowered.tools.obfuscation.interfaces.IMixinAnnotationProcessor;
import org.spongepowered.tools.obfuscation.interfaces.IObfuscationManager;
import org.spongepowered.tools.obfuscation.mapping.IMappingConsumer;
@@ -97,6 +98,10 @@ abstract class AnnotatedMixinElementHandler {
messager.printMessage(kind, msg, this.element, this.annotation.asMirror());
}
public final void printMessage(IMessagerSuppressible messager, Diagnostic.Kind kind, CharSequence msg, SuppressedBy suppressedBy) {
messager.printMessage(kind, msg, this.element, this.annotation.asMirror(), suppressedBy);
}
}
/**
@@ -52,6 +52,8 @@ import org.spongepowered.tools.obfuscation.mirror.FieldHandle;
import org.spongepowered.tools.obfuscation.mirror.MethodHandle;
import org.spongepowered.tools.obfuscation.mirror.TypeHandle;
import org.spongepowered.tools.obfuscation.mirror.TypeUtils;
import org.spongepowered.tools.obfuscation.mirror.TypeUtils.Equivalency;
import org.spongepowered.tools.obfuscation.mirror.TypeUtils.EquivalencyResult;
import com.google.common.base.Strings;
@@ -349,11 +351,23 @@ public class AnnotatedMixinElementHandlerAccessor extends AnnotatedMixinElementH
}
private void registerFactoryForTarget(AnnotatedElementInvoker elem, TypeHandle target) {
if (!elem.getReturnType().equals(target.getType())) {
throw new RuntimeException("Invalid Factory @Invoker return type, expected " + target.getType());
EquivalencyResult equivalency = TypeUtils.isEquivalentType(this.ap.getProcessingEnvironment(), elem.getReturnType(), target.getType());
if (equivalency.type != Equivalency.EQUIVALENT) {
if (equivalency.type == Equivalency.EQUIVALENT_BUT_RAW && equivalency.rawType == 1) {
elem.printMessage(this.ap, Kind.WARNING, "Raw return type for Factory @Invoker", SuppressedBy.RAW_TYPES);
} else if (equivalency.type == Equivalency.BOUNDS_MISMATCH) {
elem.printMessage(this.ap, Kind.ERROR, "Invalid Factory @Invoker return type, generic type arguments of " + target.getType()
+ " are incompatible with " + elem.getReturnType() + ". " + equivalency);
return;
} else {
elem.printMessage(this.ap, Kind.ERROR, "Invalid Factory @Invoker return type, expected " + target.getType() + " but found "
+ elem.getReturnType());
return;
}
}
if (!elem.isStatic()) {
throw new RuntimeException("Factory @Invoker must be static");
elem.printMessage(this.ap, Kind.ERROR, "Factory @Invoker must be static");
return;
}
if (!elem.shouldRemap()) {
@@ -62,7 +62,18 @@ public enum SuppressedBy {
* Suppress warnings when a mixin target specified by name is located in the
* default package
*/
DEFAULT_PACKAGE("default-package");
DEFAULT_PACKAGE("default-package"),
/**
* Suppress warnings when a mixin target is resolved by the AP as visible
* but cannot be referenced with a class literal for some reason
*/
PUBLIC_TARGET("public-target"),
/**
* The default java "raw types" suppressions
*/
RAW_TYPES("rawtypes");
private final String token;
@@ -226,7 +226,16 @@ public class TypeHandle {
* Get whether the element is probably public
*/
public boolean isPublic() {
return this.getTargetElement() != null && this.getTargetElement().getModifiers().contains(Modifier.PUBLIC);
TypeElement targetElement = this.getTargetElement();
if (targetElement == null || !targetElement.getModifiers().contains(Modifier.PUBLIC)) {
return false;
}
for (Element e = targetElement.getEnclosingElement(); e != null && e.getKind() != ElementKind.PACKAGE; e = e.getEnclosingElement()) {
if (!e.getModifiers().contains(Modifier.PUBLIC)) {
return false;
}
}
return true;
}
/**
@@ -24,20 +24,23 @@
*/
package org.spongepowered.tools.obfuscation.mirror;
import java.util.List;
import javax.annotation.processing.ProcessingEnvironment;
import javax.lang.model.element.Element;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.Modifier;
import javax.lang.model.element.Name;
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.TypeKind;
import javax.lang.model.type.TypeMirror;
import javax.lang.model.type.TypeVariable;
import org.spongepowered.asm.util.Bytecode;
import org.spongepowered.asm.util.Constants;
import org.spongepowered.asm.util.SignaturePrinter;
@@ -45,7 +48,91 @@ import org.spongepowered.asm.util.SignaturePrinter;
* Convenience functions for mirror types
*/
public abstract class TypeUtils {
/**
* Result type returned by {@link TypeUtils#isEquivalentType}
*/
public enum Equivalency {
/**
* Types are not equivalent
*/
NOT_EQUIVALENT,
/**
* Types are equivalent, but one type is raw
*/
EQUIVALENT_BUT_RAW,
/**
* Types are equivalent, but generic type parameters do not match
*/
BOUNDS_MISMATCH,
/**
* Types are equivalent, any generic type parameters are also equivalent
* or both types are raw
*/
EQUIVALENT
}
/**
* Result bundle from a type equivalency check. See
* {@link TypeUtils#isEquivalentType} for details
*/
public static class EquivalencyResult {
/**
* Singleton for equivalent type results
*/
static final EquivalencyResult EQUIVALENT = new EquivalencyResult(Equivalency.EQUIVALENT, "", 0);
/**
* The equivalency result type
*/
public final Equivalency type;
/**
* Detail string for use in user-facing error messages describing the
* nature of match failures
*/
public final String detail;
/**
* For {@link Equivalency#EQUIVALENT_BUT_RAW} indicates which argument
* was the raw one. This should only ever have the values 0 (for not
* relevant), 1 or 2. It is up to the outer scope (the caller) to
* determine whether to warn based on the rawness of the respective
* "left" and "right" types.
*/
public final int rawType;
EquivalencyResult(Equivalency type, String detail, int rawType) {
this.type = type;
this.detail = detail;
this.rawType = rawType;
}
@Override
public String toString() {
return this.detail;
}
static EquivalencyResult notEquivalent(String format, Object... args) {
return new EquivalencyResult(Equivalency.NOT_EQUIVALENT, String.format(format, args), 0);
}
static EquivalencyResult boundsMismatch(String format, Object... args) {
return new EquivalencyResult(Equivalency.BOUNDS_MISMATCH, String.format(format, args), 0);
}
static EquivalencyResult equivalentButRaw(int rawType) {
return new EquivalencyResult(Equivalency.EQUIVALENT_BUT_RAW, String.format("Type %d is raw", rawType), rawType);
}
}
/**
* Number of times to recurse into TypeMirrors when trying to determine the
* upper bound of a TYPEVAR
@@ -193,7 +280,9 @@ public abstract class TypeUtils {
* @return type name
*/
public static String getSimpleName(TypeMirror type) {
return Bytecode.getSimpleName(TypeUtils.getTypeName(type));
String name = TypeUtils.getTypeName(type);
int pos = name.lastIndexOf('.');
return pos > 0 ? name.substring(pos + 1) : name;
}
/**
@@ -372,6 +461,25 @@ public abstract class TypeUtils {
}
return null;
}
private static String describeGenericBound(TypeMirror type) {
if (type instanceof TypeVariable) {
StringBuilder description = new StringBuilder("<");
TypeVariable typeVar = (TypeVariable)type;
description.append(typeVar.toString());
TypeMirror lowerBound = typeVar.getLowerBound();
if (lowerBound.getKind() != TypeKind.NULL) {
description.append(" super ").append(lowerBound);
}
TypeMirror upperBound = typeVar.getUpperBound();
if (upperBound.getKind() != TypeKind.NULL) {
description.append(" extends ").append(upperBound);
}
return description.append(">").toString();
}
return type.toString();
}
/**
* Get whether the target type is assignable to the specified superclass
@@ -391,9 +499,79 @@ public abstract class TypeUtils {
return assignable;
}
/**
* Get whether the two supplied type mirrors represent the same type. For
* generic types the type arguments must also be equivalent in order to
* fully satisfy the equivalence condition. If one of the supplied types is
* a raw type then a relevant result indicated by <tt>EQUIVALENT_BUT_RAW
* </tt> will be returned and the caller can inspect which argument (t1 or
* t2) was raw by querying the <tt>rawType</tt> member.
*
* @param processingEnv processing environment
* @param t1 first type for comparison
* @param t2 second type for comparison
* @return true if the supplied types are equivalent
*/
public static EquivalencyResult isEquivalentType(ProcessingEnvironment processingEnv, TypeMirror t1, TypeMirror t2) {
if (t1 == null || t2 == null) {
return EquivalencyResult.notEquivalent("Invalid types supplied: %s, %s", t1, t2);
}
if (processingEnv.getTypeUtils().isSameType(t1, t2)) {
return EquivalencyResult.EQUIVALENT;
}
if (t1 instanceof TypeVariable && t2 instanceof TypeVariable) {
t1 = TypeUtils.getUpperBound(t1);
t2 = TypeUtils.getUpperBound(t2);
if (processingEnv.getTypeUtils().isSameType(t1, t2)) {
return EquivalencyResult.EQUIVALENT;
}
}
if (t1 instanceof DeclaredType && t2 instanceof DeclaredType) {
DeclaredType dtT1 = (DeclaredType)t1;
DeclaredType dtT2 = (DeclaredType)t2;
TypeMirror rawT1 = TypeUtils.toRawType(processingEnv, dtT1);
TypeMirror rawT2 = TypeUtils.toRawType(processingEnv, dtT2);
if (!processingEnv.getTypeUtils().isSameType(rawT1, rawT2)) {
return EquivalencyResult.notEquivalent("Base types %s and %s are not compatible", rawT1, rawT2);
}
List<? extends TypeMirror> argsT1 = dtT1.getTypeArguments();
List<? extends TypeMirror> argsT2 = dtT2.getTypeArguments();
if (argsT1.size() != argsT2.size()) {
if (argsT1.size() == 0) {
return EquivalencyResult.equivalentButRaw(1);
}
if (argsT2.size() == 0) {
return EquivalencyResult.equivalentButRaw(2);
}
return EquivalencyResult.notEquivalent("Mismatched generic argument counts %s<[%d]> and %s<[%d]>", rawT1, argsT1.size(), rawT2, argsT2.size());
}
for (int arg = 0; arg < argsT1.size(); arg++) {
TypeMirror argT1 = argsT1.get(arg);
TypeMirror argT2 = argsT2.get(arg);
if (TypeUtils.isEquivalentType(processingEnv, argT1, argT2).type != Equivalency.EQUIVALENT) {
return EquivalencyResult.boundsMismatch("Generic bounds mismatch between %s and %s",
TypeUtils.describeGenericBound(argT1), TypeUtils.describeGenericBound(argT2));
}
}
return EquivalencyResult.EQUIVALENT;
}
return EquivalencyResult.notEquivalent("%s and %s do not match", t1, t2);
}
private static TypeMirror toRawType(ProcessingEnvironment processingEnv, DeclaredType targetType) {
return processingEnv.getElementUtils().getTypeElement(((TypeElement)targetType.asElement()).getQualifiedName()).asType();
if (targetType.getKind() == TypeKind.INTERSECTION) {
return targetType;
}
Name qualifiedName = ((TypeElement)targetType.asElement()).getQualifiedName();
TypeElement typeElement = processingEnv.getElementUtils().getTypeElement(qualifiedName);
return typeElement != null ? typeElement.asType() : targetType;
}
/**
@@ -139,16 +139,23 @@ public class MixinPlatformAgentFMLLegacy extends MixinPlatformAgentAbstract impl
private boolean initInjectionState;
@Override
public boolean accept(MixinPlatformManager manager, IContainerHandle handle) {
if (!(handle instanceof ContainerHandleURI) || !super.accept(manager, handle)) {
return false;
public AcceptResult accept(MixinPlatformManager manager, IContainerHandle handle) {
try {
this.clCoreModManager = MixinPlatformAgentFMLLegacy.getCoreModManagerClass();
} catch (ClassNotFoundException ex) {
MixinPlatformAgentAbstract.logger.info("FML platform manager could not load class {}. Proceeding without FML support.",
ex.getMessage());
return AcceptResult.INVALID;
}
if (!(handle instanceof ContainerHandleURI) || super.accept(manager, handle) != AcceptResult.ACCEPTED) {
return AcceptResult.REJECTED;
}
this.file = ((ContainerHandleURI)handle).getFile();
this.fileName = this.file.getName();
this.coreModWrapper = this.initFMLCoreMod();
return true;
return this.coreModWrapper != null ? AcceptResult.ACCEPTED : AcceptResult.REJECTED;
}
/**
@@ -156,14 +163,6 @@ public class MixinPlatformAgentFMLLegacy extends MixinPlatformAgentAbstract impl
*/
private ITweaker initFMLCoreMod() {
try {
try {
this.clCoreModManager = MixinPlatformAgentFMLLegacy.getCoreModManagerClass();
} catch (ClassNotFoundException ex) {
MixinPlatformAgentAbstract.logger.info("FML platform manager could not load class {}. Proceeding without FML support.",
ex.getMessage());
return null;
}
if ("true".equalsIgnoreCase(this.handle.getAttribute(MixinPlatformAgentFMLLegacy.MFATT_FORCELOADASMOD))) {
MixinPlatformAgentAbstract.logger.debug("ForceLoadAsMod was specified for {}, attempting force-load", this.fileName);
this.loadAsMod();
@@ -424,7 +423,11 @@ public class MixinPlatformAgentFMLLegacy extends MixinPlatformAgentAbstract impl
public String getSideName() {
// Using this method first prevents us from accidentally loading FML
// classes too early when using the tweaker in dev
for (ITweaker tweaker : GlobalProperties.<List<ITweaker>>get(MixinServiceLaunchWrapper.BLACKBOARD_KEY_TWEAKS)) {
List<ITweaker> tweakerList = GlobalProperties.<List<ITweaker>>get(MixinServiceLaunchWrapper.BLACKBOARD_KEY_TWEAKS);
if (tweakerList == null) {
return null;
}
for (ITweaker tweaker : tweakerList) {
if (tweaker.getClass().getName().endsWith(MixinPlatformAgentFMLLegacy.SERVER_TWEAKER_TAIL)) {
return Constants.SIDE_SERVER;
} else if (tweaker.getClass().getName().endsWith(MixinPlatformAgentFMLLegacy.CLIENT_TWEAKER_TAIL)) {
@@ -39,8 +39,8 @@ public class MixinPlatformAgentLiteLoaderLegacy extends MixinPlatformAgentAbstra
private static final String LITELOADER_TWEAKER_NAME = "com.mumfrey.liteloader.launch.LiteLoaderTweaker";
@Override
public boolean accept(MixinPlatformManager manager, IContainerHandle handle) {
return false;
public AcceptResult accept(MixinPlatformManager manager, IContainerHandle handle) {
return AcceptResult.REJECTED;
}
/* (non-Javadoc)
@@ -38,6 +38,29 @@ import org.spongepowered.asm.launch.platform.container.IContainerHandle;
*/
public interface IMixinPlatformAgent {
/**
* Result type returned from {@link IMixinPlatformAgent#accept}
*/
public enum AcceptResult {
/**
* The container was accepted
*/
ACCEPTED,
/**
* The container was rejected
*/
REJECTED,
/**
* The agent encountered an error and no further containers should be
* offered
*/
INVALID;
}
/**
* Accept and bind to a container handle. This method is called for agents
* hosted by {@link MixinContainer} and the agent should react accordingly.
@@ -47,11 +70,10 @@ public interface IMixinPlatformAgent {
*
* @param manager platform manager instance
* @param handle handle to container
* @return true if this agent can accept a container of the supplied type,
* false if the agent cannot handle the container (in which case it
* will be discarded)
* @return AcceptResult representing this agent's acceptance of the supplied
* container
*/
public abstract boolean accept(MixinPlatformManager manager, IContainerHandle handle);
public abstract AcceptResult accept(MixinPlatformManager manager, IContainerHandle handle);
/**
* Get the phase provider for this agent
@@ -28,6 +28,7 @@ import java.util.Collection;
import org.spongepowered.asm.launch.platform.container.IContainerHandle;
import org.spongepowered.asm.mixin.MixinEnvironment.Phase;
import org.spongepowered.asm.util.Constants;
import org.spongepowered.asm.util.IConsumer;
/**
@@ -43,7 +44,10 @@ public interface IMixinPlatformServiceAgent extends IMixinPlatformAgent {
public abstract void init();
/**
* Attempt to determine the side name from the current environment
* Attempt to determine the side name from the current environment. Return
* <tt>null</tt> if the side name cannot be determined by this agent. Return
* side name or {@link Constants#SIDE_UNKNOWN} if the agent is able to
* determine the side.
*/
public abstract String getSideName();
@@ -26,11 +26,13 @@ package org.spongepowered.asm.launch.platform;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.spongepowered.asm.launch.GlobalProperties;
import org.spongepowered.asm.launch.platform.IMixinPlatformAgent.AcceptResult;
import org.spongepowered.asm.launch.platform.container.IContainerHandle;
import org.spongepowered.asm.service.MixinService;
@@ -59,22 +61,25 @@ public class MixinContainer {
public MixinContainer(MixinPlatformManager manager, IContainerHandle handle) {
this.handle = handle;
for (String agentClass : MixinContainer.agentClasses) {
for (Iterator<String> iter = MixinContainer.agentClasses.iterator(); iter.hasNext();) {
String agentClass = iter.next();
try {
@SuppressWarnings("unchecked")
Class<IMixinPlatformAgent> clazz = (Class<IMixinPlatformAgent>)Class.forName(agentClass);
String simpleName = clazz.getSimpleName();
String acceptAction = "rejected";
MixinContainer.logger.debug("Instancing new {} for {}", simpleName, this.handle);
IMixinPlatformAgent agent = clazz.newInstance();
if (agent.accept(manager, this.handle)) {
AcceptResult acceptAction = agent.accept(manager, this.handle);
if (acceptAction == AcceptResult.ACCEPTED) {
this.agents.add(agent);
acceptAction = "accepted";
} else if (acceptAction == AcceptResult.INVALID) {
iter.remove();
continue;
}
MixinContainer.logger.debug("{} {} container {}", simpleName, acceptAction, this.handle);
MixinContainer.logger.debug("{} {} container {}", simpleName, acceptAction.name().toLowerCase(), this.handle);
} catch (InstantiationException ex) {
Throwable cause = ex.getCause();
if (cause instanceof RuntimeException) {
@@ -56,10 +56,10 @@ public abstract class MixinPlatformAgentAbstract implements IMixinPlatformAgent
}
@Override
public boolean accept(MixinPlatformManager manager, IContainerHandle handle) {
public AcceptResult accept(MixinPlatformManager manager, IContainerHandle handle) {
this.manager = manager;
this.handle = handle;
return true;
return AcceptResult.ACCEPTED;
}
@Override
@@ -33,6 +33,7 @@ import java.util.Locale;
import java.util.Map;
import java.util.Set;
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.spongepowered.asm.launch.GlobalProperties;
@@ -1041,7 +1042,14 @@ public final class MixinEnvironment implements ITokenProvider {
return "Unknown";
}
}
/**
* Get logging level info/debug based on verbose setting
*/
private Level getVerboseLoggingLevel() {
return this.getOption(Option.DEBUG_VERBOSE) ? Level.INFO : Level.DEBUG;
}
/**
* Get the phase for this environment
*
@@ -1119,7 +1127,7 @@ public final class MixinEnvironment implements ITokenProvider {
if (provider != null && !this.tokenProviderClasses.contains(provider.getClass().getName())) {
String providerName = provider.getClass().getName();
TokenProviderWrapper wrapper = new TokenProviderWrapper(provider, this);
MixinEnvironment.logger.info("Adding new token provider {} to {}", providerName, this);
MixinEnvironment.logger.log(this.getVerboseLoggingLevel(), "Adding new token provider {} to {}", providerName, this);
this.tokenProviders.add(wrapper);
this.tokenProviderClasses.add(providerName);
Collections.sort(this.tokenProviders);
@@ -35,6 +35,7 @@ import org.objectweb.asm.tree.MethodNode;
import org.objectweb.asm.tree.VarInsnNode;
import org.spongepowered.asm.mixin.injection.InjectionPoint;
import org.spongepowered.asm.mixin.injection.ModifyVariable;
import org.spongepowered.asm.mixin.injection.InjectionPoint.RestrictTargetLevel;
import org.spongepowered.asm.mixin.injection.code.Injector;
import org.spongepowered.asm.mixin.injection.struct.InjectionInfo;
import org.spongepowered.asm.mixin.injection.struct.Target;
@@ -121,16 +122,12 @@ public class ModifyVariableInjector extends Injector {
protected void sanityCheck(Target target, List<InjectionPoint> injectionPoints) {
super.sanityCheck(target, injectionPoints);
if (target.isStatic != this.isStatic) {
throw new InvalidInjectionException(this.info, "'static' of variable modifier method does not match target in " + this);
}
int ordinal = this.discriminator.getOrdinal();
if (ordinal < -1) {
throw new InvalidInjectionException(this.info, "Invalid ordinal " + ordinal + " specified in " + this);
}
if (this.discriminator.getIndex() == 0 && !this.isStatic) {
if (this.discriminator.getIndex() == 0 && !target.isStatic) {
throw new InvalidInjectionException(this.info, "Invalid index 0 specified in non-static variable modifier " + this);
}
}
@@ -149,6 +146,8 @@ public class ModifyVariableInjector extends Injector {
if (this.discriminator.printLVT()) {
this.printLocals(target, context);
}
this.checkTargetForNode(target, node, RestrictTargetLevel.ALLOW_ALL);
InjectorData handler = new InjectorData(target, "handler", false);
this.validateParams(handler, this.returnType, this.returnType);
@@ -72,10 +72,27 @@ import com.google.common.collect.ImmutableSet;
*/
public final class ClassInfo {
/**
* Include <tt>private</tt> members when running a member search
*/
public static final int INCLUDE_PRIVATE = Opcodes.ACC_PRIVATE;
/**
* Include <tt>static</tt> members when running a member search
*/
public static final int INCLUDE_STATIC = Opcodes.ACC_STATIC;
/**
* Include <tt>private</tt> <b>and</b> <tt>static</tt> members when running
* a member search
*/
public static final int INCLUDE_ALL = ClassInfo.INCLUDE_PRIVATE | ClassInfo.INCLUDE_STATIC;
/**
* Include instance and class initialisers when running a method search
*/
public static final int INCLUDE_INITIALISERS = 0x40000;
/**
* Search type for the findInHierarchy methods, replaces a boolean flag
* which made calling code difficult to read
@@ -682,9 +699,14 @@ public final class ClassInfo {
* Interfaces
*/
private final Set<String> interfaces;
/**
* Constructors and initialisers in this class
*/
private final Set<Method> initialisers;
/**
* Public and protected methods (instance) methods in this class
* Methods in this class
*/
private final Set<Method> methods;
@@ -754,6 +776,9 @@ public final class ClassInfo {
this.superName = null;
this.outerName = null;
this.isProbablyStatic = true;
this.initialisers = ImmutableSet.<Method>of(
new Method("<init>", "()V")
);
this.methods = ImmutableSet.<Method>of(
new Method("getClass", "()Ljava/lang/Class;"),
new Method("hashCode", "()I"),
@@ -787,6 +812,7 @@ public final class ClassInfo {
try {
this.name = classNode.name;
this.superName = classNode.superName != null ? classNode.superName : ClassInfo.JAVA_LANG_OBJECT;
this.initialisers = new HashSet<Method>();
this.methods = new HashSet<Method>();
this.fields = new HashSet<Field>();
this.isInterface = ((classNode.access & Opcodes.ACC_INTERFACE) != 0);
@@ -839,7 +865,9 @@ public final class ClassInfo {
}
private void addMethod(MethodNode method, boolean injected) {
if (!method.name.startsWith("<")) {
if (method.name.startsWith("<")) {
this.initialisers.add(new Method(method, injected));
} else {
this.methods.add(new Method(method, injected));
}
}
@@ -1740,8 +1768,8 @@ public final class ClassInfo {
* @param memberType Type of member list to search
* @return the field object or null if the field could not be resolved
*/
@SuppressWarnings("unchecked")
private <M extends Member> M findMember(String name, String desc, int flags, Type memberType) {
@SuppressWarnings("unchecked")
Set<M> members = (Set<M>)(memberType == Type.METHOD ? this.methods : this.fields);
for (M member : members) {
@@ -1749,6 +1777,14 @@ public final class ClassInfo {
return member;
}
}
if (memberType == Type.METHOD && (flags & ClassInfo.INCLUDE_INITIALISERS) != 0) {
for (Method ctor : this.initialisers) {
if (ctor.equals(name, desc) && ctor.matchesFlags(flags)) {
return (M)ctor;
}
}
}
return null;
}
@@ -37,6 +37,7 @@ import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.Handle;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
@@ -44,6 +45,7 @@ import org.objectweb.asm.tree.AnnotationNode;
import org.objectweb.asm.tree.ClassNode;
import org.objectweb.asm.tree.FieldNode;
import org.objectweb.asm.tree.InnerClassNode;
import org.objectweb.asm.tree.InvokeDynamicInsnNode;
import org.objectweb.asm.tree.MethodNode;
import org.spongepowered.asm.mixin.Implements;
import org.spongepowered.asm.mixin.Mixin;
@@ -91,6 +93,17 @@ class MixinInfo implements Comparable<MixinInfo>, IMixinInfo {
public MixinMethodNode(int access, String name, String desc, String signature, String[] exceptions) {
super(access, name, desc, signature, exceptions, MixinInfo.this);
}
@Override
public void visitInvokeDynamicInsn(String name, String descriptor, Handle bootstrapMethodHandle, Object... bootstrapMethodArguments) {
// Create a shallow copy of the bootstrap method args because the
// base implementation just passes the array by reference. This
// causes any changes applied to the cloned classnode to leak into
// the "master" ClassNode!
Object[] bsmArgs = new Object[bootstrapMethodArguments.length];
System.arraycopy(bootstrapMethodArguments, 0, bsmArgs, 0, bootstrapMethodArguments.length);
this.instructions.add(new InvokeDynamicInsnNode(name, descriptor, bootstrapMethodHandle, bsmArgs));
}
public boolean isInjector() {
return (this.getInjectorAnnotation() != null || this.isSurrogate());
@@ -500,17 +500,18 @@ class MixinPreProcessorStandard {
return false;
}
if (method.isSynthetic()) {
boolean synthetic = method.isSynthetic();
if (synthetic) {
context.transformDescriptor(mixinMethod);
method.remapTo(mixinMethod.desc);
}
MethodNode target = context.findMethod(mixinMethod, null);
if (target == null) {
if (target == null && !synthetic) {
return false;
}
String type = method.isSynthetic() ? "synthetic" : "@Unique";
String type = synthetic ? "synthetic" : "@Unique";
if (Bytecode.getVisibility(mixinMethod).ordinal() < Visibility.PUBLIC.ordinal()) {
if (method.isConformed()) {
@@ -524,6 +525,10 @@ class MixinPreProcessorStandard {
return false;
}
if (target == null) {
return false;
}
if (this.strictUnique) {
throw new InvalidMixinException(this.mixin, String.format("Method conflict, %s method %s in %s cannot overwrite %s%s in %s",
type, mixinMethod.name, this.mixin, target.name, target.desc, context.getTarget()));
@@ -371,13 +371,14 @@ final class TargetClassContext extends ClassContext implements ITargetClassConte
* Process {@link Debug} annotations on the class after application
*/
void processDebugTasks() {
AnnotationNode classDebugAnnotation = Annotations.getVisible(this.classNode, Debug.class);
this.forceExport = classDebugAnnotation != null && Boolean.TRUE.equals(Annotations.<Boolean>getValue(classDebugAnnotation, "export"));
if (!this.env.getOption(Option.DEBUG_VERBOSE)) {
return;
}
AnnotationNode classDebugAnnotation = Annotations.getVisible(this.classNode, Debug.class);
if (classDebugAnnotation != null) {
this.forceExport = Boolean.TRUE.equals(Annotations.<Boolean>getValue(classDebugAnnotation, "export"));
if (Boolean.TRUE.equals(Annotations.<Boolean>getValue(classDebugAnnotation, "print"))) {
Bytecode.textify(this.classNode, System.err);
}
@@ -429,10 +429,14 @@ public final class Bytecode {
out += String.format("[%s] %d", Bytecode.getOpcodeName(node), ((VarInsnNode)node).var);
} else if (node instanceof MethodInsnNode) {
MethodInsnNode mth = (MethodInsnNode)node;
out += String.format("[%s] %s %s %s", Bytecode.getOpcodeName(node), mth.owner, mth.name, mth.desc);
out += String.format("[%s] %s::%s%s", Bytecode.getOpcodeName(node), mth.owner, mth.name, mth.desc);
} else if (node instanceof FieldInsnNode) {
FieldInsnNode fld = (FieldInsnNode)node;
out += String.format("[%s] %s %s %s", Bytecode.getOpcodeName(node), fld.owner, fld.name, fld.desc);
out += String.format("[%s] %s::%s:%s", Bytecode.getOpcodeName(node), fld.owner, fld.name, fld.desc);
} else if (node instanceof InvokeDynamicInsnNode) {
InvokeDynamicInsnNode idc = (InvokeDynamicInsnNode)node;
out += String.format("[%s] %s%s { %s %s::%s%s }", Bytecode.getOpcodeName(node), idc.name, idc.desc,
Bytecode.getOpcodeName(idc.bsm.getTag(), "H_GETFIELD", 1), idc.bsm.getOwner(), idc.bsm.getName(), idc.bsm.getDesc());
} else if (node instanceof LineNumberNode) {
LineNumberNode ln = (LineNumberNode)node;
out += String.format("LINE=[%d] LABEL=[%s]", ln.line, ln.start.getLabel());
@@ -142,7 +142,7 @@ public final class Locals {
if (classInfo == null) {
throw new LVTGeneratorError("Could not load class metadata for " + classNode.name + " generating LVT for " + method.name);
}
Method methodInfo = classInfo.findMethod(method);
Method methodInfo = classInfo.findMethod(method, method.access | ClassInfo.INCLUDE_INITIALISERS);
if (methodInfo == null) {
throw new LVTGeneratorError("Could not locate method metadata for " + method.name + " generating LVT in " + classNode.name);
}
@@ -24,8 +24,9 @@
*/
package org.spongepowered.asm.util.asm;
import java.lang.reflect.Field;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.tree.ClassNode;
/**
* Utility methods for determining ASM version and other version-specific
@@ -33,57 +34,71 @@ import org.objectweb.asm.tree.ClassNode;
*/
public final class ASM {
@SuppressWarnings("deprecation")
private static final int[] EXPERIMENTAL_VERSIONS = { };
private static final int[] SUPPORTED_VERSIONS = { Opcodes.ASM6, Opcodes.ASM5, Opcodes.ASM7 };
private static int majorVersion = 5;
private static int minorVersion = 0;
private static String maxVersion = "FALLBACK";
/**
* The detected ASM API Version
*/
public static final int API_VERSION = ASM.detectVersion();
private static boolean experimental;
private ASM() {
}
/**
* Get the major API version
*/
public static int getApiVersionMajor() {
return ASM.majorVersion;
}
/**
* Get the minor API version
*/
public static int getApiVersionMinor() {
return ASM.minorVersion;
}
/**
* Get the ASM API version as a string (mostly for debugging and the banner)
*
* @return ASM API version as string
*/
public static String getApiVersionString() {
String suffix = "";
if (ASM.experimental) {
int version = ASM.detectVersion(ASM.SUPPORTED_VERSIONS);
suffix = String.format("-EXPERIMENTAL (%d.%d)", ((0xFF0000 & version) >> 16), ((0xFF00 & version) >> 8));
}
return String.format("ASM %d.%d%s", ((0xFF0000 & ASM.API_VERSION) >> 16), ((0xFF00 & ASM.API_VERSION) >> 8), suffix);
return String.format("ASM %d.%d (%s)", ASM.majorVersion, ASM.minorVersion, ASM.maxVersion);
}
private static int detectVersion() {
int expVersion = ASM.detectVersion(ASM.EXPERIMENTAL_VERSIONS);
if (expVersion > 0) {
ASM.experimental = true;
return expVersion;
}
int apiVersion = Opcodes.ASM4;
ASM.experimental = false;
int version = ASM.detectVersion(ASM.SUPPORTED_VERSIONS);
if (version > 0) {
return version;
}
return Opcodes.ASM5;
}
private static int detectVersion(int[] versions) {
for (int version : versions) {
for (Field field : Opcodes.class.getDeclaredFields()) {
if (field.getType() != Integer.TYPE || !field.getName().startsWith("ASM")) {
continue;
}
try {
new ClassNode(version).hashCode();
return version;
} catch (IllegalArgumentException ex) {
// expected, this version is not supported
int version = field.getInt(null);
// int patch = version & 0xFF;
int minor = (version >> 8) & 0xFF;
int major = (version >> 16) & 0xFF;
boolean experimental = ((version >> 24) & 0xFF) != 0;
if (major >= ASM.majorVersion) {
ASM.maxVersion = field.getName();
if (!experimental) {
apiVersion = version;
ASM.majorVersion = major;
ASM.minorVersion = minor;
}
}
} catch (ReflectiveOperationException ex) {
throw new Error(ex);
}
}
return 0;
return apiVersion;
}
}
@@ -53,9 +53,9 @@ public class MixinPlatformAgentMinecraftForge extends MixinPlatformAgentAbstract
* org.spongepowered.asm.launch.platform.container.IContainerHandle)
*/
@Override
public boolean accept(MixinPlatformManager manager, IContainerHandle handle) {
public AcceptResult accept(MixinPlatformManager manager, IContainerHandle handle) {
// No containers plz
return false;
return AcceptResult.REJECTED;
}
/* (non-Javadoc)
@@ -91,11 +91,7 @@ public class ModLauncherClassTracker implements IClassProcessor, IClassTracker {
}
}
synchronized (this.loadedClasses) {
this.loadedClasses.add(name);
}
return Phases.NONE;
return Phases.AFTER_ONLY;
}
/* (non-Javadoc)
@@ -106,6 +102,10 @@ public class ModLauncherClassTracker implements IClassProcessor, IClassTracker {
*/
@Override
public boolean processClass(Phase phase, ClassNode classNode, Type classType, String reason) {
synchronized (this.loadedClasses) {
this.loadedClasses.add(classType.getClassName());
}
return false;
}