Merge `Parsed` and `Layouted` types into `Pass` with `Feedback` 🌝🎢🌚

1 files changed, 31 insertions, 35 deletions

diff --git a/tests/src/typeset.rs b/tests/src/typeset.rs
index 61889e95..efeb5aee 100644
--- a/tests/src/typeset.rs
+++ b/tests/src/typeset.rs
@@ -5,6 +5,7 @@ use std::fs::{File, create_dir_all, read_dir, read_to_string};
 use std::io::{BufWriter, Write};
 use std::panic;
 use std::process::Command;
+use std::time::{Instant, Duration};
 
 use futures_executor::block_on;
 
@@ -55,8 +56,6 @@ fn main() -> DynResult<()> {
         }).ok();
     }
 
-    println!();
-
     Ok(())
 }
 
@@ -121,43 +120,40 @@ fn test(name: &str, src: &str) -> DynResult<()> {
 
 /// Compile the source code with the typesetter.
 fn compile(typesetter: &Typesetter, src: &str) -> MultiLayout {
-    #![allow(unused_variables)]
-    use std::time::Instant;
-
-    // Warmup.
-    #[cfg(not(debug_assertions))]
-    let warmup = {
-        let warmup_start = Instant::now();
-        block_on(typesetter.typeset(&src));
-        Instant::now() - warmup_start
-    };
-
-    let start = Instant::now();
-    let parsed = typesetter.parse(&src);
-    let parse = Instant::now() - start;
-
-    if !parsed.errors.is_empty() {
-        println!("parse errors: {:#?}", parsed.errors);
-    }
-
-    let start_layout = Instant::now();
-    let layouted = block_on(typesetter.layout(&parsed.output));
-    let layout = Instant::now() - start_layout;
-    let total = Instant::now() - start;
-
-    if !layouted.errors.is_empty() {
-        println!("layout errors: {:#?}", layouted.errors);
-    }
+    if cfg!(debug_assertions) {
+        let typeset = block_on(typesetter.typeset(src));
+        let errors = typeset.feedback.errors;
+
+        if !errors.is_empty() {
+            for error in errors {
+                println!("  {:?} {:?}: {}",
+                    error.v.severity,
+                    error.span,
+                    error.v.message
+                );
+            }
+        }
 
-    #[cfg(not(debug_assertions))] {
-        println!(" - cold start:  {:?}", warmup);
-        println!(" - warmed up:   {:?}", total);
+        typeset.output
+    } else {
+        fn measure<T>(f: impl FnOnce() -> T) -> (T, Duration) {
+            let start = Instant::now();
+            let output = f();
+            let duration = Instant::now() - start;
+            (output, duration)
+        };
+
+        let (_, cold) = measure(|| block_on(typesetter.typeset(src)));
+        let (model, parse) = measure(|| typesetter.parse(src).output);
+        let (layouts, layout) = measure(|| block_on(typesetter.layout(&model)).output);
+
+        println!(" - cold start:  {:?}", cold);
+        println!(" - warmed up:   {:?}", parse + layout);
         println!("   - parsing:   {:?}", parse);
         println!("   - layouting: {:?}", layout);
-        println!();
-    }
 
-    layouted.output
+        layouts
+    }
 }
 
 /// Command line options.