rust/crates/flycheck/src/lib.rs

365 lines
13 KiB
Rust
Raw Normal View History

//! Flycheck provides the functionality needed to run `cargo check` or
//! 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
use std::{
fmt,
io::{self, BufRead, BufReader},
2020-06-28 13:00:04 -05:00
process::{self, Command, Stdio},
2020-06-26 09:17:22 -05:00
time::Duration,
};
2020-06-25 06:47:22 -05:00
use crossbeam_channel::{never, select, unbounded, Receiver, Sender};
use paths::AbsPathBuf;
use serde::Deserialize;
2021-01-07 11:08:34 -06:00
use stdx::JodChild;
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 {
CargoCommand {
command: String,
2020-07-21 03:50:24 -05:00
target_triple: Option<String>,
all_targets: bool,
no_default_features: bool,
all_features: bool,
features: Vec<String>,
extra_args: Vec<String>,
},
CustomCommand {
command: String,
args: Vec<String>,
},
}
impl fmt::Display for FlycheckConfig {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
FlycheckConfig::CargoCommand { command, .. } => write!(f, "cargo {}", command),
FlycheckConfig::CustomCommand { command, args } => {
write!(f, "{} {}", command, args.join(" "))
}
}
}
}
/// Flycheck wraps the shared state and communication machinery used for
/// running `cargo check` (or other compatible command) and providing
/// diagnostics based on the output.
/// The spawned thread is shut down when this struct is dropped.
#[derive(Debug)]
pub struct FlycheckHandle {
// 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,
}
impl FlycheckHandle {
2020-06-25 01:39:33 -05:00
pub fn spawn(
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,
workspace_root: AbsPathBuf,
2020-06-25 01:39:33 -05:00
) -> FlycheckHandle {
let actor = FlycheckActor::new(id, sender, config, workspace_root);
2020-06-28 15:35:18 -05:00
let (sender, receiver) = unbounded::<Restart>();
let thread = jod_thread::Builder::new()
.name("Flycheck".to_owned())
.spawn(move || actor.run(receiver))
.expect("failed to spawn thread");
2021-09-15 13:22:06 -05:00
FlycheckHandle { sender, _thread: thread }
}
/// Schedule a re-start of the cargo check worker.
pub fn update(&self) {
2020-06-28 15:35:18 -05:00
self.sender.send(Restart).unwrap();
}
}
2020-06-25 02:19:01 -05:00
pub enum Message {
/// Request adding a diagnostic with fixes included to a file
AddDiagnostic { workspace_root: AbsPathBuf, diagnostic: Diagnostic },
/// Request check progress notification to client
Progress {
/// Flycheck instance ID
id: usize,
progress: Progress,
},
}
impl fmt::Debug for Message {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Message::AddDiagnostic { workspace_root, diagnostic } => f
.debug_struct("AddDiagnostic")
.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()
}
}
}
}
#[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),
DidFinish(io::Result<()>),
2020-06-26 09:17:22 -05:00
DidCancel,
}
2020-06-25 02:26:13 -05:00
struct Restart;
struct FlycheckActor {
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,
workspace_root: AbsPathBuf,
2020-03-31 17:39:50 -05:00
/// WatchThread exists to wrap around the communication needed to be able to
/// 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.
cargo_handle: Option<CargoHandle>,
2020-06-25 06:47:22 -05:00
}
enum Event {
Restart(Restart),
CheckEvent(Option<CargoMessage>),
}
impl FlycheckActor {
2020-06-25 01:39:33 -05:00
fn new(
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,
workspace_root: AbsPathBuf,
2020-06-25 01:39:33 -05:00
) -> FlycheckActor {
FlycheckActor { id, sender, config, workspace_root, cargo_handle: None }
}
fn progress(&self, progress: Progress) {
self.send(Message::Progress { id: self.id, progress });
}
2020-06-25 10:14:11 -05:00
fn next_event(&self, inbox: &Receiver<Restart>) -> Option<Event> {
let check_chan = self.cargo_handle.as_ref().map(|cargo| &cargo.receiver);
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>) {
2020-06-25 06:47:22 -05:00
while let Some(event) = self.next_event(&inbox) {
match event {
2020-06-26 09:17:22 -05:00
Event::Restart(Restart) => {
while let Ok(Restart) = inbox.recv_timeout(Duration::from_millis(50)) {}
2020-06-26 09:17:22 -05:00
self.cancel_check_process();
let mut command = self.check_command();
2021-08-15 07:46:13 -05:00
tracing::info!("restart flycheck {:?}", command);
command.stdout(Stdio::piped()).stderr(Stdio::null()).stdin(Stdio::null());
if let Ok(child) = command.spawn().map(JodChild) {
self.cargo_handle = Some(CargoHandle::spawn(child));
self.progress(Progress::DidStart);
}
2020-06-26 09:17:22 -05:00
}
2020-06-25 06:47:22 -05:00
Event::CheckEvent(None) => {
// Watcher finished, replace it with a never channel to
// avoid busy-waiting.
let cargo_handle = self.cargo_handle.take().unwrap();
let res = cargo_handle.join();
if res.is_err() {
2021-08-15 07:46:13 -05:00
tracing::error!(
"Flycheck failed to run the following command: {:?}",
self.check_command()
)
}
self.progress(Progress::DidFinish(res));
}
2020-06-26 09:17:22 -05:00
Event::CheckEvent(Some(message)) => match message {
CargoMessage::CompilerArtifact(msg) => {
self.progress(Progress::DidCheckCrate(msg.target.name));
2020-06-25 06:47:22 -05:00
}
CargoMessage::Diagnostic(msg) => {
2020-06-25 06:47:22 -05:00
self.send(Message::AddDiagnostic {
workspace_root: self.workspace_root.clone(),
diagnostic: msg,
2020-06-25 06:47:22 -05: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();
}
2020-06-26 09:17:22 -05:00
fn cancel_check_process(&mut self) {
if self.cargo_handle.take().is_some() {
self.progress(Progress::DidCancel);
}
}
fn check_command(&self) -> Command {
2020-04-01 05:31:42 -05:00
let mut cmd = match &self.config {
FlycheckConfig::CargoCommand {
command,
2020-07-21 03:50:24 -05:00
target_triple,
no_default_features,
all_targets,
all_features,
extra_args,
features,
} => {
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);
cmd.current_dir(&self.workspace_root);
2020-05-08 07:54:29 -05:00
cmd.args(&["--workspace", "--message-format=json", "--manifest-path"])
.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");
}
if *all_features {
cmd.arg("--all-features");
} else {
if *no_default_features {
cmd.arg("--no-default-features");
}
if !features.is_empty() {
cmd.arg("--features");
cmd.arg(features.join(" "));
}
}
2020-04-01 05:31:42 -05:00
cmd.args(extra_args);
cmd
}
FlycheckConfig::CustomCommand { command, args } => {
let mut cmd = Command::new(command);
cmd.args(args);
cmd
2020-04-01 05:03:06 -05:00
}
};
2020-04-01 05:31:42 -05:00
cmd.current_dir(&self.workspace_root);
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) {
2020-06-25 01:39:33 -05:00
(self.sender)(check_task)
}
}
2020-06-28 16:01:28 -05:00
struct CargoHandle {
child: JodChild,
2020-06-28 16:01:28 -05:00
#[allow(unused)]
thread: jod_thread::JoinHandle<io::Result<bool>>,
receiver: Receiver<CargoMessage>,
2020-06-28 16:01:28 -05:00
}
2020-06-28 16:01:28 -05:00
impl CargoHandle {
fn spawn(mut child: JodChild) -> CargoHandle {
let child_stdout = child.stdout.take().unwrap();
2020-06-28 16:01:28 -05:00
let (sender, receiver) = unbounded();
let actor = CargoActor::new(child_stdout, sender);
let thread = jod_thread::Builder::new()
.name("CargoHandle".to_owned())
.spawn(move || actor.run())
.expect("failed to spawn thread");
CargoHandle { child, thread, receiver }
}
fn join(mut self) -> io::Result<()> {
// It is okay to ignore the result, as it only errors if the process is already dead
let _ = self.child.kill();
let exit_status = self.child.wait()?;
let read_at_least_one_message = self.thread.join()?;
if !exit_status.success() && !read_at_least_one_message {
// FIXME: Read the stderr to display the reason, see `read2()` reference in PR comment:
// https://github.com/rust-analyzer/rust-analyzer/pull/3632#discussion_r395605298
return Err(io::Error::new(
io::ErrorKind::Other,
format!(
"Cargo watcher failed, the command produced no valid metadata (exit code: {:?})",
exit_status
),
));
}
Ok(())
}
2020-06-28 16:01:28 -05:00
}
2020-06-28 16:01:28 -05:00
struct CargoActor {
child_stdout: process::ChildStdout,
sender: Sender<CargoMessage>,
2020-06-28 16:01:28 -05:00
}
impl CargoActor {
fn new(child_stdout: process::ChildStdout, sender: Sender<CargoMessage>) -> CargoActor {
CargoActor { child_stdout, sender }
2020-04-01 05:45:37 -05:00
}
fn run(self) -> io::Result<bool> {
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
// 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
// erroneus output.
let stdout = BufReader::new(self.child_stdout);
2020-06-28 16:01:28 -05:00
let mut read_at_least_one_message = false;
for message in stdout.lines() {
2020-06-28 16:01:28 -05:00
let message = match message {
Ok(message) => message,
Err(err) => {
2021-08-15 07:46:13 -05:00
tracing::error!("Invalid json from cargo check, ignoring ({})", err);
2020-06-28 16:01:28 -05:00
continue;
}
};
read_at_least_one_message = true;
2021-04-19 14:26:04 -05:00
// Try to deserialize a message from Cargo or Rustc.
let mut deserializer = serde_json::Deserializer::from_str(&message);
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
2021-04-19 14:26:04 -05:00
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()
}
2021-09-03 09:00:50 -05:00
_ => (),
2021-04-19 14:26:04 -05:00
},
JsonMessage::Rustc(message) => {
self.sender.send(CargoMessage::Diagnostic(message)).unwrap()
}
}
}
2020-06-28 16:01:28 -05:00
}
Ok(read_at_least_one_message)
2020-06-28 16:01:28 -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),
}