ci-cargo

manifest.rs (150615B)

---

 use super::{
     args::NonZeroUsizePlus1,
     cargo::{Toolchain, ToolchainErr},
 };
 use alloc::borrow::Cow;
 use core::cmp::Ordering;
 use std::{
     fs,
     io::{Error, ErrorKind, StderrLock, Write as _},
     path::{Path, PathBuf},
 };
 use toml::{
     Spanned,
     de::{DeArray, DeValue, Error as TomlErr},
     map::Map,
 };
 /// `"workspace"`.
 const WORKSPACE: &str = "workspace";
 /// `"package"`.
 const PACKAGE: &str = "package";
 /// `"rust-version"`.
 const RUST_VERSION: &str = "rust-version";
 /// Error returned from extracting `"workspace"`.
 #[cfg_attr(test, derive(Debug, PartialEq))]
 #[derive(Clone, Copy)]
 pub(crate) enum WorkspaceErr {
     /// Variant returned when there is no `"workspace"` key.
     Missing,
     /// Variant returned when `"workspace"` is not a table.
     InvalidType,
     /// Variant returned when `workspace.package` does not exist.
     MissingPackage,
     /// Variant returned when `workspace.package` is not a table.
     InvalidPackageType,
     /// Variant returned when `workspace.package.rust-version` does not exist.
     MissingPackageMsrv,
     /// Variant returned when `workspace.package.rust-version` is not a string.
     InvalidPackageMsrvType,
     /// Variant returned when `workspace.package.rust-version` is not a valid MSRV.
     Msrv,
 }
 impl WorkspaceErr {
     /// Writes `self` to `stderr`.
     fn write(self, mut stderr: StderrLock<'_>, file: &Path) -> Result<(), Error> {
         match self {
             Self::Missing => writeln!(
                 stderr,
                 "'{WORKSPACE}' does not exist in {}.",
                 file.display()
             ),
             Self::InvalidType => writeln!(
                 stderr,
                 "'{WORKSPACE}' exists but is not a table in {}.",
                 file.display()
             ),
             Self::MissingPackage => writeln!(
                 stderr,
                 "'{WORKSPACE}.{PACKAGE}' does not exist in {}.",
                 file.display()
             ),
             Self::InvalidPackageType => writeln!(
                 stderr,
                 "'{WORKSPACE}.{PACKAGE}' exists but is not a table in {}.",
                 file.display()
             ),
             Self::MissingPackageMsrv => writeln!(
                 stderr,
                 "'{WORKSPACE}.{PACKAGE}.{RUST_VERSION}' does not exist in {}.",
                 file.display()
             ),
             Self::InvalidPackageMsrvType => writeln!(
                 stderr,
                 "'{WORKSPACE}.{PACKAGE}.{RUST_VERSION}' exists but is not a string in {}.",
                 file.display()
             ),
             Self::Msrv => writeln!(
                 stderr,
                 "'{WORKSPACE}.{PACKAGE}.{RUST_VERSION}' exists but is not a valid MSRV in {}.",
                 file.display()
             ),
         }
     }
 }
 /// `"name"`.
 const NAME: &str = "name";
 /// Error returned from extracting `"package"`.
 #[cfg_attr(test, derive(Debug))]
 pub(crate) enum PackageErr {
     /// Variant returned when there is no `"package"` key.
     Missing,
     /// Variant returned when `"package"` is not a table.
     InvalidType,
     /// Variant returned when `packagen.name` does not exist.
     MissingName,
     /// Variant returned when `package.name` is not a string.
     InvalidNameType,
     /// Variant returned when `package.rust-version` is not a string nor table.
     InvalidMsrvType,
     /// Variant returned when `package.rust-version` is not a valid MSRV.
     Msrv,
     /// Variant returned when `package.rust-version` is table that doesn't contain the `"workspace"` key.
     MsrvWorkspaceMissing,
     /// Variant returned when `package.rust-version.workspace` is not a Boolean with value `true`.
     MsrvWorkspaceVal,
     /// Variant returned when `package.workspace` is not a string.
     InvalidWorkspaceType,
     /// Variant returned when searching for the workspace file errors.
     WorkspaceIo(Error),
     /// Variant returned when there is no workspace `Cargo.toml`.
     ///
     /// This is only returned if the package's MSRV is inherited from the workspace, there is no
     /// `workspace` key in the package's `Cargo.toml`, and there is no `workspace` key in the table
     /// `package` (i.e., this is only returned when we must search for it by crawling up the directory).
     WorkspaceDoesNotExist,
     /// Variant returned when the file located at `package.workspace` could not be read.
     ///
     /// This is only returned if the table `package` had a key `workspace` that was a string, or we searched
     /// for the workspace and found a `Cargo.toml`.
     WorkspaceRead(Error, PathBuf),
     /// Variant returned when the file located at `package.workspace` is not valid TOML.
     ///
     /// This is only returned if the table `package` had a key `workspace` that was a string, or we searched
     /// for the workspace and found a `Cargo.toml`.
     WorkspaceToml(TomlErr, PathBuf),
     /// Variant returned when `package.rust-version` defers to the workspace MSRV, but there was an error
     /// extracting the workspace MSRV from the file located at the contained `PathBuf`.
     Workspace(WorkspaceErr, PathBuf),
 }
 impl PackageErr {
     /// Writes `self` to `stderr`.
     #[expect(clippy::unreachable, reason = "want to crash when there is a bug")]
     fn write(self, mut stderr: StderrLock<'_>, file: &Path) -> Result<(), Error> {
         match self {
             Self::Missing => writeln!(stderr, "'{PACKAGE}' does not exist in {}.", file.display()),
             Self::InvalidType => writeln!(
                 stderr,
                 "'{PACKAGE}' exists but is not a table in {}.",
                 file.display()
             ),
             Self::MissingName => writeln!(stderr, "'{PACKAGE}.{NAME}' does not exist in {}.", file.display()),
             Self::InvalidNameType => writeln!(
                 stderr,
                 "'{PACKAGE}.{NAME}' exists but is not a string in {}.",
                 file.display()
             ),
             Self::InvalidMsrvType => writeln!(
                 stderr,
                 "'{PACKAGE}.{RUST_VERSION}' exists but is not a string nor table in {}.",
                 file.display()
             ),
             Self::Msrv => writeln!(
                 stderr,
                 "'{PACKAGE}.{RUST_VERSION}' is a string but is not a valid MSRV in {}.",
                 file.display()
             ),
             Self::MsrvWorkspaceMissing => writeln!(
                 stderr,
                 "'{PACKAGE}.{RUST_VERSION}' is a table but does not contain the key '{WORKSPACE}' in {}.",
                 file.display()
             ),
             Self::MsrvWorkspaceVal => writeln!(
                 stderr,
                 "'{PACKAGE}.{RUST_VERSION}.{WORKSPACE}' exists but is not a Boolean or is not true in {}.",
                 file.display()
             ),
             Self::WorkspaceIo(e) => writeln!(
                 stderr,
                 "There was an error looking for the workspace Cargo.toml in {} and its ancestor directories: {e}.",
                 file.parent().unwrap_or_else(|| unreachable!("there is a bug in main. manifest::Manifest::from_toml must be passed the absolute path to the package's Cargo.toml.")).display(),
             ),
             Self::WorkspaceDoesNotExist => writeln!(
                 stderr,
                 "There is no workspace Cargo.toml in {} nor its ancestor directories.",
                 file.parent().unwrap_or_else(|| unreachable!("there is a bug in main. manifest::Manifest::from_toml must be passed the absolute path to the package's Cargo.toml.")).display(),
             ),
             Self::InvalidWorkspaceType => writeln!(
                 stderr,
                 "'{PACKAGE}.{WORKSPACE}' exists but is not a string in {}.",
                 file.display()
             ),
             Self::WorkspaceRead(e, p) => {
                 writeln!(stderr, "There was an issue reading the workspace file {}: {e}.", p.display())
             }
             Self::WorkspaceToml(e, p) => write!(
                 stderr,
                 "Error parsing workspace file {} as TOML: {e}.",
                 p.display()
             ),
             Self::Workspace(e, p) => e.write(stderr, &p),
         }
     }
 }
 /// `"features"`.
 const FEATURES: &str = "features";
 /// Error returned from extracting feature dependencies.
 #[cfg_attr(test, derive(Debug, PartialEq))]
 pub(crate) enum FeatureDependenciesErr {
     /// Variant returned when a feature is not an array.
     ///
     /// The contained `String` is the name of the feature.
     InvalidFeatureType(String),
     /// Variant returned when a feature dependency is not a string.
     ///
     /// The contained `String` is the name of the feature.
     InvalidDependencyType(String),
     /// Variant returned when a feature dependency is not a feature nor dependency.
     ///
     /// The first contained `String` is the name of the feature, and the second `String` is the name of the invalid
     /// feature dependency.
     ///
     /// Note this is only possible when `allow_implied_features` is `false` when passed to
     /// [`Features::validate_dependencies`].
     InvalidDependency(String, String),
     /// Variant returned when a feature is cyclic.
     ///
     /// The contained `String` is the name of the feature.
     CyclicFeature(String),
     /// Variant returned when a feature dependency is redundant.
     ///
     /// The first contained `String` is the name of the feature, and the second `String` is the name of the
     /// redundant feature dependency.
     RedundantDependency(String, String),
 }
 impl FeatureDependenciesErr {
     /// Writes `self` to `stderr`.
     fn write(self, mut stderr: StderrLock<'_>, file: &Path) -> Result<(), Error> {
         match self {
             Self::InvalidFeatureType(name) => {
                 writeln!(
                     stderr,
                     "'{FEATURES}.{name}' is not an array in {}.",
                     file.display()
                 )
             }
             Self::InvalidDependencyType(name) => writeln!(
                 stderr,
                 "'{FEATURES}.{name}' contains a value that is not a string in {}.",
                 file.display()
             ),
             Self::InvalidDependency(name, dep_name) => writeln!(
                 stderr,
                 "'{FEATURES}.{name}' contains '{dep_name}' which is neither a feature nor dependency in {}. It may be an implied feature from an optional dependency, but --allow-implied-features was not passed.",
                 file.display()
             ),
             Self::CyclicFeature(name) => writeln!(
                 stderr,
                 "'{FEATURES}.{name}' is a cyclic feature in {}.",
                 file.display()
             ),
             Self::RedundantDependency(name, dep_name) => writeln!(
                 stderr,
                 "'{FEATURES}.{name}' contains the redundant dependency '{dep_name}' in {}.",
                 file.display()
             ),
         }
     }
 }
 /// Error returned from extracting `"features"`.
 #[cfg_attr(test, derive(Debug, PartialEq))]
 pub(crate) enum FeaturesErr {
     /// Variant returned when `features` is not a table in Cargo.toml.
     InvalidType,
     /// Variant returned when `features` contains a feature with an invalid name.
     ///
     /// The contained `String` is the name of the feature.
     InvalidName(String),
     /// Variant returned when there is an issue with a feature's dependencies.
     FeatureDependencies(FeatureDependenciesErr),
 }
 impl FeaturesErr {
     /// Writes `self` to `stderr`.
     fn write(self, mut stderr: StderrLock<'_>, file: &Path) -> Result<(), Error> {
         match self {
             Self::InvalidType => {
                 writeln!(
                     stderr,
                     "'{FEATURES}' exists but is not a table in {}.",
                     file.display()
                 )
             }
             Self::InvalidName(name) => {
                 writeln!(
                     stderr,
                     "'{FEATURES}.{name}' is not a valid feature name in {}.",
                     file.display()
                 )
             }
             Self::FeatureDependencies(e) => e.write(stderr, file),
         }
     }
 }
 /// Error returned from extracting dependencies.
 #[cfg_attr(test, derive(Debug, PartialEq))]
 pub(crate) enum DependenciesErr {
     /// Variant returned when the dependencies is not a table.
     ///
     /// The contained `str` is the name of the dependencies (e.g., `"dependencies"`).
     Type(&'static str),
     /// Variant returned when a dependency has an invalid name.
     ///
     /// The contained `str` is the name of dependencies (e.g., `"dependencies"`), and the `String` is the
     /// name of the dependency.
     Name(&'static str, String),
     /// Variant returned when a dependency is not a string or table.
     ///
     /// The contained `str` is the name of dependencies (e.g., `"dependencies"`), and the `String` is the
     /// name of the dependency.
     DependencyType(&'static str, String),
     /// Variant returned when a dependency contains an `"optional"` key whose value is not a Boolean.
     ///
     /// The contained `str` is the name of dependencies (e.g., `"dependencies"`), and the `String` is the
     /// name of the dependency.
     OptionalType(&'static str, String),
     /// Variant returned when an optional dependency would cause an implied feature to be created.
     ///
     /// Note this is only possible when `allow_implied_features` is `false` when passed to
     /// [`Features::add_optional_dependencies`].
     ///
     /// The contained `str` is the name of dependencies (e.g., `"dependencies"`), and the `String` is the
     /// name of the dependency.
     ImpliedFeature(&'static str, String),
 }
 /// Error returned from extracting dependencies to add implied features.
 #[cfg_attr(test, derive(Debug, PartialEq))]
 pub(crate) enum ImpliedFeaturesErr {
     /// Variant returned from extracting dependencies.
     Dependencies(DependenciesErr),
     /// Variant returned when `target` is not a table in Cargo.toml.
     TargetType,
     /// Variant returned when `target` contains a key whose value is not a table.
     ///
     /// The contained `String` is the name of the key.
     TargetPlatformType(String),
     /// Variant returned when a target platform contains an issue with dependencies.
     ///
     /// The contained `String` is the name of the target platform.
     TagetPlatformDependencies(String, DependenciesErr),
     /// Variant returned when a feature dependency is not a feature nor dependency.
     ///
     /// The first contained `String` is the name of the feature, and the second `String` is the name of the invalid
     /// feature dependency.
     ///
     /// Note this is only possible when `allow_implied_features` is `true` when passed to
     /// [`Features::validate_dependencies`] since when `false` we verify the the dependency
     /// is defined as a feature.
     InvalidDependency(String, String),
 }
 /// `"optional"`.
 const OPTIONAL: &str = "optional";
 /// `"target"`.
 const TARGET: &str = "target";
 impl ImpliedFeaturesErr {
     /// Writes `self` to `stderr`.
     fn write(self, mut stderr: StderrLock<'_>, file: &Path) -> Result<(), Error> {
         match self {
             Self::Dependencies(e) => match e {
                 DependenciesErr::Type(name) => {
                     writeln!(
                         stderr,
                         "'{name}' exists but is not a table in {}.",
                         file.display()
                     )
                 }
                 DependenciesErr::Name(name, dep_name) => {
                     writeln!(
                         stderr,
                         "'{name}.{dep_name}' is not a valid dependency name in {}.",
                         file.display()
                     )
                 }
                 DependenciesErr::DependencyType(name, dep_name) => {
                     writeln!(
                         stderr,
                         "'{name}.{dep_name}' exists but is not a string nor table in {}.",
                         file.display()
                     )
                 }
                 DependenciesErr::OptionalType(name, dep_name) => {
                     writeln!(
                         stderr,
                         "'{name}.{dep_name}.{OPTIONAL}' exists but is not a Boolean in {}.",
                         file.display()
                     )
                 }
                 DependenciesErr::ImpliedFeature(name, dep_name) => {
                     writeln!(
                         stderr,
                         "'{name}.{dep_name}' causes an implied feature to be defined in {}, but implied features were forbidden. --allow-implied-features can be passed to allow it.",
                         file.display()
                     )
                 }
             },
             Self::TargetType => {
                 writeln!(
                     stderr,
                     "'{TARGET}' exists but is not a table in {}.",
                     file.display()
                 )
             }
             Self::TargetPlatformType(name) => {
                 writeln!(
                     stderr,
                     "'{TARGET}.{name}' exists but is not a table in {}.",
                     file.display()
                 )
             }
             Self::TagetPlatformDependencies(name, e) => match e {
                 DependenciesErr::Type(table_name) => {
                     writeln!(
                         stderr,
                         "'{TARGET}.{name}.{table_name}' exists but is not a table in {}.",
                         file.display()
                     )
                 }
                 DependenciesErr::Name(table_name, dep_name) => {
                     writeln!(
                         stderr,
                         "'{TARGET}.{name}.{table_name}.{dep_name}' is not a valid dependency name in {}.",
                         file.display()
                     )
                 }
                 DependenciesErr::DependencyType(table_name, dep_name) => writeln!(
                     stderr,
                     "'{TARGET}.{name}.{table_name}.{dep_name}' exists but is not a string nor table in {}.",
                     file.display()
                 ),
                 DependenciesErr::OptionalType(table_name, dep_name) => writeln!(
                     stderr,
                     "'{TARGET}.{name}.{table_name}.{dep_name}.{OPTIONAL}' exists but is not a Boolean in {}.",
                     file.display()
                 ),
                 DependenciesErr::ImpliedFeature(table_name, dep_name) => {
                     writeln!(
                         stderr,
                         "'{TARGET}.{name}.{table_name}.{dep_name}' causes an implied feature to be defined in {}, but implied features were forbidden. --allow-implied-features can be passed to allow it.",
                         file.display()
                     )
                 }
             },
             Self::InvalidDependency(name, dep_name) => writeln!(
                 stderr,
                 "'{FEATURES}.{name}' contains '{dep_name}' which is neither a feature nor dependency in {}.",
                 file.display()
             ),
         }
     }
 }
 /// Error returned from parsing Cargo.toml.
 #[cfg_attr(test, derive(Debug, PartialEq))]
 pub(crate) enum ManifestErr {
     /// Variant returned when Cargo.toml is not valid TOML.
     Toml(TomlErr, PathBuf),
     /// Variant returned when extracting `package`.
     Package(PackageErr, PathBuf),
     /// Variant returned when extracting `features`.
     Features(FeaturesErr, PathBuf),
     /// Variant returned when extracting dependencies in order to add implied features.
     ImpliedFeatures(ImpliedFeaturesErr, PathBuf),
     /// Variant returned when ignoring a feature that does not exist.
     UndefinedIgnoreFeature(String, PathBuf),
 }
 impl ManifestErr {
     /// Writes `self` to `stderr`.
     pub(crate) fn write(self, mut stderr: StderrLock<'_>) -> Result<(), Error> {
         match self {
             Self::Toml(e, file) => write!(
                 stderr,
                 "Error parsing package file {} as TOML: {e}.",
                 file.display()
             ),
             Self::Package(e, file) => e.write(stderr, &file),
             Self::Features(e, file) => e.write(stderr, &file),
             Self::ImpliedFeatures(e, file) => e.write(stderr, &file),
             Self::UndefinedIgnoreFeature(feature, file) => writeln!(
                 stderr,
                 "The feature '{feature}' was requested to be ignored, but it is not a feature in the package file {}.",
                 file.display()
             ),
         }
     }
 }
 /// Error when there are too many features to create the power set.
 #[cfg_attr(test, derive(Debug, PartialEq))]
 pub(crate) struct TooManyFeaturesErr;
 /// Parses `val` as a `u64` in decimal notation without leading 0s.
 ///
 /// # Errors
 ///
 /// Errors iff `val` is not a valid `u64` in decimal notation without leading 0s.
 pub(crate) fn parse_int(val: &str) -> Result<u64, ()> {
     val.as_bytes().first().ok_or(()).and_then(|fst| {
         if *fst == b'0' {
             if val.len() == 1 { Ok(0) } else { Err(()) }
         } else {
             val.parse().map_err(|_e| ())
         }
     })
 }
 /// MSRV in Cargo.toml.
 #[cfg_attr(test, derive(Debug, PartialEq))]
 pub(crate) struct Msrv {
     /// Major version.
     major: u64,
     /// Minor version.
     minor: Option<u64>,
     /// Patch version.
     patch: Option<u64>,
 }
 impl Msrv {
     /// Converts `msrv` into `Self` based on a valid MSRV string.
     #[expect(unsafe_code, reason = "comments justify their correctness")]
     fn extract_msrv(msrv: &str) -> Result<Self, ()> {
         let mut iter = msrv.as_bytes().split(|b| *b == b'.');
         iter.next().ok_or(()).and_then(|fst| {
             // SAFETY:
             // The original input is a `str` and we split on `b'.'` which is a single-byte
             // UTF-8 code unit; thus we don't have to worry about splitting a multi-byte
             // UTF-8 code unit.
             let major_utf8 = unsafe { str::from_utf8_unchecked(fst) };
             parse_int(major_utf8).and_then(|major| {
                 iter.next().map_or_else(
                     || {
                         Ok(Self {
                             major,
                             minor: None,
                             patch: None,
                         })
                     },
                     |snd| {
                         // SAFETY:
                         // The original input is a `str` and we split on `b'.'` which is
                         // a single-byte UTF-8 code unit; thus we don't have to worry
                         // about splitting a multi-byte UTF-8 code unit.
                         let minor_utf8 = unsafe { str::from_utf8_unchecked(snd) };
                         parse_int(minor_utf8).and_then(|minor_val| {
                             iter.next().map_or_else(
                                 || {
                                     Ok(Self {
                                         major,
                                         minor: Some(minor_val),
                                         patch: None,
                                     })
                                 },
                                 |lst| {
                                     // SAFETY:
                                     // The original input is a `str` and we split on
                                     // `b'.'` which is a single-byte UTF-8 code
                                     // unit; thus we don't have to worry about
                                     // splitting a multi-byte UTF-8 code unit.
                                     let patch_utf8 = unsafe { str::from_utf8_unchecked(lst) };
                                     parse_int(patch_utf8).and_then(|patch_val| {
                                         iter.next().map_or_else(
                                             || {
                                                 Ok(Self {
                                                     major,
                                                     minor: Some(minor_val),
                                                     patch: Some(patch_val),
                                                 })
                                             },
                                             |_| Err(()),
                                         )
                                     })
                                 },
                             )
                         })
                     },
                 )
             })
         })
     }
     /// Reads `workspace` from `toml` extracting the MSRV.
     fn extract_workspace(
         toml: &Map<Spanned<Cow<'_, str>>, Spanned<DeValue<'_>>>,
     ) -> Result<Self, WorkspaceErr> {
         toml.get(WORKSPACE)
             .ok_or(WorkspaceErr::Missing)
             .and_then(|work_span| {
                 if let DeValue::Table(ref workspace) = *work_span.get_ref() {
                     workspace
                         .get(PACKAGE)
                         .ok_or(WorkspaceErr::MissingPackage)
                         .and_then(|pack_span| {
                             if let DeValue::Table(ref package) = *pack_span.get_ref() {
                                 package
                                     .get(RUST_VERSION)
                                     .ok_or(WorkspaceErr::MissingPackageMsrv)
                                     .and_then(|msrv_span| {
                                         if let DeValue::String(ref msrv) = *msrv_span.get_ref() {
                                             Self::extract_msrv(msrv)
                                                 .map_err(|()| WorkspaceErr::Msrv)
                                         } else {
                                             Err(WorkspaceErr::InvalidPackageMsrvType)
                                         }
                                     })
                             } else {
                                 Err(WorkspaceErr::InvalidPackageType)
                             }
                         })
                 } else {
                     Err(WorkspaceErr::InvalidType)
                 }
             })
     }
     /// Recursively looks for `Cargo.toml` in `cur_dir` and ancestor directories until one is found
     /// that contains a key named [`WORKSPACE`]. Once found, it's MSRV will be parsed and returned.
     ///
     /// We make this recursive in case the (impossible?) path traversal becomes cyclic; in which
     /// we want a stack overflow to occur.
     ///
     /// Note if any error occurs not related to a not found file error, then this will error.
     fn get_workspace_toml(mut cur_dir: PathBuf) -> Result<Self, PackageErr> {
         cur_dir.push(super::cargo_toml());
         match fs::read_to_string(&cur_dir) {
             Ok(file) => Map::parse(&file)
                 .map_err(|e| PackageErr::WorkspaceToml(e, cur_dir.clone()))
                 .and_then(|toml| {
                     let t = toml.into_inner();
                     if t.contains_key(WORKSPACE) {
                         Self::extract_workspace(&t).map_err(|e| PackageErr::Workspace(e, cur_dir))
                     } else {
                         _ = cur_dir.pop();
                         if cur_dir.pop() {
                             Self::get_workspace_toml(cur_dir)
                         } else {
                             Err(PackageErr::WorkspaceDoesNotExist)
                         }
                     }
                 }),
             Err(e) => {
                 if matches!(e.kind(), ErrorKind::NotFound) {
                     _ = cur_dir.pop();
                     if cur_dir.pop() {
                         Self::get_workspace_toml(cur_dir)
                     } else {
                         Err(PackageErr::WorkspaceIo(e))
                     }
                 } else {
                     Err(PackageErr::WorkspaceIo(e))
                 }
             }
         }
     }
     /// Extracts `"rust-version"` from `"package"` or `toml` in the case it's defined in a workspace.
     #[expect(
         clippy::panic_in_result_fn,
         reason = "want to crash when there is a bug"
     )]
     fn extract_from_toml(
         toml: &Map<Spanned<Cow<'_, str>>, Spanned<DeValue<'_>>>,
         package: &Map<Spanned<Cow<'_, str>>, Spanned<DeValue<'_>>>,
         cargo_toml: &Path,
     ) -> Result<Option<Self>, PackageErr> {
         package.get(RUST_VERSION).map_or(Ok(None), |msrv_span| {
             match *msrv_span.get_ref() {
                 DeValue::String(ref msrv) => Self::extract_msrv(msrv)
                     .map_err(|()| PackageErr::Msrv)
                     .map(Some),
                 DeValue::Table(ref msrv) => msrv
                     .get(WORKSPACE)
                     .ok_or(PackageErr::MsrvWorkspaceMissing)
                     .and_then(|work| {
                         if matches!(*work.get_ref(), DeValue::Boolean(b) if b) {
                             package.get(WORKSPACE).map_or_else(
                                 || if toml.contains_key(WORKSPACE) {
                                     Self::extract_workspace(toml).map_err(|e| PackageErr::Workspace(e, cargo_toml.to_path_buf())).map(Some)
                                 } else {
                                     let mut search_path = cargo_toml.to_path_buf();
                                     assert!(search_path.pop(), "there is a bug in main. manifest::Manifest::from_toml must be passed the absolute path to the package's Cargo.toml.");
                                     if search_path.pop() {
                                         Self::get_workspace_toml(search_path).map(Some)
                                     } else {
                                         Err(PackageErr::WorkspaceDoesNotExist)
                                     }
                                 },
                                 |path_span| {
                                     if let DeValue::String(ref workspace_path) = *path_span.get_ref() {
                                         let mut path = cargo_toml.to_path_buf();
                                         assert!(path.pop(), "there is a bug in main. manifest::Manifest::from_toml must be passed the absolute path to the package's Cargo.toml.");
                                         path.push(workspace_path.as_ref());
                                         path.push(super::cargo_toml());
                                         fs::read_to_string(&path).map_err(|e| PackageErr::WorkspaceRead(e, path.clone())).and_then(|workspace_file| Map::parse(&workspace_file).map_err(|e| PackageErr::WorkspaceToml(e, path.clone())).and_then(|workspace_toml| Self::extract_workspace(workspace_toml.get_ref()).map_err(|e| PackageErr::Workspace(e, path)).map(Some)))
                                     } else {
                                         Err(PackageErr::InvalidWorkspaceType)
                                     }
                                 },
                             )
                         } else {
                             Err(PackageErr::MsrvWorkspaceVal)
                         }
                     }),
                 DeValue::Integer(_)
                 | DeValue::Float(_)
                 | DeValue::Boolean(_)
                 | DeValue::Datetime(_)
                 | DeValue::Array(_) => Err(PackageErr::InvalidMsrvType),
             }
         })
     }
     /// Returns `Some` containing the MSRV with `'+'` prepended iff `stable` is semantically greater than `self`
     /// or the default toolchan is semantically not equivalent to `self`; otherwise returns `None`.
     ///
     /// When `stable` is semantically less than the MSRV, an error is returned.
     pub(crate) fn compare_to_other(
         &self,
         default: bool,
         rustup_home: Option<&Path>,
         cargo_path: &Path,
         cargo_home: Option<&Path>,
     ) -> Result<Option<String>, Box<ToolchainErr>> {
         if default {
             Toolchain::Default(false)
         } else {
             Toolchain::Stable
         }
         .get_version(rustup_home, cargo_path, cargo_home)
         .and_then(|stable_dflt_version| {
             match self.major.cmp(&stable_dflt_version.major) {
                 Ordering::Less => Ok(true),
                 Ordering::Equal => self.minor.map_or_else(
                     || Ok(false),
                     |min| match min.cmp(&stable_dflt_version.minor) {
                         Ordering::Less => Ok(true),
                         Ordering::Equal => self.patch.map_or_else(
                             || Ok(false),
                             |pat| match pat.cmp(&stable_dflt_version.patch) {
                                 Ordering::Less => Ok(true),
                                 Ordering::Equal => Ok(false),
                                 Ordering::Greater => {
                                     if default {
                                         Ok(true)
                                     } else {
                                         Err(Box::new(ToolchainErr::MsrvTooHigh))
                                     }
                                 }
                             },
                         ),
                         Ordering::Greater => {
                             if default {
                                 Ok(true)
                             } else {
                                 Err(Box::new(ToolchainErr::MsrvTooHigh))
                             }
                         }
                     },
                 ),
                 Ordering::Greater => {
                     if default {
                         Ok(true)
                     } else {
                         Err(Box::new(ToolchainErr::MsrvTooHigh))
                     }
                 }
             }
             .and_then(|get_msrv| {
                 if get_msrv {
                     Toolchain::Msrv(&self.minor.map_or_else(
                         || format!("+{}", self.major),
                         |min| {
                             self.patch.map_or_else(
                                 || format!("+{}.{min}", self.major),
                                 |pat| format!("+{}.{min}.{pat}", self.major),
                             )
                         },
                     ))
                     .get_version(rustup_home, cargo_path, cargo_home)
                     .and_then(|msrv_version| {
                         if msrv_version.major == self.major
                             && self.minor.is_none_or(|minor| {
                                 msrv_version.minor == minor
                                     && self.patch.is_none_or(|patch| msrv_version.patch == patch)
                             })
                         {
                             Ok(Some(format!(
                                 "+{}.{}.{}",
                                 msrv_version.major, msrv_version.minor, msrv_version.patch
                             )))
                         } else {
                             Err(Box::new(ToolchainErr::MsrvNotCompatibleWithInstalledMsrv(
                                 msrv_version,
                             )))
                         }
                     })
                 } else {
                     Ok(None)
                 }
             })
         })
     }
 }
 /// `package` info.
 #[cfg_attr(test, derive(Debug, PartialEq))]
 pub(crate) struct Package {
     /// `rust-version`.
     msrv: Option<Msrv>,
     /// `name`.
     name: String,
 }
 impl Package {
     /// MSRV.
     pub(crate) const fn msrv(&self) -> Option<&Msrv> {
         self.msrv.as_ref()
     }
     /// Name.
     pub(crate) const fn name(&self) -> &str {
         self.name.as_str()
     }
     /// Extracts `"package"` from `toml`.
     fn extract_from_toml(
         toml: &Map<Spanned<Cow<'_, str>>, Spanned<DeValue<'_>>>,
         cargo_toml: &Path,
     ) -> Result<Self, PackageErr> {
         toml.get(PACKAGE)
             .ok_or(PackageErr::Missing)
             .and_then(|pack_span| {
                 if let DeValue::Table(ref package) = *pack_span.get_ref() {
                     package
                         .get(NAME)
                         .ok_or(PackageErr::MissingName)
                         .and_then(|name_span| {
                             if let DeValue::String(ref name) = *name_span.get_ref() {
                                 Msrv::extract_from_toml(toml, package, cargo_toml).map(|msrv| {
                                     Self {
                                         msrv,
                                         name: name.clone().into_owned(),
                                     }
                                 })
                             } else {
                                 Err(PackageErr::InvalidNameType)
                             }
                         })
                 } else {
                     Err(PackageErr::InvalidType)
                 }
             })
     }
 }
 /// Returns `true` iff `nodes` is pairwise disconnected.
 #[expect(
     clippy::arithmetic_side_effects,
     clippy::indexing_slicing,
     reason = "comment justifies correctness"
 )]
 fn pairwise_disconnected(nodes: &[&str], features: &[(String, Vec<String>)]) -> bool {
     /// `panic`s with a static message about the existence of a bug in [`Manifest::deserialize`].
     #[expect(clippy::unreachable, reason = "want to crash when there is a bug")]
     fn impossible<T>() -> T {
         unreachable!(
             "there is a bug in manifest::Manifest::deserialize where feature dependencies are not only features."
         )
     }
     /// Returns `true` iff `feature_deps` directly contains `feature` or indirectly in the `Vec<String>`
     /// associated with it.
     fn contains(
         feature_deps: &[String],
         feature: &str,
         features: &[(String, Vec<String>)],
     ) -> bool {
         feature_deps.iter().any(|feat| {
             feat == feature
                 || contains(
                     &features
                         .iter()
                         .find(|val| val.0 == *feat)
                         .unwrap_or_else(impossible)
                         .1,
                     feature,
                     features,
                 )
         })
     }
     !nodes.iter().enumerate().any(|(idx, feature)| {
         let feature_info = &features
             .iter()
             .find(|val| val.0 == **feature)
             .unwrap_or_else(impossible)
             .1;
         // `idx < nodes.len()`, so overflow is not possible and indexing is fine.
         nodes[idx + 1..].iter().any(|feat| {
             contains(feature_info, feat, features)
                 || contains(
                     features
                         .iter()
                         .find(|val| val.0 == **feat)
                         .unwrap_or_else(impossible)
                         .1
                         .as_slice(),
                     feature,
                     features,
                 )
         })
     })
 }
 /// Power set of [`Features`] returned from [`Features::power_set`].
 ///
 /// Note this is technically not the power set of features since semantically equivalent sets are ignored.
 ///
 /// The last set iterated will always be the empty set. If no features in [`Features`] depend on another
 /// feature, then this will always return the entire set of features first; otherwise the entire set will
 /// never be returned. The expected cardinality of a set iterated decreases; thus while it will almost always
 /// be possible for a set _A_ to have larger cardinality than a set _B_ even when _A_ is iterated before _B_,
 /// the expected value is smaller.
 ///
 /// The reason we attempt, but don't guarantee, that the first set iterated corresponds to a semantically
 /// equivalent set as the original set is to take advantage of the parallel compiliation that occurs. Typically
 /// the more features one enables, the more dependencies and functionality is added. By compiling code that
 /// maximizes this first, we take better advantage of how code is compiled; in contrast if we compiled fewer
 /// features first, subsequent compilations with more features will have to happen. We don't guarantee this
 /// though since it slightly complicates code; instead we iterate based on the _expected_ cardinality in
 /// descending order.
 ///
 /// We don't implement `Iterator` since we want to re-use the same `String` that represents the set we are
 /// returning.
 #[cfg_attr(test, derive(Debug, PartialEq))]
 pub(crate) struct PowerSet<'a> {
     /// The set of features.
     feats: &'a [(String, Vec<String>)],
     /// `true` iff there are more sets to iterate.
     has_remaining: bool,
     /// `true` iff `feats` has redundant features; thus requiring us to check if a given set should be returned.
     check_overlap: bool,
     /// The current element of the power set that we are to return.
     ///
     /// This gets decremented as we iterate sets.
     idx: usize,
     /// Intermediate buffer we use to check if a set contains redundant features.
     buffer: Vec<&'a str>,
     /// The set we return.
     ///
     /// This is of the form `"<feat_1>,<feat_2>,...,<feat_n>"`.
     set: String,
     /// Number of sets skipped due to an equivalence with a smaller set.
     skipped_sets_counter: usize,
     /// `true` iff they empty set should be skipped.
     ///
     /// This doesn't contribute to [`Self::skipped_sets_counter`].
     skip_empty_set: bool,
 }
 impl<'a> PowerSet<'a> {
     /// Max cardinality of a set we allow to take the power set of.
     // usize::MAX = 2^usize::BITS - 1 >= usize::BITS since usize::MAX >= 0;
     // thus `usize::BITS as usize` is free from truncation.
     #[expect(clippy::as_conversions, reason = "comment justifies correctness")]
     const MAX_SET_LEN: usize = usize::BITS as usize;
     /// Returns the cardinality less one of the power set of a set
     /// whose cardinality is `set_len`.
     ///
     /// `set_len` MUST not be greater than [`Self::MAX_SET_LEN`].
     #[expect(
         clippy::arithmetic_side_effects,
         reason = "comment justifies correctness"
     )]
     const fn len_minus_one(set_len: usize) -> usize {
         assert!(
             set_len <= Self::MAX_SET_LEN,
             "manifest::PowerSet::len_minus_one must be passed a `usize` no larger than PowerSet::MAX_SET_LEN"
         );
         if set_len == Self::MAX_SET_LEN {
             usize::MAX
         } else {
             // We verified that `set_len <= usize::BITS`; thus
             // this won't overflow nor underflow since 2^0 = 1.
             (1 << set_len) - 1
         }
     }
     /// Returns the cardinality of `self`.
     ///
     /// Note this is constant and is not affected by iteration of
     /// `self`. This isn't the remaining length. [`Self::skip_empty_set`]
     /// contributes towards this value.
     #[expect(
         clippy::arithmetic_side_effects,
         reason = "comment justifies correctness"
     )]
     pub(crate) fn len(&self) -> NonZeroUsizePlus1 {
         // We don't allow construction of `PowerSet` unless the set of features
         // is no more than [`Self::MAX_SET_LEN`]; thus this won't `panic`.
         // Underflow won't occur either since we don't allow construction when the
         // set of features is empty and when we must skip the empty set.
         // `NonZeroUsizePlus1` treats `0` as `usize::MAX + 1`, so we use wrapping addition.
         // This will only wrapp when `self.features.len() == Self::MAX_SET_LEN` and `!self.skip_empty_set`.
         NonZeroUsizePlus1::new(
             (Self::len_minus_one(self.feats.len()) - usize::from(self.skip_empty_set))
                 .wrapping_add(1),
         )
     }
     /// Contructs `Self` based on `features`.
     ///
     /// When iterating the sets, the empty set will be skipped iff `skip_empty_set`;
     /// but this _won't_ contribute to `skipped_sets_counter`.
     ///
     /// Returns `None` iff `features` is empty and `skip_empty_set`.
     fn new(
         features: &'a Features,
         skip_empty_set: bool,
     ) -> Result<Option<Self>, TooManyFeaturesErr> {
         let len = features.0.len();
         match len {
             0 if skip_empty_set => Ok(None),
             ..=Self::MAX_SET_LEN => {
                 let mut buffer = Vec::with_capacity(len);
                 features.0.iter().fold((), |(), key| {
                     buffer.push(key.0.as_ref());
                 });
                 let check_overlap = !pairwise_disconnected(buffer.as_slice(), &features.0);
                 Ok(Some(Self {
                     feats: &features.0,
                     has_remaining: true,
                     check_overlap,
                     // We verified `len <= Self::MAX_SET_LEN`, so this won't `panic`.
                     idx: Self::len_minus_one(len),
                     buffer,
                     // This won't overflow since `usize::MAX = 2^usize::BITS - 1`, `usize::BITS >= 16`, the max
                     // value of `len` is `usize::BITS`.
                     // 16 * usize::BITS < 2^usize::BITS for `usize::BITS > 6`.
                     set: String::with_capacity(len << 4),
                     skipped_sets_counter: 0,
                     skip_empty_set,
                 }))
             }
             _ => Err(TooManyFeaturesErr),
         }
     }
     /// Resets `self` such that iteration returns to the beginning.
     pub(crate) const fn reset(&mut self) {
         // We don't allow construction of `PowerSet` when the number of
         // features exceeds [`Self::MAX_SET_LEN`], so this won't `panic`.
         self.idx = Self::len_minus_one(self.feats.len());
         self.has_remaining = true;
         self.skipped_sets_counter = 0;
     }
     /// Writes the next element into `self.buffer` even if the set contains overlapping features.
     #[expect(
         clippy::arithmetic_side_effects,
         reason = "comment justifies correctness"
     )]
     fn inner_next_set(&mut self) {
         self.buffer.clear();
         self.feats.iter().enumerate().fold((), |(), (i, feat)| {
             if self.idx & (1 << i) != 0 {
                 self.buffer.push(feat.0.as_str());
             }
         });
         if self.idx == 0 {
             self.has_remaining = false;
         // The empty set is always the last set.
         } else if self.idx == 1 && self.skip_empty_set {
             self.idx = 0;
             self.has_remaining = false;
         } else {
             // This won't underflow since `idx > 0`.
             self.idx -= 1;
         }
     }
     /// Transforms the current element into its string form.
     fn current_set(&mut self) {
         self.set.clear();
         self.buffer.iter().fold((), |(), s| {
             self.set.push_str(s);
             self.set.push(',');
         });
         // We remove the trailing comma. In the event `self.set` is empty, this does nothing.
         _ = self.set.pop();
     }
     /// Returns the next set.
     ///
     /// This returns `None` iff there are no more sets to return. It will continue to return `None`
     /// unless [`Self::reset`] is called.
     pub(crate) fn next_set(&mut self) -> Option<&str> {
         self.next_set_with_skip_count().map(|tup| tup.0)
     }
     /// Returns the next set along with the number of set skipped thus far.
     ///
     /// This returns `None` iff there are no more sets to return. It will continue to return `None`
     /// unless [`Self::reset`] is called.
     #[expect(
         clippy::arithmetic_side_effects,
         reason = "comment justifies correctness"
     )]
     pub(crate) fn next_set_with_skip_count(&mut self) -> Option<(&str, usize)> {
         if self.has_remaining {
             if self.check_overlap {
                 while self.has_remaining {
                     self.inner_next_set();
                     if pairwise_disconnected(self.buffer.as_slice(), self.feats) {
                         self.current_set();
                         return Some((&self.set, self.skipped_sets_counter));
                     }
                     // This maxes at `usize::MAX` since we ensure a power set is not created on a
                     // set with more than `usize::BITS` elements.
                     // We set to set every time [`Self::reset`] is called as well.
                     self.skipped_sets_counter += 1;
                 }
                 None
             } else {
                 self.inner_next_set();
                 self.current_set();
                 Some((&self.set, self.skipped_sets_counter))
             }
         } else {
             None
         }
     }
 }
 /// Dependency table.
 enum DepTable {
     /// Library dependencies.
     Dependencies,
     /// Build dependencies.
     BuildDependencies,
 }
 impl DepTable {
     /// Returns the string representation of `self`.
     const fn into_str(self) -> &'static str {
         match self {
             Self::Dependencies => "dependencies",
             Self::BuildDependencies => "build-dependencies",
         }
     }
 }
 /// `"dep:"`.
 const DEP: &[u8; 4] = b"dep:";
 /// Returns `true` iff `utf8` begins with [`DEP`].
 fn is_feature_dependency_a_dependency(utf8: &[u8]) -> bool {
     utf8.starts_with(DEP)
 }
 /// Returns `true` iff `name` does not contain a `'/'` nor begins with [`DEP`].
 fn is_feature_dependency_a_feature(name: &str) -> bool {
     let utf8 = name.as_bytes();
     !(utf8.contains(&b'/') || is_feature_dependency_a_dependency(utf8))
 }
 /// Features in Cargo.toml.
 ///
 /// Note this contains a `Vec` instead of a `HashMap` or `BTreeMap` since we enforce that very few entries exist
 /// due to the exponential nature of generating the power set; thus making a `Vec` more efficient and faster.
 /// This size is so small that we don't even sort and perform a binary search.
 ///
 /// The `String` in the tuple represents the name of the feature, and the `Vec` in the tuple represents the
 /// feature dependencies. The feature dependencies will not contain any dependency that contains a `'/'`
 /// but will contain all others. The name of each feature will not contain a `'/'` nor begin with [`DEP`].
 /// Each dependency that is a feature (i.e., does not begin with [`DEP`]) is well-defined (i.e., is a feature
 /// itself) when `false` is passed to [`Self::extract_from_toml`]; when `true` is passed, then feature dependencies
 /// that are features are not verified to be defined in `self` since implied features still have to be added.
 /// Each feature does not contain any cycles nor redundant dependencies.
 ///
 /// One must still add implied features caused from any optional dependencies iff `true` is passed to
 /// [`Self::extract_from_toml`]; after which, one needs to remove all dependencies that are not features and verify
 /// all dependencies that are features are defined in `self` in order for [`PowerSet`] to work correctly. A feature
 /// with name `<dependency>` needs to be added with an empty `Vec` of dependencies iff no features exist that have a
 /// dependency whose name is `"dep:<dependency>"` _and_ there doesn't already exist a feature with that name.
 /// An error MUST NOT happen if there is such a feature since different kinds of dependencies can have the
 /// same name. While this will allow for the situation where a feature is defined with the same name as
 /// an implied feature, that won't matter once `cargo` is run since it will error anyway.
 #[cfg_attr(test, derive(Debug, PartialEq))]
 pub(crate) struct Features(Vec<(String, Vec<String>)>);
 impl Features {
     /// Returns `true` iff `self` contains a feature named `"default"`.
     pub(crate) fn contains_default(&self) -> bool {
         self.0.iter().any(|f| f.0 == "default")
     }
     /// `panic`s with a static message about the existence of a bug in `validate_dependencies`.
     ///
     /// This is used in lieu of `unreachable` in `validate_dependencies`, `check_redundant_features`
     /// and `extract_feature_dependencies`.
     #[expect(clippy::unreachable, reason = "want to crash when there is a bug")]
     fn impossible<T>() -> T {
         unreachable!("there is a bug in manifest::Features::validate_dependencies.")
     }
     /// Verifies dependencies associated with `feature` is valid.
     ///
     /// `dependencies` are assumed to be associated with `feature` which the pair of is checked to be
     /// a key-value pair from `features` iff `allow_implied_features`. This verifies the following:
     ///
     /// * `dependencies` is an array that only contains strings.
     /// * Each string in `dependencies` that does not contain a `'/'` nor begins with [`DEP`] is a key
     ///   in `features` iff `allow_implied_features`.
     /// * `feature` nor any dependency that is a feature in `dependencies` is cyclic.
     ///
     /// `cycle_detection` MUST contain only `feature` when this is called externally.
     ///
     /// This MUST only be called by itself or [`Self::extract_feature_dependencies`].
     fn validate_dependencies<'a>(
         feature: &str,
         dependencies: &'a DeValue<'_>,
         features: &'a Map<Spanned<Cow<'_, str>>, Spanned<DeValue<'_>>>,
         cycle_detection: &mut Vec<&'a str>,
         allow_implied_features: bool,
     ) -> Result<(), FeatureDependenciesErr> {
         if let DeValue::Array(ref info) = *dependencies {
             info.iter().try_fold((), |(), dep_span| {
                 if let DeValue::String(ref dep_name) = *dep_span.get_ref() {
                     if is_feature_dependency_a_feature(dep_name) {
                         if cycle_detection.contains(&dep_name.as_ref()) {
                             Err(FeatureDependenciesErr::CyclicFeature(
                                 dep_name.clone().into_owned(),
                             ))
                         } else if let Some(next_feature) = features.get(dep_name.as_ref()) {
                             cycle_detection.push(dep_name);
                             Self::validate_dependencies(
                                 dep_name,
                                 next_feature.get_ref(),
                                 features,
                                 cycle_detection,
                                 allow_implied_features,
                             )
                             .map(|()| {
                                 // We require calling code to add `feature` before calling this function. We
                                 // always add the most recent feature dependency. Therefore this is not empty.
                                 _ = cycle_detection.pop().unwrap_or_else(Self::impossible);
                             })
                         } else if allow_implied_features {
                             // `dep_name` may be an implied feature which we have yet to add.
                             Ok(())
                         } else {
                             // We require calling code to add `feature` before calling this function. We always
                             // add the most recent feature dependency. Therefore this is not empty.
                             Err(FeatureDependenciesErr::InvalidDependency(
                                 cycle_detection
                                     .pop()
                                     .unwrap_or_else(Self::impossible)
                                     .to_owned(),
                                 dep_name.clone().into_owned(),
                             ))
                         }
                     } else {
                         Ok(())
                     }
                 } else {
                     Err(FeatureDependenciesErr::InvalidDependencyType(
                         feature.to_owned(),
                     ))
                 }
             })
         } else {
             Err(FeatureDependenciesErr::InvalidFeatureType(
                 feature.to_owned(),
             ))
         }
     }
     /// Verifies there are no redundant dependencies that are features in `dependencies`.
     ///
     /// Returns `true` iff there is a redundant dependency.
     ///
     /// This must be called _after_ `validate_dependencies` is called on the same arguments.
     fn check_redundant_dependencies(
         feature: &str,
         dependencies: &DeArray<'_>,
         features: &Map<Spanned<Cow<'_, str>>, Spanned<DeValue<'_>>>,
         allow_implied_features: bool,
     ) -> bool {
         dependencies.iter().any(|dep_span| {
             if let DeValue::String(ref dep_name) = *dep_span.get_ref() {
                 is_feature_dependency_a_feature(dep_name)
                     && (feature == dep_name
                         || features.get(dep_name.as_ref()).map_or_else(
                             || {
                                 if allow_implied_features {
                                     false
                                 } else {
                                     // We require `validate_dependencies` to be called before this function which
                                     // ensures all features recursively in the `dependencies` are defined as features iff `!allow_implied_features`.
                                     Self::impossible()
                                 }
                             },
                             |next_feature_span| {
                                 Self::check_redundant_dependencies(
                                     feature,
                                     next_feature_span
                                         .get_ref()
                                         .as_array()
                                         // We require `validate_dependencies` to be called before this function
                                         // which ensures all feature dependencies recursively are arrays.
                                         .unwrap_or_else(Self::impossible),
                                     features,
                                     allow_implied_features,
                                 )
                             },
                         ))
             } else {
                 // We require `validate_dependencies` to be called before this function which ensures all
                 // dependencies recursivley in `dependencies` are strings.
                 Self::impossible()
             }
         })
     }
     /// Extracts the feature dependencies associated with `feature`.
     ///
     /// `dependencies` are assumed to be associated with `feature` which the pair of is checked to be
     /// a key-value pair from `features` iff `allow_implied_features`. This verifies the following:
     ///
     /// * `dependencies` is an array that only contains strings.
     /// * Each string in `dependencies` that does not contain a `'/'` nor begins with [`DEP`] is a key
     ///   in `features` iff `allow_implied_features`.
     /// * There is no redundant feature in `dependencies` where "redundant" means the following:
     ///   * There are no cycles (e.g., feature = \["feature"] or feature = \["a"], a = \["b"], b = \["a"]).
     ///   * No unnecessary dependencies that are features (e.g., feature = \["a", "a"] or feature = \["a", "b"]
     ///     a = \["b"], b = \[]).
     /// * There are no duplicate dependencies in `dependencies` that beging with [`DEP`].
     ///
     /// Note since all dependencies that contain a `'/'` are ignored, there may be duplicates of them.
     /// Also when checking for redundant features in `dependencies`, _only_ features are considered; thus
     /// something like the following is allowed: feature = \["dep:a", "a"], a = \["dep:a"]
     ///
     /// This must only be called from [`Self::extract_from_toml`].
     #[expect(
         clippy::arithmetic_side_effects,
         reason = "comment justifies correctness"
     )]
     fn extract_feature_dependencies<'a>(
         feature: &'a str,
         dependencies: &'a DeValue<'_>,
         features: &'a Map<Spanned<Cow<'_, str>>, Spanned<DeValue<'_>>>,
         cycle_buffer: &mut Vec<&'a str>,
         allow_implied_features: bool,
     ) -> Result<Vec<String>, FeatureDependenciesErr> {
         // `Self::validate_dependencies` requires `cycle_buffer` to contain, and only contain, `feature`.
         cycle_buffer.clear();
         cycle_buffer.push(feature);
         Self::validate_dependencies(feature, dependencies, features, cycle_buffer, allow_implied_features).and_then(|()| {
             // `validate_dependencies` ensures `dependencies` is an array.
             let deps = dependencies.as_array().unwrap_or_else(Self::impossible);
             let mut vec_deps = Vec::with_capacity(deps.len());
             deps.iter().enumerate().try_fold((), |(), (idx, dep_span)| if let DeValue::String(ref dep_name) = *dep_span.get_ref() {
                 let dep_utf8 = dep_name.as_bytes();
                 if dep_utf8.contains(&b'/') {
                     Ok(())
                 } else if is_feature_dependency_a_dependency(dep_utf8) {
                     if vec_deps.iter().any(|d| d == dep_name) {
                         Err(FeatureDependenciesErr::RedundantDependency(feature.to_owned(), dep_name.clone().into_owned()))
                     } else {
                         vec_deps.push(dep_name.clone().into_owned());
                         Ok(())
                     }
                 } else if let Some(next_feature_span) = features.get(dep_name.as_ref()) {
                     // `validate_dependencies` ensures all feature
                     // dependencies recursively are arrays.
                     let feat_info = next_feature_span.get_ref().as_array().unwrap_or_else(Self::impossible);
                     // `idx < deps.iter().len()`; thus this won't overflow.
                     deps.iter().skip(idx + 1).try_fold((), |(), next_dep_span| if let DeValue::String(ref next_dep_name) = *next_dep_span.get_ref() {
                         if is_feature_dependency_a_feature(next_dep_name) {
                             if dep_name == next_dep_name {
                                 Err(FeatureDependenciesErr::RedundantDependency(feature.to_owned(), dep_name.clone().into_owned()))
                             } else if Self::check_redundant_dependencies(next_dep_name, feat_info, features, allow_implied_features) {
                                 Err(FeatureDependenciesErr::RedundantDependency(feature.to_owned(), next_dep_name.clone().into_owned()))
                             } else {
                                 features.get(next_dep_name.as_ref()).map_or_else(
                                     || {
                                         if allow_implied_features {
                                             Ok(())
                                         } else {
                                             // `validate_dependencies` ensures all features
                                             // recursively in the feature dependencies are defined
                                             // as features iff `!allow_implied_features`.
                                             Self::impossible()
                                         }
                                     },
                                     |next_dep_feature_span| {
                                         // `validate_dependencies` ensures all feature
                                         // dependencies recursively are arrays.
                                         if Self::check_redundant_dependencies(dep_name, next_dep_feature_span.get_ref().as_array().unwrap_or_else(Self::impossible), features, allow_implied_features) {
                                             Err(FeatureDependenciesErr::RedundantDependency(feature.to_owned(), dep_name.clone().into_owned()))
                                         } else {
                                             Ok(())
                                         }
                                     }
                                 )
                             }
                         } else {
                             Ok(())
                         }
                     } else {
                         // `validate_dependencies` ensures all dependencies recursively in `dependencies` are
                         // strings.
                         Self::impossible()
                     }).map(|()| vec_deps.push(dep_name.clone().into_owned()))
                 } else if allow_implied_features {
                     vec_deps.push(dep_name.clone().into_owned());
                     Ok(())
                 } else {
                     // `validate_dependencies` ensures all features
                     // recursively in `dependencies` are defined as features
                     // iff `!allow_implied_features`.
                     Self::impossible()
                 }
             } else {
                 // `validate_dependencies` ensures all dependencies recursively in `dependencies` are strings.
                 Self::impossible()
             }).map(|()| vec_deps)
         })
     }
     /// Extracts `"features"` from `toml`.
     fn extract_from_toml(
         toml: &Map<Spanned<Cow<'_, str>>, Spanned<DeValue<'_>>>,
         allow_implied_features: bool,
     ) -> Result<Self, FeaturesErr> {
         toml.get(FEATURES).map_or_else(
             || Ok(Self(Vec::new())),
             |features_span| {
                 if let DeValue::Table(ref features) = *features_span.get_ref() {
                     let mut cycle_buffer = Vec::with_capacity(features.len());
                     let mut feats = Vec::with_capacity(features.len());
                     features
                         .iter()
                         .try_fold((), |(), (name_span, feature_span)| {
                             let name = name_span.get_ref();
                             if is_feature_dependency_a_feature(name) {
                                 Self::extract_feature_dependencies(
                                     name,
                                     feature_span.get_ref(),
                                     features,
                                     &mut cycle_buffer,
                                     allow_implied_features,
                                 )
                                 .map_err(FeaturesErr::FeatureDependencies)
                                 .map(|deps| {
                                     feats.push((name.clone().into_owned(), deps));
                                 })
                             } else {
                                 Err(FeaturesErr::InvalidName(name.clone().into_owned()))
                             }
                         })
                         .map(|()| Self(feats))
                 } else {
                     Err(FeaturesErr::InvalidType)
                 }
             },
         )
     }
     /// Extracts optional dependencies and adds their corresponding implied feature to `self` iff
     /// `allow_implied_features` and it's appropriate to do so.
     ///
     /// This must only be called from [`Self::add_implied_features`].
     fn add_optional_dependencies(
         &mut self,
         toml: &Map<Spanned<Cow<'_, str>>, Spanned<DeValue<'_>>>,
         table: DepTable,
         allow_implied_features: bool,
     ) -> Result<(), DependenciesErr> {
         let table_name = table.into_str();
         toml.get(table_name).map_or(Ok(()), |deps_span| {
             if let DeValue::Table(ref deps) = *deps_span.get_ref() {
                 deps.iter().try_fold((), |(), dep_span| {
                     let dep_name = dep_span.0.get_ref();
                     if is_feature_dependency_a_feature(dep_name) {
                         match *dep_span.1.get_ref() {
                             DeValue::String(_) => Ok(()),
                             DeValue::Table(ref dep_info) => {
                                 dep_info.get(OPTIONAL).map_or(Ok(()), |opt_span| {
                                     if let DeValue::Boolean(ref optional) = *opt_span.get_ref() {
                                         if *optional {
                                             self.0
                                                 .iter()
                                                 .try_fold((), |(), feat| {
                                                     if feat.0 == *dep_name {
                                                         // We already have a feature with the same name,
                                                         // so we don't need to continue.
                                                         Err(())
                                                     } else if feat.1.iter().any(|feat_dep| {
                                                         feat_dep
                                                             .as_bytes()
                                                             .split_at_checked(DEP.len())
                                                             .is_some_and(|(pref, rem)| {
                                                                 pref == DEP
                                                                     && dep_name.as_bytes() == rem
                                                             })
                                                     }) {
                                                         // The feature dependencies contain `"dep:<dep_name>"`,
                                                         // so we don't need to add an implied feature.
                                                         Err(())
                                                     } else {
                                                         // The feature name is not `<dep_name>` and all of
                                                         // feature dependencies of all features are not named
                                                         // `"dep:<dep_name>"`; thus we need to continue our
                                                         // search.
                                                         Ok(())
                                                     }
                                                 })
                                                 .map_or(Ok(()), |()| {
                                                     if allow_implied_features {
                                                         // There is no feature with the name `<dep_name>` nor
                                                         // are there any features that contain a feature
                                                         // dependency named `"dep:<dep_name>"`; thus we must
                                                         // insert an implied feature.
                                                         self.0.push((
                                                             dep_name.clone().into_owned(),
                                                             Vec::new(),
                                                         ));
                                                         Ok(())
                                                     } else {
                                                         Err(DependenciesErr::ImpliedFeature(
                                                             table_name,
                                                             dep_name.clone().into_owned(),
                                                         ))
                                                     }
                                                 })
                                         } else {
                                             Ok(())
                                         }
                                     } else {
                                         Err(DependenciesErr::OptionalType(
                                             table_name,
                                             dep_name.clone().into_owned(),
                                         ))
                                     }
                                 })
                             }
                             DeValue::Integer(_)
                             | DeValue::Float(_)
                             | DeValue::Boolean(_)
                             | DeValue::Datetime(_)
                             | DeValue::Array(_) => Err(DependenciesErr::DependencyType(
                                 table_name,
                                 dep_name.clone().into_owned(),
                             )),
                         }
                     } else {
                         Err(DependenciesErr::Name(
                             table_name,
                             dep_name.clone().into_owned(),
                         ))
                     }
                 })
             } else {
                 Err(DependenciesErr::Type(table_name))
             }
         })
     }
     /// Adds implied features to `self` based on the optional dependencies in `toml` iff `allow_implied_features`.
     fn add_implied_features(
         &mut self,
         toml: &Map<Spanned<Cow<'_, str>>, Spanned<DeValue<'_>>>,
         allow_implied_features: bool,
     ) -> Result<(), ImpliedFeaturesErr> {
         self.add_optional_dependencies(toml, DepTable::Dependencies, allow_implied_features).map_err(ImpliedFeaturesErr::Dependencies).and_then(|()| self.add_optional_dependencies(toml, DepTable::BuildDependencies, allow_implied_features).map_err(ImpliedFeaturesErr::Dependencies).and_then(|()| toml.get(TARGET).map_or_else(
             || Ok(()),
             |target_span| {
                 if let DeValue::Table(ref target) = *target_span.get_ref() {
                     target.iter().try_fold((), |(), target_platform_span| {
                         if let DeValue::Table(ref target_platform) = *target_platform_span.1.get_ref() {
                             self.add_optional_dependencies(target_platform, DepTable::Dependencies, allow_implied_features).map_err(|e| ImpliedFeaturesErr::TagetPlatformDependencies(target_platform_span.0.get_ref().clone().into_owned(), e)).and_then(|()| self.add_optional_dependencies(target_platform, DepTable::BuildDependencies, allow_implied_features).map_err(|e| ImpliedFeaturesErr::TagetPlatformDependencies(target_platform_span.0.get_ref().clone().into_owned(), e)))
                         } else {
                             Err(ImpliedFeaturesErr::TargetPlatformType(target_platform_span.0.get_ref().clone().into_owned()))
                         }
                     })
                 } else {
                     Err(ImpliedFeaturesErr::TargetType)
                 }
             }
         ).and_then(|()| {
             if allow_implied_features {
                 // We don't have to worry about cyclic features or anything other than the lack of a feature with
                 // the name of the feature dependency.
                 self.0.iter().try_fold((), |(), feature| feature.1.iter().try_fold((), |(), dep| {
                      // We didn't save any feature dependencies that contain `'/'`, so we simply have to check if
                      // a dependency begins with [`DEP`] to skip it.
                      if is_feature_dependency_a_dependency(dep.as_bytes()) || self.0.iter().any(|other_feature| other_feature.0 == *dep) {
                          Ok(())
                      } else {
                          Err(ImpliedFeaturesErr::InvalidDependency(feature.0.clone(), dep.clone()))
                      }
                  }))
             } else {
                 // When `!allowed_implied_features`, [`Self::validate_dependencies`] verifies non-dependency
                 // feature dependencies are defined as features.
                 Ok(())
             }
         })))
     }
     /// Returns the power set of `self` with semantically equivalent sets removed.
     ///
     /// The empty set of features is skipped iff `skip_no_feats`. None is only
     /// returned if there are no sets of features. This is only possible iff
     /// `self` contains no features and `skip_no_feats`.
     pub(crate) fn power_set(
         &self,
         skip_no_feats: bool,
     ) -> Result<Option<PowerSet<'_>>, TooManyFeaturesErr> {
         PowerSet::new(self, skip_no_feats)
     }
 }
 /// Package and features in `Cargo.toml`.
 #[cfg_attr(test, derive(Debug, PartialEq))]
 pub(crate) struct Manifest {
     /// The package.
     package: Package,
     /// The features.
     features: Features,
 }
 impl Manifest {
     /// Returns the defined MSRV iff there was one defined.
     pub(crate) const fn package(&self) -> &Package {
         &self.package
     }
     /// Returns the defined features.
     ///
     /// Note the returned `Features` doesn't have any cyclic features, each feature dependency for a given
     /// feature is a feature itself, and there are no redundant feature dependencies for a given feature.
     pub(crate) const fn features(&self) -> &Features {
         &self.features
     }
     /// Returns the data needed from `Cargo.toml`.
     ///
     /// Note `ignore_features` MUST not contain an empty `String`.
     #[expect(
         clippy::arithmetic_side_effects,
         reason = "comments justify correctness"
     )]
     #[expect(
         clippy::needless_pass_by_value,
         reason = "want to drop `val` as soon as possible"
     )]
     pub(crate) fn from_toml(
         val: String,
         allow_implied_features: bool,
         cargo_toml: &Path,
         ignore_features: &[String],
     ) -> Result<Self, Box<ManifestErr>> {
         Map::parse(val.as_str())
             .map_err(|e| Box::new(ManifestErr::Toml(e, cargo_toml.to_path_buf())))
             .and_then(|span| {
                 let cargo = span.get_ref();
                 Package::extract_from_toml(cargo, cargo_toml)
                     .map_err(|e| Box::new(ManifestErr::Package(e, cargo_toml.to_path_buf())))
                     .and_then(|package| {
                         Features::extract_from_toml(cargo, allow_implied_features)
                             .map_err(|e| {
                                 Box::new(ManifestErr::Features(e, cargo_toml.to_path_buf()))
                             })
                             .and_then(|mut features| {
                                 features
                                     .add_implied_features(cargo, allow_implied_features)
                                     .map_err(|e| {
                                         Box::new(ManifestErr::ImpliedFeatures(
                                             e,
                                             cargo_toml.to_path_buf(),
                                         ))
                                     })
                                     .and_then(|()| {
                                         features.0.iter_mut().fold(
                                             (),
                                             |(), &mut (_, ref mut deps)| {
                                                 deps.retain(|d| {
                                                     // We retain only features. Since we didn't save any
                                                     // dependencies that contain `'/'`, it's slightly faster to just
                                                     // check that a feature dependency is not a dependency.
                                                     !is_feature_dependency_a_dependency(
                                                         d.as_bytes(),
                                                     )
                                                 });
                                             },
                                         );
                                         // First we ensure all features we are to ignore are defined;
                                         // while doing this, we remove the feature. Note `ignore_features`
                                         // and `features` only contain distinct features, so we simply
                                         // have to check for the first occurrence.
                                         // Note calling code is required to have removed the empty
                                         // string if it had existed.
                                         ignore_features
                                             .iter()
                                             .try_fold((), |(), ig_feat| {
                                                 features
                                                     .0
                                                     .iter()
                                                     .try_fold(0, |idx, info| {
                                                         if info.0 == *ig_feat {
                                                             Err(idx)
                                                         } else {
                                                             // Clearly free from overflow.
                                                             Ok(idx + 1)
                                                         }
                                                     })
                                                     .map_or_else(
                                                         |idx| {
                                                             drop(features.0.swap_remove(idx));
                                                             Ok(())
                                                         },
                                                         |_| {
                                                             Err(Box::new(
                                                                 ManifestErr::UndefinedIgnoreFeature(
                                                                     ig_feat.clone(),
                                                                     cargo_toml.to_path_buf(),
                                                                 ),
                                                             ))
                                                         },
                                                     )
                                             })
                                             .map(|()| {
                                                 // Now we remove all features that depend on the
                                                 // features we are to ignore.
                                                 ignore_features.iter().fold((), |(), ig_feat| {
                                                     features.0.retain(|info| {
                                                         !info.1.iter().any(|d| d == ig_feat)
                                                     });
                                                 });
                                                 Self { package, features }
                                             })
                                     })
                             })
                     })
             })
     }
 }
 #[cfg(test)]
 mod tests {
     use super::{
         DependenciesErr, FeatureDependenciesErr, Features, FeaturesErr, ImpliedFeaturesErr,
         Manifest, ManifestErr, Msrv, NonZeroUsizePlus1, Package, PackageErr, Path, PathBuf,
         PowerSet, TooManyFeaturesErr, WorkspaceErr,
     };
     impl PartialEq for PackageErr {
         fn eq(&self, other: &Self) -> bool {
             match *self {
                 Self::Missing => matches!(*other, Self::Missing),
                 Self::InvalidType => matches!(*other, Self::InvalidType),
                 Self::MissingName => matches!(*other, Self::MissingName),
                 Self::InvalidNameType => matches!(*other, Self::InvalidNameType),
                 Self::InvalidMsrvType => matches!(*other, Self::InvalidMsrvType),
                 Self::Msrv => matches!(*other, Self::Msrv),
                 Self::MsrvWorkspaceMissing => matches!(*other, Self::MsrvWorkspaceMissing),
                 Self::MsrvWorkspaceVal => matches!(*other, Self::MsrvWorkspaceVal),
                 Self::InvalidWorkspaceType => matches!(*other, Self::InvalidWorkspaceType),
                 Self::WorkspaceIo(ref e) => {
                     matches!(*other, Self::WorkspaceIo(ref e2) if e.kind() == e2.kind())
                 }
                 Self::WorkspaceDoesNotExist => matches!(*other, Self::WorkspaceDoesNotExist),
                 Self::WorkspaceRead(ref e, ref p) => {
                     matches!(*other, Self::WorkspaceRead(ref e2, ref p2) if e.kind() == e2.kind() && p == p2)
                 }
                 Self::WorkspaceToml(ref e, ref p) => {
                     matches!(*other, Self::WorkspaceToml(ref e2, ref p2) if e == e2 && p == p2)
                 }
                 Self::Workspace(e, ref p) => {
                     matches!(*other, Self::Workspace(e2, ref p2) if e == e2 && p == p2)
                 }
             }
         }
     }
     #[expect(
         clippy::cognitive_complexity,
         clippy::too_many_lines,
         reason = "want to test a lot of things"
     )]
     #[test]
     fn cargo_toml() {
         assert!(
             Manifest::from_toml("a".to_owned(), false, Path::new(""), &[])
                 .map_or_else(|e| matches!(*e, ManifestErr::Toml(_, _)), |_| false)
         );
         assert_eq!(
             Manifest::from_toml(String::new(), false, Path::new(""), &[]),
             Err(Box::new(ManifestErr::Package(
                 PackageErr::Missing,
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml("[' package']".to_owned(), false, Path::new(""), &[]),
             Err(Box::new(ManifestErr::Package(
                 PackageErr::Missing,
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml("['package ']".to_owned(), false, Path::new(""), &[]),
             Err(Box::new(ManifestErr::Package(
                 PackageErr::Missing,
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml("package=2".to_owned(), false, Path::new(""), &[]),
             Err(Box::new(ManifestErr::Package(
                 PackageErr::InvalidType,
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml("[package]".to_owned(), false, Path::new(""), &[]),
             Err(Box::new(ManifestErr::Package(
                 PackageErr::MissingName,
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml("[package]\nname=true".to_owned(), false, Path::new(""), &[]),
             Err(Box::new(ManifestErr::Package(
                 PackageErr::InvalidNameType,
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[package]\nname=\"\"\n\nrust-version=2".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Package(
                 PackageErr::InvalidMsrvType,
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[package]\nname=\"\"\nrust-version=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Package(
                 PackageErr::Msrv,
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[package]\nname=\"\"\nrust-version=\"a\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Package(
                 PackageErr::Msrv,
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[package]\nname=\"\"\nrust-version=\"1.00.0\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Package(
                 PackageErr::Msrv,
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[package]\nname=\"\"\nrust-version=\"1..0\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Package(
                 PackageErr::Msrv,
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[package]\nname=\"\"\nrust-version=\"1.\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Package(
                 PackageErr::Msrv,
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[package]\nname=\"\"\nrust-version=\"01.0.0\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Package(
                 PackageErr::Msrv,
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[package]\nname=\"\"\nrust-version=\"1.0.0.1\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Package(
                 PackageErr::Msrv,
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[package]\nname=\"\"\nrust-version=\"111111111111111111111111.2.3\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Package(
                 PackageErr::Msrv,
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[package]\nname=\"\"\nrust-version=\"1.0.0-nightly\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Package(
                 PackageErr::Msrv,
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[package]\nname=\"\"\nrust-version=\"-1.0.0\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Package(
                 PackageErr::Msrv,
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[package]\nname=\"\"\nrust-version=\" 1.0.0\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Package(
                 PackageErr::Msrv,
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[package]\nname=\"\"\nrust-version=\"1.0.0 \"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Package(
                 PackageErr::Msrv,
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[package]\nname=\"\"\nrust-version={}".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Package(
                 PackageErr::MsrvWorkspaceMissing,
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[package]\nname=\"\"\nrust-version={workspace=2}".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Package(
                 PackageErr::MsrvWorkspaceVal,
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[package]\nname=\"\"\nrust-version={workspace=false}".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Package(
                 PackageErr::MsrvWorkspaceVal,
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[package]\nname=\"\"\nrust-version={workspace=true}\nworkspace=2".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Package(
                 PackageErr::InvalidWorkspaceType,
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "workspace=2\n[package]\nname=\"\"\nrust-version={workspace=true}".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Package(
                 PackageErr::Workspace(WorkspaceErr::InvalidType, PathBuf::new()),
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[workspace]\n[package]\nname=\"\"\nrust-version={workspace=true}".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Package(
                 PackageErr::Workspace(WorkspaceErr::MissingPackage, PathBuf::new()),
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[workspace]\npackage=2\n[package]\nname=\"\"\nrust-version={workspace=true}"
                     .to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Package(
                 PackageErr::Workspace(WorkspaceErr::InvalidPackageType, PathBuf::new()),
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[workspace.package]\n[package]\nname=\"\"\nrust-version={workspace=true}"
                     .to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Package(
                 PackageErr::Workspace(WorkspaceErr::MissingPackageMsrv, PathBuf::new()),
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[workspace.package]\nrust-version={}\n[package]\nname=\"\"\nrust-version={workspace=true}"
                     .to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Package(
                 PackageErr::Workspace(WorkspaceErr::InvalidPackageMsrvType, PathBuf::new()),
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[workspace.package]\nrust-version=\"\"\n[package]\nname=\"\"\nrust-version={workspace=true}"
                     .to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Package(
                 PackageErr::Workspace(WorkspaceErr::Msrv, PathBuf::new()),
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "features=2\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Features(
                 FeaturesErr::InvalidType,
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[features]\n\"/\"=[]\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Features(
                 FeaturesErr::InvalidName("/".to_owned()),
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[features]\n\"dep:\"=[]\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Features(
                 FeaturesErr::InvalidName("dep:".to_owned()),
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[features]\n\"\"=2\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Features(
                 FeaturesErr::FeatureDependencies(FeatureDependenciesErr::InvalidFeatureType(
                     String::new()
                 )),
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[features]\n\"\"=[true]\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Features(
                 FeaturesErr::FeatureDependencies(FeatureDependenciesErr::InvalidDependencyType(
                     String::new()
                 )),
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[features]\n\"\"=[\"foo\"]\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Features(
                 FeaturesErr::FeatureDependencies(FeatureDependenciesErr::InvalidDependency(
                     String::new(),
                     "foo".to_owned()
                 )),
                 PathBuf::new()
             )))
         );
         // Feature dependencies can't be implied features when implied features are forbidden.
         assert_eq!(
             Manifest::from_toml(
                 "[dependencies]\nfoo={optional=true}\n[features]\n\"\"=[\"foo\"]\n[package]\nname=\"\""
                     .to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Features(
                 FeaturesErr::FeatureDependencies(FeatureDependenciesErr::InvalidDependency(
                     String::new(),
                     "foo".to_owned()
                 )),
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[features]\n\"\"=[\"\"]\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Features(
                 FeaturesErr::FeatureDependencies(FeatureDependenciesErr::CyclicFeature(
                     String::new()
                 )),
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[features]\n\"\"=[\"a\"]\na=[\"\"]\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Features(
                 FeaturesErr::FeatureDependencies(FeatureDependenciesErr::CyclicFeature(
                     String::new()
                 )),
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[features]\n\"\"=[\"a\"]\na=[\"b\"]\nb=[\"a\"]\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Features(
                 FeaturesErr::FeatureDependencies(FeatureDependenciesErr::CyclicFeature(
                     "a".to_owned()
                 )),
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[features]\n\"\"=[\"a\"]\na=[\"c\",\"b\"]\nb=[\"a\"]\nc=[]\n[package]\nname=\"\""
                     .to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Features(
                 FeaturesErr::FeatureDependencies(FeatureDependenciesErr::CyclicFeature(
                     "a".to_owned()
                 )),
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[features]\n\"\"=[]\na=[\"c\",\"b\"]\nb=[\"a\"]\nc=[]\n[package]\nname=\"\""
                     .to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Features(
                 FeaturesErr::FeatureDependencies(FeatureDependenciesErr::CyclicFeature(
                     "a".to_owned()
                 )),
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[features]\n\"\"=[\"a\",\"b\"]\na=[\"b\"]\nb=[]\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Features(
                 FeaturesErr::FeatureDependencies(FeatureDependenciesErr::RedundantDependency(
                     String::new(),
                     "b".to_owned()
                 )),
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[features]\n\"\"=[\"a\",\"a\"]\na=[]\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Features(
                 FeaturesErr::FeatureDependencies(FeatureDependenciesErr::RedundantDependency(
                     String::new(),
                     "a".to_owned()
                 )),
                 PathBuf::new()
             )))
         );
         // Duplicate `"dep:"` feature dependencies error.
         assert_eq!(
             Manifest::from_toml(
                 "[features]\n\"\"=[\"dep:\",\"dep:\"]\na=[]\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Features(
                 FeaturesErr::FeatureDependencies(FeatureDependenciesErr::RedundantDependency(
                     String::new(),
                     "dep:".to_owned()
                 )),
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "target=2\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::ImpliedFeatures(
                 ImpliedFeaturesErr::TargetType,
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "dependencies=2\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::ImpliedFeatures(
                 ImpliedFeaturesErr::Dependencies(DependenciesErr::Type("dependencies")),
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "build-dependencies=2\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::ImpliedFeatures(
                 ImpliedFeaturesErr::Dependencies(DependenciesErr::Type("build-dependencies")),
                 PathBuf::new(),
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[dependencies]\n\"dep:\"=\"\"\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::ImpliedFeatures(
                 ImpliedFeaturesErr::Dependencies(DependenciesErr::Name(
                     "dependencies",
                     "dep:".to_owned()
                 )),
                 PathBuf::new(),
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[dependencies]\n\"/\"=\"\"\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::ImpliedFeatures(
                 ImpliedFeaturesErr::Dependencies(DependenciesErr::Name(
                     "dependencies",
                     "/".to_owned()
                 )),
                 PathBuf::new(),
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[build-dependencies]\n\"dep:\"=\"\"\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::ImpliedFeatures(
                 ImpliedFeaturesErr::Dependencies(DependenciesErr::Name(
                     "build-dependencies",
                     "dep:".to_owned()
                 )),
                 PathBuf::new(),
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[build-dependencies]\n\"/\"=\"\"\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::ImpliedFeatures(
                 ImpliedFeaturesErr::Dependencies(DependenciesErr::Name(
                     "build-dependencies",
                     "/".to_owned()
                 )),
                 PathBuf::new(),
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[dependencies]\n\"\"=2\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::ImpliedFeatures(
                 ImpliedFeaturesErr::Dependencies(DependenciesErr::DependencyType(
                     "dependencies",
                     String::new()
                 )),
                 PathBuf::new(),
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[build-dependencies]\n\"\"=2\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::ImpliedFeatures(
                 ImpliedFeaturesErr::Dependencies(DependenciesErr::DependencyType(
                     "build-dependencies",
                     String::new()
                 )),
                 PathBuf::new(),
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[dependencies]\n\"\"={optional=2}\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::ImpliedFeatures(
                 ImpliedFeaturesErr::Dependencies(DependenciesErr::OptionalType(
                     "dependencies",
                     String::new()
                 )),
                 PathBuf::new(),
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[build-dependencies]\n\"\"={optional=2}\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::ImpliedFeatures(
                 ImpliedFeaturesErr::Dependencies(DependenciesErr::OptionalType(
                     "build-dependencies",
                     String::new()
                 )),
                 PathBuf::new(),
             )))
         );
         // Implied features are disallowed iff `!allow_implied_features`.
         assert_eq!(
             Manifest::from_toml(
                 "[dependencies]\nfoo={optional=true}\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::ImpliedFeatures(
                 ImpliedFeaturesErr::Dependencies(DependenciesErr::ImpliedFeature(
                     "dependencies",
                     "foo".to_owned()
                 )),
                 PathBuf::new(),
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[target]\n\"\"=2\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::ImpliedFeatures(
                 ImpliedFeaturesErr::TargetPlatformType(String::new()),
                 PathBuf::new(),
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[target.\"\"]\ndependencies=2\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::ImpliedFeatures(
                 ImpliedFeaturesErr::TagetPlatformDependencies(
                     String::new(),
                     DependenciesErr::Type("dependencies")
                 ),
                 PathBuf::new(),
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[target.\"\"]\nbuild-dependencies=2\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::ImpliedFeatures(
                 ImpliedFeaturesErr::TagetPlatformDependencies(
                     String::new(),
                     DependenciesErr::Type("build-dependencies")
                 ),
                 PathBuf::new(),
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[target.\"\".dependencies]\n\"/\"=\"\"\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::ImpliedFeatures(
                 ImpliedFeaturesErr::TagetPlatformDependencies(
                     String::new(),
                     DependenciesErr::Name("dependencies", "/".to_owned())
                 ),
                 PathBuf::new(),
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[target.\"\".dependencies]\n\"dep:\"=\"\"\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::ImpliedFeatures(
                 ImpliedFeaturesErr::TagetPlatformDependencies(
                     String::new(),
                     DependenciesErr::Name("dependencies", "dep:".to_owned())
                 ),
                 PathBuf::new(),
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[target.\"\".build-dependencies]\n\"/\"=\"\"\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::ImpliedFeatures(
                 ImpliedFeaturesErr::TagetPlatformDependencies(
                     String::new(),
                     DependenciesErr::Name("build-dependencies", "/".to_owned())
                 ),
                 PathBuf::new(),
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[target.\"\".build-dependencies]\n\"dep:\"=\"\"\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::ImpliedFeatures(
                 ImpliedFeaturesErr::TagetPlatformDependencies(
                     String::new(),
                     DependenciesErr::Name("build-dependencies", "dep:".to_owned())
                 ),
                 PathBuf::new(),
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[target.\"\".dependencies]\n\"\"=false\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::ImpliedFeatures(
                 ImpliedFeaturesErr::TagetPlatformDependencies(
                     String::new(),
                     DependenciesErr::DependencyType("dependencies", String::new())
                 ),
                 PathBuf::new(),
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[target.\"\".build-dependencies]\n\"\"=false\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::ImpliedFeatures(
                 ImpliedFeaturesErr::TagetPlatformDependencies(
                     String::new(),
                     DependenciesErr::DependencyType("build-dependencies", String::new())
                 ),
                 PathBuf::new(),
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[target.\"\".dependencies]\n\"\"={optional=2}\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::ImpliedFeatures(
                 ImpliedFeaturesErr::TagetPlatformDependencies(
                     String::new(),
                     DependenciesErr::OptionalType("dependencies", String::new())
                 ),
                 PathBuf::new(),
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[target.\"\".build-dependencies]\n\"\"={optional=2}\n[package]\nname=\"\""
                     .to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::ImpliedFeatures(
                 ImpliedFeaturesErr::TagetPlatformDependencies(
                     String::new(),
                     DependenciesErr::OptionalType("build-dependencies", String::new())
                 ),
                 PathBuf::new(),
             )))
         );
         // An invalid dependency error occurs later when we `allow_implied_features` since
         // implied features aren't added until after feature extraction.
         assert_eq!(
             Manifest::from_toml(
                 "[features]\n\"\"=[\"foo\"]\n[package]\nname=\"\"".to_owned(),
                 true,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::ImpliedFeatures(
                 ImpliedFeaturesErr::InvalidDependency(String::new(), "foo".to_owned()),
                 PathBuf::new(),
             )))
         );
         // In contrast, above would have erred sooner if `!allow_implied_features`.
         assert_eq!(
             Manifest::from_toml(
                 "[features]\n\"\"=[\"foo\"]\n[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Err(Box::new(ManifestErr::Features(
                 FeaturesErr::FeatureDependencies(FeatureDependenciesErr::InvalidDependency(
                     String::new(),
                     "foo".to_owned()
                 )),
                 PathBuf::new()
             )))
         );
         assert_eq!(
             Manifest::from_toml(
                 "[package]\nname=\"\"".to_owned(),
                 false,
                 Path::new(""),
                 &["a".to_owned()]
             ),
             Err(Box::new(ManifestErr::UndefinedIgnoreFeature(
                 "a".to_owned(),
                 PathBuf::new()
             )))
         );
         // Even if we forbid implied features, we don't error when a feature is defined
         // with the same name of an implied feature. This is due to simplicity in code
         // and the fact that `cargo` will error anyway.
         //
         // For example once `cargo` is invoked, an error will occur due to duplicate features:
         // the explict feature `foo` and the implied feature from the dependency `foo`.
         assert_eq!(
             Manifest::from_toml(
                 "[dependencies]\nfoo={optional=true}\n[features]\nfoo=[]\n[package]\nname=\"\""
                     .to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Ok(Manifest {
                 package: Package {
                     msrv: None,
                     name: String::new(),
                 },
                 features: Features(vec![("foo".to_owned(), Vec::new())]),
             })
         );
         // Allow major-only MSRV.
         assert_eq!(
             Manifest::from_toml(
                 "[package]\nname=\"foo\"\nrust-version=\"0\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Ok(Manifest {
                 package: Package {
                     msrv: Some(Msrv {
                         major: 0,
                         minor: None,
                         patch: None,
                     }),
                     name: "foo".to_owned(),
                 },
                 features: Features(Vec::new()),
             })
         );
         // Allow escapes.
         assert_eq!(
             Manifest::from_toml(
                 "[\"\\u0070ackage\"]\n\"n\\u0061me\"=\"\\u0066oo\"\n\"\\u0072ust-version\"=\"0\\u002E\\u0031\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Ok(Manifest {
                 package: Package {
                     msrv: Some(Msrv {
                         major: 0,
                         minor: Some(1),
                         patch: None,
                     }),
                     name: "foo".to_owned(),
                 },
                 features: Features(Vec::new()),
             })
         );
         assert_eq!(
             Manifest::from_toml(
                 "[package]\nname=\"\"\nrust-version=\"0.0.0\"".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Ok(Manifest {
                 package: Package {
                     msrv: Some(Msrv {
                         major: 0,
                         minor: Some(0),
                         patch: Some(0),
                     }),
                     name: String::new(),
                 },
                 features: Features(Vec::new()),
             })
         );
         // Ignore non `rust-version` keys in `package`. Ignore keys in the root document except `package`,
         // `features`, `dependencies`, `build-dependencies`, and `target`. Ignore keys in
         // `target.<something>` unless the key is `dependencies` or `build-dependencies`. Don't treat
         // `<something>` special in `target.<something>` other than its being a table.
         assert_eq!(
             Manifest::from_toml("dev-dependencies=2\n[package]\nname=\"\"\n\nfoo=2\nrust-version=\"18446744073709551615.18446744073709551615.18446744073709551615\"\n[foo]\nbar=false\n[target.\"\".foo]\nbar=2\n[target.foo]\nbar=false\n[target.dependencies]\nfoo=2\n[target.build-dependencies]\nfoo=false\n[target.dev-dependencies]\nfoo=true\n".to_owned(), false, Path::new(""), &[]),
             Ok(Manifest {
                 package: Package {
                     msrv: Some(Msrv {
                         major: u64::MAX,
                         minor: Some(u64::MAX),
                         patch: Some(u64::MAX),
                     }),
                     name: String::new(),
                 },
                 features: Features(Vec::new()),
             })
         );
         // [package]
         // name = ""
         //
         // ["\u0064ependencies"]
         // "\u0000" = "\u0000"
         // a = { optional = true }
         //
         // ["build-\u0064ependencies"]
         // "\u0000" = { optional = true }
         //
         // [dev-dependencies]
         // buzz = { optional = true }
         //
         // [target."".dependencies]
         // b = { optional = false, foo = 2 }
         // fizz = { optional = true, foo = 3 }
         //
         // [target.a.dependencies]
         // c = { optional = true }
         // wuzz = { optional = true }
         //
         // [features]
         // default = ["bar","dep:lk","a/ak", "a/ak"]
         // bar = ["dep\u003Awuzz"]
         //
         // We allow any and all key names unless it's the features table or a dependency table; in which case
         // key names must not contain `'/'` nor begin with `"dep:"`.
         //
         // The order of features is based on the following hierarchy:
         // * Explict features: lexicographically sorted
         // * dependencies: optional only, lexicographically sorted, only if an explicit feature doesn't exist with
         //   the same name nor any explicit feature contains a dependency named `"dep:<dependecy>"` and we allow
         //   implied features. If such feature exists, we don't error but simply don't add.
         // * build-dependencies: read above.
         // * target.<something>: lexicographically sorted by something, within `something`, `dependencies`
         //   is first using the same methodology as item 2, last `build-dependencies`.
         //
         // Once the order of features is determined, the only feature dependencies that are retained are those
         // that don't contain `'/'` nor begin with `"dep:"`. We don't require dependencies to be defined for
         // feature dependencies that contain `'/'` or begin with `"dep:"`. We don't care about duplicate feature
         // dependencies that contain `'/'`.
         //
         // Based on above, `Features` looks like the following:
         // 1. (bar, [])
         // 2. (default, ["bar"])
         // 3. (a, [])
         // 4. (\x00, [])
         // 5. (fizz, [])
         // 6. (c, [])
         assert_eq!(
             Manifest::from_toml(
                 "[\"\\u0064ependencies\"]\n\"\\u0000\"=\"\\u0000\"\na={optional=true}\n[\"build-\\u0064ependencies\"]\n\"\\u0000\"={optional=true}\n[target.\"\".dependencies]\nb={optional=false,foo=2}\nfizz={optional=true,foo=3}\n[features]\ndefault=[\"bar\",\"dep:lk\",\"a/ak\",\"a/ak\"]\nbar=[\"dep\\u003Awuzz\"]\n[dev-dependencies]\nbuzz={optional=true}\n[target.a.dependencies]\nc={optional=true}\nwuzz={optional=true}\n[package]\nname=\"\"".to_owned(),
                 true,
                 Path::new(""),
                 &[]
             ),
             Ok(Manifest {
                 package: Package {
                     msrv: None,
                     name: String::new(),
                 },
                 features: Features(vec![("bar".to_owned(), Vec::new()), ("default".to_owned(), vec!["bar".to_owned()]), ("a".to_owned(), Vec::new()), ("\0".to_owned(), Vec::new()), ("fizz".to_owned(), Vec::new()), ("c".to_owned(), Vec::new())]),
             })
         );
         // [package]
         // name = ""
         //
         // [dependencies]
         // foo = { "optional" = true }
         // fizz = { "optional" = true }
         //
         // [features]
         // fizz = ["dep:fizz"]
         // bar = ["dep:foo"]
         assert_eq!(
             Manifest::from_toml(
                 "[package]\nname=\"\"\n[dependencies]\nfoo={optional=true}\nfizz={optional=true}\n[features]\nfizz=[\"dep:fizz\"]\nbar=[\"dep:foo\"]".to_owned(),
                 false,
                 Path::new(""),
                 &[]
             ),
             Ok(Manifest {
                 package: Package {
                     msrv: None,
                     name: String::new(),
                 },
                 features: Features(vec![
                     ("bar".to_owned(), Vec::new()),
                     ("fizz".to_owned(), Vec::new())
                 ]),
             })
         );
         // [package]
         // name = ""
         //
         // [dependencies]
         // bar = { "optional" = true }
         //
         // [features]
         // foo = ["bar"]
         assert_eq!(
             Manifest::from_toml(
                 "[package]\nname=\"\"\n[dependencies]\nbar={optional=true}\n[features]\nfoo=[\"bar\"]"
                     .to_owned(),
                 true,
                 Path::new(""),
                 &[]
             ),
             Ok(Manifest {
                 package: Package {
                     msrv: None,
                     name: String::new(),
                 },
                 features: Features(vec![
                     ("foo".to_owned(), vec!["bar".to_owned()]),
                     ("bar".to_owned(), Vec::new()),
                 ]),
             })
         );
         assert_eq!(
             Manifest::from_toml(
                 "[package]\nname=\"\"\n[features]\na=[]\nb=[\"a\"]".to_owned(),
                 false,
                 Path::new(""),
                 &["a".to_owned()]
             ),
             Ok(Manifest {
                 package: Package {
                     msrv: None,
                     name: String::new(),
                 },
                 features: Features(vec![]),
             })
         );
         assert_eq!(
             Manifest::from_toml(
                 "[package]\nname=\"\"\n[features]\na=[]\nb=[\"a\"]".to_owned(),
                 false,
                 Path::new(""),
                 &["b".to_owned()]
             ),
             Ok(Manifest {
                 package: Package {
                     msrv: None,
                     name: String::new(),
                 },
                 features: Features(vec![("a".to_owned(), Vec::new())]),
             })
         );
         assert_eq!(
             Manifest::from_toml(
                 "[package]\nname=\"\"\n[dependencies]\nc={optional=true}\n[features]\nb=[\"c\"]"
                     .to_owned(),
                 true,
                 Path::new(""),
                 &["c".to_owned()]
             ),
             Ok(Manifest {
                 package: Package {
                     msrv: None,
                     name: String::new(),
                 },
                 features: Features(vec![]),
             })
         );
         assert_eq!(
             Manifest::from_toml(
                 "[package]\nname=\"\"\n[dependencies]\nc={optional=true}\n[features]\nb=[\"c\"]"
                     .to_owned(),
                 true,
                 Path::new(""),
                 &["b".to_owned()]
             ),
             Ok(Manifest {
                 package: Package {
                     msrv: None,
                     name: String::new(),
                 },
                 features: Features(vec![("c".to_owned(), Vec::new())]),
             })
         );
     }
     #[expect(clippy::unreachable, reason = "want to crash when there is a bug")]
     #[expect(
         clippy::cognitive_complexity,
         clippy::too_many_lines,
         reason = "want to test for a lot of things"
     )]
     #[test]
     fn power_set() {
         #[cfg(target_pointer_width = "16")]
         let feat_len_one_too_large = 17;
         #[cfg(target_pointer_width = "32")]
         let feat_len_one_too_large = 33;
         #[cfg(target_pointer_width = "64")]
         let feat_len_one_too_large = 65;
         let mut feats = Features(vec![(String::new(), Vec::new()); feat_len_one_too_large]);
         assert_eq!(PowerSet::new(&feats, false), Err(TooManyFeaturesErr));
         #[cfg(target_pointer_width = "16")]
         let max_feat_len = 16;
         #[cfg(target_pointer_width = "32")]
         let max_feat_len = 32;
         #[cfg(target_pointer_width = "64")]
         let max_feat_len = 64;
         feats.0 = vec![(String::new(), Vec::new()); max_feat_len];
         #[cfg(any(
             target_pointer_width = "16",
             target_pointer_width = "32",
             target_pointer_width = "64"
         ))]
         assert_eq!(
             PowerSet::new(&feats, false),
             Ok(Some(PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: true,
                 check_overlap: false,
                 idx: usize::MAX,
                 buffer: vec![""; max_feat_len],
                 set: String::new(),
                 skipped_sets_counter: 0,
                 skip_empty_set: false,
             }))
         );
         feats.0 = Vec::new();
         assert_eq!(
             PowerSet::new(&feats, false),
             Ok(Some(PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: true,
                 check_overlap: false,
                 idx: 0,
                 buffer: Vec::new(),
                 set: String::new(),
                 skipped_sets_counter: 0,
                 skip_empty_set: false,
             }))
         );
         assert_eq!(PowerSet::new(&feats, true), Ok(None));
         let mut power_set = PowerSet::new(&feats, false)
             .unwrap_or_else(|_e| {
                 unreachable!("not possible since we just verified PowerSet::new returned Ok")
             })
             .unwrap_or_else(|| {
                 unreachable!("not possible since we just verified PowerSet::new returned Ok(Some)")
             });
         assert_eq!(power_set.len(), NonZeroUsizePlus1::new(1));
         assert_eq!(power_set.next_set(), Some(""));
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: false,
                 check_overlap: false,
                 idx: 0,
                 buffer: Vec::new(),
                 set: String::new(),
                 skipped_sets_counter: 0,
                 skip_empty_set: false
             }
         );
         assert_eq!(power_set.next_set(), None);
         assert_eq!(power_set.len(), NonZeroUsizePlus1::new(1));
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: false,
                 check_overlap: false,
                 idx: 0,
                 buffer: Vec::new(),
                 set: String::new(),
                 skipped_sets_counter: 0,
                 skip_empty_set: false
             }
         );
         assert_eq!(power_set.next_set(), None);
         power_set.reset();
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: true,
                 check_overlap: false,
                 idx: 0,
                 buffer: Vec::new(),
                 set: String::new(),
                 skipped_sets_counter: 0,
                 skip_empty_set: false
             }
         );
         assert_eq!(power_set.next_set(), Some(""));
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: false,
                 check_overlap: false,
                 idx: 0,
                 buffer: Vec::new(),
                 set: String::new(),
                 skipped_sets_counter: 0,
                 skip_empty_set: false
             }
         );
         assert_eq!(power_set.next_set(), None);
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: false,
                 check_overlap: false,
                 idx: 0,
                 buffer: Vec::new(),
                 set: String::new(),
                 skipped_sets_counter: 0,
                 skip_empty_set: false
             }
         );
         assert_eq!(power_set.next_set(), None);
         // [features]
         // a = ["b"]
         // b = ["c", "d"]
         // c = []
         // d = []
         feats.0 = vec![
             ("a".to_owned(), vec!["b".to_owned()]),
             ("b".to_owned(), vec!["c".to_owned(), "d".to_owned()]),
             ("c".to_owned(), Vec::new()),
             ("d".to_owned(), Vec::new()),
         ];
         assert_eq!(
             PowerSet::new(&feats, false),
             Ok(Some(PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: true,
                 // At least one feature depends on another, so this will be set to `true`.
                 check_overlap: true,
                 idx: 15,
                 buffer: vec!["a", "b", "c", "d"],
                 set: String::new(),
                 skipped_sets_counter: 0,
                 skip_empty_set: false
             }))
         );
         power_set = PowerSet::new(&feats, false)
             .unwrap_or_else(|_e| {
                 unreachable!("not possible since we just verified PowerSet::new returned Ok")
             })
             .unwrap_or_else(|| {
                 unreachable!("not possible since we just verified PowerSet::new returned Ok(Some)")
             });
         assert_eq!(power_set.len(), NonZeroUsizePlus1::new(16));
         // Order is the following:
         // 1. a,b,c,d: skipped since a depends on b.
         // 2. b,c,d: skipped since b depends on c.
         // 3. a,c,d: skipped since a depends on c (via b).
         // 4. c,d
         // 5. a,b,d: skipped since a depends on b.
         // 6. b,d: skipped since b depends on d.
         // 7. a,d: skipped since a depends on d (via b).
         // 8. d
         // 9. a,b,c: skipped since a depends on b.
         // 10. b,c: skipped since b depends on c.
         // 11. a,c: skipped since a depends on c (via b).
         // 12. c
         // 13. a,b: skipped since a depends on b.
         // 14. b
         // 15. a
         // 16.
         assert_eq!(power_set.next_set(), Some("c,d"));
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: true,
                 check_overlap: true,
                 // We started at 15, and we iterated 4 items (skipping 3).
                 idx: 11,
                 buffer: vec!["c", "d"],
                 set: "c,d".to_owned(),
                 skipped_sets_counter: 3,
                 skip_empty_set: false
             }
         );
         assert_eq!(power_set.next_set(), Some("d"));
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: true,
                 check_overlap: true,
                 // We started at 11, and we iterated 4 items (skipping 3).
                 idx: 7,
                 buffer: vec!["d"],
                 set: "d".to_owned(),
                 skipped_sets_counter: 6,
                 skip_empty_set: false
             }
         );
         assert_eq!(power_set.next_set(), Some("c"));
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: true,
                 check_overlap: true,
                 // We started at 7, and we iterated 4 items (skipping 3).
                 idx: 3,
                 buffer: vec!["c"],
                 set: "c".to_owned(),
                 skipped_sets_counter: 9,
                 skip_empty_set: false
             }
         );
         assert_eq!(power_set.next_set(), Some("b"));
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: true,
                 check_overlap: true,
                 // We started at 3, and we iterated 2 items (skipping 1).
                 idx: 1,
                 buffer: vec!["b"],
                 set: "b".to_owned(),
                 skipped_sets_counter: 10,
                 skip_empty_set: false
             }
         );
         assert_eq!(power_set.next_set(), Some("a"));
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: true,
                 check_overlap: true,
                 // We started at 1, and we iterated 1 item.
                 idx: 0,
                 buffer: vec!["a"],
                 set: "a".to_owned(),
                 skipped_sets_counter: 10,
                 skip_empty_set: false
             }
         );
         assert_eq!(power_set.next_set(), Some(""));
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: false,
                 check_overlap: true,
                 // We started at 0, and we iterated 1 item but we don't underflow instead `has_remaining` is set
                 // to `false`.
                 idx: 0,
                 buffer: Vec::new(),
                 set: String::new(),
                 skipped_sets_counter: 10,
                 skip_empty_set: false
             }
         );
         assert_eq!(power_set.next_set(), None);
         // Internal state is left unchanged.
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: false,
                 check_overlap: true,
                 idx: 0,
                 buffer: Vec::new(),
                 set: String::new(),
                 skipped_sets_counter: 10,
                 skip_empty_set: false
             }
         );
         assert_eq!(power_set.next_set(), None);
         // Internal state is left unchanged.
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: false,
                 check_overlap: true,
                 idx: 0,
                 buffer: Vec::new(),
                 set: String::new(),
                 skipped_sets_counter: 10,
                 skip_empty_set: false
             }
         );
         assert_eq!(power_set.len(), NonZeroUsizePlus1::new(16));
         power_set.reset();
         // `PowerSet::reset` only resets what is necessary nothing more; in particular, `buffer` and `set` are
         // left alone.
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: true,
                 check_overlap: true,
                 idx: 15,
                 buffer: Vec::new(),
                 set: String::new(),
                 skipped_sets_counter: 0,
                 skip_empty_set: false
             }
         );
         assert_eq!(power_set.len(), NonZeroUsizePlus1::new(16));
         // Same as above except no feature depends on any other.
         // [features]
         // a = []
         // b = []
         // c = []
         // d = []
         feats.0 = vec![
             ("a".to_owned(), Vec::new()),
             ("b".to_owned(), Vec::new()),
             ("c".to_owned(), Vec::new()),
             ("d".to_owned(), Vec::new()),
         ];
         assert_eq!(
             PowerSet::new(&feats, false),
             Ok(Some(PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: true,
                 check_overlap: false,
                 idx: 15,
                 buffer: vec!["a", "b", "c", "d"],
                 set: String::new(),
                 skipped_sets_counter: 0,
                 skip_empty_set: false
             }))
         );
         power_set = PowerSet::new(&feats, false)
             .unwrap_or_else(|_e| {
                 unreachable!("not possible since we just verified PowerSet::new returned Ok")
             })
             .unwrap_or_else(|| {
                 unreachable!("not possible since we just verified PowerSet::new returned Ok(Some)")
             });
         assert_eq!(power_set.len(), NonZeroUsizePlus1::new(16));
         // Order is the same as above except nothing is skipped:
         // 1. a,b,c,d
         // 2. b,c,d
         // 3. a,c,d
         // 4. c,d
         // 5. a,b,d
         // 6. b,d
         // 7. a,d
         // 8. d
         // 9. a,b,c
         // 10. b,c
         // 11. a,c
         // 12. c
         // 13. a,b
         // 14. b
         // 15. a
         // 16.
         assert_eq!(power_set.next_set(), Some("a,b,c,d"));
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: true,
                 check_overlap: false,
                 idx: 14,
                 buffer: vec!["a", "b", "c", "d"],
                 set: "a,b,c,d".to_owned(),
                 skipped_sets_counter: 0,
                 skip_empty_set: false
             }
         );
         assert_eq!(power_set.next_set(), Some("b,c,d"));
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: true,
                 check_overlap: false,
                 idx: 13,
                 buffer: vec!["b", "c", "d"],
                 set: "b,c,d".to_owned(),
                 skipped_sets_counter: 0,
                 skip_empty_set: false
             }
         );
         assert_eq!(power_set.next_set(), Some("a,c,d"));
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: true,
                 check_overlap: false,
                 idx: 12,
                 buffer: vec!["a", "c", "d"],
                 set: "a,c,d".to_owned(),
                 skipped_sets_counter: 0,
                 skip_empty_set: false
             }
         );
         assert_eq!(power_set.next_set(), Some("c,d"));
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: true,
                 check_overlap: false,
                 idx: 11,
                 buffer: vec!["c", "d"],
                 set: "c,d".to_owned(),
                 skipped_sets_counter: 0,
                 skip_empty_set: false
             }
         );
         assert_eq!(power_set.next_set(), Some("a,b,d"));
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: true,
                 check_overlap: false,
                 idx: 10,
                 buffer: vec!["a", "b", "d"],
                 set: "a,b,d".to_owned(),
                 skipped_sets_counter: 0,
                 skip_empty_set: false
             }
         );
         assert_eq!(power_set.next_set(), Some("b,d"));
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: true,
                 check_overlap: false,
                 idx: 9,
                 buffer: vec!["b", "d"],
                 set: "b,d".to_owned(),
                 skipped_sets_counter: 0,
                 skip_empty_set: false
             }
         );
         assert_eq!(power_set.next_set(), Some("a,d"));
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: true,
                 check_overlap: false,
                 idx: 8,
                 buffer: vec!["a", "d"],
                 set: "a,d".to_owned(),
                 skipped_sets_counter: 0,
                 skip_empty_set: false
             }
         );
         assert_eq!(power_set.next_set(), Some("d"));
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: true,
                 check_overlap: false,
                 idx: 7,
                 buffer: vec!["d"],
                 set: "d".to_owned(),
                 skipped_sets_counter: 0,
                 skip_empty_set: false
             }
         );
         assert_eq!(power_set.next_set(), Some("a,b,c"));
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: true,
                 check_overlap: false,
                 idx: 6,
                 buffer: vec!["a", "b", "c"],
                 set: "a,b,c".to_owned(),
                 skipped_sets_counter: 0,
                 skip_empty_set: false
             }
         );
         assert_eq!(power_set.next_set(), Some("b,c"));
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: true,
                 check_overlap: false,
                 idx: 5,
                 buffer: vec!["b", "c"],
                 set: "b,c".to_owned(),
                 skipped_sets_counter: 0,
                 skip_empty_set: false
             }
         );
         assert_eq!(power_set.next_set(), Some("a,c"));
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: true,
                 check_overlap: false,
                 idx: 4,
                 buffer: vec!["a", "c"],
                 set: "a,c".to_owned(),
                 skipped_sets_counter: 0,
                 skip_empty_set: false
             }
         );
         assert_eq!(power_set.next_set(), Some("c"));
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: true,
                 check_overlap: false,
                 idx: 3,
                 buffer: vec!["c"],
                 set: "c".to_owned(),
                 skipped_sets_counter: 0,
                 skip_empty_set: false
             }
         );
         assert_eq!(power_set.next_set(), Some("a,b"));
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: true,
                 check_overlap: false,
                 idx: 2,
                 buffer: vec!["a", "b"],
                 set: "a,b".to_owned(),
                 skipped_sets_counter: 0,
                 skip_empty_set: false
             }
         );
         assert_eq!(power_set.next_set(), Some("b"));
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: true,
                 check_overlap: false,
                 idx: 1,
                 buffer: vec!["b"],
                 set: "b".to_owned(),
                 skipped_sets_counter: 0,
                 skip_empty_set: false
             }
         );
         assert_eq!(power_set.next_set(), Some("a"));
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: true,
                 check_overlap: false,
                 idx: 0,
                 buffer: vec!["a"],
                 set: "a".to_owned(),
                 skipped_sets_counter: 0,
                 skip_empty_set: false
             }
         );
         assert_eq!(power_set.next_set(), Some(""));
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: false,
                 check_overlap: false,
                 idx: 0,
                 buffer: Vec::new(),
                 set: String::new(),
                 skipped_sets_counter: 0,
                 skip_empty_set: false
             }
         );
         assert_eq!(power_set.next_set(), None);
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: false,
                 check_overlap: false,
                 idx: 0,
                 buffer: Vec::new(),
                 set: String::new(),
                 skipped_sets_counter: 0,
                 skip_empty_set: false
             }
         );
         assert_eq!(power_set.len(), NonZeroUsizePlus1::new(16));
         feats.0 = vec![("a".to_owned(), Vec::new())];
         assert_eq!(
             PowerSet::new(&feats, true),
             Ok(Some(PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: true,
                 check_overlap: false,
                 idx: 1,
                 buffer: vec!["a"],
                 set: String::new(),
                 skipped_sets_counter: 0,
                 skip_empty_set: true
             }))
         );
         power_set = PowerSet::new(&feats, true)
             .unwrap_or_else(|_e| {
                 unreachable!("not possible since we just verified PowerSet::new returned Ok")
             })
             .unwrap_or_else(|| {
                 unreachable!("not possible since we just verified PowerSet::new returned Ok(Some)")
             });
         assert_eq!(power_set.len(), NonZeroUsizePlus1::new(1));
         assert_eq!(power_set.next_set(), Some("a"));
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: false,
                 check_overlap: false,
                 idx: 0,
                 buffer: vec!["a"],
                 set: "a".to_owned(),
                 skipped_sets_counter: 0,
                 skip_empty_set: true,
             }
         );
         assert_eq!(power_set.next_set(), None);
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: false,
                 check_overlap: false,
                 idx: 0,
                 buffer: vec!["a"],
                 set: "a".to_owned(),
                 skipped_sets_counter: 0,
                 skip_empty_set: true,
             }
         );
         assert_eq!(power_set.next_set(), None);
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: false,
                 check_overlap: false,
                 idx: 0,
                 buffer: vec!["a"],
                 set: "a".to_owned(),
                 skipped_sets_counter: 0,
                 skip_empty_set: true,
             }
         );
         power_set.reset();
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: true,
                 check_overlap: false,
                 idx: 1,
                 buffer: vec!["a"],
                 set: "a".to_owned(),
                 skipped_sets_counter: 0,
                 skip_empty_set: true,
             }
         );
         assert_eq!(power_set.next_set(), Some("a"));
         assert_eq!(power_set.next_set(), None);
         assert_eq!(
             power_set,
             PowerSet {
                 feats: feats.0.as_slice(),
                 has_remaining: false,
                 check_overlap: false,
                 idx: 0,
                 buffer: vec!["a"],
                 set: "a".to_owned(),
                 skipped_sets_counter: 0,
                 skip_empty_set: true,
             }
         );
         assert_eq!(power_set.len(), NonZeroUsizePlus1::new(1));
     }
 }