@barefootjs/go-template 0.19.0 → 0.19.1

package/src/__tests__/derived-state-memo.test.ts

@@ -301,10 +301,17 @@ export function P(props: { items: { id: string }[] }) {
 `
     const { template } = generate(src)
     expect(template).not.toContain('len .Visible')
-    // The loop over visible() is handler-filled as `.Rows`; the count reuses it.
+    expect(template).not.toContain('bf_length .Visible')
+    // The loop over visible() is handler-filled as `.Rows`; this is one of
+    // the specialized ARRAY-only `.length` shapes (memo-backed loop slice
+    // count) that stays on native `len` even after #2255 — see the
+    // `member()` docstring on the generic `bf_length` fallback.
     expect(template).toContain('len .Rows')
-    // props.items.length is unaffected.
-    expect(template).toContain('len .Items')
+    // props.items.length is the GENERIC (non-specialized) `.length`
+    // fallback, which #2255 routed through `bf_length` (UTF-16-aware for
+    // strings, and functionally equivalent to `len` for an array/slice —
+    // both dispatch on the underlying value's shape).
+    expect(template).toContain('bf_length .Items')
   })
 })
 

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

@@ -119,37 +119,7 @@ runAdapterConformanceTests({
     // (#1897) data-table no longer skipped — loop body children + wrapper
     // struct + block-body memo baking render correctly on Go.
   ]),
-  skipDataPoints: new Set<string>([
-    // #2255 — Go `len` counts bytes; JS counts UTF-16 code units
-    // ('日本語' is 3 in JS, 9 here; '👍' is 2 in JS, 4 here).
-    'string-length-text:multibyte',
-    'string-length-text:astral',
-    // #2256 — the nullish gate covers only BARE nillable prop refs; a
-    // member-access left operand (`user?.name ?? '…'`) still lowers to
-    // the truthiness `or`, so a present-but-empty member falls back.
-    'optional-chaining-prop:empty-name',
-    // #2260 — controlled/derived boolean props: the SSR seed evaluates
-    // only the static fallback of `props.X ?? internal()` chains, so a
-    // caller-supplied true never reaches aria-*/data-state.
-    'toggle:gen:defaultPressed:true',
-    'toggle:gen:pressed:true',
-    'switch:gen:defaultChecked:true',
-    'switch:gen:checked:true',
-    'checkbox:gen:defaultChecked:true',
-    'checkbox:gen:checked:true',
-    // #2261 — invalid dynamic CSS value: html/template emits the
-    // ZgotmplZ sentinel where the oracle drops the property.
-    'style-object-dynamic:gen:color:markup',
-    // #2262 — dynamic `.flat` depth 0/negative renders empty instead of
-    // the contract's shallow copy.
-    'array-flat-dynamic-depth:gen:depth:zero',
-    'array-flat-dynamic-depth:gen:depth:negative',
-    // #2266 — asChild=true with plain-text children: the Slot define
-    // dereferences `.Children.Props.Children`, which hard-errors on a
-    // string child (`can't evaluate field Props in type interface {}`).
-    'button:gen:asChild:true',
-    'kbd:gen:asChild:true',
-  ]),
+  skipDataPoints: new Set<string>(),
   onRenderError: (err, id) => {
     if (err instanceof GoNotAvailableError) {
       console.log(`Skipping [${id}]: ${err.message}`)
@@ -1301,10 +1271,15 @@ export function Widget(props: P) {
       expect(types).toContain('Classes: "a b" + " " + "c d" + " " + in.ClassName + " tail"')
     })
 
-    // A boolean ternary memo (`isChecked = ctrl() ? c() : i()`) renders its
-    // SSR zero as `false`, not the int `0`, so `aria-checked={isChecked()}`
-    // matches Hono's `aria-checked="false"`.
-    test('boolean ternary memo defaults to false, not 0', () => {
+    // A boolean ternary memo (`isChecked = ctrl() ? c() : i()`) types its
+    // SSR field as `bool` (not `int`), so `aria-checked={isChecked()}`
+    // matches Hono's `aria-checked="false"` shape. Since #2260, `checked`'s
+    // presence is expressible (nillable `interface{}`), so the constructor
+    // bakes a runtime presence check + type-asserted read instead of the
+    // pre-#2260 unconditional `false` — see the `Controlled/derived
+    // boolean props honour a caller-supplied true` describe block below for
+    // the caller-supplied-`true` case this unlocks.
+    test('boolean ternary memo types as bool, resolves controlled presence at SSR', () => {
       const adapter = new GoTemplateAdapter()
       const source = `
 "use client"
@@ -1319,7 +1294,9 @@ export function Toggle(props: { checked?: boolean; defaultChecked?: boolean }) {
 `
       const types = adapter.generateTypes(compileToIR(source, adapter))!
       expect(types).toContain('IsChecked bool')
-      expect(types).toContain('IsChecked: false,')
+      expect(types).toContain(
+        'IsChecked: func() bool { if in.Checked != nil { return func() bool { if v, ok := in.Checked.(bool); ok { return v }; return false }() }; return in.DefaultChecked }(),',
+      )
     })
   })
 
@@ -4720,3 +4697,134 @@ export function List() {
     }
   })
 })
