Auto merge of #10564 - Muscraft:rfc2906-part6, r=epage

Part 6 of RFC2906 - Switch the inheritance source from `workspace` to…

Tracking issue: #8415
RFC: rust-lang/rfcs#2906

Part 1: #10497
Part 2: #10517
Part 3: #10538
Part 4: #10548
Part 5: #10563

This PR focuses on switching the inheritance source from `workspace` to `workspace.package`. The RFC specified `workspace` but it was decided that it should be changed to `workspace.package` per [epage's comment](#8415 (comment)).
- Moved fields that can be inherited to ` package: Option<InheritableFields>` in `TomlWorkspace`
  - Making `package` `Option<InheritableFields>` was done to remove duplication of types and better signify what fields you can inherit from in one place
- Added `#[serde(skip)]` to `ws_root` and `dependencies` in `InheritableFields` since they will never be present when deserializing and we don't want them present when serializing
- Added a method to update `ws_root` and `dependencies` in `InheritableFields`
  - Added for `ws_root` since it will never be present in a `Cargo.toml` and is needed to resolve relative paths
  - Added for `dependencies` since they are under `workspace.dependencies` not `workspace.package.dependencies`
- `workspace.dependencies` was left out of `workspace.package` to better match `package` and `package.dependencies`
- Updated error messages from `workspace._` to `workspace.package._`
- Updated `unstable.md` to reflect change to `workspace.package`
- Updated tests to use `workspace.package`

Remaining implementation work for the RFC
- Add `include` and `exclude` now that `workspace.package` is done, see [epage's comment](#8415 (comment))
- `cargo-add` support, see [epage's comment](#8415 (comment))
- Optimizations, as needed

Author: bors

src/cargo/core/mod.rs

@@ -11,9 +11,10 @@ pub use self::shell::{Shell, Verbosity};
 pub use self::source::{GitReference, Source, SourceId, SourceMap};
 pub use self::summary::{FeatureMap, FeatureValue, Summary};
 pub use self::workspace::{
-    find_workspace_root, resolve_relative_path, InheritableFields, MaybePackage, Workspace,
-    WorkspaceConfig, WorkspaceRootConfig,
+    find_workspace_root, resolve_relative_path, MaybePackage, Workspace, WorkspaceConfig,
+    WorkspaceRootConfig,
 };
+pub use crate::util::toml::InheritableFields;
 
 pub mod compiler;
 pub mod dependency;

src/cargo/core/workspace.rs

@@ -23,9 +23,7 @@ use crate::sources::{PathSource, CRATES_IO_INDEX, CRATES_IO_REGISTRY};
 use crate::util::errors::{CargoResult, ManifestError};
 use crate::util::interning::InternedString;
 use crate::util::lev_distance;
-use crate::util::toml::{
-    read_manifest, readme_for_project, StringOrBool, TomlDependency, TomlProfiles, VecStringOrBool,
-};
+use crate::util::toml::{read_manifest, InheritableFields, TomlDependency, TomlProfiles};
 use crate::util::{config::ConfigRelativePath, Config, Filesystem, IntoUrl};
 use cargo_util::paths;
 use cargo_util::paths::normalize_path;
@@ -1644,213 +1642,6 @@ impl WorkspaceRootConfig {
     }
 }
 
-/// A group of fields that are inheritable by members of the workspace
-#[derive(Clone, Debug, Default)]
-pub struct InheritableFields {
-    dependencies: Option<BTreeMap<String, TomlDependency>>,
-    version: Option<semver::Version>,
-    authors: Option<Vec<String>>,
-    description: Option<String>,
-    homepage: Option<String>,
-    documentation: Option<String>,
-    readme: Option<StringOrBool>,
-    keywords: Option<Vec<String>>,
-    categories: Option<Vec<String>>,
-    license: Option<String>,
-    license_file: Option<String>,
-    repository: Option<String>,
-    publish: Option<VecStringOrBool>,
-    edition: Option<String>,
-    badges: Option<BTreeMap<String, BTreeMap<String, String>>>,
-    rust_version: Option<String>,
-    ws_root: PathBuf,
-}
-
-impl InheritableFields {
-    pub fn new(
-        dependencies: Option<BTreeMap<String, TomlDependency>>,
-        version: Option<semver::Version>,
-        authors: Option<Vec<String>>,
-        description: Option<String>,
-        homepage: Option<String>,
-        documentation: Option<String>,
-        readme: Option<StringOrBool>,
-        keywords: Option<Vec<String>>,
-        categories: Option<Vec<String>>,
-        license: Option<String>,
-        license_file: Option<String>,
-        repository: Option<String>,
-        publish: Option<VecStringOrBool>,
-        edition: Option<String>,
-        badges: Option<BTreeMap<String, BTreeMap<String, String>>>,
-        rust_version: Option<String>,
-        ws_root: PathBuf,
-    ) -> InheritableFields {
-        Self {
-            dependencies,
-            version,
-            authors,
-            description,
-            homepage,
-            documentation,
-            readme,
-            keywords,
-            categories,
-            license,
-            license_file,
-            repository,
-            publish,
-            edition,
-            badges,
-            rust_version,
-            ws_root,
-        }
-    }
-
-    pub fn dependencies(&self) -> CargoResult<BTreeMap<String, TomlDependency>> {
-        self.dependencies.clone().map_or(
-            Err(anyhow!("`workspace.dependencies` was not defined")),
-            |d| Ok(d),
-        )
-    }
-
-    pub fn get_dependency(&self, name: &str) -> CargoResult<TomlDependency> {
-        self.dependencies.clone().map_or(
-            Err(anyhow!("`workspace.dependencies` was not defined")),
-            |deps| {
-                deps.get(name).map_or(
-                    Err(anyhow!(
-                        "`dependency.{}` was not found in `workspace.dependencies`",
-                        name
-                    )),
-                    |dep| Ok(dep.clone()),
-                )
-            },
-        )
-    }
-
-    pub fn version(&self) -> CargoResult<semver::Version> {
-        self.version
-            .clone()
-            .map_or(Err(anyhow!("`workspace.version` was not defined")), |d| {
-                Ok(d)
-            })
-    }
-
-    pub fn authors(&self) -> CargoResult<Vec<String>> {
-        self.authors
-            .clone()
-            .map_or(Err(anyhow!("`workspace.authors` was not defined")), |d| {
-                Ok(d)
-            })
-    }
-
-    pub fn description(&self) -> CargoResult<String> {
-        self.description.clone().map_or(
-            Err(anyhow!("`workspace.description` was not defined")),
-            |d| Ok(d),
-        )
-    }
-
-    pub fn homepage(&self) -> CargoResult<String> {
-        self.homepage
-            .clone()
-            .map_or(Err(anyhow!("`workspace.homepage` was not defined")), |d| {
-                Ok(d)
-            })
-    }
-
-    pub fn documentation(&self) -> CargoResult<String> {
-        self.documentation.clone().map_or(
-            Err(anyhow!("`workspace.documentation` was not defined")),
-            |d| Ok(d),
-        )
-    }
-
-    pub fn readme(&self, package_root: &Path) -> CargoResult<StringOrBool> {
-        readme_for_project(self.ws_root.as_path(), self.readme.clone()).map_or(
-            Err(anyhow!("`workspace.readme` was not defined")),
-            |readme| {
-                let rel_path =
-                    resolve_relative_path("readme", &self.ws_root, package_root, &readme)?;
-                Ok(StringOrBool::String(rel_path))
-            },
-        )
-    }
-
-    pub fn keywords(&self) -> CargoResult<Vec<String>> {
-        self.keywords
-            .clone()
-            .map_or(Err(anyhow!("`workspace.keywords` was not defined")), |d| {
-                Ok(d)
-            })
-    }
-
-    pub fn categories(&self) -> CargoResult<Vec<String>> {
-        self.categories.clone().map_or(
-            Err(anyhow!("`workspace.categories` was not defined")),
-            |d| Ok(d),
-        )
-    }
-
-    pub fn license(&self) -> CargoResult<String> {
-        self.license
-            .clone()
-            .map_or(Err(anyhow!("`workspace.license` was not defined")), |d| {
-                Ok(d)
-            })
-    }
-
-    pub fn license_file(&self, package_root: &Path) -> CargoResult<String> {
-        self.license_file.clone().map_or(
-            Err(anyhow!("`workspace.license_file` was not defined")),
-            |d| resolve_relative_path("license-file", &self.ws_root, package_root, &d),
-        )
-    }
-
-    pub fn repository(&self) -> CargoResult<String> {
-        self.repository.clone().map_or(
-            Err(anyhow!("`workspace.repository` was not defined")),
-            |d| Ok(d),
-        )
-    }
-
-    pub fn publish(&self) -> CargoResult<VecStringOrBool> {
-        self.publish
-            .clone()
-            .map_or(Err(anyhow!("`workspace.publish` was not defined")), |d| {
-                Ok(d)
-            })
-    }
-
-    pub fn edition(&self) -> CargoResult<String> {
-        self.edition
-            .clone()
-            .map_or(Err(anyhow!("`workspace.edition` was not defined")), |d| {
-                Ok(d)
-            })
-    }
-
-    pub fn rust_version(&self) -> CargoResult<String> {
-        self.rust_version.clone().map_or(
-            Err(anyhow!("`workspace.rust-version` was not defined")),
-            |d| Ok(d),
-        )
-    }
-
-    pub fn badges(&self) -> CargoResult<BTreeMap<String, BTreeMap<String, String>>> {
-        self.badges
-            .clone()
-            .map_or(Err(anyhow!("`workspace.badges` was not defined")), |d| {
-                Ok(d)
-            })
-    }
-
-    pub fn ws_root(&self) -> &PathBuf {
-        &self.ws_root
-    }
-}
-
 pub fn resolve_relative_path(
     label: &str,
     old_root: &Path,