redscript-mc 2.6.0 → 3.0.0

package/dist/src/parser/index.js

@@ -71,6 +71,8 @@ class Parser {
         this.inLibraryMode = false;
         /** Warnings accumulated during parsing (e.g. deprecated keyword usage). */
         this.warnings = [];
+        /** Parse errors collected during error-recovery mode. */
+        this.parseErrors = [];
         this.tokens = tokens;
         this.sourceLines = source?.split('\n') ?? [];
         this.filePath = filePath;
@@ -132,6 +134,51 @@ class Parser {
         return { kind: 'eof', value: '', line: span.line, col: span.col };
     }
     // -------------------------------------------------------------------------
+    // Error Recovery
+    // -------------------------------------------------------------------------
+    /**
+     * Synchronize to the next top-level declaration boundary after a parse error.
+     * Skips tokens until we find a keyword that starts a top-level declaration,
+     * or a `}` (end of a block), or EOF.
+     */
+    syncToNextDecl() {
+        const TOP_LEVEL_KEYWORDS = new Set([
+            'fn', 'struct', 'impl', 'enum', 'const', 'let', 'export', 'declare', 'import', 'namespace', 'module'
+        ]);
+        while (!this.check('eof')) {
+            const kind = this.peek().kind;
+            if (kind === '}') {
+                this.advance(); // consume the stray `}`
+                return;
+            }
+            if (TOP_LEVEL_KEYWORDS.has(kind)) {
+                return;
+            }
+            // Also recover on a plain ident that could be 'import' keyword used as ident
+            if (kind === 'ident' && this.peek().value === 'import') {
+                return;
+            }
+            this.advance();
+        }
+    }
+    /**
+     * Synchronize to the next statement boundary inside a block after a parse error.
+     * Skips tokens until we reach `;`, `}`, or EOF.
+     */
+    syncToNextStmt() {
+        while (!this.check('eof')) {
+            const kind = this.peek().kind;
+            if (kind === ';') {
+                this.advance(); // consume the `;`
+                return;
+            }
+            if (kind === '}') {
+                return; // leave `}` for parseBlock to consume
+            }
+            this.advance();
+        }
+    }
+    // -------------------------------------------------------------------------
     // Program
     // -------------------------------------------------------------------------
     parse(defaultNamespace = 'redscript') {
@@ -143,6 +190,7 @@ class Parser {
         const enums = [];
         const consts = [];
         const imports = [];
+        const interfaces = [];
         let isLibrary = false;
         let moduleName;
         // Check for namespace declaration
@@ -171,51 +219,95 @@ class Parser {
         }
         // Parse struct, function, and import declarations
         while (!this.check('eof')) {
-            if (this.check('let')) {
-                globals.push(this.parseGlobalDecl(true));
-            }
-            else if (this.check('struct')) {
-                structs.push(this.parseStructDecl());
-            }
-            else if (this.check('impl')) {
-                implBlocks.push(this.parseImplBlock());
-            }
-            else if (this.check('enum')) {
-                enums.push(this.parseEnumDecl());
-            }
-            else if (this.check('const')) {
-                consts.push(this.parseConstDecl());
-            }
-            else if (this.check('declare')) {
-                // Declaration-only stub (e.g. from builtins.d.mcrs) — parse and discard
-                this.advance(); // consume 'declare'
-                this.parseDeclareStub();
-            }
-            else if (this.check('export')) {
-                declarations.push(this.parseExportedFnDecl());
-            }
-            else if (this.check('ident') && this.peek().value === 'import') {
-                // `import math::sin;` or `import math::*;`
-                this.advance(); // consume 'import'
-                const importToken = this.peek();
-                const modName = this.expect('ident').value;
-                this.expect('::');
-                let symbol;
-                if (this.check('*')) {
-                    this.advance();
-                    symbol = '*';
+            try {
+                if (this.check('decorator') && this.peek().value.startsWith('@config')) {
+                    // @config decorator on a global let
+                    const decorToken = this.advance();
+                    const decorator = this.parseDecoratorValue(decorToken.value);
+                    if (!this.check('let')) {
+                        this.error('@config decorator must be followed by a let declaration');
+                    }
+                    const g = this.parseGlobalDecl(true);
+                    g.configKey = decorator.args?.configKey;
+                    g.configDefault = decorator.args?.configDefault;
+                    globals.push(g);
+                }
+                else if (this.check('let')) {
+                    globals.push(this.parseGlobalDecl(true));
+                }
+                else if (this.check('decorator') && this.peek().value === '@singleton') {
+                    // @singleton decorator on a struct
+                    this.advance(); // consume '@singleton'
+                    if (!this.check('struct')) {
+                        this.error('@singleton decorator must be followed by a struct declaration');
+                    }
+                    const s = this.parseStructDecl();
+                    s.isSingleton = true;
+                    structs.push(s);
+                }
+                else if (this.check('struct')) {
+                    structs.push(this.parseStructDecl());
+                }
+                else if (this.check('impl')) {
+                    implBlocks.push(this.parseImplBlock());
+                }
+                else if (this.check('interface')) {
+                    interfaces.push(this.parseInterfaceDecl());
+                }
+                else if (this.check('enum')) {
+                    enums.push(this.parseEnumDecl());
+                }
+                else if (this.check('const')) {
+                    consts.push(this.parseConstDecl());
+                }
+                else if (this.check('declare')) {
+                    // Declaration-only stub (e.g. from builtins.d.mcrs) — parse and discard
+                    this.advance(); // consume 'declare'
+                    this.parseDeclareStub();
+                }
+                else if (this.check('export')) {
+                    declarations.push(this.parseExportedFnDecl());
+                }
+                else if (this.check('import') || (this.check('ident') && this.peek().value === 'import')) {
+                    // `import math::sin;` or `import math::*;` or `import player_utils;` (whole-module file import)
+                    this.advance(); // consume 'import' (keyword or ident)
+                    const importToken = this.peek();
+                    const modName = this.expect('ident').value;
+                    // Check for `::` — if present, this is a symbol import; otherwise, whole-module import
+                    if (this.check('::')) {
+                        this.advance(); // consume '::'
+                        let symbol;
+                        if (this.check('*')) {
+                            this.advance();
+                            symbol = '*';
+                        }
+                        else {
+                            symbol = this.expect('ident').value;
+                        }
+                        this.match(';');
+                        imports.push(this.withLoc({ moduleName: modName, symbol }, importToken));
+                    }
+                    else {
+                        // Whole-module import: `import player_utils;`
+                        this.match(';');
+                        imports.push(this.withLoc({ moduleName: modName, symbol: undefined }, importToken));
+                    }
                 }
                 else {
-                    symbol = this.expect('ident').value;
+                    declarations.push(this.parseFnDecl());
                 }
-                this.match(';');
-                imports.push(this.withLoc({ moduleName: modName, symbol }, importToken));
             }
-            else {
-                declarations.push(this.parseFnDecl());
+            catch (err) {
+                if (err instanceof diagnostics_1.DiagnosticError) {
+                    this.parseErrors.push(err);
+                    this.syncToNextDecl();
+                }
+                else {
+                    throw err;
+                }
             }
         }
-        return { namespace, moduleName, globals, declarations, structs, implBlocks, enums, consts, imports, isLibrary };
+        return { namespace, moduleName, globals, declarations, structs, implBlocks, enums, consts, imports, interfaces, isLibrary };
     }
     // -------------------------------------------------------------------------
     // Struct Declaration
@@ -223,6 +315,7 @@ class Parser {
     parseStructDecl() {
         const structToken = this.expect('struct');
         const name = this.expect('ident').value;
+        const extendsName = this.match('extends') ? this.expect('ident').value : undefined;
         this.expect('{');
         const fields = [];
         while (!this.check('}') && !this.check('eof')) {
@@ -234,7 +327,7 @@ class Parser {
             this.match(',');
         }
         this.expect('}');
-        return this.withLoc({ name, fields }, structToken);
+        return this.withLoc({ name, extends: extendsName, fields }, structToken);
     }
     parseEnumDecl() {
         const enumToken = this.expect('enum');
@@ -245,6 +338,21 @@ class Parser {
         while (!this.check('}') && !this.check('eof')) {
             const variantToken = this.expect('ident');
             const variant = { name: variantToken.value };
+            // Payload fields: Variant(field: Type, ...)
+            if (this.check('(')) {
+                this.advance(); // consume '('
+                const fields = [];
+                while (!this.check(')') && !this.check('eof')) {
+                    const fieldName = this.expect('ident').value;
+                    this.expect(':');
+                    const fieldType = this.parseType();
+                    fields.push({ name: fieldName, type: fieldType });
+                    if (!this.match(','))
+                        break;
+                }
+                this.expect(')');
+                variant.fields = fields;
+            }
             if (this.match('=')) {
                 const valueToken = this.expect('int_lit');
                 variant.value = parseInt(valueToken.value, 10);
@@ -263,14 +371,76 @@ class Parser {
     }
     parseImplBlock() {
         const implToken = this.expect('impl');
-        const typeName = this.expect('ident').value;
+        let traitName;
+        let typeName;
+        const firstName = this.expect('ident').value;
+        if (this.match('for')) {
+            traitName = firstName;
+            typeName = this.expect('ident').value;
+        }
+        else {
+            typeName = firstName;
+        }
         this.expect('{');
         const methods = [];
         while (!this.check('}') && !this.check('eof')) {
             methods.push(this.parseFnDecl(typeName));
         }
         this.expect('}');
-        return this.withLoc({ kind: 'impl_block', typeName, methods }, implToken);
+        return this.withLoc({ kind: 'impl_block', traitName, typeName, methods }, implToken);
+    }
+    /**
+     * Parse an interface declaration:
+     *   interface <Name> {
+     *     fn <method>(<params>): <retType>
+     *     ...
+     *   }
+     * Method signatures have no body — they are prototype-only.
+     */
+    parseInterfaceDecl() {
+        const ifaceToken = this.expect('interface');
+        const name = this.expect('ident').value;
+        this.expect('{');
+        const methods = [];
+        while (!this.check('}') && !this.check('eof')) {
+            const fnToken = this.expect('fn');
+            const methodName = this.expect('ident').value;
+            this.expect('(');
+            const params = this.parseInterfaceParams();
+            this.expect(')');
+            let returnType;
+            if (this.match(':')) {
+                returnType = this.parseType();
+            }
+            // No body — interface methods are signature-only
+            methods.push(this.withLoc({ name: methodName, params, returnType }, fnToken));
+        }
+        this.expect('}');
+        return this.withLoc({ name, methods }, ifaceToken);
+    }
+    /**
+     * Parse interface method params — like parseParams but allows bare `self`
+     * (no `:` required for the first param named 'self').
+     */
+    parseInterfaceParams() {
+        const params = [];
+        if (!this.check(')')) {
+            do {
+                const paramToken = this.expect('ident');
+                const paramName = paramToken.value;
+                let type;
+                if (params.length === 0 && paramName === 'self' && !this.check(':')) {
+                    // self without type annotation — use a sentinel struct type
+                    type = { kind: 'named', name: 'void' };
+                }
+                else {
+                    this.expect(':');
+                    type = this.parseType();
+                }
+                params.push(this.withLoc({ name: paramName, type }, paramToken));
+            } while (this.match(','));
+        }
+        return params;
     }
     parseConstDecl() {
         const constToken = this.expect('const');
@@ -294,8 +464,15 @@ class Parser {
         const name = this.expect('ident').value;
         this.expect(':');
         const type = this.parseType();
-        this.expect('=');
-        const init = this.parseExpr();
+        let init;
+        if (this.match('=')) {
+            init = this.parseExpr();
+        }
+        else {
+            // No init — valid only for @config-decorated globals (resolved later)
+            // Use a placeholder zero literal; will be replaced in compile step
+            init = { kind: 'int_lit', value: 0 };
+        }
         this.match(';');
         return this.withLoc({ kind: 'global', name, type, init, mutable }, token);
     }
@@ -311,6 +488,7 @@ class Parser {
     }
     parseFnDecl(implTypeName) {
         const decorators = this.parseDecorators();
+        const watchObjective = decorators.find(decorator => decorator.name === 'watch')?.args?.objective;
         // Map @keep decorator to isExported flag (backward compat)
         let isExported;
         const filteredDecorators = decorators.filter(d => {
@@ -340,8 +518,12 @@ class Parser {
             returnType = this.parseType();
         }
         const body = this.parseBlock();
+        // Record the closing '}' line as endLine for accurate LSP scope detection
+        const closingBraceLine = this.tokens[this.pos - 1]?.line;
         const fn = this.withLoc({ name, typeParams, params, returnType, decorators: filteredDecorators, body,
-            isLibraryFn: this.inLibraryMode || undefined, isExported }, fnToken);
+            isLibraryFn: this.inLibraryMode || undefined, isExported, watchObjective }, fnToken);
+        if (fn.span && closingBraceLine)
+            fn.span.endLine = closingBraceLine;
         return fn;
     }
     /** Parse a `declare fn name(params): returnType;` stub — no body, just discard. */
@@ -374,8 +556,9 @@ class Parser {
         return decorators;
     }
     parseDecoratorValue(value) {
-        // Parse @tick, @on(PlayerDeath), or @on_trigger("name")
-        const match = value.match(/^@(\w+)(?:\(([^)]*)\))?$/);
+        // Parse @tick, @on(PlayerDeath), @on_trigger("name"), or @deprecated("msg with ) parens")
+        // Use a greedy match for args that allows any content inside the outermost parens.
+        const match = value.match(/^@([A-Za-z_][A-Za-z0-9_-]*)(?:\((.*)\))?$/s);
         if (!match) {
             this.error(`Invalid decorator: ${value}`);
         }
@@ -384,6 +567,9 @@ class Parser {
         if (!argsStr) {
             return { name };
         }
+        if (name === 'profile' || name === 'memoize') {
+            this.error(`@${name} decorator does not accept arguments`);
+        }
         const args = {};
         if (name === 'on') {
             const eventTypeMatch = argsStr.match(/^([A-Za-z_][A-Za-z0-9_]*)$/);
@@ -392,11 +578,14 @@ class Parser {
                 return { name, args };
             }
         }
-        // Handle @on_trigger("name"), @on_advancement("id"), @on_craft("item"), @on_join_team("team")
-        if (name === 'on_trigger' || name === 'on_advancement' || name === 'on_craft' || name === 'on_join_team') {
+        // Handle @watch("objective"), @on_trigger("name"), @on_advancement("id"), @on_craft("item"), @on_join_team("team")
+        if (name === 'watch' || name === 'on_trigger' || name === 'on_advancement' || name === 'on_craft' || name === 'on_join_team') {
             const strMatch = argsStr.match(/^"([^"]*)"$/);
             if (strMatch) {
-                if (name === 'on_trigger') {
+                if (name === 'watch') {
+                    args.objective = strMatch[1];
+                }
+                else if (name === 'on_trigger') {
                     args.trigger = strMatch[1];
                 }
                 else if (name === 'on_advancement') {
@@ -411,6 +600,38 @@ class Parser {
                 return { name, args };
             }
         }
+        // Handle @config("key", default: value)
+        if (name === 'config') {
+            // Format: @config("key_name", default: 42)
+            const configMatch = argsStr.match(/^"([^"]+)"\s*,\s*default\s*:\s*(-?\d+(?:\.\d+)?)$/);
+            if (configMatch) {
+                return { name, args: { configKey: configMatch[1], configDefault: parseFloat(configMatch[2]) } };
+            }
+            // Format: @config("key_name") — no default
+            const keyOnlyMatch = argsStr.match(/^"([^"]+)"$/);
+            if (keyOnlyMatch) {
+                return { name, args: { configKey: keyOnlyMatch[1] } };
+            }
+            this.error(`Invalid @config syntax. Expected: @config("key", default: value) or @config("key")`);
+        }
+        // Handle @deprecated("message")
+        if (name === 'deprecated') {
+            const strMatch = argsStr.match(/^"([^"]*)"$/);
+            if (strMatch) {
+                return { name, args: { message: strMatch[1] } };
+            }
+            // @deprecated with no message string
+            return { name, args: {} };
+        }
+        // @test("label") — marks a test function with a human-readable label
+        if (name === 'test') {
+            const strMatch = argsStr.match(/^"([^"]*)"$/);
+            if (strMatch) {
+                return { name, args: { testLabel: strMatch[1] } };
+            }
+            // @test with no label — use empty string
+            return { name, args: { testLabel: '' } };
+        }
         // @require_on_load(fn_name) — when this fn is used, fn_name is called from __load.
         // Accepts bare identifiers (with optional leading _) or quoted strings.
         if (name === 'require_on_load') {
@@ -459,6 +680,9 @@ class Parser {
             else if (key === 'team') {
                 args.team = val;
             }
+            else if (key === 'max') {
+                args.max = parseInt(val, 10);
+            }
         }
         return { name, args };
     }
@@ -575,7 +799,18 @@ class Parser {
         this.expect('{');
         const stmts = [];
         while (!this.check('}') && !this.check('eof')) {
-            stmts.push(this.parseStmt());
+            try {
+                stmts.push(this.parseStmt());
+            }
+            catch (err) {
+                if (err instanceof diagnostics_1.DiagnosticError) {
+                    this.parseErrors.push(err);
+                    this.syncToNextStmt();
+                }
+                else {
+                    throw err;
+                }
+            }
         }
         this.expect('}');
         return stmts;
@@ -585,19 +820,35 @@ class Parser {
         if (this.check('let')) {
             return this.parseLetStmt();
         }
+        // Const declaration (local)
+        if (this.check('const')) {
+            return this.parseLocalConstDecl();
+        }
         // Return statement
         if (this.check('return')) {
             return this.parseReturnStmt();
         }
-        // Break statement
+        // Break statement (with optional label: break outer)
         if (this.check('break')) {
             const token = this.advance();
+            // Check if next token is an identifier (label name)
+            if (this.check('ident')) {
+                const labelToken = this.advance();
+                this.match(';');
+                return this.withLoc({ kind: 'break_label', label: labelToken.value }, token);
+            }
             this.match(';');
             return this.withLoc({ kind: 'break' }, token);
         }
-        // Continue statement
+        // Continue statement (with optional label: continue outer)
         if (this.check('continue')) {
             const token = this.advance();
+            // Check if next token is an identifier (label name)
+            if (this.check('ident')) {
+                const labelToken = this.advance();
+                this.match(';');
+                return this.withLoc({ kind: 'continue_label', label: labelToken.value }, token);
+            }
             this.match(';');
             return this.withLoc({ kind: 'continue' }, token);
         }
@@ -605,10 +856,41 @@ class Parser {
         if (this.check('if')) {
             return this.parseIfStmt();
         }
+        // Labeled loop: ident ':' (while|for|foreach|repeat)
+        if (this.check('ident') && this.peek(1).kind === ':') {
+            const labelToken = this.advance(); // consume ident
+            const colonToken = this.advance(); // consume ':'
+            // Now parse the loop body
+            let loopStmt;
+            if (this.check('while')) {
+                loopStmt = this.parseWhileStmt();
+            }
+            else if (this.check('for')) {
+                loopStmt = this.parseForStmt();
+            }
+            else if (this.check('foreach')) {
+                loopStmt = this.parseForeachStmt();
+            }
+            else if (this.check('repeat')) {
+                loopStmt = this.parseRepeatStmt();
+            }
+            else {
+                throw new diagnostics_1.DiagnosticError('ParseError', `Expected loop statement after label '${labelToken.value}:', found '${this.peek().kind}'`, { line: labelToken.line, col: labelToken.col });
+            }
+            return this.withLoc({ kind: 'labeled_loop', label: labelToken.value, body: loopStmt }, labelToken);
+        }
         // While statement
         if (this.check('while')) {
             return this.parseWhileStmt();
         }
+        // Do-while statement
+        if (this.check('do')) {
+            return this.parseDoWhileStmt();
+        }
+        // Repeat N statement
+        if (this.check('repeat')) {
+            return this.parseRepeatStmt();
+        }
         // For statement
         if (this.check('for')) {
             return this.parseForStmt();
@@ -671,6 +953,16 @@ class Parser {
         this.match(';');
         return this.withLoc({ kind: 'let', name, type, init }, letToken);
     }
+    parseLocalConstDecl() {
+        const constToken = this.expect('const');
+        const name = this.expect('ident').value;
+        this.expect(':');
+        const type = this.parseType();
+        this.expect('=');
+        const value = this.parseExpr();
+        this.match(';');
+        return this.withLoc({ kind: 'const_decl', name, type, value }, constToken);
+    }
     parseReturnStmt() {
         const returnToken = this.expect('return');
         let value;
@@ -703,9 +995,7 @@ class Parser {
             }
             return this.withLoc({ kind: 'if_let_some', binding, init, then, else_ }, ifToken);
         }
-        this.expect('(');
-        const cond = this.parseExpr();
-        this.expect(')');
+        const cond = this.parseParenOptionalCond();
         const then = this.parseBlock();
         let else_;
         if (this.match('else')) {
@@ -721,12 +1011,45 @@ class Parser {
     }
     parseWhileStmt() {
         const whileToken = this.expect('while');
-        this.expect('(');
-        const cond = this.parseExpr();
-        this.expect(')');
+        // while let Some(x) = expr { ... }
+        if (this.check('let') && this.peek(1).kind === 'ident' && this.peek(1).value === 'Some') {
+            this.advance(); // consume 'let'
+            this.advance(); // consume 'Some'
+            this.expect('(');
+            const binding = this.expect('ident').value;
+            this.expect(')');
+            this.expect('=');
+            const init = this.parseExpr();
+            const body = this.parseBlock();
+            return this.withLoc({ kind: 'while_let_some', binding, init, body }, whileToken);
+        }
+        const cond = this.parseParenOptionalCond();
         const body = this.parseBlock();
         return this.withLoc({ kind: 'while', cond, body }, whileToken);
     }
+    parseDoWhileStmt() {
+        const doToken = this.expect('do');
+        const body = this.parseBlock();
+        this.expect('while');
+        const cond = this.parseParenOptionalCond();
+        this.match(';');
+        return this.withLoc({ kind: 'do_while', cond, body }, doToken);
+    }
+    parseRepeatStmt() {
+        const repeatToken = this.expect('repeat');
+        const countToken = this.expect('int_lit');
+        const count = parseInt(countToken.value, 10);
+        const body = this.parseBlock();
+        return this.withLoc({ kind: 'repeat', count, body }, repeatToken);
+    }
+    parseParenOptionalCond() {
+        if (this.match('(')) {
+            const cond = this.parseExpr();
+            this.expect(')');
+            return cond;
+        }
+        return this.parseExpr();
+    }
     parseForStmt() {
         const forToken = this.expect('for');
         // Check for for-range syntax: for <ident> in <range_lit> { ... }
@@ -798,7 +1121,14 @@ class Parser {
         else {
             // Dynamic range: expr..expr or expr..=expr
             // parseExpr stops before range_lit (not in BINARY_OPS), so this is safe
-            start = this.parseExpr();
+            const arrayOrStart = this.parseExpr();
+            // --- for_each detection: for item in arr { ... } ---
+            // If after parsing the expression there is no range_lit, it's a for_each (array iteration)
+            if (!this.check('range_lit')) {
+                const body = this.parseBlock();
+                return this.withLoc({ kind: 'for_each', binding: varName, array: arrayOrStart, body }, forToken);
+            }
+            start = arrayOrStart;
             // Consume the range_lit token which should be ".." or "..="
             if (this.check('range_lit')) {
                 const rangeOp = this.advance();
@@ -843,24 +1173,77 @@ class Parser {
         const body = this.parseBlock();
         return this.withLoc({ kind: 'foreach', binding, iterable, body, executeContext }, foreachToken);
     }
+    parseMatchPattern() {
+        // Wildcard: _
+        if (this.check('ident') && this.peek().value === '_') {
+            this.advance();
+            return { kind: 'PatWild' };
+        }
+        // None
+        if (this.check('ident') && this.peek().value === 'None') {
+            this.advance();
+            return { kind: 'PatNone' };
+        }
+        // Some(x)
+        if (this.check('ident') && this.peek().value === 'Some') {
+            this.advance(); // consume 'Some'
+            this.expect('(');
+            const binding = this.expect('ident').value;
+            this.expect(')');
+            return { kind: 'PatSome', binding };
+        }
+        // Enum pattern: EnumName::Variant or EnumName::Variant(b1, b2, ...)
+        if (this.check('ident') && this.peek(1).kind === '::') {
+            const enumName = this.advance().value;
+            this.expect('::');
+            const variant = this.expect('ident').value;
+            const bindings = [];
+            if (this.check('(')) {
+                this.advance(); // consume '('
+                while (!this.check(')') && !this.check('eof')) {
+                    bindings.push(this.expect('ident').value);
+                    if (!this.match(','))
+                        break;
+                }
+                this.expect(')');
+            }
+            return { kind: 'PatEnum', enumName, variant, bindings };
+        }
+        // Integer literal
+        if (this.check('int_lit')) {
+            const tok = this.advance();
+            return { kind: 'PatInt', value: parseInt(tok.value, 10) };
+        }
+        // Negative integer literal: -N
+        if (this.check('-') && this.peek(1).kind === 'int_lit') {
+            this.advance(); // consume '-'
+            const tok = this.advance();
+            return { kind: 'PatInt', value: -parseInt(tok.value, 10) };
+        }
+        // Legacy: range_lit or any other expression (e.g. 0..59)
+        const e = this.parseExpr();
+        return { kind: 'PatExpr', expr: e };
+    }
     parseMatchStmt() {
         const matchToken = this.expect('match');
-        this.expect('(');
-        const expr = this.parseExpr();
-        this.expect(')');
+        // Support both `match (expr)` (legacy) and `match expr` (new syntax)
+        let expr;
+        if (this.check('(')) {
+            // Peek ahead — if it looks like `(expr)` followed by `{`, consume parens
+            this.advance(); // consume '('
+            expr = this.parseExpr();
+            this.expect(')');
+        }
+        else {
+            expr = this.parseExpr();
+        }
         this.expect('{');
         const arms = [];
         while (!this.check('}') && !this.check('eof')) {
-            let pattern;
-            if (this.check('ident') && this.peek().value === '_') {
-                this.advance();
-                pattern = null;
-            }
-            else {
-                pattern = this.parseExpr();
-            }
+            const pattern = this.parseMatchPattern();
             this.expect('=>');
             const body = this.parseBlock();
+            this.match(','); // optional trailing comma
             arms.push({ pattern, body });
         }
         this.expect('}');
@@ -1203,6 +1586,13 @@ class Parser {
                 // Member call: entity.tag("name") → __entity_tag(entity, "name")
                 // Also handle arr.push(val) and arr.length
                 if (expr.kind === 'member') {
+                    // Option.unwrap_or(default) → unwrap_or AST node
+                    if (expr.field === 'unwrap_or') {
+                        const defaultExpr = this.parseExpr();
+                        this.expect(')');
+                        expr = this.withLoc({ kind: 'unwrap_or', opt: expr.obj, default_: defaultExpr }, this.getLocToken(expr) ?? openParenToken);
+                        continue;
+                    }
                     const methodMap = {
                         'tag': '__entity_tag',
                         'untag': '__entity_untag',
@@ -1287,6 +1677,25 @@ class Parser {
             this.expect('::');
             const memberToken = this.expect('ident');
             if (this.check('(')) {
+                // Peek inside: if first non-'(' token is `ident :` it's enum construction with named args.
+                // We only treat it as enum_construct when there are actual named args (not empty parens),
+                // because empty `()` is ambiguous and most commonly means a static method call.
+                const isNamedArgs = this.peek(1).kind === 'ident' && this.peek(2).kind === ':';
+                if (isNamedArgs) {
+                    // Enum variant construction: EnumName::Variant(field: expr, ...)
+                    this.advance(); // consume '('
+                    const args = [];
+                    while (!this.check(')') && !this.check('eof')) {
+                        const fieldName = this.expect('ident').value;
+                        this.expect(':');
+                        const value = this.parseExpr();
+                        args.push({ name: fieldName, value });
+                        if (!this.match(','))
+                            break;
+                    }
+                    this.expect(')');
+                    return this.withLoc({ kind: 'enum_construct', enumName: typeToken.value, variant: memberToken.value, args }, typeToken);
+                }
                 // Static method call: Type::method(args)
                 this.advance(); // consume '('
                 const args = this.parseArgs();