@wyw-in-js/transform 2.0.0-alpha.1 → 2.0.0

package/esm/utils/oxc/ast.js

@@ -1,28 +1,58 @@
 export const isOxcNode = (value) => !!value && typeof value === "object" && "type" in value && typeof value.type === "string";
+// Cache visitor-key lists per node.type. oxc-parser AST nodes have a stable
+// shape per `type` — optional children are present as null/undefined, not
+// omitted — so Object.keys() returns the same key set for every instance of
+// the same kind. First instance pays the discovery cost; the rest do an
+// indexed lookup. getOxcNodeChildren is invoked tens of millions of times
+// on a cold build of a large monorepo, so this matters a lot.
+//
+// An instance-level WeakMap cache of the resulting Node[] was tried and
+// regressed wall time ~20% (WeakMap.get/set per call beat the recompute
+// savings for small children arrays + pinned arrays into older generations
+// and increased GC pressure). Per-type key cache only.
+const META_KEYS = new Set([
+	"comments",
+	"end",
+	"errors",
+	"parent",
+	"range",
+	"span",
+	"start",
+	"type"
+]);
+const VISITOR_KEYS_BY_TYPE = new Map();
+const visitorKeysFor = (node) => {
+	let keys = VISITOR_KEYS_BY_TYPE.get(node.type);
+	if (keys === undefined) {
+		keys = Object.keys(node).filter((key) => !META_KEYS.has(key));
+		VISITOR_KEYS_BY_TYPE.set(node.type, keys);
+	}
+	return keys;
+};
 export const getOxcNodeChildren = (node) => {
 	const result = [];
 	const record = node;
-	Object.keys(record).forEach((key) => {
-		if (key === "comments" || key === "end" || key === "errors" || key === "parent" || key === "range" || key === "span" || key === "start" || key === "type") {
-			return;
-		}
-		const value = record[key];
+	const keys = visitorKeysFor(record);
+	for (let i = 0; i < keys.length; i += 1) {
+		const value = record[keys[i]];
 		if (isOxcNode(value)) {
 			result.push(value);
-			return;
-		}
-		if (Array.isArray(value)) {
-			value.forEach((item) => {
+		} else if (Array.isArray(value)) {
+			for (let j = 0; j < value.length; j += 1) {
+				const item = value[j];
 				if (isOxcNode(item)) {
 					result.push(item);
 				}
-			});
+			}
 		}
-	});
+	}
 	return result;
 };
 export const walkOxc = (node, enter, parent = null) => {
 	enter(node, parent);
-	getOxcNodeChildren(node).forEach((child) => walkOxc(child, enter, node));
+	const children = getOxcNodeChildren(node);
+	for (let i = 0; i < children.length; i += 1) {
+		walkOxc(children[i], enter, node);
+	}
 };
 //# sourceMappingURL=ast.js.map

package/esm/utils/oxc/ast.js.map

