@barefootjs/go-template 0.33.4 → 0.33.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/go-template",
-  "version": "0.33.4",
+  "version": "0.33.6",
   "description": "Go html/template adapter for BarefootJS - generates Go template files from IR",
   "type": "module",
   "main": "./dist/index.js",
@@ -49,7 +49,7 @@
     "directory": "packages/adapter-go-template"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.33.4"
+    "@barefootjs/shared": "0.33.6"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0",
@@ -67,9 +67,9 @@
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/client": "0.33.4",
-    "@barefootjs/jsx": "0.33.4",
-    "@barefootjs/vite": "0.33.4",
+    "@barefootjs/client": "0.33.6",
+    "@barefootjs/jsx": "0.33.6",
+    "@barefootjs/vite": "0.33.6",
     "vite": "^6.0.0"
   }
 }

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

@@ -18,6 +18,7 @@ import {
 } from '@barefootjs/jsx'
 import { conformancePins } from '../conformance-pins'
 import { renderDivergences } from '../render-divergences'
+import { findNestedComponents } from '../adapter/analysis/component-tree.ts'
 
 runAdapterConformanceTests({
   name: 'go-template',
@@ -987,7 +988,9 @@ export function List() {
 
     test('keeps nil for an untyped object array with non-scalar values (#1680)', () => {
       // A nested object/array value has no scalar Go type to infer, so the
-      // shape can't be synthesised — bail to nil.
+      // shape can't be synthesised — bail to nil. `tags` is a nested array
+      // of SCALARS (not objects) — #2800 only teaches synthesis to recurse
+      // into an array of OBJECT literals, so this shape is unchanged.
       const adapter = new GoTemplateAdapter()
       const ir = compileToIR(`
 "use client"
@@ -1001,6 +1004,85 @@ export function List() {
       expect(adapter.generate(ir).types!).toContain('Items: nil,')
     })
 
+    // #2800: a nested array-of-objects field (`children: [{...}]`) recurses
+    // into its own synthesized struct instead of aborting the whole
+    // signal's synthesis.
+    test('synthesises a nested struct for a nested array-of-objects field and bakes it (#2800)', () => {
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+export function NestedRefConst() {
+  const [items] = createSignal([
+    { id: 1, label: 'Alpha', children: [{ id: 10, label: 'Alpha-child' }] },
+    { id: 2, label: 'Beta', children: [{ id: 20, label: 'Beta-child' }] },
+  ])
+  return <ul>{items().map((row) => <li key={row.id}>{row.label}</li>)}</ul>
+}
+`)
+      const types = adapter.generate(ir).types!
+      expect(types).toContain('type NestedRefConstItemsItemChildrenItem struct')
+      expect(types).toContain('Children []NestedRefConstItemsItemChildrenItem')
+      expect(types).not.toContain('Items: nil,')
+      expect(types).toContain(
+        'Items: []NestedRefConstItemsItem{NestedRefConstItemsItem{ID: 1, Label: "Alpha", Children: []NestedRefConstItemsItemChildrenItem{NestedRefConstItemsItemChildrenItem{ID: 10, Label: "Alpha-child"}}}, NestedRefConstItemsItem{ID: 2, Label: "Beta", Children: []NestedRefConstItemsItemChildrenItem{NestedRefConstItemsItemChildrenItem{ID: 20, Label: "Beta-child"}}}}',
+      )
+    })
+
+    test('recurses to arbitrary depth, widening a numeric field at the innermost level (#2800)', () => {
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+export function Depth3() {
+  const [items] = createSignal([
+    { id: 1, kids: [{ id: 10, grand: [{ id: 100, n: 1 }, { id: 101, n: 2.5 }] }] },
+  ])
+  return <ul>{items().map((row) => <li key={row.id}>{row.id}</li>)}</ul>
+}
+`)
+      const types = adapter.generate(ir).types!
+      expect(types).toContain('type Depth3ItemsItemKidsItemGrandItem struct')
+      expect(types).toMatch(/type Depth3ItemsItemKidsItemGrandItem struct \{\n\tID int[\s\S]*\tN float64/)
+      expect(types).toContain('Kids []Depth3ItemsItemKidsItem')
+      expect(types).toContain('Grand []Depth3ItemsItemKidsItemGrandItem')
+      expect(types).not.toContain('Items: nil,')
+    })
+
+    test('keeps nil when a nested struct name collides with a user type (#2800)', () => {
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+type ListItemsItemChildrenItem = { id: string }
+export function List() {
+  const [items] = createSignal([{ id: 1, children: [{ id: 2 }] }])
+  return <ul>{items().map((row) => <li key={row.id}>{row.id}</li>)}</ul>
+}
+`)
+      expect(adapter.generate(ir).types!).toContain('Items: nil,')
+    })
+
+    test('keeps nil when a key is a nested array in some rows and scalar in others (#2800)', () => {
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+export function List() {
+  const [items] = createSignal([
+    { id: 1, children: [{ id: 2 }] },
+    { id: 3, children: 'not-an-array' },
+  ])
+  return <ul>{items().map((row) => <li key={row.id}>{row.id}</li>)}</ul>
+}
+`)
+      expect(adapter.generate(ir).types!).toContain('Items: nil,')
+    })
+
     test('widens mixed int/float keys to float64 and keeps negatives (#1680)', () => {
       // A key seen as both an integer and a fractional literal across elements
       // can't be `int`; widen it to `float64`. Negative numeric literals keep
@@ -1407,6 +1489,201 @@ export function Widget(props: P) {
       expect(types).toContain('Classes: "a b" + " " + "c d" + " " + in.ClassName + " tail"')
     })
 
+    // A signal seeded from a bare identifier referencing a module-level
+    // const (`const PAYLOAD = '...'; createSignal(PAYLOAD)`) used to bake
+    // to `nil` — the analyzer types it `unknown` since it never chases an
+    // identifier to its declaration, so none of convertInitialValue's typed
+    // branches saw it (#2794). Now resolved via the same
+    // resolveModuleStringConst/resolveModuleNumericConst the adapter
+    // already used for live template expressions (template-interp.ts).
+    test('signal seeded from a module-level const bakes its literal value, not nil', () => {
+      const adapter = new GoTemplateAdapter()
+      const source = `
+"use client"
+import { createSignal } from "@barefootjs/client"
+const PAYLOAD = 'hello'
+const WIDTH = 8
+export function Demo() {
+  const [value] = createSignal(PAYLOAD)
+  const [width] = createSignal(WIDTH)
+  return <textarea value={value()} data-w={width()} />
+}
+`
+      const types = adapter.generateTypes(compileToIR(source, adapter))!
+      expect(types).toContain('Value: "hello"')
+      expect(types).toContain('Width: 8')
+    })
+
+    // Same family, boolean shape (#2815 — filed and fixed in the same PR
+    // as #2794 above, since it's the identical resolver-not-wired gap on
+    // a third literal kind rather than a new mechanism).
+    test('signal seeded from a module-level boolean const bakes true/false, not nil', () => {
+      const adapter = new GoTemplateAdapter()
+      const source = `
+"use client"
+import { createSignal } from "@barefootjs/client"
+const OPEN = true
+export function Demo() {
+  const [open] = createSignal(OPEN)
+  return <div>{open() ? 'y' : 'n'}</div>
+}
+`
+      const types = adapter.generateTypes(compileToIR(source, adapter))!
+      expect(types).toContain('Open: true')
+    })
+
+    // #2700: a `derived` signal (non-empty free set, e.g. `{ ...base, done }`)
+    // whose object literal the constructor-time baker can't reproduce
+    // (identifier/member/call operands defer) used to silently keep the Go
+    // zero value for every field the SSR template reads. Loud-ified instead
+    // of taught a live-expression lowering — Go has none — since the
+    // template's `.Merged.ID` / `.Merged.Done` reads would otherwise see a
+    // wrong value with no diagnostic at all.
+    test('signal object-literal spreading a live prop refuses with BF101 when the template reads it (#2700)', () => {
+      const adapter = new GoTemplateAdapter()
+      const result = compileAndGenerate(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+type Item = { id: string; done: boolean }
+export function Widget({ base }: { base: Item }) {
+  const [merged] = createSignal({ ...base, done: true })
+  return (
+    <div>
+      <span>{merged().id}</span>
+      <span>{merged().done ? 'yes' : 'no'}</span>
+    </div>
+  )
+}
+`, adapter)
+      const bf101 = adapter.errors.filter(e => e.code === 'BF101')
+      expect(bf101.length).toBe(1)
+      expect(bf101[0].message).toContain("Signal 'merged'")
+      expect(bf101[0].message).toContain('base')
+      expect(bf101[0].suggestion?.escape).toEqual([{ kind: 'client-directive' }])
+      expect(result.template).toBeTruthy()
+    })
+
+    // Same refusal for an EXPLICITLY typed object signal (`createSignal<Item>`)
+    // — the typed `interface` branch (`value-lowering.ts`) also defers to a
+    // struct zero value (`Item{}`) for the identical reason.
+    test('typed object signal spreading a live prop also refuses with BF101 (#2700)', () => {
+      const adapter = new GoTemplateAdapter()
+      compileAndGenerate(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+type Item = { id: string; done: boolean }
+export function Widget({ base }: { base: Item }) {
+  const [merged] = createSignal<Item>({ id: base.id, done: true })
+  return <span>{merged().id}</span>
+}
+`, adapter)
+      expect(adapter.errors.some(e => e.code === 'BF101')).toBe(true)
+    })
+
+    // No memo-side counterpart: the analyzer deliberately never sets
+    // `MemoInfo.parsed` to an `object-literal` for an object-returning memo
+    // body (`analyzer.ts`, "isn't lowered from the parsed tree yet") — a
+    // pre-existing, unrelated exclusion — so this refusal has no structural
+    // handle to reach a memo without re-parsing `computation` as text,
+    // which the repo's own convention rules out. #2700's own reproduction
+    // and fixture are signal-only.
+
+    // The `/* @client */` escape: wrapping every SSR read defers evaluation
+    // to the client, so the template never reaches `rootFieldRef` for this
+    // signal — no refusal, even though the constructor still bakes `nil`.
+    test('/* @client */ on every read suppresses the #2700 refusal', () => {
+      const adapter = new GoTemplateAdapter()
+      const result = compileAndGenerate(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+type Item = { id: string; done: boolean }
+export function Widget({ base }: { base: Item }) {
+  const [merged] = createSignal({ ...base, done: true })
+  return (
+    <div>
+      <span>{/* @client */ merged().id}</span>
+      <span>{/* @client */ merged().done ? 'yes' : 'no'}</span>
+    </div>
+  )
+}
+`, adapter)
+      expect(adapter.errors.filter(e => e.code === 'BF101')).toEqual([])
+      expect(result.types).toContain('Merged: nil,')
+    })
+
+    // A signal that ONLY feeds a JSX spread (`{...merged()}`) never reaches
+    // `rootFieldRef` — spread bags bake through their own `.Spread_<slot>`
+    // route (`emitSpreadBagInits`) — so it must not trip the #2700 check even
+    // though the constructor still can't bake the literal. (This shape DOES
+    // still refuse, but with the PRE-EXISTING, unrelated "JSX spread has no
+    // Go template lowering" BF101 for `{...merged()}` on an intrinsic
+    // element — not a second, redundant #2700-shaped one.)
+    test('a signal only spread into attrs does not double-refuse under #2700', () => {
+      const adapter = new GoTemplateAdapter()
+      compileAndGenerate(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+type Item = { id: string; done: boolean }
+export function Widget({ base }: { base: Item }) {
+  const [merged] = createSignal({ ...base, done: true })
+  return <div {...merged()} />
+}
+`, adapter)
+      const bf101 = adapter.errors.filter(e => e.code === 'BF101')
+      expect(bf101.length).toBe(1)
+      expect(bf101[0].message).not.toContain("Signal 'merged' is seeded")
+    })
+
+    // A signal read ONLY from inside a `.filter()` predicate (never a plain
+    // `{merged()}` text read) must still register in `templateReadRootFields`
+    // and trip #2700's refusal — `renderFilterExprNode`'s zero-arg-call arm
+    // used to build the `$.Merged` field reference by hand instead of
+    // through `rootFieldRef`, so this exact shape was a false negative
+    // (pullfrog review, PR #2818).
+    test('a signal reachable only through a .filter() predicate still refuses with BF101 (#2700, #2818 pullfrog review)', () => {
+      const adapter = new GoTemplateAdapter()
+      compileAndGenerate(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+type Item = { id: string; done: boolean }
+export function Widget({ base, items }: { base: Item; items: Item[] }) {
+  const [merged] = createSignal({ ...base, done: true })
+  return (
+    <ul>
+      {items().filter(i => i.id === merged().id).map(i => <li key={i.id}>{i.id}</li>)}
+    </ul>
+  )
+}
+`, adapter)
+      const bf101 = adapter.errors.filter(e => e.code === 'BF101')
+      expect(bf101.length).toBe(1)
+      expect(bf101[0].message).toContain("Signal 'merged'")
+    })
+
+    // A destructured prop sharing the module const's name must still win
+    // (shadowing) — the const resolver is checked AFTER the prop lookup.
+    test('a destructured prop shadows a same-named module const', () => {
+      const adapter = new GoTemplateAdapter()
+      const source = `
+"use client"
+import { createSignal } from "@barefootjs/client"
+const PAYLOAD = 'const-value'
+interface P { PAYLOAD?: string }
+export function Demo({ PAYLOAD }: P) {
+  const [value] = createSignal(PAYLOAD)
+  return <textarea value={value()} />
+}
+`
+      const types = adapter.generateTypes(compileToIR(source, adapter))!
+      expect(types).not.toContain('Value: "const-value"')
+      // Positive pin (pullfrog review, #2816): the absence check above
+      // would pass just as well if the value fell through to `nil`
+      // instead of resolving to the prop — assert the actual expected
+      // shadowing output too, matching the `Value: in.Value,` convention
+      // used elsewhere in this file.
+      expect(types).toContain('Value: in.PAYLOAD,')
+    })
+
     // A boolean ternary memo (`isChecked = ctrl() ? c() : i()`) types its
     // SSR field as `bool` (not `int`), so `aria-checked={isChecked()}`
     // matches Hono's `aria-checked="false"` shape. Since #2260, `checked`'s
@@ -5112,6 +5389,61 @@ export function Toggle({ toggleItems }: ToggleProps) {
   })
 })
 
