@barefootjs/go-template 0.29.0 → 0.30.2

package/src/adapter/memo/memo-compute.ts

@@ -801,3 +801,128 @@ function propsAccessNameFromParsed(ctx: GoEmitContext, node: ParsedExpr): string
   if (!ctx.state.propsObjectName || node.object.name !== ctx.state.propsObjectName) return null
   return node.property
 }
+
+/**
+ * #2448: every INPUT prop name a constructor-evaluated `parsed` expression
+ * reads, either via a `<propsObjectName>.<name>` member access (object-props
+ * signature, e.g. `props.n`) or a bare identifier bound to a destructured
+ * prop (no `propsObjectName`).
+ *
+ * Two kinds of expression reach here, because `New<Comp>Props` bakes BOTH
+ * into the struct at construction time: a `createMemo` body and a
+ * `createSignal` INITIAL VALUE (`const [dbl] = createSignal(props.n)` emits
+ * `Dbl: in.N`, exactly as `createMemo(() => props.n * 2)` emits
+ * `Dbl: in.N * 2`). Either one goes stale under a per-row override, so both
+ * feed the dependency map.
+ *
+ * Feeds `GoTemplateAdapter.childDerivedFieldDeps` (built by
+ * `recordDerivedFieldDeps`, `go-template-adapter.ts`) so a parent overriding
+ * one of THESE props per row (`bf_with_props`, #2445) can be refused loudly
+ * instead of silently leaving the derived field stale — see that map's
+ * docstring.
+ *
+ * Structural counterpart of {@link freeVarsInBody}: that walk reports a
+ * member's OBJECT identifier only (`props`), treating the property name as
+ * non-referential (fine for its own free-var-substitution purpose). Here the
+ * PROPERTY name is exactly what's wanted, so a `member` node contributes it
+ * once its object resolves to the props binding — walking stops at that
+ * first `propsObjectName.<name>` hop, so a deeper chain (`props.a.b`) still
+ * contributes only its BASE prop `a` (mirrors `collectPropRefs` in
+ * `ssr-defaults.ts`, the same first-level-only rule, for the same reason: an
+ * adapter that later re-derives a nested field still needs the base field
+ * seeded).
+ *
+ * This is a best-effort STRUCTURAL walk over the child's OWN analysis-time
+ * `parsed` tree — not a re-derivation of the Go initializer text, which
+ * isn't available yet at registration time (the cross-file shape pre-pass,
+ * #2131, runs before any component's codegen).
+ */
+export function collectPropsReadByCtorInit(
+  body: ParsedExpr,
+  propsObjectName: string | null,
+  propNames: ReadonlySet<string>,
+): Set<string> {
+  const found = new Set<string>()
+  const visit = (e: ParsedExpr, bound: ReadonlySet<string>): void => {
+    switch (e.kind) {
+      case 'identifier':
+        // Destructured signature only: a bare identifier bound to a
+        // destructured prop param IS the reference (`(props) => props.n`
+        // has no bare `n` — that shape is the `member` branch below).
+        if (!propsObjectName && propNames.has(e.name) && !bound.has(e.name)) found.add(e.name)
+        return
+      case 'member':
+        if (
+          propsObjectName &&
+          !e.computed &&
+          e.object.kind === 'identifier' &&
+          e.object.name === propsObjectName
+        ) {
+          found.add(e.property)
+          return
+        }
+        visit(e.object, bound)
+        return
+      case 'index-access':
+        visit(e.object, bound)
+        visit(e.index, bound)
+        return
+      case 'binary':
+      case 'logical':
+        visit(e.left, bound)
+        visit(e.right, bound)
+        return
+      case 'unary':
+        visit(e.argument, bound)
+        return
+      case 'conditional':
+        visit(e.test, bound)
+        visit(e.consequent, bound)
+        visit(e.alternate, bound)
+        return
+      case 'call':
+        visit(e.callee, bound)
+        e.args.forEach(a => visit(a, bound))
+        return
+      case 'template-literal':
+        for (const p of e.parts) if (p.type === 'expression') visit(p.expr, bound)
+        return
+      case 'array-literal':
+        e.elements.forEach(el => visit(el, bound))
+        return
+      case 'object-literal':
+        for (const p of e.properties) visit(p.value, bound)
+        return
+      case 'array-method':
+        visit(e.object, bound)
+        e.args.forEach(a => visit(a, bound))
+        if (e.method === 'flat' && e.depthExpr) visit(e.depthExpr, bound)
+        return
+      case 'arrow': {
+        const inner = e.params.length === 0 ? bound : new Set([...bound, ...e.params])
+        visit(e.body, inner)
+        return
+      }
+      // Non-referential leaves — nothing to collect.
+      case 'literal':
+      case 'regex':
+      case 'unsupported':
+        return
+      default: {
+        // Exhaustiveness pin. A NEW `ParsedExpr` kind that lands without a
+        // case here would silently contribute no dependencies, and this
+        // walk's whole job is to answer "does this memo read that prop?" —
+        // a missed dependency is a MISSED REFUSAL, i.e. the silently-stale
+        // derived field #2448 exists to prevent. Fail the build instead:
+        // `never` makes the omission a compile error at the point the kind
+        // is added, the same drift defence `PARSED_EXPR_KINDS` gives the
+        // registry (`expression-parser.ts`).
+        const _exhaustive: never = e
+        void _exhaustive
+        return
+      }
+    }
+  }
+  visit(body, new Set())
+  return found
+}

