zexus 1.7.1 → 1.7.2

package/src/zexus/parser/strategy_context.py

@@ -6,6 +6,30 @@ from ..zexus_token import *
 from ..zexus_ast import *
 from ..config import config as zexus_config
 from types import SimpleNamespace # Helper for AST node creation
+from collections import OrderedDict
+
+STATEMENT_STARTERS = {
+    LET, CONST, DATA, PRINT, FOR, IF, WHILE, RETURN, CONTINUE, BREAK, THROW, ACTION, FUNCTION,
+    TRY, FINALLY, EXTERNAL, SCREEN, COLOR, CANVAS, GRAPHICS, ANIMATION, CLOCK,
+    EXPORT, USE, DEBUG, ENTITY, CONTRACT, VERIFY, PROTECT, PERSISTENT,
+    STORAGE, AUDIT, RESTRICT, SANDBOX, TRAIL, NATIVE, GC, INLINE, BUFFER,
+    SIMD, DEFER, PATTERN, ENUM, STREAM, WATCH, LOG, CAPABILITY, GRANT,
+    REVOKE, VALIDATE, SANITIZE, IMMUTABLE, INTERFACE, TYPE_ALIAS, MODULE,
+    PACKAGE, USING, MIDDLEWARE, AUTH, THROTTLE, CACHE, REQUIRE
+}
+
+_MEANINGFUL_TOKEN_TYPES = {
+    IDENT, STRING, INTERP_STRING, INT, FLOAT, LBRACE, RBRACE, LPAREN, RPAREN, LBRACKET,
+    RBRACKET, COMMA, DOT, SEMICOLON, ASSIGN, LAMBDA,
+    POWER, PLUS_ASSIGN, MINUS_ASSIGN, STAR_ASSIGN, SLASH_ASSIGN, MOD_ASSIGN, POWER_ASSIGN
+}
+
+_BLOCK_STATEMENTS_CACHE: "OrderedDict[tuple, tuple]" = OrderedDict()
+_BLOCK_STATEMENTS_CACHE_MAX = 256
+
+
+def _block_tokens_signature(tokens):
+    return tuple((t.type, t.literal) for t in tokens)
 
 # Import Parser for nested parsing (needed for LOG statement)
 # Note: This is imported at runtime to avoid circular dependency
@@ -137,6 +161,7 @@ class ContextStackParser:
             GRAPHICS: self._parse_graphics_statement,
             ANIMATION: self._parse_animation_statement,
             CLOCK: self._parse_clock_statement,
+            GC: self._parse_gc_statement_block,
         }
 
     def push_context(self, context_type, context_name=None):
@@ -157,6 +182,35 @@ class ContextStackParser:
         """Get the current parsing context"""
         return self.current_context[-1] if self.current_context else 'global'
 
+    def _parse_destructure_via_traditional(self, tokens):
+        """Delegate destructuring let/const parsing to the traditional parser.
+        
+        This re-lexes the token stream through a mini UltimateParser instance so
+        that ``parse_let_statement`` / ``parse_const_statement`` (which already
+        understand ``{`` / ``[`` destructure patterns) handle the work.
+        """
+        from ..lexer import Lexer
+        from .parser import UltimateParser
+        # Reconstruct source code faithfully — STRING tokens must be re-quoted
+        # so the re-lexer doesn't treat them as identifiers.
+        parts = []
+        for t in tokens:
+            if not t.literal:
+                continue
+            if t.type == 'STRING':
+                # Escape inner double-quotes and wrap in quotes
+                escaped = t.literal.replace('\\', '\\\\').replace('"', '\\"')
+                parts.append(f'"{escaped}"')
+            else:
+                parts.append(t.literal)
+        code = ' '.join(parts)
+        mini_lexer = Lexer(code)
+        mini_parser = UltimateParser(mini_lexer, 'universal', False)
+        mini_program = mini_parser.parse_program()
+        if mini_program and mini_program.statements:
+            return mini_program.statements[0]
+        return None
+
     def parse_block(self, block_info, all_tokens):
         """Parse a block with context awareness"""
         block_type = block_info.get('subtype', block_info['type'])
@@ -167,14 +221,17 @@ class ContextStackParser:
         try:
             # Early exit: if a block has no meaningful tokens, skip parsing it
             tokens = block_info.get('tokens', []) or []
-            def _meaningful(tok):
+            meaningful = False
+            for tok in tokens:
+                if tok.type in _MEANINGFUL_TOKEN_TYPES:
+                    meaningful = True
+                    break
                 lit = getattr(tok, 'literal', None)
