Construct casting vm for each step to fix broken evaluator spell casting

object-Object · object-Object · commit 6cf743f1fea1 · 2024-05-23T20:07:05.000-04:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and [Pydantic's HISTORY.md](https://github.com/pydantic/pydantic/blob/main/HISTORY.md), and this project *mostly* adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [UNRELEASED]
+
+### Fixed
+
+- Fixed a bug where the Evaluator was unable to cast any spells requiring media.
+
 ## 0.2.0+1.20.1
 
 ### Added
diff --git a/Common/src/main/kotlin/gay/object/hexdebug/adapter/DebugAdapter.kt b/Common/src/main/kotlin/gay/object/hexdebug/adapter/DebugAdapter.kt
@@ -1,6 +1,7 @@
 package gay.`object`.hexdebug.adapter
 
 import at.petrak.hexcasting.api.casting.SpellList
+import at.petrak.hexcasting.api.casting.eval.CastingEnvironment
 import at.petrak.hexcasting.api.casting.eval.ExecutionClientView
 import at.petrak.hexcasting.api.casting.eval.ResolvedPatternType
 import at.petrak.hexcasting.api.casting.iota.Iota
@@ -107,12 +108,12 @@ open class DebugAdapter(val player: ServerPlayer) : IDebugProtocolServer {
         })
     }
 
-    fun evaluate(pattern: HexPattern) = evaluate(PatternIota(pattern))
+    fun evaluate(env: CastingEnvironment, pattern: HexPattern) = evaluate(env, PatternIota(pattern))
 
-    fun evaluate(iota: Iota) = evaluate(SpellList.LList(listOf(iota)))
+    fun evaluate(env: CastingEnvironment, iota: Iota) = evaluate(env, SpellList.LList(listOf(iota)))
 
