crates/ide/src/status.rs

   1 use std::{fmt, iter::FromIterator, sync::Arc};
   2
   3 use hir::{ExpandResult, MacroFile};
   4 use ide_db::base_db::{
   5     salsa::debug::{DebugQueryTable, TableEntry},
   6     CrateId, FileId, FileTextQuery, SourceDatabase, SourceRootId,
   7 };
   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     ide_db::base_db::ParseQuery.in_db(db).entries::<SyntaxTreeStats>()
  20 }
  21 fn macro_syntax_tree_stats(db: &RootDatabase) -> SyntaxTreeStats {
  22     hir::db::ParseMacroExpansionQuery.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     format_to!(buf, "\ncounts:\n{}", profile::countme::get_all());
  42
  43     if let Some(file_id) = file_id {
  44         format_to!(buf, "\nfile info:\n");
  45         let krate = crate::parent_module::crate_for(db, file_id).pop();
  46         match krate {
  47             Some(krate) => {
  48                 let crate_graph = db.crate_graph();
  49                 let display_crate = |krate: CrateId| match &crate_graph[krate].display_name {
  50                     Some(it) => format!("{}({:?})", it, krate),
  51                     None => format!("{:?}", krate),
  52                 };
  53                 format_to!(buf, "crate: {}\n", display_crate(krate));
  54                 let deps = crate_graph[krate]
  55                     .dependencies
  56                     .iter()
  57                     .map(|dep| format!("{}={:?}", dep.name, dep.crate_id))
  58                     .format(", ");
  59                 format_to!(buf, "deps: {}\n", deps);
  60             }
  61             None => format_to!(buf, "does not belong to any crate"),
  62         }
  63     }
  64
  65     buf
  66 }
  67
  68 #[derive(Default)]
  69 struct FilesStats {
  70     total: usize,
  71     size: Bytes,
  72 }
  73
  74 impl fmt::Display for FilesStats {
  75     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
  76         write!(fmt, "{} ({}) files", self.total, self.size)
  77     }
  78 }
  79
  80 impl FromIterator<TableEntry<FileId, Arc<String>>> for FilesStats {
  81     fn from_iter<T>(iter: T) -> FilesStats
  82     where
  83         T: IntoIterator<Item = TableEntry<FileId, Arc<String>>>,
  84     {
  85         let mut res = FilesStats::default();
  86         for entry in iter {
  87             res.total += 1;
  88             res.size += entry.value.unwrap().len();
  89         }
  90         res
  91     }
  92 }
  93
  94 #[derive(Default)]
  95 pub(crate) struct SyntaxTreeStats {
  96     total: usize,
  97     pub(crate) retained: usize,
  98 }
  99
 100 impl fmt::Display for SyntaxTreeStats {
 101     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
 102         write!(fmt, "{} trees, {} retained", self.total, self.retained)
 103     }
 104 }
 105
 106 impl FromIterator<TableEntry<FileId, Parse<ast::SourceFile>>> for SyntaxTreeStats {
 107     fn from_iter<T>(iter: T) -> SyntaxTreeStats
 108     where
 109         T: IntoIterator<Item = TableEntry<FileId, Parse<ast::SourceFile>>>,
 110     {
 111         let mut res = SyntaxTreeStats::default();
 112         for entry in iter {
 113             res.total += 1;
 114             res.retained += entry.value.is_some() as usize;
 115         }
 116         res
 117     }
 118 }
 119
 120 impl<M> FromIterator<TableEntry<MacroFile, ExpandResult<Option<(Parse<SyntaxNode>, M)>>>>
 121     for SyntaxTreeStats
 122 {
 123     fn from_iter<T>(iter: T) -> SyntaxTreeStats
 124     where
 125         T: IntoIterator<Item = TableEntry<MacroFile, ExpandResult<Option<(Parse<SyntaxNode>, M)>>>>,
 126     {
 127         let mut res = SyntaxTreeStats::default();
 128         for entry in iter {
 129             res.total += 1;
 130             res.retained += entry.value.is_some() as usize;
 131         }
 132         res
 133     }
 134 }
 135
 136 #[derive(Default)]
 137 struct LibrarySymbolsStats {
 138     total: usize,
 139     size: Bytes,
 140 }
 141
 142 impl fmt::Display for LibrarySymbolsStats {
 143     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
 144         write!(fmt, "{} ({}) index symbols", self.total, self.size)
 145     }
 146 }
 147
 148 impl FromIterator<TableEntry<(), Arc<FxHashMap<SourceRootId, SymbolIndex>>>>
 149     for LibrarySymbolsStats
 150 {
 151     fn from_iter<T>(iter: T) -> LibrarySymbolsStats
 152     where
 153         T: IntoIterator<Item = TableEntry<(), Arc<FxHashMap<SourceRootId, SymbolIndex>>>>,
 154     {
 155         let mut res = LibrarySymbolsStats::default();
 156         for entry in iter {
 157             let value = entry.value.unwrap();
 158             for symbols in value.values() {
 159                 res.total += symbols.len();
 160                 res.size += symbols.memory_size();
 161             }
 162         }
 163         res
 164     }
 165 }