optipack 0.0.0-stage → 1.0.0

package/src/report.js

@@ -0,0 +1,98 @@
+/**
+ * Report accumulation and serialization.
+ */
+
+export function newFileReport(relPath, beforeBytes) {
+  return {
+    path: relPath,
+    hotFunctions: 0,
+    transforms: {},
+    bails: [],
+    lint: [],
+    residualAllocs: { closures: 0, arrays: 0, objects: 0 },
+    bytes: { before: beforeBytes, after: 0 },
+  };
+}
+
+export class Report {
+  constructor(level) {
+    this.level = level;
+    this.files = [];
+    this.warnings = [];
+    this.totals = { transforms: 0, bails: 0, warnings: 0 };
+  }
+
+  addFile(fr) {
+    this.files.push(fr);
+    this.totals.transforms += Object.values(fr.transforms).reduce((a, b) => a + b, 0);
+    this.totals.bails += fr.bails.length;
+    this.totals.warnings += this.warningsForFile(fr.path);
+    return fr;
+  }
+
+  warningsForFile(p) {
+    return this.warnings.filter((w) => w.path === p).length;
+  }
+
+  warn(entry) {
+    this.warnings.push(entry);
+    this.totals.warnings++;
+  }
+
+  finish() {
+    // Recompute totals defensively (warnings are global, files are fixed).
+    this.totals.transforms = this.files.reduce(
+      (a, f) => a + Object.values(f.transforms).reduce((x, y) => x + y, 0), 0
+    );
+    this.totals.bails = this.files.reduce((a, f) => a + f.bails.length, 0);
+    this.totals.warnings = this.warnings.length;
+    return this;
+  }
+
+  toJSON() {
+    return {
+      level: this.level,
+      files: this.files,
+      warnings: this.warnings,
+      totals: { transforms: this.totals.transforms, bails: this.totals.bails, warnings: this.totals.warnings },
+    };
+  }
+
+  serialize() {
+    return JSON.stringify(this.finish().toJSON(), null, 2) + '\n';
+  }
+}
+
+/** Shared per-file pass context handed to every pass. */
+export class PassContext {
+  constructor({ fileName, pragmas, hot, fileReport, warningsSink, config }) {
+    this.fileName = fileName;
+    this.pragmas = pragmas;
+    this.hot = hot; // HotInfo or null
+    this.fileReport = fileReport;
+    this.warningsSink = warningsSink; // (entry) => void
+    this.config = config;
+  }
+
+  applied(id) {
+    this.fileReport.transforms[id] = (this.fileReport.transforms[id] || 0) + 1;
+  }
+
+  bail(line, code, reason) {
+    if (!line) return; // generated nodes have no source line to report
+    this.fileReport.bails.push({ line, transform: code, reason });
+  }
+
+  warn(line, transform, message) {
+    this.warningsSink({ path: this.fileName, line: line ?? 0, transform, message });
+    this.fileReport.warnings = (this.fileReport.warnings || 0) + 1;
+  }
+
+  isDisabled(path, ...ids) {
+    return this.pragmas ? this.pragmas.isDisabled(path, ...ids) : false;
+  }
+
+  isHot(node) {
+    return this.hot ? this.hot.isHot(node) : false;
+  }
+}

package/test/array-methods-to-loops/expected.js

