Add sync-lockfile command

Author: chaaz

src/bin/cargo/commands/mod.rs

@@ -8,6 +8,7 @@ pub fn builtin() -> Vec<App> {
         clean::cli(),
         doc::cli(),
         fetch::cli(),
+        sync_lockfile::cli(),
         fix::cli(),
         generate_lockfile::cli(),
         git_checkout::cli(),
@@ -45,6 +46,7 @@ pub fn builtin_exec(cmd: &str) -> Option<fn(&mut Config, &ArgMatches<'_>) -> Cli
         "clean" => clean::exec,
         "doc" => doc::exec,
         "fetch" => fetch::exec,
+        "sync-lockfile" => sync_lockfile::exec,
         "fix" => fix::exec,
         "generate-lockfile" => generate_lockfile::exec,
         "git-checkout" => git_checkout::exec,
@@ -82,6 +84,7 @@ pub mod check;
 pub mod clean;
 pub mod doc;
 pub mod fetch;
+pub mod sync_lockfile;
 pub mod fix;
 pub mod generate_lockfile;
 pub mod git_checkout;

src/bin/cargo/commands/sync_lockfile.rs

@@ -0,0 +1,24 @@
+use crate::command_prelude::*;
+
+use cargo::ops;
+use cargo::ops::SyncLockfileOptions;
+
+pub fn cli() -> App {
+    subcommand("sync-lockfile")
+        .about("Synchronize the lockfile to the package")
+        .arg(opt("quiet", "No output printed to stdout").short("q"))
+        .arg_manifest_path()
+        .arg_target_triple("Sync the lockfile for the target triple")
+        .after_help("Run `cargo help sync-lockfile` for more detailed information.\n")
+}
+
+pub fn exec(config: &mut Config, args: &ArgMatches<'_>) -> CliResult {
+    let ws = args.workspace(config)?;
+
+    let opts = SyncLockfileOptions {
+        config,
+        targets: args.targets(),
+    };
+    let _ = ops::sync_lockfile(&ws, &opts)?;
+    Ok(())
+}

src/cargo/ops/cargo_sync_lockfile.rs

@@ -0,0 +1,20 @@
+use crate::core::{PackageSet, Resolve, Workspace};
+use crate::ops;
+use crate::util::CargoResult;
+use crate::util::Config;
+
+pub struct SyncLockfileOptions<'a> {
+    pub config: &'a Config,
+    /// The target arch triple to sync lockfile dependencies for
+    pub targets: Vec<String>,
+}
+
+/// Executes `cargo sync_lockfile`.
+pub fn sync_lockfile<'a>(
+    ws: &Workspace<'a>,
+    _options: &SyncLockfileOptions<'a>,
+) -> CargoResult<(Resolve, PackageSet<'a>)> {
+    ws.emit_warnings()?;
+    let (packages, resolve) = ops::resolve_ws(ws)?;
+    Ok((resolve, packages))
+}

src/cargo/ops/mod.rs

