1 files changed, 79 insertions, 30 deletions

diff --git a/crates/rust-analyzer/src/bin/main.rs b/crates/rust-analyzer/src/bin/main.rs
index bf42654a8..288847980 100644
--- a/crates/rust-analyzer/src/bin/main.rs
+++ b/crates/rust-analyzer/src/bin/main.rs
@@ -1,58 +1,106 @@
 //! Driver for rust-analyzer.
 //!
 //! Based on cli flags, either spawns an LSP server, or runs a batch analysis
-mod args;
+mod flags;
 mod logger;
 
-use std::{convert::TryFrom, env, fs, path::PathBuf, process};
+use std::{convert::TryFrom, env, fs, path::Path, process};
 
 use lsp_server::Connection;
 use project_model::ProjectManifest;
-use rust_analyzer::{cli, config::Config, from_json, Result};
+use rust_analyzer::{
+    cli::{self, AnalysisStatsCmd, BenchCmd},
+    config::Config,
+    from_json,
+    lsp_ext::supports_utf8,
+    Result,
+};
 use vfs::AbsPathBuf;
 
 #[cfg(all(feature = "mimalloc"))]
 #[global_allocator]
 static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
 
+#[cfg(all(feature = "jemalloc", not(target_env = "msvc")))]
+#[global_allocator]
+static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;
+
 fn main() {
     if let Err(err) = try_main() {
+        log::error!("Unexpected error: {}", err);
         eprintln!("{}", err);
         process::exit(101);
     }
 }
 
 fn try_main() -> Result<()> {
-    let args = args::Args::parse()?;
-    setup_logging(args.log_file)?;
-    match args.command {
-        args::Command::RunServer => run_server()?,
-        args::Command::PrintConfigSchema => {
-            println!("{:#}", Config::json_schema());
+    let flags = flags::RustAnalyzer::from_env()?;
+
+    #[cfg(debug_assertions)]
+    if flags.wait_dbg || env::var("RA_WAIT_DBG").is_ok() {
+        #[allow(unused_mut)]
+        let mut d = 4;
+        while d == 4 {
+            d = 4;
         }
-        args::Command::ProcMacro => proc_macro_srv::cli::run()?,
-
-        args::Command::Parse { no_dump } => cli::parse(no_dump)?,
-        args::Command::Symbols => cli::symbols()?,
-        args::Command::Highlight { rainbow } => cli::highlight(rainbow)?,
-        args::Command::AnalysisStats(cmd) => cmd.run(args.verbosity)?,
-        args::Command::Bench(cmd) => cmd.run(args.verbosity)?,
-        args::Command::Diagnostics { path, load_output_dirs, with_proc_macro } => {
-            cli::diagnostics(path.as_ref(), load_output_dirs, with_proc_macro)?
+    }
+
+    setup_logging(flags.log_file.as_deref(), flags.no_log_buffering)?;
+    let verbosity = flags.verbosity();
+
+    match flags.subcommand {
+        flags::RustAnalyzerCmd::LspServer(cmd) => {
+            if cmd.print_config_schema {
+                println!("{:#}", Config::json_schema());
+                return Ok(());
+            }
+            if cmd.version {
+                println!("rust-analyzer {}", env!("REV"));
+                return Ok(());
+            }
+            if cmd.help {
+                println!("{}", flags::RustAnalyzer::HELP);
+                return Ok(());
+            }
+            run_server()?
+        }
+        flags::RustAnalyzerCmd::ProcMacro(_) => proc_macro_srv::cli::run()?,
+        flags::RustAnalyzerCmd::Parse(cmd) => cli::parse(cmd.no_dump)?,
+        flags::RustAnalyzerCmd::Symbols(_) => cli::symbols()?,
+        flags::RustAnalyzerCmd::Highlight(cmd) => cli::highlight(cmd.rainbow)?,
+        flags::RustAnalyzerCmd::AnalysisStats(cmd) => AnalysisStatsCmd {
+            randomize: cmd.randomize,
+            parallel: cmd.parallel,
+            memory_usage: cmd.memory_usage,
+            only: cmd.only,
+            with_deps: cmd.with_deps,
+            path: cmd.path,
+            load_output_dirs: cmd.load_output_dirs,
+            with_proc_macro: cmd.with_proc_macro,
         }
-        args::Command::Ssr { rules } => {
-            cli::apply_ssr_rules(rules)?;
+        .run(verbosity)?,
+        flags::RustAnalyzerCmd::AnalysisBench(cmd) => {
+            let what = cmd.what();
+            BenchCmd {
+                memory_usage: cmd.memory_usage,
+                path: cmd.path,
+                load_output_dirs: cmd.load_output_dirs,
+                with_proc_macro: cmd.with_proc_macro,
+                what,
+            }
+            .run(verbosity)?
         }
-        args::Command::StructuredSearch { patterns, debug_snippet } => {
-            cli::search_for_patterns(patterns, debug_snippet)?;
+
+        flags::RustAnalyzerCmd::Diagnostics(cmd) => {
+            cli::diagnostics(&cmd.path, cmd.load_output_dirs, cmd.with_proc_macro)?
         }
-        args::Command::Version => println!("rust-analyzer {}", env!("REV")),
-        args::Command::Help => {}
+        flags::RustAnalyzerCmd::Ssr(cmd) => cli::apply_ssr_rules(cmd.rule)?,
+        flags::RustAnalyzerCmd::Search(cmd) => cli::search_for_patterns(cmd.pattern, cmd.debug)?,
     }
     Ok(())
 }
 
-fn setup_logging(log_file: Option<PathBuf>) -> Result<()> {
+fn setup_logging(log_file: Option<&Path>, no_buffering: bool) -> Result<()> {
     env::set_var("RUST_BACKTRACE", "short");
 
     let log_file = match log_file {
@@ -65,16 +113,12 @@ fn setup_logging(log_file: Option<PathBuf>) -> Result<()> {
         None => None,
     };
     let filter = env::var("RA_LOG").ok();
-    logger::Logger::new(log_file, filter.as_deref()).install();
+    logger::Logger::new(log_file, no_buffering, filter.as_deref()).install();
 
     tracing_setup::setup_tracing()?;
 
     profile::init();
 
-    if !cfg!(debug_assertions) {
-        stdx::set_assert_hook(|loc, args| log::error!("assertion failed at {}: {}", loc, args));
-    }
-
     Ok(())
 }
 
@@ -116,6 +160,11 @@ fn run_server() -> Result<()> {
             name: String::from("rust-analyzer"),
             version: Some(String::from(env!("REV"))),
         }),
+        offset_encoding: if supports_utf8(&initialize_params.capabilities) {
+            Some("utf-8".to_string())
+        } else {
+            None
+        },
     };
 
     let initialize_result = serde_json::to_value(initialize_result).unwrap();