@barefootjs/go-template 0.6.0 → 0.7.0

package/dist/index.js

@@ -51,8 +51,20 @@ function emitBfSort(recv, c) {
   });
   return `bf_sort ${wrapIfMultiToken(recv)} ${groups.join(" ")}`;
 }
+function emitBfReduce(recv, op, direction) {
+  const keyName = op.key.kind === "field" ? capitalize(op.key.field) : "";
+  return `bf_reduce ${wrapIfMultiToken(recv)} "${op.op}" "${op.key.kind}" "${keyName}" "${op.type}" "${escapeGoString(op.init)}" "${direction}"`;
+}
+function escapeGoString(s) {
+  return s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
 function capitalize(s) {
-  return s.length === 0 ? s : s[0].toUpperCase() + s.slice(1);
+  if (s.length === 0)
+    return s;
+  if (GoTemplateAdapter.GO_INITIALISMS.has(s.toLowerCase())) {
+    return s.toUpperCase();
+  }
+  return s[0].toUpperCase() + s.slice(1);
 }
 function slotIdToFieldSuffix(slotId) {
   const cleanId = slotId.startsWith("^") ? slotId.slice(1) : slotId;
@@ -62,6 +74,18 @@ function slotIdToFieldSuffix(slotId) {
   }
   return cleanId.replace("slot_", "Slot");
 }
+var GO_REMEDIATION_OPTIONS = `Options:
+1. Use @client directive for client-side evaluation
+2. Pre-compute the value in Go code`;
+function buildUnsupportedSuggestion(support) {
+  if (!support.reason)
+    return GO_REMEDIATION_OPTIONS;
+  if (support.selfContained)
+    return support.reason;
+  return `${support.reason}
+
+${GO_REMEDIATION_OPTIONS}`;
+}
 var GO_TEMPLATE_PRIMITIVES = {
   "JSON.stringify": { arity: 1, emit: (args) => `bf_json ${args[0]}` },
   String: { arity: 1, emit: (args) => `bf_string ${args[0]}` },
@@ -93,6 +117,7 @@ class GoTemplateAdapter extends BaseAdapter {
   localStructFields = new Map;
   synthStructTypes = new Map;
   usesHtmlTemplate = false;
+  moduleStringConsts = new Map;
   constructor(options = {}) {
     super();
     this.options = {
@@ -107,6 +132,7 @@ class GoTemplateAdapter extends BaseAdapter {
     this.templateVarCounter = 0;
     this.propsObjectName = ir.metadata.propsObjectName;
     this.restPropsName = ir.metadata.restPropsName ?? null;
+    this.moduleStringConsts = this.collectModuleStringConsts(ir.metadata.localConstants);
     if (!options?.siblingTemplatesRegistered) {
       this.checkImportedLoopChildComponents(ir);
     }
@@ -888,6 +914,12 @@ ${goFields.join(`
   collectStaticChildInstancesRecursive(node, result, inLoop) {
     if (node.type === "component") {
       const comp = node;
+      if (comp.dynamicTag) {
+        for (const child of comp.children) {
+          this.collectStaticChildInstancesRecursive(child, result, inLoop);
+        }
+        return;
+      }
       if (comp.name !== "Portal" && !inLoop && comp.slotId) {
         const suffix = slotIdToFieldSuffix(comp.slotId);
         result.push({
@@ -1724,6 +1756,9 @@ ${goFields.join(`
     return emitParsedExpr(expr, this);
   }
   identifier(name) {
+    const inlined = this.resolveModuleStringConst(name);
+    if (inlined !== null)
+      return inlined;
     const currentLoopParam = this.loopParamStack[this.loopParamStack.length - 1];
     if (currentLoopParam && name === currentLoopParam)
       return ".";
@@ -1745,6 +1780,48 @@ ${goFields.join(`
     const prefix = this.loopParamStack.length > 0 ? "$." : ".";
     return `${prefix}${this.capitalizeFieldName(name)}`;
   }
+  collectModuleStringConsts(constants) {
+    const map = new Map;
+    for (const c of constants ?? []) {
+      if (!c.isModule)
+        continue;
+      if (c.value === undefined)
+        continue;
+      const literal = this.parsePureStringLiteral(c.value);
+      if (literal !== null)
+        map.set(c.name, literal);
+    }
+    return map;
+  }
+  parsePureStringLiteral(source) {
+    const sf = ts.createSourceFile("__const.ts", `const __x = (${source});`, ts.ScriptTarget.Latest, false);
+    const stmt = sf.statements[0];
+    if (!stmt || !ts.isVariableStatement(stmt))
+      return null;
+    const decl = stmt.declarationList.declarations[0];
+    let init = decl?.initializer;
+    while (init && ts.isParenthesizedExpression(init))
+      init = init.expression;
+    if (!init)
+      return null;
+    if (ts.isStringLiteral(init) || ts.isNoSubstitutionTemplateLiteral(init)) {
+      return init.text;
+    }
+    return null;
+  }
+  resolveModuleStringConst(name) {
+    if (this.loopParamStack.length > 0 && this.loopParamStack[this.loopParamStack.length - 1] === name) {
+      return null;
+    }
+    if (this.loopVarRefCount.has(name))
+      return null;
+    if (this.isOuterLoopParam(name))
+      return null;
+    const value = this.moduleStringConsts.get(name);
+    if (value === undefined)
+      return null;
+    return `"${this.escapeGoString(value)}"`;
+  }
   literal(value, literalType) {
     if (literalType === "string")
       return `"${value}"`;
@@ -1905,9 +1982,7 @@ ${goFields.join(`
       message: `Higher-order method '.${method}' shape cannot be lowered to a Go template action`,
       loc: this.makeLoc(),
       suggestion: {
-        message: `Options:
-1. Use @client directive for client-side evaluation
-2. Pre-compute the value in Go code`
+        message: GO_REMEDIATION_OPTIONS
       }
     });
     return `""`;
@@ -2027,6 +2102,26 @@ ${goFields.join(`
   sortMethod(method, object, comparator, emit) {
     return emitBfSort(emit(object), comparator);
   }
+  reduceMethod(method, object, reduceOp, emit) {
+    const direction = method === "reduceRight" ? "right" : "left";
+    return emitBfReduce(emit(object), reduceOp, direction);
+  }
+  flatMethod(object, depth, emit) {
+    const d = depth === "infinity" ? -1 : depth;
+    return `bf_flat ${wrapIfMultiToken(emit(object))} ${d}`;
+  }
+  flatMapMethod(object, op, emit) {
+    const recv = wrapIfMultiToken(emit(object));
+    const proj = op.projection;
+    if (proj.kind === "tuple") {
+      const pairs = proj.elements.map((l) => l.kind === "self" ? `"self" ""` : `"field" "${capitalize(l.field)}"`).join(" ");
+      return `bf_flat_map_tuple ${recv} ${pairs}`;
+    }
+    if (proj.kind === "self") {
+      return `bf_flat_map ${recv} "self" ""`;
+    }
+    return `bf_flat_map ${recv} "field" "${capitalize(proj.field)}"`;
+  }
   unsupported(raw, _reason) {
     return `[UNSUPPORTED: ${raw}]`;
   }
@@ -2449,13 +2544,7 @@ ${goFields.join(`
         message: `Expression not supported: ${trimmed}`,
         loc: this.makeLoc(),
         suggestion: {
-          message: support.reason ? `${support.reason}
-
-Options:
-1. Use @client directive for client-side evaluation
-2. Pre-compute the value in Go code` : `Options:
-1. Use @client directive for client-side evaluation
-2. Pre-compute the value in Go code`
+          message: buildUnsupportedSuggestion(support)
         }
       });
       return `""`;
@@ -2484,9 +2573,7 @@ Options:
             message: `Complex predicate in else-if is not supported: ${altIfStmt.condition}`,
             loc: this.makeLoc(),
             suggestion: {
-              message: `Options:
-1. Use @client directive for client-side evaluation
-2. Pre-compute the value in Go code`
+              message: GO_REMEDIATION_OPTIONS
             }
           });
         }
@@ -2562,11 +2649,7 @@ Options:
         message: `Condition not supported: ${trimmed}`,
         loc: this.makeLoc(),
         suggestion: {
-          message: support.reason ? `${support.reason}
-
-Options:
-1. Use @client directive for client-side evaluation
-2. Pre-compute the value in Go code` : "Expression contains unsupported syntax"
+          message: buildUnsupportedSuggestion(support)
         }
       });
       return { condition: `false`, preamble: "" };
@@ -2579,6 +2662,9 @@ Options:
     switch (expr.kind) {
       case "identifier":
         {
+          const inlined = this.resolveModuleStringConst(expr.name);
+          if (inlined !== null)
+            return plain(inlined);
           const currentLoopParam = this.loopParamStack[this.loopParamStack.length - 1];
           if (currentLoopParam && expr.name === currentLoopParam) {
             return plain(".");
@@ -2601,6 +2687,20 @@ Options:
         if (expr.callee.kind === "identifier" && expr.args.length === 0) {
           return plain(this.rootFieldRef(expr.callee.name));
         }
+        if (expr.callee.kind === "identifier" && (identifierPath(expr.callee) ?? expr.callee.name) === "isValidElement" && expr.args.length === 1) {
+          return this.renderConditionExpr(expr.args[0]);
+        }
+        if (expr.callee.kind === "identifier" && !this.templatePrimitives[identifierPath(expr.callee) ?? ""]) {
+          const path = identifierPath(expr.callee) ?? expr.callee.name;
+          this.errors.push({
+            code: "BF102",
+            severity: "error",
+            message: `Predicate '${path}(...)' cannot be evaluated in a Go template. ` + `A server-side template cannot call user-defined JavaScript predicates.`,
+            loc: this.makeLoc(),
+            suggestion: { message: GO_REMEDIATION_OPTIONS }
+          });
+          return plain("false");
+        }
         return plain(this.renderParsedExpr(expr));
       }
       case "member": {
@@ -2812,6 +2912,9 @@ Options:
     if (comp.name === "Portal") {
       return this.renderPortalComponent(comp);
     }
+    if (comp.dynamicTag) {
+      return this.renderChildren(comp.children);
+    }
     let templateCall;
     if (this.inLoop) {
       templateCall = `{{template "${comp.name}" .}}`;
@@ -2955,7 +3058,7 @@ ${children}`;
           continue;
         const branches = caseEntries.map(([k, v], i) => {
           const head = i === 0 ? "{{if" : "{{else if";
-          return `${head} eq ${keyExpr} ${JSON.stringify(k)}}}${v}`;
+          return `${head} eq ${keyExpr} ${JSON.stringify(k)}}}${this.escapeAttrText(v)}`;
         });
         output += branches.join("") + "{{end}}";
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/go-template",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Go html/template adapter for BarefootJS - generates Go template files from IR",
   "type": "module",
   "main": "./dist/index.js",
@@ -54,6 +54,6 @@
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/jsx": "0.6.0"
+    "@barefootjs/jsx": "0.7.0"
   }
 }

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

@@ -76,16 +76,17 @@ runAdapterConformanceTests({
     // option fixed on the Hono side. Separate follow-up.
     'toggle-shared',
     'props-reactivity-comparison',
-    // #1467 Phase 2a: first `site/ui` source-root fixture. Button
-    // compiles cleanly on the Go adapter (no diagnostic), but its
-    // variant/size class composition (`Record<…>[key]` indexed object
-    // literals) and `applyRestAttrs` spread haven't been validated for
-    // byte-parity against the Hono reference under Go's template
-    // semantics. Cross-adapter parity for the `site/ui` corpus is
-    // explicitly Phase 3 ("cross-adapter parity (Mojo/Go templates)"),
-    // so Button participates only in Hono SSR conformance + the
-    // fixture-hydrate runtime layer for now.
-    'button',
+    // #1467 Phase 2b: basic interactive `site/ui` primitives. Cross-adapter
+    // parity for the `site/ui` corpus is Phase 3, so these participate only
+    // in Hono SSR conformance + the fixture-hydrate runtime layer for now.
+    // (`label` and `kbd` are static helpers; `toggle` / `switch` /
+    // `checkbox` carry uncontrolled state; `input` / `textarea` are
+    // pass-through native controls.)
+    'toggle',
+    'switch',
+    'checkbox',
+    'textarea',
+    'kbd',
   ],
   // Per-fixture build-time contracts for shapes the Go template
   // adapter intentionally refuses to lower. Lives here (not on the
@@ -298,6 +299,28 @@ export function Counter(props: { initial?: number }) {
       expect(result.types).toContain('Count int')
     })
 
+    test('module pure-string const referenced in className inlines the literal (#1467 Phase 2b)', () => {
+      // A module-scope `const X = 'literal'` used inside a className
+      // template literal must inline its value, NOT emit `{{.X}}` against a
+      // Props field that never exists (Go fails `can't evaluate field X`).
+      // Hono inlines it at runtime; this restores byte-parity.
+      const source = `
+"use client"
+const labelClasses = 'flex items-center group-data-[disabled=true]:opacity-50'
+export function Label({ className = '' }: { className?: string }) {
+  return <label className={\`\${labelClasses} \${className}\`} />
+}
+`
+      const { template, types } = compileAndGenerate(source)
+      // The literal is inlined as a Go string literal, escaped tokens intact.
+      expect(template).toContain(
+        '{{"flex items-center group-data-[disabled=true]:opacity-50"}}',
+      )
+      // No struct-field reference to the const, and no Props field for it.
+      expect(template).not.toContain('.LabelClasses')
+      expect(types).not.toContain('LabelClasses')
+    })
+
     test('dynamic loop with child component → NewXxxProps carries a populate-this-slice doc comment (#1442 echo TodoApp repro)', () => {
       // Regression: a `todos().map(t => <TodoItem todo={t} />)` loop with a
       // dynamic array (signal getter, not a static prop) declares
@@ -2318,6 +2341,81 @@ describe('GoTemplateAdapter - #1448 Tier A/B fixture-driven lowering pins', () =
 // now listed in `UNSUPPORTED_METHODS`, so `isSupported` refuses them
 // and `convertExpressionToGo` records BF101 — the same treatment the
 // unsupported array methods already got. These tests pin that parity.
+describe('GoTemplateAdapter - #1448 Tier C reduce field capitalisation', () => {
+  // #1728 review: `bf_reduce`'s projected field name must use the same
+  // initialism-aware capitalisation the adapter applies when generating
+  // struct fields (`capitalizeFieldName`), or the runtime reflect lookup
+  // misses the exported field (`id` → struct `ID`, not `Id`) and folds a
+  // zero value. Pin the emitted key so a regression to plain
+  // first-letter capitalisation fails here.
+  test('reduce over an initialism field emits the Go-initialism key (ID, not Id)', () => {
+    const adapter = new GoTemplateAdapter()
+    const ir = compileToIR(`
+function C({ items }: { items: { id: number }[] }) {
+  return <div>{items.reduce((sum, x) => sum + x.id, 0)}</div>
+}
+export { C }
+`, adapter)
+    const template = adapter.generate(ir).template ?? ''
+    expect(template).toContain('bf_reduce .Items "+" "field" "ID" "numeric" "0"')
+    expect(template).not.toContain('"Id"')
+  })
+})
+
+describe('GoTemplateAdapter - #1448 Tier C .flat(depth?)', () => {
+  function emitFlat(expr: string): string {
+    const adapter = new GoTemplateAdapter()
+    const ir = compileToIR(`
+function C({ rows }: { rows: number[][] }) {
+  return <div>{${expr}}</div>
+}
+export { C }
+`, adapter)
+    return adapter.generate(ir).template ?? ''
+  }
+
+  test('.flat() emits bf_flat with default depth 1', () => {
+    expect(emitFlat('rows.flat()')).toContain('bf_flat .Rows 1')
+  })
+
+  test('.flat(2) emits the explicit depth', () => {
+    expect(emitFlat('rows.flat(2)')).toContain('bf_flat .Rows 2')
+  })
+
+  test('.flat(Infinity) emits the -1 full-depth sentinel', () => {
+    expect(emitFlat('rows.flat(Infinity)')).toContain('bf_flat .Rows -1')
+  })
+})
+
+describe('GoTemplateAdapter - #1448 Tier C .flatMap(field projection)', () => {
+  function emitFlatMap(expr: string): string {
+    const adapter = new GoTemplateAdapter()
+    const ir = compileToIR(`
+function C({ rows }: { rows: { a: string; b: string; tags: string[] }[] }) {
+  return <div>{${expr}}</div>
+}
+export { C }
+`, adapter)
+    return adapter.generate(ir).template ?? ''
+  }
+
+  test('.flatMap(i => i.field) emits bf_flat_map with the Go-capitalised field', () => {
+    expect(emitFlatMap('rows.flatMap(i => i.tags).join(" ")')).toContain('bf_flat_map .Rows "field" "Tags"')
+  })
+
+  test('.flatMap(i => i) emits the self projection', () => {
+    expect(emitFlatMap('rows.flatMap(i => i).join(" ")')).toContain('bf_flat_map .Rows "self" ""')
+  })
+
+  test('.flatMap(i => [i.a, i.b]) emits bf_flat_map_tuple with capitalised leaves', () => {
+    expect(emitFlatMap('rows.flatMap(i => [i.a, i.b]).join(" ")')).toContain('bf_flat_map_tuple .Rows "field" "A" "field" "B"')
+  })
+
+  test('tuple self + field leaves', () => {
+    expect(emitFlatMap('rows.flatMap(i => [i, i.a]).join(" ")')).toContain('bf_flat_map_tuple .Rows "self" "" "field" "A"')
+  })
+})
+
 describe('GoTemplateAdapter - #1448 @client escape hatch (unsupported methods)', () => {
   // Compile a single expression placed in `<div>` text position, with
   // and without the directive, and return both the build errors and
@@ -2363,10 +2461,14 @@ export function C() {
   // Go fragment that must NOT survive into the template (the pre-fix
   // silent-footgun output for the string rows).
   const unsupported: Array<{ name: string; expr: string; badEmit: string }> = [
-    // Tier C array methods.
-    { name: 'reduce', expr: `items().reduce((a, b) => a + b.n, 0)`, badEmit: '.Reduce' },
-    { name: 'flatMap', expr: `items().flatMap(i => i.tags)`, badEmit: '.FlatMap' },
-    { name: 'flat', expr: `items().flat()`, badEmit: '.Flat' },
+    // Tier C array methods. The arithmetic-fold `.reduce(fn, init)`
+    // catalogue now lowers (pinned in the positive reduce-* fixtures);
+    // the no-initial-value form stays refused — JS throws on an empty
+    // array there, which a template can't mirror.
+    { name: 'reduce (no init)', expr: `items().reduce((a, b) => a + b.n)`, badEmit: '.Reduce' },
+    // Self / field / field-tuple `.flatMap` now lowers (#1448 Tier C); a
+    // tuple with a non-leaf element (here a string literal) stays refused.
+    { name: 'flatMap (literal element)', expr: `items().flatMap(i => [i.name, "x"])`, badEmit: '.FlatMap' },
     // Lowered methods whose MEANINGFUL extra argument isn't lowered yet
     // (#1448): the `fromIndex` of `.includes`/`.indexOf`/`.lastIndexOf`
     // and the variadic `.concat`. The parser refuses these (silently
@@ -2401,6 +2503,40 @@ export function C() {
     })
   }
 
+  // The diagnostic's `suggestion.message` is shaped by `isSupported`'s
+  // `selfContained` flag: reasons that already spell out the fix are shown
+  // as-is, while low-level parser reasons still get the adapter's generic
+  // "Options" remediation appended so users never lose actionable steps.
+  function suggestionFor(expr: string): string {
+    const { errors } = emit(expr, false)
+    const e = errors.find(e => e.code === 'BF101' || e.code === 'BF102')
+    return e?.suggestion?.message ?? ''
+  }
+
+  test('self-contained reason is shown without the generic Options block', () => {
+    // Generic unsupported-method reason already carries the remedy.
+    const msg = suggestionFor('items().reduce((a, b) => a + b.n)')
+    expect(msg).toContain('no SSR')
+    expect(msg).not.toContain('Options:')
+  })
+
+  test('tailored forEach reason keeps its own guidance, no Options block', () => {
+    const msg = suggestionFor('items().forEach(x => x)')
+    expect(msg).toContain("'.map(")
+    // The forEach message deliberately steers away from @client; the
+    // generic Options block (which re-suggests it) must not be appended.
+    expect(msg).not.toContain('Options:')
+    expect(msg).not.toContain('@client')
+  })
+
+  test('low-level reason still gets the actionable Options block appended', () => {
+    // `typeof` has no structured remedy reason → users must keep the
+    // generic next steps (regression guard for #1730 review).
+    const msg = suggestionFor('typeof items()')
+    expect(msg).toContain('Options:')
+    expect(msg).toContain('@client')
+  })
+
   // Predicate-level use of an unsupported string method also fails the
   // build loudly (intended): a `.filter(t => t.name.charAt(0) === "a")`
   // whose predicate calls one of the gated methods now refuses the whole

package/src/__tests__/slot-dynamic-tag.test.ts

@@ -0,0 +1,79 @@
+/**
+ * Pins the Go template lowering of the `Slot` component's dynamic tag.
+ *
+ * `Slot` does `const Tag = children.tag; return <Tag …>{…}</Tag>` inside
+ * an `if (isValidElement(children)) { … }` block. A naive lowering would:
+ *   1. emit `{{template "Tag" .TagSlot0}}` — a template that can never be
+ *      registered. Go's html/template escape-walks ALL registered
+ *      templates (even dead branches), so the whole render fails with
+ *      `no such template "Tag"`.
+ *   2. lower `isValidElement(children)` to a bogus `.IsValidElement`
+ *      struct-field access (a user type-guard predicate Go can't evaluate).
+ *
+ * The `dynamicTag` IR flag (jsx-to-ir) plus the call-condition fallback
+ * (go-template-adapter) defuse both. This test asserts the *emitted Go
+ * template string* carries neither pathology, complementing the full
+ * conformance render in `go-template-adapter.test.ts`.
+ */
+
+import { describe, test, expect } from 'bun:test'
+import { GoTemplateAdapter } from '../adapter/go-template-adapter'
+import { compileJSX } from '@barefootjs/jsx'
+
+// The committed SSR-precompiled Slot module the conformance harness feeds
+// to Go (`children.tag` dynamic tag inside an isValidElement guard).
+const SLOT_SSR = `/** @jsxImportSource hono/jsx */
+interface SlotProps { children?: unknown; className?: string; [key: string]: unknown }
+function isValidElement(element: unknown): element is { tag: unknown; props: Record<string, unknown> } {
+  return !!(element && typeof element === 'object' && 'tag' in element && 'props' in element)
+}
+export function Slot({ children, className, ...props }: SlotProps) {
+  if (children && isValidElement(children)) {
+    const Tag = children.tag as any
+    const childProps = children.props
+    const childClass = (childProps.className as string) || ''
+    const childChildren = childProps.children
+    const mergedClass = [className, childClass].filter(Boolean).join(' ')
+    return <Tag {...childProps} {...props} className={mergedClass || undefined}>{childChildren}</Tag>
+  }
+  return <>{children}</>
+}
+`
+
+describe('Slot dynamic-tag Go lowering', () => {
+  test('emitted Go template has no `{{template "Tag"` call and no `.IsValidElement` field', () => {
+    const adapter = new GoTemplateAdapter()
+    const result = compileJSX(SLOT_SSR, 'slot.tsx', { adapter, componentName: 'Slot' })
+    expect(result.errors.filter(e => e.severity === 'error')).toEqual([])
+    const template = result.files.find(f => f.type === 'markedTemplate')!
+    expect(template).toBeDefined()
+    expect(template.content).not.toContain('{{template "Tag"')
+    expect(template.content).not.toContain('.IsValidElement')
+  })
+
+  test('`isValidElement(children)` lowers to a real truthiness check — no diagnostic, no forced literal', () => {
+    const adapter = new GoTemplateAdapter()
+    const result = compileJSX(SLOT_SSR, 'slot.tsx', { adapter, componentName: 'Slot' })
+    // The guard evaluates faithfully on Go (element ⟺ has children to render),
+    // so there is neither an error nor an ignorable warning, and the condition
+    // is a real `.Children` truthiness check rather than a fudged literal.
+    expect(result.errors).toEqual([])
+    const template = result.files.find(f => f.type === 'markedTemplate')!
+    expect(template.content).toContain('.Children')
+  })
+
+  test('a non-isValidElement user predicate (e.g. `isAdmin`) is a hard BF102 error, not a silent literal', () => {
+    const SRC = `/** @jsxImportSource hono/jsx */
+declare function isAdmin(u: unknown): boolean
+export function Gate({ user }: { user?: unknown }) {
+  return <div>{isAdmin(user) ? <span>secret</span> : null}</div>
+}
+`
+    const adapter = new GoTemplateAdapter()
+    const result = compileJSX(SRC, 'gate.tsx', { adapter, componentName: 'Gate' })
+    const errors = result.errors.filter(e => e.severity === 'error')
+    expect(
+      errors.some(e => e.code === 'BF102' && /cannot be evaluated/i.test(e.message))
+    ).toBe(true)
+  })
+})