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
|
|
|
|
2022-07-20 07:59:42 -05:00
|
|
|
#![warn(rust_2018_idioms, unused_lifetimes, semicolon_in_expressions_from_macros)]
|
|
|
|
|
2022-06-13 06:34:07 -05:00
|
|
|
use std::{
|
|
|
|
fmt, io,
|
|
|
|
process::{ChildStderr, ChildStdout, Command, Stdio},
|
|
|
|
time::Duration,
|
|
|
|
};
|
2019-12-27 04:10:07 -06:00
|
|
|
|
2020-06-25 06:47:22 -05:00
|
|
|
use crossbeam_channel::{never, select, unbounded, Receiver, Sender};
|
2021-07-17 09:40:13 -05:00
|
|
|
use paths::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-06-13 06:34:07 -05:00
|
|
|
use stdx::{process::streaming_output, JodChild};
|
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
|
|
|
};
|
|
|
|
|
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,
|
2020-07-21 03:50:24 -05:00
|
|
|
target_triple: Option<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>,
|
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>,
|
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 {
|
|
|
|
FlycheckConfig::CargoCommand { command, .. } => write!(f, "cargo {}", command),
|
2022-08-18 16:41:17 -05:00
|
|
|
FlycheckConfig::CustomCommand { command, args, .. } => {
|
2020-05-10 10:35:33 -05:00
|
|
|
write!(f, "{} {}", command, args.join(" "))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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
|
2020-06-28 15:35:18 -05:00
|
|
|
sender: Sender<Restart>,
|
2021-09-15 13:22:06 -05:00
|
|
|
_thread: jod_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,
|
2021-07-17 09:40:13 -05:00
|
|
|
workspace_root: AbsPathBuf,
|
2020-06-25 01:39:33 -05:00
|
|
|
) -> FlycheckHandle {
|
2020-09-17 11:50:30 -05:00
|
|
|
let actor = FlycheckActor::new(id, sender, config, workspace_root);
|
2020-06-28 15:35:18 -05:00
|
|
|
let (sender, receiver) = unbounded::<Restart>();
|
2021-07-07 11:48:36 -05:00
|
|
|
let thread = jod_thread::Builder::new()
|
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
|
|
|
}
|
|
|
|
|
2019-12-27 04:10:07 -06:00
|
|
|
/// Schedule a re-start of the cargo check worker.
|
2022-08-19 01:52:31 -05:00
|
|
|
pub fn restart(&self) {
|
|
|
|
self.sender.send(Restart::Yes).unwrap();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Stop this cargo check worker.
|
|
|
|
pub fn cancel(&self) {
|
|
|
|
self.sender.send(Restart::No).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
|
|
|
}
|
|
|
|
|
2022-08-19 01:52:31 -05:00
|
|
|
enum Restart {
|
|
|
|
Yes,
|
|
|
|
No,
|
|
|
|
}
|
2019-12-27 04:10:07 -06:00
|
|
|
|
2020-06-25 01:24:27 -05:00
|
|
|
struct FlycheckActor {
|
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,
|
2021-07-17 09:40:13 -05:00
|
|
|
workspace_root: 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.
|
2020-06-28 16:42:44 -05:00
|
|
|
cargo_handle: Option<CargoHandle>,
|
2020-06-25 06:47:22 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
enum Event {
|
|
|
|
Restart(Restart),
|
2021-04-18 18:36:29 -05:00
|
|
|
CheckEvent(Option<CargoMessage>),
|
2019-12-27 04:43:05 -06:00
|
|
|
}
|
|
|
|
|
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,
|
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");
|
2020-09-17 11:50:30 -05:00
|
|
|
FlycheckActor { id, sender, config, workspace_root, cargo_handle: None }
|
|
|
|
}
|
|
|
|
fn progress(&self, progress: Progress) {
|
|
|
|
self.send(Message::Progress { id: self.id, progress });
|
2019-12-27 04:10:07 -06:00
|
|
|
}
|
2020-06-25 10:14:11 -05:00
|
|
|
fn next_event(&self, inbox: &Receiver<Restart>) -> Option<Event> {
|
2020-06-28 16:42:44 -05:00
|
|
|
let check_chan = self.cargo_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
|
|
|
|
return Some(Event::Restart(msg));
|
|
|
|
}
|
2020-06-25 10:14:11 -05:00
|
|
|
select! {
|
|
|
|
recv(inbox) -> msg => msg.ok().map(Event::Restart),
|
|
|
|
recv(check_chan.unwrap_or(&never())) -> msg => Some(Event::CheckEvent(msg.ok())),
|
|
|
|
}
|
|
|
|
}
|
2020-06-28 15:35:18 -05:00
|
|
|
fn run(mut self, inbox: Receiver<Restart>) {
|
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 {
|
2022-08-19 01:52:31 -05:00
|
|
|
Event::Restart(Restart::No) => {
|
|
|
|
self.cancel_check_process();
|
|
|
|
}
|
|
|
|
Event::Restart(Restart::Yes) => {
|
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
|
|
|
|
if let Restart::No = restart {
|
|
|
|
continue 'event;
|
|
|
|
}
|
|
|
|
}
|
2020-06-28 16:42:44 -05:00
|
|
|
|
2021-10-11 07:09:20 -05:00
|
|
|
let command = self.check_command();
|
2022-06-15 11:35:48 -05:00
|
|
|
tracing::debug!(?command, "will restart flycheck");
|
2022-06-13 06:34:07 -05:00
|
|
|
match CargoHandle::spawn(command) {
|
|
|
|
Ok(cargo_handle) => {
|
2022-06-16 08:25:50 -05:00
|
|
|
tracing::debug!(
|
|
|
|
command = ?self.check_command(),
|
|
|
|
"did restart flycheck"
|
|
|
|
);
|
2022-06-13 06:34:07 -05:00
|
|
|
self.cargo_handle = Some(cargo_handle);
|
|
|
|
self.progress(Progress::DidStart);
|
|
|
|
}
|
2022-06-15 11:35:48 -05:00
|
|
|
Err(error) => {
|
2022-08-22 10:42:33 -05:00
|
|
|
self.progress(Progress::DidFailToRestart(format!(
|
|
|
|
"Failed to run the following command: {:?} error={}",
|
|
|
|
self.check_command(),
|
|
|
|
error
|
|
|
|
)));
|
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
|
2020-06-28 16:42:44 -05:00
|
|
|
let cargo_handle = self.cargo_handle.take().unwrap();
|
|
|
|
let res = cargo_handle.join();
|
2020-08-10 19:12:09 -05:00
|
|
|
if res.is_err() {
|
2021-08-15 07:46:13 -05:00
|
|
|
tracing::error!(
|
2020-08-10 19:12:09 -05:00
|
|
|
"Flycheck failed to run the following command: {:?}",
|
|
|
|
self.check_command()
|
2021-10-03 07:39:43 -05:00
|
|
|
);
|
2020-08-10 19:12:09 -05:00
|
|
|
}
|
2020-09-17 11:50:30 -05:00
|
|
|
self.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) => {
|
2020-09-17 11:50:30 -05:00
|
|
|
self.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) => {
|
2020-06-25 06:47:22 -05:00
|
|
|
self.send(Message::AddDiagnostic {
|
2022-07-20 04:49:36 -05:00
|
|
|
id: self.id,
|
2020-06-25 06:47:22 -05:00
|
|
|
workspace_root: self.workspace_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) {
|
2022-06-16 08:25:50 -05:00
|
|
|
if let Some(cargo_handle) = self.cargo_handle.take() {
|
2022-08-19 01:52:31 -05:00
|
|
|
tracing::debug!(
|
|
|
|
command = ?self.check_command(),
|
|
|
|
"did cancel flycheck"
|
|
|
|
);
|
2022-06-16 08:25:50 -05:00
|
|
|
cargo_handle.cancel();
|
2020-09-17 11:50:30 -05:00
|
|
|
self.progress(Progress::DidCancel);
|
2019-12-27 04:10:07 -06:00
|
|
|
}
|
|
|
|
}
|
2022-06-30 15:58:57 -05:00
|
|
|
|
2020-06-28 16:42:44 -05:00
|
|
|
fn check_command(&self) -> Command {
|
2020-04-01 05:31:42 -05:00
|
|
|
let mut cmd = match &self.config {
|
2020-06-09 14:47:54 -05:00
|
|
|
FlycheckConfig::CargoCommand {
|
|
|
|
command,
|
2020-07-21 03:50:24 -05:00
|
|
|
target_triple,
|
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,
|
2020-06-09 14:47:54 -05:00
|
|
|
} => {
|
2020-08-12 09:52:28 -05:00
|
|
|
let mut cmd = Command::new(toolchain::cargo());
|
2020-04-01 05:31:42 -05:00
|
|
|
cmd.arg(command);
|
2021-05-12 21:50:52 -05:00
|
|
|
cmd.current_dir(&self.workspace_root);
|
2020-05-08 07:54:29 -05:00
|
|
|
cmd.args(&["--workspace", "--message-format=json", "--manifest-path"])
|
2021-07-17 09:40:13 -05:00
|
|
|
.arg(self.workspace_root.join("Cargo.toml").as_os_str());
|
2020-07-21 03:30:54 -05:00
|
|
|
|
2020-07-21 03:50:24 -05:00
|
|
|
if let Some(target) = target_triple {
|
2020-07-21 03:30:54 -05:00
|
|
|
cmd.args(&["--target", target.as_str()]);
|
|
|
|
}
|
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
|
|
|
}
|
2020-04-01 05:31:42 -05:00
|
|
|
cmd.args(extra_args);
|
2022-08-18 16:41:17 -05:00
|
|
|
cmd.envs(extra_env);
|
2020-04-01 05:31:42 -05:00
|
|
|
cmd
|
|
|
|
}
|
2022-08-18 16:41:17 -05:00
|
|
|
FlycheckConfig::CustomCommand { command, args, extra_env } => {
|
2020-04-01 05:31:42 -05:00
|
|
|
let mut cmd = Command::new(command);
|
|
|
|
cmd.args(args);
|
2022-08-18 16:41:17 -05:00
|
|
|
cmd.envs(extra_env);
|
2020-04-01 05:31:42 -05:00
|
|
|
cmd
|
2020-04-01 05:03:06 -05:00
|
|
|
}
|
|
|
|
};
|
2020-04-01 05:31:42 -05:00
|
|
|
cmd.current_dir(&self.workspace_root);
|
2020-06-28 16:42:44 -05:00
|
|
|
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-06-13 06:34:07 -05:00
|
|
|
/// A handle to a cargo process used for fly-checking.
|
2020-06-28 16:01:28 -05:00
|
|
|
struct CargoHandle {
|
2022-06-13 06:34:07 -05:00
|
|
|
/// The handle to the actual cargo process. As we cannot cancel directly from with
|
|
|
|
/// a read syscall dropping and therefor terminating the process is our best option.
|
|
|
|
child: JodChild,
|
|
|
|
thread: jod_thread::JoinHandle<io::Result<(bool, String)>>,
|
2021-04-18 18:36:29 -05:00
|
|
|
receiver: Receiver<CargoMessage>,
|
2020-06-28 16:01:28 -05:00
|
|
|
}
|
2020-03-21 16:30:33 -05:00
|
|
|
|
2020-06-28 16:01:28 -05:00
|
|
|
impl CargoHandle {
|
2022-06-13 06:34:07 -05:00
|
|
|
fn spawn(mut command: Command) -> std::io::Result<CargoHandle> {
|
|
|
|
command.stdout(Stdio::piped()).stderr(Stdio::piped()).stdin(Stdio::null());
|
|
|
|
let mut child = JodChild::spawn(command)?;
|
|
|
|
|
|
|
|
let stdout = child.stdout.take().unwrap();
|
|
|
|
let stderr = child.stderr.take().unwrap();
|
|
|
|
|
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);
|
2021-07-07 11:48:36 -05:00
|
|
|
let thread = jod_thread::Builder::new()
|
2021-07-08 07:39:41 -05:00
|
|
|
.name("CargoHandle".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");
|
2022-06-13 06:34:07 -05:00
|
|
|
Ok(CargoHandle { 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) {
|
|
|
|
let _ = self.child.kill();
|
|
|
|
let _ = self.child.wait();
|
|
|
|
}
|
|
|
|
|
|
|
|
fn join(mut self) -> io::Result<()> {
|
|
|
|
let _ = self.child.kill();
|
2022-06-13 06:34:07 -05:00
|
|
|
let exit_status = self.child.wait()?;
|
|
|
|
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!(
|
|
|
|
"Cargo watcher failed, the command produced no valid metadata (exit code: {:?}):\n{}",
|
|
|
|
exit_status, error
|
|
|
|
)))
|
|
|
|
}
|
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
|
|
|
|
2021-10-11 07:09:20 -05:00
|
|
|
let mut error = String::new();
|
|
|
|
let mut read_at_least_one_message = false;
|
|
|
|
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| {
|
|
|
|
read_at_least_one_message = true;
|
2020-06-28 16:01:28 -05:00
|
|
|
|
2021-10-11 07:09:20 -05:00
|
|
|
// Try to deserialize a message from Cargo or Rustc.
|
2021-10-14 13:57:21 -05:00
|
|
|
let mut deserializer = serde_json::Deserializer::from_str(line);
|
2021-10-11 07:09:20 -05:00
|
|
|
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 =>
|
|
|
|
{
|
|
|
|
self.sender.send(CargoMessage::CompilerArtifact(artifact)).unwrap();
|
|
|
|
}
|
|
|
|
cargo_metadata::Message::CompilerMessage(msg) => {
|
|
|
|
self.sender.send(CargoMessage::Diagnostic(msg.message)).unwrap();
|
|
|
|
}
|
|
|
|
_ => (),
|
|
|
|
},
|
|
|
|
JsonMessage::Rustc(message) => {
|
|
|
|
self.sender.send(CargoMessage::Diagnostic(message)).unwrap();
|
2021-04-18 18:36:29 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2021-10-11 07:09:20 -05:00
|
|
|
},
|
|
|
|
&mut |line| {
|
|
|
|
error.push_str(line);
|
|
|
|
error.push('\n');
|
|
|
|
},
|
|
|
|
);
|
|
|
|
match output {
|
2022-06-13 06:34:07 -05:00
|
|
|
Ok(_) => Ok((read_at_least_one_message, error)),
|
2021-11-27 11:57:51 -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
|
|
|
|
|
|
|
enum CargoMessage {
|
|
|
|
CompilerArtifact(cargo_metadata::Artifact),
|
|
|
|
Diagnostic(Diagnostic),
|
|
|
|
}
|
2021-04-19 14:26:04 -05:00
|
|
|
|
|
|
|
#[derive(Deserialize)]
|
|
|
|
#[serde(untagged)]
|
|
|
|
enum JsonMessage {
|
|
|
|
Cargo(cargo_metadata::Message),
|
|
|
|
Rustc(Diagnostic),
|
|
|
|
}
|