X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fdriver.rs;h=834d11861c0d58540e9420c82f64a41f379f1399;hb=e01caad2a87f6176f0d533ef861b1b01a5474adf;hp=1ce6f6b7c4963368f8f5ce13b8a777390a90d570;hpb=62f40e28b9b4e44d683ca2508b1bd9e637d2df38;p=rust.git diff --git a/src/driver.rs b/src/driver.rs index 1ce6f6b7c49..834d11861c0 100644 --- a/src/driver.rs +++ b/src/driver.rs @@ -1,18 +1,15 @@ -// error-pattern:yummy -#![feature(box_syntax)] #![feature(rustc_private)] -#![feature(try_from)] -#![allow(clippy::missing_docs_in_private_items)] // FIXME: switch to something more ergonomic here, once available. -// (currently there is no way to opt into sysroot crates w/o `extern crate`) +// (Currently there is no way to opt into sysroot crates without `extern crate`.) #[allow(unused_extern_crates)] extern crate rustc_driver; #[allow(unused_extern_crates)] +extern crate rustc_interface; +#[allow(unused_extern_crates)] extern crate rustc_plugin; -use self::rustc_driver::{driver::CompileController, Compilation}; -use std::convert::TryInto; +use rustc_interface::interface; use std::path::Path; use std::process::{exit, Command}; @@ -20,10 +17,103 @@ fn show_version() { println!(env!("CARGO_PKG_VERSION")); } +/// 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>( + args: impl IntoIterator, + find_arg: &str, + pred: impl Fn(&str) -> bool, +) -> Option<&'a str> { + let mut args = args.into_iter().map(String::as_str); + + while let Some(arg) = args.next() { + let arg: Vec<_> = arg.splitn(2, '=').collect(); + if arg.get(0) != Some(&find_arg) { + continue; + } + + let value = arg.get(1).cloned().or_else(|| args.next()); + if value.as_ref().map_or(false, |p| pred(p)) { + return value; + } + } + None +} + +#[test] +fn test_arg_value() { + let args: Vec<_> = ["--bar=bar", "--foobar", "123", "--foo"] + .iter() + .map(std::string::ToString::to_string) + .collect(); + + assert_eq!(arg_value(None, "--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); +} + +#[allow(clippy::too_many_lines)] + +struct ClippyCallbacks; + +impl rustc_driver::Callbacks for ClippyCallbacks { + fn after_parsing(&mut self, compiler: &interface::Compiler) -> bool { + let sess = compiler.session(); + let mut registry = rustc_plugin::registry::Registry::new( + sess, + compiler + .parse() + .expect( + "at this compilation stage \ + the crate must be parsed", + ) + .peek() + .span, + ); + registry.args_hidden = Some(Vec::new()); + + let conf = clippy_lints::read_conf(®istry); + clippy_lints::register_plugins(&mut registry, &conf); + + let rustc_plugin::registry::Registry { + early_lint_passes, + late_lint_passes, + lint_groups, + llvm_passes, + attributes, + .. + } = registry; + let mut ls = sess.lint_store.borrow_mut(); + for pass in early_lint_passes { + ls.register_early_pass(Some(sess), true, false, pass); + } + for pass in late_lint_passes { + ls.register_late_pass(Some(sess), true, false, false, pass); + } + + for (name, (to, deprecated_name)) in lint_groups { + ls.register_group(Some(sess), true, name, deprecated_name, to); + } + clippy_lints::register_pre_expansion_lints(sess, &mut ls, &conf); + clippy_lints::register_renamed(&mut ls); + + sess.plugin_llvm_passes.borrow_mut().extend(llvm_passes); + sess.plugin_attributes.borrow_mut().extend(attributes); + + // Continue execution + true + } +} + pub fn main() { rustc_driver::init_rustc_env_logger(); exit( - rustc_driver::run(move || { + rustc_driver::report_ices_to_stderr_if_any(move || { use std::env; if std::env::args().any(|a| a == "--version" || a == "-V") { @@ -31,8 +121,19 @@ pub fn main() { exit(0); } - let sys_root = option_env!("SYSROOT") - .map(String::from) + let mut orig_args: Vec = env::args().collect(); + + // Get the sysroot, looking from most specific to this invocation to the least: + // - command line + // - runtime environment + // - SYSROOT + // - RUSTUP_HOME, MULTIRUST_HOME, RUSTUP_TOOLCHAIN, MULTIRUST_TOOLCHAIN + // - sysroot from rustc in the path + // - compile-time environment + let sys_root_arg = arg_value(&orig_args, "--sysroot", |_| true); + let have_sys_root_arg = sys_root_arg.is_some(); + let sys_root = sys_root_arg + .map(std::string::ToString::to_string) .or_else(|| std::env::var("SYSROOT").ok()) .or_else(|| { let home = option_env!("RUSTUP_HOME").or(option_env!("MULTIRUST_HOME")); @@ -48,11 +149,11 @@ pub fn main() { .and_then(|out| String::from_utf8(out.stdout).ok()) .map(|s| s.trim().to_owned()) }) + .or_else(|| option_env!("SYSROOT").map(String::from)) .expect("need to specify SYSROOT env var during clippy compilation, or use rustup or multirust"); // Setting RUSTC_WRAPPER causes Cargo to pass 'rustc' as the first argument. // We're invoking the compiler programmatically, so we ignore this/ - let mut orig_args: Vec = env::args().collect(); if orig_args.len() <= 1 { std::process::exit(1); } @@ -63,7 +164,7 @@ pub fn main() { // this conditional check for the --sysroot flag is there so users can call // `clippy_driver` directly // without having to pass --sysroot or anything - let mut args: Vec = if orig_args.iter().any(|s| s == "--sysroot") { + let mut args: Vec = if have_sys_root_arg { orig_args.clone() } else { orig_args @@ -78,7 +179,7 @@ pub fn main() { // crate is // linted but not built let clippy_enabled = env::var("CLIPPY_TESTS").ok().map_or(false, |val| val == "true") - || orig_args.iter().any(|s| s == "--emit=dep-info,metadata"); + || arg_value(&orig_args, "--emit", |val| val.split(',').any(|e| e == "metadata")).is_some(); if clippy_enabled { args.extend_from_slice(&["--cfg".to_owned(), r#"feature="cargo-clippy""#.to_owned()]); @@ -93,58 +194,14 @@ pub fn main() { } } - let mut controller = CompileController::basic(); - if clippy_enabled { - controller.after_parse.callback = Box::new(move |state| { - let mut registry = rustc_plugin::registry::Registry::new( - state.session, - state - .krate - .as_ref() - .expect( - "at this compilation stage \ - the crate must be parsed", - ) - .span, - ); - registry.args_hidden = Some(Vec::new()); - - let conf = clippy_lints::read_conf(®istry); - clippy_lints::register_plugins(&mut registry, &conf); - - let rustc_plugin::registry::Registry { - early_lint_passes, - late_lint_passes, - lint_groups, - llvm_passes, - attributes, - .. - } = registry; - let sess = &state.session; - let mut ls = sess.lint_store.borrow_mut(); - for pass in early_lint_passes { - ls.register_early_pass(Some(sess), true, false, pass); - } - for pass in late_lint_passes { - ls.register_late_pass(Some(sess), true, pass); - } - - for (name, (to, deprecated_name)) in lint_groups { - ls.register_group(Some(sess), true, name, deprecated_name, to); - } - clippy_lints::register_pre_expansion_lints(sess, &mut ls, &conf); - clippy_lints::register_renamed(&mut ls); - - sess.plugin_llvm_passes.borrow_mut().extend(llvm_passes); - sess.plugin_attributes.borrow_mut().extend(attributes); - }); - } - controller.compilation_done.stop = Compilation::Stop; - + let mut clippy = ClippyCallbacks; + let mut default = rustc_driver::DefaultCallbacks; + let callbacks: &mut (dyn rustc_driver::Callbacks + Send) = + if clippy_enabled { &mut clippy } else { &mut default }; let args = args; - rustc_driver::run_compiler(&args, Box::new(controller), None, None) + rustc_driver::run_compiler(&args, callbacks, None, None) }) - .try_into() - .expect("exit code too large"), + .and_then(|result| result) + .is_err() as i32, ) }