@barefootjs/go-template 0.31.10 → 0.32.0

package/src/adapter/go-template-adapter.ts

@@ -255,6 +255,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     extractPropNameFromInitialValue: (initialValue, preParsed) =>
       this.extractPropNameFromInitialValue(initialValue, preParsed),
     extractPropFallback: (initialValue, preParsed) => this.extractPropFallback(initialValue, preParsed),
+    extractCollisionDerivation: (parsed) => this.extractCollisionDerivation(parsed),
     resolveModuleStringConst: (name) => this.resolveModuleStringConst(name),
   }
 
@@ -1873,6 +1874,8 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       lines.push('')
     }
 
+    this.emitCallerPropsInit(lines, ir, nestedComponents, staticWithoutBody, staticWithBody, dynamicWithBody, emittedWrapperVars, propTypeOverrides)
+
     lines.push(`\treturn ${propsTypeName}{`)
     lines.push('\t\tScopeID: scopeID,')
     // Host context, for when *this* component is itself a slot-attached child.
@@ -1881,6 +1884,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     if (this.usesSearchParams(ir)) {
       lines.push('\t\tSearchParams: in.SearchParams,')
     }
+    lines.push('\t\tBfCallerProps: bfCallerProps,')
 
     const nestedArrayFields = this.propDerivedNestedArrayFields(nestedComponents)
 
@@ -1918,7 +1922,17 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       if (this.isNestedArrayShadowed(param, nestedArrayFields)) continue
       const hoisted = propFallbackVars.get(param.name)
       if (hoisted) {
-        lines.push(`\t\t${fieldName}: ${hoisted.varName},`)
+        // #2683: a `collisionWrap` entry means this field is ALSO a
+        // colliding signal's shared field — `hoisted.varName` alone only
+        // carries the coalesced `props.X ?? <lit>` value, so the surrounding
+        // arithmetic (`* 2`, etc.) is composed back on here, giving the
+        // FULLY DERIVED value the signal's own initializer computes. Without
+        // this the field would silently carry just the coalesce result (the
+        // same class of bug this fix addresses, one operator short).
+        const value = hoisted.collisionWrap
+          ? `${hoisted.varName} ${hoisted.collisionWrap.operator} ${hoisted.collisionWrap.operand}`
+          : hoisted.varName
+        lines.push(`\t\t${fieldName}: ${value},`)
       } else {
         const paramDefault = goPropDefault(param.defaultValue)
         const memoFold = memoFallbacks.get(fieldName)
@@ -2038,6 +2052,139 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     lines.push('}')
   }
 
