Fix posting cancellable children with non-cancellable inheritable parents (#91)

Author: PaintNinja

eventbus-test/src/test/java/net/minecraftforge/eventbus/test/InheritanceTests.java

@@ -7,6 +7,7 @@
 import net.minecraftforge.eventbus.api.bus.EventBus;
 import net.minecraftforge.eventbus.api.event.InheritableEvent;
 import net.minecraftforge.eventbus.api.event.MutableEvent;
+import net.minecraftforge.eventbus.api.event.characteristic.Cancellable;
 import net.minecraftforge.eventbus.internal.EventBusImpl;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -206,4 +207,28 @@ final class SubEvent extends SuperEvent {
         SuperEvent.BUS.removeListener(listener);
     }
 
+    /**
+     * Tests that listener inheritance works when a non-{@link Cancellable} parent event implements {@link InheritableEvent}
+     * and a {@link Cancellable} child event inherits from the parent.
+     */
+    @Test
+    public void testListenerCallInheritanceWithCancellable() {
+        class SuperEvent implements InheritableEvent {
+            static final EventBus<SuperEvent> BUS = EventBus.create(SuperEvent.class);
+        }
+        final class SubEvent extends SuperEvent implements Cancellable {
+            static final EventBus<SubEvent> BUS = EventBus.create(SubEvent.class);
+        }
+
+        var handled = new AtomicBoolean();
+        var listener = SuperEvent.BUS.addListener(event -> handled.set(true));
+
+        Assertions.assertFalse(handled.get(), "SuperEvent should not be handled yet");
+
+        Assertions.assertDoesNotThrow(() -> SubEvent.BUS.post(new SubEvent()));
+
+        Assertions.assertTrue(handled.get(), "SuperEvent should be handled, even though SubEvent is cancellable");
+
+        SuperEvent.BUS.removeListener(listener);
+    }
 }

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

@@ -73,7 +73,7 @@ public WrappedConsumerListener(Class<? extends Event> eventType, byte priority,
          * @implNote We avoid capturing the alwaysCancelling field in the lambda so that the bytecode is generated as a
          *           {@code ICONST_1} or {@code ICONST_0} instruction, rather than a field load.
          */
-        private static Predicate<Event> wrap(boolean alwaysCancelling, Consumer<Event> consumer) {
+        public static Predicate<Event> wrap(boolean alwaysCancelling, Consumer<Event> consumer) {
             if (alwaysCancelling) {
                 return event -> {
                     consumer.accept(event);

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

@@ -51,6 +51,11 @@ static <T> List<Predicate<T>> unwrapPredicates(List<EventListener> listeners) {
         for (var listener : listeners) {
             if (listener instanceof EventListenerImpl.HasPredicate<?> predicateListener) {
                 unwrappedPredicates.add(uncheckedCast(predicateListener.predicate()));
+            } else if (listener instanceof EventListenerImpl.ConsumerListener consumerListener) {
+                // EventBus#90 hotfix
+                // Todo: Figure out a smarter way to handle this, such as when the listener is added to the EventBus and converted to an EventListener.
+                //       Refer to the GitHub issue for more details.
+                unwrappedPredicates.add(uncheckedCast(EventListenerImpl.WrappedConsumerListener.wrap(false, consumerListener.consumer())));
             } else {
                 throw new IllegalStateException("Unexpected listener type: " + listener.getClass());
             }