-                # treat identifiers, strings, numbers and structural tokens as meaningful
-                if tok.type in {IDENT, STRING, INT, FLOAT, LBRACE, RBRACE, LPAREN, RPAREN, LBRACKET, RBRACKET, COMMA, DOT, SEMICOLON, ASSIGN, LAMBDA}:
-                    return True
-                return not (lit is None or lit == '')
+                if lit is not None and lit != '':
+                    meaningful = True
+                    break
 
-            if not any(_meaningful(t) for t in tokens):
+            if not meaningful:
                 ctx_debug(f"Skipping empty/insignificant block tokens for {block_type}", level='debug')
                 return None
             # Use appropriate parsing strategy for this context
@@ -259,6 +316,10 @@ class ContextStackParser:
             parser_debug("  ❌ Invalid let statement: too few tokens")
             return None
 
+        # Destructuring pattern: let {a, b} = expr  or  let [x, y] = expr
+        if tokens[1].type in (LBRACE, LBRACKET):
+            return self._parse_destructure_via_traditional(tokens)
+
         if tokens[1].type != IDENT:
             parser_debug("  ❌ Invalid let statement: expected identifier after 'let'")
             return None
@@ -397,7 +458,7 @@ class ContextStackParser:
                 
                 # Check for statement starters that should break
                 # Context-sensitive: IF followed by THEN is an expression, not a statement