@@ -1 +1 @@
-{"mappings":"AAIA,OAAO,MAAM,aAAa,UACxB,CAAC,CAAC,SACF,OAAO,UAAU,YACjB,UAAU,SACV,OAAQ,MAA6B,SAAS;AAEhD,OAAO,MAAM,sBAAsB,SAAuB;CACxD,MAAM,SAAiB,EAAE;CACzB,MAAM,SAAS;AAEf,QAAO,KAAK,OAAO,CAAC,SAAS,QAAQ;AACnC,MACE,QAAQ,cACR,QAAQ,SACR,QAAQ,YACR,QAAQ,YACR,QAAQ,WACR,QAAQ,UACR,QAAQ,WACR,QAAQ,QACR;AACA;;EAGF,MAAM,QAAQ,OAAO;AACrB,MAAI,UAAU,MAAM,EAAE;AACpB,UAAO,KAAK,MAAM;AAClB;;AAGF,MAAI,MAAM,QAAQ,MAAM,EAAE;AACxB,SAAM,SAAS,SAAS;AACtB,QAAI,UAAU,KAAK,EAAE;AACnB,YAAO,KAAK,KAAK;;KAEnB;;GAEJ;AAEF,QAAO;;AAGT,OAAO,MAAM,WACX,MACA,OACA,SAAsB,SACb;AACT,OAAM,MAAM,OAAO;AACnB,oBAAmB,KAAK,CAAC,SAAS,UAAU,QAAQ,OAAO,OAAO,KAAK,CAAC","names":[],"sources":["../../../src/utils/oxc/ast.ts"],"version":3,"sourcesContent":["import type { Node } from 'oxc-parser';\n\ntype AnyOxcNode = Node & Record<string, unknown>;\n\nexport const isOxcNode = (value: unknown): value is Node =>\n  !!value &&\n  typeof value === 'object' &&\n  'type' in value &&\n  typeof (value as { type?: unknown }).type === 'string';\n\nexport const getOxcNodeChildren = (node: Node): Node[] => {\n  const result: Node[] = [];\n  const record = node as AnyOxcNode;\n\n  Object.keys(record).forEach((key) => {\n    if (\n      key === 'comments' ||\n      key === 'end' ||\n      key === 'errors' ||\n      key === 'parent' ||\n      key === 'range' ||\n      key === 'span' ||\n      key === 'start' ||\n      key === 'type'\n    ) {\n      return;\n    }\n\n    const value = record[key];\n    if (isOxcNode(value)) {\n      result.push(value);\n      return;\n    }\n\n    if (Array.isArray(value)) {\n      value.forEach((item) => {\n        if (isOxcNode(item)) {\n          result.push(item);\n        }\n      });\n    }\n  });\n\n  return result;\n};\n\nexport const walkOxc = (\n  node: Node,\n  enter: (node: Node, parent: Node | null) => void,\n  parent: Node | null = null\n): void => {\n  enter(node, parent);\n  getOxcNodeChildren(node).forEach((child) => walkOxc(child, enter, node));\n};\n"],"file":"ast.js"}
+{"mappings":"AAIA,OAAO,MAAM,aAAa,UACxB,CAAC,CAAC,SACF,OAAO,UAAU,YACjB,UAAU,SACV,OAAQ,MAA6B,SAAS;;;;;;;;;;;;AAahD,MAAM,YAAY,IAAI,IAAI;CACxB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;AACF,MAAM,uBAAuB,IAAI,KAAgC;AACjE,MAAM,kBAAkB,SAAwC;CAC9D,IAAI,OAAO,qBAAqB,IAAI,KAAK,KAAK;AAC9C,KAAI,SAAS,WAAW;AACtB,SAAO,OAAO,KAAK,KAAK,CAAC,QAAQ,QAAQ,CAAC,UAAU,IAAI,IAAI,CAAC;AAC7D,uBAAqB,IAAI,KAAK,MAAM,KAAK;;AAE3C,QAAO;;AAGT,OAAO,MAAM,sBAAsB,SAAuB;CACxD,MAAM,SAAiB,EAAE;CACzB,MAAM,SAAS;CACf,MAAM,OAAO,eAAe,OAAO;AACnC,MAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK,GAAG;EACvC,MAAM,QAAQ,OAAO,KAAK;AAC1B,MAAI,UAAU,MAAM,EAAE;AACpB,UAAO,KAAK,MAAM;aACT,MAAM,QAAQ,MAAM,EAAE;AAC/B,QAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,GAAG;IACxC,MAAM,OAAO,MAAM;AACnB,QAAI,UAAU,KAAK,EAAE;AACnB,YAAO,KAAK,KAAK;;;;;AAKzB,QAAO;;AAGT,OAAO,MAAM,WACX,MACA,OACA,SAAsB,SACb;AACT,OAAM,MAAM,OAAO;CACnB,MAAM,WAAW,mBAAmB,KAAK;AACzC,MAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK,GAAG;AAC3C,UAAQ,SAAS,IAAI,OAAO,KAAK","names":[],"sources":["../../../src/utils/oxc/ast.ts"],"version":3,"sourcesContent":["import type { Node } from 'oxc-parser';\n\ntype AnyOxcNode = Node & Record<string, unknown>;\n\nexport const isOxcNode = (value: unknown): value is Node =>\n  !!value &&\n  typeof value === 'object' &&\n  'type' in value &&\n  typeof (value as { type?: unknown }).type === 'string';\n\n// Cache visitor-key lists per node.type. oxc-parser AST nodes have a stable\n// shape per `type` — optional children are present as null/undefined, not\n// omitted — so Object.keys() returns the same key set for every instance of\n// the same kind. First instance pays the discovery cost; the rest do an\n// indexed lookup. getOxcNodeChildren is invoked tens of millions of times\n// on a cold build of a large monorepo, so this matters a lot.\n//\n// An instance-level WeakMap cache of the resulting Node[] was tried and\n// regressed wall time ~20% (WeakMap.get/set per call beat the recompute\n// savings for small children arrays + pinned arrays into older generations\n// and increased GC pressure). Per-type key cache only.\nconst META_KEYS = new Set([\n  'comments',\n  'end',\n  'errors',\n  'parent',\n  'range',\n  'span',\n  'start',\n  'type',\n]);\nconst VISITOR_KEYS_BY_TYPE = new Map<string, readonly string[]>();\nconst visitorKeysFor = (node: AnyOxcNode): readonly string[] => {\n  let keys = VISITOR_KEYS_BY_TYPE.get(node.type);\n  if (keys === undefined) {\n    keys = Object.keys(node).filter((key) => !META_KEYS.has(key));\n    VISITOR_KEYS_BY_TYPE.set(node.type, keys);\n  }\n  return keys;\n};\n\nexport const getOxcNodeChildren = (node: Node): Node[] => {\n  const result: Node[] = [];\n  const record = node as AnyOxcNode;\n  const keys = visitorKeysFor(record);\n  for (let i = 0; i < keys.length; i += 1) {\n    const value = record[keys[i]];\n    if (isOxcNode(value)) {\n      result.push(value);\n    } else if (Array.isArray(value)) {\n      for (let j = 0; j < value.length; j += 1) {\n        const item = value[j];\n        if (isOxcNode(item)) {\n          result.push(item);\n        }\n      }\n    }\n  }\n  return result;\n};\n\nexport const walkOxc = (\n  node: Node,\n  enter: (node: Node, parent: Node | null) => void,\n  parent: Node | null = null\n): void => {\n  enter(node, parent);\n  const children = getOxcNodeChildren(node);\n  for (let i = 0; i < children.length; i += 1) {\n    walkOxc(children[i], enter, node);\n  }\n};\n"],"file":"ast.js"}