+describe('GoTemplateAdapter - #2835 name collision with a whole-props type member', () => {
+  // Same-file sibling components (`Item` alongside the exported `List`) —
+  // compiled with `compileJSX` directly, like the #2445 describe block above,
+  // since `compileToIR`'s single-component IR round trip isn't set up to
+  // pick a specific sibling out of a multi-component file.
+  const collidingSource = `
+type ItemProps = { label: string }
+function Item(props: ItemProps) {
+  return <div>{props.label}</div>
+}
+const base = [{ label: 'z' }]
+type Props = { base: ItemProps[] }
+export function List(props: Props) {
+  return <div>{base.map((item) => <Item key={item.label} label={item.label} />)}</div>
+}
+`
+  const controlSource = `
+type ItemProps = { label: string }
+function Item(props: ItemProps) {
+  return <div>{props.label}</div>
+}
+const base = [{ label: 'z' }]
+type Props = { other: string }
+export function List(props: Props) {
+  return <div>{base.map((item) => <Item key={item.label} label={item.label} />)}</div>
+}
+`
+
+  test('a module const colliding with `Props.base` is not classified prop-derived — the actual input `findNestedComponents` (component-tree.ts) feeds to Go codegen', () => {
+    const ctx = analyzeComponent(collidingSource.trimStart(), 'test.tsx', 'List')
+    const ir = jsxToIR(ctx)
+    expect(ir).not.toBeNull()
+    const item = findNestedComponents(ir!).find(c => c.name === 'Item')
+    expect(item).toBeDefined()
+    expect(item!.isPropDerived).toBe(false)
+    expect(item!.isDynamic).toBe(false)
+  })
+
+  test('Items stays a real hydrated field (`json:"items"`), matching the non-colliding control — misclassification previously hid it behind `json:"-"` and fabricated an unrelated `Base` prop read', () => {
+    const collidingResult = compileJSX(collidingSource.trimStart(), 'test.tsx', { adapter: new GoTemplateAdapter(), outputIR: false })
+    const controlResult = compileJSX(controlSource.trimStart(), 'test.tsx', { adapter: new GoTemplateAdapter(), outputIR: false })
+    const collidingTypes = collidingResult.files.find(f => f.type === 'types')!.content
+    const controlTypes = controlResult.files.find(f => f.type === 'types')!.content
+    // `Props.base` is a real declared member independent of the loop
+    // classification, so it legitimately gets its own `Base`/`bfCallerProps`
+    // entries in BOTH cases — the loop-specific signal is the `Items` field,
+    // which a misclassified `isPropDerived: true` hides from JSON entirely.
+    expect(collidingTypes).toContain('Items []ItemProps `json:"items"`')
+    expect(collidingTypes).not.toContain('Items []ItemProps `json:"-"`')
+    const itemsFieldLine = (src: string) => src.split('\n').find(l => l.includes('[]ItemInput')) ?? ''
+    expect(itemsFieldLine(collidingTypes)).not.toBe('')
+    expect(itemsFieldLine(collidingTypes)).toBe(itemsFieldLine(controlTypes))
+  })
+})
+
 describe('GoTemplateAdapter - collision-derivation lowering (#2683)', () => {
   test('a signal colliding with its own prop composes the presence-check fold with the surrounding arithmetic', () => {
     const result = compileJSX(`

package/src/adapter/emit-context.ts

@@ -79,4 +79,18 @@ export interface GoEmitContext {
    * outer-loop params are excluded).
    */
   resolveModuleStringConst(name: string): string | null
+
+  /**
+   * Inline a module numeric const by name as its Go literal text (e.g.
+   * `8`, `-3.5`), or null when the name is not such a const (loop vars and
+   * outer-loop params are excluded, same as `resolveModuleStringConst`).
+   */
+  resolveModuleNumericConst(name: string): string | null
+
+  /**
+   * Inline a module boolean const by name as its Go literal text
+   * (`true`/`false`), or null when the name is not such a const (same
+   * exclusions as `resolveModuleNumericConst`).
+   */
+  resolveModuleBooleanConst(name: string): string | null
 }