6 files changed, 289 insertions, 92 deletions

diff --git a/crates/ra_cli/Cargo.toml b/crates/ra_cli/Cargo.toml
index 205dd223b..d42ac3ad4 100644
--- a/crates/ra_cli/Cargo.toml
+++ b/crates/ra_cli/Cargo.toml
@@ -6,7 +6,7 @@ authors = ["rust-analyzer developers"]
 publish = false
 
 [dependencies]
-clap = { version = "2.32.0", default-features = false }
+pico-args = "0.2.0"
 flexi_logger = "0.14.0"
 indicatif = "0.11.0"
 
diff --git a/crates/ra_cli/src/help.rs b/crates/ra_cli/src/help.rs
new file mode 100644
index 000000000..5171578f0
--- /dev/null
+++ b/crates/ra_cli/src/help.rs
@@ -0,0 +1,72 @@
+pub const GLOBAL_HELP: &str = "ra-cli

+

+USAGE:

+    ra_cli <SUBCOMMAND>

+

+FLAGS:

+    -h, --help        Prints help information

+

+SUBCOMMANDS:

+    analysis-bench

+    analysis-stats

+    highlight

+    parse

+    symbols";

+

+pub const ANALYSIS_BENCH_HELP: &str = "ra_cli-analysis-bench

+

+USAGE:

+    ra_cli analysis-bench [FLAGS] [OPTIONS] [PATH]

+

+FLAGS:

+    -h, --help        Prints help information

+    -v, --verbose

+    

+OPTIONS:

+    --complete <PATH:LINE:COLUMN>    Compute completions at this location

+    --highlight <PATH>               Hightlight this file

+    

+ARGS:

+    <PATH>    Project to analyse";

+

+pub const ANALYSIS_STATS_HELP: &str = "ra-cli-analysis-stats

+

+USAGE:

+    ra_cli analysis-stats [FLAGS] [OPTIONS] [PATH]

+    

+FLAGS:

+    -h, --help            Prints help information

+        --memory-usage

+    -v, --verbose

+    

+OPTIONS:

+    -o <ONLY>

+    

+ARGS:

+    <PATH>";

+

+pub const HIGHLIGHT_HELP: &str = "ra-cli-highlight

+    

+USAGE:

+    ra_cli highlight [FLAGS]

+    

+FLAGS:

+    -h, --help       Prints help information

+    -r, --rainbow";

+

+pub const SYMBOLS_HELP: &str = "ra-cli-symbols

+    

+USAGE:

+    ra_cli highlight [FLAGS]

+    

+FLAGS:

+    -h, --help    Prints help inforamtion";

+

+pub const PARSE_HELP: &str = "ra-cli-parse

+    

+USAGE:

+    ra_cli parse [FLAGS]

+    

+FLAGS:

+    -h, --help       Prints help inforamtion

+        --no-dump";

diff --git a/crates/ra_cli/src/main.rs b/crates/ra_cli/src/main.rs
index de8191ca3..e6334cf56 100644
--- a/crates/ra_cli/src/main.rs
+++ b/crates/ra_cli/src/main.rs
@@ -1,10 +1,11 @@
 mod analysis_stats;
 mod analysis_bench;
+mod help;
 
-use std::{error::Error, io::Read};
+use std::{error::Error, fmt::Write, io::Read};
 
-use clap::{App, Arg, SubCommand};
 use flexi_logger::Logger;
+use pico_args::Arguments;
 use ra_ide_api::{file_structure, Analysis};
 use ra_prof::profile;
 use ra_syntax::{AstNode, SourceFile};