+
+// #2254: `??` in CONDITION position (ternaries/`{{if}}` via
+// `convertConditionToGo` → `renderConditionExpr`'s `logical` case) still
+// emitted Go's truthiness-based `or` even for a nillable-lowered prop, so a
+// present-but-empty (`''`) value wrongly fell back to the `??` default —
+// diverging from JS, where `??` only falls back on null/undefined. The
+// sibling `logical()` emitter (used for non-condition expression positions,
+// e.g. plain interpolation) already routed nillable operands through
+// `bf_nullish` since #2248/#2252; this brings the condition-position
+// emitter in line with it.
+describe('GoTemplateAdapter - #2254 `??` in condition position on a nillable prop', () => {
+  test('ternary test comparing `props.label ?? "Default"` lowers to bf_nullish, not or', () => {
+    const adapter = new GoTemplateAdapter()
+    const result = compileJSX(`
+"use client"
+type Props = { label?: string }
+export function C(props: Props) {
+  return <div>{(props.label ?? 'Default') === 'Default' ? <span>fallback</span> : <span>set</span>}</div>
+}
+`.trimStart(), 'test.tsx', { adapter })
+    expect(result.errors ?? []).toEqual([])
+    const template = result.files?.find(f => f.path.endsWith('.tmpl'))?.content ?? ''
+    expect(template).toContain('bf_nullish .Label "Default"')
+    expect(template).not.toContain('or .Label "Default"')
+  })
+
+  test('end-to-end via real `go run`: a present-but-empty label does NOT take the ?? default branch', async () => {
+    try {
+      const html = await renderGoTemplateComponent({
+        source: `
+'use client'
+type Props = { label?: string }
+export function C(props: Props) {
+  return <div>{(props.label ?? 'Default') === 'Default' ? <span>fallback</span> : <span>set</span>}</div>
+}
+`,
+        adapter: new GoTemplateAdapter(),
+        props: { label: '' },
+      })
+      // JS: '' ?? 'Default' keeps '' (present, not nullish) → '' === 'Default'
+      // is false → the "set" branch renders. The pre-fix `or` lowering would
+      // truthiness-fallback the empty string to 'Default' and wrongly render
+      // "fallback" instead.
+      expect(html).toContain('>set</span>')
+      expect(html).not.toContain('>fallback</span>')
+    } catch (err) {
+      if (err instanceof GoNotAvailableError) {
+        console.log('Skipping #2254 e2e: go command not found')
+        return
+      }
+      throw err
+    }
+  })
+
+  test('an omitted label DOES take the ?? default branch', async () => {
+    try {
+      const html = await renderGoTemplateComponent({
+        source: `
+'use client'
+type Props = { label?: string }
+export function C(props: Props) {
+  return <div>{(props.label ?? 'Default') === 'Default' ? <span>fallback</span> : <span>set</span>}</div>
+}
+`,
+        adapter: new GoTemplateAdapter(),
+        props: {},
+      })
+      expect(html).toContain('>fallback</span>')
+      expect(html).not.toContain('>set</span>')
+    } catch (err) {
+      if (err instanceof GoNotAvailableError) {
+        console.log('Skipping #2254 e2e: go command not found')
+        return
+      }
+      throw err
+    }
+  })
+})
+
+// Review finding on #2271 (the #2254 fix): `renderConditionExpr`'s `logical`
+// case wrapped operands via `needsParens` (AST-kind-based — only
+// `logical`/`unary`/`conditional`), missing any OTHER multi-token rendering
+// (`len .X`, `bf_add a b`, a call). Unwrapped, Go's `and`/`or`/`bf_nullish`
+// (all prefix builtins) parse a multi-token operand as extra sibling args
+// instead of one operand. Switched to `wrapIfMultiToken` (whitespace-based,
+// on the rendered string), matching the main `logical()` emitter.
+describe('GoTemplateAdapter - condition-position logical operand wrapping (#2271 review)', () => {
+  test('a `.length` (member → "len .X") operand of `&&` inside a ternary TEST is parenthesized', () => {
+    // A bare `{cond && <Elem/>}` is recognized as JSX conditional-rendering
+    // shorthand and its test is extracted directly, never reaching
+    // `renderConditionExpr`'s `logical` case as a literal `&&` node — so the
+    // `&&` must be nested inside an explicit ternary test to exercise it.
+    const adapter = new GoTemplateAdapter()
+    const result = compileJSX(`
+"use client"
+type Item = { id: number }
+export function C({ items, enabled }: { items: Item[]; enabled: boolean }) {
+  return <div>{(items.length && enabled) ? <span>on</span> : <span>off</span>}</div>
+}
+`.trimStart(), 'test.tsx', { adapter })
+    expect(result.errors ?? []).toEqual([])
+    const template = result.files?.find(f => f.path.endsWith('.tmpl'))?.content ?? ''
+    // `and (len .Items) .Enabled` — NOT the broken 3-sibling-arg
+    // `and len .Items .Enabled` a bare `needsParens` miss would produce.
+    expect(template).toContain('and (len .Items) .Enabled')
+  })
+
+  test('end-to-end via real `go run`: the multi-token `&&` ternary-test operand compiles and renders correctly', async () => {
+    try {
+      const html = await renderGoTemplateComponent({
+        source: `
+'use client'
+type Item = { id: number }
+export function C({ items, enabled }: { items: Item[]; enabled: boolean }) {
+  return <div>{(items.length && enabled) ? <span>on</span> : <span>off</span>}</div>
+}
+`,
+        adapter: new GoTemplateAdapter(),
+        props: { items: [{ id: 1 }], enabled: true },
+      })
+      expect(html).toContain('>on</span>')
+      expect(html).not.toContain('>off</span>')
+    } catch (err) {
+      if (err instanceof GoNotAvailableError) {
+        console.log('Skipping #2271 review e2e: go command not found')
+        return
+      }
+      throw err
+    }
+  })
+})

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

