Refactor arg parsing

crates/ra_cli/src/main.rs

@@ -14,6 +14,15 @@ use ra_syntax::{AstNode, SourceFile};
 
 type Result<T> = std::result::Result<T, Box<dyn Error + Send + Sync>>;
 
+fn main() -> Result<()> {
+    env_logger::try_init()?;
+
+    let command = Command::from_args()?;
+    command.run()?;
+
+    Ok(())
+}
+
 #[derive(Clone, Copy)]
 pub enum Verbosity {
     Spammy,
@@ -37,13 +46,36 @@ impl Verbosity {
     }
 }
 
-fn main() -> Result<()> {
+enum Command {
-    env_logger::try_init()?;
+    Parse {
+        no_dump: bool,
+    },
+    Symbols,
+    Highlight {
+        rainbow: bool,
+    },
+    Stats {
+        verbosity: Verbosity,
+        randomize: bool,
+        memory_usage: bool,
+        only: Option<String>,
+        with_deps: bool,
+        path: String,
+    },
+    Bench {
+        verbose: bool,
+        path: String,
+        op: analysis_bench::Op,
+    },
+    HelpPrinted,
+}
 
+impl Command {
+    fn from_args() -> Result<Command> {
         let mut matches = Arguments::from_env();
         let subcommand = matches.subcommand()?.unwrap_or_default();
 
-    match subcommand.as_str() {
+        let command = match subcommand.as_str() {
             "parse" => {
                 if matches.contains(["-h", "--help"]) {
                     eprintln!(
@@ -57,18 +89,12 @@ FLAGS:
     -h, --help       Prints help inforamtion
         --no-dump"
                     );
-                return Ok(());
+                    return Ok(Command::HelpPrinted);
                 }
 
                 let no_dump = matches.contains("--no-dump");
                 matches.finish().or_else(handle_extra_flags)?;
-
+                Command::Parse { no_dump }
-            let _p = profile("parsing");
-            let file = file()?;
-            if !no_dump {
-                println!("{:#?}", file.syntax());
-            }
-            std::mem::forget(file);
             }
             "symbols" => {
                 if matches.contains(["-h", "--help"]) {
@@ -82,15 +108,12 @@ USAGE:
 FLAGS:
     -h, --help    Prints help inforamtion"
                     );
-                return Ok(());
+                    return Ok(Command::HelpPrinted);
                 }
 
                 matches.finish().or_else(handle_extra_flags)?;
 
-            let file = file()?;
+                Command::Symbols
-            for s in file_structure(&file) {
-                println!("{:?}", s);
-            }
             }
             "highlight" => {
                 if matches.contains(["-h", "--help"]) {
@@ -105,15 +128,12 @@ FLAGS:
     -h, --help       Prints help information
     -r, --rainbow"
                     );
-                return Ok(());
+                    return Ok(Command::HelpPrinted);
                 }
 
-            let rainbow_opt = matches.contains(["-r", "--rainbow"]);
+                let rainbow = matches.contains(["-r", "--rainbow"]);
                 matches.finish().or_else(handle_extra_flags)?;
-
+                Command::Highlight { rainbow }
-            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"]) {
@@ -136,7 +156,7 @@ OPTIONS:
 ARGS:
     <PATH>"
                     );
-                return Ok(());
+                    return Ok(Command::HelpPrinted);
                 }
 
                 let verbosity = match (
@@ -163,14 +183,7 @@ ARGS:
                     trailing.pop().unwrap()
                 };
 
-            analysis_stats::run(
+                Command::Stats { verbosity, randomize, memory_usage, only, with_deps, path }
-                verbosity,
-                memory_usage,
-                path.as_ref(),
-                only.as_ref().map(String::as_ref),
-                with_deps,
-                randomize,
-            )?;
             }
             "analysis-bench" => {
                 if matches.contains(["-h", "--help"]) {
@@ -192,7 +205,7 @@ OPTIONS:
 ARGS:
     <PATH>    Project to analyse"
                     );
-                return Ok(());
+                    return Ok(Command::HelpPrinted);
                 }
 
                 let verbose = matches.contains(["-v", "--verbose"]);
@@ -208,11 +221,10 @@ ARGS:
                         "exactly one of  `--highlight`, `--complete` or `--goto-def` must be set"
                     ),
                 };
-            matches.finish().or_else(handle_extra_flags)?;
+                Command::Bench { verbose, path, op }
-
-            analysis_bench::run(verbose, path.as_ref(), op)?;
             }
-        _ => eprintln!(
+            _ => {
+                eprintln!(
                     "\
 ra-cli
 
@@ -228,9 +240,51 @@ SUBCOMMANDS:
     highlight
     parse
     symbols"
-        ),
+                );
+                return Ok(Command::HelpPrinted);
+            }
+        };
+        Ok(command)
+    }
+
+    fn run(self) -> Result<()> {
+        match self {
+            Command::Parse { no_dump } => {
+                let _p = profile("parsing");
+                let file = file()?;
+                if !no_dump {
+                    println!("{:#?}", file.syntax());
+                }
+                std::mem::forget(file);
+            }
+            Command::Symbols => {
+                let file = file()?;
+                for s in file_structure(&file) {
+                    println!("{:?}", s);
+                }
+            }
+            Command::Highlight { rainbow } => {
+                let (analysis, file_id) = Analysis::from_single_file(read_stdin()?);
+                let html = analysis.highlight_as_html(file_id, rainbow).unwrap();
+                println!("{}", html);
+            }
+            Command::Stats { verbosity, randomize, memory_usage, only, with_deps, path } => {
+                analysis_stats::run(
+                    verbosity,
+                    memory_usage,
+                    path.as_ref(),
+                    only.as_ref().map(String::as_ref),
+                    with_deps,
+                    randomize,
+                )?;
+            }
+            Command::Bench { verbose, path, op } => {
+                analysis_bench::run(verbose, path.as_ref(), op)?;
+            }
+            Command::HelpPrinted => (),
         }
         Ok(())
+    }
 }
 
 fn handle_extra_flags(e: pico_args::Error) -> Result<()> {