Remove requirement for --target when invoking Cargo with -Zbuild-std

src/cargo/core/compiler/build_config.rs

@@ -99,11 +99,6 @@ impl BuildConfig {
             },
         };
 
-        if gctx.cli_unstable().build_std.is_some() && requested_kinds[0].is_host() {
-            // TODO: This should eventually be fixed.
-            anyhow::bail!("-Zbuild-std requires --target");
-        }
-
         Ok(BuildConfig {
             requested_kinds,
             jobs,

src/doc/src/reference/unstable.md

@@ -434,10 +434,6 @@ component:
 $ rustup component add rust-src --toolchain nightly
 ```
 
-It is also required today that the `-Z build-std` flag is combined with the
-`--target` flag. Note that you're not forced to do a cross compilation, you're
-just forced to pass `--target` in one form or another.
-
 Usage looks like:
 
 ```console
@@ -471,7 +467,6 @@ The value here is a comma-separated list of standard library crates to build.
 As a summary, a list of requirements today to use `-Z build-std` are:
 
 * You must install libstd's source code through `rustup component add rust-src`
-* You must pass `--target`
 * You must use both a nightly Cargo and a nightly rustc
 * The `-Z build-std` flag must be passed to all `cargo` invocations.
 

tests/build-std/main.rs

@@ -154,6 +154,66 @@ fn basic() {
     assert_eq!(p.glob(deps_dir.join("*.dylib")).count(), 0);
 }
 
+#[cargo_test(build_std_real)]
+fn host_proc_macro() {
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+                [package]
+                name = "foo"
+                version = "0.1.0"
+                edition = "2021"
+
+                [dependencies]
+                macro_test = { path = "macro_test" }
+            "#,
+        )
+        .file(
+            "src/main.rs",
+            r#"
+            extern crate macro_test;
+            use macro_test::make_answer;
+
+            make_answer!();
+
+            fn main() {
+                println!("Hello, World: {}", answer());
+            }
+            "#,
+        )
+        .file(
+            "macro_test/Cargo.toml",
+            r#"
+            [package]
+            name = "macro_test"
+            version = "0.1.0"
+            edition = "2021"
+
+            [lib]
+            proc-macro = true
+            "#,
+        )
+        .file(
+            "macro_test/src/lib.rs",
+            r#"
+            extern crate proc_macro;
+            use proc_macro::TokenStream;
+
+            #[proc_macro]
+            pub fn make_answer(_item: TokenStream) -> TokenStream {
+                "fn answer() -> u32 { 42 }".parse().unwrap()
+            }
+            "#,
+        )
+        .build();
+
+    p.cargo("build")
+        .build_std_arg("std")
+        .build_std_arg("proc_macro")
+        .run();
+}
+
 #[cargo_test(build_std_real)]
 fn cross_custom() {
     let p = project()

tests/testsuite/mock-std/dep_test/Cargo.toml

@@ -0,0 +1,4 @@
+[package]
+name = "dep_test"
+version = "0.1.0"
+edition = "2021"

tests/testsuite/mock-std/dep_test/src/lib.rs

@@ -0,0 +1 @@
+

tests/testsuite/mock-std/library/std/Cargo.toml

@@ -6,6 +6,7 @@ edition = "2018"
 
 [dependencies]
 registry-dep-using-alloc = { version = "*", features = ['mockbuild'] }
+dep_test = { path = "../../dep_test" }
 
 [features]
 feature1 = []

tests/testsuite/standard_lib.rs

@@ -246,6 +246,73 @@ fn basic() {
     p.cargo("test").build_std(&setup).target_host().run();
 }
 
+#[cargo_test(build_std_mock)]
+fn shared_std_dependency_rebuild() {
+    let manifest_dir = std::env::var("CARGO_MANIFEST_DIR").unwrap();
+    let setup = setup();
+    let p = project()
+        .file(
+            "Cargo.toml",
+            format!(
+                "
+                [package]
+                name = \"foo\"
+                version = \"0.1.0\"
+                edition = \"2021\"
+
+                [build-dependencies]
+                dep_test = {{ path = \"{}/tests/testsuite/mock-std/dep_test\" }}
+            ",
+                manifest_dir
+            )
+            .as_str(),
+        )
+        .file(
+            "src/main.rs",
+            r#"
+            fn main() {
+                println!("Hello, World!");
+            }
+            "#,
+        )
+        .file(
+            "build.rs",
+            r#"
+            fn main() {
+                println!("cargo::rerun-if-changed=build.rs");
+            }
+            "#,
+        )
+        .build();
+
+    p.cargo("build -v")
+        .build_std(&setup)
+        .target_host()
+        .with_stderr_data(str![[r#"
+...
+[RUNNING] `[..] rustc --crate-name dep_test [..]`
+...
+[RUNNING] `[..] rustc --crate-name dep_test [..]`
+...
+"#]])
+        .run();
+
+    // TODO: Because of the way in which std is resolved, it's mandatory that this is left commented
+    // out as it will fail. This case should result in `dep_test` only being built once, however
+    // it's still being built twice. This is a bug.
+    //
+    //    p.cargo("build -v")
+    //        .build_std(&setup)
+    //        .with_stderr_does_not_contain(str![[r#"
+    //...
+    //[RUNNING] `[..] rustc --crate-name dep_test [..]`
+    //...
+    //[RUNNING] `[..] rustc --crate-name dep_test [..]`
+    //...
+    //"#]])
+    //        .run();
+}
+
 #[cargo_test(build_std_mock)]
 fn simple_lib_std() {
     let setup = setup();