zexus 1.6.8 → 1.7.2

package/src/zexus/evaluator/expressions.py

@@ -1,23 +1,95 @@
 # src/zexus/evaluator/expressions.py
+import os
+
 from ..zexus_ast import (
-    IntegerLiteral, FloatLiteral, StringLiteral, ListLiteral, MapLiteral, 
-    Identifier, PrefixExpression, InfixExpression, IfExpression, 
-    Boolean as AST_Boolean, EmbeddedLiteral, ActionLiteral, LambdaExpression
+    IntegerLiteral, FloatLiteral, StringLiteral, ListLiteral, MapLiteral,
+    Identifier, PrefixExpression, InfixExpression, IfExpression,
+    Boolean as AST_Boolean, EmbeddedLiteral, ActionLiteral, LambdaExpression,
+    PropertyAccessExpression,
 )
 from ..object import (
     Integer, Float, String, List, Map,
     EvaluationError, Builtin, DateTime
 )
-from .utils import is_error, debug_log, NULL, TRUE, FALSE, is_truthy
+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:
@@ -29,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:
@@ -111,16 +185,22 @@ class ExpressionEvaluatorMixin:
         # SECURITY FIX #6: Integer overflow protection
         # Python integers have arbitrary precision, but we enforce safe ranges
         # to prevent resource exhaustion and match real-world integer behavior
-        MAX_SAFE_INT = 2**63 - 1  # 64-bit signed integer max
-        MIN_SAFE_INT = -(2**63)   # 64-bit signed integer min
-        
+        MAX_SAFE_BIT_LENGTH = 4096  # Allow values up to ~10^1233 before flagging overflow
+
         def check_overflow(result, operation):
             """Check if integer operation resulted in overflow"""
-            if result > MAX_SAFE_INT or result < MIN_SAFE_INT:
-                return EvaluationError(
-                    f"Integer overflow in {operation}",
-                    suggestion=f"Result {result} exceeds safe integer range [{MIN_SAFE_INT}, {MAX_SAFE_INT}]. Use require() to validate inputs or break calculation into smaller parts."
-                )
+            if isinstance(result, int):
+                bit_length = abs(result).bit_length()
+                if bit_length > MAX_SAFE_BIT_LENGTH:
+                    # Use a quick log10 approximation without importing decimal-heavy helpers
+                    approx_digits = int(bit_length * 0.30103) + 1 if bit_length else 1
+                    return EvaluationError(
+                        f"Integer overflow in {operation}",
+                        suggestion=(
+                            f"Result requires {bit_length} bits (~{approx_digits} digits), exceeding the safe limit of "
+                            f"{MAX_SAFE_BIT_LENGTH} bits. Break the calculation into smaller parts or enable big-integer support."
+                        )
+                    )
             return Integer(result)
         
         if operator == "+":
@@ -147,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 == ">": 
@@ -188,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}")
     
@@ -354,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()
@@ -391,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:
@@ -404,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)
@@ -434,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)
@@ -503,6 +599,215 @@ class ExpressionEvaluatorMixin:
         
         return left
 
