Full Code of guppy-rs/guppy for AI

gitextract_922wtfg2/

├── .cargo/
│   ├── config.toml
│   └── nightly-config.toml
├── .claude/
│   ├── .gitignore
│   └── settings.json
├── .config/
│   └── hakari.toml
├── .git-blame-ignore-revs
├── .gitattributes
├── .github/
│   ├── renovate.json
│   └── workflows/
│       ├── ci.yml
│       ├── docs.yml
│       ├── hakari.yml
│       └── release.yml
├── .gitignore
├── .ignore
├── .vscode/
│   └── launch.json
├── CLAUDE.md
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── Cargo.toml
├── Cross.toml
├── Justfile
├── LICENSE-APACHE
├── LICENSE-MIT
├── README.md
├── cargo-guppy/
│   ├── Cargo.toml
│   ├── README.md
│   ├── README.tpl
│   └── src/
│       ├── core.rs
│       ├── diff.rs
│       ├── lib.rs
│       ├── main.rs
│       └── mv.rs
├── clippy.toml
├── fixtures/
│   ├── Cargo.toml
│   ├── README.md
│   ├── determinator-paths/
│   │   ├── README.md
│   │   ├── git-diff.out
│   │   ├── guppy-linux.json
│   │   └── guppy-win.json
│   ├── guppy/
│   │   ├── hakari/
│   │   │   ├── metadata_guppy_44b62fa-0.toml
│   │   │   ├── metadata_guppy_44b62fa-1.toml
│   │   │   ├── metadata_guppy_44b62fa-2.toml
│   │   │   ├── metadata_guppy_44b62fa-3.toml
│   │   │   ├── metadata_guppy_78cb7e8-0.toml
│   │   │   ├── metadata_guppy_78cb7e8-1.toml
│   │   │   ├── metadata_guppy_78cb7e8-2.toml
│   │   │   ├── metadata_guppy_78cb7e8-3.toml
│   │   │   ├── metadata_guppy_869476c-0.toml
│   │   │   ├── metadata_guppy_869476c-1.toml
│   │   │   ├── metadata_guppy_869476c-2.toml
│   │   │   ├── metadata_guppy_869476c-3.toml
│   │   │   ├── metadata_guppy_c9b4f76-0.toml
│   │   │   ├── metadata_guppy_c9b4f76-1.toml
│   │   │   ├── metadata_guppy_c9b4f76-2.toml
│   │   │   └── metadata_guppy_c9b4f76-3.toml
│   │   ├── metadata_guppy_44b62fa.json
│   │   ├── metadata_guppy_78cb7e8.json
│   │   ├── metadata_guppy_869476c.json
│   │   ├── metadata_guppy_c9b4f76.json
│   │   ├── package-rules.toml
│   │   ├── path-rules.toml
│   │   └── summaries/
│   │       ├── metadata_guppy_44b62fa-0.toml
│   │       ├── metadata_guppy_44b62fa-1.toml
│   │       ├── metadata_guppy_44b62fa-2.toml
│   │       ├── metadata_guppy_44b62fa-3.toml
│   │       ├── metadata_guppy_44b62fa-4.toml
│   │       ├── metadata_guppy_44b62fa-5.toml
│   │       ├── metadata_guppy_44b62fa-6.toml
│   │       ├── metadata_guppy_44b62fa-7.toml
│   │       ├── metadata_guppy_78cb7e8-0.toml
│   │       ├── metadata_guppy_78cb7e8-1.toml
│   │       ├── metadata_guppy_78cb7e8-2.toml
│   │       ├── metadata_guppy_78cb7e8-3.toml
│   │       ├── metadata_guppy_78cb7e8-4.toml
│   │       ├── metadata_guppy_78cb7e8-5.toml
│   │       ├── metadata_guppy_78cb7e8-6.toml
│   │       ├── metadata_guppy_78cb7e8-7.toml
│   │       ├── metadata_guppy_869476c-0.toml
│   │       ├── metadata_guppy_869476c-1.toml
│   │       ├── metadata_guppy_869476c-2.toml
│   │       ├── metadata_guppy_869476c-3.toml
│   │       ├── metadata_guppy_869476c-4.toml
│   │       ├── metadata_guppy_869476c-5.toml
│   │       ├── metadata_guppy_869476c-6.toml
│   │       ├── metadata_guppy_869476c-7.toml
│   │       ├── metadata_guppy_c9b4f76-0.toml
│   │       ├── metadata_guppy_c9b4f76-1.toml
│   │       ├── metadata_guppy_c9b4f76-2.toml
│   │       ├── metadata_guppy_c9b4f76-3.toml
│   │       ├── metadata_guppy_c9b4f76-4.toml
│   │       ├── metadata_guppy_c9b4f76-5.toml
│   │       ├── metadata_guppy_c9b4f76-6.toml
│   │       └── metadata_guppy_c9b4f76-7.toml
│   ├── invalid/
│   │   ├── build_targets_duplicate_lib.json
│   │   ├── build_targets_empty_kinds.json
│   │   ├── build_targets_non_bin.json
│   │   ├── duplicate_workspace_names.json
│   │   ├── invalid_default_member.json
│   │   ├── named_feature_self_loop.json
│   │   ├── optional_dev_dep.json
│   │   └── workspace_member_different_drive.json
│   ├── large/
│   │   ├── hakari/
│   │   │   ├── hyper_util_7afb1ed-0.toml
│   │   │   ├── hyper_util_7afb1ed-1.toml
│   │   │   ├── hyper_util_7afb1ed-2.toml
│   │   │   ├── hyper_util_7afb1ed-3.toml
│   │   │   ├── metadata_libra-0.toml
│   │   │   ├── metadata_libra-1.toml
│   │   │   ├── metadata_libra-2.toml
│   │   │   ├── metadata_libra-3.toml
│   │   │   ├── metadata_libra_9ffd93b-0.toml
│   │   │   ├── metadata_libra_9ffd93b-1.toml
│   │   │   ├── metadata_libra_9ffd93b-2.toml
│   │   │   ├── metadata_libra_9ffd93b-3.toml
│   │   │   ├── metadata_libra_f0091a4-0.toml
│   │   │   ├── metadata_libra_f0091a4-1.toml
│   │   │   ├── metadata_libra_f0091a4-2.toml
│   │   │   ├── metadata_libra_f0091a4-3.toml
│   │   │   ├── mnemos_b3b4da9-0.toml
│   │   │   ├── mnemos_b3b4da9-1.toml
│   │   │   ├── mnemos_b3b4da9-2.toml
│   │   │   └── mnemos_b3b4da9-3.toml
│   │   ├── hyper_util_7afb1ed.json
│   │   ├── metadata_libra.json
│   │   ├── metadata_libra_9ffd93b.json
│   │   ├── metadata_libra_f0091a4.json
│   │   ├── mnemos_b3b4da9.json
│   │   └── summaries/
│   │       ├── hyper_util_7afb1ed-0.toml
│   │       ├── hyper_util_7afb1ed-1.toml
│   │       ├── hyper_util_7afb1ed-2.toml
│   │       ├── hyper_util_7afb1ed-3.toml
│   │       ├── hyper_util_7afb1ed-4.toml
│   │       ├── hyper_util_7afb1ed-5.toml
│   │       ├── hyper_util_7afb1ed-6.toml
│   │       ├── hyper_util_7afb1ed-7.toml
│   │       ├── metadata_libra-0.toml
│   │       ├── metadata_libra-1.toml
│   │       ├── metadata_libra-2.toml
│   │       ├── metadata_libra-3.toml
│   │       ├── metadata_libra-4.toml
│   │       ├── metadata_libra-5.toml
│   │       ├── metadata_libra-6.toml
│   │       ├── metadata_libra-7.toml
│   │       ├── metadata_libra_9ffd93b-0.toml
│   │       ├── metadata_libra_9ffd93b-1.toml
│   │       ├── metadata_libra_9ffd93b-2.toml
│   │       ├── metadata_libra_9ffd93b-3.toml
│   │       ├── metadata_libra_9ffd93b-4.toml
│   │       ├── metadata_libra_9ffd93b-5.toml
│   │       ├── metadata_libra_9ffd93b-6.toml
│   │       ├── metadata_libra_9ffd93b-7.toml
│   │       ├── metadata_libra_f0091a4-0.toml
│   │       ├── metadata_libra_f0091a4-1.toml
│   │       ├── metadata_libra_f0091a4-2.toml
│   │       ├── metadata_libra_f0091a4-3.toml
│   │       ├── metadata_libra_f0091a4-4.toml
│   │       ├── metadata_libra_f0091a4-5.toml
│   │       ├── metadata_libra_f0091a4-6.toml
│   │       ├── metadata_libra_f0091a4-7.toml
│   │       ├── mnemos_b3b4da9-0.toml
│   │       ├── mnemos_b3b4da9-1.toml
│   │       ├── mnemos_b3b4da9-2.toml
│   │       ├── mnemos_b3b4da9-3.toml
│   │       ├── mnemos_b3b4da9-4.toml
│   │       ├── mnemos_b3b4da9-5.toml
│   │       ├── mnemos_b3b4da9-6.toml
│   │       └── mnemos_b3b4da9-7.toml
│   ├── small/
│   │   ├── alternate-registries.json
│   │   ├── builddep.json
│   │   ├── hakari/
│   │   │   ├── metadata1-0.toml
│   │   │   ├── metadata1-1.toml
│   │   │   ├── metadata1-2.toml
│   │   │   ├── metadata1-3.toml
│   │   │   ├── metadata2-0.toml
│   │   │   ├── metadata2-1.toml
│   │   │   ├── metadata2-2.toml
│   │   │   ├── metadata2-3.toml
│   │   │   ├── metadata_alternate_registries-0.toml
│   │   │   ├── metadata_alternate_registries-1.toml
│   │   │   ├── metadata_alternate_registries-2.toml
│   │   │   ├── metadata_alternate_registries-3.toml
│   │   │   ├── metadata_build_targets1-0.toml
│   │   │   ├── metadata_build_targets1-1.toml
│   │   │   ├── metadata_build_targets1-2.toml
│   │   │   ├── metadata_build_targets1-3.toml
│   │   │   ├── metadata_builddep-0.toml
│   │   │   ├── metadata_builddep-1.toml
│   │   │   ├── metadata_builddep-2.toml
│   │   │   ├── metadata_builddep-3.toml
│   │   │   ├── metadata_cycle1-0.toml
│   │   │   ├── metadata_cycle1-1.toml
│   │   │   ├── metadata_cycle1-2.toml
│   │   │   ├── metadata_cycle1-3.toml
│   │   │   ├── metadata_cycle2-0.toml
│   │   │   ├── metadata_cycle2-1.toml
│   │   │   ├── metadata_cycle2-2.toml
│   │   │   ├── metadata_cycle2-3.toml
│   │   │   ├── metadata_cycle_features-0.toml
│   │   │   ├── metadata_cycle_features-1.toml
│   │   │   ├── metadata_cycle_features-2.toml
│   │   │   ├── metadata_cycle_features-3.toml
│   │   │   ├── metadata_dups-0.toml
│   │   │   ├── metadata_dups-1.toml
│   │   │   ├── metadata_dups-2.toml
│   │   │   ├── metadata_dups-3.toml
│   │   │   ├── metadata_proc_macro1-0.toml
│   │   │   ├── metadata_proc_macro1-1.toml
│   │   │   ├── metadata_proc_macro1-2.toml
│   │   │   ├── metadata_proc_macro1-3.toml
│   │   │   ├── metadata_targets1-0.toml
│   │   │   ├── metadata_targets1-1.toml
│   │   │   ├── metadata_targets1-2.toml
│   │   │   ├── metadata_targets1-3.toml
│   │   │   ├── metadata_weak_namespaced_features-0.toml
│   │   │   ├── metadata_weak_namespaced_features-1.toml
│   │   │   ├── metadata_weak_namespaced_features-2.toml
│   │   │   └── metadata_weak_namespaced_features-3.toml
│   │   ├── metadata1.json
│   │   ├── metadata2.json
│   │   ├── metadata_build_targets1.json
│   │   ├── metadata_cycle1.json
│   │   ├── metadata_cycle1_windows.json
│   │   ├── metadata_cycle1_windows_different_drives.json
│   │   ├── metadata_cycle2.json
│   │   ├── metadata_cycle_features.json
│   │   ├── metadata_default_members.json
│   │   ├── metadata_dups.json
│   │   ├── metadata_proc_macro1.json
│   │   ├── metadata_targets1.json
│   │   ├── summaries/
│   │   │   ├── metadata1-0.toml
│   │   │   ├── metadata1-1.toml
│   │   │   ├── metadata1-2.toml
│   │   │   ├── metadata1-3.toml
│   │   │   ├── metadata1-4.toml
│   │   │   ├── metadata1-5.toml
│   │   │   ├── metadata1-6.toml
│   │   │   ├── metadata1-7.toml
│   │   │   ├── metadata2-0.toml
│   │   │   ├── metadata2-1.toml
│   │   │   ├── metadata2-2.toml
│   │   │   ├── metadata2-3.toml
│   │   │   ├── metadata2-4.toml
│   │   │   ├── metadata2-5.toml
│   │   │   ├── metadata2-6.toml
│   │   │   ├── metadata2-7.toml
│   │   │   ├── metadata_alternate_registries-0.toml
│   │   │   ├── metadata_alternate_registries-1.toml
│   │   │   ├── metadata_alternate_registries-2.toml
│   │   │   ├── metadata_alternate_registries-3.toml
│   │   │   ├── metadata_alternate_registries-4.toml
│   │   │   ├── metadata_alternate_registries-5.toml
│   │   │   ├── metadata_alternate_registries-6.toml
│   │   │   ├── metadata_alternate_registries-7.toml
│   │   │   ├── metadata_build_targets1-0.toml
│   │   │   ├── metadata_build_targets1-1.toml
│   │   │   ├── metadata_build_targets1-2.toml
│   │   │   ├── metadata_build_targets1-3.toml
│   │   │   ├── metadata_build_targets1-4.toml
│   │   │   ├── metadata_build_targets1-5.toml
│   │   │   ├── metadata_build_targets1-6.toml
│   │   │   ├── metadata_build_targets1-7.toml
│   │   │   ├── metadata_builddep-0.toml
│   │   │   ├── metadata_builddep-1.toml
│   │   │   ├── metadata_builddep-2.toml
│   │   │   ├── metadata_builddep-3.toml
│   │   │   ├── metadata_builddep-4.toml
│   │   │   ├── metadata_builddep-5.toml
│   │   │   ├── metadata_builddep-6.toml
│   │   │   ├── metadata_builddep-7.toml
│   │   │   ├── metadata_cycle1-0.toml
│   │   │   ├── metadata_cycle1-1.toml
│   │   │   ├── metadata_cycle1-2.toml
│   │   │   ├── metadata_cycle1-3.toml
│   │   │   ├── metadata_cycle1-4.toml
│   │   │   ├── metadata_cycle1-5.toml
│   │   │   ├── metadata_cycle1-6.toml
│   │   │   ├── metadata_cycle1-7.toml
│   │   │   ├── metadata_cycle2-0.toml
│   │   │   ├── metadata_cycle2-1.toml
│   │   │   ├── metadata_cycle2-2.toml
│   │   │   ├── metadata_cycle2-3.toml
│   │   │   ├── metadata_cycle2-4.toml
│   │   │   ├── metadata_cycle2-5.toml
│   │   │   ├── metadata_cycle2-6.toml
│   │   │   ├── metadata_cycle2-7.toml
│   │   │   ├── metadata_cycle_features-0.toml
│   │   │   ├── metadata_cycle_features-1.toml
│   │   │   ├── metadata_cycle_features-2.toml
│   │   │   ├── metadata_cycle_features-3.toml
│   │   │   ├── metadata_cycle_features-4.toml
│   │   │   ├── metadata_cycle_features-5.toml
│   │   │   ├── metadata_cycle_features-6.toml
│   │   │   ├── metadata_cycle_features-7.toml
│   │   │   ├── metadata_dups-0.toml
│   │   │   ├── metadata_dups-1.toml
│   │   │   ├── metadata_dups-2.toml
│   │   │   ├── metadata_dups-3.toml
│   │   │   ├── metadata_dups-4.toml
│   │   │   ├── metadata_dups-5.toml
│   │   │   ├── metadata_dups-6.toml
│   │   │   ├── metadata_dups-7.toml
│   │   │   ├── metadata_proc_macro1-0.toml
│   │   │   ├── metadata_proc_macro1-1.toml
│   │   │   ├── metadata_proc_macro1-2.toml
│   │   │   ├── metadata_proc_macro1-3.toml
│   │   │   ├── metadata_proc_macro1-4.toml
│   │   │   ├── metadata_proc_macro1-5.toml
│   │   │   ├── metadata_proc_macro1-6.toml
│   │   │   ├── metadata_proc_macro1-7.toml
│   │   │   ├── metadata_targets1-0.toml
│   │   │   ├── metadata_targets1-1.toml
│   │   │   ├── metadata_targets1-2.toml
│   │   │   ├── metadata_targets1-3.toml
│   │   │   ├── metadata_targets1-4.toml
│   │   │   ├── metadata_targets1-5.toml
│   │   │   ├── metadata_targets1-6.toml
│   │   │   ├── metadata_targets1-7.toml
│   │   │   ├── metadata_weak_namespaced_features-0.toml
│   │   │   ├── metadata_weak_namespaced_features-1.toml
│   │   │   ├── metadata_weak_namespaced_features-2.toml
│   │   │   ├── metadata_weak_namespaced_features-3.toml
│   │   │   ├── metadata_weak_namespaced_features-4.toml
│   │   │   ├── metadata_weak_namespaced_features-5.toml
│   │   │   ├── metadata_weak_namespaced_features-6.toml
│   │   │   └── metadata_weak_namespaced_features-7.toml
│   │   └── weak-namespaced-features.json
│   ├── src/
│   │   ├── dep_helpers.rs
│   │   ├── details.rs
│   │   ├── json.rs
│   │   └── lib.rs
│   └── workspace/
│       └── inside-outside/
│           ├── aarch64-active/
│           │   ├── .gitignore
│           │   ├── Cargo.toml
│           │   └── src/
│           │       └── lib.rs
│           ├── external/
│           │   ├── .gitignore
│           │   ├── Cargo.toml
│           │   ├── examples/
│           │   │   └── external3.rs
│           │   └── src/
│           │       └── lib.rs
│           ├── inactive/
│           │   ├── .gitignore
│           │   ├── Cargo.toml
│           │   └── src/
│           │       └── lib.rs
│           ├── transitive/
│           │   ├── .gitignore
│           │   ├── Cargo.toml
│           │   └── src/
│           │       └── lib.rs
│           ├── workspace/
│           │   ├── .gitignore
│           │   ├── Cargo.toml
│           │   ├── internal/
│           │   │   ├── Cargo.toml
│           │   │   └── src/
│           │   │       └── lib.rs
│           │   ├── internal-macro/
│           │   │   ├── Cargo.toml
│           │   │   ├── build.rs
│           │   │   └── src/
│           │   │       └── lib.rs
│           │   ├── main/
│           │   │   ├── Cargo.toml
│           │   │   ├── build.rs
│           │   │   └── src/
│           │   │       └── lib.rs
│           │   ├── side/
│           │   │   ├── Cargo.toml
│           │   │   └── src/
│           │   │       └── lib.rs
│           │   └── src/
│           │       └── lib.rs
│           └── x86-active/
│               ├── .gitignore
│               ├── Cargo.toml
│               └── src/
│                   └── lib.rs
├── guppy/
│   ├── CHANGELOG.md
│   ├── Cargo.toml
│   ├── README.md
│   ├── README.tpl
│   ├── examples/
│   │   ├── cargo_set_link_filter.rs
│   │   ├── deps.rs
│   │   ├── print_by_level.rs
│   │   ├── print_dot.rs
│   │   ├── remove_dev_only.rs
│   │   └── topo_sort.rs
│   ├── proptest-regressions/
│   │   └── petgraph_support/
│   │       └── topo.txt
│   ├── src/
│   │   ├── debug_ignore.rs
│   │   ├── dependency_kind.rs
│   │   ├── errors.rs
│   │   ├── graph/
│   │   │   ├── build.rs
│   │   │   ├── build_targets.rs
│   │   │   ├── cargo/
│   │   │   │   ├── build.rs
│   │   │   │   ├── cargo_api.rs
│   │   │   │   └── mod.rs
│   │   │   ├── cycles.rs
│   │   │   ├── feature/
│   │   │   │   ├── build.rs
│   │   │   │   ├── cycles.rs
│   │   │   │   ├── feature_list.rs
│   │   │   │   ├── graph_impl.rs
│   │   │   │   ├── mod.rs
│   │   │   │   ├── proptest_helpers.rs
│   │   │   │   ├── query.rs
│   │   │   │   ├── resolve.rs
│   │   │   │   └── weak.rs
│   │   │   ├── graph_impl.rs
│   │   │   ├── mod.rs
│   │   │   ├── proptest_helpers.rs
│   │   │   ├── query.rs
│   │   │   ├── query_core.rs
│   │   │   ├── resolve.rs
│   │   │   ├── resolve_core.rs
│   │   │   ├── summaries/
│   │   │   │   └── package_set.rs
│   │   │   └── summaries.rs
│   │   ├── lib.rs
│   │   ├── macros.rs
│   │   ├── metadata_command.rs
│   │   ├── package_id.rs
│   │   ├── petgraph_support/
│   │   │   ├── dfs.rs
│   │   │   ├── dot.rs
│   │   │   ├── edge_ref.rs
│   │   │   ├── mod.rs
│   │   │   ├── scc.rs
│   │   │   ├── topo.rs
│   │   │   └── walk.rs
│   │   ├── platform/
│   │   │   ├── mod.rs
│   │   │   ├── platform_eval.rs
│   │   │   ├── platform_spec.rs
│   │   │   ├── proptest_helpers.rs
│   │   │   └── summaries.rs
│   │   ├── sorted_set.rs
│   │   └── unit_tests/
│   │       ├── dot_tests.rs
│   │       └── mod.rs
│   └── tests/
│       └── graph-tests/
│           ├── cargo_set_tests.rs
│           ├── feature_helpers.rs
│           ├── graph_tests.rs
│           ├── invalid_tests.rs
│           ├── main.rs
│           ├── proptest_helpers.rs
│           └── weak_namespaced.rs
├── guppy-cmdlib/
│   ├── Cargo.toml
│   └── src/
│       ├── lib.rs
│       └── proptest.rs
├── guppy-summaries/
│   ├── CHANGELOG.md
│   ├── Cargo.toml
│   ├── README.md
│   ├── README.tpl
│   └── src/
│       ├── diff.rs
│       ├── lib.rs
│       ├── report.rs
│       ├── summary.rs
│       └── unit_tests/
│           ├── basic_tests.rs
│           └── mod.rs
├── internal-tools/
│   ├── benchmarks/
│   │   ├── .gitignore
│   │   ├── Cargo.toml
│   │   └── benches/
│   │       └── package_graph.rs
│   ├── cargo-compare/
│   │   ├── Cargo.toml
│   │   ├── proptest-regressions/
│   │   │   └── tests/
│   │   │       └── workspace_tests.txt
│   │   └── src/
│   │       ├── check.rs
│   │       ├── common.rs
│   │       ├── diff.rs
│   │       ├── lib.rs
│   │       ├── main.rs
│   │       ├── tests/
│   │       │   ├── fixtures.rs
│   │       │   ├── mod.rs
│   │       │   ├── proptest_helpers.rs
│   │       │   └── workspace_tests.rs
│   │       └── type_conversions.rs
│   ├── fixture-manager/
│   │   ├── Cargo.toml
│   │   ├── src/
│   │   │   ├── context.rs
│   │   │   ├── hakari_toml.rs
│   │   │   ├── lib.rs
│   │   │   ├── main.rs
│   │   │   └── summaries.rs
│   │   └── tests/
│   │       └── unchanged_tests.rs
│   └── proptest-ext/
│       ├── Cargo.toml
│       └── src/
│           └── lib.rs
├── release.toml
├── rustfmt.toml
├── scripts/
│   ├── fix-readmes.awk
│   └── renovate-post-upgrade.sh
├── target-spec/
│   ├── CHANGELOG.md
│   ├── Cargo.toml
│   ├── README.md
│   ├── README.tpl
│   ├── build.rs
│   └── src/
│       ├── custom.rs
│       ├── custom_cfg.rs
│       ├── errors.rs
│       ├── lib.rs
│       ├── platform.rs
│       ├── proptest_helpers.rs
│       ├── simple_eval.rs
│       ├── spec.rs
│       ├── summaries.rs
│       └── triple.rs
├── target-spec-miette/
│   ├── CHANGELOG.md
│   ├── Cargo.toml
│   ├── README.md
│   ├── README.tpl
│   ├── src/
│   │   ├── fixtures.rs
│   │   ├── imp.rs
│   │   └── lib.rs
│   └── tests/
│       ├── datatest-snapshot/
│       │   ├── cfg.rs
│       │   ├── custom.rs
│       │   ├── expr.rs
│       │   ├── helpers.rs
│       │   ├── main.rs
│       │   └── snapshots/
│       │       ├── cfg-invalid/
│       │       │   ├── invalid-has-atomic.ansi
│       │       │   ├── invalid-pointer-width.ansi
│       │       │   ├── missing-arch.ansi
│       │       │   ├── unknown-endian.ansi
│       │       │   └── unquoted-value.ansi
│       │       ├── custom-invalid/
│       │       │   ├── invalid-arch.ansi
│       │       │   ├── invalid-endian.ansi
│       │       │   ├── invalid-family.ansi
│       │       │   ├── invalid-target-pointer-width.ansi
│       │       │   ├── missing-arch.ansi
│       │       │   └── syntax-error.ansi
│       │       └── expr-invalid/
│       │           ├── multiline-output.ansi
│       │           ├── unclosed-delimiter.ansi
│       │           └── unquoted-value.ansi
│       ├── fixtures/
│       │   ├── cfg-invalid/
│       │   │   ├── invalid-has-atomic.cfg
│       │   │   ├── invalid-pointer-width.cfg
│       │   │   ├── missing-arch.cfg
│       │   │   ├── unknown-endian.cfg
│       │   │   └── unquoted-value.cfg
│       │   ├── custom-invalid/
│       │   │   ├── invalid-arch.json
│       │   │   ├── invalid-endian.json
│       │   │   ├── invalid-family.json
│       │   │   ├── invalid-target-pointer-width.json
│       │   │   ├── missing-arch.json
│       │   │   └── syntax-error.json
│       │   └── expr-invalid/
│       │       ├── multiline-output
│       │       ├── unclosed-delimiter
│       │       └── unquoted-value
│       └── integration/
│           ├── main.rs
│           └── snapshots/
│               └── unavailable.ansi
├── tools/
│   ├── cargo-hakari/
│   │   ├── CHANGELOG.md
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   ├── README.tpl
│   │   └── src/
│   │       ├── cargo_cli.rs
│   │       ├── command.rs
│   │       ├── docs/
│   │       │   ├── about.rs
│   │       │   ├── config.rs
│   │       │   ├── mod.rs
│   │       │   ├── patch_directive.rs
│   │       │   └── publishing.rs
│   │       ├── helpers.rs
│   │       ├── lib.rs
│   │       ├── main.rs
│   │       ├── output.rs
│   │       └── publish.rs
│   ├── determinator/
│   │   ├── CHANGELOG.md
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   ├── README.tpl
│   │   ├── default-rules.toml
│   │   ├── src/
│   │   │   ├── determinator.rs
│   │   │   ├── errors.rs
│   │   │   ├── lib.rs
│   │   │   ├── paths0.rs
│   │   │   └── rules.rs
│   │   └── tests/
│   │       └── determinator_tests.rs
│   └── hakari/
│       ├── CHANGELOG.md
│       ├── Cargo.toml
│       ├── README.md
│       ├── README.tpl
│       ├── src/
│       │   ├── cargo_toml.rs
│       │   ├── cli_ops/
│       │   │   ├── initialize.rs
│       │   │   ├── manage_deps.rs
│       │   │   ├── mod.rs
│       │   │   └── workspace_ops.rs
│       │   ├── explain/
│       │   │   ├── display.rs
│       │   │   ├── mod.rs
│       │   │   └── simplify.rs
│       │   ├── hakari.rs
│       │   ├── helpers.rs
│       │   ├── lib.rs
│       │   ├── proptest_helpers.rs
│       │   ├── registry.rs
│       │   ├── summaries.rs
│       │   ├── toml_out.rs
│       │   └── verify/
│       │       ├── display.rs
│       │       └── mod.rs
│       └── templates/
│           ├── crate/
│           │   ├── .gitattributes
│           │   ├── Cargo.toml-in
│           │   ├── build.rs
│           │   └── src/
│           │       └── lib.rs
│           └── hakari.toml-in
└── workspace-hack/
    ├── .gitattributes
    ├── Cargo.toml
    ├── README.md
    ├── build.rs
    └── src/
        └── lib.rs

SYMBOL INDEX (2092 symbols across 139 files)

