refactor(toml): Move underscore validation to resolving

Author: epage

src/cargo/util/toml/mod.rs

@@ -306,6 +306,8 @@ fn resolve_toml(
     };
 
     if let Some(original_package) = original_toml.package() {
+        let package_name = &original_package.name;
+
         let resolved_package =
             resolve_package_toml(original_package, features, package_root, &inherit)?;
         let edition = resolved_package
@@ -341,6 +343,14 @@ fn resolve_toml(
             package_root,
             warnings,
         )?;
+        deprecated_underscore(
+            &original_toml.dev_dependencies2,
+            &original_toml.dev_dependencies,
+            "dev-dependencies",
+            package_name,
+            "package",
+            warnings,
+        );
         resolved_toml.dev_dependencies = resolve_dependencies(
             gctx,
             edition,
@@ -352,6 +362,14 @@ fn resolve_toml(
             package_root,
             warnings,
         )?;
+        deprecated_underscore(
+            &original_toml.build_dependencies2,
+            &original_toml.build_dependencies,
+            "build-dependencies",
+            package_name,
+            "package",
+            warnings,
+        );
         resolved_toml.build_dependencies = resolve_dependencies(
             gctx,
             edition,
@@ -376,6 +394,14 @@ fn resolve_toml(
                 package_root,
                 warnings,
             )?;
+            deprecated_underscore(
+                &platform.dev_dependencies2,
+                &platform.dev_dependencies,
+                "dev-dependencies",
+                name,
+                "platform target",
+                warnings,
+            );
             let resolved_dev_dependencies = resolve_dependencies(
                 gctx,
                 edition,
@@ -387,6 +413,14 @@ fn resolve_toml(
                 package_root,
                 warnings,
             )?;
+            deprecated_underscore(
+                &platform.build_dependencies2,
+                &platform.build_dependencies,
+                "build-dependencies",
+                name,
+                "platform target",
+                warnings,
+            );
             let resolved_build_dependencies = resolve_dependencies(
                 gctx,
                 edition,
@@ -617,6 +651,14 @@ fn resolve_dependencies<'a>(
         let mut resolved =
             dependency_inherit_with(v.clone(), name_in_toml, inherit, package_root, warnings)?;
         if let manifest::TomlDependency::Detailed(ref mut d) = resolved {
+            deprecated_underscore(
+                &d.default_features2,
+                &d.default_features,
+                "default-features",
+                name_in_toml,
+                "dependency",
+                warnings,
+            );
             if d.public.is_some() {
                 let public_feature = features.require(Feature::public_dependency());
                 let with_public_feature = public_feature.is_ok();
@@ -1146,28 +1188,12 @@ fn to_real_manifest(
     }
 
     validate_dependencies(original_toml.dependencies.as_ref(), None, None, warnings)?;
-    deprecated_underscore(
-        &original_toml.dev_dependencies2,
-        &original_toml.dev_dependencies,
-        "dev-dependencies",
-        package_name,
-        "package",
-        warnings,
-    );
     validate_dependencies(
         original_toml.dev_dependencies(),
         None,
         Some(DepKind::Development),
         warnings,
     )?;
-    deprecated_underscore(
-        &original_toml.build_dependencies2,
-        &original_toml.build_dependencies,
-        "build-dependencies",
-        package_name,
-        "package",
-        warnings,
-    );
     validate_dependencies(
         original_toml.build_dependencies(),
         None,
@@ -1184,28 +1210,12 @@ fn to_real_manifest(
             None,
             warnings,
         )?;
-        deprecated_underscore(
-            &platform.build_dependencies2,
-            &platform.build_dependencies,
-            "build-dependencies",
-            name,
-            "platform target",
-            warnings,
-        );
         validate_dependencies(
             platform.build_dependencies(),
             platform_kind.as_ref(),
             Some(DepKind::Build),
             warnings,
         )?;
-        deprecated_underscore(
-            &platform.dev_dependencies2,
-            &platform.dev_dependencies,
-            "dev-dependencies",
-            name,
-            "platform target",
-            warnings,
-        );
         validate_dependencies(
             platform.dev_dependencies(),
             platform_kind.as_ref(),
@@ -1811,14 +1821,6 @@ fn detailed_dep_to_dependency<P: ResolveToPath + Clone>(
 
     let version = orig.version.as_deref();
     let mut dep = Dependency::parse(pkg_name, version, new_source_id)?;
-    deprecated_underscore(
-        &orig.default_features2,
-        &orig.default_features,
-        "default-features",
-        name_in_toml,
-        "dependency",
-        manifest_ctx.warnings,
-    );
     dep.set_features(orig.features.iter().flatten())
         .set_default_features(orig.default_features().unwrap_or(true))
         .set_optional(orig.optional.unwrap_or(false))

src/cargo/util/toml/targets.rs

@@ -97,12 +97,7 @@ pub(super) fn to_targets(
         warnings,
         errors,
     )?;
-    targets.extend(to_example_targets(
-        &toml_examples,
-        package_root,
-        edition,
-        warnings,
-    )?);
+    targets.extend(to_example_targets(&toml_examples, package_root, edition)?);
 
     let toml_tests = resolve_tests(
         resolved_toml.test.as_ref(),
@@ -183,6 +178,10 @@ fn resolve_lib(
     // Check early to improve error messages
     validate_lib_name(&lib, warnings)?;
 
+    // Checking the original lib
+    validate_proc_macro(&lib, "library", warnings);
+    validate_crate_types(&lib, "library", warnings);
+
     if lib.path.is_none() {
         if let Some(inferred) = inferred {
             lib.path = Some(PathValue(inferred));
@@ -218,8 +217,6 @@ fn to_lib_target(
     let Some(lib) = resolved_lib else {
         return Ok(None);
     };
-    validate_proc_macro(lib, "library", warnings);
-    validate_crate_types(lib, "library", warnings);
 
     let path = lib.path.as_ref().expect("previously resolved");
     let path = package_root.join(&path.0);
@@ -442,14 +439,12 @@ fn to_example_targets(
     targets: &[TomlExampleTarget],
     package_root: &Path,
     edition: Edition,
-    warnings: &mut Vec<String>,
 ) -> CargoResult<Vec<Target>> {
     validate_unique_names(&targets, "example")?;
 
     let mut result = Vec::new();
     for toml in targets {
         let path = package_root.join(&toml.path.as_ref().expect("previously resolved").0);
-        validate_crate_types(&toml, "example", warnings);
         let crate_types = match toml.crate_types() {
             Some(kinds) => kinds.iter().map(|s| s.into()).collect(),
             None => Vec::new(),
@@ -637,6 +632,8 @@ fn resolve_targets_with_legacy_path(
 
     for target in &toml_targets {
         validate_target_name(target, target_kind_human, target_kind, warnings)?;
+        validate_proc_macro(target, target_kind_human, warnings);
+        validate_crate_types(target, target_kind_human, warnings);
     }
 
     let mut result = Vec::new();