Switch to a single mixin for all base continuation frames, in preparation for dynamic mixin generation

Author: object-Object

common/src/main/clojure/gay/object/caduceus/casting/actions/marks.clj

@@ -34,18 +34,19 @@
 
 (deftype OpWriteLocalMark []
   Action
-  (operate [_this _env image cont]
+  (operate [_this env image cont]
     (let [stack (-> image .getStack vec)
           mark (last stack)]
       (cond
         (nil? mark) (throw (MishapNotEnoughArgs/new 1 0))
         (> (.size mark) 1) (throw (MishapInvalidIota/ofType mark 0 "continuation_mark")))
       (when-let [true-name (MishapOthersName/getTrueNameFromDatum mark nil)]
         (throw (MishapOthersName/new true-name)))
+      (continuation/set-mark cont mark (.getWorld env))
       (OperationResult/new
         (casting/copy-image
           (.withUsedOp image)
           :stack (pop stack))
         []
-        (continuation/with-mark cont mark)
+        cont
         HexEvalSounds/NORMAL_EXECUTE))))

common/src/main/clojure/gay/object/caduceus/utils/continuation.clj

@@ -45,36 +45,40 @@
     caduceus$getMark
     []
    "Returns the continuation mark on this frame, or NullIota if none.")
-  (^at.petrak.hexcasting.api.casting.eval.vm.ContinuationFrame
-    caduceus$withMark
+  (^void
+    caduceus$setMark
     [^at.petrak.hexcasting.api.casting.iota.Iota mark]
-   "Returns a copy of this frame with the given continuation mark."))
+   "Mutably sets the continuation mark on this frame. DO NOT CALL THIS METHOD ON SINGLETONS!"))
 
 ; CURSED
 ; we catch IllegalArgumentException instead of just checking instance? so other addons can add support without depending on us
 (defn get-frame-mark
   ([frame] (get-frame-mark frame nil))
   ([frame not-found]
-   (try
+   (if (instance? ContinuationMarkHolder frame)
      (.caduceus$getMark frame)
-     (catch IllegalArgumentException _ not-found))))
+     not-found)))
 
 (defn get-mark [cont]
   (if-let [frame (frame cont)]
     (get-frame-mark frame (NullIota/new))
     (NullIota/new)))
 
