Strip redundant wrapped post-time listener checks (#85)

Further improves the performance of posting events that are final, non-`@Cancelable` and non-generic.

Author: PaintNinja

eventbus-test-jar/src/main/java/net/minecraftforge/eventbus/testjar/events/CancelableEvent.java

@@ -9,4 +9,4 @@
 import net.minecraftforge.eventbus.api.Event;
 
 @Cancelable
-public class CancelableEvent extends Event { }
+public final class CancelableEvent extends Event {}

eventbus-test-jar/src/main/java/net/minecraftforge/eventbus/testjar/events/EventWithData.java

@@ -7,7 +7,7 @@
 
 import net.minecraftforge.eventbus.api.Event;
 
-public class EventWithData extends Event {
+public final class EventWithData extends Event {
     private final String data;
     private final int foo;
     private final boolean bar;

eventbus-test-jar/src/main/java/net/minecraftforge/eventbus/testjar/events/ResultEvent.java

@@ -8,4 +8,4 @@
 import net.minecraftforge.eventbus.api.Event;
 
 @Event.HasResult
-public class ResultEvent extends Event { }
+public final class ResultEvent extends Event {}

src/main/java/net/minecraftforge/eventbus/ASMEventHandler.java

@@ -10,15 +10,23 @@
 import static org.objectweb.asm.Type.getMethodDescriptor;
 
 public class ASMEventHandler implements IEventListener {
-    private final IEventListener handler;
+    protected final IEventListener handler;
     private final SubscribeEvent subInfo;
     private final String readable;
     private final Type filter;
 
+    /**
+     * @deprecated Use {@link #of(IEventListenerFactory, Object, Method, boolean)} instead for better performance.
+     */
+    @Deprecated
     public ASMEventHandler(IEventListenerFactory factory, Object target, Method method, boolean isGeneric) throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, ClassNotFoundException {
+        this(factory, target, method, isGeneric, method.getAnnotation(SubscribeEvent.class));
+    }
+
+    private ASMEventHandler(IEventListenerFactory factory, Object target, Method method, boolean isGeneric, SubscribeEvent subInfo) throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, ClassNotFoundException {
         handler = factory.create(method, target);
 
-        subInfo = method.getAnnotation(SubscribeEvent.class);
+        this.subInfo = subInfo;
         readable = "ASM: " + target + " " + method.getName() + getMethodDescriptor(method);
         Type filter = null;
         if (isGeneric) {
@@ -54,4 +62,30 @@ public EventPriority getPriority() {
     public String toString() {
         return readable;
     }
+
+    /**
+     * Creates a new ASMEventHandler instance, factoring in a time-shifting optimisation.
+     *
+     * <p>In the case that no post-time checks are needed, an anonymous subclass instance will be returned that calls
+     * the listener without additional redundant checks.</p>
+     *
+     * @implNote The 'all or nothing' nature of the post-time checks is to reduce the likelihood of megamorphic method
+     *           invocation, which isn't as performant as monomorphic or bimorphic calls in Java 16
+     *           (what EventBus 6.2.x targets).
+     */
+    public static ASMEventHandler of(IEventListenerFactory factory, Object target, Method method, boolean isGeneric) throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, ClassNotFoundException {
+        var subInfo = method.getAnnotation(SubscribeEvent.class);
+        assert subInfo != null;
+        var eventType = method.getParameterTypes()[0];
+        if (isGeneric || !Modifier.isFinal(eventType.getModifiers()) || EventListenerHelper.isCancelable(eventType))
+            return new ASMEventHandler(factory, target, method, isGeneric, subInfo);
+
+        // If we get to this point, no post-time checks are needed, so strip them out
+        return new ASMEventHandler(factory, target, method, false, subInfo) {
+            @Override
+            public void invoke(Event event) {
+                handler.invoke(event);
+            }
+        };
+    }
 }

src/main/java/net/minecraftforge/eventbus/EventBus.java

@@ -110,7 +110,7 @@ else if (method.getDeclaringClass() != Object.class) // No need to check Object,
         }
     }
 
-    private void parentTypes(Set<Class<?>> classes, Stack<Class<?>> stack, Class<?> cls) {
+    private static void parentTypes(Set<Class<?>> classes, Stack<Class<?>> stack, Class<?> cls) {
         for (var inf : cls.getInterfaces()) {
             if (classes.add(inf))
                 stack.push(inf);
@@ -166,7 +166,7 @@ private void registerListener(final Object target, final Method method, final Me
     private static final Predicate<Event> checkCancelled = e -> !e.isCanceled();
     @SuppressWarnings("unchecked")
     private static <T extends Event> Predicate<T> passCancelled(boolean ignored) {
-        return ignored ? null : (Predicate<T>)checkCancelled;
+        return ignored ? null : (Predicate<T>) checkCancelled;
     }
 
     private static <T extends GenericEvent<? extends F>, F> Predicate<T> passGenericFilter(Class<F> type, boolean ignored) {
@@ -250,7 +250,13 @@ private <T extends Event> void addListener(final EventPriority priority, final P
             throw new IllegalArgumentException(
                     "Listener for event " + eventClass + " takes an argument that is not a subtype of the base type " + baseType);
         }
-        addToListeners(consumer, eventClass, NamedEventListener.namedWrapper(e-> doCastFilter(filter, eventClass, consumer, e), consumer.getClass()::getName), priority);
+
+        @SuppressWarnings("unchecked")
+        IEventListener listener = Modifier.isFinal(eventClass.getModifiers()) && (filter == checkCancelled || filter == null) && !EventListenerHelper.isCancelable(eventClass)
+                ? e -> consumer.accept((T) e)
+                : e -> doCastFilter(filter, eventClass, consumer, e);
+
+        addToListeners(consumer, eventClass, NamedEventListener.namedWrapper(listener, consumer.getClass()::getName), priority);
     }
 
     @SuppressWarnings("unchecked")
@@ -262,8 +268,7 @@ private static <T extends Event> void doCastFilter(final Predicate<? super T> fi
 
     private void register(Class<?> eventType, Object target, Method method) {
         try {
-            final ASMEventHandler asm = new ASMEventHandler(this.factory, target, method, IGenericEvent.class.isAssignableFrom(eventType));
-
+            ASMEventHandler asm = ASMEventHandler.of(this.factory, target, method, IGenericEvent.class.isAssignableFrom(eventType));
             addToListeners(target, eventType, asm, asm.getPriority());
         } catch (IllegalAccessException | InstantiationException | NoSuchMethodException | InvocationTargetException | ClassNotFoundException e) {
             LOGGER.error(EVENTBUS,"Error registering event handler: {} {}", eventType, method, e);

src/main/java/net/minecraftforge/eventbus/api/EventListenerHelper.java

@@ -7,6 +7,7 @@
 import net.minecraftforge.eventbus.ListenerList;
 import net.minecraftforge.eventbus.api.Event.HasResult;
 import net.minecraftforge.eventbus.internal.Cache;
+import org.jetbrains.annotations.ApiStatus;
 
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Constructor;
@@ -63,7 +64,8 @@ private static ListenerList computeListenerList(Class<?> eventClass, boolean fro
         }
     }
 
-    static boolean isCancelable(Class<?> eventClass) {
+    @ApiStatus.Internal
+    public static boolean isCancelable(Class<?> eventClass) {
         return hasAnnotation(eventClass, Cancelable.class, cancelable);
     }