-                if t.type in {LET, PRINT, FOR, WHILE, RETURN, CONTINUE, ACTION, TRY, EXTERNAL,
+                if t.type in {LET, CONST, DATA, PRINT, FOR, WHILE, RETURN, CONTINUE, BREAK, THROW, ACTION, TRY, FINALLY, EXTERNAL,
                               SCREEN, COLOR, CANVAS, GRAPHICS, ANIMATION, CLOCK,
                               EXPORT, USE, DEBUG}:
                     prev = tokens[j-1] if j > 0 else None
@@ -469,6 +530,10 @@ class ContextStackParser:
             parser_debug("  ❌ Invalid const statement: too few tokens")
             return None
 
+        # Destructuring pattern: const {a, b} = expr  or  const [x, y] = expr
+        if tokens[1].type in (LBRACE, LBRACKET):
+            return self._parse_destructure_via_traditional(tokens)
+
         if tokens[1].type != IDENT:
             parser_debug("  ❌ Invalid const statement: expected identifier after 'const'")
             return None
@@ -539,7 +604,7 @@ class ContextStackParser:
                     j += 1  # Skip the semicolon
                     break
                 # Allow method chains but stop at other statement starters
-                if t.type in {LET, CONST, PRINT, FOR, IF, WHILE, RETURN, ACTION, TRY, EXTERNAL,
+                if t.type in {LET, CONST, DATA, PRINT, FOR, IF, WHILE, RETURN, BREAK, THROW, ACTION, TRY, FINALLY, EXTERNAL,
                               SCREEN, COLOR, CANVAS, GRAPHICS, ANIMATION, CLOCK,
                               EXPORT, USE, DEBUG}:
                     prev = tokens[j-1] if j > 0 else None
@@ -757,7 +822,7 @@ class ContextStackParser:
                 operator_symbol = None
                 if i < len(tokens):
                     # Could be +, -, *, /, ==, etc.
-                    if tokens[i].type in {PLUS, MINUS, STAR, SLASH, MOD, EQ, NOT_EQ, LT, GT, LTE, GTE}:
+                    if tokens[i].type in {PLUS, MINUS, STAR, SLASH, MOD, EQ, NOT_EQ, LT, GT, LTE, GTE, POWER}:
                         operator_symbol = tokens[i].literal
                         parser_debug(f"      Operator: {operator_symbol}")
                         i += 1
@@ -1137,15 +1202,27 @@ class ContextStackParser:
         parser_debug("🔧 [Context] Parsing assignment statement")
         tokens = block_info['tokens']
 
-        # Find the ASSIGN operator
+        # Find the ASSIGN operator or compound assignment token
         assign_idx = None
-        compound_operator = None  # Track if this is +=, -=, *=, /=, %=
+        compound_operator = None  # Track if this is +=, -=, *=, /=, %=, **=
+        
+        # Map compound assignment token types to their operator strings
+        _compound_assign_map = {
+            PLUS_ASSIGN: "+", MINUS_ASSIGN: "-", STAR_ASSIGN: "*",
+            SLASH_ASSIGN: "/", MOD_ASSIGN: "%", POWER_ASSIGN: "**"
+        }
         
         for i, tok in enumerate(tokens):
-            if tok.type == ASSIGN:
+            # Check for single-token compound assignments (+=, -=, *=, /=, %=, **=)
+            if tok.type in _compound_assign_map:
+                assign_idx = i
+                compound_operator = _compound_assign_map[tok.type]
+                parser_debug(f"  🔍 Detected compound assignment token: {compound_operator}= at position {i}")
+                break
+            elif tok.type == ASSIGN:
                 assign_idx = i
-                # Check for compound assignment: operator immediately before =
-                if i > 0 and tokens[i-1].type in {PLUS, MINUS, STAR, SLASH, MOD}:
+                # Legacy check: operator immediately before = (in case of split tokens)
+                if i > 0 and tokens[i-1].type in {PLUS, MINUS, STAR, SLASH, MOD, POWER}:
                     compound_operator = tokens[i-1].literal
                     parser_debug(f"  🔍 Detected compound operator: {compound_operator}= at position {i-1}")
                     assign_idx = i  # Keep assign_idx at the = position
@@ -1156,11 +1233,11 @@ class ContextStackParser:
             return None
 
         # Parse the left-hand side (could be identifier or property access)
-        # For compound operators (+=), exclude the operator token from LHS
-        if compound_operator:
+        # For compound operators with split tokens (op + =), exclude the operator token from LHS
+        if compound_operator and tokens[assign_idx].type == ASSIGN:
             lhs_tokens = tokens[:assign_idx-1]  # Exclude the operator before =
         else:
-            lhs_tokens = tokens[:assign_idx]
+            lhs_tokens = tokens[:assign_idx]  # For single-token compound assignments
         
         # Check if this is a property access (e.g., obj.property or obj["key"])
         target_expr = None
@@ -1180,9 +1257,9 @@ class ContextStackParser:
         value_tokens = []
         stop_types = {SEMICOLON}  # RBRACE removed - handle with nesting instead
         statement_starters = {
-            LET, CONST, PRINT, FOR, IF, WHILE, RETURN, CONTINUE, ACTION, TRY, EXTERNAL,
+            LET, CONST, DATA, PRINT, FOR, IF, WHILE, RETURN, CONTINUE, BREAK, THROW, ACTION, TRY, FINALLY, EXTERNAL,
             SCREEN, COLOR, CANVAS, GRAPHICS, ANIMATION, CLOCK,
-            EXPORT, USE, DEBUG, AUDIT, RESTRICT, SANDBOX, TRAIL, NATIVE, GC, INLINE,
+            EXPORT, USE, DEBUG, ENTITY, CONTRACT, AUDIT, RESTRICT, SANDBOX, TRAIL, NATIVE, GC, INLINE,
             BUFFER, SIMD, DEFER, PATTERN, ENUM, STREAM, WATCH, CAPABILITY, GRANT,
             REVOKE, VALIDATE, SANITIZE, IMMUTABLE, INTERFACE, TYPE_ALIAS, MODULE,
             PACKAGE, USING
@@ -1465,6 +1542,22 @@ class ContextStackParser:
         if len(tokens) < 3:
             return None
 
+        # Optimization: Check AST Cache
+        token_hash = None
+        try:
+            # Create a signature from tokens (literal + type)
+            # We use a tuple which is hashable and fast
+            tv = tuple((t.literal, t.type) for t in tokens)
+            token_hash = str(hash(tv))
+            
+            from ..module_cache import get_cached_contract_ast, cache_contract_ast
+            cached = get_cached_contract_ast(token_hash)
+            if cached:
+                parser_debug(f"  ⚡ Cache Hit for Contract: {token_hash}")
+                return cached
+        except Exception:
+            pass
+
         # 1. Extract Name
         contract_name = tokens[1].literal if tokens[1].type == IDENT else "UnknownContract"
         parser_debug(f"  📝 Contract Name: {contract_name}")
@@ -1849,6 +1942,12 @@ class ContextStackParser:
         contract_stmt.storage_vars = storage_vars
         contract_stmt.actions = actions
         
+        if token_hash:
+             try:
+                 cache_contract_ast(token_hash, contract_stmt)
+             except Exception:
+                 pass
+        
         return contract_stmt
 
     # === FIXED USE STATEMENT PARSERS ===
@@ -1913,7 +2012,7 @@ class ContextStackParser:
         for i, token in enumerate(tokens):
             if token.type == STRING:
                 file_path = token.literal
-            elif token.type == IDENT and token.literal == 'as':
+            elif token.type == AS or (token.type == IDENT and token.literal == 'as'):
                 if i + 1 < len(tokens) and tokens[i + 1].type == IDENT:
                     alias = tokens[i + 1].literal
 
@@ -1926,7 +2025,11 @@ class ContextStackParser:
     def _parse_export_statement_block(self, block_info, all_tokens):
         """Parse export statement: export { name1, name2, ... } or export const/let X = value"""
         tokens = block_info['tokens']
-        parser_debug(f"    📝 Found export statement: {[t.literal for t in tokens]}")
+        if (
+            (hasattr(zexus_config, 'enable_parser_debug') and zexus_config.enable_parser_debug)
+            or zexus_config.should_log('debug')
+        ):
+            parser_debug(f"    📝 Found export statement: {[t.literal for t in tokens]}")
 
         # Check if this is "export const/let ..." syntax
         if len(tokens) >= 2 and tokens[0].type == EXPORT and tokens[1].type in [CONST, LET]:
@@ -2010,6 +2113,23 @@ class ContextStackParser:
             result.statements = [contract_stmt, export_stmt]
             return result
         
+        # Check if this is "export data Name {...}" syntax
+        if len(tokens) >= 3 and tokens[0].type == EXPORT and tokens[1].type == DATA:
+            parser_debug("    🎯 Handling 'export data' statement")
+
+            data_tokens = tokens[1:]
+            data_stmt = self._parse_data_statement(data_tokens)
+
+            if data_stmt is None:
+                return None
+
+            data_name = data_stmt.name.value if hasattr(data_stmt.name, 'value') else str(data_stmt.name)
+
+            export_stmt = ExportStatement(names=[Identifier(data_name)])
+            result = BlockStatement()
+            result.statements = [data_stmt, export_stmt]
+            return result
+
         # Check if this is "export function name(...) {...}" syntax
         if len(tokens) >= 3 and tokens[0].type == EXPORT and tokens[1].type == FUNCTION:
             parser_debug("    🎯 Handling 'export function' statement")
@@ -2137,8 +2257,13 @@ class ContextStackParser:
             return self._parse_generic_statement_block(block_info, all_tokens)
 
     def _parse_generic_statement_block(self, block_info, all_tokens):
-        """Parse generic statement block - RETURNS ExpressionStatement"""
+        """Parse generic statement block - RETURNS ExpressionStatement or AssignmentExpression"""
         tokens = block_info['tokens']
+        # Check for compound assignment tokens (+=, -=, *=, /=, %=, **=)
+        _compound_types = {PLUS_ASSIGN, MINUS_ASSIGN, STAR_ASSIGN, SLASH_ASSIGN, MOD_ASSIGN, POWER_ASSIGN}
+        for tok in tokens:
+            if tok.type in _compound_types or tok.type == ASSIGN:
+                return self._parse_assignment_statement(block_info, all_tokens)
         expression = self._parse_expression(tokens)
         if expression:
             return ExpressionStatement(expression)
@@ -2155,11 +2280,13 @@ class ContextStackParser:
         try_block = self._parse_try_block(tokens)
         error_var = self._extract_catch_variable(tokens)
         catch_block = self._parse_catch_block(tokens)
+        finally_block = self._parse_finally_block(tokens)
 
         return TryCatchStatement(
             try_block=try_block,
             error_variable=error_var,
-            catch_block=catch_block
+            catch_block=catch_block,
+            finally_block=finally_block
         )
 
     def _parse_try_block(self, tokens):
@@ -2226,23 +2353,57 @@ class ContextStackParser:
         parser_debug("  ⚠️ [Catch] Could not find catch block content")
         return BlockStatement()
 
+    def _parse_finally_block(self, tokens):
+        """Parse the finally block from tokens, if present. Returns BlockStatement or None."""
+        finally_start = -1
+        finally_end = -1
+        brace_count = 0
+        in_finally = False
+
+        for i, token in enumerate(tokens):
+            if token.type == FINALLY:
+                in_finally = True
+            elif in_finally and token.type == LBRACE:
+                if brace_count == 0:
+                    finally_start = i + 1
+                brace_count += 1
+            elif in_finally and token.type == RBRACE:
+                brace_count -= 1
+                if brace_count == 0:
+                    finally_end = i
+                    break
+
+        if finally_start != -1 and finally_end != -1 and finally_end > finally_start:
+            finally_tokens = tokens[finally_start:finally_end]
+            finally_block_statements = self._parse_block_statements(finally_tokens)
+            block = BlockStatement()
+            block.statements = finally_block_statements
+            return block
+
+        return None
+
     def _parse_block_statements(self, tokens):
         """Parse statements from a block of tokens"""
         if not tokens:
             return []
+
+        cache_key = None
+        # Large blocks can be thousands of tokens; building a signature tuple
+        # (and looking it up) can cost significant time/memory. Skip caching
+        # for very large blocks to keep parsing stable.
+        if len(tokens) <= 2000:
+            try:
+                cache_key = _block_tokens_signature(tokens)
+                cached = _BLOCK_STATEMENTS_CACHE.get(cache_key)
+                if cached is not None:
+                    return list(cached)
+            except Exception:
+                cache_key = None
         
         statements = []
         i = 0
         # Common statement-starter tokens used by several heuristics and fallbacks
-        statement_starters = {
-            LET, CONST, DATA, PRINT, FOR, IF, WHILE, RETURN, CONTINUE, ACTION, FUNCTION,
-            TRY, EXTERNAL, SCREEN, COLOR, CANVAS, GRAPHICS, ANIMATION, CLOCK,
-            EXPORT, USE, DEBUG, ENTITY, CONTRACT, VERIFY, PROTECT, PERSISTENT,
-            STORAGE, AUDIT, RESTRICT, SANDBOX, TRAIL, NATIVE, GC, INLINE, BUFFER,
-            SIMD, DEFER, PATTERN, ENUM, STREAM, WATCH, LOG, CAPABILITY, GRANT,
-            REVOKE, VALIDATE, SANITIZE, IMMUTABLE, INTERFACE, TYPE_ALIAS, MODULE,
-            PACKAGE, USING, MIDDLEWARE, AUTH, THROTTLE, CACHE, REQUIRE
-        }
+        statement_starters = STATEMENT_STARTERS
         
         # Safety: track loop iterations to prevent infinite loops
         max_iterations = len(tokens) * 10  # Very generous limit
@@ -2439,7 +2600,7 @@ class ContextStackParser:
                                 prev_tok = tokens[j-1] if j > 0 else None
                                 is_method_call_continuation = prev_tok and prev_tok.type == DOT
                                 is_expression_continuation = prev_tok and prev_tok.type in {
-                                    PLUS, MINUS, STAR, SLASH, MOD,  # Arithmetic operators
+                                    PLUS, MINUS, STAR, SLASH, MOD, POWER,  # Arithmetic operators
                                     EQ, NOT_EQ, LT, GT, LTE, GTE,    # Comparison operators
                                     AND, OR,                          # Logical operators
                                     COMMA,                            # List separator
@@ -2524,6 +2685,32 @@ class ContextStackParser:
 
                 i = j
 
+            # GC statement heuristic (performance control)
+            elif token.type == GC:
+                j = i + 1
+                action_literal = None
+
+                if j < len(tokens) and tokens[j].type == STRING:
+                    action_literal = tokens[j].literal
+                    j += 1
+
+                # Consume optional semicolon directly following the statement
+                if j < len(tokens) and tokens[j].type == SEMICOLON:
+                    j += 1
+
+                if action_literal is not None:
+                    statements.append(GCStatement(action_literal))
+                    i = j
+                    continue
+
+                # Fallback: parse as expression if tokens are malformed
+                gc_tokens = tokens[i:j]
+                expr = self._parse_expression(gc_tokens)
+                if expr:
+                    statements.append(ExpressionStatement(expr))
+                i = j if j > i else i + 1
+                continue
+
             # DATA statement heuristic (dataclass definition)
             # But not if DATA is used as an identifier (data = ...)
             elif token.type == DATA and i + 1 < len(tokens) and tokens[i + 1].type not in [ASSIGN, LBRACKET, DOT, LPAREN]:
@@ -3937,6 +4124,14 @@ class ContextStackParser:
                     i = j
 
         # print(f"    ✅ Parsed {len(statements)} statements from block")
+        if cache_key is not None:
+            try:
+                _BLOCK_STATEMENTS_CACHE[cache_key] = tuple(statements)
+                if len(_BLOCK_STATEMENTS_CACHE) > _BLOCK_STATEMENTS_CACHE_MAX:
+                    _BLOCK_STATEMENTS_CACHE.popitem(last=False)
+            except Exception:
+                pass
+
         return statements
 
     # === MAP LITERAL PARSING ===
@@ -4582,16 +4777,46 @@ class ContextStackParser:
                 # If there's a closing RBRACKET, skip it
                 if i < n and tokens[i].type == RBRACKET:
                     i += 1
-                prop_expr = self._parse_expression(inner_tokens) if inner_tokens else Identifier('')
-                current_expr = PropertyAccessExpression(
-                    object=current_expr,
-                    property=prop_expr,
-                    computed=True
-                )
+                colon_idx = None
+                depth = 0
+                for idx, tok in enumerate(inner_tokens):
+                    if tok.type in {LBRACKET, LPAREN, LBRACE}:
+                        depth += 1
+                    elif tok.type in {RBRACKET, RPAREN, RBRACE}:
+                        if depth > 0:
+                            depth -= 1
+                    elif tok.type == COLON and depth == 0:
+                        colon_idx = idx
+                        break
+
+                if colon_idx is not None:
+                    start_tokens = inner_tokens[:colon_idx]
+                    end_tokens = inner_tokens[colon_idx + 1:]
+                    start_expr = self._parse_expression(start_tokens) if start_tokens else None
+                    end_expr = self._parse_expression(end_tokens) if end_tokens else None
+                    current_expr = SliceExpression(
+                        object=current_expr,
+                        start=start_expr,
+                        end=end_expr
+                    )
+                else:
+                    if not inner_tokens:
+                        parser_debug("  ❌ Empty bracket access is invalid")
+                        prop_expr = StringLiteral("")
+                    else:
+                        prop_expr = self._parse_expression(inner_tokens)
+                        if prop_expr is None:
+                            parser_debug("  ❌ Could not parse bracket expression")
+                            prop_expr = StringLiteral("")
+                    current_expr = PropertyAccessExpression(
+                        object=current_expr,
+                        property=prop_expr,
+                        computed=True
+                    )
                 continue
 
             # Binary operators (comparisons and arithmetic - but NOT AND/OR which are handled above)
-            if t.type in {PLUS, MINUS, ASTERISK, SLASH, MOD,
+            if t.type in {PLUS, MINUS, ASTERISK, SLASH, MOD, POWER,
                          LT, GT, EQ, NOT_EQ, LTE, GTE}:
                 # Get operator precedence
                 op_precedence = self._get_operator_precedence(t.type)
@@ -4617,7 +4842,7 @@ class ContextStackParser:
                             break
                     
                     # If we're not nested and we hit an operator with same or lower precedence, stop
-                    if depth == 0 and tt.type in {PLUS, MINUS, ASTERISK, SLASH, MOD, LT, GT, EQ, NOT_EQ, LTE, GTE}:
+                    if depth == 0 and tt.type in {PLUS, MINUS, ASTERISK, SLASH, MOD, POWER, LT, GT, EQ, NOT_EQ, LTE, GTE}:
                         next_precedence = self._get_operator_precedence(tt.type)
                         # For left-associative operators, stop if next has same or lower precedence
                         if next_precedence <= op_precedence:
@@ -4649,12 +4874,15 @@ class ContextStackParser:
         Higher numbers = higher precedence (evaluated first)
         """
         # Precedence levels (matching parser.py conventions)
+        POWER_PREC = 10  # ** (exponentiation)
         PRODUCT = 9   # *, /, %
         SUM = 8       # +, -
         COMPARISON = 7  # <, >, <=, >=
         EQUALITY = 6    # ==, !=
         
-        if token_type in {ASTERISK, SLASH, MOD}:
+        if token_type == POWER:
+            return POWER_PREC
+        elif token_type in {ASTERISK, SLASH, MOD}:
             return PRODUCT
         elif token_type in {PLUS, MINUS}:
             return SUM
@@ -4669,6 +4897,21 @@ class ContextStackParser:
         """Parse a single token into an expression"""
         if token.type == STRING:
             return StringLiteral(token.literal)
+        elif token.type == INTERP_STRING:
+            # Interpolated string — delegate to sub-parser for each expr part
+            from ..lexer import Lexer as _Lexer
+            raw_parts = token.literal  # list of ("str", text) | ("expr", source)
+            parsed_parts = []
+            for part_type, part_value in raw_parts:
+                if part_type == "str":
+                    parsed_parts.append(("str", part_value))
+                elif part_type == "expr":
+                    sub_lexer = _Lexer(part_value)
+                    from .parser import Parser as _Parser, LOWEST as _LOWEST
+                    sub_parser = _Parser(sub_lexer)
+                    expr_node = sub_parser.parse_expression(_LOWEST)
+                    parsed_parts.append(("expr", expr_node if expr_node else StringLiteral("")))
+            return StringInterpolationExpression(parts=parsed_parts)
         elif token.type == INT:
             try:
                 return IntegerLiteral(int(token.literal))
@@ -4925,14 +5168,81 @@ class ContextStackParser:
         
         # Parse match cases
         cases = []
+
+        # Support case/colon syntax when present
+        if any(t.type in {CASE, DEFAULT} for t in body_tokens):
+            i = 0
+            while i < len(body_tokens):
+                if body_tokens[i].type in {COMMA, SEMICOLON}:
+                    i += 1
+                    continue
+
+                pattern = None
+
+                if body_tokens[i].type == DEFAULT:
+                    pattern = WildcardPattern()
+                    i += 1
+                    if i < len(body_tokens) and body_tokens[i].type == COLON:
+                        i += 1
+                elif body_tokens[i].type == CASE:
+                    i += 1
+                    pattern_start = i
+                    depth = 0
+                    while i < len(body_tokens):
+                        t = body_tokens[i]
+                        if t.type in {LPAREN, LBRACE, LBRACKET}:
+                            depth += 1
+                        elif t.type in {RPAREN, RBRACE, RBRACKET}:
+                            depth -= 1
+                        elif t.type == COLON and depth == 0:
+                            break
+                        i += 1
+
+                    colon_idx = i
+                    pattern_tokens = body_tokens[pattern_start:colon_idx]
+                    pattern = self._parse_pattern(pattern_tokens) if pattern_tokens else None
+
+                    if i < len(body_tokens) and body_tokens[i].type == COLON:
+                        i += 1
+                else:
+                    i += 1
+                    continue
+
+                result_start = i
+                depth = 0
+                while i < len(body_tokens):
+                    t = body_tokens[i]
+                    if t.type in {LPAREN, LBRACE, LBRACKET}:
+                        depth += 1
+                    elif t.type in {RPAREN, RBRACE, RBRACKET}:
+                        depth -= 1
+                    elif depth == 0 and t.type in {CASE, DEFAULT}:
+                        break
+                    elif depth == 0 and t.type in {COMMA, SEMICOLON}:
+                        break
+                    i += 1
+
+                result_tokens = body_tokens[result_start:i]
+                result_expr = self._parse_expression(result_tokens) if result_tokens else NullLiteral()
+
+                if pattern:
+                    cases.append(MatchCase(pattern=pattern, result=result_expr))
+                    parser_debug(f"  ✅ Parsed match case: {pattern} : {result_expr}")
+
+                while i < len(body_tokens) and body_tokens[i].type in {COMMA, SEMICOLON}:
+                    i += 1
+
+            parser_debug(f"  ✅ Match expression with {len(cases)} cases")
+            return MatchExpression(value=value_expr, cases=cases)
+
         i = 0
-        
+
         while i < len(body_tokens):
             # Skip commas and semicolons
             if body_tokens[i].type in {COMMA, SEMICOLON}:
                 i += 1
                 continue
-            
+
             # Find the => separator
             arrow_idx = -1
             depth = 0
@@ -4944,25 +5254,25 @@ class ContextStackParser:
                 elif body_tokens[j].type == LAMBDA and depth == 0:  # => is tokenized as LAMBDA
                     arrow_idx = j
                     break
-            
+
             if arrow_idx == -1:
                 # No more cases
                 break
-            
+
             # Parse pattern (from i to arrow_idx)
             pattern_tokens = body_tokens[i:arrow_idx]
             pattern = self._parse_pattern(pattern_tokens)
-            
+
             if not pattern:
                 parser_debug(f"  ❌ Failed to parse pattern: {[t.literal for t in pattern_tokens]}")
                 i = arrow_idx + 1
                 continue
-            
+
             # Find result expression end (comma, semicolon, or next pattern)
             result_start = arrow_idx + 1
             result_end = result_start
             depth = 0
-            
+
             while result_end < len(body_tokens):
                 if body_tokens[result_end].type in {LPAREN, LBRACE, LBRACKET}:
                     depth += 1
@@ -4977,7 +5287,7 @@ class ContextStackParser:
                     # Patterns can start with: INT, STRING, IDENT (for constructor or wildcard)
                     current_tok = body_tokens[result_end]
                     next_tok = body_tokens[result_end + 1]
-                    
+
                     # Pattern: literal => or _  => or Constructor( =>
                     if current_tok.type in {INT, STRING, TRUE, FALSE}:
                         # Look ahead for =>
@@ -5010,18 +5320,18 @@ class ContextStackParser:
                                     lookahead += 1
                                 if lookahead < len(body_tokens) and body_tokens[lookahead].type == LAMBDA:
                                     break  # Start of new constructor pattern
-                
+
                 result_end += 1
-            
+
             # Parse result expression
             result_tokens = body_tokens[result_start:result_end]
             result_expr = self._parse_expression(result_tokens) if result_tokens else NullLiteral()
-            
+
             cases.append(MatchCase(pattern=pattern, result=result_expr))
             parser_debug(f"  ✅ Parsed match case: {pattern} => {result_expr}")
-            
+
             i = result_end
-        
+
         parser_debug(f"  ✅ Match expression with {len(cases)} cases")
         return MatchExpression(value=value_expr, cases=cases)
     
@@ -5691,15 +6001,19 @@ class ContextStackParser:
                 while i < len(tokens) and tokens[i].type != RPAREN:
                     if tokens[i].type == IDENT:
                         # This is a parameter name
-                        params.append(Identifier(tokens[i].literal))
+                        param_name = tokens[i].literal
+                        param_type = None
                         i += 1
                         
                         # Check for type annotation: : type
                         if i < len(tokens) and tokens[i].type == COLON:
                             i += 1  # Skip COLON
                             if i < len(tokens) and tokens[i].type == IDENT:
+                                param_type = tokens[i].literal
                                 i += 1  # Skip type name
                         
+                        params.append(Identifier(param_name, type_annotation=param_type))
+                        
                         # Check for comma (more parameters)
                         if i < len(tokens) and tokens[i].type == COMMA:
                             i += 1  # Skip COMMA
@@ -5816,13 +6130,21 @@ class ContextStackParser:
         if not tokens:
             return None
         
-        # Check if this starts with ASYNC modifier
+        # Check for optional modifiers before the FUNCTION keyword (async, inline, native, etc.)
+        modifier_types = {
+            ASYNC, INLINE, NATIVE, PUBLIC, PRIVATE, SEALED, SECURE, PURE, VIEW, PAYABLE,
+        }
+        modifiers = []
         is_async = False
         start_idx = 0
-        if tokens[0].type == ASYNC:
-            is_async = True
-            start_idx = 1
-        
+
+        while start_idx < len(tokens) and tokens[start_idx].type in modifier_types:
+            modifier_token = tokens[start_idx]
+            modifiers.append(getattr(modifier_token, 'literal', modifier_token.type))
+            if modifier_token.type == ASYNC:
+                is_async = True
+            start_idx += 1
+
         # Now check for FUNCTION keyword
         if start_idx >= len(tokens) or tokens[start_idx].type != FUNCTION:
             return None
@@ -5891,8 +6213,8 @@ class ContextStackParser:
         )
         
         # Set async flag if modifier was present
-        if is_async:
-            func_stmt.modifiers = ['async']
+        if modifiers:
+            func_stmt.modifiers = modifiers
         
         return func_stmt
     
@@ -6067,11 +6389,12 @@ class ContextStackParser:
                 return statements[0]  # Return the first (and likely only) statement
             return None
         
-        # Check if this is an assignment statement (identifier = value OR property.access = value)
-        # Look for ASSIGN token anywhere in the statement
+        # Check if this is an assignment statement (identifier = value, +=, -=, *=, /=, %=, **=)
+        # Look for ASSIGN or compound assignment token anywhere in the statement
+        _compound_types = {PLUS_ASSIGN, MINUS_ASSIGN, STAR_ASSIGN, SLASH_ASSIGN, MOD_ASSIGN, POWER_ASSIGN}
         assign_idx = None
         for i, tok in enumerate(tokens):
-            if tok.type == ASSIGN:
+            if tok.type == ASSIGN or tok.type in _compound_types:
                 assign_idx = i
                 break
         
@@ -7211,6 +7534,24 @@ class ContextStackParser:
         parser_debug("  ✅ Limit statement")
         return LimitStatement(amount=gas_limit)
 
+    def _parse_gc_statement_block(self, block_info, all_tokens):
+        """Parse gc "action" statements."""
+        parser_debug("🔧 [Context] Parsing gc statement")
+        tokens = block_info.get('tokens', [])
+
+        if not tokens or tokens[0].type != GC:
+            parser_debug("  ❌ Expected GC keyword")
+            return None
+
+        if len(tokens) < 2 or tokens[1].type != STRING:
+            parser_debug("  ⚠️ GC statement missing string literal action")
+            expr = self._parse_expression(tokens)
+            return ExpressionStatement(expr) if expr else None
+
+        action = tokens[1].literal
+        parser_debug(f"  ✅ GC statement action='{action}'")
+        return GCStatement(action)
+
     def _parse_stream_statement(self, block_info, all_tokens):
         """Parse stream statement.