optipack 0.0.0-stage → 1.0.0

package/src/passes/s5-array-methods-to-loops.js

@@ -0,0 +1,357 @@
+/**
+ * S5 array-methods-to-loops — hot-path only.
+ *
+ * In hot functions, inline-arrow `.forEach`, `.map`, `.filter`, `.some`,
+ * `.every`, `.find` calls become plain indexed loops. Every method-call
+ * allocation (iterator + callback invocation machinery) disappears.
+ *
+ * Bail conditions:
+ *  - callback is not an inline arrow/function expression
+ *  - callback uses `this` or `arguments`, is async, is a generator, or
+ *    contains await/yield
+ *  - callback parameters are not plain identifiers
+ *  - receiver is optionally chained (either via `?.` in the receiver or an
+ *    optional call `arr?.map(...)`)
+ *  - the call is not unconditionally evaluated within its statement
+ *    (conditional expressions, logical right-hand sides, spread, concise
+ *    arrow bodies, loop test/update positions)
+ *  - receiver provenance may include holes (sparse arrays change
+ *    forEach/map/some/every/find/filter semantics)
+ *
+ * Note: the receiver is always evaluated exactly once (hoisted to a `const`
+ * before the loop), so a call-containing receiver never duplicates side
+ * effects — this supersedes the "receiver referenced more than once" bail.
+ */
+import traverse from '@babel/traverse';
+import * as t from '@babel/types';
+import { walk, provablyArray } from '../pass-utils.js';
+
+const _traverse = traverse.default || traverse;
+
+export const ID = 'array-methods-to-loops';
+export const CODE = 'S5';
+
+const METHODS = new Set(['forEach', 'map', 'filter', 'some', 'every', 'find']);
+
+// Nodes that make the call conditionally evaluated relative to its statement.
+function unconditionalWalk(callPath, stmtPath) {
+  let p = callPath.parentPath;
+  while (p && p !== stmtPath) {
+    const n = p.node;
+    if (t.isConditionalExpression(n)) return false;
+    if (t.isLogicalExpression(n)) return false;
+    if (t.isOptionalCallExpression(n) || t.isOptionalMemberExpression(n)) return false;
+    if (t.isSpreadElement(n)) return false;
+    if (t.isFunctionExpression(n) || t.isArrowFunctionExpression(n)) return false; // concise body crossing
+    if (t.isSwitchStatement(n) || t.isSwitchCase(n)) return false;
+    p = p.parentPath;
+  }
+  if (!p) return false;
+  const sn = stmtPath.node;
+  if (t.isForStatement(sn) || t.isWhileStatement(sn) || t.isDoWhileStatement(sn)) {
+    // The call must live inside the loop body.
+    let q = callPath;
+    let inBody = false;
+    while (q && q.node !== sn) {
+      if (q.parentPath && q.parentPath.node === sn && q.parentPath.node.body === q.node) { inBody = true; break; }
+      if (q.parentPath && q.parentPath.node === sn && q.key === 'body') { inBody = true; break; }
+      q = q.parentPath;
+    }
+    if (!inBody) return false;
+  }
+  return true;
+}
+
+function callbackIssues(cb) {
+  const problems = [];
+  if (cb.async) problems.push('async callback');
+  if (cb.generator) problems.push('generator callback');
+  let sawThis = false;
+  let sawArguments = false;
+  let sawAwaitYield = false;
+  walk(cb.body, (n) => {
+    if (t.isThisExpression(n)) { sawThis = true; return false; }
+    if (t.isIdentifier(n) && n.name === 'arguments' && !t.isMemberExpression(n)) {
+      // crude: any bare `arguments` reference
+      sawArguments = true;
+      return false;
+    }
+    if (t.isAwaitExpression(n) || t.isYieldExpression(n)) { sawAwaitYield = true; return false; }
+    return true;
+  });
+  // `arguments` references only count when they resolve outside the callback
+  // params — a param named arguments is pathological; treat as a bail.
+  if (sawThis) problems.push('callback uses this');
+  if (sawArguments) problems.push('callback uses arguments');
+  if (sawAwaitYield) problems.push('callback contains await/yield');
+  for (const p of cb.params) {
+    if (!t.isIdentifier(p)) problems.push('callback parameter is not a plain identifier');
+  }
+  if (cb.params.length > 3) problems.push('callback has more than 3 parameters');
+  return problems;
+}
+
+export default function arrayMethodsToLoops(programPath, ctx) {
+  const decided = new WeakSet();
+  const bailed = new WeakSet();
+
+  const recordBailOnce = (node, line, reason) => {
+    if (bailed.has(node)) return;
+    bailed.add(node);
+    ctx.bail(line, CODE, reason);
+  };
+
+  programPath.traverse({
+    CallExpression(path) {
+      const node = path.node;
+      if (decided.has(node)) return;
+      decided.add(node);
+
+      const callee = node.callee;
+      if (!t.isMemberExpression(callee) || callee.computed) return;
+      const prop = callee.property;
+      if (!t.isIdentifier(prop) || !METHODS.has(prop.name)) return;
+      const line = node.loc ? node.loc.start.line : 0;
+
+      // Hot functions only — silently skip elsewhere.
+      const fnParent = path.getFunctionParent();
+      if (!fnParent || !ctx.isHot(fnParent.node)) return;
+      if (ctx.isDisabled(path, ID, CODE)) return;
+
+      const fail = (reason) => {
+        recordBailOnce(node, line, reason);
+      };
+
+      if (node.arguments.length !== 1) return fail('expected exactly one callback argument');
+      const cb = node.arguments[0];
+      if (!t.isArrowFunctionExpression(cb) && !t.isFunctionExpression(cb)) {
+        return fail('callback is not an inline function expression');
+      }
+      const issues = callbackIssues(cb);
+      if (issues.length > 0) return fail(issues[0]);
+
+      // Optional chaining anywhere in the receiver or callee → bail.
+      let optional = false;
+      walk(callee.object, (n) => {
+        if (t.isOptionalMemberExpression(n) || t.isOptionalCallExpression(n)) { optional = true; return false; }
+        return true;
+      });
+      if (optional) return fail('receiver is optionally chained');
+
+      // Sparse-array provenance → bail.
+      const prov = provablyArray(callee.object, path);
+      if (prov.array && prov.holey) return fail('receiver may be a sparse array');
+
+      // Nearest statement ancestor (never crossing a function boundary).
+      let stmtPath = path;
+      while (stmtPath && !stmtPath.isStatement()) stmtPath = stmtPath.parentPath;
+      if (!stmtPath) return fail('no statement ancestor in the same function');
+      if (!unconditionalWalk(path, stmtPath)) {
+        return fail('call is conditionally evaluated within its statement');
+      }
+
+      const method = prop.name;
+      const used = !(t.isExpressionStatement(stmtPath.node) && stmtPath.node.expression === node);
+      const needsValue = used && method !== 'forEach';
+
+      const scope = stmtPath.scope;
+      const arrName = scope.generateUid('opArr');
+      const idxName = scope.generateUid('opI');
+      const accName = scope.generateUid('opAcc');
+      const resName = scope.generateUid('opRes');
+
+      // ---- translate callback body ----
+      const p0 = cb.params[0] || null;
+      const p1 = cb.params[1] || null;
+      const p2 = cb.params[2] || null;
+      const elemName = p0 ? p0.name : scope.generateUid('opV');
+      const elemKind = p0 && p0.name && scopeHasViolations(scope, p0.name, cb) ? 'let' : 'const';
+
+      const body = t.cloneNode(cb.body, true);
+      const bodyStmts = t.isBlockStatement(body) ? body.body : [t.returnStatement(body)];
+
+      const translate = (stmts) => {
+        const out = [];
+        for (const s of stmts) {
+          if (t.isReturnStatement(s)) {
+            const arg = s.argument;
+            switch (method) {
+              case 'forEach':
+                if (arg) out.push(t.expressionStatement(arg));
+                out.push(t.continueStatement());
+                break;
+              case 'map':
+                if (!used) {
+                  if (arg) out.push(t.expressionStatement(arg));
+                } else {
+                  out.push(t.expressionStatement(
+                    t.callExpression(t.memberExpression(t.identifier(accName), t.identifier('push')), [arg || t.identifier('undefined')])
+                  ));
+                }
+                out.push(t.continueStatement());
+                break;
+              case 'filter':
+                if (arg && used) {
+                  out.push(t.ifStatement(
+                    arg,
+                    t.expressionStatement(
+                      t.callExpression(t.memberExpression(t.identifier(accName), t.identifier('push')), [t.identifier(elemName)])
+                    )
+                  ));
+                }
+                out.push(t.continueStatement());
+                break;
+              case 'some':
+                if (arg) {
+                  out.push(t.ifStatement(
+                    arg,
+                    t.blockStatement([
+                      t.expressionStatement(t.assignmentExpression('=', t.identifier(resName), t.booleanLiteral(true))),
+                      t.breakStatement(),
+                    ])
+                  ));
+                }
+                out.push(t.continueStatement());
+                break;
+              case 'every':
+                if (arg) {
+                  out.push(t.ifStatement(
+                    t.unaryExpression('!', arg),
+                    t.blockStatement([
+                      t.expressionStatement(t.assignmentExpression('=', t.identifier(resName), t.booleanLiteral(false))),
+                      t.breakStatement(),
+                    ])
+                  ));
+                }
+                out.push(t.continueStatement());
+                break;
+              case 'find':
+                if (arg) {
+                  out.push(t.ifStatement(
+                    arg,
+                    t.blockStatement([
+                      t.expressionStatement(t.assignmentExpression('=', t.identifier(resName), t.identifier(elemName))),
+                      t.breakStatement(),
+                    ])
+                  ));
+                }
+                out.push(t.continueStatement());
+                break;
+              default:
+                out.push(s);
+            }
+            continue;
+          }
+          if (t.isBlockStatement(s)) {
+            s.body = translate(s.body);
+            out.push(s);
+            continue;
+          }
+          if (t.isIfStatement(s)) {
+            if (s.consequent && t.isBlockStatement(s.consequent)) s.consequent.body = translate(s.consequent.body);
+            if (s.alternate && t.isBlockStatement(s.alternate)) s.alternate.body = translate(s.alternate.body);
+            out.push(s);
+            continue;
+          }
+          if (t.isForStatement(s) || t.isForOfStatement(s) || t.isForInStatement(s) ||
+              t.isWhileStatement(s) || t.isDoWhileStatement(s)) {
+            if (s.body && t.isBlockStatement(s.body)) s.body.body = translate(s.body.body);
+            out.push(s);
+            continue;
+          }
+          if (t.isTryStatement(s)) {
+            if (s.block) s.block.body = translate(s.block.body);
+            out.push(s);
+            continue;
+          }
+          if (t.isLabeledStatement(s)) {
+            if (s.body && t.isBlockStatement(s.body)) s.body.body = translate(s.body.body);
+            out.push(s);
+            continue;
+          }
+          out.push(s);
+        }
+        return out;
+      };
+
+      const translated = translate(bodyStmts);
+      // A trailing `continue` translated from a final `return` is redundant
+      // *when fall-through behaves identically* — true for every method except
+      // map, whose fall-through pushes `undefined`. For map, a trailing
+      // continue means the callback never falls through, so the implicit
+      // push is dropped along with the continue.
+      let endsWithReturn = false;
+      if (translated.length > 0 && t.isContinueStatement(translated[translated.length - 1])) {
+        translated.pop();
+        endsWithReturn = true;
+      }
+      if (method === 'map' && used && !endsWithReturn) {
+        translated.push(t.expressionStatement(
+          t.callExpression(t.memberExpression(t.identifier(accName), t.identifier('push')), [t.identifier('undefined')])
+        ));
+      }
+
+      // ---- assemble loop ----
+      const bindDecls = [];
+      bindDecls.push(t.variableDeclaration(elemKind, [
+        t.variableDeclarator(t.identifier(elemName),
+          t.memberExpression(t.identifier(arrName), t.identifier(idxName), true)),
+      ]));
+      if (p1) {
+        bindDecls.push(t.variableDeclaration('const', [t.variableDeclarator(p1, t.identifier(idxName))]));
+      }
+      if (p2) {
+        bindDecls.push(t.variableDeclaration('const', [t.variableDeclarator(p2, t.identifier(arrName))]));
+      }
+
+      const loop = t.forStatement(
+        t.variableDeclaration('let', [t.variableDeclarator(t.identifier(idxName), t.numericLiteral(0))]),
+        t.binaryExpression('<', t.identifier(idxName), t.memberExpression(t.identifier(arrName), t.identifier('length'))),
+        t.updateExpression('++', t.identifier(idxName)),
+        t.blockStatement([...bindDecls, ...translated])
+      );
+
+      const decls = [t.variableDeclaration('const', [t.variableDeclarator(t.identifier(arrName), callee.object)])];
+      if ((method === 'map' || method === 'filter') && used) {
+        decls.push(t.variableDeclaration('const', [t.variableDeclarator(t.identifier(accName), t.arrayExpression([]))]));
+      }
+      if (method === 'some') {
+        decls.push(t.variableDeclaration('let', [t.variableDeclarator(t.identifier(resName), t.booleanLiteral(false))]));
+      } else if (method === 'every') {
+        decls.push(t.variableDeclaration('let', [t.variableDeclarator(t.identifier(resName), t.booleanLiteral(true))]));
+      } else if (method === 'find') {
+        decls.push(t.variableDeclaration('let', [t.variableDeclarator(t.identifier(resName))]));
+      }
+
+      // ---- splice into the statement list ----
+      if (!needsValue) {
+        // Value-discarding form: drop the call from its statement.
+        if (t.isExpressionStatement(stmtPath.node) && stmtPath.node.expression === node) {
+          stmtPath.replaceWithMultiple([...decls, loop]);
+        } else {
+          path.replaceWith(t.identifier('undefined'));
+          stmtPath.insertBefore([...decls, loop]);
+        }
+      } else {
+        const resultName = (method === 'map' || method === 'filter') ? accName : resName;
+        path.replaceWith(t.identifier(resultName));
+        const stmtClone = t.cloneNode(stmtPath.node, true);
+        stmtPath.replaceWithMultiple([...decls, loop, stmtClone]);
+      }
+      ctx.applied(ID);
+    },
+  });
+}
+
+function scopeHasViolations(scope, name, cb) {
+  // Whether the callback parameter is reassigned inside the callback.
+  let violations = 0;
+  walk(cb.body, (n) => {
+    if ((t.isAssignmentExpression(n) || t.isUpdateExpression(n))) {
+      const target = t.isAssignmentExpression(n) ? n.left : n.argument;
+      if (t.isIdentifier(target) && target.name === name) violations++;
+    }
+    return true;
+  });
+  return violations > 0;
+}

