redscript-mc 2.6.2 → 3.0.0

package/src/emit/sourcemap.ts

@@ -1,51 +1,35 @@
 /**
- * Source Map Generation — Stage 7 auxiliary output.
- *
- * For each generated .mcfunction file, produces a parallel sourcemap.json
- * that maps output line numbers back to .mcrs source locations.
- *
- * Format:
- * {
- *   "version": 1,
- *   "generatedFile": "data/ns/function/main.mcfunction",
- *   "sources": ["src/main.mcrs"],
- *   "mappings": [
- *     { "line": 1, "source": 0, "sourceLine": 5, "sourceCol": 2 },
- *     ...
- *   ]
- * }
+ * Source map helpers for emitted `.mcfunction` files.
  */
 
 import type { SourceLoc } from '../lir/types'
 
-// ---------------------------------------------------------------------------
-// Public types
-// ---------------------------------------------------------------------------
-
 export interface SourceMapEntry {
-  /** 1-based output line number in the .mcfunction file */
   line: number
-  /** Index into the `sources` array */
   source: number
-  /** 1-based line in the source .mcrs file */
   sourceLine: number
-  /** 1-based column in the source .mcrs file */
   sourceCol: number
 }
 
 export interface SourceMap {
   version: 1
-  /** Relative path to the generated .mcfunction file */
   generatedFile: string
-  /** List of source file paths referenced by mappings */
   sources: string[]
-  /** One entry per mapped output line */
   mappings: SourceMapEntry[]
 }
 
