@barefootjs/go-template 0.35.1 → 0.35.3

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

@@ -262,8 +262,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     extractPropFallback: (initialValue, preParsed) => this.extractPropFallback(initialValue, preParsed),
     extractCollisionDerivation: (parsed) => this.extractCollisionDerivation(parsed),
     resolveModuleStringConst: (name) => this.resolveModuleStringConst(name),
-    resolveModuleNumericConst: (name) => this.resolveModuleNumericConst(name),
-    resolveModuleBooleanConst: (name) => this.resolveModuleBooleanConst(name),
+    resolveModuleConstAsGo: (name, target) => this.resolveModuleConstAsGo(name, target),
   }
 
   /** Diagnostics from the current compile (backed by `CompileState`); `generate()` also merges these into `ir.errors`. */
@@ -4726,11 +4725,12 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     }
     const inlined = this.resolveModuleStringConst(name)
     if (inlined !== null) return inlined
-    // Module numeric const (e.g. `const TRACK = 8` used in a width expression):
-    // inline the literal value rather than emit `{{.TRACK}}` against a Props
-    // field that never exists. Mirrors the string-const inlining above.
-    const inlinedNum = this.resolveModuleNumericConst(name)
-    if (inlinedNum !== null) return inlinedNum
+    // Module scalar const (e.g. `const TRACK = 8` used in a width expression,
+    // or `const OPEN = true`): inline the literal value rather than emit
+    // `{{.TRACK}}` against a Props field that never exists. Mirrors the
+    // string-const inlining above.
+    const inlinedScalar = this.resolveModuleConstAsGo(name, { kind: 'template-action' })
+    if (inlinedScalar !== null) return inlinedScalar
     if (this.isCurrentLoopItem(name)) return '.'
     // An *outer* loop's value variable (we're in a nested loop) is in scope as
     // the Go range variable `$name` declared by that loop's `{{range … := …}}`;
@@ -4866,19 +4866,41 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
    * rebinds. Outside any loop the root *is* the dot, so we emit `.Field`.
    */
   private rootFieldRef(name: string): string {
-    // #2813 / #2788: `name` may be a bare local-const alias of a
-    // signal/memo getter (`const items__alias = items`) or a bare-props-
-    // form body destructure's renamed prop (`const { children: kids } =
-    // props`) — resolve it to the ALIASED entity's own name FIRST, so the
-    // emitted field matches what that entity itself seeds (`.Items`,
-    // `.Children`) instead of registering a second, never-populated field
-    // under the local alias (`.Items__alias`, `.Kids`).
-    const resolved = this.state.getterAliases.get(name) ?? this.state.propDestructureAliases.get(name) ?? name
+    const resolved = this.resolveRootFieldAlias(name)
     this.state.templateReadRootFields.add(resolved)
     const prefix = this.inLoop ? '$.' : '.'
     return `${prefix}${capitalizeFieldName(resolved)}`
   }
 
