zexus 1.7.1 → 1.7.2

package/src/zexus/vm/compiler.py

@@ -54,18 +54,44 @@ class BytecodeCompiler:
         
         self._compile_node(node)
         
+        self._resolve_labels()
+        
         return Bytecode(self.instructions, self.constants)
     
+    def _resolve_labels(self):
+        """Resolve label strings to instruction indices"""
+        labels = {}
+        
+        # 1. Map labels
+        for i, (op, operand) in enumerate(self.instructions):
+            if op == Opcode.NOP and isinstance(operand, str) and operand.startswith('L'):
+                labels[operand] = i
+        
+        # 2. Update jumps
+        for i, (op, operand) in enumerate(self.instructions):
+            if op in (Opcode.JUMP, Opcode.JUMP_IF_FALSE, Opcode.JUMP_IF_TRUE):
+                if isinstance(operand, str) and operand in labels:
+                    self.instructions[i] = (op, labels[operand])
+
     def _add_constant(self, value) -> int:
         """Add constant to pool, return index"""
-        # Deduplicate constants
-        key = (type(value).__name__, str(value))
-        if key in self.constant_map:
+        # Deduplicate only cheap, stable primitive constants.
+        # Avoid calling str(value) for large/complex values (AST nodes, dicts,
+        # bytecode specs) because that can be expensive on large programs and
+        # can balloon memory.
+        key = None
+        if value is None or isinstance(value, (bool, int, float, str)):
+            if isinstance(value, str) and len(value) > 256:
+                key = None
+            else:
+                key = (type(value), value)
+        if key is not None and key in self.constant_map:
             return self.constant_map[key]
         
         idx = len(self.constants)
         self.constants.append(value)
-        self.constant_map[key] = idx
+        if key is not None:
+            self.constant_map[key] = idx
         return idx
     
     def _emit(self, opcode: Opcode, *args):
