optipack 0.0.0-stage → 1.0.0

package/src/passes/s1-const-fold.js

@@ -0,0 +1,130 @@
+/**
+ * S1 const-fold — fold constant expressions.
+ *
+ * Folds: literal arithmetic / comparisons / bitwise ops, string concatenation,
+ * typeof on literals, `!` on literals, template literals whose interpolations
+ * are all literals, and logical expressions whose left operand is a literal.
+ *
+ * Visitors run in the exit phase so children fold before their parents and
+ * nested literal expressions cascade in a single traversal.
+ *
+ * Never folds across identifiers or function calls. Never produces -0, NaN or
+ * non-finite numbers (kept in original form to avoid serialization surprises).
+ */
+import traverse from '@babel/traverse';
+import * as t from '@babel/types';
+import { literalValue, evalBinary, valueToLiteralNode, isNumericResultSafe } from '../pass-utils.js';
+
+const _traverse = traverse.default || traverse;
+
+export const ID = 'const-fold';
+export const CODE = 'S1';
+
+export default function constFold(programPath, ctx) {
+  programPath.traverse({
+    BinaryExpression: {
+      exit(path) {
+        if (ctx.isDisabled(path, ID, CODE)) return;
+        const { left, right, operator } = path.node;
+        const lv = literalValue(left);
+        const rv = literalValue(right);
+        if (!lv || !rv) return;
+        // No cross-type `in`/`instanceof` (need objects); shifts need integers.
+        if (operator === 'in' || operator === 'instanceof') return;
+        if (['<<', '>>', '>>>'].includes(operator) && (!Number.isInteger(lv.value) || !Number.isInteger(rv.value))) return;
+        const v = evalBinary(operator, lv, rv);
+        if (v === undefined) return;
+        if (typeof v === 'number' && !isNumericResultSafe(v)) return;
+        const node = valueToLiteralNode(v);
+        if (!node) return;
+        path.replaceWith(node);
+        ctx.applied(ID);
+      },
+    },
+
+    UnaryExpression: {
+      exit(path) {
+        if (ctx.isDisabled(path, ID, CODE)) return;
+        const { operator, argument } = path.node;
+        if (operator === 'typeof') {
+          if (t.isStringLiteral(argument)) {
+            path.replaceWith(t.stringLiteral('string'));
+            ctx.applied(ID);
+          } else if (t.isNumericLiteral(argument)) {
+            path.replaceWith(t.stringLiteral('number'));
+            ctx.applied(ID);
+          } else if (t.isBooleanLiteral(argument)) {
+            path.replaceWith(t.stringLiteral('boolean'));
+            ctx.applied(ID);
+          } else if (t.isNullLiteral(argument)) {
+            path.replaceWith(t.stringLiteral('object'));
+            ctx.applied(ID);
+          }
+          return;
+        }
+        if (operator === '!') {
+          const lv = literalValue(argument);
+          if (lv && typeof lv.value !== 'object') {
+            path.replaceWith(t.booleanLiteral(!lv.value));
+            ctx.applied(ID);
+          }
+          return;
+        }
+        if (operator === '~') {
+          const lv = literalValue(argument);
+          if (lv && typeof lv.value === 'number' && Number.isInteger(lv.value)) {
+            const v = ~lv.value;
+            if (isNumericResultSafe(v)) {
+              path.replaceWith(t.numericLiteral(v));
+              ctx.applied(ID);
+            }
+          }
+          return;
+        }
+        // `-x` / `+x` left as-is: literals are canonical already.
+      },
+    },
+
+    TemplateLiteral: {
+      exit(path) {
+        if (ctx.isDisabled(path, ID, CODE)) return;
+        const parent = path.parent;
+        if (t.isTaggedTemplateExpression(parent) && parent.tag === path.node) return;
+        const { quasis, expressions } = path.node;
+        if (expressions.length === 0) return; // nothing to fold
+        for (const e of expressions) {
+          const lv = literalValue(e);
+          if (!lv) return;
+        }
+        let s = '';
+        for (let i = 0; i < quasis.length; i++) {
+          s += quasis[i].value.raw;
+          if (i < expressions.length) {
+            const lv = literalValue(expressions[i]);
+            s += String(lv.value);
+          }
+        }
+        path.replaceWith(t.stringLiteral(s));
+        ctx.applied(ID);
+      },
+    },
+
+    LogicalExpression: {
+      exit(path) {
+        if (ctx.isDisabled(path, ID, CODE)) return;
+        const { left, operator } = path.node;
+        const lv = literalValue(left);
+        if (!lv) return;
+        const truthy = typeof lv.value === 'string' ? lv.value.length > 0 : !!lv.value;
+        const isNullish = lv.kind === 'null';
+        let repl = null;
+        if (operator === '&&') repl = truthy ? path.node.right : path.node.left;
+        else if (operator === '||') repl = truthy ? path.node.left : path.node.right;
+        else if (operator === '??') repl = isNullish ? path.node.right : path.node.left;
+        if (!repl) return;
+        path.replaceWith(repl);
+        ctx.applied(ID);
+      },
+    },
+  });
+}

