Skip redundant wrapped post-time listener checks in more cases (#98)

Enhances the optimisation made in #85 to support also checking the permitted subclasses when the event type is sealed and running on Java 17+

Author: PaintNinja

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

@@ -5,6 +5,7 @@
 package net.minecraftforge.eventbus;
 
 import net.minecraftforge.eventbus.api.*;
+import net.minecraftforge.eventbus.internal.InternalUtils;
 
 import java.lang.reflect.*;
 import static org.objectweb.asm.Type.getMethodDescriptor;
@@ -77,7 +78,7 @@ public static ASMEventHandler of(IEventListenerFactory factory, Object target, M
         var subInfo = method.getAnnotation(SubscribeEvent.class);
         assert subInfo != null;
         var eventType = method.getParameterTypes()[0];
-        if (isGeneric || !Modifier.isFinal(eventType.getModifiers()) || EventListenerHelper.isCancelable(eventType))
+        if (InternalUtils.couldBeCancelled(eventType, isGeneric))
             return new ASMEventHandler(factory, target, method, isGeneric, subInfo);
 
         // If we get to this point, no post-time checks are needed, so strip them out

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

@@ -6,6 +6,7 @@
 
 import net.jodah.typetools.TypeResolver;
 import net.minecraftforge.eventbus.api.*;
+import net.minecraftforge.eventbus.internal.InternalUtils;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.objectweb.asm.Type;
@@ -252,7 +253,7 @@ private <T extends Event> void addListener(final EventPriority priority, final P
         }
 
         @SuppressWarnings("unchecked")
-        IEventListener listener = Modifier.isFinal(eventClass.getModifiers()) && (filter == checkCancelled || filter == null) && !EventListenerHelper.isCancelable(eventClass)
+        IEventListener listener = (filter == checkCancelled || filter == null) && !InternalUtils.couldBeCancelled(eventClass)
                 ? e -> consumer.accept((T) e)
                 : e -> doCastFilter(filter, eventClass, consumer, e);
 

src/main/java/net/minecraftforge/eventbus/internal/InternalUtils.java

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) Forge Development LLC
+ * SPDX-License-Identifier: LGPL-2.1-only
+ */
+package net.minecraftforge.eventbus.internal;
+
+import net.minecraftforge.eventbus.api.EventListenerHelper;
+import net.minecraftforge.eventbus.api.IGenericEvent;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.lang.reflect.Modifier;
+
+public final class InternalUtils {
+    private InternalUtils() {}
+
+    private static final MethodHandle GET_PERMITTED_SUBCLASSES;
+    static {
+        var lookup = MethodHandles.lookup();
+        var methodType = MethodType.methodType(Class[].class);
+        if (Runtime.version().feature() >= 17) {
+            try {
+                GET_PERMITTED_SUBCLASSES = lookup
+                        .findVirtual(Class.class, "getPermittedSubclasses", methodType)
+                        .asType(methodType.insertParameterTypes(0, Class.class));
+            } catch (Exception e) {
+                throw new ExceptionInInitializerError("Failed to find Class#getPermittedSubclasses(Class): " + e);
+            }
+        } else {
+            GET_PERMITTED_SUBCLASSES = MethodHandles.empty(methodType.insertParameterTypes(0, Class.class));
+        }
+    }
+
+    public static Class<?>[] getPermittedSubclasses(Class<?> clazz) {
+        try {
+            return (Class<?>[]) GET_PERMITTED_SUBCLASSES.invokeExact(clazz);
+        } catch (Throwable e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * @param eventType the event type to check
+     * @return true if the given event type could be cancelled by a listener for a subclass of the given event type
+     */
+    public static boolean couldBeCancelled(Class<?> eventType) {
+        return couldBeCancelled(eventType, IGenericEvent.class.isAssignableFrom(eventType));
+    }
+
+    /**
+     * @param eventType the event type to check
+     * @param isGenericEvent true if the given event type is a generic event type
+     * @return true if the given event type could be cancelled by a listener for a subclass of the given event type
+     */
+    public static boolean couldBeCancelled(Class<?> eventType, boolean isGenericEvent) {
+        if (isGenericEvent || EventListenerHelper.isCancelable(eventType)) return true;
+        if (Modifier.isFinal(eventType.getModifiers())) return false;
+
+        var permittedSubclasses = getPermittedSubclasses(eventType);
+        if (permittedSubclasses == null || permittedSubclasses.length == 0) return true;
+
+        for (var subclass : permittedSubclasses)
+            if (couldBeCancelled(subclass))
+                return true;
+
+        return false;
+    }
+}