+    def _current_directory_from_env(self, env):
+        if not env or not hasattr(env, 'get'):
+            return None
+        try:
+            file_obj = env.get("__file__")
+        except Exception:
+            file_obj = None
+        if not file_obj:
+            return None
+        path = file_obj.value if hasattr(file_obj, 'value') else str(file_obj)
+        if not path:
+            return None
+        return os.path.dirname(path)
+
+    def _evaluate_expression_to_string(self, expr, env, stack_trace, literal_identifiers=False):
+        if literal_identifiers and isinstance(expr, Identifier):
+            return expr.value, None
+        if isinstance(expr, StringLiteral):
+            return expr.value, None
+        if isinstance(expr, IntegerLiteral):
+            return str(expr.value), None
+        if isinstance(expr, FloatLiteral):
+            return str(expr.value), None
+        if isinstance(expr, AST_Boolean):
+            return "true" if expr.value else "false", None
+
+        value = self.eval_node(expr, env, stack_trace)
+        if is_error(value):
+            return None, value
+
+        if hasattr(value, 'value'):
+            return str(value.value), None
+        return str(value), None
+
+    def _flatten_property_chain(self, expr, env, stack_trace):
+        segments = []
+        current = expr
+        while isinstance(current, PropertyAccessExpression):
+            literal_mode = not getattr(current, 'computed', False)
+            segment, error = self._evaluate_expression_to_string(
+                current.property,
+                env,
+                stack_trace,
+                literal_identifiers=literal_mode,
+            )
+            if error:
+                return None, error
+            segments.insert(0, segment)
+            current = current.object
+
+        segment, error = self._evaluate_expression_to_string(
+            current,
+            env,
+            stack_trace,
+            literal_identifiers=True,
+        )
+        if error:
+            return None, error
+        segments.insert(0, segment)
+        return segments, None
+
+    def eval_find_expression(self, node, env, stack_trace):
+        debug_log("eval_find_expression", "find keyword")
+
+        pattern, error = self._evaluate_expression_to_string(
+            node.target,
+            env,
+            stack_trace,
+            literal_identifiers=True,
+        )
+        if error:
+            return error
+
+        if pattern is None or not str(pattern).strip():
+            return EvaluationError("find requires a target path")
+
+        pattern = str(pattern).strip()
+
+        scope = None
+        if getattr(node, 'scope', None) is not None:
+            scope, error = self._evaluate_expression_to_string(
+                node.scope,
+                env,
+                stack_trace,
+                literal_identifiers=True,
+            )
+            if error:
+                return error
+            scope = str(scope).strip() if scope else None
+
+        current_dir = self._current_directory_from_env(env)
+
+        from .. import module_manager
+
+        matches = module_manager.find_files(
+            pattern,
+            current_dir=current_dir,
+            scope=scope,
+        )
+
+        if not matches:
+            suggestion = "Verify the file exists or adjust the scope provided to find."
+            return EvaluationError(
+                f"find could not locate '{pattern}'",
+                suggestion=suggestion,
+            )
+
+        if len(matches) > 1:
+            preview = ", ".join(matches[:3])
+            suggestion = "Provide a more specific path or scope to disambiguate the match."
+            return EvaluationError(
+                f"find found multiple matches for '{pattern}': {preview}",
+                suggestion=suggestion,
+            )
+
+        return String(matches[0], is_trusted=True)
+
+    def eval_load_expression(self, node, env, stack_trace):
+        debug_log("eval_load_expression", "load keyword")
+
+        from ..runtime import get_load_manager
+
+        provider_hint = getattr(node, 'provider_hint', None)
+        provider = provider_hint.lower() if isinstance(provider_hint, str) else None
+
+        segments = None
+        if isinstance(node.target, PropertyAccessExpression):
+            segments, error = self._flatten_property_chain(node.target, env, stack_trace)
+            if error:
+                return error
+
+        manager = get_load_manager()
+
+        key = None
+        if segments:
+            candidate = (segments[0] or "").lower()
+            if provider is None and manager.is_provider_registered(candidate):
+                provider = candidate
+                remainder = [seg for seg in segments[1:] if seg is not None]
+                key = ".".join(remainder)
+            else:
+                key = ".".join(seg for seg in segments if seg is not None)
+
+        if key is None:
+            key, error = self._evaluate_expression_to_string(
+                node.target,
+                env,
+                stack_trace,
+                literal_identifiers=True,
+            )
+            if error:
+                return error
+
+        if isinstance(key, str):
+            key = key.strip()
+
+        if provider:
+            provider = provider.strip().lower()
+
+        if provider and not key:
+            return EvaluationError(
+                "load requires a key when a provider is specified",
+                suggestion="Append the key after the provider, for example load env.API_KEY.",
+            )
+
+        source = None
+        if getattr(node, 'source', None) is not None:
+            source, error = self._evaluate_expression_to_string(
+                node.source,
+                env,
+                stack_trace,
+            )
+            if error:
+                return error
+            if isinstance(source, str):
+                source = source.strip()
+
+        current_dir = self._current_directory_from_env(env)
+
+        if provider and not manager.is_provider_registered(provider):
+            return EvaluationError(
+                f"Unknown load provider '{provider}'",
+                suggestion="Register a provider before using it or choose a supported provider.",
+            )
+
+        try:
+            value = manager.load(
+                key,
+                provider=provider,
+                source=source,
+                current_dir=current_dir,
+            )
+        except FileNotFoundError as exc:
+            suggestion = "Check the referenced file path or provide an absolute path."
+            return EvaluationError(str(exc), suggestion=suggestion)
+        except KeyError:
+            missing = key or "<empty>"
+            message = f"load could not resolve '{missing}'"
+            if provider:
+                message += f" via provider '{provider}'"
+            if source:
+                message += f" from '{source}'"
+            suggestion = "Ensure the value exists or configure a fallback source."
+            return EvaluationError(message, suggestion=suggestion)
+        except Exception as exc:
+            return EvaluationError(f"load failed: {exc}")
+
+        return _python_to_zexus(value, mark_untrusted=True)
+
     def eval_await_expression(self, node, env, stack_trace):
         """Evaluate await expression: await <expression>
         
@@ -814,73 +1119,64 @@ 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
-        result = self.eval_node(node.expression, env, stack_trace)
-        
+        previous_allow = getattr(self, "_allow_coroutine_result", False)
+        self._allow_coroutine_result = True
+        try:
+            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