@@ -0,0 +1,58 @@
+// S5: array-method inlining inside a hot tick handler.
+import { world, system } from '@minecraft/server';
+const tags = ['a', 'bb', 'ccc'];
+function onTick() {
+  const _opArr = tags;
+  for (let _opI = 0; _opI < _opArr.length; _opI++) {
+    const t = _opArr[_opI];
+    world.sendMessage('tag:' + t);
+  }
+  const _opArr2 = tags;
+  const _opAcc2 = [];
+  for (let _opI2 = 0; _opI2 < _opArr2.length; _opI2++) {
+    const t = _opArr2[_opI2];
+    _opAcc2.push(t + '!');
+  }
+  const doubled = _opAcc2;
+  world.setDynamicProperty('doubled', doubled.join(','));
+  const _opArr3 = tags;
+  const _opAcc3 = [];
+  for (let _opI3 = 0; _opI3 < _opArr3.length; _opI3++) {
+    const t = _opArr3[_opI3];
+    if (t.length > 1) _opAcc3.push(t);
+  }
+  const longs = _opAcc3;
+  world.setDynamicProperty('longs', longs.length);
+  const _opArr4 = tags;
+  let _opRes4 = false;
+  for (let _opI4 = 0; _opI4 < _opArr4.length; _opI4++) {
+    const t = _opArr4[_opI4];
+    if (t === 'bb') {
+      _opRes4 = true;
+      break;
+    }
+  }
+  const hasBb = _opRes4;
+  const _opArr5 = tags;
+  let _opRes5 = true;
+  for (let _opI5 = 0; _opI5 < _opArr5.length; _opI5++) {
+    const t = _opArr5[_opI5];
+    if (!(t.length < 5)) {
+      _opRes5 = false;
+      break;
+    }
+  }
+  const allShort = _opRes5;
+  const _opArr6 = tags;
+  let _opRes6;
+  for (let _opI6 = 0; _opI6 < _opArr6.length; _opI6++) {
+    const t = _opArr6[_opI6];
+    if (t.length === 3) {
+      _opRes6 = t;
+      break;
+    }
+  }
+  const found = _opRes6;
+  world.setDynamicProperty('checks', String(hasBb) + String(allShort) + String(found));
+}
+system.runInterval(onTick, 20);

package/test/array-methods-to-loops/expects.json

@@ -0,0 +1,6 @@
+{
+    "hotFunctions":  1,
+    "transforms":  {
+                       "array-methods-to-loops":  6
+                   }
+}

package/test/array-methods-to-loops/input.js

@@ -0,0 +1,23 @@
+// S5: array-method inlining inside a hot tick handler.
+import { world, system } from '@minecraft/server';
+
+const tags = ['a', 'bb', 'ccc'];
+
+function onTick() {
+  tags.forEach((t) => {
+    world.sendMessage('tag:' + t);
+  });
+
+  const doubled = tags.map((t) => t + '!');
+  world.setDynamicProperty('doubled', doubled.join(','));
+
+  const longs = tags.filter((t) => t.length > 1);
+  world.setDynamicProperty('longs', longs.length);
+
+  const hasBb = tags.some((t) => t === 'bb');
+  const allShort = tags.every((t) => t.length < 5);
+  const found = tags.find((t) => t.length === 3);
+  world.setDynamicProperty('checks', String(hasBb) + String(allShort) + String(found));
+}
+
+system.runInterval(onTick, 20);

package/test/array-methods-to-loops/scenario.json

@@ -0,0 +1,22 @@
+{
+    "reads":  {
+
+              },
+    "entry":  "scripts/input.js",
+    "steps":  [
+                  {
+                      "n":  5,
+                      "op":  "tick"
+                  }
+              ],
+    "state":  {
+                  "players":  [
+                                  {
+                                      "id":  "p1"
+                                  },
+                                  {
+                                      "id":  "p2"
+                                  }
+                              ]
+              }
+}

package/test/array-methods-to-loops-bail/expected.js

@@ -0,0 +1,10 @@
+// S5 bails: non-inline callbacks, this/arguments, optional chaining.
+import { world, system } from '@minecraft/server';
+const _opLift = t => world.sendMessage(t);
+function handler(t) {
+  world.sendMessage(t);
+}
+function optionalTick(tags) {
+  tags?.forEach(_opLift);
+}
+system.runInterval(() => optionalTick(['a']), 20);

package/test/array-methods-to-loops-bail/input.js

@@ -0,0 +1,24 @@
+// S5 bails: non-inline callbacks, this/arguments, optional chaining.
+import { world, system } from '@minecraft/server';
+
+function handler(t) {
+  world.sendMessage(t);
+}
+
+function onTick(tags) {
+  tags.forEach(handler);
+
+  const obj = {
+    run: function () {
+      tags.forEach((t) => this.log(t));
+      return 1;
+    },
+  };
+  return obj;
+}
+
+function optionalTick(tags) {
+  tags?.forEach((t) => world.sendMessage(t));
+}
+
+system.runInterval(() => optionalTick(['a']), 20);

package/test/bool-simplify/expected.js

@@ -0,0 +1,14 @@
+// S3: boolean simplification shapes.
+export function f(x, y) {
+  const a = !!(x > 0);
+  return !!(y > 1);
+}
+export function g(x) {
+  return x > 0;
+}
+export function h(x) {
+  return x !== 3;
+}
+export function b(x) {
+  return x === true; // bails: x not statically boolean-typed
+}

