zexus 1.6.4 → 1.6.6

package/README.md

@@ -2,7 +2,7 @@
 
 <div align="center">
 
-![Zexus Logo](https://img.shields.io/badge/Zexus-v1.6.3-FF6B35?style=for-the-badge)
+![Zexus Logo](https://img.shields.io/badge/Zexus-v1.6.6-FF6B35?style=for-the-badge)
 [![License](https://img.shields.io/badge/License-MIT-blue.svg?style=for-the-badge)](LICENSE)
 [![Python](https://img.shields.io/badge/Python-3.8+-3776AB?style=for-the-badge&logo=python)](https://python.org)
 [![GitHub](https://img.shields.io/badge/GitHub-Zaidux/zexus--interpreter-181717?style=for-the-badge&logo=github)](https://github.com/Zaidux/zexus-interpreter)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zexus",
-  "version": "1.6.4",
+  "version": "1.6.6",
   "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.4"
+__version__ = "1.6.6"
 __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.4", prog_name="Zexus")
+@click.version_option(version="1.6.6", 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.4", prog_name="ZPM")
+@click.version_option(version="1.6.6", prog_name="ZPM")
 def cli():
     """ZPM - Zexus Package Manager
     

package/src/zexus/evaluator/statements.py

@@ -221,7 +221,7 @@ class StatementEvaluatorMixin:
             return value
         
         # Set as const in environment
-        env.set_const(node.name.value, value)
+        env.set(node.name.value, value)
         return NULL
     
     def eval_data_statement(self, node, env, stack_trace):
@@ -337,6 +337,14 @@ class StatementEvaluatorMixin:
             instance.pairs[String("__immutable__")] = Boolean(is_immutable)
             instance.pairs[String("__verified__")] = Boolean(is_verified)
             
+            # Check if single argument is a Map (from MapLiteral syntax like Block{index: 42})
+            # If so, extract field values from the map instead of treating it as positional args
+            kwargs = None
+            if len(args) == 1 and isinstance(args[0], Map):
+                # Extract keyword arguments from the Map
+                kwargs = args[0].pairs
+                debug_log("dataclass_constructor", f"Extracted {len(kwargs)} kwargs from Map")
+            
             # Process each field with validation (parent fields first, then child fields)
             arg_index = 0
             for field in all_fields:
@@ -348,8 +356,20 @@ class StatementEvaluatorMixin:
                 
                 field_value = NULL
                 
-                # Get value from arguments or default
-                if arg_index < len(args):
+                # Get value from keyword args (map syntax) or positional args
+                if kwargs is not None:
+                    # Try to get value from keyword arguments (map)
+                    field_value = kwargs.get(field_name, NULL)
+                    if field_value == NULL:
+                        # Try with String key
+                        field_value = kwargs.get(String(field_name), NULL)
+                    if field_value == NULL and field.default_value is not None:
+                        # Use default if not provided
+                        field_value = evaluator_self.eval_node(field.default_value, parent_env, stack_trace)
+                        if is_error(field_value):
+                            return field_value
+                elif arg_index < len(args):
+                    # Positional argument
                     field_value = args[arg_index]
                     arg_index += 1
                 elif field.default_value is not None:
@@ -702,10 +722,10 @@ class StatementEvaluatorMixin:
             "default": Builtin(default_static)
         }
         
-        # Register constructor in environment as const
+        # Register constructor in environment
         # For specialized generics (e.g., Box<number>), don't fail if already registered
         try:
-            env.set_const(type_name, constructor)
+            env.set(type_name, constructor)
         except ValueError as e:
             # If it's a specialized generic that's already registered, just return the existing one
             if '<' in type_name and '>' in type_name:

package/src/zexus/lexer.py

@@ -473,7 +473,7 @@ class Lexer:
             "break": BREAK,      # NEW: Break loop keyword
             "throw": THROW,      # NEW: Throw error keyword
             "external": EXTERNAL, # NEW: External keyword
-            "from": FROM,        # NEW: From keyword
+            # "from": FROM,        # NOT a keyword - only recognized contextually in import statements
             "screen": SCREEN,         # NEW: renderer keyword
             "component": COMPONENT,   # NEW: renderer keyword
             "theme": THEME,           # NEW: renderer keyword

package/src/zexus/parser/parser.py

@@ -2666,6 +2666,43 @@ class UltimateParser:
                not self.peek_token_is(RBRACKET) and 
                precedence <= self.peek_precedence()):
 
+            # CRITICAL FIX: Stop if next token is on a new line and could start a new statement
+            # This prevents expressions from spanning multiple logical lines
+            if self.cur_token.line < self.peek_token.line:
+                # Next token is on a new line - check if it could start a new statement
+                next_could_be_statement = (
+                    self.peek_token.type == IDENT or
+                    self.peek_token.type == LET or
+                    self.peek_token.type == CONST or
+                    self.peek_token.type == RETURN or
+                    self.peek_token.type == IF or
+                    self.peek_token.type == WHILE or
+                    self.peek_token.type == FOR
+                )
+                if next_could_be_statement:
+                    # Additional check: is the next token followed by [ or = ?
+                    # This would indicate it's an assignment/index expression starting
+                    if self.peek_token.type == IDENT:
+                        # Save current state to peek ahead
+                        saved_cur = self.cur_token
+                        saved_peek = self.peek_token
+                        saved_pos = self.cur_pos
+                        
+                        # Peek ahead one more token
+                        self.next_token()  # Now peek_token is what we want to check
+                        next_next = self.peek_token
+                        
+                        # Restore state
+                        self.cur_token = saved_cur
+                        self.peek_token = saved_peek
+                        self.cur_pos = saved_pos
+                        
+                        # If next token after IDENT is LBRACKET or ASSIGN, it's likely a new statement
+                        if next_next.type in (LBRACKET, ASSIGN, LPAREN):
+                            break
+                    else:
+                        break
+
             if self.peek_token.type not in self.infix_parse_fns:
                 return left_exp
 

package/src/zexus/parser/strategy_context.py

@@ -3392,6 +3392,11 @@ class ContextStackParser:
                         # E.g., after RPAREN (end of function call) or after a complete value
                         prev_token = run_tokens[-1] if run_tokens else None
                         if prev_token and prev_token.type not in {DOT, LPAREN, LBRACKET, LBRACE, ASSIGN}:
+                            # CRITICAL: Also check for newline - new line + IDENT often indicates new statement
+                            last_line = prev_token.line if hasattr(prev_token, 'line') else 0
+                            current_line = t.line if hasattr(t, 'line') else 0
+                            is_new_line = current_line > last_line
+                            
                             # Check if this starts a new statement (assignment or function call)
                             k = j + 1
                             is_new_statement_start = False
@@ -3404,6 +3409,22 @@ class ContextStackParser:
                                 # Assignment: ident = or ident.prop =
                                 elif next_tok.type == ASSIGN:
                                     is_new_statement_start = True
+                                # CRITICAL FIX: Indexed assignment: ident[...]  =
+                                elif next_tok.type == LBRACKET:
+                                    # Scan for matching RBRACKET followed by ASSIGN
+                                    bracket_depth = 1
+                                    scan_idx = k + 1
+                                    while scan_idx < len(tokens) and scan_idx < k + 20:
+                                        if tokens[scan_idx].type == LBRACKET:
+                                            bracket_depth += 1
+                                        elif tokens[scan_idx].type == RBRACKET:
+                                            bracket_depth -= 1
+                                            if bracket_depth == 0:
+                                                # Found matching closing bracket, check for ASSIGN
+                                                if scan_idx + 1 < len(tokens) and tokens[scan_idx + 1].type == ASSIGN:
+                                                    is_new_statement_start = True
+                                                break
+                                        scan_idx += 1
                                 elif next_tok.type == DOT:
                                     # Property assignment: scan for ASSIGN
                                     while k < len(tokens) and k < j + 10:
@@ -3419,7 +3440,9 @@ class ContextStackParser:
                                         else:
                                             break
                             
-                            if is_new_statement_start:
+                            # Break if this is a new statement AND on a new line
+                            # (or if we're sure it's a new statement regardless of line)
+                            if is_new_statement_start and (is_new_line or prev_token.type == RPAREN):
                                 break
                     
                     # update nesting for parentheses/brackets/braces

package/src/zexus/parser/strategy_structural.py

@@ -728,18 +728,41 @@ class StructuralAnalyzer:
                     if tj.line > last_line:
                         # Check if we have balanced parens in run_tokens (statement is syntactically complete)
                         paren_count = sum(1 if tok.type == LPAREN else -1 if tok.type == RPAREN else 0 for tok in run_tokens)
-                        if paren_count == 0:
+                        bracket_count = sum(1 if tok.type == LBRACKET else -1 if tok.type == RBRACKET else 0 for tok in run_tokens)
+                        if paren_count == 0 and bracket_count == 0:
                             # Check if run_tokens contains an assignment (this is a complete assignment statement)
                             has_assign = any(tok.type == ASSIGN for tok in run_tokens)
-                            if has_assign:
+                            
+                            # CRITICAL FIX: Also check if this is a method call OR indexed assignment statement
+                            # Method call: IDENT DOT IDENT LPAREN
+                            # Indexed assignment: IDENT LBRACKET ... RBRACKET ASSIGN
+                            is_method_call_stmt = False
+                            is_indexed_assign_stmt = False
+                            
+                            if len(run_tokens) >= 4:
+                                # Check for method call pattern: IDENT DOT IDENT LPAREN ... RPAREN
+                                has_dot = any(tok.type == DOT for tok in run_tokens)
+                                if has_dot and run_tokens[0].type == IDENT:
+                                    is_method_call_stmt = True
+                                
+                                # Check for indexed assignment pattern: IDENT LBRACKET ... RBRACKET ASSIGN ...
+                                # Look for IDENT followed by LBRACKET
+                                for idx, tok in enumerate(run_tokens[:-1]):
+                                    if tok.type == IDENT and run_tokens[idx + 1].type == LBRACKET:
+                                        is_indexed_assign_stmt = True
+                                        break
+                            
+                            if has_assign or is_method_call_stmt or is_indexed_assign_stmt:
                                 # Current token is on a new line and could start a new statement
                                 # Check if it's IDENT (could be method call, function call, or property access)
                                 if tj.type == IDENT:
                                     # CRITICAL FIX: Don't break if the previous token was ASSIGN
                                     # This means the IDENT is the RHS value, not a new statement
                                     prev_tok = run_tokens[-1] if run_tokens else None
+                                    print(f"      prev_tok={prev_tok.literal if prev_tok else None}, type={prev_tok.type if prev_tok else None}")
                                     if prev_tok and prev_tok.type == ASSIGN:
                                         # This IDENT is the RHS of the assignment, not a new statement
+                                        print(f"      -> Continuing (RHS of assignment)")
                                         pass  # Don't break, continue collecting
                                     else:
                                         # This is likely a new statement on a new line
@@ -760,6 +783,26 @@ class StructuralAnalyzer:
                         # Look ahead: IDENT DOT IDENT ASSIGN is a property assignment
                         if j + 3 < n and tokens[j + 2].type == IDENT and tokens[j + 3].type == ASSIGN:
                             is_assignment_start = True
+                    # Pattern 3: IDENT followed by LBRACKET could be indexed assignment (arr[i] = ...)
+                    elif tj.type == IDENT and j + 1 < n and tokens[j + 1].type == LBRACKET:
+                        # Look ahead to find matching RBRACKET and then ASSIGN
+                        # This pattern is: IDENT [ ... ] ASSIGN
+                        bracket_depth = 0
+                        k = j + 1
+                        found_assign_after_bracket = False
+                        while k < n:
+                            if tokens[k].type == LBRACKET:
+                                bracket_depth += 1
+                            elif tokens[k].type == RBRACKET:
+                                bracket_depth -= 1
+                                if bracket_depth == 0:
+                                    # Found matching closing bracket, check if next is ASSIGN
+                                    if k + 1 < n and tokens[k + 1].type == ASSIGN:
+                                        found_assign_after_bracket = True
+                                    break
+                            k += 1
+                        if found_assign_after_bracket:
+                            is_assignment_start = True
                     
                     is_new_statement = (
                         tj.type in stop_types or 
@@ -802,6 +845,7 @@ class StructuralAnalyzer:
             
             filtered_run_tokens = [tk for tk in run_tokens if not _is_empty_token(tk)]
             if filtered_run_tokens:  # Only create block if we have meaningful tokens
+                print(f"[DEBUG STRUCTURAL] Creating block from tokens: {[f'{t.type}:{t.literal}' for t in filtered_run_tokens[:10]]}")
                 self.blocks[block_id] = {
                     'id': block_id,
                     'type': 'statement',
@@ -993,11 +1037,12 @@ class StructuralAnalyzer:
                         continue
             
             # NEW: Check for line-based statement boundaries
-            # If we have balanced parens and the next token is on a new line and could start a new statement, create boundary
+            # If we have balanced parens/brackets and the next token is on a new line and could start a new statement, create boundary
             if cur:
-                # Check if parens are balanced
+                # Check if parens and brackets are balanced
                 paren_count = sum(1 if tok.type == LPAREN else -1 if tok.type == RPAREN else 0 for tok in cur)
-                if paren_count == 0:
+                bracket_count = sum(1 if tok.type == LBRACKET else -1 if tok.type == RBRACKET else 0 for tok in cur)
+                if paren_count == 0 and bracket_count == 0:
                     # Check if there's an ASSIGN in cur (this is a complete assignment statement)
                     has_assign = any(tok.type == ASSIGN for tok in cur)
                     if has_assign:
@@ -1005,7 +1050,7 @@ class StructuralAnalyzer:
                         last_line = cur[-1].line if cur else 0
                         if t.line > last_line:
                             # Check if current token could start a new statement
-                            # IDENT followed by DOT or LPAREN could be a new statement
+                            # IDENT could be a new statement (including indexed assignments like map[key] = val)
                             if t.type == IDENT:
                                 # This is likely a new statement on a new line
                                 results.append(cur)

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.4") -> Dict:
+    def init(self, name: str = None, version: str = "1.6.6") -> 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.4
+Version: 1.6.6
 Summary: A modern, security-first programming language with blockchain support
 Home-page: https://github.com/Zaidux/zexus-interpreter
 Author: Zaidux
@@ -50,7 +50,7 @@ Dynamic: requires-python
 
 <div align="center">
 
-![Zexus Logo](https://img.shields.io/badge/Zexus-v1.6.3-FF6B35?style=for-the-badge)
+![Zexus Logo](https://img.shields.io/badge/Zexus-v1.6.6-FF6B35?style=for-the-badge)
 [![License](https://img.shields.io/badge/License-MIT-blue.svg?style=for-the-badge)](LICENSE)
 [![Python](https://img.shields.io/badge/Python-3.8+-3776AB?style=for-the-badge&logo=python)](https://python.org)
 [![GitHub](https://img.shields.io/badge/GitHub-Zaidux/zexus--interpreter-181717?style=for-the-badge&logo=github)](https://github.com/Zaidux/zexus-interpreter)

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

@@ -14,7 +14,6 @@ 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
@@ -31,22 +30,7 @@ setup.cfg
 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
@@ -363,6 +347,8 @@ examples/test_postgres.zx
 examples/test_sqlite.zx
 examples/token_contract.zx
 examples/ziver_chain_test.zx
+issues/ISSUE2.md
+issues/ISSUE3.md
 issues/ISSUSE1.md
 linguist-submission/SUBMISSION_INSTRUCTIONS.md
 linguist-submission/grammars.yml