redscript-mc 2.6.2 → 3.0.1

package/src/parser/index.ts

@@ -10,7 +10,8 @@ import type {
   Block, ConstDecl, Decorator, EntitySelector, Expr, FnDecl, GlobalDecl, LiteralExpr, Param,
   Program, RangeExpr, SelectorFilter, SelectorKind, Span, Stmt, TypeNode, AssignOp,
   StructDecl, StructField, ExecuteSubcommand, EnumDecl, EnumVariant, BlockPosExpr, ImplBlock,
-  CoordComponent, LambdaParam, EntityTypeName, ImportDecl, MatchPattern
+  CoordComponent, LambdaParam, EntityTypeName, ImportDecl, MatchPattern,
+  InterfaceDecl, InterfaceMethod
 } from '../ast/types'
 import type { BinOp, CmpOp } from '../ast/types'
 import { DiagnosticError } from '../diagnostics'
@@ -83,6 +84,8 @@ export class Parser {
   private inLibraryMode: boolean = false
   /** Warnings accumulated during parsing (e.g. deprecated keyword usage). */
   readonly warnings: string[] = []
+  /** Parse errors collected during error-recovery mode. */
+  readonly parseErrors: DiagnosticError[] = []
 
   constructor(tokens: Token[], source?: string, filePath?: string) {
     this.tokens = tokens
@@ -164,6 +167,54 @@ export 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.
+   */
+  private syncToNextDecl(): void {
+    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.
+   */
+  private syncToNextStmt(): void {
+    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
   // -------------------------------------------------------------------------
@@ -177,6 +228,7 @@ export class Parser {
     const enums: EnumDecl[] = []
     const consts: ConstDecl[] = []
     const imports: ImportDecl[] = []
+    const interfaces: InterfaceDecl[] = []
     let isLibrary = false
     let moduleName: string | undefined
 
@@ -207,43 +259,81 @@ export 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: string
-        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: string
+            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())
+        }
+      } catch (err) {
+        if (err instanceof DiagnosticError) {
+          this.parseErrors.push(err)
+          this.syncToNextDecl()
+        } else {
+          throw err
         }
-        this.match(';')
-        imports.push(this.withLoc({ moduleName: modName, symbol }, importToken))
-      } else {
-        declarations.push(this.parseFnDecl())
       }
     }
 
-    return { namespace, moduleName, globals, declarations, structs, implBlocks, enums, consts, imports, isLibrary }
+    return { namespace, moduleName, globals, declarations, structs, implBlocks, enums, consts, imports, interfaces, isLibrary }
   }
 
   // -------------------------------------------------------------------------