+  /**
+   * Build the `bfCallerProps` local (assigned to `BfCallerProps` in the
+   * returned struct) — the hydration-only, caller-supplied-keys-only view
+   * of this component's props (#2684). See the field's doc comment
+   * (`emitPropsStructHeader`) for the two-consumers rationale.
+   *
+   * Three classes, mirroring the issue's taxonomy — gated on `param.optional`
+   * (NOT on the resolved Go type's nillability alone, even though that reads
+   * as the more "obvious" test): a REQUIRED prop must stay unconditional
+   * even when its resolved type happens to be nillable (`ctx: unknown`, the
+   * `array-flatmap-thisarg` fixture passes `ctx: null` explicitly) — Go's
+   * `interface{}` cannot tell "explicit null" from "omitted" once
+   * unmarshaled (both are the nil zero value), so nil-checking a required
+   * field would silently turn an intentional `null` into a dropped key.
+   *   1. Required prop → always included, raw `in.<InputField>` (never the
+   *      defaulted Props-field value — a caller who passes the same value
+   *      as the author's default is indistinguishable from one who didn't,
+   *      but that's inherent to a required prop having no "omitted" state).
+   *   2. Optional prop whose resolved Go type is nillable (`interface{}`,
+   *      `map[string]interface{}`, or any slice `[]T`) → included only
+   *      when `in.<InputField> != nil`, i.e. only when the caller actually
+   *      passed something.
+   *   3. Optional prop that nonetheless resolved to a CONCRETE type (a
+   *      string-union alias like `placement?: 'top' | 'bottom'`, a bare
+   *      scalar never consumed nullish/attr/text/presence-wise, OR a type
+   *      that resolves to `interface{}` some OTHER way — e.g. an inherited
+   *      `extends` clause the analyzer can't fully resolve — while
+   *      `param.optional` itself is, possibly inaccurately, `false`) —
+   *      presence is unknowable from Input alone, so it's included
+   *      unconditionally, same as class 1. A documented residual, not
+   *      silently dropped; see the PR that introduced this method for named
+   *      instances found in the corpus (e.g. `textarea`'s `rows`, inherited
+   *      through `TextareaHTMLAttributes`). Do NOT widen these props' types
+   *      to "fix" this — that's `resolvePropGoType`'s call, not this
+   *      method's, and doing so would risk the same `ctx`-style regression.
+   *
+   * `children` is excluded outright (#1952 — a separately-declared
+   * position, not relitigated here). Rest-props bags are never added to
+   * the Props struct's JSON at all (checked: no field exists for them
+   * outside Input), so nothing to exclude here either — already at parity
+   * with the reference, which never serializes rest keys.
+   *
+   * A prop shadowed by its own driving nested-array field (`isNestedArrayShadowed`
+   * — e.g. `toggleItems` colliding with a `<ToggleItem>` loop's derived
+   * `ToggleItems` field, #2672/#2525) has NO Props/Input field of its own;
+   * the reshaped nested-array local (`varName`, already built above by the
+   * static/dynamic body-wrapper emission) is its only remaining carrier, so
+   * that's what gets keyed in here instead of `in.<InputField>`. KNOWN
+   * RESIDUAL: each item within that array is still the OLD whole-struct
+   * marshal (baked author defaults / null-for-absent / zero-for-required
+   * inside every item) — recursing the sidecar into embedded Props-struct
+   * arrays needs either a generated `MarshalJSON` per Props type or a
+   * runtime array-flattening helper, a bigger surface this method's design
+   * doesn't cover. Reported, not chased (see PR description).
+   */
+  private emitCallerPropsInit(
+    lines: string[],
+    ir: ComponentIR,
+    nestedComponents: NestedComponentInfo[],
+    staticWithoutBody: NestedComponentInfo[],
+    staticWithBody: NestedComponentInfo[],
+    dynamicWithBody: NestedComponentInfo[],
+    emittedWrapperVars: Set<string>,
+    propTypeOverrides: Map<string, string>,
+  ): void {
+    lines.push('\tbfCallerProps := map[string]interface{}{}')
+    const bfCallerPropsTakenTags = new Set<string>()
+    const nestedArrayFields = this.propDerivedNestedArrayFields(nestedComponents)
+
+    for (const param of ir.metadata.propsParams) {
+      // Children are DOM content, not hydration data (#1952) — excluded the
+      // same way `emitPropsDataFields` excludes them from the Props struct.
+      if (param.name === 'children') continue
+      // Shadowed by its own driving nested-array field (#2672/#2525) — no
+      // Input field exists for it at all; handled below via the array local.
+      if (this.isNestedArrayShadowed(param, nestedArrayFields)) continue
+      // Same tag algorithm `emitPropsDataFields` uses for the Props field's
+      // own `json:"…"` tag, re-derived against a FRESH set: props are always
+      // processed first, in the same order, over an empty set in BOTH
+      // places, so the two computations can't disagree.
+      const callerKey = this.claimJsonTag(this.toJsonTag(param.sourceName ?? param.name), bfCallerPropsTakenTags)
+      if (callerKey === '-') continue // tag collision — dropped from the wire, same as the Props field itself would be
+      const inputField = `in.${capitalizeFieldName(param.sourceName ?? param.name)}`
+      const goType = resolvePropGoType(this.emitCtx, param, propTypeOverrides)
+      const isNillable = goType === 'interface{}' || goType === 'map[string]interface{}' || goType.startsWith('[]')
+      // `param.optional` gates the branch (not "isNillable alone") because a
+      // REQUIRED prop must stay unconditional even when its resolved type
+      // happens to be nillable (`ctx: unknown`, #2094's array-flatmap-thisarg
+      // fixture passes `ctx: null` explicitly) — Go's `interface{}` cannot
+      // tell "explicit null" from "omitted" once unmarshaled (both are the
+      // nil zero value), so a nil-check here would silently turn an
+      // intentional `null` into a dropped key, regressing a fixture that
+      // matched the reference before this method existed. `resolvePropGoType`
+      // never applies its nillable flip to a required prop, so this ONLY
+      // affects the rare case where a type resolves to `interface{}` some
+      // OTHER way (e.g. `unknown`, or a type inherited through an
+      // unresolved external `extends` clause) while `param.optional` is
+      // (accurately or not) false — see the method docstring's residual list.
+      if (param.optional && isNillable) {
+        lines.push(`\tif ${inputField} != nil {`)
+        lines.push(`\t\tbfCallerProps["${callerKey}"] = ${inputField}`)
+        lines.push(`\t}`)
+      } else {
+        // Required (class 1), or optional-but-concrete residual (class 3),
+        // or optional-but-misresolved-required residual — see docstring.
+        lines.push(`\tbfCallerProps["${callerKey}"] = ${inputField}`)
+      }
+    }
+
+    // Shadowed nested-array props — see method docstring.
+    for (const nested of [...staticWithoutBody, ...staticWithBody, ...dynamicWithBody]) {
+      if (!nested.isPropDerived) continue
+      const varName = `${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`
+      const isBuilt = staticWithoutBody.includes(nested) || emittedWrapperVars.has(varName)
+      if (!isBuilt) continue
+      const arrayFieldName = capitalizeFieldName(`${nested.name}s`)
+      const param = ir.metadata.propsParams.find(
+        p => capitalizeFieldName(p.name) === arrayFieldName || capitalizeFieldName(p.sourceName ?? p.name) === arrayFieldName,
+      )
+      if (!param || !this.isNestedArrayShadowed(param, nestedArrayFields)) continue
+      const callerKey = this.claimJsonTag(this.toJsonTag(param.sourceName ?? param.name), bfCallerPropsTakenTags)
+      if (callerKey === '-') continue
+      if (param.optional) {
+        lines.push(`\tif in.${nested.name}s != nil {`)
+        lines.push(`\t\tbfCallerProps["${callerKey}"] = ${varName}`)
+        lines.push(`\t}`)
+      } else {
+        lines.push(`\tbfCallerProps["${callerKey}"] = ${varName}`)
+      }
+    }
+    lines.push('')
+  }
+
   private emitStaticChildInstances(lines: string[], ir: ComponentIR): void {
     const staticChildren = this.collectStaticChildInstances(ir.root, ir.metadata.propsParams)
     for (const child of staticChildren) {
@@ -2741,6 +2888,24 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     if (this.usesSearchParams(ir)) {
       lines.push('\tSearchParams bf.SearchParams `json:"-"`')
     }
+
+    // #2684: the raw, CALLER-SUPPLIED view of this component's props —
+    // populated by `NewXxxProps` with exactly the keys the caller passed
+    // (required props always; optional ones only when not nil), holding
+    // the UNDEFAULTED value. This exists because every prop field above
+    // (e.g. `X`) serves TWO different consumers that want two different
+    // values: the Go TEMPLATE wants the DEFAULTED value so `{{.X}}` renders
+    // the author's fallback, while the HYDRATION PAYLOAD wants to know only
+    // what the caller actually supplied — baking the author's default into
+    // it makes an omitted prop indistinguishable from one explicitly passed
+    // with that value, and a Go zero value indistinguishable from an
+    // explicit zero/empty/false (the reference, Hono, only ever serializes
+    // caller-passed keys). One field can't answer both questions at once,
+    // so this sidecar gives the hydration payload its own carrier;
+    // `BfPropsAttr` (runtime/bf.go) marshals THIS map instead of the whole
+    // struct when it's present. `json:"-"` — never marshaled as an ordinary
+    // struct field; `BfPropsAttr` reads it directly by name via reflection.
+    lines.push('\tBfCallerProps map[string]interface{} `json:"-"`')
   }
 
   private emitPropsDataFields(
@@ -3588,7 +3753,32 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
 
     const propTypeOverrides = buildPropTypeOverrides(this.emitCtx, ir)
     for (const signal of ir.metadata.signals) {
-      const match = this.extractPropFallback(signal.initialValue, this.resolvedSignalParsed(signal))
+      let match = this.extractPropFallback(signal.initialValue, this.resolvedSignalParsed(signal))
+      // #2683: the idempotent fold above declines a non-idempotent
+      // derivation (`(props.count ?? 1) * 2`) at the top level. When that
+      // signal's Go field name COLLIDES with the prop's own field — the
+      // exact condition under which the props-field loop below would
+      // otherwise silently drop the derivation and emit the raw prop
+      // instead — fall back to the collision-derivation matcher so the
+      // coalesced value still gets hoisted; the props-field loop composes
+      // the surrounding arithmetic back on top of it (`collisionWrap`).
+      // Gated strictly on the collision so a differently-named signal
+      // deriving from the same prop (not colliding) is untouched — that
+      // path's own dedicated field keeps today's behavior byte-for-byte.
+      let collisionWrap: { operator: string; operand: string } | undefined
+      if (!match) {
+        const collision = this.extractCollisionDerivation(this.resolvedSignalParsed(signal))
+        if (collision) {
+          const collisionParam = ir.metadata.propsParams.find(p => p.name === collision.propName)
+          const collisionField = collisionParam
+            ? capitalizeFieldName(collisionParam.sourceName ?? collision.propName)
+            : null
+          if (collisionField && capitalizeFieldName(signal.getter) === collisionField) {
+            match = { propName: collision.propName, goFallback: collision.goFallback }
+            collisionWrap = { operator: collision.operator, operand: collision.operand }
+          }
+        }
+      }
       if (!match) continue
       if (result.has(match.propName)) continue
       const param = ir.metadata.propsParams.find(p => p.name === match.propName)
@@ -3648,6 +3838,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         goFallback: match.goFallback,
         zeroLiteral,
         ...(nullishLowered ? { assertType: concreteType } : {}),
+        ...(collisionWrap ? { collisionWrap } : {}),
       })
     }
     return result
