diff options
author | Aleksey Kladov <[email protected]> | 2020-02-18 11:37:45 +0000 |
---|---|---|
committer | Aleksey Kladov <[email protected]> | 2020-02-18 11:37:45 +0000 |
commit | 865759925be6b72f7ef39124ed0e4c86c0412a69 (patch) | |
tree | 0fc36373073a66c2bbd6c7cfae6cb734527d847f /crates/ra_lsp_server/src/cli/analysis_stats.rs | |
parent | c855e36696afa54260773a6bc8a358df67d60dea (diff) |
Rename folder
Diffstat (limited to 'crates/ra_lsp_server/src/cli/analysis_stats.rs')
-rw-r--r-- | crates/ra_lsp_server/src/cli/analysis_stats.rs | 260 |
1 files changed, 0 insertions, 260 deletions
diff --git a/crates/ra_lsp_server/src/cli/analysis_stats.rs b/crates/ra_lsp_server/src/cli/analysis_stats.rs deleted file mode 100644 index 99ab6e443..000000000 --- a/crates/ra_lsp_server/src/cli/analysis_stats.rs +++ /dev/null | |||
@@ -1,260 +0,0 @@ | |||
1 | //! Fully type-check project and print various stats, like the number of type | ||
2 | //! errors. | ||
3 | |||
4 | use std::{collections::HashSet, fmt::Write, path::Path, time::Instant}; | ||
5 | |||
6 | use hir::{ | ||
7 | db::{DefDatabase, HirDatabase}, | ||
8 | AssocItem, Crate, HasSource, HirDisplay, ModuleDef, | ||
9 | }; | ||
10 | use hir_def::FunctionId; | ||
11 | use hir_ty::{Ty, TypeWalk}; | ||
12 | use itertools::Itertools; | ||
13 | use ra_db::SourceDatabaseExt; | ||
14 | use ra_syntax::AstNode; | ||
15 | use rand::{seq::SliceRandom, thread_rng}; | ||
16 | |||
17 | use crate::cli::{load_cargo::load_cargo, progress_report::ProgressReport, Result, Verbosity}; | ||
18 | |||
19 | pub fn analysis_stats( | ||
20 | verbosity: Verbosity, | ||
21 | memory_usage: bool, | ||
22 | path: &Path, | ||
23 | only: Option<&str>, | ||
24 | with_deps: bool, | ||
25 | randomize: bool, | ||
26 | ) -> Result<()> { | ||
27 | let db_load_time = Instant::now(); | ||
28 | let (mut host, roots) = load_cargo(path)?; | ||
29 | let db = host.raw_database(); | ||
30 | println!("Database loaded, {} roots, {:?}", roots.len(), db_load_time.elapsed()); | ||
31 | let analysis_time = Instant::now(); | ||
32 | let mut num_crates = 0; | ||
33 | let mut visited_modules = HashSet::new(); | ||
34 | let mut visit_queue = Vec::new(); | ||
35 | |||
36 | let members = | ||
37 | roots | ||
38 | .into_iter() | ||
39 | .filter_map(|(source_root_id, project_root)| { | ||
40 | if with_deps || project_root.is_member() { | ||
41 | Some(source_root_id) | ||
42 | } else { | ||
43 | None | ||
44 | } | ||
45 | }) | ||
46 | .collect::<HashSet<_>>(); | ||
47 | |||
48 | let mut krates = Crate::all(db); | ||
49 | if randomize { | ||
50 | krates.shuffle(&mut thread_rng()); | ||
51 | } | ||
52 | for krate in krates { | ||
53 | let module = krate.root_module(db).expect("crate without root module"); | ||
54 | let file_id = module.definition_source(db).file_id; | ||
55 | if members.contains(&db.file_source_root(file_id.original_file(db))) { | ||
56 | num_crates += 1; | ||
57 | visit_queue.push(module); | ||
58 | } | ||
59 | } | ||
60 | |||
61 | if randomize { | ||
62 | visit_queue.shuffle(&mut thread_rng()); | ||
63 | } | ||
64 | |||
65 | println!("Crates in this dir: {}", num_crates); | ||
66 | let mut num_decls = 0; | ||
67 | let mut funcs = Vec::new(); | ||
68 | while let Some(module) = visit_queue.pop() { | ||
69 | if visited_modules.insert(module) { | ||
70 | visit_queue.extend(module.children(db)); | ||
71 | |||
72 | for decl in module.declarations(db) { | ||
73 | num_decls += 1; | ||
74 | if let ModuleDef::Function(f) = decl { | ||
75 | funcs.push(f); | ||
76 | } | ||
77 | } | ||
78 | |||
79 | for impl_block in module.impl_blocks(db) { | ||
80 | for item in impl_block.items(db) { | ||
81 | num_decls += 1; | ||
82 | if let AssocItem::Function(f) = item { | ||
83 | funcs.push(f); | ||
84 | } | ||
85 | } | ||
86 | } | ||
87 | } | ||
88 | } | ||
89 | println!("Total modules found: {}", visited_modules.len()); | ||
90 | println!("Total declarations: {}", num_decls); | ||
91 | println!("Total functions: {}", funcs.len()); | ||
92 | println!("Item Collection: {:?}, {}", analysis_time.elapsed(), ra_prof::memory_usage()); | ||
93 | |||
94 | if randomize { | ||
95 | funcs.shuffle(&mut thread_rng()); | ||
96 | } | ||
97 | |||
98 | let inference_time = Instant::now(); | ||
99 | let mut bar = match verbosity { | ||
100 | Verbosity::Quiet | Verbosity::Spammy => ProgressReport::hidden(), | ||
101 | _ => ProgressReport::new(funcs.len() as u64), | ||
102 | }; | ||
103 | |||
104 | bar.tick(); | ||
105 | let mut num_exprs = 0; | ||
106 | let mut num_exprs_unknown = 0; | ||
107 | let mut num_exprs_partially_unknown = 0; | ||
108 | let mut num_type_mismatches = 0; | ||
109 | for f in funcs { | ||
110 | let name = f.name(db); | ||
111 | let full_name = f | ||
112 | .module(db) | ||
113 | .path_to_root(db) | ||
114 | .into_iter() | ||
115 | .rev() | ||
116 | .filter_map(|it| it.name(db)) | ||
117 | .chain(Some(f.name(db))) | ||
118 | .join("::"); | ||
119 | if let Some(only_name) = only { | ||
120 | if name.to_string() != only_name && full_name != only_name { | ||
121 | continue; | ||
122 | } | ||
123 | } | ||
124 | let mut msg = format!("processing: {}", full_name); | ||
125 | if verbosity.is_verbose() { | ||
126 | let src = f.source(db); | ||
127 | let original_file = src.file_id.original_file(db); | ||
128 | let path = db.file_relative_path(original_file); | ||
129 | let syntax_range = src.value.syntax().text_range(); | ||
130 | write!(msg, " ({:?} {})", path, syntax_range).unwrap(); | ||
131 | } | ||
132 | if verbosity.is_spammy() { | ||
133 | bar.println(format!("{}", msg)); | ||
134 | } | ||
135 | bar.set_message(&msg); | ||
136 | let f_id = FunctionId::from(f); | ||
137 | let body = db.body(f_id.into()); | ||
138 | let inference_result = db.infer(f_id.into()); | ||
139 | let (previous_exprs, previous_unknown, previous_partially_unknown) = | ||
140 | (num_exprs, num_exprs_unknown, num_exprs_partially_unknown); | ||
141 | for (expr_id, _) in body.exprs.iter() { | ||
142 | let ty = &inference_result[expr_id]; | ||
143 | num_exprs += 1; | ||
144 | if let Ty::Unknown = ty { | ||
145 | num_exprs_unknown += 1; | ||
146 | } else { | ||
147 | let mut is_partially_unknown = false; | ||
148 | ty.walk(&mut |ty| { | ||
149 | if let Ty::Unknown = ty { | ||
150 | is_partially_unknown = true; | ||
151 | } | ||
152 | }); | ||
153 | if is_partially_unknown { | ||
154 | num_exprs_partially_unknown += 1; | ||
155 | } | ||
156 | } | ||
157 | if only.is_some() && verbosity.is_spammy() { | ||
158 | // in super-verbose mode for just one function, we print every single expression | ||
159 | let (_, sm) = db.body_with_source_map(f_id.into()); | ||
160 | let src = sm.expr_syntax(expr_id); | ||
161 | if let Some(src) = src { | ||
162 | let original_file = src.file_id.original_file(db); | ||
163 | let line_index = host.analysis().file_line_index(original_file).unwrap(); | ||
164 | let text_range = src.value.either( | ||
165 | |it| it.syntax_node_ptr().range(), | ||
166 | |it| it.syntax_node_ptr().range(), | ||
167 | ); | ||
168 | let (start, end) = ( | ||
169 | line_index.line_col(text_range.start()), | ||
170 | line_index.line_col(text_range.end()), | ||
171 | ); | ||
172 | bar.println(format!( | ||
173 | "{}:{}-{}:{}: {}", | ||
174 | start.line + 1, | ||
175 | start.col_utf16, | ||
176 | end.line + 1, | ||
177 | end.col_utf16, | ||
178 | ty.display(db) | ||
179 | )); | ||
180 | } else { | ||
181 | bar.println(format!("unknown location: {}", ty.display(db))); | ||
182 | } | ||
183 | } | ||
184 | if let Some(mismatch) = inference_result.type_mismatch_for_expr(expr_id) { | ||
185 | num_type_mismatches += 1; | ||
186 | if verbosity.is_verbose() { | ||
187 | let (_, sm) = db.body_with_source_map(f_id.into()); | ||
188 | let src = sm.expr_syntax(expr_id); | ||
189 | if let Some(src) = src { | ||
190 | // FIXME: it might be nice to have a function (on Analysis?) that goes from Source<T> -> (LineCol, LineCol) directly | ||
191 | let original_file = src.file_id.original_file(db); | ||
192 | let path = db.file_relative_path(original_file); | ||
193 | let line_index = host.analysis().file_line_index(original_file).unwrap(); | ||
194 | let text_range = src.value.either( | ||
195 | |it| it.syntax_node_ptr().range(), | ||
196 | |it| it.syntax_node_ptr().range(), | ||
197 | ); | ||
198 | let (start, end) = ( | ||
199 | line_index.line_col(text_range.start()), | ||
200 | line_index.line_col(text_range.end()), | ||
201 | ); | ||
202 | bar.println(format!( | ||
203 | "{} {}:{}-{}:{}: Expected {}, got {}", | ||
204 | path, | ||
205 | start.line + 1, | ||
206 | start.col_utf16, | ||
207 | end.line + 1, | ||
208 | end.col_utf16, | ||
209 | mismatch.expected.display(db), | ||
210 | mismatch.actual.display(db) | ||
211 | )); | ||
212 | } else { | ||
213 | bar.println(format!( | ||
214 | "{}: Expected {}, got {}", | ||
215 | name, | ||
216 | mismatch.expected.display(db), | ||
217 | mismatch.actual.display(db) | ||
218 | )); | ||
219 | } | ||
220 | } | ||
221 | } | ||
222 | } | ||
223 | if verbosity.is_spammy() { | ||
224 | bar.println(format!( | ||
225 | "In {}: {} exprs, {} unknown, {} partial", | ||
226 | full_name, | ||
227 | num_exprs - previous_exprs, | ||
228 | num_exprs_unknown - previous_unknown, | ||
229 | num_exprs_partially_unknown - previous_partially_unknown | ||
230 | )); | ||
231 | } | ||
232 | bar.inc(1); | ||
233 | } | ||
234 | bar.finish_and_clear(); | ||
235 | println!("Total expressions: {}", num_exprs); | ||
236 | println!( | ||
237 | "Expressions of unknown type: {} ({}%)", | ||
238 | num_exprs_unknown, | ||
239 | if num_exprs > 0 { num_exprs_unknown * 100 / num_exprs } else { 100 } | ||
240 | ); | ||
241 | println!( | ||
242 | "Expressions of partially unknown type: {} ({}%)", | ||
243 | num_exprs_partially_unknown, | ||
244 | if num_exprs > 0 { num_exprs_partially_unknown * 100 / num_exprs } else { 100 } | ||
245 | ); | ||
246 | println!("Type mismatches: {}", num_type_mismatches); | ||
247 | println!("Inference: {:?}, {}", inference_time.elapsed(), ra_prof::memory_usage()); | ||
248 | println!("Total: {:?}, {}", analysis_time.elapsed(), ra_prof::memory_usage()); | ||
249 | |||
250 | if memory_usage { | ||
251 | for (name, bytes) in host.per_query_memory_usage() { | ||
252 | println!("{:>8} {}", bytes, name) | ||
253 | } | ||
254 | let before = ra_prof::memory_usage(); | ||
255 | drop(host); | ||
256 | println!("leftover: {}", before.allocated - ra_prof::memory_usage().allocated) | ||
257 | } | ||
258 | |||
259 | Ok(()) | ||
260 | } | ||