zexus 1.7.1 → 1.7.2

package/src/zexus/evaluator/expressions.py

@@ -11,16 +11,85 @@ from ..object import (
     Integer, Float, String, List, Map,
     EvaluationError, Builtin, DateTime
 )
+from ..config import config as zexus_config
 from .utils import is_error, debug_log, NULL, TRUE, FALSE, is_truthy, _python_to_zexus
 
 class ExpressionEvaluatorMixin:
     """Handles evaluation of expressions: Literals, Math, Logic, Identifiers."""
     
+    def eval_property_access_expression(self, node, env, stack_trace=None):
+        obj = self.eval_node(node.object, env, stack_trace)
+        if is_error(obj): return obj
+
+        from ..object import String, Map, List, EvaluationError
+
+        if node.computed:
+            # Index notation: obj[expr]
+            idx = self.eval_node(node.property, env, stack_trace)
+            if is_error(idx): return idx
+            
+            if isinstance(obj, List):
+                 return obj.get(idx)
+            elif isinstance(obj, Map):
+                 key = idx
+                 if isinstance(key, str): key = String(key)
+                 return obj.get(key) or NULL
+            elif isinstance(obj, String):
+                 return obj.get(idx)
+            else:
+                 # Fallback for Python objects
+                 try:
+                     raw_idx = idx.value if hasattr(idx, 'value') else idx
+                     return obj[raw_idx]
+                 except (IndexError, KeyError, TypeError):
+                     return NULL
+        else:
+            # Dot notation: obj.prop
+            if not hasattr(node.property, 'value'):
+                 return EvaluationError(f"Invalid property identifier: {node.property}")
+            
+            prop_name = str(node.property.value)
+            
+            # Check security restrictions (redact, read-only, etc.)
+            try:
+                from ..security import get_security_context
+                ctx = get_security_context()
+                target = f"{getattr(node.object, 'value', str(node.object))}.{prop_name}"
+                restriction = ctx.get_restriction(target)
+                if restriction:
+                    rule = restriction.get('restriction')
+                    if rule == 'redact':
+                        return String('***REDACTED***')
+            except Exception:
+                pass
+            
+            if isinstance(obj, Map):
+                 return obj.get(String(prop_name)) or NULL
+            elif isinstance(obj, dict):
+                 return obj.get(prop_name, NULL)
+            elif hasattr(obj, 'get') and hasattr(obj, 'set') and callable(getattr(obj, 'get', None)):
+                 # Contract-like objects (e.g., SmartContract) expose state via get/set.
+                 # This makes `contract.state_var` reliable and deterministic.
+                 try:
+                     res = obj.get(prop_name)
+                     return res if res is not None else NULL
+                 except Exception:
+                     return NULL
+            else:
+                 # Try getattr (for data classes, etc.)
+                 try:
+                     res = getattr(obj, prop_name, NULL)
+                     return res
+                 except Exception:
+                     return NULL
+
     def eval_identifier(self, node, env):
-        debug_log("eval_identifier", f"Looking up: {node.value}")
+        name = node.value
+        if zexus_config.fast_debug_enabled:
+            debug_log("eval_identifier", f"Looking up: {name}")
         
         # Special case: 'this' keyword should be treated like ThisExpression
-        if node.value == "this":
+        if name == "this":
             # Look for contract instance first
             contract_instance = env.get("__contract_instance__")
             if contract_instance is not None:
@@ -32,21 +101,23 @@ class ExpressionEvaluatorMixin:
                 return data_instance
         
         # First, check environment for user-defined variables (including DATA dataclasses)
-        val = env.get(node.value)
+        val = env.get(name)
         if val:
-            debug_log("  Found in environment", f"{node.value} = {val}")
+            if zexus_config.fast_debug_enabled:
+                 debug_log("  Found in environment", f"{name} = {val}")
             return val
         
         # Check builtins (self.builtins should be defined in FunctionEvaluatorMixin)
         if hasattr(self, 'builtins'):
-            builtin = self.builtins.get(node.value)
+            builtin = self.builtins.get(name)
             if builtin:
-                debug_log("  Found builtin", f"{node.value} = {builtin}")
+                if zexus_config.fast_debug_enabled:
+                    debug_log("  Found builtin", f"{name} = {builtin}")
                 return builtin
         
         # Special handling for TX - ONLY if not already defined by user
         # This provides blockchain transaction context when TX is not a user dataclass
-        if node.value == "TX":
+        if name == "TX":
             from ..blockchain.transaction import get_current_tx, create_tx_context
             tx = get_current_tx()
             if tx is None:
@@ -156,6 +227,12 @@ class ExpressionEvaluatorMixin:
                     suggestion="Check your divisor value. Modulo operation requires a non-zero divisor."
                 )
             return Integer(left_val % right_val)
+        elif operator == "**":
+            if right_val < 0:
+                # Negative exponent returns float
+                return Float(left_val ** right_val)
+            result = left_val ** right_val
+            return check_overflow(result, "exponentiation")
         elif operator == "<": 
             return TRUE if left_val < right_val else FALSE
         elif operator == ">": 
@@ -197,6 +274,11 @@ class ExpressionEvaluatorMixin:
             return TRUE if left_val == right_val else FALSE
         elif operator == "!=": 
             return TRUE if left_val != right_val else FALSE
+        elif operator == "**":
+            try:
+                return Float(left_val ** right_val)
+            except (OverflowError, ValueError) as e:
+                return EvaluationError(f"Exponentiation error: {e}")
         
         return EvaluationError(f"Unknown float operator: {operator}")
     
