zexus 1.7.1 → 1.7.2

package/src/zexus/parser/parser.py

@@ -20,12 +20,19 @@ LOWEST, TERNARY, ASSIGN_PREC, NULLISH_PREC, LOGICAL, EQUALS, LESSGREATER, SUM, P
 precedences = {
     QUESTION: TERNARY,  # condition ? true : false (very low precedence)
     ASSIGN: ASSIGN_PREC,
+    PLUS_ASSIGN: ASSIGN_PREC,
+    MINUS_ASSIGN: ASSIGN_PREC,
+    STAR_ASSIGN: ASSIGN_PREC,
+    SLASH_ASSIGN: ASSIGN_PREC,
+    MOD_ASSIGN: ASSIGN_PREC,
+    POWER_ASSIGN: ASSIGN_PREC,
     NULLISH: NULLISH_PREC,  # value ?? default
     OR: LOGICAL, AND: LOGICAL,
     EQ: EQUALS, NOT_EQ: EQUALS,
     LT: LESSGREATER, GT: LESSGREATER, LTE: LESSGREATER, GTE: LESSGREATER,
     PLUS: SUM, MINUS: SUM,
     SLASH: PRODUCT, STAR: PRODUCT, MOD: PRODUCT,
+    POWER: PREFIX,  # ** has higher precedence than * and /
     LPAREN: CALL,
     LBRACKET: CALL,
     LBRACE: CALL,  # Entity{...} constructor syntax
@@ -60,12 +67,89 @@ class UltimateParser:
         else:
             self.use_advanced_parsing = False
 
+        # Statement dispatch table (O(1) lookup replacing if/elif chain)
+        self._statement_dispatch = {
+            LET: self.parse_let_statement,
+            CONST: self.parse_const_statement,
+            DATA: self.parse_data_statement,
+            RETURN: self.parse_return_statement,
+            CONTINUE: self.parse_continue_statement,
+            BREAK: self.parse_break_statement,
+            THROW: self.parse_throw_statement,
+            PRINT: self.parse_print_statement,
+            FOR: self.parse_for_each_statement,
+            SCREEN: self.parse_screen_statement,
+            COLOR: self.parse_color_statement,
+            CANVAS: self.parse_canvas_statement,
+            GRAPHICS: self.parse_graphics_statement,
+            ANIMATION: self.parse_animation_statement,
+            CLOCK: self.parse_clock_statement,
+            ACTION: self.parse_action_statement,
+            FUNCTION: self.parse_function_statement,
+            IF: self.parse_if_statement,
+            WHILE: self.parse_while_statement,
+            USE: self.parse_use_statement,
+            EXACTLY: self.parse_exactly_statement,
+            EXPORT: self.parse_export_statement,
+            DEBUG: self.parse_debug_statement,
+            TRY: self.parse_try_catch_statement,
+            EXTERNAL: self.parse_external_declaration,
+            ENTITY: self.parse_entity_statement,
+            VERIFY: self.parse_verify_statement,
+            CONTRACT: self.parse_contract_statement,
+            PROTECT: self.parse_protect_statement,
+            SEAL: self.parse_seal_statement,
+            AUDIT: self.parse_audit_statement,
+            RESTRICT: self.parse_restrict_statement,
+            SANDBOX: self.parse_sandbox_statement,
+            TRAIL: self.parse_trail_statement,
+            TX: self.parse_tx_statement,
+            NATIVE: self.parse_native_statement,
+            GC: self.parse_gc_statement,
+            INLINE: self.parse_inline_statement,
+            BUFFER: self.parse_buffer_statement,
+            SIMD: self.parse_simd_statement,
+            DEFER: self.parse_defer_statement,
+            PATTERN: self.parse_pattern_statement,
+            ENUM: self.parse_enum_statement,
+            STREAM: self.parse_stream_statement,
+            WATCH: self.parse_watch_statement,
+            EMIT: self.parse_emit_statement,
+            MODIFIER: self.parse_modifier_declaration,
+            # Security statements
+            CAPABILITY: self.parse_capability_statement,
+            GRANT: self.parse_grant_statement,
+            REVOKE: self.parse_revoke_statement,
+            VALIDATE: self.parse_validate_statement,
+            SANITIZE: self.parse_sanitize_statement,
+            INJECT: self.parse_inject_statement,
+            IMMUTABLE: self.parse_immutable_statement,
+            # Complexity statements
+            INTERFACE: self.parse_interface_statement,
+            TYPE_ALIAS: self.parse_type_alias_statement,
+            MODULE: self.parse_module_statement,
+            PACKAGE: self.parse_package_statement,
+            USING: self.parse_using_statement,
+            CHANNEL: self.parse_channel_statement,
+            SEND: self.parse_send_statement,
+            RECEIVE: self.parse_receive_statement,
+            ATOMIC: self.parse_atomic_statement,
+            # Blockchain statements
+            LEDGER: self.parse_ledger_statement,
+            STATE: self.parse_state_statement,
+            REQUIRE: self.parse_require_statement,
+            REVERT: self.parse_revert_statement,
+            LIMIT: self.parse_limit_statement,
+        }
+
         # Traditional parser setup (fallback)
         self.prefix_parse_fns = {
             IDENT: self.parse_identifier,
+            EVENT: self.parse_identifier,
             INT: self.parse_integer_literal,
             FLOAT: self.parse_float_literal,
             STRING: self.parse_string_literal,
+            INTERP_STRING: self.parse_interpolated_string,
             BANG: self.parse_prefix_expression,
             MINUS: self.parse_prefix_expression,
             TRUE: self.parse_boolean,
@@ -88,6 +172,7 @@ class UltimateParser:
             SANITIZE: self.parse_sanitize_expression,  # FIX #4: Support sanitize as expression
             FIND: self.parse_find_expression,
             LOAD: self.parse_load_expression,
+            MATCH: self.parse_match_expression,
         }
         self.infix_parse_fns = {
             PLUS: self.parse_infix_expression,
@@ -95,6 +180,7 @@ class UltimateParser:
             SLASH: self.parse_infix_expression,
             STAR: self.parse_infix_expression,
             MOD: self.parse_infix_expression,
+            POWER: self.parse_infix_expression,
             EQ: self.parse_infix_expression,
             NOT_EQ: self.parse_infix_expression,
             LT: self.parse_infix_expression,
@@ -106,6 +192,12 @@ class UltimateParser:
             QUESTION: self.parse_ternary_expression,  # condition ? true : false
             NULLISH: self.parse_nullish_expression,  # value ?? default
             ASSIGN: self.parse_assignment_expression,
+            PLUS_ASSIGN: self.parse_compound_assignment_expression,
+            MINUS_ASSIGN: self.parse_compound_assignment_expression,
+            STAR_ASSIGN: self.parse_compound_assignment_expression,
+            SLASH_ASSIGN: self.parse_compound_assignment_expression,
+            MOD_ASSIGN: self.parse_compound_assignment_expression,
+            POWER_ASSIGN: self.parse_compound_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
@@ -125,6 +217,10 @@ class UltimateParser:
             lex.line,
             lex.column,
             lex.last_token_type,
+            getattr(lex, 'at_statement_boundary', True),
+            getattr(lex, 'paren_depth', 0),
+            getattr(lex, 'bracket_depth', 0),
+            getattr(lex, 'brace_depth', 0),
         )
 
     def _restore_lexer_state(self, snapshot):
@@ -138,7 +234,19 @@ class UltimateParser:
             self.lexer.line,
             self.lexer.column,
             self.lexer.last_token_type,
+            boundary,
+            paren_depth,
+            bracket_depth,
+            brace_depth,
         ) = snapshot
