tjs-lang 0.7.7 → 0.7.8

package/src/lang/bool-coercion.ts

@@ -0,0 +1,314 @@
+/**
+ * Boolean coercion rewriter.
+ *
+ * Fixes the JS footgun `Boolean(new Boolean(false)) === true` (and friends)
+ * by rewriting every truthiness context to call `__tjs.toBool(x)`, which
+ * unwraps boxed primitives before coercing.
+ *
+ * Contexts rewritten:
+ *   if (cond)           → if (__tjs.toBool(cond))
+ *   while (cond)        → while (__tjs.toBool(cond))
+ *   do {} while (cond)  → do {} while (__tjs.toBool(cond))
+ *   for (_; cond; _)    → for (_; __tjs.toBool(cond); _)
+ *   !x                  → !__tjs.toBool(x)
+ *   a && b              → ((__tjs__t)=>__tjs.toBool(__tjs__t)?(b):__tjs__t)(a)
+ *   a || b              → ((__tjs__t)=>__tjs.toBool(__tjs__t)?__tjs__t:(b))(a)
+ *   a ? b : c           → __tjs.toBool(a)?(b):(c)
+ *   Boolean(x)          → __tjs.toBool(x)        (call form, not `new`)
+ *
+ * `??` (nullish coalescing) is intentionally NOT rewritten — its semantics
+ * are about null/undefined specifically, not truthiness, so boxed primitives
+ * behave correctly already.
+ *
+ * `===` / `!==` (identity) are also not touched — that's a separate
+ * footgun handled by the `Is` / `Eq` operators under TjsEquals.
+ *
+ * Always-on under TjsStandard.
+ */
+
+import * as acorn from 'acorn'
+import type { Program, Node } from 'acorn'
+
+export interface BoolCoercionPatch {
+  start: number
+  end: number
+  newText: string
+}
+
+/**
+ * Walk the AST and emit replacement patches for every truthiness context.
+ * Patches are pre-deduped: nested coercions inside an outer patch are
+ * folded into the outer patch's newText, so returned patches don't overlap.
+ */
+export function rewriteBoolCoercion(
+  ast: Program,
+  source: string
+): BoolCoercionPatch[] {
+  const candidates: BoolCoercionPatch[] = []
+
+  function emitTestWrap(test: Node): void {
+    candidates.push({
+      start: test.start,
+      end: test.end,
+      newText: `__tjs.toBool(${rewriteExpr(test, source)})`,
+    })
+  }
+
+  function visit(node: Node): void {
+    if (!node || typeof node !== 'object' || !('type' in node)) return
+
+    switch ((node as any).type) {
+      case 'IfStatement':
+      case 'WhileStatement':
+      case 'DoWhileStatement': {
+        const n = node as any
+        emitTestWrap(n.test)
+        // Visit the body / consequent / alternate normally
+        if (n.consequent) visit(n.consequent)
+        if (n.alternate) visit(n.alternate)
+        if (n.body) visit(n.body)
+        return
+      }
+      case 'ForStatement': {
+        const n = node as any
+        if (n.init) visit(n.init)
+        if (n.test) emitTestWrap(n.test)
+        if (n.update) visit(n.update)
+        if (n.body) visit(n.body)
+        return
+      }
+      case 'ConditionalExpression': {
+        const n = node as any
+        candidates.push({
+          start: n.start,
+          end: n.end,
+          newText:
+            `__tjs.toBool(${rewriteExpr(n.test, source)})` +
+            `?(${rewriteExpr(n.consequent, source)})` +
+            `:(${rewriteExpr(n.alternate, source)})`,
+        })
+        return
+      }
+      case 'LogicalExpression': {
+        const n = node as any
+        if (n.operator === '&&' || n.operator === '||') {
+          candidates.push({
+            start: n.start,
+            end: n.end,
+            newText: rewriteExpr(node, source),
+          })
+          return
+        }
+        // ?? unchanged — descend in case nested coercions live in the operands
+        break
+      }
+      case 'UnaryExpression': {
+        const n = node as any
+        if (n.operator === '!') {
+          candidates.push({
+            start: n.start,
+            end: n.end,
+            newText: `!__tjs.toBool(${rewriteExpr(n.argument, source)})`,
+          })
+          return
+        }
+        break
+      }
+      case 'CallExpression': {
+        const n = node as any
+        if (
+          n.callee &&
+          n.callee.type === 'Identifier' &&
+          n.callee.name === 'Boolean' &&
+          n.arguments.length === 1 &&
+          n.arguments[0].type !== 'SpreadElement'
+        ) {
+          // Boolean(x) → __tjs.toBool(x). Rare in practice but eliminates
+          // the inconsistency with the rewritten `if (x)` cases.
+          candidates.push({
+            start: n.start,
+            end: n.end,
+            newText: `__tjs.toBool(${rewriteExpr(n.arguments[0], source)})`,
+          })
+          return
+        }
+        break
+      }
+    }
+
+    // Default: walk children
+    walkChildren(node, visit)
+  }
+
+  visit(ast)
+
+  return dedupeNested(candidates)
+}
+
+/**
+ * Recursive partial codegen: returns the rewritten source for an expression
+ * subtree. For uninteresting nodes, returns the original source slice with
+ * any nested coercions rewritten in place.
+ */
+function rewriteExpr(node: Node | null | undefined, source: string): string {
+  if (!node) return ''
+  switch ((node as any).type) {
+    case 'LogicalExpression': {
+      const n = node as any
+      const left = rewriteExpr(n.left, source)
+      const right = rewriteExpr(n.right, source)
+      if (n.operator === '&&') {
+        return `((__tjs__t)=>__tjs.toBool(__tjs__t)?(${right}):__tjs__t)(${left})`
+      }
+      if (n.operator === '||') {
+        return `((__tjs__t)=>__tjs.toBool(__tjs__t)?__tjs__t:(${right}))(${left})`
+      }
+      // ??
+      return `(${left})??(${right})`
+    }
+    case 'ConditionalExpression': {
+      const n = node as any
+      return (
+        `__tjs.toBool(${rewriteExpr(n.test, source)})` +
+        `?(${rewriteExpr(n.consequent, source)})` +
+        `:(${rewriteExpr(n.alternate, source)})`
+      )
+    }
+    case 'UnaryExpression': {
+      const n = node as any
+      if (n.operator === '!') {
+        return `!__tjs.toBool(${rewriteExpr(n.argument, source)})`
+      }
+      return rewriteOther(node, source)
+    }
+    case 'CallExpression': {
+      const n = node as any
+      if (
+        n.callee &&
+        n.callee.type === 'Identifier' &&
+        n.callee.name === 'Boolean' &&
+        n.arguments.length === 1 &&
+        n.arguments[0].type !== 'SpreadElement'
+      ) {
+        return `__tjs.toBool(${rewriteExpr(n.arguments[0], source)})`
+      }
+      return rewriteOther(node, source)
+    }
+  }
+  return rewriteOther(node, source)
+}
+
+/**
+ * Generic structural recursion: walk all child nodes in source order, splice
+ * rewritten children into the original source between gaps. This preserves
+ * arbitrary syntax (template literals, destructuring, JSX, etc.) without
+ * needing a full code generator — we only customize the nodes we actually
+ * rewrite.
+ */
+function rewriteOther(node: Node, source: string): string {
+  const start = (node as any).start
+  const end = (node as any).end
+  if (typeof start !== 'number' || typeof end !== 'number') return ''
+
+  const children = collectChildren(node)
+  if (children.length === 0) return source.slice(start, end)
+
+  // Sort by start position (defensive — should already be in order)
+  children.sort((a, b) => a.start - b.start)
+
+  let out = ''
+  let cursor = start
+  for (const child of children) {
+    if (child.start < cursor) continue // overlapping; skip
+    if (child.start > cursor) out += source.slice(cursor, child.start)
+    out += rewriteExpr(child, source)
+    cursor = child.end
+  }
+  if (cursor < end) out += source.slice(cursor, end)
+  return out
+}
+
+/** Iterate the children of `cb` for any node, generic shape. */
+function walkChildren(node: Node, cb: (n: Node) => void): void {
+  for (const child of collectChildren(node)) cb(child)
+}
+
+function collectChildren(node: Node): Node[] {
+  const out: Node[] = []
+  for (const key in node) {
+    if (key === 'type' || key === 'start' || key === 'end' || key === 'loc') {
+      continue
+    }
+    const v = (node as any)[key]
+    if (Array.isArray(v)) {
+      for (const item of v) {
+        if (item && typeof item === 'object' && typeof item.type === 'string') {
+          out.push(item)
+        }
+      }
+    } else if (v && typeof v === 'object' && typeof v.type === 'string') {
+      out.push(v)
+    }
+  }
+  return out
+}
+
+/**
+ * Drop patches whose range is fully contained in another patch's range.
+ * The outer patch's newText already includes the inner rewrites via the
+ * recursive partial codegen, so the inner patch is redundant.
+ *
+ * Equal-range patches: keep the first one encountered (insertion order
+ * mirrors AST traversal order, where the parent is visited first).
+ */
+function dedupeNested(patches: BoolCoercionPatch[]): BoolCoercionPatch[] {
+  // Sort by start asc, end desc (outermost first for equal starts)
+  const sorted = [...patches].sort((a, b) => a.start - b.start || b.end - a.end)
+  const kept: BoolCoercionPatch[] = []
+  let lastEnd = -1
+  for (const p of sorted) {
+    if (p.start >= lastEnd) {
+      kept.push(p)
+      lastEnd = p.end
+    }
+    // else: contained inside the last kept patch — drop
+  }
+  return kept
+}
+
+/**
+ * Source-text wrapper: parse, rewrite, re-emit. Used for code that's
+ * extracted before the main parse (test/mock bodies) but still needs the
+ * coercion rewrite to behave consistently with the rest of the module.
+ *
+ * Wraps the body in a function so top-level statements like `expect(...)`
+ * parse as a Program. Returns the original source unchanged if parsing
+ * fails (rather than throwing — a bad test body would already have been
+ * caught by the main parse).
+ */
+export function rewriteBoolCoercionInSource(source: string): string {
+  let ast: Program
+  try {
+    ast = acorn.parse(`function __wrap__(){${source}}`, {
+      ecmaVersion: 2022,
+      sourceType: 'module',
+      locations: false,
+    }) as Program
+  } catch {
+    return source
+  }
+  const wrapped = `function __wrap__(){${source}}`
+  const patches = rewriteBoolCoercion(ast, wrapped)
+  if (patches.length === 0) return source
+
+  // Apply patches right-to-left
+  patches.sort((a, b) => b.start - a.start)
+  let out = wrapped
+  for (const p of patches) {
+    out = out.slice(0, p.start) + p.newText + out.slice(p.end)
+  }
+  // Strip the wrapper
+  const prefix = 'function __wrap__(){'
+  const suffix = '}'
+  return out.slice(prefix.length, out.length - suffix.length)
+}