-// ---------------------------------------------------------------------------
-// Builder — accumulates mappings as lines are emitted
-// ---------------------------------------------------------------------------
+export interface NamespaceSourceMapEntry {
+  source: number
+  line: number
+  col?: number
+  name?: string
+}
+
+export interface NamespaceSourceMap {
+  version: 1
+  sources: string[]
+  mappings: Record<string, NamespaceSourceMapEntry>
+}
 
 export class SourceMapBuilder {
   private readonly generatedFile: string
@@ -58,27 +42,17 @@ export class SourceMapBuilder {
     this.generatedFile = generatedFile
   }
 
-  /** Record the source location for the next output line. */
   addLine(sourceLoc: SourceLoc | undefined): void {
     this.lineNumber++
     if (!sourceLoc) return
-
-    let idx = this.sourceIndex.get(sourceLoc.file)
-    if (idx === undefined) {
-      idx = this.sources.length
-      this.sources.push(sourceLoc.file)
-      this.sourceIndex.set(sourceLoc.file, idx)
-    }
-
     this.mappings.push({
       line: this.lineNumber,
-      source: idx,
+      source: this.getSourceIndex(sourceLoc.file),
       sourceLine: sourceLoc.line,
       sourceCol: sourceLoc.col,
     })
   }
 
-  /** Return the completed SourceMap, or null if there are no mappings. */
   build(): SourceMap | null {
     if (this.mappings.length === 0) return null
     return {
@@ -88,14 +62,61 @@ export class SourceMapBuilder {
       mappings: [...this.mappings],
     }
   }
+
+  private getSourceIndex(file: string): number {
+    let idx = this.sourceIndex.get(file)
+    if (idx === undefined) {
+      idx = this.sources.length
+      this.sources.push(file)
+      this.sourceIndex.set(file, idx)
+    }
+    return idx
+  }
 }
 
-/** Serialize a SourceMap to JSON string (pretty-printed). */
-export function serializeSourceMap(map: SourceMap): string {
+export class NamespaceSourceMapBuilder {
+  private readonly sourceIndex = new Map<string, number>()
+  private readonly sources: string[] = []
+  private readonly mappings: Record<string, NamespaceSourceMapEntry> = {}
+
+  addFunctionMapping(functionName: string, sourceLoc: SourceLoc | undefined, name?: string): void {
+    if (!sourceLoc) return
+    this.mappings[functionName] = {
+      source: this.getSourceIndex(sourceLoc.file),
+      line: sourceLoc.line,
+      col: sourceLoc.col,
+      ...(name ? { name } : {}),
+    }
+  }
+
+  build(): NamespaceSourceMap | null {
+    if (Object.keys(this.mappings).length === 0) return null
+    return {
+      version: 1,
+      sources: [...this.sources],
+      mappings: { ...this.mappings },
+    }
+  }
+
+  private getSourceIndex(file: string): number {
+    let idx = this.sourceIndex.get(file)
+    if (idx === undefined) {
+      idx = this.sources.length
+      this.sources.push(file)
+      this.sourceIndex.set(file, idx)
+    }
+    return idx
+  }
+}
+
+export function serializeSourceMap(map: SourceMap | NamespaceSourceMap): string {
   return JSON.stringify(map, null, 2) + '\n'
 }
 
-/** Given a .mcfunction path, return the path for the sidecar sourcemap.json. */
 export function sourceMapPath(mcfunctionPath: string): string {
   return mcfunctionPath.replace(/\.mcfunction$/, '.sourcemap.json')
 }
+
+export function namespaceSourceMapPath(namespace: string): string {
+  return `${namespace}.sourcemap.json`
+}

package/src/formatter/index.ts

@@ -1,22 +1,49 @@
 export function format(source: string): string {
-  const lines = source.split("\n")
+  const lines = source.replace(/\r\n/g, '\n').split('\n')
+  const normalized: string[] = []
+
+  for (const rawLine of lines) {
+    const line = rawLine.trim()
+    if (line === '{' && normalized.length > 0) {
+      let idx = normalized.length - 1
+      while (idx >= 0 && normalized[idx] === '') idx--
+      if (idx >= 0) {
+        normalized[idx] = `${normalized[idx]} {`
+        continue
+      }
+    }
+    normalized.push(line)
+  }
+
   let indent = 0
   const result: string[] = []
+  let blankCount = 0
 
-  for (let line of lines) {
-    line = line.trim()
-    if (!line) { result.push(""); continue }
+  for (const line of normalized) {
+    if (!line) {
+      if (result.length === 0) continue
+      if (blankCount >= 2) continue
+      result.push('')
+      blankCount++
+      continue
+    }
+    blankCount = 0
 
     // Decrease indent before }
-    if (line.startsWith("}")) indent = Math.max(0, indent - 1)
+    if (line.startsWith('}')) indent = Math.max(0, indent - 1)
 
     // Add indentation
-    result.push("    ".repeat(indent) + line)
+    result.push('  '.repeat(indent) + line)
 
     // Increase indent after {
-    if (line.endsWith("{")) indent++
+    if (line.endsWith('{')) indent++
+  }
+
+  while (result.length > 0 && result[result.length - 1] === '') {
+    result.pop()
   }
 
   // Ensure single newline at end
-  return result.join("\n").trimEnd() + "\n"
+  if (result.length === 0) return '\n'
+  return result.join('\n') + '\n'
 }

package/src/hir/deprecated.ts

@@ -0,0 +1,212 @@
+/**
+ * Deprecated function checker — Stage 2.5 of the RedScript compiler pipeline.
+ *
+ * Walks HIR to find calls to @deprecated-annotated functions and collects
+ * compile-time warnings (non-fatal).
+ */
+
+import type { HIRModule, HIRFunction, HIRStmt, HIRExpr, HIRBlock } from './types'
+import type { Decorator } from '../ast/types'
+
+/**
+ * Build a map from function name → deprecation message for all @deprecated functions.
+ */
+function buildDeprecatedMap(hir: HIRModule): Map<string, string> {
+  const deprecated = new Map<string, string>()
+  for (const fn of hir.functions) {
+    const dep = getDeprecatedDecorator(fn.decorators)
+    if (dep !== null) {
+      deprecated.set(fn.name, dep)
+    }
+  }
+  // Also check impl block methods
+  for (const ib of hir.implBlocks) {
+    for (const m of ib.methods) {
+      const dep = getDeprecatedDecorator(m.decorators)
+      if (dep !== null) {
+        deprecated.set(`${ib.typeName}::${m.name}`, dep)
+      }
+    }
+  }
+  return deprecated
+}
+
+function getDeprecatedDecorator(decorators: Decorator[]): string | null {
+  for (const dec of decorators) {
+    if (dec.name === 'deprecated') {
+      return dec.args?.message ?? ''
+    }
+  }
+  return null
+}
+
+/**
+ * Walk HIR and emit a warning for every call to a @deprecated function.
+ *
+ * Returns an array of warning strings (same format as parser.warnings).
+ */
+export function checkDeprecatedCalls(hir: HIRModule): string[] {
+  const deprecated = buildDeprecatedMap(hir)
+  if (deprecated.size === 0) return []
+
+  const warnings: string[] = []
+
+  for (const fn of hir.functions) {
+    walkBlock(fn.body, fn.name, deprecated, warnings)
+  }
+  for (const ib of hir.implBlocks) {
+    for (const m of ib.methods) {
+      walkBlock(m.body, `${ib.typeName}::${m.name}`, deprecated, warnings)
+    }
+  }
+
+  return warnings
+}
+
+function walkBlock(block: HIRBlock, caller: string, deprecated: Map<string, string>, warnings: string[]): void {
+  for (const stmt of block) {
+    walkStmt(stmt, caller, deprecated, warnings)
+  }
+}
+
+function walkStmt(stmt: HIRStmt, caller: string, deprecated: Map<string, string>, warnings: string[]): void {
+  switch (stmt.kind) {
+    case 'let':
+    case 'let_destruct':
+      walkExpr(stmt.init, caller, deprecated, warnings)
+      break
+    case 'expr':
+      walkExpr(stmt.expr, caller, deprecated, warnings)
+      break
+    case 'return':
+      if (stmt.value) walkExpr(stmt.value, caller, deprecated, warnings)
+      break
+    case 'if':
+      walkExpr(stmt.cond, caller, deprecated, warnings)
+      walkBlock(stmt.then, caller, deprecated, warnings)
+      if (stmt.else_) walkBlock(stmt.else_, caller, deprecated, warnings)
+      break
+    case 'while':
+      walkExpr(stmt.cond, caller, deprecated, warnings)
+      walkBlock(stmt.body, caller, deprecated, warnings)
+      if (stmt.step) walkBlock(stmt.step, caller, deprecated, warnings)
+      break
+    case 'foreach':
+      walkExpr(stmt.iterable, caller, deprecated, warnings)
+      walkBlock(stmt.body, caller, deprecated, warnings)
+      break
+    case 'match':
+      walkExpr(stmt.expr, caller, deprecated, warnings)
+      for (const arm of stmt.arms) {
+        walkBlock(arm.body, caller, deprecated, warnings)
+      }
+      break
+    // break/continue/raw/execute: no sub-exprs to walk for deprecation purposes
+    default:
+      break
+  }
+}
+
+function walkExpr(expr: HIRExpr, caller: string, deprecated: Map<string, string>, warnings: string[]): void {
+  switch (expr.kind) {
+    case 'call': {
+      // Check if this function is deprecated
+      if (deprecated.has(expr.fn)) {
+        const msg = deprecated.get(expr.fn)!
+        const location = expr.span ? `line ${expr.span.line}, col ${expr.span.col}: ` : ''
+        const detail = msg ? `: ${msg}` : ''
+        warnings.push(`[DeprecatedUsage] ${location}'${expr.fn}' is deprecated${detail} (called from '${caller}')`)
+      }
+      for (const arg of expr.args) walkExpr(arg, caller, deprecated, warnings)
+      break
+    }
+    case 'static_call': {
+      const qualName = `${expr.type}::${expr.method}`
+      if (deprecated.has(qualName)) {
+        const msg = deprecated.get(qualName)!
+        const location = expr.span ? `line ${expr.span.line}, col ${expr.span.col}: ` : ''
+        const detail = msg ? `: ${msg}` : ''
+        warnings.push(`[DeprecatedUsage] ${location}'${qualName}' is deprecated${detail} (called from '${caller}')`)
+      }
+      for (const arg of expr.args) walkExpr(arg, caller, deprecated, warnings)
+      break
+    }
+    case 'invoke':
+      walkExpr(expr.callee, caller, deprecated, warnings)
+      for (const arg of expr.args) walkExpr(arg, caller, deprecated, warnings)
+      break
+    case 'binary':
+      walkExpr(expr.left, caller, deprecated, warnings)
+      walkExpr(expr.right, caller, deprecated, warnings)
+      break
+    case 'unary':
+      walkExpr(expr.operand, caller, deprecated, warnings)
+      break
+    case 'is_check':
+      walkExpr(expr.expr, caller, deprecated, warnings)
+      break
+    case 'type_cast':
+      walkExpr(expr.expr, caller, deprecated, warnings)
+      break
+    case 'assign':
+      walkExpr(expr.value, caller, deprecated, warnings)
+      break
+    case 'member_assign':
+      walkExpr(expr.obj, caller, deprecated, warnings)
+      walkExpr(expr.value, caller, deprecated, warnings)
+      break
+    case 'index_assign':
+      walkExpr(expr.obj, caller, deprecated, warnings)
+      walkExpr(expr.index, caller, deprecated, warnings)
+      walkExpr(expr.value, caller, deprecated, warnings)
+      break
+    case 'member':
+      walkExpr(expr.obj, caller, deprecated, warnings)
+      break
+    case 'index':
+      walkExpr(expr.obj, caller, deprecated, warnings)
+      walkExpr(expr.index, caller, deprecated, warnings)
+      break
+    case 'array_lit':
+      for (const el of expr.elements) walkExpr(el, caller, deprecated, warnings)
+      break
+    case 'struct_lit':
+      for (const f of expr.fields) walkExpr(f.value, caller, deprecated, warnings)
+      break
+    case 'str_interp':
+      for (const part of expr.parts) {
+        if (typeof part !== 'string') walkExpr(part, caller, deprecated, warnings)
+      }
+      break
+    case 'f_string':
+      for (const part of expr.parts) {
+        if (part.kind === 'expr') walkExpr(part.expr, caller, deprecated, warnings)
+      }
+      break
+    case 'some_lit':
+      walkExpr(expr.value, caller, deprecated, warnings)
+      break
+    case 'unwrap_or':
+      walkExpr(expr.opt, caller, deprecated, warnings)
+      walkExpr(expr.default_, caller, deprecated, warnings)
+      break
+    case 'lambda': {
+      const body = expr.body
+      if (Array.isArray(body)) {
+        walkBlock(body as HIRBlock, caller, deprecated, warnings)
+      } else {
+        walkExpr(body as HIRExpr, caller, deprecated, warnings)
+      }
+      break
+    }
+    case 'tuple_lit':
+      for (const el of expr.elements) walkExpr(el, caller, deprecated, warnings)
+      break
+    case 'enum_construct':
+      for (const arg of expr.args) walkExpr(arg.value, caller, deprecated, warnings)
+      break
+    // Terminals: int_lit, float_lit, bool_lit, str_lit, ident, selector, etc.
+    default:
+      break
+  }
+}

package/src/hir/lower.ts

@@ -18,30 +18,37 @@ import type {
 import type {
   HIRModule, HIRFunction, HIRParam, HIRExpr, HIRStmt, HIRBlock,
   HIRExecuteSubcommand, HIRStruct, HIRImplBlock, HIREnum, HIRConst, HIRGlobal, HIRMatchPattern,
+  HIRFStringPart,
 } from './types'
+import { expandStructDeclarations } from '../structs/expand'
 
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
 
 export function lowerToHIR(program: Program): HIRModule {
+  const structs = expandStructDeclarations(program.structs).map((s): HIRStruct => ({
+    name: s.name,
+    extends: s.extends,
+    fields: s.fields.map(f => ({ name: f.name, type: f.type })),
+    isSingleton: s.isSingleton,
+    span: s.span,
+  }))
+
   return {
     namespace: program.namespace,
     globals: program.globals.map(lowerGlobal),
     functions: program.declarations.map(lowerFunction),
-    structs: program.structs.map((s): HIRStruct => ({
-      name: s.name,
-      fields: s.fields.map(f => ({ name: f.name, type: f.type })),
-      span: s.span,
-    })),
+    structs,
     implBlocks: program.implBlocks.map((ib): HIRImplBlock => ({
       typeName: ib.typeName,
+      traitName: ib.traitName,
       methods: ib.methods.map(lowerFunction),
       span: ib.span,
     })),
     enums: program.enums.map((e): HIREnum => ({
       name: e.name,
-      variants: e.variants.map(v => ({ name: v.name, value: v.value })),
+      variants: e.variants.map(v => ({ name: v.name, value: v.value, fields: v.fields })),
       span: e.span,
     })),
     consts: program.consts.map((c): HIRConst => ({
@@ -65,6 +72,7 @@ function lowerMatchPattern(pat: MatchPattern): HIRMatchPattern {
     case 'PatInt':  return pat
     case 'PatWild': return pat
     case 'PatExpr': return { kind: 'PatExpr', expr: lowerExpr(pat.expr) }
+    case 'PatEnum': return { kind: 'PatEnum', enumName: pat.enumName, variant: pat.variant, bindings: pat.bindings }
   }
 }
 
@@ -93,6 +101,8 @@ function lowerFunction(fn: FnDecl): HIRFunction {
     isLibraryFn: fn.isLibraryFn,
     isExported: fn.isExported,
     span: fn.span,
+    sourceFile: fn.sourceFile,
+    watchObjective: fn.watchObjective,
   }
 }
 
@@ -130,6 +140,9 @@ function lowerStmt(stmt: Stmt): HIRStmt | HIRStmt[] {
     case 'let_destruct':
       return { kind: 'let_destruct', names: stmt.names, type: stmt.type, init: lowerExpr(stmt.init), span: stmt.span }
 
+    case 'const_decl':
+      return { kind: 'const_decl', name: stmt.name, type: stmt.type, value: lowerExpr(stmt.value), span: stmt.span }
+
     case 'expr':
       return { kind: 'expr', expr: lowerExpr(stmt.expr), span: stmt.span }
 
@@ -142,6 +155,27 @@ function lowerStmt(stmt: Stmt): HIRStmt | HIRStmt[] {
     case 'continue':
       return { kind: 'continue', span: stmt.span }
 
+    case 'break_label':
+      return { kind: 'break_label', label: stmt.label, span: stmt.span }
+
+    case 'continue_label':
+      return { kind: 'continue_label', label: stmt.label, span: stmt.span }
+
+    case 'labeled_loop': {
+      // Lower the body — for desugared loops (for_each, for_range, etc.) this may return
+      // an array of [init..., while_stmt]. The label should attach to the while stmt only;
+      // any init stmts come before as plain statements.
+      const lowered = lowerStmt(stmt.body)
+      if (Array.isArray(lowered)) {
+        // Multiple stmts: init stmts + while (last element)
+        const inits = lowered.slice(0, -1)
+        const loopStmt = lowered[lowered.length - 1]
+        const labeled: HIRStmt = { kind: 'labeled_loop', label: stmt.label, body: loopStmt, span: stmt.span }
+        return [...inits, labeled]
+      }
+      return { kind: 'labeled_loop', label: stmt.label, body: lowered, span: stmt.span }
+    }
+
     case 'if':
       return {
         kind: 'if',
@@ -411,6 +445,71 @@ function lowerStmt(stmt: Stmt): HIRStmt | HIRStmt[] {
         span: stmt.span,
       }
 
+    // --- Desugaring: do_while → body + while(cond) { body } ---
+    // Emits the body once unconditionally, then a while loop:
+    //   <body>
+    //   while (cond) { <body> }
+    case 'do_while': {
+      const firstBody = lowerBlock(stmt.body)
+      const loopBody = lowerBlock(stmt.body)
+      const whileStmt: HIRStmt = {
+        kind: 'while',
+        cond: lowerExpr(stmt.cond),
+        body: loopBody,
+        span: stmt.span,
+      }
+      return [...firstBody, whileStmt]
+    }
+
+    // --- Desugaring: repeat N → let __repeat_i = 0; while(__repeat_i < N) { body; __repeat_i = __repeat_i + 1 } ---
+    case 'repeat': {
+      const id = repeatCounter++
+      const idxName = `__repeat_i_${id}`
+      const initStmt: HIRStmt = {
+        kind: 'let',
+        name: idxName,
+        type: { kind: 'named', name: 'int' },
+        init: { kind: 'int_lit', value: 0 },
+        span: stmt.span,
+      }
+      const body = lowerBlock(stmt.body)
+      const step: HIRStmt[] = [{
+        kind: 'expr',
+        expr: {
+          kind: 'assign',
+          target: idxName,
+          value: {
+            kind: 'binary',
+            op: '+',
+            left: { kind: 'ident', name: idxName },
+            right: { kind: 'int_lit', value: 1 },
+          },
+        },
+      }]
+      const whileStmt: HIRStmt = {
+        kind: 'while',
+        cond: {
+          kind: 'binary',
+          op: '<',
+          left: { kind: 'ident', name: idxName },
+          right: { kind: 'int_lit', value: stmt.count },
+        },
+        body,
+        step,
+        span: stmt.span,
+      }
+      return [initStmt, whileStmt]
+    }
+
+    case 'while_let_some':
+      return {
+        kind: 'while_let_some',
+        binding: stmt.binding,
+        init: lowerExpr(stmt.init),
+        body: lowerBlock(stmt.body),
+        span: stmt.span,
+      }
+
     default: {
       const _exhaustive: never = stmt
       throw new Error(`Unknown statement kind: ${(_exhaustive as any).kind}`)
@@ -434,6 +533,9 @@ function lowerExecuteSubcommand(sub: ExecuteSubcommand): HIRExecuteSubcommand {
 /** Counter to generate unique variable names for for_each desugaring */
 let forEachCounter = 0
 
+/** Counter to generate unique variable names for repeat desugaring */
+let repeatCounter = 0
+
 /** Map compound assignment operator to its base binary op */
 const COMPOUND_TO_BINOP: Record<string, string> = {
   '+=': '+',
@@ -484,8 +586,14 @@ function lowerExpr(expr: Expr): HIRExpr {
         span: expr.span,
       }
 
-    case 'f_string':
-      return { kind: 'f_string', parts: expr.parts, span: expr.span }
+    case 'f_string': {
+      const hirParts: HIRFStringPart[] = expr.parts.map(part =>
+        part.kind === 'text'
+          ? { kind: 'text' as const, value: part.value }
+          : { kind: 'expr' as const, expr: lowerExpr(part.expr) }
+      )
+      return { kind: 'f_string', parts: hirParts, span: expr.span }
+    }
 
     // Binary ops — && and || preserved as-is (short-circuit → control flow in MIR)
     case 'binary':
@@ -603,6 +711,15 @@ function lowerExpr(expr: Expr): HIRExpr {
     case 'path_expr':
       return { kind: 'path_expr', enumName: expr.enumName, variant: expr.variant, span: expr.span }
 
+    case 'enum_construct':
+      return {
+        kind: 'enum_construct',
+        enumName: expr.enumName,
+        variant: expr.variant,
+        args: expr.args.map(a => ({ name: a.name, value: lowerExpr(a.value) })),
+        span: expr.span,
+      }
+
     case 'tuple_lit':
       return { kind: 'tuple_lit', elements: expr.elements.map(lowerExpr), span: expr.span }
 
@@ -612,6 +729,9 @@ function lowerExpr(expr: Expr): HIRExpr {
     case 'none_lit':
       return { kind: 'none_lit', span: expr.span }
 
+    case 'unwrap_or':
+      return { kind: 'unwrap_or', opt: lowerExpr(expr.opt), default_: lowerExpr(expr.default_), span: expr.span }
+
     case 'type_cast':
       return { kind: 'type_cast', expr: lowerExpr(expr.expr), targetType: expr.targetType, span: expr.span }
 

package/src/hir/monomorphize.ts

@@ -277,10 +277,25 @@ class Monomorphizer {
           then: this.rewriteBlock(stmt.then, ctx),
           else_: stmt.else_ ? this.rewriteBlock(stmt.else_, ctx) : undefined,
         }
+      case 'while_let_some':
+        return {
+          ...stmt,
+          init: this.rewriteExpr(stmt.init, ctx),
+          body: this.rewriteBlock(stmt.body, ctx),
+        }
+      case 'const_decl':
+        return { ...stmt, value: this.rewriteExpr(stmt.value, ctx) }
       case 'break':
       case 'continue':
       case 'raw':
         return stmt
+      case 'break_label':
+      case 'continue_label':
+        return stmt
+      case 'labeled_loop': {
+        const body = this.rewriteStmt(stmt.body, ctx)
+        return { ...stmt, body }
+      }
     }
   }
 
@@ -338,12 +353,19 @@ class Monomorphizer {
       case 'str_interp':
         return { ...expr, parts: expr.parts.map(p => typeof p === 'string' ? p : this.rewriteExpr(p, ctx)) }
       case 'f_string':
-        // FStringPart uses AST Expr (not HIRExpr) — pass through without rewriting
-        return expr
+        // HIRFStringPart uses HIRExpr — rewrite expr parts
+        return {
+          ...expr,
+          parts: expr.parts.map(p =>
+            p.kind === 'text' ? p : { kind: 'expr' as const, expr: this.rewriteExpr(p.expr, ctx) }
+          ),
+        }
       case 'some_lit':
         return { ...expr, value: this.rewriteExpr(expr.value, ctx) }
       case 'none_lit':
         return expr
+      case 'unwrap_or':
+        return { ...expr, opt: this.rewriteExpr(expr.opt, ctx), default_: this.rewriteExpr(expr.default_, ctx) }
       // Literals / terminals — pass through unchanged
       default:
         return expr