refactor(toml): Rename 'resolved' to 'normalized'

epage · epage · commit a682564336f0 · 2024-08-01T16:23:53.000-05:00
In a discussion on an issue, it became confusing to talk about
"resolved" manifests and dependency resolution,
so I'm switching manifests to use the other term I considered,
"normalized".
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -33,7 +33,7 @@ cargo-platform = { path = "crates/cargo-platform", version = "0.1.5" }
 cargo-test-macro = { version = "0.3.0", path = "crates/cargo-test-macro" }
 cargo-test-support = { version = "0.4.0", path = "crates/cargo-test-support" }
 cargo-util = { version = "0.2.14", path = "crates/cargo-util" }
-cargo-util-schemas = { version = "0.5.0", path = "crates/cargo-util-schemas" }
+cargo-util-schemas = { version = "0.6.0", path = "crates/cargo-util-schemas" }
 cargo_metadata = "0.18.1"
 clap = "4.5.11"
 color-print = "0.3.6"
diff --git a/crates/cargo-util-schemas/Cargo.toml b/crates/cargo-util-schemas/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "cargo-util-schemas"
-version = "0.5.1"
+version = "0.6.0"
 rust-version = "1.80"  # MSRV:1
 edition.workspace = true
 license.workspace = true
diff --git a/crates/cargo-util-schemas/src/manifest/mod.rs b/crates/cargo-util-schemas/src/manifest/mod.rs
@@ -106,8 +106,8 @@ impl TomlManifest {
         self.features.as_ref()
     }
 
-    pub fn resolved_lints(&self) -> Result<Option<&TomlLints>, UnresolvedError> {
-        self.lints.as_ref().map(|l| l.resolved()).transpose()
+    pub fn normalized_lints(&self) -> Result<Option<&TomlLints>, UnresolvedError> {
+        self.lints.as_ref().map(|l| l.normalized()).transpose()
     }
 }
 
@@ -237,23 +237,26 @@ impl TomlPackage {
         }
     }
 