@@ -3742,6 +3933,67 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return { propName, goFallback }
   }
 
+  /**
+   * #2683: match a signal's collision-derivation shape — `(props.X ?? <lit>)
+   * <op> <int>` — the ONE non-idempotent shape this adapter faithfully lowers
+   * when a signal's Go field name collides with its own prop's field (see the
+   * collision-override loop in `collectPropFallbackVars` / the props-field
+   * loop in `generateNewPropsFunction`). Composes two ALREADY-EXISTING
+   * lowerings instead of adding a third: `extractPropFallbackFromParsed`
+   * recognizes the embedded `props.X ?? <lit>` presence check exactly as it
+   * does for the idempotent fold, and the wrap mirrors the SAME `<ref> <op>
+   * <int>` arithmetic shape `memoInitialFromParsedBody`'s multiply-family
+   * branch already supports for a bare `props.X <op> N` (non-negative
+   * integer operand only, matching that branch's own restriction).
+   *
+   * Returns null for any other shape — the caller then keeps today's
+   * raw-passthrough behavior (sound-or-loud; the remaining #2683 pin, if
+   * any, covers whatever this doesn't reach).
+   */
+  private extractCollisionDerivation(
+    parsed: ParsedExpr | undefined,
+  ): { propName: string; goFallback: string; operator: string; operand: string } | null {
+    if (!parsed || parsed.kind !== 'binary') return null
+    if (!['*', '+', '-', '/'].includes(parsed.op)) return null
+    const { right } = parsed
+    if (
+      right.kind !== 'literal' ||
+      right.literalType !== 'number' ||
+      typeof right.value !== 'number' ||
+      !Number.isInteger(right.value) ||
+      right.value < 0
+    ) {
+      return null
+    }
+    // Constant division by zero is a Go COMPILE error (`invalid operation:
+    // division by zero`), unlike JS's Infinity — declining keeps that shape
+    // on the raw-passthrough path instead of breaking the build.
+    if (parsed.op === '/' && right.value === 0) return null
+    // The `??` fallback itself must be a NUMERIC literal before delegating
+    // to the fold: `extractPropFallbackFromParsed` happily matches a string
+    // fallback (`(props.label ?? 'x') + 2`), which would hoist
+    // `var label string = "x"` and emit `Label: label + 2,` — invalid Go
+    // (string + int), a compile break where the pre-existing behavior at
+    // least built (Copilot review on #2694). JS's `'x' + 2` is string
+    // concatenation besides, so a numeric compose could never be faithful
+    // for it — the shape belongs on the raw-passthrough path until someone
+    // lowers it through ConcatStr deliberately. Gating on `??` (not `||`)
+    // also keeps JS nullish semantics exact for numeric props, where a
+    // caller's explicit `0` must NOT trigger the fallback.
+    const coalesce = parsed.left
+    if (
+      coalesce.kind !== 'logical' ||
+      coalesce.op !== '??' ||
+      coalesce.right.kind !== 'literal' ||
+      coalesce.right.literalType !== 'number'
+    ) {
+      return null
+    }
+    const inner = this.extractPropFallbackFromParsed(parsed.left)
+    if (!inner) return null
+    return { ...inner, operator: parsed.op, operand: String(right.value) }
+  }
+
   /**
    * Extract the prop name from a signal's `props.xxx`-pattern initialValue,
    * e.g. `"props.initial ?? 0"` → `"initial"`, `"props.checked"` → `"checked"`.

package/src/adapter/lib/types.ts

@@ -167,6 +167,16 @@ export interface PropFallbackVar {
    * distinguishable from an absent one.
    */
   assertType?: string