package/src/adapter/type/type-codegen.ts

@@ -15,6 +15,48 @@ import type { TypeInfo } from '@barefootjs/jsx'
 
 import type { GoEmitContext } from '../emit-context.ts'
 
+/**
+ * Collapse a homogeneous LITERAL union (`'a' | 'b'`, `1 | 2`, `true | false`)
+ * to the primitive that backs it, so a variant-typed signal or prop
+ * (`createSignal<'a' | 'b'>('a')`, the `{ variant?: 'a' | 'b' }` prop shape)
+ * gets a real Go type instead of `interface{}` — and, downstream in
+ * `convertInitialValue`, a real seed instead of `nil`. #2477's Go leg: the
+ * analyzer maps an explicit literal-union type argument to
+ * `{kind:'union'}` of literal members, and with no
+ * `union` arm here OR in `convertInitialValue` the field fell to
+ * `interface{}` and the seed to `nil` — which the child's `string` field
+ * then rejected at `go run` time (`cannot use nil as string value`).
+ *
+ * Only a union whose EVERY member is a literal of ONE primitive family
+ * (string / number / boolean; a same-family primitive keyword member like
+ * `'a' | string` also counts) collapses. Anything else — mixed families,
+ * `null` / `undefined` members, object members — returns the input
+ * unchanged and keeps today's `interface{}` fallback, so the collapse can
+ * never widen what Go accepts, only type what it already receives.
+ */
+export function collapseLiteralUnion(typeInfo: TypeInfo): TypeInfo {
+  if (typeInfo.kind !== 'union' || !typeInfo.unionTypes || typeInfo.unionTypes.length === 0) {
+    return typeInfo
+  }
+  // Purely structural: `typeNodeToTypeInfo` lowers a literal member to
+  // `kind: 'primitive'` + `literalValue`, so the member's family is just
+  // its `primitive` — no re-parsing of `raw` (the first cut of this
+  // helper regexed the member text because the analyzer had no literal
+  // arm; that gap is closed at the source).
+  const familyOf = (m: TypeInfo): 'string' | 'number' | 'boolean' | null => {
+    if (m.kind !== 'primitive') return null
+    return m.primitive === 'string' || m.primitive === 'number' || m.primitive === 'boolean'
+      ? m.primitive
+      : null
+  }
+  const first = familyOf(typeInfo.unionTypes[0])
+  if (!first) return typeInfo
+  for (const m of typeInfo.unionTypes) {
+    if (familyOf(m) !== first) return typeInfo
+  }
+  return { kind: 'primitive', raw: typeInfo.raw, primitive: first }
+}
+
 /**
  * Convert a `TypeInfo` to a Go type string.
  *
@@ -27,9 +69,10 @@ import type { GoEmitContext } from '../emit-context.ts'
  */
 export function typeInfoToGo(
   ctx: GoEmitContext,
-  typeInfo: TypeInfo,
+  _typeInfo: TypeInfo,
   defaultValue?: string,
 ): string {
+  const typeInfo = collapseLiteralUnion(_typeInfo)
   switch (typeInfo.kind) {
     case 'primitive':
       switch (typeInfo.primitive) {

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

@@ -11,6 +11,7 @@ import type { GoEmitContext } from '../emit-context.ts'
 import type { PropFallbackVar } from '../lib/types.ts'
 import { capitalizeFieldName } from '../lib/go-naming.ts'
 import { parsedLiteralToGo } from './parsed-literal-to-go.ts'
+import { collapseLiteralUnion } from '../type/type-codegen.ts'
 
 /** Default for `getSignalInitialValueAsGo`'s optional fallback-var map. */
 const EMPTY_PROP_FALLBACK_VARS: ReadonlyMap<string, PropFallbackVar> = new Map()
@@ -61,10 +62,14 @@ function nillableAwarePropRef(ctx: GoEmitContext, propName: string, expectedType
 export function convertInitialValue(
   ctx: GoEmitContext,
   value: string,
-  typeInfo: TypeInfo,
+  _typeInfo: TypeInfo,
   propsParams?: { name: string }[],
   preParsed?: ParsedExpr,
 ): string {
+  // Literal unions collapse to their backing primitive the same way
+  // `typeInfoToGo` collapses the field's type — the two MUST agree, or a
+  // `string` field gets a `nil` seed (#2477's `go run` failure).
+  const typeInfo = collapseLiteralUnion(_typeInfo)
   const propRef = (propName: string): string => nillableAwarePropRef(ctx, propName, typeInfo)
 
   if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(value)) {

package/src/conformance-pins.ts

@@ -15,11 +15,6 @@ export const conformancePins: ConformancePins = {
   // JS-runtime target runs it, a DSL adapter surfaces BF021 + `/* @client */`.
   // See spec/callback-fidelity.md.
   'filter-typeof-predicate': [{ code: 'BF021', severity: 'error' }],
-  // A `.map()` body with a `const`/`let` preamble before its branches:
-  // a JS runtime folds it, a DSL adapter can't carry the loop-local into a
-  // conditional branch template, so it refuses with BF021 + `/* @client */`.
-  // See spec/callback-fidelity.md.
-  'map-preamble-branch-body': [{ code: 'BF021', severity: 'error' }],
   'map-array-builder-body': [{ code: 'BF021', severity: 'error' }],
   'map-array-builder-escaping': [{ code: 'BF021', severity: 'error' }],
   // `.fill(value)` mutates the receiver in place — no template lowering

package/src/render-divergences.ts

@@ -30,13 +30,28 @@ export const renderDivergences: RenderDivergences = {
   // `test-render.ts`) now replicates that documented contract for a
   // signal-backed dynamic child-component loop.
 
-  // #2445: a child component nested inside a dynamic loop row whose root
-  // is a plain element gets ONE hoisted `BadgeSlot0 BadgeProps` field on
-  // the parent, built outside the loop with no per-row data, and the
-  // template passes `$.BadgeSlot0` for every row — so every row renders
-  // the child with zero-value props. The sibling shape (row root IS the
-  // child component) already emits a per-row slice; see the `todo-app-ssr`
-  // note above on `.TodoItems []TodoItemProps`.
-  'composite-row-child-component':
-    'a child component nested inside a dynamic loop row receives one hoisted props value built outside `{{range}}`, so every row renders the child with zero-value props (https://github.com/piconic-ai/barefootjs/issues/2445)',
+  // Onboarding TSX-fidelity fixtures (PR #2461): `expectedHtml` is
+  // hand-authored to the CORRECT output because the emission bug lives in
+  // the shared compiler layer — every adapter, including the Hono
+  // reference, currently emits the broken form (verified against this
+  // adapter's emitted template; see each fixture's docstring). Graduate
+  // by fixing the shared emission, regenerating `expectedHtml` from the
+  // fixed reference, and deleting these lines (and the matching hono
+  // `skipJsx` entries).
+  'aliased-destructured-prop':
+    'aliased destructured prop `{ n: count }` loses its rename — the Input struct field is Count `json:"count"`, so the caller-side struct literal keyed by the real prop name fails `go run` outright (unknown field N, exit 1) (https://github.com/piconic-ai/barefootjs/issues/2460)',
+
+  // #2482 audit follow-ups: loop-scope holes specific to this adapter's
+  // four-stack scope tracking and its SSR seeding. Graduate by applying
+  // the fix described in each issue and deleting the line.
+  'loop-destructured-param-condition':
+    'a destructured .map() param binding used as a row ternary CONDITION emits the root-scope `{{if $.Active}}` — `renderConditionExpr` omits `loopBindingStack`, unlike `identifierToGoRef` (text positions resolve the same binding correctly) (https://github.com/piconic-ai/barefootjs/issues/2486)',
+  'nested-loop-tail-content':
+    'outer-row content AFTER a nested inner loop renders through non-loop arms (spread lowers to the component-root `.Spread_0`) — `inLoop` is cleared, not restored, by the inner loop\'s exit; the same content BEFORE the inner loop emits correctly (https://github.com/piconic-ai/barefootjs/issues/2487)',
+  'loop-param-shadows-spread-const':
+    'spreading a loop row object mangles attribute names (`id` → `-i-d`, `title` → `-title`); the spread VALUE is correctly row-scoped, distinguishing this from the template-adapter const-shadow hole #2489 (https://github.com/piconic-ai/barefootjs/issues/2490)',
+  'loop-param-shadows-record-template-span':
+    'a dynamic-key element access on a loop row (`tone[k]`) renders empty at execute time — the emitted template contains no baked const (correct post-fix), but the row lookup resolves to nothing (https://github.com/piconic-ai/barefootjs/issues/2491)',
+  'callback-param-shadows-prop':
+    'JS-computed signal/memo initializers (`[…].map(…).join(…)`, memo over signal + prop) don\'t seed Go SSR — renders `[]` / empty where every other adapter renders the computed value; hydration snaps to correct (https://github.com/piconic-ai/barefootjs/issues/2492)',
 }