@@ -5,6 +5,7 @@ pub use self::cargo_compile::{
 pub use self::cargo_compile::{CompileFilter, FilterRule, LibRule, Packages};
 pub use self::cargo_doc::{doc, DocOptions};
 pub use self::cargo_fetch::{fetch, FetchOptions};
+pub use self::cargo_sync_lockfile::{sync_lockfile, SyncLockfileOptions};
 pub use self::cargo_generate_lockfile::generate_lockfile;
 pub use self::cargo_generate_lockfile::update_lockfile;
 pub use self::cargo_generate_lockfile::UpdateOptions;
@@ -33,6 +34,7 @@ mod cargo_clean;
 mod cargo_compile;
 mod cargo_doc;
 mod cargo_fetch;
+mod cargo_sync_lockfile;
 mod cargo_generate_lockfile;
 mod cargo_install;
 mod cargo_new;

tests/testsuite/main.rs

@@ -109,6 +109,7 @@ mod rustflags;
 mod search;
 mod shell_quoting;
 mod standard_lib;
+mod sync_lockfile;
 mod test;
 mod timings;
 mod tool_paths;

tests/testsuite/sync_lockfile.rs

@@ -0,0 +1,135 @@
+//! Tests for the `cargo sync-lockfile` command.
+
+use cargo_test_support::registry::Package;
+use cargo_test_support::rustc_host;
+use cargo_test_support::{basic_manifest, cross_compile, project};
+
+#[cargo_test]
+fn no_deps() {
+    let p = project()
+        .file("src/main.rs", "mod a; fn main() {}")
+        .file("src/a.rs", "")
+        .build();
+
+    p.cargo("sync-lockfile").with_stdout("").run();
+}
+
+#[cargo_test]
+fn sync_all_platform_dependencies_when_no_target_is_given() {
+    if cross_compile::disabled() {
+        return;
+    }
+
+    Package::new("d1", "1.2.3")
+        .file("Cargo.toml", &basic_manifest("d1", "1.2.3"))
+        .file("src/lib.rs", "")
+        .publish();
+
+    Package::new("d2", "0.1.2")
+        .file("Cargo.toml", &basic_manifest("d2", "0.1.2"))
+        .file("src/lib.rs", "")
+        .publish();
+
+    let target = cross_compile::alternate();
+    let host = rustc_host();
+    let p = project()
+        .file(
+            "Cargo.toml",
+            &format!(
+                r#"
+            [package]
+            name = "foo"
+            version = "0.0.1"
+            authors = []
+
+            [target.{host}.dependencies]
+            d1 = "1.2.3"
+
+            [target.{target}.dependencies]
+            d2 = "0.1.2"
+        "#,
+                host = host,
+                target = target
+            ),
+        )
+        .file("src/lib.rs", "")
+        .build();
+
+    p.cargo("sync-lockfile")
+        .with_stderr_contains("[DOWNLOADED] d1 v1.2.3 [..]")
+        .with_stderr_contains("[DOWNLOADED] d2 v0.1.2 [..]")
+        .run();
+}
+
+#[cargo_test]
+fn sync_platform_specific_dependencies() {
+    if cross_compile::disabled() {
+        return;
+    }
+
+    Package::new("d1", "1.2.3")
+        .file("Cargo.toml", &basic_manifest("d1", "1.2.3"))
+        .file("src/lib.rs", "")
+        .publish();
+
+    Package::new("d2", "0.1.2")
+        .file("Cargo.toml", &basic_manifest("d2", "0.1.2"))
+        .file("src/lib.rs", "")
+        .publish();
+
+    let target = cross_compile::alternate();
+    let host = rustc_host();
+    let p = project()
+        .file(
+            "Cargo.toml",
+            &format!(
+                r#"
+            [package]
+            name = "foo"
+            version = "0.0.1"
+            authors = []
+
+            [target.{host}.dependencies]
+            d1 = "1.2.3"
+
+            [target.{target}.dependencies]
+            d2 = "0.1.2"
+        "#,
+                host = host,
+                target = target
+            ),
+        )
+        .file("src/lib.rs", "")
+        .build();
+
+    p.cargo("sync-lockfile --target")
+        .arg(&host)
+        .with_stderr_contains("[DOWNLOADED] d1 v1.2.3 [..]")
+        .with_stderr_does_not_contain("[DOWNLOADED] d2 v0.1.2 [..]")
+        .run();
+
+    p.cargo("sync-lockfile --target")
+        .arg(&target)
+        .with_stderr_contains("[DOWNLOADED] d2 v0.1.2[..]")
+        .with_stderr_does_not_contain("[DOWNLOADED] d1 v1.2.3 [..]")
+        .run();
+}
+
+#[cargo_test]
+fn sync_warning() {
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+            [package]
+            name = "foo"
+            version = "1.0.0"
+            misspelled = "wut"
+            "#,
+        )
+        .file("src/lib.rs", "")
+        .build();
+    p.cargo("sync-lockfile")
+        .with_stderr("[WARNING] unused manifest key: package.misspelled")
+        .run();
+}