+        if hasattr(self.lexer, 'at_statement_boundary'):
+            self.lexer.at_statement_boundary = boundary
+        if hasattr(self.lexer, 'paren_depth'):
+            self.lexer.paren_depth = paren_depth
+        if hasattr(self.lexer, 'bracket_depth'):
+            self.lexer.bracket_depth = bracket_depth
+        if hasattr(self.lexer, 'brace_depth'):
+            self.lexer.brace_depth = brace_depth
 
     # ------------------------------------------------------------------
     # Legacy compatibility helpers
@@ -205,6 +313,13 @@ class UltimateParser:
         if not self.use_advanced_parsing:
             return self._parse_traditional()
 
+        # Large-file stability: advanced parsing performs whole-file analysis
+        # that can become expensive on very large sources. For long files, fall
+        # back to the traditional streaming parser which is more predictable.
+        if self._should_disable_advanced_for_size():
+            self.use_advanced_parsing = False
+            return self._parse_traditional()
+
         try:
             # OPTIMIZATION: Check if we already have tokens cached
             if not hasattr(self, '_cached_tokens'):
@@ -212,11 +327,43 @@ class UltimateParser:
             
             all_tokens = self._cached_tokens
 
+            # If the token stream is huge, prefer the traditional parser to avoid
+            # heavy multi-pass analysis and large intermediate structures.
+            try:
+                max_tokens = getattr(config, 'advanced_parsing_max_tokens', 50000)
+                if isinstance(max_tokens, int) and max_tokens > 0 and len(all_tokens) > max_tokens:
+                    self.use_advanced_parsing = False
+                    return self._parse_traditional()
+            except Exception:
+                pass
+
             # Arrow lambdas currently parse reliably via the traditional engine.
-            # When the token stream contains the '=>' literal, switch to the
-            # classic parser immediately to keep AST output deterministic.
-            if any(t.type == LAMBDA and getattr(t, 'literal', None) == '=>'
-                   for t in all_tokens):
+            # When the token stream contains the '=>' literal OUTSIDE of a match
+            # block, switch to the classic parser to keep AST output deterministic.
+            # Match blocks use '=>' for case arms (e.g. 42 => "answer") so we
+            # must NOT bail out when arrows only appear inside match bodies.
+            has_non_match_arrow = False
+            in_match_brace = False
+            match_brace_depth = 0
+            for idx, t in enumerate(all_tokens):
+                if t.type == MATCH:
+                    # Look ahead for opening brace
+                    for k in range(idx + 1, min(idx + 10, len(all_tokens))):
+                        if all_tokens[k].type == LBRACE:
+                            in_match_brace = True
+                            match_brace_depth = 1
+                            break
+                elif in_match_brace:
+                    if t.type == LBRACE:
+                        match_brace_depth += 1
+                    elif t.type == RBRACE:
+                        match_brace_depth -= 1
+                        if match_brace_depth == 0:
+                            in_match_brace = False
+                elif t.type == LAMBDA and getattr(t, 'literal', None) == '=>':
+                    has_non_match_arrow = True
+                    break
+            if has_non_match_arrow:
                 self.use_advanced_parsing = False
                 return self._parse_traditional()
 
@@ -242,11 +389,18 @@ class UltimateParser:
 
             if self._should_verify_with_traditional(program, all_tokens):
                 fallback_program, fallback_errors = self._parse_traditional_copy()
-                if fallback_program and len(fallback_program.statements) > len(program.statements):
-                    self._log("🔁 Traditional parser produced a richer AST; switching to fallback result", "normal")
-                    self.errors = list(fallback_errors or [])
-                    self.use_advanced_parsing = False
-                    return fallback_program
+                # Only prefer the traditional parser if it produces significantly more
+                # statements (>50% more). A small difference often means the advanced
+                # parser correctly merged compound constructs (e.g. let x = match {...})
+                # that the traditional parser fragments into separate pieces.
+                if fallback_program:
+                    adv_count = len(program.statements)
+                    trad_count = len(fallback_program.statements)
+                    if adv_count > 0 and trad_count > adv_count * 1.5:
+                        self._log("🔁 Traditional parser produced a richer AST; switching to fallback result", "normal")
+                        self.errors = list(fallback_errors or [])
+                        self.use_advanced_parsing = False
+                        return fallback_program
 
             self._log(f"✅ Parsing Complete: {len(program.statements)} statements, {len(self.errors)} errors", "minimal")
             return program
@@ -256,6 +410,26 @@ class UltimateParser:
             self.use_advanced_parsing = False
             return self._parse_traditional()
 
+    def _should_disable_advanced_for_size(self) -> bool:
+        """Heuristic guardrail to keep very large inputs stable.
+
+        Uses source line-count (cheap) to decide whether to skip advanced parsing.
+        """
+        try:
+            source = getattr(self.lexer, 'input', None)
+            if not isinstance(source, str) or not source:
+                return False
+
+            max_lines = getattr(config, 'advanced_parsing_max_lines', 2000)
+            if isinstance(max_lines, int) and max_lines > 0:
+                # count('\n') is linear but cheap compared to tokenization + analysis
+                line_count = source.count('\n') + 1
+                if line_count > max_lines:
+                    return True
+        except Exception:
+            return False
+        return False
+
     def _advanced_result_needs_fallback(self, program):
         """Detect obvious advanced-parser failures and trigger traditional fallback."""
         try:
@@ -387,6 +561,10 @@ class UltimateParser:
         original_line = self.lexer.line
         original_column = self.lexer.column
         original_last_token_type = self.lexer.last_token_type
+        original_boundary = getattr(self.lexer, 'at_statement_boundary', True)
+        original_paren_depth = getattr(self.lexer, 'paren_depth', 0)
+        original_bracket_depth = getattr(self.lexer, 'bracket_depth', 0)
+        original_brace_depth = getattr(self.lexer, 'brace_depth', 0)
         original_cur = self.cur_token
         original_peek = self.peek_token
 
@@ -395,6 +573,14 @@ class UltimateParser:
         self.lexer.read_position = 0
         self.lexer.ch = ''
         self.lexer.last_token_type = None  # ✅ CRITICAL: Reset context-aware state
+        if hasattr(self.lexer, 'at_statement_boundary'):
+            self.lexer.at_statement_boundary = True
+        if hasattr(self.lexer, 'paren_depth'):
+            self.lexer.paren_depth = 0
+        if hasattr(self.lexer, 'bracket_depth'):
+            self.lexer.bracket_depth = 0
+        if hasattr(self.lexer, 'brace_depth'):
+            self.lexer.brace_depth = 0
         self.lexer.read_char()
 
         # OPTIMIZATION: Pre-allocate list with reasonable capacity
@@ -420,6 +606,14 @@ class UltimateParser:
         self.lexer.line = original_line
         self.lexer.column = original_column
         self.lexer.last_token_type = original_last_token_type
+        if hasattr(self.lexer, 'at_statement_boundary'):
+            self.lexer.at_statement_boundary = original_boundary
+        if hasattr(self.lexer, 'paren_depth'):
+            self.lexer.paren_depth = original_paren_depth
+        if hasattr(self.lexer, 'bracket_depth'):
+            self.lexer.bracket_depth = original_bracket_depth
+        if hasattr(self.lexer, 'brace_depth'):
+            self.lexer.brace_depth = original_brace_depth
         self.cur_token = original_cur
         self.peek_token = original_peek
 
@@ -444,11 +638,21 @@ class UltimateParser:
             try:
                 statement = self.context_parser.parse_block(block_info, all_tokens)
                 if statement:
-                    program.statements.append(statement)
-                    parsed_count += 1
-                    if config.enable_debug_logs:  # Only show detailed parsing in verbose mode
-                        stmt_type = type(statement).__name__
-                        self._log(f"  ✅ Parsed: {stmt_type} at line {block_info['start_token'].line}", "verbose")
+                    # Unwrap synthetic BlockStatements emitted by context strategies so inner statements flow to the program
+                    from ..zexus_ast import BlockStatement as _BlockStatement
+
+                    if isinstance(statement, _BlockStatement) and getattr(statement, "statements", None):
+                        program.statements.extend(statement.statements)
+                        parsed_count += len(statement.statements)
+                        if config.enable_debug_logs:
+                            stmt_types = ", ".join(type(stmt).__name__ for stmt in statement.statements)
+                            self._log(f"  ✅ Parsed composite block [{stmt_types}] at line {block_info['start_token'].line}", "verbose")
+                    else:
+                        program.statements.append(statement)
+                        parsed_count += 1
+                        if config.enable_debug_logs:  # Only show detailed parsing in verbose mode
+                            stmt_type = type(statement).__name__
+                            self._log(f"  ✅ Parsed: {stmt_type} at line {block_info['start_token'].line}", "verbose")
 
             except Exception as e:
                 error_msg = f"Line {block_info['start_token'].line}: {str(e)}"
@@ -511,175 +715,22 @@ class UltimateParser:
         # Skip stray semicolons that may appear between statements
         if self.cur_token_is(SEMICOLON):
             return None
+        if self.cur_token_is(RBRACE):
+            return None
         try:
             node = None
-            if self.cur_token_is(LET):
-                node = self.parse_let_statement()
-            elif self.cur_token_is(CONST):
-                node = self.parse_const_statement()
-            elif self.cur_token_is(DATA):
-                node = self.parse_data_statement()
-            elif self.cur_token_is(RETURN):
-                node = self.parse_return_statement()
-            elif self.cur_token_is(CONTINUE):
-                node = self.parse_continue_statement()
-            elif self.cur_token_is(BREAK):
-                node = self.parse_break_statement()
-            elif self.cur_token_is(THROW):
-                node = self.parse_throw_statement()
-            elif self.cur_token_is(PRINT):
-                node = self.parse_print_statement()
-            elif self.cur_token_is(FOR):
-                node = self.parse_for_each_statement()
-            elif self.cur_token_is(SCREEN):
-                node = self.parse_screen_statement()
-            elif self.cur_token_is(COLOR):
-                node = self.parse_color_statement()
-            elif self.cur_token_is(CANVAS):
-                node = self.parse_canvas_statement()
-            elif self.cur_token_is(GRAPHICS):
-                node = self.parse_graphics_statement()
-            elif self.cur_token_is(ANIMATION):
-                node = self.parse_animation_statement()
-            elif self.cur_token_is(CLOCK):
-                node = self.parse_clock_statement()
-            elif self.cur_token_is(ACTION):
-                node = self.parse_action_statement()
-            elif self.cur_token_is(FUNCTION):
-                node = self.parse_function_statement()
-            elif self.cur_token_is(IF):
-                node = self.parse_if_statement()
-            elif self.cur_token_is(WHILE):
-                node = self.parse_while_statement()
-            elif self.cur_token_is(USE):
-                node = self.parse_use_statement()
-            elif self.cur_token_is(EXACTLY):
-                node = self.parse_exactly_statement()
-            elif self.cur_token_is(EXPORT):
-                node = self.parse_export_statement()
-            elif self.cur_token_is(DEBUG):
-                node = self.parse_debug_statement()
-            elif self.cur_token_is(TRY):
-                node = self.parse_try_catch_statement()
-            elif self.cur_token_is(EXTERNAL):
-                node = self.parse_external_declaration()
-            elif self.cur_token_is(ENTITY):
-                node = self.parse_entity_statement()
-            elif self.cur_token_is(VERIFY):
-                node = self.parse_verify_statement()
-            elif self.cur_token_is(CONTRACT):
-                node = self.parse_contract_statement()
-            elif self.cur_token_is(PROTECT):
-                node = self.parse_protect_statement()
-            elif self.cur_token_is(SEAL):
-                node = self.parse_seal_statement()
-            elif self.cur_token_is(AUDIT):
-                node = self.parse_audit_statement()
-            elif self.cur_token_is(RESTRICT):
-                node = self.parse_restrict_statement()
-            elif self.cur_token_is(SANDBOX):
-                node = self.parse_sandbox_statement()
-            elif self.cur_token_is(TRAIL):
-                node = self.parse_trail_statement()
-            elif self.cur_token_is(TX):
-                node = self.parse_tx_statement()
-            elif self.cur_token_is(NATIVE):
-                node = self.parse_native_statement()
-            elif self.cur_token_is(GC):
-                node = self.parse_gc_statement()
-            elif self.cur_token_is(INLINE):
-                node = self.parse_inline_statement()
-            elif self.cur_token_is(BUFFER):
-                node = self.parse_buffer_statement()
-            elif self.cur_token_is(SIMD):
-                node = self.parse_simd_statement()
-            elif self.cur_token_is(DEFER):
-                node = self.parse_defer_statement()
-            elif self.cur_token_is(PATTERN):
-                node = self.parse_pattern_statement()
-            elif self.cur_token_is(ENUM):
-                node = self.parse_enum_statement()
-            elif self.cur_token_is(STREAM):
-                node = self.parse_stream_statement()
-            elif self.cur_token_is(WATCH):
-                print(f"[PARSE_STMT] Matched WATCH", file=sys.stderr, flush=True)
-                node = self.parse_watch_statement()
-            elif self.cur_token_is(EMIT):
-                print(f"[PARSE_STMT] Matched EMIT", file=sys.stderr, flush=True)
-                node = self.parse_emit_statement()
-            elif self.cur_token_is(MODIFIER):
-                print(f"[PARSE_STMT] Matched MODIFIER", file=sys.stderr, flush=True)
-                node = self.parse_modifier_declaration()
-            # === SECURITY STATEMENT HANDLERS ===
-            elif self.cur_token_is(CAPABILITY):
-                print(f"[PARSE_STMT] Matched CAPABILITY", file=sys.stderr, flush=True)
-                node = self.parse_capability_statement()
-            elif self.cur_token_is(GRANT):
-                print(f"[PARSE_STMT] Matched GRANT", file=sys.stderr, flush=True)
-                node = self.parse_grant_statement()
-            elif self.cur_token_is(REVOKE):
-                print(f"[PARSE_STMT] Matched REVOKE", file=sys.stderr, flush=True)
-                node = self.parse_revoke_statement()
-            elif self.cur_token_is(VALIDATE):
-                print(f"[PARSE_STMT] Matched VALIDATE", file=sys.stderr, flush=True)
-                node = self.parse_validate_statement()
-            elif self.cur_token_is(SANITIZE):
-                print(f"[PARSE_STMT] Matched SANITIZE", file=sys.stderr, flush=True)
-                node = self.parse_sanitize_statement()
-            elif self.cur_token_is(INJECT):
-                print(f"[PARSE_STMT] Matched INJECT", file=sys.stderr, flush=True)
-                node = self.parse_inject_statement()
-            elif self.cur_token_is(IMMUTABLE):
-                print(f"[PARSE_STMT] Matched IMMUTABLE", file=sys.stderr, flush=True)
-                node = self.parse_immutable_statement()
-            # === COMPLEXITY STATEMENT HANDLERS ===
-            elif self.cur_token_is(INTERFACE):
-                print(f"[PARSE_STMT] Matched INTERFACE", file=sys.stderr, flush=True)
-                node = self.parse_interface_statement()
-            elif self.cur_token_is(TYPE_ALIAS):
-                print(f"[PARSE_STMT] Matched TYPE_ALIAS", file=sys.stderr, flush=True)
-                node = self.parse_type_alias_statement()
-            elif self.cur_token_is(MODULE):
-                print(f"[PARSE_STMT] Matched MODULE", file=sys.stderr, flush=True)
-                node = self.parse_module_statement()
-            elif self.cur_token_is(PACKAGE):
-                print(f"[PARSE_STMT] Matched PACKAGE", file=sys.stderr, flush=True)
-                node = self.parse_package_statement()
-            elif self.cur_token_is(USING):
-                print(f"[PARSE_STMT] Matched USING", file=sys.stderr, flush=True)
-                node = self.parse_using_statement()
-            elif self.cur_token_is(CHANNEL):
-                print(f"[PARSE_STMT] Matched CHANNEL", file=sys.stderr, flush=True)
-                node = self.parse_channel_statement()
-            elif self.cur_token_is(SEND):
-                print(f"[PARSE_STMT] Matched SEND", file=sys.stderr, flush=True)
-                node = self.parse_send_statement()
-            elif self.cur_token_is(RECEIVE):
-                print(f"[PARSE_STMT] Matched RECEIVE", file=sys.stderr, flush=True)
-                node = self.parse_receive_statement()
-            elif self.cur_token_is(ATOMIC):
-                print(f"[PARSE_STMT] Matched ATOMIC", file=sys.stderr, flush=True)
-                node = self.parse_atomic_statement()
-            # === BLOCKCHAIN STATEMENT HANDLERS ===
-            elif self.cur_token_is(LEDGER):
-                print(f"[PARSE_STMT] Matched LEDGER", file=sys.stderr, flush=True)
-                node = self.parse_ledger_statement()
-            elif self.cur_token_is(STATE):
-                print(f"[PARSE_STMT] Matched STATE", file=sys.stderr, flush=True)
-                node = self.parse_state_statement()
-            elif self.cur_token_is(REQUIRE):
-                node = self.parse_require_statement()
-            elif self.cur_token_is(REVERT):
-                print(f"[PARSE_STMT] Matched REVERT", file=sys.stderr, flush=True)
-                node = self.parse_revert_statement()
-            elif self.cur_token_is(LIMIT):
-                print(f"[PARSE_STMT] Matched LIMIT", file=sys.stderr, flush=True)
-                node = self.parse_limit_statement()
+            tok_type = self.cur_token.type
+            handler = self._statement_dispatch.get(tok_type)
+            if handler is not None:
+                node = handler()
             else:
-                print(f"[PARSE_STMT] No match, falling back to expression statement", file=sys.stderr, flush=True)
                 node = self.parse_expression_statement()
 
             if node is not None:
+                # Attach source location for debugger / error reporting
+                if self.cur_token and not getattr(node, 'line', 0):
+                    node.line = getattr(self.cur_token, 'line', 0) or 0
+                    node.column = getattr(self.cur_token, 'column', 0) or 0
                 return attach_modifiers(node, modifiers)
             return None
         except Exception as e:
@@ -736,8 +787,13 @@ class UltimateParser:
         """Parse { } block with tolerance for missing closing brace"""
         block = BlockStatement()
         self.next_token()
-        import sys
-        print(f"[BLOCK_START] Entering brace block, first token: {self.cur_token.type}={repr(self.cur_token.literal)}", file=sys.stderr, flush=True)
+        debug_enabled = config.enable_debug_logs
+        if debug_enabled:
+            print(
+                f"[BLOCK_START] Entering brace block, first token: {self.cur_token.type}={repr(self.cur_token.literal)}",
+                file=sys.stderr,
+                flush=True,
+            )
 
         brace_count = 1
         stmt_count = 0
@@ -748,19 +804,38 @@ class UltimateParser:
                 brace_count -= 1
                 if brace_count == 0:
                     break
+                # Skip standalone closing braces from nested blocks without parsing a statement
+                self.next_token()
+                continue
 
-            print(f"[BLOCK_STMT] About to parse statement {stmt_count}, token: {self.cur_token.type}={repr(self.cur_token.literal)}", file=sys.stderr, flush=True)
+            if debug_enabled:
+                print(
+                    f"[BLOCK_STMT] About to parse statement {stmt_count}, token: {self.cur_token.type}={repr(self.cur_token.literal)}",
+                    file=sys.stderr,
+                    flush=True,
+                )
             stmt = self.parse_statement()
-            print(f"[BLOCK_STMT] Parsed statement {stmt_count}: {type(stmt).__name__ if stmt else 'None'}", file=sys.stderr, flush=True)
+            if debug_enabled:
+                print(
+                    f"[BLOCK_STMT] Parsed statement {stmt_count}: {type(stmt).__name__ if stmt else 'None'}",
+                    file=sys.stderr,
+                    flush=True,
+                )
             if stmt is not None:
                 block.statements.append(stmt)
             self.next_token()
             stmt_count += 1
 
-        print(f"[BLOCK_END] Finished block with {len(block.statements)} statements", file=sys.stderr, flush=True)
+        if debug_enabled:
+            print(
+                f"[BLOCK_END] Finished block with {len(block.statements)} statements",
+                file=sys.stderr,
+                flush=True,
+            )
         # TOLERANT: Don't error if we hit EOF without closing brace
         if self.cur_token_is(EOF) and brace_count > 0:
-            self.errors.append(f"Line {self.cur_token.line}: Unclosed block (reached EOF)")
+            # Tolerant mode: allow missing closing braces at EOF without failing hard
+            brace_count = 0
 
         return block
 
@@ -781,8 +856,9 @@ class UltimateParser:
 
     def parse_if_statement(self):
         """Tolerant if statement parser with elif support"""
-        import sys
-        print(f"[PARSE_IF] Starting if statement parsing", file=sys.stderr, flush=True)
+        debug_enabled = config.enable_debug_logs
+        if debug_enabled:
+            print("[PARSE_IF] Starting if statement parsing", file=sys.stderr, flush=True)
         # Skip IF token
         self.next_token()
 
@@ -804,48 +880,99 @@ class UltimateParser:
             )
             raise error
 
-        print(f"[PARSE_IF] Parsed condition, now at token: {self.cur_token.type}={repr(self.cur_token.literal)}", file=sys.stderr, flush=True)
+        if debug_enabled:
+            print(
+                f"[PARSE_IF] Parsed condition, now at token: {self.cur_token.type}={repr(self.cur_token.literal)}",
+                file=sys.stderr,
+                flush=True,
+            )
         # Parse consequence (flexible block style)
         consequence = self.parse_block("if")
-        print(f"[PARSE_IF] Parsed consequence block, now at token: {self.cur_token.type}={repr(self.cur_token.literal)}", file=sys.stderr, flush=True)
+        if debug_enabled:
+            print(
+                f"[PARSE_IF] Parsed consequence block, now at token: {self.cur_token.type}={repr(self.cur_token.literal)}",
+                file=sys.stderr,
+                flush=True,
+            )
         if not consequence:
             return None
 
-        # Parse elif clauses
-        elif_parts = []
-        while self.cur_token_is(ELIF):
-            self.next_token()  # Move past elif
-            
-            # Parse elif condition (with or without parentheses)
+        def _parse_conditional_clause(keyword):
+            """Parse an if/elif/else-if condition allowing optional parentheses."""
             if self.cur_token_is(LPAREN):
                 self.next_token()  # Skip (
-                elif_condition = self.parse_expression(LOWEST)
+                clause_condition = self.parse_expression(LOWEST)
                 if not self.expect_peek(RPAREN):
-                    # Expected closing paren after elif condition
                     return None
             else:
-                # No parentheses - parse expression directly
-                elif_condition = self.parse_expression(LOWEST)
-            
-            if not elif_condition:
+                clause_condition = self.parse_expression(LOWEST)
+
+            if not clause_condition:
                 error = self._create_parse_error(
-                    "Expected condition after 'elif'",
-                    suggestion="Add a condition expression: elif (condition) { ... }"
+                    f"Expected condition after '{keyword}'",
+                    suggestion=f"Add a condition expression: {keyword} (condition) {{ ... }}"
                 )
                 raise error
-            
-            # Parse elif consequence block
-            elif_consequence = self.parse_block("elif")
-            if not elif_consequence:
-                return None
-            
-            elif_parts.append((elif_condition, elif_consequence))
 