@@ -135,7 +135,7 @@ import { lowerCtorExpr } from "./memo/ctor-lowering.ts"
 import { resolveBlockBodyMemoModuleConst } from "./memo/memo-value.ts"
 import { computeMemoInitialValue, computeMemoInitialValueOrNull, filterArmEarlierSiblingRefs } from "./memo/memo-compute.ts"
 import { collectSpreadSlots, buildSpreadInitializer } from "./spread/spread-codegen.ts"
-import { buildPropTypeOverrides, resolvePropGoType, collectNillablePropNames, collectNullishConsumedPropNames, collectOmittableAttrConsumedPropNames, NULLISH_SCALAR_GO_TYPES } from "./props/prop-types.ts"
+import { buildPropTypeOverrides, resolvePropGoType, collectNillablePropNames, collectNullishConsumedPropNames, collectOmittableAttrConsumedPropNames, collectTextConsumedPropNames, collectPresenceCheckedPropNames, NULLISH_SCALAR_GO_TYPES } from "./props/prop-types.ts"
 import { collectStringValueNames } from "./props/prop-classes.ts"
 
 export type { GoTemplateAdapterOptions } from "./lib/types.ts"
@@ -419,6 +419,8 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     this.buildLocalTypeTables(ir, ir.metadata.componentName)
     this.state.nullishConsumedPropNames = collectNullishConsumedPropNames(this.emitCtx, ir)
     this.state.omittableAttrConsumedPropNames = collectOmittableAttrConsumedPropNames(this.emitCtx, ir)