package/test/bool-simplify/expects.json

@@ -0,0 +1,11 @@
+{
+    "transforms":  {
+                       "bool-simplify":  4
+                   },
+    "bails":  [
+                  {
+                      "transform":  "S3",
+                      "reasonContains":  "not statically boolean"
+                  }
+              ]
+}

package/test/bool-simplify/input.js

@@ -0,0 +1,18 @@
+// S3: boolean simplification shapes.
+export function f(x, y) {
+  const a = x > 0 ? true : false;
+  if (y > 1) {
+    return true;
+  } else {
+    return false;
+  }
+}
+export function g(x) {
+  return (x > 0) === true;
+}
+export function h(x) {
+  return (x !== 3) !== false;
+}
+export function b(x) {
+  return x === true; // bails: x not statically boolean-typed
+}

package/test/cache-getter-chains/expected.js

@@ -0,0 +1,20 @@
+// B1: repeated host chains cached within barrier-free regions.
+import { world, system } from '@minecraft/server';
+function onTick(player) {
+  const _opC = player.location.x;
+  // Two uses in one statement: cached with one const before the statement.
+  world.sendMessage('x=' + _opC + ' again=' + _opC);
+
+  // Two uses across barrier-free statements: cached across both.
+  const _opC2 = player.location.y;
+  const first = _opC2;
+  const second = _opC2 + 1;
+  world.sendMessage('y=' + (first + second));
+
+  // Uses split by a call barrier: bails.
+  const a = player.location.z;
+  world.sendMessage('mid');
+  const b = player.location.z;
+  world.sendMessage('z=' + (a + b));
+}
+system.runInterval(onTick, 20);

package/test/cache-getter-chains/expects.json

@@ -0,0 +1,11 @@
+{
+    "transforms":  {
+                       "cache-getter-chains":  2
+                   },
+    "bails":  [
+                  {
+                      "transform":  "B1",
+                      "reasonContains":  "split by call/assignment barriers"
+                  }
+              ]
+}

package/test/cache-getter-chains/input.js

@@ -0,0 +1,20 @@
+// B1: repeated host chains cached within barrier-free regions.
+import { world, system } from '@minecraft/server';
+
+function onTick(player) {
+  // Two uses in one statement: cached with one const before the statement.
+  world.sendMessage('x=' + player.location.x + ' again=' + player.location.x);
+
+  // Two uses across barrier-free statements: cached across both.
+  const first = player.location.y;
+  const second = player.location.y + 1;
+  world.sendMessage('y=' + (first + second));
+
+  // Uses split by a call barrier: bails.
+  const a = player.location.z;
+  world.sendMessage('mid');
+  const b = player.location.z;
+  world.sendMessage('z=' + (a + b));
+}
+
+system.runInterval(onTick, 20);

package/test/cache-getter-chains/scenario.json

@@ -0,0 +1,35 @@
+{
+    "reads":  {
+                  "location:p1":  [
+                                      {
+                                          "y":  64,
+                                          "z":  2,
+                                          "x":  1
+                                      }
+                                  ],
+                  "location:p2":  [
+                                      {
+                                          "y":  70,
+                                          "z":  4,
+                                          "x":  3
+                                      }
+                                  ]
+              },
+    "entry":  "scripts/input.js",
+    "steps":  [
+                  {
+                      "n":  5,
+                      "op":  "tick"
+                  }
+              ],
+    "state":  {
+                  "players":  [
+                                  {
+                                      "id":  "p1"
+                                  },
+                                  {
+                                      "id":  "p2"
+                                  }
+                              ]
+              }
+}

package/test/closure-lift/expected.js