+  /**
+   * #2813 / #2788: `name` may be a bare local-const alias of a signal/memo
+   * getter (`const items__alias = items`) or a bare-props-form body
+   * destructure's renamed prop (`const { children: kids } = props`) —
+   * resolve it to the ALIASED entity's own name, so a caller that needs to
+   * build its own prefixed field reference (e.g. `renderFilterExprNode`,
+   * which must hardcode `$.` regardless of `rootFieldRef`'s
+   * `this.inLoop`-conditional prefix — #2857) still lands on the field that
+   * entity itself seeds (`.Items`, `.Children`) instead of a never-populated
+   * field under the local alias (`.Items__alias`, `.Kids`). `rootFieldRef`
+   * itself is built on top of this so there is exactly one resolution.
+   */
+  private resolveRootFieldAlias(name: string): string {
+    return this.state.getterAliases.get(name) ?? this.state.propDestructureAliases.get(name) ?? name
+  }
+
+  /**
+   * Root-scope field reference from INSIDE a `.filter()`/`.find()` predicate
+   * (#2857, #2879). Same registration + alias resolution as `rootFieldRef`,
+   * but the `$.` prefix is unconditional: a filter predicate's `{{if}}`
+   * always sits inside its loop's own `{{range}}` (`renderLoop` restores
+   * `this.inLoop` before rendering it), so a bare `.Field` would resolve
+   * against the current row's type instead of root.
+   */
+  private filterRootFieldRef(name: string): string {
+    this.rootFieldRef(name)
+    return `$.${capitalizeFieldName(this.resolveRootFieldAlias(name))}`
+  }
+
   /**
    * When `name` is a local binding of the `searchParams()` env signal, resolve
    * it to the canonical `.SearchParams` field — not `.<Capitalized name>` — so
@@ -4926,13 +4948,10 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   }
 
   /**
-   * The single module-const lookup shared by `resolveModuleNumericConst`
-   * and `resolveModuleBooleanConst` — they differ only in which literal
-   * SHAPE they accept from the same "plain module-level const" search, not
-   * in how that search is performed. A second inline lookup per resolver
-   * would grow `binding-scope-ratchet.test.ts`'s shrink-only floor for this
-   * file (already at 5) for a shape variance the callers can express
-   * themselves instead.
+   * The single module-const lookup shared by `resolveModuleConstAsGo` —
+   * kept as its own method (rather than inlined) so a second `.find(` isn't
+   * added elsewhere, growing `binding-scope-ratchet.test.ts`'s shrink-only
+   * floor for this file (already at 5).
    */
   private findModuleConst(name: string): ConstantInfo | undefined {
     return this.state.localConstants.find(
@@ -4941,40 +4960,50 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   }
 
   /**
-   * Inline a module-level numeric const (`const TRACK = 8`) as its literal
-   * value. Only a plain numeric initializer qualifies — anything computed or
-   * non-numeric falls through to the normal field/ident resolution. Scoped to
-   * module consts (like the string variant) and guarded against loop vars so a
-   * range variable that shadows a const name still wins.
-   */
-  private resolveModuleNumericConst(name: string): string | null {
-    if (this.isCurrentLoopItem(name)) return null
-    if (this.loopVarRefCount.has(name)) return null
-    if (this.isOuterLoopParam(name)) return null
-    const c = this.findModuleConst(name)
-    if (!c || c.value === undefined) return null
-    // `value` is reconstructed from source text, so a valid TS literal may carry
-    // numeric separators (`100_000`). Strip them between digits, then accept a
-    // plain decimal / float; Go template numeric literals don't allow `_`.
-    const v = c.value.trim().replace(/(?<=\d)_(?=\d)/g, '')
-    return /^-?\d+(\.\d+)?$/.test(v) ? v : null
-  }
-
-  /**
-   * Inline a module-level boolean const (`const OPEN = true`) as its Go
-   * literal (`true`/`false`). Only a plain `true`/`false` initializer
-   * qualifies (#2815) — mirrors `resolveModuleNumericConst`'s shape, sharing
-   * its lookup rather than adding a second `.find(` (see
-   * `findModuleConst`'s docstring).
+   * Resolve a bare identifier naming a plain module-level const (`const
+   * TRACK = 8`, `const OPEN = true`, `const INITIAL: Row[] = [...]`, #2794 /
+   * #2815 / #2862) to its value's Go literal — dispatched STRUCTURALLY off
+   * `ConstantInfo.parsed`, through the same `parsedLiteralToGo` door an
+   * inline `createSignal([...])`/`createSignal({...})` seed already takes,
+   * rather than a separate per-type text-matching resolver for each literal
+   * shape (the numeric/boolean resolvers this replaces, and the array/
+   * object-literal gap #2862 tracked, were exactly that repeated pattern).
+   * `resolveModuleStringConst` stays separate: its fixed-point text
+   * resolution also covers a COMPOSED template-literal const (`` `${A}-${B}`
+   * ``) that has no single structural literal to bake.
+   *
+   * `target` names the emission position, which constrains what can resolve
+   * there:
+   *   - `go-source` (the `New<Component>Props` constructor) may bake a
+   *     composite (array/object) literal against `bakeType` — falling back
+   *     to the const's OWN declared type when the consumer's type is
+   *     `unknown` (the analyzer's inference is text-shaped and never chases
+   *     a bare `createSignal(INITIAL)` seed to its declaration).
+   *   - `template-action` (a bare `{{...}}` splice, e.g. a className
+   *     expression) has no valid Go template spelling for a composite
+   *     literal, so only a scalar (or unary-minus number) resolves there —
+   *     the same restriction the numeric/boolean resolvers already had.
+   *
+   * Scoped to module consts and guarded against loop vars so a range
+   * variable that shadows a const name still wins (same guards the
+   * resolvers this replaces already had).
    */
-  private resolveModuleBooleanConst(name: string): string | null {
+  private resolveModuleConstAsGo(
+    name: string,
+    target: { kind: 'template-action' } | { kind: 'go-source'; bakeType: TypeInfo },
+  ): string | null {
     if (this.isCurrentLoopItem(name)) return null
     if (this.loopVarRefCount.has(name)) return null
     if (this.isOuterLoopParam(name)) return null
     const c = this.findModuleConst(name)
-    if (!c || c.value === undefined) return null
-    const v = c.value.trim()
-    return v === 'true' || v === 'false' ? v : null
+    if (!c?.parsed) return null
+    if (target.kind === 'template-action') {
+      return c.parsed.kind === 'literal' || c.parsed.kind === 'unary'
+        ? parsedLiteralToGo(this.emitCtx, c.parsed)
+        : null
+    }
+    const bakeType = target.bakeType.kind !== 'unknown' ? target.bakeType : (c.type ?? undefined)
+    return parsedLiteralToGo(this.emitCtx, c.parsed, bakeType)
   }
 
   literal(value: string | number | boolean | null, literalType: LiteralType): string {
@@ -6212,12 +6241,28 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
           // prefix because a filter predicate must always escape back to
           // root regardless of loop nesting; call it only for its
           // registration side effect and keep the prefix here (pullfrog
-          // review, PR #2818).
-          this.rootFieldRef(signal)
-          return `$.${capitalizeFieldName(signal)}`
+          // review, PR #2818). The field name itself DOES go through
+          // `resolveRootFieldAlias` (#2857) so a getter-alias local
+          // (`const items__alias = items`) still emits the field the
+          // signal itself seeds instead of a phantom `.Items__alias`.
+          return this.filterRootFieldRef(signal)
         }
-        this.rootFieldRef(expr.name)
-        return `.${capitalizeFieldName(expr.name)}`
+        // Any other identifier reaching here is ALSO a root-scope
+        // reference (a memo, a plain derived const, or — #2857 — a
+        // bare-props-form destructured/renamed prop) rather than the
+        // loop's own param, so it needs the same unconditional `$.`
+        // escape as the signal branch above, for the same reason: a
+        // `.filter().map()` JSX loop's `{{if}}` gate (built from
+        // `loop.filterPredicate` a few hundred lines below, via
+        // `renderPredicateCondition` → this method) always sits inside
+        // that loop's own `{{range}}`, never at the template's un-rebound
+        // root, so `rootFieldRef`'s own `this.inLoop`-conditional prefix
+        // would be wrong here even without the alias bug — a bare
+        // `.Field` resolves against the CURRENT LOOP ITEM's type, not
+        // root, and `html/template` panics at execute time (`can't
+        // evaluate field ... in type ...`) the first time such a
+        // reference is exercised.
+        return this.filterRootFieldRef(expr.name)
       }
 
       case 'literal':
@@ -6234,6 +6279,18 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         if (expr.object.kind === 'identifier' && expr.object.name === param) {
           return `${paramPrefix}.${capitalizeFieldName(expr.property)}`
         }
+        // props.x on a bare-props-form component (#2879): props are
+        // flattened onto the root struct, so this is a root-scope read
+        // (`$.X`), not `.Props.X`. Mirrors `renderConditionExpr`'s own
+        // `propsObjectName` branch; `props.a.b` still reaches root through
+        // the generic recursion below.
+        if (
+          expr.object.kind === 'identifier' &&
+          this.state.propsObjectName &&
+          expr.object.name === this.state.propsObjectName
+        ) {
+          return this.filterRootFieldRef(expr.property)
+        }
         // `.length` on a higher-order filter result (e.g.
         // `x.tags.filter(t => t.active).length > 0`). Reuse
         // `renderFilterLengthExpr` so the inner filter lowers to
@@ -6262,11 +6319,11 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
           return `${paramPrefix}.${capitalizeFieldName(expr.callee.property)}`
         }
         // Signal calls: `filter()` -> `$.Filter`. Same registration-only
