feat: migrate void-to-undefined to compiled matchers

Author: j4k0xb

packages/matchers/package.json

@@ -3,6 +3,7 @@
   "version": "0.1.0",
   "private": true,
   "type": "module",
+  "main": "src/index.ts",
   "scripts": {
     "build": "tsx scripts/build.ts",
     "bench": "tsx benchmark/test.js",

packages/matchers/src/compiler.ts

@@ -46,31 +46,38 @@ if (${checks ?? true}) { return captures; }`;
  */
 export function compileVisitor<T extends t.Node>(
   schema: NodeSchema<T>,
-  cb: (path: NodePath<T>, captures: object) => void,
   phase: 'enter' | 'exit' = 'enter',
-): Visitor {
+): <S = unknown>(cb: VisitNodeFunction<S, T>) => Visitor<S> {
   const context: Context = { captures: [] };
   const checks = compileNode(schema, 'node', context, false);
   const code = `
+const node = path.node;
 const captures = { ${context.captures.map((v) => `${v}: undefined`).join(', ')} };
-if (${checks ?? true}) { cb(path, captures); }`;
+if (${checks ?? true}) { cb.call(state, path, state, captures); }`;
 
   // eslint-disable-next-line @typescript-eslint/no-implied-eval
-  const match = Function('path', 'node', 'cb', code) as (
+  const match = Function('path', 'state', 'cb', code) as (
     path: NodePath<T>,
-    node: T,
-    cb: (path: NodePath<T>, captures: object) => void,
+    state: unknown,
+    cb: VisitNodeFunction<unknown, T>,
   ) => void;
 
-  return {
+  return <S>(cb: VisitNodeFunction<S, T>) => ({
     [schema.type]: {
-      [phase](path: NodePath<T>) {
-        match(path, path.node, cb);
+      [phase](path: NodePath<T>, state: S) {
+        match(path, state, cb as never);
       },
     },
-  };
+  });
 }
 
+export type VisitNodeFunction<S, T extends t.Node> = (
+  this: S,
+  path: NodePath<T>,
+  state: S,
+  captures: object,
+) => void;
+
 type CompileFunction = (
   schema: never,
   input: string,

packages/matchers/test/visitor.test.ts

@@ -5,12 +5,19 @@ import * as m from '../src';
 
 test('visitor', () => {
   const ast = t.program([t.emptyStatement(), t.returnStatement()]);
-  const cb = vi.fn((path: NodePath<t.ReturnStatement>, captures: object) => {
+  const cb = vi.fn(function (
+    this: undefined,
+    path: NodePath<t.ReturnStatement>,
+    state: unknown,
+    captures: object,
+  ) {
     expect(path.type).toBe('ReturnStatement');
+    expect(this).toBe(state);
+    expect(this).toBeUndefined();
     expect(captures).toEqual({});
   });
-  const visitor = m.compileVisitor(m.returnStatement(), cb);
-  traverse(ast, visitor);
+  const visitor = m.compileVisitor(m.returnStatement());
+  traverse(ast, visitor(cb));
 
   expect(cb).toHaveBeenCalledOnce();
 });

packages/webcrack/package.json

@@ -74,6 +74,7 @@
     "@types/debug": "^4.1.12",
     "@types/node": "^22.13.16",
     "@webcrack/eslint-config": "workspace:*",
+    "@webcrack/matchers": "workspace:*",
     "@webcrack/typescript-config": "workspace:*",
     "esbuild": "^0.25.2",
     "typescript": "^5.8.2"

packages/webcrack/src/unminify/test/void-to-undefined.test.ts

@@ -6,6 +6,8 @@ const expectJS = testTransform(voidToUndefined);
 
 test('void 0', () => expectJS('void 0').toMatchInlineSnapshot('undefined;'));
 
+test('void 1', () => expectJS('void 1').toMatchInlineSnapshot('undefined;'));
+
 test('ignore when undefined is declared in scope', () =>
   expectJS('let undefined = 1; { void 0; }').toMatchInlineSnapshot(`
     let undefined = 1;

packages/webcrack/src/unminify/transforms/void-to-undefined.ts

@@ -1,25 +1,18 @@
 import * as t from '@babel/types';
-import * as m from '@codemod/matchers';
+import * as m from '@webcrack/matchers';
 import type { Transform } from '../../ast-utils';
 
+const visitor = m.compileVisitor(m.unaryExpression('void', m.numericLiteral()));
+
 export default {
   name: 'void-to-undefined',
   tags: ['safe'],
   scope: true,
-  visitor: () => {
-    const matcher = m.unaryExpression('void', m.numericLiteral(0));
-    return {
-      UnaryExpression: {
-        exit(path) {
-          if (
-            matcher.match(path.node) &&
-            !path.scope.hasBinding('undefined', { noGlobals: true })
-          ) {
-            path.replaceWith(t.identifier('undefined'));
-            this.changes++;
-          }
-        },
-      },
-    };
-  },
+  visitor: () =>
+    visitor((path, state) => {
+      if (!path.scope.hasBinding('undefined', { noGlobals: true })) {
+        path.replaceWith(t.identifier('undefined'));
+        state.changes++;
+      }
+    }),
 } satisfies Transform;