@barefootjs/go-template 0.31.0 → 0.31.2

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

@@ -17,7 +17,7 @@ import type { GoEmitContext } from '../emit-context.ts'
 import type { PropFallbackVar } from '../lib/types.ts'
 import { capitalizeFieldName } from '../lib/go-naming.ts'
 import { escapeGoString } from '../lib/go-emit.ts'
-import { parsedLiteralToGo } from './parsed-literal-to-go.ts'
+import { numberLiteralRawGo, parsedLiteralToGo } from './parsed-literal-to-go.ts'
 import { collapseLiteralUnion } from '../type/type-codegen.ts'
 
 /** Default for `getSignalInitialValueAsGo`'s optional fallback-var map. */
@@ -40,16 +40,25 @@ const EMPTY_PROP_FALLBACK_VARS: ReadonlyMap<string, PropFallbackVar> = new Map()
  * undefined` half is source-level documentation of nullability, not a
  * Go-representable branch, so it's unwrapped to its single non-
  * undefined/null primitive branch.
+ *
+ * `param.name` is the LOCAL binding — `nillablePropNames` (a source-level
+ * analysis set, `collectNillablePropNames`) stays keyed by it — while the
+ * emitted `in.<Field>` reference is caller-facing (`sourceName ?? name`,
+ * #2525), so the two must resolve separately rather than off one name.
  */
-function nillableAwarePropRef(ctx: GoEmitContext, propName: string, expectedType: TypeInfo): string {
-  const fieldRef = `in.${capitalizeFieldName(propName)}`
+function nillableAwarePropRef(
+  ctx: GoEmitContext,
+  param: { name: string; sourceName?: string },
+  expectedType: TypeInfo,
+): string {
+  const fieldRef = `in.${capitalizeFieldName(param.sourceName ?? param.name)}`
   const scalar =
     expectedType.kind === 'primitive'
       ? expectedType
       : expectedType.kind === 'union' && expectedType.unionTypes?.length === 2
         ? expectedType.unionTypes.find(t => t.primitive !== 'undefined' && t.primitive !== 'null')
         : undefined
-  if (ctx.state.nillablePropNames.has(propName) && scalar?.kind === 'primitive') {
+  if (ctx.state.nillablePropNames.has(param.name) && scalar?.kind === 'primitive') {
     const goType =
       scalar.primitive === 'boolean' ? 'bool' :
       scalar.primitive === 'number' ? 'float64' :
@@ -70,41 +79,62 @@ export function convertInitialValue(
   ctx: GoEmitContext,
   value: string,
   _typeInfo: TypeInfo,
-  propsParams?: { name: string }[],
+  propsParams?: { name: string; sourceName?: 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)
+  const propRef = (param: { name: string; sourceName?: string }): string =>
+    nillableAwarePropRef(ctx, param, typeInfo)
 
   if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(value)) {
-    if (propsParams?.some(p => p.name === value)) {
-      return propRef(value)
+    const param = propsParams?.find(p => p.name === value)
+    if (param) {
+      return propRef(param)
     }
   }
 
   const propName = ctx.extractPropNameFromInitialValue(value, preParsed)
-  if (propName && propsParams?.some(p => p.name === propName)) {
-    return propRef(propName)
+  const param = propName ? propsParams?.find(p => p.name === propName) : undefined
+  if (param) {
+    return propRef(param)
   }
 
   if (typeInfo.kind === 'primitive') {
     if (typeInfo.primitive === 'boolean') {
+      // Structural first: the SAME initial value, already parsed
+      // (`SignalInfo.parsed`/module-const `parsed`) — text-matching
+      // `value === 'true'` is the fallback for a caller with no `preParsed`
+      // (an unsupported shape `tsNodeToParsedExpr` couldn't represent).
+      if (preParsed?.kind === 'literal' && preParsed.literalType === 'boolean' && typeof preParsed.value === 'boolean') {
+        return preParsed.value ? 'true' : 'false'
+      }
       return value === 'true' ? 'true' : 'false'
     }
     if (typeInfo.primitive === 'number') {
-      // Leading `-` (#2168 math-methods: `createSignal(-7.6)`) — without it,
-      // a negative initial value never matches either literal shape below
-      // and silently falls to the `0` zero-value fallback, regardless of the
-      // field's Go type.
+      // Structural first — `numberLiteralRawGo` unwraps a leading unary minus
+      // (#2168 math-methods: `createSignal(-7.6)`) off the literal's OWN
+      // `raw` token (exact source spelling, never a re-stringified value).
+      const numGo = preParsed ? numberLiteralRawGo(preParsed) : null
+      if (numGo !== null) return numGo
+      // Text fallback for a caller with no `preParsed`. Leading `-` handled
+      // the same way (without it, a negative initial value never matches
+      // either literal shape below and silently falls to the `0`
+      // zero-value fallback, regardless of the field's Go type).
       if (/^-?\d+$/.test(value)) return value
       if (/^-?\d+\.\d+$/.test(value)) return value
       return '0'
     }
     if (typeInfo.primitive === 'string') {
-      if (value.startsWith("'") || value.endsWith("'")) {
+      // Structural first: `JSON.stringify` re-quotes/escapes the literal's
+      // unquoted `value` for Go — correct for any embedded quote/backslash,
+      // unlike the text fallback's blind `'` → `"` swap below.
+      if (preParsed?.kind === 'literal' && preParsed.literalType === 'string' && typeof preParsed.value === 'string') {
+        return JSON.stringify(preParsed.value)
+      }
+      if (value.startsWith("'") && value.endsWith("'")) {
         return value.replace(/'/g, '"')
       }
       if (value.startsWith('"') && value.endsWith('"')) {
@@ -227,24 +257,28 @@ export function objectLiteralToGoMap(ctx: GoEmitContext, expr: ParsedExpr): stri
 export function getSignalInitialValueAsGo(
   ctx: GoEmitContext,
   initialValue: string,
-  propsParams: { name: string }[],
+  propsParams: { name: string; sourceName?: string }[],
   propFallbackVars: ReadonlyMap<string, PropFallbackVar> = EMPTY_PROP_FALLBACK_VARS,
   signalType?: TypeInfo,
 ): string {
-  const propRef = (propName: string): string =>
-    signalType ? nillableAwarePropRef(ctx, propName, signalType) : `in.${capitalizeFieldName(propName)}`
+  const propRef = (param: { name: string; sourceName?: string }): string =>
+    signalType
+      ? nillableAwarePropRef(ctx, param, signalType)
+      : `in.${capitalizeFieldName(param.sourceName ?? param.name)}`
 
-  if (propsParams.some(p => p.name === initialValue)) {
+  const directParam = propsParams.find(p => p.name === initialValue)
+  if (directParam) {
     const hoisted = propFallbackVars.get(initialValue)
     if (hoisted) return hoisted.varName
-    return propRef(initialValue)
+    return propRef(directParam)
   }
 
   const propName = ctx.extractPropNameFromInitialValue(initialValue)
-  if (propName && propsParams.some(p => p.name === propName)) {
-    const hoisted = propFallbackVars.get(propName)
+  const param = propName ? propsParams.find(p => p.name === propName) : undefined
+  if (param) {
+    const hoisted = propFallbackVars.get(propName!)
     if (hoisted) return hoisted.varName
-    return propRef(propName)
+    return propRef(param)
   }
 
   // single quotes are normalized to Go double quotes
@@ -320,7 +354,7 @@ function resolveMapJoinBaseAsGo(
   ctx: GoEmitContext,
   object: ParsedExpr,
   signals: { getter: string; initialValue: string; type?: TypeInfo; parsed?: ParsedExpr }[],
-  propsParams: { name: string }[],
+  propsParams: { name: string; sourceName?: string }[],
 ): string | null {
   if (object.kind === 'call' && object.callee.kind === 'identifier' && object.args.length === 0) {
     const calleeName = object.callee.name
@@ -337,8 +371,9 @@ function resolveMapJoinBaseAsGo(
       : object.kind === 'identifier'
         ? object.name
         : null
-  if (propName && propsParams.some(p => p.name === propName)) {
-    return `in.${capitalizeFieldName(propName)}`
+  const param = propName ? propsParams.find(p => p.name === propName) : undefined
+  if (param) {
+    return `in.${capitalizeFieldName(param.sourceName ?? param.name)}`
   }
 
   if (object.kind === 'array-literal') {
@@ -376,7 +411,7 @@ export function mapJoinChainToGo(
   ctx: GoEmitContext,
   chain: { object: ParsedExpr; arrow: Extract<ParsedExpr, { kind: 'arrow' }>; sepArg?: ParsedExpr },
   signals: { getter: string; initialValue: string; type?: TypeInfo; parsed?: ParsedExpr }[],
-  propsParams: { name: string }[],
+  propsParams: { name: string; sourceName?: string }[],
   propFallbackVars: ReadonlyMap<string, PropFallbackVar>,
 ): string | null {
   const itemsGo = resolveMapJoinBaseAsGo(ctx, chain.object, signals, propsParams)
@@ -393,11 +428,12 @@ export function mapJoinChainToGo(
   for (const name of freeVars) {
     const sig = signals.find(s => s.getter === name)
     let goExpr: string | null = null
+    const freeVarParam = propsParams.find(p => p.name === name)
     if (sig) {
       goExpr = getSignalInitialValueAsGo(ctx, sig.initialValue, propsParams, propFallbackVars, sig.type)
-    } else if (propsParams.some(p => p.name === name)) {
+    } else if (freeVarParam) {
       const hoisted = propFallbackVars.get(name)
-      goExpr = hoisted ? hoisted.varName : `in.${capitalizeFieldName(name)}`
+      goExpr = hoisted ? hoisted.varName : `in.${capitalizeFieldName(freeVarParam.sourceName ?? name)}`
     }
     if (goExpr === null) return null
     envEntries.push(`${JSON.stringify(name)}: ${goExpr}`)

package/src/render-divergences.ts

@@ -12,6 +12,12 @@
  * fixture-divergences section of `ui/compat.lock.json` — surfaced on
  * the docs compatibility-matrix page. Graduating an entry means fixing
  * the adapter (or the shared compiler layer) and deleting the line.
+ *
+ * Empty — the file's last live entry (`aliased-destructured-prop`, #2525)
+ * graduated: the Input struct field is now keyed by `sourceName ?? name`
+ * (caller-facing), so the caller-side composite literal `go run`s clean.
+ * Keep the file (and this header) when the set is empty — the next
+ * divergence lands here, not in a re-created file.
  */
 
 import type { RenderDivergences } from '@barefootjs/jsx'
@@ -29,19 +35,4 @@ export const renderDivergences: RenderDivergences = {
   // production). `buildDynamicChildLoopSeeding` (this package's
   // `test-render.ts`) now replicates that documented contract for a
   // signal-backed dynamic child-component loop.
-
-  // Onboarding TSX-fidelity fixtures (PR #2461): `expectedHtml` was
-  // hand-authored to the CORRECT output while the emission bug lived in
-  // the shared compiler layer — every adapter, including the Hono
-  // reference, used to emit the broken form. That shared-layer defect
-  // (#2460) is now FIXED (b4f5075): `expectedHtml` is generated from the
-  // Hono reference like any other fixture. The remaining gap is
-  // Go-specific — the Input struct field stays keyed by the local
-  // binding instead of `sourceName ?? name`, so the caller-side struct
-  // literal fails `go run` outright — tracked by #2525 (go-template's
-  // `go run` exit-1 failure). Graduate by keying the Input struct field
-  // by `sourceName ?? name` and deleting this line (and the matching
-  // hono `skipJsx` entry, already gone).
-  '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/2525)',
 }

package/src/test-render.ts

@@ -673,7 +673,12 @@ function buildGoPropsInit(
   // declared params are `className` / `type`) emits a top-level
   // `Placeholder:` initializer and Go fails with `unknown field Placeholder
   // in struct literal of type InputInput`. (#1467 Phase 2b)
-  const declaredParams = new Set((ir?.metadata.propsParams ?? []).map(p => p.name))
+  // `key` is caller-facing (what the fixture's caller supplied), so this
+  // set must be built from `sourceName ?? name` — a local-only set routes
+  // an aliased param into the rest bag.
+  const declaredParams = new Set(
+    (ir?.metadata.propsParams ?? []).map(p => p.sourceName ?? p.name),
+  )
   const restPropsName = ir?.metadata.restPropsName ?? null
   const restBagField = restPropsName ? capitalizeFieldName(restPropsName) : null