redscript-mc 2.6.0 → 2.6.2

package/src/mir/lower.ts

@@ -121,7 +121,7 @@ class FnContext {
   /** Tuple variable tracking: varName → array of element temps (index = slot) */
   readonly tupleVars = new Map<string, Temp[]>()
   /** Array variable tracking: varName → { ns, pathPrefix } for NBT-backed int[] */
-  readonly arrayVars = new Map<string, { ns: string; pathPrefix: string }>()
+  readonly arrayVars = new Map<string, { ns: string; pathPrefix: string; knownLen?: number }>()
   /** Macro function info for all functions in the module */
   readonly macroInfo: Map<string, MacroFunctionInfo>
   /** Function parameter info for call_macro generation */
@@ -515,10 +515,29 @@ function lowerStmt(
         const typeName = (stmt.type?.kind === 'struct') ? stmt.type.name : '__anon'
         const fieldTemps = new Map<string, Temp>()
         for (const field of stmt.init.fields) {
-          const val = lowerExpr(field.value, ctx, scope)
-          const t = ctx.freshTemp()
-          ctx.emit({ kind: 'copy', dst: t, src: val })
-          fieldTemps.set(field.name, t)
+          if (field.value.kind === 'struct_lit') {
+            // Nested struct literal: register it as a synthetic var "${parentName}.${fieldName}"
+            // so that chained access like r.pos.x can be resolved
+            const nestedVarName = `${stmt.name}.${field.name}`
+            const nestedTypeName = '__anon'
+            const nestedFieldTemps = new Map<string, Temp>()
+            for (const nestedField of field.value.fields) {
+              const nval = lowerExpr(nestedField.value, ctx, scope)
+              const nt = ctx.freshTemp()
+              ctx.emit({ kind: 'copy', dst: nt, src: nval })
+              nestedFieldTemps.set(nestedField.name, nt)
+            }
+            ctx.structVars.set(nestedVarName, { typeName: nestedTypeName, fields: nestedFieldTemps })
+            // Store a placeholder temp (0) for the field itself in the parent struct
+            const t = ctx.freshTemp()
+            ctx.emit({ kind: 'const', dst: t, value: 0 })
+            fieldTemps.set(field.name, t)
+          } else {
+            const val = lowerExpr(field.value, ctx, scope)
+            const t = ctx.freshTemp()
+            ctx.emit({ kind: 'copy', dst: t, src: val })
+            fieldTemps.set(field.name, t)
+          }
         }
         ctx.structVars.set(stmt.name, { typeName, fields: fieldTemps })
       } else if (stmt.type?.kind === 'option') {
@@ -578,7 +597,7 @@ function lowerStmt(
         // Array literal: write to NBT storage, track the var for index access
         const ns = `${ctx.getNamespace()}:arrays`
         const pathPrefix = stmt.name
-        ctx.arrayVars.set(stmt.name, { ns, pathPrefix })
+        ctx.arrayVars.set(stmt.name, { ns, pathPrefix, knownLen: stmt.init.elements.length })
         const elems = stmt.init.elements
         // Check if all elements are pure integer literals (no side-effects)
         const allConst = elems.every(e => e.kind === 'int_lit')
@@ -587,14 +606,15 @@ function lowerStmt(
           const vals = elems.map(e => (e as { kind: 'int_lit'; value: number }).value).join(', ')
           ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage ${ns} ${pathPrefix} set value [${vals}]`, args: [] })
         } else {
-          // Initialize with zeros, then overwrite dynamic elements
-          const zeros = elems.map(() => '0').join(', ')
-          ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage ${ns} ${pathPrefix} set value [${zeros}]`, args: [] })
+          // Initialize with known int_lit values (0 for dynamic slots), then overwrite dynamic elements.
+          // Using actual int_lit values avoids a bug where non-zero literals (e.g. 10000) would be
+          // left as 0 because the nbt_write for pure int_lits was skipped.
+          const initVals = elems.map(e => (e.kind === 'int_lit' ? String(e.value) : '0')).join(', ')
+          ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage ${ns} ${pathPrefix} set value [${initVals}]`, args: [] })
           for (let i = 0; i < elems.length; i++) {
+            if (elems[i].kind === 'int_lit') continue  // already in the init array
             const elemOp = lowerExpr(elems[i], ctx, scope)
-            if (elemOp.kind !== 'const' || (elems[i].kind !== 'int_lit')) {
-              ctx.emit({ kind: 'nbt_write', ns, path: `${pathPrefix}[${i}]`, type: 'int', scale: 1, src: elemOp })
-            }
+            ctx.emit({ kind: 'nbt_write', ns, path: `${pathPrefix}[${i}]`, type: 'int', scale: 1, src: elemOp })
           }
         }
         // Store array length as a temp in scope (for .len access)
@@ -891,67 +911,142 @@ function lowerStmt(
 
     case 'match': {
       // Lower match as chained if/else
-      const matchVal = lowerExpr(stmt.expr, ctx, scope)
       const mergeBlock = ctx.newBlock('match_merge')
 
+      // Determine if any arm uses Option patterns (PatSome / PatNone).
+      // If so, resolve the Option has/val slots from the subject ident.
+      const hasOptionPats = stmt.arms.some(a =>
+        a.pattern.kind === 'PatSome' || a.pattern.kind === 'PatNone'
+      )
+
+      // For Option match: resolve has/val temps from subject (must be an ident)
+      let optHasOp: Operand | undefined
+      let optValTemp: string | undefined
+      if (hasOptionPats) {
+        if (stmt.expr.kind === 'ident') {
+          const sv = ctx.structVars.get(stmt.expr.name)
+          if (sv && sv.typeName === '__option') {
+            optHasOp = { kind: 'temp', name: sv.fields.get('has')! }
+            optValTemp = sv.fields.get('val')!
+          } else {
+            // Fall back: evaluate and use __rf_has/__rf_val convention
+            lowerExpr(stmt.expr, ctx, scope)
+            const hasT = ctx.freshTemp()
+            const valT = ctx.freshTemp()
+            ctx.emit({ kind: 'copy', dst: hasT, src: { kind: 'temp', name: '__rf_has' } })
+            ctx.emit({ kind: 'copy', dst: valT, src: { kind: 'temp', name: '__rf_val' } })
+            optHasOp = { kind: 'temp', name: hasT }
+            optValTemp = valT
+          }
+        } else {
+          lowerExpr(stmt.expr, ctx, scope)
+          const hasT = ctx.freshTemp()
+          const valT = ctx.freshTemp()
+          ctx.emit({ kind: 'copy', dst: hasT, src: { kind: 'temp', name: '__rf_has' } })
+          ctx.emit({ kind: 'copy', dst: valT, src: { kind: 'temp', name: '__rf_val' } })
+          optHasOp = { kind: 'temp', name: hasT }
+          optValTemp = valT
+        }
+      }
+
+      // For non-option match, evaluate the subject once
+      const matchVal: Operand = hasOptionPats
+        ? optHasOp! // unused for non-option path
+        : lowerExpr(stmt.expr, ctx, scope)
+
       for (let i = 0; i < stmt.arms.length; i++) {
         const arm = stmt.arms[i]
-        if (arm.pattern === null) {
-          // Default arm — just emit the body
+        const pat = arm.pattern
+
+        if (pat.kind === 'PatWild') {
+          // Wildcard/default arm — always matches
           lowerBlock(arm.body, ctx, new Map(scope))
           if (isPlaceholderTerm(ctx.current().term)) {
             ctx.terminate({ kind: 'jump', target: mergeBlock.id })
           }
-        } else if (arm.pattern.kind === 'range_lit') {
-          // Range pattern: e.g. 0..59 => emit ge/le comparisons
-          const range = arm.pattern.range
+        } else if (pat.kind === 'PatNone') {
+          // None arm: optHasOp == 0
+          const cmpTemp = ctx.freshTemp()
+          ctx.emit({ kind: 'cmp', dst: cmpTemp, op: 'eq', a: optHasOp!, b: { kind: 'const', value: 0 } })
           const armBody = ctx.newBlock('match_arm')
           const nextArm = ctx.newBlock('match_next')
-
-          // Chain checks: if min defined, check matchVal >= min; if max defined, check matchVal <= max
-          // Each failed check jumps to nextArm
-          const checks: Array<{ op: 'ge' | 'le'; bound: number }> = []
-          if (range.min !== undefined) checks.push({ op: 'ge', bound: range.min })
-          if (range.max !== undefined) checks.push({ op: 'le', bound: range.max })
-
-          if (checks.length === 0) {
-            // Open range — always matches
-            ctx.terminate({ kind: 'jump', target: armBody.id })
-          } else {
-            // Emit checks sequentially; each check passes → continue to next or armBody
-            for (let ci = 0; ci < checks.length; ci++) {
-              const { op, bound } = checks[ci]
-              const cmpTemp = ctx.freshTemp()
-              ctx.emit({ kind: 'cmp', dst: cmpTemp, op, a: matchVal, b: { kind: 'const', value: bound } })
-              const passBlock = ci === checks.length - 1 ? armBody : ctx.newBlock('match_range_check')
-              ctx.terminate({ kind: 'branch', cond: { kind: 'temp', name: cmpTemp }, then: passBlock.id, else: nextArm.id })
-              if (ci < checks.length - 1) ctx.switchTo(passBlock)
-            }
-          }
-
+          ctx.terminate({ kind: 'branch', cond: { kind: 'temp', name: cmpTemp }, then: armBody.id, else: nextArm.id })
           ctx.switchTo(armBody)
           lowerBlock(arm.body, ctx, new Map(scope))
           if (isPlaceholderTerm(ctx.current().term)) {
             ctx.terminate({ kind: 'jump', target: mergeBlock.id })
           }
-
           ctx.switchTo(nextArm)
-        } else {
-          const patOp = lowerExpr(arm.pattern, ctx, scope)
+        } else if (pat.kind === 'PatSome') {
+          // Some(x) arm: optHasOp == 1, bind x = optValTemp
           const cmpTemp = ctx.freshTemp()
-          ctx.emit({ kind: 'cmp', dst: cmpTemp, op: 'eq', a: matchVal, b: patOp })
-
+          ctx.emit({ kind: 'cmp', dst: cmpTemp, op: 'eq', a: optHasOp!, b: { kind: 'const', value: 1 } })
+          const armBody = ctx.newBlock('match_arm')
+          const nextArm = ctx.newBlock('match_next')
+          ctx.terminate({ kind: 'branch', cond: { kind: 'temp', name: cmpTemp }, then: armBody.id, else: nextArm.id })
+          ctx.switchTo(armBody)
+          const armScope = new Map(scope)
+          // Bind the pattern variable to the option value temp
+          if (optValTemp) armScope.set(pat.binding, optValTemp)
+          lowerBlock(arm.body, ctx, armScope)
+          if (isPlaceholderTerm(ctx.current().term)) {
+            ctx.terminate({ kind: 'jump', target: mergeBlock.id })
+          }
+          ctx.switchTo(nextArm)
+        } else if (pat.kind === 'PatInt') {
+          const cmpTemp = ctx.freshTemp()
+          ctx.emit({ kind: 'cmp', dst: cmpTemp, op: 'eq', a: matchVal, b: { kind: 'const', value: pat.value } })
           const armBody = ctx.newBlock('match_arm')
           const nextArm = ctx.newBlock('match_next')
           ctx.terminate({ kind: 'branch', cond: { kind: 'temp', name: cmpTemp }, then: armBody.id, else: nextArm.id })
-
           ctx.switchTo(armBody)
           lowerBlock(arm.body, ctx, new Map(scope))
           if (isPlaceholderTerm(ctx.current().term)) {
             ctx.terminate({ kind: 'jump', target: mergeBlock.id })
           }
-
           ctx.switchTo(nextArm)
+        } else if (pat.kind === 'PatExpr') {
+          // Legacy: range_lit or other expression
+          const expr = pat.expr
+          if (expr.kind === 'range_lit') {
+            const range = expr.range
+            const armBody = ctx.newBlock('match_arm')
+            const nextArm = ctx.newBlock('match_next')
+            const checks: Array<{ op: 'ge' | 'le'; bound: number }> = []
+            if (range.min !== undefined) checks.push({ op: 'ge', bound: range.min })
+            if (range.max !== undefined) checks.push({ op: 'le', bound: range.max })
+            if (checks.length === 0) {
+              ctx.terminate({ kind: 'jump', target: armBody.id })
+            } else {
+              for (let ci = 0; ci < checks.length; ci++) {
+                const { op, bound } = checks[ci]
+                const cmpTemp = ctx.freshTemp()
+                ctx.emit({ kind: 'cmp', dst: cmpTemp, op, a: matchVal, b: { kind: 'const', value: bound } })
+                const passBlock = ci === checks.length - 1 ? armBody : ctx.newBlock('match_range_check')
+                ctx.terminate({ kind: 'branch', cond: { kind: 'temp', name: cmpTemp }, then: passBlock.id, else: nextArm.id })
+                if (ci < checks.length - 1) ctx.switchTo(passBlock)
+              }
+            }
+            ctx.switchTo(armBody)
+            lowerBlock(arm.body, ctx, new Map(scope))
+            if (isPlaceholderTerm(ctx.current().term)) {
+              ctx.terminate({ kind: 'jump', target: mergeBlock.id })
+            }
+            ctx.switchTo(nextArm)
+          } else {
+            const patOp = lowerExpr(expr, ctx, scope)
+            const cmpTemp = ctx.freshTemp()
+            ctx.emit({ kind: 'cmp', dst: cmpTemp, op: 'eq', a: matchVal, b: patOp })
+            const armBody = ctx.newBlock('match_arm')
+            const nextArm = ctx.newBlock('match_next')
+            ctx.terminate({ kind: 'branch', cond: { kind: 'temp', name: cmpTemp }, then: armBody.id, else: nextArm.id })
+            ctx.switchTo(armBody)
+            lowerBlock(arm.body, ctx, new Map(scope))
+            if (isPlaceholderTerm(ctx.current().term)) {
+              ctx.terminate({ kind: 'jump', target: mergeBlock.id })
+            }
+            ctx.switchTo(nextArm)
+          }
         }
       }
 
@@ -1267,6 +1362,15 @@ function lowerExpr(
           if (fieldTemp) return { kind: 'temp', name: fieldTemp }
         }
       }
+      // Chained struct field access: v.pos.x → look up synthetic var "v.pos" in structVars
+      if (expr.obj.kind === 'member' && expr.obj.obj.kind === 'ident') {
+        const syntheticName = `${expr.obj.obj.name}.${expr.obj.field}`
+        const nestedSv = ctx.structVars.get(syntheticName)
+        if (nestedSv) {
+          const fieldTemp = nestedSv.fields.get(expr.field)
+          if (fieldTemp) return { kind: 'temp', name: fieldTemp }
+        }
+      }
       // Fallback: opaque
       const obj = lowerExpr(expr.obj, ctx, scope)
       const t = ctx.freshTemp()
@@ -1318,9 +1422,37 @@ function lowerExpr(
     }
 
     case 'call': {
+      // Handle arr.len() — parser desugars obj.len() → call { fn: 'len', args: [obj] }
+      if (expr.fn === 'len' && expr.args.length === 1 && expr.args[0].kind === 'ident') {
+        const arrName = (expr.args[0] as { kind: 'ident'; name: string }).name
+        const arrInfo = ctx.arrayVars.get(arrName)
+        if (arrInfo) {
+          if (arrInfo.knownLen !== undefined) {
+            const t = ctx.freshTemp()
+            ctx.emit({ kind: 'const', dst: t, value: arrInfo.knownLen })
+            return { kind: 'temp', name: t }
+          }
+          // Dynamic array: read length at runtime via data get
+          const t = ctx.freshTemp()
+          ctx.emit({ kind: 'nbt_list_len', dst: t, ns: arrInfo.ns, path: arrInfo.pathPrefix })
+          return { kind: 'temp', name: t }
+        }
+        // Also check scope (literal array length temp)
+        const lenTemp = scope.get(arrName)
+        if (lenTemp !== undefined) {
+          return { kind: 'temp', name: lenTemp }
+        }
+      }
+
       // Handle scoreboard_get / score — read from vanilla MC scoreboard
       if (expr.fn === 'scoreboard_get' || expr.fn === 'score') {
-        const player = hirExprToStringLiteral(expr.args[0])
+        const playerArg = exprToCommandArg(expr.args[0], ctx.currentMacroParams)
+        // If the arg is a plain ident (Player variable, not a macro param), use @s —
+        // event handlers are always called via `execute as <player> run function ...`
+        // so @s correctly refers to the player in context.
+        const player = (!playerArg.isMacro && expr.args[0].kind === 'ident')
+          ? '@s'
+          : (playerArg.str || '@s')
         const obj = hirExprToStringLiteral(expr.args[1])
         const t = ctx.freshTemp()
         ctx.emit({ kind: 'score_read', dst: t, player, obj })
@@ -1329,7 +1461,10 @@ function lowerExpr(
 
       // Handle scoreboard_set — write to vanilla MC scoreboard
       if (expr.fn === 'scoreboard_set') {
-        const player = hirExprToStringLiteral(expr.args[0])
+        const playerArg = exprToCommandArg(expr.args[0], ctx.currentMacroParams)
+        const player = (!playerArg.isMacro && expr.args[0].kind === 'ident')
+          ? '@s'
+          : (playerArg.str || '@s')
         const obj = hirExprToStringLiteral(expr.args[1])
         const src = lowerExpr(expr.args[2], ctx, scope)
         ctx.emit({ kind: 'score_write', player, obj, src })
@@ -1338,6 +1473,36 @@ function lowerExpr(
         return { kind: 'temp', name: t }
       }
 
+      // Handle storage_set_array(storagePath, fieldName, nbtArrayLiteral)
+      // Writes a literal NBT int array to data storage (used in @load for tables).
+      // Emits: data modify storage <storagePath> <fieldName> set value <nbtArray>
+      if (expr.fn === 'storage_set_array' && expr.args.length >= 3) {
+        const storagePath = hirExprToStringLiteral(expr.args[0])
+        const fieldName = hirExprToStringLiteral(expr.args[1])
+        const nbtLiteral = hirExprToStringLiteral(expr.args[2])
+        ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage ${storagePath} ${fieldName} set value ${nbtLiteral}`, args: [] })
+        const t = ctx.freshTemp()
+        ctx.emit({ kind: 'const', dst: t, value: 0 })
+        return { kind: 'temp', name: t }
+      }
+
+      // Handle storage_get_int(storagePath, fieldName, index) → int
+      // Reads one element from an NBT int-array stored in data storage.
+      // Const index: execute store result score $dst run data get storage <ns> <field>[N] 1
+      // Runtime index: nbt_read_dynamic via macro sub-function
+      if (expr.fn === 'storage_get_int' && expr.args.length >= 3) {
+        const storagePath = hirExprToStringLiteral(expr.args[0])
+        const fieldName = hirExprToStringLiteral(expr.args[1])
+        const indexOp = lowerExpr(expr.args[2], ctx, scope)
+        const t = ctx.freshTemp()
+        if (indexOp.kind === 'const') {
+          ctx.emit({ kind: 'nbt_read', dst: t, ns: storagePath, path: `${fieldName}[${indexOp.value}]`, scale: 1 })
+        } else {
+          ctx.emit({ kind: 'nbt_read_dynamic', dst: t, ns: storagePath, pathPrefix: fieldName, indexSrc: indexOp })
+        }
+        return { kind: 'temp', name: t }
+      }
+
       // Handle __entity_tag / __entity_untag — entity.tag("name") / entity.untag("name") sugar
       if (expr.fn === '__entity_tag' || expr.fn === '__entity_untag') {
         const selArg = expr.args[0]
@@ -1532,7 +1697,7 @@ function lowerExpr(
 
       // Handle builtin calls → raw MC commands
       if (BUILTIN_SET.has(expr.fn)) {
-        const cmd = formatBuiltinCall(expr.fn, expr.args, ctx.currentMacroParams)
+        const cmd = formatBuiltinCall(expr.fn, expr.args, ctx.currentMacroParams, ctx.getNamespace())
         ctx.emit({ kind: 'call', dst: null, fn: `__raw:${cmd}`, args: [] })
         const t = ctx.freshTemp()
         ctx.emit({ kind: 'const', dst: t, value: 0 })
@@ -1723,6 +1888,28 @@ function lowerExpr(
     }
 
     case 'invoke': {
+      // Check for array.len() call: arr.len() → compile-time constant or NBT length
+      if (expr.callee.kind === 'member' && expr.callee.field === 'len' && expr.callee.obj.kind === 'ident') {
+        const arrInfo = ctx.arrayVars.get((expr.callee.obj as { kind: 'ident'; name: string }).name)
+        if (arrInfo) {
+          if (arrInfo.knownLen !== undefined) {
+            // Compile-time constant length (literal array)
+            const t = ctx.freshTemp()
+            ctx.emit({ kind: 'const', dst: t, value: arrInfo.knownLen })
+            return { kind: 'temp', name: t }
+          }
+          // Dynamic array (function parameter, heap_new, etc.): read length at runtime
+          // emit: execute store result score $t __ns run data get storage ns:arrays path
+          const t = ctx.freshTemp()
+          ctx.emit({ kind: 'nbt_list_len', dst: t, ns: arrInfo.ns, path: arrInfo.pathPrefix })
+          return { kind: 'temp', name: t }
+        }
+        // Also check scope-tracked length temp for literal arrays
+        const lenTemp = scope.get((expr.callee.obj as { kind: 'ident'; name: string }).name)
+        if (lenTemp !== undefined) {
+          return { kind: 'temp', name: lenTemp }
+        }
+      }
       // Check for struct method call: v.method(args)
       if (expr.callee.kind === 'member' && expr.callee.obj.kind === 'ident') {
         const sv = ctx.structVars.get(expr.callee.obj.name)
@@ -2145,11 +2332,47 @@ const MACRO_SENTINEL = '\x01'
  * If any argument uses a macro param, the command is prefixed with \x01
  * (converted to $ in LIR emission).
  */
+/**
+ * Convert an f_string HIRExpr to a Minecraft JSON text component string.
+ * Each interpolated variable becomes a {"score":{"name":"$var","objective":"__ns"}} component.
+ */
+function fStringToJsonText(expr: HIRExpr, namespace: string): string {
+  if (expr.kind !== 'f_string') return JSON.stringify(expr.kind === 'str_lit' ? { text: expr.value } : { text: '~' })
+  const objective = `__${namespace}`
+  const extra: unknown[] = []
+  for (const part of expr.parts) {
+    if (part.kind === 'text') {
+      if (part.value) extra.push({ text: part.value })
+    } else {
+      // expr part — must be a scoreboard variable (ident)
+      const inner = part.expr
+      if (inner.kind === 'ident') {
+        extra.push({ score: { name: `$${inner.name}`, objective } })
+      } else if (inner.kind === 'int_lit') {
+        extra.push({ text: String(inner.value) })
+      } else {
+        extra.push({ text: '?' })
+      }
+    }
+  }
+  if (extra.length === 0) return '{"text":""}'
+  if (extra.length === 1) return JSON.stringify(extra[0])
+  return JSON.stringify({ text: '', extra })
+}
+
 function formatBuiltinCall(
   fn: string,
   args: HIRExpr[],
   macroParams: Set<string>,
+  namespace = '',
 ): string {
+  // For text-display builtins, the message arg may be an f_string — convert to JSON text
+  const TEXT_BUILTINS = new Set(['tell', 'tellraw', 'title', 'subtitle', 'actionbar', 'announce'])
+  const resolveTextArg = (arg: HIRExpr): string => {
+    if (arg.kind === 'f_string') return fStringToJsonText(arg, namespace)
+    return JSON.stringify({ text: exprToCommandArg(arg, macroParams).str })
+  }
+
   const fmtArgs = args.map(a => exprToCommandArg(a, macroParams))
   const strs = fmtArgs.map(a => a.str)
   const hasMacro = fmtArgs.some(a => a.isMacro)
@@ -2200,12 +2423,32 @@ function formatBuiltinCall(
     }
     case 'say': cmd = `say ${strs[0] ?? ''}`; break
     case 'tell':
-    case 'tellraw': cmd = `tellraw ${strs[0]} {"text":"${strs[1]}"}`; break
-    case 'title': cmd = `title ${strs[0]} title {"text":"${strs[1]}"}`; break
-    case 'actionbar': cmd = `title ${strs[0]} actionbar {"text":"${strs[1]}"}`; break
-    case 'subtitle': cmd = `title ${strs[0]} subtitle {"text":"${strs[1]}"}`; break
+    case 'tellraw': {
+      const msgJson = resolveTextArg(args[1])
+      cmd = `tellraw ${strs[0]} ${msgJson}`
+      break
+    }
+    case 'title': {
+      const msgJson = resolveTextArg(args[1])
+      cmd = `title ${strs[0]} title ${msgJson}`
+      break
+    }
+    case 'actionbar': {
+      const msgJson = resolveTextArg(args[1])
+      cmd = `title ${strs[0]} actionbar ${msgJson}`
+      break
+    }
+    case 'subtitle': {
+      const msgJson = resolveTextArg(args[1])
+      cmd = `title ${strs[0]} subtitle ${msgJson}`
+      break
+    }
     case 'title_times': cmd = `title ${strs[0]} times ${strs[1]} ${strs[2]} ${strs[3]}`; break
-    case 'announce': cmd = `tellraw @a {"text":"${strs[0]}"}`; break
+    case 'announce': {
+      const msgJson = resolveTextArg(args[0])
+      cmd = `tellraw @a ${msgJson}`
+      break
+    }
     case 'give': {
       const nbt = strs[3] ? strs[3] : ''
       cmd = `give ${strs[0]} ${strs[1]}${nbt} ${strs[2] ?? '1'}`

package/src/mir/types.ts

@@ -81,6 +81,7 @@ export type MIRInstr = MIRInstrBase & (
   | { kind: 'nbt_read_dynamic'; dst: Temp; ns: string; pathPrefix: string; indexSrc: Operand }
   | { kind: 'nbt_write'; ns: string; path: string; type: NBTType; scale: number; src: Operand }
   | { kind: 'nbt_write_dynamic'; ns: string; pathPrefix: string; indexSrc: Operand; valueSrc: Operand }
+  | { kind: 'nbt_list_len'; dst: Temp; ns: string; path: string }
 
   // ── Vanilla scoreboard interop ────────────────────────────────────────────
   | { kind: 'score_read'; dst: Temp; player: string; obj: string }

package/src/mir/verify.ts

@@ -165,6 +165,7 @@ function getDst(instr: MIRInstr): Temp | null {
     case 'and': case 'or': case 'not':
     case 'nbt_read':
     case 'nbt_read_dynamic':
+    case 'nbt_list_len':
       return instr.dst
     case 'call':
     case 'call_macro':
@@ -194,6 +195,7 @@ function getUsedTemps(instr: MIRInstr): Temp[] {
       temps.push(...getOperandTemps(instr.a), ...getOperandTemps(instr.b))
       break
     case 'nbt_read':
+    case 'nbt_list_len':
       break
     case 'nbt_read_dynamic':
       temps.push(...getOperandTemps(instr.indexSrc))

package/src/optimizer/interprocedural.ts

@@ -134,6 +134,10 @@ function substituteInstr(instr: MIRInstr, sub: Map<Temp, Operand>): MIRInstr {
       return { ...instr, a: substituteOp(instr.a, sub), b: substituteOp(instr.b, sub) }
     case 'nbt_write':
       return { ...instr, src: substituteOp(instr.src, sub) }
+    case 'nbt_read_dynamic':
+      return { ...instr, indexSrc: substituteOp(instr.indexSrc, sub) }
+    case 'nbt_write_dynamic':
+      return { ...instr, indexSrc: substituteOp(instr.indexSrc, sub), valueSrc: substituteOp(instr.valueSrc, sub) }
     case 'call':
       return { ...instr, args: instr.args.map(a => substituteOp(a, sub)) }
     case 'call_macro':

package/src/parser/index.ts

@@ -10,7 +10,7 @@ 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
+  CoordComponent, LambdaParam, EntityTypeName, ImportDecl, MatchPattern
 } from '../ast/types'
 import type { BinOp, CmpOp } from '../ast/types'
 import { DiagnosticError } from '../diagnostics'
@@ -395,12 +395,15 @@ export class Parser {
     }
 
     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: import('../ast/types').FnDecl = this.withLoc(
       { name, typeParams, params, returnType, decorators: filteredDecorators, body,
         isLibraryFn: this.inLibraryMode || undefined, isExported },
       fnToken,
     )
+    if (fn.span && closingBraceLine) fn.span.endLine = closingBraceLine
     return fn
   }
 
@@ -906,7 +909,16 @@ export 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()
@@ -955,25 +967,62 @@ export class Parser {
     return this.withLoc({ kind: 'foreach', binding, iterable, body, executeContext }, foreachToken)
   }
 
+  private parseMatchPattern(): MatchPattern {
+    // 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 }
+    }
+    // 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 }
+  }
+
   private parseMatchStmt(): Stmt {
     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: 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: Array<{ pattern: Expr | null; body: Block }> = []
+    const arms: Array<{ pattern: MatchPattern; body: Block }> = []
     while (!this.check('}') && !this.check('eof')) {
-      let pattern: Expr | null
-      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 })
     }