Add artifact dependency fields to structures

Author: fee1-dead

Cargo.lock

@@ -34,7 +34,7 @@ bytesize = "1.0"
 cargo-platform = { path = "crates/cargo-platform", version = "0.1.3" }
 cargo-util = { path = "crates/cargo-util", version = "0.2.4" }
 clap = { version = "4.2.0", features = ["wrap_help"] }
-crates-io = { path = "crates/crates-io", version = "0.36.1" }
+crates-io = { path = "crates/crates-io", version = "0.37.0" }
 curl = { version = "0.4.44", features = ["http2"] }
 curl-sys = "0.4.61"
 env_logger = "0.10.0"

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "crates-io"
-version = "0.36.1"
+version = "0.37.0"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/rust-lang/cargo"

crates/crates-io/Cargo.toml

@@ -73,6 +73,12 @@ pub struct NewCrateDependency {
     pub registry: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub explicit_name_in_toml: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub artifact: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub bindep_target: Option<String>,
+    #[serde(default)]
+    pub lib: bool,
 }
 
 #[derive(Deserialize)]

crates/crates-io/lib.rs

@@ -12,7 +12,6 @@ use crate::core::compiler::{CompileKind, CompileTarget};
 use crate::core::{PackageId, SourceId, Summary};
 use crate::util::errors::CargoResult;
 use crate::util::interning::InternedString;
-use crate::util::toml::StringOrVec;
 use crate::util::OptVersionReq;
 
 /// Information about a dependency requested by a Cargo manifest.
@@ -468,25 +467,22 @@ impl ser::Serialize for Artifact {
         SerializedArtifact {
             kinds: self.kinds(),
             lib: self.is_lib,
-            target: self.target.as_ref().map(|t| match t {
-                ArtifactTarget::BuildDependencyAssumeTarget => "target",
-                ArtifactTarget::Force(target) => target.rustc_target().as_str(),
-            }),
+            target: self.target.as_ref().map(ArtifactTarget::as_str),
         }
         .serialize(s)
     }
 }
 
 impl Artifact {
     pub(crate) fn parse(
-        artifacts: &StringOrVec,
+        artifacts: &[impl AsRef<str>],
         is_lib: bool,
         target: Option<&str>,
     ) -> CargoResult<Self> {
         let kinds = ArtifactKind::validate(
             artifacts
                 .iter()
-                .map(|s| ArtifactKind::parse(s))
+                .map(|s| ArtifactKind::parse(s.as_ref()))
                 .collect::<Result<Vec<_>, _>>()?,
         )?;
         Ok(Artifact {
@@ -529,6 +525,13 @@ impl ArtifactTarget {
         })
     }
 
+    pub fn as_str(&self) -> &str {
+        match self {
+            ArtifactTarget::BuildDependencyAssumeTarget => "target",
+            ArtifactTarget::Force(target) => target.rustc_target().as_str(),
+        }
+    }
+
     pub fn to_compile_kind(&self) -> Option<CompileKind> {
         self.to_compile_target().map(CompileKind::Target)
     }
@@ -539,6 +542,7 @@ impl ArtifactTarget {
             ArtifactTarget::Force(target) => Some(*target),
         }
     }
+
     pub(crate) fn to_resolved_compile_kind(
         &self,
         root_unit_compile_kind: CompileKind,
@@ -575,20 +579,13 @@ impl ser::Serialize for ArtifactKind {
     where
         S: ser::Serializer,
     {
-        let out: Cow<'_, str> = match *self {
-            ArtifactKind::SelectedBinary(name) => format!("bin:{}", name.as_str()).into(),
-            _ => self.crate_type().into(),
-        };
-        out.serialize(s)
+        self.as_str().serialize(s)
     }
 }
 
 impl fmt::Display for ArtifactKind {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str(match self {
-            ArtifactKind::SelectedBinary(bin_name) => return write!(f, "bin:{bin_name}"),
-            _ => self.crate_type(),
-        })
+        f.write_str(&self.as_str())
     }
 }
 
@@ -604,7 +601,14 @@ impl ArtifactKind {
         }
     }
 
-    fn parse(kind: &str) -> CargoResult<Self> {
+    pub fn as_str(&self) -> Cow<'static, str> {
+        match *self {
+            ArtifactKind::SelectedBinary(name) => format!("bin:{}", name.as_str()).into(),
+            _ => self.crate_type().into(),
+        }
+    }
+
+    pub fn parse(kind: &str) -> CargoResult<Self> {
         Ok(match kind {
             "bin" => ArtifactKind::AllBinaries,
             "cdylib" => ArtifactKind::Cdylib,

src/cargo/core/dependency.rs

@@ -328,6 +328,17 @@ fn transmit(
                 .to_string(),
                 registry: dep_registry,
                 explicit_name_in_toml: dep.explicit_name_in_toml().map(|s| s.to_string()),
+                artifact: dep.artifact().map(|artifact| {
+                    artifact
+                        .kinds()
+                        .iter()
+                        .map(|x| x.as_str().into_owned())
+                        .collect()
+                }),
+                bindep_target: dep.artifact().and_then(|artifact| {
+                    artifact.target().map(|target| target.as_str().to_owned())
+                }),
+                lib: dep.artifact().map_or(false, |artifact| artifact.is_lib()),
             })
         })
         .collect::<CargoResult<Vec<NewCrateDependency>>>()?;

src/cargo/ops/registry.rs

@@ -174,7 +174,7 @@ use semver::Version;
 use serde::Deserialize;
 use tar::Archive;
 
-use crate::core::dependency::{DepKind, Dependency};
+use crate::core::dependency::{Artifact, DepKind, Dependency};
 use crate::core::source::MaybePackage;
 use crate::core::{Package, PackageId, QueryKind, Source, SourceId, Summary};
 use crate::sources::PathSource;
@@ -363,6 +363,9 @@ struct RegistryDependency<'a> {
     registry: Option<Cow<'a, str>>,
     package: Option<InternedString>,
     public: Option<bool>,
+    artifact: Option<Vec<Cow<'a, str>>>,
+    bindep_target: Option<Cow<'a, str>>,
+    lib: bool,
 }
 
 impl<'a> RegistryDependency<'a> {
@@ -379,6 +382,9 @@ impl<'a> RegistryDependency<'a> {
             registry,
             package,
             public,
+            artifact,
+            bindep_target,
+            lib,
         } = self;
 
         let id = if let Some(registry) = &registry {
@@ -418,6 +424,11 @@ impl<'a> RegistryDependency<'a> {
             dep.set_registry_id(id);
         }
 
+        if let Some(artifacts) = artifact {
+            let artifact = Artifact::parse(&artifacts, lib, bindep_target.as_deref())?;
+            dep.set_artifact(artifact);
+        }
+
         dep.set_optional(optional)
             .set_default_features(default_features)
             .set_features(features)

src/cargo/sources/registry/mod.rs

@@ -3206,7 +3206,7 @@ impl<P: ResolveToPath + Clone> DetailedTomlDependency<P> {
             self.target.as_deref(),
         ) {
             if cx.config.cli_unstable().bindeps {
-                let artifact = Artifact::parse(artifact, is_lib, target)?;
+                let artifact = Artifact::parse(&artifact.0, is_lib, target)?;
                 if dep.kind() != DepKind::Build
                     && artifact.target() == Some(ArtifactTarget::BuildDependencyAssumeTarget)
                 {