Merge branch 'trunk' into integrate-linker

.github/workflows/benchmarks.yml

@@ -42,4 +42,4 @@ jobs:
         run: cd ci/bench-runner && cargo build --release && cd ../..
 
       - name: run benchmarks with regression check
-        run: ./ci/bench-runner/target/release/bench-runner --check-executables-changed
+        run: echo "TODO re-enable benchmarks once race condition is fixed"#./ci/bench-runner/target/release/bench-runner --check-executables-changed

cli/src/build.rs

@@ -312,3 +312,88 @@ fn spawn_rebuild_thread(
         rebuild_host_end.as_millis()
     })
 }
+
+#[allow(clippy::too_many_arguments)]
+pub fn check_file(
+    arena: &Bump,
+    src_dir: PathBuf,
+    roc_file_path: PathBuf,
+    emit_timings: bool,
+) -> Result<usize, LoadingProblem> {
+    let compilation_start = SystemTime::now();
+
+    // only used for generating errors. We don't do code generation, so hardcoding should be fine
+    // we need monomorphization for when exhaustiveness checking
+    let ptr_bytes = 8;
+
+    // Step 1: compile the app and generate the .o file
+    let subs_by_module = MutMap::default();
+
+    // Release builds use uniqueness optimizations
+    let stdlib = arena.alloc(roc_builtins::std::standard_stdlib());
+
+    let mut loaded = roc_load::file::load_and_monomorphize(
+        arena,
+        roc_file_path,
+        stdlib,
+        src_dir.as_path(),
+        subs_by_module,
+        ptr_bytes,
+        builtin_defs_map,
+    )?;
+
+    let buf = &mut String::with_capacity(1024);
+
+    let mut it = loaded.timings.iter().peekable();
+    while let Some((module_id, module_timing)) = it.next() {
+        let module_name = loaded.interns.module_name(*module_id);
+
+        buf.push_str("    ");
+
+        if module_name.is_empty() {
+            // the App module
+            buf.push_str("Application Module");
+        } else {
+            buf.push_str(module_name);
+        }
+
+        buf.push('\n');
+
+        report_timing(buf, "Read .roc file from disk", module_timing.read_roc_file);
+        report_timing(buf, "Parse header", module_timing.parse_header);
+        report_timing(buf, "Parse body", module_timing.parse_body);
+        report_timing(buf, "Canonicalize", module_timing.canonicalize);
+        report_timing(buf, "Constrain", module_timing.constrain);
+        report_timing(buf, "Solve", module_timing.solve);
+        report_timing(
+            buf,
+            "Find Specializations",
+            module_timing.find_specializations,
+        );
+        report_timing(
+            buf,
+            "Make Specializations",
+            module_timing.make_specializations,
+        );
+        report_timing(buf, "Other", module_timing.other());
+        buf.push('\n');
+        report_timing(buf, "Total", module_timing.total());
+
+        if it.peek().is_some() {
+            buf.push('\n');
+        }
+    }
+
+    let compilation_end = compilation_start.elapsed().unwrap();
+
+    if emit_timings {
+        println!(
+            "\n\nCompilation finished!\n\nHere's how long each module took to compile:\n\n{}",
+            buf
+        );
+
+        println!("Finished checking in {} ms\n", compilation_end.as_millis(),);
+    }
+
+    Ok(program::report_problems(&mut loaded))
+}

cli/src/lib.rs

@@ -26,6 +26,7 @@ pub const CMD_BUILD: &str = "build";
 pub const CMD_REPL: &str = "repl";
 pub const CMD_EDIT: &str = "edit";
 pub const CMD_DOCS: &str = "docs";
+pub const CMD_CHECK: &str = "check";
 
 pub const FLAG_DEBUG: &str = "debug";
 pub const FLAG_DEV: &str = "dev";
@@ -138,6 +139,20 @@ pub fn build_app<'a>() -> App<'a> {
         .subcommand(App::new(CMD_REPL)
             .about("Launch the interactive Read Eval Print Loop (REPL)")
         )
+        .subcommand(App::new(CMD_CHECK)
+            .about("Build a binary from the given .roc file, but don't run it")
+            .arg(
+                Arg::with_name(FLAG_TIME)
+                    .long(FLAG_TIME)
+                    .help("Prints detailed compilation time information.")
+                    .required(false),
+            )
+            .arg(
+                Arg::with_name(ROC_FILE)
+                    .help("The .roc file of an app to run")
+                    .required(true),
+            )
+            )
         .subcommand(
             App::new(CMD_DOCS)
                 .about("Generate documentation for Roc modules")

cli/src/main.rs

@@ -1,7 +1,9 @@
+use roc_cli::build::check_file;
 use roc_cli::{
-    build_app, docs, repl, BuildConfig, CMD_BUILD, CMD_DOCS, CMD_EDIT, CMD_REPL, CMD_RUN,
-    DIRECTORY_OR_FILES, ROC_FILE,
+    build_app, docs, repl, BuildConfig, CMD_BUILD, CMD_CHECK, CMD_DOCS, CMD_EDIT, CMD_REPL,
+    CMD_RUN, DIRECTORY_OR_FILES, FLAG_TIME, ROC_FILE,
 };
+use roc_load::file::LoadingProblem;
 use std::fs::{self, FileType};
 use std::io;
 use std::path::{Path, PathBuf};
@@ -52,6 +54,31 @@ If you're building the compiler from source you'll want to do `cargo run [FILE]`
 
             Ok(1)
         }
+        Some(CMD_CHECK) => {
+            let arena = bumpalo::Bump::new();
+
+            let matches = matches.subcommand_matches(CMD_CHECK).unwrap();
+            let emit_timings = matches.is_present(FLAG_TIME);
+            let filename = matches.value_of(ROC_FILE).unwrap();
+            let roc_file_path = PathBuf::from(filename);
+            let src_dir = roc_file_path.parent().unwrap().to_owned();
+
+            match check_file(&arena, src_dir, roc_file_path, emit_timings) {
+                Ok(number_of_errors) => {
+                    let exit_code = if number_of_errors != 0 { 1 } else { 0 };
+                    Ok(exit_code)
+                }
+
+                Err(LoadingProblem::FormattedReport(report)) => {
+                    print!("{}", report);
+
+                    Ok(1)
+                }
+                Err(other) => {
+                    panic!("build_file failed with error:\n{:?}", other);
+                }
+            }
+        }
         Some(CMD_REPL) => {
             repl::main()?;
 

compiler/build/src/link.rs

@@ -56,7 +56,7 @@ fn find_zig_str_path() -> PathBuf {
         return zig_str_path;
     }
 
-    panic!("cannot find `str.zig`")
+    panic!("cannot find `str.zig`. Launch me from either the root of the roc repo or one level down(roc/examples, roc/cli...)")
 }
 
 fn find_wasi_libc_path() -> PathBuf {