1use std::cell::Cell;
9use std::ffi::OsString;
10use std::io::Write;
11use std::sync::Once;
12
13use clap::Parser;
14use serde_json::Map;
15
16mod args;
17mod baseline;
18mod cache;
19mod cache_command;
20mod commands;
21mod config;
22mod config_toml;
23mod env;
24mod error;
25mod explain;
26mod filter;
27mod fix;
28mod format;
29mod install;
30mod instances;
31mod lint;
32mod lsp;
33mod mcp;
34mod migrate;
35mod npmrc;
36mod output;
37mod registry;
38mod roots;
39mod trace;
40mod update;
41mod watch;
42mod write;
43
44use args::{Cli, Command, Format};
45use env::Env;
46pub use error::{CliError, Kind};
47use lint::Teardown;
48pub use lint::{LintCache, lint_to_json, lint_to_json_cached};
49use output::{emit_error, emit_error_with};
50
51pub fn run(args: impl IntoIterator<Item = OsString>) -> u8 {
68 let raw: Vec<OsString> = args.into_iter().collect();
69 exit_two_on_panic(&raw, &mut std::io::stdout(), || run_with(raw.clone(), Teardown::Free))
70}
71
72thread_local! {
73 static LAST_PANIC: Cell<Option<String>> = const { Cell::new(None) };
77}
78
79fn record_panics() {
82 static ONCE: Once = Once::new();
83 ONCE.call_once(|| {
84 let previous = std::panic::take_hook();
85 std::panic::set_hook(Box::new(move |info| {
86 let _ = LAST_PANIC.try_with(|last| last.set(Some(info.to_string())));
88 previous(info);
89 }));
90 });
91}
92
93const WORKER_STACK_SIZE: usize = 64 << 20;
97
98pub fn configure_global_pool() {
101 static ONCE: Once = Once::new();
102 ONCE.call_once(|| {
103 let _ = rayon::ThreadPoolBuilder::new()
104 .stack_size(WORKER_STACK_SIZE)
105 .thread_name(|index| format!("skif-worker-{index}"))
106 .build_global();
107 });
108}
109
110fn exit_two_on_panic(raw: &[OsString], stdout: &mut dyn Write, body: impl FnOnce() -> u8) -> u8 {
116 record_panics();
117 LAST_PANIC.with(|last| last.set(None));
118 let outcome = std::panic::catch_unwind(std::panic::AssertUnwindSafe(body));
119 skif_core::timing::flush_stderr();
120 outcome.unwrap_or_else(|payload| {
121 let recorded = LAST_PANIC.with(Cell::take);
122 let format = error_format(raw);
123 if matches!(format, Format::Json | Format::Toon) {
124 let text = payload
125 .downcast_ref::<&str>()
126 .copied()
127 .or_else(|| payload.downcast_ref::<String>().map(String::as_str));
128 let report = match (recorded, text) {
129 (Some(recorded), Some(text)) if !recorded.ends_with(text) => text.to_owned(),
130 (Some(recorded), _) => recorded,
131 (None, text) => text.unwrap_or("panic").to_owned(),
132 };
133 emit_error_with(&internal_error(&report), format, Map::new(), stdout);
134 }
135 2
136 })
137}
138
139fn internal_error(report: &str) -> CliError {
142 CliError::new(Kind::Internal, format!("internal error: {report}"))
143}
144
145pub fn run_to_exit(args: impl IntoIterator<Item = OsString>) -> u8 {
156 let raw: Vec<OsString> = args.into_iter().collect();
157 if let Err(error) = env::enter_bazel_run_directory() {
158 emit_error(&error, error_format(&raw));
159 return 2;
160 }
161 exit_two_on_panic(&raw, &mut std::io::stdout(), || run_with(raw.clone(), Teardown::Leak))
162}
163
164fn run_with(args: impl IntoIterator<Item = OsString>, teardown: Teardown) -> u8 {
165 let raw: Vec<OsString> = args.into_iter().collect();
166 configure_global_pool();
167 env::enable_timings();
168 if let Some(error) = removed_flag(&raw) {
169 emit_error(&error, error_format(&raw));
170 return 2;
171 }
172 let cli = match Cli::try_parse_from(&raw) {
173 Ok(cli) => cli,
174 Err(error) => return usage(&raw, &error),
175 };
176 match cli.command {
177 None if cli.lint.watch => watch::run(&cli.lint, Env::detect()),
178 None => lint::run(&cli.lint, Env::detect(), teardown),
179 Some(Command::Rules(args)) => commands::rules(&args),
180 Some(Command::Schema) => commands::schema(),
181 Some(Command::Init(args)) => commands::init(&args),
182 Some(Command::Config(args)) => config::run(&args),
183 Some(Command::ExplainUsage(args)) => explain::run(&args),
184 Some(Command::Migrate(args)) => migrate::run(&args),
185 Some(Command::Baseline(args)) => baseline::run(&args),
186 Some(Command::Update(args)) => update::run(&args, Env::detect()),
187 Some(Command::List(args)) => instances::list(&args),
188 Some(Command::Json(args)) => instances::json(&args),
189 Some(Command::Format(args)) => format::run(&args, Env::detect(), teardown),
190 Some(Command::Cache(args)) => cache_command::run(&args),
191 Some(Command::Mcp) => mcp::run(),
192 Some(Command::Lsp) => lsp::run(),
193 }
194}
195
196const REMOVED_FLAGS: [&str; 2] = ["--type-aware", "--no-type-aware"];
198
199fn removed_flag(raw: &[OsString]) -> Option<CliError> {
202 raw.iter()
203 .skip(1)
204 .take_while(|arg| arg.to_str() != Some("--"))
205 .filter_map(|arg| arg.to_str()?.split('=').next())
206 .find(|flag| REMOVED_FLAGS.contains(flag))
207 .map(|flag| {
208 CliError::new(
209 Kind::Usage,
210 format!(
211 "`{flag}` is no longer a flag: type-aware analysis was removed in skif 0.9.0 and every member is \
212 judged by name, as it was without types; drop the flag"
213 ),
214 )
215 })
216}
217
218fn usage(raw: &[OsString], error: &clap::Error) -> u8 {
221 if !error.use_stderr() {
222 let _ = error.print();
223 return 0;
224 }
225 let format = error_format(raw);
226 if matches!(format, Format::Json | Format::Toon) {
227 let message = error.to_string();
228 emit_error(&CliError::new(Kind::Usage, message.trim_end()), format);
229 } else {
230 let _ = error.print();
231 }
232 2
233}
234
235fn error_format(raw: &[OsString]) -> Format {
239 let args: Vec<&str> = raw.iter().filter_map(|arg| arg.to_str()).collect();
240 let mut values = Vec::new();
241 for (index, arg) in args.iter().enumerate() {
242 if let Some(value) = arg.strip_prefix("--format=") {
243 values.push(value);
244 } else if *arg == "--format" {
245 values.extend(args.get(index + 1));
246 }
247 }
248 let chosen = values
249 .iter()
250 .find(|value| !value.contains('='))
251 .or_else(|| values.first())
252 .and_then(|value| value.split('=').next());
253 match chosen {
254 Some("json") => Format::Json,
255 Some("toon") => Format::Toon,
256 _ => Format::Human,
257 }
258}
259
260#[cfg(test)]
261mod tests {
262 use super::*;
263
264 fn args(list: &[&str]) -> Vec<OsString> {
265 list.iter().map(OsString::from).collect()
266 }
267
268 #[test]
269 fn a_removed_type_aware_flag_is_named_before_clap_parses() {
270 for flag in REMOVED_FLAGS {
271 for raw in [
272 args(&["skif", flag]),
273 args(&["skif", "explain-usage", "a.ts", flag]),
274 args(&["skif", "baseline", "write", &format!("{flag}=true")]),
275 ] {
276 let error = removed_flag(&raw).unwrap_or_else(|| panic!("{raw:?}"));
277 assert_eq!(error.kind, Kind::Usage);
278 let message = error.to_string();
279 assert!(
280 message.starts_with(&format!("`{flag}` is no longer a flag")),
281 "{message}"
282 );
283 assert!(
284 message.contains("type-aware analysis was removed in skif 0.9.0"),
285 "{message}"
286 );
287 }
288 }
289 assert!(removed_flag(&args(&["skif", "--no-js", "."])).is_none());
290 assert!(
291 removed_flag(&args(&["skif", "--", "--type-aware"])).is_none(),
292 "a path after `--`"
293 );
294 }
295
296 #[test]
297 fn a_panic_exits_two_in_every_format() {
298 for (raw, format) in [
299 (args(&["skif"]), Format::Human),
300 (args(&["skif", "--format", "json"]), Format::Json),
301 (args(&["skif", "--format", "toon"]), Format::Toon),
302 ] {
303 let mut stdout = Vec::new();
304 assert_eq!(exit_two_on_panic(&raw, &mut stdout, || panic!("boom")), 2);
305 let text = String::from_utf8_lossy(&stdout);
306 let document: serde_json::Value = match format {
307 Format::Json => serde_json::from_str(&text).unwrap(),
308 Format::Toon => serde_toon::decode_to_value(&text).unwrap_or_else(|error| panic!("{error}: {text:?}")),
309 _ => {
310 assert!(stdout.is_empty(), "{text}");
311 continue;
312 }
313 };
314 assert_eq!(document["error"]["kind"], "internal", "{document:#}");
315 let message = document["error"]["message"].as_str().unwrap();
316 assert!(
317 message.starts_with("internal error: panicked at ")
318 && message.contains("lib.rs:")
319 && message.ends_with(":\nboom"),
320 "the message names the location and the panic: {message}"
321 );
322 }
323 }
324
325 fn panic_message(body: impl FnOnce() -> u8) -> String {
327 let mut stdout = Vec::new();
328 assert_eq!(
329 exit_two_on_panic(&args(&["skif", "--format", "json"]), &mut stdout, body),
330 2
331 );
332 let document: serde_json::Value = serde_json::from_slice(&stdout).unwrap();
333 document["error"]["message"].as_str().unwrap().to_owned()
334 }
335
336 #[test]
337 fn a_panic_on_another_thread_is_not_reported_as_this_one() {
338 let message = panic_message(|| {
341 let other = std::thread::spawn(|| std::panic::panic_any("another thread's panic"));
342 assert!(other.join().is_err(), "the other thread panicked");
343 std::panic::resume_unwind(Box::new("boom"))
344 });
345 assert_eq!(message, "internal error: boom");
346 }
347
348 #[test]
349 fn a_panic_caught_earlier_on_this_thread_is_not_reported_again() {
350 record_panics();
351 let earlier = std::panic::catch_unwind(|| std::panic::panic_any("an earlier panic"));
352 assert!(earlier.is_err(), "the earlier body panicked");
353 let message = panic_message(|| std::panic::resume_unwind(Box::new(String::from("boom"))));
354 assert_eq!(message, "internal error: boom");
355 }
356
357 #[test]
358 fn a_panic_caught_inside_the_run_does_not_end_it() {
359 let mut stdout = Vec::new();
360 let code = exit_two_on_panic(&args(&["skif", "--format", "json"]), &mut stdout, || {
361 let fallback = std::panic::catch_unwind(|| std::panic::panic_any("the checker's panic"));
362 assert!(fallback.is_err(), "the inner body panicked");
363 0
364 });
365 assert_eq!(code, 0);
366 assert_eq!(stdout, b"");
367 }
368
369 #[test]
370 fn a_panic_caught_inside_the_run_is_not_reported_as_the_one_that_ended_it() {
371 let message = panic_message(|| {
372 let fallback = std::panic::catch_unwind(|| std::panic::panic_any("the checker's panic"));
373 assert!(fallback.is_err(), "the inner body panicked");
374 std::panic::resume_unwind(Box::new("a worker's panic"))
375 });
376 assert_eq!(message, "internal error: a worker's panic");
377 }
378
379 #[test]
380 fn a_panic_of_a_rayon_worker_exits_two() {
381 let message = panic_message(|| {
382 rayon::scope(|scope| scope.spawn(|_| panic!("a worker's panic")));
383 0
384 });
385 assert!(message.ends_with("a worker's panic"), "{message}");
386 }
387
388 #[test]
389 fn without_a_panic_the_exit_code_is_the_body_s() {
390 let mut stdout = Vec::new();
391 assert_eq!(
392 exit_two_on_panic(&args(&["skif", "--format", "json"]), &mut stdout, || 1),
393 1
394 );
395 assert_eq!(stdout, b"");
396 }
397}