package/src/passes/s2-dead-code.js

@@ -0,0 +1,183 @@
+/**
+ * S2 dead-code — remove provably unreachable code.
+ *
+ * 1. Statements after an unconditional return/throw/break/continue in a block.
+ * 2. Branches made constant by S1 (if / conditional / while-false / for-false).
+ * 3. Unused local declarations whose initializers are side-effect-free
+ *    (no calls, no member writes, no await/yield, no delete).
+ */
+import traverse from '@babel/traverse';
+import * as t from '@babel/types';
+import { isPureExpression, isStaticLiteral, literalValue } from '../pass-utils.js';
+
+const _traverse = traverse.default || traverse;
+
+export const ID = 'dead-code';
+export const CODE = 'S2';
+
+function isTerminal(stmt) {
+  return (
+    t.isReturnStatement(stmt) ||
+    t.isThrowStatement(stmt) ||
+    t.isBreakStatement(stmt) ||
+    t.isContinueStatement(stmt)
+  );
+}
+
+function blockBodyOf(stmt) {
+  if (t.isBlockStatement(stmt)) return stmt.body;
+  return [stmt];
+}
+
+function allExit(stmts) {
+  if (stmts.length === 0) return false;
+  const last = stmts[stmts.length - 1];
+  if (!isTerminal(last)) return false;
+  for (const s of stmts) {
+    if (t.isIfStatement(s) || t.isSwitchStatement(s)) return false; // may fall through around it
+  }
+  return true;
+}
+
+export default function deadCode(programPath, ctx) {
+  // Step 1: code after a terminal statement.
+  programPath.traverse({
+    BlockStatement(path) {
+      const body = path.node.body;
+      let cut = -1;
+      for (let i = 0; i < body.length; i++) {
+        if (isTerminal(body[i])) { cut = i; break; }
+      }
+      if (cut >= 0 && cut < body.length - 1) {
+        if (ctx.isDisabled(path, ID, CODE)) return;
+        const removed = body.length - 1 - cut;
+        path.node.body = body.slice(0, cut + 1);
+        ctx.applied(ID);
+        // record one bail-style note is unnecessary: this is an application.
+        void removed;
+      }
+    },
+  });
+
+  // Step 2: constant branches.
+  programPath.traverse({
+    IfStatement(path) {
+      if (ctx.isDisabled(path, ID, CODE)) return;
+      const test = path.node.test;
+      if (!isStaticLiteral(test)) return;
+      const lv = literalValue(test);
+      const truthy = lv ? (typeof lv.value === 'string' ? lv.value.length > 0 : !!lv.value) : null;
+      if (truthy === null) return;
+      const keep = truthy ? path.node.consequent : path.node.alternate;
+      if (!keep) {
+        path.remove();
+      } else {
+        path.replaceWithMultiple(blockBodyOf(keep));
+      }
+      ctx.applied(ID);
+    },
+    ConditionalExpression(path) {
+      if (ctx.isDisabled(path, ID, CODE)) return;
+      const lv = literalValue(path.node.test);
+      if (!lv) return;
+      const truthy = typeof lv.value === 'string' ? lv.value.length > 0 : !!lv.value;
+      path.replaceWith(truthy ? path.node.consequent : path.node.alternate);
+      ctx.applied(ID);
+    },
+    WhileStatement(path) {
+      if (ctx.isDisabled(path, ID, CODE)) return;
+      const lv = literalValue(path.node.test);
+      if (!lv) return;
+      const truthy = typeof lv.value === 'string' ? lv.value.length > 0 : !!lv.value;
+      if (!truthy) {
+        path.remove();
+        ctx.applied(ID);
+      }
+    },
+    ForStatement(path) {
+      if (ctx.isDisabled(path, ID, CODE)) return;
+      if (!path.node.test) return;
+      const lv = literalValue(path.node.test);
+      if (!lv) return;
+      const truthy = typeof lv.value === 'string' ? lv.value.length > 0 : !!lv.value;
+      if (!truthy) {
+        path.remove();
+        ctx.applied(ID);
+      }
+    },
+  });
+
+  // Step 3: unused local declarations with pure initializers.
+  programPath.scope.crawl();
+  const removals = [];
+  const scopeSet = new Set();
+  programPath.traverse({
+    enter(p) {
+      if (p.scope) scopeSet.add(p.scope);
+    },
+  });
+  scopeSet.add(programPath.scope);
+  const scopes = [...scopeSet];
+
+  for (const scope of scopes) {
+    for (const name of Object.keys(scope.bindings)) {
+      const binding = scope.bindings[name];
+      if (binding.references > 0) continue;
+      const bp = binding.path;
+      let declPath = null;
+      if (bp.isVariableDeclarator()) declPath = bp;
+      else if (bp.isFunctionDeclaration()) declPath = bp;
+      if (!declPath) continue;
+      // Never touch anything exported.
+      let exported = false;
+      let up = declPath.parentPath;
+      while (up) {
+        if (up.isExportNamedDeclaration() || up.isExportDefaultDeclaration()) { exported = true; break; }
+        up = up.parentPath;
+      }
+      if (exported) continue;
+      if (declPath.isVariableDeclarator()) {
+        const init = declPath.node.init;
+        if (!init) {
+          // `var x;` unused — remove the declarator.
+          removals.push({ kind: 'declarator', path: declPath });
+          continue;
+        }
+        if (!isPureExpression(init)) continue;
+        removals.push({ kind: 'declarator', path: declPath });
+      } else {
+        // Respect explicit user intent: a pragma-hot function is never dead.
+        const fnLoc = declPath.node.loc;
+        if (fnLoc && ctx.pragmas && ctx.pragmas.isHotLine(fnLoc.start.line)) continue;
+        removals.push({ kind: 'function', path: declPath });
+      }
+    }
+  }
+
+  // Apply deterministically by source position.
+  removals.sort((a, b) => {
+    const al = a.path.node.loc ? a.path.node.loc.start.line : 0;
+    const bl = b.path.node.loc ? b.path.node.loc.start.line : 0;
+    return al - bl || a.path.node.start - b.path.node.start;
+  });
+  for (const r of removals) {
+    if (ctx.isDisabled(r.path, ID, CODE)) continue;
+    if (!r.path.node) continue; // parent may already be gone
+    try {
+      if (r.kind === 'declarator') {
+        const decl = r.path.parentPath; // VariableDeclaration
+        if (!decl || !decl.node) continue;
+        if (decl.node.declarations.length === 1) decl.remove();
+        else {
+          const idx = decl.node.declarations.indexOf(r.path.node);
+          if (idx >= 0) decl.node.declarations.splice(idx, 1);
+        }
+      } else {
+        r.path.remove();
+      }
+      ctx.applied(ID);
+    } catch {
+      // Node already removed by an overlapping removal; ignore.
+    }
+  }
+}

