@barefootjs/go-template 0.35.0 → 0.35.2

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

@@ -376,6 +376,161 @@ describe('GoTemplateAdapter - bf_ternary value-position lowering (#2335)', () =>
   test('emits no {{if}} action fragment for a value-position ternary', () => {
     expect(render("flag ? 'a' : 'b'")).not.toContain('{{if')
   })
+
+  // #2863: a multi-part template literal (mixed literal text and MULTIPLE
+  // interpolations) as a ternary BRANCH used to lower through the TEXT-
+  // position `templateLiteral()` path (`{{.Start}}-{{.End}}`), nesting raw
+  // `{{`/`}}` delimiters inside `bf_ternary`'s own argument list — a
+  // `html/template` parse error ("unexpected \"{\" in operand") at Go
+  // application startup, even though `bf build` itself succeeded. It must
+  // instead fold to one pipeline value, chained through the same
+  // `bf_concat_str` runtime helper JS string-concat `+` already uses (#2168).
+  test('a multi-part template-literal branch folds to a bf_concat_str chain, not a raw fragment (#2863)', () => {
+    expect(render('end ? `${start}-${end}` : start')).toBe(
+      '{{(bf_ternary (bf_truthy .End) (bf_concat_str (bf_concat_str .Start "-") .End) .Start)}}',
+    )
+  })
+
+  test('a template-literal branch never leaks a raw {{ or }} into the surrounding action (#2863)', () => {
+    const out = render('end ? `${start}-${end}` : start')
+    const inner = out.slice(2, -2) // strip the outer {{ }} the whole expression is wrapped in
+    expect(inner).not.toContain('{{')
+    expect(inner).not.toContain('}}')
+  })
+
+  test('a single-part template-literal branch reduces to the bare value, no bf_concat_str wrap (#2863)', () => {
+    expect(render('end ? `${start}` : end')).toBe('{{(bf_ternary (bf_truthy .End) .Start .End)}}')
+  })
+
+  test('static text in a template-literal branch is an escaped Go string literal (#2863)', () => {
+    expect(render('end ? `say "hi" ${start}` : end')).toBe(
+      '{{(bf_ternary (bf_truthy .End) (bf_concat_str "say \\"hi\\" " .Start) .End)}}',
+    )
+  })
+
+  test('a nested ternary inside a template-literal branch still lowers to bf_ternary, not {{if}} (#2863)', () => {
+    const out = render('end ? `x ${flag ? \'a\' : \'b\'}` : end')
+    expect(out).toBe(
+      '{{(bf_ternary (bf_truthy .End) (bf_concat_str "x " (bf_ternary (bf_truthy .Flag) "a" "b")) .End)}}',
+    )
+    expect(out).not.toContain('{{if')
+  })
+})
+
+// #2863 follow-up: the same value-position leak existed for a `+`/`||`
+// operand and a registered-lowering (`queryHref`) argument, not just a
+// `bf_ternary` branch — every such position funnels through the Go
+// adapter's shared `lowerValueOperand` door (`expr/url-builder.ts`).
+describe('GoTemplateAdapter - value-position template literal in other operand positions (#2863)', () => {
+  const adapter = new GoTemplateAdapter()
+  const render = (expr: string) => adapter.renderExpression({ expr } as IRExpression)
+
+  test('a template-literal operand of `+` folds through bf_concat_str, not a raw fragment', () => {
+    const out = render('`${a}-${b}` + a')
+    const inner = out.slice(2, -2)
+    expect(inner).not.toContain('{{')
+    expect(inner).toContain('bf_concat_str')
+  })
+
+  test('a template-literal operand of `||` folds through bf_concat_str, not a raw fragment', () => {
+    const out = render('a || `${a}-${b}`')
+    const inner = out.slice(2, -2)
+    expect(inner).not.toContain('{{')
+  })
+
+  // The issue's exact repro shape: a local, expression-bodied helper arrow
+  // (`eventTime`) whose body is the ternary+template-literal, called from a
+  // `.map()` row. A ternary written DIRECTLY inline in JSX instead compiles
+  // to a text-position `IRConditional` (`{{if}}…{{else}}…{{end}}`, correct
+  // and unaffected by this bug) — the buggy VALUE-position path is only
+  // reached once `inlineLocalHelperCall` substitutes the helper's body into
+  // the `eventTime(event)` call site and the Go adapter re-parses the
+  // result as a plain expression, not a JSX conditional.
+  test('the issue #2863 repro: a local-helper ternary+template-literal inlined in a .map() row lowers to valid Go source', () => {
+    const { template } = compileAndGenerate(`
+'use client'
+import { createSignal } from '@barefootjs/client'
+type Event = { id: string; time: string; endTime: string }
+type Dashboard = { events: Event[] }
+const empty: Dashboard = { events: [] }
+export function Schedule() {
+  const [data] = createSignal<Dashboard>(empty)
+  const eventTime = (event: Event) =>
+    event.endTime ? \`\${event.time}–\${event.endTime}\` : event.time
+  return (
+    <ol>
+      {data().events.map((event) => (
+        <li key={event.id}><time>{eventTime(event)}</time></li>
+      ))}
+    </ol>
+  )
+}
+`)
+    expect(template).toContain(
+      '(bf_ternary (bf_truthy .EndTime) (bf_concat_str (bf_concat_str .Time "–") .EndTime) .Time)',
+    )
+    expect(template).not.toContain('{{.Time}}–{{.EndTime}}')
+  })
+})
+
+// #2863 (pullfrog review on #2877): three more argument/operand positions
+// that reach a template literal without going through `lowerValueOperand`/
+// `emitOperand` — verified to reproduce the identical `unexpected "{" in
+// operand` class of bug before this fix, via a standalone script driving
+// `html/template.Parse` on the pre-fix output.
+describe('GoTemplateAdapter - value-position template literal in condition/array-method/index positions (#2863 follow-up)', () => {
+  // `renderConditionExpr`'s own `binary`/`unary`/`logical` recursion is a
+  // SEPARATE walker from the generic `emit()` dispatcher (it threads a
+  // `preamble` string `emitOperand` doesn't track) — reached whenever a
+  // ternary/`&&`/`||`/`!` TEST is a comparison against (or otherwise
+  // contains) a template literal, since `lowerTernaryTest`/`lowerUrlGuard`'s
+  // "bool-shape" branch routes through `convertConditionToGo` instead of
+  // `lowerValueOperand`.
+  test('a ternary TEST comparing to a template literal folds through bf_concat_str inside the {{if}}', () => {
+    const { template } = compileAndGenerate(`
+'use client'
+import { createSignal } from '@barefootjs/client'
+export function T() {
+  const [x] = createSignal('x')
+  const [y] = createSignal('y')
+  const [z] = createSignal('z')
+  return <span>{(x() === \`\${y()}-\${z()}\`) ? 'a' : 'b'}</span>
+}
+`)
+    expect(template).toContain('{{if eq .X (bf_concat_str (bf_concat_str .Y "-") .Z)}}')
+  })
+
+  // `arrayMethod()`'s per-method cases (`join`, `includes`, `indexOf`, …) all
+  // lower their receiver/args via the dispatcher's plain `emit`, not
+  // `emitOperand` — no ternary or helper-inlining needed to reach the bug.
+  test('Array.join with a template-literal separator folds through bf_concat_str', () => {
+    const { template } = compileAndGenerate(`
+'use client'
+import { createSignal } from '@barefootjs/client'
+export function T() {
+  const [items] = createSignal<string[]>([])
+  const [y] = createSignal('y')
+  const [z] = createSignal('z')
+  return <span>{items().join(\`\${y()}-\${z()}\`)}</span>
+}
+`)
+    expect(template).toContain('bf_join (.Items) (bf_concat_str (bf_concat_str .Y "-") .Z)')
+  })
+
+  // `indexAccess()` lowers both the object and the index via plain `emit`.
+  test('a computed index-access with a template-literal key folds through bf_concat_str', () => {
+    const { template } = compileAndGenerate(`
+'use client'
+import { createSignal } from '@barefootjs/client'
+export function T() {
+  const [obj] = createSignal<Record<string, string>>({})
+  const [y] = createSignal('y')
+  const [z] = createSignal('z')
+  return <span>{obj()[\`\${y()}-\${z()}\`]}</span>
+}
+`)
+    expect(template).toContain('bf_get .Obj (bf_concat_str (bf_concat_str .Y "-") .Z)')
+  })
 })
 
 // #2335 item 2 (correctness): a ternary used as a boolean CONDITION used to
