1 files changed, 161 insertions, 121 deletions

diff --git a/xtask/src/main.rs b/xtask/src/main.rs
index dec48629c..e419db7a7 100644
--- a/xtask/src/main.rs
+++ b/xtask/src/main.rs
@@ -7,57 +7,44 @@
 //!
 //! This binary is integrated into the `cargo` command line by using an alias in
 //! `.cargo/config`.
+mod flags;
 
-use std::env;
+mod codegen;
+mod ast_src;
+#[cfg(test)]
+mod tidy;
 
-use codegen::CodegenCmd;
-use pico_args::Arguments;
-use xshell::{cmd, cp, pushd};
-use xtask::{
-    codegen::{self, Mode},
+mod install;
+mod release;
+mod dist;
+mod metrics;
+mod pre_cache;
+
+use anyhow::{bail, Result};
+use std::{
+    env,
+    path::{Path, PathBuf},
+};
+use walkdir::{DirEntry, WalkDir};
+use xshell::{cmd, cp, pushd, pushenv};
+
+use crate::{
+    codegen::Mode,
     dist::DistCmd,
     install::{InstallCmd, Malloc, ServerOpt},
-    metrics::MetricsCmd,
-    pre_cache::PreCacheCmd,
-    pre_commit, project_root,
-    release::{PromoteCmd, ReleaseCmd},
-    run_clippy, run_fuzzer, run_rustfmt, Result,
 };
 
 fn main() -> Result<()> {
-    if env::args().next().map(|it| it.contains("pre-commit")) == Some(true) {
-        return pre_commit::run_hook();
-    }
-
     let _d = pushd(project_root())?;
 
-    let mut args = Arguments::from_env();
-    let subcommand = args.subcommand()?.unwrap_or_default();
-
-    match subcommand.as_str() {
-        "install" => {
-            if args.contains(["-h", "--help"]) {
-                eprintln!(
-                    "\
-cargo xtask install
-Install rust-analyzer server or editor plugin.
-
-USAGE:
-    cargo xtask install [FLAGS]
-
-FLAGS:
-        --client[=CLIENT] Install only VS Code plugin.
-                          CLIENT is one of 'code', 'code-exploration', 'code-insiders', 'codium', or 'code-oss'
-        --server          Install only the language server
-        --mimalloc        Use mimalloc for server
-    -h, --help            Prints help information
-        "
-                );
-                return Ok(());
-            }
-            let server = args.contains("--server");
-            let client_code = args.contains("--client");
-            if server && client_code {
+    let flags = flags::Xtask::from_env()?;
+    match flags.subcommand {
+        flags::XtaskCmd::Help(_) => {
+            println!("{}", flags::Xtask::HELP);
+            return Ok(());
+        }
+        flags::XtaskCmd::Install(flags) => {
+            if flags.server && flags.client {
                 eprintln!(
                     "error: The argument `--server` cannot be used with `--client`\n\n\
                      For more information try --help"
@@ -65,93 +52,146 @@ FLAGS:
                 return Ok(());
             }
 
-            let malloc =
-                if args.contains("--mimalloc") { Malloc::Mimalloc } else { Malloc::System };
+            let malloc = if flags.mimalloc {
+                Malloc::Mimalloc
+            } else if flags.jemalloc {
+                Malloc::Jemalloc
+            } else {
+                Malloc::System
+            };
 
-            let client_opt = args.opt_value_from_str("--client")?;
-
-            args.finish()?;
+            let client_bin = flags.code_bin.map(|it| it.parse()).transpose()?;
 
             InstallCmd {
-                client: if server { None } else { Some(client_opt.unwrap_or_default()) },
-                server: if client_code { None } else { Some(ServerOpt { malloc }) },
+                client: if flags.server { None } else { client_bin },
+                server: if flags.client { None } else { Some(ServerOpt { malloc }) },
             }
             .run()
         }
-        "codegen" => {
-            let features = args.contains("--features");
-            args.finish()?;
-            CodegenCmd { features }.run()
-        }
-        "format" => {
-            args.finish()?;
-            run_rustfmt(Mode::Overwrite)
-        }
-        "install-pre-commit-hook" => {
-            args.finish()?;
-            pre_commit::install_hook()
+        flags::XtaskCmd::Codegen(cmd) => cmd.run(),
+        flags::XtaskCmd::Lint(_) => run_clippy(),
+        flags::XtaskCmd::FuzzTests(_) => run_fuzzer(),
+        flags::XtaskCmd::PreCache(cmd) => cmd.run(),
+        flags::XtaskCmd::Release(cmd) => cmd.run(),
+        flags::XtaskCmd::Promote(cmd) => cmd.run(),
+        flags::XtaskCmd::Dist(flags) => {
+            DistCmd { nightly: flags.nightly, client_version: flags.client }.run()
         }
-        "lint" => {
-            args.finish()?;
-            run_clippy()
-        }
-        "fuzz-tests" => {
-            args.finish()?;
-            run_fuzzer()
-        }
-        "pre-cache" => {
-            args.finish()?;
-            PreCacheCmd.run()
-        }
-        "release" => {
-            let dry_run = args.contains("--dry-run");
-            args.finish()?;
-            ReleaseCmd { dry_run }.run()
-        }
-        "promote" => {
-            let dry_run = args.contains("--dry-run");
-            args.finish()?;
-            PromoteCmd { dry_run }.run()
-        }
-        "dist" => {
-            let nightly = args.contains("--nightly");
-            let client_version: Option<String> = args.opt_value_from_str("--client")?;
-            args.finish()?;
-            DistCmd { nightly, client_version }.run()
-        }
-        "metrics" => {
-            let dry_run = args.contains("--dry-run");
-            args.finish()?;
-            MetricsCmd { dry_run }.run()
-        }
-        "bb" => {
-            let suffix: String = args.free_from_str()?.unwrap();
-            args.finish()?;
-            cmd!("cargo build --release").run()?;
-            cp("./target/release/rust-analyzer", format!("./target/rust-analyzer-{}", suffix))?;
-            Ok(())
-        }
-        _ => {
-            eprintln!(
-                "\
-cargo xtask
-Run custom build command.
-
-USAGE:
-    cargo xtask <SUBCOMMAND>
-
-SUBCOMMANDS:
-    format
-    install-pre-commit-hook
-    fuzz-tests
-    codegen
-    install
-    lint
-    dist
-    promote
-    bb"
-            );
+        flags::XtaskCmd::Metrics(cmd) => cmd.run(),
+        flags::XtaskCmd::Bb(cmd) => {
+            {
+                let _d = pushd("./crates/rust-analyzer")?;
+                cmd!("cargo build --release --features jemalloc").run()?;
+            }
+            cp("./target/release/rust-analyzer", format!("./target/rust-analyzer-{}", cmd.suffix))?;
             Ok(())
         }
     }
 }
+
+fn project_root() -> PathBuf {
+    Path::new(
+        &env::var("CARGO_MANIFEST_DIR").unwrap_or_else(|_| env!("CARGO_MANIFEST_DIR").to_owned()),
+    )
+    .ancestors()
+    .nth(1)
+    .unwrap()
+    .to_path_buf()
+}
+
+fn rust_files() -> impl Iterator<Item = PathBuf> {
+    rust_files_in(&project_root().join("crates"))
+}
+
+#[cfg(test)]
+fn cargo_files() -> impl Iterator<Item = PathBuf> {
+    files_in(&project_root(), "toml")
+        .filter(|path| path.file_name().map(|it| it == "Cargo.toml").unwrap_or(false))
+}
+
+fn rust_files_in(path: &Path) -> impl Iterator<Item = PathBuf> {
+    files_in(path, "rs")
+}
+
+fn run_rustfmt(mode: Mode) -> Result<()> {
+    let _dir = pushd(project_root())?;
+    let _e = pushenv("RUSTUP_TOOLCHAIN", "stable");
+    ensure_rustfmt()?;
+    let check = match mode {
+        Mode::Overwrite => &[][..],
+        Mode::Verify => &["--", "--check"],
+    };
+    cmd!("cargo fmt {check...}").run()?;
+    Ok(())
+}
+
+fn ensure_rustfmt() -> Result<()> {
+    let out = cmd!("rustfmt --version").read()?;
+    if !out.contains("stable") {
+        bail!(
+            "Failed to run rustfmt from toolchain 'stable'. \
+             Please run `rustup component add rustfmt --toolchain stable` to install it.",
+        )
+    }
+    Ok(())
+}
+
+fn run_clippy() -> Result<()> {
+    if cmd!("cargo clippy --version").read().is_err() {
+        bail!(
+            "Failed run cargo clippy. \
+            Please run `rustup component add clippy` to install it.",
+        )
+    }
+
+    let allowed_lints = "
+        -A clippy::collapsible_if
+        -A clippy::needless_pass_by_value
+        -A clippy::nonminimal_bool
+        -A clippy::redundant_pattern_matching
+    "
+    .split_ascii_whitespace();
+    cmd!("cargo clippy --all-features --all-targets -- {allowed_lints...}").run()?;
+    Ok(())
+}
+
+fn run_fuzzer() -> Result<()> {
+    let _d = pushd("./crates/syntax")?;
+    let _e = pushenv("RUSTUP_TOOLCHAIN", "nightly");
+    if cmd!("cargo fuzz --help").read().is_err() {
+        cmd!("cargo install cargo-fuzz").run()?;
+    };
+
+    // Expecting nightly rustc
+    let out = cmd!("rustc --version").read()?;
+    if !out.contains("nightly") {
+        bail!("fuzz tests require nightly rustc")
+    }
+
+    cmd!("cargo fuzz run parser").run()?;
+    Ok(())
+}
+
+fn date_iso() -> Result<String> {
+    let res = cmd!("date --iso --utc").read()?;
+    Ok(res)
+}
+
+fn is_release_tag(tag: &str) -> bool {
+    tag.len() == "2020-02-24".len() && tag.starts_with(|c: char| c.is_ascii_digit())
+}
+
+fn files_in(path: &Path, ext: &'static str) -> impl Iterator<Item = PathBuf> {
+    let iter = WalkDir::new(path);
+    return iter
+        .into_iter()
+        .filter_entry(|e| !is_hidden(e))
+        .map(|e| e.unwrap())
+        .filter(|e| !e.file_type().is_dir())
+        .map(|e| e.into_path())
+        .filter(move |path| path.extension().map(|it| it == ext).unwrap_or(false));
+
+    fn is_hidden(entry: &DirEntry) -> bool {
+        entry.file_name().to_str().map(|s| s.starts_with('.')).unwrap_or(false)
+    }
+}