-        // `rootFieldRef` call as the `identifier` case above, for the same
+        // `rootFieldRef` call — and the same `resolveRootFieldAlias` field
+        // resolution (#2857) — as the `identifier` case above, for the same
         // reason (#2700's BF101 gate; pullfrog review, PR #2818).
         if (expr.callee.kind === 'identifier' && expr.args.length === 0) {
-          this.rootFieldRef(expr.callee.name)
-          return `$.${capitalizeFieldName(expr.callee.name)}`
+          return this.filterRootFieldRef(expr.callee.name)
         }
         // A nested callback method call (`other.some(r => …)`) reaching this
         // arm has no Go template form in filter context — the fallthrough
@@ -6302,30 +6359,50 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         if (this.filterExprUnsupported) return 'false'
         const right = this.renderFilterExpr(expr.right, param, localVarMap, datumField)
         if (this.filterExprUnsupported) return 'false'
+        // #2873 (pullfrog review, PR #2882): every case below is a prefix
+        // function call (`bf_mod a b`, `eq a b`, …), so a COMPOUND operand —
+        // itself a nested binary result like `bf_mod .N 2` — must be
+        // parenthesised or the template parser folds its tokens into the
+        // outer call's argument list (`eq bf_mod .N 2 0` hands `eq` four
+        // args, and a bare func-name argument like `bf_mod` there is called
+        // with ZERO args instead of nested: `wrong number of args for
+        // bf_mod: want 2 got 0`). Mirrors the general (non-filter) binary
+        // emitter's `wl`/`wr` wrapping (`wrapIfMultiToken`, above) — this
+        // switch had never applied it, so `-`/`*`/`/` had the identical
+        // pre-existing gap for a nested compound operand.
+        const wl = wrapIfMultiToken(left)
+        const wr = wrapIfMultiToken(right)
 
         switch (expr.op) {
           case '===':
           case '==':
-            return `eq ${left} ${right}`
+            return `eq ${wl} ${wr}`
           case '!==':
           case '!=':
-            return `ne ${left} ${right}`
+            return `ne ${wl} ${wr}`
           case '>':
-            return `gt ${left} ${right}`
+            return `gt ${wl} ${wr}`
           case '<':
-            return `lt ${left} ${right}`
+            return `lt ${wl} ${wr}`
           case '>=':
-            return `ge ${left} ${right}`
+            return `ge ${wl} ${wr}`
           case '<=':
-            return `le ${left} ${right}`
+            return `le ${wl} ${wr}`
           case '+':
-            return this._emitPlus(expr.left, expr.right, left, right)
+            return this._emitPlus(expr.left, expr.right, wl, wr)
           case '-':
-            return `bf_sub ${left} ${right}`
+            return `bf_sub ${wl} ${wr}`
           case '*':
-            return `bf_mul ${left} ${right}`
+            return `bf_mul ${wl} ${wr}`
           case '/':
-            return `bf_div ${left} ${right}`
+            return `bf_div ${wl} ${wr}`
+          case '%':
+            // #2873: mirrors the general binary emitter's `%` case (below,
+            // `bf_mod`) — this switch previously had no `%` case, so the
+            // `default` arm emitted a literal ` % ` into the template text,
+            // which `html/template` can't parse (`unexpected "%" in
+            // operand`).
+            return `bf_mod ${wl} ${wr}`
           default:
             return `${left} ${expr.op} ${right}`
         }