-        # Parse else clause
+            return clause_condition
+
+        # Parse elif / else-if chains (using lookahead so we keep the closing brace as current token)
+        elif_parts = []
         alternative = None
-        if self.cur_token_is(ELSE):
-            self.next_token()
-            alternative = self.parse_block("else")
+
+        while True:
+            if debug_enabled:
+                print(
+                    f"[PARSE_IF] After consequence, current={self.cur_token.type}, peek={self.peek_token.type if self.peek_token else None}",
+                    file=sys.stderr,
+                    flush=True,
+                )
+            if self.peek_token_is(ELIF):
+                self.next_token()  # Move to 'elif'
+                self.next_token()  # Advance to first token of condition
+                if debug_enabled:
+                    print("[PARSE_IF] Detected 'elif' clause", file=sys.stderr, flush=True)
+                clause_condition = _parse_conditional_clause("elif")
+                if clause_condition is None:
+                    return None
+
+                clause_block = self.parse_block("elif")
+                if not clause_block:
+                    return None
+
+                elif_parts.append((clause_condition, clause_block))
+                continue
+
+            if self.peek_token_is(ELSE):
+                self.next_token()  # Move to 'else'
+
+                # Support `else if` by converting it into another elif clause
+                if self.peek_token_is(IF):
+                    self.next_token()  # Move to 'if'
+                    self.next_token()  # Advance to first token of condition
+                    if debug_enabled:
+                        print("[PARSE_IF] Detected 'else if' clause", file=sys.stderr, flush=True)
+                    clause_condition = _parse_conditional_clause("else if")
+                    if clause_condition is None:
+                        return None
+
+                    clause_block = self.parse_block("elif")
+                    if not clause_block:
+                        return None
+
+                    elif_parts.append((clause_condition, clause_block))
+                    if debug_enabled:
+                        print("[PARSE_IF] Completed 'else if' clause", file=sys.stderr, flush=True)
+                    continue
+
+                if debug_enabled:
+                    print("[PARSE_IF] Detected plain 'else' clause", file=sys.stderr, flush=True)
+                alternative = self.parse_block("else")
+                if not alternative:
+                    return None
+                break
+
+            break
 
         return IfStatement(condition=condition, consequence=consequence, elif_parts=elif_parts, alternative=alternative)
 
@@ -951,11 +1078,101 @@ class UltimateParser:
 
         return FunctionStatement(name=name, parameters=parameters, body=body, return_type=return_type)
 
+    def _parse_destructure_pattern(self):
+        """Parse a destructuring pattern: {a, b: renamed} or [x, y, ..rest]"""
+        from ..zexus_ast import DestructurePattern
+        if self.cur_token_is(LBRACE):
+            # Map destructuring: {a, b, c: renamed}
+            bindings = []
+            self.next_token()  # skip {
+            while not self.cur_token_is(RBRACE) and not self.cur_token_is(EOF):
+                if self.cur_token_is(COMMA):
+                    self.next_token()
+                    continue
+                if not self.cur_token_is(IDENT):
+                    self.errors.append(f"Expected identifier in map destructure, got {self.cur_token.type}")
+                    return None
+                source_key = self.cur_token.literal
+                target_name = source_key  # default: same name
+                if self.peek_token_is(COLON):
+                    self.next_token()  # skip :
+                    self.next_token()  # move to target name
+                    if not self.cur_token_is(IDENT):
+                        self.errors.append("Expected identifier after ':' in map destructure")
+                        return None
+                    target_name = self.cur_token.literal
+                bindings.append((source_key, target_name))
+                self.next_token()
+            # cur_token should be RBRACE
+            return DestructurePattern(kind='map', bindings=bindings)
+        elif self.cur_token_is(LBRACKET):
+            # List destructuring: [x, y, ..rest]
+            bindings = []
+            rest = None
+            idx = 0
+            self.next_token()  # skip [
+            while not self.cur_token_is(RBRACKET) and not self.cur_token_is(EOF):
+                if self.cur_token_is(COMMA):
+                    self.next_token()
+                    continue
+                # Check for rest element: ..rest (lexed as DOT DOT IDENT)
+                if self.cur_token.literal == '.':
+                    # Consume second dot
+                    self.next_token()
+                    if self.cur_token.literal == '.':
+                        self.next_token()  # move to rest identifier
+                        if self.cur_token_is(IDENT):
+                            rest = self.cur_token.literal
+                            self.next_token()
+                            continue
+                    # If not a valid ..rest, skip
+                    continue
+                if self.cur_token_is(IDENT) and self.cur_token.literal.startswith('..'):
+                    rest = self.cur_token.literal[2:]
+                    self.next_token()
+                    continue
+                if not self.cur_token_is(IDENT):
+                    self.errors.append(f"Expected identifier in list destructure, got {self.cur_token.type}")
+                    return None
+                bindings.append((idx, self.cur_token.literal))
+                idx += 1
+                self.next_token()
+            # cur_token should be RBRACKET
+            return DestructurePattern(kind='list', bindings=bindings, rest=rest)
+        return None
+
     def parse_let_statement(self):
-        """Tolerant let statement parser"""
+        """Tolerant let statement parser with destructuring and type annotation support
+        
+        let x = value
+        let x: int = value      (type annotation)
+        let {a, b} = map_expr
+        let [x, y] = list_expr
+        """
         stmt = LetStatement(name=None, value=None)
 
