Rewatch: improve watch output and add clear-screen (#8373)

* Rewatch: show warnings in completion output

* Rewatch: use CompilationOutcome enum

* feat(rewatch): add watch --clear-screen

Make screen clearing opt-in so scripted stdout stays stable while
interactive watch mode can drop stale warnings and errors between
rebuilds.

Also print explicit rebuild and failure markers so fixed vs broken
state is easier to spot.

Refs #8139

Signed-off-by: Paul Kim <paul.bushuo@gmail.com>

* fix(rewatch): restore full rebuild plain output

Signed-off-by: Paul Kim <paul.bushuo@gmail.com>

---------

Signed-off-by: Paul Kim <paul.bushuo@gmail.com>

Author: Bushuo

rewatch/src/build.rs

@@ -56,6 +56,43 @@ pub struct CompilerArgs {
     pub parser_args: Vec<String>,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum CompilationOutcome {
+    Clean,
+    Warnings,
+}
+
+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>,
+    outcome: CompilationOutcome,
+    duration: Duration,
+) -> String {
+    let compilation_kind = compilation_kind
+        .map(|kind| format!("{kind} "))
+        .unwrap_or_default();
+    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",
+        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 +283,7 @@ pub fn incremental_build(
     only_incremental: bool,
     create_sourcedirs: bool,
     plain_output: bool,
-) -> Result<(), 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);
@@ -264,7 +301,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 +351,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 +427,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 +444,14 @@ 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 outcome = if has_parse_warnings || has_compile_warnings || has_config_warning_output {
+            CompilationOutcome::Warnings
+        } else {
+            CompilationOutcome::Clean
+        };
+
         if show_progress {
             if plain_output {
                 println!("Compiled {num_compiled_modules} modules")
@@ -421,7 +467,7 @@ pub fn incremental_build(
             }
         }
 
-        if helpers::contains_ascii_characters(&compile_warnings) {
+        if has_compile_warnings {
             eprintln!("{}", &compile_warnings);
         }
         if initial_build {
@@ -432,7 +478,7 @@ pub fn incremental_build(
         write_compiler_info(build_state);
 
         let _lock = drop_lock(LockKind::Build, &build_folder);
-        Ok(())
+        Ok(outcome)
     }
 }
 
@@ -519,14 +565,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,
+                        default_timing.unwrap_or(timing_total_elapsed),
+                    )
                 );
             }
             clean::cleanup_after_build(&build_state);
@@ -540,3 +588,31 @@ pub fn build(
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn formats_successful_completion_message() {
+        assert_eq!(
+            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"),
+                CompilationOutcome::Warnings,
+                Duration::from_millis(1500),
+            ),
+            format!(
+                "{LINE_CLEAR}{}Finished incremental compilation with warnings in 1.50s",
+                WARNING
+            )
+        );
+    }
+}

rewatch/src/cli.rs

@@ -383,6 +383,16 @@ mod tests {
         }
     }
 
+    #[test]
+    fn watch_clear_screen_flag_is_parsed() {
+        let cli = parse(&["rescript", "watch", "--clear-screen"]).expect("expected watch command");
+
+        match cli.command {
+            Command::Watch(watch_args) => assert!(watch_args.clear_screen),
+            other => panic!("expected watch command, got {other:?}"),
+        }
+    }
+
     #[test]
     fn clean_prod_flag_is_parsed() {
         let cli = parse(&["rescript", "clean", "--prod"]).expect("expected clean command");
@@ -428,6 +438,10 @@ pub struct WatchArgs {
     #[command(flatten)]
     pub warn_error: WarnErrorArg,
 
+    /// Clear terminal screen before each rebuild in interactive watch mode.
+    #[arg(long, default_value_t = false)]
+    pub clear_screen: bool,
+
     /// Skip dev-dependencies and dev sources (type: "dev")
     #[arg(long, default_value_t = false)]
     pub prod: bool,
@@ -440,6 +454,7 @@ impl From<BuildArgs> for WatchArgs {
             filter: build_args.filter,
             after_build: build_args.after_build,
             warn_error: build_args.warn_error,
+            clear_screen: false,
             prod: build_args.prod,
         }
     }

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/main.rs

@@ -79,6 +79,7 @@ fn main() -> Result<()> {
                 true, // create_sourcedirs is now always enabled
                 plain_output,
                 (*watch_args.warn_error).clone(),
+                watch_args.clear_screen,
                 watch_args.prod,
             ) {
                 Err(e) => {