@barefootjs/go-template 0.31.10 → 0.33.0

package/src/adapter/value/value-lowering.ts

@@ -232,6 +232,9 @@ export function objectLiteralToGoMap(ctx: GoEmitContext, expr: ParsedExpr): stri
   if (expr.kind !== 'object-literal') return null
   const entries: string[] = []
   for (const prop of expr.properties) {
+    // A spread (`{ ...t }`, #2696 Step 2) has no static key to bake as a Go
+    // map entry — bail, same as any other unsupported shape.
+    if (prop.kind === 'spread') return null
     if (prop.shorthand) return null
     const val = parsedLiteralToGo(ctx, prop.value)
     if (val === null) return null
@@ -390,40 +393,43 @@ function resolveMapJoinBaseAsGo(
   return null
 }
 
+/** `.map`/`.filter` → the runtime evaluator function that composes it. Both
+ *  take `items any` and return `[]any` (`eval.go`), so nesting one call's
+ *  result straight into another's `items` argument is exactly `.a().b()`'s
+ *  JS semantics — no expression-tree fusion needed (#2696 review). */
+const CALLBACK_EVAL_FUNC: Record<string, string> = { map: 'bf.MapEval', filter: 'bf.FilterEval' }
+
 /**
- * Lower a `.map(cb).join(sep)` chain (matched by {@link matchMapJoinChain})
- * to a `bf.Join(bf.MapEval(<items>, "<projJSON>", "<param>", <envMap>),
- * <sep>)` Go expression — the constructor-source analogue of
- * `matchFilterArmMemo`'s `bf.FilterEval` emit (`memo-compute.ts`), reusing
- * the SAME two runtime evaluator functions (`MapEval`, `eval.go`; `Join`,
- * `bf.go`) the template-position `bf_map_eval`/`bf_join` lowering already
- * calls. Shared by a memo's derived value (`memoInitialFromParsedBody`'s
- * concatenation-chain arm) and a SIGNAL's own initializer
- * (`convertInitialValue`'s `string` branch, #2492).
+ * Lower ONE `.map(cb)`/`.filter(cb)` step to a runtime-evaluator call over an
+ * already-resolved `itemsGo` Go expression: `bf.MapEval(<itemsGo>,
+ * "<projJSON>", "<param>", <envMap>)` (or `bf.FilterEval` for `.filter`).
+ * Shared by {@link resolveMapChainAsGo} (an intermediate step feeding the
+ * NEXT step's `items`) and {@link mapJoinChainToGo} (the outermost step,
+ * whose result feeds `bf.Join`).
  *
- * @returns the Go expression, or null when the receiver doesn't resolve
- *   ({@link resolveMapJoinBaseAsGo}), the projection body isn't
- *   representable to the runtime evaluator (`serializeParsedExpr` refusal),
- *   a captured free variable doesn't resolve, or the separator isn't a
- *   string literal (a dynamic separator — out of scope for this arm).
+ * @returns the Go expression, or null when the callback body isn't
+ *   representable to the runtime evaluator (`serializeParsedExpr` refusal)
+ *   or a captured free variable doesn't resolve.
  */
-export function mapJoinChainToGo(
+function callbackStepToGo(
   ctx: GoEmitContext,
-  chain: { object: ParsedExpr; arrow: Extract<ParsedExpr, { kind: 'arrow' }>; sepArg?: ParsedExpr },
+  method: string,
+  itemsGo: string,
+  arrow: Extract<ParsedExpr, { kind: 'arrow' }>,
   signals: { getter: string; initialValue: string; type?: TypeInfo; parsed?: ParsedExpr }[],
   propsParams: { name: string; sourceName?: string }[],
   propFallbackVars: ReadonlyMap<string, PropFallbackVar>,
 ): string | null {
-  const itemsGo = resolveMapJoinBaseAsGo(ctx, chain.object, signals, propsParams)
-  if (itemsGo === null) return null
+  const evalFunc = CALLBACK_EVAL_FUNC[method]
+  if (!evalFunc) return null
 
   const knownGetterNames = new Set(signals.map(s => s.getter))
-  const materialized = materializeGetterCalls(chain.arrow.body, knownGetterNames)
+  const materialized = materializeGetterCalls(arrow.body, knownGetterNames)
   const projJSON = serializeParsedExpr(materialized)
   if (projJSON === null) return null
 
-  const paramName = chain.arrow.params[0] ?? '_'
-  const freeVars = freeVarsInBody(materialized, new Set(chain.arrow.params))
+  const paramName = arrow.params[0] ?? '_'
+  const freeVars = freeVarsInBody(materialized, new Set(arrow.params))
   const envEntries: string[] = []
   for (const name of freeVars) {
     const sig = signals.find(s => s.getter === name)
@@ -440,6 +446,74 @@ export function mapJoinChainToGo(
   }
   const envMap = `map[string]any{${envEntries.join(', ')}}`
 
+  return `${evalFunc}(${itemsGo}, "${escapeGoString(projJSON)}", ${JSON.stringify(paramName)}, ${envMap})`
+}
+
+/**
+ * Resolve a `.map()`/`.filter()` CHAIN of any depth to a Go expression:
+ * peel off callback-method layers one at a time (`asCallbackMethodCall`),
+ * composing a `bf.MapEval`/`bf.FilterEval` call around the PREVIOUS layer's
+ * result for each one, down to the base receiver
+ * ({@link resolveMapJoinBaseAsGo} — a signal call, prop field, or array
+ * literal). `rows().map(t => ({ id: t.id, … })).map(r => r.id)` composes as
+ * `bf.MapEval(bf.MapEval(<rows>, "{id:t.id,…}", "t", {}), "r.id", "r", {})`
+ * — before this, only a chain whose FIRST layer already matched a base
+ * shape resolved; a nested map/filter layer silently fell to `null` (#2696
+ * review: `map-object-literal-body`'s two chained `.map()`s).
+ *
+ * @returns the Go expression, or null when the base receiver doesn't
+ *   resolve or any layer's callback isn't representable
+ *   ({@link callbackStepToGo}).
+ */
+function resolveMapChainAsGo(
+  ctx: GoEmitContext,
+  expr: ParsedExpr,
+  signals: { getter: string; initialValue: string; type?: TypeInfo; parsed?: ParsedExpr }[],
+  propsParams: { name: string; sourceName?: string }[],
+  propFallbackVars: ReadonlyMap<string, PropFallbackVar>,
+): string | null {
+  const cb = asCallbackMethodCall(expr)
+  if (cb && cb.method in CALLBACK_EVAL_FUNC) {
+    const innerGo = resolveMapChainAsGo(ctx, cb.object, signals, propsParams, propFallbackVars)
+    if (innerGo === null) return null
+    return callbackStepToGo(ctx, cb.method, innerGo, cb.arrow, signals, propsParams, propFallbackVars)
+  }
+  return resolveMapJoinBaseAsGo(ctx, expr, signals, propsParams)
+}
+
+/**
+ * Lower a `.map(cb).join(sep)` chain (matched by {@link matchMapJoinChain})
+ * to a `bf.Join(<chain>, <sep>)` Go expression, where `<chain>` is the
+ * chain's OWN `.map()` step composed by {@link callbackStepToGo} over
+ * whatever {@link resolveMapChainAsGo} resolves its receiver to (a base
+ * shape, or one or more nested `.map()`/`.filter()` layers) — the
+ * constructor-source analogue of `matchFilterArmMemo`'s `bf.FilterEval`
+ * emit (`memo-compute.ts`), reusing the SAME runtime evaluator functions
+ * (`MapEval`/`FilterEval`, `eval.go`; `Join`, `bf.go`) the template-position
+ * `bf_map_eval`/`bf_join` lowering already calls. Shared by a memo's
+ * derived value (`memoInitialFromParsedBody`'s concatenation-chain arm and
+ * bare-chain arm) and a SIGNAL's own initializer (`convertInitialValue`'s
+ * `string` branch, #2492).
+ *
+ * @returns the Go expression, or null when the receiver doesn't resolve
+ *   ({@link resolveMapChainAsGo}), the projection body isn't representable
+ *   to the runtime evaluator (`serializeParsedExpr` refusal), a captured
+ *   free variable doesn't resolve, or the separator isn't a string literal
+ *   (a dynamic separator — out of scope for this arm).
+ */
+export function mapJoinChainToGo(
+  ctx: GoEmitContext,
+  chain: { object: ParsedExpr; arrow: Extract<ParsedExpr, { kind: 'arrow' }>; sepArg?: ParsedExpr },
+  signals: { getter: string; initialValue: string; type?: TypeInfo; parsed?: ParsedExpr }[],
+  propsParams: { name: string; sourceName?: string }[],
+  propFallbackVars: ReadonlyMap<string, PropFallbackVar>,
+): string | null {
+  const itemsGo = resolveMapChainAsGo(ctx, chain.object, signals, propsParams, propFallbackVars)
+  if (itemsGo === null) return null
+
+  const mapGo = callbackStepToGo(ctx, 'map', itemsGo, chain.arrow, signals, propsParams, propFallbackVars)
+  if (mapGo === null) return null
+
   let sepGo: string
   if (!chain.sepArg) {
     sepGo = JSON.stringify(',')
@@ -449,5 +523,5 @@ export function mapJoinChainToGo(
     return null
   }
 
-  return `bf.Join(bf.MapEval(${itemsGo}, "${escapeGoString(projJSON)}", ${JSON.stringify(paramName)}, ${envMap}), ${sepGo})`
+  return `bf.Join(${mapGo}, ${sepGo})`
 }

package/src/render-divergences.ts

@@ -18,27 +18,6 @@
 import type { RenderDivergences } from '@barefootjs/jsx'
 
 export const renderDivergences: RenderDivergences = {
-  // #2683: the props-struct emitter (`go-template-adapter.ts`) skips a
-  // signal whose Go field name collides with a prop field, keyed purely on
-  // the NAME collision — never on whether `extractPropFallback` actually
-  // matched a supported `props.x ?? <default>` shape. For a non-idempotent
-  // derivation (`createSignal((props.count ?? 1) * 2)`) the fallback
-  // extractor correctly declines to fold `* 2` into the struct default, but
-  // the `continue` fires anyway on the name match alone, so the emitted
-  // struct field silently drops the `* 2` and the signal's initial value
-  // renders as the raw prop instead of its derived value. Not a one-liner:
-  // two Go struct fields can't share an identifier, so simply removing the
-  // skip emits a duplicate field — the real fix needs its own PR.
-  'signal-prop-same-name-derived':
-    'self-derived signal collides with its prop field name in the generated Go props struct — the non-idempotent `* 2` derivation is dropped and the signal renders the raw prop value instead (https://github.com/piconic-ai/barefootjs/issues/2683)',
-  // #2685 review: same #2683 bug, one hop of const indirection removed —
-  // the props-struct field-name collision is keyed on the SIGNAL's name,
-  // not on how its initializer reaches the prop, so
-  // `const mid = props.count; createSignal((mid ?? 1) * 2)` collides
-  // exactly like the direct-access form above. This is go's PRE-EXISTING
-  // #2683 defect surfacing through a new fixture, not a regression from
-  // the #2685 review fix (which lands correctly on every other
-  // template-stash adapter — see those adapters' conformance runs).
-  'signal-prop-same-name-via-const-derived':
-    'self-derived signal (reached through a component-scope const) collides with its prop field name in the generated Go props struct — the non-idempotent `* 2` derivation is dropped and the signal renders the raw prop value instead (https://github.com/piconic-ai/barefootjs/issues/2683)',
+  'signal-object-spread-init':
+    'PRE-EXISTING, unrelated to the #2696 Step 2 spread work this fixture pins: a `derived`-classified signal/memo whose value is an OBJECT literal has no live-template-expression lowering on Go — unlike the other six template-stash backends (e.g. minijinja emits `{% set merged = dict(base, done=true) %}`), Go always bakes an object-typed signal/memo field into Go SOURCE at `NewXxxProps` constructor time (`convertInitialValue`/`parsedLiteralToGo`), and that baker is STATIC-only (identifier/call/member operands defer, `parsed-literal-to-go.ts`\'s own docstring) — it cannot reference a live prop at all. Reproduced identically with the spread REMOVED (`createSignal({ id: base.id, done: true })`), confirming the gap predates and is independent of spread: the signal seeds `nil` and every field read (`.Merged.ID`/`.Merged.Done`) reads the Go zero value regardless of `initialTodos`. Graduate by teaching the baker to emit prop-referencing Go expressions (https://github.com/piconic-ai/barefootjs/issues/2700).',
 }