package/src/passes/s3-bool-simplify.js

@@ -0,0 +1,82 @@
+/**
+ * S3 bool-simplify — boolean-tautology simplification.
+ *
+ *  - `x ? true : false`          -> `!!x`
+ *  - `if (x) return true; else return false;` -> `return !!x;`
+ *  - `x === true` / `x !== false` -> `x`        (x statically boolean-typed)
+ *  - `x === false` / `x !== true` -> `!x`       (duals, same precondition)
+ *
+ * Bails whenever `x` is not statically boolean-typed (result of a comparison,
+ * a `!` expression, a Boolean() call, or an and/or of such).
+ */
+import traverse from '@babel/traverse';
+import * as t from '@babel/types';
+import { isBooleanTyped } from '../pass-utils.js';
+
+const _traverse = traverse.default || traverse;
+
+export const ID = 'bool-simplify';
+export const CODE = 'S3';
+
+function notNot(expr) {
+  return t.unaryExpression('!', t.unaryExpression('!', expr));
+}
+
+function singleReturn(stmt, value) {
+  if (t.isReturnStatement(stmt)) {
+    return t.isBooleanLiteral(stmt.argument) && stmt.argument.value === value;
+  }
+  if (t.isBlockStatement(stmt) && stmt.body.length === 1) {
+    const s = stmt.body[0];
+    return t.isReturnStatement(s) && t.isBooleanLiteral(s.argument) && s.argument.value === value;
+  }
+  return false;
+}
+
+export default function boolSimplify(programPath, ctx) {
+  programPath.traverse({
+    ConditionalExpression(path) {
+      if (ctx.isDisabled(path, ID, CODE)) return;
+      const { test, consequent, alternate } = path.node;
+      if (t.isBooleanLiteral(consequent) && consequent.value === true &&
+          t.isBooleanLiteral(alternate) && alternate.value === false) {
+        path.replaceWith(notNot(test));
+        ctx.applied(ID);
+      }
+    },
+    IfStatement(path) {
+      if (ctx.isDisabled(path, ID, CODE)) return;
+      const { test, consequent, alternate } = path.node;
+      if (!alternate) return;
+      if (singleReturn(consequent, true) && singleReturn(alternate, false)) {
+        path.replaceWith(t.returnStatement(notNot(test)));
+        ctx.applied(ID);
+      }
+    },
+    BinaryExpression(path) {
+      if (ctx.isDisabled(path, ID, CODE)) return;
+      const { left, right, operator } = path.node;
+      // Normalize operand order: find (expr, literal) pair.
+      let expr = null;
+      if (t.isBooleanLiteral(right)) expr = left;
+      else if (t.isBooleanLiteral(left)) expr = right;
+      if (!expr) return;
+      const lit = t.isBooleanLiteral(right) ? right.value : left.value;
+      if (!isBooleanTyped(expr)) {
+        ctx.bail(path.node.loc ? path.node.loc.start.line : 0, CODE,
+          'operand not statically boolean-typed');
+        return;
+      }
+      // x === true -> x ; x !== false -> x ; x === false -> !x ; x !== true -> !x
+      const replacement =
+        (operator === '===' && lit === true) || (operator === '!==' && lit === false)
+          ? expr
+          : (operator === '===' && lit === false) || (operator === '!==' && lit === true)
+            ? t.unaryExpression('!', expr)
+            : null;
+      if (!replacement) return;
+      path.replaceWith(replacement);
+      ctx.applied(ID);
+    },
+  });
+}