@@ -117,6 +143,7 @@ class BytecodeCompiler:
         """Return a friendly message for unsupported nodes."""
         hints = {
             "UseStatement": "Module imports",
+            "FromStatement": "Module imports",
             "EntityStatement": "Entity declarations",
             "ContractStatement": "Contract declarations",
             "ActionStatement": "Action/function declarations",
@@ -170,7 +197,53 @@ class BytecodeCompiler:
             self._emit(Opcode.PRINT)
     
     def _compile_LetStatement(self, node):
-        """Compile let/const declaration"""
+        """Compile let/const declaration, including destructuring patterns."""
+        from ..zexus_ast import DestructurePattern
+        
+        if isinstance(node.name, DestructurePattern):
+            # Compile the RHS value expression — leaves it on the stack
+            self._compile_node(node.value)
+            pattern = node.name
+            
+            if pattern.kind == 'map':
+                for source_key, target_name in pattern.bindings:
+                    # DUP the map on the stack so we can index multiple times
+                    self._emit(Opcode.DUP)
+                    # Push the key string
+                    key_idx = self._add_constant(source_key)
+                    self._emit(Opcode.LOAD_CONST, key_idx)
+                    # Index into the map: map[key]
+                    self._emit(Opcode.INDEX)
+                    # Store to local name
+                    name_idx = self._add_constant(target_name)
+                    self._emit(Opcode.STORE_NAME, name_idx)
+                # Pop the original map off the stack
+                self._emit(Opcode.POP)
+            elif pattern.kind == 'list':
+                for idx, target_name in pattern.bindings:
+                    self._emit(Opcode.DUP)
+                    idx_const = self._add_constant(idx)
+                    self._emit(Opcode.LOAD_CONST, idx_const)
+                    self._emit(Opcode.INDEX)
+                    name_idx = self._add_constant(target_name)
+                    self._emit(Opcode.STORE_NAME, name_idx)
+                # Handle rest element: ..rest captures remaining items
+                if pattern.rest:
+                    rest_start = len(pattern.bindings)
+                    # SLICE expects stack: [obj, start, end]
+                    self._emit(Opcode.DUP)                              # list
+                    start_idx = self._add_constant(rest_start)
+                    self._emit(Opcode.LOAD_CONST, start_idx)            # start
+                    none_idx = self._add_constant(None)
+                    self._emit(Opcode.LOAD_CONST, none_idx)             # end (None = to end)
+                    self._emit(Opcode.SLICE)
+                    rest_name_idx = self._add_constant(pattern.rest)
+                    self._emit(Opcode.STORE_NAME, rest_name_idx)
+                # Pop the original list off the stack
+                self._emit(Opcode.POP)
+            return
+        
+        # Normal (non-destructuring) let/const
         # Compile value
         self._compile_node(node.value)
         
@@ -224,6 +297,30 @@ class BytecodeCompiler:
         """Load boolean constant"""
         const_idx = self._add_constant(node.value)
         self._emit(Opcode.LOAD_CONST, const_idx)
+
+    def _compile_NullLiteral(self, node):
+        """Load null constant"""
+        const_idx = self._add_constant(None)
+        self._emit(Opcode.LOAD_CONST, const_idx)
+
+    def _compile_PropertyAccessExpression(self, node):
+        """Compile property access"""
+        # Compile object
+        self._compile_node(node.object)
+        
+        if node.computed:
+            # Bracket notation: obj[expr]
+            self._compile_node(node.property)
+            self._emit(Opcode.INDEX)
+        else:
+            # Dot notation: obj.prop
+            if hasattr(node.property, 'value'):
+                name = node.property.value
+            else:
+                name = str(node.property)
+            const_idx = self._add_constant(name)
+            self._emit(Opcode.LOAD_CONST, const_idx)
+            self._emit(Opcode.GET_ATTR)
     
     # ==================== Binary Operations ====================
     
@@ -300,6 +397,29 @@ class BytecodeCompiler:
         self._emit(Opcode.NOP)
         self.instructions[-1] = (Opcode.NOP, end_label)
     
+    _compile_IfStatement = _compile_IfExpression
+
+    def _compile_TernaryExpression(self, node):
+        """Compile ternary expression (cond ? true : false)"""
+        # Compile condition
+        self._compile_node(node.condition)
+        
+        # Jump if false
+        else_label = self._make_label()
+        end_label = self._make_label()
+        
+        self._emit(Opcode.JUMP_IF_FALSE, else_label)
+        
+        # True branch
+        self._compile_node(node.true_value)
+        self._emit(Opcode.JUMP, end_label)
+        
+        # False branch
+        self._mark_label(else_label)
+        self._compile_node(node.false_value)
+        
+        self._mark_label(end_label)
+
     def _compile_WhileStatement(self, node):
         """Compile while loop"""
         start_label = self._make_label()
@@ -423,6 +543,8 @@ class BytecodeCompiler:
         count = len(node.elements)
         self._emit(Opcode.BUILD_LIST, count)
     
+    _compile_ListLiteral = _compile_ArrayLiteral
+
     def _compile_MapLiteral(self, node):
         """Compile map/dictionary literal"""
         # Compile key-value pairs
@@ -447,7 +569,583 @@ class BytecodeCompiler:
         self._compile_node(node.left)
         self._compile_node(node.index)
         self._emit(Opcode.INDEX)
+
+    def _compile_PropertyAccessExpression(self, node):
+        """Compile property access (obj.prop or obj[expr])."""
+        self._compile_node(node.object)
+
+        if getattr(node, "computed", False):
+            self._compile_node(node.property)
+        else:
+            prop_name = node.property.value if hasattr(node.property, 'value') else str(node.property)
+            prop_idx = self._add_constant(prop_name)
+            self._emit(Opcode.LOAD_CONST, prop_idx)
+
+        self._emit(Opcode.INDEX)
+
+    def _compile_SliceExpression(self, node):
+        """Compile slice expression: obj[start:end]"""
+        self._compile_node(node.object)
+
+        if node.start is not None:
+            self._compile_node(node.start)
+        else:
+            self._emit(Opcode.LOAD_CONST, self._add_constant(None))
+
+        if node.end is not None:
+            self._compile_node(node.end)
+        else:
+            self._emit(Opcode.LOAD_CONST, self._add_constant(None))
+
+        self._emit(Opcode.SLICE)
+
+    # ==================== Advanced Control Flow & Declarations ====================
+
+    def _compile_ActionStatement(self, node):
+        """Compile action/function definition"""
+        # Create a new compiler for the function body
+        func_compiler = self.__class__()
+        
+        # Compile body
+        func_compiler._compile_node(node.body)
+        
+        # Ensure implicit return (null) if execution flows off the end
+        null_idx = func_compiler._add_constant(None)
+        func_compiler._emit(Opcode.LOAD_CONST, null_idx)
+        func_compiler._emit(Opcode.RETURN)
+        
+        # Get bytecode
+        from .bytecode import Bytecode
+        func_compiler._resolve_labels()
+        func_bytecode = Bytecode(func_compiler.instructions, func_compiler.constants)
+        
+        # Prepare function descriptor
+        params = [p.value if hasattr(p, 'value') else str(p) for p in node.parameters]
+        func_desc = {
+            "bytecode": func_bytecode,
+            "params": params,
+            "is_async": getattr(node, 'is_async', False),
+            "name": node.name.value if hasattr(node.name, 'value') else str(node.name)
+        }
+        
+        # Store using STORE_FUNC
+        # Operand: (name_idx, func_const_idx)
+        func_idx = self._add_constant(func_desc)
+        name_idx = self._add_constant(func_desc["name"])
+        
+        self._emit(Opcode.STORE_FUNC, (name_idx, func_idx))
+
+    # Aliases for other function types
+    _compile_FunctionStatement = _compile_ActionStatement
+    _compile_PureFunctionStatement = _compile_ActionStatement
+
+    def _compile_ConstStatement(self, node):
+        """Compile const declaration (same as Let for current VM)"""
+        self._compile_LetStatement(node)
+
+    def _compile_FileImportExpression(self, node):
+        """Compile file import expression (<<)"""
+        self._compile_node(node.filepath)
+        self._emit(Opcode.READ)
+
+    def _compile_AssignmentExpression(self, node):
+        """Compile variable or property assignment"""
+        
+        # Check target type
+        target = node.name
+        
+        # 1. Variable Assignment (target is Identifier or string)
+        if isinstance(target, (zexus_ast.Identifier, str)):
+            self._compile_node(node.value)
+            self._emit(Opcode.DUP)
+            name = target.value if hasattr(target, 'value') else str(target)
+            name_idx = self._add_constant(name)
+            self._emit(Opcode.STORE_NAME, name_idx)
+            return
+
+        # 2. Property/Index Assignment (target[key] = value, target.prop = value)
+        if hasattr(zexus_ast, 'IndexExpression') and isinstance(target, zexus_ast.IndexExpression) or \
+           isinstance(target, zexus_ast.PropertyAccessExpression):
+            # Transform to obj.set(key, value)
+            
+            # 2a. Compile object
+            obj = target.object if isinstance(target, zexus_ast.PropertyAccessExpression) else target.left
+            self._compile_node(obj)
+            
+            # 2b. Compile key
+            if isinstance(target, zexus_ast.PropertyAccessExpression):
+                if target.computed:
+                    self._compile_node(target.property)
+                else:
+                    if hasattr(target.property, 'value'):
+                        prop_name = target.property.value
+                    else:
+                        prop_name = str(target.property)
+                    idx = self._add_constant(prop_name)
+                    self._emit(Opcode.LOAD_CONST, idx)
+            else: # IndexExpression
+                self._compile_node(target.index)
+            
+            # 2c. Compile value
+            self._compile_node(node.value)
+            
+            # 2d. Call set(key, value)
+            method_idx = self._add_constant("set")
+            self._emit(Opcode.CALL_METHOD, (method_idx, 2))
+            return
+
+        raise UnsupportedNodeError(type(target).__name__, "Assignment target not supported")
+
+    def _compile_UseStatement(self, node):
+        """Compile module import via VM import helper."""
+        file_path_attr = getattr(node, 'file_path', None) or getattr(node, 'embedded_ref', None)
+        path = file_path_attr.value if hasattr(file_path_attr, 'value') else str(file_path_attr or "")
+        alias = node.alias.value if node.alias and hasattr(node.alias, 'value') else (node.alias or "")
+
+        names_list = []
+        if getattr(node, 'names', None):
+            for entry in node.names:
+                if entry is None:
+                    continue
+                names_list.append(entry.value if hasattr(entry, 'value') else str(entry))
+
+        spec = {
+            "file": path,
+            "alias": alias,
+            "names": names_list,
+            "is_named": bool(getattr(node, 'is_named_import', False)) and len(names_list) > 0,
+        }
+
+        spec_idx = self._add_constant(spec)
+        self._emit(Opcode.LOAD_CONST, spec_idx)
+        name_idx = self._add_constant("__vm_use_module__")
+        self._emit(Opcode.CALL_NAME, (name_idx, 1))
+        self._emit(Opcode.POP)
+
+    def _compile_FromStatement(self, node):
+        """Compile from-import statements into VM helper calls."""
+        file_path_attr = getattr(node, 'file_path', None) or getattr(node, 'embedded_ref', None)
+        file_path = file_path_attr.value if hasattr(file_path_attr, 'value') else str(file_path_attr or "")
+        entries = []
+        for entry in getattr(node, 'imports', []) or []:
+            if isinstance(entry, (list, tuple)):
+                base = entry[0] if len(entry) > 0 else None
+                alias = entry[1] if len(entry) > 1 else None
+            else:
+                base = entry
+                alias = None
+            if base is None:
+                continue
+            entries.append({
+                "name": base.value if hasattr(base, 'value') else str(base),
+                "alias": alias.value if hasattr(alias, 'value') else (str(alias) if alias else ""),
+            })
+
+        spec = {
+            "file": file_path,
+            "imports": entries,
+        }
+
+        spec_idx = self._add_constant(spec)
+        self._emit(Opcode.LOAD_CONST, spec_idx)
+        name_idx = self._add_constant("__vm_from_module__")
+        self._emit(Opcode.CALL_NAME, (name_idx, 1))
+        self._emit(Opcode.POP)
+
+    def _compile_TxStatement(self, node):
+        """Compile transaction block with automatic revert on error.
+
+        Emits:
+            TX_BEGIN
+            SETUP_TRY catch_label
+            <body>
+            POP_TRY
+            TX_COMMIT
+            JUMP end_label
+          catch_label:
+            POP            ; discard exception value
+            TX_REVERT
+            THROW          ; re-raise so callers see the error
+          end_label:
+        """
+        catch_label = self._make_label()
+        end_label = self._make_label()
+
+        self._emit(Opcode.TX_BEGIN)
+        self._emit(Opcode.SETUP_TRY, catch_label)
+        self._compile_node(node.body)
+        self._emit(Opcode.POP_TRY)
+        self._emit(Opcode.TX_COMMIT)
+        self._emit(Opcode.JUMP, end_label)
+
+        # Exception handler — revert and re-raise
+        self._mark_label(catch_label)
+        self._emit(Opcode.TX_REVERT)
+        self._emit(Opcode.THROW)
+
+        self._mark_label(end_label)
+
+    def _compile_GCStatement(self, node):
+        """Compile GC statement"""
+        # Call builtin gc(action)
+        action = node.action.value if hasattr(node.action, 'value') else str(node.action)
+        
+        # Load 'gc' function name
+        gc_idx = self._add_constant("gc")
+        
+        # Load action argument
+        action_idx = self._add_constant(action)
+        self._emit(Opcode.LOAD_CONST, action_idx)
+        
+        # Call gc(action)
+        self._emit(Opcode.CALL_NAME, (gc_idx, 1))
+        self._emit(Opcode.POP)
+
     
+    def _compile_ContractStatement(self, node):
+        """Compile smart contract definition into bytecode that creates a real
+        SmartContract object at runtime.
+
+        Stack layout at DEFINE_CONTRACT execution (top → bottom):
+            contract_name
+            value_N, name_N   ← last storage var
+            ...
+            value_1, name_1   ← first storage var
+
+        The AST node is stored in the constants pool so the VM can create
+        Action objects (which hold the AST body + closure environment) and
+        access storage_vars metadata for SmartContract construction.
+        """
+        contract_name = node.name.value
+
+        # Store the full AST node in constants so the VM has access to
+        # action definitions (parameters, body) and storage_vars metadata.
+        ast_idx = self._add_constant(node)
+
+        # Compile storage initial values to bytecode.
+        # Each var pushes (name, value) onto the stack.
+        storage_vars = getattr(node, 'storage_vars', [])
+        for sv in storage_vars:
+            # Push var name
+            var_name = sv.name.value if hasattr(sv, 'name') and hasattr(sv.name, 'value') else str(getattr(sv, 'name', ''))
+            self._emit(Opcode.LOAD_CONST, self._add_constant(var_name))
+            # Push initial value (or None)
+            if getattr(sv, 'initial_value', None):
+                self._compile_node(sv.initial_value)
+            else:
+                self._emit(Opcode.LOAD_CONST, self._add_constant(None))
+
+        # Push contract name
+        name_idx = self._add_constant(contract_name)
+        self._emit(Opcode.LOAD_CONST, name_idx)
+
+        # Emit DEFINE_CONTRACT with (ast_idx, storage_count) so the VM can
+        # reconstruct the full SmartContract.
+        self._emit(Opcode.DEFINE_CONTRACT, (ast_idx, len(storage_vars)))
+
+        # Store the contract in the environment
+        self._emit(Opcode.STORE_NAME, name_idx)
+
+    def _compile_BreakStatement(self, node):
+        """Compile break statement"""
+        if not self.loop_stack:
+            raise BytecodeCompilationError("Break statement outside loop")
+        self._emit(Opcode.JUMP, self.loop_stack[-1]['end'])
+
+    def _compile_ContinueStatement(self, node):
+        """Compile continue statement
+        
+        Behavior:
+        - If inside a loop: Jump to loop start (next iteration).
+        - If outside a loop: Enable 'Continue On Error' mode globally.
+        """
+        if self.loop_stack:
+            # Inside loop: Standard control flow
+            self._emit(Opcode.JUMP, self.loop_stack[-1]['continue'])
+        else:
+            # Outside loop: Enable error resilience
+            self._emit(Opcode.ENABLE_ERROR_MODE)
+
+    def _compile_RequireStatement(self, node):
+        """Compile require(condition, message)"""
+        self._compile_node(node.condition)
+        
+        if node.message:
+            self._compile_node(node.message)
+        else:
+            self._emit(Opcode.LOAD_CONST, self._add_constant("Requirement failed"))
+            
+        self._emit(Opcode.REQUIRE)
+
+    def _compile_RevertStatement(self, node):
+        """Compile revert(reason)"""
+        if node.reason:
+            self._compile_node(node.reason)
+        else:
+            self._emit(Opcode.LOAD_CONST, self._add_constant("Transaction reverted"))
+            
+        self._emit(Opcode.TX_REVERT)
+
+    def _compile_TryCatchStatement(self, node):
+        """Compile try-catch block"""
+        catch_label = self._make_label()
+        end_label = self._make_label()
+        
+        # SETUP_TRY catch_label
+        # (Assuming SETUP_TRY takes a jump target)
+        # Note: Opcode must handle jump target resolution. 
+        # Typically JUMP opcodes use labels. Here we treat SETUP_TRY like a jump-setup.
+        self._emit(Opcode.SETUP_TRY, catch_label)
+        
+        self._compile_node(node.try_block)
+        
+        self._emit(Opcode.POP_TRY)
+        self._emit(Opcode.JUMP, end_label)
+        
+        # Catch block
+        self._mark_label(catch_label)
+        
+        # Exception provided on stack?
+        if node.error_variable:
+            self._emit(Opcode.STORE_NAME, self._add_constant(node.error_variable.value))
+        else:
+            self._emit(Opcode.POP)
+            
+        self._compile_node(node.catch_block)
+        
+        self._mark_label(end_label)
+
+    def _unsupported_message(self, node_type):
+        """Helper for unsupported messages"""
+        return f"Node type '{node_type}' is not currently supported by the bytecode compiler."
+
+    def _compile_AwaitExpression(self, node):
+        """Compile await expression"""
+        self._compile_node(node.argument)
+        self._emit(Opcode.AWAIT)
+
+    def _compile_ThisExpression(self, node):
+        """Compile 'this' expression"""
+        # Load 'this' from environment (it's passed as implicit argument in methods)
+        name_idx = self._add_constant("this")
+        self._emit(Opcode.LOAD_NAME, name_idx)
+
+    def _compile_EntityStatement(self, node):
+        """Compile Entity definition"""
+        # Similar to Contract, but uses DEFINE_ENTITY
+        entity_name = node.name.value
+        name_idx = self._add_constant(entity_name)
+        
+        # Push name
+        self._emit(Opcode.LOAD_CONST, name_idx)
+        
+        # Compile body members
+        member_count = 0
+        if hasattr(node.body, 'statements'):
+            for stmt in node.body.statements:
+                stmt_type = type(stmt).__name__
+                # Reuse state/action compilation
+                if stmt_type in ('StateStatement', 'ActionStatement'):
+                    if stmt_type == 'StateStatement':
+                         # Value
+                        if getattr(stmt, 'initial_value', None):
+                            self._compile_node(stmt.initial_value)
+                        else:
+                            self._emit(Opcode.LOAD_CONST, self._add_constant(None))
+                        # Name
+                        self._emit(Opcode.LOAD_CONST, self._add_constant(stmt.name.value))
+                    elif stmt_type == 'ActionStatement':
+                        self._compile_node(stmt)
+                        self._emit(Opcode.LOAD_NAME, self._add_constant(stmt.name.value))
+                        self._emit(Opcode.LOAD_CONST, self._add_constant(stmt.name.value))
+                    
+                    member_count += 1
+
+        self._emit(Opcode.DEFINE_ENTITY, member_count)
+        self._emit(Opcode.STORE_NAME, name_idx)
+
+    def _compile_DataStatement(self, node):
+        """Compile Data/Dataclass definition"""
+        # Data objects are simpler entities
+        # For now, map to Entity logic or simple Struct
+        # We'll use DEFINE_ENTITY for now to keep it uniform
+        
+        data_name = node.name.value
+        name_idx = self._add_constant(data_name)
+        self._emit(Opcode.LOAD_CONST, name_idx)
+        
+        member_count = 0
+        if node.fields:
+            for field in node.fields:
+                # Default value
+                if field.default_value:
+                    self._compile_node(field.default_value)
+                else:
+                    self._emit(Opcode.LOAD_CONST, self._add_constant(None))
+                
+                # Field name
+                field_name = field.name.value if hasattr(field.name, 'value') else str(field.name)
+                self._emit(Opcode.LOAD_CONST, self._add_constant(field_name))
+                member_count += 1
+                
+        self._emit(Opcode.DEFINE_ENTITY, member_count)
+        self._emit(Opcode.STORE_NAME, name_idx)
+        
+    def _compile_CapabilityStatement(self, node):
+        """Compile capability definition"""
+        # Load definition map
+        if node.definition:
+            self._compile_node(node.definition)
+        else:
+            self._emit(Opcode.LOAD_CONST, self._add_constant(None))
+            
+        # Load name
+        name = node.name.value if hasattr(node.name, 'value') else str(node.name)
+        self._emit(Opcode.LOAD_CONST, self._add_constant(name))
+        
+        self._emit(Opcode.DEFINE_CAPABILITY)
+
+    def _compile_GrantStatement(self, node):
+        """Compile grant capability"""
+        # Logic: Push Entity (or name), Push Caps... Emit GRANT
+        
+        # Push entity name (string)
+        entity = node.entity_name.value if hasattr(node.entity_name, 'value') else str(node.entity_name)
+        self._emit(Opcode.LOAD_CONST, self._add_constant(entity))
+        
+        # Traverse capabilities
+        count = 0
+        for cap in node.capabilities:
+            cap_name = cap.value if hasattr(cap, 'value') else str(cap)
+            self._emit(Opcode.LOAD_CONST, self._add_constant(cap_name))
+            count += 1
+            
+        self._emit(Opcode.GRANT_CAPABILITY, count)
+
+    def _compile_RevokeStatement(self, node):
+        """Compile revoke capability"""
+        # Push entity name
+        entity = node.entity_name.value if hasattr(node.entity_name, 'value') else str(node.entity_name)
+        self._emit(Opcode.LOAD_CONST, self._add_constant(entity))
+        
+        # Traverse capabilities
+        count = 0
+        for cap in node.capabilities:
+            cap_name = cap.value if hasattr(cap, 'value') else str(cap)
+            self._emit(Opcode.LOAD_CONST, self._add_constant(cap_name))
+            count += 1
+            
+        self._emit(Opcode.REVOKE_CAPABILITY, count)
+
+    def _compile_AuditStatement(self, node):
+        """Compile audit log"""
+        # AuditStatement(data_name, action_type, timestamp)
+        
+        # Load data name (variable being audited)
+        data_name = node.data_name.value if hasattr(node.data_name, 'value') else str(node.data_name)
+        self._emit(Opcode.LOAD_CONST, self._add_constant(data_name))
+        
+        # Load action type
+        if hasattr(node.action_type, 'value'):
+            self._emit(Opcode.LOAD_CONST, self._add_constant(node.action_type.value))
+        else:
+            self._emit(Opcode.LOAD_CONST, self._add_constant(str(node.action_type)))
+            
+        # Load timestamp (if any)
+        if node.timestamp:
+            self._compile_node(node.timestamp)
+        else:
+             self._emit(Opcode.LOAD_CONST, self._add_constant(None))
+             
+        self._emit(Opcode.AUDIT_LOG)
+
+    def _compile_RestrictStatement(self, node):
+        """Compile restrict access"""
+        # RestrictStatement(target, restriction_type)
+        # target is PropertyAccessExpression usually (obj.field) or Identifier
+        
+        if hasattr(node.target, 'object'):
+            # Property access: obj.field
+            self._compile_node(node.target.object) # Push object
+            
+            # Helper to get property name
+            prop_name = node.target.property.value if hasattr(node.target.property, 'value') else str(node.target.property)
+            self._emit(Opcode.LOAD_CONST, self._add_constant(prop_name))
+        else:
+            # Just identifier
+            self._emit(Opcode.LOAD_NAME, self._add_constant(node.target.value))
+            self._emit(Opcode.LOAD_CONST, self._add_constant(None)) # No property
+
+        # Load restriction string
+        res_type = node.restriction_type if isinstance(node.restriction_type, str) else str(node.restriction_type)
+        self._emit(Opcode.LOAD_CONST, self._add_constant(res_type))
+        
+        self._emit(Opcode.RESTRICT_ACCESS)
+
+
+    def _compile_PatternStatement(self, node):
+        """Compile pattern matching (match statement)"""
+        # Logic:
+        # evaluate value -> store in temp
+        # for each case:
+        #   load value
+        #   evaluate pattern
+        #   check match (simulated EQ)
+        #   jump_if_false -> next_case
+        #   execute action
+        #   jump -> end
+        
+        # Evaluate match subject
+        self._compile_node(node.value if hasattr(node, 'value') else node.expression)
+        
+        end_label = self._make_label()
+        
+        # Iterate cases
+        for case in node.cases:
+            next_case_lbl = self._make_label()
+            
+            # Duplicate Subject (Stack: [..., subj, subj])
+            self._emit(Opcode.DUP)
+            
+            # Evaluate Pattern
+            # Note: AST might call it 'pattern' or something else depending on Case node type
+            pattern_node = getattr(case, 'pattern', None)
+            if pattern_node:
+                # LiteralPattern holds a literal node in .value
+                if isinstance(pattern_node, zexus_ast.LiteralPattern):
+                    self._compile_node(pattern_node.value)
+                # Wildcard/Variable patterns always match; skip pattern compilation
+                elif isinstance(pattern_node, (zexus_ast.WildcardPattern, zexus_ast.VariablePattern)):
+                    pass
+                else:
+                    self._compile_node(pattern_node)
+            
+            # Equality check
+            self._emit(Opcode.EQ)
+            
+            # Jump if False
+            self._emit(Opcode.JUMP_IF_FALSE, next_case_lbl)
+            
+            # Match! 
+            # Pop subject
+            self._emit(Opcode.POP)
+            
+            # Execute Action/Consequence
+            # MatchExpression uses 'consequence', PatternStatement uses 'action', MatchCase uses 'result'
+            body = getattr(case, 'consequence', getattr(case, 'action', getattr(case, 'result', None)))
+            self._compile_node(body)
+            self._emit(Opcode.JUMP, end_label)
+            
+            # Next Case
+            self._mark_label(next_case_lbl)
+            
+        # No match? Pop subject
+        self._emit(Opcode.POP)
+        self._mark_label(end_label)
+
+    # Alias MatchExpression to logic (it's similar enough for basic cases)
+    _compile_MatchExpression = _compile_PatternStatement
+
     # ==================== Fallback for unsupported nodes ====================
     
     def __getattr__(self, name):