crates/ide/src/status.rs

   1 use std::{fmt, iter::FromIterator, sync::Arc};
   2
   3 use base_db::{
   4     salsa::debug::{DebugQueryTable, TableEntry},
   5     CrateId, FileId, FileTextQuery, SourceDatabase, SourceRootId,
   6 };
   7 use hir::MacroFile;
   8 use ide_db::{
   9     symbol_index::{LibrarySymbolsQuery, SymbolIndex},
  10     RootDatabase,
  11 };
  12 use itertools::Itertools;
  13 use profile::{memory_usage, Bytes};
  14 use rustc_hash::FxHashMap;
  15 use stdx::format_to;
  16 use syntax::{ast, Parse, SyntaxNode};
  17
  18 fn syntax_tree_stats(db: &RootDatabase) -> SyntaxTreeStats {
  19     base_db::ParseQuery.in_db(db).entries::<SyntaxTreeStats>()
  20 }
  21 fn macro_syntax_tree_stats(db: &RootDatabase) -> SyntaxTreeStats {
  22     hir::db::ParseMacroQuery.in_db(db).entries::<SyntaxTreeStats>()
  23 }
  24
  25 // Feature: Status
  26 //
  27 // Shows internal statistic about memory usage of rust-analyzer.
  28 //
  29 // |===
  30 // | Editor  | Action Name
  31 //
  32 // | VS Code | **Rust Analyzer: Status**
  33 // |===
  34 pub(crate) fn status(db: &RootDatabase, file_id: Option<FileId>) -> String {
  35     let mut buf = String::new();
  36     format_to!(buf, "{}\n", FileTextQuery.in_db(db).entries::<FilesStats>());
  37     format_to!(buf, "{}\n", LibrarySymbolsQuery.in_db(db).entries::<LibrarySymbolsStats>());
  38     format_to!(buf, "{}\n", syntax_tree_stats(db));
  39     format_to!(buf, "{} (macros)\n", macro_syntax_tree_stats(db));
  40     format_to!(buf, "{} total\n", memory_usage());
  41
  42     if let Some(file_id) = file_id {
  43         format_to!(buf, "\nfile info:\n");
  44         let krate = crate::parent_module::crate_for(db, file_id).pop();
  45         match krate {
  46             Some(krate) => {
  47                 let crate_graph = db.crate_graph();
  48                 let display_crate = |krate: CrateId| match &crate_graph[krate].display_name {
  49                     Some(it) => format!("{}({:?})", it, krate),
  50                     None => format!("{:?}", krate),
  51                 };
  52                 format_to!(buf, "crate: {}\n", display_crate(krate));
  53                 let deps = crate_graph[krate]
  54                     .dependencies
  55                     .iter()
  56                     .map(|dep| format!("{}={:?}", dep.name, dep.crate_id))
  57                     .format(", ");
  58                 format_to!(buf, "deps: {}\n", deps);
  59             }
  60             None => format_to!(buf, "does not belong to any crate"),
  61         }
  62     }
  63     buf
  64 }
  65
  66 #[derive(Default)]
  67 struct FilesStats {
  68     total: usize,
  69     size: Bytes,
  70 }
  71
  72 impl fmt::Display for FilesStats {
  73     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
  74         write!(fmt, "{} ({}) files", self.total, self.size)
  75     }
  76 }
  77
  78 impl FromIterator<TableEntry<FileId, Arc<String>>> for FilesStats {
  79     fn from_iter<T>(iter: T) -> FilesStats
  80     where
  81         T: IntoIterator<Item = TableEntry<FileId, Arc<String>>>,
  82     {
  83         let mut res = FilesStats::default();
  84         for entry in iter {
  85             res.total += 1;
  86             res.size += entry.value.unwrap().len();
  87         }
  88         res
  89     }
  90 }
  91
  92 #[derive(Default)]
  93 pub(crate) struct SyntaxTreeStats {
  94     total: usize,
  95     pub(crate) retained: usize,
  96 }
  97
  98 impl fmt::Display for SyntaxTreeStats {
  99     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
 100         write!(fmt, "{} trees, {} retained", self.total, self.retained)
 101     }
 102 }
 103
 104 impl FromIterator<TableEntry<FileId, Parse<ast::SourceFile>>> for SyntaxTreeStats {
 105     fn from_iter<T>(iter: T) -> SyntaxTreeStats
 106     where
 107         T: IntoIterator<Item = TableEntry<FileId, Parse<ast::SourceFile>>>,
 108     {
 109         let mut res = SyntaxTreeStats::default();
 110         for entry in iter {
 111             res.total += 1;
 112             res.retained += entry.value.is_some() as usize;
 113         }
 114         res
 115     }
 116 }
 117
 118 impl<M> FromIterator<TableEntry<MacroFile, Option<(Parse<SyntaxNode>, M)>>> for SyntaxTreeStats {
 119     fn from_iter<T>(iter: T) -> SyntaxTreeStats
 120     where
 121         T: IntoIterator<Item = TableEntry<MacroFile, Option<(Parse<SyntaxNode>, M)>>>,
 122     {
 123         let mut res = SyntaxTreeStats::default();
 124         for entry in iter {
 125             res.total += 1;
 126             res.retained += entry.value.is_some() as usize;
 127         }
 128         res
 129     }
 130 }
 131
 132 #[derive(Default)]
 133 struct LibrarySymbolsStats {
 134     total: usize,
 135     size: Bytes,
 136 }
 137
 138 impl fmt::Display for LibrarySymbolsStats {
 139     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
 140         write!(fmt, "{} ({}) index symbols", self.total, self.size)
 141     }
 142 }
 143
 144 impl FromIterator<TableEntry<(), Arc<FxHashMap<SourceRootId, SymbolIndex>>>>
 145     for LibrarySymbolsStats
 146 {
 147     fn from_iter<T>(iter: T) -> LibrarySymbolsStats
 148     where
 149         T: IntoIterator<Item = TableEntry<(), Arc<FxHashMap<SourceRootId, SymbolIndex>>>>,
 150     {
 151         let mut res = LibrarySymbolsStats::default();
 152         for entry in iter {
 153             let value = entry.value.unwrap();
 154             for symbols in value.values() {
 155                 res.total += symbols.len();
 156                 res.size += symbols.memory_size();
 157             }
 158         }
 159         res
 160     }
 161 }