@barefootjs/go-template 0.18.5 → 0.18.7

package/src/adapter/lib/compile-state.ts

@@ -66,6 +66,15 @@ export class CompileState {
    */
   localConstants: IRMetadata['localConstants'] = []
 
+  /**
+   * Every name a `.map()`/`.filter()` loop callback binds as its item/index
+   * parameter anywhere in the component (#2208 fable review). Consulted by
+   * static loop-source resolution (`getBakedStaticChildLoop`) so a const
+   * whose name a DIFFERENT, enclosing loop's own callback param shadows is
+   * never resolved as that const's static value.
+   */
+  staticLoopSourceBoundNames: Set<string> = new Set()
+
   /**
    * Names of component-scope arrow-const helpers (`const sortClass = …`),
    * eligible for call-site inlining.

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

@@ -7,7 +7,7 @@
  * function over `ir.metadata`; no adapter instance state.
  */
 
-import type { ComponentIR, TypeInfo } from '@barefootjs/jsx'
+import { collectLoopBoundNames, type ComponentIR, type TypeInfo } from '@barefootjs/jsx'
 
 /** True when `type` is the `string` primitive. */
 function isStringTypeInfo(type: TypeInfo): boolean {
@@ -22,14 +22,33 @@ function isBareStringLiteral(initialValue: string | undefined): boolean {
 }
 
 /**
- * String-typed signals and props. A signal is string-typed when its inferred
- * type is `string` (or, defensively, when its initial value is a bare string
- * literal); a prop when its annotated type is `string`. Drives `isStringName`
- * for `isStringConcatBinary` — the shared helper (`@barefootjs/jsx`) that
- * decides whether a JS `+` is string concatenation rather than numeric
- * addition (Go's `html/template` has no native `+` at all; `binary()` always
- * emits a runtime call, `bf_add` for addition or `bf_concat_str` for
- * concatenation — see `go-template-adapter.ts`'s `binary()`).
+ * String-typed signals, props, and same-file local consts (#2212, ported
+ * here for #2236). A signal is string-typed when its inferred type is
+ * `string` (or, defensively, when its initial value is a bare string
+ * literal); a prop when its annotated type is `string`; a local const the
+ * same way. Drives `isStringName` for `isStringConcatBinary` — the shared
+ * helper (`@barefootjs/jsx`) that decides whether a JS `+` is string
+ * concatenation rather than numeric addition (Go's `html/template` has no
+ * native `+` at all; `binary()` always emits a runtime call, `bf_add` for
+ * addition or `bf_concat_str` for concatenation — see
+ * `go-template-adapter.ts`'s `binary()`). Local consts matter for exactly
+ * the shadowing shape this exclusion exists for: with a loop-bound `label`
+ * subtracted, an outer `{label + suffix}` (where `suffix = '!'`) must
+ * still classify as string concat via its OTHER operand, or it would fall
+ * back to `bf_add` and render `0`.
+ *
+ * Excludes any name bound as a `.map()`/`.filter()` loop callback's item or
+ * index parameter ANYWHERE in the component (#2212, ported here for #2236):
+ * this lookup is a flat, scope-blind `Set<string>` with no notion of a loop
+ * param shadowing an outer string-typed binding of the same name
+ * (`values.map((label) => 1 + label)` inside a component that also has a
+ * string `label` prop) — left unguarded, that shadowed `label` would be
+ * misdetected as string-typed and `1 + label` would silently lower to
+ * `bf_concat_str` instead of staying numeric `bf_add`. Subtracting loop-bound
+ * names is coarse (it also suppresses a genuinely non-shadowed same-named
+ * string elsewhere in the component) but safe: the suppressed case just
+ * falls back to today's numeric `bf_add` — the same, already-accepted
+ * residual as an unresolvable operand — never silently-wrong output.
  */
 export function collectStringValueNames(ir: ComponentIR): Set<string> {
   const names = new Set<string>()
@@ -41,5 +60,11 @@ export function collectStringValueNames(ir: ComponentIR): Set<string> {
   for (const p of ir.metadata.propsParams) {
     if (isStringTypeInfo(p.type)) names.add(p.name)
   }
+  for (const c of ir.metadata.localConstants) {
+    if ((c.type !== null && isStringTypeInfo(c.type)) || isBareStringLiteral(c.value)) {
+      names.add(c.name)
+    }
+  }
+  for (const bound of collectLoopBoundNames(ir)) names.delete(bound)
   return names
 }

package/src/conformance-pins.ts

@@ -15,19 +15,21 @@ export const conformancePins: ConformancePins = {
   // `style={{ … }}` object literal now lowers to a CSS string with dynamic
   // values interpolated (`background-color:{{.Color}};padding:8px`) via
   // `tryLowerStyleObject` (#1322).
-  // Sibling-imported child component inside a loop body: the adapter
-  // emits `{{template "X" .}}` which only resolves if the user has
-  // compiled the sibling file and registered the template on the
-  // same instance. BF103 makes that requirement loud. (The barefoot
-  // CLI passes `siblingTemplatesRegistered: true` so CLI builds
-  // suppress the diagnostic — see compileJSX `siblingTemplatesRegistered`.)
-  'static-array-children': [{ code: 'BF103', severity: 'error' }],
-  // TodoApp / TodoAppSSR import `TodoItem` from a sibling file and
-  // call it inside a keyed `.map`. Same BF103 surface as
-  // `static-array-children` above — pinned at adapter level so the
-  // shared-component corpus stays adapter-neutral.
-  'todo-app': [{ code: 'BF103', severity: 'error' }],
-  'todo-app-ssr': [{ code: 'BF103', severity: 'error' }],
+  // `todo-app` / `todo-app-ssr` no longer pinned (#2205) — the conformance
+  // harness now passes `siblingTemplatesRegistered: true` for fixtures with
+  // sibling `components`, matching `bf build`'s real semantics, so the
+  // BF103 loop-body cross-template check no longer fires spuriously.
+  // (`todo-app-ssr` is still skipped on this adapter via
+  // `render-divergences.ts` — #2209 — for an unrelated signal-seeding gap;
+  // `todo-app`'s pre-hydration empty render is unaffected.)
+  // `static-array-children` no longer pinned (#2208) — `items`'s
+  // array-literal initializer is now recognized as fully-static and its
+  // per-item ListItem props/data-key are baked directly into
+  // `NewStaticListProps`'s constructor (`analyzeBakeableStaticChildLoop`),
+  // since the loop body is a single child component with a plain-value
+  // prop set. See #2224 for the narrower remaining gap (a plain-ELEMENT
+  // loop body over a static array, or an inline/unnamed array literal —
+  // still refused).
   // `([emoji, users]) => ...` is an array-index tuple destructure — #2087
   // Phase B's widened gate now admits this shape (`destructure-array-index-in-map`
   // exercises the same `segments`-based lowering). The remaining refusal here
@@ -40,13 +42,11 @@ export const conformancePins: ConformancePins = {
   // array bound to such a const. See the `renderLoop` comment at the check
   // site; Jinja / ERB apply the same narrow check for the same reason.
   'static-array-from-props': [{ code: 'BF101', severity: 'error' }],
-  // Same computed-const array as above, plus the pre-existing BF103 (a
-  // sibling-imported child component used inside the loop body) — the
-  // destructure param itself no longer contributes a diagnostic.
-  'static-array-from-props-with-component': [
-    { code: 'BF103', severity: 'error' },
-    { code: 'BF101', severity: 'error' },
-  ],
+  // Same computed-const array as above — the destructure param itself no
+  // longer contributes a diagnostic, and BF103 (sibling-imported child
+  // component in the loop body) no longer fires either now that the
+  // conformance harness passes `siblingTemplatesRegistered: true` (#2205).
+  'static-array-from-props-with-component': [{ code: 'BF101', severity: 'error' }],
   // (`style-3-signals` graduated alongside `style-object-dynamic` — see note
   // above; the `style={{ … }}` object now lowers to a CSS string.)
   // (`tagged-template-classname` graduated by #2092 — the tag resolves
@@ -127,15 +127,14 @@ export const conformancePins: ConformancePins = {
   // `string-trim` no longer pinned — pre-existing `bf_trim`
   // (wraps `strings.TrimSpace`) handles the strip (#1448 Tier A
   // ninth PR, closing out Tier A).
-  // #2073 follow-up: a function-reference `.map(format)` callback has no
-  // arrow body to serialize — not a CALLBACK_METHODS shape — so the
-  // UNSUPPORTED_METHODS gate refuses it with BF101 rather than emitting
-  // a broken template.
-  'array-map-function-reference': [{ code: 'BF101', severity: 'error' }],
-  // Edge-case sweep (Priority 12): `dangerouslySetInnerHTML` requires a
-  // deliberate raw-HTML (unescaped) output affordance in the target
-  // template language. No lowering exists yet, so the compiler refuses
-  // the shape loudly instead of emitting entity-escaped markup that
-  // silently renders tags as text.
-  'dangerous-inner-html': [{ code: 'BF101', severity: 'error' }],
+  // `array-map-function-reference` no longer pinned — a bare-identifier
+  // `.map(format)` callback now resolves one hop to its declaration
+  // (`resolveCallbackMethodFunctionReferences`, #2206), the same mechanism
+  // #2090 established for `.sort(fnref)`.
+  // `dangerous-inner-html` no longer pinned — a compile-time string-literal
+  // `dangerouslySetInnerHTML={{ __html: '...' }}` is spliced directly into
+  // the template as trusted raw text (`resolveDangerousInnerHtml`, #2207).
+  // A dynamic/signal-derived value still refuses with BF101 — see the
+  // `dangerous-inner-html-dynamic` fixture/pin below (tracked: #2215).
+  'dangerous-inner-html-dynamic': [{ code: 'BF101', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2215' }],
 }

package/src/render-divergences.ts

@@ -17,4 +17,16 @@
 import type { RenderDivergences } from '@barefootjs/jsx'
 
 export const renderDivergences: RenderDivergences = {
+  // `todo-app-ssr` no longer diverges (#2209). Two parts: (1) `.Todos`
+  // (the loop's DATUM slice) is already seeded straight from the caller's
+  // Input — the constructor derives it from `initialTodos`, and `[]Todo`
+  // zero-fills `Editing: false`, so the `.map(t => ({ ...t, editing:
+  // false }))` transform in the signal initializer was never actually the
+  // gap on Go, unlike the 7 template-string adapters. (2) The real gap was
+  // `.TodoItems []TodoItemProps` — the loop-body CHILD COMPONENT slice the
+  // template actually ranges over — which has no server-side population
+  // path in this harness (documented as route-handler-populated in
+  // production). `buildDynamicChildLoopSeeding` (this package's
+  // `test-render.ts`) now replicates that documented contract for a
+  // signal-backed dynamic child-component loop.
 }

package/src/test-render.ts

@@ -6,10 +6,12 @@
  */
 
 import { compileJSX } from '@barefootjs/jsx'
-import type { TemplateAdapter, ComponentIR } from '@barefootjs/jsx'
+import type { TemplateAdapter, ComponentIR, ParsedExpr } from '@barefootjs/jsx'
 import { GoTemplateAdapter } from './adapter/go-template-adapter.ts'
 import { deduplicateGoTypes } from './build.ts'
-import { capitalizeFieldName, goFieldNameForKey } from './adapter/lib/go-naming.ts'
+import { capitalizeFieldName, goFieldNameForKey, loopKeyToGoFieldPath } from './adapter/lib/go-naming.ts'
+import { findNestedComponents } from './adapter/analysis/component-tree.ts'
+import type { NestedComponentInfo } from './adapter/lib/types.ts'
 import { mkdir, rm } from 'node:fs/promises'
 import { resolve } from 'node:path'
 
@@ -157,8 +159,15 @@ export async function renderGoTemplateComponent(options: RenderOptions): Promise
     }
   }
 
-  // Compile parent source
-  const result = compileJSX(source, 'component.tsx', { adapter, outputIR: true })
+  // Compile parent source. `siblingTemplatesRegistered: Boolean(components)`
+  // matches this harness's real behavior — every sibling child template is concatenated
+  // into `tmplContent` and parsed onto one `*template.Template` instance
+  // below, so a loop-body cross-template call resolves at render time (#2205).
+  const result = compileJSX(source, 'component.tsx', {
+    adapter,
+    outputIR: true,
+    siblingTemplatesRegistered: Boolean(components),
+  })
 
   const errors = result.errors.filter(e => e.severity === 'error')
   if (errors.length > 0) {
@@ -319,11 +328,16 @@ export async function renderGoTemplateComponent(options: RenderOptions): Promise
     // cross-adapter; default to 'test' otherwise.
     const rootScopeId = typeof props?.__instanceId === 'string' ? props.__instanceId : 'test'
 
+    // (#2209 part 2) Route-handler-equivalent seeding for a signal-backed
+    // dynamic child-component loop — see buildDynamicChildLoopSeeding's
+    // docstring.
+    const { lines: dynamicSeedingLines, needsFmt } = buildDynamicChildLoopSeeding(ir, template)
+
     // main.go — render program
     const mainGo = `package main
 
 import (
-	"html/template"
+${needsFmt ? '\t"fmt"\n' : ''}	"html/template"
 	"math/rand"
 	"os"
 
@@ -368,7 +382,7 @@ func main() {
 		ScopeID: ${JSON.stringify(rootScopeId)},
 ${propsInit}
 	})
-	if err := tmpl.ExecuteTemplate(os.Stdout, "${componentName}", props); err != nil {
+${dynamicSeedingLines.length > 0 ? dynamicSeedingLines.join('\n') + '\n' : ''}	if err := tmpl.ExecuteTemplate(os.Stdout, "${componentName}", props); err != nil {
 		os.Stderr.WriteString("template error: " + err.Error() + "\\n")
 		os.Exit(1)
 	}
@@ -551,6 +565,95 @@ function ensureMergedStdlibImports(goTypes: string): string {
   return goTypes.replace(/import\s*\([^)]*\)/, newBlock)
 }
 
+/**
+ * Recursively resolve `expr` (a loop's `arrayParsed`) down through
+ * `call`/`member` chains to the base signal getter it reads
+ * (`todos().filter(...)` → `todos`), or `null` when the base isn't a
+ * signal getter call. Structural `ParsedExpr` walk, not string/regex
+ * parsing (see CLAUDE.md's "never parse JS with regex" rule).
+ */
+function findBaseSignalGetter(expr: ParsedExpr | undefined, signalGetters: ReadonlySet<string>): string | null {
+  if (!expr) return null
+  switch (expr.kind) {
+    case 'identifier':
+      return signalGetters.has(expr.name) ? expr.name : null
+    case 'call':
+      return findBaseSignalGetter(expr.callee, signalGetters)
+    case 'member':
+      return findBaseSignalGetter(expr.object, signalGetters)
+    default:
+      return null
+  }
+}
+
+/**
+ * (#2209 part 2) Replicate, in the generated `main.go`, the documented
+ * "the route handler populates the loop-body child-component slice at
+ * request time" contract for a signal-backed dynamic loop —
+ * `generateNewPropsFunction`'s doc comment on `<Name>s []<Name>Props`
+ * in `adapter/go-template-adapter.ts`. The constructor only ever seeds
+ * the loop's DATUM slice (e.g. `.Todos`, straight from the caller's
+ * Input); the child-component Props slice the template actually
+ * ranges over (`.TodoItems`) has no server-side population path in
+ * this harness — the Hono reference materializes it by literally
+ * executing the component, so this closes the gap the same way:
+ * derive each item's child Props from the datum slice, exactly as a
+ * real route handler is documented to.
+ *
+ * Deliberately narrow: only fires for a loop whose (a) array source
+ * resolves, through `call`/`member` chains, to a component signal
+ * getter, (b) generated Go TEMPLATE text actually ranges over
+ * `.<Name>s` (a plain substring check on GENERATED GO OUTPUT — not JS
+ * parsing — so a `/* @client *\/`-marked loop, whose SSR template has
+ * no such range, is untouched by construction), and (c) at least one
+ * child prop is a bare pass-through of the loop item (`todo={todo}`).
+ * Returns the Go statements to splice into `main()` plus whether `fmt`
+ * needs importing.
+ */
+function buildDynamicChildLoopSeeding(
+  ir: ComponentIR,
+  template: string,
+): { lines: string[]; needsFmt: boolean } {
+  const signalGetters = new Set(ir.metadata.signals.map(s => s.getter))
+  const lines: string[] = []
+  let needsFmt = false
+  for (const nested of findNestedComponents(ir.root) as NestedComponentInfo[]) {
+    if (!nested.isDynamic || nested.isPropDerived) continue
+    if (nested.bodyChildren && nested.bodyChildren.length > 0) continue
+    if (!nested.loopParam) continue
+    if (!template.includes(`:= .${nested.name}s}}`)) continue
+    const datumField = findBaseSignalGetter(nested.loopArrayParsed, signalGetters)
+    if (!datumField) continue
+
+    const inputFields: string[] = []
+    for (const prop of nested.props) {
+      if (prop.isEventHandler) continue
+      if (prop.name === 'key' || prop.name.includes('-')) continue
+      if (
+        prop.value.kind === 'expression' &&
+        prop.value.parsed?.kind === 'identifier' &&
+        prop.value.parsed.name === nested.loopParam
+      ) {
+        inputFields.push(`${capitalizeFieldName(prop.name)}: item`)
+      }
+    }
+    if (inputFields.length === 0) continue
+
+    lines.push(`\tprops.${nested.name}s = make([]${nested.name}Props, len(props.${capitalizeFieldName(datumField)}))`)
+    lines.push(`\tfor i, item := range props.${capitalizeFieldName(datumField)} {`)
+    lines.push(`\t\tprops.${nested.name}s[i] = New${nested.name}Props(${nested.name}Input{${inputFields.join(', ')}})`)
+    lines.push(`\t\tprops.${nested.name}s[i].BfParent = props.ScopeID`)
+    lines.push(`\t\tprops.${nested.name}s[i].BfMount = ${JSON.stringify(nested.slotId ?? '')}`)
+    const keyField = loopKeyToGoFieldPath(nested.loopKey, nested.loopParam)
+    if (keyField) {
+      lines.push(`\t\tprops.${nested.name}s[i].BfDataKey = fmt.Sprint(${keyField})`)
+      needsFmt = true
+    }
+    lines.push(`\t}`)
+  }
+  return { lines, needsFmt }
+}
+
 /**
  * Build Go struct field initializers from props.
  */