redscript-mc 2.6.2 → 3.0.0

package/src/emit/index.ts

@@ -6,7 +6,13 @@
  */
 
 import type { LIRModule, LIRFunction, LIRInstr, Slot, CmpOp, ExecuteSubcmd } from '../lir/types'
-import { SourceMapBuilder, serializeSourceMap, sourceMapPath } from './sourcemap'
+import {
+  NamespaceSourceMapBuilder,
+  SourceMapBuilder,
+  namespaceSourceMapPath,
+  serializeSourceMap,
+  sourceMapPath,
+} from './sourcemap'
 import { McVersion, DEFAULT_MC_VERSION } from '../types/mc-version'
 
 export interface DatapackFile {
@@ -14,17 +20,35 @@ export interface DatapackFile {
   content: string
 }
 
+export interface WatchFunction {
+  name: string
+  objective: string
+}
+
 export interface EmitOptions {
   namespace: string
   tickFunctions?: string[]
   loadFunctions?: string[]
   scheduleFunctions?: Array<{ name: string; ticks: number }>
+  watchFunctions?: WatchFunction[]
   /** When true, generate a .sourcemap.json sidecar file for each .mcfunction */
   generateSourceMap?: boolean
   /** Target Minecraft version; controls which MC features are used in codegen */
   mcVersion?: McVersion
   /** Map of EventTypeName → list of fully-qualified function references for @on handlers */
   eventHandlers?: Map<string, string[]>
+  /** Scoreboard objective names for @singleton struct fields — added to load.mcfunction */
+  singletonObjectives?: string[]
+  /** Functions decorated with @profile. */
+  profiledFunctions?: string[]
+  /** Emit debug-only profiling instrumentation and helpers. */
+  enableProfiling?: boolean
+  /** Functions decorated with @throttle. */
+  throttleFunctions?: Array<{ name: string; ticks: number }>
+  /** Functions decorated with @retry. */
+  retryFunctions?: Array<{ name: string; max: number }>
+  /** Functions decorated with @memoize — single-arg int result caching (LRU-1). */
+  memoizeFunctions?: string[]
 }
 
 // ---------------------------------------------------------------------------
@@ -36,10 +60,17 @@ export function emit(module: LIRModule, options: EmitOptions): DatapackFile[] {
   const tickFns = options.tickFunctions ?? []
   const loadFns = options.loadFunctions ?? []
   const scheduleFns = options.scheduleFunctions ?? []
+  const watchFns = options.watchFunctions ?? []
+  const profiledFns = options.profiledFunctions ?? []
+  const enableProfiling = options.enableProfiling ?? false
+  const throttleFns = options.throttleFunctions ?? []
+  const retryFns = options.retryFunctions ?? []
+  const memoizeFns = options.memoizeFunctions ?? []
   const objective = module.objective
   const genSourceMap = options.generateSourceMap ?? false
   const mcVersion = options.mcVersion ?? DEFAULT_MC_VERSION
   const files: DatapackFile[] = []
+  const namespaceMapBuilder = genSourceMap ? new NamespaceSourceMapBuilder() : null
 
   // pack.mcmeta
   files.push({
@@ -49,8 +80,23 @@ export function emit(module: LIRModule, options: EmitOptions): DatapackFile[] {
     }, null, 2) + '\n',
   })
 
+  const singletonObjectives = options.singletonObjectives ?? []
+
   // load.mcfunction — creates the scoreboard objective
-  const loadCmds = [`scoreboard objectives add ${objective} dummy`]
+  const loadCmds = [
+    `scoreboard objectives add ${objective} dummy`,
+    ...watchFns.map(watch => `scoreboard objectives add ${watchPrevObjective(watch.name)} dummy`),
+    ...singletonObjectives.map(obj => `scoreboard objectives add ${obj} dummy`),
+    ...(enableProfiling && profiledFns.length > 0
+      ? [
+          'scoreboard objectives add __time dummy',
+          'scoreboard objectives add __profile dummy',
+        ]
+      : []),
+    ...throttleFns.map(t => `scoreboard objectives add ${throttleObjective(t.name)} dummy`),
+    ...retryFns.map(r => `scoreboard objectives add ${retryObjective(r.name)} dummy`),
+    ...(memoizeFns.length > 0 ? [`scoreboard objectives add __memo dummy`] : []),
+  ]
   files.push({
     path: `data/${namespace}/function/load.mcfunction`,
     content: loadCmds.join('\n') + '\n',
@@ -59,20 +105,40 @@ export function emit(module: LIRModule, options: EmitOptions): DatapackFile[] {
   // Each LIR function → .mcfunction file
   for (const fn of module.functions) {
     const fnPath = fnNameToPath(fn.name, namespace)
+    namespaceMapBuilder?.addFunctionMapping(qualifiedFunctionRef(fn.name, namespace), fn.sourceLoc, humanFunctionName(fn))
     if (genSourceMap) {
       const builder = new SourceMapBuilder(fnPath)
-      const lines = emitFunctionWithSourceMap(fn, namespace, objective, builder, mcVersion)
+      const lines = emitFunction(fn, namespace, objective, mcVersion, enableProfiling && profiledFns.includes(fn.name), builder)
       files.push({ path: fnPath, content: lines.join('\n') + '\n' })
       const map = builder.build()
       if (map) {
         files.push({ path: sourceMapPath(fnPath), content: serializeSourceMap(map) })
       }
     } else {
-      const lines = emitFunction(fn, namespace, objective, mcVersion)
+      const lines = emitFunction(fn, namespace, objective, mcVersion, enableProfiling && profiledFns.includes(fn.name))
       files.push({ path: fnPath, content: lines.join('\n') + '\n' })
     }
   }
 
+  const namespaceMap = namespaceMapBuilder?.build()
+  if (namespaceMap) {
+    files.push({
+      path: namespaceSourceMapPath(namespace),
+      content: serializeSourceMap(namespaceMap),
+    })
+  }
+
+  if (enableProfiling && profiledFns.length > 0) {
+    files.push({
+      path: `data/${namespace}/function/__profiler_reset.mcfunction`,
+      content: emitProfilerReset(profiledFns).join('\n') + '\n',
+    })
+    files.push({
+      path: `data/${namespace}/function/__profiler_report.mcfunction`,
+      content: emitProfilerReport(profiledFns).join('\n') + '\n',
+    })
+  }
+
   // @schedule wrapper functions: _schedule_xxx → schedule function ns:xxx Nt
   for (const { name, ticks } of scheduleFns) {
     files.push({
@@ -81,6 +147,122 @@ export function emit(module: LIRModule, options: EmitOptions): DatapackFile[] {
     })
   }
 
+  for (const watch of watchFns) {
+    const dispatcher = watchDispatcherName(watch.name)
+    const prevObjective = watchPrevObjective(watch.name)
+    const changedCondition = `unless score @s ${watch.objective} = @s ${prevObjective}`
+    files.push({
+      path: fnNameToPath(dispatcher, namespace),
+      content: [
+        `execute as @a unless score @s ${prevObjective} = @s ${prevObjective} run scoreboard players operation @s ${prevObjective} = @s ${watch.objective}`,
+        `execute as @a ${changedCondition} run function ${namespace}:${watch.name}`,
+        `execute as @a ${changedCondition} run scoreboard players operation @s ${prevObjective} = @s ${watch.objective}`,
+      ].join('\n') + '\n',
+    })
+  }
+
+  // @throttle wrapper functions
+  for (const { name, ticks } of throttleFns) {
+    const obj = throttleObjective(name)
+    const inner = `${name}_inner`
+    files.push({
+      path: fnNameToPath(throttleDispatcherName(name), namespace),
+      content: [
+        `scoreboard players add __throttle_${name} ${obj} 1`,
+        `execute if score __throttle_${name} ${obj} matches ${ticks}.. run function ${namespace}:${inner}`,
+        `execute if score __throttle_${name} ${obj} matches ${ticks}.. run scoreboard players set __throttle_${name} ${obj} 0`,
+      ].join('\n') + '\n',
+    })
+    // Rename the original function to _inner by emitting a redirect wrapper:
+    // The original LIR function keeps its original name; the dispatcher wraps it.
+    // We just need the dispatcher to call the real function as <name>_inner.
+    // Actually: the original compiled function stays as <name>. We generate
+    // a wrapper at <name>_inner that simply calls <name>.
+    files.push({
+      path: fnNameToPath(inner, namespace),
+      content: `function ${namespace}:${name}\n`,
+    })
+  }
+
+  // @retry wrapper functions
+  for (const { name, max } of retryFns) {
+    const obj = retryObjective(name)
+    const dispatcherName = retryDispatcherName(name)
+    // Dispatcher: if retries remaining > 0, call the function; if it returns 0, decrement counter
+    // We use a two-file approach:
+    //   __retry_<name>: decrements counter then calls the real function
+    //   __retry_<name>_init: sets the counter to max and schedules the first attempt
+    // Runtime logic:
+    //   - On success (fn returns nonzero): reset counter to 0
+    //   - On failure (fn returns 0): counter -= 1, schedule next tick
+    // Since we can't read a function return value in mcfunction directly,
+    // we use a storage-based approach: the function itself sets a "success" flag.
+    // Simpler scoreboard approach (matching task spec):
+    //   __retry_<name> obj tracks remaining attempts
+    //   Each tick, if counter > 0: call fn, if fn "failed" (set counter to 0 from outside) schedule retry
+    // Simplest correct approach:
+    //   generate a tick-registered dispatcher that:
+    //     1. if counter > 0, call the function
+    //     2. function sets __retry_<name>_result to 1 on success (convention)
+    //     3. if result == 0, decrement counter; else reset counter
+    // For simplicity, use the same pattern as @throttle but inverted:
+    //   The user's function sets a score $ret to signal success/failure.
+    //   We wrap it: if counter > 0, run the function.
+    //   After running, check $ret: if 0, keep counter; else reset to 0.
+    //   Next tick the dispatcher will retry if counter > 0.
+    //
+    // Minimal correct implementation (matching task spec — fn returns 0 = failure):
+    //   __retry_<name>_tick: registered as @tick
+    //     execute if score __retry_<name> <obj> matches 1.. run function ns:<name>
+    //     execute if score __retry_<name> <obj> matches 1.. if score $ret <obj> matches 0 run scoreboard players remove __retry_<name> <obj> 1
+    //     execute if score __retry_<name> <obj> matches 1.. unless score $ret <obj> matches 0 run scoreboard players set __retry_<name> <obj> 0
+    //   To start a retry sequence, something must set __retry_<name> <obj> to max.
+    //   We generate __retry_<name>_start: scoreboard players set __retry_<name> <obj> <max>
+    files.push({
+      path: fnNameToPath(dispatcherName, namespace),
+      content: [
+        `execute if score __retry_${name} ${obj} matches 1.. run function ${namespace}:${name}`,
+        `execute if score __retry_${name} ${obj} matches 1.. if score $ret ${obj} matches 0 run scoreboard players remove __retry_${name} ${obj} 1`,
+        `execute if score __retry_${name} ${obj} matches 1.. unless score $ret ${obj} matches 0 run scoreboard players set __retry_${name} ${obj} 0`,
+      ].join('\n') + '\n',
+    })
+    files.push({
+      path: fnNameToPath(`${name}_start`, namespace),
+      content: `scoreboard players set __retry_${name} ${obj} ${max}\n`,
+    })
+  }
+
+  // @memoize wrapper functions (LRU-1 cache: last call arg/result)
+  // The original compiled function has been renamed to <name>_impl.
+  // We generate <name>.mcfunction as the public entry point with cache logic:
+  //   Players in __memo objective:
+  //     __memo_<name>_key  — cached argument value
+  //     __memo_<name>_val  — cached return value
+  //     __memo_<name>_hit  — 1 if a cached result is available
+  //   On call ($p0 = argument):
+  //     1. If __memo_<name>_hit == 1 AND __memo_<name>_key == $p0 → copy cached val to $ret, return
+  //     2. Otherwise: call <name>_impl, store $p0 → key, $ret → val, set hit=1
+  for (const name of memoizeFns) {
+    const keyPlayer = `__memo_${name}_key`
+    const valPlayer = `__memo_${name}_val`
+    const hitPlayer = `__memo_${name}_hit`
+    const implName = `${name}_impl`
+    files.push({
+      path: fnNameToPath(name, namespace),
+      content: [
+        `# @memoize wrapper for ${name} (LRU-1 cache)`,
+        `# Cache hit: valid flag set AND key matches current arg`,
+        `execute if score ${hitPlayer} __memo matches 1 if score ${keyPlayer} __memo = $p0 ${objective} run scoreboard players operation $ret ${objective} = ${valPlayer} __memo`,
+        `execute if score ${hitPlayer} __memo matches 1 if score ${keyPlayer} __memo = $p0 ${objective} run return 0`,
+        `# Cache miss: call implementation, store result`,
+        `function ${namespace}:${implName}`,
+        `scoreboard players operation ${keyPlayer} __memo = $p0 ${objective}`,
+        `scoreboard players operation ${valPlayer} __memo = $ret ${objective}`,
+        `scoreboard players set ${hitPlayer} __memo 1`,
+      ].join('\n') + '\n',
+    })
+  }
+
   // Tag files for tick/load
   if (loadFns.length > 0 || true) {
     // Always include load.json — it must reference the load.mcfunction
@@ -91,8 +273,14 @@ export function emit(module: LIRModule, options: EmitOptions): DatapackFile[] {
     })
   }
 
-  if (tickFns.length > 0) {
-    const tickValues = tickFns.map(fn => `${namespace}:${fn}`)
+  const allTickFns = [
+    ...tickFns,
+    ...watchFns.map(watch => watchDispatcherName(watch.name)),
+    ...throttleFns.map(t => throttleDispatcherName(t.name)),
+    ...retryFns.map(r => retryDispatcherName(r.name)),
+  ]
+  if (allTickFns.length > 0) {
+    const tickValues = allTickFns.map(fn => `${namespace}:${fn}`)
     files.push({
       path: 'data/minecraft/tags/function/tick.json',
       content: JSON.stringify({ values: tickValues }, null, 2) + '\n',
@@ -127,25 +315,36 @@ export function emit(module: LIRModule, options: EmitOptions): DatapackFile[] {
 // Function emission
 // ---------------------------------------------------------------------------
 
-function emitFunction(fn: LIRFunction, namespace: string, objective: string, mcVersion: McVersion): string[] {
-  const lines: string[] = []
-  for (const instr of fn.instructions) {
-    lines.push(emitInstr(instr, namespace, objective, mcVersion))
-  }
-  return lines
-}
-
-function emitFunctionWithSourceMap(
+function emitFunction(
   fn: LIRFunction,
   namespace: string,
   objective: string,
-  builder: SourceMapBuilder,
   mcVersion: McVersion,
+  isProfiled = false,
+  builder?: SourceMapBuilder,
 ): string[] {
   const lines: string[] = []
+  const pushLine = (line: string, sourceLoc?: LIRFunction['sourceLoc']): void => {
+    lines.push(line)
+    builder?.addLine(sourceLoc)
+  }
+
+  for (const line of emitFunctionHeader(fn)) pushLine(line)
+  if (isProfiled) {
+    for (const line of profilerStartLines(fn.name)) pushLine(line)
+  }
+
+  let lastSourceMarker: string | undefined
   for (const instr of fn.instructions) {
-    lines.push(emitInstr(instr, namespace, objective, mcVersion))
-    builder.addLine(instr.sourceLoc)
+    const marker = instr.sourceLoc ? formatSourceMarker(instr.sourceLoc) : undefined
+    if (marker && marker !== lastSourceMarker) {
+      pushLine(`# src: ${marker}`)
+      lastSourceMarker = marker
+    }
+    pushLine(flattenExecute(emitInstr(instr, namespace, objective, mcVersion)), instr.sourceLoc)
+  }
+  if (isProfiled) {
+    for (const line of profilerEndLines(fn.name)) pushLine(line)
   }
   return lines
 }
@@ -156,6 +355,105 @@ function fnNameToPath(name: string, namespace: string): string {
   return `data/${namespace}/function/${mcName}.mcfunction`
 }
 
+function qualifiedFunctionRef(name: string, namespace: string): string {
+  return `${namespace}:${name.replace(/::/g, '/').toLowerCase()}`
+}
+
+function humanFunctionName(fn: LIRFunction): string {
+  const match = fn.sourceSnippet?.match(/^fn\s+([^(]+)/)
+  return match?.[1] ?? fn.name.split('::').pop() ?? fn.name
+}
+
+function emitFunctionHeader(fn: LIRFunction): string[] {
+  if (!fn.sourceLoc) return []
+  const lines: string[] = []
+  lines.push(`# Generated from: ${fn.sourceLoc.file}:${fn.sourceLoc.line} (fn ${humanFunctionName(fn)})`)
+  if (fn.sourceSnippet) {
+    lines.push(`# Source: ${fn.sourceSnippet}`)
+  }
+  return lines
+}
+
+function formatSourceMarker(sourceLoc: NonNullable<LIRInstr['sourceLoc']>): string {
+  return `${sourceLoc.file}:${sourceLoc.line}`
+}
+
+function watchDispatcherName(name: string): string {
+  return `__watch_${name}`
+}
+
+function watchPrevObjective(name: string): string {
+  return `__watch_${name}_prev`
+}
+
+function throttleDispatcherName(name: string): string {
+  return `__throttle_${name}`
+}
+
+function throttleObjective(name: string): string {
+  return `__throttle`
+}
+
+function retryDispatcherName(name: string): string {
+  return `__retry_${name}`
+}
+
+function retryObjective(name: string): string {
+  return `__retry`
+}
+
+function profilerSafeName(name: string): string {
+  return name.replace(/[^A-Za-z0-9_]/g, '_')
+}
+
+function profilerStartPlayer(name: string): string {
+  return `#prof_start_${profilerSafeName(name)}`
+}
+
+function profilerDeltaPlayer(name: string): string {
+  return `#prof_delta_${profilerSafeName(name)}`
+}
+
+function profilerTotalPlayer(name: string): string {
+  return `#prof_total_${profilerSafeName(name)}`
+}
+
+function profilerCountPlayer(name: string): string {
+  return `#prof_count_${profilerSafeName(name)}`
+}
+
+function profilerStartLines(name: string): string[] {
+  return [
+    `# __profiler_start_${name}`,
+    `scoreboard players set ${profilerStartPlayer(name)} __time 0`,
+    `execute store result score ${profilerStartPlayer(name)} __time run time query gametime`,
+  ]
+}
+
+function profilerEndLines(name: string): string[] {
+  return [
+    `# __profiler_end_${name}`,
+    `scoreboard players set ${profilerDeltaPlayer(name)} __time 0`,
+    `execute store result score ${profilerDeltaPlayer(name)} __time run time query gametime`,
+    `scoreboard players operation ${profilerDeltaPlayer(name)} __time -= ${profilerStartPlayer(name)} __time`,
+    `scoreboard players operation ${profilerTotalPlayer(name)} __profile += ${profilerDeltaPlayer(name)} __time`,
+    `scoreboard players add ${profilerCountPlayer(name)} __profile 1`,
+  ]
+}
+
+function emitProfilerReset(profiledFns: string[]): string[] {
+  return profiledFns.flatMap(name => [
+    `scoreboard players set ${profilerTotalPlayer(name)} __profile 0`,
+    `scoreboard players set ${profilerCountPlayer(name)} __profile 0`,
+  ])
+}
+
+function emitProfilerReport(profiledFns: string[]): string[] {
+  return profiledFns.map(name => (
+    `tellraw @a [{"text":"[profile] ${name}: total="},{"score":{"name":"${profilerTotalPlayer(name)}","objective":"__profile"}},{"text":" ticks count="},{"score":{"name":"${profilerCountPlayer(name)}","objective":"__profile"}}]`
+  ))
+}
+
 // ---------------------------------------------------------------------------
 // Instruction emission
 // ---------------------------------------------------------------------------
@@ -283,6 +581,56 @@ function macroLineCompat(template: string): string {
   return template.replace(/\$\((\w+)\)/g, (_m, p) => `{storage:rs:macro_args,path:${p}}`)
 }
 
+// ---------------------------------------------------------------------------
+// Execute Chain Optimization
+// ---------------------------------------------------------------------------
+
+/**
+ * Flatten nested execute-if chains into a single execute with multiple conditions.
+ *
+ * MC allows chaining conditions:
+ *   execute if A run execute if B run X
+ * can be written as:
+ *   execute if A if B run X
+ *
+ * This reduces command-parsing overhead and improves TPS.
+ *
+ * Rules:
+ * - Only merges when the inner `run` clause is itself `execute if ...`
+ * - Does NOT merge `if ... run execute unless ...` — semantics differ
+ *   (unless negates, changing behavior in chain context)
+ * - Recursively flattens deeper nesting (3+ levels)
+ */
+export function flattenExecute(cmd: string): string {
+  // Match: execute <conditions> run execute if <rest>
+  // We only flatten when the inner execute starts with "if" (not "unless", "as", "at", etc.)
+  // Pattern: "execute <prefix> run execute if <suffix>"
+  const RUN_EXECUTE_IF = / run execute if /
+  if (!RUN_EXECUTE_IF.test(cmd)) {
+    return cmd
+  }
+
+  // Find the " run execute if " boundary
+  const idx = cmd.indexOf(' run execute if ')
+  if (idx === -1) return cmd
+
+  const outer = cmd.slice(0, idx)           // "execute if A"
+  const inner = cmd.slice(idx + ' run '.length) // "execute if B run X"
+
+  // The outer must start with "execute"
+  if (!outer.startsWith('execute ')) return cmd
+
+  // Inner starts with "execute if ..."
+  // Strip the "execute" prefix from inner to get the conditions + run tail
+  // Result: outer + " " + inner_conditions_and_tail
+  const innerWithoutExecute = inner.slice('execute '.length) // "if B run X"
+
+  const merged = `${outer} ${innerWithoutExecute}`
+
+  // Recurse to handle 3+ levels
+  return flattenExecute(merged)
+}
+
 function emitSubcmd(sub: ExecuteSubcmd): string {
   switch (sub.kind) {
     case 'as':

package/src/emit/modules.ts

@@ -69,6 +69,9 @@ export function compileModules(
     const tokens = lexer.tokenize()
     const parser = new Parser(tokens, mod.source, mod.filePath)
     const ast = parser.parse(namespace)
+    if (parser.parseErrors.length > 0) {
+      throw parser.parseErrors[0]
+    }
 
     // Verify declared module name matches provided name
     const declaredName = ast.moduleName
@@ -122,7 +125,12 @@ export function compileModules(
         )
       }
 
-      if (imp.symbol === '*') {
+      if (imp.symbol === undefined) {
+        // Whole-module file import (`import player_utils;`) — not a symbol import;
+        // this is resolved by the file-level compile() function, not compileModules.
+        // Skip here to avoid treating it as a cross-module symbol reference.
+        continue
+      } else if (imp.symbol === '*') {
         // Wildcard: import all exports
         for (const sym of sourceExports) {
           resolved.set(sym, `${imp.moduleName}/${sym}`)
@@ -153,6 +161,7 @@ export function compileModules(
 
   for (const ast of parsedModules.values()) {
     for (const imp of ast.imports) {
+      if (imp.symbol === undefined) continue // whole-module file import, skip
       const used = usedExports.get(imp.moduleName)
       if (!used) continue
       if (imp.symbol === '*') {
@@ -346,12 +355,16 @@ function compileSingleModule(
     // Extract decorator metadata
     const tickFunctions: string[] = []
     const loadFunctions: string[] = []
+    const watchFunctions: Array<{ name: string; objective: string }> = []
     const coroutineInfos: CoroutineInfo[] = []
     const scheduleFunctions: Array<{ name: string; ticks: number }> = []
     for (const fn of hir.functions) {
       for (const dec of fn.decorators) {
         if (dec.name === 'tick') tickFunctions.push(fn.name)
         if (dec.name === 'load') loadFunctions.push(fn.name)
+        if (dec.name === 'watch' && dec.args?.objective) {
+          watchFunctions.push({ name: fn.name, objective: dec.args.objective })
+        }
         if (dec.name === 'coroutine') {
           coroutineInfos.push({ fnName: fn.name, batch: dec.args?.batch ?? 10, onDone: dec.args?.onDone })
         }
@@ -374,7 +387,7 @@ function compileSingleModule(
     lir.objective = objective
     const lirOpt = lirOptimizeModule(lir)
 
-    const files = emit(lirOpt, { namespace, tickFunctions, loadFunctions, scheduleFunctions })
+    const files = emit(lirOpt, { namespace, tickFunctions, loadFunctions, watchFunctions, scheduleFunctions })
 
     // For named modules: rename the load.mcfunction to avoid path collision.
     // Rename `data/${ns}/function/load.mcfunction` → `data/${ns}/function/${modName}/_load.mcfunction`
@@ -525,7 +538,10 @@ function rewriteStmt(stmt: Stmt, symbolMap: Map<string, string>): void {
     case 'let_destruct':
       rewriteExpr(stmt.init, symbolMap)
       break
-    // break, continue, raw: nothing to rewrite
+    case 'labeled_loop':
+      rewriteStmt(stmt.body, symbolMap)
+      break
+    // break, continue, break_label, continue_label, raw: nothing to rewrite
   }
 }