fn add_recursive_package_query_deps()

in focus/internals/src/lib/target_resolver/incremental_bazel_resolver.rs [337:399]

• 54 lines of code
• 4 McCabe index (conditional complexity)

    fn add_recursive_package_query_deps(
        &self,
        recursive_package_queries: BTreeSet<&Label>,
        immediate_deps: &BTreeMap<DependencyKey, DependencyValue>,
    ) -> BTreeMap<DependencyKey, DependencyValue> {
        let mut deps: BTreeMap<Label, BTreeSet<DependencyKey>> = BTreeMap::new();
        for containing_target in recursive_package_queries {
            debug_assert_eq!(containing_target.target_name, TargetName::Ellipsis);

            // Given the label `//foo/...`, try to find targets like
            // `//foo/bar:baz`, for which `//foo` is a prefix.
            for dep_key in immediate_deps.keys() {
                match dep_key {
                    DependencyKey::BazelPackage(Label {
                        external_repository: None,
                        path_components,
                        target_name,
                    })
                    | DependencyKey::BazelBuildFile(Label {
                        external_repository: None,
                        path_components,
                        target_name,
                    }) => {
                        debug_assert_ne!(target_name, &TargetName::Ellipsis);

                        if path_components.starts_with(&containing_target.path_components) {
                            deps.entry((*containing_target).clone())
                                .or_default()
                                .insert(dep_key.clone());
                        }
                    }

                    DependencyKey::BazelPackage(Label {
                        external_repository: Some(_),
                        path_components: _,
                        target_name: _,
                    })
                    | DependencyKey::BazelBuildFile(Label {
                        external_repository: Some(_),
                        path_components: _,
                        target_name: _,
                    })
                    | DependencyKey::Path(_) => {
                        // None of these could have been associated with a
                        // `//...` pattern inside the repository itself.
                    }

                    key @ DependencyKey::DummyForTesting(_) => {
                        panic!("Got dummy dependency key: {:?}", key);
                    }
                }
            }
        }

        deps.into_iter()
            .map(|(k, v)| {
                (
                    DependencyKey::BazelPackage(k),
                    DependencyValue::PackageInfo { deps: v },
                )
            })
            .collect()
    }