@@ -363,7 +445,7 @@ class ExpressionEvaluatorMixin:
         
         # SECURITY FIX #8: Strict Type Checking for Arithmetic
         # All arithmetic operations require numeric types (Integer or Float)
-        elif operator in ("*", "-", "/", "%"):
+        elif operator in ("*", "-", "/", "%", "**"):
             # Get type names for error messages
             left_type = type(left).__name__.replace("Obj", "").upper()
             right_type = type(right).__name__.replace("Obj", "").upper()
@@ -400,9 +482,11 @@ class ExpressionEvaluatorMixin:
                         if r_val == 0:
                             return EvaluationError("Modulo by zero")
                         result = l_val % r_val
+                    elif operator == "**":
+                        result = l_val ** r_val
                     
                     # Return Integer if result is whole number, Float otherwise
-                    if result == int(result) and operator != "/":  # Division always returns float
+                    if result == int(result) and operator not in ("/", "**"):  # Division/power always returns float
                         return Integer(int(result))
                     return Float(result)
                 except Exception as e:
@@ -413,6 +497,10 @@ class ExpressionEvaluatorMixin:
         
         # Comparison with mixed numeric types (Integer/Float comparison allowed)
         elif operator in ("<", ">", "<=", ">="):
+            # Safe null handling: Any comparison with NULL is False (except != handled above)
+            if left == NULL or right == NULL:
+                return FALSE
+
             if isinstance(left, (Integer, Float)) and isinstance(right, (Integer, Float)):
                 l_val = float(left.value)
                 r_val = float(right.value)
@@ -443,12 +531,11 @@ class ExpressionEvaluatorMixin:
         
         if operator == "!":
             # !true = false, !false = true, !null = true, !anything_else = false
-            if right == TRUE:
+            # Use is_truthy for robust comparison (handles non-singleton BooleanObj)
+            if is_truthy(right):
                 return FALSE
-            elif right == FALSE or right == NULL:
-                return TRUE
             else:
-                return FALSE
+                return TRUE
         elif operator == "-":
             if isinstance(right, Integer):
                 return Integer(-right.value)
@@ -1032,42 +1119,38 @@ class ExpressionEvaluatorMixin:
     def eval_async_expression(self, node, env, stack_trace):
         """Evaluate async expression: async <expression>
         
-        Executes the expression in a background thread.
-        Example: async producer()
+        Schedules the expression on the shared Zexus event loop.
+        For call expressions, evaluation is deferred entirely to the loop.
+        For coroutine results, driving is done inside a loop task.
         """
-        import threading
+        from ..event_loop import spawn as _spawn
+        import asyncio
         import sys
-        
-        # For call expressions, we need to defer evaluation to the thread
-        # Otherwise evaluating here will execute the action in the main thread
+
+        # For call expressions, we need to defer evaluation to the event loop
         if type(node.expression).__name__ == 'CallExpression':
-            def run_in_thread():
+            async def _run_call():
                 try:
                     result = self.eval_node(node.expression, env, stack_trace)
-                    
+
                     # If it's a Coroutine (from async action), execute it
                     if hasattr(result, '__class__') and result.__class__.__name__ == 'Coroutine':
                         try:
-                            # Prime the generator
                             next(result.generator)
-                            # Execute until completion
                             while True:
                                 next(result.generator)
                         except StopIteration:
-                            pass  # Coroutine completed
-                    
+                            pass
                 except StopIteration:
-                    pass  # Normal coroutine completion
+                    pass
                 except Exception as e:
-                    import sys
                     print(f"[ASYNC ERROR] {type(e).__name__}: {str(e)}", file=sys.stderr, flush=True)
                     import traceback
                     traceback.print_exc(file=sys.stderr)
-            
-            thread = threading.Thread(target=run_in_thread, daemon=True)
-            thread.start()
+
+            _spawn(_run_call())
             return NULL
-        
+
         # For other expressions, evaluate first then check if it's a Coroutine
         previous_allow = getattr(self, "_allow_coroutine_result", False)
         self._allow_coroutine_result = True
@@ -1075,35 +1158,25 @@ class ExpressionEvaluatorMixin:
             result = self.eval_node(node.expression, env, stack_trace)
         finally:
             self._allow_coroutine_result = previous_allow
-        
+
         if is_error(result):
             return result
-        
-        # print(f"[ASYNC EXPR] Expression evaluated to: {type(result).__name__}", file=sys.stderr)
-        
-        # If it's a Coroutine (from calling an async action), execute it in a thread
+
+        # If it's a Coroutine, drive it on the shared event loop
         if hasattr(result, '__class__') and result.__class__.__name__ == 'Coroutine':
-            def run_coroutine():
+            async def _drive_coroutine():
                 try:
-                    # Prime the generator
                     next(result.generator)
-                    # Execute until completion
                     while True:
                         next(result.generator)
                 except StopIteration:
-                    pass  # Coroutine completed normally
+                    pass
                 except Exception as e:
-                    import sys
                     print(f"[ASYNC ERROR] {type(e).__name__}: {str(e)}", file=sys.stderr, flush=True)
                     import traceback
                     traceback.print_exc(file=sys.stderr)
-            
-            thread = threading.Thread(target=run_coroutine, daemon=True)
-            thread.start()
+
+            _spawn(_drive_coroutine())
             return NULL
-        
-        # For any other result (including NULL from regular actions),
-        # we can't execute it asynchronously since it already executed.
-        # Just return NULL to indicate "async operation initiated"
-        # print(f"[ASYNC EXPR] Result is not a coroutine, returning NULL", file=sys.stderr)
+
         return NULL