@@ -6571,7 +6648,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
    * `loopVarRefCount` — so both are still consulted. Shared by the
    * string-keyed fast paths (#2236, #2242 Copilot review) that resolve raw
    * `jsExpr` text before `identifier()`'s own guards can see it. Mirrors the
-   * checks in `resolveModuleStringConst` / `resolveModuleNumericConst`.
+   * checks in `resolveModuleStringConst` / `resolveModuleConstAsGo`.
    */
   private isLoopShadowedName(name: string): boolean {
     return this.scope.isBound(name) || this.loopVarRefCount.has(name)
@@ -7127,6 +7204,15 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
             result = `bf_mul ${left} ${right}`; break
           case '/':
             result = `bf_div ${left} ${right}`; break
+          case '%':
+            // #2873: this switch had no `%` case even though
+            // `needsParensInGoTemplate` (above) already treats `%` as an
+            // arithmetic operator needing parens — so the `default` arm
+            // below emitted a literal ` % ` into a ternary/condition's
+            // template text, which `html/template` can't parse
+            // (`unexpected "%" in operand`). Mirrors the general binary
+            // emitter's `%` case (`bf_mod`, outside condition position).
+            result = `bf_mod ${left} ${right}`; break
           default:
             result = `${left} ${expr.op} ${right}`
         }

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

@@ -7,7 +7,7 @@
  * function over `ir.metadata`; no adapter instance state.
  */
 
-import { collectLoopBoundNames, type ComponentIR, type TypeInfo } from '@barefootjs/jsx'
+import { collectLoopBoundNames, resolveBodyDestructuredPropAliases, type ComponentIR, type TypeInfo } from '@barefootjs/jsx'
 
 /** True when `type` is the `string` primitive. */
 function isStringTypeInfo(type: TypeInfo): boolean {
@@ -49,6 +49,19 @@ function isBareStringLiteral(initialValue: string | undefined): boolean {
  * 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.
+ *
+ * A bare-props-form component's BODY-destructured, RENAMED prop (`const {
+ * fallbackLabel: skipLabel } = props`, the #2788 alias family) has no
+ * `propsParams` entry of its own — `propsParams` only carries the TYPE-level,
+ * caller-facing names, and the local alias never appears there. Without the
+ * alias resolved here too, a string-typed prop referenced only under its
+ * local rename in a `+` concat (`greeting + skipLabel`) is invisible to this
+ * witness, so `isStringConcatBinary` falls through to numeric `bf_add`
+ * instead of `bf_concat_str` (#2894, the go-template sibling of #2883's
+ * Mojolicious fix). `resolveBodyDestructuredPropAliases` already recognizes
+ * this exact destructuring shape; reusing it here keeps this one witness the
+ * single source of truth `_isStringValueName` reads, rather than growing a
+ * second, adapter-local alias lookup.
  */
 export function collectStringValueNames(ir: ComponentIR): Set<string> {
   const names = new Set<string>()
@@ -60,6 +73,12 @@ export function collectStringValueNames(ir: ComponentIR): Set<string> {
   for (const p of ir.metadata.propsParams) {
     if (isStringTypeInfo(p.type)) names.add(p.name)
   }
+  for (const [local, callerKey] of resolveBodyDestructuredPropAliases(
+    ir.metadata.localConstants ?? [],
+    ir.metadata.propsObjectName,
+  )) {
+    if (names.has(callerKey)) names.add(local)
+  }
   for (const c of ir.metadata.localConstants) {
     if ((c.type !== null && isStringTypeInfo(c.type)) || isBareStringLiteral(c.value)) {
       names.add(c.name)

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

@@ -94,9 +94,10 @@ export function convertInitialValue(
     if (param) {
       return propRef(param)
     }
-    // Module-const seed (#2794): a signal seeded from a bare identifier
-    // that refers to a module-level const (`const PAYLOAD = 'x';
-    // createSignal(PAYLOAD)`) types `unknown` — the analyzer's type
+    // Module-const seed (#2794/#2815/#2862): a signal seeded from a bare
+    // identifier that refers to a module-level const (`const PAYLOAD = 'x';
+    // createSignal(PAYLOAD)`, or `const INITIAL: Row[] = [...];
+    // createSignal(INITIAL)`) types `unknown` — the analyzer's type
     // inference is text-shaped and never chases an identifier to its
     // declaration — so none of the typed branches below ever see it and
     // this used to fall through to the final `nil`. Checked AFTER the
@@ -107,10 +108,8 @@ export function convertInitialValue(
     // leaving that case on the pre-existing `nil` path unchanged.
     const inlinedStr = ctx.resolveModuleStringConst(value)
     if (inlinedStr !== null) return inlinedStr
-    const inlinedNum = ctx.resolveModuleNumericConst(value)
-    if (inlinedNum !== null) return inlinedNum
-    const inlinedBool = ctx.resolveModuleBooleanConst(value)
-    if (inlinedBool !== null) return inlinedBool
+    const inlinedConst = ctx.resolveModuleConstAsGo(value, { kind: 'go-source', bakeType: typeInfo })
+    if (inlinedConst !== null) return inlinedConst
   }
 
   const propName = ctx.extractPropNameFromInitialValue(value, preParsed)

package/src/conformance-pins.ts

@@ -101,4 +101,19 @@ export const conformancePins: ConformancePins = {
   // resolves the primitive normally and never reaches this refusal (formerly
   // tracked as #2771, closed) — no open issue tracks further work.
   'namespace-import-primitive': [{ code: 'BF013', severity: 'error' }],
+  // #2893: `analyzeBakeableStaticElementLoop`'s static-array bake (Go's only
+  // path to bind a static/non-signal array as a loop source — `html/template`
+  // has no slice literal syntax) bails the WHOLE loop when the body contains
+  // a nested `loop` node (module docstring, `static-element-loop-bake.ts`).
+  // This fixture's outer static array's row has a nested `.map()` over
+  // `item.children`, so it falls through to the generic "computed loop
+  // array" BF101 refusal. Unrelated to #2798's own fix (a client-JS-only
+  // ref/reactive-binding gap) — this is a pre-existing Go-adapter SSR
+  // static-loop-baking scope boundary the new fixture happened to be the
+  // first to exercise.
+  'static-nested-loop-ref': [{
+    code: 'BF101',
+    severity: 'error',
+    issue: 'https://github.com/piconic-ai/barefootjs/issues/2893',
+  }],
 }