package/src/passes/s6-destructure-to-direct.js

@@ -0,0 +1,186 @@
+/**
+ * S6 destructure-to-direct — hot functions only.
+ *
+ * `const { x, y } = obj` (obj a simple never-reassigned identifier, <= 3 total
+ * uses of the pattern variables) becomes direct `obj.x` reads at use sites.
+ * Default values are hoisted to an `if` at the declaration site so they are
+ * never re-evaluated per use.
+ *
+ * Bail conditions: nested patterns, rest elements, computed keys, non-identifier
+ * object, reassigned object, > 3 uses, any call/assignment/await between the
+ * declaration and the last use (the object's properties could change), or
+ * for-of/for-in heads.
+ */
+import traverse from '@babel/traverse';
+import * as t from '@babel/types';
+import { containsBarrier, corridorSafe } from '../pass-utils.js';
+
+const _traverse = traverse.default || traverse;
+
+export const ID = 'destructure-to-direct';
+export const CODE = 'S6';
+
+/** Root identifier name of a member chain, or the identifier itself. */
+function memberRootIs(node, name) {
+  let cur = node;
+  while (t.isMemberExpression(cur)) cur = cur.object;
+  return t.isIdentifier(cur) && cur.name === name;
+}
+
+export default function destructureToDirect(programPath, ctx) {
+  programPath.traverse({
+    VariableDeclaration(path) {
+      const node = path.node;
+      const line = node.loc ? node.loc.start.line : 0;
+      const fnParent = path.getFunctionParent();
+      if (!fnParent || !ctx.isHot(fnParent.node)) return;
+      if (ctx.isDisabled(path, ID, CODE)) return;
+
+      const fail = (reason) => ctx.bail(line, CODE, reason);
+
+      if (node.kind !== 'const') {
+        if (node.declarations.length === 1 && t.isObjectPattern(node.declarations[0].id) && line > 0) {
+          return fail('declaration is not const');
+        }
+        return;
+      }
+      const parent = path.parentPath;
+      if (parent.isForOfStatement() || parent.isForInStatement() || parent.isForStatement()) {
+        return line > 0 ? fail('declaration is a loop head') : undefined;
+      }
+      if (node.declarations.length !== 1) return line > 0 ? fail('multiple declarators') : undefined;
+      const declarator = node.declarations[0];
+      const pattern = declarator.id;
+      if (!t.isObjectPattern(pattern)) return; // not an opportunity
+      const obj = declarator.init;
+      if (!obj || !t.isIdentifier(obj)) {
+        return line > 0 ? fail('object is not a simple identifier (member chains are B1 territory)') : undefined;
+      }
+
+      const objBinding = path.scope.getBinding(obj.name);
+      if (!objBinding) return fail('object binding not found');
+      if (objBinding.constantViolations.length > 0) return fail('object identifier is reassigned');
+
+      // Validate pattern shape.
+      const props = [];
+      for (const p of pattern.properties) {
+        if (t.isRestElement(p)) return fail('rest element');
+        if (!t.isObjectProperty(p)) return fail('unsupported pattern element');
+        if (p.computed) return fail('computed key');
+        let keyName = null;
+        if (t.isIdentifier(p.key)) keyName = p.key.name;
+        else if (t.isStringLiteral(p.key) && /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(p.key.value)) keyName = p.key.value;
+        else return fail('non-identifier key');
+        if (!t.isIdentifier(p.value) && !t.isAssignmentPattern(p.value)) return fail('nested pattern or non-identifier value');
+        if (t.isAssignmentPattern(p.value)) {
+          if (!t.isIdentifier(p.value.left)) return fail('nested pattern in default target');
+          props.push({ key: keyName, local: p.value.left.name, hasDefault: true, deflt: p.value.right });
+        } else {
+          props.push({ key: keyName, local: p.value.name, hasDefault: false, deflt: null });
+        }
+      }
+      if (props.length === 0) return fail('empty pattern');
+
+      // Uses.
+      let totalUses = 0;
+      const refsByLocal = new Map();
+      for (const p of props) {
+        const binding = path.scope.getBinding(p.local);
+        if (!binding) return fail(`binding ${p.local} not found`);
+        if (binding.constantViolations.length > 0) return fail(`binding ${p.local} is reassigned`);
+        refsByLocal.set(p.local, binding);
+        totalUses += binding.references;
+      }
+      if (totalUses > 3) return fail(`total uses ${totalUses} > 3`);
+
+      // Barrier check between declaration and each use: any statement strictly
+      // between the declaration and the use's statement must be free of calls
+      // and assignments; within the use's own statement, an evaluation-order
+      // corridor check ensures no call executes before the read.
+      const fnBodyPath = fnParent.get('body');
+      const declStart = declarator.start ?? 0;
+      const declEnd = declarator.end ?? 0;
+      const useNodes = [];
+      for (const [, binding] of refsByLocal) {
+        for (const ref of binding.referencePaths) useNodes.push(ref.node);
+      }
+      const lastRefPos = useNodes.reduce((m, u) => Math.max(m, u.end ?? 0), declEnd);
+      let barrierProblem = null;
+      fnBodyPath.traverse({
+        Statement(sPath) {
+          if (barrierProblem) return false;
+          const n = sPath.node;
+          if (n === node) return;
+          if (sPath.isFunctionDeclaration()) return;
+          const s = n.start ?? 0;
+          const e = n.end ?? 0;
+          const own = useNodes.filter((u) => u.start >= s && u.end <= e);
+          if (own.length > 0) {
+            // Corridor check inside the use's own statement (sorted by position).
+            own.sort((a, b) => a.start - b.start);
+            if (!corridorSafe(n, own)) {
+              barrierProblem = 'a call inside the use statement executes before the read';
+            }
+            return;
+          }
+          const between = e > declStart && s < lastRefPos;
+          if (between && containsBarrier(n, { loops: true })) {
+            barrierProblem = 'calls or assignments between declaration and use could mutate the object';
+          }
+        },
+      });
+      if (!barrierProblem) {
+        // Property writes to the object anywhere in the function are mutation
+        // risks (`cfg = ...` reassignment is covered by constantViolations).
+        fnBodyPath.traverse({
+          AssignmentExpression(aPath) {
+            if (memberRootIs(aPath.node.left, obj.name)) {
+              barrierProblem = `property of "${obj.name}" is written`;
+            }
+          },
+          UpdateExpression(aPath) {
+            if (memberRootIs(aPath.node.argument, obj.name)) barrierProblem = `property of "${obj.name}" is updated`;
+          },
+          UnaryExpression(aPath) {
+            if (aPath.node.operator === 'delete' && memberRootIs(aPath.node.argument, obj.name)) {
+              barrierProblem = `property of "${obj.name}" is deleted`;
+            }
+          },
+        });
+      }
+      if (barrierProblem) return fail(barrierProblem);
+
+      // Rewrite.
+      const objExpr = t.identifier(obj.name);
+      let hasDefaults = false;
+      for (const p of props) {
+        if (p.hasDefault) { hasDefaults = true; continue; }
+        const binding = refsByLocal.get(p.local);
+        for (const ref of binding.referencePaths) {
+          if (ctx.isDisabled(ref, ID, CODE)) continue;
+          ref.replaceWith(t.memberExpression(t.cloneNode(objExpr), t.identifier(p.key)));
+        }
+      }
+
+      if (hasDefaults) {
+        // Keep defaulted locals: hoist the default to an if.
+        const stmts = [];
+        for (const p of props) {
+          if (!p.hasDefault) continue;
+          stmts.push(t.variableDeclaration('let', [
+            t.variableDeclarator(t.identifier(p.local),
+              t.memberExpression(t.cloneNode(objExpr), t.identifier(p.key))),
+          ]));
+          stmts.push(t.ifStatement(
+            t.binaryExpression('===', t.identifier(p.local), t.identifier('undefined')),
+            t.expressionStatement(t.assignmentExpression('=', t.identifier(p.local), p.deflt))
+          ));
+        }
+        path.replaceWithMultiple(stmts);
+      } else {
+        path.remove();
+      }
+      ctx.applied(ID);
+    },
+  });
+}