Rewatch: use CompilationOutcome enum

Author: Bushuo

rewatch/src/build.rs

@@ -57,8 +57,9 @@ pub struct CompilerArgs {
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct IncrementalBuildResult {
-    pub has_warnings: bool,
+pub enum CompilationOutcome {
+    Clean,
+    Warnings,
 }
 
 fn has_output(output: &str) -> bool {
@@ -75,14 +76,16 @@ fn has_config_warnings(build_state: &BuildCommandState) -> bool {
 
 pub fn format_finished_compilation_message(
     compilation_kind: Option<&str>,
-    has_warnings: bool,
+    outcome: CompilationOutcome,
     duration: Duration,
 ) -> String {
     let compilation_kind = compilation_kind
         .map(|kind| format!("{kind} "))
         .unwrap_or_default();
-    let status = if has_warnings { WARNING } else { CHECKMARK };
-    let warning_suffix = if has_warnings { " with warnings" } else { "" };
+    let (status, warning_suffix) = match outcome {
+        CompilationOutcome::Clean => (CHECKMARK, ""),
+        CompilationOutcome::Warnings => (WARNING, " with warnings"),
+    };
 
     format!(
         "{LINE_CLEAR}{status}Finished {compilation_kind}compilation{warning_suffix} in {:.2}s",
@@ -279,7 +282,7 @@ pub fn incremental_build(
     only_incremental: bool,
     create_sourcedirs: bool,
     plain_output: bool,
-) -> Result<IncrementalBuildResult, IncrementalBuildError> {
+) -> Result<CompilationOutcome, IncrementalBuildError> {
     let build_folder = build_state.root_folder.to_string_lossy().to_string();
 
     let _lock = get_lock_or_exit(LockKind::Build, &build_folder);
@@ -442,7 +445,11 @@ pub fn incremental_build(
     } else {
         let has_compile_warnings = has_output(&compile_warnings);
         let has_config_warning_output = initial_build && has_config_warnings(build_state);
-        let has_warnings = has_parse_warnings || has_compile_warnings || has_config_warning_output;
+        let outcome = if has_parse_warnings || has_compile_warnings || has_config_warning_output {
+            CompilationOutcome::Warnings
+        } else {
+            CompilationOutcome::Clean
+        };
 
         if show_progress {
             if plain_output {
@@ -470,7 +477,7 @@ pub fn incremental_build(
         write_compiler_info(build_state);
 
         let _lock = drop_lock(LockKind::Build, &build_folder);
-        Ok(IncrementalBuildResult { has_warnings })
+        Ok(outcome)
     }
 }
 
@@ -564,7 +571,7 @@ pub fn build(
                     "\n{}",
                     format_finished_compilation_message(
                         None,
-                        result.has_warnings,
+                        result,
                         default_timing.unwrap_or(timing_total_elapsed),
                     )
                 );
@@ -588,15 +595,19 @@ mod tests {
     #[test]
     fn formats_successful_completion_message() {
         assert_eq!(
-            format_finished_compilation_message(None, false, Duration::from_millis(1500)),
+            format_finished_compilation_message(None, CompilationOutcome::Clean, Duration::from_millis(1500),),
             format!("{LINE_CLEAR}{}Finished compilation in 1.50s", CHECKMARK)
         );
     }
 
     #[test]
     fn formats_warning_completion_message() {
         assert_eq!(
-            format_finished_compilation_message(Some("incremental"), true, Duration::from_millis(1500)),
+            format_finished_compilation_message(
+                Some("incremental"),
+                CompilationOutcome::Warnings,
+                Duration::from_millis(1500),
+            ),
             format!(
                 "{LINE_CLEAR}{}Finished incremental compilation with warnings in 1.50s",
                 WARNING

rewatch/src/watcher.rs

@@ -400,7 +400,7 @@ async fn async_watch(
                                 "\n{}\n",
                                 build::format_finished_compilation_message(
                                     Some(compilation_type),
-                                    result.has_warnings,
+                                    result,
                                     timing_total_elapsed,
                                 )
                             );
@@ -452,11 +452,7 @@ async fn async_watch(
                     if !plain_output && show_progress {
                         println!(
                             "\n{}\n",
-                            build::format_finished_compilation_message(
-                                None,
-                                result.has_warnings,
-                                timing_total_elapsed,
-                            )
+                            build::format_finished_compilation_message(None, result, timing_total_elapsed,)
                         );
                     }
                 }