@xnoxs/flux-lang 3.1.1

package/src/codegen.js

@@ -0,0 +1,785 @@
+'use strict';
+
+// ── Format spec extractor for string interpolation {n:.2f} ───────────────────
+function extractFormatSpec(raw) {
+  const ci = raw.lastIndexOf(':');
+  if (ci < 1) return null;
+  const spec = raw.slice(ci + 1).trim();
+  // Must contain at least one format-type char: .  <  >  ^  ,  or letter format
+  if (spec.length > 0 && /[.<>^,dbeEfFgGoOxXs%bcn]/.test(spec) &&
+      /^([.<>^0\-+ #,]*[0-9]*\.?[0-9]*[dbeEfFgGoOxXs%bcn]?[,]?)$/.test(spec)) {
+    return { expr: raw.slice(0, ci).trim(), fmt: spec };
+  }
+  return null;
+}
+
+// ── Runtime _fmt helper (injected when format specs are detected) ─────────────
+const FMT_HELPER = `
+function _fmt(v, s) {
+  if (s === ',') return (+v).toLocaleString();
+  if (s === '%') return ((+v)*100).toFixed(0)+'%';
+  var m = s.match(/^([0-9,]*)?\\.([0-9]+)([fdgGeEb%x])$/);
+  if (m) {
+    var d=+m[2], t=m[3], comma=s[0]===',';
+    if (t==='f'||t==='d') return comma ? (+v).toLocaleString(void 0,{minimumFractionDigits:d,maximumFractionDigits:d}) : (+v).toFixed(d);
+    if (t==='e'||t==='E') return (+v).toExponential(d);
+    if (t==='%') return ((+v)*100).toFixed(d)+'%';
+    if (t==='b') return Math.round(+v).toString(2);
+    if (t==='x') return Math.round(+v).toString(16);
+  }
+  var m2 = s.match(/^([0-9]*)d$/); if (m2) return Math.round(+v).toString();
+  return String(v);
+}`;
+
+class CodeGenError extends Error {
+  constructor(msg, node) {
+    super(`${msg}${node ? ` [${node.type}]` : ''}`);
+    this.name = 'CodeGenError';
+  }
+}
+
+// ── Class registry (pre-pass) ─────────────────────────────────────────────────
+function buildClassRegistry(ast) {
+  const reg = {};
+  for (const node of ast.body) {
+    const n = node.type === 'ExportDecl' ? node.decl : node;
+    if (n.type === 'ClassDecl')
+      reg[n.name] = { fields: n.fields, superClass: n.superClass };
+  }
+  return reg;
+}
+
+function getAllFields(name, reg, visited = new Set()) {
+  if (!name || !reg[name] || visited.has(name)) return [];
+  visited.add(name);
+  const parent = getAllFields(reg[name].superClass, reg, visited);
+  return [...parent, ...reg[name].fields];
+}
+
+// ── Code Generator ────────────────────────────────────────────────────────────
+class CodeGenerator {
+  constructor(opts = {}) {
+    this.ind        = opts.indent || '    ';
+    this.level      = 0;
+    this.lines      = [];
+    this.clsReg     = {};
+    this.smBuilder  = opts.smBuilder || null;
+    this._needsFmt  = false;
+    this._loopDepth = 0; // track for/while nesting — match arms must not `return` inside loops
+  }
+
+  i()        { return this.ind.repeat(this.level); }
+  emit(s)    { this.lines.push(this.i() + s); }
+  emitRaw(s) { this.lines.push(s); }
+  blank()    { this.lines.push(''); }
+
+  in()   { this.level++; }
+  out()  { this.level = Math.max(0, this.level - 1); }
+
+  // Record a source-map mapping for the next line to be emitted.
+  // srcLoc: token-style { line (1-based), col (1-based) }
+  _map(srcLoc) {
+    if (!this.smBuilder || !srcLoc) return;
+    const genLine = this.lines.length;               // 0-based line about to be pushed
+    const genCol  = this.ind.repeat(this.level).length;
+    const srcLine = (srcLoc.line || 1) - 1;          // convert to 0-based
+    const srcCol  = (srcLoc.col  || 1) - 1;
+    this.smBuilder.addMapping(genLine, genCol, srcLine, srcCol);
+  }
+
+  generate(ast) {
+    this.clsReg    = buildClassRegistry(ast);
+    this.lines     = [];
+    this.level     = 0;
+    this._needsFmt = false;
+
+    this.emit('// Generated by Flux Transpiler v3.1.0');
+    this.emit('"use strict";');
+    this.blank();
+
+    for (const node of ast.body) this.genStmt(node);
+
+    // Inject _fmt helper if any format specs were used
+    if (this._needsFmt) {
+      this.lines.splice(2, 0, FMT_HELPER);
+    }
+
+    return { code: this.lines.join('\n'), smBuilder: this.smBuilder };
+  }
+
+  // ── Statements ─────────────────────────────────────────────────
+  genStmt(node) {
+    // Record source location for every statement (function, var, if, etc.)
+    this._map(node.loc);
+    switch (node.type) {
+      case 'VarDecl':        return this.genVar(node);
+      case 'DestructureDecl':return this.genDestructure(node);
+      case 'FnDecl':         return this.genFn(node);
+      case 'ClassDecl':      return this.genClass(node);
+      case 'IfStmt':         return this.genIf(node);
+      case 'ForInStmt':      return this.genFor(node);
+      case 'WhileStmt':      return this.genWhile(node);
+      case 'MatchStmt':      return this.genMatch(node);
+      case 'ReturnStmt':     return this.genReturn(node);
+      case 'TryCatchStmt':   return this.genTryCatch(node);
+      case 'ThrowStmt':      return this.genThrow(node);
+      case 'DoWhileStmt':    return this.genDoWhile(node);
+      case 'BreakStmt':      return this.emit(node.label ? `break ${node.label};` : 'break;');
+      case 'ContinueStmt':   return this.emit(node.label ? `continue ${node.label};` : 'continue;');
+      case 'LabeledStmt':    return this.genLabeled(node);
+      case 'ImportDecl':     return this.genImport(node);
+      case 'ExportDecl':     return this.genExport(node);
+      case 'TypeDecl':       return this.genTypeDecl(node);
+      case 'InterfaceDecl':  return this.genInterfaceDecl(node);
+      case 'EnumDecl':       return this.genEnumDecl(node);
+      case 'ExprStmt':       return this.emit(this.genExpr(node.expr) + ';');
+      default:
+        throw new CodeGenError(`Unknown statement: ${node.type}`, node);
+    }
+  }
+
+  // ── var / val ───────────────────────────────────────────────────
+  genVar(node) {
+    const kw   = node.kind === 'val' ? 'const' : 'let';
+    const init = node.init ? ` = ${this.genExpr(node.init)}` : '';
+    this.emit(`${kw} ${node.name}${init};`);
+  }
+
+  // ── destructuring ───────────────────────────────────────────────
+  genDestructure(node) {
+    const kw   = node.kind === 'val' ? 'const' : 'let';
+    const init = this.genExpr(node.init);
+
+    if (node.patternType === 'object') {
+      const props = node.pattern.map(p => {
+        if (p.rest) return `...${p.key}`;
+        let s = p.alias !== p.key ? `${p.key}: ${p.alias}` : p.key;
+        if (p.defaultVal) s += ` = ${this.genExpr(p.defaultVal)}`;
+        return s;
+      }).join(', ');
+      this.emit(`${kw} { ${props} } = ${init};`);
+    } else {
+      const items = node.pattern.map(p => {
+        if (!p) return '';
+        if (p.rest) return `...${p.name}`;
+        let s = p.name;
+        if (p.defaultVal) s += ` = ${this.genExpr(p.defaultVal)}`;
+        return s;
+      }).join(', ');
+      this.emit(`${kw} [${items}] = ${init};`);
+    }
+  }
+
+  // ── fn ──────────────────────────────────────────────────────────
+  genFn(node, prefix = '') {
+    const asyncKw = node.async ? 'async ' : '';
+    const name    = node.name || '';
+    const params  = node.params.map(p =>
+      p.rest ? `...${p.name}` :
+      p.defaultVal ? `${p.name} = ${this.genExpr(p.defaultVal)}` :
+      p.name
+    ).join(', ');
+
+    if (node.inline) {
+      this.emit(`${prefix}${asyncKw}function ${name}(${params}) { return ${this.genExpr(node.body)}; }`);
+    } else {
+      this.emit(`${prefix}${asyncKw}function ${name}(${params}) {`);
+      this.in();
+      for (const s of node.body) this.genStmt(s);
+      this.out();
+      this.emit('}');
+    }
+  }
+
+  // ── class ──────────────────────────────────────────────────────
+  genClass(node) {
+    const ext = node.superClass ? ` extends ${node.superClass}` : '';
+    this.emit(`class ${node.name}${ext} {`);
+    this.in();
+
+    // Constructor
+    const allFields = getAllFields(node.name, this.clsReg);
+    if (allFields.length > 0) {
+      const params = allFields.map(f => f.name).join(', ');
+      this.emit(`constructor(${params}) {`);
+      this.in();
+
+      // super(...parentFields) if extending
+      if (node.superClass && this.clsReg[node.superClass]) {
+        const parentFields = getAllFields(node.superClass, this.clsReg);
+        if (parentFields.length > 0)
+          this.emit(`super(${parentFields.map(f => f.name).join(', ')});`);
+      }
+
+      // Assign own fields only
+      for (const f of node.fields) this.emit(`this.${f.name} = ${f.name};`);
+      this.out();
+      this.emit('}');
+      this.blank();
+    }
+
+    // Methods
+    for (const m of node.methods) {
+      const asyncKw   = m.async ? 'async ' : '';
+      const staticKw  = (m.modifiers && m.modifiers.has('static')) ? 'static ' : '';
+      const getsetKw  = m.getset ? `${m.getset} ` : '';
+      const params    = m.params.map(p =>
+        p.rest ? `...${p.name}` :
+        p.defaultVal ? `${p.name} = ${this.genExpr(p.defaultVal)}` :
+        p.name
+      ).join(', ');
+      if (m.inline) {
+        this.emit(`${staticKw}${asyncKw}${getsetKw}${m.name}(${params}) { return ${this.genExpr(m.body)}; }`);
+      } else {
+        this.emit(`${staticKw}${asyncKw}${getsetKw}${m.name}(${params}) {`);
+        this.in();
+        for (const s of m.body) this.genStmt(s);
+        this.out();
+        this.emit('}');
+      }
+      this.blank();
+    }
+
+    this.out();
+    this.emit('}');
+    this.blank();
+  }
+
+  // ── if / else if / else ─────────────────────────────────────────
+  genIf(node) {
+    this.emit(`if (${this.genExpr(node.cond)}) {`);
+    this.in(); node.then.forEach(s => this.genStmt(s)); this.out();
+    this.emit('}');
+
+    for (const ei of node.elseifs) {
+      this.emitRaw(this.i() + `else if (${this.genExpr(ei.cond)}) {`);
+      this.in(); ei.body.forEach(s => this.genStmt(s)); this.out();
+      this.emit('}');
+    }
+
+    if (node.else_) {
+      this.emitRaw(this.i() + 'else {');
+      this.in(); node.else_.forEach(s => this.genStmt(s)); this.out();
+      this.emit('}');
+    }
+  }
+
+  // ── for x in iter / for i in 0..10 / for [a,b] in arr ──────────
+  genFor(node) {
+    const iter = node.iter;
+    const label = node.label ? `${node.label}: ` : '';
+
+    if (iter.type === 'RangeExpr') {
+      const s = this.genExpr(iter.start);
+      const e = this.genExpr(iter.end);
+      this.emit(`${label}for (let ${node.var} = ${s}; ${node.var} < ${e}; ${node.var}++) {`);
+    } else if (node.isAwait) {
+      this.emit(`${label}for await (const ${node.var} of ${this.genExpr(iter)}) {`);
+    } else {
+      this.emit(`${label}for (const ${node.var} of ${this.genExpr(iter)}) {`);
+    }
+    this._loopDepth++;
+    this.in();
+    // Destructuring in loop var: for [a, b] in arr
+    if (node.varPattern) {
+      const p = node.varPattern;
+      if (p.type === 'array') {
+        const names = p.names.map(n => n.rest ? `...${n.name}` : n.name).join(', ');
+        this.emit(`const [${names}] = ${node.var};`);
+      }
+    }
+    node.body.forEach(s => this.genStmt(s));
+    this.out();
+    this._loopDepth--;
+    this.emit('}');
+  }
+
+  // ── labeled statement ────────────────────────────────────────────
+  genLabeled(node) {
+    // Inject label onto the inner loop/while statement
+    node.body.label = node.label;
+    this.genStmt(node.body);
+  }
+
+  // ── while ───────────────────────────────────────────────────────
+  genWhile(node) {
+    const label = node.label ? `${node.label}: ` : '';
+    this.emit(`${label}while (${this.genExpr(node.cond)}) {`);
+    this._loopDepth++;
+    this.in(); node.body.forEach(s => this.genStmt(s)); this.out();
+    this._loopDepth--;
+    this.emit('}');
+  }
+
+  // ── match / when ────────────────────────────────────────────────
+  genMatch(node) {
+    const subj = this.genExpr(node.subject);
+    const arms = node.arms;
+
+    let hasOpenIf = false; // tracks whether an `if` has been emitted yet
+
+    arms.forEach((arm, i) => {
+      const pat = arm.pattern;
+      let cond     = null;
+      let bindings = []; // const declarations to inject into arm body
+
+      if (pat.type === 'WildcardPat') {
+        cond = null;
+      } else if (pat.type === 'RangePat') {
+        const lo = this.genExpr(pat.start);
+        const hi = this.genExpr(pat.end);
+        cond = `${subj} >= ${lo} && ${subj} <= ${hi}`;
+      } else if (pat.type === 'VariantPat') {
+        // ADT variant: Ok(v), Err(msg), Some(n), None (no bindings)
+        cond     = `${subj}?.__type === "${pat.variant}"`;
+        bindings = pat.bindings.map((b, idx) => `const ${b} = ${subj}.__args[${idx}];`);
+      } else {
+        // LiteralPat — uppercase identifier may be a no-arg ADT constant (None, Empty…)
+        const patExpr = this.genExpr(pat.value);
+        if (pat.value.type === 'Identifier' && /^[A-Z]/.test(pat.value.name)) {
+          cond = `(${subj} === ${patExpr} || ${subj}?.__type === "${pat.value.name}")`;
+        } else {
+          cond = `${subj} === ${patExpr}`;
+        }
+      }
+
+      // Apply guard: when Pattern if guardExpr
+      if (arm.guard) {
+        const guardSrc = this.genExpr(arm.guard);
+        if (bindings.length > 0) {
+          // Guard may reference bound vars — use an IIFE so bindings are in scope
+          const iife = `(function(){ ${bindings.map(b => b.replace('const ', 'var ')).join(' ')} return (${guardSrc}); }())`;
+          cond = cond ? `(${cond}) && ${iife}` : iife;
+        } else {
+          cond = cond ? `(${cond}) && (${guardSrc})` : guardSrc;
+        }
+      }
+
+      // FIX: track whether we've emitted an `if` yet so that a wildcard
+      // arm appearing first doesn't produce a bare `else {` (invalid JS).
+      if (!hasOpenIf && cond) {
+        this.emit(`if (${cond}) {`);
+        hasOpenIf = true;
+      } else if (!hasOpenIf && !cond) {
+        // Wildcard/default as first (or only) arm — emit `if (true)` so the
+        // subsequent `else if` / `else` arms (if any) have a valid anchor.
+        this.emit(`if (true) {`);
+        hasOpenIf = true;
+      } else if (hasOpenIf && cond) {
+        this.emitRaw(this.i() + `else if (${cond}) {`);
+      } else {
+        this.emitRaw(this.i() + 'else {');
+      }
+      this.in();
+      for (const b of bindings) this.emit(b);
+      if (arm.inline) {
+        const exprSrc = this.genExpr(arm.body[0].expr);
+        if (this._loopDepth > 0) {
+          // Inside a for/while — use plain statement (return would escape the loop)
+          this.emit(`${exprSrc};`);
+        } else {
+          // Inside a function body — use return to produce the value
+          this.emit(`return ${exprSrc};`);
+        }
+      } else {
+        arm.body.forEach(s => this.genStmt(s));
+      }
+      this.out();
+      this.emit('}');
+    });
+  }
+
+  // ── interface → erased at runtime (structural typing comment) ──
+  genInterfaceDecl(node) {
+    this.blank();
+    this.emit(`// interface ${node.name}`);
+    this.blank();
+  }
+
+  // ── enum → Object.freeze({ Key: value, ... }) ───────────────────
+  genEnumDecl(node) {
+    this.blank();
+    const pairs = node.members.map(m => {
+      const val = this.genExpr(m.value);
+      return `${m.name}: ${val}`;
+    }).join(', ');
+    this.emit(`const ${node.name} = Object.freeze({ ${pairs} });`);
+    this.blank();
+  }
+
+  // ── type / ADT ──────────────────────────────────────────────────
+  genTypeDecl(node) {
+    this.blank();
+    this.emit(`// ADT type: ${node.name}`);
+    for (const v of node.variants) {
+      if (v.fields.length === 0) {
+        this.emit(`const ${v.name} = Object.freeze({ __type: "${v.name}", __args: [] });`);
+      } else {
+        const params    = v.fields.join(', ');
+        const argsArr   = `[${v.fields.join(', ')}]`;
+        const fieldsObj = v.fields.map(f => `${f}: ${f}`).join(', ');
+        this.emit(`function ${v.name}(${params}) { return Object.freeze({ __type: "${v.name}", __args: ${argsArr}, ${fieldsObj} }); }`);
+      }
+    }
+    this.blank();
+  }
+
+  // ── return ──────────────────────────────────────────────────────
+  genReturn(node) {
+    if (node.value) this.emit(`return ${this.genExpr(node.value)};`);
+    else             this.emit('return;');
+  }
+
+  // ── try / catch / finally ───────────────────────────────────────
+  genTryCatch(node) {
+    this.emit('try {');
+    this.in(); node.tryBody.forEach(s => this.genStmt(s)); this.out();
+    this.emit('}');
+
+    if (node.catchBody) {
+      const param = node.catchParam ? `(${node.catchParam})` : '(_err)';
+      this.emitRaw(this.i() + `catch ${param} {`);
+      this.in(); node.catchBody.forEach(s => this.genStmt(s)); this.out();
+      this.emit('}');
+    }
+
+    if (node.finallyBody) {
+      this.emitRaw(this.i() + 'finally {');
+      this.in(); node.finallyBody.forEach(s => this.genStmt(s)); this.out();
+      this.emit('}');
+    }
+  }
+
+  // ── throw ───────────────────────────────────────────────────────
+  genThrow(node) {
+    this.emit(`throw ${this.genExpr(node.value)};`);
+  }
+
+  // ── do...while ──────────────────────────────────────────────────
+  genDoWhile(node) {
+    this.emit('do {');
+    this.in();
+    for (const s of node.body) this.genStmt(s);
+    this.out();
+    this.emit(`} while (${this.genExpr(node.cond)});`);
+  }
+
+  // ── import ──────────────────────────────────────────────────────
+  genImport(node) {
+    const src = typeof node.source === 'string' ? node.source : String(node.source);
+    if (node.namespaceName) {
+      this.emit(`const ${node.namespaceName} = require("${src}");`);
+    } else if (node.defaultName) {
+      this.emit(`const ${node.defaultName} = require("${src}");`);
+    } else if (node.names.length) {
+      const parts = node.names.map(n => {
+        if (typeof n === 'string') return n;
+        return n.name !== n.alias ? `${n.name}: ${n.alias}` : n.name;
+      }).join(', ');
+      this.emit(`const { ${parts} } = require("${src}");`);
+    }
+  }
+
+  // ── export ──────────────────────────────────────────────────────
+  genExport(node) {
+    if (node.isDefault) {
+      this.emit(`module.exports = ${this.genExpr(node.decl)};`);
+      return;
+    }
+    const decl = node.decl;
+    switch (decl.type) {
+      case 'FnDecl': {
+        const asyncKw = decl.async ? 'async ' : '';
+        const params  = decl.params.map(p =>
+          p.rest ? `...${p.name}` :
+          p.defaultVal ? `${p.name} = ${this.genExpr(p.defaultVal)}` :
+          p.name
+        ).join(', ');
+        if (decl.inline) {
+          this.emit(`${asyncKw}function ${decl.name}(${params}) { return ${this.genExpr(decl.body)}; }`);
+        } else {
+          this.emit(`${asyncKw}function ${decl.name}(${params}) {`);
+          this.in(); decl.body.forEach(s => this.genStmt(s)); this.out();
+          this.emit('}');
+        }
+        this.emit(`module.exports.${decl.name} = ${decl.name};`);
+        break;
+      }
+      case 'ClassDecl':
+        this.genClass(decl);
+        this.emit(`module.exports.${decl.name} = ${decl.name};`);
+        break;
+      case 'TypeDecl':
+        this.genTypeDecl(decl);
+        for (const v of decl.variants) this.emit(`module.exports.${v.name} = ${v.name};`);
+        break;
+      case 'InterfaceDecl':
+        this.genInterfaceDecl(decl);
+        break;
+      case 'EnumDecl':
+        this.genEnumDecl(decl);
+        this.emit(`module.exports.${decl.name} = ${decl.name};`);
+        break;
+      case 'VarDecl': {
+        const kw = decl.kind === 'val' ? 'const' : 'let';
+        this.emit(`${kw} ${decl.name} = ${this.genExpr(decl.init)};`);
+        this.emit(`module.exports.${decl.name} = ${decl.name};`);
+        break;
+      }
+      default:
+        this.genStmt(decl);
+    }
+  }
+
+  // ── Expressions ─────────────────────────────────────────────────
+  genExpr(node) {
+    if (!node) return 'undefined';
+    switch (node.type) {
+      case 'NumberLit':  return String(node.value);
+      case 'BoolLit':    return String(node.value);
+      case 'NullLit':    return 'null';
+      case 'SelfExpr':   return 'this';
+      case 'Identifier': return node.name === 'print' ? 'console.log' : node.name;
+
+      case 'StringLit':
+        return JSON.stringify(node.value);
+
+      case 'RegexLit':
+        return `/${node.value.pattern}/${node.value.flags}`;
+
+      case 'TemplateLit':
+        return this.genTemplate(node.parts);
+
+      case 'BinaryExpr':
+        return `(${this.genExpr(node.left)} ${node.op} ${this.genExpr(node.right)})`;
+
+      case 'UnaryExpr':
+        return `${node.op}${this.genExpr(node.operand)}`;
+
+      case 'UpdateExpr':
+        return node.prefix
+          ? `${node.op}${this.genExpr(node.operand)}`
+          : `${this.genExpr(node.operand)}${node.op}`;
+
+      case 'TernaryExpr':
+        return `(${this.genExpr(node.cond)} ? ${this.genExpr(node.then)} : ${this.genExpr(node.else_)})`;
+
+      case 'AssignExpr':
+        return `${this.genExpr(node.target)} ${node.op} ${this.genExpr(node.value)}`;
+
+      case 'AwaitExpr':
+        return `await ${this.genExpr(node.operand)}`;
+
+      case 'TypeofExpr':
+        return `typeof ${this.genExpr(node.operand)}`;
+
+      case 'SpreadExpr':
+        return `...${this.genExpr(node.expr)}`;
+
+      case 'CallExpr': {
+        const callee = this.genExpr(node.callee);
+        const args   = node.args.map(a => this.genExpr(a)).join(', ');
+        return `${callee}(${args})`;
+      }
+
+      case 'MemberExpr': {
+        const objSrc = this.genExpr(node.obj);
+        // Wrap NumberLit in parens: (42).toString() not 42.toString()
+        const wrappedObj = node.obj.type === 'NumberLit' ? `(${objSrc})` : objSrc;
+        return `${wrappedObj}.${node.prop}`;
+      }
+
+      case 'OptMemberExpr':
+        return `${this.genExpr(node.obj)}?.${node.prop}`;
+
+      case 'OptIndexExpr':
+        return `${this.genExpr(node.obj)}?.[${this.genExpr(node.idx)}]`;
+
+      case 'OptCallExpr': {
+        const args = node.args.map(a => this.genExpr(a)).join(', ');
+        return `${this.genExpr(node.callee)}?.(${args})`;
+      }
+
+      case 'IndexExpr':
+        return `${this.genExpr(node.obj)}[${this.genExpr(node.idx)}]`;
+
+      case 'NewExpr': {
+        const args = node.args.map(a => this.genExpr(a)).join(', ');
+        return `new ${node.callee}(${args})`;
+      }
+
+      case 'LambdaExpr': {
+        const params = node.params.map(p =>
+          p.rest ? `...${p.name}` : p.name
+        ).join(', ');
+        if (node.block) {
+          // Multiline block body: x ->\n    stmts
+          const saved = this.lines.length;
+          const savedLevel = this.level;
+          this.emit(`(${params}) => {`);
+          this.in();
+          for (const s of node.body) this.genStmt(s);
+          this.out();
+          this.emit('}');
+          const block = this.lines.splice(saved).map(l => l.trimStart()).join(' ');
+          this.level = savedLevel;
+          return block;
+        }
+        return `(${params}) => ${this.genExpr(node.body)}`;
+      }
+
+      case 'FnDecl': {
+        // Anonymous function expression
+        const asyncKw = node.async ? 'async ' : '';
+        const params  = node.params.map(p =>
+          p.rest ? `...${p.name}` :
+          p.defaultVal ? `${p.name} = ${this.genExpr(p.defaultVal)}` :
+          p.name
+        ).join(', ');
+        if (node.inline) {
+          return `${asyncKw}function(${params}) { return ${this.genExpr(node.body)}; }`;
+        } else {
+          // Multi-line anonymous fn — emit as IIFE-like block; wrap in parens
+          const saved = this.lines.length;
+          const savedLevel = this.level;
+          this.emit(`${asyncKw}function(${params}) {`);
+          this.in();
+          for (const s of node.body) this.genStmt(s);
+          this.out();
+          this.emit('}');
+          // Pull out the generated lines and return as string
+          const block = this.lines.splice(saved).map(l => l.trimStart()).join(' ');
+          this.level = savedLevel;
+          return block;
+        }
+      }
+
+      case 'MatchStmt': {
+        // match used as an expression — wrap the if/else chain in an IIFE so
+        // it yields a value.  Temporarily zero out _loopDepth so that inline
+        // arms produce `return expr;` even when the match is nested inside a
+        // for/while loop.
+        const saved          = this.lines.length;
+        const savedLevel     = this.level;
+        const savedLoopDepth = this._loopDepth;
+        this._loopDepth      = 0;
+        this.emit('(() => {');
+        this.in();
+        this.genMatch(node);
+        this.out();
+        this.emit('})()');
+        this._loopDepth = savedLoopDepth;
+        const block = this.lines.splice(saved).map(l => l.trimStart()).join(' ');
+        this.level = savedLevel;
+        return block;
+      }
+
+      case 'ArrayExpr':
+        return `[${node.items.map(i => this.genExpr(i)).join(', ')}]`;
+
+      case 'ObjectExpr': {
+        const pairs = node.pairs.map(p => {
+          if (p.spread) return `...${this.genExpr(p.value)}`;
+          // Computed key: { [expr]: value }
+          if (p.computed) return `[${this.genExpr(p.keyExpr)}]: ${this.genExpr(p.value)}`;
+          // Auto-quote keys that aren't valid JS identifiers (e.g. "Content-Type")
+          const isIdent = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(p.key);
+          const keyStr  = isIdent ? p.key : `"${p.key}"`;
+          // Shorthand detection: { name: name } → { name }  (only for plain identifiers)
+          if (isIdent && p.value && p.value.type === 'Identifier' && p.value.name === p.key)
+            return p.key;
+          return `${keyStr}: ${this.genExpr(p.value)}`;
+        }).join(', ');
+        return `{ ${pairs} }`;
+      }
+
+      case 'RangeExpr':
+        // When used standalone (not in for-in), generate an array
+        return `Array.from({ length: ${this.genExpr(node.end)} - ${this.genExpr(node.start)} }, (_, i) => i + ${this.genExpr(node.start)})`;
+
+      case 'PipeExpr':
+        return this.genPipe(node);
+
+      // ── Type system expressions (compile-time only, runtime pass-through) ──
+      case 'CastExpr':
+        // expr as Type  →  just the expr at runtime
+        return this.genExpr(node.expr);
+
+      case 'AsConstExpr':
+        // expr as const  →  Object.freeze(expr)
+        return `Object.freeze(${this.genExpr(node.expr)})`;
+
+      case 'SatisfiesExpr':
+        // expr satisfies Type  →  just the expr at runtime
+        return this.genExpr(node.expr);
+
+      case 'IsExpr':
+        // expr is Type  →  just the expr at runtime (used as a type guard result)
+        return this.genExpr(node.expr);
+
+      case 'NonNullExpr':
+        // expr!  →  just the expr at runtime (non-null assertion)
+        return this.genExpr(node.expr);
+
+      default:
+        throw new CodeGenError(`Unknown expression: ${node.type}`, node);
+    }
+  }
+
+  // ── Template literal: "Hello, {name}!" ──────────────────────────
+  // Each {expr} part is raw Flux source — parse + compile it.
+  // Supports format specs: {price:.2f}  {n:,}  {pct:.1%}
+  genTemplate(parts) {
+    const { Lexer }  = require('./lexer');
+    const { Parser } = require('./parser');
+
+    let result = '`';
+    for (const p of parts) {
+      if (p.type === 'text') {
+        result += p.value.replace(/`/g, '\\`').replace(/\$/g, '\\$');
+      } else {
+        // Check for format spec: {value:.2f} or {n:,}
+        const fmtInfo = extractFormatSpec(p.value);
+        const exprSrc = fmtInfo ? fmtInfo.expr : p.value;
+        const fmt     = fmtInfo ? fmtInfo.fmt  : null;
+
+        try {
+          const tokens = new Lexer(exprSrc).tokenize();
+          const expr   = new Parser(tokens).parseExpr();
+          const gen    = this.genExpr(expr);
+          if (fmt) {
+            this._needsFmt = true;
+            result += `\${_fmt(${gen}, ${JSON.stringify(fmt)})}`;
+          } else {
+            result += `\${${gen}}`;
+          }
+        } catch (_) {
+          result += `\${${p.value}}`;
+        }
+      }
+    }
+    result += '`';
+    return result;
+  }
+
+  // ── Pipe: a |> f  →  f(a)
+  //         a |> f(b, c)  →  f(a, b, c) ─────────────────────────
+  genPipe(node) {
+    const left = this.genExpr(node.left);
+    const right = node.right;
+
+    if (right.type === 'Identifier') {
+      const fn = this.genExpr(right);
+      return `${fn}(${left})`;
+    }
+    if (right.type === 'CallExpr') {
+      const fn   = this.genExpr(right.callee);
+      const rest = right.args.map(a => this.genExpr(a)).join(', ');
+      return rest ? `${fn}(${left}, ${rest})` : `${fn}(${left})`;
+    }
+    // Lambda / other expression: treat as call
+    return `(${this.genExpr(right)})(${left})`;
+  }
+}
+
+module.exports = { CodeGenerator, CodeGenError };