@@ -253,6 +343,7 @@ export class Parser {
   private parseStructDecl(): StructDecl {
     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: StructField[] = []
@@ -267,7 +358,7 @@ export class Parser {
     }
 
     this.expect('}')
-    return this.withLoc({ name, fields }, structToken)
+    return this.withLoc({ name, extends: extendsName, fields }, structToken)
   }
 
   private parseEnumDecl(): EnumDecl {
@@ -282,6 +373,21 @@ export class Parser {
       const variantToken = this.expect('ident')
       const variant: EnumVariant = { name: variantToken.value }
 
+      // Payload fields: Variant(field: Type, ...)
+      if (this.check('(')) {
+        this.advance() // consume '('
+        const fields: { name: string; type: TypeNode }[] = []
+        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)
@@ -303,7 +409,15 @@ export class Parser {
 
   private parseImplBlock(): ImplBlock {
     const implToken = this.expect('impl')
-    const typeName = this.expect('ident').value
+    let traitName: string | undefined
+    let typeName: string
+    const firstName = this.expect('ident').value
+    if (this.match('for')) {
+      traitName = firstName
+      typeName = this.expect('ident').value
+    } else {
+      typeName = firstName
+    }
     this.expect('{')
 
     const methods: FnDecl[] = []
@@ -312,7 +426,63 @@ export class Parser {
     }
 
     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.
+   */
+  private parseInterfaceDecl(): InterfaceDecl {
+    const ifaceToken = this.expect('interface')
+    const name = this.expect('ident').value
+    this.expect('{')
+
+    const methods: InterfaceMethod[] = []
+    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: TypeNode | undefined
+      if (this.match(':')) {
+        returnType = this.parseType()
+      }
+      // No body — interface methods are signature-only
+      methods.push(this.withLoc({ name: methodName, params, returnType }, fnToken) as InterfaceMethod)
+    }
+
+    this.expect('}')
+    return this.withLoc({ name, methods }, ifaceToken) as InterfaceDecl
+  }
+
+  /**
+   * Parse interface method params — like parseParams but allows bare `self`
+   * (no `:` required for the first param named 'self').
+   */
+  private parseInterfaceParams(): Param[] {
+    const params: Param[] = []
+    if (!this.check(')')) {
+      do {
+        const paramToken = this.expect('ident')
+        const paramName = paramToken.value
+        let type: TypeNode
+        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
   }
 
   private parseConstDecl(): ConstDecl {
@@ -340,8 +510,14 @@ export class Parser {
     const name = this.expect('ident').value
     this.expect(':')
     const type = this.parseType()
-    this.expect('=')
-    const init = this.parseExpr()
+    let init: Expr
+    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)
   }
@@ -360,6 +536,7 @@ export class Parser {
 
   private parseFnDecl(implTypeName?: string): FnDecl {
     const decorators = this.parseDecorators()
+    const watchObjective = decorators.find(decorator => decorator.name === 'watch')?.args?.objective
 
     // Map @keep decorator to isExported flag (backward compat)
     let isExported: boolean | undefined
@@ -400,7 +577,7 @@ export class Parser {
 
     const fn: import('../ast/types').FnDecl = this.withLoc(
       { name, typeParams, params, returnType, decorators: filteredDecorators, body,
-        isLibraryFn: this.inLibraryMode || undefined, isExported },
+        isLibraryFn: this.inLibraryMode || undefined, isExported, watchObjective },
       fnToken,
     )
     if (fn.span && closingBraceLine) fn.span.endLine = closingBraceLine
@@ -439,8 +616,9 @@ export class Parser {
   }
 
   private parseDecoratorValue(value: string): Decorator {
-    // 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}`)
     }
@@ -452,6 +630,10 @@ export class Parser {
       return { name }
     }
 
+    if (name === 'profile' || name === 'benchmark' || name === 'memoize') {
+      this.error(`@${name} decorator does not accept arguments`)
+    }
+
     const args: Decorator['args'] = {}
 
     if (name === 'on') {
@@ -462,11 +644,13 @@ export class Parser {
       }
     }
 
-    // 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') {
           args.advancement = strMatch[1]
@@ -479,6 +663,41 @@ export class Parser {
       }
     }
 
+    // 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') {
@@ -519,6 +738,8 @@ export class Parser {
         args.item = val
       } else if (key === 'team') {
         args.team = val
+      } else if (key === 'max') {
+        args.max = parseInt(val, 10)
       }
     }
 
@@ -645,7 +866,16 @@ export class Parser {
     const stmts: Stmt[] = []
 
     while (!this.check('}') && !this.check('eof')) {
-      stmts.push(this.parseStmt())
+      try {
+        stmts.push(this.parseStmt())
+      } catch (err) {
+        if (err instanceof DiagnosticError) {
+          this.parseErrors.push(err)
+          this.syncToNextStmt()
+        } else {
+          throw err
+        }
+      }
     }
 
     this.expect('}')
@@ -658,21 +888,38 @@ export class Parser {
       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)
     }
@@ -682,11 +929,45 @@ export class Parser {
       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: Stmt
+      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 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()
@@ -763,6 +1044,17 @@ export class Parser {
     return this.withLoc({ kind: 'let', name, type, init }, letToken)
   }
 
+  private parseLocalConstDecl(): Stmt {
+    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)
+  }
+
   private parseReturnStmt(): Stmt {
     const returnToken = this.expect('return')
 
@@ -801,9 +1093,7 @@ export 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_: Block | undefined
@@ -821,14 +1111,52 @@ export class Parser {
 
   private parseWhileStmt(): Stmt {
     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)
   }
 
+  private parseDoWhileStmt(): Stmt {
+    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)
+  }
+
+  private parseRepeatStmt(): Stmt {
+    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)
+  }
+
+  private parseParenOptionalCond(): Expr {
+    if (this.match('(')) {
+      const cond = this.parseExpr()
+      this.expect(')')
+      return cond
+    }
+    return this.parseExpr()
+  }
+
   private parseForStmt(): Stmt {
     const forToken = this.expect('for')
 
@@ -986,6 +1314,22 @@ export class Parser {
       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: string[] = []
+      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()
@@ -1390,6 +1734,17 @@ export 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: Record<string, string> = {
             'tag': '__entity_tag',
             'untag': '__entity_untag',
@@ -1502,6 +1857,24 @@ export 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: { name: string; value: Expr }[] = []
+          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()