FILE: cargo-guppy/src/core.rs
  type Kind (line 17) | pub enum Kind {
    method should_traverse (line 26) | pub fn should_traverse(self, link: &PackageLink<'_>) -> bool {
  type QueryOptions (line 38) | pub struct QueryOptions {
    method direction (line 49) | fn direction(&self) -> DependencyDirection {
    method apply (line 58) | pub fn apply<'g>(&self, pkg_graph: &'g PackageGraph) -> Result<Package...
  type BaseFilterOptions (line 77) | pub struct BaseFilterOptions {
    method omitted_package_ids (line 90) | pub fn omitted_package_ids<'g: 'a, 'a>(
  type FilterOptions (line 100) | pub struct FilterOptions {
    method make_resolver (line 119) | pub fn make_resolver<'g>(
    method eval (line 147) | fn eval(
  function names_to_ids (line 158) | pub(crate) fn names_to_ids<'g: 'a, 'a>(

FILE: cargo-guppy/src/diff.rs
  type DiffOptions (line 9) | pub struct DiffOptions;
    method diff (line 12) | pub fn diff<'a>(
  type Package (line 116) | struct Package<'a>(pub &'a PackageMetadata<'a>);
  type Target (line 119) | type Target = PackageMetadata<'a>;
  method deref (line 121) | fn deref(&self) -> &Self::Target {
  method serialize (line 127) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  type Diff (line 140) | pub struct Diff<'a> {
  function fmt (line 147) | fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {

FILE: cargo-guppy/src/lib.rs
  function cmd_cycles (line 64) | pub fn cmd_cycles(metadata_opts: CargoMetadataOptions, features: bool) -...
  function cmd_diff (line 111) | pub fn cmd_diff(json: bool, old: &str, new: &str) -> Result<()> {
  type DiffSummariesOptions (line 133) | pub struct DiffSummariesOptions {
    method exec (line 144) | pub fn exec(&self) -> Result<()> {
  type DupsOptions (line 168) | pub struct DupsOptions {
  function cmd_dups (line 176) | pub fn cmd_dups(opts: &DupsOptions) -> Result<()> {
  type BuildKind (line 205) | pub enum BuildKind {
  type ResolveCargoOptions (line 214) | pub struct ResolveCargoOptions {
  function cmd_resolve_cargo (line 244) | pub fn cmd_resolve_cargo(opts: &ResolveCargoOptions) -> Result<()> {
  type NameVisitor (line 327) | struct NameVisitor;
  method visit_package (line 330) | fn visit_package(&self, package: PackageMetadata<'_>, f: &mut DotWrite<'...
  method visit_link (line 334) | fn visit_link(&self, _link: PackageLink<'_>, f: &mut DotWrite<'_, '_>) -...
  type CmdSelectOptions (line 340) | pub struct CmdSelectOptions {
    method output_direction (line 360) | fn output_direction(&self) -> DependencyDirection {
  function cmd_select (line 369) | pub fn cmd_select(options: &CmdSelectOptions) -> Result<()> {
  type SubtreeSizeOptions (line 404) | pub struct SubtreeSizeOptions {
  function cmd_subtree_size (line 417) | pub fn cmd_subtree_size(options: &SubtreeSizeOptions) -> Result<()> {

FILE: cargo-guppy/src/main.rs
  type Args (line 14) | struct Args {
  type Command (line 21) | enum Command {
  function executable_name (line 65) | fn executable_name(subcommand: &str) -> String {
  function args (line 79) | fn args() -> impl Iterator<Item = String> {
  function main (line 89) | fn main() -> Result<()> {

FILE: cargo-guppy/src/mv.rs
  type MvOptions (line 21) | pub struct MvOptions {
    method exec (line 39) | pub fn exec(&self) -> Result<()> {
  type DestDir (line 184) | enum DestDir {
    method new (line 190) | fn new(pkg_graph: &PackageGraph, dest_dir: &Utf8Path) -> Result<Self> {
    method is_create (line 227) | fn is_create(&self) -> bool {
    method join (line 234) | fn join(&self, workspace_path: &Utf8Path, src_dir: &Utf8Path) -> Resul...
  function canonicalize_dir (line 264) | fn canonicalize_dir(pkg_graph: &PackageGraph, path: impl AsRef<Utf8Path>...
  function rel_path (line 279) | fn rel_path<'a>(path: &'a Path, workspace_root: &Utf8Path) -> Result<&'a...
  function moves_for (line 291) | fn moves_for<'g: 'a, 'a>(
  type PackageMove (line 336) | struct PackageMove<'g> {
  type ManifestEdit (line 342) | struct ManifestEdit<'g> {
  function fmt (line 348) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function apply_edits (line 358) | fn apply_edits(manifest_path: &Utf8Path, edits: &[ManifestEdit<'_>]) -> ...
  function apply_edit (line 406) | fn apply_edit(table: &mut Table, edit: &ManifestEdit<'_>) -> Result<()> {
  function update_root_toml (line 450) | fn update_root_toml(
  function read_toml (line 514) | fn read_toml(manifest_path: &Utf8Path) -> Result<DocumentMut> {
  function replace_decorated (line 522) | fn replace_decorated(dest: &mut Value, new_value: impl Into<Value>) -> V...

FILE: fixtures/src/dep_helpers.rs
  function __from_metadata (line 22) | fn __from_metadata<'a>(link: &PackageLink<'a>) -> PackageMetadata<'a> {
  function __to_metadata (line 25) | fn __to_metadata<'a>(link: &PackageLink<'a>) -> PackageMetadata<'a> {
  type LinkToMetadata (line 28) | type LinkToMetadata<'a> = fn(&PackageLink<'a>) -> PackageMetadata<'a>;
  type DirectionDesc (line 34) | pub struct DirectionDesc<'a> {
  function new (line 43) | fn new(direction: DependencyDirection) -> Self {
  function forward (line 50) | fn forward() -> Self {
  function reverse (line 60) | fn reverse() -> Self {
  function known_metadata (line 70) | fn known_metadata(&self, dep: &PackageLink<'a>) -> PackageMetadata<'a> {
  function variable_metadata (line 74) | fn variable_metadata(&self, dep: &PackageLink<'a>) -> PackageMetadata<'a> {
  function from (line 80) | fn from(direction: DependencyDirection) -> Self {
  function assert_deps_internal (line 85) | pub(crate) fn assert_deps_internal(
  function assert_transitive_deps_internal (line 144) | pub(crate) fn assert_transitive_deps_internal(
  function assert_topo_ids (line 279) | pub(crate) fn assert_topo_ids(graph: &PackageGraph, direction: Dependenc...
  function assert_topo_metadatas (line 293) | pub(crate) fn assert_topo_metadatas(
  function assert_all_links (line 312) | pub(crate) fn assert_all_links(graph: &PackageGraph, direction: Dependen...
  function assert_enabled_status_is_known (line 351) | fn assert_enabled_status_is_known(req: DependencyReq<'_>, msg: &str) {
  type GraphAssert (line 373) | pub trait GraphAssert<'g>: Copy + fmt::Debug {
    constant NAME (line 378) | const NAME: &'static str;
    method depends_on (line 382) | fn depends_on(&self, a_id: Self::Id, b_id: Self::Id) -> Result<bool, E...
    method directly_depends_on (line 384) | fn directly_depends_on(&self, a_id: Self::Id, b_id: Self::Id) -> Resul...
    method is_cyclic (line 386) | fn is_cyclic(&self, a_id: Self::Id, b_id: Self::Id) -> Result<bool, Er...
    method query (line 388) | fn query(
    method resolve (line 394) | fn resolve(&self, initials: &[Self::Id], direction: DependencyDirectio...
    method ids (line 398) | fn ids(
    method root_ids (line 411) | fn root_ids(
    method root_metadatas (line 421) | fn root_metadatas(
    method assert_topo_order (line 431) | fn assert_topo_order(
    method assert_depends_on_any (line 449) | fn assert_depends_on_any(
    method assert_depends_on (line 484) | fn assert_depends_on(
    method assert_not_depends_on (line 511) | fn assert_not_depends_on(
    method assert_directly_depends_on (line 544) | fn assert_directly_depends_on(
  type GraphMetadata (line 572) | pub trait GraphMetadata<'g> {
    method id (line 574) | fn id(&self) -> Self::Id;
  type GraphQuery (line 577) | pub trait GraphQuery<'g> {
    method direction (line 581) | fn direction(&self) -> DependencyDirection;
    method starts_from (line 583) | fn starts_from(&self, id: Self::Id) -> bool;
    method resolve (line 585) | fn resolve(self) -> Self::Set;
  type GraphSet (line 588) | pub trait GraphSet<'g>: Clone + fmt::Debug {
    method len (line 591) | fn len(&self) -> usize;
    method is_empty (line 593) | fn is_empty(&self) -> bool {
    method contains (line 597) | fn contains(&self, id: Self::Id) -> bool;
    method union (line 599) | fn union(&self, other: &Self) -> Self;
    method intersection (line 600) | fn intersection(&self, other: &Self) -> Self;
    method difference (line 601) | fn difference(&self, other: &Self) -> Self;
    method symmetric_difference (line 602) | fn symmetric_difference(&self, other: &Self) -> Self;
    method ids (line 604) | fn ids(&self, direction: DependencyDirection) -> Vec<Self::Id>;
    method metadatas (line 605) | fn metadatas(&self, direction: DependencyDirection) -> Vec<Self::Metad...
    method root_ids (line 606) | fn root_ids(&self, direction: DependencyDirection) -> Vec<Self::Id>;
    method root_metadatas (line 607) | fn root_metadatas(&self, direction: DependencyDirection) -> Vec<Self::...
  type Id (line 611) | type Id = &'g PackageId;
  type Metadata (line 612) | type Metadata = PackageMetadata<'g>;
  type Query (line 613) | type Query = PackageQuery<'g>;
  type Set (line 614) | type Set = PackageSet<'g>;
  constant NAME (line 615) | const NAME: &'static str = "package";
  function depends_on (line 617) | fn depends_on(&self, a_id: Self::Id, b_id: Self::Id) -> Result<bool, Err...
  function directly_depends_on (line 621) | fn directly_depends_on(&self, a_id: Self::Id, b_id: Self::Id) -> Result<...
  function is_cyclic (line 625) | fn is_cyclic(&self, a_id: Self::Id, b_id: Self::Id) -> Result<bool, Erro...
  function query (line 630) | fn query(
  type Id (line 641) | type Id = &'g PackageId;
  function id (line 642) | fn id(&self) -> Self::Id {
  type Id (line 648) | type Id = &'g PackageId;
  type Set (line 649) | type Set = PackageSet<'g>;
  function direction (line 651) | fn direction(&self) -> DependencyDirection {
  function starts_from (line 655) | fn starts_from(&self, id: Self::Id) -> bool {
  function resolve (line 659) | fn resolve(self) -> Self::Set {
  type Id (line 665) | type Id = &'g PackageId;
  type Metadata (line 666) | type Metadata = PackageMetadata<'g>;
  function len (line 668) | fn len(&self) -> usize {
  function contains (line 672) | fn contains(&self, id: Self::Id) -> bool {
  function union (line 676) | fn union(&self, other: &Self) -> Self {
  function intersection (line 680) | fn intersection(&self, other: &Self) -> Self {
  function difference (line 684) | fn difference(&self, other: &Self) -> Self {
  function symmetric_difference (line 688) | fn symmetric_difference(&self, other: &Self) -> Self {
  function ids (line 692) | fn ids(&self, direction: DependencyDirection) -> Vec<Self::Id> {
  function metadatas (line 696) | fn metadatas(&self, direction: DependencyDirection) -> Vec<Self::Metadat...
  function root_ids (line 700) | fn root_ids(&self, direction: DependencyDirection) -> Vec<Self::Id> {
  function root_metadatas (line 704) | fn root_metadatas(&self, direction: DependencyDirection) -> Vec<Self::Me...
  type Id (line 710) | type Id = FeatureId<'g>;
  type Metadata (line 711) | type Metadata = FeatureMetadata<'g>;
  type Query (line 712) | type Query = FeatureQuery<'g>;
  type Set (line 713) | type Set = FeatureSet<'g>;
  constant NAME (line 714) | const NAME: &'static str = "feature";
  function depends_on (line 716) | fn depends_on(&self, a_id: Self::Id, b_id: Self::Id) -> Result<bool, Err...
  function directly_depends_on (line 720) | fn directly_depends_on(&self, a_id: Self::Id, b_id: Self::Id) -> Result<...
  function is_cyclic (line 724) | fn is_cyclic(&self, a_id: Self::Id, b_id: Self::Id) -> Result<bool, Erro...
  function query (line 729) | fn query(
  type Id (line 740) | type Id = FeatureId<'g>;
  function id (line 741) | fn id(&self) -> Self::Id {
  type Id (line 747) | type Id = FeatureId<'g>;
  type Set (line 748) | type Set = FeatureSet<'g>;
  function direction (line 750) | fn direction(&self) -> DependencyDirection {
  function starts_from (line 754) | fn starts_from(&self, id: Self::Id) -> bool {
  function resolve (line 758) | fn resolve(self) -> Self::Set {
  type Id (line 764) | type Id = FeatureId<'g>;
  type Metadata (line 765) | type Metadata = FeatureMetadata<'g>;
  function len (line 767) | fn len(&self) -> usize {
  function contains (line 771) | fn contains(&self, id: Self::Id) -> bool {
  function union (line 775) | fn union(&self, other: &Self) -> Self {
  function intersection (line 779) | fn intersection(&self, other: &Self) -> Self {
  function difference (line 783) | fn difference(&self, other: &Self) -> Self {
  function symmetric_difference (line 787) | fn symmetric_difference(&self, other: &Self) -> Self {
  function ids (line 791) | fn ids(&self, direction: DependencyDirection) -> Vec<Self::Id> {
  function metadatas (line 795) | fn metadatas(&self, direction: DependencyDirection) -> Vec<Self::Metadat...
  function root_ids (line 799) | fn root_ids(&self, direction: DependencyDirection) -> Vec<Self::Id> {
  function root_metadatas (line 803) | fn root_metadatas(&self, direction: DependencyDirection) -> Vec<Self::Me...
  function assert_link_order (line 815) | pub fn assert_link_order<'g>(
  function dep_link_ptrs (line 842) | fn dep_link_ptrs<'g>(dep_links: impl IntoIterator<Item = PackageLink<'g>...

FILE: fixtures/src/details.rs
  type FixtureDetails (line 27) | pub struct FixtureDetails {
    method new (line 36) | pub fn new(package_details: AHashMap<PackageId, PackageDetails>) -> Se...
    method with_workspace_members (line 46) | pub fn with_workspace_members<'a>(
    method with_link_details (line 59) | pub fn with_link_details(
    method with_feature_graph_warnings (line 67) | pub fn with_feature_graph_warnings(mut self, mut warnings: Vec<Feature...
    method with_cycles (line 73) | pub fn with_cycles(mut self, cycles: Vec<Vec<&'static str>>) -> Self {
    method known_ids (line 84) | pub fn known_ids(&self) -> impl Iterator<Item = &PackageId> {
    method assert_workspace (line 88) | pub fn assert_workspace(&self, workspace: Workspace) {
    method assert_topo (line 118) | pub fn assert_topo(&self, graph: &PackageGraph) {
    method assert_metadata (line 131) | pub fn assert_metadata(&self, id: &PackageId, metadata: PackageMetadat...
    method has_build_targets (line 140) | pub fn has_build_targets(&self, id: &PackageId) -> bool {
    method assert_build_targets (line 145) | pub fn assert_build_targets(&self, metadata: PackageMetadata<'_>, msg:...
    method has_deps (line 179) | pub fn has_deps(&self, id: &PackageId) -> bool {
    method assert_deps (line 184) | pub fn assert_deps(&self, graph: &PackageGraph, id: &PackageId, msg: &...
    method has_reverse_deps (line 190) | pub fn has_reverse_deps(&self, id: &PackageId) -> bool {
    method assert_reverse_deps (line 195) | pub fn assert_reverse_deps(&self, graph: &PackageGraph, id: &PackageId...
    method has_transitive_deps (line 205) | pub fn has_transitive_deps(&self, id: &PackageId) -> bool {
    method assert_transitive_deps (line 210) | pub fn assert_transitive_deps(&self, graph: &PackageGraph, id: &Packag...
    method has_transitive_reverse_deps (line 220) | pub fn has_transitive_reverse_deps(&self, id: &PackageId) -> bool {
    method assert_transitive_reverse_deps (line 225) | pub fn assert_transitive_reverse_deps(&self, graph: &PackageGraph, id:...
    method assert_link_details (line 238) | pub fn assert_link_details(&self, graph: &PackageGraph, msg: &str) {
    method has_named_features (line 266) | pub fn has_named_features(&self, id: &PackageId) -> bool {
    method assert_named_features (line 270) | pub fn assert_named_features(&self, graph: &PackageGraph, id: &Package...
    method assert_feature_graph_warnings (line 281) | pub fn assert_feature_graph_warnings(&self, graph: &PackageGraph, msg:...
    method assert_cycles (line 291) | pub fn assert_cycles(&self, graph: &PackageGraph, msg: &str) {
  type PackageDetails (line 319) | pub struct PackageDetails {
    method new (line 345) | pub fn new(
    method with_workspace_path (line 370) | pub fn with_workspace_path(mut self, path: &'static str) -> Self {
    method with_local_path (line 375) | pub fn with_local_path(mut self, path: &'static str) -> Self {
    method with_crates_io (line 380) | pub fn with_crates_io(self) -> Self {
    method with_external_source (line 384) | pub fn with_external_source(mut self, source: &'static str) -> Self {
    method with_build_targets (line 389) | pub fn with_build_targets(
    method with_deps (line 407) | pub fn with_deps(mut self, mut deps: Vec<(&'static str, &'static str)>...
    method with_reverse_deps (line 417) | pub fn with_reverse_deps(
    method with_transitive_deps (line 431) | pub fn with_transitive_deps(mut self, mut transitive_deps: Vec<&'stati...
    method with_transitive_reverse_deps (line 437) | pub fn with_transitive_reverse_deps(
    method with_named_features (line 451) | pub fn with_named_features(mut self, mut named_features: Vec<&'static ...
    method insert_into (line 457) | pub fn insert_into(self, map: &mut AHashMap<PackageId, PackageDetails>) {
    method id (line 461) | pub fn id(&self) -> &PackageId {
    method deps (line 465) | pub fn deps(&self, direction: DependencyDirection) -> Option<&[(&'stat...
    method transitive_deps (line 472) | pub fn transitive_deps(&self, direction: DependencyDirection) -> Optio...
    method assert_metadata (line 479) | pub fn assert_metadata(&self, metadata: PackageMetadata<'_>, msg: &str) {
  type LinkDetails (line 507) | pub struct LinkDetails {
    method new (line 515) | pub fn new(from: PackageId, to: PackageId) -> Self {
    method with_platform_status (line 524) | pub fn with_platform_status(
    method with_features (line 534) | pub fn with_features(
    method insert_into (line 544) | pub fn insert_into(self, map: &mut AHashMap<(PackageId, PackageId), Se...
    method assert_metadata (line 548) | pub fn assert_metadata(&self, link: PackageLink<'_>, msg: &str) {
  type PlatformResults (line 598) | pub struct PlatformResults {
    method new (line 606) | pub fn new(
    method with_feature_status (line 617) | pub fn with_feature_status(

FILE: fixtures/src/json.rs
  constant FIXTURE_MANAGER_EXCLUDES (line 183) | const FIXTURE_MANAGER_EXCLUDES: &[&str] = &[
  type JsonFixture (line 252) | pub struct JsonFixture {
    method new (line 261) | fn new(name: &'static str, rel_path: &'static str, details: FixtureDet...
    method by_name (line 294) | pub fn by_name(name: &str) -> Option<&'static Self> {
    method name (line 299) | pub fn name(&self) -> &'static str {
    method abs_path (line 304) | pub fn abs_path(&self) -> &Utf8Path {
    method workspace_path (line 309) | pub fn workspace_path(&self) -> &Utf8Path {
    method json (line 314) | pub fn json(&self) -> &str {
    method graph (line 319) | pub fn graph(&self) -> &PackageGraph {
    method details (line 324) | pub fn details(&self) -> &FixtureDetails {
    method verify (line 329) | pub fn verify(&self) {
    method init_graph (line 399) | fn init_graph(&self) -> (&str, &PackageGraph) {
    method parse_graph (line 409) | fn parse_graph(json: &str) -> PackageGraph {
  function normalize_assuming_no_symlinks (line 417) | fn normalize_assuming_no_symlinks(p: impl AsRef<Utf8Path>) -> Utf8PathBuf {
  method metadata1 (line 435) | pub(crate) fn metadata1() -> Self {
  method metadata2 (line 527) | pub(crate) fn metadata2() -> Self {
  method metadata_builddep (line 609) | pub(crate) fn metadata_builddep() -> Self {
  method metadata_dups (line 615) | pub(crate) fn metadata_dups() -> Self {
  method metadata_cycle1 (line 638) | pub(crate) fn metadata_cycle1() -> Self {
  method metadata_cycle1_windows (line 674) | pub(crate) fn metadata_cycle1_windows() -> Self {
  method metadata_cycle1_windows_different_drives (line 725) | pub(crate) fn metadata_cycle1_windows_different_drives() -> Self {
  method metadata_cycle2 (line 788) | pub(crate) fn metadata_cycle2() -> Self {
  method metadata_cycle_features (line 900) | pub(crate) fn metadata_cycle_features() -> Self {
  method metadata_targets1 (line 914) | pub(crate) fn metadata_targets1() -> Self {
  method metadata_build_targets1 (line 1190) | pub(crate) fn metadata_build_targets1() -> Self {
  method metadata_proc_macro1 (line 1268) | pub(crate) fn metadata_proc_macro1() -> Self {
  method metadata_alternate_registries (line 1290) | pub(crate) fn metadata_alternate_registries() -> Self {
  method metadata_weak_namespaced_features (line 1295) | pub(crate) fn metadata_weak_namespaced_features() -> Self {
  method metadata_libra (line 1300) | pub(crate) fn metadata_libra() -> Self {
  method metadata_libra_f0091a4 (line 1438) | pub(crate) fn metadata_libra_f0091a4() -> Self {
  method metadata_libra_9ffd93b (line 1450) | pub(crate) fn metadata_libra_9ffd93b() -> Self {
  method mnemos_b3b4da9 (line 1469) | pub(crate) fn mnemos_b3b4da9() -> Self {
  method hyper_util_7afb1ed (line 1475) | pub(crate) fn hyper_util_7afb1ed() -> Self {
  method metadata_guppy_78cb7e8 (line 1481) | pub(crate) fn metadata_guppy_78cb7e8() -> Self {
  method metadata_guppy_869476c (line 1487) | pub(crate) fn metadata_guppy_869476c() -> Self {
  method metadata_guppy_c9b4f76 (line 1493) | pub(crate) fn metadata_guppy_c9b4f76() -> Self {
  method metadata_guppy_44b62fa (line 1499) | pub(crate) fn metadata_guppy_44b62fa() -> Self {

FILE: fixtures/src/lib.rs
  function package_id (line 13) | pub fn package_id(s: impl Into<Box<str>>) -> PackageId {

FILE: fixtures/workspace/inside-outside/aarch64-active/src/lib.rs
  function it_works (line 4) | fn it_works() {

FILE: fixtures/workspace/inside-outside/external/src/lib.rs
  function it_works (line 4) | fn it_works() {

FILE: fixtures/workspace/inside-outside/inactive/src/lib.rs
  function it_works (line 4) | fn it_works() {

FILE: fixtures/workspace/inside-outside/transitive/src/lib.rs
  function it_works (line 4) | fn it_works() {

FILE: fixtures/workspace/inside-outside/workspace/internal-macro/build.rs
  function main (line 1) | fn main() {

FILE: fixtures/workspace/inside-outside/workspace/internal-macro/src/lib.rs
  function it_works (line 4) | fn it_works() {

FILE: fixtures/workspace/inside-outside/workspace/internal/src/lib.rs
  function it_works (line 4) | fn it_works() {

FILE: fixtures/workspace/inside-outside/workspace/main/build.rs
  function main (line 1) | fn main() {

FILE: fixtures/workspace/inside-outside/workspace/main/src/lib.rs
  function it_works (line 4) | fn it_works() {

FILE: fixtures/workspace/inside-outside/workspace/side/src/lib.rs
  function it_works (line 4) | fn it_works() {

FILE: fixtures/workspace/inside-outside/workspace/src/lib.rs
  function it_works (line 4) | fn it_works() {

FILE: fixtures/workspace/inside-outside/x86-active/src/lib.rs
  function it_works (line 4) | fn it_works() {

FILE: guppy-cmdlib/src/lib.rs
  type PackagesAndFeatures (line 28) | pub struct PackagesAndFeatures {
    method make_feature_sets (line 54) | pub fn make_feature_sets<'g>(
  type CargoResolverVersionCmd (line 89) | pub enum CargoResolverVersionCmd {
    method to_guppy (line 123) | pub fn to_guppy(self) -> CargoResolverVersion {
  type InitialsPlatformCmd (line 97) | pub enum InitialsPlatformCmd {
    method to_guppy (line 135) | pub fn to_guppy(self) -> InitialsPlatform {
  type CargoResolverOpts (line 105) | pub struct CargoResolverOpts {
  type CargoMetadataOptions (line 148) | pub struct CargoMetadataOptions {
    method current_dir (line 156) | pub fn current_dir(&self) -> Result<PathBuf> {
    method abs_manifest_path (line 161) | pub fn abs_manifest_path(&self) -> Result<PathBuf> {
    method make_command (line 171) | pub fn make_command(&self) -> MetadataCommand {
  function string_to_platform_spec (line 183) | pub fn string_to_platform_spec(s: Option<&str>) -> Result<PlatformSpec> {

FILE: guppy-cmdlib/src/proptest.rs
  method strategy (line 14) | pub fn strategy(graph: &PackageGraph) -> impl Strategy<Value = Self> + '_ {
  function triple_strategy (line 49) | pub fn triple_strategy() -> impl Strategy<Value = Option<String>> {

FILE: guppy-summaries/src/diff.rs
  type SummaryDiff (line 74) | pub struct SummaryDiff<'a> {
  function new (line 84) | pub fn new(old: &'a Summary, new: &'a Summary) -> Self {
  function is_changed (line 92) | pub fn is_changed(&self) -> bool {
  function is_unchanged (line 97) | pub fn is_unchanged(&self) -> bool {
  function report (line 104) | pub fn report<'b>(&'b self) -> SummaryReport<'a, 'b> {
  type UnchangedInfo (line 110) | pub type UnchangedInfo<'a> = (&'a Version, &'a SummarySource, &'a Packag...
  type PackageDiff (line 114) | pub struct PackageDiff<'a> {
  function new (line 124) | pub fn new(old: &'a PackageMap, new: &'a PackageMap) -> Self {
  function is_unchanged (line 177) | pub fn is_unchanged(&self) -> bool {
  function combine_insert_remove (line 185) | fn combine_insert_remove(changed: &mut BTreeMap<&'a SummaryId, SummaryDi...
  function changed_sort_key (line 238) | pub(crate) fn changed_sort_key<'a>(
  method serialize (line 251) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  type SummaryDiffStatus (line 314) | pub enum SummaryDiffStatus<'a> {
  function make_changed (line 372) | fn make_changed(
  function make_changed_diff (line 407) | fn make_changed_diff(
  function tag (line 442) | pub fn tag(&self) -> SummaryDiffTag {
  function latest_status (line 451) | pub fn latest_status(&self) -> PackageStatus {
  function serialize (line 464) | pub fn serialize<S>(item: &PackageInfo, serializer: S) -> Result<S::Ok, ...
  type SummaryDiffTag (line 488) | pub enum SummaryDiffTag {
    method fmt (line 500) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type Diff (line 510) | type Diff = (&'a PackageInfo, &'a PackageInfo);
  method diff (line 512) | fn diff(&'a self, other: &'a Self) -> edit::Edit<'a, Self> {
  type Diff (line 522) | type Diff = (&'a PackageStatus, &'a PackageStatus);
  method diff (line 524) | fn diff(&'a self, other: &'a Self) -> edit::Edit<'a, Self> {
  type CombineStatus (line 534) | enum CombineStatus<'a> {
  function record_added (line 546) | fn record_added(&mut self, summary_id: &'a SummaryId) {
  function record_removed (line 559) | fn record_removed(&mut self, summary_id: &'a SummaryId) {
  function record_changed (line 572) | fn record_changed(&mut self) {

FILE: guppy-summaries/src/report.rs
  type SummaryReport (line 14) | pub struct SummaryReport<'a, 'b> {
  function new (line 22) | pub fn new(diff: &'b SummaryDiff<'a>) -> Self {
  function make_sorted (line 33) | fn make_sorted(
  function fmt (line 48) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type PackageReport (line 70) | struct PackageReport<'x> {
  function new (line 76) | fn new(
  function fmt (line 88) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function display_list (line 188) | fn display_list<I>(f: &mut fmt::Formatter, items: I) -> fmt::Result

FILE: guppy-summaries/src/summary.rs
  type PackageMap (line 15) | pub type PackageMap = BTreeMap<SummaryId, PackageInfo>;
  type Summary (line 24) | pub struct Summary {
    method with_metadata (line 55) | pub fn with_metadata(metadata: &impl Serialize) -> Result<Self, toml::...
    method parse (line 66) | pub fn parse(s: &str) -> Result<Self, toml::de::Error> {
    method diff (line 73) | pub fn diff<'a>(&'a self, other: &'a Summary) -> SummaryDiff<'a> {
    method to_string (line 78) | pub fn to_string(&self) -> Result<String, toml::ser::Error> {
    method write_to_string (line 85) | pub fn write_to_string(&self, dst: &mut String) -> Result<(), toml::se...
  type SummaryId (line 95) | pub struct SummaryId {
    method new (line 109) | pub fn new(name: impl Into<String>, version: Version, source: SummaryS...
    method fmt (line 119) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type SummarySource (line 131) | pub enum SummarySource {
    method workspace (line 167) | pub fn workspace(workspace_path: impl Into<Utf8PathBuf>) -> Self {
    method path (line 174) | pub fn path(path: impl Into<Utf8PathBuf>) -> Self {
    method crates_io (line 179) | pub fn crates_io() -> Self {
    method external (line 185) | pub fn external(source: impl Into<String>) -> Self {
    method fmt (line 193) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type PackageInfo (line 214) | pub struct PackageInfo {
  type PackageStatus (line 231) | pub enum PackageStatus {
    method fmt (line 248) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function serialize (line 264) | pub fn serialize<S>(package_map: &PackageMap, serializer: S) -> Result<S...
  type PackageSerialize (line 281) | struct PackageSerialize<'a> {
  function deserialize (line 288) | pub fn deserialize<'de, D>(deserializer: D) -> Result<PackageMap, D::Error>
  type PackageDeserialize (line 303) | struct PackageDeserialize {
  function serialize_forward_slashes (line 312) | pub fn serialize_forward_slashes<S>(path: &Utf8PathBuf, serializer: S) -...
  function path_replace_slashes (line 321) | fn path_replace_slashes(path: &Utf8Path) -> impl fmt::Display + Serializ...
  function serialize (line 337) | pub fn serialize<S>(serializer: S) -> Result<S::Ok, S::Error>
  function deserialize (line 346) | pub fn deserialize<'de, D>(deserializer: D) -> Result<(), D::Error>
  type CratesIoDeserialize (line 358) | struct CratesIoDeserialize {

FILE: guppy-summaries/src/unit_tests/basic_tests.rs
  function empty_roundtrip (line 110) | fn empty_roundtrip() {
  function basic_roundtrip (line 128) | fn basic_roundtrip() {
  function test_serialization (line 344) | fn test_serialization() {
  function make_summary (line 583) | fn make_summary(list: Vec<(SummaryId, PackageStatus, Vec<&str>, Vec<&str...

FILE: guppy/examples/cargo_set_link_filter.rs
  type PackageResolverForPlatformSet (line 28) | struct PackageResolverForPlatformSet(Vec<PlatformSpec>);
    method new (line 31) | fn new(platform_set: Vec<PlatformSpec>) -> Self {
    method can_platform_status_be_true (line 35) | fn can_platform_status_be_true(&self, platform_status: PlatformStatus)...
    method should_include_dependency_req (line 42) | fn should_include_dependency_req(&self, dependency_req: DependencyReq)...
    method accept (line 50) | fn accept(&mut self, _query: &PackageQuery<'g>, link: PackageLink<'g>)...
  function win32_platform_spec (line 56) | fn win32_platform_spec() -> PlatformSpec {
  function win64_platform_spec (line 69) | fn win64_platform_spec() -> PlatformSpec {
  function cargo_set_to_package_names (line 82) | fn cargo_set_to_package_names(cargo_set: CargoSet) -> Vec<String> {
  function main (line 98) | fn main() -> Result<(), Error> {

FILE: guppy/examples/deps.rs
  function main (line 9) | fn main() -> Result<(), Error> {

FILE: guppy/examples/print_by_level.rs
  function main (line 15) | fn main() -> Result<(), Error> {

FILE: guppy/examples/print_dot.rs
  type PackageNameVisitor (line 23) | struct PackageNameVisitor;
  method visit_package (line 26) | fn visit_package(&self, package: PackageMetadata<'_>, f: &mut DotWrite<'...
  method visit_link (line 34) | fn visit_link(&self, link: PackageLink<'_>, f: &mut DotWrite<'_, '_>) ->...
  function main (line 44) | fn main() -> Result<(), Error> {

FILE: guppy/examples/remove_dev_only.rs
  function main (line 15) | fn main() -> Result<(), Error> {

FILE: guppy/examples/topo_sort.rs
  function main (line 11) | fn main() -> Result<(), Error> {

FILE: guppy/src/debug_ignore.rs
  type DebugIgnore (line 16) | pub struct DebugIgnore<T>(pub T);
  type Target (line 19) | type Target = T;
  method deref (line 21) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 27) | fn deref_mut(&mut self) -> &mut Self::Target {
  function fmt (line 33) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

FILE: guppy/src/dependency_kind.rs
  type DependencyKind (line 10) | pub enum DependencyKind {
    constant VALUES (line 30) | pub const VALUES: &'static [Self; 3] = &[
    method to_str (line 37) | pub fn to_str(self) -> &'static str {
    method fmt (line 47) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

FILE: guppy/src/errors.rs
  type Error (line 15) | pub enum Error {
    method command_error (line 77) | pub(crate) fn command_error(err: cargo_metadata::Error) -> Self {
    method unknown_feature_id (line 81) | pub(crate) fn unknown_feature_id(feature_id: FeatureId<'_>) -> Self {
    method fmt (line 90) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method source (line 153) | fn source(&self) -> Option<&(dyn error::Error + 'static)> {
  type FeatureGraphWarning (line 181) | pub enum FeatureGraphWarning {
    method fmt (line 202) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type FeatureBuildStage (line 227) | pub enum FeatureBuildStage {
    method fmt (line 245) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: guppy/src/graph/build.rs
  method build (line 34) | pub(crate) fn build(mut metadata: Metadata) -> Result<Self, Box<Error>> {
  method new (line 96) | fn new(
  type GraphBuildState (line 171) | struct GraphBuildState<'a> {
  function new (line 186) | fn new(
  function process_package (line 237) | fn process_package(
  function package_data_and_remove_build_targets (line 412) | fn package_data_and_remove_build_targets(
  function workspace_path (line 427) | fn workspace_path(
  function finish (line 449) | fn finish(self) -> Graph<PackageId, PackageLinkImpl, Directed, PackageIx> {
  type PackageDataValue (line 456) | struct PackageDataValue {
    method new (line 467) | fn new(
  type ResolvedName (line 515) | enum ResolvedName {
  type ReqResolvedName (line 527) | struct ReqResolvedName<'g> {
  function new (line 536) | fn new(renamed: Option<&str>, resolved_name: &'g ResolvedName) -> Self {
  function matches (line 543) | fn matches(&self, name: &str) -> bool {
  method create_path (line 572) | fn create_path(path: &Utf8Path, workspace_root: &Utf8Path) -> Self {
  method from_cargo_string (line 582) | fn from_cargo_string(input: impl Into<String>) -> Self {
  type BuildTargetMap (line 600) | type BuildTargetMap = BTreeMap<OwnedBuildTargetId, BuildTargetImpl>;
  type BuildTargets (line 602) | struct BuildTargets<'a> {
  function new (line 608) | fn new(package_id: &'a PackageId) -> Self {
  function add (line 615) | fn add(&mut self, target: Target) -> Result<(), Box<Error>> {
  function is_proc_macro (line 730) | fn is_proc_macro(list: &[String]) -> bool {
  function finish (line 734) | fn finish(self) -> BuildTargetMap {
  type DependencyResolver (line 739) | struct DependencyResolver<'g> {
  function new (line 753) | fn new(
  function resolve (line 791) | fn resolve<'a>(
  type DependencyReqs (line 820) | struct DependencyReqs<'g> {
  function push (line 826) | fn push(&mut self, resolved_name: ReqResolvedName<'g>, dependency: &'g D...
  function matches_for (line 830) | fn matches_for<'a>(
  method new (line 868) | fn new<'a>(
  method add_instance (line 980) | fn add_instance(&mut self, from_id: &PackageId, dep: &Dependency) -> Res...
  method add_instance (line 990) | fn add_instance(&mut self, from_id: &PackageId, dep: &Dependency) -> Res...
  method new (line 1026) | fn new(registries: Option<Vec<String>>) -> Self {
  type WindowsPathPrefix (line 1038) | enum WindowsPathPrefix<'a> {
  function parse (line 1050) | fn parse(s: &'a str) -> Option<(Self, &'a str)> {
  function parse_inner (line 1069) | fn parse_inner(s: &'a str) -> Option<(Self, &'a str)> {
  function parse_unc_components (line 1092) | fn parse_unc_components(s: &'a str) -> Option<(Self, &'a str)> {
  function normalize_windows_path_on_unix (line 1117) | fn normalize_windows_path_on_unix(path: Utf8PathBuf) -> Utf8PathBuf {
  function diff_utf8_paths_cross_platform (line 1157) | fn diff_utf8_paths_cross_platform(path: &Utf8Path, base: &Utf8Path) -> O...
  function convert_relative_forward_slashes (line 1209) | fn convert_relative_forward_slashes(rel_path: Utf8PathBuf) -> Utf8PathBuf {
  function test_parse_named_feature_dependency (line 1230) | fn test_parse_named_feature_dependency() {
  function test_create_path (line 1250) | fn test_create_path() {
  function test_convert_relative_forward_slashes (line 1262) | fn test_convert_relative_forward_slashes() {
  function test_normalize_windows_path_on_unix (line 1271) | fn test_normalize_windows_path_on_unix() {
  function verify_diff_utf8_paths_cross_platform (line 1299) | fn verify_diff_utf8_paths_cross_platform(
  function test_workspace_path_out_of_pocket (line 1315) | fn test_workspace_path_out_of_pocket() {
  function test_diff_utf8_paths_cross_platform_unix (line 1324) | fn test_diff_utf8_paths_cross_platform_unix() {
  function test_diff_utf8_paths_cross_platform_windows (line 1347) | fn test_diff_utf8_paths_cross_platform_windows() {
  function test_diff_utf8_paths_cross_platform_unc (line 1382) | fn test_diff_utf8_paths_cross_platform_unc() {
  function test_diff_utf8_paths_cross_platform_extended_length (line 1402) | fn test_diff_utf8_paths_cross_platform_extended_length() {
  function test_diff_utf8_paths_cross_platform_different_drives (line 1447) | fn test_diff_utf8_paths_cross_platform_different_drives() {
  function test_diff_utf8_paths_cross_platform_different_unc_servers (line 1465) | fn test_diff_utf8_paths_cross_platform_different_unc_servers() {
  function test_diff_utf8_paths_cross_platform_mixed (line 1495) | fn test_diff_utf8_paths_cross_platform_mixed() {
  function test_diff_utf8_paths_cross_platform_trailing_slashes (line 1508) | fn test_diff_utf8_paths_cross_platform_trailing_slashes() {
  function test_diff_utf8_paths_cross_platform_root_only (line 1525) | fn test_diff_utf8_paths_cross_platform_root_only() {
  function test_windows_path_prefix_parse (line 1542) | fn test_windows_path_prefix_parse() {
  function test_create_path_windows (line 1593) | fn test_create_path_windows() {
  function test_convert_relative_forward_slashes_absolute (line 1608) | fn test_convert_relative_forward_slashes_absolute() {
  function test_workspace_path_out_of_pocket_on_windows_same_drive (line 1617) | fn test_workspace_path_out_of_pocket_on_windows_same_drive() {
  function test_workspace_path_out_of_pocket_on_windows_different_drives (line 1627) | fn test_workspace_path_out_of_pocket_on_windows_different_drives() {

FILE: guppy/src/graph/build_targets.rs
  type BuildTarget (line 15) | pub struct BuildTarget<'g> {
  function new (line 22) | pub(super) fn new((id, inner): (&'g OwnedBuildTargetId, &'g BuildTargetI...
  function id (line 31) | pub fn id(&self) -> BuildTargetId<'g> {
  function name (line 36) | pub fn name(&self) -> &'g str {
  function kind (line 49) | pub fn kind(&self) -> BuildTargetKind<'g> {
  function required_features (line 61) | pub fn required_features(&self) -> &'g [String] {
  function path (line 67) | pub fn path(&self) -> &'g Utf8Path {
  function edition (line 73) | pub fn edition(&self) -> &'g str {
  function doc_by_default (line 87) | pub fn doc_by_default(&self) -> bool {
  function doctest_by_default (line 98) | pub fn doctest_by_default(&self) -> bool {
  function doc_tests (line 105) | pub fn doc_tests(&self) -> bool {
  function test_by_default (line 118) | pub fn test_by_default(&self) -> bool {
  type BuildTargetId (line 126) | pub enum BuildTargetId<'g> {
  function name (line 169) | pub fn name(&self) -> Option<&'g str> {
  function as_key (line 180) | pub(super) fn as_key(&self) -> &(dyn BuildTargetKey + 'g) {
  type BuildTargetKind (line 190) | pub enum BuildTargetKind<'g> {
  function new (line 222) | fn new(inner: &'g BuildTargetKindImpl) -> Self {
  type BuildTargetImpl (line 235) | pub(super) struct BuildTargetImpl {
  type OwnedBuildTargetId (line 250) | pub(super) enum OwnedBuildTargetId {
    method as_borrowed (line 260) | fn as_borrowed(&self) -> BuildTargetId<'_> {
    method borrow (line 298) | fn borrow(&self) -> &(dyn BuildTargetKey + 'g) {
    method as_key (line 331) | fn as_key(&self) -> &dyn BuildTargetKey {
  type BuildTargetKindImpl (line 274) | pub(super) enum BuildTargetKindImpl {
  type BuildTargetKey (line 281) | pub(super) trait BuildTargetKey {
    method key (line 282) | fn key(&self) -> BuildTargetId<'_>;
    method key (line 286) | fn key(&self) -> BuildTargetId<'_> {
    method key (line 292) | fn key(&self) -> BuildTargetId<'_> {
  method eq (line 304) | fn eq(&self, other: &Self) -> bool {
  method partial_cmp (line 314) | fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
  method cmp (line 320) | fn cmp(&self, other: &Self) -> Ordering {

FILE: guppy/src/graph/cargo/build.rs
  type CargoSetBuildState (line 19) | pub(super) struct CargoSetBuildState<'a> {
  function new (line 25) | pub(super) fn new<'g>(
  function build (line 38) | pub(super) fn build<'g>(
  function build_intermediate (line 57) | pub(super) fn build_intermediate(self, query: FeatureQuery) -> CargoInte...
  function new_v1 (line 68) | fn new_v1<'g>(
  function new_v2 (line 80) | fn new_v2<'g>(
  function is_omitted (line 95) | fn is_omitted(&self, package_ix: NodeIndex<PackageIx>) -> bool {
  function build_set (line 99) | fn build_set<'g>(
  function new_v1_intermediate (line 353) | fn new_v1_intermediate<'g>(
  function new_v2_intermediate (line 380) | fn new_v2_intermediate<'g>(&self, query: FeatureQuery<'g>) -> CargoInter...

FILE: guppy/src/graph/cargo/cargo_api.rs
  type CargoOptions (line 22) | pub struct CargoOptions<'a> {
  function new (line 42) | pub fn new() -> Self {
  function set_resolver (line 56) | pub fn set_resolver(&mut self, resolver: CargoResolverVersion) -> &mut S...
  function set_include_dev (line 67) | pub fn set_include_dev(&mut self, include_dev: bool) -> &mut Self {
  function set_initials_platform (line 77) | pub fn set_initials_platform(&mut self, initials_platform: InitialsPlatf...
  function set_platform (line 83) | pub fn set_platform(&mut self, platform_spec: impl Into<PlatformSpec>) -...
  function set_target_platform (line 91) | pub fn set_target_platform(&mut self, target_platform: impl Into<Platfor...
  function set_host_platform (line 97) | pub fn set_host_platform(&mut self, host_platform: impl Into<PlatformSpe...
  function add_omitted_packages (line 108) | pub fn add_omitted_packages(
  method default (line 118) | fn default() -> Self {
  type CargoResolverVersion (line 128) | pub enum CargoResolverVersion {
  type InitialsPlatform (line 185) | pub enum InitialsPlatform {
  method default (line 209) | fn default() -> Self {
  type CargoSet (line 219) | pub struct CargoSet<'g> {
  function new (line 255) | pub fn new(
  function with_package_resolver (line 273) | pub fn with_package_resolver(
  function new_internal (line 283) | fn new_internal(
  function new_intermediate (line 299) | pub fn new_intermediate(
  function feature_graph (line 308) | pub fn feature_graph(&self) -> &FeatureGraph<'g> {
  function package_graph (line 313) | pub fn package_graph(&self) -> &'g PackageGraph {
  function initials (line 319) | pub fn initials(&self) -> &FeatureSet<'g> {
  function features_only (line 328) | pub fn features_only(&self) -> &FeatureSet<'g> {
  function target_features (line 336) | pub fn target_features(&self) -> &FeatureSet<'g> {
  function host_features (line 346) | pub fn host_features(&self) -> &FeatureSet<'g> {
  function platform_features (line 351) | pub fn platform_features(&self, build_platform: BuildPlatform) -> &Featu...
  function all_features (line 359) | pub fn all_features(&self) -> [(BuildPlatform, &FeatureSet<'g>); 2] {
  function target_direct_deps (line 369) | pub fn target_direct_deps(&self) -> &PackageSet<'g> {
  function host_direct_deps (line 376) | pub fn host_direct_deps(&self) -> &PackageSet<'g> {
  function platform_direct_deps (line 381) | pub fn platform_direct_deps(&self, build_platform: BuildPlatform) -> &Pa...
  function all_direct_deps (line 390) | pub fn all_direct_deps(&self) -> [(BuildPlatform, &PackageSet<'g>); 2] {
  function proc_macro_links (line 410) | pub fn proc_macro_links<'a>(&'a self) -> impl ExactSizeIterator<Item = P...
  function build_dep_links (line 427) | pub fn build_dep_links<'a>(&'a self) -> impl ExactSizeIterator<Item = Pa...
  function target_links (line 442) | pub fn target_links<'a>(&'a self) -> impl ExactSizeIterator<Item = Packa...
  function host_links (line 460) | pub fn host_links<'a>(&'a self) -> impl ExactSizeIterator<Item = Package...
  type BuildPlatform (line 480) | pub enum BuildPlatform {
    constant VALUES (line 496) | pub const VALUES: &'static [Self; 2] = &[BuildPlatform::Target, BuildP...
    method flip (line 499) | pub fn flip(self) -> Self {
    method fmt (line 508) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type CargoIntermediateSet (line 522) | pub enum CargoIntermediateSet<'g> {
  function target_host_sets (line 532) | pub fn target_host_sets(&self) -> (&FeatureSet<'g>, &FeatureSet<'g>) {

FILE: guppy/src/graph/cycles.rs
  type Cycles (line 272) | pub struct Cycles<'g> {
  function new (line 278) | pub(super) fn new(package_graph: &'g PackageGraph) -> Self {
  function is_cyclic (line 288) | pub fn is_cyclic(&self, a: &PackageId, b: &PackageId) -> Result<bool, Er...
  function all_cycles (line 303) | pub fn all_cycles(&self) -> impl DoubleEndedIterator<Item = Vec<&'g Pack...

FILE: guppy/src/graph/feature/build.rs
  type FeaturePetgraph (line 23) | pub(super) type FeaturePetgraph = Graph<FeatureNode, FeatureEdge, Direct...
  type FeatureEdgeReference (line 24) | pub(super) type FeatureEdgeReference<'g> = <&'g FeaturePetgraph as IntoE...
  type FeatureGraphBuildState (line 27) | pub(super) struct FeatureGraphBuildState {
    method new (line 37) | pub(super) fn new(package_graph: &PackageGraph) -> Self {
    method add_nodes (line 53) | pub(super) fn add_nodes(&mut self, package: PackageMetadata<'_>) {
    method end_nodes (line 67) | pub(super) fn end_nodes(&mut self) {
    method add_named_feature_edges (line 71) | pub(super) fn add_named_feature_edges(&mut self, metadata: PackageMeta...
    method nodes_for_named_feature_dep (line 102) | fn nodes_for_named_feature_dep(
    method make_named_feature_node (line 223) | fn make_named_feature_node(
    method make_named_feature_cross_edge (line 268) | fn make_named_feature_cross_edge(
    method make_full_conditional_link_impl (line 282) | fn make_full_conditional_link_impl(link: &PackageLink<'_>) -> Conditio...
    method add_dependency_edges (line 299) | pub(super) fn add_dependency_edges(&mut self, link: PackageLink<'_>) {
    method add_node (line 379) | fn add_node(&mut self, feature_id: FeatureNode) -> NodeIndex<FeatureIx> {
    method add_edges (line 386) | fn add_edges(
    method lookup_node (line 487) | fn lookup_node(&self, node: &FeatureNode) -> Option<NodeIndex<FeatureI...
    method build (line 491) | pub(super) fn build(self) -> FeatureGraphImpl {
  type FeatureReq (line 504) | struct FeatureReq<'g> {
  function new (line 514) | fn new(link: PackageLink<'g>) -> Self {
  function is_empty (line 527) | fn is_empty(&self) -> bool {
  function add_features (line 532) | fn add_features(
  function extend (line 564) | fn extend(
  function finish (line 579) | fn finish(self) -> impl Iterator<Item = (FeatureNode, FeatureEdge)> + us...
  type DependencyBuildState (line 595) | struct DependencyBuildState {
    method new (line 603) | fn new(package_edge_ix: EdgeIndex<PackageIx>) -> Self {
    method extend (line 612) | fn extend(&mut self, dep_kind: DependencyKind, status: &PlatformStatus...
    method is_empty (line 621) | fn is_empty(&self) -> bool {
    method finish (line 625) | fn finish(self) -> FeatureEdge {

FILE: guppy/src/graph/feature/cycles.rs
  type Cycles (line 21) | pub struct Cycles<'g> {
  function new (line 27) | pub(super) fn new(feature_graph: FeatureGraph<'g>) -> Self {
  function is_cyclic (line 35) | pub fn is_cyclic<'a>(
  function all_cycles (line 54) | pub fn all_cycles(&self) -> impl Iterator<Item = Vec<FeatureId<'g>>> + '...

FILE: guppy/src/graph/feature/feature_list.rs
  type FeatureList (line 22) | pub struct FeatureList<'g> {
  function new (line 29) | pub fn new(
  function package (line 40) | pub fn package(&self) -> &PackageMetadata<'g> {
  function contains (line 45) | pub fn contains(&self, label: FeatureLabel<'_>) -> bool {
  function has_base (line 53) | pub fn has_base(&self) -> bool {
  function has_named_feature (line 59) | pub fn has_named_feature(&self, feature_name: &str) -> bool {
  function has_optional_dependency (line 65) | pub fn has_optional_dependency(&self, dep_name: &str) -> bool {
  function labels (line 72) | pub fn labels(&self) -> &[FeatureLabel<'g>] {
  function named_features (line 79) | pub fn named_features(&self) -> impl Iterator<Item = &'g str> + '_ {
  function optional_deps (line 90) | pub fn optional_deps(&self) -> impl Iterator<Item = &'g str> + '_ {
  function iter (line 99) | pub fn iter<'a>(&'a self) -> Iter<'g, 'a> {
  function display_features (line 104) | pub fn display_features<'a>(&'a self) -> DisplayFeatures<'g, 'a> {
  function into_labels (line 111) | pub fn into_labels(self) -> Vec<FeatureLabel<'g>> {
  function fmt (line 117) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Item (line 126) | type Item = FeatureId<'g>;
  type IntoIter (line 127) | type IntoIter = IntoIter<'g>;
  method into_iter (line 129) | fn into_iter(self) -> Self::IntoIter {
  type Item (line 135) | type Item = FeatureId<'g>;
  type IntoIter (line 136) | type IntoIter = Iter<'g, 'a>;
  method into_iter (line 138) | fn into_iter(self) -> Self::IntoIter {
  type IntoIter (line 144) | pub struct IntoIter<'g> {
  function new (line 151) | pub fn new(feature_list: FeatureList<'g>) -> Self {
  type Item (line 160) | type Item = FeatureId<'g>;
  method next (line 162) | fn next(&mut self) -> Option<Self::Item> {
  type Iter (line 170) | pub struct Iter<'g, 'a> {
  function new (line 177) | pub fn new(feature_list: &'a FeatureList<'g>) -> Self {
  type Item (line 186) | type Item = FeatureId<'g>;
  method next (line 188) | fn next(&mut self) -> Option<Self::Item> {
  type DisplayFeatures (line 199) | pub struct DisplayFeatures<'g, 'a>(&'a [FeatureLabel<'g>]);
  function fmt (line 202) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function fmt (line 215) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: guppy/src/graph/feature/graph_impl.rs
  method feature_graph (line 56) | pub fn feature_graph(&self) -> FeatureGraph<'_> {
  method get_feature_graph (line 64) | pub(super) fn get_feature_graph(&self) -> &FeatureGraphImpl {
  type FeatureGraph (line 74) | pub struct FeatureGraph<'g> {
  function build_warnings (line 83) | pub fn build_warnings(&self) -> &'g [FeatureGraphWarning] {
  function package_graph (line 88) | pub fn package_graph(&self) -> &'g PackageGraph {
  function feature_count (line 95) | pub fn feature_count(&self) -> usize {
  function link_count (line 100) | pub fn link_count(&self) -> usize {
  function contains (line 105) | pub fn contains(&self, feature_id: impl Into<FeatureId<'g>>) -> bool {
  function metadata (line 111) | pub fn metadata(
  function all_features_for (line 125) | pub fn all_features_for(&self, package_id: &PackageId) -> Result<Feature...
  function is_default_feature (line 143) | pub fn is_default_feature<'a>(
  function depends_on (line 166) | pub fn depends_on<'a>(
  function directly_depends_on (line 183) | pub fn directly_depends_on<'a>(
  function cycles (line 198) | pub fn cycles(&self) -> Cycles<'g> {
  function verify (line 208) | pub fn verify(&self) -> Result<(), Error> {
  function sccs (line 229) | pub(super) fn sccs(&self) -> &'g Sccs<FeatureIx> {
  function metadata_impl (line 248) | fn metadata_impl(&self, feature_id: FeatureId<'g>) -> Option<&'g Feature...
  function metadata_for_ix (line 253) | pub(in crate::graph) fn metadata_for_ix(
  function metadata_for_node (line 261) | pub(super) fn metadata_for_node(&self, node: FeatureNode) -> Option<Feat...
  function metadata_impl_for_node (line 271) | fn metadata_impl_for_node(&self, node: &FeatureNode) -> Option<&'g Featu...
  function dep_graph (line 275) | pub(super) fn dep_graph(&self) -> &'g FeaturePetgraph {
  function edge_to_conditional_link (line 280) | pub(super) fn edge_to_conditional_link(
  function feature_ix_depends_on (line 304) | fn feature_ix_depends_on(
  function feature_ix_depends_on_no_conditional (line 312) | fn feature_ix_depends_on_no_conditional(
  function feature_ixs_for_package_ix (line 328) | pub(super) fn feature_ixs_for_package_ix(
  function feature_ixs_for_package_ixs (line 340) | pub(super) fn feature_ixs_for_package_ixs<I>(
  function feature_ixs_for_package_ixs_filtered (line 355) | pub(in crate::graph) fn feature_ixs_for_package_ixs_filtered<B>(
  function package_ix_for_feature_ix (line 373) | pub(in crate::graph) fn package_ix_for_feature_ix(
  function feature_ixs (line 382) | pub(super) fn feature_ixs<'a, B>(
  function feature_ix (line 395) | pub(super) fn feature_ix(
  type FeatureId (line 413) | pub struct FeatureId<'g> {
  function new (line 422) | pub fn new(package_id: &'g PackageId, label: FeatureLabel<'g>) -> Self {
  function named (line 428) | pub fn named(package_id: &'g PackageId, feature_name: &'g str) -> Self {
  function optional_dependency (line 436) | pub fn optional_dependency(package_id: &'g PackageId, dep_name: &'g str)...
  function base (line 444) | pub fn base(package_id: &'g PackageId) -> Self {
  function from_node (line 451) | pub(super) fn from_node(package_graph: &'g PackageGraph, node: &FeatureN...
  function node_to_feature (line 463) | pub(super) fn node_to_feature(
  function package_id (line 471) | pub fn package_id(&self) -> &'g PackageId {
  function label (line 476) | pub fn label(&self) -> FeatureLabel<'g> {
  function is_base (line 482) | pub fn is_base(&self) -> bool {
  function is_optional_dependency (line 488) | pub fn is_optional_dependency(self) -> bool {
  function is_named (line 494) | pub fn is_named(self) -> bool {
  function from (line 500) | fn from((package_id, label): (&'g PackageId, FeatureLabel<'g>)) -> Self {
  function fmt (line 535) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type FeatureLabel (line 542) | pub enum FeatureLabel<'g> {
  function kind (line 563) | pub fn kind(self) -> FeatureKind {
  function fmt (line 588) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type FeatureMetadata (line 599) | pub struct FeatureMetadata<'g> {
  function feature_id (line 609) | pub fn feature_id(&self) -> FeatureId<'g> {
  function package_id (line 614) | pub fn package_id(&self) -> &'g PackageId {
  function package (line 619) | pub fn package(&self) -> PackageMetadata<'g> {
  function label (line 627) | pub fn label(&self) -> FeatureLabel<'g> {
  function package_ix (line 636) | pub(in crate::graph) fn package_ix(&self) -> NodeIndex<PackageIx> {
  function feature_ix (line 641) | pub(in crate::graph) fn feature_ix(&self) -> NodeIndex<FeatureIx> {
  function fmt (line 647) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type FeatureGraphImpl (line 656) | pub(in crate::graph) struct FeatureGraphImpl {
    method new (line 669) | pub(super) fn new(package_graph: &PackageGraph) -> Self {
  type ConditionalLink (line 736) | pub struct ConditionalLink<'g> {
  function new (line 748) | pub(super) fn new(
  function from (line 770) | pub fn from(&self) -> FeatureMetadata<'g> {
  function to (line 779) | pub fn to(&self) -> FeatureMetadata<'g> {
  function endpoints (line 788) | pub fn endpoints(&self) -> (FeatureMetadata<'g>, FeatureMetadata<'g>) {
  function normal (line 793) | pub fn normal(&self) -> PlatformStatus<'g> {
  function build (line 798) | pub fn build(&self) -> PlatformStatus<'g> {
  function dev (line 803) | pub fn dev(&self) -> PlatformStatus<'g> {
  function status_for_kind (line 809) | pub fn status_for_kind(&self, kind: DependencyKind) -> PlatformStatus<'g> {
  function dev_only (line 819) | pub fn dev_only(&self) -> bool {
  function package_link (line 824) | pub fn package_link(&self) -> PackageLink<'g> {
  function edge_ix (line 835) | pub(super) fn edge_ix(&self) -> EdgeIndex<FeatureIx> {
  function package_edge_ix (line 840) | pub(in crate::graph) fn package_edge_ix(&self) -> EdgeIndex<PackageIx> {
  function fmt (line 846) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type FeatureNode (line 861) | pub(in crate::graph) struct FeatureNode {
    method new (line 868) | pub(in crate::graph) fn new(
    method base (line 879) | pub(in crate::graph) fn base(package_ix: NodeIndex<PackageIx>) -> Self {
    method optional_dep (line 886) | pub(in crate::graph) fn optional_dep(package_ix: NodeIndex<PackageIx>,...
    method named_feature (line 893) | pub(in crate::graph) fn named_feature(
    method from_id (line 903) | fn from_id(feature_graph: &FeatureGraph<'_>, id: FeatureId<'_>) -> Opt...
    method named_features (line 911) | pub(super) fn named_features(package: PackageMetadata<'_>) -> impl Ite...
    method optional_deps (line 921) | pub(super) fn optional_deps(package: PackageMetadata<'_>) -> impl Iter...
    method package_ix (line 931) | pub(in crate::graph) fn package_ix(&self) -> NodeIndex<PackageIx> {
    method package_id_and_feature_label (line 935) | pub(in crate::graph) fn package_id_and_feature_label<'g>(
  type FeatureEdge (line 951) | pub enum FeatureEdge {
  type ConditionalLinkImpl (line 1007) | pub struct ConditionalLinkImpl {
    method dev_only (line 1016) | fn dev_only(&self) -> bool {
  type FeatureMetadataImpl (line 1023) | pub(super) struct FeatureMetadataImpl {
  type FeatureKind (line 1031) | pub enum FeatureKind {
    method is_base (line 1050) | pub fn is_base(self) -> bool {
    method is_named (line 1056) | pub fn is_named(self) -> bool {
    method is_optional_dependency (line 1062) | pub fn is_optional_dependency(self) -> bool {

FILE: guppy/src/graph/feature/proptest_helpers.rs
  function proptest1_id_strategy (line 30) | pub fn proptest1_id_strategy(&self) -> impl Strategy<Value = FeatureId<'...
  function proptest1_set_strategy (line 40) | pub fn proptest1_set_strategy(&self) -> impl Strategy<Value = FeatureSet...

FILE: guppy/src/graph/feature/query.rs
  type FeatureFilter (line 28) | pub trait FeatureFilter<'g> {
    method accept (line 37) | fn accept(&mut self, graph: &FeatureGraph<'g>, feature_id: FeatureId<'...
  function accept (line 44) | fn accept(&mut self, graph: &FeatureGraph<'g>, feature_id: FeatureId<'g>...
  function accept (line 50) | fn accept(&mut self, graph: &FeatureGraph<'g>, feature_id: FeatureId<'g>...
  function accept (line 56) | fn accept(&mut self, graph: &FeatureGraph<'g>, feature_id: FeatureId<'g>...
  type FeatureFilterFn (line 63) | pub struct FeatureFilterFn<F>(F);
  function new (line 70) | pub fn new(f: F) -> Self {
  function accept (line 79) | fn accept(&mut self, graph: &FeatureGraph<'g>, feature_id: FeatureId<'g>...
  type StandardFeatures (line 89) | pub enum StandardFeatures {
    constant VALUES (line 102) | pub const VALUES: &'static [Self; 3] = &[
    method accept (line 110) | fn accept(&mut self, graph: &FeatureGraph<'g>, feature_id: FeatureId<'...
  function named_feature_filter (line 135) | pub fn named_feature_filter<'g: 'a, 'a>(
  function feature_id_filter (line 160) | pub fn feature_id_filter<'g: 'a, 'a>(
  type FeatureQuery (line 180) | pub struct FeatureQuery<'g> {
  function query_workspace (line 196) | pub fn query_workspace(&self, filter: impl FeatureFilter<'g>) -> Feature...
  function query_directed (line 206) | pub fn query_directed<'a>(
  function query_forward (line 220) | pub fn query_forward<'a>(
  function query_reverse (line 234) | pub fn query_reverse<'a>(
  function query_from_parts (line 245) | pub(in crate::graph) fn query_from_parts(
  function graph (line 263) | pub fn graph(&self) -> &FeatureGraph<'g> {
  function direction (line 268) | pub fn direction(&self) -> DependencyDirection {
  function initials (line 275) | pub fn initials<'a>(&'a self) -> impl ExactSizeIterator<Item = FeatureMe...
  function initial_packages (line 286) | pub fn initial_packages<'a>(&'a self) -> impl Iterator<Item = PackageMet...
  function starts_from_package (line 294) | pub fn starts_from_package(&self, package_id: &PackageId) -> Result<bool...
  function starts_from (line 302) | pub fn starts_from<'a>(&self, feature_id: impl Into<FeatureId<'a>>) -> R...
  function resolve (line 311) | pub fn resolve(self) -> FeatureSet<'g> {
  function resolve_with (line 317) | pub fn resolve_with(self, resolver: impl FeatureResolver<'g>) -> Feature...
  function resolve_with_fn (line 323) | pub fn resolve_with_fn(
  function starts_from_package_ix (line 334) | pub(in crate::graph) fn starts_from_package_ix(
  type FeatureResolver (line 346) | pub trait FeatureResolver<'g> {
    method accept (line 348) | fn accept(&mut self, query: &FeatureQuery<'g>, link: ConditionalLink<'...
  function accept (line 355) | fn accept(&mut self, query: &FeatureQuery<'g>, link: ConditionalLink<'g>...
  function accept (line 361) | fn accept(&mut self, query: &FeatureQuery<'g>, link: ConditionalLink<'g>...
  function accept (line 367) | fn accept(&mut self, query: &FeatureQuery<'g>, link: ConditionalLink<'g>...
  type ResolverFn (line 373) | struct ResolverFn<F>(pub F);
  function accept (line 379) | fn accept(&mut self, query: &FeatureQuery<'g>, link: ConditionalLink<'g>...

FILE: guppy/src/graph/feature/resolve.rs
  function resolve_all (line 32) | pub fn resolve_all(&self) -> FeatureSet<'g> {
  function resolve_none (line 40) | pub fn resolve_none(&self) -> FeatureSet<'g> {
  function resolve_ids (line 50) | pub fn resolve_ids<'a>(
  type FeatureSet (line 68) | pub struct FeatureSet<'g> {
  function fmt (line 74) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function new (line 84) | pub(super) fn new(query: FeatureQuery<'g>) -> Self {
  function with_resolver (line 92) | pub(super) fn with_resolver(
  function from_included (line 131) | pub(in crate::graph) fn from_included(
  function graph (line 142) | pub fn graph(&self) -> &FeatureGraph<'g> {
  function len (line 147) | pub fn len(&self) -> usize {
  function is_empty (line 152) | pub fn is_empty(&self) -> bool {
  function contains (line 159) | pub fn contains<'a>(&self, feature_id: impl Into<FeatureId<'a>>) -> Resu...
  function contains_package (line 168) | pub fn contains_package(&self, package_id: &PackageId) -> Result<bool, E...
  function to_feature_query (line 179) | pub fn to_feature_query(&self, direction: DependencyDirection) -> Featur...
  function union (line 200) | pub fn union(&self, other: &Self) -> Self {
  function intersection (line 215) | pub fn intersection(&self, other: &Self) -> Self {
  function difference (line 230) | pub fn difference(&self, other: &Self) -> Self {
  function symmetric_difference (line 247) | pub fn symmetric_difference(&self, other: &Self) -> Self {
  function filter (line 266) | pub fn filter(
  function partition (line 296) | pub fn partition(
  function filter_partition (line 329) | pub fn filter_partition(
  function features_for (line 360) | pub fn features_for(&self, package_id: &PackageId) -> Result<Option<Feat...
  function to_package_set (line 367) | pub fn to_package_set(&self) -> PackageSet<'g> {
  function into_cargo_set (line 391) | pub fn into_cargo_set(self, opts: &CargoOptions<'_>) -> Result<CargoSet<...
  function feature_ids (line 407) | pub fn feature_ids<'a>(
  function features (line 426) | pub fn features<'a>(
  function packages_with_features (line 448) | pub fn packages_with_features<'a>(
  function root_ids (line 478) | pub fn root_ids<'a>(
  function root_features (line 501) | pub fn root_features<'a>(
  function conditional_links (line 523) | pub fn conditional_links<'a>(
  function features_for_package_impl (line 541) | fn features_for_package_impl<'a>(
  function ixs_unordered (line 568) | pub(in crate::graph) fn ixs_unordered(
  function contains_package_ix (line 576) | pub(in crate::graph) fn contains_package_ix(&self, package_ix: NodeIndex...
  function links (line 584) | pub fn links<'a>(
  method eq (line 609) | fn eq(&self, other: &Self) -> bool {

FILE: guppy/src/graph/feature/weak.rs
  type WeakDependencies (line 17) | pub(super) struct WeakDependencies {
    method new (line 22) | pub(super) fn new() -> Self {
    method insert (line 28) | pub(super) fn insert(&mut self, edge_ix: EdgeIndex<PackageIx>) -> Weak...
    method get (line 32) | pub(super) fn get(&self, edge_ix: EdgeIndex<PackageIx>) -> Option<Weak...
    method new_buffer_states (line 37) | pub(super) fn new_buffer_states<'g, F>(&self, accept_fn: F) -> WeakBuf...
  type WeakIndex (line 48) | pub struct WeakIndex(pub(super) usize);
  type WeakBufferStates (line 51) | pub(super) struct WeakBufferStates<'g, 'a, F> {
  function new (line 62) | fn new(deps: &'a WeakDependencies, len: usize, accept_fn: F) -> Self {
  function track (line 72) | pub(super) fn track(
  type SingleBufferState (line 133) | pub(super) enum SingleBufferState<'g> {
  method default (line 139) | fn default() -> Self {
  type SingleBufferVec (line 144) | type SingleBufferVec<'g> = Vec<(ConditionalLink<'g>, FeatureEdgeReferenc...

FILE: guppy/src/graph/graph_impl.rs
  type PackageGraph (line 42) | pub struct PackageGraph {
    method from_command (line 63) | pub fn from_command(command: &mut MetadataCommand) -> Result<Self, Err...
    method from_metadata (line 68) | pub fn from_metadata(metadata: CargoMetadata) -> Result<Self, Error> {
    method from_json (line 82) | pub fn from_json(json: impl AsRef<str>) -> Result<Self, Error> {
    method verify (line 89) | pub fn verify(&self) -> Result<(), Error> {
    method workspace (line 228) | pub fn workspace(&self) -> Workspace<'_> {
    method package_ids (line 236) | pub fn package_ids(&self) -> impl ExactSizeIterator<Item = &PackageId> {
    method packages (line 241) | pub fn packages(&self) -> impl ExactSizeIterator<Item = PackageMetadat...
    method metadata (line 249) | pub fn metadata(&self, package_id: &PackageId) -> Result<PackageMetada...
    method package_count (line 258) | pub fn package_count(&self) -> usize {
    method link_count (line 268) | pub fn link_count(&self) -> usize {
    method new_depends_cache (line 275) | pub fn new_depends_cache(&self) -> DependsCache<'_> {
    method depends_on (line 287) | pub fn depends_on(&self, package_a: &PackageId, package_b: &PackageId)...
    method directly_depends_on (line 297) | pub fn directly_depends_on(
    method cycles (line 310) | pub fn cycles(&self) -> Cycles<'_> {
    method dep_links_ixs_directed (line 320) | fn dep_links_ixs_directed(
    method link_between_ixs (line 330) | fn link_between_ixs(
    method sccs (line 341) | pub(super) fn sccs(&self) -> &Sccs<PackageIx> {
    method invalidate_caches (line 358) | pub fn invalidate_caches(&mut self) {
    method dep_graph (line 366) | pub(super) fn dep_graph(&self) -> &Graph<PackageId, PackageLinkImpl, D...
    method edge_ref_to_link (line 371) | pub(super) fn edge_ref_to_link<'g>(
    method edge_ix_to_link (line 385) | pub(super) fn edge_ix_to_link(&self, edge_ix: EdgeIndex<PackageIx>) ->...
    method package_ixs (line 400) | pub(super) fn package_ixs<'g, 'a, B>(
    method package_ix (line 415) | pub(super) fn package_ix(&self, package_id: &PackageId) -> Result<Node...
  type PackageGraphData (line 56) | pub(super) struct PackageGraphData {
    method package_ids (line 422) | pub fn package_ids(&self) -> impl ExactSizeIterator<Item = &PackageId> {
    method metadata_impl (line 431) | pub(super) fn metadata_impl(&self, package_id: &PackageId) -> Option<&...
  type DependsCache (line 440) | pub struct DependsCache<'g> {
  function new (line 450) | pub fn new(package_graph: &'g PackageGraph) -> Self {
  function depends_on (line 461) | pub fn depends_on(
  type Workspace (line 483) | pub struct Workspace<'g> {
  function root (line 490) | pub fn root(&self) -> &'g Utf8Path {
  function target_directory (line 495) | pub fn target_directory(&self) -> &'g Utf8Path {
  function build_directory (line 504) | pub fn build_directory(&self) -> Option<&'g Utf8Path> {
  function default_member_ids (line 515) | pub fn default_member_ids(&self) -> impl ExactSizeIterator<Item = &'g Pa...
  function default_members (line 527) | pub fn default_members(&self) -> impl ExactSizeIterator<Item = PackageMe...
  function member_count (line 536) | pub fn member_count(&self) -> usize {
  function contains_name (line 541) | pub fn contains_name(&self, name: impl AsRef<str>) -> bool {
  function contains_path (line 546) | pub fn contains_path(&self, path: impl AsRef<Utf8Path>) -> bool {
  function iter (line 551) | pub fn iter(&self) -> impl ExactSizeIterator<Item = PackageMetadata<'g>>...
  function iter_by_path (line 557) | pub fn iter_by_path(
  function iter_by_name (line 570) | pub fn iter_by_name(
  function member_ids (line 582) | pub fn member_ids(&self) -> impl ExactSizeIterator<Item = &'g PackageId>...
  function member_by_path (line 589) | pub fn member_by_path(&self, path: impl AsRef<Utf8Path>) -> Result<Packa...
  function members_by_paths (line 603) | pub fn members_by_paths<B>(
  function member_by_name (line 619) | pub fn member_by_name(&self, name: impl AsRef<str>) -> Result<PackageMet...
  function members_by_names (line 633) | pub fn members_by_names<B>(
  function metadata_table (line 650) | pub fn metadata_table(&self) -> &'g JsonValue {
  function par_iter (line 665) | pub fn par_iter(&self) -> impl ParallelIterator<Item = PackageMetadata<'...
  function par_iter_by_path (line 673) | pub fn par_iter_by_path(
  function par_iter_by_name (line 692) | pub fn par_iter_by_name(
  type WorkspaceImpl (line 707) | pub(super) struct WorkspaceImpl {
  type PackageMetadata (line 727) | pub struct PackageMetadata<'g> {
  function fmt (line 733) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function new (line 744) | pub(super) fn new(graph: &'g PackageGraph, inner: &'g PackageMetadataImp...
  function id (line 749) | pub fn id(&self) -> &'g PackageId {
  function graph (line 754) | pub fn graph(&self) -> &'g PackageGraph {
  function to_package_query (line 761) | pub fn to_package_query(&self, direction: DependencyDirection) -> Packag...
  function to_package_set (line 767) | pub fn to_package_set(&self) -> PackageSet<'g> {
  function to_feature_set (line 774) | pub fn to_feature_set(&self, features: impl FeatureFilter<'g>) -> Featur...
  function direct_links_directed (line 784) | pub fn direct_links_directed(
  function direct_links (line 792) | pub fn direct_links(&self) -> impl Iterator<Item = PackageLink<'g>> + 'g...
  function reverse_direct_links (line 798) | pub fn reverse_direct_links(&self) -> impl Iterator<Item = PackageLink<'...
  function link_between (line 808) | pub fn link_between(
  function link_to (line 820) | pub fn link_to(&self, to: &PackageId) -> Result<Option<PackageLink<'g>>,...
  function link_from (line 828) | pub fn link_from(&self, from: &PackageId) -> Result<Option<PackageLink<'...
  function name (line 839) | pub fn name(&self) -> &'g str {
  function version (line 846) | pub fn version(&self) -> &'g Version {
  function authors (line 853) | pub fn authors(&self) -> &'g [String] {
  function description (line 860) | pub fn description(&self) -> Option<&'g str> {
  function license (line 868) | pub fn license(&self) -> Option<&'g str> {
  function license_file (line 876) | pub fn license_file(&self) -> Option<&'g Utf8Path> {
  function source (line 883) | pub fn source(&self) -> PackageSource<'g> {
  function in_workspace (line 890) | pub fn in_workspace(&self) -> bool {
  function manifest_path (line 897) | pub fn manifest_path(&self) -> &'g Utf8Path {
  function categories (line 906) | pub fn categories(&self) -> &'g [String] {
  function keywords (line 913) | pub fn keywords(&self) -> &'g [String] {
  function readme (line 921) | pub fn readme(&self) -> Option<&'g Utf8Path> {
  function repository (line 928) | pub fn repository(&self) -> Option<&'g str> {
  function homepage (line 935) | pub fn homepage(&self) -> Option<&'g str> {
  function documentation (line 942) | pub fn documentation(&self) -> Option<&'g str> {
  function edition (line 949) | pub fn edition(&self) -> &'g str {
  function metadata_table (line 957) | pub fn metadata_table(&self) -> &'g JsonValue {
  function links (line 966) | pub fn links(&self) -> Option<&'g str> {
  function publish (line 973) | pub fn publish(&self) -> PackagePublish<'g> {
  function default_run (line 983) | pub fn default_run(&self) -> Option<&'g str> {
  function minimum_rust_version (line 993) | pub fn minimum_rust_version(&self) -> Option<&'g Version> {
  function rust_version (line 1011) | pub fn rust_version(&self) -> Option<&'g VersionReq> {
  function build_targets (line 1020) | pub fn build_targets(&self) -> impl Iterator<Item = BuildTarget<'g>> + u...
  function build_target (line 1025) | pub fn build_target(&self, id: &BuildTargetId<'_>) -> Option<BuildTarget...
  function is_proc_macro (line 1036) | pub fn is_proc_macro(&self) -> bool {
  function has_build_script (line 1050) | pub fn has_build_script(&self) -> bool {
  function has_default_feature (line 1059) | pub fn has_default_feature(&self) -> bool {
  function default_feature_id (line 1064) | pub fn default_feature_id(&self) -> FeatureId<'g> {
  function named_features (line 1077) | pub fn named_features(&self) -> impl Iterator<Item = &'g str> + 'g + use...
  function package_ix (line 1087) | pub(super) fn package_ix(&self) -> NodeIndex<PackageIx> {
  function link_between_impl (line 1091) | fn link_between_impl(
  function direct_links_impl (line 1103) | fn direct_links_impl(
  function get_feature_idx (line 1110) | pub(super) fn get_feature_idx(&self, label: FeatureLabel<'_>) -> Option<...
  function feature_idx_to_label (line 1126) | pub(super) fn feature_idx_to_label(&self, idx: FeatureIndexInPackage) ->...
  function all_feature_nodes (line 1148) | pub(super) fn all_feature_nodes(&self) -> impl Iterator<Item = FeatureNo...
  function named_features_full (line 1164) | pub(super) fn named_features_full(
  function optional_deps_full (line 1183) | pub(super) fn optional_deps_full(
  type FeatureIndexInPackage (line 1202) | pub(crate) enum FeatureIndexInPackage {
  method eq (line 1210) | fn eq(&self, other: &Self) -> bool {
  type PackageMetadataImpl (line 1220) | pub(crate) struct PackageMetadataImpl {
  type PackageSource (line 1259) | pub enum PackageSource<'g> {
  constant CRATES_IO_REGISTRY (line 1283) | pub const CRATES_IO_REGISTRY: &'static str =
  function new (line 1286) | pub(super) fn new(inner: &'g PackageSourceImpl) -> Self {
  function is_workspace (line 1296) | pub fn is_workspace(&self) -> bool {
  function is_path (line 1302) | pub fn is_path(&self) -> bool {
  function is_external (line 1307) | pub fn is_external(&self) -> bool {
  function is_crates_io (line 1312) | pub fn is_crates_io(&self) -> bool {
  function is_local (line 1318) | pub fn is_local(&self) -> bool {
  function workspace_path (line 1326) | pub fn workspace_path(&self) -> Option<&'g Utf8Path> {
  function local_path (line 1337) | pub fn local_path(&self) -> Option<&'g Utf8Path> {
  function external_source (line 1346) | pub fn external_source(&self) -> Option<&'g str> {
  function parse_external (line 1359) | pub fn parse_external(&self) -> Option<ExternalSource<'g>> {
  function fmt (line 1368) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type ExternalSource (line 1385) | pub enum ExternalSource<'g> {
  constant REGISTRY_PLUS (line 1530) | pub const REGISTRY_PLUS: &'static str = "registry+";
  constant SPARSE_PLUS (line 1535) | pub const SPARSE_PLUS: &'static str = "sparse+";
  constant GIT_PLUS (line 1540) | pub const GIT_PLUS: &'static str = "git+";
  constant BRANCH_EQ (line 1545) | pub const BRANCH_EQ: &'static str = "?branch=";
  constant TAG_EQ (line 1550) | pub const TAG_EQ: &'static str = "?tag=";
  constant REV_EQ (line 1555) | pub const REV_EQ: &'static str = "?rev=";
  constant CRATES_IO_URL (line 1560) | pub const CRATES_IO_URL: &'static str = "https://github.com/rust-lang/cr...
  function new (line 1565) | pub fn new(source: &'g str) -> Option<Self> {
  function fmt (line 1622) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type GitReq (line 1649) | pub enum GitReq<'g> {
  type PackageSourceImpl (line 1691) | pub(super) enum PackageSourceImpl {
  type PackagePublish (line 1704) | pub enum PackagePublish<'g> {
  function new (line 1721) | pub(super) fn new(inner: &'g PackagePublishImpl) -> Self {
  constant CRATES_IO (line 1730) | pub const CRATES_IO: &'static str = "crates-io";
  function is_unrestricted (line 1743) | pub fn is_unrestricted(&self) -> bool {
  function can_publish_to (line 1767) | pub fn can_publish_to(&self, registry: impl AsRef<str>) -> bool {
  function can_publish_to_crates_io (line 1776) | pub fn can_publish_to_crates_io(&self) -> bool {
  function is_never (line 1791) | pub fn is_never(&self) -> bool {
  type PackagePublishImpl (line 1801) | pub(super) enum PackagePublishImpl {
  type PackageLink (line 1813) | pub struct PackageLink<'g> {
  function new (line 1824) | pub(super) fn new(
  function from (line 1849) | pub fn from(&self) -> PackageMetadata<'g> {
  function to (line 1854) | pub fn to(&self) -> PackageMetadata<'g> {
  function endpoints (line 1859) | pub fn endpoints(&self) -> (PackageMetadata<'g>, PackageMetadata<'g>) {
  function dep_name (line 1864) | pub fn dep_name(&self) -> &'g str {
  function resolved_name (line 1870) | pub fn resolved_name(&self) -> &'g str {
  function version_req (line 1886) | pub fn version_req(&self) -> &'g VersionReq {
  function registry (line 1894) | pub fn registry(&self) -> Option<&'g str> {
  function path (line 1902) | pub fn path(&self) -> Option<&'g Utf8Path> {
  function normal (line 1907) | pub fn normal(&self) -> DependencyReq<'g> {
  function build (line 1914) | pub fn build(&self) -> DependencyReq<'g> {
  function dev (line 1921) | pub fn dev(&self) -> DependencyReq<'g> {
  function req_for_kind (line 1929) | pub fn req_for_kind(&self, kind: DependencyKind) -> DependencyReq<'g> {
  function dev_only (line 1939) | pub fn dev_only(&self) -> bool {
  function edge_ix (line 1949) | pub(super) fn edge_ix(&self) -> EdgeIndex<PackageIx> {
  function as_inner_ptrs (line 1955) | pub fn as_inner_ptrs(&self) -> PackageLinkPtrs {
  type PackageLinkPtrs (line 1967) | pub struct PackageLinkPtrs {
  type PackageLinkImpl (line 1974) | pub(crate) struct PackageLinkImpl {
    method dev_only (line 1987) | fn dev_only(&self) -> bool {
  type DependencyReq (line 1997) | pub struct DependencyReq<'g> {
  function is_present (line 2006) | pub fn is_present(&self) -> bool {
  function status (line 2015) | pub fn status(&self) -> EnabledStatus<'g> {
  function default_features (line 2022) | pub fn default_features(&self) -> EnabledStatus<'g> {
  function no_default_features (line 2032) | pub fn no_default_features(&self) -> EnabledStatus<'g> {
  function features (line 2039) | pub fn features(&self) -> impl Iterator<Item = &'g str> + use<'g> {
  function feature_status (line 2051) | pub fn feature_status(&self, feature: &str) -> EnabledStatus<'g> {
  type EnabledStatus (line 2097) | pub struct EnabledStatus<'g> {
  function new (line 2105) | pub(super) fn new(required: &'g PlatformStatusImpl, optional: &'g Platfo...
  function is_never (line 2113) | pub fn is_never(&self) -> bool {
  function required_on (line 2121) | pub fn required_on(&self, platform_spec: &PlatformSpec) -> EnabledTernary {
  function enabled_on (line 2130) | pub fn enabled_on(&self, platform_spec: &PlatformSpec) -> EnabledTernary {
  function required_status (line 2138) | pub fn required_status(&self) -> PlatformStatus<'g> {
  function optional_status (line 2143) | pub fn optional_status(&self) -> PlatformStatus<'g> {
  type NamedFeatureDep (line 2149) | pub(super) enum NamedFeatureDep {
    method named_feature (line 2161) | pub(super) fn named_feature(feature_name: impl Into<String>) -> Self {
    method optional_dependency (line 2166) | pub(super) fn optional_dependency(dep_name: impl Into<String>) -> Self {
    method dep_named_feature (line 2171) | pub(super) fn dep_named_feature(
    method fmt (line 2185) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type DependencyReqImpl (line 2208) | pub(super) struct DependencyReqImpl {
    method all_features (line 2214) | fn all_features(&self) -> impl Iterator<Item = &str> {
    method enabled (line 2220) | pub(super) fn enabled(&self) -> EnabledStatus<'_> {
    method default_features (line 2224) | pub(super) fn default_features(&self) -> EnabledStatus<'_> {
    method no_default_features (line 2228) | pub(super) fn no_default_features(&self) -> EnabledStatus<'_> {
    method feature_status (line 2232) | pub(super) fn feature_status(&self, feature: &str) -> EnabledStatus<'_> {
    method make_status (line 2244) | fn make_status(
  type DepRequiredOrOptional (line 2255) | pub(super) struct DepRequiredOrOptional {
    method all_features (line 2263) | pub(super) fn all_features(&self) -> impl Iterator<Item = &str> {

FILE: guppy/src/graph/mod.rs
  type DependencyDirection (line 45) | pub enum DependencyDirection {
    method opposite (line 54) | pub fn opposite(self) -> Self {
    method from (line 63) | fn from(direction: Direction) -> Self {
  method from (line 72) | fn from(direction: DependencyDirection) -> Self {
  type PackageIx (line 82) | struct PackageIx(u32);
  type FeatureIx (line 86) | struct FeatureIx(u32);
  type GraphSpec (line 120) | trait GraphSpec {
    type Node (line 127) | type Node = PackageId;
    type Edge (line 128) | type Edge = PackageLinkImpl;
    type Ix (line 129) | type Ix = PackageIx;
    type Node (line 140) | type Node = feature::FeatureNode;
    type Edge (line 141) | type Edge = feature::FeatureEdge;
    type Ix (line 142) | type Ix = FeatureIx;
  type FeatureGraphSpec (line 137) | pub(crate) enum FeatureGraphSpec {}
  function cargo_version_matches (line 148) | fn cargo_version_matches(req: &VersionReq, version: &Version) -> bool {

FILE: guppy/src/graph/proptest_helpers.rs
  method proptest1_id_strategy (line 34) | pub fn proptest1_id_strategy(&self) -> impl Strategy<Value = &PackageId> {
  method proptest1_link_strategy (line 49) | pub fn proptest1_link_strategy(&self) -> impl Strategy<Value = PackageLi...
  method proptest1_resolver_strategy (line 63) | pub fn proptest1_resolver_strategy(&self) -> impl Strategy<Value = Prop0...
  method proptest1_cargo_options_strategy (line 71) | pub fn proptest1_cargo_options_strategy(&self) -> impl Strategy<Value = ...
  function proptest1_name_strategy (line 119) | pub fn proptest1_name_strategy(&self) -> impl Strategy<Value = &'g str> ...
  function proptest1_id_strategy (line 131) | pub fn proptest1_id_strategy(&self) -> impl Strategy<Value = &'g Package...
  function name_list (line 137) | fn name_list(&self) -> &'g [Box<str>] {
  type Prop010Resolver (line 149) | pub struct Prop010Resolver {
    method new (line 155) | fn new(included_edges: FixedBitSet) -> Self {
    method check_depends_on (line 164) | pub fn check_depends_on(&mut self, check: bool) {
    method accept_link (line 169) | pub fn accept_link(&self, link: PackageLink<'_>) -> bool {
    method accept (line 175) | fn accept(&mut self, query: &PackageQuery<'g>, link: PackageLink<'g>) ...
  function fixedbitset_strategy (line 192) | pub(super) fn fixedbitset_strategy(len: usize) -> impl Strategy<Value = ...

FILE: guppy/src/graph/query.rs
  type PackageQuery (line 22) | pub struct PackageQuery<'g> {
  method query_workspace (line 39) | pub fn query_workspace(&self) -> PackageQuery<'_> {
  method query_workspace_paths (line 47) | pub fn query_workspace_paths(
  method query_workspace_names (line 69) | pub fn query_workspace_names(
  method query_directed (line 90) | pub fn query_directed<'g, 'a>(
  method query_forward (line 104) | pub fn query_forward<'g, 'a>(
  method query_reverse (line 117) | pub fn query_reverse<'g, 'a>(
  method query_from_parts (line 127) | pub(super) fn query_from_parts(
  function graph (line 145) | pub fn graph(&self) -> &'g PackageGraph {
  function direction (line 150) | pub fn direction(&self) -> DependencyDirection {
  function initials (line 157) | pub fn initials<'a>(&'a self) -> impl ExactSizeIterator<Item = PackageMe...
  function starts_from (line 169) | pub fn starts_from(&self, package_id: &PackageId) -> Result<bool, Error> {
  function to_feature_query (line 176) | pub fn to_feature_query(&self, filter: impl FeatureFilter<'g>) -> Featur...
  function resolve (line 188) | pub fn resolve(self) -> PackageSet<'g> {
  function resolve_with (line 194) | pub fn resolve_with(self, resolver: impl PackageResolver<'g>) -> Package...
  function resolve_with_fn (line 200) | pub fn resolve_with_fn(

FILE: guppy/src/graph/query_core.rs
  type QueryParams (line 17) | pub(super) enum QueryParams<G: GraphSpec> {
  function direction (line 23) | pub(super) fn direction(&self) -> DependencyDirection {
  function has_initial (line 31) | pub(super) fn has_initial(&self, initial: NodeIndex<G::Ix>) -> bool {
  function initials (line 38) | pub(super) fn initials(&self) -> &[NodeIndex<G::Ix>] {
  method clone (line 50) | fn clone(&self) -> Self {
  function fmt (line 62) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function all_visit_map (line 70) | pub(super) fn all_visit_map<G, Ix>(graph: G) -> (FixedBitSet, usize)
  function reachable_map (line 82) | pub(super) fn reachable_map<G, Ix>(
  function reachable_map_buffered_filter (line 106) | pub(super) fn reachable_map_buffered_filter<G, Ix>(

FILE: guppy/src/graph/resolve.rs
  method resolve_all (line 36) | pub fn resolve_all(&self) -> PackageSet<'_> {
  method resolve_none (line 44) | pub fn resolve_none(&self) -> PackageSet<'_> {
  method resolve_ids (line 56) | pub fn resolve_ids<'a>(
  method resolve_workspace (line 69) | pub fn resolve_workspace(&self) -> PackageSet<'_> {
  method resolve_workspace_paths (line 86) | pub fn resolve_workspace_paths(
  method resolve_workspace_names (line 110) | pub fn resolve_workspace_names(
  method resolve_package_name (line 132) | pub fn resolve_package_name(&self, name: impl AsRef<str>) -> PackageSet<...
  type PackageSet (line 157) | pub struct PackageSet<'g> {
  function new (line 165) | pub(super) fn new(query: PackageQuery<'g>) -> Self {
  function from_included (line 173) | pub(super) fn from_included(graph: &'g PackageGraph, included: impl Into...
  function with_resolver (line 180) | pub(super) fn with_resolver(
  function len (line 196) | pub fn len(&self) -> usize {
  function is_empty (line 201) | pub fn is_empty(&self) -> bool {
  function contains (line 208) | pub fn contains(&self, package_id: &PackageId) -> Result<bool, Error> {
  function to_package_query (line 215) | pub fn to_package_query(&self, direction: DependencyDirection) -> Packag...
  function union (line 236) | pub fn union(&self, other: &Self) -> Self {
  function intersection (line 251) | pub fn intersection(&self, other: &Self) -> Self {
  function difference (line 266) | pub fn difference(&self, other: &Self) -> Self {
  function symmetric_difference (line 283) | pub fn symmetric_difference(&self, other: &Self) -> Self {
  function filter (line 302) | pub fn filter(
  function partition (line 332) | pub fn partition(
  function filter_partition (line 365) | pub fn filter_partition(
  function to_feature_set (line 396) | pub fn to_feature_set(&self, filter: impl FeatureFilter<'g>) -> FeatureS...
  function package_ids (line 417) | pub fn package_ids<'a>(
  function ixs (line 427) | pub(super) fn ixs(&'g self, direction: DependencyDirection) -> Topo<'g, ...
  function packages (line 438) | pub fn packages<'a>(
  function root_ids (line 458) | pub fn root_ids<'a>(
  function root_packages (line 480) | pub fn root_packages<'a>(
  function links (line 510) | pub fn links<'a>(
  function display_dot (line 523) | pub fn display_dot<'a, V: PackageDotVisitor + 'g>(
  function ixs_unordered (line 537) | pub(super) fn ixs_unordered(&self) -> impl Iterator<Item = NodeIndex<Pac...
  function contains_ix (line 541) | pub(super) fn contains_ix(&self, package_ix: NodeIndex<PackageIx>) -> bo...
  method eq (line 547) | fn eq(&self, other: &Self) -> bool {
  type PackageResolver (line 556) | pub trait PackageResolver<'g> {
    method accept (line 561) | fn accept(&mut self, query: &PackageQuery<'g>, link: PackageLink<'g>) ...
  function accept (line 568) | fn accept(&mut self, query: &PackageQuery<'g>, link: PackageLink<'g>) ->...
  function accept (line 574) | fn accept(&mut self, query: &PackageQuery<'g>, link: PackageLink<'g>) ->...
  function accept (line 580) | fn accept(&mut self, query: &PackageQuery<'g>, link: PackageLink<'g>) ->...
  type ResolverFn (line 585) | pub(super) struct ResolverFn<F>(pub(super) F);
  function accept (line 591) | fn accept(&mut self, query: &PackageQuery<'g>, link: PackageLink<'g>) ->...
  type PackageDotVisitor (line 597) | pub trait PackageDotVisitor {
    method visit_package (line 600) | fn visit_package(&self, package: PackageMetadata<'_>, f: &mut DotWrite...
    method visit_link (line 604) | fn visit_link(&self, link: PackageLink<'_>, f: &mut DotWrite<'_, '_>) ...
  type VisitorWrap (line 607) | struct VisitorWrap<'g, V> {
  function new (line 613) | fn new(graph: &'g PackageGraph, inner: V) -> Self {
  function visit_node (line 624) | fn visit_node(&self, node: NR, f: &mut DotWrite<'_, '_>) -> fmt::Result {
  function visit_edge (line 632) | fn visit_edge(&self, edge: ER, f: &mut DotWrite<'_, '_>) -> fmt::Result {

FILE: guppy/src/graph/resolve_core.rs
  type ResolveCore (line 28) | pub(super) struct ResolveCore<G> {
  function new (line 35) | pub(super) fn new(
  function all_nodes (line 50) | pub(super) fn all_nodes(graph: &Graph<G::Node, G::Edge, Directed, G::Ix>...
  function empty (line 59) | pub(super) fn empty() -> Self {
  function with_edge_filter (line 68) | pub(super) fn with_edge_filter<'g>(
  function with_buffered_edge_filter (line 93) | pub(super) fn with_buffered_edge_filter<'g>(
  function from_included (line 115) | pub(super) fn from_included<T: Into<FixedBitSet>>(included: T) -> Self {
  function len (line 125) | pub(super) fn len(&self) -> usize {
  function is_empty (line 129) | pub(super) fn is_empty(&self) -> bool {
  function contains (line 133) | pub(super) fn contains(&self, ix: NodeIndex<G::Ix>) -> bool {
  function union_with (line 141) | pub(super) fn union_with(&mut self, other: &Self) {
  function intersect_with (line 146) | pub(super) fn intersect_with(&mut self, other: &Self) {
  function difference (line 152) | pub(super) fn difference(&self, other: &Self) -> Self {
  function symmetric_difference_with (line 160) | pub(super) fn symmetric_difference_with(&mut self, other: &Self) {
  function invalidate_caches (line 165) | pub(super) fn invalidate_caches(&mut self) {
  function roots (line 170) | pub(super) fn roots(
  function topo (line 187) | pub(super) fn topo<'g>(
  function links (line 218) | pub(super) fn links<'g>(
  method eq (line 248) | fn eq(&self, other: &Self) -> bool {
  type Topo (line 268) | pub(super) struct Topo<'g, G: GraphSpec> {
  type Item (line 275) | type Item = NodeIndex<G::Ix>;
  method next (line 277) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 288) | fn size_hint(&self) -> (usize, Option<usize>) {
  method len (line 294) | fn len(&self) -> usize {
  type Links (line 302) | pub(super) struct Links<'g, G: GraphSpec> {
  type Item (line 311) | type Item = (NodeIndex<G::Ix>, NodeIndex<G::Ix>, EdgeIndex<G::Ix>);
  method next (line 313) | fn next(&mut self) -> Option<Self::Item> {

FILE: guppy/src/graph/summaries.rs
  function to_summary (line 28) | pub fn to_summary(&self, opts: &CargoOptions<'_>) -> Result<Summary, Err...
  function to_package_map (line 48) | fn to_package_map(
  method metadata_by_summary_id (line 91) | pub fn metadata_by_summary_id(
  function to_summary_id (line 122) | pub fn to_summary_id(&self) -> SummaryId {
  type CargoOptionsSummary (line 137) | pub struct CargoOptionsSummary {
    method new (line 170) | pub fn new(
    method to_cargo_options (line 208) | pub fn to_cargo_options<'g>(
  type InitialsPlatformSummary (line 240) | pub enum InitialsPlatformSummary {
  method from (line 257) | fn from(s: InitialsPlatformSummary) -> Self {
  type FeaturesOnlySummary (line 280) | pub struct FeaturesOnlySummary {
  function to_summary_source (line 297) | pub fn to_summary_source(&self) -> SummarySource {
  function eq (line 313) | fn eq(&self, summary_source: &SummarySource) -> bool {
  function parse_old_metadata (line 332) | fn parse_old_metadata() {

FILE: guppy/src/graph/summaries/package_set.rs
  type PackageSetSummary (line 104) | pub struct PackageSetSummary {
    method new (line 137) | pub fn new(package_set: &PackageSet<'_>) -> Self {
    method from_package_ids (line 149) | pub fn from_package_ids<'a>(
    method is_empty (line 164) | pub fn is_empty(&self) -> bool {
    method to_package_set (line 173) | pub fn to_package_set<'g>(
    method to_package_set_registry (line 191) | pub fn to_package_set_registry<'g, 'a>(
    method to_package_set_impl (line 208) | fn to_package_set_impl<'g, 'a>(
  function to_summary (line 130) | pub fn to_summary(&self) -> PackageSetSummary {
  type ThirdPartySummary (line 231) | pub struct ThirdPartySummary {
    method fmt (line 244) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method deserialize (line 395) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  type ThirdPartySource (line 258) | pub enum ThirdPartySource {
    method fmt (line 283) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type GitReqSummary (line 312) | pub enum GitReqSummary {
    method new (line 336) | pub fn new(git_req: GitReq<'_>) -> Self {
    method as_git_req (line 346) | pub fn as_git_req(&self) -> GitReq<'_> {
  function to_summary (line 330) | pub fn to_summary(self) -> GitReqSummary {
  type ThirdPartySelectFields (line 361) | struct ThirdPartySelectFields<'a> {
  method serialize (line 506) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  function serialize_opt_path_fwdslash (line 544) | fn serialize_opt_path_fwdslash<S>(
  function version_req_is_star (line 557) | fn version_req_is_star(req: &VersionReq) -> bool {
  type PackageMatcher (line 566) | struct PackageMatcher<'a> {
  function new (line 576) | fn new(
  function store_is_match (line 621) | fn store_is_match(&mut self, metadata: PackageMetadata<'_>) -> bool {
  function finish (line 663) | fn finish(self, graph: &PackageGraph, error_message: impl Into<String>) ...
  function source_matches (line 719) | fn source_matches(
  function valid (line 785) | fn valid() {
  function invalid (line 918) | fn invalid() {
  function format_input (line 991) | fn format_input(input: &str) -> String {

FILE: guppy/src/metadata_command.rs
  type MetadataCommand (line 25) | pub struct MetadataCommand {
    method new (line 34) | pub fn new() -> Self {
    method cargo_path (line 44) | pub fn cargo_path(&mut self, path: impl Into<PathBuf>) -> &mut Self {
    method manifest_path (line 54) | pub fn manifest_path(&mut self, path: impl Into<PathBuf>) -> &mut Self {
    method current_dir (line 62) | pub fn current_dir(&mut self, path: impl Into<PathBuf>) -> &mut Self {
    method no_deps (line 76) | pub fn no_deps(&mut self) -> &mut Self {
    method other_options (line 91) | pub fn other_options(
    method env (line 102) | pub fn env(
    method cargo_command (line 113) | pub fn cargo_command(&self) -> Command {
    method exec (line 118) | pub fn exec(&self) -> Result<CargoMetadata, Error> {
    method build_graph (line 124) | pub fn build_graph(&self) -> Result<PackageGraph, Error> {
  type Error (line 133) | type Error = Error;
  method try_from (line 135) | fn try_from(command: MetadataCommand) -> Result<Self, Self::Error> {
  type Error (line 141) | type Error = Error;
  method try_from (line 143) | fn try_from(command: &'a MetadataCommand) -> Result<Self, Self::Error> {
  type CargoMetadata (line 159) | pub struct CargoMetadata(pub(crate) cargo_metadata::Metadata);
    method parse_json (line 163) | pub fn parse_json(json: impl AsRef<str>) -> Result<Self, Error> {
    method serialize (line 169) | pub fn serialize(&self, writer: &mut impl io::Write) -> Result<(), Err...
    method build_graph (line 174) | pub fn build_graph(self) -> Result<PackageGraph, Error> {
  type Error (line 180) | type Error = Error;
  method try_from (line 182) | fn try_from(metadata: CargoMetadata) -> Result<Self, Self::Error> {

FILE: guppy/src/package_id.rs
  type PackageId (line 9) | pub struct PackageId {
    method new (line 16) | pub fn new(s: impl Into<Box<str>>) -> Self {
    method from_metadata (line 20) | pub(super) fn from_metadata(id: cargo_metadata::PackageId) -> Self {
    method repr (line 28) | pub fn repr(&self) -> &str {
    method fmt (line 34) | fn fmt(&self, f: &mut fmt::Formatter) -> std::fmt::Result {
    method eq (line 40) | fn eq(&self, other: &&PackageId) -> bool {
  function eq (line 46) | fn eq(&self, other: &PackageId) -> bool {

FILE: guppy/src/petgraph_support/dfs.rs
  function dfs_next_buffered_filter (line 13) | pub fn dfs_next_buffered_filter<N, VM, G>(
  type BufferedEdgeFilter (line 51) | pub trait BufferedEdgeFilter<G>
    method filter (line 58) | fn filter(&mut self, edge: G::EdgeRef) -> Self::Iter;
  type Iter (line 67) | type Iter = T::Iter;
  function filter (line 70) | fn filter(&mut self, edge: G::EdgeRef) -> Self::Iter {
  type SimpleEdgeFilterFn (line 76) | pub struct SimpleEdgeFilterFn<F>(pub F);
  type Iter (line 83) | type Iter = Option<G::EdgeRef>;
  function filter (line 86) | fn filter(&mut self, edge: G::EdgeRef) -> Self::Iter {
  type BufferedEdgeFilterFn (line 92) | pub struct BufferedEdgeFilterFn<F>(pub F);
  type Iter (line 100) | type Iter = I;
  function filter (line 103) | fn filter(&mut self, edge: G::EdgeRef) -> Self::Iter {
  type ReversedBufferedFilter (line 109) | pub struct ReversedBufferedFilter<T>(pub T);
  type Iter (line 116) | type Iter =
  function filter (line 119) | fn filter(&mut self, edge: <Reversed<G> as IntoEdgeReferences>::EdgeRef)...
  type ReversedEdgeReferences (line 127) | pub struct ReversedEdgeReferences<I> {
  type Item (line 135) | type Item = ReversedEdgeReference<I::Item>;
  method next (line 138) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 146) | fn size_hint(&self) -> (usize, Option<usize>) {
  function horrible_transmute (line 151) | unsafe fn horrible_transmute<A, B>(a: A) -> B {

FILE: guppy/src/petgraph_support/dot.rs
  type DotVisitor (line 13) | pub trait DotVisitor<NR, ER> {
    method visit_node (line 16) | fn visit_node(&self, node: NR, f: &mut DotWrite<'_, '_>) -> fmt::Result;
    method visit_edge (line 20) | fn visit_edge(&self, edge: ER, f: &mut DotWrite<'_, '_>) -> fmt::Result;
  type DisplayVisitor (line 31) | pub struct DisplayVisitor;
    method visit_node (line 40) | fn visit_node(&self, node: NR, f: &mut DotWrite<'_, '_>) -> fmt::Result {
    method visit_edge (line 44) | fn visit_edge(&self, edge: ER, f: &mut DotWrite<'_, '_>) -> fmt::Result {
  function visit_node (line 53) | fn visit_node(&self, node: NR, f: &mut DotWrite<'_, '_>) -> fmt::Result {
  function visit_edge (line 57) | fn visit_edge(&self, edge: ER, f: &mut DotWrite<'_, '_>) -> fmt::Result {
  type DotFmt (line 63) | pub struct DotFmt<G, V> {
  function new (line 76) | pub fn new(graph: G, visitor: V) -> Self {
  function fmt (line 81) | pub fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function fmt (line 119) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type DotWrite (line 125) | pub struct DotWrite<'a, 'b> {
  function new (line 131) | fn new(f: &'a mut fmt::Formatter<'b>) -> Self {
  function set_escape_backslashes (line 142) | pub fn set_escape_backslashes(&mut self, escape_backslashes: bool) {
  function write_fmt (line 153) | pub fn write_fmt(&mut self, args: fmt::Arguments<'_>) -> fmt::Result {
  method write_str (line 160) | fn write_str(&mut self, s: &str) -> fmt::Result {
  method write_char (line 167) | fn write_char(&mut self, c: char) -> fmt::Result {
  function graph_type (line 180) | fn graph_type<G: GraphProp>(graph: G) -> &'static str {
  function edge_str (line 188) | fn edge_str<G: GraphProp>(graph: G) -> &'static str {

FILE: guppy/src/petgraph_support/edge_ref.rs
  type GraphEdgeRef (line 11) | pub trait GraphEdgeRef<'a, E, Ix: IndexType>: EdgeRef {
    method into_edge_reference (line 12) | fn into_edge_reference(self) -> EdgeReference<'a, E, Ix>;
  function into_edge_reference (line 16) | fn into_edge_reference(self) -> EdgeReference<'a, E, Ix> {
  function into_edge_reference (line 24) | fn into_edge_reference(self) -> EdgeReference<'a, E, Ix> {

FILE: guppy/src/petgraph_support/mod.rs
  function edge_triple (line 20) | pub fn edge_triple<ER: EdgeRef>(edge_ref: ER) -> (ER::NodeId, ER::NodeId...
  type IxBitSet (line 25) | pub struct IxBitSet(pub FixedBitSet);
    method with_capacity (line 29) | pub(crate) fn with_capacity(bits: usize) -> Self {
    method insert_node_ix (line 34) | pub(crate) fn insert_node_ix<Ix: IndexType>(&mut self, bit: NodeIndex<...
    method from_iter (line 46) | fn from_iter<T: IntoIterator<Item = NodeIndex<Ix>>>(iter: T) -> Self {
    method from_iter (line 52) | fn from_iter<T: IntoIterator<Item = EdgeIndex<Ix>>>(iter: T) -> Self {
    method extend (line 58) | fn extend<T: IntoIterator<Item = NodeIndex<Ix>>>(&mut self, iter: T) {
  method from (line 40) | fn from(ix_set: IxBitSet) -> Self {

FILE: guppy/src/petgraph_support/scc.rs
  type Sccs (line 16) | pub(crate) struct Sccs<Ix: IndexType> {
  function new (line 25) | pub fn new<G>(graph: G, mut scc_sorter: impl FnMut(&mut Vec<NodeIndex<Ix...
  function is_same_scc (line 55) | pub fn is_same_scc(&self, a: NodeIndex<Ix>, b: NodeIndex<Ix>) -> bool {
  function multi_sccs (line 66) | pub fn multi_sccs(&self) -> impl DoubleEndedIterator<Item = &[NodeIndex<...
  function externals (line 72) | pub fn externals<'a, G>(&'a self, graph: G) -> impl Iterator<Item = Node...
  function node_iter (line 123) | pub fn node_iter(&self, direction: Direction) -> NodeIter<'_, Ix> {
  type NodeIter (line 133) | pub(crate) struct NodeIter<'a, Ix> {
  function direction (line 141) | pub fn direction(&self) -> Direction {
  type Item (line 147) | type Item = NodeIndex<Ix>;
  method next (line 149) | fn next(&mut self) -> Option<NodeIndex<Ix>> {

FILE: guppy/src/petgraph_support/topo.rs
  type TopoWithCycles (line 16) | pub struct TopoWithCycles<Ix> {
  function new (line 24) | pub fn new<G>(graph: G) -> Self
  function sort_nodes (line 90) | pub fn sort_nodes(&self, nodes: &mut [NodeIndex<Ix>]) {
  function topo_ix (line 95) | pub fn topo_ix(&self, node_ix: NodeIndex<Ix>) -> usize {
  function possibly_cyclic_graph (line 121) | fn possibly_cyclic_graph() -> impl Strategy<Value = Graph<(), ()>> {
  function check_consistency (line 148) | fn check_consistency(topo: &TopoWithCycles<u32>, n: usize) {

FILE: guppy/src/petgraph_support/walk.rs
  type EdgeDfs (line 9) | pub(crate) struct EdgeDfs<E, N, VM> {
  function new (line 24) | pub(crate) fn new<G>(graph: G, initials: impl IntoIterator<Item = N>) ->...
  function new_single (line 48) | pub(crate) fn new_single<G>(graph: G, start: N) -> Self
  function next (line 56) | pub fn next<G>(&mut self, graph: G) -> Option<(N, N, E)>
  type Item (line 72) | type Item = (G::NodeId, G::NodeId, G::EdgeId);
  function walk_next (line 74) | fn walk_next(&mut self, context: G) -> Option<Self::Item> {

FILE: guppy/src/platform/platform_eval.rs
  type PlatformStatus (line 12) | pub enum PlatformStatus<'g> {
  function new (line 27) | pub(crate) fn new(specs: &'g PlatformStatusImpl) -> Self {
  function is_always (line 43) | pub fn is_always(&self) -> bool {
  function is_never (line 51) | pub fn is_never(&self) -> bool {
  function is_present (line 59) | pub fn is_present(&self) -> bool {
  function enabled_on (line 67) | pub fn enabled_on(&self, platform_spec: &PlatformSpec) -> EnabledTernary {
  type EnabledTernary (line 91) | pub enum EnabledTernary {
    method new (line 106) | fn new(x: Option<bool>) -> Self {
    method is_known (line 115) | pub fn is_known(self) -> bool {
  type Output (line 125) | type Output = Self;
  method bitand (line 127) | fn bitand(self, rhs: Self) -> Self::Output {
  type Output (line 140) | type Output = Self;
  method bitor (line 142) | fn bitor(self, rhs: Self) -> Self {
  type PlatformEval (line 157) | pub struct PlatformEval<'g> {
  function eval (line 165) | pub fn eval(&self, platform: &Platform) -> EnabledTernary {
  function target_specs (line 182) | pub fn target_specs(&self) -> &'g [TargetSpec] {
  type PlatformStatusImpl (line 188) | pub(crate) enum PlatformStatusImpl {
    method is_never (line 196) | pub(crate) fn is_never(&self) -> bool {
    method extend (line 203) | pub(crate) fn extend(&mut self, other: &PlatformStatusImpl) {
    method add_spec (line 219) | pub(crate) fn add_spec(&mut self, spec: Option<&TargetSpec>) {
  method default (line 237) | fn default() -> Self {

FILE: guppy/src/platform/platform_spec.rs
  type PlatformSpec (line 19) | pub enum PlatformSpec {
    method current (line 59) | pub fn current() -> Result<Self, TargetSpecError> {
    method build_target (line 68) | pub fn build_target() -> Result<Self, TargetSpecError> {
    method from (line 75) | fn from(platform: T) -> Self {

FILE: guppy/src/platform/proptest_helpers.rs
  method strategy (line 16) | pub fn strategy(platform: impl Strategy<Value = Platform>) -> impl Strat...
  type Parameters (line 26) | type Parameters = ();
  type Strategy (line 27) | type Strategy = BoxedStrategy<Self>;
  method arbitrary_with (line 29) | fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {

FILE: guppy/src/platform/summaries.rs
  type PlatformSpecSummary (line 12) | pub enum PlatformSpecSummary {
    method new (line 110) | pub fn new(platform_spec: &PlatformSpec) -> Self {
    method to_platform_spec (line 123) | pub fn to_platform_spec(&self) -> Result<PlatformSpec, TargetSpecError> {
    method is_any (line 134) | pub fn is_any(&self) -> bool {
    method deserialize (line 166) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  method serialize (line 146) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  type Spec (line 161) | struct Spec {
  type PlatformSpecSummaryDeserialize (line 202) | enum PlatformSpecSummaryDeserialize {

FILE: guppy/src/sorted_set.rs
  type SortedSet (line 8) | pub struct SortedSet<T> {
  type _SortedSetCovariant (line 12) | type _SortedSetCovariant<'a> = SortedSet<&'a ()>;
  function new (line 20) | pub fn new(v: impl Into<Vec<T>>) -> Self {
  function contains (line 30) | pub fn contains(&self, item: &T) -> bool {
  function as_slice (line 35) | pub fn as_slice(&self) -> &[T] {
  function into_inner (line 40) | pub fn into_inner(self) -> Box<[T]> {
  function from_iter (line 49) | fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
  type Target (line 56) | type Target = [T];
  method deref (line 58) | fn deref(&self) -> &Self::Target {
  function fmt (line 64) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: guppy/src/unit_tests/dot_tests.rs
  function dot_fmt (line 12) | fn dot_fmt() {
  type NoEscapeDisplayVisitor (line 65) | pub struct NoEscapeDisplayVisitor;
    method visit_node (line 74) | fn visit_node(&self, node: NR, f: &mut DotWrite<'_, '_>) -> fmt::Result {
    method visit_edge (line 79) | fn visit_edge(&self, edge: ER, f: &mut DotWrite<'_, '_>) -> fmt::Result {

FILE: guppy/tests/graph-tests/cargo_set_tests.rs
  type PackageResolverForTesting (line 12) | struct PackageResolverForTesting<'a, 'g> {
  function new (line 23) | fn new() -> Self {
  function with_filter (line 30) | fn with_filter(f: &'a impl Fn(PackageLink<'g>) -> bool) -> Self {
  function link_to_string (line 38) | fn link_to_string(link: &PackageLink) -> String {
  function links_to_strings (line 48) | fn links_to_strings<'g>(links: impl IntoIterator<Item = PackageLink<'g>>...
  function accept (line 58) | fn accept(&mut self, _query: &PackageQuery<'g>, link: PackageLink<'g>) -...
  function cargo_set_with_resolver (line 64) | fn cargo_set_with_resolver<'g>(
  function cargo_set_package_names (line 82) | fn cargo_set_package_names(cargo_set: &CargoSet) -> Vec<String> {
  function test_package_resolver_visits (line 94) | fn test_package_resolver_visits() {
  function test_package_resolver_filtering_normal_links_on_target (line 253) | fn test_package_resolver_filtering_normal_links_on_target() {
  function test_package_resolver_filtering_build_links_on_target (line 293) | fn test_package_resolver_filtering_build_links_on_target() {
  function test_package_resolver_filtering_links_on_host (line 326) | fn test_package_resolver_filtering_links_on_host() {

FILE: guppy/tests/graph-tests/feature_helpers.rs
  function assert_features_for_package (line 9) | pub(super) fn assert_features_for_package(

FILE: guppy/tests/graph-tests/graph_tests.rs
  function metadata_default_members (line 24) | fn metadata_default_members() {
  function metadata1 (line 51) | fn metadata1() {
  function metadata2 (line 169) | fn metadata2() {
  function metadata_dups (line 189) | fn metadata_dups() {
  function metadata_cycle1 (line 197) | fn metadata_cycle1() {
  function metadata_cycle2 (line 205) | fn metadata_cycle2() {
  function metadata_cycle_features (line 213) | fn metadata_cycle_features() {
  function metadata_cycle1_windows (line 261) | fn metadata_cycle1_windows() {
  function metadata_cycle1_windows_different_drives (line 286) | fn metadata_cycle1_windows_different_drives() {
  function windows_metadata_path_normalization (line 321) | fn windows_metadata_path_normalization() {
  function metadata_targets1 (line 373) | fn metadata_targets1() {
  function metadata_build_targets1 (line 460) | fn metadata_build_targets1() {
  function metadata_proc_macro1 (line 468) | fn metadata_proc_macro1() {
  function metadata_libra (line 497) | fn metadata_libra() {
  function metadata_libra_f0091a4 (line 505) | fn metadata_libra_f0091a4() {
  function metadata_libra_9ffd93b (line 513) | fn metadata_libra_9ffd93b() {
  function mnemos_b3b4da9 (line 595) | fn mnemos_b3b4da9() {
  function hyper_util_7afb1ed (line 604) | fn hyper_util_7afb1ed() {
  function metadata_guppy_44b62fa (line 618) | fn metadata_guppy_44b62fa() {
  type NameVisitor (line 638) | struct NameVisitor;
  method visit_package (line 641) | fn visit_package(&self, package: PackageMetadata<'_>, f: &mut DotWrite<'...
  method visit_link (line 645) | fn visit_link(&self, link: PackageLink<'_>, f: &mut DotWrite<'_, '_>) ->...

FILE: guppy/tests/graph-tests/invalid_tests.rs
  function optional_dev_dep (line 6) | fn optional_dev_dep() {
  function duplicate_workspace_names (line 14) | fn duplicate_workspace_names() {
  function invalid_default_member (line 22) | fn invalid_default_member() {
  function build_targets_empty_kinds (line 30) | fn build_targets_empty_kinds() {
  function build_targets_non_bin (line 38) | fn build_targets_non_bin() {
  function build_targets_duplicate_lib (line 46) | fn build_targets_duplicate_lib() {
  function named_feature_self_loop (line 56) | fn named_feature_self_loop() {
  function proc_macro_mixed_kinds (line 81) | fn proc_macro_mixed_kinds() {
  function workspace_member_different_drive (line 119) | fn workspace_member_different_drive() {
  function assert_invalid (line 126) | fn assert_invalid(json: &str, search_str: &str) {

FILE: guppy/tests/graph-tests/proptest_helpers.rs
  function depends_on (line 270) | pub(super) fn depends_on<'g, G: GraphAssert<'g>>(
  function depends_on_same_id (line 288) | pub(super) fn depends_on_same_id<'g, G: GraphAssert<'g>>(graph: G, query...
  function link_order (line 304) | pub(super) fn link_order(
  function roots (line 334) | pub(super) fn roots<'g, G: GraphAssert<'g>>(
  function resolve_contains (line 383) | pub(super) fn resolve_contains<'g, G: GraphAssert<'g>>(
  type ResolveTree (line 407) | pub(super) enum ResolveTree<G: GraphAssert<'static>> {
  function strategy (line 420) | pub(super) fn strategy(
  function resolve_ops (line 451) | pub(super) fn resolve_ops<G: GraphAssert<'static>>(graph: G, resolve_tre...
  function resolve_ops_impl (line 465) | fn resolve_ops_impl<G: GraphAssert<'static>>(
  function package_feature_set_roundtrip (line 516) | pub(super) fn package_feature_set_roundtrip(
  function feature_set_props (line 557) | pub(super) fn feature_set_props(feature_set: FeatureSet<'_>, direction: ...
  function query_starts_from (line 594) | pub(super) fn query_starts_from<'g, G: GraphAssert<'g>>(

FILE: guppy/tests/graph-tests/weak_namespaced.rs
  function default_features (line 16) | fn default_features() {
  function named_feature_single_dep (line 27) | fn named_feature_single_dep() {
  function named_feature_same_as_dep_plus_feature (line 45) | fn named_feature_same_as_dep_plus_feature() {
  function enabled_non_weak_feature (line 71) | fn enabled_non_weak_feature() {
  function named_feature_does_not_enable_dep_with_same_name (line 95) | fn named_feature_does_not_enable_dep_with_same_name() {
  function enabled_weak_feature_1 (line 114) | fn enabled_weak_feature_1() {
  function enabled_weak_feature_2 (line 141) | fn enabled_weak_feature_2() {
  function enabled_weak_feature_3 (line 166) | fn enabled_weak_feature_3() {
  function disabled_weak_feature_1 (line 192) | fn disabled_weak_feature_1() {
  function disabled_weak_feature_2 (line 215) | fn disabled_weak_feature_2() {
  function platform_not_matched_features (line 239) | fn platform_not_matched_features() {
  function platform_matched_features (line 279) | fn platform_matched_features() {
  function test_feature_presence (line 331) | fn test_feature_presence() {
  function test_edge_upgrades (line 362) | fn test_edge_upgrades() {
  function feature_set_fn (line 404) | fn feature_set_fn(named_features: &[&str]) -> FeatureSet<'static> {
  function make_linux_cargo_set (line 415) | fn make_linux_cargo_set(feature_set: FeatureSet<'static>) -> CargoSet<'s...
  function make_windows_cargo_set (line 419) | fn make_windows_cargo_set(feature_set: FeatureSet<'static>) -> CargoSet<...
  function make_cargo_set (line 423) | fn make_cargo_set(feature_set: FeatureSet<'static>, triple: &'static str...

FILE: internal-tools/benchmarks/benches/package_graph.rs
  function construct_benchmarks (line 13) | pub fn construct_benchmarks(c: &mut Criterion) {
  function query_benchmarks (line 17) | pub fn query_benchmarks(c: &mut Criterion) {
  function make_package_graph (line 94) | fn make_package_graph() -> PackageGraph {
  function make_package_name_hashmap (line 102) | fn make_package_name_hashmap<'g>(
  function id_pairs_strategy (line 116) | fn id_pairs_strategy(graph: &PackageGraph) -> impl Strategy<Value = Vec<...
  function ids_directions_strategy (line 124) | fn ids_directions_strategy(

FILE: internal-tools/cargo-compare/src/check.rs
  type CheckOpts (line 21) | pub struct CheckOpts {
    method exec (line 41) | pub fn exec(self, ctx: &GlobalContext) -> Result<()> {

FILE: internal-tools/cargo-compare/src/common.rs
  type GuppyCargoCommon (line 38) | pub struct GuppyCargoCommon {
    method resolve_cargo (line 60) | pub fn resolve_cargo(&self, ctx: &GlobalContext<'_>) -> anyhow::Result...
    method resolve_guppy (line 135) | pub fn resolve_guppy(&self, ctx: &GlobalContext<'_>) -> Result<Feature...
    method make_target_platform (line 184) | pub fn make_target_platform(&self) -> Result<Platform> {
    method strategy (line 194) | pub fn strategy<'a>(
    method cargo_make_gctx (line 217) | fn cargo_make_gctx(&self, _ctx: &GlobalContext) -> anyhow::Result<carg...
    method cargo_discover_root (line 232) | fn cargo_discover_root(&self, gctx: &cargo::GlobalContext) -> anyhow::...
    method cargo_make_workspace (line 244) | fn cargo_make_workspace<'gctx>(
    method cargo_make_cli_features (line 253) | fn cargo_make_cli_features(&self) -> CliFeatures {
    method guppy_current_platform (line 267) | fn guppy_current_platform(&self) -> Result<Platform> {
  type FeatureMap (line 273) | pub struct FeatureMap {
    method from_guppy (line 279) | fn from_guppy(target_features: &FeatureSet<'_>, host_features: &Featur...
    method feature_set_to_map (line 288) | fn feature_set_to_map(feature_set: &FeatureSet<'_>) -> BTreeMap<Packag...
  function anyhow_to_eyre (line 302) | pub(crate) fn anyhow_to_eyre<T>(x: anyhow::Result<T>) -> Result<T> {
  function query_target_features (line 314) | fn query_target_features(triple: &str) -> Result<TargetFeatures> {

FILE: internal-tools/cargo-compare/src/diff.rs
  type DiffOpts (line 21) | pub struct DiffOpts {
    method exec (line 31) | pub fn exec(self, ctx: &GlobalContext) -> Result<()> {
    method compute_diff (line 42) | pub fn compute_diff<'g>(self, ctx: &'g GlobalContext) -> Result<Target...
  type TargetHostDiff (line 67) | pub struct TargetHostDiff<'g> {
  function new (line 74) | pub fn new(target_diff: FeatureDiff<'g>, host_diff: FeatureDiff<'g>) -> ...
  function any_diff (line 83) | pub fn any_diff(&self) -> bool {
  function fmt (line 91) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type FeatureDiff (line 101) | pub struct FeatureDiff<'g> {
  function any_diff (line 110) | pub fn any_diff(&self) -> bool {
  function fmt (line 116) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

FILE: internal-tools/cargo-compare/src/lib.rs
  type CargoCompare (line 25) | pub struct CargoCompare {
    method exec (line 32) | pub fn exec(self) -> Result<()> {
  type Command (line 51) | enum Command {
  type GlobalContext (line 60) | pub struct GlobalContext<'g> {
  function new (line 66) | pub fn new(temp_home: bool, graph: &'g PackageGraph) -> Result<Self> {
  function home_dir (line 78) | pub fn home_dir(&self) -> &Path {
  function graph (line 85) | pub fn graph(&self) -> &'g PackageGraph {

FILE: internal-tools/cargo-compare/src/main.rs
  function main (line 8) | fn main() -> Result<()> {

FILE: internal-tools/cargo-compare/src/tests/fixtures.rs
  type Fixture (line 21) | pub struct Fixture {
    method new (line 46) | pub fn new(
    method graph (line 153) | pub fn graph(&self) -> &PackageGraph {
    method num_proptests (line 158) | pub fn num_proptests(&self) -> u32 {
    method common_strategy (line 176) | pub fn common_strategy(&self) -> impl Strategy<Value = GuppyCargoCommo...

FILE: internal-tools/cargo-compare/src/tests/proptest_helpers.rs
  function compare (line 34) | pub(super) fn compare(graph: &PackageGraph, common: GuppyCargoCommon) ->...

FILE: internal-tools/cargo-compare/src/type_conversions.rs
  type ToGuppy (line 8) | pub trait ToGuppy {
    method to_guppy (line 11) | fn to_guppy(&self) -> Self::Guppy;
    type Guppy (line 15) | type Guppy = guppy::PackageId;
    method to_guppy (line 17) | fn to_guppy(&self) -> Self::Guppy {
    type Guppy (line 24) | type Guppy = BTreeSet<String>;
    method to_guppy (line 26) | fn to_guppy(&self) -> Self::Guppy {

FILE: internal-tools/fixture-manager/src/context.rs
  type ContextImpl (line 8) | pub trait ContextImpl<'g> {
    method dir_name (line 13) | fn dir_name(fixture: &'g JsonFixture) -> Utf8PathBuf;
    method file_name (line 14) | fn file_name(fixture: &'g JsonFixture, item: &Self::IterItem) -> String;
    method iter (line 16) | fn iter(
    method parse_existing (line 21) | fn parse_existing(path: &Utf8Path, contents: String) -> Result<Self::E...
    method is_changed (line 22) | fn is_changed(item: &Self::IterItem, existing: &Self::Existing) -> bool;
    method diff (line 23) | fn diff(
    method write_to_string (line 29) | fn write_to_string(
  type ContextDiff (line 36) | pub trait ContextDiff<'a> {}
  type GenerateContext (line 38) | pub struct GenerateContext<'g, T: ContextImpl<'g>> {
  function new (line 46) | pub fn new(fixture: &'g JsonFixture, args: &T::IterArgs, skip_existing: ...
  type Item (line 66) | type Item = Result<ContextItem<'g, T>>;
  method next (line 68) | fn next(&mut self) -> Option<Self::Item> {
  type ContextItem (line 96) | pub struct ContextItem<'g, T: ContextImpl<'g>> {
  function path (line 104) | pub fn path(&self) -> &Utf8Path {
  function is_changed (line 108) | pub fn is_changed(&self) -> bool {
  function diff (line 118) | pub fn diff(&self) -> String {
  function write_to_path (line 122) | pub fn write_to_path(&self) -> Result<()> {
  function read_contents (line 138) | fn read_contents(file: &Utf8Path) -> Result<Option<String>> {

FILE: internal-tools/fixture-manager/src/hakari_toml.rs
  type HakariTomlContext (line 13) | pub struct HakariTomlContext;
    type IterArgs (line 16) | type IterArgs = usize;
    type IterItem (line 17) | type IterItem = (usize, HakariTomlItem<'g>);
    type Existing (line 18) | type Existing = HakariCargoToml;
    method dir_name (line 20) | fn dir_name(fixture: &'g JsonFixture) -> Utf8PathBuf {
    method file_name (line 28) | fn file_name(fixture: &'g JsonFixture, &(count, _): &Self::IterItem) -...
    method iter (line 32) | fn iter(
    method parse_existing (line 72) | fn parse_existing(path: &Utf8Path, contents: String) -> Result<Self::E...
    method is_changed (line 76) | fn is_changed((_, item): &Self::IterItem, existing: &Self::Existing) -...
    method diff (line 80) | fn diff(
    method write_to_string (line 114) | fn write_to_string(
  type HakariTomlItem (line 137) | pub struct HakariTomlItem<'g> {

FILE: internal-tools/fixture-manager/src/lib.rs
  type FixtureManager (line 18) | pub struct FixtureManager {
    method exec (line 25) | pub fn exec(self) -> Result<()> {
  type Command (line 35) | enum Command {
  function list (line 45) | pub fn list() -> Result<()> {
  type GenerateSummariesOpts (line 54) | pub struct GenerateSummariesOpts {
    constant DEFAULT_COUNT_STR (line 65) | pub const DEFAULT_COUNT_STR: &'static str = "8";
    method default_count (line 68) | pub fn default_count() -> usize {
    method exec (line 122) | pub fn exec(self) -> Result<()> {
  type GenerateHakariOpts (line 76) | pub struct GenerateHakariOpts {
    constant DEFAULT_COUNT_STR (line 87) | pub const DEFAULT_COUNT_STR: &'static str = "4";
    method default_count (line 90) | pub fn default_count() -> usize {
    method exec (line 128) | pub fn exec(self) -> Result<()> {
  type GenerateOpts (line 98) | pub struct GenerateOpts {
    method exec (line 134) | pub fn exec<'g, T: ContextImpl<'g>>(self, args: T::IterArgs) -> Result...
  type GenerateMode (line 115) | pub enum GenerateMode {

FILE: internal-tools/fixture-manager/src/main.rs
  function main (line 8) | fn main() -> Result<()> {

FILE: internal-tools/fixture-manager/src/summaries.rs
  type SummaryContext (line 17) | pub struct SummaryContext;
    type IterArgs (line 20) | type IterArgs = usize;
    type IterItem (line 21) | type IterItem = (usize, Summary);
    type Existing (line 22) | type Existing = Summary;
    method dir_name (line 24) | fn dir_name(fixture: &'g JsonFixture) -> Utf8PathBuf {
    method file_name (line 32) | fn file_name(fixture: &'g JsonFixture, &(count, _): &Self::IterItem) -...
    method iter (line 36) | fn iter(
    method parse_existing (line 78) | fn parse_existing(_: &Utf8Path, contents: String) -> Result<Self::Exis...
    method is_changed (line 82) | fn is_changed((_, summary): &Self::IterItem, existing: &Self::Existing...
    method diff (line 87) | fn diff(
    method write_to_string (line 104) | fn write_to_string(

FILE: internal-tools/fixture-manager/tests/unchanged_tests.rs
  function summaries_unchanged (line 13) | fn summaries_unchanged() -> Result<()> {
  function hakari_unchanged (line 44) | fn hakari_unchanged() -> Result<()> {

FILE: internal-tools/proptest-ext/src/lib.rs
  type ValueGenerator (line 17) | pub struct ValueGenerator {
    method new (line 23) | pub fn new() -> Self {
    method deterministic (line 33) | pub fn deterministic() -> Self {
    method from_seed (line 43) | pub fn from_seed(seed: impl Hash) -> Self {
    method partial_clone (line 62) | pub fn partial_clone(&mut self) -> Self {
    method generate (line 72) | pub fn generate<S: Strategy>(&mut self, strategy: S) -> S::Value {

FILE: target-spec-miette/src/imp.rs
  type IntoMietteDiagnostic (line 12) | pub trait IntoMietteDiagnostic {
    method into_diagnostic (line 19) | fn into_diagnostic(self) -> Self::IntoDiagnostic;
    type IntoDiagnostic (line 23) | type IntoDiagnostic = Box<dyn Diagnostic + Send + Sync + 'static>;
    method into_diagnostic (line 25) | fn into_diagnostic(self) -> Self::IntoDiagnostic {
    type IntoDiagnostic (line 79) | type IntoDiagnostic = ExpressionParseDiagnostic;
    method into_diagnostic (line 81) | fn into_diagnostic(self) -> Self::IntoDiagnostic {
    type IntoDiagnostic (line 140) | type IntoDiagnostic = TripleParseDiagnostic;
    method into_diagnostic (line 142) | fn into_diagnostic(self) -> Self::IntoDiagnostic {
    type IntoDiagnostic (line 198) | type IntoDiagnostic = PlainStringParseDiagnostic;
    method into_diagnostic (line 200) | fn into_diagnostic(self) -> Self::IntoDiagnostic {
    type IntoDiagnostic (line 206) | type IntoDiagnostic = CustomTripleCreateDiagnostic;
    method into_diagnostic (line 208) | fn into_diagnostic(self) -> Self::IntoDiagnostic {
  type ExpressionParseDiagnostic (line 40) | pub struct ExpressionParseDiagnostic(ExpressionParseError);
    method new (line 44) | pub fn new(error: ExpressionParseError) -> Self {
    method fmt (line 50) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method fmt (line 56) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method source (line 62) | fn source(&self) -> Option<&(dyn StdError + 'static)> {
  method source_code (line 68) | fn source_code(&self) -> Option<&dyn SourceCode> {
  method labels (line 72) | fn labels(&self) -> Option<Box<dyn Iterator<Item = LabeledSpan> + '_>> {
  type TripleParseDiagnostic (line 88) | pub struct TripleParseDiagnostic {
    method new (line 96) | pub fn new(error: TripleParseError) -> Self {
    method fmt (line 103) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method fmt (line 109) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method source (line 115) | fn source(&self) -> Option<&(dyn StdError + 'static)> {
  method source_code (line 121) | fn source_code(&self) -> Option<&dyn SourceCode> {
  method labels (line 125) | fn labels(&self) -> Option<Box<dyn Iterator<Item = LabeledSpan> + '_>> {
  type PlainStringParseDiagnostic (line 149) | pub struct PlainStringParseDiagnostic {
    method new (line 157) | pub fn new(error: PlainStringParseError) -> Self {
    method fmt (line 164) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method fmt (line 170) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method source (line 178) | fn source(&self) -> Option<&(dyn StdError + 'static)> {
  method source_code (line 184) | fn source_code(&self) -> Option<&dyn SourceCode> {
  method labels (line 188) | fn labels(&self) -> Option<Box<dyn Iterator<Item = LabeledSpan> + '_>> {
  type CustomTripleCreateDiagnostic (line 214) | pub struct CustomTripleCreateDiagnostic(CustomTripleCreateError);
    method new (line 218) | pub fn new(error: CustomTripleCreateError) -> Self {
    method fmt (line 224) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method fmt (line 230) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method source (line 236) | fn source(&self) -> Option<&(dyn StdError + 'static)> {
  method source_code (line 247) | fn source_code(&self) -> Option<&dyn SourceCode> {
  method labels (line 251) | fn labels(&self) -> Option<Box<dyn Iterator<Item = LabeledSpan> + '_>> {

FILE: target-spec-miette/tests/datatest-snapshot/cfg.rs
  function cfg_invalid (line 11) | pub(crate) fn cfg_invalid(path: &Utf8Path, contents: String) -> datatest...

FILE: target-spec-miette/tests/datatest-snapshot/custom.rs
  function custom_invalid (line 14) | pub(crate) fn custom_invalid(path: &Utf8Path, contents: String) -> datat...

FILE: target-spec-miette/tests/datatest-snapshot/expr.rs
  function expr_invalid (line 8) | pub(crate) fn expr_invalid(path: &Utf8Path, contents: String) -> datates...

FILE: target-spec-miette/tests/datatest-snapshot/helpers.rs
  function snapbox_assert_ansi (line 8) | pub(crate) fn snapbox_assert_ansi(test_name: &str, path: &Utf8Path, actu...
  function snapshot_path (line 28) | fn snapshot_path(test_name: &str, file_name: &str, ext: &str) -> PathBuf {

FILE: target-spec-miette/tests/integration/main.rs
  function unavailable_snapshot (line 9) | fn unavailable_snapshot() {

FILE: target-spec/build.rs
  function main (line 6) | fn main() {

FILE: target-spec/src/custom.rs
  type TargetDefinition (line 15) | pub(crate) struct TargetDefinition {
    method into_target_info (line 57) | pub(crate) fn into_target_info(self, triple: Cow<'static, str>) -> Tar...
  function deserialize (line 104) | pub(super) fn deserialize<'de, D>(deserializer: D) -> Result<u8, D::Error>
  function serialize (line 141) | pub(super) fn serialize<S>(value: &u8, serializer: S) -> Result<S::Ok, S...
  type Endian (line 154) | enum Endian {
    method to_cfg_expr (line 161) | fn to_cfg_expr(self) -> cfg_expr::targets::Endian {
  type AllTargets (line 176) | struct AllTargets(BTreeMap<String, TargetDefinition>);
  function test_all_builtin_specs_recognized (line 179) | fn test_all_builtin_specs_recognized() {

FILE: target-spec/src/custom_cfg.rs
  function parse_cfg_output (line 34) | pub(crate) fn parse_cfg_output(
  type CfgValue (line 49) | enum CfgValue {
    method set (line 70) | fn set(
    method into_option (line 93) | fn into_option(self) -> Option<String> {
    method require (line 104) | fn require(
  type ParsedCfg (line 125) | struct ParsedCfg {
    method parse (line 141) | fn parse(triple: &str, input: &str) -> Result<Self, CustomTripleCreate...
    method into_target_info_and_features (line 259) | fn into_target_info_and_features(
  function test_parse_x86_64_linux (line 346) | fn test_parse_x86_64_linux() {
  function test_parse_big_endian (line 393) | fn test_parse_big_endian() {
  function test_parse_multiple_families (line 419) | fn test_parse_multiple_families() {
  function test_missing_required_arch (line 436) | fn test_missing_required_arch() {
  function test_missing_required_pointer_width (line 453) | fn test_missing_required_pointer_width() {
  function test_malformed_quoting (line 470) | fn test_malformed_quoting() {
  function test_invalid_pointer_width (line 489) | fn test_invalid_pointer_width() {
  function test_missing_required_endian (line 510) | fn test_missing_required_endian() {
  function test_missing_required_panic (line 533) | fn test_missing_required_panic() {
  function test_invalid_has_atomic (line 553) | fn test_invalid_has_atomic() {
  function test_unknown_endian_value (line 584) | fn test_unknown_endian_value() {
  function test_parse_bare_metal_target (line 614) | fn test_parse_bare_metal_target() {
  function test_duplicate_single_valued_key (line 646) | fn test_duplicate_single_valued_key() {
  function test_roundtrip_against_rustc (line 680) | fn test_roundtrip_against_rustc() {

FILE: target-spec/src/errors.rs
  type Error (line 11) | pub enum Error {
    method fmt (line 32) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method source (line 54) | fn source(&self) -> Option<&(dyn error::Error + 'static)> {
  type ExpressionParseError (line 73) | pub struct ExpressionParseError {
    method new (line 86) | pub(crate) fn new(input: &str, error: cfg_expr::ParseError) -> Self {
    method fmt (line 103) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type ExpressionParseErrorKind (line 113) | pub enum ExpressionParseErrorKind {
    method from_cfg_expr (line 145) | fn from_cfg_expr(reason: cfg_expr::error::Reason) -> Self {
    method fmt (line 166) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type PlainStringParseError (line 202) | pub struct PlainStringParseError {
    method new (line 214) | pub(crate) fn new(input: String, char_index: usize, character: char) -...
    method span (line 223) | pub fn span(&self) -> std::ops::Range<usize> {
    method fmt (line 230) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method source (line 241) | fn source(&self) -> Option<&(dyn error::Error + 'static)> {
  type TripleParseError (line 253) | pub struct TripleParseError {
    method new (line 259) | pub(crate) fn new(
    method new_strict (line 269) | pub(crate) fn new_strict(triple_str: Cow<'static, str>) -> Self {
    method triple_str (line 277) | pub fn triple_str(&self) -> &str {
    method fmt (line 283) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method source (line 289) | fn source(&self) -> Option<&(dyn error::Error + 'static)> {
  type TripleParseErrorKind (line 295) | enum TripleParseErrorKind {
    method fmt (line 301) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method source (line 316) | fn source(&self) -> Option<&(dyn error::Error + 'static)> {
  type CustomTripleCreateError (line 327) | pub enum CustomTripleCreateError {
    method input (line 410) | pub fn input(&self) -> Option<&str> {
    method input_string (line 419) | pub fn input_string(&self) -> Option<&String> {
    method line_and_column (line 442) | pub fn line_and_column(&self) -> Option<(usize, usize)> {
    method label (line 463) | pub fn label(&self) -> Option<String> {
    method fmt (line 491) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method source (line 540) | fn source(&self) -> Option<&(dyn error::Error + 'static)> {
  type RustcVersionVerboseParseError (line 561) | pub enum RustcVersionVerboseParseError {
    method fmt (line 573) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method source (line 589) | fn source(&self) -> Option<&(dyn error::Error + 'static)> {
  function test_expression_parse_error_span (line 604) | fn test_expression_parse_error_span(input: &str, expected_span: std::ops...
  function test_plain_string_parse_error_span (line 611) | fn test_plain_string_parse_error_span(input: &str, expected_span: std::o...

FILE: target-spec/src/platform.rs
  type Platform (line 35) | pub struct Platform {
    method new (line 45) | pub fn new(
    method new_strict (line 57) | pub fn new_strict(
    method from_rustc_version_verbose (line 67) | pub fn from_rustc_version_verbose(
    method current (line 84) | pub fn current() -> Result<Self, Error> {
    method build_target (line 106) | pub fn build_target() -> Result<Self, Error> {
    method from_triple (line 117) | pub fn from_triple(triple: Triple, target_features: TargetFeatures) ->...
    method new_custom (line 127) | pub fn new_custom(
    method new_custom_cfg (line 143) | pub fn new_custom_cfg(
    method add_flags (line 164) | pub fn add_flags(&mut self, flags: impl IntoIterator<Item = impl Into<...
    method triple_str (line 169) | pub fn triple_str(&self) -> &str {
    method flags (line 174) | pub fn flags(&self) -> impl ExactSizeIterator<Item = &str> {
    method has_flag (line 179) | pub fn has_flag(&self, flag: impl AsRef<str>) -> bool {
    method is_standard (line 196) | pub fn is_standard(&self) -> bool {
    method is_builtin (line 213) | pub fn is_builtin(&self) -> bool {
    method is_heuristic (line 232) | pub fn is_heuristic(&self) -> bool {
    method is_custom (line 241) | pub fn is_custom(&self) -> bool {
    method triple (line 246) | pub fn triple(&self) -> &Triple {
    method target_features (line 251) | pub fn target_features(&self) -> &TargetFeatures {
    method custom_json (line 256) | pub(crate) fn custom_json(&self) -> Option<&str> {
    method custom_cfg_text (line 261) | pub(crate) fn custom_cfg_text(&self) -> Option<&str> {
  type TargetFeatures (line 269) | pub enum TargetFeatures {
    method features (line 280) | pub fn features(features: impl IntoIterator<Item = impl Into<Cow<'stat...
    method none (line 285) | pub fn none() -> Self {
    method matches (line 291) | pub fn matches(&self, feature: &str) -> Option<bool> {
  constant LINUX_CFG (line 306) | const LINUX_CFG: &str = "\
  function new_custom_cfg_basic (line 320) | fn new_custom_cfg_basic() {
  function new_custom_cfg_evaluates_expressions (line 333) | fn new_custom_cfg_evaluates_expressions() {
  function new_custom_cfg_with_features (line 361) | fn new_custom_cfg_with_features() {
  function new_custom_cfg_with_no_features (line 374) | fn new_custom_cfg_with_no_features() {

FILE: target-spec/src/proptest_helpers.rs
  method strategy (line 32) | pub fn strategy(
  method filtered_strategy (line 50) | pub fn filtered_strategy(
  function flag_strategy (line 71) | pub fn flag_strategy() -> impl Strategy<Value = &'static str> {
  type Parameters (line 78) | type Parameters = ();
  type Strategy (line 79) | type Strategy = BoxedStrategy<Self>;
  method arbitrary_with (line 81) | fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {

FILE: target-spec/src/simple_eval.rs
  function eval (line 18) | pub fn eval(spec_or_triple: &str, platform: &str) -> Result<Option<bool>...
  function test_windows (line 29) | fn test_windows() {
  function test_not_target_os (line 37) | fn test_not_target_os() {
  function test_not_target_os_false (line 49) | fn test_not_target_os_false() {
  function test_exact_triple (line 61) | fn test_exact_triple() {
  function test_redox (line 69) | fn test_redox() {
  function test_bogus_families (line 81) | fn test_bogus_families() {
  function test_target_feature (line 146) | fn test_target_feature() {

FILE: target-spec/src/spec.rs
  type TargetSpec (line 71) | pub enum TargetSpec {
    method new (line 86) | pub fn new(input: impl Into<Cow<'static, str>>) -> Result<Self, Error> {
    method looks_like_expression (line 105) | pub fn looks_like_expression(input: &str) -> bool {
    method looks_like_plain_string (line 116) | pub fn looks_like_plain_string(input: &str) -> bool {
    method is_known (line 129) | pub fn is_known(&self) -> bool {
    method eval (line 143) | pub fn eval(&self, platform: &Platform) -> Option<bool> {
    method fmt (line 160) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Err (line 152) | type Err = Error;
  method from_str (line 154) | fn from_str(input: &str) -> Result<Self, Self::Err> {
  type TargetSpecExpression (line 172) | pub struct TargetSpecExpression {
    method new (line 181) | pub fn new(input: &str) -> Result<Self, ExpressionParseError> {
    method expression_str (line 190) | pub fn expression_str(&self) -> &str {
    method eval (line 198) | pub fn eval(&self, platform: &Platform) -> Option<bool> {
    method fmt (line 235) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Err (line 227) | type Err = ExpressionParseError;
  method from_str (line 229) | fn from_str(input: &str) -> Result<Self, Self::Err> {
  type TargetSpecPlainString (line 244) | pub struct TargetSpecPlainString(Cow<'static, str>);
    method new (line 248) | pub fn new(input: impl Into<Cow<'static, str>>) -> Result<Self, PlainS...
    method as_str (line 255) | pub fn as_str(&self) -> &str {
    method validate (line 259) | fn validate(input: &str) -> Result<(), PlainStringParseError> {
    method fmt (line 280) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Err (line 272) | type Err = PlainStringParseError;
  method from_str (line 274) | fn from_str(input: &str) -> Result<Self, Self::Err> {
  function test_triple (line 294) | fn test_triple() {
  function test_single (line 303) | fn test_single() {
  function test_target_abi (line 317) | fn test_target_abi() {
  function test_not (line 338) | fn test_not() {
  function test_testequal (line 346) | fn test_testequal() {
  function test_identifier_like_triple (line 361) | fn test_identifier_like_triple() {
  function test_triple_string_identifier (line 369) | fn test_triple_string_identifier() {
  function test_unknown_triple (line 388) | fn test_unknown_triple() {
  function test_unknown_flag (line 399) | fn test_unknown_flag() {
  function test_unknown_predicate (line 414) | fn test_unknown_predicate() {
  function test_extra (line 442) | fn test_extra() {
  function test_incomplete (line 448) | fn test_incomplete() {

FILE: target-spec/src/summaries.rs
  method to_summary (line 20) | pub fn to_summary(&self) -> PlatformSummary {
  type PlatformSummary (line 33) | pub struct PlatformSummary {
    method new (line 62) | pub fn new(triple_str: impl Into<String>) -> Self {
    method with_custom_json (line 82) | pub fn with_custom_json(mut self, custom_json: impl Into<String>) -> S...
    method with_custom_cfg (line 93) | pub fn with_custom_cfg(mut self, custom_cfg: impl Into<String>) -> Self {
    method with_target_features (line 100) | pub fn with_target_features(mut self, target_features: TargetFeaturesS...
    method with_added_flags (line 106) | pub fn with_added_flags(mut self, flags: impl IntoIterator<Item = impl...
    method from_platform (line 112) | pub fn from_platform(platform: &Platform) -> Self {
    method to_platform (line 125) | pub fn to_platform(&self) -> Result<Platform, Error> {
    method deserialize (line 224) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  type TargetFeaturesSummary (line 179) | pub enum TargetFeaturesSummary {
    method new (line 193) | pub fn new(target_features: &TargetFeatures) -> Self {
    method to_target_features (line 204) | pub fn to_target_features(&self) -> TargetFeatures {
    method deserialize (line 293) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  type PlatformSummaryDeserialize (line 256) | enum PlatformSummaryDeserialize {
  method serialize (line 280) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  type TargetFeaturesDeserialize (line 317) | enum TargetFeaturesDeserialize {
  function platform_deserialize_valid (line 330) | fn platform_deserialize_valid() {

FILE: target-spec/src/triple.rs
  type Triple (line 54) | pub struct Triple {
    method new (line 60) | pub fn new(triple_str: impl Into<Cow<'static, str>>) -> Result<Self, T...
    method new_strict (line 69) | pub fn new_strict(triple_str: impl Into<Cow<'static, str>>) -> Result<...
    method from_rustc_version_verbose (line 91) | pub fn from_rustc_version_verbose(output: impl AsRef<[u8]>) -> Result<...
    method new_custom (line 120) | pub fn new_custom(
    method new_custom_cfg (line 155) | pub fn new_custom_cfg(
    method as_str (line 173) | pub fn as_str(&self) -> &str {
    method is_standard (line 190) | pub fn is_standard(&self) -> bool {
    method is_builtin (line 206) | pub fn is_builtin(&self) -> bool {
    method is_heuristic (line 225) | pub fn is_heuristic(&self) -> bool {
    method is_custom (line 234) | pub fn is_custom(&self) -> bool {
    method eval (line 243) | pub fn eval(&self, platform: &Platform) -> bool {
    method matches (line 249) | pub(crate) fn matches(&self, tp: &TargetPredicate) -> bool {
    method custom_json (line 254) | pub(crate) fn custom_json(&self) -> Option<&str> {
    method custom_cfg_text (line 259) | pub(crate) fn custom_cfg_text(&self) -> Option<&str> {
  type Err (line 265) | type Err = TripleParseError;
  method from_str (line 267) | fn from_str(triple_str: &str) -> Result<Self, Self::Err> {
  type TripleInner (line 275) | enum TripleInner {
    method new (line 310) | fn new(triple_str: Cow<'static, str>) -> Result<Self, TripleParseError> {
    method new_strict (line 326) | fn new_strict(triple_str: Cow<'static, str>) -> Result<Self, TriplePar...
    method from_borrowed_str (line 333) | fn from_borrowed_str(triple_str: &str) -> Result<Self, TripleParseErro...
    method is_standard (line 352) | fn is_standard(&self) -> bool {
    method is_builtin (line 360) | fn is_builtin(&self) -> bool {
    method is_heuristic (line 369) | fn is_heuristic(&self) -> bool {
    method is_custom (line 378) | fn is_custom(&self) -> bool {
    method as_str (line 386) | fn as_str(&self) -> &str {
    method matches (line 395) | fn matches(&self, tp: &TargetPredicate) -> bool {
    method custom_json (line 405) | pub(crate) fn custom_json(&self) -> Option<&str> {
    method custom_cfg_text (line 418) | pub(crate) fn custom_cfg_text(&self) -> Option<&str> {
    method project (line 430) | fn project(&self) -> TripleInnerProjected<'_> {
    method hash (line 475) | fn hash<H: hash::Hasher>(&self, state: &mut H) {
  type CustomSource (line 300) | pub(crate) enum CustomSource {
  type TripleInnerProjected (line 444) | enum TripleInnerProjected<'a> {
  method eq (line 453) | fn eq(&self, other: &Self) -> bool {
  method partial_cmp (line 462) | fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
  method cmp (line 469) | fn cmp(&self, other: &Self) -> Ordering {
  function test_parse (line 486) | fn test_parse() {
  function test_parse_rustc_version_verbose (line 515) | fn test_parse_rustc_version_verbose() {

FILE: tools/cargo-hakari/src/cargo_cli.rs
  type CargoCli (line 11) | pub(crate) struct CargoCli<'a> {
  function new (line 19) | pub(crate) fn new(command: &'a str, output: OutputContext) -> Self {
  function add_arg (line 29) | pub(crate) fn add_arg(&mut self, arg: &'a str) -> &mut Self {
  function add_args (line 34) | pub(crate) fn add_args(&mut self, args: impl IntoIterator<Item = &'a str...
  function all_args (line 39) | pub(crate) fn all_args(&self) -> Vec<&str> {
  function to_expression (line 45) | pub(crate) fn to_expression(&self) -> duct::Expression {
  function cargo_path (line 64) | fn cargo_path() -> Utf8PathBuf {

FILE: tools/cargo-hakari/src/command.rs
  type Args (line 49) | pub struct Args {
    method exec (line 60) | pub fn exec(self) -> Result<i32> {
  type GlobalOpts (line 66) | struct GlobalOpts {
  type Command (line 73) | enum Command {
    method exec (line 105) | fn exec(self, output: OutputOpts) -> Result<i32> {
  type CommandWithBuilder (line 168) | enum CommandWithBuilder {
    method exec (line 274) | fn exec(
  type PackageSelection (line 435) | struct PackageSelection {
    method to_package_set (line 443) | fn to_package_set<'g>(&self, graph: &'g PackageGraph) -> Result<Packag...
  function cwd_rel_to_workspace_rel (line 456) | fn cwd_rel_to_workspace_rel(path: &Utf8Path, workspace_root: &Utf8Path) ...
  function make_builder_and_output (line 472) | fn make_builder_and_output(
  function write_to_cargo_toml (line 494) | fn write_to_cargo_toml(
  function apply_on_dialog (line 527) | fn apply_on_dialog(

FILE: tools/cargo-hakari/src/helpers.rs
  function read_contents (line 12) | pub(crate) fn read_contents(
  function regenerate_lockfile (line 38) | pub(crate) fn regenerate_lockfile(output: OutputContext) -> Result<()> {
  function test_read_contents (line 57) | fn test_read_contents() -> Result<()> {

FILE: tools/cargo-hakari/src/main.rs
  function executable_name (line 11) | fn executable_name(subcommand: &str) -> String {
  function args (line 23) | fn args() -> impl Iterator<Item = String> {
  function main (line 33) | fn main() -> Result<()> {

FILE: tools/cargo-hakari/src/output.rs
  type OutputOpts (line 12) | pub(crate) struct OutputOpts {
    method init (line 43) | pub(crate) fn init(self) -> OutputContext {
  type OutputContext (line 80) | pub(crate) struct OutputContext {
  function format_fn (line 87) | fn format_fn(f: &mut Formatter, record: &Record<'_>) -> std::io::Result<...
  function stderr_supports_color (line 117) | fn stderr_supports_color() -> bool {
  type Color (line 126) | pub enum Color {
    method init_colored (line 133) | fn init_colored(self) {
    method is_enabled (line 141) | pub(crate) fn is_enabled(self) -> bool {
    method to_arg (line 150) | pub(crate) fn to_arg(self) -> &'static str {
    type Err (line 160) | type Err = String;
    method from_str (line 162) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  type Styles (line 175) | pub(crate) struct Styles {
    method colorize (line 184) | fn colorize(&mut self) {

FILE: tools/cargo-hakari/src/publish.rs
  function publish_hakari (line 11) | pub(crate) fn publish_hakari(
  type TempRemoveDep (line 68) | struct TempRemoveDep<'g> {
  function new (line 73) | fn new(
  function none (line 111) | fn none() -> Self {
  function is_none (line 115) | fn is_none(&self) -> bool {
  function finish (line 119) | fn finish(&mut self, success: bool) -> Result<()> {
  method drop (line 131) | fn drop(&mut self) {
  type TempRemoveDepInner (line 138) | struct TempRemoveDepInner<'g> {
  function finish (line 145) | fn finish(self, success: bool) -> Result<()> {

FILE: tools/determinator/src/determinator.rs
  type Determinator (line 37) | pub struct Determinator<'g, 'a> {
  function new (line 49) | pub fn new(old: &'a PackageGraph, new: &'g PackageGraph) -> Self {
  function add_changed_paths (line 94) | pub fn add_changed_paths(
  function match_path (line 112) | pub fn match_path(
  function set_rules (line 128) | pub fn set_rules(&mut self, rules: &DeterminatorRules) -> Result<&mut Se...
  function set_cargo_options (line 140) | pub fn set_cargo_options(&mut self, cargo_options: &'a CargoOptions<'a>)...
  function default_cargo_options (line 151) | pub fn default_cargo_options() -> CargoOptions<'static> {
  function set_features_only (line 171) | pub fn set_features_only<'b>(
  function compute (line 205) | pub fn compute(&self) -> DeterminatorSet<'g> {
  type DeterminatorSet (line 260) | pub struct DeterminatorSet<'g> {
  type BuildState (line 286) | struct BuildState<'g, 'a, 'b> {
  function new (line 295) | fn new(determinator: &'b Determinator<'g, 'a>) -> Self {
  function process_path (line 308) | fn process_path(mut self, path: &Utf8Path) -> Option<Self> {
  function process_build_summaries (line 323) | fn process_build_summaries(&mut self) {
  function build_summaries_changed (line 344) | fn build_summaries_changed(&self, name: &str, package: PackageMetadata<'...
  function process_path (line 372) | fn process_path<'g>(
  type CargoBuildCache (line 429) | struct CargoBuildCache<'g> {
  function new (line 434) | fn new(determinator: &Determinator<'g, '_>) -> Self {
  type BuildResult (line 461) | struct BuildResult<'g> {
  function new (line 469) | fn new(
  function unified_workspace_set (line 509) | fn unified_workspace_set(&self, workspace_set: &PackageSet<'g>) -> Packa...
  function is_changed (line 524) | fn is_changed(&self, other: &BuildResult<'_>, cargo_options: &CargoOptio...
  function all_cargo_sets (line 540) | fn all_cargo_sets<'a>(&'a self) -> impl Iterator<Item = &'a CargoSet<'g>...
  function make_cargo_set (line 547) | fn make_cargo_set<'x>(
  type ReverseIndex (line 561) | struct ReverseIndex<'g> {
  type ReverseIndexEdge (line 568) | enum ReverseIndexEdge {
  function new (line 576) | fn new(determinator: &Determinator<'g, '_>, build_cache: &CargoBuildCach...
  function affected_closure (line 624) | fn affected_closure(

FILE: tools/determinator/src/errors.rs
  type RulesError (line 11) | pub struct RulesError {
    method rule_index (line 18) | pub fn rule_index(&self) -> RuleIndex {
    method kind (line 23) | pub fn kind(&self) -> &RulesErrorKind {
    method resolve_ref (line 31) | pub(crate) fn resolve_ref(rule_index: RuleIndex, err: guppy::Error) ->...
    method glob_parse (line 38) | pub(crate) fn glob_parse(rule_index: RuleIndex, err: globset::Error) -...
    method fmt (line 48) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method source (line 58) | fn source(&self) -> Option<&(dyn error::Error + 'static)> {
  type RulesErrorKind (line 69) | pub enum RulesErrorKind {
    method fmt (line 83) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

FILE: tools/determinator/src/paths0.rs
  type Utf8Paths0 (line 70) | pub struct Utf8Paths0 {
    method new (line 78) | pub fn new(buf: impl Into<String>) -> Self {
    method from_bytes (line 91) | pub fn from_bytes(buf: impl Into<Vec<u8>>) -> Result<Self, (Vec<u8>, U...
    method new_forward_slashes (line 102) | pub fn new_forward_slashes(buf: impl Into<String>) -> Self {
    method iter (line 112) | pub fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = &'a Utf8Path> + '...
    method validate_utf8 (line 120) | fn validate_utf8(buf: Vec<u8>) -> Result<String, (Vec<u8>, Utf8Error)> {
    method strip_trailing_null_byte (line 136) | fn strip_trailing_null_byte(mut buf: String) -> Self {
  type Item (line 146) | type Item = &'a Utf8Path;
  type IntoIter (line 147) | type IntoIter = Box<dyn Iterator<Item = &'a Utf8Path> + 'a>;
  method into_iter (line 149) | fn into_iter(self) -> Self::IntoIter {
  function basic (line 164) | fn basic() {
  function backslashes (line 178) | fn backslashes() {
  function forward_slashes (line 186) | fn forward_slashes() {
  function paths_eq (line 195) | fn paths_eq(bytes: impl Into<Vec<u8>>, expected: &[&str]) {
  function paths_eq_fwd (line 204) | fn paths_eq_fwd(bytes: impl Into<Vec<u8>>, expected: &[&str]) {

FILE: tools/determinator/src/rules.rs
  type DeterminatorRules (line 121) | pub struct DeterminatorRules {
    method parse (line 169) | pub fn parse(s: &str) -> Result<Self, toml::de::Error> {
    method default_rules (line 192) | pub fn default_rules() -> &'static DeterminatorRules {
  method default (line 145) | fn default() -> Self {
  function default_true (line 155) | fn default_true() -> bool {
  type PathRule (line 217) | pub struct PathRule {
  type DeterminatorPostRule (line 259) | pub enum DeterminatorPostRule {
  type PackageRule (line 314) | pub struct PackageRule {
  type DeterminatorMarkChanged (line 366) | pub enum DeterminatorMarkChanged {
  type PathMatch (line 387) | pub enum PathMatch {
  type RuleIndex (line 404) | pub enum RuleIndex {
    method fmt (line 416) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type RulesImpl (line 431) | pub(crate) struct RulesImpl<'g> {
  function new (line 437) | pub(crate) fn new(
  type PathRuleImpl (line 533) | pub(crate) struct PathRuleImpl<'g> {
  type PackageRuleImpl (line 541) | pub(crate) struct PackageRuleImpl<'g> {
  type MarkChangedImpl (line 547) | pub(crate) enum MarkChangedImpl<'g> {
  function new (line 553) | fn new(
  function serialize (line 570) | pub fn serialize<S>(
  function deserialize (line 583) | pub fn deserialize<'de, D>(deserializer: D) -> Result<DeterminatorMarkCh...
  type MarkChangedDeserialized (line 603) | enum MarkChangedDeserialized {
  function parse (line 614) | fn parse() {
  function parse_empty (line 677) | fn parse_empty() {
  function parse_bad (line 688) | fn parse_bad() {

FILE: tools/determinator/tests/determinator_tests.rs
  function guppy_no_rules (line 15) | fn guppy_no_rules() {
  function guppy_path_rules (line 49) | fn guppy_path_rules() {
  function guppy_package_rules (line 188) | fn guppy_package_rules() {
  function guppy_package_rules_2 (line 285) | fn guppy_package_rules_2() {
  function guppy_deps (line 319) | fn guppy_deps() {
  function guppy_match_paths (line 390) | fn guppy_match_paths() {
  function git_match_paths (line 446) | fn git_match_paths() {
  function git_match_paths_backslashes (line 453) | fn git_match_paths_backslashes() {
  function git_match_paths_impl (line 460) | fn git_match_paths_impl(paths: Utf8Paths0) {
  function read_options (line 514) | fn read_options(fixture: &JsonFixture, toml_name: &str) -> DeterminatorR...

FILE: tools/hakari/src/cargo_toml.rs
  type HakariCargoToml (line 62) | pub struct HakariCargoToml {
    constant BEGIN_SECTION (line 73) | pub const BEGIN_SECTION: &'static str = "\n### BEGIN HAKARI SECTION\n";
    constant END_SECTION (line 77) | pub const END_SECTION: &'static str = "\n### END HAKARI SECTION\n";
    method new (line 86) | pub fn new(toml_path: impl Into<Utf8PathBuf>) -> Result<Self, CargoTom...
    method new_relative (line 104) | pub fn new_relative(
    method new_in_memory (line 119) | pub fn new_in_memory(
    method toml_path (line 150) | pub fn toml_path(&self) -> &Utf8Path {
    method contents (line 155) | pub fn contents(&self) -> &str {
    method generated_offsets (line 160) | pub fn generated_offsets(&self) -> (usize, usize) {
    method generated_contents (line 167) | pub fn generated_contents(&self) -> &str {
    method is_changed (line 172) | pub fn is_changed(&self, toml: &str) -> bool {
    method diff_toml (line 184) | pub fn diff_toml<'a>(&'a self, toml: &'a str) -> Patch<'a, str> {
    method write_to_file (line 196) | pub fn write_to_file(self, toml: &str) -> Result<bool, CargoTomlError> {
    method write (line 219) | pub fn write(&self, toml: &str, mut out: impl io::Write) -> io::Result...
    method write_to_fmt (line 231) | pub fn write_to_fmt(&self, toml: &str, mut out: impl fmt::Write) -> fm...
  type CargoTomlError (line 242) | pub enum CargoTomlError {
    method fmt (line 261) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method source (line 280) | fn source(&self) -> Option<&(dyn error::Error + 'static)> {

FILE: tools/hakari/src/cli_ops/initialize.rs
  constant CRATE_TEMPLATE_DIR (line 10) | const CRATE_TEMPLATE_DIR: Dir = include_dir!("$CARGO_MANIFEST_DIR/templa...
  constant CONFIG_TEMPLATE (line 11) | const CONFIG_TEMPLATE: &str = include_str!("../../templates/hakari.toml-...
  type HakariInit (line 15) | pub struct HakariInit<'g, 'a> {
  function new (line 28) | pub fn new(
  function set_config (line 90) | pub fn set_config(
  function set_cargo_toml_comment (line 107) | pub fn set_cargo_toml_comment(&mut self, comment: &'a str) -> &mut Self {
  function make_ops (line 113) | pub fn make_ops(&self) -> WorkspaceOps<'g, 'a> {
  function make_new_crate_op (line 124) | fn make_new_crate_op(&self) -> WorkspaceOp<'g, 'a> {
  type InitError (line 177) | pub enum InitError {
    method fmt (line 219) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method source (line 253) | fn source(&self) -> Option<&(dyn error::Error + 'static)> {

FILE: tools/hakari/src/cli_ops/manage_deps.rs
  function manage_dep_ops (line 25) | pub fn manage_dep_ops(&self, workspace_set: &PackageSet<'g>) -> Option<W...
  function add_dep_ops (line 78) | pub fn add_dep_ops(
  function remove_dep_ops (line 126) | pub fn remove_dep_ops(
  function needs_update_v2 (line 157) | fn needs_update_v2(

FILE: tools/hakari/src/cli_ops/workspace_ops.rs
  type WorkspaceOps (line 22) | pub struct WorkspaceOps<'g, 'a> {
  function new (line 28) | pub(crate) fn new(
  function display (line 40) | pub fn display<'ops>(&'ops self) -> WorkspaceOpsDisplay<'g, 'a, 'ops> {
  function is_empty (line 46) | pub fn is_empty(&self) -> bool {
  function apply (line 53) | pub fn apply(&self) -> Result<(), ApplyError> {
  type WorkspaceOp (line 70) | pub(crate) enum WorkspaceOp<'g, 'a> {
  function apply (line 91) | fn apply(&self, canonical_workspace_root: &Utf8Path) -> Result<(), Apply...
  function create_new_crate (line 146) | fn create_new_crate(
  function add_to_root_toml (line 172) | fn add_to_root_toml(
  function get_workspace_members_array (line 232) | fn get_workspace_members_array<'doc>(
  function add_to_cargo_toml (line 285) | fn add_to_cargo_toml(
  function inline_table_for_add (line 312) | fn inline_table_for_add(
  function remove_from_cargo_toml (line 363) | fn remove_from_cargo_toml(name: &str, package: PackageMetadata<'g>) -> R...
  function get_or_insert_dependencies_table (line 374) | fn get_or_insert_dependencies_table<'doc>(
  function decorate (line 407) | fn decorate(existing: &Value, new: impl Into<Value>) -> Value {
  function with_forward_slashes (line 416) | fn with_forward_slashes(path: &Utf8Path) -> Utf8PathBuf {
  function canonical_rel_path (line 425) | fn canonical_rel_path(
  function read_toml (line 450) | fn read_toml(manifest_path: &Utf8Path) -> Result<DocumentMut, ApplyError> {
  function write_contents (line 457) | fn write_contents(contents: &[u8], path: &Utf8Path) -> Result<(), ApplyE...
  function write_document (line 461) | fn write_document(document: &DocumentMut, path: &Utf8Path) -> Result<(),...
  function write_atomic (line 465) | fn write_atomic(
  type ApplyError (line 480) | pub struct ApplyError {
    method message (line 489) | pub fn message(&self) -> &str {
    method path (line 495) | pub fn path(&self) -> &Utf8Path {
    method io (line 502) | fn io(message: impl Into<String>, path: impl Into<Utf8PathBuf>, err: i...
    method toml (line 510) | fn toml(
    method misc (line 522) | fn misc(message: impl Into<String>, path: impl Into<Utf8PathBuf>) -> S...
    method fmt (line 532) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method source (line 538) | fn source(&self) -> Option<&(dyn error::Error + 'static)> {
  type ApplyErrorKind (line 548) | enum ApplyErrorKind {
  type WorkspaceOpsDisplay (line 556) | pub struct WorkspaceOpsDisplay<'g, 'a, 'ops> {
  function new (line 562) | fn new(ops: &'ops WorkspaceOps<'g, 'a>) -> Self {
  function colorize (line 570) | pub fn colorize(&mut self) -> &mut Self {
  function fmt (line 577) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Styles (line 667) | struct Styles {
    method colorize (line 681) | fn colorize(&mut self) {
  function package_names_paths (line 695) | fn package_names_paths<'g>(package_set: &PackageSet<'g>) -> Vec<(&'g str...
  function test_inline_table_for_add (line 717) | fn test_inline_table_for_add() {

FILE: tools/hakari/src/explain/display.rs
  type HakariExplainDisplay (line 15) | pub struct HakariExplainDisplay<'g, 'a, 'explain> {
  function new (line 21) | pub(super) fn new(explain: &'explain HakariExplain<'g, 'a>) -> Self {
  function colorize (line 29) | pub fn colorize(&mut self) -> &mut Self {
  function display_platform_str (line 34) | fn display_platform_str(
  constant DITTO_MARK (line 49) | const DITTO_MARK: &str = "\"";
  function fmt (line 52) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Styles (line 154) | struct Styles {
    method colorize (line 169) | fn colorize(&mut self) {
  type FeatureDisplay (line 185) | struct FeatureDisplay<'g, 'a> {
  function fmt (line 190) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: tools/hakari/src/explain/mod.rs
  type HakariExplain (line 31) | pub struct HakariExplain<'g, 'a> {
  type ExplainMap (line 41) | type ExplainMap<'g, 'a> = BTreeMap<&'a BTreeSet<&'g str>, ExplainInner<'...
  type ExplainInner (line 44) | struct ExplainInner<'g> {
  type ExplainInnerValue (line 53) | struct ExplainInnerValue<'g> {
  function new (line 65) | pub(crate) fn new(hakari: &'a Hakari<'g>, dep_id: &PackageId) -> Result<...
  function simplify_map (line 82) | fn simplify_map(hakari: &'a Hakari<'g>, map: IntermediateMap<'g, 'a>) ->...
  function dependency (line 115) | pub fn dependency(&self) -> PackageMetadata<'g> {
  function display (line 121) | pub fn display<'explain>(&'explain self) -> HakariExplainDisplay<'g, 'a,...
  function explain_maps (line 127) | fn explain_maps(&self) -> [(BuildPlatform, &ExplainMap<'g, 'a>); 2] {
  type ExplainIntermediate (line 137) | struct ExplainIntermediate<'g, 'a> {
  type IntermediateMap (line 142) | type IntermediateMap<'g, 'a> = BTreeMap<&'a BTreeSet<&'g str>, Intermedi...
  type IntermediateInner (line 145) | struct IntermediateInner<'g> {
  type IntermediateInnerValue (line 151) | struct IntermediateInnerValue<'g> {
  function new (line 157) | fn new(hakari: &'a Hakari<'g>, dep_id: &'g PackageId) -> Result<Self, gu...

FILE: tools/hakari/src/explain/simplify.rs
  type Simple (line 12) | pub(super) enum Simple<T> {
  function display_with (line 19) | pub(super) fn display_with<'simple, F>(
  type SimpleDisplay (line 36) | pub(super) struct SimpleDisplay<'simple, T, F> {
  function fmt (line 47) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function simplify3 (line 55) | pub(super) fn simplify3<A, B, C>(
  function simplify1 (line 103) | pub(super) fn simplify1<A>(input: &BTreeSet<A>, n_a: usize) -> Vec<Simpl...

FILE: tools/hakari/src/hakari.rs
  type HakariBuilder (line 36) | pub struct HakariBuilder<'g> {
  function new (line 59) | pub fn new(
  function graph (line 92) | pub fn graph(&self) -> &'g PackageGraph {
  function hakari_package (line 99) | pub fn hakari_package(&self) -> Option<&PackageMetadata<'g>> {
  function read_toml (line 111) | pub fn read_toml(&self) -> Option<Result<HakariCargoToml, CargoTomlError...
  function set_platforms (line 137) | pub fn set_platforms(
  function platforms (line 150) | pub fn platforms(&self) -> impl ExactSizeIterator<Item = &str> + '_ {
  function set_resolver (line 159) | pub fn set_resolver(&mut self, resolver: CargoResolverVersion) -> &mut S...
  function resolver (line 165) | pub fn resolver(&self) -> CargoResolverVersion {
  function add_traversal_excludes (line 182) | pub fn add_traversal_excludes<'b>(
  function traversal_excludes (line 198) | pub fn traversal_excludes<'b>(&'b self) -> impl Iterator<Item = &'g Pack...
  function is_traversal_excluded (line 209) | pub fn is_traversal_excluded(&self, package_id: &PackageId) -> Result<bo...
  function add_final_excludes (line 222) | pub fn add_final_excludes<'b>(
  function final_excludes (line 235) | pub fn final_excludes<'b>(&'b self) -> impl Iterator<Item = &'g PackageI...
  function is_final_excluded (line 242) | pub fn is_final_excluded(&self, package_id: &PackageId) -> Result<bool, ...
  function is_excluded (line 254) | pub fn is_excluded(&self, package_id: &PackageId) -> Result<bool, guppy:...
  function add_registries (line 262) | pub fn add_registries(
  function set_unify_target_host (line 278) | pub fn set_unify_target_host(&mut self, unify_target_host: UnifyTargetHo...
  function unify_target_host (line 284) | pub fn unify_target_host(&self) -> UnifyTargetHost {
  function set_output_single_feature (line 295) | pub fn set_output_single_feature(&mut self, output_single_feature: bool)...
  function output_single_feature (line 301) | pub fn output_single_feature(&self) -> bool {
  function set_dep_format_version (line 308) | pub fn set_dep_format_version(&mut self, dep_format_version: DepFormatVe...
  function dep_format_version (line 314) | pub fn dep_format_version(&self) -> DepFormatVersion {
  function set_workspace_hack_line_style (line 321) | pub fn set_workspace_hack_line_style(
  function workspace_hack_line_style (line 330) | pub fn workspace_hack_line_style(&self) -> WorkspaceHackLineStyle {
  function compute (line 335) | pub fn compute(self) -> Hakari<'g> {
  function traversal_excludes_only (line 344) | pub(crate) fn traversal_excludes_only<'b>(
  function make_traversal_excludes (line 350) | fn make_traversal_excludes<'b>(&'b self) -> TraversalExcludes<'g, 'b> {
  function make_features_only (line 363) | fn make_features_only<'b>(&'b self) -> FeatureSet<'g> {
  function from_summary (line 389) | pub fn from_summary(
  type UnifyTargetHost (line 488) | pub enum UnifyTargetHost {
    method to_impl (line 1591) | fn to_impl(self, graph: &PackageGraph) -> UnifyTargetHostImpl {
  method default (line 524) | fn default() -> Self {
  type DepFormatVersion (line 537) | pub enum DepFormatVersion {
    method latest (line 566) | pub fn latest() -> Self {
    method fmt (line 572) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type WorkspaceHackLineStyle (line 589) | pub enum WorkspaceHackLineStyle {
  type OutputKey (line 603) | pub struct OutputKey {
  type Hakari (line 619) | pub struct Hakari<'g> {
  function builder (line 636) | pub fn builder(&self) -> &HakariBuilder<'g> {
  function read_toml (line 648) | pub fn read_toml(&self) -> Option<Result<HakariCargoToml, CargoTomlError...
  function write_toml (line 655) | pub fn write_toml(
  function toml_name_map (line 674) | pub fn toml_name_map(&self) -> AHashMap<Cow<'g, str>, PackageMetadata<'g...
  function explain (line 682) | pub fn explain(
  function to_toml_string (line 693) | pub fn to_toml_string(&self, options: &HakariOutputOptions) -> Result<St...
  function build (line 703) | fn build(builder: HakariBuilder<'g>) -> Self {
  type OutputMap (line 828) | pub type OutputMap<'g> =
  type ComputedMap (line 841) | pub type ComputedMap<'g> = BTreeMap<(Option<usize>, &'g PackageId), Comp...
  type ComputedValue (line 849) | pub struct ComputedValue<'g> {
  type ComputedInnerMap (line 861) | pub type ComputedInnerMap<'g> = BTreeMap<BTreeSet<&'g str>, ComputedInne...
  type ComputedInnerValue (line 865) | pub struct ComputedInnerValue<'g> {
  function extend (line 876) | fn extend(&mut self, other: ComputedInnerValue<'g>) {
  function push (line 882) | fn push(
  type TraversalExcludes (line 894) | struct TraversalExcludes<'g, 'b> {
  function iter (line 900) | fn iter(&self) -> impl Iterator<Item = &'g PackageId> + 'b + use<'g, 'b> {
  function is_excluded (line 904) | fn is_excluded(&self, package_id: &PackageId) -> bool {
  type ComputedMapBuild (line 911) | struct ComputedMapBuild<'g, 'b> {
  function new (line 917) | fn new(builder: &'b HakariBuilder<'g>) -> Self {
  function get (line 1077) | fn get(
  function get_or_insert_mut (line 1085) | fn get_or_insert_mut(
  function iter (line 1095) | fn iter<'a>(
  function inner_maps (line 1106) | pub fn inner_maps(&self) -> [(BuildPlatform, &ComputedInnerMap<'g>); 2] {
  function into_inner_maps (line 1115) | pub fn into_inner_maps(self) -> [(BuildPlatform, ComputedInnerMap<'g>); ...
  function get_inner (line 1123) | pub fn get_inner(&self, build_platform: BuildPlatform) -> &ComputedInner...
  function get_inner_mut (line 1131) | pub fn get_inner_mut(&mut self, build_platform: BuildPlatform) -> &mut C...
  function merge (line 1139) | fn merge(&mut self, other: ComputedValue<'g>) {
  function contains (line 1151) | fn contains(&mut self, build_platform: BuildPlatform, features: &BTreeSe...
  function insert (line 1155) | fn insert(
  function mark_fixed_up (line 1169) | fn mark_fixed_up(&mut self, build_platform: BuildPlatform, features: BTr...
  function describe (line 1176) | fn describe<'a>(&'a self) -> ValueDescribe<'g, 'a> {
  type ValueDescribe (line 1215) | enum ValueDescribe<'g, 'a> {
  function description (line 1245) | fn description(self) -> &'static str {
  function insert (line 1260) | fn insert(
  type OutputMapBuild (line 1361) | struct OutputMapBuild<'g> {
  function new (line 1367) | fn new(graph: &'g PackageGraph) -> Self {
  function is_inserted (line 1374) | fn is_inserted(&self, output_key: OutputKey, package_id: &'g PackageId) ...
  function get (line 1382) | fn get(
  function insert_all (line 1393) | fn insert_all<'a>(
  function insert_inner (line 1413) | fn insert_inner(
  function insert (line 1431) | fn insert(
  function iter_feature_sets (line 1448) | fn iter_feature_sets<'a>(&'a self) -> impl Iterator<Item = (OutputKey, F...
  function finish (line 1465) | fn finish(
  function filter_root_features (line 1545) | fn filter_root_features(
  type UnifyTargetHostImpl (line 1584) | enum UnifyTargetHostImpl {
  function unify_target_host_auto (line 1627) | fn unify_target_host_auto() {

FILE: tools/hakari/src/helpers.rs
  type VersionDisplay (line 9) | pub(crate) struct VersionDisplay<'a> {
  function new (line 18) | pub(crate) fn new(
  function fmt (line 32) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function min_version (line 64) | fn min_version() {
  function min_versions_match (line 110) | fn min_versions_match() {

FILE: tools/hakari/src/proptest_helpers.rs
  function proptest1_strategy (line 34) | pub fn proptest1_strategy(
  function builder_summary_roundtrip (line 94) | fn builder_summary_roundtrip() {
  function traversal_excludes (line 119) | fn traversal_excludes() {

FILE: tools/hakari/src/registry.rs
  type Registry (line 7) | pub(crate) struct Registry {
  type K1 (line 13) | type K1<'a> = &'a str;
  type K2 (line 14) | type K2<'a> = &'a str;
  method key1 (line 16) | fn key1(&self) -> Self::K1<'_> {
  method key2 (line 20) | fn key2(&self) -> Self::K2<'_> {

FILE: tools/hakari/src/summaries.rs
  type HakariConfig (line 32) | pub struct HakariConfig {
  type Err (line 43) | type Err = toml::de::Error;
  method from_str (line 46) | fn from_str(input: &str) -> Result<Self, Self::Err> {
  type HakariBuilderSummary (line 60) | pub struct HakariBuilderSummary {
    method new (line 117) | pub fn new(builder: &HakariBuilder<'_>) -> Result<Self, TargetSpecErro...
    method to_hakari_builder (line 153) | pub fn to_hakari_builder<'g>(
    method to_string (line 163) | pub fn to_string(&self) -> Result<String, toml::ser::Error> {
    method write_comment (line 173) | pub fn write_comment(&self, mut out: impl fmt::Write) -> Result<(), To...
    method write_to_string (line 192) | pub fn write_to_string(&self, dst: &mut String) -> Result<(), toml::se...
  function to_summary (line 206) | pub fn to_summary(&self) -> Result<HakariBuilderSummary, TargetSpecError> {
  type OutputOptionsSummary (line 217) | pub struct OutputOptionsSummary {
    method new (line 233) | pub fn new(options: &HakariOutputOptions) -> Self {
    method to_options (line 242) | pub fn to_options(&self) -> HakariOutputOptions {
  type RegistryDe (line 257) | struct RegistryDe {
  type RegistrySer (line 262) | struct RegistrySer<'a> {
  function serialize (line 267) | pub fn serialize<S>(
  function deserialize (line 289) | pub fn deserialize<'de, D>(deserializer: D) -> Result<BTreeMap<String, S...
  function parse_registries (line 308) | fn parse_registries() {

FILE: tools/hakari/src/toml_out.rs
  type HakariOutputOptions (line 32) | pub struct HakariOutputOptions {
    method new (line 45) | pub fn new() -> Self {
    method set_exact_versions (line 69) | pub fn set_exact_versions(&mut self, exact_versions: bool) -> &mut Self {
    method set_absolute_paths (line 95) | pub fn set_absolute_paths(&mut self, absolute_paths: bool) -> &mut Self {
    method set_builder_summary (line 113) | pub fn set_builder_summary(&mut self, builder_summary: bool) -> &mut S...
  method default (line 120) | fn default() -> Self {
  type TomlOutError (line 128) | pub enum TomlOutError {
    method from (line 214) | fn from(err: TargetSpecError) -> Self {
    method from (line 220) | fn from(err: fmt::Error) -> Self {
    method fmt (line 226) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method source (line 257) | fn source(&self) -> Option<&(dyn error::Error + 'static)> {
  function toml_name_map (line 180) | pub(crate) fn toml_name_map<'g>(
  function write_toml (line 270) | pub(crate) fn write_toml(
  function make_hashed_name (line 504) | fn make_hashed_name(dep: &PackageMetadata<'_>, dep_format: DepFormatVers...
  function get_or_insert_table (line 521) | fn get_or_insert_table<'t>(parent: &'t mut Table, key: &str) -> &'t mut ...
  function make_package_name_unique (line 539) | fn make_package_name_unique() {
  function alternate_registries (line 565) | fn alternate_registries() {

FILE: tools/hakari/src/verify/display.rs
  type VerifyErrorsDisplay (line 13) | pub struct VerifyErrorsDisplay<'g, 'verify> {
  function new (line 20) | pub(super) fn new(verify: &'verify VerifyErrors<'g>) -> Self {
  function colorize (line 29) | pub fn colorize(&mut self) -> &mut Self {
  function fmt (line 37) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Styles (line 59) | struct Styles {
    method colorize (line 64) | fn colorize(&mut self) {

FILE: tools/hakari/src/verify/mod.rs
  function verify (line 36) | pub fn verify(mut self) -> Result<(), VerifyErrors<'g>> {
  type VerifyErrors (line 65) | pub struct VerifyErrors<'g> {
  function errors (line 78) | pub fn errors<'a>(&'a self) -> impl ExactSizeIterator<Item = HakariExpla...
  function display (line 88) | pub fn display<'verify>(&'verify self) -> VerifyErrorsDisplay<'g, 'verif...
  function cargo_guppy_verify (line 101) | fn cargo_guppy_verify() {

FILE: tools/hakari/templates/crate/build.rs
  function main (line 2) | fn main() {}

FILE: workspace-hack/build.rs
  function main (line 2) | fn main() {}

[
  {
    "path": ".cargo/config.toml",
    "chars": 59,
    "preview": "[alias]\nxfmt = \"fmt -- --config imports_granularity=Crate\"\n"
  },
  {
    "path": ".cargo/nightly-config.toml",
    "chars": 563,
    "preview": "# Extra configuration for nightly Rust.\n#\n# Use manually by passing this path into `--config`, or via the Justfile: `jus"
  },
  {
    "path": ".claude/.gitignore",
    "chars": 21,
    "preview": "/settings.local.json\n"
  },
  {
    "path": ".claude/settings.json",
    "chars": 451,
    "preview": "{\n  \"permissions\": {\n    \"allow\": [\n      \"Bash(cargo build:*)\",\n      \"Bash(cargo check:*)\",\n      \"Bash(cargo doc:*)\","
  },
  {
    "path": ".config/hakari.toml",
    "chars": 1149,
    "preview": "# This file contains settings for `cargo hakari`.\n# See https://docs.rs/cargo-hakari/latest/cargo_hakari/config for a fu"
  },
  {
    "path": ".git-blame-ignore-revs",
    "chars": 72,
    "preview": "# Update style_version to 2024\n4722ab31392e622ec6373ef133e3956e3a2851c7\n"
  },
  {
    "path": ".gitattributes",
    "chars": 60,
    "preview": "# Disable all CRLF conversions throughout the repo.\n* -text\n"
  },
  {
    "path": ".github/renovate.json",
    "chars": 115,
    "preview": "{\n    \"extends\": [\n        \"github>nextest-rs/renovate\",\n        \"github>nextest-rs/renovate:post-upgrade\"\n    ]\n}\n"
  },
  {
    "path": ".github/workflows/ci.yml",
    "chars": 6291,
    "preview": "on:\n  push:\n    branches:\n      - main\n  pull_request:\n    branches:\n      - main\n\nname: CI\n\njobs:\n  lint:\n    name: Lin"
  },
  {
    "path": ".github/workflows/docs.yml",
    "chars": 1609,
    "preview": "on:\n  push:\n    branches:\n      - main\n    workflow_dispatch:\n\nname: Docs\n\n# Sets permissions to allow deployment to Git"
  },
  {
    "path": ".github/workflows/hakari.yml",
    "chars": 804,
    "preview": "# This workflow file serves as an example for cargo-hakari CI integration.\n\non:\n  push:\n    branches:\n      - main\n  pul"
  },
  {
    "path": ".github/workflows/release.yml",
    "chars": 13707,
    "preview": "# adapted from https://github.com/taiki-e/cargo-hack/blob/main/.github/workflows/release.yml\n\nname: Publish releases to "
  },
  {
    "path": ".gitignore",
    "chars": 19,
    "preview": "/target\n**/*.rs.bk\n"
  },
  {
    "path": ".ignore",
    "chars": 11,
    "preview": "/fixtures/\n"
  },
  {
    "path": ".vscode/launch.json",
    "chars": 1025,
    "preview": "{\n    // Use IntelliSense to learn about possible attributes.\n    // Hover to view descriptions of existing attributes.\n"
  },
  {
    "path": "CLAUDE.md",
    "chars": 295,
    "preview": "# Instructions for dropshot-api-manager\n\n## General instructions\n\n* Always use `cargo nextest run` to run tests. Never u"
  },
  {
    "path": "CODE_OF_CONDUCT.md",
    "chars": 5523,
    "preview": "\n# Contributor Covenant Code of Conduct\n\n## Our Pledge\n\nWe as members, contributors, and leaders pledge to make particip"
  },
  {
    "path": "CONTRIBUTING.md",
    "chars": 1118,
    "preview": "# Contributing to cargo-guppy\n\n## Pull Requests\n\nWe actively welcome your pull requests. If you have a new feature in mi"
  },
  {
    "path": "Cargo.toml",
    "chars": 1412,
    "preview": "[workspace]\nresolver = \"2\"\nmembers = [\n    \"cargo-guppy\",\n    \"fixtures\",\n    \"guppy\",\n    \"guppy-cmdlib\",\n    \"guppy-su"
  },
  {
    "path": "Cross.toml",
    "chars": 274,
    "preview": "[build.env]\npassthrough = [\"CARGO_PROFILE_RELEASE_LTO\"]\n\n[target.x86_64-unknown-freebsd]\n# The current cross 0.2.4 docke"
  },
  {
    "path": "Justfile",
    "chars": 2087,
    "preview": "# Note: help messages should be 1 line long as required by just.\n\n# Print a help message.\nhelp:\n    just --list\n\n# Run t"
  },
  {
    "path": "LICENSE-APACHE",
    "chars": 10847,
    "preview": "                              Apache License\n                        Version 2.0, January 2004\n                     http"
  },
  {
    "path": "LICENSE-MIT",
    "chars": 1067,
    "preview": "Copyright (c) The cargo-guppy Contributors\n\nPermission is hereby granted, free of charge, to any\nperson obtaining a copy"
  },
  {
    "path": "README.md",
    "chars": 7653,
    "preview": "# cargo-guppy: track and query dependency graphs\n\n[![Build Status](https://github.com/guppy-rs/guppy/workflows/CI/badge."
  },
  {
    "path": "cargo-guppy/Cargo.toml",
    "chars": 775,
    "preview": "[package]\nname = \"cargo-guppy\"\nversion = \"0.1.0\"\nauthors = [\"Rain <rain1@fb.com>\", \"Brandon Williams <bmwill@fb.com>\"]\nl"
  },
  {
    "path": "cargo-guppy/README.md",
    "chars": 1793,
    "preview": "# cargo-guppy\n\n[![Documentation (main)](https://img.shields.io/badge/docs-main-brightgreen)](https://guppy-rs.github.io/"
  },
  {
    "path": "cargo-guppy/README.tpl",
    "chars": 694,
    "preview": "# {{crate}}\n\n[![Documentation (main)](https://img.shields.io/badge/docs-main-brightgreen)](https://guppy-rs.github.io/gu"
  },
  {
    "path": "cargo-guppy/src/core.rs",
    "chars": 5600,
    "preview": "// Copyright (c) The cargo-guppy Contributors\n// SPDX-License-Identifier: MIT OR Apache-2.0\n\n//! Implementations for opt"
  },
  {
    "path": "cargo-guppy/src/diff.rs",
    "chars": 6506,
    "preview": "// Copyright (c) The cargo-guppy Contributors\n// SPDX-License-Identifier: MIT OR Apache-2.0\n\nuse guppy::{PackageId, grap"
  },
  {
    "path": "cargo-guppy/src/lib.rs",
    "chars": 16089,
    "preview": "// Copyright (c) The cargo-guppy Contributors\n// SPDX-License-Identifier: MIT OR Apache-2.0\n\n//! A command-line frontend"
  },
  {
    "path": "cargo-guppy/src/main.rs",
    "chars": 3467,
    "preview": "// Copyright (c) The cargo-guppy Contributors\n// SPDX-License-Identifier: MIT OR Apache-2.0\n\nuse cargo_guppy::{\n    CmdS"
  },
  {
    "path": "cargo-guppy/src/mv.rs",
    "chars": 19549,
    "preview": "// Copyright (c) The cargo-guppy Contributors\n// SPDX-License-Identifier: MIT OR Apache-2.0\n\nuse camino::{Utf8Path, Utf8"
  },
  {
    "path": "clippy.toml",
    "chars": 168,
    "preview": "disallowed-methods = [\n    # use ahash everywhere instead\n    \"std::collections::hash::map::HashMap::new\",\n    \"std::col"
  },
  {
    "path": "fixtures/Cargo.toml",
    "chars": 305,
    "preview": "[package]\nname = \"fixtures\"\nversion = \"0.1.0\"\nauthors = [\"Rain <rain1@fb.com>\"]\npublish = false\nedition = \"2024\"\n\n[depen"
  },
  {
    "path": "fixtures/README.md",
    "chars": 812,
    "preview": "# Fixtures for cargo-guppy\n\nThis directory contains interesting test corpuses used within the cargo-guppy codebase.\n\nThe"
  },
  {
    "path": "fixtures/determinator-paths/README.md",
    "chars": 400,
    "preview": "# determinator paths fixtures\n\nThis fixture is used to test that path matching works correctly across platforms.\n\n* `git"
  },
  {
    "path": "fixtures/determinator-paths/guppy-linux.json",
    "chars": 874889,
    "preview": "{\"packages\":[{\"name\":\"adler\",\"version\":\"0.2.3\",\"id\":\"adler 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)"
  },
  {
    "path": "fixtures/determinator-paths/guppy-win.json",
    "chars": 889333,
    "preview": "{\"packages\":[{\"name\":\"adler\",\"version\":\"0.2.3\",\"id\":\"adler 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)"
  },
  {
    "path": "fixtures/guppy/hakari/metadata_guppy_44b62fa-0.toml",
    "chars": 765,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_g"
  },
  {
    "path": "fixtures/guppy/hakari/metadata_guppy_44b62fa-1.toml",
    "chars": 1009,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_g"
  },
  {
    "path": "fixtures/guppy/hakari/metadata_guppy_44b62fa-2.toml",
    "chars": 656,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_g"
  },
  {
    "path": "fixtures/guppy/hakari/metadata_guppy_44b62fa-3.toml",
    "chars": 450,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_g"
  },
  {
    "path": "fixtures/guppy/hakari/metadata_guppy_78cb7e8-0.toml",
    "chars": 3346,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_g"
  },
  {
    "path": "fixtures/guppy/hakari/metadata_guppy_78cb7e8-1.toml",
    "chars": 21396,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_g"
  },
  {
    "path": "fixtures/guppy/hakari/metadata_guppy_78cb7e8-2.toml",
    "chars": 12663,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_g"
  },
  {
    "path": "fixtures/guppy/hakari/metadata_guppy_78cb7e8-3.toml",
    "chars": 2467,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_g"
  },
  {
    "path": "fixtures/guppy/hakari/metadata_guppy_869476c-0.toml",
    "chars": 1750,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_g"
  },
  {
    "path": "fixtures/guppy/hakari/metadata_guppy_869476c-1.toml",
    "chars": 1724,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_g"
  },
  {
    "path": "fixtures/guppy/hakari/metadata_guppy_869476c-2.toml",
    "chars": 10325,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_g"
  },
  {
    "path": "fixtures/guppy/hakari/metadata_guppy_869476c-3.toml",
    "chars": 2305,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_g"
  },
  {
    "path": "fixtures/guppy/hakari/metadata_guppy_c9b4f76-0.toml",
    "chars": 13370,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_g"
  },
  {
    "path": "fixtures/guppy/hakari/metadata_guppy_c9b4f76-1.toml",
    "chars": 13143,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_g"
  },
  {
    "path": "fixtures/guppy/hakari/metadata_guppy_c9b4f76-2.toml",
    "chars": 12692,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_g"
  },
  {
    "path": "fixtures/guppy/hakari/metadata_guppy_c9b4f76-3.toml",
    "chars": 16629,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_g"
  },
  {
    "path": "fixtures/guppy/metadata_guppy_44b62fa.json",
    "chars": 53770,
    "preview": "{\"packages\":[{\"name\":\"cargo-guppy\",\"version\":\"0.1.0\",\"id\":\"cargo-guppy 0.1.0 (path+file:///home/fakeuser/dev/cargo-guppy"
  },
  {
    "path": "fixtures/guppy/metadata_guppy_78cb7e8.json",
    "chars": 763945,
    "preview": "{\"packages\":[{\"name\":\"adler\",\"version\":\"0.2.3\",\"id\":\"adler 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)"
  },
  {
    "path": "fixtures/guppy/metadata_guppy_869476c.json",
    "chars": 763945,
    "preview": "{\"packages\":[{\"name\":\"adler\",\"version\":\"0.2.3\",\"id\":\"adler 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)"
  },
  {
    "path": "fixtures/guppy/metadata_guppy_c9b4f76.json",
    "chars": 763945,
    "preview": "{\"packages\":[{\"name\":\"adler\",\"version\":\"0.2.3\",\"id\":\"adler 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)"
  },
  {
    "path": "fixtures/guppy/package-rules.toml",
    "chars": 454,
    "preview": "# This file lists out determinator package rules that can be used in tests.\n\nuse-default-rules = false\n\n# This path rule"
  },
  {
    "path": "fixtures/guppy/path-rules.toml",
    "chars": 725,
    "preview": "# This file lists out determinator path rules that can be used in tests.\n\n[[path-rule]]\n# Ignore README files.\nglobs = ["
  },
  {
    "path": "fixtures/guppy/summaries/metadata_guppy_44b62fa-0.toml",
    "chars": 1156,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/guppy/summaries/metadata_guppy_44b62fa-1.toml",
    "chars": 1133,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/guppy/summaries/metadata_guppy_44b62fa-2.toml",
    "chars": 1685,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/guppy/summaries/metadata_guppy_44b62fa-3.toml",
    "chars": 925,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/guppy/summaries/metadata_guppy_44b62fa-4.toml",
    "chars": 1507,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/guppy/summaries/metadata_guppy_44b62fa-5.toml",
    "chars": 613,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/guppy/summaries/metadata_guppy_44b62fa-6.toml",
    "chars": 1765,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/guppy/summaries/metadata_guppy_44b62fa-7.toml",
    "chars": 2130,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/guppy/summaries/metadata_guppy_78cb7e8-0.toml",
    "chars": 4212,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/guppy/summaries/metadata_guppy_78cb7e8-1.toml",
    "chars": 5896,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/guppy/summaries/metadata_guppy_78cb7e8-2.toml",
    "chars": 19811,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/guppy/summaries/metadata_guppy_78cb7e8-3.toml",
    "chars": 10065,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/guppy/summaries/metadata_guppy_78cb7e8-4.toml",
    "chars": 2175,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/guppy/summaries/metadata_guppy_78cb7e8-5.toml",
    "chars": 28885,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/guppy/summaries/metadata_guppy_78cb7e8-6.toml",
    "chars": 12232,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/guppy/summaries/metadata_guppy_78cb7e8-7.toml",
    "chars": 4476,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/guppy/summaries/metadata_guppy_869476c-0.toml",
    "chars": 21885,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/guppy/summaries/metadata_guppy_869476c-1.toml",
    "chars": 8324,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/guppy/summaries/metadata_guppy_869476c-2.toml",
    "chars": 3708,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/guppy/summaries/metadata_guppy_869476c-3.toml",
    "chars": 12686,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/guppy/summaries/metadata_guppy_869476c-4.toml",
    "chars": 12454,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/guppy/summaries/metadata_guppy_869476c-5.toml",
    "chars": 11337,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/guppy/summaries/metadata_guppy_869476c-6.toml",
    "chars": 10995,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/guppy/summaries/metadata_guppy_869476c-7.toml",
    "chars": 13341,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/guppy/summaries/metadata_guppy_c9b4f76-0.toml",
    "chars": 11964,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/guppy/summaries/metadata_guppy_c9b4f76-1.toml",
    "chars": 9488,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/guppy/summaries/metadata_guppy_c9b4f76-2.toml",
    "chars": 8935,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/guppy/summaries/metadata_guppy_c9b4f76-3.toml",
    "chars": 24922,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/guppy/summaries/metadata_guppy_c9b4f76-4.toml",
    "chars": 15821,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/guppy/summaries/metadata_guppy_c9b4f76-5.toml",
    "chars": 20519,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/guppy/summaries/metadata_guppy_c9b4f76-6.toml",
    "chars": 10310,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/guppy/summaries/metadata_guppy_c9b4f76-7.toml",
    "chars": 4889,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/invalid/build_targets_duplicate_lib.json",
    "chars": 2068,
    "preview": "{\"packages\":[{\"name\":\"testcrate\",\"version\":\"0.1.0\",\"id\":\"testcrate 0.1.0 (path+file:///Users/fakeuser/local/testcrates/t"
  },
  {
    "path": "fixtures/invalid/build_targets_empty_kinds.json",
    "chars": 2065,
    "preview": "{\"packages\":[{\"name\":\"testcrate\",\"version\":\"0.1.0\",\"id\":\"testcrate 0.1.0 (path+file:///Users/fakeuser/local/testcrates/t"
  },
  {
    "path": "fixtures/invalid/build_targets_non_bin.json",
    "chars": 2075,
    "preview": "{\"packages\":[{\"name\":\"testcrate\",\"version\":\"0.1.0\",\"id\":\"testcrate 0.1.0 (path+file:///Users/fakeuser/local/testcrates/t"
  },
  {
    "path": "fixtures/invalid/duplicate_workspace_names.json",
    "chars": 2040,
    "preview": "{\"packages\":[{\"name\":\"pkg\",\"version\":\"0.1.0\",\"id\":\"pkg 0.1.0 (path+file:///Users/fakeuser/local/testcrates/testworkspace"
  },
  {
    "path": "fixtures/invalid/invalid_default_member.json",
    "chars": 3342,
    "preview": "{\n  \"packages\": [\n    {\n      \"name\": \"testcrate\",\n      \"version\": \"0.1.0\",\n      \"id\": \"testcrate 0.1.0 (path+file:///"
  },
  {
    "path": "fixtures/invalid/named_feature_self_loop.json",
    "chars": 3488,
    "preview": "{\n  \"packages\": [\n    {\n      \"name\": \"a\",\n      \"version\": \"0.1.0\",\n      \"id\": \"path+file:///home/fakeuser/dev/tmp/nam"
  },
  {
    "path": "fixtures/invalid/optional_dev_dep.json",
    "chars": 3519,
    "preview": "{\"packages\":[{\"name\":\"lazy_static\",\"version\":\"1.4.0\",\"id\":\"lazy_static 1.4.0 (registry+https://github.com/rust-lang/crat"
  },
  {
    "path": "fixtures/invalid/workspace_member_different_drive.json",
    "chars": 999,
    "preview": "{\"packages\":[{\"name\":\"testcrate\",\"version\":\"0.1.0\",\"id\":\"testcrate 0.1.0 (path+file:///D:/other-drive/testcrate)\",\"licen"
  },
  {
    "path": "fixtures/large/hakari/hyper_util_7afb1ed-0.toml",
    "chars": 8191,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture hyper_util"
  },
  {
    "path": "fixtures/large/hakari/hyper_util_7afb1ed-1.toml",
    "chars": 1222,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture hyper_util"
  },
  {
    "path": "fixtures/large/hakari/hyper_util_7afb1ed-2.toml",
    "chars": 7105,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture hyper_util"
  },
  {
    "path": "fixtures/large/hakari/hyper_util_7afb1ed-3.toml",
    "chars": 1268,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture hyper_util"
  },
  {
    "path": "fixtures/large/hakari/metadata_libra-0.toml",
    "chars": 46460,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_l"
  },
  {
    "path": "fixtures/large/hakari/metadata_libra-1.toml",
    "chars": 37294,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_l"
  },
  {
    "path": "fixtures/large/hakari/metadata_libra-2.toml",
    "chars": 5180,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_l"
  },
  {
    "path": "fixtures/large/hakari/metadata_libra-3.toml",
    "chars": 11128,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_l"
  },
  {
    "path": "fixtures/large/hakari/metadata_libra_9ffd93b-0.toml",
    "chars": 39024,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_l"
  },
  {
    "path": "fixtures/large/hakari/metadata_libra_9ffd93b-1.toml",
    "chars": 9236,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_l"
  },
  {
    "path": "fixtures/large/hakari/metadata_libra_9ffd93b-2.toml",
    "chars": 12022,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_l"
  },
  {
    "path": "fixtures/large/hakari/metadata_libra_9ffd93b-3.toml",
    "chars": 46804,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_l"
  },
  {
    "path": "fixtures/large/hakari/metadata_libra_f0091a4-0.toml",
    "chars": 53100,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_l"
  },
  {
    "path": "fixtures/large/hakari/metadata_libra_f0091a4-1.toml",
    "chars": 62244,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_l"
  },
  {
    "path": "fixtures/large/hakari/metadata_libra_f0091a4-2.toml",
    "chars": 7555,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_l"
  },
  {
    "path": "fixtures/large/hakari/metadata_libra_f0091a4-3.toml",
    "chars": 28737,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_l"
  },
  {
    "path": "fixtures/large/hakari/mnemos_b3b4da9-0.toml",
    "chars": 91253,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture mnemos_b3b"
  },
  {
    "path": "fixtures/large/hakari/mnemos_b3b4da9-1.toml",
    "chars": 80530,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture mnemos_b3b"
  },
  {
    "path": "fixtures/large/hakari/mnemos_b3b4da9-2.toml",
    "chars": 17598,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture mnemos_b3b"
  },
  {
    "path": "fixtures/large/hakari/mnemos_b3b4da9-3.toml",
    "chars": 87835,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture mnemos_b3b"
  },
  {
    "path": "fixtures/large/hyper_util_7afb1ed.json",
    "chars": 606123,
    "preview": "{\n  \"packages\": [\n    {\n      \"name\": \"addr2line\",\n      \"version\": \"0.22.0\",\n      \"id\": \"registry+https://github.com/r"
  },
  {
    "path": "fixtures/large/metadata_libra.json",
    "chars": 1892550,
    "preview": "{\"packages\":[{\"name\":\"bech32\",\"version\":\"0.6.0\",\"id\":\"bech32 0.6.0 (registry+https://github.com/rust-lang/crates.io-inde"
  },
  {
    "path": "fixtures/large/metadata_libra_9ffd93b.json",
    "chars": 2428281,
    "preview": "{\"packages\":[{\"name\":\"http-body\",\"version\":\"0.1.0\",\"id\":\"http-body 0.1.0 (registry+https://github.com/rust-lang/crates.i"
  },
  {
    "path": "fixtures/large/metadata_libra_f0091a4.json",
    "chars": 2105330,
    "preview": "{\"packages\":[{\"name\":\"serde_urlencoded\",\"version\":\"0.6.1\",\"id\":\"serde_urlencoded 0.6.1 (registry+https://github.com/rust"
  },
  {
    "path": "fixtures/large/mnemos_b3b4da9.json",
    "chars": 6165962,
    "preview": "{\n  \"packages\": [\n    {\n      \"name\": \"CoreFoundation-sys\",\n      \"version\": \"0.1.4\",\n      \"id\": \"CoreFoundation-sys 0."
  },
  {
    "path": "fixtures/large/summaries/hyper_util_7afb1ed-0.toml",
    "chars": 8313,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture hype"
  },
  {
    "path": "fixtures/large/summaries/hyper_util_7afb1ed-1.toml",
    "chars": 7818,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture hype"
  },
  {
    "path": "fixtures/large/summaries/hyper_util_7afb1ed-2.toml",
    "chars": 8841,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture hype"
  },
  {
    "path": "fixtures/large/summaries/hyper_util_7afb1ed-3.toml",
    "chars": 5894,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture hype"
  },
  {
    "path": "fixtures/large/summaries/hyper_util_7afb1ed-4.toml",
    "chars": 1961,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture hype"
  },
  {
    "path": "fixtures/large/summaries/hyper_util_7afb1ed-5.toml",
    "chars": 5044,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture hype"
  },
  {
    "path": "fixtures/large/summaries/hyper_util_7afb1ed-6.toml",
    "chars": 4464,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture hype"
  },
  {
    "path": "fixtures/large/summaries/hyper_util_7afb1ed-7.toml",
    "chars": 5069,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture hype"
  },
  {
    "path": "fixtures/large/summaries/metadata_libra-0.toml",
    "chars": 28353,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/large/summaries/metadata_libra-1.toml",
    "chars": 43274,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/large/summaries/metadata_libra-2.toml",
    "chars": 73714,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/large/summaries/metadata_libra-3.toml",
    "chars": 55450,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/large/summaries/metadata_libra-4.toml",
    "chars": 58239,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/large/summaries/metadata_libra-5.toml",
    "chars": 44739,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/large/summaries/metadata_libra-6.toml",
    "chars": 64197,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/large/summaries/metadata_libra-7.toml",
    "chars": 58304,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/large/summaries/metadata_libra_9ffd93b-0.toml",
    "chars": 41500,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/large/summaries/metadata_libra_9ffd93b-1.toml",
    "chars": 50997,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/large/summaries/metadata_libra_9ffd93b-2.toml",
    "chars": 49152,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/large/summaries/metadata_libra_9ffd93b-3.toml",
    "chars": 67493,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/large/summaries/metadata_libra_9ffd93b-4.toml",
    "chars": 48218,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/large/summaries/metadata_libra_9ffd93b-5.toml",
    "chars": 37889,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/large/summaries/metadata_libra_9ffd93b-6.toml",
    "chars": 67249,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/large/summaries/metadata_libra_9ffd93b-7.toml",
    "chars": 38614,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/large/summaries/metadata_libra_f0091a4-0.toml",
    "chars": 36532,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/large/summaries/metadata_libra_f0091a4-1.toml",
    "chars": 1859,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/large/summaries/metadata_libra_f0091a4-2.toml",
    "chars": 36847,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/large/summaries/metadata_libra_f0091a4-3.toml",
    "chars": 23718,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/large/summaries/metadata_libra_f0091a4-4.toml",
    "chars": 61339,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/large/summaries/metadata_libra_f0091a4-5.toml",
    "chars": 46663,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/large/summaries/metadata_libra_f0091a4-6.toml",
    "chars": 34914,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/large/summaries/metadata_libra_f0091a4-7.toml",
    "chars": 78838,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture meta"
  },
  {
    "path": "fixtures/large/summaries/mnemos_b3b4da9-0.toml",
    "chars": 66517,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture mnem"
  },
  {
    "path": "fixtures/large/summaries/mnemos_b3b4da9-1.toml",
    "chars": 18667,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture mnem"
  },
  {
    "path": "fixtures/large/summaries/mnemos_b3b4da9-2.toml",
    "chars": 145998,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture mnem"
  },
  {
    "path": "fixtures/large/summaries/mnemos_b3b4da9-3.toml",
    "chars": 27453,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture mnem"
  },
  {
    "path": "fixtures/large/summaries/mnemos_b3b4da9-4.toml",
    "chars": 47359,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture mnem"
  },
  {
    "path": "fixtures/large/summaries/mnemos_b3b4da9-5.toml",
    "chars": 22934,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture mnem"
  },
  {
    "path": "fixtures/large/summaries/mnemos_b3b4da9-6.toml",
    "chars": 157440,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture mnem"
  },
  {
    "path": "fixtures/large/summaries/mnemos_b3b4da9-7.toml",
    "chars": 70869,
    "preview": "# This summary was @generated. To regenerate, run:\n#   cargo run -p fixture-manager -- generate-summaries --fixture mnem"
  },
  {
    "path": "fixtures/small/alternate-registries.json",
    "chars": 41973,
    "preview": "{\"packages\":[{\"name\":\"debug-ignore\",\"version\":\"1.0.1\",\"id\":\"debug-ignore 1.0.1 (path+file:///home/fakeuser/dev/debug-ign"
  },
  {
    "path": "fixtures/small/builddep.json",
    "chars": 2762,
    "preview": "{\"packages\":[{\"name\":\"builddep\",\"version\":\"0.1.0\",\"id\":\"builddep 0.1.0 (path+file:///home/fakeuser/dev/tmp/test-workspac"
  },
  {
    "path": "fixtures/small/hakari/metadata1-0.toml",
    "chars": 1268,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata1\n"
  },
  {
    "path": "fixtures/small/hakari/metadata1-1.toml",
    "chars": 2638,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata1\n"
  },
  {
    "path": "fixtures/small/hakari/metadata1-2.toml",
    "chars": 2371,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata1\n"
  },
  {
    "path": "fixtures/small/hakari/metadata1-3.toml",
    "chars": 2301,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata1\n"
  },
  {
    "path": "fixtures/small/hakari/metadata2-0.toml",
    "chars": 2038,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata2\n"
  },
  {
    "path": "fixtures/small/hakari/metadata2-1.toml",
    "chars": 2652,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata2\n"
  },
  {
    "path": "fixtures/small/hakari/metadata2-2.toml",
    "chars": 593,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata2\n"
  },
  {
    "path": "fixtures/small/hakari/metadata2-3.toml",
    "chars": 1249,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata2\n"
  },
  {
    "path": "fixtures/small/hakari/metadata_alternate_registries-0.toml",
    "chars": 1984,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_a"
  },
  {
    "path": "fixtures/small/hakari/metadata_alternate_registries-1.toml",
    "chars": 1021,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_a"
  },
  {
    "path": "fixtures/small/hakari/metadata_alternate_registries-2.toml",
    "chars": 1146,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_a"
  },
  {
    "path": "fixtures/small/hakari/metadata_alternate_registries-3.toml",
    "chars": 1759,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_a"
  },
  {
    "path": "fixtures/small/hakari/metadata_build_targets1-0.toml",
    "chars": 685,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_b"
  },
  {
    "path": "fixtures/small/hakari/metadata_build_targets1-1.toml",
    "chars": 673,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_b"
  },
  {
    "path": "fixtures/small/hakari/metadata_build_targets1-2.toml",
    "chars": 572,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_b"
  },
  {
    "path": "fixtures/small/hakari/metadata_build_targets1-3.toml",
    "chars": 653,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_b"
  },
  {
    "path": "fixtures/small/hakari/metadata_builddep-0.toml",
    "chars": 858,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_b"
  },
  {
    "path": "fixtures/small/hakari/metadata_builddep-1.toml",
    "chars": 807,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_b"
  },
  {
    "path": "fixtures/small/hakari/metadata_builddep-2.toml",
    "chars": 858,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_b"
  },
  {
    "path": "fixtures/small/hakari/metadata_builddep-3.toml",
    "chars": 754,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_b"
  },
  {
    "path": "fixtures/small/hakari/metadata_cycle1-0.toml",
    "chars": 759,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_c"
  },
  {
    "path": "fixtures/small/hakari/metadata_cycle1-1.toml",
    "chars": 644,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_c"
  },
  {
    "path": "fixtures/small/hakari/metadata_cycle1-2.toml",
    "chars": 837,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_c"
  },
  {
    "path": "fixtures/small/hakari/metadata_cycle1-3.toml",
    "chars": 758,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_c"
  },
  {
    "path": "fixtures/small/hakari/metadata_cycle2-0.toml",
    "chars": 915,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_c"
  },
  {
    "path": "fixtures/small/hakari/metadata_cycle2-1.toml",
    "chars": 932,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_c"
  },
  {
    "path": "fixtures/small/hakari/metadata_cycle2-2.toml",
    "chars": 1152,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_c"
  },
  {
    "path": "fixtures/small/hakari/metadata_cycle2-3.toml",
    "chars": 979,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_c"
  },
  {
    "path": "fixtures/small/hakari/metadata_cycle_features-0.toml",
    "chars": 956,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_c"
  },
  {
    "path": "fixtures/small/hakari/metadata_cycle_features-1.toml",
    "chars": 889,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_c"
  },
  {
    "path": "fixtures/small/hakari/metadata_cycle_features-2.toml",
    "chars": 884,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_c"
  },
  {
    "path": "fixtures/small/hakari/metadata_cycle_features-3.toml",
    "chars": 693,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_c"
  },
  {
    "path": "fixtures/small/hakari/metadata_dups-0.toml",
    "chars": 839,
    "preview": "# This file is @generated. To regenerate, run:\n#    cargo run -p fixture-manager -- generate-hakari --fixture metadata_d"
  }
]

// ... and 378 more files (download for full content)