ephemeris_release/adapters/cargo/

workspace.rs

//! Cargo's resolved workspace model and the source locations needed to edit it.

mod edit;

use std::collections::{BTreeMap, BTreeSet};
use std::ffi::OsStr;
use std::path::{Path, PathBuf};
use std::process::{Command, ExitStatus};
use std::{fmt, fs, io};

use cargo_platform::Platform;
use ephemeris_files::RepositoryRoot;
use facet::Facet;
use toml_edit::{DocumentMut, Item, Value};

use super::version_groups::VersionGroups;

/// A Cargo workspace discovery, planning, or edit failure.
#[derive(Debug, thiserror::Error)]
pub(crate) enum WorkspaceError {
    /// A workspace file cannot be read.
    #[error("cannot read {path}")]
    Read {
        /// The file.
        path: PathBuf,
        /// Why reading failed.
        source: io::Error,
    },
    /// A manifest is not valid TOML.
    #[error("invalid Cargo manifest {path}")]
    Manifest {
        /// The manifest.
        path: PathBuf,
        /// The parse failure.
        source: toml_edit::TomlError,
    },
    /// `cargo metadata` lists no workspace members.
    #[error("workspace has no members")]
    NoMembers,
    /// `cargo metadata` could not be started.
    #[error("cannot run cargo metadata")]
    MetadataSpawn(#[source] io::Error),
    /// `cargo metadata` failed.
    #[error("cargo metadata exited with {status}: {stderr}")]
    MetadataFailed {
        /// The exit status.
        status: ExitStatus,
        /// The trimmed standard error output.
        stderr: String,
    },
    /// `cargo metadata` printed output that does not decode.
    #[error("cannot decode cargo metadata")]
    MetadataDecode(#[source] Box<facet_json::DeserializeError>),
    /// Two workspace members share a package name.
    #[error("duplicate release unit `{0}`")]
    Duplicate(String),
    /// A proposal names a package outside the workspace.
    #[error("unknown release unit `{0}`")]
    UnknownUnit(String),
    /// A member manifest path has no parent directory.
    #[error("manifest {} has no parent directory", .0.display())]
    NoManifestDirectory(PathBuf),
    /// A member manifest was not parsed along with the workspace.
    #[error("manifest {} was not loaded", .0.display())]
    ManifestNotLoaded(PathBuf),
    /// A member manifest has no `[package]` table.
    #[error("manifest of release unit `{0}` has no package table")]
    NoPackageTable(String),
    /// A member's version is neither literal nor inherited from the workspace.
    #[error("release unit `{0}` has no supported package version source")]
    MissingVersionSource(String),
    /// A version is not strict semver.
    #[error("invalid version `{version}`")]
    InvalidVersion {
        /// The rejected text.
        version: String,
        /// The parse failure.
        #[source]
        source: semver::Error,
    },
    /// A proposal covers only part of a shared version group.
    #[error("shared version source {version_source} has unconfigured members: {missing:?}")]
    IncompleteVersionGroup {
        /// Where the group's version is set.
        version_source: VersionSource,
        /// Members the proposal leaves out.
        missing: Vec<String>,
    },
    /// A shared version group received different targets.
    #[error("shared version source {version_source} has conflicting targets for {members:?}")]
    ConflictingVersionGroup {
        /// Where the group's version is set.
        version_source: VersionSource,
        /// The members with conflicting targets.
        members: Vec<String>,
    },
    /// A shared dependency entry would change for packages outside the
    /// proposal.
    #[error("cannot update {dependency}: proposed release omits dependent packages {missing:?}")]
    UnselectedDependencyConsumers {
        /// The proposed package.
        dependency: String,
        /// Consumers of the shared entry that are not proposed.
        missing: Vec<String>,
    },
    /// A dependency requirement is not a valid semver requirement.
    #[error("invalid requirement {requirement:?} on {dependency} in {consumer}")]
    InvalidRequirement {
        /// The package holding the requirement.
        consumer: String,
        /// The required package.
        dependency: String,
        /// The requirement as written.
        requirement: String,
        /// The parse failure.
        #[source]
        source: semver::Error,
    },
    /// A requirement is too complex to rewrite safely.
    #[error(
        "cannot safely update {dependency} for {consumer}: requirement {requirement:?} does not \
         accept {version}"
    )]
    UnsupportedDependencyRequirement {
        /// The package holding the requirement.
        consumer: String,
        /// The proposed package.
        dependency: String,
        /// The requirement as written.
        requirement: String,
        /// The proposed version.
        version: String,
    },
    /// No manifest entry matches a dependency that `cargo metadata` reports.
    #[error("cannot locate local dependency source for {dependency} used by {consumer}")]
    MissingDependencySource {
        /// The package holding the dependency.
        consumer: String,
        /// The dependency.
        dependency: String,
    },
    /// A file changed between planning and applying.
    #[error("release plan is stale for {path}; refresh before applying")]
    Stale {
        /// The changed file.
        path: PathBuf,
    },
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct Member {
    pub(crate) name: String,
    pub(crate) path: PathBuf,
    pub(crate) version: String,
    pub(crate) publishable: bool,
    pub(crate) dependencies: Vec<String>,
}

/// The manifest entry that sets a package version.
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub(crate) enum VersionSource {
    /// `[package].version` in this member manifest.
    Member(PathBuf),
    /// `[workspace.package].version` in this root manifest.
    Workspace(PathBuf),
}

#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct DependencySlot {
    manifest: PathBuf,
    table_path: Vec<String>,
    alias: String,
}

