fn build_version_mapping_for_kind()

in crate_universe/src/resolver.rs [364:413]


    fn build_version_mapping_for_kind(
        kind: DependencyKind,
        merged_cargo_metadata: &Metadata,
        resolved_artifacts: &[CrateContext],
    ) -> BTreeMap<String, Version> {
        // Build the intersection of version requirements for all the member (i.e. toplevel) packages
        // of our workspace.
        let mut member_package_version_reqs: HashMap<String, Vec<VersionReq>> = Default::default();
        for package in &merged_cargo_metadata.packages {
            for dep in &package.dependencies {
                if dep.kind == kind {
                    let reqs = member_package_version_reqs
                        .entry(dep.name.clone())
                        .or_default();
                    if let Some(source) = &dep.source {
                        // If a git dependency is present, and doesn't specify any version requirements,
                        // treat it as something we're depending on but don't add an empty version requirement.
                        // Versions with pre-release tags do not match empty version requirements,
                        // so otherwise they will get filtered out by the version matching below,
                        // but we assume if you specifically added a git dep, you probably wanted it.
                        if source.starts_with("git+") && dep.req.comparators.is_empty() {
                            continue;
                        }
                    }
                    reqs.push(dep.req.clone());
                }
            }
        }

        let mut member_package_version_mapping = BTreeMap::new();
        for package in resolved_artifacts {
            // If the package name matches one of the member packages' direct dependencies, consider it
            // for the final version: insert it into the map if we didn't have one yet, take the highest
            // version so far if there was already one.
            if let Some(version_req) = member_package_version_reqs.get(&package.pkg_name) {
                if version_req
                    .iter()
                    .all(|req| req.matches(&package.pkg_version))
                {
                    let current_pkg_version = member_package_version_mapping
                        .entry(package.pkg_name.clone())
                        .or_insert_with(|| Version::new(0, 0, 0));
                    if *current_pkg_version < package.pkg_version {
                        *current_pkg_version = package.pkg_version.clone();
                    }
                }
            }
        }
        member_package_version_mapping
    }