-    pub fn resolved_edition(&self) -> Result<Option<&String>, UnresolvedError> {
-        self.edition.as_ref().map(|v| v.resolved()).transpose()
+    pub fn normalized_edition(&self) -> Result<Option<&String>, UnresolvedError> {
+        self.edition.as_ref().map(|v| v.normalized()).transpose()
     }
 
-    pub fn resolved_rust_version(&self) -> Result<Option<&RustVersion>, UnresolvedError> {
-        self.rust_version.as_ref().map(|v| v.resolved()).transpose()
+    pub fn normalized_rust_version(&self) -> Result<Option<&RustVersion>, UnresolvedError> {
+        self.rust_version
+            .as_ref()
+            .map(|v| v.normalized())
+            .transpose()
     }
 
-    pub fn resolved_version(&self) -> Result<Option<&semver::Version>, UnresolvedError> {
-        self.version.as_ref().map(|v| v.resolved()).transpose()
+    pub fn normalized_version(&self) -> Result<Option<&semver::Version>, UnresolvedError> {
+        self.version.as_ref().map(|v| v.normalized()).transpose()
     }
 
-    pub fn resolved_authors(&self) -> Result<Option<&Vec<String>>, UnresolvedError> {
-        self.authors.as_ref().map(|v| v.resolved()).transpose()
+    pub fn normalized_authors(&self) -> Result<Option<&Vec<String>>, UnresolvedError> {
+        self.authors.as_ref().map(|v| v.normalized()).transpose()
     }
 
-    pub fn resolved_build(&self) -> Result<Option<&String>, UnresolvedError> {
+    pub fn normalized_build(&self) -> Result<Option<&String>, UnresolvedError> {
         let readme = self.build.as_ref().ok_or(UnresolvedError)?;
         match readme {
             StringOrBool::Bool(false) => Ok(None),
@@ -262,60 +265,66 @@ impl TomlPackage {
         }
     }
 
-    pub fn resolved_exclude(&self) -> Result<Option<&Vec<String>>, UnresolvedError> {
-        self.exclude.as_ref().map(|v| v.resolved()).transpose()
+    pub fn normalized_exclude(&self) -> Result<Option<&Vec<String>>, UnresolvedError> {
+        self.exclude.as_ref().map(|v| v.normalized()).transpose()
     }
 
-    pub fn resolved_include(&self) -> Result<Option<&Vec<String>>, UnresolvedError> {
-        self.include.as_ref().map(|v| v.resolved()).transpose()
+    pub fn normalized_include(&self) -> Result<Option<&Vec<String>>, UnresolvedError> {
+        self.include.as_ref().map(|v| v.normalized()).transpose()
     }
 
-    pub fn resolved_publish(&self) -> Result<Option<&VecStringOrBool>, UnresolvedError> {
-        self.publish.as_ref().map(|v| v.resolved()).transpose()
+    pub fn normalized_publish(&self) -> Result<Option<&VecStringOrBool>, UnresolvedError> {
+        self.publish.as_ref().map(|v| v.normalized()).transpose()
     }
 
-    pub fn resolved_description(&self) -> Result<Option<&String>, UnresolvedError> {
-        self.description.as_ref().map(|v| v.resolved()).transpose()
+    pub fn normalized_description(&self) -> Result<Option<&String>, UnresolvedError> {
+        self.description
+            .as_ref()
+            .map(|v| v.normalized())
+            .transpose()
     }
 
-    pub fn resolved_homepage(&self) -> Result<Option<&String>, UnresolvedError> {
-        self.homepage.as_ref().map(|v| v.resolved()).transpose()
+    pub fn normalized_homepage(&self) -> Result<Option<&String>, UnresolvedError> {
+        self.homepage.as_ref().map(|v| v.normalized()).transpose()
     }
 
-    pub fn resolved_documentation(&self) -> Result<Option<&String>, UnresolvedError> {
+    pub fn normalized_documentation(&self) -> Result<Option<&String>, UnresolvedError> {
         self.documentation
             .as_ref()
-            .map(|v| v.resolved())
+            .map(|v| v.normalized())
             .transpose()
     }
 
-    pub fn resolved_readme(&self) -> Result<Option<&String>, UnresolvedError> {
+    pub fn normalized_readme(&self) -> Result<Option<&String>, UnresolvedError> {
         let readme = self.readme.as_ref().ok_or(UnresolvedError)?;
-        readme.resolved().and_then(|sb| match sb {
+        readme.normalized().and_then(|sb| match sb {
             StringOrBool::Bool(false) => Ok(None),
             StringOrBool::Bool(true) => Err(UnresolvedError),
             StringOrBool::String(value) => Ok(Some(value)),
         })
     }
 
-    pub fn resolved_keywords(&self) -> Result<Option<&Vec<String>>, UnresolvedError> {
-        self.keywords.as_ref().map(|v| v.resolved()).transpose()
+    pub fn normalized_keywords(&self) -> Result<Option<&Vec<String>>, UnresolvedError> {
+        self.keywords.as_ref().map(|v| v.normalized()).transpose()
     }
 
-    pub fn resolved_categories(&self) -> Result<Option<&Vec<String>>, UnresolvedError> {
-        self.categories.as_ref().map(|v| v.resolved()).transpose()
+    pub fn normalized_categories(&self) -> Result<Option<&Vec<String>>, UnresolvedError> {
+        self.categories.as_ref().map(|v| v.normalized()).transpose()
     }
 
-    pub fn resolved_license(&self) -> Result<Option<&String>, UnresolvedError> {
-        self.license.as_ref().map(|v| v.resolved()).transpose()
+    pub fn normalized_license(&self) -> Result<Option<&String>, UnresolvedError> {
+        self.license.as_ref().map(|v| v.normalized()).transpose()
     }
 
-    pub fn resolved_license_file(&self) -> Result<Option<&String>, UnresolvedError> {
-        self.license_file.as_ref().map(|v| v.resolved()).transpose()
+    pub fn normalized_license_file(&self) -> Result<Option<&String>, UnresolvedError> {
+        self.license_file
+            .as_ref()
+            .map(|v| v.normalized())
+            .transpose()
     }
 
-    pub fn resolved_repository(&self) -> Result<Option<&String>, UnresolvedError> {
-        self.repository.as_ref().map(|v| v.resolved()).transpose()
+    pub fn normalized_repository(&self) -> Result<Option<&String>, UnresolvedError> {
+        self.repository.as_ref().map(|v| v.normalized()).transpose()
     }
 }
 
@@ -330,7 +339,7 @@ pub enum InheritableField<T> {
 }
 
 impl<T> InheritableField<T> {
-    pub fn resolved(&self) -> Result<&T, UnresolvedError> {
+    pub fn normalized(&self) -> Result<&T, UnresolvedError> {
         self.as_value().ok_or(UnresolvedError)
     }
 
@@ -634,7 +643,7 @@ impl InheritableDependency {
         }
     }
 
-    pub fn resolved(&self) -> Result<&TomlDependency, UnresolvedError> {
+    pub fn normalized(&self) -> Result<&TomlDependency, UnresolvedError> {
         match self {
             InheritableDependency::Value(d) => Ok(d),
             InheritableDependency::Inherit(_) => Err(UnresolvedError),
@@ -1440,7 +1449,7 @@ pub struct InheritableLints {
 }
 
 impl InheritableLints {
-    pub fn resolved(&self) -> Result<&TomlLints, UnresolvedError> {
+    pub fn normalized(&self) -> Result<&TomlLints, UnresolvedError> {
         if self.workspace {
             Err(UnresolvedError)
         } else {
diff --git a/src/cargo/core/compiler/fingerprint/mod.rs b/src/cargo/core/compiler/fingerprint/mod.rs
@@ -1426,7 +1426,7 @@ fn calculate_normal(
     // HACK(#13975): duplicating the lookup logic here until `--check-cfg` is supported
     // on Cargo's MSRV and we can centralize the logic in `lints_to_rustflags`
     let mut lint_check_cfg = Vec::new();
-    if let Ok(Some(lints)) = unit.pkg.manifest().resolved_toml().resolved_lints() {
+    if let Ok(Some(lints)) = unit.pkg.manifest().normalized_toml().normalized_lints() {
         if let Some(rust_lints) = lints.get("rust") {
             if let Some(unexpected_cfgs) = rust_lints.get("unexpected_cfgs") {
                 if let Some(config) = unexpected_cfgs.config() {
diff --git a/src/cargo/core/compiler/mod.rs b/src/cargo/core/compiler/mod.rs
@@ -1355,7 +1355,7 @@ fn check_cfg_args(unit: &Unit) -> CargoResult<Vec<OsString>> {
     ];
 
     // Also include the custom arguments specified in `[lints.rust.unexpected_cfgs.check_cfg]`
-    if let Ok(Some(lints)) = unit.pkg.manifest().resolved_toml().resolved_lints() {
+    if let Ok(Some(lints)) = unit.pkg.manifest().normalized_toml().normalized_lints() {
         if let Some(rust_lints) = lints.get("rust") {
             if let Some(unexpected_cfgs) = rust_lints.get("unexpected_cfgs") {
                 if let Some(config) = unexpected_cfgs.config() {
diff --git a/src/cargo/core/manifest.rs b/src/cargo/core/manifest.rs
@@ -64,7 +64,7 @@ pub struct Manifest {
     contents: Rc<String>,
     document: Rc<toml_edit::ImDocument<String>>,
     original_toml: Rc<TomlManifest>,
-    resolved_toml: Rc<TomlManifest>,
+    normalized_toml: Rc<TomlManifest>,
     summary: Summary,
 
     // this form of manifest:
@@ -110,7 +110,7 @@ pub struct VirtualManifest {
     contents: Rc<String>,
     document: Rc<toml_edit::ImDocument<String>>,
     original_toml: Rc<TomlManifest>,
-    resolved_toml: Rc<TomlManifest>,
+    normalized_toml: Rc<TomlManifest>,
 
     // this form of manifest:
     replace: Vec<(PackageIdSpec, Dependency)>,
@@ -422,7 +422,7 @@ impl Manifest {
         contents: Rc<String>,
         document: Rc<toml_edit::ImDocument<String>>,
         original_toml: Rc<TomlManifest>,
-        resolved_toml: Rc<TomlManifest>,
+        normalized_toml: Rc<TomlManifest>,
         summary: Summary,
 
         default_kind: Option<CompileKind>,
@@ -451,7 +451,7 @@ impl Manifest {
             contents,
             document,
             original_toml,
-            resolved_toml,
+            normalized_toml,
             summary,
 
             default_kind,
@@ -483,9 +483,9 @@ impl Manifest {
     pub fn contents(&self) -> &str {
         self.contents.as_str()
     }
-    /// See [`Manifest::resolved_toml`] for what "resolved" means
-    pub fn to_resolved_contents(&self) -> CargoResult<String> {
-        let toml = toml::to_string_pretty(self.resolved_toml())?;
+    /// See [`Manifest::normalized_toml`] for what "normalized" means
+    pub fn to_normalized_contents(&self) -> CargoResult<String> {
+        let toml = toml::to_string_pretty(self.normalized_toml())?;
         Ok(format!("{}\n{}", MANIFEST_PREAMBLE, toml))
     }
     /// Collection of spans for the original TOML
@@ -502,8 +502,8 @@ impl Manifest {
     /// useful for the operation of cargo, including
     /// - workspace inheritance
     /// - target discovery
-    pub fn resolved_toml(&self) -> &TomlManifest {
-        &self.resolved_toml
+    pub fn normalized_toml(&self) -> &TomlManifest {
+        &self.normalized_toml
     }
     pub fn summary(&self) -> &Summary {
         &self.summary
@@ -553,7 +553,7 @@ impl Manifest {
         &self.warnings
     }
     pub fn profiles(&self) -> Option<&TomlProfiles> {
-        self.resolved_toml.profile.as_ref()
+        self.normalized_toml.profile.as_ref()
     }
     pub fn publish(&self) -> &Option<Vec<String>> {
         &self.publish
@@ -664,7 +664,7 @@ impl VirtualManifest {
         contents: Rc<String>,
         document: Rc<toml_edit::ImDocument<String>>,
         original_toml: Rc<TomlManifest>,
-        resolved_toml: Rc<TomlManifest>,
+        normalized_toml: Rc<TomlManifest>,
         replace: Vec<(PackageIdSpec, Dependency)>,
         patch: HashMap<Url, Vec<Dependency>>,
         workspace: WorkspaceConfig,
@@ -675,7 +675,7 @@ impl VirtualManifest {
             contents,
             document,
             original_toml,
-            resolved_toml,
+            normalized_toml,
             replace,
             patch,
             workspace,
@@ -698,8 +698,8 @@ impl VirtualManifest {
         &self.original_toml
     }
     /// The [`TomlManifest`] with all fields expanded
-    pub fn resolved_toml(&self) -> &TomlManifest {
-        &self.resolved_toml
+    pub fn normalized_toml(&self) -> &TomlManifest {
+        &self.normalized_toml
     }
 
     pub fn replace(&self) -> &[(PackageIdSpec, Dependency)] {
@@ -715,7 +715,7 @@ impl VirtualManifest {
     }
 
     pub fn profiles(&self) -> Option<&TomlProfiles> {
-        self.resolved_toml.profile.as_ref()
+        self.normalized_toml.profile.as_ref()
     }
 
     pub fn warnings_mut(&mut self) -> &mut Warnings {
diff --git a/src/cargo/core/workspace.rs b/src/cargo/core/workspace.rs
@@ -1066,7 +1066,7 @@ impl<'gctx> Workspace<'gctx> {
                     );
                     self.gctx.shell().warn(&msg)
                 };
-                if manifest.resolved_toml().has_profiles() {
+                if manifest.normalized_toml().has_profiles() {
                     emit_warning("profiles")?;
                 }
                 if !manifest.replace().is_empty() {
@@ -1191,7 +1191,7 @@ impl<'gctx> Workspace<'gctx> {
         let mut error_count = 0;
         let toml_lints = pkg
             .manifest()
-            .resolved_toml()
+            .normalized_toml()
             .lints
             .clone()
             .map(|lints| lints.lints)
diff --git a/src/cargo/ops/cargo_package.rs b/src/cargo/ops/cargo_package.rs
@@ -924,7 +924,7 @@ fn tar(
             }
             FileContents::Generated(generated_kind) => {
                 let contents = match generated_kind {
-                    GeneratedFile::Manifest => publish_pkg.manifest().to_resolved_contents()?,
+                    GeneratedFile::Manifest => publish_pkg.manifest().to_normalized_contents()?,
                     GeneratedFile::Lockfile => build_lock(ws, &publish_pkg, local_reg)?,
                     GeneratedFile::VcsInfo(ref s) => serde_json::to_string_pretty(s)?,
                 };
diff --git a/src/cargo/ops/fix.rs b/src/cargo/ops/fix.rs
@@ -443,7 +443,7 @@ fn add_feature_for_unused_deps(
     let manifest = pkg.manifest();
 
     let activated_opt_deps = manifest
-        .resolved_toml()
+        .normalized_toml()
         .features()
         .map(|map| {
             map.values()
@@ -479,7 +479,7 @@ fn add_feature_for_unused_deps(
                 // only way to guarantee an optional dependency is available for use.
                 //
                 // The way we avoid implicitly creating features in Edition2024 is we remove the
-                // dependency from `resolved_toml` if there is no `dep:` syntax as that is the only
+                // dependency from `normalized_toml` if there is no `dep:` syntax as that is the only
                 // syntax that suppresses the creation of the implicit feature.
                 for (feature_name, activations) in features.iter_mut() {
                     let Some(activations) = activations.as_array_mut() else {
diff --git a/src/cargo/ops/registry/publish.rs b/src/cargo/ops/registry/publish.rs
@@ -411,7 +411,7 @@ pub(crate) fn prepare_transmit(
         }
     }
 
-    let string_features = match manifest.resolved_toml().features() {
+    let string_features = match manifest.normalized_toml().features() {
         Some(features) => features
             .iter()
             .map(|(feat, values)| {
diff --git a/src/cargo/ops/vendor.rs b/src/cargo/ops/vendor.rs
@@ -360,7 +360,7 @@ fn cp_sources(
         let cksum = if dst.file_name() == Some(OsStr::new("Cargo.toml"))
             && pkg.package_id().source_id().is_git()
         {
-            let contents = pkg.manifest().to_resolved_contents()?;
+            let contents = pkg.manifest().to_normalized_contents()?;
             copy_and_checksum(
                 &dst,
                 &mut dst_opts,
diff --git a/src/cargo/sources/path.rs b/src/cargo/sources/path.rs
@@ -880,14 +880,14 @@ fn read_packages(
 
 fn nested_paths(manifest: &Manifest) -> Vec<PathBuf> {
     let mut nested_paths = Vec::new();
-    let resolved = manifest.resolved_toml();
-    let dependencies = resolved
+    let normalized = manifest.normalized_toml();
+    let dependencies = normalized
         .dependencies
         .iter()
-        .chain(resolved.build_dependencies())
-        .chain(resolved.dev_dependencies())
+        .chain(normalized.build_dependencies())
+        .chain(normalized.dev_dependencies())
         .chain(
-            resolved
+            normalized
                 .target
                 .as_ref()
                 .into_iter()
diff --git a/src/cargo/util/lints.rs b/src/cargo/util/lints.rs
diff --git a/src/cargo/util/toml/mod.rs b/src/cargo/util/toml/mod.rs
diff --git a/src/cargo/util/toml/targets.rs b/src/cargo/util/toml/targets.rs

Original file line number	Diff line number	Diff line change
`@@ -106,8 +106,8 @@ impl TomlManifest {`
`106`	`106`	`self.features.as_ref()`
`107`	`107`	`}`
`108`	`108`
`109`		`- pub fn resolved_lints(&self) -> Result<Option<&TomlLints>, UnresolvedError> {`
`110`		`- self.lints.as_ref().map(\|l\| l.resolved()).transpose()`
	`109`	`+ pub fn normalized_lints(&self) -> Result<Option<&TomlLints>, UnresolvedError> {`
	`110`	`+ self.lints.as_ref().map(\|l\| l.normalized()).transpose()`
`111`	`111`	`}`
`112`	`112`	`}`
`113`	`113`
`@@ -237,23 +237,26 @@ impl TomlPackage {`
`237`	`237`	`}`
`238`	`238`	`}`
`239`	`239`
`240`		`- pub fn resolved_edition(&self) -> Result<Option<&String>, UnresolvedError> {`
`241`		`- self.edition.as_ref().map(\|v\| v.resolved()).transpose()`
	`240`	`+ pub fn normalized_edition(&self) -> Result<Option<&String>, UnresolvedError> {`
	`241`	`+ self.edition.as_ref().map(\|v\| v.normalized()).transpose()`
`242`	`242`	`}`
`243`	`243`
`244`		`- pub fn resolved_rust_version(&self) -> Result<Option<&RustVersion>, UnresolvedError> {`
`245`		`- self.rust_version.as_ref().map(\|v\| v.resolved()).transpose()`
	`244`	`+ pub fn normalized_rust_version(&self) -> Result<Option<&RustVersion>, UnresolvedError> {`
	`245`	`+ self.rust_version`
	`246`	`+ .as_ref()`
	`247`	`+ .map(\|v\| v.normalized())`
	`248`	`+ .transpose()`
`246`	`249`	`}`
`247`	`250`
`248`		`- pub fn resolved_version(&self) -> Result<Option<&semver::Version>, UnresolvedError> {`
`249`		`- self.version.as_ref().map(\|v\| v.resolved()).transpose()`
	`251`	`+ pub fn normalized_version(&self) -> Result<Option<&semver::Version>, UnresolvedError> {`
	`252`	`+ self.version.as_ref().map(\|v\| v.normalized()).transpose()`
`250`	`253`	`}`
`251`	`254`
`252`		`- pub fn resolved_authors(&self) -> Result<Option<&Vec<String>>, UnresolvedError> {`
`253`		`- self.authors.as_ref().map(\|v\| v.resolved()).transpose()`
	`255`	`+ pub fn normalized_authors(&self) -> Result<Option<&Vec<String>>, UnresolvedError> {`
	`256`	`+ self.authors.as_ref().map(\|v\| v.normalized()).transpose()`
`254`	`257`	`}`
`255`	`258`
`256`		`- pub fn resolved_build(&self) -> Result<Option<&String>, UnresolvedError> {`
	`259`	`+ pub fn normalized_build(&self) -> Result<Option<&String>, UnresolvedError> {`
`257`	`260`	`let readme = self.build.as_ref().ok_or(UnresolvedError)?;`
`258`	`261`	`match readme {`
`259`	`262`	`StringOrBool::Bool(false) => Ok(None),`
`@@ -262,60 +265,66 @@ impl TomlPackage {`
`262`	`265`	`}`
`263`	`266`	`}`
`264`	`267`
`265`		`- pub fn resolved_exclude(&self) -> Result<Option<&Vec<String>>, UnresolvedError> {`
`266`		`- self.exclude.as_ref().map(\|v\| v.resolved()).transpose()`
	`268`	`+ pub fn normalized_exclude(&self) -> Result<Option<&Vec<String>>, UnresolvedError> {`
	`269`	`+ self.exclude.as_ref().map(\|v\| v.normalized()).transpose()`
`267`	`270`	`}`
`268`	`271`
`269`		`- pub fn resolved_include(&self) -> Result<Option<&Vec<String>>, UnresolvedError> {`
`270`		`- self.include.as_ref().map(\|v\| v.resolved()).transpose()`
	`272`	`+ pub fn normalized_include(&self) -> Result<Option<&Vec<String>>, UnresolvedError> {`
	`273`	`+ self.include.as_ref().map(\|v\| v.normalized()).transpose()`
`271`	`274`	`}`
`272`	`275`
`273`		`- pub fn resolved_publish(&self) -> Result<Option<&VecStringOrBool>, UnresolvedError> {`
`274`		`- self.publish.as_ref().map(\|v\| v.resolved()).transpose()`
	`276`	`+ pub fn normalized_publish(&self) -> Result<Option<&VecStringOrBool>, UnresolvedError> {`
	`277`	`+ self.publish.as_ref().map(\|v\| v.normalized()).transpose()`
`275`	`278`	`}`
`276`	`279`
`277`		`- pub fn resolved_description(&self) -> Result<Option<&String>, UnresolvedError> {`
`278`		`- self.description.as_ref().map(\|v\| v.resolved()).transpose()`
	`280`	`+ pub fn normalized_description(&self) -> Result<Option<&String>, UnresolvedError> {`
	`281`	`+ self.description`
	`282`	`+ .as_ref()`
	`283`	`+ .map(\|v\| v.normalized())`
	`284`	`+ .transpose()`
`279`	`285`	`}`
`280`	`286`
`281`		`- pub fn resolved_homepage(&self) -> Result<Option<&String>, UnresolvedError> {`
`282`		`- self.homepage.as_ref().map(\|v\| v.resolved()).transpose()`
	`287`	`+ pub fn normalized_homepage(&self) -> Result<Option<&String>, UnresolvedError> {`
	`288`	`+ self.homepage.as_ref().map(\|v\| v.normalized()).transpose()`
`283`	`289`	`}`
`284`	`290`
`285`		`- pub fn resolved_documentation(&self) -> Result<Option<&String>, UnresolvedError> {`
	`291`	`+ pub fn normalized_documentation(&self) -> Result<Option<&String>, UnresolvedError> {`
`286`	`292`	`self.documentation`
`287`	`293`	`.as_ref()`
`288`		`- .map(\|v\| v.resolved())`
	`294`	`+ .map(\|v\| v.normalized())`
`289`	`295`	`.transpose()`
`290`	`296`	`}`
`291`	`297`
`292`		`- pub fn resolved_readme(&self) -> Result<Option<&String>, UnresolvedError> {`
	`298`	`+ pub fn normalized_readme(&self) -> Result<Option<&String>, UnresolvedError> {`
`293`	`299`	`let readme = self.readme.as_ref().ok_or(UnresolvedError)?;`
`294`		`- readme.resolved().and_then(\|sb\| match sb {`
	`300`	`+ readme.normalized().and_then(\|sb\| match sb {`
`295`	`301`	`StringOrBool::Bool(false) => Ok(None),`
`296`	`302`	`StringOrBool::Bool(true) => Err(UnresolvedError),`
`297`	`303`	`StringOrBool::String(value) => Ok(Some(value)),`
`298`	`304`	`})`
`299`	`305`	`}`
`300`	`306`
`301`		`- pub fn resolved_keywords(&self) -> Result<Option<&Vec<String>>, UnresolvedError> {`
`302`		`- self.keywords.as_ref().map(\|v\| v.resolved()).transpose()`
	`307`	`+ pub fn normalized_keywords(&self) -> Result<Option<&Vec<String>>, UnresolvedError> {`
	`308`	`+ self.keywords.as_ref().map(\|v\| v.normalized()).transpose()`
`303`	`309`	`}`
`304`	`310`
`305`		`- pub fn resolved_categories(&self) -> Result<Option<&Vec<String>>, UnresolvedError> {`
`306`		`- self.categories.as_ref().map(\|v\| v.resolved()).transpose()`
	`311`	`+ pub fn normalized_categories(&self) -> Result<Option<&Vec<String>>, UnresolvedError> {`
	`312`	`+ self.categories.as_ref().map(\|v\| v.normalized()).transpose()`
`307`	`313`	`}`
`308`	`314`
`309`		`- pub fn resolved_license(&self) -> Result<Option<&String>, UnresolvedError> {`
`310`		`- self.license.as_ref().map(\|v\| v.resolved()).transpose()`
	`315`	`+ pub fn normalized_license(&self) -> Result<Option<&String>, UnresolvedError> {`
	`316`	`+ self.license.as_ref().map(\|v\| v.normalized()).transpose()`
`311`	`317`	`}`
`312`	`318`
`313`		`- pub fn resolved_license_file(&self) -> Result<Option<&String>, UnresolvedError> {`
`314`		`- self.license_file.as_ref().map(\|v\| v.resolved()).transpose()`
	`319`	`+ pub fn normalized_license_file(&self) -> Result<Option<&String>, UnresolvedError> {`
	`320`	`+ self.license_file`
	`321`	`+ .as_ref()`
	`322`	`+ .map(\|v\| v.normalized())`
	`323`	`+ .transpose()`
`315`	`324`	`}`
`316`	`325`
`317`		`- pub fn resolved_repository(&self) -> Result<Option<&String>, UnresolvedError> {`
`318`		`- self.repository.as_ref().map(\|v\| v.resolved()).transpose()`
	`326`	`+ pub fn normalized_repository(&self) -> Result<Option<&String>, UnresolvedError> {`
	`327`	`+ self.repository.as_ref().map(\|v\| v.normalized()).transpose()`
`319`	`328`	`}`
`320`	`329`	`}`
`321`	`330`
`@@ -330,7 +339,7 @@ pub enum InheritableField<T> {`
`330`	`339`	`}`
`331`	`340`
`332`	`341`	`impl<T> InheritableField<T> {`
`333`		`- pub fn resolved(&self) -> Result<&T, UnresolvedError> {`
	`342`	`+ pub fn normalized(&self) -> Result<&T, UnresolvedError> {`
`334`	`343`	`self.as_value().ok_or(UnresolvedError)`
`335`	`344`	`}`
`336`	`345`
`@@ -634,7 +643,7 @@ impl InheritableDependency {`
`634`	`643`	`}`
`635`	`644`	`}`
`636`	`645`
`637`		`- pub fn resolved(&self) -> Result<&TomlDependency, UnresolvedError> {`
	`646`	`+ pub fn normalized(&self) -> Result<&TomlDependency, UnresolvedError> {`
`638`	`647`	`match self {`
`639`	`648`	`InheritableDependency::Value(d) => Ok(d),`
`640`	`649`	`InheritableDependency::Inherit(_) => Err(UnresolvedError),`
`@@ -1440,7 +1449,7 @@ pub struct InheritableLints {`
`1440`	`1449`	`}`
`1441`	`1450`
`1442`	`1451`	`impl InheritableLints {`
`1443`		`- pub fn resolved(&self) -> Result<&TomlLints, UnresolvedError> {`
	`1452`	`+ pub fn normalized(&self) -> Result<&TomlLints, UnresolvedError> {`
`1444`	`1453`	`if self.workspace {`
`1445`	`1454`	`Err(UnresolvedError)`
`1446`	`1455`	`} else {`
Original file line number	Diff line number	Diff line change
`@@ -924,7 +924,7 @@ fn tar(`
`924`	`924`	`}`
`925`	`925`	`FileContents::Generated(generated_kind) => {`
`926`	`926`	`let contents = match generated_kind {`
`927`		`- GeneratedFile::Manifest => publish_pkg.manifest().to_resolved_contents()?,`
	`927`	`+ GeneratedFile::Manifest => publish_pkg.manifest().to_normalized_contents()?,`
`928`	`928`	`GeneratedFile::Lockfile => build_lock(ws, &publish_pkg, local_reg)?,`
`929`	`929`	`GeneratedFile::VcsInfo(ref s) => serde_json::to_string_pretty(s)?,`
`930`	`930`	`};`
Original file line number	Diff line number	Diff line change
`@@ -411,7 +411,7 @@ pub(crate) fn prepare_transmit(`
`411`	`411`	`}`
`412`	`412`	`}`
`413`	`413`
`414`		`- let string_features = match manifest.resolved_toml().features() {`
	`414`	`+ let string_features = match manifest.normalized_toml().features() {`
`415`	`415`	`Some(features) => features`
`416`	`416`	`.iter()`
`417`	`417`	`.map(\|(feat, values)\| {`
Original file line number	Diff line number	Diff line change
`@@ -360,7 +360,7 @@ fn cp_sources(`
`360`	`360`	`let cksum = if dst.file_name() == Some(OsStr::new("Cargo.toml"))`
`361`	`361`	`&& pkg.package_id().source_id().is_git()`
`362`	`362`	`{`
`363`		`- let contents = pkg.manifest().to_resolved_contents()?;`
	`363`	`+ let contents = pkg.manifest().to_normalized_contents()?;`
`364`	`364`	`copy_and_checksum(`
`365`	`365`	`&dst,`
`366`	`366`	`&mut dst_opts,`