#[derive(Clone, Debug)]
struct DependencyUse {
    consumer: String,
    dependency: String,
    slot: DependencySlot,
    requirement: Option<String>,
    kind: Option<String>,
}

/// One member dependency as `cargo metadata` resolved it, to be located in
/// the manifests.
struct Declaration<'a> {
    root_manifest: &'a Path,
    root: &'a DocumentMut,
    manifest: &'a Path,
    consumer: &'a str,
    dependency: &'a str,
    alias: &'a str,
    path: &'a Path,
    kind: Option<&'a str>,
}

#[derive(Clone, Debug)]
struct Package {
    unit: Member,
    source: VersionSource,
    dependencies: Vec<DependencyUse>,
}

struct WorkspaceSources {
    root_source: String,
    members: Vec<MetadataPackage>,
    documents: BTreeMap<PathBuf, DocumentMut>,
    snapshots: BTreeMap<PathBuf, String>,
}

#[derive(Debug)]
pub(crate) struct Workspace {
    root: RepositoryRoot,
    packages: Vec<Package>,
    version_groups: VersionGroups,
    snapshots: BTreeMap<PathBuf, String>,
}

#[derive(Clone, Debug, Eq, Facet, PartialEq)]
struct Metadata {
    packages: Vec<MetadataPackage>,
    workspace_members: Vec<String>,
}

#[derive(Clone, Debug, Eq, Facet, PartialEq)]
struct MetadataPackage {
    id: String,
    name: String,
    version: String,
    manifest_path: String,
    publish: Option<Vec<String>>,
    dependencies: Vec<MetadataDependency>,
}

#[derive(Clone, Debug, Eq, Facet, PartialEq)]
struct MetadataDependency {
    name: String,
    req: String,
    path: Option<String>,
    rename: Option<String>,
    kind: Option<String>,
    target: Option<String>,
}

impl DependencyUse {
    fn kind_for_ordering(&self) -> bool {
        self.kind.as_deref() != Some("dev")
    }
}

