crates/rust-analyzer/src/bin/main.rs

   1 //! Driver for rust-analyzer.
   2 //!
   3 //! Based on cli flags, either spawns an LSP server, or runs a batch analysis
   4 mod args;
   5 mod logger;
   6
   7 use std::{convert::TryFrom, env, fs, path::PathBuf, process};
   8
   9 use lsp_server::Connection;
  10 use project_model::ProjectManifest;
  11 use rust_analyzer::{cli, config::Config, from_json, Result};
  12 use vfs::AbsPathBuf;
  13
  14 #[cfg(all(feature = "mimalloc"))]
  15 #[global_allocator]
  16 static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
  17
  18 #[cfg(all(feature = "jemalloc", not(target_env = "msvc")))]
  19 #[global_allocator]
  20 static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;
  21
  22 fn main() {
  23     if let Err(err) = try_main() {
  24         eprintln!("{}", err);
  25         process::exit(101);
  26     }
  27 }
  28
  29 fn try_main() -> Result<()> {
  30     let args = args::Args::parse()?;
  31     setup_logging(args.log_file)?;
  32     match args.command {
  33         args::Command::RunServer => run_server()?,
  34         args::Command::PrintConfigSchema => {
  35             println!("{:#}", Config::json_schema());
  36         }
  37         args::Command::ProcMacro => proc_macro_srv::cli::run()?,
  38
  39         args::Command::Parse { no_dump } => cli::parse(no_dump)?,
  40         args::Command::Symbols => cli::symbols()?,
  41         args::Command::Highlight { rainbow } => cli::highlight(rainbow)?,
  42         args::Command::AnalysisStats(cmd) => cmd.run(args.verbosity)?,
  43         args::Command::Bench(cmd) => cmd.run(args.verbosity)?,
  44         args::Command::Diagnostics { path, load_output_dirs, with_proc_macro } => {
  45             cli::diagnostics(path.as_ref(), load_output_dirs, with_proc_macro)?
  46         }
  47         args::Command::Ssr { rules } => {
  48             cli::apply_ssr_rules(rules)?;
  49         }
  50         args::Command::StructuredSearch { patterns, debug_snippet } => {
  51             cli::search_for_patterns(patterns, debug_snippet)?;
  52         }
  53         args::Command::Version => println!("rust-analyzer {}", env!("REV")),
  54         args::Command::Help => {}
  55     }
  56     Ok(())
  57 }
  58
  59 fn setup_logging(log_file: Option<PathBuf>) -> Result<()> {
  60     env::set_var("RUST_BACKTRACE", "short");
  61
  62     let log_file = match log_file {
  63         Some(path) => {
  64             if let Some(parent) = path.parent() {
  65                 let _ = fs::create_dir_all(parent);
  66             }
  67             Some(fs::File::create(path)?)
  68         }
  69         None => None,
  70     };
  71     let filter = env::var("RA_LOG").ok();
  72     logger::Logger::new(log_file, filter.as_deref()).install();
  73
  74     tracing_setup::setup_tracing()?;
  75
  76     profile::init();
  77
  78     Ok(())
  79 }
  80
  81 mod tracing_setup {
  82     use tracing::subscriber;
  83     use tracing_subscriber::layer::SubscriberExt;
  84     use tracing_subscriber::EnvFilter;
  85     use tracing_subscriber::Registry;
  86     use tracing_tree::HierarchicalLayer;
  87
  88     pub(crate) fn setup_tracing() -> super::Result<()> {
  89         let filter = EnvFilter::from_env("CHALK_DEBUG");
  90         let layer = HierarchicalLayer::default()
  91             .with_indent_lines(true)
  92             .with_ansi(false)
  93             .with_indent_amount(2)
  94             .with_writer(std::io::stderr);
  95         let subscriber = Registry::default().with(filter).with(layer);
  96         subscriber::set_global_default(subscriber)?;
  97         Ok(())
  98     }
  99 }
 100
 101 fn run_server() -> Result<()> {
 102     log::info!("server will start");
 103
 104     let (connection, io_threads) = Connection::stdio();
 105
 106     let (initialize_id, initialize_params) = connection.initialize_start()?;
 107     log::info!("InitializeParams: {}", initialize_params);
 108     let initialize_params =
 109         from_json::<lsp_types::InitializeParams>("InitializeParams", initialize_params)?;
 110
 111     let server_capabilities = rust_analyzer::server_capabilities(&initialize_params.capabilities);
 112
 113     let initialize_result = lsp_types::InitializeResult {
 114         capabilities: server_capabilities,
 115         server_info: Some(lsp_types::ServerInfo {
 116             name: String::from("rust-analyzer"),
 117             version: Some(String::from(env!("REV"))),
 118         }),
 119     };
 120
 121     let initialize_result = serde_json::to_value(initialize_result).unwrap();
 122
 123     connection.initialize_finish(initialize_id, initialize_result)?;
 124
 125     if let Some(client_info) = initialize_params.client_info {
 126         log::info!("Client '{}' {}", client_info.name, client_info.version.unwrap_or_default());
 127     }
 128
 129     let config = {
 130         let root_path = match initialize_params
 131             .root_uri
 132             .and_then(|it| it.to_file_path().ok())
 133             .and_then(|it| AbsPathBuf::try_from(it).ok())
 134         {
 135             Some(it) => it,
 136             None => {
 137                 let cwd = env::current_dir()?;
 138                 AbsPathBuf::assert(cwd)
 139             }
 140         };
 141
 142         let mut config = Config::new(root_path, initialize_params.capabilities);
 143         if let Some(json) = initialize_params.initialization_options {
 144             config.update(json);
 145         }
 146
 147         if config.linked_projects().is_empty() {
 148             let workspace_roots = initialize_params
 149                 .workspace_folders
 150                 .map(|workspaces| {
 151                     workspaces
 152                         .into_iter()
 153                         .filter_map(|it| it.uri.to_file_path().ok())
 154                         .filter_map(|it| AbsPathBuf::try_from(it).ok())
 155                         .collect::<Vec<_>>()
 156                 })
 157                 .filter(|workspaces| !workspaces.is_empty())
 158                 .unwrap_or_else(|| vec![config.root_path.clone()]);
 159
 160             let discovered = ProjectManifest::discover_all(&workspace_roots);
 161             log::info!("discovered projects: {:?}", discovered);
 162             if discovered.is_empty() {
 163                 log::error!("failed to find any projects in {:?}", workspace_roots);
 164             }
 165
 166             config.discovered_projects = Some(discovered);
 167         }
 168
 169         config
 170     };
 171
 172     rust_analyzer::main_loop(config, connection)?;
 173
 174     io_threads.join()?;
 175     log::info!("server did shut down");
 176     Ok(())
 177 }