@barefootjs/go-template 0.18.7 → 0.19.0

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

@@ -6,6 +6,7 @@
  */
 
 import type { ComponentIR, IRMetadata, IRNode, ParsedExpr } from '@barefootjs/jsx'
+import { isBooleanAttr } from '@barefootjs/jsx'
 
 import type { GoEmitContext } from '../emit-context.ts'
 import { typeInfoToGo } from '../type/type-codegen.ts'
@@ -20,7 +21,7 @@ export function buildPropTypeOverrides(ctx: GoEmitContext, ir: ComponentIR): Map
   const overrides = new Map<string, string>()
   for (const signal of ir.metadata.signals) {
     const propNames = [signal.initialValue]
-    const extracted = ctx.extractPropNameFromInitialValue(signal.initialValue)
+    const extracted = ctx.extractPropNameFromInitialValue(signal.initialValue, signal.parsed)
     if (extracted) propNames.push(extracted)
 
     for (const propName of propNames) {
@@ -106,6 +107,151 @@ function collectToFixedPropNames(root: IRNode): Set<string> {
   return names
 }
 
+/**
+ * Concrete scalar Go types eligible for the nullish (`??`) nillable flip in
+ * `resolvePropGoType`. Only these can round-trip through an `interface{}`
+ * field and back via a constructor type assertion / `bf.ToInt`-style
+ * coercion (see the fallback-var emission in `generateNewPropsFunction`).
+ */
+export const NULLISH_SCALAR_GO_TYPES: ReadonlySet<string> = new Set(['string', 'int', 'float64', 'bool'])
+
+/**
+ * Names of OPTIONAL props consumed nullish-sensitively — the left operand of
+ * a `??` anywhere in the component's parsed expression trees, or a signal's
+ * `props.X ?? <literal>` initial value (#2248).
+ *
+ * Why this matters: JS `??` falls back only on `null`/`undefined`, keeping
+ * `''`/`0`/`false`. A Go zero-valued scalar field cannot represent "absent",
+ * so a `??`-consumed optional scalar must lower to the adapter's established
+ * nillable representation (`interface{}`) for the distinction to exist at
+ * render time. `resolvePropGoType` applies that flip using this set.
+ *
+ * The IR walk is generic (any nested object/array is descended, so parsed
+ * trees inside expressions, conditions, attributes, and loops are all seen)
+ * and the match is shape-precise: `identifier` left (destructured props) or
+ * `<propsObject>.<name>` member left. KNOWN LIMITATION (same class as
+ * `collectToFixedPropNames`): an `identifier` left shadowed by a same-named
+ * loop/callback param is misattributed to the prop — the flip is then merely
+ * unnecessary, not incorrect.
+ */
+export function collectNullishConsumedPropNames(ctx: GoEmitContext, ir: ComponentIR): Set<string> {
+  const names = new Set<string>()
+  // A destructure default (`{ className = '' }`) means the binding is never
+  // nullish in JS — the default already applied — so such props never need
+  // the nillable flip (and `applyGoFallback`'s concrete-typed baking relies
+  // on them staying concrete).
+  const optionalParams = new Set(
+    ir.metadata.propsParams.filter(p => p.optional && p.defaultValue == null).map(p => p.name),
+  )
+  if (optionalParams.size === 0) return names
+
+  const propsObject = ctx.state.propsObjectName
+  const propNameOfLeft = (left: ParsedExpr): string | null => {
+    if (left.kind === 'identifier') return left.name
+    if (
+      left.kind === 'member' &&
+      !left.computed &&
+      left.object.kind === 'identifier' &&
+      left.object.name === propsObject
+    ) {
+      return left.property
+    }
+    return null
+  }
+
+  // `?? <zero-equivalent literal>` (`?? ''`, `?? 0`, `?? false`) is the one
+  // shape where nullish and truthiness semantics coincide — nil and the zero
+  // value both land on the same output — so it earns no flip. Only a
+  // fallback the zero value must NOT collapse into makes the distinction
+  // observable.
+  const isZeroEquivalentLiteral = (right: ParsedExpr): boolean =>
+    right.kind === 'literal' &&
+    (right.value === '' || right.value === false || right.value === null ||
+      (right.literalType === 'number' && Number(right.value) === 0))
+
+  const walk = (node: unknown): void => {
+    if (!node || typeof node !== 'object') return
+    if (Array.isArray(node)) {
+      for (const item of node) walk(item)
+      return
+    }
+    const rec = node as Record<string, unknown>
+    if (rec.kind === 'logical' && rec.op === '??' && rec.left && rec.right) {
+      const propName = propNameOfLeft(rec.left as ParsedExpr)
+      if (propName && optionalParams.has(propName) && !isZeroEquivalentLiteral(rec.right as ParsedExpr)) {
+        names.add(propName)
+      }
+    }
+    for (const value of Object.values(rec)) walk(value)
+  }
+  walk(ir.root)
+
+  // Signal seeds (`createSignal(props.X ?? 1)`) live in metadata, not the
+  // tree — reuse the seam's existing `props.X ?? <literal>` recognizer. The
+  // zero-equivalent exclusion matches on the Go-formatted fallback literal.
+  for (const signal of ir.metadata.signals) {
+    const match = ctx.extractPropFallback(signal.initialValue, signal.parsed)
+    if (!match || !optionalParams.has(match.propName)) continue
+    const f = match.goFallback
+    if (f === '""' || f === 'false' || f === 'nil' || Number(f) === 0) continue
+    names.add(match.propName)
+  }
+  return names
+}
+
+/**
+ * Names of OPTIONAL no-default props consumed as the BARE value of an
+ * omittable attribute (`rows={rows}` / `rows={props.rows}`) anywhere in the
+ * component's element tree.
+ *
+ * Why this matters: Hono omits an attribute whose value is `undefined`, and
+ * the adapter's `emitExpression` mirrors that with a `{{if ne .X nil}}` guard
+ * — which needs a nillable field to test. A concrete scalar field would
+ * render the zero value (`rows="0"`) instead of dropping the attribute, so
+ * these props take the same `interface{}` flip as `??` consumption
+ * (`resolvePropGoType`). The match mirrors `emitExpression`'s guard branch:
+ * bare identifiers / `<propsObject>.<name>` only, skipping `class`/`style`
+ * (own lowerings) and boolean/presence attrs (truthiness-tested, where a nil
+ * and a zero value already coincide). Same shadowing caveat as
+ * `collectNullishConsumedPropNames`: a same-named loop/callback param can
+ * misattribute, making the flip merely unnecessary, not incorrect.
+ */
+export function collectOmittableAttrConsumedPropNames(ctx: GoEmitContext, ir: ComponentIR): Set<string> {
+  const names = new Set<string>()
+  const optionalParams = new Set(
+    ir.metadata.propsParams.filter(p => p.optional && p.defaultValue == null).map(p => p.name),
+  )
+  if (optionalParams.size === 0) return names
+
+  const propsObject = ctx.state.propsObjectName
+  const walk = (node: unknown): void => {
+    if (!node || typeof node !== 'object') return
+    if (Array.isArray(node)) {
+      for (const item of node) walk(item)
+      return
+    }
+    const rec = node as Record<string, unknown>
+    if (rec.type === 'element' && Array.isArray(rec.attrs)) {
+      for (const attr of rec.attrs as Array<{ name: string; value: Record<string, unknown> }>) {
+        if (attr.name === 'class' || attr.name === 'className' || attr.name === 'style') continue
+        if (isBooleanAttr(attr.name)) continue
+        if (attr.value?.kind !== 'expression' || attr.value.presenceOrUndefined) continue
+        const bareId = String(attr.value.expr ?? '').trim()
+        const propName =
+          propsObject && bareId.startsWith(`${propsObject}.`)
+            ? bareId.slice(propsObject.length + 1)
+            : bareId
+        if (/^[A-Za-z_$][\w$]*$/.test(propName) && optionalParams.has(propName)) {
+          names.add(propName)
+        }
+      }
+    }
+    for (const value of Object.values(rec)) walk(value)
+  }
+  walk(ir.root)
+  return names
+}
+
 /**
  * Resolve a prop param's Go struct-field type using the SAME logic
  * `generatePropsStruct` / `generateInputStruct` use: a `propTypeOverrides` entry
@@ -131,6 +277,37 @@ export function resolvePropGoType(
   if (param.optional && ctx.state.localStructFields.has(base)) {
     return 'map[string]interface{}'
   }
+  // An OPTIONAL scalar prop consumed by `??` lowers to `interface{}` (#2248):
+  // a zero-valued `string`/`int` field cannot distinguish "absent" from
+  // `''`/`0`, so JS nullish semantics (which KEEP `''`/`0`) are unexpressible
+  // on the concrete type. `interface{}` is the adapter's established nillable
+  // representation; the `??` template lowering then tests nil-ness via
+  // `bf_nullish` and the constructor seeds via a nil check + assertion.
+  // Assignment ergonomics are unchanged (plain literals assign into
+  // `interface{}`), and the prop joins the existing nillable behaviours
+  // (bare-attribute omission) by construction.
+  //
+  // Gated to `kind: 'primitive'` — a string-union prop
+  // (`placement?: 'top' | 'bottom'`) must stay its scalar Go type (the same
+  // invariant the struct-map gate above documents): the union-typed
+  // class-composition lowerings key off the concrete type, AND the flip
+  // would buy nothing — the zero value (`""`) is never a legal union
+  // member, so the zero-check already coincides with nullish semantics for
+  // every valid input. (A literal-number union containing 0 would be the
+  // exception; none exists in the corpus and the conflation is the
+  // documented pre-#2248 trade-off there.)
+  // A bare-attribute consumption (`rows={rows}`) takes the same flip (#2259):
+  // attribute omission for an absent optional needs a nil to test — see
+  // `collectOmittableAttrConsumedPropNames`.
+  if (
+    param.optional &&
+    param.type.kind === 'primitive' &&
+    (ctx.state.nullishConsumedPropNames.has(param.name) ||
+      ctx.state.omittableAttrConsumedPropNames.has(param.name)) &&
+    NULLISH_SCALAR_GO_TYPES.has(base)
+  ) {
+    return 'interface{}'
+  }
   return base
 }
 

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

@@ -32,7 +32,7 @@ export function convertInitialValue(
     }
   }
 
-  const propName = ctx.extractPropNameFromInitialValue(value)
+  const propName = ctx.extractPropNameFromInitialValue(value, preParsed)
   if (propName && propsParams?.some(p => p.name === propName)) {
     return `in.${capitalizeFieldName(propName)}`
   }

package/src/test-render.ts

@@ -699,7 +699,7 @@ function buildGoPropsInit(
     // not the naive `Id`) — see `goMapLiteralFromObject`'s identical fix.
     const goField = capitalizeFieldName(key)
     if (typeof value === 'string') {
-      lines.push(`\t\t${goField}: "${value}",`)
+      lines.push(`\t\t${goField}: ${goStringLit(value)},`)
     } else if (typeof value === 'number') {
       lines.push(`\t\t${goField}: ${value},`)
     } else if (typeof value === 'boolean') {
@@ -828,6 +828,20 @@ function goTypedMapSliceLiteralFromArray(arr: unknown[], elemType: string): stri
  * names. Only the keys the caller supplied are set, so an omitted optional prop
  * (e.g. `defaultOn` on the third toggle item) takes the Go zero value. (#1297)
  */
+/**
+ * Emit a JS string as a Go interpreted string literal. JSON string
+ * escaping is a subset of Go's (`\"`, `\\`, `\n`, `\uXXXX` are all valid
+ * Go escapes), so `JSON.stringify` is a correct emitter — unlike the
+ * previous quote-only `.replace(/"/g, '\\"')`, it also survives
+ * backslashes, newlines, and control characters (data-point conformance
+ * caught the quote case: a `"` in a string prop broke the generated
+ * `main.go` at compile time). Lone surrogates emit as `\uDXXX`, which Go
+ * rejects — acceptable until a fixture needs malformed-UTF-16 props.
+ */
+function goStringLit(v: string): string {
+  return JSON.stringify(v)
+}
+
 function goStructLiteral(obj: Record<string, unknown>, typeName: string): string {
   const fields: string[] = []
   for (const [k, v] of Object.entries(obj)) {
@@ -836,7 +850,7 @@ function goStructLiteral(obj: Record<string, unknown>, typeName: string): string
     // adapter's own struct-literal baking (`parsed-literal-to-go.ts`)
     // sanitizes those to `DataX`, not `Data-x` (Copilot review, #2202).
     const goField = goFieldNameForKey(k)
-    if (typeof v === 'string') fields.push(`${goField}: "${v.replace(/"/g, '\\"')}"`)
+    if (typeof v === 'string') fields.push(`${goField}: ${goStringLit(v)}`)
     else if (typeof v === 'number' || typeof v === 'boolean') fields.push(`${goField}: ${v}`)
     else if (v === null) fields.push(`${goField}: nil`)
     else if (Array.isArray(v)) fields.push(`${goField}: ${goArrayLiteralFromArray(v)}`)
@@ -848,7 +862,7 @@ function goStructLiteral(obj: Record<string, unknown>, typeName: string): string
 function goArrayLiteralFromArray(arr: unknown[]): string {
   const entries: string[] = []
   for (const v of arr) {
-    if (typeof v === 'string') entries.push(`"${v.replace(/"/g, '\\"')}"`)
+    if (typeof v === 'string') entries.push(goStringLit(v))
     else if (typeof v === 'number') entries.push(String(v))
     else if (typeof v === 'boolean') entries.push(String(v))
     else if (v === null) entries.push('nil')
@@ -886,7 +900,7 @@ function goMapLiteralFromObject(
     // uses for exactly this key-to-Go-field sanitization.
     const emittedKey = capitalizeKeys ? goFieldNameForKey(k) : k
     const key = JSON.stringify(emittedKey)
-    if (typeof v === 'string') entries.push(`${key}: "${v.replace(/"/g, '\\"')}"`)
+    if (typeof v === 'string') entries.push(`${key}: ${goStringLit(v)}`)
     else if (typeof v === 'number') entries.push(`${key}: ${v}`)
     else if (typeof v === 'boolean') entries.push(`${key}: ${v}`)
     else if (v === null) entries.push(`${key}: nil`)