fix: include a virtual workspace's root Cargo.toml in the cache key (#395)

In a virtual workspace the root `Cargo.toml` is not a package, so the cache key hashed only the
members' manifests and left out the root's `[profile]`, `[patch]` and `[workspace.dependencies]`
(#268). Editing one of those, such as a `[profile.dev]` opt-level, kept the same key: every run
restored the stale cache as an exact hit, rebuilt what the edit invalidated, and saved nothing, so
the rebuild repeated on every run until something else changed the key.

This change hashes the root manifest of the workspace `cargo metadata` reports, along with its
members' manifests. It ignores `workspace.package.version` and the paths and versions of path
dependencies in `[workspace.dependencies]`, as it already does for members, so a release version
bump still keeps the key. It also reads `Cargo.lock` from that root, so a `workspaces` entry that
points at a member directory now hashes the lockfile that builds it. A workspace whose root is a
package keeps its key, and a virtual workspace gets a new one once.

src/config.ts

@@ -167,11 +167,17 @@ export class CacheConfig {
           )),
         );
 
-        const workspaceMembers = await workspace.getWorkspaceMembers(cmdFormat);
+        const { members, workspaceRoot } = await workspace.getWorkspaceMembers(cmdFormat);
 
-        const cargo_manifests = sort_and_uniq(workspaceMembers.map((member) => path.join(member.path, "Cargo.toml")));
+        const cargo_manifests = members.map((member) => path.join(member.path, "Cargo.toml"));
+        // A virtual workspace's root manifest belongs to no member, yet its `[profile]` and `[patch]`
+        // sections apply to every member.
+        const root_manifest = path.join(workspaceRoot, "Cargo.toml");
+        if (await exists(root_manifest)) {
+          cargo_manifests.push(root_manifest);
+        }
 
-        for (const cargo_manifest of cargo_manifests) {
+        for (const cargo_manifest of sort_and_uniq(cargo_manifests)) {
           try {
             const content = await fs.readFile(cargo_manifest, { encoding: "utf8" });
             // Use any since TomlPrimitive is not exposed
@@ -184,12 +190,17 @@ export class CacheConfig {
               }
             }
 
-            for (const prefix of ["", "build-", "dev-"]) {
-              const section_name = `${prefix}dependencies`;
-              if (!(section_name in parsed)) {
+            const workspace_table = parsed.workspace ?? {};
+            if ("package" in workspace_table && "version" in workspace_table.package) {
+              workspace_table.package["version"] = "0.0.0";
+            }
+
+            const dependency_tables = ["", "build-", "dev-"].map((prefix) => parsed[`${prefix}dependencies`]);
+            dependency_tables.push(workspace_table.dependencies);
+            for (const deps of dependency_tables) {
+              if (deps === undefined) {
                 continue;
               }
-              const deps = parsed[section_name];
 
               for (const key of Object.keys(deps)) {
                 const dep = deps[key];
@@ -217,7 +228,7 @@ export class CacheConfig {
           }
         }
 
-        const cargo_lock = path.join(workspace.root, "Cargo.lock");
+        const cargo_lock = path.join(workspaceRoot, "Cargo.lock");
         if (await exists(cargo_lock)) {
           try {
             const content = await fs.readFile(cargo_lock, { encoding: "utf8" });

src/save.ts

@@ -41,8 +41,8 @@ async function run() {
     for (const workspace of config.workspaces) {
       const packages = await workspace.getPackagesOutsideWorkspaceRoot(config.cmdFormat);
       if (workspaceCrates === "true") {
-        const wsMembers = await workspace.getWorkspaceMembers(config.cmdFormat);
-        packages.push(...wsMembers);
+        const { members } = await workspace.getWorkspaceMembers(config.cmdFormat);
+        packages.push(...members);
       }
       allPackages.push(...packages);
       try {

src/workspace.ts

@@ -15,9 +15,10 @@ export class Workspace {
     cmdFormat: string,
     filter: (p: Meta["packages"][0]) => boolean,
     extraArgs?: string,
-  ): Promise<Packages> {
+  ): Promise<{ packages: Packages; workspaceRoot: string }> {
     const cmd = "cargo metadata --all-features --format-version 1" + (extraArgs ? ` ${extraArgs}` : "");
     let packages: Packages = [];
+    let workspaceRoot = this.root;
     try {
       core.debug(`collecting metadata for "${this.root}"`);
       const meta: Meta = JSON.parse(
@@ -27,6 +28,7 @@ export class Workspace {
         }),
       );
       core.debug(`workspace "${this.root}" has ${meta.packages.length} packages`);
+      workspaceRoot = meta.workspace_root;
       for (const pkg of meta.packages.filter(filter)) {
         const targets = pkg.targets.filter((t) => t.kind.some((kind) => SAVE_TARGETS.has(kind))).map((t) => t.name);
         packages.push({ name: pkg.name, version: pkg.version, targets, path: path.dirname(pkg.manifest_path) });
@@ -34,15 +36,18 @@ export class Workspace {
     } catch (err) {
       console.error(err);
     }
-    return packages;
+    return { packages, workspaceRoot };
   }
 
   public async getPackagesOutsideWorkspaceRoot(cmdFormat: string): Promise<Packages> {
-    return await this.getPackages(cmdFormat, (pkg) => !pkg.manifest_path.startsWith(this.root));
+    const filter = (pkg: Meta["packages"][0]) => !pkg.manifest_path.startsWith(this.root);
+    return (await this.getPackages(cmdFormat, filter)).packages;
   }
 
-  public async getWorkspaceMembers(cmdFormat: string): Promise<Packages> {
-    return await this.getPackages(cmdFormat, (_) => true, "--no-deps");
+  /** The workspace's members, and the root directory of the cargo workspace they belong to. */
+  public async getWorkspaceMembers(cmdFormat: string): Promise<{ members: Packages; workspaceRoot: string }> {
+    const { packages, workspaceRoot } = await this.getPackages(cmdFormat, (_) => true, "--no-deps");
+    return { members: packages, workspaceRoot };
   }
 }
 
@@ -56,6 +61,7 @@ export interface PackageDefinition {
 export type Packages = Array<PackageDefinition>;
 
 interface Meta {
+  workspace_root: string;
   packages: Array<{
     name: string;
     version: string;