19 files changed, 478 insertions, 456 deletions
diff --git a/xtask/Cargo.toml b/xtask/Cargo.toml
index 4abc7b053..b17dde598 100644
--- a/xtask/Cargo.toml
+++ b/xtask/Cargo.toml
@@ -6,17 +6,14 @@ authors = ["rust-analyzer developers"]
 publish = false
 license = "MIT OR Apache-2.0"
-[lib]
-doctest = false
 [dependencies]
 anyhow = "1.0.26"
 flate2 = "1.0"
-pico-args = "0.3.1"
 proc-macro2 = "1.0.8"
 quote = "1.0.2"
-ungrammar = "1.9"
+ungrammar = "=1.11"
 walkdir = "2.3.1"
 write-json = "0.1.0"
 xshell = "0.1"
+xflags = "0.1.2"
 # Avoid adding more dependencies to this crate
diff --git a/xtask/src/codegen.rs b/xtask/src/codegen.rs
index adea053b6..2f56c5ad0 100644
--- a/xtask/src/codegen.rs
+++ b/xtask/src/codegen.rs
@@ -18,9 +18,9 @@ use std::{
 };
 use xshell::{cmd, pushenv, read_file, write_file};
-use crate::{ensure_rustfmt, project_root, Result};
+use crate::{ensure_rustfmt, flags, project_root, Result};
-pub use self::{
+pub(crate) use self::{
    gen_assists_docs::{generate_assists_docs, generate_assists_tests},
    gen_diagnostic_docs::generate_diagnostic_docs,
    gen_feature_docs::generate_feature_docs,
@@ -30,17 +30,13 @@ pub use self::{
 };
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
-pub enum Mode {
+pub(crate) enum Mode {
    Overwrite,
    Verify,
 }
-pub struct CodegenCmd {
+impl flags::Codegen {
-    pub features: bool,
+    pub(crate) fn run(self) -> Result<()> {
-}
-impl CodegenCmd {
-    pub fn run(self) -> Result<()> {
        if self.features {
            generate_lint_completions(Mode::Overwrite)?;
        }
diff --git a/xtask/src/codegen/gen_assists_docs.rs b/xtask/src/codegen/gen_assists_docs.rs
index 6e18a50a6..c469b388d 100644
--- a/xtask/src/codegen/gen_assists_docs.rs
+++ b/xtask/src/codegen/gen_assists_docs.rs
@@ -4,15 +4,15 @@ use std::{fmt, path::Path};
 use crate::{
    codegen::{self, extract_comment_blocks_with_empty_lines, reformat, Location, Mode, PREAMBLE},
-    project_root, rust_files, Result,
+    project_root, rust_files_in, Result,
 };
-pub fn generate_assists_tests(mode: Mode) -> Result<()> {
+pub(crate) fn generate_assists_tests(mode: Mode) -> Result<()> {
    let assists = Assist::collect()?;
    generate_tests(&assists, mode)
 }
-pub fn generate_assists_docs(mode: Mode) -> Result<()> {
+pub(crate) fn generate_assists_docs(mode: Mode) -> Result<()> {
    let assists = Assist::collect()?;
    let contents = assists.into_iter().map(|it| it.to_string()).collect::<Vec<_>>().join("\n\n");
    let contents = format!("//{}\n{}\n", PREAMBLE, contents.trim());
@@ -32,7 +32,7 @@ struct Assist {
 impl Assist {
    fn collect() -> Result<Vec<Assist>> {
        let mut res = Vec::new();
-        for path in rust_files(&project_root().join("crates/assists/src/handlers")) {
+        for path in rust_files_in(&project_root().join("crates/ide_assists/src/handlers")) {
            collect_file(&mut res, path.as_path())?;
        }
        res.sort_by(|lhs, rhs| lhs.id.cmp(&rhs.id));
@@ -135,7 +135,7 @@ r#####"
        buf.push_str(&test)
    }
    let buf = reformat(&buf)?;
-    codegen::update(&project_root().join("crates/assists/src/tests/generated.rs"), &buf, mode)
+    codegen::update(&project_root().join("crates/ide_assists/src/tests/generated.rs"), &buf, mode)
 }
 fn hide_hash_comments(text: &str) -> String {
diff --git a/xtask/src/codegen/gen_diagnostic_docs.rs b/xtask/src/codegen/gen_diagnostic_docs.rs
index 00aaea5b7..a2561817b 100644
--- a/xtask/src/codegen/gen_diagnostic_docs.rs
+++ b/xtask/src/codegen/gen_diagnostic_docs.rs
@@ -7,7 +7,7 @@ use crate::{
    project_root, rust_files, Result,
 };
-pub fn generate_diagnostic_docs(mode: Mode) -> Result<()> {
+pub(crate) fn generate_diagnostic_docs(mode: Mode) -> Result<()> {
    let diagnostics = Diagnostic::collect()?;
    let contents =
        diagnostics.into_iter().map(|it| it.to_string()).collect::<Vec<_>>().join("\n\n");
@@ -27,7 +27,7 @@ struct Diagnostic {
 impl Diagnostic {
    fn collect() -> Result<Vec<Diagnostic>> {
        let mut res = Vec::new();
-        for path in rust_files(&project_root()) {
+        for path in rust_files() {
            collect_file(&mut res, path)?;
        }
        res.sort_by(|lhs, rhs| lhs.id.cmp(&rhs.id));
diff --git a/xtask/src/codegen/gen_feature_docs.rs b/xtask/src/codegen/gen_feature_docs.rs
index 065dd33f1..cad7ff477 100644
--- a/xtask/src/codegen/gen_feature_docs.rs
+++ b/xtask/src/codegen/gen_feature_docs.rs
@@ -7,7 +7,7 @@ use crate::{
    project_root, rust_files, Result,
 };
-pub fn generate_feature_docs(mode: Mode) -> Result<()> {
+pub(crate) fn generate_feature_docs(mode: Mode) -> Result<()> {
    let features = Feature::collect()?;
    let contents = features.into_iter().map(|it| it.to_string()).collect::<Vec<_>>().join("\n\n");
    let contents = format!("//{}\n{}\n", PREAMBLE, contents.trim());
@@ -26,7 +26,7 @@ struct Feature {
 impl Feature {
    fn collect() -> Result<Vec<Feature>> {
        let mut res = Vec::new();
-        for path in rust_files(&project_root()) {
+        for path in rust_files() {
            collect_file(&mut res, path)?;
        }
        res.sort_by(|lhs, rhs| lhs.id.cmp(&rhs.id));
diff --git a/xtask/src/codegen/gen_features.rs b/xtask/src/codegen/gen_features.rs
deleted file mode 100644
index 3cf15ce02..000000000
--- a/xtask/src/codegen/gen_features.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-//! Generates descriptors structure for unstable feature from Unstable Book
-use std::path::{Path, PathBuf};
-use quote::quote;
-use walkdir::WalkDir;
-use xshell::{cmd, read_file};
-use crate::codegen::{project_root, reformat, update, Mode, Result};
-pub fn generate_features(mode: Mode) -> Result<()> {
-    if !Path::new("./target/rust").exists() {
-        cmd!("git clone https://github.com/rust-lang/rust ./target/rust").run()?;
-    }
-    let contents = generate_descriptor("./target/rust/src/doc/unstable-book/src".into())?;
-    let destination = project_root().join("crates/ide/src/completion/generated_features.rs");
-    update(destination.as_path(), &contents, mode)?;
-    Ok(())
-}
-fn generate_descriptor(src_dir: PathBuf) -> Result<String> {
-    let definitions = ["language-features", "library-features"]
-        .iter()
-        .flat_map(|it| WalkDir::new(src_dir.join(it)))
-        .filter_map(|e| e.ok())
-        .filter(|entry| {
-            // Get all `.md ` files
-            entry.file_type().is_file() && entry.path().extension().unwrap_or_default() == "md"
-        })
-        .map(|entry| {
-            let path = entry.path();
-            let feature_ident = path.file_stem().unwrap().to_str().unwrap().replace("-", "_");
-            let doc = read_file(path).unwrap();
-            quote! { LintCompletion { label: #feature_ident, description: #doc } }
-        });
-    let ts = quote! {
-        use crate::completion::complete_attribute::LintCompletion;
-        pub(super) const FEATURES:  &[LintCompletion] = &[
-            #(#definitions),*
-        ];
-    };
-    reformat(&ts.to_string())
-}
diff --git a/xtask/src/codegen/gen_lint_completions.rs b/xtask/src/codegen/gen_lint_completions.rs
index b97421217..b1c057037 100644
--- a/xtask/src/codegen/gen_lint_completions.rs
+++ b/xtask/src/codegen/gen_lint_completions.rs
@@ -1,7 +1,7 @@
 //! Generates descriptors structure for unstable feature from Unstable Book
+use std::fmt::Write;
 use std::path::{Path, PathBuf};
-use quote::quote;
 use walkdir::WalkDir;
 use xshell::{cmd, read_file};
@@ -10,31 +10,31 @@ use crate::{
    run_rustfmt,
 };
-pub fn generate_lint_completions(mode: Mode) -> Result<()> {
+pub(crate) fn generate_lint_completions(mode: Mode) -> Result<()> {
    if !Path::new("./target/rust").exists() {
        cmd!("git clone --depth=1 https://github.com/rust-lang/rust ./target/rust").run()?;
    }
-    let ts_features = generate_descriptor("./target/rust/src/doc/unstable-book/src".into())?;
+    let mut contents = String::from("use crate::completions::attribute::LintCompletion;\n\n");
-    cmd!("curl http://rust-lang.github.io/rust-clippy/master/lints.json --output ./target/clippy_lints.json").run()?;
+    generate_descriptor(&mut contents, "./target/rust/src/doc/unstable-book/src".into())?;
+    contents.push('\n');
-    let ts_clippy = generate_descriptor_clippy(&Path::new("./target/clippy_lints.json"))?;
+    cmd!("curl http://rust-lang.github.io/rust-clippy/master/lints.json --output ./target/clippy_lints.json").run()?;
-    let ts = quote! {
+    generate_descriptor_clippy(&mut contents, &Path::new("./target/clippy_lints.json"))?;
-        use crate::completions::attribute::LintCompletion;
+    let contents = reformat(&contents)?;
-        #ts_features
-        #ts_clippy
-    };
-    let contents = reformat(ts.to_string().as_str())?;
-    let destination = project_root().join("crates/completion/src/generated_lint_completions.rs");
+    let destination =
+        project_root().join("crates/ide_completion/src/generated_lint_completions.rs");
    update(destination.as_path(), &contents, mode)?;
    run_rustfmt(mode)?;
    Ok(())
 }
-fn generate_descriptor(src_dir: PathBuf) -> Result<proc_macro2::TokenStream> {
+fn generate_descriptor(buf: &mut String, src_dir: PathBuf) -> Result<()> {
-    let definitions = ["language-features", "library-features"]
+    buf.push_str(r#"pub(super) const FEATURES: &[LintCompletion] = &["#);
+    buf.push('\n');
+    ["language-features", "library-features"]
        .iter()
        .flat_map(|it| WalkDir::new(src_dir.join(it)))
        .filter_map(|e| e.ok())
@@ -42,21 +42,15 @@ fn generate_descriptor(src_dir: PathBuf) -> Result<proc_macro2::TokenStream> {
            // Get all `.md ` files
            entry.file_type().is_file() && entry.path().extension().unwrap_or_default() == "md"
        })
-        .map(|entry| {
+        .for_each(|entry| {
            let path = entry.path();
            let feature_ident = path.file_stem().unwrap().to_str().unwrap().replace("-", "_");
            let doc = read_file(path).unwrap();
-            quote! { LintCompletion { label: #feature_ident, description: #doc } }
+            push_lint_completion(buf, &feature_ident, &doc);
        });
+    buf.push_str("];\n");
-    let ts = quote! {
+    Ok(())
-        pub(super) const FEATURES:  &[LintCompletion] = &[
-            #(#definitions),*
-        ];
-    };
-    Ok(ts)
 }
 #[derive(Default)]
@@ -65,7 +59,7 @@ struct ClippyLint {
    id: String,
 }
-fn generate_descriptor_clippy(path: &Path) -> Result<proc_macro2::TokenStream> {
+fn generate_descriptor_clippy(buf: &mut String, path: &Path) -> Result<()> {
    let file_content = read_file(path)?;
    let mut clippy_lints: Vec<ClippyLint> = vec![];
@@ -96,18 +90,27 @@ fn generate_descriptor_clippy(path: &Path) -> Result<proc_macro2::TokenStream> {
        }
    }
-    let definitions = clippy_lints.into_iter().map(|clippy_lint| {
+    buf.push_str(r#"pub(super) const CLIPPY_LINTS: &[LintCompletion] = &["#);
+    buf.push('\n');
+    clippy_lints.into_iter().for_each(|clippy_lint| {
        let lint_ident = format!("clippy::{}", clippy_lint.id);
        let doc = clippy_lint.help;
+        push_lint_completion(buf, &lint_ident, &doc);
-        quote! { LintCompletion { label: #lint_ident, description: #doc } }
    });
-    let ts = quote! {
+    buf.push_str("];\n");
-        pub(super) const CLIPPY_LINTS:  &[LintCompletion] = &[
-            #(#definitions),*
+    Ok(())
-        ];
+}
-    };
-    Ok(ts)
+fn push_lint_completion(buf: &mut String, label: &str, description: &str) {
+    writeln!(
+        buf,
+        r###"    LintCompletion {{
+        label: "{}",
+        description: r##"{}"##
+    }},"###,
+        label, description
+    )
+    .unwrap();
 }
diff --git a/xtask/src/codegen/gen_parser_tests.rs b/xtask/src/codegen/gen_parser_tests.rs
index 6e4abd10c..cb8939063 100644
--- a/xtask/src/codegen/gen_parser_tests.rs
+++ b/xtask/src/codegen/gen_parser_tests.rs
@@ -12,7 +12,7 @@ use crate::{
    project_root, Result,
 };
-pub fn generate_parser_tests(mode: Mode) -> Result<()> {
+pub(crate) fn generate_parser_tests(mode: Mode) -> Result<()> {
    let tests = tests_from_dir(&project_root().join(Path::new("crates/parser/src/grammar")))?;
    fn install_tests(tests: &HashMap<String, Test>, into: &str, mode: Mode) -> Result<()> {
        let tests_dir = project_root().join(into);
diff --git a/xtask/src/codegen/gen_syntax.rs b/xtask/src/codegen/gen_syntax.rs
index eb524d85a..191bc0e9d 100644
--- a/xtask/src/codegen/gen_syntax.rs
+++ b/xtask/src/codegen/gen_syntax.rs
@@ -18,7 +18,7 @@ use crate::{
    project_root, Result,
 };
-pub fn generate_syntax(mode: Mode) -> Result<()> {
+pub(crate) fn generate_syntax(mode: Mode) -> Result<()> {
    let grammar = rust_grammar();
    let ast = lower(&grammar);
diff --git a/xtask/src/dist.rs b/xtask/src/dist.rs
index 6bc34106b..f2503f807 100644
--- a/xtask/src/dist.rs
+++ b/xtask/src/dist.rs
@@ -11,13 +11,13 @@ use xshell::{cmd, cp, mkdir_p, pushd, read_file, rm_rf, write_file};
 use crate::{date_iso, project_root};
-pub struct DistCmd {
+pub(crate) struct DistCmd {
-    pub nightly: bool,
+    pub(crate) nightly: bool,
-    pub client_version: Option<String>,
+    pub(crate) client_version: Option<String>,
 }
 impl DistCmd {
-    pub fn run(self) -> Result<()> {
+    pub(crate) fn run(self) -> Result<()> {
        let dist = project_root().join("dist");
        rm_rf(&dist)?;
        mkdir_p(&dist)?;
@@ -59,7 +59,7 @@ fn dist_client(version: &str, release_tag: &str) -> Result<()> {
 fn dist_server() -> Result<()> {
    let target = get_target();
-    if target.contains("-linux-gnu") {
+    if target.contains("-linux-gnu") || target.contains("-linux-musl") {
        env::set_var("CC", "clang");
    }
diff --git a/xtask/src/flags.rs b/xtask/src/flags.rs
new file mode 100644
index 000000000..5710fbdb5
--- /dev/null
+++ b/xtask/src/flags.rs
@@ -0,0 +1,139 @@
+#![allow(unreachable_pub)]
+xflags::args_parser! {
+    /// Run custom build command.
+    cmd xtask {
+        default cmd help {
+            /// Print help information.
+            optional -h, --help
+        }
+        /// Install rust-analyzer server or editor plugin.
+        cmd install {
+            /// Install only VS Code plugin.
+            optional --client
+            /// One of 'code', 'code-exploration', 'code-insiders', 'codium', or 'code-oss'.
+            optional --code-bin name: String
+            /// Install only the language server.
+            optional --server
+            /// Use mimalloc allocator for server
+            optional --mimalloc
+            /// Use jemalloc allocator for server
+            optional --jemalloc
+        }
+        cmd codegen {
+            optional --features
+        }
+        cmd lint {}
+        cmd fuzz-tests {}
+        cmd pre-cache {}
+        cmd release {
+            optional --dry-run
+        }
+        cmd promote {
+            optional --dry-run
+        }
+        cmd dist {
+            optional --nightly
+            optional --client version: String
+        }
+        cmd metrics {
+            optional --dry-run
+        }
+        /// Builds a benchmark version of rust-analyzer and puts it into `./target`.
+        cmd bb
+            required suffix: String
+        {}
+    }
+}
+// generated start
+// The following code is generated by `xflags` macro.
+// Run `env XFLAGS_DUMP= cargo build` to regenerate.
+#[derive(Debug)]
+pub struct Xtask {
+    pub subcommand: XtaskCmd,
+}
+#[derive(Debug)]
+pub enum XtaskCmd {
+    Help(Help),
+    Install(Install),
+    Codegen(Codegen),
+    Lint(Lint),
+    FuzzTests(FuzzTests),
+    PreCache(PreCache),
+    Release(Release),
+    Promote(Promote),
+    Dist(Dist),
+    Metrics(Metrics),
+    Bb(Bb),
+}
+#[derive(Debug)]
+pub struct Help {
+    pub help: bool,
+}
+#[derive(Debug)]
+pub struct Install {
+    pub client: bool,
+    pub code_bin: Option<String>,
+    pub server: bool,
+    pub mimalloc: bool,
+    pub jemalloc: bool,
+}
+#[derive(Debug)]
+pub struct Codegen {
+    pub features: bool,
+}
+#[derive(Debug)]
+pub struct Lint {}
+#[derive(Debug)]
+pub struct FuzzTests {}
+#[derive(Debug)]
+pub struct PreCache {}
+#[derive(Debug)]
+pub struct Release {
+    pub dry_run: bool,
+}
+#[derive(Debug)]
+pub struct Promote {
+    pub dry_run: bool,
+}
+#[derive(Debug)]
+pub struct Dist {
+    pub nightly: bool,
+    pub client: Option<String>,
+}
+#[derive(Debug)]
+pub struct Metrics {
+    pub dry_run: bool,
+}
+#[derive(Debug)]
+pub struct Bb {
+    pub suffix: String,
+}
+impl Xtask {
+    pub const HELP: &'static str = Self::_HELP;
+    pub fn from_env() -> xflags::Result<Self> {
+        let mut p = xflags::rt::Parser::new_from_env();
+        Self::_parse(&mut p)
+    }
+}
+// generated end
diff --git a/xtask/src/install.rs b/xtask/src/install.rs
index 12962bcfa..ea2194248 100644
--- a/xtask/src/install.rs
+++ b/xtask/src/install.rs
@@ -6,15 +6,15 @@ use anyhow::{bail, format_err, Context, Result};
 use xshell::{cmd, pushd};
 // Latest stable, feel free to send a PR if this lags behind.
-const REQUIRED_RUST_VERSION: u32 = 47;
+const REQUIRED_RUST_VERSION: u32 = 50;
-pub struct InstallCmd {
+pub(crate) struct InstallCmd {
-    pub client: Option<ClientOpt>,
+    pub(crate) client: Option<ClientOpt>,
-    pub server: Option<ServerOpt>,
+    pub(crate) server: Option<ServerOpt>,
 }
 #[derive(Clone, Copy)]
-pub enum ClientOpt {
+pub(crate) enum ClientOpt {
    VsCode,
    VsCodeExploration,
    VsCodeInsiders,
@@ -24,7 +24,7 @@ pub enum ClientOpt {
 }
 impl ClientOpt {
-    pub const fn as_cmds(&self) -> &'static [&'static str] {
+    pub(crate) const fn as_cmds(&self) -> &'static [&'static str] {
        match self {
            ClientOpt::VsCode => &["code"],
            ClientOpt::VsCodeExploration => &["code-exploration"],
@@ -60,17 +60,18 @@ impl std::str::FromStr for ClientOpt {
    }
 }
-pub struct ServerOpt {
+pub(crate) struct ServerOpt {
-    pub malloc: Malloc,
+    pub(crate) malloc: Malloc,
 }
-pub enum Malloc {
+pub(crate) enum Malloc {
    System,
    Mimalloc,
+    Jemalloc,
 }
 impl InstallCmd {
-    pub fn run(self) -> Result<()> {
+    pub(crate) fn run(self) -> Result<()> {
        if cfg!(target_os = "macos") {
            fix_path_for_mac().context("Fix path for mac")?
        }
@@ -128,7 +129,7 @@ fn install_client(client_opt: ClientOpt) -> Result<()> {
    let installed_extensions = if cfg!(unix) {
        cmd!("npm --version").run().context("`npm` is required to build the VS Code plugin")?;
-        cmd!("npm install").run()?;
+        cmd!("npm ci").run()?;
        cmd!("npm run package --scripts-prepend-node-path").run()?;
@@ -139,7 +140,7 @@ fn install_client(client_opt: ClientOpt) -> Result<()> {
        cmd!("cmd.exe /c npm --version")
            .run()
            .context("`npm` is required to build the VS Code plugin")?;
-        cmd!("cmd.exe /c npm install").run()?;
+        cmd!("cmd.exe /c npm ci").run()?;
        cmd!("cmd.exe /c npm run package").run()?;
@@ -176,9 +177,10 @@ fn install_server(opts: ServerOpt) -> Result<()> {
    let features = match opts.malloc {
        Malloc::System => &[][..],
        Malloc::Mimalloc => &["--features", "mimalloc"],
+        Malloc::Jemalloc => &["--features", "jemalloc"],
    };
-    let cmd = cmd!("cargo install --path crates/rust-analyzer --locked --force {features...}");
+    let cmd = cmd!("cargo install --path crates/rust-analyzer --locked --force --features force-always-assert {features...}");
    let res = cmd.run();
    if res.is_err() && old_rust {
diff --git a/xtask/src/lib.rs b/xtask/src/lib.rs
deleted file mode 100644
index babec2dbd..000000000
--- a/xtask/src/lib.rs
+++ /dev/null
@@ -1,118 +0,0 @@
-//! Support library for `cargo xtask` command.
-//!
-//! See https://github.com/matklad/cargo-xtask/
-pub mod codegen;
-mod ast_src;
-pub mod install;
-pub mod release;
-pub mod dist;
-pub mod pre_commit;
-pub mod metrics;
-pub mod pre_cache;
-use std::{
-    env,
-    path::{Path, PathBuf},
-};
-use walkdir::{DirEntry, WalkDir};
-use xshell::{cmd, pushd, pushenv};
-use crate::codegen::Mode;
-pub use anyhow::{bail, Context as _, Result};
-pub 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()
-}
-pub fn rust_files(path: &Path) -> 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(|path| path.extension().map(|it| it == "rs").unwrap_or(false));
-    fn is_hidden(entry: &DirEntry) -> bool {
-        entry.file_name().to_str().map(|s| s.starts_with('.')).unwrap_or(false)
-    }
-}
-pub 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(())
-}
-pub 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(())
-}
-pub 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())
-}
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;
+mod install;
-use pico_args::Arguments;
+mod release;
-use xshell::{cmd, cp, pushd};
+mod dist;
-use xtask::{
+mod metrics;
-    codegen::{self, Mode},
+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 flags = flags::Xtask::from_env()?;
-    let subcommand = args.subcommand()?.unwrap_or_default();
+    match flags.subcommand {
+        flags::XtaskCmd::Help(_) => {
-    match subcommand.as_str() {
+            println!("{}", flags::Xtask::HELP);
-        "install" => {
+            return Ok(());
-            if args.contains(["-h", "--help"]) {
+        }
-                eprintln!(
+        flags::XtaskCmd::Install(flags) => {
-                    "\
+            if flags.server && flags.client {
-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 {
                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 =
+            let malloc = if flags.mimalloc {
-                if args.contains("--mimalloc") { Malloc::Mimalloc } else { Malloc::System };
+                Malloc::Mimalloc
+            } else if flags.jemalloc {
+                Malloc::Jemalloc
+            } else {
+                Malloc::System
+            };
-            let client_opt = args.opt_value_from_str("--client")?;
+            let client_bin = flags.code_bin.map(|it| it.parse()).transpose()?;
-            args.finish()?;
            InstallCmd {
-                client: if server { None } else { Some(client_opt.unwrap_or_default()) },
+                client: if flags.server { None } else { client_bin },
-                server: if client_code { None } else { Some(ServerOpt { malloc }) },
+                server: if flags.client { None } else { Some(ServerOpt { malloc }) },
            }
            .run()
        }
-        "codegen" => {
+        flags::XtaskCmd::Codegen(cmd) => cmd.run(),
-            let features = args.contains("--features");
+        flags::XtaskCmd::Lint(_) => run_clippy(),
-            args.finish()?;
+        flags::XtaskCmd::FuzzTests(_) => run_fuzzer(),
-            CodegenCmd { features }.run()
+        flags::XtaskCmd::PreCache(cmd) => cmd.run(),
-        }
+        flags::XtaskCmd::Release(cmd) => cmd.run(),
-        "format" => {
+        flags::XtaskCmd::Promote(cmd) => cmd.run(),
-            args.finish()?;
+        flags::XtaskCmd::Dist(flags) => {
-            run_rustfmt(Mode::Overwrite)
+            DistCmd { nightly: flags.nightly, client_version: flags.client }.run()
-        }
-        "install-pre-commit-hook" => {
-            args.finish()?;
-            pre_commit::install_hook()
        }
-        "lint" => {
+        flags::XtaskCmd::Metrics(cmd) => cmd.run(),
-            args.finish()?;
+        flags::XtaskCmd::Bb(cmd) => {
-            run_clippy()
+            {
-        }
+                let _d = pushd("./crates/rust-analyzer")?;
-        "fuzz-tests" => {
+                cmd!("cargo build --release --features jemalloc").run()?;
-            args.finish()?;
+            }
-            run_fuzzer()
+            cp("./target/release/rust-analyzer", format!("./target/rust-analyzer-{}", cmd.suffix))?;
-        }
-        "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"
-            );
            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)
+    }
+}
diff --git a/xtask/src/metrics.rs b/xtask/src/metrics.rs
index 624ad3b7e..eb58b3274 100644
--- a/xtask/src/metrics.rs
+++ b/xtask/src/metrics.rs
@@ -9,14 +9,12 @@ use std::{
 use anyhow::{bail, format_err, Result};
 use xshell::{cmd, mkdir_p, pushd, pushenv, read_file, rm_rf};
-type Unit = String;
+use crate::flags;
-pub struct MetricsCmd {
+type Unit = String;
-    pub dry_run: bool,
-}
-impl MetricsCmd {
+impl flags::Metrics {
-    pub fn run(self) -> Result<()> {
+    pub(crate) fn run(self) -> Result<()> {
        let mut metrics = Metrics::new()?;
        if !self.dry_run {
            rm_rf("./target/release")?;
diff --git a/xtask/src/pre_cache.rs b/xtask/src/pre_cache.rs
index 569f88f68..b456224fd 100644
--- a/xtask/src/pre_cache.rs
+++ b/xtask/src/pre_cache.rs
@@ -6,12 +6,12 @@ use std::{
 use anyhow::Result;
 use xshell::rm_rf;
-pub struct PreCacheCmd;
+use crate::flags;
-impl PreCacheCmd {
+impl flags::PreCache {
    /// Cleans the `./target` dir after the build such that only
    /// dependencies are cached on CI.
-    pub fn run(self) -> Result<()> {
+    pub(crate) fn run(self) -> Result<()> {
        let slow_tests_cookie = Path::new("./target/.slow_tests_cookie");
        if !slow_tests_cookie.exists() {
            panic!("slow tests were skipped on CI!")
diff --git a/xtask/src/pre_commit.rs b/xtask/src/pre_commit.rs
deleted file mode 100644
index 8f2dbea19..000000000
--- a/xtask/src/pre_commit.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-//! pre-commit hook for code formatting.
-use std::{fs, path::PathBuf};
-use anyhow::{bail, Result};
-use xshell::cmd;
-use crate::{project_root, run_rustfmt, Mode};
-// FIXME: if there are changed `.ts` files, also reformat TypeScript (by
-// shelling out to `npm fmt`).
-pub fn run_hook() -> Result<()> {
-    run_rustfmt(Mode::Overwrite)?;
-    let diff = cmd!("git diff --diff-filter=MAR --name-only --cached").read()?;
-    let root = project_root();
-    for line in diff.lines() {
-        let file = root.join(line);
-        cmd!("git update-index --add {file}").run()?;
-    }
-    Ok(())
-}
-pub fn install_hook() -> Result<()> {
-    let hook_path: PathBuf =
-        format!("./.git/hooks/pre-commit{}", std::env::consts::EXE_SUFFIX).into();
-    if hook_path.exists() {
-        bail!("Git hook already created");
-    }
-    let me = std::env::current_exe()?;
-    fs::copy(me, hook_path)?;
-    Ok(())
-}
diff --git a/xtask/src/release.rs b/xtask/src/release.rs
index 2d716253e..d8d86fd63 100644
--- a/xtask/src/release.rs
+++ b/xtask/src/release.rs
@@ -1,13 +1,11 @@
-use xshell::{cmd, cp, pushd, read_dir, write_file};
+use std::fmt::Write;
-use crate::{codegen, date_iso, is_release_tag, project_root, Mode, Result};
+use xshell::{cmd, cp, pushd, read_dir, write_file};
-pub struct ReleaseCmd {
+use crate::{codegen, date_iso, flags, is_release_tag, project_root, Mode, Result};
-    pub dry_run: bool,
-}
-impl ReleaseCmd {
+impl flags::Release {
-    pub fn run(self) -> Result<()> {
+    pub(crate) fn run(self) -> Result<()> {
        if !self.dry_run {
            cmd!("git switch release").run()?;
            cmd!("git fetch upstream --tags --force").run()?;
@@ -24,6 +22,34 @@ impl ReleaseCmd {
        let commit = cmd!("git rev-parse HEAD").read()?;
        let changelog_n = read_dir(changelog_dir.as_path())?.len();
+        for &adoc in [
+            "manual.adoc",
+            "generated_assists.adoc",
+            "generated_config.adoc",
+            "generated_diagnostic.adoc",
+            "generated_features.adoc",
+        ]
+        .iter()
+        {
+            let src = project_root().join("./docs/user/").join(adoc);
+            let dst = website_root.join(adoc);
+            cp(src, dst)?;
+        }
+        let tags = cmd!("git tag --list").read()?;
+        let prev_tag = tags.lines().filter(|line| is_release_tag(line)).last().unwrap();
+        let git_log = cmd!("git log {prev_tag}..HEAD --merges --reverse").read()?;
+        let mut git_log_summary = String::new();
+        for line in git_log.lines() {
+            let line = line.trim_start();
+            if let Some(p) = line.find(':') {
+                if let Ok(pr) = line[..p].parse::<u32>() {
+                    writeln!(git_log_summary, "* pr:{}[]{}", pr, &line[p + 1..]).unwrap();
+                }
+            }
+        }
        let contents = format!(
            "\
 = Changelog #{}
@@ -40,49 +66,24 @@ https://github.com/sponsors/rust-analyzer[GitHub Sponsors].
 == New Features
-* pr:[] .
+{}
 == Fixes
 == Internal Improvements
 ",
-            changelog_n, commit, today
+            changelog_n, commit, today, git_log_summary
        );
        let path = changelog_dir.join(format!("{}-changelog-{}.adoc", today, changelog_n));
        write_file(&path, &contents)?;
-        for &adoc in [
-            "manual.adoc",
-            "generated_assists.adoc",
-            "generated_config.adoc",
-            "generated_diagnostic.adoc",
-            "generated_features.adoc",
-        ]
-        .iter()
-        {
-            let src = project_root().join("./docs/user/").join(adoc);
-            let dst = website_root.join(adoc);
-            cp(src, dst)?;
-        }
-        let tags = cmd!("git tag --list").read()?;
-        let prev_tag = tags.lines().filter(|line| is_release_tag(line)).last().unwrap();
-        let git_log = cmd!("git log {prev_tag}..HEAD --merges --reverse").read()?;
-        let git_log_dst = website_root.join("git.log");
-        write_file(git_log_dst, &git_log)?;
        Ok(())
    }
 }
-pub struct PromoteCmd {
+impl flags::Promote {
-    pub dry_run: bool,
+    pub(crate) fn run(self) -> Result<()> {
-}
-impl PromoteCmd {
-    pub fn run(self) -> Result<()> {
        let _dir = pushd("../rust-rust-analyzer")?;
        cmd!("git switch master").run()?;
        cmd!("git fetch upstream").run()?;
@@ -99,7 +100,7 @@ impl PromoteCmd {
        cmd!("git add src/tools/rust-analyzer").run()?;
        cmd!("git commit -m':arrow_up: rust-analyzer'").run()?;
        if !self.dry_run {
-            cmd!("git push").run()?;
+            cmd!("git push -u").run()?;
            cmd!("xdg-open https://github.com/matklad/rust/pull/new/{branch}?body=r%3F%20%40ghost")
                .run()?;
        }
diff --git a/xtask/tests/tidy.rs b/xtask/src/tidy.rs
index 6abad189a..349ca14d0 100644
--- a/xtask/tests/tidy.rs
+++ b/xtask/src/tidy.rs
@@ -4,7 +4,9 @@ use std::{
 };
 use xshell::{cmd, read_file};
-use xtask::{
+use crate::{
+    cargo_files,
    codegen::{self, Mode},
    project_root, run_rustfmt, rust_files,
 };
@@ -82,7 +84,7 @@ Please adjust docs/dev/lsp-extensions.md.
 #[test]
 fn rust_files_are_tidy() {
    let mut tidy_docs = TidyDocs::default();
-    for path in rust_files(&project_root().join("crates")) {
+    for path in rust_files() {
        let text = read_file(&path).unwrap();
        check_todo(&path, &text);
        check_dbg(&path, &text);
@@ -94,6 +96,55 @@ fn rust_files_are_tidy() {
 }
 #[test]
+fn cargo_files_are_tidy() {
+    for cargo in cargo_files() {
+        let mut section = None;
+        for (line_no, text) in read_file(&cargo).unwrap().lines().enumerate() {
+            let text = text.trim();
+            if text.starts_with('[') {
+                if !text.ends_with(']') {
+                    panic!(
+                        "\nplease don't add comments or trailing whitespace in section lines.\n\
+                            {}:{}\n",
+                        cargo.display(),
+                        line_no + 1
+                    )
+                }
+                section = Some(text);
+                continue;
+            }
+            let text: String = text.split_whitespace().collect();
+            if !text.contains("path=") {
+                continue;
+            }
+            match section {
+                Some(s) if s.contains("dev-dependencies") => {
+                    if text.contains("version") {
+                        panic!(
+                            "\ncargo internal dev-dependencies should not have a version.\n\
+                            {}:{}\n",
+                            cargo.display(),
+                            line_no + 1
+                        );
+                    }
+                }
+                Some(s) if s.contains("dependencies") => {
+                    if !text.contains("version") {
+                        panic!(
+                            "\ncargo internal dependencies should have a version.\n\
+                            {}:{}\n",
+                            cargo.display(),
+                            line_no + 1
+                        );
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+}
+#[test]
 fn check_merge_commits() {
    let stdout = cmd!("git rev-list --merges --invert-grep --author 'bors\\[bot\\]' HEAD~19..")
        .read()
@@ -145,7 +196,7 @@ https://github.blog/2015-06-08-how-to-undo-almost-anything-with-git/#redo-after-
 fn deny_clippy(path: &PathBuf, text: &String) {
    let ignore = &[
        // The documentation in string literals may contain anything for its own purposes
-        "completion/src/generated_lint_completions.rs",
+        "ide_completion/src/generated_lint_completions.rs",
    ];
    if ignore.iter().any(|p| path.ends_with(p)) {
        return;
@@ -171,7 +222,6 @@ fn check_licenses() {
 Apache-2.0
 Apache-2.0 OR BSL-1.0
 Apache-2.0 OR MIT
-Apache-2.0 WITH LLVM-exception OR Apache-2.0 OR MIT
 Apache-2.0/MIT
 BSD-3-Clause
 CC0-1.0
@@ -232,7 +282,7 @@ fn check_todo(path: &Path, text: &str) {
        // `ast::make`.
        "ast/make.rs",
        // The documentation in string literals may contain anything for its own purposes
-        "completion/src/generated_lint_completions.rs",
+        "ide_completion/src/generated_lint_completions.rs",
    ];
    if need_todo.iter().any(|p| path.ends_with(p)) {
        return;
@@ -259,10 +309,10 @@ fn check_dbg(path: &Path, text: &str) {
        // Assists to remove `dbg!()`
        "handlers/remove_dbg.rs",
        // We have .dbg postfix
-        "completion/src/completions/postfix.rs",
+        "ide_completion/src/completions/postfix.rs",
        // The documentation in string literals may contain anything for its own purposes
-        "completion/src/lib.rs",
+        "ide_completion/src/lib.rs",
-        "completion/src/generated_lint_completions.rs",
+        "ide_completion/src/generated_lint_completions.rs",
        // test for doc test for remove_dbg
        "src/tests/generated.rs",
    ];