impl Declaration<'_> {
    fn missing_source(&self) -> WorkspaceError {
        WorkspaceError::MissingDependencySource {
            consumer: self.consumer.to_owned(),
            dependency: self.dependency.to_owned(),
        }
    }

    /// The use declared by `item` at `table_path`, following workspace
    /// inheritance to the entry that holds the requirement.
    fn dependency_use(
        &self,
        table_path: Vec<String>,
        item: &Item,
    ) -> Result<DependencyUse, WorkspaceError> {
        let inherited = item
            .as_table_like()
            .and_then(|table| table.get("workspace"))
            .and_then(Item::as_bool)
            == Some(true);
        let (source_manifest, source_table_path, effective) = if inherited {
            (
                self.root_manifest,
                vec!["workspace".to_owned(), "dependencies".to_owned()],
                inherited_dependency(self.root, self.alias).ok_or_else(|| self.missing_source())?,
            )
        } else {
            (self.manifest, table_path, item)
        };
        let effective_table = effective.as_table_like();
        let effective_name = effective_table
            .and_then(|table| table.get("package"))
            .and_then(Item::as_str)
            .unwrap_or(self.alias);
        let effective_path = effective_table
            .and_then(|table| table.get("path"))
            .and_then(Item::as_str)
            .map(|relative| {
                let path = source_manifest
                    .parent()
                    .unwrap_or_else(|| Path::new("."))
                    .join(relative);
                fs::canonicalize(&path).map_err(|source| WorkspaceError::Read { path, source })
            })
            .transpose()?;
        if effective_name != self.dependency || effective_path.as_deref() != Some(self.path) {
            return Err(WorkspaceError::Stale {
                path: self.manifest.to_path_buf(),
            });
        }
        Ok(DependencyUse {
            consumer: self.consumer.to_owned(),
            dependency: self.dependency.to_owned(),
            slot: DependencySlot {
                manifest: source_manifest.to_path_buf(),
                table_path: source_table_path,
                alias: self.alias.to_owned(),
            },
            requirement: effective_table
                .and_then(|table| table.get("version"))
                .and_then(Item::as_str)
                .map(str::to_owned),
            kind: self.kind.map(str::to_owned),
        })
    }
}

impl Workspace {
    pub(crate) fn load(root: &RepositoryRoot) -> Result<Self, WorkspaceError> {
        let root_manifest = root.as_path().join("Cargo.toml");
        let sources = snapshot_workspace(&root_manifest, root.as_path())?;
        let root_document = parse_manifest(&root_manifest, &sources.root_source)?;
        let mut packages = assemble_packages(&root_manifest, &root_document, &sources)?;
        packages.sort_by(|left, right| left.unit.name.cmp(&right.unit.name));
        let version_groups = VersionGroups::new(
            packages
                .iter()
                .map(|package| (package.source.clone(), package.unit.name.clone())),
        );
        Ok(Self {
            root: root.clone(),
            packages,
            version_groups,
            snapshots: sources.snapshots,
        })
    }

    pub(crate) fn units(&self) -> Vec<Member> {
        self.packages
            .iter()
            .map(|package| package.unit.clone())
            .collect()
    }

    /// This workspace with the packages `names` maps renamed to the release
    /// unit IDs they map to, so that every query uses unit IDs.
    pub(crate) fn renamed(&self, names: &BTreeMap<String, String>) -> Self {
        let rename = |name: &String| names.get(name).unwrap_or(name).clone();
        let packages: Vec<_> = self
            .packages
            .iter()
            .map(|package| Package {
                unit: Member {
                    name: rename(&package.unit.name),
                    dependencies: package.unit.dependencies.iter().map(rename).collect(),
                    ..package.unit.clone()
                },
                source: package.source.clone(),
                dependencies: package
                    .dependencies
                    .iter()
                    .map(|usage| DependencyUse {
                        consumer: rename(&usage.consumer),
                        dependency: rename(&usage.dependency),
                        ..usage.clone()
                    })
                    .collect(),
            })
            .collect();
        let version_groups = VersionGroups::new(
            packages
                .iter()
                .map(|package| (package.source.clone(), package.unit.name.clone())),
        );
        Self {
            root: self.root.clone(),
            packages,
            version_groups,
            snapshots: self.snapshots.clone(),
        }
    }

    pub(crate) const fn version_groups(&self) -> &VersionGroups {
        &self.version_groups
    }

    pub(crate) const fn snapshots(&self) -> &BTreeMap<PathBuf, String> {
        &self.snapshots
    }

    pub(crate) const fn root(&self) -> &RepositoryRoot {
        &self.root
    }
}

impl fmt::Display for VersionSource {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Member(path) => write!(f, "{} [package].version", path.display()),
            Self::Workspace(path) => write!(f, "{} [workspace.package].version", path.display()),
        }
    }
}

