@pyreon/compiler 0.15.0 → 0.18.0

package/src/tests/defer-inline.test.ts

@@ -0,0 +1,199 @@
+import { transformDeferInline } from '../defer-inline'
+
+describe('transformDeferInline — basic rewrites', () => {
+  test('rewrites <Defer when={x}><Modal /></Defer> with named import', () => {
+    const input = `
+import { Defer } from '@pyreon/core'
+import { Modal } from './Modal'
+
+export function App() {
+  const open = () => true
+  return <Defer when={open}><Modal /></Defer>
+}
+`
+    const result = transformDeferInline(input, 'app.tsx')
+    expect(result.changed).toBe(true)
+    expect(result.code).not.toContain("import { Modal } from './Modal'")
+    expect(result.code).toContain(`chunk={() => import('./Modal').then((__m) => ({ default: __m.Modal }))}`)
+    expect(result.code).toContain('{(__C) => <__C />}')
+  })
+
+  test('rewrites with default import', () => {
+    const input = `
+import { Defer } from '@pyreon/core'
+import Modal from './Modal'
+
+export function App() {
+  return <Defer when={() => true}><Modal /></Defer>
+}
+`
+    const result = transformDeferInline(input, 'app.tsx')
+    expect(result.changed).toBe(true)
+    expect(result.code).not.toContain('import Modal from')
+    expect(result.code).toContain(`chunk={() => import('./Modal')}`)
+    expect(result.code).not.toContain(`.then((__m) =>`)
+  })
+
+  test('preserves other props on Defer (fallback, when, on)', () => {
+    const input = `
+import { Defer } from '@pyreon/core'
+import { Modal } from './Modal'
+export function App() {
+  return <Defer when={() => true} fallback={<span>loading</span>}><Modal /></Defer>
+}
+`
+    const result = transformDeferInline(input, 'app.tsx')
+    expect(result.changed).toBe(true)
+    expect(result.code).toContain('when={() => true}')
+    expect(result.code).toContain('fallback={<span>loading</span>}')
+  })
+
+  test('works for on="visible" trigger', () => {
+    const input = `
+import { Defer } from '@pyreon/core'
+import { Comments } from './Comments'
+export function Post() {
+  return <Defer on="visible"><Comments /></Defer>
+}
+`
+    const result = transformDeferInline(input, 'post.tsx')
+    expect(result.changed).toBe(true)
+    expect(result.code).toContain('on="visible"')
+    expect(result.code).toContain(`chunk={() => import('./Comments').then((__m) => ({ default: __m.Comments }))}`)
+  })
+})
+
+describe('transformDeferInline — bail-out cases', () => {
+  test('leaves unchanged when chunk prop is already provided', () => {
+    const input = `
+import { Defer } from '@pyreon/core'
+import { Modal } from './Modal'
+export function App() {
+  return (
+    <Defer chunk={() => import('./Modal')} when={() => true}>
+      {Modal => <Modal />}
+    </Defer>
+  )
+}
+`
+    const result = transformDeferInline(input, 'app.tsx')
+    expect(result.changed).toBe(false)
+    expect(result.code).toBe(input)
+    expect(result.warnings).toEqual([])
+  })
+
+  test('warns when inline child is also used outside the Defer', () => {
+    const input = `
+import { Defer } from '@pyreon/core'
+import { Modal } from './Modal'
+const eagerCopy = <Modal />
+export function App() {
+  return <Defer when={() => true}><Modal /></Defer>
+}
+`
+    const result = transformDeferInline(input, 'app.tsx')
+    expect(result.changed).toBe(false)
+    expect(result.warnings).toHaveLength(1)
+    expect(result.warnings[0]!.code).toBe('defer-inline/import-used-elsewhere')
+  })
+
+  test('warns when inline child is not imported', () => {
+    const input = `
+import { Defer } from '@pyreon/core'
+export function App() {
+  return <Defer when={() => true}><LocalThing /></Defer>
+}
+function LocalThing() { return null }
+`
+    const result = transformDeferInline(input, 'app.tsx')
+    expect(result.changed).toBe(false)
+    expect(result.warnings).toHaveLength(1)
+    expect(result.warnings[0]!.code).toBe('defer-inline/import-not-found')
+  })
+
+  test('skips Defer with multiple children (still requires render-prop form)', () => {
+    const input = `
+import { Defer } from '@pyreon/core'
+import { Modal } from './Modal'
+import { Spinner } from './Spinner'
+export function App() {
+  return <Defer when={() => true}><Modal /><Spinner /></Defer>
+}
+`
+    const result = transformDeferInline(input, 'app.tsx')
+    // No transform fires (multi-child shape doesn't match the inline-eligible
+    // single-component-child pattern). No warning either — v1 just leaves it
+    // alone; downstream Defer's runtime behaviour handles the malformed shape.
+    expect(result.changed).toBe(false)
+  })
+
+  test('skips Defer whose child has props (multi-prop closure capture)', () => {
+    const input = `
+import { Defer } from '@pyreon/core'
+import { Modal } from './Modal'
+export function App() {
+  return <Defer when={() => true}><Modal title="hi" /></Defer>
+}
+`
+    const result = transformDeferInline(input, 'app.tsx')
+    expect(result.changed).toBe(false)
+  })
+
+  test('fast-path: no Defer in source returns unchanged', () => {
+    const input = `
+import { signal } from '@pyreon/reactivity'
+export const count = signal(0)
+`
+    const result = transformDeferInline(input, 'count.ts')
+    expect(result.changed).toBe(false)
+    expect(result.code).toBe(input)
+  })
+
+  test('does not blow up on syntactically-invalid source — returns unchanged', () => {
+    const input = `import {{{ Defer broken syntax`
+    const result = transformDeferInline(input, 'broken.tsx')
+    expect(result.changed).toBe(false)
+    // Returns the input unchanged; downstream parser will surface the real error.
+    expect(result.code).toBe(input)
+  })
+
+  test('skips renamed imports — { Modal as M } not handled in v1', () => {
+    const input = `
+import { Defer } from '@pyreon/core'
+import { Modal as M } from './Modal'
+export function App() {
+  return <Defer when={() => true}><M /></Defer>
+}
+`
+    const result = transformDeferInline(input, 'app.tsx')
+    expect(result.changed).toBe(false)
+    // Renamed-import case is not yet supported — falls through to the
+    // import-not-found warning (no specifier whose `local.name === 'M'`
+    // AND `imported.name === local.name` matches).
+    expect(result.warnings[0]?.code).toBe('defer-inline/import-not-found')
+  })
+})
+
+describe('transformDeferInline — multiple Defers in one file', () => {
+  test('rewrites two independent Defers with distinct imports', () => {
+    const input = `
+import { Defer } from '@pyreon/core'
+import { Modal } from './Modal'
+import { Comments } from './Comments'
+export function App() {
+  return (
+    <div>
+      <Defer when={() => true}><Modal /></Defer>
+      <Defer on="visible"><Comments /></Defer>
+    </div>
+  )
+}
+`
+    const result = transformDeferInline(input, 'app.tsx')
+    expect(result.changed).toBe(true)
+    expect(result.code).not.toContain("import { Modal } from './Modal'")
+    expect(result.code).not.toContain("import { Comments } from './Comments'")
+    expect(result.code).toContain(`chunk={() => import('./Modal').then((__m) => ({ default: __m.Modal }))}`)
+    expect(result.code).toContain(`chunk={() => import('./Comments').then((__m) => ({ default: __m.Comments }))}`)
+  })
+})

