Rewatch: show warnings in completion output

Author: Bushuo

rewatch/src/build.rs

@@ -56,6 +56,40 @@ pub struct CompilerArgs {
     pub parser_args: Vec<String>,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct IncrementalBuildResult {
+    pub has_warnings: bool,
+}
+
+fn has_output(output: &str) -> bool {
+    helpers::contains_ascii_characters(output)
+}
+
+fn has_config_warnings(build_state: &BuildCommandState) -> bool {
+    build_state.packages.iter().any(|(_, package)| {
+        package.is_local_dep
+            && (!package.config.get_unsupported_fields().is_empty()
+                || !package.config.get_unknown_fields().is_empty())
+    })
+}
+
+pub fn format_finished_compilation_message(
+    compilation_kind: Option<&str>,
+    has_warnings: bool,
+    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 { "" };
+
+    format!(
+        "{LINE_CLEAR}{status}Finished {compilation_kind}compilation{warning_suffix} in {:.2}s",
+        duration.as_secs_f64()
+    )
+}
+
 pub fn get_compiler_args(rescript_file_path: &Path) -> Result<String> {
     let filename = &helpers::get_abs_path(rescript_file_path);
     let current_package = helpers::get_abs_path(
@@ -246,7 +280,7 @@ pub fn incremental_build(
     only_incremental: bool,
     create_sourcedirs: bool,
     plain_output: bool,
-) -> Result<(), IncrementalBuildError> {
+) -> Result<IncrementalBuildResult, IncrementalBuildError> {
     let build_folder = build_state.root_folder.to_string_lossy().to_string();
 
     let _lock = get_lock_or_exit(LockKind::Build, &build_folder);
@@ -264,7 +298,7 @@ pub fn incremental_build(
         ProgressStyle::with_template(&format!(
             "{} {}Parsing... {{spinner}} {{pos}}/{{len}} {{msg}}",
             format_step(current_step, total_steps),
-            CODE
+            PARSE
         ))
         .unwrap(),
     );
@@ -314,13 +348,14 @@ pub fn incremental_build(
                 "{}{} {}Parsed {} source files in {:.2}s",
                 LINE_CLEAR,
                 format_step(current_step, total_steps),
-                CODE,
+                PARSE,
                 num_dirty_modules,
                 default_timing.unwrap_or(timing_parse_total).as_secs_f64()
             );
         }
     }
-    if helpers::contains_ascii_characters(&parse_warnings) {
+    let has_parse_warnings = has_output(&parse_warnings);
+    if has_parse_warnings {
         eprintln!("{}", &parse_warnings);
     }
 
@@ -389,13 +424,13 @@ pub fn incremental_build(
                 );
             }
         }
-        if helpers::contains_ascii_characters(&compile_warnings) {
+        if has_output(&compile_warnings) {
             eprintln!("{}", &compile_warnings);
         }
         if initial_build {
             log_config_warnings(build_state);
         }
-        if helpers::contains_ascii_characters(&compile_errors) {
+        if has_output(&compile_errors) {
             eprintln!("{}", &compile_errors);
         }
 
@@ -406,6 +441,10 @@ pub fn incremental_build(
             plain_output,
         })
     } 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;
+
         if show_progress {
             if plain_output {
                 println!("Compiled {num_compiled_modules} modules")
@@ -421,7 +460,7 @@ pub fn incremental_build(
             }
         }
 
-        if helpers::contains_ascii_characters(&compile_warnings) {
+        if has_compile_warnings {
             eprintln!("{}", &compile_warnings);
         }
         if initial_build {
@@ -432,7 +471,7 @@ pub fn incremental_build(
         write_compiler_info(build_state);
 
         let _lock = drop_lock(LockKind::Build, &build_folder);
-        Ok(())
+        Ok(IncrementalBuildResult { has_warnings })
     }
 }
 
@@ -519,14 +558,16 @@ pub fn build(
         create_sourcedirs,
         plain_output,
     ) {
-        Ok(_) => {
+        Ok(result) => {
             if !plain_output && show_progress {
                 let timing_total_elapsed = timing_total.elapsed();
                 println!(
-                    "\n{}{}Finished Compilation in {:.2}s",
-                    LINE_CLEAR,
-                    SPARKLES,
-                    default_timing.unwrap_or(timing_total_elapsed).as_secs_f64()
+                    "\n{}",
+                    format_finished_compilation_message(
+                        None,
+                        result.has_warnings,
+                        default_timing.unwrap_or(timing_total_elapsed),
+                    )
                 );
             }
             clean::cleanup_after_build(&build_state);
@@ -540,3 +581,27 @@ pub fn build(
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn formats_successful_completion_message() {
+        assert_eq!(
+            format_finished_compilation_message(None, false, 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!(
+                "{LINE_CLEAR}{}Finished incremental compilation with warnings in 1.50s",
+                WARNING
+            )
+        );
+    }
+}

rewatch/src/helpers.rs

@@ -18,13 +18,13 @@ pub mod deserialize;
 
 pub mod emojis {
     use console::Emoji;
-    pub static COMMAND: Emoji<'_, '_> = Emoji("🏃 ", "");
-    pub static SWEEP: Emoji<'_, '_> = Emoji("🧹 ", "");
-    pub static CODE: Emoji<'_, '_> = Emoji("🧱 ", "");
-    pub static SWORDS: Emoji<'_, '_> = Emoji("🤺 ", "");
-    pub static CHECKMARK: Emoji<'_, '_> = Emoji("✅ ", "");
-    pub static CROSS: Emoji<'_, '_> = Emoji("❌ ", "");
-    pub static SPARKLES: Emoji<'_, '_> = Emoji("✨ ", "");
+    pub static COMMAND: Emoji<'_, '_> = Emoji("🏃 ", "[run] ");
+    pub static SWEEP: Emoji<'_, '_> = Emoji("🧹 ", "[clean] ");
+    pub static PARSE: Emoji<'_, '_> = Emoji("🧱 ", "[parse] ");
+    pub static SWORDS: Emoji<'_, '_> = Emoji("🤺 ", "[build] ");
+    pub static CHECKMARK: Emoji<'_, '_> = Emoji("✅ ", "[ok] ");
+    pub static WARNING: Emoji<'_, '_> = Emoji("⚠️ ", "[warn] ");
+    pub static CROSS: Emoji<'_, '_> = Emoji("❌ ", "[error] ");
     pub static LINE_CLEAR: &str = "\x1b[2K\r";
 }
 

rewatch/src/watcher.rs

@@ -5,7 +5,6 @@ use crate::cmd;
 use crate::config;
 use crate::helpers;
 use crate::helpers::StrippedVerbatimPath;
-use crate::helpers::emojis::*;
 use crate::lock::LockKind;
 use crate::queue::FifoQueue;
 use crate::queue::*;
@@ -379,17 +378,15 @@ async fn async_watch(
         match needs_compile_type {
             CompileType::Incremental => {
                 let timing_total = Instant::now();
-                if build::incremental_build(
+                if let Ok(result) = build::incremental_build(
                     &mut build_state,
                     None,
                     initial_build,
                     show_progress,
                     !initial_build,
                     create_sourcedirs,
                     plain_output,
-                )
-                .is_ok()
-                {
+                ) {
                     if let Some(a) = after_build.clone() {
                         cmd::run(a)
                     }
@@ -400,11 +397,12 @@ async fn async_watch(
                             println!("Finished {compilation_type} compilation")
                         } else {
                             println!(
-                                "\n{}{}Finished {} compilation in {:.2}s\n",
-                                LINE_CLEAR,
-                                SPARKLES,
-                                compilation_type,
-                                timing_total_elapsed.as_secs_f64()
+                                "\n{}\n",
+                                build::format_finished_compilation_message(
+                                    Some(compilation_type),
+                                    result.has_warnings,
+                                    timing_total_elapsed,
+                                )
                             );
                         }
                     }
@@ -436,7 +434,7 @@ async fn async_watch(
                 current_watch_paths = compute_watch_paths(&build_state, path);
                 register_watches(watcher, &current_watch_paths);
 
-                let _ = build::incremental_build(
+                let result = build::incremental_build(
                     &mut build_state,
                     None,
                     initial_build,
@@ -445,25 +443,25 @@ async fn async_watch(
                     create_sourcedirs,
                     plain_output,
                 );
-                if let Some(a) = after_build.clone() {
-                    cmd::run(a)
-                }
-
-                build::write_build_ninja(&build_state);
+                if let Ok(result) = result {
+                    if let Some(a) = after_build.clone() {
+                        cmd::run(a)
+                    }
 
-                let timing_total_elapsed = timing_total.elapsed();
-                if show_progress {
-                    if plain_output {
-                        println!("Finished compilation")
-                    } else {
+                    let timing_total_elapsed = timing_total.elapsed();
+                    if !plain_output && show_progress {
                         println!(
-                            "\n{}{}Finished compilation in {:.2}s\n",
-                            LINE_CLEAR,
-                            SPARKLES,
-                            timing_total_elapsed.as_secs_f64()
+                            "\n{}\n",
+                            build::format_finished_compilation_message(
+                                None,
+                                result.has_warnings,
+                                timing_total_elapsed,
+                            )
                         );
                     }
                 }
+
+                build::write_build_ninja(&build_state);
                 needs_compile_type = CompileType::None;
                 initial_build = false;
             }