zexus 1.8.2 → 1.8.3

package/src/zexus/vm/fastops.pyx

@@ -148,7 +148,12 @@ def execute(list instrs, list consts, dict env, dict builtins, dict closure_cell
                 a = a.value
             if hasattr(b, "value"):
                 b = b.value
-            stack.append(a / b if b != 0 else 0)
+            if b == 0:
+                raise ZeroDivisionError("Division by zero")
+            elif isinstance(a, int) and not isinstance(a, bool) and isinstance(b, int) and not isinstance(b, bool):
+                stack.append(a // b if a % b == 0 else a / b)
+            else:
+                stack.append(a / b)
         elif op_name == "MOD":
             b = stack.pop() if stack else 1
             a = stack.pop() if stack else 0
@@ -197,10 +202,14 @@ def execute(list instrs, list consts, dict env, dict builtins, dict closure_cell
             stack.append(elements)
         elif op_name == "BUILD_MAP":
             count = operand if operand is not None else 0
-            result = {}
+            pairs = []
             for _ in range(count):
                 val = stack.pop(); key = stack.pop()
-                result[key] = val
+                pairs.append((key, val))
+            pairs.reverse()
+            result = {}
+            for k, v in pairs:
+                result[k] = v
             stack.append(result)
         elif op_name == "BUILD_SET":
             count = operand if operand is not None else 0
@@ -214,10 +223,79 @@ def execute(list instrs, list consts, dict env, dict builtins, dict closure_cell
                     stack.append(obj.get(idx))
                 elif isinstance(obj, ZMap):
                     stack.append(obj.get(idx))
+                elif hasattr(obj, 'data') and hasattr(obj, 'entity_def'):
+                    idx_str = idx.value if hasattr(idx, 'value') else str(idx) if idx is not None else None
+                    if idx_str:
+                        val = obj.get(idx_str)
+                        if hasattr(val, 'value'):
+                            stack.append(val.value)
+                        else:
+                            stack.append(val)
+                    else:
+                        stack.append(None)
+                elif isinstance(obj, dict):
+                    raw_idx = idx.value if hasattr(idx, 'value') else idx
+                    if raw_idx in obj:
+                        stack.append(obj[raw_idx])
+                    elif isinstance(raw_idx, int) and not isinstance(raw_idx, bool):
+                        keys = list(obj.keys())
+                        if 0 <= raw_idx < len(keys):
+                            stack.append(obj[keys[raw_idx]])
+                        else:
+                            stack.append(None)
+                    else:
+                        stack.append(None)
                 else:
                     stack.append(obj[idx] if obj is not None else None)
             except Exception:
                 stack.append(None)
+        elif op_name == "FOR_ITER":
+            var_count = operand if operand else 1
+            idx = stack.pop() if stack else 0
+            obj = stack.pop() if stack else None
+            try:
+                if isinstance(obj, dict):
+                    keys = list(obj.keys())
+                    if isinstance(idx, int) and 0 <= idx < len(keys):
+                        key = keys[idx]
+                        if var_count == 2:
+                            stack.append(key)
+                            stack.append(obj[key])
+                        else:
+                            stack.append(key)
+                    else:
+                        for _ in range(var_count):
+                            stack.append(None)
+                elif isinstance(obj, ZMap):
+                    keys = list(obj.pairs.keys())
+                    if isinstance(idx, int) and 0 <= idx < len(keys):
+                        key = keys[idx]
+                        if var_count == 2:
+                            stack.append(key)
+                            stack.append(obj.pairs[key])
+                        else:
+                            stack.append(key)
+                    else:
+                        for _ in range(var_count):
+                            stack.append(None)
+                elif isinstance(obj, (list, ZList)):
+                    elems = obj.elements if isinstance(obj, ZList) else obj
+                    if isinstance(idx, int) and 0 <= idx < len(elems):
+                        if var_count == 2:
+                            stack.append(idx)
+                            stack.append(elems[idx])
+                        else:
+                            stack.append(elems[idx])
+                    else:
+                        for _ in range(var_count):
+                            stack.append(None)
+                else:
+                    raise NotImplementedError("FOR_ITER target type not supported")
+            except NotImplementedError:
+                raise
+            except Exception:
+                for _ in range(var_count):
+                    stack.append(None)
         elif op_name == "SLICE":
             end = stack.pop() if stack else None
             start = stack.pop() if stack else None

package/src/zexus/vm/optimizer.py

@@ -81,6 +81,9 @@ class BytecodeOptimizer:
             "JUMP_BACKWARD",
             "LABEL",
             "JUMP_TARGET",
+            "SETUP_TRY",
+            "POP_TRY",
+            "THROW",
         }
 
     def _has_control_flow(self, instructions: List[Tuple[str, Any]]) -> bool:
@@ -94,9 +97,14 @@ class BytecodeOptimizer:
         """Validate that jump targets are sane and within bounds."""
         max_index = len(instructions) - 1
         for idx, (op, operand) in enumerate(instructions):
-            if op in ("JUMP", "JUMP_IF_FALSE", "JUMP_IF_TRUE", "JUMP_FORWARD", "JUMP_BACKWARD"):
+            if op in ("JUMP", "JUMP_IF_FALSE", "JUMP_IF_TRUE", "JUMP_FORWARD", "JUMP_BACKWARD", "SETUP_TRY"):
                 if not isinstance(operand, int):
-                    return False
+                    # SETUP_TRY and others require an int target
+                    if op == "SETUP_TRY":
+                        return False
+                    if op in ("JUMP", "JUMP_IF_FALSE", "JUMP_IF_TRUE"):
+                        return False
+                    continue
                 if operand < 0 or operand > max_index:
                     return False
                 if op == "JUMP" and operand == idx:
@@ -404,8 +412,9 @@ class BytecodeOptimizer:
     
     def _dead_code_elimination(self, instructions: List[Tuple[str, Any]]) -> List[Tuple[str, Any]]:
         """
-        Remove unreachable code after RETURN, unconditional JUMP, etc.
+        Remove unreachable code after RETURN, unconditional JUMP, THROW, etc.
         Jump targets are remapped after dead code removal to keep control flow valid.
+        SETUP_TRY handler targets are treated as jump targets (catch blocks are reachable).
         """
         result = []
         in_dead_code = False
@@ -413,14 +422,24 @@ class BytecodeOptimizer:
         removed_indices: Set[int] = set()
 
         for idx, (op, operand) in enumerate(instructions):
+            # Standard jumps
             if op in ("JUMP", "JUMP_IF_FALSE", "JUMP_IF_TRUE", "JUMP_FORWARD", "JUMP_BACKWARD"):
                 if isinstance(operand, int):
                     jump_targets.add(operand)
+            # SETUP_TRY handler addresses are also jump targets (catch blocks)
+            elif op == "SETUP_TRY":
+                if isinstance(operand, int):
+                    jump_targets.add(operand)
         
         for idx, (op, operand) in enumerate(instructions):
             if in_dead_code:
-                # Skip until we hit a jump target or label
-                if op in ("LABEL", "JUMP_TARGET") or idx in jump_targets:
+                # Stop skipping at jump targets, labels, or NOP labels
+                is_label = (
+                    op in ("LABEL", "JUMP_TARGET")
+                    or idx in jump_targets
+                    or (op == "NOP" and isinstance(operand, str) and operand.startswith("L"))
+                )
+                if is_label:
                     in_dead_code = False
                     result.append((op, operand))
                 else:
@@ -429,7 +448,7 @@ class BytecodeOptimizer:
             else:
                 result.append((op, operand))
                 # Mark dead code after unconditional control flow
-                if op in ("RETURN", "JUMP"):
+                if op in ("RETURN", "JUMP", "THROW"):
                     in_dead_code = True
         
         # Remap jump targets after dead code removal
@@ -441,7 +460,8 @@ class BytecodeOptimizer:
                     index_map[old_idx] = new_idx
                     new_idx += 1
             
-            jump_ops = ("JUMP", "JUMP_IF_FALSE", "JUMP_IF_TRUE", "JUMP_FORWARD", "JUMP_BACKWARD")
+            # Include SETUP_TRY in jump remapping — its operand is a handler address
+            jump_ops = ("JUMP", "JUMP_IF_FALSE", "JUMP_IF_TRUE", "JUMP_FORWARD", "JUMP_BACKWARD", "SETUP_TRY")
             remapped = []
             for op, operand in result:
                 if op in jump_ops and isinstance(operand, int) and operand in index_map:
@@ -569,40 +589,58 @@ class BytecodeOptimizer:
     
     def _strength_reduction(self, instructions: List[Tuple[str, Any]]) -> List[Tuple[str, Any]]:
         """
-        Replace expensive operations with cheaper equivalents
-        
-        Examples:
-            x * 2 → x + x (addition cheaper than multiplication)
-            x ** 2 → x * x
-            x / 2 → x * 0.5 (if floating point)
+        Replace expensive operations with cheaper equivalents.
+
+        Patterns recognised (where *val* comes from ``LOAD_CONST``):
+            ``val * 2``  → ``val + val``  (addition cheaper than multiplication)
+            ``val ** 2`` → ``val * val``  (avoid exponentiation)
+
+        Only fires when the constant is a literal ``2`` so that the
+        semantics are bit-identical for integers.
         """
         result = []
         i = 0
-        
+
         while i < len(instructions):
-            # Pattern: multiply by power of 2
+            # We need a 3-instruction window: LOAD_x  LOAD_CONST  OP
             if i + 2 < len(instructions):
                 op1, operand1 = instructions[i]
                 op2, operand2 = instructions[i + 1]
-                op3, operand3 = instructions[i + 2]
-                
-                # x * 2 → x + x (cheaper)
-                if op1 == "LOAD_NAME" and op2 == "LOAD_CONST" and op3 == "MUL":
-                    # This is simplified - would need constant value check
-                    pass
-            
+                op3, _        = instructions[i + 2]
+
+                if op2 == "LOAD_CONST" and operand2 == 2:
+                    # x * 2 → x + x  (DUP + ADD)
+                    if op3 == "MUL":
+                        result.append(instructions[i])        # LOAD_x
+                        result.append(("DUP", None))
+                        result.append(("ADD", None))
+                        self.stats.strength_reductions += 1
+                        i += 3
+                        continue
+
+                    # x ** 2 → x * x  (DUP + MUL)
+                    if op3 == "POW":
+                        result.append(instructions[i])        # LOAD_x
+                        result.append(("DUP", None))
+                        result.append(("MUL", None))
+                        self.stats.strength_reductions += 1
+                        i += 3
+                        continue
+
             result.append(instructions[i])
             i += 1
-        
+
         return result
     
     def _loop_invariant_code_motion(self, instructions: List[Tuple[str, Any]]) -> List[Tuple[str, Any]]:
         """
-        Move loop-invariant computations outside loops
-        
-        This is experimental and requires loop detection
+        Move loop-invariant computations outside loops.
+
+        This is experimental and requires loop detection (back-edge
+        analysis).  Currently a **no-op** — the instruction list is
+        returned unchanged.  Gated behind ``level >= 3`` so it never
+        fires unless explicitly requested.
         """
-        # Placeholder for future implementation
         return instructions
     
     def get_stats(self) -> Dict[str, Any]: