impl FlycheckHandle {
pub fn spawn(
+ sender: Box<dyn Fn(CheckTask) + Send>,
config: FlycheckConfig,
workspace_root: PathBuf,
- sender: Box<dyn Fn(CheckTask) + Send>,
) -> FlycheckHandle {
let (cmd_send, cmd_recv) = unbounded::<CheckCommand>();
let handle = jod_thread::spawn(move || {
- FlycheckActor::new(config, workspace_root, sender).run(&cmd_recv);
+ FlycheckActor::new(sender, config, workspace_root).run(&cmd_recv);
});
FlycheckHandle { cmd_send, handle }
}
impl FlycheckActor {
fn new(
+ sender: Box<dyn Fn(CheckTask) + Send>,
config: FlycheckConfig,
workspace_root: PathBuf,
- sender: Box<dyn Fn(CheckTask) + Send>,
) -> FlycheckActor {
FlycheckActor {
sender,
let (sender, receiver) = unbounded();
let sender = Box::new(move |msg| sender.send(msg).unwrap());
let cargo_project_root = cargo.workspace_root().to_path_buf();
- let flycheck = FlycheckHandle::spawn(config.clone(), cargo_project_root.into(), sender);
+ let flycheck = FlycheckHandle::spawn(sender, config.clone(), cargo_project_root.into());
Some((flycheck, receiver))
}
ProjectWorkspace::Json { .. } => {
};
let mut loader = {
- let loader = vfs_notify::LoaderHandle::spawn(Box::new(move |msg| {
+ let loader = vfs_notify::NotifyHandle::spawn(Box::new(move |msg| {
task_sender.send(msg).unwrap()
}));
Box::new(loader)
use crate::include::Include;
#[derive(Debug)]
-pub struct LoaderHandle {
+pub struct NotifyHandle {
// Relative order of fields below is significant.
sender: crossbeam_channel::Sender<Message>,
_thread: jod_thread::JoinHandle,
Invalidate(AbsPathBuf),
}
-impl loader::Handle for LoaderHandle {
- fn spawn(sender: loader::Sender) -> LoaderHandle {
- let actor = LoaderActor::new(sender);
+impl loader::Handle for NotifyHandle {
+ fn spawn(sender: loader::Sender) -> NotifyHandle {
+ let actor = NotifyActor::new(sender);
let (sender, receiver) = unbounded::<Message>();
let thread = jod_thread::spawn(move || actor.run(receiver));
- LoaderHandle { sender, _thread: thread }
+ NotifyHandle { sender, _thread: thread }
}
fn set_config(&mut self, config: loader::Config) {
self.sender.send(Message::Config(config)).unwrap()
type NotifyEvent = notify::Result<notify::Event>;
-struct LoaderActor {
+struct NotifyActor {
+ sender: loader::Sender,
config: Vec<(AbsPathBuf, Include, bool)>,
watched_paths: FxHashSet<AbsPathBuf>,
- sender: loader::Sender,
// Drop order of fields bellow is significant,
watcher: Option<RecommendedWatcher>,
watcher_receiver: Receiver<NotifyEvent>,
NotifyEvent(NotifyEvent),
}
-impl LoaderActor {
- fn new(sender: loader::Sender) -> LoaderActor {
+impl NotifyActor {
+ fn new(sender: loader::Sender) -> NotifyActor {
let (watcher_sender, watcher_receiver) = unbounded();
let watcher = log_notify_error(Watcher::new_immediate(move |event| {
watcher_sender.send(event).unwrap()
}));
- LoaderActor {
- watcher,
- watcher_receiver,
- watched_paths: FxHashSet::default(),
+ NotifyActor {
sender,
config: Vec::new(),
+ watched_paths: FxHashSet::default(),
+ watcher,
+ watcher_receiver,
}
}