-(defn with-frame-mark [frame iota]
-  (try
-    (.caduceus$withMark frame iota)
-    (catch IllegalArgumentException _ frame)))
-
-(defn with-mark [cont mark]
-  (if-let [frame (frame cont)]
-    (.pushFrame
-      (.getNext cont)
-      (with-frame-mark frame mark))
-    cont))
+(defn set-frame-mark [frame iota world]
+  (let [frame-type (.getType frame)]
+    (when (and
+            (instance? ContinuationMarkHolder frame)
+            ; CURSED: pass the frame through serialization to detect singletons
+            (-> frame
+                .serializeToNBT
+                (#(.deserializeFromNBT frame-type % world))
+                (identical? frame)
+                not))
+      (.caduceus$setMark frame iota))))
+
+(defn set-mark [cont mark world]
+  (when-let [frame (frame cont)]
+    (set-frame-mark frame mark world)))
 
 (defn- frame-tag-type-id [tag]
   (-> tag
@@ -85,12 +89,11 @@
 (def MARK-TAG "caduceus:mark")
 
 (defn- get-frame-tag-mark [tag]
-  (let [data-tag (.getCompound tag HexContinuationTypes/KEY_DATA)]
-    (if (.contains data-tag MARK-TAG net.minecraft.nbt.Tag/TAG_COMPOUND)
-      (let [mark-tag (.getCompound data-tag MARK-TAG)
-            mark-type (.getString mark-tag HexIotaTypes/KEY_TYPE)]
-        (when-not (= mark-type "hexcasting:null")
-          mark-tag)))))
+  (if (.contains tag MARK-TAG net.minecraft.nbt.Tag/TAG_COMPOUND)
+    (let [mark-tag (.getCompound tag MARK-TAG)
+          mark-type (.getString mark-tag HexIotaTypes/KEY_TYPE)]
+      (when-not (= mark-type "hexcasting:null")
+        mark-tag))))
 
 (defn- mod-name [id]
   (if-let [mod (-> id Platform/getOptionalMod (.orElse nil))]

common/src/main/java/gay/object/caduceus/mixin/MixinAllContinuationFrames.java

@@ -0,0 +1,59 @@
+package gay.object.caduceus.mixin;
+
+import at.petrak.hexcasting.api.casting.eval.vm.*;
+import at.petrak.hexcasting.api.casting.iota.Iota;
+import at.petrak.hexcasting.api.casting.iota.NullIota;
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
+import gay.object.caduceus.utils.continuation.ContinuationMarkHolder;
+import org.jetbrains.annotations.Nullable;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+// FrameFinishEval is a singleton, so caduceus$setMark SHOULD never be called on it
+// technically we don't even need this mixin for it, but it's here for testing
+@Mixin(value = {FrameEvaluate.class, FrameForEach.class, FrameFinishEval.class}, remap = false)
+public abstract class MixinAllContinuationFrames implements ContinuationFrame, ContinuationMarkHolder {
+    @Unique
+    @Nullable
+    private Iota caduceus$mark;
+
+    @Unique
+    @Override
+    public Iota caduceus$getMark() {
+        if (caduceus$mark == null) {
+            return new NullIota();
+        }
+        return caduceus$mark;
+    }
+
+    @Unique
+    @Override
+    public void caduceus$setMark(Iota newMark) {
+        caduceus$mark = newMark;
+    }
+
+    @WrapOperation(
+        method = "evaluate",
+        at = @At(value = "INVOKE", target = "Lat/petrak/hexcasting/api/casting/eval/vm/SpellContinuation;pushFrame(Lat/petrak/hexcasting/api/casting/eval/vm/ContinuationFrame;)Lat/petrak/hexcasting/api/casting/eval/vm/SpellContinuation;"),
+        require = 0
+    )
+    private SpellContinuation caduceus$addMarkToPushedFrame(SpellContinuation instance, ContinuationFrame frame, Operation<SpellContinuation> original) {
+        // if we're pushing a frame which is the same class as (or a subclass of) this one, copy the mark over
+        // this handles cases like FrameEvaluate creating a new frame with list.cdr
+        if (getClass().isInstance(frame) && frame instanceof ContinuationMarkHolder holder) {
+            holder.caduceus$setMark(caduceus$mark);
+        }
+        return original.call(instance, frame);
+    }
+
+    @Inject(method = "copy", at = @At("RETURN"), require = 0)
+    private void caduceus$addMarkToCopy(CallbackInfoReturnable<ContinuationFrame> cir) {
+        if (cir.getReturnValue() instanceof ContinuationMarkHolder holder) {
+            holder.caduceus$setMark(caduceus$mark);
+        }
+    }
+}

common/src/main/java/gay/object/caduceus/mixin/MixinContinuationFrameCompanion.java

@@ -0,0 +1,39 @@
+package gay.object.caduceus.mixin;
+
+import at.petrak.hexcasting.api.casting.iota.IotaType;
+import gay.object.caduceus.utils.continuation.ContinuationMarkHolder;
+import gay.object.caduceus.utils.continuation.ContinuationUtils;
+import at.petrak.hexcasting.api.casting.eval.vm.ContinuationFrame;
+import com.llamalad7.mixinextras.injector.ModifyReturnValue;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.Tag;
+import net.minecraft.server.level.ServerLevel;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+
+@Mixin(ContinuationFrame.Companion.class)
+public class MixinContinuationFrameCompanion {
+    @ModifyReturnValue(method = "fromNBT", at = @At("RETURN"))
+    private ContinuationFrame caduceus$deserializeMark(ContinuationFrame frame, CompoundTag tag, ServerLevel world) {
+        if (
+            frame instanceof ContinuationMarkHolder holder
+            && tag.contains(ContinuationUtils.getMarkTagKey(), Tag.TAG_COMPOUND)
+            // CURSED: pass the frame through serialization to detect singletons
+            && frame.getType().deserializeFromNBT(frame.serializeToNBT(), world) != frame
+        ) {
+            var markTag = tag.getCompound(ContinuationUtils.getMarkTagKey());
+            var mark = IotaType.deserialize(markTag, world);
+            holder.caduceus$setMark(mark);
+        }
+        return frame;
+    }
+
+    @ModifyReturnValue(method = "toNBT", at = @At("RETURN"))
+    private CompoundTag caduceus$serializeMark(CompoundTag tag, ContinuationFrame frame) {
+        if (frame instanceof ContinuationMarkHolder holder) {
+            var markTag = IotaType.serialize(holder.caduceus$getMark());
+            tag.put(ContinuationUtils.getMarkTagKey(), markTag);
+        }
+        return tag;
+    }
+}