package/src/lang/codegen.test.ts

@@ -1446,6 +1446,143 @@ function getData(id: 0):! { value: 0 } {
       // But error properties are accessible
       expect(result.message).toContain('Expected integer')
     })
+
+    it('returns MonadicError when a function param receives a non-function', () => {
+      const { code } = tjs(`function f(fn = (x) => x): 0 { return fn(5) }`)
+      const f = new Function(code + '; return f')()
+
+      // Passing a function: works
+      expect(f((n: number) => n * 2)).toBe(10)
+
+      // Passing a non-function: MonadicError
+      for (const bad of [42, 'hello', { x: 1 }, [1, 2], true]) {
+        const result = f(bad)
+        expect(result).toBeInstanceOf(MonadicError)
+        expect(result.expected).toBe('function')
+        expect(result.path).toContain('f.fn')
+      }
+    })
+
+    describe('checkFnShape — pass-time shape check for function params', () => {
+      it('passes a correctly-typed TJS function through unchanged', () => {
+        // strLength has __tjs metadata declaring (string) => integer,
+        // matching counter's expected shape via cross-ref inference.
+        const { code } = tjs(`function strLength(s: ''): 0 { return s.length }
+function map(arr: [''], counter = strLength): [0] { return arr.map(counter) }`)
+        const fns = new Function(code + '\nreturn { strLength, map }')()
+        expect(fns.map(['hello', 'hi'])).toEqual([5, 2])
+      })
+
+      it('returns ONE MonadicError when a typed callback has the wrong return shape', () => {
+        // badFn declares (string) => boolean — counter expects (string) => integer.
+        const { code } = tjs(`function strLength(s: ''): 0 { return s.length }
+function badFn(s: ''): true { return true }
+function map(arr: [''], counter = strLength): [0] { return arr.map(counter) }`)
+        const fns = new Function(code + '\nreturn { badFn, map }')()
+        const r = fns.map(['hi', 'world'], fns.badFn)
+        expect(r).toBeInstanceOf(MonadicError)
+        expect(r.expected).toBe('integer')
+        expect(r.path).toContain('map.counter(return)')
+      })
+
+      it('passes untyped arrows through unchanged (no per-call wrapping)', () => {
+        // x => false has no __tjs metadata. checkFnShape sees no metadata
+        // and returns the function unchanged. The body runs unmolested
+        // and returns whatever the body returns. The user's mental model:
+        // "if I pass an untyped function, you trust it".
+        const { code } = tjs(`function strLength(s: ''): 0 { return s.length }
+function map(arr: [''], counter = strLength): [0] { return arr.map(counter) }`)
+        const fns = new Function(code + '\nreturn { map }')()
+        // (x) => false returns boolean for each call. Result is array of
+        // booleans, NOT array of MonadicErrors. The outer return doesn't
+        // validate items by default (no :?).
+        const r = fns.map(['hi', 'world'], (x: string) => false)
+        expect(Array.isArray(r)).toBe(true)
+        expect(r).toEqual([false, false])
+      })
+
+      it('does not emit checkFnShape when shape is empty (all-any)', () => {
+        // `(x) => x` infers params=[{x: any}], returns: any
+        // → nothing useful to check → emitter omits the call
+        const { code: code3 } = tjs(`function h(fn = (x) => x): 0 { return 0 }`)
+        expect(code3).not.toContain('__tjs.checkFnShape')
+      })
+
+      it('emits checkFnShape when only the return type is known', () => {
+        // `() => 5` infers no params, returns: integer
+        const { code } = tjs(`function k(make = () => 5): 0 { return make() }`)
+        expect(code).toContain('__tjs.checkFnShape')
+      })
+
+      it('array param with embedded MonadicError propagates the first error', () => {
+        // The "errors propagate, not accumulate" rule: when an array
+        // input contains a MonadicError, the receiving function emits
+        // that error directly instead of saying "expected array, got X".
+        const { code } = tjs(`function first(s: ['hi']): 'hi' { return s[0] }`)
+        const fns = new Function(code + '\nreturn { first }')()
+        const fakeError = Object.assign(new Error('preexisting'), {
+          name: 'MonadicError',
+          path: 'somewhere.x',
+          expected: 'integer',
+          actual: 'string',
+        })
+        const r = fns.first([fakeError, 'world'])
+        expect(r).toBeInstanceOf(Error)
+        expect(r.path).toBe('somewhere.x') // the propagated error, not a new one
+        expect(r.message).toBe('preexisting')
+      })
+
+      it('module-level errors do not attribute to function declaration line', () => {
+        // Reported case: an error in top-level imperative code (here `x` is
+        // undefined) caused signature tests to fail with `line: 1` (the
+        // function declaration's line), so the editor marked line 1 instead
+        // of letting the user find the actual error on line 5.
+        const { testResults } = tjs(
+          `function f(s: ''): 0 { return s.length }\n\nconsole.log(x)`,
+          { runTests: 'report' }
+        )
+        const sig = testResults?.find((t) => t.isSignatureTest)
+        expect(sig).toBeDefined()
+        expect(sig?.passed).toBe(false)
+        expect(sig?.error).toContain('Module execution failed')
+        // Critical: no line attribution → editor won't mark a misleading line
+        expect(sig?.line).toBeUndefined()
+      })
+
+      it("user's reported case: x => false passes through cleanly", () => {
+        // The original frustration: `mapStrings(['hi'], x => false)` was
+        // producing array of MonadicErrors. Now untyped arrows pass
+        // through and the function body runs unmolested.
+        const { code } = tjs(`function strLength(s: 'hello'): 5 {
+  return s.length
+}
+function mapStrings(s: ['hello', 'foo'], counter = strLength): [5, 3] {
+  return s.map(counter)
+}`)
+        const fns = new Function(code + '\nreturn { mapStrings }')()
+        const r = fns.mapStrings(['hello', 'world'], (x: string) => false)
+        // Untyped arrow → no checks → array of booleans (no error pollution)
+        expect(r).toEqual([false, false])
+        expect(r.every((v: any) => v instanceof Error)).toBe(false)
+      })
+
+      it("propagates a referenced function's signature (cross-ref)", () => {
+        // `counter = strLength` should give `counter` strLength's signature
+        // `(s: '') => 0`, even though the AST default is just an Identifier.
+        const src = `function strLength(s: ''): 0 { return s.length }
+function map(arr: [''], counter = strLength): [0] { return arr.map(counter) }`
+        const r = tjs(src)
+        const counterType = r.types?.map?.params?.counter?.type
+        expect(counterType?.kind).toBe('function')
+        expect(counterType?.params).toEqual([
+          { name: 's', type: { kind: 'string' } },
+        ])
+        expect(counterType?.returns).toEqual({ kind: 'integer' })
+
+        // checkFnShape should be emitted (signature is non-trivial)
+        expect(r.code).toContain('__tjs.checkFnShape')
+      })
+    })
   })
 
   describe('error vs valid value distinction', () => {