feat: add compilation progress with time

quartz/compiler.qz

@@ -149,9 +149,19 @@ module Compiler {
  validate_address: bool,
  test_mode: bool,
  output_path: string,
+ progress: bool,
  ): nil or error {
+ let start_time = unixtime::now_nanosec();
+
  let module_ = self.parse(input, nil, skip_errors, true).context("parse").try;
 
+ if progress {
+ let end_time = unixtime::now_nanosec();
+ println("parse: {}ms", ((end_time - start_time) / (1000000 as i64)).to_string());
+
+ start_time = end_time;
+ }
+
  let typechecker = Typechecker::new();
  let n or err = typechecker.run(module_, main_path).context("typecheck");
  if err != nil {
@@ -232,14 +242,35 @@ module Compiler {
  return _ or err_internal;
  }
 
+ if progress {
+ let end_time = unixtime::now_nanosec();
+ println("typecheck: {}ms", ((end_time - start_time) / (1000000 as i64)).to_string());
+
+ start_time = end_time;
+ }
+
  let irgen = IrCodeGenerator::new(test_mode, "main_{}".format(entrypoint));
  irgen.globals = typechecker.globals;
  irgen.set_interfaces(typechecker.interfaces);
  let term = irgen.run(module_).context("ircodegen").try;
 
+ if progress {
+ let end_time = unixtime::now_nanosec();
+ println("ircodegen: {}ms", ((end_time - start_time) / (1000000 as i64)).to_string());
+
+ start_time = end_time;
+ }
+
  term = transform_let_call(term);
  term = transform_escaping(term);
 
+ if progress {
+ let end_time = unixtime::now_nanosec();
+ println("transform: {}ms", ((end_time - start_time) / (1000000 as i64)).to_string());
+
+ start_time = end_time;
+ }
+
  let envs = environs();
  if envs.has("GENERATE_IR") {
  file_write("quartz.ir", term.to_string());
@@ -257,9 +288,23 @@ module Compiler {
 
  term = gen.fold_consts(term);
 
+ if progress {
+ let end_time = unixtime::now_nanosec();
+ println("fold: {}ms", ((end_time - start_time) / (1000000 as i64)).to_string());
+
+ start_time = end_time;
+ }
+
  let offset = ((irgen.data_section_offset + 7) / 8) * 8;
  gen.run(term, entrypoint, offset);
 
+ if progress {
+ let end_time = unixtime::now_nanosec();
+ println("codegen: {}ms", ((end_time - start_time) / (1000000 as i64)).to_string());
+
+ start_time = end_time;
+ }
+
  writer.close();
 
  return nil;

quartz/generator.qz

@@ -4,7 +4,7 @@ import quartz::value;
 import quartz::path;
 import quartz::ir_code_gen;
 
-let MODE_READABLE_WASM = true;
+let MODE_READABLE_WASM = false;
 
 fun escape(s: string): string {
  let result = make[vec[byte]]();
@@ -103,7 +103,9 @@ module Generator {
  fun new_statement(self) {
  if self.index > 0 {
  self.writer.write("\n");
- self.writer.write(" ".repeat(self.depth * 4));
+ if MODE_READABLE_WASM {
+ self.writer.write(" ".repeat(self.depth * 4));
+ }
  }
  self.index = 0;
  }
@@ -141,8 +143,10 @@ module Generator {
  self.write(escape(element.t_data!.data));
  self.end();
  } else if element.t_comment != nil {
- self.new_statement();
- self.write(format(" ;; {}", escape(element.t_comment!)));
+ if MODE_READABLE_WASM {
+ self.new_statement();
+ self.write(format(" ;; {}", escape(element.t_comment!)));
+ }
  } else if element.t_import != nil {
  self.start();
  self.write("import");
@@ -1137,8 +1141,10 @@ module Generator {
  self.new_statement();
  self.write(format("i64.store{}", suffix));
  } else if expr.t_string != nil {
- self.new_statement();
- self.write(format(";; string: {}", escape(self.strings.at(expr.t_string!))));
+ if MODE_READABLE_WASM {
+ self.new_statement();
+ self.write(format(";; string: {}", escape(self.strings.at(expr.t_string!))));
+ }
 
  self.new_statement();
  self.write(format("i32.const {}", expr.t_string!.to_string()));
@@ -1148,8 +1154,10 @@ module Generator {
  self.new_statement();
  self.write("call $quartz_core_load_string");
  } else if expr.t_type_rep != nil {
- self.new_statement();
- self.write(format(";; type_rep: {}", derive::to_string(expr.t_type_rep!)));
+ if MODE_READABLE_WASM {
+ self.new_statement();
+ self.write(format(";; type_rep: {}", derive::to_string(expr.t_type_rep!)));
+ }
 
  self.new_statement();
  self.write(format("i32.const {}", expr.t_type_rep!.to_string()));
@@ -1203,8 +1211,10 @@ module Generator {
  let size = expr.t_sizeof!.type_.sizeof();
  let length = expr.t_sizeof!.length;
 
- self.new_statement();
- self.write(" ;; sizeof");
+ if MODE_READABLE_WASM {
+ self.new_statement();
+ self.write(" ;; sizeof");
+ }
 
  self.write_value(Value {
  t_i32: size,
@@ -1220,8 +1230,10 @@ module Generator {
  self.new_statement();
  self.write("br $exit");
  } else if expr.t_comment != nil {
- self.new_statement();
- self.write(format(" ;; {}", escape(expr.t_comment!)));
+ if MODE_READABLE_WASM {
+ self.new_statement();
+ self.write(format(" ;; {}", escape(expr.t_comment!)));
+ }
  } else if expr.t_dynamic_call != nil {
  for arg in expr.t_dynamic_call!.args {
  self.expression(arg);

quartz/main.qz

@@ -325,6 +325,7 @@ fun start(): nil or error {
  validate_address,
  compile.test,
  compile.output!,
+ envs.has("VERBOSE"),
  );
  if err != nil {
  err_println(err!.message);

quartz/std.qz

@@ -1792,7 +1792,8 @@ module FileWriter {
  return _ or error::new("fd_write").context(WasiError::from_errno(err));
  }
 
- self.buffer = make[vec[byte]]();
+ // NOTE: reuse the buffer
+ self.buffer.length = 0;
  }
 
  fun close(self) {