jz 0.8.0 → 0.9.0

package/src/wat/codegen.js

@@ -20,6 +20,19 @@ function wrapBlock(node, depth) {
   return '{ ' + codegen(node, depth) + '; }'
 }
 
+// Effective precedence of a node in expression position: binaries from `prec`,
+// ternary/arrow/comma below them, atoms/calls/members bind tightest.
+const ASSOC = new Set(['&&', '||', '+', '*', '&', '|', '^'])
+const cprec = (n) => !Array.isArray(n) || n[0] == null ? Infinity
+  : prec[n[0]] != null ? prec[n[0]]
+  : n[0] === '?' || n[0] === '?:' ? 1.5
+  : n[0] === '=>' ? 0.7
+  : n[0] === ',' ? 0.1
+  : Infinity
+
+/** Print child, parenthesized when it binds looser than the context. */
+const paren = (n, ctx) => cprec(n) < ctx ? '(' + codegen(n) + ')' : codegen(n)
+
 /** Generate jz source from AST. Enforces semicolons. */
 export function codegen(node, depth = 0) {
   if (node == null) return ''
@@ -31,8 +44,13 @@ export function codegen(node, depth = 0) {
   const [op, ...a] = node
   const ind = INDENT.repeat(depth), ind1 = INDENT.repeat(depth + 1)
 
-  // Literal: [, value]
-  if (op == null) return typeof a[0] === 'string' ? JSON.stringify(a[0]) : a[0] == null ? 'null' : String(a[0]) + (typeof a[0] === 'bigint' ? 'n' : '')
+  // Literal: [, value]. `[]` (no payload) is subscript's undefined encoding —
+  // print it as `undefined`, not `null` (distinct values through a round-trip).
+  if (op == null) return typeof a[0] === 'string' ? JSON.stringify(a[0]) : a[0] === null ? 'null' : a[0] === undefined ? 'undefined' : String(a[0]) + (typeof a[0] === 'bigint' ? 'n' : '')
+  // ['nan'] — jz's parse encodes NaN as a self-describing marker (src/parse.js)
+  if (op === 'nan') return 'NaN'
+  // ['bool', 1|0] — true/false parse to a self-describing marker (src/parse.js)
+  if (op === 'bool') return a[0] ? 'true' : 'false'
 
   // Statements
   if (op === ';') return a.map(s => codegen(s, depth)).filter(Boolean).join(';\n' + ind) + ';'
@@ -97,6 +115,17 @@ export function codegen(node, depth = 0) {
     if (a.length === 3) return 'try ' + codegen(a[0], depth) + ' catch (' + a[1] + ') ' + codegen(a[2], depth)
     return 'try ' + codegen(a[0], depth) + ' catch ' + codegen(a[1], depth)
   }
+  // Parser shape: ['try', body, ['catch', param|null, cbody]?, ['finally', fbody]?] —
+  // bodies arrive unbraced (bare statement or `;`-list); JS requires the blocks back.
+  if (op === 'try') {
+    let s = 'try ' + wrapBlock(a[0], depth)
+    for (const c of a.slice(1)) {
+      if (!Array.isArray(c)) continue
+      if (c[0] === 'catch') s += (c[1] != null ? ' catch (' + codegen(c[1]) + ') ' : ' catch ') + wrapBlock(c[2], depth)
+      else if (c[0] === 'finally') s += ' finally ' + wrapBlock(c[1], depth)
+    }
+    return s
+  }
 
   // Arrow
   if (op === '=>') {
@@ -114,11 +143,21 @@ export function codegen(node, depth = 0) {
   // Grouping parens / function call
   if (op === '()') {
     if (a.length === 1) return '(' + (a[0] == null ? '' : codegen(a[0])) + ')'
-    return codegen(a[0]) + '(' + a.slice(1).map(x => codegen(x)).join(', ') + ')'
+    // An arrow/ternary/binary callee binds looser than the call — parenthesize
+    // (IIFE: `(() => {…})()`), else `... => body()` re-parses into the body.
+    const calleeNeedsParens = Array.isArray(a[0]) && (a[0][0] === '=>' || a[0][0] === '?' || prec[a[0][0]] != null)
+    const callee = calleeNeedsParens ? '(' + codegen(a[0]) + ')' : codegen(a[0])
+    return callee + '(' + a.slice(1).map(x => codegen(x)).join(', ') + ')'
   }
 
-  // Property access
-  if (op === '.') return codegen(a[0]) + '.' + a[1]
+  // Property access. Canonicalized well-known-symbol props ('@@iterator' …)
+  // are not valid dot syntax — print the computed [Symbol.X] source form,
+  // which canonSymbols folds back to the same '@@X' on re-parse.
+  if (op === '.') {
+    if (typeof a[1] === 'string' && a[1].startsWith('@@'))
+      return codegen(a[0]) + '[Symbol.' + a[1].slice(2) + ']'
+    return codegen(a[0]) + '.' + a[1]
+  }
   if (op === '?.') return codegen(a[0]) + '?.' + a[1]
   if (op === '?.[]') return codegen(a[0]) + '?.[' + codegen(a[1]) + ']'
   if (op === '?.()') return codegen(a[0]) + '?.(' + a.slice(1).map(x => codegen(x)).join(', ') + ')'
@@ -134,7 +173,13 @@ export function codegen(node, depth = 0) {
     // Subscript: ['[]', obj, idx]
     return codegen(a[0]) + '[' + codegen(a[1]) + ']'
   }
-  if (op === ':') return codegen(a[0]) + ': ' + codegen(a[1])
+  if (op === ':') {
+    if (typeof a[0] === 'string' && a[0].startsWith('@@'))
+      return '[Symbol.' + a[0].slice(2) + ']: ' + codegen(a[1])
+    // a '@@X' key needs the quoted form ('@@iterator': v) only when written
+    // literally; the computed form above is the canonical print.
+    return codegen(a[0]) + ': ' + codegen(a[1])
+  }
   if (op === 'str') return JSON.stringify(a[0])
   if (op === '//') return '/' + a[0] + '/' + (a[1] || '')
 
@@ -157,20 +202,35 @@ export function codegen(node, depth = 0) {
   // Unary prefix
   if (a.length === 1) {
     if (op === '++' || op === '--') return a[0] == null ? op : op + codegen(a[0])
-    if (op === 'typeof') return 'typeof ' + codegen(a[0])
-    if (op === 'u-') return '-' + codegen(a[0])
-    if (op === 'u+') return '+' + codegen(a[0])
-    return op + codegen(a[0])
+    if (op === 'typeof') return 'typeof ' + paren(a[0], 14)
+    if (op === 'u-') return '-' + paren(a[0], 14)
+    if (op === 'u+') return '+' + paren(a[0], 14)
+    return op + paren(a[0], 14)
   }
 
   // Postfix
   if (a.length === 2 && a[1] === null) return codegen(a[0]) + op
 
-  // Binary
-  if (a.length === 2 && prec[op]) return codegen(a[0]) + ' ' + op + ' ' + codegen(a[1])
+  // Binary — parenthesize looser-binding children: parse preserves user parens as
+  // '()' group nodes, but jzify/canon-synthesized trees are bare, so `&&` over a
+  // synthesized `||` must print `a && (b || c)`, not re-associate on re-parse.
+  if (a.length === 2 && prec[op]) {
+    const P = prec[op]
+    // `??` may not mix with bare `&&`/`||` at all (JS SyntaxError) — force parens.
+    const force = (n) => op === '??' && Array.isArray(n) && (n[0] === '&&' || n[0] === '||')
+    const left = force(a[0]) || cprec(a[0]) < P || (cprec(a[0]) === P && op === '**')  // ** is right-assoc
+      ? '(' + codegen(a[0]) + ')' : codegen(a[0])
+    // Assignment RHS takes any assignment-expression bare (arrows, ternaries,
+    // chained `=`) — only a comma-sequence needs parens there.
+    const rmin = P === 1 ? 0.5 : P
+    const right = force(a[1]) || cprec(a[1]) < rmin || (cprec(a[1]) === rmin && !(ASSOC.has(op) && a[1][0] === op))
+      ? '(' + codegen(a[1]) + ')' : codegen(a[1])
+    return left + ' ' + op + ' ' + right
+  }
 
-  // Ternary
-  if (op === '?' || op === '?:') return codegen(a[0]) + ' ? ' + codegen(a[1]) + ' : ' + codegen(a[2])
+  // Ternary — only the condition slot needs guarding (branches take any
+  // assignment-expression; ?: is right-associative)
+  if (op === '?' || op === '?:') return paren(a[0], 2) + ' ? ' + codegen(a[1]) + ' : ' + codegen(a[2])
 
   // Fallback
   return op + '(' + a.map(x => codegen(x)).join(', ') + ')'

package/transform.js

@@ -8,14 +8,123 @@
  *
  * @module jz/transform
  */
-import { parse } from 'subscript/feature/jessie'
+import { parse } from './src/parse.js'
 import jzify from './jzify/index.js'
 import { codegen } from './src/wat/codegen.js'
+import { initWarnings, warn } from './src/ctx.js'
+
+// jzify mints temps under private-use-area prefixes (jzify/names.js) so they can
+// never collide with user names — but printed source must be plain identifiers
+// (the compiler REJECTS the reserved prefix in user code). Strip the prefix and
+// uniquify against every name present in the program.
+const PUA = /^[-]/
+function renameSynthetic(ast) {
+  const names = new Set(), synth = new Set()
+  const collect = (n) => {
+    if (typeof n === 'string') (PUA.test(n) ? synth : names).add(n)
+    else if (Array.isArray(n) && n[0] != null) for (let i = 0; i < n.length; i++) collect(n[i])
+  }
+  collect(ast)
+  if (!synth.size) return ast
+  const map = new Map()
+  for (const s of synth) {
+    let base = s.replace(PUA, ''), name = base
+    for (let i = 2; names.has(name); i++) name = base + '_' + i
+    names.add(name); map.set(s, name)
+  }
+  const rename = (n) => {
+    if (Array.isArray(n) && n[0] != null)
+      for (let i = 0; i < n.length; i++) {
+        if (typeof n[i] === 'string' && map.has(n[i])) n[i] = map.get(n[i])
+        else rename(n[i])
+      }
+    return n
+  }
+  return rename(ast)
+}
+
+// Canonical equality — converter-only (the compile path keeps JS-loose `==`).
+// jz's `==` follows JS: statically-known mixed types coerce (`1 == "1"` is
+// true), so a blanket `===` swap would change behavior. Rewrite by proof:
+//   x == null / == undefined → x === null || x === undefined  (exact, incl. dynamic)
+//   typeof x == "s", same-type literals → strict op            (provably identical)
+//   mixed-type literals → folded constant                      (the JS loose result)
+//   anything else → strict op + `eqeq` advisory                (identical unless
+//     the operands mix types at runtime — the case Crockford bans `==` over)
+// jzify-synthesized comparisons carry no source `loc` and rewrite silently.
+const isLit = n => Array.isArray(n) && n.length === 2 && n[0] == null
+const isNullish = n => n === 'null' || n === 'undefined' || (isLit(n) && n[1] == null)
+const isTypeof = n => Array.isArray(n) && n[0] === 'typeof'
+const isStrLit = n => isLit(n) && typeof n[1] === 'string'
+// Re-evaluable without effects — jz has no getters/proxies, so member and
+// index reads are pure; calls and assignments are not.
+const isPure = n => typeof n === 'string' || isLit(n)
+  || (Array.isArray(n) && (n[0] === '.' || n[0] === '?.') && isPure(n[1]))
+  || (Array.isArray(n) && (n[0] === '[]' || n[0] === '?.[]') && n.length === 3 && isPure(n[1]) && isPure(n[2]))
+
+let eqTemp = 0
+function canonEqNode(node, source) {
+  const [op, a, b] = node, eq = op === '=='
+  const strict = eq ? '===' : '!=='
+  if (isNullish(a) && isNullish(b)) return [null, eq]
+  if (isNullish(a) || isNullish(b)) {
+    const x = isNullish(a) ? b : a
+    const test = v => eq ? ['||', ['===', v, 'null'], ['===', v, 'undefined']]
+                         : ['&&', ['!==', v, 'null'], ['!==', v, 'undefined']]
+    if (isPure(x)) return test(x)
+    const t = `eq${eqTemp++}`   // effectful operand — bind once
+    return ['()', ['=>', t, test(t)], x]
+  }
+  if ((isTypeof(a) && (isTypeof(b) || isStrLit(b))) || (isTypeof(b) && isStrLit(a)))
+    return [strict, a, b]
+  if (isLit(a) && isLit(b)) {
+    if (typeof a[1] === typeof b[1]) return [strict, a, b]
+    const r = +a[1] === +b[1]   // JS loose result for mixed number/string/boolean/bigint literals
+    return [null, eq ? r : !r]
+  }
+  // `.prototype` comparisons are bundler idioms jzify folds away — no advisory.
+  const protoish = n => Array.isArray(n) && n[0] === '.' && (n[2] === 'prototype' || protoish(n[1]))
+  if (source != null && node.loc != null && !protoish(a) && !protoish(b)) {
+    const before = source.slice(0, node.loc)
+    warn('eqeq', `\`${eq ? '==' : '!='}\` rewritten to \`${strict}\` — identical unless the operands mix types at runtime (loose \`${eq ? '==' : '!='}\` coerces, e.g. \`1 == "1"\`); review if coercion was intended`,
+      { line: before.split('\n').length, column: node.loc - before.lastIndexOf('\n') })
+  }
+  return [strict, a, b]
+}
+
+// Two passes: pre-jzify on the raw parse (source locs intact → advisories point
+// at real lines) and post-jzify silent (`source: null`) — jzify both rebuilds
+// user nodes (dropping loc) and synthesizes its own `==`/`!=` (dispose guards,
+// protocol probes, prepended runtimes), all of which must still canonicalize.
+function canonEq(n, source) {
+  if (!Array.isArray(n) || n[0] == null) return n
+  for (let i = 1; i < n.length; i++) n[i] = canonEq(n[i], source)
+  return (n[0] === '==' || n[0] === '!=') ? canonEqNode(n, source) : n
+}
+
+// AST fingerprint for no-change detection (bigints aren't JSON-stringifiable)
+const key = (ast) => JSON.stringify(ast, (_, v) => typeof v === 'bigint' ? v + 'n' : v)
 
 /**
  * @param {string} code - full-JS source
- * @returns {string} canonical jz source
+ * @param {object} [opts]
+ * @param {boolean} [opts.onlyLowered] - return null when jzify changes nothing
+ *   (source is already canonical jz) — lets a REPL keep the user's original
+ *   bytes, comments and formatting intact, and rewrite only real lowerings.
+ * @param {{entries: Array}} [opts.warnings] - advisory sink (mirrors compile's
+ *   `opts.warnings`) — collects `eqeq` rewrite advisories etc.
+ * @returns {string|null} canonical jz source
  */
-export default function transform(code) {
-  return codegen(jzify(parse(code)))
+export default function transform(code, { onlyLowered = false, warnings = null } = {}) {
+  initWarnings(warnings)
+  eqTemp = 0
+  try {
+    if (onlyLowered) {
+      const before = key(parse(code))
+      const lowered = canonEq(jzify(canonEq(parse(code), code)), null)   // fresh parse — jzify mutates its input
+      if (key(lowered) === before) return null
+      return codegen(renameSynthetic(lowered))
+    }
+    return codegen(renameSynthetic(canonEq(jzify(canonEq(parse(code), code)), null)))
+  } finally { initWarnings(null) }
 }

package/wasi.js

@@ -131,5 +131,8 @@ export function instantiate(wasm, opts = {}) {
   const imports = wasi(opts)
   const inst = new WebAssembly.Instance(new WebAssembly.Module(wasm), imports)
   imports._setMemory(inst.exports.memory)
+  // WASI reactor convention: module init lives in `_initialize` (not a wasm start
+  // section — WASI calls there would fire before memory is wired above).
+  inst.exports._initialize?.()
   return inst
 }