Add a compile-time warning when casting from EventBus#create to CancellableEventBus (#106)

Author: PaintNinja

eventbus-test/src/test/java/net/minecraftforge/eventbus/test/compiletime/EventBusValidatorTests.java

@@ -35,4 +35,26 @@ record CancellableEvent() implements Cancellable, RecordEvent {
         """);
         assertThat(compilation).hadWarningContaining("should be CancellableEventBus");
     }
+
+    /**
+     * Tests that the compile-time validation emits a warning when calling EventBus#create(Class) and casting the result
+     * to CancellableEventBus, as this relies on internal implementation details that aren't guaranteed to hold true in
+     * future patch updates. The correct approach is to call CancellableEventBus#create(Class) directly.
+     */
+    @Test
+    public void testBusFieldNotCasted() {
+        var compilation = compile("""
+            record CancellableEvent() implements Cancellable, RecordEvent {
+                static final CancellableEventBus<CancellableEvent> BUS = (CancellableEventBus<CancellableEvent>) EventBus.create(CancellableEvent.class);
+            }
+        """);
+        assertThat(compilation).hadWarningContaining("should call CancellableEventBus#create(Class) directly");
+
+        compilation = compile("""
+            record CancellableEvent() implements Cancellable, RecordEvent {
+                static final CancellableEventBus<CancellableEvent> BUS = CancellableEventBus.create(CancellableEvent.class);
+            }
+        """);
+        assertThat(compilation).succeeded();
+    }
 }

eventbus-validator/src/main/java/net/minecraftforge/eventbus/validator/EventBusValidator.java

@@ -4,6 +4,14 @@
  */
 package net.minecraftforge.eventbus.validator;
 
+import com.sun.source.tree.IdentifierTree;
+import com.sun.source.tree.MemberSelectTree;
+import com.sun.source.tree.MethodInvocationTree;
+import com.sun.source.tree.TypeCastTree;
+import com.sun.source.tree.VariableTree;
+import com.sun.source.util.TreePath;
+import com.sun.source.util.Trees;
+
 import javax.annotation.processing.ProcessingEnvironment;
 import javax.annotation.processing.RoundEnvironment;
 import javax.lang.model.element.Element;
@@ -18,11 +26,13 @@
 
 public final class EventBusValidator extends AbstractValidator {
     private Types types;
+    private Trees trees;
 
     @Override
     public void init(ProcessingEnvironment processingEnv) {
         super.init(processingEnv);
         types = processingEnv.getTypeUtils();
+        trees = Trees.instance(processingEnv);
     }
 
     @Override
@@ -38,7 +48,8 @@ private void process(Element element) {
         if (element.getKind() == ElementKind.FIELD) {
             TypeMirror erasedFieldType = types.erasure(element.asType());
             var isStandardEventBus = types.isSameType(erasedFieldType, BusTypes.eventBus);
-            if (!(isStandardEventBus || types.isSameType(erasedFieldType, BusTypes.cancellableEventBus)))
+            var isCancellableEventBus = false;
+            if (!(isStandardEventBus || (isCancellableEventBus = types.isSameType(erasedFieldType, BusTypes.cancellableEventBus))))
                 return; // only interested in (Cancellable)EventBus fields
 
             // Show a warning if the bus field is not final
@@ -62,11 +73,44 @@ private void process(Element element) {
                     );
                 }
             }
+
+            // Show a warning if the field initialiser casts the result of EventBus.create(...) to CancellableEventBus
+            if (isCancellableEventBus) {
+                checkForCastedEventBusCreate(element);
+            }
         }
 
 
         for (var child : element.getEnclosedElements()) {
             process(child);
         }
     }
+
+    private void checkForCastedEventBusCreate(Element fieldElement) {
+        TreePath path = trees.getPath(fieldElement);
+        if (path == null || !(path.getLeaf() instanceof VariableTree variableTree)) return;
+
+        // Check if initialiser is a cast expression and the expression being cast is a method invocation
+        if (!(variableTree.getInitializer() instanceof TypeCastTree cast
+                && cast.getExpression() instanceof MethodInvocationTree methodInvocation)) return;
+
+        // Check if it's a call to EventBus.create(...)
+        if (!(methodInvocation.getMethodSelect() instanceof MemberSelectTree memberSelectTree
+                && memberSelectTree.getExpression() instanceof IdentifierTree identifierTree
+                && identifierTree.getName().contentEquals("EventBus")
+                && memberSelectTree.getIdentifier().contentEquals("create"))) return;
+
+        // And that its result is being cast to CancellableEventBus...
+        // Note: Can't use types#getTypeMirror here because it returns null for TypeCastTree when wrapped in TreePath in
+        //       this context, so we have to manually resolve the type element from the tree instead.
+        if (trees.getElement(new TreePath(new TreePath(path, cast), cast.getType())) instanceof TypeElement typeElement) {
+            if (types.isSameType(types.erasure(typeElement.asType()), BusTypes.cancellableEventBus)) {
+                processingEnv.getMessager().printWarning(
+                        "CancellableEventBus field " + fieldElement.getEnclosingElement().getSimpleName() + '.' + fieldElement.getSimpleName() +
+                                " should call CancellableEventBus#create(Class) directly instead of casting the result from EventBus#create(Class)",
+                        fieldElement
+                );
+            }
+        }
+    }
 }