@@ -0,0 +1,58 @@
+// B2: closure lifting inside a hot handler.
+import { world, system } from '@minecraft/server';
+const _opLift = () => {
+  world.sendMessage('tick');
+};
+const _opLift2 = () => world.sendMessage(PREFIX + ':2');
+const _opCap = 7;
+const _opLift3 = () => world.sendMessage('n=' + _opCap);
+let _opCell;
+const _opLift4 = suffix => world.sendMessage(_opCell.tag + suffix);
+const _opLift5 = () => setup(world.getAllPlayers()[0]);
+const _opLift6 = () => reassigned(world.getAllPlayers()[0]);
+const PREFIX = 'op';
+function onTick() {
+  // Captures nothing: lifted.
+  const announce = _opLift;
+  announce();
+
+  // Captures a module-level const: lifted.
+  const announce2 = _opLift2;
+  announce2();
+
+  // Captures a per-invocation const primitive: lifted with the value inlined
+  // as a module const (_opCap).
+  const local = 7;
+  const announce3 = _opLift3;
+  announce3();
+
+  // Captures a never-reassigned live local, called synchronously: lifted via
+  // a module-level cell assigned at the creation point.
+  const ctxObj = {
+    tag: 'x'
+  };
+  _opCell = ctxObj;
+  const announce4 = _opLift4;
+  announce4('!4');
+}
+
+// Escaping arrow (registration) capturing a live local: bails — each
+// registration needs its own capture and the invocation count is unprovable.
+function setup(player) {
+  const cb = () => world.sendMessage('hi ' + player.name);
+  system.runInterval(cb, 20);
+}
+
+// Reassigned capture: bails.
+function reassigned(player) {
+  let n = player.location.y;
+  const cb = () => world.sendMessage('n=' + n);
+  cb();
+  n = 9;
+  cb();
+}
+world.afterEvents.worldLoad.subscribe(() => {
+  system.runInterval(onTick, 20);
+  system.runInterval(_opLift5, 20);
+  system.runInterval(_opLift6, 20);
+});

package/test/closure-lift/expects.json

@@ -0,0 +1 @@
+{"transforms": {"closure-lift": 6}, "bails": [{"transform": "B2", "reasonContains": "escapes as a value"}, {"transform": "B2", "reasonContains": "reassigned"}]}

package/test/closure-lift/input.js

@@ -0,0 +1,50 @@
+// B2: closure lifting inside a hot handler.
+import { world, system } from '@minecraft/server';
+
+const PREFIX = 'op';
+
+function onTick() {
+  // Captures nothing: lifted.
+  const announce = () => {
+    world.sendMessage('tick');
+  };
+  announce();
+
+  // Captures a module-level const: lifted.
+  const announce2 = () => world.sendMessage(PREFIX + ':2');
+  announce2();
+
+  // Captures a per-invocation const primitive: lifted with the value inlined
+  // as a module const (_opCap).
+  const local = 7;
+  const announce3 = () => world.sendMessage('n=' + local);
+  announce3();
+
+  // Captures a never-reassigned live local, called synchronously: lifted via
+  // a module-level cell assigned at the creation point.
+  const ctxObj = { tag: 'x' };
+  const announce4 = (suffix) => world.sendMessage(ctxObj.tag + suffix);
+  announce4('!4');
+}
+
+// Escaping arrow (registration) capturing a live local: bails — each
+// registration needs its own capture and the invocation count is unprovable.
+function setup(player) {
+  const cb = () => world.sendMessage('hi ' + player.name);
+  system.runInterval(cb, 20);
+}
+
+// Reassigned capture: bails.
+function reassigned(player) {
+  let n = player.location.y;
+  const cb = () => world.sendMessage('n=' + n);
+  cb();
+  n = 9;
+  cb();
+}
+
+world.afterEvents.worldLoad.subscribe(() => {
+  system.runInterval(onTick, 20);
+  system.runInterval(() => setup(world.getAllPlayers()[0]), 20);
+  system.runInterval(() => reassigned(world.getAllPlayers()[0]), 20);
+});

package/test/closure-lift/scenario.json

@@ -0,0 +1,9 @@
+{
+  "entry": "scripts/input.js",
+  "reads": { "location:p1": [{ "x": 1, "y": 64, "z": 2 }], "name:p1": ["Alice"] },
+  "state": { "players": [{ "id": "p1" }, { "id": "p2" }] },
+  "steps": [
+    { "op": "fire", "event": "world.afterEvents.worldLoad", "payload": {} },
+    { "op": "tick", "n": 45 }
+  ]
+}

package/test/const-fold/expected.js

@@ -0,0 +1,12 @@
+// S1: constant folding shapes.
+export const a = 3;
+export const b = "xyz";
+export const c = "string";
+export const d = false;
+export const e = false;
+export const f = 10;
+export const g = "a1b";
+export const h = 'fallback';
+export const i = 5;
+export const j = i + 1; // never folded: crosses an identifier
+export const k = Math.floor(1.5); // never folded: function call