fn snapshot_workspace(
    root_manifest: &Path,
    root: &Path,
) -> Result<WorkspaceSources, WorkspaceError> {
    let root_source = read(root_manifest)?;
    let metadata = read_metadata(root_manifest, root)?;
    let members = metadata_members(&metadata);
    if members.is_empty() {
        return Err(WorkspaceError::NoMembers);
    }
    let mut snapshots = BTreeMap::from([(root_manifest.to_path_buf(), root_source.clone())]);
    let mut documents = BTreeMap::new();
    for package in &members {
        let manifest = PathBuf::from(&package.manifest_path);
        let contents = if let Some(contents) = snapshots.get(&manifest) {
            contents.clone()
        } else {
            let contents = read(&manifest)?;
            snapshots.insert(manifest.clone(), contents.clone());
            contents
        };
        documents.insert(manifest.clone(), parse_manifest(&manifest, &contents)?);
    }
    let stable_metadata = read_metadata(root_manifest, root)?;
    for (path, snapshot) in &snapshots {
        if read(path)? != *snapshot {
            return Err(WorkspaceError::Stale { path: path.clone() });
        }
    }
    if let Some(path) = metadata_difference(&metadata, &stable_metadata, root_manifest) {
        return Err(WorkspaceError::Stale { path });
    }
    Ok(WorkspaceSources {
        root_source,
        members,
        documents,
        snapshots,
    })
}

fn assemble_packages(
    root_manifest: &Path,
    root_document: &DocumentMut,
    sources: &WorkspaceSources,
) -> Result<Vec<Package>, WorkspaceError> {
    let member_paths: BTreeMap<_, _> = sources
        .members
        .iter()
        .map(|package| {
            let manifest = PathBuf::from(&package.manifest_path);
            let directory = manifest
                .parent()
                .ok_or_else(|| WorkspaceError::NoManifestDirectory(manifest.clone()))?;
            let directory = fs::canonicalize(directory).map_err(|source| WorkspaceError::Read {
                path: directory.to_path_buf(),
                source,
            })?;
            Ok((directory, (package.id.clone(), package.name.clone())))
        })
        .collect::<Result<_, WorkspaceError>>()?;
    let mut packages = Vec::with_capacity(sources.members.len());
    let mut names = BTreeSet::new();
    for metadata_package in &sources.members {
        if !names.insert(metadata_package.name.clone()) {
            return Err(WorkspaceError::Duplicate(metadata_package.name.clone()));
        }
        let manifest = PathBuf::from(&metadata_package.manifest_path);
        let document = sources
            .documents
            .get(&manifest)
            .ok_or_else(|| WorkspaceError::ManifestNotLoaded(manifest.clone()))?;
        let source = version_source(
            root_manifest,
            root_document,
            &manifest,
            document,
            &metadata_package.name,
            &metadata_package.version,
        )?;
        let dependencies = dependency_uses(
            root_manifest,
            root_document,
            &manifest,
            document,
            metadata_package,
            &member_paths,
        )?;
        let mut ordering_dependencies: Vec<_> = dependencies
            .iter()
            .filter(|dependency| dependency.kind_for_ordering())
            .map(|dependency| dependency.dependency.clone())
            .collect();
        ordering_dependencies.sort();
        ordering_dependencies.dedup();
        packages.push(Package {
            unit: Member {
                name: metadata_package.name.clone(),
                path: manifest
                    .parent()
                    .ok_or_else(|| WorkspaceError::NoManifestDirectory(manifest.clone()))?
                    .to_path_buf(),
                version: metadata_package.version.clone(),
                publishable: metadata_package
                    .publish
                    .as_ref()
                    .is_none_or(|registries| !registries.is_empty()),
                dependencies: ordering_dependencies,
            },
            source,
            dependencies,
        });
    }
    Ok(packages)
}

fn version_source(
    root_manifest: &Path,
    root: &DocumentMut,
    manifest: &Path,
    package_document: &DocumentMut,
    name: &str,
    metadata_version: &str,
) -> Result<VersionSource, WorkspaceError> {
    let package = package_document
        .get("package")
        .and_then(Item::as_table_like)
        .ok_or_else(|| WorkspaceError::NoPackageTable(name.to_owned()))?;
    match package.get("version") {
        Some(Item::Value(Value::String(version))) => {
            if version.value() != metadata_version {
                return Err(WorkspaceError::Stale {
                    path: manifest.to_path_buf(),
                });
            }
            Ok(VersionSource::Member(manifest.to_path_buf()))
        }
        Some(item)
            if item
                .as_table_like()
                .and_then(|table| table.get("workspace"))
                .and_then(Item::as_bool)
                == Some(true) =>
        {
            let version = root
                .get("workspace")
                .and_then(Item::as_table_like)
                .and_then(|table| table.get("package"))
                .and_then(Item::as_table_like)
                .and_then(|table| table.get("version"))
                .and_then(Item::as_str)
                .ok_or_else(|| WorkspaceError::MissingVersionSource(name.to_owned()))?;
            if version != metadata_version {
                return Err(WorkspaceError::Stale {
                    path: root_manifest.to_path_buf(),
                });
            }
            Ok(VersionSource::Workspace(root_manifest.to_path_buf()))
        }
        _ => Err(WorkspaceError::MissingVersionSource(name.to_owned())),
    }
}

