@barefootjs/go-template 0.19.0 → 0.20.0

package/src/adapter/memo/memo-compute.ts

@@ -35,6 +35,34 @@ function getterCallName(e: ParsedExpr): string | null {
     : null
 }
 
+/** Whether `t` is `boolean`, or a `T | undefined`/`T | null` union whose
+ *  non-nullish branch is `boolean` (the controlled-signal shape,
+ *  `createSignal<boolean | undefined>(...)`). */
+function isBooleanTypeInfo(t: TypeInfo): boolean {
+  if (t.kind === 'primitive') return t.primitive === 'boolean'
+  if (t.kind === 'union' && t.unionTypes?.length === 2) {
+    const scalar = t.unionTypes.find(u => u.primitive !== 'undefined' && u.primitive !== 'null')
+    return scalar?.kind === 'primitive' && scalar.primitive === 'boolean'
+  }
+  return false
+}
+
+/** Whether the getter NAME (a signal or memo) has a boolean-compatible
+ *  declared type — gates the ternary-over-getter-calls branch below
+ *  (#2260) so it only fires for the boolean shape it hardcodes a `func()
+ *  bool { ... }()` wrapper for; a string/number-typed getter falls through
+ *  to the caller's normal handling instead of emitting invalid Go. */
+function isBooleanTypedGetter(
+  ctx: GoEmitContext,
+  name: string,
+  signals: { getter: string; initialValue: string; type?: TypeInfo }[],
+): boolean {
+  const signal = signals.find(s => s.getter === name)
+  if (signal) return signal.type !== undefined && isBooleanTypeInfo(signal.type)
+  const memo = (ctx.state.currentMemos ?? []).find(m => m.name === name)
+  return memo?.type !== undefined && isBooleanTypeInfo(memo.type)
+}
+
 /** A `props.X` member access → the prop name, else null. */
 function propsMemberName(e: ParsedExpr): string | null {
   return e.kind === 'member' &&
@@ -45,6 +73,25 @@ function propsMemberName(e: ParsedExpr): string | null {
     : null
 }
 
+/**
+ * A prop reference resolved against the component's ACTUAL props-object
+ * binding (`ctx.state.propsObjectName` — may be a non-`props` name, or
+ * `null` for a destructured signature), else null. Mirrors
+ * `collectPresenceCheckedPropNames`'s (prop-types.ts) exact shape so the
+ * presence-check codegen branch below can't drift from the collector that
+ * decides which props got the nillable flip in the first place — unlike
+ * `propsMemberName` (hardcoded to the literal name `props`), which only
+ * matches the conventional object-props signature.
+ */
+function propNameForPropsBinding(ctx: GoEmitContext, e: ParsedExpr): string | null {
+  const propsObject = ctx.state.propsObjectName
+  if (e.kind === 'member' && !e.computed && e.object.kind === 'identifier' && e.object.name === propsObject) {
+    return e.property
+  }
+  if (!propsObject && e.kind === 'identifier') return e.name
+  return null
+}
+
 /** A `() => props.X.filter((p) => <predicate>)` match: the array prop name,
  *  the predicate serialized to the runtime evaluator's ParsedExpr JSON, the
  *  arrow's param name, and the free variable names its predicate captures.
@@ -56,7 +103,7 @@ function propsMemberName(e: ParsedExpr): string | null {
 export function matchFilterArmMemo(
   ctx: GoEmitContext,
   body: ParsedExpr,
-  signals: { getter: string; initialValue: string }[],
+  signals: { getter: string; initialValue: string; type?: TypeInfo }[],
   propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
 ): { propName: string; predJSON: string; paramName: string; freeVars: string[] } | null {
   const cb = asCallbackMethodCall(body)
@@ -93,7 +140,7 @@ export function matchFilterArmMemo(
 export function filterArmEarlierSiblingRefs(
   ctx: GoEmitContext,
   memo: { name: string; parsed?: ParsedExpr },
-  signals: { getter: string; initialValue: string }[],
+  signals: { getter: string; initialValue: string; type?: TypeInfo }[],
   propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
 ): string[] {
   if (!memo.parsed) return []
@@ -126,7 +173,7 @@ export function filterArmEarlierSiblingRefs(
 export function computeMemoInitialValue(
   ctx: GoEmitContext,
   memo: { name: string; computation: string; deps: string[]; parsed?: ParsedExpr },
-  signals: { getter: string; initialValue: string }[],
+  signals: { getter: string; initialValue: string; type?: TypeInfo }[],
   propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
   propFallbackVars: ReadonlyMap<string, PropFallbackVar> = EMPTY_PROP_FALLBACK_VARS,
   goType?: string,
@@ -168,7 +215,7 @@ export function computeMemoInitialValue(
 export function memoInitialFromParsedBody(
   ctx: GoEmitContext,
   body: ParsedExpr,
-  signals: { getter: string; initialValue: string }[],
+  signals: { getter: string; initialValue: string; type?: TypeInfo }[],
   propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
   propFallbackVars: ReadonlyMap<string, PropFallbackVar>,
   currentMemoName: string,
@@ -310,6 +357,42 @@ export function memoInitialFromParsedBody(
     if (propName) return propRef(propName)
   }
 
+  // () => props.X !== undefined (or !=/===/==) — the "controlled component"
+  // idiom's `isControlled` memo (#2260). Distinguishing "caller passed a
+  // value" from "caller omitted the prop" needs the nillable `interface{}`
+  // representation `collectPresenceCheckedPropNames`/`resolvePropGoType`
+  // flip `props.X` to; the input field's Go zero value for `interface{}` IS
+  // `nil`, so a plain nil-check is exact (no `bf_nullish`-style helper
+  // needed — this is presence, not a `??` fallback).
+  if (
+    body.kind === 'binary' &&
+    (body.op === '!==' || body.op === '!=' || body.op === '===' || body.op === '==')
+  ) {
+    const other =
+      body.right.kind === 'identifier' && body.right.name === 'undefined' ? body.left :
+      body.left.kind === 'identifier' && body.left.name === 'undefined' ? body.right : null
+    const propName = other ? propNameForPropsBinding(ctx, other) : null
+    if (propName) {
+      const param = propsParams.find(p => p.name === propName)
+      // Guard on the field ACTUALLY being nillable-flipped — a presence
+      // check against a CONCRETE-typed field (a required prop, or an
+      // optional one this memo's shape didn't trigger the flip for, e.g.
+      // via `collectPresenceCheckedPropNames`'s primitive-only /
+      // no-default gate) can't be tested this way (`x != nil` doesn't even
+      // compile against a `string`/`bool` field) — fall through to the
+      // caller's zero-value default instead of emitting invalid Go. Reads
+      // the RAW `in.<Field>` directly — NOT through `propRef`, which
+      // prefers a hoisted `?? <fallback>` local when one exists: that local
+      // already collapsed "absent" into the fallback value at hoist time,
+      // so it's never nil and testing it here would be nonsensical (and,
+      // being concretely typed, wouldn't compile against `nil` either).
+      if (param && ctx.state.nillablePropNames.has(propName)) {
+        const isNe = body.op === '!==' || body.op === '!='
+        return `in.${capitalizeFieldName(propName)} ${isNe ? '!=' : '=='} nil`
+      }
+    }
+  }
+
   // () => cond() ? A : B where each branch is a module string const or a
   // string literal, and `cond` is a signal/memo this resolver can evaluate.
   if (body.kind === 'conditional') {
@@ -350,6 +433,37 @@ export function memoInitialFromParsedBody(
         }
       }
     }
+
+    // () => cond() ? branchA() : branchB() — a ternary whose CONDITION and
+    // BOTH branches are getter calls (signals/memos), not string literals
+    // (#2260's `isPressed = isControlled() ? controlledPressed() :
+    // internalPressed()`). `resolveGetterValueAsGo` resolves each — a
+    // presence-check memo like `isControlled` above already yields a Go
+    // `bool` expression, so the condition needs no extra wrapping.
+    //
+    // GATED to both branches being boolean-typed signals/memos
+    // (`isBooleanTypedGetter`) — `getterCallName` only checks call SHAPE,
+    // not type, so an ungated version would also match a derived
+    // string/number memo (`label = isActive() ? activeLabel() :
+    // inactiveLabel()`) and hardcode an invalid `func() bool { return
+    // "..." }()` (Copilot review finding on the initial version of this
+    // branch).
+    if (condName) {
+      const tName = getterCallName(body.consequent)
+      const fName = getterCallName(body.alternate)
+      if (
+        tName && fName &&
+        isBooleanTypedGetter(ctx, tName, signals) &&
+        isBooleanTypedGetter(ctx, fName, signals)
+      ) {
+        const condGo = resolveGetterValueAsGo(ctx, condName, signals, propsParams, propFallbackVars, resolving)
+        const tGo = resolveGetterValueAsGo(ctx, tName, signals, propsParams, propFallbackVars, resolving)
+        const fGo = resolveGetterValueAsGo(ctx, fName, signals, propsParams, propFallbackVars, resolving)
+        if (condGo !== null && tGo !== null && fGo !== null) {
+          return `func() bool { if ${condGo} { return ${tGo} }; return ${fGo} }()`
+        }
+      }
+    }
   }
 
   // () => <ref> <*|+|-|/> <non-negative int>. The operand must be a
@@ -473,7 +587,7 @@ export function memoInitialFromParsedBody(
 export function computeMemoInitialValueOrNull(
   ctx: GoEmitContext,
   memo: { name: string; computation: string; deps: string[]; parsed?: ParsedExpr; parsedBlock?: ParsedStatement[]; parsedBlockComplete?: boolean },
-  signals: { getter: string; initialValue: string }[],
+  signals: { getter: string; initialValue: string; type?: TypeInfo }[],
   propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
   propFallbackVars: ReadonlyMap<string, PropFallbackVar> = EMPTY_PROP_FALLBACK_VARS,
   /**
@@ -555,14 +669,14 @@ export function computeMemoInitialValueOrNull(
 export function resolveGetterValueAsGo(
   ctx: GoEmitContext,
   name: string,
-  signals: { getter: string; initialValue: string }[],
+  signals: { getter: string; initialValue: string; type?: TypeInfo }[],
   propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
   propFallbackVars: ReadonlyMap<string, PropFallbackVar>,
   resolving: ReadonlySet<string> = new Set(),
 ): string | null {
   const signal = signals.find(s => s.getter === name)
   if (signal) {
-    return getSignalInitialValueAsGo(ctx, signal.initialValue, propsParams, propFallbackVars)
+    return getSignalInitialValueAsGo(ctx, signal.initialValue, propsParams, propFallbackVars, signal.type)
   }
   const memo = (ctx.state.currentMemos ?? []).find(m => m.name === name)
   if (memo) {
@@ -598,7 +712,7 @@ export function resolveGetterValueAsGo(
 export function computeComparisonTernaryGo(
   ctx: GoEmitContext,
   parsed: ParsedExpr | undefined,
-  signals: { getter: string; initialValue: string }[],
+  signals: { getter: string; initialValue: string; type?: TypeInfo }[],
   propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
   propFallbackVars: ReadonlyMap<string, PropFallbackVar>,
   resolving: ReadonlySet<string> = new Set(),
@@ -654,7 +768,7 @@ export function computeComparisonTernaryGo(
 export function resolveComparisonOperandGo(
   ctx: GoEmitContext,
   node: ParsedExpr,
-  signals: { getter: string; initialValue: string }[],
+  signals: { getter: string; initialValue: string; type?: TypeInfo }[],
   propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
   propFallbackVars: ReadonlyMap<string, PropFallbackVar>,
   resolving: ReadonlySet<string> = new Set(),

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

@@ -148,13 +148,19 @@ export function collectNullishConsumedPropNames(ctx: GoEmitContext, ir: Componen
   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
+    if (left.kind === 'member' && !left.computed && left.object.kind === 'identifier') {
+      if (left.object.name === propsObject) return left.property
+      // Single-hop member access rooted at a bare destructured optional
+      // OBJECT prop (`user?.name ?? '…'`, #2256): the flip belongs to the
+      // ROOT prop (`user`) — an optional-object prop already lowers to a
+      // nillable `map[string]interface{}` by construction
+      // (`resolvePropGoType`'s struct-map branch), so it's the root's
+      // membership here (not the accessed field) that lets
+      // `nillablePropNameOf` route the `??` to `bf_nullish`. A deeper
+      // chain (`props.user?.name`, `user?.address?.city`) isn't matched —
+      // same single-hop `?.` caveat documented on the `member` ParsedExpr
+      // variant.
+      return left.object.name
     }
     return null
   }
@@ -252,6 +258,126 @@ export function collectOmittableAttrConsumedPropNames(ctx: GoEmitContext, ir: Co
   return names
 }
 
+/**
+ * Names of OPTIONAL no-default props consumed as the BARE value of a
+ * TEXT-position expression (`{size}` / `{props.size}`) anywhere in the
+ * component's element tree.
+ *
+ * Why this matters (#2267): with no flip, an absent `size?: number` prop
+ * resolves to a concrete `int` field and `{{.Size}}` prints its zero value
+ * (`0`) instead of empty — the JS reference renders `undefined` as "".
+ * These props take the same `interface{}` flip as `??`/omittable-attribute
+ * consumption (`resolvePropGoType`); `renderExpression`'s emitter then
+ * routes the flipped field through `bf_string` (nil-safe stringify)
+ * instead of a bare `{{.X}}`, since `text/template` prints a nil
+ * `interface{}` as the literal `<no value>`, not "".
+ *
+ * Generic recursive walk (matching `type: 'expression'` ANYWHERE, like
+ * `collectNullishConsumedPropNames`) rather than only `element.children` —
+ * a fragment return (`<>{size}</>`) or a conditional branch's children
+ * would otherwise be missed. Same shadowing caveat as the sibling
+ * collectors: a same-named loop/callback param can misattribute, making
+ * the flip merely unnecessary, not incorrect.
+ *
+ * Filtered to `kind: 'primitive'` — unlike the `??`/omittable-attribute
+ * collectors (whose consumers, `bf_nullish` and the `{{if ne .X nil}}`
+ * guard, are nil-test-only and pass the underlying value through
+ * untouched), this collector's consumer (`renderExpression`'s `bf_string`
+ * wrap) RESTRINGIFIES the value via `fmt.Sprintf`. An optional prop
+ * carrying already-rendered markup (a JSX-element/children prop) also
+ * independently resolves to `interface{}` via `resolvePropGoType`'s
+ * struct-map branch — routing THAT through `bf_string` would strip its
+ * `template.HTML` safe-markup typing, so `text/template` re-escapes
+ * already-escaped HTML on print (observed as literal `&lt;div&gt;...`).
+ * Restricting to primitives keeps this collector disjoint from that flip.
+ */
+export function collectTextConsumedPropNames(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 && p.type.kind === 'primitive')
+      .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 === 'expression') {
+      const bareId = String(rec.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
+}
+
+/**
+ * Names of OPTIONAL no-default props whose PRESENCE is tested — `props.X
+ * !== undefined` / `!= undefined` (or the `===`/`==` negation) — anywhere in
+ * a memo's computation (#2260). This is the "controlled component" idiom's
+ * `isControlled` check (`createMemo(() => props.pressed !== undefined)`):
+ * distinguishing "caller passed a value" from "caller omitted the prop" is
+ * only expressible on the nillable `interface{}` representation (a
+ * concrete `bool` field can't tell `pressed={false}` from omitted `pressed`
+ * apart — both are the Go zero value `false`), so these props take the
+ * same `interface{}` flip as `??`/attribute/text consumption
+ * (`resolvePropGoType`). `memoInitialFromParsedBody`'s presence-check
+ * branch then lowers the comparison to `in.X != nil`.
+ *
+ * Scoped to `ir.metadata.memos[].parsed` (not the generic tree walk the
+ * sibling collectors use) — a presence check is a memo-computation shape,
+ * never a JSX child/attribute expression.
+ */
+export function collectPresenceCheckedPropNames(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 && p.type.kind === 'primitive')
+      .map(p => p.name),
+  )
+  if (optionalParams.size === 0) return names
+
+  const propsObject = ctx.state.propsObjectName
+  const isUndefinedCheck = (op: string): boolean =>
+    op === '!==' || op === '!=' || op === '===' || op === '=='
+
+  for (const memo of ir.metadata.memos) {
+    const body = memo.parsed
+    if (!body || body.kind !== 'binary' || !isUndefinedCheck(body.op)) continue
+    const other = body.right.kind === 'identifier' && body.right.name === 'undefined'
+      ? body.left
+      : body.left.kind === 'identifier' && body.left.name === 'undefined'
+        ? body.right
+        : null
+    if (!other) continue
+    // Object-props style (`props.X`) — `other` is a member access rooted at
+    // the props object. Destructured style (`X` bare) — `other` is a bare
+    // identifier naming the prop directly.
+    const propName =
+      other.kind === 'member' && !other.computed &&
+        other.object.kind === 'identifier' && other.object.name === propsObject
+        ? other.property
+        : !propsObject && other.kind === 'identifier'
+          ? other.name
+          : null
+    if (propName && optionalParams.has(propName)) names.add(propName)
+  }
+  return names
+}
+
 /**
  * Resolve a prop param's Go struct-field type using the SAME logic
  * `generatePropsStruct` / `generateInputStruct` use: a `propTypeOverrides` entry
@@ -298,12 +424,18 @@ export function resolvePropGoType(
   // 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`.
+  // `collectOmittableAttrConsumedPropNames`. A bare TEXT-position
+  // consumption (`{size}`) takes the same flip too (#2267) — see
+  // `collectTextConsumedPropNames`. A presence check (`props.X !==
+  // undefined`, the "controlled component" idiom's `isControlled` memo)
+  // takes the same flip too (#2260) — see `collectPresenceCheckedPropNames`.
   if (
     param.optional &&
     param.type.kind === 'primitive' &&
     (ctx.state.nullishConsumedPropNames.has(param.name) ||
-      ctx.state.omittableAttrConsumedPropNames.has(param.name)) &&
+      ctx.state.omittableAttrConsumedPropNames.has(param.name) ||
+      ctx.state.textConsumedPropNames.has(param.name) ||
+      ctx.state.presenceCheckedPropNames.has(param.name)) &&
     NULLISH_SCALAR_GO_TYPES.has(base)
   ) {
     return 'interface{}'

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

@@ -15,6 +15,45 @@ import { parsedLiteralToGo } from './parsed-literal-to-go.ts'
 /** Default for `getSignalInitialValueAsGo`'s optional fallback-var map. */
 const EMPTY_PROP_FALLBACK_VARS: ReadonlyMap<string, PropFallbackVar> = new Map()
 