+    this.state.textConsumedPropNames = collectTextConsumedPropNames(this.emitCtx, ir)
+    this.state.presenceCheckedPropNames = collectPresenceCheckedPropNames(this.emitCtx, ir)
     this.state.nillablePropNames = collectNillablePropNames(this.emitCtx, ir)
   }
 
@@ -3093,13 +3095,52 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       return goExpr
     }
 
+    // A bare TEXT-position reference to an optional no-default scalar prop
+    // that `resolvePropGoType` flipped to nillable `interface{}` (#2267,
+    // `collectTextConsumedPropNames`) needs a nil-safe stringify: plain
+    // `{{.X}}` prints a nil `interface{}` as the literal `<no value>`, not
+    // "" — `bf_string` (the runtime's nil-safe `String()`) prints "" for
+    // nil and formats a present value identically to `text/template`'s own
+    // default printing, so this is a no-op for the non-nil case.
+    const finalExpr =
+      this.textNillablePropNameOf(classify.parsed) !== null
+        ? `bf_string ${wrapIfMultiToken(goExpr)}`
+        : goExpr
+
     // Mark expressions with slotId using comment nodes for client JS to find.
     // This includes reactive expressions AND loop-param-dependent expressions.
     if (expr.slotId) {
-      return `{{bfTextStart "${expr.slotId}"}}{{${goExpr}}}{{bfTextEnd}}`
+      return `{{bfTextStart "${expr.slotId}"}}{{${finalExpr}}}{{bfTextEnd}}`
     }
 
