(#691): Flush the Backend buffer

Fixes #689.

Normally the `BufWriter` in `LogBackend` is `flush`ed in `drop`, but since all of this runs from a static or a background thread, no destructors are run (reliably at least; not sure about the background thread case). Thus, we need to explicitly `flush` the buffer. I believe this may be the remaining cause of #613.

This fix adds a `flush` method to `trait WriteEvent`, which is called after all `Event`s have been written so that we never lose any of the `Event`s. It's implemented by delegating to `Write::flush`, both for `BufWriter` in `LogBackend` and `stderr()` in `DebugBackend` (though that one is usually unbuffered).

I discovered this while implementing #687, as the missing `flush` is reliably detected when running the `Backend` on the main thread.

Author: kkysen

analysis/runtime/src/runtime/backend.rs

@@ -1,7 +1,7 @@
 use enum_dispatch::enum_dispatch;
 use fs_err::{File, OpenOptions};
 use std::fmt::Debug;
-use std::io::BufWriter;
+use std::io::{stderr, BufWriter, Write};
 use std::sync::mpsc::Receiver;
 
 use bincode;
@@ -14,6 +14,8 @@ use crate::parse::{self, AsStr, GetChoices};
 #[enum_dispatch]
 pub(super) trait WriteEvent {
     fn write(&mut self, event: Event);
+
+    fn flush(&mut self);
 }
 
 pub(super) trait DetectBackend: Sized {
@@ -56,6 +58,10 @@ impl WriteEvent for DebugBackend {
         let mir_loc = self.metadata.get(event.mir_loc);
         eprintln!("{:?}: {:?}", mir_loc, event.kind);
     }
+
+    fn flush(&mut self) {
+        stderr().flush().unwrap();
+    }
 }
 
 pub struct LogBackend {
@@ -66,6 +72,10 @@ impl WriteEvent for LogBackend {
     fn write(&mut self, event: Event) {
         bincode::serialize_into(&mut self.writer, &event).unwrap();
     }
+
+    fn flush(&mut self) {
+        self.writer.flush().unwrap();
+    }
 }
 
 #[enum_dispatch(WriteEvent)]
@@ -80,9 +90,10 @@ impl Backend {
             let done = matches!(event.kind, EventKind::Done);
             self.write(event);
             if done {
-                return;
+                break;
             }
         }
+        self.flush();
     }
 
     pub fn run(&mut self, rx: Receiver<Event>) {