zexus 1.6.3 → 1.6.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zexus",
-  "version": "1.6.3",
+  "version": "1.6.4",
   "description": "A modern, security-first programming language with blockchain support",
   "main": "index.js",
   "bin": {

package/src/zexus/__init__.py

@@ -4,7 +4,7 @@ Zexus Programming Language
 A declarative, intent-based programming language for modern applications.
 """
 
-__version__ = "1.6.3"
+__version__ = "1.6.4"
 __author__ = "Ziver Labs"
 __email__ = "ziverofficial567@gmail.com"
 

package/src/zexus/cli/main.py

@@ -91,7 +91,7 @@ def show_all_commands():
     console.print("\n[bold green]💡 Tip:[/bold green] Use 'zx <command> --help' for detailed command options\n")
 
 @click.group(invoke_without_command=True)
-@click.version_option(version="1.6.3", prog_name="Zexus")
+@click.version_option(version="1.6.4", prog_name="Zexus")
 @click.option('--syntax-style', type=click.Choice(['universal', 'tolerable', 'auto']),
               default='auto', help='Syntax style to use (universal=strict, tolerable=flexible)')
 @click.option('--advanced-parsing', is_flag=True, default=True,

package/src/zexus/cli/zpm.py

@@ -18,7 +18,7 @@ console = Console()
 
 
 @click.group()
-@click.version_option(version="1.6.3", prog_name="ZPM")
+@click.version_option(version="1.6.4", prog_name="ZPM")
 def cli():
     """ZPM - Zexus Package Manager
     

package/src/zexus/evaluator/core.py

@@ -517,30 +517,21 @@ class Evaluator(ExpressionEvaluatorMixin, StatementEvaluatorMixin, FunctionEvalu
                 if is_error(obj): 
                     return obj
                 
-                # Safely extract property name - property can be Identifier, IntegerLiteral, or other expression
-                # IMPORTANT: For Identifier nodes in index expressions (arr[i]), we need to evaluate them first!
-                if isinstance(node.property, zexus_ast.Identifier):
-                    # This could be either a property name (obj.prop) or an index variable (arr[i])
-                    # We need to check if it's being used as an index (numeric) or property (string)
-                    # First try to evaluate it as an identifier (variable lookup)
-                    prop_result = self.eval_identifier(node.property, env)
-                    if not is_error(prop_result) and not isinstance(prop_result, type(NULL)):
-                        # Successfully found a variable, use its value as the property/index
-                        property_name = prop_result.value if hasattr(prop_result, 'value') else str(prop_result)
-                    else:
-                        # Not found as variable, treat as literal property name (for obj.prop syntax)
-                        property_name = node.property.value
-                elif isinstance(node.property, zexus_ast.IntegerLiteral):
-                    # Direct integer index like arr[0]
-                    property_name = node.property.value
-                elif isinstance(node.property, zexus_ast.PropertyAccessExpression):
-                    # Nested property access - evaluate it
+                # Determine property name based on whether it's computed (obj[expr]) or literal (obj.prop)
+                if hasattr(node, 'computed') and node.computed:
+                    # Computed property (obj[expr]) - always evaluate the expression
                     prop_result = self.eval_node(node.property, env, stack_trace)
                     if is_error(prop_result):
                         return prop_result
                     property_name = prop_result.value if hasattr(prop_result, 'value') else str(prop_result)
+                elif isinstance(node.property, zexus_ast.Identifier):
+                    # Literal property (obj.prop) - use the identifier name directly
+                    property_name = node.property.value
+                elif isinstance(node.property, zexus_ast.IntegerLiteral):
+                    # Direct integer index like arr[0] (for backwards compatibility)
+                    property_name = node.property.value
                 else:
-                    # Evaluate the property expression to get the key
+                    # Fallback: evaluate the property expression
                     prop_result = self.eval_node(node.property, env, stack_trace)
                     if is_error(prop_result):
                         return prop_result

package/src/zexus/evaluator/functions.py

@@ -354,42 +354,67 @@ class FunctionEvaluatorMixin:
             
             elif isinstance(fn, EntityDefinition):
                 debug_log("  Creating entity instance (old format)")
-                # Entity constructor: Person("Alice", 30)
+                # Entity constructor: Person("Alice", 30) or Person{name: "Alice", age: 30}
                 # Create instance with positional arguments mapped to properties
                 from ..object import EntityInstance, String, Integer
                 
                 values = {}
-                # Map positional arguments to property names
-                if isinstance(fn.properties, dict):
-                    prop_names = list(fn.properties.keys())
-                else:
-                    prop_names = [prop['name'] for prop in fn.properties]
                 
-                for i, arg in enumerate(args):
-                    if i < len(prop_names):
-                        values[prop_names[i]] = arg
+                # Special case: If single argument is a Map, use it as field values
+                # This handles Entity{field: value} syntax which becomes Entity(Map{...})
+                if len(args) == 1 and isinstance(args[0], Map):
+                    debug_log("  Single Map argument detected - using as field values")
+                    map_arg = args[0]
+                    # Extract key-value pairs from the Map
+                    for key, value in map_arg.pairs.items():
+                        # Convert key to string if it's a String object
+                        key_str = key.value if isinstance(key, String) else str(key)
+                        values[key_str] = value
+                else:
+                    # Map positional arguments to property names
+                    if isinstance(fn.properties, dict):
+                        prop_names = list(fn.properties.keys())
+                    else:
+                        prop_names = [prop['name'] for prop in fn.properties]
+                    
+                    for i, arg in enumerate(args):
+                        if i < len(prop_names):
+                            values[prop_names[i]] = arg
                 
                 return EntityInstance(fn, values)
             
             # Handle SecurityEntityDefinition (from security.py with methods support)
             from ..security import EntityDefinition as SecurityEntityDef, EntityInstance as SecurityEntityInstance
+            from ..object import String
             if isinstance(fn, SecurityEntityDef):
                 debug_log("  Creating entity instance (with methods)")
                 
                 values = {}
-                # Map positional arguments to property names, INCLUDING INHERITED PROPERTIES
-                # Use get_all_properties() to get the full property list in correct order
-                if hasattr(fn, 'get_all_properties'):
-                    # Get all properties (parent + child) in correct order
-                    all_props = fn.get_all_properties()
-                    prop_names = list(all_props.keys())
-                else:
-                    # Fallback for old-style properties
-                    prop_names = list(fn.properties.keys()) if isinstance(fn.properties, dict) else [prop['name'] for prop in fn.properties]
                 
-                for i, arg in enumerate(args):
-                    if i < len(prop_names):
-                        values[prop_names[i]] = arg
+                # Special case: If single argument is a Map, use it as field values
+                # This handles Entity{field: value} syntax which becomes Entity(Map{...})
+                if len(args) == 1 and isinstance(args[0], Map):
+                    debug_log("  Single Map argument detected - using as field values")
+                    map_arg = args[0]
+                    # Extract key-value pairs from the Map
+                    for key, value in map_arg.pairs.items():
+                        # Convert key to string if it's a String object
+                        key_str = key.value if isinstance(key, String) else str(key)
+                        values[key_str] = value
+                else:
+                    # Map positional arguments to property names, INCLUDING INHERITED PROPERTIES
+                    # Use get_all_properties() to get the full property list in correct order
+                    if hasattr(fn, 'get_all_properties'):
+                        # Get all properties (parent + child) in correct order
+                        all_props = fn.get_all_properties()
+                        prop_names = list(all_props.keys())
+                    else:
+                        # Fallback for old-style properties
+                        prop_names = list(fn.properties.keys()) if isinstance(fn.properties, dict) else [prop['name'] for prop in fn.properties]
+                    
+                    for i, arg in enumerate(args):
+                        if i < len(prop_names):
+                            values[prop_names[i]] = arg
                 
                 debug_log(f"  Entity instance created with {len(values)} properties: {list(values.keys())}")
                 # Use create_instance to handle dependency injection
@@ -1977,6 +2002,8 @@ class FunctionEvaluatorMixin:
                 return Integer(len(arg.value))
             if isinstance(arg, List): 
                 return Integer(len(arg.elements))
+            if isinstance(arg, Map):
+                return Integer(len(arg.pairs))
             # Handle Python list (shouldn't happen, but defensive)
             if isinstance(arg, list):
                 return Integer(len(arg))

package/src/zexus/evaluator/statements.py

@@ -757,15 +757,23 @@ class StatementEvaluatorMixin:
             if is_error(obj):
                 return obj
 
-            # Safely extract property key
-            if hasattr(node.name.property, 'value'):
-                prop_key = node.name.property.value
-            else:
-                # Evaluate property expression
+            # Determine property key based on whether it's computed (obj[expr]) or literal (obj.prop)
+            if hasattr(node.name, 'computed') and node.name.computed:
+                # Computed property (obj[expr]) - evaluate the expression
                 prop_result = self.eval_node(node.name.property, env, stack_trace)
                 if is_error(prop_result):
                     return prop_result
                 prop_key = prop_result.value if hasattr(prop_result, 'value') else str(prop_result)
+            else:
+                # Literal property (obj.prop) - use the identifier name directly
+                if hasattr(node.name.property, 'value'):
+                    prop_key = node.name.property.value
+                else:
+                    # Fallback: evaluate it
+                    prop_result = self.eval_node(node.name.property, env, stack_trace)
+                    if is_error(prop_result):
+                        return prop_result
+                    prop_key = prop_result.value if hasattr(prop_result, 'value') else str(prop_result)
 
             # Evaluate value first
             value = self.eval_node(node.value, env, stack_trace)
@@ -1708,11 +1716,10 @@ class StatementEvaluatorMixin:
         
         # Pass the AST nodes as storage_vars, not the storage dict
         contract = SmartContract(node.name.value, node.storage_vars, actions)
-        contract.deploy()
+        # Deploy with evaluated storage values to avoid storing AST nodes
+        contract.deploy(evaluated_storage_values=storage)
         
-        # Initialize storage with evaluated initial values
-        for var_name, init_val in storage.items():
-            contract.storage.set(var_name, init_val)
+        # Storage values are now set during deploy(), no need to set again
         
         # Check if contract has a constructor and execute it
         if 'constructor' in actions:

package/src/zexus/parser/parser.py

@@ -27,6 +27,7 @@ precedences = {
     SLASH: PRODUCT, STAR: PRODUCT, MOD: PRODUCT,
     LPAREN: CALL,
     LBRACKET: CALL,
+    LBRACE: CALL,  # Entity{...} constructor syntax
     DOT: CALL,
 }
 
@@ -103,6 +104,7 @@ class UltimateParser:
             ASSIGN: self.parse_assignment_expression,
             LAMBDA: self.parse_lambda_infix,  # support arrow-style lambdas: params => body
             LPAREN: self.parse_call_expression,
+            LBRACE: self.parse_constructor_call_expression,  # Entity{field: value} syntax
             LBRACKET: self.parse_index_expression,
             DOT: self.parse_method_call_expression,
         }
@@ -1506,7 +1508,7 @@ class UltimateParser:
             arguments = self.parse_expression_list(RPAREN)
             return MethodCallExpression(object=left, method=method, arguments=arguments)
         else:
-            return PropertyAccessExpression(object=left, property=method)
+            return PropertyAccessExpression(object=left, property=method, computed=False)
 
     def parse_export_statement(self):
         token = self.cur_token
@@ -1709,7 +1711,7 @@ class UltimateParser:
             return None
 
         field_name = Identifier(self.cur_token.literal)
-        target = PropertyAccessExpression(obj_name, field_name)
+        target = PropertyAccessExpression(obj_name, field_name, computed=False)
 
         # Expect assignment
         if not self.expect_peek(ASSIGN):
@@ -2728,6 +2730,18 @@ class UltimateParser:
         exp.arguments = self.parse_expression_list(RPAREN)
         return exp
 
+    def parse_constructor_call_expression(self, function):
+        """Parse constructor call with map literal syntax: Entity{field: value, ...}
+        
+        This converts Entity{a: 1, b: 2} into Entity({a: 1, b: 2})
+        """
+        # Current token is LBRACE, parse it as a map literal
+        map_literal = self.parse_map_literal()
+        
+        # Create a call expression with the map as the single argument
+        exp = CallExpression(function=function, arguments=[map_literal])
+        return exp
+
     def parse_prefix_expression(self):
         expression = PrefixExpression(operator=self.cur_token.literal, right=None)
         self.next_token()
@@ -2800,7 +2814,7 @@ class UltimateParser:
         # Expect closing bracket
         if not self.expect_peek(RBRACKET):
             return None
-        return PropertyAccessExpression(object=left, property=index_expr)
+        return PropertyAccessExpression(object=left, property=index_expr, computed=True)
 
     def _lookahead_token_after_matching_paren(self):
         """Character-level lookahead: detect if the matching ')' is followed by '=>' (arrow).

package/src/zexus/parser/strategy_context.py

@@ -1533,9 +1533,40 @@ class ContextStackParser:
                                     default_val = BooleanLiteral(True)
                                 elif val_token.type == FALSE:
                                     default_val = BooleanLiteral(False)
+                                elif val_token.type == LBRACE:
+                                    # Map literal: {}
+                                    # Find matching RBRACE
+                                    map_start = current_idx
+                                    depth = 1
+                                    current_idx += 1
+                                    while current_idx < brace_end and depth > 0:
+                                        if tokens[current_idx].type == LBRACE:
+                                            depth += 1
+                                        elif tokens[current_idx].type == RBRACE:
+                                            depth -= 1
+                                        current_idx += 1
+                                    # Parse the map literal
+                                    map_tokens = tokens[map_start:current_idx]
+                                    default_val = self._parse_map_literal(map_tokens)
+                                elif val_token.type == LBRACKET:
+                                    # List literal: []
+                                    # Find matching RBRACKET
+                                    list_start = current_idx
+                                    depth = 1
+                                    current_idx += 1
+                                    while current_idx < brace_end and depth > 0:
+                                        if tokens[current_idx].type == LBRACKET:
+                                            depth += 1
+                                        elif tokens[current_idx].type == RBRACKET:
+                                            depth -= 1
+                                        current_idx += 1
+                                    # Parse the list literal
+                                    list_tokens = tokens[list_start:current_idx]
+                                    default_val = self._parse_list_literal(list_tokens)
                                 elif val_token.type == IDENT:
                                     default_val = Identifier(val_token.literal)
-                                current_idx += 1
+                                    current_idx += 1
+                                # Note: current_idx already advanced for LBRACE and LBRACKET cases
 
                         # Use AstNodeShim for compatibility with evaluator
                         storage_vars.append(AstNodeShim(
@@ -3932,6 +3963,24 @@ class ContextStackParser:
                     if i < n and tokens[i].type == RPAREN:
                         i += 1  # Skip RPAREN
                     return CallExpression(Identifier(name), args, type_args=type_args)
+                
+                # Check for constructor call with map literal: Entity{field: value, ...}
+                elif i < n and tokens[i].type == LBRACE:
+                    # Parse the map literal as the single argument
+                    start = i
+                    depth = 1
+                    i += 1  # Skip LBRACE
+                    # Find matching RBRACE
+                    while i < n and depth > 0:
+                        if tokens[i].type == LBRACE:
+                            depth += 1
+                        elif tokens[i].type == RBRACE:
+                            depth -= 1
+                        i += 1
+                    # Parse the map literal tokens (including braces)
+                    map_literal = self._parse_map_literal(tokens[start:i])
+                    return CallExpression(Identifier(name), [map_literal], type_args=type_args)
+                
                 else:
                     return Identifier(name)
 
@@ -3997,7 +4046,8 @@ class ContextStackParser:
                     # Property access: expr.name
                     current_expr = PropertyAccessExpression(
                         object=current_expr,
-                        property=Identifier(name_token.literal)
+                        property=Identifier(name_token.literal),
+                        computed=False
                     )
                 continue
 
@@ -4052,7 +4102,8 @@ class ContextStackParser:
                 prop_expr = self._parse_expression(inner_tokens) if inner_tokens else Identifier('')
                 current_expr = PropertyAccessExpression(
                     object=current_expr,
-                    property=prop_expr
+                    property=prop_expr,
+                    computed=True
                 )
                 continue
 

package/src/zexus/security.py

@@ -734,8 +734,10 @@ class StorageBackend:
 class InMemoryBackend(StorageBackend):
     def __init__(self):
         self.data = {}
-    def set(self, key, value): self.data[key] = value
-    def get(self, key): return self.data.get(key)
+    def set(self, key, value):
+        self.data[key] = value
+    def get(self, key):
+        return self.data.get(key)
     def delete(self, key): 
         if key in self.data: del self.data[key]
 
@@ -954,8 +956,24 @@ class SmartContract:
         
         print(f"   🔗 Contract Address: {new_address}")
 
-        # Deploy the instance (initialize storage)
-        instance.deploy()
+        # Copy initial storage values from the template contract
+        # This ensures instances get the evaluated initial values
+        initial_storage = {}
+        for var_node in self.storage_vars:
+            var_name = None
+            if hasattr(var_node, 'name'):
+                var_name = var_node.name.value if hasattr(var_node.name, 'value') else var_node.name
+            elif isinstance(var_node, dict):
+                var_name = var_node.get("name")
+            
+            if var_name:
+                # Get the initial value from the template contract's storage
+                value = self.storage.get(var_name)
+                if value is not None:
+                    initial_storage[var_name] = value
+        
+        # Deploy the instance with the copied initial values
+        instance.deploy(evaluated_storage_values=initial_storage)
         instance.parent_contract = self
         
         print(f"   Available actions: {list(self.actions.keys())}")
@@ -964,32 +982,32 @@ class SmartContract:
     def __call__(self, *args):
         return self.instantiate(args)
 
-    def deploy(self):
-        """Deploy the contract and initialize persistent storage"""
+    def deploy(self, evaluated_storage_values=None):
+        """Deploy the contract and initialize persistent storage
+        
+        Args:
+            evaluated_storage_values: Optional dict of evaluated initial values
+        """
         # Checks if we should reset storage or strictly load existing
         # For simplicity in this VM, subsequent runs act like "loading" if DB exists
         self.is_deployed = True
         
-        # Initialize storage only if key doesn't exist (preserve persistence)
-        for var_node in self.storage_vars:
-            var_name = None
-            default_value = None
-
-            if hasattr(var_node, 'initial_value'):
-                var_name = var_node.name.value if hasattr(var_node.name, 'value') else var_node.name
-                default_value = var_node.initial_value
-            elif isinstance(var_node, dict) and "initial_value" in var_node:
-                var_name = var_node.get("name")
-                default_value = var_node["initial_value"]
-
-            if var_name:
-                # ONLY set if not already in DB (Persistence Logic)
+        # If evaluated values are provided, use them (from evaluator)
+        if evaluated_storage_values:
+            for var_name, value in evaluated_storage_values.items():
                 if self.storage.get(var_name) is None:
-                    if default_value is not None:
-                        self.storage.set(var_name, default_value)
-                    else:
-                        # Set reasonable defaults for types if null
-                        self.storage.set(var_name, Null)
+                    self.storage.set(var_name, value)
+        else:
+            # Fallback: Initialize storage with NULL for declared variables
+            for var_node in self.storage_vars:
+                var_name = None
+                if hasattr(var_node, 'name'):
+                    var_name = var_node.name.value if hasattr(var_node.name, 'value') else var_node.name
+                elif isinstance(var_node, dict):
+                    var_name = var_node.get("name")
+                
+                if var_name and self.storage.get(var_name) is None:
+                    self.storage.set(var_name, Null)
 
     def call_method(self, action_name, args):
         """Call a contract action - similar to EntityInstance.call_method"""

package/src/zexus/zexus_ast.py

@@ -592,12 +592,13 @@ class LiteralPattern:
         return f"LiteralPattern({self.value})"
 
 class PropertyAccessExpression(Expression):
-    def __init__(self, object, property):
+    def __init__(self, object, property, computed=False):
         self.object = object
         self.property = property
+        self.computed = computed  # True for obj[expr], False for obj.prop
 
     def __repr__(self):
-        return f"PropertyAccessExpression(object={self.object}, property={self.property})"
+        return f"PropertyAccessExpression(object={self.object}, property={self.property}, computed={self.computed})"
 
 class AssignmentExpression(Expression):
     def __init__(self, name, value):

package/src/zexus/zpm/package_manager.py

@@ -23,7 +23,7 @@ class PackageManager:
         self.installer = PackageInstaller(self.zpm_dir)
         self.publisher = PackagePublisher(self.registry)
         
-    def init(self, name: str = None, version: str = "1.6.3") -> Dict:
+    def init(self, name: str = None, version: str = "1.6.4") -> Dict:
         """Initialize a new Zexus project with package.json"""
         if self.config_file.exists():
             print(f"⚠️  {self.config_file} already exists")

package/src/zexus.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zexus
-Version: 1.6.3
+Version: 1.6.4
 Summary: A modern, security-first programming language with blockchain support
 Home-page: https://github.com/Zaidux/zexus-interpreter
 Author: Zaidux

package/src/zexus.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 .gitattributes
 .gitignore
 CHANGELOG.md
+FIX_SUMMARY.md
 LICENSE
 PUBLISH_TO_NPM.md
 README.md
@@ -13,6 +14,7 @@ any.zx
 check_verify_ast.py
 comprehensive_test.zx
 crypto.zx
+debug_parse.py
 debug_persist_ultimate.zx
 demo_backend_server.zx
 demo_backend_simple.zx
@@ -30,8 +32,21 @@ setup.py
 setup_stdlib.sh
 shared_config.json
 test_const_time_debug.zx
+test_contract_assignment.zx
+test_contract_debug.zx
+test_contract_map.zx
 test_data.json
+test_entity_debug.zx
+test_map_assignment.zx
+test_map_debug.zx
+test_map_len.zx
+test_map_persistence.zx
+test_nested_map_assignment.zx
+test_simple_contract.zx
 test_sqlite_python.py
+test_state_variable_type.zx
+test_storage_init.zx
+test_storage_types.zx
 ultimate_test.zx
 zexus.json
 zpics
@@ -348,6 +363,7 @@ examples/test_postgres.zx
 examples/test_sqlite.zx
 examples/token_contract.zx
 examples/ziver_chain_test.zx
+issues/ISSUSE1.md
 linguist-submission/SUBMISSION_INSTRUCTIONS.md
 linguist-submission/grammars.yml
 linguist-submission/languages.yml