package/src/passes/s4-for-of-to-indexed.js

@@ -0,0 +1,140 @@
+/**
+ * S4 for-of-to-indexed — convert `for (const v of it)` to an indexed loop,
+ * only when the iterable is statically provably an array.
+ *
+ * Bail conditions:
+ *  - `for await`
+ *  - iterable not provably an array (host returns, Map/Set, strings, generators)
+ *  - destructuring binding with rest elements
+ *  - a scope binding named `Symbol` (iterator protocol could be shadowed)
+ *  - non-identifier / non-array-pattern bindings
+ *
+ * Semantics preserved:
+ *  - per-iteration binding (const inside the loop body)
+ *  - live `.length` checks (pushes during iteration extend the loop, exactly
+ *    like the array iterator)
+ *  - break/continue/return/labels untouched
+ */
+import traverse from '@babel/traverse';
+import * as t from '@babel/types';
+import { provablyArray } from '../pass-utils.js';
+
+const _traverse = traverse.default || traverse;
+
+export const ID = 'for-of-to-indexed';
+export const CODE = 'S4';
+
+function indexExpr(arrName, idxName, offset) {
+  const idx = offset === 0 ? t.identifier(idxName) : t.binaryExpression('+', t.identifier(idxName), t.numericLiteral(offset));
+  return t.memberExpression(t.identifier(arrName), idx, true);
+}
+
+export default function forOfToIndexed(programPath, ctx) {
+  programPath.traverse({
+    ForOfStatement(path) {
+      const node = path.node;
+      const line = node.loc ? node.loc.start.line : 0;
+      if (ctx.isDisabled(path, ID, CODE)) return;
+
+      const fail = (reason) => {
+        ctx.bail(line, CODE, reason);
+        return;
+      };
+
+      if (node.await) return fail('for await loop');
+      if (path.scope.getBinding('Symbol')) return fail('Symbol shadowed in scope');
+
+      if (!t.isVariableDeclaration(node.left) || node.left.declarations.length !== 1) {
+        return fail('loop head is not a single declarator');
+      }
+      const declarator = node.left.declarations[0];
+      const id = declarator.id;
+      const kind = node.left.kind;
+
+      if (t.isIdentifier(id)) {
+        if (id.name === 'arguments' || id.name === 'eval') return fail('loop variable is arguments/eval');
+        // Reassignment of a let/var loop variable is fine (translate to let).
+      } else if (t.isArrayPattern(id)) {
+        for (const el of id.elements) {
+          if (el && t.isRestElement(el)) return fail('destructuring with rest element');
+          if (el && !t.isIdentifier(el) && !t.isAssignmentPattern(el)) {
+            return fail('unsupported destructuring element');
+          }
+          if (el && t.isAssignmentPattern(el) && !t.isIdentifier(el.left)) {
+            return fail('unsupported destructuring default target');
+          }
+        }
+      } else {
+        return fail('loop variable is not an identifier or array pattern');
+      }
+
+      const prov = provablyArray(node.right, path);
+      if (!prov.array) return fail('iterable not provably an array');
+
+      // Choose the array reference: direct identifier when immutable, else a hoisted const.
+      let arrName;
+      const pre = [];
+      if (t.isIdentifier(node.right)) {
+        const binding = path.scope.getBinding(node.right.name);
+        if (binding && binding.constantViolations.length === 0) {
+          arrName = node.right.name;
+        }
+      }
+      if (!arrName) {
+        arrName = path.scope.generateUid('opArr');
+        pre.push(t.variableDeclaration('const', [t.variableDeclarator(t.identifier(arrName), node.right)]));
+      }
+      const idxName = path.scope.generateUid('opI');
+
+      // Binding declarations inside the loop body.
+      const bindDecls = [];
+      const declKind = kind === 'const' ? 'const' : 'let';
+      const pushDecl = (name, readExpr, deflt) => {
+        if (deflt) {
+          bindDecls.push(t.variableDeclaration('let', [t.variableDeclarator(t.identifier(name), readExpr)]));
+          bindDecls.push(
+            t.ifStatement(
+              t.binaryExpression('===', t.identifier(name), t.identifier('undefined')),
+              t.expressionStatement(t.assignmentExpression('=', t.identifier(name), deflt))
+            )
+          );
+        } else {
+          bindDecls.push(t.variableDeclaration(declKind, [t.variableDeclarator(t.identifier(name), readExpr)]));
+        }
+      };
+      if (t.isIdentifier(id)) {
+        pushDecl(id.name, indexExpr(arrName, idxName, 0), null);
+      } else {
+        // Array pattern: read the element once, then index into it.
+        const elemUid = path.scope.generateUid('opEl');
+        bindDecls.push(t.variableDeclaration('const', [
+          t.variableDeclarator(t.identifier(elemUid), indexExpr(arrName, idxName, 0)),
+        ]));
+        id.elements.forEach((el, k) => {
+          if (!el) return; // hole
+          const elemRead = t.memberExpression(t.identifier(elemUid), t.numericLiteral(k), true);
+          if (t.isIdentifier(el)) pushDecl(el.name, elemRead, null);
+          else pushDecl(el.left.name, elemRead, el.right);
+        });
+      }
+
+      // Loop body: binding decls + original body (wrapped when it was a block).
+      const bodyStmts = [...bindDecls];
+      if (t.isBlockStatement(node.body)) {
+        bodyStmts.push(node.body); // nested block preserves shadowing
+      } else {
+        bodyStmts.push(node.body);
+      }
+      const forNode = 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(bodyStmts)
+      );
+
+      const replacement = pre.length > 0 ? t.blockStatement([...pre, forNode]) : forNode;
+      path.replaceWith(replacement);
+      ctx.applied(ID);
+    },
+  });
+}