+/**
+ * A bare prop-field reference (`in.<Field>`), type-asserted when the prop
+ * was flipped to nillable `interface{}` (#2248/#2259/#2260's
+ * `resolvePropGoType` flips) while THE CONSUMER's own expected type is a
+ * concrete scalar — e.g. `createSignal<boolean | undefined>(props.pressed)`
+ * resolves to a plain `bool` signal field (the `| undefined` half doesn't
+ * itself trigger a flip), but `props.pressed` now bakes as `interface{}`.
+ * A bare `interface{}` value can't assign into a `bool` field/branch (Go
+ * compile error) — safely type-assert with a zero-value fallback for the
+ * concrete-scalar case instead of the bare field reference. Object/array
+ * expected types are left alone (already `interface{}`-compatible).
+ *
+ * `expectedType` may be `kind: 'union'` — a `T | undefined` signal type
+ * annotation (the controlled-component idiom's controlled signal) — the `|
+ * 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.
+ */
+function nillableAwarePropRef(ctx: GoEmitContext, propName: string, expectedType: TypeInfo): string {
+  const fieldRef = `in.${capitalizeFieldName(propName)}`
+  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') {
+    const goType =
+      scalar.primitive === 'boolean' ? 'bool' :
+      scalar.primitive === 'number' ? 'float64' :
+      scalar.primitive === 'string' ? 'string' : null
+    if (goType) {
+      const zero = goType === 'bool' ? 'false' : goType === 'string' ? '""' : '0'
+      return `func() ${goType} { if v, ok := ${fieldRef}.(${goType}); ok { return v }; return ${zero} }()`
+    }
+  }
+  return fieldRef
+}
+
 /**
  * Lower a signal/const initial value to its Go SSR literal: a prop reference
  * becomes `in.<Field>`, a non-literal falls back to the type's zero value.
@@ -26,15 +65,17 @@ export function convertInitialValue(
   propsParams?: { name: string }[],
   preParsed?: ParsedExpr,
 ): string {
+  const propRef = (propName: string): string => nillableAwarePropRef(ctx, propName, typeInfo)
+
   if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(value)) {
     if (propsParams?.some(p => p.name === value)) {
-      return `in.${capitalizeFieldName(value)}`
+      return propRef(value)
     }
   }
 
   const propName = ctx.extractPropNameFromInitialValue(value, preParsed)
   if (propName && propsParams?.some(p => p.name === propName)) {
-    return `in.${capitalizeFieldName(propName)}`
+    return propRef(propName)
   }
 
   if (typeInfo.kind === 'primitive') {
@@ -148,24 +189,36 @@ export function objectLiteralToGoMap(ctx: GoEmitContext, expr: ParsedExpr): stri
  * Get a signal's initial value as Go code — a literal, or a props reference
  * (`in.<Field>`, or the hoisted fallback var when `props.X ?? N` has one).
  * Unrecognized values default to `0`.
+ *
+ * `signalType`, when passed, drives the same nillable-prop type-assertion
+ * `convertInitialValue` applies (#2260) — a caller resolving a getter as the
+ * operand of a boolean condition/ternary branch (`resolveGetterValueAsGo`)
+ * needs a concrete-typed result, not a bare `interface{}` field reference,
+ * when the referenced prop was flipped to nillable. Omitted by call sites
+ * that splice the result into an `interface{}`-typed context (e.g. a
+ * `map[string]any{...}` env entry), where the bare reference is fine.
  */
 export function getSignalInitialValueAsGo(
   ctx: GoEmitContext,
   initialValue: string,
   propsParams: { name: 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)}`
+
   if (propsParams.some(p => p.name === initialValue)) {
     const hoisted = propFallbackVars.get(initialValue)
     if (hoisted) return hoisted.varName
-    return `in.${capitalizeFieldName(initialValue)}`
+    return propRef(initialValue)
   }
 
   const propName = ctx.extractPropNameFromInitialValue(initialValue)
   if (propName && propsParams.some(p => p.name === propName)) {
     const hoisted = propFallbackVars.get(propName)
     if (hoisted) return hoisted.varName
-    return `in.${capitalizeFieldName(propName)}`
+    return propRef(propName)
   }
 
   // single quotes are normalized to Go double quotes

package/src/conformance-pins.ts

@@ -137,4 +137,10 @@ export const conformancePins: ConformancePins = {
   // 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' }],
+  // #2273: a method call on a prop typed as a built-in host rich type
+  // (Date, Map, …) has no catalogued lowering in any adapter — this is a
+  // compiler-level refusal (`checkRichTypeMethodCalls`, wired ahead of
+  // `adapter.generate()`), not an adapter-specific gap, so it is pinned
+  // identically across every adapter package including Hono.
+  'date-method-uncatalogued': [{ code: 'BF021', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2274' }],
 }