Add some more stage metrics

schala-lang/language/src/schala.rs

@@ -23,6 +23,8 @@ pub struct Schala<'a> {
 
     /// Execution state for AST-walking interpreter
     eval_state: tree_walk_eval::State<'a>,
+
+    timings: Vec<(&'static str, std::time::Duration)>,
 }
 
 /*
@@ -47,6 +49,7 @@ impl<'a> Schala<'a> {
             type_context: type_inference::TypeContext::new(),
             active_parser: parsing::Parser::new(),
             eval_state: tree_walk_eval::State::new(),
+            timings: Vec::new(),
         }
     }
 
@@ -68,6 +71,9 @@ impl<'a> Schala<'a> {
     /// Note: this should eventually use a query-based system for parallelization, cf.
     /// https://rustc-dev-guide.rust-lang.org/overview.html
     fn run_pipeline(&mut self, source: &str, config: SchalaConfig) -> Result<String, SchalaError> {
+        self.timings = vec![];
+        let sw = Stopwatch::start_new();
+
         // 1st stage - tokenization
         // TODO tokenize should return its own error type
         let tokens = tokenizing::tokenize(source);
@@ -81,19 +87,27 @@ impl<'a> Schala<'a> {
             .active_parser
             .parse()
             .map_err(|err| SchalaError::from_parse_error(err, &self.source_reference))?;
+        self.timings.push(("parsing", sw.elapsed()));
 
+        let sw = Stopwatch::start_new();
         //Perform all symbol table work
         self.symbol_table
             .process_ast(&ast, &mut self.type_context)
             .map_err(SchalaError::from_symbol_table)?;
 
+        self.timings.push(("symbol_table", sw.elapsed()));
+
         // Typechecking
         // TODO typechecking not working
         //let _overall_type = self.type_context.typecheck(&ast).map_err(SchalaError::from_type_error);
 
+        let sw = Stopwatch::start_new();
         let reduced_ir = reduced_ir::reduce(&ast, &self.symbol_table, &self.type_context);
+        self.timings.push(("reduced_ir", sw.elapsed()));
 
+        let sw = Stopwatch::start_new();
         let evaluation_outputs = self.eval_state.evaluate(reduced_ir, &self.type_context, config.repl);
+        self.timings.push(("tree-walking-evaluation", sw.elapsed()));
         let text_output: Result<Vec<String>, String> = evaluation_outputs.into_iter().collect();
 
         let text_output: Result<Vec<String>, SchalaError> =
@@ -168,8 +182,13 @@ impl<'a> ProgrammingLanguageInterface for Schala<'a> {
 
         let main_output =
             self.run_pipeline(source, request.config).map_err(|schala_err| schala_err.display());
+        let total_duration = sw.elapsed();
 
-        let global_output_stats = GlobalOutputStats { total_duration: sw.elapsed(), stage_durations: vec![] };
+        let stage_durations: Vec<_> = std::mem::replace(&mut self.timings, vec![])
+            .into_iter()
+            .map(|(label, duration)| (label.to_string(), duration))
+            .collect();
+        let global_output_stats = GlobalOutputStats { total_duration, stage_durations };
 
         ComputationResponse { main_output, global_output_stats, debug_responses: vec![] }
     }

schala-lang/language/src/symbol_table/populator.rs

@@ -146,7 +146,6 @@ impl<'a> SymbolTablePopulator<'a> {
         scope_stack: &[ScopeSegment],
         inner: &Statement,
     ) -> Result<(), SymbolError> {
-        println!("handling annotation: {}", name);
         if name == "register_builtin" {
             if let Statement {
                 id: _,