@barefootjs/jsx 0.6.0 → 0.6.1

package/src/__tests__/expression-parser.test.ts

@@ -1,6 +1,6 @@
 import { describe, test, expect } from 'bun:test'
 import ts from 'typescript'
-import { parseExpression, isSupported, exprToString, parseBlockBody } from '../expression-parser'
+import { parseExpression, isSupported, exprToString, stringifyParsedExpr, parseBlockBody } from '../expression-parser'
 import { collectAllTypeRanges, reconstructWithoutTypes } from '../strip-types'
 
 describe('expression-parser', () => {
@@ -1512,3 +1512,111 @@ describe('expression-parser — array-method full-arity lowering (#1448)', () =>
     })
   }
 })
+
+describe('expression-parser — .flat(depth?) lowering (#1448 Tier C)', () => {
+  // Depth literals normalise into a structured `flatDepth` at parse time.
+  const depths: Array<[string, string, number | 'infinity']> = [
+    ['.flat() → depth 1', 'arr.flat()', 1],
+    ['.flat(2) → depth 2', 'arr.flat(2)', 2],
+    ['.flat(Infinity) → "infinity"', 'arr.flat(Infinity)', 'infinity'],
+    ['.flat(0) → depth 0 (shallow copy)', 'arr.flat(0)', 0],
+    ['.flat(-1) → normalised to 0 (JS clamps)', 'arr.flat(-1)', 0],
+    ['.flat(1.9) → truncated to 1', 'arr.flat(1.9)', 1],
+  ]
+  for (const [label, expr, expected] of depths) {
+    test(label, () => {
+      const result = parseExpression(expr)
+      expect(result.kind).toBe('array-method')
+      if (result.kind === 'array-method' && result.method === 'flat') {
+        expect(result.flatDepth).toBe(expected)
+      } else {
+        throw new Error(`expected a flat array-method, got ${result.kind}`)
+      }
+    })
+  }
+
+  test('non-literal depth refuses (must be resolvable at template time)', () => {
+    const result = parseExpression('arr.flat(n)')
+    expect(result.kind).toBe('unsupported')
+    if (result.kind === 'unsupported') {
+      // Wrong remedy `@client` must not be suggested (doesn't work in
+      // attribute / condition position).
+      expect(result.reason).not.toContain('@client')
+      expect(result.reason).toContain('literal')
+    }
+  })
+
+  // exprToString (diagnostics / debug output) must preserve the normalised
+  // depth, not collapse every form to `.flat()`.
+  test('exprToString round-trips the normalised depth', () => {
+    expect(exprToString(parseExpression('arr.flat()'))).toBe('arr.flat()')
+    expect(exprToString(parseExpression('arr.flat(2)'))).toBe('arr.flat(2)')
+    expect(exprToString(parseExpression('arr.flat(Infinity)'))).toBe('arr.flat(Infinity)')
+    expect(exprToString(parseExpression('arr.flat(0)'))).toBe('arr.flat(0)')
+  })
+})
+
+describe('expression-parser — .flatMap(fn) projection (#1448 Tier C)', () => {
+  // Accepted catalogue: self, single field, and array-literal tuples of
+  // self / field leaves.
+  type Proj = { kind: 'self' } | { kind: 'field'; field: string } | { kind: 'tuple'; elements: unknown[] }
+  const accepted: Array<[string, string, Proj]> = [
+    ['self (i => i)', 'arr.flatMap(i => i)', { kind: 'self' }],
+    ['field (i => i.tags)', 'arr.flatMap(i => i.tags)', { kind: 'field', field: 'tags' }],
+    ['single-return block body', 'arr.flatMap(i => { return i.tags })', { kind: 'field', field: 'tags' }],
+    ['tuple of fields', 'arr.flatMap(i => [i.a, i.b])', { kind: 'tuple', elements: [{ kind: 'field', field: 'a' }, { kind: 'field', field: 'b' }] }],
+    ['tuple self + field', 'arr.flatMap(i => [i, i.tags])', { kind: 'tuple', elements: [{ kind: 'self' }, { kind: 'field', field: 'tags' }] }],
+  ]
+  for (const [label, expr, projection] of accepted) {
+    test(`${label} — lowers to a flatMap array-method`, () => {
+      const result = parseExpression(expr)
+      expect(result.kind).toBe('array-method')
+      if (result.kind === 'array-method' && result.method === 'flatMap') {
+        expect(result.flatMapOp.projection).toEqual(projection)
+      } else {
+        throw new Error(`expected a flatMap array-method, got ${result.kind}`)
+      }
+    })
+  }
+
+  // Out of catalogue → refused (BF101 + @client hint).
+  const refused = [
+    ['deep field access', 'arr.flatMap(i => i.a.b)'],
+    ['index/array callback params', 'arr.flatMap((i, idx) => i.tags)'],
+    // Tuple with a non-leaf element (arithmetic / literal / deep access).
+    ['tuple with arithmetic element', 'arr.flatMap(i => [i.a, i.b + 1])'],
+    ['tuple with literal element', 'arr.flatMap(i => [i.a, "x"])'],
+    ['tuple with deep access', 'arr.flatMap(i => [i.a, i.b.c])'],
+    ['tuple with spread', 'arr.flatMap(i => [...i.a])'],
+    // Empty tuple is a degenerate no-op — refused so emitters never
+    // produce a zero-arg `flat_map_tuple` call.
+    ['empty tuple', 'arr.flatMap(i => [])'],
+    // Wrong-arity forms are intercepted by the same arm (not the generic
+    // "flatMap has no template lowering" gate) so the reason stays tailored.
+    ['2-arg flatMap(fn, thisArg)', 'arr.flatMap(i => i.tags, ctx)'],
+  ]
+  for (const [label, expr] of refused) {
+    test(`${label} — refuses`, () => {
+      const result = parseExpression(expr)
+      expect(result.kind).toBe('unsupported')
+      if (result.kind === 'unsupported') {
+        expect(result.reason).toContain('flatMap shape not supported')
+      }
+    })
+  }
+
+  test('exprToString / stringify round-trip the callback', () => {
+    // Scalar projections, plus the array-literal tuple — the round-trip
+    // relies on the callback `raw`, so a regression in raw capture would
+    // surface here for every projection shape.
+    for (const src of [
+      'arr.flatMap(i => i.tags)',
+      'arr.flatMap(t => t)',
+      'arr.flatMap(i => [i.a, i.b])',
+      'arr.flatMap(i => [i, i.tags])',
+    ]) {
+      expect(exprToString(parseExpression(src))).toBe(src)
+      expect(stringifyParsedExpr(parseExpression(src))).toBe(src)
+    }
+  })
+})