package/test/const-fold/expects.json

@@ -0,0 +1 @@
+{"transforms": {"const-fold": 12}}

package/test/const-fold/input.js

@@ -0,0 +1,12 @@
+// S1: constant folding shapes.
+export const a = 1 + 2;
+export const b = 'x' + 'y' + 'z';
+export const c = typeof 'hello';
+export const d = !true;
+export const e = 10 > 5 && 3 < 2;
+export const f = 2 * 3 + 4;
+export const g = `a${1}b`;
+export const h = null ?? 'fallback';
+export const i = 5;
+export const j = i + 1; // never folded: crosses an identifier
+export const k = Math.floor(1.5); // never folded: function call

package/test/const-fold-bail/expected.js

@@ -0,0 +1,7 @@
+// S1 bail: identifiers and calls never fold.
+export const a = x + 1;
+export const b = Math.floor(1.5);
+export const c = obj.k + 1;
+export function d(x) {
+  return x * 2 + 1;
+}

package/test/const-fold-bail/expects.json

@@ -0,0 +1,3 @@
+{
+    "noTransforms":  true
+}

package/test/const-fold-bail/input.js

@@ -0,0 +1,7 @@
+// S1 bail: identifiers and calls never fold.
+export const a = x + 1;
+export const b = Math.floor(1.5);
+export const c = obj.k + 1;
+export function d(x) {
+  return x * 2 + 1;
+}

package/test/cross-tick-cache/config.json

@@ -0,0 +1 @@
+{"level": "risky"}

package/test/cross-tick-cache/expected.js

@@ -0,0 +1,38 @@
+// R1: cross-tick caches (risky, opt-in).
+import { world, system } from '@minecraft/server';
+const __opR1Cache = new WeakMap();
+function __opR1Component(obj, key) {
+  let m = __opR1Cache.get(obj);
+  if (m === undefined) {
+    m = new Map();
+    __opR1Cache.set(obj, m);
+  }
+  let v = m.get(key);
+  if (v === undefined) {
+    v = obj.getComponent(key);
+    m.set(key, v);
+  }
+  return v;
+}
+function __opR1Field(obj, key) {
+  let m = __opR1Cache.get(obj);
+  if (m === undefined) {
+    m = new Map();
+    __opR1Cache.set(obj, m);
+  }
+  let v = m.get(key);
+  if (v === undefined) {
+    v = obj[key];
+    m.set(key, v);
+  }
+  return v;
+}
+function onTick(player) {
+  const health = __opR1Component(player, "minecraft:health");
+  const id = __opR1Field(player, "id");
+  const typeId = __opR1Field(player, "typeId");
+  if (health) {
+    world.sendMessage(id + ':' + typeId + ':' + health.currentValue);
+  }
+}
+system.runInterval(() => onTick(world.getAllPlayers()[0]), 20);

package/test/cross-tick-cache/expects.json

@@ -0,0 +1,6 @@
+{
+    "warnings":  3,
+    "transforms":  {
+                       "cross-tick-cache":  3
+                   }
+}

package/test/cross-tick-cache/input.js

@@ -0,0 +1,13 @@
+// R1: cross-tick caches (risky, opt-in).
+import { world, system } from '@minecraft/server';
+
+function onTick(player) {
+  const health = player.getComponent('minecraft:health');
+  const id = player.id;
+  const typeId = player.typeId;
+  if (health) {
+    world.sendMessage(id + ':' + typeId + ':' + health.currentValue);
+  }
+}
+
+system.runInterval(() => onTick(world.getAllPlayers()[0]), 20);

package/test/cross-tick-cache/scenario.json

@@ -0,0 +1,33 @@
+{
+    "reads":  {
+                  "component:p1:minecraft:health":  [
+                                                        {
+                                                            "currentValue":  20
+                                                        }
+                                                    ],
+                  "location:p1":  [
+                                      {
+                                          "y":  64,
+                                          "z":  2,
+                                          "x":  1
+                                      }
+                                  ]
+              },
+    "entry":  "scripts/input.js",
+    "steps":  [
+                  {
+                      "n":  5,
+                      "op":  "tick"
+                  }
+              ],
+    "state":  {
+                  "players":  [
+                                  {
+                                      "id":  "p1"
+                                  },
+                                  {
+                                      "id":  "p2"
+                                  }
+                              ]
+              }
+}