Feat: Add Error Handling during Runtime

Author: kavishsathia

src/tracer/__tests__/tracer_debug.ts

@@ -107,3 +107,14 @@ function h(f, x) {
   const output = steps.map(stringifyWithExplanation)
   console.log(output.join('\n\n'))
 })
+
+
+test('general', () => {
+  const code = `
+  3 % 0;
+  `
+  const program = parse(code, { ecmaVersion: 10 })!
+  const steps = getSteps(convert(program), { stepLimit: 200 })
+  const output = steps.map(stringifyWithExplanation)
+  console.log(output.join('\n\n'))
+})

src/tracer/nodes/Expression/BinaryExpression.ts

@@ -59,9 +59,16 @@ export class StepperBinaryExpression implements BinaryExpression, StepperBaseNod
       }
       return ret
     } else if (left_type === 'number' && right_type === 'number') {
+      if (this.operator === '/' && this.right.value === 0) {
+        throw new Error('Division by zero');
+      }
+
+      if (this.operator === '%' && this.right.value === 0) {
+        throw new Error('Modulo by zero');
+      }
+
       const ret =
-        ['*', '+', '/', '-', '===', '!==', '<', '>', '<=', '>=', '%'].includes(this.operator as string) &&
-        !(this.operator === '/' && this.right.value === 0)
+        ['*', '+', '/', '-', '===', '!==', '<', '>', '<=', '>=', '%'].includes(this.operator as string)
       if (ret) {
         redex.preRedex = [this]
       }

src/tracer/steppers.ts

@@ -16,53 +16,72 @@ export function getSteps(
   const node: StepperBaseNode = prelude(convert(inputNode))
   const steps: IStepperPropContents[] = []
   const limit = stepLimit === undefined ? 1000 : stepLimit % 2 === 0 ? stepLimit : stepLimit + 1
+  let hasError = false;
+
   let numSteps = 0
   function evaluate(node: StepperBaseNode): StepperBaseNode {
     numSteps += 1
     if (numSteps >= limit) {
       return node;
     }
-    const isOneStepPossible = node.isOneStepPossible()
-    if (isOneStepPossible) {
-      const oldNode = node
-      const newNode = node.oneStep()
-      if (redex) {
-        const explanations: string[] = redex.preRedex.map(explain)
-        const beforeMarkers: Marker[] = redex.preRedex.map((redex, index) => ({
-          redex: redex,
-          redexType: 'beforeMarker',
-          explanation: explanations[index]
-        }))
-        steps.push({
-          ast: oldNode,
-          markers: beforeMarkers
-        })
-        const afterMarkers: Marker[] =
-          redex.postRedex.length > 0
-            ? redex.postRedex.map((redex, index) => ({
-                redex: redex,
-                redexType: 'afterMarker',
-                explanation: explanations[index]
-              }))
-            : [
-                {
+
+    try {
+      const isOneStepPossible = node.isOneStepPossible()
+      if (isOneStepPossible) {
+        const oldNode = node
+        let newNode: StepperBaseNode;
+        newNode = node.oneStep()
+
+        if (redex) {
+          const explanations: string[] = redex.preRedex.map(explain)
+          const beforeMarkers: Marker[] = redex.preRedex.map((redex, index) => ({
+            redex: redex,
+            redexType: 'beforeMarker',
+            explanation: explanations[index]
+          }))
+          steps.push({
+            ast: oldNode,
+            markers: beforeMarkers
+          })
+          const afterMarkers: Marker[] =
+            redex.postRedex.length > 0
+              ? redex.postRedex.map((redex, index) => ({
+                  redex: redex,
                   redexType: 'afterMarker',
-                  explanation: explanations[0] // use explanation based on preRedex
-                }
-              ]
-        steps.push({
-          ast: newNode,
-          markers: afterMarkers
-        })
+                  explanation: explanations[index]
+                }))
+              : [
+                  {
+                    redexType: 'afterMarker',
+                    explanation: explanations[0] // use explanation based on preRedex
+                  }
+                ]
+          steps.push({
+            ast: newNode,
+            markers: afterMarkers
+          })
+        }
+        // reset
+        redex.preRedex = []
+        redex.postRedex = []
+        return evaluate(newNode)
+      } else {
+        return node
       }
-      // reset
-      redex.preRedex = []
-      redex.postRedex = []
-      return evaluate(newNode)
-    } else {
-      return node
+    } catch (error) {
+      // Handle error during step evaluation
+      hasError = true;
+      steps.push({
+        ast: node,
+        markers: [{
+          redexType: 'beforeMarker',
+          explanation: error instanceof Error ? error.message : String(error)
+        }]
+      });
+      return node;
     }
   }
+  
   // First node
   steps.push({
     ast: node,
@@ -88,13 +107,25 @@ export function getSteps(
   if (result.type === 'Program' && (result as StepperProgram).body.length === 0) {
     result = new StepperExpressionStatement(undefinedNode)
   }
-  steps.push({
-    ast: result,
-    markers: [
-      {
-        explanation: 'Evaluation complete'
-      }
-    ]
-  })
+
+  if (!hasError) {
+    steps.push({
+      ast: result,
+      markers: [
+        {
+          explanation: 'Evaluation complete'
+        }
+      ]
+    })
+  } else {
+    steps.push({
+      ast: result,
+      markers: [
+        {
+          explanation: 'Evaluation stuck'
+        }
+      ],
+    })
+  }
   return steps
 }