zexus 1.7.2 → 1.8.1

package/src/zexus/vm/cache.py

@@ -17,7 +17,6 @@ Enhanced: File-based persistent caching for faster repeat runs
 
 import hashlib
 import json
-import pickle
 import time
 from collections import OrderedDict
 from dataclasses import dataclass
@@ -271,8 +270,9 @@ class BytecodeCache:
             constants_size = 0
             for const in bytecode.constants:
                 try:
-                    constants_size += len(pickle.dumps(const))
-                except (TypeError, pickle.PicklingError):
+                    import sys as _sys
+                    constants_size += _sys.getsizeof(const)
+                except (TypeError, ValueError):
                     constants_size += 100  # Fallback estimate
             
             # Add metadata overhead
@@ -504,9 +504,9 @@ class BytecodeCache:
                 with open(cache_file, 'wb') as f:
                     f.write(data)
             else:
-                cache_file = self.cache_dir / f"{key}.cache"
-                with open(cache_file, 'wb') as f:
-                    pickle.dump(bytecode, f, protocol=pickle.HIGHEST_PROTOCOL)
+                # SECURITY (H14): Legacy pickle format disabled — use .zxc only
+                if self.debug:
+                    print(f"⚠️ Cache: Skipping disk save (pickle disabled, .zxc not available)")
             
             if self.debug:
                 print(f"💾 Cache: Saved to disk {key[:8]}...")
@@ -531,14 +531,9 @@ class BytecodeCache:
                         print(f"💾 Cache: Loaded .zxc from disk {key[:8]}...")
                     return bytecode
 
-            # Fallback to legacy pickle format
-            cache_file = self.cache_dir / f"{key}.cache"
-            if cache_file.exists():
-                with open(cache_file, 'rb') as f:
-                    bytecode = pickle.load(f)
-                if self.debug:
-                    print(f"💾 Cache: Loaded .cache from disk {key[:8]}...")
-                return bytecode
+            # SECURITY (H14): Legacy pickle .cache format disabled
+            # Only .zxc binary format is supported for disk cache
+            pass
         except Exception as e:
             if self.debug:
                 print(f"⚠️ Cache: Failed to load from disk: {e}")
@@ -713,10 +708,9 @@ class BytecodeCache:
                     f.write(meta_bytes)
                     f.write(bc_bytes)
             else:
-                cache_file = self.cache_dir / f"file_{file_key}.cache"
-                data = {'metadata': meta_dict, 'bytecodes': bytecodes, 'cached_at': time.time()}
-                with open(cache_file, 'wb') as f:
-                    pickle.dump(data, f, protocol=pickle.HIGHEST_PROTOCOL)
+                # SECURITY (H14): Legacy pickle format disabled
+                if self.debug:
+                    print(f"⚠️ FileCache: Skipping disk save (pickle disabled, .zxc not available)")
             
             if self.debug:
                 print(f"💾 FileCache: Saved to disk {file_key[:8]}...")
@@ -749,16 +743,8 @@ class BytecodeCache:
                     bytecodes = _zxc_deserialize_multi(raw[4 + meta_len:])
                     cache_file = zxc_file
 
-            # Fallback to legacy pickle
-            if bytecodes is None:
-                pkl_file = self.cache_dir / f"file_{file_key}.cache"
-                if pkl_file.exists():
-                    with open(pkl_file, 'rb') as f:
-                        data = pickle.load(f)
-                    cached_meta = data.get('metadata', {})
-                    bytecodes = data.get('bytecodes', [])
-                    cached_at = data.get('cached_at', time.time())
-                    cache_file = pkl_file
+            # SECURITY (H14): Legacy pickle format disabled
+            pass
 
             if cached_meta is None or bytecodes is None:
                 return None
@@ -810,10 +796,11 @@ class BytecodeCache:
             return
         
         try:
-            index_file = self.cache_dir / 'file_index.cache'
+            # SECURITY (H14): Use JSON instead of pickle for index
+            index_file = self.cache_dir / 'file_index.json'
             if index_file.exists():
-                with open(index_file, 'rb') as f:
-                    index = pickle.load(f)
+                with open(index_file, 'r') as f:
+                    index = json.load(f)
                 if self.debug:
                     print(f"📂 FileCache: Loaded index with {len(index)} files")
         except Exception as e:
@@ -826,7 +813,8 @@ class BytecodeCache:
             return
         
         try:
-            index_file = self.cache_dir / 'file_index.cache'
+            # SECURITY (H14): Use JSON instead of pickle for index
+            index_file = self.cache_dir / 'file_index.json'
             # Just save file keys and metadata (not bytecode)
             index = {
                 key: {
@@ -837,8 +825,8 @@ class BytecodeCache:
                 }
                 for key, data in self._file_cache.items()
             }
-            with open(index_file, 'wb') as f:
-                pickle.dump(index, f, protocol=pickle.HIGHEST_PROTOCOL)
+            with open(index_file, 'w') as f:
+                json.dump(index, f)
         except Exception as e:
             if self.debug:
                 print(f"⚠️ FileCache: Failed to save index: {e}")
@@ -985,18 +973,8 @@ class BytecodeCache:
                 cached.get('content_hash') == metadata.content_hash):
                 return True
         