@@ -1486,7 +1641,7 @@ export function Widget(props: P) {
     // 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
+    // resolveModuleStringConst/resolveModuleConstAsGo 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()
@@ -4701,11 +4856,14 @@ export function CompositeRowChildComponent(props: { items: Item[] }) {
   })
 
   // A multi-part template literal (mixed literal text and interpolation,
-  // `` `#${row.id} ${row.label}` ``) has no single-pipeline-value reduction
-  // the way a single-part ternary does — refuse it loudly (BF101) instead
-  // of silently emitting the stale constructor-only value (the #2445 bug
-  // this whole fix exists to close).
-  test('a multi-part template-literal per-row prop is refused with BF101, not silently stale', () => {
+  // `` `#${row.id} ${row.label}` ``) folds through the shared value-operand
+  // door (#2863) — a left-folded `bf_concat_str` chain — instead of being
+  // refused (BF101) the way it used to be here (this call site had no
+  // reduction for the multi-part case before #2863, only a single-part
+  // unwrap). It must still NOT silently emit the stale constructor-only
+  // value (the #2445 bug this whole fix exists to close) — it now emits the
+  // correct live per-row value instead.
+  test('a multi-part template-literal per-row prop folds through bf_concat_str, not silently stale (#2445, #2863)', () => {
     const result = compileJSX(`
 'use client'
 import { createSignal } from '@barefootjs/client'
@@ -4726,9 +4884,11 @@ export function CompositeRowChildComponent(props: { items: Item[] }) {
   )
 }
 `.trimStart(), 'test.tsx', { adapter: new GoTemplateAdapter(), outputIR: false })
-    expect((result.errors ?? []).some(e => e.code === 'BF101')).toBe(true)
+    expect(result.errors ?? []).toEqual([])
     const template = result.files.find(f => f.type === 'markedTemplate')!.content
-    expect(template).not.toContain('bf_with_props')
+    expect(template).toContain(
+      '{{template "Badge" (bf_with_props $.BadgeSlot0 "Text" (bf_concat_str (bf_concat_str (bf_concat_str "#" .ID) " ") .Label))}}',
+    )
   })
 
   // A prop whose expression `convertExpressionToGo` itself refuses (an
@@ -6048,7 +6208,7 @@ export function Nested({ groups }: { groups: { label: string }[][] }) {
 // goes through `identifier()` (the `ParsedExprEmitter` method), which
 // already carries the loop-shadow guards (`loopParamStack` /
 // `isOuterLoopParam`, mirrored from `resolveModuleStringConst` /
-// `resolveModuleNumericConst`). So a `.map((count) => ...)` callback param
+// `resolveModuleConstAsGo`). So a `.map((count) => ...)` callback param
 // that shadows an outer `const count = 7` got the OUTER literal inlined at
 // the `data-key` position even though the text position (which DOES go
 // through `identifier()`) correctly resolved to the per-item value.

package/src/adapter/emit-context.ts

@@ -14,7 +14,7 @@
  * genuinely needs it, so the seam documents the real cross-module coupling.
  */
 
-import type { ParsedExpr } from '@barefootjs/jsx'
+import type { ParsedExpr, TypeInfo } from '@barefootjs/jsx'
 
 import type { CompileState } from './lib/compile-state.ts'
 
@@ -81,16 +81,18 @@ export interface GoEmitContext {
   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`).
+   * Resolve a bare identifier naming a plain module-level const (`const
+   * TRACK = 8`, `const OPEN = true`, `const INITIAL: Row[] = [...]`) to its
+   * Go literal, dispatched structurally off the const's `ConstantInfo.parsed`
+   * — or null when the name is not such a const (loop vars and outer-loop
+   * params are excluded, same as `resolveModuleStringConst`). `target.kind
+   * === 'go-source'` may bake a composite (array/object) literal against
+   * `target.bakeType`; `target.kind === 'template-action'` only resolves a
+   * scalar, since a `{{...}}` splice has no valid Go template spelling for a
+   * composite literal.
    */
-  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
+  resolveModuleConstAsGo(
+    name: string,
+    target: { kind: 'template-action' } | { kind: 'go-source'; bakeType: TypeInfo },
+  ): string | null
 }

package/src/adapter/expr/url-builder.ts

@@ -10,13 +10,14 @@
 import {
   type LoweringNode,
   type ParsedExpr,
+  type TemplatePart,
   parseExpression,
   stringifyParsedExpr,
   isValidHelperId,
 } from '@barefootjs/jsx'
 
 import type { GoEmitContext } from '../emit-context.ts'
-import { wrapIfMultiToken } from '../lib/go-emit.ts'
+import { escapeGoString, wrapIfMultiToken } from '../lib/go-emit.ts'
 
 /**
  * Logical helper id → Go template helper name. `bf_<helper>` is a formula,
@@ -61,7 +62,7 @@ function lowerUrlGuard(ctx: GoEmitContext, g: ParsedExpr): string {
   if (isBoolShape) {
     return ctx.convertConditionToGo(stringifyParsedExpr(g), g).condition
   }
-  const valueGo = wrapIfMultiToken(ctx.convertExpressionToGo(stringifyParsedExpr(g), undefined, g))
+  const valueGo = lowerValueOperand(ctx, g)
   return `ne ${valueGo} ""`
 }
 
@@ -91,21 +92,63 @@ export function lowerTernary(
   alternate: ParsedExpr,
 ): string {
   const t = lowerTernaryTest(ctx, test)
-  return `(bf_ternary ${t} ${lowerTernaryOperand(ctx, consequent)} ${lowerTernaryOperand(ctx, alternate)})`
+  return `(bf_ternary ${t} ${lowerValueOperand(ctx, consequent)} ${lowerValueOperand(ctx, alternate)})`
 }
 
 /**
- * A ternary branch in value position: a nested ternary recurses to another
- * `bf_ternary`; anything else lowers to its Go value (parenthesised when
- * multi-token so it stays one argument). String branches become quoted,
- * html/template-escaped values — not the bare unquoted text the old `{{if}}`
- * fragment path emitted — which is exactly right for the value positions this
- * is reached for.
+ * Lower a template literal to ONE Go pipeline VALUE (#2863): a left fold of
+ * `bf_concat_str` over the parts — static text as an escaped Go string
+ * literal, each interpolation as its own value operand. The TEXT-position
+ * form (`GoTemplateAdapter.templateLiteral()`: literal text interleaved with
+ * `{{…}}` actions) is only legal where the result is spliced directly into
+ * markup; inside another action's argument list (a `bf_ternary` branch, a
+ * helper-call arg, a `bf_query` guard value, …) Go rejects nested `{{`/`}}`
+ * delimiters ("unexpected \"{\" in operand"). This is the Go twin of the
+ * concatenation every other DSL adapter already emits for the same nested
+ * shape (e.g. Jinja/Twig `bf.string(a) ~ '–' ~ bf.string(b)`) — Go was the
+ * lone outlier because `text/template` has no expression-level string
+ * concatenation operator of its own, only this runtime helper (already used
+ * by `binary()`'s string-typed `+`, #2168).
+ *
+ * A single-part literal (`` `${x}` `` alone) reduces to that one value with
+ * no `bf_concat_str` wrapper — mirrors the sibling single-part unwrap at the
+ * child-prop call site. An all-static literal (already reduced to a plain
+ * `literal` ParsedExpr by the parser in practice, but handled here too)
+ * folds to one escaped string.
  */
-function lowerTernaryOperand(ctx: GoEmitContext, n: ParsedExpr): string {
+export function lowerTemplateLiteralValue(ctx: GoEmitContext, parts: readonly TemplatePart[]): string {
+  const terms: string[] = []
+  for (const part of parts) {
+    if (part.type === 'string') {
+      if (part.value !== '') terms.push(`"${escapeGoString(part.value)}"`)
+    } else {
+      terms.push(lowerValueOperand(ctx, part.expr))
+    }
+  }
+  if (terms.length === 0) return '""'
+  return terms.slice(1).reduce((acc, t) => `(bf_concat_str ${acc} ${t})`, terms[0])
+}
+
+/**
+ * The single door for "this ParsedExpr sits in Go pipeline ARGUMENT
+ * position" — a `bf_ternary` branch, a ternary/guard test's value form, a
+ * helper-call arg, a `bf_query` base/guard/value. A nested ternary recurses
+ * to another `bf_ternary`; a template literal folds through
+ * `lowerTemplateLiteralValue` (#2863) rather than the generic expression
+ * path, which would otherwise return the TEXT-position mixed
+ * literal-text-plus-`{{…}}`-actions form; anything else lowers to its Go
+ * value (parenthesised when multi-token so it stays one argument). String
+ * branches become quoted, html/template-escaped values — not the bare
+ * unquoted text the old `{{if}}` fragment path emitted — which is exactly
+ * right for the value positions this is reached for.
+ */
+export function lowerValueOperand(ctx: GoEmitContext, n: ParsedExpr): string {
   if (n.kind === 'conditional') {
     return lowerTernary(ctx, n.test, n.consequent, n.alternate)
   }
+  if (n.kind === 'template-literal') {
+    return wrapIfMultiToken(lowerTemplateLiteralValue(ctx, n.parts))
+  }
   return wrapIfMultiToken(ctx.convertExpressionToGo(stringifyParsedExpr(n), undefined, n))
 }
 
@@ -120,7 +163,7 @@ function lowerTernaryOperand(ctx: GoEmitContext, n: ParsedExpr): string {
  * counterpart of `lowerUrlGuard`'s string-only `ne <value> ""`.
  */
 function lowerTernaryTest(ctx: GoEmitContext, test: ParsedExpr): string {
-  const go = wrapIfMultiToken(ctx.convertExpressionToGo(stringifyParsedExpr(test), undefined, test))
+  const go = lowerValueOperand(ctx, test)
   const isBoolShape =
     (test.kind === 'binary' && BOOL_COMPARISON_OPS.has(test.op)) ||
     (test.kind === 'unary' && test.op === '!') ||
@@ -280,22 +323,14 @@ function ternaryHasQueryBranch(
 function renderLoweringNode(ctx: GoEmitContext, node: LoweringNode): string | null {
   const helper = goHelperName(node.helper)
   if (!helper) return null
-  const lowerExpr = (n: ParsedExpr): string =>
-    ctx.convertExpressionToGo(stringifyParsedExpr(n), undefined, n)
-  // A `conditional` in ARGUMENT position lowers to the pipeline-position
-  // `(bf_ternary …)` form via the shared `lowerTernary` (#2335) — the same
-  // form the ParsedExpr `conditional()` emitter and the condition-expression
-  // emitter produce. Routing it here explicitly (rather than leaning on the
-  // generic `lowerExpr`, whose `conditional()` dispatch now reaches the very
-  // same helper) keeps the arg lowering self-contained and its intent local;
-  // `lowerTernary` itself right-folds a nested chain (the #2324 union stage's
-  // locale→pattern table) into `(bf_ternary <cond> <a> (bf_ternary …))`.
-  const lowerArg = (n: ParsedExpr): string =>
-    n.kind === 'conditional'
-      ? lowerTernary(ctx, n.test, n.consequent, n.alternate)
-      : wrapIfMultiToken(lowerExpr(n))
+  // Every argument here is Go pipeline ARGUMENT position — a `conditional`
+  // lowers to `(bf_ternary …)`, a `template-literal` folds through
+  // `bf_concat_str` (#2863) rather than leaking the TEXT-position
+  // `{{…}}`-actions form into this call's argument list, anything else takes
+  // the generic value path. `lowerValueOperand` is the one shared door every
+  // such position in this file now goes through.
   if (node.kind === 'helper-call') {
-    const args = node.args.map(a => lowerArg(a))
+    const args = node.args.map(a => lowerValueOperand(ctx, a))
     return [helper, ...args].join(' ')
   }
   // guard-list — `queryHref`-shaped. Inclusion mirrors the client exactly, where
@@ -304,12 +339,12 @@ function renderLoweringNode(ctx: GoEmitContext, node: LoweringNode): string | nu
   //   - plain `key: v` (guard null)        → `(true) "key" v`
   //   - conditional `key: cond ? a : <omit>` → `(<cond>) "key" a`, where the
   //     non-empty check is done by bf_query, not folded into the guard.
-  const parts: string[] = [wrapIfMultiToken(lowerExpr(node.base))]
+  const parts: string[] = [lowerValueOperand(ctx, node.base)]
   for (const t of node.triples) {
     const includeGo = t.guard === null ? 'true' : lowerUrlGuard(ctx, t.guard)
     parts.push(`(${includeGo})`)
     parts.push(JSON.stringify(t.key))
-    parts.push(wrapIfMultiToken(lowerExpr(t.value)))
+    parts.push(lowerValueOperand(ctx, t.value))
   }
   return `${helper} ${parts.join(' ')}`
 }