feat(v8)!: synchronize Rust crates with major updates

components/git/v8.js

@@ -31,6 +31,10 @@ export function builder(yargs) {
           describe: 'Update dependencies concurrently',
           default: true,
         });
+        yargs.option('cargo', {
+          describe: 'The cargo binary that will be executed when updating the Rust crates',
+          default: 'cargo',
+        });
       }
     })
     .command({

docs/git-node.md

@@ -388,6 +388,7 @@ modifying your `PATH` environment variable).
 ### `git node v8 major`
 
 - Replaces `deps/v8` with a newer major version.
+- Synchronizes the manifest and vendored Rust crates in `deps/crates`.
 - Resets the embedder version number to `-node.0`.
 - Bumps `NODE_MODULE_VERSION` according to the [Node.js ABI version registry][].
 
@@ -399,6 +400,9 @@ Options:
 - `--no-version-bump`: Disable automatic bump of the `NODE_MODULE_VERSION`
   constant.
 
+- `--cargo=/path/to/cargo`: The Cargo binary that will be executed by the shell
+  when updating the Rust crates. Defaults to `cargo`.
+
 ### `git node v8 minor`
 
 Compare current V8 version with latest upstream of the same major. Applies a

lib/update-v8/common.js

@@ -1,7 +1,9 @@
+import assert from 'node:assert';
 import path from 'node:path';
 import { promises as fs } from 'node:fs';
 
 import { getNodeV8Version } from './util.js';
+import { forceRunAsync } from '../run.js';
 
 export function getV8Version(label) {
   return {
@@ -12,6 +14,27 @@ export function getV8Version(label) {
   };
 };
 
+export function checkCargoAvailable() {
+  return {
+    title: 'Check Cargo exists in environment',
+    task: async(ctx) => {
+      try {
+        const output = await forceRunAsync(ctx.cargo, ['--version'], {
+          ignoreFailure: false,
+          captureStdout: true,
+        });
+        assert(output.startsWith('cargo'));
+      } catch (cause) {
+        let error = 'Unable to determine cargo version.';
+        if (ctx.cargo === 'cargo') {
+          error += '\nYou may need to specify the path to your cargo binary with `--cargo`.';
+        }
+        throw new Error(error, { cause });
+      }
+    }
+  };
+}
+
 export async function checkCwd(ctx) {
   let isNode = false;
   try {

lib/update-v8/constants.js

@@ -154,6 +154,11 @@ export const v8Deps = [
     },
     since: 138
   },
+  {
+    name: 'rust',
+    repo: 'third_party/rust',
+    since: 139
+  },
   {
     name: 'llvm-libc',
     repo: 'third_party/llvm-libc/src',

lib/update-v8/index.js

@@ -1,16 +1,25 @@
 import { Listr } from 'listr2';
 
+import { checkCargoAvailable } from './common.js';
 import { checkOptions, doBackport } from './backport.js';
 import updateVersionNumbers from './updateVersionNumbers.js';
 import commitUpdate from './commitUpdate.js';
 import majorUpdate from './majorUpdate.js';
 import minorUpdate from './minorUpdate.js';
 import updateDeps from './deps.js';
+import updateCrates from './updateCrates.js';
 import updateV8Clone from './updateV8Clone.js';
 
 export function major(options) {
   const tasks = new Listr(
-    [updateV8Clone(), majorUpdate(), commitUpdate(), updateVersionNumbers()],
+    [
+      checkCargoAvailable(),
+      updateV8Clone(),
+      majorUpdate(),
+      commitUpdate(),
+      updateCrates(),
+      updateVersionNumbers()
+    ],
     getOptions(options)
   );
   return tasks.run(options);

lib/update-v8/updateCrates.js

@@ -0,0 +1,189 @@
+import semver from 'semver';
+import * as TOML from 'smol-toml';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+
+import { removeDirectory } from './util.js';
+import { forceRunAsync } from '../run.js';
+
+export default function updateCrates() {
+  return {
+    title: 'Update Rust crates',
+    skip: (ctx) => ctx.newVersion.majorMinor < 139,
+    task: (ctx, task) => {
+      return task.newListr([
+        enumerateTemporalDependencies(),
+        removeExistingCrates(),
+        vendorCrates(),
+        buildManifest(),
+        generateLockfile(),
+        updateGYP(),
+        commitChanges()
+      ]);
+    }
+  };
+}
+
+const chromiumCratesDir = 'deps/v8/third_party/rust/chromium_crates_io';
+const nodeCratesDir = 'deps/crates';
+
+function enumerateTemporalDependencies() {
+  return {
+    title: 'Enumerate Temporal dependency tree',
+    task: async(ctx) => {
+      const tree = await forceRunAsync(
+        ctx.cargo,
+        ['tree', '-Z', 'bindeps', '--package', 'temporal_capi', '--prefix', 'none'],
+        {
+          ignoreFailure: false,
+          captureStdout: true,
+          spawnArgs: { cwd: path.join(ctx.nodeDir, chromiumCratesDir) }
+        }
+      );
+      const crates = new Set();
+      for (const crate of tree.trimEnd().split('\n').sort()) {
+        const [name, version] = crate.split(' ', 2);
+        crates.add(`${name}@${version.substring(1)}`);
+      }
+      ctx.temporalCrates = crates;
+    },
+  };
+}
+
+function removeExistingCrates() {
+  return {
+    title: 'Remove existing crates',
+    task: (ctx) => removeDirectory(path.join(ctx.nodeDir, nodeCratesDir, 'vendor'))
+  };
+}
+
+// Note that the crates vendored in third_party/rust/chromium_crates_io already have any custom
+// Chromium patches applied by gnrt, so we don't need to worry about patching them ourselves.
+function vendorCrates() {
+  return {
+    title: 'Copy vendored crates',
+    task: async(ctx, task) => {
+      const chromiumVendor = path.join(ctx.nodeDir, chromiumCratesDir, 'vendor');
+      const nodeVendor = path.join(ctx.nodeDir, nodeCratesDir, 'vendor');
+      await fs.mkdir(nodeVendor);
+
+      const subtasks = [];
+      const rustVersions = [];
+      for (const dir of await fs.readdir(chromiumVendor)) {
+        const crate = await getCrateInfo(dir);
+        if (!crate || !ctx.temporalCrates.has(`${crate.name}@${crate.version}`)) continue;
+        if (crate.name === 'temporal_capi') {
+          ctx.temporalCAPIDirectory = dir;
+        }
+        if (crate['rust-version']) {
+          rustVersions.push(crate['rust-version']);
+        }
+        subtasks.push({
+          title: dir,
+          task: async(ctx) => {
+            await fs.cp(
+              path.join(chromiumVendor, dir),
+              path.join(nodeVendor, dir),
+              { recursive: true }
+            );
+          }
+        });
+      }
+
+      if (rustVersions.length) {
+        const msrv = rustVersions.map(semver.coerce).reduce((a, b) => (semver.gt(a, b) ? a : b));
+        ctx.msrv = `${msrv.major}.${msrv.minor}`;
+      }
+
+      return task.newListr(subtasks, { concurrent: ctx.concurrent });
+
+      async function getCrateInfo(crate) {
+        try {
+          const manifest = TOML.parse(
+            await fs.readFile(path.join(chromiumVendor, crate, 'Cargo.toml'), 'utf8')
+          );
+          return manifest.package;
+        } catch {
+          return null;
+        }
+      }
+    }
+  };
+}
+
+function buildManifest() {
+  return {
+    title: 'Build new manifest',
+    task: async(ctx) => {
+      const sourceManifest = TOML.parse(
+        await fs.readFile(path.join(ctx.nodeDir, chromiumCratesDir, 'Cargo.toml'), 'utf8')
+      );
+
+      const header =
+      '# This manifest is generated by node-core-utils. Do not modify it directly.\n\n';
+      const manifest = {
+        package: {
+          edition: sourceManifest.package.edition,
+          name: 'node_crates',
+          version: `${ctx.newVersion.major}.${ctx.newVersion.minor}.${ctx.newVersion.build}`
+        },
+        lib: {
+          'crate-type': ['staticlib']
+        },
+        dependencies: {}
+      };
+      if (ctx.msrv) {
+        manifest.package['rust-version'] = ctx.msrv;
+      }
+      for (const crate of ctx.temporalCrates) {
+        const name = crate.split('@', 1)[0];
+        if (name === 'temporal_capi' || typeof sourceManifest.dependencies[name] === 'object') {
+          manifest.dependencies[name] = sourceManifest.dependencies[name];
+        }
+      }
+
+      const cargoTOML = header + TOML.stringify(manifest);
+      await fs.writeFile(path.join(ctx.nodeDir, nodeCratesDir, 'Cargo.toml'), cargoTOML);
+    },
+  };
+}
+
+function generateLockfile() {
+  return {
+    title: 'Generate lockfile',
+    task: (ctx) => forceRunAsync(ctx.cargo, ['generate-lockfile', '--quiet', '--offline'], {
+      ignoreFailure: false,
+      spawnArgs: { cwd: path.join(ctx.nodeDir, nodeCratesDir) }
+    })
+  };
+}
+
+function updateGYP() {
+  return {
+    title: 'Update include path in crates.gyp',
+    task: async(ctx, task) => {
+      const filePath = path.join(ctx.nodeDir, nodeCratesDir, 'crates.gyp');
+      let gyp = await fs.readFile(filePath, 'utf8');
+      const [definition, currentDirectory] = gyp.match(/'temporal_capi_dir': '(.+?)'/);
+      if (currentDirectory === ctx.temporalCAPIDirectory) {
+        task.skip('crates.gyp already up-to-date');
+        return;
+      }
+      gyp = gyp.replace(definition, `'temporal_capi_dir': '${ctx.temporalCAPIDirectory}'`);
+      await fs.writeFile(filePath, gyp);
+    }
+  };
+}
+
+function commitChanges() {
+  return {
+    title: 'Commit changes',
+    task: async(ctx) => {
+      await ctx.execGitNode('add', ['--force', 'deps/crates']);
+      await ctx.execGitNode(
+        'commit',
+        ['-m', `deps: update Rust crates for V8 ${ctx.newVersion}`]
+      );
+    }
+  };
+}

package.json

@@ -55,6 +55,7 @@
     "ora": "^9.0.0",
     "replace-in-file": "^8.3.0",
     "semver": "^7.7.1",
+    "smol-toml": "^1.7.0",
     "undici": "^8.3.0",
     "which": "^7.0.0",
     "yargs": "^18.0.0"