X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmain.rs;h=e0b2bcc7266455766a5ce29556aebf82241f474b;hb=f195680edb1d0ba2c04bfd6ba4fccfca184e8dbe;hp=81933d5769a67fa21b61085733a23d623898308c;hpb=47a706682cb5fd47b61fd8451c1a781c4f16c81e;p=rust.git diff --git a/src/main.rs b/src/main.rs index 81933d5769a..e0b2bcc7266 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,15 +1,4 @@ -// error-pattern:yummy -#![feature(box_syntax)] -#![feature(rustc_private)] -#![allow(unknown_lints, missing_docs_in_private_items)] - -use std::collections::HashMap; -use std::process; -use std::io::{self, Write}; - -extern crate cargo_metadata; - -use std::path::{Path, PathBuf}; +use rustc_tools_util::*; const CARGO_CLIPPY_HELP: &str = r#"Checks a package to catch common mistakes and improve your Rust code. @@ -18,11 +7,9 @@ Common options: -h, --help Print this message - --features Features to compile for the package -V, --version Print version info and exit - --all Run over all packages in the current workspace -Other options are the same as `cargo rustc`. +Other options are the same as `cargo check`. To allow or deny a lint from the command line you can use `cargo clippy --` with: @@ -32,20 +19,18 @@ -D --deny OPT Set lint denied -F --forbid OPT Set lint forbidden -The feature `cargo-clippy` is automatically defined for convenience. You can use -it to allow or deny lints from the code, eg.: +You can use tool lints to allow or deny lints from your code, eg.: - #[cfg_attr(feature = "cargo-clippy", allow(needless_lifetimes))] + #[allow(clippy::needless_lifetimes)] "#; -#[allow(print_stdout)] fn show_help() { println!("{}", CARGO_CLIPPY_HELP); } -#[allow(print_stdout)] fn show_version() { - println!("{}", env!("CARGO_PKG_VERSION")); + let version_info = rustc_tools_util::get_version_info!(); + println!("{}", version_info); } pub fn main() { @@ -54,144 +39,31 @@ pub fn main() { show_help(); return; } + if std::env::args().any(|a| a == "--version" || a == "-V") { show_version(); return; } - let mut manifest_path_arg = std::env::args() - .skip(2) - .skip_while(|val| !val.starts_with("--manifest-path")); - let manifest_path_arg = manifest_path_arg.next().and_then(|val| { - if val == "--manifest-path" { - manifest_path_arg.next() - } else if val.starts_with("--manifest-path=") { - Some(val["--manifest-path=".len()..].to_owned()) - } else { - None - } - }); - - let mut metadata = if let Ok(metadata) = cargo_metadata::metadata(manifest_path_arg.as_ref().map(AsRef::as_ref)) { - metadata - } else { - println!( - "{:?}", - cargo_metadata::metadata(manifest_path_arg.as_ref().map(AsRef::as_ref)) - ); - let _ = io::stderr().write_fmt(format_args!("error: Could not obtain cargo metadata.\n")); - process::exit(101); - }; - - let manifest_path = manifest_path_arg.map(|arg| { - PathBuf::from(arg) - .canonicalize() - .expect("manifest path could not be canonicalized") - }); - - let packages = if std::env::args().any(|a| a == "--all") { - metadata.packages - } else { - let package_index = { - if let Some(manifest_path) = manifest_path { - metadata.packages.iter().position(|package| { - let package_manifest_path = Path::new(&package.manifest_path) - .canonicalize() - .expect("package manifest path could not be canonicalized"); - package_manifest_path == manifest_path - }) - } else { - let package_manifest_paths: HashMap<_, _> = metadata - .packages - .iter() - .enumerate() - .map(|(i, package)| { - let package_manifest_path = Path::new(&package.manifest_path) - .parent() - .expect("could not find parent directory of package manifest") - .canonicalize() - .expect("package directory cannot be canonicalized"); - (package_manifest_path, i) - }) - .collect(); - - let current_dir = std::env::current_dir() - .expect("could not read current directory") - .canonicalize() - .expect("current directory cannot be canonicalized"); - - let mut current_path: &Path = ¤t_dir; - - // This gets the most-recent parent (the one that takes the fewest `cd ..`s to - // reach). - loop { - if let Some(&package_index) = package_manifest_paths.get(current_path) { - break Some(package_index); - } else { - // We'll never reach the filesystem root, because to get to this point in the - // code - // the call to `cargo_metadata::metadata` must have succeeded. So it's okay to - // unwrap the current path's parent. - current_path = current_path - .parent() - .unwrap_or_else(|| panic!("could not find parent of path {}", current_path.display())); - } - } - } - }.expect("could not find matching package"); - - vec![metadata.packages.remove(package_index)] - }; - - for package in packages { - let manifest_path = package.manifest_path; - - for target in package.targets { - let args = std::env::args() - .skip(1) - .filter(|a| a != "--all" && !a.starts_with("--manifest-path=")); - - let args = std::iter::once(format!("--manifest-path={}", manifest_path)).chain(args); - if let Some(first) = target.kind.get(0) { - if target.kind.len() > 1 || first.ends_with("lib") { - println!("lib: {}", target.name); - if let Err(code) = process(std::iter::once("--lib".to_owned()).chain(args)) { - std::process::exit(code); - } - } else if ["bin", "example", "test", "bench"].contains(&&**first) { - println!("{}: {}", first, target.name); - if let Err(code) = process( - vec![format!("--{}", first), target.name] - .into_iter() - .chain(args), - ) { - std::process::exit(code); - } - } - } else { - panic!("badly formatted cargo metadata: target::kind is an empty array"); - } - } + if let Err(code) = process(std::env::args().skip(2)) { + std::process::exit(code); } } -fn process(old_args: I) -> Result<(), i32> +fn process(mut old_args: I) -> Result<(), i32> where I: Iterator, { - let mut args = vec!["rustc".to_owned()]; + let mut args = vec!["check".to_owned()]; - let mut found_dashes = false; - for arg in old_args { - found_dashes |= arg == "--"; + for arg in old_args.by_ref() { + if arg == "--" { + break; + } args.push(arg); } - if !found_dashes { - args.push("--".to_owned()); - } - args.push("--emit=metadata".to_owned()); - args.push("--cfg".to_owned()); - args.push(r#"feature="cargo-clippy""#.to_owned()); + + let clippy_args: String = old_args.map(|arg| format!("{}__CLIPPY_HACKERY__", arg)).collect(); let mut path = std::env::current_exe() .expect("current executable path invalid") @@ -199,9 +71,32 @@ fn process(old_args: I) -> Result<(), i32> if cfg!(windows) { path.set_extension("exe"); } + + let target_dir = std::env::var_os("CLIPPY_DOGFOOD") + .map(|_| { + std::env::var_os("CARGO_MANIFEST_DIR").map_or_else( + || std::ffi::OsString::from("clippy_dogfood"), + |d| { + std::path::PathBuf::from(d) + .join("target") + .join("dogfood") + .into_os_string() + }, + ) + }) + .map(|p| ("CARGO_TARGET_DIR", p)); + + // Run the dogfood tests directly on nightly cargo. This is required due + // to a bug in rustup.rs when running cargo on custom toolchains. See issue #3118. + if std::env::var_os("CLIPPY_DOGFOOD").is_some() && cfg!(windows) { + args.insert(0, "+nightly".to_string()); + } + let exit_status = std::process::Command::new("cargo") .args(&args) .env("RUSTC_WRAPPER", path) + .env("CLIPPY_ARGS", clippy_args) + .envs(target_dir) .spawn() .expect("could not run cargo") .wait()