@sproutboat/toolchain 0.4.19 → 0.4.20

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @sproutboat/toolchain
 
+## 0.4.20
+
+### Patch Changes
+
+- 0cdd803: `String.prototype.replaceAll` is linear instead of quadratic (baronunread/sproutboat#237). Porffor grew the result with one full-copy `strcat` per match; a patch to `compiler/builtins/string.ts` collects the pieces and joins them once. Replacing in a 2.1 MB string went from about 42 s to 71 ms (Node: 36 ms), with identical output.
+
 ## 0.4.19
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sproutboat/toolchain",
-  "version": "0.4.19",
+  "version": "0.4.20",
   "license": "MIT",
   "type": "module",
   "repository": {

package/src/acquire.test.ts

@@ -120,6 +120,12 @@ async function fixture(): Promise<{ archive: string; sha256: string }> {
       "}\n",
     "compiler/builtins/json.ts": "// sb_json_utf16_v1\n",
     "runtime/fetch-globals.js": "// sb_text_encoder_scalar_v1\n",
+    "compiler/builtins/string.ts":
+      "export const __Porffor_string_replaceAll = (str: any, searchValue: any, replaceValue: any) => {\n" +
+      "  let out: any = __Porffor_string_emptyLike(str);\n  let appendIndex: i32 = 0;\n  let searchIndex: i32 = 0;\n  let matched: boolean = false;\n" +
+      "    out = __Porffor_strcat(out, __Porffor_string_substringLike(str, appendIndex, matchIndex));\n    out = __Porffor_strcat(out, __Porffor_string_applyReplacer(str, match, matchIndex, replaceValue));\n" +
+      "  if (!matched) return str;\n  return __Porffor_strcat(out, __Porffor_string_substringLike(str, appendIndex, thisLen));\n};\n" +
+      "export const __String_prototype_replaceAll = function (this: string, searchValue: any, replaceValue: any) {};\n",
     "compiler/builtins/promise.ts":
       "export const __Porffor_promise_resolve = (value: any, promise: any): void => {\n" +
       "  if (Porffor.type(value) == Porffor.TYPES.object) {\n" +
@@ -202,6 +208,10 @@ test("the default call (no url/expectedSha256 override) never touches the networ
     },
   });
   expect(await readFile(join(dir, "runtime/index.js"), "utf8")).not.toBe("");
+  // #237: replaceAll joins its pieces once instead of a strcat per match.
+  expect(await readFile(join(dir, "compiler/builtins/string.ts"), "utf8")).toContain(
+    "return Porffor.callThis(__Array_prototype_join, pieces, '');",
+  );
   // #236: the native-fetch build edits uWebSockets to accept HTTP/1.0.
   const index = await readFile(join(dir, "compiler/index.js"), "utf8");
   expect(index).toContain("import { sbPatchHttp10 } from './sb-http10.js';");

package/src/patch.ts

@@ -270,6 +270,27 @@ const PROMISE_NULL_INJECT =
   "  if (Porffor.type(value) == Porffor.TYPES.object && value != null) {\n    // cheap prototype-chain probe for 'then'";
 const PROMISE_NULL_MARKER = "sproutboat #168: null is object-typed";
 
+// baronunread/sproutboat#237: String.prototype.replaceAll grew its result with
+// one __Porffor_strcat per match, and each strcat copies everything so far, so
+// a 2.7 MB string with many matches took ~22 s (Node: 17 ms). Collect the
+// pieces and join once: Array.prototype.join sizes the result up front and
+// copies each piece a single time.
+const REPLACE_ALL_EDITS = [
+  [
+    "  let out: any = __Porffor_string_emptyLike(str);\n  let appendIndex: i32 = 0;\n  let searchIndex: i32 = 0;\n  let matched: boolean = false;",
+    "  // sproutboat #237: pieces joined once, not a strcat (full copy) per match.\n  const pieces: any[] = Porffor.array.new(0);\n  let appendIndex: i32 = 0;\n  let searchIndex: i32 = 0;\n  let matched: boolean = false;",
+  ],
+  [
+    "    out = __Porffor_strcat(out, __Porffor_string_substringLike(str, appendIndex, matchIndex));\n    out = __Porffor_strcat(out, __Porffor_string_applyReplacer(str, match, matchIndex, replaceValue));",
+    "    Porffor.array.fastPush(pieces, __Porffor_string_substringLike(str, appendIndex, matchIndex));\n    Porffor.array.fastPush(pieces, __Porffor_string_applyReplacer(str, match, matchIndex, replaceValue));",
+  ],
+  [
+    "  if (!matched) return str;\n  return __Porffor_strcat(out, __Porffor_string_substringLike(str, appendIndex, thisLen));\n};",
+    "  if (!matched) return str;\n  Porffor.array.fastPush(pieces, __Porffor_string_substringLike(str, appendIndex, thisLen));\n  return Porffor.callThis(__Array_prototype_join, pieces, '');\n};",
+  ],
+] as const;
+const REPLACE_ALL_MARKER = "sproutboat #237: pieces joined once";
+
 // Porffor's TypedArray.from only handles iterables. An array-like input such
 // as { length: 16 } silently becomes an empty typed array, including HMAC
 // keys made with Uint8Array.from({ length: 16 }, mapFn). The compiler uses a
@@ -1070,6 +1091,23 @@ export async function patchPromiseResolveNull(root: string): Promise<void> {
   await writeFile(file, src.replace(PROMISE_NULL_ANCHOR, PROMISE_NULL_INJECT));
 }
 
+/** #237: linear String.prototype.replaceAll. Precompiled by patchTypedArrayFrom. */
+export async function patchReplaceAll(root: string): Promise<void> {
+  const file = resolve(root, "compiler/builtins/string.ts");
+  let src = await readFile(file, "utf8");
+  if (src.includes(REPLACE_ALL_MARKER)) return;
+  const start = src.indexOf("export const __Porffor_string_replaceAll = ");
+  const end = src.indexOf("export const __String_prototype_replaceAll = ", start);
+  if (start < 0 || end < 0) throw new Error(`could not find Porffor's replaceAll in ${file}`);
+  let body = src.slice(start, end);
+  for (const [anchor, inject] of REPLACE_ALL_EDITS) {
+    if (!body.includes(anchor)) throw new Error(`could not patch Porffor's replaceAll: anchor not found in ${file}`);
+    body = body.replace(anchor, inject);
+  }
+  src = src.slice(0, start) + body + src.slice(end);
+  await writeFile(file, src);
+}
+
 export async function patchTypedArrayFrom(root: string): Promise<void> {
   const file = resolve(root, "compiler/builtins/typedarray.js");
   const src = await readFile(file, "utf8");
@@ -1146,8 +1184,9 @@ export async function ensurePorfforPatched(root: string): Promise<void> {
   await patchRenderJs(root);
   await patchDateParser(root);
   await patchPromiseResolveNull(root);
-  // Last of the builtin edits: its precompile picks up the date and promise
-  // patches above too.
+  await patchReplaceAll(root);
+  // Last of the builtin edits: its precompile picks up the date, promise and
+  // replaceAll patches above too.
   await patchTypedArrayFrom(root);
   await patchUnicode(root);
   done.add(root);