parseman 0.50.0 → 0.50.1

package/dist/plugin/index.js

@@ -6540,6 +6540,22 @@ var Encoder = class {
   choiceRollbackMasks = /* @__PURE__ */ new Map();
   nonCommittingChoiceSites = /* @__PURE__ */ new Set();
   failureRollbackCleanSites = /* @__PURE__ */ new Set();
+  /**
+   * `hasSideWriter` memo for `failureNeedsRollback`, shared across every call
+   * for the lifetime of this `Encoder`. A cached entry is written only when
+   * `complete` is true, which means the answer is a path-independent fact
+   * about that combinator node — it does not depend on which root's traversal
+   * asked, only on the node's own reachable subgraph. Scoping the memo per call
+   * (as a local inside `failureNeedsRollback`) was correct but discarded that
+   * fact after every arm, so a grammar with many ordered-choice arms / optional
+   * / attempt sites re-walked the SAME shared rule graph from scratch for each
+   * site — O(sites × graph size) instead of O(graph size). Measured on the
+   * scss-parser grammar (composed CSS-base superset, the deepest/largest of the
+   * four grammars): 47-50s for one `compileRuleMap` with the per-call memo,
+   * versus the whole macro transform completing in under a second once this
+   * memo is hoisted here.
+   */
+  sideWriterMemo = /* @__PURE__ */ new Map();
   labels = void 0;
   /** Trivia table in scope at the row being encoded — codegen's `ctx.activeTrivia`. */
   activeTrivia = void 0;
@@ -6965,13 +6981,13 @@ var Encoder = class {
     const refName = p._ruleName;
     const winner = refName === void 0 ? void 0 : this.winners?.[refName];
     const root = winner !== void 0 && !winnerWrapsReference2(winner, p) ? winner : p;
-    const sideWriterMemo = /* @__PURE__ */ new Map();
-    const hasSideWriter = (current, seen = /* @__PURE__ */ new Set()) => {
+    const sideWriterMemo = this.sideWriterMemo;
+    const seen = /* @__PURE__ */ new Set();
+    const hasSideWriter = (current) => {
       const cached = sideWriterMemo.get(current);
       if (cached !== void 0) return { found: cached, complete: true };
       if (seen.has(current)) return { found: false, complete: false };
-      const next = new Set(seen);
-      next.add(current);
+      seen.add(current);
       const def = current._def;
       let result;
       switch (def.tag) {
@@ -6986,11 +7002,11 @@ var Encoder = class {
           const name = current._ruleName;
           const resolvedWinner = name === void 0 ? void 0 : this.winners?.[name];
           if (resolvedWinner !== void 0 && !winnerWrapsReference2(resolvedWinner, current)) {
-            result = hasSideWriter(resolvedWinner, next);
+            result = hasSideWriter(resolvedWinner);
             break;
           }
           try {
-            result = hasSideWriter(def.thunk(), next);
+            result = hasSideWriter(def.thunk());
           } catch {
             result = { found: true, complete: true };
           }
@@ -7000,7 +7016,7 @@ var Encoder = class {
           let complete = true;
           result = { found: false, complete: true };
           for (const child of childrenOf2(def)) {
-            const childResult = hasSideWriter(child, next);
+            const childResult = hasSideWriter(child);
             if (childResult.found) {
               result = { found: true, complete: true };
               break;
@@ -7010,6 +7026,7 @@ var Encoder = class {
           if (!result.found) result = { found: false, complete };
         }
       }
+      seen.delete(current);
       if (result.found || result.complete) sideWriterMemo.set(current, result.found);
       return result;
     };
@@ -16675,7 +16692,7 @@ function compileRuleMap(ruleMap, opts = {}) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.50.0";
+var PARSEMAN_VERSION = "0.50.1";
 
 // src/compiler/compile-linkable-table.ts
 function isLocal(rule) {