Evaluating commands fails after #168

src/ghci/compilation_log.rs

@@ -0,0 +1,57 @@
+use crate::ghci::parse::CompilationResult;
+use crate::ghci::parse::CompilationSummary;
+use crate::ghci::parse::GhcDiagnostic;
+use crate::ghci::parse::GhcMessage;
+use crate::ghci::parse::Severity;
+
+/// A log of messages from compilation, used to write the error log.
+#[derive(Debug, Clone, Default)]
+pub struct CompilationLog {
+    pub summary: Option<CompilationSummary>,
+    pub diagnostics: Vec<GhcDiagnostic>,
+}
+
+impl CompilationLog {
+    /// Get the result of compilation.
+    pub fn result(&self) -> Option<CompilationResult> {
+        self.summary.map(|summary| summary.result)
+    }
+}
+
+impl Extend<GhcMessage> for CompilationLog {
+    fn extend<T: IntoIterator<Item = GhcMessage>>(&mut self, iter: T) {
+        for message in iter {
+            match message {
+                GhcMessage::Compiling(module) => {
+                    tracing::debug!(module = %module.name, path = %module.path, "Compiling");
+                }
+                GhcMessage::Diagnostic(diagnostic) => {
+                    if let GhcDiagnostic {
+                        severity: Severity::Error,
+                        path: Some(path),
+                        message,
+                        ..
+                    } = &diagnostic
+                    {
+                        // We can't use 'message' for the field name because that's what tracing uses
+                        // for the message.
+                        tracing::debug!(%path, error = message, "Module failed to compile");
+                    }
+                    self.diagnostics.push(diagnostic);
+                }
+                GhcMessage::Summary(summary) => {
+                    self.summary = Some(summary);
+                    match summary.result {
+                        CompilationResult::Ok => {
+                            tracing::debug!("Compilation succeeded");
+                        }
+                        CompilationResult::Err => {
+                            tracing::debug!("Compilation failed");
+                        }
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+}

src/ghci/error_log.rs

@@ -6,8 +6,7 @@ use tokio::io::BufWriter;
 use tracing::instrument;
 
 use super::parse::CompilationResult;
-use super::parse::CompilationSummary;
-use super::parse::GhcMessage;
+use super::CompilationLog;
 
 /// Error log writer.
 ///
@@ -24,12 +23,8 @@ impl ErrorLog {
     }
 
     /// Write the error log, if any, with the given compilation summary and diagnostic messages.
-    #[instrument(skip(self, messages), name = "error_log_write", level = "debug")]
-    pub async fn write(
-        &mut self,
-        compilation_summary: Option<CompilationSummary>,
-        messages: &[GhcMessage],
-    ) -> miette::Result<()> {
+    #[instrument(skip(self, log), name = "error_log_write", level = "debug")]
+    pub async fn write(&mut self, log: &CompilationLog) -> miette::Result<()> {
         let path = match &self.path {
             Some(path) => path,
             None => {
@@ -41,7 +36,7 @@ impl ErrorLog {
         let file = File::create(path).await.into_diagnostic()?;
         let mut writer = BufWriter::new(file);
 
-        if let Some(summary) = compilation_summary {
+        if let Some(summary) = log.summary {
             // `ghcid` only writes the headline if there's no errors.
             if let CompilationResult::Ok = summary.result {
                 tracing::debug!(%path, "Writing 'All good'");
@@ -57,13 +52,11 @@ impl ErrorLog {
             }
         }
 
-        for message in messages {
-            if let GhcMessage::Diagnostic(diagnostic) = message {
-                writer
-                    .write_all(diagnostic.to_string().as_bytes())
-                    .await
-                    .into_diagnostic()?;
-            }
+        for diagnostic in &log.diagnostics {
+            writer
+                .write_all(diagnostic.to_string().as_bytes())
+                .await
+                .into_diagnostic()?;
         }
 
         // This is load-bearing! If we don't properly flush/shutdown the handle, nothing gets

src/ghci/manager.rs

@@ -12,6 +12,7 @@ use tokio::sync::Mutex;
 use tracing::instrument;
 
 use crate::event_filter::FileEvent;
+use crate::ghci::CompilationLog;
 use crate::shutdown::ShutdownHandle;
 
 use super::Ghci;
@@ -60,11 +61,12 @@ pub async fn run_ghci(
         .wrap_err("Failed to start `ghci`")?;
 
     // Wait for ghci to finish loading.
+    let mut log = CompilationLog::default();
     tokio::select! {
         _ = handle.on_shutdown_requested() => {
             ghci.stop().await.wrap_err("Failed to quit ghci")?;
         }
-        startup_result = ghci.initialize() => {
+        startup_result = ghci.initialize(&mut log) => {
             startup_result?;
         }
     }