Exercise 1: Hand-Tracing the Stack Through a Function Call — Possible Solution
====================================================================

THE PROGRAM
------------------------------
    fun add(a, b) { return a + b; }
    print add(3, 4);

TRACE
------------------------------
Top-level script frame: function=<script>, base=0.

1. Compiling `fun add...` pushes the WispFunction value onto the
   stack, then OP_DEFINE_GLOBAL pops it into globals['add'].
   Stack after this statement: []  (globals now holds 'add')

2. Compiling `print add(3, 4);`:
   - OP_GET_GLOBAL 'add'  -> stack: [<fn add>]
   - OP_CONSTANT 3.0      -> stack: [<fn add>, 3.0]
   - OP_CONSTANT 4.0      -> stack: [<fn add>, 3.0, 4.0]

   IMMEDIATELY BEFORE OP_CALL runs:
       stack = [<fn add>, 3.0, 4.0]

3. OP_CALL 2 executes:
   - callee = stack[-(2+1)] = stack[-3] = <fn add>  (found correctly)
   - new_base = len(stack) - arg_count = 3 - 2 = 1
   - a new CallFrame(function=<fn add>, ip=0, base=1) is pushed

   IMMEDIATELY AFTER the new CallFrame is pushed:
       stack = [<fn add>, 3.0, 4.0]   (unchanged -- OP_CALL never
                                        touches the stack's contents,
                                        only reads it and pushes a frame)
       frames = [<script frame, base=0>, <add frame, base=1>]

   Inside add's own frame, slot 0 means stack[1+0]=3.0 (parameter a),
   slot 1 means stack[1+1]=4.0 (parameter b) -- base=1 is exactly
   right because the function value itself sits at stack[0], one
   position before where its own arguments begin.

4. add's own body runs: OP_GET_LOCAL 0 (pushes 3.0), OP_GET_LOCAL 1
   (pushes 4.0), OP_ADD (pops both, pushes 7.0), OP_RETURN.

   Stack right before OP_RETURN pops its own result:
       stack = [<fn add>, 3.0, 4.0, 7.0]

5. OP_RETURN executes:
   - result = stack.pop() = 7.0    -> stack: [<fn add>, 3.0, 4.0]
   - finished_frame = frames.pop() (the add frame, base=1)
   - frames is non-empty (still has the script frame), so:
   - del stack[finished_frame.base - 1:] = del stack[0:]
     -> stack: []   (everything from the function value onward is gone)
   - stack.append(result) -> stack: [7.0]

   IMMEDIATELY AFTER OP_RETURN finishes:
       stack = [7.0]
       frames = [<script frame, base=0>]   (back to just the script)

6. OP_PRINT pops 7.0 and prints "7".

WHY THIS WORKS AS AN ANSWER
------------------------------
The single most important number in this whole trace is base=1 for
add's own frame -- not 0. It's easy to assume a function's own first
parameter always lives at stack position 0, but that's only true if
NOTHING else is on the stack when the call happens. Here, the
function value itself occupies position 0, so the real base has to
account for that: new_base = len(stack) - arg_count correctly lands
on position 1, exactly where the first real argument sits, and every
OP_GET_LOCAL/OP_SET_LOCAL inside add's own body is then correctly
offset from THAT base, not from absolute position 0.