-        if not self.expect_peek(IDENT):
+        # Check for destructuring pattern
+        if self.peek_token_is(LBRACE) or self.peek_token_is(LBRACKET):
+            self.next_token()  # move to { or [
+            pattern = self._parse_destructure_pattern()
+            if pattern is None:
+                return None
+            stmt.name = pattern
+            # Expect = after pattern
+            if self.peek_token_is(ASSIGN):
+                self.next_token()
+            else:
+                self.errors.append("Expected '=' after destructuring pattern")
+                return None
+            self.next_token()
+            stmt.value = self.parse_expression(LOWEST)
+            if self.peek_token_is(SEMICOLON):
+                self.next_token()
+            return stmt
+
+        if self.peek_token_is(IDENT) or self.peek_token_is(EVENT):
+            self.next_token()
+        else:
             error = self._create_parse_error(
                 "Expected variable name after 'let'",
                 suggestion="Use 'let' to declare a variable: let myVariable = value"
@@ -964,8 +1181,33 @@ class UltimateParser:
 
         stmt.name = Identifier(value=self.cur_token.literal)
 
-        # TOLERANT: Allow both = and : for assignment
-        if self.peek_token_is(ASSIGN) or (self.peek_token_is(COLON) and self.peek_token.literal == ":"):
+        # Disambiguate `:` — could be type annotation (let x: int = ...) or
+        # old-style assignment (let x: value).  If `:` is followed by an
+        # IDENT and then `=`, treat it as a type annotation.
+        if self.peek_token_is(COLON) and self.peek_token.literal == ":":
+            # Peek two ahead to see if this is `name: TYPE = value`
+            saved_pos = getattr(self, '_saved_pos', None)
+            # Manual two-token lookahead
+            self.next_token()  # move to :
+            if self.peek_token_is(IDENT):
+                # Could be type annotation — check if IDENT is followed by =
+                type_tok = self.peek_token
+                self.next_token()  # move to potential type token
+                if self.peek_token_is(ASSIGN):
+                    # It IS a type annotation: let x: int = value
+                    stmt.type_annotation = self.cur_token.literal
+                    self.next_token()  # move to =
+                else:
+                    # It's old-style assignment: let x: value
+                    # cur_token is the first token of the value expression
+                    stmt.value = self.parse_expression(LOWEST)
+                    if self.peek_token_is(SEMICOLON):
+                        self.next_token()
+                    return stmt
+            else:
+                # Not IDENT after `:` — old-style assignment
+                pass  # fall through to parse value
+        elif self.peek_token_is(ASSIGN):
             self.next_token()
         else:
             self.errors.append("Expected '=' or ':' after variable name")
@@ -981,20 +1223,59 @@ class UltimateParser:
         return stmt
 
     def parse_const_statement(self):
-        """Tolerant const statement parser - immutable variable declaration
+        """Tolerant const statement parser with destructuring and type annotation support
         
-        Syntax: const NAME = value;
+        const NAME = value;
+        const PI: float = 3.14;
+        const {a, b} = map_expr;
+        const [x, y] = list_expr;
         """
         stmt = ConstStatement(name=None, value=None)
 
-        if not self.expect_peek(IDENT):
+        # Check for destructuring pattern
+        if self.peek_token_is(LBRACE) or self.peek_token_is(LBRACKET):
+            self.next_token()  # move to { or [
+            pattern = self._parse_destructure_pattern()
+            if pattern is None:
+                return None
+            stmt.name = pattern
+            if self.peek_token_is(ASSIGN):
+                self.next_token()
+            else:
+                self.errors.append("Expected '=' after destructuring pattern")
+                return None
+            self.next_token()
+            stmt.value = self.parse_expression(LOWEST)
+            if self.peek_token_is(SEMICOLON):
+                self.next_token()
+            return stmt
+
+        if self.peek_token_is(IDENT) or self.peek_token_is(EVENT):
+            self.next_token()
+        else:
             self.errors.append("Expected variable name after 'const'")
             return None
 
         stmt.name = Identifier(value=self.cur_token.literal)
 
-        # TOLERANT: Allow both = and : for assignment
-        if self.peek_token_is(ASSIGN) or (self.peek_token_is(COLON) and self.peek_token.literal == ":"):
+        # Disambiguate `:` — type annotation vs old-style assignment
+        if self.peek_token_is(COLON) and self.peek_token.literal == ":":
+            self.next_token()  # move to :
+            if self.peek_token_is(IDENT):
+                type_tok = self.peek_token
+                self.next_token()  # move to potential type token
+                if self.peek_token_is(ASSIGN):
+                    stmt.type_annotation = self.cur_token.literal
+                    self.next_token()  # move to =
+                else:
+                    # Old-style assignment: const x: value
+                    stmt.value = self.parse_expression(LOWEST)
+                    if self.peek_token_is(SEMICOLON):
+                        self.next_token()
+                    return stmt
+            else:
+                pass  # fall through to parse value
+        elif self.peek_token_is(ASSIGN):
             self.next_token()
         else:
             self.errors.append("Expected '=' or ':' after variable name in const declaration")
@@ -1368,13 +1649,14 @@ class UltimateParser:
         """
         import sys
         # Debug logging (fail silently if file operations fail)
-        try:
-            log_path = os.path.join(tempfile.gettempdir(), 'parser_log.txt')
-            with open(log_path, 'a') as f:
-                f.write(f"===  parse_print_statement CALLED ===\n")
-                f.flush()
-        except (IOError, OSError, PermissionError):
-            pass  # Silently ignore debug logging errors
+        if getattr(config, 'enable_parser_debug', False):
+            try:
+                log_path = os.path.join(tempfile.gettempdir(), 'parser_log.txt')
+                with open(log_path, 'a') as f:
+                    f.write(f"===  parse_print_statement CALLED ===\n")
+                    f.flush()
+            except (IOError, OSError, PermissionError):
+                pass  # Silently ignore debug logging errors
         
         stmt = PrintStatement(values=[])
         self.next_token()
@@ -1442,10 +1724,17 @@ class UltimateParser:
         if not catch_block:
             return None
 
+        # Check for optional 'finally' block
+        finally_block = None
+        if self.peek_token_is(FINALLY):
+            self.next_token()  # consume 'finally'
+            finally_block = self.parse_block("finally")
+
         return TryCatchStatement(
             try_block=try_block,
             error_variable=error_var,
-            catch_block=catch_block
+            catch_block=catch_block,
+            finally_block=finally_block
         )
 
     def parse_debug_statement(self):
@@ -1665,6 +1954,29 @@ class UltimateParser:
         expression.value = self.parse_expression(LOWEST)
         return expression
 
+    def parse_compound_assignment_expression(self, left):
+        """Parse compound assignment: x += 5  →  x = x + 5"""
+        if not isinstance(left, (Identifier, PropertyAccessExpression)):
+            self.errors.append(f"Line {self.cur_token.line}:{self.cur_token.column} - Cannot use compound assignment on {type(left).__name__}, only identifiers and properties allowed")
+            return None
+
+        # Map compound operator token to the underlying arithmetic operator
+        op_map = {
+            PLUS_ASSIGN: "+",
+            MINUS_ASSIGN: "-",
+            STAR_ASSIGN: "*",
+            SLASH_ASSIGN: "/",
+            MOD_ASSIGN: "%",
+            POWER_ASSIGN: "**",
+        }
+        operator = op_map.get(self.cur_token.type, "+")
+        self.next_token()
+        right = self.parse_expression(LOWEST)
+
+        # Desugar: x += expr  →  x = x + expr
+        infix = InfixExpression(left=left, operator=operator, right=right)
+        return AssignmentExpression(name=left, value=infix)
+
     def parse_method_call_expression(self, left):
         if not self.cur_token_is(DOT):
             return None
@@ -1691,29 +2003,41 @@ class UltimateParser:
     def parse_export_statement(self):
         token = self.cur_token
 
-        # Check for syntactic sugar: export action name() {} or export function name() {}
-        if self.peek_token_is(ACTION) or self.peek_token_is(FUNCTION):
-            self.next_token()  # Move to ACTION/FUNCTION token
-            
-            # Parse the action/function normally
-            if self.cur_token_is(ACTION):
-                func_stmt = self.parse_action_statement()
-            else:  # FUNCTION
-                func_stmt = self.parse_function_statement()
-            
-            if func_stmt is None:
+        keyword_parsers = {
+            ACTION: self.parse_action_statement,
+            FUNCTION: self.parse_function_statement,
+            CONTRACT: self.parse_contract_statement,
+            CONST: self.parse_const_statement,
+            LET: self.parse_let_statement,
+            DATA: self.parse_data_statement,
+        }
+
+        if self.peek_token and self.peek_token.type in keyword_parsers:
+            keyword_type = self.peek_token.type
+            self.next_token()  # Move to the declaration keyword
+            declaration = keyword_parsers[keyword_type]()
+
+            if declaration is None:
                 return None
-            
-            # Extract the function name for export
-            func_name = func_stmt.name.value if hasattr(func_stmt.name, 'value') else str(func_stmt.name)
-            
-            # Create a compound statement: the function definition + export
-            # We'll use a BlockStatement to hold both
-            from ..zexus_ast import BlockStatement, ExportStatement
-            export_stmt = ExportStatement(names=[Identifier(func_name)])
-            
-            # Return a block containing both statements
-            return BlockStatement(statements=[func_stmt, export_stmt])
+
+            decl_name = getattr(declaration, "name", None)
+            export_names = []
+
+            if isinstance(decl_name, Identifier):
+                export_names.append(decl_name)
+            elif decl_name is not None:
+                export_names.append(Identifier(str(decl_name)))
+
+            if not export_names:
+                self.errors.append(
+                    f"Line {token.line}:{token.column} - Unable to determine export name"
+                )
+                return declaration
+
+            export_stmt = ExportStatement(names=export_names)
+            block = BlockStatement()
+            block.statements.extend([declaration, export_stmt])
+            return block
 
         names = []
 
@@ -2614,12 +2938,16 @@ class UltimateParser:
             self.errors.append("Expected parameter name")
             return None
 
-        params.append(Identifier(self.cur_token.literal))
+        param_name = self.cur_token.literal
+        param_type = None
         
-        # Skip optional type annotation: : type
+        # Capture optional type annotation: : type
         if self.peek_token_is(COLON):
             self.next_token()  # Move to :
-            self.next_token()  # Move to type (skip it)
+            self.next_token()  # Move to type
+            param_type = self.cur_token.literal
+
+        params.append(Identifier(param_name, type_annotation=param_type))
 
         while self.peek_token_is(COMMA):
             self.next_token()
@@ -2627,12 +2955,16 @@ class UltimateParser:
             if not self.cur_token_is(IDENT):
                 self.errors.append("Expected parameter name after comma")
                 return None
-            params.append(Identifier(self.cur_token.literal))
+            param_name = self.cur_token.literal
+            param_type = None
             
-            # Skip optional type annotation: : type
+            # Capture optional type annotation: : type
             if self.peek_token_is(COLON):
                 self.next_token()  # Move to :
-                self.next_token()  # Move to type (skip it)
+                self.next_token()  # Move to type
+                param_type = self.cur_token.literal
+
+            params.append(Identifier(param_name, type_annotation=param_type))
 
         if not self.expect_peek(RPAREN):
             self.errors.append("Expected ')' after parameters")
@@ -2802,9 +3134,8 @@ class UltimateParser:
         file_path = self.cur_token.literal
 
         alias = None
-        if self.peek_token_is(IDENT) and self.peek_token.literal == "as":
-            self.next_token()
-            self.next_token()
+        if self.peek_token_is(AS) or (self.peek_token_is(IDENT) and self.peek_token.literal == "as"):
+            self.next_token()  # consume 'as'
             if not self.expect_peek(IDENT):
                 self.errors.append("Expected alias name after 'as'")
                 return None
@@ -2955,6 +3286,17 @@ class UltimateParser:
 
     def parse_return_statement(self):
         stmt = ReturnStatement(return_value=None)
+        # Handle bare `return` without value
+        if self.peek_token_is(SEMICOLON):
+            # Advance to semicolon so outer loop can consume it on next iteration
+            self.next_token()
+            return stmt
+
+        if self.peek_token_is(RBRACE) or self.peek_token_is(EOF):
+            # No explicit return value; leave current token on 'return'
+            return stmt
+
+        # Otherwise parse the return value expression
         self.next_token()
         stmt.return_value = self.parse_expression(LOWEST)
         if self.peek_token_is(SEMICOLON):
@@ -3004,6 +3346,8 @@ class UltimateParser:
         if left_exp is None:
             return None
 
+        debug_enabled = config.enable_debug_logs
+
         # Stop parsing when we hit closing delimiters or terminators
         # This prevents the parser from trying to parse beyond expression boundaries
         while (not self.peek_token_is(SEMICOLON) and
@@ -3014,11 +3358,17 @@ class UltimateParser:
                not self.peek_token_is(LBRACE) and
                precedence <= self.peek_precedence()):
 
-            print(f"[EXPR LOOP] cur={self.cur_token.literal}@L{self.cur_token.line}, peek={self.peek_token.literal}@L{self.peek_token.line}, precedence={precedence}, peek_prec={self.peek_precedence()}")
+            if debug_enabled:
+                print(
+                    f"[EXPR LOOP] cur={self.cur_token.literal}@L{self.cur_token.line}, peek={self.peek_token.literal}@L{self.peek_token.line}, precedence={precedence}, peek_prec={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:
-                print(f"[NEWLINE CHECK] cur_line={self.cur_token.line}, peek_line={self.peek_token.line}, peek_type={self.peek_token.type}, peek_lit={self.peek_token.literal}")
+                if debug_enabled:
+                    print(
+                        f"[NEWLINE CHECK] cur_line={self.cur_token.line}, peek_line={self.peek_token.line}, peek_type={self.peek_token.type}, peek_lit={self.peek_token.literal}"
+                    )
                 # 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
@@ -3027,9 +3377,12 @@ class UltimateParser:
                     self.peek_token.type == RETURN or
                     self.peek_token.type == IF or
                     self.peek_token.type == WHILE or
-                    self.peek_token.type == FOR
+                    self.peek_token.type == FOR or
+                    self.peek_token.type == FUNCTION or
+                    self.peek_token.type == ACTION
                 )
-                print(f"[NEWLINE CHECK] next_could_be_statement={next_could_be_statement}")
+                if debug_enabled:
+                    print(f"[NEWLINE CHECK] next_could_be_statement={next_could_be_statement}")
                 if next_could_be_statement:
                     # Additional check: is the next token followed by [ or = ?
                     # This would indicate it's an assignment/index expression starting
@@ -3125,8 +3478,9 @@ class UltimateParser:
     def parse_identifier(self):
         # Allow DEBUG keyword to be used as identifier in expression contexts
         # This enables debug(value) function calls while keeping debug value; statements
-        if self.cur_token.type == DEBUG:
-            return Identifier(value="debug")
+        if self.cur_token.type in {DEBUG, EVENT}:
+            literal = getattr(self.cur_token, 'literal', None)
+            return Identifier(value=literal if literal is not None else self.cur_token.type.lower())
         return Identifier(value=self.cur_token.literal)
 
     def parse_integer_literal(self):
@@ -3146,17 +3500,44 @@ class UltimateParser:
     def parse_string_literal(self):
         return StringLiteral(value=self.cur_token.literal)
 
+    def parse_interpolated_string(self):
+        """Parse a string with ${expr} interpolation.
+        
+        The token literal is a list of ("str", text) or ("expr", source) tuples
+        produced by the lexer. For each "expr" part, we create a sub-lexer and
+        sub-parser to parse the expression source into an AST node.
+        """
+        raw_parts = self.cur_token.literal
+        parsed_parts = []
+        for part_type, part_value in raw_parts:
+            if part_type == "str":
+                parsed_parts.append(("str", part_value))
+            elif part_type == "expr":
+                # Parse the expression using a sub-parser
+                sub_lexer = Lexer(part_value)
+                sub_parser = Parser(sub_lexer)
+                expr_node = sub_parser.parse_expression(LOWEST)
+                if expr_node is None:
+                    # Fallback: treat as empty string
+                    parsed_parts.append(("str", ""))
+                else:
+                    parsed_parts.append(("expr", expr_node))
+        return StringInterpolationExpression(parts=parsed_parts)
+
     def parse_boolean(self):
         lit = getattr(self.cur_token, 'literal', '')
         val = True if isinstance(lit, str) and lit.lower() == 'true' else False
         # Transient trace to diagnose boolean parsing
-        try:
-            if lit.lower() == 'false':
-                import traceback as _tb
-                stack = ''.join(_tb.format_stack(limit=4)[-2:])
-                print(f"[PARSE_BOOL_TRACE] false token at position {self.lexer.position}: literal={lit}, val={val}\n{stack}")
-        except Exception:
-            pass
+        if config.enable_debug_logs:
+            try:
+                if lit.lower() == 'false':
+                    import traceback as _tb
+                    stack = ''.join(_tb.format_stack(limit=4)[-2:])
+                    print(
+                        f"[PARSE_BOOL_TRACE] false token at position {self.lexer.position}: literal={lit}, val={val}\n{stack}"
+                    )
+            except Exception:
+                pass
         return Boolean(value=val)
 
     def parse_null(self):
@@ -3285,11 +3666,39 @@ class UltimateParser:
         # current token is LBRACKET (parser calls this after advancing to that token)
         # Move to the first token inside the brackets
         self.next_token()
-        index_expr = self.parse_expression(LOWEST)
+        start_expr = None
+        end_expr = None
+
+        if self.cur_token_is(COLON):
+            # Slice with omitted start: obj[:end]
+            if self.peek_token_is(RBRACKET):
+                # obj[:]
+                self.next_token()
+                return SliceExpression(object=left, start=None, end=None)
+            self.next_token()
+            end_expr = self.parse_expression(LOWEST)
+            if not self.expect_peek(RBRACKET):
+                return None
+            return SliceExpression(object=left, start=None, end=end_expr)
+
+        start_expr = self.parse_expression(LOWEST)
+
+        if self.peek_token_is(COLON):
+            # Slice with explicit start: obj[start:end]
+            self.next_token()  # move to ':'
+            if self.peek_token_is(RBRACKET):
+                self.next_token()  # move to ']'
+                return SliceExpression(object=left, start=start_expr, end=None)
+            self.next_token()
+            end_expr = self.parse_expression(LOWEST)
+            if not self.expect_peek(RBRACKET):
+                return None
+            return SliceExpression(object=left, start=start_expr, end=end_expr)
+
         # Expect closing bracket
         if not self.expect_peek(RBRACKET):
             return None
-        return PropertyAccessExpression(object=left, property=index_expr, computed=True)
+        return PropertyAccessExpression(object=left, property=start_expr, computed=True)
 
     def _lookahead_token_after_matching_paren(self):
         """Character-level lookahead: detect if the matching ')' is followed by '=>' (arrow).
@@ -3324,6 +3733,73 @@ class UltimateParser:
 
         return None
 
+    def parse_match_expression(self):
+        """Parse match expression: match value { case p: r, ... } or match value { p => r, ... }"""
+        expression = MatchExpression(value=None, cases=[])
+        
+        self.next_token() # Consume MATCH
+        
+        expression.value = self.parse_expression(LOWEST)
+        
+        if not self.expect_peek(LBRACE):
+            return None
+
+        while not self.peek_token_is(RBRACE) and not self.peek_token_is(EOF):
+            if self.peek_token_is(CASE):
+                # case pattern: result syntax
+                self.next_token() # Consume CASE
+                if not self.peek_token_is(COLON):
+                    self.next_token()
+                pattern = self.parse_expression(LOWEST)
+                if not self.expect_peek(COLON):
+                    return None
+                result = None
+                if self.peek_token_is(LBRACE):
+                    if not self.expect_peek(LBRACE):
+                        return None
+                    result = self.parse_block_statement()
+                else:
+                    self.next_token()
+                    result = self.parse_expression(LOWEST)
+                    if self.peek_token_is(COMMA) or self.peek_token_is(SEMICOLON):
+                        self.next_token()
+                case = MatchCase(pattern=pattern, result=result)
+                expression.cases.append(case)
+            elif self.peek_token_is(DEFAULT):
+                # default: result syntax
+                self.next_token() # Consume DEFAULT
+                if not self.expect_peek(COLON):
+                    return None
+                self.next_token()
+                result = self.parse_expression(LOWEST)
+                if self.peek_token_is(COMMA) or self.peek_token_is(SEMICOLON):
+                    self.next_token()
+                pattern = Identifier(value="_")
+                case = MatchCase(pattern=pattern, result=result)
+                expression.cases.append(case)
+            else:
+                # Arrow syntax: pattern => result
+                self.next_token()  # Move to pattern token
+                pattern = self.parse_expression(LOWEST)
+                
+                # Expect => (LAMBDA token with literal '=>')
+                if self.peek_token_is(LAMBDA):
+                    self.next_token()  # Consume =>
+                    self.next_token()  # Move to result
+                    result = self.parse_expression(LOWEST)
+                    if self.peek_token_is(COMMA) or self.peek_token_is(SEMICOLON):
+                        self.next_token()
+                    case = MatchCase(pattern=pattern, result=result)
+                    expression.cases.append(case)
+                else:
+                    # Skip unexpected tokens
+                    pass
+        
+        if not self.expect_peek(RBRACE):
+            return None
+            
+        return expression
+
     def parse_if_expression(self):
         """Parse if expression - handles both statement form and expression form
         
@@ -3563,17 +4039,27 @@ class UltimateParser:
         storage_vars = []
         actions = []
 
-        while not self.cur_token_is(RBRACE) and not self.cur_token_is(EOF):
+        while not self.cur_token_is(EOF):
             self.next_token()
+            
+            # Parse modifiers preceding the declaration
+            modifiers = self._parse_modifiers()
 
             if self.cur_token_is(RBRACE):
+                # If more declarations follow, skip this brace (close of inner block)
+                if (self.peek_token_is(ACTION) or self.peek_token_is(STATE) or self.peek_token_is(DATA) or
+                        (self.peek_token_is(IDENT) and getattr(self.peek_token, 'literal', None) == 'persistent')):
+                    continue
                 break
 
             # Check for state variable declaration
             if self.cur_token_is(STATE):
                 state_stmt = self.parse_state_statement()
                 if state_stmt:
+                    # Attach parsed modifiers
+                    state_stmt.modifiers = modifiers
                     storage_vars.append(state_stmt)
+                    print(f"DEBUG: Parsed state {state_stmt.name.value} modifiers={modifiers}")
 
             # Check for data member declaration
             elif self.cur_token_is(DATA):
@@ -3588,12 +4074,12 @@ class UltimateParser:
                     self.next_token()  # Move to value
                     data_value = self.parse_expression(LOWEST)
                     
-                    # Create a let statement for the data member
-                    from ..zexus_ast import LetStatement
-                    data_stmt = LetStatement()
-                    data_stmt.name = Identifier(data_name)
-                    data_stmt.value = data_value
+                    # Treat contract data as state with default value
+                    from ..zexus_ast import StateStatement
+                    # Pass modifiers to constructor
+                    data_stmt = StateStatement(Identifier(data_name), data_value, modifiers=modifiers)
                     storage_vars.append(data_stmt)
+                    print(f"DEBUG: Parsed data {data_name} modifiers={modifiers}")
                     
                     # Consume optional semicolon (same as parse_state_statement)
                     if self.peek_token_is(SEMICOLON):
@@ -3606,21 +4092,31 @@ class UltimateParser:
                     self.next_token()
                     if self.cur_token_is(IDENT):
                         storage_name = self.cur_token.literal
+                        # Note: Persistent storage doesn't support standard modifiers yet
                         storage_vars.append({"name": storage_name})
 
             # Check for action definition
             elif self.cur_token_is(ACTION):
                 action = self.parse_action_statement()
                 if action:
+                    # Attach parsed modifiers
+                    action.modifiers = modifiers
                     actions.append(action)
 
-        self.expect_peek(RBRACE)
+        if not self.cur_token_is(RBRACE):
+            # Tolerant: if the contract body ends at EOF, don't emit a hard error
+            if not self.peek_token_is(EOF):
+                self.expect_peek(RBRACE)
         
         # Create body block with storage vars and actions
         body = BlockStatement()
         body.statements = storage_vars + actions
+
+        contract_node = ContractStatement(contract_name, body, modifiers=[], implements=implements)
+        contract_node.storage_vars = storage_vars
+        contract_node.actions = actions
         
-        return ContractStatement(contract_name, body, modifiers=[], implements=implements)
+        return contract_node
 
     def parse_protect_statement(self):
         """Parse protect statement
@@ -4247,7 +4743,8 @@ class UltimateParser:
         
         Asserts condition, reverts transaction if false.
         """
-        print(f"[DEBUG PARSER] parse_require_statement called", flush=True)
+        if config.enable_debug_logs:
+            print("[DEBUG PARSER] parse_require_statement called", flush=True)
         token = self.cur_token
         
         if not self.expect_peek(LPAREN):
@@ -4271,7 +4768,11 @@ class UltimateParser:
         if self.peek_token_is(SEMICOLON):
             self.next_token()
         
-        print(f"[DEBUG PARSER] Creating RequireStatement with condition={condition}, message={message}", flush=True)
+        if config.enable_debug_logs:
+            print(
+                f"[DEBUG PARSER] Creating RequireStatement with condition={condition}, message={message}",
+                flush=True,
+            )
         return RequireStatement(condition=condition, message=message)
     
     def parse_revert_statement(self):