fn dependency_uses(
    root_manifest: &Path,
    root: &DocumentMut,
    manifest: &Path,
    package_document: &DocumentMut,
    package: &MetadataPackage,
    members: &BTreeMap<PathBuf, (String, String)>,
) -> Result<Vec<DependencyUse>, WorkspaceError> {
    let mut result = Vec::new();
    let mut seen = BTreeSet::new();
    for dependency in &package.dependencies {
        for usage in dependency_uses_for_dependency(
            root_manifest,
            root,
            manifest,
            package_document,
            package,
            members,
            dependency,
        )? {
            if seen.insert((
                usage.slot.clone(),
                usage.kind.clone(),
                dependency.target.clone(),
            )) {
                result.push(usage);
            }
        }
    }
    Ok(result)
}

fn dependency_uses_for_dependency(
    root_manifest: &Path,
    root: &DocumentMut,
    manifest: &Path,
    package_document: &DocumentMut,
    package: &MetadataPackage,
    members: &BTreeMap<PathBuf, (String, String)>,
    dependency: &MetadataDependency,
) -> Result<Vec<DependencyUse>, WorkspaceError> {
    let Some(path) = &dependency.path else {
        return Ok(Vec::new());
    };
    let path = fs::canonicalize(path).map_err(|source| WorkspaceError::Read {
        path: PathBuf::from(path),
        source,
    })?;
    let Some((_, target_name)) = members.get(&path) else {
        return Ok(Vec::new());
    };
    let Some(section) = dependency_section(dependency.kind.as_deref()) else {
        return Ok(Vec::new());
    };
    let declaration = Declaration {
        root_manifest,
        root,
        manifest,
        consumer: &package.name,
        dependency: target_name,
        alias: dependency.rename.as_deref().unwrap_or(&dependency.name),
        path: &path,
        kind: dependency.kind.as_deref(),
    };
    let matching: Vec<_> = dependency_items(package_document, declaration.alias)
        .into_iter()
        .filter(|(table_path, _)| {
            declares_section(table_path, section, dependency.target.as_deref())
        })
        .collect();
    if matching.is_empty() {
        return Err(declaration.missing_source());
    }
    matching
        .into_iter()
        .map(|(table_path, item)| declaration.dependency_use(table_path, item))
        .collect()
}

/// The manifest section of a `cargo metadata` dependency kind, or `None` for
/// a kind releases do not edit.
fn dependency_section(kind: Option<&str>) -> Option<&'static str> {
    match kind {
        None | Some("normal") => Some("dependencies"),
        Some("dev") => Some("dev-dependencies"),
        Some("build") => Some("build-dependencies"),
        Some(_) => None,
    }
}

/// Whether `table_path` is `section`, either top-level or under the
/// `target` table for `platform`.
fn declares_section(table_path: &[String], section: &str, platform: Option<&str>) -> bool {
    if table_path.last().is_none_or(|value| value != section) {
        return false;
    }
    platform.map_or(table_path.len() == 1, |target| {
        table_path.len() == 3
            && table_path
                .get(1)
                .is_some_and(|candidate| same_platform(candidate, target))
    })
}

fn inherited_dependency<'a>(root: &'a DocumentMut, alias: &str) -> Option<&'a Item> {
    root.get("workspace")
        .and_then(Item::as_table_like)
        .and_then(|table| table.get("dependencies"))
        .and_then(Item::as_table_like)
        .and_then(|table| table.get(alias))
}

fn same_platform(source: &str, metadata: &str) -> bool {
    match (source.parse::<Platform>(), metadata.parse::<Platform>()) {
        (Ok(source), Ok(metadata)) => source == metadata,
        _ => false,
    }
}