-        # Check disk cache
-        if self.persistent and self.cache_dir:
-            cache_file = self.cache_dir / f"file_{file_key}.cache"
-            if cache_file.exists():
-                try:
-                    with open(cache_file, 'rb') as f:
-                        data = pickle.load(f)
-                    cached_meta = data.get('metadata', {})
-                    return (cached_meta.get('mtime') == metadata.mtime and
-                            cached_meta.get('content_hash') == metadata.content_hash)
-                except Exception:
-                    pass
+        # SECURITY (H14): Legacy pickle .cache disk cache disabled
+        # Only .zxc format is used for disk caching now
         
         return False
     

package/src/zexus/vm/compiler.py

@@ -139,6 +139,20 @@ class BytecodeCompiler:
                 f"Failed to compile {node_type}: {exc}"
             ) from exc
 
+    def _emit_vm_builtin_call(self, builtin_name: str, payload, discard_result: bool = True) -> None:
+        """Emit a VM-builtin call with the AST payload as a constant.
+
+        This is used to keep the VM bytecode compiler aligned with the evaluator
+        bytecode compiler for directive-like statements that the VM can delegate
+        to higher-level helpers when available.
+        """
+        payload_idx = self._add_constant(payload)
+        self._emit(Opcode.LOAD_CONST, payload_idx)
+        name_idx = self._add_constant(builtin_name)
+        self._emit(Opcode.CALL_NAME, (name_idx, 1))
+        if discard_result:
+            self._emit(Opcode.POP)
+
     def _unsupported_message(self, node_type: str) -> str:
         """Return a friendly message for unsupported nodes."""
         hints = {
@@ -801,6 +815,38 @@ class BytecodeCompiler:
         self._emit(Opcode.CALL_NAME, (gc_idx, 1))
         self._emit(Opcode.POP)
 
+    # ------------------------------------------------------------------
+    # Directive-like statements (delegate to VM helpers when available)
+    # ------------------------------------------------------------------
+
+    def _compile_NativeStatement(self, node):
+        """Compile native statement via VM helper (if provided)."""
+        self._emit_vm_builtin_call("__vm_native_statement__", node, discard_result=False)
+
+    def _compile_InlineStatement(self, node):
+        """Compile inline optimization directive via VM helper."""
+        self._emit_vm_builtin_call("__vm_inline_statement__", node, discard_result=False)
+
+    def _compile_BufferStatement(self, node):
+        """Compile buffer directive via VM helper."""
+        self._emit_vm_builtin_call("__vm_buffer_statement__", node, discard_result=False)
+
+    def _compile_SIMDStatement(self, node):
+        """Compile SIMD directive via VM helper."""
+        self._emit_vm_builtin_call("__vm_simd_statement__", node, discard_result=False)
+
+    def _compile_DeferStatement(self, node):
+        """Compile defer directive via VM helper."""
+        self._emit_vm_builtin_call("__vm_defer_statement__", node, discard_result=False)
+
+    def _compile_EmitStatement(self, node):
+        """Compile emit statement via VM helper."""
+        self._emit_vm_builtin_call("__vm_emit_statement__", node, discard_result=False)
+
+    def _compile_ProtocolStatement(self, node):
+        """Compile protocol statement via VM helper."""
+        self._emit_vm_builtin_call("__vm_protocol_statement__", node, discard_result=False)
+
     
     def _compile_ContractStatement(self, node):
         """Compile smart contract definition into bytecode that creates a real
@@ -939,31 +985,45 @@ class BytecodeCompiler:
         # Push name
         self._emit(Opcode.LOAD_CONST, name_idx)
         
-        # Compile body members
+        # Compile properties and methods from EntityStatement's actual attributes
         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
+        
+        # Compile properties (list of dicts with 'name', 'type', 'default_value')
+        for prop in (node.properties or []):
+            prop_name = prop.get('name', '') if isinstance(prop, dict) else getattr(prop, 'name', '')
+            default_val = prop.get('default_value', None) if isinstance(prop, dict) else getattr(prop, 'default_value', None)
+            
+            if default_val is not None:
+                self._compile_node(default_val)
+            else:
+                self._emit(Opcode.LOAD_CONST, self._add_constant(None))
+            self._emit(Opcode.LOAD_CONST, self._add_constant(prop_name))
+            member_count += 1
+        
+        # Compile methods (list of ActionStatement)
+        for method in (node.methods or []):
+            self._compile_node(method)
+            method_name = method.name.value if hasattr(method.name, 'value') else str(method.name)
+            self._emit(Opcode.LOAD_NAME, self._add_constant(method_name))
+            self._emit(Opcode.LOAD_CONST, self._add_constant(method_name))
+            member_count += 1
 
         self._emit(Opcode.DEFINE_ENTITY, member_count)
         self._emit(Opcode.STORE_NAME, name_idx)
 
+    def _compile_ExportStatement(self, node):
+        """Compile export statement - marks names for module export.
+        
+        Export is a declaration/annotation; the exported names are already
+        defined by their own declarations, so this just emits EXPORT opcodes
+        to register them in the module's export table.
+        """
+        for name_node in (node.names or []):
+            name = name_node.value if hasattr(name_node, 'value') else str(name_node)
+            name_idx = self._add_constant(name)
+            self._emit(Opcode.LOAD_NAME, name_idx)
+            self._emit(Opcode.EXPORT, name_idx)
+
     def _compile_DataStatement(self, node):
         """Compile Data/Dataclass definition"""
         # Data objects are simpler entities