create 'mixinoverride' tag (#184)

Author: dicedpixels

tags/faq/mixinoverride.ytag

@@ -0,0 +1,58 @@
+type: text
+
+---
+
+When writing mixins, you may be tempted to override methods from superclasses in mixins like so:
+```java
+@Mixin(PlayerEntity.class)
+class PlayerEntityMixin {
+  @Override
+  public EntityPose getPose() {
+    return EntityPose.SWIMMING;
+  } 
+}
+```
+
+For mod compatibility reasons, you should not do this. Instead, you should use one of the following methods:
+```java
+
+// Mixin the parent, and use instanceof to check what `this` is
+@Mixin(Entity.class)
+class EntityMixin {
+  @ModifyReturnValue(
+    method = "getPose",
+    at = @At("RETURN")
+  )
+  private EntityPose overrideForPlayer(EntityPose pose) {
+    // the compiler doesn't belive `this` can ever be `PlayerEntity`, so a cast to `Object` is required
+    return (Object) this instanceof PlayerEntity ? EntityPose.SWIMMING : pose;
+  }
+```
+
+```java
+
+// use submixin to conditionally modify the parent
+@Mixin(Entity.class)
+class EntityMixin {
+  // 1. define a dummy handler in a mixin to the superclass, that does nothing, but is protected
+  @WrapMethod(
+    method = "getPose"
+  )
+  protected EntityPose overrideForPlayer(Operation<EntityPose> original) {
+    return original.call();
+  }
+
+  @Mixin(PlayerEntity.class)
+  private static class PlayerEntityMixin extends EntityMixin /* !important! */ {
+    // 2. Override the handler in the child mixin, and make the actual changes
+    @Override
+    protected EntityPose overrideForPlayer(Operation<EntityPose> original) {
+      return EntityPose.SWIMMING;
+    }
+  }
+}
+```
+
+Both of the above patterns can work for any mixin injector, and even when you just need to make small changes to the superclass.
+
+The `instanceof` pattern is more direct, and can be simpler to understand, while the submixin pattern can lead to a code structure more similar to just overriding the target method and keeps all code relevant to a given class in a mixin to that class. the general agreement is that it doesn't matter which you pick; either is better than `@Override`.