fn dependency_items<'a>(document: &'a DocumentMut, alias: &str) -> Vec<(Vec<String>, &'a Item)> {
    let sections = ["dependencies", "dev-dependencies", "build-dependencies"];
    let mut result = Vec::new();
    for section in sections {
        if let Some(item) = document
            .get(section)
            .and_then(Item::as_table_like)
            .and_then(|table| table.get(alias))
        {
            result.push((vec![section.to_owned()], item));
        }
    }
    if let Some(targets) = document.get("target").and_then(Item::as_table_like) {
        for (target, target_item) in targets.iter() {
            let Some(target_table) = target_item.as_table_like() else {
                continue;
            };
            for section in sections {
                if let Some(item) = target_table
                    .get(section)
                    .and_then(Item::as_table_like)
                    .and_then(|table| table.get(alias))
                {
                    result.push((
                        vec!["target".to_owned(), target.to_owned(), section.to_owned()],
                        item,
                    ));
                }
            }
        }
    }
    result
}

fn parse_manifest(path: &Path, contents: &str) -> Result<DocumentMut, WorkspaceError> {
    contents
        .parse::<DocumentMut>()
        .map_err(|source| WorkspaceError::Manifest {
            path: path.to_path_buf(),
            source,
        })
}

fn read(path: &Path) -> Result<String, WorkspaceError> {
    fs::read_to_string(path).map_err(|source| WorkspaceError::Read {
        path: path.to_path_buf(),
        source,
    })
}

/// Run `cargo metadata` in `directory` and return its standard output.
pub(super) fn run_metadata(
    directory: &Path,
    args: impl IntoIterator<Item = impl AsRef<OsStr>>,
) -> Result<Vec<u8>, WorkspaceError> {
    let output = Command::new("cargo")
        .arg("metadata")
        .args(args)
        .current_dir(directory)
        .output()
        .map_err(WorkspaceError::MetadataSpawn)?;
    if output.status.success() {
        Ok(output.stdout)
    } else {
        Err(WorkspaceError::MetadataFailed {
            status: output.status,
            stderr: String::from_utf8_lossy(&output.stderr).trim().to_owned(),
        })
    }
}

fn read_metadata(root_manifest: &Path, root: &Path) -> Result<Metadata, WorkspaceError> {
    let stdout = run_metadata(
        root,
        [
            OsStr::new("--no-deps"),
            OsStr::new("--locked"),
            OsStr::new("--offline"),
            OsStr::new("--format-version=1"),
            OsStr::new("--manifest-path"),
            root_manifest.as_os_str(),
        ],
    )?;
    facet_json::from_str(&String::from_utf8_lossy(&stdout))
        .map_err(|error| WorkspaceError::MetadataDecode(Box::new(error)))
}

fn metadata_members(metadata: &Metadata) -> Vec<MetadataPackage> {
    let member_ids: BTreeSet<_> = metadata.workspace_members.iter().collect();
    let mut packages: Vec<_> = metadata
        .packages
        .iter()
        .filter(|package| member_ids.contains(&package.id))
        .cloned()
        .collect();
    packages.sort_by(|left, right| left.manifest_path.cmp(&right.manifest_path));
    for package in &mut packages {
        package.dependencies.sort_by(|left, right| {
            (
                &left.name,
                &left.req,
                &left.path,
                &left.rename,
                &left.kind,
                &left.target,
            )
                .cmp(&(
                    &right.name,
                    &right.req,
                    &right.path,
                    &right.rename,
                    &right.kind,
                    &right.target,
                ))
        });
    }
    packages
}

fn metadata_difference(
    before: &Metadata,
    after: &Metadata,
    root_manifest: &Path,
) -> Option<PathBuf> {
    let left_members: BTreeSet<_> = before.workspace_members.iter().collect();
    let right_members: BTreeSet<_> = after.workspace_members.iter().collect();
    if left_members != right_members {
        return Some(root_manifest.to_path_buf());
    }
    let left = metadata_members(before);
    let right = metadata_members(after);
    if left == right {
        return None;
    }
    let right_by_manifest: BTreeMap<_, _> = right
        .iter()
        .map(|package| (&package.manifest_path, package))
        .collect();
    left.iter()
        .find(|package| right_by_manifest.get(&package.manifest_path) != Some(package))
        .map(|package| PathBuf::from(&package.manifest_path))
        .or_else(|| Some(root_manifest.to_path_buf()))
}