chore: reorganize benchmarks (#13606)

benchmark/babel-parser/large-regexp/bench.mjs

@@ -0,0 +1,22 @@
+import Benchmark from "benchmark";
+import baseline from "@babel-baseline/parser";
+import current from "@babel/parser";
+import { report } from "../../util.mjs";
+
+const suite = new Benchmark.Suite();
+function createInput(length) {
+  return "const a = /" + "[/\\\\]".repeat(length / 4) + "/igsudm";
+}
+function benchCases(name, implementation, options) {
+  for (const length of [256, 512, 1024, 2048]) {
+    const input = createInput(length);
+    suite.add(`${name} ${length}-size RegExp literal `, () => {
+      implementation.parse(input, options);
+    });
+  }
+}
+
+benchCases("baseline", baseline);
+benchCases("current", current);
+
+suite.on("cycle", report).run();

benchmark/babel-parser/many-arrow-function-flow-types/bench.mjs

@@ -0,0 +1,22 @@
+import Benchmark from "benchmark";
+import baseline from "@babel-baseline/parser";
+import current from "@babel/parser";
+import { report } from "../../util.mjs";
+
+const suite = new Benchmark.Suite();
+function createInput(length) {
+  return "type A = " + "| (x) => void".repeat(length);
+}
+function benchCases(name, implementation, options) {
+  for (const length of [256, 512, 1024, 2048]) {
+    const input = createInput(length);
+    suite.add(`${name} ${length} arrow function types`, () => {
+      implementation.parse(input, options);
+    });
+  }
+}
+
+benchCases("baseline", baseline, { plugins: ["flow"] });
+benchCases("current", current, { plugins: ["flow"] });
+
+suite.on("cycle", report).run();

benchmark/babel-parser/many-async-arrows/bench.mjs

@@ -0,0 +1,22 @@
+import Benchmark from "benchmark";
+import baseline from "@babel-baseline/parser";
+import current from "@babel/parser";
+import { report } from "../../util.mjs";
+
+const suite = new Benchmark.Suite();
+function createInput(length) {
+  return "async () => {};".repeat(length);
+}
+function benchCases(name, implementation, options) {
+  for (const length of [256, 512, 1024, 2048]) {
+    const input = createInput(length);
+    suite.add(`${name} ${length} async arrow functions`, () => {
+      implementation.parse(input, options);
+    });
+  }
+}
+
+benchCases("baseline", baseline);
+benchCases("current", current);
+
+suite.on("cycle", report).run();

benchmark/babel-parser/many-class-private-properties/1-length.bench.mjs

@@ -0,0 +1,34 @@
+import Benchmark from "benchmark";
+import baseline from "@babel-baseline/parser";
+import current from "@babel/parser";
+import { report } from "../../util.mjs";
+
+const suite = new Benchmark.Suite();
+// All codepoints in [0x4e00, 0x9ffc] are valid identifier name per Unicode 13
+function createInput(length) {
+  if (length > 0x9ffc - 0x4e00) {
+    throw new Error(
+      `Length greater than ${
+        0x9ffc - 0x4e00
+      } is not supported! Consider modify the \`createInput\`.`
+    );
+  }
+  let source = "class C { ";
+  for (let i = 0; i < length; i++) {
+    source += "#" + String.fromCharCode(0x4e00 + i) + ";";
+  }
+  return source + " }";
+}
+function benchCases(name, implementation, options) {
+  for (const length of [256, 512, 1024, 2048]) {
+    const input = createInput(length);
+    suite.add(`${name} ${length} length-1 private properties`, () => {
+      implementation.parse(input, options);
+    });
+  }
+}
+
+benchCases("baseline", baseline);
+benchCases("current", current);
+
+suite.on("cycle", report).run();

benchmark/babel-parser/many-empty-statements/attachComment-false.bench.mjs

@@ -0,0 +1,19 @@
+import Benchmark from "benchmark";
+import baseline from "@babel-baseline/parser";
+import current from "@babel/parser";
+import { report } from "../../util.mjs";
+
+const suite = new Benchmark.Suite();
+
+function benchCases(name, implementation, options) {
+  for (const length of [256, 512, 1024, 2048]) {
+    suite.add(`${name} ${length} empty statement`, () => {
+      implementation.parse(";".repeat(length), options);
+    });
+  }
+}
+
+benchCases("baseline", baseline);
+benchCases("current + attachComment: false", current, { attachComment: false });
+
+suite.on("cycle", report).run();

benchmark/babel-parser/many-identifiers/1-length.bench.mjs

@@ -0,0 +1,23 @@
+import Benchmark from "benchmark";
+import baseline from "@babel-baseline/parser";
+import current from "@babel/parser";
+import { report } from "../../util.mjs";
+
+const suite = new Benchmark.Suite();
+function createInput(length) {
+  return "a;".repeat(length);
+}
+current.parse("a");
+function benchCases(name, implementation, options) {
+  for (const length of [64, 128, 256, 512, 1024]) {
+    const input = createInput(length);
+    suite.add(`${name} ${length} length-1 identifiers`, () => {
+      implementation.parse(input, options);
+    });
+  }
+}
+
+benchCases("baseline", baseline);
+benchCases("current", current);
+
+suite.on("cycle", report).run();

benchmark/babel-parser/many-identifiers/11-length.bench.mjs

@@ -0,0 +1,23 @@
+import Benchmark from "benchmark";
+import baseline from "../../lib/index-main.js";
+import current from "@babel/parser";
+import { report } from "../../util.mjs";
+
+const suite = new Benchmark.Suite();
+function createInput(length) {
+  return "abcde12345z;".repeat(length);
+}
+current.parse("a");
+function benchCases(name, implementation, options) {
+  for (const length of [64, 128, 256, 512]) {
+    const input = createInput(length);
+    suite.add(`${name} ${length} length-11 identifiers`, () => {
+      implementation.parse(input, options);
+    });
+  }
+}
+
+benchCases("baseline", baseline);
+benchCases("current", current);
+
+suite.on("cycle", report).run();

benchmark/babel-parser/many-identifiers/2-length.bench.mjs

@@ -0,0 +1,23 @@
+import Benchmark from "benchmark";
+import baseline from "@babel-baseline/parser";
+import current from "@babel/parser";
+import { report } from "../../util.mjs";
+
+const suite = new Benchmark.Suite();
+function createInput(length) {
+  return "aa;".repeat(length);
+}
+current.parse("a");
+function benchCases(name, implementation, options) {
+  for (const length of [64, 128, 256, 512, 1024]) {
+    const input = createInput(length);
+    suite.add(`${name} ${length} length-2 identifiers`, () => {
+      implementation.parse(input, options);
+    });
+  }
+}
+
+benchCases("baseline", baseline);
+benchCases("current", current);
+
+suite.on("cycle", report).run();

benchmark/babel-parser/many-identifiers/await.mjs

@@ -0,0 +1,23 @@
+import Benchmark from "benchmark";
+import baseline from "../../lib/index-main.js";
+import current from "@babel/parser";
+import { report } from "../../util.mjs";
+
+const suite = new Benchmark.Suite();
+function createInput(length) {
+  return "await;".repeat(length);
+}
+current.parse("a");
+function benchCases(name, implementation, options) {
+  for (const length of [64, 128, 256, 512]) {
+    const input = createInput(length);
+    suite.add(`${name} ${length} await identifier`, () => {
+      implementation.parse(input, options);
+    });
+  }
+}
+
+benchCases("baseline", baseline);
+benchCases("current", current);
+
+suite.on("cycle", report).run();

benchmark/babel-parser/many-inner-comments-nested/bench.mjs

@@ -0,0 +1,22 @@
+import Benchmark from "benchmark";
+import baseline from "@babel-baseline/parser";
+import current from "@babel/parser";
+import { report } from "../../util.mjs";
+
+const suite = new Benchmark.Suite();
+function createInput(length) {
+  return "[,\n// c\n".repeat(length) + "\n]".repeat(length);
+}
+function benchCases(name, implementation, options) {
+  for (const length of [128, 256, 512, 1024]) {
+    const input = createInput(length);
+    suite.add(`${name} ${length} nested inner comments`, () => {
+      implementation.parse(input, options);
+    });
+  }
+}
+
+benchCases("baseline", baseline);
+benchCases("current", current);
+
+suite.on("cycle", report).run();

benchmark/babel-parser/many-inner-comments/bench.mjs

@@ -0,0 +1,24 @@
+import Benchmark from "benchmark";
+import baseline from "@babel-baseline/parser";
+import current from "@babel/parser";
+import { report } from "../../util.mjs";
+
+const suite = new Benchmark.Suite();
+function createInput(length) {
+  return "[" + "// c\n".repeat(length) + "]";
+}
+current.parse(createInput(256), {});
+function benchCases(name, implementation, options) {
+  for (const length of [128, 256, 512, 1024]) {
+    const input = createInput(length);
+    const { parse } = implementation;
+    suite.add(`${name} ${length} inner comments`, () => {
+      parse(input, options);
+    });
+  }
+}
+
+benchCases("baseline", baseline);
+benchCases("current", current);
+
+suite.on("cycle", report).run();

benchmark/babel-parser/many-leading-comments-nested/bench.mjs

@@ -0,0 +1,24 @@
+import Benchmark from "benchmark";
+import baseline from "@babel-baseline/parser";
+import current from "@babel/parser";
+import { report } from "../../util.mjs";
+
+const suite = new Benchmark.Suite();
+function createInput(length) {
+  return "// c\n{\n".repeat(length) + "}".repeat(length);
+}
+current.parse(createInput(256), {});
+function benchCases(name, implementation, options) {
+  for (const length of [128, 256, 512, 1024]) {
+    const input = createInput(length);
+    const { parse } = implementation;
+    suite.add(`${name} ${length} nested leading comments`, () => {
+      parse(input, options);
+    });
+  }
+}
+
+benchCases("baseline", baseline);
+benchCases("current", current);
+
+suite.on("cycle", report).run();

benchmark/babel-parser/many-leading-comments/bench.mjs

@@ -0,0 +1,24 @@
+import Benchmark from "benchmark";
+import baseline from "@babel-baseline/parser";
+import current from "@babel/parser";
+import { report } from "../../util.mjs";
+
+const suite = new Benchmark.Suite();
+function createInput(length) {
+  return "// c\n".repeat(length) + "{}";
+}
+current.parse(createInput(256), {});
+function benchCases(name, implementation, options) {
+  for (const length of [128, 256, 512, 1024]) {
+    const input = createInput(length);
+    const { parse } = implementation;
+    suite.add(`${name} ${length} leading comments`, () => {
+      parse(input, options);
+    });
+  }
+}
+
+benchCases("baseline", baseline);
+benchCases("current", current);
+
+suite.on("cycle", report).run();

benchmark/babel-parser/many-leading-trailing-comments/bench.mjs

@@ -0,0 +1,27 @@
+import Benchmark from "benchmark";
+import baseline from "@babel-baseline/parser";
+import current from "@babel/parser";
+import { report } from "../../util.mjs";
+
+const suite = new Benchmark.Suite();
+function createInput(length) {
+  return "\n// c\na".repeat(length);
+}
+current.parse(createInput(256), {});
+function benchCases(name, implementation, options) {
+  for (const length of [128, 256, 512, 1024]) {
+    const input = createInput(length);
+    const { parse } = implementation;
+    suite.add(
+      `${name} ${length} leading comments + ${length - 1} trailing comments`,
+      () => {
+        parse(input, options);
+      }
+    );
+  }
+}
+
+benchCases("baseline", baseline);
+benchCases("current", current);
+
+suite.on("cycle", report).run();

benchmark/babel-parser/many-let-declarations-within-block/10-length-binding.mjs

@@ -0,0 +1,22 @@
+import Benchmark from "benchmark";
+import baseline from "@babel-baseline/parser";
+import current from "@babel/parser";
+import { report } from "../../util.mjs";
+
+const suite = new Benchmark.Suite();
+function createInput(length) {
+  return "{ let foecnatsni };".repeat(length);
+}
+function benchCases(name, implementation, options) {
+  for (const length of [64, 128, 256, 512]) {
+    const input = createInput(length);
+    suite.add(`${name} ${length} let and length-10 binding identifiers`, () => {
+      implementation.parse(input, options);
+    });
+  }
+}
+
+benchCases("baseline", baseline);
+benchCases("current", current);
+
+suite.on("cycle", report).run();

benchmark/babel-parser/many-let-declarations/1-length-binding.mjs

@@ -0,0 +1,34 @@
+import Benchmark from "benchmark";
+import baseline from "@babel-baseline/parser";
+import current from "@babel/parser";
+import { report } from "../../util.mjs";
+
+const suite = new Benchmark.Suite();
+// All codepoints in [0x4e00, 0x9ffc] are valid identifier name per Unicode 13
+function createInput(length) {
+  if (length > 0x9ffc - 0x4e00) {
+    throw new Error(
+      `Length greater than ${
+        0x9ffc - 0x4e00
+      } is not supported! Consider modify the \`createInput\`.`
+    );
+  }
+  let source = "";
+  for (let i = 0; i < length; i++) {
+    source += "let " + String.fromCharCode(0x4e00 + i) + ";";
+  }
+  return source;
+}
+function benchCases(name, implementation, options) {
+  for (const length of [256, 512, 1024, 2048]) {
+    const input = createInput(length);
+    suite.add(`${name} ${length} length-1 let bindings`, () => {
+      implementation.parse(input, options);
+    });
+  }
+}
+
+benchCases("baseline", baseline);
+benchCases("current", current);
+
+suite.on("cycle", report).run();

benchmark/babel-parser/many-named-export/1-length.bench.mjs

@@ -0,0 +1,34 @@
+import Benchmark from "benchmark";
+import baseline from "@babel-baseline/parser";
+import current from "@babel/parser";
+import { report } from "../../util.mjs";
+
+const suite = new Benchmark.Suite();
+// All codepoints in [0x4e00, 0x9ffc] are valid identifier name per Unicode 13
+function createInput(length) {
+  if (length > 0x9ffc - 0x4e00) {
+    throw new Error(
+      `Length greater than ${
+        0x9ffc - 0x4e00
+      } is not supported! Consider modify the \`createInput\`.`
+    );
+  }
+  let source = "export { ";
+  for (let i = 0; i < length; i++) {
+    source += String.fromCharCode(0x4e00 + i) + ",";
+  }
+  return source + " } from './foo'";
+}
+function benchCases(name, implementation, options) {
+  for (const length of [256, 512, 1024, 2048]) {
+    const input = createInput(length);
+    suite.add(`${name} ${length} length-1 named export`, () => {
+      implementation.parse(input, options);
+    });
+  }
+}
+
+benchCases("baseline", baseline, { sourceType: "module" });
+benchCases("current", current, { sourceType: "module" });
+
+suite.on("cycle", report).run();

benchmark/babel-parser/many-small-all-flags-regexp/bench.mjs

@@ -0,0 +1,22 @@
+import Benchmark from "benchmark";
+import baseline from "../../lib/index-v2.js";
+import current from "@babel/parser";
+import { report } from "../../util.mjs";
+
+const suite = new Benchmark.Suite();
+function createInput(length) {
+  return "/x/dgimsuy;".repeat(length);
+}
+function benchCases(name, implementation, options) {
+  for (const length of [256, 512, 1024, 2048]) {
+    const input = createInput(length);
+    suite.add(`${name} ${length} small regexp literal with all flags`, () => {
+      implementation.parse(input, options);
+    });
+  }
+}
+
+benchCases("baseline", baseline);
+benchCases("current", current);
+
+suite.on("cycle", report).run();

benchmark/babel-parser/many-trailing-comments-nested/bench.mjs

@@ -0,0 +1,22 @@
+import Benchmark from "benchmark";
+import baseline from "@babel-baseline/parser";
+import current from "@babel/parser";
+import { report } from "../../util.mjs";
+
+const suite = new Benchmark.Suite();
+function createInput(length) {
+  return "{".repeat(length) + "} // c\n".repeat(length);
+}
+function benchCases(name, implementation, options) {
+  for (const length of [128, 256, 512, 1024]) {
+    const input = createInput(length);
+    suite.add(`${name} ${length} nested trailing comments`, () => {
+      implementation.parse(input, options);
+    });
+  }
+}
+
+benchCases("baseline", baseline);
+benchCases("current", current);
+
+suite.on("cycle", report).run();

benchmark/babel-parser/many-trailing-comments/bench.mjs

@@ -0,0 +1,24 @@
+import Benchmark from "benchmark";
+import baseline from "@babel-baseline/parser";
+import current from "@babel/parser";
+import { report } from "../../util.mjs";
+
+const suite = new Benchmark.Suite();
+function createInput(length) {
+  return "{}" + "// c\n".repeat(length);
+}
+current.parse(createInput(256), {});
+function benchCases(name, implementation, options) {
+  for (const length of [128, 256, 512, 1024]) {
+    const input = createInput(length);
+    const { parse } = implementation;
+    suite.add(`${name} ${length} trailing comments`, () => {
+      parse(input, options);
+    });
+  }
+}
+
+benchCases("baseline", baseline);
+benchCases("current", current);
+
+suite.on("cycle", report).run();