-    return `{{${goExpr}}}`
+    return `{{${finalExpr}}}`
+  }
+
+  /**
+   * The nillable-prop name a bare TEXT-position expression refers to, or
+   * null. Mirrors `nillablePropNameOf` (the `??`-lowering gate) but keys on
+   * `textConsumedPropNames` instead of `nullishConsumedPropNames` — a
+   * text-only optional scalar prop (`{size}`, never consumed by `??` or a
+   * bare omittable attribute) is in neither of those other two sets.
+   */
+  private textNillablePropNameOf(expr: ParsedExpr | undefined): string | null {
+    if (!expr) return null
+    let name: string | null = null
+    if (expr.kind === 'identifier') {
+      name = expr.name
+    } else if (
+      expr.kind === 'member' &&
+      !expr.computed &&
+      expr.object.kind === 'identifier' &&
+      expr.object.name === this.state.propsObjectName
+    ) {
+      name = expr.property
+    }
+    return name !== null &&
+      this.state.textConsumedPropNames.has(name) &&
+      this.state.nillablePropNames.has(name)
+      ? name
+      : null
   }
 
   /**
@@ -3512,7 +3553,13 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     }
 
     const obj = emit(object)
-    if (property === 'length') return `len ${obj}`
+    // JS `.length`: array element count OR, for a string, UTF-16 code-unit
+    // count (#2255) — NOT Go's native `len`, which is byte count for a
+    // string. `Length`/`bf_length` (bf.go) dispatches on the runtime value's
+    // shape to match. The specialized array-only `.length` shapes above
+    // (filter-result count, memo-backed loop slice count) stay on `len`,
+    // since arrays never hit the UTF-16 divergence.
+    if (property === 'length') return `bf_length ${wrapIfMultiToken(obj)}`
     // A `?.`-written access (`user?.name`, #2168 optional-chaining-prop):
     // a plain `.Field` dot-chain panics evaluating a field on a nil
     // interface/pointer (`nil pointer evaluating interface {}.Name`), so
@@ -3679,13 +3726,19 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     let name: string | null = null
     if (expr.kind === 'identifier') {
       name = expr.name
-    } else if (
-      expr.kind === 'member' &&
-      !expr.computed &&
-      expr.object.kind === 'identifier' &&
-      expr.object.name === this.state.propsObjectName
-    ) {
-      name = expr.property
+    } else if (expr.kind === 'member' && !expr.computed && expr.object.kind === 'identifier') {
+      if (expr.object.name === this.state.propsObjectName) {
+        name = expr.property
+      } else {
+        // Single-hop member access rooted at a bare destructured optional
+        // OBJECT prop (`user?.name ?? '…'`, #2256) — the ROOT prop is what
+        // needs to be in the nillable/nullish-consumed sets, not the
+        // accessed field; `member()`'s own `bf_get` lowering for the `?.`
+        // hop already returns Go `nil` on a nil/missing root, so gating on
+        // the root here is sufficient. Mirrors
+        // `collectNullishConsumedPropNames`'s `propNameOfLeft`.
+        name = expr.object.name
+      }
     }
     return name !== null &&
       this.state.nullishConsumedPropNames.has(name) &&
@@ -4417,11 +4470,6 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return this.renderFilterExpr(pred, param, new Map(), datumField ?? undefined)
   }
 
-  /** Whether an expression needs parentheses when used in and/or. */
-  private needsParens(expr: ParsedExpr): boolean {
-    return expr.kind === 'logical' || expr.kind === 'unary' || expr.kind === 'conditional'
-  }
-
   /**
    * Split a rendered template block into preamble + final expression.
    * The last `{{...}}` must be a variable reference (`$bf_rN` or
@@ -5100,19 +5148,26 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         if (expr.callee.kind === 'identifier' && expr.args.length === 0) {
           return plain(this.rootFieldRef(expr.callee.name))
         }
-        // `isValidElement(x)` — the framework "is this a renderable element?"
-        // predicate. In the Go SSR children model an element is represented by
-        // its already-rendered markup, so this evaluates faithfully as a
-        // truthiness check on the argument (an element is "valid" when there is
-        // something to render). Lowering it as a real, evaluatable expression —
-        // rather than a fabricated `.IsValidElement` field access — is what lets
-        // the `Slot` dynamic-tag guard register and run cleanly on Go.
+        // `isValidElement(x)` — the framework "is this a renderable element
+        // (not plain text)?" predicate. #2266: a passed-through JSX child is
+        // ALSO represented as pre-rendered markup on Go's SSR model, so a
+        // plain non-empty STRING child is truthy but is NOT a valid element
+        // — a bare truthiness check (the pre-#2266 lowering) wrongly took
+        // `Slot`'s element-merge branch and panicked dereferencing
+        // `.Props`/`.Tag` on a string (`can't evaluate field Props in type
+        // interface {}`). `bf_is_element` (bf.go) does a real reflect-based
+        // shape check (map/struct carrying both `tag`+`props` keys/fields,
+        // case-insensitively), matching JS's `'tag' in x && 'props' in x`.
+        // Pre-parenthesised — `call`-kind results aren't covered by
+        // `needsParens`, so an unparenthesised `bf_is_element X` splices as
+        // extra sibling args into an enclosing `and`/`or`.
         if (
           expr.callee.kind === 'identifier' &&
           (identifierPath(expr.callee) ?? expr.callee.name) === 'isValidElement' &&
           expr.args.length === 1
         ) {
-          return this.renderConditionExpr(expr.args[0])
+          const inner = this.renderConditionExpr(expr.args[0])
+          return { preamble: inner.preamble, expr: `(bf_is_element ${wrapIfMultiToken(inner.expr)})` }
         }
         // Any other user-defined predicate call with arguments (e.g.
         // `isAdmin(user)`) has no server-side evaluator and is not a registered
@@ -5252,11 +5307,27 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         const leftResult = this.renderConditionExpr(expr.left)
         const rightResult = this.renderConditionExpr(expr.right)
         const preamble = leftResult.preamble + rightResult.preamble
-        const wrapLeft = this.needsParens(expr.left) ? `(${leftResult.expr})` : leftResult.expr
-        const wrapRight = this.needsParens(expr.right) ? `(${rightResult.expr})` : rightResult.expr
+        // `wrapIfMultiToken` (whitespace-based, on the RENDERED string) — not
+        // `needsParens` (AST-kind-based, only `logical`/`unary`/`conditional`)
+        // — matches the main `logical()` emitter's own wrapping. `needsParens`
+        // misses any other multi-token rendering (`len .X`, `bf_add a b`,
+        // `.SearchParams.Get "k"`), which `and`/`or`/`bf_nullish` (all prefix
+        // builtins) would otherwise parse as extra sibling args instead of one
+        // operand.
+        const wrapLeft = wrapIfMultiToken(leftResult.expr)
+        const wrapRight = wrapIfMultiToken(rightResult.expr)
+        // `??` on a nillable prop needs true JS nullish semantics (#2254,
+        // sibling of #2248/#2252's fix for text-expression/signal-seed
+        // positions): Go's `or` is truthiness-based, so a present-but-empty
+        // `""`/`0`/`false` operand wrongly falls back. `bf_nullish` tests
+        // nil-ness only. Mirrors the `logical()` emitter's own gate (used
+        // for non-condition expression positions) — same
+        // `nullishConsumed ∩ nillable` check via `nillablePropNameOf`.
         const result = expr.op === '&&'
           ? `and ${wrapLeft} ${wrapRight}`
-          : `or ${wrapLeft} ${wrapRight}`
+          : expr.op === '??' && this.nillablePropNameOf(expr.left) !== null
+            ? `bf_nullish ${wrapLeft} ${wrapRight}`
+            : `or ${wrapLeft} ${wrapRight}`
         return { preamble, expr: result }
       }
 
@@ -6119,17 +6190,22 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     for (const e of entries) {
       if (e.kind === 'expr' && !isSupported(parseExpression(e.expr)).supported) return null
     }
-    // The static CSS key + literal value are inlined into a double-quoted
-    // `style="..."` attribute, so HTML-attr escape them (a value like `'"'`
-    // would otherwise terminate the attribute / inject markup). The dynamic
-    // arm's `{{…}}` action is escaped by `html/template`'s attribute context.
-    return entries
-      .map(e =>
-        e.kind === 'literal'
-          ? `${this.escapeAttrText(e.cssKey)}:${this.escapeAttrText(e.value)}`
-          : `${this.escapeAttrText(e.cssKey)}:{{${this.convertExpressionToGo(e.expr)}}}`,
-      )
-      .join(';')
+    // Routed through the single `bf_style_object` runtime call (#2261)
+    // rather than per-pair `key:value` template interpolation — a dynamic
+    // value that fails the ported `hasUnsafeStyleValue` CSS-injection scan
+    // must DROP its entire pair to match Hono's oracle behavior, which
+    // isn't expressible as a per-pair inline substitution (a dropped
+    // MIDDLE pair would otherwise leave a dangling `key:` / stray `;;` in
+    // a `.map().join(';')` splice). `String()` (already returns "" for
+    // nil) also has an established zero-value contract for numbers/bools,
+    // avoiding html/template's own contextual CSS auto-escaper (whose
+    // `ZgotmplZ` sentinel — the pre-#2261 divergence — is bypassed by the
+    // call returning a trusted `template.CSS`, not a plain `string`).
+    const args = entries.flatMap(e => [
+      JSON.stringify(e.cssKey),
+      e.kind === 'literal' ? JSON.stringify(e.value) : wrapIfMultiToken(this.convertExpressionToGo(e.expr)),
+    ])
+    return `{{bf_style_object ${args.join(' ')}}}`
   }
 
   private renderAttributes(element: IRElement): string {

package/src/adapter/lib/compile-state.ts

@@ -164,6 +164,24 @@ export class CompileState {
    */
   omittableAttrConsumedPropNames: Set<string> = new Set()
 
+  /**
+   * OPTIONAL no-default prop names consumed as a BARE TEXT-position
+   * expression value (`{size}`) — #2267. Same `resolvePropGoType` flip and
+   * same populate-before-first-resolve ordering as
+   * `nullishConsumedPropNames`: the text emitter's nil-safe `bf_string`
+   * wrap needs a nillable field to have something to guard.
+   */
+  textConsumedPropNames: Set<string> = new Set()
+
+  /**
+   * OPTIONAL no-default prop names whose PRESENCE is tested — `props.X !==
+   * undefined` (the "controlled component" idiom's `isControlled` memo) —
+   * #2260. Same `resolvePropGoType` flip and same populate-before-first-
+   * resolve ordering as `nullishConsumedPropNames`: distinguishing "caller
+   * passed a value" from "caller omitted the prop" needs a nillable field.
+   */
+  presenceCheckedPropNames: Set<string> = new Set()
+
   /**
    * String-typed signal getter / prop names (#2168 string-concat-plus).
    * Feeds `isStringName` for `isStringConcatBinary`, which decides whether a