+  /**
+   * #2683: set when this fallback var was hoisted from a signal's
+   * COLLISION-DERIVATION initializer (`(props.X ?? <lit>) <op> <int>`, where
+   * the signal's Go field name collides with prop X's) rather than a plain
+   * `props.X ?? <lit>`. `varName` above still holds only the coalesced RAW
+   * value (the presence-check declaration is unchanged) — this records the
+   * arithmetic wrap the props-field loop applies ON TOP of it so the shared
+   * field carries the FULLY DERIVED value, not just the coalesce result.
+   */
+  collisionWrap?: { operator: string; operand: string }
 }
 
 /**

package/src/adapter/props/prop-types.ts

@@ -10,6 +10,7 @@ import { isBooleanAttr } from '@barefootjs/jsx'
 
 import type { GoEmitContext } from '../emit-context.ts'
 import { resolveSignalParsedThroughSeedPlan } from '../lib/compile-state.ts'
+import { capitalizeFieldName } from '../lib/go-naming.ts'
 import { typeInfoToGo } from '../type/type-codegen.ts'
 
 /**
@@ -224,7 +225,31 @@ export function collectNullishConsumedPropNames(ctx: GoEmitContext, ir: Componen
     // between `props.X` and `createSignal` doesn't leave this loop and
     // `collectPropFallbackVars`'s identical extraction disagreeing on
     // whether the prop needs the nillable flip.
-    const match = ctx.extractPropFallback(signal.initialValue, resolveSignalParsedThroughSeedPlan(ctx.state, signal))
+    const resolvedParsed = resolveSignalParsedThroughSeedPlan(ctx.state, signal)
+    let match = ctx.extractPropFallback(signal.initialValue, resolvedParsed)
+    // #2683: the idempotent fold above declines a non-idempotent derivation
+    // (`(props.count ?? 1) * 2`) at the top level. When that signal's Go
+    // field name COLLIDES with the prop's own field, the props-struct
+    // emitter composes the derivation onto the SHARED field (see
+    // `collectPropFallbackVars`'s identical collision gate) — which needs
+    // the SAME nillable flip an ordinary `??` fallback gets, so an absent
+    // prop (nil) stays distinguishable from an explicit zero-equivalent
+    // value. Gated strictly on the collision, matching that other site, so
+    // a differently-named signal deriving from the same prop (not
+    // colliding — its own dedicated field, untouched by this fix) doesn't
+    // spuriously flip the prop's type.
+    if (!match) {
+      const collision = ctx.extractCollisionDerivation(resolvedParsed)
+      if (collision) {
+        const collisionParam = ir.metadata.propsParams.find(p => p.name === collision.propName)
+        const collisionField = collisionParam
+          ? capitalizeFieldName(collisionParam.sourceName ?? collision.propName)
+          : null
+        if (collisionField && capitalizeFieldName(signal.getter) === collisionField) {
+          match = { propName: collision.propName, goFallback: collision.goFallback }
+        }
+      }
+    }
     if (!match || !optionalParams.has(match.propName)) continue
     const f = match.goFallback
     if (f === '""' || f === 'false' || f === 'nil' || Number(f) === 0) continue

package/src/render-divergences.ts

@@ -17,28 +17,4 @@
 
 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)',
-}
+export const renderDivergences: RenderDivergences = {}