#![feature(rustc_private)]
+#![feature(once_cell)]
+#![feature(bool_to_option)]
#![cfg_attr(feature = "deny-warnings", deny(warnings))]
// warn on lints, that are included in `rust-lang/rust`s bootstrap
#![warn(rust_2018_idioms, unused_lifetimes)]
// FIXME: switch to something more ergonomic here, once available.
// (Currently there is no way to opt into sysroot crates without `extern crate`.)
-extern crate rustc_data_structures;
extern crate rustc_driver;
extern crate rustc_errors;
extern crate rustc_interface;
use rustc_middle::ty::TyCtxt;
use rustc_tools_util::VersionInfo;
-use lazy_static::lazy_static;
use std::borrow::Cow;
use std::env;
+use std::iter;
+use std::lazy::SyncLazy;
use std::ops::Deref;
use std::panic;
use std::path::{Path, PathBuf};
use std::process::{exit, Command};
-mod lintlist;
-
/// If a command-line option matches `find_arg`, then apply the predicate `pred` on its value. If
/// true, then return it. The parameter is assumed to be either `--arg=value` or `--arg value`.
fn arg_value<'a, T: Deref<Target = str>>(
None
}
-#[test]
-fn test_arg_value() {
- let args = &["--bar=bar", "--foobar", "123", "--foo"];
-
- assert_eq!(arg_value(&[] as &[&str], "--foobar", |_| true), None);
- assert_eq!(arg_value(args, "--bar", |_| false), None);
- assert_eq!(arg_value(args, "--bar", |_| true), Some("bar"));
- assert_eq!(arg_value(args, "--bar", |p| p == "bar"), Some("bar"));
- assert_eq!(arg_value(args, "--bar", |p| p == "foo"), None);
- assert_eq!(arg_value(args, "--foobar", |p| p == "foo"), None);
- assert_eq!(arg_value(args, "--foobar", |p| p == "123"), Some("123"));
- assert_eq!(arg_value(args, "--foo", |_| true), None);
-}
-
struct DefaultCallbacks;
impl rustc_driver::Callbacks for DefaultCallbacks {}
}
}
-#[allow(clippy::find_map, clippy::filter_map)]
-fn describe_lints() {
- use lintlist::{Level, Lint, ALL_LINTS, LINT_LEVELS};
- use rustc_data_structures::fx::FxHashSet;
-
- println!(
- "
-Available lint options:
- -W <foo> Warn about <foo>
- -A <foo> Allow <foo>
- -D <foo> Deny <foo>
- -F <foo> Forbid <foo> (deny <foo> and all attempts to override)
-
-"
- );
-
- let lint_level = |lint: &Lint| {
- LINT_LEVELS
- .iter()
- .find(|level_mapping| level_mapping.0 == lint.group)
- .map(|(_, level)| match level {
- Level::Allow => "allow",
- Level::Warn => "warn",
- Level::Deny => "deny",
- })
- .unwrap()
- };
-
- let mut lints: Vec<_> = ALL_LINTS.iter().collect();
- // The sort doesn't case-fold but it's doubtful we care.
- lints.sort_by_cached_key(|x: &&Lint| (lint_level(x), x.name));
-
- let max_lint_name_len = lints
- .iter()
- .map(|lint| lint.name.len())
- .map(|len| len + "clippy::".len())
- .max()
- .unwrap_or(0);
-
- let padded = |x: &str| {
- let mut s = " ".repeat(max_lint_name_len - x.chars().count());
- s.push_str(x);
- s
- };
-
- let scoped = |x: &str| format!("clippy::{}", x);
-
- let lint_groups: FxHashSet<_> = lints.iter().map(|lint| lint.group).collect();
-
- println!("Lint checks provided by clippy:\n");
- println!(" {} {:7.7} meaning", padded("name"), "default");
- println!(" {} {:7.7} -------", padded("----"), "-------");
-
- let print_lints = |lints: &[&Lint]| {
- for lint in lints {
- let name = lint.name.replace("_", "-");
- println!(
- " {} {:7.7} {}",
- padded(&scoped(&name)),
- lint_level(lint),
- lint.desc
- );
- }
- println!("\n");
- };
-
- print_lints(&lints);
-
- let max_group_name_len = std::cmp::max(
- "clippy::all".len(),
- lint_groups
- .iter()
- .map(|group| group.len())
- .map(|len| len + "clippy::".len())
- .max()
- .unwrap_or(0),
- );
-
- let padded_group = |x: &str| {
- let mut s = " ".repeat(max_group_name_len - x.chars().count());
- s.push_str(x);
- s
- };
-
- println!("Lint groups provided by clippy:\n");
- println!(" {} sub-lints", padded_group("name"));
- println!(" {} ---------", padded_group("----"));
- println!(" {} the set of all clippy lints", padded_group("clippy::all"));
-
- let print_lint_groups = || {
- for group in lint_groups {
- let name = group.to_lowercase().replace("_", "-");
- let desc = lints
- .iter()
- .filter(|&lint| lint.group == group)
- .map(|lint| lint.name)
- .map(|name| name.replace("_", "-"))
- .collect::<Vec<String>>()
- .join(", ");
- println!(" {} {}", padded_group(&scoped(&name)), desc);
- }
- println!("\n");
- };
-
- print_lint_groups();
-}
-
fn display_help() {
println!(
"\
const BUG_REPORT_URL: &str = "https://github.com/rust-lang/rust-clippy/issues/new";
-lazy_static! {
- static ref ICE_HOOK: Box<dyn Fn(&panic::PanicInfo<'_>) + Sync + Send + 'static> = {
- let hook = panic::take_hook();
- panic::set_hook(Box::new(|info| report_clippy_ice(info, BUG_REPORT_URL)));
- hook
- };
-}
+static ICE_HOOK: SyncLazy<Box<dyn Fn(&panic::PanicInfo<'_>) + Sync + Send + 'static>> = SyncLazy::new(|| {
+ let hook = panic::take_hook();
+ panic::set_hook(Box::new(|info| report_clippy_ice(info, BUG_REPORT_URL)));
+ hook
+});
fn report_clippy_ice(info: &panic::PanicInfo<'_>, bug_report_url: &str) {
// Invoke our ICE handler, which prints the actual panic message and optionally a backtrace
// If backtraces are enabled, also print the query stack
let backtrace = env::var_os("RUST_BACKTRACE").map_or(false, |x| &x != "0");
- if backtrace {
- TyCtxt::try_print_query_stack(&handler);
- }
+ let num_frames = if backtrace { None } else { Some(2) };
+
+ TyCtxt::try_print_query_stack(&handler, num_frames);
}
fn toolchain_path(home: Option<String>, toolchain: Option<String>) -> Option<PathBuf> {
})
}
+fn remove_clippy_args<'a, T, U, I>(args: &mut Vec<T>, clippy_args: I)
+where
+ T: AsRef<str>,
+ U: AsRef<str> + ?Sized + 'a,
+ I: Iterator<Item = &'a U> + Clone,
+{
+ let args_iter = clippy_args.map(AsRef::as_ref);
+ let args_count = args_iter.clone().count();
+
+ if args_count > 0 {
+ if let Some(start) = args.windows(args_count).enumerate().find_map(|(current, window)| {
+ window
+ .iter()
+ .map(AsRef::as_ref)
+ .eq(args_iter.clone())
+ .then_some(current)
+ }) {
+ args.drain(start..start + args_count);
+ }
+ }
+}
+
+#[allow(clippy::too_many_lines)]
pub fn main() {
rustc_driver::init_rustc_env_logger();
- lazy_static::initialize(&ICE_HOOK);
+ SyncLazy::force(&ICE_HOOK);
exit(rustc_driver::catch_with_exit_code(move || {
let mut orig_args: Vec<String> = env::args().collect();
args.extend(vec!["--sysroot".into(), sys_root]);
};
- return rustc_driver::run_compiler(&args, &mut DefaultCallbacks, None, None, None);
+ return rustc_driver::RunCompiler::new(&args, &mut DefaultCallbacks).run();
}
if orig_args.iter().any(|a| a == "--version" || a == "-V") {
exit(0);
}
- let should_describe_lints = || {
- let args: Vec<_> = env::args().collect();
- args.windows(2)
- .any(|args| args[1] == "help" && matches!(args[0].as_str(), "-W" | "-A" | "-D" | "-F"))
- };
-
- if !wrapper_mode && should_describe_lints() {
- describe_lints();
- exit(0);
- }
-
// this conditional check for the --sysroot flag is there so users can call
// `clippy_driver` directly
// without having to pass --sysroot or anything
args.extend(vec!["--sysroot".into(), sys_root]);
};
- // this check ensures that dependencies are built but not linted and the final
- // crate is linted but not built
- let clippy_enabled = env::var("CLIPPY_TESTS").map_or(false, |val| val == "true")
- || arg_value(&orig_args, "--cap-lints", |val| val == "allow").is_none();
+ let clippy_args = env::var("CLIPPY_ARGS").unwrap_or_default();
+ let clippy_args = clippy_args.split_whitespace();
+ let no_deps = clippy_args.clone().any(|flag| flag == "--no-deps");
+
+ // We enable Clippy if one of the following conditions is met
+ // - IF Clippy is run on its test suite OR
+ // - IF Clippy is run on the main crate, not on deps (`!cap_lints_allow`) THEN
+ // - IF `--no-deps` is not set (`!no_deps`) OR
+ // - IF `--no-deps` is set and Clippy is run on the specified primary package
+ let clippy_tests_set = env::var("CLIPPY_TESTS").map_or(false, |val| val == "true");
+ let cap_lints_allow = arg_value(&orig_args, "--cap-lints", |val| val == "allow").is_some();
+ let in_primary_package = env::var("CARGO_PRIMARY_PACKAGE").is_ok();
+ let clippy_enabled = clippy_tests_set || (!cap_lints_allow && (!no_deps || in_primary_package));
if clippy_enabled {
+ remove_clippy_args(&mut args, iter::once("--no-deps"));
args.extend(vec!["--cfg".into(), r#"feature="cargo-clippy""#.into()]);
- if let Ok(extra_args) = env::var("CLIPPY_ARGS") {
- args.extend(extra_args.split("__CLIPPY_HACKERY__").filter_map(|s| {
- if s.is_empty() {
- None
- } else {
- Some(s.to_string())
- }
- }));
- }
+ } else {
+ // Remove all flags passed through RUSTFLAGS if Clippy is not enabled.
+ remove_clippy_args(&mut args, clippy_args);
}
+
let mut clippy = ClippyCallbacks;
let mut default = DefaultCallbacks;
let callbacks: &mut (dyn rustc_driver::Callbacks + Send) =
if clippy_enabled { &mut clippy } else { &mut default };
- rustc_driver::run_compiler(&args, callbacks, None, None, None)
+
+ rustc_driver::RunCompiler::new(&args, callbacks).run()
}))
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_arg_value() {
+ let args = &["--bar=bar", "--foobar", "123", "--foo"];
+
+ assert_eq!(arg_value(&[] as &[&str], "--foobar", |_| true), None);
+ assert_eq!(arg_value(args, "--bar", |_| false), None);
+ assert_eq!(arg_value(args, "--bar", |_| true), Some("bar"));
+ assert_eq!(arg_value(args, "--bar", |p| p == "bar"), Some("bar"));
+ assert_eq!(arg_value(args, "--bar", |p| p == "foo"), None);
+ assert_eq!(arg_value(args, "--foobar", |p| p == "foo"), None);
+ assert_eq!(arg_value(args, "--foobar", |p| p == "123"), Some("123"));
+ assert_eq!(arg_value(args, "--foo", |_| true), None);
+ }
+
+ #[test]
+ fn removes_clippy_args_from_start() {
+ let mut args = vec!["-D", "clippy::await_holding_lock", "--cfg", r#"feature="some_feat""#];
+ let clippy_args = ["-D", "clippy::await_holding_lock"].iter();
+
+ remove_clippy_args(&mut args, clippy_args);
+ assert_eq!(args, &["--cfg", r#"feature="some_feat""#]);
+ }
+
+ #[test]
+ fn removes_clippy_args_from_end() {
+ let mut args = vec!["-Zui-testing", "-A", "clippy::empty_loop", "--no-deps"];
+ let clippy_args = ["-A", "clippy::empty_loop", "--no-deps"].iter();
+
+ remove_clippy_args(&mut args, clippy_args);
+ assert_eq!(args, &["-Zui-testing"]);
+ }
+
+ #[test]
+ fn removes_clippy_args_from_middle() {
+ let mut args = vec!["-Zui-testing", "-W", "clippy::filter_map", "-L", "serde"];
+ let clippy_args = ["-W", "clippy::filter_map"].iter();
+
+ remove_clippy_args(&mut args, clippy_args);
+ assert_eq!(args, &["-Zui-testing", "-L", "serde"]);
+ }
+
+ #[test]
+ fn no_clippy_args_to_remove() {
+ let mut args = vec!["-Zui-testing", "-L", "serde"];
+ let clippy_args: [&str; 0] = [];
+
+ remove_clippy_args(&mut args, clippy_args.iter());
+ assert_eq!(args, &["-Zui-testing", "-L", "serde"]);
+ }
+}