-    fun evaluate(list: SpellList) = debugger?.let {
-        val result = it.evaluate(list)
+    fun evaluate(env: CastingEnvironment, list: SpellList) = debugger?.let {
+        val result = it.evaluate(env, list)
         if (result.startedEvaluating) {
             setEvaluatorState(ItemEvaluator.EvalState.MODIFIED)
         }
diff --git a/Common/src/main/kotlin/gay/object/hexdebug/casting/eval/DebugItemCastEnv.kt b/Common/src/main/kotlin/gay/object/hexdebug/casting/eval/DebugItemCastEnv.kt
@@ -7,7 +7,6 @@ import gay.`object`.hexdebug.debugger.DebugStepType
 import net.minecraft.network.chat.Component
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.world.InteractionHand
-import org.eclipse.lsp4j.debug.OutputEventArgumentsCategory
 
 class DebugItemCastEnv(
     caster: ServerPlayer,
@@ -23,8 +22,6 @@ class DebugItemCastEnv(
 
     override fun sendMishapMsgToPlayer(mishap: OperatorSideEffect.DoMishap) {
         super.sendMishapMsgToPlayer(mishap)
-        mishap.mishap.errorMessageWithName(this, mishap.errorCtx)?.also {
-            printDebugMessage(caster, it, OutputEventArgumentsCategory.STDERR)
-        }
+        printDebugMishap(this, caster, mishap)
     }
 }
diff --git a/Common/src/main/kotlin/gay/object/hexdebug/casting/eval/DebugStaffCastEnv.kt b/Common/src/main/kotlin/gay/object/hexdebug/casting/eval/DebugStaffCastEnv.kt
@@ -0,0 +1,27 @@
+package gay.`object`.hexdebug.casting.eval
+
+import at.petrak.hexcasting.api.casting.castables.Action
+import at.petrak.hexcasting.api.casting.eval.env.StaffCastEnv
+import at.petrak.hexcasting.api.casting.eval.sideeffects.OperatorSideEffect
+import gay.`object`.hexdebug.debugger.DebugStepType
+import net.minecraft.network.chat.Component
+import net.minecraft.server.level.ServerPlayer
+import net.minecraft.world.InteractionHand
+
+class DebugStaffCastEnv(
+    caster: ServerPlayer,
+    castingHand: InteractionHand,
+) : StaffCastEnv(caster, castingHand), IDebugCastEnv {
+    override var lastEvaluatedAction: Action? = null
+    override var lastDebugStepType: DebugStepType? = null
+
+    override fun printMessage(message: Component) {
+        super.printMessage(message)
+        printDebugMessage(caster, message)
+    }
+
+    override fun sendMishapMsgToPlayer(mishap: OperatorSideEffect.DoMishap) {
+        super.sendMishapMsgToPlayer(mishap)
+        printDebugMishap(this, caster, mishap)
+    }
+}
diff --git a/Common/src/main/kotlin/gay/object/hexdebug/casting/eval/IDebugCastEnv.kt b/Common/src/main/kotlin/gay/object/hexdebug/casting/eval/IDebugCastEnv.kt
@@ -1,6 +1,9 @@
 package gay.`object`.hexdebug.casting.eval
 
 import at.petrak.hexcasting.api.casting.castables.Action
+import at.petrak.hexcasting.api.casting.eval.CastingEnvironment
+import at.petrak.hexcasting.api.casting.eval.sideeffects.OperatorSideEffect
+import at.petrak.hexcasting.api.casting.eval.vm.CastingVM
 import gay.`object`.hexdebug.adapter.DebugAdapterManager
 import gay.`object`.hexdebug.debugger.DebugStepType
 import net.minecraft.network.chat.Component
@@ -26,4 +29,12 @@ interface IDebugCastEnv {
     ) {
         DebugAdapterManager[caster]?.print(message.string + "\n", category, withSource)
     }
+
+    fun printDebugMishap(env: CastingEnvironment, caster: ServerPlayer, mishap: OperatorSideEffect.DoMishap) {
+        mishap.mishap.errorMessageWithName(env, mishap.errorCtx)?.also {
+            printDebugMessage(caster, it, OutputEventArgumentsCategory.STDERR)
+        }
+    }
 }
+
+val CastingVM.debugCastEnv get() = env as IDebugCastEnv
diff --git a/Common/src/main/kotlin/gay/object/hexdebug/debugger/HexDebugger.kt b/Common/src/main/kotlin/gay/object/hexdebug/debugger/HexDebugger.kt
@@ -16,6 +16,7 @@ import at.petrak.hexcasting.common.casting.actions.eval.OpEval
 import gay.`object`.hexdebug.adapter.LaunchArgs
 import gay.`object`.hexdebug.casting.eval.FrameBreakpoint
 import gay.`object`.hexdebug.casting.eval.IDebugCastEnv
+import gay.`object`.hexdebug.casting.eval.debugCastEnv
 import gay.`object`.hexdebug.debugger.allocators.SourceAllocator
 import gay.`object`.hexdebug.debugger.allocators.VariablesAllocator
 import gay.`object`.hexdebug.utils.ceilToPow
@@ -29,21 +30,26 @@ import org.eclipse.lsp4j.debug.LoadedSourceEventArgumentsReason as LoadedSourceR
 class HexDebugger(
     private val initArgs: InitializeRequestArguments,
     private val launchArgs: LaunchArgs,
-    val vm: CastingVM,
+    private val defaultEnv: CastingEnvironment,
     private val world: ServerLevel,
     private val onExecute: ((Iota) -> Unit)? = null,
     iotas: List<Iota>,
+    private var image: CastingImage = CastingImage(),
 ) {
     constructor(
         initArgs: InitializeRequestArguments,
         launchArgs: LaunchArgs,
         castArgs: CastArgs,
-    ) : this(initArgs, launchArgs, CastingVM.empty(castArgs.env), castArgs.world, castArgs.onExecute, castArgs.iotas)
+        image: CastingImage = CastingImage(),
+    ) : this(initArgs, launchArgs, castArgs.env, castArgs.world, castArgs.onExecute, castArgs.iotas, image)
 
     var lastEvaluatedMetadata: IotaMetadata? = null
         private set
 
-    private val debugCastEnv = vm.env as IDebugCastEnv
+    // ensure we passed a debug cast env to help catch errors early
+    init {
+        defaultEnv as IDebugCastEnv
+    }
 
     private val variablesAllocator = VariablesAllocator()
     private val sourceAllocator = SourceAllocator(iotas.hashCode())
@@ -94,6 +100,8 @@ class HexDebugger(
 
     private val nextFrame get() = (nextContinuation as? NotDone)?.frame
 
+    private fun getVM(env: CastingEnvironment? = null) = CastingVM(image, env ?: defaultEnv)
+
     private fun registerNewSource(frame: ContinuationFrame): Source? = getIotas(frame)?.let(::registerNewSource)
 
     private fun registerNewSource(iotas: Iterable<Iota>): Source? {
@@ -154,7 +162,7 @@ class HexDebugger(
         val scopes = mutableListOf(
             Scope().apply {
                 name = "Data"
-                variablesReference = vm.image.run {
+                variablesReference = image.run {
                     variablesAllocator.add(
                         toVariable("Stack", stack.asReversed()),
                         toVariable("Ravenmind", getRavenmind()),
@@ -163,7 +171,7 @@ class HexDebugger(
             },
             Scope().apply {
                 name = "State"
-                variablesReference = vm.image.run {
+                variablesReference = image.run {
                     val variables = mutableListOf(
                         toVariable("OpsConsumed", opsConsumed.toString()),
                         toVariable("EscapeNext", escapeNext.toString()),
@@ -241,9 +249,9 @@ class HexDebugger(
         }
     }
 
-    private fun getRavenmind() = vm.image.userData.let {
+    private fun getRavenmind() = image.userData.let {
         if (it.contains(HexAPI.RAVENMIND_USERDATA)) {
-            IotaType.deserialize(it.getCompound(HexAPI.RAVENMIND_USERDATA), vm.env.world)
+            IotaType.deserialize(it.getCompound(HexAPI.RAVENMIND_USERDATA), defaultEnv.world)
         } else {
             NullIota()
         }
@@ -350,7 +358,7 @@ class HexDebugger(
             ?.let { breakpoints[it.source.sourceReference]?.get(it.line) }
             ?: return false
 
-        val escapeNext = vm.image.escapeNext || vm.image.parenCount > 0
+        val escapeNext = image.escapeNext || image.parenCount > 0
 
         return when (breakpointMode) {
             SourceBreakpointMode.EVALUATED -> !escapeNext
@@ -359,6 +367,8 @@ class HexDebugger(
         }
     }
 
+    fun generateDescs() = getVM().generateDescs()
+
     private fun getClientView(vm: CastingVM): ExecutionClientView {
         val (stackDescs, ravenmind) = vm.generateDescs()
         val isStackClear = nextContinuation is Done // only close the window if we're done evaluating
@@ -368,13 +378,13 @@ class HexDebugger(
     /**
      * Use [DebugAdapter.evaluate][gay.object.hexdebug.adapter.DebugAdapter.evaluate] instead.
      */
-    internal fun evaluate(list: SpellList): DebugStepResult {
+    internal fun evaluate(env: CastingEnvironment, list: SpellList): DebugStepResult {
         val startedEvaluating = evaluatorResetData == null
         if (startedEvaluating) {
-            evaluatorResetData = Pair(nextContinuation, vm.image)
+            evaluatorResetData = Pair(nextContinuation, image)
         }
         nextContinuation = nextContinuation.pushFrame(FrameEvaluate(list, false))
-        return executeOnce().copy(startedEvaluating = startedEvaluating)
+        return executeNextDebugStep(getVM(env)).copy(startedEvaluating = startedEvaluating)
     }
 
     /**
@@ -383,7 +393,7 @@ class HexDebugger(
     internal fun resetEvaluator() {
         evaluatorResetData?.also { (continuation, image) ->
             nextContinuation = continuation
-            vm.image = image
+            this.image = image
             evaluatorResetData = null
         }
         evaluatorUIPatterns.clear()
@@ -400,14 +410,15 @@ class HexDebugger(
     }
 
     fun executeUntilStopped(stepType: RequestStepType? = null): DebugStepResult {
+        val vm = getVM()
         var lastResult: DebugStepResult? = null
         var isEscaping: Boolean? = null
         var stepDepth = 0
         var shouldStop = false
         var hitBreakpoint = false
 
         while (true) {
-            val result = executeOnce(exactlyOnce = true).let {
+            val result = executeNextDebugStep(vm, exactlyOnce = true).let {
                 if (it.isDone) return it
                 lastResult?.plus(it) ?: it
             }
@@ -452,8 +463,10 @@ class HexDebugger(
         }
     }
 
+    fun executeOnce() = executeNextDebugStep(getVM())
+
     // Copy of CastingVM.queueExecuteAndWrapIotas to allow stepping by one pattern at a time.
-    fun executeOnce(exactlyOnce: Boolean = false): DebugStepResult {
+    private fun executeNextDebugStep(vm: CastingVM, exactlyOnce: Boolean = false): DebugStepResult {
         var stepResult = DebugStepResult(StopReason.STEP)
 
         var continuation = nextContinuation // bind locally so we can do smart casting
@@ -464,7 +477,7 @@ class HexDebugger(
         // Begin aggregating info
         val info = CastingVM.TempControllerInfo(earlyExit = false)
         while (continuation is NotDone && !info.earlyExit) {
-            debugCastEnv.reset()
+            vm.debugCastEnv.reset()
 
             // Take the top of the continuation stack...
             val frame = continuation.frame
@@ -506,7 +519,7 @@ class HexDebugger(
                 onExecute?.invoke(castResult.cast)
             }
 
-            val stepType = getStepType(castResult, continuation, newContinuation)
+            val stepType = getStepType(vm, castResult, continuation, newContinuation)
             if (newContinuation is NotDone) {
                 setIotaOverrides(castResult, continuation, newContinuation, stepType)
 
@@ -516,7 +529,7 @@ class HexDebugger(
                 }
 
                 // insert a virtual FrameFinishEval if OpEval didn't (ie. if we did a TCO)
-                if (launchArgs.showTailCallFrames && debugCastEnv.lastEvaluatedAction is OpEval) {
+                if (launchArgs.showTailCallFrames && vm.debugCastEnv.lastEvaluatedAction is OpEval) {
                     val invokeMeta = iotaMetadata[castResult.cast]
                     val nextInvokeMeta = frameInvocationMetadata[newContinuation.next]?.invoke()
                     if (invokeMeta != null && invokeMeta != nextInvokeMeta) {
@@ -558,11 +571,12 @@ class HexDebugger(
         virtualFrames[continuation]?.clear()
 
         nextContinuation = continuation
+        image = vm.image
 
-        if (continuation is Done) {
-            stepResult = stepResult.done()
-        }
-        return stepResult.copy(clientInfo = getClientView(vm))
+        return when (continuation) {
+            is Done -> stepResult.done()
+            is NotDone -> stepResult
+        }.copy(clientInfo = getClientView(vm))
     }
 
     private fun shouldStopAtFrame(continuation: SpellContinuation) =
@@ -608,6 +622,7 @@ class HexDebugger(
     }
 
     private fun getStepType(
+        vm: CastingVM,
         castResult: CastResult,
         continuation: NotDone,
         newContinuation: SpellContinuation,
@@ -645,7 +660,7 @@ class HexDebugger(
             return DebugStepType.IN
         }
 
-        return debugCastEnv.lastDebugStepType
+        return vm.debugCastEnv.lastDebugStepType
     }
 
     private fun setIotaOverrides(
@@ -686,7 +701,7 @@ class HexDebugger(
     private fun iotaToString(iota: Iota, isSource: Boolean = false): String = when (iota) {
         // i feel like hex should have a thing for this...
         is PatternIota -> HexAPI.instance().run {
-            when (val lookup = PatternRegistryManifest.matchPattern(iota.pattern, vm.env, false)) {
+            when (val lookup = PatternRegistryManifest.matchPattern(iota.pattern, defaultEnv, false)) {
                 is PatternShapeMatch.Normal -> getActionI18n(lookup.key, false)
                 is PatternShapeMatch.PerWorld -> getActionI18n(lookup.key, true)
                 is PatternShapeMatch.Special -> lookup.handler.name
diff --git a/Common/src/main/kotlin/gay/object/hexdebug/items/ItemDebugger.kt b/Common/src/main/kotlin/gay/object/hexdebug/items/ItemDebugger.kt
@@ -1,14 +1,12 @@
 package gay.`object`.hexdebug.items
 
 import at.petrak.hexcasting.api.casting.iota.ListIota
-import at.petrak.hexcasting.api.casting.iota.PatternIota
 import at.petrak.hexcasting.api.mod.HexConfig
 import at.petrak.hexcasting.api.utils.getBoolean
 import at.petrak.hexcasting.api.utils.getInt
 import at.petrak.hexcasting.api.utils.putBoolean
 import at.petrak.hexcasting.api.utils.putInt
 import at.petrak.hexcasting.common.items.magic.ItemPackagedHex
-import at.petrak.hexcasting.common.msgs.MsgNewSpiralPatternsS2C
 import at.petrak.hexcasting.xplat.IXplatAbstractions
 import gay.`object`.hexdebug.HexDebug
 import gay.`object`.hexdebug.adapter.DebugAdapterManager
@@ -90,13 +88,7 @@ class ItemDebugger(properties: Properties) : ItemPackagedHex(properties) {
             } ?: return InteractionResultHolder.fail(stack)
 
             val ctx = DebugItemCastEnv(serverPlayer, usedHand)
-            val args = CastArgs(instrs, ctx, serverLevel) {
-                if (it is PatternIota) {
-                    val packet = MsgNewSpiralPatternsS2C(serverPlayer.uuid, listOf(it.pattern), 140)
-                    IXplatAbstractions.INSTANCE.sendPacketToPlayer(serverPlayer, packet)
-                    IXplatAbstractions.INSTANCE.sendPacketTracking(serverPlayer, packet)
-                }
-            }
+            val args = CastArgs(instrs, ctx, serverLevel)
 
             if (!debugAdapter.startDebugging(args)) {
                 return noClient(player, stack)
diff --git a/Common/src/main/kotlin/gay/object/hexdebug/items/ItemEvaluator.kt b/Common/src/main/kotlin/gay/object/hexdebug/items/ItemEvaluator.kt
@@ -7,6 +7,7 @@ import at.petrak.hexcasting.common.msgs.*
 import at.petrak.hexcasting.xplat.IXplatAbstractions
 import gay.`object`.hexdebug.HexDebug
 import gay.`object`.hexdebug.adapter.DebugAdapterManager
+import gay.`object`.hexdebug.casting.eval.DebugStaffCastEnv
 import gay.`object`.hexdebug.utils.itemPredicate
 import net.minecraft.client.player.LocalPlayer
 import net.minecraft.client.renderer.item.ClampedItemPropertyFunction
@@ -47,7 +48,7 @@ class ItemEvaluator(properties: Properties) : ItemStaff(properties) {
         }
 
         val patterns = debugger.evaluatorUIPatterns
-        val (stack, ravenmind) = debugger.vm.generateDescs()
+        val (stack, ravenmind) = debugger.generateDescs()
         IXplatAbstractions.INSTANCE.sendPacketToPlayer(
             player, MsgOpenSpellGuiS2C(hand, patterns, stack, ravenmind, 0)
         )
@@ -82,7 +83,8 @@ class ItemEvaluator(properties: Properties) : ItemStaff(properties) {
                 return
             }
 
-            val clientInfo = debugAdapter.evaluate(msg.pattern) ?: return
+            val env = DebugStaffCastEnv(sender, msg.handUsed)
+            val clientInfo = debugAdapter.evaluate(env, msg.pattern) ?: return
 
             debugger.evaluatorUIPatterns.clear()
             if (!clientInfo.isStackClear) {
