mirror of
https://github.com/rust-lang/cargo.git
synced 2025-09-25 11:14:46 +00:00
1793 lines
45 KiB
Rust
1793 lines
45 KiB
Rust
//! Tests for setting custom rustc flags.
|
|
|
|
use std::fs;
|
|
|
|
use crate::prelude::*;
|
|
use cargo_test_support::registry::Package;
|
|
use cargo_test_support::{
|
|
RawOutput, basic_manifest, paths, project, project_in_home, rustc_host, str,
|
|
};
|
|
use snapbox::assert_data_eq;
|
|
|
|
#[cargo_test]
|
|
fn env_rustflags_normal_source() {
|
|
let p = project()
|
|
.file("src/lib.rs", "")
|
|
.file("src/bin/a.rs", "fn main() {}")
|
|
.file("examples/b.rs", "fn main() {}")
|
|
.file("tests/c.rs", "#[test] fn f() { }")
|
|
.file(
|
|
"benches/d.rs",
|
|
r#"
|
|
#![feature(test)]
|
|
extern crate test;
|
|
#[bench] fn run1(_ben: &mut test::Bencher) { }
|
|
"#,
|
|
)
|
|
.build();
|
|
|
|
// Use RUSTFLAGS to pass an argument that will generate an error
|
|
p.cargo("check --lib")
|
|
.env("RUSTFLAGS", "-Z bogus")
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
p.cargo("check --bin=a")
|
|
.env("RUSTFLAGS", "-Z bogus")
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
p.cargo("check --example=b")
|
|
.env("RUSTFLAGS", "-Z bogus")
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
p.cargo("test")
|
|
.env("RUSTFLAGS", "-Z bogus")
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
p.cargo("bench")
|
|
.env("RUSTFLAGS", "-Z bogus")
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn env_rustflags_build_script() {
|
|
// RUSTFLAGS should be passed to rustc for build scripts
|
|
// when --target is not specified.
|
|
let p = project()
|
|
.file(
|
|
"Cargo.toml",
|
|
r#"
|
|
[package]
|
|
name = "foo"
|
|
version = "0.0.1"
|
|
build = "build.rs"
|
|
"#,
|
|
)
|
|
.file("src/lib.rs", "")
|
|
.file(
|
|
"build.rs",
|
|
r#"
|
|
fn main() { assert!(cfg!(foo)); }
|
|
"#,
|
|
)
|
|
.build();
|
|
|
|
p.cargo("check").env("RUSTFLAGS", "--cfg foo").run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn env_rustflags_build_script_dep() {
|
|
// RUSTFLAGS should be passed to rustc for build scripts
|
|
// when --target is not specified.
|
|
// In this test if --cfg foo is not passed the build will fail.
|
|
let foo = project()
|
|
.file(
|
|
"Cargo.toml",
|
|
r#"
|
|
[package]
|
|
name = "foo"
|
|
version = "0.0.1"
|
|
build = "build.rs"
|
|
|
|
[build-dependencies.bar]
|
|
path = "../bar"
|
|
"#,
|
|
)
|
|
.file("src/lib.rs", "")
|
|
.file("build.rs", "fn main() {}")
|
|
.build();
|
|
let _bar = project()
|
|
.at("bar")
|
|
.file("Cargo.toml", &basic_manifest("bar", "0.0.1"))
|
|
.file(
|
|
"src/lib.rs",
|
|
r#"
|
|
fn bar() { }
|
|
#[cfg(not(foo))]
|
|
fn bar() { }
|
|
"#,
|
|
)
|
|
.build();
|
|
|
|
foo.cargo("check").env("RUSTFLAGS", "--cfg foo").run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn env_rustflags_normal_source_with_target() {
|
|
let p = project()
|
|
.file("src/lib.rs", "")
|
|
.file("src/bin/a.rs", "fn main() {}")
|
|
.file("examples/b.rs", "fn main() {}")
|
|
.file("tests/c.rs", "#[test] fn f() { }")
|
|
.file(
|
|
"benches/d.rs",
|
|
r#"
|
|
#![feature(test)]
|
|
extern crate test;
|
|
#[bench] fn run1(_ben: &mut test::Bencher) { }
|
|
"#,
|
|
)
|
|
.build();
|
|
|
|
let host = &rustc_host();
|
|
|
|
// Use RUSTFLAGS to pass an argument that will generate an error
|
|
p.cargo("check --lib --target")
|
|
.arg(host)
|
|
.env("RUSTFLAGS", "-Z bogus")
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
p.cargo("check --bin=a --target")
|
|
.arg(host)
|
|
.env("RUSTFLAGS", "-Z bogus")
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
p.cargo("check --example=b --target")
|
|
.arg(host)
|
|
.env("RUSTFLAGS", "-Z bogus")
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
p.cargo("test --target")
|
|
.arg(host)
|
|
.env("RUSTFLAGS", "-Z bogus")
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
p.cargo("bench --target")
|
|
.arg(host)
|
|
.env("RUSTFLAGS", "-Z bogus")
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn env_rustflags_build_script_with_target() {
|
|
// RUSTFLAGS should not be passed to rustc for build scripts
|
|
// when --target is specified.
|
|
let p = project()
|
|
.file(
|
|
"Cargo.toml",
|
|
r#"
|
|
[package]
|
|
name = "foo"
|
|
version = "0.0.1"
|
|
build = "build.rs"
|
|
"#,
|
|
)
|
|
.file("src/lib.rs", "")
|
|
.file(
|
|
"build.rs",
|
|
r#"
|
|
fn main() { assert!(!cfg!(foo)); }
|
|
"#,
|
|
)
|
|
.build();
|
|
|
|
let host = rustc_host();
|
|
p.cargo("check --target")
|
|
.arg(host)
|
|
.env("RUSTFLAGS", "--cfg foo")
|
|
.run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn env_rustflags_build_script_with_target_doesnt_apply_to_host_kind() {
|
|
// RUSTFLAGS should *not* be passed to rustc for build scripts when --target is specified as the
|
|
// host triple even if target-applies-to-host-kind is enabled, to match legacy Cargo behavior.
|
|
let p = project()
|
|
.file(
|
|
"Cargo.toml",
|
|
r#"
|
|
[package]
|
|
name = "foo"
|
|
version = "0.0.1"
|
|
build = "build.rs"
|
|
"#,
|
|
)
|
|
.file("src/lib.rs", "")
|
|
.file(
|
|
"build.rs",
|
|
r#"
|
|
fn main() { assert!(!cfg!(foo)); }
|
|
"#,
|
|
)
|
|
.file(
|
|
".cargo/config.toml",
|
|
r#"
|
|
target-applies-to-host = true
|
|
"#,
|
|
)
|
|
.build();
|
|
|
|
let host = rustc_host();
|
|
p.cargo("check --target")
|
|
.masquerade_as_nightly_cargo(&["target-applies-to-host"])
|
|
.arg(host)
|
|
.arg("-Ztarget-applies-to-host")
|
|
.env("RUSTFLAGS", "--cfg foo")
|
|
.run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn env_rustflags_build_script_dep_with_target() {
|
|
// RUSTFLAGS should not be passed to rustc for build scripts
|
|
// when --target is specified.
|
|
// In this test if --cfg foo is passed the build will fail.
|
|
let foo = project()
|
|
.file(
|
|
"Cargo.toml",
|
|
r#"
|
|
[package]
|
|
name = "foo"
|
|
version = "0.0.1"
|
|
build = "build.rs"
|
|
|
|
[build-dependencies.bar]
|
|
path = "../bar"
|
|
"#,
|
|
)
|
|
.file("src/lib.rs", "")
|
|
.file("build.rs", "fn main() {}")
|
|
.build();
|
|
let _bar = project()
|
|
.at("bar")
|
|
.file("Cargo.toml", &basic_manifest("bar", "0.0.1"))
|
|
.file(
|
|
"src/lib.rs",
|
|
r#"
|
|
fn bar() { }
|
|
#[cfg(foo)]
|
|
fn bar() { }
|
|
"#,
|
|
)
|
|
.build();
|
|
|
|
let host = rustc_host();
|
|
foo.cargo("check --target")
|
|
.arg(host)
|
|
.env("RUSTFLAGS", "--cfg foo")
|
|
.run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn env_rustflags_recompile() {
|
|
let p = project().file("src/lib.rs", "").build();
|
|
|
|
p.cargo("check").run();
|
|
// Setting RUSTFLAGS forces a recompile
|
|
p.cargo("check")
|
|
.env("RUSTFLAGS", "-Z bogus")
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn env_rustflags_recompile2() {
|
|
let p = project().file("src/lib.rs", "").build();
|
|
|
|
p.cargo("check").env("RUSTFLAGS", "--cfg foo").run();
|
|
// Setting RUSTFLAGS forces a recompile
|
|
p.cargo("check")
|
|
.env("RUSTFLAGS", "-Z bogus")
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn env_rustflags_no_recompile() {
|
|
let p = project().file("src/lib.rs", "").build();
|
|
|
|
p.cargo("check").env("RUSTFLAGS", "--cfg foo").run();
|
|
p.cargo("check")
|
|
.env("RUSTFLAGS", "--cfg foo")
|
|
.with_stderr_data(str![[r#"
|
|
[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
|
|
|
|
"#]])
|
|
.run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn build_rustflags_normal_source() {
|
|
let p = project()
|
|
.file("src/lib.rs", "")
|
|
.file("src/bin/a.rs", "fn main() {}")
|
|
.file("examples/b.rs", "fn main() {}")
|
|
.file("tests/c.rs", "#[test] fn f() { }")
|
|
.file(
|
|
"benches/d.rs",
|
|
r#"
|
|
#![feature(test)]
|
|
extern crate test;
|
|
#[bench] fn run1(_ben: &mut test::Bencher) { }
|
|
"#,
|
|
)
|
|
.file(
|
|
".cargo/config.toml",
|
|
r#"
|
|
[build]
|
|
rustflags = ["-Z", "bogus"]
|
|
"#,
|
|
)
|
|
.build();
|
|
|
|
p.cargo("check --lib")
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
p.cargo("check --bin=a")
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
p.cargo("check --example=b")
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
p.cargo("test")
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
p.cargo("bench")
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn build_rustflags_build_script() {
|
|
// RUSTFLAGS should be passed to rustc for build scripts
|
|
// when --target is not specified.
|
|
let p = project()
|
|
.file(
|
|
"Cargo.toml",
|
|
r#"
|
|
[package]
|
|
name = "foo"
|
|
version = "0.0.1"
|
|
build = "build.rs"
|
|
"#,
|
|
)
|
|
.file("src/lib.rs", "")
|
|
.file(
|
|
"build.rs",
|
|
r#"
|
|
fn main() { assert!(cfg!(foo)); }
|
|
"#,
|
|
)
|
|
.file(
|
|
".cargo/config.toml",
|
|
r#"
|
|
[build]
|
|
rustflags = ["--cfg", "foo"]
|
|
"#,
|
|
)
|
|
.build();
|
|
|
|
p.cargo("check").run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn build_rustflags_build_script_dep() {
|
|
// RUSTFLAGS should be passed to rustc for build scripts
|
|
// when --target is not specified.
|
|
// In this test if --cfg foo is not passed the build will fail.
|
|
let foo = project()
|
|
.file(
|
|
"Cargo.toml",
|
|
r#"
|
|
[package]
|
|
name = "foo"
|
|
version = "0.0.1"
|
|
build = "build.rs"
|
|
|
|
[build-dependencies.bar]
|
|
path = "../bar"
|
|
"#,
|
|
)
|
|
.file("src/lib.rs", "")
|
|
.file("build.rs", "fn main() {}")
|
|
.file(
|
|
".cargo/config.toml",
|
|
r#"
|
|
[build]
|
|
rustflags = ["--cfg", "foo"]
|
|
"#,
|
|
)
|
|
.build();
|
|
let _bar = project()
|
|
.at("bar")
|
|
.file("Cargo.toml", &basic_manifest("bar", "0.0.1"))
|
|
.file(
|
|
"src/lib.rs",
|
|
r#"
|
|
fn bar() { }
|
|
#[cfg(not(foo))]
|
|
fn bar() { }
|
|
"#,
|
|
)
|
|
.build();
|
|
|
|
foo.cargo("check").run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn build_rustflags_normal_source_with_target() {
|
|
let p = project()
|
|
.file("src/lib.rs", "")
|
|
.file("src/bin/a.rs", "fn main() {}")
|
|
.file("examples/b.rs", "fn main() {}")
|
|
.file("tests/c.rs", "#[test] fn f() { }")
|
|
.file(
|
|
"benches/d.rs",
|
|
r#"
|
|
#![feature(test)]
|
|
extern crate test;
|
|
#[bench] fn run1(_ben: &mut test::Bencher) { }
|
|
"#,
|
|
)
|
|
.file(
|
|
".cargo/config.toml",
|
|
r#"
|
|
[build]
|
|
rustflags = ["-Z", "bogus"]
|
|
"#,
|
|
)
|
|
.build();
|
|
|
|
let host = &rustc_host();
|
|
|
|
// Use build.rustflags to pass an argument that will generate an error
|
|
p.cargo("check --lib --target")
|
|
.arg(host)
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
p.cargo("check --bin=a --target")
|
|
.arg(host)
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
p.cargo("check --example=b --target")
|
|
.arg(host)
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
p.cargo("test --target")
|
|
.arg(host)
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
p.cargo("bench --target")
|
|
.arg(host)
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn build_rustflags_build_script_with_target() {
|
|
// RUSTFLAGS should not be passed to rustc for build scripts
|
|
// when --target is specified.
|
|
let p = project()
|
|
.file(
|
|
"Cargo.toml",
|
|
r#"
|
|
[package]
|
|
name = "foo"
|
|
version = "0.0.1"
|
|
build = "build.rs"
|
|
"#,
|
|
)
|
|
.file("src/lib.rs", "")
|
|
.file(
|
|
"build.rs",
|
|
r#"
|
|
fn main() { assert!(!cfg!(foo)); }
|
|
"#,
|
|
)
|
|
.file(
|
|
".cargo/config.toml",
|
|
r#"
|
|
[build]
|
|
rustflags = ["--cfg", "foo"]
|
|
"#,
|
|
)
|
|
.build();
|
|
|
|
let host = rustc_host();
|
|
p.cargo("check --target").arg(host).run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn build_rustflags_build_script_dep_with_target() {
|
|
// RUSTFLAGS should not be passed to rustc for build scripts
|
|
// when --target is specified.
|
|
// In this test if --cfg foo is passed the build will fail.
|
|
let foo = project()
|
|
.file(
|
|
"Cargo.toml",
|
|
r#"
|
|
[package]
|
|
name = "foo"
|
|
version = "0.0.1"
|
|
build = "build.rs"
|
|
|
|
[build-dependencies.bar]
|
|
path = "../bar"
|
|
"#,
|
|
)
|
|
.file("src/lib.rs", "")
|
|
.file("build.rs", "fn main() {}")
|
|
.file(
|
|
".cargo/config.toml",
|
|
r#"
|
|
[build]
|
|
rustflags = ["--cfg", "foo"]
|
|
"#,
|
|
)
|
|
.build();
|
|
let _bar = project()
|
|
.at("bar")
|
|
.file("Cargo.toml", &basic_manifest("bar", "0.0.1"))
|
|
.file(
|
|
"src/lib.rs",
|
|
r#"
|
|
fn bar() { }
|
|
#[cfg(foo)]
|
|
fn bar() { }
|
|
"#,
|
|
)
|
|
.build();
|
|
|
|
let host = rustc_host();
|
|
foo.cargo("check --target").arg(host).run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn build_rustflags_recompile() {
|
|
let p = project().file("src/lib.rs", "").build();
|
|
|
|
p.cargo("check").run();
|
|
|
|
// Setting RUSTFLAGS forces a recompile
|
|
let config = r#"
|
|
[build]
|
|
rustflags = ["-Z", "bogus"]
|
|
"#;
|
|
let config_file = paths::root().join("foo/.cargo/config.toml");
|
|
fs::create_dir_all(config_file.parent().unwrap()).unwrap();
|
|
fs::write(config_file, config).unwrap();
|
|
|
|
p.cargo("check")
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn build_rustflags_recompile2() {
|
|
let p = project().file("src/lib.rs", "").build();
|
|
|
|
p.cargo("check").env("RUSTFLAGS", "--cfg foo").run();
|
|
|
|
// Setting RUSTFLAGS forces a recompile
|
|
let config = r#"
|
|
[build]
|
|
rustflags = ["-Z", "bogus"]
|
|
"#;
|
|
let config_file = paths::root().join("foo/.cargo/config.toml");
|
|
fs::create_dir_all(config_file.parent().unwrap()).unwrap();
|
|
fs::write(config_file, config).unwrap();
|
|
|
|
p.cargo("check")
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn build_rustflags_no_recompile() {
|
|
let p = project()
|
|
.file("src/lib.rs", "")
|
|
.file(
|
|
".cargo/config.toml",
|
|
r#"
|
|
[build]
|
|
rustflags = ["--cfg", "foo"]
|
|
"#,
|
|
)
|
|
.build();
|
|
|
|
p.cargo("check").env("RUSTFLAGS", "--cfg foo").run();
|
|
p.cargo("check")
|
|
.env("RUSTFLAGS", "--cfg foo")
|
|
.with_stderr_data(str![[r#"
|
|
[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
|
|
|
|
"#]])
|
|
.run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn build_rustflags_with_home_config() {
|
|
// We need a config file inside the home directory
|
|
let home = paths::home();
|
|
let home_config = home.join(".cargo");
|
|
fs::create_dir(&home_config).unwrap();
|
|
fs::write(
|
|
&home_config.join("config"),
|
|
r#"
|
|
[build]
|
|
rustflags = ["-Cllvm-args=-x86-asm-syntax=intel"]
|
|
"#,
|
|
)
|
|
.unwrap();
|
|
|
|
// And we need the project to be inside the home directory
|
|
// so the walking process finds the home project twice.
|
|
let p = project_in_home("foo").file("src/lib.rs", "").build();
|
|
|
|
p.cargo("check -v").run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn target_rustflags_normal_source() {
|
|
let p = project()
|
|
.file("src/lib.rs", "")
|
|
.file("src/bin/a.rs", "fn main() {}")
|
|
.file("examples/b.rs", "fn main() {}")
|
|
.file("tests/c.rs", "#[test] fn f() { }")
|
|
.file(
|
|
"benches/d.rs",
|
|
r#"
|
|
#![feature(test)]
|
|
extern crate test;
|
|
#[bench] fn run1(_ben: &mut test::Bencher) { }
|
|
"#,
|
|
)
|
|
.file(
|
|
".cargo/config.toml",
|
|
&format!(
|
|
"
|
|
[target.{}]
|
|
rustflags = [\"-Z\", \"bogus\"]
|
|
",
|
|
rustc_host()
|
|
),
|
|
)
|
|
.build();
|
|
|
|
p.cargo("check --lib")
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
p.cargo("check --bin=a")
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
p.cargo("check --example=b")
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
p.cargo("test")
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
p.cargo("bench")
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn target_rustflags_also_for_build_scripts() {
|
|
let p = project()
|
|
.file("src/lib.rs", "")
|
|
.file(
|
|
"build.rs",
|
|
r#"
|
|
fn main() { assert!(cfg!(foo)); }
|
|
"#,
|
|
)
|
|
.file(
|
|
".cargo/config.toml",
|
|
&format!(
|
|
"
|
|
[target.{}]
|
|
rustflags = [\"--cfg=foo\"]
|
|
",
|
|
rustc_host()
|
|
),
|
|
)
|
|
.build();
|
|
|
|
p.cargo("check").run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn target_rustflags_not_for_build_scripts_with_target() {
|
|
let host = rustc_host();
|
|
let p = project()
|
|
.file("src/lib.rs", "")
|
|
.file(
|
|
"build.rs",
|
|
r#"
|
|
fn main() { assert!(!cfg!(foo)); }
|
|
"#,
|
|
)
|
|
.file(
|
|
".cargo/config.toml",
|
|
&format!(
|
|
"
|
|
[target.{}]
|
|
rustflags = [\"--cfg=foo\"]
|
|
",
|
|
host
|
|
),
|
|
)
|
|
.build();
|
|
|
|
p.cargo("check --target").arg(host).run();
|
|
|
|
// Enabling -Ztarget-applies-to-host should not make a difference without the config setting
|
|
p.cargo("check --target")
|
|
.arg(host)
|
|
.masquerade_as_nightly_cargo(&["target-applies-to-host"])
|
|
.arg("-Ztarget-applies-to-host")
|
|
.run();
|
|
|
|
// Even with the setting, the rustflags from `target.` should not apply, to match the legacy
|
|
// Cargo behavior.
|
|
p.change_file(
|
|
".cargo/config.toml",
|
|
&format!(
|
|
"
|
|
target-applies-to-host = true
|
|
|
|
[target.{}]
|
|
rustflags = [\"--cfg=foo\"]
|
|
",
|
|
host
|
|
),
|
|
);
|
|
p.cargo("check --target")
|
|
.arg(host)
|
|
.masquerade_as_nightly_cargo(&["target-applies-to-host"])
|
|
.arg("-Ztarget-applies-to-host")
|
|
.run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn build_rustflags_for_build_scripts() {
|
|
let host = rustc_host();
|
|
let p = project()
|
|
.file("src/lib.rs", "")
|
|
.file(
|
|
"build.rs",
|
|
r#"
|
|
fn main() { assert!(cfg!(foo), "CFG FOO!"); }
|
|
"#,
|
|
)
|
|
.file(
|
|
".cargo/config.toml",
|
|
"
|
|
[build]
|
|
rustflags = [\"--cfg=foo\"]
|
|
",
|
|
)
|
|
.build();
|
|
|
|
// With "legacy" behavior, build.rustflags should apply to build scripts without --target
|
|
p.cargo("check").run();
|
|
|
|
// But should _not_ apply _with_ --target
|
|
p.cargo("check --target")
|
|
.arg(host)
|
|
.with_status(101)
|
|
.with_stderr_data("...\n[..]CFG FOO![..]\n...")
|
|
.run();
|
|
|
|
// Enabling -Ztarget-applies-to-host should not make a difference without the config setting
|
|
p.cargo("check")
|
|
.masquerade_as_nightly_cargo(&["target-applies-to-host"])
|
|
.arg("-Ztarget-applies-to-host")
|
|
.run();
|
|
p.cargo("check --target")
|
|
.arg(host)
|
|
.masquerade_as_nightly_cargo(&["target-applies-to-host"])
|
|
.arg("-Ztarget-applies-to-host")
|
|
.with_status(101)
|
|
.with_stderr_data("...\n[..]CFG FOO![..]\n...")
|
|
.run();
|
|
|
|
// When set to false though, the "proper" behavior where host artifacts _only_ pick up on
|
|
// [host] should be applied.
|
|
p.change_file(
|
|
".cargo/config.toml",
|
|
"
|
|
target-applies-to-host = false
|
|
|
|
[build]
|
|
rustflags = [\"--cfg=foo\"]
|
|
",
|
|
);
|
|
p.cargo("check")
|
|
.masquerade_as_nightly_cargo(&["target-applies-to-host"])
|
|
.arg("-Ztarget-applies-to-host")
|
|
.with_status(101)
|
|
.with_stderr_data("...\n[..]CFG FOO![..]\n...")
|
|
.run();
|
|
p.cargo("check --target")
|
|
.arg(host)
|
|
.masquerade_as_nightly_cargo(&["target-applies-to-host"])
|
|
.arg("-Ztarget-applies-to-host")
|
|
.with_status(101)
|
|
.with_stderr_data("...\n[..]CFG FOO![..]\n...")
|
|
.run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn host_rustflags_for_build_scripts() {
|
|
let host = rustc_host();
|
|
let p = project()
|
|
.file("src/lib.rs", "")
|
|
.file(
|
|
"build.rs",
|
|
r#"
|
|
// Ensure that --cfg=foo is passed.
|
|
fn main() { assert!(cfg!(foo)); }
|
|
"#,
|
|
)
|
|
.file(
|
|
".cargo/config.toml",
|
|
&format!(
|
|
"
|
|
target-applies-to-host = false
|
|
|
|
[host.{}]
|
|
rustflags = [\"--cfg=foo\"]
|
|
",
|
|
host
|
|
),
|
|
)
|
|
.build();
|
|
|
|
p.cargo("check --target")
|
|
.arg(host)
|
|
.masquerade_as_nightly_cargo(&["target-applies-to-host", "host-config"])
|
|
.arg("-Ztarget-applies-to-host")
|
|
.arg("-Zhost-config")
|
|
.run();
|
|
}
|
|
|
|
// target.{}.rustflags takes precedence over build.rustflags
|
|
#[cargo_test]
|
|
fn target_rustflags_precedence() {
|
|
let p = project()
|
|
.file("src/lib.rs", "")
|
|
.file("src/bin/a.rs", "fn main() {}")
|
|
.file("examples/b.rs", "fn main() {}")
|
|
.file("tests/c.rs", "#[test] fn f() { }")
|
|
.file(
|
|
".cargo/config.toml",
|
|
&format!(
|
|
"
|
|
[build]
|
|
rustflags = [\"--cfg\", \"foo\"]
|
|
|
|
[target.{}]
|
|
rustflags = [\"-Z\", \"bogus\"]
|
|
",
|
|
rustc_host()
|
|
),
|
|
)
|
|
.build();
|
|
|
|
p.cargo("check --lib")
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
p.cargo("check --bin=a")
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
p.cargo("check --example=b")
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
p.cargo("test")
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
p.cargo("bench")
|
|
.with_status(101)
|
|
.with_stderr_data(str![[r#"
|
|
[ERROR] failed to run `rustc` to learn about target-specific information
|
|
|
|
Caused by:
|
|
[..]bogus[..]
|
|
...
|
|
"#]])
|
|
.run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn cfg_rustflags_normal_source() {
|
|
let p = project()
|
|
.file("src/lib.rs", "pub fn t() {}")
|
|
.file("src/bin/a.rs", "fn main() {}")
|
|
.file("examples/b.rs", "fn main() {}")
|
|
.file("tests/c.rs", "#[test] fn f() { }")
|
|
.file(
|
|
".cargo/config.toml",
|
|
&format!(
|
|
r#"
|
|
[target.'cfg({})']
|
|
rustflags = ["--cfg", "bar"]
|
|
"#,
|
|
if rustc_host().contains("-windows-") {
|
|
"windows"
|
|
} else {
|
|
"not(windows)"
|
|
}
|
|
),
|
|
)
|
|
.build();
|
|
|
|
p.cargo("build --lib -v")
|
|
.with_stderr_data(str![[r#"
|
|
[COMPILING] foo v0.0.1 ([ROOT]/foo)
|
|
[RUNNING] `rustc --crate-name foo [..] --cfg bar`
|
|
[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
|
|
|
|
"#]])
|
|
.run();
|
|
|
|
p.cargo("build --bin=a -v")
|
|
.with_stderr_data(str![[r#"
|
|
[COMPILING] foo v0.0.1 ([ROOT]/foo)
|
|
[RUNNING] `rustc --crate-name a [..] --cfg bar`
|
|
[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
|
|
|
|
"#]])
|
|
.run();
|
|
|
|
p.cargo("build --example=b -v")
|
|
.with_stderr_data(str![[r#"
|
|
[COMPILING] foo v0.0.1 ([ROOT]/foo)
|
|
[RUNNING] `rustc --crate-name b [..] --cfg bar`
|
|
[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
|
|
|
|
"#]])
|
|
.run();
|
|
|
|
p.cargo("test --no-run -v")
|
|
.with_stderr_data(str![[r#"
|
|
[COMPILING] foo v0.0.1 ([ROOT]/foo)
|
|
[RUNNING] `rustc [..] --cfg bar`
|
|
[RUNNING] `rustc [..] --cfg bar`
|
|
[RUNNING] `rustc [..] --cfg bar`
|
|
[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
|
|
[EXECUTABLE] `[ROOT]/foo/target/debug/deps/foo-[HASH][EXE]`
|
|
[EXECUTABLE] `[ROOT]/foo/target/debug/deps/a-[HASH][EXE]`
|
|
[EXECUTABLE] `[ROOT]/foo/target/debug/deps/c-[HASH][EXE]`
|
|
|
|
"#]])
|
|
.run();
|
|
|
|
p.cargo("bench --no-run -v")
|
|
.with_stderr_data(str![[r#"
|
|
[COMPILING] foo v0.0.1 ([ROOT]/foo)
|
|
[RUNNING] `rustc [..] --cfg bar`
|
|
[RUNNING] `rustc [..] --cfg bar`
|
|
[RUNNING] `rustc [..] --cfg bar`
|
|
[FINISHED] `bench` profile [optimized] target(s) in [ELAPSED]s
|
|
[EXECUTABLE] `[ROOT]/foo/target/release/deps/foo-[HASH][EXE]`
|
|
[EXECUTABLE] `[ROOT]/foo/target/release/deps/a-[HASH][EXE]`
|
|
|
|
"#]])
|
|
.run();
|
|
}
|
|
|
|
// target.'cfg(...)'.rustflags takes precedence over build.rustflags
|
|
#[cargo_test]
|
|
fn cfg_rustflags_precedence() {
|
|
let p = project()
|
|
.file("src/lib.rs", "pub fn t() {}")
|
|
.file("src/bin/a.rs", "fn main() {}")
|
|
.file("examples/b.rs", "fn main() {}")
|
|
.file("tests/c.rs", "#[test] fn f() { }")
|
|
.file(
|
|
".cargo/config.toml",
|
|
&format!(
|
|
r#"
|
|
[build]
|
|
rustflags = ["--cfg", "foo"]
|
|
|
|
[target.'cfg({})']
|
|
rustflags = ["--cfg", "bar"]
|
|
"#,
|
|
if rustc_host().contains("-windows-") {
|
|
"windows"
|
|
} else {
|
|
"not(windows)"
|
|
}
|
|
),
|
|
)
|
|
.build();
|
|
|
|
p.cargo("build --lib -v")
|
|
.with_stderr_data(str![[r#"
|
|
[COMPILING] foo v0.0.1 ([ROOT]/foo)
|
|
[RUNNING] `rustc --crate-name foo [..] --cfg bar`
|
|
[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
|
|
|
|
"#]])
|
|
.run();
|
|
|
|
p.cargo("build --bin=a -v")
|
|
.with_stderr_data(str![[r#"
|
|
[COMPILING] foo v0.0.1 ([ROOT]/foo)
|
|
[RUNNING] `rustc --crate-name a [..] --cfg bar`
|
|
[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
|
|
|
|
"#]])
|
|
.run();
|
|
|
|
p.cargo("build --example=b -v")
|
|
.with_stderr_data(str![[r#"
|
|
[COMPILING] foo v0.0.1 ([ROOT]/foo)
|
|
[RUNNING] `rustc --crate-name b [..] --cfg bar`
|
|
[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
|
|
|
|
"#]])
|
|
.run();
|
|
|
|
p.cargo("test --no-run -v")
|
|
.with_stderr_data(str![[r#"
|
|
[COMPILING] foo v0.0.1 ([ROOT]/foo)
|
|
[RUNNING] `rustc [..] --cfg bar`
|
|
[RUNNING] `rustc [..] --cfg bar`
|
|
[RUNNING] `rustc [..] --cfg bar`
|
|
[FINISHED] `test` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
|
|
[EXECUTABLE] `[ROOT]/foo/target/debug/deps/foo-[HASH][EXE]`
|
|
[EXECUTABLE] `[ROOT]/foo/target/debug/deps/a-[HASH][EXE]`
|
|
[EXECUTABLE] `[ROOT]/foo/target/debug/deps/c-[HASH][EXE]`
|
|
|
|
"#]])
|
|
.run();
|
|
|
|
p.cargo("bench --no-run -v")
|
|
.with_stderr_data(str![[r#"
|
|
[COMPILING] foo v0.0.1 ([ROOT]/foo)
|
|
[RUNNING] `rustc [..] --cfg bar`
|
|
[RUNNING] `rustc [..] --cfg bar`
|
|
[RUNNING] `rustc [..] --cfg bar`
|
|
[FINISHED] `bench` profile [optimized] target(s) in [ELAPSED]s
|
|
[EXECUTABLE] `[ROOT]/foo/target/release/deps/foo-[HASH][EXE]`
|
|
[EXECUTABLE] `[ROOT]/foo/target/release/deps/a-[HASH][EXE]`
|
|
|
|
"#]])
|
|
.run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn target_rustflags_string_and_array_form1() {
|
|
let p1 = project()
|
|
.file("src/lib.rs", "")
|
|
.file(
|
|
".cargo/config.toml",
|
|
r#"
|
|
[build]
|
|
rustflags = ["--cfg", "foo"]
|
|
"#,
|
|
)
|
|
.build();
|
|
|
|
p1.cargo("check -v")
|
|
.with_stderr_data(str![[r#"
|
|
[CHECKING] foo v0.0.1 ([ROOT]/foo)
|
|
[RUNNING] `rustc --crate-name foo [..] --cfg foo`
|
|
[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
|
|
|
|
"#]])
|
|
.run();
|
|
|
|
let p2 = project()
|
|
.file("src/lib.rs", "")
|
|
.file(
|
|
".cargo/config.toml",
|
|
r#"
|
|
[build]
|
|
rustflags = "--cfg foo"
|
|
"#,
|
|
)
|
|
.build();
|
|
|
|
p2.cargo("check -v")
|
|
.with_stderr_data(str![[r#"
|
|
[CHECKING] foo v0.0.1 ([ROOT]/foo)
|
|
[RUNNING] `rustc --crate-name foo [..] --cfg foo`
|
|
[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
|
|
|
|
"#]])
|
|
.run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn target_rustflags_string_and_array_form2() {
|
|
let p1 = project()
|
|
.file(
|
|
".cargo/config.toml",
|
|
&format!(
|
|
r#"
|
|
[target.{}]
|
|
rustflags = ["--cfg", "foo"]
|
|
"#,
|
|
rustc_host()
|
|
),
|
|
)
|
|
.file("src/lib.rs", "")
|
|
.build();
|
|
|
|
p1.cargo("check -v")
|
|
.with_stderr_data(str![[r#"
|
|
[CHECKING] foo v0.0.1 ([ROOT]/foo)
|
|
[RUNNING] `rustc --crate-name foo [..] --cfg foo`
|
|
[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
|
|
|
|
"#]])
|
|
.run();
|
|
|
|
let p2 = project()
|
|
.file(
|
|
".cargo/config.toml",
|
|
&format!(
|
|
r#"
|
|
[target.{}]
|
|
rustflags = "--cfg foo"
|
|
"#,
|
|
rustc_host()
|
|
),
|
|
)
|
|
.file("src/lib.rs", "")
|
|
.build();
|
|
|
|
p2.cargo("check -v")
|
|
.with_stderr_data(str![[r#"
|
|
[CHECKING] foo v0.0.1 ([ROOT]/foo)
|
|
[RUNNING] `rustc --crate-name foo [..] --cfg foo`
|
|
[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
|
|
|
|
"#]])
|
|
.run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn two_matching_in_config() {
|
|
let p1 = project()
|
|
.file(
|
|
".cargo/config.toml",
|
|
r#"
|
|
[target.'cfg(unix)']
|
|
rustflags = ["--cfg", 'foo="a"']
|
|
[target.'cfg(windows)']
|
|
rustflags = ["--cfg", 'foo="a"']
|
|
[target.'cfg(target_pointer_width = "32")']
|
|
rustflags = ["--cfg", 'foo="b"']
|
|
[target.'cfg(target_pointer_width = "64")']
|
|
rustflags = ["--cfg", 'foo="b"']
|
|
"#,
|
|
)
|
|
.file(
|
|
"src/main.rs",
|
|
r#"
|
|
#![allow(unexpected_cfgs)]
|
|
fn main() {
|
|
if cfg!(foo = "a") {
|
|
println!("a");
|
|
} else if cfg!(foo = "b") {
|
|
println!("b");
|
|
} else {
|
|
panic!()
|
|
}
|
|
}
|
|
"#,
|
|
)
|
|
.build();
|
|
|
|
p1.cargo("run").run();
|
|
p1.cargo("build")
|
|
.with_stderr_data(str![[r#"
|
|
[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
|
|
|
|
"#]])
|
|
.run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn env_rustflags_misspelled() {
|
|
let p = project().file("src/main.rs", "fn main() { }").build();
|
|
|
|
for cmd in &["check", "build", "run", "test", "bench"] {
|
|
p.cargo(cmd)
|
|
.env("RUST_FLAGS", "foo")
|
|
.with_stderr_data(
|
|
"\
|
|
[WARNING] Cargo does not read `RUST_FLAGS` environment variable. Did you mean `RUSTFLAGS`?
|
|
...
|
|
",
|
|
)
|
|
.run();
|
|
}
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn env_rustflags_misspelled_build_script() {
|
|
let p = project()
|
|
.file(
|
|
"Cargo.toml",
|
|
r#"
|
|
[package]
|
|
name = "foo"
|
|
version = "0.0.1"
|
|
edition = "2021"
|
|
build = "build.rs"
|
|
"#,
|
|
)
|
|
.file("src/lib.rs", "")
|
|
.file("build.rs", "fn main() { }")
|
|
.build();
|
|
|
|
p.cargo("check")
|
|
.env("RUST_FLAGS", "foo")
|
|
.with_stderr_data(str![[r#"
|
|
[WARNING] Cargo does not read `RUST_FLAGS` environment variable. Did you mean `RUSTFLAGS`?
|
|
[COMPILING] foo v0.0.1 ([ROOT]/foo)
|
|
[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
|
|
|
|
"#]])
|
|
.run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn remap_path_prefix_works() {
|
|
// Check that remap-path-prefix works.
|
|
Package::new("bar", "0.1.0")
|
|
.file("src/lib.rs", "pub fn f() -> &'static str { file!() }")
|
|
.publish();
|
|
|
|
let p = project()
|
|
.file(
|
|
"Cargo.toml",
|
|
r#"
|
|
[package]
|
|
name = "foo"
|
|
version = "0.1.0"
|
|
|
|
[dependencies]
|
|
bar = "0.1"
|
|
"#,
|
|
)
|
|
.file(
|
|
"src/main.rs",
|
|
r#"
|
|
fn main() {
|
|
println!("{}", bar::f());
|
|
}
|
|
"#,
|
|
)
|
|
.build();
|
|
|
|
p.cargo("run")
|
|
.env(
|
|
"RUSTFLAGS",
|
|
format!("--remap-path-prefix={}=/foo", paths::root().display()),
|
|
)
|
|
.with_stdout_data(str![[r#"
|
|
/foo/home/.cargo/registry/src/-[HASH]/bar-0.1.0/src/lib.rs
|
|
|
|
"#]])
|
|
.run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn rustflags_remap_path_prefix_ignored_for_c_metadata() {
|
|
let p = project().file("src/lib.rs", "").build();
|
|
|
|
let build_output = p
|
|
.cargo("build -v")
|
|
.env(
|
|
"RUSTFLAGS",
|
|
"--remap-path-prefix=/abc=/zoo --remap-path-prefix /spaced=/zoo",
|
|
)
|
|
.run();
|
|
let first_c_metadata = dbg!(get_c_metadata(build_output));
|
|
|
|
p.cargo("clean").run();
|
|
|
|
let build_output = p
|
|
.cargo("build -v")
|
|
.env(
|
|
"RUSTFLAGS",
|
|
"--remap-path-prefix=/def=/zoo --remap-path-prefix /earth=/zoo",
|
|
)
|
|
.run();
|
|
let second_c_metadata = dbg!(get_c_metadata(build_output));
|
|
|
|
assert_data_eq!(first_c_metadata, second_c_metadata);
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn rustc_remap_path_prefix_ignored_for_c_metadata() {
|
|
let p = project().file("src/lib.rs", "").build();
|
|
|
|
let build_output = p
|
|
.cargo("rustc -v -- --remap-path-prefix=/abc=/zoo --remap-path-prefix /spaced=/zoo")
|
|
.run();
|
|
let first_c_metadata = dbg!(get_c_metadata(build_output));
|
|
|
|
p.cargo("clean").run();
|
|
|
|
let build_output = p
|
|
.cargo("rustc -v -- --remap-path-prefix=/def=/zoo --remap-path-prefix /earth=/zoo")
|
|
.run();
|
|
let second_c_metadata = dbg!(get_c_metadata(build_output));
|
|
|
|
assert_data_eq!(first_c_metadata, second_c_metadata);
|
|
}
|
|
|
|
// `--remap-path-prefix` is meant to take two different binaries and make them the same but the
|
|
// rlib name, including `-Cextra-filename`, can still end up in the binary so it can't change
|
|
#[cargo_test]
|
|
fn rustflags_remap_path_prefix_ignored_for_c_extra_filename() {
|
|
let p = project().file("src/lib.rs", "").build();
|
|
|
|
let build_output = p
|
|
.cargo("build -v")
|
|
.env(
|
|
"RUSTFLAGS",
|
|
"--remap-path-prefix=/abc=/zoo --remap-path-prefix /spaced=/zoo",
|
|
)
|
|
.run();
|
|
let first_c_extra_filename = dbg!(get_c_extra_filename(build_output));
|
|
|
|
p.cargo("clean").run();
|
|
|
|
let build_output = p
|
|
.cargo("build -v")
|
|
.env(
|
|
"RUSTFLAGS",
|
|
"--remap-path-prefix=/def=/zoo --remap-path-prefix /earth=/zoo",
|
|
)
|
|
.run();
|
|
let second_c_extra_filename = dbg!(get_c_extra_filename(build_output));
|
|
|
|
assert_data_eq!(first_c_extra_filename, second_c_extra_filename);
|
|
}
|
|
|
|
// `--remap-path-prefix` is meant to take two different binaries and make them the same but the
|
|
// rlib name, including `-Cextra-filename`, can still end up in the binary so it can't change
|
|
#[cargo_test]
|
|
fn rustc_remap_path_prefix_ignored_for_c_extra_filename() {
|
|
let p = project().file("src/lib.rs", "").build();
|
|
|
|
let build_output = p
|
|
.cargo("rustc -v -- --remap-path-prefix=/abc=/zoo --remap-path-prefix /spaced=/zoo")
|
|
.run();
|
|
let first_c_extra_filename = dbg!(get_c_extra_filename(build_output));
|
|
|
|
p.cargo("clean").run();
|
|
|
|
let build_output = p
|
|
.cargo("rustc -v -- --remap-path-prefix=/def=/zoo --remap-path-prefix /earth=/zoo")
|
|
.run();
|
|
let second_c_extra_filename = dbg!(get_c_extra_filename(build_output));
|
|
|
|
assert_data_eq!(first_c_extra_filename, second_c_extra_filename);
|
|
}
|
|
|
|
fn get_c_metadata(output: RawOutput) -> String {
|
|
let get_c_metadata_re =
|
|
regex::Regex::new(r".* (--crate-name [^ ]+).* (-C ?metadata=[^ ]+).*").unwrap();
|
|
|
|
let stderr = String::from_utf8(output.stderr).unwrap();
|
|
let mut c_metadata = get_c_metadata_re
|
|
.captures_iter(&stderr)
|
|
.map(|c| {
|
|
let (_, [name, c_metadata]) = c.extract();
|
|
format!("{name} {c_metadata}")
|
|
})
|
|
.collect::<Vec<_>>();
|
|
assert!(
|
|
!c_metadata.is_empty(),
|
|
"`{get_c_metadata_re:?}` did not match:\n```\n{stderr}\n```"
|
|
);
|
|
c_metadata.sort();
|
|
c_metadata.join("\n")
|
|
}
|
|
|
|
fn get_c_extra_filename(output: RawOutput) -> String {
|
|
let get_c_extra_filename_re =
|
|
regex::Regex::new(r".* (--crate-name [^ ]+).* (-C ?extra-filename=[^ ]+).*").unwrap();
|
|
|
|
let stderr = String::from_utf8(output.stderr).unwrap();
|
|
let mut c_extra_filename = get_c_extra_filename_re
|
|
.captures_iter(&stderr)
|
|
.map(|c| {
|
|
let (_, [name, c_extra_filename]) = c.extract();
|
|
format!("{name} {c_extra_filename}")
|
|
})
|
|
.collect::<Vec<_>>();
|
|
assert!(
|
|
!c_extra_filename.is_empty(),
|
|
"`{get_c_extra_filename_re:?}` did not match:\n```\n{stderr}\n```"
|
|
);
|
|
c_extra_filename.sort();
|
|
c_extra_filename.join("\n")
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn host_config_rustflags_with_target() {
|
|
// regression test for https://github.com/rust-lang/cargo/issues/10206
|
|
let p = project()
|
|
.file("src/lib.rs", "")
|
|
.file("build.rs", "fn main() { assert!(cfg!(foo)); }")
|
|
.file(".cargo/config.toml", "target-applies-to-host = false")
|
|
.build();
|
|
|
|
p.cargo("check")
|
|
.masquerade_as_nightly_cargo(&["target-applies-to-host", "host-config"])
|
|
.arg("-Zhost-config")
|
|
.arg("-Ztarget-applies-to-host")
|
|
.arg("-Zunstable-options")
|
|
.arg("--config")
|
|
.arg("host.rustflags=[\"--cfg=foo\"]")
|
|
.run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn target_applies_to_host_rustflags_works() {
|
|
// Ensures that rustflags are passed to the target when
|
|
// target_applies_to_host=false
|
|
let p = project()
|
|
.file(
|
|
"src/lib.rs",
|
|
r#"#[cfg(feature = "flag")] compile_error!("flag passed");"#,
|
|
)
|
|
.build();
|
|
|
|
// Use RUSTFLAGS to pass an argument that will generate an error.
|
|
p.cargo("check")
|
|
.masquerade_as_nightly_cargo(&["target-applies-to-host"])
|
|
.arg("-Ztarget-applies-to-host")
|
|
.env("CARGO_TARGET_APPLIES_TO_HOST", "false")
|
|
.env("RUSTFLAGS", r#"--cfg feature="flag""#)
|
|
.with_status(101)
|
|
.with_stderr_data(
|
|
"[CHECKING] foo v0.0.1 ([ROOT]/foo)
|
|
[ERROR] flag passed
|
|
...",
|
|
)
|
|
.run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn target_applies_to_host_rustdocflags_works() {
|
|
// Ensures that rustflags are passed to the target when
|
|
// target_applies_to_host=false
|
|
let p = project()
|
|
.file(
|
|
"src/lib.rs",
|
|
r#"#[cfg(feature = "flag")] compile_error!("flag passed");"#,
|
|
)
|
|
.build();
|
|
|
|
// Use RUSTFLAGS to pass an argument that would generate an error
|
|
// but it is ignored.
|
|
p.cargo("doc")
|
|
.masquerade_as_nightly_cargo(&["target-applies-to-host"])
|
|
.arg("-Ztarget-applies-to-host")
|
|
.env("CARGO_TARGET_APPLIES_TO_HOST", "false")
|
|
.env("RUSTDOCFLAGS", r#"--cfg feature="flag""#)
|
|
.with_status(101)
|
|
.with_stderr_data(
|
|
"[DOCUMENTING] foo v0.0.1 ([ROOT]/foo)
|
|
[ERROR] flag passed
|
|
...",
|
|
)
|
|
.run();
|
|
}
|
|
|
|
#[cargo_test]
|
|
fn host_config_shared_build_dep() {
|
|
// rust-lang/cargo#14253
|
|
Package::new("cc", "1.0.0").publish();
|
|
let p = project()
|
|
.file(
|
|
"Cargo.toml",
|
|
r#"
|
|
[package]
|
|
name = "bootstrap"
|
|
edition = "2021"
|
|
|
|
[dependencies]
|
|
cc = "1.0.0"
|
|
|
|
[build-dependencies]
|
|
cc = "1.0.0"
|
|
|
|
[profile.dev]
|
|
debug = 0
|
|
"#,
|
|
)
|
|
.file("src/lib.rs", "")
|
|
.file("build.rs", "fn main() {}")
|
|
.file(
|
|
".cargo/config.toml",
|
|
"
|
|
target-applies-to-host=false
|
|
|
|
[host]
|
|
rustflags = ['--cfg', 'from_host']
|
|
|
|
[build]
|
|
rustflags = ['--cfg', 'from_target']
|
|
",
|
|
)
|
|
.build();
|
|
|
|
p.cargo("build -v")
|
|
.masquerade_as_nightly_cargo(&["target-applies-to-host"])
|
|
.arg("-Ztarget-applies-to-host")
|
|
.arg("-Zhost-config")
|
|
.with_stderr_data(
|
|
str![[r#"
|
|
[UPDATING] `dummy-registry` index
|
|
[LOCKING] 1 package to latest compatible version
|
|
[DOWNLOADING] crates ...
|
|
[DOWNLOADED] cc v1.0.0 (registry `dummy-registry`)
|
|
[COMPILING] cc v1.0.0
|
|
[RUNNING] `rustc --crate-name cc [..]--cfg from_host[..]`
|
|
[RUNNING] `rustc --crate-name cc [..]--cfg from_target[..]`
|
|
[COMPILING] bootstrap v0.0.0 ([ROOT]/foo)
|
|
[RUNNING] `rustc --crate-name build_script_build [..]--cfg from_host[..]`
|
|
[RUNNING] `[ROOT]/foo/target/debug/build/bootstrap-[HASH]/build-script-build`
|
|
[RUNNING] `rustc --crate-name bootstrap[..]--cfg from_target[..]`
|
|
[FINISHED] `dev` profile [unoptimized] target(s) in [ELAPSED]s
|
|
|
|
"#]]
|
|
.unordered(),
|
|
)
|
|
.run();
|
|
}
|