1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
|
//! Command like parsing for rust-analyzer.
//!
//! If run started args, we run the LSP server loop. With a subcommand, we do a
//! one-time batch processing.
use std::{env, fmt::Write, path::PathBuf};
use anyhow::{bail, Result};
use pico_args::Arguments;
use ra_ssr::{SsrPattern, SsrRule};
use rust_analyzer::cli::{AnalysisStatsCmd, BenchCmd, BenchWhat, Position, Verbosity};
use vfs::AbsPathBuf;
pub(crate) struct Args {
pub(crate) verbosity: Verbosity,
pub(crate) command: Command,
}
pub(crate) enum Command {
Parse {
no_dump: bool,
},
Symbols,
Highlight {
rainbow: bool,
},
AnalysisStats(AnalysisStatsCmd),
Bench(BenchCmd),
Diagnostics {
path: PathBuf,
load_output_dirs: bool,
with_proc_macro: bool,
/// Include files which are not modules. In rust-analyzer
/// this would include the parser test files.
all: bool,
},
Ssr {
rules: Vec<SsrRule>,
},
StructuredSearch {
debug_snippet: Option<String>,
patterns: Vec<SsrPattern>,
},
ProcMacro,
RunServer,
Version,
}
impl Args {
pub(crate) fn parse() -> Result<Result<Args, HelpPrinted>> {
let mut matches = Arguments::from_env();
if matches.contains("--version") {
matches.finish().or_else(handle_extra_flags)?;
return Ok(Ok(Args { verbosity: Verbosity::Normal, command: Command::Version }));
}
let verbosity = match (
matches.contains(["-vv", "--spammy"]),
matches.contains(["-v", "--verbose"]),
matches.contains(["-q", "--quiet"]),
) {
(true, _, true) => bail!("Invalid flags: -q conflicts with -vv"),
(true, _, false) => Verbosity::Spammy,
(false, false, false) => Verbosity::Normal,
(false, false, true) => Verbosity::Quiet,
(false, true, false) => Verbosity::Verbose,
(false, true, true) => bail!("Invalid flags: -q conflicts with -v"),
};
let subcommand = match matches.subcommand()? {
Some(it) => it,
None => {
if matches.contains(["-h", "--help"]) {
print_subcommands();
return Ok(Err(HelpPrinted));
}
matches.finish().or_else(handle_extra_flags)?;
return Ok(Ok(Args { verbosity, command: Command::RunServer }));
}
};
let command = match subcommand.as_str() {
"parse" => {
if matches.contains(["-h", "--help"]) {
eprintln!(
"\
rust-analyzer parse
USAGE:
rust-analyzer parse [FLAGS]
FLAGS:
-h, --help Prints help information
--no-dump"
);
return Ok(Err(HelpPrinted));
}
let no_dump = matches.contains("--no-dump");
matches.finish().or_else(handle_extra_flags)?;
Command::Parse { no_dump }
}
"symbols" => {
if matches.contains(["-h", "--help"]) {
eprintln!(
"\
rust-analyzer symbols
USAGE:
rust-analyzer highlight [FLAGS]
FLAGS:
-h, --help Prints help inforamtion"
);
return Ok(Err(HelpPrinted));
}
matches.finish().or_else(handle_extra_flags)?;
Command::Symbols
}
"highlight" => {
if matches.contains(["-h", "--help"]) {
eprintln!(
"\
rust-analyzer highlight
USAGE:
rust-analyzer highlight [FLAGS]
FLAGS:
-h, --help Prints help information
-r, --rainbow"
);
return Ok(Err(HelpPrinted));
}
let rainbow = matches.contains(["-r", "--rainbow"]);
matches.finish().or_else(handle_extra_flags)?;
Command::Highlight { rainbow }
}
"analysis-stats" => {
if matches.contains(["-h", "--help"]) {
eprintln!(
"\
rust-analyzer analysis-stats
USAGE:
rust-analyzer analysis-stats [FLAGS] [OPTIONS] [PATH]
FLAGS:
-o, --only Only analyze items matching this path
-h, --help Prints help information
--memory-usage Collect memory usage statistics
--randomize Randomize order in which crates, modules, and items are processed
--parallel Run type inference in parallel
--load-output-dirs Load OUT_DIR values by running `cargo check` before analysis
--with-proc-macro Use ra-proc-macro-srv for proc-macro expanding
--with-deps Also analyze all dependencies
-v, --verbose
-q, --quiet
OPTIONS:
-o <ONLY>
ARGS:
<PATH>"
);
return Ok(Err(HelpPrinted));
}
let randomize = matches.contains("--randomize");
let parallel = matches.contains("--parallel");
let memory_usage = matches.contains("--memory-usage");
let only: Option<String> = matches.opt_value_from_str(["-o", "--only"])?;
let with_deps: bool = matches.contains("--with-deps");
let load_output_dirs = matches.contains("--load-output-dirs");
let with_proc_macro = matches.contains("--with-proc-macro");
let path = {
let mut trailing = matches.free()?;
if trailing.len() != 1 {
bail!("Invalid flags");
}
trailing.pop().unwrap().into()
};
Command::AnalysisStats(AnalysisStatsCmd {
randomize,
parallel,
memory_usage,
only,
with_deps,
path,
load_output_dirs,
with_proc_macro,
})
}
"analysis-bench" => {
if matches.contains(["-h", "--help"]) {
eprintln!(
"\
rust-analyzer analysis-bench
USAGE:
rust-analyzer analysis-bench [FLAGS] [OPTIONS]
FLAGS:
-h, --help Prints help information
--memory-usage Collect memory usage statistics
--load-output-dirs Load OUT_DIR values by running `cargo check` before analysis
--with-proc-macro Use ra-proc-macro-srv for proc-macro expanding
-v, --verbose
OPTIONS:
--project <PATH> Path to directory with Cargo.toml
--complete <PATH:LINE:COLUMN> Compute completions at this location
--goto-def <PATH:LINE:COLUMN> Compute goto definition at this location
--highlight <PATH> Hightlight this file
ARGS:
<PATH> Project to analyse"
);
return Ok(Err(HelpPrinted));
}
let path: PathBuf = matches.opt_value_from_str("--project")?.unwrap_or_default();
let highlight_path: Option<String> = matches.opt_value_from_str("--highlight")?;
let complete_path: Option<Position> = matches.opt_value_from_str("--complete")?;
let goto_def_path: Option<Position> = matches.opt_value_from_str("--goto-def")?;
let what = match (highlight_path, complete_path, goto_def_path) {
(Some(path), None, None) => {
let path = env::current_dir().unwrap().join(path);
BenchWhat::Highlight { path: AbsPathBuf::assert(path) }
}
(None, Some(position), None) => BenchWhat::Complete(position),
(None, None, Some(position)) => BenchWhat::GotoDef(position),
_ => panic!(
"exactly one of `--highlight`, `--complete` or `--goto-def` must be set"
),
};
let memory_usage = matches.contains("--memory-usage");
let load_output_dirs = matches.contains("--load-output-dirs");
let with_proc_macro = matches.contains("--with-proc-macro");
Command::Bench(BenchCmd {
memory_usage,
path,
what,
load_output_dirs,
with_proc_macro,
})
}
"diagnostics" => {
if matches.contains(["-h", "--help"]) {
eprintln!(
"\
rust-analyzer diagnostics
USAGE:
rust-analyzer diagnostics [FLAGS] [PATH]
FLAGS:
-h, --help Prints help information
--load-output-dirs Load OUT_DIR values by running `cargo check` before analysis
--all Include all files rather than only modules
ARGS:
<PATH>"
);
return Ok(Err(HelpPrinted));
}
let load_output_dirs = matches.contains("--load-output-dirs");
let with_proc_macro = matches.contains("--with-proc-macro");
let all = matches.contains("--all");
let path = {
let mut trailing = matches.free()?;
if trailing.len() != 1 {
bail!("Invalid flags");
}
trailing.pop().unwrap().into()
};
Command::Diagnostics { path, load_output_dirs, with_proc_macro, all }
}
"proc-macro" => Command::ProcMacro,
"ssr" => {
if matches.contains(["-h", "--help"]) {
eprintln!(
"\
rust-analyzer ssr
USAGE:
rust-analyzer ssr [FLAGS] [RULE...]
EXAMPLE:
rust-analyzer ssr '$a.foo($b) ==> bar($a, $b)'
FLAGS:
--debug <snippet> Prints debug information for any nodes with source exactly equal to <snippet>
-h, --help Prints help information
ARGS:
<RULE> A structured search replace rule"
);
return Ok(Err(HelpPrinted));
}
let mut rules = Vec::new();
while let Some(rule) = matches.free_from_str()? {
rules.push(rule);
}
Command::Ssr { rules }
}
"search" => {
if matches.contains(["-h", "--help"]) {
eprintln!(
"\
rust-analyzer search
USAGE:
rust-analyzer search [FLAGS] [PATTERN...]
EXAMPLE:
rust-analyzer search '$a.foo($b)'
FLAGS:
--debug <snippet> Prints debug information for any nodes with source exactly equal to <snippet>
-h, --help Prints help information
ARGS:
<PATTERN> A structured search pattern"
);
return Ok(Err(HelpPrinted));
}
let debug_snippet = matches.opt_value_from_str("--debug")?;
let mut patterns = Vec::new();
while let Some(rule) = matches.free_from_str()? {
patterns.push(rule);
}
Command::StructuredSearch { patterns, debug_snippet }
}
_ => {
print_subcommands();
return Ok(Err(HelpPrinted));
}
};
Ok(Ok(Args { verbosity, command }))
}
}
fn print_subcommands() {
eprintln!(
"\
rust-analyzer
USAGE:
rust-analyzer <SUBCOMMAND>
FLAGS:
-h, --help Prints help information
SUBCOMMANDS:
analysis-bench
analysis-stats
highlight
diagnostics
proc-macro
parse
search
ssr
symbols"
)
}
pub(crate) struct HelpPrinted;
fn handle_extra_flags(e: pico_args::Error) -> Result<()> {
if let pico_args::Error::UnusedArgsLeft(flags) = e {
let mut invalid_flags = String::new();
for flag in flags {
write!(&mut invalid_flags, "{}, ", flag)?;
}
let (invalid_flags, _) = invalid_flags.split_at(invalid_flags.len() - 2);
bail!("Invalid flags: {}", invalid_flags);
} else {
bail!(e);
}
}
|