package/src/__tests__/foreach-client-only.test.ts

@@ -0,0 +1,80 @@
+/**
+ * `.forEach()` is client-callback-only (#1448 Tier C / Tier D-class).
+ *
+ * `.forEach()` returns `undefined`, so it has no template-position meaning
+ * and is never a lowering target. This pins the two halves of that contract:
+ *
+ *  1. In **template position** the support gate refuses it (the template
+ *     adapters surface this as BF101 via `isSupported`), with a dedicated
+ *     reason that explains the `undefined` return — not the generic
+ *     `/* @client *​/` escape-hatch hint.
+ *  2. Inside an **event handler / `createEffect` callback** it is client JS
+ *     and passes straight through to the emitted runtime untouched — this is
+ *     the only valid use.
+ */
+
+import { describe, test, expect } from 'bun:test'
+import { parseExpression, isSupported } from '../expression-parser'
+import { compileJSX } from '../compiler'
+import { TestAdapter } from '../adapters/test-adapter'
+
+const adapter = new TestAdapter()
+
+describe('.forEach() — template position is refused (#1448)', () => {
+  test('isSupported reports forEach as unsupported', () => {
+    const support = isSupported(parseExpression('items().forEach(t => t.x)'))
+    expect(support.supported).toBe(false)
+    expect(support.level).toBe('L5_UNSUPPORTED')
+  })
+
+  test('refusal reason explains the undefined return and points to the valid uses', () => {
+    const support = isSupported(parseExpression('items().forEach(t => t.x)'))
+    expect(support.supported).toBe(false)
+    if (support.supported) return
+    // Dedicated forEach message that steers to .map(...) / createEffect —
+    // not the generic refusal, which offers the /* @client */ escape hatch.
+    expect(support.reason).toContain('returns undefined')
+    expect(support.reason).toContain('createEffect')
+    expect(support.reason).toContain('.map(')
+    expect(support.reason).not.toContain('/* @client */')
+  })
+
+  test('a bare-identifier receiver is refused too (not just signal getters)', () => {
+    const support = isSupported(parseExpression('list.forEach(x => x)'))
+    expect(support.supported).toBe(false)
+    expect(support.level).toBe('L5_UNSUPPORTED')
+  })
+})
+
+describe('.forEach() — client-callback use passes through (#1448)', () => {
+  // forEach inside an event handler and a createEffect callback is client JS;
+  // it must reach the emitted runtime verbatim with no compile error.
+  const source = `
+    'use client'
+    import { createSignal, createEffect } from '@barefootjs/client'
+
+    export function C() {
+      const [items, setItems] = createSignal<any[]>([])
+      const handle = () => { items().forEach(t => console.log(t)) }
+      createEffect(() => { items().forEach(t => t) })
+      return <button onClick={handle}>go</button>
+    }
+  `
+
+  test('no compile errors for forEach in callbacks', () => {
+    const result = compileJSX(source, 'C.tsx', { adapter })
+    expect(result.errors).toHaveLength(0)
+  })
+
+  test('forEach reaches the emitted client JS verbatim', () => {
+    const result = compileJSX(source, 'C.tsx', { adapter })
+    const client = result.files.find(f => f.path.endsWith('.client.js'))
+    expect(client).toBeDefined()
+    // Target the user's own `items().forEach(...)` calls specifically — a bare
+    // `/forEach/g` count would also catch any `forEach` the client-code
+    // generator emits for loop / hydration infrastructure, making this flaky.
+    // Both the handler call and the createEffect call must survive verbatim.
+    const occurrences = client!.content.match(/items\(\)\.forEach\(/g) ?? []
+    expect(occurrences.length).toBe(2)
+  })
+})

package/src/__tests__/ir-reduce-op.test.ts

@@ -0,0 +1,51 @@
+import { describe, test, expect } from 'bun:test'
+import { analyzeComponent } from '../analyzer'
+import { jsxToIR } from '../jsx-to-ir'
+import { parseExpression } from '../expression-parser'
+
+/**
+ * IR-level verification for `.reduce(fn, init)` (#1448 Tier C). The
+ * parser intercepts the arithmetic-fold catalogue into a structured
+ * `array-method` + `ReduceOp` node — this test pins the source-string
+ * that survives through `jsxToIR` to an `IRExpression`, then re-parses
+ * it to confirm the structured fold shape adapters consume.
+ *
+ * Hydration and template-emit correctness are pinned at the adapter
+ * conformance layer (`reduce-*` fixtures in `packages/adapter-tests/
+ * fixtures/methods/`).
+ */
+describe('reduce(fn, init) IR shape', () => {
+  test('sum over a struct field re-parses to a numeric ReduceOp', () => {
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+
+      export function Total() {
+        const [items] = createSignal<{ duration: number }[]>([])
+        return <div>{items().reduce((sum, t) => sum + t.duration, 0)}</div>
+      }
+    `
+
+    const ctx = analyzeComponent(source, 'Total.tsx')
+    const ir = jsxToIR(ctx)
+
+    expect(ir).not.toBeNull()
+    if (ir!.type !== 'element') return
+    const exprNode = ir!.children.find(c => c.type === 'expression')
+    expect(exprNode?.type).toBe('expression')
+    if (exprNode?.type !== 'expression') return
+
+    // The IR carries the expression as a source string (the same shape
+    // adapters re-parse at emit time). Round-trip it to confirm the
+    // ReduceOp catalogue match survives the analyzer → IR boundary.
+    const parsed = parseExpression(exprNode.expr)
+    expect(parsed.kind).toBe('array-method')
+    if (parsed.kind !== 'array-method') return
+    expect(parsed.method).toBe('reduce')
+    if (parsed.method !== 'reduce') return
+    expect(parsed.reduceOp.op).toBe('+')
+    expect(parsed.reduceOp.key).toEqual({ kind: 'field', field: 'duration' })
+    expect(parsed.reduceOp.type).toBe('numeric')
+    expect(parsed.reduceOp.init).toBe('0')
+  })
+})

package/src/__tests__/reduce-op.test.ts

@@ -0,0 +1,201 @@
+import { describe, test, expect } from 'bun:test'
+import { parseExpression, isSupported, stringifyParsedExpr } from '../expression-parser'
+
+/**
+ * `.reduce(fn, init)` arithmetic-fold catalogue (#1448 Tier C). The
+ * parser intercepts the accepted shapes into a structured `ReduceOp`
+ * (mirroring the `.sort` `SortComparator` precedent) and refuses
+ * everything else to `unsupported` so the template adapters surface
+ * BF101 with the `@client` escape hatch.
+ */
+describe('reduce() arithmetic-fold catalogue', () => {
+  test('numeric sum over a field → field/numeric', () => {
+    const r = parseExpression('items.reduce((sum, t) => sum + t.duration, 0)')
+    expect(r.kind).toBe('array-method')
+    if (r.kind === 'array-method' && r.method === 'reduce') {
+      expect(r.reduceOp.op).toBe('+')
+      expect(r.reduceOp.key).toEqual({ kind: 'field', field: 'duration' })
+      expect(r.reduceOp.type).toBe('numeric')
+      expect(r.reduceOp.init).toBe('0')
+      expect(r.reduceOp.paramAcc).toBe('sum')
+      expect(r.reduceOp.paramItem).toBe('t')
+    }
+    expect(isSupported(r).supported).toBe(true)
+  })
+
+  test('numeric sum over self (primitive array) → self/numeric', () => {
+    const r = parseExpression('nums.reduce((a, b) => a + b, 0)')
+    expect(r.kind).toBe('array-method')
+    if (r.kind === 'array-method' && r.method === 'reduce') {
+      expect(r.reduceOp.op).toBe('+')
+      expect(r.reduceOp.key).toEqual({ kind: 'self' })
+      expect(r.reduceOp.type).toBe('numeric')
+    }
+  })
+
+  test('reduceRight shares the catalogue and preserves the method name', () => {
+    const r = parseExpression("items.reduceRight((acc, x) => acc + x.label, '')")
+    expect(r.kind).toBe('array-method')
+    if (r.kind === 'array-method') {
+      expect(r.method).toBe('reduceRight')
+      if (r.method === 'reduceRight') {
+        expect(r.reduceOp.op).toBe('+')
+        expect(r.reduceOp.key).toEqual({ kind: 'field', field: 'label' })
+        expect(r.reduceOp.type).toBe('string')
+      }
+    }
+  })
+
+  test('reduceRight round-trips with its method name preserved', () => {
+    const r = parseExpression('nums.reduceRight((a, b) => a + b, 0)')
+    expect(stringifyParsedExpr(r)).toBe('nums.reduceRight((a,b) => a + b, 0)')
+  })
+
+  test('product over a field with init 1 → field/numeric/*', () => {
+    const r = parseExpression('items.reduce((acc, x) => acc * x.qty, 1)')
+    expect(r.kind).toBe('array-method')
+    if (r.kind === 'array-method' && r.method === 'reduce') {
+      expect(r.reduceOp.op).toBe('*')
+      expect(r.reduceOp.key).toEqual({ kind: 'field', field: 'qty' })
+      expect(r.reduceOp.type).toBe('numeric')
+      expect(r.reduceOp.init).toBe('1')
+    }
+  })
+
+  test('string init makes + a concatenation fold (init is the decoded value)', () => {
+    const r = parseExpression("items.reduce((acc, x) => acc + x.label, '')")
+    expect(r.kind).toBe('array-method')
+    if (r.kind === 'array-method' && r.method === 'reduce') {
+      expect(r.reduceOp.op).toBe('+')
+      expect(r.reduceOp.type).toBe('string')
+      expect(r.reduceOp.init).toBe('') // decoded contents, not the `''` source
+    }
+  })
+
+  test('non-empty string seed decodes to its contents', () => {
+    const r = parseExpression("items.reduce((acc, x) => acc + x.label, ', ')")
+    expect(r.kind).toBe('array-method')
+    if (r.kind === 'array-method' && r.method === 'reduce') {
+      expect(r.reduceOp.init).toBe(', ')
+    }
+  })
+
+  test('numeric init normalises separators / radix to canonical decimal', () => {
+    // `.text` gives TS's canonical decimal so Go ParseFloat + Perl agree
+    // (#1728 review: raw `1_000` / `0x10` would mis-parse on Go).
+    for (const [src, expected] of [
+      ['1_000', '1000'],
+      ['0x10', '16'],
+      ['1e3', '1000'],
+    ] as const) {
+      const r = parseExpression(`nums.reduce((a, b) => a + b, ${src})`)
+      expect(r.kind).toBe('array-method')
+      if (r.kind === 'array-method' && r.method === 'reduce') {
+        expect(r.reduceOp.init).toBe(expected)
+      }
+    }
+  })
+
+  test('parenthesized numeric init is unwrapped and accepted', () => {
+    for (const [src, expected] of [
+      ['(0)', '0'],
+      ['(-1)', '-1'],
+    ] as const) {
+      const r = parseExpression(`nums.reduce((a, b) => a + b, ${src})`)
+      expect(r.kind).toBe('array-method')
+      if (r.kind === 'array-method' && r.method === 'reduce') {
+        expect(r.reduceOp.init).toBe(expected)
+      }
+    }
+  })
+
+  test('an escape-free seed containing an apostrophe is accepted (decoded contents kept)', () => {
+    // `"a'b"` is escape-free (decoded === raw inner), so it's accepted;
+    // the decoded value carries the apostrophe, which the Mojo emit
+    // single-quote-escapes.
+    const r = parseExpression(`items.reduce((acc, x) => acc + x.l, "a'b")`)
+    expect(r.kind).toBe('array-method')
+    if (r.kind === 'array-method' && r.method === 'reduce') {
+      expect(r.reduceOp.init).toBe("a'b")
+    }
+  })
+
+  test('single-return block body unwraps to the fold expression', () => {
+    const r = parseExpression('items.reduce((sum, t) => { return sum + t.n }, 0)')
+    expect(r.kind).toBe('array-method')
+    if (r.kind === 'array-method' && r.method === 'reduce') {
+      expect(r.reduceOp.key).toEqual({ kind: 'field', field: 'n' })
+    }
+  })
+
+  test('negative numeric init is accepted', () => {
+    const r = parseExpression('nums.reduce((a, b) => a + b, -1)')
+    expect(r.kind).toBe('array-method')
+    if (r.kind === 'array-method' && r.method === 'reduce') {
+      expect(r.reduceOp.init).toBe('-1')
+    }
+  })
+
+  test('round-trips a numeric fold back to valid JS via stringifyParsedExpr', () => {
+    const r = parseExpression('items.reduce((sum, t) => sum + t.duration, 0)')
+    expect(stringifyParsedExpr(r)).toBe('items.reduce((sum,t) => sum + t.duration, 0)')
+  })
+
+  test('round-trips a string fold by re-quoting the decoded seed', () => {
+    const r = parseExpression("items.reduce((a, x) => a + x.l, ', ')")
+    // Decoded seed `, ` re-quoted via JSON.stringify → a valid JS string.
+    expect(stringifyParsedExpr(r)).toBe('items.reduce((a,x) => a + x.l, ", ")')
+  })
+
+  describe('refused shapes → unsupported (BF101)', () => {
+    test('missing initial value', () => {
+      // A no-init reduce isn't intercepted (it needs 2 args); it falls
+      // through to a generic `call` that the UNSUPPORTED_METHODS gate
+      // refuses — JS throws on an empty array here, so a template can't
+      // mirror it cleanly.
+      const r = parseExpression('items.reduce((sum, t) => sum + t.duration)')
+      expect(isSupported(r).supported).toBe(false)
+    })
+
+    test('string concat with * is rejected', () => {
+      const r = parseExpression("items.reduce((acc, x) => acc * x.label, '')")
+      expect(r.kind).toBe('unsupported')
+    })
+
+    test('accumulator on the right operand is rejected', () => {
+      const r = parseExpression('items.reduce((sum, t) => t.duration + sum, 0)')
+      expect(r.kind).toBe('unsupported')
+    })
+
+    test('non-literal init is rejected', () => {
+      const r = parseExpression('items.reduce((sum, t) => sum + t.n, start)')
+      expect(r.kind).toBe('unsupported')
+    })
+
+    test('object-building reducer is rejected', () => {
+      const r = parseExpression('items.reduce((acc, x) => ({ ...acc, [x.id]: x }), {})')
+      expect(r.kind).toBe('unsupported')
+    })
+
+    test('deep field access is rejected', () => {
+      const r = parseExpression('items.reduce((sum, t) => sum + t.a.b, 0)')
+      expect(r.kind).toBe('unsupported')
+    })
+
+    test('string seed carrying an escape is rejected (cross-adapter safety)', () => {
+      // A seed with an escape can't be guaranteed byte-equal across the
+      // Go-template / Perl string embeddings without per-target decoding,
+      // so it refuses to `unsupported` rather than risk divergence.
+      const r = parseExpression("items.reduce((acc, x) => acc + x.l, '\\n')")
+      expect(r.kind).toBe('unsupported')
+    })
+
+    test('reduceRight without an init is refused (like reduce)', () => {
+      // The matching 2-arg form is intercepted; a no-init reduceRight
+      // falls through to a generic call the UNSUPPORTED_METHODS gate
+      // refuses (JS throws on an empty array there).
+      const rr = parseExpression('items.reduceRight((sum, t) => sum + t.n)')
+      expect(isSupported(rr).supported).toBe(false)
+    })
+  })
+})

package/src/adapters/parsed-expr-emitter.ts

@@ -33,7 +33,7 @@
  *     be added in one place.
  */
 
-import type { ParsedExpr, SortComparator, TemplatePart } from '../expression-parser'
+import type { ParsedExpr, SortComparator, ReduceOp, FlatDepth, FlatMapOp, TemplatePart } from '../expression-parser'
 
 export type HigherOrderMethod = 'filter' | 'every' | 'some' | 'find' | 'findIndex' | 'findLast' | 'findLastIndex'
 
@@ -82,6 +82,17 @@ export type ArrayMethod =
  */
 export type SortMethod = 'sort' | 'toSorted'
 
+/**
+ * `reduce` / `reduceRight` are handled by the dedicated `reduceMethod()`
+ * dispatcher arm (#1448 Tier C) for the same reason sort is: they carry
+ * a structured `ReduceOp` (the parsed arithmetic-fold spec) rather than
+ * a `ParsedExpr[]` args list, so folding them into `arrayMethod()` would
+ * force a spec-or-args runtime check at every call site. The method name
+ * is threaded through so adapters can pick the fold direction (left for
+ * `reduce`, right for `reduceRight`).
+ */
+export type ReduceMethod = 'reduce' | 'reduceRight'
+
 export type LiteralType = 'string' | 'number' | 'boolean' | 'null'
 
 /**
@@ -140,6 +151,28 @@ export interface ParsedExprEmitter {
     comparator: SortComparator,
     emit: (e: ParsedExpr) => string,
   ): string
+  reduceMethod(
+    method: ReduceMethod,
+    object: ParsedExpr,
+    reduceOp: ReduceOp,
+    emit: (e: ParsedExpr) => string,
+  ): string
+  // `.flat(depth?)` gets its own dispatcher arm (#1448 Tier C): it carries
+  // a structured `FlatDepth` (the validated literal / `'infinity'`) rather
+  // than a `ParsedExpr[]` args list, same rationale as sort / reduce.
+  flatMethod(
+    object: ParsedExpr,
+    depth: FlatDepth,
+    emit: (e: ParsedExpr) => string,
+  ): string
+  // `.flatMap(fn)` value-returning field projection gets its own arm
+  // (#1448 Tier C): it carries a structured `FlatMapOp` rather than a
+  // `ParsedExpr[]` args list, same rationale as sort / reduce / flat.
+  flatMapMethod(
+    object: ParsedExpr,
+    op: FlatMapOp,
+    emit: (e: ParsedExpr) => string,
+  ): string
   unsupported(raw: string, reason: string): string
 }
 
@@ -183,6 +216,15 @@ export function emitParsedExpr(expr: ParsedExpr, emitter: ParsedExprEmitter): st
       if (expr.method === 'sort' || expr.method === 'toSorted') {
         return emitter.sortMethod(expr.method, expr.object, expr.comparator, emit)
       }
+      if (expr.method === 'reduce' || expr.method === 'reduceRight') {
+        return emitter.reduceMethod(expr.method, expr.object, expr.reduceOp, emit)
+      }
+      if (expr.method === 'flat') {
+        return emitter.flatMethod(expr.object, expr.flatDepth, emit)
+      }
+      if (expr.method === 'flatMap') {
+        return emitter.flatMapMethod(expr.object, expr.flatMapOp, emit)
+      }
       return emitter.arrayMethod(expr.method, expr.object, expr.args, emit)
     case 'unsupported':
       return emitter.unsupported(expr.raw, expr.reason)