@@ -13,77 +14,89 @@ type Result<T> = std::result::Result<T, Box<dyn Error + Send + Sync>>;
 
 fn main() -> Result<()> {
     Logger::with_env().start()?;
-    let matches = App::new("ra-cli")
-        .setting(clap::AppSettings::SubcommandRequiredElseHelp)
-        .subcommand(SubCommand::with_name("parse").arg(Arg::with_name("no-dump").long("--no-dump")))
-        .subcommand(SubCommand::with_name("symbols"))
-        .subcommand(
-            SubCommand::with_name("highlight")
-                .arg(Arg::with_name("rainbow").short("r").long("rainbow")),
-        )
-        .subcommand(
-            SubCommand::with_name("analysis-stats")
-                .arg(Arg::with_name("verbose").short("v").long("verbose"))
-                .arg(Arg::with_name("memory-usage").long("memory-usage"))
-                .arg(Arg::with_name("only").short("o").takes_value(true))
-                .arg(Arg::with_name("path")),
-        )
-        .subcommand(
-            SubCommand::with_name("analysis-bench")
-                .arg(Arg::with_name("verbose").short("v").long("verbose"))
-                .arg(
-                    Arg::with_name("highlight")
-                        .long("highlight")
-                        .takes_value(true)
-                        .conflicts_with("complete")
-                        .value_name("PATH")
-                        .help("highlight this file"),
-                )
-                .arg(
-                    Arg::with_name("complete")
-                        .long("complete")
-                        .takes_value(true)
-                        .conflicts_with("highlight")
-                        .value_name("PATH:LINE:COLUMN")
-                        .help("compute completions at this location"),
-                )
-                .arg(Arg::with_name("path").value_name("PATH").help("project to analyze")),
-        )
-        .get_matches();
-    match matches.subcommand() {
-        ("parse", Some(matches)) => {
+
+    let subcommand = match std::env::args_os().nth(1) {
+        None => {
+            eprintln!("{}", help::GLOBAL_HELP);
+            return Ok(());
+        }
+        Some(s) => s,
+    };
+    let mut matches = Arguments::from_vec(std::env::args_os().skip(2).collect());
+
+    match &*subcommand.to_string_lossy() {
+        "parse" => {
+            if matches.contains(["-h", "--help"]) {
+                eprintln!("{}", help::PARSE_HELP);
+                return Ok(());
+            }
+            let no_dump = matches.contains("--no-dump");
+            matches.finish().or_else(handle_extra_flags)?;
+
             let _p = profile("parsing");
             let file = file()?;
-            if !matches.is_present("no-dump") {
+            if !no_dump {
                 println!("{:#?}", file.syntax());
             }
             std::mem::forget(file);
         }
-        ("symbols", _) => {
+        "symbols" => {
+            if matches.contains(["-h", "--help"]) {
+                eprintln!("{}", help::SYMBOLS_HELP);
+                return Ok(());
+            }
+            matches.finish().or_else(handle_extra_flags)?;
             let file = file()?;
             for s in file_structure(&file) {
                 println!("{:?}", s);
             }
         }
-        ("highlight", Some(matches)) => {
+        "highlight" => {
+            if matches.contains(["-h", "--help"]) {
+                eprintln!("{}", help::HIGHLIGHT_HELP);
+                return Ok(());
+            }
+            let rainbow_opt = matches.contains(["-r", "--rainbow"]);
+            matches.finish().or_else(handle_extra_flags)?;
             let (analysis, file_id) = Analysis::from_single_file(read_stdin()?);
-            let html = analysis.highlight_as_html(file_id, matches.is_present("rainbow")).unwrap();
+            let html = analysis.highlight_as_html(file_id, rainbow_opt).unwrap();
             println!("{}", html);
         }
-        ("analysis-stats", Some(matches)) => {
-            let verbose = matches.is_present("verbose");
-            let memory_usage = matches.is_present("memory-usage");
-            let path = matches.value_of("path").unwrap_or("");
-            let only = matches.value_of("only");
-            analysis_stats::run(verbose, memory_usage, path.as_ref(), only)?;
+        "analysis-stats" => {
+            if matches.contains(["-h", "--help"]) {
+                eprintln!("{}", help::ANALYSIS_STATS_HELP);
+                return Ok(());
+            }
+            let verbose = matches.contains(["-v", "--verbose"]);
+            let memory_usage = matches.contains("--memory-usage");
+            let path: String = matches.value_from_str("--path")?.unwrap_or_default();
+            let only = matches.value_from_str(["-o", "--only"])?.map(|v: String| v.to_owned());
+            matches.finish().or_else(handle_extra_flags)?;
+            analysis_stats::run(
+                verbose,
+                memory_usage,
+                path.as_ref(),
+                only.as_ref().map(String::as_ref),
+            )?;
         }
-        ("analysis-bench", Some(matches)) => {
-            let verbose = matches.is_present("verbose");
-            let path = matches.value_of("path").unwrap_or("");
-            let op = if let Some(path) = matches.value_of("highlight") {
+        "analysis-bench" => {
+            if matches.contains(["-h", "--help"]) {
+                eprintln!("{}", help::ANALYSIS_BENCH_HELP);
+                return Ok(());
+            }
+            let verbose = matches.contains(["-v", "--verbose"]);
+            let path: String = matches.value_from_str("--path")?.unwrap_or_default();
+            let highlight_path = matches.value_from_str("--highlight")?;
+            let complete_path = matches.value_from_str("--complete")?;
+            if highlight_path.is_some() && complete_path.is_some() {
+                panic!("either --highlight or --complete must be set, not both")
+            }
+            let op = if let Some(path) = highlight_path {
+                let path: String = path;
                 analysis_bench::Op::Highlight { path: path.into() }
-            } else if let Some(path_line_col) = matches.value_of("complete") {
-                let (path_line, column) = rsplit_at_char(path_line_col, ':')?;
+            } else if let Some(path_line_col) = complete_path {
+                let path_line_col: String = path_line_col;
+                let (path_line, column) = rsplit_at_char(path_line_col.as_str(), ':')?;
                 let (path, line) = rsplit_at_char(path_line, ':')?;
                 analysis_bench::Op::Complete {
                     path: path.into(),
@@ -93,13 +106,27 @@ fn main() -> Result<()> {
             } else {
                 panic!("either --highlight or --complete must be set")
             };
+            matches.finish().or_else(handle_extra_flags)?;
             analysis_bench::run(verbose, path.as_ref(), op)?;
         }
-        _ => unreachable!(),
+        _ => eprintln!("{}", help::GLOBAL_HELP),
     }
     Ok(())
 }
 
+fn handle_extra_flags(e: pico_args::Error) -> Result<()> {
+    if let pico_args::Error::UnusedArgsLeft(flags) = e {
+        let mut invalid_flags = String::new();
+        for flag in flags {
+            write!(&mut invalid_flags, "{}, ", flag)?;
+        }
+        let (invalid_flags, _) = invalid_flags.split_at(invalid_flags.len() - 2);
+        Err(format!("Invalid flags: {}", invalid_flags).into())
+    } else {
+        Err(e.to_string().into())
+    }
+}
+
 fn file() -> Result<SourceFile> {
     let text = read_stdin()?;
     Ok(SourceFile::parse(&text).tree())
diff --git a/crates/ra_tools/Cargo.toml b/crates/ra_tools/Cargo.toml
index b94a0b18d..848ca408d 100644
--- a/crates/ra_tools/Cargo.toml
+++ b/crates/ra_tools/Cargo.toml
@@ -8,7 +8,7 @@ publish = false
 [dependencies]
 walkdir = "2.1.3"
 itertools = "0.8.0"
-clap = { version = "2.32.0", default-features = false }
+pico-args = "0.2.0"
 quote = "1.0.2"
 proc-macro2 = "1.0.1"
 ron = "0.5.1"
diff --git a/crates/ra_tools/src/help.rs b/crates/ra_tools/src/help.rs
new file mode 100644
index 000000000..6dde6c2d2
--- /dev/null
+++ b/crates/ra_tools/src/help.rs
@@ -0,0 +1,45 @@
+pub const GLOBAL_HELP: &str = "tasks

+

+USAGE:

+    ra_tools <SUBCOMMAND>

+

+FLAGS:

+    -h, --help       Prints help information

+

+SUBCOMMANDS:

+    format

+    format-hook

+    fuzz-tests

+    gen-syntax

+    gen-tests

+    install-ra

+    lint";

+

+pub const INSTALL_RA_HELP: &str = "ra_tools-install-ra

+

+USAGE:

+    ra_tools.exe install-ra [FLAGS]

+

+FLAGS:

+        --client-code

+    -h, --help           Prints help information

+        --jemalloc

+        --server";

+

+pub fn print_no_param_subcommand_help(subcommand: &str) {

+    eprintln!(

+        "ra_tools-{}

+

+USAGE:

+    ra_tools {}

+

+FLAGS:

+    -h, --help       Prints help information",

+        subcommand, subcommand

+    );

+}

+

+pub const INSTALL_RA_CONFLICT: &str =

+    "error: The argument `--server` cannot be used with `--client-code`

+                    

+For more information try --help";

diff --git a/crates/ra_tools/src/main.rs b/crates/ra_tools/src/main.rs
index 33badf290..f96f1875f 100644
--- a/crates/ra_tools/src/main.rs
+++ b/crates/ra_tools/src/main.rs
@@ -1,5 +1,8 @@
-use clap::{App, Arg, SubCommand};
+mod help;
+
+use core::fmt::Write;
 use core::str;
+use pico_args::Arguments;
 use ra_tools::{
     gen_tests, generate_boilerplate, install_format_hook, run, run_clippy, run_fuzzer, run_rustfmt,
     Cmd, Overwrite, Result,
@@ -20,45 +23,95 @@ struct ServerOpt {
 }
 
 fn main() -> Result<()> {
-    let matches = App::new("tasks")
-        .setting(clap::AppSettings::SubcommandRequiredElseHelp)
-        .subcommand(SubCommand::with_name("gen-syntax"))
-        .subcommand(SubCommand::with_name("gen-tests"))
-        .subcommand(
-            SubCommand::with_name("install-ra")
-                .arg(Arg::with_name("server").long("--server"))
-                .arg(Arg::with_name("jemalloc").long("jemalloc"))
-                .arg(Arg::with_name("client-code").long("client-code").conflicts_with("server")),
-        )
-        .alias("install-code")
-        .subcommand(SubCommand::with_name("format"))
-        .subcommand(SubCommand::with_name("format-hook"))
-        .subcommand(SubCommand::with_name("fuzz-tests"))
-        .subcommand(SubCommand::with_name("lint"))
-        .get_matches();
-    match matches.subcommand() {
-        ("install-ra", Some(matches)) => {
+    let subcommand = match std::env::args_os().nth(1) {
+        None => {
+            eprintln!("{}", help::GLOBAL_HELP);
+            return Ok(());
+        }
+        Some(s) => s,
+    };
+    let mut matches = Arguments::from_vec(std::env::args_os().skip(2).collect());
+    let subcommand = &*subcommand.to_string_lossy();
+    match subcommand {
+        "install-ra" | "install-code" => {
+            if matches.contains(["-h", "--help"]) {
+                eprintln!("{}", help::INSTALL_RA_HELP);
+                return Ok(());
+            }
+            let server = matches.contains("--server");
+            let client_code = matches.contains("--client-code");
+            if server && client_code {
+                eprintln!("{}", help::INSTALL_RA_CONFLICT);
+                return Ok(());
+            }
+            let jemalloc = matches.contains("--jemalloc");
+            matches.finish().or_else(handle_extra_flags)?;
             let opts = InstallOpt {
-                client: if matches.is_present("server") { None } else { Some(ClientOpt::VsCode) },
-                server: if matches.is_present("client-code") {
-                    None
-                } else {
-                    Some(ServerOpt { jemalloc: matches.is_present("jemalloc") })
-                },
+                client: if server { None } else { Some(ClientOpt::VsCode) },
+                server: if client_code { None } else { Some(ServerOpt { jemalloc: jemalloc }) },
             };
             install(opts)?
         }
-        ("gen-tests", _) => gen_tests(Overwrite)?,
-        ("gen-syntax", _) => generate_boilerplate(Overwrite)?,
-        ("format", _) => run_rustfmt(Overwrite)?,
-        ("format-hook", _) => install_format_hook()?,
-        ("lint", _) => run_clippy()?,
-        ("fuzz-tests", _) => run_fuzzer()?,
-        _ => unreachable!(),
+        "gen-tests" => {
+            if matches.contains(["-h", "--help"]) {
+                help::print_no_param_subcommand_help(&subcommand);
+                return Ok(());
+            }
+            gen_tests(Overwrite)?
+        }
+        "gen-syntax" => {
+            if matches.contains(["-h", "--help"]) {
+                help::print_no_param_subcommand_help(&subcommand);
+                return Ok(());
+            }
+            generate_boilerplate(Overwrite)?
+        }
+        "format" => {
+            if matches.contains(["-h", "--help"]) {
+                help::print_no_param_subcommand_help(&subcommand);
+                return Ok(());
+            }
+            run_rustfmt(Overwrite)?
+        }
+        "format-hook" => {
+            if matches.contains(["-h", "--help"]) {
+                help::print_no_param_subcommand_help(&subcommand);
+                return Ok(());
+            }
+            install_format_hook()?
+        }
+        "lint" => {
+            if matches.contains(["-h", "--help"]) {
+                help::print_no_param_subcommand_help(&subcommand);
+                return Ok(());
+            }
+            run_clippy()?
+        }
+        "fuzz-tests" => {
+            if matches.contains(["-h", "--help"]) {
+                help::print_no_param_subcommand_help(&subcommand);
+                return Ok(());
+            }
+            run_fuzzer()?
+        }
+        _ => eprintln!("{}", help::GLOBAL_HELP),
     }
     Ok(())
 }
 
+fn handle_extra_flags(e: pico_args::Error) -> Result<()> {
+    if let pico_args::Error::UnusedArgsLeft(flags) = e {
+        let mut invalid_flags = String::new();
+        for flag in flags {
+            write!(&mut invalid_flags, "{}, ", flag)?;
+        }
+        let (invalid_flags, _) = invalid_flags.split_at(invalid_flags.len() - 2);
+        Err(format!("Invalid flags: {}", invalid_flags).into())
+    } else {
+        Err(e.to_string().into())
+    }
+}
+
 fn install(opts: InstallOpt) -> Result<()> {
     if cfg!(target_os = "macos") {
         fix_path_for_mac()?