package/src/tests/detector-tag-consistency.test.ts

@@ -2,18 +2,22 @@ import { readFileSync } from 'node:fs'
 import { dirname, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
 
-// Drift guard between the static `detectPyreonPatterns` detector codes
-// and the `[detector: <code>]` annotations on `.claude/rules/anti-patterns.md`.
+// Drift guard between Pyreon's static detectors (compiler + lint) and the
+// `[detector: <code>]` annotations on `.claude/rules/anti-patterns.md`.
 // Without this test, a new bullet can land without a detector tag, or
 // a detector code can be renamed without updating the doc. Either
 // direction is a silent inconsistency — consumers read the doc and
 // expect the detector to back it up.
 //
 // The test does one thing: every `[detector: CODE]` tag in the doc
-// must reference a PyreonDiagnosticCode (or the literal `N/A` for
-// bullets explicitly declared doc-only), and every
-// PyreonDiagnosticCode must appear at least once in the doc so the
-// tag-documentation loop is closed.
+// must reference a known detector (compiler PyreonDiagnosticCode OR
+// @pyreon/lint rule ID without the `pyreon/` prefix), and every
+// compiler PyreonDiagnosticCode must appear at least once in the doc
+// so the tag-documentation loop is closed.
+//
+// Lint rules are NOT required to appear in anti-patterns.md (some are
+// stylistic, not anti-pattern shaped). When they DO appear with a
+// `[detector:]` tag, the tag must match the rule ID's local part.
 
 const HERE = dirname(fileURLToPath(import.meta.url))
 const REPO_ROOT = resolve(HERE, '../../../../../')
@@ -22,7 +26,7 @@ const ANTI_PATTERNS_PATH = resolve(REPO_ROOT, '.claude/rules/anti-patterns.md')
 // Kept in sync with the `PyreonDiagnosticCode` union in
 // `pyreon-intercept.ts`. When adding a new code, ALSO add a bullet
 // (with the `[detector: <code>]` tag) to `anti-patterns.md`.
-const KNOWN_CODES = [
+const COMPILER_CODES = [
   'for-missing-by',
   'for-with-key',
   'props-destructured',
@@ -35,8 +39,17 @@ const KNOWN_CODES = [
   'signal-write-as-call',
   'static-return-null-conditional',
   'as-unknown-as-vnodechild',
+  'island-never-with-registry-entry',
+] as const
+type CompilerCode = (typeof COMPILER_CODES)[number]
+
+// `@pyreon/lint` rule IDs that may appear as `[detector:]` tags. Listed
+// WITHOUT the `pyreon/` prefix (the tag convention strips it for
+// readability). Add the rule ID here when documenting a new lint rule
+// in anti-patterns.md.
+const LINT_RULE_DETECTORS = [
+  'storage-signal-v-forwarding',
 ] as const
-type KnownCode = (typeof KNOWN_CODES)[number]
 
 function readAntiPatterns(): string {
   return readFileSync(ANTI_PATTERNS_PATH, 'utf8')
@@ -57,20 +70,20 @@ function extractDetectorTags(doc: string): string[] {
   return found
 }
 
-describe('anti-patterns.md detector tags vs PyreonDiagnosticCode', () => {
+describe('anti-patterns.md detector tags vs static detectors', () => {
   const doc = readAntiPatterns()
   const tags = extractDetectorTags(doc)
 
-  it('every [detector: CODE] tag references a known PyreonDiagnosticCode', () => {
-    const validCodes = new Set<string>(KNOWN_CODES)
+  it('every [detector: CODE] tag references a known detector (compiler or lint)', () => {
+    const validCodes = new Set<string>([...COMPILER_CODES, ...LINT_RULE_DETECTORS])
     const unknown = tags.filter((t) => !validCodes.has(t) && t !== 'N/A')
     expect(unknown).toEqual([])
   })
 
   it('every PyreonDiagnosticCode appears at least once as a [detector:] tag', () => {
     const tagSet = new Set(tags)
-    const missing: KnownCode[] = []
-    for (const code of KNOWN_CODES) {
+    const missing: CompilerCode[] = []
+    for (const code of COMPILER_CODES) {
       if (!tagSet.has(code)) missing.push(code)
     }
     // If this fails, add a bullet for the new detector code to
@@ -80,7 +93,7 @@ describe('anti-patterns.md detector tags vs PyreonDiagnosticCode', () => {
     expect(missing).toEqual([])
   })
 
-  it('reports at least as many tags as detector codes (multi-code bullets allowed)', () => {
-    expect(tags.length).toBeGreaterThanOrEqual(KNOWN_CODES.length)
+  it('reports at least as many tags as compiler detector codes (multi-code bullets allowed)', () => {
+    expect(tags.length).toBeGreaterThanOrEqual(COMPILER_CODES.length)
   })
 })