2021-09-08 14:31:47 +00:00
|
|
|
#![cfg_attr(feature = "deny-warnings", deny(warnings))]
|
|
|
|
#![warn(rust_2018_idioms, unused_lifetimes)]
|
2023-07-17 08:19:29 +00:00
|
|
|
#![allow(unused_extern_crates)]
|
2017-11-14 13:56:00 +00:00
|
|
|
|
2024-05-02 15:26:44 +00:00
|
|
|
use ui_test::custom_flags::rustfix::RustfixMode;
|
2024-02-27 14:25:18 +00:00
|
|
|
use ui_test::spanned::Spanned;
|
2024-07-25 16:29:17 +00:00
|
|
|
use ui_test::{status_emitter, Args, CommandBuilder, Config, Match, OutputConflictHandling};
|
2015-04-13 17:58:18 +00:00
|
|
|
|
2023-07-17 08:19:29 +00:00
|
|
|
use std::collections::BTreeMap;
|
2023-08-24 19:32:12 +00:00
|
|
|
use std::env::{self, set_var, var_os};
|
2021-06-03 06:41:37 +00:00
|
|
|
use std::ffi::{OsStr, OsString};
|
2018-05-30 18:29:00 +00:00
|
|
|
use std::fs;
|
2018-05-22 08:21:42 +00:00
|
|
|
use std::path::{Path, PathBuf};
|
2023-07-17 08:19:29 +00:00
|
|
|
use std::sync::LazyLock;
|
2022-01-13 12:18:19 +00:00
|
|
|
use test_utils::IS_RUSTC_TEST_SUITE;
|
2015-04-13 17:58:18 +00:00
|
|
|
|
2023-07-17 08:19:29 +00:00
|
|
|
// Test dependencies may need an `extern crate` here to ensure that they show up
|
|
|
|
// in the depinfo file (otherwise cargo thinks they are unused)
|
|
|
|
extern crate clippy_lints;
|
|
|
|
extern crate clippy_utils;
|
|
|
|
extern crate futures;
|
|
|
|
extern crate if_chain;
|
|
|
|
extern crate itertools;
|
|
|
|
extern crate parking_lot;
|
|
|
|
extern crate quote;
|
|
|
|
extern crate syn;
|
|
|
|
extern crate tokio;
|
|
|
|
|
2023-08-24 19:32:12 +00:00
|
|
|
mod test_utils;
|
|
|
|
|
2023-07-17 08:19:29 +00:00
|
|
|
/// All crates used in UI tests are listed here
|
|
|
|
static TEST_DEPENDENCIES: &[&str] = &[
|
2023-11-02 16:35:56 +00:00
|
|
|
"clippy_config",
|
2023-07-17 08:19:29 +00:00
|
|
|
"clippy_lints",
|
|
|
|
"clippy_utils",
|
|
|
|
"futures",
|
|
|
|
"if_chain",
|
|
|
|
"itertools",
|
|
|
|
"parking_lot",
|
|
|
|
"quote",
|
|
|
|
"regex",
|
|
|
|
"serde_derive",
|
|
|
|
"serde",
|
|
|
|
"syn",
|
|
|
|
"tokio",
|
|
|
|
];
|
|
|
|
|
|
|
|
/// Produces a string with an `--extern` flag for all UI test crate
|
|
|
|
/// dependencies.
|
|
|
|
///
|
|
|
|
/// The dependency files are located by parsing the depinfo file for this test
|
|
|
|
/// module. This assumes the `-Z binary-dep-depinfo` flag is enabled. All test
|
|
|
|
/// dependencies must be added to Cargo.toml at the project root. Test
|
|
|
|
/// dependencies that are not *directly* used by this test module require an
|
|
|
|
/// `extern crate` declaration.
|
|
|
|
static EXTERN_FLAGS: LazyLock<Vec<String>> = LazyLock::new(|| {
|
|
|
|
let current_exe_depinfo = {
|
|
|
|
let mut path = env::current_exe().unwrap();
|
|
|
|
path.set_extension("d");
|
|
|
|
fs::read_to_string(path).unwrap()
|
|
|
|
};
|
|
|
|
let mut crates = BTreeMap::<&str, &str>::new();
|
|
|
|
for line in current_exe_depinfo.lines() {
|
|
|
|
// each dependency is expected to have a Makefile rule like `/path/to/crate-hash.rlib:`
|
|
|
|
let parse_name_path = || {
|
|
|
|
if line.starts_with(char::is_whitespace) {
|
|
|
|
return None;
|
|
|
|
}
|
|
|
|
let path_str = line.strip_suffix(':')?;
|
|
|
|
let path = Path::new(path_str);
|
|
|
|
if !matches!(path.extension()?.to_str()?, "rlib" | "so" | "dylib" | "dll") {
|
|
|
|
return None;
|
|
|
|
}
|
|
|
|
let (name, _hash) = path.file_stem()?.to_str()?.rsplit_once('-')?;
|
|
|
|
// the "lib" prefix is not present for dll files
|
|
|
|
let name = name.strip_prefix("lib").unwrap_or(name);
|
|
|
|
Some((name, path_str))
|
|
|
|
};
|
|
|
|
if let Some((name, path)) = parse_name_path() {
|
|
|
|
if TEST_DEPENDENCIES.contains(&name) {
|
|
|
|
// A dependency may be listed twice if it is available in sysroot,
|
|
|
|
// and the sysroot dependencies are listed first. As of the writing,
|
|
|
|
// this only seems to apply to if_chain.
|
|
|
|
crates.insert(name, path);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
let not_found: Vec<&str> = TEST_DEPENDENCIES
|
|
|
|
.iter()
|
|
|
|
.copied()
|
|
|
|
.filter(|n| !crates.contains_key(n))
|
|
|
|
.collect();
|
|
|
|
assert!(
|
|
|
|
not_found.is_empty(),
|
|
|
|
"dependencies not found in depinfo: {not_found:?}\n\
|
|
|
|
help: Make sure the `-Z binary-dep-depinfo` rust flag is enabled\n\
|
|
|
|
help: Try adding to dev-dependencies in Cargo.toml\n\
|
|
|
|
help: Be sure to also add `extern crate ...;` to tests/compile-test.rs",
|
|
|
|
);
|
|
|
|
crates
|
|
|
|
.into_iter()
|
|
|
|
.map(|(name, path)| format!("--extern={name}={path}"))
|
|
|
|
.collect()
|
|
|
|
});
|
|
|
|
|
2020-12-06 14:01:03 +00:00
|
|
|
// whether to run internal tests or not
|
2022-01-13 12:18:19 +00:00
|
|
|
const RUN_INTERNAL_TESTS: bool = cfg!(feature = "internal");
|
2020-12-06 14:01:03 +00:00
|
|
|
|
2023-08-24 19:32:12 +00:00
|
|
|
fn base_config(test_dir: &str) -> (Config, Args) {
|
2023-09-12 16:13:53 +00:00
|
|
|
let mut args = Args::test().unwrap();
|
|
|
|
args.bless |= var_os("RUSTC_BLESS").is_some_and(|v| v != "0");
|
2023-08-24 19:32:12 +00:00
|
|
|
|
2023-10-21 12:16:11 +00:00
|
|
|
let target_dir = PathBuf::from(var_os("CARGO_TARGET_DIR").unwrap_or_else(|| "target".into()));
|
2023-08-24 19:32:12 +00:00
|
|
|
let mut config = Config {
|
2024-02-27 14:25:18 +00:00
|
|
|
output_conflict_handling: OutputConflictHandling::Error,
|
2023-09-12 16:13:53 +00:00
|
|
|
filter_files: env::var("TESTNAME")
|
|
|
|
.map(|filters| filters.split(',').map(str::to_string).collect())
|
|
|
|
.unwrap_or_default(),
|
2023-07-02 12:35:19 +00:00
|
|
|
target: None,
|
2024-02-27 14:25:18 +00:00
|
|
|
bless_command: Some("cargo uibless".into()),
|
2023-10-21 12:16:11 +00:00
|
|
|
out_dir: target_dir.join("ui_test"),
|
2023-08-24 19:32:12 +00:00
|
|
|
..Config::rustc(Path::new("tests").join(test_dir))
|
2021-11-04 12:52:36 +00:00
|
|
|
};
|
2024-07-25 16:29:17 +00:00
|
|
|
config.comment_defaults.base().exit_status = None.into();
|
|
|
|
config.comment_defaults.base().require_annotations = None.into();
|
2024-05-02 15:26:44 +00:00
|
|
|
config
|
|
|
|
.comment_defaults
|
|
|
|
.base()
|
|
|
|
.set_custom("rustfix", RustfixMode::Everything);
|
2024-02-27 14:25:18 +00:00
|
|
|
config.comment_defaults.base().diagnostic_code_prefix = Some(Spanned::dummy("clippy::".into())).into();
|
|
|
|
config.with_args(&args);
|
2022-02-10 17:40:06 +00:00
|
|
|
let current_exe_path = env::current_exe().unwrap();
|
2021-09-28 17:03:12 +00:00
|
|
|
let deps_path = current_exe_path.parent().unwrap();
|
|
|
|
let profile_path = deps_path.parent().unwrap();
|
2019-04-22 13:04:48 +00:00
|
|
|
|
2023-07-17 08:19:29 +00:00
|
|
|
config.program.args.extend(
|
|
|
|
[
|
|
|
|
"--emit=metadata",
|
|
|
|
"-Aunused",
|
2023-03-09 20:54:53 +00:00
|
|
|
"-Ainternal_features",
|
2023-07-17 08:19:29 +00:00
|
|
|
"-Zui-testing",
|
2024-03-07 16:19:29 +00:00
|
|
|
"-Zdeduplicate-diagnostics=no",
|
2023-07-17 08:19:29 +00:00
|
|
|
"-Dwarnings",
|
|
|
|
&format!("-Ldependency={}", deps_path.display()),
|
|
|
|
]
|
|
|
|
.map(OsString::from),
|
|
|
|
);
|
|
|
|
|
|
|
|
config.program.args.extend(EXTERN_FLAGS.iter().map(OsString::from));
|
2024-04-04 17:52:55 +00:00
|
|
|
// Prevent rustc from creating `rustc-ice-*` files the console output is enough.
|
|
|
|
config.program.envs.push(("RUSTC_ICE".into(), Some("0".into())));
|
2023-07-17 08:19:29 +00:00
|
|
|
|
|
|
|
if let Some(host_libs) = option_env!("HOST_LIBS") {
|
|
|
|
let dep = format!("-Ldependency={}", Path::new(host_libs).join("deps").display());
|
|
|
|
config.program.args.push(dep.into());
|
|
|
|
}
|
2023-07-02 12:35:19 +00:00
|
|
|
|
|
|
|
config.program.program = profile_path.join(if cfg!(windows) {
|
2021-09-28 17:03:12 +00:00
|
|
|
"clippy-driver.exe"
|
|
|
|
} else {
|
|
|
|
"clippy-driver"
|
|
|
|
});
|
2023-08-24 19:32:12 +00:00
|
|
|
(config, args)
|
2023-07-02 12:35:19 +00:00
|
|
|
}
|
|
|
|
|
2022-02-10 17:40:06 +00:00
|
|
|
fn run_ui() {
|
2023-08-24 19:32:12 +00:00
|
|
|
let (mut config, args) = base_config("ui");
|
|
|
|
config
|
|
|
|
.program
|
|
|
|
.envs
|
2023-10-21 12:16:11 +00:00
|
|
|
.push(("CLIPPY_CONF_DIR".into(), Some("tests".into())));
|
2023-07-02 12:35:19 +00:00
|
|
|
|
2023-08-24 19:32:12 +00:00
|
|
|
ui_test::run_tests_generic(
|
|
|
|
vec![config],
|
|
|
|
ui_test::default_file_filter,
|
|
|
|
ui_test::default_per_file_config,
|
2023-10-21 12:16:11 +00:00
|
|
|
status_emitter::Text::from(args.format),
|
2023-07-02 12:35:19 +00:00
|
|
|
)
|
|
|
|
.unwrap();
|
2021-10-21 11:11:36 +00:00
|
|
|
}
|
|
|
|
|
2022-02-10 17:40:06 +00:00
|
|
|
fn run_internal_tests() {
|
2020-12-06 14:01:03 +00:00
|
|
|
// only run internal tests with the internal-tests feature
|
|
|
|
if !RUN_INTERNAL_TESTS {
|
|
|
|
return;
|
|
|
|
}
|
2023-08-24 19:32:12 +00:00
|
|
|
let (mut config, args) = base_config("ui-internal");
|
2024-02-27 14:25:18 +00:00
|
|
|
config.bless_command = Some("cargo uitest --features internal -- -- --bless".into());
|
2023-07-31 21:53:53 +00:00
|
|
|
|
2023-08-24 19:32:12 +00:00
|
|
|
ui_test::run_tests_generic(
|
|
|
|
vec![config],
|
|
|
|
ui_test::default_file_filter,
|
|
|
|
ui_test::default_per_file_config,
|
2023-10-21 12:16:11 +00:00
|
|
|
status_emitter::Text::from(args.format),
|
2023-07-31 21:53:53 +00:00
|
|
|
)
|
|
|
|
.unwrap();
|
2020-12-06 14:01:03 +00:00
|
|
|
}
|
|
|
|
|
2022-02-10 17:40:06 +00:00
|
|
|
fn run_ui_toml() {
|
2023-08-24 19:32:12 +00:00
|
|
|
let (mut config, args) = base_config("ui-toml");
|
|
|
|
|
2023-10-21 12:16:11 +00:00
|
|
|
config
|
2024-02-27 14:25:18 +00:00
|
|
|
.comment_defaults
|
|
|
|
.base()
|
|
|
|
.normalize_stderr
|
|
|
|
.push((Match::from(env::current_dir().unwrap().as_path()), b"$DIR".into()));
|
2023-07-02 12:35:19 +00:00
|
|
|
|
|
|
|
ui_test::run_tests_generic(
|
2023-08-24 19:32:12 +00:00
|
|
|
vec![config],
|
|
|
|
ui_test::default_file_filter,
|
|
|
|
|config, path, _file_contents| {
|
2023-07-02 12:35:19 +00:00
|
|
|
config
|
|
|
|
.program
|
|
|
|
.envs
|
|
|
|
.push(("CLIPPY_CONF_DIR".into(), Some(path.parent().unwrap().into())));
|
2020-05-28 13:45:24 +00:00
|
|
|
},
|
2023-10-21 12:16:11 +00:00
|
|
|
status_emitter::Text::from(args.format),
|
2023-07-02 12:35:19 +00:00
|
|
|
)
|
|
|
|
.unwrap();
|
2020-05-28 13:45:24 +00:00
|
|
|
}
|
|
|
|
|
2024-02-27 14:25:18 +00:00
|
|
|
// Allow `Default::default` as `OptWithSpan` is not nameable
|
|
|
|
#[allow(clippy::default_trait_access)]
|
2022-02-10 17:40:06 +00:00
|
|
|
fn run_ui_cargo() {
|
2022-01-13 12:18:19 +00:00
|
|
|
if IS_RUSTC_TEST_SUITE {
|
2020-08-11 13:43:21 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2023-08-24 19:32:12 +00:00
|
|
|
let (mut config, args) = base_config("ui-cargo");
|
2023-07-02 12:35:19 +00:00
|
|
|
config.program.input_file_flag = CommandBuilder::cargo().input_file_flag;
|
|
|
|
config.program.out_dir_flag = CommandBuilder::cargo().out_dir_flag;
|
|
|
|
config.program.args = vec!["clippy".into(), "--color".into(), "never".into(), "--quiet".into()];
|
|
|
|
config
|
|
|
|
.program
|
|
|
|
.envs
|
|
|
|
.push(("RUSTFLAGS".into(), Some("-Dwarnings".into())));
|
|
|
|
// We need to do this while we still have a rustc in the `program` field.
|
|
|
|
config.fill_host_and_target().unwrap();
|
|
|
|
config.program.program.set_file_name(if cfg!(windows) {
|
|
|
|
"cargo-clippy.exe"
|
|
|
|
} else {
|
|
|
|
"cargo-clippy"
|
|
|
|
});
|
2024-05-02 15:26:44 +00:00
|
|
|
config.comment_defaults.base().custom.clear();
|
2023-07-02 12:35:19 +00:00
|
|
|
|
2023-10-21 12:16:11 +00:00
|
|
|
config
|
2024-02-27 14:25:18 +00:00
|
|
|
.comment_defaults
|
|
|
|
.base()
|
|
|
|
.normalize_stderr
|
|
|
|
.push((Match::from(env::current_dir().unwrap().as_path()), b"$DIR".into()));
|
2020-05-28 13:45:24 +00:00
|
|
|
|
2023-09-12 16:13:53 +00:00
|
|
|
let ignored_32bit = |path: &Path| {
|
|
|
|
// FIXME: for some reason the modules are linted in a different order for this test
|
|
|
|
cfg!(target_pointer_width = "32") && path.ends_with("tests/ui-cargo/module_style/fail_mod/Cargo.toml")
|
|
|
|
};
|
|
|
|
|
2023-07-02 12:35:19 +00:00
|
|
|
ui_test::run_tests_generic(
|
2023-08-24 19:32:12 +00:00
|
|
|
vec![config],
|
2023-09-12 16:13:53 +00:00
|
|
|
|path, config| {
|
2024-02-27 14:25:18 +00:00
|
|
|
path.ends_with("Cargo.toml")
|
|
|
|
.then(|| ui_test::default_any_file_filter(path, config) && !ignored_32bit(path))
|
2023-09-12 16:13:53 +00:00
|
|
|
},
|
2023-10-21 12:16:11 +00:00
|
|
|
|_config, _path, _file_contents| {},
|
|
|
|
status_emitter::Text::from(args.format),
|
2023-07-02 12:35:19 +00:00
|
|
|
)
|
|
|
|
.unwrap();
|
2015-04-13 17:58:18 +00:00
|
|
|
}
|
|
|
|
|
2023-07-02 12:35:19 +00:00
|
|
|
fn main() {
|
2022-01-27 14:12:45 +00:00
|
|
|
set_var("CLIPPY_DISABLE_DOCS_LINKS", "true");
|
2023-07-17 08:19:29 +00:00
|
|
|
// The SPEEDTEST_* env variables can be used to check Clippy's performance on your PR. It runs the
|
|
|
|
// affected test 1000 times and gets the average.
|
|
|
|
if let Ok(speedtest) = std::env::var("SPEEDTEST") {
|
|
|
|
println!("----------- STARTING SPEEDTEST -----------");
|
|
|
|
let f = match speedtest.as_str() {
|
|
|
|
"ui" => run_ui as fn(),
|
|
|
|
"cargo" => run_ui_cargo as fn(),
|
|
|
|
"toml" => run_ui_toml as fn(),
|
|
|
|
"internal" => run_internal_tests as fn(),
|
|
|
|
"ui-cargo-toml-metadata" => ui_cargo_toml_metadata as fn(),
|
|
|
|
|
|
|
|
_ => panic!("unknown speedtest: {speedtest} || accepted speedtests are: [ui, cargo, toml, internal]"),
|
|
|
|
};
|
|
|
|
|
|
|
|
let iterations;
|
|
|
|
if let Ok(iterations_str) = std::env::var("SPEEDTEST_ITERATIONS") {
|
|
|
|
iterations = iterations_str
|
|
|
|
.parse::<u64>()
|
|
|
|
.unwrap_or_else(|_| panic!("Couldn't parse `{iterations_str}`, please use a valid u64"));
|
|
|
|
} else {
|
|
|
|
iterations = 1000;
|
|
|
|
}
|
|
|
|
|
|
|
|
let mut sum = 0;
|
|
|
|
for _ in 0..iterations {
|
|
|
|
let start = std::time::Instant::now();
|
|
|
|
f();
|
|
|
|
sum += start.elapsed().as_millis();
|
|
|
|
}
|
2023-08-24 19:32:12 +00:00
|
|
|
println!(
|
|
|
|
"average {} time: {} millis.",
|
|
|
|
speedtest.to_uppercase(),
|
|
|
|
sum / u128::from(iterations)
|
|
|
|
);
|
2023-07-17 08:19:29 +00:00
|
|
|
} else {
|
|
|
|
run_ui();
|
|
|
|
run_ui_toml();
|
|
|
|
run_ui_cargo();
|
|
|
|
run_internal_tests();
|
|
|
|
ui_cargo_toml_metadata();
|
|
|
|
}
|
2015-04-13 17:58:18 +00:00
|
|
|
}
|
2021-06-03 06:41:37 +00:00
|
|
|
|
2022-07-28 17:08:22 +00:00
|
|
|
fn ui_cargo_toml_metadata() {
|
|
|
|
let ui_cargo_path = Path::new("tests/ui-cargo");
|
|
|
|
let cargo_common_metadata_path = ui_cargo_path.join("cargo_common_metadata");
|
|
|
|
let publish_exceptions =
|
|
|
|
["fail_publish", "fail_publish_true", "pass_publish_empty"].map(|path| cargo_common_metadata_path.join(path));
|
|
|
|
|
|
|
|
for entry in walkdir::WalkDir::new(ui_cargo_path) {
|
|
|
|
let entry = entry.unwrap();
|
|
|
|
let path = entry.path();
|
|
|
|
if path.file_name() != Some(OsStr::new("Cargo.toml")) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
let toml = fs::read_to_string(path).unwrap().parse::<toml::Value>().unwrap();
|
|
|
|
|
|
|
|
let package = toml.as_table().unwrap().get("package").unwrap().as_table().unwrap();
|
|
|
|
|
|
|
|
let name = package.get("name").unwrap().as_str().unwrap().replace('-', "_");
|
|
|
|
assert!(
|
|
|
|
path.parent()
|
|
|
|
.unwrap()
|
|
|
|
.components()
|
|
|
|
.map(|component| component.as_os_str().to_string_lossy().replace('-', "_"))
|
|
|
|
.any(|s| *s == name)
|
|
|
|
|| path.starts_with(&cargo_common_metadata_path),
|
2022-10-06 07:44:38 +00:00
|
|
|
"{path:?} has incorrect package name"
|
2022-07-28 17:08:22 +00:00
|
|
|
);
|
|
|
|
|
|
|
|
let publish = package.get("publish").and_then(toml::Value::as_bool).unwrap_or(true);
|
|
|
|
assert!(
|
|
|
|
!publish || publish_exceptions.contains(&path.parent().unwrap().to_path_buf()),
|
2022-10-06 07:44:38 +00:00
|
|
|
"{path:?} lacks `publish = false`"
|
2022-07-28 17:08:22 +00:00
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|