package/esm/utils/oxcPreevalTransforms.js

@@ -1,5 +1,6 @@
 import { collectOxcExportsAndImports } from "./collectOxcExportsAndImports.js";
 import { EventEmitter } from "./EventEmitter.js";
+import { getOxcNodeChildren } from "./oxc/ast.js";
 import { parseOxcProgramCached } from "./parseOxc.js";
 const ssrCheckFields = new Set([
 	"document",
@@ -97,28 +98,11 @@ const getStaticBinding = (scope, name) => {
 };
 const isFileLikeRequireSpecifier = (value) => value.startsWith(".") || value.startsWith("/") || value.startsWith("file:");
 const isNode = (value) => !!value && typeof value === "object" && "type" in value && typeof value.type === "string";
-const getChildren = (node) => {
-	const result = [];
-	const record = node;
-	Object.keys(record).forEach((key) => {
-		if (key === "type" || key === "start" || key === "end" || key === "range") {
-			return;
-		}
-		const value = record[key];
-		if (isNode(value)) {
-			result.push(value);
-			return;
-		}
-		if (Array.isArray(value)) {
-			value.forEach((item) => {
-				if (isNode(item)) {
-					result.push(item);
-				}
-			});
-		}
-	});
-	return result;
-};
+// Reuses the per-node.type visitor-key cache in utils/oxc/ast.ts. This file's
+// getChildren shape historically diverged from the canonical one (a smaller
+// metadata-key skip set), but the produced children list is identical in
+// practice because oxc-parser nodes don't carry the extra metadata fields.
+const getChildren = getOxcNodeChildren;
 const parseOxc = (code, filename) => {
 	return parseOxcProgramCached(filename, code, "unambiguous");
 };
@@ -314,57 +298,92 @@ const predeclareScopeNames = (node, scope) => {
 		});
 	}
 	const visitScopeDescendants = (child) => {
-		if (child.type === "VariableDeclarator") {
-			collectBindingNames(child.id).forEach((name) => {
-				scope.names.add(name);
-			});
-		} else if (child.type === "FunctionDeclaration" && child.id) {
-			scope.names.add(child.id.name);
-		} else if (child.type === "ClassDeclaration" && child.id) {
-			scope.names.add(child.id.name);
-		} else if (child.type === "ImportDefaultSpecifier" || child.type === "ImportNamespaceSpecifier" || child.type === "ImportSpecifier") {
-			scope.names.add(child.local.name);
+		switch (child.type) {
+			case "VariableDeclarator": {
+				const names = collectBindingNames(child.id);
+				for (let i = 0; i < names.length; i += 1) {
+					scope.names.add(names[i]);
+				}
+				break;
+			}
+			case "FunctionDeclaration":
+			case "ClassDeclaration":
+				if (child.id) {
+					scope.names.add(child.id.name);
+				}
+				break;
+			case "ImportDefaultSpecifier":
+			case "ImportNamespaceSpecifier":
+			case "ImportSpecifier":
+				scope.names.add(child.local.name);
+				break;
+			default: break;
 		}
 		if (createsScope(child)) {
 			return;
 		}
-		getChildren(child).forEach(visitScopeDescendants);
+		const children = getChildren(child);
+		for (let i = 0; i < children.length; i += 1) {
+			visitScopeDescendants(children[i]);
+		}
 	};
-	getChildren(node).forEach(visitScopeDescendants);
+	const rootChildren = getChildren(node);
+	for (let i = 0; i < rootChildren.length; i += 1) {
+		visitScopeDescendants(rootChildren[i]);
+	}
 };
 const declareBindings = (node, scope) => {
-	if (node.type === "VariableDeclarator") {
-		const names = collectBindingNames(node.id);
-		names.forEach((name) => {
-			scope.names.add(name);
-			scope.bindings.set(name, null);
-		});
-		if (node.id.type === "Identifier" && node.init) {
-			scope.bindings.set(node.id.name, node.init);
-		}
-		return;
-	}
-	if (node.type === "FunctionDeclaration" && node.id) {
-		scope.names.add(node.id.name);
-		scope.bindings.set(node.id.name, null);
-	}
-	if (node.type === "ClassDeclaration" && node.id) {
-		scope.names.add(node.id.name);
-		scope.bindings.set(node.id.name, null);
-		return;
-	}
-	if (node.type === "ImportDefaultSpecifier" || node.type === "ImportNamespaceSpecifier" || node.type === "ImportSpecifier") {
-		scope.names.add(node.local.name);
-		scope.bindings.set(node.local.name, null);
-		return;
-	}
-	if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
-		node.params.forEach((param) => {
-			collectBindingNames(param).forEach((name) => {
+	// Called for every visited AST node, so the dispatch is hot. A switch lets
+	// V8 generate a jump table on node.type; the previous chained `if`s walked
+	// each branch's string-compare for every non-matching node.
+	switch (node.type) {
+		case "VariableDeclarator": {
+			const names = collectBindingNames(node.id);
+			for (let i = 0; i < names.length; i += 1) {
+				const name = names[i];
 				scope.names.add(name);
 				scope.bindings.set(name, null);
-			});
-		});
+			}
+			if (node.id.type === "Identifier" && node.init) {
+				scope.bindings.set(node.id.name, node.init);
+			}
+			return;
+		}
+		case "ClassDeclaration": {
+			if (node.id) {
+				scope.names.add(node.id.name);
+				scope.bindings.set(node.id.name, null);
+			}
+			return;
+		}
+		case "ImportDefaultSpecifier":
+		case "ImportNamespaceSpecifier":
+		case "ImportSpecifier": {
+			scope.names.add(node.local.name);
+			scope.bindings.set(node.local.name, null);
+			return;
+		}
+		case "FunctionDeclaration": {
+			if (node.id) {
+				scope.names.add(node.id.name);
+				scope.bindings.set(node.id.name, null);
+			}
+		}
+		// eslint-disable-next-line no-fallthrough
+		case "FunctionExpression":
+		case "ArrowFunctionExpression": {
+			const { params } = node;
+			for (let i = 0; i < params.length; i += 1) {
+				const names = collectBindingNames(params[i]);
+				for (let j = 0; j < names.length; j += 1) {
+					const name = names[j];
+					scope.names.add(name);
+					scope.bindings.set(name, null);
+				}
+			}
+			break;
+		}
+		default: break;
 	}
 };
 const visit = (node, scope, enter, parent = null, ancestors = []) => {
@@ -375,7 +394,17 @@ const visit = (node, scope, enter, parent = null, ancestors = []) => {
 	}
 	declareBindings(node, currentScope);
 	enter(node, currentScope, parent, ancestors);
-	getChildren(node).forEach((child) => visit(child, currentScope, enter, node, [...ancestors, node]));
+	// Push onto a shared ancestors stack instead of allocating `[...ancestors,
+	// node]` per child step (O(n × depth) extra allocation on deep ASTs).
+	// Every consumer of `ancestors` in this file reads it synchronously inside
+	// the enter callback; future callers that need to retain the reference
+	// must .slice() it themselves.
+	ancestors.push(node);
+	const children = getChildren(node);
+	for (let i = 0; i < children.length; i += 1) {
+		visit(children[i], currentScope, enter, node, ancestors);
+	}
+	ancestors.pop();
 };
 export const replaceImportMetaEnvWithOxc = (code, filename) => {
 	if (!importMetaEnvRe.test(code)) {