2020-08-10 19:12:09 -05:00
|
|
|
//! Flycheck provides the functionality needed to run `cargo check` or
|
2019-12-27 04:10:07 -06:00
|
|
|
//! another compatible command (f.x. clippy) in a background thread and provide
|
|
|
|
//! LSP diagnostics based on the output of the command.
|
2020-03-31 17:16:16 -05:00
|
|
|
|
2023-12-05 04:35:09 -06:00
|
|
|
#![warn(rust_2018_idioms, unused_lifetimes)]
|
2022-07-20 07:59:42 -05:00
|
|
|
|
2022-06-13 06:34:07 -05:00
|
|
|
use std::{
|
2023-08-15 18:02:55 -05:00
|
|
|
ffi::OsString,
|
2022-06-13 06:34:07 -05:00
|
|
|
fmt, io,
|
2023-08-15 18:02:55 -05:00
|
|
|
path::PathBuf,
|
2022-06-13 06:34:07 -05:00
|
|
|
process::{ChildStderr, ChildStdout, Command, Stdio},
|
|
|
|
time::Duration,
|
|
|
|
};
|
2019-12-27 04:10:07 -06:00
|
|
|
|
2022-11-05 10:28:04 -05:00
|
|
|
use command_group::{CommandGroup, GroupChild};
|
2020-06-25 06:47:22 -05:00
|
|
|
use crossbeam_channel::{never, select, unbounded, Receiver, Sender};
|
2023-10-04 09:34:34 -05:00
|
|
|
use paths::{AbsPath, AbsPathBuf};
|
2022-08-18 16:41:17 -05:00
|
|
|
use rustc_hash::FxHashMap;
|
2021-04-18 18:36:29 -05:00
|
|
|
use serde::Deserialize;
|
2022-11-05 10:28:04 -05:00
|
|
|
use stdx::process::streaming_output;
|
2019-12-29 11:27:14 -06:00
|
|
|
|
2020-05-14 18:58:39 -05:00
|
|
|
pub use cargo_metadata::diagnostic::{
|
2020-07-09 08:34:37 -05:00
|
|
|
Applicability, Diagnostic, DiagnosticCode, DiagnosticLevel, DiagnosticSpan,
|
|
|
|
DiagnosticSpanMacroExpansion,
|
2020-05-14 18:58:39 -05:00
|
|
|
};
|
2024-02-14 08:13:45 -06:00
|
|
|
use toolchain::Tool;
|
2020-05-14 18:58:39 -05:00
|
|
|
|
2022-09-15 06:28:09 -05:00
|
|
|
#[derive(Copy, Clone, Debug, Default, PartialEq, Eq)]
|
|
|
|
pub enum InvocationStrategy {
|
2022-10-19 16:34:36 -05:00
|
|
|
Once,
|
2022-09-15 06:28:09 -05:00
|
|
|
#[default]
|
|
|
|
PerWorkspace,
|
|
|
|
}
|
|
|
|
|
2022-10-22 16:02:59 -05:00
|
|
|
#[derive(Clone, Debug, Default, PartialEq, Eq)]
|
|
|
|
pub enum InvocationLocation {
|
|
|
|
Root(AbsPathBuf),
|
|
|
|
#[default]
|
|
|
|
Workspace,
|
|
|
|
}
|
|
|
|
|
2020-04-01 11:41:43 -05:00
|
|
|
#[derive(Clone, Debug, PartialEq, Eq)]
|
2020-04-01 05:31:42 -05:00
|
|
|
pub enum FlycheckConfig {
|
2020-06-09 14:47:54 -05:00
|
|
|
CargoCommand {
|
|
|
|
command: String,
|
2022-09-24 18:22:27 -05:00
|
|
|
target_triples: Vec<String>,
|
2020-06-09 14:47:54 -05:00
|
|
|
all_targets: bool,
|
2020-07-30 09:04:01 -05:00
|
|
|
no_default_features: bool,
|
2020-06-09 14:47:54 -05:00
|
|
|
all_features: bool,
|
|
|
|
features: Vec<String>,
|
|
|
|
extra_args: Vec<String>,
|
2022-08-18 16:41:17 -05:00
|
|
|
extra_env: FxHashMap<String, String>,
|
2023-01-04 11:04:45 -06:00
|
|
|
ansi_color_output: bool,
|
2023-09-30 21:02:12 -05:00
|
|
|
target_dir: Option<PathBuf>,
|
2020-06-09 14:47:54 -05:00
|
|
|
},
|
|
|
|
CustomCommand {
|
|
|
|
command: String,
|
|
|
|
args: Vec<String>,
|
2022-08-18 16:41:17 -05:00
|
|
|
extra_env: FxHashMap<String, String>,
|
2022-09-15 06:28:09 -05:00
|
|
|
invocation_strategy: InvocationStrategy,
|
2022-10-22 16:02:59 -05:00
|
|
|
invocation_location: InvocationLocation,
|
2020-06-09 14:47:54 -05:00
|
|
|
},
|
2019-12-27 04:10:07 -06:00
|
|
|
}
|
|
|
|
|
2020-05-10 10:35:33 -05:00
|
|
|
impl fmt::Display for FlycheckConfig {
|
|
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
|
|
match self {
|
2022-12-23 12:42:58 -06:00
|
|
|
FlycheckConfig::CargoCommand { command, .. } => write!(f, "cargo {command}"),
|
2022-08-18 16:41:17 -05:00
|
|
|
FlycheckConfig::CustomCommand { command, args, .. } => {
|
2022-12-23 12:42:58 -06:00
|
|
|
write!(f, "{command} {}", args.join(" "))
|
2020-05-10 10:35:33 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-01 04:09:19 -05:00
|
|
|
/// Flycheck wraps the shared state and communication machinery used for
|
2019-12-27 04:10:07 -06:00
|
|
|
/// running `cargo check` (or other compatible command) and providing
|
|
|
|
/// diagnostics based on the output.
|
2019-12-27 04:43:05 -06:00
|
|
|
/// The spawned thread is shut down when this struct is dropped.
|
2019-12-27 04:10:07 -06:00
|
|
|
#[derive(Debug)]
|
2020-06-25 01:24:27 -05:00
|
|
|
pub struct FlycheckHandle {
|
2020-03-28 05:31:10 -05:00
|
|
|
// XXX: drop order is significant
|
2023-02-28 05:08:23 -06:00
|
|
|
sender: Sender<StateChange>,
|
2023-05-20 07:29:32 -05:00
|
|
|
_thread: stdx::thread::JoinHandle,
|
2022-07-18 13:30:07 -05:00
|
|
|
id: usize,
|
2019-12-27 04:10:07 -06:00
|
|
|
}
|
|
|
|
|
2020-06-25 01:24:27 -05:00
|
|
|
impl FlycheckHandle {
|
2020-06-25 01:39:33 -05:00
|
|
|
pub fn spawn(
|
2020-09-17 11:50:30 -05:00
|
|
|
id: usize,
|
2020-06-25 02:19:01 -05:00
|
|
|
sender: Box<dyn Fn(Message) + Send>,
|
2020-06-25 01:39:33 -05:00
|
|
|
config: FlycheckConfig,
|
2024-02-14 08:13:45 -06:00
|
|
|
sysroot_root: Option<AbsPathBuf>,
|
2021-07-17 09:40:13 -05:00
|
|
|
workspace_root: AbsPathBuf,
|
2020-06-25 01:39:33 -05:00
|
|
|
) -> FlycheckHandle {
|
2024-02-14 08:13:45 -06:00
|
|
|
let actor = FlycheckActor::new(id, sender, config, sysroot_root, workspace_root);
|
2023-02-28 05:08:23 -06:00
|
|
|
let (sender, receiver) = unbounded::<StateChange>();
|
2023-05-26 12:18:17 -05:00
|
|
|
let thread = stdx::thread::Builder::new(stdx::thread::ThreadIntent::Worker)
|
2021-07-08 07:39:41 -05:00
|
|
|
.name("Flycheck".to_owned())
|
2021-07-07 11:48:36 -05:00
|
|
|
.spawn(move || actor.run(receiver))
|
|
|
|
.expect("failed to spawn thread");
|
2022-07-18 13:30:07 -05:00
|
|
|
FlycheckHandle { id, sender, _thread: thread }
|
2020-01-11 14:32:40 -06:00
|
|
|
}
|
|
|
|
|
2024-02-08 03:40:42 -06:00
|
|
|
/// Schedule a re-start of the cargo check worker to do a workspace wide check.
|
2023-10-04 09:34:34 -05:00
|
|
|
pub fn restart_workspace(&self, saved_file: Option<AbsPathBuf>) {
|
|
|
|
self.sender.send(StateChange::Restart { package: None, saved_file }).unwrap();
|
2024-02-08 03:40:42 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Schedule a re-start of the cargo check worker to do a package wide check.
|
|
|
|
pub fn restart_for_package(&self, package: String) {
|
2023-10-04 09:34:34 -05:00
|
|
|
self.sender
|
|
|
|
.send(StateChange::Restart { package: Some(package), saved_file: None })
|
|
|
|
.unwrap();
|
2022-08-19 01:52:31 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Stop this cargo check worker.
|
|
|
|
pub fn cancel(&self) {
|
2023-02-28 05:08:23 -06:00
|
|
|
self.sender.send(StateChange::Cancel).unwrap();
|
2019-12-27 04:10:07 -06:00
|
|
|
}
|
2022-07-18 13:30:07 -05:00
|
|
|
|
|
|
|
pub fn id(&self) -> usize {
|
|
|
|
self.id
|
|
|
|
}
|
2019-12-27 04:10:07 -06:00
|
|
|
}
|
|
|
|
|
2020-06-25 02:19:01 -05:00
|
|
|
pub enum Message {
|
2020-01-15 08:50:49 -06:00
|
|
|
/// Request adding a diagnostic with fixes included to a file
|
2022-07-20 04:49:36 -05:00
|
|
|
AddDiagnostic { id: usize, workspace_root: AbsPathBuf, diagnostic: Diagnostic },
|
2020-06-25 01:01:03 -05:00
|
|
|
|
|
|
|
/// Request check progress notification to client
|
2020-09-17 11:50:30 -05:00
|
|
|
Progress {
|
|
|
|
/// Flycheck instance ID
|
|
|
|
id: usize,
|
|
|
|
progress: Progress,
|
|
|
|
},
|
2020-06-25 01:01:03 -05:00
|
|
|
}
|
|
|
|
|
2021-01-28 08:04:44 -06:00
|
|
|
impl fmt::Debug for Message {
|
|
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
|
|
match self {
|
2022-07-20 04:49:36 -05:00
|
|
|
Message::AddDiagnostic { id, workspace_root, diagnostic } => f
|
2021-01-28 08:04:44 -06:00
|
|
|
.debug_struct("AddDiagnostic")
|
2022-07-20 04:49:36 -05:00
|
|
|
.field("id", id)
|
2021-01-28 08:04:44 -06:00
|
|
|
.field("workspace_root", workspace_root)
|
|
|
|
.field("diagnostic_code", &diagnostic.code.as_ref().map(|it| &it.code))
|
|
|
|
.finish(),
|
|
|
|
Message::Progress { id, progress } => {
|
|
|
|
f.debug_struct("Progress").field("id", id).field("progress", progress).finish()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-25 01:01:03 -05:00
|
|
|
#[derive(Debug)]
|
2020-06-25 02:19:01 -05:00
|
|
|
pub enum Progress {
|
2020-06-26 09:17:22 -05:00
|
|
|
DidStart,
|
2020-06-25 02:19:01 -05:00
|
|
|
DidCheckCrate(String),
|
2020-06-28 16:42:44 -05:00
|
|
|
DidFinish(io::Result<()>),
|
2020-06-26 09:17:22 -05:00
|
|
|
DidCancel,
|
2022-08-22 10:42:33 -05:00
|
|
|
DidFailToRestart(String),
|
2019-12-27 04:10:07 -06:00
|
|
|
}
|
|
|
|
|
2023-02-28 05:08:23 -06:00
|
|
|
enum StateChange {
|
2023-10-04 09:34:34 -05:00
|
|
|
Restart { package: Option<String>, saved_file: Option<AbsPathBuf> },
|
2023-02-28 05:08:23 -06:00
|
|
|
Cancel,
|
2022-08-19 01:52:31 -05:00
|
|
|
}
|
2019-12-27 04:10:07 -06:00
|
|
|
|
2022-09-15 06:28:09 -05:00
|
|
|
/// A [`FlycheckActor`] is a single check instance of a workspace.
|
2020-06-25 01:24:27 -05:00
|
|
|
struct FlycheckActor {
|
2022-09-15 06:28:09 -05:00
|
|
|
/// The workspace id of this flycheck instance.
|
2020-09-17 11:50:30 -05:00
|
|
|
id: usize,
|
2020-06-25 02:19:01 -05:00
|
|
|
sender: Box<dyn Fn(Message) + Send>,
|
2020-04-01 05:03:06 -05:00
|
|
|
config: FlycheckConfig,
|
2022-09-26 08:58:55 -05:00
|
|
|
/// Either the workspace root of the workspace we are flychecking,
|
|
|
|
/// or the project root of the project.
|
|
|
|
root: AbsPathBuf,
|
2024-02-14 08:13:45 -06:00
|
|
|
sysroot_root: Option<AbsPathBuf>,
|
2022-06-13 06:34:07 -05:00
|
|
|
/// CargoHandle exists to wrap around the communication needed to be able to
|
2020-03-31 17:39:50 -05:00
|
|
|
/// run `cargo check` without blocking. Currently the Rust standard library
|
|
|
|
/// doesn't provide a way to read sub-process output without blocking, so we
|
|
|
|
/// have to wrap sub-processes output handling in a thread and pass messages
|
|
|
|
/// back over a channel.
|
2023-08-15 17:58:21 -05:00
|
|
|
command_handle: Option<CommandHandle>,
|
2020-06-25 06:47:22 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
enum Event {
|
2023-02-28 05:08:23 -06:00
|
|
|
RequestStateChange(StateChange),
|
2021-04-18 18:36:29 -05:00
|
|
|
CheckEvent(Option<CargoMessage>),
|
2019-12-27 04:43:05 -06:00
|
|
|
}
|
|
|
|
|
2023-10-04 09:34:34 -05:00
|
|
|
const SAVED_FILE_PLACEHOLDER: &str = "$saved_file";
|
|
|
|
|
2020-06-25 01:24:27 -05:00
|
|
|
impl FlycheckActor {
|
2020-06-25 01:39:33 -05:00
|
|
|
fn new(
|
2020-09-17 11:50:30 -05:00
|
|
|
id: usize,
|
2020-06-25 02:19:01 -05:00
|
|
|
sender: Box<dyn Fn(Message) + Send>,
|
2020-06-25 01:39:33 -05:00
|
|
|
config: FlycheckConfig,
|
2024-02-14 08:13:45 -06:00
|
|
|
sysroot_root: Option<AbsPathBuf>,
|
2021-07-17 09:40:13 -05:00
|
|
|
workspace_root: AbsPathBuf,
|
2020-06-25 01:39:33 -05:00
|
|
|
) -> FlycheckActor {
|
2022-08-19 01:52:31 -05:00
|
|
|
tracing::info!(%id, ?workspace_root, "Spawning flycheck");
|
2024-02-14 08:13:45 -06:00
|
|
|
FlycheckActor {
|
|
|
|
id,
|
|
|
|
sender,
|
|
|
|
config,
|
|
|
|
sysroot_root,
|
|
|
|
root: workspace_root,
|
|
|
|
command_handle: None,
|
|
|
|
}
|
2020-09-17 11:50:30 -05:00
|
|
|
}
|
2022-09-15 06:28:09 -05:00
|
|
|
|
|
|
|
fn report_progress(&self, progress: Progress) {
|
2020-09-17 11:50:30 -05:00
|
|
|
self.send(Message::Progress { id: self.id, progress });
|
2019-12-27 04:10:07 -06:00
|
|
|
}
|
2022-09-15 06:28:09 -05:00
|
|
|
|
2023-02-28 05:08:23 -06:00
|
|
|
fn next_event(&self, inbox: &Receiver<StateChange>) -> Option<Event> {
|
2023-08-15 17:58:21 -05:00
|
|
|
let check_chan = self.command_handle.as_ref().map(|cargo| &cargo.receiver);
|
2022-10-03 07:03:54 -05:00
|
|
|
if let Ok(msg) = inbox.try_recv() {
|
|
|
|
// give restarts a preference so check outputs don't block a restart or stop
|
2023-02-28 05:08:23 -06:00
|
|
|
return Some(Event::RequestStateChange(msg));
|
2022-10-03 07:03:54 -05:00
|
|
|
}
|
2020-06-25 10:14:11 -05:00
|
|
|
select! {
|
2023-02-28 05:08:23 -06:00
|
|
|
recv(inbox) -> msg => msg.ok().map(Event::RequestStateChange),
|
2020-06-25 10:14:11 -05:00
|
|
|
recv(check_chan.unwrap_or(&never())) -> msg => Some(Event::CheckEvent(msg.ok())),
|
|
|
|
}
|
|
|
|
}
|
2022-09-15 06:28:09 -05:00
|
|
|
|
2023-02-28 05:08:23 -06:00
|
|
|
fn run(mut self, inbox: Receiver<StateChange>) {
|
2022-10-03 07:03:54 -05:00
|
|
|
'event: while let Some(event) = self.next_event(&inbox) {
|
2020-06-25 06:47:22 -05:00
|
|
|
match event {
|
2023-02-28 05:08:23 -06:00
|
|
|
Event::RequestStateChange(StateChange::Cancel) => {
|
|
|
|
tracing::debug!(flycheck_id = self.id, "flycheck cancelled");
|
2022-08-19 01:52:31 -05:00
|
|
|
self.cancel_check_process();
|
|
|
|
}
|
2023-10-04 09:34:34 -05:00
|
|
|
Event::RequestStateChange(StateChange::Restart { package, saved_file }) => {
|
2022-06-30 15:58:57 -05:00
|
|
|
// Cancel the previously spawned process
|
|
|
|
self.cancel_check_process();
|
2022-10-03 07:03:54 -05:00
|
|
|
while let Ok(restart) = inbox.recv_timeout(Duration::from_millis(50)) {
|
|
|
|
// restart chained with a stop, so just cancel
|
2023-02-28 05:08:23 -06:00
|
|
|
if let StateChange::Cancel = restart {
|
2022-10-03 07:03:54 -05:00
|
|
|
continue 'event;
|
|
|
|
}
|
|
|
|
}
|
2020-06-28 16:42:44 -05:00
|
|
|
|
2023-10-04 09:34:34 -05:00
|
|
|
let command =
|
|
|
|
match self.check_command(package.as_deref(), saved_file.as_deref()) {
|
|
|
|
Some(c) => c,
|
|
|
|
None => continue,
|
|
|
|
};
|
2023-08-15 18:02:55 -05:00
|
|
|
let formatted_command = format!("{:?}", command);
|
|
|
|
|
2022-06-15 11:35:48 -05:00
|
|
|
tracing::debug!(?command, "will restart flycheck");
|
2023-08-15 17:58:21 -05:00
|
|
|
match CommandHandle::spawn(command) {
|
|
|
|
Ok(command_handle) => {
|
2023-08-15 18:02:55 -05:00
|
|
|
tracing::debug!(command = formatted_command, "did restart flycheck");
|
2023-08-15 17:58:21 -05:00
|
|
|
self.command_handle = Some(command_handle);
|
2022-09-15 06:28:09 -05:00
|
|
|
self.report_progress(Progress::DidStart);
|
2022-06-13 06:34:07 -05:00
|
|
|
}
|
2022-06-15 11:35:48 -05:00
|
|
|
Err(error) => {
|
2022-09-15 06:28:09 -05:00
|
|
|
self.report_progress(Progress::DidFailToRestart(format!(
|
2023-08-15 18:02:55 -05:00
|
|
|
"Failed to run the following command: {} error={}",
|
|
|
|
formatted_command, error
|
2022-08-22 10:42:33 -05:00
|
|
|
)));
|
2022-06-13 06:34:07 -05:00
|
|
|
}
|
|
|
|
}
|
2020-06-26 09:17:22 -05:00
|
|
|
}
|
2020-06-25 06:47:22 -05:00
|
|
|
Event::CheckEvent(None) => {
|
2022-07-20 04:49:36 -05:00
|
|
|
tracing::debug!(flycheck_id = self.id, "flycheck finished");
|
2022-06-16 08:25:50 -05:00
|
|
|
|
|
|
|
// Watcher finished
|
2023-08-15 17:58:21 -05:00
|
|
|
let command_handle = self.command_handle.take().unwrap();
|
2023-08-15 18:02:55 -05:00
|
|
|
let formatted_handle = format!("{:?}", command_handle);
|
|
|
|
|
2023-08-15 17:58:21 -05:00
|
|
|
let res = command_handle.join();
|
2020-08-10 19:12:09 -05:00
|
|
|
if res.is_err() {
|
2021-08-15 07:46:13 -05:00
|
|
|
tracing::error!(
|
2023-08-15 18:02:55 -05:00
|
|
|
"Flycheck failed to run the following command: {}",
|
|
|
|
formatted_handle
|
2021-10-03 07:39:43 -05:00
|
|
|
);
|
2020-08-10 19:12:09 -05:00
|
|
|
}
|
2022-09-15 06:28:09 -05:00
|
|
|
self.report_progress(Progress::DidFinish(res));
|
2019-12-27 04:10:07 -06:00
|
|
|
}
|
2020-06-26 09:17:22 -05:00
|
|
|
Event::CheckEvent(Some(message)) => match message {
|
2021-04-18 18:36:29 -05:00
|
|
|
CargoMessage::CompilerArtifact(msg) => {
|
2023-02-28 05:08:23 -06:00
|
|
|
tracing::trace!(
|
|
|
|
flycheck_id = self.id,
|
|
|
|
artifact = msg.target.name,
|
|
|
|
"artifact received"
|
|
|
|
);
|
2022-09-15 06:28:09 -05:00
|
|
|
self.report_progress(Progress::DidCheckCrate(msg.target.name));
|
2020-06-25 06:47:22 -05:00
|
|
|
}
|
|
|
|
|
2021-04-18 18:36:29 -05:00
|
|
|
CargoMessage::Diagnostic(msg) => {
|
2023-02-28 05:08:23 -06:00
|
|
|
tracing::trace!(
|
|
|
|
flycheck_id = self.id,
|
|
|
|
message = msg.message,
|
|
|
|
"diagnostic received"
|
|
|
|
);
|
2020-06-25 06:47:22 -05:00
|
|
|
self.send(Message::AddDiagnostic {
|
2022-07-20 04:49:36 -05:00
|
|
|
id: self.id,
|
2022-09-26 08:58:55 -05:00
|
|
|
workspace_root: self.root.clone(),
|
2021-04-18 18:36:29 -05:00
|
|
|
diagnostic: msg,
|
2020-06-25 06:47:22 -05:00
|
|
|
});
|
|
|
|
}
|
|
|
|
},
|
|
|
|
}
|
2019-12-27 04:10:07 -06:00
|
|
|
}
|
2020-06-26 09:17:22 -05:00
|
|
|
// If we rerun the thread, we need to discard the previous check results first
|
|
|
|
self.cancel_check_process();
|
2019-12-27 04:10:07 -06:00
|
|
|
}
|
2022-06-16 08:25:50 -05:00
|
|
|
|
2020-06-26 09:17:22 -05:00
|
|
|
fn cancel_check_process(&mut self) {
|
2023-08-15 17:58:21 -05:00
|
|
|
if let Some(command_handle) = self.command_handle.take() {
|
2022-08-19 01:52:31 -05:00
|
|
|
tracing::debug!(
|
2023-08-15 18:02:55 -05:00
|
|
|
command = ?command_handle,
|
2022-08-19 01:52:31 -05:00
|
|
|
"did cancel flycheck"
|
|
|
|
);
|
2023-08-15 17:58:21 -05:00
|
|
|
command_handle.cancel();
|
2022-09-15 06:28:09 -05:00
|
|
|
self.report_progress(Progress::DidCancel);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-10-04 09:34:34 -05:00
|
|
|
/// Construct a `Command` object for checking the user's code. If the user
|
|
|
|
/// has specified a custom command with placeholders that we cannot fill,
|
|
|
|
/// return None.
|
|
|
|
fn check_command(
|
|
|
|
&self,
|
|
|
|
package: Option<&str>,
|
|
|
|
saved_file: Option<&AbsPath>,
|
|
|
|
) -> Option<Command> {
|
2022-10-22 16:02:59 -05:00
|
|
|
let (mut cmd, args) = match &self.config {
|
2020-06-09 14:47:54 -05:00
|
|
|
FlycheckConfig::CargoCommand {
|
|
|
|
command,
|
2022-09-24 18:22:27 -05:00
|
|
|
target_triples,
|
2020-07-30 09:04:01 -05:00
|
|
|
no_default_features,
|
2020-06-09 14:47:54 -05:00
|
|
|
all_targets,
|
|
|
|
all_features,
|
|
|
|
extra_args,
|
|
|
|
features,
|
2022-08-18 16:41:17 -05:00
|
|
|
extra_env,
|
2023-01-04 11:04:45 -06:00
|
|
|
ansi_color_output,
|
2023-09-30 21:02:12 -05:00
|
|
|
target_dir,
|
2020-06-09 14:47:54 -05:00
|
|
|
} => {
|
2024-02-14 08:13:45 -06:00
|
|
|
let mut cmd = Command::new(Tool::Cargo.path());
|
|
|
|
if let Some(sysroot_root) = &self.sysroot_root {
|
|
|
|
cmd.env("RUSTUP_TOOLCHAIN", AsRef::<std::path::Path>::as_ref(sysroot_root));
|
|
|
|
}
|
2020-04-01 05:31:42 -05:00
|
|
|
cmd.arg(command);
|
2022-10-24 09:07:42 -05:00
|
|
|
cmd.current_dir(&self.root);
|
2024-02-08 03:40:42 -06:00
|
|
|
|
|
|
|
match package {
|
|
|
|
Some(pkg) => cmd.arg("-p").arg(pkg),
|
|
|
|
None => cmd.arg("--workspace"),
|
|
|
|
};
|
2023-01-04 11:04:45 -06:00
|
|
|
|
|
|
|
cmd.arg(if *ansi_color_output {
|
|
|
|
"--message-format=json-diagnostic-rendered-ansi"
|
|
|
|
} else {
|
|
|
|
"--message-format=json"
|
|
|
|
});
|
|
|
|
|
|
|
|
cmd.arg("--manifest-path");
|
|
|
|
cmd.arg(self.root.join("Cargo.toml").as_os_str());
|
2020-07-21 03:30:54 -05:00
|
|
|
|
2022-09-24 18:22:27 -05:00
|
|
|
for target in target_triples {
|
2022-12-24 15:09:08 -06:00
|
|
|
cmd.args(["--target", target.as_str()]);
|
2020-07-21 03:30:54 -05:00
|
|
|
}
|
2020-04-01 05:31:42 -05:00
|
|
|
if *all_targets {
|
|
|
|
cmd.arg("--all-targets");
|
|
|
|
}
|
2020-05-05 15:44:39 -05:00
|
|
|
if *all_features {
|
|
|
|
cmd.arg("--all-features");
|
2020-07-30 09:04:01 -05:00
|
|
|
} else {
|
|
|
|
if *no_default_features {
|
|
|
|
cmd.arg("--no-default-features");
|
|
|
|
}
|
|
|
|
if !features.is_empty() {
|
|
|
|
cmd.arg("--features");
|
|
|
|
cmd.arg(features.join(" "));
|
|
|
|
}
|
2020-05-05 15:44:39 -05:00
|
|
|
}
|
2023-09-30 21:02:12 -05:00
|
|
|
if let Some(target_dir) = target_dir {
|
|
|
|
cmd.arg("--target-dir").arg(target_dir);
|
|
|
|
}
|
2022-08-18 16:41:17 -05:00
|
|
|
cmd.envs(extra_env);
|
2023-10-04 09:34:34 -05:00
|
|
|
(cmd, extra_args.clone())
|
2020-04-01 05:31:42 -05:00
|
|
|
}
|
2022-10-22 16:02:59 -05:00
|
|
|
FlycheckConfig::CustomCommand {
|
|
|
|
command,
|
|
|
|
args,
|
|
|
|
extra_env,
|
|
|
|
invocation_strategy,
|
|
|
|
invocation_location,
|
|
|
|
} => {
|
2020-04-01 05:31:42 -05:00
|
|
|
let mut cmd = Command::new(command);
|
2022-08-18 16:41:17 -05:00
|
|
|
cmd.envs(extra_env);
|
2022-10-22 16:02:59 -05:00
|
|
|
|
|
|
|
match invocation_location {
|
|
|
|
InvocationLocation::Workspace => {
|
|
|
|
match invocation_strategy {
|
|
|
|
InvocationStrategy::Once => {
|
|
|
|
cmd.current_dir(&self.root);
|
|
|
|
}
|
|
|
|
InvocationStrategy::PerWorkspace => {
|
|
|
|
// FIXME: cmd.current_dir(&affected_workspace);
|
|
|
|
cmd.current_dir(&self.root);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
InvocationLocation::Root(root) => {
|
|
|
|
cmd.current_dir(root);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-10-04 09:34:34 -05:00
|
|
|
if args.contains(&SAVED_FILE_PLACEHOLDER.to_owned()) {
|
|
|
|
// If the custom command has a $saved_file placeholder, and
|
|
|
|
// we're saving a file, replace the placeholder in the arguments.
|
|
|
|
if let Some(saved_file) = saved_file {
|
|
|
|
let args = args
|
|
|
|
.iter()
|
|
|
|
.map(|arg| {
|
|
|
|
if arg == SAVED_FILE_PLACEHOLDER {
|
|
|
|
saved_file.to_string()
|
|
|
|
} else {
|
|
|
|
arg.clone()
|
|
|
|
}
|
|
|
|
})
|
|
|
|
.collect();
|
|
|
|
(cmd, args)
|
|
|
|
} else {
|
|
|
|
// The custom command has a $saved_file placeholder,
|
|
|
|
// but we had an IDE event that wasn't a file save. Do nothing.
|
|
|
|
return None;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
(cmd, args.clone())
|
|
|
|
}
|
2020-04-01 05:03:06 -05:00
|
|
|
}
|
|
|
|
};
|
2022-10-22 16:02:59 -05:00
|
|
|
|
|
|
|
cmd.args(args);
|
2023-10-04 09:34:34 -05:00
|
|
|
Some(cmd)
|
2020-03-31 17:39:50 -05:00
|
|
|
}
|
2020-06-25 01:39:33 -05:00
|
|
|
|
2020-06-25 02:19:01 -05:00
|
|
|
fn send(&self, check_task: Message) {
|
2021-10-03 07:39:43 -05:00
|
|
|
(self.sender)(check_task);
|
2020-06-25 01:39:33 -05:00
|
|
|
}
|
2019-12-27 04:10:07 -06:00
|
|
|
}
|
|
|
|
|
2022-11-24 14:30:15 -06:00
|
|
|
struct JodGroupChild(GroupChild);
|
|
|
|
|
|
|
|
impl Drop for JodGroupChild {
|
|
|
|
fn drop(&mut self) {
|
|
|
|
_ = self.0.kill();
|
|
|
|
_ = self.0.wait();
|
|
|
|
}
|
|
|
|
}
|
2022-11-05 10:28:04 -05:00
|
|
|
|
2022-06-13 06:34:07 -05:00
|
|
|
/// A handle to a cargo process used for fly-checking.
|
2023-08-15 17:58:21 -05:00
|
|
|
struct CommandHandle {
|
2022-06-13 06:34:07 -05:00
|
|
|
/// The handle to the actual cargo process. As we cannot cancel directly from with
|
2022-11-07 04:53:33 -06:00
|
|
|
/// a read syscall dropping and therefore terminating the process is our best option.
|
2022-11-24 14:30:15 -06:00
|
|
|
child: JodGroupChild,
|
2023-05-20 07:29:32 -05:00
|
|
|
thread: stdx::thread::JoinHandle<io::Result<(bool, String)>>,
|
2021-04-18 18:36:29 -05:00
|
|
|
receiver: Receiver<CargoMessage>,
|
2023-08-15 18:02:55 -05:00
|
|
|
program: OsString,
|
|
|
|
arguments: Vec<OsString>,
|
|
|
|
current_dir: Option<PathBuf>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl fmt::Debug for CommandHandle {
|
|
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
|
|
f.debug_struct("CommandHandle")
|
|
|
|
.field("program", &self.program)
|
|
|
|
.field("arguments", &self.arguments)
|
|
|
|
.field("current_dir", &self.current_dir)
|
|
|
|
.finish()
|
|
|
|
}
|
2020-06-28 16:01:28 -05:00
|
|
|
}
|
2020-03-21 16:30:33 -05:00
|
|
|
|
2023-08-15 17:58:21 -05:00
|
|
|
impl CommandHandle {
|
|
|
|
fn spawn(mut command: Command) -> std::io::Result<CommandHandle> {
|
2022-06-13 06:34:07 -05:00
|
|
|
command.stdout(Stdio::piped()).stderr(Stdio::piped()).stdin(Stdio::null());
|
2022-11-24 14:30:15 -06:00
|
|
|
let mut child = command.group_spawn().map(JodGroupChild)?;
|
2022-06-13 06:34:07 -05:00
|
|
|
|
2023-08-15 18:02:55 -05:00
|
|
|
let program = command.get_program().into();
|
|
|
|
let arguments = command.get_args().map(|arg| arg.into()).collect::<Vec<OsString>>();
|
|
|
|
let current_dir = command.get_current_dir().map(|arg| arg.to_path_buf());
|
|
|
|
|
2022-11-05 10:28:04 -05:00
|
|
|
let stdout = child.0.inner().stdout.take().unwrap();
|
|
|
|
let stderr = child.0.inner().stderr.take().unwrap();
|
2022-06-13 06:34:07 -05:00
|
|
|
|
2020-06-28 16:01:28 -05:00
|
|
|
let (sender, receiver) = unbounded();
|
2022-06-13 06:34:07 -05:00
|
|
|
let actor = CargoActor::new(sender, stdout, stderr);
|
2023-05-26 12:18:17 -05:00
|
|
|
let thread = stdx::thread::Builder::new(stdx::thread::ThreadIntent::Worker)
|
2024-02-23 14:50:41 -06:00
|
|
|
.name("CommandHandle".to_owned())
|
2022-06-13 06:34:07 -05:00
|
|
|
.spawn(move || actor.run())
|
2021-07-07 11:48:36 -05:00
|
|
|
.expect("failed to spawn thread");
|
2023-08-15 18:02:55 -05:00
|
|
|
Ok(CommandHandle { program, arguments, current_dir, child, thread, receiver })
|
2020-06-28 16:42:44 -05:00
|
|
|
}
|
2021-10-11 07:09:20 -05:00
|
|
|
|
2022-06-15 11:35:48 -05:00
|
|
|
fn cancel(mut self) {
|
2022-11-05 10:28:04 -05:00
|
|
|
let _ = self.child.0.kill();
|
|
|
|
let _ = self.child.0.wait();
|
2022-06-15 11:35:48 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
fn join(mut self) -> io::Result<()> {
|
2022-11-05 10:28:04 -05:00
|
|
|
let _ = self.child.0.kill();
|
|
|
|
let exit_status = self.child.0.wait()?;
|
2022-06-13 06:34:07 -05:00
|
|
|
let (read_at_least_one_message, error) = self.thread.join()?;
|
|
|
|
if read_at_least_one_message || exit_status.success() {
|
|
|
|
Ok(())
|
|
|
|
} else {
|
|
|
|
Err(io::Error::new(io::ErrorKind::Other, format!(
|
2022-12-30 01:59:11 -06:00
|
|
|
"Cargo watcher failed, the command produced no valid metadata (exit code: {exit_status:?}):\n{error}"
|
2022-06-13 06:34:07 -05:00
|
|
|
)))
|
|
|
|
}
|
2020-03-16 07:43:29 -05:00
|
|
|
}
|
2020-06-28 16:01:28 -05:00
|
|
|
}
|
2020-03-16 07:43:29 -05:00
|
|
|
|
2020-06-28 16:01:28 -05:00
|
|
|
struct CargoActor {
|
2021-04-18 18:36:29 -05:00
|
|
|
sender: Sender<CargoMessage>,
|
2022-06-13 06:34:07 -05:00
|
|
|
stdout: ChildStdout,
|
|
|
|
stderr: ChildStderr,
|
2020-06-28 16:01:28 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
impl CargoActor {
|
2022-06-13 06:34:07 -05:00
|
|
|
fn new(sender: Sender<CargoMessage>, stdout: ChildStdout, stderr: ChildStderr) -> CargoActor {
|
|
|
|
CargoActor { sender, stdout, stderr }
|
2020-04-01 05:45:37 -05:00
|
|
|
}
|
2021-10-11 07:09:20 -05:00
|
|
|
|
2022-06-13 06:34:07 -05:00
|
|
|
fn run(self) -> io::Result<(bool, String)> {
|
2020-06-28 16:01:28 -05:00
|
|
|
// We manually read a line at a time, instead of using serde's
|
|
|
|
// stream deserializers, because the deserializer cannot recover
|
|
|
|
// from an error, resulting in it getting stuck, because we try to
|
2020-06-28 16:42:44 -05:00
|
|
|
// be resilient against failures.
|
2020-06-28 16:01:28 -05:00
|
|
|
//
|
|
|
|
// Because cargo only outputs one JSON object per line, we can
|
|
|
|
// simply skip a line if it doesn't parse, which just ignores any
|
2022-08-17 08:44:58 -05:00
|
|
|
// erroneous output.
|
2020-06-28 16:01:28 -05:00
|
|
|
|
2023-03-03 12:26:21 -06:00
|
|
|
let mut stdout_errors = String::new();
|
|
|
|
let mut stderr_errors = String::new();
|
|
|
|
let mut read_at_least_one_stdout_message = false;
|
|
|
|
let mut read_at_least_one_stderr_message = false;
|
|
|
|
let process_line = |line: &str, error: &mut String| {
|
|
|
|
// Try to deserialize a message from Cargo or Rustc.
|
|
|
|
let mut deserializer = serde_json::Deserializer::from_str(line);
|
|
|
|
deserializer.disable_recursion_limit();
|
|
|
|
if let Ok(message) = JsonMessage::deserialize(&mut deserializer) {
|
|
|
|
match message {
|
|
|
|
// Skip certain kinds of messages to only spend time on what's useful
|
|
|
|
JsonMessage::Cargo(message) => match message {
|
|
|
|
cargo_metadata::Message::CompilerArtifact(artifact) if !artifact.fresh => {
|
2024-02-01 09:16:38 -06:00
|
|
|
self.sender.send(CargoMessage::CompilerArtifact(artifact)).unwrap();
|
2023-03-03 12:26:21 -06:00
|
|
|
}
|
|
|
|
cargo_metadata::Message::CompilerMessage(msg) => {
|
|
|
|
self.sender.send(CargoMessage::Diagnostic(msg.message)).unwrap();
|
|
|
|
}
|
|
|
|
_ => (),
|
|
|
|
},
|
|
|
|
JsonMessage::Rustc(message) => {
|
|
|
|
self.sender.send(CargoMessage::Diagnostic(message)).unwrap();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
error.push_str(line);
|
|
|
|
error.push('\n');
|
2023-05-07 02:42:52 -05:00
|
|
|
false
|
2023-03-03 12:26:21 -06:00
|
|
|
};
|
2021-10-11 07:09:20 -05:00
|
|
|
let output = streaming_output(
|
2022-06-13 06:34:07 -05:00
|
|
|
self.stdout,
|
|
|
|
self.stderr,
|
2021-10-11 07:09:20 -05:00
|
|
|
&mut |line| {
|
2023-03-03 12:26:21 -06:00
|
|
|
if process_line(line, &mut stdout_errors) {
|
|
|
|
read_at_least_one_stdout_message = true;
|
2021-04-18 18:36:29 -05:00
|
|
|
}
|
2021-10-11 07:09:20 -05:00
|
|
|
},
|
|
|
|
&mut |line| {
|
2023-03-03 12:26:21 -06:00
|
|
|
if process_line(line, &mut stderr_errors) {
|
|
|
|
read_at_least_one_stderr_message = true;
|
|
|
|
}
|
2021-10-11 07:09:20 -05:00
|
|
|
},
|
|
|
|
);
|
2023-03-03 12:26:21 -06:00
|
|
|
|
|
|
|
let read_at_least_one_message =
|
|
|
|
read_at_least_one_stdout_message || read_at_least_one_stderr_message;
|
|
|
|
let mut error = stdout_errors;
|
|
|
|
error.push_str(&stderr_errors);
|
2021-10-11 07:09:20 -05:00
|
|
|
match output {
|
2022-06-13 06:34:07 -05:00
|
|
|
Ok(_) => Ok((read_at_least_one_message, error)),
|
2022-12-23 12:42:58 -06:00
|
|
|
Err(e) => Err(io::Error::new(e.kind(), format!("{e:?}: {error}"))),
|
2020-06-28 16:01:28 -05:00
|
|
|
}
|
|
|
|
}
|
2020-03-16 07:43:29 -05:00
|
|
|
}
|
2021-04-18 18:36:29 -05:00
|
|
|
|
2024-02-01 09:16:38 -06:00
|
|
|
#[allow(clippy::large_enum_variant)]
|
2021-04-18 18:36:29 -05:00
|
|
|
enum CargoMessage {
|
2024-02-01 09:16:38 -06:00
|
|
|
CompilerArtifact(cargo_metadata::Artifact),
|
2021-04-18 18:36:29 -05:00
|
|
|
Diagnostic(Diagnostic),
|
|
|
|
}
|
2021-04-19 14:26:04 -05:00
|
|
|
|
|
|
|
#[derive(Deserialize)]
|
|
|
|
#[serde(untagged)]
|
|
|
|
enum JsonMessage {
|
|
|
|
Cargo(cargo_metadata::Message),
|
|
|
|
Rustc(Diagnostic),
|
|
|
|
}
|