1 files changed, 67 insertions, 71 deletions

diff --git a/crates/ra_cli/src/main.rs b/crates/ra_cli/src/main.rs
index a9a9fbddd..e6334cf56 100644
--- a/crates/ra_cli/src/main.rs
+++ b/crates/ra_cli/src/main.rs
@@ -15,105 +15,101 @@ type Result<T> = std::result::Result<T, Box<dyn Error + Send + Sync>>;
 fn main() -> Result<()> {
     Logger::with_env().start()?;
 
-    let subcommand = std::env::args_os().nth(1);
-    if subcommand.is_none() {
-        help::print_global_help();
-        return Ok(());
-    }
-    let subcommand = subcommand.unwrap();
+    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"]) {
-                help::print_parse_help();
+                eprintln!("{}", help::PARSE_HELP);
                 return Ok(());
-            } else {
-                let no_dump = matches.contains("--no-dump");
-                matches.finish().or_else(handle_extra_flags)?;
+            }
+            let no_dump = matches.contains("--no-dump");
+            matches.finish().or_else(handle_extra_flags)?;
 
-                let _p = profile("parsing");
-                let file = file()?;
-                if !no_dump {
-                    println!("{:#?}", file.syntax());
-                }
-                std::mem::forget(file);
+            let _p = profile("parsing");
+            let file = file()?;
+            if !no_dump {
+                println!("{:#?}", file.syntax());
             }
+            std::mem::forget(file);
         }
         "symbols" => {
             if matches.contains(["-h", "--help"]) {
-                help::print_symbols_help();
+                eprintln!("{}", help::SYMBOLS_HELP);
                 return Ok(());
-            } else {
-                matches.finish().or_else(handle_extra_flags)?;
-                let file = file()?;
-                for s in file_structure(&file) {
-                    println!("{:?}", s);
-                }
+            }
+            matches.finish().or_else(handle_extra_flags)?;
+            let file = file()?;
+            for s in file_structure(&file) {
+                println!("{:?}", s);
             }
         }
         "highlight" => {
             if matches.contains(["-h", "--help"]) {
-                help::print_highlight_help();
+                eprintln!("{}", help::HIGHLIGHT_HELP);
                 return Ok(());
-            } else {
-                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, rainbow_opt).unwrap();
-                println!("{}", html);
             }
+            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, rainbow_opt).unwrap();
+            println!("{}", html);
         }
         "analysis-stats" => {
             if matches.contains(["-h", "--help"]) {
-                help::print_analysis_stats_help();
+                eprintln!("{}", help::ANALYSIS_STATS_HELP);
                 return Ok(());
-            } else {
-                let verbose = matches.contains(["-v", "--verbose"]);
-                let memory_usage = matches.contains("--memory-usage");
-                let path = matches.value_from_str("--path")?.unwrap_or("".to_string());
-                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),
-                )?;
             }
+            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" => {
             if matches.contains(["-h", "--help"]) {
-                help::print_analysis_bench_help();
+                eprintln!("{}", help::ANALYSIS_BENCH_HELP);
                 return Ok(());
-            } else {
-                let verbose = matches.contains(["-v", "--verbose"]);
-                let path = matches.value_from_str("--path")?.unwrap_or("".to_string());
-                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) = 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(),
-                        line: line.parse()?,
-                        column: column.parse()?,
-                    }
-                } else {
-                    panic!("either --highlight or --complete must be set")
-                };
-                matches.finish().or_else(handle_extra_flags)?;
-                analysis_bench::run(verbose, path.as_ref(), op)?;
             }
+            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) = 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(),
+                    line: line.parse()?,
+                    column: column.parse()?,
+                }
+            } else {
+                panic!("either --highlight or --complete must be set")
+            };
+            matches.finish().or_else(handle_extra_flags)?;
+            analysis_bench::run(verbose, path.as_ref(), op)?;
         }
-        _ => help::print_global_help(),
+        _ => eprintln!("{}", help::GLOBAL_HELP),
     }
     Ok(())
 }
@@ -122,7 +118,7 @@ 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).expect("Error on write");
+            write!(&mut invalid_flags, "{}, ", flag)?;
         }
         let (invalid_flags, _) = invalid_flags.split_at(invalid_flags.len() - 2);
         Err(format!("Invalid flags: {}", invalid_flags).into())