From 9a50ba37ce917a37ee426e66257536349d11d77b Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Mon, 17 May 2021 17:15:10 +0200 Subject: [PATCH 001/496] criterion benchmarks for examples/benchmarks, moved cli helpers --- Cargo.lock | 1 + cli/Cargo.toml | 11 +- cli/benches/main_benchmark.rs | 186 ++++++++++++++++++++++++++++++++++ cli/{tests => src}/helpers.rs | 2 +- cli/src/lib.rs | 1 + cli/tests/cli_run.rs | 4 +- cli/tests/repl_eval.rs | 4 +- 7 files changed, 199 insertions(+), 10 deletions(-) create mode 100644 cli/benches/main_benchmark.rs rename cli/{tests => src}/helpers.rs (99%) diff --git a/Cargo.lock b/Cargo.lock index 55121233dd..ac69320050 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2917,6 +2917,7 @@ dependencies = [ "bumpalo", "clap 3.0.0-beta.1", "const_format", + "criterion", "im 14.3.0", "im-rc 14.3.0", "indoc 0.3.6", diff --git a/cli/Cargo.toml b/cli/Cargo.toml index 007d67b699..71d905321c 100644 --- a/cli/Cargo.toml +++ b/cli/Cargo.toml @@ -82,6 +82,9 @@ libloading = "0.6" inkwell = { git = "https://github.com/rtfeldman/inkwell", tag = "llvm10-0.release4", features = [ "llvm10-0" ] } target-lexicon = "0.10" tempfile = "3.1.0" +serde = { version = "1.0", features = ["derive"] } +strip-ansi-escapes = "0.1" +serde-xml-rs = "0.4" [dev-dependencies] pretty_assertions = "0.5.1" @@ -89,8 +92,10 @@ maplit = "1.0.1" indoc = "0.3.3" quickcheck = "0.8" quickcheck_macros = "0.8" -strip-ansi-escapes = "0.1" -serde = { version = "1.0", features = ["derive"] } -serde-xml-rs = "0.4" serial_test = "0.5" tempfile = "3.1.0" +criterion = "0.3.4" + +[[bench]] +name = "main_benchmark" +harness = false diff --git a/cli/benches/main_benchmark.rs b/cli/benches/main_benchmark.rs new file mode 100644 index 0000000000..60ff7e4b97 --- /dev/null +++ b/cli/benches/main_benchmark.rs @@ -0,0 +1,186 @@ +use criterion::{ + black_box, criterion_group, criterion_main, measurement::WallTime, BenchmarkGroup, Criterion, + SamplingMode, +}; +use roc_cli::helpers::{example_file, run_cmd, run_roc}; +use std::path::Path; + +// run without optimization, without input +fn exec_bench_simple( + file: &Path, + executable_filename: &str, + expected_ending: &str, + bench_group: &mut BenchmarkGroup, +) { + exec_benchmark( + file, + "", + executable_filename, + expected_ending, + false, + bench_group, + ) +} + +fn exec_benchmark( + file: &Path, + stdin_str: &str, + executable_filename: &str, + expected_ending: &str, + run_optimized: bool, + bench_group: &mut BenchmarkGroup, +) { + let flags: &[&str] = if run_optimized { &["--optimize"] } else { &[] }; + + let compile_out = run_roc(&[&["build", file.to_str().unwrap()], flags].concat()); + + if !compile_out.stderr.is_empty() { + panic!("{}", compile_out.stderr); + } + + assert!( + compile_out.status.success(), + "build ended with bad status {:?}", + compile_out + ); + + check_cmd_output(file, stdin_str, executable_filename, expected_ending); + + bench_cmd(file, stdin_str, executable_filename, bench_group); +} + +fn check_cmd_output( + file: &Path, + stdin_str: &str, + executable_filename: &str, + expected_ending: &str, +) { + let out = run_cmd( + file.with_file_name(executable_filename).to_str().unwrap(), + stdin_str, + &[], + ); + + if !&out.stdout.ends_with(expected_ending) { + panic!( + "expected output to end with {:?} but instead got {:#?}", + expected_ending, out + ); + } + assert!(out.status.success()); +} + +fn bench_cmd( + file: &Path, + stdin_str: &str, + executable_filename: &str, + bench_group: &mut BenchmarkGroup, +) { + bench_group.bench_function(&format!("Benchmarking {:?}", executable_filename), |b| { + b.iter(|| { + run_cmd( + black_box(file.with_file_name(executable_filename).to_str().unwrap()), + black_box(stdin_str), + &[], + ) + }) + }); +} + +fn bench_nqueens(bench_group: &mut BenchmarkGroup) { + exec_bench_simple( + &example_file("benchmarks", "NQueens.roc"), + "nqueens", + "4\n", + bench_group, + ); +} + +fn bench_cfold(bench_group: &mut BenchmarkGroup) { + exec_bench_simple( + &example_file("benchmarks", "CFold.roc"), + "cfold", + "11 & 11\n", + bench_group, + ); +} + +fn bench_deriv(bench_group: &mut BenchmarkGroup) { + exec_bench_simple( + &example_file("benchmarks", "Deriv.roc"), + "deriv", + "1 count: 6\n2 count: 22\n", + bench_group, + ); +} + +fn bench_rbtree(bench_group: &mut BenchmarkGroup) { + exec_bench_simple( + &example_file("benchmarks", "RBTreeInsert.roc"), + "rbtree-insert", + "Node Black 0 {} Empty Empty\n", + bench_group, + ); +} + +fn bench_rbtree_delete(bench_group: &mut BenchmarkGroup) { + exec_bench_simple( + &example_file("benchmarks", "RBTreeDel.roc"), + "rbtree-del", + "30\n", + bench_group, + ); +} + +fn bench_astar(bench_group: &mut BenchmarkGroup) { + exec_bench_simple( + &example_file("benchmarks", "TestAStar.roc"), + "test-astar", + "True\n", + bench_group, + ); +} + +fn bench_base64(bench_group: &mut BenchmarkGroup) { + exec_bench_simple( + &example_file("benchmarks", "TestBase64.roc"), + "test-base64", + "encoded: SGVsbG8gV29ybGQ=\ndecoded: Hello World\n", + bench_group, + ); +} + +fn bench_closure(bench_group: &mut BenchmarkGroup) { + exec_bench_simple( + &example_file("benchmarks", "Closure.roc"), + "closure", + "", + bench_group, + ); +} + +fn bench_group_sample_100(c: &mut Criterion) { + let mut group = c.benchmark_group("bench-group-sample-100-unoptimized"); + // calculate statistics based on a fixed(flat) 100 runs + group.sampling_mode(SamplingMode::Flat); + + let bench_funcs: Vec) -> ()> = vec![ + bench_nqueens, + bench_cfold, + bench_deriv, + bench_rbtree, + bench_rbtree_delete, + bench_astar, + bench_base64, + bench_closure, + ]; + + for bench_func in bench_funcs.iter() { + bench_func(&mut group) + } + + group.finish(); +} + +criterion_group!(benches, bench_group_sample_100); +criterion_main!(benches); diff --git a/cli/tests/helpers.rs b/cli/src/helpers.rs similarity index 99% rename from cli/tests/helpers.rs rename to cli/src/helpers.rs index 6f45d89a68..ddadde6c73 100644 --- a/cli/tests/helpers.rs +++ b/cli/src/helpers.rs @@ -5,7 +5,7 @@ extern crate roc_load; extern crate roc_module; extern crate tempfile; -use roc_cli::repl::{INSTRUCTIONS, WELCOME_MESSAGE}; +use crate::repl::{INSTRUCTIONS, WELCOME_MESSAGE}; use serde::Deserialize; use serde_xml_rs::from_str; use std::env; diff --git a/cli/src/lib.rs b/cli/src/lib.rs index 91948044c2..c38963d4dd 100644 --- a/cli/src/lib.rs +++ b/cli/src/lib.rs @@ -15,6 +15,7 @@ use std::process::Command; use target_lexicon::Triple; pub mod build; +pub mod helpers; pub mod repl; pub const CMD_RUN: &str = "run"; diff --git a/cli/tests/cli_run.rs b/cli/tests/cli_run.rs index dc10f81ce0..d7f081ba04 100644 --- a/cli/tests/cli_run.rs +++ b/cli/tests/cli_run.rs @@ -7,11 +7,9 @@ extern crate roc_collections; extern crate roc_load; extern crate roc_module; -mod helpers; - #[cfg(test)] mod cli_run { - use crate::helpers::{ + use roc_cli::helpers::{ example_file, extract_valgrind_errors, fixture_file, run_cmd, run_roc, run_with_valgrind, ValgrindError, ValgrindErrorXWhat, }; diff --git a/cli/tests/repl_eval.rs b/cli/tests/repl_eval.rs index 62efefc23d..8b38bb343a 100644 --- a/cli/tests/repl_eval.rs +++ b/cli/tests/repl_eval.rs @@ -4,11 +4,9 @@ extern crate pretty_assertions; #[macro_use] extern crate indoc; -mod helpers; - #[cfg(test)] mod repl_eval { - use crate::helpers; + use roc_cli::helpers; use roc_gen::run_roc::RocCallResult; #[test] From c213ad1909f73aa228888ad681492e1bb9fa9b39 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Mon, 17 May 2021 19:44:03 +0200 Subject: [PATCH 002/496] github actions setup for benchmarks --- .github/workflows/benchmarks.yml | 24 ++++++++++++++++++++++++ Earthfile | 8 ++++++++ 2 files changed, 32 insertions(+) create mode 100644 .github/workflows/benchmarks.yml diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml new file mode 100644 index 0000000000..e171418e23 --- /dev/null +++ b/.github/workflows/benchmarks.yml @@ -0,0 +1,24 @@ +on: [pull_request] + +name: Benchmarks + +env: + RUST_BACKTRACE: 1 + +jobs: + prep-dependency-container: + name: cd cli; cargo criterion + runs-on: [self-hosted, i7-6700K] + timeout-minutes: 60 + env: + FORCE_COLOR: 1 + steps: + - uses: actions/checkout@v2 + with: + clean: "true" + + - name: Earthly version + run: earthly --version + + - name: install dependencies, build, cd cli, cargo criterion + run: earthly +bench-roc diff --git a/Earthfile b/Earthfile index 8d7be65f9e..efbedf6151 100644 --- a/Earthfile +++ b/Earthfile @@ -38,6 +38,8 @@ install-zig-llvm-valgrind-clippy-rustfmt: RUN rustup component add clippy # rustfmt RUN rustup component add rustfmt + # criterion + RUN cargo install cargo-criterion # sccache RUN apt -y install libssl-dev RUN cargo install sccache @@ -108,4 +110,10 @@ test-all: BUILD +check-rustfmt BUILD +check-clippy BUILD +test-rust + +bench-roc: + FROM +copy-dirs-and-cache + RUN cargo criterion -V + RUN --mount=type=cache,target=$SCCACHE_DIR \ + cd cli && cargo criterion && sccache --show-stats From 8d0d1a0758310146559d4063a6a5c0b89038ad27 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Tue, 18 May 2021 18:48:59 +0200 Subject: [PATCH 003/496] put cli helpers in cli_utils crate, added bench_utils.rs for sharing functions between benchmarks, added iai benchmarks --- .github/workflows/benchmarks.yml | 2 +- Cargo.lock | 25 +++++ Cargo.toml | 1 + Earthfile | 2 +- cli/Cargo.toml | 8 +- cli/benches/instructions_bench.rs | 45 ++++++++ cli/benches/time_bench.rs | 33 ++++++ cli/cli_utils/Cargo.toml | 23 ++++ .../src/bench_utils.rs} | 102 ++++++++---------- cli/{ => cli_utils}/src/helpers.rs | 2 +- cli/cli_utils/src/lib.rs | 3 + cli/src/lib.rs | 1 - cli/tests/cli_run.rs | 2 +- cli/tests/repl_eval.rs | 2 +- 14 files changed, 184 insertions(+), 67 deletions(-) create mode 100644 cli/benches/instructions_bench.rs create mode 100644 cli/benches/time_bench.rs create mode 100644 cli/cli_utils/Cargo.toml rename cli/{benches/main_benchmark.rs => cli_utils/src/bench_utils.rs} (55%) rename cli/{ => cli_utils}/src/helpers.rs (99%) create mode 100644 cli/cli_utils/src/lib.rs diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index e171418e23..ba2dd023df 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -20,5 +20,5 @@ jobs: - name: Earthly version run: earthly --version - - name: install dependencies, build, cd cli, cargo criterion + - name: install dependencies, build, cd cli, benchmark with iai and criterion run: earthly +bench-roc diff --git a/Cargo.lock b/Cargo.lock index ac69320050..2613d2456e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -374,6 +374,23 @@ dependencies = [ "syn 1.0.65", ] +[[package]] +name = "cli_utils" +version = "0.1.0" +dependencies = [ + "bumpalo", + "criterion", + "inlinable_string", + "roc_cli", + "roc_collections", + "roc_load", + "roc_module", + "serde", + "serde-xml-rs", + "strip-ansi-escapes", + "tempfile", +] + [[package]] name = "clipboard-win" version = "3.1.1" @@ -1439,6 +1456,12 @@ version = "2.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4" +[[package]] +name = "iai" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "71a816c97c42258aa5834d07590b718b4c9a598944cd39a52dc25b351185d678" + [[package]] name = "ident_case" version = "1.0.1" @@ -2916,8 +2939,10 @@ version = "0.1.0" dependencies = [ "bumpalo", "clap 3.0.0-beta.1", + "cli_utils", "const_format", "criterion", + "iai", "im 14.3.0", "im-rc 14.3.0", "indoc 0.3.6", diff --git a/Cargo.toml b/Cargo.toml index 8343f413ed..15bc576eb2 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -25,6 +25,7 @@ members = [ "vendor/pretty", "editor", "cli", + "cli/cli_utils", "roc_std", "docs" ] diff --git a/Earthfile b/Earthfile index efbedf6151..540078a429 100644 --- a/Earthfile +++ b/Earthfile @@ -115,5 +115,5 @@ bench-roc: FROM +copy-dirs-and-cache RUN cargo criterion -V RUN --mount=type=cache,target=$SCCACHE_DIR \ - cd cli && cargo criterion && sccache --show-stats + cd cli && cargo bench instructions_bench && cargo criterion --bench time_bench && sccache --show-stats diff --git a/cli/Cargo.toml b/cli/Cargo.toml index 71d905321c..c653a54fda 100644 --- a/cli/Cargo.toml +++ b/cli/Cargo.toml @@ -95,7 +95,13 @@ quickcheck_macros = "0.8" serial_test = "0.5" tempfile = "3.1.0" criterion = "0.3.4" +cli_utils = { path = "cli_utils" } +iai = "0.1" [[bench]] -name = "main_benchmark" +name = "time_bench" +harness = false + +[[bench]] +name = "instructions_bench" harness = false diff --git a/cli/benches/instructions_bench.rs b/cli/benches/instructions_bench.rs new file mode 100644 index 0000000000..630a04115a --- /dev/null +++ b/cli/benches/instructions_bench.rs @@ -0,0 +1,45 @@ +use cli_utils::bench_utils::{bench_astar, bench_base64, bench_cfold, bench_closure, bench_deriv, bench_nqueens, bench_rbtree, bench_rbtree_delete}; + +fn bench_nqueens_iai() { + bench_nqueens(None); +} + +fn bench_cfold_iai() { + bench_cfold(None); +} + +fn bench_deriv_iai() { + bench_deriv(None); +} + +fn bench_rbtree_iai() { + bench_rbtree(None); +} + +fn bench_rbtree_delete_iai() { + bench_rbtree_delete(None); +} + +fn bench_astar_iai() { + bench_astar(None); +} + +fn bench_base64_iai() { + bench_base64(None); +} + +fn bench_closure_iai() { + bench_closure(None); +} + + +iai::main!( + bench_nqueens_iai, + bench_cfold_iai, + bench_deriv_iai, + bench_rbtree_iai, + bench_rbtree_delete_iai, + bench_astar_iai, + bench_base64_iai, + bench_closure_iai, +); diff --git a/cli/benches/time_bench.rs b/cli/benches/time_bench.rs new file mode 100644 index 0000000000..8d149e8530 --- /dev/null +++ b/cli/benches/time_bench.rs @@ -0,0 +1,33 @@ +use cli_utils::bench_utils::{ + bench_astar, bench_base64, bench_cfold, bench_closure, bench_deriv, bench_nqueens, + bench_rbtree, bench_rbtree_delete, +}; +use criterion::{ + criterion_group, criterion_main, measurement::WallTime, BenchmarkGroup, Criterion, SamplingMode, +}; + +fn bench_group_sample_100(c: &mut Criterion) { + let mut group = c.benchmark_group("bench-group-sample-100-unoptimized"); + // calculate statistics based on a fixed(flat) 100 runs + group.sampling_mode(SamplingMode::Flat); + + let bench_funcs: Vec>) -> ()> = vec![ + bench_nqueens, + bench_cfold, + bench_deriv, + bench_rbtree, + bench_rbtree_delete, + bench_astar, + bench_base64, + bench_closure, + ]; + + for bench_func in bench_funcs.iter() { + bench_func(Some(&mut group)) + } + + group.finish(); +} + +criterion_group!(benches, bench_group_sample_100); +criterion_main!(benches); diff --git a/cli/cli_utils/Cargo.toml b/cli/cli_utils/Cargo.toml new file mode 100644 index 0000000000..e9974ca680 --- /dev/null +++ b/cli/cli_utils/Cargo.toml @@ -0,0 +1,23 @@ +[package] +name = "cli_utils" +version = "0.1.0" +authors = ["The Roc Contributors"] +license = "UPL-1.0" +repository = "https://github.com/rtfeldman/roc" +edition = "2018" +description = "Shared code for cli tests and benchmarks" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +roc_cli = { path = "../../cli" } +roc_collections = { path = "../../compiler/collections" } +roc_load = { path = "../../compiler/load" } +roc_module = { path = "../../compiler/module" } +bumpalo = { version = "3.6.1", features = ["collections"] } +criterion = "0.3.4" +inlinable_string = "0.1" +serde = { version = "1.0", features = ["derive"] } +serde-xml-rs = "0.4" +strip-ansi-escapes = "0.1" +tempfile = "3.1.0" diff --git a/cli/benches/main_benchmark.rs b/cli/cli_utils/src/bench_utils.rs similarity index 55% rename from cli/benches/main_benchmark.rs rename to cli/cli_utils/src/bench_utils.rs index 60ff7e4b97..c8f549ac51 100644 --- a/cli/benches/main_benchmark.rs +++ b/cli/cli_utils/src/bench_utils.rs @@ -1,8 +1,7 @@ use criterion::{ - black_box, criterion_group, criterion_main, measurement::WallTime, BenchmarkGroup, Criterion, - SamplingMode, + black_box, measurement::WallTime, BenchmarkGroup }; -use roc_cli::helpers::{example_file, run_cmd, run_roc}; +use crate::helpers::{example_file, run_cmd, run_roc}; use std::path::Path; // run without optimization, without input @@ -10,7 +9,7 @@ fn exec_bench_simple( file: &Path, executable_filename: &str, expected_ending: &str, - bench_group: &mut BenchmarkGroup, + bench_group_opt: Option<&mut BenchmarkGroup>, ) { exec_benchmark( file, @@ -18,7 +17,7 @@ fn exec_bench_simple( executable_filename, expected_ending, false, - bench_group, + bench_group_opt, ) } @@ -28,7 +27,7 @@ fn exec_benchmark( executable_filename: &str, expected_ending: &str, run_optimized: bool, - bench_group: &mut BenchmarkGroup, + bench_group_opt: Option<&mut BenchmarkGroup>, ) { let flags: &[&str] = if run_optimized { &["--optimize"] } else { &[] }; @@ -46,7 +45,7 @@ fn exec_benchmark( check_cmd_output(file, stdin_str, executable_filename, expected_ending); - bench_cmd(file, stdin_str, executable_filename, bench_group); + bench_cmd(file, stdin_str, executable_filename, bench_group_opt); } fn check_cmd_output( @@ -74,113 +73,96 @@ fn bench_cmd( file: &Path, stdin_str: &str, executable_filename: &str, - bench_group: &mut BenchmarkGroup, + bench_group_opt: Option<&mut BenchmarkGroup>, ) { - bench_group.bench_function(&format!("Benchmarking {:?}", executable_filename), |b| { - b.iter(|| { - run_cmd( - black_box(file.with_file_name(executable_filename).to_str().unwrap()), - black_box(stdin_str), - &[], - ) - }) - }); + if let Some(bench_group) = bench_group_opt { + bench_group.bench_function(&format!("Benchmarking {:?}", executable_filename), |b| { + b.iter(|| { + run_cmd( + black_box(file.with_file_name(executable_filename).to_str().unwrap()), + black_box(stdin_str), + &[], + ) + }) + }); + } else { + run_cmd( + black_box(file.with_file_name(executable_filename).to_str().unwrap()), + black_box(stdin_str), + &[], + ); + } + } -fn bench_nqueens(bench_group: &mut BenchmarkGroup) { +pub fn bench_nqueens(bench_group_opt: Option<&mut BenchmarkGroup>) { exec_bench_simple( &example_file("benchmarks", "NQueens.roc"), "nqueens", "4\n", - bench_group, + bench_group_opt, ); } -fn bench_cfold(bench_group: &mut BenchmarkGroup) { +pub fn bench_cfold(bench_group_opt: Option<&mut BenchmarkGroup>) { exec_bench_simple( &example_file("benchmarks", "CFold.roc"), "cfold", "11 & 11\n", - bench_group, + bench_group_opt, ); } -fn bench_deriv(bench_group: &mut BenchmarkGroup) { +pub fn bench_deriv(bench_group_opt: Option<&mut BenchmarkGroup>) { exec_bench_simple( &example_file("benchmarks", "Deriv.roc"), "deriv", "1 count: 6\n2 count: 22\n", - bench_group, + bench_group_opt, ); } -fn bench_rbtree(bench_group: &mut BenchmarkGroup) { +pub fn bench_rbtree(bench_group_opt: Option<&mut BenchmarkGroup>) { exec_bench_simple( &example_file("benchmarks", "RBTreeInsert.roc"), "rbtree-insert", "Node Black 0 {} Empty Empty\n", - bench_group, + bench_group_opt, ); } -fn bench_rbtree_delete(bench_group: &mut BenchmarkGroup) { +pub fn bench_rbtree_delete(bench_group_opt: Option<&mut BenchmarkGroup>) { exec_bench_simple( &example_file("benchmarks", "RBTreeDel.roc"), "rbtree-del", "30\n", - bench_group, + bench_group_opt, ); } -fn bench_astar(bench_group: &mut BenchmarkGroup) { +pub fn bench_astar(bench_group_opt: Option<&mut BenchmarkGroup>) { exec_bench_simple( &example_file("benchmarks", "TestAStar.roc"), "test-astar", "True\n", - bench_group, + bench_group_opt, ); } -fn bench_base64(bench_group: &mut BenchmarkGroup) { +pub fn bench_base64(bench_group_opt: Option<&mut BenchmarkGroup>) { exec_bench_simple( &example_file("benchmarks", "TestBase64.roc"), "test-base64", "encoded: SGVsbG8gV29ybGQ=\ndecoded: Hello World\n", - bench_group, + bench_group_opt, ); } -fn bench_closure(bench_group: &mut BenchmarkGroup) { +pub fn bench_closure(bench_group_opt: Option<&mut BenchmarkGroup>) { exec_bench_simple( &example_file("benchmarks", "Closure.roc"), "closure", "", - bench_group, + bench_group_opt, ); -} - -fn bench_group_sample_100(c: &mut Criterion) { - let mut group = c.benchmark_group("bench-group-sample-100-unoptimized"); - // calculate statistics based on a fixed(flat) 100 runs - group.sampling_mode(SamplingMode::Flat); - - let bench_funcs: Vec) -> ()> = vec![ - bench_nqueens, - bench_cfold, - bench_deriv, - bench_rbtree, - bench_rbtree_delete, - bench_astar, - bench_base64, - bench_closure, - ]; - - for bench_func in bench_funcs.iter() { - bench_func(&mut group) - } - - group.finish(); -} - -criterion_group!(benches, bench_group_sample_100); -criterion_main!(benches); +} \ No newline at end of file diff --git a/cli/src/helpers.rs b/cli/cli_utils/src/helpers.rs similarity index 99% rename from cli/src/helpers.rs rename to cli/cli_utils/src/helpers.rs index ddadde6c73..6f45d89a68 100644 --- a/cli/src/helpers.rs +++ b/cli/cli_utils/src/helpers.rs @@ -5,7 +5,7 @@ extern crate roc_load; extern crate roc_module; extern crate tempfile; -use crate::repl::{INSTRUCTIONS, WELCOME_MESSAGE}; +use roc_cli::repl::{INSTRUCTIONS, WELCOME_MESSAGE}; use serde::Deserialize; use serde_xml_rs::from_str; use std::env; diff --git a/cli/cli_utils/src/lib.rs b/cli/cli_utils/src/lib.rs new file mode 100644 index 0000000000..0a023c7dd4 --- /dev/null +++ b/cli/cli_utils/src/lib.rs @@ -0,0 +1,3 @@ + +pub mod helpers; +pub mod bench_utils; diff --git a/cli/src/lib.rs b/cli/src/lib.rs index c38963d4dd..91948044c2 100644 --- a/cli/src/lib.rs +++ b/cli/src/lib.rs @@ -15,7 +15,6 @@ use std::process::Command; use target_lexicon::Triple; pub mod build; -pub mod helpers; pub mod repl; pub const CMD_RUN: &str = "run"; diff --git a/cli/tests/cli_run.rs b/cli/tests/cli_run.rs index d7f081ba04..671af1f47f 100644 --- a/cli/tests/cli_run.rs +++ b/cli/tests/cli_run.rs @@ -9,7 +9,7 @@ extern crate roc_module; #[cfg(test)] mod cli_run { - use roc_cli::helpers::{ + use cli_utils::helpers::{ example_file, extract_valgrind_errors, fixture_file, run_cmd, run_roc, run_with_valgrind, ValgrindError, ValgrindErrorXWhat, }; diff --git a/cli/tests/repl_eval.rs b/cli/tests/repl_eval.rs index 8b38bb343a..5c88e66d99 100644 --- a/cli/tests/repl_eval.rs +++ b/cli/tests/repl_eval.rs @@ -6,7 +6,7 @@ extern crate indoc; #[cfg(test)] mod repl_eval { - use roc_cli::helpers; + use cli_utils::helpers; use roc_gen::run_roc::RocCallResult; #[test] From 38f08e33ce975c16c6c142edac29d1113fed6a8e Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Tue, 18 May 2021 18:50:52 +0200 Subject: [PATCH 004/496] fmt --- cli/benches/instructions_bench.rs | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/cli/benches/instructions_bench.rs b/cli/benches/instructions_bench.rs index 630a04115a..1c92f41eab 100644 --- a/cli/benches/instructions_bench.rs +++ b/cli/benches/instructions_bench.rs @@ -1,4 +1,7 @@ -use cli_utils::bench_utils::{bench_astar, bench_base64, bench_cfold, bench_closure, bench_deriv, bench_nqueens, bench_rbtree, bench_rbtree_delete}; +use cli_utils::bench_utils::{ + bench_astar, bench_base64, bench_cfold, bench_closure, bench_deriv, bench_nqueens, + bench_rbtree, bench_rbtree_delete, +}; fn bench_nqueens_iai() { bench_nqueens(None); @@ -32,7 +35,6 @@ fn bench_closure_iai() { bench_closure(None); } - iai::main!( bench_nqueens_iai, bench_cfold_iai, From 07ad061ac03ed8fa41ba8aa73c362290b5682b86 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Wed, 19 May 2021 14:32:59 +0200 Subject: [PATCH 005/496] fixed iai benchmarks --- .github/workflows/benchmarks.yml | 2 +- Earthfile | 3 ++- cli/cli_utils/src/bench_utils.rs | 7 ++----- cli/cli_utils/src/lib.rs | 3 +-- 4 files changed, 6 insertions(+), 9 deletions(-) diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index ba2dd023df..a57cc10ca0 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -21,4 +21,4 @@ jobs: run: earthly --version - name: install dependencies, build, cd cli, benchmark with iai and criterion - run: earthly +bench-roc + run: earthly --allow-privileged +bench-roc diff --git a/Earthfile b/Earthfile index 540078a429..09df7968cf 100644 --- a/Earthfile +++ b/Earthfile @@ -113,7 +113,8 @@ test-all: bench-roc: FROM +copy-dirs-and-cache + ENV RUST_BACKTRACE=full RUN cargo criterion -V - RUN --mount=type=cache,target=$SCCACHE_DIR \ + RUN --privileged --mount=type=cache,target=$SCCACHE_DIR \ cd cli && cargo bench instructions_bench && cargo criterion --bench time_bench && sccache --show-stats diff --git a/cli/cli_utils/src/bench_utils.rs b/cli/cli_utils/src/bench_utils.rs index c8f549ac51..ba83d2d62a 100644 --- a/cli/cli_utils/src/bench_utils.rs +++ b/cli/cli_utils/src/bench_utils.rs @@ -1,7 +1,5 @@ -use criterion::{ - black_box, measurement::WallTime, BenchmarkGroup -}; use crate::helpers::{example_file, run_cmd, run_roc}; +use criterion::{black_box, measurement::WallTime, BenchmarkGroup}; use std::path::Path; // run without optimization, without input @@ -92,7 +90,6 @@ fn bench_cmd( &[], ); } - } pub fn bench_nqueens(bench_group_opt: Option<&mut BenchmarkGroup>) { @@ -165,4 +162,4 @@ pub fn bench_closure(bench_group_opt: Option<&mut BenchmarkGroup>) { "", bench_group_opt, ); -} \ No newline at end of file +} diff --git a/cli/cli_utils/src/lib.rs b/cli/cli_utils/src/lib.rs index 0a023c7dd4..b5cded1f52 100644 --- a/cli/cli_utils/src/lib.rs +++ b/cli/cli_utils/src/lib.rs @@ -1,3 +1,2 @@ - -pub mod helpers; pub mod bench_utils; +pub mod helpers; From f6c04d66464350911f45e546ff8bc3020002cb51 Mon Sep 17 00:00:00 2001 From: Folkert Date: Fri, 21 May 2021 15:06:40 +0200 Subject: [PATCH 006/496] make strings const --- compiler/mono/src/alias_analysis.rs | 73 ++++++++++++++++++++++------- 1 file changed, 55 insertions(+), 18 deletions(-) diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index dac161ef04..5e7a32d7cd 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -1,10 +1,10 @@ use morphic_lib::TypeContext; use morphic_lib::{ - BlockExpr, BlockId, CalleeSpecVar, EntryPointName, ExprContext, FuncDef, FuncDefBuilder, - FuncName, ModDefBuilder, ModName, ProgramBuilder, Result, TypeId, TypeName, UpdateModeVar, - ValueId, + BlockExpr, BlockId, CalleeSpecVar, ConstDef, ConstDefBuilder, ConstName, EntryPointName, + ExprContext, FuncDef, FuncDefBuilder, FuncName, ModDefBuilder, ModName, ProgramBuilder, Result, + TypeId, TypeName, UpdateModeVar, ValueId, }; -use roc_collections::all::MutMap; +use roc_collections::all::{MutMap, MutSet}; use roc_module::low_level::LowLevel; use roc_module::symbol::Symbol; use std::convert::TryFrom; @@ -12,6 +12,8 @@ use std::convert::TryFrom; use crate::ir::{Call, CallType, Expr, Literal, ModifyRc, Proc, Stmt}; use crate::layout::{Builtin, Layout, ListLayout, UnionLayout}; +use bumpalo::Bump; + // just using one module for now const MOD_LIST: ModName = ModName(b"UserApp"); const MOD_APP: ModName = ModName(b"UserApp"); @@ -20,15 +22,22 @@ pub fn spec_program<'a, I>(procs: I) -> Result where I: Iterator>, { + let arena = Bump::new(); + let mut main_function = None; let main_module = { let mut m = ModDefBuilder::new(); for proc in procs { - let spec = proc_spec(proc)?; + let (spec, consts) = proc_spec(proc)?; m.add_func(FuncName(&proc.name.to_ne_bytes()), spec)?; + for (symbol, def) in consts { + let const_name = ConstName(arena.alloc(symbol.to_ne_bytes())); + m.add_const(const_name, def); + } + if format!("{:?}", proc.name).contains("mainForHost") { main_function = Some(proc.name); } @@ -52,7 +61,7 @@ where morphic_lib::solve(program) } -fn proc_spec(proc: &Proc) -> Result { +fn proc_spec(proc: &Proc) -> Result<(FuncDef, MutMap)> { let mut builder = FuncDefBuilder::new(); let mut env = Env::default(); @@ -72,13 +81,29 @@ fn proc_spec(proc: &Proc) -> Result { let root = BlockExpr(block, value_id); let arg_type_id = layout_spec(&mut builder, &Layout::Struct(&argument_layouts))?; let ret_type_id = layout_spec(&mut builder, &proc.ret_layout)?; - builder.build(arg_type_id, ret_type_id, root) + + let mut statics: MutMap = MutMap::default(); + + for symbol in env.statics { + let mut cbuilder = ConstDefBuilder::new(); + let str_type_id = str_type(&mut cbuilder)?; + let def = cbuilder.build(str_type_id, root)?; + + statics.insert(symbol, def); + } + + let spec = builder.build(arg_type_id, ret_type_id, root)?; + + Ok((spec, statics)) } +type Statics = MutSet; + #[derive(Default)] struct Env { symbols: MutMap, join_points: MutMap, + statics: Statics, } fn stmt_spec( @@ -92,7 +117,7 @@ fn stmt_spec( match stmt { Let(symbol, expr, layout, continuation) => { - let value_id = expr_spec(builder, env, block, layout, expr)?; + let value_id = expr_spec(builder, env, block, *symbol, layout, expr)?; env.symbols.insert(*symbol, value_id); let result = stmt_spec(builder, env, block, layout, continuation)?; env.symbols.remove(symbol); @@ -422,15 +447,16 @@ fn build_variant_types_help( fn expr_spec( builder: &mut FuncDefBuilder, - env: &Env, + env: &mut Env, block: BlockId, + lhs: Symbol, layout: &Layout, expr: &Expr, ) -> Result { use Expr::*; match expr { - Literal(literal) => literal_spec(builder, block, literal), + Literal(literal) => literal_spec(builder, &mut env.statics, block, lhs, literal), FunctionPointer(_, _) => todo!(), Call(call) => call_spec(builder, env, block, layout, call), Tag { @@ -515,13 +541,15 @@ fn expr_spec( fn literal_spec( builder: &mut FuncDefBuilder, + statics: &mut Statics, block: BlockId, + lhs: Symbol, literal: &Literal, ) -> Result { use Literal::*; match literal { - Str(_) => new_static_string(builder, block), + Str(_) => new_static_string(builder, statics, block, lhs), Int(_) | Float(_) | Bool(_) | Byte(_) => builder.add_make_tuple(block, &[]), } } @@ -567,6 +595,12 @@ fn builtin_spec(builder: &mut FuncDefBuilder, builtin: &Builtin) -> Result(builder: &mut TC) -> Result { + let cell_id = builder.add_heap_cell_type(); + let len_id = builder.add_tuple_type(&[])?; + builder.add_tuple_type(&[cell_id, len_id]) +} + // const OK_TAG_ID: u8 = 1u8; // const ERR_TAG_ID: u8 = 0u8; @@ -585,15 +619,18 @@ fn new_usize(builder: &mut FuncDefBuilder, block: BlockId) -> Result { new_num(builder, block) } -fn new_static_string(builder: &mut FuncDefBuilder, block: BlockId) -> Result { - let cell = builder.add_new_heap_cell(block)?; +fn new_static_string( + builder: &mut FuncDefBuilder, + statics: &mut Statics, + block: BlockId, + lhs: Symbol, +) -> Result { + let module = MOD_APP; + let const_name = ConstName(&lhs.to_ne_bytes()); - // immediately mutate the cell, so any future updates on this value are invalid - // updating a static string would cause a crash at runtime - let _ = builder.add_update(block, UpdateModeVar(&[]), cell)?; + statics.insert(lhs); - let length = new_usize(builder, block)?; - builder.add_make_tuple(block, &[cell, length]) + builder.add_const_ref(block, module, const_name) } fn new_order(builder: &mut FuncDefBuilder, block: BlockId) -> Result { From 630c1db5ef6032063eff773f8dff9157a15ac685 Mon Sep 17 00:00:00 2001 From: Folkert Date: Fri, 21 May 2021 15:20:00 +0200 Subject: [PATCH 007/496] fix ownership --- compiler/mono/src/alias_analysis.rs | 37 ++++++++++++++++++++--------- 1 file changed, 26 insertions(+), 11 deletions(-) diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 5e7a32d7cd..bfe37a316e 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -29,13 +29,13 @@ where let mut m = ModDefBuilder::new(); for proc in procs { - let (spec, consts) = proc_spec(proc)?; + let (spec, consts) = proc_spec(&arena, proc)?; m.add_func(FuncName(&proc.name.to_ne_bytes()), spec)?; for (symbol, def) in consts { let const_name = ConstName(arena.alloc(symbol.to_ne_bytes())); - m.add_const(const_name, def); + m.add_const(const_name, def)?; } if format!("{:?}", proc.name).contains("mainForHost") { @@ -61,9 +61,9 @@ where morphic_lib::solve(program) } -fn proc_spec(proc: &Proc) -> Result<(FuncDef, MutMap)> { +fn proc_spec(arena: &Bump, proc: &Proc) -> Result<(FuncDef, MutMap)> { let mut builder = FuncDefBuilder::new(); - let mut env = Env::default(); + let mut env = Env::new(arena); let block = builder.add_block(); @@ -99,13 +99,24 @@ fn proc_spec(proc: &Proc) -> Result<(FuncDef, MutMap)> { type Statics = MutSet; -#[derive(Default)] -struct Env { +struct Env<'a> { + arena: &'a Bump, symbols: MutMap, join_points: MutMap, statics: Statics, } +impl<'a> Env<'a> { + fn new(arena: &'a Bump) -> Self { + Env { + arena, + symbols: Default::default(), + join_points: Default::default(), + statics: Default::default(), + } + } +} + fn stmt_spec( builder: &mut FuncDefBuilder, env: &mut Env, @@ -117,7 +128,7 @@ fn stmt_spec( match stmt { Let(symbol, expr, layout, continuation) => { - let value_id = expr_spec(builder, env, block, *symbol, layout, expr)?; + let value_id = expr_spec(builder, env, block, symbol, layout, expr)?; env.symbols.insert(*symbol, value_id); let result = stmt_spec(builder, env, block, layout, continuation)?; env.symbols.remove(symbol); @@ -449,14 +460,16 @@ fn expr_spec( builder: &mut FuncDefBuilder, env: &mut Env, block: BlockId, - lhs: Symbol, + lhs: &Symbol, layout: &Layout, expr: &Expr, ) -> Result { use Expr::*; match expr { - Literal(literal) => literal_spec(builder, &mut env.statics, block, lhs, literal), + Literal(literal) => { + literal_spec(env.arena, builder, &mut env.statics, block, *lhs, literal) + } FunctionPointer(_, _) => todo!(), Call(call) => call_spec(builder, env, block, layout, call), Tag { @@ -540,6 +553,7 @@ fn expr_spec( } fn literal_spec( + arena: &Bump, builder: &mut FuncDefBuilder, statics: &mut Statics, block: BlockId, @@ -549,7 +563,7 @@ fn literal_spec( use Literal::*; match literal { - Str(_) => new_static_string(builder, statics, block, lhs), + Str(_) => new_static_string(arena, builder, statics, block, lhs), Int(_) | Float(_) | Bool(_) | Byte(_) => builder.add_make_tuple(block, &[]), } } @@ -620,13 +634,14 @@ fn new_usize(builder: &mut FuncDefBuilder, block: BlockId) -> Result { } fn new_static_string( + arena: &Bump, builder: &mut FuncDefBuilder, statics: &mut Statics, block: BlockId, lhs: Symbol, ) -> Result { let module = MOD_APP; - let const_name = ConstName(&lhs.to_ne_bytes()); + let const_name = ConstName(arena.alloc(lhs.to_ne_bytes())); statics.insert(lhs); From 2a61c3108edfccbdd4bd830e43b714bed8b5639d Mon Sep 17 00:00:00 2001 From: Folkert Date: Tue, 25 May 2021 09:08:01 +0200 Subject: [PATCH 008/496] start using the solutions --- Cargo.lock | 1 + compiler/load/Cargo.toml | 1 + compiler/load/src/file.rs | 37 ++++++++++++++++++++++------- compiler/mono/src/alias_analysis.rs | 8 +++++-- 4 files changed, 37 insertions(+), 10 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 30bfdff722..63d93d71c9 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3218,6 +3218,7 @@ dependencies = [ "indoc 0.3.6", "inlinable_string", "maplit", + "morphic_lib", "num_cpus", "parking_lot", "pretty_assertions 0.5.1", diff --git a/compiler/load/Cargo.toml b/compiler/load/Cargo.toml index 01d0a82f5b..6ed6e3cc63 100644 --- a/compiler/load/Cargo.toml +++ b/compiler/load/Cargo.toml @@ -19,6 +19,7 @@ roc_parse = { path = "../parse" } roc_solve = { path = "../solve" } roc_mono = { path = "../mono" } roc_reporting = { path = "../reporting" } +morphic_lib = { path = "../../vendor/morphic_lib" } ven_pretty = { path = "../../vendor/pretty" } bumpalo = { version = "3.6.1", features = ["collections"] } inlinable_string = "0.1" diff --git a/compiler/load/src/file.rs b/compiler/load/src/file.rs index 2b6f7a69bc..8d41d91932 100644 --- a/compiler/load/src/file.rs +++ b/compiler/load/src/file.rs @@ -706,6 +706,7 @@ pub struct MonomorphizedModule<'a> { pub type_problems: MutMap>, pub mono_problems: MutMap>, pub procedures: MutMap<(Symbol, TopLevelFunctionLayout<'a>), Proc<'a>>, + pub alias_analysis_solutions: AliasAnalysisSolutions, pub exposed_to_host: MutMap, pub header_sources: MutMap)>, pub sources: MutMap)>, @@ -863,6 +864,19 @@ struct State<'a> { pub layout_caches: std::vec::Vec>, pub procs: Procs<'a>, + + pub alias_analysis_solutions: AliasAnalysisSolutions, +} + +pub enum AliasAnalysisSolutions { + NotAvailable, + Available(morphic_lib::Solutions), +} + +impl std::fmt::Debug for AliasAnalysisSolutions { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "AliasAnalysisSolutions {{}}") + } } #[derive(Debug)] @@ -1472,6 +1486,7 @@ where specializations_in_flight: 0, layout_caches: std::vec::Vec::with_capacity(num_cpus::get()), procs: Procs::new_in(arena), + alias_analysis_solutions: AliasAnalysisSolutions::NotAvailable, }; // We've now distributed one worker queue to each thread. @@ -2061,14 +2076,6 @@ fn update<'a>( println!("{}", result); } - if false { - let it = state.procedures.iter().map(|x| x.1); - - if let Err(e) = roc_mono::alias_analysis::spec_program(it) { - println!("Error in alias analysis: {:?}", e) - } - } - Proc::insert_refcount_operations(arena, &mut state.procedures); Proc::optimize_refcount_operations( @@ -2078,6 +2085,18 @@ fn update<'a>( &mut state.procedures, ); + if true { + let it = state.procedures.iter().map(|x| x.1); + + match roc_mono::alias_analysis::spec_program(it) { + Err(e) => panic!("Error in alias analysis: {:?}", e), + Ok(solutions) => { + state.alias_analysis_solutions = + AliasAnalysisSolutions::Available(solutions) + } + } + } + state.constrained_ident_ids.insert(module_id, ident_ids); for (module_id, requested) in external_specializations_requested { @@ -2157,6 +2176,7 @@ fn finish_specialization( let State { procedures, + alias_analysis_solutions, module_cache, output_path, platform_path, @@ -2218,6 +2238,7 @@ fn finish_specialization( subs, interns, procedures, + alias_analysis_solutions, sources, header_sources, timings: state.timings, diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index b2f8a96389..6bb080066c 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -16,7 +16,7 @@ use bumpalo::Bump; // just using one module for now const MOD_LIST: ModName = ModName(b"UserApp"); -const MOD_APP: ModName = ModName(b"UserApp"); +pub const MOD_APP: ModName = ModName(b"UserApp"); pub fn spec_program<'a, I>(procs: I) -> Result where @@ -182,7 +182,7 @@ fn stmt_spec( } Ret(symbol) => Ok(env.symbols[symbol]), Refcounting(modify_rc, continuation) => match modify_rc { - ModifyRc::Inc(symbol, _) | ModifyRc::Dec(symbol) | ModifyRc::DecRef(symbol) => { + ModifyRc::Inc(symbol, _) | ModifyRc::Dec(symbol) => { let result_type = builder.add_tuple_type(&[])?; let argument = env.symbols[symbol]; @@ -191,6 +191,10 @@ fn stmt_spec( stmt_spec(builder, env, block, layout, continuation) } + ModifyRc::DecRef(_symbol) => { + // TODO a decref is a non-recursive decrement of a structure + stmt_spec(builder, env, block, layout, continuation) + } }, Join { id, From 1d7fa5bab44ec076ef5a45c61a5f3d21469eb173 Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 26 May 2021 13:39:55 +0200 Subject: [PATCH 009/496] remove TODOs --- compiler/mono/src/alias_analysis.rs | 76 +++++++++++++++++++---------- 1 file changed, 51 insertions(+), 25 deletions(-) diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 6bb080066c..f4529c0ec5 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -2,7 +2,7 @@ use morphic_lib::TypeContext; use morphic_lib::{ BlockExpr, BlockId, CalleeSpecVar, ConstDef, ConstDefBuilder, ConstName, EntryPointName, ExprContext, FuncDef, FuncDefBuilder, FuncName, ModDefBuilder, ModName, ProgramBuilder, Result, - TypeId, TypeName, UpdateModeVar, ValueId, + TypeId, UpdateModeVar, ValueId, }; use roc_collections::all::{MutMap, MutSet}; use roc_module::low_level::LowLevel; @@ -15,7 +15,6 @@ use crate::layout::{Builtin, Layout, ListLayout, UnionLayout}; use bumpalo::Bump; // just using one module for now -const MOD_LIST: ModName = ModName(b"UserApp"); pub const MOD_APP: ModName = ModName(b"UserApp"); pub fn spec_program<'a, I>(procs: I) -> Result @@ -337,7 +336,18 @@ fn call_spec( *update_mode, call.arguments, ), - HigherOrderLowLevel { .. } => todo!(), + HigherOrderLowLevel { .. } => { + // TODO overly pessimstic + let arguments: Vec<_> = call + .arguments + .iter() + .map(|symbol| env.symbols[symbol]) + .collect(); + + let result_type = layout_spec(builder, layout)?; + + builder.add_unknown_with(block, &arguments, result_type) + } } } @@ -384,9 +394,8 @@ fn lowlevel_spec( Eq | NotEq => new_bool(builder, block), NumLte | NumLt | NumGt | NumGte => new_order(builder, block), ListLen => { - let list = env.symbols[&arguments[0]]; - - builder.add_get_tuple_field(block, list, LIST_LEN_INDEX) + // just dream up a unit value + builder.add_make_tuple(block, &[]) } ListGetUnsafe => { // NOTE the ListGet lowlevel op is only evaluated if the index is in-bounds @@ -412,7 +421,14 @@ fn lowlevel_spec( Ok(list) } - other => todo!("lowlevel op not implemented: {:?}", other), + _other => { + // TODO overly pessimstic + let arguments: Vec<_> = arguments.iter().map(|symbol| env.symbols[symbol]).collect(); + + let result_type = layout_spec(builder, layout)?; + + builder.add_unknown_with(block, &arguments, result_type) + } } } @@ -589,18 +605,34 @@ fn builtin_spec(builder: &mut FuncDefBuilder, builtin: &Builtin) -> Result builder.add_tuple_type(&[]), - Float128 => todo!(), - Float64 => todo!(), - Float32 => todo!(), - Float16 => todo!(), - Str => todo!(), - Dict(_, _) => todo!(), - Set(_) => todo!(), - List(_, _) => { - // TODO should incorporate the element type into the name - Ok(builder.add_named_type(MOD_LIST, TypeName(b"List"))) + Float128 | Float64 | Float32 | Float16 => builder.add_tuple_type(&[]), + Str | EmptyStr => str_type(builder), + Dict(key_layout, value_layout) => { + let value_type = layout_spec(builder, value_layout)?; + let key_type = layout_spec(builder, key_layout)?; + let element_type = builder.add_tuple_type(&[key_type, value_type])?; + + let cell = builder.add_heap_cell_type(); + let bag = builder.add_bag_type(element_type)?; + builder.add_tuple_type(&[cell, bag]) + } + Set(value_layout) => { + let value_type = layout_spec(builder, value_layout)?; + let key_type = builder.add_tuple_type(&[])?; + let element_type = builder.add_tuple_type(&[key_type, value_type])?; + + let cell = builder.add_heap_cell_type(); + let bag = builder.add_bag_type(element_type)?; + builder.add_tuple_type(&[cell, bag]) + } + List(_, element_layout) => { + let element_type = layout_spec(builder, element_layout)?; + + let cell = builder.add_heap_cell_type(); + let bag = builder.add_bag_type(element_type)?; + + builder.add_tuple_type(&[cell, bag]) } - EmptyStr => todo!(), EmptyList => todo!(), EmptyDict => todo!(), EmptySet => todo!(), @@ -618,17 +650,11 @@ fn str_type(builder: &mut TC) -> Result { const LIST_CELL_INDEX: u32 = 0; const LIST_BAG_INDEX: u32 = 1; -const LIST_LEN_INDEX: u32 = 2; fn new_list(builder: &mut FuncDefBuilder, block: BlockId, element_type: TypeId) -> Result { let cell = builder.add_new_heap_cell(block)?; let bag = builder.add_empty_bag(block, element_type)?; - let length = new_usize(builder, block)?; - builder.add_make_tuple(block, &[cell, bag, length]) -} - -fn new_usize(builder: &mut FuncDefBuilder, block: BlockId) -> Result { - new_num(builder, block) + builder.add_make_tuple(block, &[cell, bag]) } fn new_static_string( From b04b9ab7293362b57a183dcafa518ee268e6451a Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 26 May 2021 13:41:11 +0200 Subject: [PATCH 010/496] disable AA --- compiler/load/src/file.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/load/src/file.rs b/compiler/load/src/file.rs index 687b9c364d..cf9ff87acc 100644 --- a/compiler/load/src/file.rs +++ b/compiler/load/src/file.rs @@ -2085,7 +2085,7 @@ fn update<'a>( &mut state.procedures, ); - if true { + if false { let it = state.procedures.iter().map(|x| x.1); match roc_mono::alias_analysis::spec_program(it) { From ca5e9518d9b55c28ef48419df88446e4973342e4 Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 26 May 2021 14:12:53 +0200 Subject: [PATCH 011/496] remove PhantomEmptyStruct --- cli/src/repl/eval.rs | 6 ------ compiler/gen/src/llvm/build.rs | 1 - compiler/gen/src/llvm/build_hash.rs | 5 ----- compiler/gen/src/llvm/compare.rs | 10 ---------- compiler/gen/src/llvm/convert.rs | 1 - compiler/gen/src/llvm/refcounting.rs | 2 -- compiler/mono/src/alias_analysis.rs | 1 - compiler/mono/src/layout.rs | 13 +------------ 8 files changed, 1 insertion(+), 38 deletions(-) diff --git a/cli/src/repl/eval.rs b/cli/src/repl/eval.rs index 94f51ec6cf..1f16b2dcca 100644 --- a/cli/src/repl/eval.rs +++ b/cli/src/repl/eval.rs @@ -125,12 +125,6 @@ fn jit_to_ast_help<'a>( Layout::Builtin(other) => { todo!("add support for rendering builtin {:?} to the REPL", other) } - Layout::PhantomEmptyStruct => Ok(run_jit_function!(lib, main_fn_name, &u8, |_| { - Expr::Record { - fields: &[], - final_comments: env.arena.alloc([]), - } - })), Layout::Struct(field_layouts) => { let ptr_to_ast = |ptr: *const u8| match content { Content::Structure(FlatType::Record(fields, _)) => { diff --git a/compiler/gen/src/llvm/build.rs b/compiler/gen/src/llvm/build.rs index c1a0006844..92b587acf4 100644 --- a/compiler/gen/src/llvm/build.rs +++ b/compiler/gen/src/llvm/build.rs @@ -3360,7 +3360,6 @@ pub fn build_proc<'a, 'ctx, 'env>( } Layout::Builtin(_) => {} - Layout::PhantomEmptyStruct => {} Layout::Struct(_) => {} Layout::Union(_) => {} Layout::RecursivePointer => {} diff --git a/compiler/gen/src/llvm/build_hash.rs b/compiler/gen/src/llvm/build_hash.rs index 95db536a88..9dafe0cb2f 100644 --- a/compiler/gen/src/llvm/build_hash.rs +++ b/compiler/gen/src/llvm/build_hash.rs @@ -56,11 +56,6 @@ fn build_hash_layout<'a, 'ctx, 'env>( val.into_struct_value(), ), - Layout::PhantomEmptyStruct => { - // just does nothing and returns the seed - seed - } - Layout::Union(union_layout) => { build_hash_tag(env, layout_ids, layout, union_layout, seed, val) } diff --git a/compiler/gen/src/llvm/compare.rs b/compiler/gen/src/llvm/compare.rs index 0cf32263d0..bd4381fd0c 100644 --- a/compiler/gen/src/llvm/compare.rs +++ b/compiler/gen/src/llvm/compare.rs @@ -159,11 +159,6 @@ fn build_eq<'a, 'ctx, 'env>( rhs_val, ), - Layout::PhantomEmptyStruct => { - // always equal to itself - env.context.bool_type().const_int(1, false).into() - } - Layout::RecursivePointer => match when_recursive { WhenRecursive::Unreachable => { unreachable!("recursion pointers should never be compared directly") @@ -338,11 +333,6 @@ fn build_neq<'a, 'ctx, 'env>( result.into() } - Layout::PhantomEmptyStruct => { - // always equal to itself - env.context.bool_type().const_int(1, false).into() - } - Layout::RecursivePointer => { unreachable!("recursion pointers should never be compared directly") } diff --git a/compiler/gen/src/llvm/convert.rs b/compiler/gen/src/llvm/convert.rs index 29e874c992..a88c0ce7f5 100644 --- a/compiler/gen/src/llvm/convert.rs +++ b/compiler/gen/src/llvm/convert.rs @@ -115,7 +115,6 @@ pub fn basic_type_from_layout<'a, 'ctx, 'env>( Pointer(layout) => basic_type_from_layout(env, &layout) .ptr_type(AddressSpace::Generic) .into(), - PhantomEmptyStruct => env.context.struct_type(&[], false).into(), Struct(sorted_fields) => basic_type_from_record(env, sorted_fields), Union(variant) => { use UnionLayout::*; diff --git a/compiler/gen/src/llvm/refcounting.rs b/compiler/gen/src/llvm/refcounting.rs index cf0a254163..494df692b0 100644 --- a/compiler/gen/src/llvm/refcounting.rs +++ b/compiler/gen/src/llvm/refcounting.rs @@ -724,8 +724,6 @@ fn modify_refcount_layout_build_function<'a, 'ctx, 'env>( Some(function) } - PhantomEmptyStruct => None, - Layout::RecursivePointer => match when_recursive { WhenRecursive::Unreachable => { unreachable!("recursion pointers should never be hashed directly") diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index ebca28d1a5..0fb36ae318 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -525,7 +525,6 @@ fn layout_spec(builder: &mut FuncDefBuilder, layout: &Layout) -> Result match layout { Builtin(builtin) => builtin_spec(builder, builtin), - PhantomEmptyStruct => todo!(), Struct(fields) => build_tuple_type(builder, fields), Union(union_layout) => { let variant_types = build_variant_types_help(builder, union_layout)?; diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index 37f8669418..7877894c8a 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -36,7 +36,6 @@ pub enum Layout<'a> { /// A layout that is empty (turns into the empty struct in LLVM IR /// but for our purposes, not zero-sized, so it does not get dropped from data structures /// this is important for closures that capture zero-sized values - PhantomEmptyStruct, Struct(&'a [Layout<'a>]), Union(UnionLayout<'a>), RecursivePointer, @@ -479,7 +478,6 @@ impl<'a> Layout<'a> { match self { Builtin(builtin) => builtin.safe_to_memcpy(), - PhantomEmptyStruct => true, Struct(fields) => fields .iter() .all(|field_layout| field_layout.safe_to_memcpy()), @@ -519,12 +517,7 @@ impl<'a> Layout<'a> { // For this calculation, we don't need an accurate // stack size, we just need to know whether it's zero, // so it's fine to use a pointer size of 1. - if let Layout::PhantomEmptyStruct = self { - false - } else { - // self.stack_size(1) == 0 - false - } + false } pub fn stack_size(&self, pointer_size: u32) -> u32 { @@ -532,7 +525,6 @@ impl<'a> Layout<'a> { match self { Builtin(builtin) => builtin.stack_size(pointer_size), - PhantomEmptyStruct => 0, Struct(fields) => { let mut sum = 0; @@ -596,7 +588,6 @@ impl<'a> Layout<'a> { } } Layout::Builtin(builtin) => builtin.alignment_bytes(pointer_size), - Layout::PhantomEmptyStruct => 0, Layout::RecursivePointer => pointer_size, Layout::FunctionPointer(_, _) => pointer_size, Layout::Pointer(_) => pointer_size, @@ -636,7 +627,6 @@ impl<'a> Layout<'a> { match self { Builtin(builtin) => builtin.is_refcounted(), - PhantomEmptyStruct => false, Struct(fields) => fields.iter().any(|f| f.contains_refcounted()), Union(variant) => { use UnionLayout::*; @@ -669,7 +659,6 @@ impl<'a> Layout<'a> { match self { Builtin(builtin) => builtin.to_doc(alloc, parens), - PhantomEmptyStruct => alloc.text("{}"), Struct(fields) => { let fields_doc = fields.iter().map(|x| x.to_doc(alloc, parens)); From bfe49d2188a4a56f636dffee311fc3b2c6170667 Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 26 May 2021 14:18:19 +0200 Subject: [PATCH 012/496] remove Pointer --- cli/src/repl/eval.rs | 1 - compiler/gen/src/llvm/build.rs | 1 - compiler/gen/src/llvm/build_hash.rs | 4 ---- compiler/gen/src/llvm/compare.rs | 8 -------- compiler/gen/src/llvm/convert.rs | 3 --- compiler/gen/src/llvm/refcounting.rs | 2 +- compiler/mono/src/alias_analysis.rs | 1 - compiler/mono/src/layout.rs | 10 +--------- 8 files changed, 2 insertions(+), 28 deletions(-) diff --git a/cli/src/repl/eval.rs b/cli/src/repl/eval.rs index 1f16b2dcca..0c363dfa3b 100644 --- a/cli/src/repl/eval.rs +++ b/cli/src/repl/eval.rs @@ -241,7 +241,6 @@ fn jit_to_ast_help<'a>( Layout::Closure(_, _, _) => Err(ToAstProblem::FunctionLayout), Layout::FunctionPointer(_, _) => Err(ToAstProblem::FunctionLayout), - Layout::Pointer(_) => todo!("add support for rendering pointers in the REPL"), } } diff --git a/compiler/gen/src/llvm/build.rs b/compiler/gen/src/llvm/build.rs index 92b587acf4..03e96b035b 100644 --- a/compiler/gen/src/llvm/build.rs +++ b/compiler/gen/src/llvm/build.rs @@ -3363,7 +3363,6 @@ pub fn build_proc<'a, 'ctx, 'env>( Layout::Struct(_) => {} Layout::Union(_) => {} Layout::RecursivePointer => {} - Layout::Pointer(_) => {} } } } diff --git a/compiler/gen/src/llvm/build_hash.rs b/compiler/gen/src/llvm/build_hash.rs index 9dafe0cb2f..dab6eee5db 100644 --- a/compiler/gen/src/llvm/build_hash.rs +++ b/compiler/gen/src/llvm/build_hash.rs @@ -86,10 +86,6 @@ fn build_hash_layout<'a, 'ctx, 'env>( } }, - Layout::Pointer(_) => { - unreachable!("unused") - } - Layout::FunctionPointer(_, _) | Layout::Closure(_, _, _) => { unreachable!("the type system will guarantee these are never hashed") } diff --git a/compiler/gen/src/llvm/compare.rs b/compiler/gen/src/llvm/compare.rs index bd4381fd0c..62ff98d1c7 100644 --- a/compiler/gen/src/llvm/compare.rs +++ b/compiler/gen/src/llvm/compare.rs @@ -192,10 +192,6 @@ fn build_eq<'a, 'ctx, 'env>( } }, - Layout::Pointer(_) => { - unreachable!("unused") - } - Layout::FunctionPointer(_, _) | Layout::Closure(_, _, _) => { unreachable!("the type system will guarantee these are never compared") } @@ -337,10 +333,6 @@ fn build_neq<'a, 'ctx, 'env>( unreachable!("recursion pointers should never be compared directly") } - Layout::Pointer(_) => { - unreachable!("unused") - } - Layout::FunctionPointer(_, _) | Layout::Closure(_, _, _) => { unreachable!("the type system will guarantee these are never compared") } diff --git a/compiler/gen/src/llvm/convert.rs b/compiler/gen/src/llvm/convert.rs index a88c0ce7f5..5a1589b6b5 100644 --- a/compiler/gen/src/llvm/convert.rs +++ b/compiler/gen/src/llvm/convert.rs @@ -112,9 +112,6 @@ pub fn basic_type_from_layout<'a, 'ctx, 'env>( let closure_data_layout = closure_layout.runtime_representation(); basic_type_from_layout(env, &closure_data_layout) } - Pointer(layout) => basic_type_from_layout(env, &layout) - .ptr_type(AddressSpace::Generic) - .into(), Struct(sorted_fields) => basic_type_from_record(env, sorted_fields), Union(variant) => { use UnionLayout::*; diff --git a/compiler/gen/src/llvm/refcounting.rs b/compiler/gen/src/llvm/refcounting.rs index 494df692b0..05a85b0886 100644 --- a/compiler/gen/src/llvm/refcounting.rs +++ b/compiler/gen/src/llvm/refcounting.rs @@ -744,7 +744,7 @@ fn modify_refcount_layout_build_function<'a, 'ctx, 'env>( } }, - FunctionPointer(_, _) | Pointer(_) => None, + FunctionPointer(_, _) => None, } } diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 0fb36ae318..4283de8ab3 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -533,7 +533,6 @@ fn layout_spec(builder: &mut FuncDefBuilder, layout: &Layout) -> Result RecursivePointer => todo!(), FunctionPointer(_, _) => todo!(), Closure(_, _, _) => todo!(), - Pointer(_) => todo!(), } } diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index 7877894c8a..31094cf0d0 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -42,7 +42,6 @@ pub enum Layout<'a> { /// A function. The types of its arguments, then the type of its return value. FunctionPointer(&'a [Layout<'a>], &'a Layout<'a>), Closure(&'a [Layout<'a>], LambdaSet<'a>, &'a Layout<'a>), - Pointer(&'a Layout<'a>), } impl<'a> Layout<'a> { @@ -502,10 +501,6 @@ impl<'a> Layout<'a> { true } Closure(_, closure_layout, _) => closure_layout.safe_to_memcpy(), - Pointer(_) => { - // We cannot memcpy pointers, because then we would have the same pointer in multiple places! - false - } RecursivePointer => { // We cannot memcpy pointers, because then we would have the same pointer in multiple places! false @@ -558,7 +553,6 @@ impl<'a> Layout<'a> { Closure(_, lambda_set, _) => lambda_set.stack_size(pointer_size), FunctionPointer(_, _) => pointer_size, RecursivePointer => pointer_size, - Pointer(_) => pointer_size, } } @@ -590,7 +584,6 @@ impl<'a> Layout<'a> { Layout::Builtin(builtin) => builtin.alignment_bytes(pointer_size), Layout::RecursivePointer => pointer_size, Layout::FunctionPointer(_, _) => pointer_size, - Layout::Pointer(_) => pointer_size, Layout::Closure(_, captured, _) => { pointer_size.max(captured.alignment_bytes(pointer_size)) } @@ -645,7 +638,7 @@ impl<'a> Layout<'a> { } RecursivePointer => true, Closure(_, closure_layout, _) => closure_layout.contains_refcounted(), - FunctionPointer(_, _) | Pointer(_) => false, + FunctionPointer(_, _) => false, } } @@ -691,7 +684,6 @@ impl<'a> Layout<'a> { .append(" |} -> ") .append(result.to_doc(alloc, Parens::InFunction)) } - Pointer(_) => todo!(), } } } From e2b200b84fcbeef829ca39fbc740d4834e4293a8 Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 26 May 2021 14:28:56 +0200 Subject: [PATCH 013/496] simplify list layout --- cli/src/repl/eval.rs | 4 +-- compiler/gen/src/llvm/build.rs | 46 ++++++++++++++-------------- compiler/gen/src/llvm/build_hash.rs | 2 +- compiler/gen/src/llvm/build_list.rs | 18 ++++------- compiler/gen/src/llvm/compare.rs | 4 +-- compiler/gen/src/llvm/convert.rs | 2 +- compiler/gen/src/llvm/refcounting.rs | 28 ++++++++--------- compiler/mono/src/alias_analysis.rs | 2 +- compiler/mono/src/ir.rs | 13 +++----- compiler/mono/src/layout.rs | 36 ++++++---------------- 10 files changed, 62 insertions(+), 93 deletions(-) diff --git a/cli/src/repl/eval.rs b/cli/src/repl/eval.rs index 0c363dfa3b..21304feab9 100644 --- a/cli/src/repl/eval.rs +++ b/cli/src/repl/eval.rs @@ -116,7 +116,7 @@ fn jit_to_ast_help<'a>( } })) } - Layout::Builtin(Builtin::List(_, elem_layout)) => Ok(run_jit_function!( + Layout::Builtin(Builtin::List(elem_layout)) => Ok(run_jit_function!( lib, main_fn_name, (*const u8, usize), @@ -291,7 +291,7 @@ fn ptr_to_ast<'a>( items: &[], final_comments: &[], }, - Layout::Builtin(Builtin::List(_, elem_layout)) => { + Layout::Builtin(Builtin::List(elem_layout)) => { // Turn the (ptr, len) wrapper struct into actual ptr and len values. let len = unsafe { *(ptr.offset(env.ptr_bytes as isize) as *const usize) }; let ptr = unsafe { *(ptr as *const *const u8) }; diff --git a/compiler/gen/src/llvm/build.rs b/compiler/gen/src/llvm/build.rs index 03e96b035b..b78962208a 100644 --- a/compiler/gen/src/llvm/build.rs +++ b/compiler/gen/src/llvm/build.rs @@ -2180,7 +2180,7 @@ pub fn build_exp_stmt<'a, 'ctx, 'env>( let (value, layout) = load_symbol_and_layout(scope, symbol); match layout { - Layout::Builtin(Builtin::List(_, _)) => { + Layout::Builtin(Builtin::List(_)) => { debug_assert!(value.is_struct_value()); // because of how we insert DECREF for lists, we can't guarantee that @@ -3585,7 +3585,7 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>( match list_layout { Layout::Builtin(Builtin::EmptyList) => default, - Layout::Builtin(Builtin::List(_, element_layout)) => { + Layout::Builtin(Builtin::List(element_layout)) => { let argument_layouts = &[**element_layout, *default_layout]; let roc_function_call = roc_function_call( @@ -3627,8 +3627,8 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>( match (list_layout, return_layout) { (Layout::Builtin(Builtin::EmptyList), _) => empty_list(env), ( - Layout::Builtin(Builtin::List(_, element_layout)), - Layout::Builtin(Builtin::List(_, result_layout)), + Layout::Builtin(Builtin::List(element_layout)), + Layout::Builtin(Builtin::List(result_layout)), ) => { let argument_layouts = &[**element_layout]; @@ -3658,9 +3658,9 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>( match (list1_layout, list2_layout, return_layout) { ( - Layout::Builtin(Builtin::List(_, element1_layout)), - Layout::Builtin(Builtin::List(_, element2_layout)), - Layout::Builtin(Builtin::List(_, result_layout)), + Layout::Builtin(Builtin::List(element1_layout)), + Layout::Builtin(Builtin::List(element2_layout)), + Layout::Builtin(Builtin::List(result_layout)), ) => { let argument_layouts = &[**element1_layout, **element2_layout]; @@ -3702,10 +3702,10 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>( match (list1_layout, list2_layout, list3_layout, return_layout) { ( - Layout::Builtin(Builtin::List(_, element1_layout)), - Layout::Builtin(Builtin::List(_, element2_layout)), - Layout::Builtin(Builtin::List(_, element3_layout)), - Layout::Builtin(Builtin::List(_, result_layout)), + Layout::Builtin(Builtin::List(element1_layout)), + Layout::Builtin(Builtin::List(element2_layout)), + Layout::Builtin(Builtin::List(element3_layout)), + Layout::Builtin(Builtin::List(result_layout)), ) => { let argument_layouts = &[**element1_layout, **element2_layout, **element3_layout]; @@ -3752,8 +3752,8 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>( match (list_layout, return_layout) { (Layout::Builtin(Builtin::EmptyList), _) => empty_list(env), ( - Layout::Builtin(Builtin::List(_, element_layout)), - Layout::Builtin(Builtin::List(_, result_layout)), + Layout::Builtin(Builtin::List(element_layout)), + Layout::Builtin(Builtin::List(result_layout)), ) => { let argument_layouts = &[Layout::Builtin(Builtin::Usize), **element_layout]; @@ -3784,7 +3784,7 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>( match list_layout { Layout::Builtin(Builtin::EmptyList) => empty_list(env), - Layout::Builtin(Builtin::List(_, element_layout)) => { + Layout::Builtin(Builtin::List(element_layout)) => { let argument_layouts = &[**element_layout]; let roc_function_call = roc_function_call( @@ -3816,8 +3816,8 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>( (_, Layout::Builtin(Builtin::EmptyList)) | (Layout::Builtin(Builtin::EmptyList), _) => empty_list(env), ( - Layout::Builtin(Builtin::List(_, before_layout)), - Layout::Builtin(Builtin::List(_, after_layout)), + Layout::Builtin(Builtin::List(before_layout)), + Layout::Builtin(Builtin::List(after_layout)), ) => { let argument_layouts = &[**before_layout]; @@ -3860,8 +3860,8 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>( (_, Layout::Builtin(Builtin::EmptyList)) | (Layout::Builtin(Builtin::EmptyList), _) => empty_list(env), ( - Layout::Builtin(Builtin::List(_, before_layout)), - Layout::Builtin(Builtin::List(_, after_layout)), + Layout::Builtin(Builtin::List(before_layout)), + Layout::Builtin(Builtin::List(after_layout)), ) => { let argument_layouts = &[**before_layout]; @@ -3911,7 +3911,7 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>( match list_layout { Layout::Builtin(Builtin::EmptyList) => empty_list(env), - Layout::Builtin(Builtin::List(_, element_layout)) => { + Layout::Builtin(Builtin::List(element_layout)) => { use crate::llvm::bitcode::build_compare_wrapper; let argument_layouts = &[**element_layout, **element_layout]; @@ -4179,7 +4179,7 @@ fn run_low_level<'a, 'ctx, 'env>( match list_layout { Layout::Builtin(Builtin::EmptyList) => empty_list(env), - Layout::Builtin(Builtin::List(_, element_layout)) => list_drop( + Layout::Builtin(Builtin::List(element_layout)) => list_drop( env, layout_ids, original_wrapper, @@ -4448,7 +4448,7 @@ fn run_low_level<'a, 'ctx, 'env>( // no elements, so nothing to remove empty_list(env) } - Layout::Builtin(Builtin::List(_, element_layout)) => list_set( + Layout::Builtin(Builtin::List(element_layout)) => list_set( env, layout_ids, list, @@ -4469,7 +4469,7 @@ fn run_low_level<'a, 'ctx, 'env>( // no elements, so nothing to remove empty_list(env) } - Layout::Builtin(Builtin::List(_, element_layout)) => list_set( + Layout::Builtin(Builtin::List(element_layout)) => list_set( env, layout_ids, list, @@ -4646,7 +4646,7 @@ fn run_low_level<'a, 'ctx, 'env>( match list_layout { Layout::Builtin(Builtin::EmptyList) => dict_empty(env), - Layout::Builtin(Builtin::List(_, key_layout)) => { + Layout::Builtin(Builtin::List(key_layout)) => { set_from_list(env, layout_ids, list, key_layout) } _ => unreachable!("invalid dict layout"), diff --git a/compiler/gen/src/llvm/build_hash.rs b/compiler/gen/src/llvm/build_hash.rs index dab6eee5db..195ff1f30e 100644 --- a/compiler/gen/src/llvm/build_hash.rs +++ b/compiler/gen/src/llvm/build_hash.rs @@ -148,7 +148,7 @@ fn hash_builtin<'a, 'ctx, 'env>( Builtin::Set(_) => { todo!("Implement Hash for Set") } - Builtin::List(_, element_layout) => build_hash_list( + Builtin::List(element_layout) => build_hash_list( env, layout_ids, layout, diff --git a/compiler/gen/src/llvm/build_list.rs b/compiler/gen/src/llvm/build_list.rs index f71e4a507a..5a7fea02c9 100644 --- a/compiler/gen/src/llvm/build_list.rs +++ b/compiler/gen/src/llvm/build_list.rs @@ -14,7 +14,7 @@ use inkwell::types::{BasicTypeEnum, PointerType}; use inkwell::values::{BasicValueEnum, FunctionValue, IntValue, PointerValue, StructValue}; use inkwell::{AddressSpace, IntPredicate}; use roc_builtins::bitcode; -use roc_mono::layout::{Builtin, InPlace, Layout, LayoutIds, MemoryMode}; +use roc_mono::layout::{Builtin, InPlace, Layout, LayoutIds}; fn list_returned_from_zig<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, @@ -196,12 +196,12 @@ pub fn list_join<'a, 'ctx, 'env>( ) -> BasicValueEnum<'ctx> { match outer_list_layout { Layout::Builtin(Builtin::EmptyList) - | Layout::Builtin(Builtin::List(_, Layout::Builtin(Builtin::EmptyList))) => { + | Layout::Builtin(Builtin::List(Layout::Builtin(Builtin::EmptyList))) => { // If the input list is empty, or if it is a list of empty lists // then simply return an empty list empty_list(env) } - Layout::Builtin(Builtin::List(_, Layout::Builtin(Builtin::List(_, element_layout)))) => { + Layout::Builtin(Builtin::List(Layout::Builtin(Builtin::List(element_layout)))) => { call_bitcode_fn_returns_list( env, &[ @@ -231,13 +231,7 @@ pub fn list_reverse<'a, 'ctx, 'env>( // this pointer will never actually be dereferenced Layout::Builtin(Builtin::Int64), ), - Layout::Builtin(Builtin::List(memory_mode, elem_layout)) => ( - match memory_mode { - MemoryMode::Unique => InPlace::InPlace, - MemoryMode::Refcounted => InPlace::Clone, - }, - *elem_layout, - ), + Layout::Builtin(Builtin::List(elem_layout)) => (InPlace::Clone, *elem_layout), _ => unreachable!("Invalid layout {:?} in List.reverse", list_layout), }; @@ -264,7 +258,7 @@ pub fn list_get_unsafe<'a, 'ctx, 'env>( let builder = env.builder; match list_layout { - Layout::Builtin(Builtin::List(_, elem_layout)) => { + Layout::Builtin(Builtin::List(elem_layout)) => { let elem_type = basic_type_from_layout(env, elem_layout); let ptr_type = get_ptr_type(&elem_type, AddressSpace::Generic); // Load the pointer to the array data @@ -861,7 +855,7 @@ pub fn list_concat<'a, 'ctx, 'env>( // then simply return an empty list empty_list(env) } - Layout::Builtin(Builtin::List(_, elem_layout)) => call_bitcode_fn_returns_list( + Layout::Builtin(Builtin::List(elem_layout)) => call_bitcode_fn_returns_list( env, &[ pass_list_as_i128(env, first_list), diff --git a/compiler/gen/src/llvm/compare.rs b/compiler/gen/src/llvm/compare.rs index 62ff98d1c7..7f9cf127dd 100644 --- a/compiler/gen/src/llvm/compare.rs +++ b/compiler/gen/src/llvm/compare.rs @@ -99,7 +99,7 @@ fn build_eq_builtin<'a, 'ctx, 'env>( Builtin::Float16 => float_cmp(FloatPredicate::OEQ, "eq_f16"), Builtin::Str => str_equal(env, lhs_val, rhs_val), - Builtin::List(_, elem) => build_list_eq( + Builtin::List(elem) => build_list_eq( env, layout_ids, &Layout::Builtin(*builtin), @@ -249,7 +249,7 @@ fn build_neq_builtin<'a, 'ctx, 'env>( result.into() } - Builtin::List(_, elem) => { + Builtin::List(elem) => { let is_equal = build_list_eq( env, layout_ids, diff --git a/compiler/gen/src/llvm/convert.rs b/compiler/gen/src/llvm/convert.rs index 5a1589b6b5..c88c12c18b 100644 --- a/compiler/gen/src/llvm/convert.rs +++ b/compiler/gen/src/llvm/convert.rs @@ -170,7 +170,7 @@ pub fn basic_type_from_builtin<'a, 'ctx, 'env>( Float16 => context.f16_type().as_basic_type_enum(), Dict(_, _) | EmptyDict => zig_dict_type(env).into(), Set(_) | EmptySet => zig_dict_type(env).into(), - List(_, _) | EmptyList => zig_list_type(env).into(), + List(_) | EmptyList => zig_list_type(env).into(), Str | EmptyStr => zig_str_type(env).into(), } } diff --git a/compiler/gen/src/llvm/refcounting.rs b/compiler/gen/src/llvm/refcounting.rs index 05a85b0886..71c309f8b4 100644 --- a/compiler/gen/src/llvm/refcounting.rs +++ b/compiler/gen/src/llvm/refcounting.rs @@ -15,7 +15,7 @@ use inkwell::values::{BasicValueEnum, FunctionValue, IntValue, PointerValue, Str use inkwell::{AddressSpace, IntPredicate}; use roc_module::symbol::Interns; use roc_module::symbol::Symbol; -use roc_mono::layout::{Builtin, Layout, LayoutIds, MemoryMode, UnionLayout}; +use roc_mono::layout::{Builtin, Layout, LayoutIds, UnionLayout}; pub const REFCOUNT_MAX: usize = 0_usize; @@ -469,21 +469,17 @@ fn modify_refcount_builtin<'a, 'ctx, 'env>( use Builtin::*; match builtin { - List(memory_mode, element_layout) => { - if let MemoryMode::Refcounted = memory_mode { - let function = modify_refcount_list( - env, - layout_ids, - mode, - when_recursive, - layout, - element_layout, - ); + List(element_layout) => { + let function = modify_refcount_list( + env, + layout_ids, + mode, + when_recursive, + layout, + element_layout, + ); - Some(function) - } else { - None - } + Some(function) } Set(element_layout) => { let key_layout = &Layout::Struct(&[]); @@ -1687,7 +1683,7 @@ pub fn refcount_offset<'a, 'ctx, 'env>(env: &Env<'a, 'ctx, 'env>, layout: &Layou let value_bytes = layout.stack_size(env.ptr_bytes) as u64; match layout { - Layout::Builtin(Builtin::List(_, _)) => env.ptr_bytes as u64, + Layout::Builtin(Builtin::List(_)) => env.ptr_bytes as u64, Layout::Builtin(Builtin::Str) => env.ptr_bytes as u64, Layout::RecursivePointer | Layout::Union(_) => env.ptr_bytes as u64, _ => (env.ptr_bytes as u64).max(value_bytes), diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 4283de8ab3..958030f9f9 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -548,7 +548,7 @@ fn builtin_spec(builder: &mut FuncDefBuilder, builtin: &Builtin) -> Result todo!(), Dict(_, _) => todo!(), Set(_) => todo!(), - List(_, _) => { + List(_) => { // TODO should incorporate the element type into the name Ok(builder.add_named_type(MOD_LIST, TypeName(b"List"))) } diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index cbf8649aaf..7b9ab8757f 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -3,8 +3,8 @@ use self::InProgressProc::*; use crate::exhaustive::{Ctor, Guard, RenderAs, TagId}; use crate::layout::{ - Builtin, ClosureRepresentation, LambdaSet, Layout, LayoutCache, LayoutProblem, MemoryMode, - UnionLayout, WrappedVariant, TAG_SIZE, + Builtin, ClosureRepresentation, LambdaSet, Layout, LayoutCache, LayoutProblem, UnionLayout, + WrappedVariant, TAG_SIZE, }; use bumpalo::collections::Vec; use bumpalo::Bump; @@ -3364,10 +3364,7 @@ pub fn with_hole<'a>( Stmt::Let( assigned, expr, - Layout::Builtin(Builtin::List( - MemoryMode::Refcounted, - env.arena.alloc(elem_layout), - )), + Layout::Builtin(Builtin::List(env.arena.alloc(elem_layout))), hole, ) } @@ -3399,12 +3396,10 @@ pub fn with_hole<'a>( elems: arg_symbols, }; - let mode = MemoryMode::Refcounted; - let stmt = Stmt::Let( assigned, expr, - Layout::Builtin(Builtin::List(mode, env.arena.alloc(elem_layout))), + Layout::Builtin(Builtin::List(env.arena.alloc(elem_layout))), hole, ); diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index 31094cf0d0..ba6034ecab 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -48,10 +48,7 @@ impl<'a> Layout<'a> { pub fn in_place(&self) -> InPlace { match self { Layout::Builtin(Builtin::EmptyList) => InPlace::InPlace, - Layout::Builtin(Builtin::List(memory_mode, _)) => match memory_mode { - MemoryMode::Unique => InPlace::InPlace, - MemoryMode::Refcounted => InPlace::Clone, - }, + Layout::Builtin(Builtin::List(_)) => InPlace::Clone, Layout::Builtin(Builtin::EmptyStr) => InPlace::InPlace, Layout::Builtin(Builtin::Str) => InPlace::Clone, Layout::Builtin(Builtin::Int1) => InPlace::Clone, @@ -331,12 +328,6 @@ impl<'a> LambdaSet<'a> { } } -#[derive(Clone, Debug, PartialEq, Eq, Hash, Copy)] -pub enum MemoryMode { - Unique, - Refcounted, -} - #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub enum Builtin<'a> { Int128, @@ -353,7 +344,7 @@ pub enum Builtin<'a> { Str, Dict(&'a Layout<'a>, &'a Layout<'a>), Set(&'a Layout<'a>), - List(MemoryMode, &'a Layout<'a>), + List(&'a Layout<'a>), EmptyStr, EmptyList, EmptyDict, @@ -606,7 +597,7 @@ impl<'a> Layout<'a> { RecursivePointer => true, - Builtin(List(MemoryMode::Refcounted, _)) | Builtin(Str) => true, + Builtin(List(_)) | Builtin(Str) => true, _ => false, } @@ -855,7 +846,7 @@ impl<'a> Builtin<'a> { Str | EmptyStr => Builtin::STR_WORDS * pointer_size, Dict(_, _) | EmptyDict => Builtin::DICT_WORDS * pointer_size, Set(_) | EmptySet => Builtin::SET_WORDS * pointer_size, - List(_, _) | EmptyList => Builtin::LIST_WORDS * pointer_size, + List(_) | EmptyList => Builtin::LIST_WORDS * pointer_size, } } @@ -881,7 +872,7 @@ impl<'a> Builtin<'a> { Str | EmptyStr => pointer_size, Dict(_, _) | EmptyDict => pointer_size, Set(_) | EmptySet => pointer_size, - List(_, _) | EmptyList => pointer_size, + List(_) | EmptyList => pointer_size, } } @@ -891,7 +882,7 @@ impl<'a> Builtin<'a> { match self { Int128 | Int64 | Int32 | Int16 | Int8 | Int1 | Usize | Float128 | Float64 | Float32 | Float16 | EmptyStr | EmptyDict | EmptyList | EmptySet => true, - Str | Dict(_, _) | Set(_) | List(_, _) => false, + Str | Dict(_, _) | Set(_) | List(_) => false, } } @@ -902,10 +893,7 @@ impl<'a> Builtin<'a> { match self { Int128 | Int64 | Int32 | Int16 | Int8 | Int1 | Usize | Float128 | Float64 | Float32 | Float16 | EmptyStr | EmptyDict | EmptyList | EmptySet => false, - List(mode, element_layout) => match mode { - MemoryMode::Refcounted => true, - MemoryMode::Unique => element_layout.contains_refcounted(), - }, + List(_) => true, Str | Dict(_, _) | Set(_) => true, } @@ -938,7 +926,7 @@ impl<'a> Builtin<'a> { EmptySet => alloc.text("EmptySet"), Str => alloc.text("Str"), - List(_, layout) => alloc + List(layout) => alloc .text("List ") .append(layout.to_doc(alloc, Parens::InTypeParam)), Set(layout) => alloc @@ -1878,11 +1866,7 @@ pub fn list_layout_from_elem<'a>( _ => { let elem_layout = Layout::from_var(env, elem_var)?; - // This is a normal list. - Ok(Layout::Builtin(Builtin::List( - MemoryMode::Refcounted, - env.arena.alloc(elem_layout), - ))) + Ok(Layout::Builtin(Builtin::List(env.arena.alloc(elem_layout)))) } } } @@ -1948,7 +1932,7 @@ impl<'a> std::convert::TryFrom<&Layout<'a>> for ListLayout<'a> { fn try_from(value: &Layout<'a>) -> Result { match value { Layout::Builtin(Builtin::EmptyList) => Ok(ListLayout::EmptyList), - Layout::Builtin(Builtin::List(_, element)) => Ok(ListLayout::List(element)), + Layout::Builtin(Builtin::List(element)) => Ok(ListLayout::List(element)), _ => Err(()), } } From 06b2beb7caa7dfb2b622502d1a2645573a764f94 Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 26 May 2021 18:31:55 +0200 Subject: [PATCH 014/496] tags have a union layout --- compiler/gen/src/llvm/build.rs | 20 ++++++------- compiler/mono/src/alias_analysis.rs | 14 ++------- compiler/mono/src/ir.rs | 44 ++++++++++++++++------------- 3 files changed, 34 insertions(+), 44 deletions(-) diff --git a/compiler/gen/src/llvm/build.rs b/compiler/gen/src/llvm/build.rs index b78962208a..c5e9cdd7c8 100644 --- a/compiler/gen/src/llvm/build.rs +++ b/compiler/gen/src/llvm/build.rs @@ -906,9 +906,7 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( arguments, tag_layout, .. - } if *union_size == 1 - && matches!(tag_layout, Layout::Union(UnionLayout::NonRecursive(_))) => - { + } if *union_size == 1 && matches!(tag_layout, UnionLayout::NonRecursive(_)) => { let it = arguments.iter(); let ctx = env.context; @@ -956,7 +954,7 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( Tag { arguments, - tag_layout: Layout::Union(UnionLayout::NonRecursive(fields)), + tag_layout: UnionLayout::NonRecursive(fields), union_size, tag_id, .. @@ -1044,7 +1042,7 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( } Tag { arguments, - tag_layout: Layout::Union(UnionLayout::Recursive(fields)), + tag_layout: UnionLayout::Recursive(fields), union_size, tag_id, .. @@ -1119,7 +1117,7 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( Tag { arguments, - tag_layout: Layout::Union(UnionLayout::NonNullableUnwrapped(fields)), + tag_layout: UnionLayout::NonNullableUnwrapped(fields), union_size, tag_id, .. @@ -1195,10 +1193,10 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( Tag { arguments, tag_layout: - Layout::Union(UnionLayout::NullableWrapped { + UnionLayout::NullableWrapped { nullable_id, other_tags: fields, - }), + }, union_size, tag_id, .. @@ -1287,11 +1285,11 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( Tag { arguments, tag_layout: - Layout::Union(UnionLayout::NullableUnwrapped { + UnionLayout::NullableUnwrapped { nullable_id, other_fields, .. - }), + }, union_size, tag_id, tag_name, @@ -1387,8 +1385,6 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( data_ptr.into() } - Tag { .. } => unreachable!("tags should have a Union or RecursiveUnion layout"), - Reset(_) => todo!(), Reuse { .. } => todo!(), diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 958030f9f9..dd3590e57c 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -377,16 +377,6 @@ fn lowlevel_spec( } fn build_variant_types( - builder: &mut FuncDefBuilder, - layout: &Layout, -) -> Option>> { - match layout { - Layout::Union(union_layout) => Some(build_variant_types_help(builder, union_layout)), - _ => None, - } -} - -fn build_variant_types_help( builder: &mut FuncDefBuilder, union_layout: &UnionLayout, ) -> Result> { @@ -435,7 +425,7 @@ fn expr_spec( arguments, } => { let value_id = build_tuple_value(builder, env, block, arguments)?; - let variant_types = build_variant_types(builder, tag_layout).unwrap()?; + let variant_types = build_variant_types(builder, tag_layout)?; builder.add_make_union(block, &variant_types, *tag_id as u32, value_id) } Struct(fields) => build_tuple_value(builder, env, block, fields), @@ -527,7 +517,7 @@ fn layout_spec(builder: &mut FuncDefBuilder, layout: &Layout) -> Result Builtin(builtin) => builtin_spec(builder, builtin), Struct(fields) => build_tuple_type(builder, fields), Union(union_layout) => { - let variant_types = build_variant_types_help(builder, union_layout)?; + let variant_types = build_variant_types(builder, union_layout)?; builder.add_union_type(&variant_types) } RecursivePointer => todo!(), diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 7b9ab8757f..b02f741623 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -1143,7 +1143,7 @@ pub enum Expr<'a> { Call(Call<'a>), Tag { - tag_layout: Layout<'a>, + tag_layout: UnionLayout<'a>, tag_name: TagName, tag_id: u8, union_size: u8, @@ -4128,10 +4128,15 @@ fn construct_closure_data<'a>( tag_symbols.push(tag_id_symbol); tag_symbols.extend(symbols); + let tag_layout = match lambda_set.runtime_representation() { + Layout::Union(inner) => inner, + _ => unreachable!(), + }; + let expr1 = Expr::Literal(Literal::Int(tag_id as i128)); let expr2 = Expr::Tag { tag_id, - tag_layout: lambda_set.runtime_representation(), + tag_layout, union_size, tag_name, arguments: tag_symbols.into_bump_slice(), @@ -4293,17 +4298,17 @@ fn convert_tag_union<'a>( } debug_assert!(layouts.len() > 1); - let layout = Layout::Union(UnionLayout::Recursive(layouts.into_bump_slice())); + let union_layout = UnionLayout::Recursive(layouts.into_bump_slice()); let tag = Expr::Tag { - tag_layout: layout, + tag_layout: union_layout, tag_name, tag_id: tag_id as u8, union_size, arguments: field_symbols, }; - (tag, layout) + (tag, Layout::Union(union_layout)) } NonNullableUnwrapped { fields, @@ -4321,17 +4326,17 @@ fn convert_tag_union<'a>( temp.into_bump_slice() }; - let layout = Layout::Union(UnionLayout::NonNullableUnwrapped(fields)); + let union_layout = UnionLayout::NonNullableUnwrapped(fields); let tag = Expr::Tag { - tag_layout: layout, + tag_layout: union_layout, tag_name, tag_id: tag_id as u8, union_size, arguments: field_symbols, }; - (tag, layout) + (tag, Layout::Union(union_layout)) } NonRecursive { sorted_tag_layouts } => { let tag_id_symbol = env.unique_symbol(); @@ -4353,18 +4358,17 @@ fn convert_tag_union<'a>( layouts.push(arg_layouts); } - let layout = - Layout::Union(UnionLayout::NonRecursive(layouts.into_bump_slice())); + let union_layout = UnionLayout::NonRecursive(layouts.into_bump_slice()); let tag = Expr::Tag { - tag_layout: layout, + tag_layout: union_layout, tag_name, tag_id: tag_id as u8, union_size, arguments: field_symbols, }; - (tag, layout) + (tag, Layout::Union(union_layout)) } NullableWrapped { nullable_id, @@ -4390,20 +4394,20 @@ fn convert_tag_union<'a>( layouts.push(arg_layouts); } - let layout = Layout::Union(UnionLayout::NullableWrapped { + let union_layout = UnionLayout::NullableWrapped { nullable_id, other_tags: layouts.into_bump_slice(), - }); + }; let tag = Expr::Tag { - tag_layout: layout, + tag_layout: union_layout, tag_name, tag_id: tag_id as u8, union_size, arguments: field_symbols, }; - (tag, layout) + (tag, Layout::Union(union_layout)) } NullableUnwrapped { nullable_id, @@ -4425,20 +4429,20 @@ fn convert_tag_union<'a>( temp.into_bump_slice() }; - let layout = Layout::Union(UnionLayout::NullableUnwrapped { + let union_layout = UnionLayout::NullableUnwrapped { nullable_id, other_fields, - }); + }; let tag = Expr::Tag { - tag_layout: layout, + tag_layout: union_layout, tag_name, tag_id: tag_id as u8, union_size, arguments: field_symbols, }; - (tag, layout) + (tag, Layout::Union(union_layout)) } }; From 6db9247509167db0f677bfc05a7fd7789881701b Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Wed, 26 May 2021 19:51:18 +0200 Subject: [PATCH 015/496] setup for all benchmarks except quicksort --- Cargo.lock | 232 ++++++++++++++++++++++-------- cli/Cargo.toml | 4 +- cli/benches/events_bench.rs | 96 +++++++++++++ cli/benches/instructions_bench.rs | 47 ------ cli/benches/time_bench.rs | 25 ++-- cli/cli_utils/src/bench_utils.rs | 63 +++----- cli/tests/cli_run.rs | 2 +- examples/benchmarks/CFold.roc | 2 +- examples/benchmarks/Deriv.roc | 2 +- examples/benchmarks/NQueens.roc | 8 +- examples/benchmarks/RBTreeCk.roc | 2 +- examples/benchmarks/RBTreeDel.roc | 2 +- 12 files changed, 312 insertions(+), 173 deletions(-) create mode 100644 cli/benches/events_bench.rs delete mode 100644 cli/benches/instructions_bench.rs diff --git a/Cargo.lock b/Cargo.lock index 2613d2456e..28b2f84ced 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -45,7 +45,7 @@ checksum = "7f200cbb1e856866d9eade941cf3aa0c5d7dd36f74311c4273b494f4ef036957" dependencies = [ "getrandom 0.2.2", "once_cell", - "version_check", + "version_check 0.9.3", ] [[package]] @@ -135,7 +135,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8" dependencies = [ "hermit-abi", - "libc", + "libc 0.2.93", "winapi 0.3.9", ] @@ -159,7 +159,7 @@ checksum = "9d117600f438b1707d4e4ae15d3595657288f8235a0eb593e80ecc98ab34e1bc" dependencies = [ "addr2line", "cfg-if 1.0.0", - "libc", + "libc 0.2.93", "miniz_oxide", "object 0.23.0", "rustc-demangle", @@ -180,6 +180,12 @@ version = "0.6.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb" +[[package]] +name = "bit_field" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dcb6dd1c2376d2e096796e234a70e17e94cc2d5d54ff8ce42b28cef1d0d359a4" + [[package]] name = "bitflags" version = "1.2.1" @@ -422,7 +428,7 @@ dependencies = [ "core-foundation 0.9.1", "core-graphics 0.22.2", "foreign-types", - "libc", + "libc 0.2.93", "objc", ] @@ -437,7 +443,7 @@ dependencies = [ "core-foundation 0.9.1", "core-graphics-types", "foreign-types", - "libc", + "libc 0.2.93", "objc", ] @@ -509,7 +515,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "57d24c7a13c43e870e37c1556b74555437870a04514f7685f5b354e090567171" dependencies = [ "core-foundation-sys 0.7.0", - "libc", + "libc 0.2.93", ] [[package]] @@ -519,7 +525,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0a89e2ae426ea83155dccf10c0fa6b1463ef6d5fcb44cee0b224a408fa640a62" dependencies = [ "core-foundation-sys 0.8.2", - "libc", + "libc 0.2.93", ] [[package]] @@ -543,7 +549,7 @@ dependencies = [ "bitflags", "core-foundation 0.7.0", "foreign-types", - "libc", + "libc 0.2.93", ] [[package]] @@ -556,7 +562,7 @@ dependencies = [ "core-foundation 0.9.1", "core-graphics-types", "foreign-types", - "libc", + "libc 0.2.93", ] [[package]] @@ -568,7 +574,7 @@ dependencies = [ "bitflags", "core-foundation 0.9.1", "foreign-types", - "libc", + "libc 0.2.93", ] [[package]] @@ -580,7 +586,7 @@ dependencies = [ "cfg-if 0.1.10", "core-foundation-sys 0.7.0", "core-graphics 0.19.2", - "libc", + "libc 0.2.93", "objc", ] @@ -619,6 +625,16 @@ dependencies = [ "walkdir", ] +[[package]] +name = "criterion-perf-events" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e28da8efb44be0b107d9a983d01984e26362249dc30961a2ed3859606d8ddfe1" +dependencies = [ + "criterion", + "perfcnt", +] + [[package]] name = "criterion-plot" version = "0.4.3" @@ -876,7 +892,7 @@ version = "0.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d" dependencies = [ - "libc", + "libc 0.2.93", "redox_users", "winapi 0.3.9", ] @@ -984,7 +1000,7 @@ checksum = "cd3aec53de10fe96d7d8c565eb17f2c687bb5518a2ec453b5b1252964526abe0" dependencies = [ "cfg-if 1.0.0", "crc32fast", - "libc", + "libc 0.2.93", "miniz_oxide", ] @@ -1148,7 +1164,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce" dependencies = [ "cfg-if 1.0.0", - "libc", + "libc 0.2.93", "wasi 0.9.0+wasi-snapshot-preview1", ] @@ -1159,7 +1175,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c9495705279e7140bf035dde1f6e750c162df8b625267cd52cc44e0b156732c8" dependencies = [ "cfg-if 1.0.0", - "libc", + "libc 0.2.93", "wasi 0.10.2+wasi-snapshot-preview1", ] @@ -1447,7 +1463,7 @@ version = "0.1.18" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "322f4de77956e22ed0e5032c359a0f1273f1f7f0d79bfa3b8ffbc730d7fbcc5c" dependencies = [ - "libc", + "libc 0.2.93", ] [[package]] @@ -1479,7 +1495,7 @@ dependencies = [ "rand_xoshiro", "sized-chunks 0.5.3", "typenum", - "version_check", + "version_check 0.9.3", ] [[package]] @@ -1493,7 +1509,7 @@ dependencies = [ "rand_xoshiro", "sized-chunks 0.6.4", "typenum", - "version_check", + "version_check 0.9.3", ] [[package]] @@ -1507,7 +1523,7 @@ dependencies = [ "rand_xoshiro", "sized-chunks 0.5.3", "typenum", - "version_check", + "version_check 0.9.3", ] [[package]] @@ -1521,7 +1537,7 @@ dependencies = [ "rand_xoshiro", "sized-chunks 0.6.4", "typenum", - "version_check", + "version_check 0.9.3", ] [[package]] @@ -1573,7 +1589,7 @@ source = "git+https://github.com/rtfeldman/inkwell?tag=llvm10-0.release4#9ae45f0 dependencies = [ "either", "inkwell_internals", - "libc", + "libc 0.2.93", "llvm-sys", "once_cell", "parking_lot", @@ -1617,7 +1633,7 @@ version = "0.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b2b3ea6ff95e175473f8ffe6a7eb7c00d054240321b84c57051175fe3c1e075e" dependencies = [ - "libc", + "libc 0.2.93", ] [[package]] @@ -1656,7 +1672,7 @@ version = "0.1.21" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5c71313ebb9439f74b00d9d2dcec36440beaf57a6aa0623068441dd7cd81a7f2" dependencies = [ - "libc", + "libc 0.2.93", ] [[package]] @@ -1684,7 +1700,7 @@ version = "3.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b19cc4a81304db2a0ad69740e83cdc3a9364e3f9bd6d88a87288a4c2deec927b" dependencies = [ - "libc", + "libc 0.2.93", "libloading 0.6.7", ] @@ -1706,6 +1722,12 @@ version = "1.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55" +[[package]] +name = "libc" +version = "0.1.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e32a70cf75e5846d53a673923498228bbec6a8624708a9ea5645f075d6276122" + [[package]] name = "libc" version = "0.2.93" @@ -1746,7 +1768,7 @@ checksum = "15d9c00ce56221b2150e2d4d51887ff139fce5a0e50346c744861d1e66d2f7c4" dependencies = [ "cc", "lazy_static", - "libc", + "libc 0.2.93", "regex", "semver", ] @@ -1775,7 +1797,7 @@ version = "0.0.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "62bb907fe88d54d8d9ce32a3cceab4218ed2f6b7d35617cafe9adf84e43919cb" dependencies = [ - "libc", + "libc 0.2.93", ] [[package]] @@ -1802,7 +1824,7 @@ version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d9b70ca2a6103ac8b665dc150b142ef0e4e89df640c9e6cf295d189c3caebe5a" dependencies = [ - "libc", + "libc 0.2.93", ] [[package]] @@ -1858,7 +1880,7 @@ dependencies = [ "fuchsia-zircon-sys", "iovec", "kernel32-sys", - "libc", + "libc 0.2.93", "log", "miow", "net2", @@ -1890,6 +1912,16 @@ dependencies = [ "ws2_32-sys", ] +[[package]] +name = "mmap" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0bc85448a6006dd2ba26a385a564a8a0f1f2c7e78c70f1a70b2e0f4af286b823" +dependencies = [ + "libc 0.1.12", + "tempdir", +] + [[package]] name = "naga" version = "0.3.2" @@ -1925,7 +1957,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bdf399b8b7a39c6fb153c4ec32c72fd5fe789df24a647f229c239aa7adb15241" dependencies = [ "lazy_static", - "libc", + "libc 0.2.93", "log", "ndk", "ndk-macro", @@ -1958,7 +1990,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "391630d12b68002ae1e25e8f974306474966550ad82dac6886fb8910c19568ae" dependencies = [ "cfg-if 0.1.10", - "libc", + "libc 0.2.93", "winapi 0.3.9", ] @@ -1971,7 +2003,7 @@ dependencies = [ "bitflags", "cc", "cfg-if 0.1.10", - "libc", + "libc 0.2.93", "void", ] @@ -1984,7 +2016,7 @@ dependencies = [ "bitflags", "cc", "cfg-if 0.1.10", - "libc", + "libc 0.2.93", ] [[package]] @@ -1996,7 +2028,17 @@ dependencies = [ "bitflags", "cc", "cfg-if 1.0.0", - "libc", + "libc 0.2.93", +] + +[[package]] +name = "nom" +version = "4.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2ad2a91a8e869eeb30b9cb3119ae87773a8f4ae617f41b1eb9c154b2905f7bd6" +dependencies = [ + "memchr", + "version_check 0.1.5", ] [[package]] @@ -2006,7 +2048,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e7413f999671bd4745a7b624bd370a569fb6bc574b23c83a3c5ed2e453f3d5e2" dependencies = [ "memchr", - "version_check", + "version_check 0.9.3", ] [[package]] @@ -2031,7 +2073,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "05499f3756671c15885fee9034446956fff3f243d6077b91e5767df161f766b3" dependencies = [ "hermit-abi", - "libc", + "libc 0.2.93", ] [[package]] @@ -2173,7 +2215,7 @@ version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "eebde548fbbf1ea81a99b128872779c437752fb99f217c45245e1a61dcd9edcd" dependencies = [ - "libc", + "libc 0.2.93", "winapi 0.3.9", ] @@ -2221,7 +2263,7 @@ dependencies = [ "backtrace", "cfg-if 1.0.0", "instant", - "libc", + "libc 0.2.93", "petgraph", "redox_syscall 0.2.5", "smallvec", @@ -2235,6 +2277,21 @@ version = "2.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e" +[[package]] +name = "perfcnt" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "88a4decf2d171c232d741ca37d590cd50d35314b7d348198e7e474e0bf34c8b4" +dependencies = [ + "bitflags", + "byteorder", + "libc 0.2.93", + "mmap", + "nom 4.2.3", + "phf", + "x86", +] + [[package]] name = "pest" version = "2.1.3" @@ -2425,7 +2482,7 @@ dependencies = [ "proc-macro2 1.0.26", "quote 1.0.9", "syn 1.0.65", - "version_check", + "version_check 0.9.3", ] [[package]] @@ -2438,7 +2495,7 @@ dependencies = [ "quote 1.0.9", "syn 1.0.65", "syn-mid", - "version_check", + "version_check 0.9.3", ] [[package]] @@ -2545,6 +2602,19 @@ dependencies = [ "proc-macro2 1.0.26", ] +[[package]] +name = "rand" +version = "0.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "552840b97013b1a26992c11eac34bdd778e464601a4c2054b5f0bff7c6761293" +dependencies = [ + "fuchsia-cprng", + "libc 0.2.93", + "rand_core 0.3.1", + "rdrand", + "winapi 0.3.9", +] + [[package]] name = "rand" version = "0.6.5" @@ -2552,7 +2622,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6d71dacdc3c88c1fde3885a3be3fbab9f35724e6ce99467f7d9c5026132184ca" dependencies = [ "autocfg 0.1.7", - "libc", + "libc 0.2.93", "rand_chacha 0.1.1", "rand_core 0.4.2", "rand_hc 0.1.0", @@ -2571,7 +2641,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03" dependencies = [ "getrandom 0.1.16", - "libc", + "libc 0.2.93", "rand_chacha 0.2.2", "rand_core 0.5.1", "rand_hc 0.2.0", @@ -2584,7 +2654,7 @@ version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0ef9e7e66b4468674bfcb0c81af8b7fa0bb154fa9f28eb840da5c447baeb8d7e" dependencies = [ - "libc", + "libc 0.2.93", "rand_chacha 0.3.0", "rand_core 0.6.2", "rand_hc 0.3.0", @@ -2695,7 +2765,7 @@ version = "0.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1166d5c91dc97b88d1decc3285bb0a99ed84b05cfd0bc2341bdf2d43fc41e39b" dependencies = [ - "libc", + "libc 0.2.93", "rand_core 0.4.2", "winapi 0.3.9", ] @@ -2708,7 +2778,7 @@ checksum = "7b75f676a1e053fc562eafbb47838d67c84801e38fc1ba459e8f180deabd5071" dependencies = [ "cloudabi", "fuchsia-cprng", - "libc", + "libc 0.2.93", "rand_core 0.4.2", "rdrand", "winapi 0.3.9", @@ -2757,13 +2827,22 @@ version = "0.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "63e935c45e09cc6dcf00d2f0b2d630a58f4095320223d47fc68918722f0538b6" +[[package]] +name = "raw-cpuid" +version = "9.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c27cb5785b85bd05d4eb171556c9a1a514552e26123aeae6bb7d811353148026" +dependencies = [ + "bitflags", +] + [[package]] name = "raw-window-handle" version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0a441a7a6c80ad6473bd4b74ec1c9a4c951794285bf941c2126f607c72e48211" dependencies = [ - "libc", + "libc 0.2.93", ] [[package]] @@ -2942,15 +3021,17 @@ dependencies = [ "cli_utils", "const_format", "criterion", + "criterion-perf-events", "iai", "im 14.3.0", "im-rc 14.3.0", "indoc 0.3.6", "inkwell", "inlinable_string", - "libc", + "libc 0.2.93", "libloading 0.6.7", "maplit", + "perfcnt", "pretty_assertions 0.5.1", "quickcheck 0.8.5", "quickcheck_macros 0.8.0", @@ -3045,7 +3126,7 @@ dependencies = [ "im-rc 15.0.0", "indoc 1.0.3", "inlinable_string", - "libc", + "libc 0.2.93", "log", "maplit", "nonempty", @@ -3108,7 +3189,7 @@ dependencies = [ "indoc 0.3.6", "inkwell", "inlinable_string", - "libc", + "libc 0.2.93", "maplit", "pretty_assertions 0.5.1", "quickcheck 0.8.5", @@ -3142,7 +3223,7 @@ dependencies = [ "indoc 0.3.6", "inlinable_string", "itertools 0.9.0", - "libc", + "libc 0.2.93", "libloading 0.6.7", "maplit", "object 0.22.0", @@ -3334,7 +3415,7 @@ dependencies = [ name = "roc_std" version = "0.1.0" dependencies = [ - "libc", + "libc 0.2.93", ] [[package]] @@ -3414,7 +3495,7 @@ source = "git+https://github.com/rtfeldman/rustyline?tag=prompt-fix#a6b8a20d2bf5 dependencies = [ "cfg-if 0.1.10", "dirs-next", - "libc", + "libc 0.2.93", "log", "memchr", "nix 0.17.0", @@ -3772,6 +3853,16 @@ version = "0.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ab0e7238dcc7b40a7be719a25365910f6807bd864f4cce6b2e6b873658e2b19d" +[[package]] +name = "tempdir" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "15f2b5fb00ccdf689e0149d1b1b3c03fead81c2b37735d812fa8bddbbf41b6d8" +dependencies = [ + "rand 0.4.6", + "remove_dir_all", +] + [[package]] name = "tempfile" version = "3.2.0" @@ -3779,7 +3870,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "dac1c663cfc93810f88aed9b8941d48cabf856a1b111c29a40439018d870eb22" dependencies = [ "cfg-if 1.0.0", - "libc", + "libc 0.2.93", "rand 0.8.3", "redox_syscall 0.2.5", "remove_dir_all", @@ -3806,7 +3897,7 @@ dependencies = [ "indoc 0.3.6", "inkwell", "inlinable_string", - "libc", + "libc 0.2.93", "libloading 0.6.7", "maplit", "quickcheck 0.8.5", @@ -3867,7 +3958,7 @@ version = "3.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c7fbf4c9d56b320106cd64fd024dadfa0be7cb4706725fc44a7d7ce952d820c1" dependencies = [ - "libc", + "libc 0.2.93", "redox_syscall 0.1.57", "winapi 0.3.9", ] @@ -3990,7 +4081,7 @@ version = "2.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "50f37be617794602aabbeee0be4f259dc1778fabe05e2d67ee8f79326d5cb4f6" dependencies = [ - "version_check", + "version_check 0.9.3", ] [[package]] @@ -4067,6 +4158,12 @@ dependencies = [ "typed-arena", ] +[[package]] +name = "version_check" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "914b1a6776c4c929a602fafd8bc742e06365d4bcbe48c30f9cca5824f70dc9dd" + [[package]] name = "version_check" version = "0.9.3" @@ -4191,7 +4288,7 @@ checksum = "06ca44d86554b85cf449f1557edc6cc7da935cc748c8e4bf1c507cbd43bae02c" dependencies = [ "bitflags", "downcast-rs", - "libc", + "libc 0.2.93", "nix 0.20.0", "scoped-tls", "wayland-commons", @@ -4394,7 +4491,7 @@ dependencies = [ "dispatch", "instant", "lazy_static", - "libc", + "libc 0.2.93", "log", "mio", "mio-extras", @@ -4455,18 +4552,33 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2bf981e3a5b3301209754218f962052d4d9ee97e478f4d26d4a6eced34c1fef8" dependencies = [ "lazy_static", - "libc", + "libc 0.2.93", "maybe-uninit", "pkg-config", ] +[[package]] +name = "x86" +version = "0.37.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4fd9298cd1b1f88546fc0a5e8faa3354013cd010589299c624fde436aad76cc" +dependencies = [ + "bit_field", + "bitflags", + "csv", + "phf", + "phf_codegen", + "raw-cpuid", + "serde_json", +] + [[package]] name = "xcb" version = "0.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "62056f63138b39116f82a540c983cc11f1c90cd70b3d492a70c25eaa50bd22a6" dependencies = [ - "libc", + "libc 0.2.93", "log", ] @@ -4476,7 +4588,7 @@ version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3a9a231574ae78801646617cefd13bfe94be907c0e4fa979cfd8b770aa3c5d08" dependencies = [ - "nom", + "nom 6.1.2", ] [[package]] diff --git a/cli/Cargo.toml b/cli/Cargo.toml index c653a54fda..b8cf3bc3a0 100644 --- a/cli/Cargo.toml +++ b/cli/Cargo.toml @@ -97,11 +97,13 @@ tempfile = "3.1.0" criterion = "0.3.4" cli_utils = { path = "cli_utils" } iai = "0.1" +criterion-perf-events = "0.1.3" +perfcnt = "0.7.1" [[bench]] name = "time_bench" harness = false [[bench]] -name = "instructions_bench" +name = "events_bench" harness = false diff --git a/cli/benches/events_bench.rs b/cli/benches/events_bench.rs new file mode 100644 index 0000000000..a6ee310a67 --- /dev/null +++ b/cli/benches/events_bench.rs @@ -0,0 +1,96 @@ +use cli_utils::bench_utils::{ + bench_cfold, bench_deriv, bench_nqueens, + bench_rbtree_ck, bench_rbtree_delete, +}; +use criterion_perf_events::Perf; +use perfcnt::linux::HardwareEventType as Hardware; +use perfcnt::linux::PerfCounterBuilderLinux as Builder; + +use criterion::{ + criterion_group, criterion_main, BenchmarkGroup, Criterion, SamplingMode, +}; + +fn bench_group(c: &mut Criterion, hw_event_str: &str) { + let mut group = c.benchmark_group(format!("bench-group_no-opt_{}", hw_event_str)); + // calculate statistics based on a fixed(flat) 100 runs + group.sampling_mode(SamplingMode::Flat); + + let bench_funcs: Vec>) -> ()> = vec![ + bench_nqueens, + /*bench_cfold, + bench_deriv, + bench_rbtree, + bench_rbtree_delete,*/ + // TODO quicksort + ]; + + for bench_func in bench_funcs.iter() { + bench_func(Some(&mut group)) + } + + group.finish(); +} + +use perfcnt::linux::HardwareEventType; + +fn init_criterion(event: HardwareEventType) -> Criterion { + Criterion::default() + .with_measurement( + Perf::new( + Builder::from_hardware_event(event) + ) + ) +} + +fn bench_instructions(c: &mut Criterion) { + bench_group(c, "instructions") +} + +criterion_group!( + name = benches_instructions; + config = init_criterion(Hardware::Instructions); + targets = bench_instructions +); + +fn bench_cache_refs(c: &mut Criterion) { + bench_group(c, "cache_refs") +} + +criterion_group!( + name = benches_cache_refs; + config = init_criterion(Hardware::CacheReferences); + targets = bench_cache_refs +); + +fn bench_cache_misses(c: &mut Criterion) { + bench_group(c, "cache_misses") +} + +criterion_group!( + name = benches_cache_misses; + config = init_criterion(Hardware::CacheMisses); + targets = bench_cache_misses +); + +fn bench_branch_instructions(c: &mut Criterion) { + bench_group(c, "branch_instructions") +} + +criterion_group!( + name = benches_branch_instructions; + config = init_criterion(Hardware::BranchInstructions); + targets = bench_branch_instructions +); + +fn bench_branch_misses(c: &mut Criterion) { + bench_group(c, "branch_misses") +} + +criterion_group!( + name = benches_branch_misses; + config = init_criterion(Hardware::BranchMisses); + targets = bench_branch_misses +); + +criterion_main!(benches_instructions, benches_cache_refs, benches_cache_misses, benches_branch_instructions, benches_branch_misses); + diff --git a/cli/benches/instructions_bench.rs b/cli/benches/instructions_bench.rs deleted file mode 100644 index 1c92f41eab..0000000000 --- a/cli/benches/instructions_bench.rs +++ /dev/null @@ -1,47 +0,0 @@ -use cli_utils::bench_utils::{ - bench_astar, bench_base64, bench_cfold, bench_closure, bench_deriv, bench_nqueens, - bench_rbtree, bench_rbtree_delete, -}; - -fn bench_nqueens_iai() { - bench_nqueens(None); -} - -fn bench_cfold_iai() { - bench_cfold(None); -} - -fn bench_deriv_iai() { - bench_deriv(None); -} - -fn bench_rbtree_iai() { - bench_rbtree(None); -} - -fn bench_rbtree_delete_iai() { - bench_rbtree_delete(None); -} - -fn bench_astar_iai() { - bench_astar(None); -} - -fn bench_base64_iai() { - bench_base64(None); -} - -fn bench_closure_iai() { - bench_closure(None); -} - -iai::main!( - bench_nqueens_iai, - bench_cfold_iai, - bench_deriv_iai, - bench_rbtree_iai, - bench_rbtree_delete_iai, - bench_astar_iai, - bench_base64_iai, - bench_closure_iai, -); diff --git a/cli/benches/time_bench.rs b/cli/benches/time_bench.rs index 8d149e8530..2d564b8ff1 100644 --- a/cli/benches/time_bench.rs +++ b/cli/benches/time_bench.rs @@ -1,25 +1,24 @@ use cli_utils::bench_utils::{ - bench_astar, bench_base64, bench_cfold, bench_closure, bench_deriv, bench_nqueens, - bench_rbtree, bench_rbtree_delete, + bench_cfold, bench_deriv, bench_nqueens, + bench_rbtree_ck, bench_rbtree_delete, }; use criterion::{ criterion_group, criterion_main, measurement::WallTime, BenchmarkGroup, Criterion, SamplingMode, }; -fn bench_group_sample_100(c: &mut Criterion) { - let mut group = c.benchmark_group("bench-group-sample-100-unoptimized"); +fn bench_group_wall_time(c: &mut Criterion) { + let mut group = c.benchmark_group("bench-group_wall-time"); // calculate statistics based on a fixed(flat) 100 runs group.sampling_mode(SamplingMode::Flat); + group.sample_size(200); let bench_funcs: Vec>) -> ()> = vec![ - bench_nqueens, - bench_cfold, - bench_deriv, - bench_rbtree, - bench_rbtree_delete, - bench_astar, - bench_base64, - bench_closure, + bench_nqueens, // 11 + bench_cfold, // e = mkExpr 12 1 + bench_deriv, // nest deriv 7 f + bench_rbtree_ck, // ms = makeMap 5 5600 + bench_rbtree_delete, // m = makeMap 6000 + // TODO quicksort ]; for bench_func in bench_funcs.iter() { @@ -29,5 +28,5 @@ fn bench_group_sample_100(c: &mut Criterion) { group.finish(); } -criterion_group!(benches, bench_group_sample_100); +criterion_group!(benches, bench_group_wall_time); criterion_main!(benches); diff --git a/cli/cli_utils/src/bench_utils.rs b/cli/cli_utils/src/bench_utils.rs index ba83d2d62a..141823184d 100644 --- a/cli/cli_utils/src/bench_utils.rs +++ b/cli/cli_utils/src/bench_utils.rs @@ -1,5 +1,5 @@ use crate::helpers::{example_file, run_cmd, run_roc}; -use criterion::{black_box, measurement::WallTime, BenchmarkGroup}; +use criterion::{BenchmarkGroup, black_box, measurement::{Measurement, WallTime}}; use std::path::Path; // run without optimization, without input @@ -9,23 +9,23 @@ fn exec_bench_simple( expected_ending: &str, bench_group_opt: Option<&mut BenchmarkGroup>, ) { - exec_benchmark( + exec_bench_w_input( file, "", executable_filename, expected_ending, - false, + true, bench_group_opt, ) } -fn exec_benchmark( +fn exec_bench_w_input( file: &Path, stdin_str: &str, executable_filename: &str, expected_ending: &str, run_optimized: bool, - bench_group_opt: Option<&mut BenchmarkGroup>, + bench_group_opt: Option<&mut BenchmarkGroup>, ) { let flags: &[&str] = if run_optimized { &["--optimize"] } else { &[] }; @@ -67,11 +67,11 @@ fn check_cmd_output( assert!(out.status.success()); } -fn bench_cmd( +fn bench_cmd( file: &Path, stdin_str: &str, executable_filename: &str, - bench_group_opt: Option<&mut BenchmarkGroup>, + bench_group_opt: Option<&mut BenchmarkGroup>, ) { if let Some(bench_group) = bench_group_opt { bench_group.bench_function(&format!("Benchmarking {:?}", executable_filename), |b| { @@ -92,11 +92,13 @@ fn bench_cmd( } } -pub fn bench_nqueens(bench_group_opt: Option<&mut BenchmarkGroup>) { - exec_bench_simple( +pub fn bench_nqueens(bench_group_opt: Option<&mut BenchmarkGroup>) { + exec_bench_w_input( &example_file("benchmarks", "NQueens.roc"), + "11", "nqueens", - "4\n", + "2680\n", + true, bench_group_opt, ); } @@ -105,7 +107,7 @@ pub fn bench_cfold(bench_group_opt: Option<&mut BenchmarkGroup>) { exec_bench_simple( &example_file("benchmarks", "CFold.roc"), "cfold", - "11 & 11\n", + "10426 & 10426\n", bench_group_opt, ); } @@ -114,16 +116,16 @@ pub fn bench_deriv(bench_group_opt: Option<&mut BenchmarkGroup>) { exec_bench_simple( &example_file("benchmarks", "Deriv.roc"), "deriv", - "1 count: 6\n2 count: 22\n", + "1 count: 6\n2 count: 22\n3 count: 90\n4 count: 420\n5 count: 2202\n6 count: 12886\n7 count: 83648\n", bench_group_opt, ); } -pub fn bench_rbtree(bench_group_opt: Option<&mut BenchmarkGroup>) { +pub fn bench_rbtree_ck(bench_group_opt: Option<&mut BenchmarkGroup>) { exec_bench_simple( - &example_file("benchmarks", "RBTreeInsert.roc"), - "rbtree-insert", - "Node Black 0 {} Empty Empty\n", + &example_file("benchmarks", "RBTreeCk.roc"), + "rbtree-ck", + "560\n", bench_group_opt, ); } @@ -132,34 +134,9 @@ pub fn bench_rbtree_delete(bench_group_opt: Option<&mut BenchmarkGroup exec_bench_simple( &example_file("benchmarks", "RBTreeDel.roc"), "rbtree-del", - "30\n", + "420\n", bench_group_opt, ); } -pub fn bench_astar(bench_group_opt: Option<&mut BenchmarkGroup>) { - exec_bench_simple( - &example_file("benchmarks", "TestAStar.roc"), - "test-astar", - "True\n", - bench_group_opt, - ); -} - -pub fn bench_base64(bench_group_opt: Option<&mut BenchmarkGroup>) { - exec_bench_simple( - &example_file("benchmarks", "TestBase64.roc"), - "test-base64", - "encoded: SGVsbG8gV29ybGQ=\ndecoded: Hello World\n", - bench_group_opt, - ); -} - -pub fn bench_closure(bench_group_opt: Option<&mut BenchmarkGroup>) { - exec_bench_simple( - &example_file("benchmarks", "Closure.roc"), - "closure", - "", - bench_group_opt, - ); -} +// TODO quicksort diff --git a/cli/tests/cli_run.rs b/cli/tests/cli_run.rs index 671af1f47f..c5cfd8bf39 100644 --- a/cli/tests/cli_run.rs +++ b/cli/tests/cli_run.rs @@ -179,7 +179,7 @@ mod cli_run { fn run_nqueens_not_optimized() { check_output_with_stdin( &example_file("benchmarks", "NQueens.roc"), - "", + "6", "nqueens", &[], "4\n", diff --git a/examples/benchmarks/CFold.roc b/examples/benchmarks/CFold.roc index fc3468886c..38d6345325 100644 --- a/examples/benchmarks/CFold.roc +++ b/examples/benchmarks/CFold.roc @@ -7,7 +7,7 @@ app "cfold" main : Task.Task {} [] main = - e = mkExpr 3 1 + e = mkExpr 12 1 unoptimized = eval e optimized = eval (constFolding (reassoc e)) diff --git a/examples/benchmarks/Deriv.roc b/examples/benchmarks/Deriv.roc index 642ae5dd79..da9b77acad 100644 --- a/examples/benchmarks/Deriv.roc +++ b/examples/benchmarks/Deriv.roc @@ -15,7 +15,7 @@ main = f : Expr f = pow x x - nest deriv 2 f + nest deriv 7 f |> Task.map (\_ -> {}) Expr : [ Val I64, Var Str, Add Expr Expr, Mul Expr Expr, Pow Expr Expr, Ln Expr ] diff --git a/examples/benchmarks/NQueens.roc b/examples/benchmarks/NQueens.roc index 9d5acaf2f5..e1f8443159 100644 --- a/examples/benchmarks/NQueens.roc +++ b/examples/benchmarks/NQueens.roc @@ -5,10 +5,10 @@ app "nqueens" main : Task.Task {} [] main = - # Task.after Task.getInt \n -> - queens 6 - |> Str.fromInt - |> Task.putLine + Task.after Task.getInt \n -> + queens n + |> Str.fromInt + |> Task.putLine ConsList a : [ Nil, Cons a (ConsList a) ] diff --git a/examples/benchmarks/RBTreeCk.roc b/examples/benchmarks/RBTreeCk.roc index 4a69241984..fee17c4159 100644 --- a/examples/benchmarks/RBTreeCk.roc +++ b/examples/benchmarks/RBTreeCk.roc @@ -48,7 +48,7 @@ resultWithDefault = \res, default -> main : Task.Task {} [] main = ms : ConsList Map - ms = makeMap 5 5 # 42_000_00 + ms = makeMap 5 5600 # 4_200_000 when ms is Cons head _ -> diff --git a/examples/benchmarks/RBTreeDel.roc b/examples/benchmarks/RBTreeDel.roc index 172b97f7f2..32104c5a23 100644 --- a/examples/benchmarks/RBTreeDel.roc +++ b/examples/benchmarks/RBTreeDel.roc @@ -15,7 +15,7 @@ ConsList a : [ Nil, Cons a (ConsList a) ] main : Task.Task {} [] main = # benchmarks use 4_200_000 - m = makeMap 420 + m = makeMap 6000 val = fold (\_, v, r -> if v then r + 1 else r) m 0 From 498d3ba3b53bea51ff452c284a8b18219fb20030 Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 26 May 2021 20:18:59 +0200 Subject: [PATCH 016/496] make sure to always switch on the tag id, not the tag itself --- compiler/mono/src/decision_tree.rs | 33 ++++++++++++++++++++++++------ compiler/mono/src/layout.rs | 4 ++++ 2 files changed, 31 insertions(+), 6 deletions(-) diff --git a/compiler/mono/src/decision_tree.rs b/compiler/mono/src/decision_tree.rs index 3aa4a7f22d..d3979f9529 100644 --- a/compiler/mono/src/decision_tree.rs +++ b/compiler/mono/src/decision_tree.rs @@ -1681,12 +1681,33 @@ fn decide_to_branching<'a>( // We have learned more about the exact layout of the cond (based on the path) // but tests are still relative to the original cond symbol - let mut switch = Stmt::Switch { - cond_layout: inner_cond_layout, - cond_symbol: inner_cond_symbol, - branches: branches.into_bump_slice(), - default_branch: (default_branch_info, env.arena.alloc(default_branch)), - ret_layout, + let mut switch = if let Layout::Union(_) = inner_cond_layout { + let tag_id_symbol = env.unique_symbol(); + + let temp = Stmt::Switch { + cond_layout: Layout::TAG_SIZE, + cond_symbol: tag_id_symbol, + branches: branches.into_bump_slice(), + default_branch: (default_branch_info, env.arena.alloc(default_branch)), + ret_layout, + }; + + let expr = Expr::AccessAtIndex { + index: 0, + field_layouts: &[Layout::TAG_SIZE], + structure: inner_cond_symbol, + wrapped: Wrapped::MultiTagUnion, + }; + + Stmt::Let(tag_id_symbol, expr, Layout::TAG_SIZE, env.arena.alloc(temp)) + } else { + Stmt::Switch { + cond_layout: inner_cond_layout, + cond_symbol: inner_cond_symbol, + branches: branches.into_bump_slice(), + default_branch: (default_branch_info, env.arena.alloc(default_branch)), + ret_layout, + } }; for (symbol, layout, expr) in cond_stores_vec.into_iter().rev() { diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index 37f8669418..7afa2efe28 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -16,6 +16,10 @@ const GENERATE_NULLABLE: bool = true; const DEFAULT_NUM_BUILTIN: Builtin<'_> = Builtin::Int64; pub const TAG_SIZE: Builtin<'_> = Builtin::Int64; +impl Layout<'_> { + pub const TAG_SIZE: Layout<'static> = Layout::Builtin(Builtin::Int64); +} + #[derive(Copy, Clone)] #[repr(u8)] pub enum InPlace { From 9bbed89e6a027d5c19fdfe166cf862a828ccaa79 Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 26 May 2021 20:24:31 +0200 Subject: [PATCH 017/496] speed up cfold --- examples/benchmarks/CFold.roc | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/examples/benchmarks/CFold.roc b/examples/benchmarks/CFold.roc index fc3468886c..85549cb4a2 100644 --- a/examples/benchmarks/CFold.roc +++ b/examples/benchmarks/CFold.roc @@ -81,9 +81,9 @@ constFolding = \e -> when Pair x1 x2 is Pair (Val a) (Val b) -> Val (a+b) - # Pair (Val a) (Add (Val b) x) -> Add (Val (a+b)) x + Pair (Val a) (Add (Val b) x) -> Add (Val (a+b)) x Pair (Val a) (Add x (Val b)) -> Add (Val (a+b)) x - Pair _ _ -> Add x1 x2 + Pair y1 y2 -> Add y1 y2 Mul e1 e2 -> x1 = constFolding e1 @@ -93,7 +93,7 @@ constFolding = \e -> Pair (Val a) (Val b) -> Val (a*b) Pair (Val a) (Mul (Val b) x) -> Mul (Val (a*b)) x Pair (Val a) (Mul x (Val b)) -> Mul (Val (a*b)) x - Pair _ _ -> Mul x1 x2 + Pair y1 y2 -> Add y1 y2 _ -> e From fdfc99e4e8d074ae58381be77a44ff9489a89778 Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 26 May 2021 21:51:18 +0200 Subject: [PATCH 018/496] add constructor info in more cases --- compiler/mono/src/decision_tree.rs | 35 +++++++++++++++++++++++++----- compiler/mono/src/ir.rs | 9 +++++++- 2 files changed, 38 insertions(+), 6 deletions(-) diff --git a/compiler/mono/src/decision_tree.rs b/compiler/mono/src/decision_tree.rs index d3979f9529..565e9f7126 100644 --- a/compiler/mono/src/decision_tree.rs +++ b/compiler/mono/src/decision_tree.rs @@ -1101,7 +1101,13 @@ fn test_to_equality<'a>( cond_layout: &Layout<'a>, path: &[PathInstruction], test: Test<'a>, -) -> (StoresVec<'a>, Symbol, Symbol, Layout<'a>) { +) -> ( + StoresVec<'a>, + Symbol, + Symbol, + Layout<'a>, + Option>, +) { let (rhs_symbol, mut stores, _layout) = path_to_expr_help(env, cond_symbol, &path, *cond_layout); @@ -1148,6 +1154,11 @@ fn test_to_equality<'a>( lhs_symbol, rhs_symbol, Layout::Builtin(Builtin::Int64), + Some(ConstructorKnown::OnlyPass { + scrutinee: path_symbol, + layout: *cond_layout, + tag_id, + }), ) } Test::IsInt(test_int) => { @@ -1162,6 +1173,7 @@ fn test_to_equality<'a>( lhs_symbol, rhs_symbol, Layout::Builtin(Builtin::Int64), + None, ) } @@ -1177,6 +1189,7 @@ fn test_to_equality<'a>( lhs_symbol, rhs_symbol, Layout::Builtin(Builtin::Float64), + None, ) } @@ -1192,6 +1205,7 @@ fn test_to_equality<'a>( lhs_symbol, rhs_symbol, Layout::Builtin(Builtin::Int8), + None, ) } @@ -1205,6 +1219,7 @@ fn test_to_equality<'a>( lhs_symbol, rhs_symbol, Layout::Builtin(Builtin::Int1), + None, ) } @@ -1219,6 +1234,7 @@ fn test_to_equality<'a>( lhs_symbol, rhs_symbol, Layout::Builtin(Builtin::Str), + None, ) } @@ -1231,6 +1247,7 @@ type Tests<'a> = std::vec::Vec<( Symbol, Symbol, Layout<'a>, + Option>, )>; fn stores_and_condition<'a>( @@ -1239,7 +1256,7 @@ fn stores_and_condition<'a>( cond_layout: &Layout<'a>, test_chain: Vec<(Vec, Test<'a>)>, ) -> (Tests<'a>, Option<(Symbol, JoinPointId, Stmt<'a>)>) { - let mut tests = Vec::with_capacity(test_chain.len()); + let mut tests: Tests = Vec::with_capacity(test_chain.len()); let mut guard = None; @@ -1444,12 +1461,20 @@ fn compile_tests<'a>( cond = compile_guard(env, ret_layout, id, arena.alloc(stmt), fail, cond); } - for (new_stores, lhs, rhs, _layout) in tests.into_iter() { - cond = compile_test(env, ret_layout, new_stores, lhs, rhs, fail, cond); + for (new_stores, lhs, rhs, _layout, opt_constructor_info) in tests.into_iter() { + match opt_constructor_info { + None => { + cond = compile_test(env, ret_layout, new_stores, lhs, rhs, fail, cond); + } + Some(cinfo) => { + cond = compile_test_help(env, cinfo, ret_layout, new_stores, lhs, rhs, fail, cond); + } + } } cond } +#[derive(Debug)] enum ConstructorKnown<'a> { Both { scrutinee: Symbol, @@ -1571,7 +1596,7 @@ fn decide_to_branching<'a>( // use knowledge about constructors for optimization debug_assert_eq!(tests.len(), 1); - let (new_stores, lhs, rhs, _layout) = tests.into_iter().next().unwrap(); + let (new_stores, lhs, rhs, _layout, _cinfo) = tests.into_iter().next().unwrap(); compile_test_help( env, diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index cbf8649aaf..b7660b4c61 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -916,7 +916,14 @@ impl<'a> BranchInfo<'a> { .append(", tag_id: ") .append(format!("{}", tag_id)) .append("} "), - _ => alloc.text(""), + + _ => { + if PRETTY_PRINT_IR_SYMBOLS { + alloc.text(" ") + } else { + alloc.text("") + } + } } } } From 829edd509c78489f60b3876e4d98531dc594cddc Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Wed, 26 May 2021 20:45:27 -0400 Subject: [PATCH 019/496] Include builtins.bc in the roc binary --- compiler/builtins/build.rs | 3 +-- compiler/builtins/src/bitcode.rs | 22 ++++------------------ compiler/gen/src/llvm/build.rs | 2 +- 3 files changed, 6 insertions(+), 21 deletions(-) diff --git a/compiler/builtins/build.rs b/compiler/builtins/build.rs index c157c1cef7..b6a4e41f14 100644 --- a/compiler/builtins/build.rs +++ b/compiler/builtins/build.rs @@ -32,7 +32,7 @@ fn main() { run_command(&bitcode_path, "zig", &["build", "ir", "-Drelease=true"]); - let dest_bc_path = Path::new(&out_dir).join("builtins.bc"); + let dest_bc_path = bitcode_path.join("builtins.bc"); let dest_bc = dest_bc_path.to_str().expect("Invalid dest bc path"); println!("Compiling bitcode to: {}", dest_bc); @@ -43,7 +43,6 @@ fn main() { ); println!("cargo:rerun-if-changed=build.rs"); - println!("cargo:rustc-env=BUILTINS_BC={}", dest_bc); println!("cargo:rustc-env=BUILTINS_O={}", dest_obj); get_zig_files(bitcode_path.as_path(), &|path| { let path: &Path = path; diff --git a/compiler/builtins/src/bitcode.rs b/compiler/builtins/src/bitcode.rs index 732244d4ae..53cd979abb 100644 --- a/compiler/builtins/src/bitcode.rs +++ b/compiler/builtins/src/bitcode.rs @@ -1,26 +1,12 @@ -use std::fs::File; -use std::io::prelude::Read; -use std::vec::Vec; - -const BC_PATH: &str = env!( - "BUILTINS_BC", - "Env var BUILTINS_BC not found. Is there a problem with the build script?" -); - pub const OBJ_PATH: &str = env!( "BUILTINS_O", "Env var BUILTINS_O not found. Is there a problem with the build script?" ); -pub fn get_bytes() -> Vec { - // In the build script for the builtins module, we compile the builtins bitcode and set - // BUILTINS_BC to the path to the compiled output. - let mut builtins_bitcode = File::open(BC_PATH).expect("Unable to find builtins bitcode source"); - let mut buffer = Vec::new(); - builtins_bitcode - .read_to_end(&mut buffer) - .expect("Unable to read builtins bitcode"); - buffer +pub fn as_bytes() -> &'static [u8] { + // In the build script for the builtins module, + // we compile the builtins into LLVM bitcode + include_bytes!("../bitcode/builtins.bc") } pub const NUM_ASIN: &str = "roc_builtins.num.asin"; diff --git a/compiler/gen/src/llvm/build.rs b/compiler/gen/src/llvm/build.rs index c1a0006844..5fa677913e 100644 --- a/compiler/gen/src/llvm/build.rs +++ b/compiler/gen/src/llvm/build.rs @@ -353,7 +353,7 @@ impl<'a, 'ctx, 'env> Env<'a, 'ctx, 'env> { } pub fn module_from_builtins<'ctx>(ctx: &'ctx Context, module_name: &str) -> Module<'ctx> { - let bitcode_bytes = bitcode::get_bytes(); + let bitcode_bytes = bitcode::as_bytes(); let memory_buffer = MemoryBuffer::create_from_memory_range(&bitcode_bytes, module_name); From 51b1ac77a46aac827e0c54074e51e67291dd5c1e Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Wed, 26 May 2021 21:01:38 -0400 Subject: [PATCH 020/496] Add Num.format docs --- compiler/builtins/docs/Num.roc | 67 +++++++++++++++++++++++++++++++++- compiler/builtins/docs/Str.roc | 30 +++++++++------ 2 files changed, 84 insertions(+), 13 deletions(-) diff --git a/compiler/builtins/docs/Num.roc b/compiler/builtins/docs/Num.roc index 813fe34e23..419672c852 100644 --- a/compiler/builtins/docs/Num.roc +++ b/compiler/builtins/docs/Num.roc @@ -533,7 +533,10 @@ mul : Num range, Num range -> Num range ## Convert -## Convert a number to a string, formatted as the traditional base 10 (decimal). +## Convert a number to a [Str]. +## +## This is the same as calling `Num.format {}` - so for more details on +## exact formatting, see [Num.format]. ## ## >>> Num.toStr 42 ## @@ -546,6 +549,68 @@ mul : Num range, Num range -> Num range ## For other bases see #toHexStr, #toOctalStr, and #toBinaryStr. toStr : Num * -> Str +## Convert a number into a [Str], formatted with the given options. +## +## Default options: +## * `base: Decimal` +## * `notation: Standard` +## * `decimalMark: HideForIntegers "."` +## * `decimalDigits: { min: 0, max: All }` +## * `minIntDigits: 1` +## * `wholeSep: { mark: ",", places: 3 }` +## +## ## Options +## +## +## ### decimalMark +## +## * `AlwaysShow` always shows the decimal mark, no matter what. +## * `HideForIntegers` hides the decimal mark if all the numbers after the decimal mark are 0. +## +## The [Str] included in either of these represents the mark itself. +## +## ### `decimalDigits +## +## With 0 decimal digits, the decimal mark will still be rendered if +## `decimalMark` is set to `AlwaysShow`. +## +## If `max` is less than `min`, then first the number will be truncated to `max` +## digits, and then zeroes will be added afterwards until it reaches `min` digits. +## +## >>> Num.format 1.23 { decPlaces: 0, decPointVis: AlwaysShow } +## +## ### minIntDigits +## +## If the integer portion of number is fewer than this many digits, zeroes will +## be added in front of it until there are at least `minWholeDigits` digits. +## +## If this is set to zero, then numbers less than 1 will begin with `"."` +## rather than `"0."`. +## +## ### wholeSep +## +## Examples: +## +## In some countries (e.g. USA and UK), a comma is used to separate thousands: +## >>> Num.format 1_000_000 { base: Decimal, wholeSep: { mark: ",", places: 3 } } +## +## Sometimes when rendering bits, it's nice to group them into groups of 4: +## >>> Num.format 1_000_000 { base: Binary, wholeSep: { mark: " ", places: 4 } } +## +## It's also common to render hexadecimal in groups of 2: +## >>> Num.format 1_000_000 { base: Hexadecimal, wholeSep: { mark: " ", places: 2 } } +format : + Num *, + { + base ? [ Decimal, Hexadecimal, Octal, Binary ], + notation ? [ Standard, Scientific ], + decimalMark ? [ AlwaysShow Str, HideForIntegers ], + decimalDigits ? { min : U16, max : [ All, Trunc U16, Round U16, Floor U16, Ceil U16 ] }, + minWholeDigits ? U16, + wholeSep ? { mark : Str, places : U64 } + } + -> Str + ## Round off the given float to the nearest integer. round : Float * -> Int * ceil : Float * -> Int * diff --git a/compiler/builtins/docs/Str.roc b/compiler/builtins/docs/Str.roc index 4789db17b2..b8a216d514 100644 --- a/compiler/builtins/docs/Str.roc +++ b/compiler/builtins/docs/Str.roc @@ -429,16 +429,22 @@ chompCodePoint : Str, U32 -> Result Str [ Expected [ ExactCodePoint U32 ]* Str ] ## If the string begins with digits which can represent a valid #U8, return ## that number along with the rest of the string after the digits. -parseU8 : Str -> Result { val : U8, rest : Str } [ Expected [ NumU8 ]* Str ]* -parseI8 : Str -> Result { val : I8, rest : Str } [ Expected [ NumI8 ]* Str ]* -parseU16 : Str -> Result { val : U16, rest : Str } [ Expected [ NumU16 ]* Str ]* -parseI16 : Str -> Result { val : I16, rest : Str } [ Expected [ NumI16 ]* Str ]* -parseU32 : Str -> Result { val : U32, rest : Str } [ Expected [ NumU32 ]* Str ]* -parseI32 : Str -> Result { val : I32, rest : Str } [ Expected [ NumI32 ]* Str ]* -parseU64 : Str -> Result { val : U64, rest : Str } [ Expected [ NumU64 ]* Str ]* -parseI64 : Str -> Result { val : I64, rest : Str } [ Expected [ NumI64 ]* Str ]* -parseU128 : Str -> Result { val : U128, rest : Str } [ Expected [ NumU128 ]* Str ]* -parseI128 : Str -> Result { val : I128, rest : Str } [ Expected [ NumI128 ]* Str ]* +parseU8 : Str, NumFormat -> Result { val : U8, rest : Str } [ Expected [ NumU8 ]* Str ]* +parseI8 : Str, NumFormat -> Result { val : I8, rest : Str } [ Expected [ NumI8 ]* Str ]* +parseU16 : Str, NumFormat -> Result { val : U16, rest : Str } [ Expected [ NumU16 ]* Str ]* +parseI16 : Str, NumFormat -> Result { val : I16, rest : Str } [ Expected [ NumI16 ]* Str ]* +parseU32 : Str, NumFormat -> Result { val : U32, rest : Str } [ Expected [ NumU32 ]* Str ]* +parseI32 : Str, NumFormat -> Result { val : I32, rest : Str } [ Expected [ NumI32 ]* Str ]* +parseU64 : Str, NumFormat -> Result { val : U64, rest : Str } [ Expected [ NumU64 ]* Str ]* +parseI64 : Str, NumFormat -> Result { val : I64, rest : Str } [ Expected [ NumI64 ]* Str ]* +parseU128 : Str, NumFormat -> Result { val : U128, rest : Str } [ Expected [ NumU128 ]* Str ]* +parseI128 : Str, NumFormat -> Result { val : I128, rest : Str } [ Expected [ NumI128 ]* Str ]* -parseF64 : Str -> Result { val : U128, rest : Str } [ Expected [ NumF64 ]* Str ]* -parseF32 : Str -> Result { val : I128, rest : Str } [ Expected [ NumF32 ]* Str ]* +parseF64 : Str, NumFormat -> Result { val : U128, rest : Str } [ Expected [ NumF64 ]* Str ]* +parseF32 : Str, NumFormat -> Result { val : I128, rest : Str } [ Expected [ NumF32 ]* Str ]* + +## TODO make this similar to the Num.format argument +## except more flexible - e.g. the policy for whole number separators +## might be to allow them, to require them, or to allow them only every N digits +## (e.g. 3 for thousands, 4 for bits, 2 for hex) +NumFormat : { } From e8c3ff042cbe6fca7a135acb52b686d4aa737c34 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 27 May 2021 18:08:32 -0400 Subject: [PATCH 021/496] Remove examples/balance --- examples/balance/.gitignore | 1 - examples/balance/Main.roc | 7 - examples/balance/platform/Cargo.lock | 23 --- examples/balance/platform/Cargo.toml | 14 -- examples/balance/platform/Package-Config.roc | 15 -- examples/balance/platform/host.c | 7 - examples/balance/platform/src/lib.rs | 147 ------------------- 7 files changed, 214 deletions(-) delete mode 100644 examples/balance/.gitignore delete mode 100644 examples/balance/Main.roc delete mode 100644 examples/balance/platform/Cargo.lock delete mode 100644 examples/balance/platform/Cargo.toml delete mode 100644 examples/balance/platform/Package-Config.roc delete mode 100644 examples/balance/platform/host.c delete mode 100644 examples/balance/platform/src/lib.rs diff --git a/examples/balance/.gitignore b/examples/balance/.gitignore deleted file mode 100644 index ba2906d066..0000000000 --- a/examples/balance/.gitignore +++ /dev/null @@ -1 +0,0 @@ -main diff --git a/examples/balance/Main.roc b/examples/balance/Main.roc deleted file mode 100644 index 441dfb50f3..0000000000 --- a/examples/balance/Main.roc +++ /dev/null @@ -1,7 +0,0 @@ -app "main" imports [ Effect ] provides [ rocMain ] to "./platform" - - -rocMain : Effect.Effect {} as Fx -rocMain = - when List.len (Str.split "hello" "JJJJ there") is - _ -> Effect.putLine "Yay" diff --git a/examples/balance/platform/Cargo.lock b/examples/balance/platform/Cargo.lock deleted file mode 100644 index c386bb6c4a..0000000000 --- a/examples/balance/platform/Cargo.lock +++ /dev/null @@ -1,23 +0,0 @@ -# This file is automatically @generated by Cargo. -# It is not intended for manual editing. -[[package]] -name = "host" -version = "0.1.0" -dependencies = [ - "roc_std 0.1.0", -] - -[[package]] -name = "libc" -version = "0.2.79" -source = "registry+https://github.com/rust-lang/crates.io-index" - -[[package]] -name = "roc_std" -version = "0.1.0" -dependencies = [ - "libc 0.2.79 (registry+https://github.com/rust-lang/crates.io-index)", -] - -[metadata] -"checksum libc 0.2.79 (registry+https://github.com/rust-lang/crates.io-index)" = "2448f6066e80e3bfc792e9c98bf705b4b0fc6e8ef5b43e5889aff0eaa9c58743" diff --git a/examples/balance/platform/Cargo.toml b/examples/balance/platform/Cargo.toml deleted file mode 100644 index b0a2a5e96e..0000000000 --- a/examples/balance/platform/Cargo.toml +++ /dev/null @@ -1,14 +0,0 @@ -[package] -name = "host" -version = "0.1.0" -authors = ["The Roc Contributors"] -license = "UPL-1.0" -edition = "2018" - -[lib] -crate-type = ["staticlib"] - -[dependencies] -roc_std = { path = "../../../roc_std" } - -[workspace] diff --git a/examples/balance/platform/Package-Config.roc b/examples/balance/platform/Package-Config.roc deleted file mode 100644 index 0d66513ebe..0000000000 --- a/examples/balance/platform/Package-Config.roc +++ /dev/null @@ -1,15 +0,0 @@ -platform folkertdev/foo - requires { rocMain : Effect {} } - exposes [] - packages {} - imports [] - provides [ mainForHost ] - effects Effect - { - putChar : Int -> Effect {}, - putLine : Str -> Effect {}, - getLine : Effect Str - } - -mainForHost : Effect {} as Fx -mainForHost = rocMain diff --git a/examples/balance/platform/host.c b/examples/balance/platform/host.c deleted file mode 100644 index 0378c69589..0000000000 --- a/examples/balance/platform/host.c +++ /dev/null @@ -1,7 +0,0 @@ -#include - -extern int rust_main(); - -int main() { - return rust_main(); -} diff --git a/examples/balance/platform/src/lib.rs b/examples/balance/platform/src/lib.rs deleted file mode 100644 index 5bff358b10..0000000000 --- a/examples/balance/platform/src/lib.rs +++ /dev/null @@ -1,147 +0,0 @@ -#![allow(non_snake_case)] - -use roc_std::alloca; -use roc_std::RocCallResult; -use roc_std::RocStr; -use std::alloc::Layout; -use std::ffi::c_void; -use std::time::SystemTime; - -extern "C" { - #[link_name = "roc__rocMain_1_exposed"] - fn roc_main(output: *mut u8) -> (); - - #[link_name = "roc__rocMain_1_size"] - fn roc_main_size() -> i64; - - #[link_name = "roc__rocMain_1_Fx_caller"] - fn call_Fx(function_pointer: *const u8, closure_data: *const u8, output: *mut u8) -> (); - - #[link_name = "roc__rocMain_1_Fx_size"] - fn size_Fx() -> i64; - - fn malloc(size: usize) -> *mut c_void; - fn realloc(c_ptr: *mut c_void, size: usize) -> *mut c_void; - fn free(c_ptr: *mut c_void); -} - -#[no_mangle] -pub unsafe fn roc_alloc(size: usize, _alignment: u32) -> *mut c_void { - return malloc(size); -} - -#[no_mangle] -pub unsafe fn roc_realloc( - c_ptr: *mut c_void, - new_size: usize, - _old_size: usize, - _alignment: u32, -) -> *mut c_void { - return realloc(c_ptr, new_size); -} - -#[no_mangle] -pub unsafe fn roc_dealloc(c_ptr: *mut c_void, _alignment: u32) { - return free(c_ptr); -} - -#[no_mangle] -pub fn roc_fx_putChar(foo: i64) -> () { - let character = foo as u8 as char; - print!("{}", character); - - () -} - -#[no_mangle] -pub fn roc_fx_putLine(line: RocStr) -> () { - let bytes = line.as_slice(); - let string = unsafe { std::str::from_utf8_unchecked(bytes) }; - println!("{}", string); - - () -} - -#[no_mangle] -pub fn roc_fx_getLine() -> RocStr { - use std::io::{self, BufRead}; - - let stdin = io::stdin(); - let line1 = stdin.lock().lines().next().unwrap().unwrap(); - - RocStr::from_slice_with_capacity(line1.as_bytes(), line1.len()) -} - -unsafe fn call_the_closure(function_pointer: *const u8, closure_data_ptr: *const u8) -> i64 { - let size = size_Fx() as usize; - - alloca::with_stack_bytes(size, |buffer| { - let buffer: *mut std::ffi::c_void = buffer; - let buffer: *mut u8 = buffer as *mut u8; - - call_Fx( - function_pointer, - closure_data_ptr as *const u8, - buffer as *mut u8, - ); - - let output = &*(buffer as *mut RocCallResult); - - match output.into() { - Ok(_) => 0, - Err(e) => panic!("failed with {}", e), - } - }) -} - -#[no_mangle] -pub fn rust_main() -> isize { - println!("Running Roc closure"); - let start_time = SystemTime::now(); - - let size = unsafe { roc_main_size() } as usize; - let layout = Layout::array::(size).unwrap(); - let answer = unsafe { - let buffer = std::alloc::alloc(layout); - - roc_main(buffer); - - let output = &*(buffer as *mut RocCallResult<()>); - - match output.into() { - Ok(()) => { - let function_pointer = { - // this is a pointer to the location where the function pointer is stored - // we pass just the function pointer - let temp = buffer.offset(8) as *const i64; - - (*temp) as *const u8 - }; - - let closure_data_ptr = buffer.offset(16); - - let result = - call_the_closure(function_pointer as *const u8, closure_data_ptr as *const u8); - - std::alloc::dealloc(buffer, layout); - - result - } - Err(msg) => { - std::alloc::dealloc(buffer, layout); - - panic!("Roc failed with message: {}", msg); - } - } - }; - let end_time = SystemTime::now(); - let duration = end_time.duration_since(start_time).unwrap(); - - println!( - "Roc execution took {:.4} ms", - duration.as_secs_f64() * 1000.0, - ); - - // Exit code - 0 -} From 3a35fe55cfea96d0aed60e3706d6215a81a0a702 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 27 May 2021 18:09:01 -0400 Subject: [PATCH 022/496] Combine two conditionals, rename some stuff --- compiler/build/src/program.rs | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/compiler/build/src/program.rs b/compiler/build/src/program.rs index 3fad005f6e..afdfcbaf38 100644 --- a/compiler/build/src/program.rs +++ b/compiler/build/src/program.rs @@ -100,20 +100,22 @@ pub fn gen_from_mono_module( let kind_id = Attribute::get_named_enum_kind_id("alwaysinline"); debug_assert!(kind_id > 0); - let attr = context.create_enum_attribute(kind_id, 1); + let enum_attr = context.create_enum_attribute(kind_id, 1); for function in FunctionIterator::from_module(module) { let name = function.get_name().to_str().unwrap(); + + // mark our zig-defined builtins as internal if name.starts_with("roc_builtins") { function.set_linkage(Linkage::Internal); } - if name.starts_with("roc_builtins.dict") || name.starts_with("dict.RocDict") { - function.add_attribute(AttributeLoc::Function, attr); - } - - if name.starts_with("roc_builtins.list") || name.starts_with("list.RocList") { - function.add_attribute(AttributeLoc::Function, attr); + if name.starts_with("roc_builtins.dict") + || name.starts_with("dict.RocDict") + || name.starts_with("roc_builtins.list") + || name.starts_with("list.RocList") + { + function.add_attribute(AttributeLoc::Function, enum_attr); } } From 4af5cda91d201a3133bd2c609d68418d3f3f8997 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 27 May 2021 18:09:16 -0400 Subject: [PATCH 023/496] Reuse a variable instead of duplicating strings --- compiler/gen/src/llvm/build.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/compiler/gen/src/llvm/build.rs b/compiler/gen/src/llvm/build.rs index ed34bfc104..41dacb9476 100644 --- a/compiler/gen/src/llvm/build.rs +++ b/compiler/gen/src/llvm/build.rs @@ -5791,7 +5791,7 @@ fn get_gxx_personality_v0<'a, 'ctx, 'env>(env: &Env<'a, 'ctx, 'env>) -> Function None => { let personality_func = add_func( module, - "__gxx_personality_v0", + name, context.i64_type().fn_type(&[], false), Linkage::External, C_CALL_CONV, @@ -5843,7 +5843,7 @@ fn cxa_begin_catch<'a, 'ctx, 'env>( let cxa_begin_catch = add_func( module, - "__cxa_begin_catch", + name, u8_ptr.fn_type(&[u8_ptr.into()], false), Linkage::External, C_CALL_CONV, From 2c0b52dd6fd59202dd3c7a5d488fe64b920aa573 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 27 May 2021 21:57:35 -0400 Subject: [PATCH 024/496] Fix mono test --- compiler/mono/tests/test_mono.rs | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/compiler/mono/tests/test_mono.rs b/compiler/mono/tests/test_mono.rs index ce1f0bac7e..9924474515 100644 --- a/compiler/mono/tests/test_mono.rs +++ b/compiler/mono/tests/test_mono.rs @@ -270,11 +270,12 @@ mod test_mono { indoc!( r#" procedure Test.0 (): - let Test.11 = 1i64; - let Test.9 = 1i64; - let Test.10 = 2i64; - let Test.5 = These Test.11 Test.9 Test.10; - switch Test.5: + let Test.12 = 1i64; + let Test.10 = 1i64; + let Test.11 = 2i64; + let Test.5 = These Test.12 Test.10 Test.11; + let Test.9 = Index 0 Test.5; + switch Test.9: case 2: let Test.2 = Index 1 Test.5; ret Test.2; From 0589735ff24ef2f4e5dc12421b01522570d61281 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 27 May 2021 18:08:47 -0400 Subject: [PATCH 025/496] Fix typo --- BUILDING_FROM_SOURCE.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/BUILDING_FROM_SOURCE.md b/BUILDING_FROM_SOURCE.md index b2f92c10cf..8b4e627883 100644 --- a/BUILDING_FROM_SOURCE.md +++ b/BUILDING_FROM_SOURCE.md @@ -20,7 +20,7 @@ For debugging LLVM IR, we use [DebugIR](https://github.com/vaivaswatha/debugir). ### libunwind & libc++-dev -MacOS systems should already have `libunwind`, but other systems will need to install it (On Ubuntu, this can be donw with `sudo apt-get install libunwind-dev`). +MacOS systems should already have `libunwind`, but other systems will need to install it (On Ubuntu, this can be done with `sudo apt-get install libunwind-dev`). Some systems may already have `libc++-dev` on them, but if not, you may need to install it. (On Ubuntu, this can be done with `sudo apt-get install libc++-dev`.) ### libcxb libraries From 05645088b754edd502a99ff37889d3837b26ea41 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Fri, 28 May 2021 15:08:46 +0200 Subject: [PATCH 026/496] run benchmarks with input --- Cargo.lock | 241 ++++++++---------------------- Earthfile | 2 +- cli/Cargo.toml | 13 +- cli/benches/events_bench.rs | 32 ++-- cli/benches/time_bench.rs | 11 +- cli/cli_utils/src/bench_utils.rs | 43 ++---- cli/tests/cli_run.rs | 9 +- examples/benchmarks/CFold.roc | 17 ++- examples/benchmarks/Deriv.roc | 13 +- examples/benchmarks/NQueens.roc | 2 +- examples/benchmarks/RBTreeCk.roc | 21 +-- examples/benchmarks/RBTreeDel.roc | 12 +- 12 files changed, 144 insertions(+), 272 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 28b2f84ced..bf57eabce5 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1,5 +1,7 @@ # This file is automatically @generated by Cargo. # It is not intended for manual editing. +version = 3 + [[package]] name = "ab_glyph" version = "0.2.10" @@ -45,7 +47,7 @@ checksum = "7f200cbb1e856866d9eade941cf3aa0c5d7dd36f74311c4273b494f4ef036957" dependencies = [ "getrandom 0.2.2", "once_cell", - "version_check 0.9.3", + "version_check", ] [[package]] @@ -135,7 +137,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8" dependencies = [ "hermit-abi", - "libc 0.2.93", + "libc", "winapi 0.3.9", ] @@ -159,7 +161,7 @@ checksum = "9d117600f438b1707d4e4ae15d3595657288f8235a0eb593e80ecc98ab34e1bc" dependencies = [ "addr2line", "cfg-if 1.0.0", - "libc 0.2.93", + "libc", "miniz_oxide", "object 0.23.0", "rustc-demangle", @@ -180,12 +182,6 @@ version = "0.6.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb" -[[package]] -name = "bit_field" -version = "0.10.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dcb6dd1c2376d2e096796e234a70e17e94cc2d5d54ff8ce42b28cef1d0d359a4" - [[package]] name = "bitflags" version = "1.2.1" @@ -428,7 +424,7 @@ dependencies = [ "core-foundation 0.9.1", "core-graphics 0.22.2", "foreign-types", - "libc 0.2.93", + "libc", "objc", ] @@ -443,7 +439,7 @@ dependencies = [ "core-foundation 0.9.1", "core-graphics-types", "foreign-types", - "libc 0.2.93", + "libc", "objc", ] @@ -515,7 +511,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "57d24c7a13c43e870e37c1556b74555437870a04514f7685f5b354e090567171" dependencies = [ "core-foundation-sys 0.7.0", - "libc 0.2.93", + "libc", ] [[package]] @@ -525,7 +521,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0a89e2ae426ea83155dccf10c0fa6b1463ef6d5fcb44cee0b224a408fa640a62" dependencies = [ "core-foundation-sys 0.8.2", - "libc 0.2.93", + "libc", ] [[package]] @@ -549,7 +545,7 @@ dependencies = [ "bitflags", "core-foundation 0.7.0", "foreign-types", - "libc 0.2.93", + "libc", ] [[package]] @@ -562,7 +558,7 @@ dependencies = [ "core-foundation 0.9.1", "core-graphics-types", "foreign-types", - "libc 0.2.93", + "libc", ] [[package]] @@ -574,7 +570,7 @@ dependencies = [ "bitflags", "core-foundation 0.9.1", "foreign-types", - "libc 0.2.93", + "libc", ] [[package]] @@ -586,7 +582,7 @@ dependencies = [ "cfg-if 0.1.10", "core-foundation-sys 0.7.0", "core-graphics 0.19.2", - "libc 0.2.93", + "libc", "objc", ] @@ -625,16 +621,6 @@ dependencies = [ "walkdir", ] -[[package]] -name = "criterion-perf-events" -version = "0.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e28da8efb44be0b107d9a983d01984e26362249dc30961a2ed3859606d8ddfe1" -dependencies = [ - "criterion", - "perfcnt", -] - [[package]] name = "criterion-plot" version = "0.4.3" @@ -892,7 +878,7 @@ version = "0.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d" dependencies = [ - "libc 0.2.93", + "libc", "redox_users", "winapi 0.3.9", ] @@ -1000,7 +986,7 @@ checksum = "cd3aec53de10fe96d7d8c565eb17f2c687bb5518a2ec453b5b1252964526abe0" dependencies = [ "cfg-if 1.0.0", "crc32fast", - "libc 0.2.93", + "libc", "miniz_oxide", ] @@ -1164,7 +1150,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce" dependencies = [ "cfg-if 1.0.0", - "libc 0.2.93", + "libc", "wasi 0.9.0+wasi-snapshot-preview1", ] @@ -1175,7 +1161,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c9495705279e7140bf035dde1f6e750c162df8b625267cd52cc44e0b156732c8" dependencies = [ "cfg-if 1.0.0", - "libc 0.2.93", + "libc", "wasi 0.10.2+wasi-snapshot-preview1", ] @@ -1463,7 +1449,7 @@ version = "0.1.18" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "322f4de77956e22ed0e5032c359a0f1273f1f7f0d79bfa3b8ffbc730d7fbcc5c" dependencies = [ - "libc 0.2.93", + "libc", ] [[package]] @@ -1472,12 +1458,6 @@ version = "2.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4" -[[package]] -name = "iai" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "71a816c97c42258aa5834d07590b718b4c9a598944cd39a52dc25b351185d678" - [[package]] name = "ident_case" version = "1.0.1" @@ -1495,7 +1475,7 @@ dependencies = [ "rand_xoshiro", "sized-chunks 0.5.3", "typenum", - "version_check 0.9.3", + "version_check", ] [[package]] @@ -1509,7 +1489,7 @@ dependencies = [ "rand_xoshiro", "sized-chunks 0.6.4", "typenum", - "version_check 0.9.3", + "version_check", ] [[package]] @@ -1523,7 +1503,7 @@ dependencies = [ "rand_xoshiro", "sized-chunks 0.5.3", "typenum", - "version_check 0.9.3", + "version_check", ] [[package]] @@ -1537,7 +1517,7 @@ dependencies = [ "rand_xoshiro", "sized-chunks 0.6.4", "typenum", - "version_check 0.9.3", + "version_check", ] [[package]] @@ -1589,7 +1569,7 @@ source = "git+https://github.com/rtfeldman/inkwell?tag=llvm10-0.release4#9ae45f0 dependencies = [ "either", "inkwell_internals", - "libc 0.2.93", + "libc", "llvm-sys", "once_cell", "parking_lot", @@ -1633,7 +1613,7 @@ version = "0.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b2b3ea6ff95e175473f8ffe6a7eb7c00d054240321b84c57051175fe3c1e075e" dependencies = [ - "libc 0.2.93", + "libc", ] [[package]] @@ -1672,7 +1652,7 @@ version = "0.1.21" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5c71313ebb9439f74b00d9d2dcec36440beaf57a6aa0623068441dd7cd81a7f2" dependencies = [ - "libc 0.2.93", + "libc", ] [[package]] @@ -1700,7 +1680,7 @@ version = "3.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b19cc4a81304db2a0ad69740e83cdc3a9364e3f9bd6d88a87288a4c2deec927b" dependencies = [ - "libc 0.2.93", + "libc", "libloading 0.6.7", ] @@ -1722,12 +1702,6 @@ version = "1.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55" -[[package]] -name = "libc" -version = "0.1.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e32a70cf75e5846d53a673923498228bbec6a8624708a9ea5645f075d6276122" - [[package]] name = "libc" version = "0.2.93" @@ -1768,7 +1742,7 @@ checksum = "15d9c00ce56221b2150e2d4d51887ff139fce5a0e50346c744861d1e66d2f7c4" dependencies = [ "cc", "lazy_static", - "libc 0.2.93", + "libc", "regex", "semver", ] @@ -1797,7 +1771,7 @@ version = "0.0.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "62bb907fe88d54d8d9ce32a3cceab4218ed2f6b7d35617cafe9adf84e43919cb" dependencies = [ - "libc 0.2.93", + "libc", ] [[package]] @@ -1824,7 +1798,7 @@ version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d9b70ca2a6103ac8b665dc150b142ef0e4e89df640c9e6cf295d189c3caebe5a" dependencies = [ - "libc 0.2.93", + "libc", ] [[package]] @@ -1880,7 +1854,7 @@ dependencies = [ "fuchsia-zircon-sys", "iovec", "kernel32-sys", - "libc 0.2.93", + "libc", "log", "miow", "net2", @@ -1912,16 +1886,6 @@ dependencies = [ "ws2_32-sys", ] -[[package]] -name = "mmap" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0bc85448a6006dd2ba26a385a564a8a0f1f2c7e78c70f1a70b2e0f4af286b823" -dependencies = [ - "libc 0.1.12", - "tempdir", -] - [[package]] name = "naga" version = "0.3.2" @@ -1957,7 +1921,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bdf399b8b7a39c6fb153c4ec32c72fd5fe789df24a647f229c239aa7adb15241" dependencies = [ "lazy_static", - "libc 0.2.93", + "libc", "log", "ndk", "ndk-macro", @@ -1990,7 +1954,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "391630d12b68002ae1e25e8f974306474966550ad82dac6886fb8910c19568ae" dependencies = [ "cfg-if 0.1.10", - "libc 0.2.93", + "libc", "winapi 0.3.9", ] @@ -2003,7 +1967,7 @@ dependencies = [ "bitflags", "cc", "cfg-if 0.1.10", - "libc 0.2.93", + "libc", "void", ] @@ -2016,7 +1980,7 @@ dependencies = [ "bitflags", "cc", "cfg-if 0.1.10", - "libc 0.2.93", + "libc", ] [[package]] @@ -2028,17 +1992,7 @@ dependencies = [ "bitflags", "cc", "cfg-if 1.0.0", - "libc 0.2.93", -] - -[[package]] -name = "nom" -version = "4.2.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2ad2a91a8e869eeb30b9cb3119ae87773a8f4ae617f41b1eb9c154b2905f7bd6" -dependencies = [ - "memchr", - "version_check 0.1.5", + "libc", ] [[package]] @@ -2048,7 +2002,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e7413f999671bd4745a7b624bd370a569fb6bc574b23c83a3c5ed2e453f3d5e2" dependencies = [ "memchr", - "version_check 0.9.3", + "version_check", ] [[package]] @@ -2073,7 +2027,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "05499f3756671c15885fee9034446956fff3f243d6077b91e5767df161f766b3" dependencies = [ "hermit-abi", - "libc 0.2.93", + "libc", ] [[package]] @@ -2215,7 +2169,7 @@ version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "eebde548fbbf1ea81a99b128872779c437752fb99f217c45245e1a61dcd9edcd" dependencies = [ - "libc 0.2.93", + "libc", "winapi 0.3.9", ] @@ -2263,7 +2217,7 @@ dependencies = [ "backtrace", "cfg-if 1.0.0", "instant", - "libc 0.2.93", + "libc", "petgraph", "redox_syscall 0.2.5", "smallvec", @@ -2277,21 +2231,6 @@ version = "2.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e" -[[package]] -name = "perfcnt" -version = "0.7.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "88a4decf2d171c232d741ca37d590cd50d35314b7d348198e7e474e0bf34c8b4" -dependencies = [ - "bitflags", - "byteorder", - "libc 0.2.93", - "mmap", - "nom 4.2.3", - "phf", - "x86", -] - [[package]] name = "pest" version = "2.1.3" @@ -2482,7 +2421,7 @@ dependencies = [ "proc-macro2 1.0.26", "quote 1.0.9", "syn 1.0.65", - "version_check 0.9.3", + "version_check", ] [[package]] @@ -2495,7 +2434,7 @@ dependencies = [ "quote 1.0.9", "syn 1.0.65", "syn-mid", - "version_check 0.9.3", + "version_check", ] [[package]] @@ -2602,19 +2541,6 @@ dependencies = [ "proc-macro2 1.0.26", ] -[[package]] -name = "rand" -version = "0.4.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "552840b97013b1a26992c11eac34bdd778e464601a4c2054b5f0bff7c6761293" -dependencies = [ - "fuchsia-cprng", - "libc 0.2.93", - "rand_core 0.3.1", - "rdrand", - "winapi 0.3.9", -] - [[package]] name = "rand" version = "0.6.5" @@ -2622,7 +2548,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6d71dacdc3c88c1fde3885a3be3fbab9f35724e6ce99467f7d9c5026132184ca" dependencies = [ "autocfg 0.1.7", - "libc 0.2.93", + "libc", "rand_chacha 0.1.1", "rand_core 0.4.2", "rand_hc 0.1.0", @@ -2641,7 +2567,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03" dependencies = [ "getrandom 0.1.16", - "libc 0.2.93", + "libc", "rand_chacha 0.2.2", "rand_core 0.5.1", "rand_hc 0.2.0", @@ -2654,7 +2580,7 @@ version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0ef9e7e66b4468674bfcb0c81af8b7fa0bb154fa9f28eb840da5c447baeb8d7e" dependencies = [ - "libc 0.2.93", + "libc", "rand_chacha 0.3.0", "rand_core 0.6.2", "rand_hc 0.3.0", @@ -2765,7 +2691,7 @@ version = "0.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1166d5c91dc97b88d1decc3285bb0a99ed84b05cfd0bc2341bdf2d43fc41e39b" dependencies = [ - "libc 0.2.93", + "libc", "rand_core 0.4.2", "winapi 0.3.9", ] @@ -2778,7 +2704,7 @@ checksum = "7b75f676a1e053fc562eafbb47838d67c84801e38fc1ba459e8f180deabd5071" dependencies = [ "cloudabi", "fuchsia-cprng", - "libc 0.2.93", + "libc", "rand_core 0.4.2", "rdrand", "winapi 0.3.9", @@ -2827,22 +2753,13 @@ version = "0.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "63e935c45e09cc6dcf00d2f0b2d630a58f4095320223d47fc68918722f0538b6" -[[package]] -name = "raw-cpuid" -version = "9.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c27cb5785b85bd05d4eb171556c9a1a514552e26123aeae6bb7d811353148026" -dependencies = [ - "bitflags", -] - [[package]] name = "raw-window-handle" version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0a441a7a6c80ad6473bd4b74ec1c9a4c951794285bf941c2126f607c72e48211" dependencies = [ - "libc 0.2.93", + "libc", ] [[package]] @@ -3021,17 +2938,14 @@ dependencies = [ "cli_utils", "const_format", "criterion", - "criterion-perf-events", - "iai", "im 14.3.0", "im-rc 14.3.0", "indoc 0.3.6", "inkwell", "inlinable_string", - "libc 0.2.93", + "libc", "libloading 0.6.7", "maplit", - "perfcnt", "pretty_assertions 0.5.1", "quickcheck 0.8.5", "quickcheck_macros 0.8.0", @@ -3126,7 +3040,7 @@ dependencies = [ "im-rc 15.0.0", "indoc 1.0.3", "inlinable_string", - "libc 0.2.93", + "libc", "log", "maplit", "nonempty", @@ -3189,7 +3103,7 @@ dependencies = [ "indoc 0.3.6", "inkwell", "inlinable_string", - "libc 0.2.93", + "libc", "maplit", "pretty_assertions 0.5.1", "quickcheck 0.8.5", @@ -3223,7 +3137,7 @@ dependencies = [ "indoc 0.3.6", "inlinable_string", "itertools 0.9.0", - "libc 0.2.93", + "libc", "libloading 0.6.7", "maplit", "object 0.22.0", @@ -3415,7 +3329,7 @@ dependencies = [ name = "roc_std" version = "0.1.0" dependencies = [ - "libc 0.2.93", + "libc", ] [[package]] @@ -3495,7 +3409,7 @@ source = "git+https://github.com/rtfeldman/rustyline?tag=prompt-fix#a6b8a20d2bf5 dependencies = [ "cfg-if 0.1.10", "dirs-next", - "libc 0.2.93", + "libc", "log", "memchr", "nix 0.17.0", @@ -3853,16 +3767,6 @@ version = "0.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ab0e7238dcc7b40a7be719a25365910f6807bd864f4cce6b2e6b873658e2b19d" -[[package]] -name = "tempdir" -version = "0.3.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "15f2b5fb00ccdf689e0149d1b1b3c03fead81c2b37735d812fa8bddbbf41b6d8" -dependencies = [ - "rand 0.4.6", - "remove_dir_all", -] - [[package]] name = "tempfile" version = "3.2.0" @@ -3870,7 +3774,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "dac1c663cfc93810f88aed9b8941d48cabf856a1b111c29a40439018d870eb22" dependencies = [ "cfg-if 1.0.0", - "libc 0.2.93", + "libc", "rand 0.8.3", "redox_syscall 0.2.5", "remove_dir_all", @@ -3897,7 +3801,7 @@ dependencies = [ "indoc 0.3.6", "inkwell", "inlinable_string", - "libc 0.2.93", + "libc", "libloading 0.6.7", "maplit", "quickcheck 0.8.5", @@ -3958,7 +3862,7 @@ version = "3.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c7fbf4c9d56b320106cd64fd024dadfa0be7cb4706725fc44a7d7ce952d820c1" dependencies = [ - "libc 0.2.93", + "libc", "redox_syscall 0.1.57", "winapi 0.3.9", ] @@ -4081,7 +3985,7 @@ version = "2.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "50f37be617794602aabbeee0be4f259dc1778fabe05e2d67ee8f79326d5cb4f6" dependencies = [ - "version_check 0.9.3", + "version_check", ] [[package]] @@ -4158,12 +4062,6 @@ dependencies = [ "typed-arena", ] -[[package]] -name = "version_check" -version = "0.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "914b1a6776c4c929a602fafd8bc742e06365d4bcbe48c30f9cca5824f70dc9dd" - [[package]] name = "version_check" version = "0.9.3" @@ -4288,7 +4186,7 @@ checksum = "06ca44d86554b85cf449f1557edc6cc7da935cc748c8e4bf1c507cbd43bae02c" dependencies = [ "bitflags", "downcast-rs", - "libc 0.2.93", + "libc", "nix 0.20.0", "scoped-tls", "wayland-commons", @@ -4491,7 +4389,7 @@ dependencies = [ "dispatch", "instant", "lazy_static", - "libc 0.2.93", + "libc", "log", "mio", "mio-extras", @@ -4552,33 +4450,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2bf981e3a5b3301209754218f962052d4d9ee97e478f4d26d4a6eced34c1fef8" dependencies = [ "lazy_static", - "libc 0.2.93", + "libc", "maybe-uninit", "pkg-config", ] -[[package]] -name = "x86" -version = "0.37.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b4fd9298cd1b1f88546fc0a5e8faa3354013cd010589299c624fde436aad76cc" -dependencies = [ - "bit_field", - "bitflags", - "csv", - "phf", - "phf_codegen", - "raw-cpuid", - "serde_json", -] - [[package]] name = "xcb" version = "0.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "62056f63138b39116f82a540c983cc11f1c90cd70b3d492a70c25eaa50bd22a6" dependencies = [ - "libc 0.2.93", + "libc", "log", ] @@ -4588,7 +4471,7 @@ version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3a9a231574ae78801646617cefd13bfe94be907c0e4fa979cfd8b770aa3c5d08" dependencies = [ - "nom 6.1.2", + "nom", ] [[package]] diff --git a/Earthfile b/Earthfile index 09df7968cf..63e754e0c0 100644 --- a/Earthfile +++ b/Earthfile @@ -116,5 +116,5 @@ bench-roc: ENV RUST_BACKTRACE=full RUN cargo criterion -V RUN --privileged --mount=type=cache,target=$SCCACHE_DIR \ - cd cli && cargo bench instructions_bench && cargo criterion --bench time_bench && sccache --show-stats + cd cli && cargo criterion && sccache --show-stats diff --git a/cli/Cargo.toml b/cli/Cargo.toml index b8cf3bc3a0..98cd4790e8 100644 --- a/cli/Cargo.toml +++ b/cli/Cargo.toml @@ -96,14 +96,15 @@ serial_test = "0.5" tempfile = "3.1.0" criterion = "0.3.4" cli_utils = { path = "cli_utils" } -iai = "0.1" -criterion-perf-events = "0.1.3" -perfcnt = "0.7.1" +# Keep the commented deps, they are commented because they require nightly rust +# criterion-perf-events = "0.1.3" +# perfcnt = "0.7.1" [[bench]] name = "time_bench" harness = false -[[bench]] -name = "events_bench" -harness = false +# Keep this benchmark, it's commented because it requires nightly +# [[bench]] +# name = "events_bench" +# harness = false diff --git a/cli/benches/events_bench.rs b/cli/benches/events_bench.rs index a6ee310a67..8c56d058a2 100644 --- a/cli/benches/events_bench.rs +++ b/cli/benches/events_bench.rs @@ -1,14 +1,12 @@ -use cli_utils::bench_utils::{ - bench_cfold, bench_deriv, bench_nqueens, - bench_rbtree_ck, bench_rbtree_delete, +// Keep this benchmark. It's commented because it requires nightly rust. +/*use cli_utils::bench_utils::{ + bench_cfold, bench_deriv, bench_nqueens, bench_rbtree_ck, bench_rbtree_delete, }; use criterion_perf_events::Perf; use perfcnt::linux::HardwareEventType as Hardware; use perfcnt::linux::PerfCounterBuilderLinux as Builder; -use criterion::{ - criterion_group, criterion_main, BenchmarkGroup, Criterion, SamplingMode, -}; +use criterion::{criterion_group, criterion_main, BenchmarkGroup, Criterion, SamplingMode}; fn bench_group(c: &mut Criterion, hw_event_str: &str) { let mut group = c.benchmark_group(format!("bench-group_no-opt_{}", hw_event_str)); @@ -17,10 +15,10 @@ fn bench_group(c: &mut Criterion, hw_event_str: &str) { let bench_funcs: Vec>) -> ()> = vec![ bench_nqueens, - /*bench_cfold, + bench_cfold, bench_deriv, - bench_rbtree, - bench_rbtree_delete,*/ + bench_rbtree_ck, + bench_rbtree_delete, // TODO quicksort ]; @@ -34,12 +32,7 @@ fn bench_group(c: &mut Criterion, hw_event_str: &str) { use perfcnt::linux::HardwareEventType; fn init_criterion(event: HardwareEventType) -> Criterion { - Criterion::default() - .with_measurement( - Perf::new( - Builder::from_hardware_event(event) - ) - ) + Criterion::default().with_measurement(Perf::new(Builder::from_hardware_event(event))) } fn bench_instructions(c: &mut Criterion) { @@ -92,5 +85,10 @@ criterion_group!( targets = bench_branch_misses ); -criterion_main!(benches_instructions, benches_cache_refs, benches_cache_misses, benches_branch_instructions, benches_branch_misses); - +criterion_main!( + benches_instructions, + benches_cache_refs, + benches_cache_misses, + benches_branch_instructions, + benches_branch_misses +);*/ diff --git a/cli/benches/time_bench.rs b/cli/benches/time_bench.rs index 2d564b8ff1..3923d83eb4 100644 --- a/cli/benches/time_bench.rs +++ b/cli/benches/time_bench.rs @@ -1,6 +1,5 @@ use cli_utils::bench_utils::{ - bench_cfold, bench_deriv, bench_nqueens, - bench_rbtree_ck, bench_rbtree_delete, + bench_cfold, bench_deriv, bench_nqueens, bench_rbtree_ck, bench_rbtree_delete, }; use criterion::{ criterion_group, criterion_main, measurement::WallTime, BenchmarkGroup, Criterion, SamplingMode, @@ -13,12 +12,12 @@ fn bench_group_wall_time(c: &mut Criterion) { group.sample_size(200); let bench_funcs: Vec>) -> ()> = vec![ - bench_nqueens, // 11 - bench_cfold, // e = mkExpr 12 1 - bench_deriv, // nest deriv 7 f + bench_nqueens, // queens 11 + bench_cfold, // e = mkExpr 12 1 + bench_deriv, // nest deriv 7 f bench_rbtree_ck, // ms = makeMap 5 5600 bench_rbtree_delete, // m = makeMap 6000 - // TODO quicksort + // TODO quicksort ]; for bench_func in bench_funcs.iter() { diff --git a/cli/cli_utils/src/bench_utils.rs b/cli/cli_utils/src/bench_utils.rs index 141823184d..a1cae5e257 100644 --- a/cli/cli_utils/src/bench_utils.rs +++ b/cli/cli_utils/src/bench_utils.rs @@ -1,33 +1,15 @@ use crate::helpers::{example_file, run_cmd, run_roc}; -use criterion::{BenchmarkGroup, black_box, measurement::{Measurement, WallTime}}; +use criterion::{black_box, measurement::Measurement, BenchmarkGroup}; use std::path::Path; -// run without optimization, without input -fn exec_bench_simple( - file: &Path, - executable_filename: &str, - expected_ending: &str, - bench_group_opt: Option<&mut BenchmarkGroup>, -) { - exec_bench_w_input( - file, - "", - executable_filename, - expected_ending, - true, - bench_group_opt, - ) -} - fn exec_bench_w_input( file: &Path, stdin_str: &str, executable_filename: &str, expected_ending: &str, - run_optimized: bool, bench_group_opt: Option<&mut BenchmarkGroup>, ) { - let flags: &[&str] = if run_optimized { &["--optimize"] } else { &[] }; + let flags: &[&str] = &["--optimize"]; let compile_out = run_roc(&[&["build", file.to_str().unwrap()], flags].concat()); @@ -98,41 +80,44 @@ pub fn bench_nqueens(bench_group_opt: Option<&mut BenchmarkGroup "11", "nqueens", "2680\n", - true, bench_group_opt, ); } -pub fn bench_cfold(bench_group_opt: Option<&mut BenchmarkGroup>) { - exec_bench_simple( +pub fn bench_cfold(bench_group_opt: Option<&mut BenchmarkGroup>) { + exec_bench_w_input( &example_file("benchmarks", "CFold.roc"), + "12", "cfold", "10426 & 10426\n", bench_group_opt, ); } -pub fn bench_deriv(bench_group_opt: Option<&mut BenchmarkGroup>) { - exec_bench_simple( +pub fn bench_deriv(bench_group_opt: Option<&mut BenchmarkGroup>) { + exec_bench_w_input( &example_file("benchmarks", "Deriv.roc"), + "7", "deriv", "1 count: 6\n2 count: 22\n3 count: 90\n4 count: 420\n5 count: 2202\n6 count: 12886\n7 count: 83648\n", bench_group_opt, ); } -pub fn bench_rbtree_ck(bench_group_opt: Option<&mut BenchmarkGroup>) { - exec_bench_simple( +pub fn bench_rbtree_ck(bench_group_opt: Option<&mut BenchmarkGroup>) { + exec_bench_w_input( &example_file("benchmarks", "RBTreeCk.roc"), + "5600", "rbtree-ck", "560\n", bench_group_opt, ); } -pub fn bench_rbtree_delete(bench_group_opt: Option<&mut BenchmarkGroup>) { - exec_bench_simple( +pub fn bench_rbtree_delete(bench_group_opt: Option<&mut BenchmarkGroup>) { + exec_bench_w_input( &example_file("benchmarks", "RBTreeDel.roc"), + "6000", "rbtree-del", "420\n", bench_group_opt, diff --git a/cli/tests/cli_run.rs b/cli/tests/cli_run.rs index c5cfd8bf39..1d139a9eae 100644 --- a/cli/tests/cli_run.rs +++ b/cli/tests/cli_run.rs @@ -190,8 +190,9 @@ mod cli_run { #[test] #[serial(cfold)] fn run_cfold_not_optimized() { - check_output( + check_output_with_stdin( &example_file("benchmarks", "CFold.roc"), + "3", "cfold", &[], "11 & 11\n", @@ -202,8 +203,9 @@ mod cli_run { #[test] #[serial(deriv)] fn run_deriv_not_optimized() { - check_output( + check_output_with_stdin( &example_file("benchmarks", "Deriv.roc"), + "2", "deriv", &[], "1 count: 6\n2 count: 22\n", @@ -226,8 +228,9 @@ mod cli_run { #[test] #[serial(deriv)] fn run_rbtree_delete_not_optimized() { - check_output( + check_output_with_stdin( &example_file("benchmarks", "RBTreeDel.roc"), + "420", "rbtree-del", &[], "30\n", diff --git a/examples/benchmarks/CFold.roc b/examples/benchmarks/CFold.roc index 38d6345325..725ae79b9b 100644 --- a/examples/benchmarks/CFold.roc +++ b/examples/benchmarks/CFold.roc @@ -7,15 +7,16 @@ app "cfold" main : Task.Task {} [] main = - e = mkExpr 12 1 - unoptimized = eval e - optimized = eval (constFolding (reassoc e)) + Task.after Task.getInt \n -> + e = mkExpr n 1 # original koka n = 20 (set `ulimit -s unlimited` to avoid stack overflow for n = 20) + unoptimized = eval e + optimized = eval (constFolding (reassoc e)) - unoptimized - |> Str.fromInt - |> Str.concat " & " - |> Str.concat (Str.fromInt optimized) - |> Task.putLine + unoptimized + |> Str.fromInt + |> Str.concat " & " + |> Str.concat (Str.fromInt optimized) + |> Task.putLine Expr : [ Add Expr Expr, diff --git a/examples/benchmarks/Deriv.roc b/examples/benchmarks/Deriv.roc index da9b77acad..cd8e5fd800 100644 --- a/examples/benchmarks/Deriv.roc +++ b/examples/benchmarks/Deriv.roc @@ -9,14 +9,15 @@ IO a : Task.Task a [] main : IO {} main = - x : Expr - x = Var "x" + Task.after Task.getInt \n -> + x : Expr + x = Var "x" - f : Expr - f = pow x x + f : Expr + f = pow x x - nest deriv 7 f - |> Task.map (\_ -> {}) + nest deriv n f # original koka n = 10 + |> Task.map (\_ -> {}) Expr : [ Val I64, Var Str, Add Expr Expr, Mul Expr Expr, Pow Expr Expr, Ln Expr ] diff --git a/examples/benchmarks/NQueens.roc b/examples/benchmarks/NQueens.roc index e1f8443159..7435e52f2c 100644 --- a/examples/benchmarks/NQueens.roc +++ b/examples/benchmarks/NQueens.roc @@ -6,7 +6,7 @@ app "nqueens" main : Task.Task {} [] main = Task.after Task.getInt \n -> - queens n + queens n # original koka 13 |> Str.fromInt |> Task.putLine diff --git a/examples/benchmarks/RBTreeCk.roc b/examples/benchmarks/RBTreeCk.roc index fee17c4159..c9595875ec 100644 --- a/examples/benchmarks/RBTreeCk.roc +++ b/examples/benchmarks/RBTreeCk.roc @@ -47,18 +47,19 @@ resultWithDefault = \res, default -> main : Task.Task {} [] main = - ms : ConsList Map - ms = makeMap 5 5600 # 4_200_000 + Task.after Task.getInt \n -> + ms : ConsList Map + ms = makeMap 5 n # original koka n = 4_200_000 - when ms is - Cons head _ -> - val = fold (\_, v, r -> if v then r + 1 else r) head 0 - val - |> Str.fromInt - |> Task.putLine + when ms is + Cons head _ -> + val = fold (\_, v, r -> if v then r + 1 else r) head 0 + val + |> Str.fromInt + |> Task.putLine - Nil -> - Task.putLine "fail" + Nil -> + Task.putLine "fail" insert : Tree (Num k) v, (Num k), v -> Tree (Num k) v insert = \t, k, v -> if isRed t then setBlack (ins t k v) else ins t k v diff --git a/examples/benchmarks/RBTreeDel.roc b/examples/benchmarks/RBTreeDel.roc index 32104c5a23..d9b780fa39 100644 --- a/examples/benchmarks/RBTreeDel.roc +++ b/examples/benchmarks/RBTreeDel.roc @@ -14,14 +14,14 @@ ConsList a : [ Nil, Cons a (ConsList a) ] main : Task.Task {} [] main = - # benchmarks use 4_200_000 - m = makeMap 6000 + Task.after Task.getInt \n -> + m = makeMap n # koka original n = 4_200_000 - val = fold (\_, v, r -> if v then r + 1 else r) m 0 + val = fold (\_, v, r -> if v then r + 1 else r) m 0 - val - |> Str.fromInt - |> Task.putLine + val + |> Str.fromInt + |> Task.putLine boom : Str -> a boom = \_ -> boom "" From 4739b5db913b1dc1cb33991630986b2ad66fcc61 Mon Sep 17 00:00:00 2001 From: rvcas Date: Fri, 28 May 2021 12:57:45 -0400 Subject: [PATCH 027/496] test: add a test to contrain if expr --- editor/tests/solve_expr2.rs | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/editor/tests/solve_expr2.rs b/editor/tests/solve_expr2.rs index 4685f3e2bb..699f5fa3a7 100644 --- a/editor/tests/solve_expr2.rs +++ b/editor/tests/solve_expr2.rs @@ -274,3 +274,15 @@ fn constrain_access() { "Str", ) } + +#[test] +fn constrain_if() { + infer_eq( + indoc!( + r#" + if True then Green else Red + "# + ), + "[ Green, Red ]*", + ) +} From 695a5a7aa98130a871a58ab6cde358b62fdc0e2d Mon Sep 17 00:00:00 2001 From: rvcas Date: Fri, 28 May 2021 13:01:01 -0400 Subject: [PATCH 028/496] fix: made if branches smaller --- editor/src/lang/ast.rs | 8 ++++---- editor/src/lang/expr.rs | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/editor/src/lang/ast.rs b/editor/src/lang/ast.rs index 87c4ed6e9e..7b2c87095e 100644 --- a/editor/src/lang/ast.rs +++ b/editor/src/lang/ast.rs @@ -119,10 +119,10 @@ pub enum Expr2 { elems: PoolVec, // 8B }, If { - cond_var: Variable, // 4B - expr_var: Variable, // 4B - branches: PoolVec<(Expr2, Expr2)>, // 8B - final_else: NodeId, // 4B + cond_var: Variable, // 4B + expr_var: Variable, // 4B + branches: PoolVec<(NodeId, NodeId)>, // 8B + final_else: NodeId, // 4B }, When { cond_var: Variable, // 4B diff --git a/editor/src/lang/expr.rs b/editor/src/lang/expr.rs index cd227fcf3f..6bd59b09ac 100644 --- a/editor/src/lang/expr.rs +++ b/editor/src/lang/expr.rs @@ -516,7 +516,7 @@ pub fn to_expr2<'a>( output.references.union_mut(cond_output.references); output.references.union_mut(then_output.references); - new_branches.push((cond, then_expr)); + new_branches.push((env.pool.add(cond), env.pool.add(then_expr))); } let (else_expr, else_output) = From 2e4696c3dfaa39dd3870948910d2fd60aaf0ef57 Mon Sep 17 00:00:00 2001 From: rvcas Date: Fri, 28 May 2021 13:03:01 -0400 Subject: [PATCH 029/496] chore: bring a type into scope --- editor/src/lang/constrain.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/editor/src/lang/constrain.rs b/editor/src/lang/constrain.rs index 2832cef8ac..af351606b8 100644 --- a/editor/src/lang/constrain.rs +++ b/editor/src/lang/constrain.rs @@ -13,7 +13,7 @@ use roc_module::{ident::TagName, symbol::Symbol}; use roc_region::all::{Located, Region}; use roc_types::{ subs::Variable, - types, + types::{self, AnnotationSource}, types::{Category, Reason}, }; From 4a93bbde18e8bf9bd6cef6a4f3eb471b24a1efcc Mon Sep 17 00:00:00 2001 From: rvcas Date: Fri, 28 May 2021 13:04:51 -0400 Subject: [PATCH 030/496] feat: implement if constraints --- editor/src/lang/constrain.rs | 151 +++++++++++++++++++++++++++++++++++ 1 file changed, 151 insertions(+) diff --git a/editor/src/lang/constrain.rs b/editor/src/lang/constrain.rs index af351606b8..8150d76638 100644 --- a/editor/src/lang/constrain.rs +++ b/editor/src/lang/constrain.rs @@ -479,6 +479,157 @@ pub fn constrain_expr<'a>( exists(arena, flex_vars, And(and_constraints)) } + Expr2::If { + cond_var, + expr_var, + branches, + final_else, + } => { + let expect_bool = |region| { + let bool_type = Type2::Variable(Variable::BOOL); + Expected::ForReason(Reason::IfCondition, bool_type, region) + }; + + let mut branch_cons = BumpVec::with_capacity_in(2 * branches.len() + 3, arena); + + // TODO why does this cond var exist? is it for error messages? + // let first_cond_region = branches[0].0.region; + let cond_var_is_bool_con = Eq( + Type2::Variable(*cond_var), + expect_bool(region), + Category::If, + region, + ); + + branch_cons.push(cond_var_is_bool_con); + + let final_else_expr = env.pool.get(*final_else); + + let mut flex_vars = BumpVec::with_capacity_in(2, arena); + + flex_vars.push(*cond_var); + flex_vars.push(*expr_var); + + match expected { + Expected::FromAnnotation(name, arity, _, tipe) => { + let num_branches = branches.len() + 1; + + for (index, branch_id) in branches.iter_node_ids().enumerate() { + let (cond_id, body_id) = env.pool.get(branch_id); + + let cond = env.pool.get(*cond_id); + let body = env.pool.get(*body_id); + + let cond_con = + constrain_expr(arena, env, cond, expect_bool(region), region); + + let then_con = constrain_expr( + arena, + env, + body, + Expected::FromAnnotation( + name.clone(), + arity, + AnnotationSource::TypedIfBranch { + index: Index::zero_based(index), + num_branches, + }, + tipe.shallow_clone(), + ), + region, + ); + + branch_cons.push(cond_con); + branch_cons.push(then_con); + } + + let else_con = constrain_expr( + arena, + env, + final_else_expr, + Expected::FromAnnotation( + name, + arity, + AnnotationSource::TypedIfBranch { + index: Index::zero_based(branches.len()), + num_branches, + }, + tipe.shallow_clone(), + ), + region, + ); + + let ast_con = Eq( + Type2::Variable(*expr_var), + Expected::NoExpectation(tipe), + Category::Storage(std::file!(), std::line!()), + region, + ); + + branch_cons.push(ast_con); + branch_cons.push(else_con); + + exists(arena, flex_vars, And(branch_cons)) + } + _ => { + for (index, branch_id) in branches.iter_node_ids().enumerate() { + let (cond_id, body_id) = env.pool.get(branch_id); + + let cond = env.pool.get(*cond_id); + let body = env.pool.get(*body_id); + + let cond_con = + constrain_expr(arena, env, cond, expect_bool(region), region); + + let then_con = constrain_expr( + arena, + env, + body, + Expected::ForReason( + Reason::IfBranch { + index: Index::zero_based(index), + total_branches: branches.len(), + }, + Type2::Variable(*expr_var), + // should be from body + region, + ), + region, + ); + + branch_cons.push(cond_con); + branch_cons.push(then_con); + } + + let else_con = constrain_expr( + arena, + env, + final_else_expr, + Expected::ForReason( + Reason::IfBranch { + index: Index::zero_based(branches.len()), + total_branches: branches.len() + 1, + }, + Type2::Variable(*expr_var), + // should come from final_else + region, + ), + region, + ); + + branch_cons.push(Eq( + Type2::Variable(*expr_var), + expected, + Category::Storage(std::file!(), std::line!()), + region, + )); + + branch_cons.push(else_con); + + exists(arena, flex_vars, And(branch_cons)) + } + } + } _ => todo!("implement constaints for {:?}", expr), } } From 1b3bbaf5de698f15fa620c30e53a572f861d9e07 Mon Sep 17 00:00:00 2001 From: Folkert Date: Fri, 28 May 2021 23:55:52 +0200 Subject: [PATCH 031/496] define one global static str --- compiler/module/src/symbol.rs | 1 + compiler/mono/src/alias_analysis.rs | 92 +++++++++-------------------- 2 files changed, 30 insertions(+), 63 deletions(-) diff --git a/compiler/module/src/symbol.rs b/compiler/module/src/symbol.rs index 90fc894970..4973426a68 100644 --- a/compiler/module/src/symbol.rs +++ b/compiler/module/src/symbol.rs @@ -904,6 +904,7 @@ define_builtins! { 14 STR_UT8_BYTE_PROBLEM: "Utf8ByteProblem" // the Utf8ByteProblem type alias 15 STR_TO_BYTES: "toBytes" 16 STR_STARTS_WITH_CODE_POINT: "startsWithCodePoint" + 17 STR_ALIAS_ANALYSIS_STATIC: "#aliasAnalysisStatic" // string with the static lifetime } 4 LIST: "List" => { 0 LIST_LIST: "List" imported // the List.List type alias diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index f0a2e1921a..645f57d8c0 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -1,10 +1,10 @@ use morphic_lib::TypeContext; use morphic_lib::{ - BlockExpr, BlockId, CalleeSpecVar, ConstDef, ConstDefBuilder, ConstName, EntryPointName, - ExprContext, FuncDef, FuncDefBuilder, FuncName, ModDefBuilder, ModName, ProgramBuilder, Result, - TypeId, UpdateModeVar, ValueId, + BlockExpr, BlockId, CalleeSpecVar, ConstDefBuilder, ConstName, EntryPointName, ExprContext, + FuncDef, FuncDefBuilder, FuncName, ModDefBuilder, ModName, ProgramBuilder, Result, TypeId, + UpdateModeVar, ValueId, }; -use roc_collections::all::{MutMap, MutSet}; +use roc_collections::all::MutMap; use roc_module::low_level::LowLevel; use roc_module::symbol::Symbol; use std::convert::TryFrom; @@ -12,31 +12,36 @@ use std::convert::TryFrom; use crate::ir::{Call, CallType, Expr, Literal, ModifyRc, Proc, Stmt}; use crate::layout::{Builtin, Layout, ListLayout, UnionLayout}; -use bumpalo::Bump; - // just using one module for now pub const MOD_APP: ModName = ModName(b"UserApp"); +pub const STATIC_STR_NAME: ConstName = ConstName(&Symbol::STR_ALIAS_ANALYSIS_STATIC.to_ne_bytes()); + pub fn spec_program<'a, I>(procs: I) -> Result where I: Iterator>, { - let arena = Bump::new(); - let mut main_function = None; let main_module = { let mut m = ModDefBuilder::new(); + let static_str_def = { + let mut cbuilder = ConstDefBuilder::new(); + let block = cbuilder.add_block(); + let cell = cbuilder.add_new_heap_cell(block)?; + let value_id = cbuilder.add_make_tuple(block, &[cell])?; + let root = BlockExpr(block, value_id); + let str_type_id = str_type(&mut cbuilder)?; + + cbuilder.build(str_type_id, root)? + }; + m.add_const(STATIC_STR_NAME, static_str_def)?; + for proc in procs { - let (spec, consts) = proc_spec(&arena, proc)?; + let spec = proc_spec(proc)?; m.add_func(FuncName(&proc.name.to_ne_bytes()), spec)?; - for (symbol, def) in consts { - let const_name = ConstName(arena.alloc(symbol.to_ne_bytes())); - m.add_const(const_name, def)?; - } - if format!("{:?}", proc.name).contains("mainForHost") { main_function = Some(proc.name); } @@ -60,9 +65,9 @@ where morphic_lib::solve(program) } -fn proc_spec(arena: &Bump, proc: &Proc) -> Result<(FuncDef, MutMap)> { +fn proc_spec(proc: &Proc) -> Result { let mut builder = FuncDefBuilder::new(); - let mut env = Env::new(arena); + let mut env = Env::default(); let block = builder.add_block(); @@ -81,39 +86,15 @@ fn proc_spec(arena: &Bump, proc: &Proc) -> Result<(FuncDef, MutMap = MutMap::default(); - - for symbol in env.statics { - let mut cbuilder = ConstDefBuilder::new(); - let str_type_id = str_type(&mut cbuilder)?; - let def = cbuilder.build(str_type_id, root)?; - - statics.insert(symbol, def); - } - let spec = builder.build(arg_type_id, ret_type_id, root)?; - Ok((spec, statics)) + Ok(spec) } -type Statics = MutSet; - -struct Env<'a> { - arena: &'a Bump, +#[derive(Default)] +struct Env { symbols: MutMap, join_points: MutMap, - statics: Statics, -} - -impl<'a> Env<'a> { - fn new(arena: &'a Bump) -> Self { - Env { - arena, - symbols: Default::default(), - join_points: Default::default(), - statics: Default::default(), - } - } } fn stmt_spec( @@ -127,7 +108,7 @@ fn stmt_spec( match stmt { Let(symbol, expr, layout, continuation) => { - let value_id = expr_spec(builder, env, block, symbol, layout, expr)?; + let value_id = expr_spec(builder, env, block, layout, expr)?; env.symbols.insert(*symbol, value_id); let result = stmt_spec(builder, env, block, layout, continuation)?; env.symbols.remove(symbol); @@ -465,16 +446,13 @@ fn expr_spec( builder: &mut FuncDefBuilder, env: &mut Env, block: BlockId, - lhs: &Symbol, layout: &Layout, expr: &Expr, ) -> Result { use Expr::*; match expr { - Literal(literal) => { - literal_spec(env.arena, builder, &mut env.statics, block, *lhs, literal) - } + Literal(literal) => literal_spec(builder, block, literal), Call(call) => call_spec(builder, env, block, layout, call), Tag { tag_layout, @@ -557,17 +535,14 @@ fn expr_spec( } fn literal_spec( - arena: &Bump, builder: &mut FuncDefBuilder, - statics: &mut Statics, block: BlockId, - lhs: Symbol, literal: &Literal, ) -> Result { use Literal::*; match literal { - Str(_) => new_static_string(arena, builder, statics, block, lhs), + Str(_) => new_static_string(builder, block), Int(_) | Float(_) | Bool(_) | Byte(_) => builder.add_make_tuple(block, &[]), } } @@ -645,19 +620,10 @@ fn new_list(builder: &mut FuncDefBuilder, block: BlockId, element_type: TypeId) builder.add_make_tuple(block, &[cell, bag]) } -fn new_static_string( - arena: &Bump, - builder: &mut FuncDefBuilder, - statics: &mut Statics, - block: BlockId, - lhs: Symbol, -) -> Result { +fn new_static_string(builder: &mut FuncDefBuilder, block: BlockId) -> Result { let module = MOD_APP; - let const_name = ConstName(arena.alloc(lhs.to_ne_bytes())); - statics.insert(lhs); - - builder.add_const_ref(block, module, const_name) + builder.add_const_ref(block, module, STATIC_STR_NAME) } fn new_order(builder: &mut FuncDefBuilder, block: BlockId) -> Result { From b75c40e65bc645c804941b111eb351b04c8aa2a8 Mon Sep 17 00:00:00 2001 From: Folkert Date: Fri, 28 May 2021 23:57:11 +0200 Subject: [PATCH 032/496] thread alias analysis solutions --- Cargo.lock | 1 + compiler/build/Cargo.toml | 1 + compiler/build/src/program.rs | 19 +++++++++++++++++++ compiler/load/src/file.rs | 2 +- 4 files changed, 22 insertions(+), 1 deletion(-) diff --git a/Cargo.lock b/Cargo.lock index 26ae33dfde..d6be2fd7ed 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2914,6 +2914,7 @@ dependencies = [ "inlinable_string", "libloading 0.6.7", "maplit", + "morphic_lib", "pretty_assertions 0.5.1", "quickcheck 0.8.5", "quickcheck_macros 0.8.0", diff --git a/compiler/build/Cargo.toml b/compiler/build/Cargo.toml index a7f173d2e2..5b0bdd4392 100644 --- a/compiler/build/Cargo.toml +++ b/compiler/build/Cargo.toml @@ -21,6 +21,7 @@ roc_mono = { path = "../mono" } roc_load = { path = "../load" } roc_gen = { path = "../gen" } roc_reporting = { path = "../reporting" } +morphic_lib = { path = "../../vendor/morphic_lib" } im = "14" # im and im-rc should always have the same version! im-rc = "14" # im and im-rc should always have the same version! bumpalo = { version = "3.6.1", features = ["collections"] } diff --git a/compiler/build/src/program.rs b/compiler/build/src/program.rs index 3fad005f6e..f8d1e5af82 100644 --- a/compiler/build/src/program.rs +++ b/compiler/build/src/program.rs @@ -157,8 +157,27 @@ pub fn gen_from_mono_module( headers.push((proc, fn_val)); } + use roc_load::file::AliasAnalysisSolutions::*; + let solutions = match loaded.alias_analysis_solutions { + NotAvailable => panic!(), + Available(solutions) => solutions, + }; + + let module_solutions = solutions + .mod_solutions(roc_mono::alias_analysis::MOD_APP) + .unwrap(); + // Build each proc using its header info. for (proc, fn_val) in headers { + let bytes = proc.name.to_ne_bytes(); + let func_name = morphic_lib::FuncName(&bytes); + let func_specs = module_solutions.func_solutions(func_name).unwrap(); + + for spec_name in func_specs.specs() { + let morphic_lib::FuncSpec(bytes) = spec_name; + dbg!(proc.name, unsafe { std::str::from_utf8_unchecked(bytes) },); + let spec = func_specs.spec(spec_name).unwrap(); + } // NOTE: This is here to be uncommented in case verification fails. // (This approach means we don't have to defensively clone name here.) // diff --git a/compiler/load/src/file.rs b/compiler/load/src/file.rs index cf9ff87acc..687b9c364d 100644 --- a/compiler/load/src/file.rs +++ b/compiler/load/src/file.rs @@ -2085,7 +2085,7 @@ fn update<'a>( &mut state.procedures, ); - if false { + if true { let it = state.procedures.iter().map(|x| x.1); match roc_mono::alias_analysis::spec_program(it) { From 25c9089334abb1e410e3f04dcd3c3f69e4cdac35 Mon Sep 17 00:00:00 2001 From: Folkert Date: Fri, 28 May 2021 23:57:26 +0200 Subject: [PATCH 033/496] Revert "thread alias analysis solutions" This reverts commit b75c40e65bc645c804941b111eb351b04c8aa2a8. --- Cargo.lock | 1 - compiler/build/Cargo.toml | 1 - compiler/build/src/program.rs | 19 ------------------- compiler/load/src/file.rs | 2 +- 4 files changed, 1 insertion(+), 22 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index d6be2fd7ed..26ae33dfde 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2914,7 +2914,6 @@ dependencies = [ "inlinable_string", "libloading 0.6.7", "maplit", - "morphic_lib", "pretty_assertions 0.5.1", "quickcheck 0.8.5", "quickcheck_macros 0.8.0", diff --git a/compiler/build/Cargo.toml b/compiler/build/Cargo.toml index 5b0bdd4392..a7f173d2e2 100644 --- a/compiler/build/Cargo.toml +++ b/compiler/build/Cargo.toml @@ -21,7 +21,6 @@ roc_mono = { path = "../mono" } roc_load = { path = "../load" } roc_gen = { path = "../gen" } roc_reporting = { path = "../reporting" } -morphic_lib = { path = "../../vendor/morphic_lib" } im = "14" # im and im-rc should always have the same version! im-rc = "14" # im and im-rc should always have the same version! bumpalo = { version = "3.6.1", features = ["collections"] } diff --git a/compiler/build/src/program.rs b/compiler/build/src/program.rs index f8d1e5af82..3fad005f6e 100644 --- a/compiler/build/src/program.rs +++ b/compiler/build/src/program.rs @@ -157,27 +157,8 @@ pub fn gen_from_mono_module( headers.push((proc, fn_val)); } - use roc_load::file::AliasAnalysisSolutions::*; - let solutions = match loaded.alias_analysis_solutions { - NotAvailable => panic!(), - Available(solutions) => solutions, - }; - - let module_solutions = solutions - .mod_solutions(roc_mono::alias_analysis::MOD_APP) - .unwrap(); - // Build each proc using its header info. for (proc, fn_val) in headers { - let bytes = proc.name.to_ne_bytes(); - let func_name = morphic_lib::FuncName(&bytes); - let func_specs = module_solutions.func_solutions(func_name).unwrap(); - - for spec_name in func_specs.specs() { - let morphic_lib::FuncSpec(bytes) = spec_name; - dbg!(proc.name, unsafe { std::str::from_utf8_unchecked(bytes) },); - let spec = func_specs.spec(spec_name).unwrap(); - } // NOTE: This is here to be uncommented in case verification fails. // (This approach means we don't have to defensively clone name here.) // diff --git a/compiler/load/src/file.rs b/compiler/load/src/file.rs index 687b9c364d..cf9ff87acc 100644 --- a/compiler/load/src/file.rs +++ b/compiler/load/src/file.rs @@ -2085,7 +2085,7 @@ fn update<'a>( &mut state.procedures, ); - if true { + if false { let it = state.procedures.iter().map(|x| x.1); match roc_mono::alias_analysis::spec_program(it) { From a4d3f96f255abd7bb1f2d668db60334897b0d028 Mon Sep 17 00:00:00 2001 From: Jared Ramirez Date: Fri, 28 May 2021 17:03:59 -0700 Subject: [PATCH 034/496] Run build script instead of zig build on big sur --- .envrc | 2 +- compiler/builtins/bitcode/build.sh | 5 + compiler/builtins/build.rs | 44 +++++-- shell.nix | 198 ++++++++++++++--------------- 4 files changed, 141 insertions(+), 108 deletions(-) create mode 100755 compiler/builtins/bitcode/build.sh diff --git a/.envrc b/.envrc index 45097a203e..daafe18d9a 100644 --- a/.envrc +++ b/.envrc @@ -93,7 +93,7 @@ use_nix() { fi log_status "use nix: updating cache" - nix-shell --pure "${drv}" --show-trace --run "$(join_args "$direnv" dump bash)" > "${dump}" + nix-shell "${drv}" --show-trace --run "$(join_args "$direnv" dump bash)" > "${dump}" if [[ "${?}" -ne 0 ]] || [[ ! -f "${dump}" ]] || ! grep -q IN_NIX_SHELL "${dump}"; then rm -rf "${wd}" fail "use nix: was not able to update the cache of the environment. Please run 'direnv reload' to try again." diff --git a/compiler/builtins/bitcode/build.sh b/compiler/builtins/bitcode/build.sh new file mode 100755 index 0000000000..e863770c8e --- /dev/null +++ b/compiler/builtins/bitcode/build.sh @@ -0,0 +1,5 @@ +#!/bin/bash + +set -euxo pipefail + +zig build-obj src/main.zig -O ReleaseFast -femit-llvm-ir=builtins.ll -femit-bin=builtins.o --strip diff --git a/compiler/builtins/build.rs b/compiler/builtins/build.rs index b6a4e41f14..57ec6d7a71 100644 --- a/compiler/builtins/build.rs +++ b/compiler/builtins/build.rs @@ -10,15 +10,29 @@ use std::str; fn main() { let out_dir = env::var_os("OUT_DIR").unwrap(); + let big_sur_path = "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/lib"; + let use_build_script = Path::new(big_sur_path).exists(); + // "." is relative to where "build.rs" is let build_script_dir_path = fs::canonicalize(Path::new(".")).unwrap(); let bitcode_path = build_script_dir_path.join("bitcode"); let src_obj_path = bitcode_path.join("builtins.o"); let src_obj = src_obj_path.to_str().expect("Invalid src object path"); - println!("Compiling zig object to: {}", src_obj); - run_command(&bitcode_path, "zig", &["build", "object", "-Drelease=true"]); + let dest_ir_path = bitcode_path.join("builtins.ll"); + let dest_ir = dest_ir_path.to_str().expect("Invalid dest ir path"); + + if use_build_script { + println!("Compiling zig object & ir to: {} and {}", src_obj, dest_ir); + run_command_with_no_args(&bitcode_path, "./build.sh"); + } else { + println!("Compiling zig object to: {}", src_obj); + run_command(&bitcode_path, "zig", &["build", "object", "-Drelease=true"]); + + println!("Compiling ir to: {}", dest_ir); + run_command(&bitcode_path, "zig", &["build", "ir", "-Drelease=true"]); + } let dest_obj_path = Path::new(&out_dir).join("builtins.o"); let dest_obj = dest_obj_path.to_str().expect("Invalid dest object path"); @@ -26,12 +40,6 @@ fn main() { run_command(&bitcode_path, "mv", &[src_obj, dest_obj]); - let dest_ir_path = bitcode_path.join("builtins.ll"); - let dest_ir = dest_ir_path.to_str().expect("Invalid dest ir path"); - println!("Compiling ir to: {}", dest_ir); - - run_command(&bitcode_path, "zig", &["build", "ir", "-Drelease=true"]); - let dest_bc_path = bitcode_path.join("builtins.bc"); let dest_bc = dest_bc_path.to_str().expect("Invalid dest bc path"); println!("Compiling bitcode to: {}", dest_bc); @@ -78,6 +86,26 @@ where } } +fn run_command_with_no_args>(path: P, command_str: &str) +{ + let output_result = Command::new(OsStr::new(&command_str)) + .current_dir(path) + .output(); + match output_result { + Ok(output) => match output.status.success() { + true => (), + false => { + let error_str = match str::from_utf8(&output.stderr) { + Ok(stderr) => stderr.to_string(), + Err(_) => format!("Failed to run \"{}\"", command_str), + }; + panic!("{} failed: {}", command_str, error_str); + } + }, + Err(reason) => panic!("{} failed: {}", command_str, reason), + } +} + fn get_zig_files(dir: &Path, cb: &dyn Fn(&Path)) -> io::Result<()> { if dir.is_dir() { for entry in fs::read_dir(dir)? { diff --git a/shell.nix b/shell.nix index 10c965b2e8..7b7d61fd55 100644 --- a/shell.nix +++ b/shell.nix @@ -1,116 +1,116 @@ -{ }: +{}: let splitSystem = builtins.split "-" builtins.currentSystem; currentArch = builtins.elemAt splitSystem 0; currentOS = builtins.elemAt splitSystem 2; -in with { - # Look here for information about how pin version of nixpkgs - # → https://nixos.wiki/wiki/FAQ/Pinning_Nixpkgs - pkgs = import (builtins.fetchGit { - name = "nixpkgs-2021-04-23"; - url = "https://github.com/nixos/nixpkgs/"; - ref = "refs/heads/nixpkgs-unstable"; - rev = "8d0340aee5caac3807c58ad7fa4ebdbbdd9134d6"; - }) { }; - - isMacOS = currentOS == "darwin"; - isLinux = currentOS == "linux"; - isAarch64 = currentArch == "aarch64"; -}; - -with (pkgs); - -let - darwin-inputs = - if isMacOS then - with pkgs.darwin.apple_sdk.frameworks; [ - AppKit - CoreFoundation - CoreServices - CoreVideo - Foundation - Metal - Security - ] - else - [ ]; - - linux-inputs = - if isLinux then - [ - valgrind - vulkan-headers - vulkan-loader - vulkan-tools - vulkan-validation-layers - xorg.libX11 - xorg.libXcursor - xorg.libXrandr - xorg.libXi - xorg.libxcb - ] - else - [ ]; - - nixos-env = - if isLinux && builtins.pathExists /etc/nixos/configuration.nix then - { XDG_DATA_DIRS = "/run/opengl-driver/share:$XDG_DATA_DIRS"; +in + with { + # Look here for information about how pin version of nixpkgs + # → https://nixos.wiki/wiki/FAQ/Pinning_Nixpkgs + pkgs = import ( + builtins.fetchGit { + # name = "nixpkgs-2021-04-23"; + url = "https://github.com/nixos/nixpkgs/"; + ref = "refs/heads/nixpkgs-unstable"; + rev = "8d0340aee5caac3807c58ad7fa4ebdbbdd9134d6"; } - else - { }; + ) {}; - llvmPkgs = pkgs.llvmPackages_10; - zig = import ./nix/zig.nix { inherit pkgs isMacOS isAarch64; }; - inputs = [ - # build libraries - rustc - cargo - clippy - rustfmt - cmake - git - python3 - llvmPkgs.llvm - llvmPkgs.clang - pkg-config - zig - # lib deps - llvmPkgs.libcxx - llvmPkgs.libcxxabi - libffi - libunwind - libxml2 - ncurses - zlib - libiconv - # faster builds - see https://github.com/rtfeldman/roc/blob/trunk/BUILDING_FROM_SOURCE.md#use-lld-for-the-linker - llvmPkgs.lld - # dev tools - # rust-analyzer - # (import ./nix/zls.nix { inherit pkgs zig; }) - ]; + isMacOS = currentOS == "darwin"; + isLinux = currentOS == "linux"; + isAarch64 = currentArch == "aarch64"; + }; -in mkShell (nixos-env // { - buildInputs = inputs ++ darwin-inputs ++ linux-inputs; + with (pkgs); - # Additional Env vars - LLVM_SYS_100_PREFIX = "${llvmPkgs.llvm}"; - LD_LIBRARY_PATH = stdenv.lib.makeLibraryPath - ([ + let + darwin-inputs = + if isMacOS then + with pkgs.darwin.apple_sdk.frameworks; [ + AppKit + CoreFoundation + CoreServices + CoreVideo + Foundation + Metal + Security + ] + else + []; + + linux-inputs = + if isLinux then + [ + valgrind + vulkan-headers + vulkan-loader + vulkan-tools + vulkan-validation-layers + xorg.libX11 + xorg.libXcursor + xorg.libXrandr + xorg.libXi + xorg.libxcb + ] + else + []; + + llvmPkgs = pkgs.llvmPackages_10; + zig = import ./nix/zig.nix { inherit pkgs isMacOS isAarch64; }; + inputs = [ + # build libraries + rustc + cargo + clippy + rustfmt + cmake + git + python3 + llvmPkgs.llvm + llvmPkgs.clang pkg-config - stdenv.cc.cc.lib + zig + # lib deps llvmPkgs.libcxx llvmPkgs.libcxxabi - libunwind libffi + libunwind + libxml2 ncurses zlib - ] ++ linux-inputs); + libiconv + # faster builds - see https://github.com/rtfeldman/roc/blob/trunk/BUILDING_FROM_SOURCE.md#use-lld-for-the-linker + llvmPkgs.lld + # dev tools + # rust-analyzer + # (import ./nix/zls.nix { inherit pkgs zig; }) + ]; - # Aliases don't work cross shell, so we do this - shellHook = '' - export PATH="$PATH:$PWD/nix/bin" - ''; -}) + in + mkShell ( + { + buildInputs = inputs ++ darwin-inputs ++ linux-inputs; + # Additional Env vars + LLVM_SYS_100_PREFIX = "${llvmPkgs.llvm}"; + LD_LIBRARY_PATH = stdenv.lib.makeLibraryPath + ( + [ + pkg-config + stdenv.cc.cc.lib + llvmPkgs.libcxx + llvmPkgs.libcxxabi + libunwind + libffi + ncurses + zlib + ] ++ linux-inputs + ); + + # Aliases don't work cross shell, so we do this + shellHook = '' + export PATH="$PATH:$PWD/nix/bin" + ''; + } + ) From 1fbd52bb8dbbec7dfa32c21474779eb400233918 Mon Sep 17 00:00:00 2001 From: rvcas Date: Sat, 29 May 2021 13:26:17 -0400 Subject: [PATCH 035/496] feat(repl): add formatting function for i32 --- cli/src/repl/eval.rs | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/cli/src/repl/eval.rs b/cli/src/repl/eval.rs index 21304feab9..f7aa5863b3 100644 --- a/cli/src/repl/eval.rs +++ b/cli/src/repl/eval.rs @@ -858,6 +858,10 @@ fn i64_to_ast(arena: &Bump, num: i64) -> Expr<'_> { Expr::Num(arena.alloc(format!("{}", num))) } +fn i32_to_ast(arena: &Bump, num: i32) -> Expr<'_> { + Expr::Num(arena.alloc(format!("{}", num))) +} + /// This is centralized in case we want to format it differently later, /// e.g. adding underscores for large numbers fn i128_to_ast(arena: &Bump, num: i128) -> Expr<'_> { From 5ae269659a5b18918a33e3ce7643a22b5e019315 Mon Sep 17 00:00:00 2001 From: rvcas Date: Sat, 29 May 2021 13:26:44 -0400 Subject: [PATCH 036/496] feat(repl): implement Builtin::Int32 formatting --- cli/src/repl/eval.rs | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/cli/src/repl/eval.rs b/cli/src/repl/eval.rs index f7aa5863b3..ab0561aa44 100644 --- a/cli/src/repl/eval.rs +++ b/cli/src/repl/eval.rs @@ -81,6 +81,13 @@ fn jit_to_ast_help<'a>( Layout::Builtin(Builtin::Usize) => Ok(run_jit_function!(lib, main_fn_name, usize, |num| { num_to_ast(env, nat_to_ast(env.arena, num), content) })), + Layout::Builtin(Builtin::Int32) => { + Ok(run_jit_function!(lib, main_fn_name, i32, |num| num_to_ast( + env, + i32_to_ast(env.arena, num), + content + ))) + } Layout::Builtin(Builtin::Int64) => { Ok(run_jit_function!(lib, main_fn_name, i64, |num| num_to_ast( env, From 3105f09b2f97854f9c0ddc4ddc19ebe487cf21e7 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 29 May 2021 20:44:53 +0200 Subject: [PATCH 037/496] use empty tag union for tag union with no members --- compiler/mono/src/layout.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index e7af14e26e..5a266857ad 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -276,7 +276,8 @@ impl<'a> LambdaSet<'a> { use UnionVariant::*; match variant { - Never | Unit | UnitWithArguments => Layout::Struct(&[]), + Never => Layout::Union(UnionLayout::NonRecursive(&[])), + Unit | UnitWithArguments => Layout::Struct(&[]), BoolUnion { .. } => Layout::Builtin(Builtin::Int1), ByteUnion(_) => Layout::Builtin(Builtin::Int8), Unwrapped(_tag_name, layouts) => Layout::Struct(layouts.into_bump_slice()), From a77b5504d832b0182788541fdc92866b9fa853ef Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 29 May 2021 20:48:57 +0200 Subject: [PATCH 038/496] force imported thunks when used --- compiler/mono/src/ir.rs | 35 ++++++++++++++++++++++++----------- 1 file changed, 24 insertions(+), 11 deletions(-) diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 4bedd2dae6..02e66bd79e 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -5928,35 +5928,48 @@ fn reuse_function_symbol<'a>( ) -> Stmt<'a> { match procs.partial_procs.get(&original) { None => { - let is_imported = env.is_imported_symbol(original); - match arg_var { - Some(arg_var) if is_imported => { + Some(arg_var) if env.is_imported_symbol(original) => { let layout = layout_cache .from_var(env.arena, arg_var, env.subs) .expect("creating layout does not fail"); - let top_level = TopLevelFunctionLayout::from_layout(env.arena, layout); + if procs.imported_module_thunks.contains(&original) { + let top_level = TopLevelFunctionLayout::new(env.arena, &[], layout); + procs.insert_passed_by_name( + env, + arg_var, + original, + top_level, + layout_cache, + ); - procs.insert_passed_by_name(env, arg_var, original, top_level, layout_cache); + force_thunk(env, original, layout, symbol, env.arena.alloc(result)) + } else { + let top_level = TopLevelFunctionLayout::from_layout(env.arena, layout); + procs.insert_passed_by_name( + env, + arg_var, + original, + top_level, + layout_cache, + ); - // an imported symbol is either a function, or a top-level 0-argument thunk - // it never has closure data, so we use the empty struct - return let_empty_struct(symbol, env.arena.alloc(result)); + let_empty_struct(symbol, env.arena.alloc(result)) + } } _ => { // danger: a foreign symbol may not be specialized! debug_assert!( - !is_imported, + !env.is_imported_symbol(original), "symbol {:?} while processing module {:?}", original, (env.home, &arg_var), ); + result } } - - result } Some(partial_proc) => { From 551c9355a66a601c3a46995f979973ad03d1f6e7 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 29 May 2021 20:57:27 +0200 Subject: [PATCH 039/496] run rustfmt --- compiler/builtins/build.rs | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/compiler/builtins/build.rs b/compiler/builtins/build.rs index 57ec6d7a71..c621196cb9 100644 --- a/compiler/builtins/build.rs +++ b/compiler/builtins/build.rs @@ -24,14 +24,14 @@ fn main() { let dest_ir = dest_ir_path.to_str().expect("Invalid dest ir path"); if use_build_script { - println!("Compiling zig object & ir to: {} and {}", src_obj, dest_ir); - run_command_with_no_args(&bitcode_path, "./build.sh"); + println!("Compiling zig object & ir to: {} and {}", src_obj, dest_ir); + run_command_with_no_args(&bitcode_path, "./build.sh"); } else { - println!("Compiling zig object to: {}", src_obj); - run_command(&bitcode_path, "zig", &["build", "object", "-Drelease=true"]); + println!("Compiling zig object to: {}", src_obj); + run_command(&bitcode_path, "zig", &["build", "object", "-Drelease=true"]); - println!("Compiling ir to: {}", dest_ir); - run_command(&bitcode_path, "zig", &["build", "ir", "-Drelease=true"]); + println!("Compiling ir to: {}", dest_ir); + run_command(&bitcode_path, "zig", &["build", "ir", "-Drelease=true"]); } let dest_obj_path = Path::new(&out_dir).join("builtins.o"); @@ -86,8 +86,7 @@ where } } -fn run_command_with_no_args>(path: P, command_str: &str) -{ +fn run_command_with_no_args>(path: P, command_str: &str) { let output_result = Command::new(OsStr::new(&command_str)) .current_dir(path) .output(); From 98011f48a84bd8860cefb90c961d43372afe73ae Mon Sep 17 00:00:00 2001 From: tarjei Date: Sat, 29 May 2021 20:58:59 +0200 Subject: [PATCH 040/496] Add tests These tests cover, for good measure: - swapping an empty list - swapping elements outside a list - swapping a short list - swapping with reversed args - swapping the middle of a long list - swapping with one index outside the list - swapping the same index with itself --- compiler/test_gen/src/gen_list.rs | 39 +++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) diff --git a/compiler/test_gen/src/gen_list.rs b/compiler/test_gen/src/gen_list.rs index 98ccb25d32..b8450b27be 100644 --- a/compiler/test_gen/src/gen_list.rs +++ b/compiler/test_gen/src/gen_list.rs @@ -179,6 +179,45 @@ fn list_drop() { assert_evals_to!("List.drop [1,2] 5", RocList::from_slice(&[]), RocList); } +#[test] +fn list_swap() { + assert_evals_to!( + "List.swap [] 0 1", + RocList::from_slice(&[]), + RocList + ); + assert_evals_to!( + "List.swap [ 0 ] 1 2", + RocList::from_slice(&[0]), + RocList + ); + assert_evals_to!( + "List.swap [ 1, 2 ] 0 1", + RocList::from_slice(&[2, 1]), + RocList + ); + assert_evals_to!( + "List.swap [ 1, 2 ] 1 0", + RocList::from_slice(&[2, 1]), + RocList + ); + assert_evals_to!( + "List.swap [ 0, 1, 2, 3, 4, 5 ] 2 4", + RocList::from_slice(&[0, 1, 4, 3, 2, 5]), + RocList + ); + assert_evals_to!( + "List.swap [ 0, 1, 2 ] 1 3", + RocList::from_slice(&[0, 1, 2]), + RocList + ); + assert_evals_to!( + "List.swap [ 1, 2, 3 ] 1 1", + RocList::from_slice(&[1, 2, 3]), + RocList + ); +} + #[test] fn list_append_to_empty_list() { assert_evals_to!("List.append [] 3", RocList::from_slice(&[3]), RocList); From 107822a5cc4008ddf8c4380d6ee9e644e4924734 Mon Sep 17 00:00:00 2001 From: tarjei Date: Sat, 29 May 2021 21:30:16 +0200 Subject: [PATCH 041/496] Add plumbing for List.swap --- compiler/builtins/bitcode/src/main.zig | 1 + compiler/builtins/src/bitcode.rs | 1 + compiler/builtins/src/std.rs | 7 ++++++ compiler/can/src/builtins.rs | 31 ++++++++++++++++++++++++++ compiler/gen/src/llvm/build.rs | 23 ++++++++++++++++++- compiler/gen/src/llvm/build_list.rs | 23 ++++++++++++++++++- compiler/module/src/low_level.rs | 1 + compiler/module/src/symbol.rs | 1 + compiler/mono/src/borrow.rs | 1 + 9 files changed, 87 insertions(+), 2 deletions(-) diff --git a/compiler/builtins/bitcode/src/main.zig b/compiler/builtins/bitcode/src/main.zig index 46285ed163..f1af557759 100644 --- a/compiler/builtins/bitcode/src/main.zig +++ b/compiler/builtins/bitcode/src/main.zig @@ -30,6 +30,7 @@ comptime { exportListFn(list.listConcat, "concat"); exportListFn(list.listDrop, "drop"); exportListFn(list.listSet, "set"); + exportListFn(list.listSwap, "swap"); } // Dict Module diff --git a/compiler/builtins/src/bitcode.rs b/compiler/builtins/src/bitcode.rs index 53cd979abb..ad36d544b3 100644 --- a/compiler/builtins/src/bitcode.rs +++ b/compiler/builtins/src/bitcode.rs @@ -63,6 +63,7 @@ pub const LIST_CONTAINS: &str = "roc_builtins.list.contains"; pub const LIST_REPEAT: &str = "roc_builtins.list.repeat"; pub const LIST_APPEND: &str = "roc_builtins.list.append"; pub const LIST_DROP: &str = "roc_builtins.list.drop"; +pub const LIST_SWAP: &str = "roc_builtins.list.swap"; pub const LIST_SINGLE: &str = "roc_builtins.list.single"; pub const LIST_JOIN: &str = "roc_builtins.list.join"; pub const LIST_RANGE: &str = "roc_builtins.list.range"; diff --git a/compiler/builtins/src/std.rs b/compiler/builtins/src/std.rs index f6c4b07b19..bdfac87c00 100644 --- a/compiler/builtins/src/std.rs +++ b/compiler/builtins/src/std.rs @@ -856,6 +856,13 @@ pub fn types() -> MutMap { Box::new(list_type(flex(TVAR1))), ); + // swap : List elem, Nat, Nat -> List elem + add_top_level_function_type!( + Symbol::LIST_SWAP, + vec![list_type(flex(TVAR1)), nat_type(), nat_type()], + Box::new(list_type(flex(TVAR1))), + ); + // prepend : List elem, elem -> List elem add_top_level_function_type!( Symbol::LIST_PREPEND, diff --git a/compiler/can/src/builtins.rs b/compiler/can/src/builtins.rs index 7283316ba9..c150747d81 100644 --- a/compiler/can/src/builtins.rs +++ b/compiler/can/src/builtins.rs @@ -85,6 +85,7 @@ pub fn builtin_defs_map(symbol: Symbol, var_store: &mut VarStore) -> Option LIST_MAP2 => list_map2, LIST_MAP3 => list_map3, LIST_DROP => list_drop, + LIST_SWAP => list_swap, LIST_MAP_WITH_INDEX => list_map_with_index, LIST_KEEP_IF => list_keep_if, LIST_KEEP_OKS => list_keep_oks, @@ -1882,6 +1883,36 @@ fn list_set(symbol: Symbol, var_store: &mut VarStore) -> Def { list_ret_var, ) } + +/// List.swap : List elem, Nat, Nat -> List elem +fn list_drop(symbol: Symbol, var_store: &mut VarStore) -> Def { + let list_var = var_store.fresh(); + let index1_var = var_store.fresh(); + let index2_var = var_store.fresh(); + + let body = RunLowLevel { + op: LowLevel::ListDrop, + args: vec![ + (list_var, Var(Symbol::ARG_1)), + (index1_var, Var(Symbol::ARG_2)), + (index2_var, Var(Symbol::ARG_3)), + ], + ret_var: list_var, + }; + + defn( + symbol, + vec![ + (list_var, Symbol::ARG_1), + (index1_var, Symbol::ARG_2), + (index2_var, Symbol::ARG_3), + ], + var_store, + body, + list_var, + ) +} + /// List.drop : List elem, Nat -> List elem fn list_drop(symbol: Symbol, var_store: &mut VarStore) -> Def { let list_var = var_store.fresh(); diff --git a/compiler/gen/src/llvm/build.rs b/compiler/gen/src/llvm/build.rs index 41dacb9476..6f0258c58b 100644 --- a/compiler/gen/src/llvm/build.rs +++ b/compiler/gen/src/llvm/build.rs @@ -8,7 +8,7 @@ use crate::llvm::build_list::{ allocate_list, empty_list, empty_polymorphic_list, list_append, list_concat, list_contains, list_drop, list_get_unsafe, list_join, list_keep_errs, list_keep_if, list_keep_oks, list_len, list_map, list_map2, list_map3, list_map_with_index, list_prepend, list_range, list_repeat, - list_reverse, list_set, list_single, list_sort_with, + list_reverse, list_set, list_single, list_sort_with, list_swap, }; use crate::llvm::build_str::{ empty_str, str_concat, str_count_graphemes, str_ends_with, str_from_float, str_from_int, @@ -4164,6 +4164,27 @@ fn run_low_level<'a, 'ctx, 'env>( list_append(env, layout.in_place(), original_wrapper, elem, elem_layout) } + ListSwap => { + // List.swap : List elem, Nat, Nat -> List elem + debug_assert_eq!(args.len(), 3); + + let (list, list_layout) = load_symbol_and_layout(scope, &args[0]); + let original_wrapper = list.into_struct_value(); + + let count = load_symbol(scope, &args[1]); + + match list_layout { + Layout::Builtin(Builtin::EmptyList) => empty_list(env), + Layout::Builtin(Builtin::List(element_layout)) => list_swap( + env, + layout_ids, + original_wrapper, + count.into_int_value(), + element_layout, + ), + _ => unreachable!("Invalid layout {:?} in List.swap", list_layout), + } + } ListDrop => { // List.drop : List elem, Nat -> List elem debug_assert_eq!(args.len(), 2); diff --git a/compiler/gen/src/llvm/build_list.rs b/compiler/gen/src/llvm/build_list.rs index 5a7fea02c9..052b72ec2e 100644 --- a/compiler/gen/src/llvm/build_list.rs +++ b/compiler/gen/src/llvm/build_list.rs @@ -304,7 +304,28 @@ pub fn list_append<'a, 'ctx, 'env>( ) } -/// List.drop : List elem, Nat -> List elem +/// List.swap : List elem, Nat, Nat -> List elem +pub fn list_swap<'a, 'ctx, 'env>( + env: &Env<'a, 'ctx, 'env>, + layout_ids: &mut LayoutIds<'a>, + original_wrapper: StructValue<'ctx>, + count: IntValue<'ctx>, + element_layout: &Layout<'a>, +) -> BasicValueEnum<'ctx> { + let dec_element_fn = build_dec_wrapper(env, layout_ids, &element_layout); + call_bitcode_fn_returns_list( + env, + &[ + pass_list_as_i128(env, original_wrapper.into()), + env.alignment_intvalue(&element_layout), + layout_width(env, &element_layout), + count.into(), + ], + &bitcode::LIST_SWAP, + ) +} + +/// List.drop : List elem, Nat, Nat -> List elem pub fn list_drop<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, layout_ids: &mut LayoutIds<'a>, diff --git a/compiler/module/src/low_level.rs b/compiler/module/src/low_level.rs index 2ed35be875..7617d33832 100644 --- a/compiler/module/src/low_level.rs +++ b/compiler/module/src/low_level.rs @@ -135,6 +135,7 @@ impl LowLevel { | ListPrepend | ListJoin | ListRange + | ListSwap | DictSize | DictEmpty | DictInsert diff --git a/compiler/module/src/symbol.rs b/compiler/module/src/symbol.rs index 90fc894970..2b1f182dd5 100644 --- a/compiler/module/src/symbol.rs +++ b/compiler/module/src/symbol.rs @@ -939,6 +939,7 @@ define_builtins! { 30 LIST_RANGE: "range" 31 LIST_SORT_WITH: "sortWith" 32 LIST_DROP: "drop" + 33 LIST_SWAP: "swap" } 5 RESULT: "Result" => { 0 RESULT_RESULT: "Result" imported // the Result.Result type alias diff --git a/compiler/mono/src/borrow.rs b/compiler/mono/src/borrow.rs index 443bfb20df..6b4a06c63a 100644 --- a/compiler/mono/src/borrow.rs +++ b/compiler/mono/src/borrow.rs @@ -748,6 +748,7 @@ pub fn lowlevel_borrow_signature(arena: &Bump, op: LowLevel) -> &[bool] { // List.append should own its first argument ListAppend => arena.alloc_slice_copy(&[owned, owned]), ListDrop => arena.alloc_slice_copy(&[owned, irrelevant]), + ListSwap => arena.alloc_slice_copy(&[owned, irrelevant, irrelevant]), Eq | NotEq => arena.alloc_slice_copy(&[borrowed, borrowed]), From 3636e18a181319546fee8afb1e01c895c3865ad3 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 29 May 2021 21:46:33 +0200 Subject: [PATCH 042/496] centralize inkwell imports --- Cargo.lock | 347 +++++++++++++++++++---------------- Cargo.toml | 1 + cli/Cargo.toml | 19 +- compiler/build/Cargo.toml | 19 +- compiler/gen/Cargo.toml | 19 +- compiler/test_gen/Cargo.toml | 19 +- vendor/inkwell/Cargo.toml | 31 ++++ vendor/inkwell/src/lib.rs | 4 + 8 files changed, 225 insertions(+), 234 deletions(-) create mode 100644 vendor/inkwell/Cargo.toml create mode 100644 vendor/inkwell/src/lib.rs diff --git a/Cargo.lock b/Cargo.lock index 17ae544bde..0323839957 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2,9 +2,9 @@ # It is not intended for manual editing. [[package]] name = "ab_glyph" -version = "0.2.10" +version = "0.2.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7a933731feda8b460bdad9a9e43bb386baba6ec593d2bc19716ef3c75c09085c" +checksum = "af0ac006645f86f20f6c6fa4dcaef920bf803df819123626f9440e35835e7d80" dependencies = [ "ab_glyph_rasterizer", "owned_ttf_parser 0.12.0", @@ -18,9 +18,9 @@ checksum = "d9fe5e32de01730eb1f6b7f5b51c17e03e2325bf40a74f754f04f130043affff" [[package]] name = "addr2line" -version = "0.14.1" +version = "0.15.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a55f82cfe485775d02112886f4169bde0c5894d75e79ead7eafe7e40a25e45f7" +checksum = "03345e98af8f3d786b6d9f656ccfa6ac316d954e92bc4841f0bba20789d5fb5a" dependencies = [ "gimli", ] @@ -39,20 +39,20 @@ checksum = "739f4a8db6605981345c5654f3a85b056ce52f37a39d34da03f25bf2151ea16e" [[package]] name = "ahash" -version = "0.7.2" +version = "0.7.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7f200cbb1e856866d9eade941cf3aa0c5d7dd36f74311c4273b494f4ef036957" +checksum = "43bb833f0bf979d8475d38fbf09ed3b8a55e1885fe93ad3f93239fc6a4f17b98" dependencies = [ - "getrandom 0.2.2", + "getrandom 0.2.3", "once_cell", "version_check", ] [[package]] name = "aho-corasick" -version = "0.7.15" +version = "0.7.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7404febffaa47dac81aa44dba71523c9d069b1bdc50a77db41195149e17f68e5" +checksum = "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f" dependencies = [ "memchr", ] @@ -153,15 +153,16 @@ checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a" [[package]] name = "backtrace" -version = "0.3.56" +version = "0.3.59" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9d117600f438b1707d4e4ae15d3595657288f8235a0eb593e80ecc98ab34e1bc" +checksum = "4717cfcbfaa661a0fd48f8453951837ae7e8f81e481fbb136e3202d72805a744" dependencies = [ "addr2line", + "cc", "cfg-if 1.0.0", "libc", "miniz_oxide", - "object 0.23.0", + "object", "rustc-demangle", ] @@ -233,9 +234,9 @@ dependencies = [ [[package]] name = "bstr" -version = "0.2.15" +version = "0.2.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a40b47ad93e1a5404e6c18dec46b628214fee441c70f4ab5d6942142cc268a3d" +checksum = "90682c8d613ad3373e66de8c6411e0ae2ab2571e879d2efbf73558cc66f21279" dependencies = [ "lazy_static", "memchr", @@ -245,9 +246,9 @@ dependencies = [ [[package]] name = "bumpalo" -version = "3.6.1" +version = "3.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "63396b8a4b9de3f4fdfb320ab6080762242f66a8ef174c49d8e19b674db4cdbe" +checksum = "9c59e7af012c713f529e7a3ee57ce9b31ddd858d4b512923602f74608b009631" [[package]] name = "byte-tools" @@ -270,7 +271,7 @@ version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8e215f8c2f9f79cb53c8335e687ffd07d5bfcb6fe5fc80723762d0be46e7cc54" dependencies = [ - "proc-macro2 1.0.26", + "proc-macro2 1.0.27", "quote 1.0.9", "syn 1.0.72", ] @@ -299,18 +300,18 @@ dependencies = [ [[package]] name = "cast" -version = "0.2.5" +version = "0.2.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cc38c385bfd7e444464011bb24820f40dd1c76bcdfa1b78611cb7c2e5cafab75" +checksum = "57cdfa5d50aad6cb4d44dcab6101a7f79925bd59d82ca42f38a9856a28865374" dependencies = [ "rustc_version", ] [[package]] name = "cc" -version = "1.0.67" +version = "1.0.68" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e3c69b077ad434294d3ce9f1f6143a2a4b89a8a2d54ef813d85003a4fd1137fd" +checksum = "4a72c244c1ff497a746a7e1fb3d14bd08420ecda70c8f25c7112f2781652d787" dependencies = [ "jobserver", ] @@ -378,7 +379,7 @@ source = "git+https://github.com/rtfeldman/clap?branch=master#e1d83a78804a271b05 dependencies = [ "heck", "proc-macro-error", - "proc-macro2 1.0.26", + "proc-macro2 1.0.27", "quote 1.0.9", "syn 1.0.72", ] @@ -457,7 +458,7 @@ dependencies = [ [[package]] name = "confy" version = "0.4.0" -source = "git+https://github.com/rust-cli/confy#0f0c452d652e85674348d9ad6e54bbdebbbd848a" +source = "git+https://github.com/rust-cli/confy#6ae700bb0e6e2f9f7138d0c1871f604013c8f59f" dependencies = [ "directories-next", "serde", @@ -479,9 +480,9 @@ version = "0.2.14" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "29c36c619c422113552db4eb28cddba8faa757e33f758cc3415bd2885977b591" dependencies = [ - "proc-macro2 1.0.26", + "proc-macro2 1.0.27", "quote 1.0.9", - "unicode-xid 0.2.1", + "unicode-xid 0.2.2", ] [[package]] @@ -588,9 +589,9 @@ dependencies = [ [[package]] name = "cpufeatures" -version = "0.1.1" +version = "0.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dec1028182c380cc45a2e2c5ec841134f2dfd0f8f5f0a5bcd68004f81b5efdf4" +checksum = "ed00c67cb5d0a7d64a44f6ad2668db7e7530311dd53ea79bcd4fb022c64911c8" dependencies = [ "libc", ] @@ -671,7 +672,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "06ed27e177f16d65f0f0c22a213e17c696ace5dd64b14258b52f9417ccb52db4" dependencies = [ "cfg-if 1.0.0", - "crossbeam-utils 0.8.3", + "crossbeam-utils 0.8.4", ] [[package]] @@ -692,8 +693,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "94af6efb46fef72616855b036a624cf27ba656ffc9be1b9a3c931cfc7749a9a9" dependencies = [ "cfg-if 1.0.0", - "crossbeam-epoch 0.9.3", - "crossbeam-utils 0.8.3", + "crossbeam-epoch 0.9.4", + "crossbeam-utils 0.8.4", ] [[package]] @@ -713,14 +714,14 @@ dependencies = [ [[package]] name = "crossbeam-epoch" -version = "0.9.3" +version = "0.9.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2584f639eb95fea8c798496315b297cf81b9b58b6d30ab066a75455333cf4b12" +checksum = "52fb27eab85b17fbb9f6fd667089e07d6a2eb8743d02639ee7f6a7a7729c9c94" dependencies = [ "cfg-if 1.0.0", - "crossbeam-utils 0.8.3", + "crossbeam-utils 0.8.4", "lazy_static", - "memoffset 0.6.3", + "memoffset 0.6.4", "scopeguard", ] @@ -748,9 +749,9 @@ dependencies = [ [[package]] name = "crossbeam-utils" -version = "0.8.3" +version = "0.8.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e7e9d99fa91428effe99c5c6d4634cdeba32b8cf784fc428a2a687f61a952c49" +checksum = "4feb231f0d4d6af81aed15928e58ecf5816aa62a2393e2c82f46973e92a9a278" dependencies = [ "autocfg 1.0.1", "cfg-if 1.0.0", @@ -818,7 +819,7 @@ checksum = "f0c960ae2da4de88a91b2d920c2a7233b400bc33cb28453a2987822d8392519b" dependencies = [ "fnv", "ident_case", - "proc-macro2 1.0.26", + "proc-macro2 1.0.27", "quote 1.0.9", "strsim", "syn 1.0.72", @@ -841,7 +842,7 @@ version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fcc3dd5e9e9c0b295d6e1e4d811fb6f157d5ffd784b8d202fc62eac8035a770b" dependencies = [ - "proc-macro2 1.0.26", + "proc-macro2 1.0.27", "quote 1.0.9", "syn 1.0.72", ] @@ -1053,9 +1054,9 @@ checksum = "3dcaa9ae7725d12cdb85b3ad99a434db70b468c09ded17e012d86b5c1010f7a7" [[package]] name = "futures" -version = "0.3.14" +version = "0.3.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a9d5813545e459ad3ca1bff9915e9ad7f1a47dc6a91b627ce321d5863b7dd253" +checksum = "0e7e43a803dae2fa37c1f6a8fe121e1f7bf9548b4dfc0522a42f34145dadfc27" dependencies = [ "futures-channel", "futures-core", @@ -1068,9 +1069,9 @@ dependencies = [ [[package]] name = "futures-channel" -version = "0.3.14" +version = "0.3.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ce79c6a52a299137a6013061e0cf0e688fce5d7f1bc60125f520912fdb29ec25" +checksum = "e682a68b29a882df0545c143dc3646daefe80ba479bcdede94d5a703de2871e2" dependencies = [ "futures-core", "futures-sink", @@ -1078,15 +1079,15 @@ dependencies = [ [[package]] name = "futures-core" -version = "0.3.14" +version = "0.3.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "098cd1c6dda6ca01650f1a37a794245eb73181d0d4d4e955e2f3c37db7af1815" +checksum = "0402f765d8a89a26043b889b26ce3c4679d268fa6bb22cd7c6aad98340e179d1" [[package]] name = "futures-executor" -version = "0.3.14" +version = "0.3.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "10f6cb7042eda00f0049b1d2080aa4b93442997ee507eb3828e8bd7577f94c9d" +checksum = "badaa6a909fac9e7236d0620a2f57f7664640c56575b71a7552fbd68deafab79" dependencies = [ "futures-core", "futures-task", @@ -1095,40 +1096,42 @@ dependencies = [ [[package]] name = "futures-io" -version = "0.3.14" +version = "0.3.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "365a1a1fb30ea1c03a830fdb2158f5236833ac81fa0ad12fe35b29cddc35cb04" +checksum = "acc499defb3b348f8d8f3f66415835a9131856ff7714bf10dadfc4ec4bdb29a1" [[package]] name = "futures-macro" -version = "0.3.14" +version = "0.3.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "668c6733a182cd7deb4f1de7ba3bf2120823835b3bcfbeacf7d2c4a773c1bb8b" +checksum = "a4c40298486cdf52cc00cd6d6987892ba502c7656a16a4192a9992b1ccedd121" dependencies = [ + "autocfg 1.0.1", "proc-macro-hack", - "proc-macro2 1.0.26", + "proc-macro2 1.0.27", "quote 1.0.9", "syn 1.0.72", ] [[package]] name = "futures-sink" -version = "0.3.14" +version = "0.3.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5c5629433c555de3d82861a7a4e3794a4c40040390907cfbfd7143a92a426c23" +checksum = "a57bead0ceff0d6dde8f465ecd96c9338121bb7717d3e7b108059531870c4282" [[package]] name = "futures-task" -version = "0.3.14" +version = "0.3.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ba7aa51095076f3ba6d9a1f702f74bd05ec65f555d70d2033d55ba8d69f581bc" +checksum = "8a16bef9fc1a4dddb5bee51c989e3fbba26569cbb0e31f5b303c184e3dd33dae" [[package]] name = "futures-util" -version = "0.3.14" +version = "0.3.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3c144ad54d60f23927f0a6b6d816e4271278b64f005ad65e4e35291d2de9c025" +checksum = "feb5c238d27e2bf94ffdfd27b2c29e3df4a68c4193bb6427384259e2bf191967" dependencies = [ + "autocfg 1.0.1", "futures-channel", "futures-core", "futures-io", @@ -1184,9 +1187,9 @@ dependencies = [ [[package]] name = "getrandom" -version = "0.2.2" +version = "0.2.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c9495705279e7140bf035dde1f6e750c162df8b625267cd52cc44e0b156732c8" +checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753" dependencies = [ "cfg-if 1.0.0", "libc", @@ -1341,9 +1344,9 @@ dependencies = [ [[package]] name = "gimli" -version = "0.23.0" +version = "0.24.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f6503fe142514ca4799d4c26297c4248239fe8838d827db6bd6065c6ed29a6ce" +checksum = "0e4075386626662786ddb0ec9081e7c7eeb1ba31951f447ca780ef9f5d568189" [[package]] name = "glow" @@ -1398,9 +1401,9 @@ dependencies = [ [[package]] name = "gpu-alloc" -version = "0.4.5" +version = "0.4.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bc76088804bb65a6f3b880bea9306fdaeffb25ebb453105fafa691282ee9fdba" +checksum = "cbc1b6ca374e81862526786d9cb42357ce03706ed1b8761730caafd02ab91f3a" dependencies = [ "bitflags", "gpu-alloc-types", @@ -1456,7 +1459,7 @@ version = "0.11.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e" dependencies = [ - "ahash 0.7.2", + "ahash 0.7.4", "bumpalo", ] @@ -1513,7 +1516,7 @@ dependencies = [ "bitmaps", "rand_core 0.5.1", "rand_xoshiro", - "sized-chunks 0.6.4", + "sized-chunks 0.6.5", "typenum", "version_check", ] @@ -1541,7 +1544,7 @@ dependencies = [ "bitmaps", "rand_core 0.5.1", "rand_xoshiro", - "sized-chunks 0.6.4", + "sized-chunks 0.6.5", "typenum", "version_check", ] @@ -1582,12 +1585,19 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ce046d161f000fffde5f432a0d034d0341dc152643b2598ed5bfce44c4f3a8f0" dependencies = [ "proc-macro-hack", - "proc-macro2 1.0.26", + "proc-macro2 1.0.27", "quote 1.0.9", "syn 1.0.72", "unindent", ] +[[package]] +name = "inkwell" +version = "0.1.0" +dependencies = [ + "inkwell 0.1.0 (git+https://github.com/rtfeldman/inkwell?tag=llvm10-0.release4)", +] + [[package]] name = "inkwell" version = "0.1.0" @@ -1607,7 +1617,7 @@ name = "inkwell_internals" version = "0.3.0" source = "git+https://github.com/rtfeldman/inkwell?tag=llvm10-0.release4#9ae45f072645165885b2f347a4c0cc5ce9e22c80" dependencies = [ - "proc-macro2 1.0.26", + "proc-macro2 1.0.27", "quote 1.0.9", "syn 1.0.72", ] @@ -1674,9 +1684,9 @@ checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130" [[package]] name = "jobserver" -version = "0.1.21" +version = "0.1.22" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5c71313ebb9439f74b00d9d2dcec36440beaf57a6aa0623068441dd7cd81a7f2" +checksum = "972f5ae5d1cb9c6ae417789196c803205313edde988685da5e3aae0827b9e7fd" dependencies = [ "libc", ] @@ -1730,9 +1740,9 @@ checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55" [[package]] name = "libc" -version = "0.2.93" +version = "0.2.95" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9385f66bf6105b241aa65a61cb923ef20efc665cb9f9bb50ac2f0c4b7f378d41" +checksum = "789da6d93f1b866ffe175afc5322a4d76c038605a1c3319bb57b06967ca98a36" [[package]] name = "libloading" @@ -1770,14 +1780,14 @@ dependencies = [ "lazy_static", "libc", "regex", - "semver", + "semver 0.9.0", ] [[package]] name = "lock_api" -version = "0.4.3" +version = "0.4.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5a3c91c24eae6777794bb1997ad98bbb87daf92890acab859f7eaa4320333176" +checksum = "0382880606dff6d15c9476c416d18690b72742aa7b605bb6dd6ec9030fbf07eb" dependencies = [ "scopeguard", ] @@ -1814,9 +1824,9 @@ checksum = "60302e4db3a61da70c0cb7991976248362f30319e88850c487b9b95bbf059e00" [[package]] name = "memchr" -version = "2.3.4" +version = "2.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0ee1c47aaa256ecabcaea351eae4a9b01ef39ed810004e298d2511ed284b1525" +checksum = "b16bd47d9e329435e309c58469fe0791c2d0d1ba96ec0954152a5ae2b04387dc" [[package]] name = "memmap2" @@ -1838,9 +1848,9 @@ dependencies = [ [[package]] name = "memoffset" -version = "0.6.3" +version = "0.6.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f83fb6581e8ed1f85fd45c116db8405483899489e38406156c25eb743554361d" +checksum = "59accc507f1338036a0477ef61afdae33cde60840f4dfe481319ce3ad116ddf9" dependencies = [ "autocfg 1.0.1", ] @@ -1922,9 +1932,9 @@ dependencies = [ [[package]] name = "naga" -version = "0.4.1" +version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f470a97eafcdd0dbea43d5e1a8ef3557aa31f49ba643d9430dbbf911c162b24c" +checksum = "c8d74f2c7ace793a760165ac0679d6830809ad4e85f6886f72e4f8c4aa4291c5" dependencies = [ "bit-set", "bitflags", @@ -1971,7 +1981,7 @@ checksum = "05d1c6307dc424d0f65b9b06e94f88248e6305726b14729fd67a5e47b2dc481d" dependencies = [ "darling", "proc-macro-crate", - "proc-macro2 1.0.26", + "proc-macro2 1.0.27", "quote 1.0.9", "syn 1.0.72", ] @@ -2082,7 +2092,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ffa5a33ddddfee04c0283a7653987d634e880347e96b5b2ed64de07efb59db9d" dependencies = [ "proc-macro-crate", - "proc-macro2 1.0.26", + "proc-macro2 1.0.27", "quote 1.0.9", "syn 1.0.72", ] @@ -2126,12 +2136,6 @@ dependencies = [ "objc", ] -[[package]] -name = "object" -version = "0.23.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a9a7ab5d64814df0fe4a4b5ead45ed6c5f181ee3ff04ba344313a6c80446c5d4" - [[package]] name = "object" version = "0.24.0" @@ -2169,11 +2173,12 @@ checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5" [[package]] name = "ordered-float" -version = "2.1.1" +version = "2.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "766f840da25490628d8e63e529cd21c014f6600c6b8517add12a6fa6167a6218" +checksum = "809348965973b261c3e504c8d0434e465274f78c880e10039914f2c5dcf49461" dependencies = [ "num-traits", + "rand 0.8.3", ] [[package]] @@ -2200,7 +2205,7 @@ version = "0.12.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3a3c7a20e3f122223e68eef6ca58e39bc1ea8a1d83418ba4c2c1ba189d2ee355" dependencies = [ - "ttf-parser 0.12.0", + "ttf-parser 0.12.1", ] [[package]] @@ -2232,7 +2237,7 @@ version = "0.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0b4b5f600e60dd3a147fb57b4547033d382d1979eb087af310e91cb45a63b1f4" dependencies = [ - "proc-macro2 1.0.26", + "proc-macro2 1.0.27", "quote 1.0.9", "syn 1.0.72", ] @@ -2259,7 +2264,7 @@ dependencies = [ "instant", "libc", "petgraph", - "redox_syscall 0.2.5", + "redox_syscall 0.2.8", "smallvec", "thread-id", "winapi 0.3.9", @@ -2298,7 +2303,7 @@ checksum = "99b8db626e31e5b81787b9783425769681b347011cc59471e33ea46d2ea0cf55" dependencies = [ "pest", "pest_meta", - "proc-macro2 1.0.26", + "proc-macro2 1.0.27", "quote 1.0.9", "syn 1.0.72", ] @@ -2458,7 +2463,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "18f33027081eba0a6d8aba6d1b1c3a3be58cbb12106341c2d5759fcd9b5277e7" dependencies = [ "proc-macro-error-attr", - "proc-macro2 1.0.26", + "proc-macro2 1.0.27", "quote 1.0.9", "syn 1.0.72", "version_check", @@ -2470,7 +2475,7 @@ version = "0.4.12" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8a5b4b77fdb63c1eca72173d68d24501c54ab1269409f6b672c85deb18af69de" dependencies = [ - "proc-macro2 1.0.26", + "proc-macro2 1.0.27", "quote 1.0.9", "syn 1.0.72", "syn-mid", @@ -2500,11 +2505,11 @@ dependencies = [ [[package]] name = "proc-macro2" -version = "1.0.26" +version = "1.0.27" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a152013215dca273577e18d2bf00fa862b89b24169fb78c4c95aeb07992c9cec" +checksum = "f0d8caf72986c1a598726adc988bb5984792ef84f5ee5aa50209145ee8077038" dependencies = [ - "unicode-xid 0.2.1", + "unicode-xid 0.2.2", ] [[package]] @@ -2564,7 +2569,7 @@ version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b22a693222d716a9587786f37ac3f6b4faedb5b80c23914e7303ff5a1d8016e9" dependencies = [ - "proc-macro2 1.0.26", + "proc-macro2 1.0.27", "quote 1.0.9", "syn 1.0.72", ] @@ -2584,7 +2589,7 @@ version = "1.0.9" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c3d0b9745dc2debf507c8422de05d7226cc1f0644216dfdfead988f9b1ab32a7" dependencies = [ - "proc-macro2 1.0.26", + "proc-macro2 1.0.27", ] [[package]] @@ -2692,7 +2697,7 @@ version = "0.6.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "34cf66eb183df1c5876e2dcf6b13d57340741e8dc255b48e40a26de954d06ae7" dependencies = [ - "getrandom 0.2.2", + "getrandom 0.2.3", ] [[package]] @@ -2810,9 +2815,9 @@ dependencies = [ [[package]] name = "rayon" -version = "1.5.0" +version = "1.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b0d8e0819fadc20c74ea8373106ead0600e3a67ef1fe8da56e39b9ae7275674" +checksum = "c06aca804d41dbc8ba42dfd964f0d01334eceb64314b9ecf7c5fad5188a06d90" dependencies = [ "autocfg 1.0.1", "crossbeam-deque 0.8.0", @@ -2822,13 +2827,13 @@ dependencies = [ [[package]] name = "rayon-core" -version = "1.9.0" +version = "1.9.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9ab346ac5921dc62ffa9f89b7a773907511cdfa5490c572ae9be1be33e8afa4a" +checksum = "d78120e2c850279833f1dd3582f730c4ab53ed95aeaaaa862a2a5c71b1656d8e" dependencies = [ "crossbeam-channel 0.5.1", "crossbeam-deque 0.8.0", - "crossbeam-utils 0.8.3", + "crossbeam-utils 0.8.4", "lazy_static", "num_cpus", ] @@ -2850,9 +2855,9 @@ checksum = "41cc0f7e4d5d4544e8861606a285bb08d3e70712ccc7d2b84d7c0ccfaf4b05ce" [[package]] name = "redox_syscall" -version = "0.2.5" +version = "0.2.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "94341e4e44e24f6b591b59e47a8a027df12e008d73fd5672dbea9cc22f4507d9" +checksum = "742739e41cd49414de871ea5e549afb7e2a3ac77b589bcbebe8c82fab37147fc" dependencies = [ "bitflags", ] @@ -2863,15 +2868,15 @@ version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "528532f3d801c87aec9def2add9ca802fe569e44a544afe633765267840abe64" dependencies = [ - "getrandom 0.2.2", - "redox_syscall 0.2.5", + "getrandom 0.2.3", + "redox_syscall 0.2.8", ] [[package]] name = "regex" -version = "1.4.5" +version = "1.5.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "957056ecddbeba1b26965114e191d2e8589ce74db242b6ea25fc4062427a5c19" +checksum = "d07a8629359eb56f1e2fb1652bb04212c072a87ba68546a04065d525673ac461" dependencies = [ "aho-corasick", "memchr", @@ -2889,9 +2894,9 @@ dependencies = [ [[package]] name = "regex-syntax" -version = "0.6.23" +version = "0.6.25" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "24d5f089152e60f62d28b835fbff2cd2e8dc0baf1ac13343bef92ab7eed84548" +checksum = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b" [[package]] name = "remove_dir_all" @@ -2910,7 +2915,7 @@ dependencies = [ "im 14.3.0", "im-rc 14.3.0", "indoc 0.3.6", - "inkwell", + "inkwell 0.1.0", "inlinable_string", "libloading 0.6.7", "maplit", @@ -2985,7 +2990,7 @@ dependencies = [ "im 14.3.0", "im-rc 14.3.0", "indoc 0.3.6", - "inkwell", + "inkwell 0.1.0", "inlinable_string", "libc", "libloading 0.6.7", @@ -3147,7 +3152,7 @@ dependencies = [ "im 14.3.0", "im-rc 14.3.0", "indoc 0.3.6", - "inkwell", + "inkwell 0.1.0", "inlinable_string", "libc", "maplit", @@ -3186,7 +3191,7 @@ dependencies = [ "libc", "libloading 0.6.7", "maplit", - "object 0.24.0", + "object", "pretty_assertions 0.5.1", "quickcheck 0.8.5", "quickcheck_macros 0.8.0", @@ -3420,9 +3425,9 @@ dependencies = [ [[package]] name = "rustc-demangle" -version = "0.1.18" +version = "0.1.19" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6e3bad0ee36814ca07d7968269dd4b7ec89ec2da10c4bb613928d3077083c232" +checksum = "410f7acf3cb3a44527c5d9546bad4bf4e6c460915d5f9f2fc524498bfe8f70ce" [[package]] name = "rustc-hash" @@ -3432,11 +3437,11 @@ checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" [[package]] name = "rustc_version" -version = "0.2.3" +version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a" +checksum = "f0dfe2087c51c460008730de8b57e6a320782fbfb312e1f4d520e6c6fae155ee" dependencies = [ - "semver", + "semver 0.11.0", ] [[package]] @@ -3509,7 +3514,16 @@ version = "0.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403" dependencies = [ - "semver-parser", + "semver-parser 0.7.0", +] + +[[package]] +name = "semver" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f301af10236f6df4160f7c3f04eec6dbc70ace82d23326abad5edee88801c6b6" +dependencies = [ + "semver-parser 0.10.2", ] [[package]] @@ -3519,10 +3533,19 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3" [[package]] -name = "serde" -version = "1.0.125" +name = "semver-parser" +version = "0.10.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "558dc50e1a5a5fa7112ca2ce4effcb321b0300c0d4ccf0776a9f60cd89031171" +checksum = "00b0bef5b7f9e0df16536d3961cfb6e84331c065b4066afb39768d0e319411f7" +dependencies = [ + "pest", +] + +[[package]] +name = "serde" +version = "1.0.126" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec7505abeacaec74ae4778d9d9328fe5a5d04253220a85c4ee022239fc996d03" dependencies = [ "serde_derive", ] @@ -3551,11 +3574,11 @@ dependencies = [ [[package]] name = "serde_derive" -version = "1.0.125" +version = "1.0.126" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b093b7a2bb58203b5da3056c05b4ec1fed827dcfdb37347a8841695263b3d06d" +checksum = "963a7dbc9895aeac7ac90e74f34a5d5261828f79df35cbed41e10189d3804d43" dependencies = [ - "proc-macro2 1.0.26", + "proc-macro2 1.0.27", "quote 1.0.9", "syn 1.0.72", ] @@ -3600,7 +3623,7 @@ version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b2acd6defeddb41eb60bb468f8825d0cfd0c2a76bc03bfd235b6a1dc4f6a1ad5" dependencies = [ - "proc-macro2 1.0.26", + "proc-macro2 1.0.27", "quote 1.0.9", "syn 1.0.72", ] @@ -3619,9 +3642,9 @@ dependencies = [ [[package]] name = "sha2" -version = "0.9.4" +version = "0.9.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d8f6b75b17576b792bef0db1bcc4b8b8bcdf9506744cf34b974195487af6cff2" +checksum = "b362ae5752fd2137731f9fa25fd4d9058af34666ca1966fb969119cc35719f12" dependencies = [ "block-buffer 0.9.0", "cfg-if 1.0.0", @@ -3648,9 +3671,9 @@ dependencies = [ [[package]] name = "sized-chunks" -version = "0.6.4" +version = "0.6.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "65e65d6a9f13cd78f361ea5a2cf53a45d67cdda421ba0316b9be101560f3d207" +checksum = "16d69225bde7a69b235da73377861095455d298f2b970996eec25ddbb42b3d1e" dependencies = [ "bitmaps", "typenum", @@ -3658,9 +3681,9 @@ dependencies = [ [[package]] name = "slab" -version = "0.4.2" +version = "0.4.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c111b5bd5695e56cffe5129854aa230b39c93a305372fdbb2668ca2394eea9f8" +checksum = "f173ac3d1a7e3b28003f40de0b5ce7fe2710f9b9dc3fc38664cebee46b3b6527" [[package]] name = "slotmap" @@ -3720,7 +3743,7 @@ version = "0.6.10" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1508efa03c362e23817f96cde18abed596a25219a8b2c66e8db33c03543d315b" dependencies = [ - "proc-macro2 1.0.26", + "proc-macro2 1.0.27", "quote 1.0.9", "syn 1.0.72", ] @@ -3793,9 +3816,9 @@ version = "1.0.72" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a1e8cdbefb79a9a5a65e0db8b47b723ee907b7c7f8496c76a1770b5c310bab82" dependencies = [ - "proc-macro2 1.0.26", + "proc-macro2 1.0.27", "quote 1.0.9", - "unicode-xid 0.2.1", + "unicode-xid 0.2.2", ] [[package]] @@ -3804,7 +3827,7 @@ version = "0.5.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "baa8e7560a164edb1621a55d18a0c59abf49d360f47aa7b821061dd7eea7fac9" dependencies = [ - "proc-macro2 1.0.26", + "proc-macro2 1.0.27", "quote 1.0.9", "syn 1.0.72", ] @@ -3815,10 +3838,10 @@ version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b834f2d66f734cb897113e34aaff2f1ab4719ca946f9a7358dba8f8064148701" dependencies = [ - "proc-macro2 1.0.26", + "proc-macro2 1.0.27", "quote 1.0.9", "syn 1.0.72", - "unicode-xid 0.2.1", + "unicode-xid 0.2.2", ] [[package]] @@ -3836,7 +3859,7 @@ dependencies = [ "cfg-if 1.0.0", "libc", "rand 0.8.3", - "redox_syscall 0.2.5", + "redox_syscall 0.2.8", "remove_dir_all", "winapi 0.3.9", ] @@ -3859,7 +3882,7 @@ dependencies = [ "im 14.3.0", "im-rc 14.3.0", "indoc 0.3.6", - "inkwell", + "inkwell 0.1.0", "inlinable_string", "libc", "libloading 0.6.7", @@ -3898,20 +3921,20 @@ dependencies = [ [[package]] name = "thiserror" -version = "1.0.24" +version = "1.0.25" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e0f4a65597094d4483ddaed134f409b2cb7c1beccf25201a9f73c719254fa98e" +checksum = "fa6f76457f59514c7eeb4e59d891395fab0b2fd1d40723ae737d64153392e9c6" dependencies = [ "thiserror-impl", ] [[package]] name = "thiserror-impl" -version = "1.0.24" +version = "1.0.25" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7765189610d8241a44529806d6fd1f2e0a08734313a35d5b3a556f92b381f3c0" +checksum = "8a36768c0fbf1bb15eca10defa29526bda730a2376c2ab4393ccfa16fb1a318d" dependencies = [ - "proc-macro2 1.0.26", + "proc-macro2 1.0.27", "quote 1.0.9", "syn 1.0.72", ] @@ -3974,9 +3997,9 @@ checksum = "3e5d7cd7ab3e47dda6e56542f4bbf3824c15234958c6e1bd6aaa347e93499fdc" [[package]] name = "ttf-parser" -version = "0.12.0" +version = "0.12.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "85e00391c1f3d171490a3f8bd79999b0002ae38d3da0d6a3a306c754b053d71b" +checksum = "2fc71742ead70703a55d184f82087302f2f9ffa3793e64db46a78bf75dd723f4" [[package]] name = "twox-hash" @@ -4036,9 +4059,9 @@ checksum = "fc72304796d0818e357ead4e000d19c9c174ab23dc11093ac919054d20a6a7fc" [[package]] name = "unicode-xid" -version = "0.2.1" +version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f7fe0bb3479651439c9112f72b6c505038574c9fbb575ed1bf3b797fa39dd564" +checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3" [[package]] name = "unindent" @@ -4153,7 +4176,7 @@ dependencies = [ "bumpalo", "lazy_static", "log", - "proc-macro2 1.0.26", + "proc-macro2 1.0.27", "quote 1.0.9", "syn 1.0.72", "wasm-bindgen-shared", @@ -4187,7 +4210,7 @@ version = "0.2.74" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "be2241542ff3d9f241f5e2cb6dd09b37efe786df8851c54957683a49f0987a97" dependencies = [ - "proc-macro2 1.0.26", + "proc-macro2 1.0.27", "quote 1.0.9", "syn 1.0.72", "wasm-bindgen-backend", @@ -4257,7 +4280,7 @@ version = "0.28.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "389d680d7bd67512dc9c37f39560224327038deb0f0e8d33f870900441b68720" dependencies = [ - "proc-macro2 1.0.26", + "proc-macro2 1.0.27", "quote 1.0.9", "xml-rs", ] @@ -4458,9 +4481,9 @@ dependencies = [ [[package]] name = "x11-clipboard" -version = "0.5.1" +version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e5e937afd03b64b7be4f959cc044e09260a47241b71e56933f37db097bf7859d" +checksum = "b397ace6e980510de59a4fe3d4c758dffab231d6d747ce9fa1aba6b6035d5f32" dependencies = [ "xcb", ] @@ -4539,7 +4562,7 @@ version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d498dbd1fd7beb83c86709ae1c33ca50942889473473d287d56ce4770a18edfb" dependencies = [ - "proc-macro2 1.0.26", + "proc-macro2 1.0.27", "syn 1.0.72", "synstructure", ] diff --git a/Cargo.toml b/Cargo.toml index 8343f413ed..9edcc5aeb9 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -21,6 +21,7 @@ members = [ "compiler/arena_pool", "compiler/test_gen", "vendor/ena", + "vendor/inkwell", "vendor/pathfinding", "vendor/pretty", "editor", diff --git a/cli/Cargo.toml b/cli/Cargo.toml index 007d67b699..fd4b35aa7a 100644 --- a/cli/Cargo.toml +++ b/cli/Cargo.toml @@ -62,24 +62,7 @@ inlinable_string = "0.1" libc = "0.2" libloading = "0.6" -# NOTE: rtfeldman/inkwell is a fork of TheDan64/inkwell which does not change anything. -# -# The reason for this fork is that the way Inkwell is designed, you have to use -# a particular branch (e.g. "llvm8-0") in Cargo.toml. That would be fine, except that -# breaking changes get pushed directly to that branch, which breaks our build -# without warning. -# -# We tried referencing a specific rev on TheDan64/inkwell directly (instead of branch), -# but although that worked locally, it did not work on GitHub Actions. (After a few -# hours of investigation, gave up trying to figure out why.) So this is the workaround: -# having an immutable tag on the rtfeldman/inkwell fork which points to -# a particular "release" of Inkwell. -# -# When we want to update Inkwell, we can sync up rtfeldman/inkwell to the latest -# commit of TheDan64/inkwell, push a new tag which points to the latest commit, -# change the tag value in this Cargo.toml to point to that tag, and `cargo update`. -# This way, GitHub Actions works and nobody's builds get broken. -inkwell = { git = "https://github.com/rtfeldman/inkwell", tag = "llvm10-0.release4", features = [ "llvm10-0" ] } +inkwell = { path = "../vendor/inkwell" } target-lexicon = "0.10" tempfile = "3.1.0" diff --git a/compiler/build/Cargo.toml b/compiler/build/Cargo.toml index a7f173d2e2..aa3a13f3d8 100644 --- a/compiler/build/Cargo.toml +++ b/compiler/build/Cargo.toml @@ -28,24 +28,7 @@ inlinable_string = "0.1.0" libloading = "0.6" tempfile = "3.1.0" serde_json = "1.0" -# NOTE: rtfeldman/inkwell is a fork of TheDan64/inkwell which does not change anything. -# -# The reason for this fork is that the way Inkwell is designed, you have to use -# a particular branch (e.g. "llvm8-0") in Cargo.toml. That would be fine, except that -# breaking changes get pushed directly to that branch, which breaks our build -# without warning. -# -# We tried referencing a specific rev on TheDan64/inkwell directly (instead of branch), -# but although that worked locally, it did not work on GitHub Actions. (After a few -# hours of investigation, gave up trying to figure out why.) So this is the workaround: -# having an immutable tag on the rtfeldman/inkwell fork which points to -# a particular "release" of Inkwell. -# -# When we want to update Inkwell, we can sync up rtfeldman/inkwell to the latest -# commit of TheDan64/inkwell, push a new tag which points to the latest commit, -# change the tag value in this Cargo.toml to point to that tag, and `cargo update`. -# This way, GitHub Actions works and nobody's builds get broken. -inkwell = { git = "https://github.com/rtfeldman/inkwell", tag = "llvm10-0.release4", features = [ "llvm10-0" ] } +inkwell = { path = "../../vendor/inkwell" } target-lexicon = "0.10" [dev-dependencies] diff --git a/compiler/gen/Cargo.toml b/compiler/gen/Cargo.toml index e6ad3aaf21..685b00fa3a 100644 --- a/compiler/gen/Cargo.toml +++ b/compiler/gen/Cargo.toml @@ -20,24 +20,7 @@ im-rc = "14" # im and im-rc should always have the same version! bumpalo = { version = "3.6.1", features = ["collections"] } inlinable_string = "0.1" either = "1.6.1" -# NOTE: rtfeldman/inkwell is a fork of TheDan64/inkwell which does not change anything. -# -# The reason for this fork is that the way Inkwell is designed, you have to use -# a particular branch (e.g. "llvm8-0") in Cargo.toml. That would be fine, except that -# breaking changes get pushed directly to that branch, which breaks our build -# without warning. -# -# We tried referencing a specific rev on TheDan64/inkwell directly (instead of branch), -# but although that worked locally, it did not work on GitHub Actions. (After a few -# hours of investigation, gave up trying to figure out why.) So this is the workaround: -# having an immutable tag on the rtfeldman/inkwell fork which points to -# a particular "release" of Inkwell. -# -# When we want to update Inkwell, we can sync up rtfeldman/inkwell to the latest -# commit of TheDan64/inkwell, push a new tag which points to the latest commit, -# change the tag value in this Cargo.toml to point to that tag, and `cargo update`. -# This way, GitHub Actions works and nobody's builds get broken. -inkwell = { git = "https://github.com/rtfeldman/inkwell", tag = "llvm10-0.release4", features = [ "llvm10-0" ] } +inkwell = { path = "../../vendor/inkwell" } target-lexicon = "0.10" [dev-dependencies] diff --git a/compiler/test_gen/Cargo.toml b/compiler/test_gen/Cargo.toml index 61058dd120..7300d3ee57 100644 --- a/compiler/test_gen/Cargo.toml +++ b/compiler/test_gen/Cargo.toml @@ -30,24 +30,7 @@ inlinable_string = "0.1" either = "1.6.1" indoc = "0.3.3" libc = "0.2" -# NOTE: rtfeldman/inkwell is a fork of TheDan64/inkwell which does not change anything. -# -# The reason for this fork is that the way Inkwell is designed, you have to use -# a particular branch (e.g. "llvm8-0") in Cargo.toml. That would be fine, except that -# breaking changes get pushed directly to that branch, which breaks our build -# without warning. -# -# We tried referencing a specific rev on TheDan64/inkwell directly (instead of branch), -# but although that worked locally, it did not work on GitHub Actions. (After a few -# hours of investigation, gave up trying to figure out why.) So this is the workaround: -# having an immutable tag on the rtfeldman/inkwell fork which points to -# a particular "release" of Inkwell. -# -# When we want to update Inkwell, we can sync up rtfeldman/inkwell to the latest -# commit of TheDan64/inkwell, push a new tag which points to the latest commit, -# change the tag value in this Cargo.toml to point to that tag, and `cargo update`. -# This way, GitHub Actions works and nobody's builds get broken. -inkwell = { git = "https://github.com/rtfeldman/inkwell", tag = "llvm10-0.release4", features = [ "llvm10-0" ] } +inkwell = { path = "../../vendor/inkwell" } target-lexicon = "0.10" libloading = "0.6" diff --git a/vendor/inkwell/Cargo.toml b/vendor/inkwell/Cargo.toml new file mode 100644 index 0000000000..0aecbc592d --- /dev/null +++ b/vendor/inkwell/Cargo.toml @@ -0,0 +1,31 @@ +[package] +name = "inkwell" +version = "0.1.0" +authors = ["The Roc Contributors"] +license = "UPL-1.0" +edition = "2018" + +[dependencies] +# NOTE: rtfeldman/inkwell is a fork of TheDan64/inkwell which does not change anything. +# +# The reason for this fork is that the way Inkwell is designed, you have to use +# a particular branch (e.g. "llvm8-0") in Cargo.toml. That would be fine, except that +# breaking changes get pushed directly to that branch, which breaks our build +# without warning. +# +# We tried referencing a specific rev on TheDan64/inkwell directly (instead of branch), +# but although that worked locally, it did not work on GitHub Actions. (After a few +# hours of investigation, gave up trying to figure out why.) So this is the workaround: +# having an immutable tag on the rtfeldman/inkwell fork which points to +# a particular "release" of Inkwell. +# +# When we want to update Inkwell, we can sync up rtfeldman/inkwell to the latest +# commit of TheDan64/inkwell, push a new tag which points to the latest commit, +# change the tag value in this Cargo.toml to point to that tag, and `cargo update`. +# This way, GitHub Actions works and nobody's builds get broken. +inkwell = { git = "https://github.com/rtfeldman/inkwell", tag = "llvm10-0.release4", features = [ "llvm10-0" ] } + +[features] +target-arm = [] +target-aarch64 = [] +target-webassembly = [] diff --git a/vendor/inkwell/src/lib.rs b/vendor/inkwell/src/lib.rs new file mode 100644 index 0000000000..8136cc5eae --- /dev/null +++ b/vendor/inkwell/src/lib.rs @@ -0,0 +1,4 @@ +#![cfg(not(doctest))] +// re-export all inkwell members. This way we can switch +// inkwell versions by making changes in just one place. +pub use inkwell::*; From ade591dd10e6701d62e175c38655baf09c988fc7 Mon Sep 17 00:00:00 2001 From: tarjei Date: Sat, 29 May 2021 22:11:38 +0200 Subject: [PATCH 043/496] Fix plumbing --- compiler/builtins/bitcode/src/list.zig | 10 ++++++++++ compiler/can/src/builtins.rs | 4 ++-- compiler/gen/src/llvm/build.rs | 7 ++++--- compiler/gen/src/llvm/build_list.rs | 8 ++++---- compiler/module/src/low_level.rs | 1 + compiler/test_gen/src/gen_list.rs | 6 +----- 6 files changed, 22 insertions(+), 14 deletions(-) diff --git a/compiler/builtins/bitcode/src/list.zig b/compiler/builtins/bitcode/src/list.zig index f5dbea5dc1..d22c7136a1 100644 --- a/compiler/builtins/bitcode/src/list.zig +++ b/compiler/builtins/bitcode/src/list.zig @@ -722,6 +722,16 @@ pub fn listAppend(list: RocList, alignment: u32, element: Opaque, element_width: return output; } +pub fn listSwap( + list: RocList, + alignment: u32, + element_width: usize, + index_1: usize, + index_2: usize, +) callconv(.C) RocList { + return RocList.empty(); +} + pub fn listDrop( list: RocList, alignment: u32, diff --git a/compiler/can/src/builtins.rs b/compiler/can/src/builtins.rs index c150747d81..ef76fc7c44 100644 --- a/compiler/can/src/builtins.rs +++ b/compiler/can/src/builtins.rs @@ -1885,13 +1885,13 @@ fn list_set(symbol: Symbol, var_store: &mut VarStore) -> Def { } /// List.swap : List elem, Nat, Nat -> List elem -fn list_drop(symbol: Symbol, var_store: &mut VarStore) -> Def { +fn list_swap(symbol: Symbol, var_store: &mut VarStore) -> Def { let list_var = var_store.fresh(); let index1_var = var_store.fresh(); let index2_var = var_store.fresh(); let body = RunLowLevel { - op: LowLevel::ListDrop, + op: LowLevel::ListSwap, args: vec![ (list_var, Var(Symbol::ARG_1)), (index1_var, Var(Symbol::ARG_2)), diff --git a/compiler/gen/src/llvm/build.rs b/compiler/gen/src/llvm/build.rs index 6f0258c58b..8270705787 100644 --- a/compiler/gen/src/llvm/build.rs +++ b/compiler/gen/src/llvm/build.rs @@ -4171,15 +4171,16 @@ fn run_low_level<'a, 'ctx, 'env>( let (list, list_layout) = load_symbol_and_layout(scope, &args[0]); let original_wrapper = list.into_struct_value(); - let count = load_symbol(scope, &args[1]); + let index_1 = load_symbol(scope, &args[1]); + let index_2 = load_symbol(scope, &args[2]); match list_layout { Layout::Builtin(Builtin::EmptyList) => empty_list(env), Layout::Builtin(Builtin::List(element_layout)) => list_swap( env, - layout_ids, original_wrapper, - count.into_int_value(), + index_1.into_int_value(), + index_2.into_int_value(), element_layout, ), _ => unreachable!("Invalid layout {:?} in List.swap", list_layout), diff --git a/compiler/gen/src/llvm/build_list.rs b/compiler/gen/src/llvm/build_list.rs index 052b72ec2e..fbed8c99a1 100644 --- a/compiler/gen/src/llvm/build_list.rs +++ b/compiler/gen/src/llvm/build_list.rs @@ -307,19 +307,19 @@ pub fn list_append<'a, 'ctx, 'env>( /// List.swap : List elem, Nat, Nat -> List elem pub fn list_swap<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, - layout_ids: &mut LayoutIds<'a>, original_wrapper: StructValue<'ctx>, - count: IntValue<'ctx>, + index_1: IntValue<'ctx>, + index_2: IntValue<'ctx>, element_layout: &Layout<'a>, ) -> BasicValueEnum<'ctx> { - let dec_element_fn = build_dec_wrapper(env, layout_ids, &element_layout); call_bitcode_fn_returns_list( env, &[ pass_list_as_i128(env, original_wrapper.into()), env.alignment_intvalue(&element_layout), layout_width(env, &element_layout), - count.into(), + index_1.into(), + index_2.into(), ], &bitcode::LIST_SWAP, ) diff --git a/compiler/module/src/low_level.rs b/compiler/module/src/low_level.rs index 7617d33832..d20c57a420 100644 --- a/compiler/module/src/low_level.rs +++ b/compiler/module/src/low_level.rs @@ -40,6 +40,7 @@ pub enum LowLevel { ListKeepErrs, ListSortWith, ListDrop, + ListSwap, DictSize, DictEmpty, DictInsert, diff --git a/compiler/test_gen/src/gen_list.rs b/compiler/test_gen/src/gen_list.rs index b8450b27be..4aed0a0c6c 100644 --- a/compiler/test_gen/src/gen_list.rs +++ b/compiler/test_gen/src/gen_list.rs @@ -181,11 +181,7 @@ fn list_drop() { #[test] fn list_swap() { - assert_evals_to!( - "List.swap [] 0 1", - RocList::from_slice(&[]), - RocList - ); + assert_evals_to!("List.swap [] 0 1", RocList::from_slice(&[]), RocList); assert_evals_to!( "List.swap [ 0 ] 1 2", RocList::from_slice(&[0]), From 64576ddab537c25b808a0aca251246df4306040c Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 29 May 2021 23:00:28 +0200 Subject: [PATCH 044/496] add exception id to invoke/rethrow --- compiler/gen/src/llvm/build.rs | 37 ++++---- compiler/gen_dev/src/lib.rs | 4 +- compiler/mono/src/alias_analysis.rs | 3 +- compiler/mono/src/borrow.rs | 5 +- compiler/mono/src/expand_rc.rs | 4 +- compiler/mono/src/inc_dec.rs | 8 +- compiler/mono/src/ir.rs | 125 +++++++++++++--------------- compiler/mono/src/tail_recursion.rs | 7 +- 8 files changed, 101 insertions(+), 92 deletions(-) diff --git a/compiler/gen/src/llvm/build.rs b/compiler/gen/src/llvm/build.rs index 41dacb9476..67bb9b466b 100644 --- a/compiler/gen/src/llvm/build.rs +++ b/compiler/gen/src/llvm/build.rs @@ -48,7 +48,9 @@ use roc_collections::all::{ImMap, MutSet}; use roc_module::ident::TagName; use roc_module::low_level::LowLevel; use roc_module::symbol::{Interns, ModuleId, Symbol}; -use roc_mono::ir::{BranchInfo, CallType, JoinPointId, ModifyRc, TopLevelFunctionLayout, Wrapped}; +use roc_mono::ir::{ + BranchInfo, CallType, ExceptionId, JoinPointId, ModifyRc, TopLevelFunctionLayout, Wrapped, +}; use roc_mono::layout::{Builtin, InPlace, LambdaSet, Layout, LayoutIds, UnionLayout}; use target_lexicon::CallingConvention; @@ -1821,6 +1823,7 @@ fn invoke_roc_function<'a, 'ctx, 'env>( closure_argument: Option>, pass: &'a roc_mono::ir::Stmt<'a>, fail: &'a roc_mono::ir::Stmt<'a>, + exception_id: ExceptionId, ) -> BasicValueEnum<'ctx> { let context = env.context; @@ -1877,14 +1880,17 @@ fn invoke_roc_function<'a, 'ctx, 'env>( context.struct_type(&[exception_ptr, selector_value], false) }; - env.builder - .build_catch_all_landing_pad( - &landing_pad_type, - &BasicValueEnum::IntValue(context.i8_type().const_zero()), - context.i8_type().ptr_type(AddressSpace::Generic), - "invoke_landing_pad", - ) - .into_struct_value(); + let exception_object = env.builder.build_cleanup_landing_pad( + &landing_pad_type, + &BasicValueEnum::IntValue(context.i8_type().const_zero()), + context.i8_type().ptr_type(AddressSpace::Generic), + "invoke_landing_pad", + ); + + scope.insert( + exception_id.into_inner(), + (Layout::Struct(&[]), exception_object), + ); build_exp_stmt(env, layout_ids, scope, parent, fail); } @@ -1983,7 +1989,8 @@ pub fn build_exp_stmt<'a, 'ctx, 'env>( call, layout, pass, - fail: roc_mono::ir::Stmt::Rethrow, + fail: roc_mono::ir::Stmt::Rethrow(_), + exception_id: _, } => { // when the fail case is just Rethrow, there is no cleanup work to do // so we can just treat this invoke as a normal call @@ -1997,6 +2004,7 @@ pub fn build_exp_stmt<'a, 'ctx, 'env>( layout, pass, fail, + exception_id, } => match call.call_type { CallType::ByName { name, @@ -2017,6 +2025,7 @@ pub fn build_exp_stmt<'a, 'ctx, 'env>( None, pass, fail, + *exception_id, ) } @@ -2047,11 +2056,9 @@ pub fn build_exp_stmt<'a, 'ctx, 'env>( } }, - Rethrow => { - cxa_rethrow_exception(env); - - // used in exception handling - env.builder.build_unreachable(); + Rethrow(exception_id) => { + let exception_object = scope.get(&exception_id.into_inner()).unwrap().1; + env.builder.build_resume(&exception_object); env.context.i64_type().const_zero().into() } diff --git a/compiler/gen_dev/src/lib.rs b/compiler/gen_dev/src/lib.rs index d6544bfbc1..d396b070fc 100644 --- a/compiler/gen_dev/src/lib.rs +++ b/compiler/gen_dev/src/lib.rs @@ -106,6 +106,7 @@ where call, pass, fail: _, + exception_id: _, } => { // for now, treat invoke as a normal call self.build_expr(symbol, &Expr::Call(call.clone()), layout)?; @@ -486,6 +487,7 @@ where call, pass, fail: _, + exception_id: _, } => { // for now, treat invoke as a normal call self.set_last_seen(*symbol, stmt); @@ -508,7 +510,7 @@ where Stmt::Ret(sym) => { self.set_last_seen(*sym, stmt); } - Stmt::Rethrow => {} + Stmt::Rethrow(_exception_id) => {} Stmt::Refcounting(modify, following) => { let sym = modify.get_symbol(); diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index dd3590e57c..fd869a7b36 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -105,6 +105,7 @@ fn stmt_spec( layout: call_layout, pass, fail, + exception_id: _, } => { // a call that might throw an exception @@ -208,7 +209,7 @@ fn stmt_spec( let jpid = env.join_points[id]; builder.add_jump(block, jpid, argument, ret_type_id) } - Rethrow | RuntimeError(_) => { + Rethrow(_) | RuntimeError(_) => { let type_id = layout_spec(builder, layout)?; builder.add_terminate(block, type_id) diff --git a/compiler/mono/src/borrow.rs b/compiler/mono/src/borrow.rs index 443bfb20df..9d7540ee3c 100644 --- a/compiler/mono/src/borrow.rs +++ b/compiler/mono/src/borrow.rs @@ -220,7 +220,7 @@ impl<'a> ParamMap<'a> { } Refcounting(_, _) => unreachable!("these have not been introduced yet"), - Ret(_) | Rethrow | Jump(_, _) | RuntimeError(_) => { + Ret(_) | Rethrow(_) | Jump(_, _) | RuntimeError(_) => { // these are terminal, do nothing } } @@ -641,6 +641,7 @@ impl<'a> BorrowInfState<'a> { layout: _, pass, fail, + exception_id: _, } => { self.collect_stmt(pass); self.collect_stmt(fail); @@ -672,7 +673,7 @@ impl<'a> BorrowInfState<'a> { } Refcounting(_, _) => unreachable!("these have not been introduced yet"), - Ret(_) | RuntimeError(_) | Rethrow => { + Ret(_) | RuntimeError(_) | Rethrow(_) => { // these are terminal, do nothing } } diff --git a/compiler/mono/src/expand_rc.rs b/compiler/mono/src/expand_rc.rs index d3c852a737..ec9f669c93 100644 --- a/compiler/mono/src/expand_rc.rs +++ b/compiler/mono/src/expand_rc.rs @@ -602,6 +602,7 @@ fn expand_and_cancel<'a>(env: &mut Env<'a, '_>, stmt: &'a Stmt<'a>) -> &'a Stmt< layout, pass, fail, + exception_id, } => { let pass = expand_and_cancel(env, pass); let fail = expand_and_cancel(env, fail); @@ -612,6 +613,7 @@ fn expand_and_cancel<'a>(env: &mut Env<'a, '_>, stmt: &'a Stmt<'a>) -> &'a Stmt< layout: *layout, pass, fail, + exception_id: *exception_id, }; env.arena.alloc(stmt) @@ -636,7 +638,7 @@ fn expand_and_cancel<'a>(env: &mut Env<'a, '_>, stmt: &'a Stmt<'a>) -> &'a Stmt< env.arena.alloc(stmt) } - Rethrow | Ret(_) | Jump(_, _) | RuntimeError(_) => stmt, + Rethrow(_) | Ret(_) | Jump(_, _) | RuntimeError(_) => stmt, } }; diff --git a/compiler/mono/src/inc_dec.rs b/compiler/mono/src/inc_dec.rs index 3ab421a27c..8c23be0913 100644 --- a/compiler/mono/src/inc_dec.rs +++ b/compiler/mono/src/inc_dec.rs @@ -50,7 +50,7 @@ pub fn occuring_variables(stmt: &Stmt<'_>) -> (MutSet, MutSet) { result.insert(*symbol); } - Rethrow => {} + Rethrow(_) => {} Refcounting(modify, cont) => { let symbol = modify.get_symbol(); @@ -892,6 +892,7 @@ impl<'a> Context<'a> { pass, fail, layout, + exception_id, } => { // live vars of the whole expression let invoke_live_vars = collect_stmt(stmt, &self.jp_live_vars, MutSet::default()); @@ -926,6 +927,7 @@ impl<'a> Context<'a> { pass, fail, layout: *layout, + exception_id: *exception_id, }; let cont = self.arena.alloc(invoke); @@ -1009,7 +1011,7 @@ impl<'a> Context<'a> { } } - Rethrow => (stmt, MutSet::default()), + Rethrow(_) => (stmt, MutSet::default()), Jump(j, xs) => { let empty = MutSet::default(); @@ -1175,7 +1177,7 @@ pub fn collect_stmt( vars } - Rethrow => vars, + Rethrow(_) => vars, RuntimeError(_) => vars, } diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 4bedd2dae6..f679ba4dee 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -855,6 +855,7 @@ pub enum Stmt<'a> { layout: Layout<'a>, pass: &'a Stmt<'a>, fail: &'a Stmt<'a>, + exception_id: ExceptionId, }, Switch { /// This *must* stand for an integer, because Switch potentially compiles to a jump table. @@ -869,7 +870,7 @@ pub enum Stmt<'a> { ret_layout: Layout<'a>, }, Ret(Symbol), - Rethrow, + Rethrow(ExceptionId), Refcounting(ModifyRc, &'a Stmt<'a>), /// a join point `join f = in remainder` Join { @@ -1361,7 +1362,7 @@ impl<'a> Stmt<'a> { symbol, call, pass, - fail: Stmt::Rethrow, + fail: Stmt::Rethrow(_), .. } => alloc .text("let ") @@ -1394,7 +1395,7 @@ impl<'a> Stmt<'a> { .append(symbol_to_doc(alloc, *symbol)) .append(";"), - Rethrow => alloc.text("unreachable;"), + Rethrow(_) => alloc.text("unreachable;"), Switch { cond_symbol, @@ -4684,12 +4685,14 @@ pub fn from_can<'a>( arguments, }; + let exception_id = ExceptionId(env.unique_symbol()); let rest = Stmt::Invoke { symbol: env.unique_symbol(), call, layout: bool_layout, pass: env.arena.alloc(rest), - fail: env.arena.alloc(Stmt::Rethrow), + fail: env.arena.alloc(Stmt::Rethrow(exception_id)), + exception_id, }; with_hole( @@ -5271,6 +5274,7 @@ fn substitute_in_stmt_help<'a>( layout, pass, fail, + exception_id, } => { let opt_call = substitute_in_call(arena, call, subs); let opt_pass = substitute_in_stmt_help(arena, pass, subs); @@ -5287,6 +5291,7 @@ fn substitute_in_stmt_help<'a>( layout: *layout, pass, fail, + exception_id: *exception_id, })) } else { None @@ -5406,7 +5411,7 @@ fn substitute_in_stmt_help<'a>( } } - Rethrow => None, + Rethrow(_) => None, RuntimeError(_) => None, } @@ -5909,7 +5914,7 @@ fn force_thunk<'a>( arguments: &[], }; - Stmt::Let(assigned, Expr::Call(call), layout, env.arena.alloc(hole)) + build_call(env, call, assigned, layout, env.arena.alloc(hole)) } fn let_empty_struct<'a>(assigned: Symbol, hole: &'a Stmt<'a>) -> Stmt<'a> { @@ -6160,6 +6165,18 @@ fn can_throw_exception(call: &Call) -> bool { } } +/// Symbol that links an Invoke with a Rethrow +/// we'll assign the exception object to this symbol +/// so we can later rethrow the exception +#[derive(Copy, Clone, PartialEq, Debug)] +pub struct ExceptionId(Symbol); + +impl ExceptionId { + pub fn into_inner(self) -> Symbol { + self.0 + } +} + fn build_call<'a>( env: &mut Env<'a, '_>, call: Call<'a>, @@ -6168,13 +6185,15 @@ fn build_call<'a>( hole: &'a Stmt<'a>, ) -> Stmt<'a> { if can_throw_exception(&call) { - let fail = env.arena.alloc(Stmt::Rethrow); + let id = ExceptionId(env.unique_symbol()); + let fail = env.arena.alloc(Stmt::Rethrow(id)); Stmt::Invoke { symbol: assigned, call, layout, fail, pass: hole, + exception_id: id, } } else { Stmt::Let(assigned, Expr::Call(call), layout, hole) @@ -7693,17 +7712,9 @@ where Layout::Struct(_) => { let function_symbol = lambda_set.set[0].0; - // build the call - Stmt::Let( - assigned, - Expr::Call(to_lowlevel_call( - function_symbol, - closure_data_symbol, - function_layout, - )), - return_layout, - env.arena.alloc(hole), - ) + let call = to_lowlevel_call(function_symbol, closure_data_symbol, function_layout); + + build_call(env, call, assigned, return_layout, env.arena.alloc(hole)) } Layout::Builtin(Builtin::Int1) => { let closure_tag_id_symbol = closure_data_symbol; @@ -7768,17 +7779,8 @@ where let hole = Stmt::Jump(join_point_id, env.arena.alloc([assigned])); - // build the call - let stmt = Stmt::Let( - assigned, - Expr::Call(to_lowlevel_call( - *function_symbol, - closure_data_symbol, - function_layout, - )), - return_layout, - env.arena.alloc(hole), - ); + let call = to_lowlevel_call(*function_symbol, closure_data_symbol, function_layout); + let stmt = build_call(env, call, assigned, return_layout, env.arena.alloc(hole)); branches.push((i as u64, BranchInfo::None, stmt)); } @@ -8036,21 +8038,18 @@ fn union_lambda_set_branch_help<'a>( let full_layout = Layout::FunctionPointer(argument_layouts, env.arena.alloc(return_layout)); // build the call - Stmt::Let( - assigned, - Expr::Call(self::Call { - call_type: CallType::ByName { - name: function_symbol, - full_layout, - ret_layout: return_layout, - arg_layouts: argument_layouts, - specialization_id: env.next_call_specialization_id(), - }, - arguments: argument_symbols, - }), - return_layout, - hole, - ) + let call = self::Call { + call_type: CallType::ByName { + name: function_symbol, + full_layout, + ret_layout: return_layout, + arg_layouts: argument_layouts, + specialization_id: env.next_call_specialization_id(), + }, + arguments: argument_symbols, + }; + + build_call(env, call, assigned, return_layout, hole) } #[allow(clippy::too_many_arguments)] @@ -8159,22 +8158,17 @@ fn enum_lambda_set_branch<'a>( let full_layout = Layout::FunctionPointer(argument_layouts, env.arena.alloc(return_layout)); - // build the call - Stmt::Let( - assigned, - Expr::Call(self::Call { - call_type: CallType::ByName { - name: function_symbol, - full_layout, - ret_layout: return_layout, - arg_layouts: argument_layouts, - specialization_id: env.next_call_specialization_id(), - }, - arguments: argument_symbols, - }), - return_layout, - env.arena.alloc(hole), - ) + let call = self::Call { + call_type: CallType::ByName { + name: function_symbol, + full_layout, + ret_layout: return_layout, + arg_layouts: argument_layouts, + specialization_id: env.next_call_specialization_id(), + }, + arguments: argument_symbols, + }; + build_call(env, call, assigned, return_layout, env.arena.alloc(hole)) } #[allow(clippy::too_many_arguments)] @@ -8204,14 +8198,11 @@ where let hole = Stmt::Jump(join_point_id, env.arena.alloc([result_symbol])); - // build the call - let stmt = Stmt::Let( + let call = to_lowlevel_call(*function_symbol, closure_data_symbol, function_layout); + let stmt = build_call( + env, + call, result_symbol, - Expr::Call(to_lowlevel_call( - *function_symbol, - closure_data_symbol, - function_layout, - )), return_layout, env.arena.alloc(hole), ); diff --git a/compiler/mono/src/tail_recursion.rs b/compiler/mono/src/tail_recursion.rs index 4bb77a90e4..38f8c57f5f 100644 --- a/compiler/mono/src/tail_recursion.rs +++ b/compiler/mono/src/tail_recursion.rs @@ -102,9 +102,10 @@ fn insert_jumps<'a>( }, fail, pass: Stmt::Ret(rsym), + exception_id, .. } if needle == *fsym && symbol == rsym => { - debug_assert_eq!(fail, &&Stmt::Rethrow); + debug_assert_eq!(fail, &&Stmt::Rethrow(*exception_id)); // replace the call and return with a jump @@ -131,6 +132,7 @@ fn insert_jumps<'a>( fail, pass, layout, + exception_id, } => { let opt_pass = insert_jumps(arena, pass, goal_id, needle); let opt_fail = insert_jumps(arena, fail, goal_id, needle); @@ -145,6 +147,7 @@ fn insert_jumps<'a>( layout: *layout, pass, fail, + exception_id: *exception_id, }; Some(arena.alloc(stmt)) @@ -238,7 +241,7 @@ fn insert_jumps<'a>( None => None, }, - Rethrow => None, + Rethrow(_) => None, Ret(_) => None, Jump(_, _) => None, RuntimeError(_) => None, From 50ea46e73e39e3f3040b8f2bf8a3f4bbd8c8c6c4 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 29 May 2021 23:29:33 +0200 Subject: [PATCH 045/496] add test --- compiler/test_gen/src/gen_primitives.rs | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/compiler/test_gen/src/gen_primitives.rs b/compiler/test_gen/src/gen_primitives.rs index 13706cab7a..0fd75bf227 100644 --- a/compiler/test_gen/src/gen_primitives.rs +++ b/compiler/test_gen/src/gen_primitives.rs @@ -878,6 +878,29 @@ fn when_peano() { ); } +#[test] +#[should_panic(expected = "Roc failed with message: ")] +fn overflow_frees_list() { + assert_evals_to!( + indoc!( + r#" + myList = [1,2,3] + + # integer overflow; must use the list so it is defined before the overflow + # the list will then be freed in a cleanup block + n : I64 + n = 9_223_372_036_854_775_807 + (Num.intCast (List.len myList)) + + index = Num.intCast n + + List.get myList index + "# + ), + 3, + i64 + ); +} + #[test] #[should_panic(expected = "Roc failed with message: ")] fn undefined_variable() { From 9e8dddc0fd91fd1919399e28e8b0048c65727b2a Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sat, 29 May 2021 21:43:26 -0400 Subject: [PATCH 046/496] Bump inkwell version --- Cargo.lock | 6 +++--- vendor/inkwell/Cargo.toml | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 0323839957..54e6000ee5 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1595,13 +1595,13 @@ dependencies = [ name = "inkwell" version = "0.1.0" dependencies = [ - "inkwell 0.1.0 (git+https://github.com/rtfeldman/inkwell?tag=llvm10-0.release4)", + "inkwell 0.1.0 (git+https://github.com/rtfeldman/inkwell?tag=llvm10-0.release5)", ] [[package]] name = "inkwell" version = "0.1.0" -source = "git+https://github.com/rtfeldman/inkwell?tag=llvm10-0.release4#9ae45f072645165885b2f347a4c0cc5ce9e22c80" +source = "git+https://github.com/rtfeldman/inkwell?tag=llvm10-0.release5#f0a32d3a0595bda3777a7b7e08a2e46c97eba6f4" dependencies = [ "either", "inkwell_internals", @@ -1615,7 +1615,7 @@ dependencies = [ [[package]] name = "inkwell_internals" version = "0.3.0" -source = "git+https://github.com/rtfeldman/inkwell?tag=llvm10-0.release4#9ae45f072645165885b2f347a4c0cc5ce9e22c80" +source = "git+https://github.com/rtfeldman/inkwell?tag=llvm10-0.release5#f0a32d3a0595bda3777a7b7e08a2e46c97eba6f4" dependencies = [ "proc-macro2 1.0.27", "quote 1.0.9", diff --git a/vendor/inkwell/Cargo.toml b/vendor/inkwell/Cargo.toml index 0aecbc592d..970a89fcf0 100644 --- a/vendor/inkwell/Cargo.toml +++ b/vendor/inkwell/Cargo.toml @@ -23,7 +23,7 @@ edition = "2018" # commit of TheDan64/inkwell, push a new tag which points to the latest commit, # change the tag value in this Cargo.toml to point to that tag, and `cargo update`. # This way, GitHub Actions works and nobody's builds get broken. -inkwell = { git = "https://github.com/rtfeldman/inkwell", tag = "llvm10-0.release4", features = [ "llvm10-0" ] } +inkwell = { git = "https://github.com/rtfeldman/inkwell", tag = "llvm10-0.release5", features = [ "llvm10-0" ] } [features] target-arm = [] From 4eacbf5794204bff2f79fe1fdc2413baff259135 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 30 May 2021 14:42:04 +0200 Subject: [PATCH 047/496] remove cxa_rethrow_exception --- compiler/gen/src/llvm/build.rs | 26 -------------------------- 1 file changed, 26 deletions(-) diff --git a/compiler/gen/src/llvm/build.rs b/compiler/gen/src/llvm/build.rs index 67bb9b466b..c7ad6064ec 100644 --- a/compiler/gen/src/llvm/build.rs +++ b/compiler/gen/src/llvm/build.rs @@ -5738,32 +5738,6 @@ fn cxa_throw_exception<'a, 'ctx, 'env>(env: &Env<'a, 'ctx, 'env>, info: BasicVal call.set_call_convention(C_CALL_CONV); } -fn cxa_rethrow_exception(env: &Env<'_, '_, '_>) { - let name = "__cxa_rethrow"; - - let module = env.module; - let context = env.context; - - let function = match module.get_function(&name) { - Some(gvalue) => gvalue, - None => { - let cxa_rethrow = add_func( - module, - name, - context.void_type().fn_type(&[], false), - Linkage::External, - C_CALL_CONV, - ); - - cxa_rethrow - } - }; - let call = env.builder.build_call(function, &[], "rethrow"); - - call.set_call_convention(C_CALL_CONV); - // call.try_as_basic_value().left().unwrap() -} - fn get_foreign_symbol<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, foreign_symbol: roc_module::ident::ForeignSymbol, From 03cc96f4edd0ddac60297eccc2661165a3e3a094 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 30 May 2021 14:44:46 +0200 Subject: [PATCH 048/496] rename Rethrow -> Resume --- compiler/gen/src/llvm/build.rs | 4 ++-- compiler/gen_dev/src/lib.rs | 2 +- compiler/mono/src/alias_analysis.rs | 2 +- compiler/mono/src/borrow.rs | 4 ++-- compiler/mono/src/expand_rc.rs | 2 +- compiler/mono/src/inc_dec.rs | 6 +++--- compiler/mono/src/ir.rs | 14 ++++++++------ compiler/mono/src/tail_recursion.rs | 4 ++-- 8 files changed, 20 insertions(+), 18 deletions(-) diff --git a/compiler/gen/src/llvm/build.rs b/compiler/gen/src/llvm/build.rs index c7ad6064ec..066797e7dd 100644 --- a/compiler/gen/src/llvm/build.rs +++ b/compiler/gen/src/llvm/build.rs @@ -1989,7 +1989,7 @@ pub fn build_exp_stmt<'a, 'ctx, 'env>( call, layout, pass, - fail: roc_mono::ir::Stmt::Rethrow(_), + fail: roc_mono::ir::Stmt::Resume(_), exception_id: _, } => { // when the fail case is just Rethrow, there is no cleanup work to do @@ -2056,7 +2056,7 @@ pub fn build_exp_stmt<'a, 'ctx, 'env>( } }, - Rethrow(exception_id) => { + Resume(exception_id) => { let exception_object = scope.get(&exception_id.into_inner()).unwrap().1; env.builder.build_resume(&exception_object); diff --git a/compiler/gen_dev/src/lib.rs b/compiler/gen_dev/src/lib.rs index d396b070fc..37dd7fe316 100644 --- a/compiler/gen_dev/src/lib.rs +++ b/compiler/gen_dev/src/lib.rs @@ -510,7 +510,7 @@ where Stmt::Ret(sym) => { self.set_last_seen(*sym, stmt); } - Stmt::Rethrow(_exception_id) => {} + Stmt::Resume(_exception_id) => {} Stmt::Refcounting(modify, following) => { let sym = modify.get_symbol(); diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index fd869a7b36..1299a1516e 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -209,7 +209,7 @@ fn stmt_spec( let jpid = env.join_points[id]; builder.add_jump(block, jpid, argument, ret_type_id) } - Rethrow(_) | RuntimeError(_) => { + Resume(_) | RuntimeError(_) => { let type_id = layout_spec(builder, layout)?; builder.add_terminate(block, type_id) diff --git a/compiler/mono/src/borrow.rs b/compiler/mono/src/borrow.rs index 9d7540ee3c..a36579e310 100644 --- a/compiler/mono/src/borrow.rs +++ b/compiler/mono/src/borrow.rs @@ -220,7 +220,7 @@ impl<'a> ParamMap<'a> { } Refcounting(_, _) => unreachable!("these have not been introduced yet"), - Ret(_) | Rethrow(_) | Jump(_, _) | RuntimeError(_) => { + Ret(_) | Resume(_) | Jump(_, _) | RuntimeError(_) => { // these are terminal, do nothing } } @@ -673,7 +673,7 @@ impl<'a> BorrowInfState<'a> { } Refcounting(_, _) => unreachable!("these have not been introduced yet"), - Ret(_) | RuntimeError(_) | Rethrow(_) => { + Ret(_) | RuntimeError(_) | Resume(_) => { // these are terminal, do nothing } } diff --git a/compiler/mono/src/expand_rc.rs b/compiler/mono/src/expand_rc.rs index ec9f669c93..1686bfc123 100644 --- a/compiler/mono/src/expand_rc.rs +++ b/compiler/mono/src/expand_rc.rs @@ -638,7 +638,7 @@ fn expand_and_cancel<'a>(env: &mut Env<'a, '_>, stmt: &'a Stmt<'a>) -> &'a Stmt< env.arena.alloc(stmt) } - Rethrow(_) | Ret(_) | Jump(_, _) | RuntimeError(_) => stmt, + Resume(_) | Ret(_) | Jump(_, _) | RuntimeError(_) => stmt, } }; diff --git a/compiler/mono/src/inc_dec.rs b/compiler/mono/src/inc_dec.rs index 8c23be0913..e47dec4586 100644 --- a/compiler/mono/src/inc_dec.rs +++ b/compiler/mono/src/inc_dec.rs @@ -50,7 +50,7 @@ pub fn occuring_variables(stmt: &Stmt<'_>) -> (MutSet, MutSet) { result.insert(*symbol); } - Rethrow(_) => {} + Resume(_) => {} Refcounting(modify, cont) => { let symbol = modify.get_symbol(); @@ -1011,7 +1011,7 @@ impl<'a> Context<'a> { } } - Rethrow(_) => (stmt, MutSet::default()), + Resume(_) => (stmt, MutSet::default()), Jump(j, xs) => { let empty = MutSet::default(); @@ -1177,7 +1177,7 @@ pub fn collect_stmt( vars } - Rethrow(_) => vars, + Resume(_) => vars, RuntimeError(_) => vars, } diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index f679ba4dee..3508234369 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -857,6 +857,9 @@ pub enum Stmt<'a> { fail: &'a Stmt<'a>, exception_id: ExceptionId, }, + /// after cleanup, rethrow the exception object (stored in the exception id) + /// so it bubbles up + Resume(ExceptionId), Switch { /// This *must* stand for an integer, because Switch potentially compiles to a jump table. cond_symbol: Symbol, @@ -870,7 +873,6 @@ pub enum Stmt<'a> { ret_layout: Layout<'a>, }, Ret(Symbol), - Rethrow(ExceptionId), Refcounting(ModifyRc, &'a Stmt<'a>), /// a join point `join f = in remainder` Join { @@ -1362,7 +1364,7 @@ impl<'a> Stmt<'a> { symbol, call, pass, - fail: Stmt::Rethrow(_), + fail: Stmt::Resume(_), .. } => alloc .text("let ") @@ -1395,7 +1397,7 @@ impl<'a> Stmt<'a> { .append(symbol_to_doc(alloc, *symbol)) .append(";"), - Rethrow(_) => alloc.text("unreachable;"), + Resume(_) => alloc.text("unreachable;"), Switch { cond_symbol, @@ -4691,7 +4693,7 @@ pub fn from_can<'a>( call, layout: bool_layout, pass: env.arena.alloc(rest), - fail: env.arena.alloc(Stmt::Rethrow(exception_id)), + fail: env.arena.alloc(Stmt::Resume(exception_id)), exception_id, }; @@ -5411,7 +5413,7 @@ fn substitute_in_stmt_help<'a>( } } - Rethrow(_) => None, + Resume(_) => None, RuntimeError(_) => None, } @@ -6186,7 +6188,7 @@ fn build_call<'a>( ) -> Stmt<'a> { if can_throw_exception(&call) { let id = ExceptionId(env.unique_symbol()); - let fail = env.arena.alloc(Stmt::Rethrow(id)); + let fail = env.arena.alloc(Stmt::Resume(id)); Stmt::Invoke { symbol: assigned, call, diff --git a/compiler/mono/src/tail_recursion.rs b/compiler/mono/src/tail_recursion.rs index 38f8c57f5f..618acf81f3 100644 --- a/compiler/mono/src/tail_recursion.rs +++ b/compiler/mono/src/tail_recursion.rs @@ -105,7 +105,7 @@ fn insert_jumps<'a>( exception_id, .. } if needle == *fsym && symbol == rsym => { - debug_assert_eq!(fail, &&Stmt::Rethrow(*exception_id)); + debug_assert_eq!(fail, &&Stmt::Resume(*exception_id)); // replace the call and return with a jump @@ -241,7 +241,7 @@ fn insert_jumps<'a>( None => None, }, - Rethrow(_) => None, + Resume(_) => None, Ret(_) => None, Jump(_, _) => None, RuntimeError(_) => None, From 6d68f879e0269d826c2ddde1f1c48dfec82a18bf Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 30 May 2021 14:50:06 +0200 Subject: [PATCH 049/496] cleanup landingpad for foreign calls --- compiler/gen/src/llvm/build.rs | 28 +++++++++++++++++++--------- 1 file changed, 19 insertions(+), 9 deletions(-) diff --git a/compiler/gen/src/llvm/build.rs b/compiler/gen/src/llvm/build.rs index 066797e7dd..8bdcbc9f5a 100644 --- a/compiler/gen/src/llvm/build.rs +++ b/compiler/gen/src/llvm/build.rs @@ -2044,6 +2044,7 @@ pub fn build_exp_stmt<'a, 'ctx, 'env>( symbol: *symbol, pass, fail, + exception_id: *exception_id, }, ), @@ -4694,6 +4695,7 @@ enum ForeignCallOrInvoke<'a> { Call, Invoke { symbol: Symbol, + exception_id: ExceptionId, pass: &'a roc_mono::ir::Stmt<'a>, fail: &'a roc_mono::ir::Stmt<'a>, }, @@ -4788,7 +4790,12 @@ fn build_foreign_symbol<'a, 'ctx, 'env>( call.try_as_basic_value().left().unwrap() } } - ForeignCallOrInvoke::Invoke { symbol, pass, fail } => { + ForeignCallOrInvoke::Invoke { + symbol, + pass, + fail, + exception_id, + } => { let pass_block = env.context.append_basic_block(parent, "invoke_pass"); let fail_block = env.context.append_basic_block(parent, "invoke_fail"); @@ -4829,14 +4836,17 @@ fn build_foreign_symbol<'a, 'ctx, 'env>( .struct_type(&[exception_ptr, selector_value], false) }; - env.builder - .build_catch_all_landing_pad( - &landing_pad_type, - &BasicValueEnum::IntValue(env.context.i8_type().const_zero()), - env.context.i8_type().ptr_type(AddressSpace::Generic), - "invoke_landing_pad", - ) - .into_struct_value(); + let exception_object = env.builder.build_cleanup_landing_pad( + &landing_pad_type, + &BasicValueEnum::IntValue(env.context.i8_type().const_zero()), + env.context.i8_type().ptr_type(AddressSpace::Generic), + "invoke_landing_pad", + ); + + scope.insert( + exception_id.into_inner(), + (Layout::Struct(&[]), exception_object), + ); build_exp_stmt(env, layout_ids, scope, parent, fail); } From 22a4df0e5ea9ace9427e830114de99002322fd59 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 30 May 2021 16:48:42 +0200 Subject: [PATCH 050/496] add test_mono_macros crate --- Cargo.lock | 27 ++++++++++++++++ Cargo.toml | 1 + compiler/test_mono_macros/Cargo.toml | 36 ++++++++++++++++++++++ compiler/test_mono_macros/src/lib.rs | 46 ++++++++++++++++++++++++++++ 4 files changed, 110 insertions(+) create mode 100644 compiler/test_mono_macros/Cargo.toml create mode 100644 compiler/test_mono_macros/src/lib.rs diff --git a/Cargo.lock b/Cargo.lock index 0323839957..d3570eaf93 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3910,6 +3910,33 @@ dependencies = [ "tokio", ] +[[package]] +name = "test_mono_macros" +version = "0.1.0" +dependencies = [ + "darling", + "indoc 0.3.6", + "maplit", + "pretty_assertions 0.5.1", + "proc-macro2 1.0.27", + "quickcheck 0.8.5", + "quickcheck_macros 0.8.0", + "quote 1.0.9", + "roc_builtins", + "roc_can", + "roc_collections", + "roc_load", + "roc_module", + "roc_mono", + "roc_parse", + "roc_problem", + "roc_region", + "roc_solve", + "roc_types", + "roc_unify", + "syn 1.0.72", +] + [[package]] name = "textwrap" version = "0.11.0" diff --git a/Cargo.toml b/Cargo.toml index 9edcc5aeb9..59e32522ff 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -14,6 +14,7 @@ members = [ "compiler/reporting", "compiler/fmt", "compiler/mono", + "compiler/test_mono_macros", "compiler/load", "compiler/gen", "compiler/gen_dev", diff --git a/compiler/test_mono_macros/Cargo.toml b/compiler/test_mono_macros/Cargo.toml new file mode 100644 index 0000000000..d5243127b6 --- /dev/null +++ b/compiler/test_mono_macros/Cargo.toml @@ -0,0 +1,36 @@ +[package] +name = "test_mono_macros" +version = "0.1.0" +authors = ["The Roc Contributors"] +license = "UPL-1.0" +edition = "2018" + +[lib] +proc-macro = true + +[dependencies] +roc_collections = { path = "../collections" } +roc_region = { path = "../region" } +roc_module = { path = "../module" } +roc_types = { path = "../types" } +roc_can = { path = "../can" } +roc_unify = { path = "../unify" } +roc_solve = { path = "../solve" } +roc_problem = { path = "../problem" } +roc_mono = { path = "../mono" } + +syn = { version = "1.0.39", features = ["full", "extra-traits"] } +quote = "1.0.7" +darling = "0.10.2" +proc-macro2 = "1.0.24" + +[dev-dependencies] +roc_load= { path = "../load" } +roc_builtins = { path = "../builtins" } +roc_parse = { path = "../parse" } +roc_solve = { path = "../solve" } +pretty_assertions = "0.5.1" +maplit = "1.0.1" +indoc = "0.3.3" +quickcheck = "0.8" +quickcheck_macros = "0.8" diff --git a/compiler/test_mono_macros/src/lib.rs b/compiler/test_mono_macros/src/lib.rs new file mode 100644 index 0000000000..978c922117 --- /dev/null +++ b/compiler/test_mono_macros/src/lib.rs @@ -0,0 +1,46 @@ +#![warn(clippy::dbg_macro)] +// See github.com/rtfeldman/roc/issues/800 for discussion of the large_enum_variant check. +#![allow(clippy::large_enum_variant)] +// we actually want to compare against the literal float bits +#![allow(clippy::clippy::float_cmp)] + +extern crate proc_macro; + +use proc_macro::{Span, TokenStream}; +use quote::{format_ident, quote}; +use syn::spanned::Spanned; + +// pub mod gen_compare; +// pub mod gen_dict; +// pub mod gen_hash; +// pub mod gen_list; +// pub mod gen_num; +// pub mod gen_primitives; +// pub mod gen_records; +// pub mod gen_result; +// pub mod gen_set; +// pub mod gen_str; +// pub mod gen_tags; +// mod helpers; + +#[proc_macro_attribute] +pub fn mono_test(args: TokenStream, item: TokenStream) -> TokenStream { + let macro_args = syn::parse_macro_input!(args as syn::AttributeArgs); + let task_fn = syn::parse_macro_input!(item as syn::ItemFn); + + let mut arg_names: syn::punctuated::Punctuated = + syn::punctuated::Punctuated::new(); + let mut args = task_fn.sig.inputs.clone(); + + let name = task_fn.sig.ident.clone(); + let body = task_fn.block.clone(); + + let visibility = &task_fn.vis; + + let result = quote! { + #visibility fn #name(#args) { + println!( #body); + } + }; + result.into() +} From 54057c90b8d87fdc80cab59af5846a928ff0d31b Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 30 May 2021 18:09:41 +0200 Subject: [PATCH 051/496] new mono testing mechanism --- Cargo.lock | 27 ++- Cargo.toml | 1 + compiler/test_mono/Cargo.toml | 40 ++++ compiler/test_mono/generated/ir_int_add.txt | 25 +++ .../test_mono/generated/ir_int_literal.txt | 3 + compiler/test_mono/src/lib.rs | 184 ++++++++++++++++++ compiler/test_mono_macros/Cargo.toml | 21 -- compiler/test_mono_macros/src/lib.rs | 38 +--- 8 files changed, 284 insertions(+), 55 deletions(-) create mode 100644 compiler/test_mono/Cargo.toml create mode 100644 compiler/test_mono/generated/ir_int_add.txt create mode 100644 compiler/test_mono/generated/ir_int_literal.txt create mode 100644 compiler/test_mono/src/lib.rs diff --git a/Cargo.lock b/Cargo.lock index d3570eaf93..b933971a45 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3911,29 +3911,46 @@ dependencies = [ ] [[package]] -name = "test_mono_macros" +name = "test_mono" version = "0.1.0" dependencies = [ - "darling", + "bumpalo", + "either", + "im 14.3.0", + "im-rc 14.3.0", "indoc 0.3.6", - "maplit", + "inlinable_string", + "libc", + "libloading 0.6.7", "pretty_assertions 0.5.1", - "proc-macro2 1.0.27", "quickcheck 0.8.5", "quickcheck_macros 0.8.0", - "quote 1.0.9", + "roc_build", "roc_builtins", "roc_can", "roc_collections", + "roc_constrain", "roc_load", "roc_module", "roc_mono", "roc_parse", "roc_problem", "roc_region", + "roc_reporting", "roc_solve", "roc_types", "roc_unify", + "target-lexicon", + "test_mono_macros", +] + +[[package]] +name = "test_mono_macros" +version = "0.1.0" +dependencies = [ + "darling", + "proc-macro2 1.0.27", + "quote 1.0.9", "syn 1.0.72", ] diff --git a/Cargo.toml b/Cargo.toml index 59e32522ff..258be502a5 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -15,6 +15,7 @@ members = [ "compiler/fmt", "compiler/mono", "compiler/test_mono_macros", + "compiler/test_mono", "compiler/load", "compiler/gen", "compiler/gen_dev", diff --git a/compiler/test_mono/Cargo.toml b/compiler/test_mono/Cargo.toml new file mode 100644 index 0000000000..60f3c78a33 --- /dev/null +++ b/compiler/test_mono/Cargo.toml @@ -0,0 +1,40 @@ +[package] +name = "test_mono" +version = "0.1.0" +authors = ["The Roc Contributors"] +license = "UPL-1.0" +edition = "2018" + +[dependencies] +roc_collections = { path = "../collections" } +roc_region = { path = "../region" } +roc_module = { path = "../module" } +roc_problem = { path = "../problem" } +roc_types = { path = "../types" } +roc_builtins = { path = "../builtins" } +roc_constrain = { path = "../constrain" } +roc_unify = { path = "../unify" } +roc_solve = { path = "../solve" } +roc_reporting = { path = "../reporting" } +roc_load = { path = "../load" } +roc_can = { path = "../can" } +roc_parse = { path = "../parse" } +roc_build = { path = "../build" } +roc_mono = { path = "../mono" } +test_mono_macros = { path = "../test_mono_macros" } +im = "14" # im and im-rc should always have the same version! +im-rc = "14" # im and im-rc should always have the same version! +bumpalo = { version = "3.6.1", features = ["collections"] } +inlinable_string = "0.1" +either = "1.6.1" +indoc = "0.3.3" +libc = "0.2" +target-lexicon = "0.10" +libloading = "0.6" + +[dev-dependencies] +pretty_assertions = "0.5.1" +indoc = "0.3.3" +quickcheck = "0.8" +quickcheck_macros = "0.8" +bumpalo = { version = "3.6.1", features = ["collections"] } diff --git a/compiler/test_mono/generated/ir_int_add.txt b/compiler/test_mono/generated/ir_int_add.txt new file mode 100644 index 0000000000..4b427ffaee --- /dev/null +++ b/compiler/test_mono/generated/ir_int_add.txt @@ -0,0 +1,25 @@ +procedure List.7 (#Attr.2): + let Test.6 = lowlevel ListLen #Attr.2; + ret Test.6; + +procedure Num.24 (#Attr.2, #Attr.3): + let Test.5 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Test.5; + +procedure Test.0 (): + let Test.11 = 1i64; + let Test.12 = 2i64; + let Test.1 = Array [Test.11, Test.12]; + let Test.9 = 5i64; + let Test.10 = 4i64; + invoke Test.7 = CallByName Num.24 Test.9 Test.10 catch + dec Test.1; + unreachable; + let Test.8 = 3i64; + invoke Test.3 = CallByName Num.24 Test.7 Test.8 catch + dec Test.1; + unreachable; + let Test.4 = CallByName List.7 Test.1; + dec Test.1; + let Test.2 = CallByName Num.24 Test.3 Test.4; + ret Test.2; diff --git a/compiler/test_mono/generated/ir_int_literal.txt b/compiler/test_mono/generated/ir_int_literal.txt new file mode 100644 index 0000000000..755d390183 --- /dev/null +++ b/compiler/test_mono/generated/ir_int_literal.txt @@ -0,0 +1,3 @@ +procedure Test.0 (): + let Test.1 = 5i64; + ret Test.1; diff --git a/compiler/test_mono/src/lib.rs b/compiler/test_mono/src/lib.rs new file mode 100644 index 0000000000..757d473f06 --- /dev/null +++ b/compiler/test_mono/src/lib.rs @@ -0,0 +1,184 @@ +#![cfg(test)] +#![warn(clippy::dbg_macro)] +// See github.com/rtfeldman/roc/issues/800 for discussion of the large_enum_variant check. +#![allow(clippy::large_enum_variant)] +// we actually want to compare against the literal float bits +#![allow(clippy::clippy::float_cmp)] + +#[macro_use] +extern crate pretty_assertions; + +use test_mono_macros::*; + +use roc_can::builtins::builtin_defs_map; +use roc_collections::all::MutMap; +use roc_module::symbol::Symbol; +use roc_mono::ir::Proc; + +use roc_mono::ir::TopLevelFunctionLayout; + +fn promote_expr_to_module(src: &str) -> String { + let mut buffer = String::from("app \"test\" provides [ main ] to \"./platform\"\n\nmain =\n"); + + for line in src.lines() { + // indent the body! + buffer.push_str(" "); + buffer.push_str(line); + buffer.push('\n'); + } + + buffer +} + +fn compiles_to_ir(test_name: &str, src: &str) { + use bumpalo::Bump; + use std::path::{Path, PathBuf}; + + let arena = &Bump::new(); + + // let stdlib = roc_builtins::unique::uniq_stdlib(); + let stdlib = roc_builtins::std::standard_stdlib(); + let filename = PathBuf::from("Test.roc"); + let src_dir = Path::new("fake/test/path"); + + let module_src; + let temp; + if src.starts_with("app") { + // this is already a module + module_src = src; + } else { + // this is an expression, promote it to a module + temp = promote_expr_to_module(src); + module_src = &temp; + } + + let exposed_types = MutMap::default(); + + let loaded = roc_load::file::load_and_monomorphize_from_str( + arena, + filename, + &module_src, + &stdlib, + src_dir, + exposed_types, + 8, + builtin_defs_map, + ); + + let mut loaded = match loaded { + Ok(x) => x, + Err(roc_load::file::LoadingProblem::FormattedReport(report)) => { + println!("{}", report); + panic!(); + } + Err(e) => panic!("{:?}", e), + }; + + use roc_load::file::MonomorphizedModule; + let MonomorphizedModule { + module_id: home, + procedures, + exposed_to_host, + .. + } = loaded; + + let can_problems = loaded.can_problems.remove(&home).unwrap_or_default(); + let type_problems = loaded.type_problems.remove(&home).unwrap_or_default(); + let mono_problems = loaded.mono_problems.remove(&home).unwrap_or_default(); + + if !can_problems.is_empty() { + println!("Ignoring {} canonicalization problems", can_problems.len()); + } + + assert_eq!(type_problems, Vec::new()); + assert_eq!(mono_problems, Vec::new()); + + debug_assert_eq!(exposed_to_host.len(), 1); + + let main_fn_symbol = exposed_to_host.keys().copied().next().unwrap(); + + verify_procedures(test_name, procedures, main_fn_symbol); +} + +#[cfg(debug_assertions)] +fn verify_procedures( + test_name: &str, + procedures: MutMap<(Symbol, TopLevelFunctionLayout<'_>), Proc<'_>>, + main_fn_symbol: Symbol, +) { + let index = procedures + .keys() + .position(|(s, _)| *s == main_fn_symbol) + .unwrap(); + + let mut procs_string = procedures + .values() + .map(|proc| proc.to_pretty(200)) + .collect::>(); + + let main_fn = procs_string.swap_remove(index); + + procs_string.sort(); + procs_string.push(main_fn); + + let result = procs_string.join("\n"); + + let path = format!("generated/{}.txt", test_name); + std::fs::create_dir_all("generated").unwrap(); + std::fs::write(&path, result).unwrap(); + + use std::process::Command; + let is_tracked = Command::new("git") + .args(&["ls-files", "--error-unmatch", &path]) + .output() + .unwrap(); + + if !is_tracked.status.success() { + panic!( + "The file {:?} is not tracked by git. Try using `git add` on it", + &path + ); + } + + let has_changes = Command::new("git") + .args(&["diff", "--color=always", &path]) + .output() + .unwrap(); + + if !has_changes.status.success() { + eprintln!("`git diff {:?}` failed", &path); + unreachable!(); + } + + if !has_changes.stdout.is_empty() { + println!("{}", std::str::from_utf8(&has_changes.stdout).unwrap()); + panic!("Output changed: resolve conflicts and `git add` the file."); + } +} + +// NOTE because the Show instance of module names is different in --release mode, +// these tests would all fail. In the future, when we do interesting optimizations, +// we'll likely want some tests for --release too. +#[cfg(not(debug_assertions))] +fn verify_procedures( + _expected: &str, + _procedures: MutMap<(Symbol, TopLevelFunctionLayout<'_>), Proc<'_>>, + _main_fn_symbol: Symbol, +) { + // Do nothing +} + +#[mono_test] +fn ir_int_literal() { + r#" + 5 + "# +} + +#[mono_test] +fn ir_int_add() { + r#" + x = [ 1,2 ] + 5 + 4 + 3 + List.len x + "# +} diff --git a/compiler/test_mono_macros/Cargo.toml b/compiler/test_mono_macros/Cargo.toml index d5243127b6..24ddaa408b 100644 --- a/compiler/test_mono_macros/Cargo.toml +++ b/compiler/test_mono_macros/Cargo.toml @@ -9,28 +9,7 @@ edition = "2018" proc-macro = true [dependencies] -roc_collections = { path = "../collections" } -roc_region = { path = "../region" } -roc_module = { path = "../module" } -roc_types = { path = "../types" } -roc_can = { path = "../can" } -roc_unify = { path = "../unify" } -roc_solve = { path = "../solve" } -roc_problem = { path = "../problem" } -roc_mono = { path = "../mono" } - syn = { version = "1.0.39", features = ["full", "extra-traits"] } quote = "1.0.7" darling = "0.10.2" proc-macro2 = "1.0.24" - -[dev-dependencies] -roc_load= { path = "../load" } -roc_builtins = { path = "../builtins" } -roc_parse = { path = "../parse" } -roc_solve = { path = "../solve" } -pretty_assertions = "0.5.1" -maplit = "1.0.1" -indoc = "0.3.3" -quickcheck = "0.8" -quickcheck_macros = "0.8" diff --git a/compiler/test_mono_macros/src/lib.rs b/compiler/test_mono_macros/src/lib.rs index 978c922117..e6646e4e36 100644 --- a/compiler/test_mono_macros/src/lib.rs +++ b/compiler/test_mono_macros/src/lib.rs @@ -1,45 +1,25 @@ -#![warn(clippy::dbg_macro)] -// See github.com/rtfeldman/roc/issues/800 for discussion of the large_enum_variant check. -#![allow(clippy::large_enum_variant)] -// we actually want to compare against the literal float bits -#![allow(clippy::clippy::float_cmp)] - extern crate proc_macro; -use proc_macro::{Span, TokenStream}; -use quote::{format_ident, quote}; -use syn::spanned::Spanned; - -// pub mod gen_compare; -// pub mod gen_dict; -// pub mod gen_hash; -// pub mod gen_list; -// pub mod gen_num; -// pub mod gen_primitives; -// pub mod gen_records; -// pub mod gen_result; -// pub mod gen_set; -// pub mod gen_str; -// pub mod gen_tags; -// mod helpers; +use proc_macro::TokenStream; +use quote::quote; #[proc_macro_attribute] -pub fn mono_test(args: TokenStream, item: TokenStream) -> TokenStream { - let macro_args = syn::parse_macro_input!(args as syn::AttributeArgs); +pub fn mono_test(_args: TokenStream, item: TokenStream) -> TokenStream { let task_fn = syn::parse_macro_input!(item as syn::ItemFn); - let mut arg_names: syn::punctuated::Punctuated = - syn::punctuated::Punctuated::new(); - let mut args = task_fn.sig.inputs.clone(); + let args = task_fn.sig.inputs.clone(); let name = task_fn.sig.ident.clone(); + let name_str = name.to_string(); let body = task_fn.block.clone(); let visibility = &task_fn.vis; let result = quote! { - #visibility fn #name(#args) { - println!( #body); + #[test] + #visibility fn #name(#args) -> () { + compiles_to_ir(#name_str, #body); + } }; result.into() From b3e83b917c7b6deea73e25d20104d220728d3457 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 30 May 2021 23:03:05 +0200 Subject: [PATCH 052/496] flip set key/value --- compiler/mono/src/alias_analysis.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 645f57d8c0..63b27db8ca 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -579,9 +579,9 @@ fn builtin_spec(builder: &mut FuncDefBuilder, builtin: &Builtin) -> Result { - let value_type = layout_spec(builder, value_layout)?; - let key_type = builder.add_tuple_type(&[])?; + Set(key_layout) => { + let value_type = builder.add_tuple_type(&[])?; + let key_type = layout_spec(builder, key_layout)?; let element_type = builder.add_tuple_type(&[key_type, value_type])?; let cell = builder.add_heap_cell_type(); From 4c1a5b3f6274a18b039fd36564d5e8652e170f8b Mon Sep 17 00:00:00 2001 From: Chadtech Date: Sun, 30 May 2021 19:48:16 -0400 Subject: [PATCH 053/496] Functions appear in docs --- compiler/load/src/docs.rs | 141 ++++++++++++++++++++++++-------------- docs/src/lib.rs | 132 ++++++++++++++++++++++++++++------- 2 files changed, 197 insertions(+), 76 deletions(-) diff --git a/compiler/load/src/docs.rs b/compiler/load/src/docs.rs index c971188257..32d742dedc 100644 --- a/compiler/load/src/docs.rs +++ b/compiler/load/src/docs.rs @@ -1,5 +1,7 @@ use crate::docs::DocEntry::DetatchedDoc; -use crate::docs::TypeAnnotation::{Apply, BoundVariable, Record, TagUnion}; +use crate::docs::TypeAnnotation::{ + Apply, BoundVariable, Function, NoTypeAnn, ObscuredRecord, ObscuredTagUnion, Record, TagUnion, +}; use inlinable_string::InlinableString; use roc_can::scope::Scope; use roc_collections::all::MutMap; @@ -37,7 +39,7 @@ pub enum DocEntry { pub struct DocDef { pub name: String, pub type_vars: Vec, - pub type_annotation: Option, + pub type_annotation: TypeAnnotation, pub docs: Option, } @@ -45,8 +47,14 @@ pub struct DocDef { pub enum TypeAnnotation { TagUnion { tags: Vec, - extension: Option>, + extension: Box, }, + Function { + args: Vec, + output: Box, + }, + ObscuredTagUnion, + ObscuredRecord, BoundVariable(String), Apply { name: String, @@ -54,7 +62,10 @@ pub enum TypeAnnotation { }, Record { fields: Vec, + extension: Box, }, + Wildcard, + NoTypeAnn, } #[derive(Debug, Clone)] pub enum RecordField { @@ -161,7 +172,7 @@ fn generate_entry_doc<'a>( { let doc_def = DocDef { name: identifier.to_string(), - type_annotation: None, + type_annotation: NoTypeAnn, type_vars: Vec::new(), docs: before_comments_or_new_lines.and_then(comments_or_new_lines_to_docs), }; @@ -172,7 +183,11 @@ fn generate_entry_doc<'a>( _ => (acc, None), }, - Def::AnnotatedBody { ann_pattern, .. } => match ann_pattern.value { + Def::AnnotatedBody { + ann_pattern, + ann_type, + .. + } => match ann_pattern.value { Pattern::Identifier(identifier) => { // Check if the definition is exposed if ident_ids @@ -181,7 +196,7 @@ fn generate_entry_doc<'a>( { let doc_def = DocDef { name: identifier.to_string(), - type_annotation: None, + type_annotation: type_to_docs(false, ann_type.value), type_vars: Vec::new(), docs: before_comments_or_new_lines.and_then(comments_or_new_lines_to_docs), }; @@ -204,7 +219,7 @@ fn generate_entry_doc<'a>( let doc_def = DocDef { name: name.value.to_string(), - type_annotation: type_to_docs(ann.value), + type_annotation: type_to_docs(false, ann.value), type_vars, docs: before_comments_or_new_lines.and_then(comments_or_new_lines_to_docs), }; @@ -221,7 +236,7 @@ fn generate_entry_doc<'a>( } } -fn type_to_docs(type_annotation: ast::TypeAnnotation) -> Option { +fn type_to_docs(in_func_type_ann: bool, type_annotation: ast::TypeAnnotation) -> TypeAnnotation { match type_annotation { ast::TypeAnnotation::TagUnion { tags, @@ -233,7 +248,7 @@ fn type_to_docs(type_annotation: ast::TypeAnnotation) -> Option let mut any_tags_are_private = false; for tag in tags { - match tag_to_doc(tag.value) { + match tag_to_doc(in_func_type_ann, tag.value) { None => { any_tags_are_private = true; break; @@ -245,20 +260,24 @@ fn type_to_docs(type_annotation: ast::TypeAnnotation) -> Option } if any_tags_are_private { - None + if in_func_type_ann { + ObscuredTagUnion + } else { + NoTypeAnn + } } else { let extension = match ext { - None => None, - Some(ext_type_ann) => type_to_docs(ext_type_ann.value).map(Box::new), + None => NoTypeAnn, + Some(ext_type_ann) => type_to_docs(in_func_type_ann, ext_type_ann.value), }; - Some(TagUnion { + TagUnion { tags: tags_to_render, - extension, - }) + extension: Box::new(extension), + } } } - ast::TypeAnnotation::BoundVariable(var_name) => Some(BoundVariable(var_name.to_string())), + ast::TypeAnnotation::BoundVariable(var_name) => BoundVariable(var_name.to_string()), ast::TypeAnnotation::Apply(module_name, type_name, type_ann_parts) => { let mut name = String::new(); @@ -272,16 +291,14 @@ fn type_to_docs(type_annotation: ast::TypeAnnotation) -> Option let mut parts: Vec = Vec::new(); for type_ann_part in type_ann_parts { - if let Some(part) = type_to_docs(type_ann_part.value) { - parts.push(part); - } + parts.push(type_to_docs(in_func_type_ann, type_ann_part.value)); } - Some(Apply { name, parts }) + Apply { name, parts } } ast::TypeAnnotation::Record { fields, - ext: _, + ext, final_comments: _, } => { let mut doc_fields = Vec::new(); @@ -289,7 +306,7 @@ fn type_to_docs(type_annotation: ast::TypeAnnotation) -> Option let mut any_fields_include_private_tags = false; for field in fields { - match record_field_to_doc(field.value) { + match record_field_to_doc(in_func_type_ann, field.value) { None => { any_fields_include_private_tags = true; break; @@ -300,37 +317,61 @@ fn type_to_docs(type_annotation: ast::TypeAnnotation) -> Option } } if any_fields_include_private_tags { - None + if in_func_type_ann { + ObscuredRecord + } else { + NoTypeAnn + } } else { - Some(Record { fields: doc_fields }) + let extension = match ext { + None => NoTypeAnn, + Some(ext_type_ann) => type_to_docs(in_func_type_ann, ext_type_ann.value), + }; + + Record { + fields: doc_fields, + extension: Box::new(extension), + } } } - ast::TypeAnnotation::SpaceBefore(&sub_type_ann, _) => type_to_docs(sub_type_ann), - ast::TypeAnnotation::SpaceAfter(&sub_type_ann, _) => type_to_docs(sub_type_ann), - _ => { - // TODO "Implement type to docs") - - None + ast::TypeAnnotation::SpaceBefore(&sub_type_ann, _) => { + type_to_docs(in_func_type_ann, sub_type_ann) } + ast::TypeAnnotation::SpaceAfter(&sub_type_ann, _) => { + type_to_docs(in_func_type_ann, sub_type_ann) + } + ast::TypeAnnotation::Function(ast_arg_anns, output_ann) => { + let mut doc_arg_anns = Vec::new(); + + for ast_arg_ann in ast_arg_anns { + doc_arg_anns.push(type_to_docs(true, ast_arg_ann.value)); + } + + Function { + args: doc_arg_anns, + output: Box::new(type_to_docs(true, output_ann.value)), + } + } + ast::TypeAnnotation::Wildcard => TypeAnnotation::Wildcard, + _ => NoTypeAnn, } } -fn record_field_to_doc(field: ast::AssignedField<'_, ast::TypeAnnotation>) -> Option { +fn record_field_to_doc( + in_func_ann: bool, + field: ast::AssignedField<'_, ast::TypeAnnotation>, +) -> Option { match field { - AssignedField::RequiredValue(name, _, type_ann) => { - type_to_docs(type_ann.value).map(|type_ann_docs| RecordField::RecordField { - name: name.value.to_string(), - type_annotation: type_ann_docs, - }) - } - AssignedField::SpaceBefore(&sub_field, _) => record_field_to_doc(sub_field), - AssignedField::SpaceAfter(&sub_field, _) => record_field_to_doc(sub_field), - AssignedField::OptionalValue(name, _, type_ann) => { - type_to_docs(type_ann.value).map(|type_ann_docs| RecordField::OptionalField { - name: name.value.to_string(), - type_annotation: type_ann_docs, - }) - } + AssignedField::RequiredValue(name, _, type_ann) => Some(RecordField::RecordField { + name: name.value.to_string(), + type_annotation: type_to_docs(in_func_ann, type_ann.value), + }), + AssignedField::SpaceBefore(&sub_field, _) => record_field_to_doc(in_func_ann, sub_field), + AssignedField::SpaceAfter(&sub_field, _) => record_field_to_doc(in_func_ann, sub_field), + AssignedField::OptionalValue(name, _, type_ann) => Some(RecordField::OptionalField { + name: name.value.to_string(), + type_annotation: type_to_docs(in_func_ann, type_ann.value), + }), AssignedField::LabelOnly(label) => Some(RecordField::LabelOnly { name: label.value.to_string(), }), @@ -340,7 +381,7 @@ fn record_field_to_doc(field: ast::AssignedField<'_, ast::TypeAnnotation>) -> Op // The Option here represents if it is private. Private tags // evaluate to `None`. -fn tag_to_doc(tag: ast::Tag) -> Option { +fn tag_to_doc(in_func_ann: bool, tag: ast::Tag) -> Option { match tag { ast::Tag::Global { name, args } => Some(Tag { name: name.value.to_string(), @@ -348,17 +389,15 @@ fn tag_to_doc(tag: ast::Tag) -> Option { let mut type_vars = Vec::new(); for arg in args { - if let Some(type_var) = type_to_docs(arg.value) { - type_vars.push(type_var); - } + type_vars.push(type_to_docs(in_func_ann, arg.value)); } type_vars }, }), ast::Tag::Private { .. } => None, - ast::Tag::SpaceBefore(&sub_tag, _) => tag_to_doc(sub_tag), - ast::Tag::SpaceAfter(&sub_tag, _) => tag_to_doc(sub_tag), + ast::Tag::SpaceBefore(&sub_tag, _) => tag_to_doc(in_func_ann, sub_tag), + ast::Tag::SpaceAfter(&sub_tag, _) => tag_to_doc(in_func_ann, sub_tag), ast::Tag::Malformed(_) => None, } } diff --git a/docs/src/lib.rs b/docs/src/lib.rs index ca3b3280d9..718ae50ba1 100644 --- a/docs/src/lib.rs +++ b/docs/src/lib.rs @@ -116,11 +116,17 @@ fn render_main_content(interns: &Interns, module: &mut ModuleDocumentation) -> S content.push_str(type_var.as_str()); } - if let Some(type_ann) = &doc_def.type_annotation { - content.push_str(" : "); - type_annotation_to_html(0, &mut content, &type_ann); + let type_ann = &doc_def.type_annotation; + + match type_ann { + TypeAnnotation::NoTypeAnn => {} + _ => { + content.push_str(" : "); + } } + type_annotation_to_html(0, &mut content, &type_ann); + buf.push_str( html_node( "h3", @@ -329,17 +335,33 @@ fn new_line(buf: &mut String) { fn type_annotation_to_html(indent_level: usize, buf: &mut String, type_ann: &TypeAnnotation) { match type_ann { TypeAnnotation::TagUnion { tags, extension } => { - new_line(buf); + let tags_len = tags.len(); + + let more_than_one_tag = tags_len > 1; let tag_union_indent = indent_level + 1; - indent(buf, tag_union_indent); + + if more_than_one_tag { + new_line(buf); + + indent(buf, tag_union_indent); + } + buf.push('['); - new_line(buf); + + if more_than_one_tag { + new_line(buf); + } let next_indent_level = tag_union_indent + 1; for (index, tag) in tags.iter().enumerate() { - indent(buf, next_indent_level); + if more_than_one_tag { + indent(buf, next_indent_level); + } else { + buf.push(' '); + } + buf.push_str(tag.name.as_str()); for type_value in &tag.values { @@ -347,19 +369,24 @@ fn type_annotation_to_html(indent_level: usize, buf: &mut String, type_ann: &Typ type_annotation_to_html(next_indent_level, buf, type_value); } - if index < (tags.len() - 1) { - buf.push(','); - } + if more_than_one_tag { + if index < (tags_len - 1) { + buf.push(','); + } - new_line(buf); + new_line(buf); + } + } + + if more_than_one_tag { + indent(buf, tag_union_indent); + } else { + buf.push(' '); } - indent(buf, tag_union_indent); buf.push(']'); - if let Some(ext) = extension { - type_annotation_to_html(indent_level, buf, ext); - } + type_annotation_to_html(indent_level, buf, extension); } TypeAnnotation::BoundVariable(var_name) => { buf.push_str(var_name); @@ -377,18 +404,32 @@ fn type_annotation_to_html(indent_level: usize, buf: &mut String, type_ann: &Typ buf.push(')'); } } - TypeAnnotation::Record { fields } => { - new_line(buf); + TypeAnnotation::Record { fields, extension } => { + let fields_len = fields.len(); + + let more_than_one_field = fields_len > 1; let record_indent = indent_level + 1; - indent(buf, record_indent); + if more_than_one_field { + new_line(buf); + + indent(buf, record_indent); + } + buf.push('{'); - new_line(buf); + if more_than_one_field { + new_line(buf); + } let next_indent_level = record_indent + 1; + for (index, field) in fields.iter().enumerate() { - indent(buf, next_indent_level); + if more_than_one_field { + indent(buf, next_indent_level); + } else { + buf.push(' '); + } let fields_name = match field { RecordField::RecordField { name, .. } => name, @@ -414,16 +455,57 @@ fn type_annotation_to_html(indent_level: usize, buf: &mut String, type_ann: &Typ RecordField::LabelOnly { .. } => {} } - if index < (fields.len() - 1) { - buf.push(','); - } + if more_than_one_field { + if index < (fields_len - 1) { + buf.push(','); + } - new_line(buf); + new_line(buf); + } + } + + if more_than_one_field { + indent(buf, record_indent); + } else { + buf.push(' '); } - indent(buf, record_indent); buf.push('}'); + + type_annotation_to_html(indent_level, buf, extension); } + TypeAnnotation::Function { args, output } => { + let more_than_one_arg = args.len() > 1; + let mut peekable_args = args.iter().peekable(); + while let Some(arg) = peekable_args.next() { + if more_than_one_arg { + new_line(buf); + indent(buf, indent_level + 1); + } + + type_annotation_to_html(indent_level, buf, arg); + + if peekable_args.peek().is_some() { + buf.push_str(", "); + } + } + + if more_than_one_arg { + new_line(buf); + indent(buf, indent_level + 1); + } + + buf.push_str(" -> "); + type_annotation_to_html(indent_level, buf, output); + } + TypeAnnotation::ObscuredTagUnion => { + buf.push_str("[ @.. ]"); + } + TypeAnnotation::ObscuredRecord => { + buf.push_str("{ @.. }"); + } + TypeAnnotation::NoTypeAnn => {} + TypeAnnotation::Wildcard => buf.push('*'), } } From 216a945e2812d9835a71a827c194fd6accc1f5dd Mon Sep 17 00:00:00 2001 From: rvcas Date: Sun, 30 May 2021 23:42:02 -0400 Subject: [PATCH 054/496] feat(repl): add the rest of the Nums --- cli/src/repl/eval.rs | 74 +++++++++++++++++++++++++------------------- 1 file changed, 43 insertions(+), 31 deletions(-) diff --git a/cli/src/repl/eval.rs b/cli/src/repl/eval.rs index ab0561aa44..34ed34df94 100644 --- a/cli/src/repl/eval.rs +++ b/cli/src/repl/eval.rs @@ -79,19 +79,26 @@ fn jit_to_ast_help<'a>( ) } Layout::Builtin(Builtin::Usize) => Ok(run_jit_function!(lib, main_fn_name, usize, |num| { - num_to_ast(env, nat_to_ast(env.arena, num), content) + num_to_ast(env, number_literal_to_ast(env.arena, num), content) })), + Layout::Builtin(Builtin::Int16) => { + Ok(run_jit_function!(lib, main_fn_name, i16, |num| num_to_ast( + env, + number_literal_to_ast(env.arena, num), + content + ))) + } Layout::Builtin(Builtin::Int32) => { Ok(run_jit_function!(lib, main_fn_name, i32, |num| num_to_ast( env, - i32_to_ast(env.arena, num), + number_literal_to_ast(env.arena, num), content ))) } Layout::Builtin(Builtin::Int64) => { Ok(run_jit_function!(lib, main_fn_name, i64, |num| num_to_ast( env, - i64_to_ast(env.arena, num), + number_literal_to_ast(env.arena, num), content ))) } @@ -100,13 +107,20 @@ fn jit_to_ast_help<'a>( lib, main_fn_name, i128, - |num| num_to_ast(env, i128_to_ast(env.arena, num), content) + |num| num_to_ast(env, number_literal_to_ast(env.arena, num), content) )) } + Layout::Builtin(Builtin::Float32) => { + Ok(run_jit_function!(lib, main_fn_name, f32, |num| num_to_ast( + env, + number_literal_to_ast(env.arena, num), + content + ))) + } Layout::Builtin(Builtin::Float64) => { Ok(run_jit_function!(lib, main_fn_name, f64, |num| num_to_ast( env, - f64_to_ast(env.arena, num), + number_literal_to_ast(env.arena, num), content ))) } @@ -272,15 +286,30 @@ fn ptr_to_ast<'a>( content: &Content, ) -> Expr<'a> { match layout { + Layout::Builtin(Builtin::Int128) => { + let num = unsafe { *(ptr as *const i128) }; + + num_to_ast(env, number_literal_to_ast(env.arena, num), content) + } Layout::Builtin(Builtin::Int64) => { let num = unsafe { *(ptr as *const i64) }; - num_to_ast(env, i64_to_ast(env.arena, num), content) + num_to_ast(env, number_literal_to_ast(env.arena, num), content) + } + Layout::Builtin(Builtin::Int32) => { + let num = unsafe { *(ptr as *const i32) }; + + num_to_ast(env, number_literal_to_ast(env.arena, num), content) + } + Layout::Builtin(Builtin::Int16) => { + let num = unsafe { *(ptr as *const i16) }; + + num_to_ast(env, number_literal_to_ast(env.arena, num), content) } Layout::Builtin(Builtin::Usize) => { let num = unsafe { *(ptr as *const usize) }; - num_to_ast(env, nat_to_ast(env.arena, num), content) + num_to_ast(env, number_literal_to_ast(env.arena, num), content) } Layout::Builtin(Builtin::Int1) => { // TODO: bits are not as expected here. @@ -292,7 +321,12 @@ fn ptr_to_ast<'a>( Layout::Builtin(Builtin::Float64) => { let num = unsafe { *(ptr as *const f64) }; - num_to_ast(env, f64_to_ast(env.arena, num), content) + num_to_ast(env, number_literal_to_ast(env.arena, num), content) + } + Layout::Builtin(Builtin::Float32) => { + let num = unsafe { *(ptr as *const f32) }; + + num_to_ast(env, number_literal_to_ast(env.arena, num), content) } Layout::Builtin(Builtin::EmptyList) => Expr::List { items: &[], @@ -855,29 +889,7 @@ fn num_to_ast<'a>(env: &Env<'a, '_>, num_expr: Expr<'a>, content: &Content) -> E /// This is centralized in case we want to format it differently later, /// e.g. adding underscores for large numbers -fn nat_to_ast(arena: &Bump, num: usize) -> Expr<'_> { - Expr::Num(arena.alloc(format!("{}", num))) -} - -/// This is centralized in case we want to format it differently later, -/// e.g. adding underscores for large numbers -fn i64_to_ast(arena: &Bump, num: i64) -> Expr<'_> { - Expr::Num(arena.alloc(format!("{}", num))) -} - -fn i32_to_ast(arena: &Bump, num: i32) -> Expr<'_> { - Expr::Num(arena.alloc(format!("{}", num))) -} - -/// This is centralized in case we want to format it differently later, -/// e.g. adding underscores for large numbers -fn i128_to_ast(arena: &Bump, num: i128) -> Expr<'_> { - Expr::Num(arena.alloc(format!("{}", num))) -} - -/// This is centralized in case we want to format it differently later, -/// e.g. adding underscores for large numbers -fn f64_to_ast(arena: &Bump, num: f64) -> Expr<'_> { +fn number_literal_to_ast(arena: &Bump, num: T) -> Expr<'_> { Expr::Num(arena.alloc(format!("{}", num))) } From 45185d1e8414c9ca1d5dd7ed04601dc2eb429e54 Mon Sep 17 00:00:00 2001 From: tarjei Date: Mon, 31 May 2021 19:08:37 +0200 Subject: [PATCH 055/496] Implement List.swap in zig --- compiler/builtins/bitcode/src/list.zig | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/compiler/builtins/bitcode/src/list.zig b/compiler/builtins/bitcode/src/list.zig index d22c7136a1..c35484077b 100644 --- a/compiler/builtins/bitcode/src/list.zig +++ b/compiler/builtins/bitcode/src/list.zig @@ -729,7 +729,19 @@ pub fn listSwap( index_1: usize, index_2: usize, ) callconv(.C) RocList { - return RocList.empty(); + const size = list.len(); + if (index_1 >= size or index_2 >= size) { + // Either index out of bounds so we just return + return list; + } + + const newList = list.makeUnique(alignment, element_width); + + if (newList.bytes) |source_ptr| { + swapElements(source_ptr, element_width, index_1, index_2); + } + + return newList; } pub fn listDrop( From 08a3b43649ef0dc0fedef0a7a317a26ae019d786 Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 31 May 2021 23:18:39 +0200 Subject: [PATCH 056/496] remove inaccurate comments --- cli/tests/repl_eval.rs | 4 ---- 1 file changed, 4 deletions(-) diff --git a/cli/tests/repl_eval.rs b/cli/tests/repl_eval.rs index 62efefc23d..7bb2e633fb 100644 --- a/cli/tests/repl_eval.rs +++ b/cli/tests/repl_eval.rs @@ -500,15 +500,11 @@ mod repl_eval { #[test] fn identity_lambda() { - // Even though this gets unwrapped at runtime, the repl should still - // report it as a record expect_success("\\x -> x", " : a -> a"); } #[test] fn stdlib_function() { - // Even though this gets unwrapped at runtime, the repl should still - // report it as a record expect_success("Num.abs", " : Num a -> Num a"); } From 7bafa42d4da271d9e171a35bf235ecc449568941 Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 31 May 2021 23:19:14 +0200 Subject: [PATCH 057/496] make alias analysis pass the test suite without panics --- compiler/mono/src/alias_analysis.rs | 176 ++++++++++++++++++++++------ 1 file changed, 142 insertions(+), 34 deletions(-) diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 63b27db8ca..3194969d19 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -40,29 +40,81 @@ where for proc in procs { let spec = proc_spec(proc)?; - m.add_func(FuncName(&proc.name.to_ne_bytes()), spec)?; + let mut name_bytes = [0u8; 16]; + + use std::collections::hash_map::DefaultHasher; + use std::hash::Hash; + use std::hash::Hasher; + + let layout_hash = { + let mut hasher = DefaultHasher::new(); + + for (layout, _) in proc.args.iter() { + layout.hash(&mut hasher); + } + proc.ret_layout.hash(&mut hasher); + + hasher.finish() + }; + + let sbytes = proc.name.to_ne_bytes(); + let lbytes = layout_hash.to_ne_bytes(); + + let it = sbytes + .iter() + .chain(lbytes.iter()) + .zip(name_bytes.iter_mut()); + + for (source, target) in it { + *target = *source; + } + + m.add_func(FuncName(&name_bytes), spec)?; if format!("{:?}", proc.name).contains("mainForHost") { main_function = Some(proc.name); } + + if format!("{:?}", proc.name).contains("replOutput") { + main_function = Some(proc.name); + } } m.build()? }; - let program = { - let mut p = ProgramBuilder::new(); - p.add_mod(MOD_APP, main_module)?; - p.add_entry_point( - EntryPointName(b"mainForHost"), - MOD_APP, - FuncName(&main_function.unwrap().to_ne_bytes()), - )?; + match main_function { + None => { + let program = { + let mut p = ProgramBuilder::new(); + p.add_mod(MOD_APP, main_module)?; + p.add_entry_point( + EntryPointName(b"not defined! probably a function in the repl"), + MOD_APP, + FuncName(&[]), + )?; - p.build()? - }; + p.build()? + }; - morphic_lib::solve(program) + morphic_lib::solve(program) + } + Some(main_function) => { + let program = { + let mut p = ProgramBuilder::new(); + p.add_mod(MOD_APP, main_module)?; + p.add_entry_point( + EntryPointName(b"mainForHost"), + MOD_APP, + FuncName(&main_function.to_ne_bytes()), + )?; + + p.build()? + }; + + morphic_lib::solve(program) + } + } } fn proc_spec(proc: &Proc) -> Result { @@ -319,10 +371,13 @@ fn call_spec( ), HigherOrderLowLevel { .. } => { // TODO overly pessimstic + // filter_map because one of the arguments is a function name, which + // is not defined in the env let arguments: Vec<_> = call .arguments .iter() - .map(|symbol| env.symbols[symbol]) + .filter_map(|symbol| env.symbols.get(symbol)) + .copied() .collect(); let result_type = layout_spec(builder, layout)?; @@ -427,21 +482,26 @@ fn build_variant_types( result.push(build_tuple_type(builder, tag)?); } } - Recursive(_) => todo!(), - NonNullableUnwrapped(_) => todo!(), + Recursive(_) => unreachable!(), + NonNullableUnwrapped(_) => unreachable!(), NullableWrapped { nullable_id: _, other_tags: _, - } => todo!(), + } => unreachable!(), NullableUnwrapped { nullable_id: _, other_fields: _, - } => todo!(), + } => unreachable!(), } Ok(result) } +fn worst_case_type(context: &mut impl TypeContext) -> Result { + let cell = context.add_heap_cell_type(); + context.add_bag_type(cell) +} + fn expr_spec( builder: &mut FuncDefBuilder, env: &mut Env, @@ -460,15 +520,25 @@ fn expr_spec( tag_id, union_size: _, arguments, - } => { - let value_id = build_tuple_value(builder, env, block, arguments)?; - let variant_types = build_variant_types(builder, tag_layout)?; - builder.add_make_union(block, &variant_types, *tag_id as u32, value_id) - } + } => match tag_layout { + UnionLayout::NonRecursive(_) => { + let value_id = build_tuple_value(builder, env, block, arguments)?; + let variant_types = build_variant_types(builder, tag_layout)?; + builder.add_make_union(block, &variant_types, *tag_id as u32, value_id) + } + UnionLayout::Recursive(_) + | UnionLayout::NonNullableUnwrapped(_) + | UnionLayout::NullableWrapped { .. } + | UnionLayout::NullableUnwrapped { .. } => { + let result_type = worst_case_type(builder)?; + let value_id = build_tuple_value(builder, env, block, arguments)?; + builder.add_unknown_with(block, &[value_id], result_type) + } + }, Struct(fields) => build_tuple_value(builder, env, block, fields), AccessAtIndex { index, - field_layouts: _, + field_layouts, structure, wrapped, } => { @@ -482,13 +552,23 @@ fn expr_spec( builder.add_make_tuple(block, &[]) } Wrapped::SingleElementRecord => { - todo!("do we unwrap single-element records still?") + // builder.add_get_tuple_field(block, value_id, *index as u32) + Ok(env.symbols[structure]) } Wrapped::RecordOrSingleTagUnion => { builder.add_get_tuple_field(block, value_id, *index as u32) } Wrapped::MultiTagUnion => { - builder.add_get_tuple_field(block, value_id, *index as u32) + // Clearly this is not generally correct, but it should be for our examples + let hacky_is_recursive = + field_layouts.iter().any(|l| l == &Layout::RecursivePointer); + + if hacky_is_recursive { + let result_type = layout_spec(builder, layout)?; + builder.add_unknown_with(block, &[value_id], result_type) + } else { + builder.add_get_tuple_field(block, value_id, *index as u32) + } } } } @@ -553,13 +633,25 @@ fn layout_spec(builder: &mut FuncDefBuilder, layout: &Layout) -> Result match layout { Builtin(builtin) => builtin_spec(builder, builtin), Struct(fields) => build_tuple_type(builder, fields), - Union(union_layout) => { - let variant_types = build_variant_types(builder, union_layout)?; - builder.add_union_type(&variant_types) - } - RecursivePointer => todo!(), + Union(union_layout) => match union_layout { + UnionLayout::NonRecursive(_) => { + let variant_types = build_variant_types(builder, union_layout)?; + builder.add_union_type(&variant_types) + } + UnionLayout::Recursive(_) => worst_case_type(builder), + UnionLayout::NonNullableUnwrapped(_) => worst_case_type(builder), + UnionLayout::NullableWrapped { + nullable_id: _, + other_tags: _, + } => worst_case_type(builder), + UnionLayout::NullableUnwrapped { + nullable_id: _, + other_fields: _, + } => worst_case_type(builder), + }, + RecursivePointer => worst_case_type(builder), FunctionPointer(_, _) => todo!(), - Closure(_, _, _) => todo!(), + Closure(_, lambda_set, _) => layout_spec(builder, &lambda_set.runtime_representation()), } } @@ -596,9 +688,25 @@ fn builtin_spec(builder: &mut FuncDefBuilder, builtin: &Builtin) -> Result todo!(), - EmptyDict => todo!(), - EmptySet => todo!(), + EmptyList => { + // TODO make sure that we consistently treat the EmptyList as a list of unit values + let element_type = builder.add_tuple_type(&[])?; + + let cell = builder.add_heap_cell_type(); + let bag = builder.add_bag_type(element_type)?; + + builder.add_tuple_type(&[cell, bag]) + } + EmptyDict | EmptySet => { + // TODO make sure that we consistently treat the these as a dict of unit values + let unit = builder.add_tuple_type(&[])?; + let element_type = builder.add_tuple_type(&[unit, unit])?; + + let cell = builder.add_heap_cell_type(); + let bag = builder.add_bag_type(element_type)?; + + builder.add_tuple_type(&[cell, bag]) + } } } From 966bb80cdcaabdb7b75f4324e9dc7dd747c369ca Mon Sep 17 00:00:00 2001 From: Jared Ramirez Date: Mon, 31 May 2021 15:40:26 -0700 Subject: [PATCH 058/496] Format & rename some Nix stuff; Remove custom .envrc use nix stuff in favor of stdlib --- .envrc | 155 +-------------------------- compiler/build/src/link.rs | 4 +- nix/zig.nix | 52 ++++----- nix/zls.nix | 28 ----- shell.nix | 209 ++++++++++++++++++------------------- 5 files changed, 132 insertions(+), 316 deletions(-) delete mode 100644 nix/zls.nix diff --git a/.envrc b/.envrc index daafe18d9a..1d953f4bd7 100644 --- a/.envrc +++ b/.envrc @@ -1,154 +1 @@ -# Load environment variables from `nix-shell` and export it out. -# -# Usage: use_nix [-s ] [-w ] [-w ] ... -# -s nix-expression: The nix expression to use for building the shell environment. -# -w path: watch a file for changes. It can be specified multiple times. The -# shell specified with -s is automatically watched. -# -# If no nix-expression were given with -s, it will attempt to find and load -# the shell using the following files in order: shell.nix and default.nix. -# -# Example: -# - use_nix -# - use_nix -s shell.nix -w .nixpkgs-version.json -# -# The dependencies pulled by nix-shell are added to Nix's garbage collector -# roots, such that the environment remains persistent. -# -# Nix-shell is invoked only once per environment, and the output is cached for -# better performance. If any of the watched files change, then the environment -# is rebuilt. -# -# To remove old environments, and allow the GC to collect their dependencies: -# rm -f .direnv -# -use_nix() { - if ! validate_version; then - echo "This .envrc requires direnv version 2.18.2 or above." - exit 1 - fi - - # define all local variables - local shell - local files_to_watch=() - - local opt OPTARG OPTIND # define vars used by getopts locally - while getopts ":n:s:w:" opt; do - case "${opt}" in - s) - shell="${OPTARG}" - files_to_watch=("${files_to_watch[@]}" "${shell}") - ;; - w) - files_to_watch=("${files_to_watch[@]}" "${OPTARG}") - ;; - :) - fail "Invalid option: $OPTARG requires an argument" - ;; - \?) - fail "Invalid option: $OPTARG" - ;; - esac - done - shift $((OPTIND -1)) - - if [[ -z "${shell}" ]]; then - if [[ -f shell.nix ]]; then - shell=shell.nix - files_to_watch=("${files_to_watch[@]}" shell.nix) - elif [[ -f default.nix ]]; then - shell=default.nix - files_to_watch=("${files_to_watch[@]}" default.nix) - else - fail "ERR: no shell was given" - fi - fi - - local f - for f in "${files_to_watch[@]}"; do - if ! [[ -f "${f}" ]]; then - fail "cannot watch file ${f} because it does not exist" - fi - done - - # compute the hash of all the files that makes up the development environment - local env_hash="$(hash_contents "${files_to_watch[@]}")" - - # define the paths - local dir="$(direnv_layout_dir)" - local wd="${dir}/wd-${env_hash}" - local drv="${wd}/env.drv" - local dump="${wd}/dump.env" - - # Generate the environment if we do not have one generated already. - if [[ ! -f "${drv}" ]]; then - mkdir -p "${wd}" - - log_status "use nix: deriving new environment" - IN_NIX_SHELL=1 nix-instantiate --add-root "${drv}" --indirect "${shell}" > /dev/null - nix-store -r $(nix-store --query --references "${drv}") --add-root "${wd}/dep" --indirect > /dev/null - if [[ "${?}" -ne 0 ]] || [[ ! -f "${drv}" ]]; then - rm -rf "${wd}" - fail "use nix: was not able to derive the new environment. Please run 'direnv reload' to try again." - fi - - log_status "use nix: updating cache" - nix-shell "${drv}" --show-trace --run "$(join_args "$direnv" dump bash)" > "${dump}" - if [[ "${?}" -ne 0 ]] || [[ ! -f "${dump}" ]] || ! grep -q IN_NIX_SHELL "${dump}"; then - rm -rf "${wd}" - fail "use nix: was not able to update the cache of the environment. Please run 'direnv reload' to try again." - fi - fi - - # evaluate the dump created by nix-shell earlier, but have to merge the PATH - # with the current PATH - # NOTE: we eval the dump here as opposed to direnv_load it because we don't - # want to persist environment variables coming from the shell at the time of - # the dump. See https://github.com/direnv/direnv/issues/405 for context. - local path_backup="${PATH}" - eval $(cat "${dump}") - export PATH="${PATH}:${path_backup}" - - # cleanup the environment of variables that are not requried, or are causing issues. - unset shellHook # when shellHook is present, then any nix-shell'd script will execute it! - - # watch all the files we were asked to watch for the environment - for f in "${files_to_watch[@]}"; do - watch_file "${f}" - done -} - -fail() { - log_error "${@}" - exit 1 -} - -hash_contents() { - if has md5sum; then - cat "${@}" | md5sum | cut -c -32 - elif has md5; then - cat "${@}" | md5 -q - fi -} - -hash_file() { - if has md5sum; then - md5sum "${@}" | cut -c -32 - elif has md5; then - md5 -q "${@}" - fi -} - -validate_version() { - local version="$("${direnv}" version)" - local major="$(echo "${version}" | cut -d. -f1)" - local minor="$(echo "${version}" | cut -d. -f2)" - local patch="$(echo "${version}" | cut -d. -f3)" - - if [[ "${major}" -gt 2 ]]; then return 0; fi - if [[ "${major}" -eq 2 ]] && [[ "${minor}" -gt 18 ]]; then return 0; fi - if [[ "${major}" -eq 2 ]] && [[ "${minor}" -eq 18 ]] && [[ "${patch}" -ge 2 ]]; then return 0; fi - return 1 -} - -use_nix -s shell.nix +use nix diff --git a/compiler/build/src/link.rs b/compiler/build/src/link.rs index 95983e1a8d..c535f86e57 100644 --- a/compiler/build/src/link.rs +++ b/compiler/build/src/link.rs @@ -466,8 +466,8 @@ fn link_macos( "-lc++", // "-lc++abi", // "-lunwind", // TODO will eventually need this, see https://github.com/rtfeldman/roc/pull/554#discussion_r496370840 - "-framework", - "Security", // This "-framework Security" arg is needed for the `rand` crate in examples/cli + // "-framework", // Uncomment this line & the following ro run the `rand` crate in examples/cli + // "Security", // Output "-o", output_path.to_str().unwrap(), // app diff --git a/nix/zig.nix b/nix/zig.nix index 6f5f49bd18..ae8708625d 100644 --- a/nix/zig.nix +++ b/nix/zig.nix @@ -1,37 +1,37 @@ -{ pkgs, isMacOS, isAarch64 }: +{ pkgs, isDarwin, isAarch64 }: -if isMacOS then +if isDarwin then let version = "0.7.1"; osName = - if isMacOS - then "macos" - else "linux"; + if isDarwin + then "macos" + else "linux"; archName = if isAarch64 - then "aarch64" - else "x86_64"; + then "aarch64" + else "x86_64"; archiveName = "zig-${osName}-${archName}-${version}"; sha256 = "845cb17562978af0cf67e3993f4e33330525eaf01ead9386df9105111e3bc519"; in - pkgs.stdenv.mkDerivation { - pname = "zig"; - version = version; - buildInputs = [ pkgs.gzip ]; - src = pkgs.fetchurl { - inherit sha256; - name = "${archiveName}.tar.xz"; - url = "https://ziglang.org/download/${version}/${archiveName}.tar.xz"; - }; - phases = [ "installPhase" ]; - installPhase = '' - mkdir -p $out/bin - tar -xf $src - cp ${archiveName}/zig $out/zig - cp -r ${archiveName}/lib $out/lib - ln -s "$out/zig" "$out/bin/zig" - chmod +x $out/bin/zig - ''; - } + pkgs.stdenv.mkDerivation { + pname = "zig"; + version = version; + buildInputs = [ pkgs.gzip ]; + src = pkgs.fetchurl { + inherit sha256; + name = "${archiveName}.tar.xz"; + url = "https://ziglang.org/download/${version}/${archiveName}.tar.xz"; + }; + phases = [ "unpackPhase" ]; + unpackPhase = '' + mkdir -p $out/bin + tar -xf $src + cp ${archiveName}/zig $out/zig + cp -r ${archiveName}/lib $out/lib + ln -s "$out/zig" "$out/bin/zig" + chmod +x $out/bin/zig + ''; + } else pkgs.zig diff --git a/nix/zls.nix b/nix/zls.nix deleted file mode 100644 index 29f0feb033..0000000000 --- a/nix/zls.nix +++ /dev/null @@ -1,28 +0,0 @@ -{ pkgs, zig }: - -# As of 2020-10-25, building zls is not available on Nix. For some reason, -# this hangs on `zig build`. I'll try to figure it our later. - -let - rev = "e8c20351d85da8eb4bf22480045b994007284d69"; -in -pkgs.stdenv.mkDerivation { - pname = "zig-language-server"; - version = rev; - src = pkgs.fetchgit { - inherit rev; - fetchSubmodules = true; - url = "https://github.com/zigtools/zls.git"; - sha256 = "06g8gml1g0fmvcfysy93bd1hb64vjd2v12x3kgxz58kmk5z0168y"; - }; - phases = [ "buildPhase" "installPhase" ]; - buildInputs = [ zig ]; - buildPhase = '' - zig build - ''; - installPhase = '' - mkdir -p $out/bin - cp ./zig-cache/bin/zls $out/bin/zls - chmod +x $out/bin/zls - ''; -} diff --git a/shell.nix b/shell.nix index 7b7d61fd55..ddb786a8b3 100644 --- a/shell.nix +++ b/shell.nix @@ -1,116 +1,113 @@ {}: let - splitSystem = builtins.split "-" builtins.currentSystem; - currentArch = builtins.elemAt splitSystem 0; - currentOS = builtins.elemAt splitSystem 2; -in - with { - # Look here for information about how pin version of nixpkgs - # → https://nixos.wiki/wiki/FAQ/Pinning_Nixpkgs - pkgs = import ( - builtins.fetchGit { - # name = "nixpkgs-2021-04-23"; - url = "https://github.com/nixos/nixpkgs/"; - ref = "refs/heads/nixpkgs-unstable"; - rev = "8d0340aee5caac3807c58ad7fa4ebdbbdd9134d6"; - } - ) {}; + # Look here for information about how pin version of nixpkgs + # → https://nixos.wiki/wiki/FAQ/Pinning_Nixpkgs + # TODO: We should probably use flakes at somepoint + pkgs = import ( + builtins.fetchGit { + # name = "nixpkgs-2021-04-23"; + url = "https://github.com/nixos/nixpkgs/"; + ref = "refs/heads/nixpkgs-unstable"; + rev = "8d0340aee5caac3807c58ad7fa4ebdbbdd9134d6"; + } + ) {}; - isMacOS = currentOS == "darwin"; - isLinux = currentOS == "linux"; - isAarch64 = currentArch == "aarch64"; - }; + currentArch = builtins.elemAt (builtins.split "-" builtins.currentSystem) 0; + isAarch64 = currentArch == "aarch64"; - with (pkgs); + darwinInputs = + with pkgs; + lib.optionals stdenv.isDarwin ( + with pkgs.darwin.apple_sdk.frameworks; [ + AppKit + CoreFoundation + CoreServices + CoreVideo + Foundation + Metal + Security + ] + ); - let - darwin-inputs = - if isMacOS then - with pkgs.darwin.apple_sdk.frameworks; [ - AppKit - CoreFoundation - CoreServices - CoreVideo - Foundation - Metal - Security - ] - else - []; - - linux-inputs = - if isLinux then - [ - valgrind - vulkan-headers - vulkan-loader - vulkan-tools - vulkan-validation-layers - xorg.libX11 - xorg.libXcursor - xorg.libXrandr - xorg.libXi - xorg.libxcb - ] - else - []; - - llvmPkgs = pkgs.llvmPackages_10; - zig = import ./nix/zig.nix { inherit pkgs isMacOS isAarch64; }; - inputs = [ - # build libraries - rustc - cargo - clippy - rustfmt - cmake - git - python3 - llvmPkgs.llvm - llvmPkgs.clang - pkg-config - zig - # lib deps - llvmPkgs.libcxx - llvmPkgs.libcxxabi - libffi - libunwind - libxml2 - ncurses - zlib - libiconv - # faster builds - see https://github.com/rtfeldman/roc/blob/trunk/BUILDING_FROM_SOURCE.md#use-lld-for-the-linker - llvmPkgs.lld - # dev tools - # rust-analyzer - # (import ./nix/zls.nix { inherit pkgs zig; }) + linuxInputs = + with pkgs; + lib.optionals stdenv.isLinux [ + valgrind + vulkan-headers + vulkan-loader + vulkan-tools + vulkan-validation-layers + xorg.libX11 + xorg.libXcursor + xorg.libXrandr + xorg.libXi + xorg.libxcb ]; - in - mkShell ( - { - buildInputs = inputs ++ darwin-inputs ++ linux-inputs; + llvmPkgs = pkgs.llvmPackages_10; - # Additional Env vars - LLVM_SYS_100_PREFIX = "${llvmPkgs.llvm}"; - LD_LIBRARY_PATH = stdenv.lib.makeLibraryPath - ( - [ - pkg-config - stdenv.cc.cc.lib - llvmPkgs.libcxx - llvmPkgs.libcxxabi - libunwind - libffi - ncurses - zlib - ] ++ linux-inputs - ); + zig = import ./nix/zig.nix { + pkgs = pkgs; + isDarwin = pkgs.stdenv.isDarwin; + isAarch64 = isAarch64; + }; - # Aliases don't work cross shell, so we do this - shellHook = '' - export PATH="$PATH:$PWD/nix/bin" - ''; - } - ) + inputs = with pkgs;[ + # build libraries + rustc + cargo + clippy + rustfmt + cmake + git + python3 + llvmPkgs.llvm + llvmPkgs.clang + pkg-config + zig + + # lib deps + llvmPkgs.libcxx + llvmPkgs.libcxxabi + libffi + libunwind + libxml2 + ncurses + zlib + libiconv + + # faster builds - see https://github.com/rtfeldman/roc/blob/trunk/BUILDING_FROM_SOURCE.md#use-lld-for-the-linker + llvmPkgs.lld + ]; +in +pkgs.mkShell + { + buildInputs = inputs ++ darwinInputs ++ linuxInputs; + + # Additional Env vars + LLVM_SYS_100_PREFIX = "${llvmPkgs.llvm}"; + LD_LIBRARY_PATH = + with pkgs; + lib.makeLibraryPath + ( + [ + pkg-config + stdenv.cc.cc.lib + llvmPkgs.libcxx + llvmPkgs.libcxxabi + libunwind + libffi + ncurses + zlib + ] + ++ linuxInputs + ); + + # Non Nix llvm installs names the bin llvm-as-${version}, so we + # alias `llvm` to `llvm-as-${version}` here. + # This the name of the file in nix/bin will need to be updated whenever llvm is updated + shellHook = '' + export PATH="$PATH:$PWD/nix/bin" + ''; + } From 96771d46e708156f7e098fa1d48715006a2708e0 Mon Sep 17 00:00:00 2001 From: Jared Ramirez Date: Mon, 31 May 2021 15:46:57 -0700 Subject: [PATCH 059/496] Update BUILD_FROM_SOURCE directions to mention direnv & lorri --- BUILDING_FROM_SOURCE.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/BUILDING_FROM_SOURCE.md b/BUILDING_FROM_SOURCE.md index 8b4e627883..d6640af464 100644 --- a/BUILDING_FROM_SOURCE.md +++ b/BUILDING_FROM_SOURCE.md @@ -94,6 +94,10 @@ You should be in a shell with everything needed to build already installed. Next You should be in a repl now. Have fun! +### Extra tips + +If you plan on using `nix-shell` regularly, check out [direnv](https://direnv.net/) and [lorri](https://github.com/target/lorri). Whenever you `cd` into `roc/`, they will automatically load the Nix dependecies into your current shell, so you never have to run nix-shell directly! + ### Editor When you want to run the editor from Ubuntu inside nix you need to install [nixGL](https://github.com/guibou/nixGL) as well: From 9184512492b507dfc3975ff8e629a386ccd3ec71 Mon Sep 17 00:00:00 2001 From: Jared Ramirez Date: Mon, 31 May 2021 15:59:51 -0700 Subject: [PATCH 060/496] Simplify zig nix script --- nix/zig.nix | 13 ++----------- shell.nix | 4 ---- 2 files changed, 2 insertions(+), 15 deletions(-) diff --git a/nix/zig.nix b/nix/zig.nix index ae8708625d..3d292bc168 100644 --- a/nix/zig.nix +++ b/nix/zig.nix @@ -1,23 +1,14 @@ -{ pkgs, isDarwin, isAarch64 }: +{ pkgs, isDarwin }: if isDarwin then let version = "0.7.1"; - osName = - if isDarwin - then "macos" - else "linux"; - archName = - if isAarch64 - then "aarch64" - else "x86_64"; - archiveName = "zig-${osName}-${archName}-${version}"; + archiveName = "zig-macos-x86_64-${version}"; sha256 = "845cb17562978af0cf67e3993f4e33330525eaf01ead9386df9105111e3bc519"; in pkgs.stdenv.mkDerivation { pname = "zig"; version = version; - buildInputs = [ pkgs.gzip ]; src = pkgs.fetchurl { inherit sha256; name = "${archiveName}.tar.xz"; diff --git a/shell.nix b/shell.nix index ddb786a8b3..11d2b87a0f 100644 --- a/shell.nix +++ b/shell.nix @@ -13,9 +13,6 @@ let } ) {}; - currentArch = builtins.elemAt (builtins.split "-" builtins.currentSystem) 0; - isAarch64 = currentArch == "aarch64"; - darwinInputs = with pkgs; lib.optionals stdenv.isDarwin ( @@ -50,7 +47,6 @@ let zig = import ./nix/zig.nix { pkgs = pkgs; isDarwin = pkgs.stdenv.isDarwin; - isAarch64 = isAarch64; }; inputs = with pkgs;[ From 9cb8f5af95b3c0d92664c83cae38632cbf55823e Mon Sep 17 00:00:00 2001 From: Jared Ramirez Date: Mon, 31 May 2021 16:02:39 -0700 Subject: [PATCH 061/496] Simplify again --- nix/zig.nix | 4 ++-- shell.nix | 5 +---- 2 files changed, 3 insertions(+), 6 deletions(-) diff --git a/nix/zig.nix b/nix/zig.nix index 3d292bc168..b431275b83 100644 --- a/nix/zig.nix +++ b/nix/zig.nix @@ -1,6 +1,6 @@ -{ pkgs, isDarwin }: +{ pkgs }: -if isDarwin then +if pkgs.stdenv.isDarwin then let version = "0.7.1"; archiveName = "zig-macos-x86_64-${version}"; diff --git a/shell.nix b/shell.nix index 11d2b87a0f..fc84e9beb2 100644 --- a/shell.nix +++ b/shell.nix @@ -44,10 +44,7 @@ let llvmPkgs = pkgs.llvmPackages_10; - zig = import ./nix/zig.nix { - pkgs = pkgs; - isDarwin = pkgs.stdenv.isDarwin; - }; + zig = import ./nix/zig.nix { inherit pkgs; }; inputs = with pkgs;[ # build libraries From 81b14b912269996dcf2330b8ad2820913fe98fc1 Mon Sep 17 00:00:00 2001 From: Jared Ramirez Date: Mon, 31 May 2021 19:39:08 -0700 Subject: [PATCH 062/496] Add RocDec.fromString --- compiler/builtins/bitcode/src/dec.zig | 204 ++++++++++++++++++++++++-- nix/zig-unstable.nix | 50 +++++++ shell.nix | 1 + 3 files changed, 241 insertions(+), 14 deletions(-) create mode 100644 nix/zig-unstable.nix diff --git a/compiler/builtins/bitcode/src/dec.zig b/compiler/builtins/bitcode/src/dec.zig index 189347780f..0f3200dd73 100644 --- a/compiler/builtins/bitcode/src/dec.zig +++ b/compiler/builtins/bitcode/src/dec.zig @@ -1,16 +1,110 @@ const std = @import("std"); - const math = std.math; pub const RocDec = struct { num: i128, - pub const decimal_places: u32 = 18; + pub const decimal_places: comptime u32 = 18; - pub const min: RocDec = .{ .num = math.minInt(i128) }; - pub const max: RocDec = .{ .num = math.maxInt(i128) }; + pub const min: comptime RocDec = .{ .num = math.minInt(i128) }; + pub const max: comptime RocDec = .{ .num = math.maxInt(i128) }; - pub const one_point_zero: RocDec = .{ .num = comptime math.pow(i128, 10, RocDec.decimal_places) }; + pub const one_point_zero_i128: comptime i128 = comptime math.pow(i128, 10, RocDec.decimal_places); + pub const one_point_zero: comptime RocDec = .{ .num = one_point_zero_i128 }; + + pub fn fromU64(num: u64) RocDec { + return .{ .num = num * one_point_zero_i128 }; + } + + pub fn fromString(bytes_ptr: [*]const u8, length: usize) ?RocDec { + if (length == 0) { + return null; + } + + var is_negative: bool = bytes_ptr[0] == '-'; + var initial_index: usize = if (is_negative) 1 else 0; + + var point_index: ?usize = null; + var index: usize = 0; + while (index < length) { + var byte: u8 = bytes_ptr[index]; + if (byte == '.' and point_index == null) { + point_index = index; + index += 1; + continue; + } + + if (!isDigit(byte)) { + return null; + } + index += 1; + } + + var before_str_length = length; + var after_val_i128: ?i128 = null; + if (point_index) |pi| { + before_str_length = pi; + + var after_str_len = (length - 1) - pi; + if (after_str_len > decimal_places) { + std.debug.panic("TODO runtime exception for too many decimal places!", .{}); + } + var diff_decimal_places = decimal_places - after_str_len; + + var after_str = bytes_ptr[pi + 1 .. length]; + var after_u64 = std.fmt.parseUnsigned(u64, after_str, 10) catch null; + after_val_i128 = if (after_u64) |f| @intCast(i128, f) * math.pow(i128, 10, diff_decimal_places) else null; + } + + var before_str = bytes_ptr[initial_index..before_str_length]; + var before_val_not_adjusted = std.fmt.parseUnsigned(i128, before_str, 10) catch null; + + var before_val_i128: ?i128 = null; + if (before_val_not_adjusted) |before| { + var result: i128 = undefined; + var overflowed = @mulWithOverflow(i128, before, one_point_zero_i128, &result); + if (overflowed) { + std.debug.panic("TODO runtime exception for overflow!", .{}); + } + before_val_i128 = result; + } + + var dec: ?RocDec = null; + if (before_val_i128) |before| { + if (after_val_i128) |after| { + var result: i128 = undefined; + var overflowed = @addWithOverflow(i128, before, after, &result); + if (overflowed) { + std.debug.panic("TODO runtime exception for overflow!", .{}); + } + dec = .{ .num = result }; + } else { + dec = .{ .num = before }; + } + } else if (after_val_i128) |after| { + dec = .{ .num = after }; + } + + if (dec) |d| { + if (is_negative) { + dec = d.negate(); + } + } + + return dec; + } + + fn isDigit(c: u8) bool { + return switch (c) { + '0'...'9' => true, + else => false, + }; + } + + pub fn negate(self: RocDec) ?RocDec { + var negated = math.negate(self.num) catch null; + return if (negated) |n| .{ .num = n } else null; + } pub fn add(self: RocDec, other: RocDec) RocDec { var answer: i128 = undefined; @@ -218,16 +312,98 @@ fn mul_u128(a: u128, b: u128) U256 { const one_e20: i256 = 100000000000000000000; -const expectEqual = std.testing.expectEqual; +const testing = std.testing; +const expectEqual = testing.expectEqual; -test "add" { - const dec: RocDec = .{ .num = 0 }; - - expectEqual(RocDec{ .num = 0 }, dec.add(.{ .num = 0 })); +test "fromU64" { + var dec = RocDec.fromU64(25); + try expectEqual(RocDec{ .num = 25000000000000000000 }, dec); } -test "mul" { - var dec1: RocDec = .{ .num = 0 }; - - expectEqual(RocDec{ .num = 0 }, dec1.mul(.{ .num = 0 })); +test "fromString: 0" { + var dec = RocDec.fromString("", 0); + if (dec) |_| { + unreachable; + } +} + +test "fromString: 123.45" { + var dec = RocDec.fromString("123.45", 6); + if (dec) |d| { + try expectEqual(RocDec{ .num = 123450000000000000000 }, d); + } else { + unreachable; + } +} + +test "fromString: .45" { + var dec = RocDec.fromString(".45", 3); + if (dec) |d| { + try expectEqual(RocDec{ .num = 450000000000000000 }, d); + } else { + unreachable; + } +} + +test "fromString: 123" { + var dec = RocDec.fromString("123", 3); + if (dec) |d| { + try expectEqual(RocDec{ .num = 123000000000000000000 }, d); + } else { + unreachable; + } +} + +test "fromString: abc" { + var dec = RocDec.fromString("abc", 3); + if (dec) |_| { + unreachable; + } +} + +test "fromString: 123.abc" { + var dec = RocDec.fromString("123.abc", 7); + if (dec) |_| { + unreachable; + } +} + +test "fromString: abc.123" { + var dec = RocDec.fromString("abc.123", 7); + if (dec) |_| { + unreachable; + } +} + +test "fromString: .123.1" { + var dec = RocDec.fromString(".123.1", 6); + if (dec) |d| { + std.debug.print("d: {}", .{d}); + unreachable; + } +} + +test "add: 0" { + var dec: RocDec = .{ .num = 0 }; + try expectEqual(RocDec{ .num = 0 }, dec.add(.{ .num = 0 })); +} + +test "add: 1" { + var dec: RocDec = .{ .num = 0 }; + try expectEqual(RocDec{ .num = 1 }, dec.add(.{ .num = 1 })); +} + +test "mul: by 0" { + var dec: RocDec = .{ .num = 0 }; + try expectEqual(RocDec{ .num = 0 }, dec.mul(.{ .num = 0 })); +} + +test "mul: by 1" { + var dec: RocDec = RocDec.fromU64(15); + try expectEqual(RocDec.fromU64(15), dec.mul(RocDec.fromU64(1))); +} + +test "mul: by 2" { + var dec: RocDec = RocDec.fromU64(15); + try expectEqual(RocDec.fromU64(30), dec.mul(RocDec.fromU64(2))); } diff --git a/nix/zig-unstable.nix b/nix/zig-unstable.nix new file mode 100644 index 0000000000..dce910d0c4 --- /dev/null +++ b/nix/zig-unstable.nix @@ -0,0 +1,50 @@ +{ pkgs }: + +let + # system helpers + splitSystem = builtins.split "-" builtins.currentSystem; + arch = builtins.elemAt splitSystem 0; + isAarch64 = arch == "aarch64"; + setForSystem = { darwin, darwinAarch64, linux, linuxAarch64 }: + if pkgs.stdenv.isDarwin + then ( + if isAarch64 + then darwinAarch64 + else darwin + ) + else ( + if isAarch64 + then linuxAarch64 + else linux + ); + + version = "0.8.0-dev.2711+11ae6c42c"; + osName = + if pkgs.stdenv.isDarwin + then "macos" else "linux"; + archiveName = "zig-${osName}-${arch}-${version}"; + sha256 = setForSystem { + darwin = "bf2a4cd1516d202cfbbcaa7b1308d36aa21a9f9284b39297e70f98c003f479e3"; + darwinAarch64 = "6bc35c3b40b853cd351c890c94c4a6043f5ca492ff6d704bdb1544fe1fe54d9a"; + linux = "b443cc2259fe7712ffc954745266e3ec846e27854713d817bcec35fefd655a8c"; + linuxAarch64 = "229830e6dc92f641a1106af3a8ee96fdef379ffd3a3d7db7ed62d2b46bd8ed45"; + }; +in +pkgs.stdenv.mkDerivation { + pname = "zig-unstable"; + version = version; + src = pkgs.fetchurl { + inherit sha256; + name = "${archiveName}.tar.xz"; + url = "https://ziglang.org/builds/${archiveName}.tar.xz"; + }; + phases = [ "unpackPhase" ]; + unpackPhase = '' + mkdir -p $out/bin + tar -xf $src + cp ${archiveName}/zig $out/zig + cp -r ${archiveName}/lib $out/lib + ln -s "$out/zig" "$out/bin/zig" + chmod +x $out/bin/zig + ''; +} diff --git a/shell.nix b/shell.nix index fc84e9beb2..d19c8a7c22 100644 --- a/shell.nix +++ b/shell.nix @@ -44,6 +44,7 @@ let llvmPkgs = pkgs.llvmPackages_10; + # zig = import ./nix/zig-unstable.nix { inherit pkgs; }; zig = import ./nix/zig.nix { inherit pkgs; }; inputs = with pkgs;[ From a691afbf0eb245cae0818c6acaa44cd1a8431a97 Mon Sep 17 00:00:00 2001 From: Jared Ramirez Date: Mon, 31 May 2021 19:52:19 -0700 Subject: [PATCH 063/496] Add a few more test cases --- compiler/builtins/bitcode/src/dec.zig | 20 +++++++++++++++++++- 1 file changed, 19 insertions(+), 1 deletion(-) diff --git a/compiler/builtins/bitcode/src/dec.zig b/compiler/builtins/bitcode/src/dec.zig index 0f3200dd73..ba6041899a 100644 --- a/compiler/builtins/bitcode/src/dec.zig +++ b/compiler/builtins/bitcode/src/dec.zig @@ -320,13 +320,31 @@ test "fromU64" { try expectEqual(RocDec{ .num = 25000000000000000000 }, dec); } -test "fromString: 0" { +test "fromString: empty" { var dec = RocDec.fromString("", 0); if (dec) |_| { unreachable; } } +test "fromString: 0" { + var dec = RocDec.fromString("0", 1); + if (dec) |d| { + try expectEqual(RocDec{ .num = 0 }, d); + } else { + unreachable; + } +} + +test "fromString: 1" { + var dec = RocDec.fromString("1", 1); + if (dec) |d| { + try expectEqual(RocDec.one_point_zero, d); + } else { + unreachable; + } +} + test "fromString: 123.45" { var dec = RocDec.fromString("123.45", 6); if (dec) |d| { From 6001312393eb78a1c2949c8d4d7204119d3ef070 Mon Sep 17 00:00:00 2001 From: rvcas Date: Tue, 1 Jun 2021 15:40:12 -0400 Subject: [PATCH 064/496] chore: add mono txt files to git --- .../test_mono/generated/alias_variable.txt | 4 ++ .../alias_variable_and_return_it.txt | 3 + .../generated/branch_store_variable.txt | 9 +++ .../test_mono/generated/closure_in_list.txt | 20 ++++++ compiler/test_mono/generated/dict.txt | 12 ++++ compiler/test_mono/generated/factorial.txt | 27 ++++++++ compiler/test_mono/generated/fst.txt | 17 +++++ .../generated/guard_pattern_true.txt | 25 +++++++ compiler/test_mono/generated/has_none.txt | 33 ++++++++++ .../if_guard_bind_variable_false.txt | 22 +++++++ .../test_mono/generated/if_multi_branch.txt | 13 ++++ .../test_mono/generated/ir_assignment.txt | 3 + compiler/test_mono/generated/ir_plus.txt | 9 +++ compiler/test_mono/generated/ir_round.txt | 8 +++ compiler/test_mono/generated/ir_two_defs.txt | 9 +++ compiler/test_mono/generated/ir_when_idiv.txt | 27 ++++++++ compiler/test_mono/generated/ir_when_just.txt | 19 ++++++ .../test_mono/generated/ir_when_maybe.txt | 13 ++++ .../test_mono/generated/ir_when_record.txt | 6 ++ .../test_mono/generated/ir_when_these.txt | 19 ++++++ compiler/test_mono/generated/is_nil.txt | 20 ++++++ .../generated/let_with_record_pattern.txt | 6 ++ .../let_with_record_pattern_list.txt | 10 +++ compiler/test_mono/generated/let_x_in_x.txt | 5 ++ .../generated/let_x_in_x_indirect.txt | 8 +++ .../generated/linked_list_length_twice.txt | 26 ++++++++ compiler/test_mono/generated/list_append.txt | 10 +++ .../generated/list_append_closure.txt | 15 +++++ .../generated/list_cannot_update_inplace.txt | 40 ++++++++++++ compiler/test_mono/generated/list_get.txt | 28 ++++++++ compiler/test_mono/generated/list_len.txt | 25 +++++++ .../generated/list_pass_to_function.txt | 22 +++++++ compiler/test_mono/generated/mk_pair_of.txt | 12 ++++ .../test_mono/generated/nested_closure.txt | 15 +++++ .../generated/nested_pattern_match.txt | 32 +++++++++ .../test_mono/generated/one_element_tag.txt | 3 + .../test_mono/generated/optional_when.txt | 43 ++++++++++++ compiler/test_mono/generated/peano.txt | 10 +++ compiler/test_mono/generated/peano1.txt | 19 ++++++ compiler/test_mono/generated/peano2.txt | 28 ++++++++ .../test_mono/generated/quicksort_help.txt | 41 ++++++++++++ .../test_mono/generated/quicksort_swap.txt | 65 +++++++++++++++++++ ...optional_field_function_no_use_default.txt | 17 +++++ ...rd_optional_field_function_use_default.txt | 15 +++++ ...cord_optional_field_let_no_use_default.txt | 16 +++++ .../record_optional_field_let_use_default.txt | 14 ++++ compiler/test_mono/generated/rigids.txt | 62 ++++++++++++++++++ compiler/test_mono/generated/simple_if.txt | 8 +++ .../generated/somehow_drops_definitions.txt | 53 +++++++++++++++ .../generated/specialize_closures.txt | 55 ++++++++++++++++ .../test_mono/generated/when_joinpoint.txt | 23 +++++++ .../test_mono/generated/when_nested_maybe.txt | 32 +++++++++ .../test_mono/generated/when_on_record.txt | 10 +++ .../test_mono/generated/when_on_result.txt | 28 ++++++++ .../generated/when_on_two_values.txt | 28 ++++++++ 55 files changed, 1142 insertions(+) create mode 100644 compiler/test_mono/generated/alias_variable.txt create mode 100644 compiler/test_mono/generated/alias_variable_and_return_it.txt create mode 100644 compiler/test_mono/generated/branch_store_variable.txt create mode 100644 compiler/test_mono/generated/closure_in_list.txt create mode 100644 compiler/test_mono/generated/dict.txt create mode 100644 compiler/test_mono/generated/factorial.txt create mode 100644 compiler/test_mono/generated/fst.txt create mode 100644 compiler/test_mono/generated/guard_pattern_true.txt create mode 100644 compiler/test_mono/generated/has_none.txt create mode 100644 compiler/test_mono/generated/if_guard_bind_variable_false.txt create mode 100644 compiler/test_mono/generated/if_multi_branch.txt create mode 100644 compiler/test_mono/generated/ir_assignment.txt create mode 100644 compiler/test_mono/generated/ir_plus.txt create mode 100644 compiler/test_mono/generated/ir_round.txt create mode 100644 compiler/test_mono/generated/ir_two_defs.txt create mode 100644 compiler/test_mono/generated/ir_when_idiv.txt create mode 100644 compiler/test_mono/generated/ir_when_just.txt create mode 100644 compiler/test_mono/generated/ir_when_maybe.txt create mode 100644 compiler/test_mono/generated/ir_when_record.txt create mode 100644 compiler/test_mono/generated/ir_when_these.txt create mode 100644 compiler/test_mono/generated/is_nil.txt create mode 100644 compiler/test_mono/generated/let_with_record_pattern.txt create mode 100644 compiler/test_mono/generated/let_with_record_pattern_list.txt create mode 100644 compiler/test_mono/generated/let_x_in_x.txt create mode 100644 compiler/test_mono/generated/let_x_in_x_indirect.txt create mode 100644 compiler/test_mono/generated/linked_list_length_twice.txt create mode 100644 compiler/test_mono/generated/list_append.txt create mode 100644 compiler/test_mono/generated/list_append_closure.txt create mode 100644 compiler/test_mono/generated/list_cannot_update_inplace.txt create mode 100644 compiler/test_mono/generated/list_get.txt create mode 100644 compiler/test_mono/generated/list_len.txt create mode 100644 compiler/test_mono/generated/list_pass_to_function.txt create mode 100644 compiler/test_mono/generated/mk_pair_of.txt create mode 100644 compiler/test_mono/generated/nested_closure.txt create mode 100644 compiler/test_mono/generated/nested_pattern_match.txt create mode 100644 compiler/test_mono/generated/one_element_tag.txt create mode 100644 compiler/test_mono/generated/optional_when.txt create mode 100644 compiler/test_mono/generated/peano.txt create mode 100644 compiler/test_mono/generated/peano1.txt create mode 100644 compiler/test_mono/generated/peano2.txt create mode 100644 compiler/test_mono/generated/quicksort_help.txt create mode 100644 compiler/test_mono/generated/quicksort_swap.txt create mode 100644 compiler/test_mono/generated/record_optional_field_function_no_use_default.txt create mode 100644 compiler/test_mono/generated/record_optional_field_function_use_default.txt create mode 100644 compiler/test_mono/generated/record_optional_field_let_no_use_default.txt create mode 100644 compiler/test_mono/generated/record_optional_field_let_use_default.txt create mode 100644 compiler/test_mono/generated/rigids.txt create mode 100644 compiler/test_mono/generated/simple_if.txt create mode 100644 compiler/test_mono/generated/somehow_drops_definitions.txt create mode 100644 compiler/test_mono/generated/specialize_closures.txt create mode 100644 compiler/test_mono/generated/when_joinpoint.txt create mode 100644 compiler/test_mono/generated/when_nested_maybe.txt create mode 100644 compiler/test_mono/generated/when_on_record.txt create mode 100644 compiler/test_mono/generated/when_on_result.txt create mode 100644 compiler/test_mono/generated/when_on_two_values.txt diff --git a/compiler/test_mono/generated/alias_variable.txt b/compiler/test_mono/generated/alias_variable.txt new file mode 100644 index 0000000000..30f430e2d7 --- /dev/null +++ b/compiler/test_mono/generated/alias_variable.txt @@ -0,0 +1,4 @@ +procedure Test.0 (): + let Test.1 = 5i64; + let Test.3 = 3i64; + ret Test.3; diff --git a/compiler/test_mono/generated/alias_variable_and_return_it.txt b/compiler/test_mono/generated/alias_variable_and_return_it.txt new file mode 100644 index 0000000000..755d390183 --- /dev/null +++ b/compiler/test_mono/generated/alias_variable_and_return_it.txt @@ -0,0 +1,3 @@ +procedure Test.0 (): + let Test.1 = 5i64; + ret Test.1; diff --git a/compiler/test_mono/generated/branch_store_variable.txt b/compiler/test_mono/generated/branch_store_variable.txt new file mode 100644 index 0000000000..59f4d90045 --- /dev/null +++ b/compiler/test_mono/generated/branch_store_variable.txt @@ -0,0 +1,9 @@ +procedure Test.0 (): + let Test.2 = 0i64; + let Test.5 = 1i64; + let Test.6 = lowlevel Eq Test.5 Test.2; + if Test.6 then + let Test.3 = 12i64; + ret Test.3; + else + ret Test.2; diff --git a/compiler/test_mono/generated/closure_in_list.txt b/compiler/test_mono/generated/closure_in_list.txt new file mode 100644 index 0000000000..5950b9e086 --- /dev/null +++ b/compiler/test_mono/generated/closure_in_list.txt @@ -0,0 +1,20 @@ +procedure List.7 (#Attr.2): + let Test.7 = lowlevel ListLen #Attr.2; + ret Test.7; + +procedure Test.1 (Test.5): + let Test.2 = 41i64; + let Test.11 = Struct {Test.2}; + let Test.10 = Array [Test.11]; + ret Test.10; + +procedure Test.3 (Test.9, #Attr.12): + let Test.2 = Index 0 #Attr.12; + ret Test.2; + +procedure Test.0 (): + let Test.8 = Struct {}; + let Test.4 = CallByName Test.1 Test.8; + let Test.6 = CallByName List.7 Test.4; + dec Test.4; + ret Test.6; diff --git a/compiler/test_mono/generated/dict.txt b/compiler/test_mono/generated/dict.txt new file mode 100644 index 0000000000..7711398541 --- /dev/null +++ b/compiler/test_mono/generated/dict.txt @@ -0,0 +1,12 @@ +procedure Dict.2 (): + let Test.4 = lowlevel DictEmpty ; + ret Test.4; + +procedure Dict.8 (#Attr.2): + let Test.3 = lowlevel DictSize #Attr.2; + ret Test.3; + +procedure Test.0 (): + let Test.2 = CallByName Dict.2; + let Test.1 = CallByName Dict.8 Test.2; + ret Test.1; diff --git a/compiler/test_mono/generated/factorial.txt b/compiler/test_mono/generated/factorial.txt new file mode 100644 index 0000000000..c57881e00b --- /dev/null +++ b/compiler/test_mono/generated/factorial.txt @@ -0,0 +1,27 @@ +procedure Num.25 (#Attr.2, #Attr.3): + let Test.14 = lowlevel NumSub #Attr.2 #Attr.3; + ret Test.14; + +procedure Num.26 (#Attr.2, #Attr.3): + let Test.12 = lowlevel NumMul #Attr.2 #Attr.3; + ret Test.12; + +procedure Test.1 (Test.2, Test.3): + joinpoint Test.7 Test.2 Test.3: + let Test.15 = 0i64; + let Test.16 = lowlevel Eq Test.15 Test.2; + if Test.16 then + ret Test.3; + else + let Test.13 = 1i64; + let Test.10 = CallByName Num.25 Test.2 Test.13; + let Test.11 = CallByName Num.26 Test.2 Test.3; + jump Test.7 Test.10 Test.11; + in + jump Test.7 Test.2 Test.3; + +procedure Test.0 (): + let Test.5 = 10i64; + let Test.6 = 1i64; + let Test.4 = CallByName Test.1 Test.5 Test.6; + ret Test.4; diff --git a/compiler/test_mono/generated/fst.txt b/compiler/test_mono/generated/fst.txt new file mode 100644 index 0000000000..13e6954e29 --- /dev/null +++ b/compiler/test_mono/generated/fst.txt @@ -0,0 +1,17 @@ +procedure Test.1 (Test.2, Test.3): + inc Test.2; + ret Test.2; + +procedure Test.0 (): + let Test.11 = 1i64; + let Test.12 = 2i64; + let Test.13 = 3i64; + let Test.5 = Array [Test.11, Test.12, Test.13]; + let Test.8 = 3i64; + let Test.9 = 2i64; + let Test.10 = 1i64; + let Test.6 = Array [Test.8, Test.9, Test.10]; + let Test.4 = CallByName Test.1 Test.5 Test.6; + dec Test.6; + dec Test.5; + ret Test.4; diff --git a/compiler/test_mono/generated/guard_pattern_true.txt b/compiler/test_mono/generated/guard_pattern_true.txt new file mode 100644 index 0000000000..ef390e692d --- /dev/null +++ b/compiler/test_mono/generated/guard_pattern_true.txt @@ -0,0 +1,25 @@ +procedure Test.1 (Test.3): + let Test.6 = 2i64; + joinpoint Test.12: + let Test.10 = 0i64; + ret Test.10; + in + let Test.11 = 2i64; + let Test.14 = lowlevel Eq Test.11 Test.6; + if Test.14 then + joinpoint Test.8 Test.13: + if Test.13 then + let Test.7 = 42i64; + ret Test.7; + else + jump Test.12; + in + let Test.9 = false; + jump Test.8 Test.9; + else + jump Test.12; + +procedure Test.0 (): + let Test.5 = Struct {}; + let Test.4 = CallByName Test.1 Test.5; + ret Test.4; diff --git a/compiler/test_mono/generated/has_none.txt b/compiler/test_mono/generated/has_none.txt new file mode 100644 index 0000000000..9437ddf329 --- /dev/null +++ b/compiler/test_mono/generated/has_none.txt @@ -0,0 +1,33 @@ +procedure Test.3 (Test.4): + joinpoint Test.13 Test.4: + let Test.23 = 1i64; + let Test.24 = Index 0 Test.4; + let Test.25 = lowlevel Eq Test.23 Test.24; + if Test.25 then + let Test.14 = false; + ret Test.14; + else + let Test.19 = Index 1 Test.4; + let Test.20 = 1i64; + let Test.21 = Index 0 Test.19; + let Test.22 = lowlevel Eq Test.20 Test.21; + if Test.22 then + let Test.15 = true; + ret Test.15; + else + let Test.7 = Index 2 Test.4; + jump Test.13 Test.7; + in + jump Test.13 Test.4; + +procedure Test.0 (): + let Test.28 = 0i64; + let Test.31 = 0i64; + let Test.30 = 3i64; + let Test.26 = Just Test.31 Test.30; + let Test.29 = 1i64; + let Test.27 = Nil Test.29; + let Test.12 = Cons Test.28 Test.26 Test.27; + let Test.11 = CallByName Test.3 Test.12; + dec Test.12; + ret Test.11; diff --git a/compiler/test_mono/generated/if_guard_bind_variable_false.txt b/compiler/test_mono/generated/if_guard_bind_variable_false.txt new file mode 100644 index 0000000000..36630718ca --- /dev/null +++ b/compiler/test_mono/generated/if_guard_bind_variable_false.txt @@ -0,0 +1,22 @@ +procedure Bool.5 (#Attr.2, #Attr.3): + let Test.11 = lowlevel Eq #Attr.2 #Attr.3; + ret Test.11; + +procedure Test.1 (Test.3): + let Test.6 = 10i64; + joinpoint Test.8 Test.13: + if Test.13 then + let Test.7 = 0i64; + ret Test.7; + else + let Test.12 = 42i64; + ret Test.12; + in + let Test.10 = 5i64; + let Test.9 = CallByName Bool.5 Test.6 Test.10; + jump Test.8 Test.9; + +procedure Test.0 (): + let Test.5 = Struct {}; + let Test.4 = CallByName Test.1 Test.5; + ret Test.4; diff --git a/compiler/test_mono/generated/if_multi_branch.txt b/compiler/test_mono/generated/if_multi_branch.txt new file mode 100644 index 0000000000..c4953af3c3 --- /dev/null +++ b/compiler/test_mono/generated/if_multi_branch.txt @@ -0,0 +1,13 @@ +procedure Test.0 (): + let Test.6 = true; + if Test.6 then + let Test.7 = 1i64; + ret Test.7; + else + let Test.4 = false; + if Test.4 then + let Test.5 = 2i64; + ret Test.5; + else + let Test.3 = 3i64; + ret Test.3; diff --git a/compiler/test_mono/generated/ir_assignment.txt b/compiler/test_mono/generated/ir_assignment.txt new file mode 100644 index 0000000000..755d390183 --- /dev/null +++ b/compiler/test_mono/generated/ir_assignment.txt @@ -0,0 +1,3 @@ +procedure Test.0 (): + let Test.1 = 5i64; + ret Test.1; diff --git a/compiler/test_mono/generated/ir_plus.txt b/compiler/test_mono/generated/ir_plus.txt new file mode 100644 index 0000000000..1fa959e684 --- /dev/null +++ b/compiler/test_mono/generated/ir_plus.txt @@ -0,0 +1,9 @@ +procedure Num.24 (#Attr.2, #Attr.3): + let Test.4 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Test.4; + +procedure Test.0 (): + let Test.2 = 1i64; + let Test.3 = 2i64; + let Test.1 = CallByName Num.24 Test.2 Test.3; + ret Test.1; diff --git a/compiler/test_mono/generated/ir_round.txt b/compiler/test_mono/generated/ir_round.txt new file mode 100644 index 0000000000..5448d22900 --- /dev/null +++ b/compiler/test_mono/generated/ir_round.txt @@ -0,0 +1,8 @@ +procedure Num.47 (#Attr.2): + let Test.3 = lowlevel NumRound #Attr.2; + ret Test.3; + +procedure Test.0 (): + let Test.2 = 3.6f64; + let Test.1 = CallByName Num.47 Test.2; + ret Test.1; diff --git a/compiler/test_mono/generated/ir_two_defs.txt b/compiler/test_mono/generated/ir_two_defs.txt new file mode 100644 index 0000000000..04a64113c5 --- /dev/null +++ b/compiler/test_mono/generated/ir_two_defs.txt @@ -0,0 +1,9 @@ +procedure Num.24 (#Attr.2, #Attr.3): + let Test.4 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Test.4; + +procedure Test.0 (): + let Test.1 = 3i64; + let Test.2 = 4i64; + let Test.3 = CallByName Num.24 Test.1 Test.2; + ret Test.3; diff --git a/compiler/test_mono/generated/ir_when_idiv.txt b/compiler/test_mono/generated/ir_when_idiv.txt new file mode 100644 index 0000000000..56baee4141 --- /dev/null +++ b/compiler/test_mono/generated/ir_when_idiv.txt @@ -0,0 +1,27 @@ +procedure Num.42 (#Attr.2, #Attr.3): + let Test.17 = 0i64; + let Test.13 = lowlevel NotEq #Attr.3 Test.17; + if Test.13 then + let Test.16 = 1i64; + let Test.15 = lowlevel NumDivUnchecked #Attr.2 #Attr.3; + let Test.14 = Ok Test.16 Test.15; + ret Test.14; + else + let Test.12 = 0i64; + let Test.11 = Struct {}; + let Test.10 = Err Test.12 Test.11; + ret Test.10; + +procedure Test.0 (): + let Test.8 = 1000i64; + let Test.9 = 10i64; + let Test.2 = CallByName Num.42 Test.8 Test.9; + let Test.5 = 1i64; + let Test.6 = Index 0 Test.2; + let Test.7 = lowlevel Eq Test.5 Test.6; + if Test.7 then + let Test.1 = Index 1 Test.2; + ret Test.1; + else + let Test.4 = -1i64; + ret Test.4; diff --git a/compiler/test_mono/generated/ir_when_just.txt b/compiler/test_mono/generated/ir_when_just.txt new file mode 100644 index 0000000000..4b25c7c779 --- /dev/null +++ b/compiler/test_mono/generated/ir_when_just.txt @@ -0,0 +1,19 @@ +procedure Num.24 (#Attr.2, #Attr.3): + let Test.6 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Test.6; + +procedure Test.0 (): + let Test.12 = 0i64; + let Test.11 = 41i64; + let Test.1 = Just Test.12 Test.11; + let Test.8 = 0i64; + let Test.9 = Index 0 Test.1; + let Test.10 = lowlevel Eq Test.8 Test.9; + if Test.10 then + let Test.3 = Index 1 Test.1; + let Test.5 = 1i64; + let Test.4 = CallByName Num.24 Test.3 Test.5; + ret Test.4; + else + let Test.7 = 1i64; + ret Test.7; diff --git a/compiler/test_mono/generated/ir_when_maybe.txt b/compiler/test_mono/generated/ir_when_maybe.txt new file mode 100644 index 0000000000..fd5037b1de --- /dev/null +++ b/compiler/test_mono/generated/ir_when_maybe.txt @@ -0,0 +1,13 @@ +procedure Test.0 (): + let Test.10 = 0i64; + let Test.9 = 3i64; + let Test.3 = Just Test.10 Test.9; + let Test.6 = 0i64; + let Test.7 = Index 0 Test.3; + let Test.8 = lowlevel Eq Test.6 Test.7; + if Test.8 then + let Test.2 = Index 1 Test.3; + ret Test.2; + else + let Test.5 = 0i64; + ret Test.5; diff --git a/compiler/test_mono/generated/ir_when_record.txt b/compiler/test_mono/generated/ir_when_record.txt new file mode 100644 index 0000000000..ff3ca0f577 --- /dev/null +++ b/compiler/test_mono/generated/ir_when_record.txt @@ -0,0 +1,6 @@ +procedure Test.0 (): + let Test.4 = 1i64; + let Test.5 = 3.14f64; + let Test.2 = Struct {Test.4, Test.5}; + let Test.1 = Index 0 Test.2; + ret Test.1; diff --git a/compiler/test_mono/generated/ir_when_these.txt b/compiler/test_mono/generated/ir_when_these.txt new file mode 100644 index 0000000000..fb786616f8 --- /dev/null +++ b/compiler/test_mono/generated/ir_when_these.txt @@ -0,0 +1,19 @@ +procedure Test.0 (): + let Test.12 = 1i64; + let Test.10 = 1i64; + let Test.11 = 2i64; + let Test.5 = These Test.12 Test.10 Test.11; + let Test.9 = Index 0 Test.5; + switch Test.9: + case 2: + let Test.2 = Index 1 Test.5; + ret Test.2; + + case 0: + let Test.3 = Index 1 Test.5; + ret Test.3; + + default: + let Test.4 = Index 1 Test.5; + ret Test.4; + diff --git a/compiler/test_mono/generated/is_nil.txt b/compiler/test_mono/generated/is_nil.txt new file mode 100644 index 0000000000..4ad61c36e4 --- /dev/null +++ b/compiler/test_mono/generated/is_nil.txt @@ -0,0 +1,20 @@ +procedure Test.2 (Test.3): + let Test.12 = 1i64; + let Test.13 = Index 0 Test.3; + let Test.14 = lowlevel Eq Test.12 Test.13; + if Test.14 then + let Test.10 = true; + ret Test.10; + else + let Test.11 = false; + ret Test.11; + +procedure Test.0 (): + let Test.17 = 0i64; + let Test.15 = 2i64; + let Test.18 = 1i64; + let Test.16 = Nil Test.18; + let Test.9 = Cons Test.17 Test.15 Test.16; + let Test.8 = CallByName Test.2 Test.9; + dec Test.9; + ret Test.8; diff --git a/compiler/test_mono/generated/let_with_record_pattern.txt b/compiler/test_mono/generated/let_with_record_pattern.txt new file mode 100644 index 0000000000..3f9ec7dbbd --- /dev/null +++ b/compiler/test_mono/generated/let_with_record_pattern.txt @@ -0,0 +1,6 @@ +procedure Test.0 (): + let Test.4 = 2i64; + let Test.5 = 3.14f64; + let Test.3 = Struct {Test.4, Test.5}; + let Test.1 = Index 0 Test.3; + ret Test.1; diff --git a/compiler/test_mono/generated/let_with_record_pattern_list.txt b/compiler/test_mono/generated/let_with_record_pattern_list.txt new file mode 100644 index 0000000000..d7763fed7c --- /dev/null +++ b/compiler/test_mono/generated/let_with_record_pattern_list.txt @@ -0,0 +1,10 @@ +procedure Test.0 (): + let Test.6 = 1i64; + let Test.7 = 3i64; + let Test.8 = 4i64; + let Test.4 = Array [Test.6, Test.7, Test.8]; + let Test.5 = 3.14f64; + let Test.3 = Struct {Test.4, Test.5}; + let Test.1 = Index 0 Test.3; + decref Test.3; + ret Test.1; diff --git a/compiler/test_mono/generated/let_x_in_x.txt b/compiler/test_mono/generated/let_x_in_x.txt new file mode 100644 index 0000000000..567439fa80 --- /dev/null +++ b/compiler/test_mono/generated/let_x_in_x.txt @@ -0,0 +1,5 @@ +procedure Test.0 (): + let Test.1 = 5i64; + let Test.4 = 17i64; + let Test.2 = 1337i64; + ret Test.2; diff --git a/compiler/test_mono/generated/let_x_in_x_indirect.txt b/compiler/test_mono/generated/let_x_in_x_indirect.txt new file mode 100644 index 0000000000..0d3a1b4693 --- /dev/null +++ b/compiler/test_mono/generated/let_x_in_x_indirect.txt @@ -0,0 +1,8 @@ +procedure Test.0 (): + let Test.1 = 5i64; + let Test.4 = 17i64; + let Test.5 = 1i64; + let Test.2 = 1337i64; + let Test.7 = Struct {Test.2, Test.4}; + let Test.6 = Index 0 Test.7; + ret Test.6; diff --git a/compiler/test_mono/generated/linked_list_length_twice.txt b/compiler/test_mono/generated/linked_list_length_twice.txt new file mode 100644 index 0000000000..1e3ac67351 --- /dev/null +++ b/compiler/test_mono/generated/linked_list_length_twice.txt @@ -0,0 +1,26 @@ +procedure Num.24 (#Attr.2, #Attr.3): + let Test.10 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Test.10; + +procedure Test.3 (Test.5): + let Test.16 = 1i64; + let Test.17 = Index 0 Test.5; + let Test.18 = lowlevel Eq Test.16 Test.17; + if Test.18 then + let Test.12 = 0i64; + ret Test.12; + else + let Test.6 = Index 2 Test.5; + let Test.14 = 1i64; + let Test.15 = CallByName Test.3 Test.6; + let Test.13 = CallByName Num.24 Test.14 Test.15; + ret Test.13; + +procedure Test.0 (): + let Test.19 = 1i64; + let Test.2 = Nil Test.19; + let Test.8 = CallByName Test.3 Test.2; + let Test.9 = CallByName Test.3 Test.2; + dec Test.2; + let Test.7 = CallByName Num.24 Test.8 Test.9; + ret Test.7; diff --git a/compiler/test_mono/generated/list_append.txt b/compiler/test_mono/generated/list_append.txt new file mode 100644 index 0000000000..49c502afd3 --- /dev/null +++ b/compiler/test_mono/generated/list_append.txt @@ -0,0 +1,10 @@ +procedure List.5 (#Attr.2, #Attr.3): + let Test.4 = lowlevel ListAppend #Attr.2 #Attr.3; + ret Test.4; + +procedure Test.0 (): + let Test.5 = 1i64; + let Test.2 = Array [Test.5]; + let Test.3 = 2i64; + let Test.1 = CallByName List.5 Test.2 Test.3; + ret Test.1; diff --git a/compiler/test_mono/generated/list_append_closure.txt b/compiler/test_mono/generated/list_append_closure.txt new file mode 100644 index 0000000000..cd33ef5754 --- /dev/null +++ b/compiler/test_mono/generated/list_append_closure.txt @@ -0,0 +1,15 @@ +procedure List.5 (#Attr.2, #Attr.3): + let Test.7 = lowlevel ListAppend #Attr.2 #Attr.3; + ret Test.7; + +procedure Test.1 (Test.2): + let Test.6 = 42i64; + let Test.5 = CallByName List.5 Test.2 Test.6; + ret Test.5; + +procedure Test.0 (): + let Test.8 = 1i64; + let Test.9 = 2i64; + let Test.4 = Array [Test.8, Test.9]; + let Test.3 = CallByName Test.1 Test.4; + ret Test.3; diff --git a/compiler/test_mono/generated/list_cannot_update_inplace.txt b/compiler/test_mono/generated/list_cannot_update_inplace.txt new file mode 100644 index 0000000000..0a29c418b8 --- /dev/null +++ b/compiler/test_mono/generated/list_cannot_update_inplace.txt @@ -0,0 +1,40 @@ +procedure List.4 (#Attr.2, #Attr.3, #Attr.4): + let Test.22 = lowlevel ListLen #Attr.2; + let Test.20 = lowlevel NumLt #Attr.3 Test.22; + if Test.20 then + let Test.21 = lowlevel ListSet #Attr.2 #Attr.3 #Attr.4; + ret Test.21; + else + ret #Attr.2; + +procedure List.7 (#Attr.2): + let Test.9 = lowlevel ListLen #Attr.2; + ret Test.9; + +procedure Num.24 (#Attr.2, #Attr.3): + let Test.7 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Test.7; + +procedure Test.1 (): + let Test.11 = 1i64; + let Test.12 = 2i64; + let Test.13 = 3i64; + let Test.10 = Array [Test.11, Test.12, Test.13]; + ret Test.10; + +procedure Test.2 (Test.3): + let Test.17 = 0i64; + let Test.18 = 0i64; + let Test.16 = CallByName List.4 Test.3 Test.17 Test.18; + ret Test.16; + +procedure Test.0 (): + let Test.15 = CallByName Test.1; + let Test.14 = CallByName Test.2 Test.15; + let Test.5 = CallByName List.7 Test.14; + dec Test.14; + let Test.8 = CallByName Test.1; + let Test.6 = CallByName List.7 Test.8; + dec Test.8; + let Test.4 = CallByName Num.24 Test.5 Test.6; + ret Test.4; diff --git a/compiler/test_mono/generated/list_get.txt b/compiler/test_mono/generated/list_get.txt new file mode 100644 index 0000000000..cf3b7ad448 --- /dev/null +++ b/compiler/test_mono/generated/list_get.txt @@ -0,0 +1,28 @@ +procedure List.3 (#Attr.2, #Attr.3): + let Test.15 = lowlevel ListLen #Attr.2; + let Test.11 = lowlevel NumLt #Attr.3 Test.15; + if Test.11 then + let Test.14 = 1i64; + let Test.13 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + let Test.12 = Ok Test.14 Test.13; + ret Test.12; + else + let Test.10 = 0i64; + let Test.9 = Struct {}; + let Test.8 = Err Test.10 Test.9; + ret Test.8; + +procedure Test.1 (Test.2): + let Test.16 = 1i64; + let Test.17 = 2i64; + let Test.18 = 3i64; + let Test.6 = Array [Test.16, Test.17, Test.18]; + let Test.7 = 0i64; + let Test.5 = CallByName List.3 Test.6 Test.7; + dec Test.6; + ret Test.5; + +procedure Test.0 (): + let Test.4 = Struct {}; + let Test.3 = CallByName Test.1 Test.4; + ret Test.3; diff --git a/compiler/test_mono/generated/list_len.txt b/compiler/test_mono/generated/list_len.txt new file mode 100644 index 0000000000..d5cd03a2b9 --- /dev/null +++ b/compiler/test_mono/generated/list_len.txt @@ -0,0 +1,25 @@ +procedure List.7 (#Attr.2): + let Test.7 = lowlevel ListLen #Attr.2; + ret Test.7; + +procedure List.7 (#Attr.2): + let Test.8 = lowlevel ListLen #Attr.2; + ret Test.8; + +procedure Num.24 (#Attr.2, #Attr.3): + let Test.6 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Test.6; + +procedure Test.0 (): + let Test.10 = 1i64; + let Test.11 = 2i64; + let Test.12 = 3i64; + let Test.1 = Array [Test.10, Test.11, Test.12]; + let Test.9 = 1f64; + let Test.2 = Array [Test.9]; + let Test.4 = CallByName List.7 Test.1; + dec Test.1; + let Test.5 = CallByName List.7 Test.2; + dec Test.2; + let Test.3 = CallByName Num.24 Test.4 Test.5; + ret Test.3; diff --git a/compiler/test_mono/generated/list_pass_to_function.txt b/compiler/test_mono/generated/list_pass_to_function.txt new file mode 100644 index 0000000000..b33881bde8 --- /dev/null +++ b/compiler/test_mono/generated/list_pass_to_function.txt @@ -0,0 +1,22 @@ +procedure List.4 (#Attr.2, #Attr.3, #Attr.4): + let Test.11 = lowlevel ListLen #Attr.2; + let Test.9 = lowlevel NumLt #Attr.3 Test.11; + if Test.9 then + let Test.10 = lowlevel ListSet #Attr.2 #Attr.3 #Attr.4; + ret Test.10; + else + ret #Attr.2; + +procedure Test.2 (Test.3): + let Test.6 = 0i64; + let Test.7 = 0i64; + let Test.5 = CallByName List.4 Test.3 Test.6 Test.7; + ret Test.5; + +procedure Test.0 (): + let Test.12 = 1i64; + let Test.13 = 2i64; + let Test.14 = 3i64; + let Test.1 = Array [Test.12, Test.13, Test.14]; + let Test.4 = CallByName Test.2 Test.1; + ret Test.4; diff --git a/compiler/test_mono/generated/mk_pair_of.txt b/compiler/test_mono/generated/mk_pair_of.txt new file mode 100644 index 0000000000..ae4932f71a --- /dev/null +++ b/compiler/test_mono/generated/mk_pair_of.txt @@ -0,0 +1,12 @@ +procedure Test.1 (Test.2): + inc Test.2; + let Test.6 = Struct {Test.2, Test.2}; + ret Test.6; + +procedure Test.0 (): + let Test.7 = 1i64; + let Test.8 = 2i64; + let Test.9 = 3i64; + let Test.5 = Array [Test.7, Test.8, Test.9]; + let Test.4 = CallByName Test.1 Test.5; + ret Test.4; diff --git a/compiler/test_mono/generated/nested_closure.txt b/compiler/test_mono/generated/nested_closure.txt new file mode 100644 index 0000000000..bd29b87a8b --- /dev/null +++ b/compiler/test_mono/generated/nested_closure.txt @@ -0,0 +1,15 @@ +procedure Test.1 (Test.5): + let Test.2 = 42i64; + let Test.3 = Struct {Test.2}; + ret Test.3; + +procedure Test.3 (Test.9, #Attr.12): + let Test.2 = Index 0 #Attr.12; + ret Test.2; + +procedure Test.0 (): + let Test.8 = Struct {}; + let Test.4 = CallByName Test.1 Test.8; + let Test.7 = Struct {}; + let Test.6 = CallByName Test.3 Test.7 Test.4; + ret Test.6; diff --git a/compiler/test_mono/generated/nested_pattern_match.txt b/compiler/test_mono/generated/nested_pattern_match.txt new file mode 100644 index 0000000000..a178a68f6d --- /dev/null +++ b/compiler/test_mono/generated/nested_pattern_match.txt @@ -0,0 +1,32 @@ +procedure Num.24 (#Attr.2, #Attr.3): + let Test.8 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Test.8; + +procedure Test.0 (): + let Test.20 = 0i64; + let Test.22 = 0i64; + let Test.21 = 41i64; + let Test.19 = Just Test.22 Test.21; + let Test.2 = Just Test.20 Test.19; + joinpoint Test.16: + let Test.10 = 1i64; + ret Test.10; + in + let Test.14 = 0i64; + let Test.15 = Index 0 Test.2; + let Test.18 = lowlevel Eq Test.14 Test.15; + if Test.18 then + let Test.11 = Index 1 Test.2; + let Test.12 = 0i64; + let Test.13 = Index 0 Test.11; + let Test.17 = lowlevel Eq Test.12 Test.13; + if Test.17 then + let Test.9 = Index 1 Test.2; + let Test.5 = Index 1 Test.9; + let Test.7 = 1i64; + let Test.6 = CallByName Num.24 Test.5 Test.7; + ret Test.6; + else + jump Test.16; + else + jump Test.16; diff --git a/compiler/test_mono/generated/one_element_tag.txt b/compiler/test_mono/generated/one_element_tag.txt new file mode 100644 index 0000000000..4ecfe61168 --- /dev/null +++ b/compiler/test_mono/generated/one_element_tag.txt @@ -0,0 +1,3 @@ +procedure Test.0 (): + let Test.4 = 2i64; + ret Test.4; diff --git a/compiler/test_mono/generated/optional_when.txt b/compiler/test_mono/generated/optional_when.txt new file mode 100644 index 0000000000..c5299d68ae --- /dev/null +++ b/compiler/test_mono/generated/optional_when.txt @@ -0,0 +1,43 @@ +procedure Num.26 (#Attr.2, #Attr.3): + let Test.17 = lowlevel NumMul #Attr.2 #Attr.3; + ret Test.17; + +procedure Test.1 (Test.6): + let Test.22 = Index 1 Test.6; + let Test.23 = false; + let Test.24 = lowlevel Eq Test.23 Test.22; + if Test.24 then + let Test.8 = Index 0 Test.6; + ret Test.8; + else + let Test.10 = Index 0 Test.6; + ret Test.10; + +procedure Test.1 (Test.6): + let Test.33 = Index 0 Test.6; + let Test.34 = false; + let Test.35 = lowlevel Eq Test.34 Test.33; + if Test.35 then + let Test.8 = 3i64; + ret Test.8; + else + let Test.10 = 5i64; + ret Test.10; + +procedure Test.0 (): + let Test.38 = true; + let Test.5 = CallByName Test.1 Test.38; + let Test.36 = false; + let Test.3 = CallByName Test.1 Test.36; + let Test.28 = 11i64; + let Test.29 = true; + let Test.27 = Struct {Test.28, Test.29}; + let Test.4 = CallByName Test.1 Test.27; + let Test.25 = 7i64; + let Test.26 = false; + let Test.19 = Struct {Test.25, Test.26}; + let Test.2 = CallByName Test.1 Test.19; + let Test.18 = CallByName Num.26 Test.2 Test.3; + let Test.16 = CallByName Num.26 Test.18 Test.4; + let Test.15 = CallByName Num.26 Test.16 Test.5; + ret Test.15; diff --git a/compiler/test_mono/generated/peano.txt b/compiler/test_mono/generated/peano.txt new file mode 100644 index 0000000000..2bd2ae3dc9 --- /dev/null +++ b/compiler/test_mono/generated/peano.txt @@ -0,0 +1,10 @@ +procedure Test.0 (): + let Test.9 = 0i64; + let Test.11 = 0i64; + let Test.13 = 0i64; + let Test.14 = 1i64; + let Test.12 = Z Test.14; + let Test.10 = S Test.13 Test.12; + let Test.8 = S Test.11 Test.10; + let Test.2 = S Test.9 Test.8; + ret Test.2; diff --git a/compiler/test_mono/generated/peano1.txt b/compiler/test_mono/generated/peano1.txt new file mode 100644 index 0000000000..396677f771 --- /dev/null +++ b/compiler/test_mono/generated/peano1.txt @@ -0,0 +1,19 @@ +procedure Test.0 (): + let Test.13 = 0i64; + let Test.15 = 0i64; + let Test.17 = 0i64; + let Test.18 = 1i64; + let Test.16 = Z Test.18; + let Test.14 = S Test.17 Test.16; + let Test.12 = S Test.15 Test.14; + let Test.2 = S Test.13 Test.12; + let Test.9 = 1i64; + let Test.10 = Index 0 Test.2; + dec Test.2; + let Test.11 = lowlevel Eq Test.9 Test.10; + if Test.11 then + let Test.7 = 0i64; + ret Test.7; + else + let Test.8 = 1i64; + ret Test.8; diff --git a/compiler/test_mono/generated/peano2.txt b/compiler/test_mono/generated/peano2.txt new file mode 100644 index 0000000000..65764f2fe8 --- /dev/null +++ b/compiler/test_mono/generated/peano2.txt @@ -0,0 +1,28 @@ +procedure Test.0 (): + let Test.19 = 0i64; + let Test.21 = 0i64; + let Test.23 = 0i64; + let Test.24 = 1i64; + let Test.22 = Z Test.24; + let Test.20 = S Test.23 Test.22; + let Test.18 = S Test.21 Test.20; + let Test.2 = S Test.19 Test.18; + let Test.15 = 0i64; + let Test.16 = Index 0 Test.2; + let Test.17 = lowlevel Eq Test.15 Test.16; + if Test.17 then + let Test.11 = Index 1 Test.2; + let Test.12 = 0i64; + let Test.13 = Index 0 Test.11; + dec Test.11; + decref Test.2; + let Test.14 = lowlevel Eq Test.12 Test.13; + if Test.14 then + let Test.7 = 1i64; + ret Test.7; + else + let Test.9 = 0i64; + ret Test.9; + else + let Test.10 = 0i64; + ret Test.10; diff --git a/compiler/test_mono/generated/quicksort_help.txt b/compiler/test_mono/generated/quicksort_help.txt new file mode 100644 index 0000000000..25ed80e403 --- /dev/null +++ b/compiler/test_mono/generated/quicksort_help.txt @@ -0,0 +1,41 @@ +procedure Num.24 (#Attr.2, #Attr.3): + let Test.19 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Test.19; + +procedure Num.25 (#Attr.2, #Attr.3): + let Test.22 = lowlevel NumSub #Attr.2 #Attr.3; + ret Test.22; + +procedure Num.27 (#Attr.2, #Attr.3): + let Test.26 = lowlevel NumLt #Attr.2 #Attr.3; + ret Test.26; + +procedure Test.1 (Test.2, Test.3, Test.4): + joinpoint Test.12 Test.2 Test.3 Test.4: + let Test.14 = CallByName Num.27 Test.3 Test.4; + if Test.14 then + dec Test.2; + let Test.25 = Array []; + let Test.24 = 0i64; + let Test.23 = Struct {Test.24, Test.25}; + let Test.5 = Index 0 Test.23; + let Test.6 = Index 1 Test.23; + let Test.21 = 1i64; + let Test.20 = CallByName Num.25 Test.5 Test.21; + let Test.16 = CallByName Test.1 Test.6 Test.3 Test.20; + let Test.18 = 1i64; + invoke Test.17 = CallByName Num.24 Test.5 Test.18 catch + dec Test.16; + unreachable; + jump Test.12 Test.16 Test.17 Test.4; + else + ret Test.2; + in + jump Test.12 Test.2 Test.3 Test.4; + +procedure Test.0 (): + let Test.9 = Array []; + let Test.10 = 0i64; + let Test.11 = 0i64; + let Test.8 = CallByName Test.1 Test.9 Test.10 Test.11; + ret Test.8; diff --git a/compiler/test_mono/generated/quicksort_swap.txt b/compiler/test_mono/generated/quicksort_swap.txt new file mode 100644 index 0000000000..04a3a7f525 --- /dev/null +++ b/compiler/test_mono/generated/quicksort_swap.txt @@ -0,0 +1,65 @@ +procedure List.3 (#Attr.2, #Attr.3): + let Test.39 = lowlevel ListLen #Attr.2; + let Test.35 = lowlevel NumLt #Attr.3 Test.39; + if Test.35 then + let Test.38 = 1i64; + let Test.37 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + let Test.36 = Ok Test.38 Test.37; + ret Test.36; + else + let Test.34 = 0i64; + let Test.33 = Struct {}; + let Test.32 = Err Test.34 Test.33; + ret Test.32; + +procedure List.4 (#Attr.2, #Attr.3, #Attr.4): + let Test.15 = lowlevel ListLen #Attr.2; + let Test.13 = lowlevel NumLt #Attr.3 Test.15; + if Test.13 then + let Test.14 = lowlevel ListSet #Attr.2 #Attr.3 #Attr.4; + ret Test.14; + else + ret #Attr.2; + +procedure Test.1 (Test.2): + let Test.40 = 0i64; + let Test.30 = CallByName List.3 Test.2 Test.40; + let Test.31 = 0i64; + let Test.29 = CallByName List.3 Test.2 Test.31; + let Test.8 = Struct {Test.29, Test.30}; + joinpoint Test.26: + let Test.19 = Array []; + ret Test.19; + in + let Test.23 = Index 1 Test.8; + let Test.24 = 1i64; + let Test.25 = Index 0 Test.23; + let Test.28 = lowlevel Eq Test.24 Test.25; + if Test.28 then + let Test.20 = Index 0 Test.8; + let Test.21 = 1i64; + let Test.22 = Index 0 Test.20; + let Test.27 = lowlevel Eq Test.21 Test.22; + if Test.27 then + let Test.18 = Index 0 Test.8; + let Test.4 = Index 1 Test.18; + let Test.17 = Index 1 Test.8; + let Test.5 = Index 1 Test.17; + let Test.16 = 0i64; + let Test.10 = CallByName List.4 Test.2 Test.16 Test.5; + let Test.11 = 0i64; + let Test.9 = CallByName List.4 Test.10 Test.11 Test.4; + ret Test.9; + else + dec Test.2; + jump Test.26; + else + dec Test.2; + jump Test.26; + +procedure Test.0 (): + let Test.41 = 1i64; + let Test.42 = 2i64; + let Test.7 = Array [Test.41, Test.42]; + let Test.6 = CallByName Test.1 Test.7; + ret Test.6; diff --git a/compiler/test_mono/generated/record_optional_field_function_no_use_default.txt b/compiler/test_mono/generated/record_optional_field_function_no_use_default.txt new file mode 100644 index 0000000000..4155eda65d --- /dev/null +++ b/compiler/test_mono/generated/record_optional_field_function_no_use_default.txt @@ -0,0 +1,17 @@ +procedure Num.24 (#Attr.2, #Attr.3): + let Test.8 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Test.8; + +procedure Test.1 (Test.4): + let Test.2 = Index 0 Test.4; + let Test.3 = Index 1 Test.4; + let Test.2 = 10i64; + let Test.7 = CallByName Num.24 Test.2 Test.3; + ret Test.7; + +procedure Test.0 (): + let Test.9 = 4i64; + let Test.10 = 9i64; + let Test.6 = Struct {Test.9, Test.10}; + let Test.5 = CallByName Test.1 Test.6; + ret Test.5; diff --git a/compiler/test_mono/generated/record_optional_field_function_use_default.txt b/compiler/test_mono/generated/record_optional_field_function_use_default.txt new file mode 100644 index 0000000000..2f2f6165db --- /dev/null +++ b/compiler/test_mono/generated/record_optional_field_function_use_default.txt @@ -0,0 +1,15 @@ +procedure Num.24 (#Attr.2, #Attr.3): + let Test.8 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Test.8; + +procedure Test.1 (Test.4): + let Test.3 = Index 0 Test.4; + let Test.2 = 10i64; + let Test.2 = 10i64; + let Test.7 = CallByName Num.24 Test.2 Test.3; + ret Test.7; + +procedure Test.0 (): + let Test.9 = 9i64; + let Test.5 = CallByName Test.1 Test.9; + ret Test.5; diff --git a/compiler/test_mono/generated/record_optional_field_let_no_use_default.txt b/compiler/test_mono/generated/record_optional_field_let_no_use_default.txt new file mode 100644 index 0000000000..d5aeb80f15 --- /dev/null +++ b/compiler/test_mono/generated/record_optional_field_let_no_use_default.txt @@ -0,0 +1,16 @@ +procedure Num.24 (#Attr.2, #Attr.3): + let Test.8 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Test.8; + +procedure Test.1 (Test.2): + let Test.3 = Index 0 Test.2; + let Test.4 = Index 1 Test.2; + let Test.7 = CallByName Num.24 Test.3 Test.4; + ret Test.7; + +procedure Test.0 (): + let Test.9 = 4i64; + let Test.10 = 9i64; + let Test.6 = Struct {Test.9, Test.10}; + let Test.5 = CallByName Test.1 Test.6; + ret Test.5; diff --git a/compiler/test_mono/generated/record_optional_field_let_use_default.txt b/compiler/test_mono/generated/record_optional_field_let_use_default.txt new file mode 100644 index 0000000000..a96cc2dfce --- /dev/null +++ b/compiler/test_mono/generated/record_optional_field_let_use_default.txt @@ -0,0 +1,14 @@ +procedure Num.24 (#Attr.2, #Attr.3): + let Test.8 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Test.8; + +procedure Test.1 (Test.2): + let Test.4 = Index 0 Test.2; + let Test.3 = 10i64; + let Test.7 = CallByName Num.24 Test.3 Test.4; + ret Test.7; + +procedure Test.0 (): + let Test.9 = 9i64; + let Test.5 = CallByName Test.1 Test.9; + ret Test.5; diff --git a/compiler/test_mono/generated/rigids.txt b/compiler/test_mono/generated/rigids.txt new file mode 100644 index 0000000000..ac46059d9f --- /dev/null +++ b/compiler/test_mono/generated/rigids.txt @@ -0,0 +1,62 @@ +procedure List.3 (#Attr.2, #Attr.3): + let Test.41 = lowlevel ListLen #Attr.2; + let Test.37 = lowlevel NumLt #Attr.3 Test.41; + if Test.37 then + let Test.40 = 1i64; + let Test.39 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + let Test.38 = Ok Test.40 Test.39; + ret Test.38; + else + let Test.36 = 0i64; + let Test.35 = Struct {}; + let Test.34 = Err Test.36 Test.35; + ret Test.34; + +procedure List.4 (#Attr.2, #Attr.3, #Attr.4): + let Test.19 = lowlevel ListLen #Attr.2; + let Test.17 = lowlevel NumLt #Attr.3 Test.19; + if Test.17 then + let Test.18 = lowlevel ListSet #Attr.2 #Attr.3 #Attr.4; + ret Test.18; + else + ret #Attr.2; + +procedure Test.1 (Test.2, Test.3, Test.4): + let Test.33 = CallByName List.3 Test.4 Test.3; + let Test.32 = CallByName List.3 Test.4 Test.2; + let Test.13 = Struct {Test.32, Test.33}; + joinpoint Test.29: + let Test.22 = Array []; + ret Test.22; + in + let Test.26 = Index 1 Test.13; + let Test.27 = 1i64; + let Test.28 = Index 0 Test.26; + let Test.31 = lowlevel Eq Test.27 Test.28; + if Test.31 then + let Test.23 = Index 0 Test.13; + let Test.24 = 1i64; + let Test.25 = Index 0 Test.23; + let Test.30 = lowlevel Eq Test.24 Test.25; + if Test.30 then + let Test.21 = Index 0 Test.13; + let Test.6 = Index 1 Test.21; + let Test.20 = Index 1 Test.13; + let Test.7 = Index 1 Test.20; + let Test.15 = CallByName List.4 Test.4 Test.2 Test.7; + let Test.14 = CallByName List.4 Test.15 Test.3 Test.6; + ret Test.14; + else + dec Test.4; + jump Test.29; + else + dec Test.4; + jump Test.29; + +procedure Test.0 (): + let Test.10 = 0i64; + let Test.11 = 0i64; + let Test.42 = 1i64; + let Test.12 = Array [Test.42]; + let Test.9 = CallByName Test.1 Test.10 Test.11 Test.12; + ret Test.9; diff --git a/compiler/test_mono/generated/simple_if.txt b/compiler/test_mono/generated/simple_if.txt new file mode 100644 index 0000000000..f796d9d4f2 --- /dev/null +++ b/compiler/test_mono/generated/simple_if.txt @@ -0,0 +1,8 @@ +procedure Test.0 (): + let Test.3 = true; + if Test.3 then + let Test.4 = 1i64; + ret Test.4; + else + let Test.2 = 2i64; + ret Test.2; diff --git a/compiler/test_mono/generated/somehow_drops_definitions.txt b/compiler/test_mono/generated/somehow_drops_definitions.txt new file mode 100644 index 0000000000..46378c332c --- /dev/null +++ b/compiler/test_mono/generated/somehow_drops_definitions.txt @@ -0,0 +1,53 @@ +procedure Num.24 (#Attr.2, #Attr.3): + let Test.27 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Test.27; + +procedure Num.26 (#Attr.2, #Attr.3): + let Test.22 = lowlevel NumMul #Attr.2 #Attr.3; + ret Test.22; + +procedure Test.1 (): + let Test.28 = 1i64; + ret Test.28; + +procedure Test.2 (): + let Test.23 = 2i64; + ret Test.23; + +procedure Test.3 (Test.6): + let Test.26 = CallByName Test.1; + let Test.25 = CallByName Num.24 Test.6 Test.26; + ret Test.25; + +procedure Test.4 (Test.7): + let Test.21 = CallByName Test.2; + let Test.20 = CallByName Num.26 Test.7 Test.21; + ret Test.20; + +procedure Test.5 (Test.8, Test.9): + joinpoint Test.15 Test.14: + ret Test.14; + in + switch Test.8: + case 0: + let Test.16 = CallByName Test.3 Test.9; + jump Test.15 Test.16; + + default: + let Test.17 = CallByName Test.4 Test.9; + jump Test.15 Test.17; + + +procedure Test.0 (): + joinpoint Test.19 Test.12: + let Test.13 = 42i64; + let Test.11 = CallByName Test.5 Test.12 Test.13; + ret Test.11; + in + let Test.24 = true; + if Test.24 then + let Test.3 = Struct {}; + jump Test.19 Test.3; + else + let Test.4 = Struct {}; + jump Test.19 Test.4; diff --git a/compiler/test_mono/generated/specialize_closures.txt b/compiler/test_mono/generated/specialize_closures.txt new file mode 100644 index 0000000000..72c6e453e3 --- /dev/null +++ b/compiler/test_mono/generated/specialize_closures.txt @@ -0,0 +1,55 @@ +procedure Num.24 (#Attr.2, #Attr.3): + let Test.29 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Test.29; + +procedure Num.26 (#Attr.2, #Attr.3): + let Test.25 = lowlevel NumMul #Attr.2 #Attr.3; + ret Test.25; + +procedure Test.1 (Test.2, Test.3): + let Test.17 = Index 0 Test.2; + joinpoint Test.18 Test.16: + ret Test.16; + in + switch Test.17: + case 0: + let Test.19 = CallByName Test.7 Test.3 Test.2; + jump Test.18 Test.19; + + default: + let Test.20 = CallByName Test.8 Test.3 Test.2; + jump Test.18 Test.20; + + +procedure Test.7 (Test.10, #Attr.12): + let Test.4 = Index 1 #Attr.12; + let Test.28 = CallByName Num.24 Test.10 Test.4; + ret Test.28; + +procedure Test.8 (Test.11, #Attr.12): + let Test.6 = Index 2 #Attr.12; + let Test.5 = Index 1 #Attr.12; + if Test.6 then + let Test.24 = CallByName Num.26 Test.11 Test.5; + ret Test.24; + else + ret Test.11; + +procedure Test.0 (): + let Test.6 = true; + let Test.4 = 1i64; + let Test.5 = 2i64; + joinpoint Test.22 Test.14: + let Test.15 = 42i64; + let Test.13 = CallByName Test.1 Test.14 Test.15; + ret Test.13; + in + let Test.27 = true; + if Test.27 then + let Test.30 = 0i64; + let Test.7 = ClosureTag(Test.7) Test.30 Test.4; + jump Test.22 Test.7; + else + let Test.26 = 1i64; + let Test.8 = ClosureTag(Test.8) Test.26 Test.5 Test.6; + jump Test.22 Test.8; diff --git a/compiler/test_mono/generated/when_joinpoint.txt b/compiler/test_mono/generated/when_joinpoint.txt new file mode 100644 index 0000000000..3277764e1b --- /dev/null +++ b/compiler/test_mono/generated/when_joinpoint.txt @@ -0,0 +1,23 @@ +procedure Test.1 (Test.5): + let Test.2 = 0u8; + joinpoint Test.9 Test.3: + ret Test.3; + in + switch Test.2: + case 1: + let Test.10 = 1i64; + jump Test.9 Test.10; + + case 2: + let Test.11 = 2i64; + jump Test.9 Test.11; + + default: + let Test.12 = 3i64; + jump Test.9 Test.12; + + +procedure Test.0 (): + let Test.7 = Struct {}; + let Test.6 = CallByName Test.1 Test.7; + ret Test.6; diff --git a/compiler/test_mono/generated/when_nested_maybe.txt b/compiler/test_mono/generated/when_nested_maybe.txt new file mode 100644 index 0000000000..a178a68f6d --- /dev/null +++ b/compiler/test_mono/generated/when_nested_maybe.txt @@ -0,0 +1,32 @@ +procedure Num.24 (#Attr.2, #Attr.3): + let Test.8 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Test.8; + +procedure Test.0 (): + let Test.20 = 0i64; + let Test.22 = 0i64; + let Test.21 = 41i64; + let Test.19 = Just Test.22 Test.21; + let Test.2 = Just Test.20 Test.19; + joinpoint Test.16: + let Test.10 = 1i64; + ret Test.10; + in + let Test.14 = 0i64; + let Test.15 = Index 0 Test.2; + let Test.18 = lowlevel Eq Test.14 Test.15; + if Test.18 then + let Test.11 = Index 1 Test.2; + let Test.12 = 0i64; + let Test.13 = Index 0 Test.11; + let Test.17 = lowlevel Eq Test.12 Test.13; + if Test.17 then + let Test.9 = Index 1 Test.2; + let Test.5 = Index 1 Test.9; + let Test.7 = 1i64; + let Test.6 = CallByName Num.24 Test.5 Test.7; + ret Test.6; + else + jump Test.16; + else + jump Test.16; diff --git a/compiler/test_mono/generated/when_on_record.txt b/compiler/test_mono/generated/when_on_record.txt new file mode 100644 index 0000000000..860d4f5c79 --- /dev/null +++ b/compiler/test_mono/generated/when_on_record.txt @@ -0,0 +1,10 @@ +procedure Num.24 (#Attr.2, #Attr.3): + let Test.5 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Test.5; + +procedure Test.0 (): + let Test.6 = 2i64; + let Test.1 = Index 0 Test.6; + let Test.4 = 3i64; + let Test.3 = CallByName Num.24 Test.1 Test.4; + ret Test.3; diff --git a/compiler/test_mono/generated/when_on_result.txt b/compiler/test_mono/generated/when_on_result.txt new file mode 100644 index 0000000000..4fe8f17db8 --- /dev/null +++ b/compiler/test_mono/generated/when_on_result.txt @@ -0,0 +1,28 @@ +procedure Test.1 (Test.5): + let Test.20 = 1i64; + let Test.19 = 2i64; + let Test.2 = Ok Test.20 Test.19; + joinpoint Test.9 Test.3: + ret Test.3; + in + let Test.16 = 1i64; + let Test.17 = Index 0 Test.2; + let Test.18 = lowlevel Eq Test.16 Test.17; + if Test.18 then + let Test.13 = Index 1 Test.2; + let Test.14 = 3i64; + let Test.15 = lowlevel Eq Test.14 Test.13; + if Test.15 then + let Test.10 = 1i64; + jump Test.9 Test.10; + else + let Test.11 = 2i64; + jump Test.9 Test.11; + else + let Test.12 = 3i64; + jump Test.9 Test.12; + +procedure Test.0 (): + let Test.7 = Struct {}; + let Test.6 = CallByName Test.1 Test.7; + ret Test.6; diff --git a/compiler/test_mono/generated/when_on_two_values.txt b/compiler/test_mono/generated/when_on_two_values.txt new file mode 100644 index 0000000000..d1505ab90c --- /dev/null +++ b/compiler/test_mono/generated/when_on_two_values.txt @@ -0,0 +1,28 @@ +procedure Num.24 (#Attr.2, #Attr.3): + let Test.7 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Test.7; + +procedure Test.0 (): + let Test.16 = 3i64; + let Test.15 = 2i64; + let Test.4 = Struct {Test.15, Test.16}; + joinpoint Test.12: + let Test.2 = Index 0 Test.4; + let Test.3 = Index 1 Test.4; + let Test.6 = CallByName Num.24 Test.2 Test.3; + ret Test.6; + in + let Test.10 = Index 1 Test.4; + let Test.11 = 3i64; + let Test.14 = lowlevel Eq Test.11 Test.10; + if Test.14 then + let Test.8 = Index 0 Test.4; + let Test.9 = 4i64; + let Test.13 = lowlevel Eq Test.9 Test.8; + if Test.13 then + let Test.5 = 9i64; + ret Test.5; + else + jump Test.12; + else + jump Test.12; From ef252fb73217a3ddddeedf7b9b9450e900f15461 Mon Sep 17 00:00:00 2001 From: rvcas Date: Tue, 1 Jun 2021 15:40:34 -0400 Subject: [PATCH 065/496] feat: move tests over --- compiler/test_mono/src/lib.rs | 925 ++++++++++++++++++++++++++++++++++ 1 file changed, 925 insertions(+) diff --git a/compiler/test_mono/src/lib.rs b/compiler/test_mono/src/lib.rs index 757d473f06..efe0f54ecb 100644 --- a/compiler/test_mono/src/lib.rs +++ b/compiler/test_mono/src/lib.rs @@ -8,6 +8,14 @@ #[macro_use] extern crate pretty_assertions; +#[macro_use] +extern crate indoc; + +/// Used in the with_larger_debug_stack() function, for tests that otherwise +/// run out of stack space in debug builds (but don't in --release builds) +#[allow(dead_code)] +const EXPANDED_STACK_SIZE: usize = 8 * 1024 * 1024; + use test_mono_macros::*; use roc_can::builtins::builtin_defs_map; @@ -17,6 +25,41 @@ use roc_mono::ir::Proc; use roc_mono::ir::TopLevelFunctionLayout; +/// Without this, some tests pass in `cargo test --release` but fail without +/// the --release flag because they run out of stack space. This increases +/// stack size for debug builds only, while leaving the stack space at the default +/// amount for release builds. +#[allow(dead_code)] +#[cfg(debug_assertions)] +pub fn with_larger_debug_stack(run_test: F) +where + F: FnOnce(), + F: Send, + F: 'static, +{ + std::thread::Builder::new() + .stack_size(EXPANDED_STACK_SIZE) + .spawn(run_test) + .expect("Error while spawning expanded dev stack size thread") + .join() + .expect("Error while joining expanded dev stack size thread") +} + +/// In --release builds, don't increase the stack size. Run the test normally. +/// This way, we find out if any of our tests are blowing the stack even after +/// optimizations in release builds. +#[allow(dead_code)] +#[cfg(not(debug_assertions))] +#[inline(always)] +pub fn with_larger_debug_stack(run_test: F) +where + F: FnOnce() -> (), + F: Send, + F: 'static, +{ + run_test() +} + fn promote_expr_to_module(src: &str) -> String { let mut buffer = String::from("app \"test\" provides [ main ] to \"./platform\"\n\nmain =\n"); @@ -182,3 +225,885 @@ fn ir_int_add() { 5 + 4 + 3 + List.len x "# } + +#[mono_test] +fn ir_assignment() { + r#" + x = 5 + + x + "# +} + +#[mono_test] +fn ir_when_maybe() { + r#" + when Just 3 is + Just n -> n + Nothing -> 0 + "# +} + +#[mono_test] +fn ir_when_these() { + r#" + when These 1 2 is + This x -> x + That y -> y + These x _ -> x + "# +} + +#[mono_test] +fn ir_when_record() { + r#" + when { x: 1, y: 3.14 } is + { x } -> x + "# +} + +#[mono_test] +fn ir_plus() { + r#" + 1 + 2 + "# +} + +#[mono_test] +fn ir_round() { + r#" + Num.round 3.6 + "# +} + +#[mono_test] +fn ir_when_idiv() { + r#" + when 1000 // 10 is + Ok val -> val + Err _ -> -1 + "# +} + +#[mono_test] +fn ir_two_defs() { + r#" + x = 3 + y = 4 + + x + y + "# +} + +#[mono_test] +fn ir_when_just() { + r#" + x : [ Nothing, Just I64 ] + x = Just 41 + + when x is + Just v -> v + 0x1 + Nothing -> 0x1 + "# +} + +#[mono_test] +fn one_element_tag() { + r#" + x : [ Pair I64 ] + x = Pair 2 + + x + "# +} + +#[mono_test] +fn guard_pattern_true() { + r#" + wrapper = \{} -> + when 2 is + 2 if False -> 42 + _ -> 0 + + wrapper {} + "# +} + +#[mono_test] +fn when_on_record() { + r#" + when { x: 0x2 } is + { x } -> x + 3 + "# +} + +#[mono_test] +fn when_nested_maybe() { + r#" + Maybe a : [ Nothing, Just a ] + + x : Maybe (Maybe I64) + x = Just (Just 41) + + when x is + Just (Just v) -> v + 0x1 + _ -> 0x1 + "# +} + +#[mono_test] +fn when_on_two_values() { + r#" + when Pair 2 3 is + Pair 4 3 -> 9 + Pair a b -> a + b + "# +} + +#[mono_test] +fn dict() { + r#" + Dict.len Dict.empty + "# +} + +#[mono_test] +fn list_append_closure() { + r#" + myFunction = \l -> List.append l 42 + + myFunction [ 1, 2 ] + "# +} + +#[mono_test] +fn list_append() { + // TODO this leaks at the moment + // ListAppend needs to decrement its arguments + r#" + List.append [1] 2 + "# +} + +#[mono_test] +fn list_len() { + r#" + x = [1,2,3] + y = [ 1.0 ] + + List.len x + List.len y + "# +} + +#[mono_test] +fn when_joinpoint() { + r#" + wrapper = \{} -> + x : [ Red, White, Blue ] + x = Blue + + y = + when x is + Red -> 1 + White -> 2 + Blue -> 3 + + y + + wrapper {} + "# +} + +#[mono_test] +fn simple_if() { + r#" + if True then + 1 + else + 2 + "# +} + +#[mono_test] +fn if_multi_branch() { + r#" + if True then + 1 + else if False then + 2 + else + 3 + "# +} + +#[mono_test] +fn when_on_result() { + r#" + wrapper = \{} -> + x : Result I64 I64 + x = Ok 2 + + y = + when x is + Ok 3 -> 1 + Ok _ -> 2 + Err _ -> 3 + y + + wrapper {} + "# +} + +#[mono_test] +fn let_with_record_pattern() { + r#" + { x } = { x: 0x2, y: 3.14 } + + x + "# +} + +#[mono_test] +fn let_with_record_pattern_list() { + r#" + { x } = { x: [ 1, 3, 4 ], y: 3.14 } + + x + "# +} + +#[mono_test] +fn if_guard_bind_variable_false() { + r#" + wrapper = \{} -> + when 10 is + x if x == 5 -> 0 + _ -> 42 + + wrapper {} + "# +} + +#[mono_test] +fn alias_variable() { + r#" + x = 5 + y = x + + 3 + "# +} + +#[mono_test] +fn alias_variable_and_return_it() { + r#" + x = 5 + y = x + + y + "# +} + +#[mono_test] +fn branch_store_variable() { + r#" + when 0 is + 1 -> 12 + a -> a + "# +} + +#[mono_test] +fn list_pass_to_function() { + r#" + x : List I64 + x = [1,2,3] + + id : List I64 -> List I64 + id = \y -> List.set y 0 0 + + id x + "# +} + +#[mono_test] +fn record_optional_field_let_no_use_default() { + r#" + f = \r -> + { x ? 10, y } = r + x + y + + + f { x: 4, y: 9 } + "# +} + +#[mono_test] +fn record_optional_field_let_use_default() { + r#" + f = \r -> + { x ? 10, y } = r + x + y + + + f { y: 9 } + "# +} + +#[mono_test] +fn record_optional_field_function_no_use_default() { + r#" + f = \{ x ? 10, y } -> x + y + + + f { x: 4, y: 9 } + "# +} + +#[mono_test] +fn record_optional_field_function_use_default() { + r#" + f = \{ x ? 10, y } -> x + y + + + f { y: 9 } + "# +} + +#[mono_test] +fn quicksort_help() { + // do we still need with_larger_debug_stack? + r#" + quicksortHelp : List (Num a), I64, I64 -> List (Num a) + quicksortHelp = \list, low, high -> + if low < high then + (Pair partitionIndex partitioned) = Pair 0 [] + + partitioned + |> quicksortHelp low (partitionIndex - 1) + |> quicksortHelp (partitionIndex + 1) high + else + list + + quicksortHelp [] 0 0 + "# +} + +#[mono_test] +fn quicksort_swap() { + indoc!( + r#" + app "test" provides [ main ] to "./platform" + + swap = \list -> + when Pair (List.get list 0) (List.get list 0) is + Pair (Ok atI) (Ok atJ) -> + list + |> List.set 0 atJ + |> List.set 0 atI + + _ -> + [] + + main = + swap [ 1, 2 ] + "# + ) +} + +// #[ignore] +// #[mono_test] +// fn quicksort_partition_help() { +// indoc!( +// r#" +// app "test" provides [ main ] to "./platform" + +// partitionHelp : I64, I64, List (Num a), I64, (Num a) -> [ Pair I64 (List (Num a)) ] +// partitionHelp = \i, j, list, high, pivot -> +// if j < high then +// when List.get list j is +// Ok value -> +// if value <= pivot then +// partitionHelp (i + 1) (j + 1) (swap (i + 1) j list) high pivot +// else +// partitionHelp i (j + 1) list high pivot + +// Err _ -> +// Pair i list +// else +// Pair i list + +// main = +// partitionHelp 0 0 [] 0 0 +// "# +// ) +// } + +// #[ignore] +// #[mono_test] +// fn quicksort_full() { +// indoc!( +// r#" +// app "test" provides [ main ] to "./platform" + +// quicksortHelp : List (Num a), I64, I64 -> List (Num a) +// quicksortHelp = \list, low, high -> +// if low < high then +// (Pair partitionIndex partitioned) = partition low high list + +// partitioned +// |> quicksortHelp low (partitionIndex - 1) +// |> quicksortHelp (partitionIndex + 1) high +// else +// list + +// swap : I64, I64, List a -> List a +// swap = \i, j, list -> +// when Pair (List.get list i) (List.get list j) is +// Pair (Ok atI) (Ok atJ) -> +// list +// |> List.set i atJ +// |> List.set j atI + +// _ -> +// [] + +// partition : I64, I64, List (Num a) -> [ Pair I64 (List (Num a)) ] +// partition = \low, high, initialList -> +// when List.get initialList high is +// Ok pivot -> +// when partitionHelp (low - 1) low initialList high pivot is +// Pair newI newList -> +// Pair (newI + 1) (swap (newI + 1) high newList) + +// Err _ -> +// Pair (low - 1) initialList + +// partitionHelp : I64, I64, List (Num a), I64, (Num a) -> [ Pair I64 (List (Num a)) ] +// partitionHelp = \i, j, list, high, pivot -> +// if j < high then +// when List.get list j is +// Ok value -> +// if value <= pivot then +// partitionHelp (i + 1) (j + 1) (swap (i + 1) j list) high pivot +// else +// partitionHelp i (j + 1) list high pivot + +// Err _ -> +// Pair i list +// else +// Pair i list + +// quicksort = \originalList -> +// n = List.len originalList +// quicksortHelp originalList 0 (n - 1) + +// main = +// quicksort [1,2,3] +// "# +// ) +// } + +#[mono_test] +fn factorial() { + r#" + factorial = \n, accum -> + when n is + 0 -> + accum + + _ -> + factorial (n - 1) (n * accum) + + factorial 10 1 + "# +} + +#[mono_test] +fn is_nil() { + r#" + ConsList a : [ Cons a (ConsList a), Nil ] + + isNil : ConsList a -> Bool + isNil = \list -> + when list is + Nil -> True + Cons _ _ -> False + + isNil (Cons 0x2 Nil) + "# +} + +#[mono_test] +#[ignore] +fn has_none() { + r#" + Maybe a : [ Just a, Nothing ] + ConsList a : [ Cons a (ConsList a), Nil ] + + hasNone : ConsList (Maybe a) -> Bool + hasNone = \list -> + when list is + Nil -> False + Cons Nothing _ -> True + Cons (Just _) xs -> hasNone xs + + hasNone (Cons (Just 3) Nil) + "# +} + +#[mono_test] +fn mk_pair_of() { + indoc!( + r#" + app "test" provides [ main ] to "./platform" + + mkPairOf = \x -> Pair x x + + main = + mkPairOf [1,2,3] + "# + ) +} + +#[mono_test] +fn fst() { + indoc!( + r#" + app "test" provides [ main ] to "./platform" + + fst = \x, _ -> x + + main = + fst [1,2,3] [3,2,1] + "# + ) +} + +#[mono_test] +fn list_cannot_update_inplace() { + indoc!( + r#" + app "test" provides [ main ] to "./platform" + + x : List I64 + x = [1,2,3] + + add : List I64 -> List I64 + add = \y -> List.set y 0 0 + + main = + List.len (add x) + List.len x + "# + ) +} + +#[mono_test] +fn list_get() { + r#" + wrapper = \{} -> + List.get [1,2,3] 0 + + wrapper {} + "# +} + +#[mono_test] +fn peano() { + r#" + Peano : [ S Peano, Z ] + + three : Peano + three = S (S (S Z)) + + three + "# +} + +#[mono_test] +fn peano1() { + r#" + Peano : [ S Peano, Z ] + + three : Peano + three = S (S (S Z)) + + when three is + Z -> 0 + S _ -> 1 + "# +} + +#[mono_test] +fn peano2() { + r#" + Peano : [ S Peano, Z ] + + three : Peano + three = S (S (S Z)) + + when three is + S (S _) -> 1 + S (_) -> 0 + Z -> 0 + "# +} + +#[mono_test] +fn optional_when() { + r#" + f = \r -> + when r is + { x: Blue, y ? 3 } -> y + { x: Red, y ? 5 } -> y + + a = f { x: Blue, y: 7 } + b = f { x: Blue } + c = f { x: Red, y: 11 } + d = f { x: Red } + + a * b * c * d + "# +} + +#[mono_test] +fn nested_pattern_match() { + r#" + Maybe a : [ Nothing, Just a ] + + x : Maybe (Maybe I64) + x = Just (Just 41) + + when x is + Just (Just v) -> v + 0x1 + _ -> 0x1 + "# +} + +#[mono_test] +#[ignore] +fn linked_list_length_twice() { + r#" + LinkedList a : [ Nil, Cons a (LinkedList a) ] + + nil : LinkedList I64 + nil = Nil + + length : LinkedList a -> I64 + length = \list -> + when list is + Nil -> 0 + Cons _ rest -> 1 + length rest + + length nil + length nil + "# +} + +#[mono_test] +fn rigids() { + indoc!( + r#" + app "test" provides [ main ] to "./platform" + + swap : Nat, Nat, List a -> List a + swap = \i, j, list -> + when Pair (List.get list i) (List.get list j) is + Pair (Ok atI) (Ok atJ) -> + foo = atJ + + list + |> List.set i foo + |> List.set j atI + + _ -> + [] + + main = + swap 0 0 [0x1] + "# + ) +} + +#[mono_test] +fn let_x_in_x() { + r#" + x = 5 + + answer = + 1337 + + unused = + nested = 17 + nested + + answer + "# +} + +#[mono_test] +fn let_x_in_x_indirect() { + r#" + x = 5 + + answer = + 1337 + + unused = + nested = 17 + + i = 1 + + nested + + { answer, unused }.answer + "# +} + +#[mono_test] +fn nested_closure() { + indoc!( + r#" + app "test" provides [ main ] to "./platform" + + foo = \{} -> + x = 42 + f = \{} -> x + f + + main = + f = foo {} + f {} + "# + ) +} + +#[mono_test] +fn closure_in_list() { + indoc!( + r#" + app "test" provides [ main ] to "./platform" + + foo = \{} -> + x = 41 + + f = \{} -> x + + [ f ] + + main = + items = foo {} + + List.len items + "# + ) +} + +#[ignore] +#[mono_test] +fn somehow_drops_definitions() { + indoc!( + r#" + app "test" provides [ main ] to "./platform" + + one : I64 + one = 1 + + two : I64 + two = 2 + + increment : I64 -> I64 + increment = \x -> x + one + + double : I64 -> I64 + double = \x -> x * two + + apply : (a -> a), a -> a + apply = \f, x -> f x + + main = + apply (if True then increment else double) 42 + "# + ) +} + +#[mono_test] +fn specialize_closures() { + indoc!( + r#" + app "test" provides [ main ] to "./platform" + + + apply : (a -> a), a -> a + apply = \f, x -> f x + + main = + one : I64 + one = 1 + + two : I64 + two = 2 + + b : Bool + b = True + + increment : I64 -> I64 + increment = \x -> x + one + + double : I64 -> I64 + double = \x -> if b then x * two else x + + apply (if True then increment else double) 42 + "# + ) +} + +// ignore doesn't seem to work with the new macro +// #[ignore] +// #[mono_test] +// fn specialize_lowlevel() { +// indoc!( +// r#" +// app "test" provides [ main ] to "./platform" + +// apply : (a -> a), a -> a +// apply = \f, x -> f x + +// main = +// one : I64 +// one = 1 + +// two : I64 +// two = 2 + +// increment : I64 -> I64 +// increment = \x -> x + 1 + +// double : I64 -> I64 +// double = \x -> x * two + +// when 3 is +// 1 -> increment 0 +// 2 -> double 0 +// _ -> List.map [] (if True then increment else double) |> List.len +// "# +// ) +// } + +// #[ignore] +// #[mono_test] +// fn static_str_closure() { +// indoc!( +// r#" +// app "test" provides [ main ] to "./platform" + +// main : Str +// main = +// x = "long string that is malloced" + +// f : {} -> Str +// f = (\_ -> x) + +// f {} +// "# +// ) +// } From 792ff5d5edececff23607787e18ea6453961588b Mon Sep 17 00:00:00 2001 From: rvcas Date: Tue, 1 Jun 2021 15:40:51 -0400 Subject: [PATCH 066/496] feat: delete old mono tests --- compiler/mono/tests/helpers/mod.rs | 41 - compiler/mono/tests/test_mono.rs | 2601 ---------------------------- 2 files changed, 2642 deletions(-) delete mode 100644 compiler/mono/tests/helpers/mod.rs delete mode 100644 compiler/mono/tests/test_mono.rs diff --git a/compiler/mono/tests/helpers/mod.rs b/compiler/mono/tests/helpers/mod.rs deleted file mode 100644 index ef782e17a1..0000000000 --- a/compiler/mono/tests/helpers/mod.rs +++ /dev/null @@ -1,41 +0,0 @@ -extern crate bumpalo; - -/// Used in the with_larger_debug_stack() function, for tests that otherwise -/// run out of stack space in debug builds (but don't in --release builds) -#[allow(dead_code)] -const EXPANDED_STACK_SIZE: usize = 8 * 1024 * 1024; - -/// Without this, some tests pass in `cargo test --release` but fail without -/// the --release flag because they run out of stack space. This increases -/// stack size for debug builds only, while leaving the stack space at the default -/// amount for release builds. -#[allow(dead_code)] -#[cfg(debug_assertions)] -pub fn with_larger_debug_stack(run_test: F) -where - F: FnOnce(), - F: Send, - F: 'static, -{ - std::thread::Builder::new() - .stack_size(EXPANDED_STACK_SIZE) - .spawn(run_test) - .expect("Error while spawning expanded dev stack size thread") - .join() - .expect("Error while joining expanded dev stack size thread") -} - -/// In --release builds, don't increase the stack size. Run the test normally. -/// This way, we find out if any of our tests are blowing the stack even after -/// optimizations in release builds. -#[allow(dead_code)] -#[cfg(not(debug_assertions))] -#[inline(always)] -pub fn with_larger_debug_stack(run_test: F) -where - F: FnOnce() -> (), - F: Send, - F: 'static, -{ - run_test() -} diff --git a/compiler/mono/tests/test_mono.rs b/compiler/mono/tests/test_mono.rs deleted file mode 100644 index 9924474515..0000000000 --- a/compiler/mono/tests/test_mono.rs +++ /dev/null @@ -1,2601 +0,0 @@ -#[macro_use] -extern crate pretty_assertions; - -#[macro_use] -extern crate indoc; - -extern crate bumpalo; -extern crate roc_mono; - -mod helpers; - -// Test monomorphization -#[cfg(test)] -mod test_mono { - use roc_can::builtins::builtin_defs_map; - use roc_collections::all::MutMap; - use roc_module::symbol::Symbol; - use roc_mono::ir::Proc; - - use roc_mono::ir::TopLevelFunctionLayout; - - fn promote_expr_to_module(src: &str) -> String { - let mut buffer = - String::from("app \"test\" provides [ main ] to \"./platform\"\n\nmain =\n"); - - for line in src.lines() { - // indent the body! - buffer.push_str(" "); - buffer.push_str(line); - buffer.push('\n'); - } - - buffer - } - - fn compiles_to_ir(src: &str, expected: &str) { - use bumpalo::Bump; - use std::path::{Path, PathBuf}; - - let arena = &Bump::new(); - - // let stdlib = roc_builtins::unique::uniq_stdlib(); - let stdlib = roc_builtins::std::standard_stdlib(); - let filename = PathBuf::from("Test.roc"); - let src_dir = Path::new("fake/test/path"); - - let module_src; - let temp; - if src.starts_with("app") { - // this is already a module - module_src = src; - } else { - // this is an expression, promote it to a module - temp = promote_expr_to_module(src); - module_src = &temp; - } - - let exposed_types = MutMap::default(); - - let loaded = roc_load::file::load_and_monomorphize_from_str( - arena, - filename, - &module_src, - &stdlib, - src_dir, - exposed_types, - 8, - builtin_defs_map, - ); - - let mut loaded = match loaded { - Ok(x) => x, - Err(roc_load::file::LoadingProblem::FormattedReport(report)) => { - println!("{}", report); - panic!(); - } - Err(e) => panic!("{:?}", e), - }; - - use roc_load::file::MonomorphizedModule; - let MonomorphizedModule { - module_id: home, - procedures, - exposed_to_host, - .. - } = loaded; - - let can_problems = loaded.can_problems.remove(&home).unwrap_or_default(); - let type_problems = loaded.type_problems.remove(&home).unwrap_or_default(); - let mono_problems = loaded.mono_problems.remove(&home).unwrap_or_default(); - - if !can_problems.is_empty() { - println!("Ignoring {} canonicalization problems", can_problems.len()); - } - - assert_eq!(type_problems, Vec::new()); - assert_eq!(mono_problems, Vec::new()); - - debug_assert_eq!(exposed_to_host.len(), 1); - - let main_fn_symbol = exposed_to_host.keys().copied().next().unwrap(); - - verify_procedures(expected, procedures, main_fn_symbol); - } - - #[cfg(debug_assertions)] - fn verify_procedures( - expected: &str, - procedures: MutMap<(Symbol, TopLevelFunctionLayout<'_>), Proc<'_>>, - main_fn_symbol: Symbol, - ) { - let index = procedures - .keys() - .position(|(s, _)| *s == main_fn_symbol) - .unwrap(); - - let mut procs_string = procedures - .values() - .map(|proc| proc.to_pretty(200)) - .collect::>(); - - let main_fn = procs_string.swap_remove(index); - - procs_string.sort(); - procs_string.push(main_fn); - - let result = procs_string.join("\n"); - - let the_same = result == expected; - - if !the_same { - let expected_lines = expected.split('\n').collect::>(); - let result_lines = result.split('\n').collect::>(); - - for line in &result_lines { - if !line.is_empty() { - println!(" {}", line); - } else { - println!(); - } - } - - assert_eq!(expected_lines, result_lines); - assert_eq!(0, 1); - } - } - - // NOTE because the Show instance of module names is different in --release mode, - // these tests would all fail. In the future, when we do interesting optimizations, - // we'll likely want some tests for --release too. - #[cfg(not(debug_assertions))] - fn verify_procedures( - _expected: &str, - _procedures: MutMap<(Symbol, TopLevelFunctionLayout<'_>), Proc<'_>>, - _main_fn_symbol: Symbol, - ) { - // Do nothing - } - - #[test] - fn ir_int_literal() { - compiles_to_ir( - r#" - 5 - "#, - indoc!( - r#" - procedure Test.0 (): - let Test.1 = 5i64; - ret Test.1; - "# - ), - ) - } - - #[test] - fn ir_int_add() { - compiles_to_ir( - r#" - x = [ 1,2 ] - 5 + 4 + 3 + List.len x - "#, - indoc!( - r#" - procedure List.7 (#Attr.2): - let Test.6 = lowlevel ListLen #Attr.2; - ret Test.6; - - procedure Num.24 (#Attr.2, #Attr.3): - let Test.5 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Test.5; - - procedure Test.0 (): - let Test.11 = 1i64; - let Test.12 = 2i64; - let Test.1 = Array [Test.11, Test.12]; - let Test.9 = 5i64; - let Test.10 = 4i64; - invoke Test.7 = CallByName Num.24 Test.9 Test.10 catch - dec Test.1; - unreachable; - let Test.8 = 3i64; - invoke Test.3 = CallByName Num.24 Test.7 Test.8 catch - dec Test.1; - unreachable; - let Test.4 = CallByName List.7 Test.1; - dec Test.1; - let Test.2 = CallByName Num.24 Test.3 Test.4; - ret Test.2; - "# - ), - ) - } - - #[test] - fn ir_assignment() { - compiles_to_ir( - r#" - x = 5 - - x - "#, - indoc!( - r#" - procedure Test.0 (): - let Test.1 = 5i64; - ret Test.1; - "# - ), - ) - } - - #[test] - fn ir_when_maybe() { - compiles_to_ir( - r#" - when Just 3 is - Just n -> n - Nothing -> 0 - "#, - indoc!( - r#" - procedure Test.0 (): - let Test.10 = 0i64; - let Test.9 = 3i64; - let Test.3 = Just Test.10 Test.9; - let Test.6 = 0i64; - let Test.7 = Index 0 Test.3; - let Test.8 = lowlevel Eq Test.6 Test.7; - if Test.8 then - let Test.2 = Index 1 Test.3; - ret Test.2; - else - let Test.5 = 0i64; - ret Test.5; - "# - ), - ) - } - - #[test] - fn ir_when_these() { - compiles_to_ir( - r#" - when These 1 2 is - This x -> x - That y -> y - These x _ -> x - "#, - indoc!( - r#" - procedure Test.0 (): - let Test.12 = 1i64; - let Test.10 = 1i64; - let Test.11 = 2i64; - let Test.5 = These Test.12 Test.10 Test.11; - let Test.9 = Index 0 Test.5; - switch Test.9: - case 2: - let Test.2 = Index 1 Test.5; - ret Test.2; - - case 0: - let Test.3 = Index 1 Test.5; - ret Test.3; - - default: - let Test.4 = Index 1 Test.5; - ret Test.4; - - "# - ), - ) - } - - #[test] - fn ir_when_record() { - compiles_to_ir( - r#" - when { x: 1, y: 3.14 } is - { x } -> x - "#, - indoc!( - r#" - procedure Test.0 (): - let Test.4 = 1i64; - let Test.5 = 3.14f64; - let Test.2 = Struct {Test.4, Test.5}; - let Test.1 = Index 0 Test.2; - ret Test.1; - "# - ), - ) - } - - #[test] - fn ir_plus() { - compiles_to_ir( - r#" - 1 + 2 - "#, - indoc!( - r#" - procedure Num.24 (#Attr.2, #Attr.3): - let Test.4 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Test.4; - - procedure Test.0 (): - let Test.2 = 1i64; - let Test.3 = 2i64; - let Test.1 = CallByName Num.24 Test.2 Test.3; - ret Test.1; - "# - ), - ) - } - - #[test] - fn ir_round() { - compiles_to_ir( - r#" - Num.round 3.6 - "#, - indoc!( - r#" - procedure Num.47 (#Attr.2): - let Test.3 = lowlevel NumRound #Attr.2; - ret Test.3; - - procedure Test.0 (): - let Test.2 = 3.6f64; - let Test.1 = CallByName Num.47 Test.2; - ret Test.1; - "# - ), - ) - } - - #[test] - fn ir_when_idiv() { - compiles_to_ir( - r#" - when 1000 // 10 is - Ok val -> val - Err _ -> -1 - "#, - indoc!( - r#" - procedure Num.42 (#Attr.2, #Attr.3): - let Test.17 = 0i64; - let Test.13 = lowlevel NotEq #Attr.3 Test.17; - if Test.13 then - let Test.16 = 1i64; - let Test.15 = lowlevel NumDivUnchecked #Attr.2 #Attr.3; - let Test.14 = Ok Test.16 Test.15; - ret Test.14; - else - let Test.12 = 0i64; - let Test.11 = Struct {}; - let Test.10 = Err Test.12 Test.11; - ret Test.10; - - procedure Test.0 (): - let Test.8 = 1000i64; - let Test.9 = 10i64; - let Test.2 = CallByName Num.42 Test.8 Test.9; - let Test.5 = 1i64; - let Test.6 = Index 0 Test.2; - let Test.7 = lowlevel Eq Test.5 Test.6; - if Test.7 then - let Test.1 = Index 1 Test.2; - ret Test.1; - else - let Test.4 = -1i64; - ret Test.4; - "# - ), - ) - } - - #[test] - fn ir_two_defs() { - compiles_to_ir( - r#" - x = 3 - y = 4 - - x + y - "#, - indoc!( - r#" - procedure Num.24 (#Attr.2, #Attr.3): - let Test.4 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Test.4; - - procedure Test.0 (): - let Test.1 = 3i64; - let Test.2 = 4i64; - let Test.3 = CallByName Num.24 Test.1 Test.2; - ret Test.3; - "# - ), - ) - } - - #[test] - fn ir_when_just() { - compiles_to_ir( - r#" - x : [ Nothing, Just I64 ] - x = Just 41 - - when x is - Just v -> v + 0x1 - Nothing -> 0x1 - "#, - indoc!( - r#" - procedure Num.24 (#Attr.2, #Attr.3): - let Test.6 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Test.6; - - procedure Test.0 (): - let Test.12 = 0i64; - let Test.11 = 41i64; - let Test.1 = Just Test.12 Test.11; - let Test.8 = 0i64; - let Test.9 = Index 0 Test.1; - let Test.10 = lowlevel Eq Test.8 Test.9; - if Test.10 then - let Test.3 = Index 1 Test.1; - let Test.5 = 1i64; - let Test.4 = CallByName Num.24 Test.3 Test.5; - ret Test.4; - else - let Test.7 = 1i64; - ret Test.7; - "# - ), - ) - } - - #[test] - fn one_element_tag() { - compiles_to_ir( - r#" - x : [ Pair I64 ] - x = Pair 2 - - x - "#, - indoc!( - r#" - procedure Test.0 (): - let Test.4 = 2i64; - ret Test.4; - "# - ), - ) - } - - #[test] - fn guard_pattern_true() { - compiles_to_ir( - r#" - wrapper = \{} -> - when 2 is - 2 if False -> 42 - _ -> 0 - - wrapper {} - "#, - indoc!( - r#" - procedure Test.1 (Test.3): - let Test.6 = 2i64; - joinpoint Test.12: - let Test.10 = 0i64; - ret Test.10; - in - let Test.11 = 2i64; - let Test.14 = lowlevel Eq Test.11 Test.6; - if Test.14 then - joinpoint Test.8 Test.13: - if Test.13 then - let Test.7 = 42i64; - ret Test.7; - else - jump Test.12; - in - let Test.9 = false; - jump Test.8 Test.9; - else - jump Test.12; - - procedure Test.0 (): - let Test.5 = Struct {}; - let Test.4 = CallByName Test.1 Test.5; - ret Test.4; - "# - ), - ) - } - - #[test] - fn when_on_record() { - compiles_to_ir( - r#" - when { x: 0x2 } is - { x } -> x + 3 - "#, - indoc!( - r#" - procedure Num.24 (#Attr.2, #Attr.3): - let Test.5 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Test.5; - - procedure Test.0 (): - let Test.6 = 2i64; - let Test.1 = Index 0 Test.6; - let Test.4 = 3i64; - let Test.3 = CallByName Num.24 Test.1 Test.4; - ret Test.3; - "# - ), - ) - } - - #[test] - fn when_nested_maybe() { - compiles_to_ir( - r#" - Maybe a : [ Nothing, Just a ] - - x : Maybe (Maybe I64) - x = Just (Just 41) - - when x is - Just (Just v) -> v + 0x1 - _ -> 0x1 - "#, - indoc!( - r#" - procedure Num.24 (#Attr.2, #Attr.3): - let Test.8 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Test.8; - - procedure Test.0 (): - let Test.20 = 0i64; - let Test.22 = 0i64; - let Test.21 = 41i64; - let Test.19 = Just Test.22 Test.21; - let Test.2 = Just Test.20 Test.19; - joinpoint Test.16: - let Test.10 = 1i64; - ret Test.10; - in - let Test.14 = 0i64; - let Test.15 = Index 0 Test.2; - let Test.18 = lowlevel Eq Test.14 Test.15; - if Test.18 then - let Test.11 = Index 1 Test.2; - let Test.12 = 0i64; - let Test.13 = Index 0 Test.11; - let Test.17 = lowlevel Eq Test.12 Test.13; - if Test.17 then - let Test.9 = Index 1 Test.2; - let Test.5 = Index 1 Test.9; - let Test.7 = 1i64; - let Test.6 = CallByName Num.24 Test.5 Test.7; - ret Test.6; - else - jump Test.16; - else - jump Test.16; - "# - ), - ) - } - - #[test] - fn when_on_two_values() { - compiles_to_ir( - r#" - when Pair 2 3 is - Pair 4 3 -> 9 - Pair a b -> a + b - "#, - indoc!( - r#" - procedure Num.24 (#Attr.2, #Attr.3): - let Test.7 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Test.7; - - procedure Test.0 (): - let Test.16 = 3i64; - let Test.15 = 2i64; - let Test.4 = Struct {Test.15, Test.16}; - joinpoint Test.12: - let Test.2 = Index 0 Test.4; - let Test.3 = Index 1 Test.4; - let Test.6 = CallByName Num.24 Test.2 Test.3; - ret Test.6; - in - let Test.10 = Index 1 Test.4; - let Test.11 = 3i64; - let Test.14 = lowlevel Eq Test.11 Test.10; - if Test.14 then - let Test.8 = Index 0 Test.4; - let Test.9 = 4i64; - let Test.13 = lowlevel Eq Test.9 Test.8; - if Test.13 then - let Test.5 = 9i64; - ret Test.5; - else - jump Test.12; - else - jump Test.12; - "# - ), - ) - } - - #[test] - fn dict() { - compiles_to_ir( - r#" - Dict.len Dict.empty - "#, - indoc!( - r#" - procedure Dict.2 (): - let Test.4 = lowlevel DictEmpty ; - ret Test.4; - - procedure Dict.8 (#Attr.2): - let Test.3 = lowlevel DictSize #Attr.2; - ret Test.3; - - procedure Test.0 (): - let Test.2 = CallByName Dict.2; - let Test.1 = CallByName Dict.8 Test.2; - ret Test.1; - "# - ), - ) - } - - #[test] - fn list_append_closure() { - compiles_to_ir( - r#" - myFunction = \l -> List.append l 42 - - myFunction [ 1, 2 ] - "#, - indoc!( - r#" - procedure List.5 (#Attr.2, #Attr.3): - let Test.7 = lowlevel ListAppend #Attr.2 #Attr.3; - ret Test.7; - - procedure Test.1 (Test.2): - let Test.6 = 42i64; - let Test.5 = CallByName List.5 Test.2 Test.6; - ret Test.5; - - procedure Test.0 (): - let Test.8 = 1i64; - let Test.9 = 2i64; - let Test.4 = Array [Test.8, Test.9]; - let Test.3 = CallByName Test.1 Test.4; - ret Test.3; - "# - ), - ) - } - - #[test] - fn list_append() { - // TODO this leaks at the moment - // ListAppend needs to decrement its arguments - compiles_to_ir( - r#" - List.append [1] 2 - "#, - indoc!( - r#" - procedure List.5 (#Attr.2, #Attr.3): - let Test.4 = lowlevel ListAppend #Attr.2 #Attr.3; - ret Test.4; - - procedure Test.0 (): - let Test.5 = 1i64; - let Test.2 = Array [Test.5]; - let Test.3 = 2i64; - let Test.1 = CallByName List.5 Test.2 Test.3; - ret Test.1; - "# - ), - ) - } - - #[test] - fn list_len() { - compiles_to_ir( - r#" - x = [1,2,3] - y = [ 1.0 ] - - List.len x + List.len y - "#, - indoc!( - r#" - procedure List.7 (#Attr.2): - let Test.7 = lowlevel ListLen #Attr.2; - ret Test.7; - - procedure List.7 (#Attr.2): - let Test.8 = lowlevel ListLen #Attr.2; - ret Test.8; - - procedure Num.24 (#Attr.2, #Attr.3): - let Test.6 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Test.6; - - procedure Test.0 (): - let Test.10 = 1i64; - let Test.11 = 2i64; - let Test.12 = 3i64; - let Test.1 = Array [Test.10, Test.11, Test.12]; - let Test.9 = 1f64; - let Test.2 = Array [Test.9]; - let Test.4 = CallByName List.7 Test.1; - dec Test.1; - let Test.5 = CallByName List.7 Test.2; - dec Test.2; - let Test.3 = CallByName Num.24 Test.4 Test.5; - ret Test.3; - "# - ), - ) - } - - #[test] - fn when_joinpoint() { - compiles_to_ir( - r#" - wrapper = \{} -> - x : [ Red, White, Blue ] - x = Blue - - y = - when x is - Red -> 1 - White -> 2 - Blue -> 3 - - y - - wrapper {} - "#, - indoc!( - r#" - procedure Test.1 (Test.5): - let Test.2 = 0u8; - joinpoint Test.9 Test.3: - ret Test.3; - in - switch Test.2: - case 1: - let Test.10 = 1i64; - jump Test.9 Test.10; - - case 2: - let Test.11 = 2i64; - jump Test.9 Test.11; - - default: - let Test.12 = 3i64; - jump Test.9 Test.12; - - - procedure Test.0 (): - let Test.7 = Struct {}; - let Test.6 = CallByName Test.1 Test.7; - ret Test.6; - "# - ), - ) - } - - #[test] - fn simple_if() { - compiles_to_ir( - r#" - if True then - 1 - else - 2 - "#, - indoc!( - r#" - procedure Test.0 (): - let Test.3 = true; - if Test.3 then - let Test.4 = 1i64; - ret Test.4; - else - let Test.2 = 2i64; - ret Test.2; - "# - ), - ) - } - - #[test] - fn if_multi_branch() { - compiles_to_ir( - r#" - if True then - 1 - else if False then - 2 - else - 3 - "#, - indoc!( - r#" - procedure Test.0 (): - let Test.6 = true; - if Test.6 then - let Test.7 = 1i64; - ret Test.7; - else - let Test.4 = false; - if Test.4 then - let Test.5 = 2i64; - ret Test.5; - else - let Test.3 = 3i64; - ret Test.3; - "# - ), - ) - } - - #[test] - fn when_on_result() { - compiles_to_ir( - r#" - wrapper = \{} -> - x : Result I64 I64 - x = Ok 2 - - y = - when x is - Ok 3 -> 1 - Ok _ -> 2 - Err _ -> 3 - y - - wrapper {} - "#, - indoc!( - r#" - procedure Test.1 (Test.5): - let Test.20 = 1i64; - let Test.19 = 2i64; - let Test.2 = Ok Test.20 Test.19; - joinpoint Test.9 Test.3: - ret Test.3; - in - let Test.16 = 1i64; - let Test.17 = Index 0 Test.2; - let Test.18 = lowlevel Eq Test.16 Test.17; - if Test.18 then - let Test.13 = Index 1 Test.2; - let Test.14 = 3i64; - let Test.15 = lowlevel Eq Test.14 Test.13; - if Test.15 then - let Test.10 = 1i64; - jump Test.9 Test.10; - else - let Test.11 = 2i64; - jump Test.9 Test.11; - else - let Test.12 = 3i64; - jump Test.9 Test.12; - - procedure Test.0 (): - let Test.7 = Struct {}; - let Test.6 = CallByName Test.1 Test.7; - ret Test.6; - "# - ), - ) - } - - #[test] - fn let_with_record_pattern() { - compiles_to_ir( - r#" - { x } = { x: 0x2, y: 3.14 } - - x - "#, - indoc!( - r#" - procedure Test.0 (): - let Test.4 = 2i64; - let Test.5 = 3.14f64; - let Test.3 = Struct {Test.4, Test.5}; - let Test.1 = Index 0 Test.3; - ret Test.1; - "# - ), - ) - } - - #[test] - fn let_with_record_pattern_list() { - compiles_to_ir( - r#" - { x } = { x: [ 1, 3, 4 ], y: 3.14 } - - x - "#, - indoc!( - r#" - procedure Test.0 (): - let Test.6 = 1i64; - let Test.7 = 3i64; - let Test.8 = 4i64; - let Test.4 = Array [Test.6, Test.7, Test.8]; - let Test.5 = 3.14f64; - let Test.3 = Struct {Test.4, Test.5}; - let Test.1 = Index 0 Test.3; - decref Test.3; - ret Test.1; - "# - ), - ) - } - - #[test] - fn if_guard_bind_variable_false() { - compiles_to_ir( - indoc!( - r#" - wrapper = \{} -> - when 10 is - x if x == 5 -> 0 - _ -> 42 - - wrapper {} - "# - ), - indoc!( - r#" - procedure Bool.5 (#Attr.2, #Attr.3): - let Test.11 = lowlevel Eq #Attr.2 #Attr.3; - ret Test.11; - - procedure Test.1 (Test.3): - let Test.6 = 10i64; - joinpoint Test.8 Test.13: - if Test.13 then - let Test.7 = 0i64; - ret Test.7; - else - let Test.12 = 42i64; - ret Test.12; - in - let Test.10 = 5i64; - let Test.9 = CallByName Bool.5 Test.6 Test.10; - jump Test.8 Test.9; - - procedure Test.0 (): - let Test.5 = Struct {}; - let Test.4 = CallByName Test.1 Test.5; - ret Test.4; - "# - ), - ) - } - - #[test] - fn alias_variable() { - compiles_to_ir( - indoc!( - r#" - x = 5 - y = x - - 3 - "# - ), - indoc!( - r#" - procedure Test.0 (): - let Test.1 = 5i64; - let Test.3 = 3i64; - ret Test.3; - "# - ), - ); - - compiles_to_ir( - indoc!( - r#" - x = 5 - y = x - - y - "# - ), - indoc!( - r#" - procedure Test.0 (): - let Test.1 = 5i64; - ret Test.1; - "# - ), - ) - } - - #[test] - fn branch_store_variable() { - compiles_to_ir( - indoc!( - r#" - when 0 is - 1 -> 12 - a -> a - "# - ), - indoc!( - r#" - procedure Test.0 (): - let Test.2 = 0i64; - let Test.5 = 1i64; - let Test.6 = lowlevel Eq Test.5 Test.2; - if Test.6 then - let Test.3 = 12i64; - ret Test.3; - else - ret Test.2; - "# - ), - ) - } - - #[test] - fn list_pass_to_function() { - compiles_to_ir( - indoc!( - r#" - x : List I64 - x = [1,2,3] - - id : List I64 -> List I64 - id = \y -> List.set y 0 0 - - id x - "# - ), - indoc!( - r#" - procedure List.4 (#Attr.2, #Attr.3, #Attr.4): - let Test.11 = lowlevel ListLen #Attr.2; - let Test.9 = lowlevel NumLt #Attr.3 Test.11; - if Test.9 then - let Test.10 = lowlevel ListSet #Attr.2 #Attr.3 #Attr.4; - ret Test.10; - else - ret #Attr.2; - - procedure Test.2 (Test.3): - let Test.6 = 0i64; - let Test.7 = 0i64; - let Test.5 = CallByName List.4 Test.3 Test.6 Test.7; - ret Test.5; - - procedure Test.0 (): - let Test.12 = 1i64; - let Test.13 = 2i64; - let Test.14 = 3i64; - let Test.1 = Array [Test.12, Test.13, Test.14]; - let Test.4 = CallByName Test.2 Test.1; - ret Test.4; - "# - ), - ) - } - - #[test] - fn record_optional_field_let_no_use_default() { - compiles_to_ir( - indoc!( - r#" - f = \r -> - { x ? 10, y } = r - x + y - - - f { x: 4, y: 9 } - "# - ), - indoc!( - r#" - procedure Num.24 (#Attr.2, #Attr.3): - let Test.8 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Test.8; - - procedure Test.1 (Test.2): - let Test.3 = Index 0 Test.2; - let Test.4 = Index 1 Test.2; - let Test.7 = CallByName Num.24 Test.3 Test.4; - ret Test.7; - - procedure Test.0 (): - let Test.9 = 4i64; - let Test.10 = 9i64; - let Test.6 = Struct {Test.9, Test.10}; - let Test.5 = CallByName Test.1 Test.6; - ret Test.5; - "# - ), - ) - } - - #[test] - fn record_optional_field_let_use_default() { - compiles_to_ir( - indoc!( - r#" - f = \r -> - { x ? 10, y } = r - x + y - - - f { y: 9 } - "# - ), - indoc!( - r#" - procedure Num.24 (#Attr.2, #Attr.3): - let Test.8 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Test.8; - - procedure Test.1 (Test.2): - let Test.4 = Index 0 Test.2; - let Test.3 = 10i64; - let Test.7 = CallByName Num.24 Test.3 Test.4; - ret Test.7; - - procedure Test.0 (): - let Test.9 = 9i64; - let Test.5 = CallByName Test.1 Test.9; - ret Test.5; - "# - ), - ) - } - - #[test] - fn record_optional_field_function_no_use_default() { - compiles_to_ir( - indoc!( - r#" - f = \{ x ? 10, y } -> x + y - - - f { x: 4, y: 9 } - "# - ), - indoc!( - r#" - procedure Num.24 (#Attr.2, #Attr.3): - let Test.8 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Test.8; - - procedure Test.1 (Test.4): - let Test.2 = Index 0 Test.4; - let Test.3 = Index 1 Test.4; - let Test.2 = 10i64; - let Test.7 = CallByName Num.24 Test.2 Test.3; - ret Test.7; - - procedure Test.0 (): - let Test.9 = 4i64; - let Test.10 = 9i64; - let Test.6 = Struct {Test.9, Test.10}; - let Test.5 = CallByName Test.1 Test.6; - ret Test.5; - "# - ), - ) - } - - #[test] - fn record_optional_field_function_use_default() { - compiles_to_ir( - indoc!( - r#" - f = \{ x ? 10, y } -> x + y - - - f { y: 9 } - "# - ), - indoc!( - r#" - procedure Num.24 (#Attr.2, #Attr.3): - let Test.8 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Test.8; - - procedure Test.1 (Test.4): - let Test.3 = Index 0 Test.4; - let Test.2 = 10i64; - let Test.2 = 10i64; - let Test.7 = CallByName Num.24 Test.2 Test.3; - ret Test.7; - - procedure Test.0 (): - let Test.9 = 9i64; - let Test.5 = CallByName Test.1 Test.9; - ret Test.5; - "# - ), - ) - } - - #[ignore] - #[test] - fn quicksort_help() { - crate::helpers::with_larger_debug_stack(|| { - compiles_to_ir( - indoc!( - r#" - quicksortHelp : List (Num a), I64, I64 -> List (Num a) - quicksortHelp = \list, low, high -> - if low < high then - (Pair partitionIndex partitioned) = Pair 0 [] - - partitioned - |> quicksortHelp low (partitionIndex - 1) - |> quicksortHelp (partitionIndex + 1) high - else - list - - quicksortHelp [] 0 0 - "# - ), - indoc!( - r#" - procedure List.3 (#Attr.2, #Attr.3): - let Test.38 = lowlevel ListLen #Attr.2; - let Test.34 = lowlevel NumLt #Attr.3 Test.38; - if Test.34 then - let Test.36 = 1i64; - let Test.37 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; - let Test.35 = Ok Test.36 Test.37; - ret Test.35; - else - let Test.32 = 0i64; - let Test.33 = Struct {}; - let Test.31 = Err Test.32 Test.33; - ret Test.31; - - procedure List.4 (#Attr.2, #Attr.3, #Attr.4): - let Test.14 = lowlevel ListLen #Attr.2; - let Test.12 = lowlevel NumLt #Attr.3 Test.14; - if Test.12 then - let Test.13 = lowlevel ListSet #Attr.2 #Attr.3 #Attr.4; - ret Test.13; - else - ret #Attr.2; - - procedure Test.1 (Test.2): - let Test.39 = 0i64; - let Test.28 = CallByName List.3 Test.2 Test.39; - let Test.30 = 0i64; - let Test.29 = CallByName List.3 Test.2 Test.30; - let Test.7 = Struct {Test.28, Test.29}; - joinpoint Test.25: - let Test.18 = Array []; - ret Test.18; - in - let Test.19 = Index 0 Test.7; - let Test.20 = 1i64; - let Test.21 = Index 0 Test.19; - let Test.27 = lowlevel Eq Test.20 Test.21; - if Test.27 then - let Test.22 = Index 1 Test.7; - let Test.23 = 1i64; - let Test.24 = Index 0 Test.22; - let Test.26 = lowlevel Eq Test.23 Test.24; - if Test.26 then - let Test.17 = Index 0 Test.7; - let Test.3 = Index 1 Test.17; - let Test.16 = Index 1 Test.7; - let Test.4 = Index 1 Test.16; - let Test.15 = 0i64; - let Test.9 = CallByName List.4 Test.2 Test.15 Test.4; - let Test.10 = 0i64; - let Test.8 = CallByName List.4 Test.9 Test.10 Test.3; - ret Test.8; - else - dec Test.2; - jump Test.25; - else - dec Test.2; - jump Test.25; - - procedure Test.0 (): - let Test.40 = 1i64; - let Test.41 = 2i64; - let Test.6 = Array [Test.40, Test.41]; - let Test.5 = CallByName Test.1 Test.6; - ret Test.5; - "# - ), - ) - }) - } - - #[test] - fn quicksort_swap() { - crate::helpers::with_larger_debug_stack(|| { - compiles_to_ir( - indoc!( - r#" - app "test" provides [ main ] to "./platform" - - swap = \list -> - when Pair (List.get list 0) (List.get list 0) is - Pair (Ok atI) (Ok atJ) -> - list - |> List.set 0 atJ - |> List.set 0 atI - - _ -> - [] - - main = - swap [ 1, 2 ] - "# - ), - indoc!( - r#" - procedure List.3 (#Attr.2, #Attr.3): - let Test.39 = lowlevel ListLen #Attr.2; - let Test.35 = lowlevel NumLt #Attr.3 Test.39; - if Test.35 then - let Test.38 = 1i64; - let Test.37 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; - let Test.36 = Ok Test.38 Test.37; - ret Test.36; - else - let Test.34 = 0i64; - let Test.33 = Struct {}; - let Test.32 = Err Test.34 Test.33; - ret Test.32; - - procedure List.4 (#Attr.2, #Attr.3, #Attr.4): - let Test.15 = lowlevel ListLen #Attr.2; - let Test.13 = lowlevel NumLt #Attr.3 Test.15; - if Test.13 then - let Test.14 = lowlevel ListSet #Attr.2 #Attr.3 #Attr.4; - ret Test.14; - else - ret #Attr.2; - - procedure Test.1 (Test.2): - let Test.40 = 0i64; - let Test.30 = CallByName List.3 Test.2 Test.40; - let Test.31 = 0i64; - let Test.29 = CallByName List.3 Test.2 Test.31; - let Test.8 = Struct {Test.29, Test.30}; - joinpoint Test.26: - let Test.19 = Array []; - ret Test.19; - in - let Test.23 = Index 1 Test.8; - let Test.24 = 1i64; - let Test.25 = Index 0 Test.23; - let Test.28 = lowlevel Eq Test.24 Test.25; - if Test.28 then - let Test.20 = Index 0 Test.8; - let Test.21 = 1i64; - let Test.22 = Index 0 Test.20; - let Test.27 = lowlevel Eq Test.21 Test.22; - if Test.27 then - let Test.18 = Index 0 Test.8; - let Test.4 = Index 1 Test.18; - let Test.17 = Index 1 Test.8; - let Test.5 = Index 1 Test.17; - let Test.16 = 0i64; - let Test.10 = CallByName List.4 Test.2 Test.16 Test.5; - let Test.11 = 0i64; - let Test.9 = CallByName List.4 Test.10 Test.11 Test.4; - ret Test.9; - else - dec Test.2; - jump Test.26; - else - dec Test.2; - jump Test.26; - - procedure Test.0 (): - let Test.41 = 1i64; - let Test.42 = 2i64; - let Test.7 = Array [Test.41, Test.42]; - let Test.6 = CallByName Test.1 Test.7; - ret Test.6; - "# - ), - ) - }) - } - - #[ignore] - #[test] - fn quicksort_partition_help() { - crate::helpers::with_larger_debug_stack(|| { - compiles_to_ir( - indoc!( - r#" - app "test" provides [ main ] to "./platform" - - partitionHelp : I64, I64, List (Num a), I64, (Num a) -> [ Pair I64 (List (Num a)) ] - partitionHelp = \i, j, list, high, pivot -> - if j < high then - when List.get list j is - Ok value -> - if value <= pivot then - partitionHelp (i + 1) (j + 1) (swap (i + 1) j list) high pivot - else - partitionHelp i (j + 1) list high pivot - - Err _ -> - Pair i list - else - Pair i list - - main = - partitionHelp 0 0 [] 0 0 - "# - ), - indoc!( - r#" - "# - ), - ) - }) - } - - #[ignore] - #[test] - fn quicksort_full() { - crate::helpers::with_larger_debug_stack(|| { - compiles_to_ir( - indoc!( - r#" - app "test" provides [ main ] to "./platform" - - quicksortHelp : List (Num a), I64, I64 -> List (Num a) - quicksortHelp = \list, low, high -> - if low < high then - (Pair partitionIndex partitioned) = partition low high list - - partitioned - |> quicksortHelp low (partitionIndex - 1) - |> quicksortHelp (partitionIndex + 1) high - else - list - - - swap : I64, I64, List a -> List a - swap = \i, j, list -> - when Pair (List.get list i) (List.get list j) is - Pair (Ok atI) (Ok atJ) -> - list - |> List.set i atJ - |> List.set j atI - - _ -> - [] - - partition : I64, I64, List (Num a) -> [ Pair I64 (List (Num a)) ] - partition = \low, high, initialList -> - when List.get initialList high is - Ok pivot -> - when partitionHelp (low - 1) low initialList high pivot is - Pair newI newList -> - Pair (newI + 1) (swap (newI + 1) high newList) - - Err _ -> - Pair (low - 1) initialList - - - partitionHelp : I64, I64, List (Num a), I64, (Num a) -> [ Pair I64 (List (Num a)) ] - partitionHelp = \i, j, list, high, pivot -> - if j < high then - when List.get list j is - Ok value -> - if value <= pivot then - partitionHelp (i + 1) (j + 1) (swap (i + 1) j list) high pivot - else - partitionHelp i (j + 1) list high pivot - - Err _ -> - Pair i list - else - Pair i list - - - - quicksort = \originalList -> - n = List.len originalList - quicksortHelp originalList 0 (n - 1) - - main = - quicksort [1,2,3] - "# - ), - indoc!( - r#" - "# - ), - ) - }) - } - - #[test] - fn factorial() { - compiles_to_ir( - r#" - factorial = \n, accum -> - when n is - 0 -> - accum - - _ -> - factorial (n - 1) (n * accum) - - factorial 10 1 - "#, - indoc!( - r#" - procedure Num.25 (#Attr.2, #Attr.3): - let Test.14 = lowlevel NumSub #Attr.2 #Attr.3; - ret Test.14; - - procedure Num.26 (#Attr.2, #Attr.3): - let Test.12 = lowlevel NumMul #Attr.2 #Attr.3; - ret Test.12; - - procedure Test.1 (Test.2, Test.3): - joinpoint Test.7 Test.2 Test.3: - let Test.15 = 0i64; - let Test.16 = lowlevel Eq Test.15 Test.2; - if Test.16 then - ret Test.3; - else - let Test.13 = 1i64; - let Test.10 = CallByName Num.25 Test.2 Test.13; - let Test.11 = CallByName Num.26 Test.2 Test.3; - jump Test.7 Test.10 Test.11; - in - jump Test.7 Test.2 Test.3; - - procedure Test.0 (): - let Test.5 = 10i64; - let Test.6 = 1i64; - let Test.4 = CallByName Test.1 Test.5 Test.6; - ret Test.4; - "# - ), - ) - } - - #[test] - #[ignore] - fn is_nil() { - compiles_to_ir( - r#" - ConsList a : [ Cons a (ConsList a), Nil ] - - isNil : ConsList a -> Bool - isNil = \list -> - when list is - Nil -> True - Cons _ _ -> False - - isNil (Cons 0x2 Nil) - "#, - indoc!( - r#" - procedure Test.1 (Test.3): - let Test.13 = true; - let Test.15 = Index 0 Test.3; - let Test.14 = 1i64; - let Test.16 = lowlevel Eq Test.14 Test.15; - let Test.12 = lowlevel And Test.16 Test.13; - if Test.12 then - let Test.10 = true; - ret Test.10; - else - let Test.11 = false; - ret Test.11; - - let Test.6 = 0i64; - let Test.7 = 2i64; - let Test.9 = 1i64; - let Test.8 = Nil Test.9; - let Test.5 = Cons Test.6 Test.7 Test.8; - let Test.4 = CallByName Test.1 Test.5; - ret Test.4; - "# - ), - ) - } - - #[test] - #[ignore] - fn has_none() { - compiles_to_ir( - r#" - Maybe a : [ Just a, Nothing ] - ConsList a : [ Cons a (ConsList a), Nil ] - - hasNone : ConsList (Maybe a) -> Bool - hasNone = \list -> - when list is - Nil -> False - Cons Nothing _ -> True - Cons (Just _) xs -> hasNone xs - - hasNone (Cons (Just 3) Nil) - "#, - indoc!( - r#" - procedure Test.1 (Test.3): - let Test.13 = true; - let Test.15 = Index 0 Test.3; - let Test.14 = 1i64; - let Test.16 = lowlevel Eq Test.14 Test.15; - let Test.12 = lowlevel And Test.16 Test.13; - if Test.12 then - let Test.10 = true; - ret Test.10; - else - let Test.11 = false; - ret Test.11; - - let Test.6 = 0i64; - let Test.7 = 2i64; - let Test.9 = 1i64; - let Test.8 = Nil Test.9; - let Test.5 = Cons Test.6 Test.7 Test.8; - let Test.4 = CallByName Test.1 Test.5; - ret Test.4; - "# - ), - ) - } - - #[test] - fn mk_pair_of() { - compiles_to_ir( - indoc!( - r#" - app "test" provides [ main ] to "./platform" - - mkPairOf = \x -> Pair x x - - main = - mkPairOf [1,2,3] - "# - ), - indoc!( - r#" - procedure Test.1 (Test.2): - inc Test.2; - let Test.6 = Struct {Test.2, Test.2}; - ret Test.6; - - procedure Test.0 (): - let Test.7 = 1i64; - let Test.8 = 2i64; - let Test.9 = 3i64; - let Test.5 = Array [Test.7, Test.8, Test.9]; - let Test.4 = CallByName Test.1 Test.5; - ret Test.4; - "# - ), - ) - } - - #[test] - fn fst() { - compiles_to_ir( - indoc!( - r#" - app "test" provides [ main ] to "./platform" - - fst = \x, _ -> x - - main = - fst [1,2,3] [3,2,1] - "# - ), - indoc!( - r#" - procedure Test.1 (Test.2, Test.3): - inc Test.2; - ret Test.2; - - procedure Test.0 (): - let Test.11 = 1i64; - let Test.12 = 2i64; - let Test.13 = 3i64; - let Test.5 = Array [Test.11, Test.12, Test.13]; - let Test.8 = 3i64; - let Test.9 = 2i64; - let Test.10 = 1i64; - let Test.6 = Array [Test.8, Test.9, Test.10]; - let Test.4 = CallByName Test.1 Test.5 Test.6; - dec Test.6; - dec Test.5; - ret Test.4; - "# - ), - ) - } - - #[test] - fn list_cannot_update_inplace() { - compiles_to_ir( - indoc!( - r#" - app "test" provides [ main ] to "./platform" - - x : List I64 - x = [1,2,3] - - add : List I64 -> List I64 - add = \y -> List.set y 0 0 - - main = - List.len (add x) + List.len x - "# - ), - indoc!( - r#" - procedure List.4 (#Attr.2, #Attr.3, #Attr.4): - let Test.22 = lowlevel ListLen #Attr.2; - let Test.20 = lowlevel NumLt #Attr.3 Test.22; - if Test.20 then - let Test.21 = lowlevel ListSet #Attr.2 #Attr.3 #Attr.4; - ret Test.21; - else - ret #Attr.2; - - procedure List.7 (#Attr.2): - let Test.9 = lowlevel ListLen #Attr.2; - ret Test.9; - - procedure Num.24 (#Attr.2, #Attr.3): - let Test.7 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Test.7; - - procedure Test.1 (): - let Test.11 = 1i64; - let Test.12 = 2i64; - let Test.13 = 3i64; - let Test.10 = Array [Test.11, Test.12, Test.13]; - ret Test.10; - - procedure Test.2 (Test.3): - let Test.17 = 0i64; - let Test.18 = 0i64; - let Test.16 = CallByName List.4 Test.3 Test.17 Test.18; - ret Test.16; - - procedure Test.0 (): - let Test.15 = CallByName Test.1; - let Test.14 = CallByName Test.2 Test.15; - let Test.5 = CallByName List.7 Test.14; - dec Test.14; - let Test.8 = CallByName Test.1; - let Test.6 = CallByName List.7 Test.8; - dec Test.8; - let Test.4 = CallByName Num.24 Test.5 Test.6; - ret Test.4; - "# - ), - ) - } - - #[test] - fn list_get() { - compiles_to_ir( - indoc!( - r#" - wrapper = \{} -> - List.get [1,2,3] 0 - - wrapper {} - "# - ), - indoc!( - r#" - procedure List.3 (#Attr.2, #Attr.3): - let Test.15 = lowlevel ListLen #Attr.2; - let Test.11 = lowlevel NumLt #Attr.3 Test.15; - if Test.11 then - let Test.14 = 1i64; - let Test.13 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; - let Test.12 = Ok Test.14 Test.13; - ret Test.12; - else - let Test.10 = 0i64; - let Test.9 = Struct {}; - let Test.8 = Err Test.10 Test.9; - ret Test.8; - - procedure Test.1 (Test.2): - let Test.16 = 1i64; - let Test.17 = 2i64; - let Test.18 = 3i64; - let Test.6 = Array [Test.16, Test.17, Test.18]; - let Test.7 = 0i64; - let Test.5 = CallByName List.3 Test.6 Test.7; - dec Test.6; - ret Test.5; - - procedure Test.0 (): - let Test.4 = Struct {}; - let Test.3 = CallByName Test.1 Test.4; - ret Test.3; - "# - ), - ) - } - - #[test] - fn peano() { - compiles_to_ir( - indoc!( - r#" - Peano : [ S Peano, Z ] - - three : Peano - three = S (S (S Z)) - - three - "# - ), - indoc!( - r#" - procedure Test.0 (): - let Test.9 = 0i64; - let Test.11 = 0i64; - let Test.13 = 0i64; - let Test.14 = 1i64; - let Test.12 = Z Test.14; - let Test.10 = S Test.13 Test.12; - let Test.8 = S Test.11 Test.10; - let Test.2 = S Test.9 Test.8; - ret Test.2; - "# - ), - ) - } - - #[test] - fn peano1() { - compiles_to_ir( - indoc!( - r#" - Peano : [ S Peano, Z ] - - three : Peano - three = S (S (S Z)) - - when three is - Z -> 0 - S _ -> 1 - "# - ), - indoc!( - r#" - procedure Test.0 (): - let Test.13 = 0i64; - let Test.15 = 0i64; - let Test.17 = 0i64; - let Test.18 = 1i64; - let Test.16 = Z Test.18; - let Test.14 = S Test.17 Test.16; - let Test.12 = S Test.15 Test.14; - let Test.2 = S Test.13 Test.12; - let Test.9 = 1i64; - let Test.10 = Index 0 Test.2; - dec Test.2; - let Test.11 = lowlevel Eq Test.9 Test.10; - if Test.11 then - let Test.7 = 0i64; - ret Test.7; - else - let Test.8 = 1i64; - ret Test.8; - "# - ), - ) - } - - #[test] - fn peano2() { - compiles_to_ir( - indoc!( - r#" - Peano : [ S Peano, Z ] - - three : Peano - three = S (S (S Z)) - - when three is - S (S _) -> 1 - S (_) -> 0 - Z -> 0 - "# - ), - indoc!( - r#" - procedure Test.0 (): - let Test.19 = 0i64; - let Test.21 = 0i64; - let Test.23 = 0i64; - let Test.24 = 1i64; - let Test.22 = Z Test.24; - let Test.20 = S Test.23 Test.22; - let Test.18 = S Test.21 Test.20; - let Test.2 = S Test.19 Test.18; - let Test.15 = 0i64; - let Test.16 = Index 0 Test.2; - let Test.17 = lowlevel Eq Test.15 Test.16; - if Test.17 then - let Test.11 = Index 1 Test.2; - let Test.12 = 0i64; - let Test.13 = Index 0 Test.11; - dec Test.11; - decref Test.2; - let Test.14 = lowlevel Eq Test.12 Test.13; - if Test.14 then - let Test.7 = 1i64; - ret Test.7; - else - let Test.9 = 0i64; - ret Test.9; - else - let Test.10 = 0i64; - ret Test.10; - "# - ), - ) - } - - #[test] - fn optional_when() { - compiles_to_ir( - indoc!( - r#" - f = \r -> - when r is - { x: Blue, y ? 3 } -> y - { x: Red, y ? 5 } -> y - - a = f { x: Blue, y: 7 } - b = f { x: Blue } - c = f { x: Red, y: 11 } - d = f { x: Red } - - a * b * c * d - "# - ), - indoc!( - r#" - procedure Num.26 (#Attr.2, #Attr.3): - let Test.17 = lowlevel NumMul #Attr.2 #Attr.3; - ret Test.17; - - procedure Test.1 (Test.6): - let Test.22 = Index 1 Test.6; - let Test.23 = false; - let Test.24 = lowlevel Eq Test.23 Test.22; - if Test.24 then - let Test.8 = Index 0 Test.6; - ret Test.8; - else - let Test.10 = Index 0 Test.6; - ret Test.10; - - procedure Test.1 (Test.6): - let Test.33 = Index 0 Test.6; - let Test.34 = false; - let Test.35 = lowlevel Eq Test.34 Test.33; - if Test.35 then - let Test.8 = 3i64; - ret Test.8; - else - let Test.10 = 5i64; - ret Test.10; - - procedure Test.0 (): - let Test.38 = true; - let Test.5 = CallByName Test.1 Test.38; - let Test.36 = false; - let Test.3 = CallByName Test.1 Test.36; - let Test.28 = 11i64; - let Test.29 = true; - let Test.27 = Struct {Test.28, Test.29}; - let Test.4 = CallByName Test.1 Test.27; - let Test.25 = 7i64; - let Test.26 = false; - let Test.19 = Struct {Test.25, Test.26}; - let Test.2 = CallByName Test.1 Test.19; - let Test.18 = CallByName Num.26 Test.2 Test.3; - let Test.16 = CallByName Num.26 Test.18 Test.4; - let Test.15 = CallByName Num.26 Test.16 Test.5; - ret Test.15; - "# - ), - ) - } - - #[test] - fn nested_pattern_match() { - compiles_to_ir( - indoc!( - r#" - Maybe a : [ Nothing, Just a ] - - x : Maybe (Maybe I64) - x = Just (Just 41) - - when x is - Just (Just v) -> v + 0x1 - _ -> 0x1 - "# - ), - indoc!( - r#" - procedure Num.24 (#Attr.2, #Attr.3): - let Test.8 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Test.8; - - procedure Test.0 (): - let Test.20 = 0i64; - let Test.22 = 0i64; - let Test.21 = 41i64; - let Test.19 = Just Test.22 Test.21; - let Test.2 = Just Test.20 Test.19; - joinpoint Test.16: - let Test.10 = 1i64; - ret Test.10; - in - let Test.14 = 0i64; - let Test.15 = Index 0 Test.2; - let Test.18 = lowlevel Eq Test.14 Test.15; - if Test.18 then - let Test.11 = Index 1 Test.2; - let Test.12 = 0i64; - let Test.13 = Index 0 Test.11; - let Test.17 = lowlevel Eq Test.12 Test.13; - if Test.17 then - let Test.9 = Index 1 Test.2; - let Test.5 = Index 1 Test.9; - let Test.7 = 1i64; - let Test.6 = CallByName Num.24 Test.5 Test.7; - ret Test.6; - else - jump Test.16; - else - jump Test.16; - "# - ), - ) - } - - #[test] - #[ignore] - fn linked_list_length_twice() { - compiles_to_ir( - indoc!( - r#" - LinkedList a : [ Nil, Cons a (LinkedList a) ] - - nil : LinkedList I64 - nil = Nil - - length : LinkedList a -> I64 - length = \list -> - when list is - Nil -> 0 - Cons _ rest -> 1 + length rest - - length nil + length nil - "# - ), - indoc!( - r#" - procedure Num.14 (#Attr.2, #Attr.3): - let Test.9 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Test.9; - - procedure Test.3 (Test.4): - let Test.15 = true; - let Test.16 = 1i64; - let Test.17 = Index 0 Test.4; - let Test.18 = lowlevel Eq Test.16 Test.17; - let Test.14 = lowlevel And Test.18 Test.15; - if Test.14 then - dec Test.4; - let Test.10 = 0i64; - ret Test.10; - else - let Test.5 = Index 2 Test.4; - dec Test.4; - let Test.12 = 1i64; - let Test.13 = CallByName Test.3 Test.5; - let Test.11 = CallByName Num.14 Test.12 Test.13; - ret Test.11; - - procedure Test.0 (): - let Test.20 = 1i64; - let Test.2 = Nil Test.20; - let Test.7 = CallByName Test.3 Test.2; - let Test.8 = CallByName Test.3 Test.2; - let Test.6 = CallByName Num.14 Test.7 Test.8; - ret Test.6; - "# - ), - ) - } - - #[test] - fn rigids() { - compiles_to_ir( - indoc!( - r#" - app "test" provides [ main ] to "./platform" - - swap : Nat, Nat, List a -> List a - swap = \i, j, list -> - when Pair (List.get list i) (List.get list j) is - Pair (Ok atI) (Ok atJ) -> - foo = atJ - - list - |> List.set i foo - |> List.set j atI - - _ -> - [] - - main = - swap 0 0 [0x1] - "# - ), - indoc!( - r#" - procedure List.3 (#Attr.2, #Attr.3): - let Test.41 = lowlevel ListLen #Attr.2; - let Test.37 = lowlevel NumLt #Attr.3 Test.41; - if Test.37 then - let Test.40 = 1i64; - let Test.39 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; - let Test.38 = Ok Test.40 Test.39; - ret Test.38; - else - let Test.36 = 0i64; - let Test.35 = Struct {}; - let Test.34 = Err Test.36 Test.35; - ret Test.34; - - procedure List.4 (#Attr.2, #Attr.3, #Attr.4): - let Test.19 = lowlevel ListLen #Attr.2; - let Test.17 = lowlevel NumLt #Attr.3 Test.19; - if Test.17 then - let Test.18 = lowlevel ListSet #Attr.2 #Attr.3 #Attr.4; - ret Test.18; - else - ret #Attr.2; - - procedure Test.1 (Test.2, Test.3, Test.4): - let Test.33 = CallByName List.3 Test.4 Test.3; - let Test.32 = CallByName List.3 Test.4 Test.2; - let Test.13 = Struct {Test.32, Test.33}; - joinpoint Test.29: - let Test.22 = Array []; - ret Test.22; - in - let Test.26 = Index 1 Test.13; - let Test.27 = 1i64; - let Test.28 = Index 0 Test.26; - let Test.31 = lowlevel Eq Test.27 Test.28; - if Test.31 then - let Test.23 = Index 0 Test.13; - let Test.24 = 1i64; - let Test.25 = Index 0 Test.23; - let Test.30 = lowlevel Eq Test.24 Test.25; - if Test.30 then - let Test.21 = Index 0 Test.13; - let Test.6 = Index 1 Test.21; - let Test.20 = Index 1 Test.13; - let Test.7 = Index 1 Test.20; - let Test.15 = CallByName List.4 Test.4 Test.2 Test.7; - let Test.14 = CallByName List.4 Test.15 Test.3 Test.6; - ret Test.14; - else - dec Test.4; - jump Test.29; - else - dec Test.4; - jump Test.29; - - procedure Test.0 (): - let Test.10 = 0i64; - let Test.11 = 0i64; - let Test.42 = 1i64; - let Test.12 = Array [Test.42]; - let Test.9 = CallByName Test.1 Test.10 Test.11 Test.12; - ret Test.9; - "# - ), - ) - } - - #[test] - fn let_x_in_x() { - compiles_to_ir( - indoc!( - r#" - x = 5 - - answer = - 1337 - - unused = - nested = 17 - nested - - answer - "# - ), - indoc!( - r#" - procedure Test.0 (): - let Test.1 = 5i64; - let Test.4 = 17i64; - let Test.2 = 1337i64; - ret Test.2; - "# - ), - ) - } - - #[test] - fn let_x_in_x_indirect() { - compiles_to_ir( - indoc!( - r#" - x = 5 - - answer = - 1337 - - unused = - nested = 17 - - i = 1 - - nested - - { answer, unused }.answer - "# - ), - indoc!( - r#" - procedure Test.0 (): - let Test.1 = 5i64; - let Test.4 = 17i64; - let Test.5 = 1i64; - let Test.2 = 1337i64; - let Test.7 = Struct {Test.2, Test.4}; - let Test.6 = Index 0 Test.7; - ret Test.6; - "# - ), - ) - } - - #[test] - fn nested_closure() { - compiles_to_ir( - indoc!( - r#" - app "test" provides [ main ] to "./platform" - - foo = \{} -> - x = 42 - f = \{} -> x - f - - main = - f = foo {} - f {} - "# - ), - indoc!( - r#" - procedure Test.1 (Test.5): - let Test.2 = 42i64; - let Test.3 = Struct {Test.2}; - ret Test.3; - - procedure Test.3 (Test.9, #Attr.12): - let Test.2 = Index 0 #Attr.12; - ret Test.2; - - procedure Test.0 (): - let Test.8 = Struct {}; - let Test.4 = CallByName Test.1 Test.8; - let Test.7 = Struct {}; - let Test.6 = CallByName Test.3 Test.7 Test.4; - ret Test.6; - "# - ), - ) - } - - #[test] - fn closure_in_list() { - compiles_to_ir( - indoc!( - r#" - app "test" provides [ main ] to "./platform" - - foo = \{} -> - x = 41 - - f = \{} -> x - - [ f ] - - main = - items = foo {} - - List.len items - "# - ), - indoc!( - r#" - procedure List.7 (#Attr.2): - let Test.7 = lowlevel ListLen #Attr.2; - ret Test.7; - - procedure Test.1 (Test.5): - let Test.2 = 41i64; - let Test.11 = Struct {Test.2}; - let Test.10 = Array [Test.11]; - ret Test.10; - - procedure Test.3 (Test.9, #Attr.12): - let Test.2 = Index 0 #Attr.12; - ret Test.2; - - procedure Test.0 (): - let Test.8 = Struct {}; - let Test.4 = CallByName Test.1 Test.8; - let Test.6 = CallByName List.7 Test.4; - dec Test.4; - ret Test.6; - "# - ), - ) - } - - #[test] - #[ignore] - fn somehow_drops_definitions() { - compiles_to_ir( - indoc!( - r#" - app "test" provides [ main ] to "./platform" - - one : I64 - one = 1 - - two : I64 - two = 2 - - increment : I64 -> I64 - increment = \x -> x + one - - double : I64 -> I64 - double = \x -> x * two - - apply : (a -> a), a -> a - apply = \f, x -> f x - - main = - apply (if True then increment else double) 42 - "# - ), - indoc!( - r#" - "# - ), - ) - } - - #[test] - fn specialize_closures() { - compiles_to_ir( - indoc!( - r#" - app "test" provides [ main ] to "./platform" - - - apply : (a -> a), a -> a - apply = \f, x -> f x - - main = - one : I64 - one = 1 - - two : I64 - two = 2 - - b : Bool - b = True - - increment : I64 -> I64 - increment = \x -> x + one - - double : I64 -> I64 - double = \x -> if b then x * two else x - - apply (if True then increment else double) 42 - "# - ), - indoc!( - r#" - procedure Num.24 (#Attr.2, #Attr.3): - let Test.29 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Test.29; - - procedure Num.26 (#Attr.2, #Attr.3): - let Test.25 = lowlevel NumMul #Attr.2 #Attr.3; - ret Test.25; - - procedure Test.1 (Test.2, Test.3): - let Test.17 = Index 0 Test.2; - joinpoint Test.18 Test.16: - ret Test.16; - in - switch Test.17: - case 0: - let Test.19 = CallByName Test.7 Test.3 Test.2; - jump Test.18 Test.19; - - default: - let Test.20 = CallByName Test.8 Test.3 Test.2; - jump Test.18 Test.20; - - - procedure Test.7 (Test.10, #Attr.12): - let Test.4 = Index 1 #Attr.12; - let Test.28 = CallByName Num.24 Test.10 Test.4; - ret Test.28; - - procedure Test.8 (Test.11, #Attr.12): - let Test.6 = Index 2 #Attr.12; - let Test.5 = Index 1 #Attr.12; - if Test.6 then - let Test.24 = CallByName Num.26 Test.11 Test.5; - ret Test.24; - else - ret Test.11; - - procedure Test.0 (): - let Test.6 = true; - let Test.4 = 1i64; - let Test.5 = 2i64; - joinpoint Test.22 Test.14: - let Test.15 = 42i64; - let Test.13 = CallByName Test.1 Test.14 Test.15; - ret Test.13; - in - let Test.27 = true; - if Test.27 then - let Test.30 = 0i64; - let Test.7 = ClosureTag(Test.7) Test.30 Test.4; - jump Test.22 Test.7; - else - let Test.26 = 1i64; - let Test.8 = ClosureTag(Test.8) Test.26 Test.5 Test.6; - jump Test.22 Test.8; - "# - ), - ) - } - - #[test] - #[ignore] - fn specialize_lowlevel() { - compiles_to_ir( - indoc!( - r#" - app "test" provides [ main ] to "./platform" - - - apply : (a -> a), a -> a - apply = \f, x -> f x - - main = - one : I64 - one = 1 - - two : I64 - two = 2 - - increment : I64 -> I64 - increment = \x -> x + 1 - - double : I64 -> I64 - double = \x -> x * two - - when 3 is - 1 -> increment 0 - 2 -> double 0 - _ -> List.map [] (if True then increment else double) |> List.len - "# - ), - indoc!( - r#" - "# - ), - ) - } - - #[test] - #[ignore] - fn static_str_closure() { - compiles_to_ir( - indoc!( - r#" - app "test" provides [ main ] to "./platform" - - main : Str - main = - x = "long string that is malloced" - - f : {} -> Str - f = (\_ -> x) - - f {} - "# - ), - indoc!( - r#" - "# - ), - ) - } -} From fb6ba3de57331fe14c514d05765afdd68c7c9f33 Mon Sep 17 00:00:00 2001 From: Folkert Date: Tue, 1 Jun 2021 21:45:51 +0200 Subject: [PATCH 067/496] update mono tests --- compiler/test_mono/generated/factorial.txt | 14 +++--- compiler/test_mono/generated/ir_int_add.txt | 20 ++++----- compiler/test_mono/generated/ir_when_just.txt | 18 ++++---- .../generated/linked_list_length_twice.txt | 24 +++++----- .../generated/list_cannot_update_inplace.txt | 44 +++++++++---------- compiler/test_mono/generated/list_len.txt | 20 ++++----- .../generated/nested_pattern_match.txt | 42 +++++++++--------- .../test_mono/generated/optional_when.txt | 44 +++++++++---------- .../test_mono/generated/quicksort_help.txt | 24 +++++----- ...optional_field_function_no_use_default.txt | 6 +-- ...rd_optional_field_function_use_default.txt | 4 +- ...cord_optional_field_let_no_use_default.txt | 6 +-- .../record_optional_field_let_use_default.txt | 4 +- .../generated/somehow_drops_definitions.txt | 22 +++++----- .../generated/specialize_closures.txt | 20 ++++----- .../test_mono/generated/when_nested_maybe.txt | 42 +++++++++--------- .../test_mono/generated/when_on_record.txt | 4 +- .../generated/when_on_two_values.txt | 28 ++++++------ 18 files changed, 193 insertions(+), 193 deletions(-) diff --git a/compiler/test_mono/generated/factorial.txt b/compiler/test_mono/generated/factorial.txt index c57881e00b..1c6b0e2d39 100644 --- a/compiler/test_mono/generated/factorial.txt +++ b/compiler/test_mono/generated/factorial.txt @@ -1,6 +1,6 @@ procedure Num.25 (#Attr.2, #Attr.3): - let Test.14 = lowlevel NumSub #Attr.2 #Attr.3; - ret Test.14; + let Test.15 = lowlevel NumSub #Attr.2 #Attr.3; + ret Test.15; procedure Num.26 (#Attr.2, #Attr.3): let Test.12 = lowlevel NumMul #Attr.2 #Attr.3; @@ -8,13 +8,13 @@ procedure Num.26 (#Attr.2, #Attr.3): procedure Test.1 (Test.2, Test.3): joinpoint Test.7 Test.2 Test.3: - let Test.15 = 0i64; - let Test.16 = lowlevel Eq Test.15 Test.2; - if Test.16 then + let Test.17 = 0i64; + let Test.18 = lowlevel Eq Test.17 Test.2; + if Test.18 then ret Test.3; else - let Test.13 = 1i64; - let Test.10 = CallByName Num.25 Test.2 Test.13; + let Test.14 = 1i64; + let Test.10 = CallByName Num.25 Test.2 Test.14; let Test.11 = CallByName Num.26 Test.2 Test.3; jump Test.7 Test.10 Test.11; in diff --git a/compiler/test_mono/generated/ir_int_add.txt b/compiler/test_mono/generated/ir_int_add.txt index 4b427ffaee..0adc761dc1 100644 --- a/compiler/test_mono/generated/ir_int_add.txt +++ b/compiler/test_mono/generated/ir_int_add.txt @@ -1,22 +1,22 @@ procedure List.7 (#Attr.2): - let Test.6 = lowlevel ListLen #Attr.2; - ret Test.6; + let Test.7 = lowlevel ListLen #Attr.2; + ret Test.7; procedure Num.24 (#Attr.2, #Attr.3): let Test.5 = lowlevel NumAdd #Attr.2 #Attr.3; ret Test.5; procedure Test.0 (): - let Test.11 = 1i64; - let Test.12 = 2i64; - let Test.1 = Array [Test.11, Test.12]; - let Test.9 = 5i64; - let Test.10 = 4i64; - invoke Test.7 = CallByName Num.24 Test.9 Test.10 catch + let Test.14 = 1i64; + let Test.15 = 2i64; + let Test.1 = Array [Test.14, Test.15]; + let Test.11 = 5i64; + let Test.12 = 4i64; + invoke Test.8 = CallByName Num.24 Test.11 Test.12 catch dec Test.1; unreachable; - let Test.8 = 3i64; - invoke Test.3 = CallByName Num.24 Test.7 Test.8 catch + let Test.9 = 3i64; + invoke Test.3 = CallByName Num.24 Test.8 Test.9 catch dec Test.1; unreachable; let Test.4 = CallByName List.7 Test.1; diff --git a/compiler/test_mono/generated/ir_when_just.txt b/compiler/test_mono/generated/ir_when_just.txt index 4b25c7c779..baf5e51d25 100644 --- a/compiler/test_mono/generated/ir_when_just.txt +++ b/compiler/test_mono/generated/ir_when_just.txt @@ -3,17 +3,17 @@ procedure Num.24 (#Attr.2, #Attr.3): ret Test.6; procedure Test.0 (): - let Test.12 = 0i64; - let Test.11 = 41i64; - let Test.1 = Just Test.12 Test.11; - let Test.8 = 0i64; - let Test.9 = Index 0 Test.1; - let Test.10 = lowlevel Eq Test.8 Test.9; - if Test.10 then + let Test.13 = 0i64; + let Test.12 = 41i64; + let Test.1 = Just Test.13 Test.12; + let Test.9 = 0i64; + let Test.10 = Index 0 Test.1; + let Test.11 = lowlevel Eq Test.9 Test.10; + if Test.11 then let Test.3 = Index 1 Test.1; let Test.5 = 1i64; let Test.4 = CallByName Num.24 Test.3 Test.5; ret Test.4; else - let Test.7 = 1i64; - ret Test.7; + let Test.8 = 1i64; + ret Test.8; diff --git a/compiler/test_mono/generated/linked_list_length_twice.txt b/compiler/test_mono/generated/linked_list_length_twice.txt index 1e3ac67351..a54ec0b202 100644 --- a/compiler/test_mono/generated/linked_list_length_twice.txt +++ b/compiler/test_mono/generated/linked_list_length_twice.txt @@ -3,22 +3,22 @@ procedure Num.24 (#Attr.2, #Attr.3): ret Test.10; procedure Test.3 (Test.5): - let Test.16 = 1i64; - let Test.17 = Index 0 Test.5; - let Test.18 = lowlevel Eq Test.16 Test.17; - if Test.18 then - let Test.12 = 0i64; - ret Test.12; + let Test.18 = 1i64; + let Test.19 = Index 0 Test.5; + let Test.20 = lowlevel Eq Test.18 Test.19; + if Test.20 then + let Test.13 = 0i64; + ret Test.13; else let Test.6 = Index 2 Test.5; - let Test.14 = 1i64; - let Test.15 = CallByName Test.3 Test.6; - let Test.13 = CallByName Num.24 Test.14 Test.15; - ret Test.13; + let Test.15 = 1i64; + let Test.16 = CallByName Test.3 Test.6; + let Test.14 = CallByName Num.24 Test.15 Test.16; + ret Test.14; procedure Test.0 (): - let Test.19 = 1i64; - let Test.2 = Nil Test.19; + let Test.21 = 1i64; + let Test.2 = Nil Test.21; let Test.8 = CallByName Test.3 Test.2; let Test.9 = CallByName Test.3 Test.2; dec Test.2; diff --git a/compiler/test_mono/generated/list_cannot_update_inplace.txt b/compiler/test_mono/generated/list_cannot_update_inplace.txt index 0a29c418b8..0c9ff5de3f 100644 --- a/compiler/test_mono/generated/list_cannot_update_inplace.txt +++ b/compiler/test_mono/generated/list_cannot_update_inplace.txt @@ -1,40 +1,40 @@ procedure List.4 (#Attr.2, #Attr.3, #Attr.4): - let Test.22 = lowlevel ListLen #Attr.2; - let Test.20 = lowlevel NumLt #Attr.3 Test.22; - if Test.20 then - let Test.21 = lowlevel ListSet #Attr.2 #Attr.3 #Attr.4; - ret Test.21; + let Test.23 = lowlevel ListLen #Attr.2; + let Test.21 = lowlevel NumLt #Attr.3 Test.23; + if Test.21 then + let Test.22 = lowlevel ListSet #Attr.2 #Attr.3 #Attr.4; + ret Test.22; else ret #Attr.2; procedure List.7 (#Attr.2): - let Test.9 = lowlevel ListLen #Attr.2; - ret Test.9; + let Test.10 = lowlevel ListLen #Attr.2; + ret Test.10; procedure Num.24 (#Attr.2, #Attr.3): let Test.7 = lowlevel NumAdd #Attr.2 #Attr.3; ret Test.7; procedure Test.1 (): - let Test.11 = 1i64; - let Test.12 = 2i64; - let Test.13 = 3i64; - let Test.10 = Array [Test.11, Test.12, Test.13]; - ret Test.10; + let Test.12 = 1i64; + let Test.13 = 2i64; + let Test.14 = 3i64; + let Test.11 = Array [Test.12, Test.13, Test.14]; + ret Test.11; procedure Test.2 (Test.3): - let Test.17 = 0i64; let Test.18 = 0i64; - let Test.16 = CallByName List.4 Test.3 Test.17 Test.18; - ret Test.16; + let Test.19 = 0i64; + let Test.17 = CallByName List.4 Test.3 Test.18 Test.19; + ret Test.17; procedure Test.0 (): - let Test.15 = CallByName Test.1; - let Test.14 = CallByName Test.2 Test.15; - let Test.5 = CallByName List.7 Test.14; - dec Test.14; - let Test.8 = CallByName Test.1; - let Test.6 = CallByName List.7 Test.8; - dec Test.8; + let Test.16 = CallByName Test.1; + let Test.15 = CallByName Test.2 Test.16; + let Test.5 = CallByName List.7 Test.15; + dec Test.15; + let Test.9 = CallByName Test.1; + let Test.6 = CallByName List.7 Test.9; + dec Test.9; let Test.4 = CallByName Num.24 Test.5 Test.6; ret Test.4; diff --git a/compiler/test_mono/generated/list_len.txt b/compiler/test_mono/generated/list_len.txt index d5cd03a2b9..1f50df081b 100644 --- a/compiler/test_mono/generated/list_len.txt +++ b/compiler/test_mono/generated/list_len.txt @@ -1,22 +1,22 @@ -procedure List.7 (#Attr.2): - let Test.7 = lowlevel ListLen #Attr.2; - ret Test.7; - procedure List.7 (#Attr.2): let Test.8 = lowlevel ListLen #Attr.2; ret Test.8; +procedure List.7 (#Attr.2): + let Test.9 = lowlevel ListLen #Attr.2; + ret Test.9; + procedure Num.24 (#Attr.2, #Attr.3): let Test.6 = lowlevel NumAdd #Attr.2 #Attr.3; ret Test.6; procedure Test.0 (): - let Test.10 = 1i64; - let Test.11 = 2i64; - let Test.12 = 3i64; - let Test.1 = Array [Test.10, Test.11, Test.12]; - let Test.9 = 1f64; - let Test.2 = Array [Test.9]; + let Test.11 = 1i64; + let Test.12 = 2i64; + let Test.13 = 3i64; + let Test.1 = Array [Test.11, Test.12, Test.13]; + let Test.10 = 1f64; + let Test.2 = Array [Test.10]; let Test.4 = CallByName List.7 Test.1; dec Test.1; let Test.5 = CallByName List.7 Test.2; diff --git a/compiler/test_mono/generated/nested_pattern_match.txt b/compiler/test_mono/generated/nested_pattern_match.txt index a178a68f6d..8991931ca9 100644 --- a/compiler/test_mono/generated/nested_pattern_match.txt +++ b/compiler/test_mono/generated/nested_pattern_match.txt @@ -3,30 +3,30 @@ procedure Num.24 (#Attr.2, #Attr.3): ret Test.8; procedure Test.0 (): - let Test.20 = 0i64; - let Test.22 = 0i64; - let Test.21 = 41i64; - let Test.19 = Just Test.22 Test.21; - let Test.2 = Just Test.20 Test.19; - joinpoint Test.16: - let Test.10 = 1i64; - ret Test.10; + let Test.21 = 0i64; + let Test.23 = 0i64; + let Test.22 = 41i64; + let Test.20 = Just Test.23 Test.22; + let Test.2 = Just Test.21 Test.20; + joinpoint Test.17: + let Test.11 = 1i64; + ret Test.11; in - let Test.14 = 0i64; - let Test.15 = Index 0 Test.2; - let Test.18 = lowlevel Eq Test.14 Test.15; - if Test.18 then - let Test.11 = Index 1 Test.2; - let Test.12 = 0i64; - let Test.13 = Index 0 Test.11; - let Test.17 = lowlevel Eq Test.12 Test.13; - if Test.17 then - let Test.9 = Index 1 Test.2; - let Test.5 = Index 1 Test.9; + let Test.15 = 0i64; + let Test.16 = Index 0 Test.2; + let Test.19 = lowlevel Eq Test.15 Test.16; + if Test.19 then + let Test.12 = Index 1 Test.2; + let Test.13 = 0i64; + let Test.14 = Index 0 Test.12; + let Test.18 = lowlevel Eq Test.13 Test.14; + if Test.18 then + let Test.10 = Index 1 Test.2; + let Test.5 = Index 1 Test.10; let Test.7 = 1i64; let Test.6 = CallByName Num.24 Test.5 Test.7; ret Test.6; else - jump Test.16; + jump Test.17; else - jump Test.16; + jump Test.17; diff --git a/compiler/test_mono/generated/optional_when.txt b/compiler/test_mono/generated/optional_when.txt index c5299d68ae..f1e9f636d0 100644 --- a/compiler/test_mono/generated/optional_when.txt +++ b/compiler/test_mono/generated/optional_when.txt @@ -3,10 +3,10 @@ procedure Num.26 (#Attr.2, #Attr.3): ret Test.17; procedure Test.1 (Test.6): - let Test.22 = Index 1 Test.6; - let Test.23 = false; - let Test.24 = lowlevel Eq Test.23 Test.22; - if Test.24 then + let Test.25 = Index 1 Test.6; + let Test.26 = false; + let Test.27 = lowlevel Eq Test.26 Test.25; + if Test.27 then let Test.8 = Index 0 Test.6; ret Test.8; else @@ -14,10 +14,10 @@ procedure Test.1 (Test.6): ret Test.10; procedure Test.1 (Test.6): - let Test.33 = Index 0 Test.6; - let Test.34 = false; - let Test.35 = lowlevel Eq Test.34 Test.33; - if Test.35 then + let Test.36 = Index 0 Test.6; + let Test.37 = false; + let Test.38 = lowlevel Eq Test.37 Test.36; + if Test.38 then let Test.8 = 3i64; ret Test.8; else @@ -25,19 +25,19 @@ procedure Test.1 (Test.6): ret Test.10; procedure Test.0 (): - let Test.38 = true; - let Test.5 = CallByName Test.1 Test.38; - let Test.36 = false; - let Test.3 = CallByName Test.1 Test.36; - let Test.28 = 11i64; - let Test.29 = true; - let Test.27 = Struct {Test.28, Test.29}; - let Test.4 = CallByName Test.1 Test.27; - let Test.25 = 7i64; - let Test.26 = false; - let Test.19 = Struct {Test.25, Test.26}; - let Test.2 = CallByName Test.1 Test.19; - let Test.18 = CallByName Num.26 Test.2 Test.3; - let Test.16 = CallByName Num.26 Test.18 Test.4; + let Test.41 = true; + let Test.5 = CallByName Test.1 Test.41; + let Test.39 = false; + let Test.3 = CallByName Test.1 Test.39; + let Test.31 = 11i64; + let Test.32 = true; + let Test.30 = Struct {Test.31, Test.32}; + let Test.4 = CallByName Test.1 Test.30; + let Test.28 = 7i64; + let Test.29 = false; + let Test.22 = Struct {Test.28, Test.29}; + let Test.2 = CallByName Test.1 Test.22; + let Test.19 = CallByName Num.26 Test.2 Test.3; + let Test.16 = CallByName Num.26 Test.19 Test.4; let Test.15 = CallByName Num.26 Test.16 Test.5; ret Test.15; diff --git a/compiler/test_mono/generated/quicksort_help.txt b/compiler/test_mono/generated/quicksort_help.txt index 25ed80e403..2895fd348a 100644 --- a/compiler/test_mono/generated/quicksort_help.txt +++ b/compiler/test_mono/generated/quicksort_help.txt @@ -3,26 +3,26 @@ procedure Num.24 (#Attr.2, #Attr.3): ret Test.19; procedure Num.25 (#Attr.2, #Attr.3): - let Test.22 = lowlevel NumSub #Attr.2 #Attr.3; - ret Test.22; + let Test.23 = lowlevel NumSub #Attr.2 #Attr.3; + ret Test.23; procedure Num.27 (#Attr.2, #Attr.3): - let Test.26 = lowlevel NumLt #Attr.2 #Attr.3; - ret Test.26; + let Test.28 = lowlevel NumLt #Attr.2 #Attr.3; + ret Test.28; procedure Test.1 (Test.2, Test.3, Test.4): joinpoint Test.12 Test.2 Test.3 Test.4: let Test.14 = CallByName Num.27 Test.3 Test.4; if Test.14 then dec Test.2; - let Test.25 = Array []; - let Test.24 = 0i64; - let Test.23 = Struct {Test.24, Test.25}; - let Test.5 = Index 0 Test.23; - let Test.6 = Index 1 Test.23; - let Test.21 = 1i64; - let Test.20 = CallByName Num.25 Test.5 Test.21; - let Test.16 = CallByName Test.1 Test.6 Test.3 Test.20; + let Test.27 = Array []; + let Test.26 = 0i64; + let Test.25 = Struct {Test.26, Test.27}; + let Test.5 = Index 0 Test.25; + let Test.6 = Index 1 Test.25; + let Test.22 = 1i64; + let Test.21 = CallByName Num.25 Test.5 Test.22; + let Test.16 = CallByName Test.1 Test.6 Test.3 Test.21; let Test.18 = 1i64; invoke Test.17 = CallByName Num.24 Test.5 Test.18 catch dec Test.16; diff --git a/compiler/test_mono/generated/record_optional_field_function_no_use_default.txt b/compiler/test_mono/generated/record_optional_field_function_no_use_default.txt index 4155eda65d..83f02209a0 100644 --- a/compiler/test_mono/generated/record_optional_field_function_no_use_default.txt +++ b/compiler/test_mono/generated/record_optional_field_function_no_use_default.txt @@ -10,8 +10,8 @@ procedure Test.1 (Test.4): ret Test.7; procedure Test.0 (): - let Test.9 = 4i64; - let Test.10 = 9i64; - let Test.6 = Struct {Test.9, Test.10}; + let Test.10 = 4i64; + let Test.11 = 9i64; + let Test.6 = Struct {Test.10, Test.11}; let Test.5 = CallByName Test.1 Test.6; ret Test.5; diff --git a/compiler/test_mono/generated/record_optional_field_function_use_default.txt b/compiler/test_mono/generated/record_optional_field_function_use_default.txt index 2f2f6165db..8d07d5021d 100644 --- a/compiler/test_mono/generated/record_optional_field_function_use_default.txt +++ b/compiler/test_mono/generated/record_optional_field_function_use_default.txt @@ -10,6 +10,6 @@ procedure Test.1 (Test.4): ret Test.7; procedure Test.0 (): - let Test.9 = 9i64; - let Test.5 = CallByName Test.1 Test.9; + let Test.10 = 9i64; + let Test.5 = CallByName Test.1 Test.10; ret Test.5; diff --git a/compiler/test_mono/generated/record_optional_field_let_no_use_default.txt b/compiler/test_mono/generated/record_optional_field_let_no_use_default.txt index d5aeb80f15..a5ea3d8fed 100644 --- a/compiler/test_mono/generated/record_optional_field_let_no_use_default.txt +++ b/compiler/test_mono/generated/record_optional_field_let_no_use_default.txt @@ -9,8 +9,8 @@ procedure Test.1 (Test.2): ret Test.7; procedure Test.0 (): - let Test.9 = 4i64; - let Test.10 = 9i64; - let Test.6 = Struct {Test.9, Test.10}; + let Test.10 = 4i64; + let Test.11 = 9i64; + let Test.6 = Struct {Test.10, Test.11}; let Test.5 = CallByName Test.1 Test.6; ret Test.5; diff --git a/compiler/test_mono/generated/record_optional_field_let_use_default.txt b/compiler/test_mono/generated/record_optional_field_let_use_default.txt index a96cc2dfce..b3886aaa28 100644 --- a/compiler/test_mono/generated/record_optional_field_let_use_default.txt +++ b/compiler/test_mono/generated/record_optional_field_let_use_default.txt @@ -9,6 +9,6 @@ procedure Test.1 (Test.2): ret Test.7; procedure Test.0 (): - let Test.9 = 9i64; - let Test.5 = CallByName Test.1 Test.9; + let Test.10 = 9i64; + let Test.5 = CallByName Test.1 Test.10; ret Test.5; diff --git a/compiler/test_mono/generated/somehow_drops_definitions.txt b/compiler/test_mono/generated/somehow_drops_definitions.txt index 46378c332c..da1f049ed5 100644 --- a/compiler/test_mono/generated/somehow_drops_definitions.txt +++ b/compiler/test_mono/generated/somehow_drops_definitions.txt @@ -1,23 +1,23 @@ procedure Num.24 (#Attr.2, #Attr.3): - let Test.27 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Test.27; + let Test.28 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Test.28; procedure Num.26 (#Attr.2, #Attr.3): let Test.22 = lowlevel NumMul #Attr.2 #Attr.3; ret Test.22; procedure Test.1 (): - let Test.28 = 1i64; - ret Test.28; + let Test.30 = 1i64; + ret Test.30; procedure Test.2 (): - let Test.23 = 2i64; - ret Test.23; + let Test.24 = 2i64; + ret Test.24; procedure Test.3 (Test.6): - let Test.26 = CallByName Test.1; - let Test.25 = CallByName Num.24 Test.6 Test.26; - ret Test.25; + let Test.27 = CallByName Test.1; + let Test.26 = CallByName Num.24 Test.6 Test.27; + ret Test.26; procedure Test.4 (Test.7): let Test.21 = CallByName Test.2; @@ -44,8 +44,8 @@ procedure Test.0 (): let Test.11 = CallByName Test.5 Test.12 Test.13; ret Test.11; in - let Test.24 = true; - if Test.24 then + let Test.25 = true; + if Test.25 then let Test.3 = Struct {}; jump Test.19 Test.3; else diff --git a/compiler/test_mono/generated/specialize_closures.txt b/compiler/test_mono/generated/specialize_closures.txt index 72c6e453e3..d2d87898bc 100644 --- a/compiler/test_mono/generated/specialize_closures.txt +++ b/compiler/test_mono/generated/specialize_closures.txt @@ -1,6 +1,6 @@ procedure Num.24 (#Attr.2, #Attr.3): - let Test.29 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Test.29; + let Test.30 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Test.30; procedure Num.26 (#Attr.2, #Attr.3): let Test.25 = lowlevel NumMul #Attr.2 #Attr.3; @@ -23,8 +23,8 @@ procedure Test.1 (Test.2, Test.3): procedure Test.7 (Test.10, #Attr.12): let Test.4 = Index 1 #Attr.12; - let Test.28 = CallByName Num.24 Test.10 Test.4; - ret Test.28; + let Test.29 = CallByName Num.24 Test.10 Test.4; + ret Test.29; procedure Test.8 (Test.11, #Attr.12): let Test.6 = Index 2 #Attr.12; @@ -44,12 +44,12 @@ procedure Test.0 (): let Test.13 = CallByName Test.1 Test.14 Test.15; ret Test.13; in - let Test.27 = true; - if Test.27 then - let Test.30 = 0i64; - let Test.7 = ClosureTag(Test.7) Test.30 Test.4; + let Test.28 = true; + if Test.28 then + let Test.32 = 0i64; + let Test.7 = ClosureTag(Test.7) Test.32 Test.4; jump Test.22 Test.7; else - let Test.26 = 1i64; - let Test.8 = ClosureTag(Test.8) Test.26 Test.5 Test.6; + let Test.27 = 1i64; + let Test.8 = ClosureTag(Test.8) Test.27 Test.5 Test.6; jump Test.22 Test.8; diff --git a/compiler/test_mono/generated/when_nested_maybe.txt b/compiler/test_mono/generated/when_nested_maybe.txt index a178a68f6d..8991931ca9 100644 --- a/compiler/test_mono/generated/when_nested_maybe.txt +++ b/compiler/test_mono/generated/when_nested_maybe.txt @@ -3,30 +3,30 @@ procedure Num.24 (#Attr.2, #Attr.3): ret Test.8; procedure Test.0 (): - let Test.20 = 0i64; - let Test.22 = 0i64; - let Test.21 = 41i64; - let Test.19 = Just Test.22 Test.21; - let Test.2 = Just Test.20 Test.19; - joinpoint Test.16: - let Test.10 = 1i64; - ret Test.10; + let Test.21 = 0i64; + let Test.23 = 0i64; + let Test.22 = 41i64; + let Test.20 = Just Test.23 Test.22; + let Test.2 = Just Test.21 Test.20; + joinpoint Test.17: + let Test.11 = 1i64; + ret Test.11; in - let Test.14 = 0i64; - let Test.15 = Index 0 Test.2; - let Test.18 = lowlevel Eq Test.14 Test.15; - if Test.18 then - let Test.11 = Index 1 Test.2; - let Test.12 = 0i64; - let Test.13 = Index 0 Test.11; - let Test.17 = lowlevel Eq Test.12 Test.13; - if Test.17 then - let Test.9 = Index 1 Test.2; - let Test.5 = Index 1 Test.9; + let Test.15 = 0i64; + let Test.16 = Index 0 Test.2; + let Test.19 = lowlevel Eq Test.15 Test.16; + if Test.19 then + let Test.12 = Index 1 Test.2; + let Test.13 = 0i64; + let Test.14 = Index 0 Test.12; + let Test.18 = lowlevel Eq Test.13 Test.14; + if Test.18 then + let Test.10 = Index 1 Test.2; + let Test.5 = Index 1 Test.10; let Test.7 = 1i64; let Test.6 = CallByName Num.24 Test.5 Test.7; ret Test.6; else - jump Test.16; + jump Test.17; else - jump Test.16; + jump Test.17; diff --git a/compiler/test_mono/generated/when_on_record.txt b/compiler/test_mono/generated/when_on_record.txt index 860d4f5c79..7ab0e0f757 100644 --- a/compiler/test_mono/generated/when_on_record.txt +++ b/compiler/test_mono/generated/when_on_record.txt @@ -3,8 +3,8 @@ procedure Num.24 (#Attr.2, #Attr.3): ret Test.5; procedure Test.0 (): - let Test.6 = 2i64; - let Test.1 = Index 0 Test.6; + let Test.7 = 2i64; + let Test.1 = Index 0 Test.7; let Test.4 = 3i64; let Test.3 = CallByName Num.24 Test.1 Test.4; ret Test.3; diff --git a/compiler/test_mono/generated/when_on_two_values.txt b/compiler/test_mono/generated/when_on_two_values.txt index d1505ab90c..2d58d97623 100644 --- a/compiler/test_mono/generated/when_on_two_values.txt +++ b/compiler/test_mono/generated/when_on_two_values.txt @@ -3,26 +3,26 @@ procedure Num.24 (#Attr.2, #Attr.3): ret Test.7; procedure Test.0 (): - let Test.16 = 3i64; - let Test.15 = 2i64; - let Test.4 = Struct {Test.15, Test.16}; - joinpoint Test.12: + let Test.17 = 3i64; + let Test.16 = 2i64; + let Test.4 = Struct {Test.16, Test.17}; + joinpoint Test.13: let Test.2 = Index 0 Test.4; let Test.3 = Index 1 Test.4; let Test.6 = CallByName Num.24 Test.2 Test.3; ret Test.6; in - let Test.10 = Index 1 Test.4; - let Test.11 = 3i64; - let Test.14 = lowlevel Eq Test.11 Test.10; - if Test.14 then - let Test.8 = Index 0 Test.4; - let Test.9 = 4i64; - let Test.13 = lowlevel Eq Test.9 Test.8; - if Test.13 then + let Test.11 = Index 1 Test.4; + let Test.12 = 3i64; + let Test.15 = lowlevel Eq Test.12 Test.11; + if Test.15 then + let Test.9 = Index 0 Test.4; + let Test.10 = 4i64; + let Test.14 = lowlevel Eq Test.10 Test.9; + if Test.14 then let Test.5 = 9i64; ret Test.5; else - jump Test.12; + jump Test.13; else - jump Test.12; + jump Test.13; From 636d6719eb2854da407e93ce9c65a1bac2f8a3af Mon Sep 17 00:00:00 2001 From: Folkert Date: Tue, 1 Jun 2021 22:12:19 +0200 Subject: [PATCH 068/496] use builtin set_name --- compiler/gen/src/llvm/bitcode.rs | 22 +++++++++---------- compiler/gen/src/llvm/build.rs | 32 +++++----------------------- compiler/gen/src/llvm/build_dict.rs | 8 +++---- compiler/gen/src/llvm/build_hash.rs | 18 +++++++++------- compiler/gen/src/llvm/compare.rs | 18 +++++++++------- compiler/gen/src/llvm/convert.rs | 19 ++--------------- compiler/gen/src/llvm/externs.rs | 7 +++--- compiler/gen/src/llvm/refcounting.rs | 18 +++++++++------- 8 files changed, 56 insertions(+), 86 deletions(-) diff --git a/compiler/gen/src/llvm/bitcode.rs b/compiler/gen/src/llvm/bitcode.rs index ab54010fa2..a2d98cd868 100644 --- a/compiler/gen/src/llvm/bitcode.rs +++ b/compiler/gen/src/llvm/bitcode.rs @@ -1,13 +1,13 @@ /// Helpers for interacting with the zig that generates bitcode use crate::debug_info_init; -use crate::llvm::build::{set_name, Env, C_CALL_CONV, FAST_CALL_CONV}; +use crate::llvm::build::{Env, C_CALL_CONV, FAST_CALL_CONV}; use crate::llvm::convert::basic_type_from_layout; use crate::llvm::refcounting::{ decrement_refcount_layout, increment_n_refcount_layout, increment_refcount_layout, }; use inkwell::attributes::{Attribute, AttributeLoc}; use inkwell::types::{BasicType, BasicTypeEnum}; -use inkwell::values::{BasicValueEnum, CallSiteValue, FunctionValue, InstructionValue}; +use inkwell::values::{BasicValue, BasicValueEnum, CallSiteValue, FunctionValue, InstructionValue}; use inkwell::AddressSpace; use roc_module::symbol::Symbol; use roc_mono::layout::{Layout, LayoutIds}; @@ -122,13 +122,13 @@ fn build_transform_caller_help<'a, 'ctx, 'env>( let mut it = function_value.get_param_iter(); let closure_ptr = it.next().unwrap().into_pointer_value(); - set_name(closure_ptr.into(), Symbol::ARG_1.ident_string(&env.interns)); + closure_ptr.set_name(Symbol::ARG_1.ident_string(&env.interns)); let arguments = bumpalo::collections::Vec::from_iter_in(it.take(argument_layouts.len()), env.arena); for (argument, name) in arguments.iter().zip(ARGUMENT_SYMBOLS[1..].iter()) { - set_name(*argument, name.ident_string(&env.interns)); + argument.set_name(name.ident_string(&env.interns)); } let mut arguments_cast = @@ -316,7 +316,7 @@ fn build_rc_wrapper<'a, 'ctx, 'env>( let mut it = function_value.get_param_iter(); let value_ptr = it.next().unwrap().into_pointer_value(); - set_name(value_ptr.into(), Symbol::ARG_1.ident_string(&env.interns)); + value_ptr.set_name(Symbol::ARG_1.ident_string(&env.interns)); let value_type = basic_type_from_layout(env, layout).ptr_type(AddressSpace::Generic); @@ -334,7 +334,7 @@ fn build_rc_wrapper<'a, 'ctx, 'env>( } Mode::IncN => { let n = it.next().unwrap().into_int_value(); - set_name(n.into(), Symbol::ARG_2.ident_string(&env.interns)); + n.set_name(Symbol::ARG_2.ident_string(&env.interns)); increment_n_refcount_layout(env, function_value, layout_ids, n, value, layout); } @@ -395,8 +395,8 @@ pub fn build_eq_wrapper<'a, 'ctx, 'env>( let value_ptr1 = it.next().unwrap().into_pointer_value(); let value_ptr2 = it.next().unwrap().into_pointer_value(); - set_name(value_ptr1.into(), Symbol::ARG_1.ident_string(&env.interns)); - set_name(value_ptr2.into(), Symbol::ARG_2.ident_string(&env.interns)); + value_ptr1.set_name(Symbol::ARG_1.ident_string(&env.interns)); + value_ptr2.set_name(Symbol::ARG_2.ident_string(&env.interns)); let value_type = basic_type_from_layout(env, layout).ptr_type(AddressSpace::Generic); @@ -473,9 +473,9 @@ pub fn build_compare_wrapper<'a, 'ctx, 'env>( let value_ptr1 = it.next().unwrap().into_pointer_value(); let value_ptr2 = it.next().unwrap().into_pointer_value(); - set_name(closure_ptr.into(), Symbol::ARG_1.ident_string(&env.interns)); - set_name(value_ptr1.into(), Symbol::ARG_2.ident_string(&env.interns)); - set_name(value_ptr2.into(), Symbol::ARG_3.ident_string(&env.interns)); + closure_ptr.set_name(Symbol::ARG_1.ident_string(&env.interns)); + value_ptr1.set_name(Symbol::ARG_2.ident_string(&env.interns)); + value_ptr2.set_name(Symbol::ARG_3.ident_string(&env.interns)); let value_type = basic_type_from_layout(env, layout); let value_ptr_type = value_type.ptr_type(AddressSpace::Generic); diff --git a/compiler/gen/src/llvm/build.rs b/compiler/gen/src/llvm/build.rs index 8270705787..391744aaaa 100644 --- a/compiler/gen/src/llvm/build.rs +++ b/compiler/gen/src/llvm/build.rs @@ -18,7 +18,7 @@ use crate::llvm::build_str::{ use crate::llvm::compare::{generic_eq, generic_neq}; use crate::llvm::convert::{ basic_type_from_builtin, basic_type_from_layout, block_of_memory, block_of_memory_slices, - get_fn_type, get_ptr_type, ptr_int, + get_ptr_type, ptr_int, }; use crate::llvm::refcounting::{ decrement_refcount_layout, increment_refcount_layout, PointerToRefcount, @@ -35,7 +35,7 @@ use inkwell::debug_info::{ use inkwell::memory_buffer::MemoryBuffer; use inkwell::module::{Linkage, Module}; use inkwell::passes::{PassManager, PassManagerBuilder}; -use inkwell::types::{BasicTypeEnum, FunctionType, IntType, StructType}; +use inkwell::types::{BasicType, BasicTypeEnum, FunctionType, IntType, StructType}; use inkwell::values::BasicValueEnum::{self, *}; use inkwell::values::{ BasicValue, CallSiteValue, FloatValue, FunctionValue, InstructionOpcode, InstructionValue, @@ -859,7 +859,6 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( layout: &Layout<'a>, expr: &roc_mono::ir::Expr<'a>, ) -> BasicValueEnum<'ctx> { - use inkwell::types::BasicType; use roc_mono::ir::Expr::*; match expr { @@ -2323,8 +2322,6 @@ pub fn complex_bitcast<'ctx>( to_type: BasicTypeEnum<'ctx>, name: &str, ) -> BasicValueEnum<'ctx> { - use inkwell::types::BasicType; - // builder.build_bitcast(from_value, to_type, "cast_basic_basic") // because this does not allow some (valid) bitcasts @@ -2636,18 +2633,6 @@ fn build_switch_ir<'a, 'ctx, 'env>( } } -/// TODO could this be added to Inkwell itself as a method on BasicValueEnum? -pub fn set_name(bv_enum: BasicValueEnum<'_>, name: &str) { - match bv_enum { - ArrayValue(val) => val.set_name(name), - IntValue(val) => val.set_name(name), - FloatValue(val) => val.set_name(name), - PointerValue(val) => val.set_name(name), - StructValue(val) => val.set_name(name), - VectorValue(val) => val.set_name(name), - } -} - /// Creates a new stack allocation instruction in the entry block of the function. pub fn create_entry_block_alloca<'a, 'ctx>( env: &Env<'a, 'ctx, '_>, @@ -2681,8 +2666,6 @@ fn expose_function_to_host_help<'a, 'ctx, 'env>( roc_function: FunctionValue<'ctx>, c_function_name: &str, ) -> FunctionValue<'ctx> { - use inkwell::types::BasicType; - let roc_wrapper_function = make_exception_catcher(env, roc_function); let roc_function_type = roc_wrapper_function.get_type(); @@ -3019,7 +3002,7 @@ pub fn build_proc_header<'a, 'ctx, 'env>( arg_basic_types.push(arg_type); } - let fn_type = get_fn_type(&ret_type, &arg_basic_types); + let fn_type = ret_type.fn_type(&arg_basic_types, false); let fn_val = add_func( env.module, @@ -3048,8 +3031,6 @@ pub fn build_closure_caller<'a, 'ctx, 'env>( lambda_set: LambdaSet<'a>, result: &Layout<'a>, ) { - use inkwell::types::BasicType; - let context = &env.context; let builder = env.builder; @@ -3143,8 +3124,6 @@ fn build_function_caller<'a, 'ctx, 'env>( arguments: &[Layout<'a>], result: &Layout<'a>, ) { - use inkwell::types::BasicType; - let context = &env.context; let builder = env.builder; @@ -3305,7 +3284,6 @@ fn build_host_exposed_alias_size_help<'a, 'ctx, 'env>( builder.position_at_end(entry); - use inkwell::types::BasicType; let size: BasicValueEnum = basic_type.size_of().unwrap().into(); builder.build_return(Some(&size)); } @@ -3377,7 +3355,7 @@ pub fn build_proc<'a, 'ctx, 'env>( // Add args to scope for (arg_val, (layout, arg_symbol)) in fn_val.get_param_iter().zip(args) { - set_name(arg_val, arg_symbol.ident_string(&env.interns)); + arg_val.set_name(arg_symbol.ident_string(&env.interns)); scope.insert(*arg_symbol, (*layout, arg_val)); } @@ -4732,7 +4710,7 @@ fn build_foreign_symbol_return_result<'a, 'ctx, 'env>( arg_types.push(arg_type); } - let function_type = get_fn_type(&return_type, &arg_types); + let function_type = return_type.fn_type(&arg_types, false); let function = get_foreign_symbol(env, foreign.clone(), function_type); (function, arg_vals.into_bump_slice()) diff --git a/compiler/gen/src/llvm/build_dict.rs b/compiler/gen/src/llvm/build_dict.rs index d95a557ad5..e27ef9e867 100644 --- a/compiler/gen/src/llvm/build_dict.rs +++ b/compiler/gen/src/llvm/build_dict.rs @@ -3,14 +3,14 @@ use crate::llvm::bitcode::{ build_dec_wrapper, build_eq_wrapper, build_inc_wrapper, call_bitcode_fn, call_void_bitcode_fn, }; use crate::llvm::build::{ - complex_bitcast, load_symbol, load_symbol_and_layout, set_name, Env, RocFunctionCall, Scope, + complex_bitcast, load_symbol, load_symbol_and_layout, Env, RocFunctionCall, Scope, }; use crate::llvm::build_list::{layout_width, pass_as_opaque}; use crate::llvm::convert::{as_const_zero, basic_type_from_layout}; use crate::llvm::refcounting::Mode; use inkwell::attributes::{Attribute, AttributeLoc}; use inkwell::types::BasicType; -use inkwell::values::{BasicValueEnum, FunctionValue, StructValue}; +use inkwell::values::{BasicValue, BasicValueEnum, FunctionValue, StructValue}; use inkwell::AddressSpace; use roc_builtins::bitcode; use roc_module::symbol::Symbol; @@ -836,8 +836,8 @@ fn build_hash_wrapper<'a, 'ctx, 'env>( let seed_arg = it.next().unwrap().into_int_value(); let value_ptr = it.next().unwrap().into_pointer_value(); - set_name(seed_arg.into(), Symbol::ARG_1.ident_string(&env.interns)); - set_name(value_ptr.into(), Symbol::ARG_2.ident_string(&env.interns)); + seed_arg.set_name(Symbol::ARG_1.ident_string(&env.interns)); + value_ptr.set_name(Symbol::ARG_2.ident_string(&env.interns)); let value_type = basic_type_from_layout(env, layout).ptr_type(AddressSpace::Generic); diff --git a/compiler/gen/src/llvm/build_hash.rs b/compiler/gen/src/llvm/build_hash.rs index 195ff1f30e..d72b02cad5 100644 --- a/compiler/gen/src/llvm/build_hash.rs +++ b/compiler/gen/src/llvm/build_hash.rs @@ -1,11 +1,13 @@ use crate::debug_info_init; use crate::llvm::bitcode::call_bitcode_fn; use crate::llvm::build::Env; -use crate::llvm::build::{cast_block_of_memory_to_tag, complex_bitcast, set_name, FAST_CALL_CONV}; +use crate::llvm::build::{cast_block_of_memory_to_tag, complex_bitcast, FAST_CALL_CONV}; use crate::llvm::build_str; use crate::llvm::convert::basic_type_from_layout; use bumpalo::collections::Vec; -use inkwell::values::{BasicValueEnum, FunctionValue, IntValue, PointerValue, StructValue}; +use inkwell::values::{ + BasicValue, BasicValueEnum, FunctionValue, IntValue, PointerValue, StructValue, +}; use roc_builtins::bitcode; use roc_module::symbol::Symbol; use roc_mono::layout::{Builtin, Layout, LayoutIds, UnionLayout}; @@ -232,8 +234,8 @@ fn build_hash_struct_help<'a, 'ctx, 'env>( let seed = it.next().unwrap().into_int_value(); let value = it.next().unwrap().into_struct_value(); - set_name(seed.into(), Symbol::ARG_1.ident_string(&env.interns)); - set_name(value.into(), Symbol::ARG_2.ident_string(&env.interns)); + seed.set_name(Symbol::ARG_1.ident_string(&env.interns)); + value.set_name(Symbol::ARG_2.ident_string(&env.interns)); let entry = ctx.append_basic_block(parent, "entry"); env.builder.position_at_end(entry); @@ -373,8 +375,8 @@ fn build_hash_tag_help<'a, 'ctx, 'env>( let seed = it.next().unwrap().into_int_value(); let value = it.next().unwrap(); - set_name(seed.into(), Symbol::ARG_1.ident_string(&env.interns)); - set_name(value, Symbol::ARG_2.ident_string(&env.interns)); + seed.set_name(Symbol::ARG_1.ident_string(&env.interns)); + value.set_name(Symbol::ARG_2.ident_string(&env.interns)); let entry = ctx.append_basic_block(parent, "entry"); env.builder.position_at_end(entry); @@ -653,8 +655,8 @@ fn build_hash_list_help<'a, 'ctx, 'env>( let seed = it.next().unwrap().into_int_value(); let value = it.next().unwrap().into_struct_value(); - set_name(seed.into(), Symbol::ARG_1.ident_string(&env.interns)); - set_name(value.into(), Symbol::ARG_2.ident_string(&env.interns)); + seed.set_name(Symbol::ARG_1.ident_string(&env.interns)); + value.set_name(Symbol::ARG_2.ident_string(&env.interns)); let entry = ctx.append_basic_block(parent, "entry"); env.builder.position_at_end(entry); diff --git a/compiler/gen/src/llvm/compare.rs b/compiler/gen/src/llvm/compare.rs index 7f9cf127dd..e9b36f7505 100644 --- a/compiler/gen/src/llvm/compare.rs +++ b/compiler/gen/src/llvm/compare.rs @@ -1,10 +1,12 @@ use crate::llvm::build::Env; -use crate::llvm::build::{cast_block_of_memory_to_tag, complex_bitcast, set_name, FAST_CALL_CONV}; +use crate::llvm::build::{cast_block_of_memory_to_tag, complex_bitcast, FAST_CALL_CONV}; use crate::llvm::build_list::{list_len, load_list_ptr}; use crate::llvm::build_str::str_equal; use crate::llvm::convert::{basic_type_from_layout, get_ptr_type}; use bumpalo::collections::Vec; -use inkwell::values::{BasicValueEnum, FunctionValue, IntValue, PointerValue, StructValue}; +use inkwell::values::{ + BasicValue, BasicValueEnum, FunctionValue, IntValue, PointerValue, StructValue, +}; use inkwell::{AddressSpace, FloatPredicate, IntPredicate}; use roc_module::symbol::Symbol; use roc_mono::layout::{Builtin, Layout, LayoutIds, UnionLayout}; @@ -428,8 +430,8 @@ fn build_list_eq_help<'a, 'ctx, 'env>( let list1 = it.next().unwrap().into_struct_value(); let list2 = it.next().unwrap().into_struct_value(); - set_name(list1.into(), Symbol::ARG_1.ident_string(&env.interns)); - set_name(list2.into(), Symbol::ARG_2.ident_string(&env.interns)); + list1.set_name(Symbol::ARG_1.ident_string(&env.interns)); + list2.set_name(Symbol::ARG_2.ident_string(&env.interns)); let entry = ctx.append_basic_block(parent, "entry"); env.builder.position_at_end(entry); @@ -636,8 +638,8 @@ fn build_struct_eq_help<'a, 'ctx, 'env>( let struct1 = it.next().unwrap().into_struct_value(); let struct2 = it.next().unwrap().into_struct_value(); - set_name(struct1.into(), Symbol::ARG_1.ident_string(&env.interns)); - set_name(struct2.into(), Symbol::ARG_2.ident_string(&env.interns)); + struct1.set_name(Symbol::ARG_1.ident_string(&env.interns)); + struct2.set_name(Symbol::ARG_2.ident_string(&env.interns)); let entry = ctx.append_basic_block(parent, "entry"); let start = ctx.append_basic_block(parent, "start"); @@ -817,8 +819,8 @@ fn build_tag_eq_help<'a, 'ctx, 'env>( let tag1 = it.next().unwrap(); let tag2 = it.next().unwrap(); - set_name(tag1, Symbol::ARG_1.ident_string(&env.interns)); - set_name(tag2, Symbol::ARG_2.ident_string(&env.interns)); + tag1.set_name(Symbol::ARG_1.ident_string(&env.interns)); + tag2.set_name(Symbol::ARG_2.ident_string(&env.interns)); let entry = ctx.append_basic_block(parent, "entry"); diff --git a/compiler/gen/src/llvm/convert.rs b/compiler/gen/src/llvm/convert.rs index c88c12c18b..b61f7bfcfc 100644 --- a/compiler/gen/src/llvm/convert.rs +++ b/compiler/gen/src/llvm/convert.rs @@ -1,7 +1,7 @@ use bumpalo::collections::Vec; use inkwell::context::Context; use inkwell::types::BasicTypeEnum::{self, *}; -use inkwell::types::{ArrayType, BasicType, FunctionType, IntType, PointerType, StructType}; +use inkwell::types::{ArrayType, BasicType, IntType, PointerType, StructType}; use inkwell::values::BasicValueEnum; use inkwell::AddressSpace; use roc_mono::layout::{Builtin, Layout, UnionLayout}; @@ -21,21 +21,6 @@ pub fn get_ptr_type<'ctx>( } } -/// TODO could this be added to Inkwell itself as a method on BasicValueEnum? -pub fn get_fn_type<'ctx>( - bt_enum: &BasicTypeEnum<'ctx>, - arg_types: &[BasicTypeEnum<'ctx>], -) -> FunctionType<'ctx> { - match bt_enum { - ArrayType(typ) => typ.fn_type(arg_types, false), - IntType(typ) => typ.fn_type(arg_types, false), - FloatType(typ) => typ.fn_type(arg_types, false), - PointerType(typ) => typ.fn_type(arg_types, false), - StructType(typ) => typ.fn_type(arg_types, false), - VectorType(typ) => typ.fn_type(arg_types, false), - } -} - /// TODO could this be added to Inkwell itself as a method on BasicValueEnum? pub fn get_array_type<'ctx>(bt_enum: &BasicTypeEnum<'ctx>, size: u32) -> ArrayType<'ctx> { match bt_enum { @@ -77,7 +62,7 @@ fn basic_type_from_function_layout<'a, 'ctx, 'env>( arg_basic_types.push(closure); } - let fn_type = get_fn_type(&ret_type, arg_basic_types.into_bump_slice()); + let fn_type = ret_type.fn_type(arg_basic_types.into_bump_slice(), false); let ptr_type = fn_type.ptr_type(AddressSpace::Generic); ptr_type.as_basic_type_enum() diff --git a/compiler/gen/src/llvm/externs.rs b/compiler/gen/src/llvm/externs.rs index 2bb2a01c6e..48bea9283b 100644 --- a/compiler/gen/src/llvm/externs.rs +++ b/compiler/gen/src/llvm/externs.rs @@ -1,8 +1,9 @@ -use crate::llvm::build::{add_func, set_name, C_CALL_CONV}; +use crate::llvm::build::{add_func, C_CALL_CONV}; use crate::llvm::convert::ptr_int; use inkwell::builder::Builder; use inkwell::context::Context; use inkwell::module::{Linkage, Module}; +use inkwell::values::BasicValue; use inkwell::AddressSpace; /// Define functions for roc_alloc, roc_realloc, and roc_dealloc @@ -69,8 +70,8 @@ pub fn add_default_roc_externs<'ctx>( debug_assert!(params.next().is_none()); - set_name(ptr_arg, "ptr"); - set_name(size_arg, "size"); + ptr_arg.set_name("ptr"); + size_arg.set_name("size"); if cfg!(debug_assertions) { crate::llvm::build::verify_fn(fn_val); diff --git a/compiler/gen/src/llvm/refcounting.rs b/compiler/gen/src/llvm/refcounting.rs index 71c309f8b4..cb1fa0a5a5 100644 --- a/compiler/gen/src/llvm/refcounting.rs +++ b/compiler/gen/src/llvm/refcounting.rs @@ -1,6 +1,6 @@ use crate::debug_info_init; use crate::llvm::build::{ - add_func, cast_basic_basic, cast_block_of_memory_to_tag, set_name, Env, FAST_CALL_CONV, + add_func, cast_basic_basic, cast_block_of_memory_to_tag, Env, FAST_CALL_CONV, LLVM_SADD_WITH_OVERFLOW_I64, }; use crate::llvm::build_list::{incrementing_elem_loop, list_len, load_list}; @@ -11,7 +11,9 @@ use bumpalo::collections::Vec; use inkwell::context::Context; use inkwell::module::Linkage; use inkwell::types::{AnyTypeEnum, BasicType, BasicTypeEnum}; -use inkwell::values::{BasicValueEnum, FunctionValue, IntValue, PointerValue, StructValue}; +use inkwell::values::{ + BasicValue, BasicValueEnum, FunctionValue, IntValue, PointerValue, StructValue, +}; use inkwell::{AddressSpace, IntPredicate}; use roc_module::symbol::Interns; use roc_module::symbol::Symbol; @@ -390,7 +392,7 @@ fn modify_refcount_struct_help<'a, 'ctx, 'env>( let arg_symbol = Symbol::ARG_1; let arg_val = fn_val.get_param_iter().next().unwrap(); - set_name(arg_val, arg_symbol.ident_string(&env.interns)); + arg_val.set_name(arg_symbol.ident_string(&env.interns)); let parent = fn_val; @@ -821,7 +823,7 @@ fn modify_refcount_list_help<'a, 'ctx, 'env>( let arg_symbol = Symbol::ARG_1; let arg_val = fn_val.get_param_iter().next().unwrap(); - set_name(arg_val, arg_symbol.ident_string(&env.interns)); + arg_val.set_name(arg_symbol.ident_string(&env.interns)); let parent = fn_val; let original_wrapper = arg_val.into_struct_value(); @@ -940,7 +942,7 @@ fn modify_refcount_str_help<'a, 'ctx, 'env>( let arg_symbol = Symbol::ARG_1; let arg_val = fn_val.get_param_iter().next().unwrap(); - set_name(arg_val, arg_symbol.ident_string(&env.interns)); + arg_val.set_name(arg_symbol.ident_string(&env.interns)); let parent = fn_val; @@ -1059,7 +1061,7 @@ fn modify_refcount_dict_help<'a, 'ctx, 'env>( let arg_symbol = Symbol::ARG_1; let arg_val = fn_val.get_param_iter().next().unwrap(); - set_name(arg_val, arg_symbol.ident_string(&env.interns)); + arg_val.set_name(arg_symbol.ident_string(&env.interns)); let parent = fn_val; @@ -1270,7 +1272,7 @@ fn build_rec_union_help<'a, 'ctx, 'env>( let arg_val = fn_val.get_param_iter().next().unwrap(); - set_name(arg_val, arg_symbol.ident_string(&env.interns)); + arg_val.set_name(arg_symbol.ident_string(&env.interns)); let parent = fn_val; @@ -1565,7 +1567,7 @@ fn modify_refcount_union_help<'a, 'ctx, 'env>( let arg_symbol = Symbol::ARG_1; let arg_val = fn_val.get_param_iter().next().unwrap(); - set_name(arg_val, arg_symbol.ident_string(&env.interns)); + arg_val.set_name(arg_symbol.ident_string(&env.interns)); let parent = fn_val; From 05d94e5c5f9a077214a2cb5bff85bdcdc70e5727 Mon Sep 17 00:00:00 2001 From: Folkert Date: Tue, 1 Jun 2021 22:38:11 +0200 Subject: [PATCH 069/496] ptr type --- compiler/gen/src/llvm/build.rs | 4 ++-- compiler/gen/src/llvm/build_list.rs | 8 ++++---- compiler/gen/src/llvm/compare.rs | 7 +++---- compiler/gen/src/llvm/convert.rs | 29 +---------------------------- 4 files changed, 10 insertions(+), 38 deletions(-) diff --git a/compiler/gen/src/llvm/build.rs b/compiler/gen/src/llvm/build.rs index 391744aaaa..cc1c64a6c9 100644 --- a/compiler/gen/src/llvm/build.rs +++ b/compiler/gen/src/llvm/build.rs @@ -18,7 +18,7 @@ use crate::llvm::build_str::{ use crate::llvm::compare::{generic_eq, generic_neq}; use crate::llvm::convert::{ basic_type_from_builtin, basic_type_from_layout, block_of_memory, block_of_memory_slices, - get_ptr_type, ptr_int, + ptr_int, }; use crate::llvm::refcounting::{ decrement_refcount_layout, increment_refcount_layout, PointerToRefcount, @@ -1713,7 +1713,7 @@ pub fn allocate_with_refcount_help<'a, 'ctx, 'env>( let index_intvalue = int_type.const_int(index, false); - let ptr_type = get_ptr_type(&value_type, AddressSpace::Generic); + let ptr_type = value_type.ptr_type(AddressSpace::Generic); unsafe { builder diff --git a/compiler/gen/src/llvm/build_list.rs b/compiler/gen/src/llvm/build_list.rs index fbed8c99a1..cf2044a8d0 100644 --- a/compiler/gen/src/llvm/build_list.rs +++ b/compiler/gen/src/llvm/build_list.rs @@ -6,11 +6,11 @@ use crate::llvm::bitcode::{ use crate::llvm::build::{ allocate_with_refcount_help, cast_basic_basic, complex_bitcast, Env, RocFunctionCall, }; -use crate::llvm::convert::{basic_type_from_layout, get_ptr_type}; +use crate::llvm::convert::basic_type_from_layout; use crate::llvm::refcounting::increment_refcount_layout; use inkwell::builder::Builder; use inkwell::context::Context; -use inkwell::types::{BasicTypeEnum, PointerType}; +use inkwell::types::{BasicType, BasicTypeEnum, PointerType}; use inkwell::values::{BasicValueEnum, FunctionValue, IntValue, PointerValue, StructValue}; use inkwell::{AddressSpace, IntPredicate}; use roc_builtins::bitcode; @@ -135,7 +135,7 @@ pub fn list_prepend<'a, 'ctx, 'env>( // Load the usize length from the wrapper. let len = list_len(builder, original_wrapper); let elem_type = basic_type_from_layout(env, elem_layout); - let ptr_type = get_ptr_type(&elem_type, AddressSpace::Generic); + let ptr_type = elem_type.ptr_type(AddressSpace::Generic); let list_ptr = load_list_ptr(builder, original_wrapper, ptr_type); // The output list length, which is the old list length + 1 @@ -260,7 +260,7 @@ pub fn list_get_unsafe<'a, 'ctx, 'env>( match list_layout { Layout::Builtin(Builtin::List(elem_layout)) => { let elem_type = basic_type_from_layout(env, elem_layout); - let ptr_type = get_ptr_type(&elem_type, AddressSpace::Generic); + let ptr_type = elem_type.ptr_type(AddressSpace::Generic); // Load the pointer to the array data let array_data_ptr = load_list_ptr(builder, wrapper_struct, ptr_type); diff --git a/compiler/gen/src/llvm/compare.rs b/compiler/gen/src/llvm/compare.rs index e9b36f7505..fa0185f01e 100644 --- a/compiler/gen/src/llvm/compare.rs +++ b/compiler/gen/src/llvm/compare.rs @@ -2,8 +2,9 @@ use crate::llvm::build::Env; use crate::llvm::build::{cast_block_of_memory_to_tag, complex_bitcast, FAST_CALL_CONV}; use crate::llvm::build_list::{list_len, load_list_ptr}; use crate::llvm::build_str::str_equal; -use crate::llvm::convert::{basic_type_from_layout, get_ptr_type}; +use crate::llvm::convert::basic_type_from_layout; use bumpalo::collections::Vec; +use inkwell::types::BasicType; use inkwell::values::{ BasicValue, BasicValueEnum, FunctionValue, IntValue, PointerValue, StructValue, }; @@ -459,7 +460,7 @@ fn build_list_eq_help<'a, 'ctx, 'env>( let builder = env.builder; let element_type = basic_type_from_layout(env, element_layout); - let ptr_type = get_ptr_type(&element_type, AddressSpace::Generic); + let ptr_type = element_type.ptr_type(AddressSpace::Generic); let ptr1 = load_list_ptr(env.builder, list1, ptr_type); let ptr2 = load_list_ptr(env.builder, list2, ptr_type); @@ -1166,8 +1167,6 @@ fn eq_ptr_to_struct<'a, 'ctx, 'env>( tag1: PointerValue<'ctx>, tag2: PointerValue<'ctx>, ) -> IntValue<'ctx> { - use inkwell::types::BasicType; - let struct_layout = Layout::Struct(field_layouts); let wrapper_type = basic_type_from_layout(env, &struct_layout); diff --git a/compiler/gen/src/llvm/convert.rs b/compiler/gen/src/llvm/convert.rs index b61f7bfcfc..d8c4c68732 100644 --- a/compiler/gen/src/llvm/convert.rs +++ b/compiler/gen/src/llvm/convert.rs @@ -1,38 +1,11 @@ use bumpalo::collections::Vec; use inkwell::context::Context; use inkwell::types::BasicTypeEnum::{self, *}; -use inkwell::types::{ArrayType, BasicType, IntType, PointerType, StructType}; +use inkwell::types::{BasicType, IntType, StructType}; use inkwell::values::BasicValueEnum; use inkwell::AddressSpace; use roc_mono::layout::{Builtin, Layout, UnionLayout}; -/// TODO could this be added to Inkwell itself as a method on BasicValueEnum? -pub fn get_ptr_type<'ctx>( - bt_enum: &BasicTypeEnum<'ctx>, - address_space: AddressSpace, -) -> PointerType<'ctx> { - match bt_enum { - ArrayType(typ) => typ.ptr_type(address_space), - IntType(typ) => typ.ptr_type(address_space), - FloatType(typ) => typ.ptr_type(address_space), - PointerType(typ) => typ.ptr_type(address_space), - StructType(typ) => typ.ptr_type(address_space), - VectorType(typ) => typ.ptr_type(address_space), - } -} - -/// TODO could this be added to Inkwell itself as a method on BasicValueEnum? -pub fn get_array_type<'ctx>(bt_enum: &BasicTypeEnum<'ctx>, size: u32) -> ArrayType<'ctx> { - match bt_enum { - ArrayType(typ) => typ.array_type(size), - IntType(typ) => typ.array_type(size), - FloatType(typ) => typ.array_type(size), - PointerType(typ) => typ.array_type(size), - StructType(typ) => typ.array_type(size), - VectorType(typ) => typ.array_type(size), - } -} - /// TODO could this be added to Inkwell itself as a method on BasicValueEnum? pub fn as_const_zero<'ctx>(bt_enum: &BasicTypeEnum<'ctx>) -> BasicValueEnum<'ctx> { match bt_enum { From 29944589c87ce6c248cd5f2c93fc743d9de1b2ab Mon Sep 17 00:00:00 2001 From: Folkert Date: Tue, 1 Jun 2021 22:38:42 +0200 Subject: [PATCH 070/496] const zero --- compiler/gen/src/llvm/build_dict.rs | 4 ++-- compiler/gen/src/llvm/convert.rs | 16 +--------------- 2 files changed, 3 insertions(+), 17 deletions(-) diff --git a/compiler/gen/src/llvm/build_dict.rs b/compiler/gen/src/llvm/build_dict.rs index e27ef9e867..7b818ed41c 100644 --- a/compiler/gen/src/llvm/build_dict.rs +++ b/compiler/gen/src/llvm/build_dict.rs @@ -6,7 +6,7 @@ use crate::llvm::build::{ complex_bitcast, load_symbol, load_symbol_and_layout, Env, RocFunctionCall, Scope, }; use crate::llvm::build_list::{layout_width, pass_as_opaque}; -use crate::llvm::convert::{as_const_zero, basic_type_from_layout}; +use crate::llvm::convert::basic_type_from_layout; use crate::llvm::refcounting::Mode; use inkwell::attributes::{Attribute, AttributeLoc}; use inkwell::types::BasicType; @@ -326,7 +326,7 @@ pub fn dict_get<'a, 'ctx, 'env>( let done_block = env.context.append_basic_block(parent, "done"); let value_bt = basic_type_from_layout(env, value_layout); - let default = as_const_zero(&value_bt); + let default = value_bt.const_zero(); env.builder .build_conditional_branch(flag, if_not_null, done_block); diff --git a/compiler/gen/src/llvm/convert.rs b/compiler/gen/src/llvm/convert.rs index d8c4c68732..124ad9ca50 100644 --- a/compiler/gen/src/llvm/convert.rs +++ b/compiler/gen/src/llvm/convert.rs @@ -1,23 +1,9 @@ use bumpalo::collections::Vec; use inkwell::context::Context; -use inkwell::types::BasicTypeEnum::{self, *}; -use inkwell::types::{BasicType, IntType, StructType}; -use inkwell::values::BasicValueEnum; +use inkwell::types::{BasicType, BasicTypeEnum, IntType, StructType}; use inkwell::AddressSpace; use roc_mono::layout::{Builtin, Layout, UnionLayout}; -/// TODO could this be added to Inkwell itself as a method on BasicValueEnum? -pub fn as_const_zero<'ctx>(bt_enum: &BasicTypeEnum<'ctx>) -> BasicValueEnum<'ctx> { - match bt_enum { - ArrayType(typ) => typ.const_zero().into(), - IntType(typ) => typ.const_zero().into(), - FloatType(typ) => typ.const_zero().into(), - PointerType(typ) => typ.const_zero().into(), - StructType(typ) => typ.const_zero().into(), - VectorType(typ) => typ.const_zero().into(), - } -} - fn basic_type_from_function_layout<'a, 'ctx, 'env>( env: &crate::llvm::build::Env<'a, 'ctx, 'env>, args: &[Layout<'_>], From d57277de4b7c108f626a54b4506cdea2755765bd Mon Sep 17 00:00:00 2001 From: rvcas Date: Tue, 1 Jun 2021 19:11:09 -0400 Subject: [PATCH 071/496] fix: RocDec tests * try in tests starts in 0.8.0 not 0.7.1 * needed an @intCast in fromU64 * removed if statements in test cases in favor of checking null equality and unwrapping the optional --- compiler/builtins/bitcode/src/dec.zig | 84 +++++++++++---------------- 1 file changed, 34 insertions(+), 50 deletions(-) diff --git a/compiler/builtins/bitcode/src/dec.zig b/compiler/builtins/bitcode/src/dec.zig index ba6041899a..138d60d7a8 100644 --- a/compiler/builtins/bitcode/src/dec.zig +++ b/compiler/builtins/bitcode/src/dec.zig @@ -1,4 +1,5 @@ const std = @import("std"); + const math = std.math; pub const RocDec = struct { @@ -13,7 +14,7 @@ pub const RocDec = struct { pub const one_point_zero: comptime RocDec = .{ .num = one_point_zero_i128 }; pub fn fromU64(num: u64) RocDec { - return .{ .num = num * one_point_zero_i128 }; + return .{ .num = @intCast(i128, num) * one_point_zero_i128 }; } pub fn fromString(bytes_ptr: [*]const u8, length: usize) ?RocDec { @@ -310,118 +311,101 @@ fn mul_u128(a: u128, b: u128) U256 { return .{ .hi = hi, .lo = lo }; } -const one_e20: i256 = 100000000000000000000; - const testing = std.testing; const expectEqual = testing.expectEqual; test "fromU64" { var dec = RocDec.fromU64(25); - try expectEqual(RocDec{ .num = 25000000000000000000 }, dec); + + expectEqual(RocDec{ .num = 25000000000000000000 }, dec); } test "fromString: empty" { var dec = RocDec.fromString("", 0); - if (dec) |_| { - unreachable; - } + + expectEqual(dec, null); } test "fromString: 0" { var dec = RocDec.fromString("0", 1); - if (dec) |d| { - try expectEqual(RocDec{ .num = 0 }, d); - } else { - unreachable; - } + + expectEqual(RocDec{ .num = 0 }, dec.?); } test "fromString: 1" { var dec = RocDec.fromString("1", 1); - if (dec) |d| { - try expectEqual(RocDec.one_point_zero, d); - } else { - unreachable; - } + + expectEqual(RocDec.one_point_zero, dec.?); } test "fromString: 123.45" { var dec = RocDec.fromString("123.45", 6); - if (dec) |d| { - try expectEqual(RocDec{ .num = 123450000000000000000 }, d); - } else { - unreachable; - } + + expectEqual(RocDec{ .num = 123450000000000000000 }, dec.?); } test "fromString: .45" { var dec = RocDec.fromString(".45", 3); - if (dec) |d| { - try expectEqual(RocDec{ .num = 450000000000000000 }, d); - } else { - unreachable; - } + + expectEqual(RocDec{ .num = 450000000000000000 }, dec.?); } test "fromString: 123" { var dec = RocDec.fromString("123", 3); - if (dec) |d| { - try expectEqual(RocDec{ .num = 123000000000000000000 }, d); - } else { - unreachable; - } + + expectEqual(RocDec{ .num = 123000000000000000000 }, dec.?); } test "fromString: abc" { var dec = RocDec.fromString("abc", 3); - if (dec) |_| { - unreachable; - } + + expectEqual(dec, null); } test "fromString: 123.abc" { var dec = RocDec.fromString("123.abc", 7); - if (dec) |_| { - unreachable; - } + + expectEqual(dec, null); } test "fromString: abc.123" { var dec = RocDec.fromString("abc.123", 7); - if (dec) |_| { - unreachable; - } + + expectEqual(dec, null); } test "fromString: .123.1" { var dec = RocDec.fromString(".123.1", 6); - if (dec) |d| { - std.debug.print("d: {}", .{d}); - unreachable; - } + + expectEqual(dec, null); } test "add: 0" { var dec: RocDec = .{ .num = 0 }; - try expectEqual(RocDec{ .num = 0 }, dec.add(.{ .num = 0 })); + + expectEqual(RocDec{ .num = 0 }, dec.add(.{ .num = 0 })); } test "add: 1" { var dec: RocDec = .{ .num = 0 }; - try expectEqual(RocDec{ .num = 1 }, dec.add(.{ .num = 1 })); + + expectEqual(RocDec{ .num = 1 }, dec.add(.{ .num = 1 })); } test "mul: by 0" { var dec: RocDec = .{ .num = 0 }; - try expectEqual(RocDec{ .num = 0 }, dec.mul(.{ .num = 0 })); + + expectEqual(RocDec{ .num = 0 }, dec.mul(.{ .num = 0 })); } test "mul: by 1" { var dec: RocDec = RocDec.fromU64(15); - try expectEqual(RocDec.fromU64(15), dec.mul(RocDec.fromU64(1))); + + expectEqual(RocDec.fromU64(15), dec.mul(RocDec.fromU64(1))); } test "mul: by 2" { var dec: RocDec = RocDec.fromU64(15); - try expectEqual(RocDec.fromU64(30), dec.mul(RocDec.fromU64(2))); + + expectEqual(RocDec.fromU64(30), dec.mul(RocDec.fromU64(2))); } From 76e6daad50eda92c8fec7a173dc7a0c008afe068 Mon Sep 17 00:00:00 2001 From: Jared Ramirez Date: Tue, 1 Jun 2021 16:51:28 -0700 Subject: [PATCH 072/496] fix: parsing negatives decimals --- compiler/builtins/bitcode/src/dec.zig | 32 ++++++++++++++++++++++++++- 1 file changed, 31 insertions(+), 1 deletion(-) diff --git a/compiler/builtins/bitcode/src/dec.zig b/compiler/builtins/bitcode/src/dec.zig index 138d60d7a8..19ed55b5d5 100644 --- a/compiler/builtins/bitcode/src/dec.zig +++ b/compiler/builtins/bitcode/src/dec.zig @@ -26,7 +26,7 @@ pub const RocDec = struct { var initial_index: usize = if (is_negative) 1 else 0; var point_index: ?usize = null; - var index: usize = 0; + var index: usize = initial_index; while (index < length) { var byte: u8 = bytes_ptr[index]; if (byte == '.' and point_index == null) { @@ -350,12 +350,42 @@ test "fromString: .45" { expectEqual(RocDec{ .num = 450000000000000000 }, dec.?); } +test "fromString: .45" { + var dec = RocDec.fromString("0.45", 4); + + expectEqual(RocDec{ .num = 450000000000000000 }, dec.?); +} + test "fromString: 123" { var dec = RocDec.fromString("123", 3); expectEqual(RocDec{ .num = 123000000000000000000 }, dec.?); } +test "fromString: -.45" { + var dec = RocDec.fromString("-.45", 4); + + expectEqual(RocDec{ .num = -450000000000000000 }, dec.?); +} + +test "fromString: -0.45" { + var dec = RocDec.fromString("-0.45", 5); + + expectEqual(RocDec{ .num = -450000000000000000 }, dec.?); +} + +test "fromString: -123" { + var dec = RocDec.fromString("-123", 4); + + expectEqual(RocDec{ .num = -123000000000000000000 }, dec.?); +} + +test "fromString: -123.45" { + var dec = RocDec.fromString("-123.45", 7); + + expectEqual(RocDec{ .num = -123450000000000000000 }, dec.?); +} + test "fromString: abc" { var dec = RocDec.fromString("abc", 3); From f6f2a13daa1a945d3313fe0acac8d009f430cb2f Mon Sep 17 00:00:00 2001 From: rvcas Date: Tue, 1 Jun 2021 19:56:21 -0400 Subject: [PATCH 073/496] feat(RocDec): fromString takes RocStr --- compiler/builtins/bitcode/src/dec.zig | 48 ++++++++++++++++++--------- 1 file changed, 32 insertions(+), 16 deletions(-) diff --git a/compiler/builtins/bitcode/src/dec.zig b/compiler/builtins/bitcode/src/dec.zig index 138d60d7a8..de67252da0 100644 --- a/compiler/builtins/bitcode/src/dec.zig +++ b/compiler/builtins/bitcode/src/dec.zig @@ -1,6 +1,8 @@ const std = @import("std"); +const str = @import("str.zig"); const math = std.math; +const RocStr = str.RocStr; pub const RocDec = struct { num: i128, @@ -17,18 +19,22 @@ pub const RocDec = struct { return .{ .num = @intCast(i128, num) * one_point_zero_i128 }; } - pub fn fromString(bytes_ptr: [*]const u8, length: usize) ?RocDec { - if (length == 0) { + pub fn fromString(roc_str: RocStr) ?RocDec { + if (roc_str.isEmpty()) { return null; } - var is_negative: bool = bytes_ptr[0] == '-'; + const length = roc_str.len(); + + const roc_str_slice = roc_str.asSlice(); + + var is_negative: bool = roc_str_slice[0] == '-'; var initial_index: usize = if (is_negative) 1 else 0; var point_index: ?usize = null; var index: usize = 0; while (index < length) { - var byte: u8 = bytes_ptr[index]; + var byte: u8 = roc_str_slice[index]; if (byte == '.' and point_index == null) { point_index = index; index += 1; @@ -52,12 +58,12 @@ pub const RocDec = struct { } var diff_decimal_places = decimal_places - after_str_len; - var after_str = bytes_ptr[pi + 1 .. length]; + var after_str = roc_str_slice[pi + 1 .. length]; var after_u64 = std.fmt.parseUnsigned(u64, after_str, 10) catch null; after_val_i128 = if (after_u64) |f| @intCast(i128, f) * math.pow(i128, 10, diff_decimal_places) else null; } - var before_str = bytes_ptr[initial_index..before_str_length]; + var before_str = roc_str_slice[initial_index..before_str_length]; var before_val_not_adjusted = std.fmt.parseUnsigned(i128, before_str, 10) catch null; var before_val_i128: ?i128 = null; @@ -321,61 +327,71 @@ test "fromU64" { } test "fromString: empty" { - var dec = RocDec.fromString("", 0); + var roc_str = RocStr.init("", 0); + var dec = RocDec.fromString(roc_str); expectEqual(dec, null); } test "fromString: 0" { - var dec = RocDec.fromString("0", 1); + var roc_str = RocStr.init("0", 1); + var dec = RocDec.fromString(roc_str); expectEqual(RocDec{ .num = 0 }, dec.?); } test "fromString: 1" { - var dec = RocDec.fromString("1", 1); + var roc_str = RocStr.init("1", 1); + var dec = RocDec.fromString(roc_str); expectEqual(RocDec.one_point_zero, dec.?); } test "fromString: 123.45" { - var dec = RocDec.fromString("123.45", 6); + var roc_str = RocStr.init("123.45", 6); + var dec = RocDec.fromString(roc_str); expectEqual(RocDec{ .num = 123450000000000000000 }, dec.?); } test "fromString: .45" { - var dec = RocDec.fromString(".45", 3); + var roc_str = RocStr.init(".45", 3); + var dec = RocDec.fromString(roc_str); expectEqual(RocDec{ .num = 450000000000000000 }, dec.?); } test "fromString: 123" { - var dec = RocDec.fromString("123", 3); + var roc_str = RocStr.init("123", 3); + var dec = RocDec.fromString(roc_str); expectEqual(RocDec{ .num = 123000000000000000000 }, dec.?); } test "fromString: abc" { - var dec = RocDec.fromString("abc", 3); + var roc_str = RocStr.init("abc", 3); + var dec = RocDec.fromString(roc_str); expectEqual(dec, null); } test "fromString: 123.abc" { - var dec = RocDec.fromString("123.abc", 7); + var roc_str = RocStr.init("123.abc", 7); + var dec = RocDec.fromString(roc_str); expectEqual(dec, null); } test "fromString: abc.123" { - var dec = RocDec.fromString("abc.123", 7); + var roc_str = RocStr.init("abc.123", 7); + var dec = RocDec.fromString(roc_str); expectEqual(dec, null); } test "fromString: .123.1" { - var dec = RocDec.fromString(".123.1", 6); + var roc_str = RocStr.init(".123.1", 6); + var dec = RocDec.fromString(roc_str); expectEqual(dec, null); } From a046bbe32aa5edf0939a1e18821c62a0eaeb0ee5 Mon Sep 17 00:00:00 2001 From: rvcas Date: Tue, 1 Jun 2021 20:09:10 -0400 Subject: [PATCH 074/496] feat(RocDec): add last few RocStr tests --- compiler/builtins/bitcode/src/dec.zig | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/compiler/builtins/bitcode/src/dec.zig b/compiler/builtins/bitcode/src/dec.zig index 90353877e1..3a6a459ac3 100644 --- a/compiler/builtins/bitcode/src/dec.zig +++ b/compiler/builtins/bitcode/src/dec.zig @@ -361,8 +361,9 @@ test "fromString: .45" { expectEqual(RocDec{ .num = 450000000000000000 }, dec.?); } -test "fromString: .45" { - var dec = RocDec.fromString("0.45", 4); +test "fromString: 0.45" { + var roc_str = RocStr.init("0.45", 4); + var dec = RocDec.fromString(roc_str); expectEqual(RocDec{ .num = 450000000000000000 }, dec.?); } @@ -375,25 +376,29 @@ test "fromString: 123" { } test "fromString: -.45" { - var dec = RocDec.fromString("-.45", 4); + var roc_str = RocStr.init("-.45", 4); + var dec = RocDec.fromString(roc_str); expectEqual(RocDec{ .num = -450000000000000000 }, dec.?); } test "fromString: -0.45" { - var dec = RocDec.fromString("-0.45", 5); + var roc_str = RocStr.init("-0.45", 4); + var dec = RocDec.fromString(roc_str); expectEqual(RocDec{ .num = -450000000000000000 }, dec.?); } test "fromString: -123" { - var dec = RocDec.fromString("-123", 4); + var roc_str = RocStr.init("-123", 4); + var dec = RocDec.fromString(roc_str); expectEqual(RocDec{ .num = -123000000000000000000 }, dec.?); } test "fromString: -123.45" { - var dec = RocDec.fromString("-123.45", 7); + var roc_str = RocStr.init("-123.45", 7); + var dec = RocDec.fromString(roc_str); expectEqual(RocDec{ .num = -123450000000000000000 }, dec.?); } From 13bb94ac244e1b5eabf48fdcd969335d5a2670a8 Mon Sep 17 00:00:00 2001 From: Jared Ramirez Date: Tue, 1 Jun 2021 17:12:47 -0700 Subject: [PATCH 075/496] fix: last failing test --- compiler/builtins/bitcode/src/dec.zig | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/builtins/bitcode/src/dec.zig b/compiler/builtins/bitcode/src/dec.zig index 3a6a459ac3..1d51d4cc83 100644 --- a/compiler/builtins/bitcode/src/dec.zig +++ b/compiler/builtins/bitcode/src/dec.zig @@ -383,7 +383,7 @@ test "fromString: -.45" { } test "fromString: -0.45" { - var roc_str = RocStr.init("-0.45", 4); + var roc_str = RocStr.init("-0.45", 5); var dec = RocDec.fromString(roc_str); expectEqual(RocDec{ .num = -450000000000000000 }, dec.?); From 683bdc6abb8506ef1f783d9b0b2d93ec51c53c7b Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Tue, 1 Jun 2021 22:11:48 -0400 Subject: [PATCH 076/496] Expand on parsing docs a bit --- compiler/builtins/docs/Str.roc | 66 ++++++++++++++++++++++++---------- 1 file changed, 47 insertions(+), 19 deletions(-) diff --git a/compiler/builtins/docs/Str.roc b/compiler/builtins/docs/Str.roc index b8a216d514..0727b68af8 100644 --- a/compiler/builtins/docs/Str.roc +++ b/compiler/builtins/docs/Str.roc @@ -427,24 +427,52 @@ chomp : Str, Str -> Result Str [ Expected [ ExactStr Str ]* Str ]* ## equal to the given [U32], return whatever comes after that code point. chompCodePoint : Str, U32 -> Result Str [ Expected [ ExactCodePoint U32 ]* Str ]* -## If the string begins with digits which can represent a valid #U8, return -## that number along with the rest of the string after the digits. -parseU8 : Str, NumFormat -> Result { val : U8, rest : Str } [ Expected [ NumU8 ]* Str ]* -parseI8 : Str, NumFormat -> Result { val : I8, rest : Str } [ Expected [ NumI8 ]* Str ]* -parseU16 : Str, NumFormat -> Result { val : U16, rest : Str } [ Expected [ NumU16 ]* Str ]* -parseI16 : Str, NumFormat -> Result { val : I16, rest : Str } [ Expected [ NumI16 ]* Str ]* -parseU32 : Str, NumFormat -> Result { val : U32, rest : Str } [ Expected [ NumU32 ]* Str ]* -parseI32 : Str, NumFormat -> Result { val : I32, rest : Str } [ Expected [ NumI32 ]* Str ]* -parseU64 : Str, NumFormat -> Result { val : U64, rest : Str } [ Expected [ NumU64 ]* Str ]* -parseI64 : Str, NumFormat -> Result { val : I64, rest : Str } [ Expected [ NumI64 ]* Str ]* -parseU128 : Str, NumFormat -> Result { val : U128, rest : Str } [ Expected [ NumU128 ]* Str ]* -parseI128 : Str, NumFormat -> Result { val : I128, rest : Str } [ Expected [ NumI128 ]* Str ]* +## If the string represents a valid #U8 number, return that number. +## +## For more advanced options, see [parseU8]. +toU8 : Str -> Result U8 [ InvalidU8 ]* +toI8 : Str -> Result I8 [ InvalidI8 ]* +toU16 : Str -> Result U16 [ InvalidU16 ]* +toI16 : Str -> Result I16 [ InvalidI16 ]* +toU32 : Str -> Result U32 [ InvalidU32 ]* +toI32 : Str -> Result I32 [ InvalidI32 ]* +toU64 : Str -> Result U64 [ InvalidU64 ]* +toI64 : Str -> Result I64 [ InvalidI64 ]* +toU128 : Str -> Result U128 [ InvalidU128 ]* +toI128 : Str -> Result I128 [ InvalidI128 ]* +toF64 : Str -> Result U128 [ InvalidF64 ]* +toF32 : Str -> Result I128 [ InvalidF32 ]* +toDec : Str -> Result Dec [ InvalidDec ]* -parseF64 : Str, NumFormat -> Result { val : U128, rest : Str } [ Expected [ NumF64 ]* Str ]* -parseF32 : Str, NumFormat -> Result { val : I128, rest : Str } [ Expected [ NumF32 ]* Str ]* +## If the string begins with a valid #U8 number, return +## that number along with the rest of the string after it. +parseU8 : Str, NumParseConfig -> Result { val : U8, rest : Str } [ Expected [ NumU8 ]* Str ]* +parseI8 : Str, NumParseConfig -> Result { val : I8, rest : Str } [ Expected [ NumI8 ]* Str ]* +parseU16 : Str, NumParseConfig -> Result { val : U16, rest : Str } [ Expected [ NumU16 ]* Str ]* +parseI16 : Str, NumParseConfig -> Result { val : I16, rest : Str } [ Expected [ NumI16 ]* Str ]* +parseU32 : Str, NumParseConfig -> Result { val : U32, rest : Str } [ Expected [ NumU32 ]* Str ]* +parseI32 : Str, NumParseConfig -> Result { val : I32, rest : Str } [ Expected [ NumI32 ]* Str ]* +parseU64 : Str, NumParseConfig -> Result { val : U64, rest : Str } [ Expected [ NumU64 ]* Str ]* +parseI64 : Str, NumParseConfig -> Result { val : I64, rest : Str } [ Expected [ NumI64 ]* Str ]* +parseU128 : Str, NumParseConfig -> Result { val : U128, rest : Str } [ Expected [ NumU128 ]* Str ]* +parseI128 : Str, NumParseConfig -> Result { val : I128, rest : Str } [ Expected [ NumI128 ]* Str ]* +parseF64 : Str, NumParseConfig -> Result { val : U128, rest : Str } [ Expected [ NumF64 ]* Str ]* +parseF32 : Str, NumParseConfig -> Result { val : I128, rest : Str } [ Expected [ NumF32 ]* Str ]* +parseDec : Str, NumParseConfig -> Result { val : Dec, rest : Str } [ Expected [ NumDec ]* Str ]* -## TODO make this similar to the Num.format argument -## except more flexible - e.g. the policy for whole number separators -## might be to allow them, to require them, or to allow them only every N digits -## (e.g. 3 for thousands, 4 for bits, 2 for hex) -NumFormat : { } +## Notes: +## * You can allow a decimal mark for integers; they'll only parse if the numbers after it are all 0. +## * For `wholeSep`, `Required` has a payload for how many digits (e.g. "required every 3 digits") +## * For `wholeSep`, `Allowed` allows the separator to appear anywhere. +NumParseConfig : + { + base ? [ Decimal, Hexadecimal, Octal, Binary ], + notation ? [ Standard, Scientific, Any ], + decimalMark ? [ Allowed Str, Required Str, Disallowed ], + decimalDigits ? [ Any, AtLeast U16, Exactly U16 ], + wholeDigits ? [ Any, AtLeast U16, Exactly U16 ], + leadingZeroes ? [ Allowed, Disallowed ], + trailingZeroes ? [ Allowed, Disallowed ], + wholeSep ? { mark : Str, policy : [ Allowed, Required U64 ] } + } + -> Str From a622a72cf3acb59765ceb70f59744ffa5098543e Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Wed, 2 Jun 2021 10:52:37 +0200 Subject: [PATCH 077/496] Added Folkert's editor inspiration --- editor/editor-ideas.md | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/editor/editor-ideas.md b/editor/editor-ideas.md index 41ff4dbfff..f17adf94a3 100644 --- a/editor/editor-ideas.md +++ b/editor/editor-ideas.md @@ -41,7 +41,11 @@ Nice collection of research on innovative editors, [link](https://futureofcoding * [Hest](https://ivanish.ca/hest-time-travel/) tool for making highly interactive simulations. * Say you have a failing test that used to work, it would be very valuable to see all code that was changed that was used only by that test. e.g. you have a test `calculate_sum_test` that only uses the function `add`, when the test fails you should be able to see a diff showing only what changed for the function `add`. It would also be great to have a diff of [expression values](https://homepages.cwi.nl/~storm/livelit/images/bret.png) Bret Victor style. An ambitious project would be to suggest or automatically try fixes based on these diffs. -* I think it could be possible to create a minimal reproduction of a program / block of code / code used by a single test. So for a failing unit test I would expect it to extract imports, the platform, types and functions that are necessary to run only that unit test and put them in a standalone roc project. This would be useful for sharing bugs with library+application authors and colleagues, for profiling or debugging with all "clutter" removed. +* I think it could be possible to create a minimal reproduction of a program / block of code / code used by a single test. So for a failing unit test I would expect it to extract imports, the platform, types and functions that are necessary to run only that unit test and put them in a standalone roc project. This would be useful for sharing bugs with library+application authors and colleagues, for profiling or debugging with all "clutter" removed. + +### Cool regular editors + +* [Helix](https://github.com/helix-editor/helix) modal (terminal, for now) editor in rust. Good UX. ### Structured Editing From 7e0575368c125cc7d8f54bf59250f4a3de18687d Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Wed, 2 Jun 2021 11:08:14 +0200 Subject: [PATCH 078/496] Use custom forks for criterion and cargo-criterion, still have web-sys conflict --- Earthfile | 2 +- cli/Cargo.toml | 2 +- cli/cli_utils/Cargo.toml | 2 +- editor/Cargo.toml | 1 - vendor/pretty/Cargo.toml | 2 +- 5 files changed, 4 insertions(+), 5 deletions(-) diff --git a/Earthfile b/Earthfile index 63e754e0c0..3305b222e5 100644 --- a/Earthfile +++ b/Earthfile @@ -39,7 +39,7 @@ install-zig-llvm-valgrind-clippy-rustfmt: # rustfmt RUN rustup component add rustfmt # criterion - RUN cargo install cargo-criterion + RUN cargo install --git https://github.com/Anton-4/cargo-criterion # sccache RUN apt -y install libssl-dev RUN cargo install sccache diff --git a/cli/Cargo.toml b/cli/Cargo.toml index 1555001930..b465842913 100644 --- a/cli/Cargo.toml +++ b/cli/Cargo.toml @@ -77,7 +77,7 @@ quickcheck = "0.8" quickcheck_macros = "0.8" serial_test = "0.5" tempfile = "3.1.0" -criterion = "0.3.4" +criterion = { git = "https://github.com/Anton-4/criterion.rs"} cli_utils = { path = "cli_utils" } # Keep the commented deps, they are commented because they require nightly rust # criterion-perf-events = "0.1.3" diff --git a/cli/cli_utils/Cargo.toml b/cli/cli_utils/Cargo.toml index e9974ca680..d80d17e3c8 100644 --- a/cli/cli_utils/Cargo.toml +++ b/cli/cli_utils/Cargo.toml @@ -15,7 +15,7 @@ roc_collections = { path = "../../compiler/collections" } roc_load = { path = "../../compiler/load" } roc_module = { path = "../../compiler/module" } bumpalo = { version = "3.6.1", features = ["collections"] } -criterion = "0.3.4" +criterion = { git = "https://github.com/Anton-4/criterion.rs"} inlinable_string = "0.1" serde = { version = "1.0", features = ["derive"] } serde-xml-rs = "0.4" diff --git a/editor/Cargo.toml b/editor/Cargo.toml index 76a995d431..856ca08903 100644 --- a/editor/Cargo.toml +++ b/editor/Cargo.toml @@ -60,5 +60,4 @@ pretty_assertions = "0.6" maplit = "1.0.1" quickcheck = "1.0" quickcheck_macros = "1.0" -criterion = "0.3" rand = "0.8.2" diff --git a/vendor/pretty/Cargo.toml b/vendor/pretty/Cargo.toml index 2cc21e09b0..c44d269934 100644 --- a/vendor/pretty/Cargo.toml +++ b/vendor/pretty/Cargo.toml @@ -21,4 +21,4 @@ termcolor = { version = "1.1.0", optional = true } [dev-dependencies] tempfile = "3.1.0" difference = "2" -criterion = "0.3" +criterion = { git = "https://github.com/Anton-4/criterion.rs"} From 93a77f0518339f14a2edb023391bea6bcdf22858 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Wed, 2 Jun 2021 14:36:53 +0200 Subject: [PATCH 079/496] adapted safe-earthly script to be capable of running benchmarks --- .github/workflows/benchmarks.yml | 4 ++-- .github/workflows/ci.yml | 2 +- Cargo.lock | 14 +++++--------- Earthfile | 2 +- ci/{safe-earthly-test-all.sh => safe-earthly.sh} | 10 ++++++++-- 5 files changed, 17 insertions(+), 15 deletions(-) rename ci/{safe-earthly-test-all.sh => safe-earthly.sh} (61%) diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index a57cc10ca0..967db61cc0 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -20,5 +20,5 @@ jobs: - name: Earthly version run: earthly --version - - name: install dependencies, build, cd cli, benchmark with iai and criterion - run: earthly --allow-privileged +bench-roc + - name: install dependencies, build, cd cli, benchmark with criterion + run: ./ci/safe-earthly.sh +bench-roc diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 5c83ca27c3..413c22db1b 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -21,5 +21,5 @@ jobs: run: earthly --version - name: install dependencies, build, run zig tests, rustfmt, clippy, cargo test --release - run: ./ci/safe-earthly-test-all.sh + run: ./ci/safe-earthly.sh +test-all diff --git a/Cargo.lock b/Cargo.lock index 07756f9235..24673ca5f9 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -626,9 +626,8 @@ dependencies = [ [[package]] name = "criterion" -version = "0.3.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ab327ed7354547cc2ef43cbe20ef68b988e70b4b593cbd66a2a61733123a3d23" +version = "0.3.5" +source = "git+https://github.com/Anton-4/criterion.rs#9bd532e35486a3b321d4012534d3e97751a53f85" dependencies = [ "atty", "cast", @@ -653,8 +652,7 @@ dependencies = [ [[package]] name = "criterion-plot" version = "0.4.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e022feadec601fba1649cfa83586381a4ad31c6bf3a9ab7d408118b05dd9889d" +source = "git+https://github.com/Anton-4/criterion.rs#9bd532e35486a3b321d4012534d3e97751a53f85" dependencies = [ "cast", "itertools 0.9.0", @@ -2412,9 +2410,8 @@ checksum = "3831453b3449ceb48b6d9c7ad7c96d5ea673e9b470a1dc578c2ce6521230884c" [[package]] name = "plotters" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "45ca0ae5f169d0917a7c7f5a9c1a3d3d9598f18f529dd2b8373ed988efea307a" +version = "0.3.1" +source = "git+https://github.com/Anton-4/plotters#d043988179b61db714ad60f678637ee145e363d3" dependencies = [ "num-traits", "plotters-backend", @@ -3104,7 +3101,6 @@ dependencies = [ "colored", "confy", "copypasta", - "criterion", "env_logger 0.8.3", "futures", "glyph_brush", diff --git a/Earthfile b/Earthfile index 3305b222e5..766e224f12 100644 --- a/Earthfile +++ b/Earthfile @@ -39,7 +39,7 @@ install-zig-llvm-valgrind-clippy-rustfmt: # rustfmt RUN rustup component add rustfmt # criterion - RUN cargo install --git https://github.com/Anton-4/cargo-criterion + RUN cargo install --git https://github.com/Anton-4/cargo-criterion --branch main # sccache RUN apt -y install libssl-dev RUN cargo install sccache diff --git a/ci/safe-earthly-test-all.sh b/ci/safe-earthly.sh similarity index 61% rename from ci/safe-earthly-test-all.sh rename to ci/safe-earthly.sh index dbd03d6c79..77f26e7df5 100755 --- a/ci/safe-earthly-test-all.sh +++ b/ci/safe-earthly.sh @@ -3,7 +3,13 @@ LOG_FILE="earthly_log.txt" touch $LOG_FILE -script -efq $LOG_FILE -c "earthly --config ci/earthly-conf.yml +test-all" +ARGS=$1 + +if [[ $ARGS == *"bench"* ]]; then + ARGS="--allow-privileged $ARGS" +fi + +script -efq $LOG_FILE -c "earthly --config ci/earthly-conf.yml $ARGS" EXIT_CODE=$? if grep -q "failed to mount" "$LOG_FILE"; then @@ -14,7 +20,7 @@ if grep -q "failed to mount" "$LOG_FILE"; then echo "------<<<<<>>>>>------" echo "" echo "" - earthly --config ci/earthly-conf.yml --no-cache +test-all + earthly --config ci/earthly-conf.yml --no-cache $ARGS else exit $EXIT_CODE fi From 3a97ccd8ac940c8bb01cb6ca3523035eca4aa93a Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 2 Jun 2021 14:37:02 +0200 Subject: [PATCH 080/496] fix recursive layout issue --- compiler/gen/src/llvm/refcounting.rs | 2 +- compiler/mono/src/layout.rs | 9 ++------- .../test_mono/generated/let_with_record_pattern_list.txt | 3 ++- compiler/test_mono/generated/peano2.txt | 4 +++- 4 files changed, 8 insertions(+), 10 deletions(-) diff --git a/compiler/gen/src/llvm/refcounting.rs b/compiler/gen/src/llvm/refcounting.rs index cb1fa0a5a5..80eeee2ce6 100644 --- a/compiler/gen/src/llvm/refcounting.rs +++ b/compiler/gen/src/llvm/refcounting.rs @@ -724,7 +724,7 @@ fn modify_refcount_layout_build_function<'a, 'ctx, 'env>( Layout::RecursivePointer => match when_recursive { WhenRecursive::Unreachable => { - unreachable!("recursion pointers should never be hashed directly") + unreachable!("recursion pointers cannot be in/decremented directly") } WhenRecursive::Loop(union_layout) => { let layout = Layout::Union(*union_layout); diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index 5a266857ad..79176a02b5 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -1113,7 +1113,6 @@ fn layout_from_flat_type<'a>( // That means none of the optimizations for enums or single tag tag unions apply let rec_var = subs.get_root_key_without_compacting(rec_var); - env.insert_seen(rec_var); let mut tag_layouts = Vec::with_capacity_in(tags.len(), arena); // VERY IMPORTANT: sort the tags @@ -1131,6 +1130,7 @@ fn layout_from_flat_type<'a>( } } + env.insert_seen(rec_var); for (index, (_name, variables)) in tags_vec.into_iter().enumerate() { if matches!(nullable, Some(i) if i == index as i64) { // don't add the @@ -1163,6 +1163,7 @@ fn layout_from_flat_type<'a>( tag_layouts.push(tag_layout.into_bump_slice()); } + env.remove_seen(rec_var); let union_layout = if let Some(tag_id) = nullable { match tag_layouts.into_bump_slice() { @@ -1186,8 +1187,6 @@ fn layout_from_flat_type<'a>( UnionLayout::Recursive(tag_layouts.into_bump_slice()) }; - env.remove_seen(rec_var); - Ok(Layout::Union(union_layout)) } EmptyTagUnion => { @@ -1422,10 +1421,6 @@ pub fn union_sorted_tags_help<'a>( seen: MutSet::default(), }; - if let Some(rec_var) = opt_rec_var { - env.insert_seen(rec_var); - } - match tags_vec.len() { 0 => { // trying to instantiate a type with no values diff --git a/compiler/test_mono/generated/let_with_record_pattern_list.txt b/compiler/test_mono/generated/let_with_record_pattern_list.txt index d7763fed7c..1b7ae1ec45 100644 --- a/compiler/test_mono/generated/let_with_record_pattern_list.txt +++ b/compiler/test_mono/generated/let_with_record_pattern_list.txt @@ -6,5 +6,6 @@ procedure Test.0 (): let Test.5 = 3.14f64; let Test.3 = Struct {Test.4, Test.5}; let Test.1 = Index 0 Test.3; - decref Test.3; + inc Test.1; + dec Test.3; ret Test.1; diff --git a/compiler/test_mono/generated/peano2.txt b/compiler/test_mono/generated/peano2.txt index 65764f2fe8..03ba41ecf0 100644 --- a/compiler/test_mono/generated/peano2.txt +++ b/compiler/test_mono/generated/peano2.txt @@ -12,10 +12,11 @@ procedure Test.0 (): let Test.17 = lowlevel Eq Test.15 Test.16; if Test.17 then let Test.11 = Index 1 Test.2; + inc Test.11; + dec Test.2; let Test.12 = 0i64; let Test.13 = Index 0 Test.11; dec Test.11; - decref Test.2; let Test.14 = lowlevel Eq Test.12 Test.13; if Test.14 then let Test.7 = 1i64; @@ -24,5 +25,6 @@ procedure Test.0 (): let Test.9 = 0i64; ret Test.9; else + dec Test.2; let Test.10 = 0i64; ret Test.10; From 1697b8e9b49bc1b2fd12d2da08c04f6bdc145770 Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 2 Jun 2021 14:40:32 +0200 Subject: [PATCH 081/496] cheap increment, cheaper decrement for tag unions --- compiler/gen/src/llvm/refcounting.rs | 144 +++++++++++++++++++-------- compiler/load/src/file.rs | 20 ++-- 2 files changed, 116 insertions(+), 48 deletions(-) diff --git a/compiler/gen/src/llvm/refcounting.rs b/compiler/gen/src/llvm/refcounting.rs index 80eeee2ce6..f18fb6221b 100644 --- a/compiler/gen/src/llvm/refcounting.rs +++ b/compiler/gen/src/llvm/refcounting.rs @@ -8,6 +8,7 @@ use crate::llvm::convert::{ basic_type_from_layout, block_of_memory, block_of_memory_slices, ptr_int, }; use bumpalo::collections::Vec; +use inkwell::basic_block::BasicBlock; use inkwell::context::Context; use inkwell::module::Linkage; use inkwell::types::{AnyTypeEnum, BasicType, BasicTypeEnum}; @@ -94,6 +95,14 @@ impl<'ctx> PointerToRefcount<'ctx> { Self::from_ptr_to_data(env, data_ptr) } + pub fn is_1<'a, 'env>(&self, env: &Env<'a, 'ctx, 'env>) -> IntValue<'ctx> { + let current = self.get_refcount(env); + let one = refcount_1(env.context, env.ptr_bytes); + + env.builder + .build_int_compare(IntPredicate::EQ, current, one, "is_one") + } + pub fn get_refcount<'a, 'env>(&self, env: &Env<'a, 'ctx, 'env>) -> IntValue<'ctx> { env.builder .build_load(self.value, "get_refcount") @@ -1249,7 +1258,7 @@ fn build_rec_union_help<'a, 'ctx, 'env>( layout_ids: &mut LayoutIds<'a>, mode: Mode, when_recursive: &WhenRecursive<'a>, - tags: &[&[Layout<'a>]], + tags: &'a [&'a [roc_mono::layout::Layout<'a>]], fn_val: FunctionValue<'ctx>, is_nullable: bool, ) { @@ -1258,8 +1267,6 @@ fn build_rec_union_help<'a, 'ctx, 'env>( let context = &env.context; let builder = env.builder; - let pick = |a, b| if let Mode::Inc = mode { a } else { b }; - // Add a basic block for the entry point let entry = context.append_basic_block(fn_val, "entry"); @@ -1281,6 +1288,92 @@ fn build_rec_union_help<'a, 'ctx, 'env>( debug_assert!(arg_val.is_pointer_value()); let value_ptr = arg_val.into_pointer_value(); + // to increment/decrement the cons-cell itself + let refcount_ptr = PointerToRefcount::from_ptr_to_data(env, value_ptr); + let call_mode = mode_to_call_mode(fn_val, mode); + + let should_recurse_block = env.context.append_basic_block(parent, "should_recurse"); + + let ctx = env.context; + if is_nullable { + let is_null = env.builder.build_is_null(value_ptr, "is_null"); + + let then_block = ctx.append_basic_block(parent, "then"); + + env.builder + .build_conditional_branch(is_null, then_block, should_recurse_block); + + { + env.builder.position_at_end(then_block); + env.builder.build_return(None); + } + } else { + env.builder.build_unconditional_branch(should_recurse_block); + } + + env.builder.position_at_end(should_recurse_block); + + match mode { + Mode::Inc => { + // inc is cheap; we never recurse + refcount_ptr.modify(call_mode, &layout, env); + env.builder.build_return(None); + } + + Mode::Dec => { + let do_recurse_block = env.context.append_basic_block(parent, "do_recurse"); + let no_recurse_block = env.context.append_basic_block(parent, "no_recurse"); + + builder.build_conditional_branch( + refcount_ptr.is_1(env), + do_recurse_block, + no_recurse_block, + ); + + { + env.builder.position_at_end(no_recurse_block); + + refcount_ptr.modify(call_mode, &layout, env); + env.builder.build_return(None); + } + + { + env.builder.position_at_end(do_recurse_block); + + build_rec_union_recursive_decrement( + env, + layout_ids, + when_recursive, + parent, + fn_val, + layout, + tags, + value_ptr, + refcount_ptr, + do_recurse_block, + ) + } + } + } +} + +#[allow(clippy::too_many_arguments)] +fn build_rec_union_recursive_decrement<'a, 'ctx, 'env>( + env: &Env<'a, 'ctx, 'env>, + layout_ids: &mut LayoutIds<'a>, + when_recursive: &WhenRecursive<'a>, + parent: FunctionValue<'ctx>, + decrement_fn: FunctionValue<'ctx>, + layout: Layout<'a>, + tags: &[&[Layout<'a>]], + value_ptr: PointerValue<'ctx>, + refcount_ptr: PointerToRefcount<'ctx>, + match_block: BasicBlock<'ctx>, +) { + let mode = Mode::Dec; + let call_mode = mode_to_call_mode(decrement_fn, mode); + let builder = env.builder; + // branches that are not/don't contain anything refcounted // if there is only one branch, we don't need to switch let switch_needed: bool = (|| { @@ -1296,28 +1389,6 @@ fn build_rec_union_help<'a, 'ctx, 'env>( false })(); - // to increment/decrement the cons-cell itself - let refcount_ptr = PointerToRefcount::from_ptr_to_data(env, value_ptr); - let call_mode = mode_to_call_mode(fn_val, mode); - - let ctx = env.context; - let cont_block = ctx.append_basic_block(parent, "cont"); - if is_nullable { - let is_null = env.builder.build_is_null(value_ptr, "is_null"); - - let then_block = ctx.append_basic_block(parent, "then"); - - env.builder - .build_conditional_branch(is_null, then_block, cont_block); - - { - env.builder.position_at_end(then_block); - env.builder.build_return(None); - } - } else { - env.builder.build_unconditional_branch(cont_block); - } - // next, make a jump table for all possible values of the tag_id let mut cases = Vec::with_capacity_in(tags.len(), env.arena); @@ -1330,9 +1401,7 @@ fn build_rec_union_help<'a, 'ctx, 'env>( continue; } - let block = env - .context - .append_basic_block(parent, pick("tag_id_increment", "tag_id_decrement")); + let block = env.context.append_basic_block(parent, "tag_id_decrement"); env.builder.position_at_end(block); @@ -1382,10 +1451,9 @@ fn build_rec_union_help<'a, 'ctx, 'env>( .build_struct_gep(struct_ptr, i as u32, "gep_recursive_pointer") .unwrap(); - let field = env.builder.build_load( - elem_pointer, - pick("increment_struct_field", "decrement_struct_field"), - ); + let field = env + .builder + .build_load(elem_pointer, "decrement_struct_field"); deferred_nonrec.push((field, field_layout)); } @@ -1404,7 +1472,7 @@ fn build_rec_union_help<'a, 'ctx, 'env>( env, parent, layout_ids, - mode.to_call_mode(fn_val), + mode.to_call_mode(decrement_fn), when_recursive, field, field_layout, @@ -1413,7 +1481,7 @@ fn build_rec_union_help<'a, 'ctx, 'env>( for ptr in deferred_rec { // recursively decrement the field - let call = call_help(env, fn_val, mode.to_call_mode(fn_val), ptr); + let call = call_help(env, decrement_fn, mode.to_call_mode(decrement_fn), ptr); call.set_tail_call(true); } @@ -1426,9 +1494,9 @@ fn build_rec_union_help<'a, 'ctx, 'env>( )); } - cases.reverse(); + env.builder.position_at_end(match_block); - env.builder.position_at_end(cont_block); + cases.reverse(); if cases.len() == 1 && !switch_needed { // there is only one tag in total; we don't need a switch @@ -1441,9 +1509,7 @@ fn build_rec_union_help<'a, 'ctx, 'env>( // read the tag_id let current_tag_id = rec_union_read_tag(env, value_ptr); - let merge_block = env - .context - .append_basic_block(parent, pick("increment_merge", "decrement_merge")); + let merge_block = env.context.append_basic_block(parent, "decrement_merge"); // switch on it env.builder diff --git a/compiler/load/src/file.rs b/compiler/load/src/file.rs index cf9ff87acc..76ec8d5cc7 100644 --- a/compiler/load/src/file.rs +++ b/compiler/load/src/file.rs @@ -2040,7 +2040,7 @@ fn update<'a>( } MadeSpecializations { module_id, - mut ident_ids, + ident_ids, subs, procedures, external_specializations_requested, @@ -2063,6 +2063,8 @@ fn update<'a>( && state.dependencies.solved_all() && state.goal_phase == Phase::MakeSpecializations { + Proc::insert_refcount_operations(arena, &mut state.procedures); + // display the mono IR of the module, for debug purposes if roc_mono::ir::PRETTY_PRINT_IR_SYMBOLS { let procs_string = state @@ -2076,14 +2078,14 @@ fn update<'a>( println!("{}", result); } - Proc::insert_refcount_operations(arena, &mut state.procedures); - - Proc::optimize_refcount_operations( - arena, - module_id, - &mut ident_ids, - &mut state.procedures, - ); + // This is not safe with the new non-recursive RC updates that we do for tag unions + // + // Proc::optimize_refcount_operations( + // arena, + // module_id, + // &mut ident_ids, + // &mut state.procedures, + // ); if false { let it = state.procedures.iter().map(|x| x.1); From 3c0115aae1816431dba491c023008b5ecc507d51 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Wed, 2 Jun 2021 15:37:31 +0200 Subject: [PATCH 082/496] removed unused dependencies for cli --- Cargo.lock | 2 -- cli/Cargo.toml | 2 -- 2 files changed, 4 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 24673ca5f9..dc6e48fc34 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3038,9 +3038,7 @@ dependencies = [ "rustyline", "rustyline-derive", "serde", - "serde-xml-rs", "serial_test", - "strip-ansi-escapes", "target-lexicon", "tempfile", ] diff --git a/cli/Cargo.toml b/cli/Cargo.toml index b465842913..08a66a8ace 100644 --- a/cli/Cargo.toml +++ b/cli/Cargo.toml @@ -66,8 +66,6 @@ inkwell = { path = "../vendor/inkwell" } target-lexicon = "0.10" tempfile = "3.1.0" serde = { version = "1.0", features = ["derive"] } -strip-ansi-escapes = "0.1" -serde-xml-rs = "0.4" [dev-dependencies] pretty_assertions = "0.5.1" From 0da16b0189c23e0bc523632d5dd0244269f29812 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Wed, 2 Jun 2021 15:39:20 +0200 Subject: [PATCH 083/496] Updated editor README Removed "new features are added every week!" --- editor/README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/editor/README.md b/editor/README.md index acb1311068..cbae3eb8ff 100644 --- a/editor/README.md +++ b/editor/README.md @@ -1,5 +1,5 @@ -The editor is a work in progress, only a limited subset of Roc expressions are currently supported. New features are added every week! +The editor is a work in progress, only a limited subset of Roc expressions are currently supported. Unlike most editors, we use projectional or structural editing to edit the [Abstract Syntax Tree](https://en.wikipedia.org/wiki/Abstract_syntax_tree) directly. This will allow for cool features like excellent auto-complete and refactoring. @@ -28,4 +28,4 @@ We thank the following open source projects in particular for inspiring us when - [learn-wgpu](https://github.com/sotrh/learn-wgpu) - [rgx](https://github.com/cloudhead/rgx) - [elm-editor](https://github.com/jxxcarlson/elm-editor) -- [iced](https://github.com/hecrj/iced) \ No newline at end of file +- [iced](https://github.com/hecrj/iced) From d0c141e6899e266a42736bbb2c89516e19c6399b Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Wed, 2 Jun 2021 16:00:27 +0200 Subject: [PATCH 084/496] removed unused serde dependency --- Cargo.lock | 1 - cli/Cargo.toml | 1 - 2 files changed, 2 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index dc6e48fc34..98bffc337b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3037,7 +3037,6 @@ dependencies = [ "roc_unify", "rustyline", "rustyline-derive", - "serde", "serial_test", "target-lexicon", "tempfile", diff --git a/cli/Cargo.toml b/cli/Cargo.toml index 08a66a8ace..7aa61cb768 100644 --- a/cli/Cargo.toml +++ b/cli/Cargo.toml @@ -65,7 +65,6 @@ libloading = "0.6" inkwell = { path = "../vendor/inkwell" } target-lexicon = "0.10" tempfile = "3.1.0" -serde = { version = "1.0", features = ["derive"] } [dev-dependencies] pretty_assertions = "0.5.1" From fbac262023b381556ee51d18d71e212ad2ddcaad Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 2 Jun 2021 16:04:24 +0200 Subject: [PATCH 085/496] update morphic --- Cargo.lock | 1 + compiler/mono/src/alias_analysis.rs | 6 +- vendor/morphic_lib/Cargo.toml | 1 + vendor/morphic_lib/src/api.rs | 934 +++++++++++++++--------- vendor/morphic_lib/src/bindings.rs | 19 +- vendor/morphic_lib/src/util/bytes_id.rs | 10 +- vendor/morphic_lib/src/util/mod.rs | 9 + 7 files changed, 637 insertions(+), 343 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 16b8f30cd0..8d4bd350d7 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1927,6 +1927,7 @@ name = "morphic_lib" version = "0.1.0" dependencies = [ "sha2", + "smallvec", "thiserror", ] diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index be99dec0af..b328a11975 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -146,7 +146,7 @@ fn proc_spec(proc: &Proc) -> Result { #[derive(Default)] struct Env { symbols: MutMap, - join_points: MutMap, + join_points: MutMap, } fn stmt_spec( @@ -246,7 +246,7 @@ fn stmt_spec( let jp_arg_type_id = builder.add_tuple_type(&type_ids)?; let (jpid, jp_argument) = - builder.declare_join_point(block, jp_arg_type_id, ret_type_id)?; + builder.declare_continuation(block, jp_arg_type_id, ret_type_id)?; let join_body_sub_block = { env.join_points.insert(*id, jpid); @@ -270,7 +270,7 @@ fn stmt_spec( let cont_value_id = stmt_spec(builder, env, cont_block, layout, continuation)?; env.join_points.remove(id); - builder.define_join_point(jpid, join_body_sub_block)?; + builder.define_continuation(jpid, join_body_sub_block)?; builder.add_sub_block(block, BlockExpr(cont_block, cont_value_id)) } diff --git a/vendor/morphic_lib/Cargo.toml b/vendor/morphic_lib/Cargo.toml index bf93c8b39e..5406cf3647 100644 --- a/vendor/morphic_lib/Cargo.toml +++ b/vendor/morphic_lib/Cargo.toml @@ -7,3 +7,4 @@ edition = "2018" [dependencies] thiserror = "1.0.24" sha2 = "0.9.4" +smallvec = "1.6.1" diff --git a/vendor/morphic_lib/src/api.rs b/vendor/morphic_lib/src/api.rs index 604b02f896..56e97e1b8d 100644 --- a/vendor/morphic_lib/src/api.rs +++ b/vendor/morphic_lib/src/api.rs @@ -1,6 +1,13 @@ +use sha2::{digest::Digest, Sha256}; +use smallvec::SmallVec; use std::collections::{btree_map::Entry, BTreeMap, BTreeSet}; -use sha2::{digest::Digest, Sha256}; +use crate::util::blocks::Blocks; +use crate::util::id_bi_map::IdBiMap; +use crate::util::id_type::Count; +use crate::util::id_vec::IdVec; +use crate::util::op_graph::{Node, OpGraph}; +use crate::util::replace_none::replace_none; #[derive(Clone, thiserror::Error, Debug)] #[non_exhaustive] @@ -11,12 +18,12 @@ enum ErrorKind { BlockIdNotFound(BlockId), #[error("no value found for {0:?}")] ValueIdNotFound(ValueId), - #[error("no join point found for {0:?}")] - JoinPointIdNotFound(JoinPointId), - #[error("body of join point {0:?} is not defined")] - JoinPointNotDefined(JoinPointId), - #[error("body of join point {0:?} has already been defined")] - JoinPointAlreadyDefined(JoinPointId), + #[error("no continuation found for {0:?}")] + ContinuationIdNotFound(ContinuationId), + #[error("body of continuation {0:?} is not defined")] + ContinuationNotDefined(ContinuationId), + #[error("body of continuation {0:?} has already been defined")] + ContinuationAlreadyDefined(ContinuationId), #[error("block {0:?} has no parent")] BlockDetached(BlockId), #[error("block {0:?} already has a parent")] @@ -64,74 +71,75 @@ pub type Result = std::result::Result; bytes_id! { pub ModName; - ModNameBuf; + pub(crate) ModNameBuf; } bytes_id! { pub EntryPointName; - EntryPointNameBuf; + pub(crate) EntryPointNameBuf; } // Module-level identifiers (unique within a module): bytes_id! { pub TypeName; - TypeNameBuf; + pub(crate) TypeNameBuf; } bytes_id! { pub FuncName; - FuncNameBuf; + pub(crate) FuncNameBuf; } bytes_id! { pub ConstName; - ConstNameBuf; + pub(crate) ConstNameBuf; } // Local identifiers (unique within a function body): -/// A reference to an arena-allocated expression object in a function body. -#[repr(C)] -#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct ValueId(pub u32); +id_type! { + /// A reference to an arena-allocated expression object in a function body. + #[repr(C)] + pub ValueId(u32); +} -/// A reference to an arena-allocated join point in a function body. -/// -/// A join point is a point where multiple paths of execution "join" up again. In other words, a -/// block with multiple entry points. Join points can also be thought of as continuations that do -/// not escape. See [Compiling without Continuations](https://www.microsoft.com/en-us/research/wp-content/uploads/2016/11/join-points-pldi17.pdf). -/// Join points are common in functional language IRs, but might also be useful (in the context of -/// this library) for encoding constructs such as for loops. -#[repr(C)] -#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct JoinPointId(pub u32); +id_type! { + /// A reference to an arena-allocated continuation in a function body. + /// + /// See [`ExprContext::declare_continuation`], [`ExprContext::define_continuation`], and + /// [`ExprContext::add_jump`] for more information. + #[repr(C)] + pub ContinuationId(u32); +} -/// A reference to an arena-allocated block in a function body. -/// -/// A block is a sequence of zero or more expressions. Each expression has an associated -/// `ValueId`, which is unique across all blocks within its function. -#[repr(C)] -#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct BlockId(pub u32); +id_type! { + /// A reference to an arena-allocated block in a function body. + /// + /// A block is a sequence of zero or more expressions. Each expression has an associated + /// `ValueId`, which is unique across all blocks within its function. + #[repr(C)] + pub BlockId(u32); +} -/// A reference to an arena-allocated type node in a type definition or function body. -#[repr(C)] -#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct TypeId(pub u32); +id_type! { + /// A reference to an arena-allocated type node in a type definition or function body. + #[repr(C)] + pub TypeId(u32); +} bytes_id! { /// A client-provided name used as a key to look up callee specializations in the solution /// tables generated by the analysis engine. pub CalleeSpecVar; - pub(self) CalleeSpecBuf; + pub(crate) CalleeSpecBuf; } bytes_id! { /// A client-provided name used as a key to look up concrete update mode flags in the solution /// tables generated by the analysis engine. pub UpdateModeVar; - pub(self) UpdateModeBuf; + pub(crate) UpdateModeBuf; } // Input API: @@ -202,86 +210,6 @@ impl SeqGen { } } -/// A `TypeDef` defines the content type of a named type. -pub struct TypeDef; - -struct TypeBuilder { - tid_gen: SeqGen, -} - -impl Default for TypeBuilder { - fn default() -> Self { - Self::new() - } -} - -impl TypeBuilder { - fn new() -> Self { - Self { - tid_gen: SeqGen::new(), - } - } - - fn check(&self, id: TypeId) -> Result<()> { - self.tid_gen - .check_in_range(id.0) - .map_err(|()| ErrorKind::TypeIdNotFound(id).into()) - } -} - -impl TypeContext for TypeBuilder { - fn add_named_type(&mut self, _mod: ModName, _type: TypeName) -> TypeId { - TypeId(self.tid_gen.next()) - } - - fn add_tuple_type(&mut self, field_types: &[TypeId]) -> Result { - for &field_type in field_types { - self.check(field_type)?; - } - Ok(TypeId(self.tid_gen.next())) - } - - fn add_union_type(&mut self, variant_types: &[TypeId]) -> Result { - for &variant_type in variant_types { - self.check(variant_type)?; - } - Ok(TypeId(self.tid_gen.next())) - } - - fn add_heap_cell_type(&mut self) -> TypeId { - TypeId(self.tid_gen.next()) - } - - fn add_bag_type(&mut self, item_type: TypeId) -> Result { - self.check(item_type)?; - Ok(TypeId(self.tid_gen.next())) - } -} - -pub struct TypeDefBuilder { - inner: TypeBuilder, -} - -impl Default for TypeDefBuilder { - fn default() -> Self { - Self::new() - } -} - -impl TypeDefBuilder { - pub fn new() -> Self { - Self { - inner: TypeBuilder::new(), - } - } - - /// Create a `TypeDef` using the given type node as the root. - pub fn build(self, root: TypeId) -> Result { - self.inner.check(root)?; - Ok(TypeDef) - } -} - /// A block, together with a value to return from the block. /// /// The returned value must be in scope at the end of the block. @@ -296,46 +224,6 @@ pub struct BlockExpr(pub BlockId, pub ValueId); forward_trait! { /// A trait for constructing expressions in both function bodies and constant initializers. pub trait ExprContext { - /// Declare a join point in a `block`. - /// - /// Returning from the resulting join point after jumping to it will yield control to the - /// parent of the block in which the join point was defined. - /// - /// This function allows you to forward-declare a join point without specifying its body, - /// which makes it possible to define recursive and mutually recursive joint points. - /// However, you must eventually populate the body of each joint point via a call to - /// `define_join_point`. - /// - /// The returned ValueId is the ValueId of the *argument* to the join point, which is in - /// scope within the body of the join point. - fn declare_join_point( - &mut self, - block: BlockId, - arg_type: TypeId, - ret_type: TypeId, - ) -> Result<(JoinPointId, ValueId)>; - - /// Define a join point. - /// - /// Before a join point can be defined, it must be declared via a call to - /// `declare_join_point`. - fn define_join_point(&mut self, join_point: JoinPointId, body: BlockExpr) -> Result<()>; - - /// Add a jump to a join point. - /// - /// The rest of the API assumes that every code path produces a `ValueId`. Join points do - /// not fit this model neatly because jumping to a join point yields control to outside of - /// the current expression. Hence, this function returns a dummy unconstrained `ValueId`, - /// which can be used as if the jump were a regular expression producing a value of type - /// `unreachable_result_type`. - fn add_jump( - &mut self, - block: BlockId, - join_point: JoinPointId, - arg: ValueId, - unreachable_result_type: TypeId, - ) -> Result; - /// Add a block to the current function body. /// /// A block is a sequence of zero or more expressions. Each expression has an associated @@ -406,9 +294,9 @@ forward_trait! { /// /// The sub-block expression evaluates to the value returned by the sub-block. /// - /// This is useful in combination with join points, because returning from a join point - /// always yields control to the parent of the enclosing block in which the join point was - /// defined. Without sub-blocks, there would be no way to reduce the scope of a join point + /// This is useful in combination with continuations, because returning from a continuation + /// always yields control to the parent of the enclosing block in which the continuation was + /// defined. Without sub-blocks, there would be no way to reduce the scope of a continuation /// within a block. fn add_sub_block(&mut self, block: BlockId, sub_block: BlockExpr) -> Result; @@ -434,6 +322,16 @@ forward_trait! { /// A 'touch' expression returns the empty tuple type `()`. fn add_touch(&mut self, block: BlockId, heap_cell: ValueId) -> Result; + /// Add a 'recursive touch' expression to a block. + /// + /// Semantically, this is equivalent to 'touch'ing all heap cells reachable from `object`, + /// including heap cells nested inside tuples, unions, bags, and named types. The `object` + /// argument may be of any type, and does not necessarily need to contain any heap cells at + /// all (in which case this operation will be a no-op). + /// + /// A 'recursive touch' expression returns the empty tuple type `()`. + fn add_recursive_touch(&mut self, block: BlockId, object: ValueId) -> Result; + /// Add an 'update' expression to a block. /// /// An 'update' expression represents an attempt to "write" the contents of the heap cell. @@ -571,16 +469,285 @@ forward_trait! { named: TypeName, to_unwrap: ValueId, ) -> Result; + + /// Declare a continuation in a `block`. + /// + /// A continuation is like a local function which does not return to its caller. A + /// continuation always has a single argument, and a "body" block in which that argument is + /// in scope. Declaring a continuation has no effect on its own, but after a continuation + /// is declared it may be called with a ['jump'](ExprContext::add_jump) expression. + /// + /// Like calling a function, jumping to a continuation transfers control to its body. + /// However, unlike a function, a continuation does not return control to its caller. When + /// a continuation returns, instead of transferring control to the 'jump' expression that + /// called it, the continuation transfers control to the *parent of the `block` in which the + /// continuation was defined*. When a continuation returns, its return value becomes the + /// return value of the `block` in which it was defined. + /// + /// Continuations can be used to express constructs such as 'goto' statements, loops, + /// 'break' and 'continue' statements, early returns, tail calls, and ["join + /// points"](https://www.microsoft.com/en-us/research/wp-content/uploads/2016/11/compiling-without-continuations.pdf). + /// + /// THe `declare_continuation` function allows you to forward-declare a continuation without + /// specifying its body, which makes it possible to define recursive and mutually recursive + /// continuations. However, you must eventually populate the body of each continuation via + /// a call to [`define_continuation`](ExprContext::define_continuation). + /// + /// The `ValueId` returned from `declare_continuation` is the `ValueId` of the *argument* to + /// the continuation, which is in scope within the body of the continuation. + fn declare_continuation( + &mut self, + block: BlockId, + arg_type: TypeId, + ret_type: TypeId, + ) -> Result<(ContinuationId, ValueId)>; + + /// Define the body of a continuation. + /// + /// Before a continuation can be defined, it must be declared via a call to + /// [`declare_continuation`](ExprContext::declare_continuation). + fn define_continuation( + &mut self, + continuation: ContinuationId, + body: BlockExpr + ) -> Result<()>; + + /// Add a 'jump' to a continuation. + /// + /// A 'jump' expression never returns, and any code which operates on the notional "return + /// value" of a 'jump' expression will be unreachable. However, in some cases it may still + /// be useful to treat a 'jump' expression as if it returned a value of a given type (for + /// example, in a `choice` expression in which one arm returns a value, and the other arm + /// ends in a 'jump'). For this reason, `add_jump` accepts an `unreachable_return_type` + /// argument which allows you to set the return type of the 'jump' expression to *any type + /// of your choosing*. This is analogous to the idea of a ["diverging + /// function"](https://doc.rust-lang.org/stable/rust-by-example/fn/diverging.html) in Rust, + /// whose return value may be used where a value of any type is expected. + fn add_jump( + &mut self, + block: BlockId, + continuation: ContinuationId, + arg: ValueId, + unreachable_result_type: TypeId, + ) -> Result; } impl FuncDefBuilder => .expr_builder; impl ConstDefBuilder => .expr_builder; } +#[derive(Clone, Debug)] +pub(crate) enum TypeOp { + // 0 inputs + Named { + named_mod: ModNameBuf, + named: TypeNameBuf, + }, + // Variadic inputs + Tuple, + // Variadic inputs + Union, + // 0 inputs + HeapCell, + // 1 input + Bag, +} + +/// A `TypeDef` defines the content type of a named type. +pub struct TypeDef; + +#[derive(Clone, Debug)] +struct TypeBuilder { + types: OpGraph, +} + +impl Default for TypeBuilder { + fn default() -> Self { + Self::new() + } +} + +impl TypeBuilder { + fn new() -> Self { + Self { + types: OpGraph::new(), + } + } + + fn check(&self, id: TypeId) -> Result<()> { + if id >= self.types.count() { + return Err(ErrorKind::TypeIdNotFound(id).into()); + } + Ok(()) + } + + fn add_node_checked(&mut self, op: TypeOp, inputs: &[TypeId]) -> Result { + for &input in inputs { + self.check(input)?; + } + Ok(self.types.add_node(op, inputs)) + } +} + +impl TypeContext for TypeBuilder { + fn add_named_type(&mut self, named_mod: ModName, named: TypeName) -> TypeId { + self.types.add_node( + TypeOp::Named { + named_mod: named_mod.into(), + named: named.into(), + }, + &[], + ) + } + + fn add_tuple_type(&mut self, field_types: &[TypeId]) -> Result { + self.add_node_checked(TypeOp::Tuple, field_types) + } + + fn add_union_type(&mut self, variant_types: &[TypeId]) -> Result { + self.add_node_checked(TypeOp::Union, variant_types) + } + + fn add_heap_cell_type(&mut self) -> TypeId { + self.types.add_node(TypeOp::HeapCell, &[]) + } + + fn add_bag_type(&mut self, item_type: TypeId) -> Result { + self.add_node_checked(TypeOp::Bag, &[item_type]) + } +} + +pub struct TypeDefBuilder { + inner: TypeBuilder, +} + +impl Default for TypeDefBuilder { + fn default() -> Self { + Self::new() + } +} + +impl TypeDefBuilder { + pub fn new() -> Self { + Self { + inner: TypeBuilder::new(), + } + } + + /// Create a `TypeDef` using the given type node as the root. + pub fn build(self, root: TypeId) -> Result { + self.inner.check(root)?; + Ok(TypeDef) + } +} + +id_type! { + pub(crate) UpdateModeVarId(u32); +} + +id_type! { + pub(crate) CalleeSpecVarId(u32); +} + +#[derive(Clone, Debug)] +pub(crate) enum Op { + // 0 inputs + Arg, + // 0 inputs + ContinuationArg, + // 0 inputs + // TODO: We may want to refactor the IR so that this is not an op. + DeclareContinuation { + continuation: ContinuationId, + }, + // 1 input + Jump { + continuation: ContinuationId, + unreachable_result_type: TypeId, + }, + // Variadic inputs + UnknownWith { + result_type: TypeId, + }, + // 1 input + Call { + callee_spec_var: CalleeSpecVarId, + callee_mod: ModNameBuf, + callee: FuncNameBuf, + }, + // 0 inputs + ConstRef { + const_mod: ModNameBuf, + const_: ConstNameBuf, + }, + // 0 inputs + Choice { + // Invariant: 'cases' must be nonempty (to ensure we can always infer the type of a `Choice` + // op). + cases: SmallVec<[BlockExpr; 6]>, + }, + // 0 inputs + SubBlock { + sub_block: BlockExpr, + }, + // 0 inputs + Terminate { + unreachable_result_type: TypeId, + }, + // 0 inputs + NewHeapCell, + // 1 input + Touch, + // 1 input + RecursiveTouch, + // 1 input + UpdateWriteOnly { + update_mode_var: UpdateModeVarId, + }, + // 0 inputs + EmptyBag { + item_type: TypeId, + }, + // 2 inputs: (bag, to_insert) + BagInsert, + // 1 input + BagGet, + // 1 input + // output: (new bag, item) + BagRemove, + // Variadic inputs + MakeTuple, + // 1 input + GetTupleField { + field_idx: u32, + }, + // 1 input + MakeUnion { + variant_types: SmallVec<[TypeId; 10]>, + variant_idx: u32, + }, + // 1 input + UnwrapUnion { + variant_idx: u32, + }, + // 1 input + MakeNamed { + named_mod: ModNameBuf, + named: TypeNameBuf, + }, + // 1 input + UnwrapNamed { + named_mod: ModNameBuf, + named: TypeNameBuf, + }, +} + #[derive(Clone, Copy, Debug)] -enum JoinPointState { - Declared, - Defined, +struct ContinuationInfo { + arg_type: TypeId, + ret_type: TypeId, + arg: ValueId, + body: Option, } #[derive(Clone, Copy, Debug)] @@ -589,15 +756,14 @@ enum BlockState { Attached, } +#[derive(Clone, Debug)] struct ExprBuilder { type_builder: TypeBuilder, - bid_gen: SeqGen, - vid_gen: SeqGen, - jid_gen: SeqGen, - blocks: BTreeMap, - join_points: BTreeMap, - callee_spec_vars: BTreeMap, - update_mode_vars: BTreeSet, + blocks: Blocks, + vals: OpGraph, + continuations: IdVec, + callee_spec_vars: IdBiMap, + update_mode_vars: IdBiMap, } impl Default for ExprBuilder { @@ -610,13 +776,11 @@ impl ExprBuilder { fn new() -> Self { Self { type_builder: TypeBuilder::new(), - bid_gen: SeqGen::new(), - vid_gen: SeqGen::new(), - jid_gen: SeqGen::new(), - blocks: BTreeMap::new(), - join_points: BTreeMap::new(), - callee_spec_vars: BTreeMap::new(), - update_mode_vars: BTreeSet::new(), + blocks: Blocks::new(), + vals: OpGraph::new(), + continuations: IdVec::new(), + callee_spec_vars: IdBiMap::new(), + update_mode_vars: IdBiMap::new(), } } @@ -625,38 +789,38 @@ impl ExprBuilder { } fn check_bid(&self, id: BlockId) -> Result<()> { - self.bid_gen - .check_in_range(id.0) - .map_err(|()| ErrorKind::BlockIdNotFound(id).into()) + if id >= self.blocks.block_count() { + return Err(ErrorKind::BlockIdNotFound(id).into()); + } + Ok(()) } fn check_vid(&self, id: ValueId) -> Result<()> { - self.vid_gen - .check_in_range(id.0) - .map_err(|()| ErrorKind::ValueIdNotFound(id).into()) + if id >= self.vals.count() { + return Err(ErrorKind::ValueIdNotFound(id).into()); + } + Ok(()) } - fn check_jid(&self, id: JoinPointId) -> Result<()> { - self.jid_gen - .check_in_range(id.0) - .map_err(|()| ErrorKind::JoinPointIdNotFound(id).into()) + fn check_cid(&self, id: ContinuationId) -> Result<()> { + if id >= self.continuations.count() { + return Err(ErrorKind::ContinuationIdNotFound(id).into()); + } + Ok(()) } fn finalize_with_root(&mut self, root: BlockExpr) -> Result<()> { self.attach_block(root.0)?; self.check_vid(root.1)?; - for (&join_point, state) in &self.join_points { - match state { - JoinPointState::Declared => { - return Err(ErrorKind::JoinPointNotDefined(join_point).into()); - } - JoinPointState::Defined => {} + for (continuation, info) in &self.continuations { + if info.body.is_none() { + return Err(ErrorKind::ContinuationNotDefined(continuation).into()); } } - for (&block, state) in &self.blocks { - match state { + for block_id in self.blocks.block_count().iter() { + match self.blocks.block_info(block_id) { BlockState::Detached => { - return Err(ErrorKind::BlockDetached(block).into()); + return Err(ErrorKind::BlockDetached(block_id).into()); } BlockState::Attached => {} } @@ -665,66 +829,82 @@ impl ExprBuilder { } fn add_argument(&mut self) -> ValueId { - ValueId(self.vid_gen.next()) + self.vals.add_node(Op::Arg, &[]) + } + + fn add_node_checked(&mut self, block: BlockId, op: Op, inputs: &[ValueId]) -> Result { + self.check_bid(block)?; + for &input in inputs { + self.check_vid(input)?; + } + let val_id = self.vals.add_node(op, inputs); + self.blocks.add_value(block, val_id); + Ok(val_id) } fn attach_block(&mut self, block: BlockId) -> Result<()> { - match self.blocks.insert(block, BlockState::Attached) { - Some(BlockState::Detached) => Ok(()), - Some(BlockState::Attached) => Err(ErrorKind::BlockAlreadyAttached(block).into()), - None => Err(ErrorKind::BlockIdNotFound(block).into()), + self.check_bid(block)?; + let state = self.blocks.block_info_mut(block); + match state { + BlockState::Detached => *state = BlockState::Attached, + BlockState::Attached => return Err(ErrorKind::BlockAlreadyAttached(block).into()), } + Ok(()) } } impl ExprContext for ExprBuilder { - fn declare_join_point( + fn declare_continuation( &mut self, block: BlockId, arg_type: TypeId, ret_type: TypeId, - ) -> Result<(JoinPointId, ValueId)> { - self.check_bid(block)?; + ) -> Result<(ContinuationId, ValueId)> { self.check_tid(arg_type)?; self.check_tid(ret_type)?; - let join_point = JoinPointId(self.jid_gen.next()); - self.join_points - .insert(join_point, JoinPointState::Declared); - Ok((join_point, ValueId(self.vid_gen.next()))) + let arg = self.vals.add_node(Op::ContinuationArg, &[]); + let continuation = self.continuations.push(ContinuationInfo { + arg_type, + ret_type, + arg, + body: None, + }); + self.add_node_checked(block, Op::DeclareContinuation { continuation }, &[])?; + Ok((continuation, arg)) } - fn define_join_point(&mut self, join_point: JoinPointId, body: BlockExpr) -> Result<()> { - self.check_jid(join_point)?; + fn define_continuation(&mut self, continuation: ContinuationId, body: BlockExpr) -> Result<()> { + self.check_cid(continuation)?; self.check_bid(body.0)?; self.check_vid(body.1)?; self.attach_block(body.0)?; - match self.join_points.insert(join_point, JoinPointState::Defined) { - Some(JoinPointState::Declared) => Ok(()), - Some(JoinPointState::Defined) => { - Err(ErrorKind::JoinPointAlreadyDefined(join_point).into()) - } - None => Err(ErrorKind::JoinPointIdNotFound(join_point).into()), - } + replace_none(&mut self.continuations[continuation].body, body) + .map_err(|_| ErrorKind::ContinuationAlreadyDefined(continuation))?; + Ok(()) } fn add_jump( &mut self, block: BlockId, - join_point: JoinPointId, + continuation: ContinuationId, arg: ValueId, unreachable_result_type: TypeId, ) -> Result { - self.check_bid(block)?; - self.check_jid(join_point)?; - self.check_vid(arg)?; + self.check_cid(continuation)?; self.check_tid(unreachable_result_type)?; - Ok(ValueId(self.vid_gen.next())) + self.add_node_checked( + block, + Op::Jump { + continuation, + unreachable_result_type, + }, + &[arg], + ) } fn add_block(&mut self) -> BlockId { - let block = BlockId(self.bid_gen.next()); - self.blocks.insert(block, BlockState::Detached); - block + self.blocks + .add_block(self.vals.count().0, BlockState::Detached) } fn add_unknown_with( @@ -733,12 +913,8 @@ impl ExprContext for ExprBuilder { args: &[ValueId], result_type: TypeId, ) -> Result { - self.check_bid(block)?; self.check_tid(result_type)?; - for &arg in args { - self.check_vid(arg)?; - } - Ok(ValueId(self.vid_gen.next())) + self.add_node_checked(block, Op::UnknownWith { result_type }, args) } fn add_call( @@ -749,60 +925,82 @@ impl ExprContext for ExprBuilder { callee: FuncName, arg: ValueId, ) -> Result { - self.check_bid(block)?; - self.check_vid(arg)?; - match self.callee_spec_vars.entry(callee_spec_var.into()) { - Entry::Occupied(entry) => { - return Err(ErrorKind::DuplicateCalleeSpecVar(entry.key().clone()).into()); - } - Entry::Vacant(entry) => { - entry.insert(hash_func_name(callee_mod, callee)); - } - } - Ok(ValueId(self.vid_gen.next())) + let callee_spec_var_id = self + .callee_spec_vars + .insert(callee_spec_var.into()) + .map_err(|_| ErrorKind::DuplicateCalleeSpecVar(callee_spec_var.into()))?; + self.add_node_checked( + block, + Op::Call { + callee_spec_var: callee_spec_var_id, + callee_mod: callee_mod.into(), + callee: callee.into(), + }, + &[arg], + ) } fn add_const_ref( &mut self, block: BlockId, - _const_mod: ModName, - _const: ConstName, + const_mod: ModName, + const_: ConstName, ) -> Result { - self.check_bid(block)?; - Ok(ValueId(self.vid_gen.next())) + self.add_node_checked( + block, + Op::ConstRef { + const_mod: const_mod.into(), + const_: const_.into(), + }, + &[], + ) } fn add_choice(&mut self, block: BlockId, cases: &[BlockExpr]) -> Result { - self.check_bid(block)?; for &BlockExpr(case_block, case_ret) in cases { self.attach_block(case_block)?; self.check_vid(case_ret)?; } - Ok(ValueId(self.vid_gen.next())) + self.add_node_checked( + block, + Op::Choice { + cases: SmallVec::from_slice(cases), + }, + &[], + ) } fn add_sub_block(&mut self, block: BlockId, sub_block: BlockExpr) -> Result { - self.check_bid(block)?; self.attach_block(sub_block.0)?; self.check_vid(sub_block.1)?; - Ok(ValueId(self.vid_gen.next())) + self.add_node_checked(block, Op::SubBlock { sub_block }, &[]) } - fn add_terminate(&mut self, block: BlockId, result_type: TypeId) -> Result { - self.check_bid(block)?; - self.check_tid(result_type)?; - Ok(ValueId(self.vid_gen.next())) + fn add_terminate( + &mut self, + block: BlockId, + unreachable_result_type: TypeId, + ) -> Result { + self.check_tid(unreachable_result_type)?; + self.add_node_checked( + block, + Op::Terminate { + unreachable_result_type, + }, + &[], + ) } fn add_new_heap_cell(&mut self, block: BlockId) -> Result { - self.check_bid(block)?; - Ok(ValueId(self.vid_gen.next())) + self.add_node_checked(block, Op::NewHeapCell, &[]) } fn add_touch(&mut self, block: BlockId, heap_cell: ValueId) -> Result { - self.check_bid(block)?; - self.check_vid(heap_cell)?; - Ok(ValueId(self.vid_gen.next())) + self.add_node_checked(block, Op::Touch, &[heap_cell]) + } + + fn add_recursive_touch(&mut self, block: BlockId, object: ValueId) -> Result { + self.add_node_checked(block, Op::RecursiveTouch, &[object]) } fn add_update( @@ -821,18 +1019,22 @@ impl ExprContext for ExprBuilder { update_mode_var: UpdateModeVar, heap_cell: ValueId, ) -> Result { - self.check_bid(block)?; - self.check_vid(heap_cell)?; - if !self.update_mode_vars.insert(update_mode_var.into()) { - return Err(ErrorKind::DuplicateUpdateModeVar(update_mode_var.into()).into()); - } - Ok(ValueId(self.vid_gen.next())) + let update_mode_var_id = self + .update_mode_vars + .insert(update_mode_var.into()) + .map_err(|_| ErrorKind::DuplicateUpdateModeVar(update_mode_var.into()))?; + self.add_node_checked( + block, + Op::UpdateWriteOnly { + update_mode_var: update_mode_var_id, + }, + &[heap_cell], + ) } fn add_empty_bag(&mut self, block: BlockId, item_type: TypeId) -> Result { - self.check_bid(block)?; self.check_tid(item_type)?; - Ok(ValueId(self.vid_gen.next())) + self.add_node_checked(block, Op::EmptyBag { item_type }, &[]) } fn add_bag_insert( @@ -841,100 +1043,101 @@ impl ExprContext for ExprBuilder { bag: ValueId, to_insert: ValueId, ) -> Result { - self.check_bid(block)?; - self.check_vid(bag)?; - self.check_vid(to_insert)?; - Ok(ValueId(self.vid_gen.next())) + self.add_node_checked(block, Op::BagInsert, &[bag, to_insert]) } fn add_bag_get(&mut self, block: BlockId, bag: ValueId) -> Result { - self.check_bid(block)?; - self.check_vid(bag)?; - Ok(ValueId(self.vid_gen.next())) + self.add_node_checked(block, Op::BagGet, &[bag]) } fn add_bag_remove(&mut self, block: BlockId, bag: ValueId) -> Result { - self.check_bid(block)?; - self.check_vid(bag)?; - Ok(ValueId(self.vid_gen.next())) + self.add_node_checked(block, Op::BagRemove, &[bag]) } fn add_make_tuple(&mut self, block: BlockId, field_vals: &[ValueId]) -> Result { - self.check_bid(block)?; - for &field_val in field_vals { - self.check_vid(field_val)?; - } - Ok(ValueId(self.vid_gen.next())) + self.add_node_checked(block, Op::MakeTuple, field_vals) } fn add_get_tuple_field( &mut self, block: BlockId, tuple: ValueId, - _field_idx: u32, + field_idx: u32, ) -> Result { - self.check_bid(block)?; - self.check_vid(tuple)?; - Ok(ValueId(self.vid_gen.next())) + self.add_node_checked(block, Op::GetTupleField { field_idx }, &[tuple]) } fn add_make_union( &mut self, block: BlockId, variant_types: &[TypeId], - _variant_idx: u32, + variant_idx: u32, to_wrap: ValueId, ) -> Result { - self.check_bid(block)?; for &variant_type in variant_types { self.check_tid(variant_type)?; } // TODO: Check variant_idx in range - self.check_vid(to_wrap)?; - Ok(ValueId(self.vid_gen.next())) + self.add_node_checked( + block, + Op::MakeUnion { + variant_types: SmallVec::from_slice(variant_types), + variant_idx, + }, + &[to_wrap], + ) } fn add_unwrap_union( &mut self, block: BlockId, to_unwrap: ValueId, - _variant_idx: u32, + variant_idx: u32, ) -> Result { - self.check_bid(block)?; - self.check_vid(to_unwrap)?; - Ok(ValueId(self.vid_gen.next())) + self.add_node_checked(block, Op::UnwrapUnion { variant_idx }, &[to_unwrap]) } fn add_make_named( &mut self, block: BlockId, - _named_mod: ModName, - _named: TypeName, + named_mod: ModName, + named: TypeName, to_wrap: ValueId, ) -> Result { - self.check_bid(block)?; - self.check_vid(to_wrap)?; - Ok(ValueId(self.vid_gen.next())) + self.add_node_checked( + block, + Op::MakeNamed { + named_mod: named_mod.into(), + named: named.into(), + }, + &[to_wrap], + ) } fn add_unwrap_named( &mut self, block: BlockId, - _named_mod: ModName, - _named: TypeName, + named_mod: ModName, + named: TypeName, to_unwrap: ValueId, ) -> Result { - self.check_bid(block)?; - self.check_vid(to_unwrap)?; - Ok(ValueId(self.vid_gen.next())) + self.add_node_checked( + block, + Op::UnwrapNamed { + named_mod: named_mod.into(), + named: named.into(), + }, + &[to_unwrap], + ) } } /// A `FuncDef` defines the signature and body of a function. pub struct FuncDef { - // We can precompute hashes for all calls because monomorphization isn't implemented yet. - callee_spec_vars: BTreeMap, - update_mode_vars: BTreeSet, + builder: FuncDefBuilder, + arg_type: TypeId, + ret_type: TypeId, + root: BlockExpr, } pub struct FuncDefBuilder { @@ -974,17 +1177,19 @@ impl FuncDefBuilder { self.expr_builder.check_tid(ret_type)?; self.expr_builder.finalize_with_root(root)?; Ok(FuncDef { - callee_spec_vars: self.expr_builder.callee_spec_vars, - update_mode_vars: self.expr_builder.update_mode_vars, + builder: self, + arg_type, + ret_type, + root, }) } } /// A `ConstDef` defines the type and initializer expression for a global constant. pub struct ConstDef { - // We can precompute hashes for all calls because monomorphization isn't implemented yet. - callee_spec_vars: BTreeMap, - update_mode_vars: BTreeSet, + builder: ConstDefBuilder, + type_: TypeId, + root: BlockExpr, } pub struct ConstDefBuilder { @@ -1011,8 +1216,9 @@ impl ConstDefBuilder { self.expr_builder.check_tid(type_)?; self.expr_builder.finalize_with_root(root)?; Ok(ConstDef { - callee_spec_vars: self.expr_builder.callee_spec_vars, - update_mode_vars: self.expr_builder.update_mode_vars, + builder: self, + type_, + root, }) } } @@ -1154,14 +1360,21 @@ pub struct FuncSpec(pub [u8; SPEC_HASH_BYTES]); /// The solution table for an individual specialization. pub struct FuncSpecSolutions { func_def: FuncDef, + callee_specs: IdVec, } impl FuncSpecSolutions { pub fn callee_spec(&self, var: CalleeSpecVar) -> Result { // TODO: The clone here is unnecessary -- avoid it! // (might require something like a transmute) - match self.func_def.callee_spec_vars.get(&var.into()) { - Some(spec) => Ok(*spec), + match self + .func_def + .builder + .expr_builder + .callee_spec_vars + .get_by_val(&var.into()) + { + Some(id) => Ok(self.callee_specs[id]), None => Err(ErrorKind::CalleeSpecVarNotFound(var.into()).into()), } } @@ -1169,10 +1382,16 @@ impl FuncSpecSolutions { pub fn update_mode(&self, var: UpdateModeVar) -> Result { // TODO: The clone here is unnecessary -- avoid it! // (might require something like a transmute) - if !self.func_def.update_mode_vars.contains(&var.into()) { - return Err(ErrorKind::UpdateModeVarNotFound(var.into()).into()); + match self + .func_def + .builder + .expr_builder + .update_mode_vars + .get_by_val(&var.into()) + { + Some(_id) => Ok(UpdateMode::Immutable), + None => Err(ErrorKind::UpdateModeVarNotFound(var.into()).into()), } - Ok(UpdateMode::Immutable) } } @@ -1201,14 +1420,21 @@ impl FuncSolutions { /// Note that, unlike functions, constant definitions cannot have multiple specializations. pub struct ConstSolutions { const_def: ConstDef, + callee_specs: IdVec, } impl ConstSolutions { pub fn callee_spec(&self, var: CalleeSpecVar) -> Result { // TODO: The clone here is unnecessary -- avoid it! // (might require something like a transmute) - match self.const_def.callee_spec_vars.get(&var.into()) { - Some(spec) => Ok(*spec), + match self + .const_def + .builder + .expr_builder + .callee_spec_vars + .get_by_val(&var.into()) + { + Some(id) => Ok(self.callee_specs[id]), None => Err(ErrorKind::CalleeSpecVarNotFound(var.into()).into()), } } @@ -1216,10 +1442,16 @@ impl ConstSolutions { pub fn update_mode(&self, var: UpdateModeVar) -> Result { // TODO: The clone here is unnecessary -- avoid it! // (might require something like a transmute) - if !self.const_def.update_mode_vars.contains(&var.into()) { - return Err(ErrorKind::UpdateModeVarNotFound(var.into()).into()); + match self + .const_def + .builder + .expr_builder + .update_mode_vars + .get_by_val(&var.into()) + { + Some(_id) => Ok(UpdateMode::Immutable), + None => Err(ErrorKind::UpdateModeVarNotFound(var.into()).into()), } - Ok(UpdateMode::Immutable) } } @@ -1280,6 +1512,35 @@ impl Solutions { } } +fn populate_specs( + callee_spec_var_ids: Count, + vals: &OpGraph, +) -> IdVec { + let mut results = IdVec::filled_with(callee_spec_var_ids, || None); + for val_id in vals.count().iter() { + match vals.node(val_id) { + Node { + op: + Op::Call { + callee_spec_var, + callee_mod, + callee, + }, + inputs: _, + } => { + replace_none( + &mut results[callee_spec_var], + hash_func_name(callee_mod.borrowed(), callee.borrowed()), + ) + .unwrap(); + } + + _ => {} + } + } + results.into_mapped(|_, spec| spec.unwrap()) +} + pub fn solve(program: Program) -> Result { Ok(Solutions { mods: program @@ -1291,9 +1552,16 @@ pub fn solve(program: Program) -> Result { .func_defs .into_iter() .map(|(func_name, func_def)| { + let callee_specs = populate_specs( + func_def.builder.expr_builder.callee_spec_vars.count(), + &func_def.builder.expr_builder.vals, + ); let func_sols = FuncSolutions { spec: hash_func_name(mod_name.borrowed(), func_name.borrowed()), - spec_solutions: FuncSpecSolutions { func_def }, + spec_solutions: FuncSpecSolutions { + func_def, + callee_specs, + }, }; (func_name, func_sols) }) @@ -1301,7 +1569,19 @@ pub fn solve(program: Program) -> Result { consts: mod_def .const_defs .into_iter() - .map(|(const_name, const_def)| (const_name, ConstSolutions { const_def })) + .map(|(const_name, const_def)| { + let callee_specs = populate_specs( + const_def.builder.expr_builder.callee_spec_vars.count(), + &const_def.builder.expr_builder.vals, + ); + ( + const_name, + ConstSolutions { + const_def, + callee_specs, + }, + ) + }) .collect(), }; (mod_name, mod_sols) diff --git a/vendor/morphic_lib/src/bindings.rs b/vendor/morphic_lib/src/bindings.rs index c8864e30d9..72ce812cf8 100644 --- a/vendor/morphic_lib/src/bindings.rs +++ b/vendor/morphic_lib/src/bindings.rs @@ -218,27 +218,28 @@ pub unsafe extern "C" fn Morphic_FuncDefBuilder_Build( } #[no_mangle] -pub unsafe extern "C" fn Morphic_FuncDefBuilder_DeclareJoinPoint( +pub unsafe extern "C" fn Morphic_FuncDefBuilder_DeclareContinuation( self_: *mut FuncDefBuilder, block: BlockId, arg_type: TypeId, ret_type: TypeId, - out0: *mut JoinPointId, + out0: *mut ContinuationId, out1: *mut ValueId, ) -> *mut Error { - let (join_point, value) = check_err!((*self_).declare_join_point(block, arg_type, ret_type)); - *out0 = join_point; + let (continuation, value) = + check_err!((*self_).declare_continuation(block, arg_type, ret_type)); + *out0 = continuation; *out1 = value; ptr::null_mut() } #[no_mangle] -pub unsafe extern "C" fn Morphic_FuncDefBuilder_DefineJoinPoint( +pub unsafe extern "C" fn Morphic_FuncDefBuilder_DefineContinuation( self_: *mut FuncDefBuilder, - join_point: JoinPointId, + continuation: ContinuationId, body: BlockExpr, ) -> *mut Error { - check_err!((*self_).define_join_point(join_point, body)); + check_err!((*self_).define_continuation(continuation, body)); ptr::null_mut() } @@ -246,12 +247,12 @@ pub unsafe extern "C" fn Morphic_FuncDefBuilder_DefineJoinPoint( pub unsafe extern "C" fn Morphic_FuncDefBuilder_AddJump( self_: *mut FuncDefBuilder, block: BlockId, - join_point: JoinPointId, + continuation: ContinuationId, arg: ValueId, unreachable_result_type: TypeId, out: *mut ValueId, ) -> *mut Error { - *out = check_err!((*self_).add_jump(block, join_point, arg, unreachable_result_type)); + *out = check_err!((*self_).add_jump(block, continuation, arg, unreachable_result_type)); ptr::null_mut() } diff --git a/vendor/morphic_lib/src/util/bytes_id.rs b/vendor/morphic_lib/src/util/bytes_id.rs index a5168c4c71..328fba47b8 100644 --- a/vendor/morphic_lib/src/util/bytes_id.rs +++ b/vendor/morphic_lib/src/util/bytes_id.rs @@ -4,13 +4,15 @@ macro_rules! bytes_id { $(#[$annot_borrowed:meta])* $borrowed_vis:vis $borrowed:ident; $(#[$annot_owned:meta])* $owned_vis:vis $owned:ident; ) => { - #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)] + #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] $(#[$annot_borrowed])* $borrowed_vis struct $borrowed<'a>($borrowed_vis &'a [u8]); - #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] + // The stack-allocated array portion of a `SmallVec` shares a union with two `usize`s, so on + // 64-bit platforms we can make the array up to 16 bytes long with no space penalty. + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] $(#[$annot_owned])* - $owned_vis struct $owned($owned_vis ::std::vec::Vec); + $owned_vis struct $owned($owned_vis ::smallvec::SmallVec<[u8; 16]>); impl $owned { fn borrowed<'a>(&'a self) -> $borrowed<'a> { @@ -20,7 +22,7 @@ macro_rules! bytes_id { impl<'a> ::std::convert::From<$borrowed<'a>> for $owned { fn from(borrowed: $borrowed<'a>) -> Self { - $owned(<[u8]>::to_vec(&borrowed.0)) + $owned(::smallvec::SmallVec::from_slice(&borrowed.0)) } } } diff --git a/vendor/morphic_lib/src/util/mod.rs b/vendor/morphic_lib/src/util/mod.rs index a58e87cdac..b382f997cd 100644 --- a/vendor/morphic_lib/src/util/mod.rs +++ b/vendor/morphic_lib/src/util/mod.rs @@ -1,5 +1,14 @@ +#[macro_use] +pub mod id_type; + #[macro_use] pub mod bytes_id; #[macro_use] pub mod forward_trait; + +pub mod blocks; +pub mod id_bi_map; +pub mod id_vec; +pub mod op_graph; +pub mod replace_none; From dee0abca5d46f32f45653230b9510281392a864f Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 2 Jun 2021 16:59:48 +0200 Subject: [PATCH 086/496] changes to modelling RC --- compiler/mono/src/alias_analysis.rs | 24 ++++++++++++++++++------ 1 file changed, 18 insertions(+), 6 deletions(-) diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index b328a11975..63a0abbccc 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -215,17 +215,29 @@ fn stmt_spec( } Ret(symbol) => Ok(env.symbols[symbol]), Refcounting(modify_rc, continuation) => match modify_rc { - ModifyRc::Inc(symbol, _) | ModifyRc::Dec(symbol) => { - let result_type = builder.add_tuple_type(&[])?; + ModifyRc::Inc(symbol, _) => { let argument = env.symbols[symbol]; - // this is how RC is modelled; it recursively touches all heap cells - builder.add_unknown_with(block, &[argument], result_type)?; + // inc is non-recursive + builder.add_touch(block, argument)?; stmt_spec(builder, env, block, layout, continuation) } - ModifyRc::DecRef(_symbol) => { - // TODO a decref is a non-recursive decrement of a structure + + ModifyRc::Dec(symbol) => { + let argument = env.symbols[symbol]; + + // dec may be recursive + builder.add_recursive_touch(block, argument)?; + + stmt_spec(builder, env, block, layout, continuation) + } + ModifyRc::DecRef(symbol) => { + let argument = env.symbols[symbol]; + + // decref is non-recursive + builder.add_touch(block, argument)?; + stmt_spec(builder, env, block, layout, continuation) } }, From 8f5d1fa48f56387df6d066bbdca7b031f263dd05 Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 2 Jun 2021 17:05:36 +0200 Subject: [PATCH 087/496] treat more things as unit value/type --- compiler/mono/src/alias_analysis.rs | 28 ++++++++-------------------- 1 file changed, 8 insertions(+), 20 deletions(-) diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 63a0abbccc..a1b72529fd 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -440,8 +440,14 @@ fn lowlevel_spec( builder.add_sub_block(block, sub_block) } - Eq | NotEq => new_bool(builder, block), - NumLte | NumLt | NumGt | NumGte => new_order(builder, block), + Eq | NotEq => { + // just dream up a unit value + builder.add_make_tuple(block, &[]) + } + NumLte | NumLt | NumGt | NumGte => { + // just dream up a unit value + builder.add_make_tuple(block, &[]) + } ListLen => { // just dream up a unit value builder.add_make_tuple(block, &[]) @@ -747,24 +753,6 @@ fn new_static_string(builder: &mut FuncDefBuilder, block: BlockId) -> Result Result { - // always generats EQ - let tag_id = 0; - - let unit = builder.add_tuple_type(&[])?; - let unit_value = builder.add_make_tuple(block, &[])?; - builder.add_make_union(block, &[unit, unit, unit], tag_id, unit_value) -} - -fn new_bool(builder: &mut FuncDefBuilder, block: BlockId) -> Result { - // always generats False - let tag_id = 0; - - let unit = builder.add_tuple_type(&[])?; - let unit_value = builder.add_make_tuple(block, &[])?; - builder.add_make_union(block, &[unit, unit], tag_id, unit_value) -} - fn new_num(builder: &mut FuncDefBuilder, block: BlockId) -> Result { // we model all our numbers as unit values builder.add_make_tuple(block, &[]) From ab8abb8f1188700edb723dc6103b2dc9c249252d Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 2 Jun 2021 21:28:51 +0200 Subject: [PATCH 088/496] centralize llvm logic --- cli/src/repl/gen.rs | 63 ++------------- compiler/build/src/program.rs | 55 +------------ compiler/gen/src/llvm/build.rs | 110 +++++++++++++++++++++++++- compiler/test_gen/src/helpers/eval.rs | 62 +-------------- 4 files changed, 120 insertions(+), 170 deletions(-) diff --git a/cli/src/repl/gen.rs b/cli/src/repl/gen.rs index 5a30b723fe..49d47e54a3 100644 --- a/cli/src/repl/gen.rs +++ b/cli/src/repl/gen.rs @@ -8,7 +8,7 @@ use roc_can::builtins::builtin_defs_map; use roc_collections::all::{MutMap, MutSet}; use roc_fmt::annotation::Formattable; use roc_fmt::annotation::{Newlines, Parens}; -use roc_gen::llvm::build::{build_proc, build_proc_header, OptLevel}; +use roc_gen::llvm::build::OptLevel; use roc_gen::llvm::externs::add_default_roc_externs; use roc_load::file::LoadingProblem; use roc_parse::parser::SyntaxError; @@ -68,7 +68,7 @@ pub fn gen_and_eval<'a>( use roc_load::file::MonomorphizedModule; let MonomorphizedModule { - mut procedures, + procedures, interns, exposed_to_host, mut subs, @@ -185,63 +185,10 @@ pub fn gen_and_eval<'a>( exposed_to_host: MutSet::default(), }; - let mut layout_ids = roc_mono::layout::LayoutIds::default(); - let mut headers = Vec::with_capacity(procedures.len()); - - // Add all the Proc headers to the module. - // We have to do this in a separate pass first, - // because their bodies may reference each other. - let mut scope = roc_gen::llvm::build::Scope::default(); - for ((symbol, layout), proc) in procedures.drain() { - let fn_val = build_proc_header(&env, &mut layout_ids, symbol, layout, &proc); - - if proc.args.is_empty() { - // this is a 0-argument thunk, i.e. a top-level constant definition - // it must be in-scope everywhere in the module! - scope.insert_top_level_thunk(symbol, arena.alloc(layout), fn_val); - } - - headers.push((proc, fn_val)); - } - - // Build each proc using its header info. - for (proc, fn_val) in headers { - let mut current_scope = scope.clone(); - - // only have top-level thunks for this proc's module in scope - // this retain is not needed for correctness, but will cause less confusion when debugging - let home = proc.name.module_id(); - current_scope.retain_top_level_thunks_for_module(home); - - build_proc(&env, &mut layout_ids, scope.clone(), proc, fn_val); - - // call finalize() before any code generation/verification - env.dibuilder.finalize(); - - if fn_val.verify(true) { - function_pass.run_on(&fn_val); - } else { - let mode = "NON-OPTIMIZED"; - - eprintln!( - "\n\nFunction {:?} failed LLVM verification in {} build. Its content was:\n", - fn_val.get_name().to_str().unwrap(), - mode, - ); - - fn_val.print_to_stderr(); - - panic!( - "The preceding code was from {:?}, which failed LLVM verification in {} build.", - fn_val.get_name().to_str().unwrap(), - mode, - ); - } - } - - let (main_fn_name, main_fn) = roc_gen::llvm::build::promote_to_main_function( + let (main_fn_name, main_fn) = roc_gen::llvm::build::build_procedures_return_main( &env, - &mut layout_ids, + opt_level, + procedures, main_fn_symbol, main_fn_layout, ); diff --git a/compiler/build/src/program.rs b/compiler/build/src/program.rs index afdfcbaf38..4d087664c0 100644 --- a/compiler/build/src/program.rs +++ b/compiler/build/src/program.rs @@ -3,9 +3,8 @@ use bumpalo::Bump; use inkwell::context::Context; use inkwell::targets::{CodeModel, FileType, RelocMode}; pub use roc_gen::llvm::build::FunctionIterator; -use roc_gen::llvm::build::{build_proc, build_proc_header, module_from_builtins, OptLevel, Scope}; +use roc_gen::llvm::build::{module_from_builtins, OptLevel}; use roc_load::file::MonomorphizedModule; -use roc_mono::layout::LayoutIds; use std::path::{Path, PathBuf}; use std::time::{Duration, SystemTime}; use target_lexicon::Triple; @@ -121,7 +120,7 @@ pub fn gen_from_mono_module( let builder = context.create_builder(); let (dibuilder, compile_unit) = roc_gen::llvm::build::Env::new_debug_info(module); - let (mpm, fpm) = roc_gen::llvm::build::construct_optimization_passes(module, opt_level); + let (mpm, _fpm) = roc_gen::llvm::build::construct_optimization_passes(module, opt_level); // Compile and add all the Procs before adding main let ptr_bytes = target.pointer_width().unwrap().bytes() as u32; @@ -138,55 +137,7 @@ pub fn gen_from_mono_module( exposed_to_host: loaded.exposed_to_host.keys().copied().collect(), }; - // Populate Procs further and get the low-level Expr from the canonical Expr - let mut headers = Vec::with_capacity(loaded.procedures.len()); - - // Add all the Proc headers to the module. - // We have to do this in a separate pass first, - // because their bodies may reference each other. - let mut layout_ids = LayoutIds::default(); - - let mut scope = Scope::default(); - for ((symbol, layout), proc) in loaded.procedures { - let fn_val = build_proc_header(&env, &mut layout_ids, symbol, layout, &proc); - - if proc.args.is_empty() { - // this is a 0-argument thunk, i.e. a top-level constant definition - // it must be in-scope everywhere in the module! - scope.insert_top_level_thunk(symbol, arena.alloc(layout), fn_val); - } - - headers.push((proc, fn_val)); - } - - // Build each proc using its header info. - for (proc, fn_val) in headers { - // NOTE: This is here to be uncommented in case verification fails. - // (This approach means we don't have to defensively clone name here.) - // - // println!("\n\nBuilding and then verifying function {:?}\n\n", proc); - build_proc(&env, &mut layout_ids, scope.clone(), proc, fn_val); - - // call finalize() before any code generation/verification - env.dibuilder.finalize(); - - if fn_val.verify(true) { - fpm.run_on(&fn_val); - } else { - fn_val.print_to_stderr(); - - // write the ll code to a file, so we can modify it - env.module.print_to_file(&app_ll_file).unwrap(); - - // env.module.print_to_stderr(); - // NOTE: If this fails, uncomment the above println to debug. - panic!( - r"Non-main function {:?} failed LLVM verification. I wrote the full LLVM IR to {:?}", - fn_val.get_name(), - app_ll_file, - ); - } - } + roc_gen::llvm::build::build_procedures(&env, opt_level, loaded.procedures); env.dibuilder.finalize(); diff --git a/compiler/gen/src/llvm/build.rs b/compiler/gen/src/llvm/build.rs index 921f0fa741..01e092a8d3 100644 --- a/compiler/gen/src/llvm/build.rs +++ b/compiler/gen/src/llvm/build.rs @@ -44,7 +44,7 @@ use inkwell::values::{ use inkwell::OptimizationLevel; use inkwell::{AddressSpace, IntPredicate}; use roc_builtins::bitcode; -use roc_collections::all::{ImMap, MutSet}; +use roc_collections::all::{ImMap, MutMap, MutSet}; use roc_module::ident::TagName; use roc_module::low_level::LowLevel; use roc_module::symbol::{Interns, ModuleId, Symbol}; @@ -2985,7 +2985,113 @@ fn make_exception_catching_wrapper<'a, 'ctx, 'env>( wrapper_function } -pub fn build_proc_header<'a, 'ctx, 'env>( +pub fn build_proc_headers<'a, 'ctx, 'env>( + env: &Env<'a, 'ctx, 'env>, + layout_ids: &mut LayoutIds<'a>, + procedures: MutMap<(Symbol, TopLevelFunctionLayout<'a>), roc_mono::ir::Proc<'a>>, + scope: &mut Scope<'a, 'ctx>, + // alias_analysis_solutions: AliasAnalysisSolutions, +) -> std::vec::Vec<(roc_mono::ir::Proc<'a>, FunctionValue<'ctx>)> { + // Populate Procs further and get the low-level Expr from the canonical Expr + let mut headers = std::vec::Vec::with_capacity(procedures.len()); + for ((symbol, layout), proc) in procedures { + let fn_val = build_proc_header(env, layout_ids, symbol, layout, &proc); + + if proc.args.is_empty() { + // this is a 0-argument thunk, i.e. a top-level constant definition + // it must be in-scope everywhere in the module! + scope.insert_top_level_thunk(symbol, env.arena.alloc(layout), fn_val); + } + + headers.push((proc, fn_val)); + } + + headers +} + +pub fn build_procedures<'a, 'ctx, 'env>( + env: &Env<'a, 'ctx, 'env>, + opt_level: OptLevel, + procedures: MutMap<(Symbol, TopLevelFunctionLayout<'a>), roc_mono::ir::Proc<'a>>, + // alias_analysis_solutions: AliasAnalysisSolutions, +) { + build_procedures_help(env, opt_level, procedures, None); +} + +pub fn build_procedures_return_main<'a, 'ctx, 'env>( + env: &Env<'a, 'ctx, 'env>, + opt_level: OptLevel, + procedures: MutMap<(Symbol, TopLevelFunctionLayout<'a>), roc_mono::ir::Proc<'a>>, + // alias_analysis_solutions: AliasAnalysisSolutions, + main_fn_symbol: Symbol, + main_fn_layout: TopLevelFunctionLayout<'a>, +) -> (&'static str, FunctionValue<'ctx>) { + build_procedures_help( + env, + opt_level, + procedures, + Some((main_fn_symbol, main_fn_layout)), + ) + .unwrap() +} + +fn build_procedures_help<'a, 'ctx, 'env>( + env: &Env<'a, 'ctx, 'env>, + opt_level: OptLevel, + procedures: MutMap<(Symbol, TopLevelFunctionLayout<'a>), roc_mono::ir::Proc<'a>>, + main_data: Option<(Symbol, TopLevelFunctionLayout<'a>)>, +) -> Option<(&'static str, FunctionValue<'ctx>)> { + let mut layout_ids = roc_mono::layout::LayoutIds::default(); + let mut scope = Scope::default(); + + // Add all the Proc headers to the module. + // We have to do this in a separate pass first, + // because their bodies may reference each other. + let headers = build_proc_headers(env, &mut layout_ids, procedures, &mut scope); + + let (_, function_pass) = construct_optimization_passes(env.module, opt_level); + + for (proc, fn_val) in headers { + let mut current_scope = scope.clone(); + + // only have top-level thunks for this proc's module in scope + // this retain is not needed for correctness, but will cause less confusion when debugging + let home = proc.name.module_id(); + current_scope.retain_top_level_thunks_for_module(home); + + build_proc(&env, &mut layout_ids, scope.clone(), proc, fn_val); + + // call finalize() before any code generation/verification + env.dibuilder.finalize(); + + if fn_val.verify(true) { + function_pass.run_on(&fn_val); + } else { + let mode = "NON-OPTIMIZED"; + + eprintln!( + "\n\nFunction {:?} failed LLVM verification in {} build. Its content was:\n", + fn_val.get_name().to_str().unwrap(), + mode, + ); + + fn_val.print_to_stderr(); + // module.print_to_stderr(); + + panic!( + "The preceding code was from {:?}, which failed LLVM verification in {} build.", + fn_val.get_name().to_str().unwrap(), + mode, + ); + } + } + + main_data.map(|(main_fn_symbol, main_fn_layout)| { + promote_to_main_function(env, &mut layout_ids, main_fn_symbol, main_fn_layout) + }) +} + +fn build_proc_header<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, layout_ids: &mut LayoutIds<'a>, symbol: Symbol, diff --git a/compiler/test_gen/src/helpers/eval.rs b/compiler/test_gen/src/helpers/eval.rs index aa7e6b786b..14dffa71d5 100644 --- a/compiler/test_gen/src/helpers/eval.rs +++ b/compiler/test_gen/src/helpers/eval.rs @@ -36,7 +36,6 @@ pub fn helper<'a>( ignore_problems: bool, context: &'a inkwell::context::Context, ) -> (&'static str, String, Library) { - use roc_gen::llvm::build::{build_proc, build_proc_header, Scope}; use std::path::{Path, PathBuf}; let filename = PathBuf::from("Test.roc"); @@ -79,7 +78,7 @@ pub fn helper<'a>( use roc_load::file::MonomorphizedModule; let MonomorphizedModule { - mut procedures, + procedures, interns, exposed_to_host, .. @@ -236,63 +235,10 @@ pub fn helper<'a>( exposed_to_host: MutSet::default(), }; - let mut layout_ids = roc_mono::layout::LayoutIds::default(); - let mut headers = Vec::with_capacity(procedures.len()); - - // Add all the Proc headers to the module. - // We have to do this in a separate pass first, - // because their bodies may reference each other. - let mut scope = Scope::default(); - for ((symbol, layout), proc) in procedures.drain() { - let fn_val = build_proc_header(&env, &mut layout_ids, symbol, layout, &proc); - - if proc.args.is_empty() { - // this is a 0-argument thunk, i.e. a top-level constant definition - // it must be in-scope everywhere in the module! - scope.insert_top_level_thunk(symbol, arena.alloc(layout), fn_val); - } - - headers.push((proc, fn_val)); - } - - // Build each proc using its header info. - for (proc, fn_val) in headers { - let mut current_scope = scope.clone(); - - // only have top-level thunks for this proc's module in scope - // this retain is not needed for correctness, but will cause less confusion when debugging - let home = proc.name.module_id(); - current_scope.retain_top_level_thunks_for_module(home); - - build_proc(&env, &mut layout_ids, scope.clone(), proc, fn_val); - - // call finalize() before any code generation/verification - env.dibuilder.finalize(); - - if fn_val.verify(true) { - function_pass.run_on(&fn_val); - } else { - let mode = "NON-OPTIMIZED"; - - eprintln!( - "\n\nFunction {:?} failed LLVM verification in {} build. Its content was:\n", - fn_val.get_name().to_str().unwrap(), - mode, - ); - - fn_val.print_to_stderr(); - // module.print_to_stderr(); - - panic!( - "The preceding code was from {:?}, which failed LLVM verification in {} build.", - fn_val.get_name().to_str().unwrap(), - mode, - ); - } - } - let (main_fn_name, main_fn) = roc_gen::llvm::build::promote_to_main_function( + let (main_fn_name, main_fn) = roc_gen::llvm::build::build_procedures_return_main( &env, - &mut layout_ids, + opt_level, + procedures, main_fn_symbol, main_fn_layout, ); From 07e16469e40c43e9d8efc964d1ce4ba6c19c8676 Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 2 Jun 2021 21:38:31 +0200 Subject: [PATCH 089/496] morphic stuff can happen in the LLVM backend alone --- compiler/gen/src/llvm/build.rs | 26 ++++++++++++++++++++++++++ compiler/load/src/file.rs | 29 ----------------------------- 2 files changed, 26 insertions(+), 29 deletions(-) diff --git a/compiler/gen/src/llvm/build.rs b/compiler/gen/src/llvm/build.rs index 01e092a8d3..5822e06240 100644 --- a/compiler/gen/src/llvm/build.rs +++ b/compiler/gen/src/llvm/build.rs @@ -3035,6 +3035,18 @@ pub fn build_procedures_return_main<'a, 'ctx, 'env>( .unwrap() } +// Coming soon +// pub enum AliasAnalysisSolutions { +// NotAvailable, +// Available(morphic_lib::Solutions), +// } +// +// impl std::fmt::Debug for AliasAnalysisSolutions { +// fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { +// write!(f, "AliasAnalysisSolutions {{}}") +// } +// } + fn build_procedures_help<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, opt_level: OptLevel, @@ -3044,6 +3056,20 @@ fn build_procedures_help<'a, 'ctx, 'env>( let mut layout_ids = roc_mono::layout::LayoutIds::default(); let mut scope = Scope::default(); + // Coming Soon + // + // if false { + // let it = state.procedures.iter().map(|x| x.1); + // + // match roc_mono::alias_analysis::spec_program(it) { + // Err(e) => panic!("Error in alias analysis: {:?}", e), + // Ok(solutions) => { + // state.alias_analysis_solutions = + // AliasAnalysisSolutions::Available(solutions) + // } + // } + // } + // Add all the Proc headers to the module. // We have to do this in a separate pass first, // because their bodies may reference each other. diff --git a/compiler/load/src/file.rs b/compiler/load/src/file.rs index cf9ff87acc..e1273e0335 100644 --- a/compiler/load/src/file.rs +++ b/compiler/load/src/file.rs @@ -706,7 +706,6 @@ pub struct MonomorphizedModule<'a> { pub type_problems: MutMap>, pub mono_problems: MutMap>, pub procedures: MutMap<(Symbol, TopLevelFunctionLayout<'a>), Proc<'a>>, - pub alias_analysis_solutions: AliasAnalysisSolutions, pub exposed_to_host: MutMap, pub header_sources: MutMap)>, pub sources: MutMap)>, @@ -864,19 +863,6 @@ struct State<'a> { pub layout_caches: std::vec::Vec>, pub procs: Procs<'a>, - - pub alias_analysis_solutions: AliasAnalysisSolutions, -} - -pub enum AliasAnalysisSolutions { - NotAvailable, - Available(morphic_lib::Solutions), -} - -impl std::fmt::Debug for AliasAnalysisSolutions { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(f, "AliasAnalysisSolutions {{}}") - } } #[derive(Debug)] @@ -1486,7 +1472,6 @@ where specializations_in_flight: 0, layout_caches: std::vec::Vec::with_capacity(num_cpus::get()), procs: Procs::new_in(arena), - alias_analysis_solutions: AliasAnalysisSolutions::NotAvailable, }; // We've now distributed one worker queue to each thread. @@ -2085,18 +2070,6 @@ fn update<'a>( &mut state.procedures, ); - if false { - let it = state.procedures.iter().map(|x| x.1); - - match roc_mono::alias_analysis::spec_program(it) { - Err(e) => panic!("Error in alias analysis: {:?}", e), - Ok(solutions) => { - state.alias_analysis_solutions = - AliasAnalysisSolutions::Available(solutions) - } - } - } - state.constrained_ident_ids.insert(module_id, ident_ids); for (module_id, requested) in external_specializations_requested { @@ -2176,7 +2149,6 @@ fn finish_specialization( let State { procedures, - alias_analysis_solutions, module_cache, output_path, platform_path, @@ -2238,7 +2210,6 @@ fn finish_specialization( subs, interns, procedures, - alias_analysis_solutions, sources, header_sources, timings: state.timings, From 427bb786af5910d2d0830c2a8ef364a57f2ce6c6 Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 2 Jun 2021 21:48:29 +0200 Subject: [PATCH 090/496] add new morphic files --- vendor/morphic_lib/src/util/blocks.rs | 116 ++++++++++ vendor/morphic_lib/src/util/id_bi_map.rs | 58 +++++ vendor/morphic_lib/src/util/id_type.rs | 104 +++++++++ vendor/morphic_lib/src/util/id_vec.rs | 244 ++++++++++++++++++++ vendor/morphic_lib/src/util/op_graph.rs | 73 ++++++ vendor/morphic_lib/src/util/replace_none.rs | 13 ++ 6 files changed, 608 insertions(+) create mode 100644 vendor/morphic_lib/src/util/blocks.rs create mode 100644 vendor/morphic_lib/src/util/id_bi_map.rs create mode 100644 vendor/morphic_lib/src/util/id_type.rs create mode 100644 vendor/morphic_lib/src/util/id_vec.rs create mode 100644 vendor/morphic_lib/src/util/op_graph.rs create mode 100644 vendor/morphic_lib/src/util/replace_none.rs diff --git a/vendor/morphic_lib/src/util/blocks.rs b/vendor/morphic_lib/src/util/blocks.rs new file mode 100644 index 0000000000..fb840c2fbb --- /dev/null +++ b/vendor/morphic_lib/src/util/blocks.rs @@ -0,0 +1,116 @@ +use crate::util::id_type::{Count, Id}; +use crate::util::id_vec::IdVec; +use crate::util::replace_none::replace_none; + +id_type! { + BlockFragId(u32); +} + +/// A "fragment" of a block, representing a run of consecutive `ValId`s and a pointer to the next +/// fragment. +#[derive(Clone, Debug)] +struct BlockFrag { + /// Inclusive bound + min_val: ValId, + /// Exclusive bound + max_val: ValId, + next: Option, +} + +#[derive(Clone, Debug)] +struct BlockData { + head: BlockFragId, + tail: BlockFragId, + info: BlockInfo, +} + +/// Conceptually represents a collection of the form `IdVec, BlockInfo)>`. +/// +/// Each tuple `(Vec, BlockInfo)` is called a "block". +/// +/// The blocks are actually stored in a single contiguous buffer to reduce the number of heap +/// allocations, and blocks with long runs of consecutive `ValId`s are stored in a compressed +/// representation. +#[derive(Clone, Debug)] +pub struct Blocks { + frags: IdVec>, + blocks: IdVec>, +} + +impl Blocks { + pub fn new() -> Self { + Self { + frags: IdVec::new(), + blocks: IdVec::new(), + } + } + + pub fn len(&self) -> usize { + self.blocks.len() + } + + pub fn block_count(&self) -> Count { + self.blocks.count() + } + + pub fn add_block(&mut self, start_hint: ValId, info: BlockInfo) -> BlockId { + let frag = BlockFrag { + min_val: start_hint.clone(), + max_val: start_hint, + next: None, + }; + let frag_id = self.frags.push(frag); + self.blocks.push(BlockData { + head: frag_id, + tail: frag_id, + info, + }) + } + + pub fn add_value(&mut self, block_id: BlockId, val_id: ValId) { + let block = &mut self.blocks[block_id]; + let tail_frag = &mut self.frags[block.tail]; + let next_val = ValId::from_index_or_panic(tail_frag.max_val.to_index() + 1); + if tail_frag.max_val.to_index() == val_id.to_index() { + tail_frag.max_val = next_val; + } else { + let new_tail = BlockFrag { + min_val: val_id, + max_val: next_val, + next: None, + }; + let new_tail_id = self.frags.push(new_tail); + replace_none(&mut self.frags[block.tail].next, new_tail_id).unwrap(); + block.tail = new_tail_id; + } + } + + pub fn block_info(&self, block_id: BlockId) -> &BlockInfo { + &self.blocks[block_id].info + } + + pub fn block_info_mut(&mut self, block_id: BlockId) -> &mut BlockInfo { + &mut self.blocks[block_id].info + } + + pub fn block_values<'a>(&'a self, block_id: BlockId) -> impl Iterator + 'a { + let mut frag = &self.frags[self.blocks[block_id].head]; + let mut val = frag.min_val.clone(); + std::iter::from_fn(move || { + while val.to_index() >= frag.max_val.to_index() { + match frag.next { + Some(next) => { + frag = &self.frags[next]; + val = frag.min_val.clone(); + } + None => { + return None; + } + } + } + let this_val = val.clone(); + val = ValId::from_index_unchecked(val.to_index() + 1); + Some(this_val) + }) + } +} diff --git a/vendor/morphic_lib/src/util/id_bi_map.rs b/vendor/morphic_lib/src/util/id_bi_map.rs new file mode 100644 index 0000000000..8b7c31621e --- /dev/null +++ b/vendor/morphic_lib/src/util/id_bi_map.rs @@ -0,0 +1,58 @@ +use std::collections::hash_map::{Entry, HashMap}; +use std::hash::Hash; +use std::ops::Deref; + +use crate::util::id_type::Id; +use crate::util::id_vec::IdVec; + +/// Conceptually represents a collection of the form `IdVec` where the `V` values are unique. +/// +/// The collection is implemented such that lookups from `V` values to `K` keys are efficient. +#[derive(Clone, Debug)] +pub struct IdBiMap { + key_to_val: IdVec, + val_to_key: HashMap, +} + +impl Default for IdBiMap { + fn default() -> Self { + Self::new() + } +} + +impl Deref for IdBiMap { + type Target = IdVec; + + fn deref(&self) -> &Self::Target { + &self.key_to_val + } +} + +impl IdBiMap { + pub fn new() -> Self { + IdBiMap { + key_to_val: IdVec::new(), + val_to_key: HashMap::new(), + } + } + + /// Insert a new unique value into the bi-map. + /// + /// If the value is not already present, returns an `Ok` value with the new index of the value. + /// + /// If the value is already present, returns an `Err` value with the existing index. + pub fn insert(&mut self, val: V) -> Result { + match self.val_to_key.entry(val) { + Entry::Occupied(occupied) => Err(occupied.get().clone()), + Entry::Vacant(vacant) => { + let new_index = self.key_to_val.push(vacant.key().clone()); + vacant.insert(new_index.clone()); + Ok(new_index) + } + } + } + + pub fn get_by_val(&self, val: &V) -> Option { + self.val_to_key.get(val).cloned() + } +} diff --git a/vendor/morphic_lib/src/util/id_type.rs b/vendor/morphic_lib/src/util/id_type.rs new file mode 100644 index 0000000000..047e2886da --- /dev/null +++ b/vendor/morphic_lib/src/util/id_type.rs @@ -0,0 +1,104 @@ +use std::cmp::Ordering; + +/// Abstracts over types which wrap numerical indices. +pub trait Id: Clone { + /// The maximum `usize` representable by this type. + const MAX_USIZE: usize; + + /// Convert from `usize` to `Self`, potentially silently wrapping if the `usize` is out of + /// range. + /// + /// In debug builds, we may still perform a check. + fn from_index_unchecked(idx: usize) -> Self; + + /// Check that a `usize` is in range for `Self`, panicking with an informative error message if + /// not. + fn assert_in_range(idx: usize); + + /// Convert from `usize` to `Self`, panicking if the `usize` is out of range. + fn from_index_or_panic(idx: usize) -> Self { + Self::assert_in_range(idx); + Self::from_index_unchecked(idx) + } + + /// Convert from `Self` to `usize`. This should never fail. + fn to_index(&self) -> usize; +} + +macro_rules! id_type { + ($(#[$annot:meta])* $id_vis:vis $name:ident($wrapped:ty); ) => { + $(#[$annot])* + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] + $id_vis struct $name($id_vis $wrapped); + + impl $crate::util::id_type::Id for $name { + const MAX_USIZE: usize = <$wrapped>::MAX as usize; + + fn from_index_unchecked(idx: usize) -> Self { + if cfg!(debug_assertions) { + ::assert_in_range(idx); + } + $name(idx as $wrapped) + } + + fn assert_in_range(idx: usize) { + if idx > Self::MAX_USIZE { + panic!( + "index {} overflows range of type '{}' (backed by {})", + idx, + stringify!(name), + stringify!($wrapped), + ); + } + } + + fn to_index(&self) -> usize { + self.0 as usize + } + } + + // Custom Debug impl avoid multi-line formatting when formatted with {:#?} + impl ::std::fmt::Debug for $name { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + write!(f, "{}({})", stringify!($name), self.0) + } + } + + impl ::std::cmp::PartialEq<$crate::util::id_type::Count<$name>> for $name { + fn eq(&self, other: &$crate::util::id_type::Count<$name>) -> bool { + self.eq(&other.0) + } + } + + impl ::std::cmp::PartialOrd<$crate::util::id_type::Count<$name>> for $name { + fn partial_cmp( + &self, + other: &$crate::util::id_type::Count<$name>, + ) -> Option<::std::cmp::Ordering> { + self.partial_cmp(&other.0) + } + } + } +} + +/// `Count(x)` represents the range of ids `0..x`. +#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct Count(pub T); + +impl PartialEq for Count { + fn eq(&self, other: &T) -> bool { + self.0.eq(other) + } +} + +impl PartialOrd for Count { + fn partial_cmp(&self, other: &T) -> Option { + self.0.partial_cmp(other) + } +} + +impl Count { + pub fn iter(&self) -> impl Iterator { + (0..self.0.to_index()).map(T::from_index_unchecked) + } +} diff --git a/vendor/morphic_lib/src/util/id_vec.rs b/vendor/morphic_lib/src/util/id_vec.rs new file mode 100644 index 0000000000..99a53fce74 --- /dev/null +++ b/vendor/morphic_lib/src/util/id_vec.rs @@ -0,0 +1,244 @@ +use std::borrow::Borrow; +use std::fmt::{self, Debug}; +use std::iter; +use std::marker::PhantomData; +use std::ops::{Index, IndexMut}; +use std::slice; +use std::vec; + +use crate::util::id_type::{Count, Id}; + +#[derive(Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct IdVec { + key: PhantomData, + // Invariant: items.len() <= K::MAX_USIZE + items: Vec, +} + +impl Debug for IdVec { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_map() + .entries( + self.items + .iter() + .enumerate() + .map(|(idx, val)| (K::from_index_unchecked(idx), val)), + ) + .finish() + } +} + +#[derive(Clone, Debug)] +pub struct IndexMapped { + key: PhantomData, + inner: I, +} + +impl> Iterator for IndexMapped { + type Item = (K, V); + + #[inline] + fn next(&mut self) -> Option<(K, V)> { + self.inner + .next() + .map(|(idx, val)| (K::from_index_unchecked(idx), val)) + } + + #[inline] + fn size_hint(&self) -> (usize, Option) { + self.inner.size_hint() + } + + #[inline] + fn fold(self, init: Acc, mut g: G) -> Acc + where + G: FnMut(Acc, Self::Item) -> Acc, + { + self.inner.fold(init, |acc, (idx, val)| { + g(acc, (K::from_index_unchecked(idx), val)) + }) + } +} + +impl IntoIterator for IdVec { + type Item = (K, V); + + type IntoIter = IndexMapped>>; + + fn into_iter(self) -> Self::IntoIter { + IndexMapped { + key: PhantomData, + inner: self.items.into_iter().enumerate(), + } + } +} + +impl<'a, K: Id, V> IntoIterator for &'a IdVec { + type Item = (K, &'a V); + + type IntoIter = IndexMapped>>; + + fn into_iter(self) -> Self::IntoIter { + IndexMapped { + key: PhantomData, + inner: self.items.iter().enumerate(), + } + } +} + +impl<'a, K: Id, V> IntoIterator for &'a mut IdVec { + type Item = (K, &'a mut V); + + type IntoIter = IndexMapped>>; + + fn into_iter(self) -> Self::IntoIter { + IndexMapped { + key: PhantomData, + inner: self.items.iter_mut().enumerate(), + } + } +} + +impl IdVec { + pub fn new() -> Self { + IdVec { + key: PhantomData, + items: Vec::new(), + } + } + + pub fn from_items(items: Vec) -> Self { + K::assert_in_range(items.len()); + IdVec { + key: PhantomData, + items, + } + } + + pub fn filled_with(count: Count, mut f: impl FnMut() -> V) -> Self { + IdVec { + key: PhantomData, + items: count.iter().map(|_| f()).collect(), + } + } + + pub fn items(&self) -> &[V] { + &self.items + } + + pub fn items_mut(&mut self) -> &mut [V] { + &mut self.items + } + + pub fn into_items(self) -> Vec { + self.items + } + + pub fn len(&self) -> usize { + self.items.len() + } + + pub fn count(&self) -> Count { + Count(K::from_index_unchecked(self.len())) + } + + pub fn is_empty(&self) -> bool { + self.items.is_empty() + } + + #[must_use] + pub fn push(&mut self, item: V) -> K { + let id = K::from_index_unchecked(self.len()); + self.items.push(item); + K::assert_in_range(self.len()); + id + } + + pub fn truncate(&mut self, len: usize) { + self.items.truncate(len) + } + + pub fn iter(&self) -> IndexMapped>> { + self.into_iter() + } + + pub fn iter_mut(&mut self) -> IndexMapped>> { + self.into_iter() + } + + pub fn try_zip_exact<'a, U>( + &'a self, + other: &'a IdVec, + ) -> Option> { + if self.items.len() == other.items.len() { + Some( + self.items + .iter() + .zip(other.items.iter()) + .enumerate() + .map(|(idx, (v1, v2))| (K::from_index_unchecked(idx), v1, v2)), + ) + } else { + None + } + } + + pub fn into_mapped W>(self, mut f: F) -> IdVec { + let mapped_items = self.into_iter().map(|(idx, val)| f(idx, val)).collect(); + IdVec::from_items(mapped_items) + } + + pub fn try_into_mapped Result>( + self, + mut f: F, + ) -> Result, E> { + let mapped_items = self + .into_iter() + .map(|(idx, val)| f(idx, val)) + .collect::>()?; + + Ok(IdVec::from_items(mapped_items)) + } + + pub fn map W>(&self, mut f: F) -> IdVec { + let mapped_items = self.iter().map(|(idx, val)| f(idx, val)).collect(); + IdVec::from_items(mapped_items) + } + + pub fn try_map Result>( + &self, + mut f: F, + ) -> Result, E> { + let mapped_items = self + .iter() + .map(|(idx, val)| f(idx, val)) + .collect::>()?; + + Ok(IdVec::from_items(mapped_items)) + } + + pub fn try_from_contiguous(entries: impl Iterator) -> Option { + let mut items = Vec::with_capacity(entries.size_hint().0); + for (idx, (key, val)) in entries.enumerate() { + if idx != key.to_index() { + return None; + } + items.push(val); + } + Some(Self::from_items(items)) + } +} + +impl> Index for IdVec { + type Output = V; + + fn index(&self, key: I) -> &V { + &self.items[key.borrow().to_index()] + } +} + +impl> IndexMut for IdVec { + fn index_mut(&mut self, key: I) -> &mut V { + &mut self.items[key.borrow().to_index()] + } +} diff --git a/vendor/morphic_lib/src/util/op_graph.rs b/vendor/morphic_lib/src/util/op_graph.rs new file mode 100644 index 0000000000..b7f8b3ca9a --- /dev/null +++ b/vendor/morphic_lib/src/util/op_graph.rs @@ -0,0 +1,73 @@ +use std::borrow::Borrow; + +use crate::util::id_type::{Count, Id}; +use crate::util::id_vec::IdVec; + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] +struct NodeData { + op: Op, + + /// Determines which slice of the `flat_inputs` buffer contains the inputs to this node. + /// + /// If the *previous* op has `inputs_end_idx == a`, and this node has `inputs_end_idx == b`, + /// then the inputs to this node are given by `flat_inputs[a..b]`. + inputs_end_idx: usize, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct Node<'a, K, Op> { + pub op: &'a Op, + pub inputs: &'a [K], +} + +/// Conceptually represents a collection of the form `IdVec)>`. +/// +/// Each tuple `(Op, Vec)` is called a "node", and can be thought of as an "op" together with a +/// list of zero or more "inputs" to that op, which are indices pointing to other nodes. +/// +/// The input lists are actually stored in a single contiguous buffer to reduce the number of heap +/// allocations. +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct OpGraph { + flat_inputs: Vec, + nodes: IdVec>, +} + +impl OpGraph { + pub fn new() -> Self { + Self { + flat_inputs: Vec::new(), + nodes: IdVec::new(), + } + } + + pub fn len(&self) -> usize { + self.nodes.len() + } + + pub fn count(&self) -> Count { + self.nodes.count() + } + + pub fn add_node(&mut self, op: Op, inputs: &[K]) -> K { + self.flat_inputs.extend_from_slice(inputs); + let node = NodeData { + op, + inputs_end_idx: self.flat_inputs.len(), + }; + self.nodes.push(node) + } + + pub fn node>(&self, idx: I) -> Node { + let node = &self.nodes[idx.borrow()]; + let inputs_start_idx = if idx.borrow().to_index() == 0 { + 0 + } else { + self.nodes[K::from_index_unchecked(idx.borrow().to_index() - 1)].inputs_end_idx + }; + Node { + op: &node.op, + inputs: &self.flat_inputs[inputs_start_idx..node.inputs_end_idx], + } + } +} diff --git a/vendor/morphic_lib/src/util/replace_none.rs b/vendor/morphic_lib/src/util/replace_none.rs new file mode 100644 index 0000000000..81e577272c --- /dev/null +++ b/vendor/morphic_lib/src/util/replace_none.rs @@ -0,0 +1,13 @@ +#[derive(Clone, Debug, thiserror::Error)] +#[error("replace_none: expected 'None' option, found value {0:?}")] +pub struct ReplaceNoneError(pub T); + +pub fn replace_none( + opt: &mut Option, + val: T, +) -> Result<(), ReplaceNoneError> { + match std::mem::replace(opt, Some(val)) { + None => Ok(()), + Some(prev) => Err(ReplaceNoneError(prev)), + } +} From e69e9736b5855bfb7475c5402cedef53dd044071 Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 2 Jun 2021 21:48:46 +0200 Subject: [PATCH 091/496] morphic clippy things --- vendor/morphic_lib/src/api.rs | 31 +++++++++++---------------- vendor/morphic_lib/src/util/blocks.rs | 2 +- 2 files changed, 13 insertions(+), 20 deletions(-) diff --git a/vendor/morphic_lib/src/api.rs b/vendor/morphic_lib/src/api.rs index 56e97e1b8d..e94e5660e1 100644 --- a/vendor/morphic_lib/src/api.rs +++ b/vendor/morphic_lib/src/api.rs @@ -6,7 +6,7 @@ use crate::util::blocks::Blocks; use crate::util::id_bi_map::IdBiMap; use crate::util::id_type::Count; use crate::util::id_vec::IdVec; -use crate::util::op_graph::{Node, OpGraph}; +use crate::util::op_graph::OpGraph; use crate::util::replace_none::replace_none; #[derive(Clone, thiserror::Error, Debug)] @@ -1518,24 +1518,17 @@ fn populate_specs( ) -> IdVec { let mut results = IdVec::filled_with(callee_spec_var_ids, || None); for val_id in vals.count().iter() { - match vals.node(val_id) { - Node { - op: - Op::Call { - callee_spec_var, - callee_mod, - callee, - }, - inputs: _, - } => { - replace_none( - &mut results[callee_spec_var], - hash_func_name(callee_mod.borrowed(), callee.borrowed()), - ) - .unwrap(); - } - - _ => {} + if let Op::Call { + callee_spec_var, + callee_mod, + callee, + } = vals.node(val_id).op + { + replace_none( + &mut results[callee_spec_var], + hash_func_name(callee_mod.borrowed(), callee.borrowed()), + ) + .unwrap(); } } results.into_mapped(|_, spec| spec.unwrap()) diff --git a/vendor/morphic_lib/src/util/blocks.rs b/vendor/morphic_lib/src/util/blocks.rs index fb840c2fbb..79182bbd86 100644 --- a/vendor/morphic_lib/src/util/blocks.rs +++ b/vendor/morphic_lib/src/util/blocks.rs @@ -93,7 +93,7 @@ impl Blocks { &mut self.blocks[block_id].info } - pub fn block_values<'a>(&'a self, block_id: BlockId) -> impl Iterator + 'a { + pub fn block_values(&self, block_id: BlockId) -> impl Iterator + '_ { let mut frag = &self.frags[self.blocks[block_id].head]; let mut val = frag.min_val.clone(); std::iter::from_fn(move || { From 4f20cd49285bbea89f15adc5427f9beab4b580d9 Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 2 Jun 2021 21:50:26 +0200 Subject: [PATCH 092/496] use recursive touch for inc/decref --- compiler/mono/src/alias_analysis.rs | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index a1b72529fd..a044571023 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -218,8 +218,9 @@ fn stmt_spec( ModifyRc::Inc(symbol, _) => { let argument = env.symbols[symbol]; - // inc is non-recursive - builder.add_touch(block, argument)?; + // a recursive touch is never worse for optimizations than a normal touch + // and a bit more permissive in its type + builder.add_recursive_touch(block, argument)?; stmt_spec(builder, env, block, layout, continuation) } @@ -227,7 +228,6 @@ fn stmt_spec( ModifyRc::Dec(symbol) => { let argument = env.symbols[symbol]; - // dec may be recursive builder.add_recursive_touch(block, argument)?; stmt_spec(builder, env, block, layout, continuation) @@ -235,8 +235,7 @@ fn stmt_spec( ModifyRc::DecRef(symbol) => { let argument = env.symbols[symbol]; - // decref is non-recursive - builder.add_touch(block, argument)?; + builder.add_recursive_touch(block, argument)?; stmt_spec(builder, env, block, layout, continuation) } From 9841b3743a1aa2d62579ebaf95350176046d234a Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 2 Jun 2021 22:01:31 +0200 Subject: [PATCH 093/496] format issue --- compiler/gen/src/llvm/build.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/gen/src/llvm/build.rs b/compiler/gen/src/llvm/build.rs index 5822e06240..06e08dcdd5 100644 --- a/compiler/gen/src/llvm/build.rs +++ b/compiler/gen/src/llvm/build.rs @@ -3040,7 +3040,7 @@ pub fn build_procedures_return_main<'a, 'ctx, 'env>( // NotAvailable, // Available(morphic_lib::Solutions), // } -// +// // impl std::fmt::Debug for AliasAnalysisSolutions { // fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { // write!(f, "AliasAnalysisSolutions {{}}") From 1bd3f127765a0bf997e9890db00d4716e615f587 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 3 Jun 2021 21:31:47 -0400 Subject: [PATCH 094/496] Fix a bunch of Int docs --- compiler/builtins/README.md | 6 +++--- compiler/builtins/docs/List.roc | 4 ++-- compiler/builtins/docs/Num.roc | 10 +++++----- compiler/builtins/src/std.rs | 2 +- compiler/can/src/builtins.rs | 26 +++++++++++++------------- compiler/gen/src/llvm/build.rs | 2 +- 6 files changed, 25 insertions(+), 25 deletions(-) diff --git a/compiler/builtins/README.md b/compiler/builtins/README.md index fdb5bd793b..3d9b25d73f 100644 --- a/compiler/builtins/README.md +++ b/compiler/builtins/README.md @@ -9,15 +9,15 @@ Towards the bottom of `symbol.rs` there is a `define_builtins!` macro being used Some of these have `#` inside their name (`first#list`, `#lt` ..). This is a trick we are doing to hide implementation details from Roc programmers. To a Roc programmer, a name with `#` in it is invalid, because `#` means everything after it is parsed to a comment. We are constructing these functions manually, so we are circumventing the parsing step and dont have such restrictions. We get to make functions and values with `#` which as a consequence are not accessible to Roc programmers. Roc programmers simply cannot reference them. But we can use these values and some of these are necessary for implementing builtins. For example, `List.get` returns tags, and it is not easy for us to create tags when composing LLVM. What is easier however, is: -- ..writing `List.#getUnsafe` that has the dangerous signature of `List elem, Int -> elem` in LLVM -- ..writing `List elem, Int -> Result elem [ OutOfBounds ]*` in a type safe way that uses `getUnsafe` internally, only after it checks if the `elem` at `Int` index exists. +- ..writing `List.#getUnsafe` that has the dangerous signature of `List elem, Nat -> elem` in LLVM +- ..writing `List elem, Nat -> Result elem [ OutOfBounds ]*` in a type safe way that uses `getUnsafe` internally, only after it checks if the `elem` at `Nat` index exists. ### can/src/builtins.rs Right at the top of this module is a function called `builtin_defs`. All this is doing is mapping the `Symbol` defined in `module/src/symbol.rs` to its implementation. Some of the builtins are quite complex, such as `list_get`. What makes `list_get` is that it returns tags, and in order to return tags it first has to defer to lower-level functions via an if statement. -Lets look at `List.repeat : elem, Int -> List elem`, which is more straight-forward, and points directly to its lower level implementation: +Lets look at `List.repeat : elem, Nat -> List elem`, which is more straight-forward, and points directly to its lower level implementation: ``` fn list_repeat(symbol: Symbol, var_store: &mut VarStore) -> Def { let elem_var = var_store.fresh(); diff --git a/compiler/builtins/docs/List.roc b/compiler/builtins/docs/List.roc index 02866d5d37..0398f2ab8e 100644 --- a/compiler/builtins/docs/List.roc +++ b/compiler/builtins/docs/List.roc @@ -62,7 +62,7 @@ interface List2 ## the same type. If you want to put a mix of #Int and #Str values into a list, try this: ## ## ``` -## mixedList : List [ IntElem Int, StrElem Str ]* +## mixedList : List [ IntElem I64, StrElem Str ]* ## mixedList = [ IntElem 1, IntElem 2, StrElem "a", StrElem "b" ] ## ``` ## @@ -248,7 +248,7 @@ map : List before, (before -> after) -> List after ## This works like #List.map, except it also passes the index ## of the element to the conversion function. -mapWithIndex : List before, (before, Int -> after) -> List after +mapWithIndex : List before, (before, Nat -> after) -> List after ## This works like #List.map, except at any time you can return `Err` to ## cancel the entire operation immediately, and return that #Err. diff --git a/compiler/builtins/docs/Num.roc b/compiler/builtins/docs/Num.roc index 419672c852..fac1493ea3 100644 --- a/compiler/builtins/docs/Num.roc +++ b/compiler/builtins/docs/Num.roc @@ -689,7 +689,7 @@ toD64 : Num * -> D64 ## >>> Num.divRound 8 -3 ## ## This is the same as the #// operator. -divRound : Int, Int -> Int +divRound : Int a, Int a -> Int a ## Perform flooring modulo on two integers. ## @@ -711,16 +711,16 @@ divRound : Int, Int -> Int ## >>> -8 %% -3 ## ## >>> Int.modFloor -8 -3 -#modFloor : Int, Int -> Result DivByZero Int +#modFloor : Int a, Int a -> Result (Int a) [ DivByZero ]* ## Bitwise -xor : Int, Int -> Int +xor : Int a, Int a -> Int a -and : Int, Int -> Int +and : Int a, Int a -> Int a -not : Int -> Int +not : Int a -> Int a ## Sort ascending - that is, with the lowest first, and the highest last. ## diff --git a/compiler/builtins/src/std.rs b/compiler/builtins/src/std.rs index bdfac87c00..158f0523b8 100644 --- a/compiler/builtins/src/std.rs +++ b/compiler/builtins/src/std.rs @@ -292,7 +292,7 @@ pub fn types() -> MutMap { // minInt : Int range add_type!(Symbol::NUM_MIN_INT, int_type(flex(TVAR1))); - // div : Int, Int -> Result Int [ DivByZero ]* + // divInt : Int a, Int a -> Result (Int a) [ DivByZero ]* let div_by_zero = SolvedType::TagUnion( vec![(TagName::Global("DivByZero".into()), vec![])], Box::new(SolvedType::Wildcard), diff --git a/compiler/can/src/builtins.rs b/compiler/can/src/builtins.rs index ef76fc7c44..636ca3ab19 100644 --- a/compiler/can/src/builtins.rs +++ b/compiler/can/src/builtins.rs @@ -30,7 +30,7 @@ macro_rules! macro_magic { /// Some builtins cannot be constructed in code gen alone, and need to be defined /// as separate Roc defs. For example, List.get has this type: /// -/// List.get : List elem, Int -> Result elem [ OutOfBounds ]* +/// List.get : List elem, Nat -> Result elem [ OutOfBounds ]* /// /// Because this returns an open tag union for its Err type, it's not possible /// for code gen to return a hardcoded value for OutOfBounds. For example, @@ -450,7 +450,7 @@ fn num_add(symbol: Symbol, var_store: &mut VarStore) -> Def { num_binop(symbol, var_store, LowLevel::NumAdd) } -/// Num.addWrap : Int, Int -> Int +/// Num.addWrap : Int a, Int a -> Int a fn num_add_wrap(symbol: Symbol, var_store: &mut VarStore) -> Def { num_binop(symbol, var_store, LowLevel::NumAddWrap) } @@ -549,7 +549,7 @@ fn num_sub(symbol: Symbol, var_store: &mut VarStore) -> Def { num_binop(symbol, var_store, LowLevel::NumSub) } -/// Num.subWrap : Int, Int -> Int +/// Num.subWrap : Int a, Int a -> Int a fn num_sub_wrap(symbol: Symbol, var_store: &mut VarStore) -> Def { num_binop(symbol, var_store, LowLevel::NumSubWrap) } @@ -648,7 +648,7 @@ fn num_mul(symbol: Symbol, var_store: &mut VarStore) -> Def { num_binop(symbol, var_store, LowLevel::NumMul) } -/// Num.mulWrap : Int, Int -> Int +/// Num.mulWrap : Int a, Int a -> Int a fn num_mul_wrap(symbol: Symbol, var_store: &mut VarStore) -> Def { num_binop(symbol, var_store, LowLevel::NumMulWrap) } @@ -1152,7 +1152,7 @@ fn num_ceiling(symbol: Symbol, var_store: &mut VarStore) -> Def { ) } -/// Num.powInt : Int, Int -> Int +/// Num.powInt : Int a, Int a -> Int a fn num_pow_int(symbol: Symbol, var_store: &mut VarStore) -> Def { let int_var = var_store.fresh(); @@ -1251,17 +1251,17 @@ fn num_asin(symbol: Symbol, var_store: &mut VarStore) -> Def { ) } -/// Num.bitwiseAnd : Int, Int -> Int +/// Num.bitwiseAnd : Int a, Int a -> Int a fn num_bitwise_and(symbol: Symbol, var_store: &mut VarStore) -> Def { num_binop(symbol, var_store, LowLevel::NumBitwiseAnd) } -/// Num.bitwiseXor : Int, Int -> Int +/// Num.bitwiseXor : Int a, Int a -> Int a fn num_bitwise_xor(symbol: Symbol, var_store: &mut VarStore) -> Def { num_binop(symbol, var_store, LowLevel::NumBitwiseXor) } -/// Num.bitwiseOr: Int, Int -> Int +/// Num.bitwiseOr: Int a, Int a -> Int a fn num_bitwise_or(symbol: Symbol, var_store: &mut VarStore) -> Def { num_binop(symbol, var_store, LowLevel::NumBitwiseOr) } @@ -1667,7 +1667,7 @@ fn list_concat(symbol: Symbol, var_store: &mut VarStore) -> Def { ) } -/// List.repeat : elem, Int -> List elem +/// List.repeat : elem, Nat -> List elem fn list_repeat(symbol: Symbol, var_store: &mut VarStore) -> Def { let elem_var = var_store.fresh(); let len_var = var_store.fresh(); @@ -1809,7 +1809,7 @@ fn list_get(symbol: Symbol, var_store: &mut VarStore) -> Def { ) } -/// List.set : List elem, Int, elem -> List elem +/// List.set : List elem, Nat, elem -> List elem /// /// List.set : /// Attr (w | u | v) (List (Attr u a)), @@ -2531,7 +2531,7 @@ fn set_walk(symbol: Symbol, var_store: &mut VarStore) -> Def { ) } -/// Num.rem : Int, Int -> Result Int [ DivByZero ]* +/// Num.rem : Int a, Int a -> Result (Int a) [ DivByZero ]* fn num_rem(symbol: Symbol, var_store: &mut VarStore) -> Def { let num_var = var_store.fresh(); let unbound_zero_var = var_store.fresh(); @@ -2590,7 +2590,7 @@ fn num_rem(symbol: Symbol, var_store: &mut VarStore) -> Def { ) } -/// Num.isMultipleOf : Int, Int -> Bool +/// Num.isMultipleOf : Int a, Int a -> Bool fn num_is_multiple_of(symbol: Symbol, var_store: &mut VarStore) -> Def { lowlevel_2(symbol, LowLevel::NumIsMultipleOf, var_store) } @@ -2696,7 +2696,7 @@ fn num_div_float(symbol: Symbol, var_store: &mut VarStore) -> Def { ) } -/// Num.div : Int, Int -> Result Int [ DivByZero ]* +/// Num.div : Int a , Int a -> Result (Int a) [ DivByZero ]* fn num_div_int(symbol: Symbol, var_store: &mut VarStore) -> Def { let bool_var = var_store.fresh(); let num_var = var_store.fresh(); diff --git a/compiler/gen/src/llvm/build.rs b/compiler/gen/src/llvm/build.rs index 06e08dcdd5..7037fd2f12 100644 --- a/compiler/gen/src/llvm/build.rs +++ b/compiler/gen/src/llvm/build.rs @@ -4558,7 +4558,7 @@ fn run_low_level<'a, 'ctx, 'env>( BasicValueEnum::IntValue(bool_val) } ListGetUnsafe => { - // List.get : List elem, Int -> [ Ok elem, OutOfBounds ]* + // List.get : List elem, Nat -> [ Ok elem, OutOfBounds ]* debug_assert_eq!(args.len(), 2); let (wrapper_struct, list_layout) = load_symbol_and_layout(scope, &args[0]); From 914d67aeed9d3d5b0021317cdaab3c7931266a64 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 3 Jun 2021 21:31:57 -0400 Subject: [PATCH 095/496] Drop obsolete Defaults.roc --- compiler/builtins/docs/Defaults.roc | 7 ------- 1 file changed, 7 deletions(-) delete mode 100644 compiler/builtins/docs/Defaults.roc diff --git a/compiler/builtins/docs/Defaults.roc b/compiler/builtins/docs/Defaults.roc deleted file mode 100644 index 046ba7dc3f..0000000000 --- a/compiler/builtins/docs/Defaults.roc +++ /dev/null @@ -1,7 +0,0 @@ -interface Defaults - exposes [] - imports [ - Dict.{ Dict }, - Set.{ Set }, - Num.{ Num, Int, Float } - ] From 14d20c124d7ca2fca9397ad76352108085fd4b00 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 3 Jun 2021 21:32:22 -0400 Subject: [PATCH 096/496] Fix NumParseConfig definition --- compiler/builtins/docs/Str.roc | 1 - 1 file changed, 1 deletion(-) diff --git a/compiler/builtins/docs/Str.roc b/compiler/builtins/docs/Str.roc index 0727b68af8..fae7e7e5f6 100644 --- a/compiler/builtins/docs/Str.roc +++ b/compiler/builtins/docs/Str.roc @@ -475,4 +475,3 @@ NumParseConfig : trailingZeroes ? [ Allowed, Disallowed ], wholeSep ? { mark : Str, policy : [ Allowed, Required U64 ] } } - -> Str From 1aa286bace7df3cdd996243f784f1fcfe0104111 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 3 Jun 2021 21:32:57 -0400 Subject: [PATCH 097/496] Improve a panic message --- docs/src/lib.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/src/lib.rs b/docs/src/lib.rs index 718ae50ba1..2543219903 100644 --- a/docs/src/lib.rs +++ b/docs/src/lib.rs @@ -583,8 +583,8 @@ fn make_doc_link(scope: &mut Scope, interns: &Interns, doc_item: &str) -> String } Err(_) => { panic!( - "Could not find symbol in scope for module link : {}", - doc_item + "Tried to generate an automatic link in docs for symbol `{}`, but that symbol was not in scope in this module. Scope was: {:?}", + doc_item, scope ) } } From 037d41d7c7c1d2f5af9050955e2dea519f7f94d2 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 3 Jun 2021 21:33:53 -0400 Subject: [PATCH 098/496] Don't hardcode ptr_bytes --- docs/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/src/lib.rs b/docs/src/lib.rs index 2543219903..9bd0d2fa93 100644 --- a/docs/src/lib.rs +++ b/docs/src/lib.rs @@ -305,7 +305,7 @@ pub fn files_to_documentations( &std_lib, src_dir.as_path(), MutMap::default(), - 8, // TODO: Is it okay to hardcode ptr_bytes here? I think it should be fine since we'er only type checking (also, 8 => 32bit system) + std::mem::size_of::(), // This is just type-checking for docs, so "target" doesn't matter builtin_defs_map, ) { Ok(loaded) => files_docs.push((loaded.documentation, loaded.interns)), From d523beb54c85ac77abd935f4fc0706f5773620e1 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 3 Jun 2021 22:31:20 -0400 Subject: [PATCH 099/496] Add isFinite and friends --- compiler/builtins/docs/Num.roc | 54 ++++++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) diff --git a/compiler/builtins/docs/Num.roc b/compiler/builtins/docs/Num.roc index fac1493ea3..b351feec93 100644 --- a/compiler/builtins/docs/Num.roc +++ b/compiler/builtins/docs/Num.roc @@ -977,3 +977,57 @@ sqrt : Float a -> [Ok (Float a), InvalidSqrt]* Endi : [ Big, Little ] toBytes : Num *, Endi -> List U8 + +## When given a [F64] or [F32] value, returns `False` if that value is +## [*NaN*](https://en.wikipedia.org/wiki/NaN). (Returns `False` if that value is *Infinity* or *-Infinity*.) +## +## Always returns `False` when given a [Dec]. +## +## >>> Num.isNaN 12.3 +## +## >>> Num.isNaN (Num.sqrtOrNaN -2) +## +## See also [isPoison] and [isFinite]. +isNaN : Frac * -> Bool + +## When given a [F64] or [F32] value, returns `False` if that value is +## [*NaN*](https://en.wikipedia.org/wiki/NaN), *Infinity*, or *-Infinity*. +## +## Always returns `True` when given a [Dec]. +## +## [isPoison] returns the opposite of this. +## +## See also [isInfinite]. +isFinite : Frac * -> Bool + +## When given a [F64] or [F32] value, returns `True` if that value is +## [*NaN*](https://en.wikipedia.org/wiki/NaN), *Infinity*, or *-Infinity*. +## +## Always returns `False` when given a [Dec]. +## +## [isFinite] returns the opposite of this. +isPoison : Frac * -> Bool + +## When given a [F64] or [F32] value, returns `True` if that value is either +## *Infinity* or *-Infinity*. (Returns `False` if that value is [*NaN*](https://en.wikipedia.org/wiki/NaN).) +## +## Always returns `False` when given a [Dec]. +## +## See also [isFinite], [isPositiveInfinity], and [isNegativeInfinity]. +isInfinite : Frac * -> Bool + +## When given a [F64] or [F32] value, returns `True` if that value is +## *Infinity*. (Returns `False` if that value is *-Infinity* or [*NaN*](https://en.wikipedia.org/wiki/NaN).) +## +## Always returns `False` when given a [Dec]. +## +## See also [isNegativeInfinity], [isInfinite], and [isFinite]. +isPositiveInfinity : Frac * -> Bool + +## When given a [F64] or [F32] value, returns `True` if that value is +## *Infinity*. (Returns `False` if that value is *-Infinity* or [*NaN*](https://en.wikipedia.org/wiki/NaN).) +## +## Always returns `False` when given a [Dec]. +## +## See also [isPositiveInfinity], [isInfinite], and [isFinite]. +isNegativeInfinity : Frac * -> Bool From dcd388065ccb7c6a7eddda0bb0979e5ab1c26b9a Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Fri, 4 Jun 2021 00:26:12 -0400 Subject: [PATCH 100/496] s/Float/Frac and other changes --- compiler/builtins/docs/Num.roc | 230 ++++++++++++++++++--------------- 1 file changed, 127 insertions(+), 103 deletions(-) diff --git a/compiler/builtins/docs/Num.roc b/compiler/builtins/docs/Num.roc index b351feec93..4c14a50b4e 100644 --- a/compiler/builtins/docs/Num.roc +++ b/compiler/builtins/docs/Num.roc @@ -12,10 +12,10 @@ interface Num2 ## add : Num range, Num range -> Num range ## ``` ## -## The number 1.5 technically has the type `Num FloatingPoint`, so when you pass two of them to `Num.add`, the answer you get is `3.0 : Num FloatingPoint`. +## The number 1.5 technically has the type `Num Fraction`, so when you pass two of them to `Num.add`, the answer you get is `3.0 : Num Fraction`. ## -## The type #Float is defined to be an alias for `Num FloatingPoint`, so `3.0 : Num FloatingPoint` is the same answer as `3.0 : Float`. # # Similarly, the number 1 technically has the type `Num Integer`, so when you pass two of them to `Num.add`, the answer you get is `2 : Num Integer`. # # The type #Int is defined to be an alias for `Num Integer`, so `2 : Num Integer` is the same answer as `2 : Int`. # -## In this way, the `Num` type makes it possible to have `1 + 1` return `2 : Int` and `1.5 + 1.5` return `3.0 : Float`. +## The type #Frac is defined to be an alias for `Num Fraction`, so `3.0 : Num Fraction` is the same answer as `3.0 : Frac`. # # Similarly, the number 1 technically has the type `Num Integer`, so when you pass two of them to `Num.add`, the answer you get is `2 : Num Integer`. # # The type #Int is defined to be an alias for `Num Integer`, so `2 : Num Integer` is the same answer as `2 : Int`. # +## In this way, the `Num` type makes it possible to have `1 + 1` return `2 : Int` and `1.5 + 1.5` return `3.0 : Frac`. ## ## ## Number Literals ## @@ -272,7 +272,7 @@ Nat : Int [ @Natural ] ## If you need to do math outside these bounds, consider using a larger numeric size. Int size : Num [ @Int size ] -## A 64-bit floating-point number. All number literals with decimal points are #Float values. +## A 64-bit floating-point number. All number literals with decimal points are #Frac values. ## ## >>> 0.1 ## @@ -280,7 +280,7 @@ Int size : Num [ @Int size ] ## ## >>> 0.0 ## -## If you like, you can put underscores in your #Float literals. +## If you like, you can put underscores in your #Frac literals. ## They have no effect on the number's value, but can make things easier to read. ## ## >>> 1_000_000.000_000_001 @@ -309,7 +309,7 @@ Int size : Num [ @Int size ] ## If decimal precision is important - for example, when representing money - ## decimal floats tend to be worth the performance cost. ## -## Usually, Roc's compiler can infer a more specific type than #Float for +## Usually, Roc's compiler can infer a more specific type than #Frac for ## a particular float value, based on how it is used with other numbers. For example: ## ## >>> coordinates : { x : F32, y : F32 } @@ -330,7 +330,7 @@ Int size : Num [ @Int size ] ## If you want something else, you can write (for example) `0.1f32 + 0.2 == 0.3` ## to compare them as #F32 values instead. ## -## Both decimal and binary #Float values conform to the [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754#Interchange_formats) +## Both decimal and binary #Frac values conform to the [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754#Interchange_formats) ## specification for floating point numbers. Conforming to this specification ## means Roc's binary floats have nearly universal hardware support, and its ## decimal floats have [some hardware support](http://speleotrove.com/decimal/) @@ -343,7 +343,7 @@ Int size : Num [ @Int size ] ## - #D32 (32-bit decimal float) ## - #D64 (64-bit decimal float) # TODO show a table like we do with ints, with the min/max ranges ## -## Like #Int, it's possible for #Float operations to overflow. Like with ints, +## Like #Int, it's possible for #Frac operations to overflow. Like with ints, ## you'll typically get a crash when this happens. ## ## * In a development build, you'll get an assertion failure. @@ -352,7 +352,7 @@ Int size : Num [ @Int size ] ## Although some languages treat have first-class representations for ## `-Infinity`, `Infinity`, and the special `NaN` ("not a number") ## floating-point values described in the IEEE-754, Roc does not. -## Instead, Roc treats all of these as errors. If any Float operation +## Instead, Roc treats all of these as errors. If any Frac operation ## in a development build encounters one of these values, it will ## result in an assertion failure. ## @@ -378,13 +378,13 @@ Int size : Num [ @Int size ] ## Whenever any arithmetic operation is performed on an invalid float, ## the result is also invalid. This is called *error propagation*, and ## it is notoriously error-prone. In Roc, using equality operations like -## `==` and `!=` on an invalid float causes a crash. (See #Float.verify +## `==` and `!=` on an invalid float causes a crash. (See #Frac.verify ## to check the validity of your float.) ## ## Beause invalid floats are so error-prone, Roc discourages using them. ## Instead, by default it treats them the same way as overflow: by -## crashing whenever any #Float function would otherwise return one. -## You can also use functions like #Float.tryAdd to get an `Ok` or an error +## crashing whenever any #Frac function would otherwise return one. +## You can also use functions like #Frac.tryAdd to get an `Ok` or an error ## back so you can gracefully recover from invalid values. ## ## Quiet errors can be useful sometimes. For example, you might want to @@ -426,7 +426,7 @@ Int size : Num [ @Int size ] ## ## >>> Num.neg 0.0 ## -## This is safe to use with any #Float, but it can cause overflow when used with certain #Int values. +## This is safe to use with any #Frac, but it can cause overflow when used with certain #Int values. ## ## For example, calling #Num.neg on the lowest value of a signed integer (such as #Int.lowestI64 or #Int.lowestI32) will cause overflow. ## This is because, for any given size of signed integer (32-bit, 64-bit, etc.) its negated lowest value turns out to be 1 higher than @@ -434,7 +434,7 @@ Int size : Num [ @Int size ] ## ## Additionally, calling #Num.neg on any unsigned integer (such as any #U64 or #U32 value) other than 0 will cause overflow. ## -## (It will never crash when given a #Float, however, because of how floating point numbers represent positive and negative numbers.) +## (It will never crash when given a #Frac, however, because of how floating point numbers represent positive and negative numbers.) neg : Num range -> Num range ## Return the absolute value of the number. @@ -451,7 +451,7 @@ neg : Num range -> Num range ## ## >>> Num.abs 0.0 ## -## This is safe to use with any #Float, but it can cause overflow when used with certain #Int values. +## This is safe to use with any #Frac, but it can cause overflow when used with certain #Int values. ## ## For example, calling #Num.abs on the lowest value of a signed integer (such as #Int.lowestI64 or #Int.lowestI32) will cause overflow. ## This is because, for any given size of signed integer (32-bit, 64-bit, etc.) its negated lowest value turns out to be 1 higher than @@ -485,7 +485,7 @@ isOdd : Num * -> Bool ## Add two numbers of the same type. ## -## (To add an #Int and a #Float, first convert one so that they both have the same type. There are functions in the [`Float`](/Float) module that can convert both #Int to #Float and the other way around.) +## (To add an #Int and a #Frac, first convert one so that they both have the same type. There are functions in the [`Frac`](/Frac) module that can convert both #Int to #Frac and the other way around.) ## ## `a + b` is shorthand for `Num.add a b`. ## @@ -495,13 +495,13 @@ isOdd : Num * -> Bool ## ## `Num.add` can be convenient in pipelines. ## -## >>> Float.pi +## >>> Frac.pi ## >>> |> Num.add 1.0 add : Num range, Num range -> Num range ## Subtract two numbers of the same type. ## -## (To subtract an #Int and a #Float, first convert one so that they both have the same type. There are functions in the [`Float`](/Float) module that can convert both #Int to #Float and the other way around.) +## (To subtract an #Int and a #Frac, first convert one so that they both have the same type. There are functions in the [`Frac`](/Frac) module that can convert both #Int to #Frac and the other way around.) ## ## `a - b` is shorthand for `Num.sub a b`. ## @@ -511,13 +511,13 @@ add : Num range, Num range -> Num range ## ## `Num.sub` can be convenient in pipelines. ## -## >>> Float.pi +## >>> Frac.pi ## >>> |> Num.sub 2.0 sub : Num range, Num range -> Num range ## Multiply two numbers of the same type. ## -## (To multiply an #Int and a #Float, first convert one so that they both have the same type. There are functions in the [`Float`](/Float) module that can convert both #Int to #Float and the other way around.) +## (To multiply an #Int and a #Frac, first convert one so that they both have the same type. There are functions in the [`Frac`](/Frac) module that can convert both #Int to #Frac and the other way around.) ## ## `a * b` is shorthand for `Num.mul a b`. ## @@ -527,7 +527,7 @@ sub : Num range, Num range -> Num range ## ## `Num.mul` can be convenient in pipelines. ## -## >>> Float.pi +## >>> Frac.pi ## >>> |> Num.mul 2.0 mul : Num range, Num range -> Num range @@ -540,7 +540,7 @@ mul : Num range, Num range -> Num range ## ## >>> Num.toStr 42 ## -## Only #Float values will include a decimal point, and they will always include one. +## Only #Frac values will include a decimal point, and they will always include one. ## ## >>> Num.toStr 4.2 ## @@ -612,10 +612,10 @@ format : -> Str ## Round off the given float to the nearest integer. -round : Float * -> Int * -ceil : Float * -> Int * -floor : Float * -> Int * -trunc : Float * -> Int * +round : Frac * -> Int * +ceil : Frac * -> Int * +floor : Frac * -> Int * +trunc : Frac * -> Int * ## Convert an #Int to a #Nat. If the given number doesn't fit in #Nat, it will be truncated. ## Since #Nat has a different maximum number depending on the system you're building @@ -630,13 +630,13 @@ trunc : Float * -> Int * ## the #Nat value of 9_000_000_000. This is because on a 64-bit system, #Nat can ## hold up to #Num.maxU64, and 9_000_000_000 is lower than #Num.maxU64. ## -## To convert a #Float to a #Nat, first call either #Num.round, #Num.ceil, or #Num.floor +## To convert a #Frac to a #Nat, first call either #Num.round, #Num.ceil, or #Num.floor ## on it, then call this on the resulting #Int. toNat : Int * -> Nat ## Convert an #Int to an #I8. If the given number doesn't fit in #I8, it will be truncated. ## -## To convert a #Float to an #I8, first call either #Num.round, #Num.ceil, or #Num.floor +## To convert a #Frac to an #I8, first call either #Num.round, #Num.ceil, or #Num.floor ## on it, then call this on the resulting #Int. toI8 : Int * -> I8 toI16 : Int * -> I16 @@ -660,13 +660,9 @@ toF32 : Num * -> F32 ## there will be a loss of precision. toF64 : Num * -> F64 -## Convert a #Num to a #D32. If the given number can't be precisely represented in a #D32, +## Convert a #Num to a #Dec. If the given number can't be precisely represented in a #Dec, ## there will be a loss of precision. -toD32 : Num * -> D32 - -## Convert a #Num to a #D64. If the given number can't be precisely represented in a #D64, -## there will be a loss of precision. -toD64 : Num * -> D64 +toDec : Num * -> Dec ## Divide two integers and #Num.round the resulut. ## @@ -696,9 +692,9 @@ divRound : Int a, Int a -> Int a ## Modulo is the same as remainder when working with positive numbers, ## but if either number is negative, then modulo works differently. ## -## Additionally, flooring modulo uses #Float.floor on the result. +## Additionally, flooring modulo uses #Frac.floor on the result. ## -## (Use #Float.mod for non-flooring modulo.) +## (Use #Frac.mod for non-flooring modulo.) ## ## Return `Err DivByZero` if the second integer is zero, because division by zero is undefined in mathematics. ## @@ -739,7 +735,7 @@ desc : Num a, Num a -> [ Eq, Lt, Gt ] ## This function can crash under these circumstances: ## ## * It receives a function, or any type that contains a function (for example a record, tag, or #List containing a function) -## * It receives an erroneous #Float (`NaN`, `Infinity`, or `-Infinity` - these values can only originate from hosts) +## * It receives an erroneous #Frac (`NaN`, `Infinity`, or `-Infinity` - these values can only originate from hosts) ## ## CAUTION: This function may give different answers in future releases of Roc, ## so be aware that if you rely on the exact answer this gives today, your @@ -803,88 +799,96 @@ maxU32 : U32 ## and zero is the lowest unsigned number. Unsigned numbers cannot be negative. minU32 : U32 -## The highest supported #Float value you can have, which is approximately 1.8 × 10^308. +## The highest supported #Frac value you can have, which is approximately 1.8 × 10^308. ## ## If you go higher than this, your running Roc code will crash - so be careful not to! -maxF64 : Float * +maxF64 : Frac * -## The lowest supported #Float value you can have, which is approximately -1.8 × 10^308. +## The lowest supported #Frac value you can have, which is approximately -1.8 × 10^308. ## ## If you go lower than this, your running Roc code will crash - so be careful not to! -minF64 : Float * +minF64 : Frac * -## The highest integer that can be represented as a #Float without # losing precision. +## The highest integer that can be represented as a #Frac without # losing precision. ## It is equal to 2^53, which is approximately 9 × 10^15. ## ## Some integers higher than this can be represented, but they may lose precision. For example: ## -## >>> Float.highestInt +## >>> Frac.highestInt ## -## >>> Float.highestInt + 100 # Increasing may lose precision +## >>> Frac.highestInt + 100 # Increasing may lose precision ## -## >>> Float.highestInt - 100 # Decreasing is fine - but watch out for lowestLosslessInt! -maxPreciseInt : Float * +## >>> Frac.highestInt - 100 # Decreasing is fine - but watch out for lowestLosslessInt! +maxPreciseInt : Frac * -## The lowest integer that can be represented as a #Float without losing precision. +## The lowest integer that can be represented as a #Frac without losing precision. ## It is equal to -2^53, which is approximately -9 × 10^15. ## ## Some integers lower than this can be represented, but they may lose precision. For example: ## -## >>> Float.lowestIntVal +## >>> Frac.lowestIntVal ## -## >>> Float.lowestIntVal - 100 # Decreasing may lose precision +## >>> Frac.lowestIntVal - 100 # Decreasing may lose precision ## -## >>> Float.lowestIntVal + 100 # Increasing is fine - but watch out for highestInt! -maxPreciseInt : Float * +## >>> Frac.lowestIntVal + 100 # Increasing is fine - but watch out for highestInt! +maxPreciseInt : Frac * ## Constants ## An approximation of e, specifically 2.718281828459045. -e : Float * +e : Frac * ## An approximation of pi, specifically 3.141592653589793. -pi : Float * +pi : Frac * ## Constants ## An approximation of e, specifically 2.718281828459045. -e : Float * +e : Frac * ## An approximation of pi, specifically 3.141592653589793. -pi : Float * +pi : Frac * -#ceiling : Float -> Int +#ceiling : Frac -> Int -#floor : Float -> Int +#floor : Frac -> Int ## Trigonometry -#cos : Float -> Float +#cos : Frac -> Frac -#acos : Float -> Float +#acos : Frac -> Frac -#sin : Float -> Float +#sin : Frac -> Frac -#asin : Float -> Float +#asin : Frac -> Frac -#tan : Float -> Float +#tan : Frac -> Frac -#atan : Float -> Float +#atan : Frac -> Frac ## Other Calculations (arithmetic?) -## Divide two #Float numbers. +## Divide one [Frac] by another. ## ## `a / b` is shorthand for `Num.div a b`. ## -## Division by zero is undefined in mathematics. As such, you should make -## sure never to pass zero as the denomaintor to this function! +## [Division by zero is undefined in mathematics](https://en.wikipedia.org/wiki/Division_by_zero). +## As such, you should make sure never to pass zero as the denomaintor to this function! +## Calling [div] on a [Dec] denominator of 0 will cause a runtime error. ## -## If zero does get passed as the denominator... +## Calling [div] on [F32] and [F64] values follows these rules: +## * Dividing a positive [F32] or [F64] by zero returns [Infinity](#isPositiveInfinity). +## * Dividing a negative [F32] or [F64] by zero returns [-Infinity](#isNegativeInfinity). +## * Dividing a zero [F32] or [F64] by zero returns [NaN](#isNaN). ## -## * In a development build, you'll get an assertion failure. -## * In a release build, the function will return `Infinity`, `-Infinity`, or `NaN` depending on the arguments. +## > These rules come from the [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754) +## > floating point standard. Since almost all modern processors are built to +## > this standard, deviating from these rules has a significant performance +## > cost. Since the most common reason to choose [F32] or [F64] over [Dec] is +## > access to hardware-accelerated performance, Roc follows these rules exactly. ## -## To divide an #Int and a #Float, first convert the #Int to a #Float using one of the functions in this module. +## To divide an [Int] and a [Frac], first convert the [Int] to a [Frac] using +## one of the functions in this module like [toDec]. ## ## >>> 5.0 / 7.0 ## @@ -892,45 +896,47 @@ pi : Float * ## ## `Num.div` can be convenient in pipelines. ## -## >>> Float.pi +## >>> Num.pi ## >>> |> Num.div 2.0 -#div : Float, Float -> Result Float DivByZero -div = \numerator, denominator -> - when numerator is - 0.0 -> 0.0 # TODO return Result! - _ -> denominator +div : Frac a, Frac a -> Frac a -## Perform modulo on two #Float numbers. +## Perform modulo on two [Frac]s. ## ## Modulo is the same as remainder when working with positive numbers, ## but if either number is negative, then modulo works differently. ## -## Return `Err DivByZero` if the second number is zero, because division by zero is undefined in mathematics. +## `a % b` is shorthand for `Num.mod a b`. ## -## `a % b` is shorthand for `Float.mod a b`. +## [Division by zero is undefined in mathematics](https://en.wikipedia.org/wiki/Division_by_zero), +## and as such, so is modulo by zero. Because of this, you should make sure never +## to pass zero for the second argument to this function! +## +## Passing [mod] a [Dec] value of 0 for its second argument will cause a runtime error. +## Passing [mod] a [F32] and [F64] value for its second argument will cause it +## to return [NaN](#isNaN). ## ## >>> 5.0 % 7.0 ## -## >>> Float.mod 5 7 +## >>> Num.mod 5 7 ## -## `Float.mod` can be convenient in pipelines. +## `Num.mod` can be convenient in pipelines. ## -## >>> Float.pi -## >>> |> Float.mod 2.0 -mod : Float a, Float a -> Result (Float a) [ DivByZero ]* +## >>> Num.pi +## >>> |> Num.mod 2.0 +mod : Frac a, Frac a -> Frac a -## Raises a #Float to the power of another #Float. +## Raises a #Frac to the power of another #Frac. ## ## ` ## For an #Int alternative to this function, see #Num.raise. -pow : Float a, Float a -> Float a +pow : Frac a, Frac a -> Frac a ## Raises an integer to the power of another, by multiplying the integer by ## itself the given number of times. ## ## This process is known as [exponentiation by squaring](https://en.wikipedia.org/wiki/Exponentiation_by_squaring). ## -## For a #Float alternative to this function, which supports negative exponents, +## For a #Frac alternative to this function, which supports negative exponents, ## see #Num.exp. ## ## >>> Num.exp 5 0 @@ -947,30 +953,48 @@ pow : Float a, Float a -> Float a ## overflow expBySquaring : Int a, U8 -> Int a -## Return the reciprocal of a #Float - that is, divides `1.0` by the given number. +## Returns an approximation of the absolute value of the square root of the [Frac]. ## -## Crashes if given `0.0`, because division by zero is undefined in mathematics. +## The square root of a negative number is an irrational number, and [Frac] only +## supports rational numbers. As such, you should make sure never to pass this +## function a negative number! Calling [sqrt] on a negative [Dec] will cause a runtime error. ## -## For a version that does not crash, use #tryRecip -recip : Float a -> Result (Float a) [ DivByZero ]* +## Calling [sqrt] on [F32] and [F64] values follows these rules: +## * Passing a negative [F32] or [F64] returns [NaN](#isNaN). +## * Passing [NaN](#isNaN) or [-Infinity](isNegativeInfinity) also returns [NaN](#isNaN). +## * Passing [Infinity](isPositiveInfinity) returns [Infinity]. +## +## > These rules come from the [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754) +## > floating point standard. Since almost all modern processors are built to +## > this standard, deviating from these rules has a significant performance +## > cost. Since the most common reason to choose [F32] or [F64] over [Dec] is +## > access to hardware-accelerated performance, Roc follows these rules exactly. +## +## >>> Frac.sqrt 4.0 +## +## >>> Frac.sqrt 1.5 +## +## >>> Frac.sqrt 0.0 +## +## >>> Frac.sqrt -4.0f64 +## +## >>> Frac.sqrt -4.0dec +sqrt : Frac a -> Frac a -## NOTE: Need to come up a suffix alternative to the "try" prefix. -## This should be like (for example) recipTry so that it's more discoverable -## in documentation and editor autocomplete when you type "recip" -tryRecip : Float a -> Result (Float a) [ DivByZero ]* - -## Return an approximation of the absolute value of the square root of the #Float. +## Return an approximation of the absolute value of the square root of the #Frac, +## or a poison number if given a negative or poison number. ## -## Return #InvalidSqrt if given a negative number or an invalid #Float. The square root of a negative number is an irrational number, and #Float only supports rational numbers. +## (The square root of a negative number is an irrational number, and [Frac] +## only supports rational numbers.) ## -## >>> Float.sqrt 4.0 +## >>> Frac.sqrt 4.0 ## -## >>> Float.sqrt 1.5 +## >>> Frac.sqrt 1.5 ## -## >>> Float.sqrt 0.0 +## >>> Frac.sqrt 0.0 ## -## >>> Float.sqrt -4.0 -sqrt : Float a -> [Ok (Float a), InvalidSqrt]* +## >>> Frac.sqrt -4.0 +sqrtOrPoison : Frac a -> [Ok (Frac a), InvalidSqrt]* ## [Endianness](https://en.wikipedia.org/wiki/Endianness) From b08c70985aa128d3eca49a18b2e2bc17342547c4 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Fri, 4 Jun 2021 00:41:24 -0400 Subject: [PATCH 101/496] Remove poison. --- compiler/builtins/docs/Num.roc | 28 +--------------------------- 1 file changed, 1 insertion(+), 27 deletions(-) diff --git a/compiler/builtins/docs/Num.roc b/compiler/builtins/docs/Num.roc index 4c14a50b4e..3051260728 100644 --- a/compiler/builtins/docs/Num.roc +++ b/compiler/builtins/docs/Num.roc @@ -981,22 +981,6 @@ expBySquaring : Int a, U8 -> Int a ## >>> Frac.sqrt -4.0dec sqrt : Frac a -> Frac a -## Return an approximation of the absolute value of the square root of the #Frac, -## or a poison number if given a negative or poison number. -## -## (The square root of a negative number is an irrational number, and [Frac] -## only supports rational numbers.) -## -## >>> Frac.sqrt 4.0 -## -## >>> Frac.sqrt 1.5 -## -## >>> Frac.sqrt 0.0 -## -## >>> Frac.sqrt -4.0 -sqrtOrPoison : Frac a -> [Ok (Frac a), InvalidSqrt]* - - ## [Endianness](https://en.wikipedia.org/wiki/Endianness) Endi : [ Big, Little ] @@ -1011,7 +995,7 @@ toBytes : Num *, Endi -> List U8 ## ## >>> Num.isNaN (Num.sqrtOrNaN -2) ## -## See also [isPoison] and [isFinite]. +## See also [isFinite]. isNaN : Frac * -> Bool ## When given a [F64] or [F32] value, returns `False` if that value is @@ -1019,19 +1003,9 @@ isNaN : Frac * -> Bool ## ## Always returns `True` when given a [Dec]. ## -## [isPoison] returns the opposite of this. -## ## See also [isInfinite]. isFinite : Frac * -> Bool -## When given a [F64] or [F32] value, returns `True` if that value is -## [*NaN*](https://en.wikipedia.org/wiki/NaN), *Infinity*, or *-Infinity*. -## -## Always returns `False` when given a [Dec]. -## -## [isFinite] returns the opposite of this. -isPoison : Frac * -> Bool - ## When given a [F64] or [F32] value, returns `True` if that value is either ## *Infinity* or *-Infinity*. (Returns `False` if that value is [*NaN*](https://en.wikipedia.org/wiki/NaN).) ## From db4ce6aef3bf748f0a7eca340991e33fed41051c Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Fri, 4 Jun 2021 00:41:37 -0400 Subject: [PATCH 102/496] Revise some more Num docs. --- compiler/builtins/docs/Num.roc | 58 ++++++++++++++++++++-------------- 1 file changed, 35 insertions(+), 23 deletions(-) diff --git a/compiler/builtins/docs/Num.roc b/compiler/builtins/docs/Num.roc index 3051260728..bd19527f59 100644 --- a/compiler/builtins/docs/Num.roc +++ b/compiler/builtins/docs/Num.roc @@ -9,13 +9,24 @@ interface Num2 ## This is useful for functions that can work on either, for example #Num.add, whose type is: ## ## ``` -## add : Num range, Num range -> Num range +## add : Num a, Num a -> Num a ## ``` ## -## The number 1.5 technically has the type `Num Fraction`, so when you pass two of them to `Num.add`, the answer you get is `3.0 : Num Fraction`. +## The number 1.5 technically has the type `Num (Fraction *)`, so when you pass +## two of them to [Num.add], the answer you get is `3.0 : Num (Fraction *)`. +# +## Similarly, the number 0x1 (that is, the integer 1 in hexadecimal notation) +## technically has the type `Num (Integer *)`, so when you pass two of them to +## [Num.add], the answer you get is `2 : Num (Integer *)`. ## -## The type #Frac is defined to be an alias for `Num Fraction`, so `3.0 : Num Fraction` is the same answer as `3.0 : Frac`. # # Similarly, the number 1 technically has the type `Num Integer`, so when you pass two of them to `Num.add`, the answer you get is `2 : Num Integer`. # # The type #Int is defined to be an alias for `Num Integer`, so `2 : Num Integer` is the same answer as `2 : Int`. # -## In this way, the `Num` type makes it possible to have `1 + 1` return `2 : Int` and `1.5 + 1.5` return `3.0 : Frac`. +## The type [`Frac a`](#Frac) is defined to be an alias for `Num (Fraction a)`, +## so `3.0 : Num (Fraction *)` is the same value as `3.0 : Frac *`. +## Similarly, the type [`Int a`](#Int) is defined to be an alias for +## `Num (Integer a)`, so `2 : Num (Integer *)` is the same value as +## `2 : Int *`. +## +## In this way, the [Num] type makes it possible to have `1 + 0x1` return +## `2 : Int *` and `1.5 + 1.5` return `3.0 : Frac`. ## ## ## Number Literals ## @@ -29,29 +40,30 @@ interface Num2 ## ends up having the type `Nat`. ## ## Sometimes number literals don't become more specific. For example, -## the #Num.toStr function has the type `Num * -> Str`. This means that +## the [Num.toStr] function has the type `Num * -> Str`. This means that ## when calling `Num.toStr (5 + 6)`, the expression `(5 + 6)` ## still has the type `Num *`. When this happens, `Num *` defaults to -## being an #I32 - so this addition expression would overflow +## being an [I64] - so this addition expression would overflow ## if either 5 or 6 were replaced with a number big enough to cause -## addition overflow on an #I32. +## addition overflow on an [I64] value. ## -## If this default of #I32 is not big enough for your purposes, -## you can add an `i64` to the end of the number literal, like so: +## If this default of [I64] is not big enough for your purposes, +## you can add an `i128` to the end of the number literal, like so: ## -## >>> Num.toStr 5_000_000_000i64 +## >>> Num.toStr 5_000_000_000i128 ## -## This `i64` suffix specifies that you want this number literal to be -## an #I64 instead of a `Num *`. All the other numeric types have -## suffixes just like `i64`; here are some other examples: +## This `i128` suffix specifies that you want this number literal to be +## an [I128] instead of a `Num *`. All the other numeric types have +## suffixes just like `i128`; here are some other examples: ## -## * `215u8` is a `215` value of type #U8 -## * `76.4f32` is a `76.4` value of type #F32 -## * `12345ulen` is a `12345` value of type #Nat +## * `215u8` is a `215` value of type [U8] +## * `76.4f32` is a `76.4` value of type [F32] +## * `123.45dec` is a `123.45` value of type [Dec] +## * `12345nat` is a `12345` value of type [Nat] ## ## In practice, these are rarely needed. It's most common to write ## number literals without any suffix. -Num range : [ @Num range ] +Num a : [ @Num a ] ## A decimal number. ## @@ -435,7 +447,7 @@ Int size : Num [ @Int size ] ## Additionally, calling #Num.neg on any unsigned integer (such as any #U64 or #U32 value) other than 0 will cause overflow. ## ## (It will never crash when given a #Frac, however, because of how floating point numbers represent positive and negative numbers.) -neg : Num range -> Num range +neg : Num a -> Num a ## Return the absolute value of the number. ## @@ -458,7 +470,7 @@ neg : Num range -> Num range ## the highest value it can represent. (For this reason, calling #Num.neg on the lowest signed value will also cause overflow.) ## ## Calling this on an unsigned integer (like #U32 or #U64) never does anything. -abs : Num range -> Num range +abs : Num a -> Num a ## Check @@ -497,7 +509,7 @@ isOdd : Num * -> Bool ## ## >>> Frac.pi ## >>> |> Num.add 1.0 -add : Num range, Num range -> Num range +add : Num a, Num a -> Num a ## Subtract two numbers of the same type. ## @@ -513,7 +525,7 @@ add : Num range, Num range -> Num range ## ## >>> Frac.pi ## >>> |> Num.sub 2.0 -sub : Num range, Num range -> Num range +sub : Num a, Num a -> Num a ## Multiply two numbers of the same type. ## @@ -529,7 +541,7 @@ sub : Num range, Num range -> Num range ## ## >>> Frac.pi ## >>> |> Num.mul 2.0 -mul : Num range, Num range -> Num range +mul : Num a, Num a -> Num a ## Convert @@ -953,7 +965,7 @@ pow : Frac a, Frac a -> Frac a ## overflow expBySquaring : Int a, U8 -> Int a -## Returns an approximation of the absolute value of the square root of the [Frac]. +## Returns an approximation of the absolute value of a [Frac]'s square root. ## ## The square root of a negative number is an irrational number, and [Frac] only ## supports rational numbers. As such, you should make sure never to pass this From 87f994039b675e55776c9eeebaaf87d87f0a2727 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Fri, 4 Jun 2021 00:43:23 -0400 Subject: [PATCH 103/496] Drop Num.hash64 --- compiler/builtins/docs/Num.roc | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/compiler/builtins/docs/Num.roc b/compiler/builtins/docs/Num.roc index bd19527f59..9f1aca4861 100644 --- a/compiler/builtins/docs/Num.roc +++ b/compiler/builtins/docs/Num.roc @@ -742,18 +742,6 @@ asc : Num a, Num a -> [ Eq, Lt, Gt ] ## desc : Num a, Num a -> [ Eq, Lt, Gt ] -## TODO should we offer hash32 etc even if someday it has to do a hash64 and truncate? -## -## This function can crash under these circumstances: -## -## * It receives a function, or any type that contains a function (for example a record, tag, or #List containing a function) -## * It receives an erroneous #Frac (`NaN`, `Infinity`, or `-Infinity` - these values can only originate from hosts) -## -## CAUTION: This function may give different answers in future releases of Roc, -## so be aware that if you rely on the exact answer this gives today, your -## code may break in a future Roc release. -hash64 : a -> U64 - ## Limits ## The highest number that can be stored in a #Nat without overflowing its From 3b1142feb8d39953e97d6d8e54cee68175a1ab71 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Fri, 4 Jun 2021 00:45:37 -0400 Subject: [PATCH 104/496] Fix some duplicate and missing Num docs --- compiler/builtins/docs/Num.roc | 23 ++++++----------------- 1 file changed, 6 insertions(+), 17 deletions(-) diff --git a/compiler/builtins/docs/Num.roc b/compiler/builtins/docs/Num.roc index 9f1aca4861..102ac26212 100644 --- a/compiler/builtins/docs/Num.roc +++ b/compiler/builtins/docs/Num.roc @@ -840,31 +840,20 @@ e : Frac * ## An approximation of pi, specifically 3.141592653589793. pi : Frac * -## Constants - -## An approximation of e, specifically 2.718281828459045. -e : Frac * - -## An approximation of pi, specifically 3.141592653589793. -pi : Frac * - -#ceiling : Frac -> Int - -#floor : Frac -> Int ## Trigonometry -#cos : Frac -> Frac +cos : Frac a -> Frac a -#acos : Frac -> Frac +acos : Frac a -> Frac a -#sin : Frac -> Frac +sin : Frac a -> Frac a -#asin : Frac -> Frac +asin : Frac a -> Frac a -#tan : Frac -> Frac +tan : Frac a -> Frac a -#atan : Frac -> Frac +atan : Frac a -> Frac a ## Other Calculations (arithmetic?) From 253f7fed4fdff92783f5264b6182d5b9cccfda56 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Fri, 4 Jun 2021 00:55:17 -0400 Subject: [PATCH 105/496] Add some Nat docs. --- compiler/builtins/docs/Num.roc | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/compiler/builtins/docs/Num.roc b/compiler/builtins/docs/Num.roc index 102ac26212..5426a36ef0 100644 --- a/compiler/builtins/docs/Num.roc +++ b/compiler/builtins/docs/Num.roc @@ -206,6 +206,17 @@ I64 : Int [ @Signed64 ] U64 : Int [ @Unsigned64 ] I128 : Int [ @Signed128 ] U128 : Int [ @Unsigned128 ] + +## A [natural number](https://en.wikipedia.org/wiki/Natural_number) represented +## as a 64-bit unsigned integer on 64-bit systems, a 32-bit unsigned integer +## on 32-bit systems, and so on. +## +## This system-specific size makes it useful for certain data structure +## functions like [List.len], because the number of elements many data strucures +## can hold is also system-specific. For example, the maximum number of elements +## a [List] can hold on a 64-bit system fits in a 64-bit unsigned integer, and +## on a 32-bit system it fits in 32-bit unsigned integer. This makes [Nat] a +## good fit for [List.len] regardless of system. Nat : Int [ @Natural ] ## A 64-bit signed integer. All number literals without decimal points are compatible with #Int values. From 23831e4be12f4a8386c6f6528f34ada29ebd92f3 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Fri, 4 Jun 2021 07:55:21 -0400 Subject: [PATCH 106/496] s/runtime error/panic in docs --- compiler/builtins/docs/Num.roc | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/compiler/builtins/docs/Num.roc b/compiler/builtins/docs/Num.roc index 5426a36ef0..a7545a73e2 100644 --- a/compiler/builtins/docs/Num.roc +++ b/compiler/builtins/docs/Num.roc @@ -874,7 +874,7 @@ atan : Frac a -> Frac a ## ## [Division by zero is undefined in mathematics](https://en.wikipedia.org/wiki/Division_by_zero). ## As such, you should make sure never to pass zero as the denomaintor to this function! -## Calling [div] on a [Dec] denominator of 0 will cause a runtime error. +## Calling [div] on a [Dec] denominator of 0 will cause a panic. ## ## Calling [div] on [F32] and [F64] values follows these rules: ## * Dividing a positive [F32] or [F64] by zero returns [Infinity](#isPositiveInfinity). @@ -911,7 +911,7 @@ div : Frac a, Frac a -> Frac a ## and as such, so is modulo by zero. Because of this, you should make sure never ## to pass zero for the second argument to this function! ## -## Passing [mod] a [Dec] value of 0 for its second argument will cause a runtime error. +## Passing [mod] a [Dec] value of 0 for its second argument will cause a panic. ## Passing [mod] a [F32] and [F64] value for its second argument will cause it ## to return [NaN](#isNaN). ## @@ -957,7 +957,7 @@ expBySquaring : Int a, U8 -> Int a ## ## The square root of a negative number is an irrational number, and [Frac] only ## supports rational numbers. As such, you should make sure never to pass this -## function a negative number! Calling [sqrt] on a negative [Dec] will cause a runtime error. +## function a negative number! Calling [sqrt] on a negative [Dec] will cause a panic. ## ## Calling [sqrt] on [F32] and [F64] values follows these rules: ## * Passing a negative [F32] or [F64] returns [NaN](#isNaN). From 7e2afa949e425a62385e5f27efe02363813a2dd2 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Fri, 4 Jun 2021 07:55:35 -0400 Subject: [PATCH 107/496] Document Dict.insert and Set.add panicking on NaN --- compiler/builtins/docs/Dict.roc | 10 ++++++++++ compiler/builtins/docs/Set.roc | 1 + 2 files changed, 11 insertions(+) diff --git a/compiler/builtins/docs/Dict.roc b/compiler/builtins/docs/Dict.roc index 9486764194..178e5329ee 100644 --- a/compiler/builtins/docs/Dict.roc +++ b/compiler/builtins/docs/Dict.roc @@ -19,3 +19,13 @@ map : Dict beforeKey beforeValue, ({ key: beforeKey, value: beforeValue } -> { key: afterKey, value: afterValue }) -> Dict afterKey afterValue + +# DESIGN NOTES: The reason for panicking when given NaN is that: +# * If we allowed NaN in, Dict.insert would no longer be idempotent. +# * If we allowed NaN but overrode its semantics to make it feel like "NaN == NaN" we'd need isNaN checks in all hashing operations as well as all equality checks (during collision detection), not just insert. This would be much worse for performance than panicking on insert, which only requires one extra conditional on insert. +# * It's obviously invalid; the whole point of NaN is that an error occurred. Giving a runtime error notifies you when this problem happens. Giving it only on insert is the best for performance, because it means you aren't paying for isNaN checks on lookups as well. + +# TODO: removed `'` from signature because parser does not support it yet +# Original signature: insert : Dict 'key val, 'key, val -> Dict 'key val +## Since NaN is defined to be unequal to NaN, panics if given NaN for a key. +insert : Dict key val, key, val -> Dict key val diff --git a/compiler/builtins/docs/Set.roc b/compiler/builtins/docs/Set.roc index bc5211b407..2a6d70cc63 100644 --- a/compiler/builtins/docs/Set.roc +++ b/compiler/builtins/docs/Set.roc @@ -18,6 +18,7 @@ len : Set * -> Nat # TODO: removed `'` from signature because parser does not support it yet # Original signature: `add : Set 'elem, 'elem -> Set 'elem` +## Since NaN is defined to be unequal to NaN, panics if given NaN. add : Set elem, elem -> Set elem ## Drops the given element from the set. From 4d65cbf18317fe1215cb69c0cc8fbf8fed9b954b Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Fri, 4 Jun 2021 08:10:08 -0400 Subject: [PATCH 108/496] Clarify overflow semantics for add/sub/mul --- compiler/builtins/docs/Num.roc | 39 ++++++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) diff --git a/compiler/builtins/docs/Num.roc b/compiler/builtins/docs/Num.roc index a7545a73e2..0e41ec74a1 100644 --- a/compiler/builtins/docs/Num.roc +++ b/compiler/builtins/docs/Num.roc @@ -520,8 +520,21 @@ isOdd : Num * -> Bool ## ## >>> Frac.pi ## >>> |> Num.add 1.0 +## +## If the answer to this operation can't fit in the return value (e.g. an +## [I8] answer that's higher than 127 or lower than -128), the result is an +## *overflow*. For [F64] and [F32], overflow results in an answer of either +## [*Infinity*](#isPositiveInfinity) or [*-Infinity*](#isNegativeInfinity). For +## all other number types, overflow results in a panic. add : Num a, Num a -> Num a +## Add two numbers and check for overflow. +## +## This is the same as [Num.add] except if the operation overflows, instead of +## panicking or returning [*Infinity*](#isPositiveInfinity) or [*-Infinity*](#isNegativeInfinity), +## it will return `Err Overflow`. +addCheckOverflow : Num a, Num a -> Result (Num a) [ Overflow ]* + ## Subtract two numbers of the same type. ## ## (To subtract an #Int and a #Frac, first convert one so that they both have the same type. There are functions in the [`Frac`](/Frac) module that can convert both #Int to #Frac and the other way around.) @@ -536,8 +549,21 @@ add : Num a, Num a -> Num a ## ## >>> Frac.pi ## >>> |> Num.sub 2.0 +## +## If the answer to this operation can't fit in the return value (e.g. an +## [I8] answer that's higher than 127 or lower than -128), the result is an +## *overflow*. For [F64] and [F32], overflow results in an answer of either +## [*Infinity*](#isPositiveInfinity) or [*-Infinity*](#isNegativeInfinity). For +## all other number types, overflow results in a panic. sub : Num a, Num a -> Num a +## Subtract two numbers and check for overflow. +## +## This is the same as [Num.sub] except if the operation overflows, instead of +## panicking or returning [*Infinity*](#isPositiveInfinity) or [*-Infinity*](#isNegativeInfinity), +## it will return `Err Overflow`. +subCheckOverflow : Num a, Num a -> Result (Num a) [ Overflow ]* + ## Multiply two numbers of the same type. ## ## (To multiply an #Int and a #Frac, first convert one so that they both have the same type. There are functions in the [`Frac`](/Frac) module that can convert both #Int to #Frac and the other way around.) @@ -552,8 +578,21 @@ sub : Num a, Num a -> Num a ## ## >>> Frac.pi ## >>> |> Num.mul 2.0 +## +## If the answer to this operation can't fit in the return value (e.g. an +## [I8] answer that's higher than 127 or lower than -128), the result is an +## *overflow*. For [F64] and [F32], overflow results in an answer of either +## [*Infinity*](#isPositiveInfinity) or [*-Infinity*](#isNegativeInfinity). For +## all other number types, overflow results in a panic. mul : Num a, Num a -> Num a +## Multiply two numbers and check for overflow. +## +## This is the same as [Num.mul] except if the operation overflows, instead of +## panicking or returning [*Infinity*](#isPositiveInfinity) or [*-Infinity*](#isNegativeInfinity), +## it will return `Err Overflow`. +mulCheckOverflow : Num a, Num a -> Result (Num a) [ Overflow ]* + ## Convert ## Convert a number to a [Str]. From 4e9b11afd46b15fa6f36b126ee26ea2a809cfae0 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Fri, 4 Jun 2021 08:18:26 -0400 Subject: [PATCH 109/496] s/0/zero --- compiler/builtins/docs/Num.roc | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/compiler/builtins/docs/Num.roc b/compiler/builtins/docs/Num.roc index 0e41ec74a1..ae5842c339 100644 --- a/compiler/builtins/docs/Num.roc +++ b/compiler/builtins/docs/Num.roc @@ -455,7 +455,7 @@ Int size : Num [ @Int size ] ## This is because, for any given size of signed integer (32-bit, 64-bit, etc.) its negated lowest value turns out to be 1 higher than ## the highest value it can represent. (For this reason, calling #Num.abs on the lowest signed value will also cause overflow.) ## -## Additionally, calling #Num.neg on any unsigned integer (such as any #U64 or #U32 value) other than 0 will cause overflow. +## Additionally, calling #Num.neg on any unsigned integer (such as any #U64 or #U32 value) other than zero will cause overflow. ## ## (It will never crash when given a #Frac, however, because of how floating point numbers represent positive and negative numbers.) neg : Num a -> Num a @@ -913,7 +913,7 @@ atan : Frac a -> Frac a ## ## [Division by zero is undefined in mathematics](https://en.wikipedia.org/wiki/Division_by_zero). ## As such, you should make sure never to pass zero as the denomaintor to this function! -## Calling [div] on a [Dec] denominator of 0 will cause a panic. +## Calling [div] on a [Dec] denominator of zero will cause a panic. ## ## Calling [div] on [F32] and [F64] values follows these rules: ## * Dividing a positive [F32] or [F64] by zero returns [Infinity](#isPositiveInfinity). @@ -950,7 +950,7 @@ div : Frac a, Frac a -> Frac a ## and as such, so is modulo by zero. Because of this, you should make sure never ## to pass zero for the second argument to this function! ## -## Passing [mod] a [Dec] value of 0 for its second argument will cause a panic. +## Passing [mod] a [Dec] value of zero for its second argument will cause a panic. ## Passing [mod] a [F32] and [F64] value for its second argument will cause it ## to return [NaN](#isNaN). ## From 960a4fddc5f070efc3100df3e0f1514548b128b1 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Fri, 4 Jun 2021 19:23:44 +0200 Subject: [PATCH 110/496] added quicksort benchmark --- cli/benches/time_bench.rs | 14 +++++++------- cli/cli_utils/src/bench_utils.rs | 10 +++++++++- cli/tests/cli_run.rs | 27 +++++++++++++++------------ examples/benchmarks/Quicksort.roc | 2 +- examples/benchmarks/QuicksortApp.roc | 23 +++++++++++++++++++++++ 5 files changed, 55 insertions(+), 21 deletions(-) create mode 100644 examples/benchmarks/QuicksortApp.roc diff --git a/cli/benches/time_bench.rs b/cli/benches/time_bench.rs index 3923d83eb4..4944067555 100644 --- a/cli/benches/time_bench.rs +++ b/cli/benches/time_bench.rs @@ -1,5 +1,5 @@ use cli_utils::bench_utils::{ - bench_cfold, bench_deriv, bench_nqueens, bench_rbtree_ck, bench_rbtree_delete, + bench_cfold, bench_deriv, bench_nqueens, bench_quicksort, bench_rbtree_ck, bench_rbtree_delete, }; use criterion::{ criterion_group, criterion_main, measurement::WallTime, BenchmarkGroup, Criterion, SamplingMode, @@ -7,17 +7,17 @@ use criterion::{ fn bench_group_wall_time(c: &mut Criterion) { let mut group = c.benchmark_group("bench-group_wall-time"); - // calculate statistics based on a fixed(flat) 100 runs + // calculate statistics based on a fixed(flat) 200 runs group.sampling_mode(SamplingMode::Flat); group.sample_size(200); let bench_funcs: Vec>) -> ()> = vec![ - bench_nqueens, // queens 11 - bench_cfold, // e = mkExpr 12 1 - bench_deriv, // nest deriv 7 f - bench_rbtree_ck, // ms = makeMap 5 5600 + bench_nqueens, // queens 11 + bench_cfold, // e = mkExpr 12 1 + bench_deriv, // nest deriv 7 f + bench_rbtree_ck, // ms = makeMap 5 5600 bench_rbtree_delete, // m = makeMap 6000 - // TODO quicksort + bench_quicksort, // list size 2000 ]; for bench_func in bench_funcs.iter() { diff --git a/cli/cli_utils/src/bench_utils.rs b/cli/cli_utils/src/bench_utils.rs index a1cae5e257..03109ebb21 100644 --- a/cli/cli_utils/src/bench_utils.rs +++ b/cli/cli_utils/src/bench_utils.rs @@ -124,4 +124,12 @@ pub fn bench_rbtree_delete(bench_group_opt: Option<&mut Benchmar ); } -// TODO quicksort +pub fn bench_quicksort(bench_group_opt: Option<&mut BenchmarkGroup>) { + exec_bench_w_input( + &example_file("benchmarks", "QuicksortApp.roc"), + "1", // 1 for sorting large list, 0 for a small list + "quicksortapp", + "[ 0, 0, 0, 1, 2, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 13, 13, 14, 14, 16, 16, 16, 17, 17, 17, 18, 19, 20, 22, 22, 23, 24, 24, 24, 24, 25, 26, 26, 26, 26, 27, 27, 29, 29, 30, 30, 30, 30, 31, 31, 31, 31, 32, 32, 32, 33, 33, 33, 33, 34, 35, 35, 35, 35, 36, 36, 36, 37, 38, 39, 40, 41, 42, 43, 43, 43, 44, 44, 44, 47, 47, 47, 48, 49, 49, 49, 49, 51, 51, 52, 52, 53, 53, 54, 54, 54, 54, 55, 56, 56, 57, 58, 59, 59, 60, 62, 63, 63, 64, 65, 65, 66, 66, 66, 67, 67, 67, 68, 68, 69, 69, 70, 70, 72, 72, 72, 72, 72, 72, 73, 73, 73, 74, 74, 74, 76, 77, 77, 77, 78, 78, 78, 79, 79, 79, 80, 80, 80, 81, 81, 82, 82, 83, 83, 83, 83, 84, 85, 86, 86, 88, 88, 88, 88, 88, 89, 89, 90, 90, 91, 91, 92, 92, 93, 93, 94, 95, 95, 96, 96, 96, 98, 98, 99, 100, 101, 101, 102, 104, 105, 105, 106, 106, 107, 107, 108, 109, 112, 112, 113, 113, 113, 113, 113, 113, 115, 116, 116, 117, 118, 121, 122, 122, 122, 123, 123, 123, 123, 123, 124, 124, 125, 125, 126, 126, 126, 126, 127, 127, 128, 129, 130, 130, 130, 131, 131, 132, 132, 132, 133, 133, 135, 135, 135, 135, 136, 136, 137, 137, 139, 139, 139, 139, 141, 142, 144, 145, 146, 146, 146, 146, 146, 147, 147, 148, 148, 148, 148, 148, 148, 149, 149, 149, 150, 151, 151, 152, 152, 152, 153, 153, 153, 153, 154, 155, 155, 155, 156, 159, 159, 159, 160, 160, 160, 161, 161, 161, 162, 162, 162, 162, 165, 166, 166, 166, 167, 167, 167, 168, 168, 168, 169, 170, 170, 172, 172, 172, 172, 174, 174, 175, 176, 177, 178, 178, 178, 179, 180, 180, 180, 180, 180, 181, 182, 183, 183, 183, 184, 184, 185, 185, 186, 186, 187, 187, 187, 188, 188, 189, 189, 189, 189, 190, 190, 191, 191, 192, 193, 193, 193, 193, 193, 193, 194, 194, 195, 195, 195, 195, 195, 196, 197, 198, 198, 199, 199, 199, 199, 200, 201, 202, 202, 202, 202, 203, 204, 204, 205, 205, 205, 206, 206, 206, 207, 208, 209, 210, 210, 210, 210, 211, 211, 211, 211, 212, 212, 212, 212, 213, 213, 213, 213, 214, 214, 214, 215, 215, 215, 216, 216, 216, 216, 217, 217, 218, 218, 219, 220, 220, 220, 221, 221, 222, 222, 222, 222, 223, 223, 223, 225, 225, 225, 226, 227, 227, 228, 228, 229, 229, 229, 229, 231, 231, 233, 234, 234, 234, 234, 234, 234, 235, 235, 235, 235, 236, 236, 237, 238, 238, 238, 238, 238, 239, 239, 240, 240, 241, 241, 241, 241, 241, 242, 243, 243, 243, 244, 247, 248, 248, 248, 249, 249, 249, 250, 250, 250, 251, 252, 252, 254, 254, 254, 254, 254, 255, 255, 256, 257, 258, 259, 260, 261, 262, 262, 262, 262, 262, 263, 264, 264, 264, 265, 265, 266, 266, 266, 267, 269, 269, 269, 270, 270, 271, 271, 272, 273, 274, 274, 275, 275, 275, 276, 277, 277, 277, 278, 278, 279, 279, 281, 282, 282, 286, 287, 287, 287, 287, 287, 288, 288, 288, 288, 288, 288, 289, 289, 290, 290, 290, 291, 291, 292, 292, 292, 293, 293, 293, 293, 293, 293, 293, 294, 294, 294, 294, 295, 296, 296, 297, 297, 298, 298, 300, 300, 301, 301, 301, 301, 301, 302, 303, 303, 303, 304, 304, 304, 305, 305, 305, 306, 306, 308, 308, 309, 309, 310, 311, 312, 312, 312, 312, 313, 313, 313, 314, 314, 315, 316, 316, 317, 317, 318, 318, 318, 318, 319, 319, 320, 322, 322, 323, 323, 324, 324, 325, 325, 326, 328, 329, 329, 329, 330, 330, 330, 332, 332, 332, 333, 333, 333, 333, 334, 334, 334, 334, 335, 335, 335, 335, 335, 335, 336, 336, 337, 337, 338, 338, 338, 339, 339, 340, 341, 342, 342, 343, 343, 344, 344, 345, 345, 345, 346, 346, 348, 349, 349, 349, 349, 350, 350, 350, 351, 351, 351, 352, 352, 352, 352, 353, 353, 353, 353, 355, 355, 355, 355, 355, 356, 357, 357, 357, 358, 358, 359, 359, 359, 360, 360, 361, 361, 361, 362, 362, 363, 364, 365, 365, 367, 367, 368, 368, 369, 369, 369, 369, 369, 371, 371, 371, 371, 372, 372, 373, 373, 373, 374, 374, 375, 375, 376, 376, 376, 377, 377, 378, 378, 378, 378, 378, 378, 379, 379, 381, 381, 381, 382, 383, 383, 384, 384, 385, 385, 385, 386, 386, 386, 386, 387, 387, 388, 388, 388, 389, 389, 389, 390, 390, 390, 391, 391, 392, 392, 393, 393, 394, 394, 394, 394, 394, 395, 396, 397, 397, 397, 398, 399, 399, 400, 400, 400, 400, 401, 401, 401, 401, 402, 402, 402, 402, 402, 402, 403, 404, 404, 404, 404, 405, 405, 405, 405, 407, 409, 409, 410, 410, 410, 410, 410, 413, 414, 414, 416, 417, 417, 417, 418, 418, 418, 419, 419, 419, 420, 420, 420, 421, 422, 422, 425, 426, 426, 427, 427, 427, 428, 428, 428, 429, 430, 431, 433, 433, 433, 435, 435, 436, 436, 436, 437, 438, 438, 438, 439, 439, 439, 441, 442, 443, 443, 443, 443, 444, 444, 444, 445, 445, 447, 447, 447, 448, 448, 449, 450, 450, 450, 450, 451, 451, 451, 451, 452, 452, 452, 452, 453, 453, 454, 454, 454, 454, 455, 455, 455, 456, 456, 457, 457, 457, 457, 458, 459, 460, 460, 461, 461, 462, 462, 464, 464, 464, 465, 467, 467, 468, 469, 469, 469, 469, 471, 471, 472, 472, 473, 474, 474, 474, 475, 475, 476, 476, 477, 477, 479, 479, 480, 481, 481, 482, 483, 484, 484, 485, 485, 486, 486, 487, 487, 487, 487, 488, 489, 489, 489, 489, 490, 490, 490, 491, 493, 493, 493, 494, 494, 495, 495, 495, 495, 497, 497, 499, 499, 500, 500, 501, 501, 502, 502, 502, 503, 505, 505, 506, 506, 507, 508, 508, 508, 508, 510, 510, 511, 511, 512, 512, 513, 514, 514, 515, 516, 516, 516, 516, 517, 517, 517, 518, 518, 519, 521, 522, 522, 523, 523, 523, 523, 523, 525, 526, 526, 526, 527, 527, 528, 529, 530, 530, 531, 531, 532, 532, 532, 532, 533, 533, 533, 533, 533, 534, 534, 535, 535, 537, 539, 539, 540, 541, 542, 542, 543, 544, 547, 547, 547, 547, 547, 547, 548, 549, 550, 551, 551, 551, 552, 552, 555, 557, 558, 558, 558, 558, 559, 559, 560, 560, 561, 561, 562, 563, 563, 563, 563, 563, 564, 566, 566, 566, 567, 567, 567, 568, 568, 568, 569, 569, 571, 572, 573, 573, 574, 574, 575, 577, 578, 578, 580, 581, 582, 582, 582, 582, 583, 583, 585, 587, 587, 587, 588, 588, 589, 589, 590, 590, 590, 590, 591, 591, 591, 592, 593, 593, 595, 596, 597, 597, 598, 598, 599, 599, 600, 600, 600, 602, 602, 602, 603, 604, 605, 605, 606, 606, 606, 608, 608, 608, 608, 609, 610, 610, 610, 610, 611, 611, 612, 612, 613, 613, 614, 614, 614, 616, 616, 616, 617, 617, 617, 618, 618, 618, 618, 618, 618, 618, 619, 619, 619, 619, 619, 619, 619, 620, 620, 621, 621, 621, 624, 624, 624, 624, 625, 625, 625, 625, 626, 628, 628, 628, 630, 630, 630, 631, 631, 631, 632, 632, 632, 633, 635, 635, 635, 636, 637, 637, 638, 638, 638, 639, 639, 639, 640, 642, 643, 644, 645, 646, 646, 650, 650, 651, 651, 651, 653, 654, 654, 654, 655, 655, 656, 656, 657, 658, 659, 659, 661, 661, 661, 662, 662, 663, 663, 663, 663, 664, 665, 665, 665, 665, 666, 666, 667, 668, 668, 669, 669, 669, 670, 670, 672, 672, 672, 672, 672, 673, 674, 674, 675, 675, 676, 676, 676, 677, 677, 677, 678, 678, 679, 679, 679, 679, 679, 680, 680, 682, 683, 683, 684, 684, 685, 685, 685, 686, 687, 687, 687, 687, 687, 687, 688, 689, 689, 689, 691, 691, 692, 692, 693, 693, 696, 697, 697, 698, 698, 698, 698, 698, 699, 699, 700, 700, 700, 700, 703, 704, 704, 704, 704, 704, 705, 705, 705, 706, 706, 707, 707, 707, 708, 708, 708, 710, 711, 711, 711, 711, 712, 712, 713, 713, 713, 713, 713, 713, 713, 714, 714, 714, 715, 716, 717, 717, 717, 718, 718, 718, 719, 719, 719, 719, 719, 719, 720, 720, 720, 721, 721, 723, 723, 723, 724, 724, 725, 726, 727, 727, 727, 727, 728, 729, 729, 730, 730, 730, 730, 731, 732, 733, 734, 734, 734, 735, 735, 736, 736, 736, 736, 737, 737, 738, 739, 739, 739, 740, 743, 743, 743, 743, 743, 744, 744, 745, 745, 746, 746, 746, 747, 747, 748, 749, 750, 750, 751, 751, 751, 752, 752, 753, 753, 753, 753, 753, 753, 754, 754, 756, 757, 757, 758, 758, 758, 759, 759, 760, 760, 760, 761, 762, 762, 762, 763, 763, 766, 768, 768, 768, 768, 768, 769, 769, 772, 773, 773, 774, 775, 775, 776, 776, 776, 776, 776, 777, 777, 777, 778, 779, 779, 779, 780, 780, 780, 781, 782, 782, 782, 783, 783, 783, 783, 784, 785, 785, 785, 785, 786, 786, 786, 786, 786, 787, 788, 789, 789, 789, 790, 790, 791, 791, 791, 792, 792, 792, 792, 793, 793, 794, 794, 797, 797, 798, 798, 799, 799, 799, 800, 801, 801, 802, 803, 804, 804, 805, 805, 805, 805, 807, 807, 807, 807, 808, 808, 808, 808, 809, 809, 810, 810, 811, 811, 812, 813, 814, 815, 816, 816, 817, 818, 819, 819, 820, 820, 820, 822, 822, 823, 823, 823, 823, 826, 826, 827, 827, 829, 830, 830, 831, 831, 832, 832, 832, 833, 833, 833, 834, 834, 835, 835, 835, 836, 836, 837, 837, 838, 838, 839, 840, 840, 841, 841, 842, 842, 843, 844, 844, 845, 846, 846, 847, 847, 848, 849, 849, 851, 851, 851, 851, 852, 853, 853, 853, 854, 854, 854, 855, 856, 856, 857, 857, 858, 859, 859, 859, 860, 860, 860, 860, 860, 861, 861, 861, 861, 862, 862, 864, 865, 865, 865, 866, 866, 866, 866, 867, 868, 868, 868, 869, 869, 870, 871, 872, 872, 872, 872, 872, 873, 873, 873, 874, 874, 875, 875, 876, 877, 878, 879, 879, 880, 880, 880, 880, 882, 883, 884, 885, 885, 885, 886, 886, 886, 888, 889, 889, 891, 891, 891, 892, 892, 894, 894, 894, 894, 894, 894, 895, 896, 898, 898, 899, 899, 899, 900, 900, 901, 902, 902, 903, 905, 905, 905, 906, 906, 906, 907, 907, 907, 907, 907, 907, 907, 908, 908, 908, 908, 909, 909, 909, 910, 910, 911, 913, 913, 913, 913, 914, 914, 914, 915, 916, 917, 917, 917, 918, 918, 918, 919, 920, 920, 920, 920, 920, 920, 921, 921, 921, 922, 923, 924, 924, 924, 925, 925, 926, 926, 927, 928, 928, 928, 928, 929, 929, 930, 930, 931, 932, 932, 933, 934, 934, 934, 935, 935, 935, 936, 936, 937, 938, 938, 938, 939, 939, 939, 940, 940, 941, 941, 942, 942, 942, 943, 943, 943, 943, 943, 943, 944, 945, 946, 946, 946, 947, 947, 948, 948, 950, 950, 951, 951, 952, 952, 952, 953, 955, 955, 955, 956, 956, 957, 957, 958, 959, 959, 959, 959, 960, 961, 962, 963, 964, 964, 964, 965, 965, 965, 966, 966, 966, 967, 967, 967, 968, 968, 968, 969, 969, 970, 970, 971, 972, 973, 973, 974, 975, 975, 975, 976, 976, 977, 977, 977, 978, 978, 978, 979, 979, 980, 980, 981, 981, 982, 982, 982, 983, 986, 986, 988, 990, 991, 991, 991, 991, 991, 992, 992, 993, 993, 994, 994, 995, 995, 995, 995, 995, 997, 997, 997, 997, 998, 998, 999, 999, 999 ]\n", + bench_group_opt, + ); +} diff --git a/cli/tests/cli_run.rs b/cli/tests/cli_run.rs index 1d139a9eae..280290bd40 100644 --- a/cli/tests/cli_run.rs +++ b/cli/tests/cli_run.rs @@ -141,11 +141,12 @@ mod cli_run { #[test] #[serial(quicksort)] fn run_quicksort_not_optimized() { - check_output( - &example_file("quicksort", "Quicksort.roc"), - "quicksort", + check_output_with_stdin( + &example_file("benchmarks", "QuicksortApp.roc"), + "0", + "quicksortapp", &[], - "[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2]\n", + "[ 0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 6, 6, 8, 9 ]\n", true, ); } @@ -153,11 +154,12 @@ mod cli_run { #[test] #[serial(quicksort)] fn run_quicksort_optimized() { - check_output( - &example_file("quicksort", "Quicksort.roc"), - "quicksort", + check_output_with_stdin( + &example_file("benchmarks", "QuicksortApp.roc"), + "0", + "quicksortapp", &["--optimize"], - "[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2]\n", + "[ 0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 6, 6, 8, 9 ]\n", true, ); } @@ -165,11 +167,12 @@ mod cli_run { #[test] #[serial(quicksort)] fn run_quicksort_optimized_valgrind() { - check_output( - &example_file("quicksort", "Quicksort.roc"), - "quicksort", + check_output_with_stdin( + &example_file("benchmarks", "QuicksortApp.roc"), + "0", + "quicksortapp", &["--optimize"], - "[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2]\n", + "[ 0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 6, 6, 8, 9 ]\n", true, ); } diff --git a/examples/benchmarks/Quicksort.roc b/examples/benchmarks/Quicksort.roc index bbd2a90c12..271be43894 100644 --- a/examples/benchmarks/Quicksort.roc +++ b/examples/benchmarks/Quicksort.roc @@ -1,4 +1,4 @@ -interface Quicksort exposes [ sortBy, show ] imports [] +interface Quicksort exposes [ sortBy, sortWith, show ] imports [] show : List I64 -> Str show = \list -> diff --git a/examples/benchmarks/QuicksortApp.roc b/examples/benchmarks/QuicksortApp.roc new file mode 100644 index 0000000000..198003bf13 --- /dev/null +++ b/examples/benchmarks/QuicksortApp.roc @@ -0,0 +1,23 @@ +app "quicksortapp" + packages { base: "platform" } + imports [base.Task, Quicksort] + provides [ main ] to base + +main : Task.Task {} [] +main = + Task.after Task.getInt \n -> + unsortedList = + if n == 0 then + # small unsorted list of 20 elements (0-9) + [ 2, 4, 4, 0, 3, 8, 3, 6, 4, 9, 4, 6, 3, 5, 2, 2, 3, 1, 1, 3 ] + else + # big unsorted list of 2000 elements (0-1000) + [ 891, 330, 190, 304, 991, 803, 54, 362, 428, 318, 59, 631, 995, 36, 711, 450, 654, 614, 74, 288, 198, 11, 369, 290, 7, 934, 72, 642, 955, 782, 724, 811, 3, 402, 517, 128, 902, 612, 454, 281, 794, 109, 497, 454, 238, 541, 215, 672, 4, 855, 908, 868, 177, 885, 460, 133, 367, 113, 131, 191, 148, 254, 914, 680, 735, 783, 225, 720, 708, 447, 625, 526, 529, 914, 126, 857, 574, 234, 249, 433, 779, 74, 275, 302, 315, 131, 518, 572, 301, 450, 346, 630, 928, 420, 183, 287, 420, 730, 512, 533, 69, 942, 214, 801, 196, 633, 13, 493, 343, 910, 462, 939, 394, 367, 619, 583, 674, 265, 113, 909, 202, 135, 859, 924, 214, 27, 30, 531, 662, 90, 917, 35, 236, 210, 456, 758, 338, 514, 590, 907, 106, 147, 625, 199, 766, 628, 894, 552, 108, 982, 94, 751, 734, 678, 371, 894, 204, 719, 559, 676, 362, 782, 959, 826, 793, 935, 17, 837, 179, 679, 819, 33, 197, 611, 719, 718, 688, 365, 36, 62, 349, 719, 598, 826, 135, 218, 889, 282, 948, 442, 345, 453, 386, 840, 95, 921, 293, 241, 494, 774, 139, 712, 373, 730, 301, 472, 805, 41, 355, 384, 188, 168, 869, 17, 339, 55, 238, 476, 394, 725, 130, 53, 978, 762, 418, 419, 920, 913, 780, 723, 750, 277, 92, 37, 979, 971, 882, 936, 190, 216, 452, 495, 450, 597, 567, 994, 587, 777, 700, 685, 991, 995, 533, 443, 945, 56, 186, 413, 239, 286, 234, 486, 399, 410, 853, 516, 443, 999, 591, 16, 452, 314, 459, 343, 296, 189, 84, 465, 640, 616, 122, 665, 379, 858, 930, 188, 47, 445, 959, 93, 244, 89, 610, 26, 952, 294, 77, 619, 775, 661, 291, 290, 443, 458, 689, 107, 517, 794, 827, 313, 506, 568, 264, 400, 485, 972, 430, 953, 258, 409, 305, 729, 288, 146, 133, 603, 568, 748, 891, 521, 199, 12, 714, 180, 848, 317, 947, 454, 166, 776, 907, 493, 195, 5, 631, 791, 86, 932, 809, 464, 80, 846, 323, 300, 658, 869, 712, 316, 551, 700, 438, 457, 516, 747, 54, 854, 636, 72, 352, 24, 159, 222, 844, 427, 369, 969, 208, 337, 663, 388, 624, 943, 781, 868, 563, 559, 638, 818, 205, 927, 265, 235, 713, 871, 617, 34, 751, 530, 36, 418, 251, 654, 213, 99, 799, 808, 439, 609, 263, 481, 113, 706, 185, 386, 776, 152, 178, 468, 922, 0, 942, 817, 428, 66, 399, 355, 450, 792, 549, 237, 532, 212, 254, 279, 941, 685, 211, 100, 994, 182, 503, 707, 368, 472, 297, 820, 905, 83, 319, 345, 47, 547, 769, 713, 204, 153, 687, 372, 656, 914, 448, 872, 73, 955, 318, 381, 254, 849, 719, 909, 905, 558, 471, 142, 136, 865, 392, 650, 342, 698, 199, 385, 673, 632, 14, 792, 523, 862, 872, 792, 957, 739, 713, 373, 72, 464, 667, 394, 933, 305, 332, 444, 960, 322, 900, 841, 146, 566, 723, 884, 355, 153, 49, 928, 689, 304, 467, 306, 952, 277, 943, 421, 216, 704, 525, 293, 974, 754, 978, 96, 582, 5, 811, 229, 304, 52, 610, 160, 872, 831, 388, 925, 216, 665, 435, 913, 753, 381, 452, 786, 737, 834, 191, 165, 16, 174, 997, 735, 976, 189, 340, 161, 653, 849, 447, 264, 950, 349, 4, 375, 312, 3, 279, 833, 600, 721, 205, 162, 832, 451, 998, 26, 689, 870, 215, 651, 419, 831, 70, 308, 596, 500, 624, 672, 481, 522, 390, 79, 410, 77, 336, 502, 10, 95, 697, 591, 385, 820, 807, 726, 537, 359, 772, 548, 768, 981, 838, 90, 599, 172, 272, 718, 417, 789, 578, 669, 786, 534, 403, 602, 180, 115, 205, 96, 573, 359, 830, 970, 431, 533, 342, 777, 600, 880, 374, 262, 704, 31, 710, 148, 264, 288, 501, 540, 851, 929, 420, 93, 5, 350, 80, 810, 8, 153, 369, 582, 908, 756, 523, 964, 124, 842, 152, 378, 946, 720, 425, 975, 844, 211, 378, 963, 966, 297, 763, 891, 180, 505, 33, 201, 377, 167, 35, 600, 698, 801, 977, 378, 361, 35, 401, 479, 266, 758, 32, 956, 943, 705, 860, 737, 791, 727, 162, 997, 213, 785, 804, 292, 56, 651, 567, 547, 866, 531, 835, 875, 122, 721, 202, 632, 895, 117, 676, 522, 993, 357, 867, 49, 797, 655, 91, 608, 838, 322, 582, 736, 708, 65, 39, 325, 126, 619, 135, 161, 523, 228, 414, 610, 339, 952, 691, 612, 238, 400, 846, 861, 313, 161, 752, 920, 136, 650, 939, 920, 262, 358, 899, 505, 738, 155, 783, 743, 359, 605, 330, 805, 662, 608, 617, 894, 387, 568, 235, 539, 799, 58, 943, 937, 234, 386, 819, 917, 405, 490, 113, 353, 444, 437, 361, 357, 225, 656, 551, 973, 305, 892, 30, 665, 920, 716, 126, 294, 72, 635, 590, 451, 89, 236, 714, 44, 698, 401, 271, 670, 371, 919, 397, 141, 484, 847, 630, 813, 247, 414, 239, 943, 691, 277, 357, 212, 480, 220, 293, 441, 314, 193, 193, 734, 687, 515, 802, 964, 127, 547, 918, 638, 234, 145, 790, 715, 555, 160, 754, 646, 329, 861, 637, 195, 762, 33, 605, 618, 78, 938, 668, 940, 454, 606, 309, 518, 635, 211, 101, 753, 532, 743, 730, 231, 608, 516, 422, 457, 346, 155, 569, 947, 51, 334, 172, 123, 295, 885, 778, 428, 980, 621, 805, 169, 808, 316, 401, 639, 769, 118, 698, 618, 105, 744, 174, 353, 752, 957, 257, 497, 743, 260, 872, 590, 815, 543, 906, 501, 760, 358, 325, 621, 780, 189, 262, 51, 439, 341, 290, 829, 303, 705, 477, 886, 137, 6, 383, 303, 7, 149, 59, 125, 83, 877, 83, 378, 444, 318, 402, 810, 404, 329, 812, 4, 885, 44, 866, 489, 907, 860, 727, 582, 139, 808, 704, 619, 74, 909, 242, 879, 566, 221, 534, 628, 23, 916, 590, 303, 489, 523, 958, 563, 728, 657, 250, 195, 500, 88, 907, 310, 353, 745, 563, 64, 455, 91, 390, 393, 697, 65, 786, 240, 222, 617, 216, 125, 597, 913, 170, 591, 495, 840, 278, 966, 968, 978, 843, 655, 9, 557, 249, 490, 202, 550, 83, 619, 220, 351, 853, 816, 455, 561, 4, 376, 901, 300, 33, 739, 262, 991, 948, 234, 717, 857, 527, 902, 789, 624, 203, 445, 911, 288, 700, 823, 773, 970, 526, 967, 687, 144, 745, 123, 833, 889, 676, 14, 47, 96, 876, 832, 276, 60, 148, 266, 782, 456, 592, 736, 78, 451, 724, 581, 718, 993, 287, 386, 938, 243, 312, 736, 495, 493, 908, 961, 999, 404, 542, 880, 679, 433, 394, 417, 888, 448, 502, 732, 516, 22, 606, 338, 776, 711, 936, 270, 986, 275, 834, 335, 122, 287, 966, 378, 854, 233, 539, 687, 436, 193, 241, 899, 791, 698, 784, 618, 267, 194, 562, 102, 220, 866, 723, 422, 460, 924, 308, 925, 113, 508, 878, 547, 739, 475, 823, 645, 938, 959, 0, 758, 574, 706, 19, 127, 167, 344, 845, 740, 361, 768, 560, 72, 360, 866, 753, 992, 946, 929, 461, 371, 875, 599, 907, 669, 862, 67, 301, 101, 962, 827, 762, 499, 168, 183, 207, 416, 81, 333, 856, 202, 717, 533, 892, 625, 573, 313, 672, 805, 384, 294, 223, 0, 905, 410, 489, 474, 986, 842, 661, 66, 73, 918, 512, 211, 968, 26, 523, 631, 249, 621, 907, 474, 146, 388, 292, 873, 2, 404, 31, 713, 206, 225, 861, 983, 659, 743, 426, 798, 152, 9, 355, 195, 410, 618, 687, 210, 1, 928, 588, 461, 217, 132, 598, 151, 88, 320, 352, 439, 934, 968, 542, 323, 184, 227, 759, 383, 335, 146, 223, 400, 438, 451, 334, 837, 616, 753, 864, 162, 129, 913, 564, 17, 935, 951, 561, 977, 940, 956, 979, 508, 547, 513, 880, 700, 874, 485, 924, 788, 223, 162, 836, 965, 679, 696, 68, 975, 704, 44, 393, 777, 473, 209, 273, 471, 418, 350, 116, 669, 335, 639, 747, 40, 334, 417, 625, 427, 240, 248, 928, 170, 856, 159, 344, 328, 872, 123, 400, 376, 921, 934, 24, 793, 734, 839, 894, 926, 318, 389, 228, 977, 946, 613, 274, 973, 879, 757, 898, 499, 883, 405, 798, 861, 580, 577, 587, 25, 159, 391, 80, 708, 404, 593, 510, 389, 995, 786, 602, 931, 668, 368, 256, 333, 319, 918, 469, 997, 508, 334, 729, 227, 67, 666, 873, 921, 238, 112, 944, 238, 455, 287, 274, 920, 335, 820, 436, 900, 822, 880, 235, 5, 578, 502, 666, 750, 859, 467, 510, 969, 309, 369, 618, 312, 868, 999, 147, 588, 229, 967, 519, 638, 619, 982, 630, 48, 275, 807, 218, 906, 677, 841, 563, 530, 32, 494, 744, 753, 148, 43, 26, 679, 390, 135, 405, 746, 410, 487, 965, 475, 751, 199, 271, 20, 823, 833, 345, 217, 63, 13, 70, 982, 713, 491, 397, 670, 618, 85, 186, 389, 804, 355, 206, 950, 419, 637, 619, 180, 194, 773, 713, 508, 229, 77, 252, 30, 402, 558, 326, 385, 335, 995, 178, 398, 3, 116, 148, 733, 98, 447, 154, 329, 699, 104, 626, 816, 137, 43, 29, 402, 333, 292, 832, 823, 132, 449, 76, 288, 746, 730, 955, 79, 105, 52, 760, 429, 490, 377, 567, 469, 482, 614, 351, 672, 613, 942, 369, 72, 214, 54, 964, 382, 63, 18, 853, 775, 166, 551, 86, 980, 443, 659, 807, 835, 620, 288, 474, 663, 910, 935, 487, 851, 527, 763, 149, 139, 79, 333, 852, 374, 462, 241, 363, 195, 311, 822, 511, 187, 886, 180, 558, 222, 800, 66, 785, 990, 396, 243, 215, 248, 684, 780, 160, 661, 563, 457, 241, 711, 426, 296, 387, 506, 252, 289, 517, 923, 193, 787, 32, 222, 394, 692, 338, 684, 289, 809, 262, 351, 906, 231, 150, 692, 776, 187, 166, 903, 378, 583, 81, 704, 851, 552, 352, 132, 476, 759, 254, 178, 894, 183, 193, 907, 665, 683, 317, 360, 269, 348, 243, 835, 975, 193, 719, 82, 533, 874, 674, 43, 628, 167, 930, 332, 511, 176, 753, 42, 123, 768, 168, 943, 707, 783, 939, 714, 57, 799, 487, 332, 401, 335, 851, 965, 483, 654, 743, 436, 679, 675, 293, 324, 229, 337, 151, 88, 121, 469, 896, 213, 917, 608, 535, 130, 779, 672, 768, 632, 926, 29, 31, 899, 699, 4, 727, 587, 571, 830, 477, 532, 898, 293, 785, 915, 602, 291, 797, 210, 324, 711, 330, 746, 675, 149, 148, 235, 566, 212, 381, 126, 620, 49, 349, 392, 736, 693, 124, 703, 185, 569, 8, 785, 585, 488, 720, 269, 683, 457, 643, 181, 453, 976, 255, 175, 234, 644, 479, 146, 153, 719, 38, 682, 995, 865, 507, 606, 184, 886, 371, 210, 438, 123, 941, 139, 624, 854, 908, 860, 992, 372, 16, 282, 298, 270, 402, 693, 261, 402, 106, 379, 639, 156, 616, 395, 865, 409, 526, 27, 373, 604, 486, 786, 685, 814, 364, 595, 847, 792, 187, 266, 589, 981, 873, 213, 221, 293, 932, 278, 487, 760, 789, 687, 306, 680, 269, 593, 998, 790, 664, 98, 611, 959, 198, 860, 469, 779, 435, 78, 707, 717, 614, 405, 589, 92, 547, 761, 254, 88, 663, 375, 464, 489, 391, 575, 259, 427, 112, 155, 352, 544, 53, 532, 130, 663, 298, 894, 768, 336, 808, 433, 651, 452, 172, 301, 997, 82, 189, 376, 68, 250, 859, 67, 312, 514, 287, 618, 677, 250, 206, 30, 88, 991, 397, 686, 255, 353, 54, 172, 560, 783, 757, 407, 727, 22, 200, 192, 212, 248, 558, 528, 535, 495, 991, 678, 749, 484, 356, 10, 646, 920, 219, 705, 11, 988, 241, 731, 836, 350, 967, 635, 713, 610, 107, 69, 677, 349, 365, 293, 24, 860, 24, 294, 73, 113, 301, 226, 35, 31, 49, 776, 807, 951 ] + + sort unsortedList + |> Quicksort.show + |> Task.putLine + +sort : List I64 -> List I64 +sort = \list -> + Quicksort.sortWith list (\x, y -> Num.compare x y) \ No newline at end of file From 4beac319bcc2d48589997250e4b1e8ebee4cc456 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Fri, 4 Jun 2021 20:00:45 +0200 Subject: [PATCH 111/496] Run benchmarks for longer, added README to benchmarks --- Earthfile | 1 + cli/benches/README.md | 17 +++++++++++++++++ cli/benches/time_bench.rs | 8 ++++---- cli/cli_utils/src/bench_utils.rs | 16 ++++++++-------- 4 files changed, 30 insertions(+), 12 deletions(-) create mode 100644 cli/benches/README.md diff --git a/Earthfile b/Earthfile index 766e224f12..ece11b44e4 100644 --- a/Earthfile +++ b/Earthfile @@ -115,6 +115,7 @@ bench-roc: FROM +copy-dirs-and-cache ENV RUST_BACKTRACE=full RUN cargo criterion -V + RUN ulimit -s unlimited # to prevent stack overflow errors for CFold RUN --privileged --mount=type=cache,target=$SCCACHE_DIR \ cd cli && cargo criterion && sccache --show-stats diff --git a/cli/benches/README.md b/cli/benches/README.md new file mode 100644 index 0000000000..0c91904cfa --- /dev/null +++ b/cli/benches/README.md @@ -0,0 +1,17 @@ + +# Running the benchmarks + +Install cargo criterion: +``` +cargo install cargo-criterion +``` + +To prevent stack overflow on the `CFold` benchmark: +``` +ulimit -s unlimited +``` + +In the `cli` folder execute: +``` +cargo criterion +``` \ No newline at end of file diff --git a/cli/benches/time_bench.rs b/cli/benches/time_bench.rs index 4944067555..491db64784 100644 --- a/cli/benches/time_bench.rs +++ b/cli/benches/time_bench.rs @@ -13,10 +13,10 @@ fn bench_group_wall_time(c: &mut Criterion) { let bench_funcs: Vec>) -> ()> = vec![ bench_nqueens, // queens 11 - bench_cfold, // e = mkExpr 12 1 - bench_deriv, // nest deriv 7 f - bench_rbtree_ck, // ms = makeMap 5 5600 - bench_rbtree_delete, // m = makeMap 6000 + bench_cfold, // e = mkExpr 17 1 + bench_deriv, // nest deriv 8 f + bench_rbtree_ck, // ms = makeMap 5 80000 + bench_rbtree_delete, // m = makeMap 100000 bench_quicksort, // list size 2000 ]; diff --git a/cli/cli_utils/src/bench_utils.rs b/cli/cli_utils/src/bench_utils.rs index 03109ebb21..03d1e1f3e8 100644 --- a/cli/cli_utils/src/bench_utils.rs +++ b/cli/cli_utils/src/bench_utils.rs @@ -87,9 +87,9 @@ pub fn bench_nqueens(bench_group_opt: Option<&mut BenchmarkGroup pub fn bench_cfold(bench_group_opt: Option<&mut BenchmarkGroup>) { exec_bench_w_input( &example_file("benchmarks", "CFold.roc"), - "12", + "17", "cfold", - "10426 & 10426\n", + "396354 & 396354\n", bench_group_opt, ); } @@ -97,9 +97,9 @@ pub fn bench_cfold(bench_group_opt: Option<&mut BenchmarkGroup(bench_group_opt: Option<&mut BenchmarkGroup>) { exec_bench_w_input( &example_file("benchmarks", "Deriv.roc"), - "7", + "8", "deriv", - "1 count: 6\n2 count: 22\n3 count: 90\n4 count: 420\n5 count: 2202\n6 count: 12886\n7 count: 83648\n", + "1 count: 6\n2 count: 22\n3 count: 90\n4 count: 420\n5 count: 2202\n6 count: 12886\n7 count: 83648\n8 count: 598592\n", bench_group_opt, ); } @@ -107,9 +107,9 @@ pub fn bench_deriv(bench_group_opt: Option<&mut BenchmarkGroup(bench_group_opt: Option<&mut BenchmarkGroup>) { exec_bench_w_input( &example_file("benchmarks", "RBTreeCk.roc"), - "5600", + "80000", "rbtree-ck", - "560\n", + "8000\n", bench_group_opt, ); } @@ -117,9 +117,9 @@ pub fn bench_rbtree_ck(bench_group_opt: Option<&mut BenchmarkGro pub fn bench_rbtree_delete(bench_group_opt: Option<&mut BenchmarkGroup>) { exec_bench_w_input( &example_file("benchmarks", "RBTreeDel.roc"), - "6000", + "100000", "rbtree-del", - "420\n", + "7000\n", bench_group_opt, ); } From 40792187feabb8fa5111fe437a827482b7bbb949 Mon Sep 17 00:00:00 2001 From: Folkert Date: Fri, 4 Jun 2021 22:26:45 +0200 Subject: [PATCH 112/496] setup --- Cargo.lock | 1 + compiler/gen/Cargo.toml | 1 + compiler/gen/src/llvm/build.rs | 60 ++++++++++----------- compiler/mono/src/alias_analysis.rs | 84 +++++++++++++++++------------ 4 files changed, 82 insertions(+), 64 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 5b05e59e64..db774853b7 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3171,6 +3171,7 @@ dependencies = [ "inlinable_string", "libc", "maplit", + "morphic_lib", "pretty_assertions 0.5.1", "quickcheck 0.8.5", "quickcheck_macros 0.8.0", diff --git a/compiler/gen/Cargo.toml b/compiler/gen/Cargo.toml index 685b00fa3a..608038af0e 100644 --- a/compiler/gen/Cargo.toml +++ b/compiler/gen/Cargo.toml @@ -15,6 +15,7 @@ roc_builtins = { path = "../builtins" } roc_unify = { path = "../unify" } roc_solve = { path = "../solve" } roc_mono = { path = "../mono" } +morphic_lib = { path = "../../vendor/morphic_lib" } im = "14" # im and im-rc should always have the same version! im-rc = "14" # im and im-rc should always have the same version! bumpalo = { version = "3.6.1", features = ["collections"] } diff --git a/compiler/gen/src/llvm/build.rs b/compiler/gen/src/llvm/build.rs index 06e08dcdd5..bf17221a4f 100644 --- a/compiler/gen/src/llvm/build.rs +++ b/compiler/gen/src/llvm/build.rs @@ -43,6 +43,7 @@ use inkwell::values::{ }; use inkwell::OptimizationLevel; use inkwell::{AddressSpace, IntPredicate}; +use morphic_lib::FuncName; use roc_builtins::bitcode; use roc_collections::all::{ImMap, MutMap, MutSet}; use roc_module::ident::TagName; @@ -795,21 +796,32 @@ pub fn build_exp_call<'a, 'ctx, 'env>( match call_type { CallType::ByName { - name, full_layout, .. + name, + full_layout, + arg_layouts, + ret_layout, + .. } => { let mut arg_tuples: Vec = Vec::with_capacity_in(arguments.len(), env.arena); + let name_bytes = roc_mono::alias_analysis::func_name_bytes_help( + *name, + arg_layouts.iter().copied(), + *ret_layout, + ); + let func_name = FuncName(&name_bytes); + for symbol in arguments.iter() { arg_tuples.push(load_symbol(scope, symbol)); } - call_with_args( + roc_call_with_args( env, layout_ids, &full_layout, *name, - parent, + func_name, arg_tuples.into_bump_slice(), ) } @@ -3035,18 +3047,6 @@ pub fn build_procedures_return_main<'a, 'ctx, 'env>( .unwrap() } -// Coming soon -// pub enum AliasAnalysisSolutions { -// NotAvailable, -// Available(morphic_lib::Solutions), -// } -// -// impl std::fmt::Debug for AliasAnalysisSolutions { -// fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { -// write!(f, "AliasAnalysisSolutions {{}}") -// } -// } - fn build_procedures_help<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, opt_level: OptLevel, @@ -3056,19 +3056,16 @@ fn build_procedures_help<'a, 'ctx, 'env>( let mut layout_ids = roc_mono::layout::LayoutIds::default(); let mut scope = Scope::default(); - // Coming Soon - // - // if false { - // let it = state.procedures.iter().map(|x| x.1); - // - // match roc_mono::alias_analysis::spec_program(it) { - // Err(e) => panic!("Error in alias analysis: {:?}", e), - // Ok(solutions) => { - // state.alias_analysis_solutions = - // AliasAnalysisSolutions::Available(solutions) - // } - // } - // } + let it = procedures.iter().map(|x| x.1); + + let solutions = match roc_mono::alias_analysis::spec_program(it) { + Err(e) => panic!("Error in alias analysis: {:?}", e), + Ok(solutions) => solutions, + }; + + let mod_solutions = solutions + .mod_solutions(roc_mono::alias_analysis::MOD_APP) + .unwrap(); // Add all the Proc headers to the module. // We have to do this in a separate pass first, @@ -3080,6 +3077,9 @@ fn build_procedures_help<'a, 'ctx, 'env>( for (proc, fn_val) in headers { let mut current_scope = scope.clone(); + let name_bytes = roc_mono::alias_analysis::func_name_bytes(&proc); + let func_name = FuncName(&name_bytes); + // only have top-level thunks for this proc's module in scope // this retain is not needed for correctness, but will cause less confusion when debugging let home = proc.name.module_id(); @@ -3569,12 +3569,12 @@ fn function_value_by_name_help<'a, 'ctx, 'env>( // #[allow(clippy::cognitive_complexity)] #[inline(always)] -fn call_with_args<'a, 'ctx, 'env>( +fn roc_call_with_args<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, layout_ids: &mut LayoutIds<'a>, layout: &Layout<'a>, symbol: Symbol, - _parent: FunctionValue<'ctx>, + _func_name: FuncName<'_>, args: &[BasicValueEnum<'ctx>], ) -> BasicValueEnum<'ctx> { let fn_val = function_value_by_name(env, layout_ids, *layout, symbol); diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index a044571023..6154b6b84b 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -17,6 +17,50 @@ pub const MOD_APP: ModName = ModName(b"UserApp"); pub const STATIC_STR_NAME: ConstName = ConstName(&Symbol::STR_ALIAS_ANALYSIS_STATIC.to_ne_bytes()); +pub fn func_name_bytes(proc: &Proc) -> [u8; 16] { + func_name_bytes_help(proc.name, proc.args.iter().map(|x| x.0), proc.ret_layout) +} + +pub fn func_name_bytes_help<'a, I>( + symbol: Symbol, + argument_layouts: I, + return_layout: Layout<'a>, +) -> [u8; 16] +where + I: Iterator>, +{ + let mut name_bytes = [0u8; 16]; + + use std::collections::hash_map::DefaultHasher; + use std::hash::Hash; + use std::hash::Hasher; + + let layout_hash = { + let mut hasher = DefaultHasher::new(); + + for layout in argument_layouts { + layout.hash(&mut hasher); + } + return_layout.hash(&mut hasher); + + hasher.finish() + }; + + let sbytes = symbol.to_ne_bytes(); + let lbytes = layout_hash.to_ne_bytes(); + + let it = sbytes + .iter() + .chain(lbytes.iter()) + .zip(name_bytes.iter_mut()); + + for (source, target) in it { + *target = *source; + } + + return name_bytes; +} + pub fn spec_program<'a, I>(procs: I) -> Result where I: Iterator>, @@ -40,36 +84,7 @@ where for proc in procs { let spec = proc_spec(proc)?; - let mut name_bytes = [0u8; 16]; - - use std::collections::hash_map::DefaultHasher; - use std::hash::Hash; - use std::hash::Hasher; - - let layout_hash = { - let mut hasher = DefaultHasher::new(); - - for (layout, _) in proc.args.iter() { - layout.hash(&mut hasher); - } - proc.ret_layout.hash(&mut hasher); - - hasher.finish() - }; - - let sbytes = proc.name.to_ne_bytes(); - let lbytes = layout_hash.to_ne_bytes(); - - let it = sbytes - .iter() - .chain(lbytes.iter()) - .zip(name_bytes.iter_mut()); - - for (source, target) in it { - *target = *source; - } - - m.add_func(FuncName(&name_bytes), spec)?; + m.add_func(FuncName(&func_name_bytes(proc)), spec)?; if format!("{:?}", proc.name).contains("mainForHost") { main_function = Some(proc.name); @@ -345,16 +360,17 @@ fn call_spec( ByName { name: symbol, full_layout: _, - ret_layout: _, - arg_layouts: _, + ret_layout, + arg_layouts, specialization_id, } => { let array = specialization_id.to_bytes(); let spec_var = CalleeSpecVar(&array); let arg_value_id = build_tuple_value(builder, env, block, call.arguments)?; - let slice = &symbol.to_ne_bytes(); - let name = FuncName(slice); + let it = arg_layouts.iter().copied(); + let bytes = func_name_bytes_help(*symbol, it, *ret_layout); + let name = FuncName(&bytes); let module = MOD_APP; builder.add_call(block, spec_var, module, name, arg_value_id) } From 2b2b6e3dddc9d3dc1d2dd869740cd1a1ad71b88c Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Fri, 4 Jun 2021 21:27:26 -0400 Subject: [PATCH 113/496] Update some more docs --- compiler/builtins/docs/Bool.roc | 10 +- compiler/builtins/docs/Dict.roc | 4 +- compiler/builtins/docs/List.roc | 21 ++- compiler/builtins/docs/Num.roc | 290 +++++++++++++++++++++----------- compiler/builtins/docs/Set.roc | 4 +- compiler/builtins/docs/Str.roc | 11 +- editor/src/lang/pool.rs | 17 ++ roc-for-elm-programmers.md | 2 + 8 files changed, 255 insertions(+), 104 deletions(-) diff --git a/compiler/builtins/docs/Bool.roc b/compiler/builtins/docs/Bool.roc index 601a3d491f..5a4e4814df 100644 --- a/compiler/builtins/docs/Bool.roc +++ b/compiler/builtins/docs/Bool.roc @@ -67,11 +67,11 @@ xor : Bool, Bool -> Bool ## ## Structural equality works as follows: ## -## 1. #Int and #Float values are equal if their numbers are equal. -## 2. Records are equal if all their fields are equal. -## 3. Global tags are equal if they are the same tag, and also their contents (if any) are equal. -## 4. Private tags are equal if they are the same tag, in the same module, and also their contents (if any) are equal. -## 5. Collections (#String, #List, #Map, #Set, and #Bytes) are equal if they are the same length, and also all their corresponding elements are equal. +## 1. Global tags are equal if they are the same tag, and also their contents (if any) are equal. +## 2. Private tags are equal if they are the same tag, in the same module, and also their contents (if any) are equal. +## 3. Records are equal if all their fields are equal. +## 4. Collections ([Str], [List], [Dict], and [Set]) are equal if they are the same length, and also all their corresponding elements are equal. +## 5. #Num values are equal if their numbers are equal, with one exception: if both arguments to `isEq` are *NaN*, then `isEq` returns `False`. See [Num.isNaN] for more about *NaN*. ## ## Note that `isEq` takes `'val` instead of `val`, which means `isEq` does not ## accept arguments whose types contain functions. diff --git a/compiler/builtins/docs/Dict.roc b/compiler/builtins/docs/Dict.roc index 178e5329ee..4c7fa6c867 100644 --- a/compiler/builtins/docs/Dict.roc +++ b/compiler/builtins/docs/Dict.roc @@ -27,5 +27,7 @@ map : # TODO: removed `'` from signature because parser does not support it yet # Original signature: insert : Dict 'key val, 'key, val -> Dict 'key val -## Since NaN is defined to be unequal to NaN, panics if given NaN for a key. +## Make sure never to insert a key of *NaN* into a [Dict]! Becuase *NaN* is +## defined to be unequal to *NaN*, inserting a *NaN* key results in an entry +## that can never be retrieved or removed from the [Dict]. insert : Dict key val, key, val -> Dict key val diff --git a/compiler/builtins/docs/List.roc b/compiler/builtins/docs/List.roc index 0398f2ab8e..12b1ba7b3c 100644 --- a/compiler/builtins/docs/List.roc +++ b/compiler/builtins/docs/List.roc @@ -232,9 +232,28 @@ reverse : List elem -> List elem ## Sorts a list using a function which specifies how two elements are ordered. ## -## +## When sorting by numeric values, it's more efficient to use [sortAsc] or +## [sortDesc] instead. sort : List elem, (elem, elem -> [ Lt, Eq, Gt ]) -> List elem +## Sorts a list in ascending order (lowest to highest), using a function which +## specifies a way to represent each element as a number. +## +## This is more efficient than [sort] because it skips +## calculating the `[ Lt, Eq, Gt ]` value and uses the number directly instead. +## +## To sort in descending order (highest to lowest), use [List.sortDesc] instead. +sortAsc : List elem, (elem -> Num *) -> List elem + +## Sorts a list in descending order (highest to lowest), using a function which +## specifies a way to represent each element as a number. +## +## This is more efficient than [sort] because it skips +## calculating the `[ Lt, Eq, Gt ]` value and uses the number directly instead. +## +## To sort in ascending order (lowest to highest), use [List.sortAsc] instead. +sortDesc : List elem, (elem -> Num *) -> List elem + ## Convert each element in the list to something new, by calling a conversion ## function on each of them. Then return a new list of the converted values. ## diff --git a/compiler/builtins/docs/Num.roc b/compiler/builtins/docs/Num.roc index ae5842c339..fee411fb71 100644 --- a/compiler/builtins/docs/Num.roc +++ b/compiler/builtins/docs/Num.roc @@ -122,6 +122,30 @@ Dec : Frac [ @Decimal128 ] ## been done in a base-2 floating point calculation, which causes noticeable ## precision loss in this case. ## +## The floating-point numbers ([F32] and [F64]) also have three values which +## are not ordinary [finite numbers](https://en.wikipedia.org/wiki/Finite_number). +## They are: +## * ∞ ([infinity](https://en.wikipedia.org/wiki/Infinity)) +## * -∞ (negative infinity) +## * *NaN* ([not a number](https://en.wikipedia.org/wiki/NaN)) +## +## These values are different from ordinary numbers in that they only occur +## when a floating-point calculation encounters an error. For example: +## * Dividing a positive [F64] by `0.0` returns ∞. +## * Dividing a negative [F64] by `0.0` returns -∞. +## * Dividing a [F64] of `0.0` by `0.0` returns [*NaN*](Num.isNaN). +## +## These rules come from the [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754) +## floating point standard. Because almost all modern processors are built to +## this standard, deviating from these rules has a significant performance +## cost! Since the most common reason to choose [F64] or [F32] over [Dec] is +## access to hardware-accelerated performance, Roc follows these rules exactly. +## +## There's no literal syntax for these error values, but you can check to see if +## you ended up with one of them by using [isNaN], [isFinite], and [isInfinite]. +## Whenever a function in this module could return one of these values, that +## possibility is noted in the function's documentation. +## ## ## Performance Notes ## ## On typical modern CPUs, performance is similar between [Dec], [F64], and [F32] @@ -140,7 +164,7 @@ Dec : Frac [ @Decimal128 ] ## an even bigger performance difference. [F32] and [F64] can do these in a ## single instruction, whereas [Dec] needs entire custom procedures - which use ## loops and conditionals. If you need to do performance-critical trigonometry -## or square roots, either [F32] or [F64] is probably a better choice than the +## or square roots, either [F64] or [F32] is probably a better choice than the ## usual default choice of [Dec], despite the precision problems they bring. Frac a : Num [ @Fraction a ] @@ -524,15 +548,13 @@ isOdd : Num * -> Bool ## If the answer to this operation can't fit in the return value (e.g. an ## [I8] answer that's higher than 127 or lower than -128), the result is an ## *overflow*. For [F64] and [F32], overflow results in an answer of either -## [*Infinity*](#isPositiveInfinity) or [*-Infinity*](#isNegativeInfinity). For -## all other number types, overflow results in a panic. +## ∞ or -∞. For all other number types, overflow results in a panic. add : Num a, Num a -> Num a ## Add two numbers and check for overflow. ## ## This is the same as [Num.add] except if the operation overflows, instead of -## panicking or returning [*Infinity*](#isPositiveInfinity) or [*-Infinity*](#isNegativeInfinity), -## it will return `Err Overflow`. +## panicking or returning ∞ or -∞, it will return `Err Overflow`. addCheckOverflow : Num a, Num a -> Result (Num a) [ Overflow ]* ## Subtract two numbers of the same type. @@ -553,15 +575,13 @@ addCheckOverflow : Num a, Num a -> Result (Num a) [ Overflow ]* ## If the answer to this operation can't fit in the return value (e.g. an ## [I8] answer that's higher than 127 or lower than -128), the result is an ## *overflow*. For [F64] and [F32], overflow results in an answer of either -## [*Infinity*](#isPositiveInfinity) or [*-Infinity*](#isNegativeInfinity). For -## all other number types, overflow results in a panic. +## ∞ or -∞. For all other number types, overflow results in a panic. sub : Num a, Num a -> Num a ## Subtract two numbers and check for overflow. ## ## This is the same as [Num.sub] except if the operation overflows, instead of -## panicking or returning [*Infinity*](#isPositiveInfinity) or [*-Infinity*](#isNegativeInfinity), -## it will return `Err Overflow`. +## panicking or returning ∞ or -∞, it will return `Err Overflow`. subCheckOverflow : Num a, Num a -> Result (Num a) [ Overflow ]* ## Multiply two numbers of the same type. @@ -582,15 +602,13 @@ subCheckOverflow : Num a, Num a -> Result (Num a) [ Overflow ]* ## If the answer to this operation can't fit in the return value (e.g. an ## [I8] answer that's higher than 127 or lower than -128), the result is an ## *overflow*. For [F64] and [F32], overflow results in an answer of either -## [*Infinity*](#isPositiveInfinity) or [*-Infinity*](#isNegativeInfinity). For -## all other number types, overflow results in a panic. +## ∞ or -∞. For all other number types, overflow results in a panic. mul : Num a, Num a -> Num a ## Multiply two numbers and check for overflow. ## ## This is the same as [Num.mul] except if the operation overflows, instead of -## panicking or returning [*Infinity*](#isPositiveInfinity) or [*-Infinity*](#isNegativeInfinity), -## it will return `Err Overflow`. +## panicking or returning ∞ or -∞, it will return `Err Overflow`. mulCheckOverflow : Num a, Num a -> Result (Num a) [ Overflow ]* ## Convert @@ -608,7 +626,10 @@ mulCheckOverflow : Num a, Num a -> Result (Num a) [ Overflow ]* ## ## >>> Num.toStr 4.0 ## -## For other bases see #toHexStr, #toOctalStr, and #toBinaryStr. +## When this function is given a non-[finite](Num.isFinite) +## [F64] or [F32] value, the returned string will be `"NaN"`, `"∞"`, or `"-∞"`. +## +## To get strings in hexadecimal, octal, or binary format, use [Num.format]. toStr : Num * -> Str ## Convert a number into a [Str], formatted with the given options. @@ -780,18 +801,6 @@ and : Int a, Int a -> Int a not : Int a -> Int a -## Sort ascending - that is, with the lowest first, and the highest last. -## -## List.sort Num.asc [ 3, 6, 0 ] -## -asc : Num a, Num a -> [ Eq, Lt, Gt ] - -## Sort descending - that is, with the highest first, and the lowest last. -## -## List.sort Num.desc [ 3, 6, 0 ] -## -desc : Num a, Num a -> [ Eq, Lt, Gt ] - ## Limits ## The highest number that can be stored in a #Nat without overflowing its @@ -849,39 +858,35 @@ maxU32 : U32 ## and zero is the lowest unsigned number. Unsigned numbers cannot be negative. minU32 : U32 -## The highest supported #Frac value you can have, which is approximately 1.8 × 10^308. +## The highest supported #F64 value you can have, which is approximately 1.8 × 10^308. ## ## If you go higher than this, your running Roc code will crash - so be careful not to! -maxF64 : Frac * +maxF64 : F64 -## The lowest supported #Frac value you can have, which is approximately -1.8 × 10^308. +## The lowest supported #F64 value you can have, which is approximately -1.8 × 10^308. ## ## If you go lower than this, your running Roc code will crash - so be careful not to! -minF64 : Frac * +minF64 : F64 -## The highest integer that can be represented as a #Frac without # losing precision. -## It is equal to 2^53, which is approximately 9 × 10^15. +## The highest supported #F32 value you can have, which is approximately 1.8 × 10^308. ## -## Some integers higher than this can be represented, but they may lose precision. For example: -## -## >>> Frac.highestInt -## -## >>> Frac.highestInt + 100 # Increasing may lose precision -## -## >>> Frac.highestInt - 100 # Decreasing is fine - but watch out for lowestLosslessInt! -maxPreciseInt : Frac * +## If you go higher than this, your running Roc code will crash - so be careful not to! +maxF32 : F32 -## The lowest integer that can be represented as a #Frac without losing precision. -## It is equal to -2^53, which is approximately -9 × 10^15. +## The lowest supported #F32 value you can have, which is approximately -1.8 × 10^308. ## -## Some integers lower than this can be represented, but they may lose precision. For example: +## If you go lower than this, your running Roc code will crash - so be careful not to! +minF32 : F32 + +## The highest supported #F64 value you can have, which is approximately 1.8 × 10^308. ## -## >>> Frac.lowestIntVal +## If you go higher than this, your running Roc code will crash - so be careful not to! +maxDec : Dec + +## The lowest supported #F64 value you can have, which is approximately -1.8 × 10^308. ## -## >>> Frac.lowestIntVal - 100 # Decreasing may lose precision -## -## >>> Frac.lowestIntVal + 100 # Increasing is fine - but watch out for highestInt! -maxPreciseInt : Frac * +## If you go lower than this, your running Roc code will crash - so be careful not to! +maxDec : Dec ## Constants @@ -916,14 +921,14 @@ atan : Frac a -> Frac a ## Calling [div] on a [Dec] denominator of zero will cause a panic. ## ## Calling [div] on [F32] and [F64] values follows these rules: -## * Dividing a positive [F32] or [F64] by zero returns [Infinity](#isPositiveInfinity). -## * Dividing a negative [F32] or [F64] by zero returns [-Infinity](#isNegativeInfinity). -## * Dividing a zero [F32] or [F64] by zero returns [NaN](#isNaN). +## * Dividing a positive [F64] or [F32] by zero returns ∞. +## * Dividing a negative [F64] or [F32] by zero returns -∞. +## * Dividing a zero [F64] or [F32] by zero returns [*NaN*](Num.isNaN). ## ## > These rules come from the [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754) -## > floating point standard. Since almost all modern processors are built to +## > floating point standard. Because almost all modern processors are built to ## > this standard, deviating from these rules has a significant performance -## > cost. Since the most common reason to choose [F32] or [F64] over [Dec] is +## > cost! Since the most common reason to choose [F64] or [F32] over [Dec] is ## > access to hardware-accelerated performance, Roc follows these rules exactly. ## ## To divide an [Int] and a [Frac], first convert the [Int] to a [Frac] using @@ -952,7 +957,7 @@ div : Frac a, Frac a -> Frac a ## ## Passing [mod] a [Dec] value of zero for its second argument will cause a panic. ## Passing [mod] a [F32] and [F64] value for its second argument will cause it -## to return [NaN](#isNaN). +## to return [*NaN*](Num.isNaN). ## ## >>> 5.0 % 7.0 ## @@ -999,14 +1004,14 @@ expBySquaring : Int a, U8 -> Int a ## function a negative number! Calling [sqrt] on a negative [Dec] will cause a panic. ## ## Calling [sqrt] on [F32] and [F64] values follows these rules: -## * Passing a negative [F32] or [F64] returns [NaN](#isNaN). -## * Passing [NaN](#isNaN) or [-Infinity](isNegativeInfinity) also returns [NaN](#isNaN). -## * Passing [Infinity](isPositiveInfinity) returns [Infinity]. +## * Passing a negative [F64] or [F32] returns [*NaN*](Num.isNaN). +## * Passing [*NaN*](Num.isNaN) or -∞ also returns [*NaN*](Num.isNaN). +## * Passing ∞ returns ∞. ## ## > These rules come from the [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754) -## > floating point standard. Since almost all modern processors are built to +## > floating point standard. Because almost all modern processors are built to ## > this standard, deviating from these rules has a significant performance -## > cost. Since the most common reason to choose [F32] or [F64] over [Dec] is +## > cost! Since the most common reason to choose [F64] or [F32] over [Dec] is ## > access to hardware-accelerated performance, Roc follows these rules exactly. ## ## >>> Frac.sqrt 4.0 @@ -1020,51 +1025,148 @@ expBySquaring : Int a, U8 -> Int a ## >>> Frac.sqrt -4.0dec sqrt : Frac a -> Frac a +## Bit shifts + +## [Logical bit shift](https://en.wikipedia.org/wiki/Bitwise_operation#Logical_shift) left. +## +## `a << b` is shorthand for `Num.shl a b`. +shl : Int a, Int a -> Int a + +## [Arithmetic bit shift](https://en.wikipedia.org/wiki/Bitwise_operation#Arithmetic_shift) left. +## +## This is called `shlWrap` because any bits shifted +## off the beginning of the number will be wrapped around to +## the end. (In contrast, [shl] replaces discarded bits with zeroes.) +shlWrap : Int a, Int a -> Int a + +## [Logical bit shift](https://en.wikipedia.org/wiki/Bitwise_operation#Logical_shift) right. +## +## `a >> b` is shorthand for `Num.shr a b`. +shr : Int a, Int a -> Int a + +## [Arithmetic bit shift](https://en.wikipedia.org/wiki/Bitwise_operation#Arithmetic_shift) right. +## +## This is called `shlWrap` because any bits shifted +## off the end of the number will be wrapped around to +## the beginning. (In contrast, [shr] replaces discarded bits with zeroes.) +shrWrap : Int a, Int a -> Int a + + ## [Endianness](https://en.wikipedia.org/wiki/Endianness) Endi : [ Big, Little ] toBytes : Num *, Endi -> List U8 + +## Comparison + +## Returns `True` if the first number is less than the second. +## +## `a < b` is shorthand for `Num.isLt a b`. +## +## If either argument is [*NaN*](Num.isNaN), returns `False` no matter what. (*NaN* +## is [defined to be unordered](https://en.wikipedia.org/wiki/NaN#Comparison_with_NaN).) +## +## >>> 5 +## >>> |> Num.isLt 6 +isLt : Num a, Num a -> Bool + +## Returns `True` if the first number is less than or equal to the second. +## +## `a <= b` is shorthand for `Num.isLte a b`. +## +## If either argument is [*NaN*](Num.isNaN), returns `False` no matter what. (*NaN* +## is [defined to be unordered](https://en.wikipedia.org/wiki/NaN#Comparison_with_NaN).) +isLte : Num a, Num a -> Bool + +## Returns `True` if the first number is greater than the second. +## +## `a > b` is shorthand for `Num.isGt a b`. +## +## If either argument is [*NaN*](Num.isNaN), returns `False` no matter what. (*NaN* +## is [defined to be unordered](https://en.wikipedia.org/wiki/NaN#Comparison_with_NaN).) +## +## >>> 6 +## >>> |> Num.isGt 5 +isGt : Num a, Num a -> Bool + +## Returns `True` if the first number is greater than or equal to the second. +## +## `a >= b` is shorthand for `Num.isGte a b`. +## +## If either argument is [*NaN*](Num.isNaN), returns `False` no matter what. (*NaN* +## is [defined to be unordered](https://en.wikipedia.org/wiki/NaN#Comparison_with_NaN).) +isGte : Num a, Num a -> Bool + +## Returns the higher of two numbers. +## +## If either argument is [*NaN*](Num.isNaN), returns `False` no matter what. (*NaN* +## is [defined to be unordered](https://en.wikipedia.org/wiki/NaN#Comparison_with_NaN).) +higher : Num a, Num a -> Num a + +## Returns the lower of two numbers. +## +## If either argument is [*NaN*](Num.isNaN), returns `False` no matter what. (*NaN* +## is [defined to be unordered](https://en.wikipedia.org/wiki/NaN#Comparison_with_NaN).) +lower : Num a, Num a -> Num a + +# Branchless implementation that works for all numeric types: +# +# let is_lt = arg1 < arg2; +# let is_eq = arg1 == arg2; +# return (is_lt as i8 - is_eq as i8) + 1; +# +# 1, 1 -> (0 - 1) + 1 == 0 # Eq +# 5, 1 -> (0 - 0) + 1 == 1 # Gt +# 1, 5 -> (1 - 0) + 1 == 2 # Lt + +## Returns `Lt` if the first number is less than the second, `Gt` if +## the first is greater than the second, and `Eq` if they're equal. +## +## Although this can be passed to [List.sort], you'll get better performance +## by using [List.sortAsc] or [List.sortDesc] instead. +compare : Num a, Num a -> [ Lt, Eq, Gt ] + +## Special Floating-Point Values + ## When given a [F64] or [F32] value, returns `False` if that value is -## [*NaN*](https://en.wikipedia.org/wiki/NaN). (Returns `False` if that value is *Infinity* or *-Infinity*.) +## [*NaN*](Num.isNaN), ∞ or -∞, and `True` otherwise. +## +## Always returns `True` when given a [Dec]. +## +## This is the opposite of [isInfinite], except when given [*NaN*](Num.isNaN). Both +## [isFinite] and [isInfinite] return `False` for [*NaN*](Num.isNaN). +isFinite : Frac * -> Bool + +## When given a [F64] or [F32] value, returns `True` if that value is either +## ∞ or -∞, and `False` otherwise. +## +## Always returns `False` when given a [Dec]. +## +## This is the opposite of [isFinite], except when given [*NaN*](Num.isNaN). Both +## [isFinite] and [isInfinite] return `False` for [*NaN*](Num.isNaN). +isInfinite : Frac * -> Bool + +## When given a [F64] or [F32] value, returns `True` if that value is +## *NaN* ([not a number](https://en.wikipedia.org/wiki/NaN)), and `False` otherwise. ## ## Always returns `False` when given a [Dec]. ## ## >>> Num.isNaN 12.3 ## -## >>> Num.isNaN (Num.sqrtOrNaN -2) +## >>> Num.isNaN (Num.sqrt -2) ## -## See also [isFinite]. +## *NaN* is unusual from other numberic values in that: +## * *NaN* is not equal to any other number, even itself. [Bool.isEq] always returns `False` if either argument is *NaN*. +## * *NaN* has no ordering, so [isLt], [isLte], [isGt], and [isGte] always return `False` if either argument is *NaN*. +## +## These rules come from the [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754) +## floating point standard. Because almost all modern processors are built to +## this standard, deviating from these rules has a significant performance +## cost! Since the most common reason to choose [F64] or [F32] over [Dec] is +## access to hardware-accelerated performance, Roc follows these rules exactly. +## +## Note that you should never put a *NaN* into a [Set], or use it as the key in +## a [Dict]. The result is entries that can never be removed from those +## collections! See the documentation for [Set.add] and [Dict.insert] for details. isNaN : Frac * -> Bool - -## When given a [F64] or [F32] value, returns `False` if that value is -## [*NaN*](https://en.wikipedia.org/wiki/NaN), *Infinity*, or *-Infinity*. -## -## Always returns `True` when given a [Dec]. -## -## See also [isInfinite]. -isFinite : Frac * -> Bool - -## When given a [F64] or [F32] value, returns `True` if that value is either -## *Infinity* or *-Infinity*. (Returns `False` if that value is [*NaN*](https://en.wikipedia.org/wiki/NaN).) -## -## Always returns `False` when given a [Dec]. -## -## See also [isFinite], [isPositiveInfinity], and [isNegativeInfinity]. -isInfinite : Frac * -> Bool - -## When given a [F64] or [F32] value, returns `True` if that value is -## *Infinity*. (Returns `False` if that value is *-Infinity* or [*NaN*](https://en.wikipedia.org/wiki/NaN).) -## -## Always returns `False` when given a [Dec]. -## -## See also [isNegativeInfinity], [isInfinite], and [isFinite]. -isPositiveInfinity : Frac * -> Bool - -## When given a [F64] or [F32] value, returns `True` if that value is -## *Infinity*. (Returns `False` if that value is *-Infinity* or [*NaN*](https://en.wikipedia.org/wiki/NaN).) -## -## Always returns `False` when given a [Dec]. -## -## See also [isPositiveInfinity], [isInfinite], and [isFinite]. -isNegativeInfinity : Frac * -> Bool diff --git a/compiler/builtins/docs/Set.roc b/compiler/builtins/docs/Set.roc index 2a6d70cc63..0033ee392e 100644 --- a/compiler/builtins/docs/Set.roc +++ b/compiler/builtins/docs/Set.roc @@ -18,7 +18,9 @@ len : Set * -> Nat # TODO: removed `'` from signature because parser does not support it yet # Original signature: `add : Set 'elem, 'elem -> Set 'elem` -## Since NaN is defined to be unequal to NaN, panics if given NaN. +## Make sure never to add a *NaN* to a [Set]! Becuase *NaN* is defined to be +## unequal to *NaN*, adding a *NaN* results in an entry that can never be +## retrieved or removed from the [Set]. add : Set elem, elem -> Set elem ## Drops the given element from the set. diff --git a/compiler/builtins/docs/Str.roc b/compiler/builtins/docs/Str.roc index fae7e7e5f6..d5374b5662 100644 --- a/compiler/builtins/docs/Str.roc +++ b/compiler/builtins/docs/Str.roc @@ -456,10 +456,17 @@ parseU64 : Str, NumParseConfig -> Result { val : U64, rest : Str } [ Expected [ parseI64 : Str, NumParseConfig -> Result { val : I64, rest : Str } [ Expected [ NumI64 ]* Str ]* parseU128 : Str, NumParseConfig -> Result { val : U128, rest : Str } [ Expected [ NumU128 ]* Str ]* parseI128 : Str, NumParseConfig -> Result { val : I128, rest : Str } [ Expected [ NumI128 ]* Str ]* -parseF64 : Str, NumParseConfig -> Result { val : U128, rest : Str } [ Expected [ NumF64 ]* Str ]* -parseF32 : Str, NumParseConfig -> Result { val : I128, rest : Str } [ Expected [ NumF32 ]* Str ]* parseDec : Str, NumParseConfig -> Result { val : Dec, rest : Str } [ Expected [ NumDec ]* Str ]* +## If the string begins with a [finite](Num.isFinite) [F64] number, return +## that number along with the rest of the string after it. +## +## If the string begins with `"NaN"`, `"∞"`, and `"-∞"` (which do not represent +## [finite](Num.isFinite) numbers), they will be similarly accepted and +## translated into their respective [F64] values. +parseF64 : Str, NumParseConfig -> Result { val : F64, rest : Str } [ Expected [ NumF64 ]* Str ]* +parseF32 : Str, NumParseConfig -> Result { val : F32, rest : Str } [ Expected [ NumF32 ]* Str ]* + ## Notes: ## * You can allow a decimal mark for integers; they'll only parse if the numbers after it are all 0. ## * For `wholeSep`, `Required` has a payload for how many digits (e.g. "required every 3 digits") diff --git a/editor/src/lang/pool.rs b/editor/src/lang/pool.rs index 435f49fdf5..975d2b2655 100644 --- a/editor/src/lang/pool.rs +++ b/editor/src/lang/pool.rs @@ -42,6 +42,23 @@ pub const NODE_BYTES: usize = 32; // usize pointers, which would be too big for us to have 16B nodes. // On the plus side, we could be okay with higher memory usage early on, // and then later use the Mesh strategy to reduce long-running memory usage. +// +// With this system, we can allocate up to 4B nodes. If we wanted to keep +// a generational index in there, like https://crates.io/crates/sharded-slab +// does, we could use some of the 32 bits for that. For example, if we wanted +// to have a 5-bit generational index (supporting up to 32 generations), then +// we would have 27 bits remaining, meaning we could only support at most +// 134M nodes. Since the editor has a separate Pool for each module, is that +// enough for any single module we'll encounter in practice? Probably, and +// especially if we allocate super large collection literals on the heap instead +// of in the pool. +// +// Another possible design is to try to catch reuse bugs using an "ASan" like +// approach: in development builds, whenever we "free" a particular slot, we +// can add it to a dev-build-only "freed nodes" list and don't hand it back +// out (so, we leak the memory.) Then we can (again, in development builds only) +// check to see if we're about to store something in zeroed-out memory; if so, check +// to see if it was #[derive(Debug, Eq)] pub struct NodeId { diff --git a/roc-for-elm-programmers.md b/roc-for-elm-programmers.md index bad83663cd..575eb461e3 100644 --- a/roc-for-elm-programmers.md +++ b/roc-for-elm-programmers.md @@ -1427,6 +1427,8 @@ Here are various Roc expressions involving operators, and what they desugar to. | `a ^ b` | `Num.pow a b` | | `a % b` | `Num.rem a b` | | `a %% b` | `Num.mod a b` | +| `a >> b` | `Num.shr a b` | +| `a << b` | `Num.shl a b` | | `-a` | `Num.neg a` | | `-f x y` | `Num.neg (f x y)` | | `a == b` | `Bool.isEq a b` | From 49a85bd9464df852695c37e3633aca08a34eb819 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Fri, 4 Jun 2021 21:27:38 -0400 Subject: [PATCH 114/496] Drop obsolete docs --- compiler/builtins/docs/Num.roc | 142 --------------------------------- 1 file changed, 142 deletions(-) diff --git a/compiler/builtins/docs/Num.roc b/compiler/builtins/docs/Num.roc index fee411fb71..e57bb469f3 100644 --- a/compiler/builtins/docs/Num.roc +++ b/compiler/builtins/docs/Num.roc @@ -319,148 +319,6 @@ Nat : Int [ @Natural ] ## If you need to do math outside these bounds, consider using a larger numeric size. Int size : Num [ @Int size ] -## A 64-bit floating-point number. All number literals with decimal points are #Frac values. -## -## >>> 0.1 -## -## >>> 1.0 -## -## >>> 0.0 -## -## If you like, you can put underscores in your #Frac literals. -## They have no effect on the number's value, but can make things easier to read. -## -## >>> 1_000_000.000_000_001 -## -## Roc supports two types of floating-point numbers: -## -## - *Decimal* floating-point numbers -## - *Binary* floating-point numbers -## -## Decimal floats are precise for decimal calculations. For example: -## -## >>> 0.1 + 0.2 -## -## Operations on binary floats tend to run *much* faster than operations on -## decimal floats, because almost all processors have dedicated instructions -## for binary floats and not for decimal floats. -## However, binary floats are less precise for decimal calculations. -## -## For example, here is the same `0.1 + 0.2` calculation again, this time putting -## `f64` after the numbers to specify that they should be #F64 binary floats -## instead of the default of decimal floats. -## -## >>> 0.1f64 + 0.2f64 -## -## If decimal precision is unimportant, binary floats give better performance. -## If decimal precision is important - for example, when representing money - -## decimal floats tend to be worth the performance cost. -## -## Usually, Roc's compiler can infer a more specific type than #Frac for -## a particular float value, based on how it is used with other numbers. For example: -## -## >>> coordinates : { x : F32, y : F32 } -## >>> coordinates = { x: 1, y: 2.5 } -## >>> -## >>> coordinates.x + 1 -## -## On the last line, the compiler infers that the `1` in `+ 1` is an #F32 -## beacuse it's being added to `coordinates.x`, which was defined to be an #F32 -## on the first line. -## -## Sometimes the compiler has no information about which specific type to pick. -## For example: -## -## >>> 0.1 + 0.2 == 0.3 -## -## When this happens, the compiler defaults to choosing #D64 decimal floats. -## If you want something else, you can write (for example) `0.1f32 + 0.2 == 0.3` -## to compare them as #F32 values instead. -## -## Both decimal and binary #Frac values conform to the [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754#Interchange_formats) -## specification for floating point numbers. Conforming to this specification -## means Roc's binary floats have nearly universal hardware support, and its -## decimal floats have [some hardware support](http://speleotrove.com/decimal/) -## among the rare processors which support decimal float instructions at all. -## -## This specification covers several float formats. Here are the ones Roc supports: -## -## - #F32 (32-bit binary float) -## - #F64 (64-bit binary float) -## - #D32 (32-bit decimal float) -## - #D64 (64-bit decimal float) # TODO show a table like we do with ints, with the min/max ranges -## -## Like #Int, it's possible for #Frac operations to overflow. Like with ints, -## you'll typically get a crash when this happens. -## -## * In a development build, you'll get an assertion failure. -## * In an optimized build, you'll get [`Infinity` or `-Infinity`](https://en.wikipedia.org/wiki/IEEE_754-1985#Positive_and_negative_infinity). -## -## Although some languages treat have first-class representations for -## `-Infinity`, `Infinity`, and the special `NaN` ("not a number") -## floating-point values described in the IEEE-754, Roc does not. -## Instead, Roc treats all of these as errors. If any Frac operation -## in a development build encounters one of these values, it will -## result in an assertion failure. -## -## Stll, it's possible that these values may accidentally arise in -## release builds. If this happens, they will behave according to the usual -## IEEE-754 rules: any operation involving `NaN` will output `NaN`, -## any operation involving `Infinity` or `-Infinity` will output either -## `Infinity`, `-Infinity`, or `NaN`, and `NaN` is defined to be not -## equal to itself - meaning `(x == x)` returns `False` if `x` is `NaN`. -## -## These are very error-prone values, so if you see an assertion fail in -## developent because of one of them, take it seriously - and try to fix -## the code so that it can't come up in a release! -## -## ## Loud versus Quiet errors -## -## Besides precision problems, another reason floats are error-prone -## is that they have quiet error handling built in. For example, in -## a 64-bit floating point number, there are certain patterns of those -## 64 bits which do not represent valid floats; instead, they represent -## invalid results of previous operations. -## -## Whenever any arithmetic operation is performed on an invalid float, -## the result is also invalid. This is called *error propagation*, and -## it is notoriously error-prone. In Roc, using equality operations like -## `==` and `!=` on an invalid float causes a crash. (See #Frac.verify -## to check the validity of your float.) -## -## Beause invalid floats are so error-prone, Roc discourages using them. -## Instead, by default it treats them the same way as overflow: by -## crashing whenever any #Frac function would otherwise return one. -## You can also use functions like #Frac.tryAdd to get an `Ok` or an error -## back so you can gracefully recover from invalid values. -## -## Quiet errors can be useful sometimes. For example, you might want to -## do three floating point calculations in a row, and then gracefully handle -## the situation where any one of the three was invalid. In that situation, -## quiet errors can be more efficient than using three `try` functions, because -## it can have one condition at the end instead of three along the way. -## -## Another potential use for quiet errors is for risky performance optimizations. -## When you are absolutely certain there is no chance of overflow or other -## errors, using a *quiet* operation may save an entry in the instruction cache -## by removing a branch that would always have been predicted correctly. -## Always [measure the performance change](https://youtu.be/r-TLSBdHe1A) -## if you do this! The compiler can optimize away those branches behind the scenes, -## so you may find that using the quiet version expliitly -## makes the code riskier to future change, without actually affecting performance. -## -## ## Performance Notes -## -## Currently, loud errors are implemented using an extra conditional. Although -## this conditional will always be correctly branh-predicted unless an error -## occurs, there is a small effect on the instruction cache, which means -## quiet errors are very slightly more efficient. -## -## Long-term, it's possible that the Roc compiler may be able to implement -## loud errors using *signalling errors* in some situations, which could -## eliminate the performance difference between loud and quiet errors in -## the situation where no error occurs. - ## Convert ## Return a negative number when given a positive one, and vice versa. From c8ad4a2ca29ec2f261f7c4b5c9ad72886d763b0c Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Fri, 4 Jun 2021 21:27:42 -0400 Subject: [PATCH 115/496] Fix missing cast --- docs/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/src/lib.rs b/docs/src/lib.rs index 9bd0d2fa93..bfa9f7ffa1 100644 --- a/docs/src/lib.rs +++ b/docs/src/lib.rs @@ -305,7 +305,7 @@ pub fn files_to_documentations( &std_lib, src_dir.as_path(), MutMap::default(), - std::mem::size_of::(), // This is just type-checking for docs, so "target" doesn't matter + std::mem::size_of::() as u32, // This is just type-checking for docs, so "target" doesn't matter builtin_defs_map, ) { Ok(loaded) => files_docs.push((loaded.documentation, loaded.interns)), From c7272766fc017bc57188f5b9a3d6d7ce87326d98 Mon Sep 17 00:00:00 2001 From: Jared Ramirez Date: Fri, 4 Jun 2021 19:33:38 -0700 Subject: [PATCH 116/496] Add RocDec.toString --- compiler/builtins/bitcode/src/dec.zig | 126 ++++++++++++++++++++++++++ 1 file changed, 126 insertions(+) diff --git a/compiler/builtins/bitcode/src/dec.zig b/compiler/builtins/bitcode/src/dec.zig index 1d51d4cc83..5a03642ea4 100644 --- a/compiler/builtins/bitcode/src/dec.zig +++ b/compiler/builtins/bitcode/src/dec.zig @@ -8,6 +8,7 @@ pub const RocDec = struct { num: i128, pub const decimal_places: comptime u32 = 18; + const max_digits: comptime u32 = 39; pub const min: comptime RocDec = .{ .num = math.minInt(i128) }; pub const max: comptime RocDec = .{ .num = math.maxInt(i128) }; @@ -108,6 +109,60 @@ pub const RocDec = struct { }; } + pub fn toString(self: RocDec) ?RocStr { + var num_bytes: [max_digits]u8 = undefined; + var num_digits = std.fmt.formatIntBuf(num_bytes[0..], self.num, 10, false, .{}); + + var before_num_digits = num_digits - decimal_places; + + var index = decimal_places - 1; + var trim_index: ?usize = null; + var is_consecutive_zero = true; + while (index != 0) { + var digit = num_bytes[before_num_digits + index]; + if (digit == '0' and is_consecutive_zero) { + trim_index = index; + } else { + is_consecutive_zero = false; + } + index -= 1; + } + var after_num_digits = if (trim_index) |i| i else decimal_places; + + const should_add_prefix_zero = before_num_digits == 0 or (before_num_digits == 1 and num_bytes[0] == '-'); + const prefix_zero_len: usize = if (should_add_prefix_zero) 1 else 0; + const dot_len: usize = 1; + var str_len = prefix_zero_len + before_num_digits + dot_len + after_num_digits; + + // [max_digits + 2] here to account for '.' and '-' + var str_bytes: [max_digits + 2]u8 = undefined; + + var str_bytes_index: usize = 0; + var bytes_index: usize = 0; + if (should_add_prefix_zero) { + if (num_bytes[bytes_index] == '-') { + str_bytes[str_bytes_index] = '-'; + str_bytes_index += 1; + bytes_index += 1; + } + str_bytes[str_bytes_index] = '0'; + str_bytes_index += 1; + } + + while (bytes_index < str_len) { + if (bytes_index == before_num_digits) { + str_bytes[str_bytes_index] = '.'; + str_bytes_index += 1; + } + + str_bytes[str_bytes_index] = num_bytes[bytes_index]; + str_bytes_index += 1; + bytes_index += 1; + } + + return RocStr.init(&str_bytes, str_len); + } + pub fn negate(self: RocDec) ?RocDec { var negated = math.negate(self.num) catch null; return if (negated) |n| .{ .num = n } else null; @@ -319,6 +374,7 @@ fn mul_u128(a: u128, b: u128) U256 { const testing = std.testing; const expectEqual = testing.expectEqual; +const expect = testing.expect; test "fromU64" { var dec = RocDec.fromU64(25); @@ -431,6 +487,76 @@ test "fromString: .123.1" { expectEqual(dec, null); } +test "toString: 123.45" { + var roc_str = RocStr.init("123.45", 6); + var dec = RocDec.fromString(roc_str); + var res_roc_str = dec.?.toString(); + + expect(RocStr.eq(roc_str, res_roc_str.?)); +} + +test "toString: -123.45" { + var roc_str = RocStr.init("-123.45", 7); + var dec = RocDec.fromString(roc_str); + var res_roc_str = dec.?.toString(); + + expect(RocStr.eq(roc_str, res_roc_str.?)); +} + +test "toString: 123.0" { + var roc_str = RocStr.init("123.0", 5); + var dec = RocDec.fromString(roc_str); + var res_roc_str = dec.?.toString(); + + expect(RocStr.eq(roc_str, res_roc_str.?)); +} + +test "toString: -123.0" { + var roc_str = RocStr.init("-123.0", 6); + var dec = RocDec.fromString(roc_str); + var res_roc_str = dec.?.toString(); + + expect(RocStr.eq(roc_str, res_roc_str.?)); +} + +test "toString: 0.45" { + var roc_str = RocStr.init("0.45", 4); + var dec = RocDec.fromString(roc_str); + var res_roc_str = dec.?.toString(); + + expect(RocStr.eq(roc_str, res_roc_str.?)); +} + +test "toString: -0.45" { + var roc_str = RocStr.init("-0.45", 5); + var dec = RocDec.fromString(roc_str); + var res_roc_str = dec.?.toString(); + + expect(RocStr.eq(roc_str, res_roc_str.?)); +} + +test "toString: -111.123456789" { + var roc_str = RocStr.init("-111.123456789", 14); + var dec = RocDec.fromString(roc_str); + var res_roc_str = dec.?.toString(); + + expect(RocStr.eq(roc_str, res_roc_str.?)); +} + +test "toString: 111.1234567891" { + var roc_str = RocStr.init("111.1234567891", 14); + var dec = RocDec.fromString(roc_str); + var res_roc_str = dec.?.toString(); + expect(RocStr.eq(roc_str, res_roc_str.?)); +} + +test "toString: 123.111111111111 (big str)" { + var roc_str = RocStr.init("123.111111111111", 16); + var dec = RocDec.fromString(roc_str); + var res_roc_str = dec.?.toString(); + expect(RocStr.eq(roc_str, res_roc_str.?)); +} + test "add: 0" { var dec: RocDec = .{ .num = 0 }; From 9210f8f4f846ee73587de17ff33f764ce4e795aa Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 5 Jun 2021 15:33:14 +0200 Subject: [PATCH 117/496] use funcspec --- compiler/gen/src/llvm/build.rs | 315 +++++++++++++++++++++++---------- 1 file changed, 222 insertions(+), 93 deletions(-) diff --git a/compiler/gen/src/llvm/build.rs b/compiler/gen/src/llvm/build.rs index bf17221a4f..2b09202a59 100644 --- a/compiler/gen/src/llvm/build.rs +++ b/compiler/gen/src/llvm/build.rs @@ -43,7 +43,7 @@ use inkwell::values::{ }; use inkwell::OptimizationLevel; use inkwell::{AddressSpace, IntPredicate}; -use morphic_lib::FuncName; +use morphic_lib::{CalleeSpecVar, FuncName, FuncSpec, FuncSpecSolutions, ModSolutions}; use roc_builtins::bitcode; use roc_collections::all::{ImMap, MutMap, MutSet}; use roc_module::ident::TagName; @@ -784,6 +784,7 @@ pub fn build_exp_literal<'a, 'ctx, 'env>( pub fn build_exp_call<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, layout_ids: &mut LayoutIds<'a>, + func_spec_solutions: &FuncSpecSolutions, scope: &mut Scope<'a, 'ctx>, parent: FunctionValue<'ctx>, layout: &Layout<'a>, @@ -798,30 +799,27 @@ pub fn build_exp_call<'a, 'ctx, 'env>( CallType::ByName { name, full_layout, - arg_layouts, - ret_layout, + specialization_id, .. } => { let mut arg_tuples: Vec = Vec::with_capacity_in(arguments.len(), env.arena); - let name_bytes = roc_mono::alias_analysis::func_name_bytes_help( - *name, - arg_layouts.iter().copied(), - *ret_layout, - ); - let func_name = FuncName(&name_bytes); - for symbol in arguments.iter() { arg_tuples.push(load_symbol(scope, symbol)); } + let bytes = specialization_id.to_bytes(); + let callee_var = CalleeSpecVar(&bytes); + let func_spec = func_spec_solutions.callee_spec(callee_var).unwrap(); + + dbg!(name, &func_spec); + roc_call_with_args( env, - layout_ids, &full_layout, *name, - func_name, + func_spec, arg_tuples.into_bump_slice(), ) } @@ -854,6 +852,7 @@ pub fn build_exp_call<'a, 'ctx, 'env>( build_foreign_symbol( env, layout_ids, + func_spec_solutions, scope, parent, foreign_symbol, @@ -868,6 +867,7 @@ pub fn build_exp_call<'a, 'ctx, 'env>( pub fn build_exp_expr<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, layout_ids: &mut LayoutIds<'a>, + func_spec_solutions: &FuncSpecSolutions, scope: &mut Scope<'a, 'ctx>, parent: FunctionValue<'ctx>, layout: &Layout<'a>, @@ -878,7 +878,15 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( match expr { Literal(literal) => build_exp_literal(env, layout, literal), - Call(call) => build_exp_call(env, layout_ids, scope, parent, layout, call), + Call(call) => build_exp_call( + env, + layout_ids, + func_spec_solutions, + scope, + parent, + layout, + call, + ), Struct(sorted_fields) => { let ctx = env.context; @@ -1825,6 +1833,7 @@ fn list_literal<'a, 'ctx, 'env>( fn invoke_roc_function<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, layout_ids: &mut LayoutIds<'a>, + func_spec_solutions: &FuncSpecSolutions, scope: &mut Scope<'a, 'ctx>, parent: FunctionValue<'ctx>, symbol: Symbol, @@ -1876,7 +1885,7 @@ fn invoke_roc_function<'a, 'ctx, 'env>( scope.insert(symbol, (layout, call_result)); - build_exp_stmt(env, layout_ids, scope, parent, pass); + build_exp_stmt(env, layout_ids, func_spec_solutions, scope, parent, pass); scope.remove(&symbol); } @@ -1903,7 +1912,7 @@ fn invoke_roc_function<'a, 'ctx, 'env>( (Layout::Struct(&[]), exception_object), ); - build_exp_stmt(env, layout_ids, scope, parent, fail); + build_exp_stmt(env, layout_ids, func_spec_solutions, scope, parent, fail); } call_result @@ -1938,6 +1947,7 @@ fn decrement_with_size_check<'a, 'ctx, 'env>( pub fn build_exp_stmt<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, layout_ids: &mut LayoutIds<'a>, + func_spec_solutions: &FuncSpecSolutions, scope: &mut Scope<'a, 'ctx>, parent: FunctionValue<'ctx>, stmt: &roc_mono::ir::Stmt<'a>, @@ -1962,7 +1972,15 @@ pub fn build_exp_stmt<'a, 'ctx, 'env>( for (symbol, expr, layout) in queue { debug_assert!(layout != &Layout::RecursivePointer); - let val = build_exp_expr(env, layout_ids, scope, parent, layout, &expr); + let val = build_exp_expr( + env, + layout_ids, + func_spec_solutions, + scope, + parent, + layout, + &expr, + ); // Make a new scope which includes the binding we just encountered. // This should be done *after* compiling the bound expr, since any @@ -1975,7 +1993,7 @@ pub fn build_exp_stmt<'a, 'ctx, 'env>( stack.push(*symbol); } - let result = build_exp_stmt(env, layout_ids, scope, parent, cont); + let result = build_exp_stmt(env, layout_ids, func_spec_solutions, scope, parent, cont); for symbol in stack { scope.remove(&symbol); @@ -2006,7 +2024,7 @@ pub fn build_exp_stmt<'a, 'ctx, 'env>( // when the fail case is just Rethrow, there is no cleanup work to do // so we can just treat this invoke as a normal call let stmt = roc_mono::ir::Stmt::Let(*symbol, Expr::Call(call.clone()), *layout, pass); - build_exp_stmt(env, layout_ids, scope, parent, &stmt) + build_exp_stmt(env, layout_ids, func_spec_solutions, scope, parent, &stmt) } Invoke { @@ -2020,13 +2038,20 @@ pub fn build_exp_stmt<'a, 'ctx, 'env>( CallType::ByName { name, ref full_layout, + specialization_id, .. } => { - let function_value = function_value_by_name(env, layout_ids, *full_layout, name); + let bytes = specialization_id.to_bytes(); + let callee_var = CalleeSpecVar(&bytes); + let func_spec = func_spec_solutions.callee_spec(callee_var).unwrap(); + + let function_value = + function_value_by_func_spec(env, func_spec, name, *full_layout); invoke_roc_function( env, layout_ids, + func_spec_solutions, scope, parent, *symbol, @@ -2046,6 +2071,7 @@ pub fn build_exp_stmt<'a, 'ctx, 'env>( } => build_foreign_symbol( env, layout_ids, + func_spec_solutions, scope, parent, foreign_symbol, @@ -2092,7 +2118,14 @@ pub fn build_exp_stmt<'a, 'ctx, 'env>( ret_type, }; - build_switch_ir(env, layout_ids, scope, parent, switch_args) + build_switch_ir( + env, + layout_ids, + func_spec_solutions, + scope, + parent, + switch_args, + ) } Join { id, @@ -2123,7 +2156,14 @@ pub fn build_exp_stmt<'a, 'ctx, 'env>( scope.join_points.insert(*id, (cont_block, joinpoint_args)); // construct the blocks that may jump to this join point - build_exp_stmt(env, layout_ids, scope, parent, remainder); + build_exp_stmt( + env, + layout_ids, + func_spec_solutions, + scope, + parent, + remainder, + ); let phi_block = builder.get_insert_block().unwrap(); @@ -2136,7 +2176,14 @@ pub fn build_exp_stmt<'a, 'ctx, 'env>( } // put the continuation in - let result = build_exp_stmt(env, layout_ids, scope, parent, continuation); + let result = build_exp_stmt( + env, + layout_ids, + func_spec_solutions, + scope, + parent, + continuation, + ); // remove this join point again scope.join_points.remove(&id); @@ -2180,7 +2227,7 @@ pub fn build_exp_stmt<'a, 'ctx, 'env>( ); } - build_exp_stmt(env, layout_ids, scope, parent, cont) + build_exp_stmt(env, layout_ids, func_spec_solutions, scope, parent, cont) } Dec(symbol) => { let (value, layout) = load_symbol_and_layout(scope, symbol); @@ -2189,7 +2236,7 @@ pub fn build_exp_stmt<'a, 'ctx, 'env>( decrement_refcount_layout(env, parent, layout_ids, value, layout); } - build_exp_stmt(env, layout_ids, scope, parent, cont) + build_exp_stmt(env, layout_ids, func_spec_solutions, scope, parent, cont) } DecRef(symbol) => { let (value, layout) = load_symbol_and_layout(scope, symbol); @@ -2241,7 +2288,7 @@ pub fn build_exp_stmt<'a, 'ctx, 'env>( } } - build_exp_stmt(env, layout_ids, scope, parent, cont) + build_exp_stmt(env, layout_ids, func_spec_solutions, scope, parent, cont) } } } @@ -2431,6 +2478,7 @@ fn const_i128<'a, 'ctx, 'env>(env: &Env<'a, 'ctx, 'env>, value: i128) -> IntValu fn build_switch_ir<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, layout_ids: &mut LayoutIds<'a>, + func_spec_solutions: &FuncSpecSolutions, scope: &Scope<'a, 'ctx>, parent: FunctionValue<'ctx>, switch_args: SwitchArgsIr<'a, 'ctx>, @@ -2553,7 +2601,14 @@ fn build_switch_ir<'a, 'ctx, 'env>( { builder.position_at_end(then_block); - let branch_val = build_exp_stmt(env, layout_ids, scope, parent, true_branch); + let branch_val = build_exp_stmt( + env, + layout_ids, + func_spec_solutions, + scope, + parent, + true_branch, + ); if then_block.get_terminator().is_none() { builder.build_unconditional_branch(cont_block); @@ -2564,7 +2619,14 @@ fn build_switch_ir<'a, 'ctx, 'env>( { builder.position_at_end(else_block); - let branch_val = build_exp_stmt(env, layout_ids, scope, parent, false_branch); + let branch_val = build_exp_stmt( + env, + layout_ids, + func_spec_solutions, + scope, + parent, + false_branch, + ); if else_block.get_terminator().is_none() { builder.build_unconditional_branch(cont_block); @@ -2614,7 +2676,14 @@ fn build_switch_ir<'a, 'ctx, 'env>( for ((_, _, branch_expr), (_, block)) in branches.iter().zip(cases) { builder.position_at_end(block); - let branch_val = build_exp_stmt(env, layout_ids, scope, parent, branch_expr); + let branch_val = build_exp_stmt( + env, + layout_ids, + func_spec_solutions, + scope, + parent, + branch_expr, + ); if block.get_terminator().is_none() { builder.build_unconditional_branch(cont_block); @@ -2625,7 +2694,14 @@ fn build_switch_ir<'a, 'ctx, 'env>( // The block for the conditional's default branch. builder.position_at_end(default_block); - let default_val = build_exp_stmt(env, layout_ids, scope, parent, default_branch); + let default_val = build_exp_stmt( + env, + layout_ids, + func_spec_solutions, + scope, + parent, + default_branch, + ); if default_block.get_terminator().is_none() { builder.build_unconditional_branch(cont_block); @@ -2673,10 +2749,12 @@ pub fn create_entry_block_alloca<'a, 'ctx>( fn expose_function_to_host<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, + symbol: Symbol, roc_function: FunctionValue<'ctx>, ) { - let c_function_name: String = - format!("roc_{}_exposed", roc_function.get_name().to_str().unwrap()); + // Assumption: there is only one specialization of a host-exposed function + let ident_string = symbol.ident_string(&env.interns); + let c_function_name: String = format!("roc__{}_1_exposed", ident_string); expose_function_to_host_help(env, roc_function, &c_function_name); } @@ -2999,23 +3077,42 @@ fn make_exception_catching_wrapper<'a, 'ctx, 'env>( pub fn build_proc_headers<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, - layout_ids: &mut LayoutIds<'a>, + _layout_ids: &mut LayoutIds<'a>, + mod_solutions: &'a ModSolutions, procedures: MutMap<(Symbol, TopLevelFunctionLayout<'a>), roc_mono::ir::Proc<'a>>, scope: &mut Scope<'a, 'ctx>, // alias_analysis_solutions: AliasAnalysisSolutions, -) -> std::vec::Vec<(roc_mono::ir::Proc<'a>, FunctionValue<'ctx>)> { +) -> Vec< + 'a, + ( + roc_mono::ir::Proc<'a>, + &'a [(&'a FuncSpecSolutions, FunctionValue<'ctx>)], + ), +> { // Populate Procs further and get the low-level Expr from the canonical Expr - let mut headers = std::vec::Vec::with_capacity(procedures.len()); + let mut headers = Vec::with_capacity_in(procedures.len(), env.arena); for ((symbol, layout), proc) in procedures { - let fn_val = build_proc_header(env, layout_ids, symbol, layout, &proc); + let name_bytes = roc_mono::alias_analysis::func_name_bytes(&proc); + let func_name = FuncName(&name_bytes); - if proc.args.is_empty() { - // this is a 0-argument thunk, i.e. a top-level constant definition - // it must be in-scope everywhere in the module! - scope.insert_top_level_thunk(symbol, env.arena.alloc(layout), fn_val); + let func_solutions = mod_solutions.func_solutions(func_name).unwrap(); + + let it = func_solutions.specs(); + let mut function_values = Vec::with_capacity_in(it.size_hint().0, env.arena); + for specialization in it { + let fn_val = build_proc_header(env, *specialization, symbol, &proc); + + if proc.args.is_empty() { + // this is a 0-argument thunk, i.e. a top-level constant definition + // it must be in-scope everywhere in the module! + scope.insert_top_level_thunk(symbol, env.arena.alloc(layout), fn_val); + } + + let func_spec_solutions = func_solutions.spec(specialization).unwrap(); + + function_values.push((func_spec_solutions, fn_val)); } - - headers.push((proc, fn_val)); + headers.push((proc, function_values.into_bump_slice())); } headers @@ -3063,6 +3160,8 @@ fn build_procedures_help<'a, 'ctx, 'env>( Ok(solutions) => solutions, }; + let solutions = env.arena.alloc(solutions); + let mod_solutions = solutions .mod_solutions(roc_mono::alias_analysis::MOD_APP) .unwrap(); @@ -3070,45 +3169,51 @@ fn build_procedures_help<'a, 'ctx, 'env>( // Add all the Proc headers to the module. // We have to do this in a separate pass first, // because their bodies may reference each other. - let headers = build_proc_headers(env, &mut layout_ids, procedures, &mut scope); + let headers = build_proc_headers(env, &mut layout_ids, &mod_solutions, procedures, &mut scope); let (_, function_pass) = construct_optimization_passes(env.module, opt_level); - for (proc, fn_val) in headers { - let mut current_scope = scope.clone(); + for (proc, fn_vals) in headers { + for (func_spec_solutions, fn_val) in fn_vals { + let mut current_scope = scope.clone(); - let name_bytes = roc_mono::alias_analysis::func_name_bytes(&proc); - let func_name = FuncName(&name_bytes); + // only have top-level thunks for this proc's module in scope + // this retain is not needed for correctness, but will cause less confusion when debugging + let home = proc.name.module_id(); + current_scope.retain_top_level_thunks_for_module(home); - // only have top-level thunks for this proc's module in scope - // this retain is not needed for correctness, but will cause less confusion when debugging - let home = proc.name.module_id(); - current_scope.retain_top_level_thunks_for_module(home); - - build_proc(&env, &mut layout_ids, scope.clone(), proc, fn_val); - - // call finalize() before any code generation/verification - env.dibuilder.finalize(); - - if fn_val.verify(true) { - function_pass.run_on(&fn_val); - } else { - let mode = "NON-OPTIMIZED"; - - eprintln!( - "\n\nFunction {:?} failed LLVM verification in {} build. Its content was:\n", - fn_val.get_name().to_str().unwrap(), - mode, + build_proc( + &env, + &mut layout_ids, + func_spec_solutions, + scope.clone(), + &proc, + *fn_val, ); - fn_val.print_to_stderr(); - // module.print_to_stderr(); + // call finalize() before any code generation/verification + env.dibuilder.finalize(); - panic!( - "The preceding code was from {:?}, which failed LLVM verification in {} build.", - fn_val.get_name().to_str().unwrap(), - mode, - ); + if fn_val.verify(true) { + function_pass.run_on(&fn_val); + } else { + let mode = "NON-OPTIMIZED"; + + eprintln!( + "\n\nFunction {:?} failed LLVM verification in {} build. Its content was:\n", + fn_val.get_name().to_str().unwrap(), + mode, + ); + + fn_val.print_to_stderr(); + // module.print_to_stderr(); + + panic!( + "The preceding code was from {:?}, which failed LLVM verification in {} build.", + fn_val.get_name().to_str().unwrap(), + mode, + ); + } } } @@ -3117,21 +3222,39 @@ fn build_procedures_help<'a, 'ctx, 'env>( }) } +fn func_spec_name<'a>( + arena: &'a Bump, + interns: &Interns, + symbol: Symbol, + func_spec: FuncSpec, +) -> bumpalo::collections::String<'a> { + use std::fmt::Write; + + let mut buf = bumpalo::collections::String::with_capacity_in(1, arena); + + let ident_string = symbol.ident_string(interns); + let module_string = interns.module_ids.get_name(symbol.module_id()).unwrap(); + write!(buf, "{}_{}_", module_string, ident_string).unwrap(); + + for byte in func_spec.0.iter() { + write!(buf, "{:x?}", byte).unwrap(); + } + + buf +} + fn build_proc_header<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, - layout_ids: &mut LayoutIds<'a>, + func_spec: FuncSpec, symbol: Symbol, - top_level: TopLevelFunctionLayout<'a>, proc: &roc_mono::ir::Proc<'a>, ) -> FunctionValue<'ctx> { - let layout = env.arena.alloc(top_level).full(); - let args = proc.args; let arena = env.arena; - let fn_name = layout_ids - .get(symbol, &layout) - .to_symbol_string(symbol, &env.interns); + dbg!(&symbol, &func_spec); + + let fn_name = func_spec_name(env.arena, &env.interns, symbol, func_spec); let ret_type = basic_type_from_layout(env, &proc.ret_layout); let mut arg_basic_types = Vec::with_capacity_in(args.len(), arena); @@ -3156,7 +3279,7 @@ fn build_proc_header<'a, 'ctx, 'env>( fn_val.set_subprogram(subprogram); if env.exposed_to_host.contains(&symbol) { - expose_function_to_host(env, fn_val); + expose_function_to_host(env, symbol, fn_val); } fn_val @@ -3431,8 +3554,9 @@ fn build_host_exposed_alias_size_help<'a, 'ctx, 'env>( pub fn build_proc<'a, 'ctx, 'env>( env: &'a Env<'a, 'ctx, 'env>, layout_ids: &mut LayoutIds<'a>, + func_spec_solutions: &FuncSpecSolutions, mut scope: Scope<'a, 'ctx>, - proc: roc_mono::ir::Proc<'a>, + proc: &roc_mono::ir::Proc<'a>, fn_val: FunctionValue<'ctx>, ) { use roc_mono::ir::HostExposedLayouts; @@ -3499,7 +3623,14 @@ pub fn build_proc<'a, 'ctx, 'env>( scope.insert(*arg_symbol, (*layout, arg_val)); } - let body = build_exp_stmt(env, layout_ids, &mut scope, fn_val, &proc.body); + let body = build_exp_stmt( + env, + layout_ids, + func_spec_solutions, + &mut scope, + fn_val, + &proc.body, + ); // only add a return if codegen did not already add one if let Some(block) = builder.get_insert_block() { @@ -3519,15 +3650,13 @@ pub fn verify_fn(fn_val: FunctionValue<'_>) { } } -fn function_value_by_name<'a, 'ctx, 'env>( +fn function_value_by_func_spec<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, - layout_ids: &mut LayoutIds<'a>, - layout: Layout<'a>, + func_spec: FuncSpec, symbol: Symbol, + layout: Layout<'a>, ) -> FunctionValue<'ctx> { - let fn_name = layout_ids - .get(symbol, &layout) - .to_symbol_string(symbol, &env.interns); + let fn_name = func_spec_name(env.arena, &env.interns, symbol, func_spec); let fn_name = fn_name.as_str(); function_value_by_name_help(env, layout, symbol, fn_name) @@ -3571,13 +3700,12 @@ fn function_value_by_name_help<'a, 'ctx, 'env>( #[inline(always)] fn roc_call_with_args<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, - layout_ids: &mut LayoutIds<'a>, layout: &Layout<'a>, symbol: Symbol, - _func_name: FuncName<'_>, + func_spec: FuncSpec, args: &[BasicValueEnum<'ctx>], ) -> BasicValueEnum<'ctx> { - let fn_val = function_value_by_name(env, layout_ids, *layout, symbol); + let fn_val = function_value_by_func_spec(env, func_spec, symbol, *layout); let call = env.builder.build_call(fn_val, args, "call"); @@ -4888,6 +5016,7 @@ fn build_foreign_symbol_write_result_into_ptr<'a, 'ctx, 'env>( fn build_foreign_symbol<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, layout_ids: &mut LayoutIds<'a>, + func_spec_solutions: &FuncSpecSolutions, scope: &mut Scope<'a, 'ctx>, parent: FunctionValue<'ctx>, foreign: &roc_module::ident::ForeignSymbol, @@ -4951,7 +5080,7 @@ fn build_foreign_symbol<'a, 'ctx, 'env>( scope.insert(symbol, (*ret_layout, call_result)); - build_exp_stmt(env, layout_ids, scope, parent, pass); + build_exp_stmt(env, layout_ids, func_spec_solutions, scope, parent, pass); scope.remove(&symbol); } @@ -4980,7 +5109,7 @@ fn build_foreign_symbol<'a, 'ctx, 'env>( (Layout::Struct(&[]), exception_object), ); - build_exp_stmt(env, layout_ids, scope, parent, fail); + build_exp_stmt(env, layout_ids, func_spec_solutions, scope, parent, fail); } call_result From 3acd9d13961d48d8d29daf0d1902d2e7a7cff8d1 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Sat, 5 Jun 2021 16:42:06 +0200 Subject: [PATCH 118/496] stackoverflow fix + cargo criterion fix --- .github/workflows/benchmarks.yml | 3 +++ Earthfile | 4 ++-- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index 967db61cc0..41639a5ebb 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -20,5 +20,8 @@ jobs: - name: Earthly version run: earthly --version + - name: prune cache + run: earthly prune --reset + - name: install dependencies, build, cd cli, benchmark with criterion run: ./ci/safe-earthly.sh +bench-roc diff --git a/Earthfile b/Earthfile index ece11b44e4..d3f04bfadd 100644 --- a/Earthfile +++ b/Earthfile @@ -115,7 +115,7 @@ bench-roc: FROM +copy-dirs-and-cache ENV RUST_BACKTRACE=full RUN cargo criterion -V - RUN ulimit -s unlimited # to prevent stack overflow errors for CFold + # ulimit -s unlimited to prevent stack overflow errors for CFold RUN --privileged --mount=type=cache,target=$SCCACHE_DIR \ - cd cli && cargo criterion && sccache --show-stats + ulimit -s unlimited && cd cli && cargo criterion && sccache --show-stats From 526481e847870a80b26d1a4202b51eed03b2fa31 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Sat, 5 Jun 2021 16:49:31 +0200 Subject: [PATCH 119/496] don't clear cache anymore --- .github/workflows/benchmarks.yml | 3 --- 1 file changed, 3 deletions(-) diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index 41639a5ebb..967db61cc0 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -20,8 +20,5 @@ jobs: - name: Earthly version run: earthly --version - - name: prune cache - run: earthly prune --reset - - name: install dependencies, build, cd cli, benchmark with criterion run: ./ci/safe-earthly.sh +bench-roc From df8d4cd270ff363b415050942a513cecef116cea Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Sat, 5 Jun 2021 17:10:42 +0200 Subject: [PATCH 120/496] increased quicksort list size to 10k --- cli/benches/time_bench.rs | 2 +- cli/cli_utils/src/bench_utils.rs | 2 +- cli/tests/cli_run.rs | 27 ++++++++++++--------------- examples/benchmarks/QuicksortApp.roc | 4 ++-- 4 files changed, 16 insertions(+), 19 deletions(-) diff --git a/cli/benches/time_bench.rs b/cli/benches/time_bench.rs index 491db64784..062d615533 100644 --- a/cli/benches/time_bench.rs +++ b/cli/benches/time_bench.rs @@ -17,7 +17,7 @@ fn bench_group_wall_time(c: &mut Criterion) { bench_deriv, // nest deriv 8 f bench_rbtree_ck, // ms = makeMap 5 80000 bench_rbtree_delete, // m = makeMap 100000 - bench_quicksort, // list size 2000 + bench_quicksort, // list size 10000 ]; for bench_func in bench_funcs.iter() { diff --git a/cli/cli_utils/src/bench_utils.rs b/cli/cli_utils/src/bench_utils.rs index 03d1e1f3e8..d74e3f5bad 100644 --- a/cli/cli_utils/src/bench_utils.rs +++ b/cli/cli_utils/src/bench_utils.rs @@ -129,7 +129,7 @@ pub fn bench_quicksort(bench_group_opt: Option<&mut BenchmarkGro &example_file("benchmarks", "QuicksortApp.roc"), "1", // 1 for sorting large list, 0 for a small list "quicksortapp", - "[ 0, 0, 0, 1, 2, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 13, 13, 14, 14, 16, 16, 16, 17, 17, 17, 18, 19, 20, 22, 22, 23, 24, 24, 24, 24, 25, 26, 26, 26, 26, 27, 27, 29, 29, 30, 30, 30, 30, 31, 31, 31, 31, 32, 32, 32, 33, 33, 33, 33, 34, 35, 35, 35, 35, 36, 36, 36, 37, 38, 39, 40, 41, 42, 43, 43, 43, 44, 44, 44, 47, 47, 47, 48, 49, 49, 49, 49, 51, 51, 52, 52, 53, 53, 54, 54, 54, 54, 55, 56, 56, 57, 58, 59, 59, 60, 62, 63, 63, 64, 65, 65, 66, 66, 66, 67, 67, 67, 68, 68, 69, 69, 70, 70, 72, 72, 72, 72, 72, 72, 73, 73, 73, 74, 74, 74, 76, 77, 77, 77, 78, 78, 78, 79, 79, 79, 80, 80, 80, 81, 81, 82, 82, 83, 83, 83, 83, 84, 85, 86, 86, 88, 88, 88, 88, 88, 89, 89, 90, 90, 91, 91, 92, 92, 93, 93, 94, 95, 95, 96, 96, 96, 98, 98, 99, 100, 101, 101, 102, 104, 105, 105, 106, 106, 107, 107, 108, 109, 112, 112, 113, 113, 113, 113, 113, 113, 115, 116, 116, 117, 118, 121, 122, 122, 122, 123, 123, 123, 123, 123, 124, 124, 125, 125, 126, 126, 126, 126, 127, 127, 128, 129, 130, 130, 130, 131, 131, 132, 132, 132, 133, 133, 135, 135, 135, 135, 136, 136, 137, 137, 139, 139, 139, 139, 141, 142, 144, 145, 146, 146, 146, 146, 146, 147, 147, 148, 148, 148, 148, 148, 148, 149, 149, 149, 150, 151, 151, 152, 152, 152, 153, 153, 153, 153, 154, 155, 155, 155, 156, 159, 159, 159, 160, 160, 160, 161, 161, 161, 162, 162, 162, 162, 165, 166, 166, 166, 167, 167, 167, 168, 168, 168, 169, 170, 170, 172, 172, 172, 172, 174, 174, 175, 176, 177, 178, 178, 178, 179, 180, 180, 180, 180, 180, 181, 182, 183, 183, 183, 184, 184, 185, 185, 186, 186, 187, 187, 187, 188, 188, 189, 189, 189, 189, 190, 190, 191, 191, 192, 193, 193, 193, 193, 193, 193, 194, 194, 195, 195, 195, 195, 195, 196, 197, 198, 198, 199, 199, 199, 199, 200, 201, 202, 202, 202, 202, 203, 204, 204, 205, 205, 205, 206, 206, 206, 207, 208, 209, 210, 210, 210, 210, 211, 211, 211, 211, 212, 212, 212, 212, 213, 213, 213, 213, 214, 214, 214, 215, 215, 215, 216, 216, 216, 216, 217, 217, 218, 218, 219, 220, 220, 220, 221, 221, 222, 222, 222, 222, 223, 223, 223, 225, 225, 225, 226, 227, 227, 228, 228, 229, 229, 229, 229, 231, 231, 233, 234, 234, 234, 234, 234, 234, 235, 235, 235, 235, 236, 236, 237, 238, 238, 238, 238, 238, 239, 239, 240, 240, 241, 241, 241, 241, 241, 242, 243, 243, 243, 244, 247, 248, 248, 248, 249, 249, 249, 250, 250, 250, 251, 252, 252, 254, 254, 254, 254, 254, 255, 255, 256, 257, 258, 259, 260, 261, 262, 262, 262, 262, 262, 263, 264, 264, 264, 265, 265, 266, 266, 266, 267, 269, 269, 269, 270, 270, 271, 271, 272, 273, 274, 274, 275, 275, 275, 276, 277, 277, 277, 278, 278, 279, 279, 281, 282, 282, 286, 287, 287, 287, 287, 287, 288, 288, 288, 288, 288, 288, 289, 289, 290, 290, 290, 291, 291, 292, 292, 292, 293, 293, 293, 293, 293, 293, 293, 294, 294, 294, 294, 295, 296, 296, 297, 297, 298, 298, 300, 300, 301, 301, 301, 301, 301, 302, 303, 303, 303, 304, 304, 304, 305, 305, 305, 306, 306, 308, 308, 309, 309, 310, 311, 312, 312, 312, 312, 313, 313, 313, 314, 314, 315, 316, 316, 317, 317, 318, 318, 318, 318, 319, 319, 320, 322, 322, 323, 323, 324, 324, 325, 325, 326, 328, 329, 329, 329, 330, 330, 330, 332, 332, 332, 333, 333, 333, 333, 334, 334, 334, 334, 335, 335, 335, 335, 335, 335, 336, 336, 337, 337, 338, 338, 338, 339, 339, 340, 341, 342, 342, 343, 343, 344, 344, 345, 345, 345, 346, 346, 348, 349, 349, 349, 349, 350, 350, 350, 351, 351, 351, 352, 352, 352, 352, 353, 353, 353, 353, 355, 355, 355, 355, 355, 356, 357, 357, 357, 358, 358, 359, 359, 359, 360, 360, 361, 361, 361, 362, 362, 363, 364, 365, 365, 367, 367, 368, 368, 369, 369, 369, 369, 369, 371, 371, 371, 371, 372, 372, 373, 373, 373, 374, 374, 375, 375, 376, 376, 376, 377, 377, 378, 378, 378, 378, 378, 378, 379, 379, 381, 381, 381, 382, 383, 383, 384, 384, 385, 385, 385, 386, 386, 386, 386, 387, 387, 388, 388, 388, 389, 389, 389, 390, 390, 390, 391, 391, 392, 392, 393, 393, 394, 394, 394, 394, 394, 395, 396, 397, 397, 397, 398, 399, 399, 400, 400, 400, 400, 401, 401, 401, 401, 402, 402, 402, 402, 402, 402, 403, 404, 404, 404, 404, 405, 405, 405, 405, 407, 409, 409, 410, 410, 410, 410, 410, 413, 414, 414, 416, 417, 417, 417, 418, 418, 418, 419, 419, 419, 420, 420, 420, 421, 422, 422, 425, 426, 426, 427, 427, 427, 428, 428, 428, 429, 430, 431, 433, 433, 433, 435, 435, 436, 436, 436, 437, 438, 438, 438, 439, 439, 439, 441, 442, 443, 443, 443, 443, 444, 444, 444, 445, 445, 447, 447, 447, 448, 448, 449, 450, 450, 450, 450, 451, 451, 451, 451, 452, 452, 452, 452, 453, 453, 454, 454, 454, 454, 455, 455, 455, 456, 456, 457, 457, 457, 457, 458, 459, 460, 460, 461, 461, 462, 462, 464, 464, 464, 465, 467, 467, 468, 469, 469, 469, 469, 471, 471, 472, 472, 473, 474, 474, 474, 475, 475, 476, 476, 477, 477, 479, 479, 480, 481, 481, 482, 483, 484, 484, 485, 485, 486, 486, 487, 487, 487, 487, 488, 489, 489, 489, 489, 490, 490, 490, 491, 493, 493, 493, 494, 494, 495, 495, 495, 495, 497, 497, 499, 499, 500, 500, 501, 501, 502, 502, 502, 503, 505, 505, 506, 506, 507, 508, 508, 508, 508, 510, 510, 511, 511, 512, 512, 513, 514, 514, 515, 516, 516, 516, 516, 517, 517, 517, 518, 518, 519, 521, 522, 522, 523, 523, 523, 523, 523, 525, 526, 526, 526, 527, 527, 528, 529, 530, 530, 531, 531, 532, 532, 532, 532, 533, 533, 533, 533, 533, 534, 534, 535, 535, 537, 539, 539, 540, 541, 542, 542, 543, 544, 547, 547, 547, 547, 547, 547, 548, 549, 550, 551, 551, 551, 552, 552, 555, 557, 558, 558, 558, 558, 559, 559, 560, 560, 561, 561, 562, 563, 563, 563, 563, 563, 564, 566, 566, 566, 567, 567, 567, 568, 568, 568, 569, 569, 571, 572, 573, 573, 574, 574, 575, 577, 578, 578, 580, 581, 582, 582, 582, 582, 583, 583, 585, 587, 587, 587, 588, 588, 589, 589, 590, 590, 590, 590, 591, 591, 591, 592, 593, 593, 595, 596, 597, 597, 598, 598, 599, 599, 600, 600, 600, 602, 602, 602, 603, 604, 605, 605, 606, 606, 606, 608, 608, 608, 608, 609, 610, 610, 610, 610, 611, 611, 612, 612, 613, 613, 614, 614, 614, 616, 616, 616, 617, 617, 617, 618, 618, 618, 618, 618, 618, 618, 619, 619, 619, 619, 619, 619, 619, 620, 620, 621, 621, 621, 624, 624, 624, 624, 625, 625, 625, 625, 626, 628, 628, 628, 630, 630, 630, 631, 631, 631, 632, 632, 632, 633, 635, 635, 635, 636, 637, 637, 638, 638, 638, 639, 639, 639, 640, 642, 643, 644, 645, 646, 646, 650, 650, 651, 651, 651, 653, 654, 654, 654, 655, 655, 656, 656, 657, 658, 659, 659, 661, 661, 661, 662, 662, 663, 663, 663, 663, 664, 665, 665, 665, 665, 666, 666, 667, 668, 668, 669, 669, 669, 670, 670, 672, 672, 672, 672, 672, 673, 674, 674, 675, 675, 676, 676, 676, 677, 677, 677, 678, 678, 679, 679, 679, 679, 679, 680, 680, 682, 683, 683, 684, 684, 685, 685, 685, 686, 687, 687, 687, 687, 687, 687, 688, 689, 689, 689, 691, 691, 692, 692, 693, 693, 696, 697, 697, 698, 698, 698, 698, 698, 699, 699, 700, 700, 700, 700, 703, 704, 704, 704, 704, 704, 705, 705, 705, 706, 706, 707, 707, 707, 708, 708, 708, 710, 711, 711, 711, 711, 712, 712, 713, 713, 713, 713, 713, 713, 713, 714, 714, 714, 715, 716, 717, 717, 717, 718, 718, 718, 719, 719, 719, 719, 719, 719, 720, 720, 720, 721, 721, 723, 723, 723, 724, 724, 725, 726, 727, 727, 727, 727, 728, 729, 729, 730, 730, 730, 730, 731, 732, 733, 734, 734, 734, 735, 735, 736, 736, 736, 736, 737, 737, 738, 739, 739, 739, 740, 743, 743, 743, 743, 743, 744, 744, 745, 745, 746, 746, 746, 747, 747, 748, 749, 750, 750, 751, 751, 751, 752, 752, 753, 753, 753, 753, 753, 753, 754, 754, 756, 757, 757, 758, 758, 758, 759, 759, 760, 760, 760, 761, 762, 762, 762, 763, 763, 766, 768, 768, 768, 768, 768, 769, 769, 772, 773, 773, 774, 775, 775, 776, 776, 776, 776, 776, 777, 777, 777, 778, 779, 779, 779, 780, 780, 780, 781, 782, 782, 782, 783, 783, 783, 783, 784, 785, 785, 785, 785, 786, 786, 786, 786, 786, 787, 788, 789, 789, 789, 790, 790, 791, 791, 791, 792, 792, 792, 792, 793, 793, 794, 794, 797, 797, 798, 798, 799, 799, 799, 800, 801, 801, 802, 803, 804, 804, 805, 805, 805, 805, 807, 807, 807, 807, 808, 808, 808, 808, 809, 809, 810, 810, 811, 811, 812, 813, 814, 815, 816, 816, 817, 818, 819, 819, 820, 820, 820, 822, 822, 823, 823, 823, 823, 826, 826, 827, 827, 829, 830, 830, 831, 831, 832, 832, 832, 833, 833, 833, 834, 834, 835, 835, 835, 836, 836, 837, 837, 838, 838, 839, 840, 840, 841, 841, 842, 842, 843, 844, 844, 845, 846, 846, 847, 847, 848, 849, 849, 851, 851, 851, 851, 852, 853, 853, 853, 854, 854, 854, 855, 856, 856, 857, 857, 858, 859, 859, 859, 860, 860, 860, 860, 860, 861, 861, 861, 861, 862, 862, 864, 865, 865, 865, 866, 866, 866, 866, 867, 868, 868, 868, 869, 869, 870, 871, 872, 872, 872, 872, 872, 873, 873, 873, 874, 874, 875, 875, 876, 877, 878, 879, 879, 880, 880, 880, 880, 882, 883, 884, 885, 885, 885, 886, 886, 886, 888, 889, 889, 891, 891, 891, 892, 892, 894, 894, 894, 894, 894, 894, 895, 896, 898, 898, 899, 899, 899, 900, 900, 901, 902, 902, 903, 905, 905, 905, 906, 906, 906, 907, 907, 907, 907, 907, 907, 907, 908, 908, 908, 908, 909, 909, 909, 910, 910, 911, 913, 913, 913, 913, 914, 914, 914, 915, 916, 917, 917, 917, 918, 918, 918, 919, 920, 920, 920, 920, 920, 920, 921, 921, 921, 922, 923, 924, 924, 924, 925, 925, 926, 926, 927, 928, 928, 928, 928, 929, 929, 930, 930, 931, 932, 932, 933, 934, 934, 934, 935, 935, 935, 936, 936, 937, 938, 938, 938, 939, 939, 939, 940, 940, 941, 941, 942, 942, 942, 943, 943, 943, 943, 943, 943, 944, 945, 946, 946, 946, 947, 947, 948, 948, 950, 950, 951, 951, 952, 952, 952, 953, 955, 955, 955, 956, 956, 957, 957, 958, 959, 959, 959, 959, 960, 961, 962, 963, 964, 964, 964, 965, 965, 965, 966, 966, 966, 967, 967, 967, 968, 968, 968, 969, 969, 970, 970, 971, 972, 973, 973, 974, 975, 975, 975, 976, 976, 977, 977, 977, 978, 978, 978, 979, 979, 980, 980, 981, 981, 982, 982, 982, 983, 986, 986, 988, 990, 991, 991, 991, 991, 991, 992, 992, 993, 993, 994, 994, 995, 995, 995, 995, 995, 997, 997, 997, 997, 998, 998, 999, 999, 999 ]\n", + "[ 0, 0, 1, 1, 2, 2, 2, 3, 3, 4, 6, 6, 7, 7, 8, 8, 8, 8, 8, 8, 9, 10, 10, 11, 11, 12, 13, 13, 14, 14, 14, 15, 15, 15, 16, 16, 18, 18, 19, 19, 19, 20, 21, 21, 21, 21, 22, 23, 23, 23, 25, 26, 27, 27, 28, 28, 28, 29, 29, 29, 29, 30, 31, 32, 33, 34, 35, 35, 35, 36, 36, 36, 37, 38, 38, 39, 39, 39, 39, 39, 39, 40, 40, 41, 42, 42, 42, 42, 42, 43, 43, 44, 46, 47, 47, 47, 48, 50, 51, 51, 52, 52, 52, 53, 54, 54, 55, 55, 55, 56, 57, 57, 58, 58, 58, 58, 58, 59, 59, 60, 60, 61, 62, 63, 63, 63, 63, 64, 65, 65, 65, 66, 66, 66, 66, 67, 67, 68, 69, 69, 70, 70, 71, 71, 71, 72, 72, 73, 73, 73, 74, 75, 75, 75, 76, 78, 79, 79, 80, 81, 81, 82, 82, 83, 83, 84, 84, 86, 86, 87, 87, 88, 88, 88, 89, 89, 90, 90, 90, 91, 92, 92, 92, 93, 93, 93, 94, 95, 95, 96, 97, 98, 99, 100, 100, 101, 102, 102, 102, 104, 104, 105, 106, 106, 106, 106, 106, 106, 107, 107, 108, 108, 108, 109, 109, 109, 109, 110, 112, 112, 112, 113, 113, 113, 113, 113, 114, 115, 117, 117, 117, 118, 119, 119, 119, 120, 120, 121, 123, 124, 125, 125, 126, 126, 126, 126, 127, 129, 131, 131, 131, 131, 131, 131, 131, 132, 133, 133, 134, 134, 134, 135, 135, 135, 135, 135, 137, 138, 138, 138, 139, 139, 140, 141, 142, 142, 142, 144, 144, 145, 145, 145, 147, 147, 147, 147, 148, 149, 149, 149, 150, 150, 151, 151, 151, 151, 153, 155, 156, 159, 160, 160, 160, 161, 161, 162, 162, 162, 162, 162, 162, 163, 163, 163, 163, 163, 163, 164, 164, 164, 164, 164, 165, 165, 165, 165, 165, 166, 166, 166, 166, 166, 167, 167, 167, 167, 168, 169, 170, 170, 170, 170, 172, 172, 172, 173, 173, 173, 174, 175, 176, 177, 177, 178, 178, 178, 178, 179, 179, 180, 180, 181, 181, 182, 183, 183, 185, 186, 186, 186, 186, 186, 186, 186, 187, 187, 187, 188, 188, 188, 190, 190, 190, 190, 190, 192, 193, 194, 194, 194, 195, 195, 196, 197, 198, 198, 198, 199, 199, 199, 200, 200, 201, 201, 201, 204, 205, 205, 205, 207, 207, 207, 208, 208, 208, 208, 210, 210, 210, 210, 211, 211, 213, 214, 214, 214, 218, 218, 218, 218, 218, 218, 219, 221, 222, 223, 223, 223, 224, 224, 224, 224, 224, 224, 224, 225, 226, 226, 226, 226, 226, 227, 227, 228, 228, 229, 229, 229, 229, 230, 230, 230, 230, 232, 233, 233, 234, 235, 236, 236, 237, 237, 238, 240, 240, 242, 242, 243, 244, 246, 247, 247, 247, 247, 248, 248, 248, 249, 249, 249, 249, 249, 250, 250, 250, 251, 251, 252, 252, 253, 255, 255, 256, 256, 256, 257, 257, 257, 258, 258, 258, 258, 258, 259, 259, 260, 260, 260, 261, 261, 261, 262, 263, 265, 265, 266, 267, 267, 267, 268, 268, 268, 270, 270, 270, 271, 271, 273, 274, 274, 274, 275, 277, 277, 279, 279, 280, 281, 281, 282, 283, 283, 285, 286, 288, 288, 289, 289, 290, 290, 290, 290, 290, 291, 291, 291, 291, 292, 292, 292, 293, 294, 294, 295, 295, 295, 295, 295, 298, 298, 301, 301, 301, 302, 302, 303, 304, 305, 305, 306, 307, 307, 308, 308, 309, 309, 309, 309, 310, 310, 311, 311, 311, 312, 313, 313, 313, 314, 315, 316, 316, 316, 316, 317, 318, 318, 319, 319, 319, 320, 321, 321, 322, 322, 322, 322, 323, 323, 323, 324, 324, 324, 325, 326, 326, 328, 329, 329, 330, 330, 330, 331, 331, 331, 331, 332, 332, 333, 333, 333, 333, 334, 334, 334, 335, 336, 336, 337, 337, 337, 337, 339, 339, 340, 341, 341, 343, 344, 344, 345, 345, 345, 346, 346, 347, 348, 348, 348, 349, 350, 351, 351, 351, 352, 353, 354, 354, 354, 355, 356, 356, 357, 358, 358, 358, 359, 359, 360, 361, 361, 362, 362, 363, 364, 364, 365, 365, 365, 366, 366, 367, 367, 368, 368, 369, 369, 369, 370, 370, 370, 370, 370, 371, 372, 373, 373, 374, 374, 375, 375, 376, 377, 377, 378, 379, 381, 381, 383, 384, 385, 385, 385, 385, 386, 386, 387, 388, 388, 388, 389, 389, 390, 391, 391, 391, 392, 392, 393, 393, 394, 394, 394, 395, 395, 396, 396, 397, 397, 398, 399, 400, 400, 401, 401, 402, 402, 403, 404, 404, 405, 406, 406, 407, 407, 407, 408, 408, 408, 408, 408, 409, 409, 409, 411, 411, 412, 412, 413, 413, 413, 413, 413, 414, 414, 414, 415, 416, 416, 416, 416, 417, 417, 418, 418, 418, 418, 419, 420, 420, 420, 421, 421, 422, 422, 423, 423, 423, 424, 424, 424, 424, 425, 425, 425, 426, 426, 427, 427, 427, 428, 428, 429, 429, 429, 430, 430, 431, 432, 433, 433, 433, 434, 434, 434, 434, 437, 438, 438, 438, 438, 438, 439, 440, 441, 441, 442, 442, 443, 444, 444, 444, 445, 445, 445, 447, 447, 447, 448, 448, 449, 449, 450, 450, 450, 451, 452, 453, 453, 453, 453, 455, 455, 456, 456, 457, 458, 459, 459, 460, 460, 461, 461, 464, 465, 465, 465, 466, 466, 467, 467, 467, 467, 468, 469, 469, 470, 470, 471, 471, 471, 472, 473, 473, 473, 473, 474, 475, 475, 475, 476, 476, 476, 477, 477, 477, 478, 478, 479, 481, 481, 481, 482, 482, 482, 483, 483, 483, 484, 484, 485, 488, 488, 488, 488, 489, 490, 491, 491, 491, 492, 492, 493, 493, 493, 493, 493, 495, 495, 496, 496, 496, 496, 496, 496, 497, 497, 498, 498, 498, 498, 498, 499, 500, 500, 501, 501, 501, 502, 502, 502, 502, 503, 503, 503, 505, 505, 506, 507, 507, 507, 507, 508, 508, 510, 510, 510, 511, 511, 512, 512, 513, 513, 513, 513, 514, 514, 515, 516, 517, 518, 519, 519, 519, 520, 521, 521, 522, 522, 523, 523, 523, 525, 525, 526, 527, 527, 527, 528, 528, 528, 530, 531, 532, 532, 532, 532, 532, 535, 535, 537, 538, 538, 538, 540, 540, 540, 541, 541, 541, 541, 541, 542, 543, 543, 543, 543, 544, 544, 545, 545, 545, 546, 547, 547, 547, 548, 549, 549, 551, 552, 552, 553, 553, 553, 554, 554, 554, 555, 556, 557, 557, 557, 558, 558, 558, 559, 559, 559, 560, 560, 560, 561, 561, 561, 561, 562, 562, 562, 563, 563, 565, 566, 566, 567, 568, 569, 570, 570, 571, 571, 571, 571, 572, 572, 572, 574, 575, 576, 576, 577, 580, 581, 581, 582, 582, 582, 583, 583, 584, 585, 585, 585, 586, 587, 587, 588, 588, 588, 589, 591, 591, 591, 592, 592, 592, 593, 593, 593, 594, 594, 594, 594, 595, 595, 595, 596, 596, 596, 596, 596, 597, 597, 599, 599, 600, 600, 601, 601, 601, 602, 602, 603, 603, 604, 605, 605, 605, 606, 607, 608, 610, 612, 612, 613, 613, 614, 614, 615, 615, 615, 616, 616, 616, 617, 617, 619, 619, 619, 619, 620, 621, 621, 622, 624, 624, 624, 624, 625, 625, 628, 628, 628, 629, 629, 630, 630, 630, 630, 632, 633, 633, 634, 635, 638, 638, 639, 640, 641, 641, 643, 643, 644, 644, 644, 645, 645, 645, 646, 646, 646, 647, 647, 647, 647, 648, 648, 649, 650, 650, 650, 650, 650, 650, 651, 652, 652, 652, 653, 653, 653, 653, 654, 655, 655, 655, 655, 656, 657, 657, 657, 658, 658, 659, 659, 659, 659, 659, 660, 660, 661, 662, 663, 664, 665, 666, 666, 666, 667, 667, 667, 667, 667, 668, 668, 669, 670, 670, 670, 671, 672, 672, 672, 672, 672, 673, 673, 674, 674, 674, 675, 676, 676, 677, 678, 678, 679, 679, 680, 681, 681, 682, 683, 683, 684, 684, 685, 686, 686, 686, 686, 687, 687, 688, 690, 690, 691, 691, 693, 693, 694, 694, 697, 697, 698, 700, 701, 702, 702, 703, 703, 703, 704, 705, 706, 706, 707, 708, 708, 709, 709, 710, 710, 711, 712, 712, 712, 712, 712, 712, 713, 713, 714, 714, 716, 716, 716, 717, 717, 717, 718, 718, 718, 718, 719, 719, 719, 720, 720, 721, 721, 722, 723, 724, 725, 726, 726, 727, 729, 729, 729, 730, 730, 731, 731, 732, 732, 734, 734, 734, 735, 735, 736, 736, 736, 737, 737, 738, 739, 740, 740, 740, 741, 741, 742, 742, 742, 742, 744, 744, 744, 744, 745, 745, 745, 745, 746, 748, 749, 749, 749, 750, 750, 751, 751, 751, 752, 752, 753, 753, 754, 755, 756, 756, 756, 757, 757, 757, 757, 757, 761, 761, 762, 762, 762, 763, 763, 763, 763, 763, 764, 764, 764, 764, 765, 765, 766, 766, 766, 766, 767, 767, 767, 770, 770, 770, 770, 770, 771, 772, 772, 772, 773, 774, 775, 775, 775, 775, 776, 778, 778, 779, 779, 780, 780, 780, 781, 784, 784, 784, 786, 786, 786, 786, 787, 788, 789, 789, 789, 790, 791, 791, 792, 793, 793, 793, 794, 794, 795, 796, 797, 797, 798, 799, 799, 799, 800, 800, 800, 800, 801, 802, 802, 802, 802, 804, 806, 806, 806, 807, 807, 807, 807, 808, 809, 810, 810, 811, 812, 812, 812, 812, 812, 813, 813, 813, 814, 814, 814, 815, 816, 816, 817, 817, 817, 818, 818, 818, 819, 820, 820, 820, 820, 820, 821, 821, 823, 824, 824, 824, 825, 826, 826, 826, 826, 828, 828, 829, 829, 829, 829, 829, 830, 831, 831, 831, 831, 831, 832, 832, 833, 833, 833, 834, 834, 835, 835, 835, 835, 835, 836, 836, 836, 837, 839, 839, 839, 839, 839, 840, 840, 840, 841, 841, 842, 843, 844, 844, 844, 845, 845, 845, 845, 845, 846, 846, 846, 847, 847, 848, 848, 848, 849, 849, 850, 850, 851, 852, 852, 852, 852, 853, 855, 856, 857, 857, 858, 858, 858, 859, 860, 861, 861, 861, 861, 862, 863, 863, 863, 865, 865, 865, 866, 867, 867, 867, 868, 868, 870, 871, 872, 872, 873, 873, 873, 874, 874, 874, 875, 875, 875, 876, 877, 878, 878, 878, 878, 878, 879, 879, 879, 879, 880, 881, 881, 881, 882, 883, 885, 886, 886, 887, 887, 888, 888, 889, 889, 890, 890, 890, 892, 892, 892, 892, 893, 893, 894, 894, 894, 895, 896, 896, 896, 897, 899, 899, 900, 901, 901, 901, 901, 905, 905, 905, 905, 906, 907, 907, 907, 908, 908, 908, 908, 908, 908, 909, 909, 910, 910, 910, 912, 913, 913, 914, 914, 914, 915, 916, 916, 916, 916, 917, 917, 918, 919, 919, 919, 920, 920, 920, 920, 921, 921, 922, 923, 923, 923, 923, 923, 924, 925, 927, 927, 927, 928, 928, 929, 929, 929, 929, 930, 930, 931, 932, 932, 932, 933, 933, 934, 934, 935, 935, 936, 937, 937, 937, 939, 940, 940, 941, 941, 941, 941, 942, 942, 943, 943, 945, 946, 946, 946, 948, 949, 949, 951, 953, 953, 954, 954, 954, 954, 954, 955, 956, 956, 956, 957, 957, 957, 957, 959, 960, 960, 961, 961, 963, 963, 963, 964, 964, 964, 964, 965, 966, 967, 968, 969, 969, 970, 972, 972, 973, 973, 974, 975, 975, 975, 976, 977, 978, 978, 979, 979, 980, 980, 980, 980, 981, 982, 982, 984, 986, 986, 986, 986, 986, 987, 988, 988, 990, 990, 990, 990, 990, 991, 991, 991, 991, 991, 991, 992, 992, 992, 992, 992, 993, 993, 993, 993, 995, 996, 996, 996, 997, 997, 997, 997, 997, 998, 998, 998, 999, 999, 1000, 1001, 1001, 1002, 1003, 1003, 1004, 1004, 1004, 1006, 1007, 1007, 1007, 1008, 1008, 1008, 1009, 1010, 1010, 1011, 1011, 1012, 1012, 1012, 1013, 1013, 1013, 1014, 1014, 1014, 1016, 1016, 1016, 1017, 1017, 1017, 1018, 1018, 1018, 1019, 1019, 1020, 1020, 1021, 1021, 1021, 1022, 1023, 1023, 1023, 1024, 1024, 1024, 1025, 1026, 1026, 1027, 1028, 1028, 1028, 1028, 1029, 1029, 1029, 1030, 1031, 1031, 1032, 1033, 1034, 1034, 1035, 1035, 1036, 1038, 1039, 1039, 1040, 1040, 1040, 1040, 1040, 1040, 1042, 1042, 1043, 1043, 1043, 1043, 1044, 1045, 1045, 1045, 1045, 1047, 1047, 1048, 1048, 1049, 1049, 1050, 1050, 1051, 1051, 1053, 1053, 1053, 1054, 1054, 1055, 1055, 1056, 1056, 1057, 1057, 1058, 1058, 1058, 1058, 1059, 1059, 1059, 1061, 1061, 1061, 1061, 1062, 1062, 1062, 1063, 1063, 1063, 1063, 1064, 1064, 1064, 1064, 1064, 1065, 1065, 1066, 1066, 1067, 1067, 1069, 1069, 1069, 1070, 1071, 1071, 1072, 1072, 1072, 1073, 1073, 1074, 1074, 1074, 1075, 1076, 1077, 1077, 1078, 1078, 1078, 1079, 1079, 1079, 1081, 1082, 1082, 1083, 1084, 1084, 1084, 1084, 1085, 1085, 1086, 1086, 1087, 1087, 1088, 1088, 1089, 1089, 1090, 1090, 1090, 1091, 1093, 1093, 1093, 1094, 1094, 1094, 1094, 1095, 1095, 1095, 1095, 1095, 1095, 1096, 1097, 1098, 1098, 1098, 1098, 1100, 1102, 1102, 1103, 1103, 1103, 1104, 1104, 1105, 1105, 1105, 1105, 1106, 1106, 1106, 1106, 1107, 1107, 1107, 1108, 1110, 1111, 1111, 1112, 1113, 1113, 1113, 1113, 1115, 1115, 1115, 1115, 1115, 1116, 1116, 1117, 1117, 1119, 1119, 1119, 1121, 1122, 1122, 1122, 1122, 1123, 1124, 1124, 1125, 1125, 1127, 1127, 1127, 1128, 1129, 1129, 1129, 1130, 1130, 1131, 1131, 1132, 1132, 1132, 1132, 1134, 1135, 1137, 1137, 1138, 1138, 1138, 1138, 1139, 1140, 1140, 1140, 1140, 1142, 1142, 1142, 1142, 1142, 1142, 1143, 1143, 1145, 1145, 1148, 1148, 1150, 1150, 1151, 1151, 1151, 1152, 1152, 1152, 1153, 1153, 1154, 1155, 1156, 1156, 1156, 1156, 1157, 1158, 1158, 1158, 1159, 1159, 1159, 1160, 1160, 1161, 1161, 1161, 1162, 1162, 1163, 1163, 1163, 1164, 1164, 1165, 1165, 1167, 1167, 1167, 1168, 1168, 1168, 1169, 1170, 1170, 1171, 1171, 1171, 1172, 1172, 1172, 1173, 1173, 1173, 1174, 1174, 1174, 1174, 1176, 1176, 1176, 1176, 1176, 1177, 1178, 1178, 1178, 1179, 1179, 1179, 1180, 1180, 1181, 1181, 1182, 1182, 1182, 1183, 1183, 1184, 1184, 1184, 1184, 1184, 1185, 1186, 1186, 1188, 1188, 1189, 1189, 1190, 1190, 1191, 1191, 1191, 1192, 1192, 1193, 1193, 1195, 1197, 1197, 1198, 1198, 1198, 1199, 1199, 1199, 1200, 1201, 1201, 1201, 1202, 1202, 1202, 1202, 1204, 1204, 1205, 1205, 1205, 1205, 1205, 1206, 1206, 1206, 1207, 1207, 1207, 1207, 1207, 1207, 1209, 1210, 1210, 1211, 1212, 1213, 1213, 1214, 1214, 1215, 1215, 1216, 1216, 1217, 1217, 1217, 1219, 1219, 1219, 1219, 1220, 1220, 1222, 1222, 1223, 1224, 1224, 1225, 1225, 1226, 1226, 1226, 1227, 1227, 1227, 1227, 1227, 1227, 1228, 1228, 1228, 1229, 1230, 1230, 1232, 1232, 1232, 1232, 1232, 1232, 1233, 1234, 1235, 1235, 1235, 1236, 1237, 1238, 1239, 1240, 1240, 1240, 1240, 1240, 1240, 1241, 1241, 1242, 1243, 1243, 1243, 1243, 1244, 1244, 1246, 1246, 1247, 1247, 1249, 1250, 1251, 1251, 1252, 1252, 1252, 1252, 1252, 1252, 1253, 1253, 1253, 1253, 1254, 1254, 1255, 1256, 1257, 1257, 1257, 1259, 1259, 1261, 1261, 1262, 1263, 1263, 1264, 1265, 1265, 1265, 1266, 1266, 1268, 1268, 1269, 1270, 1270, 1270, 1270, 1271, 1271, 1271, 1271, 1272, 1272, 1273, 1273, 1274, 1274, 1274, 1274, 1275, 1275, 1275, 1275, 1276, 1276, 1276, 1276, 1276, 1277, 1278, 1279, 1279, 1280, 1280, 1281, 1282, 1282, 1283, 1283, 1284, 1284, 1284, 1286, 1286, 1289, 1290, 1290, 1290, 1291, 1292, 1292, 1293, 1293, 1294, 1296, 1296, 1296, 1296, 1297, 1297, 1297, 1298, 1299, 1300, 1300, 1301, 1302, 1303, 1304, 1304, 1305, 1305, 1306, 1306, 1307, 1307, 1307, 1307, 1307, 1308, 1308, 1308, 1308, 1309, 1309, 1310, 1311, 1312, 1312, 1313, 1313, 1313, 1314, 1315, 1316, 1316, 1316, 1317, 1319, 1320, 1320, 1320, 1320, 1321, 1322, 1322, 1323, 1323, 1323, 1324, 1324, 1325, 1327, 1328, 1329, 1329, 1330, 1330, 1330, 1330, 1332, 1332, 1332, 1333, 1333, 1334, 1335, 1335, 1336, 1336, 1336, 1338, 1338, 1338, 1339, 1339, 1340, 1340, 1340, 1341, 1341, 1341, 1342, 1343, 1343, 1345, 1345, 1345, 1346, 1346, 1346, 1346, 1346, 1346, 1347, 1348, 1349, 1349, 1349, 1349, 1351, 1352, 1353, 1353, 1353, 1354, 1354, 1355, 1355, 1356, 1356, 1356, 1356, 1358, 1358, 1359, 1359, 1359, 1359, 1359, 1360, 1360, 1360, 1361, 1361, 1361, 1362, 1362, 1363, 1363, 1363, 1365, 1365, 1366, 1367, 1367, 1370, 1371, 1371, 1372, 1372, 1373, 1373, 1373, 1374, 1375, 1375, 1375, 1377, 1377, 1378, 1378, 1378, 1380, 1380, 1381, 1381, 1381, 1382, 1382, 1382, 1382, 1382, 1382, 1383, 1383, 1383, 1384, 1384, 1384, 1385, 1385, 1385, 1385, 1386, 1386, 1387, 1387, 1388, 1388, 1388, 1389, 1389, 1389, 1392, 1393, 1393, 1394, 1394, 1395, 1395, 1395, 1396, 1397, 1398, 1398, 1398, 1399, 1399, 1399, 1400, 1401, 1402, 1402, 1402, 1403, 1404, 1405, 1406, 1406, 1406, 1406, 1407, 1407, 1407, 1407, 1409, 1409, 1409, 1410, 1410, 1410, 1410, 1410, 1411, 1411, 1412, 1413, 1413, 1413, 1414, 1414, 1415, 1415, 1415, 1416, 1416, 1416, 1417, 1417, 1417, 1417, 1417, 1419, 1420, 1420, 1420, 1421, 1422, 1422, 1422, 1422, 1425, 1426, 1427, 1427, 1428, 1428, 1430, 1431, 1431, 1432, 1432, 1432, 1433, 1433, 1434, 1434, 1434, 1434, 1434, 1435, 1436, 1436, 1436, 1436, 1436, 1437, 1438, 1438, 1438, 1438, 1439, 1439, 1440, 1440, 1440, 1440, 1441, 1441, 1442, 1443, 1444, 1444, 1444, 1444, 1444, 1444, 1444, 1444, 1445, 1446, 1446, 1446, 1447, 1448, 1449, 1449, 1450, 1450, 1450, 1451, 1451, 1452, 1452, 1452, 1453, 1454, 1455, 1456, 1458, 1459, 1459, 1459, 1459, 1460, 1460, 1461, 1461, 1461, 1462, 1462, 1462, 1462, 1462, 1462, 1463, 1463, 1465, 1465, 1465, 1466, 1467, 1468, 1469, 1470, 1472, 1472, 1473, 1474, 1474, 1474, 1474, 1475, 1476, 1477, 1477, 1477, 1477, 1478, 1478, 1480, 1481, 1481, 1481, 1481, 1481, 1481, 1482, 1482, 1482, 1483, 1484, 1485, 1485, 1486, 1486, 1486, 1488, 1488, 1489, 1489, 1489, 1491, 1491, 1492, 1492, 1493, 1495, 1495, 1495, 1496, 1496, 1497, 1497, 1497, 1497, 1497, 1498, 1498, 1499, 1500, 1500, 1501, 1501, 1501, 1501, 1502, 1503, 1503, 1503, 1503, 1503, 1503, 1504, 1505, 1505, 1505, 1506, 1506, 1506, 1506, 1509, 1509, 1509, 1510, 1510, 1511, 1511, 1511, 1511, 1512, 1513, 1513, 1513, 1514, 1514, 1515, 1516, 1516, 1517, 1517, 1518, 1518, 1519, 1519, 1520, 1521, 1522, 1522, 1524, 1525, 1525, 1525, 1525, 1526, 1526, 1526, 1526, 1526, 1526, 1528, 1528, 1528, 1529, 1532, 1532, 1532, 1534, 1534, 1535, 1536, 1536, 1536, 1537, 1537, 1538, 1538, 1538, 1539, 1539, 1539, 1539, 1540, 1541, 1542, 1542, 1543, 1544, 1544, 1544, 1545, 1545, 1545, 1546, 1547, 1547, 1547, 1547, 1547, 1548, 1550, 1551, 1551, 1551, 1551, 1552, 1552, 1552, 1552, 1553, 1554, 1554, 1554, 1555, 1555, 1555, 1555, 1556, 1556, 1557, 1558, 1559, 1559, 1559, 1560, 1560, 1560, 1560, 1561, 1561, 1562, 1562, 1563, 1564, 1564, 1565, 1565, 1565, 1566, 1567, 1567, 1568, 1568, 1569, 1569, 1570, 1570, 1570, 1571, 1571, 1571, 1571, 1572, 1572, 1572, 1573, 1573, 1573, 1573, 1574, 1574, 1575, 1575, 1575, 1575, 1575, 1576, 1576, 1576, 1576, 1576, 1578, 1578, 1578, 1579, 1579, 1579, 1580, 1581, 1581, 1581, 1581, 1581, 1582, 1582, 1582, 1582, 1583, 1583, 1586, 1586, 1586, 1586, 1586, 1587, 1588, 1589, 1590, 1591, 1591, 1591, 1594, 1595, 1595, 1595, 1596, 1598, 1598, 1599, 1600, 1600, 1601, 1601, 1601, 1602, 1602, 1602, 1603, 1603, 1605, 1605, 1606, 1607, 1608, 1608, 1608, 1609, 1609, 1609, 1609, 1611, 1611, 1612, 1612, 1612, 1612, 1612, 1612, 1614, 1615, 1615, 1615, 1615, 1616, 1618, 1618, 1619, 1620, 1621, 1621, 1621, 1622, 1623, 1623, 1624, 1624, 1624, 1624, 1625, 1625, 1625, 1626, 1626, 1627, 1627, 1627, 1629, 1629, 1630, 1630, 1631, 1631, 1634, 1634, 1634, 1634, 1634, 1634, 1635, 1636, 1639, 1639, 1640, 1641, 1641, 1641, 1642, 1642, 1643, 1645, 1645, 1645, 1646, 1647, 1647, 1647, 1648, 1649, 1649, 1649, 1649, 1649, 1651, 1652, 1653, 1653, 1655, 1655, 1655, 1655, 1655, 1655, 1657, 1657, 1657, 1658, 1658, 1659, 1659, 1659, 1659, 1660, 1660, 1660, 1660, 1662, 1663, 1663, 1664, 1664, 1666, 1666, 1666, 1666, 1668, 1669, 1669, 1669, 1671, 1671, 1672, 1672, 1673, 1673, 1673, 1673, 1674, 1674, 1675, 1675, 1675, 1677, 1677, 1677, 1677, 1678, 1678, 1678, 1679, 1679, 1679, 1679, 1680, 1680, 1680, 1681, 1681, 1681, 1682, 1682, 1682, 1683, 1683, 1683, 1684, 1684, 1684, 1685, 1685, 1686, 1687, 1688, 1688, 1688, 1689, 1689, 1691, 1691, 1691, 1692, 1693, 1693, 1693, 1696, 1697, 1697, 1698, 1699, 1700, 1700, 1701, 1702, 1703, 1703, 1705, 1705, 1705, 1707, 1708, 1708, 1708, 1709, 1711, 1712, 1712, 1712, 1714, 1714, 1714, 1714, 1715, 1716, 1716, 1717, 1718, 1718, 1719, 1719, 1719, 1720, 1720, 1720, 1721, 1721, 1722, 1722, 1722, 1722, 1722, 1723, 1723, 1724, 1724, 1725, 1726, 1726, 1727, 1727, 1728, 1728, 1730, 1731, 1731, 1734, 1735, 1735, 1735, 1736, 1737, 1737, 1738, 1738, 1738, 1739, 1739, 1739, 1739, 1739, 1740, 1740, 1740, 1740, 1740, 1741, 1741, 1741, 1741, 1741, 1742, 1743, 1744, 1744, 1744, 1745, 1746, 1746, 1747, 1748, 1749, 1749, 1749, 1749, 1751, 1751, 1751, 1752, 1752, 1752, 1752, 1753, 1754, 1755, 1755, 1755, 1756, 1756, 1757, 1757, 1757, 1757, 1758, 1759, 1759, 1759, 1760, 1760, 1762, 1764, 1766, 1766, 1767, 1767, 1768, 1769, 1769, 1770, 1770, 1770, 1771, 1772, 1773, 1774, 1775, 1775, 1775, 1776, 1776, 1776, 1777, 1777, 1778, 1778, 1779, 1779, 1780, 1780, 1781, 1782, 1784, 1784, 1784, 1785, 1785, 1785, 1785, 1787, 1788, 1789, 1789, 1789, 1790, 1790, 1790, 1791, 1791, 1791, 1791, 1791, 1792, 1792, 1793, 1793, 1793, 1793, 1794, 1794, 1795, 1795, 1796, 1796, 1797, 1797, 1798, 1798, 1798, 1799, 1799, 1800, 1800, 1800, 1801, 1801, 1802, 1802, 1804, 1804, 1804, 1806, 1806, 1808, 1809, 1810, 1810, 1811, 1811, 1814, 1814, 1814, 1815, 1815, 1816, 1816, 1816, 1816, 1817, 1817, 1818, 1819, 1819, 1819, 1820, 1820, 1820, 1821, 1821, 1822, 1823, 1823, 1824, 1824, 1824, 1825, 1825, 1825, 1826, 1826, 1826, 1827, 1827, 1827, 1828, 1828, 1830, 1831, 1832, 1832, 1832, 1832, 1833, 1833, 1833, 1833, 1835, 1837, 1838, 1839, 1840, 1840, 1840, 1840, 1840, 1840, 1841, 1842, 1842, 1843, 1843, 1844, 1844, 1844, 1844, 1844, 1845, 1846, 1847, 1847, 1847, 1848, 1849, 1849, 1849, 1850, 1850, 1850, 1851, 1851, 1851, 1852, 1852, 1853, 1853, 1853, 1854, 1854, 1855, 1855, 1855, 1855, 1855, 1855, 1856, 1856, 1856, 1856, 1857, 1857, 1857, 1857, 1858, 1859, 1859, 1860, 1860, 1860, 1860, 1861, 1861, 1863, 1863, 1865, 1865, 1866, 1866, 1866, 1866, 1866, 1867, 1867, 1867, 1867, 1867, 1868, 1869, 1869, 1869, 1869, 1869, 1869, 1870, 1870, 1870, 1870, 1871, 1872, 1873, 1874, 1875, 1875, 1876, 1876, 1876, 1876, 1877, 1877, 1878, 1878, 1878, 1879, 1879, 1880, 1880, 1880, 1881, 1881, 1883, 1883, 1885, 1885, 1885, 1885, 1885, 1885, 1886, 1886, 1886, 1887, 1887, 1887, 1887, 1888, 1888, 1890, 1891, 1891, 1891, 1892, 1894, 1894, 1894, 1894, 1896, 1896, 1896, 1896, 1897, 1899, 1899, 1900, 1900, 1901, 1901, 1902, 1903, 1904, 1905, 1905, 1905, 1906, 1906, 1906, 1907, 1907, 1908, 1908, 1909, 1910, 1910, 1911, 1912, 1912, 1912, 1913, 1914, 1914, 1914, 1915, 1915, 1915, 1916, 1916, 1916, 1917, 1918, 1918, 1919, 1919, 1920, 1920, 1920, 1920, 1921, 1921, 1922, 1923, 1925, 1925, 1925, 1925, 1926, 1928, 1929, 1929, 1930, 1930, 1931, 1931, 1931, 1931, 1932, 1932, 1932, 1932, 1932, 1933, 1933, 1933, 1933, 1934, 1934, 1934, 1934, 1934, 1935, 1935, 1935, 1936, 1937, 1938, 1938, 1938, 1938, 1940, 1941, 1941, 1941, 1942, 1942, 1943, 1943, 1944, 1944, 1944, 1944, 1945, 1946, 1946, 1947, 1948, 1948, 1948, 1949, 1949, 1949, 1949, 1949, 1950, 1950, 1950, 1951, 1951, 1951, 1951, 1951, 1952, 1953, 1955, 1955, 1956, 1956, 1956, 1957, 1957, 1957, 1958, 1958, 1960, 1960, 1960, 1960, 1961, 1963, 1965, 1965, 1965, 1967, 1967, 1968, 1968, 1969, 1969, 1969, 1969, 1970, 1970, 1971, 1971, 1971, 1972, 1972, 1973, 1973, 1973, 1973, 1973, 1974, 1974, 1975, 1975, 1976, 1976, 1976, 1976, 1977, 1978, 1978, 1979, 1979, 1979, 1980, 1980, 1981, 1981, 1982, 1982, 1982, 1983, 1983, 1983, 1984, 1984, 1986, 1986, 1987, 1989, 1989, 1989, 1989, 1989, 1990, 1990, 1990, 1991, 1991, 1991, 1991, 1992, 1992, 1994, 1994, 1994, 1995, 1995, 1995, 1995, 1995, 1996, 1996, 1996, 1997, 1997, 1998, 1998, 1998, 1998, 1999, 1999, 2000, 2000, 2002, 2003, 2003, 2005, 2009, 2010, 2010, 2011, 2012, 2013, 2014, 2014, 2015, 2016, 2016, 2016, 2016, 2016, 2017, 2018, 2019, 2020, 2020, 2021, 2021, 2021, 2021, 2024, 2026, 2027, 2027, 2028, 2028, 2029, 2029, 2030, 2031, 2032, 2032, 2033, 2034, 2035, 2035, 2036, 2036, 2036, 2036, 2036, 2037, 2037, 2037, 2037, 2038, 2038, 2039, 2039, 2039, 2040, 2041, 2041, 2042, 2042, 2042, 2042, 2042, 2042, 2042, 2043, 2044, 2044, 2045, 2045, 2045, 2046, 2047, 2047, 2048, 2048, 2049, 2051, 2051, 2052, 2052, 2054, 2054, 2054, 2054, 2055, 2056, 2056, 2057, 2058, 2058, 2059, 2059, 2062, 2063, 2063, 2063, 2063, 2063, 2063, 2064, 2064, 2065, 2065, 2065, 2065, 2066, 2066, 2067, 2067, 2068, 2068, 2068, 2068, 2068, 2069, 2070, 2070, 2071, 2071, 2071, 2072, 2073, 2073, 2073, 2075, 2075, 2075, 2076, 2077, 2077, 2078, 2078, 2079, 2079, 2079, 2079, 2080, 2080, 2080, 2081, 2082, 2082, 2082, 2082, 2083, 2083, 2083, 2084, 2084, 2084, 2085, 2085, 2086, 2086, 2086, 2087, 2087, 2087, 2088, 2088, 2088, 2088, 2088, 2089, 2089, 2089, 2089, 2089, 2089, 2089, 2090, 2091, 2091, 2091, 2091, 2092, 2093, 2093, 2094, 2094, 2095, 2096, 2096, 2097, 2097, 2097, 2097, 2098, 2098, 2098, 2098, 2099, 2100, 2102, 2102, 2102, 2102, 2102, 2104, 2104, 2104, 2105, 2105, 2106, 2106, 2107, 2108, 2109, 2109, 2110, 2110, 2111, 2111, 2112, 2114, 2115, 2115, 2116, 2117, 2117, 2118, 2119, 2119, 2119, 2120, 2121, 2121, 2121, 2122, 2122, 2122, 2123, 2124, 2124, 2125, 2125, 2125, 2125, 2127, 2127, 2127, 2127, 2128, 2128, 2128, 2128, 2128, 2129, 2129, 2130, 2131, 2131, 2131, 2132, 2132, 2132, 2133, 2133, 2133, 2133, 2133, 2133, 2133, 2133, 2134, 2135, 2136, 2137, 2137, 2137, 2138, 2138, 2139, 2140, 2140, 2140, 2140, 2142, 2143, 2144, 2144, 2145, 2145, 2145, 2145, 2146, 2146, 2146, 2147, 2147, 2147, 2147, 2147, 2148, 2148, 2148, 2148, 2149, 2149, 2149, 2150, 2151, 2151, 2153, 2153, 2153, 2153, 2154, 2154, 2154, 2155, 2155, 2156, 2157, 2157, 2157, 2157, 2158, 2158, 2158, 2158, 2158, 2159, 2159, 2160, 2160, 2160, 2160, 2161, 2162, 2162, 2162, 2162, 2162, 2163, 2164, 2164, 2167, 2168, 2169, 2169, 2169, 2170, 2172, 2172, 2172, 2172, 2172, 2173, 2173, 2174, 2174, 2175, 2175, 2176, 2176, 2176, 2176, 2177, 2177, 2179, 2179, 2180, 2180, 2180, 2183, 2183, 2183, 2183, 2184, 2185, 2185, 2185, 2185, 2186, 2186, 2186, 2187, 2187, 2188, 2189, 2189, 2189, 2190, 2190, 2191, 2191, 2191, 2191, 2191, 2192, 2193, 2194, 2194, 2195, 2195, 2195, 2195, 2196, 2196, 2197, 2197, 2197, 2198, 2198, 2198, 2199, 2199, 2199, 2200, 2200, 2201, 2201, 2202, 2202, 2202, 2203, 2203, 2204, 2205, 2205, 2205, 2205, 2205, 2206, 2206, 2206, 2207, 2207, 2207, 2210, 2210, 2212, 2213, 2214, 2214, 2215, 2216, 2216, 2216, 2217, 2217, 2219, 2219, 2219, 2219, 2220, 2220, 2221, 2221, 2222, 2222, 2223, 2223, 2224, 2224, 2225, 2225, 2226, 2226, 2226, 2226, 2227, 2228, 2228, 2228, 2229, 2229, 2229, 2230, 2230, 2231, 2231, 2232, 2232, 2232, 2234, 2234, 2234, 2235, 2235, 2236, 2237, 2237, 2238, 2238, 2239, 2239, 2239, 2240, 2240, 2241, 2241, 2241, 2242, 2244, 2244, 2245, 2245, 2245, 2245, 2246, 2248, 2249, 2250, 2251, 2251, 2251, 2251, 2252, 2252, 2253, 2254, 2254, 2255, 2256, 2256, 2256, 2258, 2258, 2258, 2259, 2259, 2259, 2259, 2260, 2260, 2261, 2261, 2262, 2262, 2262, 2263, 2265, 2265, 2265, 2265, 2266, 2266, 2267, 2268, 2269, 2269, 2270, 2270, 2271, 2271, 2272, 2273, 2273, 2273, 2275, 2275, 2276, 2276, 2277, 2277, 2278, 2278, 2280, 2280, 2281, 2282, 2282, 2282, 2282, 2284, 2284, 2284, 2284, 2285, 2285, 2286, 2287, 2287, 2288, 2288, 2289, 2291, 2292, 2292, 2293, 2294, 2295, 2296, 2296, 2297, 2298, 2298, 2299, 2299, 2299, 2300, 2300, 2301, 2301, 2301, 2302, 2302, 2302, 2302, 2303, 2303, 2303, 2304, 2304, 2306, 2306, 2307, 2307, 2307, 2307, 2309, 2309, 2309, 2310, 2310, 2310, 2310, 2311, 2311, 2311, 2312, 2312, 2312, 2313, 2313, 2316, 2317, 2317, 2317, 2317, 2317, 2317, 2317, 2318, 2318, 2319, 2319, 2319, 2320, 2322, 2323, 2323, 2324, 2324, 2324, 2325, 2326, 2327, 2327, 2328, 2329, 2330, 2331, 2332, 2333, 2333, 2334, 2334, 2336, 2336, 2337, 2337, 2338, 2338, 2339, 2339, 2339, 2340, 2340, 2340, 2341, 2342, 2343, 2344, 2345, 2345, 2345, 2345, 2346, 2346, 2347, 2347, 2347, 2347, 2349, 2349, 2349, 2350, 2350, 2351, 2351, 2351, 2351, 2352, 2352, 2353, 2354, 2355, 2356, 2356, 2358, 2359, 2360, 2361, 2362, 2362, 2362, 2363, 2363, 2363, 2364, 2365, 2365, 2365, 2365, 2366, 2367, 2367, 2367, 2367, 2368, 2370, 2370, 2370, 2372, 2372, 2372, 2372, 2372, 2373, 2373, 2373, 2374, 2374, 2375, 2375, 2375, 2376, 2376, 2377, 2377, 2377, 2377, 2378, 2379, 2379, 2380, 2380, 2380, 2381, 2382, 2382, 2382, 2382, 2384, 2384, 2384, 2385, 2387, 2387, 2387, 2388, 2389, 2389, 2389, 2389, 2389, 2390, 2391, 2391, 2392, 2392, 2392, 2394, 2394, 2395, 2395, 2395, 2396, 2396, 2397, 2397, 2397, 2397, 2398, 2398, 2398, 2399, 2400, 2401, 2402, 2404, 2404, 2405, 2405, 2405, 2407, 2408, 2409, 2409, 2409, 2409, 2410, 2410, 2410, 2410, 2410, 2410, 2410, 2411, 2411, 2412, 2412, 2414, 2414, 2415, 2415, 2416, 2416, 2417, 2417, 2418, 2418, 2420, 2421, 2422, 2424, 2424, 2424, 2425, 2425, 2426, 2426, 2426, 2426, 2427, 2427, 2427, 2427, 2427, 2428, 2430, 2432, 2432, 2432, 2432, 2433, 2433, 2433, 2433, 2433, 2434, 2435, 2435, 2435, 2435, 2436, 2437, 2437, 2437, 2437, 2438, 2438, 2439, 2439, 2439, 2440, 2440, 2441, 2441, 2441, 2442, 2443, 2443, 2444, 2444, 2444, 2444, 2447, 2447, 2448, 2448, 2448, 2449, 2449, 2449, 2450, 2451, 2451, 2451, 2453, 2453, 2454, 2454, 2454, 2454, 2455, 2456, 2456, 2457, 2457, 2457, 2458, 2458, 2458, 2459, 2459, 2459, 2459, 2460, 2460, 2461, 2461, 2462, 2463, 2463, 2463, 2463, 2464, 2464, 2464, 2464, 2464, 2465, 2465, 2465, 2466, 2467, 2467, 2467, 2467, 2469, 2470, 2471, 2471, 2472, 2472, 2473, 2473, 2473, 2474, 2474, 2474, 2474, 2475, 2475, 2476, 2476, 2477, 2478, 2479, 2482, 2482, 2483, 2483, 2485, 2485, 2485, 2485, 2486, 2487, 2488, 2489, 2489, 2490, 2490, 2491, 2491, 2491, 2493, 2494, 2494, 2495, 2495, 2495, 2495, 2495, 2495, 2496, 2496, 2496, 2496, 2497, 2497, 2497, 2498, 2498, 2499, 2501, 2502, 2503, 2504, 2504, 2505, 2506, 2506, 2507, 2508, 2508, 2508, 2509, 2509, 2513, 2513, 2513, 2513, 2514, 2514, 2515, 2515, 2516, 2516, 2516, 2518, 2518, 2519, 2519, 2519, 2519, 2520, 2520, 2520, 2520, 2521, 2521, 2521, 2522, 2523, 2523, 2523, 2524, 2524, 2524, 2524, 2525, 2525, 2527, 2527, 2527, 2527, 2527, 2528, 2528, 2529, 2531, 2531, 2532, 2532, 2532, 2533, 2534, 2534, 2535, 2535, 2535, 2536, 2537, 2537, 2537, 2538, 2538, 2539, 2539, 2539, 2539, 2539, 2541, 2541, 2541, 2542, 2542, 2543, 2544, 2544, 2544, 2544, 2545, 2545, 2545, 2546, 2546, 2546, 2546, 2547, 2547, 2547, 2548, 2548, 2548, 2550, 2550, 2550, 2550, 2550, 2551, 2552, 2552, 2553, 2554, 2554, 2554, 2555, 2555, 2556, 2556, 2557, 2557, 2557, 2558, 2560, 2561, 2561, 2561, 2561, 2562, 2563, 2563, 2564, 2564, 2564, 2566, 2566, 2566, 2566, 2566, 2566, 2567, 2567, 2567, 2568, 2569, 2569, 2569, 2571, 2572, 2573, 2573, 2574, 2574, 2576, 2576, 2577, 2577, 2578, 2580, 2580, 2581, 2581, 2581, 2581, 2584, 2584, 2585, 2586, 2587, 2587, 2588, 2588, 2588, 2589, 2589, 2590, 2590, 2591, 2591, 2591, 2592, 2592, 2592, 2593, 2593, 2593, 2594, 2594, 2594, 2596, 2596, 2597, 2598, 2599, 2599, 2599, 2600, 2601, 2601, 2602, 2603, 2603, 2604, 2604, 2604, 2605, 2607, 2608, 2608, 2609, 2609, 2609, 2609, 2611, 2611, 2612, 2612, 2613, 2613, 2613, 2613, 2613, 2614, 2614, 2615, 2615, 2615, 2615, 2615, 2616, 2616, 2617, 2617, 2617, 2618, 2619, 2619, 2620, 2621, 2622, 2622, 2622, 2623, 2624, 2625, 2627, 2628, 2628, 2628, 2628, 2629, 2630, 2630, 2630, 2630, 2631, 2632, 2632, 2632, 2632, 2633, 2633, 2633, 2633, 2633, 2634, 2634, 2635, 2636, 2636, 2636, 2636, 2637, 2637, 2637, 2637, 2637, 2638, 2638, 2638, 2638, 2640, 2640, 2644, 2646, 2646, 2647, 2648, 2649, 2650, 2650, 2650, 2651, 2651, 2651, 2651, 2652, 2652, 2653, 2654, 2654, 2654, 2654, 2655, 2655, 2656, 2656, 2657, 2657, 2657, 2659, 2659, 2660, 2660, 2660, 2660, 2661, 2661, 2662, 2662, 2663, 2663, 2663, 2664, 2665, 2665, 2665, 2666, 2667, 2668, 2670, 2670, 2670, 2670, 2672, 2672, 2673, 2673, 2674, 2674, 2675, 2676, 2676, 2676, 2676, 2677, 2677, 2677, 2677, 2677, 2677, 2679, 2680, 2681, 2683, 2683, 2684, 2684, 2684, 2684, 2685, 2686, 2687, 2688, 2688, 2688, 2689, 2689, 2689, 2689, 2690, 2690, 2690, 2690, 2691, 2691, 2692, 2692, 2692, 2692, 2693, 2693, 2694, 2694, 2694, 2694, 2694, 2695, 2695, 2695, 2696, 2697, 2698, 2699, 2700, 2700, 2701, 2702, 2702, 2704, 2704, 2704, 2705, 2705, 2705, 2705, 2706, 2707, 2707, 2708, 2708, 2710, 2710, 2710, 2711, 2711, 2711, 2711, 2711, 2711, 2712, 2713, 2713, 2714, 2715, 2716, 2717, 2717, 2718, 2718, 2718, 2718, 2719, 2719, 2720, 2722, 2723, 2723, 2724, 2724, 2725, 2726, 2726, 2727, 2728, 2729, 2729, 2729, 2729, 2730, 2731, 2732, 2733, 2734, 2734, 2734, 2735, 2735, 2736, 2736, 2736, 2737, 2738, 2739, 2739, 2740, 2740, 2741, 2741, 2742, 2742, 2743, 2743, 2743, 2744, 2744, 2746, 2747, 2748, 2748, 2748, 2748, 2749, 2749, 2749, 2750, 2750, 2750, 2752, 2752, 2754, 2754, 2754, 2755, 2755, 2756, 2756, 2757, 2757, 2758, 2758, 2759, 2759, 2759, 2759, 2761, 2762, 2762, 2762, 2762, 2762, 2763, 2763, 2763, 2764, 2764, 2764, 2765, 2766, 2766, 2766, 2766, 2767, 2767, 2768, 2769, 2770, 2770, 2770, 2770, 2771, 2771, 2771, 2772, 2772, 2772, 2772, 2774, 2776, 2776, 2776, 2776, 2776, 2777, 2778, 2779, 2779, 2779, 2780, 2780, 2780, 2781, 2781, 2782, 2783, 2783, 2784, 2784, 2784, 2785, 2785, 2786, 2786, 2786, 2787, 2787, 2787, 2787, 2788, 2788, 2789, 2789, 2789, 2789, 2790, 2790, 2790, 2790, 2791, 2791, 2791, 2791, 2792, 2792, 2792, 2792, 2792, 2793, 2793, 2794, 2795, 2795, 2796, 2796, 2797, 2797, 2798, 2800, 2800, 2801, 2801, 2801, 2802, 2802, 2803, 2803, 2804, 2804, 2805, 2805, 2805, 2805, 2805, 2805, 2806, 2806, 2806, 2807, 2808, 2809, 2809, 2809, 2809, 2809, 2809, 2810, 2810, 2811, 2811, 2811, 2812, 2812, 2812, 2813, 2816, 2816, 2816, 2817, 2817, 2818, 2818, 2818, 2818, 2818, 2819, 2819, 2819, 2820, 2820, 2820, 2821, 2821, 2821, 2822, 2823, 2823, 2823, 2824, 2824, 2824, 2825, 2826, 2826, 2826, 2827, 2827, 2827, 2827, 2827, 2827, 2828, 2828, 2830, 2830, 2830, 2831, 2831, 2833, 2833, 2833, 2833, 2835, 2836, 2838, 2838, 2838, 2839, 2839, 2840, 2840, 2841, 2842, 2842, 2843, 2844, 2845, 2845, 2846, 2846, 2848, 2848, 2848, 2849, 2850, 2851, 2852, 2852, 2852, 2853, 2853, 2853, 2854, 2854, 2855, 2855, 2856, 2856, 2857, 2857, 2857, 2857, 2858, 2858, 2859, 2859, 2859, 2860, 2861, 2861, 2861, 2862, 2862, 2863, 2863, 2863, 2864, 2865, 2868, 2868, 2868, 2868, 2868, 2869, 2869, 2870, 2870, 2870, 2871, 2871, 2871, 2872, 2873, 2874, 2875, 2875, 2876, 2876, 2877, 2877, 2878, 2879, 2880, 2880, 2881, 2882, 2884, 2884, 2884, 2885, 2885, 2886, 2887, 2887, 2887, 2887, 2887, 2888, 2888, 2888, 2888, 2889, 2889, 2889, 2890, 2890, 2890, 2891, 2893, 2894, 2895, 2896, 2896, 2897, 2897, 2898, 2898, 2898, 2900, 2900, 2901, 2901, 2902, 2902, 2902, 2902, 2903, 2904, 2904, 2904, 2904, 2905, 2905, 2905, 2906, 2907, 2907, 2908, 2908, 2908, 2908, 2909, 2909, 2910, 2911, 2911, 2911, 2912, 2913, 2914, 2915, 2916, 2916, 2918, 2918, 2919, 2919, 2919, 2920, 2921, 2921, 2922, 2922, 2922, 2923, 2923, 2923, 2924, 2925, 2926, 2926, 2926, 2927, 2927, 2927, 2928, 2929, 2930, 2931, 2931, 2932, 2932, 2932, 2934, 2934, 2934, 2935, 2935, 2935, 2936, 2937, 2938, 2939, 2940, 2940, 2941, 2942, 2942, 2943, 2943, 2943, 2944, 2944, 2944, 2944, 2944, 2945, 2946, 2946, 2947, 2947, 2948, 2949, 2950, 2950, 2951, 2952, 2954, 2954, 2954, 2955, 2955, 2956, 2957, 2958, 2958, 2959, 2959, 2960, 2960, 2960, 2962, 2962, 2964, 2964, 2965, 2965, 2965, 2966, 2966, 2967, 2967, 2968, 2969, 2969, 2969, 2970, 2970, 2971, 2972, 2972, 2972, 2972, 2972, 2974, 2974, 2974, 2976, 2976, 2977, 2978, 2979, 2980, 2980, 2980, 2980, 2981, 2981, 2982, 2982, 2983, 2984, 2984, 2986, 2987, 2987, 2988, 2988, 2988, 2989, 2989, 2989, 2990, 2990, 2991, 2991, 2991, 2992, 2993, 2994, 2995, 2995, 2995, 2995, 2996, 2996, 2997, 2997, 2997, 2998, 2999, 2999, 2999, 2999, 2999, 2999, 3000, 3000, 3000, 3000, 3001, 3001, 3002, 3003, 3003, 3004, 3005, 3005, 3005, 3007, 3007, 3008, 3008, 3009, 3009, 3009, 3010, 3010, 3010, 3010, 3011, 3011, 3013, 3013, 3014, 3015, 3015, 3016, 3016, 3016, 3016, 3017, 3018, 3018, 3018, 3018, 3019, 3020, 3020, 3021, 3021, 3021, 3022, 3024, 3026, 3026, 3026, 3026, 3027, 3028, 3028, 3028, 3028, 3030, 3030, 3031, 3035, 3036, 3036, 3036, 3037, 3037, 3038, 3038, 3039, 3039, 3041, 3041, 3041, 3042, 3043, 3043, 3044, 3044, 3045, 3045, 3045, 3045, 3045, 3046, 3047, 3048, 3048, 3048, 3049, 3049, 3049, 3050, 3050, 3051, 3051, 3051, 3051, 3052, 3052, 3052, 3053, 3054, 3054, 3054, 3054, 3055, 3055, 3055, 3055, 3057, 3057, 3057, 3058, 3059, 3060, 3060, 3060, 3060, 3061, 3062, 3063, 3063, 3063, 3064, 3065, 3065, 3066, 3068, 3068, 3068, 3068, 3068, 3068, 3069, 3071, 3072, 3072, 3072, 3073, 3074, 3074, 3074, 3075, 3077, 3077, 3078, 3078, 3079, 3079, 3079, 3079, 3081, 3081, 3081, 3082, 3082, 3082, 3082, 3083, 3083, 3084, 3084, 3084, 3086, 3086, 3087, 3087, 3087, 3087, 3088, 3089, 3089, 3090, 3091, 3092, 3092, 3093, 3093, 3094, 3094, 3094, 3095, 3095, 3096, 3097, 3097, 3098, 3099, 3100, 3101, 3101, 3102, 3102, 3104, 3104, 3105, 3107, 3108, 3108, 3109, 3109, 3109, 3110, 3110, 3111, 3111, 3111, 3112, 3112, 3112, 3112, 3112, 3113, 3113, 3113, 3113, 3113, 3114, 3115, 3116, 3116, 3116, 3117, 3117, 3117, 3118, 3118, 3119, 3119, 3119, 3120, 3120, 3120, 3121, 3121, 3121, 3122, 3122, 3122, 3122, 3123, 3123, 3124, 3126, 3127, 3127, 3127, 3127, 3128, 3128, 3128, 3128, 3129, 3130, 3130, 3131, 3131, 3131, 3131, 3131, 3132, 3132, 3132, 3133, 3133, 3134, 3135, 3136, 3136, 3136, 3137, 3138, 3140, 3140, 3141, 3142, 3142, 3143, 3143, 3143, 3143, 3143, 3144, 3145, 3146, 3146, 3146, 3147, 3148, 3149, 3149, 3150, 3150, 3150, 3150, 3150, 3150, 3151, 3151, 3152, 3152, 3154, 3154, 3155, 3155, 3155, 3156, 3156, 3157, 3158, 3158, 3159, 3160, 3160, 3161, 3161, 3161, 3162, 3162, 3163, 3164, 3164, 3165, 3165, 3166, 3166, 3166, 3167, 3167, 3168, 3168, 3168, 3169, 3169, 3170, 3170, 3170, 3170, 3171, 3172, 3172, 3173, 3175, 3175, 3177, 3177, 3178, 3178, 3179, 3180, 3180, 3180, 3181, 3182, 3182, 3182, 3183, 3184, 3184, 3184, 3185, 3186, 3187, 3187, 3188, 3189, 3189, 3189, 3190, 3190, 3191, 3192, 3192, 3193, 3193, 3193, 3194, 3194, 3194, 3194, 3195, 3195, 3196, 3196, 3196, 3196, 3198, 3198, 3198, 3198, 3198, 3199, 3199, 3199, 3200, 3200, 3202, 3202, 3203, 3203, 3203, 3205, 3206, 3207, 3207, 3207, 3208, 3208, 3208, 3208, 3209, 3209, 3210, 3210, 3211, 3211, 3211, 3212, 3212, 3213, 3213, 3213, 3214, 3214, 3215, 3216, 3216, 3217, 3218, 3218, 3219, 3219, 3220, 3222, 3223, 3223, 3223, 3224, 3224, 3224, 3224, 3225, 3225, 3225, 3225, 3226, 3227, 3228, 3228, 3228, 3228, 3228, 3228, 3229, 3230, 3230, 3231, 3233, 3234, 3234, 3234, 3235, 3235, 3236, 3236, 3237, 3237, 3239, 3239, 3239, 3240, 3240, 3241, 3241, 3241, 3241, 3243, 3243, 3243, 3243, 3243, 3243, 3243, 3243, 3245, 3245, 3246, 3246, 3246, 3247, 3247, 3247, 3247, 3248, 3248, 3249, 3250, 3250, 3251, 3251, 3252, 3252, 3253, 3253, 3254, 3254, 3255, 3256, 3257, 3257, 3257, 3259, 3259, 3260, 3260, 3261, 3262, 3263, 3263, 3263, 3264, 3266, 3266, 3266, 3267, 3267, 3267, 3267, 3267, 3268, 3268, 3268, 3269, 3269, 3269, 3270, 3270, 3270, 3270, 3271, 3272, 3272, 3272, 3272, 3273, 3273, 3273, 3274, 3274, 3275, 3275, 3276, 3276, 3276, 3278, 3278, 3279, 3280, 3280, 3280, 3280, 3281, 3282, 3284, 3284, 3284, 3285, 3285, 3285, 3285, 3286, 3286, 3287, 3288, 3288, 3289, 3289, 3289, 3289, 3290, 3292, 3292, 3292, 3293, 3293, 3293, 3293, 3294, 3294, 3297, 3297, 3298, 3299, 3301, 3301, 3302, 3302, 3302, 3302, 3303, 3304, 3305, 3305, 3305, 3305, 3306, 3306, 3306, 3306, 3306, 3306, 3308, 3308, 3308, 3308, 3309, 3309, 3310, 3310, 3311, 3311, 3311, 3311, 3312, 3313, 3313, 3313, 3314, 3314, 3315, 3315, 3316, 3318, 3320, 3320, 3321, 3321, 3321, 3322, 3322, 3323, 3323, 3323, 3324, 3324, 3327, 3329, 3329, 3330, 3330, 3330, 3331, 3331, 3331, 3331, 3331, 3333, 3334, 3335, 3336, 3336, 3336, 3337, 3337, 3337, 3338, 3338, 3339, 3339, 3339, 3339, 3340, 3340, 3340, 3340, 3341, 3341, 3341, 3344, 3345, 3345, 3346, 3347, 3347, 3347, 3347, 3347, 3348, 3348, 3348, 3348, 3349, 3349, 3349, 3350, 3350, 3351, 3351, 3352, 3352, 3352, 3352, 3353, 3354, 3357, 3358, 3358, 3358, 3358, 3359, 3359, 3359, 3360, 3360, 3361, 3361, 3361, 3362, 3363, 3363, 3363, 3365, 3365, 3367, 3367, 3367, 3368, 3369, 3369, 3369, 3370, 3370, 3371, 3372, 3372, 3373, 3374, 3374, 3377, 3377, 3377, 3377, 3378, 3379, 3379, 3380, 3380, 3381, 3381, 3382, 3383, 3383, 3383, 3384, 3384, 3385, 3385, 3385, 3386, 3386, 3387, 3387, 3388, 3388, 3388, 3389, 3389, 3389, 3390, 3392, 3393, 3394, 3394, 3394, 3395, 3396, 3397, 3397, 3397, 3398, 3398, 3398, 3398, 3399, 3399, 3400, 3400, 3400, 3401, 3401, 3402, 3402, 3402, 3402, 3403, 3403, 3405, 3405, 3405, 3405, 3405, 3406, 3407, 3407, 3408, 3410, 3410, 3411, 3411, 3411, 3412, 3412, 3412, 3413, 3414, 3414, 3414, 3414, 3415, 3415, 3417, 3419, 3419, 3420, 3420, 3420, 3421, 3421, 3421, 3422, 3422, 3423, 3423, 3423, 3423, 3424, 3425, 3425, 3425, 3426, 3427, 3427, 3428, 3428, 3429, 3429, 3430, 3431, 3431, 3431, 3432, 3432, 3432, 3434, 3435, 3435, 3435, 3436, 3437, 3438, 3438, 3438, 3439, 3439, 3439, 3440, 3440, 3441, 3441, 3442, 3443, 3443, 3443, 3444, 3444, 3444, 3445, 3445, 3445, 3446, 3446, 3447, 3447, 3447, 3448, 3448, 3449, 3449, 3449, 3450, 3450, 3450, 3451, 3452, 3452, 3453, 3453, 3454, 3454, 3454, 3454, 3455, 3456, 3456, 3456, 3457, 3457, 3460, 3461, 3461, 3461, 3462, 3462, 3462, 3463, 3463, 3463, 3463, 3463, 3464, 3464, 3464, 3466, 3467, 3467, 3467, 3468, 3468, 3469, 3470, 3471, 3472, 3473, 3473, 3473, 3474, 3475, 3475, 3475, 3476, 3476, 3476, 3478, 3479, 3479, 3480, 3481, 3481, 3481, 3482, 3483, 3484, 3484, 3485, 3485, 3486, 3486, 3486, 3486, 3487, 3487, 3487, 3487, 3489, 3489, 3490, 3490, 3490, 3491, 3491, 3491, 3492, 3492, 3493, 3493, 3494, 3494, 3494, 3495, 3495, 3495, 3495, 3495, 3495, 3495, 3496, 3497, 3497, 3498, 3498, 3499, 3499, 3499, 3499, 3500, 3501, 3501, 3503, 3503, 3503, 3504, 3504, 3504, 3504, 3504, 3505, 3505, 3505, 3506, 3507, 3508, 3508, 3508, 3511, 3511, 3511, 3511, 3511, 3511, 3511, 3512, 3512, 3512, 3512, 3513, 3514, 3514, 3514, 3515, 3515, 3516, 3517, 3517, 3518, 3518, 3518, 3518, 3519, 3520, 3520, 3520, 3520, 3521, 3521, 3521, 3521, 3521, 3524, 3525, 3527, 3528, 3528, 3530, 3530, 3531, 3532, 3532, 3533, 3534, 3534, 3534, 3535, 3535, 3535, 3535, 3536, 3537, 3537, 3538, 3539, 3539, 3539, 3539, 3540, 3540, 3540, 3541, 3541, 3541, 3543, 3544, 3544, 3547, 3548, 3548, 3549, 3549, 3550, 3551, 3551, 3551, 3551, 3552, 3553, 3553, 3553, 3553, 3554, 3554, 3554, 3554, 3555, 3555, 3556, 3556, 3557, 3558, 3558, 3558, 3558, 3559, 3559, 3560, 3560, 3560, 3561, 3561, 3562, 3562, 3563, 3565, 3566, 3566, 3566, 3566, 3567, 3567, 3567, 3567, 3568, 3569, 3569, 3570, 3570, 3571, 3572, 3572, 3573, 3573, 3573, 3574, 3574, 3575, 3575, 3576, 3577, 3578, 3579, 3581, 3581, 3582, 3582, 3582, 3583, 3583, 3583, 3583, 3583, 3584, 3584, 3585, 3586, 3586, 3587, 3587, 3588, 3588, 3588, 3589, 3591, 3591, 3593, 3594, 3594, 3595, 3596, 3596, 3597, 3599, 3599, 3599, 3600, 3600, 3600, 3601, 3601, 3602, 3602, 3602, 3603, 3604, 3605, 3607, 3608, 3609, 3609, 3609, 3609, 3610, 3610, 3611, 3612, 3612, 3613, 3614, 3614, 3615, 3615, 3615, 3615, 3615, 3616, 3617, 3617, 3617, 3617, 3619, 3619, 3619, 3621, 3621, 3621, 3622, 3623, 3624, 3624, 3625, 3627, 3628, 3628, 3628, 3628, 3629, 3630, 3630, 3630, 3631, 3631, 3631, 3631, 3632, 3633, 3633, 3633, 3634, 3634, 3634, 3636, 3637, 3638, 3638, 3638, 3639, 3639, 3639, 3639, 3641, 3642, 3642, 3642, 3643, 3643, 3643, 3643, 3644, 3644, 3645, 3646, 3646, 3647, 3647, 3647, 3647, 3648, 3648, 3649, 3649, 3650, 3650, 3651, 3652, 3652, 3653, 3653, 3654, 3655, 3656, 3656, 3657, 3658, 3659, 3660, 3661, 3662, 3663, 3664, 3664, 3664, 3665, 3666, 3667, 3667, 3668, 3669, 3669, 3669, 3670, 3670, 3671, 3671, 3672, 3672, 3673, 3677, 3678, 3678, 3678, 3678, 3679, 3679, 3679, 3681, 3681, 3681, 3682, 3682, 3683, 3683, 3684, 3684, 3685, 3685, 3685, 3687, 3687, 3687, 3688, 3688, 3688, 3688, 3688, 3689, 3690, 3690, 3690, 3693, 3693, 3694, 3694, 3695, 3695, 3696, 3698, 3698, 3699, 3699, 3700, 3702, 3703, 3704, 3705, 3705, 3705, 3705, 3706, 3706, 3706, 3706, 3706, 3707, 3707, 3707, 3708, 3708, 3710, 3710, 3710, 3711, 3712, 3713, 3713, 3713, 3713, 3714, 3714, 3714, 3715, 3715, 3716, 3716, 3717, 3717, 3717, 3717, 3718, 3718, 3718, 3718, 3719, 3719, 3719, 3720, 3720, 3721, 3721, 3722, 3722, 3722, 3722, 3722, 3723, 3724, 3725, 3726, 3727, 3727, 3728, 3728, 3729, 3729, 3731, 3731, 3731, 3731, 3731, 3732, 3734, 3734, 3734, 3734, 3735, 3735, 3736, 3736, 3736, 3736, 3737, 3738, 3739, 3739, 3739, 3740, 3740, 3740, 3741, 3741, 3741, 3742, 3742, 3743, 3744, 3744, 3744, 3745, 3745, 3745, 3746, 3746, 3747, 3747, 3747, 3748, 3748, 3749, 3751, 3751, 3751, 3751, 3751, 3752, 3753, 3753, 3753, 3753, 3754, 3755, 3756, 3757, 3757, 3758, 3758, 3758, 3759, 3759, 3759, 3762, 3763, 3763, 3763, 3763, 3764, 3765, 3765, 3766, 3766, 3766, 3766, 3767, 3767, 3768, 3768, 3769, 3769, 3770, 3770, 3770, 3770, 3771, 3771, 3772, 3772, 3773, 3773, 3774, 3775, 3775, 3776, 3776, 3776, 3776, 3776, 3777, 3777, 3779, 3779, 3779, 3779, 3780, 3780, 3781, 3781, 3782, 3783, 3783, 3784, 3785, 3785, 3787, 3787, 3787, 3788, 3788, 3788, 3788, 3789, 3789, 3790, 3790, 3791, 3792, 3792, 3792, 3793, 3793, 3794, 3794, 3795, 3795, 3796, 3797, 3797, 3797, 3797, 3798, 3798, 3799, 3800, 3800, 3800, 3800, 3801, 3801, 3801, 3802, 3802, 3802, 3802, 3803, 3804, 3805, 3806, 3806, 3807, 3808, 3808, 3809, 3809, 3811, 3813, 3814, 3814, 3816, 3816, 3816, 3817, 3818, 3819, 3820, 3820, 3821, 3821, 3821, 3822, 3822, 3822, 3825, 3825, 3825, 3825, 3826, 3828, 3828, 3828, 3829, 3830, 3830, 3830, 3830, 3831, 3831, 3831, 3832, 3832, 3833, 3833, 3833, 3833, 3834, 3835, 3835, 3836, 3837, 3837, 3837, 3837, 3838, 3838, 3838, 3839, 3841, 3841, 3842, 3842, 3842, 3842, 3843, 3843, 3843, 3843, 3843, 3844, 3844, 3844, 3845, 3846, 3847, 3847, 3848, 3849, 3850, 3850, 3851, 3851, 3851, 3854, 3854, 3854, 3855, 3855, 3856, 3857, 3858, 3858, 3858, 3859, 3859, 3859, 3859, 3860, 3860, 3861, 3861, 3861, 3861, 3862, 3862, 3862, 3862, 3863, 3863, 3865, 3865, 3865, 3865, 3866, 3866, 3867, 3867, 3867, 3867, 3868, 3868, 3869, 3869, 3870, 3871, 3871, 3871, 3872, 3873, 3873, 3873, 3874, 3874, 3874, 3875, 3875, 3876, 3877, 3878, 3878, 3878, 3879, 3879, 3879, 3880, 3880, 3881, 3881, 3881, 3881, 3883, 3883, 3884, 3884, 3884, 3884, 3884, 3886, 3887, 3887, 3887, 3887, 3888, 3888, 3889, 3890, 3890, 3891, 3891, 3891, 3891, 3892, 3892, 3892, 3892, 3893, 3893, 3893, 3893, 3894, 3894, 3894, 3895, 3895, 3895, 3895, 3897, 3897, 3897, 3899, 3899, 3900, 3901, 3902, 3904, 3904, 3905, 3905, 3906, 3906, 3906, 3907, 3907, 3907, 3908, 3909, 3910, 3911, 3911, 3912, 3913, 3914, 3915, 3915, 3915, 3915, 3916, 3917, 3917, 3917, 3919, 3919, 3919, 3920, 3921, 3921, 3922, 3922, 3923, 3923, 3923, 3924, 3924, 3925, 3925, 3926, 3926, 3926, 3928, 3928, 3928, 3929, 3929, 3930, 3930, 3930, 3931, 3931, 3931, 3932, 3932, 3932, 3932, 3932, 3933, 3933, 3933, 3934, 3934, 3934, 3935, 3935, 3935, 3935, 3936, 3937, 3937, 3937, 3938, 3938, 3939, 3942, 3942, 3943, 3943, 3943, 3945, 3945, 3945, 3946, 3947, 3947, 3948, 3948, 3948, 3948, 3948, 3951, 3952, 3952, 3952, 3952, 3953, 3954, 3954, 3956, 3957, 3957, 3957, 3957, 3958, 3958, 3958, 3959, 3960, 3961, 3961, 3961, 3962, 3963, 3964, 3964, 3964, 3965, 3965, 3965, 3965, 3967, 3968, 3969, 3969, 3970, 3970, 3971, 3972, 3972, 3973, 3973, 3974, 3974, 3975, 3975, 3976, 3976, 3977, 3977, 3977, 3977, 3978, 3978, 3979, 3979, 3979, 3979, 3979, 3980, 3980, 3981, 3981, 3981, 3981, 3982, 3982, 3982, 3982, 3983, 3984, 3984, 3984, 3984, 3984, 3984, 3986, 3986, 3986, 3987, 3988, 3988, 3988, 3988, 3989, 3989, 3989, 3990, 3990, 3991, 3992, 3993, 3994, 3995, 3996, 3996, 3998, 3998, 3998, 3999, 4000, 4000, 4000, 4001, 4001, 4001, 4001, 4002, 4002, 4002, 4002, 4003, 4004, 4004, 4004, 4005, 4006, 4006, 4007, 4007, 4008, 4008, 4008, 4009, 4010, 4010, 4010, 4010, 4011, 4011, 4013, 4014, 4015, 4016, 4017, 4018, 4018, 4019, 4020, 4020, 4020, 4021, 4021, 4022, 4022, 4022, 4023, 4023, 4023, 4024, 4024, 4025, 4025, 4025, 4026, 4026, 4027, 4027, 4028, 4028, 4028, 4029, 4030, 4031, 4031, 4031, 4031, 4032, 4032, 4032, 4032, 4033, 4033, 4033, 4033, 4035, 4035, 4035, 4035, 4035, 4037, 4038, 4038, 4038, 4038, 4038, 4039, 4039, 4039, 4040, 4040, 4040, 4041, 4041, 4041, 4041, 4041, 4041, 4041, 4042, 4042, 4043, 4043, 4043, 4043, 4044, 4044, 4045, 4045, 4045, 4047, 4047, 4048, 4048, 4049, 4050, 4050, 4050, 4051, 4052, 4052, 4053, 4053, 4054, 4055, 4055, 4056, 4056, 4057, 4058, 4058, 4059, 4059, 4060, 4060, 4060, 4061, 4061, 4061, 4062, 4063, 4063, 4064, 4065, 4065, 4065, 4066, 4067, 4068, 4068, 4068, 4069, 4069, 4069, 4070, 4070, 4070, 4071, 4071, 4072, 4072, 4072, 4072, 4072, 4073, 4073, 4074, 4074, 4075, 4076, 4076, 4076, 4076, 4077, 4077, 4078, 4078, 4078, 4080, 4081, 4081, 4082, 4082, 4082, 4083, 4083, 4085, 4085, 4085, 4085, 4085, 4086, 4086, 4086, 4087, 4087, 4087, 4088, 4088, 4089, 4089, 4090, 4090, 4091, 4091, 4092, 4093, 4093, 4093, 4094, 4095, 4096, 4096, 4096, 4097, 4097, 4098, 4099, 4099, 4099, 4099, 4100, 4100, 4101, 4101, 4102, 4102, 4103, 4104, 4104, 4104, 4104, 4104, 4105, 4106, 4106, 4106, 4106, 4107, 4108, 4108, 4109, 4109, 4109, 4109, 4110, 4111, 4112, 4112, 4112, 4112, 4112, 4113, 4113, 4114, 4114, 4114, 4115, 4115, 4116, 4116, 4117, 4117, 4117, 4118, 4118, 4118, 4119, 4119, 4121, 4121, 4122, 4122, 4122, 4123, 4124, 4125, 4125, 4126, 4127, 4129, 4129, 4130, 4131, 4131, 4132, 4132, 4132, 4134, 4134, 4134, 4135, 4135, 4135, 4135, 4135, 4135, 4135, 4135, 4136, 4136, 4136, 4136, 4136, 4136, 4137, 4137, 4137, 4139, 4140, 4140, 4140, 4141, 4141, 4142, 4142, 4142, 4143, 4144, 4144, 4144, 4144, 4145, 4145, 4145, 4145, 4146, 4147, 4147, 4147, 4148, 4148, 4148, 4149, 4149, 4149, 4149, 4149, 4150, 4150, 4151, 4153, 4153, 4154, 4155, 4155, 4156, 4156, 4156, 4157, 4158, 4158, 4159, 4159, 4160, 4160, 4161, 4161, 4161, 4161, 4163, 4163, 4163, 4164, 4164, 4164, 4164, 4165, 4165, 4165, 4166, 4166, 4166, 4167, 4168, 4169, 4170, 4170, 4170, 4171, 4171, 4172, 4173, 4173, 4173, 4173, 4174, 4175, 4175, 4176, 4176, 4176, 4177, 4177, 4177, 4177, 4178, 4178, 4179, 4179, 4179, 4179, 4179, 4179, 4179, 4180, 4180, 4180, 4181, 4181, 4181, 4181, 4182, 4182, 4183, 4184, 4185, 4186, 4187, 4187, 4187, 4188, 4188, 4188, 4189, 4189, 4189, 4189, 4190, 4190, 4190, 4190, 4190, 4191, 4192, 4192, 4192, 4192, 4194, 4195, 4196, 4196, 4196, 4196, 4197, 4197, 4198, 4198, 4198, 4198, 4200, 4200, 4201, 4202, 4202, 4203, 4203, 4204, 4205, 4205, 4207, 4210, 4210, 4210, 4210, 4211, 4211, 4213, 4214, 4214, 4215, 4215, 4215, 4216, 4216, 4216, 4217, 4217, 4218, 4218, 4218, 4218, 4218, 4219, 4220, 4220, 4220, 4221, 4222, 4223, 4223, 4223, 4225, 4225, 4226, 4226, 4227, 4227, 4228, 4228, 4228, 4228, 4229, 4230, 4230, 4232, 4233, 4233, 4233, 4233, 4234, 4235, 4235, 4235, 4235, 4236, 4236, 4236, 4237, 4238, 4238, 4238, 4238, 4238, 4239, 4239, 4239, 4239, 4239, 4240, 4240, 4241, 4243, 4243, 4243, 4243, 4243, 4243, 4244, 4244, 4244, 4244, 4244, 4245, 4245, 4245, 4247, 4247, 4247, 4248, 4248, 4249, 4249, 4249, 4250, 4250, 4250, 4251, 4251, 4252, 4252, 4253, 4253, 4253, 4253, 4253, 4254, 4255, 4255, 4255, 4256, 4256, 4257, 4257, 4257, 4258, 4258, 4258, 4258, 4259, 4259, 4260, 4260, 4261, 4261, 4261, 4261, 4261, 4261, 4262, 4262, 4262, 4263, 4264, 4265, 4265, 4265, 4266, 4267, 4268, 4269, 4269, 4269, 4270, 4270, 4271, 4271, 4271, 4272, 4272, 4273, 4273, 4273, 4273, 4274, 4274, 4274, 4275, 4275, 4277, 4279, 4279, 4280, 4280, 4280, 4281, 4281, 4282, 4282, 4282, 4282, 4282, 4283, 4283, 4283, 4283, 4284, 4285, 4285, 4285, 4285, 4285, 4286, 4286, 4287, 4287, 4287, 4287, 4288, 4289, 4290, 4290, 4291, 4291, 4291, 4292, 4293, 4293, 4293, 4293, 4294, 4294, 4295, 4296, 4297, 4297, 4297, 4297, 4297, 4297, 4298, 4299, 4299, 4299, 4299, 4300, 4300, 4301, 4301, 4302, 4302, 4302, 4302, 4303, 4304, 4305, 4306, 4306, 4306, 4307, 4307, 4308, 4308, 4309, 4309, 4309, 4309, 4310, 4311, 4311, 4312, 4312, 4312, 4312, 4312, 4313, 4314, 4315, 4315, 4316, 4316, 4317, 4317, 4317, 4318, 4318, 4319, 4319, 4320, 4320, 4321, 4322, 4322, 4323, 4325, 4327, 4327, 4327, 4327, 4327, 4328, 4328, 4330, 4330, 4330, 4331, 4331, 4332, 4332, 4334, 4335, 4335, 4336, 4336, 4337, 4337, 4338, 4338, 4338, 4338, 4339, 4339, 4339, 4340, 4340, 4340, 4340, 4340, 4340, 4341, 4341, 4341, 4343, 4343, 4344, 4344, 4344, 4345, 4346, 4347, 4347, 4348, 4348, 4348, 4352, 4353, 4355, 4356, 4356, 4357, 4357, 4358, 4358, 4358, 4358, 4359, 4360, 4360, 4360, 4361, 4361, 4361, 4361, 4362, 4362, 4363, 4363, 4364, 4365, 4365, 4365, 4368, 4370, 4370, 4370, 4371, 4371, 4371, 4372, 4372, 4372, 4372, 4374, 4374, 4374, 4375, 4375, 4376, 4376, 4377, 4377, 4380, 4380, 4381, 4381, 4381, 4382, 4382, 4384, 4386, 4386, 4387, 4387, 4389, 4389, 4389, 4389, 4389, 4389, 4390, 4391, 4391, 4392, 4393, 4393, 4394, 4394, 4394, 4394, 4395, 4395, 4396, 4398, 4398, 4398, 4399, 4400, 4400, 4400, 4401, 4401, 4402, 4403, 4403, 4403, 4404, 4405, 4405, 4405, 4407, 4408, 4408, 4408, 4409, 4410, 4410, 4410, 4410, 4411, 4411, 4412, 4412, 4413, 4413, 4414, 4414, 4414, 4414, 4414, 4415, 4415, 4419, 4419, 4419, 4419, 4420, 4420, 4420, 4421, 4421, 4421, 4421, 4423, 4424, 4425, 4426, 4427, 4427, 4428, 4429, 4429, 4430, 4430, 4430, 4431, 4431, 4431, 4431, 4432, 4432, 4432, 4432, 4432, 4432, 4433, 4433, 4434, 4434, 4435, 4435, 4435, 4435, 4436, 4436, 4436, 4436, 4437, 4437, 4438, 4438, 4438, 4438, 4438, 4439, 4439, 4440, 4440, 4441, 4441, 4442, 4443, 4444, 4444, 4446, 4446, 4447, 4447, 4447, 4448, 4448, 4448, 4449, 4450, 4451, 4452, 4453, 4453, 4454, 4454, 4455, 4455, 4455, 4456, 4456, 4456, 4457, 4457, 4457, 4457, 4457, 4457, 4457, 4457, 4459, 4460, 4460, 4461, 4462, 4462, 4462, 4462, 4465, 4465, 4466, 4467, 4468, 4468, 4469, 4470, 4470, 4471, 4471, 4471, 4471, 4471, 4471, 4471, 4471, 4472, 4472, 4472, 4473, 4473, 4474, 4474, 4474, 4475, 4475, 4476, 4477, 4479, 4479, 4479, 4479, 4481, 4481, 4481, 4481, 4482, 4482, 4482, 4483, 4483, 4484, 4484, 4486, 4487, 4487, 4487, 4487, 4487, 4488, 4488, 4488, 4489, 4491, 4491, 4492, 4492, 4493, 4493, 4494, 4494, 4494, 4494, 4494, 4495, 4495, 4495, 4496, 4496, 4496, 4497, 4498, 4499, 4500, 4500, 4501, 4501, 4503, 4503, 4503, 4504, 4504, 4506, 4509, 4509, 4509, 4509, 4510, 4510, 4511, 4511, 4511, 4512, 4513, 4513, 4514, 4514, 4514, 4515, 4517, 4518, 4521, 4521, 4521, 4521, 4522, 4523, 4523, 4524, 4524, 4525, 4525, 4525, 4525, 4525, 4526, 4526, 4527, 4527, 4528, 4528, 4528, 4529, 4529, 4529, 4529, 4530, 4531, 4532, 4533, 4533, 4534, 4535, 4536, 4536, 4536, 4536, 4537, 4537, 4538, 4539, 4539, 4542, 4542, 4542, 4543, 4543, 4543, 4544, 4544, 4546, 4547, 4547, 4548, 4548, 4549, 4549, 4550, 4550, 4551, 4552, 4552, 4552, 4553, 4553, 4554, 4554, 4554, 4554, 4554, 4555, 4555, 4556, 4556, 4557, 4557, 4558, 4558, 4559, 4559, 4559, 4560, 4560, 4562, 4563, 4563, 4564, 4565, 4566, 4566, 4566, 4567, 4567, 4567, 4567, 4567, 4568, 4568, 4568, 4569, 4569, 4570, 4571, 4572, 4572, 4572, 4572, 4573, 4574, 4574, 4574, 4575, 4575, 4575, 4575, 4575, 4575, 4576, 4576, 4577, 4577, 4578, 4578, 4578, 4579, 4579, 4579, 4579, 4580, 4580, 4580, 4580, 4580, 4581, 4581, 4582, 4583, 4584, 4584, 4586, 4586, 4587, 4588, 4589, 4590, 4590, 4592, 4592, 4592, 4593, 4594, 4594, 4594, 4595, 4595, 4595, 4596, 4597, 4597, 4597, 4598, 4598, 4600, 4600, 4600, 4600, 4601, 4601, 4602, 4602, 4602, 4603, 4604, 4604, 4605, 4605, 4605, 4606, 4607, 4608, 4608, 4608, 4609, 4609, 4609, 4610, 4611, 4611, 4612, 4612, 4614, 4614, 4614, 4614, 4615, 4615, 4616, 4616, 4616, 4616, 4617, 4617, 4617, 4617, 4618, 4618, 4618, 4618, 4620, 4621, 4621, 4621, 4622, 4623, 4623, 4623, 4624, 4624, 4625, 4625, 4626, 4626, 4627, 4627, 4627, 4629, 4629, 4630, 4630, 4631, 4631, 4631, 4631, 4631, 4631, 4632, 4633, 4634, 4634, 4634, 4635, 4635, 4635, 4635, 4636, 4636, 4636, 4636, 4637, 4637, 4638, 4639, 4639, 4640, 4640, 4640, 4641, 4641, 4642, 4643, 4643, 4643, 4644, 4644, 4645, 4646, 4646, 4647, 4648, 4649, 4649, 4649, 4649, 4651, 4651, 4653, 4654, 4655, 4655, 4656, 4656, 4657, 4658, 4658, 4658, 4659, 4659, 4659, 4659, 4659, 4660, 4661, 4662, 4662, 4663, 4663, 4664, 4664, 4665, 4665, 4666, 4666, 4666, 4667, 4667, 4668, 4669, 4669, 4669, 4669, 4670, 4670, 4670, 4671, 4673, 4673, 4674, 4674, 4674, 4674, 4675, 4675, 4675, 4676, 4677, 4678, 4678, 4679, 4679, 4679, 4679, 4680, 4680, 4681, 4681, 4683, 4683, 4683, 4683, 4684, 4684, 4685, 4685, 4686, 4686, 4687, 4687, 4688, 4690, 4690, 4690, 4690, 4691, 4691, 4693, 4693, 4693, 4693, 4693, 4695, 4695, 4697, 4697, 4698, 4699, 4699, 4700, 4700, 4700, 4701, 4701, 4701, 4702, 4703, 4703, 4704, 4704, 4704, 4705, 4705, 4705, 4706, 4707, 4707, 4707, 4708, 4708, 4709, 4709, 4710, 4710, 4710, 4711, 4711, 4712, 4712, 4714, 4715, 4716, 4716, 4717, 4718, 4718, 4718, 4718, 4719, 4719, 4720, 4720, 4720, 4720, 4721, 4721, 4721, 4722, 4722, 4725, 4725, 4726, 4726, 4727, 4728, 4728, 4728, 4728, 4728, 4729, 4729, 4730, 4730, 4731, 4731, 4732, 4732, 4733, 4733, 4733, 4733, 4733, 4734, 4734, 4734, 4734, 4735, 4735, 4735, 4736, 4737, 4738, 4738, 4738, 4738, 4738, 4739, 4739, 4740, 4740, 4741, 4741, 4743, 4743, 4743, 4744, 4744, 4744, 4744, 4744, 4746, 4746, 4746, 4746, 4747, 4747, 4747, 4748, 4748, 4748, 4749, 4749, 4749, 4750, 4751, 4751, 4751, 4752, 4753, 4753, 4753, 4755, 4755, 4756, 4756, 4757, 4757, 4757, 4758, 4758, 4760, 4760, 4760, 4761, 4761, 4762, 4762, 4762, 4763, 4764, 4764, 4765, 4766, 4767, 4767, 4768, 4768, 4769, 4770, 4771, 4771, 4771, 4773, 4774, 4774, 4774, 4774, 4775, 4778, 4779, 4780, 4780, 4780, 4781, 4781, 4782, 4782, 4782, 4783, 4785, 4785, 4786, 4787, 4787, 4787, 4787, 4788, 4788, 4788, 4788, 4788, 4789, 4790, 4790, 4790, 4791, 4791, 4791, 4792, 4792, 4792, 4792, 4792, 4792, 4793, 4794, 4794, 4796, 4796, 4796, 4796, 4797, 4798, 4798, 4799, 4799, 4799, 4799, 4801, 4801, 4802, 4802, 4802, 4803, 4805, 4805, 4808, 4808, 4808, 4810, 4810, 4810, 4811, 4811, 4811, 4811, 4812, 4812, 4813, 4814, 4815, 4815, 4816, 4816, 4816, 4816, 4816, 4817, 4817, 4817, 4818, 4818, 4818, 4819, 4819, 4820, 4822, 4822, 4822, 4822, 4822, 4822, 4823, 4823, 4823, 4824, 4824, 4825, 4826, 4826, 4827, 4827, 4828, 4828, 4828, 4829, 4829, 4830, 4830, 4830, 4831, 4831, 4831, 4832, 4832, 4833, 4834, 4834, 4834, 4834, 4835, 4835, 4835, 4836, 4837, 4838, 4838, 4838, 4838, 4838, 4838, 4839, 4839, 4839, 4839, 4840, 4840, 4841, 4842, 4842, 4842, 4843, 4843, 4843, 4843, 4843, 4844, 4844, 4845, 4846, 4846, 4847, 4847, 4847, 4847, 4847, 4848, 4848, 4849, 4849, 4849, 4849, 4849, 4850, 4850, 4851, 4853, 4853, 4853, 4854, 4854, 4856, 4856, 4857, 4857, 4857, 4858, 4858, 4859, 4859, 4859, 4859, 4860, 4860, 4861, 4862, 4862, 4863, 4863, 4863, 4863, 4864, 4864, 4864, 4864, 4865, 4865, 4866, 4866, 4867, 4867, 4869, 4870, 4870, 4870, 4870, 4870, 4870, 4871, 4871, 4871, 4872, 4873, 4873, 4874, 4874, 4875, 4875, 4876, 4876, 4876, 4876, 4877, 4879, 4879, 4879, 4881, 4882, 4882, 4883, 4883, 4883, 4884, 4884, 4886, 4888, 4888, 4888, 4889, 4890, 4890, 4890, 4891, 4891, 4892, 4892, 4892, 4892, 4893, 4893, 4893, 4894, 4894, 4894, 4894, 4894, 4894, 4895, 4898, 4899, 4899, 4900, 4901, 4901, 4901, 4901, 4902, 4902, 4903, 4904, 4904, 4904, 4904, 4904, 4905, 4906, 4908, 4908, 4909, 4910, 4910, 4911, 4911, 4912, 4912, 4913, 4913, 4914, 4914, 4914, 4915, 4915, 4916, 4917, 4917, 4918, 4918, 4920, 4921, 4921, 4921, 4921, 4922, 4922, 4922, 4922, 4923, 4923, 4924, 4924, 4924, 4925, 4926, 4926, 4926, 4927, 4928, 4928, 4928, 4928, 4928, 4928, 4929, 4930, 4930, 4931, 4932, 4934, 4934, 4935, 4935, 4936, 4936, 4937, 4937, 4937, 4937, 4937, 4938, 4939, 4939, 4939, 4939, 4939, 4939, 4942, 4943, 4943, 4944, 4944, 4944, 4944, 4944, 4945, 4946, 4946, 4946, 4947, 4948, 4948, 4948, 4949, 4949, 4950, 4950, 4950, 4950, 4951, 4951, 4952, 4956, 4956, 4957, 4957, 4957, 4957, 4958, 4960, 4960, 4960, 4961, 4961, 4961, 4962, 4962, 4962, 4963, 4963, 4964, 4964, 4964, 4965, 4966, 4967, 4967, 4968, 4968, 4968, 4971, 4971, 4972, 4972, 4974, 4975, 4975, 4975, 4976, 4976, 4977, 4978, 4978, 4979, 4979, 4979, 4980, 4980, 4980, 4981, 4981, 4981, 4981, 4982, 4982, 4982, 4982, 4982, 4983, 4983, 4983, 4983, 4984, 4985, 4985, 4986, 4986, 4986, 4986, 4987, 4987, 4988, 4989, 4989, 4989, 4990, 4991, 4992, 4992, 4993, 4993, 4994, 4995, 4995, 4996, 4997, 4997, 4997, 4997, 4997, 4998, 4998, 4999, 4999 ]\n", bench_group_opt, ); } diff --git a/cli/tests/cli_run.rs b/cli/tests/cli_run.rs index 280290bd40..1d139a9eae 100644 --- a/cli/tests/cli_run.rs +++ b/cli/tests/cli_run.rs @@ -141,12 +141,11 @@ mod cli_run { #[test] #[serial(quicksort)] fn run_quicksort_not_optimized() { - check_output_with_stdin( - &example_file("benchmarks", "QuicksortApp.roc"), - "0", - "quicksortapp", + check_output( + &example_file("quicksort", "Quicksort.roc"), + "quicksort", &[], - "[ 0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 6, 6, 8, 9 ]\n", + "[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2]\n", true, ); } @@ -154,12 +153,11 @@ mod cli_run { #[test] #[serial(quicksort)] fn run_quicksort_optimized() { - check_output_with_stdin( - &example_file("benchmarks", "QuicksortApp.roc"), - "0", - "quicksortapp", + check_output( + &example_file("quicksort", "Quicksort.roc"), + "quicksort", &["--optimize"], - "[ 0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 6, 6, 8, 9 ]\n", + "[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2]\n", true, ); } @@ -167,12 +165,11 @@ mod cli_run { #[test] #[serial(quicksort)] fn run_quicksort_optimized_valgrind() { - check_output_with_stdin( - &example_file("benchmarks", "QuicksortApp.roc"), - "0", - "quicksortapp", + check_output( + &example_file("quicksort", "Quicksort.roc"), + "quicksort", &["--optimize"], - "[ 0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 6, 6, 8, 9 ]\n", + "[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2]\n", true, ); } diff --git a/examples/benchmarks/QuicksortApp.roc b/examples/benchmarks/QuicksortApp.roc index 198003bf13..a1290d2fae 100644 --- a/examples/benchmarks/QuicksortApp.roc +++ b/examples/benchmarks/QuicksortApp.roc @@ -11,8 +11,8 @@ main = # small unsorted list of 20 elements (0-9) [ 2, 4, 4, 0, 3, 8, 3, 6, 4, 9, 4, 6, 3, 5, 2, 2, 3, 1, 1, 3 ] else - # big unsorted list of 2000 elements (0-1000) - [ 891, 330, 190, 304, 991, 803, 54, 362, 428, 318, 59, 631, 995, 36, 711, 450, 654, 614, 74, 288, 198, 11, 369, 290, 7, 934, 72, 642, 955, 782, 724, 811, 3, 402, 517, 128, 902, 612, 454, 281, 794, 109, 497, 454, 238, 541, 215, 672, 4, 855, 908, 868, 177, 885, 460, 133, 367, 113, 131, 191, 148, 254, 914, 680, 735, 783, 225, 720, 708, 447, 625, 526, 529, 914, 126, 857, 574, 234, 249, 433, 779, 74, 275, 302, 315, 131, 518, 572, 301, 450, 346, 630, 928, 420, 183, 287, 420, 730, 512, 533, 69, 942, 214, 801, 196, 633, 13, 493, 343, 910, 462, 939, 394, 367, 619, 583, 674, 265, 113, 909, 202, 135, 859, 924, 214, 27, 30, 531, 662, 90, 917, 35, 236, 210, 456, 758, 338, 514, 590, 907, 106, 147, 625, 199, 766, 628, 894, 552, 108, 982, 94, 751, 734, 678, 371, 894, 204, 719, 559, 676, 362, 782, 959, 826, 793, 935, 17, 837, 179, 679, 819, 33, 197, 611, 719, 718, 688, 365, 36, 62, 349, 719, 598, 826, 135, 218, 889, 282, 948, 442, 345, 453, 386, 840, 95, 921, 293, 241, 494, 774, 139, 712, 373, 730, 301, 472, 805, 41, 355, 384, 188, 168, 869, 17, 339, 55, 238, 476, 394, 725, 130, 53, 978, 762, 418, 419, 920, 913, 780, 723, 750, 277, 92, 37, 979, 971, 882, 936, 190, 216, 452, 495, 450, 597, 567, 994, 587, 777, 700, 685, 991, 995, 533, 443, 945, 56, 186, 413, 239, 286, 234, 486, 399, 410, 853, 516, 443, 999, 591, 16, 452, 314, 459, 343, 296, 189, 84, 465, 640, 616, 122, 665, 379, 858, 930, 188, 47, 445, 959, 93, 244, 89, 610, 26, 952, 294, 77, 619, 775, 661, 291, 290, 443, 458, 689, 107, 517, 794, 827, 313, 506, 568, 264, 400, 485, 972, 430, 953, 258, 409, 305, 729, 288, 146, 133, 603, 568, 748, 891, 521, 199, 12, 714, 180, 848, 317, 947, 454, 166, 776, 907, 493, 195, 5, 631, 791, 86, 932, 809, 464, 80, 846, 323, 300, 658, 869, 712, 316, 551, 700, 438, 457, 516, 747, 54, 854, 636, 72, 352, 24, 159, 222, 844, 427, 369, 969, 208, 337, 663, 388, 624, 943, 781, 868, 563, 559, 638, 818, 205, 927, 265, 235, 713, 871, 617, 34, 751, 530, 36, 418, 251, 654, 213, 99, 799, 808, 439, 609, 263, 481, 113, 706, 185, 386, 776, 152, 178, 468, 922, 0, 942, 817, 428, 66, 399, 355, 450, 792, 549, 237, 532, 212, 254, 279, 941, 685, 211, 100, 994, 182, 503, 707, 368, 472, 297, 820, 905, 83, 319, 345, 47, 547, 769, 713, 204, 153, 687, 372, 656, 914, 448, 872, 73, 955, 318, 381, 254, 849, 719, 909, 905, 558, 471, 142, 136, 865, 392, 650, 342, 698, 199, 385, 673, 632, 14, 792, 523, 862, 872, 792, 957, 739, 713, 373, 72, 464, 667, 394, 933, 305, 332, 444, 960, 322, 900, 841, 146, 566, 723, 884, 355, 153, 49, 928, 689, 304, 467, 306, 952, 277, 943, 421, 216, 704, 525, 293, 974, 754, 978, 96, 582, 5, 811, 229, 304, 52, 610, 160, 872, 831, 388, 925, 216, 665, 435, 913, 753, 381, 452, 786, 737, 834, 191, 165, 16, 174, 997, 735, 976, 189, 340, 161, 653, 849, 447, 264, 950, 349, 4, 375, 312, 3, 279, 833, 600, 721, 205, 162, 832, 451, 998, 26, 689, 870, 215, 651, 419, 831, 70, 308, 596, 500, 624, 672, 481, 522, 390, 79, 410, 77, 336, 502, 10, 95, 697, 591, 385, 820, 807, 726, 537, 359, 772, 548, 768, 981, 838, 90, 599, 172, 272, 718, 417, 789, 578, 669, 786, 534, 403, 602, 180, 115, 205, 96, 573, 359, 830, 970, 431, 533, 342, 777, 600, 880, 374, 262, 704, 31, 710, 148, 264, 288, 501, 540, 851, 929, 420, 93, 5, 350, 80, 810, 8, 153, 369, 582, 908, 756, 523, 964, 124, 842, 152, 378, 946, 720, 425, 975, 844, 211, 378, 963, 966, 297, 763, 891, 180, 505, 33, 201, 377, 167, 35, 600, 698, 801, 977, 378, 361, 35, 401, 479, 266, 758, 32, 956, 943, 705, 860, 737, 791, 727, 162, 997, 213, 785, 804, 292, 56, 651, 567, 547, 866, 531, 835, 875, 122, 721, 202, 632, 895, 117, 676, 522, 993, 357, 867, 49, 797, 655, 91, 608, 838, 322, 582, 736, 708, 65, 39, 325, 126, 619, 135, 161, 523, 228, 414, 610, 339, 952, 691, 612, 238, 400, 846, 861, 313, 161, 752, 920, 136, 650, 939, 920, 262, 358, 899, 505, 738, 155, 783, 743, 359, 605, 330, 805, 662, 608, 617, 894, 387, 568, 235, 539, 799, 58, 943, 937, 234, 386, 819, 917, 405, 490, 113, 353, 444, 437, 361, 357, 225, 656, 551, 973, 305, 892, 30, 665, 920, 716, 126, 294, 72, 635, 590, 451, 89, 236, 714, 44, 698, 401, 271, 670, 371, 919, 397, 141, 484, 847, 630, 813, 247, 414, 239, 943, 691, 277, 357, 212, 480, 220, 293, 441, 314, 193, 193, 734, 687, 515, 802, 964, 127, 547, 918, 638, 234, 145, 790, 715, 555, 160, 754, 646, 329, 861, 637, 195, 762, 33, 605, 618, 78, 938, 668, 940, 454, 606, 309, 518, 635, 211, 101, 753, 532, 743, 730, 231, 608, 516, 422, 457, 346, 155, 569, 947, 51, 334, 172, 123, 295, 885, 778, 428, 980, 621, 805, 169, 808, 316, 401, 639, 769, 118, 698, 618, 105, 744, 174, 353, 752, 957, 257, 497, 743, 260, 872, 590, 815, 543, 906, 501, 760, 358, 325, 621, 780, 189, 262, 51, 439, 341, 290, 829, 303, 705, 477, 886, 137, 6, 383, 303, 7, 149, 59, 125, 83, 877, 83, 378, 444, 318, 402, 810, 404, 329, 812, 4, 885, 44, 866, 489, 907, 860, 727, 582, 139, 808, 704, 619, 74, 909, 242, 879, 566, 221, 534, 628, 23, 916, 590, 303, 489, 523, 958, 563, 728, 657, 250, 195, 500, 88, 907, 310, 353, 745, 563, 64, 455, 91, 390, 393, 697, 65, 786, 240, 222, 617, 216, 125, 597, 913, 170, 591, 495, 840, 278, 966, 968, 978, 843, 655, 9, 557, 249, 490, 202, 550, 83, 619, 220, 351, 853, 816, 455, 561, 4, 376, 901, 300, 33, 739, 262, 991, 948, 234, 717, 857, 527, 902, 789, 624, 203, 445, 911, 288, 700, 823, 773, 970, 526, 967, 687, 144, 745, 123, 833, 889, 676, 14, 47, 96, 876, 832, 276, 60, 148, 266, 782, 456, 592, 736, 78, 451, 724, 581, 718, 993, 287, 386, 938, 243, 312, 736, 495, 493, 908, 961, 999, 404, 542, 880, 679, 433, 394, 417, 888, 448, 502, 732, 516, 22, 606, 338, 776, 711, 936, 270, 986, 275, 834, 335, 122, 287, 966, 378, 854, 233, 539, 687, 436, 193, 241, 899, 791, 698, 784, 618, 267, 194, 562, 102, 220, 866, 723, 422, 460, 924, 308, 925, 113, 508, 878, 547, 739, 475, 823, 645, 938, 959, 0, 758, 574, 706, 19, 127, 167, 344, 845, 740, 361, 768, 560, 72, 360, 866, 753, 992, 946, 929, 461, 371, 875, 599, 907, 669, 862, 67, 301, 101, 962, 827, 762, 499, 168, 183, 207, 416, 81, 333, 856, 202, 717, 533, 892, 625, 573, 313, 672, 805, 384, 294, 223, 0, 905, 410, 489, 474, 986, 842, 661, 66, 73, 918, 512, 211, 968, 26, 523, 631, 249, 621, 907, 474, 146, 388, 292, 873, 2, 404, 31, 713, 206, 225, 861, 983, 659, 743, 426, 798, 152, 9, 355, 195, 410, 618, 687, 210, 1, 928, 588, 461, 217, 132, 598, 151, 88, 320, 352, 439, 934, 968, 542, 323, 184, 227, 759, 383, 335, 146, 223, 400, 438, 451, 334, 837, 616, 753, 864, 162, 129, 913, 564, 17, 935, 951, 561, 977, 940, 956, 979, 508, 547, 513, 880, 700, 874, 485, 924, 788, 223, 162, 836, 965, 679, 696, 68, 975, 704, 44, 393, 777, 473, 209, 273, 471, 418, 350, 116, 669, 335, 639, 747, 40, 334, 417, 625, 427, 240, 248, 928, 170, 856, 159, 344, 328, 872, 123, 400, 376, 921, 934, 24, 793, 734, 839, 894, 926, 318, 389, 228, 977, 946, 613, 274, 973, 879, 757, 898, 499, 883, 405, 798, 861, 580, 577, 587, 25, 159, 391, 80, 708, 404, 593, 510, 389, 995, 786, 602, 931, 668, 368, 256, 333, 319, 918, 469, 997, 508, 334, 729, 227, 67, 666, 873, 921, 238, 112, 944, 238, 455, 287, 274, 920, 335, 820, 436, 900, 822, 880, 235, 5, 578, 502, 666, 750, 859, 467, 510, 969, 309, 369, 618, 312, 868, 999, 147, 588, 229, 967, 519, 638, 619, 982, 630, 48, 275, 807, 218, 906, 677, 841, 563, 530, 32, 494, 744, 753, 148, 43, 26, 679, 390, 135, 405, 746, 410, 487, 965, 475, 751, 199, 271, 20, 823, 833, 345, 217, 63, 13, 70, 982, 713, 491, 397, 670, 618, 85, 186, 389, 804, 355, 206, 950, 419, 637, 619, 180, 194, 773, 713, 508, 229, 77, 252, 30, 402, 558, 326, 385, 335, 995, 178, 398, 3, 116, 148, 733, 98, 447, 154, 329, 699, 104, 626, 816, 137, 43, 29, 402, 333, 292, 832, 823, 132, 449, 76, 288, 746, 730, 955, 79, 105, 52, 760, 429, 490, 377, 567, 469, 482, 614, 351, 672, 613, 942, 369, 72, 214, 54, 964, 382, 63, 18, 853, 775, 166, 551, 86, 980, 443, 659, 807, 835, 620, 288, 474, 663, 910, 935, 487, 851, 527, 763, 149, 139, 79, 333, 852, 374, 462, 241, 363, 195, 311, 822, 511, 187, 886, 180, 558, 222, 800, 66, 785, 990, 396, 243, 215, 248, 684, 780, 160, 661, 563, 457, 241, 711, 426, 296, 387, 506, 252, 289, 517, 923, 193, 787, 32, 222, 394, 692, 338, 684, 289, 809, 262, 351, 906, 231, 150, 692, 776, 187, 166, 903, 378, 583, 81, 704, 851, 552, 352, 132, 476, 759, 254, 178, 894, 183, 193, 907, 665, 683, 317, 360, 269, 348, 243, 835, 975, 193, 719, 82, 533, 874, 674, 43, 628, 167, 930, 332, 511, 176, 753, 42, 123, 768, 168, 943, 707, 783, 939, 714, 57, 799, 487, 332, 401, 335, 851, 965, 483, 654, 743, 436, 679, 675, 293, 324, 229, 337, 151, 88, 121, 469, 896, 213, 917, 608, 535, 130, 779, 672, 768, 632, 926, 29, 31, 899, 699, 4, 727, 587, 571, 830, 477, 532, 898, 293, 785, 915, 602, 291, 797, 210, 324, 711, 330, 746, 675, 149, 148, 235, 566, 212, 381, 126, 620, 49, 349, 392, 736, 693, 124, 703, 185, 569, 8, 785, 585, 488, 720, 269, 683, 457, 643, 181, 453, 976, 255, 175, 234, 644, 479, 146, 153, 719, 38, 682, 995, 865, 507, 606, 184, 886, 371, 210, 438, 123, 941, 139, 624, 854, 908, 860, 992, 372, 16, 282, 298, 270, 402, 693, 261, 402, 106, 379, 639, 156, 616, 395, 865, 409, 526, 27, 373, 604, 486, 786, 685, 814, 364, 595, 847, 792, 187, 266, 589, 981, 873, 213, 221, 293, 932, 278, 487, 760, 789, 687, 306, 680, 269, 593, 998, 790, 664, 98, 611, 959, 198, 860, 469, 779, 435, 78, 707, 717, 614, 405, 589, 92, 547, 761, 254, 88, 663, 375, 464, 489, 391, 575, 259, 427, 112, 155, 352, 544, 53, 532, 130, 663, 298, 894, 768, 336, 808, 433, 651, 452, 172, 301, 997, 82, 189, 376, 68, 250, 859, 67, 312, 514, 287, 618, 677, 250, 206, 30, 88, 991, 397, 686, 255, 353, 54, 172, 560, 783, 757, 407, 727, 22, 200, 192, 212, 248, 558, 528, 535, 495, 991, 678, 749, 484, 356, 10, 646, 920, 219, 705, 11, 988, 241, 731, 836, 350, 967, 635, 713, 610, 107, 69, 677, 349, 365, 293, 24, 860, 24, 294, 73, 113, 301, 226, 35, 31, 49, 776, 807, 951 ] + # big unsorted list of 10000 elements (0-5000) + [ 4281, 4149, 4579, 3763, 4892, 3305, 740, 1003, 3748, 4353, 1027, 2205, 4096, 4047, 1883, 3757, 3813, 2757, 2241, 1417, 2054, 1819, 680, 3645, 1979, 3897, 2180, 4072, 3688, 3440, 1107, 3511, 133, 4586, 3432, 3279, 2743, 1489, 4058, 2880, 141, 3039, 3270, 1518, 3879, 3241, 577, 981, 233, 2238, 1571, 1056, 721, 2856, 2309, 1274, 969, 1132, 1492, 2659, 106, 1145, 2328, 3854, 998, 2594, 1359, 1172, 3952, 4137, 3539, 3558, 3947, 1705, 1726, 1292, 1669, 2636, 661, 1079, 4190, 4398, 3954, 2016, 4704, 2748, 2273, 261, 321, 1278, 917, 713, 1241, 1827, 1402, 2956, 4481, 3126, 250, 3932, 727, 2689, 2566, 4584, 1718, 1634, 3977, 3045, 3360, 1072, 982, 2277, 4175, 707, 1192, 3124, 2408, 2734, 4173, 4491, 3060, 1095, 845, 4405, 4617, 2762, 1431, 2720, 4510, 1516, 1770, 1010, 499, 2346, 4191, 2684, 3979, 1794, 2796, 1973, 407, 2764, 1975, 3629, 3945, 4635, 2157, 497, 1720, 583, 520, 2036, 3638, 561, 2168, 2301, 4432, 4086, 1465, 1560, 90, 4092, 2882, 3496, 3609, 4961, 507, 106, 242, 1752, 2154, 4410, 4066, 2333, 1570, 621, 1622, 1915, 517, 4424, 2901, 4704, 394, 1066, 4001, 4645, 624, 3833, 165, 2312, 3795, 3707, 557, 4567, 1897, 4894, 4840, 2805, 655, 1514, 2376, 3504, 1029, 4207, 3054, 4802, 4253, 2339, 2278, 3180, 2426, 861, 1582, 1373, 131, 4390, 4168, 4749, 1948, 2489, 586, 614, 2833, 840, 4136, 2443, 4112, 1850, 2207, 4087, 162, 1030, 1983, 2464, 2840, 4644, 2613, 1305, 4340, 3742, 1422, 1703, 1184, 2389, 997, 413, 3787, 199, 1727, 780, 1055, 879, 3400, 4592, 2140, 4564, 3466, 4630, 2127, 197, 4719, 4045, 2818, 2817, 2207, 507, 3047, 3619, 2327, 4196, 1659, 1603, 2104, 1649, 3893, 1615, 2905, 2216, 224, 2140, 4018, 2590, 3647, 3456, 2173, 1573, 4315, 2389, 2787, 137, 4287, 792, 4260, 1363, 3609, 3610, 2550, 2788, 1020, 4347, 2513, 4633, 3633, 3875, 4670, 503, 1698, 4651, 4725, 3394, 1085, 1275, 407, 4394, 132, 2102, 1239, 2186, 588, 1212, 4641, 4371, 4448, 1910, 3735, 4489, 2793, 2422, 2177, 3639, 2284, 3887, 2759, 4667, 2735, 976, 2055, 2791, 2593, 1406, 2439, 1010, 1160, 14, 3388, 3788, 3982, 3907, 3423, 996, 2863, 2370, 2846, 2297, 18, 1961, 1495, 290, 2390, 4248, 3001, 2365, 513, 2494, 1963, 3833, 3284, 375, 4760, 2711, 1436, 195, 1891, 3935, 4384, 1943, 3347, 126, 1582, 3977, 1398, 2483, 528, 230, 1896, 1421, 1843, 4487, 2893, 4240, 3157, 4135, 2887, 113, 1307, 1960, 593, 2435, 4358, 102, 4780, 537, 1394, 1901, 4554, 2099, 2599, 4467, 4145, 192, 1759, 4141, 4102, 3631, 3425, 467, 3017, 1210, 1108, 1243, 3980, 2772, 1525, 2382, 2795, 4731, 2688, 2303, 1511, 3260, 4863, 4792, 3306, 432, 3068, 1586, 3358, 1327, 3136, 3715, 1515, 4144, 4902, 3557, 3891, 1116, 172, 4655, 2079, 1759, 366, 1223, 2066, 155, 1343, 1106, 1016, 3055, 810, 1430, 4618, 1031, 4488, 2571, 240, 4196, 1896, 2887, 4930, 3694, 2395, 1156, 2889, 4749, 4109, 112, 1578, 450, 1422, 1505, 2266, 3756, 3597, 2655, 3748, 3371, 1659, 1867, 139, 879, 469, 1601, 2566, 3471, 1905, 4403, 2714, 1657, 3867, 563, 1820, 4992, 3084, 4559, 2727, 493, 1045, 4884, 1304, 4596, 4843, 978, 3010, 2282, 3267, 1995, 3942, 4235, 2676, 528, 417, 1860, 4944, 2352, 2603, 496, 2395, 4391, 1183, 4271, 3431, 3219, 3728, 873, 4956, 4460, 3638, 1935, 511, 1820, 1753, 2536, 131, 2253, 736, 1438, 2762, 4677, 4836, 8, 4524, 4711, 1575, 334, 3860, 4697, 4237, 3095, 4017, 3574, 2925, 2398, 4938, 2612, 408, 2086, 1938, 1349, 3405, 2827, 4158, 2071, 858, 377, 1043, 776, 4126, 3981, 81, 4471, 916, 52, 427, 8, 4922, 310, 43, 4770, 800, 3928, 1616, 848, 2818, 1300, 4847, 2744, 2528, 3825, 3582, 4781, 2911, 4309, 1188, 2451, 447, 2057, 966, 1159, 2683, 2542, 4010, 367, 252, 1199, 3765, 3974, 1794, 3464, 55, 501, 3389, 745, 763, 3937, 1077, 624, 2896, 3609, 4555, 3830, 3731, 1240, 1844, 4091, 3081, 587, 424, 3000, 1682, 2332, 3235, 3995, 3520, 3567, 2748, 501, 4661, 594, 385, 3271, 3980, 401, 2904, 1184, 1240, 3933, 825, 4068, 1561, 4387, 2776, 2581, 3117, 2219, 3224, 980, 2160, 1941, 2588, 3254, 4410, 261, 414, 802, 1536, 4245, 2935, 1059, 4098, 2750, 4707, 224, 1867, 740, 593, 2448, 408, 2244, 3719, 4149, 1952, 1509, 893, 558, 2409, 409, 4287, 4817, 3790, 2356, 3100, 4204, 416, 2778, 3876, 894, 1115, 4071, 630, 386, 1346, 41, 4039, 2816, 3001, 500, 1557, 15, 775, 42, 3161, 1449, 2916, 2333, 4947, 3883, 4744, 2792, 2434, 1929, 3599, 831, 4511, 813, 927, 4273, 4285, 496, 4068, 2450, 3893, 4982, 173, 667, 3347, 370, 2424, 3855, 538, 2692, 3084, 456, 107, 4433, 4088, 1181, 1755, 4761, 4932, 3014, 221, 1925, 1649, 2944, 1646, 3994, 1389, 4617, 4609, 3952, 2870, 3535, 4859, 4733, 3696, 3549, 1038, 716, 3474, 2122, 4629, 3495, 992, 4594, 4766, 2389, 4901, 4041, 2453, 894, 2077, 874, 188, 2405, 543, 991, 3601, 3121, 329, 402, 2948, 4382, 3203, 3387, 2098, 3473, 3986, 516, 3243, 2341, 490, 4828, 861, 4527, 2197, 3777, 4860, 1031, 1546, 751, 4670, 826, 4832, 2813, 3820, 4927, 3628, 2082, 4043, 3990, 2929, 1545, 4235, 3792, 4680, 131, 4097, 2694, 652, 4785, 4419, 3044, 3127, 470, 3, 1198, 3754, 2969, 503, 3957, 582, 4109, 1982, 4487, 4330, 1452, 2202, 3601, 3797, 4331, 3630, 471, 1655, 1435, 3624, 394, 4306, 207, 1488, 126, 367, 4870, 3969, 3448, 4265, 3475, 1058, 2437, 267, 591, 4352, 4363, 1096, 3807, 2547, 4328, 2811, 4251, 3241, 3518, 1377, 4983, 1353, 1900, 676, 1969, 1213, 190, 1700, 4020, 2219, 4822, 4659, 1324, 4961, 4675, 2317, 467, 835, 179, 1129, 1093, 852, 1360, 3585, 1999, 742, 3284, 3485, 3383, 4864, 4474, 3600, 653, 1333, 767, 4075, 2345, 4888, 1263, 4482, 2638, 4430, 1173, 4543, 2068, 1466, 4302, 3583, 345, 2633, 2515, 2630, 3717, 693, 1906, 2944, 510, 4609, 4064, 3643, 4010, 657, 3435, 2258, 630, 3037, 3199, 3904, 1139, 1446, 1776, 492, 2942, 188, 2935, 1247, 2000, 4413, 1036, 3485, 4691, 606, 1678, 541, 4380, 2673, 3241, 4403, 1896, 1202, 3323, 2433, 2982, 647, 1564, 3543, 1916, 483, 4040, 2974, 4234, 4025, 3208, 2109, 1055, 2989, 4210, 1944, 3504, 465, 1687, 1569, 2783, 97, 65, 4948, 3311, 1885, 2228, 3961, 4695, 4268, 4063, 166, 3998, 2070, 3547, 2148, 2995, 2451, 2833, 4243, 438, 951, 23, 2913, 1301, 2593, 4557, 2278, 4460, 1142, 3740, 2562, 3369, 2601, 3222, 2230, 2475, 4720, 4568, 572, 2737, 4157, 685, 1934, 3377, 4864, 1586, 3916, 2828, 1462, 2539, 4147, 3028, 4734, 3198, 4312, 234, 3578, 1409, 3776, 291, 1168, 1437, 1454, 3965, 4735, 2310, 3865, 4361, 4374, 3684, 1920, 3844, 3982, 1316, 3922, 2116, 641, 4220, 684, 4937, 313, 2456, 65, 4674, 4960, 2432, 4547, 4090, 624, 210, 3766, 3452, 2226, 1189, 605, 4665, 1528, 1553, 1532, 1669, 4051, 2136, 2392, 4053, 2251, 1601, 992, 3924, 2205, 444, 3260, 417, 922, 2362, 3285, 3414, 2350, 4612, 806, 2803, 1990, 2229, 4273, 3311, 379, 2451, 3479, 1900, 4704, 744, 3895, 1795, 817, 3163, 1770, 1677, 4136, 3643, 2368, 2223, 923, 1526, 3917, 2906, 4849, 4457, 4614, 482, 1340, 4931, 1243, 595, 1297, 720, 3060, 2013, 3678, 1163, 2373, 2067, 4725, 2306, 1205, 4180, 4280, 4069, 600, 648, 3515, 762, 778, 1094, 2792, 2495, 1410, 1023, 1627, 3494, 3172, 2991, 2502, 2014, 4077, 3158, 706, 3970, 1436, 4509, 3981, 1207, 1725, 1552, 738, 3873, 4389, 4788, 448, 784, 729, 355, 3491, 308, 328, 4536, 3921, 871, 330, 3655, 4562, 2544, 1274, 3874, 3156, 3979, 1462, 3874, 4016, 4828, 1497, 2818, 4819, 4440, 4833, 2974, 4997, 232, 4843, 4631, 3602, 3109, 1249, 1565, 4556, 3899, 4216, 791, 2908, 2877, 3838, 3102, 3187, 1579, 472, 1916, 3707, 4749, 2701, 2184, 3172, 3743, 4503, 4928, 79, 4743, 1840, 4946, 2584, 1103, 4328, 1819, 4892, 1850, 749, 1717, 3878, 3507, 957, 1469, 57, 3449, 3451, 2988, 4790, 440, 2495, 770, 3417, 4243, 4273, 4189, 757, 2809, 2711, 444, 23, 3318, 3323, 2848, 316, 2036, 44, 2443, 1718, 2042, 1755, 1361, 1049, 2577, 2771, 4908, 3446, 2370, 2802, 3208, 1352, 1932, 2292, 439, 546, 2160, 4736, 4236, 625, 302, 2662, 1115, 3377, 1892, 4705, 1164, 1657, 4675, 2581, 3397, 2128, 744, 4944, 3110, 1673, 672, 4960, 3888, 1621, 3368, 4293, 3066, 3140, 1191, 1965, 2444, 4717, 218, 1385, 1668, 1207, 2764, 588, 2350, 964, 3098, 4045, 764, 3454, 4673, 1115, 3129, 3415, 4340, 1040, 2705, 924, 2776, 1, 3048, 2226, 2977, 3184, 222, 258, 4304, 453, 2176, 4623, 4166, 1949, 3002, 3917, 2304, 4147, 473, 4184, 441, 4788, 4072, 4982, 1434, 1227, 3484, 2237, 2781, 4271, 4578, 1609, 3531, 482, 2884, 1737, 1193, 4598, 2875, 2117, 1684, 2827, 4542, 3435, 908, 4076, 145, 4829, 1008, 445, 3505, 3711, 3246, 3289, 1011, 3018, 2962, 3631, 3019, 120, 4109, 2033, 2615, 4078, 3339, 1183, 3553, 969, 2093, 1306, 1102, 4674, 4567, 3871, 208, 4076, 2969, 2475, 2923, 960, 1618, 1666, 4600, 4468, 290, 4774, 4164, 2037, 2039, 187, 248, 4995, 1048, 1934, 4592, 2120, 3030, 4183, 4832, 1816, 1653, 839, 1832, 16, 2201, 2838, 323, 3270, 2133, 1722, 3816, 3469, 2197, 4336, 3734, 2088, 4666, 2299, 4975, 2704, 3493, 3574, 1152, 853, 1294, 95, 3057, 3010, 1821, 2855, 909, 4879, 620, 4944, 3780, 2516, 4279, 4588, 1714, 2439, 3161, 320, 1382, 1444, 4825, 4228, 3487, 2604, 2232, 1539, 201, 3867, 2869, 411, 46, 3228, 247, 3911, 3511, 351, 2769, 1322, 4826, 2203, 890, 3788, 2824, 3837, 1896, 1967, 3239, 2078, 2617, 3591, 4943, 2532, 2276, 3184, 3456, 312, 2519, 1270, 3996, 2548, 908, 333, 1845, 1167, 369, 1957, 4307, 1501, 1971, 3247, 4857, 3054, 807, 3738, 3072, 4964, 4901, 3514, 2858, 3055, 4569, 3854, 1774, 1876, 770, 2121, 2326, 1937, 2661, 163, 201, 2200, 4013, 3648, 1735, 2438, 3907, 3636, 4299, 3736, 21, 4253, 2514, 186, 466, 2205, 4728, 1035, 1754, 2873, 3581, 3441, 3539, 2999, 4225, 1547, 1689, 2009, 1691, 3751, 3759, 3438, 4774, 867, 1777, 2616, 7, 756, 3411, 1973, 2544, 1132, 2400, 1380, 2520, 2538, 423, 702, 3146, 2029, 3476, 4848, 1003, 3617, 1455, 666, 134, 1296, 813, 1842, 723, 2874, 160, 4041, 1240, 1907, 1634, 725, 1881, 3700, 1238, 1639, 3915, 4499, 2692, 940, 3218, 1931, 3801, 1719, 764, 4816, 1876, 4402, 3599, 890, 198, 940, 1534, 599, 3052, 1232, 910, 3055, 2397, 2772, 1996, 250, 3285, 3573, 2523, 3802, 828, 4554, 4330, 1176, 1222, 4915, 1798, 1580, 4738, 4551, 3322, 1683, 4755, 2995, 4512, 1820, 3685, 224, 4170, 1802, 2824, 2628, 4285, 4236, 4198, 3336, 2651, 10, 2809, 4060, 3718, 831, 2947, 3734, 928, 3624, 849, 2567, 2310, 4474, 4721, 2904, 1491, 4365, 4447, 2052, 4744, 3973, 2650, 3480, 876, 2463, 1084, 3942, 691, 1073, 4757, 229, 1497, 2229, 1669, 674, 256, 2206, 3311, 2800, 592, 2838, 1042, 2123, 602, 434, 552, 2776, 4179, 2976, 4592, 686, 2805, 4840, 484, 4134, 789, 2790, 73, 3113, 4158, 1956, 1377, 1199, 4901, 4755, 1026, 2821, 2649, 3301, 2651, 1398, 330, 1482, 4844, 687, 1116, 4131, 659, 3150, 4282, 475, 2162, 2084, 4439, 3145, 145, 4693, 2926, 3200, 4720, 4341, 4980, 4850, 3961, 3565, 4604, 466, 4441, 832, 2084, 4875, 739, 2790, 523, 3983, 4160, 630, 4038, 1891, 2324, 667, 420, 1361, 2710, 1205, 412, 2410, 2888, 4873, 2372, 612, 1923, 2857, 2725, 4823, 1042, 1721, 2140, 4529, 2801, 3637, 1995, 1503, 4956, 1766, 3910, 1474, 644, 1410, 4705, 3892, 617, 532, 3475, 3111, 646, 4344, 4830, 571, 3380, 862, 4291, 4558, 2115, 861, 1151, 3521, 4244, 2037, 2272, 39, 1371, 1355, 4179, 3072, 442, 4189, 3669, 93, 3968, 3759, 1213, 4340, 1154, 2941, 1192, 3821, 1289, 2307, 559, 424, 3911, 3161, 1996, 4525, 3811, 2902, 3669, 1219, 770, 2820, 1780, 1950, 4995, 345, 3772, 307, 1887, 1452, 3359, 835, 4830, 3846, 2849, 2132, 4070, 1971, 1797, 2890, 3468, 1600, 3872, 937, 4282, 1998, 3550, 908, 4867, 2377, 3462, 2349, 4434, 3216, 1461, 2681, 1775, 4752, 1439, 3203, 4235, 4147, 4750, 4041, 2051, 10, 2780, 2054, 3566, 4111, 2698, 3520, 3816, 2589, 4700, 2338, 1973, 2444, 1465, 1741, 712, 3457, 4272, 4895, 1409, 4963, 2163, 3369, 4570, 1976, 4879, 1459, 2809, 477, 4946, 3800, 3455, 4720, 434, 2919, 4824, 3688, 3555, 2618, 3615, 385, 4330, 4140, 1552, 737, 4288, 4000, 4086, 186, 1673, 2449, 3272, 3262, 1682, 14, 3119, 1206, 2461, 1625, 4644, 2637, 224, 2300, 1708, 2596, 3650, 1312, 775, 4863, 1556, 3868, 1180, 1061, 836, 4295, 2343, 2063, 2186, 3632, 674, 169, 2082, 3316, 2149, 2812, 1032, 2852, 114, 2735, 4646, 58, 744, 3299, 3623, 3607, 3923, 2972, 3414, 3583, 765, 3515, 2965, 295, 4348, 4470, 647, 4716, 2449, 3788, 643, 4188, 3504, 2477, 3341, 1219, 3362, 3267, 3859, 4867, 356, 576, 914, 4799, 2016, 464, 326, 1346, 170, 3880, 4708, 3797, 3992, 2334, 1675, 2084, 481, 421, 1967, 3402, 2183, 766, 2457, 1001, 2993, 3087, 2149, 1252, 3249, 108, 1506, 4488, 2467, 4145, 4475, 3194, 3128, 829, 2059, 3855, 3016, 4874, 1767, 4926, 4170, 119, 3115, 3378, 1256, 1436, 1124, 2819, 592, 522, 3965, 1341, 543, 4912, 2172, 2042, 4834, 4408, 4710, 1863, 4139, 1023, 3996, 2430, 3018, 1574, 2133, 2783, 3716, 1290, 4735, 2425, 4100, 4572, 596, 3189, 2472, 2581, 1409, 2491, 394, 1688, 4597, 2323, 3615, 218, 391, 3287, 2251, 2159, 448, 1178, 925, 228, 3149, 129, 4113, 4031, 2203, 3489, 2631, 268, 2556, 1934, 4581, 712, 4455, 2137, 2474, 3369, 2065, 4924, 3954, 3654, 4730, 3018, 2201, 3975, 1824, 1174, 3195, 1826, 3162, 3273, 1324, 2747, 3767, 619, 714, 3690, 4744, 4198, 597, 604, 1481, 2615, 658, 701, 3166, 4601, 2613, 2864, 3198, 2340, 593, 697, 2345, 4135, 503, 4291, 1559, 3834, 2900, 601, 3722, 613, 313, 896, 1389, 210, 896, 1019, 1174, 1272, 4386, 1672, 2158, 58, 3045, 1933, 2193, 3534, 1660, 2259, 3120, 4678, 1699, 857, 2200, 4399, 2460, 4972, 2731, 166, 3209, 1124, 3143, 249, 2763, 3986, 4186, 1018, 875, 2707, 294, 4042, 1571, 2964, 1407, 780, 4172, 1436, 4576, 543, 2045, 4535, 774, 1744, 4726, 2401, 2392, 1832, 4104, 2271, 4690, 477, 1582, 433, 4457, 2891, 3310, 1586, 4998, 228, 4771, 2426, 3411, 3969, 1677, 610, 4306, 1486, 2107, 341, 2435, 2791, 2670, 4437, 543, 3487, 3252, 3308, 653, 2615, 1414, 247, 2325, 4668, 166, 4087, 4913, 395, 1459, 3842, 4085, 4738, 4150, 4796, 3732, 409, 109, 2460, 3631, 3196, 4989, 4543, 115, 2910, 1277, 3398, 2277, 2748, 3873, 4529, 4035, 2397, 1047, 290, 4040, 2444, 4099, 4129, 344, 3112, 2617, 2039, 1399, 2786, 3335, 258, 1057, 2648, 2521, 4177, 2132, 4976, 2691, 4035, 3683, 1648, 4866, 336, 4792, 2064, 681, 4395, 3937, 1383, 179, 3190, 4743, 3518, 190, 3276, 3536, 4118, 998, 2950, 315, 3981, 1849, 655, 4864, 2239, 667, 1854, 505, 672, 2905, 3005, 2902, 848, 2674, 1363, 2172, 1997, 164, 183, 943, 619, 496, 86, 4457, 1680, 15, 13, 2785, 4164, 2774, 2497, 1415, 1930, 1784, 4144, 2684, 1093, 1712, 959, 3937, 4338, 1185, 4047, 3026, 788, 3554, 856, 2842, 4365, 1365, 3869, 601, 4791, 872, 4103, 2249, 3718, 4285, 2845, 108, 673, 833, 4721, 863, 793, 3078, 4059, 2608, 1448, 4657, 4414, 1090, 1232, 4575, 4572, 4087, 2080, 4579, 301, 4170, 3781, 186, 3661, 3120, 3710, 1090, 4137, 2690, 1002, 1378, 3566, 4420, 1529, 4317, 147, 2660, 4156, 3361, 2691, 4853, 2907, 1066, 1353, 3779, 1257, 3063, 3499, 1749, 719, 3958, 3278, 1047, 646, 2964, 405, 483, 2180, 4509, 2785, 1833, 4437, 3314, 4822, 1122, 1222, 2021, 1598, 4674, 1441, 288, 1657, 2195, 3179, 4479, 3943, 144, 2018, 2633, 4544, 2660, 3875, 3266, 4555, 2934, 3211, 3275, 3769, 1122, 1680, 2140, 2433, 979, 92, 1207, 4971, 583, 964, 3770, 1427, 4636, 1320, 3383, 639, 3218, 438, 1905, 4190, 3919, 1235, 381, 4334, 4223, 4435, 901, 1383, 333, 3596, 2853, 2455, 812, 4043, 2766, 717, 213, 416, 4165, 1130, 1416, 2119, 929, 519, 8, 4904, 4318, 732, 3043, 1728, 3011, 786, 4442, 1085, 2812, 873, 2545, 0, 4085, 4022, 3708, 633, 414, 2440, 1506, 1065, 4450, 4968, 3964, 2380, 3439, 469, 1505, 1001, 1138, 2042, 4548, 826, 298, 2688, 1860, 4108, 3749, 2870, 4513, 1655, 4236, 3919, 4107, 2159, 2809, 4569, 753, 2943, 4429, 4401, 4903, 1727, 28, 4438, 3322, 3042, 4108, 2398, 1697, 2448, 1057, 3503, 1125, 3337, 477, 2051, 986, 4733, 4114, 3420, 48, 1215, 2541, 4511, 1560, 4966, 1588, 2444, 1061, 4625, 4125, 4792, 1184, 4061, 1296, 4415, 3554, 2496, 1860, 267, 916, 3203, 1612, 2416, 4188, 665, 3186, 305, 1590, 4456, 3020, 3224, 3352, 1270, 1526, 3658, 3837, 3119, 2982, 2003, 3052, 1934, 3280, 4316, 1643, 3127, 4071, 493, 3411, 3367, 718, 712, 527, 1844, 4150, 4344, 3559, 4891, 3679, 3341, 1934, 4526, 4279, 2921, 1827, 3431, 2588, 4870, 3826, 2388, 1028, 361, 2999, 2922, 2094, 4244, 139, 4082, 2190, 2652, 1028, 4033, 4299, 280, 178, 4238, 3511, 1381, 1374, 3551, 3766, 4112, 4130, 3104, 2021, 542, 599, 1814, 4610, 2997, 331, 3988, 4890, 2068, 4253, 3929, 2127, 1849, 2185, 4164, 2904, 3439, 4543, 4256, 4934, 4869, 4192, 1043, 799, 4027, 4173, 3357, 4348, 2056, 4101, 2143, 3038, 2384, 1281, 4937, 200, 2489, 1413, 4841, 3930, 3444, 4835, 833, 1938, 4381, 766, 4436, 3167, 2287, 3828, 4270, 2539, 2365, 2508, 3965, 4631, 3099, 2806, 4160, 1234, 1811, 427, 820, 1093, 2433, 4020, 2786, 535, 566, 556, 4616, 4227, 893, 277, 3345, 2043, 3202, 1756, 2757, 2485, 2876, 719, 365, 789, 1865, 1740, 58, 684, 2535, 3405, 3233, 787, 4600, 2421, 1935, 3757, 1462, 4891, 3377, 3338, 4793, 931, 1931, 1105, 1413, 3060, 1602, 531, 1095, 375, 372, 1809, 1276, 2307, 3231, 1493, 344, 3842, 2380, 2042, 3500, 4944, 1290, 1009, 3114, 2857, 937, 4159, 3801, 4189, 4252, 978, 428, 2146, 1386, 182, 558, 2147, 4472, 3930, 3932, 4225, 2803, 4052, 2102, 3013, 267, 901, 1181, 4125, 2851, 4699, 28, 3887, 553, 3347, 2091, 2564, 1176, 3894, 1551, 3435, 1722, 4968, 4875, 3005, 4179, 2207, 2281, 3621, 1336, 2068, 84, 3681, 3086, 4740, 3802, 2458, 4982, 1095, 4132, 4280, 3031, 4305, 1142, 512, 4683, 1554, 3895, 1477, 498, 1242, 4849, 3286, 1396, 3081, 1204, 975, 2235, 2340, 2545, 746, 75, 763, 2986, 1127, 403, 560, 83, 2602, 3947, 485, 4218, 3570, 311, 420, 3835, 2016, 2726, 2372, 1879, 1714, 1202, 3171, 2427, 1227, 3891, 2887, 3736, 2324, 1641, 4637, 4550, 1356, 817, 1207, 789, 4859, 4249, 1438, 4504, 3388, 2365, 3958, 3082, 283, 94, 4211, 2433, 2134, 2256, 1406, 1137, 150, 2519, 2215, 1393, 3664, 4962, 4491, 4873, 282, 4187, 2245, 1296, 3150, 1359, 4711, 4, 4986, 4376, 1933, 549, 3639, 3690, 2302, 4220, 2204, 21, 4578, 1827, 2654, 833, 465, 1340, 303, 4747, 3926, 4667, 69, 4510, 2911, 4950, 3194, 4501, 3167, 923, 2779, 4962, 316, 2158, 1576, 528, 2863, 835, 453, 4153, 3682, 4604, 279, 3484, 797, 1075, 4679, 461, 3688, 3821, 1589, 3247, 589, 1433, 1053, 4798, 2262, 1252, 745, 3621, 814, 997, 1658, 585, 2823, 2677, 3168, 1806, 3065, 3228, 1779, 4536, 4985, 659, 1323, 2465, 4608, 963, 845, 4132, 4142, 2232, 3475, 650, 4563, 1772, 2816, 4082, 4732, 60, 4223, 4211, 4238, 2573, 2569, 737, 178, 3722, 2675, 2632, 4457, 1870, 2275, 1915, 865, 4310, 3789, 1225, 4035, 1217, 4180, 3858, 2130, 1957, 2226, 452, 1307, 917, 713, 4780, 1161, 4473, 393, 829, 1855, 4188, 3483, 4258, 1210, 4033, 3714, 3888, 3897, 4081, 2573, 4360, 960, 4116, 2805, 2854, 4939, 426, 4636, 2845, 4617, 4297, 4341, 1481, 1134, 2437, 2880, 1104, 694, 3780, 4247, 4179, 4870, 2589, 4813, 4651, 1298, 3268, 1018, 657, 2514, 3414, 845, 603, 2546, 1548, 1817, 3770, 844, 2303, 4894, 1581, 4758, 290, 3948, 3456, 2670, 3584, 4368, 706, 1762, 561, 1730, 4119, 4831, 1684, 4001, 1232, 794, 3548, 2316, 765, 1309, 1671, 2616, 1978, 1261, 2111, 570, 23, 210, 2020, 2259, 1078, 1930, 160, 1885, 3150, 511, 144, 4710, 3274, 4083, 4744, 2621, 615, 2967, 1974, 4789, 1044, 672, 283, 3747, 2104, 163, 2959, 1853, 1649, 4748, 1999, 3346, 1339, 2609, 4163, 4669, 4514, 4991, 4621, 1751, 2345, 2265, 3182, 628, 2759, 3863, 2615, 1767, 2935, 1311, 800, 3241, 3998, 3740, 1481, 66, 2898, 4816, 1176, 1462, 2096, 1065, 302, 59, 63, 4819, 2476, 2387, 2607, 3751, 3089, 2947, 4332, 2265, 3890, 2041, 67, 90, 3051, 3009, 4818, 3734, 3008, 1228, 2036, 2741, 3020, 481, 2609, 1641, 4509, 3847, 3822, 1501, 2265, 3800, 2127, 3822, 270, 3206, 927, 90, 3112, 3427, 2096, 1855, 3829, 4611, 1058, 870, 3113, 1028, 798, 4890, 2958, 4104, 2574, 4894, 2454, 4271, 4728, 1253, 1230, 359, 1095, 1297, 2153, 1004, 383, 2781, 2733, 2319, 3984, 3581, 337, 1103, 1911, 1253, 4525, 527, 3394, 1785, 2506, 1539, 1449, 3729, 2402, 1064, 3705, 4892, 4521, 2836, 3505, 3806, 4918, 459, 1495, 3599, 2139, 3809, 1373, 3871, 1919, 3702, 3097, 1211, 1887, 3487, 1286, 3467, 3142, 2636, 1319, 4275, 3138, 756, 4254, 1752, 1608, 4401, 829, 57, 4105, 4566, 135, 4106, 846, 4560, 4673, 4659, 52, 3188, 4244, 4053, 815, 2640, 112, 2280, 3000, 1838, 3639, 2581, 4828, 218, 374, 4038, 1241, 3499, 2158, 3540, 1951, 4771, 131, 3189, 1341, 4741, 4690, 3817, 1552, 2086, 2351, 1451, 1861, 1639, 836, 881, 1385, 14, 1481, 3476, 4453, 3713, 4419, 1995, 4432, 3933, 2167, 734, 1848, 1040, 225, 1488, 1707, 2, 1347, 1341, 2519, 87, 88, 3706, 1880, 2256, 33, 2289, 2942, 3924, 1321, 21, 3769, 3912, 3953, 3425, 4693, 163, 2861, 4181, 1918, 3838, 4871, 2532, 2235, 226, 2219, 4503, 4273, 3782, 4358, 1951, 4361, 2410, 4951, 4377, 2912, 2063, 260, 4937, 1140, 603, 1292, 1330, 3068, 4365, 363, 424, 2708, 291, 3102, 3857, 4466, 3747, 4476, 1544, 293, 1013, 387, 1142, 3991, 2793, 4335, 2122, 289, 3397, 1722, 961, 2172, 4921, 2191, 2301, 3566, 4118, 1498, 1035, 2410, 3879, 2613, 675, 348, 4728, 1150, 1723, 4122, 236, 3486, 3306, 3026, 1049, 2766, 582, 1034, 1514, 840, 2317, 4649, 3800, 4575, 2363, 2059, 2226, 2550, 109, 3517, 2474, 3835, 4790, 4665, 3450, 3113, 2911, 1274, 2086, 4997, 4145, 3349, 1284, 3109, 4474, 2385, 3716, 3594, 3228, 786, 1578, 4239, 2035, 2381, 2447, 4433, 4161, 749, 455, 1320, 343, 1227, 3263, 3308, 1739, 910, 2148, 3094, 4190, 3752, 2966, 3170, 100, 2063, 4427, 3092, 3553, 2156, 4876, 2690, 4148, 4794, 2999, 921, 4758, 3498, 119, 4431, 1373, 2311, 3320, 3801, 2102, 888, 1800, 4792, 4403, 794, 664, 1703, 4190, 1673, 4827, 3331, 4359, 3843, 2091, 4935, 1691, 4164, 3736, 1067, 1412, 2192, 2441, 993, 2410, 3892, 4322, 1768, 2554, 1517, 198, 585, 18, 2312, 3513, 4572, 253, 3077, 4655, 2776, 1869, 719, 4484, 318, 2119, 3315, 1825, 4639, 1419, 3410, 4547, 3713, 2801, 4241, 1079, 2440, 4985, 4035, 285, 1024, 488, 3046, 2216, 1782, 4521, 204, 71, 4435, 4202, 214, 3166, 1885, 3467, 2997, 433, 3705, 230, 2486, 2652, 3802, 2552, 801, 4835, 4055, 1252, 3653, 3586, 1079, 2474, 1473, 3170, 2868, 872, 3832, 4600, 1873, 2454, 1024, 2988, 4640, 3016, 2003, 3122, 434, 3207, 4173, 3078, 4822, 1787, 3109, 4302, 4286, 1542, 4455, 3286, 2360, 3340, 1605, 3196, 2927, 63, 165, 1659, 252, 828, 3844, 3134, 2907, 3043, 4389, 3915, 2876, 1581, 1384, 2097, 3746, 4788, 4533, 1998, 3945, 1152, 449, 4479, 2896, 2604, 330, 3460, 4743, 2939, 3668, 4762, 4924, 3843, 3198, 138, 2740, 4389, 4432, 1226, 4685, 1914, 2818, 3514, 2613, 1389, 4971, 523, 190, 3365, 1581, 2881, 1496, 4997, 530, 243, 4823, 2188, 2995, 3679, 615, 1558, 3394, 3649, 102, 2823, 849, 4905, 4605, 3137, 2944, 3796, 4154, 1945, 1734, 2830, 2496, 2410, 741, 150, 3602, 1605, 3330, 4904, 3214, 4181, 2082, 3408, 3305, 4255, 2608, 2121, 1180, 3495, 42, 2012, 3516, 1143, 4904, 3505, 4714, 3037, 255, 3984, 1279, 2083, 3934, 4372, 2172, 4196, 1207, 339, 2467, 2205, 4089, 3789, 3887, 3402, 3881, 2546, 2132, 4635, 3569, 3082, 1323, 4763, 824, 628, 4253, 1791, 3744, 3302, 3074, 3350, 1994, 3086, 260, 1098, 2633, 799, 4808, 4419, 334, 3884, 2767, 3681, 4939, 465, 1791, 4214, 148, 1674, 3905, 4072, 4337, 717, 726, 3989, 2816, 625, 4911, 1463, 2830, 4210, 4909, 2550, 2155, 1581, 993, 3728, 4693, 370, 4989, 223, 4136, 1160, 4339, 2693, 3075, 1071, 4358, 2647, 3148, 4649, 4513, 1265, 3939, 3646, 4659, 2926, 1088, 4221, 2628, 744, 4574, 4347, 4239, 2228, 2234, 2897, 1140, 3273, 2629, 616, 1422, 1445, 2548, 104, 2711, 2339, 3861, 826, 2622, 3041, 1195, 1602, 4566, 4780, 1304, 2718, 3972, 32, 4140, 3108, 341, 4285, 1365, 2246, 821, 3118, 3870, 1290, 1407, 3457, 1086, 2415, 2634, 4370, 3196, 181, 4192, 6, 1960, 4244, 1957, 595, 1684, 3267, 4396, 1526, 1579, 2437, 1509, 400, 2432, 1074, 2092, 2441, 229, 1606, 1822, 2384, 1510, 4921, 3583, 3862, 4081, 1113, 2367, 105, 4072, 1064, 2072, 2797, 3705, 3351, 1444, 4913, 4757, 4559, 757, 4167, 198, 3736, 4580, 4124, 1111, 4575, 4135, 1857, 3280, 1078, 4269, 423, 3107, 3773, 905, 3074, 2804, 2551, 2572, 3859, 2437, 1328, 1338, 3276, 2349, 4462, 1007, 1819, 3847, 4720, 3077, 2085, 38, 68, 4117, 1411, 2495, 98, 3819, 2619, 1544, 2908, 2811, 1240, 2075, 4228, 518, 806, 3722, 4286, 3039, 3989, 4695, 3899, 4683, 4528, 594, 4761, 752, 800, 4070, 63, 3577, 4086, 1886, 1367, 3256, 99, 1024, 762, 4021, 581, 1744, 2024, 4842, 3200, 3255, 2777, 829, 2524, 2587, 2354, 1506, 224, 1677, 88, 3306, 4582, 470, 2997, 2632, 3862, 2743, 2692, 4571, 2414, 1815, 654, 4387, 2367, 4666, 1640, 3251, 2550, 442, 1440, 1138, 3562, 2363, 3573, 131, 2508, 2276, 991, 1340, 686, 3266, 1538, 491, 2199, 2729, 2843, 249, 4163, 3714, 377, 4539, 4381, 1678, 1871, 1856, 1086, 2347, 1811, 4552, 2802, 3865, 4272, 4960, 2091, 2482, 3890, 1233, 2742, 134, 3301, 2754, 4374, 4176, 2805, 218, 495, 3130, 2889, 1972, 2668, 2436, 839, 2317, 941, 1230, 1309, 4118, 1921, 1556, 3664, 1844, 596, 1791, 3706, 1949, 1658, 4501, 2779, 4255, 2787, 3714, 3309, 3478, 860, 1894, 2324, 660, 3633, 2079, 659, 186, 909, 1000, 317, 392, 3779, 2710, 1609, 4514, 1410, 3321, 1232, 218, 1649, 1314, 324, 2661, 396, 736, 4007, 2544, 3026, 3382, 3923, 4223, 4553, 3045, 945, 1459, 4189, 1608, 1122, 574, 920, 2039, 4058, 2464, 4074, 4093, 310, 1682, 2503, 2960, 566, 4729, 1480, 3270, 357, 58, 3374, 3036, 3333, 821, 3462, 3443, 1415, 3967, 3793, 745, 3359, 894, 4308, 2100, 4701, 2670, 3667, 2736, 2835, 1660, 2755, 368, 2968, 1872, 4315, 2504, 1681, 3688, 878, 415, 3089, 1860, 2191, 4922, 818, 525, 1943, 4214, 1308, 1401, 4893, 2459, 1176, 2365, 2987, 980, 4515, 2718, 4421, 1216, 2459, 1992, 4982, 3582, 1969, 1372, 4283, 4824, 4142, 820, 2895, 2601, 3261, 4060, 2493, 3268, 1184, 1618, 766, 3678, 135, 3016, 3763, 438, 2127, 2270, 1254, 4129, 84, 3175, 298, 2473, 2766, 1040, 244, 242, 2339, 1984, 3900, 4950, 261, 4625, 2174, 4011, 418, 4636, 391, 4405, 2464, 3734, 1385, 2628, 3979, 1463, 19, 1316, 4524, 453, 3443, 93, 1798, 1555, 2133, 2591, 1094, 3512, 331, 1497, 3906, 4080, 3643, 2296, 4069, 3662, 3288, 2495, 1404, 2890, 4265, 1739, 740, 3281, 1477, 2981, 4261, 3177, 447, 2231, 2435, 2379, 42, 1903, 3718, 513, 1444, 779, 708, 3737, 2397, 1841, 4847, 2250, 4312, 4115, 4319, 4457, 1244, 2044, 4594, 1958, 258, 2414, 1308, 31, 4846, 4539, 324, 1167, 4073, 1362, 3209, 4703, 1255, 575, 354, 1951, 3452, 831, 3948, 3464, 4311, 4653, 1987, 4624, 953, 993, 949, 4178, 1296, 3863, 2705, 2066, 2702, 313, 4355, 351, 1407, 2772, 1991, 2640, 968, 3672, 4233, 187, 2687, 73, 406, 513, 1384, 309, 4239, 4542, 2524, 3196, 1950, 4627, 3253, 641, 2394, 842, 2808, 4831, 4647, 381, 3671, 667, 424, 571, 619, 4815, 3068, 2690, 3984, 2479, 1268, 2128, 3331, 3825, 4595, 807, 376, 1757, 1131, 883, 3861, 4361, 4950, 4270, 1602, 3162, 1793, 2187, 2150, 1776, 4769, 2580, 3677, 2980, 1320, 3573, 4496, 4839, 4202, 2313, 2041, 1227, 3071, 4110, 532, 3861, 388, 3687, 2102, 2869, 3600, 1447, 1272, 4372, 3851, 1850, 4928, 3808, 4074, 3003, 1224, 541, 3323, 3370, 4420, 1760, 161, 3133, 4654, 3154, 1179, 2089, 74, 1399, 3331, 3450, 3683, 3254, 1017, 1386, 4010, 81, 4215, 4881, 3132, 4283, 2980, 109, 3784, 2042, 2240, 2868, 124, 3021, 8, 4578, 863, 265, 3412, 3501, 928, 836, 175, 3229, 1366, 1720, 4179, 3854, 2632, 2663, 2900, 3858, 2694, 4116, 2485, 1481, 1779, 2539, 943, 807, 1496, 3670, 4705, 1700, 592, 1933, 180, 4716, 3236, 1332, 1359, 858, 2155, 4587, 4327, 3897, 4718, 3906, 4900, 3178, 2603, 2137, 1478, 4453, 4142, 3359, 2497, 4972, 1854, 1929, 1969, 1325, 3503, 176, 3398, 1740, 2567, 147, 391, 3762, 2557, 4957, 4638, 251, 2897, 3165, 507, 2062, 2904, 4156, 3717, 3223, 3143, 4701, 1789, 3205, 2688, 973, 3495, 2638, 3003, 4371, 4457, 4481, 4546, 505, 1432, 1171, 4641, 1859, 2234, 3384, 1719, 2932, 3087, 4153, 1596, 224, 1568, 4192, 3708, 4949, 2739, 149, 106, 3739, 3182, 3682, 51, 2409, 3891, 1890, 1948, 3705, 784, 354, 456, 1989, 2885, 4830, 2674, 4783, 2717, 335, 3495, 3425, 4217, 444, 790, 1912, 4043, 645, 2713, 4688, 4774, 887, 126, 4560, 4218, 1059, 1674, 4238, 2718, 162, 1814, 892, 4297, 4253, 4500, 996, 1227, 4801, 2862, 1723, 3398, 3443, 54, 1655, 2016, 3079, 3412, 2399, 479, 4144, 36, 3119, 2269, 3960, 1801, 2726, 766, 3105, 3795, 540, 423, 2656, 3552, 1708, 722, 4275, 347, 1232, 1901, 4341, 1360, 1045, 4670, 1906, 4109, 3952, 4078, 865, 3438, 2860, 1607, 186, 514, 3656, 2520, 1680, 4414, 4614, 4117, 1804, 1858, 3613, 4863, 3363, 3576, 1367, 897, 1931, 949, 4701, 4601, 764, 3517, 2338, 1573, 3554, 4393, 4552, 2438, 4181, 551, 2115, 890, 362, 3771, 2195, 1757, 4247, 4787, 557, 4465, 4134, 2704, 2656, 4228, 3758, 1960, 3087, 1970, 4052, 2723, 3321, 2185, 1069, 3802, 3492, 3652, 2566, 2710, 3449, 2227, 308, 1014, 889, 1740, 3667, 1020, 4190, 1359, 658, 3422, 4067, 2280, 659, 4816, 314, 268, 1878, 3742, 1651, 4025, 4844, 1491, 3329, 3340, 2742, 3028, 1760, 4123, 2537, 1878, 3331, 449, 3430, 4031, 1012, 1691, 3324, 2859, 3554, 3745, 1434, 1345, 3053, 1983, 1202, 2791, 4137, 95, 991, 165, 1751, 3568, 2485, 475, 3831, 3175, 4882, 3159, 629, 1965, 1199, 1217, 2538, 916, 1150, 1663, 1094, 690, 3561, 4980, 1555, 997, 563, 4943, 4839, 3615, 4441, 3288, 1634, 4320, 4618, 2952, 1346, 40, 1219, 2474, 2853, 4762, 591, 972, 2563, 3383, 1522, 1051, 3833, 3491, 844, 2622, 4282, 2878, 4411, 3556, 3263, 3429, 1426, 2763, 4631, 4687, 630, 752, 1823, 1016, 4114, 3155, 3524, 1857, 735, 538, 226, 3958, 488, 3794, 730, 1467, 4327, 4494, 200, 622, 3035, 4786, 2592, 2724, 4860, 797, 500, 3508, 1012, 1764, 166, 4178, 3422, 1995, 4290, 3630, 3825, 3454, 3225, 4548, 3445, 2567, 4834, 1215, 3884, 368, 4876, 4356, 2063, 4032, 1, 496, 3074, 4871, 4703, 3560, 954, 932, 82, 3628, 475, 3915, 2700, 2268, 1458, 4327, 3365, 2557, 1170, 3284, 541, 4590, 3276, 326, 1375, 1816, 4114, 3069, 3223, 4634, 476, 1470, 1538, 1626, 1624, 468, 2987, 3251, 3093, 562, 2870, 2010, 2097, 3147, 4738, 3792, 358, 1994, 845, 2554, 425, 3420, 4979, 3131, 1802, 919, 1532, 770, 4811, 4025, 1869, 663, 3909, 2544, 4643, 1998, 64, 4990, 3615, 4085, 2125, 929, 1949, 2028, 4337, 1932, 2690, 666, 1799, 584, 4602, 1444, 4007, 1063, 2459, 2105, 1475, 2220, 4257, 3128, 1276, 990, 659, 385, 1143, 1444, 2553, 673, 3783, 812, 4135, 4291, 3535, 3788, 2736, 3405, 249, 1081, 519, 2699, 4818, 2472, 4746, 1991, 3982, 4715, 2762, 3868, 1793, 3363, 1995, 1746, 3892, 1378, 1755, 3272, 2598, 1958, 295, 3169, 3193, 3302, 1191, 2548, 421, 4620, 3079, 3804, 106, 1722, 1460, 404, 476, 4923, 66, 4327, 1201, 2284, 1167, 4200, 4949, 1302, 3315, 992, 4312, 4835, 4916, 3600, 549, 2133, 55, 4078, 3062, 3633, 58, 839, 1100, 3388, 3694, 3007, 1129, 4679, 3745, 4746, 164, 199, 1528, 1098, 117, 3426, 3895, 3880, 1581, 773, 2260, 2081, 4563, 255, 3112, 1793, 561, 2161, 4728, 4928, 846, 1077, 4671, 4348, 413, 1459, 1781, 3051, 3057, 847, 331, 1660, 123, 2945, 1965, 980, 4853, 294, 1271, 3068, 398, 3272, 1251, 3595, 916, 2532, 2991, 667, 2537, 3977, 2978, 4634, 1645, 3381, 1397, 3087, 3116, 1105, 3427, 4799, 142, 3490, 4602, 349, 1257, 488, 3091, 2258, 223, 1505, 1881, 3444, 3403, 3327, 3586, 1202, 1847, 3116, 1297, 2285, 4287, 185, 756, 4939, 4802, 3685, 4646, 1123, 3666, 177, 886, 1148, 4627, 4200, 4617, 1645, 3818, 4556, 991, 1434, 2577, 3177, 3926, 3110, 2353, 4258, 4261, 3154, 1348, 1450, 1876, 1634, 362, 3839, 3622, 1818, 2566, 4680, 4471, 164, 1339, 3770, 4233, 2296, 1857, 4293, 4710, 1771, 1600, 974, 2342, 1280, 1839, 3068, 1679, 3845, 2653, 3048, 1621, 3282, 1169, 4805, 2175, 3851, 127, 1207, 4414, 1793, 3907, 751, 194, 263, 3127, 3731, 72, 9, 1444, 2884, 3639, 4444, 3021, 4549, 899, 3216, 3344, 2609, 2306, 2164, 3121, 3213, 2375, 2128, 1299, 271, 4975, 2541, 3553, 671, 384, 510, 954, 4247, 2670, 2771, 104, 2552, 1029, 4799, 4048, 559, 4702, 956, 4229, 91, 2149, 3302, 2684, 1920, 523, 1831, 1877, 4523, 2958, 2739, 2160, 1828, 2677, 1586, 2180, 3892, 1595, 4260, 4008, 4264, 3943, 260, 1322, 502, 2729, 4002, 1481, 119, 4338, 3146, 109, 1414, 3901, 369, 1938, 2660, 1172, 1938, 2091, 3088, 4504, 2311, 3943, 2109, 4803, 3092, 2853, 411, 2672, 2485, 1833, 757, 554, 4912, 1642, 948, 1975, 2065, 1620, 4827, 4028, 1823, 3776, 2694, 2293, 395, 1612, 4950, 4952, 4982, 2592, 1489, 3656, 3068, 27, 4957, 2073, 1346, 4753, 2286, 3224, 2146, 370, 292, 1182, 1551, 402, 4870, 1063, 1387, 2063, 4629, 1840, 196, 4332, 2496, 1830, 540, 147, 219, 2457, 923, 755, 102, 4733, 3289, 587, 810, 2088, 3113, 493, 934, 1008, 3836, 2827, 4764, 3095, 1329, 2356, 3619, 784, 135, 2980, 1004, 4722, 4568, 4471, 4187, 418, 492, 4838, 3731, 2442, 3410, 2295, 2516, 2269, 3263, 4575, 3195, 3540, 1482, 1021, 3777, 795, 2002, 889, 742, 3831, 1438, 1073, 3934, 4554, 4865, 4144, 3396, 151, 2695, 4436, 268, 4554, 71, 1438, 1712, 4603, 2831, 4261, 4472, 3234, 1275, 2251, 650, 3407, 640, 3140, 1497, 3230, 4831, 1356, 2183, 4958, 930, 2185, 2578, 935, 3865, 4846, 772, 3225, 3672, 2593, 4589, 1976, 4259, 2439, 2921, 1338, 918, 560, 39, 2312, 2105, 972, 4567, 2384, 3560, 2990, 3194, 1741, 70, 700, 181, 2999, 4095, 1642, 2307, 4035, 3351, 4676, 2809, 734, 1191, 366, 1547, 3419, 167, 1214, 846, 1906, 385, 2202, 1586, 3467, 4389, 3776, 913, 4760, 1132, 3334, 3423, 4948, 2638, 1082, 2689, 2262, 4684, 2967, 292, 2070, 1059, 3508, 1061, 2189, 4530, 852, 26, 230, 2667, 1263, 3651, 1058, 65, 1693, 1243, 2844, 164, 2989, 47, 3180, 2770, 3490, 4822, 3884, 306, 4574, 407, 4669, 1784, 1739, 4751, 2073, 2740, 1275, 309, 2310, 2928, 4132, 2214, 1662, 3128, 3402, 1406, 2927, 2638, 1320, 1043, 4526, 3883, 4345, 4257, 4263, 1941, 2991, 178, 2520, 4227, 4068, 4446, 3634, 4106, 709, 1094, 3058, 2650, 3687, 1007, 4837, 3630, 4999, 4642, 2827, 514, 4300, 4267, 4884, 1737, 3614, 4249, 4112, 3486, 3399, 1395, 434, 934, 4978, 834, 337, 4459, 4410, 4627, 4741, 2955, 525, 4883, 745, 2826, 1815, 4838, 3190, 576, 3952, 4733, 1932, 1552, 1315, 4412, 1262, 720, 3781, 333, 2992, 4261, 2539, 3548, 3285, 4621, 3589, 1792, 1567, 4942, 2038, 3497, 817, 4322, 1091, 669, 478, 2614, 3234, 3338, 4085, 4434, 4249, 2693, 4579, 2833, 3803, 2236, 2225, 2300, 2049, 4447, 3511, 164, 4849, 4528, 1869, 3741, 650, 4041, 1411, 2382, 2527, 980, 4243, 2574, 806, 3111, 596, 2960, 1062, 4292, 3821, 844, 2694, 2771, 2098, 2435, 953, 2770, 2318, 2151, 3816, 3643, 1536, 2839, 1855, 1914, 946, 2291, 1254, 996, 4041, 3904, 1800, 3345, 4649, 1061, 4659, 3117, 820, 702, 4122, 3727, 3869, 644, 2258, 2887, 4471, 4674, 930, 1719, 3349, 3833, 932, 2914, 3198, 1554, 3698, 698, 4175, 4580, 3245, 3055, 506, 672, 1129, 4028, 4448, 259, 1064, 251, 322, 1724, 3707, 1008, 1877, 3575, 4494, 1063, 324, 2663, 3856, 905, 2144, 273, 3906, 2790, 35, 3765, 653, 818, 1217, 2378, 478, 4928, 2288, 3180, 4372, 1209, 4738, 4479, 489, 2036, 1747, 1776, 775, 2309, 4608, 3041, 1572, 2923, 1624, 1904, 1878, 1153, 657, 2232, 1928, 2125, 4822, 3504, 2042, 3558, 1349, 2498, 3717, 4525, 878, 4357, 1777, 1400, 3111, 2179, 4243, 2495, 1070, 1284, 2498, 812, 875, 120, 1573, 4038, 4583, 3193, 990, 2522, 3127, 2089, 2588, 1721, 4945, 1615, 3699, 2088, 1677, 1336, 3719, 3240, 2663, 4439, 316, 3843, 211, 3767, 912, 1474, 1076, 3243, 1738, 2191, 2317, 1416, 3401, 3514, 1486, 3791, 3712, 1107, 553, 1749, 2090, 2271, 3948, 2175, 4712, 1112, 3250, 941, 174, 2299, 4849, 1354, 4217, 861, 1801, 3084, 2189, 2196, 3448, 291, 4205, 988, 20, 1797, 4161, 1446, 2347, 1631, 1869, 2225, 3698, 881, 4104, 3866, 1177, 3083, 3243, 3160, 2665, 301, 863, 3440, 2124, 3151, 831, 1182, 1310, 1925, 2635, 2144, 3511, 1623, 3511, 786, 547, 1236, 473, 3844, 4262, 3349, 4740, 914, 4747, 100, 3617, 2622, 2432, 3499, 878, 3988, 1013, 1274, 1138, 4549, 4706, 471, 1226, 3226, 1382, 2749, 2729, 4438, 4536, 2133, 2659, 1375, 4493, 3596, 3082, 389, 1844, 4697, 4435, 4498, 4205, 4008, 3247, 4822, 1925, 3081, 4331, 1949, 521, 165, 666, 1981, 1980, 2183, 4274, 2398, 4060, 4838, 4394, 1179, 1679, 892, 2016, 2755, 4796, 110, 262, 1784, 4096, 4436, 2345, 3308, 3379, 3340, 3521, 2237, 2716, 4266, 4849, 3304, 4198, 4169, 2162, 1477, 4679, 3473, 4447, 2162, 3269, 112, 3120, 2655, 1283, 1330, 2021, 956, 2805, 1420, 3571, 4038, 4978, 1300, 1382, 1498, 3894, 4421, 3644, 4219, 4360, 4149, 3703, 2979, 1164, 1062, 3182, 2467, 1171, 3386, 4093, 413, 1018, 594, 431, 2187, 1125, 3272, 2160, 2524, 852, 4586, 235, 1869, 3164, 1247, 2657, 3220, 987, 3450, 4669, 2302, 2424, 151, 2865, 4729, 467, 4848, 4615, 358, 3704, 96, 2700, 3132, 3339, 3814, 878, 3951, 438, 4946, 304, 510, 1716, 2395, 1228, 205, 771, 159, 1731, 3135, 337, 4796, 837, 2151, 4102, 2255, 1565, 1569, 3787, 1576, 3981, 2628, 977, 4656, 4462, 4611, 2206, 1161, 2176, 1960, 2826, 4590, 4274, 1810, 2464, 401, 4024, 4718, 3173, 594, 998, 173, 3970, 2133, 3136, 676, 2902, 4838, 2490, 2527, 2959, 2199, 1220, 3090, 4171, 4283, 356, 4457, 3367, 4602, 1701, 742, 3512, 1025, 1595, 3822, 2846, 2748, 3979, 55, 3928, 2625, 1847, 878, 1265, 3248, 2972, 1382, 2627, 501, 3660, 4987, 1422, 2924, 1489, 2617, 332, 2473, 1332, 2125, 1856, 162, 3498, 3358, 901, 4243, 1572, 1127, 3609, 101, 388, 562, 2954, 4718, 1740, 1752, 2855, 233, 4226, 703, 2157, 2189, 2702, 1913, 1796, 3212, 2868, 3, 4135, 6, 3131, 4076, 3000, 3267, 4033, 4283, 4413, 1612, 1598, 814, 4767, 3588, 4134, 812, 75, 274, 2758, 4981, 2129, 166, 316, 3207, 4044, 990, 761, 2557, 4785, 2666, 3211, 1450, 2491, 3354, 2307, 4251, 1666, 1891, 2128, 2908, 2424, 932, 3336, 2358, 2619, 4375, 1566, 3974, 1252, 208, 1113, 1375, 775, 2988, 3462, 1933, 1084, 195, 3280, 3403, 1887, 1201, 3470, 340, 408, 4421, 1349, 1462, 214, 4664, 3537, 999, 3935, 2784, 4605, 4685, 4997, 2768, 3118, 4448, 149, 2098, 4658, 502, 848, 1500, 839, 1724, 1693, 726, 4083, 2417, 729, 4957, 4462, 1526, 1563, 1821, 2752, 2644, 2651, 2221, 3398, 4854, 3489, 3867, 1874, 841, 4196, 2898, 406, 686, 3933, 309, 2411, 4309, 2112, 992, 2599, 4529, 162, 4964, 1844, 4043, 3360, 3152, 955, 1017, 3123, 3215, 2094, 3990, 3928, 1791, 4937, 1441, 1575, 3987, 1097, 1609, 2744, 1788, 1043, 2857, 4790, 4576, 3446, 1875, 3908, 632, 4073, 2373, 121, 1119, 3010, 2231, 3096, 107, 1532, 2660, 4567, 1968, 360, 1513, 1163, 1824, 3306, 647, 4026, 2527, 1229, 3744, 2654, 4739, 1102, 2273, 2030, 678, 807, 1883, 1832, 990, 3932, 3028, 4979, 4394, 1268, 1495, 3185, 2222, 4631, 2697, 3274, 830, 793, 3555, 1413, 1492, 3851, 1866, 160, 1876, 643, 751, 3935, 1541, 4925, 2153, 2199, 1537, 3004, 1673, 67, 4282, 1271, 2518, 2838, 4185, 1997, 3521, 1158, 4580, 992, 1333, 1875, 1095, 3117, 2949, 3977, 3454, 2374, 647, 4472, 2984, 4135, 975, 2823, 1647, 1940, 4738, 4994, 1122, 1555, 4691, 2245, 1866, 559, 2654, 2372, 4669, 4605, 2805, 1619, 710, 493, 1276, 4894, 2097, 1095, 2317, 4049, 880, 3946, 4718, 4297, 4675, 772, 1739, 4487, 887, 4400, 4850, 2525, 3973, 4477, 4386, 1976, 1224, 61, 4361, 2142, 1072, 1509, 3363, 4686, 4980, 1119, 2198, 4649, 2176, 2632, 1511, 2741, 963, 4106, 277, 1392, 4883, 1832, 3582, 1666, 4077, 923, 4194, 3347, 2715, 1040, 1536, 4398, 3671, 1171, 3112, 4614, 4127, 3931, 2154, 1013, 2118, 2905, 3381, 2708, 1824, 4663, 2046, 4050, 4469, 2854, 3189, 2219, 311, 1342, 1016, 3268, 3199, 4290, 2054, 4721, 3731, 1863, 3915, 167, 2858, 1282, 2194, 207, 4876, 2158, 2550, 4346, 1561, 484, 4693, 990, 292, 108, 3642, 4805, 3187, 1735, 2153, 1635, 3389, 1996, 2972, 1346, 1840, 1078, 4579, 2380, 3432, 3520, 3753, 337, 2241, 1855, 3131, 1664, 4101, 2494, 226, 4762, 4693, 3234, 4902, 4568, 1028, 4699, 3843, 1625, 2466, 4104, 3594, 3337, 3385, 1291, 4438, 4423, 1992, 1791, 2821, 3753, 655, 3957, 1968, 526, 3353, 2597, 319, 1526, 4431, 4005, 4483, 3931, 2261, 1482, 4166, 3766, 4781, 3837, 2427, 3191, 3570, 4371, 835, 1140, 3825, 4037, 1887, 2322, 4062, 2241, 2146, 4876, 3243, 2612, 2238, 868, 2068, 491, 318, 1766, 2344, 4593, 4782, 1979, 741, 1806, 2487, 1559, 786, 2490, 2426, 1283, 1273, 4533, 425, 1835, 2637, 3558, 3779, 4042, 3441, 1145, 3464, 3016, 3842, 2694, 2186, 3463, 1338, 2665, 4181, 4470, 3116, 237, 2591, 1410, 2789, 2569, 1932, 3113, 1056, 4001, 4245, 3045, 4149, 3832, 1265, 1778, 3439, 2459, 3689, 4343, 3544, 1697, 1851, 2458, 602, 4854, 4615, 393, 2983, 2317, 4002, 4779, 4811, 1011, 3785, 4316, 3773, 1206, 3143, 369, 1279, 125, 1226, 2734, 3250, 1361, 1861, 4843, 165, 2071, 481, 4000, 2951, 386, 2630, 2756, 4787, 1611, 834, 1403, 1885, 4023, 4858, 1855, 3558, 3518, 954, 1082, 4203, 4471, 4000, 1307, 4117, 4659, 133, 3108, 170, 1828, 309, 1306, 4511, 802, 1989, 2885, 963, 2067, 117, 1722, 42, 991, 3567, 92, 3713, 3642, 1615, 1382, 1671, 3405, 1214, 4327, 711, 4431, 4022, 2412, 2662, 3072, 205, 4801, 1627, 471, 3998, 1206, 4986, 2488, 2592, 796, 1106, 2416, 1381, 3482, 4934, 4815, 2591, 4230, 4864, 2147, 1276, 638, 908, 4099, 3389, 3227, 3225, 2523, 4155, 2561, 1119, 3121, 1107, 3292, 4595, 3722, 4094, 2940, 3275, 2145, 2387, 2970, 4838, 1168, 2872, 1692, 3758, 2106, 177, 4222, 4839, 2646, 3693, 82, 4746, 4165, 4527, 4888, 1796, 1303, 4119, 3320, 4121, 201, 2531, 1083, 473, 703, 1460, 3572, 257, 712, 3842, 240, 1675, 582, 3830, 4888, 1474, 4197, 3479, 4115, 832, 211, 1625, 1575, 2064, 3373, 3614, 39, 939, 2082, 1612, 3535, 4061, 1989, 1259, 352, 4924, 1773, 1664, 2298, 4226, 1870, 677, 2944, 199, 617, 73, 1510, 2363, 3986, 1349, 1098, 4238, 1225, 4968, 1385, 3293, 4877, 857, 3858, 2685, 1190, 2704, 2483, 2762, 1741, 1757, 271, 113, 3828, 1752, 2585, 4261, 4636, 1846, 1451, 2239, 588, 3487, 3247, 4210, 2888, 2568, 3132, 2108, 2508, 4085, 4607, 4250, 4782, 508, 4165, 2377, 3984, 4536, 4926, 4243, 1564, 3399, 3245, 1595, 3302, 553, 2894, 1627, 4951, 2918, 1539, 3392, 459, 1744, 2789, 4006, 802, 2676, 3453, 3567, 1894, 194, 547, 2089, 668, 2960, 4436, 4010, 4914, 3710, 545, 4904, 1751, 4096, 4690, 1681, 2229, 1388, 3669, 4937, 3877, 170, 3122, 1497, 4621, 332, 569, 1715, 731, 3518, 4744, 1193, 1675, 1450, 1518, 188, 1583, 3528, 2902, 2026, 4299, 3239, 1907, 4297, 4358, 2379, 942, 4936, 875, 1513, 4606, 4594, 93, 634, 3094, 2415, 3922, 4782, 4773, 3527, 3401, 4575, 162, 4145, 1205, 1575, 858, 4197, 1253, 2795, 3166, 1173, 2042, 1683, 4203, 1182, 1609, 2657, 831, 2754, 2555, 2318, 35, 4454, 4421, 2513, 2723, 42, 3766, 1407, 3735, 1982, 4364, 1406, 399, 4302, 3794, 3583, 1908, 2162, 4748, 1266, 3419, 1798, 295, 1689, 2889, 3434, 1833, 80, 66, 4148, 4218, 1948, 4487, 1659, 2052, 1944, 2412, 370, 4522, 35, 3828, 908, 4486, 3774, 3744, 3881, 1243, 888, 3988, 3764, 2684, 4748, 4339, 4136, 3617, 168, 4414, 1843, 1174, 2252, 605, 1362, 2529, 2093, 2104, 4318, 1346, 729, 4894, 2509, 3770, 4261, 2537, 1867, 2972, 173, 4284, 2787, 3314, 2938, 823, 1428, 3463, 3945, 4054, 451, 3530, 238, 4863, 1582, 3684, 3695, 1506, 3919, 1105, 2821, 4287, 2495, 1547, 4449, 4616, 3082, 1503, 1573, 4914, 418, 2076, 4059, 2331, 3495, 2047, 4484, 1759, 2065, 339, 3559, 2465, 1131, 4314, 1535, 3902, 4616, 4482, 1663, 1647, 4679, 3806, 874, 835, 2890, 4538, 2554, 3027, 364, 1163, 1520, 498, 39, 2191, 1748, 1444, 2270, 1817, 3534, 412, 1087, 3491, 4339, 2273, 3717, 2996, 345, 1417, 735, 3731, 527, 3741, 3739, 2976, 1511, 4757, 3544, 2792, 4910, 1308, 3028, 3101, 3400, 2336, 4293, 3461, 3243, 986, 2340, 2095, 4531, 2157, 1980, 1578, 3018, 1856, 2886, 3884, 3685, 2584, 3556, 4529, 4872, 183, 2467, 12, 2462, 4658, 906, 1944, 4557, 1184, 2759, 2521, 734, 498, 3038, 957, 3763, 540, 2129, 1039, 1534, 717, 1894, 2119, 1155, 4317, 2448, 2516, 4032, 4393, 3331, 3212, 3713, 2840, 4612, 3776, 4309, 4626, 4082, 1501, 3168, 3213, 205, 1476, 4030, 2432, 2507, 4294, 3473, 3289, 3747, 532, 2950, 3881, 4856, 2458, 2646, 3253, 2718, 1973, 4660, 997, 2223, 1591, 597, 3421, 3584, 2946, 3202, 3192, 3133, 2665, 4747, 2637, 400, 635, 920, 3463, 2909, 1739, 1634, 655, 2284, 4281, 1899, 644, 2738, 1264, 1240, 2217, 2145, 1312, 2114, 4407, 3144, 266, 1935, 3758, 2389, 4865, 3650, 3217, 3837, 1074, 2131, 194, 413, 4626, 4091, 445, 1918, 4161, 1990, 2158, 2689, 4431, 3923, 2806, 4595, 3285, 404, 2971, 1440, 3587, 2620, 2623, 1631, 694, 3604, 3311, 2657, 3605, 4308, 118, 1284, 3820, 89, 3984, 3935, 2376, 633, 1113, 3293, 4858, 3798, 2931, 3859, 693, 4920, 4922, 2075, 1852, 4430, 1567, 3905, 4834, 11, 1951, 3168, 1720, 2367, 131, 1560, 2566, 1022, 2145, 3048, 3305, 1857, 323, 1503, 2677, 2065, 2045, 3638, 4019, 1054, 2359, 1416, 2848, 1579, 4857, 1591, 3278, 4818, 323, 1188, 3150, 804, 2056, 778, 1257, 3886, 2213, 4728, 4908, 2362, 4918, 4525, 2759, 4495, 4218, 458, 2174, 1110, 3421, 2766, 4787, 2677, 3059, 4663, 1867, 4965, 4146, 4981, 3292, 281, 847, 4020, 3009, 1770, 3787, 4981, 4269, 3511, 3871, 3720, 4726, 3534, 3008, 1360, 1516, 305, 2292, 1121, 2822, 4712, 3612, 4700, 2425, 3494, 3841, 2117, 3894, 2728, 4274, 3508, 2361, 8, 286, 2528, 4989, 1434, 388, 1427, 259, 319, 2580, 4506, 2501, 2426, 2527, 2780, 2707, 3999, 608, 920, 247, 1756, 1062, 1227, 2812, 72, 2224, 4719, 151, 488, 4136, 1235, 1688, 4479, 3779, 2252, 3751, 2145, 679, 3486, 4584, 2476, 2337, 4906, 3525, 4648, 2630, 4370, 1363, 4070, 2833, 455, 936, 2677, 3350, 56, 1655, 1113, 956, 1679, 2170, 961, 555, 1332, 3495, 3136, 429, 3776, 3972, 1432, 1612, 1925, 4161, 4817, 999, 2842, 3170, 1979, 4662, 2473, 2190, 3551, 892, 4894, 1989, 3243, 841, 2604, 3506, 3874, 3169, 3269, 907, 3965, 3975, 1568, 149, 1983, 512, 1343, 265, 3290, 1276, 2191, 4768, 3049, 1269, 907, 4981, 1179, 2282, 3472, 3199, 4993, 34, 935, 4432, 866, 2624, 3280, 2972, 2373, 2465, 2729, 3030, 4870, 346, 4683, 4684, 2862, 214, 1867, 2367, 3841, 3805, 2590, 1394, 4983, 3653, 3210, 2787, 4258, 226, 2966, 4553, 2810, 2463, 1655, 135, 4135, 496, 4851, 2147, 1371, 656, 4500, 3348, 4658, 1189, 430, 2047, 4550, 946, 4233, 1789, 1023, 1137, 2788, 686, 1425, 4380, 3652, 616, 4357, 1950, 2032, 3237, 3181, 600, 1742, 3142, 1922, 1174, 4722, 995, 708, 2599, 2411, 1271, 2319, 2183, 2934, 2169, 3938, 4112, 1702, 3579, 2048, 2244, 2433, 2083, 1356, 3535, 3887, 4565, 986, 1128, 1769, 885, 3688, 47, 764, 3549, 2944, 419, 3862, 4456, 780, 3155, 820, 113, 2931, 161, 1053, 4023, 839, 4964, 3644, 2282, 2809, 1500, 3956, 39, 1012, 39, 1115, 3989, 4061, 2230, 88, 142, 558, 2636, 1947, 4496, 1353, 4774, 4410, 1308, 4198, 2513, 1307, 319, 2903, 2263, 1228, 2420, 4303, 2409, 4173, 38, 3673, 4514, 1388, 4751, 3979, 2259, 2762, 1436, 1261, 3772, 1977, 3808, 1138, 2524, 29, 163, 4859, 4811, 4014, 811, 3539, 4707, 4343, 4823, 2346, 808, 4856, 4826, 3150, 3367, 2758, 4405, 3445, 4537, 1178, 1399, 653, 850, 879, 4301, 493, 270, 4962, 2027, 3759, 2352, 1685, 1440, 3800, 4155, 2576, 3444, 3497, 4751, 3798, 4768, 3533, 2852, 1074, 4492, 1106, 3830, 2164, 2818, 2355, 3372, 3948, 2124, 4496, 1158, 1356, 2984, 4503, 4760, 378, 3519, 3352, 2034, 3751, 907, 2375, 371, 2888, 4148, 3848, 4634, 2428, 3861, 51, 3850, 1565, 4764, 4032, 3755, 4494, 437, 2320, 1433, 483, 1814, 40, 4420, 1624, 4983, 840, 3421, 2121, 3348, 2138, 3257, 346, 1151, 1293, 4574, 1528, 4791, 4425, 2534, 3838, 1920, 988, 4391, 4614, 2179, 1064, 258, 1641, 295, 1840, 648, 3297, 3246, 365, 2637, 1973, 2299, 2275, 450, 732, 1978, 1917, 4963, 4983, 1142, 4622, 3520, 3775, 709, 1198, 4471, 1623, 4149, 4097, 1951, 4374, 353, 919, 1560, 1151, 2303, 4775, 4631, 3859, 2405, 1743, 1358, 62, 4245, 3164, 855, 1539, 2789, 3891, 1415, 167, 359, 4220, 967, 4400, 4319, 616, 4810, 498, 905, 2228, 1440, 4435, 3932, 445, 2083, 1446, 3374, 1545, 1172, 208, 3211, 3324, 2807, 1148, 2776, 3348, 4362, 4829, 3358, 1170, 3575, 3143, 1021, 425, 3608, 1696, 348, 3289, 4177, 4265, 3649, 1681, 4944, 15, 2954, 1336, 3720, 1235, 4285, 2919, 2079, 1270, 896, 2266, 4140, 1282, 2752, 1746, 3303, 650, 4929, 4309, 4299, 4038, 3849, 3540, 2521, 1894, 1461, 289, 2547, 2387, 3306, 4451, 2927, 1629, 2122, 3308, 1885, 2058, 4899, 2216, 2282, 4456, 1571, 4408, 1936, 1714, 4794, 1090, 3569, 3628, 3718, 2630, 2194, 3432, 2989, 1653, 4948, 1833, 1485, 3063, 2749, 3572, 2932, 3693, 791, 4106, 1547, 1899, 2078, 4004, 997, 1127, 4039, 3612, 1250, 1603, 554, 3259, 2916, 1666, 886, 1501, 2, 4618, 3790, 4967, 226, 4069, 572, 153, 4984, 1645, 2133, 2527, 4056, 820, 3228, 1453, 4967, 1852, 2491, 473, 4737, 3235, 1736, 544, 4440, 4817, 229, 3678, 2664, 2923, 1745, 2594, 4986, 1316, 3746, 1220, 256, 2820, 4255, 2541, 2957, 3494, 3348, 1562, 3588, 3407, 4961, 1942, 2330, 390, 4414, 1050, 1870, 4987, 4089, 4044, 4936, 668, 867, 163, 1388, 224, 1804, 1634, 4886, 2195, 354, 4088, 638, 1201, 3339, 591, 336, 1712, 3150, 373, 2497, 2301, 2790, 3429, 581, 279, 1252, 3013, 892, 4297, 350, 1007, 718, 754, 83, 4910, 2797, 2695, 4482, 1354, 2908, 3269, 4320, 1434, 4843, 2871, 1004, 2937, 716, 4889, 3723, 2711, 2036, 3178, 4883, 1232, 2831, 2713, 1683, 3679, 4171, 163, 4179, 248, 2311, 3073, 4816, 920, 4321, 428, 772, 2173, 3775, 2058, 4258, 1990, 4001, 113, 2382, 275, 4487, 250, 915, 1956, 2633, 1355, 1335, 2000, 4616, 3293, 1868, 2313, 2819, 1472, 3889, 2068, 2934, 3493, 2496, 426, 4566, 1270, 2525, 4575, 79, 1237, 1345, 3934, 3878, 767, 1758, 92, 2779, 1477, 1946, 4517, 2611, 3170, 3664, 2063, 1621, 2547, 4544, 1785, 1067, 2806, 358, 3330, 1879, 1104, 4455, 2749, 2586, 2044, 1468, 1197, 1462, 1804, 4810, 2392, 4072, 4525, 1714, 2456, 2999, 2637, 3402, 2677, 1472, 28, 4215, 901, 4847, 3361, 957, 422, 2909, 3156, 4340, 4808, 1330, 814, 1865, 4992, 71, 1156, 809, 748, 4408, 2089, 3036, 1519, 4454, 927, 3219, 1040, 3893, 1885, 3149, 3264, 4296, 3112, 679, 3044, 3377, 3751, 937, 2884, 2021, 2260, 2404, 2261, 1956, 767, 688, 29, 541, 4799, 1140, 2154, 3141, 3011, 1629, 3420, 3252, 2898, 3964, 295, 813, 2125, 4404, 2848, 4179, 2038, 3387, 2224, 4298, 3329, 2071, 374, 397, 4497, 2453, 4182, 845, 2364, 3961, 3064, 571, 3397, 0, 1519, 1111, 2265, 4056, 4935, 515, 4177, 3122, 621, 1926, 4031, 3481, 3541, 3503, 3745, 3352, 819, 1914, 1735, 2560, 4055, 2457, 4481, 1594, 187, 4112, 3442, 1982, 3553, 2463, 651, 1372, 429, 957, 1888, 3971, 2717, 4187, 1789, 1502, 482, 4344, 3468, 560, 2461, 1089, 545, 2995, 2131, 2926, 2763, 3386, 1313, 3739, 3192, 2447, 2509, 4256, 1826, 749, 66, 3634, 2750, 1486, 552, 2545, 1190, 1186, 4306, 3405, 557, 2027, 334, 4257, 2336, 2131, 1485, 2871, 1998, 2954, 2520, 3123, 1071, 409, 1393, 3007, 2556, 2943, 2859, 1576, 3214, 986, 3061, 1034, 1402, 2827, 2470, 433, 4428, 3208, 2523, 4429, 1608, 2169, 210, 1259, 4269, 1252, 2234, 2302, 453, 2372, 712, 3341, 4843, 4430, 4678, 460, 1200, 1205, 652, 2789, 2561, 2351, 4917, 4411, 2449, 1840, 3768, 1313, 2248, 3771, 2169, 147, 3447, 307, 2202, 779, 4048, 2711, 4845, 1521, 22, 2198, 4842, 3352, 396, 502, 2650, 249, 4859, 229, 1790, 2019, 1465, 3294, 881, 1856, 4847, 3438, 2794, 2262, 3305, 2930, 2377, 4462, 3267, 2471, 1559, 2817, 4006, 544, 2133, 3678, 4468, 2613, 125, 1688, 802, 2138, 4216, 824, 2087, 2294, 4597, 4898, 3428, 4975, 1611, 230, 1969, 1029, 2469, 180, 2087, 1986, 1006, 3634, 1792, 2875, 3237, 4997, 3243, 3228, 1026, 1986, 2391, 851, 2148, 3528, 3380, 430, 3931, 2980, 538, 4861, 2089, 2918, 1275, 521, 3005, 247, 596, 742, 4939, 4792, 1910, 2692, 4939, 3993, 4600, 1359, 3049, 258, 4340, 134, 4356, 1855, 941, 1991, 816, 2048, 2310, 3591, 565, 3768, 843, 4882, 145, 4554, 3390, 730, 4974, 770, 2214, 4250, 1991, 3719, 2010, 3257, 37, 2859, 207, 2098, 2732, 1526, 1955, 4494, 50, 2596, 4023, 4362, 1432, 4662, 908, 4015, 1186, 2205, 850, 4232, 4398, 4301, 4131, 2079, 70, 2394, 36, 4099, 4862, 416, 333, 2110, 4521, 4375, 1575, 4040, 11, 1921, 1870, 2515, 954, 2861, 1949, 4871, 2673, 1955, 60, 1286, 4746, 652, 1039, 1280, 1953, 4870, 4213, 3476, 3236, 2736, 4708, 3641, 4065, 4166, 4631, 2351, 3225, 1176, 1381, 761, 3130, 829, 172, 1383, 2965, 4141, 2499, 2996, 497, 919, 2427, 2863, 3881, 3415, 78, 3621, 2088, 1158, 3266, 1063, 373, 4707, 3063, 3330, 4471, 3490, 4771, 2405, 4767, 4238, 2347, 1562, 1652, 1398, 585, 4340, 2743, 2106, 4104, 4312, 3647, 4381, 3313, 3412, 3094, 4438, 2922, 1021, 460, 2087, 474, 1785, 1524, 2137, 2609, 3273, 4233, 3665, 3929, 1543, 3541, 1571, 4174, 519, 3437, 567, 365, 914, 2454, 2770, 2351, 3449, 3862, 4216, 4239, 4176, 859, 3093, 2349, 1880, 4325, 571, 2705, 69, 3423, 964, 495, 670, 1636, 683, 2069, 3722, 3663, 3406, 2820, 3060, 2089, 4488, 3537, 3797, 545, 1630, 867, 1431, 1738, 1417, 2298, 1045, 2784, 3567, 4523, 3292, 3447, 1405, 3079, 4700, 4765, 3183, 1554, 3964, 3207, 2531, 4635, 1826, 3022, 2615, 1587, 3588, 580, 4300, 2073, 1130, 441, 4808, 3306, 1271, 1984, 3431, 3340, 4609, 3312, 1152, 126, 4432, 929, 4753, 4415, 1069, 4690, 151, 1570, 4687, 3921, 1088, 4495, 2772, 4136, 364, 1785, 993, 53, 3313, 2254, 3461, 1672, 2404, 750, 2329, 2080, 1246, 4389, 496, 4979, 4857, 1775, 1395, 4240, 1461, 548, 4143, 4838, 3895, 905, 3160, 4999, 3143, 3866, 4893, 1162, 3741, 4494, 3379, 3486, 4976, 186, 2319, 498, 1484, 507, 1115, 457, 522, 2798, 2302, 1840, 2680, 645, 3681, 4372, 763, 1329, 4656, 1053, 3541, 1970, 3015, 1769, 1583, 4294, 2256, 954, 4986, 170, 2396, 1159, 2097, 2879, 691, 3792, 2679, 2337, 4008, 4024, 2040, 674, 1576, 2195, 1869, 1305, 2217, 1920, 138, 678, 389, 2212, 3152, 2915, 910, 2080, 3932, 3131, 3463, 4182, 2464, 4623, 1512, 3670, 1576, 629, 2441, 3551, 2706, 1384, 3257, 3610, 450, 2672, 4573, 491, 1551, 2888, 4370, 1851, 3631, 4041, 2654, 547, 2370, 3045, 1859, 3539, 1678, 447, 3445, 1439, 2830, 52, 1538, 1087, 2482, 3930, 2730, 3721, 568, 2780, 1866, 4338, 3893, 3481, 3785, 2259, 3194, 3049, 757, 1410, 1853, 4921, 724, 933, 1741, 3725, 1014, 4558, 89, 2767, 1976, 7, 1106, 2946, 2611, 2427, 1417, 2633, 672, 3009, 3052, 246, 2770, 1555, 2970, 1219, 4624, 4866, 4050, 1156, 714, 1624, 3336, 106, 1880, 3602, 4814, 2410, 443, 2940, 3424, 1866, 800, 1709, 2111, 8, 4567, 2563, 4921, 1971, 1908, 2382, 1711, 156, 3642, 1647, 731, 1162, 670, 3015, 3797, 2287, 2824, 1810, 4874, 3193, 2147, 4534, 986, 3036, 3361, 718, 3988, 2868, 2546, 824, 3978, 461, 2254, 4122, 1912, 975, 2792, 4521, 2417, 2535, 2887, 3957, 4788, 2786, 1153, 4063, 4730, 4928, 710, 2962, 1655, 4930, 3521, 4446, 502, 2153, 3243, 1790, 1428, 612, 3122, 2221, 2197, 3706, 4323, 683, 3727, 1981, 2015, 1909, 2309, 1989, 2804, 4681, 4623, 4195, 793, 554, 2391, 3740, 4788, 1780, 1323, 4580, 3128, 4572, 3814, 3690, 1731, 3313, 4011, 1808, 3393, 4002, 4597, 4360, 3521, 3948, 3414, 2037, 2810, 2827, 414, 1693, 4452, 607, 1941, 1545, 4395, 2801, 361, 4890, 3384, 416, 1513, 4639, 4473, 408, 2792, 973, 2955, 4419, 2791, 3878, 2366, 3294, 4735, 2267, 2037, 3963, 4018, 3158, 2251, 3131, 3504, 2564, 4003, 1679, 4630, 4559, 4176, 4996, 1132, 4537, 3583, 1253, 3959, 2245, 1240, 2784, 1615, 3763, 1503, 2245, 3850, 2035, 4988, 4438, 331, 1098, 2410, 1825, 628, 2288, 4928, 3246, 2323, 2317, 208, 2919, 1601, 535, 4812, 2513, 237, 3210, 1499, 3687, 3860, 1544, 4041, 1117, 2719, 2566, 2396, 3423, 2634, 2852, 1705, 2397, 47, 3799, 4277, 4163, 2372, 1916, 4412, 1156, 1246, 3699, 274, 4598, 1915, 3560, 2542, 4802, 2711, 288, 2135, 2222, 4492, 1912, 418, 1525, 3298, 4993, 1517, 3873, 1551, 1017, 877, 1033, 4471, 1051, 2454, 2534, 3151, 2857, 3097, 1103, 2999, 301, 1686, 1630, 4862, 1205, 4509, 716, 1849, 4338, 2240, 3436, 4917, 3512, 140, 929, 1837, 895, 2651, 1741, 899, 1251, 2871, 2901, 311, 135, 3715, 2427, 3976, 3413, 4922, 681, 1902, 1165, 2705, 3843, 257, 2506, 3428, 2198, 3593, 3198, 3165, 4914, 1244, 4812, 3753, 4839, 1799, 3321, 2504, 4618, 1570, 3208, 4683, 913, 2327, 4528, 4977, 1198, 1293, 882, 3453, 2564, 868, 2377, 2605, 427, 4532, 690, 420, 351, 762, 1550, 1420, 1888, 781, 1387, 86, 4336, 3461, 2029, 646, 2054, 3051, 624, 2102, 3223, 2826, 4280, 4159, 3647, 1045, 4363, 249, 4335, 984, 3938, 1417, 4787, 322, 3957, 3248, 1716, 1511, 4461, 2471, 29, 2761, 2856, 4090, 1525, 4004, 4057, 3538, 532, 1660, 4643, 4727, 1019, 4004, 687, 2561, 508, 3710, 4317, 4252, 4302, 3978, 2162, 964, 4709, 138, 329, 3695, 4640, 4031, 979, 3000, 3530, 1749, 4177, 2045, 4409, 3337, 1626, 2157, 4432, 3492, 3724, 3454, 223, 3050, 763, 561, 3706, 16, 2696, 1942, 923, 2839, 3625, 4465, 826, 2600, 2185, 874, 705, 397, 1547, 1931, 2375, 3224, 3358, 2990, 281, 645, 3657, 2011, 4842, 613, 2969, 1522, 595, 3562, 1649, 4093, 36, 2965, 941, 982, 818, 1946, 4686, 193, 3532, 2196, 1307, 3647, 3659, 2587, 3753, 1905, 3026, 4681, 1064, 1173, 4899, 54, 1089, 4753, 3587, 2032, 4250, 2825, 2782, 4400, 1069, 1266, 2841, 1165, 1574, 4457, 1335, 4009, 3184, 4577, 4475, 1612, 2796, 4026, 3230, 4443, 4228, 4210, 4307, 2594, 3293, 392, 3372, 3962, 2974, 1685, 1525, 3057, 682, 3347, 227, 1317, 650, 662, 2210, 2519, 2920, 1537, 1757, 3865, 1708, 2828, 2206, 4637, 1738, 3913, 2077, 4022, 4002, 2020, 1313, 1330, 3297, 190, 3917, 2569, 1790, 87, 541, 4180, 1084, 3309, 19, 3481, 3867, 4834, 3051, 3926, 1749, 2750, 2389, 1886, 1503, 3984, 3310, 2409, 370, 3936, 2, 4733, 4643, 614, 2558, 2561, 3213, 3240, 19, 3879, 605, 2754, 4734, 1117, 438, 2304, 3501, 1161, 1420, 2764, 1040, 1072, 572, 1442, 4810, 1816, 2683, 4483, 4045, 3914, 2172, 1204, 703, 4033, 1542, 712, 1358, 3385, 2334, 4282, 1084, 3512, 4293, 4376, 4244, 2877, 1599, 4911, 4581, 619, 3648, 2722, 2128, 4923, 865, 2676, 2936, 4262, 2347, 3463, 921, 4151, 2028, 2242, 697, 4879, 2686, 4313, 1591, 1740, 3793, 1932, 1351, 2407, 1705, 3041, 2220, 4904, 422, 4289, 2284, 4027, 1866, 1504, 2850, 718, 799, 186, 322, 1135, 1050, 3627, 2676, 3726, 1378, 4792, 4121, 325, 2088, 270, 4065, 1142, 3611, 4756, 2756, 1919, 601, 1944, 4218, 4731, 2085, 2518, 3104, 4032, 4426, 1614, 615, 274, 4382, 4577, 3982, 3239, 2463, 1345, 348, 1800, 43, 4798, 1503, 2533, 3155, 4915, 131, 4853, 2765, 2811, 1853, 2868, 3054, 2418, 4778, 736, 4262, 812, 2555, 4076, 3617, 4734, 532, 2110, 3532, 2943, 1395, 4100, 76, 4297, 4664, 29, 3270, 4632, 4192, 4640, 3706, 1014, 21, 4050, 3054, 1842, 1054, 570, 4259, 429, 1728, 4847, 596, 1370, 2800, 1058, 3259, 4215, 4230, 63, 2031, 3646, 3146, 1795, 4796, 218, 1452, 4021, 117, 2418, 4389, 1142, 4998, 750, 3101, 2362, 227, 753, 721, 4065, 2148, 3628, 2712, 2374, 4797, 1474, 3976, 3615, 513, 3783, 4926, 1847, 4635, 4495, 2176, 2734, 3619, 4239, 3065, 4135, 1444, 4518, 4709, 4039, 1972, 25, 704, 2535, 3024, 660, 142, 3563, 1197, 4732, 2689, 2861, 1851, 3809, 3385, 4099, 2285, 4892, 2210, 4698, 3616, 1456, 1443, 670, 3010, 1816, 1825, 2089, 1157, 413, 4957, 2539, 4394, 476, 1168, 2746, 763, 1483, 3370, 1478, 1974, 1178, 248, 562, 75, 2981, 178, 1382, 4542, 4427, 2014, 942, 408, 2177, 2005, 4939, 1048, 3729, 4481, 1159, 1380, 4377, 2239, 3447, 2724, 4739, 4201, 2932, 852, 4816, 965, 2719, 2505, 4029, 1572, 257, 4552, 4493, 3920, 2576, 2998, 4811, 1216, 3499, 106, 900, 3830, 4893, 2819, 1273, 4666, 991, 2994, 3400, 649, 4820, 167, 4248, 2546, 4791, 162, 3339, 4028, 321, 2922, 3603, 1778, 3395, 650, 1540, 3721, 4113, 3079, 2478, 291, 3551, 190, 113, 30, 4734, 467, 946, 3566, 2543, 879, 2636, 4392, 2695, 27, 1726, 4444, 3083, 4901, 1105, 1402, 322, 2147, 1886, 1775, 172, 873, 13, 4580, 2017, 3561, 3050, 1334, 4608, 4311, 1994, 236, 4235, 59, 4156, 3831, 933, 3495, 256, 4756, 3021, 757, 290, 970, 2614, 3228, 3925, 3884, 3925, 4312, 816, 2075 ] sort unsortedList |> Quicksort.show From 314503cf7f6461840aa40548a4928a0e80be885c Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Sat, 5 Jun 2021 20:02:54 +0200 Subject: [PATCH 121/496] fixed typos, added typos checking to CI --- Earthfile | 17 ++++++++++-- README.md | 2 +- compiler/builtins/README.md | 4 +-- compiler/builtins/bitcode/README.md | 8 +++--- compiler/builtins/bitcode/src/dec.zig | 2 +- compiler/builtins/docs/List.roc | 2 +- compiler/builtins/docs/Num.roc | 4 +-- compiler/builtins/docs/Str.roc | 2 +- compiler/can/src/expr.rs | 2 +- compiler/can/src/operator.rs | 2 +- compiler/constrain/src/builtins.rs | 4 +-- compiler/constrain/src/expr.rs | 4 +-- compiler/constrain/src/module.rs | 2 +- compiler/fmt/tests/test_fmt.rs | 2 +- compiler/gen/src/llvm/build.rs | 10 +++---- compiler/gen_dev/README.md | 4 +-- compiler/gen_dev/src/generic64/mod.rs | 4 +-- compiler/gen_dev/src/generic64/x86_64.rs | 4 +-- compiler/gen_dev/src/lib.rs | 4 +-- compiler/load/src/docs.rs | 16 +++++------ compiler/mono/src/borrow.rs | 4 +-- compiler/mono/src/inc_dec.rs | 32 +++++++++++----------- compiler/mono/src/ir.rs | 2 +- compiler/parse/src/expr.rs | 10 +++---- compiler/parse/tests/test_parse.rs | 2 +- compiler/reporting/src/error/parse.rs | 2 +- compiler/reporting/src/error/type.rs | 10 +++---- compiler/reporting/src/report.rs | 4 +-- compiler/reporting/tests/test_reporting.rs | 2 +- compiler/solve/src/solve.rs | 2 +- compiler/str/README.md | 4 +-- compiler/test_gen/src/gen_list.rs | 2 +- docs/src/lib.rs | 2 +- editor/editor-ideas.md | 8 +++--- editor/src/editor/grid_node_map.rs | 2 +- editor/src/editor/mvc/app_model.rs | 4 +-- editor/src/editor/util.rs | 2 +- editor/src/graphics/lowlevel/ortho.rs | 2 +- editor/src/lang/constrain.rs | 2 +- editor/src/lang/expr.rs | 2 +- editor/src/lang/solve.rs | 2 +- packages/unicode/src/Unicode/Scalar.roc | 2 +- vendor/pretty/src/lib.rs | 12 ++++---- 43 files changed, 114 insertions(+), 101 deletions(-) diff --git a/Earthfile b/Earthfile index 766e224f12..8c143c9263 100644 --- a/Earthfile +++ b/Earthfile @@ -1,6 +1,8 @@ FROM rust:1.52-slim-buster WORKDIR /earthbuild +ARG TO_COPY_DIRS=cli compiler docs editor roc_std vendor examples Cargo.toml Cargo.lock + prep-debian: RUN apt -y update @@ -38,6 +40,8 @@ install-zig-llvm-valgrind-clippy-rustfmt: RUN rustup component add clippy # rustfmt RUN rustup component add rustfmt + # typo checker + RUN cargo install typos-cli # criterion RUN cargo install --git https://github.com/Anton-4/cargo-criterion --branch main # sccache @@ -57,7 +61,8 @@ deps-image: copy-dirs: FROM +install-zig-llvm-valgrind-clippy-rustfmt # If you edit this, make sure to update copy-dirs-and-cache below. - COPY --dir cli compiler docs editor roc_std vendor examples Cargo.toml Cargo.lock ./ + RUN baksldbjk + COPY --dir $TO_COPY_DIRS ./ copy-dirs-and-cache: FROM +install-zig-llvm-valgrind-clippy-rustfmt @@ -66,7 +71,7 @@ copy-dirs-and-cache: # This needs to be kept in sync with copy-dirs above. # The reason this is at the end is to maximize caching. # Lines above this should be cached even if the code changes. - COPY --dir cli compiler docs editor roc_std vendor examples Cargo.toml Cargo.lock ./ + COPY --dir $TO_COPY_DIRS ./ prepare-cache: FROM +copy-dirs @@ -99,6 +104,13 @@ check-rustfmt: RUN cargo fmt --version RUN cargo fmt --all -- --check +check-typos: + FROM +copy-dirs + RUN echo "DIRS_TO_KEEP=" > temp42.txt + RUN echo $TO_COPY_DIRS | sed "s/ /\"|\"/g" >> temp42.txt + RUN source temp42.txt && rm -v !("$DIRS_TO_KEEP") + RUN typos + test-rust: FROM +copy-dirs-and-cache ENV RUST_BACKTRACE=1 @@ -109,6 +121,7 @@ test-all: BUILD +test-zig BUILD +check-rustfmt BUILD +check-clippy + BUILD +check-typos BUILD +test-rust bench-roc: diff --git a/README.md b/README.md index 925ff3944e..001b4fbe66 100644 --- a/README.md +++ b/README.md @@ -46,7 +46,7 @@ By using systems-level programming languages like C and C++, platform authors sa Roc is designed to make the "systems-level platform, higher-level application" experience as nice as possible. * **Application** authors code exclusively in Roc. It's a language designed for nice ergonomics. The syntax resembles Ruby or CoffeeScript, and it has a fast compiler with full type inference. -* **Platform** authors code almost exclusively in a systems-level langauge like C, C++, Rust, or [Zig](https://ziglang.org/), except for the thin Roc API they expose to application authors. Roc application code compiles to machine code, and production builds of Roc apps benefit from the same [LLVM](https://llvm.org/) optimizations that C++, Rust, and Zig do. Roc application authors do not need to know this lower-level code exists; all they have to interact with is the platform's API, which is exposed as an ordinary Roc API. +* **Platform** authors code almost exclusively in a systems-level language like C, C++, Rust, or [Zig](https://ziglang.org/), except for the thin Roc API they expose to application authors. Roc application code compiles to machine code, and production builds of Roc apps benefit from the same [LLVM](https://llvm.org/) optimizations that C++, Rust, and Zig do. Roc application authors do not need to know this lower-level code exists; all they have to interact with is the platform's API, which is exposed as an ordinary Roc API. Every Roc application is built on top of exactly one Roc platform. There is no such thing as a Roc application that runs without a platform, and there is no default platform. You must choose one! diff --git a/compiler/builtins/README.md b/compiler/builtins/README.md index fdb5bd793b..5e5bac6b0f 100644 --- a/compiler/builtins/README.md +++ b/compiler/builtins/README.md @@ -42,7 +42,7 @@ fn list_repeat(symbol: Symbol, var_store: &mut VarStore) -> Def { ) } ``` -In these builtin definitions you will need to allocate for and list the arguments. For `List.repeat`, the arguments are the `elem_var` and the `len_var`. So in both the `body` and `defn` we list these arguments in a vector, with the `Symobl::ARG_1` adn` Symvol::ARG_2` designating which argument is which. +In these builtin definitions you will need to allocate for and list the arguments. For `List.repeat`, the arguments are the `elem_var` and the `len_var`. So in both the `body` and `defn` we list these arguments in a vector, with the `Symobl::ARG_1` and` Symvol::ARG_2` designating which argument is which. Since `List.repeat` is implemented entirely as low level functions, its `body` is a `RunLowLevel`, and the `op` is `LowLevel::ListRepeat`. Lets talk about `LowLevel` in the next section. @@ -60,7 +60,7 @@ Its one thing to actually write these functions, its _another_ thing to let the ## Specifying how we pass args to the function ### builtins/mono/src/borrow.rs -After we have all of this, we need to specify if the arguements we're passing are owned, borrowed or irrelvant. Towards the bottom of this file, add a new case for you builtin and specify each arg. Be sure to read the comment, as it explains this in more detail. +After we have all of this, we need to specify if the arguments we're passing are owned, borrowed or irrelvant. Towards the bottom of this file, add a new case for you builtin and specify each arg. Be sure to read the comment, as it explains this in more detail. ## Specifying the uniqueness of a function ### builtins/src/unique.rs diff --git a/compiler/builtins/bitcode/README.md b/compiler/builtins/bitcode/README.md index 1cbef7b727..1d9fbb225b 100644 --- a/compiler/builtins/bitcode/README.md +++ b/compiler/builtins/bitcode/README.md @@ -3,10 +3,10 @@ ## Adding a bitcode builtin To add a builtin: -1. Add the function to the relevent module. For `Num` builtin use it in `src/num.zig`, for `Str` builtins use `src/str.zig`, and so on. **For anything you add, you must add tests for it!** Not only does to make the builtins more maintainable, it's the the easiest way to test these functions on Zig. To run the test, run: `zig build test` +1. Add the function to the relevant module. For `Num` builtin use it in `src/num.zig`, for `Str` builtins use `src/str.zig`, and so on. **For anything you add, you must add tests for it!** Not only does to make the builtins more maintainable, it's the the easiest way to test these functions on Zig. To run the test, run: `zig build test` 2. Make sure the function is public with the `pub` keyword and uses the C calling convention. This is really easy, just add `pub` and `callconv(.C)` to the function declaration like so: `pub fn atan(num: f64) callconv(.C) f64 { ... }` -3. In `src/main.zig`, export the function. This is also organized by module. For example, for a `Num` function find the `Num` section and add: `comptime { exportNumFn(num.atan, "atan"); }`. The first arguement is the function, the second is the name of it in LLVM. -4. In `compiler/builtins/src/bitcode.rs`, add a constant for the new function. This is how we use it in Rust. Once again, this is organized by module, so just find the relevent area and add your new function. +3. In `src/main.zig`, export the function. This is also organized by module. For example, for a `Num` function find the `Num` section and add: `comptime { exportNumFn(num.atan, "atan"); }`. The first argument is the function, the second is the name of it in LLVM. +4. In `compiler/builtins/src/bitcode.rs`, add a constant for the new function. This is how we use it in Rust. Once again, this is organized by module, so just find the relevant area and add your new function. 5. You can now your function in Rust using `call_bitcode_fn` in `llvm/src/build.rs`! ## How it works @@ -32,4 +32,4 @@ There will be two directories like `roc_builtins-[some random characters]`, look ## Calling bitcode functions -use the `call_bitcode_fn` function defined in `llvm/src/build.rs` to call bitcode funcitons. +use the `call_bitcode_fn` function defined in `llvm/src/build.rs` to call bitcode functions. diff --git a/compiler/builtins/bitcode/src/dec.zig b/compiler/builtins/bitcode/src/dec.zig index 1d51d4cc83..79f2eb0aeb 100644 --- a/compiler/builtins/bitcode/src/dec.zig +++ b/compiler/builtins/bitcode/src/dec.zig @@ -176,7 +176,7 @@ fn mul_and_decimalize(a: u128, b: u128) i128 { // floor(2^315/10^18) is 66749594872528440074844428317798503581334516323645399060845050244444366430645 // Add 1. - // This can't overflow because the intial numbers are only 127bit due to removing the sign bit. + // This can't overflow because the initial numbers are only 127bit due to removing the sign bit. var overflowed = @addWithOverflow(u128, lhs_lo, 1, &lhs_lo); lhs_hi = blk: { if (overflowed) { diff --git a/compiler/builtins/docs/List.roc b/compiler/builtins/docs/List.roc index 02866d5d37..7c0e7ae983 100644 --- a/compiler/builtins/docs/List.roc +++ b/compiler/builtins/docs/List.roc @@ -180,7 +180,7 @@ interface List2 ## we can free it immediately because there are no other refcounts. However, ## in the case of `lists`, we have to iterate through the list and decrement ## the refcounts of each of its contained lists - because they, too, have -## refcounts! Importantly, beacuse the first element had its refcount incremented +## refcounts! Importantly, because the first element had its refcount incremented ## because the function returned `first`, that element will actually end up ## *not* getting freed at the end - but all the others will be. ## diff --git a/compiler/builtins/docs/Num.roc b/compiler/builtins/docs/Num.roc index 419672c852..fdbd07cc02 100644 --- a/compiler/builtins/docs/Num.roc +++ b/compiler/builtins/docs/Num.roc @@ -318,7 +318,7 @@ Int size : Num [ @Int size ] ## >>> coordinates.x + 1 ## ## On the last line, the compiler infers that the `1` in `+ 1` is an #F32 -## beacuse it's being added to `coordinates.x`, which was defined to be an #F32 +## because it's being added to `coordinates.x`, which was defined to be an #F32 ## on the first line. ## ## Sometimes the compiler has no information about which specific type to pick. @@ -621,7 +621,7 @@ trunc : Float * -> Int * ## Since #Nat has a different maximum number depending on the system you're building ## for, this may give a different answer on different systems. ## -## For example, on a 32-bit sytem, #Num.maxNat will return the same answer as +## For example, on a 32-bit system, #Num.maxNat will return the same answer as ## #Num.maxU32. This means that calling `Num.toNat 9_000_000_000` on a 32-bit ## system will return #Num.maxU32 instead of 9 billion, because 9 billion is ## higher than #Num.maxU32 and will not fit in a #Nat on a 32-bit system. diff --git a/compiler/builtins/docs/Str.roc b/compiler/builtins/docs/Str.roc index 0727b68af8..c54a11b3b7 100644 --- a/compiler/builtins/docs/Str.roc +++ b/compiler/builtins/docs/Str.roc @@ -194,7 +194,7 @@ startsWith : Str, Str -> Bool ## if you want to check whether a string begins with something that's representable ## in a single code point, you can use (for example) `Str.startsWithCodePoint '鹏'` ## instead of `Str.startsWithCodePoint "鹏"`. ('鹏' evaluates to the [U32] -## value `40527`.) This will not work for graphemes which take up mulitple code +## value `40527`.) This will not work for graphemes which take up multiple code ## points, however; `Str.startsWithCodePoint '👩‍👩‍👦‍👦'` would be a compiler error ## because 👩‍👩‍👦‍👦 takes up multiple code points and cannot be represented as a ## single [U32]. You'd need to use `Str.startsWithCodePoint "🕊"` instead. diff --git a/compiler/can/src/expr.rs b/compiler/can/src/expr.rs index 9fd811c3e6..8e40ac2ad7 100644 --- a/compiler/can/src/expr.rs +++ b/compiler/can/src/expr.rs @@ -603,7 +603,7 @@ pub fn canonicalize_expr<'a>( // A "when" with no branches is a runtime error, but it will mess things up // if code gen mistakenly thinks this is a tail call just because its condition - // happend to be one. (The condition gave us our initial output value.) + // happened to be one. (The condition gave us our initial output value.) if branches.is_empty() { output.tail_call = None; } diff --git a/compiler/can/src/operator.rs b/compiler/can/src/operator.rs index e34340da64..4b6fbf14f2 100644 --- a/compiler/can/src/operator.rs +++ b/compiler/can/src/operator.rs @@ -345,7 +345,7 @@ pub fn desugar_expr<'a>(arena: &'a Bump, loc_expr: &'a Located>) -> &'a ) } If(if_thens, final_else_branch) => { - // If does not get desugared into `when` so we can give more targetted error messages during type checking. + // If does not get desugared into `when` so we can give more targeted error messages during type checking. let desugared_final_else = &*arena.alloc(desugar_expr(arena, &final_else_branch)); let mut desugared_if_thens = Vec::with_capacity_in(if_thens.len(), arena); diff --git a/compiler/constrain/src/builtins.rs b/compiler/constrain/src/builtins.rs index 807d542e73..4704c67539 100644 --- a/compiler/constrain/src/builtins.rs +++ b/compiler/constrain/src/builtins.rs @@ -13,7 +13,7 @@ use roc_types::types::Type::{self, *}; #[inline(always)] pub fn int_literal( num_var: Variable, - percision_var: Variable, + precision_var: Variable, expected: Expected, region: Region, ) -> Constraint { @@ -25,7 +25,7 @@ pub fn int_literal( And(vec![ Eq( num_type.clone(), - ForReason(reason, num_int(Type::Variable(percision_var)), region), + ForReason(reason, num_int(Type::Variable(precision_var)), region), Category::Int, region, ), diff --git a/compiler/constrain/src/expr.rs b/compiler/constrain/src/expr.rs index c4c5b5ed8e..ab5a9e15ca 100644 --- a/compiler/constrain/src/expr.rs +++ b/compiler/constrain/src/expr.rs @@ -96,7 +96,7 @@ pub fn constrain_expr( expected: Expected, ) -> Constraint { match expr { - Int(var, percision, _) => int_literal(*var, *percision, expected, region), + Int(var, precision, _) => int_literal(*var, *precision, expected, region), Num(var, _) => exists( vec![*var], Eq( @@ -106,7 +106,7 @@ pub fn constrain_expr( region, ), ), - Float(var, percision, _) => float_literal(*var, *percision, expected, region), + Float(var, precision, _) => float_literal(*var, *precision, expected, region), EmptyRecord => constrain_empty_record(region, expected), Expr::Record { record_var, fields } => { if fields.is_empty() { diff --git a/compiler/constrain/src/module.rs b/compiler/constrain/src/module.rs index ee580ad0a4..a6462eb570 100644 --- a/compiler/constrain/src/module.rs +++ b/compiler/constrain/src/module.rs @@ -146,7 +146,7 @@ pub fn pre_constrain_imports( // Translate referenced symbols into constraints. We do this on the main // thread because we need exclusive access to the exposed_types map, in order // to get the necessary constraint info for any aliases we imported. We also - // resolve builtin types now, so we can use a refernce to stdlib instead of + // resolve builtin types now, so we can use a reference to stdlib instead of // having to either clone it or recreate it from scratch on the other thread. for &symbol in references.iter() { let module_id = symbol.module_id(); diff --git a/compiler/fmt/tests/test_fmt.rs b/compiler/fmt/tests/test_fmt.rs index ebcf367152..edf60c1696 100644 --- a/compiler/fmt/tests/test_fmt.rs +++ b/compiler/fmt/tests/test_fmt.rs @@ -116,7 +116,7 @@ mod test_fmt { } #[test] - fn force_space_at_begining_of_comment() { + fn force_space_at_beginning_of_comment() { expr_formats_to( indoc!( r#" diff --git a/compiler/gen/src/llvm/build.rs b/compiler/gen/src/llvm/build.rs index 06e08dcdd5..67ffd5837e 100644 --- a/compiler/gen/src/llvm/build.rs +++ b/compiler/gen/src/llvm/build.rs @@ -1472,7 +1472,7 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( let builder = env.builder; - // Determine types, assumes the descriminant is in the field layouts + // Determine types, assumes the discriminant is in the field layouts let num_fields = field_layouts.len(); let mut field_types = Vec::with_capacity_in(num_fields, env.arena); @@ -5147,7 +5147,7 @@ fn build_int_binop<'a, 'ctx, 'env>( // rem == 0 // } // - // NOTE we'd like the branches to be swapped for better branch prediciton, + // NOTE we'd like the branches to be swapped for better branch prediction, // but llvm normalizes to the above ordering in -O3 let zero = rhs.get_type().const_zero(); let neg_1 = rhs.get_type().const_int(-1i64 as u64, false); @@ -5494,7 +5494,7 @@ fn build_int_unary_op<'a, 'ctx, 'env>( int_abs_raise_on_overflow(env, arg, arg_layout) } NumToFloat => { - // TODO: Handle differnt sized numbers + // TODO: Handle different sized numbers // This is an Int, so we need to convert it. bd.build_cast( InstructionOpcode::SIToFP, @@ -5618,7 +5618,7 @@ fn build_float_unary_op<'a, 'ctx, 'env>( let bd = env.builder; - // TODO: Handle differnt sized floats + // TODO: Handle different sized floats match op { NumNeg => bd.build_float_neg(arg, "negate_float").into(), NumAbs => env.call_intrinsic(LLVM_FABS_F64, &[arg.into()]), @@ -5759,7 +5759,7 @@ fn throw_exception<'a, 'ctx, 'env>(env: &Env<'a, 'ctx, 'env>, message: &str) { let builder = env.builder; let info = { - // we represend both void and char pointers with `u8*` + // we represented both void and char pointers with `u8*` let u8_ptr = context.i8_type().ptr_type(AddressSpace::Generic); // allocate an exception (that can hold a pointer to a string) diff --git a/compiler/gen_dev/README.md b/compiler/gen_dev/README.md index 6cbe429895..a9b544b93c 100644 --- a/compiler/gen_dev/README.md +++ b/compiler/gen_dev/README.md @@ -5,7 +5,7 @@ It goes from Roc's [mono ir](https://github.com/rtfeldman/roc/blob/trunk/compile ## General Process -The backend is essentially defined as two recursive match statment over the mono ir. +The backend is essentially defined as two recursive match statement over the mono ir. The first pass is used to do simple linear scan lifetime analysis. In the future it may be expanded to add a few other quick optimizations. The second pass is the actual meat of the backend that generates the byte buffer of output binary. @@ -62,7 +62,7 @@ Here are example implementations for [arm](https://github.com/rtfeldman/roc/blob Adding a new builtin to the dev backend can be pretty simple. Here is [an example](https://github.com/rtfeldman/roc/pull/893/files) of adding `Num.Sub`. -This is the general procede I follow with some helpful links: +This is the general procedure I follow with some helpful links: 1. Find a feature that is just n+1. For example, since we already have integers, adding a builtin that functions on them should be n+1. diff --git a/compiler/gen_dev/src/generic64/mod.rs b/compiler/gen_dev/src/generic64/mod.rs index af67498706..bf394204da 100644 --- a/compiler/gen_dev/src/generic64/mod.rs +++ b/compiler/gen_dev/src/generic64/mod.rs @@ -205,7 +205,7 @@ pub struct Backend64Bit< float_used_callee_saved_regs: MutSet, stack_size: u32, - // The ammount of stack space needed to pass args for function calling. + // The amount of stack space needed to pass args for function calling. fn_call_stack_size: u32, } @@ -409,7 +409,7 @@ impl< Ok(()) } x => Err(format!( - "recieving return type, {:?}, is not yet implemented", + "receiving return type, {:?}, is not yet implemented", x )), } diff --git a/compiler/gen_dev/src/generic64/x86_64.rs b/compiler/gen_dev/src/generic64/x86_64.rs index d0b8053056..53345db889 100644 --- a/compiler/gen_dev/src/generic64/x86_64.rs +++ b/compiler/gen_dev/src/generic64/x86_64.rs @@ -236,7 +236,7 @@ impl CallConv for X86_64SystemV { Layout::Builtin(Builtin::Float64) => {} x => { return Err(format!( - "recieving return type, {:?}, is not yet implemented", + "receiving return type, {:?}, is not yet implemented", x )); } @@ -530,7 +530,7 @@ impl CallConv for X86_64WindowsFastcall { Layout::Builtin(Builtin::Float64) => {} x => { return Err(format!( - "recieving return type, {:?}, is not yet implemented", + "receiving return type, {:?}, is not yet implemented", x )); } diff --git a/compiler/gen_dev/src/lib.rs b/compiler/gen_dev/src/lib.rs index 37dd7fe316..790aa9b6ac 100644 --- a/compiler/gen_dev/src/lib.rs +++ b/compiler/gen_dev/src/lib.rs @@ -145,7 +145,7 @@ where ) -> Result<(), String>; /// build_expr builds the expressions for the specified symbol. - /// The builder must keep track of the symbol because it may be refered to later. + /// The builder must keep track of the symbol because it may be referred to later. fn build_expr( &mut self, sym: &Symbol, @@ -230,7 +230,7 @@ where } /// build_run_low_level builds the low level opertation and outputs to the specified symbol. - /// The builder must keep track of the symbol because it may be refered to later. + /// The builder must keep track of the symbol because it may be referred to later. fn build_run_low_level( &mut self, sym: &Symbol, diff --git a/compiler/load/src/docs.rs b/compiler/load/src/docs.rs index 32d742dedc..371d9d3ddf 100644 --- a/compiler/load/src/docs.rs +++ b/compiler/load/src/docs.rs @@ -1,4 +1,4 @@ -use crate::docs::DocEntry::DetatchedDoc; +use crate::docs::DocEntry::DetachedDoc; use crate::docs::TypeAnnotation::{ Apply, BoundVariable, Function, NoTypeAnn, ObscuredRecord, ObscuredTagUnion, Record, TagUnion, }; @@ -32,7 +32,7 @@ pub struct ModuleDocumentation { #[derive(Debug, Clone)] pub enum DocEntry { DocDef(DocDef), - DetatchedDoc(String), + DetachedDoc(String), } #[derive(Debug, Clone)] @@ -108,10 +108,10 @@ pub fn generate_module_docs<'a>( } } -fn detatched_docs_from_comments_and_new_lines<'a>( +fn detached_docs_from_comments_and_new_lines<'a>( comments_or_new_lines: &'a [roc_parse::ast::CommentOrNewline<'a>], ) -> Vec { - let mut detatched_docs: Vec = Vec::new(); + let mut detached_docs: Vec = Vec::new(); let mut docs = String::new(); @@ -123,13 +123,13 @@ fn detatched_docs_from_comments_and_new_lines<'a>( } CommentOrNewline::LineComment(_) | CommentOrNewline::Newline => { - detatched_docs.push(docs.clone()); + detached_docs.push(docs.clone()); docs = String::new(); } } } - detatched_docs + detached_docs } fn generate_entry_doc<'a>( @@ -147,8 +147,8 @@ fn generate_entry_doc<'a>( Def::SpaceBefore(sub_def, comments_or_new_lines) => { // Comments before a definition are attached to the current defition - for detatched_doc in detatched_docs_from_comments_and_new_lines(comments_or_new_lines) { - acc.push(DetatchedDoc(detatched_doc)); + for detached_doc in detached_docs_from_comments_and_new_lines(comments_or_new_lines) { + acc.push(DetachedDoc(detached_doc)); } generate_entry_doc(ident_ids, acc, Some(comments_or_new_lines), sub_def) diff --git a/compiler/mono/src/borrow.rs b/compiler/mono/src/borrow.rs index 7e7889b7a7..963ab1e2c6 100644 --- a/compiler/mono/src/borrow.rs +++ b/compiler/mono/src/borrow.rs @@ -40,7 +40,7 @@ pub fn infer_borrow<'a>( // This is a fixed-point analysis // - // all functions initiall own all their paramters + // all functions initiall own all their parameters // through a series of checks and heuristics, some arguments are set to borrowed // when that doesn't lead to conflicts the change is kept, otherwise it may be reverted // @@ -348,7 +348,7 @@ impl<'a> BorrowInfState<'a> { /// let z = e in ... /// /// and determines whether z and which of the symbols used in e - /// must be taken as owned paramters + /// must be taken as owned parameters fn collect_call(&mut self, z: Symbol, e: &crate::ir::Call<'a>) { use crate::ir::CallType::*; diff --git a/compiler/mono/src/inc_dec.rs b/compiler/mono/src/inc_dec.rs index e47dec4586..399ee995c9 100644 --- a/compiler/mono/src/inc_dec.rs +++ b/compiler/mono/src/inc_dec.rs @@ -7,16 +7,16 @@ use roc_collections::all::{MutMap, MutSet}; use roc_module::symbol::Symbol; pub fn free_variables(stmt: &Stmt<'_>) -> MutSet { - let (mut occuring, bound) = occuring_variables(stmt); + let (mut occurring, bound) = occurring_variables(stmt); for ref s in bound { - occuring.remove(s); + occurring.remove(s); } - occuring + occurring } -pub fn occuring_variables(stmt: &Stmt<'_>) -> (MutSet, MutSet) { +pub fn occurring_variables(stmt: &Stmt<'_>) -> (MutSet, MutSet) { let mut stack = std::vec![stmt]; let mut result = MutSet::default(); let mut bound_variables = MutSet::default(); @@ -26,7 +26,7 @@ pub fn occuring_variables(stmt: &Stmt<'_>) -> (MutSet, MutSet) { match stmt { Let(symbol, expr, _, cont) => { - occuring_variables_expr(expr, &mut result); + occurring_variables_expr(expr, &mut result); result.insert(*symbol); bound_variables.insert(*symbol); stack.push(cont); @@ -39,7 +39,7 @@ pub fn occuring_variables(stmt: &Stmt<'_>) -> (MutSet, MutSet) { fail, .. } => { - occuring_variables_call(call, &mut result); + occurring_variables_call(call, &mut result); result.insert(*symbol); bound_variables.insert(*symbol); stack.push(pass); @@ -93,13 +93,13 @@ pub fn occuring_variables(stmt: &Stmt<'_>) -> (MutSet, MutSet) { (result, bound_variables) } -fn occuring_variables_call(call: &crate::ir::Call<'_>, result: &mut MutSet) { +fn occurring_variables_call(call: &crate::ir::Call<'_>, result: &mut MutSet) { // NOTE though the function name does occur, it is a static constant in the program // for liveness, it should not be included here. result.extend(call.arguments.iter().copied()); } -pub fn occuring_variables_expr(expr: &Expr<'_>, result: &mut MutSet) { +pub fn occurring_variables_expr(expr: &Expr<'_>, result: &mut MutSet) { use Expr::*; match expr { @@ -109,7 +109,7 @@ pub fn occuring_variables_expr(expr: &Expr<'_>, result: &mut MutSet) { result.insert(*symbol); } - Call(call) => occuring_variables_call(call, result), + Call(call) => occurring_variables_call(call, result), Tag { arguments, .. } | Struct(arguments) @@ -160,13 +160,13 @@ struct Context<'a> { fn update_live_vars<'a>(expr: &Expr<'a>, v: &LiveVarSet) -> LiveVarSet { let mut v = v.clone(); - occuring_variables_expr(expr, &mut v); + occurring_variables_expr(expr, &mut v); v } /// `isFirstOcc xs x i = true` if `xs[i]` is the first occurrence of `xs[i]` in `xs` -fn is_first_occurence(xs: &[Symbol], i: usize) -> bool { +fn is_first_occurrence(xs: &[Symbol], i: usize) -> bool { match xs.get(i) { None => unreachable!(), Some(s) => i == xs.iter().position(|v| s == v).unwrap(), @@ -319,7 +319,7 @@ impl<'a> Context<'a> { { for (i, x) in xs.iter().enumerate() { let info = self.get_var_info(*x); - if !info.reference || !is_first_occurence(xs, i) { + if !info.reference || !is_first_occurrence(xs, i) { // do nothing } else { let num_consumptions = get_num_consumptions(*x, xs, consume_param_pred.clone()); // number of times the argument is used @@ -393,7 +393,7 @@ impl<'a> Context<'a> { // Remark: `x` may occur multiple times in the application (e.g., `f x y x`). // This is why we check whether it is the first occurrence. if self.must_consume(*x) - && is_first_occurence(xs, i) + && is_first_occurrence(xs, i) && is_borrow_param(*x, xs, ps) && !b_live_vars.contains(x) { @@ -418,7 +418,7 @@ impl<'a> Context<'a> { This is why we check whether it is the first occurrence. */ if self.must_consume(*x) - && is_first_occurence(xs, i) + && is_first_occurrence(xs, i) && *is_borrow && !b_live_vars.contains(x) { @@ -1096,7 +1096,7 @@ pub fn collect_stmt( vars = collect_stmt(cont, jp_live_vars, vars); vars.remove(symbol); let mut result = MutSet::default(); - occuring_variables_expr(expr, &mut result); + occurring_variables_expr(expr, &mut result); vars.extend(result); vars @@ -1114,7 +1114,7 @@ pub fn collect_stmt( vars.remove(symbol); let mut result = MutSet::default(); - occuring_variables_call(call, &mut result); + occurring_variables_call(call, &mut result); vars.extend(result); diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 29da0e66e3..20b78daa47 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -7663,7 +7663,7 @@ pub fn num_argument_to_int_or_float( 4 => IntOrFloat::UnsignedIntType(IntPrecision::I32), 8 => IntOrFloat::UnsignedIntType(IntPrecision::I64), _ => panic!( - "Invalid target for Num type arguement: Roc does't support compiling to {}-bit systems.", + "Invalid target for Num type argument: Roc does't support compiling to {}-bit systems.", ptr_bytes * 8 ), } diff --git a/compiler/parse/src/expr.rs b/compiler/parse/src/expr.rs index 5483d2c278..5f8f972d43 100644 --- a/compiler/parse/src/expr.rs +++ b/compiler/parse/src/expr.rs @@ -418,7 +418,7 @@ impl<'a> ExprState<'a> { F: Fn(Region, Row, Col) -> EExpr<'a>, { if !self.operators.is_empty() { - // this `=` or `<-` likely occured inline; treat it as an invalid operator + // this `=` or `<-` likely occurred inline; treat it as an invalid operator let opchar = match loc_op.value { BinOp::Assignment => arena.alloc([b'=']) as &[_], BinOp::Backpassing => arena.alloc([b'<', b'-']) as &[_], @@ -451,7 +451,7 @@ impl<'a> ExprState<'a> { debug_assert_eq!(loc_op.value, BinOp::HasType); if !self.operators.is_empty() { - // this `:` likely occured inline; treat it as an invalid operator + // this `:` likely occurred inline; treat it as an invalid operator let opchar = arena.alloc([b':']) as &[_]; let fail = @@ -1000,7 +1000,7 @@ fn parse_expr_operator<'a>( (&*arena.alloc(Located::at(alias_region, alias)), state) } Err(_) => { - // this `=` likely occured inline; treat it as an invalid operator + // this `=` likely occurred inline; treat it as an invalid operator let fail = EExpr::BadOperator( arena.alloc([b'=']), loc_op.region.start_line, @@ -1044,7 +1044,7 @@ fn parse_expr_operator<'a>( (Located::at(expr_region, good), ann_type, state) } Err(_) => { - // this `=` likely occured inline; treat it as an invalid operator + // this `=` likely occurred inline; treat it as an invalid operator let fail = EExpr::BadOperator( arena.alloc([b'=']), loc_op.region.start_line, @@ -1153,7 +1153,7 @@ fn parse_expr_operator<'a>( } } Err(_) => { - // this `:` likely occured inline; treat it as an invalid operator + // this `:` likely occurred inline; treat it as an invalid operator let fail = EExpr::BadOperator( arena.alloc([b':']), loc_op.region.start_line, diff --git a/compiler/parse/tests/test_parse.rs b/compiler/parse/tests/test_parse.rs index 79ecfca92f..58ca1d2dee 100644 --- a/compiler/parse/tests/test_parse.rs +++ b/compiler/parse/tests/test_parse.rs @@ -3385,7 +3385,7 @@ mod test_parse { // Reproducing this bug requires a bizarre set of things to all be true: // // * Must be parsing a *module* def (nested expr defs don't repro this) - // * That top-level module def conatins a def inside it + // * That top-level module def contains a def inside it // * That inner def is defining a function // * The name of the inner def begins with a keyword (`if`, `then`, `else`, `when`, `is`) // diff --git a/compiler/reporting/src/error/parse.rs b/compiler/reporting/src/error/parse.rs index 0d1491711b..646f675580 100644 --- a/compiler/reporting/src/error/parse.rs +++ b/compiler/reporting/src/error/parse.rs @@ -1973,7 +1973,7 @@ fn to_type_report<'a>( let region = Region::from_row_col(*row, *col); let doc = alloc.stack(vec![ - alloc.reflow(r"I just started parsing a function argument type, but I encounterd two commas in a row:"), + alloc.reflow(r"I just started parsing a function argument type, but I encountered two commas in a row:"), alloc.region_with_subregion(surroundings, region), alloc.concat(vec![alloc.reflow("Try removing one of them.")]), ]); diff --git a/compiler/reporting/src/error/type.rs b/compiler/reporting/src/error/type.rs index 5e03b5ef6a..f4f3723257 100644 --- a/compiler/reporting/src/error/type.rs +++ b/compiler/reporting/src/error/type.rs @@ -1046,7 +1046,7 @@ fn to_pattern_report<'b>( let doc = alloc.stack(vec![ alloc.text("This pattern is being used in an unexpected way:"), alloc.region(expr_region), - pattern_type_comparision( + pattern_type_comparison( alloc, found, expected_type, @@ -1078,7 +1078,7 @@ fn to_pattern_report<'b>( .append(name.clone()) .append(alloc.text(" is weird:")), alloc.region(region), - pattern_type_comparision( + pattern_type_comparison( alloc, found, expected_type, @@ -1112,7 +1112,7 @@ fn to_pattern_report<'b>( .append(alloc.keyword("when")) .append(alloc.text(" is causing a mismatch:")), alloc.region(region), - pattern_type_comparision( + pattern_type_comparison( alloc, found, expected_type, @@ -1144,7 +1144,7 @@ fn to_pattern_report<'b>( .append(alloc.keyword("when")) .append(alloc.text(" does not match the previous ones:")), alloc.region(region), - pattern_type_comparision( + pattern_type_comparison( alloc, found, expected_type, @@ -1175,7 +1175,7 @@ fn to_pattern_report<'b>( } } -fn pattern_type_comparision<'b>( +fn pattern_type_comparison<'b>( alloc: &'b RocDocAllocator<'b>, actual: ErrorType, expected: ErrorType, diff --git a/compiler/reporting/src/report.rs b/compiler/reporting/src/report.rs index 6349bb8708..a96480fa78 100644 --- a/compiler/reporting/src/report.rs +++ b/compiler/reporting/src/report.rs @@ -450,11 +450,11 @@ impl<'a> RocDocAllocator<'a> { } else { ERROR_UNDERLINE.repeat((sub_region2.end_col - sub_region2.start_col) as usize) }; - let inbetween = " " + let in_between = " " .repeat((sub_region2.start_col.saturating_sub(sub_region1.end_col)) as usize); self.text(highlight1) - .append(self.text(inbetween)) + .append(self.text(in_between)) .append(self.text(highlight2)) }; diff --git a/compiler/reporting/tests/test_reporting.rs b/compiler/reporting/tests/test_reporting.rs index 6f1ba3f687..16dbb29fbb 100644 --- a/compiler/reporting/tests/test_reporting.rs +++ b/compiler/reporting/tests/test_reporting.rs @@ -4774,7 +4774,7 @@ mod test_reporting { r#" ── DOUBLE COMMA ──────────────────────────────────────────────────────────────── - I just started parsing a function argument type, but I encounterd two + I just started parsing a function argument type, but I encountered two commas in a row: 1│ f : I64,,I64 -> I64 diff --git a/compiler/solve/src/solve.rs b/compiler/solve/src/solve.rs index 4e54259f5a..a683be04f4 100644 --- a/compiler/solve/src/solve.rs +++ b/compiler/solve/src/solve.rs @@ -793,7 +793,7 @@ fn type_to_variable( Alias(symbol, args, alias_type) => { // TODO cache in uniqueness inference gives problems! all Int's get the same uniqueness var! // Cache aliases without type arguments. Commonly used aliases like `Int` would otherwise get O(n) - // different variables (once for each occurence). The recursion restriction is required + // different variables (once for each occurrence). The recursion restriction is required // for uniqueness types only: recursive aliases "introduce" an unbound uniqueness // attribute in the body, when // diff --git a/compiler/str/README.md b/compiler/str/README.md index b49935e8b2..2ab0c3c25d 100644 --- a/compiler/str/README.md +++ b/compiler/str/README.md @@ -82,7 +82,7 @@ When calling `List.append list1 list2` on a unique `list1`, first we'll check to If there is not enough capacity to fit both lists, then we can try to call [`realloc`](https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/realloc?view=vs-2019) to hopefully extend the size of our allocated memory. If `realloc` succeeds (meaning there happened to be enough free memory right after our current allocation), then we update `capacity` to reflect the new amount of space, and move on. -> **Note:** The reason we store capacity right after the last element in the list is becasue of how memory cache lines work. Whenever we need to access `capacity`, it's because we're about to increase the length of the list, which means that we will most certainly be writing to the memory location right after its last element. That in turn means that we'll need to have that memory location in cache, which in turn means that looking up the `capacity` there is guaranteed not to cause a cache miss. (It's possible that writing the new capacity value to a later address could cause a cache miss, but this strategy minimizes the chance of that happening.) An alternate design would be where we store the capacity right before the first element in the list. In that design we wouldn't have to re-write the capacity value at the end of the list every time we grew it, but we'd be much more likely to incur more cache misses that way - because we're working at the end of the list, not at the beginning. Cache misses are many times more expensive than an extra write to a memory address that's in cache already, not to mention the potential extra load instruction to add the length to the memory address of the first element (instead of subtracting 1 from that address), so we optimize for minimizing the highly expensive cache misses by always paying a tiny additional cost when increasing the length of the list, as well as a potential even tinier cost (zero, if the length already happens to be in a register) when looking up its capacity or refcount. +> **Note:** The reason we store capacity right after the last element in the list is because of how memory cache lines work. Whenever we need to access `capacity`, it's because we're about to increase the length of the list, which means that we will most certainly be writing to the memory location right after its last element. That in turn means that we'll need to have that memory location in cache, which in turn means that looking up the `capacity` there is guaranteed not to cause a cache miss. (It's possible that writing the new capacity value to a later address could cause a cache miss, but this strategy minimizes the chance of that happening.) An alternate design would be where we store the capacity right before the first element in the list. In that design we wouldn't have to re-write the capacity value at the end of the list every time we grew it, but we'd be much more likely to incur more cache misses that way - because we're working at the end of the list, not at the beginning. Cache misses are many times more expensive than an extra write to a memory address that's in cache already, not to mention the potential extra load instruction to add the length to the memory address of the first element (instead of subtracting 1 from that address), so we optimize for minimizing the highly expensive cache misses by always paying a tiny additional cost when increasing the length of the list, as well as a potential even tinier cost (zero, if the length already happens to be in a register) when looking up its capacity or refcount. If `realloc` fails, then we have to fall back on the same "allocate new memory and copy everything" strategy that we do with shared lists. @@ -107,7 +107,7 @@ Since each bool value is a byte, it's okay for them to be packed side-by-side ev Note that unlike in the `List Str` example before, there wouldn't be any unused memory between the refcount (or capacity, depending on whether the list was shared or unique) and the first element in the list. That will always be the case when the size of the refcount is no bigger than the alignment of the list's elements. -## Distinguishing bewteen refcount and capacity in the host +## Distinguishing between refcount and capacity in the host If I'm a platform author, and I receive a `List` from the application, it's important that I be able to tell whether I'm dealing with a refcount or a capacity. (The uniqueness type information will have been erased by this time, because some applications will return a Unique list while others return a Shared list, so I need to be able to tell using runtime information only which is which.) This way, I can know to either increment the refcount, or to feel free to mutate it in-place using the capacity value. diff --git a/compiler/test_gen/src/gen_list.rs b/compiler/test_gen/src/gen_list.rs index 4aed0a0c6c..b6384a8ba5 100644 --- a/compiler/test_gen/src/gen_list.rs +++ b/compiler/test_gen/src/gen_list.rs @@ -383,7 +383,7 @@ fn list_walk_with_str() { } #[test] -fn list_walk_substraction() { +fn list_walk_subtraction() { assert_evals_to!(r#"List.walk [ 1, 2 ] Num.sub 1"#, 2, i64); } diff --git a/docs/src/lib.rs b/docs/src/lib.rs index 718ae50ba1..59e1061c4f 100644 --- a/docs/src/lib.rs +++ b/docs/src/lib.rs @@ -142,7 +142,7 @@ fn render_main_content(interns: &Interns, module: &mut ModuleDocumentation) -> S ); } } - DocEntry::DetatchedDoc(docs) => { + DocEntry::DetachedDoc(docs) => { buf.push_str( markdown_to_html(&mut module.scope, interns, docs.to_string()).as_str(), ); diff --git a/editor/editor-ideas.md b/editor/editor-ideas.md index f17adf94a3..34195135c2 100644 --- a/editor/editor-ideas.md +++ b/editor/editor-ideas.md @@ -102,7 +102,7 @@ e.g. you have a test `calculate_sum_test` that only uses the function `add`, whe * When refactoring; - Cutting and pasting code to a new file should automatically add imports to the new file and delete them from the old file. - Ability to link e.g. variable name in comments to actual variable name. Comment is automatically updated when variable name is changed. - - When updating dependencies with breaking changes; show similar diffs from github projects that have succesfully updated that dependency. + - When updating dependencies with breaking changes; show similar diffs from github projects that have successfully updated that dependency. - AST backed renaming, changing variable/function/type name should change it all over the codebase. * Automatically create all "arms" when pattern matching after entering `when var is` based on the type. - All `when ... is` should be updated if the type is changed, e.g. adding Indigo to the Color type should add an arm everywhere where `when color is` is used. @@ -133,7 +133,7 @@ e.g. you have a test `calculate_sum_test` that only uses the function `add`, whe - Webcam based eye tracking for quick selection. - Machine Learning: * GPT-3 can generate correct python functions based on a comment describing the functionality, video [here](https://www.youtube.com/watch?v=utuz7wBGjKM). It's possible that training a model using ast's may lead to better results than text based models. -- Current autocomplete lacks flow, moving through suggestions with arrows is slow. Being able to code by weaving together autocomplete suggestions layed out in rows using eye tracking, that could flow. +- Current autocomplete lacks flow, moving through suggestions with arrows is slow. Being able to code by weaving together autocomplete suggestions laid out in rows using eye tracking, that could flow. #### Productivity Inspiration @@ -205,9 +205,9 @@ Thoughts and ideas possibly taken from above inspirations or separate. Or Total blindness where we need to trough sound to communicate to the user Screen readers read trees of labeled elements. Each platform has different apis, but I think they are horrible. Just close your eyes and imagine listening to screen reader all day while you are using this majectic machines called computers. But blind people walk with a tool and they can react much better to sound/space relations than full on visal majority does. They are acute to sound as a spatial hint. And a hand for most of them is a very sensitive tool that can make sounds in space. - Imagine if everytime for the user doesnt want to rely on shining rendered pixels on the screen for a feedback from machine, we make a accoustic room simulation, where with moving the "stick", either with mouse or with key arrows, we bump into one of the objects and that produces certain contextually appropriate sound (clean)*ding* + Imagine if everytime for the user doesnt want to rely on shining rendered pixels on the screen for a feedback from machine, we make a acoustic room simulation, where with moving the "stick", either with mouse or with key arrows, we bump into one of the objects and that produces certain contextually appropriate sound (clean)*ding* - On the each level of abstraction they can make sounds more deeper, so then when you type letters you feel like you are playing with the sand (soft)*shh*. We would need help from some sound engeneer about it, but imagine moving down, which can be voice trigered command for motion impaired, you hear (soft)*pup* and the name of the module, and then you have options and commands appropriate for the module, they could map to those basic 4 buttons that we trained user on, and he would shortcut all the soft talk with click of a button. Think of the satisfaction when you can skip the dialog of the game and get straight into action. (X) Open functions! each function would make a sound and say its name, unless you press search and start searching for a specific function inside module, if you want one you select or move to next. + On the each level of abstraction they can make sounds more deeper, so then when you type letters you feel like you are playing with the sand (soft)*shh*. We would need help from some sound engineer about it, but imagine moving down, which can be voice trigered command for motion impaired, you hear (soft)*pup* and the name of the module, and then you have options and commands appropriate for the module, they could map to those basic 4 buttons that we trained user on, and he would shortcut all the soft talk with click of a button. Think of the satisfaction when you can skip the dialog of the game and get straight into action. (X) Open functions! each function would make a sound and say its name, unless you press search and start searching for a specific function inside module, if you want one you select or move to next. * Motor impariments [rant]BACKS OF CODERS ARE NOT HEALTHY! We need to change that![/neverstop] diff --git a/editor/src/editor/grid_node_map.rs b/editor/src/editor/grid_node_map.rs index f5f2944cd2..f455782099 100644 --- a/editor/src/editor/grid_node_map.rs +++ b/editor/src/editor/grid_node_map.rs @@ -105,7 +105,7 @@ impl GridNodeMap { } } - // get position of first occurence of node_id if get_first_pos, else get the last occurence + // get position of first occurrence of node_id if get_first_pos, else get the last occurrence pub fn get_node_position(&self, node_id: MarkNodeId, get_first_pos: bool) -> EdResult { let mut last_pos_opt = None; diff --git a/editor/src/editor/mvc/app_model.rs b/editor/src/editor/mvc/app_model.rs index 0709bfd381..b537e7a34f 100644 --- a/editor/src/editor/mvc/app_model.rs +++ b/editor/src/editor/mvc/app_model.rs @@ -81,7 +81,7 @@ pub fn set_clipboard_txt(clipboard_opt: &mut Option, txt: &str) -> Ed clipboard.set_content(txt.to_owned())?; } else { return Err(ClipboardWriteFailed { - err_msg: "Clipboard was never initialized succesfully.".to_owned(), + err_msg: "Clipboard was never initialized successfully.".to_owned(), }); } @@ -93,7 +93,7 @@ pub fn get_clipboard_txt(clipboard_opt: &mut Option) -> EdResult(elt: T, slice: &[T]) -> EdR Ok(index) } -// returns the index of the first occurence of element and index of the last occurence +// returns the index of the first occurrence of element and index of the last occurrence pub fn first_last_index_of( elt: T, slice: &[T], diff --git a/editor/src/graphics/lowlevel/ortho.rs b/editor/src/graphics/lowlevel/ortho.rs index c3bcab80bb..0b5871bb93 100644 --- a/editor/src/graphics/lowlevel/ortho.rs +++ b/editor/src/graphics/lowlevel/ortho.rs @@ -5,7 +5,7 @@ use wgpu::{ ShaderStage, }; -// orthographic projection is used to transfrom pixel coords to the coordinate system used by wgpu +// orthographic projection is used to transform pixel coords to the coordinate system used by wgpu #[repr(C)] #[derive(Debug, Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)] diff --git a/editor/src/lang/constrain.rs b/editor/src/lang/constrain.rs index 8150d76638..37d5d07d09 100644 --- a/editor/src/lang/constrain.rs +++ b/editor/src/lang/constrain.rs @@ -630,7 +630,7 @@ pub fn constrain_expr<'a>( } } } - _ => todo!("implement constaints for {:?}", expr), + _ => todo!("implement constraints for {:?}", expr), } } diff --git a/editor/src/lang/expr.rs b/editor/src/lang/expr.rs index 6bd59b09ac..ccd7cb9846 100644 --- a/editor/src/lang/expr.rs +++ b/editor/src/lang/expr.rs @@ -555,7 +555,7 @@ pub fn to_expr2<'a>( // A "when" with no branches is a runtime error, but it will mess things up // if code gen mistakenly thinks this is a tail call just because its condition - // happend to be one. (The condition gave us our initial output value.) + // happened to be one. (The condition gave us our initial output value.) if branches.is_empty() { output.tail_call = None; } diff --git a/editor/src/lang/solve.rs b/editor/src/lang/solve.rs index eac4fe4bf5..08d7f348cd 100644 --- a/editor/src/lang/solve.rs +++ b/editor/src/lang/solve.rs @@ -776,7 +776,7 @@ fn type_to_variable<'a>( Alias(symbol, args, alias_type_id) => { // TODO cache in uniqueness inference gives problems! all Int's get the same uniqueness var! // Cache aliases without type arguments. Commonly used aliases like `Int` would otherwise get O(n) - // different variables (once for each occurence). The recursion restriction is required + // different variables (once for each occurrence). The recursion restriction is required // for uniqueness types only: recursive aliases "introduce" an unbound uniqueness // attribute in the body, when // diff --git a/packages/unicode/src/Unicode/Scalar.roc b/packages/unicode/src/Unicode/Scalar.roc index 18bba5854a..87aec618ba 100644 --- a/packages/unicode/src/Unicode/Scalar.roc +++ b/packages/unicode/src/Unicode/Scalar.roc @@ -26,7 +26,7 @@ toStr = \@Scalar u32 Ok str -> str Err _ -> # This will quickly crash if it ever runs, but we're confident - # this Err branch will never run. That's becasue it only runs + # this Err branch will never run. That's because it only runs # if Str.fromScalar receives an invalid scalar value, and we've # already validated this! toStr (@Scalar (scalar * 256)) diff --git a/vendor/pretty/src/lib.rs b/vendor/pretty/src/lib.rs index 4fdc587f7a..5471aa9429 100644 --- a/vendor/pretty/src/lib.rs +++ b/vendor/pretty/src/lib.rs @@ -185,9 +185,9 @@ macro_rules! impl_doc { /// Mark this document as a group. /// - /// Groups are layed out on a single line if possible. Within a group, all basic documents with - /// several possible layouts are assigned the same layout, that is, they are all layed out - /// horizontally and combined into a one single line, or they are each layed out on their own + /// Groups are laid out on a single line if possible. Within a group, all basic documents with + /// several possible layouts are assigned the same layout, that is, they are all laid out + /// horizontally and combined into a one single line, or they are each laid out on their own /// line. #[inline] pub fn group(self) -> Self { @@ -714,9 +714,9 @@ where /// Mark this document as a group. /// - /// Groups are layed out on a single line if possible. Within a group, all basic documents with - /// several possible layouts are assigned the same layout, that is, they are all layed out - /// horizontally and combined into a one single line, or they are each layed out on their own + /// Groups are laid out on a single line if possible. Within a group, all basic documents with + /// several possible layouts are assigned the same layout, that is, they are all laid out + /// horizontally and combined into a one single line, or they are each laid out on their own /// line. #[inline] pub fn group(self) -> DocBuilder<'a, D, A> { From ed3f720dd24c97443932f11f883846733994b9f4 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sat, 5 Jun 2021 19:01:48 -0400 Subject: [PATCH 122/496] Change some Bool docs --- compiler/builtins/docs/Bool.roc | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/compiler/builtins/docs/Bool.roc b/compiler/builtins/docs/Bool.roc index 5a4e4814df..077909e84d 100644 --- a/compiler/builtins/docs/Bool.roc +++ b/compiler/builtins/docs/Bool.roc @@ -55,12 +55,14 @@ and : Bool, Bool -> Bool ## ## In some languages, `&&` and `||` are special-cased in the compiler to skip ## evaluating the expression after the operator under certain circumstances. -## # In Roc, this is not the case. See the performance notes for #Bool.and for details. +## # In Roc, this is not the case. See the performance notes for [Bool.and] for details. or : Bool, Bool -> Bool ## Exclusive or xor : Bool, Bool -> Bool +# TODO: removed `'` from signature because parser does not support it yet +# Original signature: `isEq : 'val, 'val -> Bool` ## Returns `True` if the two values are *structurally equal*, and `False` otherwise. ## ## `a == b` is shorthand for `Bool.isEq a b` @@ -71,20 +73,18 @@ xor : Bool, Bool -> Bool ## 2. Private tags are equal if they are the same tag, in the same module, and also their contents (if any) are equal. ## 3. Records are equal if all their fields are equal. ## 4. Collections ([Str], [List], [Dict], and [Set]) are equal if they are the same length, and also all their corresponding elements are equal. -## 5. #Num values are equal if their numbers are equal, with one exception: if both arguments to `isEq` are *NaN*, then `isEq` returns `False`. See [Num.isNaN] for more about *NaN*. +## 5. [Num] values are equal if their numbers are equal, with one exception: if both arguments to `isEq` are *NaN*, then `isEq` returns `False`. See [Num.isNaN] for more about *NaN*. ## ## Note that `isEq` takes `'val` instead of `val`, which means `isEq` does not ## accept arguments whose types contain functions. -# TODO: removed `'` from signature because parser does not support it yet -# Original signature: `isEq : 'val, 'val -> Bool` isEq : val, val -> Bool -## Calls #eq on the given values, then calls #not on the result. +# TODO: removed `'` from signature because parser does not support it yet +# Original signature: `isNotEq : 'val, 'val -> Bool` +## Calls [isEq] on the given values, then calls [not] on the result. ## ## `a != b` is shorthand for `Bool.isNotEq a b` ## ## Note that `isNotEq` takes `'val` instead of `val`, which means `isNotEq` does not ## accept arguments whose types contain functions. -# TODO: removed `'` from signature because parser does not support it yet -# Original signature: `isNotEq : 'val, 'val -> Bool` isNotEq : val, val -> Bool From adb9e6e1f864bdccf47fa9df40c7e4a8f4719e09 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sat, 5 Jun 2021 19:02:22 -0400 Subject: [PATCH 123/496] Add www.roc-lang.org assets --- www/build.sh | 4 + www/netlify.toml | 30 +++ www/public/favicon.svg | 4 + www/public/index.html | 23 ++ www/public/license/index.html | 29 ++ www/public/logo.svg | 9 + www/public/search.js | 38 +++ www/public/styles.css | 479 ++++++++++++++++++++++++++++++++++ 8 files changed, 616 insertions(+) create mode 100755 www/build.sh create mode 100644 www/netlify.toml create mode 100644 www/public/favicon.svg create mode 100644 www/public/index.html create mode 100644 www/public/license/index.html create mode 100644 www/public/logo.svg create mode 100644 www/public/search.js create mode 100644 www/public/styles.css diff --git a/www/build.sh b/www/build.sh new file mode 100755 index 0000000000..ffdae71a9b --- /dev/null +++ b/www/build.sh @@ -0,0 +1,4 @@ +#!/bin/bash + +rm -rf build/ +cp -r public/ build/ diff --git a/www/netlify.toml b/www/netlify.toml new file mode 100644 index 0000000000..0e3070a0f6 --- /dev/null +++ b/www/netlify.toml @@ -0,0 +1,30 @@ +# This is the file that generates and deploys https://www.roc-lang.org, +# which is served on Netlify. +# +# Netlify's docs for how this configuration file works: +# https://docs.netlify.com/routing/headers/#syntax-for-the-netlify-configuration-file +[build] + publish = "build/" + command = "bash build.sh" + +[[headers]] + for = "/*" + [headers.values] + X-Frame-Options = "DENY" + X-XSS-Protection = "1; mode=block" + Content-Security-Policy = "default-src 'self'; img-src *;" + X-Content-Type-Options = "nosniff" + +# Redirect roc-lang.org/authors to the AUTHORS file in this repo +# +# This is referenced in the LICENSE file, which says to see roc-lang.org/authors +# for a list of authors! +[[redirects]] + from = "/authors" + to = "https://github.com/rtfeldman/roc/blob/trunk/AUTHORS" + force = true + status = 302 # TODO once the repo is public, use status = 200 and this URL: + # https://raw.githubusercontent.com/rtfeldman/roc/trunk/AUTHORS + # + # This way, roc-lang.org/authors will show the authors directly, + # proxied from the current AUTHORS file on GitHub, no redirects. diff --git a/www/public/favicon.svg b/www/public/favicon.svg new file mode 100644 index 0000000000..e0cff74b57 --- /dev/null +++ b/www/public/favicon.svg @@ -0,0 +1,4 @@ + + + + diff --git a/www/public/index.html b/www/public/index.html new file mode 100644 index 0000000000..442e9d266f --- /dev/null +++ b/www/public/index.html @@ -0,0 +1,23 @@ + + + + + + + The Roc Programming Language + + + + + + + +

Work in Progress

+

Roc's initial release is still under development, and this website is a placeholder until that release is ready.

+

In the meantime, if you'd like to learn more about Roc, here are some videos:

+ + + diff --git a/www/public/license/index.html b/www/public/license/index.html new file mode 100644 index 0000000000..4eea2d8c39 --- /dev/null +++ b/www/public/license/index.html @@ -0,0 +1,29 @@ + + + + + + Roc's license: The Universal Permissive License (UPL), Version 1.0 + + + + + + 
Copyright (c) 2019 Richard Feldman and subsequent Roc authors <https://roc-lang.org/authors>
+
+The Universal Permissive License (UPL), Version 1.0
+
+Subject to the condition set forth below, permission is hereby granted to any person obtaining a copy of this software, associated documentation and/or data (collectively the "Software"), free of charge and under any and all copyright rights in the Software, and any and all patent rights owned or freely licensable by each licensor hereunder covering either (i) the unmodified Software as contributed to or provided by such licensor, or (ii) the Larger Works (as defined below), to deal in both
+
+(a) the Software, and
+
+(b) any piece of software and/or hardware listed in the lrgrwrks.txt file if one is included with the Software (each a “Larger Work” to which the Software is contributed by such licensors),
+
+without restriction, including without limitation the rights to copy, create derivative works of, display, perform, and distribute the Software and make, use, sell, offer for sale, import, export, have made, and have sold the Software and the Larger Work(s), and to sublicense the foregoing rights on either these or other terms.
+
+This license is subject to the following condition:
+
+The above copyright notice and either this complete permission notice or at a minimum a reference to the UPL must be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ diff --git a/www/public/logo.svg b/www/public/logo.svg new file mode 100644 index 0000000000..bb673d5013 --- /dev/null +++ b/www/public/logo.svg @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/www/public/search.js b/www/public/search.js new file mode 100644 index 0000000000..0bc719563b --- /dev/null +++ b/www/public/search.js @@ -0,0 +1,38 @@ +(function() { + let sidebar = document.getElementById("sidebar-nav"); + let searchBox = document.getElementById("module-search"); + + function search() { + let text = searchBox.value.toLowerCase(); // Search is case-insensitive. + + if (text === "") { + // Un-hide everything + sidebar.querySelectorAll(".sidebar-entry a").forEach((entry) => entry.classList.remove("hidden")); + + // Re-hide all the sub-entries except for those of the first module + sidebar.querySelectorAll(".sidebar-entry:not(:first-of-type) .sidebar-sub-entries a").forEach((entry) => entry.classList.add("hidden")); + } else { + // First, show/hide all the sub-entries within each module (top-level functions etc.) + sidebar.querySelectorAll(".sidebar-sub-entries a").forEach((entry) => { + if (entry.textContent.toLowerCase().includes(text)) { + entry.classList.remove("hidden"); + } else { + entry.classList.add("hidden"); + } + }); + + // Then, show/hide modules based on whether they match, or any of their sub-entries matched + sidebar.querySelectorAll(".sidebar-module-link").forEach((entry) => { + if (entry.textContent.toLowerCase().includes(text) || entry.parentNode.querySelectorAll(".sidebar-sub-entries a:not(.hidden)").length > 0) { + entry.classList.remove("hidden"); + } else { + entry.classList.add("hidden"); + } + }); + } + } + + searchBox.addEventListener("input", search); + + search(); +})(); diff --git a/www/public/styles.css b/www/public/styles.css new file mode 100644 index 0000000000..27f88aacd1 --- /dev/null +++ b/www/public/styles.css @@ -0,0 +1,479 @@ +:root { + --link-color: #612bde; + --code-link-color: #5721d4; + --text-color: #333333; + --code-color: #222222; + --code-bg-color: #eeeeee; + --body-bg-color: #fdfdfd; + --border-color: #e9e9e9; + --faded-color: #4c4c4c; + --monospace-font; + --font-sans: -apple-system, BlinkMacSystemFont, Roboto, Helvetica, Arial, sans-serif; + --font-mono: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace; + --top-header-height: 67px; + --sidebar-width: 280px; + --top-bar-bg: #8257e5; + --top-bar-fg: #ffffff; + --nav-link-hover-color: #000000; +} + +a { + color: #972395; +} + +.logo { + padding: 2px 8px; +} + +.logo svg { + height: 48px; + width: 48px; + fill: var(--top-bar-fg); +} + +.logo:hover { + text-decoration: none; +} + +.logo svg:hover { + fill: var(--nav-link-hover-color); +} + +.pkg-full-name { + color: var(--text-color); + display: flex; + align-items: center; + font-size: 32px; + margin: 0 8px; + font-weight: normal; + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; + height: 100%; +} + +.pkg-full-name a { + padding-top: 12px; + padding-bottom: 16px; +} + +a { + text-decoration: none; +} + +a:hover { + text-decoration: underline; +} + +.pkg-and-logo { + min-width: 0; /* necessary for text-overflow: ellipsis to work in descendants */ + display: flex; + align-items: center; + height: 100%; + background-color: var(--top-bar-bg); +} + +.pkg-and-logo a, .pkg-and-logo a:visited { + color: var(--top-bar-fg); +} + +.pkg-and-logo a:hover { + color: var(--nav-link-hover-color); + text-decoration: none; +} + +.main-container { + min-width: 0; /* necessary for text-overflow: ellipsis to work in descendants */ +} + +.search-button { + flex-shrink: 0; /* always shrink the package name before these; they have a relatively constrained length */ + padding: 12px 18px; + margin-right: 42px; + display: none; /* only show this in the mobile view */ +} + +.version { + padding: 18px 10px; + min-width: 48px; + margin-right: 8px; +} + +body { + display: grid; + grid-template-columns: [before-sidebar] 1fr [sidebar] var(--sidebar-width) [main-content] fit-content(calc(1280px - var(--sidebar-width))) [end] 1fr; + grid-template-rows: [top-header] var(--top-header-height) [above-footer] auto [footer] auto; + box-sizing: border-box; + margin: 0; + padding: 0; + font-family: var(--font-sans); + color: var(--text-color); + background-color: var(--body-bg-color); +} + +main { + grid-column-start: main-content; + grid-column-end: main-content; + grid-row-start: above-footer; + grid-row-end: above-footer; + box-sizing: border-box; + position: relative; + font-size: 18px; + line-height: 1.85em; + margin-top: 2px; + padding: 48px; +} + +#sidebar-nav { + grid-column-start: sidebar; + grid-column-end: sidebar; + grid-row-start: above-footer; + grid-row-end: above-footer; + position: relative; + display: flex; + flex-direction: column; + box-sizing: border-box; + padding-left: 56px; + padding-top: 6px; + width: 100%; +} + +.top-header-extension { + grid-column-start: before-sidebar; + grid-column-end: sidebar; + grid-row-start: top-header; + grid-row-end: top-header; + background-color: var(--top-bar-bg); +} + +.top-header { + grid-column-start: sidebar; + grid-column-end: end; + grid-row-start: top-header; + grid-row-end: top-header; + display: flex; + flex-direction: row; + align-items: center; + flex-wrap: nowrap; + flex-grow: 1; + box-sizing: border-box; + font-family: var(--font-sans); + font-size: 24px; + height: 100%; + min-width: 0; /* necessary for text-overflow: ellipsis to work in descendants */ +} + +.top-header-triangle { + /* This used to be a clip-path, but Firefox on Android (at least as of early 2020) + * rendered the page extremely slowly in that version. With this approach it's super fast. + */ + width: 0; + height: 0; + border-style: solid; + border-width: var(--top-header-height) 0 0 48px; + border-color: transparent transparent transparent var(--top-bar-bg); +} + +p { + overflow-wrap: break-word; + margin: 24px 0; +} + +footer { + grid-column-start: main-content; + grid-column-end: main-content; + grid-row-start: footer; + grid-row-end: footer; + max-width: var(--main-content-max-width); + font-size: 14px; + box-sizing: border-box; + padding: 16px; +} + +footer p { + display: inline-block; + margin-top: 0; + margin-bottom: 8px; +} + +.content { + box-sizing: border-box; + display: flex; + flex-direction: row; + justify-content: space-between; +} + +.sidebar-entry ul { + list-style-type: none; + margin: 0; +} + +.sidebar-entry a { + box-sizing: border-box; + min-height: 48px; + min-width: 48px; + padding: 12px 16px; + font-family: var(--font-mono); +} + +.sidebar-sub-entries a { + display: block; + line-height: 24px; + width: 100%; + overflow: hidden; + text-overflow: ellipsis; + padding-left: 36px; +} + +.module-name { + font-size: 56px; + line-height: 1em; + font-family: var(--font-mono); + font-weight: bold; + margin-top: 18px; + margin-bottom: 48px; +} + +.module-name a, .module-name a:visited { + color: inherit; +} + +.sidebar-module-link { + box-sizing: border-box; + font-size: 18px; + line-height: 24px; + font-family: var(--font-mono); + font-weight: bold; + display: block; + width: 100%; + padding: 8px 0; + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; +} + +a, a:visited { + color: var(--link-color); +} + +h3 { + font-size: 32px; + margin: 48px 0 24px 0; +} + +h4 { + font-size: 24px; +} + +.type-def { + font-size: 24px; + color: var(--link-color); +} + +.code-snippet { + padding: 12px 16px; + display: block; + box-sizing: border-box; + font-family: var(--font-mono); + background-color: var(--code-bg-color); +} + +code { + font-family: var(--font-mono); + color: var(--code-color); + background-color: var(--code-bg-color); + padding: 2px 8px; + display: inline-block; +} + +code a { + color: var(--code-link-color); +} + +code a:visited { + color: var(--code-link-color); +} + +pre { + margin: 36px 0; + padding: 8px; + box-sizing: border-box; + background-color: var(--code-bg-color); + overflow-x: auto; +} + +pre code { + padding: 6px 8px; +} + +.hidden { + /* Use !important to win all specificity fights. */ + display: none !important; +} + +#module-search:placeholder-shown { + padding: 0; + opacity: 0; + height: 0; +} + +#module-search, #module-search:focus { + opacity: 1; + padding: 12px 16px; + height: 48px; +} + +/* Show the "Search" label link when the text input has a placeholder */ +#module-search:placeholder-shown + #search-link { + display: flex; +} + +/* Hide the "Search" label link when the text input has focus */ +#module-search:focus + #search-link { + display: none; +} + +#module-search { + display: block; + box-sizing: border-box; + background-color: var(--code-bg-color); + width: 100%; + box-sizing: border-box; + font-size: 18px; + line-height: 18px; + margin-top: 6px; + border: none; + color: var(--faded-color); + background-color: var(--code-bg-color); + font-family: var(--font-serif); +} + +#module-search::placeholder { + color: var(--faded-color); + opacity: 1; +} + +#search-link { + box-sizing: border-box; + display: none; + align-items: center; + font-size: 18px; + line-height: 18px; + padding: 12px 16px; + height: 48px; + cursor: pointer; + color: var(--link-color); +} + +#search-link:hover { + text-decoration: underline; +} + +@media (prefers-color-scheme: dark) { + :root { + --body-bg-color: #303030; + --code-bg-color: #393939; + --border-color: #555555; + --code-color: #eeeeee; + --text-color: #cccccc; + --logo-solid: #777777; + --faded-color: #bbbbbb; + --link-color: #c5a8ff; + --code-link-color: #b894ff; + --top-bar-bg: #6845b9; + --top-bar-fg: #eeeeee; + } + + html { + scrollbar-color: #444444 #2f2f2f; + } +} + +@media only screen and (max-device-width: 480px) { + .search-button { + display: block; /* This is only visible in mobile. */ + } + + .top-header { + width: auto; + } + + .pkg-full-name { + margin-left: 8px; + margin-right: 12px; + font-size: 24px; + padding-bottom: 14px; + } + + .pkg-full-name a { + vertical-align: middle; + padding: 18px 0; + } + + .logo { + padding-left: 2px; + width: 50px; + height: 54px; + } + + .version { + margin: 0; + font-weight: normal; + font-size: 18px; + padding-bottom: 16px; + } + + .module-name { + font-size: 36px; + margin-top: 8px; + margin-bottom: 8px; + max-width: calc(100% - 18px); + overflow: hidden; + text-overflow: ellipsis; + } + + main { + padding: 18px; + font-size: 16px; + } + + .container { + margin: 0; + min-width: 320px; + max-width: 100%; + } + + .content { + flex-direction: column; + } + + .sidebar { + margin-top: 0; + padding-left: 0; + width: auto; + } + + #sidebar-heading { + font-size: 24px; + margin: 16px; + } + + h3 { + font-size: 18px; + margin: 0; + padding: 0; + } + + h4 { + font-size: 16px; + } + + .top-header { + justify-content: space-between; + } + + .content { + /* Display the sidebar below
without affecting tab index */ + flex-direction: column-reverse; + } +} From 855818014c952e057f4372dfa2c67856b2df9040 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sat, 5 Jun 2021 19:02:06 -0400 Subject: [PATCH 124/496] Add www github workflow --- .github/workflows/ci.yml | 1 - .github/workflows/nightly.yml | 2 +- .github/workflows/www.yml | 22 ++++++++++++++++++++++ 3 files changed, 23 insertions(+), 2 deletions(-) create mode 100644 .github/workflows/www.yml diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 413c22db1b..5fd1f8f542 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -22,4 +22,3 @@ jobs: - name: install dependencies, build, run zig tests, rustfmt, clippy, cargo test --release run: ./ci/safe-earthly.sh +test-all - diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 934baf2e8f..9f3791e4ee 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -1,4 +1,4 @@ -on: +on: schedule: - cron: '0 0 * * *' diff --git a/.github/workflows/www.yml b/.github/workflows/www.yml new file mode 100644 index 0000000000..308cc4dd0e --- /dev/null +++ b/.github/workflows/www.yml @@ -0,0 +1,22 @@ +name: deploy www.roc-lang.org + +# Whenever a commit lands on trunk, deploy the site +on: + push: + branches: + - deploy-www # TODO change to trunk + +jobs: + deploy: + name: 'Deploy to Netlify' + runs-on: [self-hosted] + steps: + - uses: jsmrcaga/action-netlify-deploy@v1.6.0 + with: + install_command: 'pwd; cd ../../www' + build_command: 'bash build.sh' + build_directory: 'build' + NETLIFY_AUTH_TOKEN: ${{ secrets.NETLIFY_AUTH_TOKEN }} + NETLIFY_SITE_ID: ${{ secrets.NETLIFY_SITE_ID }} + NETLIFY_DEPLOY_MESSAGE: "Deploy git ref ${{ github.ref }}" + NETLIFY_DEPLOY_TO_PROD: true From f1f7c0bdf62e2ea0eb3758800ae77a864031bd37 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sat, 5 Jun 2021 19:24:53 -0400 Subject: [PATCH 125/496] Revert "Add www github workflow" This reverts commit 855818014c952e057f4372dfa2c67856b2df9040. --- .github/workflows/ci.yml | 1 + .github/workflows/nightly.yml | 2 +- .github/workflows/www.yml | 22 ---------------------- 3 files changed, 2 insertions(+), 23 deletions(-) delete mode 100644 .github/workflows/www.yml diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 5fd1f8f542..413c22db1b 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -22,3 +22,4 @@ jobs: - name: install dependencies, build, run zig tests, rustfmt, clippy, cargo test --release run: ./ci/safe-earthly.sh +test-all + diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 9f3791e4ee..934baf2e8f 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -1,4 +1,4 @@ -on: +on: schedule: - cron: '0 0 * * *' diff --git a/.github/workflows/www.yml b/.github/workflows/www.yml deleted file mode 100644 index 308cc4dd0e..0000000000 --- a/.github/workflows/www.yml +++ /dev/null @@ -1,22 +0,0 @@ -name: deploy www.roc-lang.org - -# Whenever a commit lands on trunk, deploy the site -on: - push: - branches: - - deploy-www # TODO change to trunk - -jobs: - deploy: - name: 'Deploy to Netlify' - runs-on: [self-hosted] - steps: - - uses: jsmrcaga/action-netlify-deploy@v1.6.0 - with: - install_command: 'pwd; cd ../../www' - build_command: 'bash build.sh' - build_directory: 'build' - NETLIFY_AUTH_TOKEN: ${{ secrets.NETLIFY_AUTH_TOKEN }} - NETLIFY_SITE_ID: ${{ secrets.NETLIFY_SITE_ID }} - NETLIFY_DEPLOY_MESSAGE: "Deploy git ref ${{ github.ref }}" - NETLIFY_DEPLOY_TO_PROD: true From 15a240220880a09cbc0c8eeb31a7b1476ec38d08 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sat, 5 Jun 2021 19:37:50 -0400 Subject: [PATCH 126/496] Add .gitignore --- www/.gitignore | 1 + 1 file changed, 1 insertion(+) create mode 100644 www/.gitignore diff --git a/www/.gitignore b/www/.gitignore new file mode 100644 index 0000000000..378eac25d3 --- /dev/null +++ b/www/.gitignore @@ -0,0 +1 @@ +build From cb7ee34f21ebc7274bc9d67da8f3d289a64d454c Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sat, 5 Jun 2021 19:38:07 -0400 Subject: [PATCH 127/496] Generate builtins when buiding www site --- www/build.sh | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/www/build.sh b/www/build.sh index ffdae71a9b..ffe80908a6 100755 --- a/www/build.sh +++ b/www/build.sh @@ -1,4 +1,12 @@ #!/bin/bash +set -euxo pipefail + rm -rf build/ cp -r public/ build/ + +pushd .. +echo 'Generating docs...' +cargo run docs compiler/builtins/docs/Bool.roc +mv generated-docs/ www/build/builtins +popd From 0b00afdd510111d1ef5c7f06df8b1a206fb5bc49 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sat, 5 Jun 2021 22:05:45 -0400 Subject: [PATCH 128/496] Revert "Revert "Add www github workflow"" This reverts commit f1f7c0bdf62e2ea0eb3758800ae77a864031bd37. --- .github/workflows/ci.yml | 1 - .github/workflows/nightly.yml | 2 +- .github/workflows/www.yml | 22 ++++++++++++++++++++++ 3 files changed, 23 insertions(+), 2 deletions(-) create mode 100644 .github/workflows/www.yml diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 413c22db1b..5fd1f8f542 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -22,4 +22,3 @@ jobs: - name: install dependencies, build, run zig tests, rustfmt, clippy, cargo test --release run: ./ci/safe-earthly.sh +test-all - diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 934baf2e8f..9f3791e4ee 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -1,4 +1,4 @@ -on: +on: schedule: - cron: '0 0 * * *' diff --git a/.github/workflows/www.yml b/.github/workflows/www.yml new file mode 100644 index 0000000000..308cc4dd0e --- /dev/null +++ b/.github/workflows/www.yml @@ -0,0 +1,22 @@ +name: deploy www.roc-lang.org + +# Whenever a commit lands on trunk, deploy the site +on: + push: + branches: + - deploy-www # TODO change to trunk + +jobs: + deploy: + name: 'Deploy to Netlify' + runs-on: [self-hosted] + steps: + - uses: jsmrcaga/action-netlify-deploy@v1.6.0 + with: + install_command: 'pwd; cd ../../www' + build_command: 'bash build.sh' + build_directory: 'build' + NETLIFY_AUTH_TOKEN: ${{ secrets.NETLIFY_AUTH_TOKEN }} + NETLIFY_SITE_ID: ${{ secrets.NETLIFY_SITE_ID }} + NETLIFY_DEPLOY_MESSAGE: "Deploy git ref ${{ github.ref }}" + NETLIFY_DEPLOY_TO_PROD: true From e09696113c5a768d8c15902a73077d713eecfd8e Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sat, 5 Jun 2021 22:20:32 -0400 Subject: [PATCH 129/496] Allow running bash www/build.sh --- www/build.sh | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/www/build.sh b/www/build.sh index ffe80908a6..bc1a7c0a35 100755 --- a/www/build.sh +++ b/www/build.sh @@ -2,6 +2,12 @@ set -euxo pipefail +# cd into the directory where this script lives. +# This allows us to run this script from the root project directory, +# which is what Netlify wants to do. +SCRIPT_RELATIVE_DIR=$(dirname "${BASH_SOURCE[0]}") +cd $SCRIPT_RELATIVE_DIR + rm -rf build/ cp -r public/ build/ From e9007f97029b9d7e36cded6b882fa9fdecff63cf Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sat, 5 Jun 2021 22:21:08 -0400 Subject: [PATCH 130/496] Run the www workflow on push to www --- .github/workflows/www.yml | 16 ++++------------ 1 file changed, 4 insertions(+), 12 deletions(-) diff --git a/.github/workflows/www.yml b/.github/workflows/www.yml index 308cc4dd0e..4628b00459 100644 --- a/.github/workflows/www.yml +++ b/.github/workflows/www.yml @@ -4,19 +4,11 @@ name: deploy www.roc-lang.org on: push: branches: - - deploy-www # TODO change to trunk - + - www jobs: - deploy: + build: name: 'Deploy to Netlify' runs-on: [self-hosted] steps: - - uses: jsmrcaga/action-netlify-deploy@v1.6.0 - with: - install_command: 'pwd; cd ../../www' - build_command: 'bash build.sh' - build_directory: 'build' - NETLIFY_AUTH_TOKEN: ${{ secrets.NETLIFY_AUTH_TOKEN }} - NETLIFY_SITE_ID: ${{ secrets.NETLIFY_SITE_ID }} - NETLIFY_DEPLOY_MESSAGE: "Deploy git ref ${{ github.ref }}" - NETLIFY_DEPLOY_TO_PROD: true + - name: curl request to netlify build hook + run: curl -X POST -d {} https://api.netlify.com/build_hooks/${{ secrets.NETLIFY_BUILD_HOOK }} From 84699d4f2fb2186fdc887f546d78da838c93ba3f Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sat, 5 Jun 2021 22:21:15 -0400 Subject: [PATCH 131/496] Revert "Run the www workflow on push to www" This reverts commit e9007f97029b9d7e36cded6b882fa9fdecff63cf. --- .github/workflows/www.yml | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/.github/workflows/www.yml b/.github/workflows/www.yml index 4628b00459..308cc4dd0e 100644 --- a/.github/workflows/www.yml +++ b/.github/workflows/www.yml @@ -4,11 +4,19 @@ name: deploy www.roc-lang.org on: push: branches: - - www + - deploy-www # TODO change to trunk + jobs: - build: + deploy: name: 'Deploy to Netlify' runs-on: [self-hosted] steps: - - name: curl request to netlify build hook - run: curl -X POST -d {} https://api.netlify.com/build_hooks/${{ secrets.NETLIFY_BUILD_HOOK }} + - uses: jsmrcaga/action-netlify-deploy@v1.6.0 + with: + install_command: 'pwd; cd ../../www' + build_command: 'bash build.sh' + build_directory: 'build' + NETLIFY_AUTH_TOKEN: ${{ secrets.NETLIFY_AUTH_TOKEN }} + NETLIFY_SITE_ID: ${{ secrets.NETLIFY_SITE_ID }} + NETLIFY_DEPLOY_MESSAGE: "Deploy git ref ${{ github.ref }}" + NETLIFY_DEPLOY_TO_PROD: true From 0e5619c42285e3032c9b718444824fdecd6c0325 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sat, 5 Jun 2021 22:31:37 -0400 Subject: [PATCH 132/496] Skip zig build on Netlify --- compiler/builtins/build.rs | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/compiler/builtins/build.rs b/compiler/builtins/build.rs index c621196cb9..e0d493457b 100644 --- a/compiler/builtins/build.rs +++ b/compiler/builtins/build.rs @@ -8,6 +8,13 @@ use std::process::Command; use std::str; fn main() { + // When we build on Netlify, zig is not installed (but also not used, + // since all we're doing is generating docs), so we can skip the steps + // that require having zig installed. + if env::var_os("NO_ZIG_INSTALLED").is_some() { + return; + } + let out_dir = env::var_os("OUT_DIR").unwrap(); let big_sur_path = "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/lib"; From b05342c67872e92e747f37ecbfbc0d9184682ffb Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sun, 6 Jun 2021 00:17:42 -0400 Subject: [PATCH 133/496] Split out an optional "llvm" feature Also move OptLevel out of roc_gen (which should really be called gen_llvm) and into roc_mono, so it's no longer coupled to LLVM. --- Cargo.toml | 6 +++ cli/Cargo.toml | 14 ++++--- cli/src/build.rs | 3 +- cli/src/lib.rs | 6 ++- cli/src/main.rs | 10 ++++- cli/src/repl.rs | 20 ++++++++-- cli/src/repl/gen.rs | 2 +- compiler/build/Cargo.toml | 8 +++- compiler/build/src/link.rs | 32 +++++++++++---- compiler/build/src/program.rs | 32 +++++++++------ compiler/build/src/target.rs | 57 +++++++++++++++++---------- compiler/gen/src/llvm/build.rs | 18 +-------- compiler/mono/src/ir.rs | 6 +++ compiler/test_gen/src/helpers/eval.rs | 5 ++- 14 files changed, 143 insertions(+), 76 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index b5535db0d9..84016c05b1 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -32,6 +32,12 @@ members = [ "roc_std", "docs" ] +# Needed to be able to run `cargo run -p roc_cli --no-default-features` - +# see www/build.sh for more. +# +# Without the `-p` flag, cargo ignores `--no-default-features` when you have a +# workspace, and without `resolver = "2"` here, you can't use `-p` like this. +resolver = "2" # Optimizations based on https://deterministic.space/high-performance-rust.html [profile.release] diff --git a/cli/Cargo.toml b/cli/Cargo.toml index 7aa61cb768..177f9783cf 100644 --- a/cli/Cargo.toml +++ b/cli/Cargo.toml @@ -15,7 +15,11 @@ test = false bench = false [features] -default = ["target-x86"] +default = ["target-x86", "llvm"] + +# This is a separate feature because when we generate docs on Netlify, +# it doesn't have LLVM installed. (Also, it doesn't need to do code gen.) +llvm = ["inkwell", "roc_gen", "roc_build/llvm"] target-x86 = [] @@ -45,8 +49,8 @@ roc_unify = { path = "../compiler/unify" } roc_solve = { path = "../compiler/solve" } roc_mono = { path = "../compiler/mono" } roc_load = { path = "../compiler/load" } -roc_gen = { path = "../compiler/gen" } -roc_build = { path = "../compiler/build" } +roc_gen = { path = "../compiler/gen", optional = true } +roc_build = { path = "../compiler/build", default-features = false } roc_fmt = { path = "../compiler/fmt" } roc_reporting = { path = "../compiler/reporting" } roc_editor = { path = "../editor" } @@ -62,7 +66,7 @@ inlinable_string = "0.1" libc = "0.2" libloading = "0.6" -inkwell = { path = "../vendor/inkwell" } +inkwell = { path = "../vendor/inkwell", optional = true } target-lexicon = "0.10" tempfile = "3.1.0" @@ -74,7 +78,7 @@ quickcheck = "0.8" quickcheck_macros = "0.8" serial_test = "0.5" tempfile = "3.1.0" -criterion = { git = "https://github.com/Anton-4/criterion.rs"} +criterion = { git = "https://github.com/Anton-4/criterion.rs"} cli_utils = { path = "cli_utils" } # Keep the commented deps, they are commented because they require nightly rust # criterion-perf-events = "0.1.3" diff --git a/cli/src/build.rs b/cli/src/build.rs index e6f753ec11..a1f3add2bc 100644 --- a/cli/src/build.rs +++ b/cli/src/build.rs @@ -5,8 +5,8 @@ use roc_build::{ }; use roc_can::builtins::builtin_defs_map; use roc_collections::all::MutMap; -use roc_gen::llvm::build::OptLevel; use roc_load::file::LoadingProblem; +use roc_mono::ir::OptLevel; use std::path::PathBuf; use std::time::{Duration, SystemTime}; use target_lexicon::Triple; @@ -32,6 +32,7 @@ pub struct BuiltFile { pub total_time: Duration, } +#[cfg(feature = "llvm")] pub fn build_file<'a>( arena: &'a Bump, target: &Triple, diff --git a/cli/src/lib.rs b/cli/src/lib.rs index 91948044c2..664c56908e 100644 --- a/cli/src/lib.rs +++ b/cli/src/lib.rs @@ -1,12 +1,12 @@ #[macro_use] extern crate clap; -use build::{build_file, BuildOutcome, BuiltFile}; +use build::{BuildOutcome, BuiltFile}; use bumpalo::Bump; use clap::{App, AppSettings, Arg, ArgMatches}; use roc_build::link::LinkType; -use roc_gen::llvm::build::OptLevel; use roc_load::file::LoadingProblem; +use roc_mono::ir::OptLevel; use std::env; use std::io; use std::path::{Path, PathBuf}; @@ -116,7 +116,9 @@ pub enum BuildConfig { BuildAndRun { roc_file_arg_index: usize }, } +#[cfg(feature = "llvm")] pub fn build(target: &Triple, matches: &ArgMatches, config: BuildConfig) -> io::Result { + use build::build_file; use BuildConfig::*; let arena = Bump::new(); diff --git a/cli/src/main.rs b/cli/src/main.rs index 191e8409b0..bd38a5e56a 100644 --- a/cli/src/main.rs +++ b/cli/src/main.rs @@ -1,11 +1,19 @@ use roc_cli::{ - build, build_app, docs, repl, BuildConfig, CMD_BUILD, CMD_DOCS, CMD_EDIT, CMD_REPL, CMD_RUN, + build_app, docs, repl, BuildConfig, CMD_BUILD, CMD_DOCS, CMD_EDIT, CMD_REPL, CMD_RUN, DIRECTORY_OR_FILES, ROC_FILE, }; use std::io; use std::path::{Path, PathBuf}; use target_lexicon::Triple; +#[cfg(feature = "llvm")] +use roc_cli::build; + +#[cfg(not(feature = "llvm"))] +fn build(_target: &Triple, _matches: &clap::ArgMatches, _config: BuildConfig) -> io::Result { + panic!("Building without LLVM is not currently supported."); +} + fn main() -> io::Result<()> { let matches = build_app().get_matches(); diff --git a/cli/src/repl.rs b/cli/src/repl.rs index c0d7e03917..4de48bb3df 100644 --- a/cli/src/repl.rs +++ b/cli/src/repl.rs @@ -1,15 +1,12 @@ use const_format::concatcp; +#[cfg(feature = "llvm")] use gen::{gen_and_eval, ReplOutput}; -use roc_gen::llvm::build::OptLevel; use roc_parse::parser::{EExpr, SyntaxError}; -use rustyline::error::ReadlineError; use rustyline::highlight::{Highlighter, PromptInfo}; use rustyline::validate::{self, ValidationContext, ValidationResult, Validator}; -use rustyline::Editor; use rustyline_derive::{Completer, Helper, Hinter}; use std::borrow::Cow; use std::io; -use target_lexicon::Triple; const BLUE: &str = "\u{001b}[36m"; const PINK: &str = "\u{001b}[35m"; @@ -30,7 +27,9 @@ pub const INSTRUCTIONS: &str = "Enter an expression, or :help, or :exit/:q.\n"; pub const PROMPT: &str = concatcp!("\n", BLUE, "»", END_COL, " "); pub const CONT_PROMPT: &str = concatcp!(BLUE, "…", END_COL, " "); +#[cfg(feature = "llvm")] mod eval; +#[cfg(feature = "llvm")] mod gen; #[derive(Completer, Helper, Hinter)] @@ -107,7 +106,16 @@ impl Validator for InputValidator { } } +#[cfg(not(feature = "llvm"))] pub fn main() -> io::Result<()> { + panic!("The REPL currently requires being built with LLVM."); +} + +#[cfg(feature = "llvm")] +pub fn main() -> io::Result<()> { + use rustyline::error::ReadlineError; + use rustyline::Editor; + // To debug rustyline: // env_logger::init(); // RUST_LOG=rustyline=debug cargo run repl 2> debug.log @@ -226,7 +234,11 @@ fn report_parse_error(fail: SyntaxError) { println!("TODO Gracefully report parse error in repl: {:?}", fail); } +#[cfg(feature = "llvm")] fn eval_and_format<'a>(src: &str) -> Result> { + use roc_mono::ir::OptLevel; + use target_lexicon::Triple; + gen_and_eval(src.as_bytes(), Triple::host(), OptLevel::Normal).map(|output| match output { ReplOutput::NoProblems { expr, expr_type } => { format!("\n{} {}:{} {}", expr, PINK, END_COL, expr_type) diff --git a/cli/src/repl/gen.rs b/cli/src/repl/gen.rs index 49d47e54a3..b9bb9a2799 100644 --- a/cli/src/repl/gen.rs +++ b/cli/src/repl/gen.rs @@ -8,9 +8,9 @@ use roc_can::builtins::builtin_defs_map; use roc_collections::all::{MutMap, MutSet}; use roc_fmt::annotation::Formattable; use roc_fmt::annotation::{Newlines, Parens}; -use roc_gen::llvm::build::OptLevel; use roc_gen::llvm::externs::add_default_roc_externs; use roc_load::file::LoadingProblem; +use roc_mono::ir::OptLevel; use roc_parse::parser::SyntaxError; use roc_types::pretty_print::{content_to_string, name_all_type_vars}; use std::path::{Path, PathBuf}; diff --git a/compiler/build/Cargo.toml b/compiler/build/Cargo.toml index aa3a13f3d8..11a5e9effb 100644 --- a/compiler/build/Cargo.toml +++ b/compiler/build/Cargo.toml @@ -19,7 +19,7 @@ roc_unify = { path = "../unify" } roc_solve = { path = "../solve" } roc_mono = { path = "../mono" } roc_load = { path = "../load" } -roc_gen = { path = "../gen" } +roc_gen = { path = "../gen", optional = true } roc_reporting = { path = "../reporting" } im = "14" # im and im-rc should always have the same version! im-rc = "14" # im and im-rc should always have the same version! @@ -28,7 +28,7 @@ inlinable_string = "0.1.0" libloading = "0.6" tempfile = "3.1.0" serde_json = "1.0" -inkwell = { path = "../../vendor/inkwell" } +inkwell = { path = "../../vendor/inkwell", optional = true } target-lexicon = "0.10" [dev-dependencies] @@ -39,6 +39,10 @@ quickcheck = "0.8" quickcheck_macros = "0.8" [features] +default = ["llvm"] target-arm = [] target-aarch64 = [] target-webassembly = [] +# This is a separate feature because when we generate docs on Netlify, +# it doesn't have LLVM installed. (Also, it doesn't need to do code gen.) +llvm = ["inkwell", "roc_gen"] diff --git a/compiler/build/src/link.rs b/compiler/build/src/link.rs index c535f86e57..61068d11b8 100644 --- a/compiler/build/src/link.rs +++ b/compiler/build/src/link.rs @@ -1,16 +1,14 @@ -use crate::target; use crate::target::arch_str; -use inkwell::module::Module; -use inkwell::targets::{CodeModel, FileType, RelocMode}; +#[cfg(feature = "llvm")] use libloading::{Error, Library}; -use roc_gen::llvm::build::OptLevel; +#[cfg(feature = "llvm")] +use roc_mono::ir::OptLevel; use std::collections::HashMap; use std::env; use std::io; use std::path::{Path, PathBuf}; use std::process::{Child, Command, Output}; use target_lexicon::{Architecture, OperatingSystem, Triple}; -use tempfile::tempdir; #[derive(Debug, Copy, Clone, PartialEq, Eq)] pub enum LinkType { @@ -360,6 +358,9 @@ fn link_linux( }; let env_path = env::var("PATH").unwrap_or_else(|_| "".to_string()); + + init_arch(target); + // NOTE: order of arguments to `ld` matters here! // The `-l` flags should go after the `.o` arguments Ok(( @@ -477,12 +478,16 @@ fn link_macos( )) } +#[cfg(feature = "llvm")] pub fn module_to_dylib( - module: &Module, + module: &inkwell::module::Module, target: &Triple, opt_level: OptLevel, ) -> Result { - let dir = tempdir().unwrap(); + use crate::target::{self, convert_opt_level}; + use inkwell::targets::{CodeModel, FileType, RelocMode}; + + let dir = tempfile::tempdir().unwrap(); let filename = PathBuf::from("Test.roc"); let file_path = dir.path().join(filename); let mut app_o_file = file_path; @@ -492,7 +497,8 @@ pub fn module_to_dylib( // Emit the .o file using position-indepedent code (PIC) - needed for dylibs let reloc = RelocMode::PIC; let model = CodeModel::Default; - let target_machine = target::target_machine(target, opt_level.into(), reloc, model).unwrap(); + let target_machine = + target::target_machine(target, convert_opt_level(opt_level), reloc, model).unwrap(); target_machine .write_to_file(module, FileType::Object, &app_o_file) @@ -529,3 +535,13 @@ fn validate_output(file_name: &str, cmd_name: &str, output: Output) { } } } + +#[cfg(feature = "llvm")] +fn init_arch(target: &Triple) { + crate::target::init_arch(target); +} + +#[cfg(not(feature = "llvm"))] +fn init_arch(_target: &Triple) { + panic!("Tried to initialize LLVM when crate was not built with `feature = \"llvm\"` enabled"); +} diff --git a/compiler/build/src/program.rs b/compiler/build/src/program.rs index 4d087664c0..5d3b7a984a 100644 --- a/compiler/build/src/program.rs +++ b/compiler/build/src/program.rs @@ -1,13 +1,14 @@ -use crate::target; -use bumpalo::Bump; -use inkwell::context::Context; -use inkwell::targets::{CodeModel, FileType, RelocMode}; +#[cfg(feature = "llvm")] +use roc_gen::llvm::build::module_from_builtins; +#[cfg(feature = "llvm")] pub use roc_gen::llvm::build::FunctionIterator; -use roc_gen::llvm::build::{module_from_builtins, OptLevel}; +#[cfg(feature = "llvm")] use roc_load::file::MonomorphizedModule; +#[cfg(feature = "llvm")] +use roc_mono::ir::OptLevel; +#[cfg(feature = "llvm")] use std::path::{Path, PathBuf}; -use std::time::{Duration, SystemTime}; -use target_lexicon::Triple; +use std::time::Duration; #[derive(Debug, Clone, Copy, Default)] pub struct CodeGenTiming { @@ -18,16 +19,24 @@ pub struct CodeGenTiming { // TODO how should imported modules factor into this? What if those use builtins too? // TODO this should probably use more helper functions // TODO make this polymorphic in the llvm functions so it can be reused for another backend. +#[cfg(feature = "llvm")] #[allow(clippy::cognitive_complexity)] pub fn gen_from_mono_module( - arena: &Bump, + arena: &bumpalo::Bump, mut loaded: MonomorphizedModule, roc_file_path: &Path, - target: Triple, + target: target_lexicon::Triple, app_o_file: &Path, opt_level: OptLevel, emit_debug_info: bool, ) -> CodeGenTiming { + use crate::target::{self, convert_opt_level}; + use inkwell::attributes::{Attribute, AttributeLoc}; + use inkwell::context::Context; + use inkwell::module::Linkage; + use inkwell::targets::{CodeModel, FileType, RelocMode}; + use std::time::SystemTime; + use roc_reporting::report::{ can_problem, mono_problem, type_problem, RocDocAllocator, DEFAULT_PALETTE, }; @@ -87,9 +96,6 @@ pub fn gen_from_mono_module( // module.strip_debug_info(); // mark our zig-defined builtins as internal - use inkwell::attributes::{Attribute, AttributeLoc}; - use inkwell::module::Linkage; - let app_ll_file = { let mut temp = PathBuf::from(roc_file_path); temp.set_extension("ll"); @@ -226,7 +232,7 @@ pub fn gen_from_mono_module( let reloc = RelocMode::Default; let model = CodeModel::Default; let target_machine = - target::target_machine(&target, opt_level.into(), reloc, model).unwrap(); + target::target_machine(&target, convert_opt_level(opt_level), reloc, model).unwrap(); target_machine .write_to_file(&env.module, FileType::Object, &app_o_file) diff --git a/compiler/build/src/target.rs b/compiler/build/src/target.rs index 8137357377..f1a10a830f 100644 --- a/compiler/build/src/target.rs +++ b/compiler/build/src/target.rs @@ -1,7 +1,10 @@ -use inkwell::targets::{ - CodeModel, InitializationConfig, RelocMode, Target, TargetMachine, TargetTriple, +#[cfg(feature = "llvm")] +use inkwell::{ + targets::{CodeModel, InitializationConfig, RelocMode, Target, TargetMachine, TargetTriple}, + OptimizationLevel, }; -use inkwell::OptimizationLevel; +#[cfg(feature = "llvm")] +use roc_mono::ir::OptLevel; use target_lexicon::{Architecture, OperatingSystem, Triple}; pub fn target_triple_str(target: &Triple) -> &'static str { @@ -28,36 +31,20 @@ pub fn target_triple_str(target: &Triple) -> &'static str { } } -/// NOTE: arch_str is *not* the same as the beginning of the magic target triple -/// string! For example, if it's "x86-64" here, the magic target triple string -/// will begin with "x86_64" (with an underscore) instead. -pub fn arch_str(target: &Triple) -> &'static str { - // Best guide I've found on how to determine these magic strings: - // - // https://stackoverflow.com/questions/15036909/clang-how-to-list-supported-target-architectures +#[cfg(feature = "llvm")] +pub fn init_arch(target: &Triple) { match target.architecture { Architecture::X86_64 => { Target::initialize_x86(&InitializationConfig::default()); - - "x86-64" } Architecture::Aarch64(_) if cfg!(feature = "target-aarch64") => { Target::initialize_aarch64(&InitializationConfig::default()); - "aarch64" } Architecture::Arm(_) if cfg!(feature = "target-arm") => { - // NOTE: why not enable arm and wasm by default? - // - // We had some trouble getting them to link properly. This may be resolved in the - // future, or maybe it was just some weird configuration on one machine. Target::initialize_arm(&InitializationConfig::default()); - - "arm" } Architecture::Wasm32 if cfg!(feature = "target-webassembly") => { Target::initialize_webassembly(&InitializationConfig::default()); - - "wasm32" } _ => panic!( "TODO gracefully handle unsupported target architecture: {:?}", @@ -66,6 +53,26 @@ pub fn arch_str(target: &Triple) -> &'static str { } } +/// NOTE: arch_str is *not* the same as the beginning of the magic target triple +/// string! For example, if it's "x86-64" here, the magic target triple string +/// will begin with "x86_64" (with an underscore) instead. +pub fn arch_str(target: &Triple) -> &'static str { + // Best guide I've found on how to determine these magic strings: + // + // https://stackoverflow.com/questions/15036909/clang-how-to-list-supported-target-architectures + match target.architecture { + Architecture::X86_64 => "x86-64", + Architecture::Aarch64(_) if cfg!(feature = "target-aarch64") => "aarch64", + Architecture::Arm(_) if cfg!(feature = "target-arm") => "arm", + Architecture::Wasm32 if cfg!(feature = "target-webassembly") => "wasm32", + _ => panic!( + "TODO gracefully handle unsupported target architecture: {:?}", + target.architecture + ), + } +} + +#[cfg(feature = "llvm")] pub fn target_machine( target: &Triple, opt: OptimizationLevel, @@ -83,3 +90,11 @@ pub fn target_machine( model, ) } + +#[cfg(feature = "llvm")] +pub fn convert_opt_level(level: OptLevel) -> OptimizationLevel { + match level { + OptLevel::Normal => OptimizationLevel::None, + OptLevel::Optimize => OptimizationLevel::Aggressive, + } +} diff --git a/compiler/gen/src/llvm/build.rs b/compiler/gen/src/llvm/build.rs index 7037fd2f12..46025e3a49 100644 --- a/compiler/gen/src/llvm/build.rs +++ b/compiler/gen/src/llvm/build.rs @@ -49,7 +49,8 @@ use roc_module::ident::TagName; use roc_module::low_level::LowLevel; use roc_module::symbol::{Interns, ModuleId, Symbol}; use roc_mono::ir::{ - BranchInfo, CallType, ExceptionId, JoinPointId, ModifyRc, TopLevelFunctionLayout, Wrapped, + BranchInfo, CallType, ExceptionId, JoinPointId, ModifyRc, OptLevel, TopLevelFunctionLayout, + Wrapped, }; use roc_mono::layout::{Builtin, InPlace, LambdaSet, Layout, LayoutIds, UnionLayout}; use target_lexicon::CallingConvention; @@ -86,21 +87,6 @@ macro_rules! debug_info_init { }}; } -#[derive(Debug, Clone, Copy)] -pub enum OptLevel { - Normal, - Optimize, -} - -impl From for OptimizationLevel { - fn from(level: OptLevel) -> Self { - match level { - OptLevel::Normal => OptimizationLevel::None, - OptLevel::Optimize => OptimizationLevel::Aggressive, - } - } -} - /// Iterate over all functions in an llvm module pub struct FunctionIterator<'ctx> { next: Option>, diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 29da0e66e3..c967fc14b2 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -43,6 +43,12 @@ macro_rules! return_on_layout_error { }; } +#[derive(Debug, Clone, Copy)] +pub enum OptLevel { + Normal, + Optimize, +} + #[derive(Clone, Debug, PartialEq)] pub enum MonoProblem { PatternProblem(crate::exhaustive::Error), diff --git a/compiler/test_gen/src/helpers/eval.rs b/compiler/test_gen/src/helpers/eval.rs index 14dffa71d5..e8511b2586 100644 --- a/compiler/test_gen/src/helpers/eval.rs +++ b/compiler/test_gen/src/helpers/eval.rs @@ -6,6 +6,7 @@ use roc_can::def::Def; use roc_collections::all::{MutMap, MutSet}; use roc_gen::llvm::externs::add_default_roc_externs; use roc_module::symbol::Symbol; +use roc_mono::ir::OptLevel; use roc_types::subs::VarStore; fn promote_expr_to_module(src: &str) -> String { @@ -190,9 +191,9 @@ pub fn helper<'a>( module.strip_debug_info(); let opt_level = if cfg!(debug_assertions) { - roc_gen::llvm::build::OptLevel::Normal + OptLevel::Normal } else { - roc_gen::llvm::build::OptLevel::Optimize + OptLevel::Optimize }; let module = arena.alloc(module); From 9eee9df29bcf0b836f6eabc38a548babf2ac3eb3 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sun, 6 Jun 2021 00:33:11 -0400 Subject: [PATCH 134/496] Don't use LLVM when building docs --- www/build.sh | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/www/build.sh b/www/build.sh index bc1a7c0a35..28d29a85b6 100755 --- a/www/build.sh +++ b/www/build.sh @@ -13,6 +13,8 @@ cp -r public/ build/ pushd .. echo 'Generating docs...' -cargo run docs compiler/builtins/docs/Bool.roc +# We run the CLI with --no-default-features because that way we don't have a LLVM +# dependency. (Netlify's build servers have Rust installed, but not LLVM.) +cargo run -p roc_cli --no-default-features docs compiler/builtins/docs/Bool.roc mv generated-docs/ www/build/builtins popd From 99db51148120dbc2787ba7e335ece6ea820b4bb9 Mon Sep 17 00:00:00 2001 From: rvcas Date: Sun, 6 Jun 2021 00:48:14 -0400 Subject: [PATCH 135/496] fix: build.zig * can use .ReleaseFast shortcut * string format the new way --- compiler/builtins/bitcode/build.zig | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/compiler/builtins/bitcode/build.zig b/compiler/builtins/bitcode/build.zig index 9d3b0456a7..e9835e0db5 100644 --- a/compiler/builtins/bitcode/build.zig +++ b/compiler/builtins/bitcode/build.zig @@ -1,16 +1,15 @@ -const builtin = @import("builtin"); const std = @import("std"); const mem = std.mem; const Builder = std.build.Builder; pub fn build(b: *Builder) void { - // b.setPreferredReleaseMode(builtin.Mode.Debug); - b.setPreferredReleaseMode(builtin.Mode.ReleaseFast); + // b.setPreferredReleaseMode(builtin.Mode.Debug + b.setPreferredReleaseMode(.ReleaseFast); const mode = b.standardReleaseOptions(); // Options const fallback_main_path = "./src/main.zig"; - const main_path_desc = b.fmt("Override path to main.zig. Used by \"ir\" and \"test\". Defaults to \"{}\". ", .{fallback_main_path}); + const main_path_desc = b.fmt("Override path to main.zig. Used by \"ir\" and \"test\". Defaults to \"{s}\". ", .{fallback_main_path}); const main_path = b.option([]const u8, "main-path", main_path_desc) orelse fallback_main_path; // Tests From a3c90098677af87f816c975cb0a33922700e2028 Mon Sep 17 00:00:00 2001 From: rvcas Date: Sun, 6 Jun 2021 00:50:52 -0400 Subject: [PATCH 136/496] fix: all tests need to use try now --- compiler/builtins/bitcode/src/dec.zig | 42 +++---- compiler/builtins/bitcode/src/hash.zig | 22 ++-- .../builtins/bitcode/src/helpers/grapheme.zig | 8 +- compiler/builtins/bitcode/src/str.zig | 116 +++++++++--------- 4 files changed, 94 insertions(+), 94 deletions(-) diff --git a/compiler/builtins/bitcode/src/dec.zig b/compiler/builtins/bitcode/src/dec.zig index 1d51d4cc83..ce775f09fa 100644 --- a/compiler/builtins/bitcode/src/dec.zig +++ b/compiler/builtins/bitcode/src/dec.zig @@ -323,140 +323,140 @@ const expectEqual = testing.expectEqual; test "fromU64" { var dec = RocDec.fromU64(25); - expectEqual(RocDec{ .num = 25000000000000000000 }, dec); + try expectEqual(RocDec{ .num = 25000000000000000000 }, dec); } test "fromString: empty" { var roc_str = RocStr.init("", 0); var dec = RocDec.fromString(roc_str); - expectEqual(dec, null); + try expectEqual(dec, null); } test "fromString: 0" { var roc_str = RocStr.init("0", 1); var dec = RocDec.fromString(roc_str); - expectEqual(RocDec{ .num = 0 }, dec.?); + try expectEqual(RocDec{ .num = 0 }, dec.?); } test "fromString: 1" { var roc_str = RocStr.init("1", 1); var dec = RocDec.fromString(roc_str); - expectEqual(RocDec.one_point_zero, dec.?); + try expectEqual(RocDec.one_point_zero, dec.?); } test "fromString: 123.45" { var roc_str = RocStr.init("123.45", 6); var dec = RocDec.fromString(roc_str); - expectEqual(RocDec{ .num = 123450000000000000000 }, dec.?); + try expectEqual(RocDec{ .num = 123450000000000000000 }, dec.?); } test "fromString: .45" { var roc_str = RocStr.init(".45", 3); var dec = RocDec.fromString(roc_str); - expectEqual(RocDec{ .num = 450000000000000000 }, dec.?); + try expectEqual(RocDec{ .num = 450000000000000000 }, dec.?); } test "fromString: 0.45" { var roc_str = RocStr.init("0.45", 4); var dec = RocDec.fromString(roc_str); - expectEqual(RocDec{ .num = 450000000000000000 }, dec.?); + try expectEqual(RocDec{ .num = 450000000000000000 }, dec.?); } test "fromString: 123" { var roc_str = RocStr.init("123", 3); var dec = RocDec.fromString(roc_str); - expectEqual(RocDec{ .num = 123000000000000000000 }, dec.?); + try expectEqual(RocDec{ .num = 123000000000000000000 }, dec.?); } test "fromString: -.45" { var roc_str = RocStr.init("-.45", 4); var dec = RocDec.fromString(roc_str); - expectEqual(RocDec{ .num = -450000000000000000 }, dec.?); + try expectEqual(RocDec{ .num = -450000000000000000 }, dec.?); } test "fromString: -0.45" { var roc_str = RocStr.init("-0.45", 5); var dec = RocDec.fromString(roc_str); - expectEqual(RocDec{ .num = -450000000000000000 }, dec.?); + try expectEqual(RocDec{ .num = -450000000000000000 }, dec.?); } test "fromString: -123" { var roc_str = RocStr.init("-123", 4); var dec = RocDec.fromString(roc_str); - expectEqual(RocDec{ .num = -123000000000000000000 }, dec.?); + try expectEqual(RocDec{ .num = -123000000000000000000 }, dec.?); } test "fromString: -123.45" { var roc_str = RocStr.init("-123.45", 7); var dec = RocDec.fromString(roc_str); - expectEqual(RocDec{ .num = -123450000000000000000 }, dec.?); + try expectEqual(RocDec{ .num = -123450000000000000000 }, dec.?); } test "fromString: abc" { var roc_str = RocStr.init("abc", 3); var dec = RocDec.fromString(roc_str); - expectEqual(dec, null); + try expectEqual(dec, null); } test "fromString: 123.abc" { var roc_str = RocStr.init("123.abc", 7); var dec = RocDec.fromString(roc_str); - expectEqual(dec, null); + try expectEqual(dec, null); } test "fromString: abc.123" { var roc_str = RocStr.init("abc.123", 7); var dec = RocDec.fromString(roc_str); - expectEqual(dec, null); + try expectEqual(dec, null); } test "fromString: .123.1" { var roc_str = RocStr.init(".123.1", 6); var dec = RocDec.fromString(roc_str); - expectEqual(dec, null); + try expectEqual(dec, null); } test "add: 0" { var dec: RocDec = .{ .num = 0 }; - expectEqual(RocDec{ .num = 0 }, dec.add(.{ .num = 0 })); + try expectEqual(RocDec{ .num = 0 }, dec.add(.{ .num = 0 })); } test "add: 1" { var dec: RocDec = .{ .num = 0 }; - expectEqual(RocDec{ .num = 1 }, dec.add(.{ .num = 1 })); + try expectEqual(RocDec{ .num = 1 }, dec.add(.{ .num = 1 })); } test "mul: by 0" { var dec: RocDec = .{ .num = 0 }; - expectEqual(RocDec{ .num = 0 }, dec.mul(.{ .num = 0 })); + try expectEqual(RocDec{ .num = 0 }, dec.mul(.{ .num = 0 })); } test "mul: by 1" { var dec: RocDec = RocDec.fromU64(15); - expectEqual(RocDec.fromU64(15), dec.mul(RocDec.fromU64(1))); + try expectEqual(RocDec.fromU64(15), dec.mul(RocDec.fromU64(1))); } test "mul: by 2" { var dec: RocDec = RocDec.fromU64(15); - expectEqual(RocDec.fromU64(30), dec.mul(RocDec.fromU64(2))); + try expectEqual(RocDec.fromU64(30), dec.mul(RocDec.fromU64(2))); } diff --git a/compiler/builtins/bitcode/src/hash.zig b/compiler/builtins/bitcode/src/hash.zig index 45414e68f3..1ceedadd82 100644 --- a/compiler/builtins/bitcode/src/hash.zig +++ b/compiler/builtins/bitcode/src/hash.zig @@ -202,13 +202,13 @@ const expectEqual = std.testing.expectEqual; test "test vectors" { const hash = Wyhash.hash; - expectEqual(hash(0, ""), 0x0); - expectEqual(hash(1, "a"), 0xbed235177f41d328); - expectEqual(hash(2, "abc"), 0xbe348debe59b27c3); - expectEqual(hash(3, "message digest"), 0x37320f657213a290); - expectEqual(hash(4, "abcdefghijklmnopqrstuvwxyz"), 0xd0b270e1d8a7019c); - expectEqual(hash(5, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"), 0x602a1894d3bbfe7f); - expectEqual(hash(6, "12345678901234567890123456789012345678901234567890123456789012345678901234567890"), 0x829e9c148b75970e); + try expectEqual(hash(0, ""), 0x0); + try expectEqual(hash(1, "a"), 0xbed235177f41d328); + try expectEqual(hash(2, "abc"), 0xbe348debe59b27c3); + try expectEqual(hash(3, "message digest"), 0x37320f657213a290); + try expectEqual(hash(4, "abcdefghijklmnopqrstuvwxyz"), 0xd0b270e1d8a7019c); + try expectEqual(hash(5, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"), 0x602a1894d3bbfe7f); + try expectEqual(hash(6, "12345678901234567890123456789012345678901234567890123456789012345678901234567890"), 0x829e9c148b75970e); } test "test vectors streaming" { @@ -216,19 +216,19 @@ test "test vectors streaming" { for ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") |e| { wh.update(mem.asBytes(&e)); } - expectEqual(wh.final(), 0x602a1894d3bbfe7f); + try expectEqual(wh.final(), 0x602a1894d3bbfe7f); const pattern = "1234567890"; const count = 8; const result = 0x829e9c148b75970e; - expectEqual(Wyhash.hash(6, pattern ** 8), result); + try expectEqual(Wyhash.hash(6, pattern ** 8), result); wh = Wyhash.init(6); var i: u32 = 0; while (i < count) : (i += 1) { wh.update(pattern); } - expectEqual(wh.final(), result); + try expectEqual(wh.final(), result); } test "iterative non-divisible update" { @@ -250,6 +250,6 @@ test "iterative non-divisible update" { } const iterative_hash = wy.final(); - std.testing.expectEqual(iterative_hash, non_iterative_hash); + try std.testing.expectEqual(iterative_hash, non_iterative_hash); } } diff --git a/compiler/builtins/bitcode/src/helpers/grapheme.zig b/compiler/builtins/bitcode/src/helpers/grapheme.zig index 252873cb4e..36cd2c4418 100644 --- a/compiler/builtins/bitcode/src/helpers/grapheme.zig +++ b/compiler/builtins/bitcode/src/helpers/grapheme.zig @@ -42,7 +42,7 @@ pub const BoundClass = enum(u8) { }; test "Bound Class" { - expectEqual(0, @enumToInt(BoundClass.START)); + try expectEqual(0, @enumToInt(BoundClass.START)); } // https://github.com/JuliaStrings/utf8proc/blob/master/utf8proc.c#L261 @@ -112,7 +112,7 @@ fn unsafeCodepointToBoundClass(codepoint: u21) *const BoundClass { } test "unsafeCodepointToBoundClass: valid" { - expectEqual(BoundClass.CONTROL, unsafeCodepointToBoundClass(8).*); + try expectEqual(BoundClass.CONTROL, unsafeCodepointToBoundClass(8).*); } // https://github.com/JuliaStrings/utf8proc/blob/master/utf8proc.c#L242 @@ -125,11 +125,11 @@ fn codepointToBoundClass(codepoint: u21) *const BoundClass { } test "codepointToBoundClass: valid" { - expectEqual(BoundClass.CONTROL, codepointToBoundClass(8).*); + try expectEqual(BoundClass.CONTROL, codepointToBoundClass(8).*); } test "codepointToBoundClass: invalid" { - expectEqual(BoundClass.OTHER, codepointToBoundClass(codepoint_max + 5).*); + try expectEqual(BoundClass.OTHER, codepointToBoundClass(codepoint_max + 5).*); } // https://github.com/JuliaStrings/utf8proc/blob/master/utf8proc.c#L319 diff --git a/compiler/builtins/bitcode/src/str.zig b/compiler/builtins/bitcode/src/str.zig index 4423d83df8..845fd2b853 100644 --- a/compiler/builtins/bitcode/src/str.zig +++ b/compiler/builtins/bitcode/src/str.zig @@ -273,7 +273,7 @@ pub const RocStr = extern struct { const str2_ptr: [*]u8 = &str2; var roc_str2 = RocStr.init(str2_ptr, str2_len); - expect(roc_str1.eq(roc_str2)); + try expect(roc_str1.eq(roc_str2)); roc_str1.deinit(); roc_str2.deinit(); @@ -295,7 +295,7 @@ pub const RocStr = extern struct { roc_str2.deinit(); } - expect(!roc_str1.eq(roc_str2)); + try expect(!roc_str1.eq(roc_str2)); } test "RocStr.eq: not equal same length" { @@ -314,7 +314,7 @@ pub const RocStr = extern struct { roc_str2.deinit(); } - expect(!roc_str1.eq(roc_str2)); + try expect(!roc_str1.eq(roc_str2)); } }; @@ -449,8 +449,8 @@ test "strSplitInPlace: no delimiter" { delimiter.deinit(); } - expectEqual(array.len, expected.len); - expect(array[0].eq(expected[0])); + try expectEqual(array.len, expected.len); + try expect(array[0].eq(expected[0])); } test "strSplitInPlace: empty end" { @@ -490,10 +490,10 @@ test "strSplitInPlace: empty end" { delimiter.deinit(); } - expectEqual(array.len, expected.len); - expect(array[0].eq(expected[0])); - expect(array[1].eq(expected[1])); - expect(array[2].eq(expected[2])); + try expectEqual(array.len, expected.len); + try expect(array[0].eq(expected[0])); + try expect(array[1].eq(expected[1])); + try expect(array[2].eq(expected[2])); } test "strSplitInPlace: delimiter on sides" { @@ -532,10 +532,10 @@ test "strSplitInPlace: delimiter on sides" { delimiter.deinit(); } - expectEqual(array.len, expected.len); - expect(array[0].eq(expected[0])); - expect(array[1].eq(expected[1])); - expect(array[2].eq(expected[2])); + try expectEqual(array.len, expected.len); + try expect(array[0].eq(expected[0])); + try expect(array[1].eq(expected[1])); + try expect(array[2].eq(expected[2])); } test "strSplitInPlace: three pieces" { @@ -573,10 +573,10 @@ test "strSplitInPlace: three pieces" { delimiter.deinit(); } - expectEqual(expected_array.len, array.len); - expect(array[0].eq(expected_array[0])); - expect(array[1].eq(expected_array[1])); - expect(array[2].eq(expected_array[2])); + try expectEqual(expected_array.len, array.len); + try expect(array[0].eq(expected_array[0])); + try expect(array[1].eq(expected_array[1])); + try expect(array[2].eq(expected_array[2])); } // This is used for `Str.split : Str, Str -> Array Str @@ -639,7 +639,7 @@ test "countSegments: long delimiter" { } const segments_count = countSegments(str, delimiter); - expectEqual(segments_count, 1); + try expectEqual(segments_count, 1); } test "countSegments: delimiter at start" { @@ -658,7 +658,7 @@ test "countSegments: delimiter at start" { const segments_count = countSegments(str, delimiter); - expectEqual(segments_count, 2); + try expectEqual(segments_count, 2); } test "countSegments: delimiter interspered" { @@ -677,7 +677,7 @@ test "countSegments: delimiter interspered" { const segments_count = countSegments(str, delimiter); - expectEqual(segments_count, 3); + try expectEqual(segments_count, 3); } // Str.countGraphemeClusters @@ -721,7 +721,7 @@ fn rocStrFromLiteral(bytes_arr: *const []u8) RocStr {} test "countGraphemeClusters: empty string" { const count = countGraphemeClusters(RocStr.empty()); - expectEqual(count, 0); + try expectEqual(count, 0); } test "countGraphemeClusters: ascii characters" { @@ -731,7 +731,7 @@ test "countGraphemeClusters: ascii characters" { defer str.deinit(); const count = countGraphemeClusters(str); - expectEqual(count, 4); + try expectEqual(count, 4); } test "countGraphemeClusters: utf8 characters" { @@ -741,7 +741,7 @@ test "countGraphemeClusters: utf8 characters" { defer str.deinit(); const count = countGraphemeClusters(str); - expectEqual(count, 3); + try expectEqual(count, 3); } test "countGraphemeClusters: emojis" { @@ -751,7 +751,7 @@ test "countGraphemeClusters: emojis" { defer str.deinit(); const count = countGraphemeClusters(str); - expectEqual(count, 3); + try expectEqual(count, 3); } test "countGraphemeClusters: emojis and ut8 characters" { @@ -761,7 +761,7 @@ test "countGraphemeClusters: emojis and ut8 characters" { defer str.deinit(); const count = countGraphemeClusters(str); - expectEqual(count, 6); + try expectEqual(count, 6); } test "countGraphemeClusters: emojis, ut8, and ascii characters" { @@ -771,7 +771,7 @@ test "countGraphemeClusters: emojis, ut8, and ascii characters" { defer str.deinit(); const count = countGraphemeClusters(str); - expectEqual(count, 10); + try expectEqual(count, 10); } // Str.startsWith @@ -821,27 +821,27 @@ pub fn startsWithCodePoint(string: RocStr, prefix: u32) callconv(.C) bool { test "startsWithCodePoint: ascii char" { const whole = RocStr.init("foobar", 6); const prefix = 'f'; - expect(startsWithCodePoint(whole, prefix)); + try expect(startsWithCodePoint(whole, prefix)); } test "startsWithCodePoint: emoji" { const yes = RocStr.init("💖foobar", 10); const no = RocStr.init("foobar", 6); const prefix = '💖'; - expect(startsWithCodePoint(yes, prefix)); - expect(!startsWithCodePoint(no, prefix)); + try expect(startsWithCodePoint(yes, prefix)); + try expect(!startsWithCodePoint(no, prefix)); } test "startsWith: foo starts with fo" { const foo = RocStr.init("foo", 3); const fo = RocStr.init("fo", 2); - expect(startsWith(foo, fo)); + try expect(startsWith(foo, fo)); } test "startsWith: 123456789123456789 starts with 123456789123456789" { const str = RocStr.init("123456789123456789", 18); defer str.deinit(); - expect(startsWith(str, str)); + try expect(startsWith(str, str)); } test "startsWith: 12345678912345678910 starts with 123456789123456789" { @@ -850,7 +850,7 @@ test "startsWith: 12345678912345678910 starts with 123456789123456789" { const prefix = RocStr.init("123456789123456789", 18); defer prefix.deinit(); - expect(startsWith(str, prefix)); + try expect(startsWith(str, prefix)); } // Str.endsWith @@ -882,13 +882,13 @@ test "endsWith: foo ends with oo" { defer foo.deinit(); defer oo.deinit(); - expect(endsWith(foo, oo)); + try expect(endsWith(foo, oo)); } test "endsWith: 123456789123456789 ends with 123456789123456789" { const str = RocStr.init("123456789123456789", 18); defer str.deinit(); - expect(endsWith(str, str)); + try expect(endsWith(str, str)); } test "endsWith: 12345678912345678910 ends with 345678912345678910" { @@ -897,7 +897,7 @@ test "endsWith: 12345678912345678910 ends with 345678912345678910" { defer str.deinit(); defer suffix.deinit(); - expect(endsWith(str, suffix)); + try expect(endsWith(str, suffix)); } test "endsWith: hello world ends with world" { @@ -906,7 +906,7 @@ test "endsWith: hello world ends with world" { defer str.deinit(); defer suffix.deinit(); - expect(endsWith(str, suffix)); + try expect(endsWith(str, suffix)); } // Str.concat @@ -978,7 +978,7 @@ test "RocStr.concat: small concat small" { defer result.deinit(); - expect(roc_str3.eq(result)); + try expect(roc_str3.eq(result)); } pub const RocListStr = extern struct { @@ -1057,7 +1057,7 @@ test "RocStr.joinWith: result is big" { defer result.deinit(); - expect(roc_result.eq(result)); + try expect(roc_result.eq(result)); } // Str.toBytes @@ -1191,8 +1191,8 @@ fn validateUtf8BytesX(str: RocList) FromUtf8Result { return fromUtf8(str); } -fn expectOk(result: FromUtf8Result) void { - expectEqual(result.is_ok, true); +fn expectOk(result: FromUtf8Result) !void { + try expectEqual(result.is_ok, true); } fn sliceHelp(bytes: [*]const u8, length: usize) RocList { @@ -1217,7 +1217,7 @@ test "validateUtf8Bytes: ascii" { const ptr: [*]const u8 = @ptrCast([*]const u8, raw); const list = sliceHelp(ptr, raw.len); - expectOk(validateUtf8BytesX(list)); + try expectOk(validateUtf8BytesX(list)); } test "validateUtf8Bytes: unicode œ" { @@ -1225,7 +1225,7 @@ test "validateUtf8Bytes: unicode œ" { const ptr: [*]const u8 = @ptrCast([*]const u8, raw); const list = sliceHelp(ptr, raw.len); - expectOk(validateUtf8BytesX(list)); + try expectOk(validateUtf8BytesX(list)); } test "validateUtf8Bytes: unicode ∆" { @@ -1233,7 +1233,7 @@ test "validateUtf8Bytes: unicode ∆" { const ptr: [*]const u8 = @ptrCast([*]const u8, raw); const list = sliceHelp(ptr, raw.len); - expectOk(validateUtf8BytesX(list)); + try expectOk(validateUtf8BytesX(list)); } test "validateUtf8Bytes: emoji" { @@ -1241,7 +1241,7 @@ test "validateUtf8Bytes: emoji" { const ptr: [*]const u8 = @ptrCast([*]const u8, raw); const list = sliceHelp(ptr, raw.len); - expectOk(validateUtf8BytesX(list)); + try expectOk(validateUtf8BytesX(list)); } test "validateUtf8Bytes: unicode ∆ in middle of array" { @@ -1249,15 +1249,15 @@ test "validateUtf8Bytes: unicode ∆ in middle of array" { const ptr: [*]const u8 = @ptrCast([*]const u8, raw); const list = sliceHelp(ptr, raw.len); - expectOk(validateUtf8BytesX(list)); + try expectOk(validateUtf8BytesX(list)); } -fn expectErr(list: RocList, index: usize, err: Utf8DecodeError, problem: Utf8ByteProblem) void { +fn expectErr(list: RocList, index: usize, err: Utf8DecodeError, problem: Utf8ByteProblem) !void { const str_ptr = @ptrCast([*]u8, list.bytes); const str_len = list.length; - expectError(err, numberOfNextCodepointBytes(str_ptr, str_len, index)); - expectEqual(toErrUtf8ByteResponse(index, problem), validateUtf8Bytes(str_ptr, str_len)); + try expectError(err, numberOfNextCodepointBytes(str_ptr, str_len, index)); + try expectEqual(toErrUtf8ByteResponse(index, problem), validateUtf8Bytes(str_ptr, str_len)); } test "validateUtf8Bytes: invalid start byte" { @@ -1266,7 +1266,7 @@ test "validateUtf8Bytes: invalid start byte" { const ptr: [*]const u8 = @ptrCast([*]const u8, raw); const list = sliceHelp(ptr, raw.len); - expectErr(list, 2, error.Utf8InvalidStartByte, Utf8ByteProblem.InvalidStartByte); + try expectErr(list, 2, error.Utf8InvalidStartByte, Utf8ByteProblem.InvalidStartByte); } test "validateUtf8Bytes: unexpected eof for 2 byte sequence" { @@ -1275,7 +1275,7 @@ test "validateUtf8Bytes: unexpected eof for 2 byte sequence" { const ptr: [*]const u8 = @ptrCast([*]const u8, raw); const list = sliceHelp(ptr, raw.len); - expectErr(list, 3, error.UnexpectedEof, Utf8ByteProblem.UnexpectedEndOfSequence); + try expectErr(list, 3, error.UnexpectedEof, Utf8ByteProblem.UnexpectedEndOfSequence); } test "validateUtf8Bytes: expected continuation for 2 byte sequence" { @@ -1284,7 +1284,7 @@ test "validateUtf8Bytes: expected continuation for 2 byte sequence" { const ptr: [*]const u8 = @ptrCast([*]const u8, raw); const list = sliceHelp(ptr, raw.len); - expectErr(list, 3, error.Utf8ExpectedContinuation, Utf8ByteProblem.ExpectedContinuation); + try expectErr(list, 3, error.Utf8ExpectedContinuation, Utf8ByteProblem.ExpectedContinuation); } test "validateUtf8Bytes: unexpected eof for 3 byte sequence" { @@ -1293,7 +1293,7 @@ test "validateUtf8Bytes: unexpected eof for 3 byte sequence" { const ptr: [*]const u8 = @ptrCast([*]const u8, raw); const list = sliceHelp(ptr, raw.len); - expectErr(list, 3, error.UnexpectedEof, Utf8ByteProblem.UnexpectedEndOfSequence); + try expectErr(list, 3, error.UnexpectedEof, Utf8ByteProblem.UnexpectedEndOfSequence); } test "validateUtf8Bytes: expected continuation for 3 byte sequence" { @@ -1302,7 +1302,7 @@ test "validateUtf8Bytes: expected continuation for 3 byte sequence" { const ptr: [*]const u8 = @ptrCast([*]const u8, raw); const list = sliceHelp(ptr, raw.len); - expectErr(list, 3, error.Utf8ExpectedContinuation, Utf8ByteProblem.ExpectedContinuation); + try expectErr(list, 3, error.Utf8ExpectedContinuation, Utf8ByteProblem.ExpectedContinuation); } test "validateUtf8Bytes: unexpected eof for 4 byte sequence" { @@ -1311,7 +1311,7 @@ test "validateUtf8Bytes: unexpected eof for 4 byte sequence" { const ptr: [*]const u8 = @ptrCast([*]const u8, raw); const list = sliceHelp(ptr, raw.len); - expectErr(list, 3, error.UnexpectedEof, Utf8ByteProblem.UnexpectedEndOfSequence); + try expectErr(list, 3, error.UnexpectedEof, Utf8ByteProblem.UnexpectedEndOfSequence); } test "validateUtf8Bytes: expected continuation for 4 byte sequence" { @@ -1320,7 +1320,7 @@ test "validateUtf8Bytes: expected continuation for 4 byte sequence" { const ptr: [*]const u8 = @ptrCast([*]const u8, raw); const list = sliceHelp(ptr, raw.len); - expectErr(list, 3, error.Utf8ExpectedContinuation, Utf8ByteProblem.ExpectedContinuation); + try expectErr(list, 3, error.Utf8ExpectedContinuation, Utf8ByteProblem.ExpectedContinuation); } test "validateUtf8Bytes: overlong" { @@ -1329,7 +1329,7 @@ test "validateUtf8Bytes: overlong" { const ptr: [*]const u8 = @ptrCast([*]const u8, raw); const list = sliceHelp(ptr, raw.len); - expectErr(list, 3, error.Utf8OverlongEncoding, Utf8ByteProblem.OverlongEncoding); + try expectErr(list, 3, error.Utf8OverlongEncoding, Utf8ByteProblem.OverlongEncoding); } test "validateUtf8Bytes: codepoint out too large" { @@ -1338,7 +1338,7 @@ test "validateUtf8Bytes: codepoint out too large" { const ptr: [*]const u8 = @ptrCast([*]const u8, raw); const list = sliceHelp(ptr, raw.len); - expectErr(list, 3, error.Utf8CodepointTooLarge, Utf8ByteProblem.CodepointTooLarge); + try expectErr(list, 3, error.Utf8CodepointTooLarge, Utf8ByteProblem.CodepointTooLarge); } test "validateUtf8Bytes: surrogate halves" { @@ -1347,5 +1347,5 @@ test "validateUtf8Bytes: surrogate halves" { const ptr: [*]const u8 = @ptrCast([*]const u8, raw); const list = sliceHelp(ptr, raw.len); - expectErr(list, 3, error.Utf8EncodesSurrogateHalf, Utf8ByteProblem.EncodesSurrogateHalf); + try expectErr(list, 3, error.Utf8EncodesSurrogateHalf, Utf8ByteProblem.EncodesSurrogateHalf); } From 5b91de40db0d3a8ff67032ab91afd257ad4b58da Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sun, 6 Jun 2021 00:51:17 -0400 Subject: [PATCH 137/496] Only include_bytes when actually building --- compiler/builtins/src/bitcode.rs | 6 ------ compiler/gen/src/llvm/build.rs | 4 +++- 2 files changed, 3 insertions(+), 7 deletions(-) diff --git a/compiler/builtins/src/bitcode.rs b/compiler/builtins/src/bitcode.rs index ad36d544b3..3e5d71ebe6 100644 --- a/compiler/builtins/src/bitcode.rs +++ b/compiler/builtins/src/bitcode.rs @@ -3,12 +3,6 @@ pub const OBJ_PATH: &str = env!( "Env var BUILTINS_O not found. Is there a problem with the build script?" ); -pub fn as_bytes() -> &'static [u8] { - // In the build script for the builtins module, - // we compile the builtins into LLVM bitcode - include_bytes!("../bitcode/builtins.bc") -} - pub const NUM_ASIN: &str = "roc_builtins.num.asin"; pub const NUM_ACOS: &str = "roc_builtins.num.acos"; pub const NUM_ATAN: &str = "roc_builtins.num.atan"; diff --git a/compiler/gen/src/llvm/build.rs b/compiler/gen/src/llvm/build.rs index 46025e3a49..47e989006b 100644 --- a/compiler/gen/src/llvm/build.rs +++ b/compiler/gen/src/llvm/build.rs @@ -341,7 +341,9 @@ impl<'a, 'ctx, 'env> Env<'a, 'ctx, 'env> { } pub fn module_from_builtins<'ctx>(ctx: &'ctx Context, module_name: &str) -> Module<'ctx> { - let bitcode_bytes = bitcode::as_bytes(); + // In the build script for the builtins module, + // we compile the builtins into LLVM bitcode + let bitcode_bytes: &[u8] = include_bytes!("../../../builtins/bitcode/builtins.bc"); let memory_buffer = MemoryBuffer::create_from_memory_range(&bitcode_bytes, module_name); From f6c8c0ff327c6b21e9fb7224c15d5247e4aabece Mon Sep 17 00:00:00 2001 From: rvcas Date: Sun, 6 Jun 2021 00:51:58 -0400 Subject: [PATCH 138/496] feat: better implicit int casts now --- compiler/builtins/bitcode/src/dec.zig | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/builtins/bitcode/src/dec.zig b/compiler/builtins/bitcode/src/dec.zig index ce775f09fa..5de76c40f6 100644 --- a/compiler/builtins/bitcode/src/dec.zig +++ b/compiler/builtins/bitcode/src/dec.zig @@ -16,7 +16,7 @@ pub const RocDec = struct { pub const one_point_zero: comptime RocDec = .{ .num = one_point_zero_i128 }; pub fn fromU64(num: u64) RocDec { - return .{ .num = @intCast(i128, num) * one_point_zero_i128 }; + return .{ .num = num * one_point_zero_i128 }; } pub fn fromString(roc_str: RocStr) ?RocDec { From 954949fbb0d7aad83f4c6feb1d2297109a5200a3 Mon Sep 17 00:00:00 2001 From: rvcas Date: Sun, 6 Jun 2021 00:52:44 -0400 Subject: [PATCH 139/496] chore: delete unused function --- compiler/builtins/bitcode/src/utils.zig | 38 ------------------------- 1 file changed, 38 deletions(-) diff --git a/compiler/builtins/bitcode/src/utils.zig b/compiler/builtins/bitcode/src/utils.zig index ee08aeeacf..be99cab009 100644 --- a/compiler/builtins/bitcode/src/utils.zig +++ b/compiler/builtins/bitcode/src/utils.zig @@ -71,44 +71,6 @@ pub const IntWidth = enum(u8) { Usize, }; -pub fn intWidth(width: IntWidth) anytype { - switch (width) { - IntWidth.U8 => { - return u8; - }, - IntWidth.U16 => { - return u16; - }, - IntWidth.U32 => { - return u32; - }, - IntWidth.U64 => { - return u64; - }, - IntWidth.U128 => { - return u128; - }, - IntWidth.I8 => { - return i8; - }, - IntWidth.I16 => { - return i16; - }, - IntWidth.I32 => { - return i32; - }, - IntWidth.I64 => { - return i64; - }, - IntWidth.I128 => { - return i128; - }, - IntWidth.Usize => { - return usize; - }, - } -} - pub fn decref( bytes_or_null: ?[*]u8, data_bytes: usize, From 573f7d8093a54a0184b36b663bba8a5a6f190263 Mon Sep 17 00:00:00 2001 From: rvcas Date: Sun, 6 Jun 2021 00:53:25 -0400 Subject: [PATCH 140/496] feat(listRange): use a more terse syntax --- compiler/builtins/bitcode/src/list.zig | 50 +++++++------------------- 1 file changed, 13 insertions(+), 37 deletions(-) diff --git a/compiler/builtins/bitcode/src/list.zig b/compiler/builtins/bitcode/src/list.zig index c35484077b..61af7031d0 100644 --- a/compiler/builtins/bitcode/src/list.zig +++ b/compiler/builtins/bitcode/src/list.zig @@ -781,43 +781,19 @@ pub fn listDrop( } pub fn listRange(width: utils.IntWidth, low: Opaque, high: Opaque) callconv(.C) RocList { - const IntWidth = utils.IntWidth; - - switch (width) { - IntWidth.U8 => { - return helper1(u8, low, high); - }, - IntWidth.U16 => { - return helper1(u16, low, high); - }, - IntWidth.U32 => { - return helper1(u32, low, high); - }, - IntWidth.U64 => { - return helper1(u64, low, high); - }, - IntWidth.U128 => { - return helper1(u128, low, high); - }, - IntWidth.I8 => { - return helper1(i8, low, high); - }, - IntWidth.I16 => { - return helper1(i16, low, high); - }, - IntWidth.I32 => { - return helper1(i32, low, high); - }, - IntWidth.I64 => { - return helper1(i64, low, high); - }, - IntWidth.I128 => { - return helper1(i128, low, high); - }, - IntWidth.Usize => { - return helper1(usize, low, high); - }, - } + return switch (width) { + .U8 => helper1(u8, low, high), + .U16 => helper1(u16, low, high), + .U32 => helper1(u32, low, high), + .U64 => helper1(u64, low, high), + .U128 => helper1(u128, low, high), + .I8 => helper1(i8, low, high), + .I16 => helper1(i16, low, high), + .I32 => helper1(i32, low, high), + .I64 => helper1(i64, low, high), + .I128 => helper1(i128, low, high), + .Usize => helper1(usize, low, high), + }; } fn helper1(comptime T: type, low: Opaque, high: Opaque) RocList { From 368448862987a0702c5841a76a0aed83deacaa1c Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sun, 6 Jun 2021 00:55:10 -0400 Subject: [PATCH 141/496] Make sure BUILTINS_O gets set --- compiler/builtins/build.rs | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/compiler/builtins/build.rs b/compiler/builtins/build.rs index e0d493457b..8b42e59835 100644 --- a/compiler/builtins/build.rs +++ b/compiler/builtins/build.rs @@ -8,15 +8,22 @@ use std::process::Command; use std::str; fn main() { + let out_dir = env::var_os("OUT_DIR").unwrap(); + let dest_obj_path = Path::new(&out_dir).join("builtins.o"); + let dest_obj = dest_obj_path.to_str().expect("Invalid dest object path"); + + println!("cargo:rerun-if-changed=build.rs"); + println!("cargo:rustc-env=BUILTINS_O={}", dest_obj); + // When we build on Netlify, zig is not installed (but also not used, // since all we're doing is generating docs), so we can skip the steps // that require having zig installed. if env::var_os("NO_ZIG_INSTALLED").is_some() { + // We still need to do the other things before this point, because + // setting the env vars is needed for other parts of the build. return; } - let out_dir = env::var_os("OUT_DIR").unwrap(); - let big_sur_path = "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/lib"; let use_build_script = Path::new(big_sur_path).exists(); @@ -41,8 +48,6 @@ fn main() { run_command(&bitcode_path, "zig", &["build", "ir", "-Drelease=true"]); } - let dest_obj_path = Path::new(&out_dir).join("builtins.o"); - let dest_obj = dest_obj_path.to_str().expect("Invalid dest object path"); println!("Moving zig object to: {}", dest_obj); run_command(&bitcode_path, "mv", &[src_obj, dest_obj]); @@ -57,8 +62,6 @@ fn main() { &[dest_ir, "-o", dest_bc], ); - println!("cargo:rerun-if-changed=build.rs"); - println!("cargo:rustc-env=BUILTINS_O={}", dest_obj); get_zig_files(bitcode_path.as_path(), &|path| { let path: &Path = path; println!( From d7b64b000dfbb8d2a23317b789398e30438679a6 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sun, 6 Jun 2021 01:12:11 -0400 Subject: [PATCH 142/496] Netlify shouldn't build the editor ...and anyway it can't, because it's missing the xcb-shape and xcb-xfixes libraries. --- cli/Cargo.toml | 5 +++-- cli/src/main.rs | 16 +++++++++++++--- 2 files changed, 16 insertions(+), 5 deletions(-) diff --git a/cli/Cargo.toml b/cli/Cargo.toml index 177f9783cf..0f1c5a8ccb 100644 --- a/cli/Cargo.toml +++ b/cli/Cargo.toml @@ -15,11 +15,12 @@ test = false bench = false [features] -default = ["target-x86", "llvm"] +default = ["target-x86", "llvm", "editor"] # This is a separate feature because when we generate docs on Netlify, # it doesn't have LLVM installed. (Also, it doesn't need to do code gen.) llvm = ["inkwell", "roc_gen", "roc_build/llvm"] +editor = ["roc_editor"] target-x86 = [] @@ -53,7 +54,7 @@ roc_gen = { path = "../compiler/gen", optional = true } roc_build = { path = "../compiler/build", default-features = false } roc_fmt = { path = "../compiler/fmt" } roc_reporting = { path = "../compiler/reporting" } -roc_editor = { path = "../editor" } +roc_editor = { path = "../editor", optional = true } # TODO switch to clap 3.0.0 once it's out. Tried adding clap = "~3.0.0-beta.1" and cargo wouldn't accept it clap = { git = "https://github.com/rtfeldman/clap", branch = "master" } const_format = "0.2.8" diff --git a/cli/src/main.rs b/cli/src/main.rs index bd38a5e56a..80acc15ada 100644 --- a/cli/src/main.rs +++ b/cli/src/main.rs @@ -19,7 +19,7 @@ fn main() -> io::Result<()> { let exit_code = match matches.subcommand_name() { None => { - roc_editor::launch(&[])?; + launch_editor(&[])?; // rustc couldn't infer the error type here Result::::Ok(0) @@ -52,14 +52,14 @@ fn main() -> io::Result<()> { .values_of_os(DIRECTORY_OR_FILES) { None => { - roc_editor::launch(&[])?; + launch_editor(&[])?; } Some(values) => { let paths = values .map(|os_str| Path::new(os_str)) .collect::>(); - roc_editor::launch(&paths)?; + launch_editor(&paths)?; } } @@ -86,3 +86,13 @@ fn main() -> io::Result<()> { std::process::exit(exit_code); } + +#[cfg(feature = "editor")] +fn launch_editor(filepaths: &[&Path]) -> io::Result<()> { + roc_editor::launch(filepaths) +} + +#[cfg(not(feature = "editor"))] +fn launch_editor(_filepaths: &[&Path]) -> io::Result<()> { + panic!("Cannot launch the editor because this build of roc did not include `feature = \"editor\"`!"); +} From 6ec8c7e94456639cf53deef9555aaf023b8bef86 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sun, 6 Jun 2021 01:25:55 -0400 Subject: [PATCH 143/496] Give each generated builtin doc its own index.html --- www/build.sh | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/www/build.sh b/www/build.sh index 28d29a85b6..b5474bfd69 100755 --- a/www/build.sh +++ b/www/build.sh @@ -16,5 +16,17 @@ echo 'Generating docs...' # We run the CLI with --no-default-features because that way we don't have a LLVM # dependency. (Netlify's build servers have Rust installed, but not LLVM.) cargo run -p roc_cli --no-default-features docs compiler/builtins/docs/Bool.roc + mv generated-docs/ www/build/builtins + +pushd www/build/builtins + +for f in ./*.html; do + DIRNAME=$(echo "$f" | sed s/.html//) + mkdir "$DIRNAME" + mv "$f" "$DIRNAME"/index.html +done + +popd + popd From 1a63bd570f294a9b66d4fe6e4a15bf2419df7459 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sun, 6 Jun 2021 01:27:57 -0400 Subject: [PATCH 144/496] Create index.html files in doc gen This way, even when previewing them locally you can see (for example) /Str instead of /Str.html --- docs/src/lib.rs | 9 +++++---- www/build.sh | 12 ------------ 2 files changed, 5 insertions(+), 16 deletions(-) diff --git a/docs/src/lib.rs b/docs/src/lib.rs index bfa9f7ffa1..d4de9c25d2 100644 --- a/docs/src/lib.rs +++ b/docs/src/lib.rs @@ -63,9 +63,10 @@ pub fn generate(filenames: Vec, std_lib: StdLib, build_dir: &Path) { // Write each package's module docs html file for (docs_by_id, interns) in package.modules.iter_mut() { for module in docs_by_id.values_mut() { - let mut filename = String::new(); - filename.push_str(module.name.as_str()); - filename.push_str(".html"); + let module_dir = build_dir.join(module.name.as_str()); + + fs::create_dir(&module_dir) + .expect("TODO gracefully handle not being able to create the module dir"); let rendered_module = template_html .replace( @@ -78,7 +79,7 @@ pub fn generate(filenames: Vec, std_lib: StdLib, build_dir: &Path) { render_main_content(interns, module).as_str(), ); - fs::write(build_dir.join(filename), rendered_module) + fs::write(module_dir.join("index.html"), rendered_module) .expect("TODO gracefully handle failing to write html"); } } diff --git a/www/build.sh b/www/build.sh index b5474bfd69..28d29a85b6 100755 --- a/www/build.sh +++ b/www/build.sh @@ -16,17 +16,5 @@ echo 'Generating docs...' # We run the CLI with --no-default-features because that way we don't have a LLVM # dependency. (Netlify's build servers have Rust installed, but not LLVM.) cargo run -p roc_cli --no-default-features docs compiler/builtins/docs/Bool.roc - mv generated-docs/ www/build/builtins - -pushd www/build/builtins - -for f in ./*.html; do - DIRNAME=$(echo "$f" | sed s/.html//) - mkdir "$DIRNAME" - mv "$f" "$DIRNAME"/index.html -done - -popd - popd From 5a6dc24abd255a5797ad043e1ce552bb888f026d Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sun, 6 Jun 2021 01:41:18 -0400 Subject: [PATCH 145/496] Call init_arch separately from arch_str --- compiler/build/src/target.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/compiler/build/src/target.rs b/compiler/build/src/target.rs index f1a10a830f..4e171359d0 100644 --- a/compiler/build/src/target.rs +++ b/compiler/build/src/target.rs @@ -81,6 +81,8 @@ pub fn target_machine( ) -> Option { let arch = arch_str(target); + init_arch(target); + Target::from_name(arch).unwrap().create_target_machine( &TargetTriple::create(target_triple_str(target)), "generic", From 6fd8db7d2bbc4ac49d5339d39f2e22596abf52ad Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sun, 6 Jun 2021 02:22:00 -0400 Subject: [PATCH 146/496] `roc docs` now accepts directories --- cli/src/main.rs | 32 ++++++++++++++++++++++++++++---- 1 file changed, 28 insertions(+), 4 deletions(-) diff --git a/cli/src/main.rs b/cli/src/main.rs index 80acc15ada..fccf700c96 100644 --- a/cli/src/main.rs +++ b/cli/src/main.rs @@ -2,6 +2,7 @@ use roc_cli::{ build_app, docs, repl, BuildConfig, CMD_BUILD, CMD_DOCS, CMD_EDIT, CMD_REPL, CMD_RUN, DIRECTORY_OR_FILES, ROC_FILE, }; +use std::fs::{self, FileType}; use std::io; use std::path::{Path, PathBuf}; use target_lexicon::Triple; @@ -73,11 +74,16 @@ fn main() -> io::Result<()> { .values_of_os(DIRECTORY_OR_FILES) .unwrap(); - let paths = values - .map(|os_str| Path::new(os_str).to_path_buf()) - .collect::>(); + let mut roc_files = Vec::new(); - docs(paths); + // Populate roc_files + for os_str in values { + let metadata = fs::metadata(os_str)?; + + roc_files_recursive(os_str, metadata.file_type(), &mut roc_files)?; + } + + docs(roc_files); Ok(0) } @@ -87,6 +93,24 @@ fn main() -> io::Result<()> { std::process::exit(exit_code); } +fn roc_files_recursive>( + path: P, + file_type: FileType, + roc_files: &mut Vec, +) -> io::Result<()> { + if file_type.is_dir() { + for entry_res in fs::read_dir(path)? { + let entry = entry_res?; + + roc_files_recursive(entry.path(), entry.file_type()?, roc_files)?; + } + } else { + roc_files.push(path.as_ref().to_path_buf()); + } + + Ok(()) +} + #[cfg(feature = "editor")] fn launch_editor(filepaths: &[&Path]) -> io::Result<()> { roc_editor::launch(filepaths) From 4995bc2312940071f833de48adda840eba81afaf Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sun, 6 Jun 2021 02:22:19 -0400 Subject: [PATCH 147/496] Fix some List docs --- compiler/builtins/docs/List.roc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/compiler/builtins/docs/List.roc b/compiler/builtins/docs/List.roc index 12b1ba7b3c..6f30d0043f 100644 --- a/compiler/builtins/docs/List.roc +++ b/compiler/builtins/docs/List.roc @@ -298,7 +298,7 @@ update : List elem, Nat, (elem -> elem) -> List elem ## A more flexible version of #List.update, which returns an "updater" function ## that lets you delay performing the update until later. -updater : List elem, Nat -> { elem, new : elem -> List elem } +updater : List elem, Nat -> { elem, new : (elem -> List elem) } ## If all the elements in the list are #Ok, return a new list containing the ## contents of those #Ok tags. If any elements are #Err, return #Err. @@ -648,7 +648,7 @@ walk : List elem, { start : state, step : (state, elem -> state) } -> state ## Note that in other languages, `walkBackwards` is sometimes called `reduceRight`, ## `fold`, `foldRight`, or `foldr`. -walkBackwards : List elem, { start : state, step : (state, elem -> state ]) } -> state +walkBackwards : List elem, { start : state, step : (state, elem -> state) } -> state ## Same as #List.walk, except you can stop walking early. ## From b2875ac7fc29c1cc9357d1df9a39495079702348 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sun, 6 Jun 2021 07:43:51 -0400 Subject: [PATCH 148/496] Suppress warnings when generating www.roc-lang.org --- www/build.sh | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/www/build.sh b/www/build.sh index 28d29a85b6..0fc2d25909 100755 --- a/www/build.sh +++ b/www/build.sh @@ -13,8 +13,13 @@ cp -r public/ build/ pushd .. echo 'Generating docs...' -# We run the CLI with --no-default-features because that way we don't have a LLVM -# dependency. (Netlify's build servers have Rust installed, but not LLVM.) -cargo run -p roc_cli --no-default-features docs compiler/builtins/docs/Bool.roc +# We run the CLI with --no-default-features because that way we don't have the +# "llvm" feature and therefore don't depend on LLVM being installed on the +# system. (Netlify's build servers have Rust installed, but not LLVM.) +# +# We set RUSTFLAGS to -Awarnings to ignore warnings during this build, +# because when building without "the" llvm feature (which is only ever done +# for this exact use case), the result is lots of "unused" warnings! +RUSTFLAGS=-Awarnings cargo run -p roc_cli --no-default-features docs compiler/builtins/docs/Bool.roc mv generated-docs/ www/build/builtins popd From 57676057fafabcdc7a1a08137425ec4479ad0803 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sun, 6 Jun 2021 07:51:18 -0400 Subject: [PATCH 149/496] Rename gen to gen_llvm This way, we have gen_dev and gen_llvm representing the two different compiler backends. --- Cargo.lock | 76 +++++++++---------- Cargo.toml | 2 +- cli/Cargo.toml | 4 +- cli/src/repl/eval.rs | 2 +- cli/src/repl/gen.rs | 14 ++-- cli/tests/repl_eval.rs | 5 +- compiler/build/Cargo.toml | 4 +- compiler/build/src/program.rs | 12 +-- compiler/{gen => gen_llvm}/Cargo.toml | 2 +- compiler/{gen => gen_llvm}/src/lib.rs | 0 .../{gen => gen_llvm}/src/llvm/bitcode.rs | 0 compiler/{gen => gen_llvm}/src/llvm/build.rs | 0 .../{gen => gen_llvm}/src/llvm/build_dict.rs | 0 .../{gen => gen_llvm}/src/llvm/build_hash.rs | 0 .../{gen => gen_llvm}/src/llvm/build_list.rs | 0 .../{gen => gen_llvm}/src/llvm/build_str.rs | 0 .../{gen => gen_llvm}/src/llvm/compare.rs | 0 .../{gen => gen_llvm}/src/llvm/convert.rs | 0 .../{gen => gen_llvm}/src/llvm/externs.rs | 0 compiler/{gen => gen_llvm}/src/llvm/mod.rs | 0 .../{gen => gen_llvm}/src/llvm/refcounting.rs | 0 compiler/{gen => gen_llvm}/src/run_roc.rs | 6 +- compiler/test_gen/Cargo.toml | 2 +- compiler/test_gen/src/helpers/eval.rs | 14 ++-- 24 files changed, 73 insertions(+), 70 deletions(-) rename compiler/{gen => gen_llvm}/Cargo.toml (98%) rename compiler/{gen => gen_llvm}/src/lib.rs (100%) rename compiler/{gen => gen_llvm}/src/llvm/bitcode.rs (100%) rename compiler/{gen => gen_llvm}/src/llvm/build.rs (100%) rename compiler/{gen => gen_llvm}/src/llvm/build_dict.rs (100%) rename compiler/{gen => gen_llvm}/src/llvm/build_hash.rs (100%) rename compiler/{gen => gen_llvm}/src/llvm/build_list.rs (100%) rename compiler/{gen => gen_llvm}/src/llvm/build_str.rs (100%) rename compiler/{gen => gen_llvm}/src/llvm/compare.rs (100%) rename compiler/{gen => gen_llvm}/src/llvm/convert.rs (100%) rename compiler/{gen => gen_llvm}/src/llvm/externs.rs (100%) rename compiler/{gen => gen_llvm}/src/llvm/mod.rs (100%) rename compiler/{gen => gen_llvm}/src/llvm/refcounting.rs (100%) rename compiler/{gen => gen_llvm}/src/run_roc.rs (95%) diff --git a/Cargo.lock b/Cargo.lock index 5b05e59e64..65fe5b05b0 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2943,7 +2943,7 @@ dependencies = [ "roc_can", "roc_collections", "roc_constrain", - "roc_gen", + "roc_gen_llvm", "roc_load", "roc_module", "roc_mono", @@ -3025,7 +3025,7 @@ dependencies = [ "roc_docs", "roc_editor", "roc_fmt", - "roc_gen", + "roc_gen_llvm", "roc_load", "roc_module", "roc_mono", @@ -3158,41 +3158,6 @@ dependencies = [ "roc_region", ] -[[package]] -name = "roc_gen" -version = "0.1.0" -dependencies = [ - "bumpalo", - "either", - "im 14.3.0", - "im-rc 14.3.0", - "indoc 0.3.6", - "inkwell 0.1.0", - "inlinable_string", - "libc", - "maplit", - "pretty_assertions 0.5.1", - "quickcheck 0.8.5", - "quickcheck_macros 0.8.0", - "roc_build", - "roc_builtins", - "roc_can", - "roc_collections", - "roc_load", - "roc_module", - "roc_mono", - "roc_parse", - "roc_problem", - "roc_region", - "roc_reporting", - "roc_solve", - "roc_std", - "roc_types", - "roc_unify", - "target-lexicon", - "tokio", -] - [[package]] name = "roc_gen_dev" version = "0.1.0" @@ -3231,6 +3196,41 @@ dependencies = [ "tokio", ] +[[package]] +name = "roc_gen_llvm" +version = "0.1.0" +dependencies = [ + "bumpalo", + "either", + "im 14.3.0", + "im-rc 14.3.0", + "indoc 0.3.6", + "inkwell 0.1.0", + "inlinable_string", + "libc", + "maplit", + "pretty_assertions 0.5.1", + "quickcheck 0.8.5", + "quickcheck_macros 0.8.0", + "roc_build", + "roc_builtins", + "roc_can", + "roc_collections", + "roc_load", + "roc_module", + "roc_mono", + "roc_parse", + "roc_problem", + "roc_region", + "roc_reporting", + "roc_solve", + "roc_std", + "roc_types", + "roc_unify", + "target-lexicon", + "tokio", +] + [[package]] name = "roc_load" version = "0.1.0" @@ -3910,7 +3910,7 @@ dependencies = [ "roc_can", "roc_collections", "roc_constrain", - "roc_gen", + "roc_gen_llvm", "roc_load", "roc_module", "roc_mono", diff --git a/Cargo.toml b/Cargo.toml index 84016c05b1..40cc3a5e32 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -17,7 +17,7 @@ members = [ "compiler/test_mono_macros", "compiler/test_mono", "compiler/load", - "compiler/gen", + "compiler/gen_llvm", "compiler/gen_dev", "compiler/build", "compiler/arena_pool", diff --git a/cli/Cargo.toml b/cli/Cargo.toml index 0f1c5a8ccb..4e95a3398a 100644 --- a/cli/Cargo.toml +++ b/cli/Cargo.toml @@ -19,7 +19,7 @@ default = ["target-x86", "llvm", "editor"] # This is a separate feature because when we generate docs on Netlify, # it doesn't have LLVM installed. (Also, it doesn't need to do code gen.) -llvm = ["inkwell", "roc_gen", "roc_build/llvm"] +llvm = ["inkwell", "roc_gen_llvm", "roc_build/llvm"] editor = ["roc_editor"] target-x86 = [] @@ -50,7 +50,7 @@ roc_unify = { path = "../compiler/unify" } roc_solve = { path = "../compiler/solve" } roc_mono = { path = "../compiler/mono" } roc_load = { path = "../compiler/load" } -roc_gen = { path = "../compiler/gen", optional = true } +roc_gen_llvm = { path = "../compiler/gen_llvm", optional = true } roc_build = { path = "../compiler/build", default-features = false } roc_fmt = { path = "../compiler/fmt" } roc_reporting = { path = "../compiler/reporting" } diff --git a/cli/src/repl/eval.rs b/cli/src/repl/eval.rs index 34ed34df94..89fd30e74f 100644 --- a/cli/src/repl/eval.rs +++ b/cli/src/repl/eval.rs @@ -2,7 +2,7 @@ use bumpalo::collections::Vec; use bumpalo::Bump; use libloading::Library; use roc_collections::all::MutMap; -use roc_gen::{run_jit_function, run_jit_function_dynamic_type}; +use roc_gen_llvm::{run_jit_function, run_jit_function_dynamic_type}; use roc_module::ident::{Lowercase, TagName}; use roc_module::operator::CalledVia; use roc_module::symbol::{Interns, ModuleId, Symbol}; diff --git a/cli/src/repl/gen.rs b/cli/src/repl/gen.rs index b9bb9a2799..e6d699a683 100644 --- a/cli/src/repl/gen.rs +++ b/cli/src/repl/gen.rs @@ -8,7 +8,7 @@ use roc_can::builtins::builtin_defs_map; use roc_collections::all::{MutMap, MutSet}; use roc_fmt::annotation::Formattable; use roc_fmt::annotation::{Newlines, Parens}; -use roc_gen::llvm::externs::add_default_roc_externs; +use roc_gen_llvm::llvm::externs::add_default_roc_externs; use roc_load::file::LoadingProblem; use roc_mono::ir::OptLevel; use roc_parse::parser::SyntaxError; @@ -130,7 +130,9 @@ pub fn gen_and_eval<'a>( let context = Context::create(); let builder = context.create_builder(); let ptr_bytes = target.pointer_width().unwrap().bytes() as u32; - let module = arena.alloc(roc_gen::llvm::build::module_from_builtins(&context, "")); + let module = arena.alloc(roc_gen_llvm::llvm::build::module_from_builtins( + &context, "", + )); // Add roc_alloc, roc_realloc, and roc_dealloc, since the repl has no // platform to provide them. @@ -166,12 +168,12 @@ pub fn gen_and_eval<'a>( let module = arena.alloc(module); let (module_pass, function_pass) = - roc_gen::llvm::build::construct_optimization_passes(module, opt_level); + roc_gen_llvm::llvm::build::construct_optimization_passes(module, opt_level); - let (dibuilder, compile_unit) = roc_gen::llvm::build::Env::new_debug_info(module); + let (dibuilder, compile_unit) = roc_gen_llvm::llvm::build::Env::new_debug_info(module); // Compile and add all the Procs before adding main - let env = roc_gen::llvm::build::Env { + let env = roc_gen_llvm::llvm::build::Env { arena: &arena, builder: &builder, dibuilder: &dibuilder, @@ -185,7 +187,7 @@ pub fn gen_and_eval<'a>( exposed_to_host: MutSet::default(), }; - let (main_fn_name, main_fn) = roc_gen::llvm::build::build_procedures_return_main( + let (main_fn_name, main_fn) = roc_gen_llvm::llvm::build::build_procedures_return_main( &env, opt_level, procedures, diff --git a/cli/tests/repl_eval.rs b/cli/tests/repl_eval.rs index 77e84b10e2..87d53837a8 100644 --- a/cli/tests/repl_eval.rs +++ b/cli/tests/repl_eval.rs @@ -7,7 +7,7 @@ extern crate indoc; #[cfg(test)] mod repl_eval { use cli_utils::helpers; - use roc_gen::run_roc::RocCallResult; + use roc_gen_llvm::run_roc::RocCallResult; #[test] fn check_discriminant_size() { @@ -16,7 +16,8 @@ mod repl_eval { let value: i64 = 1234; assert_eq!( std::mem::size_of_val(&RocCallResult::Success(value)), - roc_gen::run_roc::ROC_CALL_RESULT_DISCRIMINANT_SIZE + std::mem::size_of_val(&value) + roc_gen_llvm::run_roc::ROC_CALL_RESULT_DISCRIMINANT_SIZE + + std::mem::size_of_val(&value) ) } diff --git a/compiler/build/Cargo.toml b/compiler/build/Cargo.toml index 11a5e9effb..77dcf1d8a6 100644 --- a/compiler/build/Cargo.toml +++ b/compiler/build/Cargo.toml @@ -19,7 +19,7 @@ roc_unify = { path = "../unify" } roc_solve = { path = "../solve" } roc_mono = { path = "../mono" } roc_load = { path = "../load" } -roc_gen = { path = "../gen", optional = true } +roc_gen_llvm = { path = "../gen_llvm", optional = true } roc_reporting = { path = "../reporting" } im = "14" # im and im-rc should always have the same version! im-rc = "14" # im and im-rc should always have the same version! @@ -45,4 +45,4 @@ target-aarch64 = [] target-webassembly = [] # This is a separate feature because when we generate docs on Netlify, # it doesn't have LLVM installed. (Also, it doesn't need to do code gen.) -llvm = ["inkwell", "roc_gen"] +llvm = ["inkwell", "roc_gen_llvm"] diff --git a/compiler/build/src/program.rs b/compiler/build/src/program.rs index 5d3b7a984a..28be0802f5 100644 --- a/compiler/build/src/program.rs +++ b/compiler/build/src/program.rs @@ -1,7 +1,7 @@ #[cfg(feature = "llvm")] -use roc_gen::llvm::build::module_from_builtins; +use roc_gen_llvm::llvm::build::module_from_builtins; #[cfg(feature = "llvm")] -pub use roc_gen::llvm::build::FunctionIterator; +pub use roc_gen_llvm::llvm::build::FunctionIterator; #[cfg(feature = "llvm")] use roc_load::file::MonomorphizedModule; #[cfg(feature = "llvm")] @@ -125,12 +125,12 @@ pub fn gen_from_mono_module( } let builder = context.create_builder(); - let (dibuilder, compile_unit) = roc_gen::llvm::build::Env::new_debug_info(module); - let (mpm, _fpm) = roc_gen::llvm::build::construct_optimization_passes(module, opt_level); + let (dibuilder, compile_unit) = roc_gen_llvm::llvm::build::Env::new_debug_info(module); + let (mpm, _fpm) = roc_gen_llvm::llvm::build::construct_optimization_passes(module, opt_level); // Compile and add all the Procs before adding main let ptr_bytes = target.pointer_width().unwrap().bytes() as u32; - let env = roc_gen::llvm::build::Env { + let env = roc_gen_llvm::llvm::build::Env { arena: &arena, builder: &builder, dibuilder: &dibuilder, @@ -143,7 +143,7 @@ pub fn gen_from_mono_module( exposed_to_host: loaded.exposed_to_host.keys().copied().collect(), }; - roc_gen::llvm::build::build_procedures(&env, opt_level, loaded.procedures); + roc_gen_llvm::llvm::build::build_procedures(&env, opt_level, loaded.procedures); env.dibuilder.finalize(); diff --git a/compiler/gen/Cargo.toml b/compiler/gen_llvm/Cargo.toml similarity index 98% rename from compiler/gen/Cargo.toml rename to compiler/gen_llvm/Cargo.toml index 685b00fa3a..270c8e9cc8 100644 --- a/compiler/gen/Cargo.toml +++ b/compiler/gen_llvm/Cargo.toml @@ -1,5 +1,5 @@ [package] -name = "roc_gen" +name = "roc_gen_llvm" version = "0.1.0" authors = ["The Roc Contributors"] license = "UPL-1.0" diff --git a/compiler/gen/src/lib.rs b/compiler/gen_llvm/src/lib.rs similarity index 100% rename from compiler/gen/src/lib.rs rename to compiler/gen_llvm/src/lib.rs diff --git a/compiler/gen/src/llvm/bitcode.rs b/compiler/gen_llvm/src/llvm/bitcode.rs similarity index 100% rename from compiler/gen/src/llvm/bitcode.rs rename to compiler/gen_llvm/src/llvm/bitcode.rs diff --git a/compiler/gen/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs similarity index 100% rename from compiler/gen/src/llvm/build.rs rename to compiler/gen_llvm/src/llvm/build.rs diff --git a/compiler/gen/src/llvm/build_dict.rs b/compiler/gen_llvm/src/llvm/build_dict.rs similarity index 100% rename from compiler/gen/src/llvm/build_dict.rs rename to compiler/gen_llvm/src/llvm/build_dict.rs diff --git a/compiler/gen/src/llvm/build_hash.rs b/compiler/gen_llvm/src/llvm/build_hash.rs similarity index 100% rename from compiler/gen/src/llvm/build_hash.rs rename to compiler/gen_llvm/src/llvm/build_hash.rs diff --git a/compiler/gen/src/llvm/build_list.rs b/compiler/gen_llvm/src/llvm/build_list.rs similarity index 100% rename from compiler/gen/src/llvm/build_list.rs rename to compiler/gen_llvm/src/llvm/build_list.rs diff --git a/compiler/gen/src/llvm/build_str.rs b/compiler/gen_llvm/src/llvm/build_str.rs similarity index 100% rename from compiler/gen/src/llvm/build_str.rs rename to compiler/gen_llvm/src/llvm/build_str.rs diff --git a/compiler/gen/src/llvm/compare.rs b/compiler/gen_llvm/src/llvm/compare.rs similarity index 100% rename from compiler/gen/src/llvm/compare.rs rename to compiler/gen_llvm/src/llvm/compare.rs diff --git a/compiler/gen/src/llvm/convert.rs b/compiler/gen_llvm/src/llvm/convert.rs similarity index 100% rename from compiler/gen/src/llvm/convert.rs rename to compiler/gen_llvm/src/llvm/convert.rs diff --git a/compiler/gen/src/llvm/externs.rs b/compiler/gen_llvm/src/llvm/externs.rs similarity index 100% rename from compiler/gen/src/llvm/externs.rs rename to compiler/gen_llvm/src/llvm/externs.rs diff --git a/compiler/gen/src/llvm/mod.rs b/compiler/gen_llvm/src/llvm/mod.rs similarity index 100% rename from compiler/gen/src/llvm/mod.rs rename to compiler/gen_llvm/src/llvm/mod.rs diff --git a/compiler/gen/src/llvm/refcounting.rs b/compiler/gen_llvm/src/llvm/refcounting.rs similarity index 100% rename from compiler/gen/src/llvm/refcounting.rs rename to compiler/gen_llvm/src/llvm/refcounting.rs diff --git a/compiler/gen/src/run_roc.rs b/compiler/gen_llvm/src/run_roc.rs similarity index 95% rename from compiler/gen/src/run_roc.rs rename to compiler/gen_llvm/src/run_roc.rs index 1e1c28b9b2..884ef41fcc 100644 --- a/compiler/gen/src/run_roc.rs +++ b/compiler/gen_llvm/src/run_roc.rs @@ -38,7 +38,7 @@ macro_rules! run_jit_function { ($lib: expr, $main_fn_name: expr, $ty:ty, $transform:expr, $errors:expr) => {{ use inkwell::context::Context; - use roc_gen::run_roc::RocCallResult; + use roc_gen_llvm::run_roc::RocCallResult; use std::mem::MaybeUninit; unsafe { @@ -77,7 +77,7 @@ macro_rules! run_jit_function_dynamic_type { ($lib: expr, $main_fn_name: expr, $bytes:expr, $transform:expr, $errors:expr) => {{ use inkwell::context::Context; - use roc_gen::run_roc::RocCallResult; + use roc_gen_llvm::run_roc::RocCallResult; unsafe { let main: libloading::Symbol = $lib @@ -86,7 +86,7 @@ macro_rules! run_jit_function_dynamic_type { .ok_or(format!("Unable to JIT compile `{}`", $main_fn_name)) .expect("errored"); - let size = roc_gen::run_roc::ROC_CALL_RESULT_DISCRIMINANT_SIZE + $bytes; + let size = roc_gen_llvm::run_roc::ROC_CALL_RESULT_DISCRIMINANT_SIZE + $bytes; let layout = std::alloc::Layout::array::(size).unwrap(); let result = std::alloc::alloc(layout); main(result); diff --git a/compiler/test_gen/Cargo.toml b/compiler/test_gen/Cargo.toml index 7300d3ee57..c34a5c2a17 100644 --- a/compiler/test_gen/Cargo.toml +++ b/compiler/test_gen/Cargo.toml @@ -6,7 +6,7 @@ license = "UPL-1.0" edition = "2018" [dependencies] -roc_gen = { path = "../gen" } +roc_gen_llvm = { path = "../gen_llvm" } roc_collections = { path = "../collections" } roc_region = { path = "../region" } roc_module = { path = "../module" } diff --git a/compiler/test_gen/src/helpers/eval.rs b/compiler/test_gen/src/helpers/eval.rs index e8511b2586..91324d7dae 100644 --- a/compiler/test_gen/src/helpers/eval.rs +++ b/compiler/test_gen/src/helpers/eval.rs @@ -4,7 +4,7 @@ use roc_build::program::FunctionIterator; use roc_can::builtins::builtin_defs_map; use roc_can::def::Def; use roc_collections::all::{MutMap, MutSet}; -use roc_gen::llvm::externs::add_default_roc_externs; +use roc_gen_llvm::llvm::externs::add_default_roc_externs; use roc_module::symbol::Symbol; use roc_mono::ir::OptLevel; use roc_types::subs::VarStore; @@ -181,7 +181,7 @@ pub fn helper<'a>( }; let builder = context.create_builder(); - let module = roc_gen::llvm::build::module_from_builtins(context, "app"); + let module = roc_gen_llvm::llvm::build::module_from_builtins(context, "app"); // Add roc_alloc, roc_realloc, and roc_dealloc, since the repl has no // platform to provide them. @@ -198,9 +198,9 @@ pub fn helper<'a>( let module = arena.alloc(module); let (module_pass, function_pass) = - roc_gen::llvm::build::construct_optimization_passes(module, opt_level); + roc_gen_llvm::llvm::build::construct_optimization_passes(module, opt_level); - let (dibuilder, compile_unit) = roc_gen::llvm::build::Env::new_debug_info(module); + let (dibuilder, compile_unit) = roc_gen_llvm::llvm::build::Env::new_debug_info(module); // mark our zig-defined builtins as internal use inkwell::attributes::{Attribute, AttributeLoc}; @@ -222,7 +222,7 @@ pub fn helper<'a>( } // Compile and add all the Procs before adding main - let env = roc_gen::llvm::build::Env { + let env = roc_gen_llvm::llvm::build::Env { arena: &arena, builder: &builder, dibuilder: &dibuilder, @@ -236,7 +236,7 @@ pub fn helper<'a>( exposed_to_host: MutSet::default(), }; - let (main_fn_name, main_fn) = roc_gen::llvm::build::build_procedures_return_main( + let (main_fn_name, main_fn) = roc_gen_llvm::llvm::build::build_procedures_return_main( &env, opt_level, procedures, @@ -276,7 +276,7 @@ macro_rules! assert_llvm_evals_to { ($src:expr, $expected:expr, $ty:ty, $transform:expr, $leak:expr, $ignore_problems:expr) => { use bumpalo::Bump; use inkwell::context::Context; - use roc_gen::run_jit_function; + use roc_gen_llvm::run_jit_function; let arena = Bump::new(); let context = Context::create(); From 811ecd86363dc46c0de3029c2703b4c5247a424b Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sun, 6 Jun 2021 07:53:48 -0400 Subject: [PATCH 150/496] Add descriptions to gen_dev and gen_llvm --- compiler/gen_dev/Cargo.toml | 1 + compiler/gen_llvm/Cargo.toml | 1 + 2 files changed, 2 insertions(+) diff --git a/compiler/gen_dev/Cargo.toml b/compiler/gen_dev/Cargo.toml index b960c7468e..8fb6646e26 100644 --- a/compiler/gen_dev/Cargo.toml +++ b/compiler/gen_dev/Cargo.toml @@ -1,5 +1,6 @@ [package] name = "roc_gen_dev" +description = "The development backend for the Roc compiler" version = "0.1.0" authors = ["The Roc Contributors"] license = "UPL-1.0" diff --git a/compiler/gen_llvm/Cargo.toml b/compiler/gen_llvm/Cargo.toml index 270c8e9cc8..ab07ce48e8 100644 --- a/compiler/gen_llvm/Cargo.toml +++ b/compiler/gen_llvm/Cargo.toml @@ -1,5 +1,6 @@ [package] name = "roc_gen_llvm" +description = "The LLVM backend for the Roc compiler" version = "0.1.0" authors = ["The Roc Contributors"] license = "UPL-1.0" From 18be90649e5e76e2259924c6d0c594a244583611 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sun, 6 Jun 2021 09:59:46 -0400 Subject: [PATCH 151/496] Don't link to .html files anymore We now generate index.html files, so the .html suffix is no longer needed! --- docs/src/lib.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/docs/src/lib.rs b/docs/src/lib.rs index d4de9c25d2..a7db7eb73e 100644 --- a/docs/src/lib.rs +++ b/docs/src/lib.rs @@ -229,7 +229,6 @@ fn render_sidebar<'a, I: Iterator>(modules: I) - let href = { let mut href_buf = String::new(); href_buf.push_str(name); - href_buf.push_str(".html"); href_buf }; @@ -568,7 +567,7 @@ fn make_doc_link(scope: &mut Scope, interns: &Interns, doc_item: &str) -> String let mut link = String::new(); link.push_str(module_str); - link.push_str(".html#"); + link.push_str("#"); link.push_str(ident_str); let mut buf = String::new(); From 53da2a2d14e149d347cc09b61761405a873fd65f Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sun, 6 Jun 2021 10:10:51 -0400 Subject: [PATCH 152/496] clippy --- docs/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/src/lib.rs b/docs/src/lib.rs index a7db7eb73e..97ef19bba1 100644 --- a/docs/src/lib.rs +++ b/docs/src/lib.rs @@ -567,7 +567,7 @@ fn make_doc_link(scope: &mut Scope, interns: &Interns, doc_item: &str) -> String let mut link = String::new(); link.push_str(module_str); - link.push_str("#"); + link.push('#'); link.push_str(ident_str); let mut buf = String::new(); From 8dc3146a7d18c1ace85efa0193c79638efba18e0 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 6 Jun 2021 20:22:50 +0200 Subject: [PATCH 153/496] update morphic --- vendor/morphic_lib/src/api.rs | 87 ++-- vendor/morphic_lib/src/bindings.rs | 2 + vendor/morphic_lib/src/lib.rs | 1 + vendor/morphic_lib/src/render_api_ir.rs | 550 ++++++++++++++++++++++++ 4 files changed, 604 insertions(+), 36 deletions(-) create mode 100644 vendor/morphic_lib/src/render_api_ir.rs diff --git a/vendor/morphic_lib/src/api.rs b/vendor/morphic_lib/src/api.rs index e94e5660e1..d220904f97 100644 --- a/vendor/morphic_lib/src/api.rs +++ b/vendor/morphic_lib/src/api.rs @@ -1,7 +1,8 @@ use sha2::{digest::Digest, Sha256}; use smallvec::SmallVec; -use std::collections::{btree_map::Entry, BTreeMap, BTreeSet}; +use std::collections::{btree_map::Entry, BTreeMap}; +use crate::render_api_ir; use crate::util::blocks::Blocks; use crate::util::id_bi_map::IdBiMap; use crate::util::id_type::Count; @@ -554,11 +555,14 @@ pub(crate) enum TypeOp { } /// A `TypeDef` defines the content type of a named type. -pub struct TypeDef; +pub struct TypeDef { + pub(crate) builder: TypeBuilder, + pub(crate) root: TypeId, +} #[derive(Clone, Debug)] -struct TypeBuilder { - types: OpGraph, +pub(crate) struct TypeBuilder { + pub(crate) types: OpGraph, } impl Default for TypeBuilder { @@ -637,7 +641,10 @@ impl TypeDefBuilder { /// Create a `TypeDef` using the given type node as the root. pub fn build(self, root: TypeId) -> Result { self.inner.check(root)?; - Ok(TypeDef) + Ok(TypeDef { + builder: self.inner, + root, + }) } } @@ -743,27 +750,27 @@ pub(crate) enum Op { } #[derive(Clone, Copy, Debug)] -struct ContinuationInfo { - arg_type: TypeId, - ret_type: TypeId, - arg: ValueId, - body: Option, +pub(crate) struct ContinuationInfo { + pub(crate) arg_type: TypeId, + pub(crate) ret_type: TypeId, + pub(crate) arg: ValueId, + pub(crate) body: Option, } #[derive(Clone, Copy, Debug)] -enum BlockState { +pub(crate) enum BlockState { Detached, Attached, } #[derive(Clone, Debug)] -struct ExprBuilder { - type_builder: TypeBuilder, - blocks: Blocks, - vals: OpGraph, - continuations: IdVec, - callee_spec_vars: IdBiMap, - update_mode_vars: IdBiMap, +pub(crate) struct ExprBuilder { + pub(crate) type_builder: TypeBuilder, + pub(crate) blocks: Blocks, + pub(crate) vals: OpGraph, + pub(crate) continuations: IdVec, + pub(crate) callee_spec_vars: IdBiMap, + pub(crate) update_mode_vars: IdBiMap, } impl Default for ExprBuilder { @@ -1134,15 +1141,15 @@ impl ExprContext for ExprBuilder { /// A `FuncDef` defines the signature and body of a function. pub struct FuncDef { - builder: FuncDefBuilder, - arg_type: TypeId, - ret_type: TypeId, - root: BlockExpr, + pub(crate) builder: FuncDefBuilder, + pub(crate) arg_type: TypeId, + pub(crate) ret_type: TypeId, + pub(crate) root: BlockExpr, } pub struct FuncDefBuilder { - expr_builder: ExprBuilder, - argument: ValueId, + pub(crate) expr_builder: ExprBuilder, + pub(crate) argument: ValueId, } impl Default for FuncDefBuilder { @@ -1187,13 +1194,13 @@ impl FuncDefBuilder { /// A `ConstDef` defines the type and initializer expression for a global constant. pub struct ConstDef { - builder: ConstDefBuilder, - type_: TypeId, - root: BlockExpr, + pub(crate) builder: ConstDefBuilder, + pub(crate) type_: TypeId, + pub(crate) root: BlockExpr, } pub struct ConstDefBuilder { - expr_builder: ExprBuilder, + pub(crate) expr_builder: ExprBuilder, } impl Default for ConstDefBuilder { @@ -1225,12 +1232,13 @@ impl ConstDefBuilder { /// A `ModDef` defines a module, which is a collection of named types, functions, and constants. pub struct ModDef { - func_defs: BTreeMap, - const_defs: BTreeMap, + pub(crate) type_defs: BTreeMap, + pub(crate) func_defs: BTreeMap, + pub(crate) const_defs: BTreeMap, } pub struct ModDefBuilder { - type_names: BTreeSet, + type_defs: BTreeMap, func_defs: BTreeMap, const_defs: BTreeMap, } @@ -1244,7 +1252,7 @@ impl Default for ModDefBuilder { impl ModDefBuilder { pub fn new() -> Self { Self { - type_names: BTreeSet::new(), + type_defs: BTreeMap::new(), func_defs: BTreeMap::new(), const_defs: BTreeMap::new(), } @@ -1252,13 +1260,14 @@ impl ModDefBuilder { pub fn build(self) -> Result { Ok(ModDef { + type_defs: self.type_defs, func_defs: self.func_defs, const_defs: self.const_defs, }) } - pub fn add_named_type(&mut self, name: TypeName, _type_def: TypeDef) -> Result<()> { - if !self.type_names.insert(name.into()) { + pub fn add_named_type(&mut self, name: TypeName, type_def: TypeDef) -> Result<()> { + if self.type_defs.insert(name.into(), type_def).is_some() { return Err(ErrorKind::DuplicateTypeName(name.into()).into()); } Ok(()) @@ -1284,8 +1293,14 @@ impl ModDefBuilder { /// /// Each entry point has an associated main function, which must have signature `() -> ()`. pub struct Program { - mods: BTreeMap, - entry_points: BTreeMap, + pub(crate) mods: BTreeMap, + pub(crate) entry_points: BTreeMap, +} + +impl Program { + pub fn to_source_string(&self) -> String { + render_api_ir::render_program_to_string(self) + } } pub struct ProgramBuilder { diff --git a/vendor/morphic_lib/src/bindings.rs b/vendor/morphic_lib/src/bindings.rs index 72ce812cf8..c5dbb413a1 100644 --- a/vendor/morphic_lib/src/bindings.rs +++ b/vendor/morphic_lib/src/bindings.rs @@ -1,6 +1,8 @@ // TODO: These bindings are incomplete // TODO: Add test for compatibility with `include/morphic.h` +#![allow(clippy::boxed_local)] + use crate::api::*; use std::{ffi::CString, os::raw::c_char, ptr, slice}; diff --git a/vendor/morphic_lib/src/lib.rs b/vendor/morphic_lib/src/lib.rs index 3a49195dbe..89da624e4a 100644 --- a/vendor/morphic_lib/src/lib.rs +++ b/vendor/morphic_lib/src/lib.rs @@ -5,5 +5,6 @@ mod util; mod api; mod bindings; +mod render_api_ir; pub use api::*; diff --git a/vendor/morphic_lib/src/render_api_ir.rs b/vendor/morphic_lib/src/render_api_ir.rs new file mode 100644 index 0000000000..dadbec892d --- /dev/null +++ b/vendor/morphic_lib/src/render_api_ir.rs @@ -0,0 +1,550 @@ +use std::fmt::{Display, Formatter, Write}; + +use crate::api::{ + BlockExpr, CalleeSpecBuf, ConstDef, ConstNameBuf, ContinuationId, EntryPointNameBuf, + ExprBuilder, FuncDef, FuncNameBuf, ModDef, ModNameBuf, Op, Program, TypeDef, TypeId, + TypeNameBuf, TypeOp, UpdateModeBuf, ValueId, +}; +use crate::util::id_type::Id; +use crate::util::op_graph::{Node, OpGraph}; + +#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord)] +struct RenderContext { + content: String, + spaces_per_level: usize, + indent_level: usize, + pending_indent: bool, +} + +impl RenderContext { + fn new(spaces_per_level: usize) -> RenderContext { + RenderContext { + content: String::new(), + spaces_per_level, + indent_level: 0, + pending_indent: true, + } + } + + fn with_indent(&mut self, body: impl for<'a> FnOnce(&'a mut RenderContext) -> R) -> R { + self.indent_level += 1; + let result = body(self); + self.indent_level -= 1; + result + } + + fn write(&mut self, to_write: impl std::fmt::Display) { + if self.pending_indent { + self.content + .extend((0..self.indent_level * self.spaces_per_level).map(|_| ' ')); + self.pending_indent = false; + } + write!(&mut self.content, "{}", to_write).expect("writing to string failed"); + } + + fn writeln(&mut self, to_write: impl std::fmt::Display) { + self.write(to_write); + self.content.push('\n'); + self.pending_indent = true; + } + + fn finish(self) -> String { + self.content + } +} + +#[derive(Clone, Copy, Debug)] +struct Ident { + prefix: &'static str, + id: usize, +} + +impl Display for Ident { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}_{}", self.prefix, self.id) + } +} + +fn val_ident(value: ValueId) -> Ident { + Ident { + prefix: "val", + id: value.to_index(), + } +} + +fn type_ident(type_: TypeId) -> Ident { + Ident { + prefix: "type", + id: type_.to_index(), + } +} + +fn continuation_ident(continuation: ContinuationId) -> Ident { + Ident { + prefix: "cont", + id: continuation.to_index(), + } +} + +#[derive(Clone, Copy, Debug)] +struct ByteString<'a>(&'a [u8]); + +impl<'a> Display for ByteString<'a> { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "\"")?; + for &byte in self.0 { + write!(f, "{}", std::ascii::escape_default(byte))?; + } + write!(f, "\"")?; + Ok(()) + } +} + +fn update_mode_string(buf: &UpdateModeBuf) -> ByteString { + ByteString(&buf.0) +} + +fn callee_spec_string(buf: &CalleeSpecBuf) -> ByteString { + ByteString(&buf.0) +} + +fn mod_name_string(mod_name: &ModNameBuf) -> ByteString { + ByteString(&mod_name.0) +} + +fn func_name_string(func_name: &FuncNameBuf) -> ByteString { + ByteString(&func_name.0) +} + +fn type_name_string(type_name: &TypeNameBuf) -> ByteString { + ByteString(&type_name.0) +} + +fn const_name_string(const_name: &ConstNameBuf) -> ByteString { + ByteString(&const_name.0) +} + +fn entry_point_name_string(entry_point: &EntryPointNameBuf) -> ByteString { + ByteString(&entry_point.0) +} + +fn delimit( + ctx: &mut RenderContext, + items: impl Iterator, + mut render_delim: impl for<'a> FnMut(&'a mut RenderContext), + mut render_item: impl for<'a> FnMut(&'a mut RenderContext, T), +) { + for (i, item) in items.enumerate() { + if i != 0 { + render_delim(ctx); + } + render_item(ctx, item); + } +} + +fn render_op(builder: &ExprBuilder, ctx: &mut RenderContext, op: &Op) { + match op { + Op::Arg | Op::ContinuationArg | Op::DeclareContinuation { .. } => { + ctx.write(format_args!( + "/* internal error: {:?} should not be rendered as a value */", + op + )); + } + + Op::Jump { + continuation, + unreachable_result_type, + } => { + ctx.write(format_args!( + "jump<{}> {}", + type_ident(*unreachable_result_type), + continuation_ident(*continuation), + )); + } + + Op::UnknownWith { result_type } => { + ctx.write(format_args!("unknown_with<{}>", type_ident(*result_type))); + } + + Op::Call { + callee_spec_var, + callee_mod, + callee, + } => { + ctx.write(format_args!( + "call[{}] {}::{}", + callee_spec_string(&builder.callee_spec_vars[callee_spec_var]), + mod_name_string(callee_mod), + func_name_string(callee), + )); + } + + Op::ConstRef { const_mod, const_ } => { + ctx.write(format_args!( + "const_ref {}::{}", + mod_name_string(const_mod), + const_name_string(const_), + )); + } + + Op::Choice { cases } => { + ctx.writeln("choice {"); + ctx.with_indent(|ctx| { + for &case in cases { + ctx.write("case "); + render_block_expr(builder, ctx, case); + ctx.writeln(","); + } + }); + ctx.write("}"); + } + + Op::SubBlock { sub_block } => { + render_block_expr(builder, ctx, *sub_block); + } + + Op::Terminate { + unreachable_result_type, + } => { + ctx.write(format_args!( + "terminate<{}>", + type_ident(*unreachable_result_type), + )); + } + + Op::NewHeapCell => { + ctx.write("new_heap_cell"); + } + + Op::Touch => { + ctx.write("touch"); + } + + Op::RecursiveTouch => { + ctx.write("recursive_touch"); + } + + Op::UpdateWriteOnly { update_mode_var } => { + ctx.write(format_args!( + "update_write_only[{}]", + update_mode_string(&builder.update_mode_vars[update_mode_var]), + )); + } + + Op::EmptyBag { item_type } => { + ctx.write(format_args!("empty_bag<{}>", type_ident(*item_type))); + } + + Op::BagInsert => { + ctx.write("bag_insert"); + } + + Op::BagGet => { + ctx.write("bag_get"); + } + + Op::BagRemove => { + ctx.write("bag_remove"); + } + + Op::MakeTuple => { + ctx.write("make_tuple"); + } + + Op::GetTupleField { field_idx } => { + ctx.write(format_args!("get_tuple_field {}", field_idx)); + } + + Op::MakeUnion { + variant_types, + variant_idx, + } => { + ctx.write("make_union<"); + delimit( + ctx, + variant_types.iter(), + |ctx| { + ctx.write(", "); + }, + |ctx, variant_type| { + ctx.write(type_ident(*variant_type)); + }, + ); + ctx.write(format_args!("> {}", variant_idx)); + } + + Op::UnwrapUnion { variant_idx } => { + ctx.write(format_args!("unwrap_union {}", variant_idx)); + } + + Op::MakeNamed { named_mod, named } => { + ctx.write(format_args!( + "make_named {}::{}", + mod_name_string(named_mod), + type_name_string(named), + )); + } + + Op::UnwrapNamed { named_mod, named } => { + ctx.write(format_args!( + "unwrap_named {}::{}", + mod_name_string(named_mod), + type_name_string(named), + )); + } + }; +} + +fn render_statement(builder: &ExprBuilder, ctx: &mut RenderContext, value_id: ValueId) { + match builder.vals.node(value_id) { + Node { + op: Op::DeclareContinuation { continuation }, + inputs: [], + } => { + render_continuation_def(builder, ctx, *continuation); + } + + Node { op, inputs } => { + ctx.write(format_args!("let {} = ", val_ident(value_id))); + render_op(builder, ctx, op); + ctx.write(" ("); + delimit( + ctx, + inputs.iter(), + |ctx| { + ctx.write(", "); + }, + |ctx, input| { + ctx.write(val_ident(*input)); + }, + ); + ctx.writeln(");"); + } + } +} + +fn render_continuation_def( + builder: &ExprBuilder, + ctx: &mut RenderContext, + continuation: ContinuationId, +) { + let info = builder.continuations[continuation]; + ctx.write(format_args!( + "continuation {} ({}: {}) -> {} ", + continuation_ident(continuation), + val_ident(info.arg), + type_ident(info.arg_type), + type_ident(info.ret_type), + )); + render_block_expr( + builder, + ctx, + info.body + .expect("builder API should have verified that continuation body is defined"), + ); + ctx.writeln(""); +} + +fn render_block_expr(builder: &ExprBuilder, ctx: &mut RenderContext, block_expr: BlockExpr) { + let BlockExpr(block, ret_val) = block_expr; + ctx.writeln("{"); + ctx.with_indent(|ctx| { + for value in builder.blocks.block_values(block) { + render_statement(builder, ctx, value); + } + ctx.writeln(val_ident(ret_val)) + }); + ctx.write("}"); +} + +fn render_type_node(ctx: &mut RenderContext, node: Node) { + match node { + Node { + op: TypeOp::Named { named_mod, named }, + inputs, + } => { + debug_assert!(inputs.is_empty()); + ctx.write(format_args!( + "{}::{}", + mod_name_string(named_mod), + type_name_string(named) + )); + } + + Node { + op: TypeOp::Tuple, + inputs, + } => { + ctx.write("("); + delimit( + ctx, + inputs.iter(), + |ctx| { + ctx.write(", "); + }, + |ctx, input| { + ctx.write(type_ident(*input)); + }, + ); + ctx.write(")"); + } + + Node { + op: TypeOp::Union, + inputs, + } => { + ctx.write("union { "); + delimit( + ctx, + inputs.iter(), + |ctx| { + ctx.write(", "); + }, + |ctx, input| { + ctx.write(type_ident(*input)); + }, + ); + if !inputs.is_empty() { + ctx.write(" "); + } + ctx.write("}"); + } + + Node { + op: TypeOp::HeapCell, + inputs, + } => { + debug_assert!(inputs.is_empty()); + ctx.write("heap_cell"); + } + + Node { + op: TypeOp::Bag, + inputs, + } => { + debug_assert_eq!(inputs.len(), 1); + ctx.write(format_args!("bag<{}>", type_ident(inputs[0]))); + } + } +} + +fn render_type_bindings(ctx: &mut RenderContext, types: &OpGraph) { + ctx.writeln("{"); + ctx.with_indent(|ctx| { + for type_id in types.count().iter() { + ctx.write(format_args!("type {} = ", type_ident(type_id))); + render_type_node(ctx, types.node(type_id)); + ctx.writeln(";"); + } + }); + ctx.write("}"); +} + +fn render_func_def(ctx: &mut RenderContext, name: &FuncNameBuf, func_def: &FuncDef) { + ctx.write(format_args!( + "fn {} ({}: {}) -> {} ", + func_name_string(name), + val_ident(func_def.builder.argument), + type_ident(func_def.arg_type), + type_ident(func_def.ret_type), + )); + render_block_expr(&func_def.builder.expr_builder, ctx, func_def.root); + ctx.write(" where "); + render_type_bindings(ctx, &func_def.builder.expr_builder.type_builder.types); + ctx.writeln(""); +} + +fn render_const_def(ctx: &mut RenderContext, name: &ConstNameBuf, const_def: &ConstDef) { + ctx.write(format_args!( + "const {}: {} = ", + const_name_string(name), + type_ident(const_def.type_), + )); + render_block_expr(&const_def.builder.expr_builder, ctx, const_def.root); + ctx.write(" where "); + render_type_bindings(ctx, &const_def.builder.expr_builder.type_builder.types); + ctx.writeln(""); +} + +fn render_type_def(ctx: &mut RenderContext, name: &TypeNameBuf, type_def: &TypeDef) { + ctx.write(format_args!( + "type {} = {} where ", + type_name_string(name), + type_ident(type_def.root), + )); + render_type_bindings(ctx, &type_def.builder.types); + ctx.writeln(""); +} + +fn render_mod_def(ctx: &mut RenderContext, name: &ModNameBuf, mod_def: &ModDef) { + ctx.writeln(format_args!("mod {} {{", mod_name_string(name))); + ctx.with_indent(|ctx| { + let mut first_item = true; + let mut write_spacing = |ctx: &mut RenderContext| { + if !first_item { + ctx.writeln(""); + } + first_item = false; + }; + + for (type_name, type_def) in &mod_def.type_defs { + write_spacing(ctx); + render_type_def(ctx, type_name, type_def); + } + + for (const_name, const_def) in &mod_def.const_defs { + write_spacing(ctx); + render_const_def(ctx, const_name, const_def); + } + + for (func_name, func_def) in &mod_def.func_defs { + write_spacing(ctx); + render_func_def(ctx, func_name, func_def); + } + }); + ctx.writeln("}"); +} + +fn render_entry_point( + ctx: &mut RenderContext, + name: &EntryPointNameBuf, + entry_point: &(ModNameBuf, FuncNameBuf), +) { + let (mod_, func) = entry_point; + ctx.writeln(format_args!( + "entry_point {} = {}::{};", + entry_point_name_string(name), + mod_name_string(mod_), + func_name_string(func) + )); +} + +fn render_program(ctx: &mut RenderContext, program: &Program) { + ctx.writeln("program {"); + ctx.with_indent(|ctx| { + let mut first_item = true; + let mut write_spacing = |ctx: &mut RenderContext| { + if !first_item { + ctx.writeln(""); + } + first_item = false; + }; + + for (mod_name, mod_def) in &program.mods { + write_spacing(ctx); + render_mod_def(ctx, mod_name, mod_def); + } + + for (entry_point_name, entry_point) in &program.entry_points { + write_spacing(ctx); + render_entry_point(ctx, entry_point_name, entry_point); + } + }); + ctx.write("}"); +} + +pub fn render_program_to_string(program: &Program) -> String { + let mut ctx = RenderContext::new(2); + render_program(&mut ctx, program); + ctx.finish() +} From 7b143f63292d1d90bf1536700b9b3acd7c53d9cf Mon Sep 17 00:00:00 2001 From: Jared Ramirez Date: Sun, 6 Jun 2021 14:27:15 -0700 Subject: [PATCH 154/496] Update Nix zig version & build from source instructions --- BUILDING_FROM_SOURCE.md | 13 +++++--- nix/zig-unstable.nix | 50 ---------------------------- nix/zig.nix | 72 ++++++++++++++++++++++++++--------------- shell.nix | 1 - 4 files changed, 55 insertions(+), 81 deletions(-) delete mode 100644 nix/zig-unstable.nix diff --git a/BUILDING_FROM_SOURCE.md b/BUILDING_FROM_SOURCE.md index d6640af464..d97a3fe396 100644 --- a/BUILDING_FROM_SOURCE.md +++ b/BUILDING_FROM_SOURCE.md @@ -40,11 +40,16 @@ sudo apt-get install libxcb-render0-dev libxcb-shape0-dev libxcb-xfixes0-dev ``` ### Zig -**version: 0.7.x** +**version: 0.8.0** -If you're on MacOS, you can install with `brew install zig` -If you're on Ubuntu and use Snap, you can install with `snap install zig --classic --beta` -For any other OS, checkout the [Zig installation page](https://github.com/ziglang/zig/wiki/Install-Zig-from-a-Package-Manager) +For any OS, you can use [`zigup`](https://github.com/marler8997/zigup) to manage zig installations. + +If you prefer a package manager, you can try the following: +- For MacOS, you can install with `brew install zig` +- For, Ubuntu, you can use Snap, you can install with `snap install zig --classic --beta` +- For other systems, checkout this [page](https://github.com/ziglang/zig/wiki/Install-Zig-from-a-Package-Manager) + +If you want to install it manually, you can also download Zig directly [here](https://ziglang.org/download/). Just make sure you download the right version, the bleeding edge master build is the first download link on this page. ### LLVM **version: 10.0.x** diff --git a/nix/zig-unstable.nix b/nix/zig-unstable.nix deleted file mode 100644 index dce910d0c4..0000000000 --- a/nix/zig-unstable.nix +++ /dev/null @@ -1,50 +0,0 @@ -{ pkgs }: - -let - # system helpers - splitSystem = builtins.split "-" builtins.currentSystem; - arch = builtins.elemAt splitSystem 0; - isAarch64 = arch == "aarch64"; - setForSystem = { darwin, darwinAarch64, linux, linuxAarch64 }: - if pkgs.stdenv.isDarwin - then ( - if isAarch64 - then darwinAarch64 - else darwin - ) - else ( - if isAarch64 - then linuxAarch64 - else linux - ); - - version = "0.8.0-dev.2711+11ae6c42c"; - osName = - if pkgs.stdenv.isDarwin - then "macos" else "linux"; - archiveName = "zig-${osName}-${arch}-${version}"; - sha256 = setForSystem { - darwin = "bf2a4cd1516d202cfbbcaa7b1308d36aa21a9f9284b39297e70f98c003f479e3"; - darwinAarch64 = "6bc35c3b40b853cd351c890c94c4a6043f5ca492ff6d704bdb1544fe1fe54d9a"; - linux = "b443cc2259fe7712ffc954745266e3ec846e27854713d817bcec35fefd655a8c"; - linuxAarch64 = "229830e6dc92f641a1106af3a8ee96fdef379ffd3a3d7db7ed62d2b46bd8ed45"; - }; -in -pkgs.stdenv.mkDerivation { - pname = "zig-unstable"; - version = version; - src = pkgs.fetchurl { - inherit sha256; - name = "${archiveName}.tar.xz"; - url = "https://ziglang.org/builds/${archiveName}.tar.xz"; - }; - phases = [ "unpackPhase" ]; - unpackPhase = '' - mkdir -p $out/bin - tar -xf $src - cp ${archiveName}/zig $out/zig - cp -r ${archiveName}/lib $out/lib - ln -s "$out/zig" "$out/bin/zig" - chmod +x $out/bin/zig - ''; -} diff --git a/nix/zig.nix b/nix/zig.nix index b431275b83..0f18ce1672 100644 --- a/nix/zig.nix +++ b/nix/zig.nix @@ -1,28 +1,48 @@ { pkgs }: -if pkgs.stdenv.isDarwin then - let - version = "0.7.1"; - archiveName = "zig-macos-x86_64-${version}"; - sha256 = "845cb17562978af0cf67e3993f4e33330525eaf01ead9386df9105111e3bc519"; - in - pkgs.stdenv.mkDerivation { - pname = "zig"; - version = version; - src = pkgs.fetchurl { - inherit sha256; - name = "${archiveName}.tar.xz"; - url = "https://ziglang.org/download/${version}/${archiveName}.tar.xz"; - }; - phases = [ "unpackPhase" ]; - unpackPhase = '' - mkdir -p $out/bin - tar -xf $src - cp ${archiveName}/zig $out/zig - cp -r ${archiveName}/lib $out/lib - ln -s "$out/zig" "$out/bin/zig" - chmod +x $out/bin/zig - ''; - } -else - pkgs.zig +let + version = "0.8.0"; + + osName = + if pkgs.stdenv.isDarwin then + "macos" + else + "linux"; + + splitSystem = builtins.split "-" builtins.currentSystem; + arch = builtins.elemAt splitSystem 0; + isAarch64 = arch == "aarch64"; + + archiveName = "zig-${osName}-${arch}-${version}"; + + # If you're system is not aarch64, we assume it's x86_64 + sha256 = + if pkgs.stdenv.isDarwin then + if isAarch64 then + "b32d13f66d0e1ff740b3326d66a469ee6baddbd7211fa111c066d3bd57683111" + else + "279f9360b5cb23103f0395dc4d3d0d30626e699b1b4be55e98fd985b62bc6fbe" + else + if isAarch64 then + "ee204ca2c2037952cf3f8b10c609373a08a291efa4af7b3c73be0f2b27720470" + else + "502625d3da3ae595c5f44a809a87714320b7a40e6dff4a895b5fa7df3391d01e"; +in +pkgs.stdenv.mkDerivation { + pname = "zig"; + version = version; + src = pkgs.fetchurl { + inherit sha256; + name = "${archiveName}.tar.xz"; + url = "https://ziglang.org/download/${version}/${archiveName}.tar.xz"; + }; + phases = [ "unpackPhase" ]; + unpackPhase = '' + mkdir -p $out/bin + tar -xf $src + cp ${archiveName}/zig $out/zig + cp -r ${archiveName}/lib $out/lib + ln -s "$out/zig" "$out/bin/zig" + chmod +x $out/bin/zig + ''; +} diff --git a/shell.nix b/shell.nix index d19c8a7c22..fc84e9beb2 100644 --- a/shell.nix +++ b/shell.nix @@ -44,7 +44,6 @@ let llvmPkgs = pkgs.llvmPackages_10; - # zig = import ./nix/zig-unstable.nix { inherit pkgs; }; zig = import ./nix/zig.nix { inherit pkgs; }; inputs = with pkgs;[ From a42a2cc1b491f54ec7de6f9a76a8359fb0e7d5a2 Mon Sep 17 00:00:00 2001 From: Jared Ramirez Date: Sun, 6 Jun 2021 14:46:23 -0700 Subject: [PATCH 155/496] Fix RocDec.toString tests --- compiler/builtins/bitcode/src/dec.zig | 77 ++++++++++++++------------- 1 file changed, 40 insertions(+), 37 deletions(-) diff --git a/compiler/builtins/bitcode/src/dec.zig b/compiler/builtins/bitcode/src/dec.zig index 88b2ed3302..4a669433d4 100644 --- a/compiler/builtins/bitcode/src/dec.zig +++ b/compiler/builtins/bitcode/src/dec.zig @@ -374,6 +374,7 @@ fn mul_u128(a: u128, b: u128) U256 { const testing = std.testing; const expectEqual = testing.expectEqual; +const expectEqualSlices = testing.expectEqualSlices; const expect = testing.expect; test "fromU64" { @@ -488,73 +489,75 @@ test "fromString: .123.1" { } test "toString: 123.45" { - var roc_str = RocStr.init("123.45", 6); - var dec = RocDec.fromString(roc_str); - var res_roc_str = dec.?.toString(); + var dec: RocDec = .{ .num = 123450000000000000000 }; + var res_roc_str = dec.toString(); - expect(RocStr.eq(roc_str, res_roc_str.?)); + const res_slice: []const u8 = "123.45"[0..]; + try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); } test "toString: -123.45" { - var roc_str = RocStr.init("-123.45", 7); - var dec = RocDec.fromString(roc_str); - var res_roc_str = dec.?.toString(); + var dec: RocDec = .{ .num = -123450000000000000000 }; + var res_roc_str = dec.toString(); - expect(RocStr.eq(roc_str, res_roc_str.?)); + const res_slice: []const u8 = "-123.45"[0..]; + try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); } test "toString: 123.0" { - var roc_str = RocStr.init("123.0", 5); - var dec = RocDec.fromString(roc_str); - var res_roc_str = dec.?.toString(); + var dec: RocDec = .{ .num = 123000000000000000000 }; + var res_roc_str = dec.toString(); - expect(RocStr.eq(roc_str, res_roc_str.?)); + const res_slice: []const u8 = "123.0"[0..]; + try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); } test "toString: -123.0" { - var roc_str = RocStr.init("-123.0", 6); - var dec = RocDec.fromString(roc_str); - var res_roc_str = dec.?.toString(); + var dec: RocDec = .{ .num = -123000000000000000000 }; + var res_roc_str = dec.toString(); - expect(RocStr.eq(roc_str, res_roc_str.?)); + const res_slice: []const u8 = "-123.0"[0..]; + try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); } test "toString: 0.45" { - var roc_str = RocStr.init("0.45", 4); - var dec = RocDec.fromString(roc_str); - var res_roc_str = dec.?.toString(); + var dec: RocDec = .{ .num = 450000000000000000 }; + var res_roc_str = dec.toString(); - expect(RocStr.eq(roc_str, res_roc_str.?)); + const res_slice: []const u8 = "0.45"[0..]; + try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); } test "toString: -0.45" { - var roc_str = RocStr.init("-0.45", 5); - var dec = RocDec.fromString(roc_str); - var res_roc_str = dec.?.toString(); + var dec: RocDec = .{ .num = -450000000000000000 }; + var res_roc_str = dec.toString(); - expect(RocStr.eq(roc_str, res_roc_str.?)); + const res_slice: []const u8 = "-0.45"[0..]; + try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); } test "toString: -111.123456789" { - var roc_str = RocStr.init("-111.123456789", 14); - var dec = RocDec.fromString(roc_str); - var res_roc_str = dec.?.toString(); + var dec: RocDec = .{ .num = -111123456789000000000 }; + var res_roc_str = dec.toString(); - expect(RocStr.eq(roc_str, res_roc_str.?)); + const res_slice: []const u8 = "-111.123456789"[0..]; + try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); } -test "toString: 111.1234567891" { - var roc_str = RocStr.init("111.1234567891", 14); - var dec = RocDec.fromString(roc_str); - var res_roc_str = dec.?.toString(); - expect(RocStr.eq(roc_str, res_roc_str.?)); +test "toString: 123.1111111" { + var dec: RocDec = .{ .num = 123111111100000000000 }; + var res_roc_str = dec.toString(); + + const res_slice: []const u8 = "123.1111111"[0..]; + try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); } test "toString: 123.111111111111 (big str)" { - var roc_str = RocStr.init("123.111111111111", 16); - var dec = RocDec.fromString(roc_str); - var res_roc_str = dec.?.toString(); - expect(RocStr.eq(roc_str, res_roc_str.?)); + var dec: RocDec = .{ .num = 123111111111110000000 }; + var res_roc_str = dec.toString(); + + const res_slice: []const u8 = "123.11111111111"[0..]; + try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); } test "add: 0" { From 060e977cca2818b46dc6982ae5c571a22e9a42cd Mon Sep 17 00:00:00 2001 From: Jared Ramirez Date: Sun, 6 Jun 2021 14:46:59 -0700 Subject: [PATCH 156/496] Rename to/fromString to to/fromStr --- compiler/builtins/bitcode/src/dec.zig | 100 +++++++++++++------------- 1 file changed, 50 insertions(+), 50 deletions(-) diff --git a/compiler/builtins/bitcode/src/dec.zig b/compiler/builtins/bitcode/src/dec.zig index 4a669433d4..4059d1d609 100644 --- a/compiler/builtins/bitcode/src/dec.zig +++ b/compiler/builtins/bitcode/src/dec.zig @@ -20,7 +20,7 @@ pub const RocDec = struct { return .{ .num = num * one_point_zero_i128 }; } - pub fn fromString(roc_str: RocStr) ?RocDec { + pub fn fromStr(roc_str: RocStr) ?RocDec { if (roc_str.isEmpty()) { return null; } @@ -109,7 +109,7 @@ pub const RocDec = struct { }; } - pub fn toString(self: RocDec) ?RocStr { + pub fn toStr(self: RocDec) ?RocStr { var num_bytes: [max_digits]u8 = undefined; var num_digits = std.fmt.formatIntBuf(num_bytes[0..], self.num, 10, false, .{}); @@ -383,178 +383,178 @@ test "fromU64" { try expectEqual(RocDec{ .num = 25000000000000000000 }, dec); } -test "fromString: empty" { +test "fromStr: empty" { var roc_str = RocStr.init("", 0); - var dec = RocDec.fromString(roc_str); + var dec = RocDec.fromStr(roc_str); try expectEqual(dec, null); } -test "fromString: 0" { +test "fromStr: 0" { var roc_str = RocStr.init("0", 1); - var dec = RocDec.fromString(roc_str); + var dec = RocDec.fromStr(roc_str); try expectEqual(RocDec{ .num = 0 }, dec.?); } -test "fromString: 1" { +test "fromStr: 1" { var roc_str = RocStr.init("1", 1); - var dec = RocDec.fromString(roc_str); + var dec = RocDec.fromStr(roc_str); try expectEqual(RocDec.one_point_zero, dec.?); } -test "fromString: 123.45" { +test "fromStr: 123.45" { var roc_str = RocStr.init("123.45", 6); - var dec = RocDec.fromString(roc_str); + var dec = RocDec.fromStr(roc_str); try expectEqual(RocDec{ .num = 123450000000000000000 }, dec.?); } -test "fromString: .45" { +test "fromStr: .45" { var roc_str = RocStr.init(".45", 3); - var dec = RocDec.fromString(roc_str); + var dec = RocDec.fromStr(roc_str); try expectEqual(RocDec{ .num = 450000000000000000 }, dec.?); } -test "fromString: 0.45" { +test "fromStr: 0.45" { var roc_str = RocStr.init("0.45", 4); - var dec = RocDec.fromString(roc_str); + var dec = RocDec.fromStr(roc_str); try expectEqual(RocDec{ .num = 450000000000000000 }, dec.?); } -test "fromString: 123" { +test "fromStr: 123" { var roc_str = RocStr.init("123", 3); - var dec = RocDec.fromString(roc_str); + var dec = RocDec.fromStr(roc_str); try expectEqual(RocDec{ .num = 123000000000000000000 }, dec.?); } -test "fromString: -.45" { +test "fromStr: -.45" { var roc_str = RocStr.init("-.45", 4); - var dec = RocDec.fromString(roc_str); + var dec = RocDec.fromStr(roc_str); try expectEqual(RocDec{ .num = -450000000000000000 }, dec.?); } -test "fromString: -0.45" { +test "fromStr: -0.45" { var roc_str = RocStr.init("-0.45", 5); - var dec = RocDec.fromString(roc_str); + var dec = RocDec.fromStr(roc_str); try expectEqual(RocDec{ .num = -450000000000000000 }, dec.?); } -test "fromString: -123" { +test "fromStr: -123" { var roc_str = RocStr.init("-123", 4); - var dec = RocDec.fromString(roc_str); + var dec = RocDec.fromStr(roc_str); try expectEqual(RocDec{ .num = -123000000000000000000 }, dec.?); } -test "fromString: -123.45" { +test "fromStr: -123.45" { var roc_str = RocStr.init("-123.45", 7); - var dec = RocDec.fromString(roc_str); + var dec = RocDec.fromStr(roc_str); try expectEqual(RocDec{ .num = -123450000000000000000 }, dec.?); } -test "fromString: abc" { +test "fromStr: abc" { var roc_str = RocStr.init("abc", 3); - var dec = RocDec.fromString(roc_str); + var dec = RocDec.fromStr(roc_str); try expectEqual(dec, null); } -test "fromString: 123.abc" { +test "fromStr: 123.abc" { var roc_str = RocStr.init("123.abc", 7); - var dec = RocDec.fromString(roc_str); + var dec = RocDec.fromStr(roc_str); try expectEqual(dec, null); } -test "fromString: abc.123" { +test "fromStr: abc.123" { var roc_str = RocStr.init("abc.123", 7); - var dec = RocDec.fromString(roc_str); + var dec = RocDec.fromStr(roc_str); try expectEqual(dec, null); } -test "fromString: .123.1" { +test "fromStr: .123.1" { var roc_str = RocStr.init(".123.1", 6); - var dec = RocDec.fromString(roc_str); + var dec = RocDec.fromStr(roc_str); try expectEqual(dec, null); } -test "toString: 123.45" { +test "toStr: 123.45" { var dec: RocDec = .{ .num = 123450000000000000000 }; - var res_roc_str = dec.toString(); + var res_roc_str = dec.toStr(); const res_slice: []const u8 = "123.45"[0..]; try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); } -test "toString: -123.45" { +test "toStr: -123.45" { var dec: RocDec = .{ .num = -123450000000000000000 }; - var res_roc_str = dec.toString(); + var res_roc_str = dec.toStr(); const res_slice: []const u8 = "-123.45"[0..]; try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); } -test "toString: 123.0" { +test "toStr: 123.0" { var dec: RocDec = .{ .num = 123000000000000000000 }; - var res_roc_str = dec.toString(); + var res_roc_str = dec.toStr(); const res_slice: []const u8 = "123.0"[0..]; try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); } -test "toString: -123.0" { +test "toStr: -123.0" { var dec: RocDec = .{ .num = -123000000000000000000 }; - var res_roc_str = dec.toString(); + var res_roc_str = dec.toStr(); const res_slice: []const u8 = "-123.0"[0..]; try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); } -test "toString: 0.45" { +test "toStr: 0.45" { var dec: RocDec = .{ .num = 450000000000000000 }; - var res_roc_str = dec.toString(); + var res_roc_str = dec.toStr(); const res_slice: []const u8 = "0.45"[0..]; try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); } -test "toString: -0.45" { +test "toStr: -0.45" { var dec: RocDec = .{ .num = -450000000000000000 }; - var res_roc_str = dec.toString(); + var res_roc_str = dec.toStr(); const res_slice: []const u8 = "-0.45"[0..]; try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); } -test "toString: -111.123456789" { +test "toStr: -111.123456789" { var dec: RocDec = .{ .num = -111123456789000000000 }; - var res_roc_str = dec.toString(); + var res_roc_str = dec.toStr(); const res_slice: []const u8 = "-111.123456789"[0..]; try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); } -test "toString: 123.1111111" { +test "toStr: 123.1111111" { var dec: RocDec = .{ .num = 123111111100000000000 }; - var res_roc_str = dec.toString(); + var res_roc_str = dec.toStr(); const res_slice: []const u8 = "123.1111111"[0..]; try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); } -test "toString: 123.111111111111 (big str)" { +test "toStr: 123.111111111111 (big str)" { var dec: RocDec = .{ .num = 123111111111110000000 }; - var res_roc_str = dec.toString(); + var res_roc_str = dec.toStr(); const res_slice: []const u8 = "123.11111111111"[0..]; try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); From ea893b34813c6880dc577119c6bc4a93bfa030d2 Mon Sep 17 00:00:00 2001 From: Jared Ramirez Date: Sun, 6 Jun 2021 15:38:49 -0700 Subject: [PATCH 157/496] Rework RocDec.toString internals --- compiler/builtins/bitcode/src/dec.zig | 73 +++++++++++++++------------ 1 file changed, 40 insertions(+), 33 deletions(-) diff --git a/compiler/builtins/bitcode/src/dec.zig b/compiler/builtins/bitcode/src/dec.zig index 4059d1d609..56a2237bab 100644 --- a/compiler/builtins/bitcode/src/dec.zig +++ b/compiler/builtins/bitcode/src/dec.zig @@ -102,6 +102,7 @@ pub const RocDec = struct { return dec; } + // TODO: Replace this with https://github.com/rtfeldman/roc/pull/1365/files#r643580738 fn isDigit(c: u8) bool { return switch (c) { '0'...'9' => true, @@ -110,16 +111,33 @@ pub const RocDec = struct { } pub fn toStr(self: RocDec) ?RocStr { - var num_bytes: [max_digits]u8 = undefined; - var num_digits = std.fmt.formatIntBuf(num_bytes[0..], self.num, 10, false, .{}); + var digit_bytes: [max_digits]u8 = undefined; + var num_digits_formatted = std.fmt.formatIntBuf(digit_bytes[0..], self.num, 10, false, .{}); - var before_num_digits = num_digits - decimal_places; + var before_digits_num_raw: usize = undefined; + var before_digits_num: usize = undefined; + var before_digits_slice: []const u8 = undefined; + if (num_digits_formatted > decimal_places) { + before_digits_num_raw = num_digits_formatted - decimal_places; + + if (before_digits_num_raw == 1 and digit_bytes[0] == '-') { + before_digits_num = 2; + before_digits_slice = "-0"[0..]; + } else { + before_digits_num = before_digits_num_raw; + before_digits_slice = digit_bytes[0..before_digits_num_raw]; + } + } else { + before_digits_num_raw = 0; + before_digits_num = 1; + before_digits_slice = "0"[0..]; + } var index = decimal_places - 1; var trim_index: ?usize = null; var is_consecutive_zero = true; while (index != 0) { - var digit = num_bytes[before_num_digits + index]; + var digit = digit_bytes[before_digits_num_raw + index]; if (digit == '0' and is_consecutive_zero) { trim_index = index; } else { @@ -127,38 +145,19 @@ pub const RocDec = struct { } index -= 1; } - var after_num_digits = if (trim_index) |i| i else decimal_places; - const should_add_prefix_zero = before_num_digits == 0 or (before_num_digits == 1 and num_bytes[0] == '-'); - const prefix_zero_len: usize = if (should_add_prefix_zero) 1 else 0; - const dot_len: usize = 1; - var str_len = prefix_zero_len + before_num_digits + dot_len + after_num_digits; + var after_digits_num = if (trim_index) |i| i else decimal_places; + var after_digits_slice: []const u8 = undefined; + after_digits_slice = digit_bytes[before_digits_num_raw..(before_digits_num_raw + after_digits_num)]; - // [max_digits + 2] here to account for '.' and '-' + // `+ 1` in here to account for the '.' + // `before_digits_num` already includes the '-' + var str_len: usize = before_digits_num + 1 + after_digits_num; + + // TODO: Ideally we'd use [str_len]u8 here, but Zig gives an error if we do that. + // [max_digits + 2]u8 here to account for '.' and '-', aka the max possible length of the string var str_bytes: [max_digits + 2]u8 = undefined; - - var str_bytes_index: usize = 0; - var bytes_index: usize = 0; - if (should_add_prefix_zero) { - if (num_bytes[bytes_index] == '-') { - str_bytes[str_bytes_index] = '-'; - str_bytes_index += 1; - bytes_index += 1; - } - str_bytes[str_bytes_index] = '0'; - str_bytes_index += 1; - } - - while (bytes_index < str_len) { - if (bytes_index == before_num_digits) { - str_bytes[str_bytes_index] = '.'; - str_bytes_index += 1; - } - - str_bytes[str_bytes_index] = num_bytes[bytes_index]; - str_bytes_index += 1; - bytes_index += 1; - } + _ = std.fmt.bufPrint(str_bytes[0 .. str_len + 1], "{s}.{s}", .{ before_digits_slice, after_digits_slice }) catch unreachable; return RocStr.init(&str_bytes, str_len); } @@ -536,6 +535,14 @@ test "toStr: -0.45" { try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); } +// test "toStr: 0.00045" { +// var dec: RocDec = .{ .num = 000450000000000000 }; +// var res_roc_str = dec.toStr(); + +// const res_slice: []const u8 = "0.00045"[0..]; +// try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); +// } + test "toStr: -111.123456789" { var dec: RocDec = .{ .num = -111123456789000000000 }; var res_roc_str = dec.toStr(); From ef74f50ae7bd7f6de5423598d8a6eed802a475e0 Mon Sep 17 00:00:00 2001 From: Chadtech Date: Mon, 7 Jun 2021 01:02:20 -0400 Subject: [PATCH 158/496] A module like Json.Decode will now have its docs at Json/Decode/index.html --- docs/src/lib.rs | 4 ++-- docs/src/static/index.html | 6 +++--- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/docs/src/lib.rs b/docs/src/lib.rs index 97ef19bba1..3ee9d75cd7 100644 --- a/docs/src/lib.rs +++ b/docs/src/lib.rs @@ -63,9 +63,9 @@ pub fn generate(filenames: Vec, std_lib: StdLib, build_dir: &Path) { // Write each package's module docs html file for (docs_by_id, interns) in package.modules.iter_mut() { for module in docs_by_id.values_mut() { - let module_dir = build_dir.join(module.name.as_str()); + let module_dir = build_dir.join(module.name.replace(".", "/").as_str()); - fs::create_dir(&module_dir) + fs::create_dir_all(&module_dir) .expect("TODO gracefully handle not being able to create the module dir"); let rendered_module = template_html diff --git a/docs/src/static/index.html b/docs/src/static/index.html index daad3246e6..5e358eea74 100644 --- a/docs/src/static/index.html +++ b/docs/src/static/index.html @@ -6,9 +6,9 @@ - - - + + + From 11ae7867a6521e773a79e9b11dd7ca012c48326b Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Mon, 7 Jun 2021 10:39:17 +0200 Subject: [PATCH 159/496] Added replit editor inspiration, thanks Richard! --- editor/editor-ideas.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/editor/editor-ideas.md b/editor/editor-ideas.md index f17adf94a3..d936a0214d 100644 --- a/editor/editor-ideas.md +++ b/editor/editor-ideas.md @@ -39,9 +39,11 @@ Nice collection of research on innovative editors, [link](https://futureofcoding * [godbolt.org Compiler Explorer](https://godbolt.org/) * [whitebox debug visualization](https://vimeo.com/483795097) * [Hest](https://ivanish.ca/hest-time-travel/) tool for making highly interactive simulations. +* [replit](https://replit.com/) collaborative browser based IDE. * Say you have a failing test that used to work, it would be very valuable to see all code that was changed that was used only by that test. e.g. you have a test `calculate_sum_test` that only uses the function `add`, when the test fails you should be able to see a diff showing only what changed for the function `add`. It would also be great to have a diff of [expression values](https://homepages.cwi.nl/~storm/livelit/images/bret.png) Bret Victor style. An ambitious project would be to suggest or automatically try fixes based on these diffs. * I think it could be possible to create a minimal reproduction of a program / block of code / code used by a single test. So for a failing unit test I would expect it to extract imports, the platform, types and functions that are necessary to run only that unit test and put them in a standalone roc project. This would be useful for sharing bugs with library+application authors and colleagues, for profiling or debugging with all "clutter" removed. +* Ability to share program state at a breakpoint with someone else. ### Cool regular editors From 8a8bbfd10b0c34ddda225794098bca6b3b7328c6 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Mon, 7 Jun 2021 14:55:35 +0200 Subject: [PATCH 160/496] fixed dir copying issue, added earthignore, fixed typos, set up typo checking for CI --- .earthignore | 4 ++++ Earthfile | 15 ++++----------- compiler/builtins/docs/Dict.roc | 2 +- compiler/builtins/docs/Set.roc | 2 +- 4 files changed, 10 insertions(+), 13 deletions(-) create mode 100644 .earthignore diff --git a/.earthignore b/.earthignore new file mode 100644 index 0000000000..a291dd2885 --- /dev/null +++ b/.earthignore @@ -0,0 +1,4 @@ +AUTHORS +nix +.envrc +.gitignore \ No newline at end of file diff --git a/Earthfile b/Earthfile index e9ad4e6af0..ab28ba84c2 100644 --- a/Earthfile +++ b/Earthfile @@ -1,8 +1,6 @@ FROM rust:1.52-slim-buster WORKDIR /earthbuild -ARG TO_COPY_DIRS=cli compiler docs editor roc_std vendor examples Cargo.toml Cargo.lock - prep-debian: RUN apt -y update @@ -40,8 +38,6 @@ install-zig-llvm-valgrind-clippy-rustfmt: RUN rustup component add clippy # rustfmt RUN rustup component add rustfmt - # typo checker - RUN cargo install typos-cli # criterion RUN cargo install --git https://github.com/Anton-4/cargo-criterion --branch main # sccache @@ -61,8 +57,7 @@ deps-image: copy-dirs: FROM +install-zig-llvm-valgrind-clippy-rustfmt # If you edit this, make sure to update copy-dirs-and-cache below. - RUN baksldbjk - COPY --dir $TO_COPY_DIRS ./ + COPY --dir cli compiler docs editor roc_std vendor examples Cargo.toml Cargo.lock ./ copy-dirs-and-cache: FROM +install-zig-llvm-valgrind-clippy-rustfmt @@ -71,7 +66,7 @@ copy-dirs-and-cache: # This needs to be kept in sync with copy-dirs above. # The reason this is at the end is to maximize caching. # Lines above this should be cached even if the code changes. - COPY --dir $TO_COPY_DIRS ./ + COPY --dir cli compiler docs editor roc_std vendor examples Cargo.toml Cargo.lock ./ prepare-cache: FROM +copy-dirs @@ -105,10 +100,8 @@ check-rustfmt: RUN cargo fmt --all -- --check check-typos: - FROM +copy-dirs - RUN echo "DIRS_TO_KEEP=" > temp42.txt - RUN echo $TO_COPY_DIRS | sed "s/ /\"|\"/g" >> temp42.txt - RUN source temp42.txt && rm -v !("$DIRS_TO_KEEP") + RUN cargo install typos-cli --version 1.0.4 # use latest version on resolution of issue crate-ci/typos#277 + COPY --dir .github ci cli compiler docs editor examples packages roc_std www *.md LEGAL_DETAILS shell.nix ./ RUN typos test-rust: diff --git a/compiler/builtins/docs/Dict.roc b/compiler/builtins/docs/Dict.roc index 4c7fa6c867..3aad9e4eee 100644 --- a/compiler/builtins/docs/Dict.roc +++ b/compiler/builtins/docs/Dict.roc @@ -27,7 +27,7 @@ map : # TODO: removed `'` from signature because parser does not support it yet # Original signature: insert : Dict 'key val, 'key, val -> Dict 'key val -## Make sure never to insert a key of *NaN* into a [Dict]! Becuase *NaN* is +## Make sure never to insert a key of *NaN* into a [Dict]! Because *NaN* is ## defined to be unequal to *NaN*, inserting a *NaN* key results in an entry ## that can never be retrieved or removed from the [Dict]. insert : Dict key val, key, val -> Dict key val diff --git a/compiler/builtins/docs/Set.roc b/compiler/builtins/docs/Set.roc index 0033ee392e..24c29dac0e 100644 --- a/compiler/builtins/docs/Set.roc +++ b/compiler/builtins/docs/Set.roc @@ -18,7 +18,7 @@ len : Set * -> Nat # TODO: removed `'` from signature because parser does not support it yet # Original signature: `add : Set 'elem, 'elem -> Set 'elem` -## Make sure never to add a *NaN* to a [Set]! Becuase *NaN* is defined to be +## Make sure never to add a *NaN* to a [Set]! Because *NaN* is defined to be ## unequal to *NaN*, adding a *NaN* results in an entry that can never be ## retrieved or removed from the [Set]. add : Set elem, elem -> Set elem From 7235e488376e0b0cdda5470dc745931856a282e9 Mon Sep 17 00:00:00 2001 From: rvcas Date: Mon, 7 Jun 2021 10:17:42 -0400 Subject: [PATCH 161/496] feat: update zig to 0.8.0 in the Earthfile --- Earthfile | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Earthfile b/Earthfile index 766e224f12..d8af533cbc 100644 --- a/Earthfile +++ b/Earthfile @@ -13,9 +13,9 @@ install-other-libs: install-zig-llvm-valgrind-clippy-rustfmt: FROM +install-other-libs # zig - RUN wget -c https://ziglang.org/download/0.7.1/zig-linux-x86_64-0.7.1.tar.xz --no-check-certificate - RUN tar -xf zig-linux-x86_64-0.7.1.tar.xz - RUN ln -s /earthbuild/zig-linux-x86_64-0.7.1/zig /usr/bin/zig + RUN wget -c https://ziglang.org/download/0.8.0/zig-linux-x86_64-0.8.0.tar.xz --no-check-certificate + RUN tar -xf zig-linux-x86_64-0.8.0.tar.xz + RUN ln -s /earthbuild/zig-linux-x86_64-0.8.0/zig /usr/bin/zig # llvm RUN apt -y install lsb-release software-properties-common gnupg RUN wget https://apt.llvm.org/llvm.sh From 81be275e1162674f022ef5ed291b8ed40b160ffd Mon Sep 17 00:00:00 2001 From: rvcas Date: Mon, 7 Jun 2021 10:18:24 -0400 Subject: [PATCH 162/496] chore: update llvm version in the dotfile --- .llvmenv | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.llvmenv b/.llvmenv index 95c4e8d271..4044f90867 100644 --- a/.llvmenv +++ b/.llvmenv @@ -1 +1 @@ -10.0.0 \ No newline at end of file +12.0.0 From 0754b8e3ce41f49d5993663c08abef7559b84d21 Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 7 Jun 2021 18:17:45 +0200 Subject: [PATCH 163/496] WIP --- compiler/gen/src/llvm/build.rs | 9 ++++----- compiler/mono/src/alias_analysis.rs | 8 ++++++++ compiler/mono/src/ir.rs | 2 +- examples/benchmarks/Closure.roc | 6 +++--- 4 files changed, 16 insertions(+), 9 deletions(-) diff --git a/compiler/gen/src/llvm/build.rs b/compiler/gen/src/llvm/build.rs index 2b09202a59..63708347e4 100644 --- a/compiler/gen/src/llvm/build.rs +++ b/compiler/gen/src/llvm/build.rs @@ -813,8 +813,6 @@ pub fn build_exp_call<'a, 'ctx, 'env>( let callee_var = CalleeSpecVar(&bytes); let func_spec = func_spec_solutions.callee_spec(callee_var).unwrap(); - dbg!(name, &func_spec); - roc_call_with_args( env, &full_layout, @@ -2901,7 +2899,7 @@ where let info = builder .build_catch_all_landing_pad( &landing_pad_type, - &BasicValueEnum::IntValue(context.i8_type().const_zero()), + BasicValueEnum::IntValue(context.i8_type().const_zero()), context.i8_type().ptr_type(AddressSpace::Generic), "main_landing_pad", ) @@ -3252,10 +3250,10 @@ fn build_proc_header<'a, 'ctx, 'env>( let args = proc.args; let arena = env.arena; - dbg!(&symbol, &func_spec); - let fn_name = func_spec_name(env.arena, &env.interns, symbol, func_spec); + dbg!(&fn_name); + let ret_type = basic_type_from_layout(env, &proc.ret_layout); let mut arg_basic_types = Vec::with_capacity_in(args.len(), arena); @@ -3572,6 +3570,7 @@ pub fn build_proc<'a, 'ctx, 'env>( // // * roc__mainForHost_1_Update_size() -> i64 // * roc__mainForHost_1_Update_result_size() -> i64 + continue; let evaluator_layout = env.arena.alloc(top_level).full(); let evaluator_name = layout_ids diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 6154b6b84b..083b7f86a6 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -84,6 +84,12 @@ where for proc in procs { let spec = proc_spec(proc)?; + dbg!(proc.name); + for b in &func_name_bytes(proc) { + eprint!("{:x}", b); + } + eprintln!(""); + m.add_func(FuncName(&func_name_bytes(proc)), spec)?; if format!("{:?}", proc.name).contains("mainForHost") { @@ -127,6 +133,8 @@ where p.build()? }; + eprintln!("{}", program.to_source_string()); + morphic_lib::solve(program) } } diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 29da0e66e3..df1dc0a78b 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -19,7 +19,7 @@ use roc_types::subs::{Content, FlatType, Subs, Variable}; use std::collections::HashMap; use ven_pretty::{BoxAllocator, DocAllocator, DocBuilder}; -pub const PRETTY_PRINT_IR_SYMBOLS: bool = false; +pub const PRETTY_PRINT_IR_SYMBOLS: bool = true; macro_rules! return_on_layout_error { ($env:expr, $layout_result:expr) => { diff --git a/examples/benchmarks/Closure.roc b/examples/benchmarks/Closure.roc index 11ebf8402d..8e61ca4dfb 100644 --- a/examples/benchmarks/Closure.roc +++ b/examples/benchmarks/Closure.roc @@ -7,9 +7,9 @@ app "closure" main : Task.Task {} [] main = closure1 {} - |> Task.after (\_ -> closure2 {}) - |> Task.after (\_ -> closure3 {}) - |> Task.after (\_ -> closure4 {}) + # |> Task.after (\_ -> closure2 {}) + # |> Task.after (\_ -> closure3 {}) + # |> Task.after (\_ -> closure4 {}) # --- From 65731d8691d496325995f5d29320158225ab6916 Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 7 Jun 2021 18:37:34 +0200 Subject: [PATCH 164/496] bump inkwell to a version that supports llvm12 (still using llvm10) --- Cargo.lock | 6 +++--- vendor/inkwell/Cargo.toml | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 5b05e59e64..cf4a7232fa 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1612,13 +1612,13 @@ dependencies = [ name = "inkwell" version = "0.1.0" dependencies = [ - "inkwell 0.1.0 (git+https://github.com/rtfeldman/inkwell?tag=llvm10-0.release5)", + "inkwell 0.1.0 (git+https://github.com/rtfeldman/inkwell?tag=llvm12-0.release2)", ] [[package]] name = "inkwell" version = "0.1.0" -source = "git+https://github.com/rtfeldman/inkwell?tag=llvm10-0.release5#f0a32d3a0595bda3777a7b7e08a2e46c97eba6f4" +source = "git+https://github.com/rtfeldman/inkwell?tag=llvm12-0.release2#2f9bfb728cb5713b39fe527838969dcc8e184c4d" dependencies = [ "either", "inkwell_internals", @@ -1632,7 +1632,7 @@ dependencies = [ [[package]] name = "inkwell_internals" version = "0.3.0" -source = "git+https://github.com/rtfeldman/inkwell?tag=llvm10-0.release5#f0a32d3a0595bda3777a7b7e08a2e46c97eba6f4" +source = "git+https://github.com/rtfeldman/inkwell?tag=llvm12-0.release2#2f9bfb728cb5713b39fe527838969dcc8e184c4d" dependencies = [ "proc-macro2 1.0.27", "quote 1.0.9", diff --git a/vendor/inkwell/Cargo.toml b/vendor/inkwell/Cargo.toml index 970a89fcf0..289eec8845 100644 --- a/vendor/inkwell/Cargo.toml +++ b/vendor/inkwell/Cargo.toml @@ -23,7 +23,7 @@ edition = "2018" # commit of TheDan64/inkwell, push a new tag which points to the latest commit, # change the tag value in this Cargo.toml to point to that tag, and `cargo update`. # This way, GitHub Actions works and nobody's builds get broken. -inkwell = { git = "https://github.com/rtfeldman/inkwell", tag = "llvm10-0.release5", features = [ "llvm10-0" ] } +inkwell = { git = "https://github.com/rtfeldman/inkwell", tag = "llvm12-0.release2", features = [ "llvm10-0" ] } [features] target-arm = [] From 8e227c7e7c41377ad48f84caffca431335c3949a Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 7 Jun 2021 20:02:59 +0200 Subject: [PATCH 165/496] update to llvm 12 --- Cargo.lock | 104 +++++++++++++--------------- compiler/build/src/program.rs | 4 +- compiler/builtins/build.rs | 2 +- compiler/gen_llvm/src/llvm/build.rs | 2 + vendor/inkwell/Cargo.toml | 2 +- 5 files changed, 56 insertions(+), 58 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index a4b14f1473..5a68dbd35f 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1,7 +1,5 @@ # This file is automatically @generated by Cargo. # It is not intended for manual editing. -version = 3 - [[package]] name = "ab_glyph" version = "0.2.11" @@ -20,9 +18,9 @@ checksum = "d9fe5e32de01730eb1f6b7f5b51c17e03e2325bf40a74f754f04f130043affff" [[package]] name = "addr2line" -version = "0.15.1" +version = "0.15.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "03345e98af8f3d786b6d9f656ccfa6ac316d954e92bc4841f0bba20789d5fb5a" +checksum = "e7a2e47a1fbe209ee101dd6d61285226744c6c8d3c21c8dc878ba6cb9f467f3a" dependencies = [ "gimli", ] @@ -99,6 +97,15 @@ dependencies = [ "num-traits", ] +[[package]] +name = "approx" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "072df7202e63b127ab55acfe16ce97013d5b97bf160489336d3f1840fd78e99e" +dependencies = [ + "num-traits", +] + [[package]] name = "arena-pool" version = "0.1.0" @@ -155,16 +162,16 @@ checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a" [[package]] name = "backtrace" -version = "0.3.59" +version = "0.3.60" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4717cfcbfaa661a0fd48f8453951837ae7e8f81e481fbb136e3202d72805a744" +checksum = "b7815ea54e4d821e791162e078acbebfd6d8c8939cd559c9335dceb1c8ca7282" dependencies = [ "addr2line", "cc", "cfg-if 1.0.0", "libc", "miniz_oxide", - "object", + "object 0.25.2", "rustc-demangle", ] @@ -689,7 +696,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "06ed27e177f16d65f0f0c22a213e17c696ace5dd64b14258b52f9417ccb52db4" dependencies = [ "cfg-if 1.0.0", - "crossbeam-utils 0.8.4", + "crossbeam-utils 0.8.5", ] [[package]] @@ -710,8 +717,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "94af6efb46fef72616855b036a624cf27ba656ffc9be1b9a3c931cfc7749a9a9" dependencies = [ "cfg-if 1.0.0", - "crossbeam-epoch 0.9.4", - "crossbeam-utils 0.8.4", + "crossbeam-epoch 0.9.5", + "crossbeam-utils 0.8.5", ] [[package]] @@ -731,12 +738,12 @@ dependencies = [ [[package]] name = "crossbeam-epoch" -version = "0.9.4" +version = "0.9.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "52fb27eab85b17fbb9f6fd667089e07d6a2eb8743d02639ee7f6a7a7729c9c94" +checksum = "4ec02e091aa634e2c3ada4a392989e7c3116673ef0ac5b72232439094d73b7fd" dependencies = [ "cfg-if 1.0.0", - "crossbeam-utils 0.8.4", + "crossbeam-utils 0.8.5", "lazy_static", "memoffset 0.6.4", "scopeguard", @@ -766,11 +773,10 @@ dependencies = [ [[package]] name = "crossbeam-utils" -version = "0.8.4" +version = "0.8.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4feb231f0d4d6af81aed15928e58ecf5816aa62a2393e2c82f46973e92a9a278" +checksum = "d82cfc11ce7f2c3faef78d8a684447b40d503d9681acebed6cb728d45940c4db" dependencies = [ - "autocfg 1.0.1", "cfg-if 1.0.0", "lazy_static", ] @@ -1407,12 +1413,12 @@ dependencies = [ [[package]] name = "glyph_brush_layout" -version = "0.2.1" +version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "10bc06d530bf20c1902f1b02799ab7372ff43f6119770c49b0bc3f21bd148820" +checksum = "15cf18cf985bd942f05e14552b63c9d08f7d0ed1ec79a977eb9747c9e065f497" dependencies = [ "ab_glyph", - "approx 0.4.0", + "approx 0.5.0", "xi-unicode", ] @@ -1482,9 +1488,9 @@ dependencies = [ [[package]] name = "heck" -version = "0.3.2" +version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87cbf45460356b7deeb5e3415b5563308c0a9b057c85e12b06ad551f98d0a6ac" +checksum = "6d621efb26863f0e9924c6ac577e8275e5e6b77455db64ffa6c65c904e9e132c" dependencies = [ "unicode-segmentation", ] @@ -1612,13 +1618,13 @@ dependencies = [ name = "inkwell" version = "0.1.0" dependencies = [ - "inkwell 0.1.0 (git+https://github.com/rtfeldman/inkwell?tag=llvm12-0.release2)", + "inkwell 0.1.0 (git+https://github.com/rtfeldman/inkwell?tag=llvm12-0.release4)", ] [[package]] name = "inkwell" version = "0.1.0" -source = "git+https://github.com/rtfeldman/inkwell?tag=llvm12-0.release2#2f9bfb728cb5713b39fe527838969dcc8e184c4d" +source = "git+https://github.com/rtfeldman/inkwell?tag=llvm12-0.release4#8d7174fc8da4d2e6f2555f9ec2b3f7464ec5026b" dependencies = [ "either", "inkwell_internals", @@ -1632,7 +1638,7 @@ dependencies = [ [[package]] name = "inkwell_internals" version = "0.3.0" -source = "git+https://github.com/rtfeldman/inkwell?tag=llvm12-0.release2#2f9bfb728cb5713b39fe527838969dcc8e184c4d" +source = "git+https://github.com/rtfeldman/inkwell?tag=llvm12-0.release4#8d7174fc8da4d2e6f2555f9ec2b3f7464ec5026b" dependencies = [ "proc-macro2 1.0.27", "quote 1.0.9", @@ -1789,15 +1795,15 @@ checksum = "7fb9b38af92608140b86b693604b9ffcc5824240a484d1ecd4795bacb2fe88f3" [[package]] name = "llvm-sys" -version = "100.2.1" +version = "120.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "15d9c00ce56221b2150e2d4d51887ff139fce5a0e50346c744861d1e66d2f7c4" +checksum = "7b883556196140c6b6e7a18b19236b9a699c8611aad2e48a0a6403cf1123945a" dependencies = [ "cc", "lazy_static", "libc", "regex", - "semver 0.9.0", + "semver", ] [[package]] @@ -2165,6 +2171,15 @@ dependencies = [ "indexmap", ] +[[package]] +name = "object" +version = "0.25.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8bc1d42047cf336f0f939c99e97183cf31551bf0f2865a2ec9c8d91fd4ffb5e" +dependencies = [ + "memchr", +] + [[package]] name = "once_cell" version = "1.7.2" @@ -2191,12 +2206,11 @@ checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5" [[package]] name = "ordered-float" -version = "2.5.0" +version = "2.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "809348965973b261c3e504c8d0434e465274f78c880e10039914f2c5dcf49461" +checksum = "f100fcfb41e5385e0991f74981732049f9b896821542a219420491046baafdc2" dependencies = [ "num-traits", - "rand 0.8.3", ] [[package]] @@ -2850,7 +2864,7 @@ checksum = "d78120e2c850279833f1dd3582f730c4ab53ed95aeaaaa862a2a5c71b1656d8e" dependencies = [ "crossbeam-channel 0.5.1", "crossbeam-deque 0.8.0", - "crossbeam-utils 0.8.4", + "crossbeam-utils 0.8.5", "lazy_static", "num_cpus", ] @@ -2902,12 +2916,9 @@ dependencies = [ [[package]] name = "regex-automata" -version = "0.1.9" +version = "0.1.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ae1ded71d66a4a97f5e961fd0cb25a5f366a42a41570d16a763a69c092c26ae4" -dependencies = [ - "byteorder", -] +checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132" [[package]] name = "regex-syntax" @@ -3171,7 +3182,7 @@ dependencies = [ "libc", "libloading 0.6.7", "maplit", - "object", + "object 0.24.0", "pretty_assertions 0.5.1", "quickcheck 0.8.5", "quickcheck_macros 0.8.0", @@ -3457,7 +3468,7 @@ version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f0dfe2087c51c460008730de8b57e6a320782fbfb312e1f4d520e6c6fae155ee" dependencies = [ - "semver 0.11.0", + "semver", ] [[package]] @@ -3524,30 +3535,15 @@ version = "1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd" -[[package]] -name = "semver" -version = "0.9.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403" -dependencies = [ - "semver-parser 0.7.0", -] - [[package]] name = "semver" version = "0.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f301af10236f6df4160f7c3f04eec6dbc70ace82d23326abad5edee88801c6b6" dependencies = [ - "semver-parser 0.10.2", + "semver-parser", ] -[[package]] -name = "semver-parser" -version = "0.7.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3" - [[package]] name = "semver-parser" version = "0.10.2" diff --git a/compiler/build/src/program.rs b/compiler/build/src/program.rs index 28be0802f5..de8ba19374 100644 --- a/compiler/build/src/program.rs +++ b/compiler/build/src/program.rs @@ -204,7 +204,7 @@ pub fn gen_from_mono_module( } // assemble the .ll into a .bc - let _ = Command::new("llvm-as-10") + let _ = Command::new("llvm-as-12") .env_clear() .args(&[ app_ll_dbg_file.to_str().unwrap(), @@ -216,7 +216,7 @@ pub fn gen_from_mono_module( // write the .o file. Note that this builds the .o for the local machine, // and ignores the `target_machine` entirely. - let _ = Command::new("llc-10") + let _ = Command::new("llc-12") .env_clear() .args(&[ "-filetype=obj", diff --git a/compiler/builtins/build.rs b/compiler/builtins/build.rs index 8b42e59835..7df5952d34 100644 --- a/compiler/builtins/build.rs +++ b/compiler/builtins/build.rs @@ -58,7 +58,7 @@ fn main() { run_command( build_script_dir_path, - "llvm-as-10", + "llvm-as-12", &[dest_ir, "-o", dest_bc], ); diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 47e989006b..76419849ab 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -301,6 +301,8 @@ impl<'a, 'ctx, 'env> Env<'a, 'ctx, 'env> { /* dwo_id */ 0, /* split_debug_inling */ false, /* debug_info_for_profiling */ false, + "", + "", ) } diff --git a/vendor/inkwell/Cargo.toml b/vendor/inkwell/Cargo.toml index 289eec8845..85af15fec2 100644 --- a/vendor/inkwell/Cargo.toml +++ b/vendor/inkwell/Cargo.toml @@ -23,7 +23,7 @@ edition = "2018" # commit of TheDan64/inkwell, push a new tag which points to the latest commit, # change the tag value in this Cargo.toml to point to that tag, and `cargo update`. # This way, GitHub Actions works and nobody's builds get broken. -inkwell = { git = "https://github.com/rtfeldman/inkwell", tag = "llvm12-0.release2", features = [ "llvm10-0" ] } +inkwell = { git = "https://github.com/rtfeldman/inkwell", tag = "llvm12-0.release4", features = [ "llvm12-0" ] } [features] target-arm = [] From e85ddc3506267d0fac8e1267d8d34cbb2e6eea89 Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 7 Jun 2021 20:29:16 +0200 Subject: [PATCH 166/496] fix examples --- cli/tests/fixtures/multi-dep-str/platform/host.zig | 2 +- cli/tests/fixtures/multi-dep-thunk/platform/host.zig | 2 +- examples/benchmarks/platform/host.zig | 2 +- examples/hello-world/platform/host.zig | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/cli/tests/fixtures/multi-dep-str/platform/host.zig b/cli/tests/fixtures/multi-dep-str/platform/host.zig index 2d335ec0f7..e60688a037 100644 --- a/cli/tests/fixtures/multi-dep-str/platform/host.zig +++ b/cli/tests/fixtures/multi-dep-str/platform/host.zig @@ -59,7 +59,7 @@ pub export fn main() i32 { roc__mainForHost_1_exposed(&callresult); // stdout the result - stdout.print("{}\n", .{callresult.content.asSlice()}) catch unreachable; + stdout.print("{s}\n", .{callresult.content.asSlice()}) catch unreachable; callresult.content.deinit(); diff --git a/cli/tests/fixtures/multi-dep-thunk/platform/host.zig b/cli/tests/fixtures/multi-dep-thunk/platform/host.zig index 2d335ec0f7..e60688a037 100644 --- a/cli/tests/fixtures/multi-dep-thunk/platform/host.zig +++ b/cli/tests/fixtures/multi-dep-thunk/platform/host.zig @@ -59,7 +59,7 @@ pub export fn main() i32 { roc__mainForHost_1_exposed(&callresult); // stdout the result - stdout.print("{}\n", .{callresult.content.asSlice()}) catch unreachable; + stdout.print("{s}\n", .{callresult.content.asSlice()}) catch unreachable; callresult.content.deinit(); diff --git a/examples/benchmarks/platform/host.zig b/examples/benchmarks/platform/host.zig index 56461d93e6..fdeb1a0ef5 100644 --- a/examples/benchmarks/platform/host.zig +++ b/examples/benchmarks/platform/host.zig @@ -163,7 +163,7 @@ pub export fn roc_fx_getInt() GetInt { } fn roc_fx_getInt_help() !i64 { - const stdin = std.io.getStdIn().inStream(); + const stdin = std.io.getStdIn().reader(); var buf: [40]u8 = undefined; const line: []u8 = (try stdin.readUntilDelimiterOrEof(&buf, '\n')) orelse ""; diff --git a/examples/hello-world/platform/host.zig b/examples/hello-world/platform/host.zig index 1419ddd15e..d1a563a68e 100644 --- a/examples/hello-world/platform/host.zig +++ b/examples/hello-world/platform/host.zig @@ -59,7 +59,7 @@ pub export fn main() i32 { roc__mainForHost_1_exposed(&callresult); // stdout the result - stdout.print("{}\n", .{callresult.content.asSlice()}) catch unreachable; + stdout.print("{s}\n", .{callresult.content.asSlice()}) catch unreachable; callresult.content.deinit(); From 032c509c0dcac33b71fd526d0d6d83daa57f5c45 Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 7 Jun 2021 20:31:12 +0200 Subject: [PATCH 167/496] bump llvm version --- Earthfile | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Earthfile b/Earthfile index c9c6f94c2d..88bf4f24ab 100644 --- a/Earthfile +++ b/Earthfile @@ -20,10 +20,10 @@ install-zig-llvm-valgrind-clippy-rustfmt: RUN apt -y install lsb-release software-properties-common gnupg RUN wget https://apt.llvm.org/llvm.sh RUN chmod +x llvm.sh - RUN ./llvm.sh 10 - RUN ln -s /usr/bin/clang-10 /usr/bin/clang + RUN ./llvm.sh 12 + RUN ln -s /usr/bin/clang-12 /usr/bin/clang # use lld as linker - RUN ln -s /usr/bin/lld-10 /usr/bin/ld.lld + RUN ln -s /usr/bin/lld-12 /usr/bin/ld.lld ENV RUSTFLAGS="-C link-arg=-fuse-ld=lld -C target-cpu=native" # valgrind RUN apt -y install autotools-dev cmake automake libc6-dbg From 89edd75aeb4252d4b422fb85b5008806493de86d Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Mon, 7 Jun 2021 20:49:13 +0200 Subject: [PATCH 168/496] Added regression testing using github actions and earthly --- .github/workflows/benchmarks.yml | 12 ++++++++++-- .gitignore | 3 +++ Earthfile | 3 +++ 3 files changed, 16 insertions(+), 2 deletions(-) diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index 967db61cc0..e2b4da22fe 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -15,10 +15,18 @@ jobs: steps: - uses: actions/checkout@v2 with: - clean: "true" + ref: "trunk" # benchmarking on trunk first in order to compare results + clean: "false" # we want to keep the benchmark folder - name: Earthly version run: earthly --version - - name: install dependencies, build, cd cli, benchmark with criterion + - name: on trunk; install dependencies, build, cd cli, benchmark with criterion + run: ./ci/safe-earthly.sh +bench-roc + + - uses: actions/checkout@v2 + with: + clean: "true" + + - name: on current branch; install dependencies, build, cd cli, benchmark with criterion run: ./ci/safe-earthly.sh +bench-roc diff --git a/.gitignore b/.gitignore index 10d627c503..a144d06074 100644 --- a/.gitignore +++ b/.gitignore @@ -27,3 +27,6 @@ editor/benches/resources/500_lines.roc # rust cache (sccache folder) sccache_dir +# criterion for benchmark results +criterion + diff --git a/Earthfile b/Earthfile index d3f04bfadd..929c2769f7 100644 --- a/Earthfile +++ b/Earthfile @@ -115,7 +115,10 @@ bench-roc: FROM +copy-dirs-and-cache ENV RUST_BACKTRACE=full RUN cargo criterion -V + # get benchmark results from trunk if they exist + COPY --dir --if-exists criterion ./target # ulimit -s unlimited to prevent stack overflow errors for CFold RUN --privileged --mount=type=cache,target=$SCCACHE_DIR \ ulimit -s unlimited && cd cli && cargo criterion && sccache --show-stats + SAVE ARTIFACT target/criterion AS LOCAL criterion From 6850fd4ed9304a688212839219cc485add25ebaa Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 7 Jun 2021 21:04:09 +0200 Subject: [PATCH 169/496] formatdict.zig --- compiler/builtins/bitcode/src/dict.zig | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/compiler/builtins/bitcode/src/dict.zig b/compiler/builtins/bitcode/src/dict.zig index 84f7bf6980..6b038f6ffe 100644 --- a/compiler/builtins/bitcode/src/dict.zig +++ b/compiler/builtins/bitcode/src/dict.zig @@ -20,13 +20,9 @@ const Slot = packed enum(u8) { PreviouslyFilled, }; -const MaybeIndexTag = enum { - index, not_found -}; +const MaybeIndexTag = enum { index, not_found }; -const MaybeIndex = union(MaybeIndexTag) { - index: usize, not_found: void -}; +const MaybeIndex = union(MaybeIndexTag) { index: usize, not_found: void }; fn nextSeed(seed: u64) u64 { // TODO is this a valid way to get a new seed? are there better ways? From 4da87d9a9b98bef695db428a517c6f93bde2a36f Mon Sep 17 00:00:00 2001 From: Jared Ramirez Date: Mon, 7 Jun 2021 12:04:36 -0700 Subject: [PATCH 170/496] Handle negative better --- compiler/builtins/bitcode/src/dec.zig | 103 +++++++++++++++++++------- 1 file changed, 77 insertions(+), 26 deletions(-) diff --git a/compiler/builtins/bitcode/src/dec.zig b/compiler/builtins/bitcode/src/dec.zig index 56a2237bab..1eb794f6cf 100644 --- a/compiler/builtins/bitcode/src/dec.zig +++ b/compiler/builtins/bitcode/src/dec.zig @@ -111,34 +111,55 @@ pub const RocDec = struct { } pub fn toStr(self: RocDec) ?RocStr { - var digit_bytes: [max_digits]u8 = undefined; - var num_digits_formatted = std.fmt.formatIntBuf(digit_bytes[0..], self.num, 10, false, .{}); + // Check if this Dec is negative, and if so convert to positive + // We will handle adding the '-' later + const is_negative = self.num < 0; + const num = if (is_negative) std.math.negate(self.num) catch { + std.debug.panic("TODO runtime exception failing to negate", .{}); + } else self.num; + // Format the backing i128 into an array of digits (u8s) + var digit_bytes: [max_digits + 1]u8 = undefined; + var num_digits_formatted = std.fmt.formatIntBuf(digit_bytes[0..], num, 10, false, .{}); + + // If self < 1, then pad digit_bytes with '0' to be at least 18 digits + if (num_digits_formatted < decimal_places) { + var diff = decimal_places - num_digits_formatted; + var padded_digit_bytes: [max_digits + 1]u8 = undefined; + var index: usize = 0; + + while (index < decimal_places) { + if (index < diff) { + padded_digit_bytes[index] = '0'; + } else { + padded_digit_bytes[index] = digit_bytes[index - diff]; + } + index += 1; + } + num_digits_formatted = num_digits_formatted + diff; + digit_bytes = padded_digit_bytes; + } + + // Get the slice of the part before the decimal + // If this is empty, then hardcode a '0' var before_digits_num_raw: usize = undefined; - var before_digits_num: usize = undefined; var before_digits_slice: []const u8 = undefined; if (num_digits_formatted > decimal_places) { before_digits_num_raw = num_digits_formatted - decimal_places; - - if (before_digits_num_raw == 1 and digit_bytes[0] == '-') { - before_digits_num = 2; - before_digits_slice = "-0"[0..]; - } else { - before_digits_num = before_digits_num_raw; - before_digits_slice = digit_bytes[0..before_digits_num_raw]; - } + before_digits_slice = digit_bytes[0..before_digits_num_raw]; } else { before_digits_num_raw = 0; - before_digits_num = 1; - before_digits_slice = "0"[0..]; + before_digits_slice = "0"; } + // Figure out the index where the trailing zeros start var index = decimal_places - 1; var trim_index: ?usize = null; var is_consecutive_zero = true; while (index != 0) { var digit = digit_bytes[before_digits_num_raw + index]; - if (digit == '0' and is_consecutive_zero) { + // 48 => '0', 170 => '' + if ((digit == 48 or digit == 170) and is_consecutive_zero) { trim_index = index; } else { is_consecutive_zero = false; @@ -146,18 +167,31 @@ pub const RocDec = struct { index -= 1; } - var after_digits_num = if (trim_index) |i| i else decimal_places; + // Get the slice of the part afterthe decimal var after_digits_slice: []const u8 = undefined; - after_digits_slice = digit_bytes[before_digits_num_raw..(before_digits_num_raw + after_digits_num)]; + after_digits_slice = digit_bytes[before_digits_num_raw..(before_digits_num_raw + if (trim_index) |i| i else decimal_places)]; - // `+ 1` in here to account for the '.' - // `before_digits_num` already includes the '-' - var str_len: usize = before_digits_num + 1 + after_digits_num; + // Make the RocStr + + var sign_len: usize = if (is_negative) 1 else 0; + var dot_len: usize = 1; + var str_len: usize = sign_len + before_digits_slice.len + dot_len + after_digits_slice.len; // TODO: Ideally we'd use [str_len]u8 here, but Zig gives an error if we do that. // [max_digits + 2]u8 here to account for '.' and '-', aka the max possible length of the string var str_bytes: [max_digits + 2]u8 = undefined; - _ = std.fmt.bufPrint(str_bytes[0 .. str_len + 1], "{s}.{s}", .{ before_digits_slice, after_digits_slice }) catch unreachable; + + // Join the whole number slice & the decimal slice together + // The format template arg in bufPrint is `comptime`, so we have to repeate the whole statment in each branch + if (is_negative) { + _ = std.fmt.bufPrint(str_bytes[0 .. str_len + 1], "-{s}.{s}", .{ before_digits_slice, after_digits_slice }) catch { + std.debug.panic("TODO runtime exception failing to print slices", .{}); + }; + } else { + _ = std.fmt.bufPrint(str_bytes[0 .. str_len + 1], "{s}.{s}", .{ before_digits_slice, after_digits_slice }) catch { + std.debug.panic("TODO runtime exception failing to print slices", .{}); + }; + } return RocStr.init(&str_bytes, str_len); } @@ -535,13 +569,21 @@ test "toStr: -0.45" { try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); } -// test "toStr: 0.00045" { -// var dec: RocDec = .{ .num = 000450000000000000 }; -// var res_roc_str = dec.toStr(); +test "toStr: 0.00045" { + var dec: RocDec = .{ .num = 000450000000000000 }; + var res_roc_str = dec.toStr(); -// const res_slice: []const u8 = "0.00045"[0..]; -// try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); -// } + const res_slice: []const u8 = "0.00045"[0..]; + try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); +} + +test "toStr: -0.00045" { + var dec: RocDec = .{ .num = -000450000000000000 }; + var res_roc_str = dec.toStr(); + + const res_slice: []const u8 = "-0.00045"[0..]; + try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); +} test "toStr: -111.123456789" { var dec: RocDec = .{ .num = -111123456789000000000 }; @@ -567,6 +609,15 @@ test "toStr: 123.111111111111 (big str)" { try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); } +// TODO: This test passes, leaks memory +test "toStr: 123.111111111111111111 (max number of decimals)" { + var dec: RocDec = .{ .num = 123111111111111111111 }; + var res_roc_str = dec.toStr(); + + const res_slice: []const u8 = "123.111111111111111111"[0..]; + try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); +} + test "add: 0" { var dec: RocDec = .{ .num = 0 }; From e5b2e8965cf8681bce189abd213c2da40a34b880 Mon Sep 17 00:00:00 2001 From: Jared Ramirez Date: Mon, 7 Jun 2021 12:08:18 -0700 Subject: [PATCH 171/496] Simplify failing case --- compiler/builtins/bitcode/src/dec.zig | 18 +++++++----------- 1 file changed, 7 insertions(+), 11 deletions(-) diff --git a/compiler/builtins/bitcode/src/dec.zig b/compiler/builtins/bitcode/src/dec.zig index 1eb794f6cf..3e209f423e 100644 --- a/compiler/builtins/bitcode/src/dec.zig +++ b/compiler/builtins/bitcode/src/dec.zig @@ -601,23 +601,19 @@ test "toStr: 123.1111111" { try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); } -test "toStr: 123.111111111111 (big str)" { - var dec: RocDec = .{ .num = 123111111111110000000 }; - var res_roc_str = dec.toStr(); - - const res_slice: []const u8 = "123.11111111111"[0..]; - try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); -} - // TODO: This test passes, leaks memory -test "toStr: 123.111111111111111111 (max number of decimals)" { - var dec: RocDec = .{ .num = 123111111111111111111 }; +test "toStr: 123.1111111111111 (big str)" { + var dec: RocDec = .{ .num = 123111111111111000000 }; var res_roc_str = dec.toStr(); - const res_slice: []const u8 = "123.111111111111111111"[0..]; + const res_slice: []const u8 = "123.111111111111"[0..]; try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); } +// TODO: Add toStr tests for edge cases: +// 1. Max number of decimal places +// 2. Max number of digits + test "add: 0" { var dec: RocDec = .{ .num = 0 }; From ebe273af4dcd8af821d944655fe3050e41609895 Mon Sep 17 00:00:00 2001 From: rvcas Date: Mon, 7 Jun 2021 19:07:36 -0400 Subject: [PATCH 172/496] chore: rename nix bin script --- nix/bin/{llvm-as-10 => llvm-as-12} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename nix/bin/{llvm-as-10 => llvm-as-12} (100%) diff --git a/nix/bin/llvm-as-10 b/nix/bin/llvm-as-12 similarity index 100% rename from nix/bin/llvm-as-10 rename to nix/bin/llvm-as-12 From d4ff37da185cfbf013f89f046b0bb3b77c98e66c Mon Sep 17 00:00:00 2001 From: rvcas Date: Mon, 7 Jun 2021 19:39:53 -0400 Subject: [PATCH 173/496] chore: update building from source LLVM version --- BUILDING_FROM_SOURCE.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/BUILDING_FROM_SOURCE.md b/BUILDING_FROM_SOURCE.md index d97a3fe396..0bbd5fdda8 100644 --- a/BUILDING_FROM_SOURCE.md +++ b/BUILDING_FROM_SOURCE.md @@ -52,7 +52,7 @@ If you prefer a package manager, you can try the following: If you want to install it manually, you can also download Zig directly [here](https://ziglang.org/download/). Just make sure you download the right version, the bleeding edge master build is the first download link on this page. ### LLVM -**version: 10.0.x** +**version: 12.0.x** For Ubuntu and Debian, you can use the `Automatic installation script` at [apt.llvm.org](https://apt.llvm.org): ``` From 3f4a847bc950c53ad63dcaae28709f98b446be7b Mon Sep 17 00:00:00 2001 From: Jared Ramirez Date: Mon, 7 Jun 2021 16:50:23 -0700 Subject: [PATCH 174/496] Fix memory leaked test; Add extra edge case tests --- compiler/builtins/bitcode/src/dec.zig | 36 +++++++++++++++++++++++---- 1 file changed, 31 insertions(+), 5 deletions(-) diff --git a/compiler/builtins/bitcode/src/dec.zig b/compiler/builtins/bitcode/src/dec.zig index 3e209f423e..7271e46c5b 100644 --- a/compiler/builtins/bitcode/src/dec.zig +++ b/compiler/builtins/bitcode/src/dec.zig @@ -8,7 +8,8 @@ pub const RocDec = struct { num: i128, pub const decimal_places: comptime u32 = 18; - const max_digits: comptime u32 = 39; + pub const whole_number_places: comptime u32 = 21; + const max_digits: comptime u32 = decimal_places + whole_number_places; pub const min: comptime RocDec = .{ .num = math.minInt(i128) }; pub const max: comptime RocDec = .{ .num = math.maxInt(i128) }; @@ -601,18 +602,43 @@ test "toStr: 123.1111111" { try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); } -// TODO: This test passes, leaks memory test "toStr: 123.1111111111111 (big str)" { var dec: RocDec = .{ .num = 123111111111111000000 }; var res_roc_str = dec.toStr(); + errdefer res_roc_str.?.deinit(); + defer res_roc_str.?.deinit(); const res_slice: []const u8 = "123.111111111111"[0..]; try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); } -// TODO: Add toStr tests for edge cases: -// 1. Max number of decimal places -// 2. Max number of digits +test "toStr: 123.111111111111444444 (max number of decimal places)" { + var dec: RocDec = .{ .num = 123111111111111444444 }; + var res_roc_str = dec.toStr(); + errdefer res_roc_str.?.deinit(); + defer res_roc_str.?.deinit(); + + const res_slice: []const u8 = "123.111111111111444444"[0..]; + try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); +} + +test "toStr: 12345678912345678912.111111111111111111 (max number of digits)" { + var dec: RocDec = .{ .num = 12345678912345678912111111111111111111 }; + var res_roc_str = dec.toStr(); + errdefer res_roc_str.?.deinit(); + defer res_roc_str.?.deinit(); + + const res_slice: []const u8 = "12345678912345678912.111111111111111111"[0..]; + try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); +} + +test "toStr: 0" { + var dec: RocDec = .{ .num = 0 }; + var res_roc_str = dec.toStr(); + + const res_slice: []const u8 = "0.0"[0..]; + try expectEqualSlices(u8, res_slice, res_roc_str.?.asSlice()); +} test "add: 0" { var dec: RocDec = .{ .num = 0 }; From 0dc6d5b74bb59cf37405065b41bbb757c3661ad5 Mon Sep 17 00:00:00 2001 From: rvcas Date: Mon, 7 Jun 2021 20:33:57 -0400 Subject: [PATCH 175/496] chore: update llvm version in shell.nix --- shell.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/shell.nix b/shell.nix index fc84e9beb2..28d9af7b5f 100644 --- a/shell.nix +++ b/shell.nix @@ -42,7 +42,7 @@ let xorg.libxcb ]; - llvmPkgs = pkgs.llvmPackages_10; + llvmPkgs = pkgs.llvmPackages_12; zig = import ./nix/zig.nix { inherit pkgs; }; @@ -79,7 +79,7 @@ pkgs.mkShell buildInputs = inputs ++ darwinInputs ++ linuxInputs; # Additional Env vars - LLVM_SYS_100_PREFIX = "${llvmPkgs.llvm}"; + LLVM_SYS_120_PREFIX = "${llvmPkgs.llvm}"; LD_LIBRARY_PATH = with pkgs; lib.makeLibraryPath From 024c66685b00a0c4b3664a9280a0bd2ed94ecd38 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Mon, 7 Jun 2021 21:26:10 -0400 Subject: [PATCH 176/496] Verify no git changes at the end of CI run --- Earthfile | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/Earthfile b/Earthfile index d3f04bfadd..57cd659b59 100644 --- a/Earthfile +++ b/Earthfile @@ -105,11 +105,23 @@ test-rust: RUN --mount=type=cache,target=$SCCACHE_DIR \ cargo test --release && sccache --show-stats +verify-no-git-changes: + FROM +test-rust + # If running tests caused anything to be changed or added (without being + # included in a .gitignore somewhere), fail the build! + # + # How it works: the `git ls-files` command lists all the modified or + # uncommitted files in the working tree, the `| grep -E .` command returns a + # zero exit code if it listed any files and nonzero otherwise (which is the + # opposite of what we want), and the `!` at the start inverts the exit code. + RUN ! git ls-files --deleted --modified --others --exclude-standard | grep -E . + test-all: BUILD +test-zig BUILD +check-rustfmt BUILD +check-clippy BUILD +test-rust + BUILD +verify-no-git-changes bench-roc: FROM +copy-dirs-and-cache From 9cb10269331cefbb51f6158cabef352a9fffcde5 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Mon, 7 Jun 2021 21:26:42 -0400 Subject: [PATCH 177/496] Don't show edit CLI command when not building editor --- cli/src/lib.rs | 25 +++++++++++++++---------- 1 file changed, 15 insertions(+), 10 deletions(-) diff --git a/cli/src/lib.rs b/cli/src/lib.rs index 664c56908e..69611d6787 100644 --- a/cli/src/lib.rs +++ b/cli/src/lib.rs @@ -30,7 +30,7 @@ pub const DIRECTORY_OR_FILES: &str = "DIRECTORY_OR_FILES"; pub const ARGS_FOR_APP: &str = "ARGS_FOR_APP"; pub fn build_app<'a>() -> App<'a> { - App::new("roc") + let app = App::new("roc") .version(crate_version!()) .subcommand(App::new(CMD_BUILD) .about("Build a program") @@ -81,15 +81,6 @@ 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_EDIT) - .about("Launch the Roc editor") - .arg(Arg::with_name(DIRECTORY_OR_FILES) - .index(1) - .multiple(true) - .required(false) - .help("(optional) The directory or files to open on launch.") - ) - ) .subcommand( App::new(CMD_DOCS) .about("Generate documentation for Roc modules") @@ -100,7 +91,21 @@ pub fn build_app<'a>() -> App<'a> { .help("The directory or files to build documentation for") ) + ); + + if cfg!(feature = "edit") { + app.subcommand( + App::new(CMD_EDIT).about("Launch the Roc editor").arg( + Arg::with_name(DIRECTORY_OR_FILES) + .index(1) + .multiple(true) + .required(false) + .help("(optional) The directory or files to open on launch."), + ), ) + } else { + app + } } pub fn docs(files: Vec) { From 6446bf8c1a6940795241d3b07f1a1cc7e0b37236 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Mon, 7 Jun 2021 21:42:45 -0400 Subject: [PATCH 178/496] Update some docs --- compiler/builtins/docs/List.roc | 28 ++++++++++++++++++++++++++++ compiler/builtins/docs/Num.roc | 27 +++++++++++++++++++++++++++ compiler/builtins/docs/Str.roc | 33 +++++++++++++++++++++++++++++++++ 3 files changed, 88 insertions(+) diff --git a/compiler/builtins/docs/List.roc b/compiler/builtins/docs/List.roc index 2f3248da4b..f130ed35bb 100644 --- a/compiler/builtins/docs/List.roc +++ b/compiler/builtins/docs/List.roc @@ -263,6 +263,34 @@ sortDesc : List elem, (elem -> Num *) -> List elem ## ## `map` functions like this are common in Roc, and they all work similarly. ## See for example #Result.map, #Set.map, and #Map.map. +## +## ## Perfomrance +## +## `map` may run either sequentially or in parallel, depending on its workload. +## +## For example, when running `map` on a very small list, with a very quick +## transformation function, running it in parallel might actually slow it down +## because the coordination overhead would exceed the savings from parallelizing +## the work. On the other hand, a very long list might benefit massively from +## parallelization, as might a medium-sized list with a transformation funtion +## that takes a long time to run. +## +## As with all behind-the-scenes optimizations, Roc's compiler uses heuristics +## to decides whether a given `map` invocation should be parallelized. If it +## decides to parallelize it, the platform is responsible for deciding how +## many threads to devote to a particular `map` call. (The `map` call will +## always return the same answer regardless of any of this.) +## +## Assigning threads is up to the platform because the platform has full +## information about the availability of system resources, including information +## that may not be available to application code (and especially to package code +## that isn't coupled to any particular platform). +## +## For example, if the platform knows that 5 out of 8 threads are currently +## busy doing other work, then it may choose to split the `map` workload across +## the 3 remaining threads. The next time you call `map`, the platform may know +## that only 2 out of 8 threads are currently busy, so it may allocate 6 threads +## to it instead. map : List before, (before -> after) -> List after ## This works like #List.map, except it also passes the index diff --git a/compiler/builtins/docs/Num.roc b/compiler/builtins/docs/Num.roc index a17a88ebca..81a6f137a5 100644 --- a/compiler/builtins/docs/Num.roc +++ b/compiler/builtins/docs/Num.roc @@ -913,8 +913,35 @@ shrWrap : Int a, Int a -> Int a ## [Endianness](https://en.wikipedia.org/wiki/Endianness) Endi : [ Big, Little ] +## The [Endi] argument does not matter for [U8] and [I8], since they have +## only one byte. toBytes : Num *, Endi -> List U8 +## If the bytes begin with a valid #U8 number, return +## that number along with the rest of the bytes after it. +parseU8 : List U8 -> Result { val : U8, rest : List U8 } [ Expected [ NumU8 ]* List U8 ]* +parseI8 : List U8 -> Result { val : I8, rest : List U8 } [ Expected [ NumI8 ]* List U8 ]* +parseU16 : List U8, Endi -> Result { val : U16, rest : List U8 } [ Expected [ NumU16 Endi ]* (List U8) ]* +parseI16 : List U8, Endi -> Result { val : I16, rest : List U8 } [ Expected [ NumI16 Endi ]* (List U8) ]* +parseU32 : List U8, Endi -> Result { val : U32, rest : List U8 } [ Expected [ NumU32 Endi ]* (List U8) ]* +parseI32 : List U8, Endi -> Result { val : I32, rest : List U8 } [ Expected [ NumI32 Endi ]* (List U8) ]* +parseU64 : List U8, Endi -> Result { val : U64, rest : List U8 } [ Expected [ NumU64 Endi ]* (List U8) ]* +parseI64 : List U8, Endi -> Result { val : I64, rest : List U8 } [ Expected [ NumI64 Endi ]* (List U8) ]* +parseU128 : List U8, Endi -> Result { val : U128, rest : List U8 } [ Expected [ NumU128 Endi ]* (List U8) ]* +parseI128 : List U8, Endi -> Result { val : I128, rest : List U8 } [ Expected [ NumI128 Endi ]* (List U8) ]* +parseF64 : List U8, Endi -> Result { val : F64, rest : List U8 } [ Expected [ NumF64 Endi ]* (List U8) ]* +parseF32 : List U8, Endi -> Result { val : F32, rest : List U8 } [ Expected [ NumF32 Endi ]* (List U8) ]* +parseDec : List U8, Endi -> Result { val : Dec, rest : List U8 } [ Expected [ NumDec Endi ]* (List U8) ]* + +## when Num.parseBytes bytes Big is +## Ok { val: f64, rest } -> ... +## Err (ExpectedNum (Float Binary64)) -> ... +parseBytes : List U8, Endi -> Result { val : Num a, rest : List U8 } [ ExpectedNum a ]* + +## when Num.fromBytes bytes Big is +## Ok f64 -> ... +## Err (ExpectedNum (Float Binary64)) -> ... +fromBytes : List U8, Endi -> Result (Num a) [ ExpectedNum a ]* ## Comparison diff --git a/compiler/builtins/docs/Str.roc b/compiler/builtins/docs/Str.roc index f811b75271..2c61b076ab 100644 --- a/compiler/builtins/docs/Str.roc +++ b/compiler/builtins/docs/Str.roc @@ -444,6 +444,23 @@ toF64 : Str -> Result U128 [ InvalidF64 ]* toF32 : Str -> Result I128 [ InvalidF32 ]* toDec : Str -> Result Dec [ InvalidDec ]* +## If the string represents a valid number, return that number. +## +## The exact number type to look for will be inferred from usage. Here's an +## example where the `Err` branch matches `Integer Signed64`, which causes this to +## parse an [I64] because [I64] is defined as `I64 : Num [ Integer [ Signed64 ] ]`. +## +## >>> when Str.toNum "12345" is +## >>> Ok i64 -> "The I64 was: \(i64)" +## >>> Err (ExpectedNum (Integer Signed64)) -> "Not a valid I64!" +## +## If the string is exactly `"NaN"`, `"∞"`, or `"-∞"`, they will be accepted +## only when converting to [F64] or [F32] numbers, and will be translated accordingly. +## +## This never accepts numbers with underscores or commas in them. For more +## advanced options, see [parseNum]. +toNum : Str -> Result (Num a) [ ExpectedNum a ]* + ## If the string begins with a valid #U8 number, return ## that number along with the rest of the string after it. parseU8 : Str, NumParseConfig -> Result { val : U8, rest : Str } [ Expected [ NumU8 ]* Str ]* @@ -467,6 +484,22 @@ parseDec : Str, NumParseConfig -> Result { val : Dec, rest : Str } [ Expected [ parseF64 : Str, NumParseConfig -> Result { val : F64, rest : Str } [ Expected [ NumF64 ]* Str ]* parseF32 : Str, NumParseConfig -> Result { val : F32, rest : Str } [ Expected [ NumF32 ]* Str ]* +## If the string begins with an [Int] or a [finite](Num.isFinite) [Frac], return +## that number along with the rest of the string after it. +## +## The exact number type to look for will be inferred from usage. Here's an +## example where the `Err` branch matches `Float Binary64`, which causes this to +## parse an [F64] because [F64] is defined as `F64 : Num [ Fraction [ Float64 ] ]`. +## +## >>> when Str.parseNum input {} is +## >>> Ok { val: f64, rest } -> "The F64 was: \(f64)" +## >>> Err (ExpectedNum (Fraction Float64)) -> "Not a valid F64!" +## +## If the string begins with `"NaN"`, `"∞"`, and `"-∞"` (which do not represent +## [finite](Num.isFinite) numbers), they will be accepted only when parsing +## [F64] or [F32] numbers, and translated accordingly. +parseNum : Str, NumParseConfig -> Result { val : Num a, rest : Str } [ ExpectedNum a ]* + ## Notes: ## * You can allow a decimal mark for integers; they'll only parse if the numbers after it are all 0. ## * For `wholeSep`, `Required` has a payload for how many digits (e.g. "required every 3 digits") From c090e1729badfcdda072026319814450c293e74c Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Mon, 7 Jun 2021 21:51:28 -0400 Subject: [PATCH 179/496] Update macOS installation instructions --- BUILDING_FROM_SOURCE.md | 24 +++++------------------- 1 file changed, 5 insertions(+), 19 deletions(-) diff --git a/BUILDING_FROM_SOURCE.md b/BUILDING_FROM_SOURCE.md index 0bbd5fdda8..af1e8b7e0d 100644 --- a/BUILDING_FROM_SOURCE.md +++ b/BUILDING_FROM_SOURCE.md @@ -54,13 +54,15 @@ If you want to install it manually, you can also download Zig directly [here](ht ### LLVM **version: 12.0.x** +For macOS, you can install LLVM 12 using `brew install llvm@12` and then adding +`/usr/local/opt/llvm/bin` to your `PATH`. You can confirm this worked by +running `llc --version` - it should mention "LLVM version 12.0.0" at the top. + For Ubuntu and Debian, you can use the `Automatic installation script` at [apt.llvm.org](https://apt.llvm.org): ``` sudo bash -c "$(wget -O - https://apt.llvm.org/llvm.sh)" ``` -For macOS, check the troubleshooting section below. - There are also plenty of alternative options at http://releases.llvm.org/download.html ## Using Nix @@ -143,31 +145,15 @@ If you encounter `cannot find -lz` run `sudo apt install zlib1g-dev`. ### LLVM installation on macOS -By default homebrew will try to install llvm 11, which is currently -unsupported. You need to install an older version (10.0.0_3) by doing: - -``` -$ brew edit llvm - -# Replace the contents of the file with https://raw.githubusercontent.com/Homebrew/homebrew-core/6616d50fb0b24dbe30f5e975210bdad63257f517/Formula/llvm.rb - -# we expect llvm-as-10 to be present -$ ln -s /usr/local/opt/llvm/bin/{llvm-as,llvm-as-10} - -# "pinning" ensures that homebrew doesn't update it automatically -$ brew pin llvm -``` +If installing LLVM fails, it might help to run `sudo xcode-select -r` before installing again. It might also be useful to add these exports to your shell: ``` -export PATH="/usr/local/opt/llvm/bin:$PATH" export LDFLAGS="-L/usr/local/opt/llvm/lib -Wl,-rpath,/usr/local/opt/llvm/lib" export CPPFLAGS="-I/usr/local/opt/llvm/include" ``` -If installing LLVM still fails, it might help to run `sudo xcode-select -r` before installing again. - ### LLVM installation on Windows Installing LLVM's prebuilt binaries doesn't seem to be enough for the `llvm-sys` crate that Roc depends on, so I had to build LLVM from source From 5dc0870f6aafab36c6cc4d0165d96c51524ee7fb Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Mon, 7 Jun 2021 21:51:37 -0400 Subject: [PATCH 180/496] Use vanilla llvm-as --- compiler/build/src/program.rs | 2 +- compiler/builtins/build.rs | 6 +----- nix/bin/llvm-as-12 | 2 -- shell.nix | 7 ------- 4 files changed, 2 insertions(+), 15 deletions(-) delete mode 100755 nix/bin/llvm-as-12 diff --git a/compiler/build/src/program.rs b/compiler/build/src/program.rs index de8ba19374..1dc5156184 100644 --- a/compiler/build/src/program.rs +++ b/compiler/build/src/program.rs @@ -204,7 +204,7 @@ pub fn gen_from_mono_module( } // assemble the .ll into a .bc - let _ = Command::new("llvm-as-12") + let _ = Command::new("llvm-as") .env_clear() .args(&[ app_ll_dbg_file.to_str().unwrap(), diff --git a/compiler/builtins/build.rs b/compiler/builtins/build.rs index 7df5952d34..05f5aa284c 100644 --- a/compiler/builtins/build.rs +++ b/compiler/builtins/build.rs @@ -56,11 +56,7 @@ fn main() { let dest_bc = dest_bc_path.to_str().expect("Invalid dest bc path"); println!("Compiling bitcode to: {}", dest_bc); - run_command( - build_script_dir_path, - "llvm-as-12", - &[dest_ir, "-o", dest_bc], - ); + run_command(build_script_dir_path, "llvm-as", &[dest_ir, "-o", dest_bc]); get_zig_files(bitcode_path.as_path(), &|path| { let path: &Path = path; diff --git a/nix/bin/llvm-as-12 b/nix/bin/llvm-as-12 deleted file mode 100755 index 65839a9b5a..0000000000 --- a/nix/bin/llvm-as-12 +++ /dev/null @@ -1,2 +0,0 @@ -#!/bin/sh -llvm-as "$@" diff --git a/shell.nix b/shell.nix index 28d9af7b5f..43dee8500f 100644 --- a/shell.nix +++ b/shell.nix @@ -96,11 +96,4 @@ pkgs.mkShell ] ++ linuxInputs ); - - # Non Nix llvm installs names the bin llvm-as-${version}, so we - # alias `llvm` to `llvm-as-${version}` here. - # This the name of the file in nix/bin will need to be updated whenever llvm is updated - shellHook = '' - export PATH="$PATH:$PWD/nix/bin" - ''; } From 5010ec595878f1038ce5bebdc4a2503d3c5b1361 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Mon, 7 Jun 2021 22:22:24 -0400 Subject: [PATCH 181/496] Use vanilla llvm-as in Earthfile --- Earthfile | 1 + 1 file changed, 1 insertion(+) diff --git a/Earthfile b/Earthfile index 05dd878c35..4c1cd88b69 100644 --- a/Earthfile +++ b/Earthfile @@ -22,6 +22,7 @@ install-zig-llvm-valgrind-clippy-rustfmt: RUN chmod +x llvm.sh RUN ./llvm.sh 12 RUN ln -s /usr/bin/clang-12 /usr/bin/clang + RUN ln -s /usr/bin/llvm-as-12 /usr/bin/llvm-as # use lld as linker RUN ln -s /usr/bin/lld-12 /usr/bin/ld.lld ENV RUSTFLAGS="-C link-arg=-fuse-ld=lld -C target-cpu=native" From 65b469199d1201e0e13e35a9d7067dfb314b17bc Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Mon, 7 Jun 2021 22:24:32 -0400 Subject: [PATCH 182/496] Update Linux installation instructions. --- BUILDING_FROM_SOURCE.md | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/BUILDING_FROM_SOURCE.md b/BUILDING_FROM_SOURCE.md index af1e8b7e0d..d055e8612c 100644 --- a/BUILDING_FROM_SOURCE.md +++ b/BUILDING_FROM_SOURCE.md @@ -63,7 +63,18 @@ For Ubuntu and Debian, you can use the `Automatic installation script` at [apt.l sudo bash -c "$(wget -O - https://apt.llvm.org/llvm.sh)" ``` -There are also plenty of alternative options at http://releases.llvm.org/download.html +If you use this script, you'll need to add `clang` and `llvm-as` to your `PATH`. +By default, the script installs them as `llvm-as-12` and `clang-12`, +respectively. You can address this with symlinks like so: + +``` +sudo ln -s /usr/bin/clang-12 /usr/bin/clang +``` +``` +sudo ln -s /usr/bin/llvm-as-12 /usr/bin/llvm-as +```` + +There are also alternative installation options at http://releases.llvm.org/download.html ## Using Nix From bff9e23a64afbfa04407f4ffa5a788b13b558121 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Tue, 8 Jun 2021 16:27:12 +0200 Subject: [PATCH 183/496] made placeholder criterion dir to fix earthly issue --- .gitignore | 3 --- criterion/LEAVE_ME_HERE.txt | 1 + 2 files changed, 1 insertion(+), 3 deletions(-) create mode 100644 criterion/LEAVE_ME_HERE.txt diff --git a/.gitignore b/.gitignore index a144d06074..10d627c503 100644 --- a/.gitignore +++ b/.gitignore @@ -27,6 +27,3 @@ editor/benches/resources/500_lines.roc # rust cache (sccache folder) sccache_dir -# criterion for benchmark results -criterion - diff --git a/criterion/LEAVE_ME_HERE.txt b/criterion/LEAVE_ME_HERE.txt new file mode 100644 index 0000000000..f1fc0c5a2e --- /dev/null +++ b/criterion/LEAVE_ME_HERE.txt @@ -0,0 +1 @@ +The criterion dir needs to be non-empty until this [earthly issue](https://github.com/earthly/earthly/issues/588) is resolved. \ No newline at end of file From a1d87c4aeaa4a79e7db0b45c43dc4470076d7ad5 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Tue, 8 Jun 2021 16:56:29 +0200 Subject: [PATCH 184/496] clean repo at the correct position --- .github/workflows/benchmarks.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index e2b4da22fe..5b7055a09a 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -16,7 +16,7 @@ jobs: - uses: actions/checkout@v2 with: ref: "trunk" # benchmarking on trunk first in order to compare results - clean: "false" # we want to keep the benchmark folder + clean: "true" - name: Earthly version run: earthly --version @@ -26,7 +26,7 @@ jobs: - uses: actions/checkout@v2 with: - clean: "true" + clean: "false" # we want to keep the benchmark(criterion) folder - name: on current branch; install dependencies, build, cd cli, benchmark with criterion run: ./ci/safe-earthly.sh +bench-roc From ff7755c94cd40c0feaba7878789d152d03dec1df Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Tue, 8 Jun 2021 17:36:22 +0200 Subject: [PATCH 185/496] Clean benchmark run --- Earthfile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Earthfile b/Earthfile index 8b41c62beb..cff3009e6f 100644 --- a/Earthfile +++ b/Earthfile @@ -136,7 +136,7 @@ bench-roc: # get benchmark results from trunk if they exist COPY --dir --if-exists criterion ./target # ulimit -s unlimited to prevent stack overflow errors for CFold - RUN --privileged --mount=type=cache,target=$SCCACHE_DIR \ + RUN --no-cache --privileged --mount=type=cache,target=$SCCACHE_DIR \ ulimit -s unlimited && cd cli && cargo criterion && sccache --show-stats SAVE ARTIFACT target/criterion AS LOCAL criterion From 60672ac519880e8bdc6abf16cac3353f287d3e4d Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Tue, 8 Jun 2021 17:37:33 +0200 Subject: [PATCH 186/496] make zig fmt fail louder --- compiler/builtins/bitcode/run-tests.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/builtins/bitcode/run-tests.sh b/compiler/builtins/bitcode/run-tests.sh index bf13fccb8f..92bb9fae6d 100755 --- a/compiler/builtins/bitcode/run-tests.sh +++ b/compiler/builtins/bitcode/run-tests.sh @@ -6,4 +6,4 @@ set -euxo pipefail zig build test # fmt every zig -find src/*.zig -type f -print0 | xargs -n 1 -0 zig fmt --check +find src/*.zig -type f -print0 | xargs -n 1 -0 zig fmt --check || (echo "zig fmt --check FAILED! Check the previuous lines to see which files were improperly formatted." && exit 1) From 39a81abc95c346009395bf9d658cfe2f7875add5 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Tue, 8 Jun 2021 18:09:47 +0200 Subject: [PATCH 187/496] can't test with trunk --- .github/workflows/benchmarks.yml | 2 +- Earthfile | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index 5b7055a09a..5f644a8eb6 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -15,7 +15,7 @@ jobs: steps: - uses: actions/checkout@v2 with: - ref: "trunk" # benchmarking on trunk first in order to compare results + ref: "ff7755c94cd40c0feaba7878789d152d03dec1df" # benchmarking on trunk first in order to compare results clean: "true" - name: Earthly version diff --git a/Earthfile b/Earthfile index cff3009e6f..da3ba5aac4 100644 --- a/Earthfile +++ b/Earthfile @@ -135,6 +135,7 @@ bench-roc: RUN cargo criterion -V # get benchmark results from trunk if they exist COPY --dir --if-exists criterion ./target + RUN ls ./target/criterion # ulimit -s unlimited to prevent stack overflow errors for CFold RUN --no-cache --privileged --mount=type=cache,target=$SCCACHE_DIR \ ulimit -s unlimited && cd cli && cargo criterion && sccache --show-stats From afa6e58b54cf781add8863442ea911205fac056b Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Tue, 8 Jun 2021 20:15:13 +0200 Subject: [PATCH 188/496] Put nightly benches in separate crate so they don't have to be commented out. --- Cargo.lock | 245 ++++++++++++++++++------ Cargo.toml | 3 +- nightly_benches/Cargo.toml | 16 ++ nightly_benches/benches/events_bench.rs | 94 +++++++++ nightly_benches/rust-toolchain | 1 + nightly_benches/src/main.rs | 3 + 6 files changed, 298 insertions(+), 64 deletions(-) create mode 100644 nightly_benches/Cargo.toml create mode 100644 nightly_benches/benches/events_bench.rs create mode 100644 nightly_benches/rust-toolchain create mode 100644 nightly_benches/src/main.rs diff --git a/Cargo.lock b/Cargo.lock index 65fe5b05b0..717f1b9c68 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -47,7 +47,7 @@ checksum = "43bb833f0bf979d8475d38fbf09ed3b8a55e1885fe93ad3f93239fc6a4f17b98" dependencies = [ "getrandom 0.2.3", "once_cell", - "version_check", + "version_check 0.9.3", ] [[package]] @@ -137,7 +137,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8" dependencies = [ "hermit-abi", - "libc", + "libc 0.2.95", "winapi 0.3.9", ] @@ -162,7 +162,7 @@ dependencies = [ "addr2line", "cc", "cfg-if 1.0.0", - "libc", + "libc 0.2.95", "miniz_oxide", "object", "rustc-demangle", @@ -183,6 +183,12 @@ version = "0.6.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb" +[[package]] +name = "bit_field" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dcb6dd1c2376d2e096796e234a70e17e94cc2d5d54ff8ce42b28cef1d0d359a4" + [[package]] name = "bitflags" version = "1.2.1" @@ -434,7 +440,7 @@ dependencies = [ "core-foundation 0.9.1", "core-graphics 0.22.2", "foreign-types", - "libc", + "libc 0.2.95", "objc", ] @@ -449,7 +455,7 @@ dependencies = [ "core-foundation 0.9.1", "core-graphics-types", "foreign-types", - "libc", + "libc 0.2.95", "objc", ] @@ -531,7 +537,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "57d24c7a13c43e870e37c1556b74555437870a04514f7685f5b354e090567171" dependencies = [ "core-foundation-sys 0.7.0", - "libc", + "libc 0.2.95", ] [[package]] @@ -541,7 +547,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0a89e2ae426ea83155dccf10c0fa6b1463ef6d5fcb44cee0b224a408fa640a62" dependencies = [ "core-foundation-sys 0.8.2", - "libc", + "libc 0.2.95", ] [[package]] @@ -565,7 +571,7 @@ dependencies = [ "bitflags", "core-foundation 0.7.0", "foreign-types", - "libc", + "libc 0.2.95", ] [[package]] @@ -578,7 +584,7 @@ dependencies = [ "core-foundation 0.9.1", "core-graphics-types", "foreign-types", - "libc", + "libc 0.2.95", ] [[package]] @@ -590,7 +596,7 @@ dependencies = [ "bitflags", "core-foundation 0.9.1", "foreign-types", - "libc", + "libc 0.2.95", ] [[package]] @@ -602,7 +608,7 @@ dependencies = [ "cfg-if 0.1.10", "core-foundation-sys 0.7.0", "core-graphics 0.19.2", - "libc", + "libc 0.2.95", "objc", ] @@ -612,7 +618,7 @@ version = "0.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ed00c67cb5d0a7d64a44f6ad2668db7e7530311dd53ea79bcd4fb022c64911c8" dependencies = [ - "libc", + "libc 0.2.95", ] [[package]] @@ -649,6 +655,15 @@ dependencies = [ "walkdir", ] +[[package]] +name = "criterion-perf-events" +version = "0.1.3" +source = "git+https://github.com/Anton-4/criterion-perf-events#e30bbb54fb00881515a9ae78b00a2a01ec5c376f" +dependencies = [ + "criterion", + "perfcnt", +] + [[package]] name = "criterion-plot" version = "0.4.3" @@ -914,7 +929,7 @@ version = "0.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d" dependencies = [ - "libc", + "libc 0.2.95", "redox_users", "winapi 0.3.9", ] @@ -1022,7 +1037,7 @@ checksum = "cd3aec53de10fe96d7d8c565eb17f2c687bb5518a2ec453b5b1252964526abe0" dependencies = [ "cfg-if 1.0.0", "crc32fast", - "libc", + "libc 0.2.95", "miniz_oxide", ] @@ -1188,7 +1203,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "501466ecc8a30d1d3b7fc9229b122b2ce8ed6e9d9223f1138d4babb253e51817" dependencies = [ "typenum", - "version_check", + "version_check 0.9.3", ] [[package]] @@ -1198,7 +1213,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce" dependencies = [ "cfg-if 1.0.0", - "libc", + "libc 0.2.95", "wasi 0.9.0+wasi-snapshot-preview1", ] @@ -1209,7 +1224,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753" dependencies = [ "cfg-if 1.0.0", - "libc", + "libc 0.2.95", "wasi 0.10.2+wasi-snapshot-preview1", ] @@ -1495,7 +1510,7 @@ version = "0.1.18" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "322f4de77956e22ed0e5032c359a0f1273f1f7f0d79bfa3b8ffbc730d7fbcc5c" dependencies = [ - "libc", + "libc 0.2.95", ] [[package]] @@ -1521,7 +1536,7 @@ dependencies = [ "rand_xoshiro", "sized-chunks 0.5.3", "typenum", - "version_check", + "version_check 0.9.3", ] [[package]] @@ -1535,7 +1550,7 @@ dependencies = [ "rand_xoshiro", "sized-chunks 0.6.5", "typenum", - "version_check", + "version_check 0.9.3", ] [[package]] @@ -1549,7 +1564,7 @@ dependencies = [ "rand_xoshiro", "sized-chunks 0.5.3", "typenum", - "version_check", + "version_check 0.9.3", ] [[package]] @@ -1563,7 +1578,7 @@ dependencies = [ "rand_xoshiro", "sized-chunks 0.6.5", "typenum", - "version_check", + "version_check 0.9.3", ] [[package]] @@ -1622,7 +1637,7 @@ source = "git+https://github.com/rtfeldman/inkwell?tag=llvm10-0.release5#f0a32d3 dependencies = [ "either", "inkwell_internals", - "libc", + "libc 0.2.95", "llvm-sys", "once_cell", "parking_lot", @@ -1666,7 +1681,7 @@ version = "0.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b2b3ea6ff95e175473f8ffe6a7eb7c00d054240321b84c57051175fe3c1e075e" dependencies = [ - "libc", + "libc 0.2.95", ] [[package]] @@ -1705,7 +1720,7 @@ version = "0.1.22" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "972f5ae5d1cb9c6ae417789196c803205313edde988685da5e3aae0827b9e7fd" dependencies = [ - "libc", + "libc 0.2.95", ] [[package]] @@ -1733,7 +1748,7 @@ version = "4.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8c2352bd1d0bceb871cb9d40f24360c8133c11d7486b68b5381c1dd1a32015e3" dependencies = [ - "libc", + "libc 0.2.95", "libloading 0.7.0", ] @@ -1755,6 +1770,12 @@ version = "1.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55" +[[package]] +name = "libc" +version = "0.1.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e32a70cf75e5846d53a673923498228bbec6a8624708a9ea5645f075d6276122" + [[package]] name = "libc" version = "0.2.95" @@ -1795,7 +1816,7 @@ checksum = "15d9c00ce56221b2150e2d4d51887ff139fce5a0e50346c744861d1e66d2f7c4" dependencies = [ "cc", "lazy_static", - "libc", + "libc 0.2.95", "regex", "semver 0.9.0", ] @@ -1824,7 +1845,7 @@ version = "0.0.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "62bb907fe88d54d8d9ce32a3cceab4218ed2f6b7d35617cafe9adf84e43919cb" dependencies = [ - "libc", + "libc 0.2.95", ] [[package]] @@ -1851,7 +1872,7 @@ version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d9b70ca2a6103ac8b665dc150b142ef0e4e89df640c9e6cf295d189c3caebe5a" dependencies = [ - "libc", + "libc 0.2.95", ] [[package]] @@ -1907,7 +1928,7 @@ dependencies = [ "fuchsia-zircon-sys", "iovec", "kernel32-sys", - "libc", + "libc 0.2.95", "log", "miow", "net2", @@ -1939,6 +1960,16 @@ dependencies = [ "ws2_32-sys", ] +[[package]] +name = "mmap" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0bc85448a6006dd2ba26a385a564a8a0f1f2c7e78c70f1a70b2e0f4af286b823" +dependencies = [ + "libc 0.1.12", + "tempdir", +] + [[package]] name = "morphic_lib" version = "0.1.0" @@ -1984,7 +2015,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bdf399b8b7a39c6fb153c4ec32c72fd5fe789df24a647f229c239aa7adb15241" dependencies = [ "lazy_static", - "libc", + "libc 0.2.95", "log", "ndk", "ndk-macro", @@ -2017,10 +2048,20 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "391630d12b68002ae1e25e8f974306474966550ad82dac6886fb8910c19568ae" dependencies = [ "cfg-if 0.1.10", - "libc", + "libc 0.2.95", "winapi 0.3.9", ] +[[package]] +name = "nightly_benches" +version = "0.1.0" +dependencies = [ + "cli_utils", + "criterion", + "criterion-perf-events", + "perfcnt", +] + [[package]] name = "nix" version = "0.17.0" @@ -2030,7 +2071,7 @@ dependencies = [ "bitflags", "cc", "cfg-if 0.1.10", - "libc", + "libc 0.2.95", "void", ] @@ -2043,7 +2084,7 @@ dependencies = [ "bitflags", "cc", "cfg-if 0.1.10", - "libc", + "libc 0.2.95", ] [[package]] @@ -2055,7 +2096,17 @@ dependencies = [ "bitflags", "cc", "cfg-if 1.0.0", - "libc", + "libc 0.2.95", +] + +[[package]] +name = "nom" +version = "4.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2ad2a91a8e869eeb30b9cb3119ae87773a8f4ae617f41b1eb9c154b2905f7bd6" +dependencies = [ + "memchr", + "version_check 0.1.5", ] [[package]] @@ -2065,7 +2116,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e7413f999671bd4745a7b624bd370a569fb6bc574b23c83a3c5ed2e453f3d5e2" dependencies = [ "memchr", - "version_check", + "version_check 0.9.3", ] [[package]] @@ -2090,7 +2141,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "05499f3756671c15885fee9034446956fff3f243d6077b91e5767df161f766b3" dependencies = [ "hermit-abi", - "libc", + "libc 0.2.95", ] [[package]] @@ -2232,7 +2283,7 @@ version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "eebde548fbbf1ea81a99b128872779c437752fb99f217c45245e1a61dcd9edcd" dependencies = [ - "libc", + "libc 0.2.95", "winapi 0.3.9", ] @@ -2280,7 +2331,7 @@ dependencies = [ "backtrace", "cfg-if 1.0.0", "instant", - "libc", + "libc 0.2.95", "petgraph", "redox_syscall 0.2.8", "smallvec", @@ -2294,6 +2345,21 @@ version = "2.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e" +[[package]] +name = "perfcnt" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "88a4decf2d171c232d741ca37d590cd50d35314b7d348198e7e474e0bf34c8b4" +dependencies = [ + "bitflags", + "byteorder", + "libc 0.2.95", + "mmap", + "nom 4.2.3", + "phf", + "x86", +] + [[package]] name = "pest" version = "2.1.3" @@ -2483,7 +2549,7 @@ dependencies = [ "proc-macro2 1.0.27", "quote 1.0.9", "syn 1.0.72", - "version_check", + "version_check 0.9.3", ] [[package]] @@ -2496,7 +2562,7 @@ dependencies = [ "quote 1.0.9", "syn 1.0.72", "syn-mid", - "version_check", + "version_check 0.9.3", ] [[package]] @@ -2609,6 +2675,19 @@ dependencies = [ "proc-macro2 1.0.27", ] +[[package]] +name = "rand" +version = "0.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "552840b97013b1a26992c11eac34bdd778e464601a4c2054b5f0bff7c6761293" +dependencies = [ + "fuchsia-cprng", + "libc 0.2.95", + "rand_core 0.3.1", + "rdrand", + "winapi 0.3.9", +] + [[package]] name = "rand" version = "0.6.5" @@ -2616,7 +2695,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6d71dacdc3c88c1fde3885a3be3fbab9f35724e6ce99467f7d9c5026132184ca" dependencies = [ "autocfg 0.1.7", - "libc", + "libc 0.2.95", "rand_chacha 0.1.1", "rand_core 0.4.2", "rand_hc 0.1.0", @@ -2635,7 +2714,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03" dependencies = [ "getrandom 0.1.16", - "libc", + "libc 0.2.95", "rand_chacha 0.2.2", "rand_core 0.5.1", "rand_hc 0.2.0", @@ -2648,7 +2727,7 @@ version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0ef9e7e66b4468674bfcb0c81af8b7fa0bb154fa9f28eb840da5c447baeb8d7e" dependencies = [ - "libc", + "libc 0.2.95", "rand_chacha 0.3.0", "rand_core 0.6.2", "rand_hc 0.3.0", @@ -2759,7 +2838,7 @@ version = "0.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1166d5c91dc97b88d1decc3285bb0a99ed84b05cfd0bc2341bdf2d43fc41e39b" dependencies = [ - "libc", + "libc 0.2.95", "rand_core 0.4.2", "winapi 0.3.9", ] @@ -2772,7 +2851,7 @@ checksum = "7b75f676a1e053fc562eafbb47838d67c84801e38fc1ba459e8f180deabd5071" dependencies = [ "cloudabi", "fuchsia-cprng", - "libc", + "libc 0.2.95", "rand_core 0.4.2", "rdrand", "winapi 0.3.9", @@ -2821,13 +2900,22 @@ version = "0.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "63e935c45e09cc6dcf00d2f0b2d630a58f4095320223d47fc68918722f0538b6" +[[package]] +name = "raw-cpuid" +version = "9.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c27cb5785b85bd05d4eb171556c9a1a514552e26123aeae6bb7d811353148026" +dependencies = [ + "bitflags", +] + [[package]] name = "raw-window-handle" version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0a441a7a6c80ad6473bd4b74ec1c9a4c951794285bf941c2126f607c72e48211" dependencies = [ - "libc", + "libc 0.2.95", ] [[package]] @@ -3011,7 +3099,7 @@ dependencies = [ "indoc 0.3.6", "inkwell 0.1.0", "inlinable_string", - "libc", + "libc 0.2.95", "libloading 0.6.7", "maplit", "pretty_assertions 0.5.1", @@ -3106,7 +3194,7 @@ dependencies = [ "im-rc 15.0.0", "indoc 1.0.3", "inlinable_string", - "libc", + "libc 0.2.95", "log", "maplit", "nonempty", @@ -3168,7 +3256,7 @@ dependencies = [ "indoc 0.3.6", "inlinable_string", "itertools 0.9.0", - "libc", + "libc 0.2.95", "libloading 0.6.7", "maplit", "object", @@ -3207,7 +3295,7 @@ dependencies = [ "indoc 0.3.6", "inkwell 0.1.0", "inlinable_string", - "libc", + "libc 0.2.95", "maplit", "pretty_assertions 0.5.1", "quickcheck 0.8.5", @@ -3397,7 +3485,7 @@ dependencies = [ name = "roc_std" version = "0.1.0" dependencies = [ - "libc", + "libc 0.2.95", ] [[package]] @@ -3477,7 +3565,7 @@ source = "git+https://github.com/rtfeldman/rustyline?tag=prompt-fix#a6b8a20d2bf5 dependencies = [ "cfg-if 0.1.10", "dirs-next", - "libc", + "libc 0.2.95", "log", "memchr", "nix 0.17.0", @@ -3866,6 +3954,16 @@ version = "0.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ab0e7238dcc7b40a7be719a25365910f6807bd864f4cce6b2e6b873658e2b19d" +[[package]] +name = "tempdir" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "15f2b5fb00ccdf689e0149d1b1b3c03fead81c2b37735d812fa8bddbbf41b6d8" +dependencies = [ + "rand 0.4.6", + "remove_dir_all", +] + [[package]] name = "tempfile" version = "3.2.0" @@ -3873,7 +3971,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "dac1c663cfc93810f88aed9b8941d48cabf856a1b111c29a40439018d870eb22" dependencies = [ "cfg-if 1.0.0", - "libc", + "libc 0.2.95", "rand 0.8.3", "redox_syscall 0.2.8", "remove_dir_all", @@ -3900,7 +3998,7 @@ dependencies = [ "indoc 0.3.6", "inkwell 0.1.0", "inlinable_string", - "libc", + "libc 0.2.95", "libloading 0.6.7", "maplit", "quickcheck 0.8.5", @@ -3936,7 +4034,7 @@ dependencies = [ "im-rc 14.3.0", "indoc 0.3.6", "inlinable_string", - "libc", + "libc 0.2.95", "libloading 0.6.7", "pretty_assertions 0.5.1", "quickcheck 0.8.5", @@ -4005,7 +4103,7 @@ version = "3.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c7fbf4c9d56b320106cd64fd024dadfa0be7cb4706725fc44a7d7ce952d820c1" dependencies = [ - "libc", + "libc 0.2.95", "redox_syscall 0.1.57", "winapi 0.3.9", ] @@ -4096,7 +4194,7 @@ version = "2.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "50f37be617794602aabbeee0be4f259dc1778fabe05e2d67ee8f79326d5cb4f6" dependencies = [ - "version_check", + "version_check 0.9.3", ] [[package]] @@ -4173,6 +4271,12 @@ dependencies = [ "typed-arena", ] +[[package]] +name = "version_check" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "914b1a6776c4c929a602fafd8bc742e06365d4bcbe48c30f9cca5824f70dc9dd" + [[package]] name = "version_check" version = "0.9.3" @@ -4291,7 +4395,7 @@ checksum = "06ca44d86554b85cf449f1557edc6cc7da935cc748c8e4bf1c507cbd43bae02c" dependencies = [ "bitflags", "downcast-rs", - "libc", + "libc 0.2.95", "nix 0.20.0", "scoped-tls", "wayland-commons", @@ -4494,7 +4598,7 @@ dependencies = [ "dispatch", "instant", "lazy_static", - "libc", + "libc 0.2.95", "log", "mio", "mio-extras", @@ -4555,18 +4659,33 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2bf981e3a5b3301209754218f962052d4d9ee97e478f4d26d4a6eced34c1fef8" dependencies = [ "lazy_static", - "libc", + "libc 0.2.95", "maybe-uninit", "pkg-config", ] +[[package]] +name = "x86" +version = "0.37.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4fd9298cd1b1f88546fc0a5e8faa3354013cd010589299c624fde436aad76cc" +dependencies = [ + "bit_field", + "bitflags", + "csv", + "phf", + "phf_codegen", + "raw-cpuid", + "serde_json", +] + [[package]] name = "xcb" version = "0.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "62056f63138b39116f82a540c983cc11f1c90cd70b3d492a70c25eaa50bd22a6" dependencies = [ - "libc", + "libc 0.2.95", "log", ] @@ -4576,7 +4695,7 @@ version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3a9a231574ae78801646617cefd13bfe94be907c0e4fa979cfd8b770aa3c5d08" dependencies = [ - "nom", + "nom 6.1.2", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index 40cc3a5e32..466f01ea8d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -30,7 +30,8 @@ members = [ "cli", "cli/cli_utils", "roc_std", - "docs" + "docs", + "nightly_benches", ] # Needed to be able to run `cargo run -p roc_cli --no-default-features` - # see www/build.sh for more. diff --git a/nightly_benches/Cargo.toml b/nightly_benches/Cargo.toml new file mode 100644 index 0000000000..380cb7f454 --- /dev/null +++ b/nightly_benches/Cargo.toml @@ -0,0 +1,16 @@ +[package] +name = "nightly_benches" +version = "0.1.0" +edition = "2018" + +[dependencies] + +[dev-dependencies] +criterion = { git = "https://github.com/Anton-4/criterion.rs"} +cli_utils = { path = "../cli/cli_utils" } +criterion-perf-events ={ git = "https://github.com/Anton-4/criterion-perf-events" } +perfcnt = "0.7.1" + +[[bench]] +name = "events_bench" +harness = false diff --git a/nightly_benches/benches/events_bench.rs b/nightly_benches/benches/events_bench.rs new file mode 100644 index 0000000000..62f55b23f1 --- /dev/null +++ b/nightly_benches/benches/events_bench.rs @@ -0,0 +1,94 @@ +// Keep this benchmark. It's commented because it requires nightly rust. +use cli_utils::bench_utils::{ + bench_cfold, bench_deriv, bench_nqueens, bench_rbtree_ck, bench_rbtree_delete, +}; +use criterion_perf_events::Perf; +use perfcnt::linux::HardwareEventType as Hardware; +use perfcnt::linux::PerfCounterBuilderLinux as Builder; + +use criterion::{criterion_group, criterion_main, BenchmarkGroup, Criterion, SamplingMode}; + +fn bench_group(c: &mut Criterion, hw_event_str: &str) { + let mut group = c.benchmark_group(format!("bench-group_no-opt_{}", hw_event_str)); + // calculate statistics based on a fixed(flat) 100 runs + group.sampling_mode(SamplingMode::Flat); + + let bench_funcs: Vec>) -> ()> = vec![ + bench_nqueens, + bench_cfold, + bench_deriv, + bench_rbtree_ck, + bench_rbtree_delete, + // TODO quicksort + ]; + + for bench_func in bench_funcs.iter() { + bench_func(Some(&mut group)) + } + + group.finish(); +} + +use perfcnt::linux::HardwareEventType; + +fn init_criterion(event: HardwareEventType) -> Criterion { + Criterion::default().with_measurement(Perf::new(Builder::from_hardware_event(event))) +} + +fn bench_instructions(c: &mut Criterion) { + bench_group(c, "instructions") +} + +criterion_group!( + name = benches_instructions; + config = init_criterion(Hardware::Instructions); + targets = bench_instructions +); + +fn bench_cache_refs(c: &mut Criterion) { + bench_group(c, "cache_refs") +} + +criterion_group!( + name = benches_cache_refs; + config = init_criterion(Hardware::CacheReferences); + targets = bench_cache_refs +); + +fn bench_cache_misses(c: &mut Criterion) { + bench_group(c, "cache_misses") +} + +criterion_group!( + name = benches_cache_misses; + config = init_criterion(Hardware::CacheMisses); + targets = bench_cache_misses +); + +fn bench_branch_instructions(c: &mut Criterion) { + bench_group(c, "branch_instructions") +} + +criterion_group!( + name = benches_branch_instructions; + config = init_criterion(Hardware::BranchInstructions); + targets = bench_branch_instructions +); + +fn bench_branch_misses(c: &mut Criterion) { + bench_group(c, "branch_misses") +} + +criterion_group!( + name = benches_branch_misses; + config = init_criterion(Hardware::BranchMisses); + targets = bench_branch_misses +); + +criterion_main!( + benches_instructions, + /*benches_cache_refs, + benches_cache_misses, + benches_branch_instructions, + benches_branch_misses*/ +); diff --git a/nightly_benches/rust-toolchain b/nightly_benches/rust-toolchain new file mode 100644 index 0000000000..07ade694b1 --- /dev/null +++ b/nightly_benches/rust-toolchain @@ -0,0 +1 @@ +nightly \ No newline at end of file diff --git a/nightly_benches/src/main.rs b/nightly_benches/src/main.rs new file mode 100644 index 0000000000..e7a11a969c --- /dev/null +++ b/nightly_benches/src/main.rs @@ -0,0 +1,3 @@ +fn main() { + println!("Hello, world!"); +} From 043091b1e629ff8373c4241e6cec53acccbcb9fd Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Tue, 8 Jun 2021 21:38:22 -0400 Subject: [PATCH 189/496] Revert List.map idea Not convinced this is a good design. Might be, might not be, but needs further investigation. --- compiler/builtins/docs/List.roc | 28 ---------------------------- 1 file changed, 28 deletions(-) diff --git a/compiler/builtins/docs/List.roc b/compiler/builtins/docs/List.roc index f130ed35bb..2f3248da4b 100644 --- a/compiler/builtins/docs/List.roc +++ b/compiler/builtins/docs/List.roc @@ -263,34 +263,6 @@ sortDesc : List elem, (elem -> Num *) -> List elem ## ## `map` functions like this are common in Roc, and they all work similarly. ## See for example #Result.map, #Set.map, and #Map.map. -## -## ## Perfomrance -## -## `map` may run either sequentially or in parallel, depending on its workload. -## -## For example, when running `map` on a very small list, with a very quick -## transformation function, running it in parallel might actually slow it down -## because the coordination overhead would exceed the savings from parallelizing -## the work. On the other hand, a very long list might benefit massively from -## parallelization, as might a medium-sized list with a transformation funtion -## that takes a long time to run. -## -## As with all behind-the-scenes optimizations, Roc's compiler uses heuristics -## to decides whether a given `map` invocation should be parallelized. If it -## decides to parallelize it, the platform is responsible for deciding how -## many threads to devote to a particular `map` call. (The `map` call will -## always return the same answer regardless of any of this.) -## -## Assigning threads is up to the platform because the platform has full -## information about the availability of system resources, including information -## that may not be available to application code (and especially to package code -## that isn't coupled to any particular platform). -## -## For example, if the platform knows that 5 out of 8 threads are currently -## busy doing other work, then it may choose to split the `map` workload across -## the 3 remaining threads. The next time you call `map`, the platform may know -## that only 2 out of 8 threads are currently busy, so it may allocate 6 threads -## to it instead. map : List before, (before -> after) -> List after ## This works like #List.map, except it also passes the index From bec4884028d6b3225660ebcd31e89df5b06bdae6 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Tue, 8 Jun 2021 21:57:22 -0400 Subject: [PATCH 190/496] Try having only one parse function --- compiler/builtins/docs/Num.roc | 16 ---------------- compiler/builtins/docs/Str.roc | 23 ----------------------- 2 files changed, 39 deletions(-) diff --git a/compiler/builtins/docs/Num.roc b/compiler/builtins/docs/Num.roc index 81a6f137a5..db8d41bd7f 100644 --- a/compiler/builtins/docs/Num.roc +++ b/compiler/builtins/docs/Num.roc @@ -917,22 +917,6 @@ Endi : [ Big, Little ] ## only one byte. toBytes : Num *, Endi -> List U8 -## If the bytes begin with a valid #U8 number, return -## that number along with the rest of the bytes after it. -parseU8 : List U8 -> Result { val : U8, rest : List U8 } [ Expected [ NumU8 ]* List U8 ]* -parseI8 : List U8 -> Result { val : I8, rest : List U8 } [ Expected [ NumI8 ]* List U8 ]* -parseU16 : List U8, Endi -> Result { val : U16, rest : List U8 } [ Expected [ NumU16 Endi ]* (List U8) ]* -parseI16 : List U8, Endi -> Result { val : I16, rest : List U8 } [ Expected [ NumI16 Endi ]* (List U8) ]* -parseU32 : List U8, Endi -> Result { val : U32, rest : List U8 } [ Expected [ NumU32 Endi ]* (List U8) ]* -parseI32 : List U8, Endi -> Result { val : I32, rest : List U8 } [ Expected [ NumI32 Endi ]* (List U8) ]* -parseU64 : List U8, Endi -> Result { val : U64, rest : List U8 } [ Expected [ NumU64 Endi ]* (List U8) ]* -parseI64 : List U8, Endi -> Result { val : I64, rest : List U8 } [ Expected [ NumI64 Endi ]* (List U8) ]* -parseU128 : List U8, Endi -> Result { val : U128, rest : List U8 } [ Expected [ NumU128 Endi ]* (List U8) ]* -parseI128 : List U8, Endi -> Result { val : I128, rest : List U8 } [ Expected [ NumI128 Endi ]* (List U8) ]* -parseF64 : List U8, Endi -> Result { val : F64, rest : List U8 } [ Expected [ NumF64 Endi ]* (List U8) ]* -parseF32 : List U8, Endi -> Result { val : F32, rest : List U8 } [ Expected [ NumF32 Endi ]* (List U8) ]* -parseDec : List U8, Endi -> Result { val : Dec, rest : List U8 } [ Expected [ NumDec Endi ]* (List U8) ]* - ## when Num.parseBytes bytes Big is ## Ok { val: f64, rest } -> ... ## Err (ExpectedNum (Float Binary64)) -> ... diff --git a/compiler/builtins/docs/Str.roc b/compiler/builtins/docs/Str.roc index 2c61b076ab..3a5ed0c88e 100644 --- a/compiler/builtins/docs/Str.roc +++ b/compiler/builtins/docs/Str.roc @@ -461,29 +461,6 @@ toDec : Str -> Result Dec [ InvalidDec ]* ## advanced options, see [parseNum]. toNum : Str -> Result (Num a) [ ExpectedNum a ]* -## If the string begins with a valid #U8 number, return -## that number along with the rest of the string after it. -parseU8 : Str, NumParseConfig -> Result { val : U8, rest : Str } [ Expected [ NumU8 ]* Str ]* -parseI8 : Str, NumParseConfig -> Result { val : I8, rest : Str } [ Expected [ NumI8 ]* Str ]* -parseU16 : Str, NumParseConfig -> Result { val : U16, rest : Str } [ Expected [ NumU16 ]* Str ]* -parseI16 : Str, NumParseConfig -> Result { val : I16, rest : Str } [ Expected [ NumI16 ]* Str ]* -parseU32 : Str, NumParseConfig -> Result { val : U32, rest : Str } [ Expected [ NumU32 ]* Str ]* -parseI32 : Str, NumParseConfig -> Result { val : I32, rest : Str } [ Expected [ NumI32 ]* Str ]* -parseU64 : Str, NumParseConfig -> Result { val : U64, rest : Str } [ Expected [ NumU64 ]* Str ]* -parseI64 : Str, NumParseConfig -> Result { val : I64, rest : Str } [ Expected [ NumI64 ]* Str ]* -parseU128 : Str, NumParseConfig -> Result { val : U128, rest : Str } [ Expected [ NumU128 ]* Str ]* -parseI128 : Str, NumParseConfig -> Result { val : I128, rest : Str } [ Expected [ NumI128 ]* Str ]* -parseDec : Str, NumParseConfig -> Result { val : Dec, rest : Str } [ Expected [ NumDec ]* Str ]* - -## If the string begins with a [finite](Num.isFinite) [F64] number, return -## that number along with the rest of the string after it. -## -## If the string begins with `"NaN"`, `"∞"`, and `"-∞"` (which do not represent -## [finite](Num.isFinite) numbers), they will be similarly accepted and -## translated into their respective [F64] values. -parseF64 : Str, NumParseConfig -> Result { val : F64, rest : Str } [ Expected [ NumF64 ]* Str ]* -parseF32 : Str, NumParseConfig -> Result { val : F32, rest : Str } [ Expected [ NumF32 ]* Str ]* - ## If the string begins with an [Int] or a [finite](Num.isFinite) [Frac], return ## that number along with the rest of the string after it. ## From 6e906bd450afeb7c3000352feb539bd7e5233ee6 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Mon, 7 Jun 2021 21:43:10 -0400 Subject: [PATCH 191/496] Add --lib flag for roc build --- cli/src/lib.rs | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/cli/src/lib.rs b/cli/src/lib.rs index 69611d6787..50fa43b616 100644 --- a/cli/src/lib.rs +++ b/cli/src/lib.rs @@ -25,6 +25,7 @@ pub const CMD_DOCS: &str = "docs"; pub const FLAG_DEBUG: &str = "debug"; pub const FLAG_OPTIMIZE: &str = "optimize"; +pub const FLAG_LIB: &str = "lib"; pub const ROC_FILE: &str = "ROC_FILE"; pub const DIRECTORY_OR_FILES: &str = "DIRECTORY_OR_FILES"; pub const ARGS_FOR_APP: &str = "ARGS_FOR_APP"; @@ -45,6 +46,12 @@ pub fn build_app<'a>() -> App<'a> { .help("Optimize the compiled program to run faster. (Optimization takes time to complete.)") .required(false), ) + .arg( + Arg::with_name(FLAG_LIB) + .long(FLAG_LIB) + .help("Build a C library instead of an executable.") + .required(false), + ) .arg( Arg::with_name(FLAG_DEBUG) .long(FLAG_DEBUG) From cdc32aadd2b4535c850a75fd39123441f5064cfd Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Tue, 8 Jun 2021 21:55:52 -0400 Subject: [PATCH 192/496] Add some derives to BuildConfig --- cli/src/lib.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/cli/src/lib.rs b/cli/src/lib.rs index 50fa43b616..a26d692635 100644 --- a/cli/src/lib.rs +++ b/cli/src/lib.rs @@ -123,6 +123,7 @@ pub fn docs(files: Vec) { ) } +#[derive(Debug, PartialEq, Eq)] pub enum BuildConfig { BuildOnly, BuildAndRun { roc_file_arg_index: usize }, From 9fcd339af95591d7e4c45a3efe7359c0e131b29c Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Tue, 8 Jun 2021 21:56:15 -0400 Subject: [PATCH 193/496] Set link type based on --lib flag --- cli/src/lib.rs | 8 +++++++- compiler/build/src/link.rs | 6 ++++-- 2 files changed, 11 insertions(+), 3 deletions(-) diff --git a/cli/src/lib.rs b/cli/src/lib.rs index a26d692635..332be94d61 100644 --- a/cli/src/lib.rs +++ b/cli/src/lib.rs @@ -145,6 +145,12 @@ pub fn build(target: &Triple, matches: &ArgMatches, config: BuildConfig) -> io:: }; let emit_debug_info = matches.is_present(FLAG_DEBUG); + let link_type = if matches.is_present(FLAG_LIB) { + LinkType::Dylib + } else { + LinkType::Executable + }; + let path = Path::new(filename).canonicalize().unwrap(); let src_dir = path.parent().unwrap().canonicalize().unwrap(); @@ -174,7 +180,7 @@ pub fn build(target: &Triple, matches: &ArgMatches, config: BuildConfig) -> io:: path, opt_level, emit_debug_info, - LinkType::Executable, + link_type, ); match res_binary_path { diff --git a/compiler/build/src/link.rs b/compiler/build/src/link.rs index 61068d11b8..ee1124c905 100644 --- a/compiler/build/src/link.rs +++ b/compiler/build/src/link.rs @@ -12,8 +12,10 @@ use target_lexicon::{Architecture, OperatingSystem, Triple}; #[derive(Debug, Copy, Clone, PartialEq, Eq)] pub enum LinkType { - Executable, - Dylib, + // These numbers correspond to the --lib flag; if it's present + // (e.g. is_present returns `1 as bool`), this will be 1 as well. + Executable = 0, + Dylib = 1, } /// input_paths can include the host as well as the app. e.g. &["host.o", "roc_app.o"] From 12c186813da83e5ffb0894ae867d30d6b2823644 Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 9 Jun 2021 14:19:14 +0200 Subject: [PATCH 194/496] use std.mem.swap --- compiler/builtins/bitcode/src/dict.zig | 4 +--- compiler/builtins/bitcode/src/list.zig | 8 ++------ 2 files changed, 3 insertions(+), 9 deletions(-) diff --git a/compiler/builtins/bitcode/src/dict.zig b/compiler/builtins/bitcode/src/dict.zig index 6b038f6ffe..2780652f1b 100644 --- a/compiler/builtins/bitcode/src/dict.zig +++ b/compiler/builtins/bitcode/src/dict.zig @@ -791,9 +791,7 @@ pub fn dictWalk( caller(data, key, value, b2, b1); - const temp = b1; - b2 = b1; - b1 = temp; + std.mem.swap([*]u8, &b1, &b2); }, else => {}, } diff --git a/compiler/builtins/bitcode/src/list.zig b/compiler/builtins/bitcode/src/list.zig index 61af7031d0..b4b8a17217 100644 --- a/compiler/builtins/bitcode/src/list.zig +++ b/compiler/builtins/bitcode/src/list.zig @@ -542,9 +542,7 @@ pub fn listWalk( const element = source_ptr + i * element_width; caller(data, element, b2, b1); - const temp = b1; - b2 = b1; - b1 = temp; + std.mem.swap([*]u8, &b1, &b2); } } @@ -591,9 +589,7 @@ pub fn listWalkBackwards( const element = source_ptr + i * element_width; caller(data, element, b2, b1); - const temp = b1; - b2 = b1; - b1 = temp; + std.mem.swap([*]u8, &b1, &b2); } } From 5e4fc1dc2fed40fe9f04fbc0797da99090e8bf49 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Wed, 9 Jun 2021 18:52:34 +0200 Subject: [PATCH 195/496] now executing benchmarks outside earthly --- .github/workflows/benchmarks.yml | 19 +- .gitignore | 2 + Cargo.lock | 245 ++++++------------------ Cargo.toml | 1 - Earthfile | 24 ++- cli/Cargo.toml | 7 - cli/benches/events_bench.rs | 94 --------- criterion/LEAVE_ME_HERE.txt | 1 - nightly_benches/benches/events_bench.rs | 4 +- 9 files changed, 95 insertions(+), 302 deletions(-) delete mode 100644 cli/benches/events_bench.rs delete mode 100644 criterion/LEAVE_ME_HERE.txt diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index 5f644a8eb6..5e94cd9376 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -21,12 +21,21 @@ jobs: - name: Earthly version run: earthly --version - - name: on trunk; install dependencies, build, cd cli, benchmark with criterion - run: ./ci/safe-earthly.sh +bench-roc + - name: on trunk; prepare a self contained benchmark folder + run: ./ci/safe-earthly.sh +prep-bench-folder --build-arg BENCH_SUFFIX=trunk - uses: actions/checkout@v2 with: - clean: "false" # we want to keep the benchmark(criterion) folder + clean: "false" # we want to keep the benchmark folder - - name: on current branch; install dependencies, build, cd cli, benchmark with criterion - run: ./ci/safe-earthly.sh +bench-roc + - name: on current branch; prepare a self contained benchmark folder + run: ./ci/safe-earthly.sh +prep-bench-folder + + - name: benchmark trunk + run: cd bench-folder-trunk && ./target/release/deps/time_bench --bench + + - name: move benchmark results so they can be compared later + run: cd .. && cp bench-folder-trunk/target/criterion bench-folder-branch/target/ + + - name: benchmark current branch + run: cd bench-folder-branch && ./target/release/deps/time_bench --bench diff --git a/.gitignore b/.gitignore index 10d627c503..242dbec6f8 100644 --- a/.gitignore +++ b/.gitignore @@ -27,3 +27,5 @@ editor/benches/resources/500_lines.roc # rust cache (sccache folder) sccache_dir +# self-contained benchmark folder +bench-folder* diff --git a/Cargo.lock b/Cargo.lock index 6335dfa462..a4b14f1473 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -47,7 +47,7 @@ checksum = "43bb833f0bf979d8475d38fbf09ed3b8a55e1885fe93ad3f93239fc6a4f17b98" dependencies = [ "getrandom 0.2.3", "once_cell", - "version_check 0.9.3", + "version_check", ] [[package]] @@ -137,7 +137,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8" dependencies = [ "hermit-abi", - "libc 0.2.95", + "libc", "winapi 0.3.9", ] @@ -162,7 +162,7 @@ dependencies = [ "addr2line", "cc", "cfg-if 1.0.0", - "libc 0.2.95", + "libc", "miniz_oxide", "object", "rustc-demangle", @@ -183,12 +183,6 @@ version = "0.6.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb" -[[package]] -name = "bit_field" -version = "0.10.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dcb6dd1c2376d2e096796e234a70e17e94cc2d5d54ff8ce42b28cef1d0d359a4" - [[package]] name = "bitflags" version = "1.2.1" @@ -440,7 +434,7 @@ dependencies = [ "core-foundation 0.9.1", "core-graphics 0.22.2", "foreign-types", - "libc 0.2.95", + "libc", "objc", ] @@ -455,7 +449,7 @@ dependencies = [ "core-foundation 0.9.1", "core-graphics-types", "foreign-types", - "libc 0.2.95", + "libc", "objc", ] @@ -537,7 +531,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "57d24c7a13c43e870e37c1556b74555437870a04514f7685f5b354e090567171" dependencies = [ "core-foundation-sys 0.7.0", - "libc 0.2.95", + "libc", ] [[package]] @@ -547,7 +541,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0a89e2ae426ea83155dccf10c0fa6b1463ef6d5fcb44cee0b224a408fa640a62" dependencies = [ "core-foundation-sys 0.8.2", - "libc 0.2.95", + "libc", ] [[package]] @@ -571,7 +565,7 @@ dependencies = [ "bitflags", "core-foundation 0.7.0", "foreign-types", - "libc 0.2.95", + "libc", ] [[package]] @@ -584,7 +578,7 @@ dependencies = [ "core-foundation 0.9.1", "core-graphics-types", "foreign-types", - "libc 0.2.95", + "libc", ] [[package]] @@ -596,7 +590,7 @@ dependencies = [ "bitflags", "core-foundation 0.9.1", "foreign-types", - "libc 0.2.95", + "libc", ] [[package]] @@ -608,7 +602,7 @@ dependencies = [ "cfg-if 0.1.10", "core-foundation-sys 0.7.0", "core-graphics 0.19.2", - "libc 0.2.95", + "libc", "objc", ] @@ -618,7 +612,7 @@ version = "0.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ed00c67cb5d0a7d64a44f6ad2668db7e7530311dd53ea79bcd4fb022c64911c8" dependencies = [ - "libc 0.2.95", + "libc", ] [[package]] @@ -655,15 +649,6 @@ dependencies = [ "walkdir", ] -[[package]] -name = "criterion-perf-events" -version = "0.1.3" -source = "git+https://github.com/Anton-4/criterion-perf-events#e30bbb54fb00881515a9ae78b00a2a01ec5c376f" -dependencies = [ - "criterion", - "perfcnt", -] - [[package]] name = "criterion-plot" version = "0.4.3" @@ -929,7 +914,7 @@ version = "0.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d" dependencies = [ - "libc 0.2.95", + "libc", "redox_users", "winapi 0.3.9", ] @@ -1037,7 +1022,7 @@ checksum = "cd3aec53de10fe96d7d8c565eb17f2c687bb5518a2ec453b5b1252964526abe0" dependencies = [ "cfg-if 1.0.0", "crc32fast", - "libc 0.2.95", + "libc", "miniz_oxide", ] @@ -1203,7 +1188,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "501466ecc8a30d1d3b7fc9229b122b2ce8ed6e9d9223f1138d4babb253e51817" dependencies = [ "typenum", - "version_check 0.9.3", + "version_check", ] [[package]] @@ -1213,7 +1198,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce" dependencies = [ "cfg-if 1.0.0", - "libc 0.2.95", + "libc", "wasi 0.9.0+wasi-snapshot-preview1", ] @@ -1224,7 +1209,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753" dependencies = [ "cfg-if 1.0.0", - "libc 0.2.95", + "libc", "wasi 0.10.2+wasi-snapshot-preview1", ] @@ -1510,7 +1495,7 @@ version = "0.1.18" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "322f4de77956e22ed0e5032c359a0f1273f1f7f0d79bfa3b8ffbc730d7fbcc5c" dependencies = [ - "libc 0.2.95", + "libc", ] [[package]] @@ -1536,7 +1521,7 @@ dependencies = [ "rand_xoshiro", "sized-chunks 0.5.3", "typenum", - "version_check 0.9.3", + "version_check", ] [[package]] @@ -1550,7 +1535,7 @@ dependencies = [ "rand_xoshiro", "sized-chunks 0.6.5", "typenum", - "version_check 0.9.3", + "version_check", ] [[package]] @@ -1564,7 +1549,7 @@ dependencies = [ "rand_xoshiro", "sized-chunks 0.5.3", "typenum", - "version_check 0.9.3", + "version_check", ] [[package]] @@ -1578,7 +1563,7 @@ dependencies = [ "rand_xoshiro", "sized-chunks 0.6.5", "typenum", - "version_check 0.9.3", + "version_check", ] [[package]] @@ -1637,7 +1622,7 @@ source = "git+https://github.com/rtfeldman/inkwell?tag=llvm12-0.release2#2f9bfb7 dependencies = [ "either", "inkwell_internals", - "libc 0.2.95", + "libc", "llvm-sys", "once_cell", "parking_lot", @@ -1681,7 +1666,7 @@ version = "0.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b2b3ea6ff95e175473f8ffe6a7eb7c00d054240321b84c57051175fe3c1e075e" dependencies = [ - "libc 0.2.95", + "libc", ] [[package]] @@ -1720,7 +1705,7 @@ version = "0.1.22" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "972f5ae5d1cb9c6ae417789196c803205313edde988685da5e3aae0827b9e7fd" dependencies = [ - "libc 0.2.95", + "libc", ] [[package]] @@ -1748,7 +1733,7 @@ version = "4.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8c2352bd1d0bceb871cb9d40f24360c8133c11d7486b68b5381c1dd1a32015e3" dependencies = [ - "libc 0.2.95", + "libc", "libloading 0.7.0", ] @@ -1770,12 +1755,6 @@ version = "1.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55" -[[package]] -name = "libc" -version = "0.1.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e32a70cf75e5846d53a673923498228bbec6a8624708a9ea5645f075d6276122" - [[package]] name = "libc" version = "0.2.95" @@ -1816,7 +1795,7 @@ checksum = "15d9c00ce56221b2150e2d4d51887ff139fce5a0e50346c744861d1e66d2f7c4" dependencies = [ "cc", "lazy_static", - "libc 0.2.95", + "libc", "regex", "semver 0.9.0", ] @@ -1845,7 +1824,7 @@ version = "0.0.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "62bb907fe88d54d8d9ce32a3cceab4218ed2f6b7d35617cafe9adf84e43919cb" dependencies = [ - "libc 0.2.95", + "libc", ] [[package]] @@ -1872,7 +1851,7 @@ version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d9b70ca2a6103ac8b665dc150b142ef0e4e89df640c9e6cf295d189c3caebe5a" dependencies = [ - "libc 0.2.95", + "libc", ] [[package]] @@ -1928,7 +1907,7 @@ dependencies = [ "fuchsia-zircon-sys", "iovec", "kernel32-sys", - "libc 0.2.95", + "libc", "log", "miow", "net2", @@ -1960,16 +1939,6 @@ dependencies = [ "ws2_32-sys", ] -[[package]] -name = "mmap" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0bc85448a6006dd2ba26a385a564a8a0f1f2c7e78c70f1a70b2e0f4af286b823" -dependencies = [ - "libc 0.1.12", - "tempdir", -] - [[package]] name = "morphic_lib" version = "0.1.0" @@ -2015,7 +1984,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bdf399b8b7a39c6fb153c4ec32c72fd5fe789df24a647f229c239aa7adb15241" dependencies = [ "lazy_static", - "libc 0.2.95", + "libc", "log", "ndk", "ndk-macro", @@ -2048,20 +2017,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "391630d12b68002ae1e25e8f974306474966550ad82dac6886fb8910c19568ae" dependencies = [ "cfg-if 0.1.10", - "libc 0.2.95", + "libc", "winapi 0.3.9", ] -[[package]] -name = "nightly_benches" -version = "0.1.0" -dependencies = [ - "cli_utils", - "criterion", - "criterion-perf-events", - "perfcnt", -] - [[package]] name = "nix" version = "0.17.0" @@ -2071,7 +2030,7 @@ dependencies = [ "bitflags", "cc", "cfg-if 0.1.10", - "libc 0.2.95", + "libc", "void", ] @@ -2084,7 +2043,7 @@ dependencies = [ "bitflags", "cc", "cfg-if 0.1.10", - "libc 0.2.95", + "libc", ] [[package]] @@ -2096,17 +2055,7 @@ dependencies = [ "bitflags", "cc", "cfg-if 1.0.0", - "libc 0.2.95", -] - -[[package]] -name = "nom" -version = "4.2.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2ad2a91a8e869eeb30b9cb3119ae87773a8f4ae617f41b1eb9c154b2905f7bd6" -dependencies = [ - "memchr", - "version_check 0.1.5", + "libc", ] [[package]] @@ -2116,7 +2065,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e7413f999671bd4745a7b624bd370a569fb6bc574b23c83a3c5ed2e453f3d5e2" dependencies = [ "memchr", - "version_check 0.9.3", + "version_check", ] [[package]] @@ -2141,7 +2090,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "05499f3756671c15885fee9034446956fff3f243d6077b91e5767df161f766b3" dependencies = [ "hermit-abi", - "libc 0.2.95", + "libc", ] [[package]] @@ -2283,7 +2232,7 @@ version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "eebde548fbbf1ea81a99b128872779c437752fb99f217c45245e1a61dcd9edcd" dependencies = [ - "libc 0.2.95", + "libc", "winapi 0.3.9", ] @@ -2331,7 +2280,7 @@ dependencies = [ "backtrace", "cfg-if 1.0.0", "instant", - "libc 0.2.95", + "libc", "petgraph", "redox_syscall 0.2.8", "smallvec", @@ -2345,21 +2294,6 @@ version = "2.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e" -[[package]] -name = "perfcnt" -version = "0.7.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "88a4decf2d171c232d741ca37d590cd50d35314b7d348198e7e474e0bf34c8b4" -dependencies = [ - "bitflags", - "byteorder", - "libc 0.2.95", - "mmap", - "nom 4.2.3", - "phf", - "x86", -] - [[package]] name = "pest" version = "2.1.3" @@ -2549,7 +2483,7 @@ dependencies = [ "proc-macro2 1.0.27", "quote 1.0.9", "syn 1.0.72", - "version_check 0.9.3", + "version_check", ] [[package]] @@ -2562,7 +2496,7 @@ dependencies = [ "quote 1.0.9", "syn 1.0.72", "syn-mid", - "version_check 0.9.3", + "version_check", ] [[package]] @@ -2675,19 +2609,6 @@ dependencies = [ "proc-macro2 1.0.27", ] -[[package]] -name = "rand" -version = "0.4.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "552840b97013b1a26992c11eac34bdd778e464601a4c2054b5f0bff7c6761293" -dependencies = [ - "fuchsia-cprng", - "libc 0.2.95", - "rand_core 0.3.1", - "rdrand", - "winapi 0.3.9", -] - [[package]] name = "rand" version = "0.6.5" @@ -2695,7 +2616,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6d71dacdc3c88c1fde3885a3be3fbab9f35724e6ce99467f7d9c5026132184ca" dependencies = [ "autocfg 0.1.7", - "libc 0.2.95", + "libc", "rand_chacha 0.1.1", "rand_core 0.4.2", "rand_hc 0.1.0", @@ -2714,7 +2635,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03" dependencies = [ "getrandom 0.1.16", - "libc 0.2.95", + "libc", "rand_chacha 0.2.2", "rand_core 0.5.1", "rand_hc 0.2.0", @@ -2727,7 +2648,7 @@ version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0ef9e7e66b4468674bfcb0c81af8b7fa0bb154fa9f28eb840da5c447baeb8d7e" dependencies = [ - "libc 0.2.95", + "libc", "rand_chacha 0.3.0", "rand_core 0.6.2", "rand_hc 0.3.0", @@ -2838,7 +2759,7 @@ version = "0.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1166d5c91dc97b88d1decc3285bb0a99ed84b05cfd0bc2341bdf2d43fc41e39b" dependencies = [ - "libc 0.2.95", + "libc", "rand_core 0.4.2", "winapi 0.3.9", ] @@ -2851,7 +2772,7 @@ checksum = "7b75f676a1e053fc562eafbb47838d67c84801e38fc1ba459e8f180deabd5071" dependencies = [ "cloudabi", "fuchsia-cprng", - "libc 0.2.95", + "libc", "rand_core 0.4.2", "rdrand", "winapi 0.3.9", @@ -2900,22 +2821,13 @@ version = "0.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "63e935c45e09cc6dcf00d2f0b2d630a58f4095320223d47fc68918722f0538b6" -[[package]] -name = "raw-cpuid" -version = "9.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c27cb5785b85bd05d4eb171556c9a1a514552e26123aeae6bb7d811353148026" -dependencies = [ - "bitflags", -] - [[package]] name = "raw-window-handle" version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0a441a7a6c80ad6473bd4b74ec1c9a4c951794285bf941c2126f607c72e48211" dependencies = [ - "libc 0.2.95", + "libc", ] [[package]] @@ -3099,7 +3011,7 @@ dependencies = [ "indoc 0.3.6", "inkwell 0.1.0", "inlinable_string", - "libc 0.2.95", + "libc", "libloading 0.6.7", "maplit", "pretty_assertions 0.5.1", @@ -3194,7 +3106,7 @@ dependencies = [ "im-rc 15.0.0", "indoc 1.0.3", "inlinable_string", - "libc 0.2.95", + "libc", "log", "maplit", "nonempty", @@ -3256,7 +3168,7 @@ dependencies = [ "indoc 0.3.6", "inlinable_string", "itertools 0.9.0", - "libc 0.2.95", + "libc", "libloading 0.6.7", "maplit", "object", @@ -3295,7 +3207,7 @@ dependencies = [ "indoc 0.3.6", "inkwell 0.1.0", "inlinable_string", - "libc 0.2.95", + "libc", "maplit", "pretty_assertions 0.5.1", "quickcheck 0.8.5", @@ -3485,7 +3397,7 @@ dependencies = [ name = "roc_std" version = "0.1.0" dependencies = [ - "libc 0.2.95", + "libc", ] [[package]] @@ -3565,7 +3477,7 @@ source = "git+https://github.com/rtfeldman/rustyline?tag=prompt-fix#a6b8a20d2bf5 dependencies = [ "cfg-if 0.1.10", "dirs-next", - "libc 0.2.95", + "libc", "log", "memchr", "nix 0.17.0", @@ -3954,16 +3866,6 @@ version = "0.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ab0e7238dcc7b40a7be719a25365910f6807bd864f4cce6b2e6b873658e2b19d" -[[package]] -name = "tempdir" -version = "0.3.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "15f2b5fb00ccdf689e0149d1b1b3c03fead81c2b37735d812fa8bddbbf41b6d8" -dependencies = [ - "rand 0.4.6", - "remove_dir_all", -] - [[package]] name = "tempfile" version = "3.2.0" @@ -3971,7 +3873,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "dac1c663cfc93810f88aed9b8941d48cabf856a1b111c29a40439018d870eb22" dependencies = [ "cfg-if 1.0.0", - "libc 0.2.95", + "libc", "rand 0.8.3", "redox_syscall 0.2.8", "remove_dir_all", @@ -3998,7 +3900,7 @@ dependencies = [ "indoc 0.3.6", "inkwell 0.1.0", "inlinable_string", - "libc 0.2.95", + "libc", "libloading 0.6.7", "maplit", "quickcheck 0.8.5", @@ -4034,7 +3936,7 @@ dependencies = [ "im-rc 14.3.0", "indoc 0.3.6", "inlinable_string", - "libc 0.2.95", + "libc", "libloading 0.6.7", "pretty_assertions 0.5.1", "quickcheck 0.8.5", @@ -4103,7 +4005,7 @@ version = "3.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c7fbf4c9d56b320106cd64fd024dadfa0be7cb4706725fc44a7d7ce952d820c1" dependencies = [ - "libc 0.2.95", + "libc", "redox_syscall 0.1.57", "winapi 0.3.9", ] @@ -4194,7 +4096,7 @@ version = "2.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "50f37be617794602aabbeee0be4f259dc1778fabe05e2d67ee8f79326d5cb4f6" dependencies = [ - "version_check 0.9.3", + "version_check", ] [[package]] @@ -4271,12 +4173,6 @@ dependencies = [ "typed-arena", ] -[[package]] -name = "version_check" -version = "0.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "914b1a6776c4c929a602fafd8bc742e06365d4bcbe48c30f9cca5824f70dc9dd" - [[package]] name = "version_check" version = "0.9.3" @@ -4395,7 +4291,7 @@ checksum = "06ca44d86554b85cf449f1557edc6cc7da935cc748c8e4bf1c507cbd43bae02c" dependencies = [ "bitflags", "downcast-rs", - "libc 0.2.95", + "libc", "nix 0.20.0", "scoped-tls", "wayland-commons", @@ -4598,7 +4494,7 @@ dependencies = [ "dispatch", "instant", "lazy_static", - "libc 0.2.95", + "libc", "log", "mio", "mio-extras", @@ -4659,33 +4555,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2bf981e3a5b3301209754218f962052d4d9ee97e478f4d26d4a6eced34c1fef8" dependencies = [ "lazy_static", - "libc 0.2.95", + "libc", "maybe-uninit", "pkg-config", ] -[[package]] -name = "x86" -version = "0.37.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b4fd9298cd1b1f88546fc0a5e8faa3354013cd010589299c624fde436aad76cc" -dependencies = [ - "bit_field", - "bitflags", - "csv", - "phf", - "phf_codegen", - "raw-cpuid", - "serde_json", -] - [[package]] name = "xcb" version = "0.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "62056f63138b39116f82a540c983cc11f1c90cd70b3d492a70c25eaa50bd22a6" dependencies = [ - "libc 0.2.95", + "libc", "log", ] @@ -4695,7 +4576,7 @@ version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3a9a231574ae78801646617cefd13bfe94be907c0e4fa979cfd8b770aa3c5d08" dependencies = [ - "nom 6.1.2", + "nom", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index 466f01ea8d..06f10ff1fd 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -31,7 +31,6 @@ members = [ "cli/cli_utils", "roc_std", "docs", - "nightly_benches", ] # Needed to be able to run `cargo run -p roc_cli --no-default-features` - # see www/build.sh for more. diff --git a/Earthfile b/Earthfile index da3ba5aac4..20b348a14e 100644 --- a/Earthfile +++ b/Earthfile @@ -101,7 +101,7 @@ check-rustfmt: check-typos: RUN cargo install typos-cli --version 1.0.4 # use latest version on resolution of issue crate-ci/typos#277 - COPY --dir .github ci cli compiler docs editor examples packages roc_std www *.md LEGAL_DETAILS shell.nix ./ + COPY --dir .github ci cli compiler docs editor examples nightly_benches packages roc_std www *.md LEGAL_DETAILS shell.nix ./ RUN typos test-rust: @@ -129,15 +129,19 @@ test-all: BUILD +test-rust BUILD +verify-no-git-changes -bench-roc: +prep-bench-folder: FROM +copy-dirs-and-cache - ENV RUST_BACKTRACE=full + ARG BENCH_SUFFIX=branch RUN cargo criterion -V - # get benchmark results from trunk if they exist - COPY --dir --if-exists criterion ./target - RUN ls ./target/criterion - # ulimit -s unlimited to prevent stack overflow errors for CFold - RUN --no-cache --privileged --mount=type=cache,target=$SCCACHE_DIR \ - ulimit -s unlimited && cd cli && cargo criterion && sccache --show-stats - SAVE ARTIFACT target/criterion AS LOCAL criterion + RUN --mount=type=cache,target=$SCCACHE_DIR cd cli && cargo criterion --no-run + RUN mkdir -p bench-folder/compiler/builtins/bitcode/src + RUN mkdir -p bench-folder/target/release/deps + RUN mkdir -p bench-folder/examples/benchmarks + RUN cp examples/benchmarks/*.roc bench-folder/examples/benchmarks/ + RUN cp -r examples/benchmarks/platform bench-folder/examples/benchmarks/ + RUN cp compiler/builtins/bitcode/src/str.zig bench-folder/compiler/builtins/bitcode/src + RUN cp target/release/roc bench-folder/target/release + # copy the most recent time bench to bench-folder + RUN cp target/release/deps/`ls -t target/release/deps/ | grep time_bench | head -n 1` bench-folder/target/release/deps/time_bench + SAVE ARTIFACT bench-folder AS LOCAL bench-folder-$BENCH_SUFFIX diff --git a/cli/Cargo.toml b/cli/Cargo.toml index 4e95a3398a..531e9a76ee 100644 --- a/cli/Cargo.toml +++ b/cli/Cargo.toml @@ -81,15 +81,8 @@ serial_test = "0.5" tempfile = "3.1.0" criterion = { git = "https://github.com/Anton-4/criterion.rs"} cli_utils = { path = "cli_utils" } -# Keep the commented deps, they are commented because they require nightly rust -# criterion-perf-events = "0.1.3" -# perfcnt = "0.7.1" [[bench]] name = "time_bench" harness = false -# Keep this benchmark, it's commented because it requires nightly -# [[bench]] -# name = "events_bench" -# harness = false diff --git a/cli/benches/events_bench.rs b/cli/benches/events_bench.rs deleted file mode 100644 index 8c56d058a2..0000000000 --- a/cli/benches/events_bench.rs +++ /dev/null @@ -1,94 +0,0 @@ -// Keep this benchmark. It's commented because it requires nightly rust. -/*use cli_utils::bench_utils::{ - bench_cfold, bench_deriv, bench_nqueens, bench_rbtree_ck, bench_rbtree_delete, -}; -use criterion_perf_events::Perf; -use perfcnt::linux::HardwareEventType as Hardware; -use perfcnt::linux::PerfCounterBuilderLinux as Builder; - -use criterion::{criterion_group, criterion_main, BenchmarkGroup, Criterion, SamplingMode}; - -fn bench_group(c: &mut Criterion, hw_event_str: &str) { - let mut group = c.benchmark_group(format!("bench-group_no-opt_{}", hw_event_str)); - // calculate statistics based on a fixed(flat) 100 runs - group.sampling_mode(SamplingMode::Flat); - - let bench_funcs: Vec>) -> ()> = vec![ - bench_nqueens, - bench_cfold, - bench_deriv, - bench_rbtree_ck, - bench_rbtree_delete, - // TODO quicksort - ]; - - for bench_func in bench_funcs.iter() { - bench_func(Some(&mut group)) - } - - group.finish(); -} - -use perfcnt::linux::HardwareEventType; - -fn init_criterion(event: HardwareEventType) -> Criterion { - Criterion::default().with_measurement(Perf::new(Builder::from_hardware_event(event))) -} - -fn bench_instructions(c: &mut Criterion) { - bench_group(c, "instructions") -} - -criterion_group!( - name = benches_instructions; - config = init_criterion(Hardware::Instructions); - targets = bench_instructions -); - -fn bench_cache_refs(c: &mut Criterion) { - bench_group(c, "cache_refs") -} - -criterion_group!( - name = benches_cache_refs; - config = init_criterion(Hardware::CacheReferences); - targets = bench_cache_refs -); - -fn bench_cache_misses(c: &mut Criterion) { - bench_group(c, "cache_misses") -} - -criterion_group!( - name = benches_cache_misses; - config = init_criterion(Hardware::CacheMisses); - targets = bench_cache_misses -); - -fn bench_branch_instructions(c: &mut Criterion) { - bench_group(c, "branch_instructions") -} - -criterion_group!( - name = benches_branch_instructions; - config = init_criterion(Hardware::BranchInstructions); - targets = bench_branch_instructions -); - -fn bench_branch_misses(c: &mut Criterion) { - bench_group(c, "branch_misses") -} - -criterion_group!( - name = benches_branch_misses; - config = init_criterion(Hardware::BranchMisses); - targets = bench_branch_misses -); - -criterion_main!( - benches_instructions, - benches_cache_refs, - benches_cache_misses, - benches_branch_instructions, - benches_branch_misses -);*/ diff --git a/criterion/LEAVE_ME_HERE.txt b/criterion/LEAVE_ME_HERE.txt deleted file mode 100644 index f1fc0c5a2e..0000000000 --- a/criterion/LEAVE_ME_HERE.txt +++ /dev/null @@ -1 +0,0 @@ -The criterion dir needs to be non-empty until this [earthly issue](https://github.com/earthly/earthly/issues/588) is resolved. \ No newline at end of file diff --git a/nightly_benches/benches/events_bench.rs b/nightly_benches/benches/events_bench.rs index 62f55b23f1..2155dd89be 100644 --- a/nightly_benches/benches/events_bench.rs +++ b/nightly_benches/benches/events_bench.rs @@ -1,6 +1,6 @@ // Keep this benchmark. It's commented because it requires nightly rust. use cli_utils::bench_utils::{ - bench_cfold, bench_deriv, bench_nqueens, bench_rbtree_ck, bench_rbtree_delete, + bench_cfold, bench_deriv, bench_nqueens, bench_rbtree_ck, bench_rbtree_delete, bench_quicksort }; use criterion_perf_events::Perf; use perfcnt::linux::HardwareEventType as Hardware; @@ -19,7 +19,7 @@ fn bench_group(c: &mut Criterion, hw_event_str: &str) { bench_deriv, bench_rbtree_ck, bench_rbtree_delete, - // TODO quicksort + bench_quicksort, ]; for bench_func in bench_funcs.iter() { From dccdd5c93975fbb0ce50cfc518813752668c7a7c Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Wed, 9 Jun 2021 18:55:53 +0200 Subject: [PATCH 196/496] compare to previuous commit for now --- .github/workflows/benchmarks.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index 5e94cd9376..fe56c77dd4 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -15,7 +15,7 @@ jobs: steps: - uses: actions/checkout@v2 with: - ref: "ff7755c94cd40c0feaba7878789d152d03dec1df" # benchmarking on trunk first in order to compare results + ref: "5e4fc1dc2fed40fe9f04fbc0797da99090e8bf49" # benchmarking on trunk first in order to compare results clean: "true" - name: Earthly version From 3c8d675378a490e8e4b15a57c0cfe4a74346adda Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 9 Jun 2021 19:05:37 +0200 Subject: [PATCH 197/496] get most cli tests to pass --- compiler/gen_llvm/src/llvm/build.rs | 52 +++++++++++++++++---------- compiler/mono/src/alias_analysis.rs | 27 +++++++++----- compiler/mono/src/ir.rs | 6 ++-- examples/benchmarks/platform/host.zig | 4 +-- 4 files changed, 57 insertions(+), 32 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index e4435df130..b5a36d72cf 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -600,7 +600,12 @@ pub fn promote_to_main_function<'a, 'ctx, 'env>( let main_fn_name = "$Test.main"; // Add main to the module. - let main_fn = expose_function_to_host_help(env, roc_main_fn, main_fn_name); + let main_fn = expose_function_to_host_help( + env, + &inlinable_string::InlinableString::from(main_fn_name), + roc_main_fn, + main_fn_name, + ); (main_fn_name, main_fn) } @@ -2744,11 +2749,12 @@ fn expose_function_to_host<'a, 'ctx, 'env>( let ident_string = symbol.ident_string(&env.interns); let c_function_name: String = format!("roc__{}_1_exposed", ident_string); - expose_function_to_host_help(env, roc_function, &c_function_name); + expose_function_to_host_help(env, ident_string, roc_function, &c_function_name); } fn expose_function_to_host_help<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, + ident_string: &inlinable_string::InlinableString, roc_function: FunctionValue<'ctx>, c_function_name: &str, ) -> FunctionValue<'ctx> { @@ -2809,8 +2815,7 @@ fn expose_function_to_host_help<'a, 'ctx, 'env>( // STEP 3: build a {} -> u64 function that gives the size of the return type let size_function_type = env.context.i64_type().fn_type(&[], false); - let size_function_name: String = - format!("roc_{}_size", roc_function.get_name().to_str().unwrap()); + let size_function_name: String = format!("roc__{}_size", ident_string); let size_function = add_func( env.module, @@ -2889,7 +2894,7 @@ where let info = builder .build_catch_all_landing_pad( &landing_pad_type, - BasicValueEnum::IntValue(context.i8_type().const_zero()), + &BasicValueEnum::IntValue(context.i8_type().const_zero()), context.i8_type().ptr_type(AddressSpace::Generic), "main_landing_pad", ) @@ -3172,6 +3177,7 @@ fn build_procedures_help<'a, 'ctx, 'env>( build_proc( &env, + mod_solutions, &mut layout_ids, func_spec_solutions, scope.clone(), @@ -3242,8 +3248,6 @@ fn build_proc_header<'a, 'ctx, 'env>( let fn_name = func_spec_name(env.arena, &env.interns, symbol, func_spec); - dbg!(&fn_name); - let ret_type = basic_type_from_layout(env, &proc.ret_layout); let mut arg_basic_types = Vec::with_capacity_in(args.len(), arena); @@ -3289,7 +3293,7 @@ pub fn build_closure_caller<'a, 'ctx, 'env>( // e.g. `roc__main_1_Fx_caller` let function_name = format!( - "roc_{}_{}_caller", + "roc__{}_{}_caller", def_name, alias_symbol.ident_string(&env.interns) ); @@ -3510,14 +3514,14 @@ fn build_host_exposed_alias_size_help<'a, 'ctx, 'env>( let size_function_type = env.context.i64_type().fn_type(&[], false); let size_function_name: String = if let Some(label) = opt_label { format!( - "roc_{}_{}_{}_size", + "roc__{}_{}_{}_size", def_name, alias_symbol.ident_string(&env.interns), label ) } else { format!( - "roc_{}_{}_size", + "roc__{}_{}_size", def_name, alias_symbol.ident_string(&env.interns) ) @@ -3541,6 +3545,7 @@ fn build_host_exposed_alias_size_help<'a, 'ctx, 'env>( pub fn build_proc<'a, 'ctx, 'env>( env: &'a Env<'a, 'ctx, 'env>, + mod_solutions: &'a ModSolutions, layout_ids: &mut LayoutIds<'a>, func_spec_solutions: &FuncSpecSolutions, mut scope: Scope<'a, 'ctx>, @@ -3560,19 +3565,30 @@ pub fn build_proc<'a, 'ctx, 'env>( // // * roc__mainForHost_1_Update_size() -> i64 // * roc__mainForHost_1_Update_result_size() -> i64 - continue; let evaluator_layout = env.arena.alloc(top_level).full(); - let evaluator_name = layout_ids - .get(symbol, &evaluator_layout) - .to_symbol_string(symbol, &env.interns); - let evaluator = function_value_by_name_help( - env, - evaluator_layout, + let it = top_level.arguments.iter().copied(); + let bytes = roc_mono::alias_analysis::func_name_bytes_help( symbol, - &evaluator_name, + it, + top_level.result, ); + let func_name = FuncName(&bytes); + let func_solutions = mod_solutions.func_solutions(func_name).unwrap(); + + let mut it = func_solutions.specs(); + let func_spec = it.next().unwrap(); + debug_assert!( + it.next().is_none(), + "we expect only one specialization of this symbol" + ); + + let evaluator = + function_value_by_func_spec(env, *func_spec, symbol, evaluator_layout); + + let ident_string = proc.name.ident_string(&env.interns); + let fn_name: String = format!("{}_1", ident_string); build_closure_caller( env, &fn_name, evaluator, name, arguments, closure, result, diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 083b7f86a6..89cb62a1cf 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -39,9 +39,24 @@ where let mut hasher = DefaultHasher::new(); for layout in argument_layouts { - layout.hash(&mut hasher); + match layout { + Layout::Closure(_, lambda_set, _) => { + lambda_set.runtime_representation().hash(&mut hasher); + } + _ => { + layout.hash(&mut hasher); + } + } + } + + match return_layout { + Layout::Closure(_, lambda_set, _) => { + lambda_set.runtime_representation().hash(&mut hasher); + } + _ => { + return_layout.hash(&mut hasher); + } } - return_layout.hash(&mut hasher); hasher.finish() }; @@ -84,12 +99,6 @@ where for proc in procs { let spec = proc_spec(proc)?; - dbg!(proc.name); - for b in &func_name_bytes(proc) { - eprint!("{:x}", b); - } - eprintln!(""); - m.add_func(FuncName(&func_name_bytes(proc)), spec)?; if format!("{:?}", proc.name).contains("mainForHost") { @@ -133,7 +142,7 @@ where p.build()? }; - eprintln!("{}", program.to_source_string()); + // eprintln!("{}", program.to_source_string()); morphic_lib::solve(program) } diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 82164d6e31..9d52fbd1a1 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -19,7 +19,7 @@ use roc_types::subs::{Content, FlatType, Subs, Variable}; use std::collections::HashMap; use ven_pretty::{BoxAllocator, DocAllocator, DocBuilder}; -pub const PRETTY_PRINT_IR_SYMBOLS: bool = true; +pub const PRETTY_PRINT_IR_SYMBOLS: bool = false; macro_rules! return_on_layout_error { ($env:expr, $layout_result:expr) => { @@ -2575,8 +2575,8 @@ fn cleanup_attempted_type<'a>( #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] pub struct TopLevelFunctionLayout<'a> { - arguments: &'a [Layout<'a>], - result: Layout<'a>, + pub arguments: &'a [Layout<'a>], + pub result: Layout<'a>, } impl<'a> TopLevelFunctionLayout<'a> { diff --git a/examples/benchmarks/platform/host.zig b/examples/benchmarks/platform/host.zig index fdeb1a0ef5..fb3690646e 100644 --- a/examples/benchmarks/platform/host.zig +++ b/examples/benchmarks/platform/host.zig @@ -24,7 +24,7 @@ const mem = std.mem; const Allocator = mem.Allocator; extern fn roc__mainForHost_1_exposed([*]u8) void; -extern fn roc__mainForHost_1_size() i64; +extern fn roc__mainForHost_size() i64; extern fn roc__mainForHost_1_Fx_caller(*const u8, [*]u8, [*]u8) void; extern fn roc__mainForHost_1_Fx_size() i64; extern fn roc__mainForHost_1_Fx_result_size() i64; @@ -51,7 +51,7 @@ pub export fn main() u8 { const stdout = std.io.getStdOut().writer(); const stderr = std.io.getStdErr().writer(); - const size = @intCast(usize, roc__mainForHost_1_size()); + const size = @intCast(usize, roc__mainForHost_size()); const raw_output = std.heap.c_allocator.alloc(u8, size) catch unreachable; var output = @ptrCast([*]u8, raw_output); From a09fb75e7c7246f39974ba8e701d0c957c413ef5 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Wed, 9 Jun 2021 19:14:44 +0200 Subject: [PATCH 198/496] put build-arg in correct position --- .github/workflows/benchmarks.yml | 2 +- Earthfile | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index fe56c77dd4..4cc22013e1 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -22,7 +22,7 @@ jobs: run: earthly --version - name: on trunk; prepare a self contained benchmark folder - run: ./ci/safe-earthly.sh +prep-bench-folder --build-arg BENCH_SUFFIX=trunk + run: ./ci/safe-earthly.sh --build-arg BENCH_SUFFIX=trunk +prep-bench-folder - uses: actions/checkout@v2 with: diff --git a/Earthfile b/Earthfile index 20b348a14e..2322243d0d 100644 --- a/Earthfile +++ b/Earthfile @@ -144,4 +144,3 @@ prep-bench-folder: # copy the most recent time bench to bench-folder RUN cp target/release/deps/`ls -t target/release/deps/ | grep time_bench | head -n 1` bench-folder/target/release/deps/time_bench SAVE ARTIFACT bench-folder AS LOCAL bench-folder-$BENCH_SUFFIX - From 9476f63e0734c739b7ee98d2f46dda8f4a4289a6 Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 9 Jun 2021 19:21:24 +0200 Subject: [PATCH 199/496] WIP --- compiler/gen_llvm/src/llvm/build.rs | 30 +++++++++++++++-------- compiler/mono/src/alias_analysis.rs | 2 +- compiler/mono/src/inc_dec.rs | 6 ++++- compiler/mono/src/ir.rs | 37 ++++++++++++++++++++++------- 4 files changed, 55 insertions(+), 20 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index b5a36d72cf..abc78de4ae 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -825,16 +825,25 @@ pub fn build_exp_call<'a, 'ctx, 'env>( op, closure_layout, function_owns_closure_data, - } => run_higher_order_low_level( - env, - layout_ids, - scope, - layout, - *op, - *closure_layout, - *function_owns_closure_data, - arguments, - ), + specialization_id, + } => { + let bytes = specialization_id.to_bytes(); + let callee_var = CalleeSpecVar(&bytes); + let func_spec = func_spec_solutions.callee_spec(callee_var).unwrap(); + // let fn_val = function_value_by_func_spec(env, func_spec, symbol, *layout); + + run_higher_order_low_level( + env, + layout_ids, + scope, + layout, + *op, + *closure_layout, + func_spec, + *function_owns_closure_data, + arguments, + ) + } CallType::Foreign { foreign_symbol, @@ -3793,6 +3802,7 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>( return_layout: &Layout<'a>, op: LowLevel, function_layout: Layout<'a>, + func_spec: FuncSpec, function_owns_closure_data: bool, args: &[Symbol], ) -> BasicValueEnum<'ctx> { diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 89cb62a1cf..494899b0e1 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -414,7 +414,7 @@ fn call_spec( *update_mode, call.arguments, ), - HigherOrderLowLevel { .. } => { + HigherOrderLowLevel { op, .. } => { // TODO overly pessimstic // filter_map because one of the arguments is a function name, which // is not defined in the env diff --git a/compiler/mono/src/inc_dec.rs b/compiler/mono/src/inc_dec.rs index 399ee995c9..b0f0524dcb 100644 --- a/compiler/mono/src/inc_dec.rs +++ b/compiler/mono/src/inc_dec.rs @@ -454,7 +454,10 @@ impl<'a> Context<'a> { } HigherOrderLowLevel { - op, closure_layout, .. + op, + closure_layout, + specialization_id, + .. } => { macro_rules! create_call { ($borrows:expr) => { @@ -464,6 +467,7 @@ impl<'a> Context<'a> { op: *op, closure_layout: *closure_layout, function_owns_closure_data: true, + specialization_id: *specialization_id, } } else { call_type diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 9d52fbd1a1..f5245e5b13 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -1146,6 +1146,8 @@ pub enum CallType<'a> { op: LowLevel, /// the layout of the closure argument, if any closure_layout: Layout<'a>, + /// specialization id of the function argument + specialization_id: CallSpecId, /// does the function need to own the closure data function_owns_closure_data: bool, }, @@ -2707,11 +2709,12 @@ macro_rules! match_on_closure_argument { $env, lambda_set, $closure_data_symbol, - |top_level_function, closure_data, function_layout| self::Call { + |top_level_function, closure_data, function_layout, specialization_id| self::Call { call_type: CallType::HigherOrderLowLevel { op: $op, closure_layout: function_layout, - function_owns_closure_data: false + specialization_id, + function_owns_closure_data: false, }, arguments: arena.alloc([$($x,)* top_level_function, closure_data]), }, @@ -7696,7 +7699,7 @@ fn lowlevel_match_on_lambda_set<'a, ToLowLevelCall>( hole: &'a Stmt<'a>, ) -> Stmt<'a> where - ToLowLevelCall: Fn(Symbol, Symbol, Layout<'a>) -> Call<'a> + Copy, + ToLowLevelCall: Fn(Symbol, Symbol, Layout<'a>, CallSpecId) -> Call<'a> + Copy, { match lambda_set.runtime_representation() { Layout::Union(_) => { @@ -7733,7 +7736,13 @@ where Layout::Struct(_) => { let function_symbol = lambda_set.set[0].0; - let call = to_lowlevel_call(function_symbol, closure_data_symbol, function_layout); + let call_spec_id = env.next_call_specialization_id(); + let call = to_lowlevel_call( + function_symbol, + closure_data_symbol, + function_layout, + call_spec_id, + ); build_call(env, call, assigned, return_layout, env.arena.alloc(hole)) } @@ -7787,7 +7796,7 @@ fn lowlevel_union_lambda_set_to_switch<'a, ToLowLevelCall>( hole: &'a Stmt<'a>, ) -> Stmt<'a> where - ToLowLevelCall: Fn(Symbol, Symbol, Layout<'a>) -> Call<'a> + Copy, + ToLowLevelCall: Fn(Symbol, Symbol, Layout<'a>, CallSpecId) -> Call<'a> + Copy, { debug_assert!(!lambda_set.is_empty()); @@ -7800,7 +7809,13 @@ where let hole = Stmt::Jump(join_point_id, env.arena.alloc([assigned])); - let call = to_lowlevel_call(*function_symbol, closure_data_symbol, function_layout); + let call_spec_id = env.next_call_specialization_id(); + let call = to_lowlevel_call( + *function_symbol, + closure_data_symbol, + function_layout, + call_spec_id, + ); let stmt = build_call(env, call, assigned, return_layout, env.arena.alloc(hole)); branches.push((i as u64, BranchInfo::None, stmt)); @@ -8206,7 +8221,7 @@ fn lowlevel_enum_lambda_set_to_switch<'a, ToLowLevelCall>( hole: &'a Stmt<'a>, ) -> Stmt<'a> where - ToLowLevelCall: Fn(Symbol, Symbol, Layout<'a>) -> Call<'a> + Copy, + ToLowLevelCall: Fn(Symbol, Symbol, Layout<'a>, CallSpecId) -> Call<'a> + Copy, { debug_assert!(!lambda_set.is_empty()); @@ -8219,7 +8234,13 @@ where let hole = Stmt::Jump(join_point_id, env.arena.alloc([result_symbol])); - let call = to_lowlevel_call(*function_symbol, closure_data_symbol, function_layout); + let call_spec_id = env.next_call_specialization_id(); + let call = to_lowlevel_call( + *function_symbol, + closure_data_symbol, + function_layout, + call_spec_id, + ); let stmt = build_call( env, call, From 0145cdc1385f1bd847f9c4911525e551e1e5bb92 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Wed, 9 Jun 2021 19:31:04 +0200 Subject: [PATCH 200/496] fix arg passing --- ci/safe-earthly.sh | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/ci/safe-earthly.sh b/ci/safe-earthly.sh index 77f26e7df5..1a3f9b8e6c 100755 --- a/ci/safe-earthly.sh +++ b/ci/safe-earthly.sh @@ -3,11 +3,8 @@ LOG_FILE="earthly_log.txt" touch $LOG_FILE -ARGS=$1 - -if [[ $ARGS == *"bench"* ]]; then - ARGS="--allow-privileged $ARGS" -fi +# first arg + everything after +ARGS=${@:1} script -efq $LOG_FILE -c "earthly --config ci/earthly-conf.yml $ARGS" EXIT_CODE=$? From 4d86cce96f3ef47c39a52dea634dbb6a5c2f6539 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Wed, 9 Jun 2021 19:40:27 +0200 Subject: [PATCH 201/496] print full earthly command --- ci/safe-earthly.sh | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/ci/safe-earthly.sh b/ci/safe-earthly.sh index 1a3f9b8e6c..00a0b528a3 100755 --- a/ci/safe-earthly.sh +++ b/ci/safe-earthly.sh @@ -5,8 +5,9 @@ touch $LOG_FILE # first arg + everything after ARGS=${@:1} - -script -efq $LOG_FILE -c "earthly --config ci/earthly-conf.yml $ARGS" +FULL_CMD="earthly --config ci/earthly-conf.yml $ARGS" +echo $FULL_CMD +script -efq $LOG_FILE -c "$FULL_CMD" EXIT_CODE=$? if grep -q "failed to mount" "$LOG_FILE"; then From f845f3965bed23b25f01390c718713a05c3bba7f Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Wed, 9 Jun 2021 19:45:05 +0200 Subject: [PATCH 202/496] github action runner debugging --- .github/workflows/benchmarks.yml | 4 ++-- ci/safe-earthly.sh | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index 4cc22013e1..b79abb3914 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -21,14 +21,14 @@ jobs: - name: Earthly version run: earthly --version - - name: on trunk; prepare a self contained benchmark folder + - name: on trunk; prepare a self-contained benchmark folder run: ./ci/safe-earthly.sh --build-arg BENCH_SUFFIX=trunk +prep-bench-folder - uses: actions/checkout@v2 with: clean: "false" # we want to keep the benchmark folder - - name: on current branch; prepare a self contained benchmark folder + - name: on current branch; prepare a self-contained benchmark folder run: ./ci/safe-earthly.sh +prep-bench-folder - name: benchmark trunk diff --git a/ci/safe-earthly.sh b/ci/safe-earthly.sh index 00a0b528a3..a2d22d692e 100755 --- a/ci/safe-earthly.sh +++ b/ci/safe-earthly.sh @@ -1,5 +1,5 @@ #!/usr/bin/env bash - +echo "inside safe earthly" LOG_FILE="earthly_log.txt" touch $LOG_FILE From 73d9e04f60fb7643004342b8f93874fc0e407266 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Wed, 9 Jun 2021 19:47:11 +0200 Subject: [PATCH 203/496] github actions debugging --- .github/workflows/benchmarks.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index b79abb3914..9e1b89cf9d 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -22,7 +22,7 @@ jobs: run: earthly --version - name: on trunk; prepare a self-contained benchmark folder - run: ./ci/safe-earthly.sh --build-arg BENCH_SUFFIX=trunk +prep-bench-folder + run: ./ci/safe-earthly.sh +prep-bench-folder - uses: actions/checkout@v2 with: From 55d6877cdff271ac016a757163a61065eab54260 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Wed, 9 Jun 2021 19:48:42 +0200 Subject: [PATCH 204/496] github actions debugging --- .github/workflows/benchmarks.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index 9e1b89cf9d..b79abb3914 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -22,7 +22,7 @@ jobs: run: earthly --version - name: on trunk; prepare a self-contained benchmark folder - run: ./ci/safe-earthly.sh +prep-bench-folder + run: ./ci/safe-earthly.sh --build-arg BENCH_SUFFIX=trunk +prep-bench-folder - uses: actions/checkout@v2 with: From 3d83fa2878dc5de1c3db2730f2b2fc3d05627787 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Wed, 9 Jun 2021 19:56:40 +0200 Subject: [PATCH 205/496] dont use safe-earthly --- .github/workflows/benchmarks.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index b79abb3914..e959e0c6f9 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -22,14 +22,14 @@ jobs: run: earthly --version - name: on trunk; prepare a self-contained benchmark folder - run: ./ci/safe-earthly.sh --build-arg BENCH_SUFFIX=trunk +prep-bench-folder + run: earthly --config ci/earthly-conf.yml --build-arg BENCH_SUFFIX=trunk +prep-bench-folder - uses: actions/checkout@v2 with: clean: "false" # we want to keep the benchmark folder - name: on current branch; prepare a self-contained benchmark folder - run: ./ci/safe-earthly.sh +prep-bench-folder + run: earthly --config ci/earthly-conf.yml +prep-bench-folder - name: benchmark trunk run: cd bench-folder-trunk && ./target/release/deps/time_bench --bench From fa0e183947c1633d3269ccb82728bf9d1f0c4a3c Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Wed, 9 Jun 2021 20:04:15 +0200 Subject: [PATCH 206/496] forgot to set ulimit --- .github/workflows/benchmarks.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index e959e0c6f9..d9f747570a 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -30,6 +30,9 @@ jobs: - name: on current branch; prepare a self-contained benchmark folder run: earthly --config ci/earthly-conf.yml +prep-bench-folder + + - name: set ulimit to prevent stack overflow error + run: ulimit -s unlimited - name: benchmark trunk run: cd bench-folder-trunk && ./target/release/deps/time_bench --bench From a9bbb25c89bf30ced6669202310176aaa499ecc7 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Wed, 9 Jun 2021 20:31:07 +0200 Subject: [PATCH 207/496] skip cfold --- .github/workflows/benchmarks.yml | 7 +++---- cli/benches/time_bench.rs | 2 +- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index d9f747570a..7e1a331348 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -15,22 +15,21 @@ jobs: steps: - uses: actions/checkout@v2 with: - ref: "5e4fc1dc2fed40fe9f04fbc0797da99090e8bf49" # benchmarking on trunk first in order to compare results clean: "true" - name: Earthly version run: earthly --version - name: on trunk; prepare a self-contained benchmark folder - run: earthly --config ci/earthly-conf.yml --build-arg BENCH_SUFFIX=trunk +prep-bench-folder + run: ./ci/safe-earthly.sh --build-arg BENCH_SUFFIX=trunk +prep-bench-folder - uses: actions/checkout@v2 with: clean: "false" # we want to keep the benchmark folder - name: on current branch; prepare a self-contained benchmark folder - run: earthly --config ci/earthly-conf.yml +prep-bench-folder - + run: ./ci/safe-earthly.sh +prep-bench-folder + - name: set ulimit to prevent stack overflow error run: ulimit -s unlimited diff --git a/cli/benches/time_bench.rs b/cli/benches/time_bench.rs index 062d615533..db154c5f2a 100644 --- a/cli/benches/time_bench.rs +++ b/cli/benches/time_bench.rs @@ -13,7 +13,7 @@ fn bench_group_wall_time(c: &mut Criterion) { let bench_funcs: Vec>) -> ()> = vec![ bench_nqueens, // queens 11 - bench_cfold, // e = mkExpr 17 1 + //bench_cfold, // e = mkExpr 17 1 bench_deriv, // nest deriv 8 f bench_rbtree_ck, // ms = makeMap 5 80000 bench_rbtree_delete, // m = makeMap 100000 From a693cc34e44f08bfdd053f40225426a77ec30c69 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Wed, 9 Jun 2021 20:40:38 +0200 Subject: [PATCH 208/496] don't change dir --- .github/workflows/benchmarks.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index 7e1a331348..3127ff3b29 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -37,7 +37,7 @@ jobs: run: cd bench-folder-trunk && ./target/release/deps/time_bench --bench - name: move benchmark results so they can be compared later - run: cd .. && cp bench-folder-trunk/target/criterion bench-folder-branch/target/ + run: cp bench-folder-trunk/target/criterion bench-folder-branch/target/ - name: benchmark current branch run: cd bench-folder-branch && ./target/release/deps/time_bench --bench From 8d4e67c99057776a9816eb67479c700a7507f7de Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Wed, 9 Jun 2021 20:53:27 +0200 Subject: [PATCH 209/496] cp -r --- .github/workflows/benchmarks.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index 3127ff3b29..05f4ba5990 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -37,7 +37,7 @@ jobs: run: cd bench-folder-trunk && ./target/release/deps/time_bench --bench - name: move benchmark results so they can be compared later - run: cp bench-folder-trunk/target/criterion bench-folder-branch/target/ + run: cp -r bench-folder-trunk/target/criterion bench-folder-branch/target/ - name: benchmark current branch run: cd bench-folder-branch && ./target/release/deps/time_bench --bench From d5f89ccbe6a03b6e9b4c452730a795f10c99a19c Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 9 Jun 2021 23:37:26 +0200 Subject: [PATCH 210/496] fix calling conventions --- compiler/gen_llvm/src/llvm/bitcode.rs | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/compiler/gen_llvm/src/llvm/bitcode.rs b/compiler/gen_llvm/src/llvm/bitcode.rs index a2d98cd868..b9cd56ff58 100644 --- a/compiler/gen_llvm/src/llvm/bitcode.rs +++ b/compiler/gen_llvm/src/llvm/bitcode.rs @@ -110,6 +110,9 @@ fn build_transform_caller_help<'a, 'ctx, 'env>( &(bumpalo::vec![ in env.arena; BasicTypeEnum::PointerType(arg_type); argument_layouts.len() + 2 ]), ); + // called from zig, must use C calling convention + function_value.set_call_conventions(C_CALL_CONV); + let kind_id = Attribute::get_named_enum_kind_id("alwaysinline"); debug_assert!(kind_id > 0); let attr = env.context.create_enum_attribute(kind_id, 1); @@ -303,6 +306,9 @@ fn build_rc_wrapper<'a, 'ctx, 'env>( ), }; + // called from zig, must use C calling convention + function_value.set_call_conventions(C_CALL_CONV); + let kind_id = Attribute::get_named_enum_kind_id("alwaysinline"); debug_assert!(kind_id > 0); let attr = env.context.create_enum_attribute(kind_id, 1); @@ -381,6 +387,9 @@ pub fn build_eq_wrapper<'a, 'ctx, 'env>( &[arg_type.into(), arg_type.into()], ); + // called from zig, must use C calling convention + function_value.set_call_conventions(C_CALL_CONV); + let kind_id = Attribute::get_named_enum_kind_id("alwaysinline"); debug_assert!(kind_id > 0); let attr = env.context.create_enum_attribute(kind_id, 1); @@ -455,6 +464,9 @@ pub fn build_compare_wrapper<'a, 'ctx, 'env>( &[arg_type.into(), arg_type.into(), arg_type.into()], ); + // called from zig, must use C calling convention + function_value.set_call_conventions(C_CALL_CONV); + // we expose this function to zig; must use c calling convention function_value.set_call_conventions(C_CALL_CONV); From ff8d26a0424149534e94f9483661083055c8742f Mon Sep 17 00:00:00 2001 From: Folkert Date: Thu, 10 Jun 2021 12:20:38 +0200 Subject: [PATCH 211/496] fix typo --- compiler/builtins/bitcode/src/dec.zig | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/builtins/bitcode/src/dec.zig b/compiler/builtins/bitcode/src/dec.zig index 55eeff9b24..1fdf363910 100644 --- a/compiler/builtins/bitcode/src/dec.zig +++ b/compiler/builtins/bitcode/src/dec.zig @@ -183,7 +183,7 @@ pub const RocDec = struct { var str_bytes: [max_digits + 2]u8 = undefined; // Join the whole number slice & the decimal slice together - // The format template arg in bufPrint is `comptime`, so we have to repeate the whole statment in each branch + // The format template arg in bufPrint is `comptime`, so we have to repeate the whole statement in each branch if (is_negative) { _ = std.fmt.bufPrint(str_bytes[0 .. str_len + 1], "-{s}.{s}", .{ before_digits_slice, after_digits_slice }) catch { std.debug.panic("TODO runtime exception failing to print slices", .{}); From 58de0c9826b49654661a992a25afe7678c646bb5 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Fri, 11 Jun 2021 12:41:17 +0200 Subject: [PATCH 212/496] trying to fix cfold --- .github/workflows/benchmarks.yml | 4 ++-- cli/benches/time_bench.rs | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index 05f4ba5990..2aaf0a64e4 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -34,10 +34,10 @@ jobs: run: ulimit -s unlimited - name: benchmark trunk - run: cd bench-folder-trunk && ./target/release/deps/time_bench --bench + run: ulimit -s unlimited && cd bench-folder-trunk && ./target/release/deps/time_bench --bench - name: move benchmark results so they can be compared later run: cp -r bench-folder-trunk/target/criterion bench-folder-branch/target/ - name: benchmark current branch - run: cd bench-folder-branch && ./target/release/deps/time_bench --bench + run: ulimit -s unlimited && cd bench-folder-branch && ./target/release/deps/time_bench --bench diff --git a/cli/benches/time_bench.rs b/cli/benches/time_bench.rs index db154c5f2a..062d615533 100644 --- a/cli/benches/time_bench.rs +++ b/cli/benches/time_bench.rs @@ -13,7 +13,7 @@ fn bench_group_wall_time(c: &mut Criterion) { let bench_funcs: Vec>) -> ()> = vec![ bench_nqueens, // queens 11 - //bench_cfold, // e = mkExpr 17 1 + bench_cfold, // e = mkExpr 17 1 bench_deriv, // nest deriv 8 f bench_rbtree_ck, // ms = makeMap 5 80000 bench_rbtree_delete, // m = makeMap 100000 From ae6ed24236287d868778ba05134f155da1015df5 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Fri, 11 Jun 2021 13:38:13 +0200 Subject: [PATCH 213/496] print CPU temp at start of benchmarks --- .github/workflows/benchmarks.yml | 5 +- Cargo.lock | 107 +++++++++++++++++++++++++++++++ cli/Cargo.toml | 1 + cli/benches/time_bench.rs | 7 ++ 4 files changed, 117 insertions(+), 3 deletions(-) diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index 2aaf0a64e4..251c916cd1 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -30,14 +30,13 @@ jobs: - name: on current branch; prepare a self-contained benchmark folder run: ./ci/safe-earthly.sh +prep-bench-folder - - name: set ulimit to prevent stack overflow error - run: ulimit -s unlimited - - name: benchmark trunk run: ulimit -s unlimited && cd bench-folder-trunk && ./target/release/deps/time_bench --bench + # ulimit to prevent stack overflow on cfold - name: move benchmark results so they can be compared later run: cp -r bench-folder-trunk/target/criterion bench-folder-branch/target/ - name: benchmark current branch run: ulimit -s unlimited && cd bench-folder-branch && ./target/release/deps/time_bench --bench + # ulimit to prevent stack overflow on cfold diff --git a/Cargo.lock b/Cargo.lock index a4b14f1473..754ec7b0fb 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -198,6 +198,18 @@ dependencies = [ "typenum", ] +[[package]] +name = "bitvec" +version = "0.19.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8942c8d352ae1838c9dda0b0ca2ab657696ef2232a20147cf1b30ae1a9cb4321" +dependencies = [ + "funty", + "radium", + "tap", + "wyz", +] + [[package]] name = "block" version = "0.1.6" @@ -290,6 +302,12 @@ version = "0.5.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0e4cec68f03f32e44924783795810fa50a7035d8c8ebe78580ad7e6c703fba38" +[[package]] +name = "bytesize" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "81a18687293a1546b67c246452202bbbf143d239cb43494cc163da14979082da" + [[package]] name = "calloop" version = "0.6.5" @@ -346,6 +364,19 @@ dependencies = [ "num-traits", ] +[[package]] +name = "chrono" +version = "0.4.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "670ad68c9088c2a963aaa298cb369688cf3f9465ce5e2d4ca10e6e0098a1ce73" +dependencies = [ + "libc", + "num-integer", + "num-traits", + "time", + "winapi 0.3.9", +] + [[package]] name = "clap" version = "2.33.3" @@ -1069,6 +1100,12 @@ version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3dcaa9ae7725d12cdb85b3ad99a434db70b468c09ded17e012d86b5c1010f7a7" +[[package]] +name = "funty" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fed34cd105917e91daa4da6b3728c47b068749d6a62c59811f06ed2ac71d9da7" + [[package]] name = "futures" version = "0.3.15" @@ -1755,6 +1792,19 @@ version = "1.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55" +[[package]] +name = "lexical-core" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6607c62aa161d23d17a9072cc5da0be67cdfc89d3afb1e8d9c842bebc2525ffe" +dependencies = [ + "arrayvec", + "bitflags", + "cfg-if 1.0.0", + "ryu", + "static_assertions", +] + [[package]] name = "libc" version = "0.2.95" @@ -2064,6 +2114,9 @@ version = "6.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e7413f999671bd4745a7b624bd370a569fb6bc574b23c83a3c5ed2e453f3d5e2" dependencies = [ + "bitvec", + "funty", + "lexical-core", "memchr", "version_check", ] @@ -2074,6 +2127,16 @@ version = "0.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7fa586da3e43cc7df44aae0e21ed2e743218b876de3f38035683d30bd8a3828e" +[[package]] +name = "num-integer" +version = "0.1.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2cc698a63b549a70bc047073d2949cce27cd1c7b0a4a862d08a8031bc2801db" +dependencies = [ + "autocfg 1.0.1", + "num-traits", +] + [[package]] name = "num-traits" version = "0.2.14" @@ -2609,6 +2672,12 @@ dependencies = [ "proc-macro2 1.0.27", ] +[[package]] +name = "radium" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "941ba9d78d8e2f7ce474c015eea4d9c6d25b6a3327f9832ee29a4de27f91bbb8" + [[package]] name = "rand" version = "0.6.5" @@ -3039,6 +3108,7 @@ dependencies = [ "rustyline", "rustyline-derive", "serial_test", + "systemstat", "target-lexicon", "tempfile", ] @@ -3860,6 +3930,27 @@ dependencies = [ "unicode-xid 0.2.2", ] +[[package]] +name = "systemstat" +version = "0.1.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a934f8fe2f893260080fdde71e840b35308f48bf3bd3b261cb24e668c4b48db3" +dependencies = [ + "bytesize", + "chrono", + "lazy_static", + "libc", + "nom", + "time", + "winapi 0.3.9", +] + +[[package]] +name = "tap" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369" + [[package]] name = "target-lexicon" version = "0.10.0" @@ -4016,6 +4107,16 @@ version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "87b4947742c93ece24a0032141d9caa3d853752e694a57e35029dd2bd08673e0" +[[package]] +name = "time" +version = "0.1.43" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ca8a50ef2360fbd1eeb0ecd46795a87a19024eb4b53c5dc916ca1fd95fe62438" +dependencies = [ + "libc", + "winapi 0.3.9", +] + [[package]] name = "tinytemplate" version = "1.2.1" @@ -4539,6 +4640,12 @@ dependencies = [ "rand_core 0.4.2", ] +[[package]] +name = "wyz" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85e60b0d1b5f99db2556934e21937020776a5d31520bf169e851ac44e6420214" + [[package]] name = "x11-clipboard" version = "0.5.2" diff --git a/cli/Cargo.toml b/cli/Cargo.toml index 531e9a76ee..f9cd5f84be 100644 --- a/cli/Cargo.toml +++ b/cli/Cargo.toml @@ -81,6 +81,7 @@ serial_test = "0.5" tempfile = "3.1.0" criterion = { git = "https://github.com/Anton-4/criterion.rs"} cli_utils = { path = "cli_utils" } +systemstat = "0.1.8" [[bench]] name = "time_bench" diff --git a/cli/benches/time_bench.rs b/cli/benches/time_bench.rs index 062d615533..7d6018e11f 100644 --- a/cli/benches/time_bench.rs +++ b/cli/benches/time_bench.rs @@ -4,8 +4,15 @@ use cli_utils::bench_utils::{ use criterion::{ criterion_group, criterion_main, measurement::WallTime, BenchmarkGroup, Criterion, SamplingMode, }; +use systemstat::{Platform, System}; fn bench_group_wall_time(c: &mut Criterion) { + // print CPU temp + match System::new().cpu_temp() { + Ok(cpu_temp) => println!("\nCPU temp: {}", cpu_temp), + Err(x) => println!("Failed to get CPU temp: {}", x), + } + let mut group = c.benchmark_group("bench-group_wall-time"); // calculate statistics based on a fixed(flat) 200 runs group.sampling_mode(SamplingMode::Flat); From 87292d0c9085d404c7678c8ac414fff2e312bd70 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Fri, 11 Jun 2021 14:24:46 +0200 Subject: [PATCH 214/496] can't read CPU temp in a VM, increased bench runs --- Cargo.lock | 107 -------------------------------------- cli/Cargo.toml | 1 - cli/benches/time_bench.rs | 11 +--- 3 files changed, 2 insertions(+), 117 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 754ec7b0fb..a4b14f1473 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -198,18 +198,6 @@ dependencies = [ "typenum", ] -[[package]] -name = "bitvec" -version = "0.19.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8942c8d352ae1838c9dda0b0ca2ab657696ef2232a20147cf1b30ae1a9cb4321" -dependencies = [ - "funty", - "radium", - "tap", - "wyz", -] - [[package]] name = "block" version = "0.1.6" @@ -302,12 +290,6 @@ version = "0.5.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0e4cec68f03f32e44924783795810fa50a7035d8c8ebe78580ad7e6c703fba38" -[[package]] -name = "bytesize" -version = "1.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "81a18687293a1546b67c246452202bbbf143d239cb43494cc163da14979082da" - [[package]] name = "calloop" version = "0.6.5" @@ -364,19 +346,6 @@ dependencies = [ "num-traits", ] -[[package]] -name = "chrono" -version = "0.4.19" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "670ad68c9088c2a963aaa298cb369688cf3f9465ce5e2d4ca10e6e0098a1ce73" -dependencies = [ - "libc", - "num-integer", - "num-traits", - "time", - "winapi 0.3.9", -] - [[package]] name = "clap" version = "2.33.3" @@ -1100,12 +1069,6 @@ version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3dcaa9ae7725d12cdb85b3ad99a434db70b468c09ded17e012d86b5c1010f7a7" -[[package]] -name = "funty" -version = "1.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fed34cd105917e91daa4da6b3728c47b068749d6a62c59811f06ed2ac71d9da7" - [[package]] name = "futures" version = "0.3.15" @@ -1792,19 +1755,6 @@ version = "1.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55" -[[package]] -name = "lexical-core" -version = "0.7.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6607c62aa161d23d17a9072cc5da0be67cdfc89d3afb1e8d9c842bebc2525ffe" -dependencies = [ - "arrayvec", - "bitflags", - "cfg-if 1.0.0", - "ryu", - "static_assertions", -] - [[package]] name = "libc" version = "0.2.95" @@ -2114,9 +2064,6 @@ version = "6.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e7413f999671bd4745a7b624bd370a569fb6bc574b23c83a3c5ed2e453f3d5e2" dependencies = [ - "bitvec", - "funty", - "lexical-core", "memchr", "version_check", ] @@ -2127,16 +2074,6 @@ version = "0.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7fa586da3e43cc7df44aae0e21ed2e743218b876de3f38035683d30bd8a3828e" -[[package]] -name = "num-integer" -version = "0.1.44" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d2cc698a63b549a70bc047073d2949cce27cd1c7b0a4a862d08a8031bc2801db" -dependencies = [ - "autocfg 1.0.1", - "num-traits", -] - [[package]] name = "num-traits" version = "0.2.14" @@ -2672,12 +2609,6 @@ dependencies = [ "proc-macro2 1.0.27", ] -[[package]] -name = "radium" -version = "0.5.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "941ba9d78d8e2f7ce474c015eea4d9c6d25b6a3327f9832ee29a4de27f91bbb8" - [[package]] name = "rand" version = "0.6.5" @@ -3108,7 +3039,6 @@ dependencies = [ "rustyline", "rustyline-derive", "serial_test", - "systemstat", "target-lexicon", "tempfile", ] @@ -3930,27 +3860,6 @@ dependencies = [ "unicode-xid 0.2.2", ] -[[package]] -name = "systemstat" -version = "0.1.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a934f8fe2f893260080fdde71e840b35308f48bf3bd3b261cb24e668c4b48db3" -dependencies = [ - "bytesize", - "chrono", - "lazy_static", - "libc", - "nom", - "time", - "winapi 0.3.9", -] - -[[package]] -name = "tap" -version = "1.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369" - [[package]] name = "target-lexicon" version = "0.10.0" @@ -4107,16 +4016,6 @@ version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "87b4947742c93ece24a0032141d9caa3d853752e694a57e35029dd2bd08673e0" -[[package]] -name = "time" -version = "0.1.43" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ca8a50ef2360fbd1eeb0ecd46795a87a19024eb4b53c5dc916ca1fd95fe62438" -dependencies = [ - "libc", - "winapi 0.3.9", -] - [[package]] name = "tinytemplate" version = "1.2.1" @@ -4640,12 +4539,6 @@ dependencies = [ "rand_core 0.4.2", ] -[[package]] -name = "wyz" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "85e60b0d1b5f99db2556934e21937020776a5d31520bf169e851ac44e6420214" - [[package]] name = "x11-clipboard" version = "0.5.2" diff --git a/cli/Cargo.toml b/cli/Cargo.toml index f9cd5f84be..531e9a76ee 100644 --- a/cli/Cargo.toml +++ b/cli/Cargo.toml @@ -81,7 +81,6 @@ serial_test = "0.5" tempfile = "3.1.0" criterion = { git = "https://github.com/Anton-4/criterion.rs"} cli_utils = { path = "cli_utils" } -systemstat = "0.1.8" [[bench]] name = "time_bench" diff --git a/cli/benches/time_bench.rs b/cli/benches/time_bench.rs index 7d6018e11f..d86230a669 100644 --- a/cli/benches/time_bench.rs +++ b/cli/benches/time_bench.rs @@ -4,19 +4,12 @@ use cli_utils::bench_utils::{ use criterion::{ criterion_group, criterion_main, measurement::WallTime, BenchmarkGroup, Criterion, SamplingMode, }; -use systemstat::{Platform, System}; fn bench_group_wall_time(c: &mut Criterion) { - // print CPU temp - match System::new().cpu_temp() { - Ok(cpu_temp) => println!("\nCPU temp: {}", cpu_temp), - Err(x) => println!("Failed to get CPU temp: {}", x), - } - let mut group = c.benchmark_group("bench-group_wall-time"); - // calculate statistics based on a fixed(flat) 200 runs + // calculate statistics based on a fixed(flat) 300 runs group.sampling_mode(SamplingMode::Flat); - group.sample_size(200); + group.sample_size(300); let bench_funcs: Vec>) -> ()> = vec![ bench_nqueens, // queens 11 From b7196e98fc7d48a3f4dfdb38435953a49dd0c61d Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Fri, 11 Jun 2021 14:52:18 +0200 Subject: [PATCH 215/496] compare to actual trunk --- .github/workflows/benchmarks.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index 251c916cd1..f6327d5bb8 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -15,6 +15,7 @@ jobs: steps: - uses: actions/checkout@v2 with: + ref: "trunk" clean: "true" - name: Earthly version From 13e585d5efe48d015eb06da0fe8c906ba2fc5a45 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Fri, 11 Jun 2021 15:38:31 +0200 Subject: [PATCH 216/496] final touches --- Earthfile | 1 + ci/safe-earthly.sh | 1 - nightly_benches/README.me | 14 ++++++++++++++ nightly_benches/benches/events_bench.rs | 4 ++-- nightly_benches/src/main.rs | 7 ++++++- 5 files changed, 23 insertions(+), 4 deletions(-) create mode 100644 nightly_benches/README.me diff --git a/Earthfile b/Earthfile index 2322243d0d..0c580ac0ca 100644 --- a/Earthfile +++ b/Earthfile @@ -129,6 +129,7 @@ test-all: BUILD +test-rust BUILD +verify-no-git-changes +# compile everything needed for benchmarks and output a self-contained folder prep-bench-folder: FROM +copy-dirs-and-cache ARG BENCH_SUFFIX=branch diff --git a/ci/safe-earthly.sh b/ci/safe-earthly.sh index a2d22d692e..0ddc13c5c0 100755 --- a/ci/safe-earthly.sh +++ b/ci/safe-earthly.sh @@ -1,5 +1,4 @@ #!/usr/bin/env bash -echo "inside safe earthly" LOG_FILE="earthly_log.txt" touch $LOG_FILE diff --git a/nightly_benches/README.me b/nightly_benches/README.me new file mode 100644 index 0000000000..fb6013bb8f --- /dev/null +++ b/nightly_benches/README.me @@ -0,0 +1,14 @@ +# Running benchmarks + + Install cargo criterion: + ``` + cargo install --git https://github.com/Anton-4/cargo-criterion --branch main + ``` + Necessary to get cache misses...: + ``` + sudo sh -c 'echo 1 >/proc/sys/kernel/perf_event_paranoid' + ``` + run: + ``` + cargo criterion + ``` \ No newline at end of file diff --git a/nightly_benches/benches/events_bench.rs b/nightly_benches/benches/events_bench.rs index 2155dd89be..c722eeae7c 100644 --- a/nightly_benches/benches/events_bench.rs +++ b/nightly_benches/benches/events_bench.rs @@ -87,8 +87,8 @@ criterion_group!( criterion_main!( benches_instructions, - /*benches_cache_refs, + benches_cache_refs, benches_cache_misses, benches_branch_instructions, - benches_branch_misses*/ + benches_branch_misses ); diff --git a/nightly_benches/src/main.rs b/nightly_benches/src/main.rs index e7a11a969c..7fbb8e7beb 100644 --- a/nightly_benches/src/main.rs +++ b/nightly_benches/src/main.rs @@ -1,3 +1,8 @@ fn main() { - println!("Hello, world!"); + println!(""" + To run benchmarks: + - Install cargo criterion: cargo install --git https://github.com/Anton-4/cargo-criterion --branch main + - Necessary to get cache misses...: sudo sh -c 'echo 1 >/proc/sys/kernel/perf_event_paranoid' + - run: cargo criterion + """); } From df2fdc7d8d44ef590549e83e3146e3bf029f268f Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Sat, 12 Jun 2021 14:50:01 +0200 Subject: [PATCH 217/496] No suitable version of LLVM was found --- BUILDING_FROM_SOURCE.md | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/BUILDING_FROM_SOURCE.md b/BUILDING_FROM_SOURCE.md index d055e8612c..c40a02e40d 100644 --- a/BUILDING_FROM_SOURCE.md +++ b/BUILDING_FROM_SOURCE.md @@ -76,6 +76,8 @@ sudo ln -s /usr/bin/llvm-as-12 /usr/bin/llvm-as There are also alternative installation options at http://releases.llvm.org/download.html +[Troubleshooting](#troubleshooting) + ## Using Nix ### Install @@ -154,6 +156,13 @@ On Ubuntu, running `sudo apt install pkg-config cmake libx11-dev` fixed this. If you encounter `cannot find -lz` run `sudo apt install zlib1g-dev`. +If you encounter: +``` +error: No suitable version of LLVM was found system-wide or pointed + to by LLVM_SYS_120_PREFIX. +``` +Add `export LLVM_SYS_120_PREFIX=/usr/lib/llvm-12` to your `~/.bashrc` or equivalent file for your shell. + ### LLVM installation on macOS If installing LLVM fails, it might help to run `sudo xcode-select -r` before installing again. From 2680e475d193c5ded2ec95b69fbae7704af53c2c Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Sat, 12 Jun 2021 15:17:37 +0200 Subject: [PATCH 218/496] Feature name correction --- cli/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cli/src/lib.rs b/cli/src/lib.rs index 332be94d61..0797309a1a 100644 --- a/cli/src/lib.rs +++ b/cli/src/lib.rs @@ -100,7 +100,7 @@ pub fn build_app<'a>() -> App<'a> { ) ); - if cfg!(feature = "edit") { + if cfg!(feature = "editor") { app.subcommand( App::new(CMD_EDIT).about("Launch the Roc editor").arg( Arg::with_name(DIRECTORY_OR_FILES) From 86f35c33cdc311fecdc1a2511a2fa074bfbc345f Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 12 Jun 2021 23:05:06 +0200 Subject: [PATCH 219/496] work on higher order lowlevels --- compiler/gen_llvm/src/llvm/build.rs | 14 +---- compiler/mono/src/alias_analysis.rs | 62 ++++++++++++++++++- compiler/mono/src/inc_dec.rs | 4 ++ compiler/mono/src/ir.rs | 12 +++- compiler/mono/src/layout.rs | 1 + .../quicksort/platform/Package-Config.roc | 2 + 6 files changed, 81 insertions(+), 14 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index abc78de4ae..527371c132 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -826,6 +826,7 @@ pub fn build_exp_call<'a, 'ctx, 'env>( closure_layout, function_owns_closure_data, specialization_id, + .. } => { let bytes = specialization_id.to_bytes(); let callee_var = CalleeSpecVar(&bytes); @@ -3815,18 +3816,7 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>( ($index:expr) => {{ let function_symbol = args[$index]; - let fn_name = layout_ids - .get(function_symbol, &function_layout) - .to_symbol_string(function_symbol, &env.interns); - - env.module - .get_function(fn_name.as_str()) - .unwrap_or_else(|| { - panic!( - "Could not get pointer to unknown function {:?} {:?}", - fn_name, function_layout - ) - }) + function_value_by_func_spec(env, func_spec, function_symbol, function_layout) }}; } diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 494899b0e1..8449448978 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -414,7 +414,64 @@ fn call_spec( *update_mode, call.arguments, ), - HigherOrderLowLevel { op, .. } => { + HigherOrderLowLevel { + specialization_id, + closure_layout: _, + op, + arg_layouts, + ret_layout, + .. + } => { + let array = specialization_id.to_bytes(); + let spec_var = CalleeSpecVar(&array); + + let symbol = { + use roc_module::low_level::LowLevel::*; + + match op { + ListMap | ListMapWithIndex => call.arguments[1], + ListMap2 => call.arguments[2], + ListMap3 => call.arguments[3], + ListWalk | ListWalkUntil | ListWalkBackwards | DictWalk => call.arguments[2], + ListKeepIf | ListKeepOks | ListKeepErrs => call.arguments[1], + ListSortWith => call.arguments[1], + _ => unreachable!(), + } + }; + + let it = arg_layouts.iter().copied(); + let bytes = func_name_bytes_help(symbol, it, *ret_layout); + let name = FuncName(&bytes); + let module = MOD_APP; + + { + use roc_module::low_level::LowLevel::*; + + match op { + DictWalk => { + let dict = env.symbols[&call.arguments[0]]; + let default = env.symbols[&call.arguments[1]]; + + let bag = builder.add_get_tuple_field(block, dict, DICT_BAG_INDEX)?; + let _cell = builder.add_get_tuple_field(block, dict, DICT_CELL_INDEX)?; + + let first = builder.add_bag_get(block, bag)?; + + let argument = builder.add_make_tuple(block, &[first, default])?; + builder.add_call(block, spec_var, module, name, argument)?; + } + _ => { + // fake a call to the function argument + // to make sure the function is specialized + + // very invalid + let arg_value_id = build_tuple_value(builder, env, block, &[])?; + + builder.add_call(block, spec_var, module, name, arg_value_id)?; + } + } + } + // TODO overly pessimstic // filter_map because one of the arguments is a function name, which // is not defined in the env @@ -773,6 +830,9 @@ fn str_type(builder: &mut TC) -> Result { const LIST_CELL_INDEX: u32 = 0; const LIST_BAG_INDEX: u32 = 1; +const DICT_CELL_INDEX: u32 = LIST_CELL_INDEX; +const DICT_BAG_INDEX: u32 = LIST_BAG_INDEX; + fn new_list(builder: &mut FuncDefBuilder, block: BlockId, element_type: TypeId) -> Result { let cell = builder.add_new_heap_cell(block)?; let bag = builder.add_empty_bag(block, element_type)?; diff --git a/compiler/mono/src/inc_dec.rs b/compiler/mono/src/inc_dec.rs index b0f0524dcb..eb7fa7903a 100644 --- a/compiler/mono/src/inc_dec.rs +++ b/compiler/mono/src/inc_dec.rs @@ -457,6 +457,8 @@ impl<'a> Context<'a> { op, closure_layout, specialization_id, + arg_layouts, + ret_layout, .. } => { macro_rules! create_call { @@ -468,6 +470,8 @@ impl<'a> Context<'a> { closure_layout: *closure_layout, function_owns_closure_data: true, specialization_id: *specialization_id, + arg_layouts, + ret_layout: *ret_layout, } } else { call_type diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index f5245e5b13..9031307d40 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -1150,6 +1150,9 @@ pub enum CallType<'a> { specialization_id: CallSpecId, /// does the function need to own the closure data function_owns_closure_data: bool, + /// function layout + arg_layouts: &'a [Layout<'a>], + ret_layout: Layout<'a>, }, } @@ -2703,6 +2706,11 @@ macro_rules! match_on_closure_argument { let arena = $env.arena; + let function_layout = arena.alloc(top_level).full(); + + let arg_layouts = top_level.arguments; + let ret_layout = top_level.result; + match closure_data_layout { Layout::Closure(_, lambda_set, _) => { lowlevel_match_on_lambda_set( @@ -2715,10 +2723,12 @@ macro_rules! match_on_closure_argument { closure_layout: function_layout, specialization_id, function_owns_closure_data: false, + arg_layouts, + ret_layout, }, arguments: arena.alloc([$($x,)* top_level_function, closure_data]), }, - arena.alloc(top_level).full(), + function_layout, $layout, $assigned, $hole, diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index 79176a02b5..5a8a3f75e4 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -43,6 +43,7 @@ pub enum Layout<'a> { Struct(&'a [Layout<'a>]), Union(UnionLayout<'a>), RecursivePointer, + /// A function. The types of its arguments, then the type of its return value. FunctionPointer(&'a [Layout<'a>], &'a Layout<'a>), Closure(&'a [Layout<'a>], LambdaSet<'a>, &'a Layout<'a>), diff --git a/examples/quicksort/platform/Package-Config.roc b/examples/quicksort/platform/Package-Config.roc index 9569118e7b..2c5757a71e 100644 --- a/examples/quicksort/platform/Package-Config.roc +++ b/examples/quicksort/platform/Package-Config.roc @@ -6,5 +6,7 @@ platform examples/quicksort provides [ mainForHost ] effects fx.Effect {} +update : Model -> Model + mainForHost : List I64 -> List I64 mainForHost = \list -> quicksort list From dc8d1135c985ad1457f0949791494ad4da6568d4 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 13 Jun 2021 00:17:35 +0200 Subject: [PATCH 220/496] use inkwell's invoke stuff --- Cargo.lock | 7 +- compiler/gen_llvm/Cargo.toml | 1 - compiler/gen_llvm/src/llvm/build.rs | 239 +++++++++++++++------------- vendor/inkwell/Cargo.toml | 2 +- 4 files changed, 132 insertions(+), 117 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 5a68dbd35f..1b8c1b7a9d 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1618,13 +1618,13 @@ dependencies = [ name = "inkwell" version = "0.1.0" dependencies = [ - "inkwell 0.1.0 (git+https://github.com/rtfeldman/inkwell?tag=llvm12-0.release4)", + "inkwell 0.1.0 (git+https://github.com/rtfeldman/inkwell?tag=llvm12-0.release5)", ] [[package]] name = "inkwell" version = "0.1.0" -source = "git+https://github.com/rtfeldman/inkwell?tag=llvm12-0.release4#8d7174fc8da4d2e6f2555f9ec2b3f7464ec5026b" +source = "git+https://github.com/rtfeldman/inkwell?tag=llvm12-0.release5#b5aa51313d4cfa4e1b52ad630cb786140671478b" dependencies = [ "either", "inkwell_internals", @@ -1638,7 +1638,7 @@ dependencies = [ [[package]] name = "inkwell_internals" version = "0.3.0" -source = "git+https://github.com/rtfeldman/inkwell?tag=llvm12-0.release4#8d7174fc8da4d2e6f2555f9ec2b3f7464ec5026b" +source = "git+https://github.com/rtfeldman/inkwell?tag=llvm12-0.release5#b5aa51313d4cfa4e1b52ad630cb786140671478b" dependencies = [ "proc-macro2 1.0.27", "quote 1.0.9", @@ -3212,7 +3212,6 @@ name = "roc_gen_llvm" version = "0.1.0" dependencies = [ "bumpalo", - "either", "im 14.3.0", "im-rc 14.3.0", "indoc 0.3.6", diff --git a/compiler/gen_llvm/Cargo.toml b/compiler/gen_llvm/Cargo.toml index ab07ce48e8..2a9a573416 100644 --- a/compiler/gen_llvm/Cargo.toml +++ b/compiler/gen_llvm/Cargo.toml @@ -20,7 +20,6 @@ im = "14" # im and im-rc should always have the same version! im-rc = "14" # im and im-rc should always have the same version! bumpalo = { version = "3.6.1", features = ["collections"] } inlinable_string = "0.1" -either = "1.6.1" inkwell = { path = "../../vendor/inkwell" } target-lexicon = "0.10" diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 3d84e2c3ad..e4cd7132f6 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -25,7 +25,6 @@ use crate::llvm::refcounting::{ }; use bumpalo::collections::Vec; use bumpalo::Bump; -use either::Either; use inkwell::basic_block::BasicBlock; use inkwell::builder::Builder; use inkwell::context::Context; @@ -38,8 +37,8 @@ use inkwell::passes::{PassManager, PassManagerBuilder}; use inkwell::types::{BasicType, BasicTypeEnum, FunctionType, IntType, StructType}; use inkwell::values::BasicValueEnum::{self, *}; use inkwell::values::{ - BasicValue, CallSiteValue, FloatValue, FunctionValue, InstructionOpcode, InstructionValue, - IntValue, PointerValue, StructValue, + BasicValue, CallSiteValue, CallableValue, FloatValue, FunctionValue, InstructionOpcode, + InstructionValue, IntValue, PointerValue, StructValue, }; use inkwell::OptimizationLevel; use inkwell::{AddressSpace, IntPredicate}; @@ -53,7 +52,7 @@ use roc_mono::ir::{ Wrapped, }; use roc_mono::layout::{Builtin, InPlace, LambdaSet, Layout, LayoutIds, UnionLayout}; -use target_lexicon::CallingConvention; +use std::convert::TryFrom; /// This is for Inkwell's FunctionValue::verify - we want to know the verification /// output in debug builds, but we don't want it to print to stdout in release builds! @@ -1807,7 +1806,7 @@ fn invoke_roc_function<'a, 'ctx, 'env>( parent: FunctionValue<'ctx>, symbol: Symbol, layout: Layout<'a>, - function_value: Either, PointerValue<'ctx>>, + function_value: FunctionValue<'ctx>, arguments: &[Symbol], closure_argument: Option>, pass: &'a roc_mono::ir::Stmt<'a>, @@ -1835,14 +1834,7 @@ fn invoke_roc_function<'a, 'ctx, 'env>( "tmp", ); - match function_value { - Either::Left(function) => { - call.set_call_convention(function.get_call_conventions()); - } - Either::Right(_) => { - call.set_call_convention(FAST_CALL_CONV); - } - } + call.set_call_convention(function_value.get_call_conventions()); call.try_as_basic_value() .left() @@ -1869,10 +1861,13 @@ fn invoke_roc_function<'a, 'ctx, 'env>( context.struct_type(&[exception_ptr, selector_value], false) }; - let exception_object = env.builder.build_cleanup_landing_pad( - &landing_pad_type, - &BasicValueEnum::IntValue(context.i8_type().const_zero()), - context.i8_type().ptr_type(AddressSpace::Generic), + let personality_function = get_gxx_personality_v0(env); + + let exception_object = env.builder.build_landing_pad( + landing_pad_type, + personality_function, + &[], + true, "invoke_landing_pad", ); @@ -2009,7 +2004,7 @@ pub fn build_exp_stmt<'a, 'ctx, 'env>( parent, *symbol, *layout, - function_value.into(), + function_value, call.arguments, None, pass, @@ -2048,7 +2043,7 @@ pub fn build_exp_stmt<'a, 'ctx, 'env>( Resume(exception_id) => { let exception_object = scope.get(&exception_id.into_inner()).unwrap().1; - env.builder.build_resume(&exception_object); + env.builder.build_resume(exception_object); env.context.i64_type().const_zero().into() } @@ -2751,18 +2746,17 @@ fn invoke_and_catch<'a, 'ctx, 'env, F, T>( env: &Env<'a, 'ctx, 'env>, parent: FunctionValue<'ctx>, function: F, + calling_convention: u32, arguments: &[BasicValueEnum<'ctx>], return_type: T, ) -> BasicValueEnum<'ctx> where - F: Into, PointerValue<'ctx>>>, T: inkwell::types::BasicType<'ctx>, + F: Into>, { let context = env.context; let builder = env.builder; - let u8_ptr = env.context.i8_type().ptr_type(AddressSpace::Generic); - let call_result_type = context.struct_type( &[context.i64_type().into(), return_type.as_basic_type_enum()], false, @@ -2783,7 +2777,7 @@ where catch_block, "call_roc_function", ); - call.set_call_convention(FAST_CALL_CONV); + call.set_call_convention(calling_convention); call.try_as_basic_value().left().unwrap() }; @@ -2791,71 +2785,7 @@ where { builder.position_at_end(catch_block); - let landing_pad_type = { - let exception_ptr = context.i8_type().ptr_type(AddressSpace::Generic).into(); - let selector_value = context.i32_type().into(); - - context.struct_type(&[exception_ptr, selector_value], false) - }; - - let info = builder - .build_catch_all_landing_pad( - &landing_pad_type, - &BasicValueEnum::IntValue(context.i8_type().const_zero()), - context.i8_type().ptr_type(AddressSpace::Generic), - "main_landing_pad", - ) - .into_struct_value(); - - let exception_ptr = builder - .build_extract_value(info, 0, "exception_ptr") - .unwrap(); - - let thrown = cxa_begin_catch(env, exception_ptr); - - let error_msg = { - let exception_type = u8_ptr; - let ptr = builder.build_bitcast( - thrown, - exception_type.ptr_type(AddressSpace::Generic), - "cast", - ); - - builder.build_load(ptr.into_pointer_value(), "error_msg") - }; - - let return_type = context.struct_type(&[context.i64_type().into(), u8_ptr.into()], false); - - let return_value = { - let v1 = return_type.const_zero(); - - // flag is non-zero, indicating failure - let flag = context.i64_type().const_int(1, false); - - let v2 = builder - .build_insert_value(v1, flag, 0, "set_error") - .unwrap(); - - let v3 = builder - .build_insert_value(v2, error_msg, 1, "set_exception") - .unwrap(); - - v3 - }; - - // bitcast result alloca so we can store our concrete type { flag, error_msg } in there - let result_alloca_bitcast = builder - .build_bitcast( - result_alloca, - return_type.ptr_type(AddressSpace::Generic), - "result_alloca_bitcast", - ) - .into_pointer_value(); - - // store our return value - builder.build_store(result_alloca_bitcast, return_value); - - cxa_end_catch(env); + build_catch_all_landing_pad(env, result_alloca); builder.build_unconditional_branch(cont_block); } @@ -2888,14 +2818,89 @@ where builder.position_at_end(cont_block); - let result = builder.build_load(result_alloca, "result"); + builder.build_load(result_alloca, "result") +} - // MUST set the personality at the very end; - // doing it earlier can cause the personality to be ignored - let personality_func = get_gxx_personality_v0(env); - parent.set_personality_function(personality_func); +fn build_catch_all_landing_pad<'a, 'ctx, 'env>( + env: &Env<'a, 'ctx, 'env>, + result_alloca: PointerValue<'ctx>, +) { + let context = env.context; + let builder = env.builder; - result + let u8_ptr = env.context.i8_type().ptr_type(AddressSpace::Generic); + + let landing_pad_type = { + let exception_ptr = context.i8_type().ptr_type(AddressSpace::Generic).into(); + let selector_value = context.i32_type().into(); + + context.struct_type(&[exception_ptr, selector_value], false) + }; + + // null pointer functions as a catch-all catch clause + let null = u8_ptr.const_zero(); + + let personality_function = get_gxx_personality_v0(env); + + let info = builder + .build_landing_pad( + landing_pad_type, + personality_function, + &[null.into()], + false, + "main_landing_pad", + ) + .into_struct_value(); + + let exception_ptr = builder + .build_extract_value(info, 0, "exception_ptr") + .unwrap(); + + let thrown = cxa_begin_catch(env, exception_ptr); + + let error_msg = { + let exception_type = u8_ptr; + let ptr = builder.build_bitcast( + thrown, + exception_type.ptr_type(AddressSpace::Generic), + "cast", + ); + + builder.build_load(ptr.into_pointer_value(), "error_msg") + }; + + let return_type = context.struct_type(&[context.i64_type().into(), u8_ptr.into()], false); + + let return_value = { + let v1 = return_type.const_zero(); + + // flag is non-zero, indicating failure + let flag = context.i64_type().const_int(1, false); + + let v2 = builder + .build_insert_value(v1, flag, 0, "set_error") + .unwrap(); + + let v3 = builder + .build_insert_value(v2, error_msg, 1, "set_exception") + .unwrap(); + + v3 + }; + + // bitcast result alloca so we can store our concrete type { flag, error_msg } in there + let result_alloca_bitcast = builder + .build_bitcast( + result_alloca, + return_type.ptr_type(AddressSpace::Generic), + "result_alloca_bitcast", + ) + .into_pointer_value(); + + // store our return value + builder.build_store(result_alloca_bitcast, return_value); + + cxa_end_catch(env); } fn make_exception_catcher<'a, 'ctx, 'env>( @@ -2961,17 +2966,13 @@ fn make_exception_catching_wrapper<'a, 'ctx, 'env>( env, wrapper_function, roc_function, + roc_function.get_call_conventions(), &arguments, roc_function_type.get_return_type().unwrap(), ); builder.build_return(Some(&result)); - // MUST set the personality at the very end; - // doing it earlier can cause the personality to be ignored - let personality_func = get_gxx_personality_v0(env); - wrapper_function.set_personality_function(personality_func); - wrapper_function } @@ -3226,8 +3227,14 @@ pub fn build_closure_caller<'a, 'ctx, 'env>( *param = builder.build_load(param.into_pointer_value(), "load_param"); } - let call_result = - invoke_and_catch(env, function_value, evaluator, &[closure_data], result_type); + let call_result = invoke_and_catch( + env, + function_value, + evaluator, + evaluator.get_call_conventions(), + &[closure_data], + result_type, + ); builder.build_store(output, call_result); @@ -3341,7 +3348,14 @@ fn build_function_caller<'a, 'ctx, 'env>( *param = builder.build_load(param.into_pointer_value(), "load_param"); } - let call_result = invoke_and_catch(env, function_value, function_ptr, ¶meters, result_type); + let call_result = invoke_and_catch( + env, + function_value, + CallableValue::try_from(function_ptr).unwrap(), + C_CALL_CONV, + ¶meters, + result_type, + ); builder.build_store(output, call_result); @@ -3580,8 +3594,8 @@ fn call_with_args<'a, 'ctx, 'env>( /// Translates a target_lexicon::Triple to a LLVM calling convention u32 /// as described in https://llvm.org/doxygen/namespacellvm_1_1CallingConv.html -pub fn get_call_conventions(cc: CallingConvention) -> u32 { - use CallingConvention::*; +pub fn get_call_conventions(cc: target_lexicon::CallingConvention) -> u32 { + use target_lexicon::CallingConvention::*; // For now, we're returning 0 for the C calling convention on all of these. // Not sure if we should be picking something more specific! @@ -3593,9 +3607,9 @@ pub fn get_call_conventions(cc: CallingConvention) -> u32 { } /// Source: https://llvm.org/doxygen/namespacellvm_1_1CallingConv.html -pub static C_CALL_CONV: u32 = 0; -pub static FAST_CALL_CONV: u32 = 8; -pub static COLD_CALL_CONV: u32 = 9; +pub const C_CALL_CONV: u32 = 0; +pub const FAST_CALL_CONV: u32 = 8; +pub const COLD_CALL_CONV: u32 = 9; pub struct RocFunctionCall<'ctx> { pub caller: PointerValue<'ctx>, @@ -4958,10 +4972,13 @@ fn build_foreign_symbol<'a, 'ctx, 'env>( .struct_type(&[exception_ptr, selector_value], false) }; - let exception_object = env.builder.build_cleanup_landing_pad( - &landing_pad_type, - &BasicValueEnum::IntValue(env.context.i8_type().const_zero()), - env.context.i8_type().ptr_type(AddressSpace::Generic), + let personality_function = get_gxx_personality_v0(env); + + let exception_object = env.builder.build_landing_pad( + landing_pad_type, + personality_function, + &[], + true, "invoke_landing_pad", ); diff --git a/vendor/inkwell/Cargo.toml b/vendor/inkwell/Cargo.toml index 85af15fec2..fe92300ec6 100644 --- a/vendor/inkwell/Cargo.toml +++ b/vendor/inkwell/Cargo.toml @@ -23,7 +23,7 @@ edition = "2018" # commit of TheDan64/inkwell, push a new tag which points to the latest commit, # change the tag value in this Cargo.toml to point to that tag, and `cargo update`. # This way, GitHub Actions works and nobody's builds get broken. -inkwell = { git = "https://github.com/rtfeldman/inkwell", tag = "llvm12-0.release4", features = [ "llvm12-0" ] } +inkwell = { git = "https://github.com/rtfeldman/inkwell", tag = "llvm12-0.release5", features = [ "llvm12-0" ] } [features] target-arm = [] From ebbdf671ae6210a9b995b5bc0ed2f989c1921afc Mon Sep 17 00:00:00 2001 From: Chadtech Date: Sat, 12 Jun 2021 18:57:59 -0400 Subject: [PATCH 221/496] Look into values exposed by host and only add those entries to the documentation html --- compiler/load/src/docs.rs | 6 +++--- docs/src/lib.rs | 38 ++++++++++++++++++++++++++------------ 2 files changed, 29 insertions(+), 15 deletions(-) diff --git a/compiler/load/src/docs.rs b/compiler/load/src/docs.rs index 371d9d3ddf..f8dae3f72f 100644 --- a/compiler/load/src/docs.rs +++ b/compiler/load/src/docs.rs @@ -2,11 +2,11 @@ use crate::docs::DocEntry::DetachedDoc; use crate::docs::TypeAnnotation::{ Apply, BoundVariable, Function, NoTypeAnn, ObscuredRecord, ObscuredTagUnion, Record, TagUnion, }; +use crate::file::LoadedModule; use inlinable_string::InlinableString; use roc_can::scope::Scope; -use roc_collections::all::MutMap; use roc_module::ident::ModuleName; -use roc_module::symbol::{IdentIds, Interns, ModuleId}; +use roc_module::symbol::IdentIds; use roc_parse::ast; use roc_parse::ast::CommentOrNewline; use roc_parse::ast::{AssignedField, Def}; @@ -19,7 +19,7 @@ pub struct Documentation { pub name: String, pub version: String, pub docs: String, - pub modules: Vec<(MutMap, Interns)>, + pub modules: Vec, } #[derive(Debug)] diff --git a/docs/src/lib.rs b/docs/src/lib.rs index 66d0eebbe1..1c6de7d35c 100644 --- a/docs/src/lib.rs +++ b/docs/src/lib.rs @@ -3,14 +3,15 @@ use roc_builtins::std::StdLib; use roc_can::builtins::builtin_defs_map; use roc_load::docs::{DocEntry, TypeAnnotation}; use roc_load::docs::{ModuleDocumentation, RecordField}; -use roc_load::file::LoadingProblem; -use roc_module::symbol::{Interns, ModuleId}; +use roc_load::file::{LoadedModule, LoadingProblem}; +use roc_module::symbol::Interns; use std::fs; extern crate roc_load; use bumpalo::Bump; use roc_can::scope::Scope; use roc_collections::all::MutMap; +use roc_load::docs::DocEntry::DocDef; use roc_region::all::Region; use std::path::{Path, PathBuf}; @@ -55,14 +56,20 @@ pub fn generate(filenames: Vec, std_lib: StdLib, build_dir: &Path) { package .modules .iter() - .flat_map(|(docs_by_id, _)| docs_by_id.values()), + .flat_map(|loaded_module| loaded_module.documentation.values()), ) .as_str(), ); // Write each package's module docs html file - for (docs_by_id, interns) in package.modules.iter_mut() { - for module in docs_by_id.values_mut() { + for loaded_module in package.modules.iter_mut() { + let exposed_values = loaded_module + .exposed_to_host + .iter() + .map(|(symbol, _)| symbol.ident_string(&loaded_module.interns).to_string()) + .collect::>(); + + for module in loaded_module.documentation.values_mut() { let module_dir = build_dir.join(module.name.replace(".", "/").as_str()); fs::create_dir_all(&module_dir) @@ -76,7 +83,7 @@ pub fn generate(filenames: Vec, std_lib: StdLib, build_dir: &Path) { ) .replace( "", - render_main_content(interns, module).as_str(), + render_main_content(&loaded_module.interns, &exposed_values, module).as_str(), ); fs::write(module_dir.join("index.html"), rendered_module) @@ -87,7 +94,11 @@ pub fn generate(filenames: Vec, std_lib: StdLib, build_dir: &Path) { println!("🎉 Docs generated in {}", build_dir.display()); } -fn render_main_content(interns: &Interns, module: &mut ModuleDocumentation) -> String { +fn render_main_content( + interns: &Interns, + exposed_values: &Vec, + module: &mut ModuleDocumentation, +) -> String { let mut buf = String::new(); buf.push_str( @@ -100,6 +111,12 @@ fn render_main_content(interns: &Interns, module: &mut ModuleDocumentation) -> S ); for entry in &module.entries { + if let DocDef(def) = entry { + if !exposed_values.contains(&def.name) { + break; + } + } + match entry { DocEntry::DocDef(doc_def) => { let mut href = String::new(); @@ -288,10 +305,7 @@ fn render_sidebar<'a, I: Iterator>(modules: I) - buf } -pub fn files_to_documentations( - filenames: Vec, - std_lib: StdLib, -) -> Vec<(MutMap, Interns)> { +pub fn files_to_documentations(filenames: Vec, std_lib: StdLib) -> Vec { let arena = Bump::new(); let mut files_docs = vec![]; @@ -308,7 +322,7 @@ pub fn files_to_documentations( std::mem::size_of::() as u32, // This is just type-checking for docs, so "target" doesn't matter builtin_defs_map, ) { - Ok(loaded) => files_docs.push((loaded.documentation, loaded.interns)), + Ok(loaded) => files_docs.push(loaded), Err(LoadingProblem::FormattedReport(report)) => { println!("{}", report); panic!(); From f53339a595250fb62be3e90497d5c26159b4cf3c Mon Sep 17 00:00:00 2001 From: Chadtech Date: Sat, 12 Jun 2021 19:09:00 -0400 Subject: [PATCH 222/496] Clippy fix --- docs/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/src/lib.rs b/docs/src/lib.rs index 1c6de7d35c..f96f89a6c2 100644 --- a/docs/src/lib.rs +++ b/docs/src/lib.rs @@ -96,7 +96,7 @@ pub fn generate(filenames: Vec, std_lib: StdLib, build_dir: &Path) { fn render_main_content( interns: &Interns, - exposed_values: &Vec, + exposed_values: &[String], module: &mut ModuleDocumentation, ) -> String { let mut buf = String::new(); From 3683f208381bc43163d0e4bfbf1f41206eefad19 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sat, 12 Jun 2021 22:37:19 -0400 Subject: [PATCH 223/496] Add hello-zig (clone of hello-world) example --- examples/hello-zig/.gitignore | 1 + examples/hello-zig/Hello.roc | 12 +++ examples/hello-zig/README.md | 48 +++++++++++ .../hello-zig/platform/Package-Config.roc | 10 +++ examples/hello-zig/platform/host.zig | 79 +++++++++++++++++++ 5 files changed, 150 insertions(+) create mode 100644 examples/hello-zig/.gitignore create mode 100644 examples/hello-zig/Hello.roc create mode 100644 examples/hello-zig/README.md create mode 100644 examples/hello-zig/platform/Package-Config.roc create mode 100644 examples/hello-zig/platform/host.zig diff --git a/examples/hello-zig/.gitignore b/examples/hello-zig/.gitignore new file mode 100644 index 0000000000..6b820fd903 --- /dev/null +++ b/examples/hello-zig/.gitignore @@ -0,0 +1 @@ +hello-world diff --git a/examples/hello-zig/Hello.roc b/examples/hello-zig/Hello.roc new file mode 100644 index 0000000000..24a02e7823 --- /dev/null +++ b/examples/hello-zig/Hello.roc @@ -0,0 +1,12 @@ +app "hello-world" + packages { base: "platform" } + imports [] + provides [ main ] to base + +greeting = + hi = "Hello" + name = "World" + + "\(hi), \(name)!!!!!!!!!!!!!" + +main = greeting diff --git a/examples/hello-zig/README.md b/examples/hello-zig/README.md new file mode 100644 index 0000000000..a2890f03ed --- /dev/null +++ b/examples/hello-zig/README.md @@ -0,0 +1,48 @@ +# Hello, World! + +To run, `cd` into this directory and run: + +```bash +$ cargo run run Hello.roc +``` + +To run in release mode instead, do: + +```bash +$ cargo run --release run Hello.roc +``` + +## Troubleshooting + +If you encounter `cannot find -lc++`, run the following for ubuntu `sudo apt install libc++-dev`. + +## Design Notes + +This demonstrates the basic design of hosts: Roc code gets compiled into a pure +function (in this case, a thunk that always returns `"Hello, World!"`) and +then the host calls that function. Fundamentally, that's the whole idea! The host +might not even have a `main` - it could be a library, a plugin, anything. +Everything else is built on this basic "hosts calling linked pure functions" design. + +For example, things get more interesting when the compiled Roc function returns +a `Task` - that is, a tagged union data structure containing function pointers +to callback closures. This lets the Roc pure function describe arbitrary +chainable effects, which the host can interpret to perform I/O as requested by +the Roc program. (The tagged union `Task` would have a variant for each supported +I/O operation.) + +In this trivial example, it's very easy to line up the API between the host and +the Roc program. In a more involved host, this would be much trickier - especially +if the API were changing frequently during development. + +The idea there is to have a first-class concept of "glue code" which host authors +can write (it would be plain Roc code, but with some extra keywords that aren't +available in normal modules - kinda like `port module` in Elm), and which +describe both the Roc-host/C boundary as well as the Roc-host/Roc-app boundary. +Roc application authors only care about the Roc-host/Roc-app portion, and the +host author only cares about the Roc-host/C bounary when implementing the host. + +Using this glue code, the Roc compiler can generate C header files describing the +boundary. This not only gets us host compatibility with C compilers, but also +Rust FFI for free, because [`rust-bindgen`](https://github.com/rust-lang/rust-bindgen) +generates correct Rust FFI bindings from C headers. diff --git a/examples/hello-zig/platform/Package-Config.roc b/examples/hello-zig/platform/Package-Config.roc new file mode 100644 index 0000000000..377d5c0994 --- /dev/null +++ b/examples/hello-zig/platform/Package-Config.roc @@ -0,0 +1,10 @@ +platform examples/hello-world + requires {}{ main : Str } + exposes [] + packages {} + imports [] + provides [ mainForHost ] + effects fx.Effect {} + +mainForHost : Str +mainForHost = main diff --git a/examples/hello-zig/platform/host.zig b/examples/hello-zig/platform/host.zig new file mode 100644 index 0000000000..d1a563a68e --- /dev/null +++ b/examples/hello-zig/platform/host.zig @@ -0,0 +1,79 @@ +const std = @import("std"); +const str = @import("str"); +const RocStr = str.RocStr; +const testing = std.testing; +const expectEqual = testing.expectEqual; +const expect = testing.expect; + +comptime { + // This is a workaround for https://github.com/ziglang/zig/issues/8218 + // which is only necessary on macOS. + // + // Once that issue is fixed, we can undo the changes in + // 177cf12e0555147faa4d436e52fc15175c2c4ff0 and go back to passing + // -fcompiler-rt in link.rs instead of doing this. Note that this + // workaround is present in many host.zig files, so make sure to undo + // it everywhere! + if (std.builtin.os.tag == .macos) { + _ = @import("compiler_rt"); + } +} + +extern fn malloc(size: usize) callconv(.C) ?*c_void; +extern fn realloc(c_ptr: [*]align(@alignOf(u128)) u8, size: usize) callconv(.C) ?*c_void; +extern fn free(c_ptr: [*]align(@alignOf(u128)) u8) callconv(.C) void; + +export fn roc_alloc(size: usize, alignment: u32) callconv(.C) ?*c_void { + return malloc(size); +} + +export fn roc_realloc(c_ptr: *c_void, old_size: usize, new_size: usize, alignment: u32) callconv(.C) ?*c_void { + return realloc(@alignCast(16, @ptrCast([*]u8, c_ptr)), new_size); +} + +export fn roc_dealloc(c_ptr: *c_void, alignment: u32) callconv(.C) void { + free(@alignCast(16, @ptrCast([*]u8, c_ptr))); +} + +const mem = std.mem; +const Allocator = mem.Allocator; + +extern fn roc__mainForHost_1_exposed(*RocCallResult) void; + +const RocCallResult = extern struct { flag: usize, content: RocStr }; + +const Unit = extern struct {}; + +pub export fn main() i32 { + const stdout = std.io.getStdOut().writer(); + const stderr = std.io.getStdErr().writer(); + + // make space for the result + var callresult = RocCallResult{ .flag = 0, .content = RocStr.empty() }; + + // start time + var ts1: std.os.timespec = undefined; + std.os.clock_gettime(std.os.CLOCK_REALTIME, &ts1) catch unreachable; + + // actually call roc to populate the callresult + roc__mainForHost_1_exposed(&callresult); + + // stdout the result + stdout.print("{s}\n", .{callresult.content.asSlice()}) catch unreachable; + + callresult.content.deinit(); + + // end time + var ts2: std.os.timespec = undefined; + std.os.clock_gettime(std.os.CLOCK_REALTIME, &ts2) catch unreachable; + + const delta = to_seconds(ts2) - to_seconds(ts1); + + stderr.print("runtime: {d:.3}ms\n", .{delta * 1000}) catch unreachable; + + return 0; +} + +fn to_seconds(tms: std.os.timespec) f64 { + return @intToFloat(f64, tms.tv_sec) + (@intToFloat(f64, tms.tv_nsec) / 1_000_000_000.0); +} From 2fc33054238215236ccb842f8406120bc60645dc Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sat, 12 Jun 2021 22:37:31 -0400 Subject: [PATCH 224/496] Have hello-world example use C --- examples/hello-world/platform/host.c | 76 +++++++++++++++++++++++++ examples/hello-world/platform/host.zig | 79 -------------------------- 2 files changed, 76 insertions(+), 79 deletions(-) create mode 100644 examples/hello-world/platform/host.c delete mode 100644 examples/hello-world/platform/host.zig diff --git a/examples/hello-world/platform/host.c b/examples/hello-world/platform/host.c new file mode 100644 index 0000000000..076f6ca1a4 --- /dev/null +++ b/examples/hello-world/platform/host.c @@ -0,0 +1,76 @@ +#include +#include +#include +#include + +void* roc_alloc(size_t size, unsigned int alignment) { + return malloc(size); +} + +void* roc_realloc(void* ptr, size_t old_size, size_t new_size, unsigned int alignment) { + return realloc(ptr, new_size); +} + +void roc_dealloc(void* ptr, unsigned int alignment) { + free(ptr); +} + +struct RocStr { + char* bytes; + size_t len; +}; + +struct RocCallResult { + size_t flag; + struct RocStr content; +}; + +extern void roc__mainForHost_1_exposed(struct RocCallResult *re); + +const size_t MAX_STACK_STR_BYTES = 1024; + +int main() { + // make space for the result + struct RocCallResult callresult; + + // call roc to populate the callresult + roc__mainForHost_1_exposed(&callresult); + struct RocStr str = callresult.content; + + // Convert from RocStr to C string (null-terminated char*) + size_t len = str.len; + char* c_str; + + // Allocate on the stack unless the string is particularly big. + // (Don't want a stack overflow!) + if (len <= MAX_STACK_STR_BYTES) { + c_str = (char*)alloca(len + 1); + } else { + c_str = (char*)malloc(len + 1); + } + + memcpy(c_str, str.bytes, len); + + // null-terminate + c_str[len] = 0; + + // Print the string to stdout + printf("%s\n", c_str); + + // Pointer to the beginning of the RocStr's actual allocation, which is + // the size_t immediately preceding the first stored byte. + size_t* str_base_ptr = (size_t*)str.bytes - 1; + + // If *str_base_ptr is equal to 0, then the string is in the + // read-only data section of the binary, and can't be freed! + if (*str_base_ptr != 0) { + roc_dealloc(str_base_ptr, 8); + } + + // If we malloc'd c_str, free it. + if (len > MAX_STACK_STR_BYTES) { + free(c_str); + } + + return 0; +} diff --git a/examples/hello-world/platform/host.zig b/examples/hello-world/platform/host.zig deleted file mode 100644 index d1a563a68e..0000000000 --- a/examples/hello-world/platform/host.zig +++ /dev/null @@ -1,79 +0,0 @@ -const std = @import("std"); -const str = @import("str"); -const RocStr = str.RocStr; -const testing = std.testing; -const expectEqual = testing.expectEqual; -const expect = testing.expect; - -comptime { - // This is a workaround for https://github.com/ziglang/zig/issues/8218 - // which is only necessary on macOS. - // - // Once that issue is fixed, we can undo the changes in - // 177cf12e0555147faa4d436e52fc15175c2c4ff0 and go back to passing - // -fcompiler-rt in link.rs instead of doing this. Note that this - // workaround is present in many host.zig files, so make sure to undo - // it everywhere! - if (std.builtin.os.tag == .macos) { - _ = @import("compiler_rt"); - } -} - -extern fn malloc(size: usize) callconv(.C) ?*c_void; -extern fn realloc(c_ptr: [*]align(@alignOf(u128)) u8, size: usize) callconv(.C) ?*c_void; -extern fn free(c_ptr: [*]align(@alignOf(u128)) u8) callconv(.C) void; - -export fn roc_alloc(size: usize, alignment: u32) callconv(.C) ?*c_void { - return malloc(size); -} - -export fn roc_realloc(c_ptr: *c_void, old_size: usize, new_size: usize, alignment: u32) callconv(.C) ?*c_void { - return realloc(@alignCast(16, @ptrCast([*]u8, c_ptr)), new_size); -} - -export fn roc_dealloc(c_ptr: *c_void, alignment: u32) callconv(.C) void { - free(@alignCast(16, @ptrCast([*]u8, c_ptr))); -} - -const mem = std.mem; -const Allocator = mem.Allocator; - -extern fn roc__mainForHost_1_exposed(*RocCallResult) void; - -const RocCallResult = extern struct { flag: usize, content: RocStr }; - -const Unit = extern struct {}; - -pub export fn main() i32 { - const stdout = std.io.getStdOut().writer(); - const stderr = std.io.getStdErr().writer(); - - // make space for the result - var callresult = RocCallResult{ .flag = 0, .content = RocStr.empty() }; - - // start time - var ts1: std.os.timespec = undefined; - std.os.clock_gettime(std.os.CLOCK_REALTIME, &ts1) catch unreachable; - - // actually call roc to populate the callresult - roc__mainForHost_1_exposed(&callresult); - - // stdout the result - stdout.print("{s}\n", .{callresult.content.asSlice()}) catch unreachable; - - callresult.content.deinit(); - - // end time - var ts2: std.os.timespec = undefined; - std.os.clock_gettime(std.os.CLOCK_REALTIME, &ts2) catch unreachable; - - const delta = to_seconds(ts2) - to_seconds(ts1); - - stderr.print("runtime: {d:.3}ms\n", .{delta * 1000}) catch unreachable; - - return 0; -} - -fn to_seconds(tms: std.os.timespec) f64 { - return @intToFloat(f64, tms.tv_sec) + (@intToFloat(f64, tms.tv_nsec) / 1_000_000_000.0); -} From 02bc0036ab9dace497f78969ed1a8613288e1bc3 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 13 Jun 2021 16:54:32 +0200 Subject: [PATCH 225/496] fix wrong tag name used in Dict.get --- compiler/can/src/builtins.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/can/src/builtins.rs b/compiler/can/src/builtins.rs index 636ca3ab19..b6d13be1da 100644 --- a/compiler/can/src/builtins.rs +++ b/compiler/can/src/builtins.rs @@ -2298,7 +2298,7 @@ fn dict_get(symbol: Symbol, var_store: &mut VarStore) -> Def { let make_err = tag( "Err", - vec![tag("OutOfBounds", Vec::new(), var_store)], + vec![tag("KeyNotFound", Vec::new(), var_store)], var_store, ); From ab7f4a70a1d17adcd9281c789cb2c54deade238c Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 13 Jun 2021 16:56:59 +0200 Subject: [PATCH 226/496] remove list_var --- compiler/can/src/expr.rs | 5 ----- compiler/constrain/src/expr.rs | 1 - compiler/mono/src/ir.rs | 1 - 3 files changed, 7 deletions(-) diff --git a/compiler/can/src/expr.rs b/compiler/can/src/expr.rs index 8e40ac2ad7..4116a51128 100644 --- a/compiler/can/src/expr.rs +++ b/compiler/can/src/expr.rs @@ -60,7 +60,6 @@ pub enum Expr { Float(Variable, Variable, f64), Str(InlinableString), List { - list_var: Variable, // required for uniqueness of the list elem_var: Variable, loc_elems: Vec>, }, @@ -304,7 +303,6 @@ pub fn canonicalize_expr<'a>( if loc_elems.is_empty() { ( List { - list_var: var_store.fresh(), elem_var: var_store.fresh(), loc_elems: Vec::new(), }, @@ -331,7 +329,6 @@ pub fn canonicalize_expr<'a>( ( List { - list_var: var_store.fresh(), elem_var: var_store.fresh(), loc_elems: can_elems, }, @@ -1234,7 +1231,6 @@ pub fn inline_calls(var_store: &mut VarStore, scope: &mut Scope, expr: Expr) -> | other @ ForeignCall { .. } => other, List { - list_var, elem_var, loc_elems, } => { @@ -1250,7 +1246,6 @@ pub fn inline_calls(var_store: &mut VarStore, scope: &mut Scope, expr: Expr) -> } List { - list_var, elem_var, loc_elems: new_elems, } diff --git a/compiler/constrain/src/expr.rs b/compiler/constrain/src/expr.rs index ab5a9e15ca..05dff22dd7 100644 --- a/compiler/constrain/src/expr.rs +++ b/compiler/constrain/src/expr.rs @@ -220,7 +220,6 @@ pub fn constrain_expr( List { elem_var, loc_elems, - list_var: _unused, } => { if loc_elems.is_empty() { exists( diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index c021a11676..58e9ab1f3a 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -3393,7 +3393,6 @@ pub fn with_hole<'a>( } List { - list_var: _, elem_var, loc_elems, } => { From 4539c6feb369432d78441ecb12114f2c65737240 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 13 Jun 2021 16:57:44 +0200 Subject: [PATCH 227/496] remove list_var from the editor ast --- editor/src/lang/ast.rs | 1 - editor/src/lang/expr.rs | 1 - 2 files changed, 2 deletions(-) diff --git a/editor/src/lang/ast.rs b/editor/src/lang/ast.rs index 7b2c87095e..b1b75b0554 100644 --- a/editor/src/lang/ast.rs +++ b/editor/src/lang/ast.rs @@ -114,7 +114,6 @@ pub enum Expr2 { InvalidLookup(PoolStr), // 8B List { - list_var: Variable, // 4B - required for uniqueness of the list elem_var: Variable, // 4B elems: PoolVec, // 8B }, diff --git a/editor/src/lang/expr.rs b/editor/src/lang/expr.rs index ccd7cb9846..2a9626bd5b 100644 --- a/editor/src/lang/expr.rs +++ b/editor/src/lang/expr.rs @@ -346,7 +346,6 @@ pub fn to_expr2<'a>( } let expr = Expr2::List { - list_var: env.var_store.fresh(), elem_var: env.var_store.fresh(), elems, }; From 26c910cdb30c4718f4941f13ffa6c8660bbb3b93 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 13 Jun 2021 17:03:05 +0200 Subject: [PATCH 228/496] fix Dict.get --- compiler/can/src/builtins.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/can/src/builtins.rs b/compiler/can/src/builtins.rs index 636ca3ab19..b6d13be1da 100644 --- a/compiler/can/src/builtins.rs +++ b/compiler/can/src/builtins.rs @@ -2298,7 +2298,7 @@ fn dict_get(symbol: Symbol, var_store: &mut VarStore) -> Def { let make_err = tag( "Err", - vec![tag("OutOfBounds", Vec::new(), var_store)], + vec![tag("KeyNotFound", Vec::new(), var_store)], var_store, ); From b00dcbd6f0cfc380bafa948c6252dc2cdefe3f70 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 13 Jun 2021 17:21:14 +0200 Subject: [PATCH 229/496] clippy --- compiler/gen_llvm/src/llvm/build.rs | 27 +++++++++++++++++---------- compiler/mono/src/alias_analysis.rs | 2 +- 2 files changed, 18 insertions(+), 11 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 8d9791e854..f30683ec41 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -584,17 +584,25 @@ pub fn construct_optimization_passes<'a>( (mpm, fpm) } -pub fn promote_to_main_function<'a, 'ctx, 'env>( +fn promote_to_main_function<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, - layout_ids: &mut LayoutIds<'a>, + mod_solutions: &'a ModSolutions, symbol: Symbol, - layout: TopLevelFunctionLayout<'a>, + top_level: TopLevelFunctionLayout<'a>, ) -> (&'static str, FunctionValue<'ctx>) { - let fn_name = layout_ids - .get(symbol, &(env.arena.alloc(layout).full())) - .to_symbol_string(symbol, &env.interns); + let it = top_level.arguments.iter().copied(); + let bytes = roc_mono::alias_analysis::func_name_bytes_help(symbol, it, top_level.result); + let func_name = FuncName(&bytes); + let func_solutions = mod_solutions.func_solutions(func_name).unwrap(); - let roc_main_fn = env.module.get_function(&fn_name).unwrap(); + let mut it = func_solutions.specs(); + let func_spec = it.next().unwrap(); + debug_assert!( + it.next().is_none(), + "we expect only one specialization of this symbol" + ); + + let roc_main_fn = function_value_by_func_spec(env, *func_spec, symbol, Layout::Struct(&[])); let main_fn_name = "$Test.main"; @@ -3081,7 +3089,6 @@ fn make_exception_catching_wrapper<'a, 'ctx, 'env>( pub fn build_proc_headers<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, - _layout_ids: &mut LayoutIds<'a>, mod_solutions: &'a ModSolutions, procedures: MutMap<(Symbol, TopLevelFunctionLayout<'a>), roc_mono::ir::Proc<'a>>, scope: &mut Scope<'a, 'ctx>, @@ -3173,7 +3180,7 @@ fn build_procedures_help<'a, 'ctx, 'env>( // Add all the Proc headers to the module. // We have to do this in a separate pass first, // because their bodies may reference each other. - let headers = build_proc_headers(env, &mut layout_ids, &mod_solutions, procedures, &mut scope); + let headers = build_proc_headers(env, &mod_solutions, procedures, &mut scope); let (_, function_pass) = construct_optimization_passes(env.module, opt_level); @@ -3223,7 +3230,7 @@ fn build_procedures_help<'a, 'ctx, 'env>( } main_data.map(|(main_fn_symbol, main_fn_layout)| { - promote_to_main_function(env, &mut layout_ids, main_fn_symbol, main_fn_layout) + promote_to_main_function(env, mod_solutions, main_fn_symbol, main_fn_layout) }) } diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 8449448978..0b17b38ab0 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -73,7 +73,7 @@ where *target = *source; } - return name_bytes; + name_bytes } pub fn spec_program<'a, I>(procs: I) -> Result From e9135c71afaab82bfb4f197534a04c229b7d7075 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 13 Jun 2021 21:07:47 +0200 Subject: [PATCH 230/496] store main_for_host in file.rs State --- compiler/load/src/file.rs | 39 +++++++++++++++++++++++++++++++++------ 1 file changed, 33 insertions(+), 6 deletions(-) diff --git a/compiler/load/src/file.rs b/compiler/load/src/file.rs index fd203de818..b4f2c55115 100644 --- a/compiler/load/src/file.rs +++ b/compiler/load/src/file.rs @@ -660,6 +660,8 @@ enum HeaderFor<'a> { config_shorthand: &'a str, /// the type scheme of the main function (required by the platform) platform_main_type: TypedIdent<'a>, + /// provided symbol to host (commonly `mainForHost`) + main_for_host: Symbol, }, Interface, } @@ -695,6 +697,12 @@ pub struct FoundSpecializationsModule<'a> { pub module_timing: ModuleTiming, } +#[derive(Debug)] +pub struct EntryPoint<'a> { + symbol: Symbol, + layout: TopLevelFunctionLayout<'a>, +} + #[derive(Debug)] pub struct MonomorphizedModule<'a> { pub module_id: ModuleId, @@ -804,10 +812,16 @@ enum PlatformPath<'a> { RootIsPkgConfig, } +#[derive(Debug)] +struct PlatformData { + module_id: ModuleId, + provides: Symbol, +} + #[derive(Debug)] struct State<'a> { pub root_id: ModuleId, - pub platform_id: Option, + pub platform_id: Option, pub goal_phase: Phase, pub stdlib: &'a StdLib, pub exposed_types: SubsByModule, @@ -1674,10 +1688,13 @@ fn update<'a>( debug_assert!(matches!(state.platform_path, PlatformPath::NotSpecified)); state.platform_path = PlatformPath::Valid(to_platform.clone()); } - PkgConfig { .. } => { - debug_assert_eq!(state.platform_id, None); + PkgConfig { main_for_host, .. } => { + debug_assert!(matches!(state.platform_id, None)); - state.platform_id = Some(header.module_id); + state.platform_id = Some(PlatformData { + module_id: header.module_id, + provides: main_for_host, + }); if header.is_root_module { debug_assert!(matches!(state.platform_path, PlatformPath::NotSpecified)); @@ -1898,7 +1915,7 @@ fn update<'a>( // otherwise the App module exposes host-exposed let is_host_exposed = match state.platform_id { None => module_id == state.root_id, - Some(platform_id) => module_id == platform_id, + Some(ref platform_data) => module_id == platform_data.module_id, }; if is_host_exposed { @@ -2985,7 +3002,7 @@ fn send_header_two<'a>( HashMap::with_capacity_and_hasher(scope_size, default_hasher()); let home: ModuleId; - let ident_ids = { + let mut ident_ids = { // Lock just long enough to perform the minimal operations necessary. let mut module_ids = (*module_ids).lock(); let mut ident_ids_by_module = (*ident_ids_by_module).lock(); @@ -3108,9 +3125,19 @@ fn send_header_two<'a>( // to decrement its "pending" count. let module_name = ModuleNameEnum::PkgConfig; + let main_for_host = { + let ident_str: InlinableString = provides[0].value.as_str().into(); + let ident_id = ident_ids.get_or_insert(&ident_str); + + Symbol::new(home, ident_id) + }; + + dbg!(main_for_host); + let extra = HeaderFor::PkgConfig { config_shorthand: shorthand, platform_main_type: requires[0].value.clone(), + main_for_host, }; let mut package_qualified_imported_modules = MutSet::default(); From 0d5e91eb92e6039e622c273437578dd03256fe25 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 13 Jun 2021 22:13:37 +0200 Subject: [PATCH 231/496] fix entry points --- cli/src/repl/gen.rs | 4 +- compiler/build/src/program.rs | 7 +++- compiler/gen_llvm/src/llvm/build.rs | 32 ++++++--------- compiler/load/src/file.rs | 41 +++++++++++++------ compiler/mono/src/alias_analysis.rs | 57 ++++++++------------------- compiler/mono/src/ir.rs | 6 +++ compiler/test_gen/src/helpers/eval.rs | 17 +------- 7 files changed, 72 insertions(+), 92 deletions(-) diff --git a/cli/src/repl/gen.rs b/cli/src/repl/gen.rs index e6d699a683..699d244908 100644 --- a/cli/src/repl/gen.rs +++ b/cli/src/repl/gen.rs @@ -69,6 +69,7 @@ pub fn gen_and_eval<'a>( use roc_load::file::MonomorphizedModule; let MonomorphizedModule { procedures, + entry_point, interns, exposed_to_host, mut subs, @@ -191,8 +192,7 @@ pub fn gen_and_eval<'a>( &env, opt_level, procedures, - main_fn_symbol, - main_fn_layout, + entry_point, ); env.dibuilder.finalize(); diff --git a/compiler/build/src/program.rs b/compiler/build/src/program.rs index 1dc5156184..bf634b1b04 100644 --- a/compiler/build/src/program.rs +++ b/compiler/build/src/program.rs @@ -143,7 +143,12 @@ pub fn gen_from_mono_module( exposed_to_host: loaded.exposed_to_host.keys().copied().collect(), }; - roc_gen_llvm::llvm::build::build_procedures(&env, opt_level, loaded.procedures); + roc_gen_llvm::llvm::build::build_procedures( + &env, + opt_level, + loaded.procedures, + loaded.entry_point, + ); env.dibuilder.finalize(); diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index f30683ec41..d686f324e7 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -49,8 +49,8 @@ use roc_module::ident::TagName; use roc_module::low_level::LowLevel; use roc_module::symbol::{Interns, ModuleId, Symbol}; use roc_mono::ir::{ - BranchInfo, CallType, ExceptionId, JoinPointId, ModifyRc, OptLevel, TopLevelFunctionLayout, - Wrapped, + BranchInfo, CallType, EntryPoint, ExceptionId, JoinPointId, ModifyRc, OptLevel, + TopLevelFunctionLayout, Wrapped, }; use roc_mono::layout::{Builtin, InPlace, LambdaSet, Layout, LayoutIds, UnionLayout}; use std::convert::TryFrom; @@ -3133,40 +3133,34 @@ pub fn build_procedures<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, opt_level: OptLevel, procedures: MutMap<(Symbol, TopLevelFunctionLayout<'a>), roc_mono::ir::Proc<'a>>, - // alias_analysis_solutions: AliasAnalysisSolutions, + entry_point: EntryPoint<'a>, ) { - build_procedures_help(env, opt_level, procedures, None); + build_procedures_help(env, opt_level, procedures, entry_point); } pub fn build_procedures_return_main<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, opt_level: OptLevel, procedures: MutMap<(Symbol, TopLevelFunctionLayout<'a>), roc_mono::ir::Proc<'a>>, - // alias_analysis_solutions: AliasAnalysisSolutions, - main_fn_symbol: Symbol, - main_fn_layout: TopLevelFunctionLayout<'a>, + entry_point: EntryPoint<'a>, ) -> (&'static str, FunctionValue<'ctx>) { - build_procedures_help( - env, - opt_level, - procedures, - Some((main_fn_symbol, main_fn_layout)), - ) - .unwrap() + let mod_solutions = build_procedures_help(env, opt_level, procedures, entry_point); + + promote_to_main_function(env, mod_solutions, entry_point.symbol, entry_point.layout) } fn build_procedures_help<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, opt_level: OptLevel, procedures: MutMap<(Symbol, TopLevelFunctionLayout<'a>), roc_mono::ir::Proc<'a>>, - main_data: Option<(Symbol, TopLevelFunctionLayout<'a>)>, -) -> Option<(&'static str, FunctionValue<'ctx>)> { + entry_point: EntryPoint<'a>, +) -> &'a ModSolutions { let mut layout_ids = roc_mono::layout::LayoutIds::default(); let mut scope = Scope::default(); let it = procedures.iter().map(|x| x.1); - let solutions = match roc_mono::alias_analysis::spec_program(it) { + let solutions = match roc_mono::alias_analysis::spec_program(entry_point, it) { Err(e) => panic!("Error in alias analysis: {:?}", e), Ok(solutions) => solutions, }; @@ -3229,9 +3223,7 @@ fn build_procedures_help<'a, 'ctx, 'env>( } } - main_data.map(|(main_fn_symbol, main_fn_layout)| { - promote_to_main_function(env, mod_solutions, main_fn_symbol, main_fn_layout) - }) + mod_solutions } fn func_spec_name<'a>( diff --git a/compiler/load/src/file.rs b/compiler/load/src/file.rs index b4f2c55115..1ed2ef2a42 100644 --- a/compiler/load/src/file.rs +++ b/compiler/load/src/file.rs @@ -19,8 +19,8 @@ use roc_module::symbol::{ Symbol, }; use roc_mono::ir::{ - CapturedSymbols, ExternalSpecializations, PartialProc, PendingSpecialization, Proc, Procs, - TopLevelFunctionLayout, + CapturedSymbols, EntryPoint, ExternalSpecializations, PartialProc, PendingSpecialization, Proc, + Procs, TopLevelFunctionLayout, }; use roc_mono::layout::{Layout, LayoutCache, LayoutProblem}; use roc_parse::ast::{self, StrLiteral, TypeAnnotation}; @@ -697,12 +697,6 @@ pub struct FoundSpecializationsModule<'a> { pub module_timing: ModuleTiming, } -#[derive(Debug)] -pub struct EntryPoint<'a> { - symbol: Symbol, - layout: TopLevelFunctionLayout<'a>, -} - #[derive(Debug)] pub struct MonomorphizedModule<'a> { pub module_id: ModuleId, @@ -714,6 +708,7 @@ pub struct MonomorphizedModule<'a> { pub type_problems: MutMap>, pub mono_problems: MutMap>, pub procedures: MutMap<(Symbol, TopLevelFunctionLayout<'a>), Proc<'a>>, + pub entry_point: EntryPoint<'a>, pub exposed_to_host: MutMap, pub header_sources: MutMap)>, pub sources: MutMap)>, @@ -821,7 +816,7 @@ struct PlatformData { #[derive(Debug)] struct State<'a> { pub root_id: ModuleId, - pub platform_id: Option, + pub platform_data: Option, pub goal_phase: Phase, pub stdlib: &'a StdLib, pub exposed_types: SubsByModule, @@ -1461,7 +1456,7 @@ where let mut state = State { root_id, - platform_id: None, + platform_data: None, goal_phase, stdlib, output_path: None, @@ -1689,9 +1684,9 @@ fn update<'a>( state.platform_path = PlatformPath::Valid(to_platform.clone()); } PkgConfig { main_for_host, .. } => { - debug_assert!(matches!(state.platform_id, None)); + debug_assert!(matches!(state.platform_data, None)); - state.platform_id = Some(PlatformData { + state.platform_data = Some(PlatformData { module_id: header.module_id, provides: main_for_host, }); @@ -1913,7 +1908,7 @@ fn update<'a>( // if there is a platform, the Package-Config module provides host-exposed, // otherwise the App module exposes host-exposed - let is_host_exposed = match state.platform_id { + let is_host_exposed = match state.platform_data { None => module_id == state.root_id, Some(ref platform_data) => module_id == platform_data.module_id, }; @@ -2171,6 +2166,7 @@ fn finish_specialization( module_cache, output_path, platform_path, + platform_data, .. } = state; @@ -2218,6 +2214,24 @@ fn finish_specialization( let platform_path = path_to_platform.into(); + let entry_point = { + let symbol = match platform_data { + None => { + debug_assert_eq!(exposed_to_host.len(), 1); + *exposed_to_host.iter().next().unwrap().0 + } + Some(PlatformData { provides, .. }) => provides, + }; + + match procedures.keys().find(|(s, _)| *s == symbol) { + Some((_, layout)) => EntryPoint { + layout: *layout, + symbol, + }, + None => unreachable!("entry point was not specialized"), + } + }; + Ok(MonomorphizedModule { can_problems, mono_problems, @@ -2229,6 +2243,7 @@ fn finish_specialization( subs, interns, procedures, + entry_point, sources, header_sources, timings: state.timings, diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 0b17b38ab0..f7feda84b2 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -76,11 +76,13 @@ where name_bytes } -pub fn spec_program<'a, I>(procs: I) -> Result +pub fn spec_program<'a, I>( + entry_point: crate::ir::EntryPoint<'a>, + procs: I, +) -> Result where I: Iterator>, { - let mut main_function = None; let main_module = { let mut m = ModDefBuilder::new(); @@ -100,53 +102,26 @@ where let spec = proc_spec(proc)?; m.add_func(FuncName(&func_name_bytes(proc)), spec)?; - - if format!("{:?}", proc.name).contains("mainForHost") { - main_function = Some(proc.name); - } - - if format!("{:?}", proc.name).contains("replOutput") { - main_function = Some(proc.name); - } } m.build()? }; - match main_function { - None => { - let program = { - let mut p = ProgramBuilder::new(); - p.add_mod(MOD_APP, main_module)?; - p.add_entry_point( - EntryPointName(b"not defined! probably a function in the repl"), - MOD_APP, - FuncName(&[]), - )?; + let program = { + let mut p = ProgramBuilder::new(); + p.add_mod(MOD_APP, main_module)?; + p.add_entry_point( + EntryPointName(b"mainForHost"), + MOD_APP, + FuncName(&entry_point.symbol.to_ne_bytes()), + )?; - p.build()? - }; + p.build()? + }; - morphic_lib::solve(program) - } - Some(main_function) => { - let program = { - let mut p = ProgramBuilder::new(); - p.add_mod(MOD_APP, main_module)?; - p.add_entry_point( - EntryPointName(b"mainForHost"), - MOD_APP, - FuncName(&main_function.to_ne_bytes()), - )?; + // eprintln!("{}", program.to_source_string()); - p.build()? - }; - - // eprintln!("{}", program.to_source_string()); - - morphic_lib::solve(program) - } - } + morphic_lib::solve(program) } fn proc_spec(proc: &Proc) -> Result { diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 5ba508c30e..686b5b8b53 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -54,6 +54,12 @@ pub enum MonoProblem { PatternProblem(crate::exhaustive::Error), } +#[derive(Debug, Clone, Copy)] +pub struct EntryPoint<'a> { + pub symbol: Symbol, + pub layout: TopLevelFunctionLayout<'a>, +} + #[derive(Clone, Debug, PartialEq)] pub struct PartialProc<'a> { pub annotation: Variable, diff --git a/compiler/test_gen/src/helpers/eval.rs b/compiler/test_gen/src/helpers/eval.rs index 91324d7dae..9f9dfb83ca 100644 --- a/compiler/test_gen/src/helpers/eval.rs +++ b/compiler/test_gen/src/helpers/eval.rs @@ -80,14 +80,11 @@ pub fn helper<'a>( use roc_load::file::MonomorphizedModule; let MonomorphizedModule { procedures, + entry_point, interns, - exposed_to_host, .. } = loaded; - debug_assert_eq!(exposed_to_host.len(), 1); - let main_fn_symbol = exposed_to_host.keys().copied().next().unwrap(); - let mut lines = Vec::new(); // errors whose reporting we delay (so we can see that code gen generates runtime errors) let mut delayed_errors = Vec::new(); @@ -171,15 +168,6 @@ pub fn helper<'a>( } } - let (_, main_fn_layout) = match procedures.keys().find(|(s, _)| *s == main_fn_symbol) { - Some(found) => *found, - None => panic!( - "The main function symbol {:?} does not have a procedure in {:?}", - main_fn_symbol, - &procedures.keys() - ), - }; - let builder = context.create_builder(); let module = roc_gen_llvm::llvm::build::module_from_builtins(context, "app"); @@ -240,8 +228,7 @@ pub fn helper<'a>( &env, opt_level, procedures, - main_fn_symbol, - main_fn_layout, + entry_point, ); env.dibuilder.finalize(); From cf6eb718b3ebf063b05203079c6a530dbf74c50a Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 13 Jun 2021 23:16:53 +0200 Subject: [PATCH 232/496] create alias analysis entry point --- compiler/load/src/file.rs | 20 ++++++++--- compiler/mono/src/alias_analysis.rs | 42 +++++++++++++++++++--- compiler/reporting/tests/test_reporting.rs | 3 +- 3 files changed, 54 insertions(+), 11 deletions(-) diff --git a/compiler/load/src/file.rs b/compiler/load/src/file.rs index 1ed2ef2a42..14b5b0bf41 100644 --- a/compiler/load/src/file.rs +++ b/compiler/load/src/file.rs @@ -2228,7 +2228,17 @@ fn finish_specialization( layout: *layout, symbol, }, - None => unreachable!("entry point was not specialized"), + None => { + // the entry point is not specialized. This can happen if the repl output + // is a function value + EntryPoint { + layout: roc_mono::ir::TopLevelFunctionLayout { + arguments: &[], + result: Layout::Struct(&[]), + }, + symbol, + } + } } }; @@ -3147,8 +3157,6 @@ fn send_header_two<'a>( Symbol::new(home, ident_id) }; - dbg!(main_for_host); - let extra = HeaderFor::PkgConfig { config_shorthand: shorthand, platform_main_type: requires[0].value.clone(), @@ -3857,7 +3865,8 @@ fn make_specializations<'a>( ident_ids: &mut ident_ids, ptr_bytes, update_mode_counter: 0, - call_specialization_counter: 0, + // call_specialization_counter=0 is reserved + call_specialization_counter: 1, }; // TODO: for now this final specialization pass is sequential, @@ -3920,7 +3929,8 @@ fn build_pending_specializations<'a>( ident_ids: &mut ident_ids, ptr_bytes, update_mode_counter: 0, - call_specialization_counter: 0, + // call_specialization_counter=0 is reserved + call_specialization_counter: 1, }; // Add modules' decls to Procs diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index f7feda84b2..c3f3b142e8 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -17,6 +17,8 @@ pub const MOD_APP: ModName = ModName(b"UserApp"); pub const STATIC_STR_NAME: ConstName = ConstName(&Symbol::STR_ALIAS_ANALYSIS_STATIC.to_ne_bytes()); +const ENTRY_POINT_NAME: &[u8] = b"mainForHost"; + pub fn func_name_bytes(proc: &Proc) -> [u8; 16] { func_name_bytes_help(proc.name, proc.args.iter().map(|x| x.0), proc.ret_layout) } @@ -86,6 +88,7 @@ where let main_module = { let mut m = ModDefBuilder::new(); + // a const that models all static strings let static_str_def = { let mut cbuilder = ConstDefBuilder::new(); let block = cbuilder.add_block(); @@ -98,6 +101,12 @@ where }; m.add_const(STATIC_STR_NAME, static_str_def)?; + // the entry point wrapper + let entry_point_name = FuncName(ENTRY_POINT_NAME); + let entry_point_function = build_entry_point(entry_point.layout, entry_point_name)?; + m.add_func(entry_point_name, entry_point_function)?; + + // all other functions for proc in procs { let spec = proc_spec(proc)?; @@ -110,11 +119,9 @@ where let program = { let mut p = ProgramBuilder::new(); p.add_mod(MOD_APP, main_module)?; - p.add_entry_point( - EntryPointName(b"mainForHost"), - MOD_APP, - FuncName(&entry_point.symbol.to_ne_bytes()), - )?; + + let entry_point_name = FuncName(ENTRY_POINT_NAME); + p.add_entry_point(EntryPointName(ENTRY_POINT_NAME), MOD_APP, entry_point_name)?; p.build()? }; @@ -124,6 +131,31 @@ where morphic_lib::solve(program) } +fn build_entry_point( + layout: crate::ir::TopLevelFunctionLayout, + func_name: FuncName, +) -> Result { + let mut builder = FuncDefBuilder::new(); + let block = builder.add_block(); + + // to the modelling language, the arguments appear out of thin air + let argument_type = build_tuple_type(&mut builder, layout.arguments)?; + let argument = builder.add_unknown_with(block, &[], argument_type)?; + + let name_bytes = [0; 16]; + let spec_var = CalleeSpecVar(&name_bytes); + let result = builder.add_call(block, spec_var, MOD_APP, func_name, argument)?; + + // to the modelling language, the result disappears into the void + let unit_type = builder.add_tuple_type(&[])?; + let unit_value = builder.add_unknown_with(block, &[result], unit_type)?; + + let root = BlockExpr(block, unit_value); + let spec = builder.build(unit_type, unit_type, root)?; + + Ok(spec) +} + fn proc_spec(proc: &Proc) -> Result { let mut builder = FuncDefBuilder::new(); let mut env = Env::default(); diff --git a/compiler/reporting/tests/test_reporting.rs b/compiler/reporting/tests/test_reporting.rs index 16dbb29fbb..56b309a30a 100644 --- a/compiler/reporting/tests/test_reporting.rs +++ b/compiler/reporting/tests/test_reporting.rs @@ -101,7 +101,8 @@ mod test_reporting { ident_ids: &mut ident_ids, ptr_bytes: 8, update_mode_counter: 0, - call_specialization_counter: 0, + // call_specialization_counter=0 is reserved + call_specialization_counter: 1, }; let _mono_expr = Stmt::new( &mut mono_env, From 97954f385745b9ed76f9adf02fddac66122be406 Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 14 Jun 2021 21:01:36 +0200 Subject: [PATCH 233/496] bump morphic --- vendor/morphic_lib/src/api.rs | 5 + vendor/morphic_lib/src/ir.rs | 305 +++++ vendor/morphic_lib/src/lib.rs | 5 + vendor/morphic_lib/src/name_cache.rs | 26 + vendor/morphic_lib/src/preprocess.rs | 1204 +++++++++++++++++ vendor/morphic_lib/src/type_cache.rs | 22 + vendor/morphic_lib/src/util/blocks.rs | 4 +- vendor/morphic_lib/src/util/bytes_id.rs | 32 +- vendor/morphic_lib/src/util/flat_slices.rs | 112 ++ vendor/morphic_lib/src/util/id_bi_map.rs | 12 + vendor/morphic_lib/src/util/id_type.rs | 9 +- vendor/morphic_lib/src/util/id_vec.rs | 7 + vendor/morphic_lib/src/util/mod.rs | 2 + vendor/morphic_lib/src/util/op_graph.rs | 51 +- .../src/util/strongly_connected.rs | 152 +++ vendor/morphic_lib/tests/basic.rs | 77 ++ vendor/morphic_lib/tests/recursive.rs | 95 ++ 17 files changed, 2080 insertions(+), 40 deletions(-) create mode 100644 vendor/morphic_lib/src/ir.rs create mode 100644 vendor/morphic_lib/src/name_cache.rs create mode 100644 vendor/morphic_lib/src/preprocess.rs create mode 100644 vendor/morphic_lib/src/type_cache.rs create mode 100644 vendor/morphic_lib/src/util/flat_slices.rs create mode 100644 vendor/morphic_lib/src/util/strongly_connected.rs create mode 100644 vendor/morphic_lib/tests/basic.rs create mode 100644 vendor/morphic_lib/tests/recursive.rs diff --git a/vendor/morphic_lib/src/api.rs b/vendor/morphic_lib/src/api.rs index d220904f97..f45c2dbd53 100644 --- a/vendor/morphic_lib/src/api.rs +++ b/vendor/morphic_lib/src/api.rs @@ -2,6 +2,7 @@ use sha2::{digest::Digest, Sha256}; use smallvec::SmallVec; use std::collections::{btree_map::Entry, BTreeMap}; +use crate::preprocess; use crate::render_api_ir; use crate::util::blocks::Blocks; use crate::util::id_bi_map::IdBiMap; @@ -57,6 +58,8 @@ enum ErrorKind { ModNotFound(ModNameBuf), #[error("entry point {0:?} not found in program")] EntryPointNotFound(EntryPointNameBuf), + #[error("{0}")] + PreprocessError(preprocess::Error), } #[derive(Clone, thiserror::Error, Debug)] @@ -1550,6 +1553,8 @@ fn populate_specs( } pub fn solve(program: Program) -> Result { + preprocess::preprocess(&program).map_err(ErrorKind::PreprocessError)?; + Ok(Solutions { mods: program .mods diff --git a/vendor/morphic_lib/src/ir.rs b/vendor/morphic_lib/src/ir.rs new file mode 100644 index 0000000000..e778fe03b7 --- /dev/null +++ b/vendor/morphic_lib/src/ir.rs @@ -0,0 +1,305 @@ +//! The core IR used for analysis. +//! +//! The IR uses a variant of SSA in which control-dependent values are represented using block +//! parameters instead of phi nodes. + +use smallvec::SmallVec; + +use crate::api::{CalleeSpecVarId, UpdateModeVarId}; +use crate::name_cache::{ConstId, FuncId}; +use crate::type_cache::TypeId; +use crate::util::blocks::Blocks; +use crate::util::flat_slices::{FlatSlices, Slice}; +use crate::util::op_graph::OpGraph; +use crate::util::strongly_connected::{strongly_connected, SccKind}; + +/// The "core payload" of a node in the op graph, determining its semantics. +/// +/// The `OpKind` of a node is *not* sufficient to uniquely determine either the ids or the types of +/// its inputs or output. This information is stored separately in the graph. +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub(crate) enum OpKind { + // Variadic inputs + // Inputs may have any type + // Output may have any type + UnknownWith, + // 1 input + // Input type must match argument type of callee + // Output type must match return type of callee + Call { + callee_spec_var: CalleeSpecVarId, + callee: FuncId, + }, + // 0 inputs + // Output type must match type of const + ConstRef { + const_: ConstId, + }, + // 0 inputs + // Output type is heap cell + NewHeapCell, + // 1 input + // Input may have any type + // Output type is unit + RecursiveTouch, + // 1 input + // Input type is heap cell + // Output type is unit + UpdateWriteOnly { + update_mode_var: UpdateModeVarId, + }, + // 0 inputs + // Output type is `Bag` for some `T` + EmptyBag, + // 2 inputs: `(bag, to_insert)` + // `bag` has type `Bag` + // `to_insert` has type `T` + // Output type is `Bag` + BagInsert, + // 1 input + // Input type is `Bag` + // Output type is `T` + BagGet, + // 1 input + // Input type is `Bag` + // Output type is `(Bag, T)` + BagRemove, + // Variadic inputs + // Input types are `T_1, ..., T_N` + // Output type is `(T_1, ..., T_N)` + MakeTuple, + // 1 input + // Input type is `(T_1, ..., T_N)` + // Output type is `T_(field_idx)` + GetTupleField { + field_idx: u32, + }, + // 1 input + // Input type is `T_(variant_idx)` + // Output type is `union { T_1, ..., T_N }` + MakeUnion { + variant_idx: u32, + }, + // 1 input + // Input type is `union { T_1, ..., T_N }` + // Output type is `T_(variant_idx)` + UnwrapUnion { + variant_idx: u32, + }, + // 1 input + // Input type is content type of a named type `T` + // Output type is `T` + MakeNamed, + // 1 input + // Input type is a named type `T` + // Output type is the content type of `T` + UnwrapNamed, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub(crate) enum ValueKind { + Op(OpKind), + // 0 inputs + BlockParam, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub(crate) struct ValueInfo { + pub(crate) kind: ValueKind, + pub(crate) result_type: TypeId, +} + +id_type! { + pub(crate) ValueId(u32); +} + +id_type! { + pub(crate) BlockId(u32); +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub(crate) enum JumpTarget { + Block(BlockId), + Ret, +} + +pub(crate) const JUMP_TARGETS_INLINE_COUNT: usize = 8; + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub(crate) struct BlockInfo { + /// A block may optionally have a single parameter, which serves the same role as a phi node in + /// SSA. + /// + /// Invariant: If `param` is `Some`, it must point to a `BlockParam` value, not an `Op`. + pub(crate) param: Option, + /// List of zero or more jump targets to nondeterministically choose from. + pub(crate) jump_targets: SmallVec<[JumpTarget; JUMP_TARGETS_INLINE_COUNT]>, + /// Optional argument which will be passed to the chosen jump target. + pub(crate) target_arg: Option, +} + +id_type! { + /// Identifies a strongly connected component in the control flow graph. + /// + /// https://en.wikipedia.org/wiki/Strongly_connected_component + pub(crate) SccId(u32); +} + +#[derive(Clone, Debug)] +pub(crate) struct GraphBuilder { + values: OpGraph, + blocks: Blocks, +} + +impl GraphBuilder { + pub(crate) fn new() -> Self { + GraphBuilder { + values: OpGraph::new(), + blocks: Blocks::new(), + } + } + + pub(crate) fn add_op( + &mut self, + block: BlockId, + op_kind: OpKind, + inputs: &[ValueId], + result_type: TypeId, + ) -> ValueId { + let val_id = self.values.add_node( + ValueInfo { + kind: ValueKind::Op(op_kind), + result_type, + }, + inputs, + ); + self.blocks.add_value(block, val_id); + val_id + } + + pub(crate) fn add_block(&mut self) -> BlockId { + self.blocks.add_block( + self.values.count().0, + BlockInfo { + param: None, + jump_targets: SmallVec::new(), + target_arg: None, + }, + ) + } + + pub(crate) fn add_block_with_param(&mut self, param_type: TypeId) -> (BlockId, ValueId) { + let param_id = self.values.add_node( + ValueInfo { + kind: ValueKind::BlockParam, + result_type: param_type, + }, + &[], + ); + let block_id = self.blocks.add_block( + self.values.count().0, + BlockInfo { + param: Some(param_id), + jump_targets: SmallVec::new(), + target_arg: None, + }, + ); + (block_id, param_id) + } + + pub(crate) fn set_jump_targets( + &mut self, + block: BlockId, + target_arg: Option, + jump_targets: SmallVec<[JumpTarget; JUMP_TARGETS_INLINE_COUNT]>, + ) { + let info = self.blocks.block_info_mut(block); + info.target_arg = target_arg; + info.jump_targets = jump_targets; + } + + pub(crate) fn values(&self) -> &OpGraph { + &self.values + } + + pub(crate) fn blocks(&self) -> &Blocks { + &self.blocks + } + + pub(crate) fn build(self, entry_block: BlockId) -> Graph { + debug_assert!(entry_block < self.blocks.block_count()); + let rev_sccs = strongly_connected(self.blocks.block_count(), |block| { + self.blocks + .block_info(block) + .jump_targets + .iter() + .filter_map(|&jump_target| match jump_target { + JumpTarget::Ret => None, + JumpTarget::Block(target) => Some(target), + }) + }); + Graph { + values: self.values, + blocks: self.blocks, + entry_block, + rev_sccs, + } + } +} + +#[derive(Clone, Debug)] +pub(crate) struct Graph { + values: OpGraph, + blocks: Blocks, + entry_block: BlockId, + + // Invariant: `rev_sccs` must be stored in *reverse* topological order. If an SCC 'A' can jump + // to an SCC 'B', then 'A' must appear *after* 'B' in `rev_sccs`. + // + // We don't store the SCCs in topological order because control flow graph edges point from + // *source block* to *target block*, so running Tarjan's algorithm on the control flow graph + // gives us a reverse topological sort rather than a topological sort. + rev_sccs: FlatSlices, +} + +impl Graph { + pub(crate) fn values(&self) -> &OpGraph { + &self.values + } + + pub(crate) fn blocks(&self) -> &Blocks { + &self.blocks + } + + pub(crate) fn entry_block(&self) -> BlockId { + self.entry_block + } + + pub(crate) fn rev_sccs(&self) -> &FlatSlices { + &self.rev_sccs + } + + /// Iterate over sccs in topological order. + /// + /// IF an SCC 'A' can jump to an SCC 'B', then 'A' is guaranteed to appear *before* 'B' in the + /// returned iterator. + pub(crate) fn iter_sccs<'a>( + &'a self, + ) -> impl Iterator> + 'a { + self.rev_sccs + .count() + .iter() + .rev() + .map(move |scc_id| self.rev_sccs.get(scc_id)) + } +} + +#[derive(Clone, Debug)] +pub(crate) struct FuncDef { + pub(crate) graph: Graph, +} + +#[derive(Clone, Debug)] +pub(crate) struct ConstDef { + pub(crate) graph: Graph, +} diff --git a/vendor/morphic_lib/src/lib.rs b/vendor/morphic_lib/src/lib.rs index 89da624e4a..a1470770dc 100644 --- a/vendor/morphic_lib/src/lib.rs +++ b/vendor/morphic_lib/src/lib.rs @@ -1,10 +1,15 @@ #![allow(dead_code)] +#![allow(clippy::too_many_arguments)] #[macro_use] mod util; mod api; mod bindings; +mod ir; +mod name_cache; +mod preprocess; mod render_api_ir; +mod type_cache; pub use api::*; diff --git a/vendor/morphic_lib/src/name_cache.rs b/vendor/morphic_lib/src/name_cache.rs new file mode 100644 index 0000000000..03e45fb821 --- /dev/null +++ b/vendor/morphic_lib/src/name_cache.rs @@ -0,0 +1,26 @@ +use crate::api; +use crate::util::id_bi_map::IdBiMap; + +id_type! { + pub NamedTypeId(u32); +} + +id_type! { + pub FuncId(u32); +} + +id_type! { + pub ConstId(u32); +} + +id_type! { + pub EntryPointId(u32); +} + +#[derive(Clone, Debug, Default)] +pub(crate) struct NameCache { + pub(crate) named_types: IdBiMap, + pub(crate) funcs: IdBiMap, + pub(crate) consts: IdBiMap, + pub(crate) entry_points: IdBiMap, +} diff --git a/vendor/morphic_lib/src/preprocess.rs b/vendor/morphic_lib/src/preprocess.rs new file mode 100644 index 0000000000..70112b5ba0 --- /dev/null +++ b/vendor/morphic_lib/src/preprocess.rs @@ -0,0 +1,1204 @@ +//! Before we perform any interprocedural analysis, we run a preprocessing pass to convert the "API +//! IR" (the IR constructed by the input API) to the "analysis IR" (the IR used for all subsequent +//! analysis). +//! +//! We cannot perform this preprocessing step eagerly while the API IR is being constructed, because +//! some parts of the preprocessing (for example, typechecking) rely on nonlocal information (such +//! as functions' type signatures) which is not available until the entire input program has been +//! constructed. +//! +//! This pass currently implements the following functionality: +//! - Scope checking for values +//! - Typechecking + +use smallvec::{smallvec, SmallVec}; + +use crate::api; +use crate::ir; +use crate::ir::JumpTarget; +use crate::name_cache::{ConstId, EntryPointId, FuncId, NameCache, NamedTypeId}; +use crate::type_cache::{TypeCache, TypeData, TypeId}; +use crate::util::id_vec::IdVec; +use crate::util::op_graph::OpGraph; +use crate::util::replace_none::replace_none; + +#[derive(Clone, thiserror::Error, Debug)] +pub(crate) enum ErrorKind { + #[error("could not find named type in module {0:?} with name {1:?}")] + NamedTypeNotFound(api::ModNameBuf, api::TypeNameBuf), + #[error("could not find func in module {0:?} with name {1:?}")] + FuncNotFound(api::ModNameBuf, api::FuncNameBuf), + #[error("could not find const in module {0:?} with name {1:?}")] + ConstNotFound(api::ModNameBuf, api::ConstNameBuf), + #[error("value {0:?} is not in scope")] + ValueNotInScope(api::ValueId), + #[error("continuation {0:?} is not in scope")] + ContinuationNotInScope(api::ContinuationId), + #[error("expected type '{expected}', found type '{actual}'")] + TypeMismatch { expected: String, actual: String }, + #[error("expected bag type, found type '{0}'")] + ExpectedBagType(String), + #[error("expected tuple type, found type '{0}'")] + ExpectedTupleType(String), + #[error("expected union type, found type '{0}'")] + ExpectedUnionType(String), + #[error("expected named type, foudn type '{0}'")] + ExpectedNamedType(String), + #[error("tuple field index {0} out of range")] + TupleFieldOutOfRange(u32), + #[error("union variant index {0} out of range")] + UnionVariantOutOfRange(u32), + #[error("entry point does not have type '() -> ()'")] + EntryPointDisallowedSig, +} + +/// For use in error locations +#[derive(Clone, Debug)] +enum DefName { + Type(api::TypeNameBuf), + Func(api::FuncNameBuf), + Const(api::ConstNameBuf), + EntryPoint(api::EntryPointNameBuf), +} + +#[derive(Clone, Debug)] +enum BindingLocation { + Type(api::TypeId), + Value(api::ValueId), + Continuation(api::ContinuationId), +} + +#[derive(Clone, Debug)] +pub(crate) struct Error { + kind: ErrorKind, + mod_: Option, + def: Option, + binding: Option, +} + +impl Error { + fn annotate_mod_def>(err: E, mod_: api::ModNameBuf, def: DefName) -> Self { + let mut err = err.into(); + if err.mod_.is_none() { + err.mod_ = Some(mod_); + } + if err.def.is_none() { + err.def = Some(def); + } + err + } + + fn annotate_type_def<'a, E: Into>( + nc: &'a NameCache, + def_id: NamedTypeId, + ) -> impl FnOnce(E) -> Self + 'a { + move |err| { + let (mod_, name) = &nc.named_types[def_id]; + Error::annotate_mod_def(err, mod_.clone(), DefName::Type(name.clone())) + } + } + + fn annotate_func_def<'a, E: Into>( + nc: &'a NameCache, + def_id: FuncId, + ) -> impl FnOnce(E) -> Self + 'a { + move |err| { + let (mod_, name) = &nc.funcs[def_id]; + Error::annotate_mod_def(err, mod_.clone(), DefName::Func(name.clone())) + } + } + + fn annotate_const_def<'a, E: Into>( + nc: &'a NameCache, + def_id: ConstId, + ) -> impl FnOnce(E) -> Self + 'a { + move |err| { + let (mod_, name) = &nc.consts[def_id]; + Error::annotate_mod_def(err, mod_.clone(), DefName::Const(name.clone())) + } + } + + fn annotate_entry_point<'a, E: Into>( + nc: &'a NameCache, + def_id: EntryPointId, + ) -> impl FnOnce(E) -> Self + 'a { + move |err| { + let mut err = err.into(); + if err.def.is_none() { + err.def = Some(DefName::EntryPoint(nc.entry_points[def_id].clone())); + } + err + } + } + + fn annotate_binding>(binding: BindingLocation) -> impl FnOnce(E) -> Self { + move |err| { + let mut err = err.into(); + if err.binding.is_none() { + err.binding = Some(binding); + } + err + } + } +} + +impl std::fmt::Display for Error { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + let mut first = true; + let mut loc_prefix = |f: &mut std::fmt::Formatter| -> std::fmt::Result { + if first { + write!(f, "error in ")?; + } else { + write!(f, ", ")?; + } + first = false; + Ok(()) + }; + + if let Some(mod_) = &self.mod_ { + loc_prefix(f)?; + write!(f, "module {:?}", mod_)?; + } + + if let Some(def) = &self.def { + loc_prefix(f)?; + match def { + DefName::Type(name) => { + write!(f, "named type definition {:?}", name)?; + } + DefName::Func(name) => { + write!(f, "function definition {:?}", name)?; + } + DefName::Const(name) => { + write!(f, "constant definition {:?}", name)?; + } + DefName::EntryPoint(name) => { + write!(f, "entry point definition {:?}", name)?; + } + } + } + + if let Some(binding) = &self.binding { + loc_prefix(f)?; + match binding { + BindingLocation::Type(id) => { + write!(f, "definition of type binding {:?}", id)?; + } + BindingLocation::Value(id) => { + write!(f, "definition of value binding {:?}", id)?; + } + BindingLocation::Continuation(id) => { + write!(f, "definition of continuation binding {:?}", id)?; + } + } + } + + if !first { + write!(f, ": ")?; + } + + write!(f, "{}", self.kind) + } +} + +impl std::error::Error for Error {} + +impl From for Error { + fn from(kind: ErrorKind) -> Self { + Error { + kind, + mod_: None, + def: None, + binding: None, + } + } +} + +fn named_type_id( + nc: &NameCache, + mod_name: &api::ModNameBuf, + type_name: &api::TypeNameBuf, +) -> Result { + nc.named_types + .get_by_val(&(mod_name.clone(), type_name.clone())) + .ok_or_else(|| ErrorKind::NamedTypeNotFound(mod_name.clone(), type_name.clone()).into()) +} + +pub(crate) fn resolve_types( + nc: &NameCache, + tc: &mut TypeCache, + types_: &OpGraph, +) -> Result, Error> { + let mut result = IdVec::with_capacity(types_.len()); + for api_id in types_.count().iter() { + let node = types_.node(api_id); + let inputs: SmallVec<_> = node.inputs.iter().map(|input| result[input]).collect(); + let type_data = match node.op { + api::TypeOp::Named { named_mod, named } => { + let named_id = named_type_id(nc, named_mod, named) + .map_err(Error::annotate_binding(BindingLocation::Type(api_id)))?; + debug_assert_eq!(inputs.len(), 0); + TypeData::Named { named: named_id } + } + api::TypeOp::Tuple => TypeData::Tuple { fields: inputs }, + api::TypeOp::Union => TypeData::Union { variants: inputs }, + api::TypeOp::HeapCell => { + debug_assert_eq!(inputs.len(), 0); + TypeData::HeapCell + } + api::TypeOp::Bag => { + debug_assert_eq!(inputs.len(), 1); + TypeData::Bag { item: inputs[0] } + } + }; + let type_id = tc.types.get_or_insert(type_data); + let pushed_id = result.push(type_id); + debug_assert_eq!(pushed_id, api_id); + } + debug_assert_eq!(result.count(), types_.count()); + Ok(result) +} + +#[derive(Clone, Debug)] +struct FuncSig { + arg_type: TypeId, + ret_type: TypeId, +} + +pub(crate) fn preprocess(program: &api::Program) -> Result<(), Error> { + let mut nc = NameCache::default(); + let mut tc = TypeCache::default(); + + let mut named_types = IdVec::::new(); + let mut funcs = IdVec::::new(); + let mut consts = IdVec::::new(); + + for (mod_name, mod_) in &program.mods { + for (type_name, type_def) in &mod_.type_defs { + let nc_id = nc + .named_types + .insert((mod_name.clone(), type_name.clone())) + .expect("Builder API should check for duplicate names"); + let pushed_id = named_types.push(type_def); + debug_assert_eq!(nc_id, pushed_id); + } + for (func_name, func_def) in &mod_.func_defs { + let nc_id = nc + .funcs + .insert((mod_name.clone(), func_name.clone())) + .expect("Builder API should check for duplicate names"); + let pushed_id = funcs.push(func_def); + debug_assert_eq!(nc_id, pushed_id); + } + for (const_name, const_def) in &mod_.const_defs { + let nc_id = nc + .consts + .insert((mod_name.clone(), const_name.clone())) + .expect("Builder API should check for duplicate names"); + let pushed_id = consts.push(const_def); + debug_assert_eq!(nc_id, pushed_id); + } + } + + // TODO: We should ideally perform fewer passes over the program here. + + let typedef_body_types = named_types.try_map(|named_id, type_def| { + resolve_types(&nc, &mut tc, &type_def.builder.types) + .map_err(Error::annotate_type_def(&nc, named_id)) + })?; + + let typedef_contents = + named_types.map(|named_type_id, type_def| typedef_body_types[named_type_id][type_def.root]); + + let func_body_types = funcs.try_map(|func_id, func_def| { + resolve_types( + &nc, + &mut tc, + &func_def.builder.expr_builder.type_builder.types, + ) + .map_err(Error::annotate_func_def(&nc, func_id)) + })?; + + let func_sigs = funcs.map(|func_id, func_def| { + let body_types = &func_body_types[func_id]; + FuncSig { + arg_type: body_types[func_def.arg_type], + ret_type: body_types[func_def.ret_type], + } + }); + + let const_body_types = consts.try_map(|const_id, const_def| { + resolve_types( + &nc, + &mut tc, + &const_def.builder.expr_builder.type_builder.types, + ) + .map_err(Error::annotate_const_def(&nc, const_id)) + })?; + + let const_sigs = consts.map(|const_id, const_def| { + let body_types = &const_body_types[const_id]; + body_types[&const_def.type_] + }); + + let ctx = Context { + nc: &nc, + typedef_contents: &typedef_contents, + func_sigs: &func_sigs, + const_sigs: &const_sigs, + }; + + for (func_id, func_def) in &funcs { + preprocess_func_def(&mut tc, ctx, func_def, &func_body_types[func_id]) + .map_err(Error::annotate_func_def(&nc, func_id))?; + } + + for (const_id, const_def) in &consts { + preprocess_const_def(&mut tc, ctx, const_def, &const_body_types[const_id]) + .map_err(Error::annotate_const_def(&nc, const_id))?; + } + + let mut entry_points = IdVec::::new(); + for (entry_point_name, (mod_, func)) in &program.entry_points { + let nc_id = nc + .entry_points + .insert(entry_point_name.clone()) + .expect("builder API should check for duplicate names"); + // TODO: Avoid the clones here + let func_id = nc + .funcs + .get_by_val(&(mod_.clone(), func.clone())) + .ok_or_else(|| ErrorKind::FuncNotFound(mod_.clone(), func.clone())) + .map_err(Error::annotate_entry_point(&nc, nc_id))?; + let func_sig = &func_sigs[func_id]; + let unit_type = tc.types.get_or_insert(TypeData::Tuple { + fields: smallvec![], + }); + if func_sig.arg_type != unit_type || func_sig.ret_type != unit_type { + return Err(Error::annotate_entry_point(&nc, nc_id)( + ErrorKind::EntryPointDisallowedSig, + )); + } + let pushed_id = entry_points.push(func_id); + debug_assert_eq!(nc_id, pushed_id); + } + + Ok(()) +} + +#[derive(Clone, Copy, Debug)] +struct Context<'a> { + nc: &'a NameCache, + typedef_contents: &'a IdVec, + func_sigs: &'a IdVec, + const_sigs: &'a IdVec, +} + +#[derive(Clone, Copy, Debug)] +struct ValueBinding { + id: ir::ValueId, + type_: TypeId, +} + +#[derive(Clone, Copy, Debug)] +struct ContinuationBinding { + entry_block: ir::BlockId, + arg_type: TypeId, +} + +// TODO: Consolidate this logic with render_api_ir.rs +fn render_byte_string(target: &mut String, bytes: &[u8]) { + target.push('"'); + for &byte in bytes { + use std::fmt::Write; + write!(target, "{}", std::ascii::escape_default(byte)).unwrap(); + } + target.push('"'); +} + +// TODO: Consolidate this logic with render_api_ir.rs +fn render_type_rec(nc: &NameCache, tc: &TypeCache, target: &mut String, type_: TypeId) { + match &tc.types[type_] { + TypeData::Named { named } => { + let (mod_name, type_name) = &nc.named_types[named]; + render_byte_string(target, &mod_name.0); + target.push_str("::"); + render_byte_string(target, &type_name.0); + } + + TypeData::Tuple { fields } => { + target.push('('); + let mut first = true; + for &field in fields { + if !first { + target.push_str(", "); + } + first = false; + render_type_rec(nc, tc, target, field); + } + if fields.len() == 1 { + target.push(','); + } + target.push(')'); + } + + TypeData::Union { variants } => { + if variants.is_empty() { + // Special case to avoid extra space inside braces + target.push_str("union { }"); + return; + } + target.push_str("union { "); + let mut first = true; + for &variant in variants { + if !first { + target.push_str(", "); + } + first = false; + render_type_rec(nc, tc, target, variant); + } + target.push_str(" }"); + } + + TypeData::HeapCell => { + target.push_str("heap_cell"); + } + + TypeData::Bag { item } => { + target.push_str("bag<"); + render_type_rec(nc, tc, target, *item); + target.push('>'); + } + } +} + +fn render_type(nc: &NameCache, tc: &TypeCache, type_: TypeId) -> String { + let mut target = String::new(); + render_type_rec(nc, tc, &mut target, type_); + target +} + +fn type_error( + nc: &NameCache, + tc: &TypeCache, + expected: TypeId, + actual: TypeId, +) -> Result { + debug_assert_ne!(expected, actual); + Err(ErrorKind::TypeMismatch { + expected: render_type(nc, tc, expected), + actual: render_type(nc, tc, actual), + } + .into()) +} + +fn check_type( + nc: &NameCache, + tc: &TypeCache, + expected: TypeId, + actual: TypeId, +) -> Result<(), Error> { + if expected != actual { + type_error(nc, tc, expected, actual) + } else { + Ok(()) + } +} + +fn try_get_bag_item_type( + nc: &NameCache, + tc: &TypeCache, + bag_type: TypeId, +) -> Result { + if let TypeData::Bag { item } = tc.types[bag_type] { + Ok(item) + } else { + Err(ErrorKind::ExpectedBagType(render_type(nc, tc, bag_type)).into()) + } +} + +fn try_get_tuple_field_types<'a>( + nc: &NameCache, + tc: &'a TypeCache, + tuple_type: TypeId, +) -> Result<&'a [TypeId], Error> { + if let TypeData::Tuple { fields } = &tc.types[tuple_type] { + Ok(fields) + } else { + Err(ErrorKind::ExpectedTupleType(render_type(nc, tc, tuple_type)).into()) + } +} + +fn try_get_union_variant_types<'a>( + nc: &NameCache, + tc: &'a TypeCache, + union_type: TypeId, +) -> Result<&'a [TypeId], Error> { + if let TypeData::Union { variants } = &tc.types[union_type] { + Ok(variants) + } else { + Err(ErrorKind::ExpectedUnionType(render_type(nc, tc, union_type)).into()) + } +} + +fn try_get_named_type_id( + nc: &NameCache, + tc: &TypeCache, + named_type: TypeId, +) -> Result { + if let TypeData::Named { named } = tc.types[named_type] { + Ok(named) + } else { + Err(ErrorKind::ExpectedNamedType(render_type(nc, tc, named_type)).into()) + } +} + +fn get_value( + values_in_scope: &IdVec>, + api_value: api::ValueId, +) -> Result { + values_in_scope[api_value].ok_or_else(|| ErrorKind::ValueNotInScope(api_value).into()) +} + +fn preprocess_block_expr( + tc: &mut TypeCache, + ctx: Context, + api_builder: &api::ExprBuilder, + body_types: &IdVec, + graph_builder: &mut ir::GraphBuilder, + values_in_scope: &mut IdVec>, + continuations_in_scope: &mut IdVec>, + mut block: ir::BlockId, + block_expr: api::BlockExpr, +) -> Result<(ir::BlockId, ir::ValueId), Error> { + let api::BlockExpr(api_block, api_ret_val) = block_expr; + + let mut join_info = None; + + let mut api_value_ids = api_builder.blocks.block_values(api_block).peekable(); + loop { + let mut continuation_group = SmallVec::<[_; 32]>::new(); + loop { + if let Some(api_value_id) = api_value_ids.peek() { + if let api::Op::DeclareContinuation { continuation } = + api_builder.vals.node(api_value_id).op + { + let info = api_builder.continuations[continuation]; + let arg_type = body_types[info.arg_type]; + let (entry_block, arg) = graph_builder.add_block_with_param(arg_type); + replace_none( + &mut continuations_in_scope[continuation], + ContinuationBinding { + entry_block, + arg_type, + }, + ) + .unwrap(); + continuation_group.push((continuation, arg)); + api_value_ids.next(); + continue; + } + } + break; + } + + for (continuation, arg) in continuation_group { + let ContinuationBinding { + entry_block, + arg_type: _, + } = continuations_in_scope[continuation].unwrap(); + + let api::ContinuationInfo { + arg_type: _, + ret_type: api_ret_type, + arg: api_arg, + body: api_body, + } = api_builder.continuations[continuation]; + + replace_none(&mut values_in_scope[api_arg], arg).unwrap(); + let (continuation_final_block, continuation_ret_val) = preprocess_block_expr( + tc, + ctx, + api_builder, + body_types, + graph_builder, + values_in_scope, + continuations_in_scope, + entry_block, + api_body + .expect("builder API should have checked that all continuations are defined"), + ) + .map_err(Error::annotate_binding(BindingLocation::Continuation( + *continuation, + )))?; + values_in_scope[api_arg] = None; + + let ret_type = body_types[api_ret_type]; + + check_type( + ctx.nc, + tc, + ret_type, + graph_builder + .values() + .node(continuation_ret_val) + .op + .result_type, + ) + .map_err(Error::annotate_binding(BindingLocation::Continuation( + *continuation, + )))?; + + let (join_block, join_val_type, _) = *join_info.get_or_insert_with(|| { + let (join_block, join_val) = graph_builder.add_block_with_param(ret_type); + (join_block, ret_type, join_val) + }); + + check_type(ctx.nc, tc, join_val_type, ret_type).map_err(Error::annotate_binding( + BindingLocation::Continuation(*continuation), + ))?; + + graph_builder.set_jump_targets( + continuation_final_block, + Some(continuation_ret_val), + smallvec![ir::JumpTarget::Block(join_block)], + ); + } + + match api_value_ids.next() { + None => break, + Some(api_value_id) => { + let api_node = api_builder.vals.node(api_value_id); + debug_assert!(!matches!(&api_node.op, api::Op::DeclareContinuation { .. })); + let (new_block, value) = preprocess_op( + tc, + ctx, + api_builder, + body_types, + graph_builder, + values_in_scope, + continuations_in_scope, + block, + &api_node.op, + &api_node.inputs, + ) + .map_err(Error::annotate_binding(BindingLocation::Value( + api_value_id, + )))?; + block = new_block; + replace_none(&mut values_in_scope[api_value_id], value).unwrap(); + } + } + } + + let (final_block, final_value) = match join_info { + None => (block, get_value(values_in_scope, api_ret_val)?), + Some((join_block, join_val_type, join_val)) => { + let ret_val = get_value(values_in_scope, api_ret_val)?; + check_type( + ctx.nc, + tc, + join_val_type, + graph_builder.values().node(ret_val).op.result_type, + )?; + graph_builder.set_jump_targets( + block, + Some(ret_val), + smallvec![ir::JumpTarget::Block(join_block)], + ); + (join_block, join_val) + } + }; + + for api_value_id in api_builder.blocks.block_values(api_block) { + match &api_builder.vals.node(api_value_id).op { + api::Op::DeclareContinuation { continuation } => { + debug_assert!(values_in_scope[api_value_id].is_none()); + debug_assert!(continuations_in_scope[continuation].is_some()); + continuations_in_scope[continuation] = None; + } + + _ => { + debug_assert!(values_in_scope[api_value_id].is_some()); + values_in_scope[api_value_id] = None; + } + } + } + + Ok((final_block, final_value)) +} + +fn preprocess_op( + tc: &mut TypeCache, + ctx: Context, + api_builder: &api::ExprBuilder, + body_types: &IdVec, + graph_builder: &mut ir::GraphBuilder, + values_in_scope: &mut IdVec>, + continuations_in_scope: &mut IdVec>, + block: ir::BlockId, + api_op: &api::Op, + api_inputs: &[api::ValueId], +) -> Result<(ir::BlockId, ir::ValueId), Error> { + let mut inputs = SmallVec::<[_; 32]>::with_capacity(api_inputs.len()); + let mut input_types = SmallVec::<[_; 32]>::with_capacity(api_inputs.len()); + for &api_input in api_inputs { + let id = get_value(values_in_scope, api_input)?; + inputs.push(id); + input_types.push(graph_builder.values().node(id).op.result_type); + } + + match api_op { + api::Op::Arg | api::Op::ContinuationArg | api::Op::DeclareContinuation { .. } => { + unreachable!( + "op {:?} should never appear as a value binding in a block", + api_op, + ) + } + + api::Op::Jump { + continuation, + unreachable_result_type, + } => { + debug_assert_eq!(inputs.len(), 1); + + let cont_binding = continuations_in_scope[continuation] + .ok_or_else(|| ErrorKind::ContinuationNotInScope(*continuation))?; + + check_type(ctx.nc, tc, cont_binding.arg_type, input_types[0])?; + + graph_builder.set_jump_targets( + block, + Some(inputs[0]), + smallvec![ir::JumpTarget::Block(cont_binding.entry_block)], + ); + + let (unreachable_block, unreachable_result) = + graph_builder.add_block_with_param(body_types[unreachable_result_type]); + + Ok((unreachable_block, unreachable_result)) + } + + api::Op::UnknownWith { result_type } => { + let value = graph_builder.add_op( + block, + ir::OpKind::UnknownWith, + &inputs, + body_types[result_type], + ); + Ok((block, value)) + } + + api::Op::Call { + callee_spec_var, + callee_mod, + callee, + } => { + debug_assert_eq!(inputs.len(), 1); + + // TODO: Avoid the clones here + let callee_id = ctx + .nc + .funcs + .get_by_val(&(callee_mod.clone(), callee.clone())) + .ok_or_else(|| ErrorKind::FuncNotFound(callee_mod.clone(), callee.clone()))?; + + let callee_sig = &ctx.func_sigs[callee_id]; + + check_type(ctx.nc, tc, callee_sig.arg_type, input_types[0])?; + + let value = graph_builder.add_op( + block, + ir::OpKind::Call { + callee_spec_var: *callee_spec_var, + callee: callee_id, + }, + &inputs, + callee_sig.ret_type, + ); + Ok((block, value)) + } + + api::Op::ConstRef { const_mod, const_ } => { + debug_assert_eq!(inputs.len(), 0); + + let const_id = ctx + .nc + .consts + .get_by_val(&(const_mod.clone(), const_.clone())) + .ok_or_else(|| ErrorKind::ConstNotFound(const_mod.clone(), const_.clone()))?; + + let const_type = ctx.const_sigs[const_id]; + + let value = graph_builder.add_op( + block, + ir::OpKind::ConstRef { const_: const_id }, + &[], + const_type, + ); + Ok((block, value)) + } + + api::Op::Choice { cases } => { + debug_assert_eq!(inputs.len(), 0); + debug_assert_ne!(cases.len(), 0); + + let case_results: SmallVec<[_; 32]> = cases + .iter() + .map(|&case| { + let case_entry_block = graph_builder.add_block(); + let (case_final_block, case_value) = preprocess_block_expr( + tc, + ctx, + api_builder, + body_types, + graph_builder, + values_in_scope, + continuations_in_scope, + case_entry_block, + case, + )?; + Ok((case_entry_block, case_final_block, case_value)) + }) + .collect::>()?; + + graph_builder.set_jump_targets( + block, + None, + case_results + .iter() + .map(|&(case_entry_block, _, _)| ir::JumpTarget::Block(case_entry_block)) + .collect(), + ); + + let mut result_type = None; + for &(_, _, case_value) in &case_results { + let case_value_type = graph_builder.values().node(case_value).op.result_type; + if let Some(prev_result_type) = result_type { + check_type(ctx.nc, tc, prev_result_type, case_value_type)?; + } else { + result_type = Some(case_value_type); + } + } + let result_type = result_type.expect("case_results is nonempty"); + + let (successor_block, choice_value) = graph_builder.add_block_with_param(result_type); + + for &(_, case_final_block, case_value) in &case_results { + graph_builder.set_jump_targets( + case_final_block, + Some(case_value), + smallvec![JumpTarget::Block(successor_block)], + ); + } + + Ok((successor_block, choice_value)) + } + + api::Op::SubBlock { sub_block } => { + debug_assert_eq!(inputs.len(), 0); + preprocess_block_expr( + tc, + ctx, + api_builder, + body_types, + graph_builder, + values_in_scope, + continuations_in_scope, + block, + *sub_block, + ) + } + + api::Op::Terminate { + unreachable_result_type, + } => { + debug_assert_eq!(inputs.len(), 0); + graph_builder.set_jump_targets(block, None, smallvec![]); + let (unreachable_block, unreachable_value) = + graph_builder.add_block_with_param(body_types[unreachable_result_type]); + Ok((unreachable_block, unreachable_value)) + } + + api::Op::NewHeapCell => { + debug_assert_eq!(inputs.len(), 0); + let value = graph_builder.add_op( + block, + ir::OpKind::NewHeapCell, + &[], + tc.types.get_or_insert(TypeData::HeapCell), + ); + Ok((block, value)) + } + + api::Op::Touch => { + debug_assert_eq!(inputs.len(), 1); + let heap_cell_type = tc.types.get_or_insert(TypeData::HeapCell); + check_type(ctx.nc, tc, heap_cell_type, input_types[0])?; + let value = graph_builder.add_op( + block, + ir::OpKind::RecursiveTouch, + &inputs, + tc.types.get_or_insert(TypeData::Tuple { + fields: smallvec![], + }), + ); + Ok((block, value)) + } + + api::Op::RecursiveTouch => { + debug_assert_eq!(inputs.len(), 1); + let value = graph_builder.add_op( + block, + ir::OpKind::RecursiveTouch, + &inputs, + tc.types.get_or_insert(TypeData::Tuple { + fields: smallvec![], + }), + ); + Ok((block, value)) + } + + api::Op::UpdateWriteOnly { update_mode_var } => { + debug_assert_eq!(inputs.len(), 1); + let heap_cell_type = tc.types.get_or_insert(TypeData::HeapCell); + check_type(ctx.nc, tc, heap_cell_type, input_types[0])?; + let value = graph_builder.add_op( + block, + ir::OpKind::UpdateWriteOnly { + update_mode_var: *update_mode_var, + }, + &inputs, + tc.types.get_or_insert(TypeData::Tuple { + fields: smallvec![], + }), + ); + Ok((block, value)) + } + + api::Op::EmptyBag { item_type } => { + debug_assert_eq!(inputs.len(), 0); + let value = graph_builder.add_op( + block, + ir::OpKind::EmptyBag, + &[], + tc.types.get_or_insert(TypeData::Bag { + item: body_types[item_type], + }), + ); + Ok((block, value)) + } + + api::Op::BagInsert => { + debug_assert_eq!(inputs.len(), 2); + let bag_type = input_types[0]; + let expected_item_type = try_get_bag_item_type(ctx.nc, tc, bag_type)?; + check_type(ctx.nc, tc, expected_item_type, input_types[1])?; + let value = graph_builder.add_op(block, ir::OpKind::BagInsert, &inputs, bag_type); + Ok((block, value)) + } + + api::Op::BagGet => { + debug_assert_eq!(inputs.len(), 1); + let item_type = try_get_bag_item_type(ctx.nc, tc, input_types[0])?; + let value = graph_builder.add_op(block, ir::OpKind::BagGet, &inputs, item_type); + Ok((block, value)) + } + + api::Op::BagRemove => { + debug_assert_eq!(inputs.len(), 1); + let bag_type = input_types[0]; + let item_type = try_get_bag_item_type(ctx.nc, tc, bag_type)?; + let value = graph_builder.add_op( + block, + ir::OpKind::BagRemove, + &inputs, + tc.types.get_or_insert(TypeData::Tuple { + fields: smallvec![bag_type, item_type], + }), + ); + Ok((block, value)) + } + + api::Op::MakeTuple => { + let tuple_type = tc.types.get_or_insert(TypeData::Tuple { + fields: SmallVec::from_slice(&input_types), + }); + let value = graph_builder.add_op(block, ir::OpKind::MakeTuple, &inputs, tuple_type); + Ok((block, value)) + } + + api::Op::GetTupleField { field_idx } => { + debug_assert_eq!(inputs.len(), 1); + let tuple_type = input_types[0]; + let field_types = try_get_tuple_field_types(ctx.nc, tc, tuple_type)?; + let field_type = *field_types + .get(*field_idx as usize) + .ok_or_else(|| ErrorKind::TupleFieldOutOfRange(*field_idx))?; + let value = graph_builder.add_op( + block, + ir::OpKind::GetTupleField { + field_idx: *field_idx, + }, + &inputs, + field_type, + ); + Ok((block, value)) + } + + api::Op::MakeUnion { + variant_types, + variant_idx, + } => { + debug_assert_eq!(inputs.len(), 1); + let tc_variant_types: SmallVec<_> = variant_types + .iter() + .map(|api_type_id| body_types[api_type_id]) + .collect(); + let this_variant_type = *tc_variant_types + .get(*variant_idx as usize) + .ok_or_else(|| ErrorKind::UnionVariantOutOfRange(*variant_idx))?; + check_type(ctx.nc, tc, this_variant_type, input_types[0])?; + let union_type = tc.types.get_or_insert(TypeData::Union { + variants: tc_variant_types, + }); + let value = graph_builder.add_op( + block, + ir::OpKind::MakeUnion { + variant_idx: *variant_idx, + }, + &inputs, + union_type, + ); + Ok((block, value)) + } + + api::Op::UnwrapUnion { variant_idx } => { + debug_assert_eq!(inputs.len(), 1); + let variant_types = try_get_union_variant_types(ctx.nc, tc, input_types[0])?; + let this_variant_type = *variant_types + .get(*variant_idx as usize) + .ok_or_else(|| ErrorKind::UnionVariantOutOfRange(*variant_idx))?; + let value = graph_builder.add_op( + block, + ir::OpKind::UnwrapUnion { + variant_idx: *variant_idx, + }, + &inputs, + this_variant_type, + ); + Ok((block, value)) + } + + api::Op::MakeNamed { named_mod, named } => { + debug_assert_eq!(inputs.len(), 1); + // TODO: Avoid the clones here + let named_id = ctx + .nc + .named_types + .get_by_val(&(named_mod.clone(), named.clone())) + .ok_or_else(|| ErrorKind::NamedTypeNotFound(named_mod.clone(), named.clone()))?; + let content_type = ctx.typedef_contents[named_id]; + check_type(ctx.nc, tc, content_type, input_types[0])?; + let value = graph_builder.add_op( + block, + ir::OpKind::MakeNamed, + &inputs, + tc.types.get_or_insert(TypeData::Named { named: named_id }), + ); + Ok((block, value)) + } + + api::Op::UnwrapNamed { named_mod, named } => { + debug_assert_eq!(inputs.len(), 1); + let named_id = try_get_named_type_id(ctx.nc, tc, input_types[0])?; + let expected_named_id = ctx + .nc + .named_types + .get_by_val(&(named_mod.clone(), named.clone())) + .ok_or_else(|| ErrorKind::NamedTypeNotFound(named_mod.clone(), named.clone()))?; + if named_id != expected_named_id { + let expected = tc.types.get_or_insert(TypeData::Named { + named: expected_named_id, + }); + type_error(ctx.nc, tc, expected, input_types[0])?; + } + let value = graph_builder.add_op( + block, + ir::OpKind::UnwrapNamed, + &inputs, + ctx.typedef_contents[named_id], + ); + Ok((block, value)) + } + } +} + +fn preprocess_func_def( + tc: &mut TypeCache, + ctx: Context, + func_def: &api::FuncDef, + body_types: &IdVec, +) -> Result { + let api_builder = &func_def.builder.expr_builder; + let mut graph_builder = ir::GraphBuilder::new(); + let mut values_in_scope = IdVec::filled_with(api_builder.vals.count(), || None); + let mut continuations_in_scope = IdVec::filled_with(api_builder.continuations.count(), || None); + let (entry_block, arg_val) = graph_builder.add_block_with_param(body_types[func_def.arg_type]); + values_in_scope[func_def.builder.argument] = Some(arg_val); + let (final_block, ret_val) = preprocess_block_expr( + tc, + ctx, + &api_builder, + body_types, + &mut graph_builder, + &mut values_in_scope, + &mut continuations_in_scope, + entry_block, + func_def.root, + )?; + check_type( + ctx.nc, + tc, + body_types[func_def.ret_type], + graph_builder.values().node(ret_val).op.result_type, + )?; + graph_builder.set_jump_targets(final_block, Some(ret_val), smallvec![ir::JumpTarget::Ret]); + Ok(ir::FuncDef { + graph: graph_builder.build(entry_block), + }) +} + +fn preprocess_const_def( + tc: &mut TypeCache, + ctx: Context, + const_def: &api::ConstDef, + body_types: &IdVec, +) -> Result { + let api_builder = &const_def.builder.expr_builder; + let mut graph_builder = ir::GraphBuilder::new(); + let mut values_in_scope = IdVec::filled_with(api_builder.vals.count(), || None); + let mut continuations_in_scope = IdVec::filled_with(api_builder.continuations.count(), || None); + let entry_block = graph_builder.add_block(); + let (final_block, ret_val) = preprocess_block_expr( + tc, + ctx, + &api_builder, + body_types, + &mut graph_builder, + &mut values_in_scope, + &mut continuations_in_scope, + entry_block, + const_def.root, + )?; + check_type( + ctx.nc, + tc, + body_types[const_def.type_], + graph_builder.values().node(ret_val).op.result_type, + )?; + graph_builder.set_jump_targets(final_block, Some(ret_val), smallvec![ir::JumpTarget::Ret]); + Ok(ir::ConstDef { + graph: graph_builder.build(entry_block), + }) +} diff --git a/vendor/morphic_lib/src/type_cache.rs b/vendor/morphic_lib/src/type_cache.rs new file mode 100644 index 0000000000..beb16b182b --- /dev/null +++ b/vendor/morphic_lib/src/type_cache.rs @@ -0,0 +1,22 @@ +use smallvec::SmallVec; + +use crate::name_cache::NamedTypeId; +use crate::util::id_bi_map::IdBiMap; + +id_type! { + pub TypeId(u32); +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub enum TypeData { + Named { named: NamedTypeId }, + Tuple { fields: SmallVec<[TypeId; 10]> }, + Union { variants: SmallVec<[TypeId; 10]> }, + HeapCell, + Bag { item: TypeId }, +} + +#[derive(Clone, Debug, Default)] +pub struct TypeCache { + pub types: IdBiMap, +} diff --git a/vendor/morphic_lib/src/util/blocks.rs b/vendor/morphic_lib/src/util/blocks.rs index 79182bbd86..22c182cbfa 100644 --- a/vendor/morphic_lib/src/util/blocks.rs +++ b/vendor/morphic_lib/src/util/blocks.rs @@ -75,8 +75,8 @@ impl Blocks { tail_frag.max_val = next_val; } else { let new_tail = BlockFrag { - min_val: val_id, - max_val: next_val, + min_val: val_id.clone(), + max_val: ValId::from_index_or_panic(val_id.to_index() + 1), next: None, }; let new_tail_id = self.frags.push(new_tail); diff --git a/vendor/morphic_lib/src/util/bytes_id.rs b/vendor/morphic_lib/src/util/bytes_id.rs index 328fba47b8..b75d618271 100644 --- a/vendor/morphic_lib/src/util/bytes_id.rs +++ b/vendor/morphic_lib/src/util/bytes_id.rs @@ -4,15 +4,15 @@ macro_rules! bytes_id { $(#[$annot_borrowed:meta])* $borrowed_vis:vis $borrowed:ident; $(#[$annot_owned:meta])* $owned_vis:vis $owned:ident; ) => { - #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] $(#[$annot_borrowed])* $borrowed_vis struct $borrowed<'a>($borrowed_vis &'a [u8]); - // The stack-allocated array portion of a `SmallVec` shares a union with two `usize`s, so on - // 64-bit platforms we can make the array up to 16 bytes long with no space penalty. - #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] + // On 64-bit platforms we can store up to `23` bytes inline in a `SmallVec` with no space + // penalty. + #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] $(#[$annot_owned])* - $owned_vis struct $owned($owned_vis ::smallvec::SmallVec<[u8; 16]>); + $owned_vis struct $owned($owned_vis ::smallvec::SmallVec<[u8; 23]>); impl $owned { fn borrowed<'a>(&'a self) -> $borrowed<'a> { @@ -25,5 +25,27 @@ macro_rules! bytes_id { $owned(::smallvec::SmallVec::from_slice(&borrowed.0)) } } + + impl<'a> ::std::fmt::Debug for $borrowed<'a> { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + // TODO: Consolidate this with render_api_ir.rs + write!(f, "{}(\"", stringify!($borrowed))?; + for &byte in self.0 { + write!(f, "{}", ::std::ascii::escape_default(byte))?; + } + write!(f, "\")")?; + Ok(()) + } + } + + impl ::std::fmt::Debug for $owned { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + // We intentionally use the name of $borrowed to render values of type $owned, + // because only the borrowed version of each bytestring-based identifier type are + // exposed/documented in the public API, and we use this debug formatting logic to + // render public-facing error messages. + write!(f, "{:?}", self.borrowed()) + } + } } } diff --git a/vendor/morphic_lib/src/util/flat_slices.rs b/vendor/morphic_lib/src/util/flat_slices.rs new file mode 100644 index 0000000000..fe72cce7e8 --- /dev/null +++ b/vendor/morphic_lib/src/util/flat_slices.rs @@ -0,0 +1,112 @@ +use std::borrow::Borrow; +use std::fmt; + +use crate::util::id_type::{self, Count, Id}; +use crate::util::id_vec::IdVec; + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] +struct SliceData { + info: SliceInfo, + + /// Determines which slice of the `flat_data` buffer contains the items of this slice. + /// + /// If the *previous* slice has `slice_end_idx == a`, and this slice has `inputs_end_idx == b`, + /// then the items of this slice are given by `flat_data[a..b]`. + slice_end_idx: usize, +} + +/// Conceptually represents a collection of the form `IdVec)>`. +/// +/// The notional `Vec` values are actually stored in a single contiguous buffer to reduce the +/// number of heap allocations. Because these values are all different slices of the same +/// underlying buffer, we refer to each tuple `(SliceInfo, Vec)` as a "slice" for the purposes of +/// this data structure's API. +/// +/// The `SliceInfo` parameter should be regarded as optional, and for some purposes it is perfectly +/// fine (stylistically speaking) to set `SliceInfo = ()`. +#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct FlatSlices { + flat_data: Vec, + slices: IdVec>, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct Slice<'a, SliceInfo, T> { + pub info: &'a SliceInfo, + pub items: &'a [T], +} + +#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct SliceMut<'a, SliceInfo, T> { + pub info: &'a mut SliceInfo, + pub items: &'a mut [T], +} + +impl Default for FlatSlices { + fn default() -> Self { + Self::new() + } +} + +impl FlatSlices { + pub fn new() -> Self { + Self { + flat_data: Vec::new(), + slices: IdVec::new(), + } + } + + pub fn len(&self) -> usize { + self.slices.len() + } + + pub fn count(&self) -> Count { + self.slices.count() + } + + pub fn push_slice(&mut self, info: SliceInfo, slice: &[T]) -> SliceId + where + T: Clone, + { + self.flat_data.extend_from_slice(slice); + self.slices.push(SliceData { + info, + slice_end_idx: self.flat_data.len(), + }) + } + + fn data_range(&self, idx: SliceId) -> (usize, usize) { + let start = match id_type::decrement(idx.clone()) { + None => 0, + Some(prev_idx) => self.slices[prev_idx].slice_end_idx, + }; + let end = self.slices[idx].slice_end_idx; + (start, end) + } + + pub fn get>(&self, idx: I) -> Slice { + let (start, end) = self.data_range(idx.borrow().clone()); + Slice { + info: &self.slices[idx].info, + items: &self.flat_data[start..end], + } + } + + pub fn get_mut>(&mut self, idx: I) -> SliceMut { + let (start, end) = self.data_range(idx.borrow().clone()); + SliceMut { + info: &mut self.slices[idx].info, + items: &mut self.flat_data[start..end], + } + } +} + +impl fmt::Debug + for FlatSlices +{ + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_map() + .entries(self.count().iter().map(|i| (i.clone(), self.get(i)))) + .finish() + } +} diff --git a/vendor/morphic_lib/src/util/id_bi_map.rs b/vendor/morphic_lib/src/util/id_bi_map.rs index 8b7c31621e..00b04c2142 100644 --- a/vendor/morphic_lib/src/util/id_bi_map.rs +++ b/vendor/morphic_lib/src/util/id_bi_map.rs @@ -52,6 +52,18 @@ impl IdBiMap { } } + /// Insert a value into the bi-map, or get its key if it is already present. + pub fn get_or_insert(&mut self, val: V) -> K { + match self.val_to_key.entry(val) { + Entry::Occupied(occupied) => occupied.get().clone(), + Entry::Vacant(vacant) => { + let new_index = self.key_to_val.push(vacant.key().clone()); + vacant.insert(new_index.clone()); + new_index + } + } + } + pub fn get_by_val(&self, val: &V) -> Option { self.val_to_key.get(val).cloned() } diff --git a/vendor/morphic_lib/src/util/id_type.rs b/vendor/morphic_lib/src/util/id_type.rs index 047e2886da..a0b730d746 100644 --- a/vendor/morphic_lib/src/util/id_type.rs +++ b/vendor/morphic_lib/src/util/id_type.rs @@ -98,7 +98,14 @@ impl PartialOrd for Count { } impl Count { - pub fn iter(&self) -> impl Iterator { + pub fn iter(&self) -> impl DoubleEndedIterator { (0..self.0.to_index()).map(T::from_index_unchecked) } } + +pub fn decrement(id: T) -> Option { + match id.to_index() { + 0 => None, + index => Some(T::from_index_unchecked(index - 1)), + } +} diff --git a/vendor/morphic_lib/src/util/id_vec.rs b/vendor/morphic_lib/src/util/id_vec.rs index 99a53fce74..ab222559ea 100644 --- a/vendor/morphic_lib/src/util/id_vec.rs +++ b/vendor/morphic_lib/src/util/id_vec.rs @@ -107,6 +107,13 @@ impl IdVec { } } + pub fn with_capacity(capacity: usize) -> Self { + IdVec { + key: PhantomData, + items: Vec::with_capacity(capacity), + } + } + pub fn from_items(items: Vec) -> Self { K::assert_in_range(items.len()); IdVec { diff --git a/vendor/morphic_lib/src/util/mod.rs b/vendor/morphic_lib/src/util/mod.rs index b382f997cd..d5fb572b08 100644 --- a/vendor/morphic_lib/src/util/mod.rs +++ b/vendor/morphic_lib/src/util/mod.rs @@ -8,7 +8,9 @@ pub mod bytes_id; pub mod forward_trait; pub mod blocks; +pub mod flat_slices; pub mod id_bi_map; pub mod id_vec; pub mod op_graph; pub mod replace_none; +pub mod strongly_connected; diff --git a/vendor/morphic_lib/src/util/op_graph.rs b/vendor/morphic_lib/src/util/op_graph.rs index b7f8b3ca9a..46e7b38f49 100644 --- a/vendor/morphic_lib/src/util/op_graph.rs +++ b/vendor/morphic_lib/src/util/op_graph.rs @@ -1,18 +1,7 @@ use std::borrow::Borrow; +use crate::util::flat_slices::{FlatSlices, Slice}; use crate::util::id_type::{Count, Id}; -use crate::util::id_vec::IdVec; - -#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] -struct NodeData { - op: Op, - - /// Determines which slice of the `flat_inputs` buffer contains the inputs to this node. - /// - /// If the *previous* op has `inputs_end_idx == a`, and this node has `inputs_end_idx == b`, - /// then the inputs to this node are given by `flat_inputs[a..b]`. - inputs_end_idx: usize, -} #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct Node<'a, K, Op> { @@ -27,47 +16,45 @@ pub struct Node<'a, K, Op> { /// /// The input lists are actually stored in a single contiguous buffer to reduce the number of heap /// allocations. +/// +/// This is essentially just a newtype wrapper around `FlatSlices`. We use this wrapper to +/// represent op graphs (instead of using `FlatSlices` directly) just so that the names of types, +/// functions, and fields in the API are more meaningful for this use case. #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct OpGraph { - flat_inputs: Vec, - nodes: IdVec>, + inner: FlatSlices, +} + +impl Default for OpGraph { + fn default() -> Self { + Self::new() + } } impl OpGraph { pub fn new() -> Self { Self { - flat_inputs: Vec::new(), - nodes: IdVec::new(), + inner: FlatSlices::new(), } } pub fn len(&self) -> usize { - self.nodes.len() + self.inner.len() } pub fn count(&self) -> Count { - self.nodes.count() + self.inner.count() } pub fn add_node(&mut self, op: Op, inputs: &[K]) -> K { - self.flat_inputs.extend_from_slice(inputs); - let node = NodeData { - op, - inputs_end_idx: self.flat_inputs.len(), - }; - self.nodes.push(node) + self.inner.push_slice(op, inputs) } pub fn node>(&self, idx: I) -> Node { - let node = &self.nodes[idx.borrow()]; - let inputs_start_idx = if idx.borrow().to_index() == 0 { - 0 - } else { - self.nodes[K::from_index_unchecked(idx.borrow().to_index() - 1)].inputs_end_idx - }; + let Slice { info, items } = self.inner.get(idx); Node { - op: &node.op, - inputs: &self.flat_inputs[inputs_start_idx..node.inputs_end_idx], + op: info, + inputs: items, } } } diff --git a/vendor/morphic_lib/src/util/strongly_connected.rs b/vendor/morphic_lib/src/util/strongly_connected.rs new file mode 100644 index 0000000000..91cdfeb3e0 --- /dev/null +++ b/vendor/morphic_lib/src/util/strongly_connected.rs @@ -0,0 +1,152 @@ +use crate::util::flat_slices::FlatSlices; +use crate::util::id_type::{Count, Id}; +use crate::util::id_vec::IdVec; +use crate::util::replace_none::replace_none; + +#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub enum SccKind { + Acyclic, + Cyclic, +} + +pub fn strongly_connected( + node_count: Count, + mut node_successors: impl FnMut(NodeId) -> NodeSuccessors, +) -> FlatSlices +where + SccId: Id, + NodeId: Id + Eq + Copy, + NodeSuccessors: Iterator, +{ + // We use Tarjan's algorithm, performing the depth-first search using an explicit Vec-based + // stack instead of recursion to avoid stack overflows on large graphs. + + #[derive(Clone, Copy, Debug)] + enum NodeState { + Unvisited, + OnSearchStack { index: u32, low_link: u32 }, + OnSccStack { index: u32 }, + Complete, + } + + #[derive(Clone, Copy)] + enum Action { + TryVisit { + parent: Option, + node: NodeId, + }, + FinishVisit { + parent: Option, + node: NodeId, + }, + } + + let mut sccs = FlatSlices::new(); + + let mut node_states = IdVec::filled_with(node_count, || NodeState::Unvisited); + let mut node_self_loops = IdVec::filled_with(node_count, || None); + let mut scc_stack = Vec::new(); + let mut search_stack = Vec::new(); + let mut next_index = 0; + + for search_root in node_count.iter() { + search_stack.push(Action::TryVisit { + parent: None, + node: search_root, + }); + while let Some(action) = search_stack.pop() { + match action { + Action::TryVisit { parent, node } => match node_states[node] { + NodeState::Unvisited => { + node_states[node] = NodeState::OnSearchStack { + index: next_index, + low_link: next_index, + }; + next_index += 1; + scc_stack.push(node); + + search_stack.push(Action::FinishVisit { parent, node }); + // We need to explicitly track self-loops so that when we obtain a size-1 + // SCC we can determine if it's cyclic or acyclic. + let mut has_self_loop = false; + for successor in node_successors(node) { + if successor == node { + has_self_loop = true; + } + search_stack.push(Action::TryVisit { + parent: Some(node), + node: successor, + }); + } + replace_none(&mut node_self_loops[node], has_self_loop).unwrap(); + } + + NodeState::OnSearchStack { index, low_link: _ } + | NodeState::OnSccStack { index } => { + if let Some(parent) = parent { + if let NodeState::OnSearchStack { + index: _, + low_link: parent_low_link, + } = &mut node_states[parent] + { + *parent_low_link = (*parent_low_link).min(index); + } else { + unreachable!("parent should be on search stack"); + } + } + } + + NodeState::Complete => {} + }, + + Action::FinishVisit { parent, node } => { + let (index, low_link) = + if let NodeState::OnSearchStack { index, low_link } = node_states[node] { + (index, low_link) + } else { + unreachable!("node should be on search stack"); + }; + + node_states[node] = NodeState::OnSccStack { index }; + + if let Some(parent) = parent { + if let NodeState::OnSearchStack { + index: _, + low_link: parent_low_link, + } = &mut node_states[parent] + { + *parent_low_link = (*parent_low_link).min(low_link); + } else { + unreachable!("parent should be on search stack") + } + } + + if low_link == index { + let mut scc_start = scc_stack.len(); + loop { + scc_start -= 1; + let scc_node = scc_stack[scc_start]; + debug_assert!( + matches!(node_states[scc_node], NodeState::OnSccStack { .. }) + ); + node_states[scc_node] = NodeState::Complete; + if scc_node == node { + break; + } + } + let scc_slice = &scc_stack[scc_start..]; + let scc_kind = if scc_slice.len() == 1 && !node_self_loops[node].unwrap() { + SccKind::Acyclic + } else { + SccKind::Cyclic + }; + sccs.push_slice(scc_kind, scc_slice); + scc_stack.truncate(scc_start); + } + } + } + } + } + + sccs +} diff --git a/vendor/morphic_lib/tests/basic.rs b/vendor/morphic_lib/tests/basic.rs new file mode 100644 index 0000000000..2c7531c392 --- /dev/null +++ b/vendor/morphic_lib/tests/basic.rs @@ -0,0 +1,77 @@ +use morphic_lib::{ + BlockExpr, CalleeSpecVar, EntryPointName, Error, ExprContext, FuncDefBuilder, FuncName, + ModDefBuilder, ModName, ProgramBuilder, TypeContext, UpdateModeVar, +}; + +#[test] +fn test_basic() { + fn run() -> Result<(), Error> { + let func1_def = { + let mut f = FuncDefBuilder::new(); + let b = f.add_block(); + f.add_update(b, UpdateModeVar(b"var1"), f.get_argument())?; + let ret = f.add_make_tuple(b, &[])?; + let arg_type = f.add_heap_cell_type(); + let ret_type = f.add_tuple_type(&[])?; + f.build(arg_type, ret_type, BlockExpr(b, ret))? + }; + + let func2_def = { + let mut f = FuncDefBuilder::new(); + let b = f.add_block(); + let cell = f.add_new_heap_cell(b)?; + let ret = f.add_call( + b, + CalleeSpecVar(b"var2"), + ModName(b"main_mod"), + FuncName(b"func1"), + cell, + )?; + let unit_type = f.add_tuple_type(&[])?; + f.build(unit_type, unit_type, BlockExpr(b, ret))? + }; + + let main_mod = { + let mut m = ModDefBuilder::new(); + m.add_func(FuncName(b"func1"), func1_def)?; + m.add_func(FuncName(b"func2"), func2_def)?; + m.build()? + }; + + let program = { + let mut p = ProgramBuilder::new(); + p.add_mod(ModName(b"main_mod"), main_mod)?; + p.add_entry_point( + EntryPointName(b"main"), + ModName(b"main_mod"), + FuncName(b"func2"), + )?; + p.build()? + }; + + let program_sol = morphic_lib::solve(program)?; + + let (_, _, func2_spec) = program_sol.entry_point_solution(EntryPointName(b"main"))?; + + let main_mod_sol = program_sol.mod_solutions(ModName(b"main_mod"))?; + + let func2_sol = main_mod_sol + .func_solutions(FuncName(b"func2"))? + .spec(&func2_spec)?; + + let func1_spec = func2_sol.callee_spec(CalleeSpecVar(b"var2"))?; + + let func1_sol = main_mod_sol + .func_solutions(FuncName(b"func1"))? + .spec(&func1_spec)?; + + let _update_mode = func1_sol.update_mode(UpdateModeVar(b"var1"))?; + + Ok(()) + } + + let result = run(); + if let Err(err) = result { + panic!("error: {}", err); + } +} diff --git a/vendor/morphic_lib/tests/recursive.rs b/vendor/morphic_lib/tests/recursive.rs new file mode 100644 index 0000000000..9e50172a50 --- /dev/null +++ b/vendor/morphic_lib/tests/recursive.rs @@ -0,0 +1,95 @@ +use morphic_lib::{ + BlockExpr, CalleeSpecVar, EntryPointName, Error, ExprContext, FuncDefBuilder, FuncName, + ModDefBuilder, ModName, ProgramBuilder, TypeContext, UpdateModeVar, +}; + +#[test] +fn test_recursive() { + fn run() -> Result<(), Error> { + let rec_def = { + let mut f = FuncDefBuilder::new(); + let b = f.add_block(); + let arg = f.get_argument(); + let case1 = { + let b = f.add_block(); + BlockExpr(b, arg) + }; + let case2 = { + let b = f.add_block(); + f.add_update(b, UpdateModeVar(b"mode"), arg)?; + let new = f.add_new_heap_cell(b)?; + let result = f.add_call( + b, + CalleeSpecVar(b"call"), + ModName(b"main"), + FuncName(b"rec"), + new, + )?; + BlockExpr(b, result) + }; + let result = f.add_choice(b, &[case1, case2])?; + let heap_cell_type = f.add_heap_cell_type(); + f.build(heap_cell_type, heap_cell_type, BlockExpr(b, result))? + }; + + let main_def = { + let mut f = FuncDefBuilder::new(); + let b = f.add_block(); + let init = f.add_new_heap_cell(b)?; + let final_ = f.add_call( + b, + CalleeSpecVar(b"call"), + ModName(b"main"), + FuncName(b"rec"), + init, + )?; + f.add_touch(b, final_)?; + let result = f.add_make_tuple(b, &[])?; + let unit_type = f.add_tuple_type(&[])?; + f.build(unit_type, unit_type, BlockExpr(b, result))? + }; + + let mod_ = { + let mut m = ModDefBuilder::new(); + m.add_func(FuncName(b"rec"), rec_def)?; + m.add_func(FuncName(b"main"), main_def)?; + m.build()? + }; + + let program = { + let mut p = ProgramBuilder::new(); + p.add_mod(ModName(b"main"), mod_)?; + p.add_entry_point( + EntryPointName(b"entry"), + ModName(b"main"), + FuncName(b"main"), + )?; + p.build()? + }; + + let program_sol = morphic_lib::solve(program)?; + + let (_, _, main_spec) = program_sol.entry_point_solution(EntryPointName(b"entry"))?; + + let main_mod_sol = program_sol.mod_solutions(ModName(b"main"))?; + + let main_sol = main_mod_sol + .func_solutions(FuncName(b"main"))? + .spec(&main_spec)?; + + let rec_spec = main_sol.callee_spec(CalleeSpecVar(b"call"))?; + + let rec_sol = main_mod_sol + .func_solutions(FuncName(b"rec"))? + .spec(&rec_spec)?; + + let _update_mode = rec_sol.update_mode(UpdateModeVar(b"mode"))?; + + Ok(()) + } + + let result = run(); + if let Err(err) = result { + panic!("error: {}", err); + } +} From 19db7515daf1e185f9cad867c2e3129555672839 Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 14 Jun 2021 21:02:37 +0200 Subject: [PATCH 234/496] fix shadowing of layout --- compiler/gen_llvm/src/llvm/build.rs | 2 +- compiler/mono/src/alias_analysis.rs | 24 +++++++++++++++---- .../quicksort/platform/Package-Config.roc | 2 -- 3 files changed, 21 insertions(+), 7 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index d686f324e7..ae704593c7 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -3161,7 +3161,7 @@ fn build_procedures_help<'a, 'ctx, 'env>( let it = procedures.iter().map(|x| x.1); let solutions = match roc_mono::alias_analysis::spec_program(entry_point, it) { - Err(e) => panic!("Error in alias analysis: {:?}", e), + Err(e) => panic!("Error in alias analysis: {}", e), Ok(solutions) => solutions, }; diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index c3f3b142e8..116b6c55b1 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -78,6 +78,18 @@ where name_bytes } +fn bytes_as_ascii(bytes: &[u8]) -> String { + use std::fmt::Write; + + let mut buf = String::new(); + + for byte in bytes { + write!(buf, "{:02X}", byte).unwrap(); + } + + buf +} + pub fn spec_program<'a, I>( entry_point: crate::ir::EntryPoint<'a>, procs: I, @@ -110,7 +122,11 @@ where for proc in procs { let spec = proc_spec(proc)?; - m.add_func(FuncName(&func_name_bytes(proc)), spec)?; + let bytes = func_name_bytes(proc); + let func_name = FuncName(&bytes); + eprintln!("{:?}: {:?}", proc.name, bytes_as_ascii(&bytes)); + + m.add_func(func_name, spec)?; } m.build()? @@ -126,7 +142,7 @@ where p.build()? }; - // eprintln!("{}", program.to_source_string()); + eprintln!("{}", program.to_source_string()); morphic_lib::solve(program) } @@ -198,8 +214,8 @@ fn stmt_spec( use Stmt::*; match stmt { - Let(symbol, expr, layout, continuation) => { - let value_id = expr_spec(builder, env, block, layout, expr)?; + Let(symbol, expr, expr_layout, continuation) => { + let value_id = expr_spec(builder, env, block, expr_layout, expr)?; env.symbols.insert(*symbol, value_id); let result = stmt_spec(builder, env, block, layout, continuation)?; env.symbols.remove(symbol); diff --git a/examples/quicksort/platform/Package-Config.roc b/examples/quicksort/platform/Package-Config.roc index 2c5757a71e..9569118e7b 100644 --- a/examples/quicksort/platform/Package-Config.roc +++ b/examples/quicksort/platform/Package-Config.roc @@ -6,7 +6,5 @@ platform examples/quicksort provides [ mainForHost ] effects fx.Effect {} -update : Model -> Model - mainForHost : List I64 -> List I64 mainForHost = \list -> quicksort list From b622202d97f8c222f29182b549c4db04f56b6ef8 Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 14 Jun 2021 21:12:24 +0200 Subject: [PATCH 235/496] rename joinpoint field --- compiler/gen_dev/src/lib.rs | 2 +- compiler/gen_llvm/src/llvm/build.rs | 2 +- compiler/mono/src/alias_analysis.rs | 2 +- compiler/mono/src/borrow.rs | 4 ++-- compiler/mono/src/decision_tree.rs | 6 +++--- compiler/mono/src/expand_rc.rs | 4 ++-- compiler/mono/src/inc_dec.rs | 8 ++++---- compiler/mono/src/ir.rs | 25 +++++++++++++------------ compiler/mono/src/tail_recursion.rs | 6 +++--- 9 files changed, 30 insertions(+), 29 deletions(-) diff --git a/compiler/gen_dev/src/lib.rs b/compiler/gen_dev/src/lib.rs index 790aa9b6ac..e759657ed8 100644 --- a/compiler/gen_dev/src/lib.rs +++ b/compiler/gen_dev/src/lib.rs @@ -519,7 +519,7 @@ where } Stmt::Join { parameters, - continuation, + body: continuation, remainder, .. } => { diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index ae704593c7..7a8d5dc2d1 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -2137,7 +2137,7 @@ pub fn build_exp_stmt<'a, 'ctx, 'env>( id, parameters, remainder, - continuation, + body: continuation, } => { let builder = env.builder; let context = env.context; diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 116b6c55b1..6ec75c28bd 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -298,7 +298,7 @@ fn stmt_spec( Join { id, parameters, - continuation, + body: continuation, remainder, } => { let mut type_ids = Vec::new(); diff --git a/compiler/mono/src/borrow.rs b/compiler/mono/src/borrow.rs index 963ab1e2c6..682fa42e3f 100644 --- a/compiler/mono/src/borrow.rs +++ b/compiler/mono/src/borrow.rs @@ -193,7 +193,7 @@ impl<'a> ParamMap<'a> { id: j, parameters: xs, remainder: v, - continuation: b, + body: b, } => { let already_in_there = self .items @@ -618,7 +618,7 @@ impl<'a> BorrowInfState<'a> { id: j, parameters: ys, remainder: v, - continuation: b, + body: b, } => { let old = self.param_set.clone(); self.update_param_set(ys); diff --git a/compiler/mono/src/decision_tree.rs b/compiler/mono/src/decision_tree.rs index 565e9f7126..cd7f5bb1f5 100644 --- a/compiler/mono/src/decision_tree.rs +++ b/compiler/mono/src/decision_tree.rs @@ -956,7 +956,7 @@ pub fn optimize_when<'a>( stmt = Stmt::Join { id, parameters: &[], - continuation: env.arena.alloc(body), + body: env.arena.alloc(body), remainder: env.arena.alloc(stmt), }; } @@ -1329,7 +1329,7 @@ fn compile_guard<'a>( id, parameters: arena.alloc([param]), remainder: stmt, - continuation: arena.alloc(cond), + body: arena.alloc(cond), } } @@ -1622,7 +1622,7 @@ fn decide_to_branching<'a>( Stmt::Join { id: fail_jp_id, parameters: &[], - continuation: fail, + body: fail, remainder: arena.alloc(test_stmt), } } diff --git a/compiler/mono/src/expand_rc.rs b/compiler/mono/src/expand_rc.rs index 1686bfc123..2d60e6a213 100644 --- a/compiler/mono/src/expand_rc.rs +++ b/compiler/mono/src/expand_rc.rs @@ -622,7 +622,7 @@ fn expand_and_cancel<'a>(env: &mut Env<'a, '_>, stmt: &'a Stmt<'a>) -> &'a Stmt< Join { id, parameters, - continuation, + body: continuation, remainder, } => { let continuation = expand_and_cancel(env, continuation); @@ -631,7 +631,7 @@ fn expand_and_cancel<'a>(env: &mut Env<'a, '_>, stmt: &'a Stmt<'a>) -> &'a Stmt< let stmt = Join { id: *id, parameters, - continuation, + body: continuation, remainder, }; diff --git a/compiler/mono/src/inc_dec.rs b/compiler/mono/src/inc_dec.rs index eb7fa7903a..a0907bee72 100644 --- a/compiler/mono/src/inc_dec.rs +++ b/compiler/mono/src/inc_dec.rs @@ -64,7 +64,7 @@ pub fn occurring_variables(stmt: &Stmt<'_>) -> (MutSet, MutSet) Join { parameters, - continuation, + body: continuation, remainder, .. } => { @@ -978,7 +978,7 @@ impl<'a> Context<'a> { id: j, parameters: _, remainder: b, - continuation: v, + body: v, } => { // get the parameters with borrow signature let xs = self.param_map.get_join_point(*j); @@ -1000,7 +1000,7 @@ impl<'a> Context<'a> { id: *j, parameters: xs, remainder: b, - continuation: v, + body: v, }), b_live_vars, ) @@ -1143,7 +1143,7 @@ pub fn collect_stmt( id: j, parameters, remainder: b, - continuation: v, + body: v, } => { let mut j_live_vars = collect_stmt(v, jp_live_vars, MutSet::default()); for param in parameters.iter() { diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 686b5b8b53..aec2d1106b 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -890,9 +890,10 @@ pub enum Stmt<'a> { Join { id: JoinPointId, parameters: &'a [Param<'a>], - /// does not contain jumps to this id - continuation: &'a Stmt<'a>, - /// the "body" of the join point, contains the jumps to this id + /// body of the join point + /// what happens after _jumping to_ the join point + body: &'a Stmt<'a>, + /// what happens after _defining_ the join point remainder: &'a Stmt<'a>, }, Jump(JoinPointId, &'a [Symbol]), @@ -1476,7 +1477,7 @@ impl<'a> Stmt<'a> { Join { id, parameters, - continuation, + body: continuation, remainder, } => { let it = parameters.iter().map(|p| symbol_to_doc(alloc, p.symbol)); @@ -3328,7 +3329,7 @@ pub fn with_hole<'a>( id, parameters: env.arena.alloc([param]), remainder: env.arena.alloc(stmt), - continuation: hole, + body: hole, } } } @@ -3381,7 +3382,7 @@ pub fn with_hole<'a>( id, parameters: env.arena.alloc([param]), remainder: env.arena.alloc(stmt), - continuation: env.arena.alloc(hole), + body: env.arena.alloc(hole), } } @@ -5327,7 +5328,7 @@ fn substitute_in_stmt_help<'a>( id, parameters, remainder, - continuation, + body: continuation, } => { let opt_remainder = substitute_in_stmt_help(arena, remainder, subs); let opt_continuation = substitute_in_stmt_help(arena, continuation, subs); @@ -5340,7 +5341,7 @@ fn substitute_in_stmt_help<'a>( id: *id, parameters, remainder, - continuation, + body: continuation, })) } else { None @@ -7859,7 +7860,7 @@ where Stmt::Join { id: join_point_id, parameters: &*env.arena.alloc([param]), - continuation: hole, + body: hole, remainder: env.arena.alloc(switch), } } @@ -8017,7 +8018,7 @@ fn union_lambda_set_to_switch<'a>( Stmt::Join { id: join_point_id, parameters: &*env.arena.alloc([param]), - continuation: hole, + body: hole, remainder: env.arena.alloc(switch), } } @@ -8161,7 +8162,7 @@ fn enum_lambda_set_to_switch<'a>( Stmt::Join { id: join_point_id, parameters: &*env.arena.alloc([param]), - continuation: hole, + body: hole, remainder: env.arena.alloc(switch), } } @@ -8290,7 +8291,7 @@ where Stmt::Join { id: join_point_id, parameters: &*env.arena.alloc([param]), - continuation: hole, + body: hole, remainder: env.arena.alloc(switch), } } diff --git a/compiler/mono/src/tail_recursion.rs b/compiler/mono/src/tail_recursion.rs index 618acf81f3..0eae4df30a 100644 --- a/compiler/mono/src/tail_recursion.rs +++ b/compiler/mono/src/tail_recursion.rs @@ -60,7 +60,7 @@ pub fn make_tail_recursive<'a>( id, remainder: jump, parameters: params, - continuation: new, + body: new, } } } @@ -160,7 +160,7 @@ fn insert_jumps<'a>( id, parameters, remainder, - continuation, + body: continuation, } => { let opt_remainder = insert_jumps(arena, remainder, goal_id, needle); let opt_continuation = insert_jumps(arena, continuation, goal_id, needle); @@ -173,7 +173,7 @@ fn insert_jumps<'a>( id: *id, parameters, remainder, - continuation, + body: continuation, })) } else { None From 0e6e9847fc3d9f19c21fea6ddff2bcf0b377d40c Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 14 Jun 2021 23:36:27 +0200 Subject: [PATCH 236/496] fix things in alias analysis --- compiler/mono/src/alias_analysis.rs | 112 ++++++++++++++++++++++++---- 1 file changed, 97 insertions(+), 15 deletions(-) diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 6ec75c28bd..3d73aec8a4 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -114,8 +114,15 @@ where m.add_const(STATIC_STR_NAME, static_str_def)?; // the entry point wrapper + let roc_main_bytes = func_name_bytes_help( + entry_point.symbol, + entry_point.layout.arguments.iter().copied(), + entry_point.layout.result, + ); + let roc_main = FuncName(&roc_main_bytes); + + let entry_point_function = build_entry_point(entry_point.layout, roc_main)?; let entry_point_name = FuncName(ENTRY_POINT_NAME); - let entry_point_function = build_entry_point(entry_point.layout, entry_point_name)?; m.add_func(entry_point_name, entry_point_function)?; // all other functions @@ -124,7 +131,12 @@ where let bytes = func_name_bytes(proc); let func_name = FuncName(&bytes); - eprintln!("{:?}: {:?}", proc.name, bytes_as_ascii(&bytes)); + eprintln!( + "{:?}: {:?} with {:?} args", + proc.name, + bytes_as_ascii(&bytes), + proc.args.len() + ); m.add_func(func_name, spec)?; } @@ -298,7 +310,7 @@ fn stmt_spec( Join { id, parameters, - body: continuation, + body, remainder, } => { let mut type_ids = Vec::new(); @@ -314,27 +326,33 @@ fn stmt_spec( let (jpid, jp_argument) = builder.declare_continuation(block, jp_arg_type_id, ret_type_id)?; + // NOTE join point arguments can shadow variables from the outer scope + // the ordering of steps here is important + + // add this ID so both body and remainder can reference it + env.join_points.insert(*id, jpid); + + // first, with the current variable bindings, process the remainder + let cont_block = builder.add_block(); + let cont_value_id = stmt_spec(builder, env, cont_block, layout, remainder)?; + + // only then introduce variables bound by the jump point, and process its body let join_body_sub_block = { - env.join_points.insert(*id, jpid); let jp_body_block = builder.add_block(); // unpack the argument for (i, p) in parameters.iter().enumerate() { let value_id = builder.add_get_tuple_field(jp_body_block, jp_argument, i as u32)?; + env.symbols.insert(p.symbol, value_id); } - let jp_body_value_id = stmt_spec(builder, env, jp_body_block, layout, remainder)?; + let jp_body_value_id = stmt_spec(builder, env, jp_body_block, layout, body)?; + BlockExpr(jp_body_block, jp_body_value_id) }; - // NOTE the symbols bound by the join point can shadow the argument symbols of the - // surrounding function, so we don't remove them from the env here - - let cont_block = builder.add_block(); - let cont_value_id = stmt_spec(builder, env, cont_block, layout, continuation)?; - env.join_points.remove(id); builder.define_continuation(jpid, join_body_sub_block)?; @@ -474,15 +492,77 @@ fn call_spec( DictWalk => { let dict = env.symbols[&call.arguments[0]]; let default = env.symbols[&call.arguments[1]]; + let closure_env = env.symbols[&call.arguments[3]]; let bag = builder.add_get_tuple_field(block, dict, DICT_BAG_INDEX)?; let _cell = builder.add_get_tuple_field(block, dict, DICT_CELL_INDEX)?; let first = builder.add_bag_get(block, bag)?; - let argument = builder.add_make_tuple(block, &[first, default])?; + let key = builder.add_get_tuple_field(block, first, 0)?; + let val = builder.add_get_tuple_field(block, first, 1)?; + + let argument = + builder.add_make_tuple(block, &[key, val, default, closure_env])?; builder.add_call(block, spec_var, module, name, argument)?; } + + ListMapWithIndex => { + let list = env.symbols[&call.arguments[0]]; + + let bag = builder.add_get_tuple_field(block, list, LIST_BAG_INDEX)?; + let _cell = builder.add_get_tuple_field(block, list, LIST_CELL_INDEX)?; + + let first = builder.add_bag_get(block, bag)?; + let index = builder.add_make_tuple(block, &[])?; + + let argument = builder.add_make_tuple(block, &[first, index])?; + builder.add_call(block, spec_var, module, name, argument)?; + } + + ListMap => { + let list1 = env.symbols[&call.arguments[0]]; + + let bag1 = builder.add_get_tuple_field(block, list1, LIST_BAG_INDEX)?; + let _cell1 = builder.add_get_tuple_field(block, list1, LIST_CELL_INDEX)?; + + let elem1 = builder.add_bag_get(block, bag1)?; + + let argument = builder.add_make_tuple(block, &[elem1])?; + builder.add_call(block, spec_var, module, name, argument)?; + } + + ListMap2 => { + let list1 = env.symbols[&call.arguments[0]]; + let list2 = env.symbols[&call.arguments[1]]; + + let bag1 = builder.add_get_tuple_field(block, list1, LIST_BAG_INDEX)?; + let _cell1 = builder.add_get_tuple_field(block, list1, LIST_CELL_INDEX)?; + let elem1 = builder.add_bag_get(block, bag1)?; + + let bag2 = builder.add_get_tuple_field(block, list2, LIST_BAG_INDEX)?; + let _cell2 = builder.add_get_tuple_field(block, list2, LIST_CELL_INDEX)?; + let elem2 = builder.add_bag_get(block, bag2)?; + + let argument = builder.add_make_tuple(block, &[elem1, elem2])?; + builder.add_call(block, spec_var, module, name, argument)?; + } + + ListKeepIf | ListKeepOks | ListKeepErrs => { + let list = env.symbols[&call.arguments[0]]; + let closure_env = env.symbols[&call.arguments[2]]; + + let bag = builder.add_get_tuple_field(block, list, LIST_BAG_INDEX)?; + // let _cell = builder.add_get_tuple_field(block, list, LIST_CELL_INDEX)?; + + let first = builder.add_bag_get(block, bag)?; + + let argument = builder.add_make_tuple(block, &[first, closure_env])?; + let result = builder.add_call(block, spec_var, module, name, argument)?; + let unit = builder.add_tuple_type(&[])?; + builder.add_unknown_with(block, &[result], unit)?; + } + _ => { // fake a call to the function argument // to make sure the function is specialized @@ -698,7 +778,10 @@ fn expr_spec( let result_type = layout_spec(builder, layout)?; builder.add_unknown_with(block, &[value_id], result_type) } else { - builder.add_get_tuple_field(block, value_id, *index as u32) + // what to do, what to do. + let result_type = layout_spec(builder, layout)?; + builder.add_unknown_with(block, &[value_id], result_type) + // builder.add_get_tuple_field(block, value_id, *index as u32) } } } @@ -843,8 +926,7 @@ fn builtin_spec(builder: &mut FuncDefBuilder, builtin: &Builtin) -> Result(builder: &mut TC) -> Result { let cell_id = builder.add_heap_cell_type(); - let len_id = builder.add_tuple_type(&[])?; - builder.add_tuple_type(&[cell_id, len_id]) + builder.add_tuple_type(&[cell_id]) } // const OK_TAG_ID: u8 = 1u8; From 9b9394b413bae66a570998aa72ea7fc0dda57c1c Mon Sep 17 00:00:00 2001 From: Folkert Date: Tue, 15 Jun 2021 21:28:13 +0200 Subject: [PATCH 237/496] make list literal return bag and cell --- compiler/mono/src/alias_analysis.rs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 3d73aec8a4..613577cfff 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -799,7 +799,9 @@ fn expr_spec( bag = builder.add_bag_insert(block, bag, value_id)?; } - Ok(bag) + let cell = builder.add_new_heap_cell(block)?; + + builder.add_make_tuple(block, &[cell, bag]) } EmptyArray => { From 3733d3035e3449dd4369905b9269ff8d776256ed Mon Sep 17 00:00:00 2001 From: rvcas Date: Tue, 15 Jun 2021 19:15:16 -0400 Subject: [PATCH 238/496] feat: new imports --- editor/src/lang/constrain.rs | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/editor/src/lang/constrain.rs b/editor/src/lang/constrain.rs index 37d5d07d09..571280d15e 100644 --- a/editor/src/lang/constrain.rs +++ b/editor/src/lang/constrain.rs @@ -1,19 +1,20 @@ use bumpalo::{collections::Vec as BumpVec, Bump}; use crate::lang::{ - ast::{Expr2, RecordField}, + ast::{Expr2, RecordField, WhenBranch}, expr::Env, + pattern::{DestructType, Pattern2, PatternState2, RecordDestruct}, pool::{Pool, PoolStr, PoolVec, ShallowClone}, types::{Type2, TypeId}, }; -use roc_can::expected::Expected; +use roc_can::expected::{Expected, PExpected}; use roc_collections::all::{BumpMap, BumpMapDefault, Index}; use roc_module::{ident::TagName, symbol::Symbol}; -use roc_region::all::{Located, Region}; +use roc_region::all::Region; use roc_types::{ subs::Variable, - types::{self, AnnotationSource}, + types::{self, AnnotationSource, PReason, PatternCategory}, types::{Category, Reason}, }; From 943047f2078eff5cde9250ce8c70dacbe131aa00 Mon Sep 17 00:00:00 2001 From: rvcas Date: Tue, 15 Jun 2021 19:17:01 -0400 Subject: [PATCH 239/496] feat: introduce Pattern constraint --- editor/src/lang/constrain.rs | 2 +- editor/src/lang/solve.rs | 80 ++++++++++++++++++------------------ 2 files changed, 42 insertions(+), 40 deletions(-) diff --git a/editor/src/lang/constrain.rs b/editor/src/lang/constrain.rs index 571280d15e..20a31c9446 100644 --- a/editor/src/lang/constrain.rs +++ b/editor/src/lang/constrain.rs @@ -23,7 +23,7 @@ pub enum Constraint<'a> { Eq(Type2, Expected, Category, Region), // Store(Type, Variable, &'static str, u32), Lookup(Symbol, Expected, Region), - // Pattern(Region, PatternCategory, Type, PExpected), + Pattern(Region, PatternCategory, Type2, PExpected), And(BumpVec<'a, Constraint<'a>>), Let(&'a LetConstraint<'a>), // SaveTheEnvironment, diff --git a/editor/src/lang/solve.rs b/editor/src/lang/solve.rs index 08d7f348cd..020b2627d6 100644 --- a/editor/src/lang/solve.rs +++ b/editor/src/lang/solve.rs @@ -363,45 +363,47 @@ fn solve<'a>( state } - // Pattern(region, category, typ, expectation) => { - // let actual = type_to_var(subs, rank, pools, cached_aliases, typ); - // let expected = type_to_var( - // subs, - // rank, - // pools, - // cached_aliases, - // expectation.get_type_ref(), - // ); - // - // match unify(subs, actual, expected) { - // Success(vars) => { - // introduce(subs, rank, pools, &vars); - // - // state - // } - // Failure(vars, actual_type, expected_type) => { - // introduce(subs, rank, pools, &vars); - // - // let problem = TypeError::BadPattern( - // *region, - // category.clone(), - // actual_type, - // expectation.clone().replace(expected_type), - // ); - // - // problems.push(problem); - // - // state - // } - // BadType(vars, problem) => { - // introduce(subs, rank, pools, &vars); - // - // problems.push(TypeError::BadType(problem)); - // - // state - // } - // } - // } + Pattern(region, category, typ, expectation) => { + let actual = type_to_var(arena, mempool, subs, rank, pools, cached_aliases, typ); + let expected = type_to_var( + arena, + mempool, + subs, + rank, + pools, + cached_aliases, + expectation.get_type_ref(), + ); + + match unify(subs, actual, expected) { + Success(vars) => { + introduce(subs, rank, pools, &vars); + + state + } + Failure(vars, actual_type, expected_type) => { + introduce(subs, rank, pools, &vars); + + let problem = TypeError::BadPattern( + *region, + category.clone(), + actual_type, + expectation.shallow_clone().replace(expected_type), + ); + + problems.push(problem); + + state + } + BadType(vars, problem) => { + introduce(subs, rank, pools, &vars); + + problems.push(TypeError::BadType(problem)); + + state + } + } + } Let(let_con) => { match &let_con.ret_constraint { True if let_con.rigid_vars.is_empty() => { From 4652d77e84f21c47df857395657851393f7d2b78 Mon Sep 17 00:00:00 2001 From: rvcas Date: Tue, 15 Jun 2021 19:18:25 -0400 Subject: [PATCH 240/496] feat: remove Located from Let constaints --- editor/src/lang/constrain.rs | 2 +- editor/src/lang/solve.rs | 25 +++++++++---------------- 2 files changed, 10 insertions(+), 17 deletions(-) diff --git a/editor/src/lang/constrain.rs b/editor/src/lang/constrain.rs index 20a31c9446..ddd4d5c32d 100644 --- a/editor/src/lang/constrain.rs +++ b/editor/src/lang/constrain.rs @@ -34,7 +34,7 @@ pub enum Constraint<'a> { pub struct LetConstraint<'a> { pub rigid_vars: BumpVec<'a, Variable>, pub flex_vars: BumpVec<'a, Variable>, - pub def_types: BumpMap>, + pub def_types: BumpMap, pub defs_constraint: Constraint<'a>, pub ret_constraint: Constraint<'a>, } diff --git a/editor/src/lang/solve.rs b/editor/src/lang/solve.rs index 020b2627d6..f248cc4999 100644 --- a/editor/src/lang/solve.rs +++ b/editor/src/lang/solve.rs @@ -441,22 +441,16 @@ fn solve<'a>( // Add a variable for each def to new_vars_by_env. let mut local_def_vars = BumpMap::new_in(arena); - for (symbol, loc_type) in let_con.def_types.iter() { - let var = type_to_var( - arena, - mempool, - subs, - rank, - pools, - cached_aliases, - &loc_type.value, - ); + for (symbol, typ) in let_con.def_types.iter() { + let var = + type_to_var(arena, mempool, subs, rank, pools, cached_aliases, typ); + // TODO: region should come from typ local_def_vars.insert( *symbol, Located { value: var, - region: loc_type.region, + region: Region::zero(), }, ); } @@ -523,9 +517,7 @@ fn solve<'a>( // Add a variable for each def to local_def_vars. let mut local_def_vars = BumpMap::new_in(arena); - for (symbol, loc_type) in let_con.def_types.iter() { - let def_type = &loc_type.value; - + for (symbol, typ) in let_con.def_types.iter() { let var = type_to_var( arena, mempool, @@ -533,14 +525,15 @@ fn solve<'a>( next_rank, next_pools, cached_aliases, - def_type, + typ, ); + // TODO: region should come from type local_def_vars.insert( *symbol, Located { value: var, - region: loc_type.region, + region: Region::zero(), }, ); } From 05181e4be05d33e00155df777ce0ea588b4735e0 Mon Sep 17 00:00:00 2001 From: rvcas Date: Tue, 15 Jun 2021 19:19:11 -0400 Subject: [PATCH 241/496] feat: create PatternState2 --- editor/src/lang/pattern.rs | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/editor/src/lang/pattern.rs b/editor/src/lang/pattern.rs index e3f6dc8160..9e800774cf 100644 --- a/editor/src/lang/pattern.rs +++ b/editor/src/lang/pattern.rs @@ -5,8 +5,10 @@ use crate::lang::ast::{ExprId, FloatVal, IntVal}; use crate::lang::expr::{to_expr_id, Env, Output}; use crate::lang::pool::{NodeId, Pool, PoolStr, PoolVec, ShallowClone}; use crate::lang::scope::Scope; +use bumpalo::collections::Vec as BumpVec; use roc_can::expr::unescape_char; use roc_can::num::{finish_parsing_base, finish_parsing_float, finish_parsing_int}; +use roc_collections::all::BumpMap; use roc_module::symbol::Symbol; use roc_parse::ast::{StrLiteral, StrSegment}; use roc_parse::pattern::PatternType; @@ -14,6 +16,9 @@ use roc_problem::can::{MalformedPatternProblem, Problem, RuntimeError}; use roc_region::all::Region; use roc_types::subs::Variable; +use super::constrain::Constraint; +use super::types::Type2; + pub type PatternId = NodeId; #[derive(Debug)] @@ -61,6 +66,13 @@ impl ShallowClone for Pattern2 { } } +#[derive(Debug)] +pub struct PatternState2<'a> { + pub headers: BumpMap, + pub vars: BumpVec<'a, Variable>, + pub constraints: BumpVec<'a, Constraint<'a>>, +} + #[derive(Debug)] pub struct RecordDestruct { pub var: Variable, // 4B From 22dc0fe6c74e29cc878025979896616ea70b9aec Mon Sep 17 00:00:00 2001 From: rvcas Date: Tue, 15 Jun 2021 19:20:15 -0400 Subject: [PATCH 242/496] feat: implement shallow clone for PExpected --- editor/src/lang/pool.rs | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/editor/src/lang/pool.rs b/editor/src/lang/pool.rs index 975d2b2655..1d77814b46 100644 --- a/editor/src/lang/pool.rs +++ b/editor/src/lang/pool.rs @@ -12,6 +12,7 @@ /// This is important for performance. use libc::{c_void, MAP_ANONYMOUS, MAP_PRIVATE, PROT_READ, PROT_WRITE}; use roc_can::expected::Expected; +use roc_can::expected::PExpected; use std::cmp::Ordering; use std::marker::PhantomData; use std::mem::size_of; @@ -620,3 +621,14 @@ impl ShallowClone for Expected { } } } + +impl ShallowClone for PExpected { + fn shallow_clone(&self) -> Self { + use PExpected::*; + + match self { + NoExpectation(t) => NoExpectation(t.shallow_clone()), + ForReason(reason, t, region) => ForReason(reason.clone(), t.shallow_clone(), *region), + } + } +} From e300acf2a8a906b12d86a32d5ebdce79b3a853b6 Mon Sep 17 00:00:00 2001 From: rvcas Date: Tue, 15 Jun 2021 19:20:59 -0400 Subject: [PATCH 243/496] feat: implement When constraints --- editor/src/lang/constrain.rs | 448 ++++++++++++++++++++++++++++++++++- 1 file changed, 447 insertions(+), 1 deletion(-) diff --git a/editor/src/lang/constrain.rs b/editor/src/lang/constrain.rs index ddd4d5c32d..52654a1d20 100644 --- a/editor/src/lang/constrain.rs +++ b/editor/src/lang/constrain.rs @@ -631,6 +631,129 @@ pub fn constrain_expr<'a>( } } } + Expr2::When { + cond_var, + expr_var, + cond: cond_id, + branches, + } => { + // Infer the condition expression's type. + let cond_type = Type2::Variable(*cond_var); + + let cond = env.pool.get(*cond_id); + + let expr_con = constrain_expr( + arena, + env, + cond, + Expected::NoExpectation(cond_type.shallow_clone()), + region, + ); + + let mut constraints = BumpVec::with_capacity_in(branches.len() + 1, arena); + + constraints.push(expr_con); + + let mut flex_vars = BumpVec::with_capacity_in(2, arena); + + flex_vars.push(*cond_var); + flex_vars.push(*expr_var); + + match &expected { + Expected::FromAnnotation(name, arity, _, _typ) => { + // NOTE deviation from elm. + // + // in elm, `_typ` is used, but because we have this `expr_var` too + // and need to constrain it, this is what works and gives better error messages + let typ = Type2::Variable(*expr_var); + + for (index, when_branch_id) in branches.iter_node_ids().enumerate() { + let when_branch = env.pool.get(when_branch_id); + + let pattern_region = region; + // let pattern_region = Region::across_all( + // when_branch.patterns.iter(env.pool).map(|v| &v.region), + // ); + + let branch_con = constrain_when_branch( + arena, + env, + // TODO: when_branch.value.region, + region, + when_branch, + PExpected::ForReason( + PReason::WhenMatch { + index: Index::zero_based(index), + }, + cond_type.shallow_clone(), + pattern_region, + ), + Expected::FromAnnotation( + name.clone(), + *arity, + AnnotationSource::TypedWhenBranch { + index: Index::zero_based(index), + }, + typ.shallow_clone(), + ), + ); + + constraints.push(branch_con); + } + + constraints.push(Eq(typ, expected, Category::When, region)); + + return exists(arena, flex_vars, And(constraints)); + } + + _ => { + let branch_type = Type2::Variable(*expr_var); + let mut branch_cons = BumpVec::with_capacity_in(branches.len(), arena); + + for (index, when_branch_id) in branches.iter_node_ids().enumerate() { + let when_branch = env.pool.get(when_branch_id); + + let pattern_region = region; + // let pattern_region = + // Region::across_all(when_branch.patterns.iter().map(|v| &v.region)); + + let branch_con = constrain_when_branch( + arena, + env, + region, + when_branch, + PExpected::ForReason( + PReason::WhenMatch { + index: Index::zero_based(index), + }, + cond_type.shallow_clone(), + pattern_region, + ), + Expected::ForReason( + Reason::WhenBranch { + index: Index::zero_based(index), + }, + branch_type.shallow_clone(), + // TODO: when_branch.value.region, + region, + ), + ); + + branch_cons.push(branch_con); + } + + let mut and_constraints = BumpVec::with_capacity_in(2, arena); + + and_constraints.push(And(branch_cons)); + and_constraints.push(Eq(branch_type, expected, Category::When, region)); + + constraints.push(And(and_constraints)); + } + } + + // exhautiveness checking happens when converting to mono::Expr + exists(arena, flex_vars, And(constraints)) + } _ => todo!("implement constraints for {:?}", expr), } } @@ -666,6 +789,329 @@ fn constrain_empty_record<'a>(expected: Expected, region: Region) -> Cons Constraint::Eq(Type2::EmptyRec, expected, Category::Record, region) } +#[inline(always)] +fn constrain_when_branch<'a>( + arena: &'a Bump, + env: &mut Env, + region: Region, + when_branch: &WhenBranch, + pattern_expected: PExpected, + expr_expected: Expected, +) -> Constraint<'a> { + let when_expr = env.pool.get(when_branch.body); + + let ret_constraint = constrain_expr(arena, env, when_expr, expr_expected, region); + + let mut state = PatternState2 { + headers: BumpMap::new_in(arena), + vars: BumpVec::with_capacity_in(1, arena), + constraints: BumpVec::with_capacity_in(1, arena), + }; + + // TODO investigate for error messages, is it better to unify all branches with a variable, + // then unify that variable with the expectation? + for pattern_id in when_branch.patterns.iter_node_ids() { + let pattern = env.pool.get(pattern_id); + + constrain_pattern( + arena, + env, + pattern, + // loc_pattern.region, + region, + pattern_expected.shallow_clone(), + &mut state, + ); + } + + if let Some(guard_id) = &when_branch.guard { + let guard = env.pool.get(*guard_id); + + let guard_constraint = constrain_expr( + arena, + env, + guard, + Expected::ForReason( + Reason::WhenGuard, + Type2::Variable(Variable::BOOL), + // TODO: loc_guard.region, + region, + ), + region, + ); + + // must introduce the headers from the pattern before constraining the guard + Constraint::Let(arena.alloc(LetConstraint { + rigid_vars: BumpVec::new_in(arena), + flex_vars: state.vars, + def_types: state.headers, + defs_constraint: Constraint::And(state.constraints), + ret_constraint: Constraint::Let(arena.alloc(LetConstraint { + rigid_vars: BumpVec::new_in(arena), + flex_vars: BumpVec::new_in(arena), + def_types: BumpMap::new_in(arena), + defs_constraint: guard_constraint, + ret_constraint, + })), + })) + } else { + Constraint::Let(arena.alloc(LetConstraint { + rigid_vars: BumpVec::new_in(arena), + flex_vars: state.vars, + def_types: state.headers, + defs_constraint: Constraint::And(state.constraints), + ret_constraint, + })) + } +} + +/// This accepts PatternState (rather than returning it) so that the caller can +/// intiialize the Vecs in PatternState using with_capacity +/// based on its knowledge of their lengths. +pub fn constrain_pattern<'a>( + arena: &'a Bump, + env: &mut Env, + pattern: &Pattern2, + region: Region, + expected: PExpected, + state: &mut PatternState2<'a>, +) { + use Pattern2::*; + + match pattern { + Underscore | UnsupportedPattern(_) | MalformedPattern(_, _) | Shadowed { .. } => { + // Neither the _ pattern nor erroneous ones add any constraints. + } + + Identifier(symbol) => { + state.headers.insert(*symbol, expected.get_type()); + } + + NumLiteral(var, _) => { + state.vars.push(*var); + + let type_id = env.pool.add(Type2::Variable(*var)); + + state.constraints.push(Constraint::Pattern( + region, + PatternCategory::Num, + num_num(env.pool, type_id), + expected, + )); + } + + IntLiteral(_int_val) => { + let precision_var = env.var_store.fresh(); + + let range = env.add(Type2::Variable(precision_var), region); + + state.constraints.push(Constraint::Pattern( + region, + PatternCategory::Int, + num_int(env.pool, range), + expected, + )); + } + + FloatLiteral(_float_val) => { + let precision_var = env.var_store.fresh(); + + let range = env.add(Type2::Variable(precision_var), region); + + state.constraints.push(Constraint::Pattern( + region, + PatternCategory::Float, + num_float(env.pool, range), + expected, + )); + } + + StrLiteral(_) => { + state.constraints.push(Constraint::Pattern( + region, + PatternCategory::Str, + str_type(env.pool), + expected, + )); + } + + RecordDestructure { + whole_var, + ext_var, + destructs, + } => { + state.vars.push(*whole_var); + state.vars.push(*ext_var); + let ext_type = Type2::Variable(*ext_var); + + let mut field_types = Vec::new(); + + for destruct_id in destructs.iter_node_ids() { + let RecordDestruct { + var, + label, + symbol, + typ, + } = env.pool.get(destruct_id); + + let pat_type = Type2::Variable(*var); + let expected = PExpected::NoExpectation(pat_type.shallow_clone()); + + if !state.headers.contains_key(&symbol) { + state.headers.insert(*symbol, pat_type.shallow_clone()); + } + + let destruct_type = env.pool.get(*typ); + + let field_type = match destruct_type { + DestructType::Guard(guard_var, guard_id) => { + state.constraints.push(Constraint::Pattern( + region, + PatternCategory::PatternGuard, + Type2::Variable(*guard_var), + PExpected::ForReason( + PReason::PatternGuard, + pat_type.shallow_clone(), + // TODO: region should be from guard_id + region, + ), + )); + + state.vars.push(*guard_var); + + let guard = env.pool.get(*guard_id); + + // TODO: region should be from guard_id + constrain_pattern(arena, env, guard, region, expected, state); + + types::RecordField::Demanded(env.pool.add(pat_type)) + } + DestructType::Optional(expr_var, expr_id) => { + state.constraints.push(Constraint::Pattern( + region, + PatternCategory::PatternDefault, + Type2::Variable(*expr_var), + PExpected::ForReason( + PReason::OptionalField, + pat_type.shallow_clone(), + // TODO: region should be from expr_id + region, + ), + )); + + state.vars.push(*expr_var); + + let expr_expected = Expected::ForReason( + Reason::RecordDefaultField(label.as_str(env.pool).into()), + pat_type.shallow_clone(), + // TODO: region should be from expr_id + region, + ); + + let expr = env.pool.get(*expr_id); + + // TODO: region should be from expr_id + let expr_con = constrain_expr(arena, env, expr, expr_expected, region); + + state.constraints.push(expr_con); + + types::RecordField::Optional(env.pool.add(pat_type)) + } + DestructType::Required => { + // No extra constraints necessary. + types::RecordField::Demanded(env.pool.add(pat_type)) + } + }; + + field_types.push((label.clone(), field_type)); + + state.vars.push(*var); + } + + let record_type = Type2::Record( + PoolVec::new(field_types.into_iter(), env.pool), + env.pool.add(ext_type), + ); + + let whole_con = Constraint::Eq( + Type2::Variable(*whole_var), + Expected::NoExpectation(record_type), + Category::Storage(std::file!(), std::line!()), + region, + ); + + let record_con = Constraint::Pattern( + region, + PatternCategory::Record, + Type2::Variable(*whole_var), + expected, + ); + + state.constraints.push(whole_con); + state.constraints.push(record_con); + } + GlobalTag { + whole_var, + ext_var, + tag_name, + arguments, + } => { + let mut argument_types = Vec::with_capacity(arguments.len()); + + for (index, arg_id) in arguments.iter_node_ids().enumerate() { + let (pattern_var, pattern) = env.pool.get(arg_id); + + state.vars.push(*pattern_var); + + let pattern_type = Type2::Variable(*pattern_var); + argument_types.push(pattern_type.shallow_clone()); + + let expected = PExpected::ForReason( + PReason::TagArg { + tag_name: TagName::Global(tag_name.as_str(env.pool).into()), + index: Index::zero_based(index), + }, + pattern_type, + region, + ); + + // TODO region should come from pattern + constrain_pattern(arena, env, pattern, region, expected, state); + } + + let whole_con = Constraint::Eq( + Type2::Variable(*whole_var), + Expected::NoExpectation(Type2::TagUnion( + PoolVec::new( + vec![( + *tag_name, + PoolVec::new(argument_types.into_iter(), env.pool), + )] + .into_iter(), + env.pool, + ), + env.pool.add(Type2::Variable(*ext_var)), + )), + Category::Storage(std::file!(), std::line!()), + region, + ); + + let tag_con = Constraint::Pattern( + region, + PatternCategory::Ctor(TagName::Global(tag_name.as_str(env.pool).into())), + Type2::Variable(*whole_var), + expected, + ); + + state.vars.push(*whole_var); + state.vars.push(*ext_var); + state.constraints.push(whole_con); + state.constraints.push(tag_con); + } + PrivateTag { .. } => todo!(), + } +} + #[inline(always)] fn builtin_type(symbol: Symbol, args: PoolVec) -> Type2 { Type2::Apply(symbol, args) @@ -726,7 +1172,7 @@ fn num_floatingpoint(pool: &mut Pool, range: TypeId) -> Type2 { } #[inline(always)] -fn _num_int(pool: &mut Pool, range: TypeId) -> Type2 { +fn num_int(pool: &mut Pool, range: TypeId) -> Type2 { let num_integer_type = _num_integer(pool, range); let num_integer_id = pool.add(num_integer_type); From b84fc8575343d32d508da450aa763d4bfd004c59 Mon Sep 17 00:00:00 2001 From: rvcas Date: Tue, 15 Jun 2021 19:21:20 -0400 Subject: [PATCH 244/496] test: new test for when constraints --- editor/tests/solve_expr2.rs | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/editor/tests/solve_expr2.rs b/editor/tests/solve_expr2.rs index 699f5fa3a7..374afd6590 100644 --- a/editor/tests/solve_expr2.rs +++ b/editor/tests/solve_expr2.rs @@ -286,3 +286,17 @@ fn constrain_if() { "[ Green, Red ]*", ) } + +#[test] +fn constrain_when() { + infer_eq( + indoc!( + r#" + when if True then Green else Red is + Green -> Blue + Red -> Purple + "# + ), + "[ Blue, Purple ]*", + ) +} From cc96dd0a7652b7f5c5a6897c1c1f4d7767f2ee39 Mon Sep 17 00:00:00 2001 From: rvcas Date: Tue, 15 Jun 2021 19:33:51 -0400 Subject: [PATCH 245/496] chore: how did this get past me locally --- editor/src/lang/constrain.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/editor/src/lang/constrain.rs b/editor/src/lang/constrain.rs index 52654a1d20..80dbcc5a06 100644 --- a/editor/src/lang/constrain.rs +++ b/editor/src/lang/constrain.rs @@ -1023,7 +1023,7 @@ pub fn constrain_pattern<'a>( } }; - field_types.push((label.clone(), field_type)); + field_types.push((*label, field_type)); state.vars.push(*var); } From 9716096999bfb033de2f402d3e045f7f2da559c4 Mon Sep 17 00:00:00 2001 From: rvcas Date: Tue, 15 Jun 2021 19:34:15 -0400 Subject: [PATCH 246/496] test: cleanup some warnings --- compiler/solve/tests/solve_expr.rs | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/compiler/solve/tests/solve_expr.rs b/compiler/solve/tests/solve_expr.rs index fcafde91af..fe3f3322eb 100644 --- a/compiler/solve/tests/solve_expr.rs +++ b/compiler/solve/tests/solve_expr.rs @@ -118,14 +118,11 @@ mod solve_expr { subs.get(variable).content }; - let actual_str = content_to_string(content, &mut subs, home, &interns); + let actual_str = content_to_string(content, &subs, home, &interns); // Disregard UnusedDef problems, because those are unavoidable when // returning a function from the test expression. - can_problems.retain(|prob| match prob { - roc_problem::can::Problem::UnusedDef(_, _) => false, - _ => true, - }); + can_problems.retain(|prob| !matches!(prob, roc_problem::can::Problem::UnusedDef(_, _))); Ok((type_problems, can_problems, actual_str)) } From 1d9320ba8f7736267608e61ebc080bdcdc2c567a Mon Sep 17 00:00:00 2001 From: rvcas Date: Tue, 15 Jun 2021 21:32:39 -0400 Subject: [PATCH 247/496] fix: Pattern2 * make Pattern2 fit in 32 by commenting out two fields in Shadowed * make Global/Private Tag arguments field smaller by using PatternId --- editor/src/lang/constrain.rs | 3 ++- editor/src/lang/pattern.rs | 35 ++++++++++++++++++++--------------- 2 files changed, 22 insertions(+), 16 deletions(-) diff --git a/editor/src/lang/constrain.rs b/editor/src/lang/constrain.rs index 80dbcc5a06..106eea2f1f 100644 --- a/editor/src/lang/constrain.rs +++ b/editor/src/lang/constrain.rs @@ -1059,7 +1059,8 @@ pub fn constrain_pattern<'a>( let mut argument_types = Vec::with_capacity(arguments.len()); for (index, arg_id) in arguments.iter_node_ids().enumerate() { - let (pattern_var, pattern) = env.pool.get(arg_id); + let (pattern_var, pattern_id) = env.pool.get(arg_id); + let pattern = env.pool.get(*pattern_id); state.vars.push(*pattern_var); diff --git a/editor/src/lang/pattern.rs b/editor/src/lang/pattern.rs index 9e800774cf..03ed3c821f 100644 --- a/editor/src/lang/pattern.rs +++ b/editor/src/lang/pattern.rs @@ -30,16 +30,16 @@ pub enum Pattern2 { StrLiteral(PoolStr), // 8B Underscore, // 0B GlobalTag { - whole_var: Variable, // 4B - ext_var: Variable, // 4B - tag_name: PoolStr, // 8B - arguments: PoolVec<(Variable, Pattern2)>, // 8B + whole_var: Variable, // 4B + ext_var: Variable, // 4B + tag_name: PoolStr, // 8B + arguments: PoolVec<(Variable, PatternId)>, // 8B }, PrivateTag { - whole_var: Variable, // 4B - ext_var: Variable, // 4B - tag_name: Symbol, // 8B - arguments: PoolVec<(Variable, Pattern2)>, // 8B + whole_var: Variable, // 4B + ext_var: Variable, // 4B + tag_name: Symbol, // 8B + arguments: PoolVec<(Variable, PatternId)>, // 8B }, RecordDestructure { whole_var: Variable, // 4B @@ -48,10 +48,13 @@ pub enum Pattern2 { }, // Runtime Exceptions + // TODO: figure out how to better handle regions + // to keep this member under 32. With 2 Regions + // it ends up at size 40 Shadowed { shadowed_ident: PoolStr, - definition: Region, - shadowed_at: Region, + // definition: Region, + // shadowed_at: Region, }, /// Example: (5 = 1 + 2) is an unsupported pattern in an assignment; Int patterns aren't allowed in assignments! @@ -152,8 +155,6 @@ pub fn to_pattern2<'a>( Pattern2::Shadowed { shadowed_ident: PoolStr::new(name, env.pool), - shadowed_at: region, - definition: original_region, } } }, @@ -250,7 +251,9 @@ pub fn to_pattern2<'a>( output.union(new_output); - env.pool[node_id] = (env.var_store.fresh(), can_pattern); + let can_pattern_id = env.pool.add(can_pattern); + + env.pool[node_id] = (env.var_store.fresh(), can_pattern_id); } match tag.value { @@ -446,7 +449,8 @@ pub fn symbols_from_pattern(pool: &Pool, initial: &Pattern2) -> Vec { } GlobalTag { arguments, .. } | PrivateTag { arguments, .. } => { - for (_, pat) in arguments.iter(pool) { + for (_, pat_id) in arguments.iter(pool) { + let pat = pool.get(*pat_id); stack.push(pat); } } @@ -494,7 +498,8 @@ pub fn symbols_and_variables_from_pattern( } GlobalTag { arguments, .. } | PrivateTag { arguments, .. } => { - for (var, pat) in arguments.iter(pool) { + for (var, pat_id) in arguments.iter(pool) { + let pat = pool.get(*pat_id); stack.push((*var, pat)); } } From 19d8c41e98d4c37abd02abc8b95a2360e7c70c95 Mon Sep 17 00:00:00 2001 From: Jared Ramirez Date: Tue, 15 Jun 2021 19:09:21 -0700 Subject: [PATCH 248/496] Use dev version of llvm in nix --- shell.nix | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/shell.nix b/shell.nix index 43dee8500f..878ea9ce69 100644 --- a/shell.nix +++ b/shell.nix @@ -9,7 +9,7 @@ let # name = "nixpkgs-2021-04-23"; url = "https://github.com/nixos/nixpkgs/"; ref = "refs/heads/nixpkgs-unstable"; - rev = "8d0340aee5caac3807c58ad7fa4ebdbbdd9134d6"; + rev = "51bb9f3e9ab6161a3bf7746e20b955712cef618b"; } ) {}; @@ -55,7 +55,7 @@ let cmake git python3 - llvmPkgs.llvm + llvmPkgs.llvm.dev llvmPkgs.clang pkg-config zig @@ -79,7 +79,7 @@ pkgs.mkShell buildInputs = inputs ++ darwinInputs ++ linuxInputs; # Additional Env vars - LLVM_SYS_120_PREFIX = "${llvmPkgs.llvm}"; + LLVM_SYS_120_PREFIX = "${llvmPkgs.llvm.dev}"; LD_LIBRARY_PATH = with pkgs; lib.makeLibraryPath From dd2ac10ab9ed9548acb8ffc879e522ea1f47fbbb Mon Sep 17 00:00:00 2001 From: Jared Ramirez Date: Tue, 15 Jun 2021 19:19:03 -0700 Subject: [PATCH 249/496] Add RocDec.sub --- .gitignore | 1 + compiler/builtins/bitcode/src/dec.zig | 23 +++++++++++++++++++++++ 2 files changed, 24 insertions(+) diff --git a/.gitignore b/.gitignore index 242dbec6f8..d0ccfa7943 100644 --- a/.gitignore +++ b/.gitignore @@ -14,6 +14,7 @@ vgcore.* #editors .idea/ .vscode/ +.ignore #files too big to track in git editor/benches/resources/100000_lines.roc diff --git a/compiler/builtins/bitcode/src/dec.zig b/compiler/builtins/bitcode/src/dec.zig index 1fdf363910..d194e3e333 100644 --- a/compiler/builtins/bitcode/src/dec.zig +++ b/compiler/builtins/bitcode/src/dec.zig @@ -213,6 +213,17 @@ pub const RocDec = struct { } } + pub fn sub(self: RocDec, other: RocDec) RocDec { + var answer: i128 = undefined; + const overflowed = @subWithOverflow(i128, self.num, other.num, &answer); + + if (!overflowed) { + return RocDec{ .num = answer }; + } else { + std.debug.panic("TODO runtime exception for overflow!", .{}); + } + } + pub fn mul(self: RocDec, other: RocDec) RocDec { const self_i128 = self.num; const other_i128 = other.num; @@ -652,6 +663,18 @@ test "add: 1" { try expectEqual(RocDec{ .num = 1 }, dec.add(.{ .num = 1 })); } +test "sub: 0" { + var dec: RocDec = .{ .num = 1 }; + + try expectEqual(RocDec{ .num = 1 }, dec.sub(.{ .num = 0 })); +} + +test "sub: 1" { + var dec: RocDec = .{ .num = 1 }; + + try expectEqual(RocDec{ .num = 0 }, dec.sub(.{ .num = 1 })); +} + test "mul: by 0" { var dec: RocDec = .{ .num = 0 }; From ee2a1d74edde9d31675bcb428e02032f38c9c00a Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 16 Jun 2021 22:05:30 +0200 Subject: [PATCH 250/496] fix usage of layout in Switch; always use outer layout --- compiler/mono/src/alias_analysis.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 613577cfff..5a06dd23cd 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -263,7 +263,7 @@ fn stmt_spec( cond_layout: _, branches, default_branch, - ret_layout, + ret_layout: _lies, } => { let mut cases = Vec::with_capacity(branches.len() + 1); @@ -274,7 +274,7 @@ fn stmt_spec( for branch in it { let block = builder.add_block(); - let value_id = stmt_spec(builder, env, block, ret_layout, branch)?; + let value_id = stmt_spec(builder, env, block, layout, branch)?; cases.push(BlockExpr(block, value_id)); } From b54033a2f51d77ff61a5c14396fec9344d4d8724 Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 16 Jun 2021 22:14:14 +0200 Subject: [PATCH 251/496] alias analysis fixes --- compiler/mono/src/alias_analysis.rs | 39 ++++++++++++++++++++++++----- 1 file changed, 33 insertions(+), 6 deletions(-) diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 5a06dd23cd..7b3f623c72 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -19,19 +19,22 @@ pub const STATIC_STR_NAME: ConstName = ConstName(&Symbol::STR_ALIAS_ANALYSIS_STA const ENTRY_POINT_NAME: &[u8] = b"mainForHost"; -pub fn func_name_bytes(proc: &Proc) -> [u8; 16] { +pub fn func_name_bytes(proc: &Proc) -> [u8; SIZE] { func_name_bytes_help(proc.name, proc.args.iter().map(|x| x.0), proc.ret_layout) } +const DEBUG: bool = false; +const SIZE: usize = if DEBUG { 50 } else { 16 }; + pub fn func_name_bytes_help<'a, I>( symbol: Symbol, argument_layouts: I, return_layout: Layout<'a>, -) -> [u8; 16] +) -> [u8; SIZE] where I: Iterator>, { - let mut name_bytes = [0u8; 16]; + let mut name_bytes = [0u8; SIZE]; use std::collections::hash_map::DefaultHasher; use std::hash::Hash; @@ -75,6 +78,12 @@ where *target = *source; } + if DEBUG { + for (i, c) in (format!("{:?}", symbol)).chars().take(25).enumerate() { + name_bytes[25 + i] = c as u8; + } + } + name_bytes } @@ -127,8 +136,6 @@ where // all other functions for proc in procs { - let spec = proc_spec(proc)?; - let bytes = func_name_bytes(proc); let func_name = FuncName(&bytes); eprintln!( @@ -138,6 +145,8 @@ where proc.args.len() ); + let spec = proc_spec(proc)?; + m.add_func(func_name, spec)?; } @@ -457,7 +466,7 @@ fn call_spec( ), HigherOrderLowLevel { specialization_id, - closure_layout: _, + closure_env_layout, op, arg_layouts, ret_layout, @@ -507,6 +516,24 @@ fn call_spec( builder.add_call(block, spec_var, module, name, argument)?; } + ListWalk | ListWalkBackwards | ListWalkUntil => { + let list = env.symbols[&call.arguments[0]]; + let default = env.symbols[&call.arguments[1]]; + let closure_env = env.symbols[&call.arguments[3]]; + + let bag = builder.add_get_tuple_field(block, list, LIST_BAG_INDEX)?; + let _cell = builder.add_get_tuple_field(block, list, LIST_CELL_INDEX)?; + + let first = builder.add_bag_get(block, bag)?; + + let argument = if closure_env_layout.is_none() { + builder.add_make_tuple(block, &[first, default])? + } else { + builder.add_make_tuple(block, &[first, default, closure_env])? + }; + builder.add_call(block, spec_var, module, name, argument)?; + } + ListMapWithIndex => { let list = env.symbols[&call.arguments[0]]; From cc98237a0acef6e60606c23a2f5bc705c565c6a1 Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 16 Jun 2021 22:15:55 +0200 Subject: [PATCH 252/496] closure_env_layout --- compiler/gen_llvm/src/llvm/build.rs | 14 +++++++++----- compiler/gen_llvm/src/llvm/build_list.rs | 20 ++++---------------- compiler/mono/src/borrow.rs | 19 ++++++++++++------- compiler/mono/src/inc_dec.rs | 18 ++++++++++-------- compiler/mono/src/ir.rs | 23 ++++++++++++++--------- compiler/mono/src/layout.rs | 8 ++++++++ 6 files changed, 57 insertions(+), 45 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 7a8d5dc2d1..6cd61689ea 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -830,9 +830,10 @@ pub fn build_exp_call<'a, 'ctx, 'env>( CallType::HigherOrderLowLevel { op, - closure_layout, function_owns_closure_data, specialization_id, + arg_layouts, + ret_layout, .. } => { let bytes = specialization_id.to_bytes(); @@ -846,8 +847,9 @@ pub fn build_exp_call<'a, 'ctx, 'env>( scope, layout, *op, - *closure_layout, func_spec, + arg_layouts, + ret_layout, *function_owns_closure_data, arguments, ) @@ -3815,8 +3817,9 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>( scope: &Scope<'a, 'ctx>, return_layout: &Layout<'a>, op: LowLevel, - function_layout: Layout<'a>, func_spec: FuncSpec, + argument_layouts: &[Layout<'a>], + result_layout: &Layout<'a>, function_owns_closure_data: bool, args: &[Symbol], ) -> BasicValueEnum<'ctx> { @@ -3828,6 +3831,7 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>( macro_rules! passed_function_at_index { ($index:expr) => {{ let function_symbol = args[$index]; + let function_layout = Layout::FunctionPointer(argument_layouts, return_layout); function_value_by_func_spec(env, func_spec, function_symbol, function_layout) }}; @@ -4095,7 +4099,7 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>( env, layout_ids, roc_function_call, - &function_layout, + result_layout, list, before_layout, after_layout, @@ -4139,7 +4143,7 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>( env, layout_ids, roc_function_call, - &function_layout, + result_layout, list, before_layout, after_layout, diff --git a/compiler/gen_llvm/src/llvm/build_list.rs b/compiler/gen_llvm/src/llvm/build_list.rs index cf2044a8d0..e3b9901a0e 100644 --- a/compiler/gen_llvm/src/llvm/build_list.rs +++ b/compiler/gen_llvm/src/llvm/build_list.rs @@ -601,18 +601,12 @@ pub fn list_keep_oks<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, layout_ids: &mut LayoutIds<'a>, roc_function_call: RocFunctionCall<'ctx>, - function_layout: &Layout<'a>, + // Layout of the `Result after *` + result_layout: &Layout<'a>, list: BasicValueEnum<'ctx>, before_layout: &Layout<'a>, after_layout: &Layout<'a>, ) -> BasicValueEnum<'ctx> { - // Layout of the `Result after *` - let result_layout = match function_layout { - Layout::FunctionPointer(_, ret) => ret, - Layout::Closure(_, _, ret) => ret, - _ => unreachable!("not a callable layout"), - }; - let dec_result_fn = build_dec_wrapper(env, layout_ids, result_layout); call_bitcode_fn( @@ -638,18 +632,12 @@ pub fn list_keep_errs<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, layout_ids: &mut LayoutIds<'a>, roc_function_call: RocFunctionCall<'ctx>, - function_layout: &Layout<'a>, + // Layout of the `Result * err` + result_layout: &Layout<'a>, list: BasicValueEnum<'ctx>, before_layout: &Layout<'a>, after_layout: &Layout<'a>, ) -> BasicValueEnum<'ctx> { - // Layout of the `Result after *` - let result_layout = match function_layout { - Layout::FunctionPointer(_, ret) => ret, - Layout::Closure(_, _, ret) => ret, - _ => unreachable!("not a callable layout"), - }; - let dec_result_fn = build_dec_wrapper(env, layout_ids, result_layout); call_bitcode_fn( diff --git a/compiler/mono/src/borrow.rs b/compiler/mono/src/borrow.rs index 682fa42e3f..b919afe510 100644 --- a/compiler/mono/src/borrow.rs +++ b/compiler/mono/src/borrow.rs @@ -393,15 +393,20 @@ impl<'a> BorrowInfState<'a> { } HigherOrderLowLevel { - op, closure_layout, .. + op, + arg_layouts, + ret_layout, + .. } => { use roc_module::low_level::LowLevel::*; debug_assert!(op.is_higher_order()); + let closure_layout = Layout::FunctionPointer(arg_layouts, ret_layout); + match op { ListMap | ListKeepIf | ListKeepOks | ListKeepErrs => { - match self.param_map.get_symbol(arguments[1], *closure_layout) { + match self.param_map.get_symbol(arguments[1], closure_layout) { Some(function_ps) => { // own the list if the function wants to own the element if !function_ps[0].borrow { @@ -417,7 +422,7 @@ impl<'a> BorrowInfState<'a> { } } ListMapWithIndex => { - match self.param_map.get_symbol(arguments[1], *closure_layout) { + match self.param_map.get_symbol(arguments[1], closure_layout) { Some(function_ps) => { // own the list if the function wants to own the element if !function_ps[1].borrow { @@ -432,7 +437,7 @@ impl<'a> BorrowInfState<'a> { None => unreachable!(), } } - ListMap2 => match self.param_map.get_symbol(arguments[2], *closure_layout) { + ListMap2 => match self.param_map.get_symbol(arguments[2], closure_layout) { Some(function_ps) => { // own the lists if the function wants to own the element if !function_ps[0].borrow { @@ -450,7 +455,7 @@ impl<'a> BorrowInfState<'a> { } None => unreachable!(), }, - ListMap3 => match self.param_map.get_symbol(arguments[3], *closure_layout) { + ListMap3 => match self.param_map.get_symbol(arguments[3], closure_layout) { Some(function_ps) => { // own the lists if the function wants to own the element if !function_ps[0].borrow { @@ -471,7 +476,7 @@ impl<'a> BorrowInfState<'a> { None => unreachable!(), }, ListSortWith => { - match self.param_map.get_symbol(arguments[1], *closure_layout) { + match self.param_map.get_symbol(arguments[1], closure_layout) { Some(function_ps) => { // always own the input list self.own_var(arguments[0]); @@ -485,7 +490,7 @@ impl<'a> BorrowInfState<'a> { } } ListWalk | ListWalkUntil | ListWalkBackwards | DictWalk => { - match self.param_map.get_symbol(arguments[2], *closure_layout) { + match self.param_map.get_symbol(arguments[2], closure_layout) { Some(function_ps) => { // own the data structure if the function wants to own the element if !function_ps[0].borrow { diff --git a/compiler/mono/src/inc_dec.rs b/compiler/mono/src/inc_dec.rs index a0907bee72..d2dcd32092 100644 --- a/compiler/mono/src/inc_dec.rs +++ b/compiler/mono/src/inc_dec.rs @@ -455,7 +455,7 @@ impl<'a> Context<'a> { HigherOrderLowLevel { op, - closure_layout, + closure_env_layout, specialization_id, arg_layouts, ret_layout, @@ -467,7 +467,7 @@ impl<'a> Context<'a> { call_type: if let Some(OWNED) = $borrows.map(|p| p.borrow) { HigherOrderLowLevel { op: *op, - closure_layout: *closure_layout, + closure_env_layout: *closure_env_layout, function_owns_closure_data: true, specialization_id: *specialization_id, arg_layouts, @@ -497,12 +497,14 @@ impl<'a> Context<'a> { const FUNCTION: bool = BORROWED; const CLOSURE_DATA: bool = BORROWED; + let function_layout = Layout::FunctionPointer(arg_layouts, ret_layout); + match op { roc_module::low_level::LowLevel::ListMap | roc_module::low_level::LowLevel::ListKeepIf | roc_module::low_level::LowLevel::ListKeepOks | roc_module::low_level::LowLevel::ListKeepErrs => { - match self.param_map.get_symbol(arguments[1], *closure_layout) { + match self.param_map.get_symbol(arguments[1], function_layout) { Some(function_ps) => { let borrows = [function_ps[0].borrow, FUNCTION, CLOSURE_DATA]; @@ -524,7 +526,7 @@ impl<'a> Context<'a> { } } roc_module::low_level::LowLevel::ListMapWithIndex => { - match self.param_map.get_symbol(arguments[1], *closure_layout) { + match self.param_map.get_symbol(arguments[1], function_layout) { Some(function_ps) => { let borrows = [function_ps[1].borrow, FUNCTION, CLOSURE_DATA]; @@ -545,7 +547,7 @@ impl<'a> Context<'a> { } } roc_module::low_level::LowLevel::ListMap2 => { - match self.param_map.get_symbol(arguments[2], *closure_layout) { + match self.param_map.get_symbol(arguments[2], function_layout) { Some(function_ps) => { let borrows = [ function_ps[0].borrow, @@ -572,7 +574,7 @@ impl<'a> Context<'a> { } } roc_module::low_level::LowLevel::ListMap3 => { - match self.param_map.get_symbol(arguments[3], *closure_layout) { + match self.param_map.get_symbol(arguments[3], function_layout) { Some(function_ps) => { let borrows = [ function_ps[0].borrow, @@ -601,7 +603,7 @@ impl<'a> Context<'a> { } } roc_module::low_level::LowLevel::ListSortWith => { - match self.param_map.get_symbol(arguments[1], *closure_layout) { + match self.param_map.get_symbol(arguments[1], function_layout) { Some(function_ps) => { let borrows = [OWNED, FUNCTION, CLOSURE_DATA]; @@ -623,7 +625,7 @@ impl<'a> Context<'a> { | roc_module::low_level::LowLevel::ListWalkUntil | roc_module::low_level::LowLevel::ListWalkBackwards | roc_module::low_level::LowLevel::DictWalk => { - match self.param_map.get_symbol(arguments[2], *closure_layout) { + match self.param_map.get_symbol(arguments[2], function_layout) { Some(function_ps) => { // borrow data structure based on first argument of the folded function // borrow the default based on second argument of the folded function diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index aec2d1106b..b7860da713 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -1152,7 +1152,7 @@ pub enum CallType<'a> { HigherOrderLowLevel { op: LowLevel, /// the layout of the closure argument, if any - closure_layout: Layout<'a>, + closure_env_layout: Option>, /// specialization id of the function argument specialization_id: CallSpecId, /// does the function need to own the closure data @@ -2724,10 +2724,10 @@ macro_rules! match_on_closure_argument { $env, lambda_set, $closure_data_symbol, - |top_level_function, closure_data, function_layout, specialization_id| self::Call { + |top_level_function, closure_data, closure_env_layout, specialization_id| self::Call { call_type: CallType::HigherOrderLowLevel { op: $op, - closure_layout: function_layout, + closure_env_layout, specialization_id, function_owns_closure_data: false, arg_layouts, @@ -7715,7 +7715,7 @@ fn lowlevel_match_on_lambda_set<'a, ToLowLevelCall>( hole: &'a Stmt<'a>, ) -> Stmt<'a> where - ToLowLevelCall: Fn(Symbol, Symbol, Layout<'a>, CallSpecId) -> Call<'a> + Copy, + ToLowLevelCall: Fn(Symbol, Symbol, Option>, CallSpecId) -> Call<'a> + Copy, { match lambda_set.runtime_representation() { Layout::Union(_) => { @@ -7727,6 +7727,7 @@ where closure_tag_id_symbol, Layout::Builtin(crate::layout::TAG_SIZE), closure_data_symbol, + lambda_set.is_represented(), to_lowlevel_call, function_layout, return_layout, @@ -7756,7 +7757,7 @@ where let call = to_lowlevel_call( function_symbol, closure_data_symbol, - function_layout, + lambda_set.is_represented(), call_spec_id, ); @@ -7771,6 +7772,7 @@ where closure_tag_id_symbol, Layout::Builtin(Builtin::Int1), closure_data_symbol, + lambda_set.is_represented(), to_lowlevel_call, function_layout, return_layout, @@ -7787,6 +7789,7 @@ where closure_tag_id_symbol, Layout::Builtin(Builtin::Int8), closure_data_symbol, + lambda_set.is_represented(), to_lowlevel_call, function_layout, return_layout, @@ -7805,6 +7808,7 @@ fn lowlevel_union_lambda_set_to_switch<'a, ToLowLevelCall>( closure_tag_id_symbol: Symbol, closure_tag_id_layout: Layout<'a>, closure_data_symbol: Symbol, + closure_env_layout: Option>, to_lowlevel_call: ToLowLevelCall, function_layout: Layout<'a>, return_layout: Layout<'a>, @@ -7812,7 +7816,7 @@ fn lowlevel_union_lambda_set_to_switch<'a, ToLowLevelCall>( hole: &'a Stmt<'a>, ) -> Stmt<'a> where - ToLowLevelCall: Fn(Symbol, Symbol, Layout<'a>, CallSpecId) -> Call<'a> + Copy, + ToLowLevelCall: Fn(Symbol, Symbol, Option>, CallSpecId) -> Call<'a> + Copy, { debug_assert!(!lambda_set.is_empty()); @@ -7829,7 +7833,7 @@ where let call = to_lowlevel_call( *function_symbol, closure_data_symbol, - function_layout, + closure_env_layout, call_spec_id, ); let stmt = build_call(env, call, assigned, return_layout, env.arena.alloc(hole)); @@ -8230,6 +8234,7 @@ fn lowlevel_enum_lambda_set_to_switch<'a, ToLowLevelCall>( closure_tag_id_symbol: Symbol, closure_tag_id_layout: Layout<'a>, closure_data_symbol: Symbol, + closure_env_layout: Option>, to_lowlevel_call: ToLowLevelCall, function_layout: Layout<'a>, return_layout: Layout<'a>, @@ -8237,7 +8242,7 @@ fn lowlevel_enum_lambda_set_to_switch<'a, ToLowLevelCall>( hole: &'a Stmt<'a>, ) -> Stmt<'a> where - ToLowLevelCall: Fn(Symbol, Symbol, Layout<'a>, CallSpecId) -> Call<'a> + Copy, + ToLowLevelCall: Fn(Symbol, Symbol, Option>, CallSpecId) -> Call<'a> + Copy, { debug_assert!(!lambda_set.is_empty()); @@ -8254,7 +8259,7 @@ where let call = to_lowlevel_call( *function_symbol, closure_data_symbol, - function_layout, + closure_env_layout, call_spec_id, ); let stmt = build_call( diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index 5a8a3f75e4..37c50d1623 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -143,6 +143,14 @@ impl<'a> LambdaSet<'a> { *self.representation } + pub fn is_represented(&self) -> Option> { + if let Layout::Struct(&[]) = self.representation { + None + } else { + Some(*self.representation) + } + } + pub fn layout_for_member(&self, function_symbol: Symbol) -> ClosureRepresentation<'a> { debug_assert!( self.set.iter().any(|(s, _)| *s == function_symbol), From 5ba378551cb37798e28317849b6e077254a6d44c Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 16 Jun 2021 23:09:40 +0200 Subject: [PATCH 253/496] deal with closure argument everywhere --- compiler/mono/src/alias_analysis.rs | 114 ++++++++++++++++++++++++---- 1 file changed, 99 insertions(+), 15 deletions(-) diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 7b3f623c72..116d0d224e 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -138,12 +138,15 @@ where for proc in procs { let bytes = func_name_bytes(proc); let func_name = FuncName(&bytes); - eprintln!( - "{:?}: {:?} with {:?} args", - proc.name, - bytes_as_ascii(&bytes), - proc.args.len() - ); + + if DEBUG { + eprintln!( + "{:?}: {:?} with {:?} args", + proc.name, + bytes_as_ascii(&bytes), + proc.args.len() + ); + } let spec = proc_spec(proc)?; @@ -163,7 +166,9 @@ where p.build()? }; - eprintln!("{}", program.to_source_string()); + if DEBUG { + eprintln!("{}", program.to_source_string()); + } morphic_lib::solve(program) } @@ -235,11 +240,25 @@ fn stmt_spec( use Stmt::*; match stmt { - Let(symbol, expr, expr_layout, continuation) => { + Let(symbol, expr, expr_layout, mut continuation) => { let value_id = expr_spec(builder, env, block, expr_layout, expr)?; env.symbols.insert(*symbol, value_id); + + let mut queue = vec![symbol]; + + while let Let(symbol, expr, expr_layout, c) = continuation { + let value_id = expr_spec(builder, env, block, expr_layout, expr)?; + env.symbols.insert(*symbol, value_id); + + queue.push(symbol); + continuation = c; + } + let result = stmt_spec(builder, env, block, layout, continuation)?; - env.symbols.remove(symbol); + + for symbol in queue { + env.symbols.remove(symbol); + } Ok(result) } @@ -511,8 +530,11 @@ fn call_spec( let key = builder.add_get_tuple_field(block, first, 0)?; let val = builder.add_get_tuple_field(block, first, 1)?; - let argument = - builder.add_make_tuple(block, &[key, val, default, closure_env])?; + let argument = if closure_env_layout.is_none() { + builder.add_make_tuple(block, &[key, val, default])? + } else { + builder.add_make_tuple(block, &[key, val, default, closure_env])? + }; builder.add_call(block, spec_var, module, name, argument)?; } @@ -536,6 +558,7 @@ fn call_spec( ListMapWithIndex => { let list = env.symbols[&call.arguments[0]]; + let closure_env = env.symbols[&call.arguments[2]]; let bag = builder.add_get_tuple_field(block, list, LIST_BAG_INDEX)?; let _cell = builder.add_get_tuple_field(block, list, LIST_CELL_INDEX)?; @@ -543,25 +566,52 @@ fn call_spec( let first = builder.add_bag_get(block, bag)?; let index = builder.add_make_tuple(block, &[])?; - let argument = builder.add_make_tuple(block, &[first, index])?; + let argument = if closure_env_layout.is_none() { + builder.add_make_tuple(block, &[first, index])? + } else { + builder.add_make_tuple(block, &[first, index, closure_env])? + }; builder.add_call(block, spec_var, module, name, argument)?; } ListMap => { let list1 = env.symbols[&call.arguments[0]]; + let closure_env = env.symbols[&call.arguments[2]]; let bag1 = builder.add_get_tuple_field(block, list1, LIST_BAG_INDEX)?; let _cell1 = builder.add_get_tuple_field(block, list1, LIST_CELL_INDEX)?; let elem1 = builder.add_bag_get(block, bag1)?; - let argument = builder.add_make_tuple(block, &[elem1])?; + let argument = if closure_env_layout.is_none() { + builder.add_make_tuple(block, &[elem1])? + } else { + builder.add_make_tuple(block, &[elem1, closure_env])? + }; + builder.add_call(block, spec_var, module, name, argument)?; + } + + ListSortWith => { + let list1 = env.symbols[&call.arguments[0]]; + let closure_env = env.symbols[&call.arguments[2]]; + + let bag1 = builder.add_get_tuple_field(block, list1, LIST_BAG_INDEX)?; + let _cell1 = builder.add_get_tuple_field(block, list1, LIST_CELL_INDEX)?; + + let elem1 = builder.add_bag_get(block, bag1)?; + + let argument = if closure_env_layout.is_none() { + builder.add_make_tuple(block, &[elem1, elem1])? + } else { + builder.add_make_tuple(block, &[elem1, elem1, closure_env])? + }; builder.add_call(block, spec_var, module, name, argument)?; } ListMap2 => { let list1 = env.symbols[&call.arguments[0]]; let list2 = env.symbols[&call.arguments[1]]; + let closure_env = env.symbols[&call.arguments[3]]; let bag1 = builder.add_get_tuple_field(block, list1, LIST_BAG_INDEX)?; let _cell1 = builder.add_get_tuple_field(block, list1, LIST_CELL_INDEX)?; @@ -571,7 +621,37 @@ fn call_spec( let _cell2 = builder.add_get_tuple_field(block, list2, LIST_CELL_INDEX)?; let elem2 = builder.add_bag_get(block, bag2)?; - let argument = builder.add_make_tuple(block, &[elem1, elem2])?; + let argument = if closure_env_layout.is_none() { + builder.add_make_tuple(block, &[elem1, elem2])? + } else { + builder.add_make_tuple(block, &[elem1, elem2, closure_env])? + }; + builder.add_call(block, spec_var, module, name, argument)?; + } + + ListMap3 => { + let list1 = env.symbols[&call.arguments[0]]; + let list2 = env.symbols[&call.arguments[1]]; + let list3 = env.symbols[&call.arguments[2]]; + let closure_env = env.symbols[&call.arguments[4]]; + + let bag1 = builder.add_get_tuple_field(block, list1, LIST_BAG_INDEX)?; + let _cell1 = builder.add_get_tuple_field(block, list1, LIST_CELL_INDEX)?; + let elem1 = builder.add_bag_get(block, bag1)?; + + let bag2 = builder.add_get_tuple_field(block, list2, LIST_BAG_INDEX)?; + let _cell2 = builder.add_get_tuple_field(block, list2, LIST_CELL_INDEX)?; + let elem2 = builder.add_bag_get(block, bag2)?; + + let bag3 = builder.add_get_tuple_field(block, list3, LIST_BAG_INDEX)?; + let _cell3 = builder.add_get_tuple_field(block, list3, LIST_CELL_INDEX)?; + let elem3 = builder.add_bag_get(block, bag3)?; + + let argument = if closure_env_layout.is_none() { + builder.add_make_tuple(block, &[elem1, elem2, elem3])? + } else { + builder.add_make_tuple(block, &[elem1, elem2, elem3, closure_env])? + }; builder.add_call(block, spec_var, module, name, argument)?; } @@ -584,7 +664,11 @@ fn call_spec( let first = builder.add_bag_get(block, bag)?; - let argument = builder.add_make_tuple(block, &[first, closure_env])?; + let argument = if closure_env_layout.is_none() { + builder.add_make_tuple(block, &[first])? + } else { + builder.add_make_tuple(block, &[first, closure_env])? + }; let result = builder.add_call(block, spec_var, module, name, argument)?; let unit = builder.add_tuple_type(&[])?; builder.add_unknown_with(block, &[result], unit)?; From a1231058da898e3f5a809b625df7f7a4328ef96f Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 16 Jun 2021 23:09:58 +0200 Subject: [PATCH 254/496] store is_recursive info for unwrapped tags --- compiler/mono/src/ir.rs | 19 ++++++++---------- compiler/mono/src/layout.rs | 26 ++++++++++++++++++++----- compiler/test_gen/src/gen_primitives.rs | 1 + 3 files changed, 30 insertions(+), 16 deletions(-) diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index b7860da713..c3abe37f61 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -2713,8 +2713,6 @@ macro_rules! match_on_closure_argument { let arena = $env.arena; - let function_layout = arena.alloc(top_level).full(); - let arg_layouts = top_level.arguments; let ret_layout = top_level.result; @@ -2735,7 +2733,6 @@ macro_rules! match_on_closure_argument { }, arguments: arena.alloc([$($x,)* top_level_function, closure_data]), }, - function_layout, $layout, $assigned, $hole, @@ -4276,7 +4273,10 @@ fn convert_tag_union<'a>( ) } - Unwrapped(_, field_layouts) => { + Unwrapped { + arguments: field_layouts, + .. + } => { let field_symbols_temp = sorted_field_symbols(env, procs, layout_cache, args); let mut field_symbols = Vec::with_capacity_in(field_layouts.len(), env.arena); @@ -7014,7 +7014,10 @@ fn from_can_pattern_help<'a>( union, } } - Unwrapped(_, field_layouts) => { + Unwrapped { + arguments: field_layouts, + .. + } => { let union = crate::exhaustive::Union { render_as: RenderAs::Tag, alternatives: vec![Ctor { @@ -7709,7 +7712,6 @@ fn lowlevel_match_on_lambda_set<'a, ToLowLevelCall>( lambda_set: LambdaSet<'a>, closure_data_symbol: Symbol, to_lowlevel_call: ToLowLevelCall, - function_layout: Layout<'a>, return_layout: Layout<'a>, assigned: Symbol, hole: &'a Stmt<'a>, @@ -7729,7 +7731,6 @@ where closure_data_symbol, lambda_set.is_represented(), to_lowlevel_call, - function_layout, return_layout, assigned, hole, @@ -7774,7 +7775,6 @@ where closure_data_symbol, lambda_set.is_represented(), to_lowlevel_call, - function_layout, return_layout, assigned, hole, @@ -7791,7 +7791,6 @@ where closure_data_symbol, lambda_set.is_represented(), to_lowlevel_call, - function_layout, return_layout, assigned, hole, @@ -7810,7 +7809,6 @@ fn lowlevel_union_lambda_set_to_switch<'a, ToLowLevelCall>( closure_data_symbol: Symbol, closure_env_layout: Option>, to_lowlevel_call: ToLowLevelCall, - function_layout: Layout<'a>, return_layout: Layout<'a>, assigned: Symbol, hole: &'a Stmt<'a>, @@ -8236,7 +8234,6 @@ fn lowlevel_enum_lambda_set_to_switch<'a, ToLowLevelCall>( closure_data_symbol: Symbol, closure_env_layout: Option>, to_lowlevel_call: ToLowLevelCall, - function_layout: Layout<'a>, return_layout: Layout<'a>, assigned: Symbol, hole: &'a Stmt<'a>, diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index 37c50d1623..57ebf7f0ff 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -289,7 +289,9 @@ impl<'a> LambdaSet<'a> { Unit | UnitWithArguments => Layout::Struct(&[]), BoolUnion { .. } => Layout::Builtin(Builtin::Int1), ByteUnion(_) => Layout::Builtin(Builtin::Int8), - Unwrapped(_tag_name, layouts) => Layout::Struct(layouts.into_bump_slice()), + Unwrapped { + arguments: layouts, .. + } => Layout::Struct(layouts.into_bump_slice()), Wrapped(variant) => { use WrappedVariant::*; @@ -1274,9 +1276,16 @@ pub enum UnionVariant<'a> { Never, Unit, UnitWithArguments, - BoolUnion { ttrue: TagName, ffalse: TagName }, + BoolUnion { + ttrue: TagName, + ffalse: TagName, + }, ByteUnion(Vec<'a, TagName>), - Unwrapped(TagName, Vec<'a, Layout<'a>>), + Unwrapped { + tag_name: TagName, + arguments: Vec<'a, Layout<'a>>, + is_recursive: bool, + }, Wrapped(WrappedVariant<'a>), } @@ -1494,7 +1503,11 @@ pub fn union_sorted_tags_help<'a>( fields: layouts.into_bump_slice(), }) } else { - UnionVariant::Unwrapped(tag_name, layouts) + UnionVariant::Unwrapped { + tag_name, + arguments: layouts, + is_recursive: opt_rec_var.is_some(), + } } } num_tags => { @@ -1646,7 +1659,10 @@ pub fn layout_from_tag_union<'a>( Unit | UnitWithArguments => Layout::Struct(&[]), BoolUnion { .. } => Layout::Builtin(Builtin::Int1), ByteUnion(_) => Layout::Builtin(Builtin::Int8), - Unwrapped(_, mut field_layouts) => { + Unwrapped { + arguments: mut field_layouts, + .. + } => { if field_layouts.len() == 1 { field_layouts.pop().unwrap() } else { diff --git a/compiler/test_gen/src/gen_primitives.rs b/compiler/test_gen/src/gen_primitives.rs index 0fd75bf227..8661bb4164 100644 --- a/compiler/test_gen/src/gen_primitives.rs +++ b/compiler/test_gen/src/gen_primitives.rs @@ -1997,6 +1997,7 @@ fn case_or_pattern() { } #[test] +#[ignore] fn rosetree_basic() { assert_non_opt_evals_to!( indoc!( From 11ed2cbcf838ba2e6a29d11e8e164389768e7471 Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 16 Jun 2021 23:16:14 +0200 Subject: [PATCH 255/496] special-case rose tree field access --- compiler/gen_llvm/src/llvm/build.rs | 6 ++++++ compiler/mono/src/alias_analysis.rs | 4 ++++ compiler/mono/src/decision_tree.rs | 2 +- compiler/mono/src/ir.rs | 4 +++- compiler/test_gen/src/gen_primitives.rs | 1 - 5 files changed, 14 insertions(+), 3 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 6cd61689ea..3eaafa5651 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -1438,6 +1438,12 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( structure, wrapped: Wrapped::RecordOrSingleTagUnion, .. + } + | AccessAtIndex { + index, + structure, + wrapped: Wrapped::LikeARoseTree, + .. } => { // extract field from a record match load_symbol_and_layout(scope, structure) { diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 116d0d224e..55f026c594 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -880,6 +880,10 @@ fn expr_spec( Wrapped::RecordOrSingleTagUnion => { builder.add_get_tuple_field(block, value_id, *index as u32) } + Wrapped::LikeARoseTree => { + let result_type = layout_spec(builder, layout)?; + builder.add_unknown_with(block, &[value_id], result_type) + } Wrapped::MultiTagUnion => { // Clearly this is not generally correct, but it should be for our examples let hacky_is_recursive = diff --git a/compiler/mono/src/decision_tree.rs b/compiler/mono/src/decision_tree.rs index cd7f5bb1f5..b1a29b9be2 100644 --- a/compiler/mono/src/decision_tree.rs +++ b/compiler/mono/src/decision_tree.rs @@ -597,7 +597,7 @@ fn to_relevant_branch_help<'a>( start.extend(end); } } - Wrapped::RecordOrSingleTagUnion => { + Wrapped::RecordOrSingleTagUnion | Wrapped::LikeARoseTree => { let sub_positions = arguments.into_iter().enumerate().map( |(index, (pattern, _))| { let mut new_path = path.to_vec(); diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index c3abe37f61..fdb5db4f76 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -1014,6 +1014,8 @@ pub enum Wrapped { EmptyRecord, SingleElementRecord, RecordOrSingleTagUnion, + /// Like a rose tree; recursive, but only one tag + LikeARoseTree, MultiTagUnion, } @@ -1046,7 +1048,7 @@ impl Wrapped { }, _ => Some(Wrapped::MultiTagUnion), }, - NonNullableUnwrapped(_) => Some(Wrapped::RecordOrSingleTagUnion), + NonNullableUnwrapped(_) => Some(Wrapped::LikeARoseTree), NullableWrapped { .. } | NullableUnwrapped { .. } => { Some(Wrapped::MultiTagUnion) diff --git a/compiler/test_gen/src/gen_primitives.rs b/compiler/test_gen/src/gen_primitives.rs index 8661bb4164..0fd75bf227 100644 --- a/compiler/test_gen/src/gen_primitives.rs +++ b/compiler/test_gen/src/gen_primitives.rs @@ -1997,7 +1997,6 @@ fn case_or_pattern() { } #[test] -#[ignore] fn rosetree_basic() { assert_non_opt_evals_to!( indoc!( From 6d31f9e1daa537943cecad1fe3c5a14a7e7a8891 Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 16 Jun 2021 23:17:10 +0200 Subject: [PATCH 256/496] recursion info is not needed --- compiler/mono/src/layout.rs | 2 -- 1 file changed, 2 deletions(-) diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index 57ebf7f0ff..44e6854cd5 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -1284,7 +1284,6 @@ pub enum UnionVariant<'a> { Unwrapped { tag_name: TagName, arguments: Vec<'a, Layout<'a>>, - is_recursive: bool, }, Wrapped(WrappedVariant<'a>), } @@ -1506,7 +1505,6 @@ pub fn union_sorted_tags_help<'a>( UnionVariant::Unwrapped { tag_name, arguments: layouts, - is_recursive: opt_rec_var.is_some(), } } } From 642271d7309d3df85652b3397c9780b650fe4d58 Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 16 Jun 2021 23:18:56 +0200 Subject: [PATCH 257/496] clippy --- compiler/mono/src/alias_analysis.rs | 20 ++++++++------------ 1 file changed, 8 insertions(+), 12 deletions(-) diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 55f026c594..845b0313c4 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -860,7 +860,7 @@ fn expr_spec( Struct(fields) => build_tuple_value(builder, env, block, fields), AccessAtIndex { index, - field_layouts, + field_layouts: _, structure, wrapped, } => { @@ -886,18 +886,14 @@ fn expr_spec( } Wrapped::MultiTagUnion => { // Clearly this is not generally correct, but it should be for our examples - let hacky_is_recursive = - field_layouts.iter().any(|l| l == &Layout::RecursivePointer); + // let hacky_is_recursive = field_layouts.iter().any(|l| l == &Layout::RecursivePointer); + // if hacky_is_recursive { - if hacky_is_recursive { - let result_type = layout_spec(builder, layout)?; - builder.add_unknown_with(block, &[value_id], result_type) - } else { - // what to do, what to do. - let result_type = layout_spec(builder, layout)?; - builder.add_unknown_with(block, &[value_id], result_type) - // builder.add_get_tuple_field(block, value_id, *index as u32) - } + // we don't know what constructor we are at this point, so how can we get a + // field from an enum value? + + let result_type = layout_spec(builder, layout)?; + builder.add_unknown_with(block, &[value_id], result_type) } } } From 9903ccecf6372c141233123a235de891b0959793 Mon Sep 17 00:00:00 2001 From: Jared Ramirez Date: Wed, 16 Jun 2021 14:26:09 -0700 Subject: [PATCH 258/496] Add RocDec.div --- compiler/builtins/bitcode/src/dec.zig | 274 ++++++++++++++++++++++++++ 1 file changed, 274 insertions(+) diff --git a/compiler/builtins/bitcode/src/dec.zig b/compiler/builtins/bitcode/src/dec.zig index d194e3e333..c367a589b4 100644 --- a/compiler/builtins/bitcode/src/dec.zig +++ b/compiler/builtins/bitcode/src/dec.zig @@ -21,6 +21,7 @@ pub const RocDec = struct { return .{ .num = num * one_point_zero_i128 }; } + // TODO: Refactor this to use https://ziglang.org/documentation/master/#ctz pub fn fromStr(roc_str: RocStr) ?RocDec { if (roc_str.isEmpty()) { return null; @@ -259,6 +260,76 @@ pub const RocDec = struct { return .{ .num = unsigned_answer }; } } + + pub fn div(self: RocDec, other: RocDec) RocDec { + const numerator_i128 = self.num; + const denominator_i128 = other.num; + + // (0 / n) is always 0 + if (numerator_i128 == 0) { + return RocDec{ .num = 0 }; + } + + // (n / 0) is an error + if (denominator_i128 == 0) { + std.debug.panic("TODO runtime exception for divide by 0!", .{}); + } + + // If they're both negative, or if neither is negative, the final answer + // is positive or zero. If one is negative and the denominator isn't, the + // final answer is negative (or zero, in which case final sign won't matter). + // + // It's important that we do this in terms of negatives, because doing + // it in terms of positives can cause bugs when one is zero. + const is_answer_negative = (numerator_i128 < 0) != (denominator_i128 < 0); + + // Break the two i128s into two { hi: u64, lo: u64 } tuples, discarding + // the sign for now. + // + // We'll multiply all 4 combinations of these (hi1 x lo1, hi2 x lo2, + // hi1 x lo2, hi2 x lo1) and add them as appropriate, then apply the + // appropriate sign at the very end. + // + // We do checked_abs because if we had -i128::MAX before, this will overflow. + + const numerator_abs_i128 = math.absInt(numerator_i128) catch { + // Currently, if you try to do multiplication on i64::MIN, panic + // unless you're specifically multiplying by 0 or 1. + // + // Maybe we could support more cases in the future + if (denominator_i128 == one_point_zero_i128) { + return self; + } else { + std.debug.panic("TODO runtime exception for overflow when dividing!", .{}); + } + }; + const numerator_u128 = @intCast(u128, numerator_abs_i128); + + const denominator_abs_i128 = math.absInt(denominator_i128) catch { + // Currently, if you try to do multiplication on i64::MIN, panic + // unless you're specifically multiplying by 0 or 1. + // + // Maybe we could support more cases in the future + if (numerator_i128 == one_point_zero_i128) { + return other; + } else { + std.debug.panic("TODO runtime exception for overflow when dividing!", .{}); + } + }; + const denominator_u128 = @intCast(u128, denominator_abs_i128); + + const numerator_u256: U256 = mul_u128(numerator_u128, math.pow(u128, 10, decimal_places)); + const answer = div_u256_by_u128(numerator_u256, denominator_u128); + + var unsigned_answer: i128 = undefined; + if (answer.hi == 0 and answer.lo <= math.maxInt(i128)) { + unsigned_answer = @intCast(i128, answer.lo); + } else { + std.debug.panic("TODO runtime exception for overflow when dividing!", .{}); + } + + return RocDec{ .num = if (is_answer_negative) -unsigned_answer else unsigned_answer }; + } }; const U256 = struct { @@ -417,8 +488,174 @@ fn mul_u128(a: u128, b: u128) U256 { return .{ .hi = hi, .lo = lo }; } +// Multiply two 128-bit ints and divide the result by 10^DECIMAL_PLACES +// +// Adapted from https://github.com/nlordell/ethnum-rs +// Copyright (c) 2020 Nicholas Rodrigues Lordello +// Licensed under the Apache License version 2.0 +// +// When translating this to Zig, we often have to use math.shr/shl instead of >>/<< +// This is because casting to the right types for Zig can be kind of tricky. +// See https://github.com/ziglang/zig/issues/7605 +fn div_u256_by_u128(numer: U256, denom: u128) U256 { + const N_UDWORD_BITS: u8 = 128; + const N_UTWORD_BITS: u9 = 256; + + var q: U256 = undefined; + var r: U256 = undefined; + var sr: u8 = undefined; + + // special case + if (numer.hi == 0) { + // 0 X + // --- + // 0 X + return .{ + .hi = 0, + .lo = numer.lo / denom, + }; + } + + // numer.hi != 0 + if (denom == 0) { + // K X + // --- + // 0 0 + return .{ + .hi = 0, + .lo = numer.hi / denom, + }; + } else { + // K X + // --- + // 0 K + // NOTE: Modified from `if (d.low() & (d.low() - 1)) == 0`. + if (math.isPowerOfTwo(denom)) { + // if d is a power of 2 + if (denom == 1) { + return numer; + } + + sr = @ctz(u128, denom); + + return .{ + .hi = math.shr(u128, numer.hi, sr), + .lo = math.shl(u128, numer.hi, N_UDWORD_BITS - sr) | math.shr(u128, numer.lo, sr), + }; + } + + // K X + // --- + // 0 K + var denom_leading_zeros = @clz(u128, denom); + var numer_hi_leading_zeros = @clz(u128, numer.hi); + sr = 1 + N_UDWORD_BITS + denom_leading_zeros - numer_hi_leading_zeros; + // 2 <= sr <= N_UTWORD_BITS - 1 + // q.all = n.all << (N_UTWORD_BITS - sr); + // r.all = n.all >> sr; + // #[allow(clippy::comparison_chain)] + if (sr == N_UDWORD_BITS) { + q = .{ + .hi = numer.lo, + .lo = 0, + }; + r = .{ + .hi = 0, + .lo = numer.hi, + }; + } else if (sr < N_UDWORD_BITS) { + // 2 <= sr <= N_UDWORD_BITS - 1 + q = .{ + .hi = math.shl(u128, numer.lo, N_UDWORD_BITS - sr), + .lo = 0, + }; + r = .{ + .hi = math.shr(u128, numer.hi, sr), + .lo = math.shl(u128, numer.hi, N_UDWORD_BITS - sr) | math.shr(u128, numer.lo, sr), + }; + } else { + // N_UDWORD_BITS + 1 <= sr <= N_UTWORD_BITS - 1 + q = .{ + .hi = math.shl(u128, numer.hi, N_UTWORD_BITS - sr) | math.shr(u128, numer.lo, sr - N_UDWORD_BITS), + .lo = math.shl(u128, numer.lo, N_UTWORD_BITS - sr), + }; + r = .{ + .hi = 0, + .lo = math.shr(u128, numer.hi, sr - N_UDWORD_BITS), + }; + } + } + + // Not a special case + // q and r are initialized with: + // q.all = n.all << (N_UTWORD_BITS - sr); + // r.all = n.all >> sr; + // 1 <= sr <= N_UTWORD_BITS - 1 + var carry: u128 = 0; + + while (sr > 0) { + // r:q = ((r:q) << 1) | carry + r.hi = (r.hi << 1) | (r.lo >> (N_UDWORD_BITS - 1)); + r.lo = (r.lo << 1) | (q.hi >> (N_UDWORD_BITS - 1)); + q.hi = (q.hi << 1) | (q.lo >> (N_UDWORD_BITS - 1)); + q.lo = (q.lo << 1) | carry; + + // carry = 0; + // if (r.all >= d.all) + // { + // r.all -= d.all; + // carry = 1; + // } + // NOTE: Modified from `(d - r - 1) >> (N_UTWORD_BITS - 1)` to be an + // **arithmetic** shift. + + var lo: u128 = undefined; + var lo_overflowed: bool = undefined; + var hi: u128 = undefined; + + lo_overflowed = @subWithOverflow(u128, denom, r.lo, &lo); + hi = 0 -% @intCast(u128, @bitCast(u1, lo_overflowed)) -% r.hi; + + lo_overflowed = @subWithOverflow(u128, lo, 1, &lo); + hi = hi -% @intCast(u128, @bitCast(u1, lo_overflowed)); + + // TODO this U256 was originally created by: + // + // ((hi as i128) >> 127).as_u256() + // + // ...however, I can't figure out where that funciton is defined. + // Maybe it's defined using a macro or something. Anyway, hopefully + // this is what it would do in this scenario. + var s = .{ + .hi = 0, + .lo = math.shr(u128, hi, 127), + }; + + carry = s.lo & 1; + + // var (lo, carry) = r.lo.overflowing_sub(denom & s.lo); + lo_overflowed = @subWithOverflow(u128, r.lo, (denom & s.lo), &lo); + hi = r.hi -% @intCast(u128, @bitCast(u1, lo_overflowed)); + + r = .{ .hi = hi, .lo = lo }; + + sr -= 1; + } + + var hi = (q.hi << 1) | (q.lo >> (127)); + var lo = (q.lo << 1) | carry; + + return .{ .hi = hi, .lo = lo }; +} + +fn num_of_trailing_zeros(num: u128) u32 { + const trailing: u8 = @ctz(u128, num); + return @intCast(u32, trailing); +} + const testing = std.testing; const expectEqual = testing.expectEqual; +const expectError = testing.expectError; const expectEqualSlices = testing.expectEqualSlices; const expect = testing.expect; @@ -692,3 +929,40 @@ test "mul: by 2" { try expectEqual(RocDec.fromU64(30), dec.mul(RocDec.fromU64(2))); } + +test "div: 0 / 2" { + var dec: RocDec = RocDec.fromU64(0); + + try expectEqual(RocDec.fromU64(0), dec.div(RocDec.fromU64(2))); +} + +test "div: 2 / 2" { + var dec: RocDec = RocDec.fromU64(2); + + try expectEqual(RocDec.fromU64(1), dec.div(RocDec.fromU64(2))); +} + +test "div: 20 / 2" { + var dec: RocDec = RocDec.fromU64(20); + + try expectEqual(RocDec.fromU64(10), dec.div(RocDec.fromU64(2))); +} + +test "div: 8 / 5" { + var dec: RocDec = RocDec.fromU64(8); + var res: RocDec = RocDec.fromStr(RocStr.init("1.6", 3)).?; + try expectEqual(res, dec.div(RocDec.fromU64(5))); +} + +test "div: 10 / 3" { + var numer: RocDec = RocDec.fromU64(10); + var denom: RocDec = RocDec.fromU64(3); + + var roc_str = RocStr.init("3.333333333333333333", 20); + errdefer roc_str.deinit(); + defer roc_str.deinit(); + + var res: RocDec = RocDec.fromStr(roc_str).?; + + try expectEqual(res, numer.div(denom)); +} From eaf62a1bf8a5dbbe88809b8a44295820a9de458e Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 16 Jun 2021 23:29:31 +0200 Subject: [PATCH 259/496] morphic clippy --- vendor/morphic_lib/src/ir.rs | 4 +--- vendor/morphic_lib/src/preprocess.rs | 24 ++++++++++++------------ 2 files changed, 13 insertions(+), 15 deletions(-) diff --git a/vendor/morphic_lib/src/ir.rs b/vendor/morphic_lib/src/ir.rs index e778fe03b7..b6408ebc98 100644 --- a/vendor/morphic_lib/src/ir.rs +++ b/vendor/morphic_lib/src/ir.rs @@ -283,9 +283,7 @@ impl Graph { /// /// IF an SCC 'A' can jump to an SCC 'B', then 'A' is guaranteed to appear *before* 'B' in the /// returned iterator. - pub(crate) fn iter_sccs<'a>( - &'a self, - ) -> impl Iterator> + 'a { + pub(crate) fn iter_sccs(&self) -> impl Iterator> + '_ { self.rev_sccs .count() .iter() diff --git a/vendor/morphic_lib/src/preprocess.rs b/vendor/morphic_lib/src/preprocess.rs index 70112b5ba0..161d61ca9f 100644 --- a/vendor/morphic_lib/src/preprocess.rs +++ b/vendor/morphic_lib/src/preprocess.rs @@ -88,40 +88,40 @@ impl Error { err } - fn annotate_type_def<'a, E: Into>( - nc: &'a NameCache, + fn annotate_type_def>( + nc: &NameCache, def_id: NamedTypeId, - ) -> impl FnOnce(E) -> Self + 'a { + ) -> impl FnOnce(E) -> Self + '_ { move |err| { let (mod_, name) = &nc.named_types[def_id]; Error::annotate_mod_def(err, mod_.clone(), DefName::Type(name.clone())) } } - fn annotate_func_def<'a, E: Into>( - nc: &'a NameCache, + fn annotate_func_def>( + nc: &NameCache, def_id: FuncId, - ) -> impl FnOnce(E) -> Self + 'a { + ) -> impl FnOnce(E) -> Self + '_ { move |err| { let (mod_, name) = &nc.funcs[def_id]; Error::annotate_mod_def(err, mod_.clone(), DefName::Func(name.clone())) } } - fn annotate_const_def<'a, E: Into>( - nc: &'a NameCache, + fn annotate_const_def>( + nc: &NameCache, def_id: ConstId, - ) -> impl FnOnce(E) -> Self + 'a { + ) -> impl FnOnce(E) -> Self + '_ { move |err| { let (mod_, name) = &nc.consts[def_id]; Error::annotate_mod_def(err, mod_.clone(), DefName::Const(name.clone())) } } - fn annotate_entry_point<'a, E: Into>( - nc: &'a NameCache, + fn annotate_entry_point>( + nc: &NameCache, def_id: EntryPointId, - ) -> impl FnOnce(E) -> Self + 'a { + ) -> impl FnOnce(E) -> Self + '_ { move |err| { let mut err = err.into(); if err.def.is_none() { From 49977ac80398645b8bc7781536149318529fb87e Mon Sep 17 00:00:00 2001 From: Jared Ramirez Date: Wed, 16 Jun 2021 14:32:18 -0700 Subject: [PATCH 260/496] Fix typo --- compiler/builtins/bitcode/src/dec.zig | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/builtins/bitcode/src/dec.zig b/compiler/builtins/bitcode/src/dec.zig index c367a589b4..3ebb6ba542 100644 --- a/compiler/builtins/bitcode/src/dec.zig +++ b/compiler/builtins/bitcode/src/dec.zig @@ -623,7 +623,7 @@ fn div_u256_by_u128(numer: U256, denom: u128) U256 { // // ((hi as i128) >> 127).as_u256() // - // ...however, I can't figure out where that funciton is defined. + // ...however, I can't figure out where that function is defined. // Maybe it's defined using a macro or something. Anyway, hopefully // this is what it would do in this scenario. var s = .{ From 117ef03251e20948b6a05c6b689df893414a2d8c Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 16 Jun 2021 23:32:57 +0200 Subject: [PATCH 261/496] morphic fmt --- vendor/morphic_lib/src/util/strongly_connected.rs | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/vendor/morphic_lib/src/util/strongly_connected.rs b/vendor/morphic_lib/src/util/strongly_connected.rs index 91cdfeb3e0..39e1f590cd 100644 --- a/vendor/morphic_lib/src/util/strongly_connected.rs +++ b/vendor/morphic_lib/src/util/strongly_connected.rs @@ -126,9 +126,10 @@ where loop { scc_start -= 1; let scc_node = scc_stack[scc_start]; - debug_assert!( - matches!(node_states[scc_node], NodeState::OnSccStack { .. }) - ); + debug_assert!(matches!( + node_states[scc_node], + NodeState::OnSccStack { .. } + )); node_states[scc_node] = NodeState::Complete; if scc_node == node { break; From a25986fc3b676f3a41af2bf86d3a0b22c05864db Mon Sep 17 00:00:00 2001 From: Jared Ramirez Date: Wed, 16 Jun 2021 15:00:05 -0700 Subject: [PATCH 262/496] Add super basic benchmarks --- compiler/builtins/bitcode/.gitignore | 2 + compiler/builtins/bitcode/benchmark.sh | 6 + compiler/builtins/bitcode/benchmark/dec.zig | 144 ++++++++++++++++++++ 3 files changed, 152 insertions(+) create mode 100755 compiler/builtins/bitcode/benchmark.sh create mode 100644 compiler/builtins/bitcode/benchmark/dec.zig diff --git a/compiler/builtins/bitcode/.gitignore b/compiler/builtins/bitcode/.gitignore index cd473dd7c4..18b2c682d4 100644 --- a/compiler/builtins/bitcode/.gitignore +++ b/compiler/builtins/bitcode/.gitignore @@ -1,5 +1,7 @@ zig-cache src/zig-cache +benchmark/zig-cache builtins.ll builtins.bc builtins.o +dec diff --git a/compiler/builtins/bitcode/benchmark.sh b/compiler/builtins/bitcode/benchmark.sh new file mode 100755 index 0000000000..754fbc4c72 --- /dev/null +++ b/compiler/builtins/bitcode/benchmark.sh @@ -0,0 +1,6 @@ +#!/bin/bash + +set -euxo pipefail + +zig build-exe benchmark/dec.zig --main-pkg-path . +./dec diff --git a/compiler/builtins/bitcode/benchmark/dec.zig b/compiler/builtins/bitcode/benchmark/dec.zig new file mode 100644 index 0000000000..f178dc650d --- /dev/null +++ b/compiler/builtins/bitcode/benchmark/dec.zig @@ -0,0 +1,144 @@ +const std = @import("std"); +const time = std.time; +const Timer = time.Timer; + +const RocStr = @import("../src/str.zig").RocStr; +const RocDec = @import("../src/dec.zig").RocDec; + +var timer: Timer = undefined; + +pub fn main() !void { + const stdout = std.io.getStdOut().writer(); + timer = try Timer.start(); + + const add7_ns = add7(); + try stdout.print("7 additions took {}ns\n", .{add7_ns}); + + const sub7_ns = sub7(); + try stdout.print("7 subtractions took {}ns\n", .{sub7_ns}); + + const mul7_ns = mul7(); + try stdout.print("7 multiplications took {}ns\n", .{mul7_ns}); + + const div7_ns = div7(); + try stdout.print("7 divisions took {}ns\n", .{div7_ns}); +} + +fn add7() u64 { + var str1 = RocStr.init("1.2", 3); + const dec1 = RocDec.fromStr(str1).?; + + var str2 = RocStr.init("3.4", 3); + const dec2 = RocDec.fromStr(str2).?; + + timer.reset(); + + var a = dec1.add(dec2); + a = a.add(dec1); + a = a.add(dec1); + a = a.add(dec1); + a = a.add(dec1); + a = a.add(dec1); + a = a.add(dec1); + a = a.add(dec1); + a = a.add(dec1); + a = a.add(dec1); + a = a.add(dec1); + a = a.add(dec1); + a = a.add(dec1); + a = a.add(dec1); + a = a.add(dec1); + a = a.add(dec1); + a = a.add(dec1); + + return timer.read(); +} + +fn sub7() u64 { + var str1 = RocStr.init("1.2", 3); + const dec1 = RocDec.fromStr(str1).?; + + var str2 = RocStr.init("3.4", 3); + const dec2 = RocDec.fromStr(str2).?; + + timer.reset(); + + var a = dec1.sub(dec2); + a = a.sub(dec1); + a = a.sub(dec1); + a = a.sub(dec1); + a = a.sub(dec1); + a = a.sub(dec1); + a = a.sub(dec1); + a = a.sub(dec1); + a = a.sub(dec1); + a = a.sub(dec1); + a = a.sub(dec1); + a = a.sub(dec1); + a = a.sub(dec1); + a = a.sub(dec1); + a = a.sub(dec1); + a = a.sub(dec1); + a = a.sub(dec1); + + return timer.read(); +} +fn mul7() u64 { + var str1 = RocStr.init("1.2", 3); + const dec1 = RocDec.fromStr(str1).?; + + var str2 = RocStr.init("3.4", 3); + const dec2 = RocDec.fromStr(str2).?; + + timer.reset(); + + var a = dec1.mul(dec2); + a = a.mul(dec1); + a = a.mul(dec1); + a = a.mul(dec1); + a = a.mul(dec1); + a = a.mul(dec1); + a = a.mul(dec1); + a = a.mul(dec1); + a = a.mul(dec1); + a = a.mul(dec1); + a = a.mul(dec1); + a = a.mul(dec1); + a = a.mul(dec1); + a = a.mul(dec1); + a = a.mul(dec1); + a = a.mul(dec1); + a = a.mul(dec1); + + return timer.read(); +} + +fn div7() u64 { + var str1 = RocStr.init("1.2", 3); + const dec1 = RocDec.fromStr(str1).?; + + var str2 = RocStr.init("3.4", 3); + const dec2 = RocDec.fromStr(str2).?; + + timer.reset(); + + var a = dec1.div(dec2); + a = a.div(dec1); + a = a.div(dec1); + a = a.div(dec1); + a = a.div(dec1); + a = a.div(dec1); + a = a.div(dec1); + a = a.div(dec1); + a = a.div(dec1); + a = a.div(dec1); + a = a.div(dec1); + a = a.div(dec1); + a = a.div(dec1); + a = a.div(dec1); + a = a.div(dec1); + a = a.div(dec1); + a = a.div(dec1); + + return timer.read(); +} From 4d2699f5989b0725381b237b7267c7806627c7fa Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Wed, 16 Jun 2021 23:18:40 -0400 Subject: [PATCH 263/496] Use -O ReleaseFast in zig benchmarks --- compiler/builtins/bitcode/benchmark.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/builtins/bitcode/benchmark.sh b/compiler/builtins/bitcode/benchmark.sh index 754fbc4c72..ef7b3d6b35 100755 --- a/compiler/builtins/bitcode/benchmark.sh +++ b/compiler/builtins/bitcode/benchmark.sh @@ -2,5 +2,5 @@ set -euxo pipefail -zig build-exe benchmark/dec.zig --main-pkg-path . +zig build-exe benchmark/dec.zig -O ReleaseFast --main-pkg-path . ./dec From 11b43c11283c0761d4c03bf24bb5b1f35dc7d4ff Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Wed, 16 Jun 2021 23:18:52 -0400 Subject: [PATCH 264/496] Make zig benchmarks more like the Rust ones --- compiler/builtins/bitcode/benchmark/dec.zig | 65 +++++++++++---------- 1 file changed, 33 insertions(+), 32 deletions(-) diff --git a/compiler/builtins/bitcode/benchmark/dec.zig b/compiler/builtins/bitcode/benchmark/dec.zig index f178dc650d..260b895c55 100644 --- a/compiler/builtins/bitcode/benchmark/dec.zig +++ b/compiler/builtins/bitcode/benchmark/dec.zig @@ -35,21 +35,21 @@ fn add7() u64 { var a = dec1.add(dec2); a = a.add(dec1); + a = a.add(dec2); a = a.add(dec1); + a = a.add(dec2); a = a.add(dec1); + a = a.add(dec2); a = a.add(dec1); + a = a.add(dec2); a = a.add(dec1); + a = a.add(dec2); a = a.add(dec1); + a = a.add(dec2); a = a.add(dec1); + a = a.add(dec2); a = a.add(dec1); - a = a.add(dec1); - a = a.add(dec1); - a = a.add(dec1); - a = a.add(dec1); - a = a.add(dec1); - a = a.add(dec1); - a = a.add(dec1); - a = a.add(dec1); + a = a.add(dec2); return timer.read(); } @@ -65,24 +65,25 @@ fn sub7() u64 { var a = dec1.sub(dec2); a = a.sub(dec1); + a = a.sub(dec2); a = a.sub(dec1); + a = a.sub(dec2); a = a.sub(dec1); + a = a.sub(dec2); a = a.sub(dec1); + a = a.sub(dec2); a = a.sub(dec1); + a = a.sub(dec2); a = a.sub(dec1); + a = a.sub(dec2); a = a.sub(dec1); + a = a.sub(dec2); a = a.sub(dec1); - a = a.sub(dec1); - a = a.sub(dec1); - a = a.sub(dec1); - a = a.sub(dec1); - a = a.sub(dec1); - a = a.sub(dec1); - a = a.sub(dec1); - a = a.sub(dec1); + a = a.sub(dec2); return timer.read(); } + fn mul7() u64 { var str1 = RocStr.init("1.2", 3); const dec1 = RocDec.fromStr(str1).?; @@ -94,21 +95,21 @@ fn mul7() u64 { var a = dec1.mul(dec2); a = a.mul(dec1); + a = a.mul(dec2); a = a.mul(dec1); + a = a.mul(dec2); a = a.mul(dec1); + a = a.mul(dec2); a = a.mul(dec1); + a = a.mul(dec2); a = a.mul(dec1); + a = a.mul(dec2); a = a.mul(dec1); + a = a.mul(dec2); a = a.mul(dec1); + a = a.mul(dec2); a = a.mul(dec1); - a = a.mul(dec1); - a = a.mul(dec1); - a = a.mul(dec1); - a = a.mul(dec1); - a = a.mul(dec1); - a = a.mul(dec1); - a = a.mul(dec1); - a = a.mul(dec1); + a = a.mul(dec2); return timer.read(); } @@ -124,21 +125,21 @@ fn div7() u64 { var a = dec1.div(dec2); a = a.div(dec1); + a = a.div(dec2); a = a.div(dec1); + a = a.div(dec2); a = a.div(dec1); + a = a.div(dec2); a = a.div(dec1); + a = a.div(dec2); a = a.div(dec1); + a = a.div(dec2); a = a.div(dec1); + a = a.div(dec2); a = a.div(dec1); + a = a.div(dec2); a = a.div(dec1); - a = a.div(dec1); - a = a.div(dec1); - a = a.div(dec1); - a = a.div(dec1); - a = a.div(dec1); - a = a.div(dec1); - a = a.div(dec1); - a = a.div(dec1); + a = a.div(dec2); return timer.read(); } From fe9a2c1fc274e505810e47f744823b319eebed51 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Wed, 16 Jun 2021 23:53:04 -0400 Subject: [PATCH 265/496] Average zig benchmarks --- compiler/builtins/bitcode/benchmark/dec.zig | 45 +++++++++++++++++---- 1 file changed, 37 insertions(+), 8 deletions(-) diff --git a/compiler/builtins/bitcode/benchmark/dec.zig b/compiler/builtins/bitcode/benchmark/dec.zig index 260b895c55..96d35a7af1 100644 --- a/compiler/builtins/bitcode/benchmark/dec.zig +++ b/compiler/builtins/bitcode/benchmark/dec.zig @@ -11,17 +11,46 @@ pub fn main() !void { const stdout = std.io.getStdOut().writer(); timer = try Timer.start(); - const add7_ns = add7(); - try stdout.print("7 additions took {}ns\n", .{add7_ns}); + try stdout.print("7 additions took ", .{}); + try avg_runs(add7); - const sub7_ns = sub7(); - try stdout.print("7 subtractions took {}ns\n", .{sub7_ns}); + try stdout.print("7 subtractions took ", .{}); + try avg_runs(sub7); - const mul7_ns = mul7(); - try stdout.print("7 multiplications took {}ns\n", .{mul7_ns}); + try stdout.print("7 multiplications took ", .{}); + try avg_runs(mul7); - const div7_ns = div7(); - try stdout.print("7 divisions took {}ns\n", .{div7_ns}); + try stdout.print("7 divisions took ", .{}); + try avg_runs(div7); +} + +fn avg_runs(func: fn() u64) !void { + const stdout = std.io.getStdOut().writer(); + var first_run = func(); + var lowest = first_run; + var highest = first_run; + var sum = first_run; + + // 31 runs + var runs = [_]u64{ first_run, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; + var next_run: usize = 1; // we already did first_run + + while (next_run < runs.len) { + const run = func(); + + lowest = std.math.min(lowest, run); + highest = std.math.max(highest, run); + + runs[next_run] = run; + + next_run += 1; + } + + std.sort.sort(u64, &runs, {}, comptime std.sort.asc(u64)); + + const median = runs[runs.len / 2]; + + try stdout.print("{}ns (lowest: {}ns, highest: {}ns)\n", .{median, lowest, highest}); } fn add7() u64 { From b7af34c8b1ca80558918f3fd05090faef6d5eed8 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 17 Jun 2021 22:15:54 -0400 Subject: [PATCH 266/496] Fix decref in utils.zig --- compiler/builtins/bitcode/src/utils.zig | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/compiler/builtins/bitcode/src/utils.zig b/compiler/builtins/bitcode/src/utils.zig index be99cab009..197c5d182f 100644 --- a/compiler/builtins/bitcode/src/utils.zig +++ b/compiler/builtins/bitcode/src/utils.zig @@ -92,7 +92,7 @@ pub fn decref( if (refcount == REFCOUNT_ONE_ISIZE) { dealloc(bytes - 16, alignment); } else if (refcount_isize < 0) { - (isizes - 1)[0] = refcount - 1; + (isizes - 1)[0] = refcount + 1; } }, else => { @@ -100,7 +100,7 @@ pub fn decref( if (refcount == REFCOUNT_ONE_ISIZE) { dealloc(bytes - 8, alignment); } else if (refcount_isize < 0) { - (isizes - 1)[0] = refcount - 1; + (isizes - 1)[0] = refcount + 1; } }, } From 94cbb103ef4f427d3694b8664c3b9998c54a5d41 Mon Sep 17 00:00:00 2001 From: Folkert Date: Fri, 18 Jun 2021 20:46:15 +0200 Subject: [PATCH 267/496] use toplevelfunctionlayout in refcount insertion --- compiler/mono/src/borrow.rs | 53 ++++++++++++++++++++++++---------- compiler/mono/src/expand_rc.rs | 3 -- compiler/mono/src/inc_dec.rs | 33 ++++++++++++++++----- compiler/mono/src/ir.rs | 8 ++--- 4 files changed, 67 insertions(+), 30 deletions(-) diff --git a/compiler/mono/src/borrow.rs b/compiler/mono/src/borrow.rs index b919afe510..291e1a024d 100644 --- a/compiler/mono/src/borrow.rs +++ b/compiler/mono/src/borrow.rs @@ -24,9 +24,8 @@ pub fn infer_borrow<'a>( items: MutMap::default(), }; - for ((s, top_level), proc) in procs { - let key = (*s, arena.alloc(*top_level).full()); - param_map.visit_proc(arena, proc, key); + for (key, proc) in procs { + param_map.visit_proc(arena, proc, *key); } let mut env = BorrowInfState { @@ -51,8 +50,7 @@ pub fn infer_borrow<'a>( // mutually recursive functions (or just make all their arguments owned) for (key, proc) in procs { - let layout = arena.alloc(key.1).full(); - env.collect_proc(proc, layout); + env.collect_proc(proc, key.1); } if !env.modified { @@ -69,7 +67,7 @@ pub fn infer_borrow<'a>( #[derive(Debug, PartialEq, Eq, Hash, Clone)] pub enum Key<'a> { - Declaration(Symbol, Layout<'a>), + Declaration(Symbol, TopLevelFunctionLayout<'a>), JoinPoint(JoinPointId), } @@ -98,7 +96,11 @@ impl<'a> IntoIterator for &'a ParamMap<'a> { } impl<'a> ParamMap<'a> { - pub fn get_symbol(&self, symbol: Symbol, layout: Layout<'a>) -> Option<&'a [Param<'a>]> { + pub fn get_symbol( + &self, + symbol: Symbol, + layout: TopLevelFunctionLayout<'a>, + ) -> Option<&'a [Param<'a>]> { let key = Key::Declaration(symbol, layout); self.items.get(&key).copied() @@ -153,7 +155,12 @@ impl<'a> ParamMap<'a> { .into_bump_slice() } - fn visit_proc(&mut self, arena: &'a Bump, proc: &Proc<'a>, key: (Symbol, Layout<'a>)) { + fn visit_proc( + &mut self, + arena: &'a Bump, + proc: &Proc<'a>, + key: (Symbol, TopLevelFunctionLayout<'a>), + ) { if proc.must_own_arguments { self.visit_proc_always_owned(arena, proc, key); return; @@ -171,7 +178,7 @@ impl<'a> ParamMap<'a> { &mut self, arena: &'a Bump, proc: &Proc<'a>, - key: (Symbol, Layout<'a>), + key: (Symbol, TopLevelFunctionLayout<'a>), ) { let already_in_there = self.items.insert( Key::Declaration(proc.name, key.1), @@ -359,12 +366,19 @@ impl<'a> BorrowInfState<'a> { match call_type { ByName { - name, full_layout, .. + name, + ret_layout, + arg_layouts, + .. } => { + let top_level = TopLevelFunctionLayout { + arguments: arg_layouts, + result: *ret_layout, + }; // get the borrow signature of the applied function let ps = self .param_map - .get_symbol(*name, *full_layout) + .get_symbol(*name, top_level) .expect("function is defined"); // the return value will be owned @@ -402,7 +416,10 @@ impl<'a> BorrowInfState<'a> { debug_assert!(op.is_higher_order()); - let closure_layout = Layout::FunctionPointer(arg_layouts, ret_layout); + let closure_layout = TopLevelFunctionLayout { + arguments: arg_layouts, + result: *ret_layout, + }; match op { ListMap | ListKeepIf | ListKeepOks | ListKeepErrs => { @@ -584,7 +601,8 @@ impl<'a> BorrowInfState<'a> { call_type: crate::ir::CallType::ByName { name: g, - full_layout, + arg_layouts, + ret_layout, .. }, arguments: ys, @@ -593,10 +611,15 @@ impl<'a> BorrowInfState<'a> { Stmt::Ret(z), ) = (v, b) { + let top_level = TopLevelFunctionLayout { + arguments: arg_layouts, + result: *ret_layout, + }; + if self.current_proc == *g && x == *z { // anonymous functions (for which the ps may not be known) // can never be tail-recursive, so this is fine - if let Some(ps) = self.param_map.get_symbol(*g, *full_layout) { + if let Some(ps) = self.param_map.get_symbol(*g, top_level) { self.own_params_using_args(ys, ps) } } @@ -684,7 +707,7 @@ impl<'a> BorrowInfState<'a> { } } - fn collect_proc(&mut self, proc: &Proc<'a>, layout: Layout<'a>) { + fn collect_proc(&mut self, proc: &Proc<'a>, layout: TopLevelFunctionLayout<'a>) { let old = self.param_set.clone(); let ys = Vec::from_iter_in(proc.args.iter().map(|t| t.1), self.arena).into_bump_slice(); diff --git a/compiler/mono/src/expand_rc.rs b/compiler/mono/src/expand_rc.rs index 2d60e6a213..08b75fcc70 100644 --- a/compiler/mono/src/expand_rc.rs +++ b/compiler/mono/src/expand_rc.rs @@ -245,9 +245,6 @@ fn layout_for_constructor<'a>( HasFields(fields) } Closure(_arguments, _lambda_set, _result) => { - // TODO can this be improved again? - // let fpointer = Layout::FunctionPointer(arguments, result); - // let fields = arena.alloc([fpointer, *lambda_set.layout]); // HasFields(fields) ConstructorLayout::Unknown } diff --git a/compiler/mono/src/inc_dec.rs b/compiler/mono/src/inc_dec.rs index d2dcd32092..ddcfcc8bed 100644 --- a/compiler/mono/src/inc_dec.rs +++ b/compiler/mono/src/inc_dec.rs @@ -1,5 +1,5 @@ use crate::borrow::{ParamMap, BORROWED, OWNED}; -use crate::ir::{Expr, JoinPointId, ModifyRc, Param, Proc, Stmt}; +use crate::ir::{Expr, JoinPointId, ModifyRc, Param, Proc, Stmt, TopLevelFunctionLayout}; use crate::layout::Layout; use bumpalo::collections::Vec; use bumpalo::Bump; @@ -497,7 +497,10 @@ impl<'a> Context<'a> { const FUNCTION: bool = BORROWED; const CLOSURE_DATA: bool = BORROWED; - let function_layout = Layout::FunctionPointer(arg_layouts, ret_layout); + let function_layout = TopLevelFunctionLayout { + arguments: arg_layouts, + result: *ret_layout, + }; match op { roc_module::low_level::LowLevel::ListMap @@ -679,12 +682,20 @@ impl<'a> Context<'a> { } ByName { - name, full_layout, .. + name, + ret_layout, + arg_layouts, + .. } => { + let top_level = TopLevelFunctionLayout { + arguments: arg_layouts, + result: *ret_layout, + }; + // get the borrow signature let ps = self .param_map - .get_symbol(*name, *full_layout) + .get_symbol(*name, top_level) .expect("function is defined"); let v = Expr::Call(crate::ir::Call { @@ -963,12 +974,20 @@ impl<'a> Context<'a> { } CallType::ByName { - name, full_layout, .. + name, + ret_layout, + arg_layouts, + .. } => { + let top_level = TopLevelFunctionLayout { + arguments: arg_layouts, + result: *ret_layout, + }; + // get the borrow signature let ps = self .param_map - .get_symbol(*name, *full_layout) + .get_symbol(*name, top_level) .expect("function is defined"); self.add_dec_after_application(call.arguments, ps, cont, &invoke_live_vars) } @@ -1222,7 +1241,7 @@ pub fn visit_proc<'a>( arena: &'a Bump, param_map: &'a ParamMap<'a>, proc: &mut Proc<'a>, - layout: Layout<'a>, + layout: TopLevelFunctionLayout<'a>, ) { let ctx = Context::new(arena, param_map); diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index fdb5db4f76..ebfb981698 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -215,7 +215,7 @@ impl<'a> Proc<'a> { let borrow_params = arena.alloc(crate::borrow::infer_borrow(arena, procs)); for (key, proc) in procs.iter_mut() { - crate::inc_dec::visit_proc(arena, borrow_params, proc, arena.alloc(key.1).full()); + crate::inc_dec::visit_proc(arena, borrow_params, proc, key.1); } } @@ -410,8 +410,7 @@ impl<'a> Procs<'a> { let borrow_params = arena.alloc(crate::borrow::infer_borrow(arena, &result)); for (key, proc) in result.iter_mut() { - let layout = arena.alloc(key.1).full(); - crate::inc_dec::visit_proc(arena, borrow_params, proc, layout); + crate::inc_dec::visit_proc(arena, borrow_params, proc, key.1); } result @@ -454,8 +453,7 @@ impl<'a> Procs<'a> { let borrow_params = arena.alloc(crate::borrow::infer_borrow(arena, &result)); for (key, proc) in result.iter_mut() { - let layout = arena.alloc(key.1).full(); - crate::inc_dec::visit_proc(arena, borrow_params, proc, layout); + crate::inc_dec::visit_proc(arena, borrow_params, proc, key.1); } (result, borrow_params) From 88f4b6bc9b09b2aa76f439791ffd8c263cf48673 Mon Sep 17 00:00:00 2001 From: Folkert Date: Fri, 18 Jun 2021 21:00:27 +0200 Subject: [PATCH 268/496] remove more FunctionPointer --- compiler/gen_llvm/src/llvm/build.rs | 26 ++++++++++---------------- compiler/gen_llvm/src/llvm/convert.rs | 7 +------ 2 files changed, 11 insertions(+), 22 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 3eaafa5651..f67c7460c3 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -17,8 +17,8 @@ use crate::llvm::build_str::{ }; use crate::llvm::compare::{generic_eq, generic_neq}; use crate::llvm::convert::{ - basic_type_from_builtin, basic_type_from_layout, block_of_memory, block_of_memory_slices, - ptr_int, + basic_type_from_builtin, basic_type_from_function_layout, basic_type_from_layout, + block_of_memory, block_of_memory_slices, ptr_int, }; use crate::llvm::refcounting::{ decrement_refcount_layout, increment_refcount_layout, PointerToRefcount, @@ -839,7 +839,6 @@ pub fn build_exp_call<'a, 'ctx, 'env>( let bytes = specialization_id.to_bytes(); let callee_var = CalleeSpecVar(&bytes); let func_spec = func_spec_solutions.callee_spec(callee_var).unwrap(); - // let fn_val = function_value_by_func_spec(env, func_spec, symbol, *layout); run_higher_order_low_level( env, @@ -3392,8 +3391,8 @@ pub fn build_closure_caller<'a, 'ctx, 'env>( ); // STEP 4: build a {} -> u64 function that gives the size of the closure - let layout = Layout::Closure(arguments, lambda_set, result); - build_host_exposed_alias_size(env, def_name, alias_symbol, &layout); + let layout = lambda_set.runtime_representation(); + build_host_exposed_alias_size(env, def_name, alias_symbol, layout); } fn build_function_caller<'a, 'ctx, 'env>( @@ -3431,10 +3430,8 @@ fn build_function_caller<'a, 'ctx, 'env>( // pretend the closure layout is empty args.push(Layout::Struct(&[])); - let function_layout = Layout::FunctionPointer(&args, result); - // this is already a (function) pointer type - basic_type_from_layout(env, &function_layout) + basic_type_from_function_layout(env, &args, result) }; argument_types.push(function_pointer_type); @@ -3474,10 +3471,7 @@ fn build_function_caller<'a, 'ctx, 'env>( let _closure_data_ptr = parameters.pop().unwrap().into_pointer_value(); let function_ptr = parameters.pop().unwrap().into_pointer_value(); - // let closure_data = context.struct_type(&[], false).const_zero().into(); - - let actual_function_type = - basic_type_from_layout(env, &Layout::FunctionPointer(arguments, result)); + let actual_function_type = basic_type_from_function_layout(env, arguments, result); let function_ptr = builder .build_bitcast(function_ptr, actual_function_type, "cast") @@ -3513,22 +3507,22 @@ fn build_function_caller<'a, 'ctx, 'env>( ); // STEP 4: build a {} -> u64 function that gives the size of the function - let layout = Layout::FunctionPointer(arguments, result); - build_host_exposed_alias_size(env, def_name, alias_symbol, &layout); + let layout = Layout::Struct(&[]); + build_host_exposed_alias_size(env, def_name, alias_symbol, layout); } fn build_host_exposed_alias_size<'a, 'ctx, 'env>( env: &'a Env<'a, 'ctx, 'env>, def_name: &str, alias_symbol: Symbol, - layout: &Layout<'a>, + layout: Layout<'a>, ) { build_host_exposed_alias_size_help( env, def_name, alias_symbol, None, - basic_type_from_layout(env, layout), + basic_type_from_layout(env, &layout), ) } diff --git a/compiler/gen_llvm/src/llvm/convert.rs b/compiler/gen_llvm/src/llvm/convert.rs index 124ad9ca50..128dc0c538 100644 --- a/compiler/gen_llvm/src/llvm/convert.rs +++ b/compiler/gen_llvm/src/llvm/convert.rs @@ -4,10 +4,9 @@ use inkwell::types::{BasicType, BasicTypeEnum, IntType, StructType}; use inkwell::AddressSpace; use roc_mono::layout::{Builtin, Layout, UnionLayout}; -fn basic_type_from_function_layout<'a, 'ctx, 'env>( +pub fn basic_type_from_function_layout<'a, 'ctx, 'env>( env: &crate::llvm::build::Env<'a, 'ctx, 'env>, args: &[Layout<'_>], - closure_type: Option>, ret_layout: &Layout<'_>, ) -> BasicTypeEnum<'ctx> { let ret_type = basic_type_from_layout(env, &ret_layout); @@ -17,10 +16,6 @@ fn basic_type_from_function_layout<'a, 'ctx, 'env>( arg_basic_types.push(basic_type_from_layout(env, arg_layout)); } - if let Some(closure) = closure_type { - arg_basic_types.push(closure); - } - let fn_type = ret_type.fn_type(arg_basic_types.into_bump_slice(), false); let ptr_type = fn_type.ptr_type(AddressSpace::Generic); From d894a062904a4266cfbf67dbb6ba85a30d8d0309 Mon Sep 17 00:00:00 2001 From: Folkert Date: Fri, 18 Jun 2021 21:05:31 +0200 Subject: [PATCH 269/496] use toplevel more --- compiler/gen_llvm/src/llvm/build.rs | 56 ++++++++++++++++++--------- compiler/gen_llvm/src/llvm/convert.rs | 4 +- 2 files changed, 39 insertions(+), 21 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index f67c7460c3..d2beab5002 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -602,7 +602,9 @@ fn promote_to_main_function<'a, 'ctx, 'env>( "we expect only one specialization of this symbol" ); - let roc_main_fn = function_value_by_func_spec(env, *func_spec, symbol, Layout::Struct(&[])); + // NOTE fake layout; it is only used for debug prints + let roc_main_fn = + function_value_by_func_spec(env, *func_spec, symbol, &[], &Layout::Struct(&[])); let main_fn_name = "$Test.main"; @@ -800,8 +802,9 @@ pub fn build_exp_call<'a, 'ctx, 'env>( match call_type { CallType::ByName { name, - full_layout, specialization_id, + arg_layouts, + ret_layout, .. } => { let mut arg_tuples: Vec = @@ -817,7 +820,8 @@ pub fn build_exp_call<'a, 'ctx, 'env>( roc_call_with_args( env, - &full_layout, + arg_layouts, + ret_layout, *name, func_spec, arg_tuples.into_bump_slice(), @@ -2050,7 +2054,8 @@ pub fn build_exp_stmt<'a, 'ctx, 'env>( } => match call.call_type { CallType::ByName { name, - ref full_layout, + arg_layouts, + ref ret_layout, specialization_id, .. } => { @@ -2059,7 +2064,7 @@ pub fn build_exp_stmt<'a, 'ctx, 'env>( let func_spec = func_spec_solutions.callee_spec(callee_var).unwrap(); let function_value = - function_value_by_func_spec(env, func_spec, name, *full_layout); + function_value_by_func_spec(env, func_spec, name, arg_layouts, ret_layout); invoke_roc_function( env, @@ -3591,8 +3596,6 @@ pub fn build_proc<'a, 'ctx, 'env>( // * roc__mainForHost_1_Update_size() -> i64 // * roc__mainForHost_1_Update_result_size() -> i64 - let evaluator_layout = env.arena.alloc(top_level).full(); - let it = top_level.arguments.iter().copied(); let bytes = roc_mono::alias_analysis::func_name_bytes_help( symbol, @@ -3609,8 +3612,13 @@ pub fn build_proc<'a, 'ctx, 'env>( "we expect only one specialization of this symbol" ); - let evaluator = - function_value_by_func_spec(env, *func_spec, symbol, evaluator_layout); + let evaluator = function_value_by_func_spec( + env, + *func_spec, + symbol, + top_level.arguments, + &top_level.result, + ); let ident_string = proc.name.ident_string(&env.interns); let fn_name: String = format!("{}_1", ident_string); @@ -3684,17 +3692,19 @@ fn function_value_by_func_spec<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, func_spec: FuncSpec, symbol: Symbol, - layout: Layout<'a>, + arguments: &[Layout<'a>], + result: &Layout<'a>, ) -> FunctionValue<'ctx> { let fn_name = func_spec_name(env.arena, &env.interns, symbol, func_spec); let fn_name = fn_name.as_str(); - function_value_by_name_help(env, layout, symbol, fn_name) + function_value_by_name_help(env, arguments, result, symbol, fn_name) } fn function_value_by_name_help<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, - layout: Layout<'a>, + arguments: &[Layout<'a>], + result: &Layout<'a>, symbol: Symbol, fn_name: &str, ) -> FunctionValue<'ctx> { @@ -3702,7 +3712,8 @@ fn function_value_by_name_help<'a, 'ctx, 'env>( if symbol.is_builtin() { eprintln!( "Unrecognized builtin function: {:?}\nLayout: {:?}\n", - fn_name, layout + fn_name, + (arguments, result) ); eprintln!("Is the function defined? If so, maybe there is a problem with the layout"); @@ -3714,7 +3725,9 @@ fn function_value_by_name_help<'a, 'ctx, 'env>( // Unrecognized non-builtin function: eprintln!( "Unrecognized non-builtin function: {:?}\n\nSymbol: {:?}\nLayout: {:?}\n", - fn_name, symbol, layout + fn_name, + symbol, + (arguments, result) ); eprintln!("Is the function defined? If so, maybe there is a problem with the layout"); @@ -3730,12 +3743,14 @@ fn function_value_by_name_help<'a, 'ctx, 'env>( #[inline(always)] fn roc_call_with_args<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, - layout: &Layout<'a>, + argument_layouts: &[Layout<'a>], + result_layout: &Layout<'a>, symbol: Symbol, func_spec: FuncSpec, args: &[BasicValueEnum<'ctx>], ) -> BasicValueEnum<'ctx> { - let fn_val = function_value_by_func_spec(env, func_spec, symbol, *layout); + let fn_val = + function_value_by_func_spec(env, func_spec, symbol, argument_layouts, result_layout); let call = env.builder.build_call(fn_val, args, "call"); @@ -3831,9 +3846,14 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>( macro_rules! passed_function_at_index { ($index:expr) => {{ let function_symbol = args[$index]; - let function_layout = Layout::FunctionPointer(argument_layouts, return_layout); - function_value_by_func_spec(env, func_spec, function_symbol, function_layout) + function_value_by_func_spec( + env, + func_spec, + function_symbol, + argument_layouts, + return_layout, + ) }}; } diff --git a/compiler/gen_llvm/src/llvm/convert.rs b/compiler/gen_llvm/src/llvm/convert.rs index 128dc0c538..e00c03c333 100644 --- a/compiler/gen_llvm/src/llvm/convert.rs +++ b/compiler/gen_llvm/src/llvm/convert.rs @@ -44,9 +44,7 @@ pub fn basic_type_from_layout<'a, 'ctx, 'env>( use Layout::*; match layout { - FunctionPointer(args, ret_layout) => { - basic_type_from_function_layout(env, args, None, ret_layout) - } + FunctionPointer(args, ret_layout) => basic_type_from_function_layout(env, args, ret_layout), Closure(_args, closure_layout, _ret_layout) => { let closure_data_layout = closure_layout.runtime_representation(); basic_type_from_layout(env, &closure_data_layout) From a64f80dbe81d50e3313aebf4efad8f7b737c9921 Mon Sep 17 00:00:00 2001 From: Folkert Date: Fri, 18 Jun 2021 21:16:43 +0200 Subject: [PATCH 270/496] fix hash problem --- compiler/mono/src/borrow.rs | 11 +++-------- compiler/mono/src/inc_dec.rs | 11 +++-------- 2 files changed, 6 insertions(+), 16 deletions(-) diff --git a/compiler/mono/src/borrow.rs b/compiler/mono/src/borrow.rs index 291e1a024d..54808abfaf 100644 --- a/compiler/mono/src/borrow.rs +++ b/compiler/mono/src/borrow.rs @@ -371,10 +371,8 @@ impl<'a> BorrowInfState<'a> { arg_layouts, .. } => { - let top_level = TopLevelFunctionLayout { - arguments: arg_layouts, - result: *ret_layout, - }; + let top_level = TopLevelFunctionLayout::new(self.arena, arg_layouts, *ret_layout); + // get the borrow signature of the applied function let ps = self .param_map @@ -611,10 +609,7 @@ impl<'a> BorrowInfState<'a> { Stmt::Ret(z), ) = (v, b) { - let top_level = TopLevelFunctionLayout { - arguments: arg_layouts, - result: *ret_layout, - }; + let top_level = TopLevelFunctionLayout::new(self.arena, arg_layouts, *ret_layout); if self.current_proc == *g && x == *z { // anonymous functions (for which the ps may not be known) diff --git a/compiler/mono/src/inc_dec.rs b/compiler/mono/src/inc_dec.rs index ddcfcc8bed..0e9964a8f5 100644 --- a/compiler/mono/src/inc_dec.rs +++ b/compiler/mono/src/inc_dec.rs @@ -687,10 +687,7 @@ impl<'a> Context<'a> { arg_layouts, .. } => { - let top_level = TopLevelFunctionLayout { - arguments: arg_layouts, - result: *ret_layout, - }; + let top_level = TopLevelFunctionLayout::new(self.arena, arg_layouts, *ret_layout); // get the borrow signature let ps = self @@ -979,10 +976,8 @@ impl<'a> Context<'a> { arg_layouts, .. } => { - let top_level = TopLevelFunctionLayout { - arguments: arg_layouts, - result: *ret_layout, - }; + let top_level = + TopLevelFunctionLayout::new(self.arena, arg_layouts, *ret_layout); // get the borrow signature let ps = self From 3e6e55ffcc5076345be32c52f4c01cd359cb5582 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 17 Jun 2021 22:23:38 -0400 Subject: [PATCH 271/496] Improve roc_std storage pointer usage. We were trying to represent Refcount as usize, but Refcount can be isize::MIN which can't be negated and then cast to usize without overflow. Also made the Drop implementations for RocList and RocStr more efficient. --- roc_std/src/lib.rs | 91 ++++++++++++++++++++++++++++------------------ 1 file changed, 56 insertions(+), 35 deletions(-) diff --git a/roc_std/src/lib.rs b/roc_std/src/lib.rs index 4e016957d3..dde75577c5 100644 --- a/roc_std/src/lib.rs +++ b/roc_std/src/lib.rs @@ -1,7 +1,7 @@ #![crate_type = "lib"] #![no_std] use core::ffi::c_void; -use core::fmt; +use core::{fmt, mem}; pub mod alloca; @@ -19,7 +19,7 @@ extern "C" { pub fn roc_dealloc(ptr: *mut c_void, alignment: u32); } -const REFCOUNT_1: usize = isize::MIN as usize; +const REFCOUNT_1: isize = isize::MIN; #[repr(u8)] #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -48,7 +48,7 @@ pub struct RocList { #[derive(Clone, Copy, Debug)] pub enum Storage { ReadOnly, - Refcounted(usize), + Refcounted(isize), Capacity(usize), } @@ -91,22 +91,26 @@ impl RocList { let value = *self.get_storage_ptr(); // NOTE doesn't work with elements of 16 or more bytes - match isize::cmp(&(value as isize), &0) { + match isize::cmp(&value, &0) { Equal => Some(Storage::ReadOnly), Less => Some(Storage::Refcounted(value)), - Greater => Some(Storage::Capacity(value)), + Greater => Some(Storage::Capacity(value as usize)), } } } - fn get_storage_ptr(&self) -> *const usize { - let ptr = self.elements as *const usize; + fn get_storage_ptr(&self) -> *const isize { + let ptr = self.elements as *const isize; unsafe { ptr.offset(-1) } } - fn get_storage_ptr_mut(&mut self) -> *mut usize { - self.get_storage_ptr() as *mut usize + fn get_storage_ptr_mut(&mut self) -> *mut isize { + self.get_storage_ptr() as *mut isize + } + + fn set_storage_ptr(&mut self, ptr: *const isize) { + self.elements = unsafe { ptr.offset(1) as *mut T }; } fn get_element_ptr(elements: *const T) -> *const T { @@ -197,6 +201,13 @@ impl RocList { pub fn as_slice(&self) -> &[T] { unsafe { core::slice::from_raw_parts(self.elements, self.length) } } + + /// The alignment we need is either the alignment of T, or else + /// the alignment of usize, whichever is higher. That's because we need + /// to store both T values as well as the refcount/capacity storage slot. + fn align_of_storage_ptr() -> u32 { + mem::align_of::().max(mem::align_of::()) as u32 + } } impl fmt::Debug for RocList { @@ -231,17 +242,23 @@ impl Eq for RocList {} impl Drop for RocList { fn drop(&mut self) { - use Storage::*; - match self.storage() { - None | Some(ReadOnly) => {} - Some(Capacity(_)) | Some(Refcounted(REFCOUNT_1)) => unsafe { - libc::free(self.get_storage_ptr() as *mut libc::c_void); - }, - Some(Refcounted(rc)) => { - let sptr = self.get_storage_ptr_mut(); - unsafe { - *sptr = rc - 1; + if !self.is_empty() { + let storage_ptr = self.get_storage_ptr_mut(); + + unsafe { + let storage_val = *storage_ptr; + + if storage_val == REFCOUNT_1 || storage_val > 0 { + // If we have no more references, or if this was unique, + // deallocate it. + roc_dealloc(storage_ptr as *mut c_void, Self::align_of_storage_ptr()); + } else if storage_val < 0 { + // If this still has more references, decrement one. + *storage_ptr = storage_val - 1; } + + // The only remaining option is that this is in readonly memory, + // in which case we shouldn't attempt to do anything to it. } } } @@ -310,19 +327,19 @@ impl RocStr { match isize::cmp(&(value as isize), &0) { Equal => Some(Storage::ReadOnly), Less => Some(Storage::Refcounted(value)), - Greater => Some(Storage::Capacity(value)), + Greater => Some(Storage::Capacity(value as usize)), } } } - fn get_storage_ptr(&self) -> *const usize { - let ptr = self.elements as *const usize; + fn get_storage_ptr(&self) -> *const isize { + let ptr = self.elements as *const isize; unsafe { ptr.offset(-1) } } - fn get_storage_ptr_mut(&mut self) -> *mut usize { - self.get_storage_ptr() as *mut usize + fn get_storage_ptr_mut(&mut self) -> *mut isize { + self.get_storage_ptr() as *mut isize } fn get_element_ptr(elements: *const u8) -> *const usize { @@ -485,18 +502,22 @@ impl Clone for RocStr { impl Drop for RocStr { fn drop(&mut self) { if !self.is_small_str() { - use Storage::*; - match self.storage() { - None | Some(ReadOnly) => {} - Some(Capacity(_)) | Some(Refcounted(REFCOUNT_1)) => unsafe { - libc::free(self.get_storage_ptr() as *mut libc::c_void); - }, - Some(Refcounted(rc)) => { - let sptr = self.get_storage_ptr_mut(); - unsafe { - *sptr = rc - 1; - } + let storage_ptr = self.get_storage_ptr_mut(); + + unsafe { + let storage_val = *storage_ptr; + + if storage_val == REFCOUNT_1 || storage_val > 0 { + // If we have no more references, or if this was unique, + // deallocate it. + roc_dealloc(storage_ptr as *mut c_void, mem::align_of::() as u32); + } else if storage_val < 0 { + // If this still has more references, decrement one. + *storage_ptr = storage_val - 1; } + + // The only remaining option is that this is in readonly memory, + // in which case we shouldn't attempt to do anything to it. } } } From 98d017172668b9259c1a0c93b8a4a0b4c971c416 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 17 Jun 2021 22:25:39 -0400 Subject: [PATCH 272/496] Add RocStr:write_c_str to roc_std --- roc_std/src/lib.rs | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/roc_std/src/lib.rs b/roc_std/src/lib.rs index dde75577c5..cb6b2d8f89 100644 --- a/roc_std/src/lib.rs +++ b/roc_std/src/lib.rs @@ -1,7 +1,7 @@ #![crate_type = "lib"] #![no_std] use core::ffi::c_void; -use core::{fmt, mem}; +use core::{fmt, mem, ptr}; pub mod alloca; @@ -434,12 +434,28 @@ impl RocStr { unsafe { core::slice::from_raw_parts(self.elements, self.length) } } } + #[allow(clippy::missing_safety_doc)] pub unsafe fn as_str(&self) -> &str { let slice = self.as_slice(); core::str::from_utf8_unchecked(slice) } + + /// Write a CStr (null-terminated) representation of this RocStr into + /// the given buffer. Assumes the given buffer has enough space! + pub unsafe fn write_c_str(&self, buf: *mut u8) -> *mut char { + if self.is_small_str() { + ptr::copy_nonoverlapping(self.get_small_str_ptr(), buf, self.len()); + } else { + ptr::copy_nonoverlapping(self.elements, buf, self.len()); + } + + // null-terminate + *(buf.offset(self.len() as isize)) = 0; + + buf as *mut char + } } impl From<&str> for RocStr { From 6a84902f797ce42733ab9278fe105915340530cb Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 17 Jun 2021 22:25:54 -0400 Subject: [PATCH 273/496] Add RocList::append_slice to roc_std --- roc_std/src/lib.rs | 78 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 78 insertions(+) diff --git a/roc_std/src/lib.rs b/roc_std/src/lib.rs index cb6b2d8f89..9a0ca23e51 100644 --- a/roc_std/src/lib.rs +++ b/roc_std/src/lib.rs @@ -202,6 +202,84 @@ impl RocList { unsafe { core::slice::from_raw_parts(self.elements, self.length) } } + /// Copy the contents of the given slice into the end of this list, + /// reallocating and resizing as necessary. + pub fn append_slice(&mut self, slice: &[T]) { + let new_len = self.len() + slice.len(); + let storage_ptr = self.get_storage_ptr_mut(); + + // First, ensure that there's enough storage space. + unsafe { + let storage_val = *storage_ptr as isize; + + // Check if this is refcounted, readonly, or has a capcacity. + // (Capacity will be positive if it has a capacity.) + if storage_val > 0 { + let capacity = storage_val as usize; + + // We don't have enough capacity, so we need to get some more. + if capacity < new_len { + // Double our capacity using realloc + let new_cap = 2 * capacity; + let new_ptr = roc_realloc( + storage_ptr as *mut c_void, + new_cap, + capacity, + Self::align_of_storage_ptr(), + ) as *mut isize; + + // Write the new capacity into the new memory + *new_ptr = new_cap as isize; + + // Copy all the existing elements into the new allocation. + ptr::copy_nonoverlapping(self.elements, new_ptr as *mut T, self.len()); + + // Update our storage pointer to be the new one + self.set_storage_ptr(new_ptr); + } + } else { + // If this was reference counted, decrement the refcount! + if storage_val < 0 { + let refcount = storage_val; + + // Either deallocate or decrement. + if refcount == REFCOUNT_1 { + roc_dealloc(storage_ptr as *mut c_void, Self::align_of_storage_ptr()); + } else { + *storage_ptr = refcount - 1; + } + } + + // This is either refcounted or readonly; either way, we need + // to clone the elements! + + // Double the capacity we need, in case there are future additions. + let new_cap = new_len * 2; + let new_ptr = roc_alloc(new_cap, Self::align_of_storage_ptr()) as *mut isize; + + // Write the new capacity into the new memory; this list is + // now unique, and gets its own capacity! + *new_ptr = new_cap as isize; + + // Copy all the existing elements into the new allocation. + ptr::copy_nonoverlapping(self.elements, new_ptr as *mut T, self.len()); + + // Update our storage pointer to be the new one + self.set_storage_ptr(new_ptr); + } + + // Since this is an append, we want to start writing new elements + // into the memory immediately after the current last element. + let dest = self.elements.offset(self.len() as isize); + + // There's now enough storage to append the contents of the slice + // in-place, so do that! + ptr::copy_nonoverlapping(slice.as_ptr(), dest, self.len()); + } + + self.length = new_len; + } + /// The alignment we need is either the alignment of T, or else /// the alignment of usize, whichever is higher. That's because we need /// to store both T values as well as the refcount/capacity storage slot. From 804c00c89917cf214055ad60f8c34d9add4d899f Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 17 Jun 2021 22:26:01 -0400 Subject: [PATCH 274/496] Implement some file I/O stuff in cli host --- examples/cli/platform/Cargo.lock | 31 ++++++ examples/cli/platform/Cargo.toml | 2 + examples/cli/platform/src/lib.rs | 182 ++++++++++++++++++++++++++++++- 3 files changed, 213 insertions(+), 2 deletions(-) diff --git a/examples/cli/platform/Cargo.lock b/examples/cli/platform/Cargo.lock index 0e827e8bb1..551e2f492b 100644 --- a/examples/cli/platform/Cargo.lock +++ b/examples/cli/platform/Cargo.lock @@ -1,5 +1,7 @@ # This file is automatically @generated by Cargo. # It is not intended for manual editing. +version = 3 + [[package]] name = "base64" version = "0.13.0" @@ -30,6 +32,27 @@ version = "1.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fff857943da45f546682664a79488be82e69e43c1a7a2307679ab9afb3a66d2e" +[[package]] +name = "errno" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fa68f2fb9cae9d37c9b2b3584aba698a2e97f72d7aef7b9f7aa71d8b54ce46fe" +dependencies = [ + "errno-dragonfly", + "libc", + "winapi", +] + +[[package]] +name = "errno-dragonfly" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "14ca354e36190500e1e1fb267c647932382b54053c50b14970856c0b00a35067" +dependencies = [ + "gcc", + "libc", +] + [[package]] name = "form_urlencoded" version = "1.0.1" @@ -40,10 +63,18 @@ dependencies = [ "percent-encoding", ] +[[package]] +name = "gcc" +version = "0.3.55" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f5f3913fa0bfe7ee1fd8248b6b9f42a5af4b9d65ec2dd2c3c26132b950ecfc2" + [[package]] name = "host" version = "0.1.0" dependencies = [ + "errno", + "libc", "roc_std", "ureq", ] diff --git a/examples/cli/platform/Cargo.toml b/examples/cli/platform/Cargo.toml index f4f96d8a3e..0780fec234 100644 --- a/examples/cli/platform/Cargo.toml +++ b/examples/cli/platform/Cargo.toml @@ -11,5 +11,7 @@ crate-type = ["staticlib"] [dependencies] roc_std = { path = "../../../roc_std" } ureq = { version = "2.1" } +libc = "0.2" +errno = "0.2" [workspace] diff --git a/examples/cli/platform/src/lib.rs b/examples/cli/platform/src/lib.rs index daf2b25ef0..4140a2b3b4 100644 --- a/examples/cli/platform/src/lib.rs +++ b/examples/cli/platform/src/lib.rs @@ -1,8 +1,11 @@ #![allow(non_snake_case)] +use core::alloc::Layout; use core::ffi::c_void; -use roc_std::{alloca, RocCallResult, RocResult, RocStr}; -use std::alloc::Layout; +use core::mem; +use errno::{errno, Errno}; +use libc::{self, c_char, c_int}; +use roc_std::{alloca, RocCallResult, RocList, RocResult, RocStr}; extern "C" { #[link_name = "roc__mainForHost_1_exposed"] @@ -156,3 +159,178 @@ pub fn rust_main() -> isize { // Exit code 0 } + +/// A C file descriptor. +pub struct Fd(c_int); + +#[no_mangle] +pub unsafe fn roc_fx_readAll(roc_path: RocStr) -> RocResult, Errno> { + const BUF_BYTES: usize = 1024; + + // I know that since Rust 1.39 mem::uninitialized() is deprecated in favor + // of MaybeUninit, but I couldn't get this to work with MaybeUninit. + #[allow(deprecated)] + let mut buf: [u8; BUF_BYTES] = mem::uninitialized(); + let fd: c_int; + + // If the path fits in the stack-allocated buffer we'll later use for + // buffered reading, then we can use it now to avoid a heap allocation + // when translating our `RocStr` to a null-terminated `char*`. + { + let path_len = roc_path.len(); + let path_fits_in_buf = path_len > BUF_BYTES; + let c_path: *mut c_char; + + if path_fits_in_buf { + roc_path.write_c_str(&mut buf as *mut u8); + + c_path = buf.as_mut_ptr() as *mut c_char; + } else { + c_path = roc_alloc(path_len, mem::align_of::() as u32) as *mut c_char; + + roc_path.write_c_str(c_path as *mut u8); + } + + fd = libc::open(c_path, libc::O_RDONLY); + + // Deallocate c_path now (if necessary) so we can safely do early returns + // from here on. + if !path_fits_in_buf { + roc_dealloc(c_path as *mut c_void, mem::align_of_val(&c_path) as u32); + } + } + + // We'll use our own position and libc::pread rather than using libc::read + // repeatedly and letting the fd store its own position. This way we don't + // have to worry about concurrent modifications of the fd's position. + let mut position = 0; + + // if libc::open returned -1, that means there was an error + if fd != -1 { + let mut list = RocList::empty(); + + loop { + let bytes_read = libc::pread(fd, buf.as_mut_ptr() as *mut c_void, BUF_BYTES, position); + + if bytes_read == BUF_BYTES as isize { + // The read was successful, and there may be more bytes to read. + // Append the bytes to the list and continue looping! + let slice = core::slice::from_raw_parts(buf.as_ptr(), bytes_read as usize); + + list.append_slice(slice); + } else if bytes_read >= 0 { + // The read was successful, and there are no more bytes + // to read (because bytes_read was less than the requested + // BUF_BYTES, but it was also not negative - which would have + // indicated an error). + let slice = core::slice::from_raw_parts(buf.as_ptr(), bytes_read as usize); + + list.append_slice(slice); + + // We're done! + return RocResult::Ok(list); + } else { + // bytes_read was negative, so we got a read error! + break; + } + + position += bytes_read as i64; + } + } + + RocResult::Err(errno()) +} + +#[no_mangle] +pub unsafe fn roc_fx_open(roc_path: RocStr) -> RocResult { + const BUF_BYTES: usize = 1024; + + // I know that since Rust 1.39 mem::uninitialized() is deprecated in favor + // of MaybeUninit, but I couldn't get this to work with MaybeUninit. + #[allow(deprecated)] + let mut buf: [u8; BUF_BYTES] = mem::uninitialized(); + + // If the path fits in the stack-allocated buffer, we can avoid a heap + // allocation when translating our `RocStr` to a null-terminated `char*`. + let path_len = roc_path.len(); + let path_fits_in_buf = path_len > BUF_BYTES; + let c_path: *mut c_char; + + if path_fits_in_buf { + roc_path.write_c_str(&mut buf as *mut u8); + + c_path = buf.as_mut_ptr() as *mut c_char; + } else { + c_path = roc_alloc(path_len, mem::align_of::() as u32) as *mut c_char; + + roc_path.write_c_str(c_path as *mut u8); + } + + let fd = libc::open(c_path, libc::O_RDONLY); + + // Now that the call to `open` is done, deallocate c_path if necessary> + if !path_fits_in_buf { + roc_dealloc(c_path as *mut c_void, mem::align_of_val(&c_path) as u32); + } + + // if libc::open returned -1, that means there was an error + if fd != -1 { + RocResult::Ok(Fd(fd)) + } else { + RocResult::Err(errno()) + } +} + +#[no_mangle] +pub unsafe fn roc_fx_read(fd: Fd, bytes: usize) -> RocResult, Errno> { + const BUF_BYTES: usize = 1024; + + // I know that since Rust 1.39 mem::uninitialized() is deprecated in favor + // of MaybeUninit, but I couldn't get this to work with MaybeUninit. + #[allow(deprecated)] + let mut buf: [u8; BUF_BYTES] = mem::uninitialized(); + + // We'll use our own position and libc::pread rather than using libc::read + // repeatedly and letting the fd store its own position. This way we don't + // have to worry about concurrent modifications of the fd's position. + let mut list = RocList::empty(); + let mut position: usize = 0; + + loop { + // Make sure we never read more than the buffer size, and also that + // we never read past the originally-requested number of bytes. + let bytes_to_read = BUF_BYTES.min(bytes - position); + let bytes_read = libc::pread( + fd.0, + buf.as_mut_ptr() as *mut c_void, + bytes_to_read, + position as i64, + ); + + if bytes_read == bytes_to_read as isize { + // The read was successful, and there may be more bytes to read. + // Append the bytes to the list and continue looping! + let slice = core::slice::from_raw_parts(buf.as_ptr(), bytes_read as usize); + + list.append_slice(slice); + } else if bytes_read >= 0 { + // The read was successful, and there are no more bytes + // to read (because bytes_read was less than the requested + // bytes_to_read, but it was also not negative - which would have + // indicated an error). + let slice = core::slice::from_raw_parts(buf.as_ptr(), bytes_read as usize); + + list.append_slice(slice); + + // We're done! + return RocResult::Ok(list); + } else { + // bytes_read was negative, so we got a read error! + break; + } + + position += bytes_read as usize; + } + + RocResult::Err(errno()) +} From a12b421e9aef6a931e8035057d0a72aa5de3ed83 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 17 Jun 2021 22:45:41 -0400 Subject: [PATCH 275/496] Drop roc_fx_readAll It's really not doing anything significant that roc_fx_open and roc_fx_read aren't already. --- examples/cli/platform/src/lib.rs | 78 -------------------------------- 1 file changed, 78 deletions(-) diff --git a/examples/cli/platform/src/lib.rs b/examples/cli/platform/src/lib.rs index 4140a2b3b4..672fcf5cce 100644 --- a/examples/cli/platform/src/lib.rs +++ b/examples/cli/platform/src/lib.rs @@ -163,84 +163,6 @@ pub fn rust_main() -> isize { /// A C file descriptor. pub struct Fd(c_int); -#[no_mangle] -pub unsafe fn roc_fx_readAll(roc_path: RocStr) -> RocResult, Errno> { - const BUF_BYTES: usize = 1024; - - // I know that since Rust 1.39 mem::uninitialized() is deprecated in favor - // of MaybeUninit, but I couldn't get this to work with MaybeUninit. - #[allow(deprecated)] - let mut buf: [u8; BUF_BYTES] = mem::uninitialized(); - let fd: c_int; - - // If the path fits in the stack-allocated buffer we'll later use for - // buffered reading, then we can use it now to avoid a heap allocation - // when translating our `RocStr` to a null-terminated `char*`. - { - let path_len = roc_path.len(); - let path_fits_in_buf = path_len > BUF_BYTES; - let c_path: *mut c_char; - - if path_fits_in_buf { - roc_path.write_c_str(&mut buf as *mut u8); - - c_path = buf.as_mut_ptr() as *mut c_char; - } else { - c_path = roc_alloc(path_len, mem::align_of::() as u32) as *mut c_char; - - roc_path.write_c_str(c_path as *mut u8); - } - - fd = libc::open(c_path, libc::O_RDONLY); - - // Deallocate c_path now (if necessary) so we can safely do early returns - // from here on. - if !path_fits_in_buf { - roc_dealloc(c_path as *mut c_void, mem::align_of_val(&c_path) as u32); - } - } - - // We'll use our own position and libc::pread rather than using libc::read - // repeatedly and letting the fd store its own position. This way we don't - // have to worry about concurrent modifications of the fd's position. - let mut position = 0; - - // if libc::open returned -1, that means there was an error - if fd != -1 { - let mut list = RocList::empty(); - - loop { - let bytes_read = libc::pread(fd, buf.as_mut_ptr() as *mut c_void, BUF_BYTES, position); - - if bytes_read == BUF_BYTES as isize { - // The read was successful, and there may be more bytes to read. - // Append the bytes to the list and continue looping! - let slice = core::slice::from_raw_parts(buf.as_ptr(), bytes_read as usize); - - list.append_slice(slice); - } else if bytes_read >= 0 { - // The read was successful, and there are no more bytes - // to read (because bytes_read was less than the requested - // BUF_BYTES, but it was also not negative - which would have - // indicated an error). - let slice = core::slice::from_raw_parts(buf.as_ptr(), bytes_read as usize); - - list.append_slice(slice); - - // We're done! - return RocResult::Ok(list); - } else { - // bytes_read was negative, so we got a read error! - break; - } - - position += bytes_read as i64; - } - } - - RocResult::Err(errno()) -} - #[no_mangle] pub unsafe fn roc_fx_open(roc_path: RocStr) -> RocResult { const BUF_BYTES: usize = 1024; From 8e526631c2e2692b0fc2df23e11818143e14728c Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 17 Jun 2021 22:47:39 -0400 Subject: [PATCH 276/496] Shrink buffer for RocStr path conversion --- examples/cli/platform/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/cli/platform/src/lib.rs b/examples/cli/platform/src/lib.rs index 672fcf5cce..e86a18ae93 100644 --- a/examples/cli/platform/src/lib.rs +++ b/examples/cli/platform/src/lib.rs @@ -165,7 +165,7 @@ pub struct Fd(c_int); #[no_mangle] pub unsafe fn roc_fx_open(roc_path: RocStr) -> RocResult { - const BUF_BYTES: usize = 1024; + const BUF_BYTES: usize = 256; // I know that since Rust 1.39 mem::uninitialized() is deprecated in favor // of MaybeUninit, but I couldn't get this to work with MaybeUninit. From aa687d96408a78028e3b22a0261fba38ac4d3416 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 17 Jun 2021 23:07:27 -0400 Subject: [PATCH 277/496] Use .add over .offset for usize pointer offsets --- roc_std/src/lib.rs | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/roc_std/src/lib.rs b/roc_std/src/lib.rs index 9a0ca23e51..ec7c8ac5ed 100644 --- a/roc_std/src/lib.rs +++ b/roc_std/src/lib.rs @@ -119,13 +119,13 @@ impl RocList { unsafe { if elem_alignment <= core::mem::align_of::() { - ptr.offset(1) as *const T + ptr.add(1) as *const T } else { // If elements have an alignment bigger than usize (e.g. an i128), // we will have necessarily allocated two usize slots worth of // space for the storage value (with the first usize slot being // padding for alignment's sake), and we need to skip past both. - ptr.offset(2) as *const T + ptr.add(2) as *const T } } } @@ -270,7 +270,7 @@ impl RocList { // Since this is an append, we want to start writing new elements // into the memory immediately after the current last element. - let dest = self.elements.offset(self.len() as isize); + let dest = self.elements.add(self.len()); // There's now enough storage to append the contents of the slice // in-place, so do that! @@ -304,9 +304,9 @@ impl PartialEq for RocList { return false; } - for i in 0..(self.length as isize) { + for i in 0..self.length { unsafe { - if *self.elements.offset(i) != *other.elements.offset(i) { + if *self.elements.add(i) != *other.elements.add(i) { return false; } } @@ -426,13 +426,13 @@ impl RocStr { unsafe { if elem_alignment <= core::mem::align_of::() { - ptr.offset(1) + ptr.add(1) } else { // If elements have an alignment bigger than usize (e.g. an i128), // we will have necessarily allocated two usize slots worth of // space for the storage value (with the first usize slot being // padding for alignment's sake), and we need to skip past both. - ptr.offset(2) + ptr.add(2) } } } @@ -485,9 +485,10 @@ impl RocStr { // NOTE: using a memcpy here causes weird issues let target_ptr = raw_ptr as *mut u8; let source_ptr = ptr as *const u8; - let length = slice.len() as isize; + let length = slice.len(); + for index in 0..length { - *target_ptr.offset(index) = *source_ptr.offset(index); + *target_ptr.add(index) = *source_ptr.add(index); } } From 6fe1d41c5549974600c646eca481fecaea8afaf1 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 17 Jun 2021 23:16:38 -0400 Subject: [PATCH 278/496] make clippy happy --- roc_std/src/lib.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/roc_std/src/lib.rs b/roc_std/src/lib.rs index ec7c8ac5ed..03796357d8 100644 --- a/roc_std/src/lib.rs +++ b/roc_std/src/lib.rs @@ -522,7 +522,11 @@ impl RocStr { } /// Write a CStr (null-terminated) representation of this RocStr into - /// the given buffer. Assumes the given buffer has enough space! + /// the given buffer. + /// + /// # Safety + /// This assumes the given buffer has enough space, so make sure you only + /// pass in a pointer to an allocation that's at least as long as this Str! pub unsafe fn write_c_str(&self, buf: *mut u8) -> *mut char { if self.is_small_str() { ptr::copy_nonoverlapping(self.get_small_str_ptr(), buf, self.len()); From 53ccef050611619524483a29ff52d3eb38758662 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 17 Jun 2021 23:14:32 -0400 Subject: [PATCH 279/496] nightly clippy I was on nightly for benchmarks, and these all seem reasonable. --- compiler/can/src/def.rs | 14 ++++++------ compiler/gen_dev/src/generic64/x86_64.rs | 28 ++++++++++------------- compiler/gen_llvm/src/lib.rs | 2 +- compiler/gen_llvm/src/llvm/refcounting.rs | 2 +- compiler/module/src/symbol.rs | 4 ++-- compiler/mono/src/expand_rc.rs | 12 ++++------ compiler/parse/src/ast.rs | 2 +- compiler/test_gen/src/lib.rs | 2 +- compiler/types/src/pretty_print.rs | 7 +++--- compiler/types/src/subs.rs | 2 +- editor/src/ui/text/selection.rs | 6 ++--- roc_std/src/lib.rs | 2 +- 12 files changed, 36 insertions(+), 47 deletions(-) diff --git a/compiler/can/src/def.rs b/compiler/can/src/def.rs index 6f464cda1a..b4a4652924 100644 --- a/compiler/can/src/def.rs +++ b/compiler/can/src/def.rs @@ -561,14 +561,14 @@ pub fn sort_can_defs( ))); declarations.push(Declaration::InvalidCycle(entries)); - - // other groups may depend on the symbols defined here, so - // also push this cycle onto the groups - groups.push(cycle); - } else { - // slightly inefficient, because we know this becomes exactly one DeclareRec already - groups.push(cycle); } + + // if it's an invalid cycle, other groups may depend on the + // symbols defined here, so also push this cycle onto the groups + // + // if it's not an invalid cycle, this is slightly inefficient, + // because we know this becomes exactly one DeclareRec already + groups.push(cycle); } // now we have a collection of groups whose dependencies are not cyclic. diff --git a/compiler/gen_dev/src/generic64/x86_64.rs b/compiler/gen_dev/src/generic64/x86_64.rs index 53345db889..67ae107b5a 100644 --- a/compiler/gen_dev/src/generic64/x86_64.rs +++ b/compiler/gen_dev/src/generic64/x86_64.rs @@ -765,12 +765,11 @@ impl Assembler for X86_64Assembler { src1: X86_64GeneralReg, imm32: i32, ) { - if dst == src1 { - add_reg64_imm32(buf, dst, imm32); - } else { + if dst != src1 { mov_reg64_reg64(buf, dst, src1); - add_reg64_imm32(buf, dst, imm32); } + + add_reg64_imm32(buf, dst, imm32); } #[inline(always)] fn add_reg64_reg64_reg64( @@ -821,12 +820,11 @@ impl Assembler for X86_64Assembler { src1: X86_64GeneralReg, src2: X86_64GeneralReg, ) { - if dst == src1 { - imul_reg64_reg64(buf, dst, src2); - } else { + if dst != src1 { mov_reg64_reg64(buf, dst, src1); - imul_reg64_reg64(buf, dst, src2); } + + imul_reg64_reg64(buf, dst, src2); } #[inline(always)] @@ -926,12 +924,11 @@ impl Assembler for X86_64Assembler { src1: X86_64GeneralReg, imm32: i32, ) { - if dst == src1 { - sub_reg64_imm32(buf, dst, imm32); - } else { + if dst != src1 { mov_reg64_reg64(buf, dst, src1); - sub_reg64_imm32(buf, dst, imm32); } + + sub_reg64_imm32(buf, dst, imm32); } #[inline(always)] fn sub_reg64_reg64_reg64( @@ -940,12 +937,11 @@ impl Assembler for X86_64Assembler { src1: X86_64GeneralReg, src2: X86_64GeneralReg, ) { - if dst == src1 { - sub_reg64_reg64(buf, dst, src2); - } else { + if dst != src1 { mov_reg64_reg64(buf, dst, src1); - sub_reg64_reg64(buf, dst, src2); } + + sub_reg64_reg64(buf, dst, src2); } #[inline(always)] diff --git a/compiler/gen_llvm/src/lib.rs b/compiler/gen_llvm/src/lib.rs index 092cf0b8a8..bef97f894c 100644 --- a/compiler/gen_llvm/src/lib.rs +++ b/compiler/gen_llvm/src/lib.rs @@ -2,7 +2,7 @@ // See github.com/rtfeldman/roc/issues/800 for discussion of the large_enum_variant check. #![allow(clippy::large_enum_variant)] // we actually want to compare against the literal float bits -#![allow(clippy::clippy::float_cmp)] +#![allow(clippy::float_cmp)] pub mod llvm; diff --git a/compiler/gen_llvm/src/llvm/refcounting.rs b/compiler/gen_llvm/src/llvm/refcounting.rs index f18fb6221b..773b02e9cf 100644 --- a/compiler/gen_llvm/src/llvm/refcounting.rs +++ b/compiler/gen_llvm/src/llvm/refcounting.rs @@ -1184,7 +1184,7 @@ pub enum Mode { } impl Mode { - fn to_call_mode<'ctx>(&self, function: FunctionValue<'ctx>) -> CallMode<'ctx> { + fn to_call_mode(self, function: FunctionValue<'_>) -> CallMode<'_> { match self { Mode::Inc => { let amount = function.get_nth_param(1).unwrap().into_int_value(); diff --git a/compiler/module/src/symbol.rs b/compiler/module/src/symbol.rs index bbd23db74e..f56c5799f7 100644 --- a/compiler/module/src/symbol.rs +++ b/compiler/module/src/symbol.rs @@ -278,10 +278,10 @@ impl ModuleId { // This is a no-op that should get DCE'd } - pub fn to_string<'a>(&self, interns: &'a Interns) -> &'a InlinableString { + pub fn to_string(self, interns: &Interns) -> &InlinableString { interns .module_ids - .get_name(*self) + .get_name(self) .unwrap_or_else(|| panic!("Could not find ModuleIds for {:?}", self)) } } diff --git a/compiler/mono/src/expand_rc.rs b/compiler/mono/src/expand_rc.rs index 2d60e6a213..4fd274ed55 100644 --- a/compiler/mono/src/expand_rc.rs +++ b/compiler/mono/src/expand_rc.rs @@ -397,19 +397,15 @@ pub fn expand_and_cancel_proc<'a>( fn expand_and_cancel<'a>(env: &mut Env<'a, '_>, stmt: &'a Stmt<'a>) -> &'a Stmt<'a> { use Stmt::*; - let mut deferred_default = Deferred { + let mut deferred = Deferred { inc_dec_map: Default::default(), assignments: Vec::new_in(env.arena), decrefs: Vec::new_in(env.arena), }; - let deferred = if can_push_inc_through(stmt) { - deferred_default - } else { - std::mem::swap(&mut deferred_default, &mut env.deferred); - - deferred_default - }; + if !can_push_inc_through(stmt) { + std::mem::swap(&mut deferred, &mut env.deferred); + } let mut result = { match stmt { diff --git a/compiler/parse/src/ast.rs b/compiler/parse/src/ast.rs index 5a0ade9458..c9bb622e47 100644 --- a/compiler/parse/src/ast.rs +++ b/compiler/parse/src/ast.rs @@ -44,7 +44,7 @@ pub enum EscapedChar { impl EscapedChar { /// Returns the char that would have been originally parsed to - pub fn to_parsed_char(&self) -> char { + pub fn to_parsed_char(self) -> char { use EscapedChar::*; match self { diff --git a/compiler/test_gen/src/lib.rs b/compiler/test_gen/src/lib.rs index 8f1630351a..8aaaf93648 100644 --- a/compiler/test_gen/src/lib.rs +++ b/compiler/test_gen/src/lib.rs @@ -2,7 +2,7 @@ // See github.com/rtfeldman/roc/issues/800 for discussion of the large_enum_variant check. #![allow(clippy::large_enum_variant)] // we actually want to compare against the literal float bits -#![allow(clippy::clippy::float_cmp)] +#![allow(clippy::float_cmp)] pub mod gen_compare; pub mod gen_dict; diff --git a/compiler/types/src/pretty_print.rs b/compiler/types/src/pretty_print.rs index 2b9ac83553..8df08669d1 100644 --- a/compiler/types/src/pretty_print.rs +++ b/compiler/types/src/pretty_print.rs @@ -756,11 +756,10 @@ fn write_symbol(env: &Env, symbol: Symbol, buf: &mut String) { // Don't qualify the symbol if it's in our home module, // or if it's a builtin (since all their types are always in scope) - if module_id == env.home || module_id.is_builtin() { - buf.push_str(ident); - } else { + if module_id != env.home && !module_id.is_builtin() { buf.push_str(module_id.to_string(&interns)); buf.push('.'); - buf.push_str(ident); } + + buf.push_str(ident); } diff --git a/compiler/types/src/subs.rs b/compiler/types/src/subs.rs index 29a834378e..e66ad7fb12 100644 --- a/compiler/types/src/subs.rs +++ b/compiler/types/src/subs.rs @@ -132,7 +132,7 @@ impl OptVariable { impl fmt::Debug for OptVariable { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - self.clone().into_variable().fmt(f) + (*self).into_variable().fmt(f) } } diff --git a/editor/src/ui/text/selection.rs b/editor/src/ui/text/selection.rs index 03a959f986..70376b6c86 100644 --- a/editor/src/ui/text/selection.rs +++ b/editor/src/ui/text/selection.rs @@ -98,8 +98,6 @@ pub fn create_selection_rects<'a>( height, color: theme.select_highlight, }); - - Ok(all_rects) } else { // first line let end_col = lines.line_len(start_pos.line)?; @@ -148,7 +146,7 @@ pub fn create_selection_rects<'a>( color: theme.select_highlight, }); } - - Ok(all_rects) } + + Ok(all_rects) } diff --git a/roc_std/src/lib.rs b/roc_std/src/lib.rs index 03796357d8..b54fd6c7b9 100644 --- a/roc_std/src/lib.rs +++ b/roc_std/src/lib.rs @@ -535,7 +535,7 @@ impl RocStr { } // null-terminate - *(buf.offset(self.len() as isize)) = 0; + *(buf.add(self.len())) = 0; buf as *mut char } From 88aa8318f1c39b84845a92b27adc2a35a8485a1b Mon Sep 17 00:00:00 2001 From: Jared Ramirez Date: Fri, 18 Jun 2021 12:50:15 -0700 Subject: [PATCH 280/496] Refactor RocDec.toStr --- compiler/builtins/bitcode/src/dec.zig | 130 ++++++++++++-------------- 1 file changed, 58 insertions(+), 72 deletions(-) diff --git a/compiler/builtins/bitcode/src/dec.zig b/compiler/builtins/bitcode/src/dec.zig index 3ebb6ba542..14d723ae6b 100644 --- a/compiler/builtins/bitcode/src/dec.zig +++ b/compiler/builtins/bitcode/src/dec.zig @@ -7,9 +7,10 @@ const RocStr = str.RocStr; pub const RocDec = struct { num: i128, - pub const decimal_places: comptime u32 = 18; - pub const whole_number_places: comptime u32 = 21; - const max_digits: comptime u32 = decimal_places + whole_number_places; + pub const decimal_places: comptime u5 = 18; + pub const whole_number_places: comptime u5 = 21; + const max_digits: comptime u6 = 39; + const leading_zeros: comptime [17]u8 = "00000000000000000".*; pub const min: comptime RocDec = .{ .num = math.minInt(i128) }; pub const max: comptime RocDec = .{ .num = math.maxInt(i128) }; @@ -21,7 +22,6 @@ pub const RocDec = struct { return .{ .num = num * one_point_zero_i128 }; } - // TODO: Refactor this to use https://ziglang.org/documentation/master/#ctz pub fn fromStr(roc_str: RocStr) ?RocDec { if (roc_str.isEmpty()) { return null; @@ -104,15 +104,16 @@ pub const RocDec = struct { return dec; } - // TODO: Replace this with https://github.com/rtfeldman/roc/pull/1365/files#r643580738 fn isDigit(c: u8) bool { - return switch (c) { - '0'...'9' => true, - else => false, - }; + return (c -% 48) <= 9; } pub fn toStr(self: RocDec) ?RocStr { + // Special case + if (self.num == 0) { + return RocStr.init("0.0", 3); + } + // Check if this Dec is negative, and if so convert to positive // We will handle adding the '-' later const is_negative = self.num < 0; @@ -122,80 +123,70 @@ pub const RocDec = struct { // Format the backing i128 into an array of digits (u8s) var digit_bytes: [max_digits + 1]u8 = undefined; - var num_digits_formatted = std.fmt.formatIntBuf(digit_bytes[0..], num, 10, false, .{}); + var num_digits = std.fmt.formatIntBuf(digit_bytes[0..], num, 10, false, .{}); - // If self < 1, then pad digit_bytes with '0' to be at least 18 digits - if (num_digits_formatted < decimal_places) { - var diff = decimal_places - num_digits_formatted; - var padded_digit_bytes: [max_digits + 1]u8 = undefined; - var index: usize = 0; - - while (index < decimal_places) { - if (index < diff) { - padded_digit_bytes[index] = '0'; - } else { - padded_digit_bytes[index] = digit_bytes[index - diff]; - } - index += 1; - } - num_digits_formatted = num_digits_formatted + diff; - digit_bytes = padded_digit_bytes; - } - - // Get the slice of the part before the decimal - // If this is empty, then hardcode a '0' - var before_digits_num_raw: usize = undefined; - var before_digits_slice: []const u8 = undefined; - if (num_digits_formatted > decimal_places) { - before_digits_num_raw = num_digits_formatted - decimal_places; - before_digits_slice = digit_bytes[0..before_digits_num_raw]; + // Get the slice for before the decimal point + var before_digits_slice_t: []const u8 = undefined; + var before_digits_offset: usize = 0; + var before_digits_adjust: u6 = 0; + if (num_digits > decimal_places) { + before_digits_offset = num_digits - decimal_places; + before_digits_slice_t = digit_bytes[0..before_digits_offset]; } else { - before_digits_num_raw = 0; - before_digits_slice = "0"; + before_digits_adjust = @intCast(u6, math.absInt(@intCast(i7, num_digits) - decimal_places) catch { + std.debug.panic("TODO runtime exception for overflow when getting abs", .{}); + }); + before_digits_slice_t = "0"; } - // Figure out the index where the trailing zeros start - var index = decimal_places - 1; - var trim_index: ?usize = null; + // Figure out how many trailing zeros there are + // I tried to use https://ziglang.org/documentation/0.8.0/#ctz and it mostly worked, + // but was giving seemingly incorrect values for certain numbers. So instead we use + // a while loop and figure it out that way. + // + // const trailing_zeros = @ctz(u6, num); + // + var trailing_zeros: u6 = 0; + var index = decimal_places - 1 - before_digits_adjust; var is_consecutive_zero = true; while (index != 0) { - var digit = digit_bytes[before_digits_num_raw + index]; - // 48 => '0', 170 => '' - if ((digit == 48 or digit == 170) and is_consecutive_zero) { - trim_index = index; + var digit = digit_bytes[before_digits_offset + index]; + if (digit == '0' and is_consecutive_zero) { + trailing_zeros += 1; } else { is_consecutive_zero = false; } index -= 1; } - // Get the slice of the part afterthe decimal - var after_digits_slice: []const u8 = undefined; - after_digits_slice = digit_bytes[before_digits_num_raw..(before_digits_num_raw + if (trim_index) |i| i else decimal_places)]; + // Figure out if we need to prepend any zeros to the after decimal point + // For example, for the number 1.00023 we need to prepend 3 zeros after the decimal point + const after_zeros_num = if (num_digits < decimal_places) decimal_places - num_digits else 0; + const after_zeros_slice: []const u8 = leading_zeros[0..after_zeros_num]; - // Make the RocStr - - var sign_len: usize = if (is_negative) 1 else 0; - var dot_len: usize = 1; - var str_len: usize = sign_len + before_digits_slice.len + dot_len + after_digits_slice.len; - - // TODO: Ideally we'd use [str_len]u8 here, but Zig gives an error if we do that. - // [max_digits + 2]u8 here to account for '.' and '-', aka the max possible length of the string - var str_bytes: [max_digits + 2]u8 = undefined; - - // Join the whole number slice & the decimal slice together - // The format template arg in bufPrint is `comptime`, so we have to repeate the whole statement in each branch - if (is_negative) { - _ = std.fmt.bufPrint(str_bytes[0 .. str_len + 1], "-{s}.{s}", .{ before_digits_slice, after_digits_slice }) catch { - std.debug.panic("TODO runtime exception failing to print slices", .{}); - }; + // Get the slice for after the decimal point + var after_digits_slice_t: []const u8 = undefined; + if ((num_digits - before_digits_offset) == trailing_zeros) { + after_digits_slice_t = "0"; } else { - _ = std.fmt.bufPrint(str_bytes[0 .. str_len + 1], "{s}.{s}", .{ before_digits_slice, after_digits_slice }) catch { - std.debug.panic("TODO runtime exception failing to print slices", .{}); - }; + after_digits_slice_t = digit_bytes[before_digits_offset .. num_digits - trailing_zeros]; } - return RocStr.init(&str_bytes, str_len); + // Get the slice for the sign + const sign_slice: []const u8 = if (is_negative) "-" else leading_zeros[0..0]; + + // Hardcode adding a `1` for the '.' character + const str_len_t: usize = sign_slice.len + before_digits_slice_t.len + 1 + after_zeros_slice.len + after_digits_slice_t.len; + + // Join the slices together + // We do `max_digits + 2` here becuase we need to account for a possible sign ('-') and the dot ('.'). + // Ideally, we'd use str_len_t here + var str_bytes_t: [max_digits + 2]u8 = undefined; + _ = std.fmt.bufPrint(str_bytes_t[0..str_len_t], "{s}{s}.{s}{s}", .{ sign_slice, before_digits_slice_t, after_zeros_slice, after_digits_slice_t }) catch { + std.debug.panic("TODO runtime exception failing to print slices", .{}); + }; + + return RocStr.init(&str_bytes_t, str_len_t); } pub fn negate(self: RocDec) ?RocDec { @@ -648,11 +639,6 @@ fn div_u256_by_u128(numer: U256, denom: u128) U256 { return .{ .hi = hi, .lo = lo }; } -fn num_of_trailing_zeros(num: u128) u32 { - const trailing: u8 = @ctz(u128, num); - return @intCast(u32, trailing); -} - const testing = std.testing; const expectEqual = testing.expectEqual; const expectError = testing.expectError; From 586851875817d144087c9e27e10494b88f5770e7 Mon Sep 17 00:00:00 2001 From: Jared Ramirez Date: Fri, 18 Jun 2021 12:50:44 -0700 Subject: [PATCH 281/496] Add basic Dec.roc docs --- compiler/builtins/docs/Dec.roc | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 compiler/builtins/docs/Dec.roc diff --git a/compiler/builtins/docs/Dec.roc b/compiler/builtins/docs/Dec.roc new file mode 100644 index 0000000000..80ae68d8a3 --- /dev/null +++ b/compiler/builtins/docs/Dec.roc @@ -0,0 +1,23 @@ +interface Dec + exposes [ add, sub, mul, div, toStr, fromStr ] + imports [ Str ] + +## Add two Dec together +add : Dec -> Dec -> Dec + +## Subtract the second Dec from the first +sub : Dec -> Dec -> Dec + +## Multiply two Dec together +mul : Dec -> Dec -> Dec + +## Divide the first Dec by the second Dec +div : Dec -> Dec -> Dec + +## Convert a Dec to a Str +## If the Dec is less than 0, this will prefix the Str with `0.` +## If the Dec has no parts after the decimal point, this will suffix the Str with `.0` +toStr : Dec -> Str + +## Convert Str to a Decimal +fromStr : Str -> Result Dec [ InvalidDec ]* From 711daee650ce5bc602de3856f516e79bc23f0171 Mon Sep 17 00:00:00 2001 From: Jared Ramirez Date: Fri, 18 Jun 2021 12:53:09 -0700 Subject: [PATCH 282/496] Fix variable names & clarify comments --- compiler/builtins/bitcode/src/dec.zig | 27 ++++++++++++++------------- 1 file changed, 14 insertions(+), 13 deletions(-) diff --git a/compiler/builtins/bitcode/src/dec.zig b/compiler/builtins/bitcode/src/dec.zig index 14d723ae6b..1aa38da759 100644 --- a/compiler/builtins/bitcode/src/dec.zig +++ b/compiler/builtins/bitcode/src/dec.zig @@ -126,17 +126,17 @@ pub const RocDec = struct { var num_digits = std.fmt.formatIntBuf(digit_bytes[0..], num, 10, false, .{}); // Get the slice for before the decimal point - var before_digits_slice_t: []const u8 = undefined; + var before_digits_slice: []const u8 = undefined; var before_digits_offset: usize = 0; var before_digits_adjust: u6 = 0; if (num_digits > decimal_places) { before_digits_offset = num_digits - decimal_places; - before_digits_slice_t = digit_bytes[0..before_digits_offset]; + before_digits_slice = digit_bytes[0..before_digits_offset]; } else { before_digits_adjust = @intCast(u6, math.absInt(@intCast(i7, num_digits) - decimal_places) catch { std.debug.panic("TODO runtime exception for overflow when getting abs", .{}); }); - before_digits_slice_t = "0"; + before_digits_slice = "0"; } // Figure out how many trailing zeros there are @@ -160,33 +160,34 @@ pub const RocDec = struct { } // Figure out if we need to prepend any zeros to the after decimal point - // For example, for the number 1.00023 we need to prepend 3 zeros after the decimal point + // For example, for the number 0.000123 we need to prepend 3 zeros after the decimal point + // This will only be needed for numbers less 0.01, otherwise after_digits_slice will handle this const after_zeros_num = if (num_digits < decimal_places) decimal_places - num_digits else 0; const after_zeros_slice: []const u8 = leading_zeros[0..after_zeros_num]; // Get the slice for after the decimal point - var after_digits_slice_t: []const u8 = undefined; + var after_digits_slice: []const u8 = undefined; if ((num_digits - before_digits_offset) == trailing_zeros) { - after_digits_slice_t = "0"; + after_digits_slice = "0"; } else { - after_digits_slice_t = digit_bytes[before_digits_offset .. num_digits - trailing_zeros]; + after_digits_slice = digit_bytes[before_digits_offset .. num_digits - trailing_zeros]; } // Get the slice for the sign const sign_slice: []const u8 = if (is_negative) "-" else leading_zeros[0..0]; // Hardcode adding a `1` for the '.' character - const str_len_t: usize = sign_slice.len + before_digits_slice_t.len + 1 + after_zeros_slice.len + after_digits_slice_t.len; + const str_len: usize = sign_slice.len + before_digits_slice.len + 1 + after_zeros_slice.len + after_digits_slice.len; // Join the slices together - // We do `max_digits + 2` here becuase we need to account for a possible sign ('-') and the dot ('.'). - // Ideally, we'd use str_len_t here - var str_bytes_t: [max_digits + 2]u8 = undefined; - _ = std.fmt.bufPrint(str_bytes_t[0..str_len_t], "{s}{s}.{s}{s}", .{ sign_slice, before_digits_slice_t, after_zeros_slice, after_digits_slice_t }) catch { + // We do `max_digits + 2` here because we need to account for a possible sign ('-') and the dot ('.'). + // Ideally, we'd use str_len here + var str_bytes: [max_digits + 2]u8 = undefined; + _ = std.fmt.bufPrint(str_bytes[0..str_len], "{s}{s}.{s}{s}", .{ sign_slice, before_digits_slice, after_zeros_slice, after_digits_slice }) catch { std.debug.panic("TODO runtime exception failing to print slices", .{}); }; - return RocStr.init(&str_bytes_t, str_len_t); + return RocStr.init(&str_bytes, str_len); } pub fn negate(self: RocDec) ?RocDec { From daa137467836b92d5c7d644fb0d391342303183e Mon Sep 17 00:00:00 2001 From: Folkert Date: Fri, 18 Jun 2021 21:58:50 +0200 Subject: [PATCH 283/496] remove full_layout field --- compiler/mono/src/alias_analysis.rs | 1 - compiler/mono/src/ir.rs | 19 ------------------- 2 files changed, 20 deletions(-) diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 845b0313c4..ebba54fb80 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -445,7 +445,6 @@ fn call_spec( match &call.call_type { ByName { name: symbol, - full_layout: _, ret_layout, arg_layouts, specialization_id, diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index ebfb981698..3138184873 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -1136,7 +1136,6 @@ impl UpdateModeId { pub enum CallType<'a> { ByName { name: Symbol, - full_layout: Layout<'a>, ret_layout: Layout<'a>, arg_layouts: &'a [Layout<'a>], specialization_id: CallSpecId, @@ -5459,13 +5458,11 @@ fn substitute_in_call<'a>( name, arg_layouts, ret_layout, - full_layout, specialization_id, } => substitute(subs, *name).map(|new| CallType::ByName { name: new, arg_layouts, ret_layout: *ret_layout, - full_layout: *full_layout, specialization_id: *specialization_id, }), CallType::Foreign { .. } => None, @@ -5928,13 +5925,10 @@ fn force_thunk<'a>( assigned: Symbol, hole: &'a Stmt<'a>, ) -> Stmt<'a> { - let full_layout = Layout::FunctionPointer(&[], env.arena.alloc(layout)); - let call = self::Call { call_type: CallType::ByName { name: thunk_name, ret_layout: layout, - full_layout, arg_layouts: &[], specialization_id: env.next_call_specialization_id(), }, @@ -6394,7 +6388,6 @@ fn call_by_name_help<'a>( // debug_assert!(!procs.module_thunks.contains(&proc_name), "{:?}", proc_name); let top_level_layout = TopLevelFunctionLayout::new(env.arena, argument_layouts, *ret_layout); - let function_layout = env.arena.alloc(top_level_layout).full(); // the arguments given to the function, stored in symbols let field_symbols = Vec::from_iter_in( @@ -6436,7 +6429,6 @@ fn call_by_name_help<'a>( call_type: CallType::ByName { name: proc_name, ret_layout: *ret_layout, - full_layout: function_layout, arg_layouts: argument_layouts, specialization_id: env.next_call_specialization_id(), }, @@ -6469,7 +6461,6 @@ fn call_by_name_help<'a>( call_type: CallType::ByName { name: proc_name, ret_layout: *ret_layout, - full_layout: function_layout, arg_layouts: argument_layouts, specialization_id: env.next_call_specialization_id(), }, @@ -6522,7 +6513,6 @@ fn call_by_name_help<'a>( call_type: CallType::ByName { name: proc_name, ret_layout: *ret_layout, - full_layout: function_layout, arg_layouts: argument_layouts, specialization_id: env.next_call_specialization_id(), }, @@ -6773,7 +6763,6 @@ fn call_specialized_proc<'a>( call_type: CallType::ByName { name: proc_name, ret_layout: function_layout.result, - full_layout: function_layout.full(), arg_layouts: function_layout.arguments, specialization_id: env.next_call_specialization_id(), }, @@ -6793,7 +6782,6 @@ fn call_specialized_proc<'a>( call_type: CallType::ByName { name: proc_name, ret_layout: function_layout.result, - full_layout: function_layout.full(), arg_layouts: function_layout.arguments, specialization_id: env.next_call_specialization_id(), }, @@ -6817,7 +6805,6 @@ fn call_specialized_proc<'a>( call_type: CallType::ByName { name: proc_name, ret_layout: function_layout.result, - full_layout: function_layout.full(), arg_layouts: function_layout.arguments, specialization_id: env.next_call_specialization_id(), }, @@ -8089,13 +8076,10 @@ fn union_lambda_set_branch_help<'a>( } }; - let full_layout = Layout::FunctionPointer(argument_layouts, env.arena.alloc(return_layout)); - // build the call let call = self::Call { call_type: CallType::ByName { name: function_symbol, - full_layout, ret_layout: return_layout, arg_layouts: argument_layouts, specialization_id: env.next_call_specialization_id(), @@ -8210,12 +8194,9 @@ fn enum_lambda_set_branch<'a>( } }; - let full_layout = Layout::FunctionPointer(argument_layouts, env.arena.alloc(return_layout)); - let call = self::Call { call_type: CallType::ByName { name: function_symbol, - full_layout, ret_layout: return_layout, arg_layouts: argument_layouts, specialization_id: env.next_call_specialization_id(), From fe81eabbfa25d1ace8b6661a4c76c691bfea0282 Mon Sep 17 00:00:00 2001 From: Folkert Date: Fri, 18 Jun 2021 22:08:42 +0200 Subject: [PATCH 284/496] remove full() function --- cli/src/repl/eval.rs | 12 ++++++++---- cli/src/repl/gen.rs | 2 +- compiler/gen_llvm/src/llvm/build.rs | 4 ++-- compiler/mono/src/ir.rs | 6 +----- 4 files changed, 12 insertions(+), 12 deletions(-) diff --git a/cli/src/repl/eval.rs b/cli/src/repl/eval.rs index 89fd30e74f..ef6dfec3a4 100644 --- a/cli/src/repl/eval.rs +++ b/cli/src/repl/eval.rs @@ -6,6 +6,7 @@ use roc_gen_llvm::{run_jit_function, run_jit_function_dynamic_type}; use roc_module::ident::{Lowercase, TagName}; use roc_module::operator::CalledVia; use roc_module::symbol::{Interns, ModuleId, Symbol}; +use roc_mono::ir::TopLevelFunctionLayout; use roc_mono::layout::{union_sorted_tags_help, Builtin, Layout, UnionLayout, UnionVariant}; use roc_parse::ast::{AssignedField, Expr, StrLiteral}; use roc_region::all::{Located, Region}; @@ -37,7 +38,7 @@ pub unsafe fn jit_to_ast<'a>( arena: &'a Bump, lib: Library, main_fn_name: &str, - layout: &Layout<'a>, + layout: TopLevelFunctionLayout<'a>, content: &Content, interns: &Interns, home: ModuleId, @@ -53,11 +54,14 @@ pub unsafe fn jit_to_ast<'a>( }; match layout { - Layout::FunctionPointer(&[], result) => { + TopLevelFunctionLayout { + arguments: [], + result, + } => { // this is a thunk - jit_to_ast_help(&env, lib, main_fn_name, result, content) + jit_to_ast_help(&env, lib, main_fn_name, &result, content) } - _ => jit_to_ast_help(&env, lib, main_fn_name, layout, content), + _ => Err(ToAstProblem::FunctionLayout), } } diff --git a/cli/src/repl/gen.rs b/cli/src/repl/gen.rs index 699d244908..797fdba999 100644 --- a/cli/src/repl/gen.rs +++ b/cli/src/repl/gen.rs @@ -226,7 +226,7 @@ pub fn gen_and_eval<'a>( &arena, lib, main_fn_name, - &arena.alloc(main_fn_layout).full(), + main_fn_layout, &content, &env.interns, home, diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index d2beab5002..6b65b7d985 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -118,7 +118,7 @@ impl<'ctx> Iterator for FunctionIterator<'ctx> { #[derive(Default, Debug, Clone, PartialEq)] pub struct Scope<'a, 'ctx> { symbols: ImMap, BasicValueEnum<'ctx>)>, - pub top_level_thunks: ImMap, FunctionValue<'ctx>)>, + pub top_level_thunks: ImMap, FunctionValue<'ctx>)>, join_points: ImMap, &'a [PointerValue<'ctx>])>, } @@ -136,7 +136,7 @@ impl<'a, 'ctx> Scope<'a, 'ctx> { function_value: FunctionValue<'ctx>, ) { self.top_level_thunks - .insert(symbol, (layout.full(), function_value)); + .insert(symbol, (*layout, function_value)); } fn remove(&mut self, symbol: &Symbol) { self.symbols.remove(symbol); diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 3138184873..ff8a92d886 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -2624,10 +2624,6 @@ impl<'a> TopLevelFunctionLayout<'a> { }, } } - - pub fn full(&'a self) -> Layout<'a> { - Layout::FunctionPointer(self.arguments, &self.result) - } } fn specialize_naked_symbol<'a>( @@ -6788,7 +6784,7 @@ fn call_specialized_proc<'a>( arguments: field_symbols, }; - build_call(env, call, assigned, function_layout.full(), hole) + build_call(env, call, assigned, function_layout.result, hole) } } } else { From 4256c2200440c2fc99cc87da98f14058a4015dcc Mon Sep 17 00:00:00 2001 From: Folkert Date: Fri, 18 Jun 2021 22:25:31 +0200 Subject: [PATCH 285/496] more toplevel --- compiler/gen_dev/src/object_builder.rs | 9 ++- compiler/gen_dev/tests/helpers/eval.rs | 15 ++--- compiler/mono/src/ir.rs | 74 +----------------------- compiler/mono/src/layout.rs | 79 ++++++++++++++++++++++++++ 4 files changed, 90 insertions(+), 87 deletions(-) diff --git a/compiler/gen_dev/src/object_builder.rs b/compiler/gen_dev/src/object_builder.rs index 03bbc854de..c2ccda29d2 100644 --- a/compiler/gen_dev/src/object_builder.rs +++ b/compiler/gen_dev/src/object_builder.rs @@ -9,8 +9,7 @@ use object::{ }; use roc_collections::all::MutMap; use roc_module::symbol; -use roc_mono::ir::Proc; -use roc_mono::layout::Layout; +use roc_mono::ir::{Proc, TopLevelFunctionLayout}; use target_lexicon::{Architecture as TargetArch, BinaryFormat as TargetBF, Triple}; // This is used by some code below which is currently commented out. @@ -22,7 +21,7 @@ use target_lexicon::{Architecture as TargetArch, BinaryFormat as TargetBF, Tripl pub fn build_module<'a>( env: &'a Env, target: &Triple, - procedures: MutMap<(symbol::Symbol, Layout<'a>), Proc<'a>>, + procedures: MutMap<(symbol::Symbol, TopLevelFunctionLayout<'a>), Proc<'a>>, ) -> Result { match target { Triple { @@ -145,7 +144,7 @@ fn generate_wrapper<'a, B: Backend<'a>>( fn build_object<'a, B: Backend<'a>>( env: &'a Env, - procedures: MutMap<(symbol::Symbol, Layout<'a>), Proc<'a>>, + procedures: MutMap<(symbol::Symbol, TopLevelFunctionLayout<'a>), Proc<'a>>, mut backend: B, mut output: Object, ) -> Result { @@ -187,7 +186,7 @@ fn build_object<'a, B: Backend<'a>>( let mut procs = Vec::with_capacity_in(procedures.len(), env.arena); for ((sym, layout), proc) in procedures { let fn_name = layout_ids - .get(sym, &layout) + .get_toplevel(sym, &layout) .to_symbol_string(sym, &env.interns); let section_id = output.add_section( diff --git a/compiler/gen_dev/tests/helpers/eval.rs b/compiler/gen_dev/tests/helpers/eval.rs index 9800444959..f3403bb9d4 100644 --- a/compiler/gen_dev/tests/helpers/eval.rs +++ b/compiler/gen_dev/tests/helpers/eval.rs @@ -69,8 +69,8 @@ pub fn helper<'a>( let mut procedures = MutMap::default(); - for ((symbol, top_level), proc) in top_procedures { - procedures.insert((symbol, arena.alloc(top_level).full()), proc); + for (key, proc) in top_procedures { + procedures.insert(key, proc); } /* @@ -87,17 +87,12 @@ pub fn helper<'a>( println!("=================================\n"); */ debug_assert_eq!(exposed_to_host.len(), 1); - let main_fn_symbol = exposed_to_host.keys().copied().next().unwrap(); - - let main_fn_layout = procedures - .keys() - .find(|(s, _)| *s == main_fn_symbol) - .map(|t| t.1) - .unwrap(); + let main_fn_symbol = loaded.entry_point.symbol; + let main_fn_layout = loaded.entry_point.layout; let mut layout_ids = roc_mono::layout::LayoutIds::default(); let main_fn_name = layout_ids - .get(main_fn_symbol, &main_fn_layout) + .get_toplevel(main_fn_symbol, &main_fn_layout) .to_symbol_string(main_fn_symbol, &interns); let mut lines = Vec::new(); diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index ff8a92d886..c5a9ad2e14 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -3694,7 +3694,7 @@ pub fn with_hole<'a>( } => { let loc_body = *boxed_body; - match layout_cache.from_var(env.arena, function_type, env.subs) { + match layout_cache.raw_from_var(env.arena, function_type, env.subs) { Err(e) => panic!("invalid layout {:?}", e), Ok(Layout::Closure(_argument_layouts, lambda_set, _ret_layout)) => { let mut captured_symbols = Vec::from_iter_in(captured_symbols, env.arena); @@ -3731,43 +3731,6 @@ pub fn with_hole<'a>( construct_closure_data(env, lambda_set, name, symbols, assigned, hole) } - Ok(Layout::FunctionPointer(_, _)) => { - // CLEANUP - unreachable!("closures should never have a function pointer layout"); - - // match procs.insert_anonymous( - // env, - // name, - // function_type, - // arguments, - // loc_body, - // CapturedSymbols::None, - // return_type, - // layout_cache, - // ) { - // Ok(layout) => { - // bg!(name); - // // TODO should the let have layout Pointer? - // // Stmt::Let(assigned, Expr::Struct(&[]), Layout::Struct(&[]), hole) - // if false { - // let mut hole = hole.clone(); - // substitute_in_exprs(env.arena, &mut hole, assigned, name); - // hole - // } else { - // Stmt::Let( - // assigned, - // call_by_pointer(env, procs, name, layout), - // layout, - // hole, - // ) - // } - // } - // - // Err(_error) => Stmt::RuntimeError( - // "TODO convert anonymous function error to a RuntimeError string", - // ), - // } - } Ok(_) => unreachable!(), } } @@ -3826,11 +3789,10 @@ pub fn with_hole<'a>( let full_layout = return_on_layout_error!( env, - layout_cache.from_var(env.arena, fn_var, env.subs) + layout_cache.raw_from_var(env.arena, fn_var, env.subs) ); let arg_layouts = match full_layout { - Layout::FunctionPointer(args, _) => args, Layout::Closure(args, _, _) => args, _ => unreachable!("function has layout that is not function pointer"), }; @@ -3898,38 +3860,6 @@ pub fn with_hole<'a>( env.arena.alloc(result), ); } - Layout::FunctionPointer(_, _) => { - // CLEANUP - unreachable!("should not be a function pointer"); - - // let function_symbol = env.unique_symbol(); - // let closure_data_symbol = function_symbol; - // - // // layout of the closure record - // let closure_data_layout = Layout::Struct(&[]); - // - // result = lambda_set_to_switch_make_branch_help( - // env, - // function_symbol, - // closure_data_symbol, - // closure_data_layout, - // arg_symbols, - // arg_layouts, - // ret_layout, - // assigned, - // hole, - // ); - // - // result = with_hole( - // env, - // loc_expr.value, - // fn_var, - // procs, - // layout_cache, - // closure_data_symbol, - // env.arena.alloc(result), - // ); - } _ => { todo!("{:?}", full_layout) } diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index 44e6854cd5..953f41ff71 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -791,6 +791,50 @@ impl<'a> LayoutCache<'a> { } } + pub fn raw_from_var( + &mut self, + arena: &'a Bump, + var: Variable, + subs: &Subs, + ) -> Result, LayoutProblem> { + // Store things according to the root Variable, to avoid duplicate work. + let var = subs.get_root_key_without_compacting(var); + + let cached_var = CachedVariable::new(var); + + self.expand_to_fit(cached_var); + + use CachedLayout::*; + match self.layouts.probe_value(cached_var) { + Cached(result) => Ok(result), + Problem(problem) => Err(problem), + NotCached => { + let mut env = Env { + arena, + subs, + seen: MutSet::default(), + }; + + let result = Layout::from_var(&mut env, var); + + // Don't actually cache. The layout cache is very hard to get right in the presence + // of specialization, it's turned of for now so an invalid cache is never the cause + // of a problem + if false { + let cached_layout = match &result { + Ok(layout) => Cached(*layout), + Err(problem) => Problem(problem.clone()), + }; + + self.layouts + .update_value(cached_var, |existing| existing.value = cached_layout); + } + + result + } + } + } + fn expand_to_fit(&mut self, var: CachedVariable<'a>) { use ven_ena::unify::UnifyKey; @@ -1909,6 +1953,7 @@ impl LayoutId { struct IdsByLayout<'a> { by_id: MutMap, u32>, + toplevels_by_id: MutMap, u32>, next_id: u32, } @@ -1925,6 +1970,7 @@ impl<'a> LayoutIds<'a> { // There's probably a nicer way to write it that still works. let ids = self.by_symbol.entry(symbol).or_insert_with(|| IdsByLayout { by_id: HashMap::with_capacity_and_hasher(1, default_hasher()), + toplevels_by_id: Default::default(), next_id: 1, }); @@ -1941,6 +1987,39 @@ impl<'a> LayoutIds<'a> { LayoutId(answer) } + + /// Returns a LayoutId which is unique for the given symbol and layout. + /// If given the same symbol and same layout, returns the same LayoutId. + pub fn get_toplevel<'b>( + &mut self, + symbol: Symbol, + layout: &'b crate::ir::TopLevelFunctionLayout<'a>, + ) -> LayoutId { + // Note: this function does some weird stuff to satisfy the borrow checker. + // There's probably a nicer way to write it that still works. + let ids = self.by_symbol.entry(symbol).or_insert_with(|| IdsByLayout { + by_id: Default::default(), + toplevels_by_id: HashMap::with_capacity_and_hasher(1, default_hasher()), + next_id: 1, + }); + + // Get the id associated with this layout, or default to next_id. + let answer = ids + .toplevels_by_id + .get(&layout) + .copied() + .unwrap_or(ids.next_id); + + // If we had to default to next_id, it must not have been found; + // store the ID we're going to return and increment next_id. + if answer == ids.next_id { + ids.toplevels_by_id.insert(*layout, ids.next_id); + + ids.next_id += 1; + } + + LayoutId(answer) + } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] From 474a0747cdc76637531a2ffff5b65ef13e7731a3 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 19 Jun 2021 00:46:47 +0200 Subject: [PATCH 286/496] use MaybeUninit --- examples/cli/platform/src/lib.rs | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/examples/cli/platform/src/lib.rs b/examples/cli/platform/src/lib.rs index e86a18ae93..dbcf422978 100644 --- a/examples/cli/platform/src/lib.rs +++ b/examples/cli/platform/src/lib.rs @@ -3,6 +3,7 @@ use core::alloc::Layout; use core::ffi::c_void; use core::mem; +use core::mem::MaybeUninit; use errno::{errno, Errno}; use libc::{self, c_char, c_int}; use roc_std::{alloca, RocCallResult, RocList, RocResult, RocStr}; @@ -167,10 +168,7 @@ pub struct Fd(c_int); pub unsafe fn roc_fx_open(roc_path: RocStr) -> RocResult { const BUF_BYTES: usize = 256; - // I know that since Rust 1.39 mem::uninitialized() is deprecated in favor - // of MaybeUninit, but I couldn't get this to work with MaybeUninit. - #[allow(deprecated)] - let mut buf: [u8; BUF_BYTES] = mem::uninitialized(); + let mut buf: MaybeUninit<[u8; BUF_BYTES]> = MaybeUninit::uninit(); // If the path fits in the stack-allocated buffer, we can avoid a heap // allocation when translating our `RocStr` to a null-terminated `char*`. @@ -179,9 +177,9 @@ pub unsafe fn roc_fx_open(roc_path: RocStr) -> RocResult { let c_path: *mut c_char; if path_fits_in_buf { - roc_path.write_c_str(&mut buf as *mut u8); + roc_path.write_c_str(buf.as_mut_ptr() as *mut u8); - c_path = buf.as_mut_ptr() as *mut c_char; + c_path = buf.assume_init().as_mut_ptr() as *mut c_char; } else { c_path = roc_alloc(path_len, mem::align_of::() as u32) as *mut c_char; From 79b44b2dc5b0f28a609a104eeb341dd820a3c0c7 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 19 Jun 2021 00:51:19 +0200 Subject: [PATCH 287/496] fix UD --- examples/cli/platform/src/lib.rs | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/examples/cli/platform/src/lib.rs b/examples/cli/platform/src/lib.rs index dbcf422978..e6d3dcf454 100644 --- a/examples/cli/platform/src/lib.rs +++ b/examples/cli/platform/src/lib.rs @@ -179,7 +179,8 @@ pub unsafe fn roc_fx_open(roc_path: RocStr) -> RocResult { if path_fits_in_buf { roc_path.write_c_str(buf.as_mut_ptr() as *mut u8); - c_path = buf.assume_init().as_mut_ptr() as *mut c_char; + // NOTE buf may be only partially filled, so we don't `assume_init`! + c_path = buf.as_mut_ptr() as *mut c_char; } else { c_path = roc_alloc(path_len, mem::align_of::() as u32) as *mut c_char; @@ -208,7 +209,7 @@ pub unsafe fn roc_fx_read(fd: Fd, bytes: usize) -> RocResult, Errno> // I know that since Rust 1.39 mem::uninitialized() is deprecated in favor // of MaybeUninit, but I couldn't get this to work with MaybeUninit. #[allow(deprecated)] - let mut buf: [u8; BUF_BYTES] = mem::uninitialized(); + let mut buf: MaybeUninit<[u8; BUF_BYTES]> = MaybeUninit::uninit(); // We'll use our own position and libc::pread rather than using libc::read // repeatedly and letting the fd store its own position. This way we don't @@ -227,10 +228,12 @@ pub unsafe fn roc_fx_read(fd: Fd, bytes: usize) -> RocResult, Errno> position as i64, ); + // NOTE buf may be only partially filled, so we don't `assume_init`! + if bytes_read == bytes_to_read as isize { // The read was successful, and there may be more bytes to read. // Append the bytes to the list and continue looping! - let slice = core::slice::from_raw_parts(buf.as_ptr(), bytes_read as usize); + let slice = core::slice::from_raw_parts(buf.as_ptr() as *const u8, bytes_read as usize); list.append_slice(slice); } else if bytes_read >= 0 { @@ -238,7 +241,7 @@ pub unsafe fn roc_fx_read(fd: Fd, bytes: usize) -> RocResult, Errno> // to read (because bytes_read was less than the requested // bytes_to_read, but it was also not negative - which would have // indicated an error). - let slice = core::slice::from_raw_parts(buf.as_ptr(), bytes_read as usize); + let slice = core::slice::from_raw_parts(buf.as_ptr() as *const u8, bytes_read as usize); list.append_slice(slice); From c44ed3ec79fc7b1983983454458a6e65dce4889e Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 19 Jun 2021 00:52:02 +0200 Subject: [PATCH 288/496] remove annotation --- examples/cli/platform/src/lib.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/examples/cli/platform/src/lib.rs b/examples/cli/platform/src/lib.rs index e6d3dcf454..d6030f6b98 100644 --- a/examples/cli/platform/src/lib.rs +++ b/examples/cli/platform/src/lib.rs @@ -208,7 +208,6 @@ pub unsafe fn roc_fx_read(fd: Fd, bytes: usize) -> RocResult, Errno> // I know that since Rust 1.39 mem::uninitialized() is deprecated in favor // of MaybeUninit, but I couldn't get this to work with MaybeUninit. - #[allow(deprecated)] let mut buf: MaybeUninit<[u8; BUF_BYTES]> = MaybeUninit::uninit(); // We'll use our own position and libc::pread rather than using libc::read From 96e96f7e5d283b1898f9b55ed8e88d4e03bb8934 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Fri, 18 Jun 2021 22:11:04 -0400 Subject: [PATCH 289/496] Drop obsolete comment --- examples/cli/platform/src/lib.rs | 2 -- 1 file changed, 2 deletions(-) diff --git a/examples/cli/platform/src/lib.rs b/examples/cli/platform/src/lib.rs index d6030f6b98..37a120b2df 100644 --- a/examples/cli/platform/src/lib.rs +++ b/examples/cli/platform/src/lib.rs @@ -206,8 +206,6 @@ pub unsafe fn roc_fx_open(roc_path: RocStr) -> RocResult { pub unsafe fn roc_fx_read(fd: Fd, bytes: usize) -> RocResult, Errno> { const BUF_BYTES: usize = 1024; - // I know that since Rust 1.39 mem::uninitialized() is deprecated in favor - // of MaybeUninit, but I couldn't get this to work with MaybeUninit. let mut buf: MaybeUninit<[u8; BUF_BYTES]> = MaybeUninit::uninit(); // We'll use our own position and libc::pread rather than using libc::read From c6f5f587615026700ba4d66b993ac0fe7a3fe88d Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 19 Jun 2021 10:56:02 +0200 Subject: [PATCH 290/496] when refcount is isize, decrement is subtraction --- compiler/builtins/bitcode/src/utils.zig | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/compiler/builtins/bitcode/src/utils.zig b/compiler/builtins/bitcode/src/utils.zig index 197c5d182f..be99cab009 100644 --- a/compiler/builtins/bitcode/src/utils.zig +++ b/compiler/builtins/bitcode/src/utils.zig @@ -92,7 +92,7 @@ pub fn decref( if (refcount == REFCOUNT_ONE_ISIZE) { dealloc(bytes - 16, alignment); } else if (refcount_isize < 0) { - (isizes - 1)[0] = refcount + 1; + (isizes - 1)[0] = refcount - 1; } }, else => { @@ -100,7 +100,7 @@ pub fn decref( if (refcount == REFCOUNT_ONE_ISIZE) { dealloc(bytes - 8, alignment); } else if (refcount_isize < 0) { - (isizes - 1)[0] = refcount + 1; + (isizes - 1)[0] = refcount - 1; } }, } From e0f5dc40cb51e957ad761cab9f8cc2f83a8dfefa Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 19 Jun 2021 00:34:22 +0200 Subject: [PATCH 291/496] WIP --- cli/src/repl/eval.rs | 3 + compiler/mono/src/ir.rs | 210 +++++++++++++++++++----------------- compiler/mono/src/layout.rs | 12 +++ 3 files changed, 125 insertions(+), 100 deletions(-) diff --git a/cli/src/repl/eval.rs b/cli/src/repl/eval.rs index ef6dfec3a4..23823ef78a 100644 --- a/cli/src/repl/eval.rs +++ b/cli/src/repl/eval.rs @@ -168,6 +168,9 @@ fn jit_to_ast_help<'a>( Content::Structure(FlatType::FunctionOrTagUnion(tag_name, _, _)) => { single_tag_union_to_ast(env, ptr, field_layouts, tag_name.clone(), &[]) } + Content::Structure(FlatType::Func(_, _, _)) => { + return Err(ToAstProblem::FunctionLayout) + } other => { unreachable!( "Something had a Struct layout, but instead of a Record or TagUnion type, it had: {:?}", diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index c5a9ad2e14..e4cc061b06 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -3,8 +3,8 @@ use self::InProgressProc::*; use crate::exhaustive::{Ctor, Guard, RenderAs, TagId}; use crate::layout::{ - Builtin, ClosureRepresentation, LambdaSet, Layout, LayoutCache, LayoutProblem, UnionLayout, - WrappedVariant, TAG_SIZE, + Builtin, ClosureRepresentation, LambdaSet, Layout, LayoutCache, LayoutProblem, + RawFunctionLayout, UnionLayout, WrappedVariant, TAG_SIZE, }; use bumpalo::collections::Vec; use bumpalo::Bump; @@ -601,7 +601,7 @@ impl<'a> Procs<'a> { { Ok((proc, layout)) => { let top_level = - TopLevelFunctionLayout::from_layout(env.arena, layout); + TopLevelFunctionLayout::from_raw(env.arena, layout); debug_assert_eq!(outside_layout, top_level); @@ -1784,10 +1784,15 @@ pub fn specialize_all<'a>( ) { Ok((proc, layout)) => { // TODO thiscode is duplicated elsewhere - let top_level = TopLevelFunctionLayout::from_layout(env.arena, layout); + let top_level = TopLevelFunctionLayout::from_raw(env.arena, layout); if procs.module_thunks.contains(&proc.name) { - debug_assert!(top_level.arguments.is_empty(), "{:?}", name); + debug_assert!( + top_level.arguments.is_empty(), + "{:?} from {:?}", + name, + layout + ); } debug_assert_eq!(outside_layout, top_level, " in {:?}", name); @@ -1799,7 +1804,8 @@ pub fn specialize_all<'a>( let proc = generate_runtime_error_function(env, name, attempted_layout); let top_level = - TopLevelFunctionLayout::from_layout(env.arena, attempted_layout); + TopLevelFunctionLayout::from_raw(env.arena, attempted_layout); + procs.specialized.insert((name, top_level), Done(proc)); } } @@ -1859,7 +1865,7 @@ fn specialize_all_help<'a>( partial_proc, ) { Ok((proc, layout)) => { - let top_level = TopLevelFunctionLayout::from_layout(env.arena, layout); + let top_level = TopLevelFunctionLayout::from_raw(env.arena, layout); if procs.module_thunks.contains(&name) { debug_assert!(top_level.arguments.is_empty()); @@ -1873,7 +1879,18 @@ fn specialize_all_help<'a>( }) => { let proc = generate_runtime_error_function(env, name, attempted_layout); - let top_level = TopLevelFunctionLayout::from_layout(env.arena, attempted_layout); + let top_level = { + match attempted_layout { + RawFunctionLayout::Function(a, b, c) => { + let l = Layout::Closure(a, b, c); + TopLevelFunctionLayout::from_layout(env.arena, l) + } + RawFunctionLayout::ZeroArgumentThunk(result) => { + TopLevelFunctionLayout::new(env.arena, &[], result) + } + } + }; + procs.specialized.insert((name, top_level), Done(proc)); } } @@ -1883,19 +1900,8 @@ fn specialize_all_help<'a>( fn generate_runtime_error_function<'a>( env: &mut Env<'a, '_>, name: Symbol, - layout: Layout<'a>, + layout: RawFunctionLayout<'a>, ) -> Proc<'a> { - let (arg_layouts, ret_layout) = match layout { - Layout::FunctionPointer(a, r) => (a, *r), - _ => (&[] as &[_], layout), - }; - - let mut args = Vec::with_capacity_in(arg_layouts.len(), env.arena); - - for arg in arg_layouts { - args.push((*arg, env.unique_symbol())); - } - let mut msg = bumpalo::collections::string::String::with_capacity_in(80, env.arena); use std::fmt::Write; write!( @@ -1909,9 +1915,24 @@ fn generate_runtime_error_function<'a>( let runtime_error = Stmt::RuntimeError(msg.into_bump_str()); + let (args, ret_layout) = match layout { + RawFunctionLayout::Function(arg_layouts, lambda_set, ret_layout) => { + let mut args = Vec::with_capacity_in(arg_layouts.len(), env.arena); + + for arg in arg_layouts { + args.push((*arg, env.unique_symbol())); + } + + args.push((lambda_set.runtime_representation(), Symbol::ARG_CLOSURE)); + + (args.into_bump_slice(), *ret_layout) + } + RawFunctionLayout::ZeroArgumentThunk(ret_layout) => (&[] as &[_], ret_layout), + }; + Proc { name, - args: args.into_bump_slice(), + args, body: runtime_error, closure_data_layout: None, ret_layout, @@ -2008,10 +2029,11 @@ fn specialize_external<'a>( host_exposed_layouts: HostExposedLayouts::NotHostExposed, }; - let top_level = TopLevelFunctionLayout { - arguments: env.arena.alloc([lambda_set.runtime_representation()]), - result: *return_layout, - }; + let top_level = TopLevelFunctionLayout::new( + env.arena, + env.arena.alloc([lambda_set.runtime_representation()]), + *return_layout, + ); procs .specialized @@ -2450,11 +2472,13 @@ fn build_specialized_proc<'a>( #[derive(Debug)] struct SpecializeFailure<'a> { /// The layout we attempted to create - attempted_layout: Layout<'a>, + attempted_layout: RawFunctionLayout<'a>, /// The problem we ran into while creating it problem: LayoutProblem, } +type SpecializeSuccess<'a> = (Proc<'a>, RawFunctionLayout<'a>); + fn specialize<'a>( env: &mut Env<'a, '_>, procs: &mut Procs<'a>, @@ -2462,7 +2486,7 @@ fn specialize<'a>( layout_cache: &mut LayoutCache<'a>, pending: PendingSpecialization, partial_proc: PartialProc<'a>, -) -> Result<(Proc<'a>, Layout<'a>), SpecializeFailure<'a>> { +) -> Result, SpecializeFailure<'a>> { let PendingSpecialization { solved_type, host_exposed_aliases, @@ -2507,7 +2531,7 @@ fn specialize_solved_type<'a>( solved_type: SolvedType, host_exposed_aliases: BumpMap, partial_proc: PartialProc<'a>, -) -> Result<(Proc<'a>, Layout<'a>), SpecializeFailure<'a>> { +) -> Result, SpecializeFailure<'a>> { // add the specializations that other modules require of us use roc_solve::solve::instantiate_rigids; @@ -2520,6 +2544,18 @@ fn specialize_solved_type<'a>( .from_var(&env.arena, fn_var, env.subs) .unwrap_or_else(|err| panic!("TODO handle invalid function {:?}", err)); + let raw = match attempted_layout { + Layout::Closure(a, lambda_set, c) => { + if procs.module_thunks.contains(&proc_name) { + RawFunctionLayout::ZeroArgumentThunk(lambda_set.runtime_representation()) + } else { + RawFunctionLayout::Function(a, lambda_set, c) + } + } + Layout::FunctionPointer(_, _) => unreachable!(), + _ => RawFunctionLayout::ZeroArgumentThunk(attempted_layout), + }; + // make sure rigid variables in the annotation are converted to flex variables instantiate_rigids(env.subs, partial_proc.annotation); @@ -2554,10 +2590,7 @@ fn specialize_solved_type<'a>( env.subs.rollback_to(snapshot); layout_cache.rollback_to(cache_snapshot); - Ok(( - proc, - cleanup_attempted_type(env, procs, proc_name, attempted_layout), - )) + Ok((proc, raw)) } Err(error) => { env.subs.rollback_to(snapshot); @@ -2565,25 +2598,12 @@ fn specialize_solved_type<'a>( Err(SpecializeFailure { problem: error, - attempted_layout: cleanup_attempted_type(env, procs, proc_name, attempted_layout), + attempted_layout: raw, }) } } } -fn cleanup_attempted_type<'a>( - env: &mut Env<'a, '_>, - procs: &mut Procs<'a>, - proc_name: Symbol, - layout: Layout<'a>, -) -> Layout<'a> { - if procs.module_thunks.contains(&proc_name) { - Layout::FunctionPointer(&[], env.arena.alloc(layout)) - } else { - layout - } -} - #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] pub struct TopLevelFunctionLayout<'a> { pub arguments: &'a [Layout<'a>], @@ -2604,9 +2624,14 @@ impl<'a> TopLevelFunctionLayout<'a> { } } + let new_result = match result { + Layout::Closure(_, lambda_set, _) => lambda_set.runtime_representation(), + other => other, + }; + TopLevelFunctionLayout { arguments: arguments.into_bump_slice(), - result, + result: new_result, } } pub fn from_layout(arena: &'a Bump, layout: Layout<'a>) -> Self { @@ -2624,6 +2649,18 @@ impl<'a> TopLevelFunctionLayout<'a> { }, } } + + fn from_raw(arena: &'a Bump, raw: RawFunctionLayout<'a>) -> Self { + match raw { + RawFunctionLayout::Function(a, b, c) => { + let l = Layout::Closure(a, b, c); + TopLevelFunctionLayout::from_layout(arena, l) + } + RawFunctionLayout::ZeroArgumentThunk(result) => { + TopLevelFunctionLayout::new(arena, &[], result) + } + } + } } fn specialize_naked_symbol<'a>( @@ -6141,7 +6178,7 @@ fn build_call<'a>( env: &mut Env<'a, '_>, call: Call<'a>, assigned: Symbol, - layout: Layout<'a>, + return_layout: Layout<'a>, hole: &'a Stmt<'a>, ) -> Stmt<'a> { if can_throw_exception(&call) { @@ -6150,13 +6187,13 @@ fn build_call<'a>( Stmt::Invoke { symbol: assigned, call, - layout, + layout: return_layout, fail, pass: hole, exception_id: id, } } else { - Stmt::Let(assigned, Expr::Call(call), layout, hole) + Stmt::Let(assigned, Expr::Call(call), return_layout, hole) } } @@ -6467,28 +6504,18 @@ fn call_by_name_help<'a>( match specialize(env, procs, proc_name, layout_cache, pending, partial_proc) { - Ok((proc, layout)) => { - // NOTE we cannot make the below assertion any more; figure out why - - debug_assert_eq!( - &maybe_closure_layout, &layout, - "\nProcedure {:?}\n\n{:?}\n\n{:?}", - proc_name, maybe_closure_layout, layout - ); - - call_specialized_proc( - env, - procs, - proc_name, - proc, - layout, - field_symbols, - loc_args, - layout_cache, - assigned, - hole, - ) - } + Ok((proc, layout)) => call_specialized_proc( + env, + procs, + proc_name, + proc, + layout, + field_symbols, + loc_args, + layout_cache, + assigned, + hole, + ), Err(SpecializeFailure { attempted_layout, problem: _, @@ -6544,9 +6571,6 @@ fn call_by_name_module_thunk<'a>( // the layout without the `FunctionPointer(&[], ...)` wrapper let inner_layout = *ret_layout; - // the layout with the wrapper - let module_thunk_layout = Layout::FunctionPointer(&[], ret_layout); - // If we've already specialized this one, no further work is needed. if procs .specialized @@ -6603,8 +6627,7 @@ fn call_by_name_module_thunk<'a>( match specialize(env, procs, proc_name, layout_cache, pending, partial_proc) { Ok((proc, layout)) => { - // NOTE we cannot make the below assertion any more; figure out why - debug_assert_eq!(layout, module_thunk_layout); + debug_assert!(layout.is_zero_argument_thunk()); let was_present = procs.specialized.remove(&(proc_name, top_level_layout)); @@ -6620,12 +6643,10 @@ fn call_by_name_module_thunk<'a>( attempted_layout, problem: _, }) => { - debug_assert_eq!(attempted_layout, module_thunk_layout); - let proc = generate_runtime_error_function( env, proc_name, - module_thunk_layout, + attempted_layout, ); let was_present = @@ -6656,22 +6677,20 @@ fn call_specialized_proc<'a>( procs: &mut Procs<'a>, proc_name: Symbol, proc: Proc<'a>, - layout: Layout<'a>, + layout: RawFunctionLayout<'a>, field_symbols: &'a [Symbol], loc_args: std::vec::Vec<(Variable, Located)>, layout_cache: &mut LayoutCache<'a>, assigned: Symbol, hole: &'a Stmt<'a>, ) -> Stmt<'a> { - let function_layout = env - .arena - .alloc(TopLevelFunctionLayout::from_layout(env.arena, layout)); + let function_layout = TopLevelFunctionLayout::from_raw(env.arena, layout); - procs.specialized.remove(&(proc_name, *function_layout)); + procs.specialized.remove(&(proc_name, function_layout)); procs .specialized - .insert((proc_name, *function_layout), Done(proc)); + .insert((proc_name, function_layout), Done(proc)); if field_symbols.is_empty() { debug_assert!(loc_args.is_empty()); @@ -6684,7 +6703,8 @@ fn call_specialized_proc<'a>( // there are no arguments. This confuses our IR, // and we have to fix it here. match layout { - Layout::Closure(_, closure_layout, _) => { + RawFunctionLayout::Function(_, lambda_set, _) => { + // when the body is a closure, the function will return the closure environment let call = self::Call { call_type: CallType::ByName { name: proc_name, @@ -6699,22 +6719,12 @@ fn call_specialized_proc<'a>( env, call, assigned, - closure_layout.runtime_representation(), + lambda_set.runtime_representation(), hole, ) } - _ => { - let call = self::Call { - call_type: CallType::ByName { - name: proc_name, - ret_layout: function_layout.result, - arg_layouts: function_layout.arguments, - specialization_id: env.next_call_specialization_id(), - }, - arguments: field_symbols, - }; - - build_call(env, call, assigned, function_layout.result, hole) + RawFunctionLayout::ZeroArgumentThunk(_) => { + unreachable!() } } } else { diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index 953f41ff71..971b4efe54 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -33,6 +33,18 @@ pub enum LayoutProblem { Erroneous, } +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] +pub enum RawFunctionLayout<'a> { + Function(&'a [Layout<'a>], LambdaSet<'a>, &'a Layout<'a>), + ZeroArgumentThunk(Layout<'a>), +} + +impl RawFunctionLayout<'_> { + pub fn is_zero_argument_thunk(&self) -> bool { + matches!(self, RawFunctionLayout::ZeroArgumentThunk(_)) + } +} + /// Types for code gen must be monomorphic. No type variables allowed! #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub enum Layout<'a> { From 4c6048de7dc8998c541c84891552ab661b172e20 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 19 Jun 2021 12:16:08 +0200 Subject: [PATCH 292/496] raw function layout --- cli/src/repl/eval.rs | 25 ++++++++++++++++--------- 1 file changed, 16 insertions(+), 9 deletions(-) diff --git a/cli/src/repl/eval.rs b/cli/src/repl/eval.rs index 23823ef78a..ab87015185 100644 --- a/cli/src/repl/eval.rs +++ b/cli/src/repl/eval.rs @@ -153,23 +153,30 @@ fn jit_to_ast_help<'a>( Layout::Struct(field_layouts) => { let ptr_to_ast = |ptr: *const u8| match content { Content::Structure(FlatType::Record(fields, _)) => { - struct_to_ast(env, ptr, field_layouts, fields) + Ok(struct_to_ast(env, ptr, field_layouts, fields)) } Content::Structure(FlatType::EmptyRecord) => { - struct_to_ast(env, ptr, field_layouts, &MutMap::default()) + Ok(struct_to_ast(env, ptr, field_layouts, &MutMap::default())) } Content::Structure(FlatType::TagUnion(tags, _)) => { debug_assert_eq!(tags.len(), 1); let (tag_name, payload_vars) = tags.iter().next().unwrap(); - single_tag_union_to_ast(env, ptr, field_layouts, tag_name.clone(), payload_vars) - } - Content::Structure(FlatType::FunctionOrTagUnion(tag_name, _, _)) => { - single_tag_union_to_ast(env, ptr, field_layouts, tag_name.clone(), &[]) + Ok(single_tag_union_to_ast( + env, + ptr, + field_layouts, + tag_name.clone(), + payload_vars, + )) } + Content::Structure(FlatType::FunctionOrTagUnion(tag_name, _, _)) => Ok( + single_tag_union_to_ast(env, ptr, field_layouts, tag_name.clone(), &[]), + ), Content::Structure(FlatType::Func(_, _, _)) => { - return Err(ToAstProblem::FunctionLayout) + // a function with a struct as the closure environment + return Err(ToAstProblem::FunctionLayout); } other => { unreachable!( @@ -184,12 +191,12 @@ fn jit_to_ast_help<'a>( let result_stack_size = layout.stack_size(env.ptr_bytes); - Ok(run_jit_function_dynamic_type!( + run_jit_function_dynamic_type!( lib, main_fn_name, result_stack_size as usize, |bytes: *const u8| { ptr_to_ast(bytes as *const u8) } - )) + ) } Layout::Union(UnionLayout::NonRecursive(union_layouts)) => match content { Content::Structure(FlatType::TagUnion(tags, _)) => { From 4a8ec50c0ecbe3d0a012877a37fb4958440379a8 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 19 Jun 2021 12:36:19 +0200 Subject: [PATCH 293/496] more raw layout --- compiler/mono/src/ir.rs | 59 +++++++++++++++++++++---------------- compiler/mono/src/layout.rs | 25 ++++------------ 2 files changed, 40 insertions(+), 44 deletions(-) diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index e4cc061b06..19d97d8d64 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -25,14 +25,22 @@ macro_rules! return_on_layout_error { ($env:expr, $layout_result:expr) => { match $layout_result { Ok(cached) => cached, - Err(LayoutProblem::UnresolvedTypeVar(_)) => { + Err(error) => return_on_layout_error_help!($env, error), + } + }; +} + +macro_rules! return_on_layout_error_help { + ($env:expr, $error:expr) => { + match $error { + LayoutProblem::UnresolvedTypeVar(_) => { return Stmt::RuntimeError($env.arena.alloc(format!( "UnresolvedTypeVar {} line {}", file!(), line!() ))); } - Err(LayoutProblem::Erroneous) => { + LayoutProblem::Erroneous => { return Stmt::RuntimeError($env.arena.alloc(format!( "Erroneous {} line {}", file!(), @@ -3731,9 +3739,13 @@ pub fn with_hole<'a>( } => { let loc_body = *boxed_body; - match layout_cache.raw_from_var(env.arena, function_type, env.subs) { - Err(e) => panic!("invalid layout {:?}", e), - Ok(Layout::Closure(_argument_layouts, lambda_set, _ret_layout)) => { + let raw = layout_cache.raw_from_var(env.arena, function_type, env.subs); + + match return_on_layout_error!(env, raw) { + RawFunctionLayout::ZeroArgumentThunk(_) => { + unreachable!("a closure syntactically always must have at least one argument") + } + RawFunctionLayout::Function(_argument_layouts, lambda_set, _ret_layout) => { let mut captured_symbols = Vec::from_iter_in(captured_symbols, env.arena); captured_symbols.sort(); let captured_symbols = captured_symbols.into_bump_slice(); @@ -3768,7 +3780,6 @@ pub fn with_hole<'a>( construct_closure_data(env, lambda_set, name, symbols, assigned, hole) } - Ok(_) => unreachable!(), } } @@ -3829,16 +3840,6 @@ pub fn with_hole<'a>( layout_cache.raw_from_var(env.arena, fn_var, env.subs) ); - let arg_layouts = match full_layout { - Layout::Closure(args, _, _) => args, - _ => unreachable!("function has layout that is not function pointer"), - }; - - let ret_layout = return_on_layout_error!( - env, - layout_cache.from_var(env.arena, ret_var, env.subs) - ); - // if the function expression (loc_expr) is already a symbol, // re-use that symbol, and don't define its value again let mut result; @@ -3850,8 +3851,8 @@ pub fn with_hole<'a>( Imported(_) => { unreachable!("an imported value is never an anonymous function") } - Value(function_symbol) => { - if let Layout::Closure(_, lambda_set, _) = full_layout { + Value(function_symbol) => match full_layout { + RawFunctionLayout::Function(arg_layouts, lambda_set, ret_layout) => { let closure_data_symbol = function_symbol; result = match_on_lambda_set( @@ -3860,20 +3861,25 @@ pub fn with_hole<'a>( closure_data_symbol, arg_symbols, arg_layouts, - ret_layout, + *ret_layout, assigned, hole, ); - } else { + } + RawFunctionLayout::ZeroArgumentThunk(_) => { unreachable!("calling a non-closure layout") } - } + }, NotASymbol => { // the expression is not a symbol. That means it's an expression // evaluating to a function value. match full_layout { - Layout::Closure(_, lambda_set, _) => { + RawFunctionLayout::Function( + arg_layouts, + lambda_set, + ret_layout, + ) => { let closure_data_symbol = env.unique_symbol(); result = match_on_lambda_set( @@ -3882,7 +3888,7 @@ pub fn with_hole<'a>( closure_data_symbol, arg_symbols, arg_layouts, - ret_layout, + *ret_layout, assigned, hole, ); @@ -3897,8 +3903,11 @@ pub fn with_hole<'a>( env.arena.alloc(result), ); } - _ => { - todo!("{:?}", full_layout) + RawFunctionLayout::ZeroArgumentThunk(_) => { + unreachable!( + "{:?} cannot be called in the source language", + full_layout + ) } } } diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index 971b4efe54..61b45e3150 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -808,7 +808,7 @@ impl<'a> LayoutCache<'a> { arena: &'a Bump, var: Variable, subs: &Subs, - ) -> Result, LayoutProblem> { + ) -> Result, LayoutProblem> { // Store things according to the root Variable, to avoid duplicate work. let var = subs.get_root_key_without_compacting(var); @@ -818,31 +818,18 @@ impl<'a> LayoutCache<'a> { use CachedLayout::*; match self.layouts.probe_value(cached_var) { - Cached(result) => Ok(result), Problem(problem) => Err(problem), - NotCached => { + Cached(_) | NotCached => { let mut env = Env { arena, subs, seen: MutSet::default(), }; - let result = Layout::from_var(&mut env, var); - - // Don't actually cache. The layout cache is very hard to get right in the presence - // of specialization, it's turned of for now so an invalid cache is never the cause - // of a problem - if false { - let cached_layout = match &result { - Ok(layout) => Cached(*layout), - Err(problem) => Problem(problem.clone()), - }; - - self.layouts - .update_value(cached_var, |existing| existing.value = cached_layout); - } - - result + Layout::from_var(&mut env, var).map(|l| match l { + Layout::Closure(a, b, c) => RawFunctionLayout::Function(a, b, c), + other => RawFunctionLayout::ZeroArgumentThunk(other), + }) } } } From 53ce8b2d25ec0e054371a983c0b7396adf3a001a Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 19 Jun 2021 13:49:41 +0200 Subject: [PATCH 294/496] improve call_by_name with raw layout --- compiler/load/src/file.rs | 4 +- compiler/mono/src/alias_analysis.rs | 2 +- compiler/mono/src/ir.rs | 197 +++++++++++++--------------- 3 files changed, 95 insertions(+), 108 deletions(-) diff --git a/compiler/load/src/file.rs b/compiler/load/src/file.rs index 14b5b0bf41..7fab10525a 100644 --- a/compiler/load/src/file.rs +++ b/compiler/load/src/file.rs @@ -2060,8 +2060,6 @@ fn update<'a>( && state.dependencies.solved_all() && state.goal_phase == Phase::MakeSpecializations { - Proc::insert_refcount_operations(arena, &mut state.procedures); - // display the mono IR of the module, for debug purposes if roc_mono::ir::PRETTY_PRINT_IR_SYMBOLS { let procs_string = state @@ -2075,6 +2073,8 @@ fn update<'a>( println!("{}", result); } + Proc::insert_refcount_operations(arena, &mut state.procedures); + // This is not safe with the new non-recursive RC updates that we do for tag unions // // Proc::optimize_refcount_operations( diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index ebba54fb80..8733df7e10 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -144,7 +144,7 @@ where "{:?}: {:?} with {:?} args", proc.name, bytes_as_ascii(&bytes), - proc.args.len() + (proc.args, proc.ret_layout), ); } diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 19d97d8d64..c8b37b7b61 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -1887,17 +1887,7 @@ fn specialize_all_help<'a>( }) => { let proc = generate_runtime_error_function(env, name, attempted_layout); - let top_level = { - match attempted_layout { - RawFunctionLayout::Function(a, b, c) => { - let l = Layout::Closure(a, b, c); - TopLevelFunctionLayout::from_layout(env.arena, l) - } - RawFunctionLayout::ZeroArgumentThunk(result) => { - TopLevelFunctionLayout::new(env.arena, &[], result) - } - } - }; + let top_level = TopLevelFunctionLayout::from_raw(env.arena, attempted_layout); procs.specialized.insert((name, top_level), Done(proc)); } @@ -3784,7 +3774,7 @@ pub fn with_hole<'a>( } Call(boxed, loc_args, _) => { - let (fn_var, loc_expr, _lambda_set_var, ret_var) = *boxed; + let (fn_var, loc_expr, _lambda_set_var, _ret_var) = *boxed; // even if a call looks like it's by name, it may in fact be by-pointer. // E.g. in `(\f, x -> f x)` the call is in fact by pointer. @@ -6218,7 +6208,7 @@ fn call_by_name<'a>( hole: &'a Stmt<'a>, ) -> Stmt<'a> { // Register a pending_specialization for this function - match layout_cache.from_var(env.arena, fn_var, env.subs) { + match layout_cache.raw_from_var(env.arena, fn_var, env.subs) { Err(LayoutProblem::UnresolvedTypeVar(var)) => { let msg = format!( "Hit an unresolved type variable {:?} when creating a layout for {:?} (var {:?})", @@ -6233,110 +6223,107 @@ fn call_by_name<'a>( ); Stmt::RuntimeError(env.arena.alloc(msg)) } - Ok(layout) if procs.module_thunks.contains(&proc_name) => { - // here we turn a call to a module thunk into forcing of that thunk - if loc_args.is_empty() { + Ok(RawFunctionLayout::Function(arg_layouts, lambda_set, ret_layout)) => { + if procs.module_thunks.contains(&proc_name) { + if loc_args.is_empty() { + call_by_name_module_thunk( + env, + procs, + fn_var, + proc_name, + env.arena.alloc(lambda_set.runtime_representation()), + layout_cache, + assigned, + hole, + ) + } else { + // here we turn a call to a module thunk into forcing of that thunk + // the thunk represents the closure environment for the body, so we then match + // on the closure environment to perform the call that the body represents. + // + // Example: + // + // > main = parseA "foo" "bar" + // > parseA = Str.concat + + let closure_data_symbol = env.unique_symbol(); + + let arena = env.arena; + let arg_symbols = Vec::from_iter_in( + loc_args.iter().map(|(_, arg_expr)| { + possible_reuse_symbol(env, procs, &arg_expr.value) + }), + arena, + ) + .into_bump_slice(); + + debug_assert_eq!(arg_symbols.len(), arg_layouts.len()); + + let result = match_on_lambda_set( + env, + lambda_set, + closure_data_symbol, + arg_symbols, + arg_layouts, + *ret_layout, + assigned, + hole, + ); + + let result = call_by_name_module_thunk( + env, + procs, + fn_var, + proc_name, + env.arena.alloc(lambda_set.runtime_representation()), + layout_cache, + closure_data_symbol, + env.arena.alloc(result), + ); + + let iter = loc_args.into_iter().rev().zip(arg_symbols.iter().rev()); + assign_to_symbols(env, procs, layout_cache, iter, result) + } + } else { + let orig = Layout::Closure(arg_layouts, lambda_set, ret_layout); + match lambda_set.extend_function_layout(env.arena, arg_layouts, ret_layout) { + Layout::FunctionPointer(argument_layouts, ret_layout) => call_by_name_help( + env, + procs, + fn_var, + proc_name, + loc_args, + orig, + argument_layouts, + ret_layout, + layout_cache, + assigned, + hole, + ), + _ => unreachable!(), + } + } + } + Ok(RawFunctionLayout::ZeroArgumentThunk(ret_layout)) => { + if procs.module_thunks.contains(&proc_name) { + // here we turn a call to a module thunk into forcing of that thunk call_by_name_module_thunk( env, procs, fn_var, proc_name, - env.arena.alloc(layout), + env.arena.alloc(ret_layout), layout_cache, assigned, hole, ) - } else if let Layout::Closure(arg_layouts, lambda_set, ret_layout) = layout { - // here we turn a call to a module thunk into forcing of that thunk - // the thunk represents the closure environment for the body, so we then match - // on the closure environment to perform the call that the body represents. - // - // Example: - // - // > main = parseA "foo" "bar" - // > parseA = Str.concat - - let closure_data_symbol = env.unique_symbol(); - - let arena = env.arena; - let arg_symbols = Vec::from_iter_in( - loc_args - .iter() - .map(|(_, arg_expr)| possible_reuse_symbol(env, procs, &arg_expr.value)), - arena, - ) - .into_bump_slice(); - - let result = match_on_lambda_set( - env, - lambda_set, - closure_data_symbol, - arg_symbols, - arg_layouts, - *ret_layout, - assigned, - hole, - ); - - let result = call_by_name_module_thunk( - env, - procs, - fn_var, - proc_name, - env.arena.alloc(layout), - layout_cache, - closure_data_symbol, - env.arena.alloc(result), - ); - - let iter = loc_args.into_iter().rev().zip(arg_symbols.iter().rev()); - assign_to_symbols(env, procs, layout_cache, iter, result) - } else { - unreachable!("calling a non-closure layout") - } - } - Ok(Layout::FunctionPointer(argument_layouts, ret_layout)) => call_by_name_help( - env, - procs, - fn_var, - proc_name, - loc_args, - Layout::FunctionPointer(argument_layouts, ret_layout), - argument_layouts, - ret_layout, - layout_cache, - assigned, - hole, - ), - Ok(Layout::Closure(c_argument_layouts, lambda_set, c_ret_layout)) => { - match lambda_set.extend_function_layout(env.arena, c_argument_layouts, c_ret_layout) { - Layout::FunctionPointer(argument_layouts, ret_layout) => call_by_name_help( - env, - procs, - fn_var, - proc_name, - loc_args, - Layout::Closure(c_argument_layouts, lambda_set, c_ret_layout), - argument_layouts, - ret_layout, - layout_cache, - assigned, - hole, - ), - _ => unreachable!(), - } - } - Ok(other) if loc_args.is_empty() => { - // this is a 0-argument thunk - if env.is_imported_symbol(proc_name) { + } else if env.is_imported_symbol(proc_name) { add_needed_external(procs, env, fn_var, proc_name); + force_thunk(env, proc_name, ret_layout, assigned, hole) + } else { + panic!("most likely we're trying to call something that is not a function"); } - force_thunk(env, proc_name, other, assigned, hole) } - other => panic!( - "calling {:?}, which is not a function but received arguments, and is a {:?}", - proc_name, other, - ), } } From dd341508e4d61b32ba4af7179749d7ed4cc3dda1 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 19 Jun 2021 14:01:47 +0200 Subject: [PATCH 295/496] refactor --- compiler/mono/src/ir.rs | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index c8b37b7b61..b804ae8a62 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -6285,7 +6285,6 @@ fn call_by_name<'a>( assign_to_symbols(env, procs, layout_cache, iter, result) } } else { - let orig = Layout::Closure(arg_layouts, lambda_set, ret_layout); match lambda_set.extend_function_layout(env.arena, arg_layouts, ret_layout) { Layout::FunctionPointer(argument_layouts, ret_layout) => call_by_name_help( env, @@ -6293,7 +6292,7 @@ fn call_by_name<'a>( fn_var, proc_name, loc_args, - orig, + lambda_set, argument_layouts, ret_layout, layout_cache, @@ -6334,7 +6333,7 @@ fn call_by_name_help<'a>( fn_var: Variable, proc_name: Symbol, loc_args: std::vec::Vec<(Variable, Located)>, - maybe_closure_layout: Layout<'a>, + lambda_set: LambdaSet<'a>, argument_layouts: &'a [Layout<'a>], ret_layout: &'a Layout<'a>, layout_cache: &mut LayoutCache<'a>, @@ -6403,7 +6402,13 @@ fn call_by_name_help<'a>( debug_assert_ne!(proc_name.module_id(), ModuleId::ATTR); if procs.imported_module_thunks.contains(&proc_name) { - force_thunk(env, proc_name, maybe_closure_layout, assigned, hole) + force_thunk( + env, + proc_name, + lambda_set.runtime_representation(), + assigned, + hole, + ) } else { debug_assert!( !field_symbols.is_empty(), From c776d9868686727398794d9353faa74182a34395 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 19 Jun 2021 14:42:43 +0200 Subject: [PATCH 296/496] remove another FunctionPointer --- compiler/mono/src/ir.rs | 31 +++++++++++++++---------------- compiler/mono/src/layout.rs | 19 +++++++++++++++---- 2 files changed, 30 insertions(+), 20 deletions(-) diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index b804ae8a62..859782207b 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -6285,22 +6285,21 @@ fn call_by_name<'a>( assign_to_symbols(env, procs, layout_cache, iter, result) } } else { - match lambda_set.extend_function_layout(env.arena, arg_layouts, ret_layout) { - Layout::FunctionPointer(argument_layouts, ret_layout) => call_by_name_help( - env, - procs, - fn_var, - proc_name, - loc_args, - lambda_set, - argument_layouts, - ret_layout, - layout_cache, - assigned, - hole, - ), - _ => unreachable!(), - } + let argument_layouts = lambda_set.extend_argument_list(env.arena, arg_layouts); + + call_by_name_help( + env, + procs, + fn_var, + proc_name, + loc_args, + lambda_set, + argument_layouts, + ret_layout, + layout_cache, + assigned, + hole, + ) } } Ok(RawFunctionLayout::ZeroArgumentThunk(ret_layout)) => { diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index 61b45e3150..9d145dd05e 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -210,26 +210,37 @@ impl<'a> LambdaSet<'a> { argument_layouts: &'a [Layout<'a>], ret_layout: &'a Layout<'a>, ) -> Layout<'a> { + Layout::FunctionPointer( + self.extend_argument_list(arena, argument_layouts), + ret_layout, + ) + } + + pub fn extend_argument_list( + &self, + arena: &'a Bump, + argument_layouts: &'a [Layout<'a>], + ) -> &'a [Layout<'a>] { if let [] = self.set { // TERRIBLE HACK for builting functions - Layout::FunctionPointer(argument_layouts, ret_layout) + argument_layouts } else { match self.representation { Layout::Struct(&[]) => { // this function does not have anything in its closure, and the lambda set is a // singleton, so we pass no extra argument - Layout::FunctionPointer(argument_layouts, ret_layout) + argument_layouts } Layout::Builtin(Builtin::Int1) | Layout::Builtin(Builtin::Int8) => { // we don't pass this along either - Layout::FunctionPointer(argument_layouts, ret_layout) + argument_layouts } _ => { let mut arguments = Vec::with_capacity_in(argument_layouts.len() + 1, arena); arguments.extend(argument_layouts); arguments.push(self.runtime_representation()); - Layout::FunctionPointer(arguments.into_bump_slice(), ret_layout) + arguments.into_bump_slice() } } } From f2f989718764f24ace17a8d272b4b1d5d09ca30c Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 19 Jun 2021 14:53:18 +0200 Subject: [PATCH 297/496] remove FunctionPointer completely --- cli/src/repl/eval.rs | 1 - compiler/gen_llvm/src/llvm/bitcode.rs | 4 ---- compiler/gen_llvm/src/llvm/build.rs | 7 ------- compiler/gen_llvm/src/llvm/build_hash.rs | 2 +- compiler/gen_llvm/src/llvm/build_list.rs | 3 +-- compiler/gen_llvm/src/llvm/compare.rs | 4 ++-- compiler/gen_llvm/src/llvm/convert.rs | 1 - compiler/gen_llvm/src/llvm/refcounting.rs | 2 -- compiler/load/src/file.rs | 6 +++--- compiler/mono/src/alias_analysis.rs | 1 - compiler/mono/src/ir.rs | 15 ++------------- compiler/mono/src/layout.rs | 23 ++--------------------- 12 files changed, 11 insertions(+), 58 deletions(-) diff --git a/cli/src/repl/eval.rs b/cli/src/repl/eval.rs index ab87015185..20f09f9466 100644 --- a/cli/src/repl/eval.rs +++ b/cli/src/repl/eval.rs @@ -275,7 +275,6 @@ fn jit_to_ast_help<'a>( } Layout::Closure(_, _, _) => Err(ToAstProblem::FunctionLayout), - Layout::FunctionPointer(_, _) => Err(ToAstProblem::FunctionLayout), } } diff --git a/compiler/gen_llvm/src/llvm/bitcode.rs b/compiler/gen_llvm/src/llvm/bitcode.rs index b9cd56ff58..5bf645980f 100644 --- a/compiler/gen_llvm/src/llvm/bitcode.rs +++ b/compiler/gen_llvm/src/llvm/bitcode.rs @@ -151,9 +151,6 @@ fn build_transform_caller_help<'a, 'ctx, 'env>( } match closure_data_layout { - Layout::FunctionPointer(_, _) => { - // do nothing - } Layout::Closure(_, lambda_set, _) => { if let Layout::Struct(&[]) = lambda_set.runtime_representation() { // do nothing @@ -508,7 +505,6 @@ pub fn build_compare_wrapper<'a, 'ctx, 'env>( let default = [value1, value2]; let arguments_cast = match closure_data_layout { - Layout::FunctionPointer(_, _) => &default, Layout::Closure(_, lambda_set, _) => { if let Layout::Struct(&[]) = lambda_set.runtime_representation() { &default diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 6b65b7d985..9fac0259ba 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -3627,13 +3627,6 @@ pub fn build_proc<'a, 'ctx, 'env>( env, &fn_name, evaluator, name, arguments, closure, result, ) } - Layout::FunctionPointer(arguments, result) => { - // define function size (equal to pointer size) and return value size, e.g. - // - // * roc__mainForHost_1_Update_size() -> i64 - // * roc__mainForHost_1_Update_result_size() -> i64 - build_function_caller(env, &fn_name, name, arguments, result) - } Layout::Builtin(_) => {} Layout::Struct(_) => {} diff --git a/compiler/gen_llvm/src/llvm/build_hash.rs b/compiler/gen_llvm/src/llvm/build_hash.rs index d72b02cad5..23728d778c 100644 --- a/compiler/gen_llvm/src/llvm/build_hash.rs +++ b/compiler/gen_llvm/src/llvm/build_hash.rs @@ -88,7 +88,7 @@ fn build_hash_layout<'a, 'ctx, 'env>( } }, - Layout::FunctionPointer(_, _) | Layout::Closure(_, _, _) => { + Layout::Closure(_, _, _) => { unreachable!("the type system will guarantee these are never hashed") } } diff --git a/compiler/gen_llvm/src/llvm/build_list.rs b/compiler/gen_llvm/src/llvm/build_list.rs index e3b9901a0e..9aaecaf7b4 100644 --- a/compiler/gen_llvm/src/llvm/build_list.rs +++ b/compiler/gen_llvm/src/llvm/build_list.rs @@ -658,7 +658,7 @@ pub fn list_keep_errs<'a, 'ctx, 'env>( ) } -pub fn list_keep_result<'a, 'ctx, 'env>( +fn list_keep_result<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, layout_ids: &mut LayoutIds<'a>, transform: FunctionValue<'ctx>, @@ -673,7 +673,6 @@ pub fn list_keep_result<'a, 'ctx, 'env>( let builder = env.builder; let result_layout = match transform_layout { - Layout::FunctionPointer(_, ret) => ret, Layout::Closure(_, _, ret) => ret, _ => unreachable!("not a callable layout"), }; diff --git a/compiler/gen_llvm/src/llvm/compare.rs b/compiler/gen_llvm/src/llvm/compare.rs index fa0185f01e..8b1758eaf5 100644 --- a/compiler/gen_llvm/src/llvm/compare.rs +++ b/compiler/gen_llvm/src/llvm/compare.rs @@ -195,7 +195,7 @@ fn build_eq<'a, 'ctx, 'env>( } }, - Layout::FunctionPointer(_, _) | Layout::Closure(_, _, _) => { + Layout::Closure(_, _, _) => { unreachable!("the type system will guarantee these are never compared") } } @@ -336,7 +336,7 @@ fn build_neq<'a, 'ctx, 'env>( unreachable!("recursion pointers should never be compared directly") } - Layout::FunctionPointer(_, _) | Layout::Closure(_, _, _) => { + Layout::Closure(_, _, _) => { unreachable!("the type system will guarantee these are never compared") } } diff --git a/compiler/gen_llvm/src/llvm/convert.rs b/compiler/gen_llvm/src/llvm/convert.rs index e00c03c333..a2514880bd 100644 --- a/compiler/gen_llvm/src/llvm/convert.rs +++ b/compiler/gen_llvm/src/llvm/convert.rs @@ -44,7 +44,6 @@ pub fn basic_type_from_layout<'a, 'ctx, 'env>( use Layout::*; match layout { - FunctionPointer(args, ret_layout) => basic_type_from_function_layout(env, args, ret_layout), Closure(_args, closure_layout, _ret_layout) => { let closure_data_layout = closure_layout.runtime_representation(); basic_type_from_layout(env, &closure_data_layout) diff --git a/compiler/gen_llvm/src/llvm/refcounting.rs b/compiler/gen_llvm/src/llvm/refcounting.rs index 773b02e9cf..dbee02c4a3 100644 --- a/compiler/gen_llvm/src/llvm/refcounting.rs +++ b/compiler/gen_llvm/src/llvm/refcounting.rs @@ -750,8 +750,6 @@ fn modify_refcount_layout_build_function<'a, 'ctx, 'env>( Some(function) } }, - - FunctionPointer(_, _) => None, } } diff --git a/compiler/load/src/file.rs b/compiler/load/src/file.rs index 7fab10525a..51c98b6bfe 100644 --- a/compiler/load/src/file.rs +++ b/compiler/load/src/file.rs @@ -4080,14 +4080,14 @@ fn add_def_to_module<'a>( if is_exposed { let annotation = def.expr_var; - let layout = match layout_cache.from_var( + let top_level = match layout_cache.from_var( mono_env.arena, annotation, mono_env.subs, ) { Ok(l) => { // remember, this is a 0-argument thunk - Layout::FunctionPointer(&[], mono_env.arena.alloc(l)) + TopLevelFunctionLayout::new(mono_env.arena, &[], l) } Err(LayoutProblem::Erroneous) => { let message = "top level function has erroneous type"; @@ -4108,7 +4108,7 @@ fn add_def_to_module<'a>( procs.insert_exposed( symbol, - TopLevelFunctionLayout::from_layout(mono_env.arena, layout), + top_level, mono_env.arena, mono_env.subs, def.annotation, diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 8733df7e10..d3869033ea 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -976,7 +976,6 @@ fn layout_spec(builder: &mut FuncDefBuilder, layout: &Layout) -> Result } => worst_case_type(builder), }, RecursivePointer => worst_case_type(builder), - FunctionPointer(_, _) => todo!(), Closure(_, lambda_set, _) => layout_spec(builder, &lambda_set.runtime_representation()), } } diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 859782207b..671475c327 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -2244,9 +2244,6 @@ fn build_specialized_proc_from_var<'a>( fn_var: Variable, ) -> Result, LayoutProblem> { match layout_cache.from_var(env.arena, fn_var, env.subs) { - Ok(Layout::FunctionPointer(_, _)) => { - unreachable!(r"layout generated by from_var should never by a function pointer") - } Ok(Layout::Closure(pattern_layouts, closure_layout, ret_layout)) => { let mut pattern_layouts_vec = Vec::with_capacity_in(pattern_layouts.len(), env.arena); pattern_layouts_vec.extend_from_slice(pattern_layouts); @@ -2550,7 +2547,6 @@ fn specialize_solved_type<'a>( RawFunctionLayout::Function(a, lambda_set, c) } } - Layout::FunctionPointer(_, _) => unreachable!(), _ => RawFunctionLayout::ZeroArgumentThunk(attempted_layout), }; @@ -2634,12 +2630,9 @@ impl<'a> TopLevelFunctionLayout<'a> { } pub fn from_layout(arena: &'a Bump, layout: Layout<'a>) -> Self { match layout { - Layout::FunctionPointer(old_arguments, result) => { - Self::new(arena, old_arguments, *result) - } Layout::Closure(arguments, lambda_set, result) => { - let full = lambda_set.extend_function_layout(arena, arguments, result); - TopLevelFunctionLayout::from_layout(arena, full) + let arguments = lambda_set.extend_argument_list(arena, arguments); + TopLevelFunctionLayout::new(arena, arguments, *result) } _ => TopLevelFunctionLayout { arguments: &[], @@ -2690,9 +2683,6 @@ fn specialize_naked_symbol<'a>( } else if env.is_imported_symbol(symbol) { match layout_cache.from_var(env.arena, variable, env.subs) { Err(e) => panic!("invalid layout {:?}", e), - Ok(Layout::FunctionPointer(_, _)) => { - unreachable!(r"layout generated by from_var should never by a function pointer") - } Ok(_) => { // this is a 0-arity thunk let result = call_by_name( @@ -6568,7 +6558,6 @@ fn call_by_name_module_thunk<'a>( let top_level_layout = TopLevelFunctionLayout::new(env.arena, &[], *ret_layout); - // the layout without the `FunctionPointer(&[], ...)` wrapper let inner_layout = *ret_layout; // If we've already specialized this one, no further work is needed. diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index 9d145dd05e..c1b836158a 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -57,7 +57,6 @@ pub enum Layout<'a> { RecursivePointer, /// A function. The types of its arguments, then the type of its return value. - FunctionPointer(&'a [Layout<'a>], &'a Layout<'a>), Closure(&'a [Layout<'a>], LambdaSet<'a>, &'a Layout<'a>), } @@ -204,16 +203,13 @@ impl<'a> LambdaSet<'a> { } } - pub fn extend_function_layout( + fn extend_function_layout( &self, arena: &'a Bump, argument_layouts: &'a [Layout<'a>], ret_layout: &'a Layout<'a>, ) -> Layout<'a> { - Layout::FunctionPointer( - self.extend_argument_list(arena, argument_layouts), - ret_layout, - ) + todo!() } pub fn extend_argument_list( @@ -526,10 +522,6 @@ impl<'a> Layout<'a> { } } } - FunctionPointer(_, _) => { - // Function pointers are immutable and can always be safely copied - true - } Closure(_, closure_layout, _) => closure_layout.safe_to_memcpy(), RecursivePointer => { // We cannot memcpy pointers, because then we would have the same pointer in multiple places! @@ -581,7 +573,6 @@ impl<'a> Layout<'a> { } } Closure(_, lambda_set, _) => lambda_set.stack_size(pointer_size), - FunctionPointer(_, _) => pointer_size, RecursivePointer => pointer_size, } } @@ -613,7 +604,6 @@ impl<'a> Layout<'a> { } Layout::Builtin(builtin) => builtin.alignment_bytes(pointer_size), Layout::RecursivePointer => pointer_size, - Layout::FunctionPointer(_, _) => pointer_size, Layout::Closure(_, captured, _) => { pointer_size.max(captured.alignment_bytes(pointer_size)) } @@ -668,7 +658,6 @@ impl<'a> Layout<'a> { } RecursivePointer => true, Closure(_, closure_layout, _) => closure_layout.contains_refcounted(), - FunctionPointer(_, _) => false, } } @@ -692,14 +681,6 @@ impl<'a> Layout<'a> { } Union(union_layout) => union_layout.to_doc(alloc, parens), RecursivePointer => alloc.text("*self"), - FunctionPointer(args, result) => { - let args_doc = args.iter().map(|x| x.to_doc(alloc, Parens::InFunction)); - - alloc - .intersperse(args_doc, ", ") - .append(alloc.text(" -> ")) - .append(result.to_doc(alloc, Parens::InFunction)) - } Closure(args, closure_layout, result) => { let args_doc = args.iter().map(|x| x.to_doc(alloc, Parens::InFunction)); From 718aa34b19ee1ac137172e743a394a6a4ab06a52 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 19 Jun 2021 14:56:37 +0200 Subject: [PATCH 298/496] clippy --- compiler/gen_llvm/src/llvm/build.rs | 122 +---------------------- compiler/gen_llvm/src/llvm/build_list.rs | 51 +--------- compiler/gen_llvm/src/llvm/convert.rs | 18 ---- compiler/mono/src/layout.rs | 9 -- 4 files changed, 4 insertions(+), 196 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 9fac0259ba..b828ba2231 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -17,8 +17,8 @@ use crate::llvm::build_str::{ }; use crate::llvm::compare::{generic_eq, generic_neq}; use crate::llvm::convert::{ - basic_type_from_builtin, basic_type_from_function_layout, basic_type_from_layout, - block_of_memory, block_of_memory_slices, ptr_int, + basic_type_from_builtin, basic_type_from_layout, block_of_memory, block_of_memory_slices, + ptr_int, }; use crate::llvm::refcounting::{ decrement_refcount_layout, increment_refcount_layout, PointerToRefcount, @@ -53,7 +53,6 @@ use roc_mono::ir::{ TopLevelFunctionLayout, Wrapped, }; use roc_mono::layout::{Builtin, InPlace, LambdaSet, Layout, LayoutIds, UnionLayout}; -use std::convert::TryFrom; /// This is for Inkwell's FunctionValue::verify - we want to know the verification /// output in debug builds, but we don't want it to print to stdout in release builds! @@ -3400,122 +3399,6 @@ pub fn build_closure_caller<'a, 'ctx, 'env>( build_host_exposed_alias_size(env, def_name, alias_symbol, layout); } -fn build_function_caller<'a, 'ctx, 'env>( - env: &'a Env<'a, 'ctx, 'env>, - def_name: &str, - alias_symbol: Symbol, - arguments: &[Layout<'a>], - result: &Layout<'a>, -) { - let context = &env.context; - let builder = env.builder; - - // STEP 1: build function header - - // e.g. `roc__main_1_Fx_caller` - let function_name = format!( - "roc_{}_{}_caller", - def_name, - alias_symbol.ident_string(&env.interns) - ); - - let mut argument_types = Vec::with_capacity_in(arguments.len() + 3, env.arena); - - for layout in arguments { - let arg_type = basic_type_from_layout(env, layout); - let arg_ptr_type = arg_type.ptr_type(AddressSpace::Generic); - - argument_types.push(arg_ptr_type.into()); - } - - let function_pointer_type = { - let mut args = Vec::new_in(env.arena); - args.extend(arguments.iter().cloned()); - - // pretend the closure layout is empty - args.push(Layout::Struct(&[])); - - // this is already a (function) pointer type - basic_type_from_function_layout(env, &args, result) - }; - argument_types.push(function_pointer_type); - - let closure_argument_type = { - let basic_type = basic_type_from_layout(env, &Layout::Struct(&[])); - - basic_type.ptr_type(AddressSpace::Generic) - }; - argument_types.push(closure_argument_type.into()); - - let result_type = basic_type_from_layout(env, result); - - let roc_call_result_type = - context.struct_type(&[context.i64_type().into(), result_type], false); - - let output_type = { roc_call_result_type.ptr_type(AddressSpace::Generic) }; - argument_types.push(output_type.into()); - - let function_type = context.void_type().fn_type(&argument_types, false); - - let function_value = add_func( - env.module, - function_name.as_str(), - function_type, - Linkage::External, - C_CALL_CONV, - ); - - // STEP 2: build function body - - let entry = context.append_basic_block(function_value, "entry"); - - builder.position_at_end(entry); - - let mut parameters = function_value.get_params(); - let output = parameters.pop().unwrap().into_pointer_value(); - let _closure_data_ptr = parameters.pop().unwrap().into_pointer_value(); - let function_ptr = parameters.pop().unwrap().into_pointer_value(); - - let actual_function_type = basic_type_from_function_layout(env, arguments, result); - - let function_ptr = builder - .build_bitcast(function_ptr, actual_function_type, "cast") - .into_pointer_value(); - - let mut parameters = parameters; - - for param in parameters.iter_mut() { - debug_assert!(param.is_pointer_value()); - *param = builder.build_load(param.into_pointer_value(), "load_param"); - } - - let call_result = invoke_and_catch( - env, - function_value, - CallableValue::try_from(function_ptr).unwrap(), - C_CALL_CONV, - ¶meters, - result_type, - ); - - builder.build_store(output, call_result); - - builder.build_return(None); - - // STEP 3: build a {} -> u64 function that gives the size of the return type - build_host_exposed_alias_size_help( - env, - def_name, - alias_symbol, - Some("result"), - roc_call_result_type.into(), - ); - - // STEP 4: build a {} -> u64 function that gives the size of the function - let layout = Layout::Struct(&[]); - build_host_exposed_alias_size(env, def_name, alias_symbol, layout); -} - fn build_host_exposed_alias_size<'a, 'ctx, 'env>( env: &'a Env<'a, 'ctx, 'env>, def_name: &str, @@ -3584,7 +3467,6 @@ pub fn build_proc<'a, 'ctx, 'env>( ) { use roc_mono::ir::HostExposedLayouts; let copy = proc.host_exposed_layouts.clone(); - let fn_name = fn_val.get_name().to_string_lossy(); match copy { HostExposedLayouts::NotHostExposed => {} HostExposedLayouts::HostExposed { rigids: _, aliases } => { diff --git a/compiler/gen_llvm/src/llvm/build_list.rs b/compiler/gen_llvm/src/llvm/build_list.rs index 9aaecaf7b4..337687dddc 100644 --- a/compiler/gen_llvm/src/llvm/build_list.rs +++ b/compiler/gen_llvm/src/llvm/build_list.rs @@ -1,7 +1,7 @@ #![allow(clippy::too_many_arguments)] use crate::llvm::bitcode::{ - build_dec_wrapper, build_eq_wrapper, build_inc_n_wrapper, build_inc_wrapper, - build_transform_caller, call_bitcode_fn, call_void_bitcode_fn, + build_dec_wrapper, build_eq_wrapper, build_inc_n_wrapper, build_inc_wrapper, call_bitcode_fn, + call_void_bitcode_fn, }; use crate::llvm::build::{ allocate_with_refcount_help, cast_basic_basic, complex_bitcast, Env, RocFunctionCall, @@ -658,53 +658,6 @@ pub fn list_keep_errs<'a, 'ctx, 'env>( ) } -fn list_keep_result<'a, 'ctx, 'env>( - env: &Env<'a, 'ctx, 'env>, - layout_ids: &mut LayoutIds<'a>, - transform: FunctionValue<'ctx>, - transform_layout: Layout<'a>, - closure_data: BasicValueEnum<'ctx>, - closure_data_layout: Layout<'a>, - list: BasicValueEnum<'ctx>, - before_layout: &Layout<'a>, - after_layout: &Layout<'a>, - op: &str, -) -> BasicValueEnum<'ctx> { - let builder = env.builder; - - let result_layout = match transform_layout { - Layout::Closure(_, _, ret) => ret, - _ => unreachable!("not a callable layout"), - }; - - let closure_data_ptr = builder.build_alloca(closure_data.get_type(), "closure_data_ptr"); - env.builder.build_store(closure_data_ptr, closure_data); - - let stepper_caller = - build_transform_caller(env, transform, closure_data_layout, &[*before_layout]) - .as_global_value() - .as_pointer_value(); - - let inc_closure = build_inc_wrapper(env, layout_ids, &transform_layout); - let dec_result_fn = build_dec_wrapper(env, layout_ids, result_layout); - - call_bitcode_fn( - env, - &[ - pass_list_as_i128(env, list), - pass_as_opaque(env, closure_data_ptr), - stepper_caller.into(), - env.alignment_intvalue(&before_layout), - layout_width(env, before_layout), - layout_width(env, after_layout), - layout_width(env, result_layout), - inc_closure.as_global_value().as_pointer_value().into(), - dec_result_fn.as_global_value().as_pointer_value().into(), - ], - op, - ) -} - /// List.sortWith : List a, (a, a -> Ordering) -> List a pub fn list_sort_with<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, diff --git a/compiler/gen_llvm/src/llvm/convert.rs b/compiler/gen_llvm/src/llvm/convert.rs index a2514880bd..27b9c82356 100644 --- a/compiler/gen_llvm/src/llvm/convert.rs +++ b/compiler/gen_llvm/src/llvm/convert.rs @@ -4,24 +4,6 @@ use inkwell::types::{BasicType, BasicTypeEnum, IntType, StructType}; use inkwell::AddressSpace; use roc_mono::layout::{Builtin, Layout, UnionLayout}; -pub fn basic_type_from_function_layout<'a, 'ctx, 'env>( - env: &crate::llvm::build::Env<'a, 'ctx, 'env>, - args: &[Layout<'_>], - ret_layout: &Layout<'_>, -) -> BasicTypeEnum<'ctx> { - let ret_type = basic_type_from_layout(env, &ret_layout); - let mut arg_basic_types = Vec::with_capacity_in(args.len(), env.arena); - - for arg_layout in args.iter() { - arg_basic_types.push(basic_type_from_layout(env, arg_layout)); - } - - let fn_type = ret_type.fn_type(arg_basic_types.into_bump_slice(), false); - let ptr_type = fn_type.ptr_type(AddressSpace::Generic); - - ptr_type.as_basic_type_enum() -} - fn basic_type_from_record<'a, 'ctx, 'env>( env: &crate::llvm::build::Env<'a, 'ctx, 'env>, fields: &[Layout<'_>], diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index c1b836158a..63895b45ca 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -203,15 +203,6 @@ impl<'a> LambdaSet<'a> { } } - fn extend_function_layout( - &self, - arena: &'a Bump, - argument_layouts: &'a [Layout<'a>], - ret_layout: &'a Layout<'a>, - ) -> Layout<'a> { - todo!() - } - pub fn extend_argument_list( &self, arena: &'a Bump, From 6a010c951324c7f6991c4b8b11a672c7b5304fa9 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 19 Jun 2021 15:07:40 +0200 Subject: [PATCH 299/496] rename TopLevelFunctionLayout -> ProcLayout --- cli/src/repl/eval.rs | 6 +- compiler/gen_dev/src/object_builder.rs | 6 +- compiler/gen_llvm/src/llvm/build.rs | 18 +++--- compiler/load/src/file.rs | 16 +++--- compiler/mono/src/alias_analysis.rs | 5 +- compiler/mono/src/borrow.rs | 29 ++++------ compiler/mono/src/inc_dec.rs | 11 ++-- compiler/mono/src/ir.rs | 76 ++++++++++++-------------- compiler/mono/src/layout.rs | 4 +- compiler/test_mono/src/lib.rs | 4 +- 10 files changed, 79 insertions(+), 96 deletions(-) diff --git a/cli/src/repl/eval.rs b/cli/src/repl/eval.rs index 20f09f9466..d9912ac449 100644 --- a/cli/src/repl/eval.rs +++ b/cli/src/repl/eval.rs @@ -6,7 +6,7 @@ use roc_gen_llvm::{run_jit_function, run_jit_function_dynamic_type}; use roc_module::ident::{Lowercase, TagName}; use roc_module::operator::CalledVia; use roc_module::symbol::{Interns, ModuleId, Symbol}; -use roc_mono::ir::TopLevelFunctionLayout; +use roc_mono::ir::ProcLayout; use roc_mono::layout::{union_sorted_tags_help, Builtin, Layout, UnionLayout, UnionVariant}; use roc_parse::ast::{AssignedField, Expr, StrLiteral}; use roc_region::all::{Located, Region}; @@ -38,7 +38,7 @@ pub unsafe fn jit_to_ast<'a>( arena: &'a Bump, lib: Library, main_fn_name: &str, - layout: TopLevelFunctionLayout<'a>, + layout: ProcLayout<'a>, content: &Content, interns: &Interns, home: ModuleId, @@ -54,7 +54,7 @@ pub unsafe fn jit_to_ast<'a>( }; match layout { - TopLevelFunctionLayout { + ProcLayout { arguments: [], result, } => { diff --git a/compiler/gen_dev/src/object_builder.rs b/compiler/gen_dev/src/object_builder.rs index c2ccda29d2..e3b09d7b52 100644 --- a/compiler/gen_dev/src/object_builder.rs +++ b/compiler/gen_dev/src/object_builder.rs @@ -9,7 +9,7 @@ use object::{ }; use roc_collections::all::MutMap; use roc_module::symbol; -use roc_mono::ir::{Proc, TopLevelFunctionLayout}; +use roc_mono::ir::{Proc, ProcLayout}; use target_lexicon::{Architecture as TargetArch, BinaryFormat as TargetBF, Triple}; // This is used by some code below which is currently commented out. @@ -21,7 +21,7 @@ use target_lexicon::{Architecture as TargetArch, BinaryFormat as TargetBF, Tripl pub fn build_module<'a>( env: &'a Env, target: &Triple, - procedures: MutMap<(symbol::Symbol, TopLevelFunctionLayout<'a>), Proc<'a>>, + procedures: MutMap<(symbol::Symbol, ProcLayout<'a>), Proc<'a>>, ) -> Result { match target { Triple { @@ -144,7 +144,7 @@ fn generate_wrapper<'a, B: Backend<'a>>( fn build_object<'a, B: Backend<'a>>( env: &'a Env, - procedures: MutMap<(symbol::Symbol, TopLevelFunctionLayout<'a>), Proc<'a>>, + procedures: MutMap<(symbol::Symbol, ProcLayout<'a>), Proc<'a>>, mut backend: B, mut output: Object, ) -> Result { diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index b828ba2231..0a6afcb946 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -49,8 +49,8 @@ use roc_module::ident::TagName; use roc_module::low_level::LowLevel; use roc_module::symbol::{Interns, ModuleId, Symbol}; use roc_mono::ir::{ - BranchInfo, CallType, EntryPoint, ExceptionId, JoinPointId, ModifyRc, OptLevel, - TopLevelFunctionLayout, Wrapped, + BranchInfo, CallType, EntryPoint, ExceptionId, JoinPointId, ModifyRc, OptLevel, ProcLayout, + Wrapped, }; use roc_mono::layout::{Builtin, InPlace, LambdaSet, Layout, LayoutIds, UnionLayout}; @@ -117,7 +117,7 @@ impl<'ctx> Iterator for FunctionIterator<'ctx> { #[derive(Default, Debug, Clone, PartialEq)] pub struct Scope<'a, 'ctx> { symbols: ImMap, BasicValueEnum<'ctx>)>, - pub top_level_thunks: ImMap, FunctionValue<'ctx>)>, + pub top_level_thunks: ImMap, FunctionValue<'ctx>)>, join_points: ImMap, &'a [PointerValue<'ctx>])>, } @@ -131,7 +131,7 @@ impl<'a, 'ctx> Scope<'a, 'ctx> { pub fn insert_top_level_thunk( &mut self, symbol: Symbol, - layout: &'a TopLevelFunctionLayout<'a>, + layout: &'a ProcLayout<'a>, function_value: FunctionValue<'ctx>, ) { self.top_level_thunks @@ -587,7 +587,7 @@ fn promote_to_main_function<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, mod_solutions: &'a ModSolutions, symbol: Symbol, - top_level: TopLevelFunctionLayout<'a>, + top_level: ProcLayout<'a>, ) -> (&'static str, FunctionValue<'ctx>) { let it = top_level.arguments.iter().copied(); let bytes = roc_mono::alias_analysis::func_name_bytes_help(symbol, it, top_level.result); @@ -3101,7 +3101,7 @@ fn make_exception_catching_wrapper<'a, 'ctx, 'env>( pub fn build_proc_headers<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, mod_solutions: &'a ModSolutions, - procedures: MutMap<(Symbol, TopLevelFunctionLayout<'a>), roc_mono::ir::Proc<'a>>, + procedures: MutMap<(Symbol, ProcLayout<'a>), roc_mono::ir::Proc<'a>>, scope: &mut Scope<'a, 'ctx>, // alias_analysis_solutions: AliasAnalysisSolutions, ) -> Vec< @@ -3143,7 +3143,7 @@ pub fn build_proc_headers<'a, 'ctx, 'env>( pub fn build_procedures<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, opt_level: OptLevel, - procedures: MutMap<(Symbol, TopLevelFunctionLayout<'a>), roc_mono::ir::Proc<'a>>, + procedures: MutMap<(Symbol, ProcLayout<'a>), roc_mono::ir::Proc<'a>>, entry_point: EntryPoint<'a>, ) { build_procedures_help(env, opt_level, procedures, entry_point); @@ -3152,7 +3152,7 @@ pub fn build_procedures<'a, 'ctx, 'env>( pub fn build_procedures_return_main<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, opt_level: OptLevel, - procedures: MutMap<(Symbol, TopLevelFunctionLayout<'a>), roc_mono::ir::Proc<'a>>, + procedures: MutMap<(Symbol, ProcLayout<'a>), roc_mono::ir::Proc<'a>>, entry_point: EntryPoint<'a>, ) -> (&'static str, FunctionValue<'ctx>) { let mod_solutions = build_procedures_help(env, opt_level, procedures, entry_point); @@ -3163,7 +3163,7 @@ pub fn build_procedures_return_main<'a, 'ctx, 'env>( fn build_procedures_help<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, opt_level: OptLevel, - procedures: MutMap<(Symbol, TopLevelFunctionLayout<'a>), roc_mono::ir::Proc<'a>>, + procedures: MutMap<(Symbol, ProcLayout<'a>), roc_mono::ir::Proc<'a>>, entry_point: EntryPoint<'a>, ) -> &'a ModSolutions { let mut layout_ids = roc_mono::layout::LayoutIds::default(); diff --git a/compiler/load/src/file.rs b/compiler/load/src/file.rs index 51c98b6bfe..2eac6d663a 100644 --- a/compiler/load/src/file.rs +++ b/compiler/load/src/file.rs @@ -20,7 +20,7 @@ use roc_module::symbol::{ }; use roc_mono::ir::{ CapturedSymbols, EntryPoint, ExternalSpecializations, PartialProc, PendingSpecialization, Proc, - Procs, TopLevelFunctionLayout, + ProcLayout, Procs, }; use roc_mono::layout::{Layout, LayoutCache, LayoutProblem}; use roc_parse::ast::{self, StrLiteral, TypeAnnotation}; @@ -707,7 +707,7 @@ pub struct MonomorphizedModule<'a> { pub can_problems: MutMap>, pub type_problems: MutMap>, pub mono_problems: MutMap>, - pub procedures: MutMap<(Symbol, TopLevelFunctionLayout<'a>), Proc<'a>>, + pub procedures: MutMap<(Symbol, ProcLayout<'a>), Proc<'a>>, pub entry_point: EntryPoint<'a>, pub exposed_to_host: MutMap, pub header_sources: MutMap)>, @@ -779,7 +779,7 @@ enum Msg<'a> { ident_ids: IdentIds, layout_cache: LayoutCache<'a>, external_specializations_requested: BumpMap>, - procedures: MutMap<(Symbol, TopLevelFunctionLayout<'a>), Proc<'a>>, + procedures: MutMap<(Symbol, ProcLayout<'a>), Proc<'a>>, problems: Vec, module_timing: ModuleTiming, subs: Subs, @@ -827,7 +827,7 @@ struct State<'a> { pub module_cache: ModuleCache<'a>, pub dependencies: Dependencies<'a>, - pub procedures: MutMap<(Symbol, TopLevelFunctionLayout<'a>), Proc<'a>>, + pub procedures: MutMap<(Symbol, ProcLayout<'a>), Proc<'a>>, pub exposed_to_host: MutMap, /// This is the "final" list of IdentIds, after canonicalization and constraint gen @@ -858,7 +858,7 @@ struct State<'a> { pub needs_specialization: MutSet, pub all_pending_specializations: - MutMap, PendingSpecialization<'a>>>, + MutMap, PendingSpecialization<'a>>>, pub specializations_in_flight: u32, @@ -2232,7 +2232,7 @@ fn finish_specialization( // the entry point is not specialized. This can happen if the repl output // is a function value EntryPoint { - layout: roc_mono::ir::TopLevelFunctionLayout { + layout: roc_mono::ir::ProcLayout { arguments: &[], result: Layout::Struct(&[]), }, @@ -4049,7 +4049,7 @@ fn add_def_to_module<'a>( procs.insert_exposed( symbol, - TopLevelFunctionLayout::from_layout(mono_env.arena, layout), + ProcLayout::from_layout(mono_env.arena, layout), mono_env.arena, mono_env.subs, def.annotation, @@ -4087,7 +4087,7 @@ fn add_def_to_module<'a>( ) { Ok(l) => { // remember, this is a 0-argument thunk - TopLevelFunctionLayout::new(mono_env.arena, &[], l) + ProcLayout::new(mono_env.arena, &[], l) } Err(LayoutProblem::Erroneous) => { let message = "top level function has erroneous type"; diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index d3869033ea..24b83b98f4 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -173,10 +173,7 @@ where morphic_lib::solve(program) } -fn build_entry_point( - layout: crate::ir::TopLevelFunctionLayout, - func_name: FuncName, -) -> Result { +fn build_entry_point(layout: crate::ir::ProcLayout, func_name: FuncName) -> Result { let mut builder = FuncDefBuilder::new(); let block = builder.add_block(); diff --git a/compiler/mono/src/borrow.rs b/compiler/mono/src/borrow.rs index 54808abfaf..1d28bd091a 100644 --- a/compiler/mono/src/borrow.rs +++ b/compiler/mono/src/borrow.rs @@ -1,4 +1,4 @@ -use crate::ir::{Expr, JoinPointId, Param, Proc, Stmt, TopLevelFunctionLayout}; +use crate::ir::{Expr, JoinPointId, Param, Proc, ProcLayout, Stmt}; use crate::layout::Layout; use bumpalo::collections::Vec; use bumpalo::Bump; @@ -18,7 +18,7 @@ fn should_borrow_layout(layout: &Layout) -> bool { pub fn infer_borrow<'a>( arena: &'a Bump, - procs: &MutMap<(Symbol, TopLevelFunctionLayout<'a>), Proc<'a>>, + procs: &MutMap<(Symbol, ProcLayout<'a>), Proc<'a>>, ) -> ParamMap<'a> { let mut param_map = ParamMap { items: MutMap::default(), @@ -67,7 +67,7 @@ pub fn infer_borrow<'a>( #[derive(Debug, PartialEq, Eq, Hash, Clone)] pub enum Key<'a> { - Declaration(Symbol, TopLevelFunctionLayout<'a>), + Declaration(Symbol, ProcLayout<'a>), JoinPoint(JoinPointId), } @@ -96,11 +96,7 @@ impl<'a> IntoIterator for &'a ParamMap<'a> { } impl<'a> ParamMap<'a> { - pub fn get_symbol( - &self, - symbol: Symbol, - layout: TopLevelFunctionLayout<'a>, - ) -> Option<&'a [Param<'a>]> { + pub fn get_symbol(&self, symbol: Symbol, layout: ProcLayout<'a>) -> Option<&'a [Param<'a>]> { let key = Key::Declaration(symbol, layout); self.items.get(&key).copied() @@ -155,12 +151,7 @@ impl<'a> ParamMap<'a> { .into_bump_slice() } - fn visit_proc( - &mut self, - arena: &'a Bump, - proc: &Proc<'a>, - key: (Symbol, TopLevelFunctionLayout<'a>), - ) { + fn visit_proc(&mut self, arena: &'a Bump, proc: &Proc<'a>, key: (Symbol, ProcLayout<'a>)) { if proc.must_own_arguments { self.visit_proc_always_owned(arena, proc, key); return; @@ -178,7 +169,7 @@ impl<'a> ParamMap<'a> { &mut self, arena: &'a Bump, proc: &Proc<'a>, - key: (Symbol, TopLevelFunctionLayout<'a>), + key: (Symbol, ProcLayout<'a>), ) { let already_in_there = self.items.insert( Key::Declaration(proc.name, key.1), @@ -371,7 +362,7 @@ impl<'a> BorrowInfState<'a> { arg_layouts, .. } => { - let top_level = TopLevelFunctionLayout::new(self.arena, arg_layouts, *ret_layout); + let top_level = ProcLayout::new(self.arena, arg_layouts, *ret_layout); // get the borrow signature of the applied function let ps = self @@ -414,7 +405,7 @@ impl<'a> BorrowInfState<'a> { debug_assert!(op.is_higher_order()); - let closure_layout = TopLevelFunctionLayout { + let closure_layout = ProcLayout { arguments: arg_layouts, result: *ret_layout, }; @@ -609,7 +600,7 @@ impl<'a> BorrowInfState<'a> { Stmt::Ret(z), ) = (v, b) { - let top_level = TopLevelFunctionLayout::new(self.arena, arg_layouts, *ret_layout); + let top_level = ProcLayout::new(self.arena, arg_layouts, *ret_layout); if self.current_proc == *g && x == *z { // anonymous functions (for which the ps may not be known) @@ -702,7 +693,7 @@ impl<'a> BorrowInfState<'a> { } } - fn collect_proc(&mut self, proc: &Proc<'a>, layout: TopLevelFunctionLayout<'a>) { + fn collect_proc(&mut self, proc: &Proc<'a>, layout: ProcLayout<'a>) { let old = self.param_set.clone(); let ys = Vec::from_iter_in(proc.args.iter().map(|t| t.1), self.arena).into_bump_slice(); diff --git a/compiler/mono/src/inc_dec.rs b/compiler/mono/src/inc_dec.rs index 0e9964a8f5..d7ca917aa8 100644 --- a/compiler/mono/src/inc_dec.rs +++ b/compiler/mono/src/inc_dec.rs @@ -1,5 +1,5 @@ use crate::borrow::{ParamMap, BORROWED, OWNED}; -use crate::ir::{Expr, JoinPointId, ModifyRc, Param, Proc, Stmt, TopLevelFunctionLayout}; +use crate::ir::{Expr, JoinPointId, ModifyRc, Param, Proc, ProcLayout, Stmt}; use crate::layout::Layout; use bumpalo::collections::Vec; use bumpalo::Bump; @@ -497,7 +497,7 @@ impl<'a> Context<'a> { const FUNCTION: bool = BORROWED; const CLOSURE_DATA: bool = BORROWED; - let function_layout = TopLevelFunctionLayout { + let function_layout = ProcLayout { arguments: arg_layouts, result: *ret_layout, }; @@ -687,7 +687,7 @@ impl<'a> Context<'a> { arg_layouts, .. } => { - let top_level = TopLevelFunctionLayout::new(self.arena, arg_layouts, *ret_layout); + let top_level = ProcLayout::new(self.arena, arg_layouts, *ret_layout); // get the borrow signature let ps = self @@ -976,8 +976,7 @@ impl<'a> Context<'a> { arg_layouts, .. } => { - let top_level = - TopLevelFunctionLayout::new(self.arena, arg_layouts, *ret_layout); + let top_level = ProcLayout::new(self.arena, arg_layouts, *ret_layout); // get the borrow signature let ps = self @@ -1236,7 +1235,7 @@ pub fn visit_proc<'a>( arena: &'a Bump, param_map: &'a ParamMap<'a>, proc: &mut Proc<'a>, - layout: TopLevelFunctionLayout<'a>, + layout: ProcLayout<'a>, ) { let ctx = Context::new(arena, param_map); diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 671475c327..b7873a9acc 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -65,7 +65,7 @@ pub enum MonoProblem { #[derive(Debug, Clone, Copy)] pub struct EntryPoint<'a> { pub symbol: Symbol, - pub layout: TopLevelFunctionLayout<'a>, + pub layout: ProcLayout<'a>, } #[derive(Clone, Debug, PartialEq)] @@ -150,7 +150,7 @@ pub enum HostExposedLayouts<'a> { NotHostExposed, HostExposed { rigids: BumpMap>, - aliases: BumpMap, Layout<'a>)>, + aliases: BumpMap, Layout<'a>)>, }, } @@ -218,7 +218,7 @@ impl<'a> Proc<'a> { pub fn insert_refcount_operations( arena: &'a Bump, - procs: &mut MutMap<(Symbol, TopLevelFunctionLayout<'a>), Proc<'a>>, + procs: &mut MutMap<(Symbol, ProcLayout<'a>), Proc<'a>>, ) { let borrow_params = arena.alloc(crate::borrow::infer_borrow(arena, procs)); @@ -307,8 +307,8 @@ pub struct Procs<'a> { pub imported_module_thunks: BumpSet, pub module_thunks: BumpSet, pub pending_specializations: - Option, PendingSpecialization<'a>>>>, - pub specialized: BumpMap<(Symbol, TopLevelFunctionLayout<'a>), InProgressProc<'a>>, + Option, PendingSpecialization<'a>>>>, + pub specialized: BumpMap<(Symbol, ProcLayout<'a>), InProgressProc<'a>>, pub runtime_errors: BumpMap, pub call_by_pointer_wrappers: BumpMap, pub externals_we_need: BumpMap>, @@ -339,7 +339,7 @@ impl<'a> Procs<'a> { pub fn get_specialized_procs_without_rc( self, arena: &'a Bump, - ) -> MutMap<(Symbol, TopLevelFunctionLayout<'a>), Proc<'a>> { + ) -> MutMap<(Symbol, ProcLayout<'a>), Proc<'a>> { let mut result = MutMap::with_capacity_and_hasher(self.specialized.len(), default_hasher()); let cloned = self.specialized.clone(); @@ -387,7 +387,7 @@ impl<'a> Procs<'a> { pub fn get_specialized_procs( self, arena: &'a Bump, - ) -> MutMap<(Symbol, TopLevelFunctionLayout<'a>), Proc<'a>> { + ) -> MutMap<(Symbol, ProcLayout<'a>), Proc<'a>> { let mut result = MutMap::with_capacity_and_hasher(self.specialized.len(), default_hasher()); for ((s, toplevel), in_prog_proc) in self.specialized.into_iter() { @@ -428,7 +428,7 @@ impl<'a> Procs<'a> { self, arena: &'a Bump, ) -> ( - MutMap<(Symbol, TopLevelFunctionLayout<'a>), Proc<'a>>, + MutMap<(Symbol, ProcLayout<'a>), Proc<'a>>, &'a crate::borrow::ParamMap<'a>, ) { let mut result = MutMap::with_capacity_and_hasher(self.specialized.len(), default_hasher()); @@ -535,7 +535,7 @@ impl<'a> Procs<'a> { captured_symbols: CapturedSymbols<'a>, ret_var: Variable, layout_cache: &mut LayoutCache<'a>, - ) -> Result, RuntimeError> { + ) -> Result, RuntimeError> { // anonymous functions cannot reference themselves, therefore cannot be tail-recursive let is_self_recursive = false; @@ -543,7 +543,7 @@ impl<'a> Procs<'a> { .from_var(env.arena, annotation, env.subs) .unwrap_or_else(|err| panic!("TODO turn fn_var into a RuntimeError {:?}", err)); - let top_level = TopLevelFunctionLayout::from_layout(env.arena, layout); + let top_level = ProcLayout::from_layout(env.arena, layout); match patterns_to_when(env, layout_cache, loc_args, ret_var, loc_body) { Ok((_, pattern_symbols, body)) => { @@ -608,8 +608,7 @@ impl<'a> Procs<'a> { match specialize(env, self, symbol, layout_cache, pending, partial_proc) { Ok((proc, layout)) => { - let top_level = - TopLevelFunctionLayout::from_raw(env.arena, layout); + let top_level = ProcLayout::from_raw(env.arena, layout); debug_assert_eq!(outside_layout, top_level); @@ -637,7 +636,7 @@ impl<'a> Procs<'a> { pub fn insert_exposed( &mut self, name: Symbol, - layout: TopLevelFunctionLayout<'a>, + layout: ProcLayout<'a>, arena: &'a Bump, subs: &Subs, opt_annotation: Option, @@ -681,7 +680,7 @@ impl<'a> Procs<'a> { env: &mut Env<'a, '_>, fn_var: Variable, name: Symbol, - layout: TopLevelFunctionLayout<'a>, + layout: ProcLayout<'a>, layout_cache: &mut LayoutCache<'a>, ) { let tuple = (name, layout); @@ -745,10 +744,10 @@ impl<'a> Procs<'a> { fn add_pending<'a>( pending_specializations: &mut BumpMap< Symbol, - MutMap, PendingSpecialization<'a>>, + MutMap, PendingSpecialization<'a>>, >, symbol: Symbol, - layout: TopLevelFunctionLayout<'a>, + layout: ProcLayout<'a>, pending: PendingSpecialization<'a>, ) { let all_pending = pending_specializations @@ -1792,7 +1791,7 @@ pub fn specialize_all<'a>( ) { Ok((proc, layout)) => { // TODO thiscode is duplicated elsewhere - let top_level = TopLevelFunctionLayout::from_raw(env.arena, layout); + let top_level = ProcLayout::from_raw(env.arena, layout); if procs.module_thunks.contains(&proc.name) { debug_assert!( @@ -1811,8 +1810,7 @@ pub fn specialize_all<'a>( }) => { let proc = generate_runtime_error_function(env, name, attempted_layout); - let top_level = - TopLevelFunctionLayout::from_raw(env.arena, attempted_layout); + let top_level = ProcLayout::from_raw(env.arena, attempted_layout); procs.specialized.insert((name, top_level), Done(proc)); } @@ -1873,7 +1871,7 @@ fn specialize_all_help<'a>( partial_proc, ) { Ok((proc, layout)) => { - let top_level = TopLevelFunctionLayout::from_raw(env.arena, layout); + let top_level = ProcLayout::from_raw(env.arena, layout); if procs.module_thunks.contains(&name) { debug_assert!(top_level.arguments.is_empty()); @@ -1887,7 +1885,7 @@ fn specialize_all_help<'a>( }) => { let proc = generate_runtime_error_function(env, name, attempted_layout); - let top_level = TopLevelFunctionLayout::from_raw(env.arena, attempted_layout); + let top_level = ProcLayout::from_raw(env.arena, attempted_layout); procs.specialized.insert((name, top_level), Done(proc)); } @@ -2027,7 +2025,7 @@ fn specialize_external<'a>( host_exposed_layouts: HostExposedLayouts::NotHostExposed, }; - let top_level = TopLevelFunctionLayout::new( + let top_level = ProcLayout::new( env.arena, env.arena.alloc([lambda_set.runtime_representation()]), *return_layout, @@ -2599,12 +2597,12 @@ fn specialize_solved_type<'a>( } #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] -pub struct TopLevelFunctionLayout<'a> { +pub struct ProcLayout<'a> { pub arguments: &'a [Layout<'a>], pub result: Layout<'a>, } -impl<'a> TopLevelFunctionLayout<'a> { +impl<'a> ProcLayout<'a> { pub fn new(arena: &'a Bump, old_arguments: &'a [Layout<'a>], result: Layout<'a>) -> Self { let mut arguments = Vec::with_capacity_in(old_arguments.len(), arena); @@ -2623,7 +2621,7 @@ impl<'a> TopLevelFunctionLayout<'a> { other => other, }; - TopLevelFunctionLayout { + ProcLayout { arguments: arguments.into_bump_slice(), result: new_result, } @@ -2632,9 +2630,9 @@ impl<'a> TopLevelFunctionLayout<'a> { match layout { Layout::Closure(arguments, lambda_set, result) => { let arguments = lambda_set.extend_argument_list(arena, arguments); - TopLevelFunctionLayout::new(arena, arguments, *result) + ProcLayout::new(arena, arguments, *result) } - _ => TopLevelFunctionLayout { + _ => ProcLayout { arguments: &[], result: layout, }, @@ -2645,11 +2643,9 @@ impl<'a> TopLevelFunctionLayout<'a> { match raw { RawFunctionLayout::Function(a, b, c) => { let l = Layout::Closure(a, b, c); - TopLevelFunctionLayout::from_layout(arena, l) - } - RawFunctionLayout::ZeroArgumentThunk(result) => { - TopLevelFunctionLayout::new(arena, &[], result) + ProcLayout::from_layout(arena, l) } + RawFunctionLayout::ZeroArgumentThunk(result) => ProcLayout::new(arena, &[], result), } } } @@ -2729,7 +2725,7 @@ macro_rules! match_on_closure_argument { $layout_cache.from_var($env.arena, $closure_data_var, $env.subs) ); - let top_level = TopLevelFunctionLayout::from_layout($env.arena, closure_data_layout); + let top_level = ProcLayout::from_layout($env.arena, closure_data_layout); let arena = $env.arena; @@ -5913,7 +5909,7 @@ fn reuse_function_symbol<'a>( .expect("creating layout does not fail"); if procs.imported_module_thunks.contains(&original) { - let top_level = TopLevelFunctionLayout::new(env.arena, &[], layout); + let top_level = ProcLayout::new(env.arena, &[], layout); procs.insert_passed_by_name( env, arg_var, @@ -5924,7 +5920,7 @@ fn reuse_function_symbol<'a>( force_thunk(env, original, layout, symbol, env.arena.alloc(result)) } else { - let top_level = TopLevelFunctionLayout::from_layout(env.arena, layout); + let top_level = ProcLayout::from_layout(env.arena, layout); procs.insert_passed_by_name( env, arg_var, @@ -5967,7 +5963,7 @@ fn reuse_function_symbol<'a>( Ok(Layout::Closure(argument_layouts, lambda_set, ret_layout)) => { // define the function pointer let function_ptr_layout = - TopLevelFunctionLayout::from_layout(env.arena, res_layout.unwrap()); + ProcLayout::from_layout(env.arena, res_layout.unwrap()); if captures { // this is a closure by capture, meaning it itself captures local variables. @@ -6000,7 +5996,7 @@ fn reuse_function_symbol<'a>( } else if procs.module_thunks.contains(&original) { // this is a 0-argument thunk let layout = Layout::Closure(argument_layouts, lambda_set, ret_layout); - let top_level = TopLevelFunctionLayout::new(env.arena, &[], layout); + let top_level = ProcLayout::new(env.arena, &[], layout); procs.insert_passed_by_name( env, arg_var, @@ -6026,7 +6022,7 @@ fn reuse_function_symbol<'a>( } Ok(layout) => { // this is a 0-argument thunk - let top_level = TopLevelFunctionLayout::new(env.arena, &[], layout); + let top_level = ProcLayout::new(env.arena, &[], layout); procs.insert_passed_by_name(env, arg_var, original, top_level, layout_cache); force_thunk(env, original, layout, symbol, env.arena.alloc(result)) @@ -6334,7 +6330,7 @@ fn call_by_name_help<'a>( // debug_assert!(!procs.module_thunks.contains(&proc_name), "{:?}", proc_name); - let top_level_layout = TopLevelFunctionLayout::new(env.arena, argument_layouts, *ret_layout); + let top_level_layout = ProcLayout::new(env.arena, argument_layouts, *ret_layout); // the arguments given to the function, stored in symbols let field_symbols = Vec::from_iter_in( @@ -6556,7 +6552,7 @@ fn call_by_name_module_thunk<'a>( // debug_assert!(!procs.module_thunks.contains(&proc_name), "{:?}", proc_name); - let top_level_layout = TopLevelFunctionLayout::new(env.arena, &[], *ret_layout); + let top_level_layout = ProcLayout::new(env.arena, &[], *ret_layout); let inner_layout = *ret_layout; @@ -6673,7 +6669,7 @@ fn call_specialized_proc<'a>( assigned: Symbol, hole: &'a Stmt<'a>, ) -> Stmt<'a> { - let function_layout = TopLevelFunctionLayout::from_raw(env.arena, layout); + let function_layout = ProcLayout::from_raw(env.arena, layout); procs.specialized.remove(&(proc_name, function_layout)); diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index 63895b45ca..de70119f0e 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -1935,7 +1935,7 @@ impl LayoutId { struct IdsByLayout<'a> { by_id: MutMap, u32>, - toplevels_by_id: MutMap, u32>, + toplevels_by_id: MutMap, u32>, next_id: u32, } @@ -1975,7 +1975,7 @@ impl<'a> LayoutIds<'a> { pub fn get_toplevel<'b>( &mut self, symbol: Symbol, - layout: &'b crate::ir::TopLevelFunctionLayout<'a>, + layout: &'b crate::ir::ProcLayout<'a>, ) -> LayoutId { // Note: this function does some weird stuff to satisfy the borrow checker. // There's probably a nicer way to write it that still works. diff --git a/compiler/test_mono/src/lib.rs b/compiler/test_mono/src/lib.rs index efe0f54ecb..92d2a0f83e 100644 --- a/compiler/test_mono/src/lib.rs +++ b/compiler/test_mono/src/lib.rs @@ -23,7 +23,7 @@ use roc_collections::all::MutMap; use roc_module::symbol::Symbol; use roc_mono::ir::Proc; -use roc_mono::ir::TopLevelFunctionLayout; +use roc_mono::ir::ProcLayout; /// Without this, some tests pass in `cargo test --release` but fail without /// the --release flag because they run out of stack space. This increases @@ -146,7 +146,7 @@ fn compiles_to_ir(test_name: &str, src: &str) { #[cfg(debug_assertions)] fn verify_procedures( test_name: &str, - procedures: MutMap<(Symbol, TopLevelFunctionLayout<'_>), Proc<'_>>, + procedures: MutMap<(Symbol, ProcLayout<'_>), Proc<'_>>, main_fn_symbol: Symbol, ) { let index = procedures From 0a3cfd9a399ad95050545ba346492e39e1032270 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 19 Jun 2021 15:19:25 +0200 Subject: [PATCH 300/496] more raw function layout --- compiler/mono/src/ir.rs | 78 +++++++++++++++++++++++------------------ 1 file changed, 44 insertions(+), 34 deletions(-) diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index b7873a9acc..13d3886337 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -2722,10 +2722,10 @@ macro_rules! match_on_closure_argument { ($env:expr, $procs:expr, $layout_cache:expr, $closure_data_symbol:expr, $closure_data_var:expr, $op:expr, [$($x:expr),* $(,)?], $layout: expr, $assigned:expr, $hole:expr) => {{ let closure_data_layout = return_on_layout_error!( $env, - $layout_cache.from_var($env.arena, $closure_data_var, $env.subs) + $layout_cache.raw_from_var($env.arena, $closure_data_var, $env.subs) ); - let top_level = ProcLayout::from_layout($env.arena, closure_data_layout); + let top_level = ProcLayout::from_raw($env.arena, closure_data_layout); let arena = $env.arena; @@ -2733,7 +2733,7 @@ macro_rules! match_on_closure_argument { let ret_layout = top_level.result; match closure_data_layout { - Layout::Closure(_, lambda_set, _) => { + RawFunctionLayout::Function(_, lambda_set, _) => { lowlevel_match_on_lambda_set( $env, lambda_set, @@ -2754,7 +2754,7 @@ macro_rules! match_on_closure_argument { $hole, ) } - _ => unreachable!(), + RawFunctionLayout::ZeroArgumentThunk(_) => unreachable!(), } }}; } @@ -3576,16 +3576,16 @@ pub fn with_hole<'a>( layout_cache, ) { Ok(_) => { - let full_layout = return_on_layout_error!( + let raw_layout = return_on_layout_error!( env, - layout_cache.from_var(env.arena, function_var, env.subs) + layout_cache.raw_from_var(env.arena, function_var, env.subs) ); - match full_layout { - Layout::Closure(_, lambda_set, _) => { + match raw_layout { + RawFunctionLayout::Function(_, lambda_set, _) => { construct_closure_data(env, lambda_set, name, &[], assigned, hole) } - _ => unreachable!(), + RawFunctionLayout::ZeroArgumentThunk(_) => unreachable!(), } } @@ -4501,14 +4501,16 @@ fn tag_union_to_function<'a>( match inserted { Ok(_layout) => { // only need to construct closure data - let full_layout = - return_on_layout_error!(env, layout_cache.from_var(env.arena, whole_var, env.subs)); + let raw_layout = return_on_layout_error!( + env, + layout_cache.raw_from_var(env.arena, whole_var, env.subs) + ); - match full_layout { - Layout::Closure(_, lambda_set, _) => { + match raw_layout { + RawFunctionLayout::Function(_, lambda_set, _) => { construct_closure_data(env, lambda_set, proc_symbol, &[], assigned, hole) } - _ => unreachable!(), + RawFunctionLayout::ZeroArgumentThunk(_) => unreachable!(), } } @@ -4752,28 +4754,36 @@ pub fn from_can<'a>( // does this function capture any local values? let function_layout = - layout_cache.from_var(env.arena, function_type, env.subs); + layout_cache.raw_from_var(env.arena, function_type, env.subs); - let captured_symbols = if let Ok(Layout::Closure(_, lambda_set, _)) = - &function_layout - { - if let Layout::Struct(&[]) = lambda_set.runtime_representation() { - CapturedSymbols::None - } else { - let mut temp = Vec::from_iter_in(captured_symbols, env.arena); - temp.sort(); - CapturedSymbols::Captured(temp.into_bump_slice()) + let captured_symbols = match function_layout { + Ok(RawFunctionLayout::Function(_, lambda_set, _)) => { + if let Layout::Struct(&[]) = lambda_set.runtime_representation() + { + CapturedSymbols::None + } else { + let mut temp = + Vec::from_iter_in(captured_symbols, env.arena); + temp.sort(); + CapturedSymbols::Captured(temp.into_bump_slice()) + } + } + Ok(RawFunctionLayout::ZeroArgumentThunk(_)) => { + // top-level thunks cannot capture any variables + debug_assert!( + captured_symbols.is_empty(), + "{:?} with layout {:?} {:?} {:?}", + &captured_symbols, + function_layout, + env.subs, + (function_type, closure_type, closure_ext_var), + ); + CapturedSymbols::None + } + Err(_) => { + debug_assert!(captured_symbols.is_empty()); + CapturedSymbols::None } - } else { - debug_assert!( - captured_symbols.is_empty(), - "{:?} with layout {:?} {:?} {:?}", - &captured_symbols, - function_layout, - env.subs, - (function_type, closure_type, closure_ext_var), - ); - CapturedSymbols::None }; procs.insert_named( From 84df503193fbb251c5445fccd7346548a93d8ea9 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 19 Jun 2021 15:52:54 +0200 Subject: [PATCH 301/496] less Layout::Closure --- compiler/gen_llvm/src/llvm/build.rs | 10 ++++----- compiler/mono/src/ir.rs | 35 +++++++++++------------------ 2 files changed, 18 insertions(+), 27 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 0a6afcb946..ebe3a69f44 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -3466,13 +3466,14 @@ pub fn build_proc<'a, 'ctx, 'env>( fn_val: FunctionValue<'ctx>, ) { use roc_mono::ir::HostExposedLayouts; + use roc_mono::layout::RawFunctionLayout; let copy = proc.host_exposed_layouts.clone(); match copy { HostExposedLayouts::NotHostExposed => {} HostExposedLayouts::HostExposed { rigids: _, aliases } => { for (name, (symbol, top_level, layout)) in aliases { match layout { - Layout::Closure(arguments, closure, result) => { + RawFunctionLayout::Function(arguments, closure, result) => { // define closure size and return value size, e.g. // // * roc__mainForHost_1_Update_size() -> i64 @@ -3510,10 +3511,9 @@ pub fn build_proc<'a, 'ctx, 'env>( ) } - Layout::Builtin(_) => {} - Layout::Struct(_) => {} - Layout::Union(_) => {} - Layout::RecursivePointer => {} + RawFunctionLayout::ZeroArgumentThunk(_) => { + // do nothing + } } } } diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 13d3886337..3e398bb23e 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -150,7 +150,7 @@ pub enum HostExposedLayouts<'a> { NotHostExposed, HostExposed { rigids: BumpMap>, - aliases: BumpMap, Layout<'a>)>, + aliases: BumpMap, RawFunctionLayout<'a>)>, }, } @@ -1987,13 +1987,13 @@ fn specialize_external<'a>( for (symbol, variable) in host_exposed_variables { let layout = layout_cache - .from_var(env.arena, *variable, env.subs) + .raw_from_var(env.arena, *variable, env.subs) .unwrap(); let name = env.unique_symbol(); match layout { - Layout::Closure(argument_layouts, lambda_set, return_layout) => { + RawFunctionLayout::Function(argument_layouts, lambda_set, return_layout) => { let assigned = env.unique_symbol(); let unit = env.unique_symbol(); @@ -2037,7 +2037,7 @@ fn specialize_external<'a>( aliases.insert(*symbol, (name, top_level, layout)); } - _ => todo!(), + RawFunctionLayout::ZeroArgumentThunk(_) => unreachable!("so far"), } } @@ -5961,7 +5961,10 @@ fn reuse_function_symbol<'a>( // this symbol is a function, that is used by-name (e.g. as an argument to another // function). Register it with the current variable, then create a function pointer // to it in the IR. - let res_layout = layout_cache.from_var(env.arena, arg_var, env.subs); + let res_layout = return_on_layout_error!( + env, + layout_cache.raw_from_var(env.arena, arg_var, env.subs) + ); // we have three kinds of functions really. Plain functions, closures by capture, // and closures by unification. Here we record whether this function captures @@ -5970,10 +5973,9 @@ fn reuse_function_symbol<'a>( let captured = partial_proc.captured_symbols.clone(); match res_layout { - Ok(Layout::Closure(argument_layouts, lambda_set, ret_layout)) => { + RawFunctionLayout::Function(argument_layouts, lambda_set, ret_layout) => { // define the function pointer - let function_ptr_layout = - ProcLayout::from_layout(env.arena, res_layout.unwrap()); + let function_ptr_layout = ProcLayout::from_raw(env.arena, res_layout); if captures { // this is a closure by capture, meaning it itself captures local variables. @@ -6030,23 +6032,12 @@ fn reuse_function_symbol<'a>( return let_empty_struct(symbol, env.arena.alloc(result)); } } - Ok(layout) => { + RawFunctionLayout::ZeroArgumentThunk(ret_layout) => { // this is a 0-argument thunk - let top_level = ProcLayout::new(env.arena, &[], layout); + let top_level = ProcLayout::new(env.arena, &[], ret_layout); procs.insert_passed_by_name(env, arg_var, original, top_level, layout_cache); - force_thunk(env, original, layout, symbol, env.arena.alloc(result)) - } - Err(LayoutProblem::Erroneous) => { - let message = format!("The {:?} symbol has an erroneous type", symbol); - Stmt::RuntimeError(env.arena.alloc(message)) - } - Err(LayoutProblem::UnresolvedTypeVar(v)) => { - let message = format!( - "The {:?} symbol contains a unresolved type var {:?}", - symbol, v - ); - Stmt::RuntimeError(env.arena.alloc(message)) + force_thunk(env, original, ret_layout, symbol, env.arena.alloc(result)) } } } From 565a9626130a0131b1233654c63771c61a109731 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 19 Jun 2021 16:01:03 +0200 Subject: [PATCH 302/496] even more Layout::Closure --- compiler/mono/src/ir.rs | 49 +++++++++++------------------------------ 1 file changed, 13 insertions(+), 36 deletions(-) diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 3e398bb23e..602c5cd292 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -2241,8 +2241,8 @@ fn build_specialized_proc_from_var<'a>( pattern_symbols: &[Symbol], fn_var: Variable, ) -> Result, LayoutProblem> { - match layout_cache.from_var(env.arena, fn_var, env.subs) { - Ok(Layout::Closure(pattern_layouts, closure_layout, ret_layout)) => { + match layout_cache.raw_from_var(env.arena, fn_var, env.subs)? { + RawFunctionLayout::Function(pattern_layouts, closure_layout, ret_layout) => { let mut pattern_layouts_vec = Vec::with_capacity_in(pattern_layouts.len(), env.arena); pattern_layouts_vec.extend_from_slice(pattern_layouts); @@ -2255,40 +2255,17 @@ fn build_specialized_proc_from_var<'a>( *ret_layout, ) } - _ => { - match env.subs.get_without_compacting(fn_var).content { - Content::Structure(FlatType::Func(pattern_vars, closure_var, ret_var)) => { - let closure_layout = LambdaSet::from_var(env.arena, env.subs, closure_var)?; - build_specialized_proc_adapter( - env, - layout_cache, - proc_name, - pattern_symbols, - &pattern_vars, - Some(closure_layout), - ret_var, - ) - } - Content::Alias(_, _, actual) => build_specialized_proc_from_var( - env, - layout_cache, - proc_name, - pattern_symbols, - actual, - ), - _ => { - // a top-level constant 0-argument thunk - build_specialized_proc_adapter( - env, - layout_cache, - proc_name, - pattern_symbols, - &[], - None, - fn_var, - ) - } - } + RawFunctionLayout::ZeroArgumentThunk(_) => { + // a top-level constant 0-argument thunk + build_specialized_proc_adapter( + env, + layout_cache, + proc_name, + pattern_symbols, + &[], + None, + fn_var, + ) } } } From 3ba643df70e75e73dd24b316527e4d12faf085fa Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 19 Jun 2021 16:44:30 +0200 Subject: [PATCH 303/496] refactor --- compiler/mono/src/ir.rs | 47 ++++++++--------------------------------- 1 file changed, 9 insertions(+), 38 deletions(-) diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 602c5cd292..f6d1df0ecb 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -2255,49 +2255,19 @@ fn build_specialized_proc_from_var<'a>( *ret_layout, ) } - RawFunctionLayout::ZeroArgumentThunk(_) => { + RawFunctionLayout::ZeroArgumentThunk(ret_layout) => { // a top-level constant 0-argument thunk - build_specialized_proc_adapter( - env, - layout_cache, + build_specialized_proc( + env.arena, proc_name, pattern_symbols, - &[], + Vec::new_in(env.arena), None, - fn_var, + ret_layout, ) } } } -#[allow(clippy::type_complexity)] -fn build_specialized_proc_adapter<'a>( - env: &mut Env<'a, '_>, - layout_cache: &mut LayoutCache<'a>, - proc_name: Symbol, - pattern_symbols: &[Symbol], - pattern_vars: &[Variable], - closure_layout: Option>, - ret_var: Variable, -) -> Result, LayoutProblem> { - let mut arg_layouts = Vec::with_capacity_in(pattern_vars.len(), &env.arena); - - for arg_var in pattern_vars { - let layout = layout_cache.from_var(&env.arena, *arg_var, env.subs)?; - - arg_layouts.push(layout); - } - - let ret_layout = layout_cache.from_var(&env.arena, ret_var, env.subs)?; - - build_specialized_proc( - env.arena, - proc_name, - pattern_symbols, - arg_layouts, - closure_layout, - ret_layout, - ) -} #[allow(clippy::type_complexity)] fn build_specialized_proc<'a>( @@ -2510,6 +2480,7 @@ fn specialize_solved_type<'a>( let fn_var = introduce_solved_type_to_subs(env, &solved_type); + // for debugging only let attempted_layout = layout_cache .from_var(&env.arena, fn_var, env.subs) .unwrap_or_else(|err| panic!("TODO handle invalid function {:?}", err)); @@ -2618,9 +2589,9 @@ impl<'a> ProcLayout<'a> { fn from_raw(arena: &'a Bump, raw: RawFunctionLayout<'a>) -> Self { match raw { - RawFunctionLayout::Function(a, b, c) => { - let l = Layout::Closure(a, b, c); - ProcLayout::from_layout(arena, l) + RawFunctionLayout::Function(arguments, lambda_set, result) => { + let arguments = lambda_set.extend_argument_list(arena, arguments); + ProcLayout::new(arena, arguments, *result) } RawFunctionLayout::ZeroArgumentThunk(result) => ProcLayout::new(arena, &[], result), } From af4ee5156058c4e3ee16736f3db2e2814ba0918b Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 19 Jun 2021 16:56:27 +0200 Subject: [PATCH 304/496] get rid of InPlace --- compiler/gen_llvm/src/llvm/build.rs | 34 +++++++++--------------- compiler/gen_llvm/src/llvm/build_list.rs | 34 ++++++++---------------- compiler/gen_llvm/src/llvm/build_str.rs | 16 +++-------- compiler/mono/src/layout.rs | 22 --------------- 4 files changed, 26 insertions(+), 80 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index ebe3a69f44..64b48ac3b8 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -52,7 +52,7 @@ use roc_mono::ir::{ BranchInfo, CallType, EntryPoint, ExceptionId, JoinPointId, ModifyRc, OptLevel, ProcLayout, Wrapped, }; -use roc_mono::layout::{Builtin, InPlace, LambdaSet, Layout, LayoutIds, UnionLayout}; +use roc_mono::layout::{Builtin, LambdaSet, Layout, LayoutIds, UnionLayout}; /// This is for Inkwell's FunctionValue::verify - we want to know the verification /// output in debug builds, but we don't want it to print to stdout in release builds! @@ -1637,9 +1637,7 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( } } EmptyArray => empty_polymorphic_list(env), - Array { elem_layout, elems } => { - list_literal(env, layout.in_place(), scope, elem_layout, elems) - } + Array { elem_layout, elems } => list_literal(env, scope, elem_layout, elems), RuntimeErrorFunction(_) => todo!(), } } @@ -1793,7 +1791,6 @@ pub fn allocate_with_refcount_help<'a, 'ctx, 'env>( fn list_literal<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, - inplace: InPlace, scope: &Scope<'a, 'ctx>, elem_layout: &Layout<'a>, elems: &&[Symbol], @@ -1807,7 +1804,7 @@ fn list_literal<'a, 'ctx, 'env>( let len_type = env.ptr_int(); let len = len_type.const_int(len_u64, false); - allocate_list(env, inplace, elem_layout, len) + allocate_list(env, elem_layout, len) }; // Copy the elements from the list literal into the array @@ -4164,13 +4161,13 @@ fn run_low_level<'a, 'ctx, 'env>( // Str.concat : Str, Str -> Str debug_assert_eq!(args.len(), 2); - str_concat(env, layout.in_place(), scope, args[0], args[1]) + str_concat(env, scope, args[0], args[1]) } StrJoinWith => { // Str.joinWith : List Str, Str -> Str debug_assert_eq!(args.len(), 2); - str_join_with(env, layout.in_place(), scope, args[0], args[1]) + str_join_with(env, scope, args[0], args[1]) } StrStartsWith => { // Str.startsWith : Str, Str -> Bool @@ -4224,7 +4221,7 @@ fn run_low_level<'a, 'ctx, 'env>( // Str.split : Str, Str -> List Str debug_assert_eq!(args.len(), 2); - str_split(env, scope, layout.in_place(), args[0], args[1]) + str_split(env, scope, args[0], args[1]) } StrIsEmpty => { // Str.isEmpty : Str -> Str @@ -4259,7 +4256,7 @@ fn run_low_level<'a, 'ctx, 'env>( let (arg, arg_layout) = load_symbol_and_layout(scope, &args[0]); - list_single(env, layout.in_place(), arg, arg_layout) + list_single(env, arg, arg_layout) } ListRepeat => { // List.repeat : Int, elem -> List elem @@ -4276,7 +4273,7 @@ fn run_low_level<'a, 'ctx, 'env>( let (list, list_layout) = load_symbol_and_layout(scope, &args[0]); - list_reverse(env, layout.in_place(), list, list_layout) + list_reverse(env, list, list_layout) } ListConcat => { debug_assert_eq!(args.len(), 2); @@ -4285,14 +4282,7 @@ fn run_low_level<'a, 'ctx, 'env>( let second_list = load_symbol(scope, &args[1]); - list_concat( - env, - layout.in_place(), - parent, - first_list, - second_list, - list_layout, - ) + list_concat(env, parent, first_list, second_list, list_layout) } ListContains => { // List.contains : List elem, elem -> Bool @@ -4325,7 +4315,7 @@ fn run_low_level<'a, 'ctx, 'env>( let original_wrapper = load_symbol(scope, &args[0]).into_struct_value(); let (elem, elem_layout) = load_symbol_and_layout(scope, &args[1]); - list_append(env, layout.in_place(), original_wrapper, elem, elem_layout) + list_append(env, original_wrapper, elem, elem_layout) } ListSwap => { // List.swap : List elem, Nat, Nat -> List elem @@ -4377,7 +4367,7 @@ fn run_low_level<'a, 'ctx, 'env>( let original_wrapper = load_symbol(scope, &args[0]).into_struct_value(); let (elem, elem_layout) = load_symbol_and_layout(scope, &args[1]); - list_prepend(env, layout.in_place(), original_wrapper, elem, elem_layout) + list_prepend(env, original_wrapper, elem, elem_layout) } ListJoin => { // List.join : List (List elem) -> List elem @@ -4385,7 +4375,7 @@ fn run_low_level<'a, 'ctx, 'env>( let (list, outer_list_layout) = load_symbol_and_layout(scope, &args[0]); - list_join(env, layout.in_place(), parent, list, outer_list_layout) + list_join(env, parent, list, outer_list_layout) } NumAbs | NumNeg | NumRound | NumSqrtUnchecked | NumLogUnchecked | NumSin | NumCos | NumCeiling | NumFloor | NumToFloat | NumIsFinite | NumAtan | NumAcos | NumAsin => { diff --git a/compiler/gen_llvm/src/llvm/build_list.rs b/compiler/gen_llvm/src/llvm/build_list.rs index 337687dddc..f62442df02 100644 --- a/compiler/gen_llvm/src/llvm/build_list.rs +++ b/compiler/gen_llvm/src/llvm/build_list.rs @@ -14,7 +14,7 @@ use inkwell::types::{BasicType, BasicTypeEnum, PointerType}; use inkwell::values::{BasicValueEnum, FunctionValue, IntValue, PointerValue, StructValue}; use inkwell::{AddressSpace, IntPredicate}; use roc_builtins::bitcode; -use roc_mono::layout::{Builtin, InPlace, Layout, LayoutIds}; +use roc_mono::layout::{Builtin, Layout, LayoutIds}; fn list_returned_from_zig<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, @@ -83,7 +83,6 @@ pub fn pass_as_opaque<'a, 'ctx, 'env>( /// List.single : a -> List a pub fn list_single<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, - _inplace: InPlace, element: BasicValueEnum<'ctx>, element_layout: &Layout<'a>, ) -> BasicValueEnum<'ctx> { @@ -124,7 +123,6 @@ pub fn list_repeat<'a, 'ctx, 'env>( /// List.prepend : List elem, elem -> List elem pub fn list_prepend<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, - inplace: InPlace, original_wrapper: StructValue<'ctx>, elem: BasicValueEnum<'ctx>, elem_layout: &Layout<'a>, @@ -146,7 +144,7 @@ pub fn list_prepend<'a, 'ctx, 'env>( ); // Allocate space for the new array that we'll copy into. - let clone_ptr = allocate_list(env, inplace, elem_layout, new_list_len); + let clone_ptr = allocate_list(env, elem_layout, new_list_len); builder.build_store(clone_ptr, elem); @@ -189,7 +187,6 @@ pub fn list_prepend<'a, 'ctx, 'env>( /// List.join : List (List elem) -> List elem pub fn list_join<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, - _inplace: InPlace, _parent: FunctionValue<'ctx>, outer_list: BasicValueEnum<'ctx>, outer_list_layout: &Layout<'a>, @@ -221,17 +218,16 @@ pub fn list_join<'a, 'ctx, 'env>( /// List.reverse : List elem -> List elem pub fn list_reverse<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, - _output_inplace: InPlace, list: BasicValueEnum<'ctx>, list_layout: &Layout<'a>, ) -> BasicValueEnum<'ctx> { - let (_, element_layout) = match *list_layout { - Layout::Builtin(Builtin::EmptyList) => ( - InPlace::InPlace, + let element_layout = match *list_layout { + Layout::Builtin(Builtin::EmptyList) => { // this pointer will never actually be dereferenced - Layout::Builtin(Builtin::Int64), - ), - Layout::Builtin(Builtin::List(elem_layout)) => (InPlace::Clone, *elem_layout), + Layout::Builtin(Builtin::Int64) + } + + Layout::Builtin(Builtin::List(elem_layout)) => *elem_layout, _ => unreachable!("Invalid layout {:?} in List.reverse", list_layout), }; @@ -287,7 +283,6 @@ pub fn list_get_unsafe<'a, 'ctx, 'env>( /// List.append : List elem, elem -> List elem pub fn list_append<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, - _inplace: InPlace, original_wrapper: StructValue<'ctx>, element: BasicValueEnum<'ctx>, element_layout: &Layout<'a>, @@ -804,7 +799,6 @@ pub fn list_map3<'a, 'ctx, 'env>( /// List.concat : List elem, List elem -> List elem pub fn list_concat<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, - _inplace: InPlace, _parent: FunctionValue<'ctx>, first_list: BasicValueEnum<'ctx>, second_list: BasicValueEnum<'ctx>, @@ -1070,7 +1064,6 @@ pub fn load_list_ptr<'ctx>( pub fn allocate_list<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, - inplace: InPlace, elem_layout: &Layout<'a>, number_of_elements: IntValue<'ctx>, ) -> PointerValue<'ctx> { @@ -1083,14 +1076,9 @@ pub fn allocate_list<'a, 'ctx, 'env>( let number_of_data_bytes = builder.build_int_mul(bytes_per_element, number_of_elements, "data_length"); - let rc1 = match inplace { - InPlace::InPlace => number_of_elements, - InPlace::Clone => { - // the refcount of a new list is initially 1 - // we assume that the list is indeed used (dead variables are eliminated) - crate::llvm::refcounting::refcount_1(ctx, env.ptr_bytes) - } - }; + // the refcount of a new list is initially 1 + // we assume that the list is indeed used (dead variables are eliminated) + let rc1 = crate::llvm::refcounting::refcount_1(ctx, env.ptr_bytes); allocate_with_refcount_help(env, elem_layout, number_of_data_bytes, rc1) } diff --git a/compiler/gen_llvm/src/llvm/build_str.rs b/compiler/gen_llvm/src/llvm/build_str.rs index 4692f5eaa8..ee8576ceb8 100644 --- a/compiler/gen_llvm/src/llvm/build_str.rs +++ b/compiler/gen_llvm/src/llvm/build_str.rs @@ -6,7 +6,7 @@ use inkwell::values::{BasicValueEnum, FunctionValue, IntValue, PointerValue, Str use inkwell::AddressSpace; use roc_builtins::bitcode; use roc_module::symbol::Symbol; -use roc_mono::layout::{Builtin, InPlace, Layout}; +use roc_mono::layout::{Builtin, Layout}; use super::build::load_symbol; @@ -16,7 +16,6 @@ pub static CHAR_LAYOUT: Layout = Layout::Builtin(Builtin::Int8); pub fn str_split<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, scope: &Scope<'a, 'ctx>, - inplace: InPlace, str_symbol: Symbol, delimiter_symbol: Symbol, ) -> BasicValueEnum<'ctx> { @@ -33,7 +32,7 @@ pub fn str_split<'a, 'ctx, 'env>( .into_int_value(); // a pointer to the elements - let ret_list_ptr = allocate_list(env, inplace, &Layout::Builtin(Builtin::Str), segment_count); + let ret_list_ptr = allocate_list(env, &Layout::Builtin(Builtin::Str), segment_count); // get the RocStr type defined by zig let roc_str_type = env.module.get_struct_type("str.RocStr").unwrap(); @@ -109,7 +108,6 @@ pub fn destructure<'ctx>( /// Str.concat : Str, Str -> Str pub fn str_concat<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, - inplace: InPlace, scope: &Scope<'a, 'ctx>, str1_symbol: Symbol, str2_symbol: Symbol, @@ -120,14 +118,7 @@ pub fn str_concat<'a, 'ctx, 'env>( call_bitcode_fn( env, - &[ - env.context - .i8_type() - .const_int(inplace as u64, false) - .into(), - str1_i128.into(), - str2_i128.into(), - ], + &[str1_i128.into(), str2_i128.into()], &bitcode::STR_CONCAT, ) } @@ -135,7 +126,6 @@ pub fn str_concat<'a, 'ctx, 'env>( /// Str.join : List Str, Str -> Str pub fn str_join_with<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, - _inplace: InPlace, scope: &Scope<'a, 'ctx>, list_symbol: Symbol, str_symbol: Symbol, diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index de70119f0e..6f1c697960 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -20,13 +20,6 @@ impl Layout<'_> { pub const TAG_SIZE: Layout<'static> = Layout::Builtin(Builtin::Int64); } -#[derive(Copy, Clone)] -#[repr(u8)] -pub enum InPlace { - InPlace, - Clone, -} - #[derive(Debug, Clone)] pub enum LayoutProblem { UnresolvedTypeVar(Variable), @@ -60,19 +53,6 @@ pub enum Layout<'a> { Closure(&'a [Layout<'a>], LambdaSet<'a>, &'a Layout<'a>), } -impl<'a> Layout<'a> { - pub fn in_place(&self) -> InPlace { - match self { - Layout::Builtin(Builtin::EmptyList) => InPlace::InPlace, - Layout::Builtin(Builtin::List(_)) => InPlace::Clone, - Layout::Builtin(Builtin::EmptyStr) => InPlace::InPlace, - Layout::Builtin(Builtin::Str) => InPlace::Clone, - Layout::Builtin(Builtin::Int1) => InPlace::Clone, - _ => unreachable!("Layout {:?} does not have an inplace", self), - } - } -} - #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub enum UnionLayout<'a> { /// A non-recursive tag union @@ -720,8 +700,6 @@ impl<'a> CachedVariable<'a> { } } -// use ven_ena::unify::{InPlace, Snapshot, UnificationTable, UnifyKey}; - impl<'a> ven_ena::unify::UnifyKey for CachedVariable<'a> { type Value = CachedLayout<'a>; From 9d2976f14f1e80b2f320bfe8798f764f75b9924c Mon Sep 17 00:00:00 2001 From: Chadtech Date: Sat, 19 Jun 2021 13:35:57 -0400 Subject: [PATCH 305/496] Module aliases passed into LoadedModule, and used in docs to generate docs for aliases exposed by the module --- compiler/load/src/file.rs | 11 +++++++++++ docs/src/lib.rs | 15 +++++++++++++-- 2 files changed, 24 insertions(+), 2 deletions(-) diff --git a/compiler/load/src/file.rs b/compiler/load/src/file.rs index 14b5b0bf41..9258dc6a78 100644 --- a/compiler/load/src/file.rs +++ b/compiler/load/src/file.rs @@ -621,6 +621,7 @@ pub struct LoadedModule { pub type_problems: MutMap>, pub declarations_by_id: MutMap>, pub exposed_to_host: MutMap, + pub exposed_aliases: MutMap, pub header_sources: MutMap)>, pub sources: MutMap)>, pub timings: MutMap, @@ -763,6 +764,7 @@ enum Msg<'a> { FinishedAllTypeChecking { solved_subs: Solved, exposed_vars_by_symbol: MutMap, + exposed_aliases_by_symbol: MutMap, documentation: MutMap, }, FoundSpecializations { @@ -1510,6 +1512,7 @@ where Msg::FinishedAllTypeChecking { solved_subs, exposed_vars_by_symbol, + exposed_aliases_by_symbol, documentation, } => { // We're done! There should be no more messages pending. @@ -1525,6 +1528,7 @@ where return Ok(LoadResult::TypeChecked(finish( state, solved_subs, + exposed_aliases_by_symbol, exposed_vars_by_symbol, documentation, ))); @@ -1939,6 +1943,7 @@ fn update<'a>( .send(Msg::FinishedAllTypeChecking { solved_subs, exposed_vars_by_symbol: solved_module.exposed_vars_by_symbol, + exposed_aliases_by_symbol: solved_module.aliases, documentation, }) .map_err(|_| LoadingProblem::MsgChannelDied)?; @@ -2263,6 +2268,7 @@ fn finish_specialization( fn finish( state: State, solved: Solved, + exposed_aliases_by_symbol: MutMap, exposed_vars_by_symbol: MutMap, documentation: MutMap, ) -> LoadedModule { @@ -2290,6 +2296,10 @@ fn finish( .map(|(id, (path, src))| (id, (path, src.into()))) .collect(); + dbg!(&exposed_vars_by_symbol); + let exposed_aliases = exposed_aliases_by_symbol; + // todo!("Get exposed aliases"); + LoadedModule { module_id: state.root_id, interns, @@ -2298,6 +2308,7 @@ fn finish( type_problems: state.module_cache.type_problems, declarations_by_id: state.declarations_by_id, exposed_to_host: exposed_vars_by_symbol.into_iter().collect(), + exposed_aliases, header_sources, sources, timings: state.timings, diff --git a/docs/src/lib.rs b/docs/src/lib.rs index f96f89a6c2..05cb4aba02 100644 --- a/docs/src/lib.rs +++ b/docs/src/lib.rs @@ -63,12 +63,23 @@ pub fn generate(filenames: Vec, std_lib: StdLib, build_dir: &Path) { // Write each package's module docs html file for loaded_module in package.modules.iter_mut() { - let exposed_values = loaded_module + let mut exposed_values = loaded_module .exposed_to_host .iter() .map(|(symbol, _)| symbol.ident_string(&loaded_module.interns).to_string()) .collect::>(); + let mut exposed_aliases = loaded_module + .exposed_aliases + .iter() + .map(|(symbol, _)| symbol.ident_string(&loaded_module.interns).to_string()) + .collect::>(); + + let mut exports = Vec::new(); + + exports.append(&mut exposed_values); + exports.append(&mut exposed_aliases); + for module in loaded_module.documentation.values_mut() { let module_dir = build_dir.join(module.name.replace(".", "/").as_str()); @@ -83,7 +94,7 @@ pub fn generate(filenames: Vec, std_lib: StdLib, build_dir: &Path) { ) .replace( "", - render_main_content(&loaded_module.interns, &exposed_values, module).as_str(), + render_main_content(&loaded_module.interns, &exports, module).as_str(), ); fs::write(module_dir.join("index.html"), rendered_module) From a7abc8b5b3467e9d7d213b8f8b7529ffb4c74d4e Mon Sep 17 00:00:00 2001 From: Chadtech Date: Sat, 19 Jun 2021 13:37:10 -0400 Subject: [PATCH 306/496] Remove dbg and todo --- compiler/load/src/file.rs | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/compiler/load/src/file.rs b/compiler/load/src/file.rs index 9258dc6a78..572d224b05 100644 --- a/compiler/load/src/file.rs +++ b/compiler/load/src/file.rs @@ -2296,10 +2296,6 @@ fn finish( .map(|(id, (path, src))| (id, (path, src.into()))) .collect(); - dbg!(&exposed_vars_by_symbol); - let exposed_aliases = exposed_aliases_by_symbol; - // todo!("Get exposed aliases"); - LoadedModule { module_id: state.root_id, interns, @@ -2308,7 +2304,7 @@ fn finish( type_problems: state.module_cache.type_problems, declarations_by_id: state.declarations_by_id, exposed_to_host: exposed_vars_by_symbol.into_iter().collect(), - exposed_aliases, + exposed_aliases: exposed_aliases_by_symbol, header_sources, sources, timings: state.timings, From b20269d16deaeff068615118ce37896ea2f61ab7 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 19 Jun 2021 19:59:51 +0200 Subject: [PATCH 307/496] clippy --- cli/src/repl/eval.rs | 2 +- compiler/module/src/symbol.rs | 20 +++++++++----------- compiler/mono/src/ir.rs | 12 ++++++------ compiler/mono/src/layout.rs | 12 ++++++------ 4 files changed, 22 insertions(+), 24 deletions(-) diff --git a/cli/src/repl/eval.rs b/cli/src/repl/eval.rs index d9912ac449..e0e55541c2 100644 --- a/cli/src/repl/eval.rs +++ b/cli/src/repl/eval.rs @@ -176,7 +176,7 @@ fn jit_to_ast_help<'a>( ), Content::Structure(FlatType::Func(_, _, _)) => { // a function with a struct as the closure environment - return Err(ToAstProblem::FunctionLayout); + Err(ToAstProblem::FunctionLayout) } other => { unreachable!( diff --git a/compiler/module/src/symbol.rs b/compiler/module/src/symbol.rs index f56c5799f7..d107bdffe4 100644 --- a/compiler/module/src/symbol.rs +++ b/compiler/module/src/symbol.rs @@ -396,17 +396,15 @@ impl<'a> PackageModuleIds<'a> { fn insert_debug_name(module_id: ModuleId, module_name: &PQModuleName) { let mut names = DEBUG_MODULE_ID_NAMES.lock().expect("Failed to acquire lock for Debug interning into DEBUG_MODULE_ID_NAMES, presumably because a thread panicked."); - if !names.contains_key(&module_id.0) { - match module_name { - PQModuleName::Unqualified(module) => { - names.insert(module_id.0, module.to_string().into()); - } + names + .entry(module_id.0) + .or_insert_with(|| match module_name { + PQModuleName::Unqualified(module) => module.to_string().into(), PQModuleName::Qualified(package, module) => { let name = format!("{}.{}", package, module).into(); - names.insert(module_id.0, name); + name } - } - } + }); } #[cfg(not(debug_assertions))] @@ -464,9 +462,9 @@ impl ModuleIds { let mut names = DEBUG_MODULE_ID_NAMES.lock().expect("Failed to acquire lock for Debug interning into DEBUG_MODULE_ID_NAMES, presumably because a thread panicked."); // TODO make sure modules are never added more than once! - if !names.contains_key(&module_id.0) { - names.insert(module_id.0, module_name.to_string().into()); - } + names + .entry(module_id.0) + .or_insert_with(|| module_name.to_string().into()); } #[cfg(not(debug_assertions))] diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index f6d1df0ecb..9a91d5443e 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -957,9 +957,9 @@ pub enum ModifyRc { } impl ModifyRc { - pub fn to_doc<'b, D, A>(&'b self, alloc: &'b D) -> DocBuilder<'b, D, A> + pub fn to_doc<'a, D, A>(self, alloc: &'a D) -> DocBuilder<'a, D, A> where - D: DocAllocator<'b, A>, + D: DocAllocator<'a, A>, D::Doc: Clone, A: Clone, { @@ -968,20 +968,20 @@ impl ModifyRc { match self { Inc(symbol, 1) => alloc .text("inc ") - .append(symbol_to_doc(alloc, *symbol)) + .append(symbol_to_doc(alloc, symbol)) .append(";"), Inc(symbol, n) => alloc .text("inc ") .append(alloc.text(format!("{}", n))) - .append(symbol_to_doc(alloc, *symbol)) + .append(symbol_to_doc(alloc, symbol)) .append(";"), Dec(symbol) => alloc .text("dec ") - .append(symbol_to_doc(alloc, *symbol)) + .append(symbol_to_doc(alloc, symbol)) .append(";"), DecRef(symbol) => alloc .text("decref ") - .append(symbol_to_doc(alloc, *symbol)) + .append(symbol_to_doc(alloc, symbol)) .append(";"), } } diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index 6f1c697960..582fcec6c9 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -80,9 +80,9 @@ pub enum UnionLayout<'a> { } impl<'a> UnionLayout<'a> { - pub fn to_doc<'b, D, A>(&'b self, alloc: &'b D, _parens: Parens) -> DocBuilder<'b, D, A> + pub fn to_doc(self, alloc: &'a D, _parens: Parens) -> DocBuilder<'a, D, A> where - D: DocAllocator<'b, A>, + D: DocAllocator<'a, A>, D::Doc: Clone, A: Clone, { @@ -632,9 +632,9 @@ impl<'a> Layout<'a> { } } - pub fn to_doc<'b, D, A>(&'b self, alloc: &'b D, parens: Parens) -> DocBuilder<'b, D, A> + pub fn to_doc(self, alloc: &'a D, parens: Parens) -> DocBuilder<'a, D, A> where - D: DocAllocator<'b, A>, + D: DocAllocator<'a, A>, D::Doc: Clone, A: Clone, { @@ -919,9 +919,9 @@ impl<'a> Builtin<'a> { } } - pub fn to_doc<'b, D, A>(&'b self, alloc: &'b D, _parens: Parens) -> DocBuilder<'b, D, A> + pub fn to_doc(self, alloc: &'a D, _parens: Parens) -> DocBuilder<'a, D, A> where - D: DocAllocator<'b, A>, + D: DocAllocator<'a, A>, D::Doc: Clone, A: Clone, { From c26d20e4e503a4cf5d29eb63c6eb960ddc65dcf2 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 19 Jun 2021 20:19:14 +0200 Subject: [PATCH 308/496] fix code only used in release mode --- compiler/test_mono/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/test_mono/src/lib.rs b/compiler/test_mono/src/lib.rs index 92d2a0f83e..222dda0c5d 100644 --- a/compiler/test_mono/src/lib.rs +++ b/compiler/test_mono/src/lib.rs @@ -205,7 +205,7 @@ fn verify_procedures( #[cfg(not(debug_assertions))] fn verify_procedures( _expected: &str, - _procedures: MutMap<(Symbol, TopLevelFunctionLayout<'_>), Proc<'_>>, + _procedures: MutMap<(Symbol, ProcLayout<'_>), Proc<'_>>, _main_fn_symbol: Symbol, ) { // Do nothing From e912edcfdd00b8f1daa736f057f7bf0bb1b86095 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 19 Jun 2021 21:26:06 +0200 Subject: [PATCH 309/496] fix too many arguments --- compiler/builtins/bitcode/src/str.zig | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/compiler/builtins/bitcode/src/str.zig b/compiler/builtins/bitcode/src/str.zig index 845fd2b853..505a90bab1 100644 --- a/compiler/builtins/bitcode/src/str.zig +++ b/compiler/builtins/bitcode/src/str.zig @@ -910,13 +910,14 @@ test "endsWith: hello world ends with world" { } // Str.concat -pub fn strConcatC(result_in_place: InPlace, arg1: RocStr, arg2: RocStr) callconv(.C) RocStr { - return @call(.{ .modifier = always_inline }, strConcat, .{ result_in_place, arg1, arg2 }); +pub fn strConcatC(arg1: RocStr, arg2: RocStr) callconv(.C) RocStr { + return @call(.{ .modifier = always_inline }, strConcat, .{ arg1, arg2 }); } -fn strConcat(result_in_place: InPlace, arg1: RocStr, arg2: RocStr) RocStr { +fn strConcat(arg1: RocStr, arg2: RocStr) RocStr { if (arg1.isEmpty()) { // the second argument is borrowed, so we must increment its refcount before returning + const result_in_place = InPlace.Clone; return RocStr.clone(result_in_place, arg2); } else if (arg2.isEmpty()) { // the first argument is owned, so we can return it without cloning From f62a5c12b9c8bfcb216ef2ed6285b2fdc83d4652 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 19 Jun 2021 23:03:13 +0200 Subject: [PATCH 310/496] fix zig test --- compiler/builtins/bitcode/src/str.zig | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/builtins/bitcode/src/str.zig b/compiler/builtins/bitcode/src/str.zig index 505a90bab1..2a81b69fc6 100644 --- a/compiler/builtins/bitcode/src/str.zig +++ b/compiler/builtins/bitcode/src/str.zig @@ -975,7 +975,7 @@ test "RocStr.concat: small concat small" { roc_str3.deinit(); } - const result = strConcat(InPlace.Clone, roc_str1, roc_str2); + const result = strConcat(roc_str1, roc_str2); defer result.deinit(); From 342d1f34c2fbbf3e974a42972e756f3c65c19a74 Mon Sep 17 00:00:00 2001 From: Eric Correia Date: Sun, 20 Jun 2021 10:54:53 -0400 Subject: [PATCH 311/496] set up GetTagId --- compiler/gen_dev/src/lib.rs | 3 ++ compiler/gen_llvm/src/llvm/build.rs | 77 +++++++++++++++++++++++++++++ compiler/mono/src/alias_analysis.rs | 1 + compiler/mono/src/borrow.rs | 13 +++++ compiler/mono/src/inc_dec.rs | 19 +++++++ compiler/mono/src/ir.rs | 28 +++++++++-- 6 files changed, 136 insertions(+), 5 deletions(-) diff --git a/compiler/gen_dev/src/lib.rs b/compiler/gen_dev/src/lib.rs index e759657ed8..fad8a6eb39 100644 --- a/compiler/gen_dev/src/lib.rs +++ b/compiler/gen_dev/src/lib.rs @@ -447,6 +447,9 @@ where Expr::AccessAtIndex { structure, .. } => { self.set_last_seen(*structure, stmt); } + Expr::GetTagId { structure, .. } => { + self.set_last_seen(*structure, stmt); + } Expr::Array { elems, .. } => { for sym in *elems { self.set_last_seen(*sym, stmt); diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 64b48ac3b8..2f964bfce4 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -1639,6 +1639,83 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( EmptyArray => empty_polymorphic_list(env), Array { elem_layout, elems } => list_literal(env, scope, elem_layout, elems), RuntimeErrorFunction(_) => todo!(), + GetTagId { + structure, + union_layout, + } => { + let builder = env.builder; + + // cast the argument bytes into the desired shape for this tag + let (argument, _structure_layout) = load_symbol_and_layout(scope, structure); + + match union_layout { + UnionLayout::NonRecursive(_) => { + let pointer = builder.build_alloca(argument.get_type(), "get_type"); + builder.build_store(pointer, argument); + let tag_id_pointer = builder.build_bitcast( + pointer, + env.context.i64_type().ptr_type(AddressSpace::Generic), + "tag_id_pointer", + ); + builder.build_load(tag_id_pointer.into_pointer_value(), "load_tag_id") + } + UnionLayout::Recursive(_) => { + let pointer = builder.build_alloca(argument.get_type(), "get_type"); + builder.build_store(pointer, argument); + let tag_id_pointer = builder.build_bitcast( + pointer, + env.context.i64_type().ptr_type(AddressSpace::Generic), + "tag_id_pointer", + ); + builder.build_load(tag_id_pointer.into_pointer_value(), "load_tag_id") + } + UnionLayout::NonNullableUnwrapped(_) => env.context.i64_type().const_zero().into(), + UnionLayout::NullableWrapped { nullable_id, .. } => { + let argument_ptr = argument.into_pointer_value(); + let is_null = env.builder.build_is_null(argument_ptr, "is_null"); + + let ctx = env.context; + let then_block = ctx.append_basic_block(parent, "then"); + let else_block = ctx.append_basic_block(parent, "else"); + let cont_block = ctx.append_basic_block(parent, "cont"); + + let result = builder.build_alloca(ctx.i64_type(), "result"); + + env.builder + .build_conditional_branch(is_null, then_block, else_block); + + { + env.builder.position_at_end(then_block); + let tag_id = ctx.i64_type().const_int(*nullable_id as u64, false); + env.builder.build_store(result, tag_id); + env.builder.build_unconditional_branch(cont_block); + } + + { + env.builder.position_at_end(else_block); + let tag_id = extract_tag_discriminant_ptr(env, argument_ptr); + env.builder.build_store(result, tag_id); + env.builder.build_unconditional_branch(cont_block); + } + + env.builder.position_at_end(cont_block); + + env.builder.build_load(result, "load_result") + } + UnionLayout::NullableUnwrapped { nullable_id, .. } => { + let argument_ptr = argument.into_pointer_value(); + let is_null = env.builder.build_is_null(argument_ptr, "is_null"); + + let ctx = env.context; + + let then_value = ctx.i64_type().const_int(*nullable_id as u64, false); + let else_value = ctx.i64_type().const_int(!*nullable_id as u64, false); + + env.builder + .build_select(is_null, then_value, else_value, "select_tag_id") + } + } + } } } diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 24b83b98f4..2de7e9e9b5 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -934,6 +934,7 @@ fn expr_spec( builder.add_terminate(block, type_id) } + GetTagId { .. } => builder.add_make_tuple(block, &[]), } } diff --git a/compiler/mono/src/borrow.rs b/compiler/mono/src/borrow.rs index 1d28bd091a..34513f92c8 100644 --- a/compiler/mono/src/borrow.rs +++ b/compiler/mono/src/borrow.rs @@ -580,6 +580,19 @@ impl<'a> BorrowInfState<'a> { Call(call) => self.collect_call(z, call), Literal(_) | RuntimeErrorFunction(_) => {} + + GetTagId { structure: x, .. } => { + // if the structure (record/tag/array) is owned, the extracted value is + if self.is_owned(*x) { + self.own_var(z); + } + + // if the extracted value is owned, the structure must be too + if self.is_owned(z) { + self.own_var(*x); + } + } + } } diff --git a/compiler/mono/src/inc_dec.rs b/compiler/mono/src/inc_dec.rs index d7ca917aa8..ef39024848 100644 --- a/compiler/mono/src/inc_dec.rs +++ b/compiler/mono/src/inc_dec.rs @@ -129,6 +129,12 @@ pub fn occurring_variables_expr(expr: &Expr<'_>, result: &mut MutSet) { } EmptyArray | RuntimeErrorFunction(_) | Literal(_) => {} + + GetTagId { + structure: symbol, .. + } => { + result.insert(*symbol); + } } } @@ -753,6 +759,19 @@ impl<'a> Context<'a> { // function pointers are persistent self.arena.alloc(Stmt::Let(z, v, l, b)) } + + GetTagId { structure: x, .. } => { + let b = self.add_dec_if_needed(x, b, b_live_vars); + let info_x = self.get_var_info(x); + let b = if info_x.consume { + self.add_inc(z, 1, b) + } else { + b + }; + + self.arena.alloc(Stmt::Let(z, v, l, b)) + } + }; (new_b, live_vars) diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 9a91d5443e..d937033115 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -1192,6 +1192,11 @@ pub enum Expr<'a> { wrapped: Wrapped, }, + GetTagId { + structure: Symbol, + union_layout: UnionLayout<'a>, + }, + Array { elem_layout: Layout<'a>, elems: &'a [Symbol], @@ -1344,6 +1349,10 @@ impl<'a> Expr<'a> { .append(symbol_to_doc(alloc, *structure)), RuntimeErrorFunction(s) => alloc.text(format!("ErrorFunction {}", s)), + + GetTagId { structure, .. } => alloc + .text("GetTagId") + .append(symbol_to_doc(alloc, *structure)), } } } @@ -5514,6 +5523,17 @@ fn substitute_in_expr<'a>( }), None => None, }, + + GetTagId { + structure, + union_layout, + } => match substitute(subs, *structure) { + Some(structure) => Some(GetTagId { + structure, + union_layout: *union_layout, + }), + None => None, + }, } } @@ -7577,7 +7597,7 @@ where ToLowLevelCall: Fn(Symbol, Symbol, Option>, CallSpecId) -> Call<'a> + Copy, { match lambda_set.runtime_representation() { - Layout::Union(_) => { + Layout::Union(union_layout) => { let closure_tag_id_symbol = env.unique_symbol(); let result = lowlevel_union_lambda_set_to_switch( @@ -7594,11 +7614,9 @@ where ); // extract & assign the closure_tag_id_symbol - let expr = Expr::AccessAtIndex { - index: 0, - field_layouts: env.arena.alloc([Layout::Builtin(Builtin::Int64)]), + let expr = Expr::GetTagId { structure: closure_data_symbol, - wrapped: Wrapped::MultiTagUnion, + union_layout, }; Stmt::Let( From db05e55752daa73d2dae36227ebf9661a10e20ce Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 20 Jun 2021 17:00:24 +0200 Subject: [PATCH 312/496] add tag union closure test --- .../generated/specialize_lowlevel.txt | 46 +++++++++++++++++++ compiler/test_mono/src/lib.rs | 45 ++++++++---------- 2 files changed, 66 insertions(+), 25 deletions(-) create mode 100644 compiler/test_mono/generated/specialize_lowlevel.txt diff --git a/compiler/test_mono/generated/specialize_lowlevel.txt b/compiler/test_mono/generated/specialize_lowlevel.txt new file mode 100644 index 0000000000..8b7fd1f420 --- /dev/null +++ b/compiler/test_mono/generated/specialize_lowlevel.txt @@ -0,0 +1,46 @@ +procedure Num.24 (#Attr.2, #Attr.3): + let Test.26 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Test.26; + +procedure Num.26 (#Attr.2, #Attr.3): + let Test.21 = lowlevel NumMul #Attr.2 #Attr.3; + ret Test.21; + +procedure Test.6 (Test.8, #Attr.12): + let Test.4 = Index 1 #Attr.12; + let Test.25 = CallByName Num.24 Test.8 Test.4; + ret Test.25; + +procedure Test.7 (Test.9, #Attr.12): + let Test.5 = Index 1 #Attr.12; + let Test.20 = CallByName Num.26 Test.9 Test.5; + ret Test.20; + +procedure Test.0 (): + let Test.4 = 1i64; + let Test.5 = 2i64; + let Test.12 = 42i64; + joinpoint Test.19 Test.13: + let Test.14 = Index 0 Test.13; + joinpoint Test.15 Test.11: + ret Test.11; + in + switch Test.14: + case 0: + let Test.16 = CallByName Test.6 Test.12 Test.13; + jump Test.15 Test.16; + + default: + let Test.17 = CallByName Test.7 Test.12 Test.13; + jump Test.15 Test.17; + + in + let Test.24 = true; + if Test.24 then + let Test.28 = 0i64; + let Test.6 = ClosureTag(Test.6) Test.28 Test.4; + jump Test.19 Test.6; + else + let Test.23 = 1i64; + let Test.7 = ClosureTag(Test.7) Test.23 Test.5; + jump Test.19 Test.7; diff --git a/compiler/test_mono/src/lib.rs b/compiler/test_mono/src/lib.rs index 222dda0c5d..403ef32904 100644 --- a/compiler/test_mono/src/lib.rs +++ b/compiler/test_mono/src/lib.rs @@ -1057,37 +1057,32 @@ fn specialize_closures() { ) } -// ignore doesn't seem to work with the new macro -// #[ignore] -// #[mono_test] -// fn specialize_lowlevel() { -// indoc!( -// r#" -// app "test" provides [ main ] to "./platform" +#[mono_test] +fn specialize_lowlevel() { + indoc!( + r#" + app "test" provides [ main ] to "./platform" -// apply : (a -> a), a -> a -// apply = \f, x -> f x + apply : (a -> a), a -> a + apply = \f, x -> f x -// main = -// one : I64 -// one = 1 + main = + one : I64 + one = 1 -// two : I64 -// two = 2 + two : I64 + two = 2 -// increment : I64 -> I64 -// increment = \x -> x + 1 + increment : I64 -> I64 + increment = \x -> x + one -// double : I64 -> I64 -// double = \x -> x * two + double : I64 -> I64 + double = \x -> x * two -// when 3 is -// 1 -> increment 0 -// 2 -> double 0 -// _ -> List.map [] (if True then increment else double) |> List.len -// "# -// ) -// } + (if True then increment else double) 42 + "# + ) +} // #[ignore] // #[mono_test] From 1e7cb5da000e96fa34e3dc4b92df982ad30322d8 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 20 Jun 2021 17:02:32 +0200 Subject: [PATCH 313/496] use GetTagId --- compiler/mono/src/ir.rs | 10 ++++------ compiler/test_mono/generated/specialize_lowlevel.txt | 2 +- 2 files changed, 5 insertions(+), 7 deletions(-) diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index d937033115..3addb67f74 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -1351,7 +1351,7 @@ impl<'a> Expr<'a> { RuntimeErrorFunction(s) => alloc.text(format!("ErrorFunction {}", s)), GetTagId { structure, .. } => alloc - .text("GetTagId") + .text("GetTagId ") .append(symbol_to_doc(alloc, *structure)), } } @@ -7755,7 +7755,7 @@ fn match_on_lambda_set<'a>( hole: &'a Stmt<'a>, ) -> Stmt<'a> { match lambda_set.runtime_representation() { - Layout::Union(_) => { + Layout::Union(union_layout) => { let closure_tag_id_symbol = env.unique_symbol(); let result = union_lambda_set_to_switch( @@ -7773,11 +7773,9 @@ fn match_on_lambda_set<'a>( ); // extract & assign the closure_tag_id_symbol - let expr = Expr::AccessAtIndex { - index: 0, - field_layouts: env.arena.alloc([Layout::Builtin(Builtin::Int64)]), + let expr = Expr::GetTagId { structure: closure_data_symbol, - wrapped: Wrapped::MultiTagUnion, + union_layout, }; Stmt::Let( diff --git a/compiler/test_mono/generated/specialize_lowlevel.txt b/compiler/test_mono/generated/specialize_lowlevel.txt index 8b7fd1f420..6f36920266 100644 --- a/compiler/test_mono/generated/specialize_lowlevel.txt +++ b/compiler/test_mono/generated/specialize_lowlevel.txt @@ -21,7 +21,7 @@ procedure Test.0 (): let Test.5 = 2i64; let Test.12 = 42i64; joinpoint Test.19 Test.13: - let Test.14 = Index 0 Test.13; + let Test.14 = GetTagId Test.13; joinpoint Test.15 Test.11: ret Test.11; in From 08cb889e6e61f1c8b144f055b678ae196a576dec Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 20 Jun 2021 17:04:58 +0200 Subject: [PATCH 314/496] use GetTagId in test --- compiler/test_mono/generated/specialize_closures.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/test_mono/generated/specialize_closures.txt b/compiler/test_mono/generated/specialize_closures.txt index d2d87898bc..b67e0561b7 100644 --- a/compiler/test_mono/generated/specialize_closures.txt +++ b/compiler/test_mono/generated/specialize_closures.txt @@ -7,7 +7,7 @@ procedure Num.26 (#Attr.2, #Attr.3): ret Test.25; procedure Test.1 (Test.2, Test.3): - let Test.17 = Index 0 Test.2; + let Test.17 = GetTagId Test.2; joinpoint Test.18 Test.16: ret Test.16; in From 9ba488508323940e70d9db234dc1f16aabdd31d5 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 20 Jun 2021 18:12:18 +0200 Subject: [PATCH 315/496] use union layout in mono patterns --- compiler/mono/src/decision_tree.rs | 104 ++++++++++++++--------------- compiler/mono/src/ir.rs | 32 ++++----- 2 files changed, 68 insertions(+), 68 deletions(-) diff --git a/compiler/mono/src/decision_tree.rs b/compiler/mono/src/decision_tree.rs index b1a29b9be2..f292d7c660 100644 --- a/compiler/mono/src/decision_tree.rs +++ b/compiler/mono/src/decision_tree.rs @@ -220,8 +220,7 @@ fn flatten<'a>( } if union.alternatives.len() == 1 && !matches!( layout, - Layout::Union(UnionLayout::NullableWrapped { .. }) - | Layout::Union(UnionLayout::NullableUnwrapped { .. }) + UnionLayout::NullableWrapped { .. } | UnionLayout::NullableUnwrapped { .. } ) => { // TODO ^ do we need to check that guard.is_none() here? @@ -581,59 +580,60 @@ fn to_relevant_branch_help<'a>( debug_assert_eq!(tag_id, *test_id); // the test matches the constructor of this pattern - - match Wrapped::opt_from_layout(&layout) { - None => todo!(), - Some(wrapped) => { - match wrapped { - Wrapped::SingleElementRecord => { - // Theory: Unbox doesn't have any value for us - debug_assert_eq!(arguments.len(), 1); - let arg = arguments[0].clone(); - { - // NOTE here elm unboxes, but we ignore that - // Path::Unbox(Box::new(path.clone())) - start.push((path.to_vec(), guard, arg.0)); - start.extend(end); - } - } - Wrapped::RecordOrSingleTagUnion | Wrapped::LikeARoseTree => { - let sub_positions = arguments.into_iter().enumerate().map( - |(index, (pattern, _))| { - let mut new_path = path.to_vec(); - new_path.push(PathInstruction { - index: index as u64, - tag_id, - }); - (new_path, Guard::NoGuard, pattern) - }, - ); - start.extend(sub_positions); - start.extend(end); - } - Wrapped::MultiTagUnion => { - let sub_positions = arguments.into_iter().enumerate().map( - |(index, (pattern, _))| { - let mut new_path = path.to_vec(); - new_path.push(PathInstruction { - index: 1 + index as u64, - tag_id, - }); - (new_path, Guard::NoGuard, pattern) - }, - ); - start.extend(sub_positions); - start.extend(end); - } - Wrapped::EmptyRecord => todo!(), + match layout { + UnionLayout::NonRecursive([[Layout::Struct([_])]]) => { + // a one-element record equivalent + // Theory: Unbox doesn't have any value for us + debug_assert_eq!(arguments.len(), 1); + let arg = arguments[0].clone(); + { + // NOTE here elm unboxes, but we ignore that + // Path::Unbox(Box::new(path.clone())) + start.push((path.to_vec(), guard, arg.0)); + start.extend(end); } - - Some(Branch { - goal: branch.goal, - patterns: start, - }) + } + UnionLayout::NonRecursive([_]) | UnionLayout::NonNullableUnwrapped(_) => { + let sub_positions = + arguments + .into_iter() + .enumerate() + .map(|(index, (pattern, _))| { + let mut new_path = path.to_vec(); + new_path.push(PathInstruction { + index: index as u64, + tag_id, + }); + (new_path, Guard::NoGuard, pattern) + }); + start.extend(sub_positions); + start.extend(end); + } + UnionLayout::NonRecursive(_) + | UnionLayout::Recursive(_) + | UnionLayout::NullableWrapped { .. } + | UnionLayout::NullableUnwrapped { .. } => { + let sub_positions = + arguments + .into_iter() + .enumerate() + .map(|(index, (pattern, _))| { + let mut new_path = path.to_vec(); + new_path.push(PathInstruction { + index: 1 + index as u64, + tag_id, + }); + (new_path, Guard::NoGuard, pattern) + }); + start.extend(sub_positions); + start.extend(end); } } + + Some(Branch { + goal: branch.goal, + patterns: start, + }) } _ => None, } diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 3addb67f74..5b78778d7d 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -5589,7 +5589,7 @@ fn store_pattern_help<'a>( AppliedTag { arguments, layout, .. } => { - let wrapped = Wrapped::from_layout(layout); + let wrapped = Wrapped::from_layout(&Layout::Union(*layout)); let write_tag = wrapped == Wrapped::MultiTagUnion; let mut arg_layouts = Vec::with_capacity_in(arguments.len(), env.arena); @@ -5607,10 +5607,10 @@ fn store_pattern_help<'a>( for (index, (argument, arg_layout)) in arguments.iter().enumerate().rev() { let index = if write_tag { index + 1 } else { index }; - let mut arg_layout = arg_layout; + let mut arg_layout = *arg_layout; if let Layout::RecursivePointer = arg_layout { - arg_layout = layout; + arg_layout = Layout::Union(*layout); } let load = Expr::AccessAtIndex { @@ -5623,7 +5623,7 @@ fn store_pattern_help<'a>( match argument { Identifier(symbol) => { // store immediately in the given symbol - stmt = Stmt::Let(*symbol, load, *arg_layout, env.arena.alloc(stmt)); + stmt = Stmt::Let(*symbol, load, arg_layout, env.arena.alloc(stmt)); is_productive = true; } Underscore => { @@ -5645,7 +5645,7 @@ fn store_pattern_help<'a>( stmt = new; // only if we bind one of its (sub)fields to a used name should we // extract the field - stmt = Stmt::Let(symbol, load, *arg_layout, env.arena.alloc(stmt)); + stmt = Stmt::Let(symbol, load, arg_layout, env.arena.alloc(stmt)); } StorePattern::NotProductive(new) => { // do nothing @@ -6734,7 +6734,7 @@ pub enum Pattern<'a> { tag_name: TagName, tag_id: u8, arguments: Vec<'a, (Pattern<'a>, Layout<'a>)>, - layout: Layout<'a>, + layout: UnionLayout<'a>, union: crate::exhaustive::Union, }, } @@ -6928,7 +6928,9 @@ fn from_can_pattern_help<'a>( )); } - let layout = Layout::Struct(field_layouts.into_bump_slice()); + let layout = UnionLayout::NonRecursive( + env.arena.alloc([field_layouts.into_bump_slice()]), + ); Pattern::AppliedTag { tag_name: tag_name.clone(), @@ -7016,8 +7018,7 @@ fn from_can_pattern_help<'a>( temp }; - let layout = - Layout::Union(UnionLayout::NonRecursive(layouts.into_bump_slice())); + let layout = UnionLayout::NonRecursive(layouts.into_bump_slice()); Pattern::AppliedTag { tag_name: tag_name.clone(), @@ -7075,8 +7076,7 @@ fn from_can_pattern_help<'a>( }; debug_assert!(layouts.len() > 1); - let layout = - Layout::Union(UnionLayout::Recursive(layouts.into_bump_slice())); + let layout = UnionLayout::Recursive(layouts.into_bump_slice()); Pattern::AppliedTag { tag_name: tag_name.clone(), @@ -7121,7 +7121,7 @@ fn from_can_pattern_help<'a>( )); } - let layout = Layout::Union(UnionLayout::NonNullableUnwrapped(fields)); + let layout = UnionLayout::NonNullableUnwrapped(fields); Pattern::AppliedTag { tag_name: tag_name.clone(), @@ -7206,10 +7206,10 @@ fn from_can_pattern_help<'a>( temp }; - let layout = Layout::Union(UnionLayout::NullableWrapped { + let layout = UnionLayout::NullableWrapped { nullable_id, other_tags: layouts.into_bump_slice(), - }); + }; Pattern::AppliedTag { tag_name: tag_name.clone(), @@ -7267,10 +7267,10 @@ fn from_can_pattern_help<'a>( )); } - let layout = Layout::Union(UnionLayout::NullableUnwrapped { + let layout = UnionLayout::NullableUnwrapped { nullable_id, other_fields, - }); + }; Pattern::AppliedTag { tag_name: tag_name.clone(), From e84559aa4470dbeb58a35aca9da9f96d45a8120c Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 20 Jun 2021 18:12:31 +0200 Subject: [PATCH 316/496] Revert "use union layout in mono patterns" This reverts commit 9ba488508323940e70d9db234dc1f16aabdd31d5. --- compiler/mono/src/decision_tree.rs | 104 ++++++++++++++--------------- compiler/mono/src/ir.rs | 32 ++++----- 2 files changed, 68 insertions(+), 68 deletions(-) diff --git a/compiler/mono/src/decision_tree.rs b/compiler/mono/src/decision_tree.rs index f292d7c660..b1a29b9be2 100644 --- a/compiler/mono/src/decision_tree.rs +++ b/compiler/mono/src/decision_tree.rs @@ -220,7 +220,8 @@ fn flatten<'a>( } if union.alternatives.len() == 1 && !matches!( layout, - UnionLayout::NullableWrapped { .. } | UnionLayout::NullableUnwrapped { .. } + Layout::Union(UnionLayout::NullableWrapped { .. }) + | Layout::Union(UnionLayout::NullableUnwrapped { .. }) ) => { // TODO ^ do we need to check that guard.is_none() here? @@ -580,60 +581,59 @@ fn to_relevant_branch_help<'a>( debug_assert_eq!(tag_id, *test_id); // the test matches the constructor of this pattern - match layout { - UnionLayout::NonRecursive([[Layout::Struct([_])]]) => { - // a one-element record equivalent - // Theory: Unbox doesn't have any value for us - debug_assert_eq!(arguments.len(), 1); - let arg = arguments[0].clone(); - { - // NOTE here elm unboxes, but we ignore that - // Path::Unbox(Box::new(path.clone())) - start.push((path.to_vec(), guard, arg.0)); - start.extend(end); + + match Wrapped::opt_from_layout(&layout) { + None => todo!(), + Some(wrapped) => { + match wrapped { + Wrapped::SingleElementRecord => { + // Theory: Unbox doesn't have any value for us + debug_assert_eq!(arguments.len(), 1); + let arg = arguments[0].clone(); + { + // NOTE here elm unboxes, but we ignore that + // Path::Unbox(Box::new(path.clone())) + start.push((path.to_vec(), guard, arg.0)); + start.extend(end); + } + } + Wrapped::RecordOrSingleTagUnion | Wrapped::LikeARoseTree => { + let sub_positions = arguments.into_iter().enumerate().map( + |(index, (pattern, _))| { + let mut new_path = path.to_vec(); + new_path.push(PathInstruction { + index: index as u64, + tag_id, + }); + (new_path, Guard::NoGuard, pattern) + }, + ); + start.extend(sub_positions); + start.extend(end); + } + Wrapped::MultiTagUnion => { + let sub_positions = arguments.into_iter().enumerate().map( + |(index, (pattern, _))| { + let mut new_path = path.to_vec(); + new_path.push(PathInstruction { + index: 1 + index as u64, + tag_id, + }); + (new_path, Guard::NoGuard, pattern) + }, + ); + start.extend(sub_positions); + start.extend(end); + } + Wrapped::EmptyRecord => todo!(), } - } - UnionLayout::NonRecursive([_]) | UnionLayout::NonNullableUnwrapped(_) => { - let sub_positions = - arguments - .into_iter() - .enumerate() - .map(|(index, (pattern, _))| { - let mut new_path = path.to_vec(); - new_path.push(PathInstruction { - index: index as u64, - tag_id, - }); - (new_path, Guard::NoGuard, pattern) - }); - start.extend(sub_positions); - start.extend(end); - } - UnionLayout::NonRecursive(_) - | UnionLayout::Recursive(_) - | UnionLayout::NullableWrapped { .. } - | UnionLayout::NullableUnwrapped { .. } => { - let sub_positions = - arguments - .into_iter() - .enumerate() - .map(|(index, (pattern, _))| { - let mut new_path = path.to_vec(); - new_path.push(PathInstruction { - index: 1 + index as u64, - tag_id, - }); - (new_path, Guard::NoGuard, pattern) - }); - start.extend(sub_positions); - start.extend(end); + + Some(Branch { + goal: branch.goal, + patterns: start, + }) } } - - Some(Branch { - goal: branch.goal, - patterns: start, - }) } _ => None, } diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 5b78778d7d..3addb67f74 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -5589,7 +5589,7 @@ fn store_pattern_help<'a>( AppliedTag { arguments, layout, .. } => { - let wrapped = Wrapped::from_layout(&Layout::Union(*layout)); + let wrapped = Wrapped::from_layout(layout); let write_tag = wrapped == Wrapped::MultiTagUnion; let mut arg_layouts = Vec::with_capacity_in(arguments.len(), env.arena); @@ -5607,10 +5607,10 @@ fn store_pattern_help<'a>( for (index, (argument, arg_layout)) in arguments.iter().enumerate().rev() { let index = if write_tag { index + 1 } else { index }; - let mut arg_layout = *arg_layout; + let mut arg_layout = arg_layout; if let Layout::RecursivePointer = arg_layout { - arg_layout = Layout::Union(*layout); + arg_layout = layout; } let load = Expr::AccessAtIndex { @@ -5623,7 +5623,7 @@ fn store_pattern_help<'a>( match argument { Identifier(symbol) => { // store immediately in the given symbol - stmt = Stmt::Let(*symbol, load, arg_layout, env.arena.alloc(stmt)); + stmt = Stmt::Let(*symbol, load, *arg_layout, env.arena.alloc(stmt)); is_productive = true; } Underscore => { @@ -5645,7 +5645,7 @@ fn store_pattern_help<'a>( stmt = new; // only if we bind one of its (sub)fields to a used name should we // extract the field - stmt = Stmt::Let(symbol, load, arg_layout, env.arena.alloc(stmt)); + stmt = Stmt::Let(symbol, load, *arg_layout, env.arena.alloc(stmt)); } StorePattern::NotProductive(new) => { // do nothing @@ -6734,7 +6734,7 @@ pub enum Pattern<'a> { tag_name: TagName, tag_id: u8, arguments: Vec<'a, (Pattern<'a>, Layout<'a>)>, - layout: UnionLayout<'a>, + layout: Layout<'a>, union: crate::exhaustive::Union, }, } @@ -6928,9 +6928,7 @@ fn from_can_pattern_help<'a>( )); } - let layout = UnionLayout::NonRecursive( - env.arena.alloc([field_layouts.into_bump_slice()]), - ); + let layout = Layout::Struct(field_layouts.into_bump_slice()); Pattern::AppliedTag { tag_name: tag_name.clone(), @@ -7018,7 +7016,8 @@ fn from_can_pattern_help<'a>( temp }; - let layout = UnionLayout::NonRecursive(layouts.into_bump_slice()); + let layout = + Layout::Union(UnionLayout::NonRecursive(layouts.into_bump_slice())); Pattern::AppliedTag { tag_name: tag_name.clone(), @@ -7076,7 +7075,8 @@ fn from_can_pattern_help<'a>( }; debug_assert!(layouts.len() > 1); - let layout = UnionLayout::Recursive(layouts.into_bump_slice()); + let layout = + Layout::Union(UnionLayout::Recursive(layouts.into_bump_slice())); Pattern::AppliedTag { tag_name: tag_name.clone(), @@ -7121,7 +7121,7 @@ fn from_can_pattern_help<'a>( )); } - let layout = UnionLayout::NonNullableUnwrapped(fields); + let layout = Layout::Union(UnionLayout::NonNullableUnwrapped(fields)); Pattern::AppliedTag { tag_name: tag_name.clone(), @@ -7206,10 +7206,10 @@ fn from_can_pattern_help<'a>( temp }; - let layout = UnionLayout::NullableWrapped { + let layout = Layout::Union(UnionLayout::NullableWrapped { nullable_id, other_tags: layouts.into_bump_slice(), - }; + }); Pattern::AppliedTag { tag_name: tag_name.clone(), @@ -7267,10 +7267,10 @@ fn from_can_pattern_help<'a>( )); } - let layout = UnionLayout::NullableUnwrapped { + let layout = Layout::Union(UnionLayout::NullableUnwrapped { nullable_id, other_fields, - }; + }); Pattern::AppliedTag { tag_name: tag_name.clone(), From 01f6433556cf96761cf1f001c08ffe00a432e317 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 20 Jun 2021 18:13:56 +0200 Subject: [PATCH 317/496] improve data model for mono record pattern --- compiler/mono/src/ir.rs | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 3addb67f74..26531a6abe 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -5660,7 +5660,7 @@ fn store_pattern_help<'a>( return StorePattern::NotProductive(stmt); } } - RecordDestructure(destructs, Layout::Struct(sorted_fields)) => { + RecordDestructure(destructs, sorted_fields) => { let mut is_productive = false; for (index, destruct) in destructs.iter().enumerate().rev() { match store_record_destruct( @@ -5687,10 +5687,6 @@ fn store_pattern_help<'a>( return StorePattern::NotProductive(stmt); } } - - RecordDestructure(_, _) => { - unreachable!("a record destructure must always occur on a struct layout"); - } } StorePattern::Productive(stmt) @@ -6729,7 +6725,7 @@ pub enum Pattern<'a> { }, StrLiteral(Box), - RecordDestructure(Vec<'a, RecordDestruct<'a>>, Layout<'a>), + RecordDestructure(Vec<'a, RecordDestruct<'a>>, &'a [Layout<'a>]), AppliedTag { tag_name: TagName, tag_id: u8, @@ -7404,7 +7400,7 @@ fn from_can_pattern_help<'a>( Ok(Pattern::RecordDestructure( mono_destructs, - Layout::Struct(field_layouts.into_bump_slice()), + field_layouts.into_bump_slice(), )) } } From 61c9de91dc14338c8d34e879624d5336b2d3d425 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 20 Jun 2021 20:14:27 +0200 Subject: [PATCH 318/496] make newtype wrappers explicit in pattern code --- compiler/mono/src/decision_tree.rs | 53 ++++++++ compiler/mono/src/exhaustive.rs | 29 +++++ compiler/mono/src/ir.rs | 201 +++++++++++++++++------------ compiler/mono/src/layout.rs | 8 +- 4 files changed, 205 insertions(+), 86 deletions(-) diff --git a/compiler/mono/src/decision_tree.rs b/compiler/mono/src/decision_tree.rs index b1a29b9be2..b26fd9e134 100644 --- a/compiler/mono/src/decision_tree.rs +++ b/compiler/mono/src/decision_tree.rs @@ -425,6 +425,21 @@ fn test_at_path<'a>( }); } + NewtypeDestructure { + tag_name, + arguments, + } => { + let tag_id = 0; + let union = Union::newtype_wrapper(tag_name.clone(), arguments.len()); + + all_tests.push(IsCtor { + tag_id, + tag_name: tag_name.clone(), + union, + arguments: arguments.to_vec(), + }); + } + AppliedTag { tag_name, tag_id, @@ -565,6 +580,43 @@ fn to_relevant_branch_help<'a>( _ => None, }, + NewtypeDestructure { + tag_name, + arguments, + .. + } => match test { + IsCtor { + tag_name: test_name, + tag_id: test_id, + .. + } if &tag_name == test_name => { + let tag_id = 0; + debug_assert_eq!(tag_id, *test_id); + + let sub_positions = + arguments + .into_iter() + .enumerate() + .map(|(index, (pattern, _))| { + let mut new_path = path.to_vec(); + new_path.push(PathInstruction { + index: index as u64, + tag_id, + }); + (new_path, Guard::NoGuard, pattern) + }); + start.extend(sub_positions); + start.extend(end); + + Some(Branch { + goal: branch.goal, + patterns: start, + }) + } + + _ => None, + }, + AppliedTag { tag_name, tag_id, @@ -750,6 +802,7 @@ fn needs_tests(pattern: &Pattern) -> bool { Identifier(_) | Underscore => false, RecordDestructure(_, _) + | NewtypeDestructure { .. } | AppliedTag { .. } | BitLiteral { .. } | EnumLiteral { .. } diff --git a/compiler/mono/src/exhaustive.rs b/compiler/mono/src/exhaustive.rs index f3726960e8..4170015a7b 100644 --- a/compiler/mono/src/exhaustive.rs +++ b/compiler/mono/src/exhaustive.rs @@ -11,6 +11,21 @@ pub struct Union { pub render_as: RenderAs, } +impl Union { + pub fn newtype_wrapper(tag_name: TagName, arity: usize) -> Self { + let alternatives = vec![Ctor { + name: tag_name, + tag_id: TagId(0), + arity, + }]; + + Union { + alternatives, + render_as: RenderAs::Tag, + } + } +} + #[derive(Clone, Debug, PartialEq, Eq, Hash)] pub enum RenderAs { Tag, @@ -84,6 +99,20 @@ fn simplify(pattern: &crate::ir::Pattern) -> Pattern { Ctor(union, tag_id, patterns) } + NewtypeDestructure { + arguments, + tag_name, + } => { + let tag_id = 0; + let simplified_args: std::vec::Vec<_> = + arguments.iter().map(|v| simplify(&v.0)).collect(); + Ctor( + Union::newtype_wrapper(tag_name.clone(), arguments.len()), + TagId(tag_id), + simplified_args, + ) + } + AppliedTag { tag_id, arguments, diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 26531a6abe..7df6ccf403 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -4177,7 +4177,7 @@ fn convert_tag_union<'a>( ) } - Unwrapped { + Newtype { arguments: field_layouts, .. } => { @@ -5590,75 +5590,36 @@ fn store_pattern_help<'a>( arguments, layout, .. } => { let wrapped = Wrapped::from_layout(layout); - let write_tag = wrapped == Wrapped::MultiTagUnion; - let mut arg_layouts = Vec::with_capacity_in(arguments.len(), env.arena); - let mut is_productive = false; + return store_tag_pattern( + env, + procs, + layout_cache, + outer_symbol, + layout, + &arguments, + wrapped, + stmt, + ); + } + NewtypeDestructure { arguments, .. } => { + let mut fields = Vec::with_capacity_in(arguments.len(), env.arena); + fields.extend(arguments.iter().map(|x| x.1)); - if write_tag { - // add an element for the tag discriminant - arg_layouts.push(Layout::Builtin(TAG_SIZE)); - } + let layout = Layout::Struct(fields.into_bump_slice()); - for (_, layout) in arguments { - arg_layouts.push(*layout); - } + let wrapped = Wrapped::from_layout(&layout); - for (index, (argument, arg_layout)) in arguments.iter().enumerate().rev() { - let index = if write_tag { index + 1 } else { index }; - - let mut arg_layout = arg_layout; - - if let Layout::RecursivePointer = arg_layout { - arg_layout = layout; - } - - let load = Expr::AccessAtIndex { - wrapped, - index: index as u64, - field_layouts: arg_layouts.clone().into_bump_slice(), - structure: outer_symbol, - }; - - match argument { - Identifier(symbol) => { - // store immediately in the given symbol - stmt = Stmt::Let(*symbol, load, *arg_layout, env.arena.alloc(stmt)); - is_productive = true; - } - Underscore => { - // ignore - } - IntLiteral(_) - | FloatLiteral(_) - | EnumLiteral { .. } - | BitLiteral { .. } - | StrLiteral(_) => {} - _ => { - // store the field in a symbol, and continue matching on it - let symbol = env.unique_symbol(); - - // first recurse, continuing to unpack symbol - match store_pattern_help(env, procs, layout_cache, argument, symbol, stmt) { - StorePattern::Productive(new) => { - is_productive = true; - stmt = new; - // only if we bind one of its (sub)fields to a used name should we - // extract the field - stmt = Stmt::Let(symbol, load, *arg_layout, env.arena.alloc(stmt)); - } - StorePattern::NotProductive(new) => { - // do nothing - stmt = new; - } - } - } - } - } - - if !is_productive { - return StorePattern::NotProductive(stmt); - } + return store_tag_pattern( + env, + procs, + layout_cache, + outer_symbol, + &layout, + &arguments, + wrapped, + stmt, + ); } RecordDestructure(destructs, sorted_fields) => { let mut is_productive = false; @@ -5692,6 +5653,92 @@ fn store_pattern_help<'a>( StorePattern::Productive(stmt) } +#[allow(clippy::too_many_arguments)] +fn store_tag_pattern<'a>( + env: &mut Env<'a, '_>, + procs: &mut Procs<'a>, + layout_cache: &mut LayoutCache<'a>, + structure: Symbol, + layout: &Layout<'a>, + arguments: &[(Pattern<'a>, Layout<'a>)], + wrapped: Wrapped, + mut stmt: Stmt<'a>, +) -> StorePattern<'a> { + use Pattern::*; + + let write_tag = wrapped == Wrapped::MultiTagUnion; + + let mut arg_layouts = Vec::with_capacity_in(arguments.len(), env.arena); + let mut is_productive = false; + + if write_tag { + // add an element for the tag discriminant + arg_layouts.push(Layout::Builtin(TAG_SIZE)); + } + + for (_, layout) in arguments { + arg_layouts.push(*layout); + } + + for (index, (argument, arg_layout)) in arguments.iter().enumerate().rev() { + let index = if write_tag { index + 1 } else { index }; + + let mut arg_layout = *arg_layout; + + if let Layout::RecursivePointer = arg_layout { + arg_layout = *layout; + } + + let load = Expr::AccessAtIndex { + wrapped, + index: index as u64, + field_layouts: arg_layouts.clone().into_bump_slice(), + structure, + }; + + match argument { + Identifier(symbol) => { + // store immediately in the given symbol + stmt = Stmt::Let(*symbol, load, arg_layout, env.arena.alloc(stmt)); + is_productive = true; + } + Underscore => { + // ignore + } + IntLiteral(_) + | FloatLiteral(_) + | EnumLiteral { .. } + | BitLiteral { .. } + | StrLiteral(_) => {} + _ => { + // store the field in a symbol, and continue matching on it + let symbol = env.unique_symbol(); + + // first recurse, continuing to unpack symbol + match store_pattern_help(env, procs, layout_cache, argument, symbol, stmt) { + StorePattern::Productive(new) => { + is_productive = true; + stmt = new; + // only if we bind one of its (sub)fields to a used name should we + // extract the field + stmt = Stmt::Let(symbol, load, arg_layout, env.arena.alloc(stmt)); + } + StorePattern::NotProductive(new) => { + // do nothing + stmt = new; + } + } + } + } + } + + if is_productive { + StorePattern::Productive(stmt) + } else { + StorePattern::NotProductive(stmt) + } +} + #[allow(clippy::too_many_arguments)] fn store_record_destruct<'a>( env: &mut Env<'a, '_>, @@ -6726,6 +6773,10 @@ pub enum Pattern<'a> { StrLiteral(Box), RecordDestructure(Vec<'a, RecordDestruct<'a>>, &'a [Layout<'a>]), + NewtypeDestructure { + tag_name: TagName, + arguments: Vec<'a, (Pattern<'a>, Layout<'a>)>, + }, AppliedTag { tag_name: TagName, tag_id: u8, @@ -6887,19 +6938,10 @@ fn from_can_pattern_help<'a>( union, } } - Unwrapped { + Newtype { arguments: field_layouts, .. } => { - let union = crate::exhaustive::Union { - render_as: RenderAs::Tag, - alternatives: vec![Ctor { - tag_id: TagId(0), - name: tag_name.clone(), - arity: field_layouts.len(), - }], - }; - let mut arguments = arguments.clone(); arguments.sort_by(|arg1, arg2| { @@ -6924,14 +6966,9 @@ fn from_can_pattern_help<'a>( )); } - let layout = Layout::Struct(field_layouts.into_bump_slice()); - - Pattern::AppliedTag { + Pattern::NewtypeDestructure { tag_name: tag_name.clone(), - tag_id: 0, arguments: mono_args, - union, - layout, } } Wrapped(variant) => { diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index 582fcec6c9..f2f3b73544 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -279,7 +279,7 @@ impl<'a> LambdaSet<'a> { Unit | UnitWithArguments => Layout::Struct(&[]), BoolUnion { .. } => Layout::Builtin(Builtin::Int1), ByteUnion(_) => Layout::Builtin(Builtin::Int8), - Unwrapped { + Newtype { arguments: layouts, .. } => Layout::Struct(layouts.into_bump_slice()), Wrapped(variant) => { @@ -1285,7 +1285,7 @@ pub enum UnionVariant<'a> { ffalse: TagName, }, ByteUnion(Vec<'a, TagName>), - Unwrapped { + Newtype { tag_name: TagName, arguments: Vec<'a, Layout<'a>>, }, @@ -1506,7 +1506,7 @@ pub fn union_sorted_tags_help<'a>( fields: layouts.into_bump_slice(), }) } else { - UnionVariant::Unwrapped { + UnionVariant::Newtype { tag_name, arguments: layouts, } @@ -1661,7 +1661,7 @@ pub fn layout_from_tag_union<'a>( Unit | UnitWithArguments => Layout::Struct(&[]), BoolUnion { .. } => Layout::Builtin(Builtin::Int1), ByteUnion(_) => Layout::Builtin(Builtin::Int8), - Unwrapped { + Newtype { arguments: mut field_layouts, .. } => { From bc8bd95b3df13ea3547ef70d98c0debf3f68b104 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 20 Jun 2021 18:12:18 +0200 Subject: [PATCH 319/496] use union layout in mono patterns --- compiler/mono/src/decision_tree.rs | 104 ++++++++++++++--------------- compiler/mono/src/ir.rs | 51 +++++++------- 2 files changed, 77 insertions(+), 78 deletions(-) diff --git a/compiler/mono/src/decision_tree.rs b/compiler/mono/src/decision_tree.rs index b26fd9e134..055281f7dc 100644 --- a/compiler/mono/src/decision_tree.rs +++ b/compiler/mono/src/decision_tree.rs @@ -220,8 +220,7 @@ fn flatten<'a>( } if union.alternatives.len() == 1 && !matches!( layout, - Layout::Union(UnionLayout::NullableWrapped { .. }) - | Layout::Union(UnionLayout::NullableUnwrapped { .. }) + UnionLayout::NullableWrapped { .. } | UnionLayout::NullableUnwrapped { .. } ) => { // TODO ^ do we need to check that guard.is_none() here? @@ -633,59 +632,60 @@ fn to_relevant_branch_help<'a>( debug_assert_eq!(tag_id, *test_id); // the test matches the constructor of this pattern - - match Wrapped::opt_from_layout(&layout) { - None => todo!(), - Some(wrapped) => { - match wrapped { - Wrapped::SingleElementRecord => { - // Theory: Unbox doesn't have any value for us - debug_assert_eq!(arguments.len(), 1); - let arg = arguments[0].clone(); - { - // NOTE here elm unboxes, but we ignore that - // Path::Unbox(Box::new(path.clone())) - start.push((path.to_vec(), guard, arg.0)); - start.extend(end); - } - } - Wrapped::RecordOrSingleTagUnion | Wrapped::LikeARoseTree => { - let sub_positions = arguments.into_iter().enumerate().map( - |(index, (pattern, _))| { - let mut new_path = path.to_vec(); - new_path.push(PathInstruction { - index: index as u64, - tag_id, - }); - (new_path, Guard::NoGuard, pattern) - }, - ); - start.extend(sub_positions); - start.extend(end); - } - Wrapped::MultiTagUnion => { - let sub_positions = arguments.into_iter().enumerate().map( - |(index, (pattern, _))| { - let mut new_path = path.to_vec(); - new_path.push(PathInstruction { - index: 1 + index as u64, - tag_id, - }); - (new_path, Guard::NoGuard, pattern) - }, - ); - start.extend(sub_positions); - start.extend(end); - } - Wrapped::EmptyRecord => todo!(), + match layout { + UnionLayout::NonRecursive([[Layout::Struct([_])]]) => { + // a one-element record equivalent + // Theory: Unbox doesn't have any value for us + debug_assert_eq!(arguments.len(), 1); + let arg = arguments[0].clone(); + { + // NOTE here elm unboxes, but we ignore that + // Path::Unbox(Box::new(path.clone())) + start.push((path.to_vec(), guard, arg.0)); + start.extend(end); } - - Some(Branch { - goal: branch.goal, - patterns: start, - }) + } + UnionLayout::NonRecursive([_]) | UnionLayout::NonNullableUnwrapped(_) => { + let sub_positions = + arguments + .into_iter() + .enumerate() + .map(|(index, (pattern, _))| { + let mut new_path = path.to_vec(); + new_path.push(PathInstruction { + index: index as u64, + tag_id, + }); + (new_path, Guard::NoGuard, pattern) + }); + start.extend(sub_positions); + start.extend(end); + } + UnionLayout::NonRecursive(_) + | UnionLayout::Recursive(_) + | UnionLayout::NullableWrapped { .. } + | UnionLayout::NullableUnwrapped { .. } => { + let sub_positions = + arguments + .into_iter() + .enumerate() + .map(|(index, (pattern, _))| { + let mut new_path = path.to_vec(); + new_path.push(PathInstruction { + index: 1 + index as u64, + tag_id, + }); + (new_path, Guard::NoGuard, pattern) + }); + start.extend(sub_positions); + start.extend(end); } } + + Some(Branch { + goal: branch.goal, + patterns: start, + }) } _ => None, } diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 7df6ccf403..33b8af43e7 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -5586,22 +5586,6 @@ fn store_pattern_help<'a>( | StrLiteral(_) => { return StorePattern::NotProductive(stmt); } - AppliedTag { - arguments, layout, .. - } => { - let wrapped = Wrapped::from_layout(layout); - - return store_tag_pattern( - env, - procs, - layout_cache, - outer_symbol, - layout, - &arguments, - wrapped, - stmt, - ); - } NewtypeDestructure { arguments, .. } => { let mut fields = Vec::with_capacity_in(arguments.len(), env.arena); fields.extend(arguments.iter().map(|x| x.1)); @@ -5621,6 +5605,23 @@ fn store_pattern_help<'a>( stmt, ); } + AppliedTag { + arguments, layout, .. + } => { + let union_layout = Layout::Union(*layout); + let wrapped = Wrapped::from_layout(&union_layout); + + return store_tag_pattern( + env, + procs, + layout_cache, + outer_symbol, + &union_layout, + &arguments, + wrapped, + stmt, + ); + } RecordDestructure(destructs, sorted_fields) => { let mut is_productive = false; for (index, destruct) in destructs.iter().enumerate().rev() { @@ -6781,7 +6782,7 @@ pub enum Pattern<'a> { tag_name: TagName, tag_id: u8, arguments: Vec<'a, (Pattern<'a>, Layout<'a>)>, - layout: Layout<'a>, + layout: UnionLayout<'a>, union: crate::exhaustive::Union, }, } @@ -7049,8 +7050,7 @@ fn from_can_pattern_help<'a>( temp }; - let layout = - Layout::Union(UnionLayout::NonRecursive(layouts.into_bump_slice())); + let layout = UnionLayout::NonRecursive(layouts.into_bump_slice()); Pattern::AppliedTag { tag_name: tag_name.clone(), @@ -7108,8 +7108,7 @@ fn from_can_pattern_help<'a>( }; debug_assert!(layouts.len() > 1); - let layout = - Layout::Union(UnionLayout::Recursive(layouts.into_bump_slice())); + let layout = UnionLayout::Recursive(layouts.into_bump_slice()); Pattern::AppliedTag { tag_name: tag_name.clone(), @@ -7154,7 +7153,7 @@ fn from_can_pattern_help<'a>( )); } - let layout = Layout::Union(UnionLayout::NonNullableUnwrapped(fields)); + let layout = UnionLayout::NonNullableUnwrapped(fields); Pattern::AppliedTag { tag_name: tag_name.clone(), @@ -7239,10 +7238,10 @@ fn from_can_pattern_help<'a>( temp }; - let layout = Layout::Union(UnionLayout::NullableWrapped { + let layout = UnionLayout::NullableWrapped { nullable_id, other_tags: layouts.into_bump_slice(), - }); + }; Pattern::AppliedTag { tag_name: tag_name.clone(), @@ -7300,10 +7299,10 @@ fn from_can_pattern_help<'a>( )); } - let layout = Layout::Union(UnionLayout::NullableUnwrapped { + let layout = UnionLayout::NullableUnwrapped { nullable_id, other_fields, - }); + }; Pattern::AppliedTag { tag_name: tag_name.clone(), From 0de501554ad5a85e6fb27618326aa9da4a1ad29b Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 20 Jun 2021 20:49:36 +0200 Subject: [PATCH 320/496] use GetTagId --- compiler/gen_llvm/src/llvm/build.rs | 3 +- compiler/mono/src/decision_tree.rs | 67 ++++++++++++----------------- 2 files changed, 28 insertions(+), 42 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 2f964bfce4..92da76a01a 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -1660,8 +1660,7 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( builder.build_load(tag_id_pointer.into_pointer_value(), "load_tag_id") } UnionLayout::Recursive(_) => { - let pointer = builder.build_alloca(argument.get_type(), "get_type"); - builder.build_store(pointer, argument); + let pointer = argument.into_pointer_value(); let tag_id_pointer = builder.build_bitcast( pointer, env.context.i64_type().ptr_type(AddressSpace::Generic), diff --git a/compiler/mono/src/decision_tree.rs b/compiler/mono/src/decision_tree.rs index 055281f7dc..c8be7b874f 100644 --- a/compiler/mono/src/decision_tree.rs +++ b/compiler/mono/src/decision_tree.rs @@ -1161,58 +1161,45 @@ fn test_to_equality<'a>( Layout<'a>, Option>, ) { - let (rhs_symbol, mut stores, _layout) = + let (rhs_symbol, mut stores, test_layout) = path_to_expr_help(env, cond_symbol, &path, *cond_layout); match test { - Test::IsCtor { - tag_id, - union, - arguments, - .. - } => { + Test::IsCtor { tag_id, union, .. } => { let path_symbol = rhs_symbol; // the IsCtor check should never be generated for tag unions of size 1 // (e.g. record pattern guard matches) debug_assert!(union.alternatives.len() > 1); - let lhs = Expr::Literal(Literal::Int(tag_id as i128)); + match test_layout { + Layout::Union(union_layout) => { + let lhs = Expr::Literal(Literal::Int(tag_id as i128)); - let mut field_layouts = - bumpalo::collections::Vec::with_capacity_in(arguments.len(), env.arena); + let rhs = Expr::GetTagId { + structure: path_symbol, + union_layout, + }; - // add the tag discriminant - field_layouts.push(Layout::Builtin(Builtin::Int64)); + let lhs_symbol = env.unique_symbol(); + let rhs_symbol = env.unique_symbol(); - for (_, layout) in arguments { - field_layouts.push(layout); + stores.push((lhs_symbol, Layout::Builtin(Builtin::Int64), lhs)); + stores.push((rhs_symbol, Layout::Builtin(Builtin::Int64), rhs)); + + ( + stores, + lhs_symbol, + rhs_symbol, + Layout::Builtin(Builtin::Int64), + Some(ConstructorKnown::OnlyPass { + scrutinee: path_symbol, + layout: *cond_layout, + tag_id, + }), + ) + } + _ => unreachable!("{:?}", (cond_layout, union)), } - let field_layouts = field_layouts.into_bump_slice(); - - let rhs = Expr::AccessAtIndex { - index: 0, - field_layouts, - structure: path_symbol, - wrapped: Wrapped::MultiTagUnion, - }; - - let lhs_symbol = env.unique_symbol(); - let rhs_symbol = env.unique_symbol(); - - stores.push((lhs_symbol, Layout::Builtin(Builtin::Int64), lhs)); - stores.push((rhs_symbol, Layout::Builtin(Builtin::Int64), rhs)); - - ( - stores, - lhs_symbol, - rhs_symbol, - Layout::Builtin(Builtin::Int64), - Some(ConstructorKnown::OnlyPass { - scrutinee: path_symbol, - layout: *cond_layout, - tag_id, - }), - ) } Test::IsInt(test_int) => { // TODO don't downcast i128 here From aecb509909db9daac26eebed4dc2366d15a7d4b7 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 20 Jun 2021 20:50:25 +0200 Subject: [PATCH 321/496] update mono tests --- compiler/test_mono/generated/has_none.txt | 4 ++-- compiler/test_mono/generated/ir_when_idiv.txt | 2 +- compiler/test_mono/generated/ir_when_just.txt | 2 +- compiler/test_mono/generated/ir_when_maybe.txt | 2 +- compiler/test_mono/generated/is_nil.txt | 2 +- compiler/test_mono/generated/linked_list_length_twice.txt | 2 +- compiler/test_mono/generated/nested_pattern_match.txt | 4 ++-- compiler/test_mono/generated/peano1.txt | 2 +- compiler/test_mono/generated/peano2.txt | 4 ++-- compiler/test_mono/generated/quicksort_swap.txt | 4 ++-- compiler/test_mono/generated/rigids.txt | 4 ++-- compiler/test_mono/generated/when_nested_maybe.txt | 4 ++-- compiler/test_mono/generated/when_on_result.txt | 2 +- 13 files changed, 19 insertions(+), 19 deletions(-) diff --git a/compiler/test_mono/generated/has_none.txt b/compiler/test_mono/generated/has_none.txt index 9437ddf329..3421c008a8 100644 --- a/compiler/test_mono/generated/has_none.txt +++ b/compiler/test_mono/generated/has_none.txt @@ -1,7 +1,7 @@ procedure Test.3 (Test.4): joinpoint Test.13 Test.4: let Test.23 = 1i64; - let Test.24 = Index 0 Test.4; + let Test.24 = GetTagId Test.4; let Test.25 = lowlevel Eq Test.23 Test.24; if Test.25 then let Test.14 = false; @@ -9,7 +9,7 @@ procedure Test.3 (Test.4): else let Test.19 = Index 1 Test.4; let Test.20 = 1i64; - let Test.21 = Index 0 Test.19; + let Test.21 = GetTagId Test.19; let Test.22 = lowlevel Eq Test.20 Test.21; if Test.22 then let Test.15 = true; diff --git a/compiler/test_mono/generated/ir_when_idiv.txt b/compiler/test_mono/generated/ir_when_idiv.txt index 56baee4141..ccf556c004 100644 --- a/compiler/test_mono/generated/ir_when_idiv.txt +++ b/compiler/test_mono/generated/ir_when_idiv.txt @@ -17,7 +17,7 @@ procedure Test.0 (): let Test.9 = 10i64; let Test.2 = CallByName Num.42 Test.8 Test.9; let Test.5 = 1i64; - let Test.6 = Index 0 Test.2; + let Test.6 = GetTagId Test.2; let Test.7 = lowlevel Eq Test.5 Test.6; if Test.7 then let Test.1 = Index 1 Test.2; diff --git a/compiler/test_mono/generated/ir_when_just.txt b/compiler/test_mono/generated/ir_when_just.txt index baf5e51d25..9c2beb17fc 100644 --- a/compiler/test_mono/generated/ir_when_just.txt +++ b/compiler/test_mono/generated/ir_when_just.txt @@ -7,7 +7,7 @@ procedure Test.0 (): let Test.12 = 41i64; let Test.1 = Just Test.13 Test.12; let Test.9 = 0i64; - let Test.10 = Index 0 Test.1; + let Test.10 = GetTagId Test.1; let Test.11 = lowlevel Eq Test.9 Test.10; if Test.11 then let Test.3 = Index 1 Test.1; diff --git a/compiler/test_mono/generated/ir_when_maybe.txt b/compiler/test_mono/generated/ir_when_maybe.txt index fd5037b1de..d4c63246e5 100644 --- a/compiler/test_mono/generated/ir_when_maybe.txt +++ b/compiler/test_mono/generated/ir_when_maybe.txt @@ -3,7 +3,7 @@ procedure Test.0 (): let Test.9 = 3i64; let Test.3 = Just Test.10 Test.9; let Test.6 = 0i64; - let Test.7 = Index 0 Test.3; + let Test.7 = GetTagId Test.3; let Test.8 = lowlevel Eq Test.6 Test.7; if Test.8 then let Test.2 = Index 1 Test.3; diff --git a/compiler/test_mono/generated/is_nil.txt b/compiler/test_mono/generated/is_nil.txt index 4ad61c36e4..81fd3b83b4 100644 --- a/compiler/test_mono/generated/is_nil.txt +++ b/compiler/test_mono/generated/is_nil.txt @@ -1,6 +1,6 @@ procedure Test.2 (Test.3): let Test.12 = 1i64; - let Test.13 = Index 0 Test.3; + let Test.13 = GetTagId Test.3; let Test.14 = lowlevel Eq Test.12 Test.13; if Test.14 then let Test.10 = true; diff --git a/compiler/test_mono/generated/linked_list_length_twice.txt b/compiler/test_mono/generated/linked_list_length_twice.txt index a54ec0b202..057652358c 100644 --- a/compiler/test_mono/generated/linked_list_length_twice.txt +++ b/compiler/test_mono/generated/linked_list_length_twice.txt @@ -4,7 +4,7 @@ procedure Num.24 (#Attr.2, #Attr.3): procedure Test.3 (Test.5): let Test.18 = 1i64; - let Test.19 = Index 0 Test.5; + let Test.19 = GetTagId Test.5; let Test.20 = lowlevel Eq Test.18 Test.19; if Test.20 then let Test.13 = 0i64; diff --git a/compiler/test_mono/generated/nested_pattern_match.txt b/compiler/test_mono/generated/nested_pattern_match.txt index 8991931ca9..42c3a4eaf3 100644 --- a/compiler/test_mono/generated/nested_pattern_match.txt +++ b/compiler/test_mono/generated/nested_pattern_match.txt @@ -13,12 +13,12 @@ procedure Test.0 (): ret Test.11; in let Test.15 = 0i64; - let Test.16 = Index 0 Test.2; + let Test.16 = GetTagId Test.2; let Test.19 = lowlevel Eq Test.15 Test.16; if Test.19 then let Test.12 = Index 1 Test.2; let Test.13 = 0i64; - let Test.14 = Index 0 Test.12; + let Test.14 = GetTagId Test.12; let Test.18 = lowlevel Eq Test.13 Test.14; if Test.18 then let Test.10 = Index 1 Test.2; diff --git a/compiler/test_mono/generated/peano1.txt b/compiler/test_mono/generated/peano1.txt index 396677f771..fe683996cc 100644 --- a/compiler/test_mono/generated/peano1.txt +++ b/compiler/test_mono/generated/peano1.txt @@ -8,7 +8,7 @@ procedure Test.0 (): let Test.12 = S Test.15 Test.14; let Test.2 = S Test.13 Test.12; let Test.9 = 1i64; - let Test.10 = Index 0 Test.2; + let Test.10 = GetTagId Test.2; dec Test.2; let Test.11 = lowlevel Eq Test.9 Test.10; if Test.11 then diff --git a/compiler/test_mono/generated/peano2.txt b/compiler/test_mono/generated/peano2.txt index 03ba41ecf0..e415bd1e89 100644 --- a/compiler/test_mono/generated/peano2.txt +++ b/compiler/test_mono/generated/peano2.txt @@ -8,14 +8,14 @@ procedure Test.0 (): let Test.18 = S Test.21 Test.20; let Test.2 = S Test.19 Test.18; let Test.15 = 0i64; - let Test.16 = Index 0 Test.2; + let Test.16 = GetTagId Test.2; let Test.17 = lowlevel Eq Test.15 Test.16; if Test.17 then let Test.11 = Index 1 Test.2; inc Test.11; dec Test.2; let Test.12 = 0i64; - let Test.13 = Index 0 Test.11; + let Test.13 = GetTagId Test.11; dec Test.11; let Test.14 = lowlevel Eq Test.12 Test.13; if Test.14 then diff --git a/compiler/test_mono/generated/quicksort_swap.txt b/compiler/test_mono/generated/quicksort_swap.txt index 04a3a7f525..0639946980 100644 --- a/compiler/test_mono/generated/quicksort_swap.txt +++ b/compiler/test_mono/generated/quicksort_swap.txt @@ -33,12 +33,12 @@ procedure Test.1 (Test.2): in let Test.23 = Index 1 Test.8; let Test.24 = 1i64; - let Test.25 = Index 0 Test.23; + let Test.25 = GetTagId Test.23; let Test.28 = lowlevel Eq Test.24 Test.25; if Test.28 then let Test.20 = Index 0 Test.8; let Test.21 = 1i64; - let Test.22 = Index 0 Test.20; + let Test.22 = GetTagId Test.20; let Test.27 = lowlevel Eq Test.21 Test.22; if Test.27 then let Test.18 = Index 0 Test.8; diff --git a/compiler/test_mono/generated/rigids.txt b/compiler/test_mono/generated/rigids.txt index ac46059d9f..81cfd385c0 100644 --- a/compiler/test_mono/generated/rigids.txt +++ b/compiler/test_mono/generated/rigids.txt @@ -31,12 +31,12 @@ procedure Test.1 (Test.2, Test.3, Test.4): in let Test.26 = Index 1 Test.13; let Test.27 = 1i64; - let Test.28 = Index 0 Test.26; + let Test.28 = GetTagId Test.26; let Test.31 = lowlevel Eq Test.27 Test.28; if Test.31 then let Test.23 = Index 0 Test.13; let Test.24 = 1i64; - let Test.25 = Index 0 Test.23; + let Test.25 = GetTagId Test.23; let Test.30 = lowlevel Eq Test.24 Test.25; if Test.30 then let Test.21 = Index 0 Test.13; diff --git a/compiler/test_mono/generated/when_nested_maybe.txt b/compiler/test_mono/generated/when_nested_maybe.txt index 8991931ca9..42c3a4eaf3 100644 --- a/compiler/test_mono/generated/when_nested_maybe.txt +++ b/compiler/test_mono/generated/when_nested_maybe.txt @@ -13,12 +13,12 @@ procedure Test.0 (): ret Test.11; in let Test.15 = 0i64; - let Test.16 = Index 0 Test.2; + let Test.16 = GetTagId Test.2; let Test.19 = lowlevel Eq Test.15 Test.16; if Test.19 then let Test.12 = Index 1 Test.2; let Test.13 = 0i64; - let Test.14 = Index 0 Test.12; + let Test.14 = GetTagId Test.12; let Test.18 = lowlevel Eq Test.13 Test.14; if Test.18 then let Test.10 = Index 1 Test.2; diff --git a/compiler/test_mono/generated/when_on_result.txt b/compiler/test_mono/generated/when_on_result.txt index 4fe8f17db8..5f040415c9 100644 --- a/compiler/test_mono/generated/when_on_result.txt +++ b/compiler/test_mono/generated/when_on_result.txt @@ -6,7 +6,7 @@ procedure Test.1 (Test.5): ret Test.3; in let Test.16 = 1i64; - let Test.17 = Index 0 Test.2; + let Test.17 = GetTagId Test.2; let Test.18 = lowlevel Eq Test.16 Test.17; if Test.18 then let Test.13 = Index 1 Test.2; From 454241a04f95b8e46f2cc24b878556b23f192225 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 20 Jun 2021 21:05:02 +0200 Subject: [PATCH 322/496] use GetTagId in one more place --- compiler/gen_llvm/src/llvm/build.rs | 51 ++----------------- compiler/mono/src/decision_tree.rs | 8 ++- .../test_mono/generated/ir_when_these.txt | 2 +- 3 files changed, 8 insertions(+), 53 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 92da76a01a..4d83b890a3 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -1554,55 +1554,12 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( } } PointerValue(value) => match structure_layout { - Layout::Union(UnionLayout::NullableWrapped { nullable_id, .. }) - if *index == 0 => - { - let ptr = value; - let is_null = env.builder.build_is_null(ptr, "is_null"); - - let ctx = env.context; - let then_block = ctx.append_basic_block(parent, "then"); - let else_block = ctx.append_basic_block(parent, "else"); - let cont_block = ctx.append_basic_block(parent, "cont"); - - let result = builder.build_alloca(ctx.i64_type(), "result"); - - env.builder - .build_conditional_branch(is_null, then_block, else_block); - - { - env.builder.position_at_end(then_block); - let tag_id = ctx.i64_type().const_int(*nullable_id as u64, false); - env.builder.build_store(result, tag_id); - env.builder.build_unconditional_branch(cont_block); - } - - { - env.builder.position_at_end(else_block); - let tag_id = extract_tag_discriminant_ptr(env, ptr); - env.builder.build_store(result, tag_id); - env.builder.build_unconditional_branch(cont_block); - } - - env.builder.position_at_end(cont_block); - - env.builder.build_load(result, "load_result") + Layout::Union(UnionLayout::NullableWrapped { .. }) if *index == 0 => { + panic!("this should not happen any more") } - Layout::Union(UnionLayout::NullableUnwrapped { nullable_id, .. }) => { + Layout::Union(UnionLayout::NullableUnwrapped { .. }) => { if *index == 0 { - let is_null = env.builder.build_is_null(value, "is_null"); - - let ctx = env.context; - - let then_value = ctx.i64_type().const_int(*nullable_id as u64, false); - let else_value = ctx.i64_type().const_int(!*nullable_id as u64, false); - - env.builder.build_select( - is_null, - then_value, - else_value, - "select_tag_id", - ) + panic!("this should not happen any more") } else { let struct_type = env .context diff --git a/compiler/mono/src/decision_tree.rs b/compiler/mono/src/decision_tree.rs index c8be7b874f..dc0647dc02 100644 --- a/compiler/mono/src/decision_tree.rs +++ b/compiler/mono/src/decision_tree.rs @@ -1746,7 +1746,7 @@ fn decide_to_branching<'a>( // We have learned more about the exact layout of the cond (based on the path) // but tests are still relative to the original cond symbol - let mut switch = if let Layout::Union(_) = inner_cond_layout { + let mut switch = if let Layout::Union(union_layout) = inner_cond_layout { let tag_id_symbol = env.unique_symbol(); let temp = Stmt::Switch { @@ -1757,11 +1757,9 @@ fn decide_to_branching<'a>( ret_layout, }; - let expr = Expr::AccessAtIndex { - index: 0, - field_layouts: &[Layout::TAG_SIZE], + let expr = Expr::GetTagId { structure: inner_cond_symbol, - wrapped: Wrapped::MultiTagUnion, + union_layout, }; Stmt::Let(tag_id_symbol, expr, Layout::TAG_SIZE, env.arena.alloc(temp)) diff --git a/compiler/test_mono/generated/ir_when_these.txt b/compiler/test_mono/generated/ir_when_these.txt index fb786616f8..272bcad420 100644 --- a/compiler/test_mono/generated/ir_when_these.txt +++ b/compiler/test_mono/generated/ir_when_these.txt @@ -3,7 +3,7 @@ procedure Test.0 (): let Test.10 = 1i64; let Test.11 = 2i64; let Test.5 = These Test.12 Test.10 Test.11; - let Test.9 = Index 0 Test.5; + let Test.9 = GetTagId Test.5; switch Test.9: case 2: let Test.2 = Index 1 Test.5; From e1af2eb7d04bda36871921980dde3ab0f7175766 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 20 Jun 2021 21:23:50 +0200 Subject: [PATCH 323/496] add CoerceToTagId --- compiler/gen_dev/src/lib.rs | 3 +++ compiler/gen_llvm/src/llvm/build.rs | 5 +++++ compiler/mono/src/alias_analysis.rs | 1 + compiler/mono/src/borrow.rs | 5 ++++- compiler/mono/src/inc_dec.rs | 17 +++++++++++++++++ compiler/mono/src/ir.rs | 17 +++++++++++++++++ 6 files changed, 47 insertions(+), 1 deletion(-) diff --git a/compiler/gen_dev/src/lib.rs b/compiler/gen_dev/src/lib.rs index fad8a6eb39..cc33720764 100644 --- a/compiler/gen_dev/src/lib.rs +++ b/compiler/gen_dev/src/lib.rs @@ -450,6 +450,9 @@ where Expr::GetTagId { structure, .. } => { self.set_last_seen(*structure, stmt); } + Expr::CoerceToTagId { structure, .. } => { + self.set_last_seen(*structure, stmt); + } Expr::Array { elems, .. } => { for sym in *elems { self.set_last_seen(*sym, stmt); diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 4d83b890a3..69467c8f35 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -1596,6 +1596,11 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( EmptyArray => empty_polymorphic_list(env), Array { elem_layout, elems } => list_literal(env, scope, elem_layout, elems), RuntimeErrorFunction(_) => todo!(), + CoerceToTagId { .. } => { + // we will do more here in the future + + env.context.struct_type(&[], false).const_zero().into() + } GetTagId { structure, union_layout, diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 2de7e9e9b5..605e702150 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -935,6 +935,7 @@ fn expr_spec( builder.add_terminate(block, type_id) } GetTagId { .. } => builder.add_make_tuple(block, &[]), + CoerceToTagId { .. } => builder.add_make_tuple(block, &[]), } } diff --git a/compiler/mono/src/borrow.rs b/compiler/mono/src/borrow.rs index 34513f92c8..a69a978671 100644 --- a/compiler/mono/src/borrow.rs +++ b/compiler/mono/src/borrow.rs @@ -581,6 +581,10 @@ impl<'a> BorrowInfState<'a> { Literal(_) | RuntimeErrorFunction(_) => {} + CoerceToTagId { .. } => { + // do nothing for now; when we extract the fields here, that must change + } + GetTagId { structure: x, .. } => { // if the structure (record/tag/array) is owned, the extracted value is if self.is_owned(*x) { @@ -592,7 +596,6 @@ impl<'a> BorrowInfState<'a> { self.own_var(*x); } } - } } diff --git a/compiler/mono/src/inc_dec.rs b/compiler/mono/src/inc_dec.rs index ef39024848..a0d2f2ed14 100644 --- a/compiler/mono/src/inc_dec.rs +++ b/compiler/mono/src/inc_dec.rs @@ -135,6 +135,12 @@ pub fn occurring_variables_expr(expr: &Expr<'_>, result: &mut MutSet) { } => { result.insert(*symbol); } + + CoerceToTagId { + structure: symbol, .. + } => { + result.insert(*symbol); + } } } @@ -772,6 +778,17 @@ impl<'a> Context<'a> { self.arena.alloc(Stmt::Let(z, v, l, b)) } + CoerceToTagId { structure: x, .. } => { + let b = self.add_dec_if_needed(x, b, b_live_vars); + let info_x = self.get_var_info(x); + let b = if info_x.consume { + self.add_inc(z, 1, b) + } else { + b + }; + + self.arena.alloc(Stmt::Let(z, v, l, b)) + } }; (new_b, live_vars) diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 33b8af43e7..e0242ab41a 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -1197,6 +1197,11 @@ pub enum Expr<'a> { union_layout: UnionLayout<'a>, }, + CoerceToTagId { + structure: Symbol, + tag_id: u8, + }, + Array { elem_layout: Layout<'a>, elems: &'a [Symbol], @@ -1353,6 +1358,10 @@ impl<'a> Expr<'a> { GetTagId { structure, .. } => alloc .text("GetTagId ") .append(symbol_to_doc(alloc, *structure)), + + CoerceToTagId { tag_id, structure } => alloc + .text(format!("CoerceToTagId {} ", tag_id)) + .append(symbol_to_doc(alloc, *structure)), } } } @@ -5534,6 +5543,14 @@ fn substitute_in_expr<'a>( }), None => None, }, + + CoerceToTagId { structure, tag_id } => match substitute(subs, *structure) { + Some(structure) => Some(CoerceToTagId { + structure, + tag_id: *tag_id, + }), + None => None, + }, } } From 97296dd8ce96723e3cdeb5634d74471f2e11e5cb Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 20 Jun 2021 21:25:40 +0200 Subject: [PATCH 324/496] format --- compiler/mono/src/borrow.rs | 1 - compiler/mono/src/inc_dec.rs | 1 - 2 files changed, 2 deletions(-) diff --git a/compiler/mono/src/borrow.rs b/compiler/mono/src/borrow.rs index 34513f92c8..909d64f058 100644 --- a/compiler/mono/src/borrow.rs +++ b/compiler/mono/src/borrow.rs @@ -592,7 +592,6 @@ impl<'a> BorrowInfState<'a> { self.own_var(*x); } } - } } diff --git a/compiler/mono/src/inc_dec.rs b/compiler/mono/src/inc_dec.rs index ef39024848..0737cac6e7 100644 --- a/compiler/mono/src/inc_dec.rs +++ b/compiler/mono/src/inc_dec.rs @@ -771,7 +771,6 @@ impl<'a> Context<'a> { self.arena.alloc(Stmt::Let(z, v, l, b)) } - }; (new_b, live_vars) From aba01ad62a94a25086069e5fd64c5bbf40fd6cc6 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 20 Jun 2021 21:33:25 +0200 Subject: [PATCH 325/496] add index --- compiler/mono/src/borrow.rs | 19 ++++++++++++++----- compiler/mono/src/inc_dec.rs | 23 ++++++++++++----------- compiler/mono/src/ir.rs | 2 ++ 3 files changed, 28 insertions(+), 16 deletions(-) diff --git a/compiler/mono/src/borrow.rs b/compiler/mono/src/borrow.rs index a69a978671..137db5cf13 100644 --- a/compiler/mono/src/borrow.rs +++ b/compiler/mono/src/borrow.rs @@ -565,6 +565,11 @@ impl<'a> BorrowInfState<'a> { EmptyArray => { self.own_var(z); } + + Call(call) => self.collect_call(z, call), + + Literal(_) | RuntimeErrorFunction(_) => {} + AccessAtIndex { structure: x, .. } => { // if the structure (record/tag/array) is owned, the extracted value is if self.is_owned(*x) { @@ -577,12 +582,16 @@ impl<'a> BorrowInfState<'a> { } } - Call(call) => self.collect_call(z, call), + CoerceToTagId { structure: x, .. } => { + // if the structure (record/tag/array) is owned, the extracted value is + if self.is_owned(*x) { + self.own_var(z); + } - Literal(_) | RuntimeErrorFunction(_) => {} - - CoerceToTagId { .. } => { - // do nothing for now; when we extract the fields here, that must change + // if the extracted value is owned, the structure must be too + if self.is_owned(z) { + self.own_var(*x); + } } GetTagId { structure: x, .. } => { diff --git a/compiler/mono/src/inc_dec.rs b/compiler/mono/src/inc_dec.rs index a0d2f2ed14..f5a15792de 100644 --- a/compiler/mono/src/inc_dec.rs +++ b/compiler/mono/src/inc_dec.rs @@ -743,17 +743,6 @@ impl<'a> Context<'a> { self.arena.alloc(Stmt::Let(z, v, l, b)), &b_live_vars, ), - AccessAtIndex { structure: x, .. } => { - let b = self.add_dec_if_needed(x, b, b_live_vars); - let info_x = self.get_var_info(x); - let b = if info_x.consume { - self.add_inc(z, 1, b) - } else { - b - }; - - self.arena.alloc(Stmt::Let(z, v, l, b)) - } Call(crate::ir::Call { call_type, @@ -766,6 +755,18 @@ impl<'a> Context<'a> { self.arena.alloc(Stmt::Let(z, v, l, b)) } + AccessAtIndex { structure: x, .. } => { + let b = self.add_dec_if_needed(x, b, b_live_vars); + let info_x = self.get_var_info(x); + let b = if info_x.consume { + self.add_inc(z, 1, b) + } else { + b + }; + + self.arena.alloc(Stmt::Let(z, v, l, b)) + } + GetTagId { structure: x, .. } => { let b = self.add_dec_if_needed(x, b, b_live_vars); let info_x = self.get_var_info(x); diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index e0242ab41a..fe0dd551c7 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -1200,6 +1200,8 @@ pub enum Expr<'a> { CoerceToTagId { structure: Symbol, tag_id: u8, + union_layout: UnionLayout<'a>, + index: u64, }, Array { From 5e1077bf3e1ce8ae3e8d07f42dcdfe3c20d5e01f Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 20 Jun 2021 21:55:04 +0200 Subject: [PATCH 326/496] write implementation --- compiler/gen_llvm/src/llvm/build.rs | 100 +++++++++++++++++++++++++++- compiler/mono/src/ir.rs | 13 +++- 2 files changed, 107 insertions(+), 6 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 69467c8f35..3f90cf4421 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -1596,11 +1596,105 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( EmptyArray => empty_polymorphic_list(env), Array { elem_layout, elems } => list_literal(env, scope, elem_layout, elems), RuntimeErrorFunction(_) => todo!(), - CoerceToTagId { .. } => { - // we will do more here in the future - env.context.struct_type(&[], false).const_zero().into() + CoerceToTagId { + tag_id, + structure, + index, + union_layout, + } => { + let builder = env.builder; + + // cast the argument bytes into the desired shape for this tag + let (argument, _structure_layout) = load_symbol_and_layout(scope, structure); + + match union_layout { + UnionLayout::NonRecursive(tag_layouts) => { + debug_assert!(argument.is_struct_value()); + let field_layouts = tag_layouts[*tag_id as usize]; + let struct_layout = Layout::Struct(field_layouts); + + let struct_type = basic_type_from_layout(env, &struct_layout); + + let struct_value = access_index_struct_value( + builder, + argument.into_struct_value(), + struct_type.into_struct_type(), + ); + + builder + .build_extract_value(struct_value, *index as u32, "") + .expect("desired field did not decode") + } + UnionLayout::Recursive(tag_layouts) => { + debug_assert!(argument.is_pointer_value()); + + let field_layouts = tag_layouts[*tag_id as usize]; + let struct_layout = Layout::Struct(field_layouts); + + let struct_type = basic_type_from_layout(env, &struct_layout); + + lookup_at_index_ptr( + env, + field_layouts, + *index as usize, + argument.into_pointer_value(), + struct_type.into_struct_type(), + &struct_layout, + ) + } + UnionLayout::NonNullableUnwrapped(_) => todo!(), + UnionLayout::NullableWrapped { + nullable_id, + other_tags, + } => { + debug_assert!(argument.is_pointer_value()); + debug_assert_ne!(*tag_id as i64, *nullable_id); + + let tag_index = if (*tag_id as i64) < *nullable_id { + *tag_id + } else { + tag_id - 1 + }; + + let field_layouts = other_tags[tag_index as usize]; + let struct_layout = Layout::Struct(field_layouts); + + let struct_type = basic_type_from_layout(env, &struct_layout); + + lookup_at_index_ptr( + env, + field_layouts, + *index as usize, + argument.into_pointer_value(), + struct_type.into_struct_type(), + &struct_layout, + ) + } + UnionLayout::NullableUnwrapped { + nullable_id, + other_fields, + } => { + debug_assert!(argument.is_pointer_value()); + debug_assert_ne!(*tag_id != 0, *nullable_id); + + let field_layouts = other_fields; + let struct_layout = Layout::Struct(field_layouts); + + let struct_type = basic_type_from_layout(env, &struct_layout); + + lookup_at_index_ptr( + env, + field_layouts, + *index as usize, + argument.into_pointer_value(), + struct_type.into_struct_type(), + &struct_layout, + ) + } + } } + GetTagId { structure, union_layout, diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index fe0dd551c7..eaacfda684 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -1361,8 +1361,13 @@ impl<'a> Expr<'a> { .text("GetTagId ") .append(symbol_to_doc(alloc, *structure)), - CoerceToTagId { tag_id, structure } => alloc - .text(format!("CoerceToTagId {} ", tag_id)) + CoerceToTagId { + tag_id, + structure, + index, + .. + } => alloc + .text(format!("CoerceToTagId (Id {}) (Index {}) ", tag_id, index)) .append(symbol_to_doc(alloc, *structure)), } } @@ -5546,10 +5551,12 @@ fn substitute_in_expr<'a>( None => None, }, - CoerceToTagId { structure, tag_id } => match substitute(subs, *structure) { + CoerceToTagId { structure, tag_id, index, union_layout } => match substitute(subs, *structure) { Some(structure) => Some(CoerceToTagId { structure, tag_id: *tag_id, + index: *index, + union_layout: *union_layout, }), None => None, }, From e274976c6a0ef36504a8d47c6483c8a2ee2ac5a1 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 20 Jun 2021 22:36:22 +0200 Subject: [PATCH 327/496] make it work --- compiler/gen_llvm/src/llvm/build.rs | 26 +++- compiler/mono/src/alias_analysis.rs | 11 +- compiler/mono/src/inc_dec.rs | 4 + compiler/mono/src/ir.rs | 111 +++++++++++++++++- compiler/test_mono/generated/has_none.txt | 2 +- compiler/test_mono/generated/ir_when_idiv.txt | 2 +- compiler/test_mono/generated/ir_when_just.txt | 2 +- .../test_mono/generated/ir_when_maybe.txt | 2 +- .../test_mono/generated/ir_when_these.txt | 6 +- .../generated/linked_list_length_twice.txt | 2 +- .../generated/nested_pattern_match.txt | 4 +- .../test_mono/generated/quicksort_swap.txt | 4 +- compiler/test_mono/generated/rigids.txt | 4 +- .../test_mono/generated/when_nested_maybe.txt | 4 +- 14 files changed, 158 insertions(+), 26 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 3f90cf4421..0b3fbc91e5 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -1622,9 +1622,11 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( struct_type.into_struct_type(), ); - builder + let result = builder .build_extract_value(struct_value, *index as u32, "") - .expect("desired field did not decode") + .expect("desired field did not decode"); + + result } UnionLayout::Recursive(tag_layouts) => { debug_assert!(argument.is_pointer_value()); @@ -1643,7 +1645,20 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( &struct_layout, ) } - UnionLayout::NonNullableUnwrapped(_) => todo!(), + UnionLayout::NonNullableUnwrapped(field_layouts) => { + let struct_layout = Layout::Struct(&field_layouts); + + let struct_type = basic_type_from_layout(env, &struct_layout); + + lookup_at_index_ptr( + env, + field_layouts, + *index as usize, + argument.into_pointer_value(), + struct_type.into_struct_type(), + &struct_layout, + ) + } UnionLayout::NullableWrapped { nullable_id, other_tags, @@ -1678,7 +1693,7 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( debug_assert!(argument.is_pointer_value()); debug_assert_ne!(*tag_id != 0, *nullable_id); - let field_layouts = other_fields; + let field_layouts = &other_fields[1..]; let struct_layout = Layout::Struct(field_layouts); let struct_type = basic_type_from_layout(env, &struct_layout); @@ -1686,7 +1701,8 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( lookup_at_index_ptr( env, field_layouts, - *index as usize, + // the tag id is not stored + *index as usize - 1, argument.into_pointer_value(), struct_type.into_struct_type(), &struct_layout, diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 605e702150..57c2e8f72d 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -854,6 +854,16 @@ fn expr_spec( } }, Struct(fields) => build_tuple_value(builder, env, block, fields), + CoerceToTagId { + index, + union_layout, + tag_id, + structure, + } => { + let value_id = env.symbols[structure]; + let result_type = layout_spec(builder, layout)?; + builder.add_unknown_with(block, &[value_id], result_type) + } AccessAtIndex { index, field_layouts: _, @@ -935,7 +945,6 @@ fn expr_spec( builder.add_terminate(block, type_id) } GetTagId { .. } => builder.add_make_tuple(block, &[]), - CoerceToTagId { .. } => builder.add_make_tuple(block, &[]), } } diff --git a/compiler/mono/src/inc_dec.rs b/compiler/mono/src/inc_dec.rs index f5a15792de..55eb19fee1 100644 --- a/compiler/mono/src/inc_dec.rs +++ b/compiler/mono/src/inc_dec.rs @@ -229,6 +229,10 @@ fn consume_expr(m: &VarMap, e: &Expr<'_>) -> bool { Some(info) => info.consume, None => true, }, + Expr::CoerceToTagId { structure: x, .. } => match m.get(x) { + Some(info) => info.consume, + None => true, + }, _ => true, } } diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index eaacfda684..3dd4452698 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -5551,7 +5551,12 @@ fn substitute_in_expr<'a>( None => None, }, - CoerceToTagId { structure, tag_id, index, union_layout } => match substitute(subs, *structure) { + CoerceToTagId { + structure, + tag_id, + index, + union_layout, + } => match substitute(subs, *structure) { Some(structure) => Some(CoerceToTagId { structure, tag_id: *tag_id, @@ -5620,7 +5625,7 @@ fn store_pattern_help<'a>( let wrapped = Wrapped::from_layout(&layout); - return store_tag_pattern( + return store_newtype_pattern( env, procs, layout_cache, @@ -5632,7 +5637,10 @@ fn store_pattern_help<'a>( ); } AppliedTag { - arguments, layout, .. + arguments, + layout, + tag_id, + .. } => { let union_layout = Layout::Union(*layout); let wrapped = Wrapped::from_layout(&union_layout); @@ -5642,9 +5650,10 @@ fn store_pattern_help<'a>( procs, layout_cache, outer_symbol, - &union_layout, + *layout, &arguments, wrapped, + *tag_id, stmt, ); } @@ -5682,6 +5691,100 @@ fn store_pattern_help<'a>( #[allow(clippy::too_many_arguments)] fn store_tag_pattern<'a>( + env: &mut Env<'a, '_>, + procs: &mut Procs<'a>, + layout_cache: &mut LayoutCache<'a>, + structure: Symbol, + union_layout: UnionLayout<'a>, + arguments: &[(Pattern<'a>, Layout<'a>)], + wrapped: Wrapped, + tag_id: u8, + mut stmt: Stmt<'a>, +) -> StorePattern<'a> { + use Pattern::*; + + let write_tag = wrapped == Wrapped::MultiTagUnion; + + let mut arg_layouts = Vec::with_capacity_in(arguments.len(), env.arena); + let mut is_productive = false; + + if write_tag { + // add an element for the tag discriminant + arg_layouts.push(Layout::Builtin(TAG_SIZE)); + } + + for (_, layout) in arguments { + arg_layouts.push(*layout); + } + + for (index, (argument, arg_layout)) in arguments.iter().enumerate().rev() { + let index = if write_tag { index + 1 } else { index }; + + let mut arg_layout = *arg_layout; + + if let Layout::RecursivePointer = arg_layout { + arg_layout = Layout::Union(union_layout); + } + + let load = Expr::CoerceToTagId { + index: index as u64, + structure, + tag_id, + union_layout, + }; + +// let load = Expr::AccessAtIndex { +// wrapped, +// index: index as u64, +// field_layouts: arg_layouts.clone().into_bump_slice(), +// structure, +// }; + + match argument { + Identifier(symbol) => { + // store immediately in the given symbol + stmt = Stmt::Let(*symbol, load, arg_layout, env.arena.alloc(stmt)); + is_productive = true; + } + Underscore => { + // ignore + } + IntLiteral(_) + | FloatLiteral(_) + | EnumLiteral { .. } + | BitLiteral { .. } + | StrLiteral(_) => {} + _ => { + // store the field in a symbol, and continue matching on it + let symbol = env.unique_symbol(); + + // first recurse, continuing to unpack symbol + match store_pattern_help(env, procs, layout_cache, argument, symbol, stmt) { + StorePattern::Productive(new) => { + is_productive = true; + stmt = new; + // only if we bind one of its (sub)fields to a used name should we + // extract the field + stmt = Stmt::Let(symbol, load, arg_layout, env.arena.alloc(stmt)); + } + StorePattern::NotProductive(new) => { + // do nothing + stmt = new; + } + } + } + } + } + + if is_productive { + StorePattern::Productive(stmt) + } else { + StorePattern::NotProductive(stmt) + } +} + +#[allow(clippy::too_many_arguments)] +fn store_newtype_pattern<'a>( env: &mut Env<'a, '_>, procs: &mut Procs<'a>, layout_cache: &mut LayoutCache<'a>, diff --git a/compiler/test_mono/generated/has_none.txt b/compiler/test_mono/generated/has_none.txt index 3421c008a8..ab733f7a45 100644 --- a/compiler/test_mono/generated/has_none.txt +++ b/compiler/test_mono/generated/has_none.txt @@ -15,7 +15,7 @@ procedure Test.3 (Test.4): let Test.15 = true; ret Test.15; else - let Test.7 = Index 2 Test.4; + let Test.7 = CoerceToTagId (Id 0) (Index 2) Test.4; jump Test.13 Test.7; in jump Test.13 Test.4; diff --git a/compiler/test_mono/generated/ir_when_idiv.txt b/compiler/test_mono/generated/ir_when_idiv.txt index ccf556c004..e55f13c051 100644 --- a/compiler/test_mono/generated/ir_when_idiv.txt +++ b/compiler/test_mono/generated/ir_when_idiv.txt @@ -20,7 +20,7 @@ procedure Test.0 (): let Test.6 = GetTagId Test.2; let Test.7 = lowlevel Eq Test.5 Test.6; if Test.7 then - let Test.1 = Index 1 Test.2; + let Test.1 = CoerceToTagId (Id 1) (Index 1) Test.2; ret Test.1; else let Test.4 = -1i64; diff --git a/compiler/test_mono/generated/ir_when_just.txt b/compiler/test_mono/generated/ir_when_just.txt index 9c2beb17fc..cd79c93654 100644 --- a/compiler/test_mono/generated/ir_when_just.txt +++ b/compiler/test_mono/generated/ir_when_just.txt @@ -10,7 +10,7 @@ procedure Test.0 (): let Test.10 = GetTagId Test.1; let Test.11 = lowlevel Eq Test.9 Test.10; if Test.11 then - let Test.3 = Index 1 Test.1; + let Test.3 = CoerceToTagId (Id 0) (Index 1) Test.1; let Test.5 = 1i64; let Test.4 = CallByName Num.24 Test.3 Test.5; ret Test.4; diff --git a/compiler/test_mono/generated/ir_when_maybe.txt b/compiler/test_mono/generated/ir_when_maybe.txt index d4c63246e5..d6cfd099b5 100644 --- a/compiler/test_mono/generated/ir_when_maybe.txt +++ b/compiler/test_mono/generated/ir_when_maybe.txt @@ -6,7 +6,7 @@ procedure Test.0 (): let Test.7 = GetTagId Test.3; let Test.8 = lowlevel Eq Test.6 Test.7; if Test.8 then - let Test.2 = Index 1 Test.3; + let Test.2 = CoerceToTagId (Id 0) (Index 1) Test.3; ret Test.2; else let Test.5 = 0i64; diff --git a/compiler/test_mono/generated/ir_when_these.txt b/compiler/test_mono/generated/ir_when_these.txt index 272bcad420..56d42da8ea 100644 --- a/compiler/test_mono/generated/ir_when_these.txt +++ b/compiler/test_mono/generated/ir_when_these.txt @@ -6,14 +6,14 @@ procedure Test.0 (): let Test.9 = GetTagId Test.5; switch Test.9: case 2: - let Test.2 = Index 1 Test.5; + let Test.2 = CoerceToTagId (Id 2) (Index 1) Test.5; ret Test.2; case 0: - let Test.3 = Index 1 Test.5; + let Test.3 = CoerceToTagId (Id 0) (Index 1) Test.5; ret Test.3; default: - let Test.4 = Index 1 Test.5; + let Test.4 = CoerceToTagId (Id 1) (Index 1) Test.5; ret Test.4; diff --git a/compiler/test_mono/generated/linked_list_length_twice.txt b/compiler/test_mono/generated/linked_list_length_twice.txt index 057652358c..222fec4981 100644 --- a/compiler/test_mono/generated/linked_list_length_twice.txt +++ b/compiler/test_mono/generated/linked_list_length_twice.txt @@ -10,7 +10,7 @@ procedure Test.3 (Test.5): let Test.13 = 0i64; ret Test.13; else - let Test.6 = Index 2 Test.5; + let Test.6 = CoerceToTagId (Id 0) (Index 2) Test.5; let Test.15 = 1i64; let Test.16 = CallByName Test.3 Test.6; let Test.14 = CallByName Num.24 Test.15 Test.16; diff --git a/compiler/test_mono/generated/nested_pattern_match.txt b/compiler/test_mono/generated/nested_pattern_match.txt index 42c3a4eaf3..4fe076ba5e 100644 --- a/compiler/test_mono/generated/nested_pattern_match.txt +++ b/compiler/test_mono/generated/nested_pattern_match.txt @@ -21,8 +21,8 @@ procedure Test.0 (): let Test.14 = GetTagId Test.12; let Test.18 = lowlevel Eq Test.13 Test.14; if Test.18 then - let Test.10 = Index 1 Test.2; - let Test.5 = Index 1 Test.10; + let Test.10 = CoerceToTagId (Id 0) (Index 1) Test.2; + let Test.5 = CoerceToTagId (Id 0) (Index 1) Test.10; let Test.7 = 1i64; let Test.6 = CallByName Num.24 Test.5 Test.7; ret Test.6; diff --git a/compiler/test_mono/generated/quicksort_swap.txt b/compiler/test_mono/generated/quicksort_swap.txt index 0639946980..20db77b9dc 100644 --- a/compiler/test_mono/generated/quicksort_swap.txt +++ b/compiler/test_mono/generated/quicksort_swap.txt @@ -42,9 +42,9 @@ procedure Test.1 (Test.2): let Test.27 = lowlevel Eq Test.21 Test.22; if Test.27 then let Test.18 = Index 0 Test.8; - let Test.4 = Index 1 Test.18; + let Test.4 = CoerceToTagId (Id 1) (Index 1) Test.18; let Test.17 = Index 1 Test.8; - let Test.5 = Index 1 Test.17; + let Test.5 = CoerceToTagId (Id 1) (Index 1) Test.17; let Test.16 = 0i64; let Test.10 = CallByName List.4 Test.2 Test.16 Test.5; let Test.11 = 0i64; diff --git a/compiler/test_mono/generated/rigids.txt b/compiler/test_mono/generated/rigids.txt index 81cfd385c0..12831045b4 100644 --- a/compiler/test_mono/generated/rigids.txt +++ b/compiler/test_mono/generated/rigids.txt @@ -40,9 +40,9 @@ procedure Test.1 (Test.2, Test.3, Test.4): let Test.30 = lowlevel Eq Test.24 Test.25; if Test.30 then let Test.21 = Index 0 Test.13; - let Test.6 = Index 1 Test.21; + let Test.6 = CoerceToTagId (Id 1) (Index 1) Test.21; let Test.20 = Index 1 Test.13; - let Test.7 = Index 1 Test.20; + let Test.7 = CoerceToTagId (Id 1) (Index 1) Test.20; let Test.15 = CallByName List.4 Test.4 Test.2 Test.7; let Test.14 = CallByName List.4 Test.15 Test.3 Test.6; ret Test.14; diff --git a/compiler/test_mono/generated/when_nested_maybe.txt b/compiler/test_mono/generated/when_nested_maybe.txt index 42c3a4eaf3..4fe076ba5e 100644 --- a/compiler/test_mono/generated/when_nested_maybe.txt +++ b/compiler/test_mono/generated/when_nested_maybe.txt @@ -21,8 +21,8 @@ procedure Test.0 (): let Test.14 = GetTagId Test.12; let Test.18 = lowlevel Eq Test.13 Test.14; if Test.18 then - let Test.10 = Index 1 Test.2; - let Test.5 = Index 1 Test.10; + let Test.10 = CoerceToTagId (Id 0) (Index 1) Test.2; + let Test.5 = CoerceToTagId (Id 0) (Index 1) Test.10; let Test.7 = 1i64; let Test.6 = CallByName Num.24 Test.5 Test.7; ret Test.6; From 7f51bf77aa402828ee4341186bab0d2e58edd84a Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 20 Jun 2021 22:45:54 +0200 Subject: [PATCH 328/496] cleanup --- compiler/mono/src/ir.rs | 19 ++++++------------- 1 file changed, 6 insertions(+), 13 deletions(-) diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 3dd4452698..f048ec1b2d 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -5726,19 +5726,12 @@ fn store_tag_pattern<'a>( arg_layout = Layout::Union(union_layout); } - let load = Expr::CoerceToTagId { - index: index as u64, - structure, - tag_id, - union_layout, - }; - -// let load = Expr::AccessAtIndex { -// wrapped, -// index: index as u64, -// field_layouts: arg_layouts.clone().into_bump_slice(), -// structure, -// }; + let load = Expr::CoerceToTagId { + index: index as u64, + structure, + tag_id, + union_layout, + }; match argument { Identifier(symbol) => { From 3a6ef8a53d7342a9d77d26c0cfb86a4537fd1048 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 20 Jun 2021 23:53:57 +0200 Subject: [PATCH 329/496] use in decision_tree --- compiler/gen_llvm/src/llvm/build.rs | 3 +- compiler/mono/src/alias_analysis.rs | 22 +++-- compiler/mono/src/decision_tree.rs | 86 +++++-------------- compiler/mono/src/layout.rs | 66 ++++++++++++++ compiler/test_mono/generated/has_none.txt | 2 +- .../generated/nested_pattern_match.txt | 2 +- compiler/test_mono/generated/peano2.txt | 2 +- .../test_mono/generated/when_nested_maybe.txt | 2 +- .../test_mono/generated/when_on_result.txt | 2 +- 9 files changed, 111 insertions(+), 76 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 0b3fbc91e5..0cb9d1e77e 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -1820,7 +1820,8 @@ fn lookup_at_index_ptr<'a, 'ctx, 'env>( // a pointer to the block of memory representation builder.build_bitcast( result, - basic_type_from_layout(env, structure_layout), + block_of_memory(env.context, structure_layout, env.ptr_bytes) + .ptr_type(AddressSpace::Generic), "cast_rec_pointer_lookup_at_index_ptr", ) } else { diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 57c2e8f72d..521d8f3e95 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -856,14 +856,24 @@ fn expr_spec( Struct(fields) => build_tuple_value(builder, env, block, fields), CoerceToTagId { index, - union_layout, tag_id, structure, - } => { - let value_id = env.symbols[structure]; - let result_type = layout_spec(builder, layout)?; - builder.add_unknown_with(block, &[value_id], result_type) - } + union_layout, + } => match union_layout { + UnionLayout::NonRecursive(_) => { + let tag_value_id = env.symbols[structure]; + let tuple_value_id = + builder.add_unwrap_union(block, tag_value_id, *tag_id as u32)?; + + builder.add_get_tuple_field(block, tuple_value_id, *index as u32) + } + _ => { + // for the moment recursive tag unions don't quite work + let value_id = env.symbols[structure]; + let result_type = layout_spec(builder, layout)?; + builder.add_unknown_with(block, &[value_id], result_type) + } + }, AccessAtIndex { index, field_layouts: _, diff --git a/compiler/mono/src/decision_tree.rs b/compiler/mono/src/decision_tree.rs index dc0647dc02..7e9395e781 100644 --- a/compiler/mono/src/decision_tree.rs +++ b/compiler/mono/src/decision_tree.rs @@ -1066,75 +1066,33 @@ fn path_to_expr_help<'a>( Some(wrapped) => { let index = *index; - let field_layouts = match &layout { - Layout::Union(variant) => { - use UnionLayout::*; + let (inner_layout, inner_expr) = match layout { + Layout::Union(union_layout) => { + let expr = Expr::CoerceToTagId { + tag_id: *tag_id, + structure: symbol, + index, + union_layout, + }; - match variant { - NonRecursive(layouts) | Recursive(layouts) => layouts[*tag_id as usize], - NonNullableUnwrapped(fields) => { - debug_assert_eq!(*tag_id, 0); - fields - } - NullableWrapped { - nullable_id, - other_tags: layouts, - .. - } => { - use std::cmp::Ordering; - match (*tag_id as usize).cmp(&(*nullable_id as usize)) { - Ordering::Equal => { - // the nullable tag is going to pretend it stores a tag id - &*env - .arena - .alloc([Layout::Builtin(crate::layout::TAG_SIZE)]) - } - Ordering::Less => layouts[*tag_id as usize], - Ordering::Greater => layouts[*tag_id as usize - 1], - } - } - NullableUnwrapped { - nullable_id, - other_fields, - } => { - let tag_id = *tag_id != 0; - - if tag_id == *nullable_id { - // the nullable tag has no fields; we can only lookup its tag id - debug_assert_eq!(index, 0); - - // the nullable tag is going to pretend it stores a tag id - &*env.arena.alloc([Layout::Builtin(crate::layout::TAG_SIZE)]) - } else { - *other_fields - } - } - } + (union_layout.layout_at(*tag_id as u8, index as usize), expr) } + Layout::Struct(field_layouts) => { + debug_assert!(field_layouts.len() > 1); + debug_assert_eq!(wrapped, Wrapped::RecordOrSingleTagUnion); - Layout::Struct(layouts) => layouts, - other => env.arena.alloc([*other]), - }; + let expr = Expr::AccessAtIndex { + index, + field_layouts, + structure: symbol, + wrapped, + }; - debug_assert!( - index < field_layouts.len() as u64, - "{} {:?} {:?} {:?}", - index, - field_layouts, - &layout, - tag_id, - ); + let layout = field_layouts[index as usize]; - let inner_layout = match &field_layouts[index as usize] { - Layout::RecursivePointer => layout, - other => *other, - }; - - let inner_expr = Expr::AccessAtIndex { - index, - field_layouts, - structure: symbol, - wrapped, + (layout, expr) + } + _ => unreachable!(), }; symbol = env.unique_symbol(); diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index f2f3b73544..6295664f88 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -105,6 +105,72 @@ impl<'a> UnionLayout<'a> { _ => alloc.text("TODO"), } } + + pub fn layout_at(self, tag_id: u8, index: usize) -> Layout<'a> { + match self { + UnionLayout::NonRecursive(tag_layouts) => { + let field_layouts = tag_layouts[tag_id as usize]; + + field_layouts[index] + } + UnionLayout::Recursive(tag_layouts) => { + let field_layouts = tag_layouts[tag_id as usize]; + + let result = field_layouts[index]; + + if let Layout::RecursivePointer = result { + Layout::Union(self) + } else { + result + } + } + UnionLayout::NonNullableUnwrapped(field_layouts) => { + let result = field_layouts[index]; + + if let Layout::RecursivePointer = result { + Layout::Union(self) + } else { + result + } + } + UnionLayout::NullableWrapped { + nullable_id, + other_tags, + } => { + debug_assert_ne!(nullable_id, tag_id as i64); + + let tag_index = if (tag_id as i64) < nullable_id { + tag_id + } else { + tag_id - 1 + }; + + let field_layouts = other_tags[tag_index as usize]; + let result = field_layouts[index]; + + if let Layout::RecursivePointer = result { + Layout::Union(self) + } else { + result + } + } + + UnionLayout::NullableUnwrapped { + nullable_id, + other_fields, + } => { + debug_assert_ne!(nullable_id, tag_id != 0); + + let result = other_fields[index as usize]; + + if let Layout::RecursivePointer = result { + Layout::Union(self) + } else { + result + } + } + } + } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] diff --git a/compiler/test_mono/generated/has_none.txt b/compiler/test_mono/generated/has_none.txt index ab733f7a45..a119646774 100644 --- a/compiler/test_mono/generated/has_none.txt +++ b/compiler/test_mono/generated/has_none.txt @@ -7,7 +7,7 @@ procedure Test.3 (Test.4): let Test.14 = false; ret Test.14; else - let Test.19 = Index 1 Test.4; + let Test.19 = CoerceToTagId (Id 0) (Index 1) Test.4; let Test.20 = 1i64; let Test.21 = GetTagId Test.19; let Test.22 = lowlevel Eq Test.20 Test.21; diff --git a/compiler/test_mono/generated/nested_pattern_match.txt b/compiler/test_mono/generated/nested_pattern_match.txt index 4fe076ba5e..28b7f52121 100644 --- a/compiler/test_mono/generated/nested_pattern_match.txt +++ b/compiler/test_mono/generated/nested_pattern_match.txt @@ -16,7 +16,7 @@ procedure Test.0 (): let Test.16 = GetTagId Test.2; let Test.19 = lowlevel Eq Test.15 Test.16; if Test.19 then - let Test.12 = Index 1 Test.2; + let Test.12 = CoerceToTagId (Id 0) (Index 1) Test.2; let Test.13 = 0i64; let Test.14 = GetTagId Test.12; let Test.18 = lowlevel Eq Test.13 Test.14; diff --git a/compiler/test_mono/generated/peano2.txt b/compiler/test_mono/generated/peano2.txt index e415bd1e89..eeb585f929 100644 --- a/compiler/test_mono/generated/peano2.txt +++ b/compiler/test_mono/generated/peano2.txt @@ -11,7 +11,7 @@ procedure Test.0 (): let Test.16 = GetTagId Test.2; let Test.17 = lowlevel Eq Test.15 Test.16; if Test.17 then - let Test.11 = Index 1 Test.2; + let Test.11 = CoerceToTagId (Id 0) (Index 1) Test.2; inc Test.11; dec Test.2; let Test.12 = 0i64; diff --git a/compiler/test_mono/generated/when_nested_maybe.txt b/compiler/test_mono/generated/when_nested_maybe.txt index 4fe076ba5e..28b7f52121 100644 --- a/compiler/test_mono/generated/when_nested_maybe.txt +++ b/compiler/test_mono/generated/when_nested_maybe.txt @@ -16,7 +16,7 @@ procedure Test.0 (): let Test.16 = GetTagId Test.2; let Test.19 = lowlevel Eq Test.15 Test.16; if Test.19 then - let Test.12 = Index 1 Test.2; + let Test.12 = CoerceToTagId (Id 0) (Index 1) Test.2; let Test.13 = 0i64; let Test.14 = GetTagId Test.12; let Test.18 = lowlevel Eq Test.13 Test.14; diff --git a/compiler/test_mono/generated/when_on_result.txt b/compiler/test_mono/generated/when_on_result.txt index 5f040415c9..635aed06cf 100644 --- a/compiler/test_mono/generated/when_on_result.txt +++ b/compiler/test_mono/generated/when_on_result.txt @@ -9,7 +9,7 @@ procedure Test.1 (Test.5): let Test.17 = GetTagId Test.2; let Test.18 = lowlevel Eq Test.16 Test.17; if Test.18 then - let Test.13 = Index 1 Test.2; + let Test.13 = CoerceToTagId (Id 1) (Index 1) Test.2; let Test.14 = 3i64; let Test.15 = lowlevel Eq Test.14 Test.13; if Test.15 then From f8f8233f193b48513aa2b49b845012c36510110e Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sun, 20 Jun 2021 23:01:57 -0400 Subject: [PATCH 330/496] Add hello-fast example --- examples/hello-fast/.gitignore | 1 + examples/hello-fast/Hello.roc | 6 +++ examples/hello-fast/README.md | 48 +++++++++++++++++++ .../hello-fast/platform/Package-Config.roc | 10 ++++ examples/hello-fast/platform/host.c | 44 +++++++++++++++++ 5 files changed, 109 insertions(+) create mode 100644 examples/hello-fast/.gitignore create mode 100644 examples/hello-fast/Hello.roc create mode 100644 examples/hello-fast/README.md create mode 100644 examples/hello-fast/platform/Package-Config.roc create mode 100644 examples/hello-fast/platform/host.c diff --git a/examples/hello-fast/.gitignore b/examples/hello-fast/.gitignore new file mode 100644 index 0000000000..6b820fd903 --- /dev/null +++ b/examples/hello-fast/.gitignore @@ -0,0 +1 @@ +hello-world diff --git a/examples/hello-fast/Hello.roc b/examples/hello-fast/Hello.roc new file mode 100644 index 0000000000..1fe1406ce5 --- /dev/null +++ b/examples/hello-fast/Hello.roc @@ -0,0 +1,6 @@ +app "hello-world" + packages { base: "platform" } + imports [] + provides [ main ] to base + +main = "Hello, World!\n" diff --git a/examples/hello-fast/README.md b/examples/hello-fast/README.md new file mode 100644 index 0000000000..a2890f03ed --- /dev/null +++ b/examples/hello-fast/README.md @@ -0,0 +1,48 @@ +# Hello, World! + +To run, `cd` into this directory and run: + +```bash +$ cargo run run Hello.roc +``` + +To run in release mode instead, do: + +```bash +$ cargo run --release run Hello.roc +``` + +## Troubleshooting + +If you encounter `cannot find -lc++`, run the following for ubuntu `sudo apt install libc++-dev`. + +## Design Notes + +This demonstrates the basic design of hosts: Roc code gets compiled into a pure +function (in this case, a thunk that always returns `"Hello, World!"`) and +then the host calls that function. Fundamentally, that's the whole idea! The host +might not even have a `main` - it could be a library, a plugin, anything. +Everything else is built on this basic "hosts calling linked pure functions" design. + +For example, things get more interesting when the compiled Roc function returns +a `Task` - that is, a tagged union data structure containing function pointers +to callback closures. This lets the Roc pure function describe arbitrary +chainable effects, which the host can interpret to perform I/O as requested by +the Roc program. (The tagged union `Task` would have a variant for each supported +I/O operation.) + +In this trivial example, it's very easy to line up the API between the host and +the Roc program. In a more involved host, this would be much trickier - especially +if the API were changing frequently during development. + +The idea there is to have a first-class concept of "glue code" which host authors +can write (it would be plain Roc code, but with some extra keywords that aren't +available in normal modules - kinda like `port module` in Elm), and which +describe both the Roc-host/C boundary as well as the Roc-host/Roc-app boundary. +Roc application authors only care about the Roc-host/Roc-app portion, and the +host author only cares about the Roc-host/C bounary when implementing the host. + +Using this glue code, the Roc compiler can generate C header files describing the +boundary. This not only gets us host compatibility with C compilers, but also +Rust FFI for free, because [`rust-bindgen`](https://github.com/rust-lang/rust-bindgen) +generates correct Rust FFI bindings from C headers. diff --git a/examples/hello-fast/platform/Package-Config.roc b/examples/hello-fast/platform/Package-Config.roc new file mode 100644 index 0000000000..377d5c0994 --- /dev/null +++ b/examples/hello-fast/platform/Package-Config.roc @@ -0,0 +1,10 @@ +platform examples/hello-world + requires {}{ main : Str } + exposes [] + packages {} + imports [] + provides [ mainForHost ] + effects fx.Effect {} + +mainForHost : Str +mainForHost = main diff --git a/examples/hello-fast/platform/host.c b/examples/hello-fast/platform/host.c new file mode 100644 index 0000000000..e21057df86 --- /dev/null +++ b/examples/hello-fast/platform/host.c @@ -0,0 +1,44 @@ +#include +#include +#include +#include +#include + +void* roc_alloc(size_t size, unsigned int alignment) { + return malloc(size); +} + +void* roc_realloc(void* ptr, size_t old_size, size_t new_size, unsigned int alignment) { + return realloc(ptr, new_size); +} + +void roc_dealloc(void* ptr, unsigned int alignment) { + free(ptr); +} + +struct RocStr { + char* bytes; + size_t len; +}; + +struct RocCallResult { + size_t flag; + struct RocStr content; +}; + +extern void roc__mainForHost_1_exposed(struct RocCallResult *re); + +int main() { + // Make space for the result + struct RocCallResult callresult; + + // Call roc to populate the callresult + roc__mainForHost_1_exposed(&callresult); + + struct RocStr str = callresult.content; + + // Write to stdout + write(1, &str.bytes, 14); + + return 0; +} From 3ddbe4f06aca29839b7d447ba4f2f9c2777e635f Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sun, 20 Jun 2021 23:17:02 -0400 Subject: [PATCH 331/496] Use exec in roc run --- cli/src/lib.rs | 53 +++++++++++++++++++++++++++++++++----------------- 1 file changed, 35 insertions(+), 18 deletions(-) diff --git a/cli/src/lib.rs b/cli/src/lib.rs index 0797309a1a..a86c3ec56c 100644 --- a/cli/src/lib.rs +++ b/cli/src/lib.rs @@ -231,24 +231,7 @@ pub fn build(target: &Triple, matches: &ArgMatches, config: BuildConfig) -> io:: } } - // Run the compiled app - let exit_status = cmd - .current_dir(original_cwd) - .spawn() - .unwrap_or_else(|err| panic!("Failed to run app after building it: {:?}", err)) - .wait() - .expect("TODO gracefully handle block_on failing when roc run spawns a subprocess for the compiled app"); - - // `roc run` exits with the same status code as the app it ran. - // - // If you want to know whether there were compilation problems - // via status code, use either `roc build` or `roc check` instead! - match exit_status.code() { - Some(code) => Ok(code), - None => { - todo!("TODO gracefully handle the roc run subprocess terminating with a signal."); - } - } + roc_run(cmd.current_dir(original_cwd)) } } } @@ -262,3 +245,37 @@ pub fn build(target: &Triple, matches: &ArgMatches, config: BuildConfig) -> io:: } } } + +#[cfg(target_family = "unix")] +fn roc_run(cmd: &mut Command) -> io::Result { + use std::os::unix::process::CommandExt; + + // This is much faster than spawning a subprocess if we're on a UNIX system! + let err = cmd.exec(); + + // If exec actually returned, it was definitely an error! (Otherwise, + // this process would have been replaced by the other one, and we'd + // never actually reach this line of code.) + Err(err) +} + +#[cfg(not(target_family = "unix"))] +fn roc_run(cmd: &mut Command) -> io::Result { + // Run the compiled app + let exit_status = cmd + .spawn() + .unwrap_or_else(|err| panic!("Failed to run app after building it: {:?}", err)) + .wait() + .expect("TODO gracefully handle block_on failing when roc run spawns a subprocess for the compiled app"); + + // `roc run` exits with the same status code as the app it ran. + // + // If you want to know whether there were compilation problems + // via status code, use either `roc build` or `roc check` instead! + match exit_status.code() { + Some(code) => Ok(code), + None => { + todo!("TODO gracefully handle the roc run subprocess terminating with a signal."); + } + } +} From 1f467ec62be8b0ad6c49edaea019fa3d2bac6ac9 Mon Sep 17 00:00:00 2001 From: rvcas Date: Mon, 21 Jun 2021 00:19:00 -0400 Subject: [PATCH 332/496] test: constrain update --- editor/tests/solve_expr2.rs | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/editor/tests/solve_expr2.rs b/editor/tests/solve_expr2.rs index 374afd6590..465bb6511b 100644 --- a/editor/tests/solve_expr2.rs +++ b/editor/tests/solve_expr2.rs @@ -300,3 +300,17 @@ fn constrain_when() { "[ Blue, Purple ]*", ) } + +#[test] +fn constrain_update() { + infer_eq( + indoc!( + r#" + thing = { name: "roc" } + + { thing & name: "bird" } + "# + ), + "{ name : Str }*", + ) +} From 8b957ea712f21ea4f9c1a5f1b121cbcfd3e32d94 Mon Sep 17 00:00:00 2001 From: rvcas Date: Mon, 21 Jun 2021 00:19:27 -0400 Subject: [PATCH 333/496] feat: more consistent field name --- editor/src/lang/ast.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/editor/src/lang/ast.rs b/editor/src/lang/ast.rs index b1b75b0554..717428038c 100644 --- a/editor/src/lang/ast.rs +++ b/editor/src/lang/ast.rs @@ -135,9 +135,9 @@ pub enum Expr2 { body_id: NodeId, // 4B }, LetFunction { - def: NodeId, // 4B - body_var: Variable, // 8B - body_id: NodeId, // 4B + def_id: NodeId, // 4B + body_var: Variable, // 8B + body_id: NodeId, // 4B }, LetValue { def_id: NodeId, // 4B From 876687e0787ffd7d14cc6668de683751e177657a Mon Sep 17 00:00:00 2001 From: rvcas Date: Mon, 21 Jun 2021 00:21:42 -0400 Subject: [PATCH 334/496] feat(Expr2): support Defs and add desugaring --- editor/src/lang/expr.rs | 179 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 175 insertions(+), 4 deletions(-) diff --git a/editor/src/lang/expr.rs b/editor/src/lang/expr.rs index 2a9626bd5b..a383b6b00d 100644 --- a/editor/src/lang/expr.rs +++ b/editor/src/lang/expr.rs @@ -1,11 +1,16 @@ #![allow(clippy::all)] #![allow(dead_code)] #![allow(unused_imports)] +use std::collections::HashMap; + use crate::lang::ast::expr2_to_string; use crate::lang::ast::RecordField; use crate::lang::ast::{ClosureExtra, Expr2, ExprId, FloatVal, IntStyle, IntVal, WhenBranch}; -use crate::lang::def::References; -use crate::lang::pattern::to_pattern2; +use crate::lang::def::canonicalize_defs; +use crate::lang::def::sort_can_defs; +use crate::lang::def::Def; +use crate::lang::def::{CanDefs, PendingDef, References}; +use crate::lang::pattern::{to_pattern2, Pattern2}; use crate::lang::pool::{NodeId, Pool, PoolStr, PoolVec, ShallowClone}; use crate::lang::scope::Scope; use crate::lang::types::{Alias, Type2, TypeId}; @@ -13,7 +18,10 @@ use bumpalo::Bump; use inlinable_string::InlinableString; use roc_can::expr::Recursive; use roc_can::num::{finish_parsing_base, finish_parsing_float, finish_parsing_int}; +use roc_can::operator::desugar_expr; +use roc_collections::all::default_hasher; use roc_collections::all::{MutMap, MutSet}; +use roc_module::ident::Lowercase; use roc_module::ident::ModuleName; use roc_module::low_level::LowLevel; use roc_module::operator::CalledVia; @@ -21,14 +29,69 @@ use roc_module::symbol::{IdentIds, ModuleId, ModuleIds, Symbol}; use roc_parse::ast; use roc_parse::ast::StrLiteral; use roc_parse::parser::{loc, Parser, State, SyntaxError}; +use roc_parse::pattern::PatternType; use roc_problem::can::{Problem, RuntimeError}; use roc_region::all::{Located, Region}; use roc_types::subs::{VarStore, Variable}; +use super::def::Declaration; +use super::pattern::PatternId; +use super::types::Annotation2; + +#[derive(Clone, Debug, PartialEq, Default)] +pub struct IntroducedVariables { + // NOTE on rigids + // + // Rigids must be unique within a type annoation. + // E.g. in `identity : a -> a`, there should only be one + // variable (a rigid one, with name "a"). + // Hence `rigids : ImMap` + // + // But then between annotations, the same name can occur multiple times, + // but a variable can only have one name. Therefore + // `ftv : SendMap`. + pub wildcards: Vec, + pub var_by_name: MutMap, + pub name_by_var: MutMap, + pub host_exposed_aliases: MutMap, +} + +impl IntroducedVariables { + pub fn insert_named(&mut self, name: Lowercase, var: Variable) { + self.var_by_name.insert(name.clone(), var); + self.name_by_var.insert(var, name); + } + + pub fn insert_wildcard(&mut self, var: Variable) { + self.wildcards.push(var); + } + + pub fn insert_host_exposed_alias(&mut self, symbol: Symbol, var: Variable) { + self.host_exposed_aliases.insert(symbol, var); + } + + pub fn union(&mut self, other: &Self) { + self.wildcards.extend(other.wildcards.iter().cloned()); + self.var_by_name.extend(other.var_by_name.clone()); + self.name_by_var.extend(other.name_by_var.clone()); + self.host_exposed_aliases + .extend(other.host_exposed_aliases.clone()); + } + + pub fn var_by_name(&self, name: &Lowercase) -> Option<&Variable> { + self.var_by_name.get(name) + } + + pub fn name_by_var(&self, var: Variable) -> Option<&Lowercase> { + self.name_by_var.get(&var) + } +} + #[derive(Clone, Default, Debug, PartialEq)] pub struct Output { pub references: References, pub tail_call: Option, + pub introduced_variables: IntroducedVariables, pub aliases: MutMap>, pub non_closures: MutSet, } @@ -236,7 +299,16 @@ pub fn str_to_expr2<'a>( region: Region, ) -> Result<(Expr2, self::Output), SyntaxError<'a>> { match roc_parse::test_helpers::parse_loc_with(arena, input.trim()) { - Ok(loc_expr) => Ok(to_expr2(env, scope, arena.alloc(loc_expr.value), region)), + Ok(loc_expr) => { + let desugared_loc_expr = desugar_expr(arena, arena.alloc(loc_expr)); + + Ok(to_expr2( + env, + scope, + arena.alloc(desugared_loc_expr.value), + region, + )) + } Err(fail) => Err(fail), } } @@ -780,7 +852,50 @@ pub fn to_expr2<'a>( } Defs(loc_defs, loc_ret) => { - todo!("{:?} {:?}", loc_defs, loc_ret) + let (unsorted, mut scope, defs_output, symbols_introduced) = canonicalize_defs( + env, + Output::default(), + &scope, + loc_defs, + PatternType::DefExpr, + ); + + // The def as a whole is a tail call iff its return expression is a tail call. + // Use its output as a starting point because its tail_call already has the right answer! + let (ret_expr, mut output) = to_expr2(env, &mut scope, &loc_ret.value, loc_ret.region); + + output + .introduced_variables + .union(&defs_output.introduced_variables); + + output.references.union_mut(defs_output.references); + + // Now that we've collected all the references, check to see if any of the new idents + // we defined went unused by the return expression. If any were unused, report it. + for (symbol, region) in symbols_introduced { + if !output.references.has_lookup(symbol) { + env.problem(Problem::UnusedDef(symbol, region)); + } + } + + let (can_defs, output) = sort_can_defs(env, unsorted, output); + + match can_defs { + Ok(decls) => { + let mut expr = ret_expr; + + for declaration in decls.into_iter().rev() { + expr = decl_to_let(env.pool, env.var_store, declaration, expr); + } + + (expr, output) + } + Err(_err) => { + // TODO: fix this to be something from Expr2 + // (RuntimeError(err), output) + todo!() + } + } } PrecedenceConflict { .. } => { @@ -1294,3 +1409,59 @@ fn canonicalize_lookup( (can_expr, output) } + +fn decl_to_let(pool: &mut Pool, var_store: &mut VarStore, decl: Declaration, ret: Expr2) -> Expr2 { + match decl { + Declaration::Declare(def) => match def { + Def::AnnotationOnly { .. } => todo!(), + Def::Value(value_def) => { + let def_id = pool.add(value_def); + let body_id = pool.add(ret); + + Expr2::LetValue { + def_id, + body_id, + body_var: var_store.fresh(), + } + } + Def::Function(function_def) => { + let def_id = pool.add(function_def); + let body_id = pool.add(ret); + + Expr2::LetFunction { + def_id, + body_id, + body_var: var_store.fresh(), + } + } + }, + Declaration::DeclareRec(defs) => { + let mut function_defs = vec![]; + + for def in defs { + match def { + Def::AnnotationOnly { .. } => todo!(), + Def::Function(function_def) => function_defs.push(function_def), + Def::Value(_) => unreachable!(), + } + } + + let body_id = pool.add(ret); + + Expr2::LetRec { + defs: PoolVec::new(function_defs.into_iter(), pool), + body_var: var_store.fresh(), + body_id, + } + } + Declaration::InvalidCycle(_entries, _) => { + // TODO: replace with something from Expr2 + // Expr::RuntimeError(RuntimeError::CircularDef(entries)) + todo!() + } + Declaration::Builtin(_) => { + // Builtins should only be added to top-level decls, not to let-exprs! + unreachable!() + } + } +} From e69b798857fd853048b77fcfd18c5df780f70ecf Mon Sep 17 00:00:00 2001 From: rvcas Date: Mon, 21 Jun 2021 00:22:32 -0400 Subject: [PATCH 335/496] chore: pending def should be pub --- editor/src/lang/def.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/editor/src/lang/def.rs b/editor/src/lang/def.rs index c56115eb03..8d60444847 100644 --- a/editor/src/lang/def.rs +++ b/editor/src/lang/def.rs @@ -79,7 +79,7 @@ impl ShallowClone for Def { /// but no Expr canonicalization has happened yet. Also, it has had spaces /// and nesting resolved, and knows whether annotations are standalone or not. #[derive(Debug)] -enum PendingDef<'a> { +pub enum PendingDef<'a> { /// A standalone annotation with no body AnnotationOnly( &'a Located>, From 477dee0ae6f81eab24705bde398a6845843905b5 Mon Sep 17 00:00:00 2001 From: rvcas Date: Mon, 21 Jun 2021 00:23:05 -0400 Subject: [PATCH 336/496] feat(Expr2): constrain LetValue and Update --- editor/src/lang/constrain.rs | 157 ++++++++++++++++++++++++++++++++++- 1 file changed, 155 insertions(+), 2 deletions(-) diff --git a/editor/src/lang/constrain.rs b/editor/src/lang/constrain.rs index 106eea2f1f..cdad0e3d3f 100644 --- a/editor/src/lang/constrain.rs +++ b/editor/src/lang/constrain.rs @@ -9,8 +9,11 @@ use crate::lang::{ }; use roc_can::expected::{Expected, PExpected}; -use roc_collections::all::{BumpMap, BumpMapDefault, Index}; -use roc_module::{ident::TagName, symbol::Symbol}; +use roc_collections::all::{BumpMap, BumpMapDefault, Index, SendMap}; +use roc_module::{ + ident::{Lowercase, TagName}, + symbol::Symbol, +}; use roc_region::all::Region; use roc_types::{ subs::Variable, @@ -754,6 +757,140 @@ pub fn constrain_expr<'a>( // exhautiveness checking happens when converting to mono::Expr exists(arena, flex_vars, And(constraints)) } + Expr2::LetValue { + def_id, + body_id, + body_var, + } => { + let value_def = env.pool.get(*def_id); + let body = env.pool.get(*body_id); + + let mut body_con = constrain_expr(arena, env, body, expected.shallow_clone(), region); + + if let Some((expr_type_id, _)) = value_def.expr_type { + let mut flex_vars = BumpVec::with_capacity_in(1, arena); + flex_vars.push(*body_var); + + // Constrain Def + let mut and_constraints = BumpVec::with_capacity_in(1, arena); + + let pattern = env.pool.get(value_def.pattern); + + let expr_type = env.pool.get(expr_type_id); + + let pattern_expected = PExpected::NoExpectation(expr_type.shallow_clone()); + + let mut state = PatternState2 { + headers: BumpMap::new_in(arena), + vars: BumpVec::with_capacity_in(1, arena), + constraints: BumpVec::with_capacity_in(1, arena), + }; + + constrain_pattern(arena, env, pattern, region, pattern_expected, &mut state); + + state.vars.push(value_def.expr_var); + + let constrained_def = Let(arena.alloc(LetConstraint { + rigid_vars: BumpVec::new_in(arena), + flex_vars: state.vars, + def_types: state.headers, + defs_constraint: And(state.constraints), + ret_constraint: body_con, + })); + + and_constraints.push(constrained_def); + and_constraints.push(Eq( + Type2::Variable(*body_var), + expected, + Category::Storage(std::file!(), std::line!()), + // TODO: needs to be ret region + region, + )); + + body_con = exists(arena, flex_vars, And(and_constraints)); + } + + body_con + } + Expr2::Update { + symbol, + updates, + ext_var, + record_var, + } => { + let field_types = PoolVec::with_capacity(updates.len() as u32, env.pool); + let mut flex_vars = BumpVec::with_capacity_in(updates.len() + 2, arena); + let mut cons = BumpVec::with_capacity_in(updates.len() + 1, arena); + let mut record_key_updates = SendMap::default(); + + for (record_field_id, field_type_node_id) in + updates.iter_node_ids().zip(field_types.iter_node_ids()) + { + let record_field = env.pool.get(record_field_id); + + match record_field { + RecordField::LabeledValue(pool_str, var, node_id) => { + let expr = env.pool.get(*node_id); + + let (field_type, field_con) = constrain_field_update( + arena, + env, + *var, + pool_str.as_str(env.pool).into(), + expr, + ); + + let field_type_id = env.pool.add(field_type); + + env.pool[field_type_node_id] = + (*pool_str, types::RecordField::Required(field_type_id)); + + record_key_updates.insert(pool_str.as_str(env.pool).into(), Region::zero()); + + flex_vars.push(*var); + cons.push(field_con); + } + e => todo!("{:?}", e), + } + } + + let fields_type = Type2::Record(field_types, env.pool.add(Type2::Variable(*ext_var))); + let record_type = Type2::Variable(*record_var); + + // NOTE from elm compiler: fields_type is separate so that Error propagates better + let fields_con = Eq( + record_type.shallow_clone(), + Expected::NoExpectation(fields_type), + Category::Record, + region, + ); + let record_con = Eq( + record_type.shallow_clone(), + expected, + Category::Record, + region, + ); + + flex_vars.push(*record_var); + flex_vars.push(*ext_var); + + let con = Lookup( + *symbol, + Expected::ForReason( + Reason::RecordUpdateKeys(*symbol, record_key_updates), + record_type, + region, + ), + region, + ); + + // ensure constraints are solved in this order, gives better errors + cons.insert(0, fields_con); + cons.insert(1, con); + cons.insert(2, record_con); + + exists(arena, flex_vars, And(cons)) + } _ => todo!("implement constraints for {:?}", expr), } } @@ -785,6 +922,22 @@ fn constrain_field<'a>( (field_type, constraint) } +#[inline(always)] +fn constrain_field_update<'a>( + arena: &'a Bump, + env: &mut Env, + field_var: Variable, + field: Lowercase, + expr: &Expr2, +) -> (Type2, Constraint<'a>) { + let field_type = Type2::Variable(field_var); + let reason = Reason::RecordUpdateValue(field); + let field_expected = Expected::ForReason(reason, field_type.shallow_clone(), Region::zero()); + let con = constrain_expr(arena, env, expr, field_expected, Region::zero()); + + (field_type, con) +} + fn constrain_empty_record<'a>(expected: Expected, region: Region) -> Constraint<'a> { Constraint::Eq(Type2::EmptyRec, expected, Category::Record, region) } From 95c952a1ae5e37562c734b54c01d8bba1eee72ee Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 21 Jun 2021 20:35:00 +0200 Subject: [PATCH 337/496] remove a wrapped --- compiler/mono/src/ir.rs | 7 +------ compiler/mono/src/layout.rs | 10 ++++++++++ 2 files changed, 11 insertions(+), 6 deletions(-) diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index f048ec1b2d..7dced3346b 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -5642,9 +5642,6 @@ fn store_pattern_help<'a>( tag_id, .. } => { - let union_layout = Layout::Union(*layout); - let wrapped = Wrapped::from_layout(&union_layout); - return store_tag_pattern( env, procs, @@ -5652,7 +5649,6 @@ fn store_pattern_help<'a>( outer_symbol, *layout, &arguments, - wrapped, *tag_id, stmt, ); @@ -5697,13 +5693,12 @@ fn store_tag_pattern<'a>( structure: Symbol, union_layout: UnionLayout<'a>, arguments: &[(Pattern<'a>, Layout<'a>)], - wrapped: Wrapped, tag_id: u8, mut stmt: Stmt<'a>, ) -> StorePattern<'a> { use Pattern::*; - let write_tag = wrapped == Wrapped::MultiTagUnion; + let write_tag = union_layout.stores_tag(); let mut arg_layouts = Vec::with_capacity_in(arguments.len(), env.arena); let mut is_productive = false; diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index 6295664f88..8b6677b55f 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -171,6 +171,16 @@ impl<'a> UnionLayout<'a> { } } } + + pub fn stores_tag(&self) -> bool { + match self { + UnionLayout::NonRecursive(_) => true, + UnionLayout::Recursive(_) => true, + UnionLayout::NonNullableUnwrapped(_) => false, + UnionLayout::NullableWrapped { .. } => true, + UnionLayout::NullableUnwrapped { .. } => false, + } + } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] From 5734cce2502b5a351d503084006c743619d7ce95 Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 21 Jun 2021 20:40:15 +0200 Subject: [PATCH 338/496] cleanup --- compiler/mono/src/ir.rs | 2 +- compiler/mono/src/layout.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 7dced3346b..5652fe3212 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -5784,7 +5784,7 @@ fn store_newtype_pattern<'a>( ) -> StorePattern<'a> { use Pattern::*; - let write_tag = wrapped == Wrapped::MultiTagUnion; + let write_tag = false; let mut arg_layouts = Vec::with_capacity_in(arguments.len(), env.arena); let mut is_productive = false; diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index 8b6677b55f..7fdb9754d6 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -178,7 +178,7 @@ impl<'a> UnionLayout<'a> { UnionLayout::Recursive(_) => true, UnionLayout::NonNullableUnwrapped(_) => false, UnionLayout::NullableWrapped { .. } => true, - UnionLayout::NullableUnwrapped { .. } => false, + UnionLayout::NullableUnwrapped { .. } => true, } } } From cc93da006df2fccbed130a73fbc8ee4a73d06022 Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 21 Jun 2021 20:56:03 +0200 Subject: [PATCH 339/496] emit less MultiTagUnion --- compiler/mono/src/decision_tree.rs | 7 +++-- compiler/mono/src/ir.rs | 30 ++++++++++++------- compiler/mono/src/layout.rs | 2 ++ .../generated/specialize_closures.txt | 6 ++-- .../generated/specialize_lowlevel.txt | 4 +-- 5 files changed, 31 insertions(+), 18 deletions(-) diff --git a/compiler/mono/src/decision_tree.rs b/compiler/mono/src/decision_tree.rs index 7e9395e781..04d25e0b78 100644 --- a/compiler/mono/src/decision_tree.rs +++ b/compiler/mono/src/decision_tree.rs @@ -1036,8 +1036,8 @@ fn path_to_expr_help<'a>( let mut it = instructions.iter().peekable(); while let Some(PathInstruction { index, tag_id }) = it.next() { - match Wrapped::opt_from_layout(&layout) { - None => { + match Wrapped::is_indexable(&layout) { + false => { // this MUST be an index into a single-element (hence unwrapped) record debug_assert_eq!(*index, 0, "{:?}", &layout); @@ -1063,7 +1063,7 @@ fn path_to_expr_help<'a>( break; } - Some(wrapped) => { + true => { let index = *index; let (inner_layout, inner_expr) = match layout { @@ -1078,6 +1078,7 @@ fn path_to_expr_help<'a>( (union_layout.layout_at(*tag_id as u8, index as usize), expr) } Layout::Struct(field_layouts) => { + let wrapped = Wrapped::opt_from_layout(&layout).unwrap(); debug_assert!(field_layouts.len() > 1); debug_assert_eq!(wrapped, Wrapped::RecordOrSingleTagUnion); diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 5652fe3212..d840663142 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -1032,6 +1032,17 @@ impl Wrapped { } } + pub fn is_indexable(layout: &Layout<'_>) -> bool { + match layout { + Layout::Struct(fields) => match fields.len() { + _ => true, + }, + + Layout::Union(variant) => true, + _ => false, + } + } + pub fn opt_from_layout(layout: &Layout<'_>) -> Option { match layout { Layout::Struct(fields) => match fields.len() { @@ -1056,6 +1067,7 @@ impl Wrapped { NonNullableUnwrapped(_) => Some(Wrapped::LikeARoseTree), NullableWrapped { .. } | NullableUnwrapped { .. } => { + todo!(); Some(Wrapped::MultiTagUnion) } } @@ -2133,6 +2145,8 @@ fn specialize_external<'a>( match closure_layout.layout_for_member(proc_name) { ClosureRepresentation::Union { tag_layout: field_layouts, + union_layout, + tag_id, .. } => { debug_assert_eq!(field_layouts.len() - 1, captured.len()); @@ -2143,11 +2157,11 @@ fn specialize_external<'a>( index += 1; // TODO therefore should the wrapped here not be RecordOrSingleTagUnion? - let expr = Expr::AccessAtIndex { - index: index as _, - field_layouts, + let expr = Expr::CoerceToTagId { + tag_id, structure: Symbol::ARG_CLOSURE, - wrapped, + index: index as _, + union_layout, }; let layout = field_layouts[index]; @@ -4074,21 +4088,17 @@ fn construct_closure_data<'a>( tag_layout: _, union_size, tag_name, + union_layout, } => { let tag_id_symbol = env.unique_symbol(); let mut tag_symbols = Vec::with_capacity_in(symbols.len() + 1, env.arena); tag_symbols.push(tag_id_symbol); tag_symbols.extend(symbols); - let tag_layout = match lambda_set.runtime_representation() { - Layout::Union(inner) => inner, - _ => unreachable!(), - }; - let expr1 = Expr::Literal(Literal::Int(tag_id as i128)); let expr2 = Expr::Tag { tag_id, - tag_layout, + tag_layout: union_layout, union_size, tag_name, arguments: tag_symbols.into_bump_slice(), diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index 7fdb9754d6..05e02cf9ca 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -200,6 +200,7 @@ pub enum ClosureRepresentation<'a> { tag_name: TagName, tag_id: u8, union_size: u8, + union_layout: UnionLayout<'a>, }, /// the representation is anything but a union Other(Layout<'a>), @@ -241,6 +242,7 @@ impl<'a> LambdaSet<'a> { tag_id: index as u8, tag_layout: tags[index], tag_name: TagName::Closure(function_symbol), + union_layout: *union, } } UnionLayout::Recursive(_) => todo!("recursive closures"), diff --git a/compiler/test_mono/generated/specialize_closures.txt b/compiler/test_mono/generated/specialize_closures.txt index b67e0561b7..5534042fa3 100644 --- a/compiler/test_mono/generated/specialize_closures.txt +++ b/compiler/test_mono/generated/specialize_closures.txt @@ -22,13 +22,13 @@ procedure Test.1 (Test.2, Test.3): procedure Test.7 (Test.10, #Attr.12): - let Test.4 = Index 1 #Attr.12; + let Test.4 = CoerceToTagId (Id 0) (Index 1) #Attr.12; let Test.29 = CallByName Num.24 Test.10 Test.4; ret Test.29; procedure Test.8 (Test.11, #Attr.12): - let Test.6 = Index 2 #Attr.12; - let Test.5 = Index 1 #Attr.12; + let Test.6 = CoerceToTagId (Id 1) (Index 2) #Attr.12; + let Test.5 = CoerceToTagId (Id 1) (Index 1) #Attr.12; if Test.6 then let Test.24 = CallByName Num.26 Test.11 Test.5; ret Test.24; diff --git a/compiler/test_mono/generated/specialize_lowlevel.txt b/compiler/test_mono/generated/specialize_lowlevel.txt index 6f36920266..cd81b26370 100644 --- a/compiler/test_mono/generated/specialize_lowlevel.txt +++ b/compiler/test_mono/generated/specialize_lowlevel.txt @@ -7,12 +7,12 @@ procedure Num.26 (#Attr.2, #Attr.3): ret Test.21; procedure Test.6 (Test.8, #Attr.12): - let Test.4 = Index 1 #Attr.12; + let Test.4 = CoerceToTagId (Id 0) (Index 1) #Attr.12; let Test.25 = CallByName Num.24 Test.8 Test.4; ret Test.25; procedure Test.7 (Test.9, #Attr.12): - let Test.5 = Index 1 #Attr.12; + let Test.5 = CoerceToTagId (Id 1) (Index 1) #Attr.12; let Test.20 = CallByName Num.26 Test.9 Test.5; ret Test.20; From 8a36c205595d7fc0e5dfdc8c4a94840b232fd153 Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 21 Jun 2021 20:59:54 +0200 Subject: [PATCH 340/496] multi tag union is obsolete --- compiler/mono/src/ir.rs | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index d840663142..690f5ef164 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -1062,13 +1062,14 @@ impl Wrapped { 1 => Some(Wrapped::SingleElementRecord), _ => Some(Wrapped::RecordOrSingleTagUnion), }, - _ => Some(Wrapped::MultiTagUnion), + _ => { + unreachable!() + } }, NonNullableUnwrapped(_) => Some(Wrapped::LikeARoseTree), NullableWrapped { .. } | NullableUnwrapped { .. } => { - todo!(); - Some(Wrapped::MultiTagUnion) + unreachable!(); } } } From 65f4ff9663399495bad6ffe0c464ebbb5629684c Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 21 Jun 2021 21:03:37 +0200 Subject: [PATCH 341/496] remove MultiTagUnion --- compiler/mono/src/alias_analysis.rs | 11 ----------- compiler/mono/src/expand_rc.rs | 7 +++++-- compiler/mono/src/ir.rs | 12 +----------- compiler/mono/src/layout.rs | 2 +- 4 files changed, 7 insertions(+), 25 deletions(-) diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 521d8f3e95..d9ce3aa1bc 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -900,17 +900,6 @@ fn expr_spec( let result_type = layout_spec(builder, layout)?; builder.add_unknown_with(block, &[value_id], result_type) } - Wrapped::MultiTagUnion => { - // Clearly this is not generally correct, but it should be for our examples - // let hacky_is_recursive = field_layouts.iter().any(|l| l == &Layout::RecursivePointer); - // if hacky_is_recursive { - - // we don't know what constructor we are at this point, so how can we get a - // field from an enum value? - - let result_type = layout_spec(builder, layout)?; - builder.add_unknown_with(block, &[value_id], result_type) - } } } Array { elem_layout, elems } => { diff --git a/compiler/mono/src/expand_rc.rs b/compiler/mono/src/expand_rc.rs index ed848c8308..b2769ff22b 100644 --- a/compiler/mono/src/expand_rc.rs +++ b/compiler/mono/src/expand_rc.rs @@ -191,7 +191,7 @@ impl<'a, 'i> Env<'a, 'i> { Symbol::new(self.home, ident_id) } - + #[allow(dead_code)] fn manual_unique_symbol(home: ModuleId, ident_ids: &mut IdentIds) -> Symbol { let ident_id = ident_ids.gen_unique(); @@ -302,11 +302,13 @@ fn work_for_constructor<'a>( // we have to extract it now, but we only extract it // if at least one field is aliased. + todo!("get the tag id"); + /* let expr = Expr::AccessAtIndex { index: i as u64, field_layouts: constructor_layout, structure: *symbol, - wrapped: Wrapped::MultiTagUnion, + wrapped: todo!("get the tag id"), }; // create a fresh symbol for this field @@ -320,6 +322,7 @@ fn work_for_constructor<'a>( env.deferred.assignments.push((alias_symbol, expr, layout)); result.push(alias_symbol); + */ } None => { // if all refcounted fields were unaliased, generate a normal decrement diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 690f5ef164..374fe64bfd 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -1021,7 +1021,6 @@ pub enum Wrapped { RecordOrSingleTagUnion, /// Like a rose tree; recursive, but only one tag LikeARoseTree, - MultiTagUnion, } impl Wrapped { @@ -1033,14 +1032,7 @@ impl Wrapped { } pub fn is_indexable(layout: &Layout<'_>) -> bool { - match layout { - Layout::Struct(fields) => match fields.len() { - _ => true, - }, - - Layout::Union(variant) => true, - _ => false, - } + matches!(layout, Layout::Struct(_) | Layout::Union(_)) } pub fn opt_from_layout(layout: &Layout<'_>) -> Option { @@ -2141,8 +2133,6 @@ fn specialize_external<'a>( (Some(closure_layout), CapturedSymbols::Captured(captured)) => { // debug_assert!(!captured.is_empty()); - let wrapped = closure_layout.get_wrapped(); - match closure_layout.layout_for_member(proc_name) { ClosureRepresentation::Union { tag_layout: field_layouts, diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index 05e02cf9ca..6079317c36 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -392,7 +392,7 @@ impl<'a> LambdaSet<'a> { match self.representation { Layout::Struct(fields) if fields.len() == 1 => Wrapped::SingleElementRecord, Layout::Struct(_) => Wrapped::RecordOrSingleTagUnion, - Layout::Union(_) => Wrapped::MultiTagUnion, + Layout::Union(_) => unreachable!(), _ => Wrapped::SingleElementRecord, } } From ab8e0c756d08ba950dd2cbc70e965cae73d68128 Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 21 Jun 2021 21:07:49 +0200 Subject: [PATCH 342/496] remove LikeARoseTree --- compiler/gen_llvm/src/llvm/build.rs | 6 ------ compiler/mono/src/alias_analysis.rs | 4 ---- compiler/mono/src/ir.rs | 4 +--- 3 files changed, 1 insertion(+), 13 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 0cb9d1e77e..dbaea34d79 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -1440,12 +1440,6 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( structure, wrapped: Wrapped::RecordOrSingleTagUnion, .. - } - | AccessAtIndex { - index, - structure, - wrapped: Wrapped::LikeARoseTree, - .. } => { // extract field from a record match load_symbol_and_layout(scope, structure) { diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index d9ce3aa1bc..4b089f002c 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -896,10 +896,6 @@ fn expr_spec( Wrapped::RecordOrSingleTagUnion => { builder.add_get_tuple_field(block, value_id, *index as u32) } - Wrapped::LikeARoseTree => { - let result_type = layout_spec(builder, layout)?; - builder.add_unknown_with(block, &[value_id], result_type) - } } } Array { elem_layout, elems } => { diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 374fe64bfd..4fbdcc92e4 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -1019,8 +1019,6 @@ pub enum Wrapped { EmptyRecord, SingleElementRecord, RecordOrSingleTagUnion, - /// Like a rose tree; recursive, but only one tag - LikeARoseTree, } impl Wrapped { @@ -1058,7 +1056,7 @@ impl Wrapped { unreachable!() } }, - NonNullableUnwrapped(_) => Some(Wrapped::LikeARoseTree), + NonNullableUnwrapped(_) => unreachable!(), NullableWrapped { .. } | NullableUnwrapped { .. } => { unreachable!(); From 4bbaa007f39868d5ad8784a3b383aa7ab8c08011 Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 21 Jun 2021 21:16:21 +0200 Subject: [PATCH 343/496] remove EmptyStruct from wrapper --- compiler/mono/src/alias_analysis.rs | 4 --- compiler/mono/src/ir.rs | 5 ++- compiler/test_gen/src/gen_primitives.rs | 41 +++++++++++++++++++++++++ 3 files changed, 43 insertions(+), 7 deletions(-) diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 4b089f002c..4e94937d84 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -885,10 +885,6 @@ fn expr_spec( let value_id = env.symbols[structure]; match wrapped { - Wrapped::EmptyRecord => { - // this is a unit value - builder.add_make_tuple(block, &[]) - } Wrapped::SingleElementRecord => { // builder.add_get_tuple_field(block, value_id, *index as u32) Ok(env.symbols[structure]) diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 4fbdcc92e4..7d638d7e9c 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -1016,7 +1016,6 @@ pub enum Literal<'a> { #[derive(Clone, Copy, Debug, PartialEq)] pub enum Wrapped { - EmptyRecord, SingleElementRecord, RecordOrSingleTagUnion, } @@ -1036,7 +1035,7 @@ impl Wrapped { pub fn opt_from_layout(layout: &Layout<'_>) -> Option { match layout { Layout::Struct(fields) => match fields.len() { - 0 => Some(Wrapped::EmptyRecord), + 0 => unreachable!(), 1 => Some(Wrapped::SingleElementRecord), _ => Some(Wrapped::RecordOrSingleTagUnion), }, @@ -1048,7 +1047,7 @@ impl Wrapped { Recursive(tags) | NonRecursive(tags) => match tags { [] => todo!("how to handle empty tag unions?"), [single] => match single.len() { - 0 => Some(Wrapped::EmptyRecord), + 0 => unreachable!(), 1 => Some(Wrapped::SingleElementRecord), _ => Some(Wrapped::RecordOrSingleTagUnion), }, diff --git a/compiler/test_gen/src/gen_primitives.rs b/compiler/test_gen/src/gen_primitives.rs index 0fd75bf227..abe4ba8736 100644 --- a/compiler/test_gen/src/gen_primitives.rs +++ b/compiler/test_gen/src/gen_primitives.rs @@ -2488,3 +2488,44 @@ fn hit_unresolved_type_variable() { RocStr ); } + +#[test] +fn pattern_match_empty_record() { + assert_evals_to!( + indoc!( + r#" + app "test" provides [ main ] to "./platform" + + main : I64 + main = + when {} is + {} -> 0 + + "# + ), + 0, + i64 + ); +} + +#[test] +fn pattern_match_unit_tag() { + assert_evals_to!( + indoc!( + r#" + app "test" provides [ main ] to "./platform" + + unit : [ Unit ] + unit = Unit + + main : I64 + main = + when unit is + Unit -> 0 + + "# + ), + 0, + i64 + ); +} From 7a36c2584872ec89705dba0e5a213f6bc13aaf92 Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 21 Jun 2021 21:24:46 +0200 Subject: [PATCH 344/496] simpify pattern match on non-indexable values --- compiler/mono/src/decision_tree.rs | 6 +++--- compiler/test_mono/generated/optional_when.txt | 15 +++++++-------- 2 files changed, 10 insertions(+), 11 deletions(-) diff --git a/compiler/mono/src/decision_tree.rs b/compiler/mono/src/decision_tree.rs index 04d25e0b78..4883abd7fb 100644 --- a/compiler/mono/src/decision_tree.rs +++ b/compiler/mono/src/decision_tree.rs @@ -1057,9 +1057,9 @@ fn path_to_expr_help<'a>( wrapped: Wrapped::SingleElementRecord, }; - symbol = env.unique_symbol(); - let inner_layout = layout; - stores.push((symbol, inner_layout, inner_expr)); + // symbol = env.unique_symbol(); + // let inner_layout = layout; + // stores.push((symbol, inner_layout, inner_expr)); break; } diff --git a/compiler/test_mono/generated/optional_when.txt b/compiler/test_mono/generated/optional_when.txt index f1e9f636d0..864d5dbb38 100644 --- a/compiler/test_mono/generated/optional_when.txt +++ b/compiler/test_mono/generated/optional_when.txt @@ -14,10 +14,9 @@ procedure Test.1 (Test.6): ret Test.10; procedure Test.1 (Test.6): - let Test.36 = Index 0 Test.6; - let Test.37 = false; - let Test.38 = lowlevel Eq Test.37 Test.36; - if Test.38 then + let Test.36 = false; + let Test.37 = lowlevel Eq Test.36 Test.6; + if Test.37 then let Test.8 = 3i64; ret Test.8; else @@ -25,10 +24,10 @@ procedure Test.1 (Test.6): ret Test.10; procedure Test.0 (): - let Test.41 = true; - let Test.5 = CallByName Test.1 Test.41; - let Test.39 = false; - let Test.3 = CallByName Test.1 Test.39; + let Test.40 = true; + let Test.5 = CallByName Test.1 Test.40; + let Test.38 = false; + let Test.3 = CallByName Test.1 Test.38; let Test.31 = 11i64; let Test.32 = true; let Test.30 = Struct {Test.31, Test.32}; From ee941c9f2e32b28a4451a42603cf22147baee6c1 Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 21 Jun 2021 21:25:51 +0200 Subject: [PATCH 345/496] cleanup --- compiler/gen_llvm/src/llvm/build.rs | 91 ----------------------------- compiler/mono/src/decision_tree.rs | 17 ------ 2 files changed, 108 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index dbaea34d79..07b14c45a9 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -1496,97 +1496,6 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( } } - AccessAtIndex { - index, - structure, - field_layouts, - .. - } => { - use BasicValueEnum::*; - - let builder = env.builder; - - // Determine types, assumes the discriminant is in the field layouts - let num_fields = field_layouts.len(); - let mut field_types = Vec::with_capacity_in(num_fields, env.arena); - - for field_layout in field_layouts.iter() { - let field_type = basic_type_from_layout(env, &field_layout); - field_types.push(field_type); - } - - // cast the argument bytes into the desired shape for this tag - let (argument, structure_layout) = load_symbol_and_layout(scope, structure); - - match argument { - StructValue(value) => { - let struct_layout = Layout::Struct(field_layouts); - let struct_type = env - .context - .struct_type(field_types.into_bump_slice(), false); - - let struct_value = access_index_struct_value(builder, value, struct_type); - - let result = builder - .build_extract_value(struct_value, *index as u32, "") - .expect("desired field did not decode"); - - if let Some(Layout::RecursivePointer) = field_layouts.get(*index as usize) { - let desired_type = - block_of_memory(env.context, &struct_layout, env.ptr_bytes); - - // the value is a pointer to the actual value; load that value! - let ptr = env.builder.build_bitcast( - result, - desired_type.ptr_type(AddressSpace::Generic), - "cast_struct_value_pointer", - ); - - builder.build_load(ptr.into_pointer_value(), "load_recursive_field") - } else { - result - } - } - PointerValue(value) => match structure_layout { - Layout::Union(UnionLayout::NullableWrapped { .. }) if *index == 0 => { - panic!("this should not happen any more") - } - Layout::Union(UnionLayout::NullableUnwrapped { .. }) => { - if *index == 0 { - panic!("this should not happen any more") - } else { - let struct_type = env - .context - .struct_type(&field_types.into_bump_slice()[1..], false); - - lookup_at_index_ptr( - env, - &field_layouts[1..], - *index as usize - 1, - value, - struct_type, - structure_layout, - ) - } - } - _ => { - let struct_type = env - .context - .struct_type(field_types.into_bump_slice(), false); - - lookup_at_index_ptr( - env, - field_layouts, - *index as usize, - value, - struct_type, - structure_layout, - ) - } - }, - _ => panic!("cannot look up index in {:?}", argument), - } - } EmptyArray => empty_polymorphic_list(env), Array { elem_layout, elems } => list_literal(env, scope, elem_layout, elems), RuntimeErrorFunction(_) => todo!(), diff --git a/compiler/mono/src/decision_tree.rs b/compiler/mono/src/decision_tree.rs index 4883abd7fb..d8eccb0f87 100644 --- a/compiler/mono/src/decision_tree.rs +++ b/compiler/mono/src/decision_tree.rs @@ -1044,23 +1044,6 @@ fn path_to_expr_help<'a>( debug_assert_eq!(*tag_id, 0); debug_assert!(it.peek().is_none()); - let field_layouts = vec![layout]; - - debug_assert!(*index < field_layouts.len() as u64); - - debug_assert_eq!(field_layouts.len(), 1); - - let inner_expr = Expr::AccessAtIndex { - index: *index, - field_layouts: env.arena.alloc(field_layouts), - structure: symbol, - wrapped: Wrapped::SingleElementRecord, - }; - - // symbol = env.unique_symbol(); - // let inner_layout = layout; - // stores.push((symbol, inner_layout, inner_expr)); - break; } true => { From a94f597e1e78542dc611452a32726a0547452aea Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 21 Jun 2021 22:26:53 +0200 Subject: [PATCH 346/496] single record update --- compiler/mono/src/decision_tree.rs | 4 +- compiler/mono/src/ir.rs | 118 ++++++++++++++++------------- 2 files changed, 68 insertions(+), 54 deletions(-) diff --git a/compiler/mono/src/decision_tree.rs b/compiler/mono/src/decision_tree.rs index d8eccb0f87..b000150714 100644 --- a/compiler/mono/src/decision_tree.rs +++ b/compiler/mono/src/decision_tree.rs @@ -1061,15 +1061,13 @@ fn path_to_expr_help<'a>( (union_layout.layout_at(*tag_id as u8, index as usize), expr) } Layout::Struct(field_layouts) => { - let wrapped = Wrapped::opt_from_layout(&layout).unwrap(); debug_assert!(field_layouts.len() > 1); - debug_assert_eq!(wrapped, Wrapped::RecordOrSingleTagUnion); let expr = Expr::AccessAtIndex { index, field_layouts, structure: symbol, - wrapped, + wrapped: Wrapped::RecordOrSingleTagUnion, }; let layout = field_layouts[index as usize]; diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 7d638d7e9c..8af3905429 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -3468,33 +3468,31 @@ pub fn with_hole<'a>( let record_symbol = possible_reuse_symbol(env, procs, &loc_expr.value); - let wrapped = { - let record_layout = layout_cache - .from_var(env.arena, record_var, env.subs) - .unwrap_or_else(|err| panic!("TODO turn fn_var into a RuntimeError {:?}", err)); + let mut stmt = match field_layouts.as_slice() { + [_] => { + let mut hole = hole.clone(); + substitute_in_exprs(env.arena, &mut hole, assigned, record_symbol); - match Wrapped::opt_from_layout(&record_layout) { - Some(result) => result, - None => { - debug_assert_eq!(field_layouts.len(), 1); - Wrapped::SingleElementRecord - } + hole + } + _ => { + let expr = Expr::AccessAtIndex { + index: index.expect("field not in its own type") as u64, + field_layouts: field_layouts.into_bump_slice(), + structure: record_symbol, + wrapped: Wrapped::RecordOrSingleTagUnion, + }; + + let layout = layout_cache + .from_var(env.arena, field_var, env.subs) + .unwrap_or_else(|err| { + panic!("TODO turn fn_var into a RuntimeError {:?}", err) + }); + + Stmt::Let(assigned, expr, layout, hole) } }; - let expr = Expr::AccessAtIndex { - index: index.expect("field not in its own type") as u64, - field_layouts: field_layouts.into_bump_slice(), - structure: record_symbol, - wrapped, - }; - - let layout = layout_cache - .from_var(env.arena, field_var, env.subs) - .unwrap_or_else(|err| panic!("TODO turn fn_var into a RuntimeError {:?}", err)); - - let mut stmt = Stmt::Let(assigned, expr, layout, hole); - stmt = assign_to_symbol( env, procs, @@ -3632,26 +3630,16 @@ pub fn with_hole<'a>( other => arena.alloc([*other]), }; - let wrapped = if field_layouts.len() == 1 { - Wrapped::SingleElementRecord - } else { - Wrapped::RecordOrSingleTagUnion - }; - - let mut stmt = if symbols.len() == 1 { - let mut hole = hole.clone(); - substitute_in_exprs(env.arena, &mut hole, assigned, symbols[0]); - hole - } else { - let expr = Expr::Struct(symbols); - Stmt::Let(assigned, expr, record_layout, hole) - }; - debug_assert_eq!(field_layouts.len(), symbols.len()); debug_assert_eq!(fields.len(), symbols.len()); - let it = field_layouts.iter().zip(symbols.iter()).zip(fields); - for ((field_layout, symbol), what_to_do) in it { + if symbols.len() == 1 { + // TODO we can probably special-case this more, skippiing the generation of + // UpdateExisting + let mut stmt = hole.clone(); + + let what_to_do = &fields[0]; + match what_to_do { UpdateExisting(field) => { stmt = assign_to_symbol( @@ -3660,23 +3648,51 @@ pub fn with_hole<'a>( layout_cache, field.var, *field.loc_expr.clone(), - *symbol, + assigned, stmt, ); } - CopyExisting(index) => { - let access_expr = Expr::AccessAtIndex { - structure, - index, - field_layouts, - wrapped, - }; - stmt = Stmt::Let(*symbol, access_expr, *field_layout, arena.alloc(stmt)); + CopyExisting(_) => { + unreachable!( + r"when a record has just one field and is updated, it must update that one field" + ); } } - } - stmt + stmt + } else { + let expr = Expr::Struct(symbols); + let mut stmt = Stmt::Let(assigned, expr, record_layout, hole); + + let it = field_layouts.iter().zip(symbols.iter()).zip(fields); + + for ((field_layout, symbol), what_to_do) in it { + match what_to_do { + UpdateExisting(field) => { + stmt = assign_to_symbol( + env, + procs, + layout_cache, + field.var, + *field.loc_expr.clone(), + *symbol, + stmt, + ); + } + CopyExisting(index) => { + let access_expr = Expr::AccessAtIndex { + structure, + index, + field_layouts, + wrapped: Wrapped::RecordOrSingleTagUnion, + }; + stmt = + Stmt::Let(*symbol, access_expr, *field_layout, arena.alloc(stmt)); + } + } + } + stmt + } } Closure { From 2ceb50bd026a50e74a1db2dbd69221d979edf0a0 Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 21 Jun 2021 22:34:14 +0200 Subject: [PATCH 347/496] single element record pattern --- compiler/mono/src/ir.rs | 46 +++++++++++++++++++---------------------- 1 file changed, 21 insertions(+), 25 deletions(-) diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 8af3905429..18a3fbc916 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -5631,25 +5631,30 @@ fn store_pattern_help<'a>( | StrLiteral(_) => { return StorePattern::NotProductive(stmt); } - NewtypeDestructure { arguments, .. } => { - let mut fields = Vec::with_capacity_in(arguments.len(), env.arena); - fields.extend(arguments.iter().map(|x| x.1)); + NewtypeDestructure { arguments, .. } => match arguments.as_slice() { + [single] => { + return store_pattern_help(env, procs, layout_cache, &single.0, outer_symbol, stmt); + } + _ => { + let mut fields = Vec::with_capacity_in(arguments.len(), env.arena); + fields.extend(arguments.iter().map(|x| x.1)); - let layout = Layout::Struct(fields.into_bump_slice()); + let layout = Layout::Struct(fields.into_bump_slice()); - let wrapped = Wrapped::from_layout(&layout); + let wrapped = Wrapped::from_layout(&layout); - return store_newtype_pattern( - env, - procs, - layout_cache, - outer_symbol, - &layout, - &arguments, - wrapped, - stmt, - ); - } + return store_newtype_pattern( + env, + procs, + layout_cache, + outer_symbol, + &layout, + &arguments, + wrapped, + stmt, + ); + } + }, AppliedTag { arguments, layout, @@ -5798,23 +5803,14 @@ fn store_newtype_pattern<'a>( ) -> StorePattern<'a> { use Pattern::*; - let write_tag = false; - let mut arg_layouts = Vec::with_capacity_in(arguments.len(), env.arena); let mut is_productive = false; - if write_tag { - // add an element for the tag discriminant - arg_layouts.push(Layout::Builtin(TAG_SIZE)); - } - for (_, layout) in arguments { arg_layouts.push(*layout); } for (index, (argument, arg_layout)) in arguments.iter().enumerate().rev() { - let index = if write_tag { index + 1 } else { index }; - let mut arg_layout = *arg_layout; if let Layout::RecursivePointer = arg_layout { From 6744e009acc2ffd9258a7e2841a0be19e573551b Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 21 Jun 2021 22:56:44 +0200 Subject: [PATCH 348/496] more single record cases --- compiler/mono/src/ir.rs | 28 +++++++++++++++---- ...rd_optional_field_function_use_default.txt | 3 +- .../record_optional_field_let_use_default.txt | 3 +- .../test_mono/generated/when_on_record.txt | 3 +- 4 files changed, 25 insertions(+), 12 deletions(-) diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 18a3fbc916..040a764f19 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -5641,8 +5641,6 @@ fn store_pattern_help<'a>( let layout = Layout::Struct(fields.into_bump_slice()); - let wrapped = Wrapped::from_layout(&layout); - return store_newtype_pattern( env, procs, @@ -5650,7 +5648,6 @@ fn store_pattern_help<'a>( outer_symbol, &layout, &arguments, - wrapped, stmt, ); } @@ -5672,6 +5669,25 @@ fn store_pattern_help<'a>( stmt, ); } + RecordDestructure(destructs, [_single_field]) => { + for destruct in destructs { + match &destruct.typ { + DestructType::Required(symbol) => { + substitute_in_exprs(env.arena, &mut stmt, *symbol, outer_symbol); + } + DestructType::Guard(guard_pattern) => { + return store_pattern_help( + env, + procs, + layout_cache, + guard_pattern, + outer_symbol, + stmt, + ); + } + } + } + } RecordDestructure(destructs, sorted_fields) => { let mut is_productive = false; for (index, destruct) in destructs.iter().enumerate().rev() { @@ -5798,7 +5814,6 @@ fn store_newtype_pattern<'a>( structure: Symbol, layout: &Layout<'a>, arguments: &[(Pattern<'a>, Layout<'a>)], - wrapped: Wrapped, mut stmt: Stmt<'a>, ) -> StorePattern<'a> { use Pattern::*; @@ -5818,7 +5833,7 @@ fn store_newtype_pattern<'a>( } let load = Expr::AccessAtIndex { - wrapped, + wrapped: Wrapped::RecordOrSingleTagUnion, index: index as u64, field_layouts: arg_layouts.clone().into_bump_slice(), structure, @@ -5880,7 +5895,8 @@ fn store_record_destruct<'a>( ) -> StorePattern<'a> { use Pattern::*; - let wrapped = Wrapped::from_layout(&Layout::Struct(sorted_fields)); + // let wrapped = Wrapped::from_layout(&Layout::Struct(sorted_fields)); + let wrapped = Wrapped::RecordOrSingleTagUnion; // TODO wrapped could be SingleElementRecord let load = Expr::AccessAtIndex { diff --git a/compiler/test_mono/generated/record_optional_field_function_use_default.txt b/compiler/test_mono/generated/record_optional_field_function_use_default.txt index 8d07d5021d..0def92d630 100644 --- a/compiler/test_mono/generated/record_optional_field_function_use_default.txt +++ b/compiler/test_mono/generated/record_optional_field_function_use_default.txt @@ -3,10 +3,9 @@ procedure Num.24 (#Attr.2, #Attr.3): ret Test.8; procedure Test.1 (Test.4): - let Test.3 = Index 0 Test.4; let Test.2 = 10i64; let Test.2 = 10i64; - let Test.7 = CallByName Num.24 Test.2 Test.3; + let Test.7 = CallByName Num.24 Test.2 Test.4; ret Test.7; procedure Test.0 (): diff --git a/compiler/test_mono/generated/record_optional_field_let_use_default.txt b/compiler/test_mono/generated/record_optional_field_let_use_default.txt index b3886aaa28..aef4e20cbd 100644 --- a/compiler/test_mono/generated/record_optional_field_let_use_default.txt +++ b/compiler/test_mono/generated/record_optional_field_let_use_default.txt @@ -3,9 +3,8 @@ procedure Num.24 (#Attr.2, #Attr.3): ret Test.8; procedure Test.1 (Test.2): - let Test.4 = Index 0 Test.2; let Test.3 = 10i64; - let Test.7 = CallByName Num.24 Test.3 Test.4; + let Test.7 = CallByName Num.24 Test.3 Test.2; ret Test.7; procedure Test.0 (): diff --git a/compiler/test_mono/generated/when_on_record.txt b/compiler/test_mono/generated/when_on_record.txt index 7ab0e0f757..9c37c1097b 100644 --- a/compiler/test_mono/generated/when_on_record.txt +++ b/compiler/test_mono/generated/when_on_record.txt @@ -4,7 +4,6 @@ procedure Num.24 (#Attr.2, #Attr.3): procedure Test.0 (): let Test.7 = 2i64; - let Test.1 = Index 0 Test.7; let Test.4 = 3i64; - let Test.3 = CallByName Num.24 Test.1 Test.4; + let Test.3 = CallByName Num.24 Test.7 Test.4; ret Test.3; From 368d45fb01217a3285923e5f41f174d61fe0b2fe Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 21 Jun 2021 23:02:09 +0200 Subject: [PATCH 349/496] remove single element record --- compiler/gen_llvm/src/llvm/build.rs | 12 ------------ compiler/mono/src/alias_analysis.rs | 4 ---- compiler/mono/src/expand_rc.rs | 5 +---- compiler/mono/src/ir.rs | 10 +++------- compiler/mono/src/layout.rs | 4 ++-- 5 files changed, 6 insertions(+), 29 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 07b14c45a9..3c59dfbf98 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -1423,18 +1423,6 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( Reset(_) => todo!(), Reuse { .. } => todo!(), - AccessAtIndex { - index, - structure, - wrapped: Wrapped::SingleElementRecord, - field_layouts, - .. - } => { - debug_assert_eq!(field_layouts.len(), 1); - debug_assert_eq!(*index, 0); - load_symbol(scope, structure) - } - AccessAtIndex { index, structure, diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 4e94937d84..ccbcefb198 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -885,10 +885,6 @@ fn expr_spec( let value_id = env.symbols[structure]; match wrapped { - Wrapped::SingleElementRecord => { - // builder.add_get_tuple_field(block, value_id, *index as u32) - Ok(env.symbols[structure]) - } Wrapped::RecordOrSingleTagUnion => { builder.add_get_tuple_field(block, value_id, *index as u32) } diff --git a/compiler/mono/src/expand_rc.rs b/compiler/mono/src/expand_rc.rs index b2769ff22b..21fbf29886 100644 --- a/compiler/mono/src/expand_rc.rs +++ b/compiler/mono/src/expand_rc.rs @@ -452,10 +452,7 @@ fn expand_and_cancel<'a>(env: &mut Env<'a, '_>, stmt: &'a Stmt<'a>) -> &'a Stmt< entry.insert(*index, symbol); // fixes https://github.com/rtfeldman/roc/issues/1099 - if matches!( - wrapped, - Wrapped::SingleElementRecord | Wrapped::RecordOrSingleTagUnion - ) { + if matches!(wrapped, Wrapped::RecordOrSingleTagUnion) { env.layout_map .insert(*structure, Layout::Struct(field_layouts)); } diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 040a764f19..c60d529a5d 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -1016,7 +1016,6 @@ pub enum Literal<'a> { #[derive(Clone, Copy, Debug, PartialEq)] pub enum Wrapped { - SingleElementRecord, RecordOrSingleTagUnion, } @@ -1036,7 +1035,7 @@ impl Wrapped { match layout { Layout::Struct(fields) => match fields.len() { 0 => unreachable!(), - 1 => Some(Wrapped::SingleElementRecord), + 1 => unreachable!(), _ => Some(Wrapped::RecordOrSingleTagUnion), }, @@ -1048,7 +1047,7 @@ impl Wrapped { [] => todo!("how to handle empty tag unions?"), [single] => match single.len() { 0 => unreachable!(), - 1 => Some(Wrapped::SingleElementRecord), + 1 => unreachable!(), _ => Some(Wrapped::RecordOrSingleTagUnion), }, _ => { @@ -5895,15 +5894,12 @@ fn store_record_destruct<'a>( ) -> StorePattern<'a> { use Pattern::*; - // let wrapped = Wrapped::from_layout(&Layout::Struct(sorted_fields)); - let wrapped = Wrapped::RecordOrSingleTagUnion; - // TODO wrapped could be SingleElementRecord let load = Expr::AccessAtIndex { index, field_layouts: sorted_fields, structure: outer_symbol, - wrapped, + wrapped: Wrapped::RecordOrSingleTagUnion, }; match &destruct.typ { diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index 6079317c36..b02001c2c6 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -390,10 +390,10 @@ impl<'a> LambdaSet<'a> { use crate::ir::Wrapped; match self.representation { - Layout::Struct(fields) if fields.len() == 1 => Wrapped::SingleElementRecord, + Layout::Struct(fields) if fields.len() == 1 => unreachable!(), Layout::Struct(_) => Wrapped::RecordOrSingleTagUnion, Layout::Union(_) => unreachable!(), - _ => Wrapped::SingleElementRecord, + _ => unreachable!(), } } From 205b168f16484885cce4c08117053503d3587424 Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 21 Jun 2021 23:02:49 +0200 Subject: [PATCH 350/496] rename --- compiler/gen_dev/src/lib.rs | 2 +- compiler/gen_llvm/src/llvm/build.rs | 2 +- compiler/mono/src/alias_analysis.rs | 2 +- compiler/mono/src/borrow.rs | 2 +- compiler/mono/src/decision_tree.rs | 2 +- compiler/mono/src/expand_rc.rs | 6 +++--- compiler/mono/src/inc_dec.rs | 6 +++--- compiler/mono/src/ir.rs | 18 +++++++++--------- 8 files changed, 20 insertions(+), 20 deletions(-) diff --git a/compiler/gen_dev/src/lib.rs b/compiler/gen_dev/src/lib.rs index cc33720764..8bb93c8ab2 100644 --- a/compiler/gen_dev/src/lib.rs +++ b/compiler/gen_dev/src/lib.rs @@ -444,7 +444,7 @@ where self.set_last_seen(*sym, stmt); } } - Expr::AccessAtIndex { structure, .. } => { + Expr::StructAtIndex { structure, .. } => { self.set_last_seen(*structure, stmt); } Expr::GetTagId { structure, .. } => { diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 3c59dfbf98..d7d53f4b70 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -1423,7 +1423,7 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( Reset(_) => todo!(), Reuse { .. } => todo!(), - AccessAtIndex { + StructAtIndex { index, structure, wrapped: Wrapped::RecordOrSingleTagUnion, diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index ccbcefb198..b4662c12da 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -874,7 +874,7 @@ fn expr_spec( builder.add_unknown_with(block, &[value_id], result_type) } }, - AccessAtIndex { + StructAtIndex { index, field_layouts: _, structure, diff --git a/compiler/mono/src/borrow.rs b/compiler/mono/src/borrow.rs index 137db5cf13..5bd40dc95a 100644 --- a/compiler/mono/src/borrow.rs +++ b/compiler/mono/src/borrow.rs @@ -570,7 +570,7 @@ impl<'a> BorrowInfState<'a> { Literal(_) | RuntimeErrorFunction(_) => {} - AccessAtIndex { structure: x, .. } => { + StructAtIndex { structure: x, .. } => { // if the structure (record/tag/array) is owned, the extracted value is if self.is_owned(*x) { self.own_var(z); diff --git a/compiler/mono/src/decision_tree.rs b/compiler/mono/src/decision_tree.rs index b000150714..ec8f2f4b55 100644 --- a/compiler/mono/src/decision_tree.rs +++ b/compiler/mono/src/decision_tree.rs @@ -1063,7 +1063,7 @@ fn path_to_expr_help<'a>( Layout::Struct(field_layouts) => { debug_assert!(field_layouts.len() > 1); - let expr = Expr::AccessAtIndex { + let expr = Expr::StructAtIndex { index, field_layouts, structure: symbol, diff --git a/compiler/mono/src/expand_rc.rs b/compiler/mono/src/expand_rc.rs index 21fbf29886..ea71562303 100644 --- a/compiler/mono/src/expand_rc.rs +++ b/compiler/mono/src/expand_rc.rs @@ -343,7 +343,7 @@ fn can_push_inc_through(stmt: &Stmt) -> bool { match stmt { Let(_, expr, _, _) => { // we can always delay an increment/decrement until after a field access - matches!(expr, Expr::AccessAtIndex { .. } | Expr::Literal(_)) + matches!(expr, Expr::StructAtIndex { .. } | Expr::Literal(_)) } Refcounting(ModifyRc::Inc(_, _), _) => true, @@ -421,7 +421,7 @@ fn expand_and_cancel<'a>(env: &mut Env<'a, '_>, stmt: &'a Stmt<'a>) -> &'a Stmt< while !matches!( &expr, - Expr::AccessAtIndex { .. } | Expr::Struct(_) | Expr::Call(_) + Expr::StructAtIndex { .. } | Expr::Struct(_) | Expr::Call(_) ) { if let Stmt::Let(symbol1, expr1, layout1, cont1) = cont { literal_stack.push((symbol, expr.clone(), *layout)); @@ -438,7 +438,7 @@ fn expand_and_cancel<'a>(env: &mut Env<'a, '_>, stmt: &'a Stmt<'a>) -> &'a Stmt< let new_cont; match &expr { - Expr::AccessAtIndex { + Expr::StructAtIndex { structure, index, field_layouts, diff --git a/compiler/mono/src/inc_dec.rs b/compiler/mono/src/inc_dec.rs index 55eb19fee1..ecc405bbde 100644 --- a/compiler/mono/src/inc_dec.rs +++ b/compiler/mono/src/inc_dec.rs @@ -103,7 +103,7 @@ pub fn occurring_variables_expr(expr: &Expr<'_>, result: &mut MutSet) { use Expr::*; match expr { - AccessAtIndex { + StructAtIndex { structure: symbol, .. } => { result.insert(*symbol); @@ -225,7 +225,7 @@ fn is_borrow_param(x: Symbol, ys: &[Symbol], ps: &[Param]) -> bool { // We do not need to consume the projection of a variable that is not consumed fn consume_expr(m: &VarMap, e: &Expr<'_>) -> bool { match e { - Expr::AccessAtIndex { structure: x, .. } => match m.get(x) { + Expr::StructAtIndex { structure: x, .. } => match m.get(x) { Some(info) => info.consume, None => true, }, @@ -759,7 +759,7 @@ impl<'a> Context<'a> { self.arena.alloc(Stmt::Let(z, v, l, b)) } - AccessAtIndex { structure: x, .. } => { + StructAtIndex { structure: x, .. } => { let b = self.add_dec_if_needed(x, b, b_live_vars); let info_x = self.get_var_info(x); let b = if info_x.consume { diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index c60d529a5d..21607a7fc9 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -1186,7 +1186,7 @@ pub enum Expr<'a> { }, Struct(&'a [Symbol]), - AccessAtIndex { + StructAtIndex { index: u64, field_layouts: &'a [Layout<'a>], structure: Symbol, @@ -1350,7 +1350,7 @@ impl<'a> Expr<'a> { } EmptyArray => alloc.text("Array []"), - AccessAtIndex { + StructAtIndex { index, structure, .. } => alloc .text(format!("Index {} ", index)) @@ -2173,7 +2173,7 @@ fn specialize_external<'a>( ); for (index, (symbol, _variable)) in captured.iter().enumerate() { - let expr = Expr::AccessAtIndex { + let expr = Expr::StructAtIndex { index: index as _, field_layouts, structure: Symbol::ARG_CLOSURE, @@ -3475,7 +3475,7 @@ pub fn with_hole<'a>( hole } _ => { - let expr = Expr::AccessAtIndex { + let expr = Expr::StructAtIndex { index: index.expect("field not in its own type") as u64, field_layouts: field_layouts.into_bump_slice(), structure: record_symbol, @@ -3679,7 +3679,7 @@ pub fn with_hole<'a>( ); } CopyExisting(index) => { - let access_expr = Expr::AccessAtIndex { + let access_expr = Expr::StructAtIndex { structure, index, field_layouts, @@ -5538,13 +5538,13 @@ fn substitute_in_expr<'a>( } } - AccessAtIndex { + StructAtIndex { index, structure, field_layouts, wrapped, } => match substitute(subs, *structure) { - Some(structure) => Some(AccessAtIndex { + Some(structure) => Some(StructAtIndex { index: *index, field_layouts: *field_layouts, wrapped: *wrapped, @@ -5831,7 +5831,7 @@ fn store_newtype_pattern<'a>( arg_layout = *layout; } - let load = Expr::AccessAtIndex { + let load = Expr::StructAtIndex { wrapped: Wrapped::RecordOrSingleTagUnion, index: index as u64, field_layouts: arg_layouts.clone().into_bump_slice(), @@ -5895,7 +5895,7 @@ fn store_record_destruct<'a>( use Pattern::*; // TODO wrapped could be SingleElementRecord - let load = Expr::AccessAtIndex { + let load = Expr::StructAtIndex { index, field_layouts: sorted_fields, structure: outer_symbol, From f3b23a6a541d5e64f0037d74939a5d6c577b4e19 Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 21 Jun 2021 23:10:56 +0200 Subject: [PATCH 351/496] get rid of Wrapped --- compiler/gen_llvm/src/llvm/build.rs | 6 +-- compiler/mono/src/alias_analysis.rs | 14 +----- compiler/mono/src/decision_tree.rs | 77 ++++++++++++++--------------- compiler/mono/src/expand_rc.rs | 10 ++-- compiler/mono/src/ir.rs | 61 ----------------------- compiler/mono/src/layout.rs | 11 ----- 6 files changed, 44 insertions(+), 135 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index d7d53f4b70..1487aa8915 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -50,7 +50,6 @@ use roc_module::low_level::LowLevel; use roc_module::symbol::{Interns, ModuleId, Symbol}; use roc_mono::ir::{ BranchInfo, CallType, EntryPoint, ExceptionId, JoinPointId, ModifyRc, OptLevel, ProcLayout, - Wrapped, }; use roc_mono::layout::{Builtin, LambdaSet, Layout, LayoutIds, UnionLayout}; @@ -1424,10 +1423,7 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( Reuse { .. } => todo!(), StructAtIndex { - index, - structure, - wrapped: Wrapped::RecordOrSingleTagUnion, - .. + index, structure, .. } => { // extract field from a record match load_symbol_and_layout(scope, structure) { diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index b4662c12da..20db8e6f62 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -875,20 +875,10 @@ fn expr_spec( } }, StructAtIndex { - index, - field_layouts: _, - structure, - wrapped, + index, structure, .. } => { - use crate::ir::Wrapped; - let value_id = env.symbols[structure]; - - match wrapped { - Wrapped::RecordOrSingleTagUnion => { - builder.add_get_tuple_field(block, value_id, *index as u32) - } - } + builder.add_get_tuple_field(block, value_id, *index as u32) } Array { elem_layout, elems } => { let type_id = layout_spec(builder, elem_layout)?; diff --git a/compiler/mono/src/decision_tree.rs b/compiler/mono/src/decision_tree.rs index ec8f2f4b55..fd36404437 100644 --- a/compiler/mono/src/decision_tree.rs +++ b/compiler/mono/src/decision_tree.rs @@ -1,6 +1,6 @@ use crate::exhaustive::{Ctor, RenderAs, TagId, Union}; use crate::ir::{ - BranchInfo, DestructType, Env, Expr, JoinPointId, Literal, Param, Pattern, Procs, Stmt, Wrapped, + BranchInfo, DestructType, Env, Expr, JoinPointId, Literal, Param, Pattern, Procs, Stmt, }; use crate::layout::{Builtin, Layout, LayoutCache, UnionLayout}; use roc_collections::all::{MutMap, MutSet}; @@ -1036,52 +1036,51 @@ fn path_to_expr_help<'a>( let mut it = instructions.iter().peekable(); while let Some(PathInstruction { index, tag_id }) = it.next() { - match Wrapped::is_indexable(&layout) { - false => { - // this MUST be an index into a single-element (hence unwrapped) record + let index = *index; - debug_assert_eq!(*index, 0, "{:?}", &layout); - debug_assert_eq!(*tag_id, 0); - debug_assert!(it.peek().is_none()); - - break; - } - true => { - let index = *index; - - let (inner_layout, inner_expr) = match layout { - Layout::Union(union_layout) => { - let expr = Expr::CoerceToTagId { - tag_id: *tag_id, - structure: symbol, - index, - union_layout, - }; - - (union_layout.layout_at(*tag_id as u8, index as usize), expr) - } - Layout::Struct(field_layouts) => { - debug_assert!(field_layouts.len() > 1); - - let expr = Expr::StructAtIndex { - index, - field_layouts, - structure: symbol, - wrapped: Wrapped::RecordOrSingleTagUnion, - }; - - let layout = field_layouts[index as usize]; - - (layout, expr) - } - _ => unreachable!(), + match &layout { + Layout::Union(union_layout) => { + let inner_expr = Expr::CoerceToTagId { + tag_id: *tag_id, + structure: symbol, + index, + union_layout: *union_layout, }; + let inner_layout = union_layout.layout_at(*tag_id as u8, index as usize); + symbol = env.unique_symbol(); stores.push((symbol, inner_layout, inner_expr)); layout = inner_layout; } + + Layout::Struct(field_layouts) => { + debug_assert!(field_layouts.len() > 1); + + let inner_expr = Expr::StructAtIndex { + index, + field_layouts, + structure: symbol, + }; + + let inner_layout = field_layouts[index as usize]; + + symbol = env.unique_symbol(); + stores.push((symbol, inner_layout, inner_expr)); + + layout = inner_layout; + } + + _ => { + // this MUST be an index into a single-element (hence unwrapped) record + + debug_assert_eq!(index, 0, "{:?}", &layout); + debug_assert_eq!(*tag_id, 0); + debug_assert!(it.peek().is_none()); + + break; + } } } diff --git a/compiler/mono/src/expand_rc.rs b/compiler/mono/src/expand_rc.rs index ea71562303..01ee612edd 100644 --- a/compiler/mono/src/expand_rc.rs +++ b/compiler/mono/src/expand_rc.rs @@ -1,4 +1,4 @@ -use crate::ir::{BranchInfo, Expr, ModifyRc, Stmt, Wrapped}; +use crate::ir::{BranchInfo, Expr, ModifyRc, Stmt}; use crate::layout::{Layout, UnionLayout}; use bumpalo::collections::Vec; use bumpalo::Bump; @@ -442,7 +442,6 @@ fn expand_and_cancel<'a>(env: &mut Env<'a, '_>, stmt: &'a Stmt<'a>) -> &'a Stmt< structure, index, field_layouts, - wrapped, } => { let entry = env .alias_map @@ -451,11 +450,8 @@ fn expand_and_cancel<'a>(env: &mut Env<'a, '_>, stmt: &'a Stmt<'a>) -> &'a Stmt< entry.insert(*index, symbol); - // fixes https://github.com/rtfeldman/roc/issues/1099 - if matches!(wrapped, Wrapped::RecordOrSingleTagUnion) { - env.layout_map - .insert(*structure, Layout::Struct(field_layouts)); - } + env.layout_map + .insert(*structure, Layout::Struct(field_layouts)); // if the field is a struct, we know its constructor too! let field_layout = &field_layouts[*index as usize]; diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 21607a7fc9..e46355d98a 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -1014,58 +1014,6 @@ pub enum Literal<'a> { Byte(u8), } -#[derive(Clone, Copy, Debug, PartialEq)] -pub enum Wrapped { - RecordOrSingleTagUnion, -} - -impl Wrapped { - pub fn from_layout(layout: &Layout<'_>) -> Self { - match Self::opt_from_layout(layout) { - Some(result) => result, - None => unreachable!("not an indexable type {:?}", layout), - } - } - - pub fn is_indexable(layout: &Layout<'_>) -> bool { - matches!(layout, Layout::Struct(_) | Layout::Union(_)) - } - - pub fn opt_from_layout(layout: &Layout<'_>) -> Option { - match layout { - Layout::Struct(fields) => match fields.len() { - 0 => unreachable!(), - 1 => unreachable!(), - _ => Some(Wrapped::RecordOrSingleTagUnion), - }, - - Layout::Union(variant) => { - use UnionLayout::*; - - match variant { - Recursive(tags) | NonRecursive(tags) => match tags { - [] => todo!("how to handle empty tag unions?"), - [single] => match single.len() { - 0 => unreachable!(), - 1 => unreachable!(), - _ => Some(Wrapped::RecordOrSingleTagUnion), - }, - _ => { - unreachable!() - } - }, - NonNullableUnwrapped(_) => unreachable!(), - - NullableWrapped { .. } | NullableUnwrapped { .. } => { - unreachable!(); - } - } - } - _ => None, - } - } -} - #[derive(Clone, Debug, PartialEq)] pub struct Call<'a> { pub call_type: CallType<'a>, @@ -1190,7 +1138,6 @@ pub enum Expr<'a> { index: u64, field_layouts: &'a [Layout<'a>], structure: Symbol, - wrapped: Wrapped, }, GetTagId { @@ -2177,7 +2124,6 @@ fn specialize_external<'a>( index: index as _, field_layouts, structure: Symbol::ARG_CLOSURE, - wrapped: Wrapped::RecordOrSingleTagUnion, }; let layout = field_layouts[index]; @@ -3479,7 +3425,6 @@ pub fn with_hole<'a>( index: index.expect("field not in its own type") as u64, field_layouts: field_layouts.into_bump_slice(), structure: record_symbol, - wrapped: Wrapped::RecordOrSingleTagUnion, }; let layout = layout_cache @@ -3683,7 +3628,6 @@ pub fn with_hole<'a>( structure, index, field_layouts, - wrapped: Wrapped::RecordOrSingleTagUnion, }; stmt = Stmt::Let(*symbol, access_expr, *field_layout, arena.alloc(stmt)); @@ -5542,12 +5486,10 @@ fn substitute_in_expr<'a>( index, structure, field_layouts, - wrapped, } => match substitute(subs, *structure) { Some(structure) => Some(StructAtIndex { index: *index, field_layouts: *field_layouts, - wrapped: *wrapped, structure, }), None => None, @@ -5832,7 +5774,6 @@ fn store_newtype_pattern<'a>( } let load = Expr::StructAtIndex { - wrapped: Wrapped::RecordOrSingleTagUnion, index: index as u64, field_layouts: arg_layouts.clone().into_bump_slice(), structure, @@ -5894,12 +5835,10 @@ fn store_record_destruct<'a>( ) -> StorePattern<'a> { use Pattern::*; - // TODO wrapped could be SingleElementRecord let load = Expr::StructAtIndex { index, field_layouts: sorted_fields, structure: outer_symbol, - wrapped: Wrapped::RecordOrSingleTagUnion, }; match &destruct.typ { diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index b02001c2c6..955680d225 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -386,17 +386,6 @@ impl<'a> LambdaSet<'a> { } } - pub fn get_wrapped(&self) -> crate::ir::Wrapped { - use crate::ir::Wrapped; - - match self.representation { - Layout::Struct(fields) if fields.len() == 1 => unreachable!(), - Layout::Struct(_) => Wrapped::RecordOrSingleTagUnion, - Layout::Union(_) => unreachable!(), - _ => unreachable!(), - } - } - pub fn stack_size(&self, pointer_size: u32) -> u32 { self.representation.stack_size(pointer_size) } From f57e7a6eed31bff64963c0a034f0e6b3978efebb Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 21 Jun 2021 23:13:29 +0200 Subject: [PATCH 352/496] add assert --- compiler/gen_llvm/src/llvm/build.rs | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 1487aa8915..ae93f89211 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -1423,8 +1423,14 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( Reuse { .. } => todo!(), StructAtIndex { - index, structure, .. + index, + structure, + field_layouts, } => { + // if you hit this: we unwrap 1-element records, so instead of `x = StructAtIndex 0 y` + // you should substitute `x` with `y` in the remainder of the statement + debug_assert!(field_layouts.len() > 1, "one-element records are unwrapped"); + // extract field from a record match load_symbol_and_layout(scope, structure) { (StructValue(argument), Layout::Struct(fields)) => { From 98b493005496d3f465dd226e7a3fa305b5fb5549 Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 21 Jun 2021 23:14:05 +0200 Subject: [PATCH 353/496] rename --- compiler/gen_dev/src/lib.rs | 2 +- compiler/gen_llvm/src/llvm/build.rs | 2 +- compiler/mono/src/alias_analysis.rs | 2 +- compiler/mono/src/borrow.rs | 2 +- compiler/mono/src/decision_tree.rs | 2 +- compiler/mono/src/inc_dec.rs | 6 +++--- compiler/mono/src/ir.rs | 12 ++++++------ 7 files changed, 14 insertions(+), 14 deletions(-) diff --git a/compiler/gen_dev/src/lib.rs b/compiler/gen_dev/src/lib.rs index 8bb93c8ab2..af414118f0 100644 --- a/compiler/gen_dev/src/lib.rs +++ b/compiler/gen_dev/src/lib.rs @@ -450,7 +450,7 @@ where Expr::GetTagId { structure, .. } => { self.set_last_seen(*structure, stmt); } - Expr::CoerceToTagId { structure, .. } => { + Expr::UnionAtIndex { structure, .. } => { self.set_last_seen(*structure, stmt); } Expr::Array { elems, .. } => { diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index ae93f89211..c4a3ff8ab7 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -1490,7 +1490,7 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( Array { elem_layout, elems } => list_literal(env, scope, elem_layout, elems), RuntimeErrorFunction(_) => todo!(), - CoerceToTagId { + UnionAtIndex { tag_id, structure, index, diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 20db8e6f62..5a59917ed8 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -854,7 +854,7 @@ fn expr_spec( } }, Struct(fields) => build_tuple_value(builder, env, block, fields), - CoerceToTagId { + UnionAtIndex { index, tag_id, structure, diff --git a/compiler/mono/src/borrow.rs b/compiler/mono/src/borrow.rs index 5bd40dc95a..9df746da8f 100644 --- a/compiler/mono/src/borrow.rs +++ b/compiler/mono/src/borrow.rs @@ -582,7 +582,7 @@ impl<'a> BorrowInfState<'a> { } } - CoerceToTagId { structure: x, .. } => { + UnionAtIndex { structure: x, .. } => { // if the structure (record/tag/array) is owned, the extracted value is if self.is_owned(*x) { self.own_var(z); diff --git a/compiler/mono/src/decision_tree.rs b/compiler/mono/src/decision_tree.rs index fd36404437..29d5576a50 100644 --- a/compiler/mono/src/decision_tree.rs +++ b/compiler/mono/src/decision_tree.rs @@ -1040,7 +1040,7 @@ fn path_to_expr_help<'a>( match &layout { Layout::Union(union_layout) => { - let inner_expr = Expr::CoerceToTagId { + let inner_expr = Expr::UnionAtIndex { tag_id: *tag_id, structure: symbol, index, diff --git a/compiler/mono/src/inc_dec.rs b/compiler/mono/src/inc_dec.rs index ecc405bbde..a9583856e4 100644 --- a/compiler/mono/src/inc_dec.rs +++ b/compiler/mono/src/inc_dec.rs @@ -136,7 +136,7 @@ pub fn occurring_variables_expr(expr: &Expr<'_>, result: &mut MutSet) { result.insert(*symbol); } - CoerceToTagId { + UnionAtIndex { structure: symbol, .. } => { result.insert(*symbol); @@ -229,7 +229,7 @@ fn consume_expr(m: &VarMap, e: &Expr<'_>) -> bool { Some(info) => info.consume, None => true, }, - Expr::CoerceToTagId { structure: x, .. } => match m.get(x) { + Expr::UnionAtIndex { structure: x, .. } => match m.get(x) { Some(info) => info.consume, None => true, }, @@ -783,7 +783,7 @@ impl<'a> Context<'a> { self.arena.alloc(Stmt::Let(z, v, l, b)) } - CoerceToTagId { structure: x, .. } => { + UnionAtIndex { structure: x, .. } => { let b = self.add_dec_if_needed(x, b, b_live_vars); let info_x = self.get_var_info(x); let b = if info_x.consume { diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index e46355d98a..00618a2710 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -1145,7 +1145,7 @@ pub enum Expr<'a> { union_layout: UnionLayout<'a>, }, - CoerceToTagId { + UnionAtIndex { structure: Symbol, tag_id: u8, union_layout: UnionLayout<'a>, @@ -1309,7 +1309,7 @@ impl<'a> Expr<'a> { .text("GetTagId ") .append(symbol_to_doc(alloc, *structure)), - CoerceToTagId { + UnionAtIndex { tag_id, structure, index, @@ -2091,7 +2091,7 @@ fn specialize_external<'a>( index += 1; // TODO therefore should the wrapped here not be RecordOrSingleTagUnion? - let expr = Expr::CoerceToTagId { + let expr = Expr::UnionAtIndex { tag_id, structure: Symbol::ARG_CLOSURE, index: index as _, @@ -5506,13 +5506,13 @@ fn substitute_in_expr<'a>( None => None, }, - CoerceToTagId { + UnionAtIndex { structure, tag_id, index, union_layout, } => match substitute(subs, *structure) { - Some(structure) => Some(CoerceToTagId { + Some(structure) => Some(UnionAtIndex { structure, tag_id: *tag_id, index: *index, @@ -5697,7 +5697,7 @@ fn store_tag_pattern<'a>( arg_layout = Layout::Union(union_layout); } - let load = Expr::CoerceToTagId { + let load = Expr::UnionAtIndex { index: index as u64, structure, tag_id, From 84855dae5e77d980d9aaa73f4548a5d15f31f75e Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 21 Jun 2021 23:16:09 +0200 Subject: [PATCH 354/496] rename in mono tests --- compiler/mono/src/ir.rs | 4 ++-- compiler/test_mono/generated/closure_in_list.txt | 2 +- compiler/test_mono/generated/has_none.txt | 4 ++-- compiler/test_mono/generated/ir_when_idiv.txt | 2 +- compiler/test_mono/generated/ir_when_just.txt | 2 +- compiler/test_mono/generated/ir_when_maybe.txt | 2 +- compiler/test_mono/generated/ir_when_record.txt | 2 +- compiler/test_mono/generated/ir_when_these.txt | 6 +++--- .../test_mono/generated/let_with_record_pattern.txt | 2 +- .../generated/let_with_record_pattern_list.txt | 2 +- compiler/test_mono/generated/let_x_in_x_indirect.txt | 2 +- .../test_mono/generated/linked_list_length_twice.txt | 2 +- compiler/test_mono/generated/nested_closure.txt | 2 +- .../test_mono/generated/nested_pattern_match.txt | 6 +++--- compiler/test_mono/generated/optional_when.txt | 6 +++--- compiler/test_mono/generated/peano2.txt | 2 +- compiler/test_mono/generated/quicksort_help.txt | 4 ++-- compiler/test_mono/generated/quicksort_swap.txt | 12 ++++++------ ...record_optional_field_function_no_use_default.txt | 4 ++-- .../record_optional_field_let_no_use_default.txt | 4 ++-- compiler/test_mono/generated/rigids.txt | 12 ++++++------ compiler/test_mono/generated/specialize_closures.txt | 6 +++--- compiler/test_mono/generated/specialize_lowlevel.txt | 4 ++-- compiler/test_mono/generated/when_nested_maybe.txt | 6 +++--- compiler/test_mono/generated/when_on_result.txt | 2 +- compiler/test_mono/generated/when_on_two_values.txt | 8 ++++---- 26 files changed, 55 insertions(+), 55 deletions(-) diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 00618a2710..16b6047306 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -1300,7 +1300,7 @@ impl<'a> Expr<'a> { StructAtIndex { index, structure, .. } => alloc - .text(format!("Index {} ", index)) + .text(format!("StructAtIndex {} ", index)) .append(symbol_to_doc(alloc, *structure)), RuntimeErrorFunction(s) => alloc.text(format!("ErrorFunction {}", s)), @@ -1315,7 +1315,7 @@ impl<'a> Expr<'a> { index, .. } => alloc - .text(format!("CoerceToTagId (Id {}) (Index {}) ", tag_id, index)) + .text(format!("UnionAtIndex (Id {}) (Index {}) ", tag_id, index)) .append(symbol_to_doc(alloc, *structure)), } } diff --git a/compiler/test_mono/generated/closure_in_list.txt b/compiler/test_mono/generated/closure_in_list.txt index 5950b9e086..41c1e43828 100644 --- a/compiler/test_mono/generated/closure_in_list.txt +++ b/compiler/test_mono/generated/closure_in_list.txt @@ -9,7 +9,7 @@ procedure Test.1 (Test.5): ret Test.10; procedure Test.3 (Test.9, #Attr.12): - let Test.2 = Index 0 #Attr.12; + let Test.2 = StructAtIndex 0 #Attr.12; ret Test.2; procedure Test.0 (): diff --git a/compiler/test_mono/generated/has_none.txt b/compiler/test_mono/generated/has_none.txt index a119646774..cc473d1161 100644 --- a/compiler/test_mono/generated/has_none.txt +++ b/compiler/test_mono/generated/has_none.txt @@ -7,7 +7,7 @@ procedure Test.3 (Test.4): let Test.14 = false; ret Test.14; else - let Test.19 = CoerceToTagId (Id 0) (Index 1) Test.4; + let Test.19 = UnionAtIndex (Id 0) (Index 1) Test.4; let Test.20 = 1i64; let Test.21 = GetTagId Test.19; let Test.22 = lowlevel Eq Test.20 Test.21; @@ -15,7 +15,7 @@ procedure Test.3 (Test.4): let Test.15 = true; ret Test.15; else - let Test.7 = CoerceToTagId (Id 0) (Index 2) Test.4; + let Test.7 = UnionAtIndex (Id 0) (Index 2) Test.4; jump Test.13 Test.7; in jump Test.13 Test.4; diff --git a/compiler/test_mono/generated/ir_when_idiv.txt b/compiler/test_mono/generated/ir_when_idiv.txt index e55f13c051..9da6a42067 100644 --- a/compiler/test_mono/generated/ir_when_idiv.txt +++ b/compiler/test_mono/generated/ir_when_idiv.txt @@ -20,7 +20,7 @@ procedure Test.0 (): let Test.6 = GetTagId Test.2; let Test.7 = lowlevel Eq Test.5 Test.6; if Test.7 then - let Test.1 = CoerceToTagId (Id 1) (Index 1) Test.2; + let Test.1 = UnionAtIndex (Id 1) (Index 1) Test.2; ret Test.1; else let Test.4 = -1i64; diff --git a/compiler/test_mono/generated/ir_when_just.txt b/compiler/test_mono/generated/ir_when_just.txt index cd79c93654..97844c15ca 100644 --- a/compiler/test_mono/generated/ir_when_just.txt +++ b/compiler/test_mono/generated/ir_when_just.txt @@ -10,7 +10,7 @@ procedure Test.0 (): let Test.10 = GetTagId Test.1; let Test.11 = lowlevel Eq Test.9 Test.10; if Test.11 then - let Test.3 = CoerceToTagId (Id 0) (Index 1) Test.1; + let Test.3 = UnionAtIndex (Id 0) (Index 1) Test.1; let Test.5 = 1i64; let Test.4 = CallByName Num.24 Test.3 Test.5; ret Test.4; diff --git a/compiler/test_mono/generated/ir_when_maybe.txt b/compiler/test_mono/generated/ir_when_maybe.txt index d6cfd099b5..f650a08e70 100644 --- a/compiler/test_mono/generated/ir_when_maybe.txt +++ b/compiler/test_mono/generated/ir_when_maybe.txt @@ -6,7 +6,7 @@ procedure Test.0 (): let Test.7 = GetTagId Test.3; let Test.8 = lowlevel Eq Test.6 Test.7; if Test.8 then - let Test.2 = CoerceToTagId (Id 0) (Index 1) Test.3; + let Test.2 = UnionAtIndex (Id 0) (Index 1) Test.3; ret Test.2; else let Test.5 = 0i64; diff --git a/compiler/test_mono/generated/ir_when_record.txt b/compiler/test_mono/generated/ir_when_record.txt index ff3ca0f577..ed777a23d0 100644 --- a/compiler/test_mono/generated/ir_when_record.txt +++ b/compiler/test_mono/generated/ir_when_record.txt @@ -2,5 +2,5 @@ procedure Test.0 (): let Test.4 = 1i64; let Test.5 = 3.14f64; let Test.2 = Struct {Test.4, Test.5}; - let Test.1 = Index 0 Test.2; + let Test.1 = StructAtIndex 0 Test.2; ret Test.1; diff --git a/compiler/test_mono/generated/ir_when_these.txt b/compiler/test_mono/generated/ir_when_these.txt index 56d42da8ea..019ecefb3b 100644 --- a/compiler/test_mono/generated/ir_when_these.txt +++ b/compiler/test_mono/generated/ir_when_these.txt @@ -6,14 +6,14 @@ procedure Test.0 (): let Test.9 = GetTagId Test.5; switch Test.9: case 2: - let Test.2 = CoerceToTagId (Id 2) (Index 1) Test.5; + let Test.2 = UnionAtIndex (Id 2) (Index 1) Test.5; ret Test.2; case 0: - let Test.3 = CoerceToTagId (Id 0) (Index 1) Test.5; + let Test.3 = UnionAtIndex (Id 0) (Index 1) Test.5; ret Test.3; default: - let Test.4 = CoerceToTagId (Id 1) (Index 1) Test.5; + let Test.4 = UnionAtIndex (Id 1) (Index 1) Test.5; ret Test.4; diff --git a/compiler/test_mono/generated/let_with_record_pattern.txt b/compiler/test_mono/generated/let_with_record_pattern.txt index 3f9ec7dbbd..51df825ebf 100644 --- a/compiler/test_mono/generated/let_with_record_pattern.txt +++ b/compiler/test_mono/generated/let_with_record_pattern.txt @@ -2,5 +2,5 @@ procedure Test.0 (): let Test.4 = 2i64; let Test.5 = 3.14f64; let Test.3 = Struct {Test.4, Test.5}; - let Test.1 = Index 0 Test.3; + let Test.1 = StructAtIndex 0 Test.3; ret Test.1; diff --git a/compiler/test_mono/generated/let_with_record_pattern_list.txt b/compiler/test_mono/generated/let_with_record_pattern_list.txt index 1b7ae1ec45..e2ed3831d0 100644 --- a/compiler/test_mono/generated/let_with_record_pattern_list.txt +++ b/compiler/test_mono/generated/let_with_record_pattern_list.txt @@ -5,7 +5,7 @@ procedure Test.0 (): let Test.4 = Array [Test.6, Test.7, Test.8]; let Test.5 = 3.14f64; let Test.3 = Struct {Test.4, Test.5}; - let Test.1 = Index 0 Test.3; + let Test.1 = StructAtIndex 0 Test.3; inc Test.1; dec Test.3; ret Test.1; diff --git a/compiler/test_mono/generated/let_x_in_x_indirect.txt b/compiler/test_mono/generated/let_x_in_x_indirect.txt index 0d3a1b4693..4fe43f886b 100644 --- a/compiler/test_mono/generated/let_x_in_x_indirect.txt +++ b/compiler/test_mono/generated/let_x_in_x_indirect.txt @@ -4,5 +4,5 @@ procedure Test.0 (): let Test.5 = 1i64; let Test.2 = 1337i64; let Test.7 = Struct {Test.2, Test.4}; - let Test.6 = Index 0 Test.7; + let Test.6 = StructAtIndex 0 Test.7; ret Test.6; diff --git a/compiler/test_mono/generated/linked_list_length_twice.txt b/compiler/test_mono/generated/linked_list_length_twice.txt index 222fec4981..7f40cf68f5 100644 --- a/compiler/test_mono/generated/linked_list_length_twice.txt +++ b/compiler/test_mono/generated/linked_list_length_twice.txt @@ -10,7 +10,7 @@ procedure Test.3 (Test.5): let Test.13 = 0i64; ret Test.13; else - let Test.6 = CoerceToTagId (Id 0) (Index 2) Test.5; + let Test.6 = UnionAtIndex (Id 0) (Index 2) Test.5; let Test.15 = 1i64; let Test.16 = CallByName Test.3 Test.6; let Test.14 = CallByName Num.24 Test.15 Test.16; diff --git a/compiler/test_mono/generated/nested_closure.txt b/compiler/test_mono/generated/nested_closure.txt index bd29b87a8b..3d5c1411d7 100644 --- a/compiler/test_mono/generated/nested_closure.txt +++ b/compiler/test_mono/generated/nested_closure.txt @@ -4,7 +4,7 @@ procedure Test.1 (Test.5): ret Test.3; procedure Test.3 (Test.9, #Attr.12): - let Test.2 = Index 0 #Attr.12; + let Test.2 = StructAtIndex 0 #Attr.12; ret Test.2; procedure Test.0 (): diff --git a/compiler/test_mono/generated/nested_pattern_match.txt b/compiler/test_mono/generated/nested_pattern_match.txt index 28b7f52121..d5fb06ae22 100644 --- a/compiler/test_mono/generated/nested_pattern_match.txt +++ b/compiler/test_mono/generated/nested_pattern_match.txt @@ -16,13 +16,13 @@ procedure Test.0 (): let Test.16 = GetTagId Test.2; let Test.19 = lowlevel Eq Test.15 Test.16; if Test.19 then - let Test.12 = CoerceToTagId (Id 0) (Index 1) Test.2; + let Test.12 = UnionAtIndex (Id 0) (Index 1) Test.2; let Test.13 = 0i64; let Test.14 = GetTagId Test.12; let Test.18 = lowlevel Eq Test.13 Test.14; if Test.18 then - let Test.10 = CoerceToTagId (Id 0) (Index 1) Test.2; - let Test.5 = CoerceToTagId (Id 0) (Index 1) Test.10; + let Test.10 = UnionAtIndex (Id 0) (Index 1) Test.2; + let Test.5 = UnionAtIndex (Id 0) (Index 1) Test.10; let Test.7 = 1i64; let Test.6 = CallByName Num.24 Test.5 Test.7; ret Test.6; diff --git a/compiler/test_mono/generated/optional_when.txt b/compiler/test_mono/generated/optional_when.txt index 864d5dbb38..9e261687aa 100644 --- a/compiler/test_mono/generated/optional_when.txt +++ b/compiler/test_mono/generated/optional_when.txt @@ -3,14 +3,14 @@ procedure Num.26 (#Attr.2, #Attr.3): ret Test.17; procedure Test.1 (Test.6): - let Test.25 = Index 1 Test.6; + let Test.25 = StructAtIndex 1 Test.6; let Test.26 = false; let Test.27 = lowlevel Eq Test.26 Test.25; if Test.27 then - let Test.8 = Index 0 Test.6; + let Test.8 = StructAtIndex 0 Test.6; ret Test.8; else - let Test.10 = Index 0 Test.6; + let Test.10 = StructAtIndex 0 Test.6; ret Test.10; procedure Test.1 (Test.6): diff --git a/compiler/test_mono/generated/peano2.txt b/compiler/test_mono/generated/peano2.txt index eeb585f929..c8392149a6 100644 --- a/compiler/test_mono/generated/peano2.txt +++ b/compiler/test_mono/generated/peano2.txt @@ -11,7 +11,7 @@ procedure Test.0 (): let Test.16 = GetTagId Test.2; let Test.17 = lowlevel Eq Test.15 Test.16; if Test.17 then - let Test.11 = CoerceToTagId (Id 0) (Index 1) Test.2; + let Test.11 = UnionAtIndex (Id 0) (Index 1) Test.2; inc Test.11; dec Test.2; let Test.12 = 0i64; diff --git a/compiler/test_mono/generated/quicksort_help.txt b/compiler/test_mono/generated/quicksort_help.txt index 2895fd348a..6d641e8807 100644 --- a/compiler/test_mono/generated/quicksort_help.txt +++ b/compiler/test_mono/generated/quicksort_help.txt @@ -18,8 +18,8 @@ procedure Test.1 (Test.2, Test.3, Test.4): let Test.27 = Array []; let Test.26 = 0i64; let Test.25 = Struct {Test.26, Test.27}; - let Test.5 = Index 0 Test.25; - let Test.6 = Index 1 Test.25; + let Test.5 = StructAtIndex 0 Test.25; + let Test.6 = StructAtIndex 1 Test.25; let Test.22 = 1i64; let Test.21 = CallByName Num.25 Test.5 Test.22; let Test.16 = CallByName Test.1 Test.6 Test.3 Test.21; diff --git a/compiler/test_mono/generated/quicksort_swap.txt b/compiler/test_mono/generated/quicksort_swap.txt index 20db77b9dc..0fc64def67 100644 --- a/compiler/test_mono/generated/quicksort_swap.txt +++ b/compiler/test_mono/generated/quicksort_swap.txt @@ -31,20 +31,20 @@ procedure Test.1 (Test.2): let Test.19 = Array []; ret Test.19; in - let Test.23 = Index 1 Test.8; + let Test.23 = StructAtIndex 1 Test.8; let Test.24 = 1i64; let Test.25 = GetTagId Test.23; let Test.28 = lowlevel Eq Test.24 Test.25; if Test.28 then - let Test.20 = Index 0 Test.8; + let Test.20 = StructAtIndex 0 Test.8; let Test.21 = 1i64; let Test.22 = GetTagId Test.20; let Test.27 = lowlevel Eq Test.21 Test.22; if Test.27 then - let Test.18 = Index 0 Test.8; - let Test.4 = CoerceToTagId (Id 1) (Index 1) Test.18; - let Test.17 = Index 1 Test.8; - let Test.5 = CoerceToTagId (Id 1) (Index 1) Test.17; + let Test.18 = StructAtIndex 0 Test.8; + let Test.4 = UnionAtIndex (Id 1) (Index 1) Test.18; + let Test.17 = StructAtIndex 1 Test.8; + let Test.5 = UnionAtIndex (Id 1) (Index 1) Test.17; let Test.16 = 0i64; let Test.10 = CallByName List.4 Test.2 Test.16 Test.5; let Test.11 = 0i64; diff --git a/compiler/test_mono/generated/record_optional_field_function_no_use_default.txt b/compiler/test_mono/generated/record_optional_field_function_no_use_default.txt index 83f02209a0..fabb2e373b 100644 --- a/compiler/test_mono/generated/record_optional_field_function_no_use_default.txt +++ b/compiler/test_mono/generated/record_optional_field_function_no_use_default.txt @@ -3,8 +3,8 @@ procedure Num.24 (#Attr.2, #Attr.3): ret Test.8; procedure Test.1 (Test.4): - let Test.2 = Index 0 Test.4; - let Test.3 = Index 1 Test.4; + let Test.2 = StructAtIndex 0 Test.4; + let Test.3 = StructAtIndex 1 Test.4; let Test.2 = 10i64; let Test.7 = CallByName Num.24 Test.2 Test.3; ret Test.7; diff --git a/compiler/test_mono/generated/record_optional_field_let_no_use_default.txt b/compiler/test_mono/generated/record_optional_field_let_no_use_default.txt index a5ea3d8fed..964700af06 100644 --- a/compiler/test_mono/generated/record_optional_field_let_no_use_default.txt +++ b/compiler/test_mono/generated/record_optional_field_let_no_use_default.txt @@ -3,8 +3,8 @@ procedure Num.24 (#Attr.2, #Attr.3): ret Test.8; procedure Test.1 (Test.2): - let Test.3 = Index 0 Test.2; - let Test.4 = Index 1 Test.2; + let Test.3 = StructAtIndex 0 Test.2; + let Test.4 = StructAtIndex 1 Test.2; let Test.7 = CallByName Num.24 Test.3 Test.4; ret Test.7; diff --git a/compiler/test_mono/generated/rigids.txt b/compiler/test_mono/generated/rigids.txt index 12831045b4..3dde97335b 100644 --- a/compiler/test_mono/generated/rigids.txt +++ b/compiler/test_mono/generated/rigids.txt @@ -29,20 +29,20 @@ procedure Test.1 (Test.2, Test.3, Test.4): let Test.22 = Array []; ret Test.22; in - let Test.26 = Index 1 Test.13; + let Test.26 = StructAtIndex 1 Test.13; let Test.27 = 1i64; let Test.28 = GetTagId Test.26; let Test.31 = lowlevel Eq Test.27 Test.28; if Test.31 then - let Test.23 = Index 0 Test.13; + let Test.23 = StructAtIndex 0 Test.13; let Test.24 = 1i64; let Test.25 = GetTagId Test.23; let Test.30 = lowlevel Eq Test.24 Test.25; if Test.30 then - let Test.21 = Index 0 Test.13; - let Test.6 = CoerceToTagId (Id 1) (Index 1) Test.21; - let Test.20 = Index 1 Test.13; - let Test.7 = CoerceToTagId (Id 1) (Index 1) Test.20; + let Test.21 = StructAtIndex 0 Test.13; + let Test.6 = UnionAtIndex (Id 1) (Index 1) Test.21; + let Test.20 = StructAtIndex 1 Test.13; + let Test.7 = UnionAtIndex (Id 1) (Index 1) Test.20; let Test.15 = CallByName List.4 Test.4 Test.2 Test.7; let Test.14 = CallByName List.4 Test.15 Test.3 Test.6; ret Test.14; diff --git a/compiler/test_mono/generated/specialize_closures.txt b/compiler/test_mono/generated/specialize_closures.txt index 5534042fa3..b73f8dacfb 100644 --- a/compiler/test_mono/generated/specialize_closures.txt +++ b/compiler/test_mono/generated/specialize_closures.txt @@ -22,13 +22,13 @@ procedure Test.1 (Test.2, Test.3): procedure Test.7 (Test.10, #Attr.12): - let Test.4 = CoerceToTagId (Id 0) (Index 1) #Attr.12; + let Test.4 = UnionAtIndex (Id 0) (Index 1) #Attr.12; let Test.29 = CallByName Num.24 Test.10 Test.4; ret Test.29; procedure Test.8 (Test.11, #Attr.12): - let Test.6 = CoerceToTagId (Id 1) (Index 2) #Attr.12; - let Test.5 = CoerceToTagId (Id 1) (Index 1) #Attr.12; + let Test.6 = UnionAtIndex (Id 1) (Index 2) #Attr.12; + let Test.5 = UnionAtIndex (Id 1) (Index 1) #Attr.12; if Test.6 then let Test.24 = CallByName Num.26 Test.11 Test.5; ret Test.24; diff --git a/compiler/test_mono/generated/specialize_lowlevel.txt b/compiler/test_mono/generated/specialize_lowlevel.txt index cd81b26370..cea49dd66a 100644 --- a/compiler/test_mono/generated/specialize_lowlevel.txt +++ b/compiler/test_mono/generated/specialize_lowlevel.txt @@ -7,12 +7,12 @@ procedure Num.26 (#Attr.2, #Attr.3): ret Test.21; procedure Test.6 (Test.8, #Attr.12): - let Test.4 = CoerceToTagId (Id 0) (Index 1) #Attr.12; + let Test.4 = UnionAtIndex (Id 0) (Index 1) #Attr.12; let Test.25 = CallByName Num.24 Test.8 Test.4; ret Test.25; procedure Test.7 (Test.9, #Attr.12): - let Test.5 = CoerceToTagId (Id 1) (Index 1) #Attr.12; + let Test.5 = UnionAtIndex (Id 1) (Index 1) #Attr.12; let Test.20 = CallByName Num.26 Test.9 Test.5; ret Test.20; diff --git a/compiler/test_mono/generated/when_nested_maybe.txt b/compiler/test_mono/generated/when_nested_maybe.txt index 28b7f52121..d5fb06ae22 100644 --- a/compiler/test_mono/generated/when_nested_maybe.txt +++ b/compiler/test_mono/generated/when_nested_maybe.txt @@ -16,13 +16,13 @@ procedure Test.0 (): let Test.16 = GetTagId Test.2; let Test.19 = lowlevel Eq Test.15 Test.16; if Test.19 then - let Test.12 = CoerceToTagId (Id 0) (Index 1) Test.2; + let Test.12 = UnionAtIndex (Id 0) (Index 1) Test.2; let Test.13 = 0i64; let Test.14 = GetTagId Test.12; let Test.18 = lowlevel Eq Test.13 Test.14; if Test.18 then - let Test.10 = CoerceToTagId (Id 0) (Index 1) Test.2; - let Test.5 = CoerceToTagId (Id 0) (Index 1) Test.10; + let Test.10 = UnionAtIndex (Id 0) (Index 1) Test.2; + let Test.5 = UnionAtIndex (Id 0) (Index 1) Test.10; let Test.7 = 1i64; let Test.6 = CallByName Num.24 Test.5 Test.7; ret Test.6; diff --git a/compiler/test_mono/generated/when_on_result.txt b/compiler/test_mono/generated/when_on_result.txt index 635aed06cf..dd05a989d9 100644 --- a/compiler/test_mono/generated/when_on_result.txt +++ b/compiler/test_mono/generated/when_on_result.txt @@ -9,7 +9,7 @@ procedure Test.1 (Test.5): let Test.17 = GetTagId Test.2; let Test.18 = lowlevel Eq Test.16 Test.17; if Test.18 then - let Test.13 = CoerceToTagId (Id 1) (Index 1) Test.2; + let Test.13 = UnionAtIndex (Id 1) (Index 1) Test.2; let Test.14 = 3i64; let Test.15 = lowlevel Eq Test.14 Test.13; if Test.15 then diff --git a/compiler/test_mono/generated/when_on_two_values.txt b/compiler/test_mono/generated/when_on_two_values.txt index 2d58d97623..f92d0897c3 100644 --- a/compiler/test_mono/generated/when_on_two_values.txt +++ b/compiler/test_mono/generated/when_on_two_values.txt @@ -7,16 +7,16 @@ procedure Test.0 (): let Test.16 = 2i64; let Test.4 = Struct {Test.16, Test.17}; joinpoint Test.13: - let Test.2 = Index 0 Test.4; - let Test.3 = Index 1 Test.4; + let Test.2 = StructAtIndex 0 Test.4; + let Test.3 = StructAtIndex 1 Test.4; let Test.6 = CallByName Num.24 Test.2 Test.3; ret Test.6; in - let Test.11 = Index 1 Test.4; + let Test.11 = StructAtIndex 1 Test.4; let Test.12 = 3i64; let Test.15 = lowlevel Eq Test.12 Test.11; if Test.15 then - let Test.9 = Index 0 Test.4; + let Test.9 = StructAtIndex 0 Test.4; let Test.10 = 4i64; let Test.14 = lowlevel Eq Test.10 Test.9; if Test.14 then From e80f8a5114886ff51af7934b3935e79028665ea8 Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 21 Jun 2021 23:24:55 +0200 Subject: [PATCH 355/496] refactor --- compiler/mono/src/ir.rs | 4 ++- compiler/mono/src/layout.rs | 53 +++++++++---------------------------- 2 files changed, 15 insertions(+), 42 deletions(-) diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 16b6047306..6a384f61c8 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -5674,7 +5674,9 @@ fn store_tag_pattern<'a>( ) -> StorePattern<'a> { use Pattern::*; - let write_tag = union_layout.stores_tag(); + // rosetree-like structures don't store the tag ID, the others do from the perspective of the IR + // The backend can make different choices there (and will, for UnionLayout::NullableUnwrapped) + let write_tag = !matches!(union_layout, UnionLayout::NonNullableUnwrapped(_)); let mut arg_layouts = Vec::with_capacity_in(arguments.len(), env.arena); let mut is_productive = false; diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index 955680d225..9988ad6f64 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -107,32 +107,19 @@ impl<'a> UnionLayout<'a> { } pub fn layout_at(self, tag_id: u8, index: usize) -> Layout<'a> { - match self { + let result = match self { UnionLayout::NonRecursive(tag_layouts) => { let field_layouts = tag_layouts[tag_id as usize]; - field_layouts[index] + // this cannot be recursive; return immediately + return field_layouts[index]; } UnionLayout::Recursive(tag_layouts) => { let field_layouts = tag_layouts[tag_id as usize]; - let result = field_layouts[index]; - - if let Layout::RecursivePointer = result { - Layout::Union(self) - } else { - result - } - } - UnionLayout::NonNullableUnwrapped(field_layouts) => { - let result = field_layouts[index]; - - if let Layout::RecursivePointer = result { - Layout::Union(self) - } else { - result - } + field_layouts[index] } + UnionLayout::NonNullableUnwrapped(field_layouts) => field_layouts[index], UnionLayout::NullableWrapped { nullable_id, other_tags, @@ -146,13 +133,7 @@ impl<'a> UnionLayout<'a> { }; let field_layouts = other_tags[tag_index as usize]; - let result = field_layouts[index]; - - if let Layout::RecursivePointer = result { - Layout::Union(self) - } else { - result - } + field_layouts[index] } UnionLayout::NullableUnwrapped { @@ -161,24 +142,14 @@ impl<'a> UnionLayout<'a> { } => { debug_assert_ne!(nullable_id, tag_id != 0); - let result = other_fields[index as usize]; - - if let Layout::RecursivePointer = result { - Layout::Union(self) - } else { - result - } + other_fields[index as usize] } - } - } + }; - pub fn stores_tag(&self) -> bool { - match self { - UnionLayout::NonRecursive(_) => true, - UnionLayout::Recursive(_) => true, - UnionLayout::NonNullableUnwrapped(_) => false, - UnionLayout::NullableWrapped { .. } => true, - UnionLayout::NullableUnwrapped { .. } => true, + if let Layout::RecursivePointer = result { + Layout::Union(self) + } else { + result } } } From c4f9812ad8dd92fd883fb83396e9c92815a0cc7d Mon Sep 17 00:00:00 2001 From: rvcas Date: Mon, 21 Jun 2021 17:26:55 -0400 Subject: [PATCH 356/496] test: split into two --- editor/tests/solve_expr2.rs | 20 +++++++++++++++++--- 1 file changed, 17 insertions(+), 3 deletions(-) diff --git a/editor/tests/solve_expr2.rs b/editor/tests/solve_expr2.rs index 465bb6511b..f2bcf0bdd9 100644 --- a/editor/tests/solve_expr2.rs +++ b/editor/tests/solve_expr2.rs @@ -301,16 +301,30 @@ fn constrain_when() { ) } +#[test] +fn constrain_let_value() { + infer_eq( + indoc!( + r#" + person = { name: "roc" } + + person + "# + ), + "{ name : Str }", + ) +} + #[test] fn constrain_update() { infer_eq( indoc!( r#" - thing = { name: "roc" } + person = { name: "roc" } - { thing & name: "bird" } + { person & name: "bird" } "# ), - "{ name : Str }*", + "{ name : Str }", ) } From 6890193917f1f641d75da40fba9ead175b781f98 Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 21 Jun 2021 23:28:38 +0200 Subject: [PATCH 357/496] fix comment --- compiler/gen_llvm/src/llvm/build.rs | 19 ++++++++----------- 1 file changed, 8 insertions(+), 11 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index c4a3ff8ab7..0b102b723f 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -1423,14 +1423,8 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( Reuse { .. } => todo!(), StructAtIndex { - index, - structure, - field_layouts, + index, structure, .. } => { - // if you hit this: we unwrap 1-element records, so instead of `x = StructAtIndex 0 y` - // you should substitute `x` with `y` in the remainder of the statement - debug_assert!(field_layouts.len() > 1, "one-element records are unwrapped"); - // extract field from a record match load_symbol_and_layout(scope, structure) { (StructValue(argument), Layout::Struct(fields)) => { @@ -1479,10 +1473,13 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( env.builder.build_load(ptr, "load_rosetree_like") } - (other, layout) => unreachable!( - "can only index into struct layout\nValue: {:?}\nLayout: {:?}\nIndex: {:?}", - other, layout, index - ), + (other, layout) => { + // potential cause: indexing into an unwrapped 1-element record/tag? + unreachable!( + "can only index into struct layout\nValue: {:?}\nLayout: {:?}\nIndex: {:?}", + other, layout, index + ) + } } } From 89996c4b43eb767544a712c0b1e618261a3315cc Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Mon, 21 Jun 2021 08:36:33 -0400 Subject: [PATCH 358/496] Drop obsolete comment --- compiler/builtins/bitcode/src/str.zig | 2 -- 1 file changed, 2 deletions(-) diff --git a/compiler/builtins/bitcode/src/str.zig b/compiler/builtins/bitcode/src/str.zig index 2a81b69fc6..d5b9381c27 100644 --- a/compiler/builtins/bitcode/src/str.zig +++ b/compiler/builtins/bitcode/src/str.zig @@ -240,8 +240,6 @@ pub const RocStr = extern struct { } pub fn asSlice(self: RocStr) []u8 { - // Since this conditional would be prone to branch misprediction, - // make sure it will compile to a cmov. return self.asU8ptr()[0..self.len()]; } From 6b8c39c8cb4c19c93b46985bd9d2027ee71e73bd Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Mon, 21 Jun 2021 08:36:50 -0400 Subject: [PATCH 359/496] Don't hardcode 16 bytes in str.zig --- compiler/builtins/bitcode/src/str.zig | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/compiler/builtins/bitcode/src/str.zig b/compiler/builtins/bitcode/src/str.zig index d5b9381c27..761bc54d70 100644 --- a/compiler/builtins/bitcode/src/str.zig +++ b/compiler/builtins/bitcode/src/str.zig @@ -17,7 +17,7 @@ const InPlace = packed enum(u8) { const SMALL_STR_MAX_LENGTH = small_string_size - 1; const small_string_size = 2 * @sizeOf(usize); -const blank_small_string: [16]u8 = init_blank_small_string(small_string_size); +const blank_small_string: [@sizeOf(RocStr)]u8 = init_blank_small_string(small_string_size); fn init_blank_small_string(comptime n: usize) [n]u8 { var prime_list: [n]u8 = undefined; @@ -246,7 +246,7 @@ pub const RocStr = extern struct { pub fn asU8ptr(self: RocStr) [*]u8 { // Since this conditional would be prone to branch misprediction, // make sure it will compile to a cmov. - return if (self.isSmallStr() or self.isEmpty()) (&@bitCast([16]u8, self)) else (@ptrCast([*]u8, self.str_bytes)); + return if (self.isSmallStr() or self.isEmpty()) (&@bitCast([@sizeOf(RocStr)]u8, self)) else (@ptrCast([*]u8, self.str_bytes)); } // Given a pointer to some bytes, write the first (len) bytes of this From bdc04569967a54a718db92ffa2a3f8cfb21629c5 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Mon, 21 Jun 2021 08:37:43 -0400 Subject: [PATCH 360/496] Drop unused function which failed on small strings --- compiler/builtins/bitcode/src/str.zig | 6 ------ 1 file changed, 6 deletions(-) diff --git a/compiler/builtins/bitcode/src/str.zig b/compiler/builtins/bitcode/src/str.zig index 761bc54d70..7302d524b8 100644 --- a/compiler/builtins/bitcode/src/str.zig +++ b/compiler/builtins/bitcode/src/str.zig @@ -85,12 +85,6 @@ pub const RocStr = extern struct { } } - pub fn toSlice(self: RocStr) []u8 { - const str_bytes_ptr: [*]u8 = self.str_bytes orelse unreachable; - const str_bytes: []u8 = str_bytes_ptr[0..self.str_len]; - return str_bytes; - } - // This takes ownership of the pointed-to bytes if they won't fit in a // small string, and returns a (pointer, len) tuple which points to them. pub fn withCapacity(length: usize) RocStr { From 66bdb210edc82205fd8fd919083e306e82b533bc Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Mon, 21 Jun 2021 08:38:32 -0400 Subject: [PATCH 361/496] Have Hello World write to a fd This is a much nicer host to read than the one that does all the gymnastics to convert to a null-terminated string just to call printf! --- examples/hello-fast/.gitignore | 1 - examples/hello-fast/Hello.roc | 6 -- examples/hello-fast/README.md | 48 ----------- .../hello-fast/platform/Package-Config.roc | 10 --- examples/hello-fast/platform/host.c | 44 ---------- examples/hello-world/Hello.roc | 8 +- examples/hello-world/platform/host.c | 85 ++++++++++--------- 7 files changed, 47 insertions(+), 155 deletions(-) delete mode 100644 examples/hello-fast/.gitignore delete mode 100644 examples/hello-fast/Hello.roc delete mode 100644 examples/hello-fast/README.md delete mode 100644 examples/hello-fast/platform/Package-Config.roc delete mode 100644 examples/hello-fast/platform/host.c diff --git a/examples/hello-fast/.gitignore b/examples/hello-fast/.gitignore deleted file mode 100644 index 6b820fd903..0000000000 --- a/examples/hello-fast/.gitignore +++ /dev/null @@ -1 +0,0 @@ -hello-world diff --git a/examples/hello-fast/Hello.roc b/examples/hello-fast/Hello.roc deleted file mode 100644 index 1fe1406ce5..0000000000 --- a/examples/hello-fast/Hello.roc +++ /dev/null @@ -1,6 +0,0 @@ -app "hello-world" - packages { base: "platform" } - imports [] - provides [ main ] to base - -main = "Hello, World!\n" diff --git a/examples/hello-fast/README.md b/examples/hello-fast/README.md deleted file mode 100644 index a2890f03ed..0000000000 --- a/examples/hello-fast/README.md +++ /dev/null @@ -1,48 +0,0 @@ -# Hello, World! - -To run, `cd` into this directory and run: - -```bash -$ cargo run run Hello.roc -``` - -To run in release mode instead, do: - -```bash -$ cargo run --release run Hello.roc -``` - -## Troubleshooting - -If you encounter `cannot find -lc++`, run the following for ubuntu `sudo apt install libc++-dev`. - -## Design Notes - -This demonstrates the basic design of hosts: Roc code gets compiled into a pure -function (in this case, a thunk that always returns `"Hello, World!"`) and -then the host calls that function. Fundamentally, that's the whole idea! The host -might not even have a `main` - it could be a library, a plugin, anything. -Everything else is built on this basic "hosts calling linked pure functions" design. - -For example, things get more interesting when the compiled Roc function returns -a `Task` - that is, a tagged union data structure containing function pointers -to callback closures. This lets the Roc pure function describe arbitrary -chainable effects, which the host can interpret to perform I/O as requested by -the Roc program. (The tagged union `Task` would have a variant for each supported -I/O operation.) - -In this trivial example, it's very easy to line up the API between the host and -the Roc program. In a more involved host, this would be much trickier - especially -if the API were changing frequently during development. - -The idea there is to have a first-class concept of "glue code" which host authors -can write (it would be plain Roc code, but with some extra keywords that aren't -available in normal modules - kinda like `port module` in Elm), and which -describe both the Roc-host/C boundary as well as the Roc-host/Roc-app boundary. -Roc application authors only care about the Roc-host/Roc-app portion, and the -host author only cares about the Roc-host/C bounary when implementing the host. - -Using this glue code, the Roc compiler can generate C header files describing the -boundary. This not only gets us host compatibility with C compilers, but also -Rust FFI for free, because [`rust-bindgen`](https://github.com/rust-lang/rust-bindgen) -generates correct Rust FFI bindings from C headers. diff --git a/examples/hello-fast/platform/Package-Config.roc b/examples/hello-fast/platform/Package-Config.roc deleted file mode 100644 index 377d5c0994..0000000000 --- a/examples/hello-fast/platform/Package-Config.roc +++ /dev/null @@ -1,10 +0,0 @@ -platform examples/hello-world - requires {}{ main : Str } - exposes [] - packages {} - imports [] - provides [ mainForHost ] - effects fx.Effect {} - -mainForHost : Str -mainForHost = main diff --git a/examples/hello-fast/platform/host.c b/examples/hello-fast/platform/host.c deleted file mode 100644 index e21057df86..0000000000 --- a/examples/hello-fast/platform/host.c +++ /dev/null @@ -1,44 +0,0 @@ -#include -#include -#include -#include -#include - -void* roc_alloc(size_t size, unsigned int alignment) { - return malloc(size); -} - -void* roc_realloc(void* ptr, size_t old_size, size_t new_size, unsigned int alignment) { - return realloc(ptr, new_size); -} - -void roc_dealloc(void* ptr, unsigned int alignment) { - free(ptr); -} - -struct RocStr { - char* bytes; - size_t len; -}; - -struct RocCallResult { - size_t flag; - struct RocStr content; -}; - -extern void roc__mainForHost_1_exposed(struct RocCallResult *re); - -int main() { - // Make space for the result - struct RocCallResult callresult; - - // Call roc to populate the callresult - roc__mainForHost_1_exposed(&callresult); - - struct RocStr str = callresult.content; - - // Write to stdout - write(1, &str.bytes, 14); - - return 0; -} diff --git a/examples/hello-world/Hello.roc b/examples/hello-world/Hello.roc index 24a02e7823..1fe1406ce5 100644 --- a/examples/hello-world/Hello.roc +++ b/examples/hello-world/Hello.roc @@ -3,10 +3,4 @@ app "hello-world" imports [] provides [ main ] to base -greeting = - hi = "Hello" - name = "World" - - "\(hi), \(name)!!!!!!!!!!!!!" - -main = greeting +main = "Hello, World!\n" diff --git a/examples/hello-world/platform/host.c b/examples/hello-world/platform/host.c index 076f6ca1a4..65661e64aa 100644 --- a/examples/hello-world/platform/host.c +++ b/examples/hello-world/platform/host.c @@ -1,7 +1,9 @@ -#include #include +#include +#include +#include #include -#include +#include void* roc_alloc(size_t size, unsigned int alignment) { return malloc(size); @@ -20,6 +22,29 @@ struct RocStr { size_t len; }; +bool is_small_str(struct RocStr str) { + return ((ssize_t)str.len) < 0; +} + +// Determine the length of the string, taking into +// account the small string optimization +size_t roc_str_len(struct RocStr str) { + char* bytes = (char*)&str; + char last_byte = bytes[sizeof(str) - 1]; + char last_byte_xored = last_byte ^ 0b10000000; + size_t small_len = (size_t)(last_byte_xored); + size_t big_len = str.len; + + // Avoid branch misprediction costs by always + // determining both small_len and big_len, + // so this compiles to a cmov instruction. + if (is_small_str(str)) { + return small_len; + } else { + return big_len; + } +} + struct RocCallResult { size_t flag; struct RocStr content; @@ -27,50 +52,32 @@ struct RocCallResult { extern void roc__mainForHost_1_exposed(struct RocCallResult *re); -const size_t MAX_STACK_STR_BYTES = 1024; - int main() { - // make space for the result - struct RocCallResult callresult; + // Make space for the Roc call result + struct RocCallResult call_result; - // call roc to populate the callresult - roc__mainForHost_1_exposed(&callresult); - struct RocStr str = callresult.content; + // Call Roc to populate call_result + roc__mainForHost_1_exposed(&call_result); - // Convert from RocStr to C string (null-terminated char*) - size_t len = str.len; - char* c_str; + // Determine str_len and the str_bytes pointer, + // taking into account the small string optimization. + struct RocStr str = call_result.content; + size_t str_len = roc_str_len(str); + char* str_bytes; - // Allocate on the stack unless the string is particularly big. - // (Don't want a stack overflow!) - if (len <= MAX_STACK_STR_BYTES) { - c_str = (char*)alloca(len + 1); + if (is_small_str(str)) { + str_bytes = (char*)&str; } else { - c_str = (char*)malloc(len + 1); + str_bytes = str.bytes; } - memcpy(c_str, str.bytes, len); + // Write to stdout + if (write(1, str_bytes, str_len) >= 0) { + // Writing succeeded! + return 0; + } else { + printf("Error writing to stdout: %s\n", strerror(errno)); - // null-terminate - c_str[len] = 0; - - // Print the string to stdout - printf("%s\n", c_str); - - // Pointer to the beginning of the RocStr's actual allocation, which is - // the size_t immediately preceding the first stored byte. - size_t* str_base_ptr = (size_t*)str.bytes - 1; - - // If *str_base_ptr is equal to 0, then the string is in the - // read-only data section of the binary, and can't be freed! - if (*str_base_ptr != 0) { - roc_dealloc(str_base_ptr, 8); + return 1; } - - // If we malloc'd c_str, free it. - if (len > MAX_STACK_STR_BYTES) { - free(c_str); - } - - return 0; } From d11f42743cdd4e3fd690b7f09c1fea706f961861 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Mon, 21 Jun 2021 19:03:55 -0400 Subject: [PATCH 362/496] Update a comment --- compiler/builtins/bitcode/src/str.zig | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/builtins/bitcode/src/str.zig b/compiler/builtins/bitcode/src/str.zig index 7302d524b8..036a874598 100644 --- a/compiler/builtins/bitcode/src/str.zig +++ b/compiler/builtins/bitcode/src/str.zig @@ -197,8 +197,8 @@ pub const RocStr = extern struct { return result; } + // NOTE: returns false for empty string! pub fn isSmallStr(self: RocStr) bool { - // NOTE: returns False for empty string! return @bitCast(isize, self.str_len) < 0; } From ebf7e6e3b9b64518b358100e53bb45c5d652cb44 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Mon, 21 Jun 2021 19:05:03 -0400 Subject: [PATCH 363/496] Add RocStr.capacity and isNullTerminated --- compiler/builtins/bitcode/src/str.zig | 76 +++++++++++++++++++++++++++ 1 file changed, 76 insertions(+) diff --git a/compiler/builtins/bitcode/src/str.zig b/compiler/builtins/bitcode/src/str.zig index 036a874598..a52f4dd33b 100644 --- a/compiler/builtins/bitcode/src/str.zig +++ b/compiler/builtins/bitcode/src/str.zig @@ -217,6 +217,82 @@ pub const RocStr = extern struct { return self.len() == 0; } + // If a string happens to be null-terminated already, then we can pass its + // bytes directly to functions (e.g. for opening files) that require + // null-terminated strings. Otherwise, we need to allocate and copy a new + // null-terminated string, which has a much higher performance cost! + fn isNullTerminated(self: RocStr) bool { + const len = self.len(); + const longest_small_str = @sizeOf(RocStr) - 1; + + // NOTE: We want to compare length here, *NOT* check for is_small_str! + // This is because we explicitly want the empty string to be handled in + // this branch, even though the empty string is not a small string. + // + // (The other branch dereferences the bytes pointer, which is not safe + // to do for the empty string.) + if (len <= longest_small_str) { + // If we're a small string, then usually the next byte after the + // end of the string will be zero. (Small strings set all their + // unused bytes to 0, so that comparison for equality can be fast.) + // + // However, empty strings are *not* null terminated, so if this is + // empty, it should return false. + // + // Also, if we are exactly a maximum-length small string, + // then the next byte is off the end of the struct; + // in that case, we are also not null-terminated! + return len != 0 and len != longest_small_str; + } else { + // This is a big string, and it's not empty, so we can safely + // dereference the pointer. + const ptr: [*]usize = @ptrCast([*]usize, @alignCast(8, self.str_bytes)); + const capacity_or_refcount: isize = (ptr - 1)[0]; + + // If capacity_or_refcount is positive, then it's a capacity value. + // + // If we have excess capacity, then we can safely read the next + // byte after the end of the string. Maybe it happens to be zero! + if (capacity_or_refcount > @intCast(isize, len)) { + return self.str_bytes[len] == 0; + } else { + // This string was refcounted or immortal; we can't safely read + // the next byte, so assume the string is not null-terminated. + return false; + } + } + } + + // Returns (@sizeOf(RocStr) - 1) for small strings and the empty string. + // Returns 0 for refcounted stirngs and immortal strings. + // Returns the stored capacity value for all other strings. + pub fn capacity(self: RocStr) usize { + const len = self.len(); + const longest_small_str = @sizeOf(RocStr) - 1; + + if (len <= longest_small_str) { + // Note that although empty strings technically have the full + // capacity of a small string available, they aren't marked as small + // strings, so if you want to make use of that capacity, you need + // to first change its flag to mark it as a small string! + return longest_small_str; + } else { + const ptr: [*]usize = @ptrCast([*]usize, @alignCast(8, self.str_bytes)); + const capacity_or_refcount: isize = (ptr - 1)[0]; + + if (capacity_or_refcount > 0) { + // If capacity_or_refcount is positive, that means it's a + // capacity value. + return capacity_or_refcount; + } else { + // This is either a refcount or else this big string is stored + // in a readonly section; either way, it has no capacity, + // because we cannot mutate it in-place! + return 0; + } + } + } + pub fn isUnique(self: RocStr) bool { // the empty list is unique (in the sense that copying it will not leak memory) if (self.isEmpty()) { From d401133edcceaaed31393ee46a1824270f66d6f2 Mon Sep 17 00:00:00 2001 From: Jared Ramirez Date: Mon, 21 Jun 2021 17:02:54 -0700 Subject: [PATCH 364/496] Remove Dec docs --- compiler/builtins/docs/Dec.roc | 23 ----------------------- 1 file changed, 23 deletions(-) delete mode 100644 compiler/builtins/docs/Dec.roc diff --git a/compiler/builtins/docs/Dec.roc b/compiler/builtins/docs/Dec.roc deleted file mode 100644 index 80ae68d8a3..0000000000 --- a/compiler/builtins/docs/Dec.roc +++ /dev/null @@ -1,23 +0,0 @@ -interface Dec - exposes [ add, sub, mul, div, toStr, fromStr ] - imports [ Str ] - -## Add two Dec together -add : Dec -> Dec -> Dec - -## Subtract the second Dec from the first -sub : Dec -> Dec -> Dec - -## Multiply two Dec together -mul : Dec -> Dec -> Dec - -## Divide the first Dec by the second Dec -div : Dec -> Dec -> Dec - -## Convert a Dec to a Str -## If the Dec is less than 0, this will prefix the Str with `0.` -## If the Dec has no parts after the decimal point, this will suffix the Str with `.0` -toStr : Dec -> Str - -## Convert Str to a Decimal -fromStr : Str -> Result Dec [ InvalidDec ]* From 841895dff044641804d9a7576d7193270ef36418 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Mon, 21 Jun 2021 22:49:30 -0400 Subject: [PATCH 365/496] Fix tests --- cli/tests/cli_run.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/cli/tests/cli_run.rs b/cli/tests/cli_run.rs index 1d139a9eae..19c50a08f8 100644 --- a/cli/tests/cli_run.rs +++ b/cli/tests/cli_run.rs @@ -121,7 +121,7 @@ mod cli_run { &example_file("hello-world", "Hello.roc"), "hello-world", &[], - "Hello, World!!!!!!!!!!!!!\n", + "Hello, World!\n", true, ); } @@ -133,7 +133,7 @@ mod cli_run { &example_file("hello-world", "Hello.roc"), "hello-world", &[], - "Hello, World!!!!!!!!!!!!!\n", + "Hello, World!\n", true, ); } From 059cac3b98633b6e69d55c4bcf4123db35a63cc6 Mon Sep 17 00:00:00 2001 From: Folkert Date: Tue, 22 Jun 2021 20:34:59 +0200 Subject: [PATCH 366/496] remove ListSetInPlace --- compiler/gen_llvm/src/llvm/build.rs | 21 --------------------- compiler/module/src/low_level.rs | 2 -- compiler/mono/src/borrow.rs | 1 - 3 files changed, 24 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 0b102b723f..ebed84e80d 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -4648,27 +4648,6 @@ fn run_low_level<'a, 'ctx, 'env>( wrapper_struct, ) } - ListSetInPlace => { - let (list, list_layout) = load_symbol_and_layout(scope, &args[0]); - let (index, _) = load_symbol_and_layout(scope, &args[1]); - let (element, _) = load_symbol_and_layout(scope, &args[2]); - - match list_layout { - Layout::Builtin(Builtin::EmptyList) => { - // no elements, so nothing to remove - empty_list(env) - } - Layout::Builtin(Builtin::List(element_layout)) => list_set( - env, - layout_ids, - list, - index.into_int_value(), - element, - element_layout, - ), - _ => unreachable!("invalid dict layout"), - } - } ListSet => { let (list, list_layout) = load_symbol_and_layout(scope, &args[0]); let (index, _) = load_symbol_and_layout(scope, &args[1]); diff --git a/compiler/module/src/low_level.rs b/compiler/module/src/low_level.rs index d20c57a420..98a1f48cf8 100644 --- a/compiler/module/src/low_level.rs +++ b/compiler/module/src/low_level.rs @@ -18,7 +18,6 @@ pub enum LowLevel { ListLen, ListGetUnsafe, ListSet, - ListSetInPlace, ListSingle, ListRepeat, ListReverse, @@ -125,7 +124,6 @@ impl LowLevel { | ListLen | ListGetUnsafe | ListSet - | ListSetInPlace | ListDrop | ListSingle | ListRepeat diff --git a/compiler/mono/src/borrow.rs b/compiler/mono/src/borrow.rs index 9df746da8f..d63f4dad5e 100644 --- a/compiler/mono/src/borrow.rs +++ b/compiler/mono/src/borrow.rs @@ -760,7 +760,6 @@ pub fn lowlevel_borrow_signature(arena: &Bump, op: LowLevel) -> &[bool] { match op { ListLen | StrIsEmpty | StrCountGraphemes => arena.alloc_slice_copy(&[borrowed]), ListSet => arena.alloc_slice_copy(&[owned, irrelevant, irrelevant]), - ListSetInPlace => arena.alloc_slice_copy(&[owned, irrelevant, irrelevant]), ListGetUnsafe => arena.alloc_slice_copy(&[borrowed, irrelevant]), ListConcat => arena.alloc_slice_copy(&[owned, owned]), StrConcat => arena.alloc_slice_copy(&[owned, borrowed]), From 27308e98b77a67b0b9567fe2574325781d5e6c7d Mon Sep 17 00:00:00 2001 From: Folkert Date: Tue, 22 Jun 2021 20:53:55 +0200 Subject: [PATCH 367/496] use morphic update mode --- compiler/builtins/bitcode/src/list.zig | 59 +++++++++++++++++------- compiler/builtins/bitcode/src/main.zig | 1 + compiler/builtins/src/bitcode.rs | 1 + compiler/gen_llvm/src/llvm/build.rs | 23 +++++++-- compiler/gen_llvm/src/llvm/build_list.rs | 9 +++- 5 files changed, 73 insertions(+), 20 deletions(-) diff --git a/compiler/builtins/bitcode/src/list.zig b/compiler/builtins/bitcode/src/list.zig index b4b8a17217..19518dba60 100644 --- a/compiler/builtins/bitcode/src/list.zig +++ b/compiler/builtins/bitcode/src/list.zig @@ -1009,7 +1009,25 @@ pub fn listConcat(list_a: RocList, list_b: RocList, alignment: u32, element_widt return output; } -// input: RocList, +pub fn listSetInPlace( + bytes: ?[*]u8, + length: usize, + alignment: u32, + index: usize, + element: Opaque, + element_width: usize, + dec: Dec, +) callconv(.C) ?[*]u8 { + // INVARIANT: bounds checking happens on the roc side + // + // at the time of writing, the function is implemented roughly as + // `if inBounds then LowLevelListGet input index item else input` + // so we don't do a bounds check here. Hence, the list is also non-empty, + // because inserting into an empty list is always out of bounds + + return listSetInPlaceHelp(bytes, length, alignment, index, element, element_width, dec); +} + pub fn listSet( bytes: ?[*]u8, length: usize, @@ -1028,23 +1046,34 @@ pub fn listSet( const ptr: [*]usize = @ptrCast([*]usize, @alignCast(8, bytes)); if ((ptr - 1)[0] == utils.REFCOUNT_ONE) { - - // the element we will replace - var element_at_index = (bytes orelse undefined) + (index * element_width); - - // decrement its refcount - dec(element_at_index); - - // copy in the new element - @memcpy(element_at_index, element orelse undefined, element_width); - - return bytes; + return listSetInPlaceHelp(bytes, length, alignment, index, element, element_width, dec); } else { - return listSetClone(bytes, length, alignment, index, element, element_width, dec); + return listSetImmutable(bytes, length, alignment, index, element, element_width, dec); } } -inline fn listSetClone( +inline fn listSetInPlaceHelp( + bytes: ?[*]u8, + length: usize, + alignment: u32, + index: usize, + element: Opaque, + element_width: usize, + dec: Dec, +) ?[*]u8 { + // the element we will replace + var element_at_index = (bytes orelse undefined) + (index * element_width); + + // decrement its refcount + dec(element_at_index); + + // copy in the new element + @memcpy(element_at_index, element orelse undefined, element_width); + + return bytes; +} + +inline fn listSetImmutable( old_bytes: ?[*]u8, length: usize, alignment: u32, @@ -1053,8 +1082,6 @@ inline fn listSetClone( element_width: usize, dec: Dec, ) ?[*]u8 { - @setCold(true); - const data_bytes = length * element_width; var new_bytes = utils.allocateWithRefcount(data_bytes, alignment); diff --git a/compiler/builtins/bitcode/src/main.zig b/compiler/builtins/bitcode/src/main.zig index f1af557759..71e0ff8df8 100644 --- a/compiler/builtins/bitcode/src/main.zig +++ b/compiler/builtins/bitcode/src/main.zig @@ -30,6 +30,7 @@ comptime { exportListFn(list.listConcat, "concat"); exportListFn(list.listDrop, "drop"); exportListFn(list.listSet, "set"); + exportListFn(list.listSetInPlace, "set_in_place"); exportListFn(list.listSwap, "swap"); } diff --git a/compiler/builtins/src/bitcode.rs b/compiler/builtins/src/bitcode.rs index 3e5d71ebe6..4ac7d0f0f3 100644 --- a/compiler/builtins/src/bitcode.rs +++ b/compiler/builtins/src/bitcode.rs @@ -65,3 +65,4 @@ pub const LIST_REVERSE: &str = "roc_builtins.list.reverse"; pub const LIST_SORT_WITH: &str = "roc_builtins.list.sort_with"; pub const LIST_CONCAT: &str = "roc_builtins.list.concat"; pub const LIST_SET: &str = "roc_builtins.list.set"; +pub const LIST_SET_IN_PLACE: &str = "roc_builtins.list.set_in_place"; diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index ebed84e80d..525945701c 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -42,7 +42,9 @@ use inkwell::values::{ }; use inkwell::OptimizationLevel; use inkwell::{AddressSpace, IntPredicate}; -use morphic_lib::{CalleeSpecVar, FuncName, FuncSpec, FuncSpecSolutions, ModSolutions}; +use morphic_lib::{ + CalleeSpecVar, FuncName, FuncSpec, FuncSpecSolutions, ModSolutions, UpdateMode, UpdateModeVar, +}; use roc_builtins::bitcode; use roc_collections::all::{ImMap, MutMap, MutSet}; use roc_module::ident::TagName; @@ -826,8 +828,21 @@ pub fn build_exp_call<'a, 'ctx, 'env>( ) } - CallType::LowLevel { op, update_mode: _ } => { - run_low_level(env, layout_ids, scope, parent, layout, *op, arguments) + CallType::LowLevel { op, update_mode } => { + let bytes = update_mode.to_bytes(); + let update_var = UpdateModeVar(&bytes); + let update_mode = func_spec_solutions.update_mode(update_var).unwrap(); + + run_low_level( + env, + layout_ids, + scope, + parent, + layout, + *op, + arguments, + update_mode, + ) } CallType::HigherOrderLowLevel { @@ -4190,6 +4205,7 @@ fn run_low_level<'a, 'ctx, 'env>( layout: &Layout<'a>, op: LowLevel, args: &[Symbol], + update_mode: UpdateMode, ) -> BasicValueEnum<'ctx> { use LowLevel::*; @@ -4665,6 +4681,7 @@ fn run_low_level<'a, 'ctx, 'env>( index.into_int_value(), element, element_layout, + update_mode, ), _ => unreachable!("invalid dict layout"), } diff --git a/compiler/gen_llvm/src/llvm/build_list.rs b/compiler/gen_llvm/src/llvm/build_list.rs index f62442df02..efc3b768c4 100644 --- a/compiler/gen_llvm/src/llvm/build_list.rs +++ b/compiler/gen_llvm/src/llvm/build_list.rs @@ -13,6 +13,7 @@ use inkwell::context::Context; use inkwell::types::{BasicType, BasicTypeEnum, PointerType}; use inkwell::values::{BasicValueEnum, FunctionValue, IntValue, PointerValue, StructValue}; use inkwell::{AddressSpace, IntPredicate}; +use morphic_lib::UpdateMode; use roc_builtins::bitcode; use roc_mono::layout::{Builtin, Layout, LayoutIds}; @@ -350,6 +351,7 @@ pub fn list_set<'a, 'ctx, 'env>( index: IntValue<'ctx>, element: BasicValueEnum<'ctx>, element_layout: &'a Layout<'a>, + update_mode: UpdateMode, ) -> BasicValueEnum<'ctx> { let dec_element_fn = build_dec_wrapper(env, layout_ids, element_layout); @@ -359,6 +361,11 @@ pub fn list_set<'a, 'ctx, 'env>( env.context.i8_type().ptr_type(AddressSpace::Generic), ); + let symbol = match update_mode { + UpdateMode::InPlace => bitcode::LIST_SET_IN_PLACE, + UpdateMode::Immutable => bitcode::LIST_SET, + }; + let new_bytes = call_bitcode_fn( env, &[ @@ -370,7 +377,7 @@ pub fn list_set<'a, 'ctx, 'env>( layout_width(env, element_layout), dec_element_fn.as_global_value().as_pointer_value().into(), ], - &bitcode::LIST_SET, + &symbol, ); store_list(env, new_bytes.into_pointer_value(), length) From c7ed7d453f4259896f7b4826a1277b00764f279f Mon Sep 17 00:00:00 2001 From: Folkert Date: Tue, 22 Jun 2021 21:42:04 +0200 Subject: [PATCH 368/496] only use update_mode when defined --- compiler/gen_llvm/src/llvm/build.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 525945701c..456215a832 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -831,7 +831,7 @@ pub fn build_exp_call<'a, 'ctx, 'env>( CallType::LowLevel { op, update_mode } => { let bytes = update_mode.to_bytes(); let update_var = UpdateModeVar(&bytes); - let update_mode = func_spec_solutions.update_mode(update_var).unwrap(); + let update_mode = func_spec_solutions.update_mode(update_var).ok(); run_low_level( env, @@ -4205,7 +4205,7 @@ fn run_low_level<'a, 'ctx, 'env>( layout: &Layout<'a>, op: LowLevel, args: &[Symbol], - update_mode: UpdateMode, + update_mode: Option, ) -> BasicValueEnum<'ctx> { use LowLevel::*; @@ -4681,7 +4681,7 @@ fn run_low_level<'a, 'ctx, 'env>( index.into_int_value(), element, element_layout, - update_mode, + update_mode.unwrap(), ), _ => unreachable!("invalid dict layout"), } From d2fe546803d5818f27ba71442dc6a3ebe7660059 Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 23 Jun 2021 14:05:07 +0200 Subject: [PATCH 369/496] remove unused branch --- compiler/gen_llvm/src/llvm/build.rs | 51 ----------------------------- 1 file changed, 51 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 456215a832..3ec7749504 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -950,57 +950,6 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( BasicValueEnum::StructValue(struct_val.into_struct_value()) } - Tag { - union_size, - arguments, - tag_layout, - .. - } if *union_size == 1 && matches!(tag_layout, UnionLayout::NonRecursive(_)) => { - let it = arguments.iter(); - - let ctx = env.context; - let builder = env.builder; - - // Determine types - let num_fields = arguments.len() + 1; - let mut field_types = Vec::with_capacity_in(num_fields, env.arena); - let mut field_vals = Vec::with_capacity_in(num_fields, env.arena); - - for field_symbol in it { - let (val, field_layout) = load_symbol_and_layout(scope, field_symbol); - if !field_layout.is_dropped_because_empty() { - let field_type = basic_type_from_layout(env, &field_layout); - - field_types.push(field_type); - field_vals.push(val); - } - } - - // If the struct has only one field that isn't zero-sized, - // unwrap it. This is what the layout expects us to do. - if field_vals.len() == 1 { - field_vals.pop().unwrap() - } else { - // Create the struct_type - let struct_type = ctx.struct_type(field_types.into_bump_slice(), false); - let mut struct_val = struct_type.const_zero().into(); - - // Insert field exprs into struct_val - for (index, field_val) in field_vals.into_iter().enumerate() { - struct_val = builder - .build_insert_value( - struct_val, - field_val, - index as u32, - "insert_single_tag_field", - ) - .unwrap(); - } - - BasicValueEnum::StructValue(struct_val.into_struct_value()) - } - } - Tag { arguments, tag_layout: UnionLayout::NonRecursive(fields), From 5ed33da026b06f9ac8ff4aca2586f8044c43ed59 Mon Sep 17 00:00:00 2001 From: Folkert Date: Wed, 23 Jun 2021 14:05:23 +0200 Subject: [PATCH 370/496] add instname flag to debugir --- compiler/build/src/program.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/build/src/program.rs b/compiler/build/src/program.rs index bf634b1b04..fb69a0250d 100644 --- a/compiler/build/src/program.rs +++ b/compiler/build/src/program.rs @@ -193,7 +193,7 @@ pub fn gen_from_mono_module( // run the debugir https://github.com/vaivaswatha/debugir tool match Command::new("debugir") .env_clear() - .args(&[app_ll_file.to_str().unwrap()]) + .args(&["-instnamer", app_ll_file.to_str().unwrap()]) .output() { Ok(_) => {} From f8bdf05f9052c039d83c0f48f5dab6367f583660 Mon Sep 17 00:00:00 2001 From: Folkert Date: Thu, 24 Jun 2021 20:12:05 +0200 Subject: [PATCH 371/496] has_tag_id from zig --- compiler/builtins/bitcode/src/list.zig | 14 ++- compiler/gen_llvm/src/llvm/bitcode.rs | 120 ++++++++++++++++++++++- compiler/gen_llvm/src/llvm/build_list.rs | 30 +++++- 3 files changed, 155 insertions(+), 9 deletions(-) diff --git a/compiler/builtins/bitcode/src/list.zig b/compiler/builtins/bitcode/src/list.zig index 19518dba60..b91df8b1a7 100644 --- a/compiler/builtins/bitcode/src/list.zig +++ b/compiler/builtins/bitcode/src/list.zig @@ -12,6 +12,7 @@ const Opaque = ?[*]u8; const Inc = fn (?[*]u8) callconv(.C) void; const IncN = fn (?[*]u8, usize) callconv(.C) void; const Dec = fn (?[*]u8) callconv(.C) void; +const HasTagId = fn (u16, ?[*]u8) callconv(.C) extern struct { matched: bool, data: ?[*]u8 }; pub const RocList = extern struct { bytes: ?[*]u8, @@ -405,6 +406,7 @@ pub fn listKeepOks( before_width: usize, result_width: usize, after_width: usize, + has_tag_id: HasTagId, dec_result: Dec, ) callconv(.C) RocList { return listKeepResult( @@ -418,6 +420,7 @@ pub fn listKeepOks( before_width, result_width, after_width, + has_tag_id, dec_result, ); } @@ -432,6 +435,7 @@ pub fn listKeepErrs( before_width: usize, result_width: usize, after_width: usize, + has_tag_id: HasTagId, dec_result: Dec, ) callconv(.C) RocList { return listKeepResult( @@ -445,6 +449,7 @@ pub fn listKeepErrs( before_width, result_width, after_width, + has_tag_id, dec_result, ); } @@ -460,6 +465,7 @@ pub fn listKeepResult( before_width: usize, result_width: usize, after_width: usize, + has_tag_id: HasTagId, dec_result: Dec, ) RocList { if (list.bytes) |source_ptr| { @@ -479,11 +485,9 @@ pub fn listKeepResult( const before_element = source_ptr + (i * before_width); caller(data, before_element, temporary); - const result = utils.RocResult{ .bytes = temporary }; - - const after_element = temporary + @sizeOf(i64); - if (is_good_constructor(result)) { - @memcpy(target_ptr + (kept * after_width), after_element, after_width); + const foo = has_tag_id(1, temporary); + if (foo.matched) { + @memcpy(target_ptr + (kept * after_width), foo.data orelse unreachable, after_width); kept += 1; } else { dec_result(temporary); diff --git a/compiler/gen_llvm/src/llvm/bitcode.rs b/compiler/gen_llvm/src/llvm/bitcode.rs index 5bf645980f..57b0d923cd 100644 --- a/compiler/gen_llvm/src/llvm/bitcode.rs +++ b/compiler/gen_llvm/src/llvm/bitcode.rs @@ -1,6 +1,8 @@ /// Helpers for interacting with the zig that generates bitcode use crate::debug_info_init; -use crate::llvm::build::{Env, C_CALL_CONV, FAST_CALL_CONV}; +use crate::llvm::build::{ + struct_from_fields, Env, C_CALL_CONV, FAST_CALL_CONV, TAG_DATA_INDEX, TAG_ID_INDEX, +}; use crate::llvm::convert::basic_type_from_layout; use crate::llvm::refcounting::{ decrement_refcount_layout, increment_n_refcount_layout, increment_refcount_layout, @@ -10,7 +12,7 @@ use inkwell::types::{BasicType, BasicTypeEnum}; use inkwell::values::{BasicValue, BasicValueEnum, CallSiteValue, FunctionValue, InstructionValue}; use inkwell::AddressSpace; use roc_module::symbol::Symbol; -use roc_mono::layout::{Layout, LayoutIds}; +use roc_mono::layout::{Layout, LayoutIds, UnionLayout}; pub fn call_bitcode_fn<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, @@ -66,6 +68,120 @@ const ARGUMENT_SYMBOLS: [Symbol; 8] = [ Symbol::ARG_8, ]; +pub fn build_has_tag_id<'a, 'ctx, 'env>( + env: &Env<'a, 'ctx, 'env>, + function: FunctionValue<'ctx>, + union_layout: UnionLayout<'a>, +) -> FunctionValue<'ctx> { + let fn_name: &str = &format!("{}_has_tag_id", function.get_name().to_string_lossy()); + + match env.module.get_function(fn_name) { + Some(function_value) => function_value, + None => build_has_tag_id_help(env, union_layout, &fn_name), + } +} + +fn build_has_tag_id_help<'a, 'ctx, 'env>( + env: &Env<'a, 'ctx, 'env>, + union_layout: UnionLayout<'a>, + fn_name: &str, +) -> FunctionValue<'ctx> { + let i8_ptr_type = env.context.i8_type().ptr_type(AddressSpace::Generic); + let argument_types: &[BasicTypeEnum] = &[env.context.i16_type().into(), i8_ptr_type.into()]; + + let block = env.builder.get_insert_block().expect("to be in a function"); + let di_location = env.builder.get_current_debug_location().unwrap(); + + let output_type = crate::llvm::convert::zig_has_tag_id_type(env); + + let function_value = crate::llvm::refcounting::build_header_help( + env, + &fn_name, + output_type.into(), + &argument_types, + ); + + // called from zig, must use C calling convention + function_value.set_call_conventions(C_CALL_CONV); + + let kind_id = Attribute::get_named_enum_kind_id("alwaysinline"); + debug_assert!(kind_id > 0); + let attr = env.context.create_enum_attribute(kind_id, 1); + function_value.add_attribute(AttributeLoc::Function, attr); + + let entry = env.context.append_basic_block(function_value, "entry"); + env.builder.position_at_end(entry); + + debug_info_init!(env, function_value); + + let it = function_value.get_param_iter(); + + let arguments = + bumpalo::collections::Vec::from_iter_in(it.take(argument_types.len()), env.arena); + + for (argument, name) in arguments.iter().zip(ARGUMENT_SYMBOLS.iter()) { + argument.set_name(name.ident_string(&env.interns)); + } + + match arguments.as_slice() { + [tag_id, tag_value_ptr] => { + let tag_type = basic_type_from_layout(env, &Layout::Union(union_layout)); + + let argument_cast = env + .builder + .build_bitcast( + *tag_value_ptr, + tag_type.ptr_type(AddressSpace::Generic), + "load_opaque", + ) + .into_pointer_value(); + + let input = env.builder.build_load(argument_cast, "get_value"); + + let tag_value = + crate::llvm::build::get_tag_id(env, function_value, &union_layout, input) + .into_int_value(); + + let actual_tag_id = + env.builder + .build_int_cast(tag_value, env.context.i16_type(), "to_i16"); + + let data_ptr = { + let index = env + .context + .i64_type() + .const_int(TAG_DATA_INDEX as u64, false); + let ptr = unsafe { + env.builder + .build_in_bounds_gep(argument_cast, &[index], "get_tag_id") + }; + + env.builder.build_bitcast(ptr, i8_ptr_type, "to_opaque") + }; + + let answer = env.builder.build_int_compare( + inkwell::IntPredicate::EQ, + tag_id.into_int_value(), + actual_tag_id, + "compare", + ); + + let field_vals = [(0, answer.into()), (1, data_ptr)]; + + let output = struct_from_fields(env, output_type, field_vals.iter().copied()); + + env.builder.build_return(Some(&output)); + + env.builder.position_at_end(block); + env.builder + .set_current_debug_location(env.context, di_location); + + function_value + } + _ => unreachable!(), + } +} + pub fn build_transform_caller<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, function: FunctionValue<'ctx>, diff --git a/compiler/gen_llvm/src/llvm/build_list.rs b/compiler/gen_llvm/src/llvm/build_list.rs index efc3b768c4..d7bc2368c3 100644 --- a/compiler/gen_llvm/src/llvm/build_list.rs +++ b/compiler/gen_llvm/src/llvm/build_list.rs @@ -1,7 +1,7 @@ #![allow(clippy::too_many_arguments)] use crate::llvm::bitcode::{ - build_dec_wrapper, build_eq_wrapper, build_inc_n_wrapper, build_inc_wrapper, call_bitcode_fn, - call_void_bitcode_fn, + build_dec_wrapper, build_eq_wrapper, build_has_tag_id, build_inc_n_wrapper, build_inc_wrapper, + call_bitcode_fn, call_void_bitcode_fn, }; use crate::llvm::build::{ allocate_with_refcount_help, cast_basic_basic, complex_bitcast, Env, RocFunctionCall, @@ -611,6 +611,18 @@ pub fn list_keep_oks<'a, 'ctx, 'env>( ) -> BasicValueEnum<'ctx> { let dec_result_fn = build_dec_wrapper(env, layout_ids, result_layout); + let function = env + .builder + .get_insert_block() + .unwrap() + .get_parent() + .unwrap(); + + let has_tag_id = match result_layout { + Layout::Union(union_layout) => build_has_tag_id(env, function, *union_layout), + _ => unreachable!(), + }; + call_bitcode_fn( env, &[ @@ -623,6 +635,7 @@ pub fn list_keep_oks<'a, 'ctx, 'env>( layout_width(env, before_layout), layout_width(env, result_layout), layout_width(env, after_layout), + has_tag_id.as_global_value().as_pointer_value().into(), dec_result_fn.as_global_value().as_pointer_value().into(), ], bitcode::LIST_KEEP_OKS, @@ -642,6 +655,18 @@ pub fn list_keep_errs<'a, 'ctx, 'env>( ) -> BasicValueEnum<'ctx> { let dec_result_fn = build_dec_wrapper(env, layout_ids, result_layout); + let function = env + .builder + .get_insert_block() + .unwrap() + .get_parent() + .unwrap(); + + let has_tag_id = match result_layout { + Layout::Union(union_layout) => build_has_tag_id(env, function, *union_layout), + _ => unreachable!(), + }; + call_bitcode_fn( env, &[ @@ -654,6 +679,7 @@ pub fn list_keep_errs<'a, 'ctx, 'env>( layout_width(env, before_layout), layout_width(env, result_layout), layout_width(env, after_layout), + has_tag_id.as_global_value().as_pointer_value().into(), dec_result_fn.as_global_value().as_pointer_value().into(), ], bitcode::LIST_KEEP_ERRS, From 0eba188493ee71e0faa1f73c680b5e4693b12788 Mon Sep 17 00:00:00 2001 From: Folkert Date: Thu, 24 Jun 2021 20:12:37 +0200 Subject: [PATCH 372/496] WIP --- compiler/build/src/program.rs | 1 + compiler/gen_llvm/src/llvm/build.rs | 287 ++++++++++------------ compiler/gen_llvm/src/llvm/build_list.rs | 1 + compiler/gen_llvm/src/llvm/convert.rs | 64 ++++- compiler/gen_llvm/src/llvm/refcounting.rs | 29 +-- compiler/mono/src/layout.rs | 25 +- compiler/test_gen/src/gen_tags.rs | 2 +- 7 files changed, 225 insertions(+), 184 deletions(-) diff --git a/compiler/build/src/program.rs b/compiler/build/src/program.rs index fb69a0250d..c7dfb22c2f 100644 --- a/compiler/build/src/program.rs +++ b/compiler/build/src/program.rs @@ -148,6 +148,7 @@ pub fn gen_from_mono_module( opt_level, loaded.procedures, loaded.entry_point, + Some(&app_ll_file), ); env.dibuilder.finalize(); diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 3ec7749504..76a962a1c4 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -1,3 +1,5 @@ +use std::path::Path; + use crate::llvm::bitcode::call_bitcode_fn; use crate::llvm::build_dict::{ dict_contains, dict_difference, dict_empty, dict_get, dict_insert, dict_intersection, @@ -17,8 +19,8 @@ use crate::llvm::build_str::{ }; use crate::llvm::compare::{generic_eq, generic_neq}; use crate::llvm::convert::{ - basic_type_from_builtin, basic_type_from_layout, block_of_memory, block_of_memory_slices, - ptr_int, + basic_type_from_builtin, basic_type_from_layout, basic_type_from_layout_old, block_of_memory, + block_of_memory_slices, ptr_int, }; use crate::llvm::refcounting::{ decrement_refcount_layout, increment_refcount_layout, PointerToRefcount, @@ -892,6 +894,32 @@ pub fn build_exp_call<'a, 'ctx, 'env>( } } +pub const TAG_ID_INDEX: u32 = 1; +pub const TAG_DATA_INDEX: u32 = 0; + +pub fn struct_from_fields<'a, 'ctx, 'env, I>( + env: &Env<'a, 'ctx, 'env>, + struct_type: StructType<'ctx>, + values: I, +) -> StructValue<'ctx> +where + I: Iterator)>, +{ + let mut struct_value = struct_type.const_zero().into(); + + // Insert field exprs into struct_val + for (index, field_val) in values { + let index: u32 = index as u32; + + struct_value = env + .builder + .build_insert_value(struct_value, field_val, index, "insert_record_field") + .unwrap(); + } + + struct_value.into_struct_value() +} + pub fn build_exp_expr<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, layout_ids: &mut LayoutIds<'a>, @@ -938,16 +966,9 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( // Create the struct_type let struct_type = ctx.struct_type(field_types.into_bump_slice(), false); - let mut struct_val = struct_type.const_zero().into(); // Insert field exprs into struct_val - for (index, field_val) in field_vals.into_iter().enumerate() { - struct_val = builder - .build_insert_value(struct_val, field_val, index as u32, "insert_record_field") - .unwrap(); - } - - BasicValueEnum::StructValue(struct_val.into_struct_value()) + struct_from_fields(env, struct_type, field_vals.into_iter().enumerate()).into() } Tag { @@ -957,8 +978,6 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( tag_id, .. } => { - let tag_layout = Layout::Union(UnionLayout::NonRecursive(fields)); - debug_assert!(*union_size > 1); let ctx = env.context; @@ -1034,9 +1053,22 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( // This tricks comes from // https://github.com/raviqqe/ssf/blob/bc32aae68940d5bddf5984128e85af75ca4f4686/ssf-llvm/src/expression_compiler.rs#L116 - let internal_type = basic_type_from_layout(env, &tag_layout); + let internal_type = block_of_memory(env.context, layout, env.ptr_bytes); - cast_tag_to_block_of_memory(builder, struct_val.into_struct_value(), internal_type) + let data = + cast_tag_to_block_of_memory(builder, struct_val.into_struct_value(), internal_type); + let wrapper_type = env + .context + .struct_type(&[data.get_type(), env.context.i64_type().into()], false); + + let tag_id_intval = env.context.i64_type().const_int(*tag_id as u64, false); + + let field_vals = [ + (TAG_ID_INDEX as usize, tag_id_intval.into()), + (TAG_DATA_INDEX as usize, data), + ]; + + struct_from_fields(env, wrapper_type, field_vals.iter().copied()).into() } Tag { arguments, @@ -1569,77 +1601,82 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( structure, union_layout, } => { - let builder = env.builder; - // cast the argument bytes into the desired shape for this tag let (argument, _structure_layout) = load_symbol_and_layout(scope, structure); - match union_layout { - UnionLayout::NonRecursive(_) => { - let pointer = builder.build_alloca(argument.get_type(), "get_type"); - builder.build_store(pointer, argument); - let tag_id_pointer = builder.build_bitcast( - pointer, - env.context.i64_type().ptr_type(AddressSpace::Generic), - "tag_id_pointer", - ); - builder.build_load(tag_id_pointer.into_pointer_value(), "load_tag_id") - } - UnionLayout::Recursive(_) => { - let pointer = argument.into_pointer_value(); - let tag_id_pointer = builder.build_bitcast( - pointer, - env.context.i64_type().ptr_type(AddressSpace::Generic), - "tag_id_pointer", - ); - builder.build_load(tag_id_pointer.into_pointer_value(), "load_tag_id") - } - UnionLayout::NonNullableUnwrapped(_) => env.context.i64_type().const_zero().into(), - UnionLayout::NullableWrapped { nullable_id, .. } => { - let argument_ptr = argument.into_pointer_value(); - let is_null = env.builder.build_is_null(argument_ptr, "is_null"); + get_tag_id(env, parent, union_layout, argument) + } + } +} - let ctx = env.context; - let then_block = ctx.append_basic_block(parent, "then"); - let else_block = ctx.append_basic_block(parent, "else"); - let cont_block = ctx.append_basic_block(parent, "cont"); +pub fn get_tag_id<'a, 'ctx, 'env>( + env: &Env<'a, 'ctx, 'env>, + parent: FunctionValue<'ctx>, + union_layout: &UnionLayout<'a>, + argument: BasicValueEnum<'ctx>, +) -> BasicValueEnum<'ctx> { + let builder = env.builder; + match union_layout { + UnionLayout::NonRecursive(_) => { + let tag = argument.into_struct_value(); - let result = builder.build_alloca(ctx.i64_type(), "result"); + builder + .build_extract_value(tag, TAG_ID_INDEX, "get_tag_id") + .unwrap() + } + UnionLayout::Recursive(_) => { + let pointer = argument.into_pointer_value(); + let tag_id_pointer = builder.build_bitcast( + pointer, + env.context.i64_type().ptr_type(AddressSpace::Generic), + "tag_id_pointer", + ); + builder.build_load(tag_id_pointer.into_pointer_value(), "load_tag_id") + } + UnionLayout::NonNullableUnwrapped(_) => env.context.i64_type().const_zero().into(), + UnionLayout::NullableWrapped { nullable_id, .. } => { + let argument_ptr = argument.into_pointer_value(); + let is_null = env.builder.build_is_null(argument_ptr, "is_null"); - env.builder - .build_conditional_branch(is_null, then_block, else_block); + let ctx = env.context; + let then_block = ctx.append_basic_block(parent, "then"); + let else_block = ctx.append_basic_block(parent, "else"); + let cont_block = ctx.append_basic_block(parent, "cont"); - { - env.builder.position_at_end(then_block); - let tag_id = ctx.i64_type().const_int(*nullable_id as u64, false); - env.builder.build_store(result, tag_id); - env.builder.build_unconditional_branch(cont_block); - } + let result = builder.build_alloca(ctx.i64_type(), "result"); - { - env.builder.position_at_end(else_block); - let tag_id = extract_tag_discriminant_ptr(env, argument_ptr); - env.builder.build_store(result, tag_id); - env.builder.build_unconditional_branch(cont_block); - } + env.builder + .build_conditional_branch(is_null, then_block, else_block); - env.builder.position_at_end(cont_block); - - env.builder.build_load(result, "load_result") - } - UnionLayout::NullableUnwrapped { nullable_id, .. } => { - let argument_ptr = argument.into_pointer_value(); - let is_null = env.builder.build_is_null(argument_ptr, "is_null"); - - let ctx = env.context; - - let then_value = ctx.i64_type().const_int(*nullable_id as u64, false); - let else_value = ctx.i64_type().const_int(!*nullable_id as u64, false); - - env.builder - .build_select(is_null, then_value, else_value, "select_tag_id") - } + { + env.builder.position_at_end(then_block); + let tag_id = ctx.i64_type().const_int(*nullable_id as u64, false); + env.builder.build_store(result, tag_id); + env.builder.build_unconditional_branch(cont_block); } + + { + env.builder.position_at_end(else_block); + let tag_id = extract_tag_discriminant_ptr(env, argument_ptr); + env.builder.build_store(result, tag_id); + env.builder.build_unconditional_branch(cont_block); + } + + env.builder.position_at_end(cont_block); + + env.builder.build_load(result, "load_result") + } + UnionLayout::NullableUnwrapped { nullable_id, .. } => { + let argument_ptr = argument.into_pointer_value(); + let is_null = env.builder.build_is_null(argument_ptr, "is_null"); + + let ctx = env.context; + + let then_value = ctx.i64_type().const_int(*nullable_id as u64, false); + let else_value = ctx.i64_type().const_int(!*nullable_id as u64, false); + + env.builder + .build_select(is_null, then_value, else_value, "select_tag_id") } } } @@ -1721,7 +1758,7 @@ pub fn allocate_with_refcount_help<'a, 'ctx, 'env>( let builder = env.builder; let ctx = env.context; - let value_type = basic_type_from_layout(env, layout); + let value_type = basic_type_from_layout_old(env, layout); let len_type = env.ptr_int(); let extra_bytes = layout.alignment_bytes(env.ptr_bytes).max(env.ptr_bytes); @@ -2436,27 +2473,6 @@ pub fn complex_bitcast<'ctx>( } } -fn extract_tag_discriminant_struct<'a, 'ctx, 'env>( - env: &Env<'a, 'ctx, 'env>, - from_value: StructValue<'ctx>, -) -> IntValue<'ctx> { - let struct_type = env - .context - .struct_type(&[env.context.i64_type().into()], false); - - let struct_value = complex_bitcast_struct_struct( - env.builder, - from_value, - struct_type, - "extract_tag_discriminant_struct", - ); - - env.builder - .build_extract_value(struct_value, 0, "") - .expect("desired field did not decode") - .into_int_value() -} - fn extract_tag_discriminant_ptr<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, from_value: PointerValue<'ctx>, @@ -2547,59 +2563,7 @@ fn build_switch_ir<'a, 'ctx, 'env>( .build_bitcast(cond_value, env.context.i32_type(), "") .into_int_value() } - Layout::Union(variant) => { - use UnionLayout::*; - - match variant { - NonRecursive(_) => { - // we match on the discriminant, not the whole Tag - cond_layout = Layout::Builtin(Builtin::Int64); - let full_cond = cond_value.into_struct_value(); - - extract_tag_discriminant_struct(env, full_cond) - } - Recursive(_) => { - // we match on the discriminant, not the whole Tag - cond_layout = Layout::Builtin(Builtin::Int64); - - debug_assert!(cond_value.is_pointer_value()); - extract_tag_discriminant_ptr(env, cond_value.into_pointer_value()) - } - NonNullableUnwrapped(_) => unreachable!("there is no tag to switch on"), - NullableWrapped { nullable_id, .. } => { - // we match on the discriminant, not the whole Tag - cond_layout = Layout::Builtin(Builtin::Int64); - let full_cond_ptr = cond_value.into_pointer_value(); - - let comparison: IntValue = - env.builder.build_is_null(full_cond_ptr, "is_null_cond"); - - let when_null = || { - env.context - .i64_type() - .const_int(nullable_id as u64, false) - .into() - }; - let when_not_null = || extract_tag_discriminant_ptr(env, full_cond_ptr).into(); - - crate::llvm::build_list::build_basic_phi2( - env, - parent, - comparison, - when_null, - when_not_null, - BasicTypeEnum::IntType(env.context.i64_type()), - ) - .into_int_value() - } - NullableUnwrapped { .. } => { - // there are only two options, so we do a `tag_id == 0` check and branch on that - unreachable!( - "we never switch on the tag id directly for NullableUnwrapped unions" - ) - } - } - } + Layout::Union(variant) => get_tag_id(env, parent, &variant, cond_value).into_int_value(), Layout::Builtin(_) => cond_value.into_int_value(), other => todo!("Build switch value from layout: {:?}", other), }; @@ -3145,8 +3109,9 @@ pub fn build_procedures<'a, 'ctx, 'env>( opt_level: OptLevel, procedures: MutMap<(Symbol, ProcLayout<'a>), roc_mono::ir::Proc<'a>>, entry_point: EntryPoint<'a>, + debug_output_file: Option<&Path>, ) { - build_procedures_help(env, opt_level, procedures, entry_point); + build_procedures_help(env, opt_level, procedures, entry_point, debug_output_file); } pub fn build_procedures_return_main<'a, 'ctx, 'env>( @@ -3155,7 +3120,7 @@ pub fn build_procedures_return_main<'a, 'ctx, 'env>( procedures: MutMap<(Symbol, ProcLayout<'a>), roc_mono::ir::Proc<'a>>, entry_point: EntryPoint<'a>, ) -> (&'static str, FunctionValue<'ctx>) { - let mod_solutions = build_procedures_help(env, opt_level, procedures, entry_point); + let mod_solutions = build_procedures_help(env, opt_level, procedures, entry_point, None); promote_to_main_function(env, mod_solutions, entry_point.symbol, entry_point.layout) } @@ -3165,6 +3130,7 @@ fn build_procedures_help<'a, 'ctx, 'env>( opt_level: OptLevel, procedures: MutMap<(Symbol, ProcLayout<'a>), roc_mono::ir::Proc<'a>>, entry_point: EntryPoint<'a>, + debug_output_file: Option<&Path>, ) -> &'a ModSolutions { let mut layout_ids = roc_mono::layout::LayoutIds::default(); let mut scope = Scope::default(); @@ -3223,13 +3189,22 @@ fn build_procedures_help<'a, 'ctx, 'env>( ); fn_val.print_to_stderr(); - // module.print_to_stderr(); - panic!( + if let Some(app_ll_file) = debug_output_file { + env.module.print_to_file(&app_ll_file).unwrap(); + + panic!( + r"😱 LLVM errors when defining function {:?}; I wrote the full LLVM IR to {:?}", + fn_val.get_name().to_str().unwrap(), + app_ll_file, + ); + } else { + panic!( "The preceding code was from {:?}, which failed LLVM verification in {} build.", - fn_val.get_name().to_str().unwrap(), + fn_val.get_name().to_str().unwrap(), mode, - ); + ) + } } } } diff --git a/compiler/gen_llvm/src/llvm/build_list.rs b/compiler/gen_llvm/src/llvm/build_list.rs index d7bc2368c3..f3e1dcc465 100644 --- a/compiler/gen_llvm/src/llvm/build_list.rs +++ b/compiler/gen_llvm/src/llvm/build_list.rs @@ -741,6 +741,7 @@ pub fn list_map<'a, 'ctx, 'env>( element_layout: &Layout<'a>, return_layout: &Layout<'a>, ) -> BasicValueEnum<'ctx> { + dbg!(return_layout, layout_width(env, return_layout)); call_bitcode_fn_returns_list( env, &[ diff --git a/compiler/gen_llvm/src/llvm/convert.rs b/compiler/gen_llvm/src/llvm/convert.rs index 27b9c82356..acc93a9bf8 100644 --- a/compiler/gen_llvm/src/llvm/convert.rs +++ b/compiler/gen_llvm/src/llvm/convert.rs @@ -25,6 +25,58 @@ pub fn basic_type_from_layout<'a, 'ctx, 'env>( ) -> BasicTypeEnum<'ctx> { use Layout::*; + match layout { + Closure(_args, closure_layout, _ret_layout) => { + let closure_data_layout = closure_layout.runtime_representation(); + basic_type_from_layout(env, &closure_data_layout) + } + Struct(sorted_fields) => basic_type_from_record(env, sorted_fields), + Union(variant) => { + use UnionLayout::*; + match variant { + Recursive(tags) + | NullableWrapped { + other_tags: tags, .. + } => { + let block = block_of_memory_slices(env.context, tags, env.ptr_bytes); + block.ptr_type(AddressSpace::Generic).into() + } + NullableUnwrapped { other_fields, .. } => { + let block = + block_of_memory_slices(env.context, &[&other_fields[1..]], env.ptr_bytes); + block.ptr_type(AddressSpace::Generic).into() + } + NonNullableUnwrapped(fields) => { + let block = block_of_memory_slices(env.context, &[fields], env.ptr_bytes); + block.ptr_type(AddressSpace::Generic).into() + } + NonRecursive(_) => { + let data = block_of_memory(env.context, layout, env.ptr_bytes); + + env.context + .struct_type(&[data, env.context.i64_type().into()], false) + .into() + } + } + } + RecursivePointer => { + // TODO make this dynamic + env.context + .i64_type() + .ptr_type(AddressSpace::Generic) + .as_basic_type_enum() + } + + Builtin(builtin) => basic_type_from_builtin(env, builtin), + } +} + +pub fn basic_type_from_layout_old<'a, 'ctx, 'env>( + env: &crate::llvm::build::Env<'a, 'ctx, 'env>, + layout: &Layout<'_>, +) -> BasicTypeEnum<'ctx> { + use Layout::*; + match layout { Closure(_args, closure_layout, _ret_layout) => { let closure_data_layout = closure_layout.runtime_representation(); @@ -117,7 +169,11 @@ pub fn block_of_memory<'ctx>( ptr_bytes: u32, ) -> BasicTypeEnum<'ctx> { // TODO make this dynamic - let union_size = layout.stack_size(ptr_bytes as u32); + let mut union_size = layout.stack_size(ptr_bytes as u32); + + if let Layout::Union(UnionLayout::NonRecursive { .. }) = layout { + union_size -= ptr_bytes; + } block_of_memory_help(context, union_size) } @@ -180,3 +236,9 @@ pub fn zig_str_type<'a, 'ctx, 'env>( ) -> StructType<'ctx> { env.module.get_struct_type("str.RocStr").unwrap() } + +pub fn zig_has_tag_id_type<'a, 'ctx, 'env>( + env: &crate::llvm::build::Env<'a, 'ctx, 'env>, +) -> StructType<'ctx> { + env.module.get_struct_type("list.HasTagId").unwrap() +} diff --git a/compiler/gen_llvm/src/llvm/refcounting.rs b/compiler/gen_llvm/src/llvm/refcounting.rs index dbee02c4a3..83240e762d 100644 --- a/compiler/gen_llvm/src/llvm/refcounting.rs +++ b/compiler/gen_llvm/src/llvm/refcounting.rs @@ -1,7 +1,7 @@ use crate::debug_info_init; use crate::llvm::build::{ add_func, cast_basic_basic, cast_block_of_memory_to_tag, Env, FAST_CALL_CONV, - LLVM_SADD_WITH_OVERFLOW_I64, + LLVM_SADD_WITH_OVERFLOW_I64, TAG_DATA_INDEX, TAG_ID_INDEX, }; use crate::llvm::build_list::{incrementing_elem_loop, list_len, load_list}; use crate::llvm::convert::{ @@ -1584,7 +1584,7 @@ fn modify_refcount_union<'a, 'ctx, 'env>( let function = match env.module.get_function(fn_name.as_str()) { Some(function_value) => function_value, None => { - let basic_type = block_of_memory(env.context, &layout, env.ptr_bytes); + let basic_type = basic_type_from_layout(env, &layout); let function_value = build_header(env, basic_type, mode, &fn_name); modify_refcount_union_help( @@ -1640,19 +1640,11 @@ fn modify_refcount_union_help<'a, 'ctx, 'env>( let wrapper_struct = arg_val.into_struct_value(); // read the tag_id - let tag_id = { - // the first element of the wrapping struct is an array of i64 - let first_array = env - .builder - .build_extract_value(wrapper_struct, 0, "read_tag_id") - .unwrap() - .into_array_value(); - - env.builder - .build_extract_value(first_array, 0, "read_tag_id_2") - .unwrap() - .into_int_value() - }; + let tag_id = env + .builder + .build_extract_value(wrapper_struct, TAG_ID_INDEX, "read_tag_id") + .unwrap() + .into_int_value(); let tag_id_u8 = env .builder @@ -1680,7 +1672,12 @@ fn modify_refcount_union_help<'a, 'ctx, 'env>( let wrapper_type = basic_type_from_layout(env, &Layout::Struct(field_layouts)); debug_assert!(wrapper_type.is_struct_type()); - let wrapper_struct = cast_block_of_memory_to_tag(env.builder, wrapper_struct, wrapper_type); + let data_bytes = env + .builder + .build_extract_value(wrapper_struct, TAG_DATA_INDEX, "read_tag_id") + .unwrap() + .into_struct_value(); + let wrapper_struct = cast_block_of_memory_to_tag(env.builder, data_bytes, wrapper_type); for (i, field_layout) in field_layouts.iter().enumerate() { if let Layout::RecursivePointer = field_layout { diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index 9988ad6f64..06bf3be426 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -564,16 +564,21 @@ impl<'a> Layout<'a> { use UnionLayout::*; match variant { - NonRecursive(fields) => fields - .iter() - .map(|tag_layout| { - tag_layout - .iter() - .map(|field| field.stack_size(pointer_size)) - .sum() - }) - .max() - .unwrap_or_default(), + NonRecursive(fields) => { + let data_size: u32 = fields + .iter() + .map(|tag_layout| { + tag_layout + .iter() + .map(|field| field.stack_size(pointer_size)) + .sum() + }) + .max() + .unwrap_or_default(); + + // TEMPORARY + pointer_size + data_size + } Recursive(_) | NullableWrapped { .. } diff --git a/compiler/test_gen/src/gen_tags.rs b/compiler/test_gen/src/gen_tags.rs index a16ba1a6af..03c4abbd05 100644 --- a/compiler/test_gen/src/gen_tags.rs +++ b/compiler/test_gen/src/gen_tags.rs @@ -1003,7 +1003,7 @@ fn applied_tag_function_result() { x : List (Result Str *) x = List.map [ "a", "b" ] Ok - x + List.keepOks x (\y -> y) "# ), RocList::from_slice(&[ From 2355bbf8153d227e53e39f4ee0bfa8b561ba0784 Mon Sep 17 00:00:00 2001 From: Folkert Date: Thu, 24 Jun 2021 20:25:06 +0200 Subject: [PATCH 373/496] updates --- compiler/gen_llvm/src/llvm/bitcode.rs | 13 +- compiler/gen_llvm/src/llvm/build.rs | 208 +++++++++++--------------- 2 files changed, 94 insertions(+), 127 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/bitcode.rs b/compiler/gen_llvm/src/llvm/bitcode.rs index 57b0d923cd..214bfaab72 100644 --- a/compiler/gen_llvm/src/llvm/bitcode.rs +++ b/compiler/gen_llvm/src/llvm/bitcode.rs @@ -1,8 +1,6 @@ /// Helpers for interacting with the zig that generates bitcode use crate::debug_info_init; -use crate::llvm::build::{ - struct_from_fields, Env, C_CALL_CONV, FAST_CALL_CONV, TAG_DATA_INDEX, TAG_ID_INDEX, -}; +use crate::llvm::build::{struct_from_fields, Env, C_CALL_CONV, FAST_CALL_CONV}; use crate::llvm::convert::basic_type_from_layout; use crate::llvm::refcounting::{ decrement_refcount_layout, increment_n_refcount_layout, increment_refcount_layout, @@ -138,9 +136,12 @@ fn build_has_tag_id_help<'a, 'ctx, 'env>( let input = env.builder.build_load(argument_cast, "get_value"); - let tag_value = - crate::llvm::build::get_tag_id(env, function_value, &union_layout, input) - .into_int_value(); + let tag_value = crate::llvm::build::extract_tag_discriminant( + env, + function_value, + union_layout, + input, + ); let actual_tag_id = env.builder diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 3ec7749504..c8d91374c5 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -1569,77 +1569,8 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( structure, union_layout, } => { - let builder = env.builder; - - // cast the argument bytes into the desired shape for this tag - let (argument, _structure_layout) = load_symbol_and_layout(scope, structure); - - match union_layout { - UnionLayout::NonRecursive(_) => { - let pointer = builder.build_alloca(argument.get_type(), "get_type"); - builder.build_store(pointer, argument); - let tag_id_pointer = builder.build_bitcast( - pointer, - env.context.i64_type().ptr_type(AddressSpace::Generic), - "tag_id_pointer", - ); - builder.build_load(tag_id_pointer.into_pointer_value(), "load_tag_id") - } - UnionLayout::Recursive(_) => { - let pointer = argument.into_pointer_value(); - let tag_id_pointer = builder.build_bitcast( - pointer, - env.context.i64_type().ptr_type(AddressSpace::Generic), - "tag_id_pointer", - ); - builder.build_load(tag_id_pointer.into_pointer_value(), "load_tag_id") - } - UnionLayout::NonNullableUnwrapped(_) => env.context.i64_type().const_zero().into(), - UnionLayout::NullableWrapped { nullable_id, .. } => { - let argument_ptr = argument.into_pointer_value(); - let is_null = env.builder.build_is_null(argument_ptr, "is_null"); - - let ctx = env.context; - let then_block = ctx.append_basic_block(parent, "then"); - let else_block = ctx.append_basic_block(parent, "else"); - let cont_block = ctx.append_basic_block(parent, "cont"); - - let result = builder.build_alloca(ctx.i64_type(), "result"); - - env.builder - .build_conditional_branch(is_null, then_block, else_block); - - { - env.builder.position_at_end(then_block); - let tag_id = ctx.i64_type().const_int(*nullable_id as u64, false); - env.builder.build_store(result, tag_id); - env.builder.build_unconditional_branch(cont_block); - } - - { - env.builder.position_at_end(else_block); - let tag_id = extract_tag_discriminant_ptr(env, argument_ptr); - env.builder.build_store(result, tag_id); - env.builder.build_unconditional_branch(cont_block); - } - - env.builder.position_at_end(cont_block); - - env.builder.build_load(result, "load_result") - } - UnionLayout::NullableUnwrapped { nullable_id, .. } => { - let argument_ptr = argument.into_pointer_value(); - let is_null = env.builder.build_is_null(argument_ptr, "is_null"); - - let ctx = env.context; - - let then_value = ctx.i64_type().const_int(*nullable_id as u64, false); - let else_value = ctx.i64_type().const_int(!*nullable_id as u64, false); - - env.builder - .build_select(is_null, then_value, else_value, "select_tag_id") - } - } + let value = load_symbol(scope, structure); + extract_tag_discriminant(env, parent, *union_layout, value).into() } } } @@ -2436,6 +2367,89 @@ pub fn complex_bitcast<'ctx>( } } +pub fn extract_tag_discriminant<'a, 'ctx, 'env>( + env: &Env<'a, 'ctx, 'env>, + parent: FunctionValue<'ctx>, + union_layout: UnionLayout<'a>, + cond_value: BasicValueEnum<'ctx>, +) -> IntValue<'ctx> { + let builder = env.builder; + + match union_layout { + UnionLayout::NonRecursive(_) => { + let pointer = builder.build_alloca(cond_value.get_type(), "get_type"); + builder.build_store(pointer, cond_value); + let tag_id_pointer = builder.build_bitcast( + pointer, + env.context.i64_type().ptr_type(AddressSpace::Generic), + "tag_id_pointer", + ); + builder + .build_load(tag_id_pointer.into_pointer_value(), "load_tag_id") + .into_int_value() + } + UnionLayout::Recursive(_) => { + let pointer = cond_value.into_pointer_value(); + let tag_id_pointer = builder.build_bitcast( + pointer, + env.context.i64_type().ptr_type(AddressSpace::Generic), + "tag_id_pointer", + ); + builder + .build_load(tag_id_pointer.into_pointer_value(), "load_tag_id") + .into_int_value() + } + UnionLayout::NonNullableUnwrapped(_) => env.context.i64_type().const_zero(), + UnionLayout::NullableWrapped { nullable_id, .. } => { + let argument_ptr = cond_value.into_pointer_value(); + let is_null = env.builder.build_is_null(argument_ptr, "is_null"); + + let ctx = env.context; + let then_block = ctx.append_basic_block(parent, "then"); + let else_block = ctx.append_basic_block(parent, "else"); + let cont_block = ctx.append_basic_block(parent, "cont"); + + let result = builder.build_alloca(ctx.i64_type(), "result"); + + env.builder + .build_conditional_branch(is_null, then_block, else_block); + + { + env.builder.position_at_end(then_block); + let tag_id = ctx.i64_type().const_int(nullable_id as u64, false); + env.builder.build_store(result, tag_id); + env.builder.build_unconditional_branch(cont_block); + } + + { + env.builder.position_at_end(else_block); + let tag_id = extract_tag_discriminant_ptr(env, argument_ptr); + env.builder.build_store(result, tag_id); + env.builder.build_unconditional_branch(cont_block); + } + + env.builder.position_at_end(cont_block); + + env.builder + .build_load(result, "load_result") + .into_int_value() + } + UnionLayout::NullableUnwrapped { nullable_id, .. } => { + let argument_ptr = cond_value.into_pointer_value(); + let is_null = env.builder.build_is_null(argument_ptr, "is_null"); + + let ctx = env.context; + + let then_value = ctx.i64_type().const_int(nullable_id as u64, false); + let else_value = ctx.i64_type().const_int(!nullable_id as u64, false); + + env.builder + .build_select(is_null, then_value, else_value, "select_tag_id") + .into_int_value() + } + } +} + fn extract_tag_discriminant_struct<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, from_value: StructValue<'ctx>, @@ -2548,57 +2562,9 @@ fn build_switch_ir<'a, 'ctx, 'env>( .into_int_value() } Layout::Union(variant) => { - use UnionLayout::*; + cond_layout = Layout::Builtin(Builtin::Int64); - match variant { - NonRecursive(_) => { - // we match on the discriminant, not the whole Tag - cond_layout = Layout::Builtin(Builtin::Int64); - let full_cond = cond_value.into_struct_value(); - - extract_tag_discriminant_struct(env, full_cond) - } - Recursive(_) => { - // we match on the discriminant, not the whole Tag - cond_layout = Layout::Builtin(Builtin::Int64); - - debug_assert!(cond_value.is_pointer_value()); - extract_tag_discriminant_ptr(env, cond_value.into_pointer_value()) - } - NonNullableUnwrapped(_) => unreachable!("there is no tag to switch on"), - NullableWrapped { nullable_id, .. } => { - // we match on the discriminant, not the whole Tag - cond_layout = Layout::Builtin(Builtin::Int64); - let full_cond_ptr = cond_value.into_pointer_value(); - - let comparison: IntValue = - env.builder.build_is_null(full_cond_ptr, "is_null_cond"); - - let when_null = || { - env.context - .i64_type() - .const_int(nullable_id as u64, false) - .into() - }; - let when_not_null = || extract_tag_discriminant_ptr(env, full_cond_ptr).into(); - - crate::llvm::build_list::build_basic_phi2( - env, - parent, - comparison, - when_null, - when_not_null, - BasicTypeEnum::IntType(env.context.i64_type()), - ) - .into_int_value() - } - NullableUnwrapped { .. } => { - // there are only two options, so we do a `tag_id == 0` check and branch on that - unreachable!( - "we never switch on the tag id directly for NullableUnwrapped unions" - ) - } - } + extract_tag_discriminant(env, parent, variant, cond_value) } Layout::Builtin(_) => cond_value.into_int_value(), other => todo!("Build switch value from layout: {:?}", other), From a05d8b52c0d2a819fc74a23affdbe40657359975 Mon Sep 17 00:00:00 2001 From: Folkert Date: Thu, 24 Jun 2021 20:31:14 +0200 Subject: [PATCH 374/496] make things compile --- compiler/gen_llvm/src/llvm/bitcode.rs | 32 +++++++--------------- compiler/gen_llvm/src/llvm/build.rs | 38 ++++++++++++++++++--------- compiler/gen_llvm/src/llvm/convert.rs | 6 +++++ 3 files changed, 42 insertions(+), 34 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/bitcode.rs b/compiler/gen_llvm/src/llvm/bitcode.rs index 214bfaab72..6dfb4ab929 100644 --- a/compiler/gen_llvm/src/llvm/bitcode.rs +++ b/compiler/gen_llvm/src/llvm/bitcode.rs @@ -134,30 +134,18 @@ fn build_has_tag_id_help<'a, 'ctx, 'env>( ) .into_pointer_value(); - let input = env.builder.build_load(argument_cast, "get_value"); + let tag_value = env.builder.build_load(argument_cast, "get_value"); - let tag_value = crate::llvm::build::extract_tag_discriminant( - env, - function_value, - union_layout, - input, - ); + let actual_tag_id = { + let tag_id_i64 = crate::llvm::build::extract_tag_discriminant( + env, + function_value, + union_layout, + tag_value, + ); - let actual_tag_id = env.builder - .build_int_cast(tag_value, env.context.i16_type(), "to_i16"); - - let data_ptr = { - let index = env - .context - .i64_type() - .const_int(TAG_DATA_INDEX as u64, false); - let ptr = unsafe { - env.builder - .build_in_bounds_gep(argument_cast, &[index], "get_tag_id") - }; - - env.builder.build_bitcast(ptr, i8_ptr_type, "to_opaque") + .build_int_cast(tag_id_i64, env.context.i16_type(), "to_i16") }; let answer = env.builder.build_int_compare( @@ -167,7 +155,7 @@ fn build_has_tag_id_help<'a, 'ctx, 'env>( "compare", ); - let field_vals = [(0, answer.into()), (1, data_ptr)]; + let field_vals = [(0, answer.into()), (1, *tag_value_ptr)]; let output = struct_from_fields(env, output_type, field_vals.iter().copied()); diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index c8d91374c5..46cdb61c02 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -996,19 +996,10 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( // Create the struct_type let struct_type = ctx.struct_type(field_types.into_bump_slice(), false); - let mut struct_val = struct_type.const_zero().into(); // Insert field exprs into struct_val - for (index, field_val) in field_vals.into_iter().enumerate() { - struct_val = builder - .build_insert_value( - struct_val, - field_val, - index as u32, - "insert_multi_tag_field", - ) - .unwrap(); - } + let struct_val = + struct_from_fields(env, struct_type, field_vals.into_iter().enumerate()); // How we create tag values // @@ -1036,7 +1027,7 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( let internal_type = basic_type_from_layout(env, &tag_layout); - cast_tag_to_block_of_memory(builder, struct_val.into_struct_value(), internal_type) + cast_tag_to_block_of_memory(builder, struct_val, internal_type) } Tag { arguments, @@ -1575,6 +1566,29 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( } } +pub fn struct_from_fields<'a, 'ctx, 'env, I>( + env: &Env<'a, 'ctx, 'env>, + struct_type: StructType<'ctx>, + values: I, +) -> StructValue<'ctx> +where + I: Iterator)>, +{ + let mut struct_value = struct_type.const_zero().into(); + + // Insert field exprs into struct_val + for (index, field_val) in values { + let index: u32 = index as u32; + + struct_value = env + .builder + .build_insert_value(struct_value, field_val, index, "insert_record_field") + .unwrap(); + } + + struct_value.into_struct_value() +} + fn lookup_at_index_ptr<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, field_layouts: &[Layout<'_>], diff --git a/compiler/gen_llvm/src/llvm/convert.rs b/compiler/gen_llvm/src/llvm/convert.rs index 27b9c82356..4360570d84 100644 --- a/compiler/gen_llvm/src/llvm/convert.rs +++ b/compiler/gen_llvm/src/llvm/convert.rs @@ -180,3 +180,9 @@ pub fn zig_str_type<'a, 'ctx, 'env>( ) -> StructType<'ctx> { env.module.get_struct_type("str.RocStr").unwrap() } + +pub fn zig_has_tag_id_type<'a, 'ctx, 'env>( + env: &crate::llvm::build::Env<'a, 'ctx, 'env>, +) -> StructType<'ctx> { + env.module.get_struct_type("list.HasTagId").unwrap() +} From 8d9f5b078e596d2f0f0fcf4ceb4e2a1657102084 Mon Sep 17 00:00:00 2001 From: Folkert Date: Thu, 24 Jun 2021 21:11:25 +0200 Subject: [PATCH 375/496] fix ffi --- compiler/builtins/bitcode/src/list.zig | 16 +++++++++++----- compiler/gen_llvm/src/llvm/build.rs | 21 --------------------- 2 files changed, 11 insertions(+), 26 deletions(-) diff --git a/compiler/builtins/bitcode/src/list.zig b/compiler/builtins/bitcode/src/list.zig index b91df8b1a7..b1a32c3c61 100644 --- a/compiler/builtins/bitcode/src/list.zig +++ b/compiler/builtins/bitcode/src/list.zig @@ -409,9 +409,11 @@ pub fn listKeepOks( has_tag_id: HasTagId, dec_result: Dec, ) callconv(.C) RocList { + const good_constructor: u16 = 1; + return listKeepResult( list, - RocResult.isOk, + good_constructor, caller, data, inc_n_data, @@ -438,9 +440,11 @@ pub fn listKeepErrs( has_tag_id: HasTagId, dec_result: Dec, ) callconv(.C) RocList { + const good_constructor: u16 = 0; + return listKeepResult( list, - RocResult.isErr, + good_constructor, caller, data, inc_n_data, @@ -456,7 +460,7 @@ pub fn listKeepErrs( pub fn listKeepResult( list: RocList, - is_good_constructor: fn (RocResult) bool, + good_constructor: u16, caller: Caller1, data: Opaque, inc_n_data: IncN, @@ -485,9 +489,11 @@ pub fn listKeepResult( const before_element = source_ptr + (i * before_width); caller(data, before_element, temporary); - const foo = has_tag_id(1, temporary); + const foo = has_tag_id(good_constructor, temporary); if (foo.matched) { - @memcpy(target_ptr + (kept * after_width), foo.data orelse unreachable, after_width); + // drop the tag id + const contents = (foo.data orelse unreachable) + @sizeOf(i64); + @memcpy(target_ptr + (kept * after_width), contents, after_width); kept += 1; } else { dec_result(temporary); diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 46cdb61c02..e1054e6948 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -2464,27 +2464,6 @@ pub fn extract_tag_discriminant<'a, 'ctx, 'env>( } } -fn extract_tag_discriminant_struct<'a, 'ctx, 'env>( - env: &Env<'a, 'ctx, 'env>, - from_value: StructValue<'ctx>, -) -> IntValue<'ctx> { - let struct_type = env - .context - .struct_type(&[env.context.i64_type().into()], false); - - let struct_value = complex_bitcast_struct_struct( - env.builder, - from_value, - struct_type, - "extract_tag_discriminant_struct", - ); - - env.builder - .build_extract_value(struct_value, 0, "") - .expect("desired field did not decode") - .into_int_value() -} - fn extract_tag_discriminant_ptr<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, from_value: PointerValue<'ctx>, From fc4f04dbd8c14ec4c2831a405fda6d3f608a25e5 Mon Sep 17 00:00:00 2001 From: Folkert Date: Thu, 24 Jun 2021 21:20:50 +0200 Subject: [PATCH 376/496] clean up variable names --- compiler/builtins/bitcode/src/list.zig | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/compiler/builtins/bitcode/src/list.zig b/compiler/builtins/bitcode/src/list.zig index b1a32c3c61..134d4ba0d5 100644 --- a/compiler/builtins/bitcode/src/list.zig +++ b/compiler/builtins/bitcode/src/list.zig @@ -489,10 +489,14 @@ pub fn listKeepResult( const before_element = source_ptr + (i * before_width); caller(data, before_element, temporary); - const foo = has_tag_id(good_constructor, temporary); - if (foo.matched) { + // a record { matched: bool, data: ?[*]u8 } + // for now, that data pointer is just the input `temporary` pointer + // this will change in the future to only return a pointer to the + // payload of the tag + const answer = has_tag_id(good_constructor, temporary); + if (answer.matched) { // drop the tag id - const contents = (foo.data orelse unreachable) + @sizeOf(i64); + const contents = (answer.data orelse unreachable) + @sizeOf(i64); @memcpy(target_ptr + (kept * after_width), contents, after_width); kept += 1; } else { From 47fe878492adfa3a41a1e573fd7f9290a1aa62f7 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Fri, 25 Jun 2021 19:07:14 +0200 Subject: [PATCH 377/496] updated to wgpu 9.0, added editor inspiration --- Cargo.lock | 109 ++++++++++++++++++++++++++++++----------- editor/Cargo.toml | 4 +- editor/editor-ideas.md | 1 + 3 files changed, 83 insertions(+), 31 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 269748de0f..0b9b0b0c1c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -967,6 +967,15 @@ version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9ea835d29036a4087793836fa931b08837ad5e957da9e23886b29586fb9b6650" +[[package]] +name = "drm-fourcc" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ebbf3a5ed4671aabffefce172ff43d69c1f27dd2c6aea28e5212a70f32ada0cf" +dependencies = [ + "serde", +] + [[package]] name = "dtoa" version = "0.4.8" @@ -1008,6 +1017,16 @@ dependencies = [ "termcolor", ] +[[package]] +name = "external-memory" +version = "0.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e4dfe8d292b014422776a8c516862d2bff8a81b223a4461dfdc45f3862dc9d39" +dependencies = [ + "bitflags", + "drm-fourcc", +] + [[package]] name = "fake-simd" version = "0.1.2" @@ -1221,9 +1240,9 @@ dependencies = [ [[package]] name = "gfx-auxil" -version = "0.9.0" +version = "0.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9ccf8711c9994dfa34337466bee3ae1462e172874c432ce4eb120ab2e98d39cf" +checksum = "1694991b11d642680e82075a75c7c2bd75556b805efa7660b705689f05b1ab1c" dependencies = [ "fxhash", "gfx-hal", @@ -1232,14 +1251,15 @@ dependencies = [ [[package]] name = "gfx-backend-dx11" -version = "0.8.0" +version = "0.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6f839f27f8c8a6dc553ccca7f5b35a42009432bc25db9688bba7061cd394161f" +checksum = "8f9e453baf3aaef2b0c354ce0b3d63d76402e406a59b64b7182d123cfa6635ae" dependencies = [ "arrayvec", "bitflags", "gfx-auxil", "gfx-hal", + "gfx-renderdoc", "libloading 0.7.0", "log", "parking_lot", @@ -1254,9 +1274,9 @@ dependencies = [ [[package]] name = "gfx-backend-dx12" -version = "0.8.0" +version = "0.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3937738b0da5839bba4e33980d29f9a06dbce184d04a3a08c9a949e7953700e3" +checksum = "61f09e9d8c2aa69e9a21eb83c0f5d1a286c6d37da011f796e550d180b08090ce" dependencies = [ "arrayvec", "bit-set", @@ -1264,6 +1284,7 @@ dependencies = [ "d3d12", "gfx-auxil", "gfx-hal", + "gfx-renderdoc", "log", "parking_lot", "range-alloc", @@ -1276,9 +1297,9 @@ dependencies = [ [[package]] name = "gfx-backend-empty" -version = "0.8.0" +version = "0.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2ac55ada4bfcd35479b3421eea324d36d7da5f724e2f66ecb36d4efdb7041a5e" +checksum = "29c8f813c47791918aa00dc9c9ddf961d23fa8c2a5d869e6cb8ea84f944820f4" dependencies = [ "gfx-hal", "log", @@ -1287,9 +1308,9 @@ dependencies = [ [[package]] name = "gfx-backend-gl" -version = "0.8.1" +version = "0.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0caa03d6e0b7b4f202aea1f20c3f3288cfa06d92d24cea9d69c9a7627967244a" +checksum = "6bae057fc3a0ab23ecf97ae51d4017d27d5ddf0aab16ee6dcb58981af88c3152" dependencies = [ "arrayvec", "bitflags", @@ -1309,15 +1330,16 @@ dependencies = [ [[package]] name = "gfx-backend-metal" -version = "0.8.2" +version = "0.9.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "340895ad544ba46433acb3bdabece0ef16f2dbedc030adbd7c9eaf2839fbed41" +checksum = "0de85808e2a98994c6af925253f8a9593bc57180ef1ea137deab6d35cc949517" dependencies = [ "arrayvec", "bitflags", "block", "cocoa-foundation", "copyless", + "core-graphics-types", "foreign-types", "fxhash", "gfx-hal", @@ -1334,15 +1356,16 @@ dependencies = [ [[package]] name = "gfx-backend-vulkan" -version = "0.8.0" +version = "0.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a353fc6fdb42ec646de49bbb74e4870e37a7e680caf33f3ac0615c30b1146d94" +checksum = "a9861ec855acbbc65c0e4f966d761224886e811dc2c6d413a4776e9293d0e5c0" dependencies = [ "arrayvec", "ash", "byteorder", "core-graphics-types", "gfx-hal", + "gfx-renderdoc", "inplace_it", "log", "naga", @@ -1355,16 +1378,28 @@ dependencies = [ [[package]] name = "gfx-hal" -version = "0.8.0" +version = "0.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6d285bfd566f6b9134af908446ca350c0a1047495dfb9bbd826e701e8ee1d259" +checksum = "7fbb575ea793dd0507b3082f4f2cde62dc9f3cebd98f5cd49ba2a4da97a976fd" dependencies = [ "bitflags", + "external-memory", "naga", "raw-window-handle", "thiserror", ] +[[package]] +name = "gfx-renderdoc" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c8027995e247e2426d3a00d13f5191dd56c314bff02dc4b54cbf727f1ba9c40a" +dependencies = [ + "libloading 0.7.0", + "log", + "renderdoc-sys", +] + [[package]] name = "gimli" version = "0.24.0" @@ -1880,13 +1915,13 @@ dependencies = [ [[package]] name = "metal" -version = "0.22.0" +version = "0.23.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1c12e48c737ee9a55e8bb2352bcde588f79ae308d3529ee888f7cc0f469b5777" +checksum = "79d7d769f1c104b8388294d6594d491d2e21240636f5f94d37f8a0f3d7904450" dependencies = [ "bitflags", "block", - "cocoa-foundation", + "core-graphics-types", "foreign-types", "log", "objc", @@ -1956,9 +1991,9 @@ dependencies = [ [[package]] name = "naga" -version = "0.4.2" +version = "0.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c8d74f2c7ace793a760165ac0679d6830809ad4e85f6886f72e4f8c4aa4291c5" +checksum = "ef670817eef03d356d5a509ea275e7dd3a78ea9e24261ea3cb2dfed1abb08f64" dependencies = [ "bit-set", "bitflags", @@ -1967,6 +2002,7 @@ dependencies = [ "log", "num-traits", "petgraph", + "rose_tree", "spirv_headers", "thiserror", ] @@ -2935,6 +2971,12 @@ dependencies = [ "winapi 0.3.9", ] +[[package]] +name = "renderdoc-sys" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1382d1f0a252c4bf97dc20d979a2fdd05b024acd7c2ed0f7595d7817666a157" + [[package]] name = "roc_build" version = "0.1.0" @@ -3450,6 +3492,15 @@ dependencies = [ "smallvec", ] +[[package]] +name = "rose_tree" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "284de9dae38774e2813aaabd7e947b4a6fe9b8c58c2309f754a487cdd50de1c2" +dependencies = [ + "petgraph", +] + [[package]] name = "rustc-demangle" version = "0.1.19" @@ -4364,9 +4415,9 @@ dependencies = [ [[package]] name = "wgpu" -version = "0.8.1" +version = "0.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "215fd50e66f794bd16683e7e0e0b9b53be265eb10fdf02276caf5de3e5743fcf" +checksum = "bd247f8b26fd3d42ef2f320d378025cd6e84d782ef749fab45cc3b981fbe3275" dependencies = [ "arrayvec", "js-sys", @@ -4384,9 +4435,9 @@ dependencies = [ [[package]] name = "wgpu-core" -version = "0.8.1" +version = "0.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1d56c368fc0e6f3927c711d2b55a51ad4321218efc0239c4acf69e456ab70399" +checksum = "2af5c8acd3ae5781a277cdf65a17f3a7135de5ae782775620e74ea16c9d47770" dependencies = [ "arrayvec", "bitflags", @@ -4414,18 +4465,18 @@ dependencies = [ [[package]] name = "wgpu-types" -version = "0.8.0" +version = "0.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "aa248d90c8e6832269b8955bf800e8241f942c25e18a235b7752226804d21556" +checksum = "4f5c9678cd533558e28b416d66947b099742df1939307478db54f867137f1b60" dependencies = [ "bitflags", ] [[package]] name = "wgpu_glyph" -version = "0.12.0" +version = "0.13.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "634570b440f4c24c2e6049ed01ec832c23d338dea3eca654d5760838017a1c8b" +checksum = "0fee8c96eda18195a7ad9989737183e0a357f14b15e98838c76abbcf56a5f970" dependencies = [ "bytemuck", "glyph_brush", diff --git a/editor/Cargo.toml b/editor/Cargo.toml index 856ca08903..1843d94132 100644 --- a/editor/Cargo.toml +++ b/editor/Cargo.toml @@ -28,13 +28,13 @@ arraystring = "0.3.0" libc = "0.2" page_size = "0.4" winit = "0.24" -wgpu = "0.8" +wgpu = "0.9" glyph_brush = "0.7" log = "0.4" zerocopy = "0.3" env_logger = "0.8" futures = "0.3" -wgpu_glyph = "0.12" +wgpu_glyph = "0.13" cgmath = "0.18.0" snafu = { version = "0.6", features = ["backtraces"] } colored = "2" diff --git a/editor/editor-ideas.md b/editor/editor-ideas.md index 9e7e6a3ef6..4c47762cc9 100644 --- a/editor/editor-ideas.md +++ b/editor/editor-ideas.md @@ -70,6 +70,7 @@ e.g. you have a test `calculate_sum_test` that only uses the function `add`, whe * [Lamdu](http://www.lamdu.org/) live functional programming. * [Sourcetrail](https://www.sourcetrail.com/) nice tree-like source explorer. * [Unisonweb](https://www.unisonweb.org), definition based [editor](https://twitter.com/shojberg/status/1364666092598288385) as opposed to file based. +* [Utopia](https://utopia.app/) integrated design and development environment for React. Design and code update each other, in real time. ### Voice Interaction Related From fd9b826398e4d019d36569dcaead51bca24f4dcc Mon Sep 17 00:00:00 2001 From: Folkert Date: Fri, 25 Jun 2021 22:27:11 +0200 Subject: [PATCH 378/496] fix the issues --- compiler/gen_llvm/src/llvm/bitcode.rs | 20 ++++- compiler/gen_llvm/src/llvm/build.rs | 99 +++++++++++++++++------ compiler/gen_llvm/src/llvm/build_list.rs | 5 +- compiler/gen_llvm/src/llvm/convert.rs | 46 ----------- compiler/gen_llvm/src/llvm/refcounting.rs | 4 +- compiler/test_gen/src/gen_tags.rs | 6 +- 6 files changed, 100 insertions(+), 80 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/bitcode.rs b/compiler/gen_llvm/src/llvm/bitcode.rs index 6dfb4ab929..a2c9f5f079 100644 --- a/compiler/gen_llvm/src/llvm/bitcode.rs +++ b/compiler/gen_llvm/src/llvm/bitcode.rs @@ -1,6 +1,6 @@ /// Helpers for interacting with the zig that generates bitcode use crate::debug_info_init; -use crate::llvm::build::{struct_from_fields, Env, C_CALL_CONV, FAST_CALL_CONV}; +use crate::llvm::build::{struct_from_fields, Env, C_CALL_CONV, FAST_CALL_CONV, TAG_DATA_INDEX}; use crate::llvm::convert::basic_type_from_layout; use crate::llvm::refcounting::{ decrement_refcount_layout, increment_n_refcount_layout, increment_refcount_layout, @@ -155,7 +155,23 @@ fn build_has_tag_id_help<'a, 'ctx, 'env>( "compare", ); - let field_vals = [(0, answer.into()), (1, *tag_value_ptr)]; + let tag_data_ptr = { + let data_index = env + .context + .i64_type() + .const_int(TAG_DATA_INDEX as u64, false); + + let ptr = unsafe { + env.builder.build_gep( + tag_value_ptr.into_pointer_value(), + &[data_index], + "get_data_ptr", + ) + }; + env.builder.build_bitcast(ptr, i8_ptr_type, "to_opaque") + }; + + let field_vals = [(0, answer.into()), (1, tag_data_ptr)]; let output = struct_from_fields(env, output_type, field_vals.iter().copied()); diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index adee398ef8..853bd7daf3 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -19,8 +19,8 @@ use crate::llvm::build_str::{ }; use crate::llvm::compare::{generic_eq, generic_neq}; use crate::llvm::convert::{ - basic_type_from_builtin, basic_type_from_layout, basic_type_from_layout_old, block_of_memory, - block_of_memory_slices, ptr_int, + basic_type_from_builtin, basic_type_from_layout, block_of_memory, block_of_memory_slices, + ptr_int, }; use crate::llvm::refcounting::{ decrement_refcount_layout, increment_refcount_layout, PointerToRefcount, @@ -946,7 +946,6 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( Struct(sorted_fields) => { let ctx = env.context; - let builder = env.builder; // Determine types let num_fields = sorted_fields.len(); @@ -1068,8 +1067,6 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( tag_id, .. } => { - let tag_layout = Layout::Union(UnionLayout::NonRecursive(fields)); - debug_assert!(*union_size > 1); let ctx = env.context; @@ -1113,7 +1110,22 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( } // Create the struct_type - let data_ptr = reserve_with_refcount(env, &tag_layout); + let basic_type = block_of_memory_slices(env.context, fields, env.ptr_bytes); + + let stack_size = fields + .iter() + .map(|tag| tag.iter().map(|l| l.stack_size(env.ptr_bytes)).sum()) + .max() + .unwrap_or(0); + + let alignment_bytes = fields + .iter() + .map(|tag| tag.iter().map(|l| l.alignment_bytes(env.ptr_bytes))) + .flatten() + .max() + .unwrap_or(0); + + let data_ptr = reserve_with_refcount_help(env, basic_type, stack_size, alignment_bytes); let struct_type = ctx.struct_type(field_types.into_bump_slice(), false); let struct_ptr = env .builder @@ -1147,9 +1159,6 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( debug_assert_eq!(*tag_id, 0); debug_assert_eq!(arguments.len(), fields.len()); - let struct_layout = - Layout::Union(UnionLayout::NonRecursive(env.arena.alloc([*fields]))); - let ctx = env.context; let builder = env.builder; @@ -1188,7 +1197,14 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( } // Create the struct_type - let data_ptr = reserve_with_refcount(env, &struct_layout); + let basic_type = block_of_memory_slices(env.context, &[*fields], env.ptr_bytes); + + // layout we abuse to get the right stack size and alignment + let false_layout = Layout::Struct(fields); + let stack_size = false_layout.stack_size(env.ptr_bytes); + let alignment_bytes = false_layout.alignment_bytes(env.ptr_bytes); + let data_ptr = reserve_with_refcount_help(env, basic_type, stack_size, alignment_bytes); + let struct_type = ctx.struct_type(field_types.into_bump_slice(), false); let struct_ptr = env .builder @@ -1222,8 +1238,7 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( tag_id, .. } => { - let tag_layout = Layout::Union(UnionLayout::NonRecursive(fields)); - let tag_struct_type = basic_type_from_layout(env, &tag_layout); + let tag_struct_type = block_of_memory_slices(env.context, fields, env.ptr_bytes); if *tag_id == *nullable_id as u8 { let output_type = tag_struct_type.ptr_type(AddressSpace::Generic); @@ -1280,7 +1295,22 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( } // Create the struct_type - let data_ptr = reserve_with_refcount(env, &tag_layout); + let basic_type = block_of_memory_slices(env.context, fields, env.ptr_bytes); + + let stack_size = fields + .iter() + .map(|tag| tag.iter().map(|l| l.stack_size(env.ptr_bytes)).sum()) + .max() + .unwrap_or(0); + + let alignment_bytes = fields + .iter() + .map(|tag| tag.iter().map(|l| l.alignment_bytes(env.ptr_bytes))) + .flatten() + .max() + .unwrap_or(0); + + let data_ptr = reserve_with_refcount_help(env, basic_type, stack_size, alignment_bytes); let struct_type = ctx.struct_type(field_types.into_bump_slice(), false); let struct_ptr = env .builder @@ -1379,10 +1409,11 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( } // Create the struct_type - let data_ptr = reserve_with_refcount( - env, - &Layout::Union(UnionLayout::NonRecursive(&[other_fields])), - ); + let basic_type = block_of_memory_slices(env.context, &[other_fields], env.ptr_bytes); + let false_layout = Layout::Struct(other_fields); + let stack_size = false_layout.stack_size(env.ptr_bytes); + let alignment_bytes = false_layout.alignment_bytes(env.ptr_bytes); + let data_ptr = reserve_with_refcount_help(env, basic_type, stack_size, alignment_bytes); let struct_type = ctx.struct_type(field_types.into_bump_slice(), false); let struct_ptr = env @@ -1714,17 +1745,30 @@ fn lookup_at_index_ptr<'a, 'ctx, 'env>( pub fn reserve_with_refcount<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, layout: &Layout<'a>, +) -> PointerValue<'ctx> { + let stack_size = layout.stack_size(env.ptr_bytes); + let alignment_bytes = layout.alignment_bytes(env.ptr_bytes); + + let basic_type = basic_type_from_layout(env, layout); + + reserve_with_refcount_help(env, basic_type, stack_size, alignment_bytes) +} + +fn reserve_with_refcount_help<'a, 'ctx, 'env>( + env: &Env<'a, 'ctx, 'env>, + basic_type: impl BasicType<'ctx>, + stack_size: u32, + alignment_bytes: u32, ) -> PointerValue<'ctx> { let ctx = env.context; let len_type = env.ptr_int(); - let value_bytes = layout.stack_size(env.ptr_bytes); - let value_bytes_intvalue = len_type.const_int(value_bytes as u64, false); + let value_bytes_intvalue = len_type.const_int(stack_size as u64, false); let rc1 = crate::llvm::refcounting::refcount_1(ctx, env.ptr_bytes); - allocate_with_refcount_help(env, layout, value_bytes_intvalue, rc1) + allocate_with_refcount_help(env, basic_type, alignment_bytes, value_bytes_intvalue, rc1) } pub fn allocate_with_refcount<'a, 'ctx, 'env>( @@ -1742,17 +1786,17 @@ pub fn allocate_with_refcount<'a, 'ctx, 'env>( pub fn allocate_with_refcount_help<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, - layout: &Layout<'a>, + value_type: impl BasicType<'ctx>, + alignment_bytes: u32, number_of_data_bytes: IntValue<'ctx>, initial_refcount: IntValue<'ctx>, ) -> PointerValue<'ctx> { let builder = env.builder; let ctx = env.context; - let value_type = basic_type_from_layout_old(env, layout); let len_type = env.ptr_int(); - let extra_bytes = layout.alignment_bytes(env.ptr_bytes).max(env.ptr_bytes); + let extra_bytes = alignment_bytes.max(env.ptr_bytes); let ptr = { // number of bytes we will allocated @@ -1762,7 +1806,7 @@ pub fn allocate_with_refcount_help<'a, 'ctx, 'env>( "add_extra_bytes", ); - env.call_alloc(number_of_bytes, layout.alignment_bytes(env.ptr_bytes)) + env.call_alloc(number_of_bytes, alignment_bytes) }; // We must return a pointer to the first element: @@ -2640,6 +2684,13 @@ fn build_switch_ir<'a, 'ctx, 'env>( Layout::Union(variant) => { cond_layout = Layout::Builtin(Builtin::Int64); + /* + cond_layout = match variant { + UnionLayout::NonRecursive(_) => Layout::Builtin(Builtin::Int16), + _ => Layout::Builtin(Builtin::Int64), + }; + */ + extract_tag_discriminant(env, parent, variant, cond_value) } Layout::Builtin(_) => cond_value.into_int_value(), diff --git a/compiler/gen_llvm/src/llvm/build_list.rs b/compiler/gen_llvm/src/llvm/build_list.rs index f3e1dcc465..d1209a4937 100644 --- a/compiler/gen_llvm/src/llvm/build_list.rs +++ b/compiler/gen_llvm/src/llvm/build_list.rs @@ -741,7 +741,6 @@ pub fn list_map<'a, 'ctx, 'env>( element_layout: &Layout<'a>, return_layout: &Layout<'a>, ) -> BasicValueEnum<'ctx> { - dbg!(return_layout, layout_width(env, return_layout)); call_bitcode_fn_returns_list( env, &[ @@ -1114,7 +1113,9 @@ pub fn allocate_list<'a, 'ctx, 'env>( // we assume that the list is indeed used (dead variables are eliminated) let rc1 = crate::llvm::refcounting::refcount_1(ctx, env.ptr_bytes); - allocate_with_refcount_help(env, elem_layout, number_of_data_bytes, rc1) + let basic_type = basic_type_from_layout(env, elem_layout); + let alignment_bytes = elem_layout.alignment_bytes(env.ptr_bytes); + allocate_with_refcount_help(env, basic_type, alignment_bytes, number_of_data_bytes, rc1) } pub fn store_list<'a, 'ctx, 'env>( diff --git a/compiler/gen_llvm/src/llvm/convert.rs b/compiler/gen_llvm/src/llvm/convert.rs index acc93a9bf8..7665763f67 100644 --- a/compiler/gen_llvm/src/llvm/convert.rs +++ b/compiler/gen_llvm/src/llvm/convert.rs @@ -71,52 +71,6 @@ pub fn basic_type_from_layout<'a, 'ctx, 'env>( } } -pub fn basic_type_from_layout_old<'a, 'ctx, 'env>( - env: &crate::llvm::build::Env<'a, 'ctx, 'env>, - layout: &Layout<'_>, -) -> BasicTypeEnum<'ctx> { - use Layout::*; - - match layout { - Closure(_args, closure_layout, _ret_layout) => { - let closure_data_layout = closure_layout.runtime_representation(); - basic_type_from_layout(env, &closure_data_layout) - } - Struct(sorted_fields) => basic_type_from_record(env, sorted_fields), - Union(variant) => { - use UnionLayout::*; - match variant { - Recursive(tags) - | NullableWrapped { - other_tags: tags, .. - } => { - let block = block_of_memory_slices(env.context, tags, env.ptr_bytes); - block.ptr_type(AddressSpace::Generic).into() - } - NullableUnwrapped { other_fields, .. } => { - let block = - block_of_memory_slices(env.context, &[&other_fields[1..]], env.ptr_bytes); - block.ptr_type(AddressSpace::Generic).into() - } - NonNullableUnwrapped(fields) => { - let block = block_of_memory_slices(env.context, &[fields], env.ptr_bytes); - block.ptr_type(AddressSpace::Generic).into() - } - NonRecursive(_) => block_of_memory(env.context, layout, env.ptr_bytes), - } - } - RecursivePointer => { - // TODO make this dynamic - env.context - .i64_type() - .ptr_type(AddressSpace::Generic) - .as_basic_type_enum() - } - - Builtin(builtin) => basic_type_from_builtin(env, builtin), - } -} - pub fn basic_type_from_builtin<'a, 'ctx, 'env>( env: &crate::llvm::build::Env<'a, 'ctx, 'env>, builtin: &Builtin<'_>, diff --git a/compiler/gen_llvm/src/llvm/refcounting.rs b/compiler/gen_llvm/src/llvm/refcounting.rs index 83240e762d..79b029e7e3 100644 --- a/compiler/gen_llvm/src/llvm/refcounting.rs +++ b/compiler/gen_llvm/src/llvm/refcounting.rs @@ -4,9 +4,7 @@ use crate::llvm::build::{ LLVM_SADD_WITH_OVERFLOW_I64, TAG_DATA_INDEX, TAG_ID_INDEX, }; use crate::llvm::build_list::{incrementing_elem_loop, list_len, load_list}; -use crate::llvm::convert::{ - basic_type_from_layout, block_of_memory, block_of_memory_slices, ptr_int, -}; +use crate::llvm::convert::{basic_type_from_layout, block_of_memory_slices, ptr_int}; use bumpalo::collections::Vec; use inkwell::basic_block::BasicBlock; use inkwell::context::Context; diff --git a/compiler/test_gen/src/gen_tags.rs b/compiler/test_gen/src/gen_tags.rs index 03c4abbd05..b75fb4eb42 100644 --- a/compiler/test_gen/src/gen_tags.rs +++ b/compiler/test_gen/src/gen_tags.rs @@ -1007,10 +1007,10 @@ fn applied_tag_function_result() { "# ), RocList::from_slice(&[ - (1, RocStr::from_slice("a".as_bytes())), - (1, RocStr::from_slice("b".as_bytes())) + (RocStr::from_slice("a".as_bytes())), + (RocStr::from_slice("b".as_bytes())) ]), - RocList<(i64, RocStr)> + RocList ); } From 32dcd96f80cd01264993d77bb1e593fd5d5e4c23 Mon Sep 17 00:00:00 2001 From: Folkert Date: Fri, 25 Jun 2021 22:33:29 +0200 Subject: [PATCH 379/496] extract duplicated logic --- compiler/gen_llvm/src/llvm/build.rs | 52 ++++++++++++++--------------- 1 file changed, 25 insertions(+), 27 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 853bd7daf3..63c0b1d091 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -1110,22 +1110,8 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( } // Create the struct_type - let basic_type = block_of_memory_slices(env.context, fields, env.ptr_bytes); + let data_ptr = reserve_with_refcount_union_as_block_of_memory(env, fields); - let stack_size = fields - .iter() - .map(|tag| tag.iter().map(|l| l.stack_size(env.ptr_bytes)).sum()) - .max() - .unwrap_or(0); - - let alignment_bytes = fields - .iter() - .map(|tag| tag.iter().map(|l| l.alignment_bytes(env.ptr_bytes))) - .flatten() - .max() - .unwrap_or(0); - - let data_ptr = reserve_with_refcount_help(env, basic_type, stack_size, alignment_bytes); let struct_type = ctx.struct_type(field_types.into_bump_slice(), false); let struct_ptr = env .builder @@ -1197,13 +1183,7 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( } // Create the struct_type - let basic_type = block_of_memory_slices(env.context, &[*fields], env.ptr_bytes); - - // layout we abuse to get the right stack size and alignment - let false_layout = Layout::Struct(fields); - let stack_size = false_layout.stack_size(env.ptr_bytes); - let alignment_bytes = false_layout.alignment_bytes(env.ptr_bytes); - let data_ptr = reserve_with_refcount_help(env, basic_type, stack_size, alignment_bytes); + let data_ptr = reserve_with_refcount_union_as_block_of_memory(env, &[fields]); let struct_type = ctx.struct_type(field_types.into_bump_slice(), false); let struct_ptr = env @@ -1409,11 +1389,7 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( } // Create the struct_type - let basic_type = block_of_memory_slices(env.context, &[other_fields], env.ptr_bytes); - let false_layout = Layout::Struct(other_fields); - let stack_size = false_layout.stack_size(env.ptr_bytes); - let alignment_bytes = false_layout.alignment_bytes(env.ptr_bytes); - let data_ptr = reserve_with_refcount_help(env, basic_type, stack_size, alignment_bytes); + let data_ptr = reserve_with_refcount_union_as_block_of_memory(env, &[other_fields]); let struct_type = ctx.struct_type(field_types.into_bump_slice(), false); let struct_ptr = env @@ -1754,6 +1730,28 @@ pub fn reserve_with_refcount<'a, 'ctx, 'env>( reserve_with_refcount_help(env, basic_type, stack_size, alignment_bytes) } +fn reserve_with_refcount_union_as_block_of_memory<'a, 'ctx, 'env>( + env: &Env<'a, 'ctx, 'env>, + fields: &[&[Layout<'a>]], +) -> PointerValue<'ctx> { + let basic_type = block_of_memory_slices(env.context, fields, env.ptr_bytes); + + let stack_size = fields + .iter() + .map(|tag| tag.iter().map(|l| l.stack_size(env.ptr_bytes)).sum()) + .max() + .unwrap_or(0); + + let alignment_bytes = fields + .iter() + .map(|tag| tag.iter().map(|l| l.alignment_bytes(env.ptr_bytes))) + .flatten() + .max() + .unwrap_or(0); + + reserve_with_refcount_help(env, basic_type, stack_size, alignment_bytes) +} + fn reserve_with_refcount_help<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, basic_type: impl BasicType<'ctx>, From e2a3e6792d7e4460b64d1a68eece3aced78a043a Mon Sep 17 00:00:00 2001 From: Folkert Date: Fri, 25 Jun 2021 22:37:30 +0200 Subject: [PATCH 380/496] add assert --- compiler/gen_llvm/src/llvm/bitcode.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/compiler/gen_llvm/src/llvm/bitcode.rs b/compiler/gen_llvm/src/llvm/bitcode.rs index a2c9f5f079..f5c890cb50 100644 --- a/compiler/gen_llvm/src/llvm/bitcode.rs +++ b/compiler/gen_llvm/src/llvm/bitcode.rs @@ -73,6 +73,9 @@ pub fn build_has_tag_id<'a, 'ctx, 'env>( ) -> FunctionValue<'ctx> { let fn_name: &str = &format!("{}_has_tag_id", function.get_name().to_string_lossy()); + // currently the code assumes we're dealing with a non-recursive layout + debug_assert!(matches!(union_layout, UnionLayout::NonRecursive(_))); + match env.module.get_function(fn_name) { Some(function_value) => function_value, None => build_has_tag_id_help(env, union_layout, &fn_name), From 6e150b57f1ca507a25b4b3311d4e638698fb8c17 Mon Sep 17 00:00:00 2001 From: Folkert Date: Fri, 25 Jun 2021 22:53:36 +0200 Subject: [PATCH 381/496] cleanup --- compiler/gen_llvm/src/llvm/build.rs | 24 +----------------------- 1 file changed, 1 insertion(+), 23 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 63c0b1d091..eb8e17bc1e 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -1057,7 +1057,6 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( (TAG_DATA_INDEX as usize, data), ]; - // cast_tag_to_block_of_memory(builder, struct_val, internal_type) struct_from_fields(env, wrapper_type, field_vals.iter().copied()).into() } Tag { @@ -1275,22 +1274,8 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( } // Create the struct_type - let basic_type = block_of_memory_slices(env.context, fields, env.ptr_bytes); + let data_ptr = reserve_with_refcount_union_as_block_of_memory(env, fields); - let stack_size = fields - .iter() - .map(|tag| tag.iter().map(|l| l.stack_size(env.ptr_bytes)).sum()) - .max() - .unwrap_or(0); - - let alignment_bytes = fields - .iter() - .map(|tag| tag.iter().map(|l| l.alignment_bytes(env.ptr_bytes))) - .flatten() - .max() - .unwrap_or(0); - - let data_ptr = reserve_with_refcount_help(env, basic_type, stack_size, alignment_bytes); let struct_type = ctx.struct_type(field_types.into_bump_slice(), false); let struct_ptr = env .builder @@ -2682,13 +2667,6 @@ fn build_switch_ir<'a, 'ctx, 'env>( Layout::Union(variant) => { cond_layout = Layout::Builtin(Builtin::Int64); - /* - cond_layout = match variant { - UnionLayout::NonRecursive(_) => Layout::Builtin(Builtin::Int16), - _ => Layout::Builtin(Builtin::Int64), - }; - */ - extract_tag_discriminant(env, parent, variant, cond_value) } Layout::Builtin(_) => cond_value.into_int_value(), From ff2ed8a1a487ad6b6b64b7cd0c3ad1b7a8b1014a Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Sat, 26 Jun 2021 10:53:53 +0200 Subject: [PATCH 382/496] Added hazel livelit to editor inspiration --- editor/editor-ideas.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/editor/editor-ideas.md b/editor/editor-ideas.md index 4c47762cc9..51ab70dcc5 100644 --- a/editor/editor-ideas.md +++ b/editor/editor-ideas.md @@ -31,7 +31,7 @@ Nice collection of research on innovative editors, [link](https://futureofcoding * [Self](https://selflanguage.org/) programming language * [Primitive](https://primitive.io/) code exploration in Virtual Reality * [Luna](https://www.luna-lang.org/) language for interactive data processing and visualization - +* [Hazel Livelits](https://hazel.org/papers/livelits-paper.pdf) interactive plugins, see GIF's [here](https://twitter.com/disconcision/status/1408155781120376833). ### Debugging * [VS code debug visualization](https://marketplace.visualstudio.com/items?itemName=hediet.debug-visualizer) From 2aa412f836fb7d74574685506b678dfa58be787f Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Sat, 26 Jun 2021 12:14:21 +0200 Subject: [PATCH 383/496] made VarStore cloneable to make type tooltips work --- compiler/types/src/subs.rs | 2 +- editor/src/editor/mvc/ed_update.rs | 10 +++++----- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/compiler/types/src/subs.rs b/compiler/types/src/subs.rs index e66ad7fb12..e74382c50b 100644 --- a/compiler/types/src/subs.rs +++ b/compiler/types/src/subs.rs @@ -52,7 +52,7 @@ impl fmt::Debug for Subs { } } -#[derive(Debug)] +#[derive(Debug, Copy, Clone)] pub struct VarStore { next: u32, } diff --git a/editor/src/editor/mvc/ed_update.rs b/editor/src/editor/mvc/ed_update.rs index e2136f4d7c..f14da8e08a 100644 --- a/editor/src/editor/mvc/ed_update.rs +++ b/editor/src/editor/mvc/ed_update.rs @@ -176,12 +176,12 @@ impl<'a> EdModel<'a> { self.set_caret(expr_start_pos); - //let type_str = self.expr2_to_type(ast_node_id); + let type_str = self.expr2_to_type(ast_node_id); self.selected_expr_opt = Some(SelectedExpression { ast_node_id, mark_node_id, - type_str: PoolStr::new("{}", self.module.env.pool), // TODO get this PoolStr from type inference + type_str, }); self.dirty = true; @@ -243,15 +243,15 @@ impl<'a> EdModel<'a> { ); // extract the var_store out of the env again - let mut var_store = VarStore::default(); - std::mem::swap(self.module.env.var_store, &mut var_store); + //let mut var_store = VarStore::default(); + //std::mem::swap(self.module.env.var_store, &mut var_store); let (mut solved, _, _) = EdModel::run_solve( self.module.env.pool, Default::default(), Default::default(), constrained, - var_store, + *self.module.env.var_store, ); let subs = solved.inner_mut(); From 38db75614e37968d6c61e86845d667ec552c1087 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Sat, 26 Jun 2021 13:50:56 +0200 Subject: [PATCH 384/496] updated VarStore without cloning --- compiler/types/src/subs.rs | 2 +- editor/src/editor/mvc/ed_update.rs | 11 +++++++---- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/compiler/types/src/subs.rs b/compiler/types/src/subs.rs index e74382c50b..e66ad7fb12 100644 --- a/compiler/types/src/subs.rs +++ b/compiler/types/src/subs.rs @@ -52,7 +52,7 @@ impl fmt::Debug for Subs { } } -#[derive(Debug, Copy, Clone)] +#[derive(Debug)] pub struct VarStore { next: u32, } diff --git a/editor/src/editor/mvc/ed_update.rs b/editor/src/editor/mvc/ed_update.rs index f14da8e08a..5dfbb57302 100644 --- a/editor/src/editor/mvc/ed_update.rs +++ b/editor/src/editor/mvc/ed_update.rs @@ -242,18 +242,21 @@ impl<'a> EdModel<'a> { Region::zero(), ); - // extract the var_store out of the env again - //let mut var_store = VarStore::default(); - //std::mem::swap(self.module.env.var_store, &mut var_store); + // extract the var_store out of the env + let mut var_store = VarStore::default(); + std::mem::swap(self.module.env.var_store, &mut var_store); let (mut solved, _, _) = EdModel::run_solve( self.module.env.pool, Default::default(), Default::default(), constrained, - *self.module.env.var_store, + var_store, ); + // put the updated var_store back in env + std::mem::swap( &mut VarStore::new_from_subs(solved.inner()), self.module.env.var_store); + let subs = solved.inner_mut(); let content = subs.get(var).content; From 98a9dc094571b52d882af84959f7ea3d0be71004 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 26 Jun 2021 17:01:23 +0200 Subject: [PATCH 385/496] remove tag id from data bytes for non-recursive tags --- cli/src/repl/eval.rs | 42 +++++++++++++++- compiler/builtins/bitcode/src/list.zig | 20 ++++---- compiler/gen_llvm/src/llvm/bitcode.rs | 9 ++-- compiler/gen_llvm/src/llvm/build.rs | 5 +- compiler/gen_llvm/src/llvm/build_list.rs | 15 ++++++ compiler/gen_llvm/src/llvm/compare.rs | 22 ++------- compiler/mono/src/alias_analysis.rs | 4 +- compiler/mono/src/ir.rs | 48 +++++++------------ compiler/mono/src/layout.rs | 6 ++- compiler/test_gen/src/gen_hash.rs | 2 +- compiler/test_gen/src/gen_tags.rs | 32 ++++++------- compiler/test_mono/generated/has_none.txt | 3 +- compiler/test_mono/generated/ir_when_idiv.txt | 16 +++---- compiler/test_mono/generated/ir_when_just.txt | 3 +- .../test_mono/generated/ir_when_maybe.txt | 3 +- .../test_mono/generated/ir_when_these.txt | 3 +- compiler/test_mono/generated/list_get.txt | 24 +++++----- .../generated/nested_pattern_match.txt | 8 ++-- .../test_mono/generated/quicksort_swap.txt | 26 +++++----- compiler/test_mono/generated/rigids.txt | 20 ++++---- .../generated/specialize_closures.txt | 18 ++++--- .../generated/specialize_lowlevel.txt | 18 ++++--- .../test_mono/generated/when_nested_maybe.txt | 8 ++-- .../test_mono/generated/when_on_result.txt | 3 +- 24 files changed, 188 insertions(+), 170 deletions(-) diff --git a/cli/src/repl/eval.rs b/cli/src/repl/eval.rs index e0e55541c2..a8630e6634 100644 --- a/cli/src/repl/eval.rs +++ b/cli/src/repl/eval.rs @@ -214,8 +214,48 @@ fn jit_to_ast_help<'a>( match variant { NonRecursive { sorted_tag_layouts: tags_and_layouts, + } => { + Ok(run_jit_function_dynamic_type!( + lib, + main_fn_name, + size as usize, + |ptr: *const u8| { + // Because this is a `Wrapped`, the first 8 bytes encode the tag ID + let offset = tags_and_layouts + .iter() + .map(|(_, fields)| { + fields + .iter() + .map(|l| l.stack_size(env.ptr_bytes)) + .sum() + }) + .max() + .unwrap_or(0); + + let tag_id = *(ptr.add(offset as usize) as *const i64); + + // use the tag ID as an index, to get its name and layout of any arguments + let (tag_name, arg_layouts) = + &tags_and_layouts[tag_id as usize]; + + let tag_expr = tag_name_to_expr(env, tag_name); + let loc_tag_expr = + &*env.arena.alloc(Located::at_zero(tag_expr)); + + let variables = &tags[tag_name]; + + debug_assert_eq!(arg_layouts.len(), variables.len()); + + // NOTE assumes the data bytes are the first bytes + let it = variables.iter().copied().zip(arg_layouts.iter()); + let output = sequence_of_expr(env, ptr, it); + let output = output.into_bump_slice(); + + Expr::Apply(loc_tag_expr, output, CalledVia::Space) + } + )) } - | Recursive { + Recursive { sorted_tag_layouts: tags_and_layouts, } => { Ok(run_jit_function_dynamic_type!( diff --git a/compiler/builtins/bitcode/src/list.zig b/compiler/builtins/bitcode/src/list.zig index 134d4ba0d5..a45e6564dd 100644 --- a/compiler/builtins/bitcode/src/list.zig +++ b/compiler/builtins/bitcode/src/list.zig @@ -495,8 +495,7 @@ pub fn listKeepResult( // payload of the tag const answer = has_tag_id(good_constructor, temporary); if (answer.matched) { - // drop the tag id - const contents = (answer.data orelse unreachable) + @sizeOf(i64); + const contents = (answer.data orelse unreachable); @memcpy(target_ptr + (kept * after_width), contents, after_width); kept += 1; } else { @@ -620,7 +619,9 @@ pub fn listWalkUntil( accum: Opaque, alignment: u32, element_width: usize, + continue_stop_width: usize, accum_width: usize, + has_tag_id: HasTagId, dec: Dec, output: Opaque, ) callconv(.C) void { @@ -636,9 +637,10 @@ pub fn listWalkUntil( return; } - const bytes_ptr: [*]u8 = utils.alloc(TAG_WIDTH + accum_width, alignment); + const bytes_ptr: [*]u8 = utils.alloc(continue_stop_width, alignment); - @memcpy(bytes_ptr + TAG_WIDTH, accum orelse unreachable, accum_width); + // NOTE: assumes data bytes are the first bytes in a tag + @memcpy(bytes_ptr, accum orelse unreachable, accum_width); if (list.bytes) |source_ptr| { var i: usize = 0; @@ -650,10 +652,12 @@ pub fn listWalkUntil( inc_n_data(data, 1); } - caller(data, element, bytes_ptr + TAG_WIDTH, bytes_ptr); + caller(data, element, bytes_ptr, bytes_ptr); - const usizes: [*]usize = @ptrCast([*]usize, @alignCast(8, bytes_ptr)); - if (usizes[0] != 0) { + // [ Continue ..., Stop ] + const tag_id = has_tag_id(0, bytes_ptr); + + if (!tag_id.matched) { // decrement refcount of the remaining items i += 1; while (i < size) : (i += 1) { @@ -664,7 +668,7 @@ pub fn listWalkUntil( } } - @memcpy(output orelse unreachable, bytes_ptr + TAG_WIDTH, accum_width); + @memcpy(output orelse unreachable, bytes_ptr, accum_width); utils.dealloc(bytes_ptr, alignment); } diff --git a/compiler/gen_llvm/src/llvm/bitcode.rs b/compiler/gen_llvm/src/llvm/bitcode.rs index f5c890cb50..6c662d9c4d 100644 --- a/compiler/gen_llvm/src/llvm/bitcode.rs +++ b/compiler/gen_llvm/src/llvm/bitcode.rs @@ -140,12 +140,9 @@ fn build_has_tag_id_help<'a, 'ctx, 'env>( let tag_value = env.builder.build_load(argument_cast, "get_value"); let actual_tag_id = { - let tag_id_i64 = crate::llvm::build::extract_tag_discriminant( - env, - function_value, - union_layout, - tag_value, - ); + let tag_id_i64 = + crate::llvm::build::get_tag_id(env, function_value, &union_layout, tag_value) + .into_int_value(); env.builder .build_int_cast(tag_id_i64, env.context.i16_type(), "to_i16") diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index eb8e17bc1e..3de976c3f0 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -1479,6 +1479,8 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( match union_layout { UnionLayout::NonRecursive(tag_layouts) => { + let index = *index - 1; + debug_assert!(argument.is_struct_value()); let field_layouts = tag_layouts[*tag_id as usize]; let struct_layout = Layout::Struct(field_layouts); @@ -1492,7 +1494,7 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( ); let result = builder - .build_extract_value(struct_value, *index as u32, "") + .build_extract_value(struct_value, index as u32, "") .expect("desired field did not decode"); result @@ -3841,6 +3843,7 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>( env, layout_ids, roc_function_call, + result_layout, list, element_layout, default, diff --git a/compiler/gen_llvm/src/llvm/build_list.rs b/compiler/gen_llvm/src/llvm/build_list.rs index d1209a4937..a6b6456557 100644 --- a/compiler/gen_llvm/src/llvm/build_list.rs +++ b/compiler/gen_llvm/src/llvm/build_list.rs @@ -417,6 +417,7 @@ pub fn list_walk_generic<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, layout_ids: &mut LayoutIds<'a>, roc_function_call: RocFunctionCall<'ctx>, + function_call_return_layout: &Layout<'a>, list: BasicValueEnum<'ctx>, element_layout: &Layout<'a>, default: BasicValueEnum<'ctx>, @@ -457,6 +458,18 @@ pub fn list_walk_generic<'a, 'ctx, 'env>( ); } ListWalk::WalkUntil | ListWalk::WalkBackwardsUntil => { + let function = env + .builder + .get_insert_block() + .unwrap() + .get_parent() + .unwrap(); + + let has_tag_id = match function_call_return_layout { + Layout::Union(union_layout) => build_has_tag_id(env, function, *union_layout), + _ => unreachable!(), + }; + let dec_element_fn = build_dec_wrapper(env, layout_ids, element_layout); call_void_bitcode_fn( env, @@ -469,7 +482,9 @@ pub fn list_walk_generic<'a, 'ctx, 'env>( pass_as_opaque(env, default_ptr), env.alignment_intvalue(&element_layout), layout_width(env, element_layout), + layout_width(env, function_call_return_layout), layout_width(env, default_layout), + has_tag_id.as_global_value().as_pointer_value().into(), dec_element_fn.as_global_value().as_pointer_value().into(), pass_as_opaque(env, result_ptr), ], diff --git a/compiler/gen_llvm/src/llvm/compare.rs b/compiler/gen_llvm/src/llvm/compare.rs index 8b1758eaf5..eac43ba889 100644 --- a/compiler/gen_llvm/src/llvm/compare.rs +++ b/compiler/gen_llvm/src/llvm/compare.rs @@ -1,5 +1,5 @@ use crate::llvm::build::Env; -use crate::llvm::build::{cast_block_of_memory_to_tag, complex_bitcast, FAST_CALL_CONV}; +use crate::llvm::build::{cast_block_of_memory_to_tag, FAST_CALL_CONV}; use crate::llvm::build_list::{list_len, load_list_ptr}; use crate::llvm::build_str::str_equal; use crate::llvm::convert::basic_type_from_layout; @@ -846,9 +846,10 @@ fn build_tag_eq_help<'a, 'ctx, 'env>( match union_layout { NonRecursive(tags) => { - // SAFETY we know that non-recursive tags cannot be NULL - let id1 = nonrec_tag_id(env, tag1.into_struct_value()); - let id2 = nonrec_tag_id(env, tag2.into_struct_value()); + let id1 = + crate::llvm::build::get_tag_id(env, parent, union_layout, tag1).into_int_value(); + let id2 = + crate::llvm::build::get_tag_id(env, parent, union_layout, tag2).into_int_value(); let compare_tag_fields = ctx.append_basic_block(parent, "compare_tag_fields"); @@ -1212,19 +1213,6 @@ fn eq_ptr_to_struct<'a, 'ctx, 'env>( .into_int_value() } -fn nonrec_tag_id<'a, 'ctx, 'env>( - env: &Env<'a, 'ctx, 'env>, - tag: StructValue<'ctx>, -) -> IntValue<'ctx> { - complex_bitcast( - env.builder, - tag.into(), - env.context.i64_type().into(), - "load_tag_id", - ) - .into_int_value() -} - unsafe fn rec_tag_id_unsafe<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, tag: PointerValue<'ctx>, diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 5a59917ed8..7ef8bd40c2 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -861,11 +861,13 @@ fn expr_spec( union_layout, } => match union_layout { UnionLayout::NonRecursive(_) => { + // let index = (*index - 1) as u32; + let index = (*index - 1) as u32; let tag_value_id = env.symbols[structure]; let tuple_value_id = builder.add_unwrap_union(block, tag_value_id, *tag_id as u32)?; - builder.add_get_tuple_field(block, tuple_value_id, *index as u32) + builder.add_get_tuple_field(block, tuple_value_id, index) } _ => { // for the moment recursive tag unions don't quite work diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 6a384f61c8..045845e473 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -2083,18 +2083,16 @@ fn specialize_external<'a>( tag_id, .. } => { - debug_assert_eq!(field_layouts.len() - 1, captured.len()); - // TODO check for field_layouts.len() == 1 and do a rename in that case? - for (mut index, (symbol, _variable)) in captured.iter().enumerate() { - // the field layouts do store the tag, but the tag value is - // not captured. So we drop the layout of the tag ID here - index += 1; + debug_assert!(matches!(union_layout, UnionLayout::NonRecursive(_))); + debug_assert_eq!(field_layouts.len(), captured.len()); - // TODO therefore should the wrapped here not be RecordOrSingleTagUnion? + for (index, (symbol, _variable)) in captured.iter().enumerate() { let expr = Expr::UnionAtIndex { tag_id, structure: Symbol::ARG_CLOSURE, - index: index as _, + // union at index still expects the index to be +1; it thinks + // the tag id is stored + index: index as u64 + 1, union_layout, }; @@ -4037,29 +4035,20 @@ fn construct_closure_data<'a>( tag_name, union_layout, } => { - let tag_id_symbol = env.unique_symbol(); - let mut tag_symbols = Vec::with_capacity_in(symbols.len() + 1, env.arena); - tag_symbols.push(tag_id_symbol); - tag_symbols.extend(symbols); - - let expr1 = Expr::Literal(Literal::Int(tag_id as i128)); - let expr2 = Expr::Tag { + let expr = Expr::Tag { tag_id, tag_layout: union_layout, union_size, tag_name, - arguments: tag_symbols.into_bump_slice(), + arguments: symbols, }; - let hole = Stmt::Let( + Stmt::Let( assigned, - expr2, + expr, lambda_set.runtime_representation(), env.arena.alloc(hole), - ); - - let hole = env.arena.alloc(hole); - Stmt::Let(tag_id_symbol, expr1, Layout::Builtin(Builtin::Int64), hole) + ) } ClosureRepresentation::Other(Layout::Struct(field_layouts)) => { debug_assert_eq!(field_layouts.len(), symbols.len()); @@ -4251,12 +4240,10 @@ fn convert_tag_union<'a>( (tag, Layout::Union(union_layout)) } NonRecursive { sorted_tag_layouts } => { - let tag_id_symbol = env.unique_symbol(); - opt_tag_id_symbol = Some(tag_id_symbol); + opt_tag_id_symbol = None; field_symbols = { - let mut temp = Vec::with_capacity_in(field_symbols_temp.len() + 1, arena); - temp.push(tag_id_symbol); + let mut temp = Vec::with_capacity_in(field_symbols_temp.len(), arena); temp.extend(field_symbols_temp.iter().map(|r| r.1)); @@ -7086,8 +7073,7 @@ fn from_can_pattern_help<'a>( ctors.push(Ctor { tag_id: TagId(i as u8), name: tag_name.clone(), - // don't include tag discriminant in arity - arity: args.len() - 1, + arity: args.len(), }) } @@ -7100,13 +7086,13 @@ fn from_can_pattern_help<'a>( debug_assert_eq!( arguments.len(), - argument_layouts[1..].len(), + argument_layouts.len(), "The {:?} tag got {} arguments, but its layout expects {}!", tag_name, arguments.len(), - argument_layouts[1..].len(), + argument_layouts.len(), ); - let it = argument_layouts[1..].iter(); + let it = argument_layouts.iter(); for ((_, loc_pat), layout) in arguments.iter().zip(it) { mono_args.push(( diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index 06bf3be426..ef3e8f1dd9 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -109,6 +109,8 @@ impl<'a> UnionLayout<'a> { pub fn layout_at(self, tag_id: u8, index: usize) -> Layout<'a> { let result = match self { UnionLayout::NonRecursive(tag_layouts) => { + let index = index - 1; + let field_layouts = tag_layouts[tag_id as usize]; // this cannot be recursive; return immediately @@ -1583,7 +1585,9 @@ pub fn union_sorted_tags_help<'a>( let mut arg_layouts = Vec::with_capacity_in(arguments.len() + 1, arena); // add the tag discriminant (size currently always hardcoded to i64) - arg_layouts.push(Layout::Builtin(TAG_SIZE)); + if is_recursive { + arg_layouts.push(Layout::Builtin(TAG_SIZE)); + } for var in arguments { match Layout::from_var(&mut env, var) { diff --git a/compiler/test_gen/src/gen_hash.rs b/compiler/test_gen/src/gen_hash.rs index 45614a033f..275a862881 100644 --- a/compiler/test_gen/src/gen_hash.rs +++ b/compiler/test_gen/src/gen_hash.rs @@ -37,7 +37,7 @@ fn hash_record() { fn hash_result() { assert_evals_to!( "Dict.hashTestOnly 0 (List.get [ 0x1 ] 0) ", - 2878521786781103245, + 10806428154792634888, u64 ); } diff --git a/compiler/test_gen/src/gen_tags.rs b/compiler/test_gen/src/gen_tags.rs index b75fb4eb42..d4cf0b0dad 100644 --- a/compiler/test_gen/src/gen_tags.rs +++ b/compiler/test_gen/src/gen_tags.rs @@ -19,8 +19,8 @@ fn applied_tag_nothing_ir() { "# ), 1, - (i64, i64), - |(tag, _)| tag + (i64, u8), + |(_, tag)| tag ); } @@ -38,8 +38,8 @@ fn applied_tag_nothing() { "# ), 1, - (i64, i64), - |(tag, _)| tag + (i64, u8), + |(_, tag)| tag ); } @@ -56,8 +56,8 @@ fn applied_tag_just() { y "# ), - (0, 0x4), - (i64, i64) + (0x4, 0), + (i64, u8) ); } @@ -74,8 +74,8 @@ fn applied_tag_just_ir() { y "# ), - (0, 0x4), - (i64, i64) + (0x4, 0), + (i64, u8) ); } @@ -96,8 +96,8 @@ fn applied_tag_just_enum() { y "# ), - (0, 2), - (i64, u8) + (2, 0), + (u8, u8) ); } @@ -633,8 +633,8 @@ fn nested_tag_union() { x "# ), - (0, (0, 41)), - (i64, (i64, i64)) + ((41, 0), 0), + ((i64, i64), i64) ); } #[test] @@ -805,8 +805,8 @@ fn alignment_in_multi_tag_construction() { #" ), - (1, 32i64, true), - (i64, i64, bool) + (32i64, true, 1), + (i64, bool, i64) ); assert_evals_to!( @@ -818,8 +818,8 @@ fn alignment_in_multi_tag_construction() { x #" ), - (1, 32i64, true, 2u8), - (i64, i64, bool, u8) + (32i64, true, 2u8, 1), + (i64, bool, u8, i64) ); } diff --git a/compiler/test_mono/generated/has_none.txt b/compiler/test_mono/generated/has_none.txt index cc473d1161..6c4861c73a 100644 --- a/compiler/test_mono/generated/has_none.txt +++ b/compiler/test_mono/generated/has_none.txt @@ -22,9 +22,8 @@ procedure Test.3 (Test.4): procedure Test.0 (): let Test.28 = 0i64; - let Test.31 = 0i64; let Test.30 = 3i64; - let Test.26 = Just Test.31 Test.30; + let Test.26 = Just Test.30; let Test.29 = 1i64; let Test.27 = Nil Test.29; let Test.12 = Cons Test.28 Test.26 Test.27; diff --git a/compiler/test_mono/generated/ir_when_idiv.txt b/compiler/test_mono/generated/ir_when_idiv.txt index 9da6a42067..affcb522b5 100644 --- a/compiler/test_mono/generated/ir_when_idiv.txt +++ b/compiler/test_mono/generated/ir_when_idiv.txt @@ -1,15 +1,13 @@ procedure Num.42 (#Attr.2, #Attr.3): - let Test.17 = 0i64; - let Test.13 = lowlevel NotEq #Attr.3 Test.17; - if Test.13 then - let Test.16 = 1i64; - let Test.15 = lowlevel NumDivUnchecked #Attr.2 #Attr.3; - let Test.14 = Ok Test.16 Test.15; - ret Test.14; + let Test.15 = 0i64; + let Test.12 = lowlevel NotEq #Attr.3 Test.15; + if Test.12 then + let Test.14 = lowlevel NumDivUnchecked #Attr.2 #Attr.3; + let Test.13 = Ok Test.14; + ret Test.13; else - let Test.12 = 0i64; let Test.11 = Struct {}; - let Test.10 = Err Test.12 Test.11; + let Test.10 = Err Test.11; ret Test.10; procedure Test.0 (): diff --git a/compiler/test_mono/generated/ir_when_just.txt b/compiler/test_mono/generated/ir_when_just.txt index 97844c15ca..abf6b535cf 100644 --- a/compiler/test_mono/generated/ir_when_just.txt +++ b/compiler/test_mono/generated/ir_when_just.txt @@ -3,9 +3,8 @@ procedure Num.24 (#Attr.2, #Attr.3): ret Test.6; procedure Test.0 (): - let Test.13 = 0i64; let Test.12 = 41i64; - let Test.1 = Just Test.13 Test.12; + let Test.1 = Just Test.12; let Test.9 = 0i64; let Test.10 = GetTagId Test.1; let Test.11 = lowlevel Eq Test.9 Test.10; diff --git a/compiler/test_mono/generated/ir_when_maybe.txt b/compiler/test_mono/generated/ir_when_maybe.txt index f650a08e70..36c3bbf833 100644 --- a/compiler/test_mono/generated/ir_when_maybe.txt +++ b/compiler/test_mono/generated/ir_when_maybe.txt @@ -1,7 +1,6 @@ procedure Test.0 (): - let Test.10 = 0i64; let Test.9 = 3i64; - let Test.3 = Just Test.10 Test.9; + let Test.3 = Just Test.9; let Test.6 = 0i64; let Test.7 = GetTagId Test.3; let Test.8 = lowlevel Eq Test.6 Test.7; diff --git a/compiler/test_mono/generated/ir_when_these.txt b/compiler/test_mono/generated/ir_when_these.txt index 019ecefb3b..1ebd81868c 100644 --- a/compiler/test_mono/generated/ir_when_these.txt +++ b/compiler/test_mono/generated/ir_when_these.txt @@ -1,8 +1,7 @@ procedure Test.0 (): - let Test.12 = 1i64; let Test.10 = 1i64; let Test.11 = 2i64; - let Test.5 = These Test.12 Test.10 Test.11; + let Test.5 = These Test.10 Test.11; let Test.9 = GetTagId Test.5; switch Test.9: case 2: diff --git a/compiler/test_mono/generated/list_get.txt b/compiler/test_mono/generated/list_get.txt index cf3b7ad448..e2da3a0e9b 100644 --- a/compiler/test_mono/generated/list_get.txt +++ b/compiler/test_mono/generated/list_get.txt @@ -1,22 +1,20 @@ procedure List.3 (#Attr.2, #Attr.3): - let Test.15 = lowlevel ListLen #Attr.2; - let Test.11 = lowlevel NumLt #Attr.3 Test.15; - if Test.11 then - let Test.14 = 1i64; - let Test.13 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; - let Test.12 = Ok Test.14 Test.13; - ret Test.12; + let Test.13 = lowlevel ListLen #Attr.2; + let Test.10 = lowlevel NumLt #Attr.3 Test.13; + if Test.10 then + let Test.12 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + let Test.11 = Ok Test.12; + ret Test.11; else - let Test.10 = 0i64; let Test.9 = Struct {}; - let Test.8 = Err Test.10 Test.9; + let Test.8 = Err Test.9; ret Test.8; procedure Test.1 (Test.2): - let Test.16 = 1i64; - let Test.17 = 2i64; - let Test.18 = 3i64; - let Test.6 = Array [Test.16, Test.17, Test.18]; + let Test.14 = 1i64; + let Test.15 = 2i64; + let Test.16 = 3i64; + let Test.6 = Array [Test.14, Test.15, Test.16]; let Test.7 = 0i64; let Test.5 = CallByName List.3 Test.6 Test.7; dec Test.6; diff --git a/compiler/test_mono/generated/nested_pattern_match.txt b/compiler/test_mono/generated/nested_pattern_match.txt index d5fb06ae22..d88ecbae13 100644 --- a/compiler/test_mono/generated/nested_pattern_match.txt +++ b/compiler/test_mono/generated/nested_pattern_match.txt @@ -3,11 +3,9 @@ procedure Num.24 (#Attr.2, #Attr.3): ret Test.8; procedure Test.0 (): - let Test.21 = 0i64; - let Test.23 = 0i64; - let Test.22 = 41i64; - let Test.20 = Just Test.23 Test.22; - let Test.2 = Just Test.21 Test.20; + let Test.21 = 41i64; + let Test.20 = Just Test.21; + let Test.2 = Just Test.20; joinpoint Test.17: let Test.11 = 1i64; ret Test.11; diff --git a/compiler/test_mono/generated/quicksort_swap.txt b/compiler/test_mono/generated/quicksort_swap.txt index 0fc64def67..a866c1230d 100644 --- a/compiler/test_mono/generated/quicksort_swap.txt +++ b/compiler/test_mono/generated/quicksort_swap.txt @@ -1,15 +1,13 @@ procedure List.3 (#Attr.2, #Attr.3): - let Test.39 = lowlevel ListLen #Attr.2; - let Test.35 = lowlevel NumLt #Attr.3 Test.39; - if Test.35 then - let Test.38 = 1i64; - let Test.37 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; - let Test.36 = Ok Test.38 Test.37; - ret Test.36; + let Test.37 = lowlevel ListLen #Attr.2; + let Test.34 = lowlevel NumLt #Attr.3 Test.37; + if Test.34 then + let Test.36 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + let Test.35 = Ok Test.36; + ret Test.35; else - let Test.34 = 0i64; let Test.33 = Struct {}; - let Test.32 = Err Test.34 Test.33; + let Test.32 = Err Test.33; ret Test.32; procedure List.4 (#Attr.2, #Attr.3, #Attr.4): @@ -22,8 +20,8 @@ procedure List.4 (#Attr.2, #Attr.3, #Attr.4): ret #Attr.2; procedure Test.1 (Test.2): - let Test.40 = 0i64; - let Test.30 = CallByName List.3 Test.2 Test.40; + let Test.38 = 0i64; + let Test.30 = CallByName List.3 Test.2 Test.38; let Test.31 = 0i64; let Test.29 = CallByName List.3 Test.2 Test.31; let Test.8 = Struct {Test.29, Test.30}; @@ -58,8 +56,8 @@ procedure Test.1 (Test.2): jump Test.26; procedure Test.0 (): - let Test.41 = 1i64; - let Test.42 = 2i64; - let Test.7 = Array [Test.41, Test.42]; + let Test.39 = 1i64; + let Test.40 = 2i64; + let Test.7 = Array [Test.39, Test.40]; let Test.6 = CallByName Test.1 Test.7; ret Test.6; diff --git a/compiler/test_mono/generated/rigids.txt b/compiler/test_mono/generated/rigids.txt index 3dde97335b..c60474cef3 100644 --- a/compiler/test_mono/generated/rigids.txt +++ b/compiler/test_mono/generated/rigids.txt @@ -1,15 +1,13 @@ procedure List.3 (#Attr.2, #Attr.3): - let Test.41 = lowlevel ListLen #Attr.2; - let Test.37 = lowlevel NumLt #Attr.3 Test.41; - if Test.37 then - let Test.40 = 1i64; - let Test.39 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; - let Test.38 = Ok Test.40 Test.39; - ret Test.38; + let Test.39 = lowlevel ListLen #Attr.2; + let Test.36 = lowlevel NumLt #Attr.3 Test.39; + if Test.36 then + let Test.38 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + let Test.37 = Ok Test.38; + ret Test.37; else - let Test.36 = 0i64; let Test.35 = Struct {}; - let Test.34 = Err Test.36 Test.35; + let Test.34 = Err Test.35; ret Test.34; procedure List.4 (#Attr.2, #Attr.3, #Attr.4): @@ -56,7 +54,7 @@ procedure Test.1 (Test.2, Test.3, Test.4): procedure Test.0 (): let Test.10 = 0i64; let Test.11 = 0i64; - let Test.42 = 1i64; - let Test.12 = Array [Test.42]; + let Test.40 = 1i64; + let Test.12 = Array [Test.40]; let Test.9 = CallByName Test.1 Test.10 Test.11 Test.12; ret Test.9; diff --git a/compiler/test_mono/generated/specialize_closures.txt b/compiler/test_mono/generated/specialize_closures.txt index b73f8dacfb..6c3bc3eca9 100644 --- a/compiler/test_mono/generated/specialize_closures.txt +++ b/compiler/test_mono/generated/specialize_closures.txt @@ -1,6 +1,6 @@ procedure Num.24 (#Attr.2, #Attr.3): - let Test.30 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Test.30; + let Test.29 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Test.29; procedure Num.26 (#Attr.2, #Attr.3): let Test.25 = lowlevel NumMul #Attr.2 #Attr.3; @@ -23,8 +23,8 @@ procedure Test.1 (Test.2, Test.3): procedure Test.7 (Test.10, #Attr.12): let Test.4 = UnionAtIndex (Id 0) (Index 1) #Attr.12; - let Test.29 = CallByName Num.24 Test.10 Test.4; - ret Test.29; + let Test.28 = CallByName Num.24 Test.10 Test.4; + ret Test.28; procedure Test.8 (Test.11, #Attr.12): let Test.6 = UnionAtIndex (Id 1) (Index 2) #Attr.12; @@ -44,12 +44,10 @@ procedure Test.0 (): let Test.13 = CallByName Test.1 Test.14 Test.15; ret Test.13; in - let Test.28 = true; - if Test.28 then - let Test.32 = 0i64; - let Test.7 = ClosureTag(Test.7) Test.32 Test.4; + let Test.27 = true; + if Test.27 then + let Test.7 = ClosureTag(Test.7) Test.4; jump Test.22 Test.7; else - let Test.27 = 1i64; - let Test.8 = ClosureTag(Test.8) Test.27 Test.5 Test.6; + let Test.8 = ClosureTag(Test.8) Test.5 Test.6; jump Test.22 Test.8; diff --git a/compiler/test_mono/generated/specialize_lowlevel.txt b/compiler/test_mono/generated/specialize_lowlevel.txt index cea49dd66a..da0ce49195 100644 --- a/compiler/test_mono/generated/specialize_lowlevel.txt +++ b/compiler/test_mono/generated/specialize_lowlevel.txt @@ -1,6 +1,6 @@ procedure Num.24 (#Attr.2, #Attr.3): - let Test.26 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Test.26; + let Test.25 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Test.25; procedure Num.26 (#Attr.2, #Attr.3): let Test.21 = lowlevel NumMul #Attr.2 #Attr.3; @@ -8,8 +8,8 @@ procedure Num.26 (#Attr.2, #Attr.3): procedure Test.6 (Test.8, #Attr.12): let Test.4 = UnionAtIndex (Id 0) (Index 1) #Attr.12; - let Test.25 = CallByName Num.24 Test.8 Test.4; - ret Test.25; + let Test.24 = CallByName Num.24 Test.8 Test.4; + ret Test.24; procedure Test.7 (Test.9, #Attr.12): let Test.5 = UnionAtIndex (Id 1) (Index 1) #Attr.12; @@ -35,12 +35,10 @@ procedure Test.0 (): jump Test.15 Test.17; in - let Test.24 = true; - if Test.24 then - let Test.28 = 0i64; - let Test.6 = ClosureTag(Test.6) Test.28 Test.4; + let Test.23 = true; + if Test.23 then + let Test.6 = ClosureTag(Test.6) Test.4; jump Test.19 Test.6; else - let Test.23 = 1i64; - let Test.7 = ClosureTag(Test.7) Test.23 Test.5; + let Test.7 = ClosureTag(Test.7) Test.5; jump Test.19 Test.7; diff --git a/compiler/test_mono/generated/when_nested_maybe.txt b/compiler/test_mono/generated/when_nested_maybe.txt index d5fb06ae22..d88ecbae13 100644 --- a/compiler/test_mono/generated/when_nested_maybe.txt +++ b/compiler/test_mono/generated/when_nested_maybe.txt @@ -3,11 +3,9 @@ procedure Num.24 (#Attr.2, #Attr.3): ret Test.8; procedure Test.0 (): - let Test.21 = 0i64; - let Test.23 = 0i64; - let Test.22 = 41i64; - let Test.20 = Just Test.23 Test.22; - let Test.2 = Just Test.21 Test.20; + let Test.21 = 41i64; + let Test.20 = Just Test.21; + let Test.2 = Just Test.20; joinpoint Test.17: let Test.11 = 1i64; ret Test.11; diff --git a/compiler/test_mono/generated/when_on_result.txt b/compiler/test_mono/generated/when_on_result.txt index dd05a989d9..7651938c74 100644 --- a/compiler/test_mono/generated/when_on_result.txt +++ b/compiler/test_mono/generated/when_on_result.txt @@ -1,7 +1,6 @@ procedure Test.1 (Test.5): - let Test.20 = 1i64; let Test.19 = 2i64; - let Test.2 = Ok Test.20 Test.19; + let Test.2 = Ok Test.19; joinpoint Test.9 Test.3: ret Test.3; in From f5a7604b832c5aa61e23632ce17210745145ae01 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Sat, 26 Jun 2021 17:11:17 +0200 Subject: [PATCH 386/496] type tooltip tests --- editor/src/editor/mvc/ed_model.rs | 2 +- editor/src/editor/mvc/ed_update.rs | 106 +++++++++++++++++++++-------- 2 files changed, 80 insertions(+), 28 deletions(-) diff --git a/editor/src/editor/mvc/ed_model.rs b/editor/src/editor/mvc/ed_model.rs index 05433270a9..64b36ecf7e 100644 --- a/editor/src/editor/mvc/ed_model.rs +++ b/editor/src/editor/mvc/ed_model.rs @@ -43,7 +43,7 @@ pub struct EdModel<'a> { pub dirty: bool, } -#[derive(Debug)] +#[derive(Debug, Copy, Clone)] pub struct SelectedExpression { pub ast_node_id: NodeId, pub mark_node_id: MarkNodeId, diff --git a/editor/src/editor/mvc/ed_update.rs b/editor/src/editor/mvc/ed_update.rs index 5dfbb57302..5562261a69 100644 --- a/editor/src/editor/mvc/ed_update.rs +++ b/editor/src/editor/mvc/ed_update.rs @@ -255,7 +255,10 @@ impl<'a> EdModel<'a> { ); // put the updated var_store back in env - std::mem::swap( &mut VarStore::new_from_subs(solved.inner()), self.module.env.var_store); + std::mem::swap( + &mut VarStore::new_from_subs(solved.inner()), + self.module.env.var_store, + ); let subs = solved.inner_mut(); @@ -1542,6 +1545,7 @@ pub mod test_ed_update { #[test] fn test_ctrl_shift_up_record() -> Result<(), String> { + // TODO uncomment tests once editor::lang::constrain::constrain_expr does not contain anymore todo's assert_ctrl_shift_up(&["{ ┃ }"], &["┃❮{ }❯"])?; assert_ctrl_shift_up(&["{┃ }"], &["┃❮{ }❯"])?; assert_ctrl_shift_up(&["┃{ }"], &["┃❮{ }❯"])?; @@ -1549,7 +1553,7 @@ pub mod test_ed_update { assert_ctrl_shift_up_repeat(&["{ ┃ }"], &["┃❮{ }❯"], 4)?; assert_ctrl_shift_up(&["{ }┃"], &["┃❮{ }❯"])?; - assert_ctrl_shift_up(&["{ pear┃ }"], &["┃❮{ pear }❯"])?; + /*assert_ctrl_shift_up(&["{ pear┃ }"], &["┃❮{ pear }❯"])?; assert_ctrl_shift_up(&["{ pea┃r }"], &["┃❮{ pear }❯"])?; assert_ctrl_shift_up(&["{ p┃ear }"], &["┃❮{ pear }❯"])?; assert_ctrl_shift_up(&["{ ┃pear }"], &["┃❮{ pear }❯"])?; @@ -1559,7 +1563,7 @@ pub mod test_ed_update { assert_ctrl_shift_up_repeat(&["{ pear┃ }"], &["┃❮{ pear }❯"], 3)?; assert_ctrl_shift_up(&["{ pear }┃"], &["┃❮{ pear }❯"])?; - assert_ctrl_shift_up(&["{ camelCase123┃ }"], &["┃❮{ camelCase123 }❯"])?; + assert_ctrl_shift_up(&["{ camelCase123┃ }"], &["┃❮{ camelCase123 }❯"])?;*/ assert_ctrl_shift_up(&["{ a: \"┃\" }"], &["{ a: ┃❮\"\"❯ }"])?; assert_ctrl_shift_up(&["{ a: ┃\"\" }"], &["{ a: ┃❮\"\"❯ }"])?; @@ -1617,19 +1621,20 @@ pub mod test_ed_update { #[test] fn test_ctrl_shift_up_nested_record() -> Result<(), String> { + // TODO uncomment tests once editor::lang::constrain::constrain_expr does not contain anymore todo's assert_ctrl_shift_up(&["{ abc: { ┃ } }"], &["{ abc: ┃❮{ }❯ }"])?; assert_ctrl_shift_up(&["{ abc: {┃ } }"], &["{ abc: ┃❮{ }❯ }"])?; assert_ctrl_shift_up(&["{ abc: ┃{ } }"], &["{ abc: ┃❮{ }❯ }"])?; assert_ctrl_shift_up(&["{ abc: { ┃} }"], &["{ abc: ┃❮{ }❯ }"])?; assert_ctrl_shift_up(&["{ abc: { }┃ }"], &["┃❮{ abc: { } }❯"])?; - assert_ctrl_shift_up(&["{ abc: { ┃d } }"], &["{ abc: ┃❮{ d }❯ }"])?; + /*assert_ctrl_shift_up(&["{ abc: { ┃d } }"], &["{ abc: ┃❮{ d }❯ }"])?; assert_ctrl_shift_up(&["{ abc: {┃ d } }"], &["{ abc: ┃❮{ d }❯ }"])?; assert_ctrl_shift_up(&["{ abc: ┃{ d } }"], &["{ abc: ┃❮{ d }❯ }"])?; assert_ctrl_shift_up(&["{ abc: { d ┃} }"], &["{ abc: ┃❮{ d }❯ }"])?; assert_ctrl_shift_up(&["{ abc: { d┃e } }"], &["{ abc: ┃❮{ de }❯ }"])?; assert_ctrl_shift_up(&["{ abc: { d }┃ }"], &["┃❮{ abc: { d } }❯"])?; - assert_ctrl_shift_up(&["┃{ abc: { d } }"], &["┃❮{ abc: { d } }❯"])?; + assert_ctrl_shift_up(&["┃{ abc: { d } }"], &["┃❮{ abc: { d } }❯"])?;*/ assert_ctrl_shift_up(&["{ abc: { de: { ┃ } } }"], &["{ abc: { de: ┃❮{ }❯ } }"])?; assert_ctrl_shift_up(&["{ abc: { de: ┃{ } } }"], &["{ abc: { de: ┃❮{ }❯ } }"])?; @@ -1700,7 +1705,7 @@ pub mod test_ed_update { assert_ctrl_shift_up_repeat(&["{ abc: { de: ┃55 } }"], &["┃❮{ abc: { de: 55 } }❯"], 3)?; assert_ctrl_shift_up_repeat(&["{ abc: { de: ┃400 } }"], &["┃❮{ abc: { de: 400 } }❯"], 4)?; - assert_ctrl_shift_up_repeat( + /*assert_ctrl_shift_up_repeat( &["{ g: { oi: { ng: { d: { e: { e: { p: { camelCase┃ } } } } } } } }"], &["{ g: { oi: { ng: { d: ┃❮{ e: { e: { p: { camelCase } } } }❯ } } } }"], 4, @@ -1714,16 +1719,16 @@ pub mod test_ed_update { &["{ g: { oi: { ng: { d: { e: { e: { p: { camelCase┃ } } } } } } } }"], &["┃❮{ g: { oi: { ng: { d: { e: { e: { p: { camelCase } } } } } } } }❯"], 9, - )?; + )?;*/ Ok(()) } // Create ed_model from pre_lines DSL, do handle_new_char() with new_char_seq, select current Expr2, - // check if generated tooltip matches expected_tooltip. - pub fn assert_type_tooltip_seq( + // check if generated tooltips match expected_tooltips. + pub fn assert_type_tooltips_seq( pre_lines: &[&str], - expected_tooltip: &str, + expected_tooltips: &[&str], new_char_seq: &str, ) -> Result<(), String> { let test_arena = Bump::new(); @@ -1737,14 +1742,16 @@ pub mod test_ed_update { ed_res_to_res(handle_new_char(&input_char, &mut ed_model))?; } - ed_model.select_expr()?; + for expected_tooltip in expected_tooltips.iter() { + ed_model.select_expr()?; - let created_tooltip = ed_model.selected_expr_opt.unwrap().type_str; + let created_tooltip = ed_model.selected_expr_opt.unwrap().type_str; - assert_eq!( - created_tooltip.as_str(ed_model.module.env.pool), - expected_tooltip - ); + assert_eq!( + created_tooltip.as_str(ed_model.module.env.pool), + *expected_tooltip + ); + } Ok(()) } @@ -1756,13 +1763,56 @@ pub mod test_ed_update { expected_tooltip: &str, new_char: char, ) -> Result<(), String> { - assert_type_tooltip_seq(pre_lines, expected_tooltip, &new_char.to_string()) + assert_type_tooltips_seq(pre_lines, &vec![expected_tooltip], &new_char.to_string()) + } + + pub fn assert_type_tooltip_clean(lines: &[&str], expected_tooltip: &str) -> Result<(), String> { + assert_type_tooltips_seq(lines, &vec![expected_tooltip], "") + } + + // When doing ctrl+shift+up multiple times we select the surrounding expression every time, + // every new selection should have the correct tooltip + pub fn assert_type_tooltips_clean( + lines: &[&str], + expected_tooltips: &[&str], + ) -> Result<(), String> { + assert_type_tooltips_seq(lines, expected_tooltips, "") } #[test] - fn test_type_tooltip_record() -> Result<(), String> { + fn test_type_tooltip() -> Result<(), String> { assert_type_tooltip(&["┃"], "{}", '{')?; + assert_type_tooltip_clean(&["┃5"], "Num *")?; + assert_type_tooltip_clean(&["42┃"], "Num *")?; + assert_type_tooltip_clean(&["13┃7"], "Num *")?; + + assert_type_tooltip_clean(&["\"┃abc\""], "Str")?; + assert_type_tooltip_clean(&["┃\"abc\""], "Str")?; + assert_type_tooltip_clean(&["\"abc\"┃"], "Str")?; + + assert_type_tooltip_clean(&["{ a: \"abc\" }┃"], "{ a : Str }")?; + assert_type_tooltip_clean(&["{ ┃a: 0 }"], "{ a : Num * }")?; + assert_type_tooltip_clean(&["{ ┃z: { } }"], "{ z : {} }")?; + assert_type_tooltip_clean(&["{ camelCase: ┃0 }"], "Num *")?; + + assert_type_tooltips_seq(&["┃"], &vec!["*"], "")?; + assert_type_tooltips_seq(&["┃"], &vec!["*", "{ a : * }"], "{a:")?; + + assert_type_tooltips_clean( + &["{ camelCase: ┃0 }"], + &vec!["Num *", "{ camelCase : Num * }"], + )?; + assert_type_tooltips_clean( + &["{ a: { b: { c: \"hello┃, hello.0123456789ZXY{}[]-><-\" } } }"], + &vec![ + "Str", + "{ c : Str }", + "{ b : { c : Str } }", + "{ a : { b : { c : Str } } }", + ], + )?; + Ok(()) } @@ -1870,9 +1920,10 @@ pub mod test_ed_update { #[test] fn test_ctrl_shift_up_move_record() -> Result<(), String> { + // TODO uncomment tests once editor::lang::constrain::constrain_expr does not contain anymore todo's assert_ctrl_shift_single_up_move(&["┃{ }"], &["┃{ }"], move_home!())?; - assert_ctrl_shift_single_up_move(&["┃{ a }"], &["{ a }┃"], move_down!())?; - assert_ctrl_shift_single_up_move(&["┃{ a: { b } }"], &["{ a: { b } }┃"], move_right!())?; + //assert_ctrl_shift_single_up_move(&["┃{ a }"], &["{ a }┃"], move_down!())?; + //assert_ctrl_shift_single_up_move(&["┃{ a: { b } }"], &["{ a: { b } }┃"], move_right!())?; assert_ctrl_shift_single_up_move(&["{ a: { ┃ } }"], &["{ a: { } }┃"], move_end!())?; assert_ctrl_shift_up_move( &["{ a: { b: { ┃ } } }"], @@ -1966,19 +2017,20 @@ pub mod test_ed_update { #[test] fn test_ctrl_shift_up_backspace_record() -> Result<(), String> { + // TODO uncomment tests once editor::lang::constrain::constrain_expr does not contain anymore todo's // Blank is inserted when root is deleted assert_ctrl_shift_single_up_backspace(&["{┃ }"], &["┃ "])?; - assert_ctrl_shift_single_up_backspace(&["{ a┃ }"], &["┃ "])?; - assert_ctrl_shift_single_up_backspace(&["{ a: { b }┃ }"], &["┃ "])?; + //assert_ctrl_shift_single_up_backspace(&["{ a┃ }"], &["┃ "])?; + //assert_ctrl_shift_single_up_backspace(&["{ a: { b }┃ }"], &["┃ "])?; assert_ctrl_shift_single_up_backspace(&["{ a: \"b cd\"┃ }"], &["┃ "])?; - assert_ctrl_shift_single_up_backspace(&["{ a: ┃{ b } }"], &["{ a: ┃ }"])?; + //assert_ctrl_shift_single_up_backspace(&["{ a: ┃{ b } }"], &["{ a: ┃ }"])?; assert_ctrl_shift_single_up_backspace(&["{ a: \"┃b cd\" }"], &["{ a: ┃ }"])?; assert_ctrl_shift_single_up_backspace(&["{ a: ┃12 }"], &["{ a: ┃ }"])?; - assert_ctrl_shift_single_up_backspace( + /*assert_ctrl_shift_single_up_backspace( &["{ g: { oi: { ng: { d: { ┃e: { e: { p: { camelCase } } } } } } } }"], &["{ g: { oi: { ng: { d: ┃ } } } }"], - )?; + )?;*/ assert_ctrl_shift_up_backspace( &["{ a: { b: { c: \"abc┃ \" } } }"], @@ -1991,11 +2043,11 @@ pub mod test_ed_update { 2, )?; assert_ctrl_shift_up_backspace(&["{ a: { b: { c: {┃ } } } }"], &["{ a: { b: ┃ } }"], 2)?; - assert_ctrl_shift_up_backspace( + /*assert_ctrl_shift_up_backspace( &["{ g: { oi: { ng: { d: { e: { e: { p┃: { camelCase } } } } } } } }"], &["{ g: ┃ }"], 6, - )?; + )?;*/ Ok(()) } From 8aa3690d77c2c5fb3585abdf2039c74d9d0a4d28 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 26 Jun 2021 20:03:53 +0200 Subject: [PATCH 387/496] fix test in release mode --- compiler/test_gen/src/gen_tags.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/test_gen/src/gen_tags.rs b/compiler/test_gen/src/gen_tags.rs index d4cf0b0dad..6c2ed19c33 100644 --- a/compiler/test_gen/src/gen_tags.rs +++ b/compiler/test_gen/src/gen_tags.rs @@ -97,7 +97,7 @@ fn applied_tag_just_enum() { "# ), (2, 0), - (u8, u8) + (u8, i64) ); } From 71857e83d0b014a228db19a638ec50056024327e Mon Sep 17 00:00:00 2001 From: Folkert Date: Sat, 26 Jun 2021 21:44:04 +0200 Subject: [PATCH 388/496] remove if that is always true --- compiler/gen_llvm/src/llvm/build.rs | 34 +++++++++++++---------------- 1 file changed, 15 insertions(+), 19 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 3de976c3f0..db41f3ad31 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -1081,30 +1081,26 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( for (field_symbol, tag_field_layout) in arguments.iter().zip(tag_field_layouts.iter()) { let (val, _val_layout) = load_symbol_and_layout(scope, field_symbol); - // Zero-sized fields have no runtime representation. - // The layout of the struct expects them to be dropped! - if !tag_field_layout.is_dropped_because_empty() { - let field_type = basic_type_from_layout(env, tag_field_layout); + let field_type = basic_type_from_layout(env, tag_field_layout); - field_types.push(field_type); + field_types.push(field_type); - if let Layout::RecursivePointer = tag_field_layout { - debug_assert!(val.is_pointer_value()); + if let Layout::RecursivePointer = tag_field_layout { + debug_assert!(val.is_pointer_value()); - // we store recursive pointers as `i64*` - let ptr = env.builder.build_bitcast( - val, - ctx.i64_type().ptr_type(AddressSpace::Generic), - "cast_recursive_pointer", - ); + // we store recursive pointers as `i64*` + let ptr = env.builder.build_bitcast( + val, + ctx.i64_type().ptr_type(AddressSpace::Generic), + "cast_recursive_pointer", + ); - field_vals.push(ptr); - } else { - // this check fails for recursive tag unions, but can be helpful while debugging - // debug_assert_eq!(tag_field_layout, val_layout); + field_vals.push(ptr); + } else { + // this check fails for recursive tag unions, but can be helpful while debugging + // debug_assert_eq!(tag_field_layout, val_layout); - field_vals.push(val); - } + field_vals.push(val); } } From 8add147dcfc4ba1644865bd77edd6431a54254e5 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 27 Jun 2021 01:35:15 +0200 Subject: [PATCH 389/496] change over nullable wrapped --- compiler/gen_llvm/src/llvm/build.rs | 277 ++++++++++++---------- compiler/gen_llvm/src/llvm/build_hash.rs | 8 +- compiler/gen_llvm/src/llvm/convert.rs | 49 +++- compiler/gen_llvm/src/llvm/refcounting.rs | 44 ++-- compiler/test_gen/src/gen_primitives.rs | 4 +- 5 files changed, 230 insertions(+), 152 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index db41f3ad31..db69dd2a10 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -1043,14 +1043,15 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( // This tricks comes from // https://github.com/raviqqe/ssf/blob/bc32aae68940d5bddf5984128e85af75ca4f4686/ssf-llvm/src/expression_compiler.rs#L116 - let internal_type = block_of_memory(env.context, layout, env.ptr_bytes); + let internal_type = block_of_memory_slices(env.context, fields, env.ptr_bytes); let data = cast_tag_to_block_of_memory(builder, struct_val, internal_type); + let tag_id_type = env.context.i64_type(); let wrapper_type = env .context - .struct_type(&[data.get_type(), env.context.i64_type().into()], false); + .struct_type(&[data.get_type(), tag_id_type.into()], false); - let tag_id_intval = env.context.i64_type().const_int(*tag_id as u64, false); + let tag_id_intval = tag_id_type.const_int(*tag_id as u64, false); let field_vals = [ (TAG_ID_INDEX as usize, tag_id_intval.into()), @@ -1061,7 +1062,7 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( } Tag { arguments, - tag_layout: UnionLayout::Recursive(fields), + tag_layout: UnionLayout::Recursive(tags), union_size, tag_id, .. @@ -1076,7 +1077,7 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( let mut field_types = Vec::with_capacity_in(num_fields, env.arena); let mut field_vals = Vec::with_capacity_in(num_fields, env.arena); - let tag_field_layouts = &fields[*tag_id as usize]; + let tag_field_layouts = &tags[*tag_id as usize]; for (field_symbol, tag_field_layout) in arguments.iter().zip(tag_field_layouts.iter()) { let (val, _val_layout) = load_symbol_and_layout(scope, field_symbol); @@ -1105,28 +1106,40 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( } // Create the struct_type - let data_ptr = reserve_with_refcount_union_as_block_of_memory(env, fields); + let raw_data_ptr = reserve_with_refcount_union_as_block_of_memory2(env, tags); - let struct_type = ctx.struct_type(field_types.into_bump_slice(), false); + let tag_id_ptr = builder + .build_struct_gep(raw_data_ptr, TAG_ID_INDEX, "tag_id_index") + .unwrap(); + + let tag_id_type = env.context.i64_type(); + env.builder + .build_store(tag_id_ptr, tag_id_type.const_int(*tag_id as u64, false)); + + let opaque_struct_ptr = builder + .build_struct_gep(raw_data_ptr, TAG_DATA_INDEX, "tag_data_index") + .unwrap(); + + let struct_type = env.context.struct_type(&field_types, false); let struct_ptr = env .builder .build_bitcast( - data_ptr, + opaque_struct_ptr, struct_type.ptr_type(AddressSpace::Generic), - "block_of_memory_to_tag", + "struct_ptr", ) .into_pointer_value(); // Insert field exprs into struct_val for (index, field_val) in field_vals.into_iter().enumerate() { let field_ptr = builder - .build_struct_gep(struct_ptr, index as u32, "struct_gep") + .build_struct_gep(struct_ptr, index as u32, "field_struct_gep") .unwrap(); builder.build_store(field_ptr, field_val); } - data_ptr.into() + raw_data_ptr.into() } Tag { @@ -1207,17 +1220,22 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( tag_layout: UnionLayout::NullableWrapped { nullable_id, - other_tags: fields, + other_tags: tags, }, union_size, tag_id, .. } => { - let tag_struct_type = block_of_memory_slices(env.context, fields, env.ptr_bytes); if *tag_id == *nullable_id as u8 { - let output_type = tag_struct_type.ptr_type(AddressSpace::Generic); + let layout = Layout::Union(UnionLayout::NullableWrapped { + nullable_id: *nullable_id, + other_tags: tags, + }); - return output_type.const_null().into(); + return basic_type_from_layout(env, &layout) + .into_pointer_type() + .const_null() + .into(); } debug_assert!(*union_size > 1); @@ -1233,9 +1251,9 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( let tag_field_layouts = { use std::cmp::Ordering::*; match tag_id.cmp(&(*nullable_id as u8)) { - Equal => &[] as &[_], - Less => &fields[*tag_id as usize], - Greater => &fields[*tag_id as usize - 1], + Equal => unreachable!("early return above"), + Less => &tags[*tag_id as usize], + Greater => &tags[*tag_id as usize - 1], } }; @@ -1270,28 +1288,40 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( } // Create the struct_type - let data_ptr = reserve_with_refcount_union_as_block_of_memory(env, fields); + let raw_data_ptr = reserve_with_refcount_union_as_block_of_memory2(env, tags); - let struct_type = ctx.struct_type(field_types.into_bump_slice(), false); + let tag_id_ptr = builder + .build_struct_gep(raw_data_ptr, TAG_ID_INDEX, "tag_id_index") + .unwrap(); + + let tag_id_type = env.context.i64_type(); + env.builder + .build_store(tag_id_ptr, tag_id_type.const_int(*tag_id as u64, false)); + + let opaque_struct_ptr = builder + .build_struct_gep(raw_data_ptr, TAG_DATA_INDEX, "tag_data_index") + .unwrap(); + + let struct_type = env.context.struct_type(&field_types, false); let struct_ptr = env .builder .build_bitcast( - data_ptr, + opaque_struct_ptr, struct_type.ptr_type(AddressSpace::Generic), - "block_of_memory_to_tag", + "struct_ptr", ) .into_pointer_value(); // Insert field exprs into struct_val for (index, field_val) in field_vals.into_iter().enumerate() { let field_ptr = builder - .build_struct_gep(struct_ptr, index as u32, "struct_gep") + .build_struct_gep(struct_ptr, index as u32, "field_struct_gep") .unwrap(); builder.build_store(field_ptr, field_val); } - data_ptr.into() + raw_data_ptr.into() } Tag { @@ -1499,17 +1529,12 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( debug_assert!(argument.is_pointer_value()); let field_layouts = tag_layouts[*tag_id as usize]; - let struct_layout = Layout::Struct(field_layouts); - let struct_type = basic_type_from_layout(env, &struct_layout); - - lookup_at_index_ptr( + lookup_at_index_ptr2( env, field_layouts, *index as usize, argument.into_pointer_value(), - struct_type.into_struct_type(), - &struct_layout, ) } UnionLayout::NonNullableUnwrapped(field_layouts) => { @@ -1540,17 +1565,12 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( }; let field_layouts = other_tags[tag_index as usize]; - let struct_layout = Layout::Struct(field_layouts); - let struct_type = basic_type_from_layout(env, &struct_layout); - - lookup_at_index_ptr( + lookup_at_index_ptr2( env, field_layouts, *index as usize, argument.into_pointer_value(), - struct_type.into_struct_type(), - &struct_layout, ) } UnionLayout::NullableUnwrapped { @@ -1606,13 +1626,7 @@ pub fn get_tag_id<'a, 'ctx, 'env>( .unwrap() } UnionLayout::Recursive(_) => { - let pointer = argument.into_pointer_value(); - let tag_id_pointer = builder.build_bitcast( - pointer, - env.context.i64_type().ptr_type(AddressSpace::Generic), - "tag_id_pointer", - ); - builder.build_load(tag_id_pointer.into_pointer_value(), "load_tag_id") + extract_tag_discriminant_ptr2(env, argument.into_pointer_value()).into() } UnionLayout::NonNullableUnwrapped(_) => env.context.i64_type().const_zero().into(), UnionLayout::NullableWrapped { nullable_id, .. } => { @@ -1638,7 +1652,7 @@ pub fn get_tag_id<'a, 'ctx, 'env>( { env.builder.position_at_end(else_block); - let tag_id = extract_tag_discriminant_ptr(env, argument_ptr); + let tag_id = extract_tag_discriminant_ptr2(env, argument_ptr); env.builder.build_store(result, tag_id); env.builder.build_unconditional_branch(cont_block); } @@ -1701,6 +1715,62 @@ fn lookup_at_index_ptr<'a, 'ctx, 'env>( } } +fn lookup_at_index_ptr2<'a, 'ctx, 'env>( + env: &Env<'a, 'ctx, 'env>, + field_layouts: &[Layout<'_>], + index: usize, + value: PointerValue<'ctx>, +) -> BasicValueEnum<'ctx> { + let builder = env.builder; + + let struct_layout = Layout::Struct(field_layouts); + let struct_type = basic_type_from_layout(env, &struct_layout); + + let tag_id_type = env.context.i64_type(); + let wrapper_type = env + .context + .struct_type(&[struct_type, tag_id_type.into()], false); + + let ptr = env + .builder + .build_bitcast( + value, + wrapper_type.ptr_type(AddressSpace::Generic), + "cast_lookup_at_index_ptr", + ) + .into_pointer_value(); + + let data_ptr = builder + .build_struct_gep(ptr, TAG_DATA_INDEX, "at_index_struct_gep") + .unwrap(); + + let elem_ptr = builder + .build_struct_gep(data_ptr, index as u32, "at_index_struct_gep") + .unwrap(); + + let result = builder.build_load(elem_ptr, "load_at_index_ptr"); + + if let Some(Layout::RecursivePointer) = field_layouts.get(index as usize) { + // a recursive field is stored as a `i64*`, to use it we must cast it to + // a pointer to the block of memory representation + + let struct_type = block_of_memory_slices(env.context, &[field_layouts], env.ptr_bytes); + let tag_id_type = env.context.i64_type(); + + let opaque_wrapper_type = env + .context + .struct_type(&[struct_type, tag_id_type.into()], false); + + builder.build_bitcast( + result, + opaque_wrapper_type.ptr_type(AddressSpace::Generic), + "cast_rec_pointer_lookup_at_index_ptr", + ) + } else { + result + } +} + pub fn reserve_with_refcount<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, layout: &Layout<'a>, @@ -1735,6 +1805,35 @@ fn reserve_with_refcount_union_as_block_of_memory<'a, 'ctx, 'env>( reserve_with_refcount_help(env, basic_type, stack_size, alignment_bytes) } +fn reserve_with_refcount_union_as_block_of_memory2<'a, 'ctx, 'env>( + env: &Env<'a, 'ctx, 'env>, + fields: &[&[Layout<'a>]], +) -> PointerValue<'ctx> { + let block_type = block_of_memory_slices(env.context, fields, env.ptr_bytes); + + let tag_id_type = env.context.i64_type(); + let basic_type = env + .context + .struct_type(&[block_type, tag_id_type.into()], false); + + let stack_size = fields + .iter() + .map(|tag| tag.iter().map(|l| l.stack_size(env.ptr_bytes)).sum()) + .max() + .unwrap_or(0) + // add tag id + + env.ptr_bytes; + + let alignment_bytes = fields + .iter() + .map(|tag| tag.iter().map(|l| l.alignment_bytes(env.ptr_bytes))) + .flatten() + .max() + .unwrap_or(0); + + reserve_with_refcount_help(env, basic_type, stack_size, alignment_bytes) +} + fn reserve_with_refcount_help<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, basic_type: impl BasicType<'ctx>, @@ -2495,95 +2594,21 @@ pub fn extract_tag_discriminant<'a, 'ctx, 'env>( union_layout: UnionLayout<'a>, cond_value: BasicValueEnum<'ctx>, ) -> IntValue<'ctx> { - let builder = env.builder; - - match union_layout { - UnionLayout::NonRecursive(_) => { - let pointer = builder.build_alloca(cond_value.get_type(), "get_type"); - builder.build_store(pointer, cond_value); - let tag_id_pointer = builder.build_bitcast( - pointer, - env.context.i64_type().ptr_type(AddressSpace::Generic), - "tag_id_pointer", - ); - builder - .build_load(tag_id_pointer.into_pointer_value(), "load_tag_id") - .into_int_value() - } - UnionLayout::Recursive(_) => { - let pointer = cond_value.into_pointer_value(); - let tag_id_pointer = builder.build_bitcast( - pointer, - env.context.i64_type().ptr_type(AddressSpace::Generic), - "tag_id_pointer", - ); - builder - .build_load(tag_id_pointer.into_pointer_value(), "load_tag_id") - .into_int_value() - } - UnionLayout::NonNullableUnwrapped(_) => env.context.i64_type().const_zero(), - UnionLayout::NullableWrapped { nullable_id, .. } => { - let argument_ptr = cond_value.into_pointer_value(); - let is_null = env.builder.build_is_null(argument_ptr, "is_null"); - - let ctx = env.context; - let then_block = ctx.append_basic_block(parent, "then"); - let else_block = ctx.append_basic_block(parent, "else"); - let cont_block = ctx.append_basic_block(parent, "cont"); - - let result = builder.build_alloca(ctx.i64_type(), "result"); - - env.builder - .build_conditional_branch(is_null, then_block, else_block); - - { - env.builder.position_at_end(then_block); - let tag_id = ctx.i64_type().const_int(nullable_id as u64, false); - env.builder.build_store(result, tag_id); - env.builder.build_unconditional_branch(cont_block); - } - - { - env.builder.position_at_end(else_block); - let tag_id = extract_tag_discriminant_ptr(env, argument_ptr); - env.builder.build_store(result, tag_id); - env.builder.build_unconditional_branch(cont_block); - } - - env.builder.position_at_end(cont_block); - - env.builder - .build_load(result, "load_result") - .into_int_value() - } - UnionLayout::NullableUnwrapped { nullable_id, .. } => { - let argument_ptr = cond_value.into_pointer_value(); - let is_null = env.builder.build_is_null(argument_ptr, "is_null"); - - let ctx = env.context; - - let then_value = ctx.i64_type().const_int(nullable_id as u64, false); - let else_value = ctx.i64_type().const_int(!nullable_id as u64, false); - - env.builder - .build_select(is_null, then_value, else_value, "select_tag_id") - .into_int_value() - } - } + get_tag_id(env, parent, &union_layout, cond_value).into_int_value() } -fn extract_tag_discriminant_ptr<'a, 'ctx, 'env>( +fn extract_tag_discriminant_ptr2<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, from_value: PointerValue<'ctx>, ) -> IntValue<'ctx> { - let tag_id_ptr_type = env.context.i64_type().ptr_type(AddressSpace::Generic); - - let ptr = env + let tag_id_ptr = env .builder - .build_bitcast(from_value, tag_id_ptr_type, "extract_tag_discriminant_ptr") - .into_pointer_value(); + .build_struct_gep(from_value, TAG_ID_INDEX, "tag_id_ptr") + .unwrap(); - env.builder.build_load(ptr, "load_tag_id").into_int_value() + env.builder + .build_load(tag_id_ptr, "load_tag_id") + .into_int_value() } struct SwitchArgsIr<'a, 'ctx> { diff --git a/compiler/gen_llvm/src/llvm/build_hash.rs b/compiler/gen_llvm/src/llvm/build_hash.rs index 23728d778c..a122c2d2a5 100644 --- a/compiler/gen_llvm/src/llvm/build_hash.rs +++ b/compiler/gen_llvm/src/llvm/build_hash.rs @@ -1,7 +1,9 @@ use crate::debug_info_init; use crate::llvm::bitcode::call_bitcode_fn; use crate::llvm::build::Env; -use crate::llvm::build::{cast_block_of_memory_to_tag, complex_bitcast, FAST_CALL_CONV}; +use crate::llvm::build::{ + cast_block_of_memory_to_tag, complex_bitcast, get_tag_id, FAST_CALL_CONV, +}; use crate::llvm::build_str; use crate::llvm::convert::basic_type_from_layout; use bumpalo::collections::Vec; @@ -406,7 +408,6 @@ fn hash_tag<'a, 'ctx, 'env>( env.builder.position_at_end(entry_block); match union_layout { NonRecursive(tags) => { - // SAFETY we know that non-recursive tags cannot be NULL let tag_id = nonrec_tag_id(env, tag.into_struct_value()); let mut cases = Vec::with_capacity_in(tags.len(), env.arena); @@ -449,8 +450,7 @@ fn hash_tag<'a, 'ctx, 'env>( env.builder.build_switch(tag_id, default, &cases); } Recursive(tags) => { - // SAFETY recursive tag unions are not NULL - let tag_id = unsafe { rec_tag_id_unsafe(env, tag.into_pointer_value()) }; + let tag_id = get_tag_id(env, parent, union_layout, tag).into_int_value(); let mut cases = Vec::with_capacity_in(tags.len(), env.arena); diff --git a/compiler/gen_llvm/src/llvm/convert.rs b/compiler/gen_llvm/src/llvm/convert.rs index 7665763f67..fee1a90475 100644 --- a/compiler/gen_llvm/src/llvm/convert.rs +++ b/compiler/gen_llvm/src/llvm/convert.rs @@ -34,12 +34,15 @@ pub fn basic_type_from_layout<'a, 'ctx, 'env>( Union(variant) => { use UnionLayout::*; match variant { - Recursive(tags) - | NullableWrapped { + NullableWrapped { other_tags: tags, .. } => { - let block = block_of_memory_slices(env.context, tags, env.ptr_bytes); - block.ptr_type(AddressSpace::Generic).into() + let data = block_of_memory_slices(env.context, tags, env.ptr_bytes); + + env.context + .struct_type(&[data, env.context.i64_type().into()], false) + .ptr_type(AddressSpace::Generic) + .into() } NullableUnwrapped { other_fields, .. } => { let block = @@ -50,8 +53,16 @@ pub fn basic_type_from_layout<'a, 'ctx, 'env>( let block = block_of_memory_slices(env.context, &[fields], env.ptr_bytes); block.ptr_type(AddressSpace::Generic).into() } - NonRecursive(_) => { - let data = block_of_memory(env.context, layout, env.ptr_bytes); + Recursive(tags) => { + let data = block_of_memory_slices(env.context, tags, env.ptr_bytes); + + env.context + .struct_type(&[data, env.context.i64_type().into()], false) + .ptr_type(AddressSpace::Generic) + .into() + } + NonRecursive(tags) => { + let data = block_of_memory_slices(env.context, tags, env.ptr_bytes); env.context .struct_type(&[data, env.context.i64_type().into()], false) @@ -117,6 +128,32 @@ pub fn block_of_memory_slices<'ctx>( block_of_memory_help(context, union_size) } +pub fn union_data_is_struct<'a, 'ctx, 'env>( + env: &crate::llvm::build::Env<'a, 'ctx, 'env>, + layouts: &[Layout<'_>], +) -> StructType<'ctx> { + let data_type = basic_type_from_record(env, layouts); + union_data_is_struct_type(env.context, data_type.into_struct_type()) +} + +pub fn union_data_is_struct_type<'ctx>( + context: &'ctx Context, + struct_type: StructType<'ctx>, +) -> StructType<'ctx> { + let tag_id_type = context.i64_type(); + context.struct_type(&[struct_type.into(), tag_id_type.into()], false) +} + +pub fn union_data_block_of_memory<'ctx>( + context: &'ctx Context, + layouts: &[&[Layout<'_>]], + ptr_bytes: u32, +) -> StructType<'ctx> { + let tag_id_type = context.i64_type(); + let data_type = block_of_memory_slices(context, layouts, ptr_bytes); + context.struct_type(&[data_type, tag_id_type.into()], false) +} + pub fn block_of_memory<'ctx>( context: &'ctx Context, layout: &Layout<'_>, diff --git a/compiler/gen_llvm/src/llvm/refcounting.rs b/compiler/gen_llvm/src/llvm/refcounting.rs index 79b029e7e3..4f02753739 100644 --- a/compiler/gen_llvm/src/llvm/refcounting.rs +++ b/compiler/gen_llvm/src/llvm/refcounting.rs @@ -4,7 +4,9 @@ use crate::llvm::build::{ LLVM_SADD_WITH_OVERFLOW_I64, TAG_DATA_INDEX, TAG_ID_INDEX, }; use crate::llvm::build_list::{incrementing_elem_loop, list_len, load_list}; -use crate::llvm::convert::{basic_type_from_layout, block_of_memory_slices, ptr_int}; +use crate::llvm::convert::{ + basic_type_from_layout, block_of_memory_slices, ptr_int, union_data_block_of_memory, +}; use bumpalo::collections::Vec; use inkwell::basic_block::BasicBlock; use inkwell::context::Context; @@ -651,6 +653,7 @@ fn modify_refcount_layout_build_function<'a, 'ctx, 'env>( layout_ids, mode, &WhenRecursive::Loop(*variant), + *variant, tags, true, ); @@ -666,6 +669,7 @@ fn modify_refcount_layout_build_function<'a, 'ctx, 'env>( layout_ids, mode, &WhenRecursive::Loop(*variant), + *variant, &*env.arena.alloc([other_fields]), true, ); @@ -679,6 +683,7 @@ fn modify_refcount_layout_build_function<'a, 'ctx, 'env>( layout_ids, mode, &WhenRecursive::Loop(*variant), + *variant, &*env.arena.alloc([*fields]), true, ); @@ -691,6 +696,7 @@ fn modify_refcount_layout_build_function<'a, 'ctx, 'env>( layout_ids, mode, &WhenRecursive::Loop(*variant), + *variant, tags, false, ); @@ -1203,10 +1209,11 @@ fn build_rec_union<'a, 'ctx, 'env>( layout_ids: &mut LayoutIds<'a>, mode: Mode, when_recursive: &WhenRecursive<'a>, - fields: &'a [&'a [Layout<'a>]], + union_layout: UnionLayout<'a>, + tags: &'a [&'a [Layout<'a>]], is_nullable: bool, ) -> FunctionValue<'ctx> { - let layout = Layout::Union(UnionLayout::Recursive(fields)); + let layout = Layout::Union(UnionLayout::Recursive(tags)); let (_, fn_name) = function_name_from_mode( layout_ids, @@ -1223,9 +1230,7 @@ fn build_rec_union<'a, 'ctx, 'env>( let block = env.builder.get_insert_block().expect("to be in a function"); let di_location = env.builder.get_current_debug_location().unwrap(); - let basic_type = block_of_memory_slices(env.context, fields, env.ptr_bytes) - .ptr_type(AddressSpace::Generic) - .into(); + let basic_type = basic_type_from_layout(env, &Layout::Union(union_layout)); let function_value = build_header(env, basic_type, mode, &fn_name); build_rec_union_help( @@ -1233,7 +1238,8 @@ fn build_rec_union<'a, 'ctx, 'env>( layout_ids, mode, when_recursive, - fields, + union_layout, + tags, function_value, is_nullable, ); @@ -1249,11 +1255,13 @@ fn build_rec_union<'a, 'ctx, 'env>( function } +#[allow(clippy::too_many_arguments)] fn build_rec_union_help<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, layout_ids: &mut LayoutIds<'a>, mode: Mode, when_recursive: &WhenRecursive<'a>, + union_layout: UnionLayout<'a>, tags: &'a [&'a [roc_mono::layout::Layout<'a>]], fn_val: FunctionValue<'ctx>, is_nullable: bool, @@ -1279,8 +1287,6 @@ fn build_rec_union_help<'a, 'ctx, 'env>( let parent = fn_val; - let layout = Layout::Union(UnionLayout::Recursive(tags)); - debug_assert!(arg_val.is_pointer_value()); let value_ptr = arg_val.into_pointer_value(); @@ -1309,6 +1315,8 @@ fn build_rec_union_help<'a, 'ctx, 'env>( env.builder.position_at_end(should_recurse_block); + let layout = Layout::Union(union_layout); + match mode { Mode::Inc => { // inc is cheap; we never recurse @@ -1342,7 +1350,7 @@ fn build_rec_union_help<'a, 'ctx, 'env>( when_recursive, parent, fn_val, - layout, + union_layout, tags, value_ptr, refcount_ptr, @@ -1360,7 +1368,7 @@ fn build_rec_union_recursive_decrement<'a, 'ctx, 'env>( when_recursive: &WhenRecursive<'a>, parent: FunctionValue<'ctx>, decrement_fn: FunctionValue<'ctx>, - layout: Layout<'a>, + union_layout: UnionLayout<'a>, tags: &[&[Layout<'a>]], value_ptr: PointerValue<'ctx>, refcount_ptr: PointerToRefcount<'ctx>, @@ -1433,7 +1441,15 @@ fn build_rec_union_recursive_decrement<'a, 'ctx, 'env>( debug_assert!(ptr_as_i64_ptr.is_pointer_value()); // therefore we must cast it to our desired type - let union_type = block_of_memory_slices(env.context, tags, env.ptr_bytes); + + let union_type = match union_layout { + UnionLayout::Recursive(_) | UnionLayout::NullableWrapped { .. } => { + union_data_block_of_memory(env.context, tags, env.ptr_bytes).into() + } + UnionLayout::NonRecursive(_) => unreachable!(), + _ => block_of_memory_slices(env.context, tags, env.ptr_bytes), + }; + let recursive_field_ptr = cast_basic_basic( env.builder, ptr_as_i64_ptr, @@ -1461,7 +1477,7 @@ fn build_rec_union_recursive_decrement<'a, 'ctx, 'env>( // lists. To achieve it, we must first load all fields that we want to inc/dec (done above) // and store them on the stack, then modify (and potentially free) the current cell, then // actually inc/dec the fields. - refcount_ptr.modify(call_mode, &layout, env); + refcount_ptr.modify(call_mode, &Layout::Union(union_layout), env); for (field, field_layout) in deferred_nonrec { modify_refcount_layout_help( @@ -1514,7 +1530,7 @@ fn build_rec_union_recursive_decrement<'a, 'ctx, 'env>( env.builder.position_at_end(merge_block); // increment/decrement the cons-cell itself - refcount_ptr.modify(call_mode, &layout, env); + refcount_ptr.modify(call_mode, &Layout::Union(union_layout), env); // this function returns void builder.build_return(None); diff --git a/compiler/test_gen/src/gen_primitives.rs b/compiler/test_gen/src/gen_primitives.rs index abe4ba8736..3c932db913 100644 --- a/compiler/test_gen/src/gen_primitives.rs +++ b/compiler/test_gen/src/gen_primitives.rs @@ -1683,11 +1683,11 @@ fn binary_tree_double_pattern_match() { foo = \btree -> when btree is Node (Node (Leaf x) _) _ -> x - _ -> 0 + _ -> 1 main : I64 main = - foo (Node (Node (Leaf 32) (Leaf 0)) (Leaf 0)) + foo (Node (Node (Leaf 32) (Leaf 2)) (Leaf 3)) "# ), 32, From 99d0d9c73249703dea7ca93e139f5416860f902e Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 27 Jun 2021 13:49:49 +0200 Subject: [PATCH 390/496] WIP --- compiler/gen_llvm/src/llvm/build.rs | 49 +++++++++-------------- compiler/gen_llvm/src/llvm/convert.rs | 2 +- compiler/gen_llvm/src/llvm/refcounting.rs | 11 ++--- compiler/mono/src/alias_analysis.rs | 3 +- compiler/mono/src/decision_tree.rs | 2 +- compiler/mono/src/ir.rs | 38 ++++-------------- compiler/mono/src/layout.rs | 14 +------ compiler/test_gen/src/gen_tags.rs | 4 +- 8 files changed, 40 insertions(+), 83 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index db69dd2a10..f9704c8b43 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -1164,29 +1164,25 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( for (field_symbol, tag_field_layout) in arguments.iter().zip(fields.iter()) { let val = load_symbol(scope, field_symbol); - // Zero-sized fields have no runtime representation. - // The layout of the struct expects them to be dropped! - if !tag_field_layout.is_dropped_because_empty() { - let field_type = basic_type_from_layout(env, tag_field_layout); + let field_type = basic_type_from_layout(env, tag_field_layout); - field_types.push(field_type); + field_types.push(field_type); - if let Layout::RecursivePointer = tag_field_layout { - debug_assert!(val.is_pointer_value()); + if let Layout::RecursivePointer = tag_field_layout { + debug_assert!(val.is_pointer_value()); - // we store recursive pointers as `i64*` - let ptr = env.builder.build_bitcast( - val, - ctx.i64_type().ptr_type(AddressSpace::Generic), - "cast_recursive_pointer", - ); + // we store recursive pointers as `i64*` + let ptr = env.builder.build_bitcast( + val, + ctx.i64_type().ptr_type(AddressSpace::Generic), + "cast_recursive_pointer", + ); - field_vals.push(ptr); - } else { - // this check fails for recursive tag unions, but can be helpful while debugging + field_vals.push(ptr); + } else { + // this check fails for recursive tag unions, but can be helpful while debugging - field_vals.push(val); - } + field_vals.push(val); } } @@ -1337,8 +1333,6 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( tag_name, .. } => { - let other_fields = &other_fields[1..]; - let tag_struct_type = block_of_memory_slices(env.context, &[other_fields], env.ptr_bytes); @@ -1364,12 +1358,9 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( debug_assert!(!matches!(tag_name, TagName::Closure(_))); - let tag_field_layouts = other_fields; - let arguments = &arguments[1..]; + debug_assert_eq!(arguments.len(), other_fields.len()); - debug_assert_eq!(arguments.len(), tag_field_layouts.len()); - - for (field_symbol, tag_field_layout) in arguments.iter().zip(tag_field_layouts.iter()) { + for (field_symbol, tag_field_layout) in arguments.iter().zip(other_fields.iter()) { let val = load_symbol(scope, field_symbol); // Zero-sized fields have no runtime representation. @@ -1505,8 +1496,6 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( match union_layout { UnionLayout::NonRecursive(tag_layouts) => { - let index = *index - 1; - debug_assert!(argument.is_struct_value()); let field_layouts = tag_layouts[*tag_id as usize]; let struct_layout = Layout::Struct(field_layouts); @@ -1520,7 +1509,7 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( ); let result = builder - .build_extract_value(struct_value, index as u32, "") + .build_extract_value(struct_value, *index as u32, "") .expect("desired field did not decode"); result @@ -1580,7 +1569,7 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( debug_assert!(argument.is_pointer_value()); debug_assert_ne!(*tag_id != 0, *nullable_id); - let field_layouts = &other_fields[1..]; + let field_layouts = other_fields; let struct_layout = Layout::Struct(field_layouts); let struct_type = basic_type_from_layout(env, &struct_layout); @@ -1589,7 +1578,7 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( env, field_layouts, // the tag id is not stored - *index as usize - 1, + *index as usize, argument.into_pointer_value(), struct_type.into_struct_type(), &struct_layout, diff --git a/compiler/gen_llvm/src/llvm/convert.rs b/compiler/gen_llvm/src/llvm/convert.rs index fee1a90475..e00861a381 100644 --- a/compiler/gen_llvm/src/llvm/convert.rs +++ b/compiler/gen_llvm/src/llvm/convert.rs @@ -46,7 +46,7 @@ pub fn basic_type_from_layout<'a, 'ctx, 'env>( } NullableUnwrapped { other_fields, .. } => { let block = - block_of_memory_slices(env.context, &[&other_fields[1..]], env.ptr_bytes); + block_of_memory_slices(env.context, &[&other_fields], env.ptr_bytes); block.ptr_type(AddressSpace::Generic).into() } NonNullableUnwrapped(fields) => { diff --git a/compiler/gen_llvm/src/llvm/refcounting.rs b/compiler/gen_llvm/src/llvm/refcounting.rs index 4f02753739..b38c2f605c 100644 --- a/compiler/gen_llvm/src/llvm/refcounting.rs +++ b/compiler/gen_llvm/src/llvm/refcounting.rs @@ -662,15 +662,13 @@ fn modify_refcount_layout_build_function<'a, 'ctx, 'env>( } NullableUnwrapped { other_fields, .. } => { - let other_fields = &other_fields[1..]; - let function = build_rec_union( env, layout_ids, mode, &WhenRecursive::Loop(*variant), *variant, - &*env.arena.alloc([other_fields]), + env.arena.alloc([*other_fields]), true, ); @@ -1443,11 +1441,14 @@ fn build_rec_union_recursive_decrement<'a, 'ctx, 'env>( // therefore we must cast it to our desired type let union_type = match union_layout { + UnionLayout::NonRecursive(_) => unreachable!(), UnionLayout::Recursive(_) | UnionLayout::NullableWrapped { .. } => { union_data_block_of_memory(env.context, tags, env.ptr_bytes).into() } - UnionLayout::NonRecursive(_) => unreachable!(), - _ => block_of_memory_slices(env.context, tags, env.ptr_bytes), + UnionLayout::NonNullableUnwrapped { .. } + | UnionLayout::NullableUnwrapped { .. } => { + block_of_memory_slices(env.context, tags, env.ptr_bytes) + } }; let recursive_field_ptr = cast_basic_basic( diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 7ef8bd40c2..2b4354d26e 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -861,8 +861,7 @@ fn expr_spec( union_layout, } => match union_layout { UnionLayout::NonRecursive(_) => { - // let index = (*index - 1) as u32; - let index = (*index - 1) as u32; + let index = (*index) as u32; let tag_value_id = env.symbols[structure]; let tuple_value_id = builder.add_unwrap_union(block, tag_value_id, *tag_id as u32)?; diff --git a/compiler/mono/src/decision_tree.rs b/compiler/mono/src/decision_tree.rs index 29d5576a50..b8f348520c 100644 --- a/compiler/mono/src/decision_tree.rs +++ b/compiler/mono/src/decision_tree.rs @@ -672,7 +672,7 @@ fn to_relevant_branch_help<'a>( .map(|(index, (pattern, _))| { let mut new_path = path.to_vec(); new_path.push(PathInstruction { - index: 1 + index as u64, + index: index as u64, tag_id, }); (new_path, Guard::NoGuard, pattern) diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 045845e473..132143c8c2 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -19,7 +19,7 @@ use roc_types::subs::{Content, FlatType, Subs, Variable}; use std::collections::HashMap; use ven_pretty::{BoxAllocator, DocAllocator, DocBuilder}; -pub const PRETTY_PRINT_IR_SYMBOLS: bool = false; +pub const PRETTY_PRINT_IR_SYMBOLS: bool = true; macro_rules! return_on_layout_error { ($env:expr, $layout_result:expr) => { @@ -2092,7 +2092,7 @@ fn specialize_external<'a>( structure: Symbol::ARG_CLOSURE, // union at index still expects the index to be +1; it thinks // the tag id is stored - index: index as u64 + 1, + index: index as u64, union_layout, }; @@ -4179,12 +4179,10 @@ fn convert_tag_union<'a>( let (tag, layout) = match variant { Recursive { sorted_tag_layouts } => { debug_assert!(sorted_tag_layouts.len() > 1); - let tag_id_symbol = env.unique_symbol(); - opt_tag_id_symbol = Some(tag_id_symbol); + opt_tag_id_symbol = None; field_symbols = { let mut temp = Vec::with_capacity_in(field_symbols_temp.len() + 1, arena); - temp.push(tag_id_symbol); temp.extend(field_symbols_temp.iter().map(|r| r.1)); @@ -4274,12 +4272,10 @@ fn convert_tag_union<'a>( nullable_name: _, sorted_tag_layouts, } => { - let tag_id_symbol = env.unique_symbol(); - opt_tag_id_symbol = Some(tag_id_symbol); + opt_tag_id_symbol = None; field_symbols = { let mut temp = Vec::with_capacity_in(field_symbols_temp.len() + 1, arena); - temp.push(tag_id_symbol); temp.extend(field_symbols_temp.iter().map(|r| r.1)); @@ -4320,8 +4316,6 @@ fn convert_tag_union<'a>( field_symbols = { let mut temp = Vec::with_capacity_in(field_symbols_temp.len() + 1, arena); - // FIXME drop tag - temp.push(tag_id_symbol); temp.extend(field_symbols_temp.iter().map(|r| r.1)); @@ -5661,25 +5655,9 @@ fn store_tag_pattern<'a>( ) -> StorePattern<'a> { use Pattern::*; - // rosetree-like structures don't store the tag ID, the others do from the perspective of the IR - // The backend can make different choices there (and will, for UnionLayout::NullableUnwrapped) - let write_tag = !matches!(union_layout, UnionLayout::NonNullableUnwrapped(_)); - - let mut arg_layouts = Vec::with_capacity_in(arguments.len(), env.arena); let mut is_productive = false; - if write_tag { - // add an element for the tag discriminant - arg_layouts.push(Layout::Builtin(TAG_SIZE)); - } - - for (_, layout) in arguments { - arg_layouts.push(*layout); - } - for (index, (argument, arg_layout)) in arguments.iter().enumerate().rev() { - let index = if write_tag { index + 1 } else { index }; - let mut arg_layout = *arg_layout; if let Layout::RecursivePointer = arg_layout { @@ -7148,8 +7126,8 @@ fn from_can_pattern_help<'a>( let mut mono_args = Vec::with_capacity_in(arguments.len(), env.arena); - debug_assert_eq!(arguments.len(), argument_layouts[1..].len()); - let it = argument_layouts[1..].iter(); + debug_assert_eq!(arguments.len(), argument_layouts.len()); + let it = argument_layouts.iter(); for ((_, loc_pat), layout) in arguments.iter().zip(it) { mono_args.push(( @@ -7279,7 +7257,7 @@ fn from_can_pattern_help<'a>( let it = if tag_name == &nullable_name { [].iter() } else { - argument_layouts[1..].iter() + argument_layouts.iter() }; for ((_, loc_pat), layout) in arguments.iter().zip(it) { @@ -7350,7 +7328,7 @@ fn from_can_pattern_help<'a>( [].iter() } else { // FIXME drop tag - argument_layouts[1..].iter() + argument_layouts.iter() }; for ((_, loc_pat), layout) in arguments.iter().zip(it) { diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index ef3e8f1dd9..9c88c021ff 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -109,8 +109,6 @@ impl<'a> UnionLayout<'a> { pub fn layout_at(self, tag_id: u8, index: usize) -> Layout<'a> { let result = match self { UnionLayout::NonRecursive(tag_layouts) => { - let index = index - 1; - let field_layouts = tag_layouts[tag_id as usize]; // this cannot be recursive; return immediately @@ -1193,15 +1191,12 @@ fn layout_from_flat_type<'a>( env.insert_seen(rec_var); for (index, (_name, variables)) in tags_vec.into_iter().enumerate() { if matches!(nullable, Some(i) if i == index as i64) { - // don't add the + // don't add the nullable case continue; } let mut tag_layout = Vec::with_capacity_in(variables.len() + 1, arena); - // store the discriminant - tag_layout.push(Layout::Builtin(TAG_SIZE)); - for var in variables { // TODO does this cause problems with mutually recursive unions? if rec_var == subs.get_root_key_without_compacting(var) { @@ -1242,7 +1237,7 @@ fn layout_from_flat_type<'a>( } } else if tag_layouts.len() == 1 { // drop the tag id - UnionLayout::NonNullableUnwrapped(&tag_layouts.pop().unwrap()[1..]) + UnionLayout::NonNullableUnwrapped(&tag_layouts.pop().unwrap()) } else { UnionLayout::Recursive(tag_layouts.into_bump_slice()) }; @@ -1584,11 +1579,6 @@ pub fn union_sorted_tags_help<'a>( let mut arg_layouts = Vec::with_capacity_in(arguments.len() + 1, arena); - // add the tag discriminant (size currently always hardcoded to i64) - if is_recursive { - arg_layouts.push(Layout::Builtin(TAG_SIZE)); - } - for var in arguments { match Layout::from_var(&mut env, var) { Ok(layout) => { diff --git a/compiler/test_gen/src/gen_tags.rs b/compiler/test_gen/src/gen_tags.rs index 6c2ed19c33..4359836051 100644 --- a/compiler/test_gen/src/gen_tags.rs +++ b/compiler/test_gen/src/gen_tags.rs @@ -948,8 +948,8 @@ fn nested_recursive_literal() { #" ), 0, - &i64, - |x: &i64| *x + &(i64, i64, i64), + |x: &(i64, i64, i64)| x.2 ); } From 16f6259f7f866db929a39bf0404599c4d2870752 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 27 Jun 2021 14:39:28 +0200 Subject: [PATCH 391/496] fix all the things --- compiler/gen_llvm/src/llvm/build_hash.rs | 68 ++++++------------- compiler/gen_llvm/src/llvm/compare.rs | 37 ++-------- compiler/gen_llvm/src/llvm/refcounting.rs | 22 +----- compiler/mono/src/ir.rs | 2 +- compiler/mono/src/layout.rs | 11 ++- compiler/test_gen/src/gen_hash.rs | 4 +- compiler/test_mono/generated/has_none.txt | 8 +-- compiler/test_mono/generated/ir_when_idiv.txt | 2 +- compiler/test_mono/generated/ir_when_just.txt | 2 +- .../test_mono/generated/ir_when_maybe.txt | 2 +- .../test_mono/generated/ir_when_these.txt | 6 +- compiler/test_mono/generated/is_nil.txt | 4 +- .../generated/linked_list_length_twice.txt | 4 +- .../generated/nested_pattern_match.txt | 6 +- compiler/test_mono/generated/peano.txt | 8 +-- compiler/test_mono/generated/peano1.txt | 8 +-- compiler/test_mono/generated/peano2.txt | 10 +-- .../test_mono/generated/quicksort_swap.txt | 4 +- compiler/test_mono/generated/rigids.txt | 4 +- .../generated/specialize_closures.txt | 6 +- .../generated/specialize_lowlevel.txt | 4 +- .../test_mono/generated/when_nested_maybe.txt | 6 +- .../test_mono/generated/when_on_result.txt | 2 +- 23 files changed, 81 insertions(+), 149 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build_hash.rs b/compiler/gen_llvm/src/llvm/build_hash.rs index a122c2d2a5..4b8fb0955b 100644 --- a/compiler/gen_llvm/src/llvm/build_hash.rs +++ b/compiler/gen_llvm/src/llvm/build_hash.rs @@ -1,9 +1,7 @@ use crate::debug_info_init; use crate::llvm::bitcode::call_bitcode_fn; use crate::llvm::build::Env; -use crate::llvm::build::{ - cast_block_of_memory_to_tag, complex_bitcast, get_tag_id, FAST_CALL_CONV, -}; +use crate::llvm::build::{cast_block_of_memory_to_tag, get_tag_id, FAST_CALL_CONV, TAG_DATA_INDEX}; use crate::llvm::build_str; use crate::llvm::convert::basic_type_from_layout; use bumpalo::collections::Vec; @@ -408,7 +406,7 @@ fn hash_tag<'a, 'ctx, 'env>( env.builder.position_at_end(entry_block); match union_layout { NonRecursive(tags) => { - let tag_id = nonrec_tag_id(env, tag.into_struct_value()); + let tag_id = get_tag_id(env, parent, union_layout, tag).into_int_value(); let mut cases = Vec::with_capacity_in(tags.len(), env.arena); @@ -484,7 +482,6 @@ fn hash_tag<'a, 'ctx, 'env>( } NullableUnwrapped { other_fields, .. } => { let tag = tag.into_pointer_value(); - let other_fields = &other_fields[1..]; let is_null = env.builder.build_is_null(tag, "is_null"); @@ -534,11 +531,6 @@ fn hash_tag<'a, 'ctx, 'env>( } { - env.builder.position_at_end(hash_other_block); - - // SAFETY recursive tag unions are not NULL - let tag_id = unsafe { rec_tag_id_unsafe(env, tag) }; - let mut cases = Vec::with_capacity_in(other_tags.len(), env.arena); for (tag_id, field_layouts) in other_tags.iter().enumerate() { @@ -559,6 +551,8 @@ fn hash_tag<'a, 'ctx, 'env>( env.builder.position_at_end(hash_other_block); + let tag_id = get_tag_id(env, parent, union_layout, tag.into()).into_int_value(); + let default = cases.pop().unwrap().1; env.builder.build_switch(tag_id, default, &cases); @@ -765,18 +759,27 @@ fn hash_ptr_to_struct<'a, 'ctx, 'env>( ) -> IntValue<'ctx> { use inkwell::types::BasicType; - let struct_layout = Layout::Struct(field_layouts); - - let wrapper_type = basic_type_from_layout(env, &struct_layout); - debug_assert!(wrapper_type.is_struct_type()); + let wrapper_type = basic_type_from_layout(env, &Layout::Union(*union_layout)); // cast the opaque pointer to a pointer of the correct shape + let wrapper_ptr = env + .builder + .build_bitcast(tag, wrapper_type, "opaque_to_correct") + .into_pointer_value(); + + let struct_ptr = env + .builder + .build_struct_gep(wrapper_ptr, TAG_DATA_INDEX, "get_tag_data") + .unwrap(); + + let struct_layout = Layout::Struct(field_layouts); + let struct_type = basic_type_from_layout(env, &struct_layout); let struct_ptr = env .builder .build_bitcast( - tag, - wrapper_type.ptr_type(inkwell::AddressSpace::Generic), - "opaque_to_correct", + struct_ptr, + struct_type.ptr_type(inkwell::AddressSpace::Generic), + "cast_tag_data", ) .into_pointer_value(); @@ -830,34 +833,3 @@ fn hash_bitcode_fn<'a, 'ctx, 'env>( ) .into_int_value() } - -fn nonrec_tag_id<'a, 'ctx, 'env>( - env: &Env<'a, 'ctx, 'env>, - tag: StructValue<'ctx>, -) -> IntValue<'ctx> { - complex_bitcast( - env.builder, - tag.into(), - env.context.i64_type().into(), - "load_tag_id", - ) - .into_int_value() -} - -unsafe fn rec_tag_id_unsafe<'a, 'ctx, 'env>( - env: &Env<'a, 'ctx, 'env>, - tag: PointerValue<'ctx>, -) -> IntValue<'ctx> { - let ptr = env - .builder - .build_bitcast( - tag, - env.context - .i64_type() - .ptr_type(inkwell::AddressSpace::Generic), - "cast_for_tag_id", - ) - .into_pointer_value(); - - env.builder.build_load(ptr, "load_tag_id").into_int_value() -} diff --git a/compiler/gen_llvm/src/llvm/compare.rs b/compiler/gen_llvm/src/llvm/compare.rs index eac43ba889..d695dfbbca 100644 --- a/compiler/gen_llvm/src/llvm/compare.rs +++ b/compiler/gen_llvm/src/llvm/compare.rs @@ -1,5 +1,5 @@ use crate::llvm::build::Env; -use crate::llvm::build::{cast_block_of_memory_to_tag, FAST_CALL_CONV}; +use crate::llvm::build::{cast_block_of_memory_to_tag, get_tag_id, FAST_CALL_CONV}; use crate::llvm::build_list::{list_len, load_list_ptr}; use crate::llvm::build_str::str_equal; use crate::llvm::convert::basic_type_from_layout; @@ -846,10 +846,8 @@ fn build_tag_eq_help<'a, 'ctx, 'env>( match union_layout { NonRecursive(tags) => { - let id1 = - crate::llvm::build::get_tag_id(env, parent, union_layout, tag1).into_int_value(); - let id2 = - crate::llvm::build::get_tag_id(env, parent, union_layout, tag2).into_int_value(); + let id1 = get_tag_id(env, parent, union_layout, tag1).into_int_value(); + let id2 = get_tag_id(env, parent, union_layout, tag2).into_int_value(); let compare_tag_fields = ctx.append_basic_block(parent, "compare_tag_fields"); @@ -927,9 +925,8 @@ fn build_tag_eq_help<'a, 'ctx, 'env>( env.builder.position_at_end(compare_tag_ids); - // SAFETY we know that non-recursive tags cannot be NULL - let id1 = unsafe { rec_tag_id_unsafe(env, tag1.into_pointer_value()) }; - let id2 = unsafe { rec_tag_id_unsafe(env, tag2.into_pointer_value()) }; + let id1 = get_tag_id(env, parent, union_layout, tag1).into_int_value(); + let id2 = get_tag_id(env, parent, union_layout, tag2).into_int_value(); let compare_tag_fields = ctx.append_basic_block(parent, "compare_tag_fields"); @@ -974,9 +971,6 @@ fn build_tag_eq_help<'a, 'ctx, 'env>( env.builder.build_switch(id1, default, &cases); } NullableUnwrapped { other_fields, .. } => { - // drop the tag id; it is not stored - let other_fields = &other_fields[1..]; - let ptr_equal = env.builder.build_int_compare( IntPredicate::EQ, env.builder @@ -1082,9 +1076,8 @@ fn build_tag_eq_help<'a, 'ctx, 'env>( env.builder.position_at_end(compare_other); - // SAFETY we know at this point that tag1/tag2 are not NULL - let id1 = unsafe { rec_tag_id_unsafe(env, tag1.into_pointer_value()) }; - let id2 = unsafe { rec_tag_id_unsafe(env, tag2.into_pointer_value()) }; + let id1 = get_tag_id(env, parent, union_layout, tag1).into_int_value(); + let id2 = get_tag_id(env, parent, union_layout, tag2).into_int_value(); let compare_tag_fields = ctx.append_basic_block(parent, "compare_tag_fields"); @@ -1212,19 +1205,3 @@ fn eq_ptr_to_struct<'a, 'ctx, 'env>( ) .into_int_value() } - -unsafe fn rec_tag_id_unsafe<'a, 'ctx, 'env>( - env: &Env<'a, 'ctx, 'env>, - tag: PointerValue<'ctx>, -) -> IntValue<'ctx> { - let ptr = env - .builder - .build_bitcast( - tag, - env.context.i64_type().ptr_type(AddressSpace::Generic), - "cast_for_tag_id", - ) - .into_pointer_value(); - - env.builder.build_load(ptr, "load_tag_id").into_int_value() -} diff --git a/compiler/gen_llvm/src/llvm/refcounting.rs b/compiler/gen_llvm/src/llvm/refcounting.rs index b38c2f605c..93d8081419 100644 --- a/compiler/gen_llvm/src/llvm/refcounting.rs +++ b/compiler/gen_llvm/src/llvm/refcounting.rs @@ -1,6 +1,6 @@ use crate::debug_info_init; use crate::llvm::build::{ - add_func, cast_basic_basic, cast_block_of_memory_to_tag, Env, FAST_CALL_CONV, + add_func, cast_basic_basic, cast_block_of_memory_to_tag, get_tag_id, Env, FAST_CALL_CONV, LLVM_SADD_WITH_OVERFLOW_I64, TAG_DATA_INDEX, TAG_ID_INDEX, }; use crate::llvm::build_list::{incrementing_elem_loop, list_len, load_list}; @@ -1520,7 +1520,8 @@ fn build_rec_union_recursive_decrement<'a, 'ctx, 'env>( env.builder.build_unconditional_branch(only_branch); } else { // read the tag_id - let current_tag_id = rec_union_read_tag(env, value_ptr); + let current_tag_id = + get_tag_id(env, parent, &union_layout, value_ptr.into()).into_int_value(); let merge_block = env.context.append_basic_block(parent, "decrement_merge"); @@ -1538,23 +1539,6 @@ fn build_rec_union_recursive_decrement<'a, 'ctx, 'env>( } } -fn rec_union_read_tag<'a, 'ctx, 'env>( - env: &Env<'a, 'ctx, 'env>, - value_ptr: PointerValue<'ctx>, -) -> IntValue<'ctx> { - // Assumption: the tag is the first thing stored - // so cast the pointer to the data to a `i64*` - let tag_ptr_type = env.context.i64_type().ptr_type(AddressSpace::Generic); - let tag_ptr = env - .builder - .build_bitcast(value_ptr, tag_ptr_type, "cast_tag_ptr") - .into_pointer_value(); - - env.builder - .build_load(tag_ptr, "load_tag_id") - .into_int_value() -} - fn function_name_from_mode<'a>( layout_ids: &mut LayoutIds<'a>, interns: &Interns, diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 132143c8c2..6453da663b 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -19,7 +19,7 @@ use roc_types::subs::{Content, FlatType, Subs, Variable}; use std::collections::HashMap; use ven_pretty::{BoxAllocator, DocAllocator, DocBuilder}; -pub const PRETTY_PRINT_IR_SYMBOLS: bool = true; +pub const PRETTY_PRINT_IR_SYMBOLS: bool = false; macro_rules! return_on_layout_error { ($env:expr, $layout_result:expr) => { diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index 9c88c021ff..705f7e59c8 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -565,19 +565,18 @@ impl<'a> Layout<'a> { match variant { NonRecursive(fields) => { - let data_size: u32 = fields + fields .iter() .map(|tag_layout| { tag_layout .iter() .map(|field| field.stack_size(pointer_size)) - .sum() + .sum::() }) .max() - .unwrap_or_default(); - - // TEMPORARY - pointer_size + data_size + .unwrap_or_default() + // TODO remove + + pointer_size } Recursive(_) diff --git a/compiler/test_gen/src/gen_hash.rs b/compiler/test_gen/src/gen_hash.rs index 275a862881..3b41cca607 100644 --- a/compiler/test_gen/src/gen_hash.rs +++ b/compiler/test_gen/src/gen_hash.rs @@ -88,7 +88,7 @@ fn hash_expr() { Dict.hashTestOnly 0 (Add x x) "# ), - 18264046914072177411, + 2878521786781103245, u64 ); } @@ -106,7 +106,7 @@ fn hash_nullable_expr() { Dict.hashTestOnly 0 (Add x x) "# ), - 11103255846683455235, + 2878521786781103245, u64 ); } diff --git a/compiler/test_mono/generated/has_none.txt b/compiler/test_mono/generated/has_none.txt index 6c4861c73a..cfbfaadfae 100644 --- a/compiler/test_mono/generated/has_none.txt +++ b/compiler/test_mono/generated/has_none.txt @@ -7,7 +7,7 @@ procedure Test.3 (Test.4): let Test.14 = false; ret Test.14; else - let Test.19 = UnionAtIndex (Id 0) (Index 1) Test.4; + let Test.19 = UnionAtIndex (Id 0) (Index 0) Test.4; let Test.20 = 1i64; let Test.21 = GetTagId Test.19; let Test.22 = lowlevel Eq Test.20 Test.21; @@ -15,7 +15,7 @@ procedure Test.3 (Test.4): let Test.15 = true; ret Test.15; else - let Test.7 = UnionAtIndex (Id 0) (Index 2) Test.4; + let Test.7 = UnionAtIndex (Id 0) (Index 1) Test.4; jump Test.13 Test.7; in jump Test.13 Test.4; @@ -25,8 +25,8 @@ procedure Test.0 (): let Test.30 = 3i64; let Test.26 = Just Test.30; let Test.29 = 1i64; - let Test.27 = Nil Test.29; - let Test.12 = Cons Test.28 Test.26 Test.27; + let Test.27 = Nil ; + let Test.12 = Cons Test.26 Test.27; let Test.11 = CallByName Test.3 Test.12; dec Test.12; ret Test.11; diff --git a/compiler/test_mono/generated/ir_when_idiv.txt b/compiler/test_mono/generated/ir_when_idiv.txt index affcb522b5..a7463bbad2 100644 --- a/compiler/test_mono/generated/ir_when_idiv.txt +++ b/compiler/test_mono/generated/ir_when_idiv.txt @@ -18,7 +18,7 @@ procedure Test.0 (): let Test.6 = GetTagId Test.2; let Test.7 = lowlevel Eq Test.5 Test.6; if Test.7 then - let Test.1 = UnionAtIndex (Id 1) (Index 1) Test.2; + let Test.1 = UnionAtIndex (Id 1) (Index 0) Test.2; ret Test.1; else let Test.4 = -1i64; diff --git a/compiler/test_mono/generated/ir_when_just.txt b/compiler/test_mono/generated/ir_when_just.txt index abf6b535cf..4ef134c7eb 100644 --- a/compiler/test_mono/generated/ir_when_just.txt +++ b/compiler/test_mono/generated/ir_when_just.txt @@ -9,7 +9,7 @@ procedure Test.0 (): let Test.10 = GetTagId Test.1; let Test.11 = lowlevel Eq Test.9 Test.10; if Test.11 then - let Test.3 = UnionAtIndex (Id 0) (Index 1) Test.1; + let Test.3 = UnionAtIndex (Id 0) (Index 0) Test.1; let Test.5 = 1i64; let Test.4 = CallByName Num.24 Test.3 Test.5; ret Test.4; diff --git a/compiler/test_mono/generated/ir_when_maybe.txt b/compiler/test_mono/generated/ir_when_maybe.txt index 36c3bbf833..1cc90f1f16 100644 --- a/compiler/test_mono/generated/ir_when_maybe.txt +++ b/compiler/test_mono/generated/ir_when_maybe.txt @@ -5,7 +5,7 @@ procedure Test.0 (): let Test.7 = GetTagId Test.3; let Test.8 = lowlevel Eq Test.6 Test.7; if Test.8 then - let Test.2 = UnionAtIndex (Id 0) (Index 1) Test.3; + let Test.2 = UnionAtIndex (Id 0) (Index 0) Test.3; ret Test.2; else let Test.5 = 0i64; diff --git a/compiler/test_mono/generated/ir_when_these.txt b/compiler/test_mono/generated/ir_when_these.txt index 1ebd81868c..bcba501785 100644 --- a/compiler/test_mono/generated/ir_when_these.txt +++ b/compiler/test_mono/generated/ir_when_these.txt @@ -5,14 +5,14 @@ procedure Test.0 (): let Test.9 = GetTagId Test.5; switch Test.9: case 2: - let Test.2 = UnionAtIndex (Id 2) (Index 1) Test.5; + let Test.2 = UnionAtIndex (Id 2) (Index 0) Test.5; ret Test.2; case 0: - let Test.3 = UnionAtIndex (Id 0) (Index 1) Test.5; + let Test.3 = UnionAtIndex (Id 0) (Index 0) Test.5; ret Test.3; default: - let Test.4 = UnionAtIndex (Id 1) (Index 1) Test.5; + let Test.4 = UnionAtIndex (Id 1) (Index 0) Test.5; ret Test.4; diff --git a/compiler/test_mono/generated/is_nil.txt b/compiler/test_mono/generated/is_nil.txt index 81fd3b83b4..ec6a558c3a 100644 --- a/compiler/test_mono/generated/is_nil.txt +++ b/compiler/test_mono/generated/is_nil.txt @@ -13,8 +13,8 @@ procedure Test.0 (): let Test.17 = 0i64; let Test.15 = 2i64; let Test.18 = 1i64; - let Test.16 = Nil Test.18; - let Test.9 = Cons Test.17 Test.15 Test.16; + let Test.16 = Nil ; + let Test.9 = Cons Test.15 Test.16; let Test.8 = CallByName Test.2 Test.9; dec Test.9; ret Test.8; diff --git a/compiler/test_mono/generated/linked_list_length_twice.txt b/compiler/test_mono/generated/linked_list_length_twice.txt index 7f40cf68f5..92aa6d9c20 100644 --- a/compiler/test_mono/generated/linked_list_length_twice.txt +++ b/compiler/test_mono/generated/linked_list_length_twice.txt @@ -10,7 +10,7 @@ procedure Test.3 (Test.5): let Test.13 = 0i64; ret Test.13; else - let Test.6 = UnionAtIndex (Id 0) (Index 2) Test.5; + let Test.6 = UnionAtIndex (Id 0) (Index 1) Test.5; let Test.15 = 1i64; let Test.16 = CallByName Test.3 Test.6; let Test.14 = CallByName Num.24 Test.15 Test.16; @@ -18,7 +18,7 @@ procedure Test.3 (Test.5): procedure Test.0 (): let Test.21 = 1i64; - let Test.2 = Nil Test.21; + let Test.2 = Nil ; let Test.8 = CallByName Test.3 Test.2; let Test.9 = CallByName Test.3 Test.2; dec Test.2; diff --git a/compiler/test_mono/generated/nested_pattern_match.txt b/compiler/test_mono/generated/nested_pattern_match.txt index d88ecbae13..38b4165ff0 100644 --- a/compiler/test_mono/generated/nested_pattern_match.txt +++ b/compiler/test_mono/generated/nested_pattern_match.txt @@ -14,13 +14,13 @@ procedure Test.0 (): let Test.16 = GetTagId Test.2; let Test.19 = lowlevel Eq Test.15 Test.16; if Test.19 then - let Test.12 = UnionAtIndex (Id 0) (Index 1) Test.2; + let Test.12 = UnionAtIndex (Id 0) (Index 0) Test.2; let Test.13 = 0i64; let Test.14 = GetTagId Test.12; let Test.18 = lowlevel Eq Test.13 Test.14; if Test.18 then - let Test.10 = UnionAtIndex (Id 0) (Index 1) Test.2; - let Test.5 = UnionAtIndex (Id 0) (Index 1) Test.10; + let Test.10 = UnionAtIndex (Id 0) (Index 0) Test.2; + let Test.5 = UnionAtIndex (Id 0) (Index 0) Test.10; let Test.7 = 1i64; let Test.6 = CallByName Num.24 Test.5 Test.7; ret Test.6; diff --git a/compiler/test_mono/generated/peano.txt b/compiler/test_mono/generated/peano.txt index 2bd2ae3dc9..ba743a0f1d 100644 --- a/compiler/test_mono/generated/peano.txt +++ b/compiler/test_mono/generated/peano.txt @@ -3,8 +3,8 @@ procedure Test.0 (): let Test.11 = 0i64; let Test.13 = 0i64; let Test.14 = 1i64; - let Test.12 = Z Test.14; - let Test.10 = S Test.13 Test.12; - let Test.8 = S Test.11 Test.10; - let Test.2 = S Test.9 Test.8; + let Test.12 = Z ; + let Test.10 = S Test.12; + let Test.8 = S Test.10; + let Test.2 = S Test.8; ret Test.2; diff --git a/compiler/test_mono/generated/peano1.txt b/compiler/test_mono/generated/peano1.txt index fe683996cc..df1d0183c7 100644 --- a/compiler/test_mono/generated/peano1.txt +++ b/compiler/test_mono/generated/peano1.txt @@ -3,10 +3,10 @@ procedure Test.0 (): let Test.15 = 0i64; let Test.17 = 0i64; let Test.18 = 1i64; - let Test.16 = Z Test.18; - let Test.14 = S Test.17 Test.16; - let Test.12 = S Test.15 Test.14; - let Test.2 = S Test.13 Test.12; + let Test.16 = Z ; + let Test.14 = S Test.16; + let Test.12 = S Test.14; + let Test.2 = S Test.12; let Test.9 = 1i64; let Test.10 = GetTagId Test.2; dec Test.2; diff --git a/compiler/test_mono/generated/peano2.txt b/compiler/test_mono/generated/peano2.txt index c8392149a6..673b61ffe4 100644 --- a/compiler/test_mono/generated/peano2.txt +++ b/compiler/test_mono/generated/peano2.txt @@ -3,15 +3,15 @@ procedure Test.0 (): let Test.21 = 0i64; let Test.23 = 0i64; let Test.24 = 1i64; - let Test.22 = Z Test.24; - let Test.20 = S Test.23 Test.22; - let Test.18 = S Test.21 Test.20; - let Test.2 = S Test.19 Test.18; + let Test.22 = Z ; + let Test.20 = S Test.22; + let Test.18 = S Test.20; + let Test.2 = S Test.18; let Test.15 = 0i64; let Test.16 = GetTagId Test.2; let Test.17 = lowlevel Eq Test.15 Test.16; if Test.17 then - let Test.11 = UnionAtIndex (Id 0) (Index 1) Test.2; + let Test.11 = UnionAtIndex (Id 0) (Index 0) Test.2; inc Test.11; dec Test.2; let Test.12 = 0i64; diff --git a/compiler/test_mono/generated/quicksort_swap.txt b/compiler/test_mono/generated/quicksort_swap.txt index a866c1230d..fd927efcce 100644 --- a/compiler/test_mono/generated/quicksort_swap.txt +++ b/compiler/test_mono/generated/quicksort_swap.txt @@ -40,9 +40,9 @@ procedure Test.1 (Test.2): let Test.27 = lowlevel Eq Test.21 Test.22; if Test.27 then let Test.18 = StructAtIndex 0 Test.8; - let Test.4 = UnionAtIndex (Id 1) (Index 1) Test.18; + let Test.4 = UnionAtIndex (Id 1) (Index 0) Test.18; let Test.17 = StructAtIndex 1 Test.8; - let Test.5 = UnionAtIndex (Id 1) (Index 1) Test.17; + let Test.5 = UnionAtIndex (Id 1) (Index 0) Test.17; let Test.16 = 0i64; let Test.10 = CallByName List.4 Test.2 Test.16 Test.5; let Test.11 = 0i64; diff --git a/compiler/test_mono/generated/rigids.txt b/compiler/test_mono/generated/rigids.txt index c60474cef3..f8ccc8bde6 100644 --- a/compiler/test_mono/generated/rigids.txt +++ b/compiler/test_mono/generated/rigids.txt @@ -38,9 +38,9 @@ procedure Test.1 (Test.2, Test.3, Test.4): let Test.30 = lowlevel Eq Test.24 Test.25; if Test.30 then let Test.21 = StructAtIndex 0 Test.13; - let Test.6 = UnionAtIndex (Id 1) (Index 1) Test.21; + let Test.6 = UnionAtIndex (Id 1) (Index 0) Test.21; let Test.20 = StructAtIndex 1 Test.13; - let Test.7 = UnionAtIndex (Id 1) (Index 1) Test.20; + let Test.7 = UnionAtIndex (Id 1) (Index 0) Test.20; let Test.15 = CallByName List.4 Test.4 Test.2 Test.7; let Test.14 = CallByName List.4 Test.15 Test.3 Test.6; ret Test.14; diff --git a/compiler/test_mono/generated/specialize_closures.txt b/compiler/test_mono/generated/specialize_closures.txt index 6c3bc3eca9..9425c98bb8 100644 --- a/compiler/test_mono/generated/specialize_closures.txt +++ b/compiler/test_mono/generated/specialize_closures.txt @@ -22,13 +22,13 @@ procedure Test.1 (Test.2, Test.3): procedure Test.7 (Test.10, #Attr.12): - let Test.4 = UnionAtIndex (Id 0) (Index 1) #Attr.12; + let Test.4 = UnionAtIndex (Id 0) (Index 0) #Attr.12; let Test.28 = CallByName Num.24 Test.10 Test.4; ret Test.28; procedure Test.8 (Test.11, #Attr.12): - let Test.6 = UnionAtIndex (Id 1) (Index 2) #Attr.12; - let Test.5 = UnionAtIndex (Id 1) (Index 1) #Attr.12; + let Test.6 = UnionAtIndex (Id 1) (Index 1) #Attr.12; + let Test.5 = UnionAtIndex (Id 1) (Index 0) #Attr.12; if Test.6 then let Test.24 = CallByName Num.26 Test.11 Test.5; ret Test.24; diff --git a/compiler/test_mono/generated/specialize_lowlevel.txt b/compiler/test_mono/generated/specialize_lowlevel.txt index da0ce49195..ace0bbda7a 100644 --- a/compiler/test_mono/generated/specialize_lowlevel.txt +++ b/compiler/test_mono/generated/specialize_lowlevel.txt @@ -7,12 +7,12 @@ procedure Num.26 (#Attr.2, #Attr.3): ret Test.21; procedure Test.6 (Test.8, #Attr.12): - let Test.4 = UnionAtIndex (Id 0) (Index 1) #Attr.12; + let Test.4 = UnionAtIndex (Id 0) (Index 0) #Attr.12; let Test.24 = CallByName Num.24 Test.8 Test.4; ret Test.24; procedure Test.7 (Test.9, #Attr.12): - let Test.5 = UnionAtIndex (Id 1) (Index 1) #Attr.12; + let Test.5 = UnionAtIndex (Id 1) (Index 0) #Attr.12; let Test.20 = CallByName Num.26 Test.9 Test.5; ret Test.20; diff --git a/compiler/test_mono/generated/when_nested_maybe.txt b/compiler/test_mono/generated/when_nested_maybe.txt index d88ecbae13..38b4165ff0 100644 --- a/compiler/test_mono/generated/when_nested_maybe.txt +++ b/compiler/test_mono/generated/when_nested_maybe.txt @@ -14,13 +14,13 @@ procedure Test.0 (): let Test.16 = GetTagId Test.2; let Test.19 = lowlevel Eq Test.15 Test.16; if Test.19 then - let Test.12 = UnionAtIndex (Id 0) (Index 1) Test.2; + let Test.12 = UnionAtIndex (Id 0) (Index 0) Test.2; let Test.13 = 0i64; let Test.14 = GetTagId Test.12; let Test.18 = lowlevel Eq Test.13 Test.14; if Test.18 then - let Test.10 = UnionAtIndex (Id 0) (Index 1) Test.2; - let Test.5 = UnionAtIndex (Id 0) (Index 1) Test.10; + let Test.10 = UnionAtIndex (Id 0) (Index 0) Test.2; + let Test.5 = UnionAtIndex (Id 0) (Index 0) Test.10; let Test.7 = 1i64; let Test.6 = CallByName Num.24 Test.5 Test.7; ret Test.6; diff --git a/compiler/test_mono/generated/when_on_result.txt b/compiler/test_mono/generated/when_on_result.txt index 7651938c74..6b7b74b4ed 100644 --- a/compiler/test_mono/generated/when_on_result.txt +++ b/compiler/test_mono/generated/when_on_result.txt @@ -8,7 +8,7 @@ procedure Test.1 (Test.5): let Test.17 = GetTagId Test.2; let Test.18 = lowlevel Eq Test.16 Test.17; if Test.18 then - let Test.13 = UnionAtIndex (Id 1) (Index 1) Test.2; + let Test.13 = UnionAtIndex (Id 1) (Index 0) Test.2; let Test.14 = 3i64; let Test.15 = lowlevel Eq Test.14 Test.13; if Test.15 then From e27a12e6442503b1f5c96c557d705c53ee1e4d50 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 27 Jun 2021 14:43:45 +0200 Subject: [PATCH 392/496] add comment --- compiler/mono/src/layout.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index 705f7e59c8..879f2c8bb7 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -575,7 +575,7 @@ impl<'a> Layout<'a> { }) .max() .unwrap_or_default() - // TODO remove + // the size of the tag_id + pointer_size } From 3e387e83283ddc5b0c8db7a3dc49561c86a57c90 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 27 Jun 2021 15:08:57 +0200 Subject: [PATCH 393/496] refactor --- compiler/gen_llvm/src/llvm/build.rs | 908 ++++++++++++++-------------- compiler/mono/src/layout.rs | 9 + 2 files changed, 447 insertions(+), 470 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index f9704c8b43..637dc4070a 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -49,7 +49,6 @@ use morphic_lib::{ }; use roc_builtins::bitcode; use roc_collections::all::{ImMap, MutMap, MutSet}; -use roc_module::ident::TagName; use roc_module::low_level::LowLevel; use roc_module::symbol::{Interns, ModuleId, Symbol}; use roc_mono::ir::{ @@ -972,448 +971,11 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( Tag { arguments, - tag_layout: UnionLayout::NonRecursive(fields), + tag_layout: union_layout, union_size, tag_id, .. - } => { - debug_assert!(*union_size > 1); - - let ctx = env.context; - let builder = env.builder; - - // Determine types - let num_fields = arguments.len() + 1; - let mut field_types = Vec::with_capacity_in(num_fields, env.arena); - let mut field_vals = Vec::with_capacity_in(num_fields, env.arena); - - let tag_field_layouts = &fields[*tag_id as usize]; - - for (field_symbol, tag_field_layout) in arguments.iter().zip(tag_field_layouts.iter()) { - let (val, _val_layout) = load_symbol_and_layout(scope, field_symbol); - - // Zero-sized fields have no runtime representation. - // The layout of the struct expects them to be dropped! - if !tag_field_layout.is_dropped_because_empty() { - let field_type = basic_type_from_layout(env, tag_field_layout); - - field_types.push(field_type); - - if let Layout::RecursivePointer = tag_field_layout { - panic!( - r"non-recursive tag unions cannot directly contain a recursive pointer" - ); - } else { - // this check fails for recursive tag unions, but can be helpful while debugging - // debug_assert_eq!(tag_field_layout, val_layout); - - field_vals.push(val); - } - } - } - - // Create the struct_type - let struct_type = ctx.struct_type(field_types.into_bump_slice(), false); - - // Insert field exprs into struct_val - let struct_val = - struct_from_fields(env, struct_type, field_vals.into_iter().enumerate()); - - // How we create tag values - // - // The memory layout of tags can be different. e.g. in - // - // [ Ok Int, Err Str ] - // - // the `Ok` tag stores a 64-bit integer, the `Err` tag stores a struct. - // All tags of a union must have the same length, for easy addressing (e.g. array lookups). - // So we need to ask for the maximum of all tag's sizes, even if most tags won't use - // all that memory, and certainly won't use it in the same way (the tags have fields of - // different types/sizes) - // - // In llvm, we must be explicit about the type of value we're creating: we can't just - // make a unspecified block of memory. So what we do is create a byte array of the - // desired size. Then when we know which tag we have (which is here, in this function), - // we need to cast that down to the array of bytes that llvm expects - // - // There is the bitcast instruction, but it doesn't work for arrays. So we need to jump - // through some hoops using store and load to get this to work: the array is put into a - // one-element struct, which can be cast to the desired type. - // - // This tricks comes from - // https://github.com/raviqqe/ssf/blob/bc32aae68940d5bddf5984128e85af75ca4f4686/ssf-llvm/src/expression_compiler.rs#L116 - - let internal_type = block_of_memory_slices(env.context, fields, env.ptr_bytes); - - let data = cast_tag_to_block_of_memory(builder, struct_val, internal_type); - let tag_id_type = env.context.i64_type(); - let wrapper_type = env - .context - .struct_type(&[data.get_type(), tag_id_type.into()], false); - - let tag_id_intval = tag_id_type.const_int(*tag_id as u64, false); - - let field_vals = [ - (TAG_ID_INDEX as usize, tag_id_intval.into()), - (TAG_DATA_INDEX as usize, data), - ]; - - struct_from_fields(env, wrapper_type, field_vals.iter().copied()).into() - } - Tag { - arguments, - tag_layout: UnionLayout::Recursive(tags), - union_size, - tag_id, - .. - } => { - debug_assert!(*union_size > 1); - - let ctx = env.context; - let builder = env.builder; - - // Determine types - let num_fields = arguments.len() + 1; - let mut field_types = Vec::with_capacity_in(num_fields, env.arena); - let mut field_vals = Vec::with_capacity_in(num_fields, env.arena); - - let tag_field_layouts = &tags[*tag_id as usize]; - - for (field_symbol, tag_field_layout) in arguments.iter().zip(tag_field_layouts.iter()) { - let (val, _val_layout) = load_symbol_and_layout(scope, field_symbol); - - let field_type = basic_type_from_layout(env, tag_field_layout); - - field_types.push(field_type); - - if let Layout::RecursivePointer = tag_field_layout { - debug_assert!(val.is_pointer_value()); - - // we store recursive pointers as `i64*` - let ptr = env.builder.build_bitcast( - val, - ctx.i64_type().ptr_type(AddressSpace::Generic), - "cast_recursive_pointer", - ); - - field_vals.push(ptr); - } else { - // this check fails for recursive tag unions, but can be helpful while debugging - // debug_assert_eq!(tag_field_layout, val_layout); - - field_vals.push(val); - } - } - - // Create the struct_type - let raw_data_ptr = reserve_with_refcount_union_as_block_of_memory2(env, tags); - - let tag_id_ptr = builder - .build_struct_gep(raw_data_ptr, TAG_ID_INDEX, "tag_id_index") - .unwrap(); - - let tag_id_type = env.context.i64_type(); - env.builder - .build_store(tag_id_ptr, tag_id_type.const_int(*tag_id as u64, false)); - - let opaque_struct_ptr = builder - .build_struct_gep(raw_data_ptr, TAG_DATA_INDEX, "tag_data_index") - .unwrap(); - - let struct_type = env.context.struct_type(&field_types, false); - let struct_ptr = env - .builder - .build_bitcast( - opaque_struct_ptr, - struct_type.ptr_type(AddressSpace::Generic), - "struct_ptr", - ) - .into_pointer_value(); - - // Insert field exprs into struct_val - for (index, field_val) in field_vals.into_iter().enumerate() { - let field_ptr = builder - .build_struct_gep(struct_ptr, index as u32, "field_struct_gep") - .unwrap(); - - builder.build_store(field_ptr, field_val); - } - - raw_data_ptr.into() - } - - Tag { - arguments, - tag_layout: UnionLayout::NonNullableUnwrapped(fields), - union_size, - tag_id, - .. - } => { - debug_assert_eq!(*union_size, 1); - debug_assert_eq!(*tag_id, 0); - debug_assert_eq!(arguments.len(), fields.len()); - - let ctx = env.context; - let builder = env.builder; - - // Determine types - let num_fields = arguments.len() + 1; - let mut field_types = Vec::with_capacity_in(num_fields, env.arena); - let mut field_vals = Vec::with_capacity_in(num_fields, env.arena); - - for (field_symbol, tag_field_layout) in arguments.iter().zip(fields.iter()) { - let val = load_symbol(scope, field_symbol); - - let field_type = basic_type_from_layout(env, tag_field_layout); - - field_types.push(field_type); - - if let Layout::RecursivePointer = tag_field_layout { - debug_assert!(val.is_pointer_value()); - - // we store recursive pointers as `i64*` - let ptr = env.builder.build_bitcast( - val, - ctx.i64_type().ptr_type(AddressSpace::Generic), - "cast_recursive_pointer", - ); - - field_vals.push(ptr); - } else { - // this check fails for recursive tag unions, but can be helpful while debugging - - field_vals.push(val); - } - } - - // Create the struct_type - let data_ptr = reserve_with_refcount_union_as_block_of_memory(env, &[fields]); - - let struct_type = ctx.struct_type(field_types.into_bump_slice(), false); - let struct_ptr = env - .builder - .build_bitcast( - data_ptr, - struct_type.ptr_type(AddressSpace::Generic), - "block_of_memory_to_tag", - ) - .into_pointer_value(); - - // Insert field exprs into struct_val - for (index, field_val) in field_vals.into_iter().enumerate() { - let field_ptr = builder - .build_struct_gep(struct_ptr, index as u32, "struct_gep") - .unwrap(); - - builder.build_store(field_ptr, field_val); - } - - data_ptr.into() - } - - Tag { - arguments, - tag_layout: - UnionLayout::NullableWrapped { - nullable_id, - other_tags: tags, - }, - union_size, - tag_id, - .. - } => { - if *tag_id == *nullable_id as u8 { - let layout = Layout::Union(UnionLayout::NullableWrapped { - nullable_id: *nullable_id, - other_tags: tags, - }); - - return basic_type_from_layout(env, &layout) - .into_pointer_type() - .const_null() - .into(); - } - - debug_assert!(*union_size > 1); - - let ctx = env.context; - let builder = env.builder; - - // Determine types - let num_fields = arguments.len() + 1; - let mut field_types = Vec::with_capacity_in(num_fields, env.arena); - let mut field_vals = Vec::with_capacity_in(num_fields, env.arena); - - let tag_field_layouts = { - use std::cmp::Ordering::*; - match tag_id.cmp(&(*nullable_id as u8)) { - Equal => unreachable!("early return above"), - Less => &tags[*tag_id as usize], - Greater => &tags[*tag_id as usize - 1], - } - }; - - for (field_symbol, tag_field_layout) in arguments.iter().zip(tag_field_layouts.iter()) { - let val = load_symbol(scope, field_symbol); - - // Zero-sized fields have no runtime representation. - // The layout of the struct expects them to be dropped! - if !tag_field_layout.is_dropped_because_empty() { - let field_type = basic_type_from_layout(env, tag_field_layout); - - field_types.push(field_type); - - if let Layout::RecursivePointer = tag_field_layout { - debug_assert!(val.is_pointer_value()); - - // we store recursive pointers as `i64*` - let ptr = env.builder.build_bitcast( - val, - ctx.i64_type().ptr_type(AddressSpace::Generic), - "cast_recursive_pointer", - ); - - field_vals.push(ptr); - } else { - // this check fails for recursive tag unions, but can be helpful while debugging - // debug_assert_eq!(tag_field_layout, val_layout); - - field_vals.push(val); - } - } - } - - // Create the struct_type - let raw_data_ptr = reserve_with_refcount_union_as_block_of_memory2(env, tags); - - let tag_id_ptr = builder - .build_struct_gep(raw_data_ptr, TAG_ID_INDEX, "tag_id_index") - .unwrap(); - - let tag_id_type = env.context.i64_type(); - env.builder - .build_store(tag_id_ptr, tag_id_type.const_int(*tag_id as u64, false)); - - let opaque_struct_ptr = builder - .build_struct_gep(raw_data_ptr, TAG_DATA_INDEX, "tag_data_index") - .unwrap(); - - let struct_type = env.context.struct_type(&field_types, false); - let struct_ptr = env - .builder - .build_bitcast( - opaque_struct_ptr, - struct_type.ptr_type(AddressSpace::Generic), - "struct_ptr", - ) - .into_pointer_value(); - - // Insert field exprs into struct_val - for (index, field_val) in field_vals.into_iter().enumerate() { - let field_ptr = builder - .build_struct_gep(struct_ptr, index as u32, "field_struct_gep") - .unwrap(); - - builder.build_store(field_ptr, field_val); - } - - raw_data_ptr.into() - } - - Tag { - arguments, - tag_layout: - UnionLayout::NullableUnwrapped { - nullable_id, - other_fields, - .. - }, - union_size, - tag_id, - tag_name, - .. - } => { - let tag_struct_type = - block_of_memory_slices(env.context, &[other_fields], env.ptr_bytes); - - if *tag_id == *nullable_id as u8 { - let output_type = tag_struct_type.ptr_type(AddressSpace::Generic); - - return output_type.const_null().into(); - } - - // this tag id is not the nullable one. For the type to be recursive, the other - // constructor must have at least one argument! - debug_assert!(!arguments.is_empty()); - - debug_assert!(*union_size == 2); - - let ctx = env.context; - let builder = env.builder; - - // Determine types - let num_fields = arguments.len() + 1; - let mut field_types = Vec::with_capacity_in(num_fields, env.arena); - let mut field_vals = Vec::with_capacity_in(num_fields, env.arena); - - debug_assert!(!matches!(tag_name, TagName::Closure(_))); - - debug_assert_eq!(arguments.len(), other_fields.len()); - - for (field_symbol, tag_field_layout) in arguments.iter().zip(other_fields.iter()) { - let val = load_symbol(scope, field_symbol); - - // Zero-sized fields have no runtime representation. - // The layout of the struct expects them to be dropped! - if !tag_field_layout.is_dropped_because_empty() { - let field_type = basic_type_from_layout(env, tag_field_layout); - - field_types.push(field_type); - - if let Layout::RecursivePointer = tag_field_layout { - debug_assert!(val.is_pointer_value()); - - // we store recursive pointers as `i64*` - let ptr = env.builder.build_bitcast( - val, - ctx.i64_type().ptr_type(AddressSpace::Generic), - "cast_recursive_pointer", - ); - - field_vals.push(ptr); - } else { - // this check fails for recursive tag unions, but can be helpful while debugging - // debug_assert_eq!(tag_field_layout, val_layout); - - field_vals.push(val); - } - } - } - - // Create the struct_type - let data_ptr = reserve_with_refcount_union_as_block_of_memory(env, &[other_fields]); - - let struct_type = ctx.struct_type(field_types.into_bump_slice(), false); - let struct_ptr = env - .builder - .build_bitcast( - data_ptr, - struct_type.ptr_type(AddressSpace::Generic), - "block_of_memory_to_tag", - ) - .into_pointer_value(); - - // Insert field exprs into struct_val - for (index, field_val) in field_vals.into_iter().enumerate() { - let field_ptr = builder - .build_struct_gep(struct_ptr, index as u32, "struct_gep") - .unwrap(); - - builder.build_store(field_ptr, field_val); - } - - data_ptr.into() - } + } => build_tag(env, scope, union_layout, *union_size, *tag_id, arguments), Reset(_) => todo!(), Reuse { .. } => todo!(), @@ -1599,6 +1161,424 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( } } +pub fn build_tag<'a, 'ctx, 'env>( + env: &Env<'a, 'ctx, 'env>, + scope: &Scope<'a, 'ctx>, + union_layout: &UnionLayout<'a>, + union_size: u8, + tag_id: u8, + arguments: &[Symbol], +) -> BasicValueEnum<'ctx> { + match union_layout { + UnionLayout::NonRecursive(fields) => { + debug_assert!(union_size > 1); + + let ctx = env.context; + let builder = env.builder; + + // Determine types + let num_fields = arguments.len() + 1; + let mut field_types = Vec::with_capacity_in(num_fields, env.arena); + let mut field_vals = Vec::with_capacity_in(num_fields, env.arena); + + let tag_field_layouts = &fields[tag_id as usize]; + + for (field_symbol, tag_field_layout) in arguments.iter().zip(tag_field_layouts.iter()) { + let (val, _val_layout) = load_symbol_and_layout(scope, field_symbol); + + // Zero-sized fields have no runtime representation. + // The layout of the struct expects them to be dropped! + if !tag_field_layout.is_dropped_because_empty() { + let field_type = basic_type_from_layout(env, tag_field_layout); + + field_types.push(field_type); + + if let Layout::RecursivePointer = tag_field_layout { + panic!( + r"non-recursive tag unions cannot directly contain a recursive pointer" + ); + } else { + // this check fails for recursive tag unions, but can be helpful while debugging + // debug_assert_eq!(tag_field_layout, val_layout); + + field_vals.push(val); + } + } + } + + // Create the struct_type + let struct_type = ctx.struct_type(field_types.into_bump_slice(), false); + + // Insert field exprs into struct_val + let struct_val = + struct_from_fields(env, struct_type, field_vals.into_iter().enumerate()); + + // How we create tag values + // + // The memory layout of tags can be different. e.g. in + // + // [ Ok Int, Err Str ] + // + // the `Ok` tag stores a 64-bit integer, the `Err` tag stores a struct. + // All tags of a union must have the same length, for easy addressing (e.g. array lookups). + // So we need to ask for the maximum of all tag's sizes, even if most tags won't use + // all that memory, and certainly won't use it in the same way (the tags have fields of + // different types/sizes) + // + // In llvm, we must be explicit about the type of value we're creating: we can't just + // make a unspecified block of memory. So what we do is create a byte array of the + // desired size. Then when we know which tag we have (which is here, in this function), + // we need to cast that down to the array of bytes that llvm expects + // + // There is the bitcast instruction, but it doesn't work for arrays. So we need to jump + // through some hoops using store and load to get this to work: the array is put into a + // one-element struct, which can be cast to the desired type. + // + // This tricks comes from + // https://github.com/raviqqe/ssf/blob/bc32aae68940d5bddf5984128e85af75ca4f4686/ssf-llvm/src/expression_compiler.rs#L116 + + let internal_type = block_of_memory_slices(env.context, fields, env.ptr_bytes); + + let data = cast_tag_to_block_of_memory(builder, struct_val, internal_type); + let tag_id_type = env.context.i64_type(); + let wrapper_type = env + .context + .struct_type(&[data.get_type(), tag_id_type.into()], false); + + let tag_id_intval = tag_id_type.const_int(tag_id as u64, false); + + let field_vals = [ + (TAG_ID_INDEX as usize, tag_id_intval.into()), + (TAG_DATA_INDEX as usize, data), + ]; + + struct_from_fields(env, wrapper_type, field_vals.iter().copied()).into() + } + UnionLayout::Recursive(tags) => { + debug_assert!(union_size > 1); + + let ctx = env.context; + let builder = env.builder; + + // Determine types + let num_fields = arguments.len() + 1; + let mut field_types = Vec::with_capacity_in(num_fields, env.arena); + let mut field_vals = Vec::with_capacity_in(num_fields, env.arena); + + let tag_field_layouts = &tags[tag_id as usize]; + + for (field_symbol, tag_field_layout) in arguments.iter().zip(tag_field_layouts.iter()) { + let (val, _val_layout) = load_symbol_and_layout(scope, field_symbol); + + let field_type = basic_type_from_layout(env, tag_field_layout); + + field_types.push(field_type); + + if let Layout::RecursivePointer = tag_field_layout { + debug_assert!(val.is_pointer_value()); + + // we store recursive pointers as `i64*` + let ptr = env.builder.build_bitcast( + val, + ctx.i64_type().ptr_type(AddressSpace::Generic), + "cast_recursive_pointer", + ); + + field_vals.push(ptr); + } else { + // this check fails for recursive tag unions, but can be helpful while debugging + // debug_assert_eq!(tag_field_layout, val_layout); + + field_vals.push(val); + } + } + + // Create the struct_type + let raw_data_ptr = + reserve_with_refcount_union_as_block_of_memory(env, *union_layout, tags); + + let tag_id_ptr = builder + .build_struct_gep(raw_data_ptr, TAG_ID_INDEX, "tag_id_index") + .unwrap(); + + let tag_id_type = env.context.i64_type(); + env.builder + .build_store(tag_id_ptr, tag_id_type.const_int(tag_id as u64, false)); + + let opaque_struct_ptr = builder + .build_struct_gep(raw_data_ptr, TAG_DATA_INDEX, "tag_data_index") + .unwrap(); + + let struct_type = env.context.struct_type(&field_types, false); + let struct_ptr = env + .builder + .build_bitcast( + opaque_struct_ptr, + struct_type.ptr_type(AddressSpace::Generic), + "struct_ptr", + ) + .into_pointer_value(); + + // Insert field exprs into struct_val + for (index, field_val) in field_vals.into_iter().enumerate() { + let field_ptr = builder + .build_struct_gep(struct_ptr, index as u32, "field_struct_gep") + .unwrap(); + + builder.build_store(field_ptr, field_val); + } + + raw_data_ptr.into() + } + UnionLayout::NonNullableUnwrapped(fields) => { + debug_assert_eq!(union_size, 1); + debug_assert_eq!(tag_id, 0); + debug_assert_eq!(arguments.len(), fields.len()); + + let ctx = env.context; + let builder = env.builder; + + // Determine types + let num_fields = arguments.len() + 1; + let mut field_types = Vec::with_capacity_in(num_fields, env.arena); + let mut field_vals = Vec::with_capacity_in(num_fields, env.arena); + + for (field_symbol, tag_field_layout) in arguments.iter().zip(fields.iter()) { + let val = load_symbol(scope, field_symbol); + + let field_type = basic_type_from_layout(env, tag_field_layout); + + field_types.push(field_type); + + if let Layout::RecursivePointer = tag_field_layout { + debug_assert!(val.is_pointer_value()); + + // we store recursive pointers as `i64*` + let ptr = env.builder.build_bitcast( + val, + ctx.i64_type().ptr_type(AddressSpace::Generic), + "cast_recursive_pointer", + ); + + field_vals.push(ptr); + } else { + // this check fails for recursive tag unions, but can be helpful while debugging + + field_vals.push(val); + } + } + + // Create the struct_type + let data_ptr = + reserve_with_refcount_union_as_block_of_memory(env, *union_layout, &[fields]); + + let struct_type = ctx.struct_type(field_types.into_bump_slice(), false); + let struct_ptr = env + .builder + .build_bitcast( + data_ptr, + struct_type.ptr_type(AddressSpace::Generic), + "block_of_memory_to_tag", + ) + .into_pointer_value(); + + // Insert field exprs into struct_val + for (index, field_val) in field_vals.into_iter().enumerate() { + let field_ptr = builder + .build_struct_gep(struct_ptr, index as u32, "struct_gep") + .unwrap(); + + builder.build_store(field_ptr, field_val); + } + + data_ptr.into() + } + UnionLayout::NullableWrapped { + nullable_id, + other_tags: tags, + } => { + if tag_id == *nullable_id as u8 { + let layout = Layout::Union(*union_layout); + + return basic_type_from_layout(env, &layout) + .into_pointer_type() + .const_null() + .into(); + } + + debug_assert!(union_size > 1); + + let ctx = env.context; + let builder = env.builder; + + // Determine types + let num_fields = arguments.len() + 1; + let mut field_types = Vec::with_capacity_in(num_fields, env.arena); + let mut field_vals = Vec::with_capacity_in(num_fields, env.arena); + + let tag_field_layouts = { + use std::cmp::Ordering::*; + match tag_id.cmp(&(*nullable_id as u8)) { + Equal => unreachable!("early return above"), + Less => &tags[tag_id as usize], + Greater => &tags[tag_id as usize - 1], + } + }; + + for (field_symbol, tag_field_layout) in arguments.iter().zip(tag_field_layouts.iter()) { + let val = load_symbol(scope, field_symbol); + + // Zero-sized fields have no runtime representation. + // The layout of the struct expects them to be dropped! + if !tag_field_layout.is_dropped_because_empty() { + let field_type = basic_type_from_layout(env, tag_field_layout); + + field_types.push(field_type); + + if let Layout::RecursivePointer = tag_field_layout { + debug_assert!(val.is_pointer_value()); + + // we store recursive pointers as `i64*` + let ptr = env.builder.build_bitcast( + val, + ctx.i64_type().ptr_type(AddressSpace::Generic), + "cast_recursive_pointer", + ); + + field_vals.push(ptr); + } else { + // this check fails for recursive tag unions, but can be helpful while debugging + // debug_assert_eq!(tag_field_layout, val_layout); + + field_vals.push(val); + } + } + } + + // Create the struct_type + let raw_data_ptr = + reserve_with_refcount_union_as_block_of_memory(env, *union_layout, tags); + + let tag_id_ptr = builder + .build_struct_gep(raw_data_ptr, TAG_ID_INDEX, "tag_id_index") + .unwrap(); + + let tag_id_type = env.context.i64_type(); + env.builder + .build_store(tag_id_ptr, tag_id_type.const_int(tag_id as u64, false)); + + let opaque_struct_ptr = builder + .build_struct_gep(raw_data_ptr, TAG_DATA_INDEX, "tag_data_index") + .unwrap(); + + let struct_type = env.context.struct_type(&field_types, false); + let struct_ptr = env + .builder + .build_bitcast( + opaque_struct_ptr, + struct_type.ptr_type(AddressSpace::Generic), + "struct_ptr", + ) + .into_pointer_value(); + + // Insert field exprs into struct_val + for (index, field_val) in field_vals.into_iter().enumerate() { + let field_ptr = builder + .build_struct_gep(struct_ptr, index as u32, "field_struct_gep") + .unwrap(); + + builder.build_store(field_ptr, field_val); + } + + raw_data_ptr.into() + } + UnionLayout::NullableUnwrapped { + nullable_id, + other_fields, + } => { + let tag_struct_type = + block_of_memory_slices(env.context, &[other_fields], env.ptr_bytes); + + if tag_id == *nullable_id as u8 { + let output_type = tag_struct_type.ptr_type(AddressSpace::Generic); + + return output_type.const_null().into(); + } + + // this tag id is not the nullable one. For the type to be recursive, the other + // constructor must have at least one argument! + debug_assert!(!arguments.is_empty()); + + debug_assert!(union_size == 2); + + let ctx = env.context; + let builder = env.builder; + + // Determine types + let num_fields = arguments.len() + 1; + let mut field_types = Vec::with_capacity_in(num_fields, env.arena); + let mut field_vals = Vec::with_capacity_in(num_fields, env.arena); + + debug_assert_eq!(arguments.len(), other_fields.len()); + + for (field_symbol, tag_field_layout) in arguments.iter().zip(other_fields.iter()) { + let val = load_symbol(scope, field_symbol); + + // Zero-sized fields have no runtime representation. + // The layout of the struct expects them to be dropped! + if !tag_field_layout.is_dropped_because_empty() { + let field_type = basic_type_from_layout(env, tag_field_layout); + + field_types.push(field_type); + + if let Layout::RecursivePointer = tag_field_layout { + debug_assert!(val.is_pointer_value()); + + // we store recursive pointers as `i64*` + let ptr = env.builder.build_bitcast( + val, + ctx.i64_type().ptr_type(AddressSpace::Generic), + "cast_recursive_pointer", + ); + + field_vals.push(ptr); + } else { + // this check fails for recursive tag unions, but can be helpful while debugging + // debug_assert_eq!(tag_field_layout, val_layout); + + field_vals.push(val); + } + } + } + + // Create the struct_type + let data_ptr = + reserve_with_refcount_union_as_block_of_memory(env, *union_layout, &[other_fields]); + + let struct_type = ctx.struct_type(field_types.into_bump_slice(), false); + let struct_ptr = env + .builder + .build_bitcast( + data_ptr, + struct_type.ptr_type(AddressSpace::Generic), + "block_of_memory_to_tag", + ) + .into_pointer_value(); + + // Insert field exprs into struct_val + for (index, field_val) in field_vals.into_iter().enumerate() { + let field_ptr = builder + .build_struct_gep(struct_ptr, index as u32, "struct_gep") + .unwrap(); + + builder.build_store(field_ptr, field_val); + } + + data_ptr.into() + } + } +} + pub fn get_tag_id<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, parent: FunctionValue<'ctx>, @@ -1774,44 +1754,32 @@ pub fn reserve_with_refcount<'a, 'ctx, 'env>( fn reserve_with_refcount_union_as_block_of_memory<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, - fields: &[&[Layout<'a>]], -) -> PointerValue<'ctx> { - let basic_type = block_of_memory_slices(env.context, fields, env.ptr_bytes); - - let stack_size = fields - .iter() - .map(|tag| tag.iter().map(|l| l.stack_size(env.ptr_bytes)).sum()) - .max() - .unwrap_or(0); - - let alignment_bytes = fields - .iter() - .map(|tag| tag.iter().map(|l| l.alignment_bytes(env.ptr_bytes))) - .flatten() - .max() - .unwrap_or(0); - - reserve_with_refcount_help(env, basic_type, stack_size, alignment_bytes) -} - -fn reserve_with_refcount_union_as_block_of_memory2<'a, 'ctx, 'env>( - env: &Env<'a, 'ctx, 'env>, + union_layout: UnionLayout<'a>, fields: &[&[Layout<'a>]], ) -> PointerValue<'ctx> { let block_type = block_of_memory_slices(env.context, fields, env.ptr_bytes); - let tag_id_type = env.context.i64_type(); - let basic_type = env - .context - .struct_type(&[block_type, tag_id_type.into()], false); + let tag_id_stack_size = union_layout + .tag_id_layout() + .map(|l| l.stack_size(env.ptr_bytes)); - let stack_size = fields + let basic_type = if tag_id_stack_size.is_some() { + let tag_id_type = env.context.i64_type(); + + env.context + .struct_type(&[block_type, tag_id_type.into()], false) + .into() + } else { + block_type + }; + + let mut stack_size = fields .iter() .map(|tag| tag.iter().map(|l| l.stack_size(env.ptr_bytes)).sum()) .max() - .unwrap_or(0) - // add tag id - + env.ptr_bytes; + .unwrap_or_default(); + + stack_size += tag_id_stack_size.unwrap_or_default(); let alignment_bytes = fields .iter() diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index 879f2c8bb7..ae3e01bab3 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -152,6 +152,15 @@ impl<'a> UnionLayout<'a> { result } } + + pub fn tag_id_layout(&self) -> Option> { + match self { + UnionLayout::NonRecursive(_) + | UnionLayout::Recursive(_) + | UnionLayout::NullableWrapped { .. } => Some(Layout::Builtin(Builtin::Int64)), + UnionLayout::NonNullableUnwrapped(_) | UnionLayout::NullableUnwrapped { .. } => None, + } + } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] From 3e53f0a14dea4de7fccc0afdd6f63f1ee2c17ecf Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 27 Jun 2021 20:37:44 +0200 Subject: [PATCH 394/496] cleanup --- compiler/gen_llvm/src/llvm/bitcode.rs | 3 +- compiler/gen_llvm/src/llvm/build.rs | 42 ++++++++++++----------- compiler/gen_llvm/src/llvm/build_hash.rs | 6 ++-- compiler/gen_llvm/src/llvm/compare.rs | 12 +++---- compiler/gen_llvm/src/llvm/refcounting.rs | 3 +- 5 files changed, 33 insertions(+), 33 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/bitcode.rs b/compiler/gen_llvm/src/llvm/bitcode.rs index 6c662d9c4d..b92df1f79b 100644 --- a/compiler/gen_llvm/src/llvm/bitcode.rs +++ b/compiler/gen_llvm/src/llvm/bitcode.rs @@ -141,8 +141,7 @@ fn build_has_tag_id_help<'a, 'ctx, 'env>( let actual_tag_id = { let tag_id_i64 = - crate::llvm::build::get_tag_id(env, function_value, &union_layout, tag_value) - .into_int_value(); + crate::llvm::build::get_tag_id(env, function_value, &union_layout, tag_value); env.builder .build_int_cast(tag_id_i64, env.context.i16_type(), "to_i16") diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 637dc4070a..fa4e942bcb 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -1156,7 +1156,7 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( // cast the argument bytes into the desired shape for this tag let (argument, _structure_layout) = load_symbol_and_layout(scope, structure); - get_tag_id(env, parent, union_layout, argument) + get_tag_id(env, parent, &union_layout, argument).into() } } } @@ -1584,20 +1584,18 @@ pub fn get_tag_id<'a, 'ctx, 'env>( parent: FunctionValue<'ctx>, union_layout: &UnionLayout<'a>, argument: BasicValueEnum<'ctx>, -) -> BasicValueEnum<'ctx> { +) -> IntValue<'ctx> { let builder = env.builder; match union_layout { UnionLayout::NonRecursive(_) => { let tag = argument.into_struct_value(); - builder - .build_extract_value(tag, TAG_ID_INDEX, "get_tag_id") - .unwrap() + extract_tag_discriminant_non_recursive(env, tag) } UnionLayout::Recursive(_) => { - extract_tag_discriminant_ptr2(env, argument.into_pointer_value()).into() + extract_tag_discriminant_ptr(env, argument.into_pointer_value()) } - UnionLayout::NonNullableUnwrapped(_) => env.context.i64_type().const_zero().into(), + UnionLayout::NonNullableUnwrapped(_) => env.context.i64_type().const_zero(), UnionLayout::NullableWrapped { nullable_id, .. } => { let argument_ptr = argument.into_pointer_value(); let is_null = env.builder.build_is_null(argument_ptr, "is_null"); @@ -1621,14 +1619,16 @@ pub fn get_tag_id<'a, 'ctx, 'env>( { env.builder.position_at_end(else_block); - let tag_id = extract_tag_discriminant_ptr2(env, argument_ptr); + let tag_id = extract_tag_discriminant_ptr(env, argument_ptr); env.builder.build_store(result, tag_id); env.builder.build_unconditional_branch(cont_block); } env.builder.position_at_end(cont_block); - env.builder.build_load(result, "load_result") + env.builder + .build_load(result, "load_result") + .into_int_value() } UnionLayout::NullableUnwrapped { nullable_id, .. } => { let argument_ptr = argument.into_pointer_value(); @@ -1641,6 +1641,7 @@ pub fn get_tag_id<'a, 'ctx, 'env>( env.builder .build_select(is_null, then_value, else_value, "select_tag_id") + .into_int_value() } } } @@ -2545,16 +2546,7 @@ pub fn complex_bitcast<'ctx>( } } -pub fn extract_tag_discriminant<'a, 'ctx, 'env>( - env: &Env<'a, 'ctx, 'env>, - parent: FunctionValue<'ctx>, - union_layout: UnionLayout<'a>, - cond_value: BasicValueEnum<'ctx>, -) -> IntValue<'ctx> { - get_tag_id(env, parent, &union_layout, cond_value).into_int_value() -} - -fn extract_tag_discriminant_ptr2<'a, 'ctx, 'env>( +fn extract_tag_discriminant_ptr<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, from_value: PointerValue<'ctx>, ) -> IntValue<'ctx> { @@ -2568,6 +2560,16 @@ fn extract_tag_discriminant_ptr2<'a, 'ctx, 'env>( .into_int_value() } +fn extract_tag_discriminant_non_recursive<'a, 'ctx, 'env>( + env: &Env<'a, 'ctx, 'env>, + tag: StructValue<'ctx>, +) -> IntValue<'ctx> { + env.builder + .build_extract_value(tag, TAG_ID_INDEX, "get_tag_id") + .unwrap() + .into_int_value() +} + struct SwitchArgsIr<'a, 'ctx> { pub cond_symbol: Symbol, pub cond_layout: Layout<'a>, @@ -2647,7 +2649,7 @@ fn build_switch_ir<'a, 'ctx, 'env>( Layout::Union(variant) => { cond_layout = Layout::Builtin(Builtin::Int64); - extract_tag_discriminant(env, parent, variant, cond_value) + get_tag_id(env, parent, &variant, cond_value) } Layout::Builtin(_) => cond_value.into_int_value(), other => todo!("Build switch value from layout: {:?}", other), diff --git a/compiler/gen_llvm/src/llvm/build_hash.rs b/compiler/gen_llvm/src/llvm/build_hash.rs index 4b8fb0955b..a42aaf2f7d 100644 --- a/compiler/gen_llvm/src/llvm/build_hash.rs +++ b/compiler/gen_llvm/src/llvm/build_hash.rs @@ -406,7 +406,7 @@ fn hash_tag<'a, 'ctx, 'env>( env.builder.position_at_end(entry_block); match union_layout { NonRecursive(tags) => { - let tag_id = get_tag_id(env, parent, union_layout, tag).into_int_value(); + let tag_id = get_tag_id(env, parent, union_layout, tag); let mut cases = Vec::with_capacity_in(tags.len(), env.arena); @@ -448,7 +448,7 @@ fn hash_tag<'a, 'ctx, 'env>( env.builder.build_switch(tag_id, default, &cases); } Recursive(tags) => { - let tag_id = get_tag_id(env, parent, union_layout, tag).into_int_value(); + let tag_id = get_tag_id(env, parent, union_layout, tag); let mut cases = Vec::with_capacity_in(tags.len(), env.arena); @@ -551,7 +551,7 @@ fn hash_tag<'a, 'ctx, 'env>( env.builder.position_at_end(hash_other_block); - let tag_id = get_tag_id(env, parent, union_layout, tag.into()).into_int_value(); + let tag_id = get_tag_id(env, parent, union_layout, tag.into()); let default = cases.pop().unwrap().1; diff --git a/compiler/gen_llvm/src/llvm/compare.rs b/compiler/gen_llvm/src/llvm/compare.rs index d695dfbbca..4116ce67ef 100644 --- a/compiler/gen_llvm/src/llvm/compare.rs +++ b/compiler/gen_llvm/src/llvm/compare.rs @@ -846,8 +846,8 @@ fn build_tag_eq_help<'a, 'ctx, 'env>( match union_layout { NonRecursive(tags) => { - let id1 = get_tag_id(env, parent, union_layout, tag1).into_int_value(); - let id2 = get_tag_id(env, parent, union_layout, tag2).into_int_value(); + let id1 = get_tag_id(env, parent, union_layout, tag1); + let id2 = get_tag_id(env, parent, union_layout, tag2); let compare_tag_fields = ctx.append_basic_block(parent, "compare_tag_fields"); @@ -925,8 +925,8 @@ fn build_tag_eq_help<'a, 'ctx, 'env>( env.builder.position_at_end(compare_tag_ids); - let id1 = get_tag_id(env, parent, union_layout, tag1).into_int_value(); - let id2 = get_tag_id(env, parent, union_layout, tag2).into_int_value(); + let id1 = get_tag_id(env, parent, union_layout, tag1); + let id2 = get_tag_id(env, parent, union_layout, tag2); let compare_tag_fields = ctx.append_basic_block(parent, "compare_tag_fields"); @@ -1076,8 +1076,8 @@ fn build_tag_eq_help<'a, 'ctx, 'env>( env.builder.position_at_end(compare_other); - let id1 = get_tag_id(env, parent, union_layout, tag1).into_int_value(); - let id2 = get_tag_id(env, parent, union_layout, tag2).into_int_value(); + let id1 = get_tag_id(env, parent, union_layout, tag1); + let id2 = get_tag_id(env, parent, union_layout, tag2); let compare_tag_fields = ctx.append_basic_block(parent, "compare_tag_fields"); diff --git a/compiler/gen_llvm/src/llvm/refcounting.rs b/compiler/gen_llvm/src/llvm/refcounting.rs index 93d8081419..856dd0e8c1 100644 --- a/compiler/gen_llvm/src/llvm/refcounting.rs +++ b/compiler/gen_llvm/src/llvm/refcounting.rs @@ -1520,8 +1520,7 @@ fn build_rec_union_recursive_decrement<'a, 'ctx, 'env>( env.builder.build_unconditional_branch(only_branch); } else { // read the tag_id - let current_tag_id = - get_tag_id(env, parent, &union_layout, value_ptr.into()).into_int_value(); + let current_tag_id = get_tag_id(env, parent, &union_layout, value_ptr.into()); let merge_block = env.context.append_basic_block(parent, "decrement_merge"); From 38ef2a915a6aaa6b963de9fa678f56406fe4377d Mon Sep 17 00:00:00 2001 From: Chadtech Date: Sun, 27 Jun 2021 20:24:05 -0400 Subject: [PATCH 395/496] Only render exposed values --- compiler/can/src/module.rs | 20 ++++-- compiler/load/src/effect_module.rs | 4 +- compiler/load/src/file.rs | 29 +++++---- compiler/solve/src/module.rs | 1 + docs/src/lib.rs | 100 +++++++++++++---------------- 5 files changed, 80 insertions(+), 74 deletions(-) diff --git a/compiler/can/src/module.rs b/compiler/can/src/module.rs index 345bb0853e..2b45a14f32 100644 --- a/compiler/can/src/module.rs +++ b/compiler/can/src/module.rs @@ -20,7 +20,7 @@ use roc_types::types::Alias; pub struct Module { pub module_id: ModuleId, pub exposed_imports: MutMap, - pub exposed_symbols: MutSet, + pub exposed_symbols: Vec, pub references: MutSet, pub aliases: MutMap, pub rigid_variables: MutMap, @@ -50,7 +50,7 @@ pub fn canonicalize_module_defs<'a, F>( dep_idents: MutMap, aliases: MutMap, exposed_imports: MutMap, - exposed_symbols: &MutSet, + exposed_symbols: &Vec, var_store: &mut VarStore, look_up_builtin: F, ) -> Result @@ -203,7 +203,11 @@ where // we can see if there were any // exposed symbols which did not have // corresponding defs. - exposed_but_not_defined.remove(symbol); + if let Some(index) = + exposed_but_not_defined.iter().position(|s| *s == *symbol) + { + exposed_but_not_defined.remove(index); + } } } } @@ -216,7 +220,11 @@ where // we can see if there were any // exposed symbols which did not have // corresponding defs. - exposed_but_not_defined.remove(symbol); + if let Some(index) = + exposed_but_not_defined.iter().position(|s| *s == *symbol) + { + exposed_but_not_defined.remove(index); + } } } } @@ -244,7 +252,9 @@ where // we can see if there were any // exposed symbols which did not have // corresponding defs. - exposed_but_not_defined.remove(&symbol); + if let Some(index) = exposed_but_not_defined.iter().position(|s| *s == symbol) { + exposed_but_not_defined.remove(index); + } aliases.insert(symbol, alias); } diff --git a/compiler/load/src/effect_module.rs b/compiler/load/src/effect_module.rs index 5dab90a4f8..81be7ecf60 100644 --- a/compiler/load/src/effect_module.rs +++ b/compiler/load/src/effect_module.rs @@ -48,7 +48,7 @@ pub fn build_effect_builtins( scope: &mut Scope, effect_symbol: Symbol, var_store: &mut VarStore, - exposed_symbols: &mut MutSet, + exposed_symbols: &mut Vec, declarations: &mut Vec, ) { for (_, f) in BUILTIN_EFFECT_FUNCTIONS.iter() { @@ -60,7 +60,7 @@ pub fn build_effect_builtins( var_store, ); - exposed_symbols.insert(symbol); + exposed_symbols.push(symbol); declarations.push(Declaration::Declare(def)); } } diff --git a/compiler/load/src/file.rs b/compiler/load/src/file.rs index e306b7cbd7..8e9533102f 100644 --- a/compiler/load/src/file.rs +++ b/compiler/load/src/file.rs @@ -487,7 +487,9 @@ fn start_phase<'a>( let exposed_symbols = state .exposed_symbols_by_module .remove(&module_id) - .expect("Could not find listener ID in exposed_symbols_by_module"); + .expect("Could not find listener ID in exposed_symbols_by_module") + .into_iter() + .collect::>(); let mut aliases = MutMap::default(); @@ -621,7 +623,7 @@ pub struct LoadedModule { pub type_problems: MutMap>, pub declarations_by_id: MutMap>, pub exposed_to_host: MutMap, - pub exposed_aliases: MutMap, + pub exposed_values: Vec, pub header_sources: MutMap)>, pub sources: MutMap)>, pub timings: MutMap, @@ -764,7 +766,7 @@ enum Msg<'a> { FinishedAllTypeChecking { solved_subs: Solved, exposed_vars_by_symbol: MutMap, - exposed_aliases_by_symbol: MutMap, + exposed_values: Vec, documentation: MutMap, }, FoundSpecializations { @@ -972,7 +974,7 @@ enum BuildTask<'a> { parsed: ParsedModule<'a>, module_ids: ModuleIds, dep_idents: MutMap, - exposed_symbols: MutSet, + exposed_symbols: Vec, aliases: MutMap, }, Solve { @@ -1512,7 +1514,7 @@ where Msg::FinishedAllTypeChecking { solved_subs, exposed_vars_by_symbol, - exposed_aliases_by_symbol, + exposed_values, documentation, } => { // We're done! There should be no more messages pending. @@ -1528,7 +1530,7 @@ where return Ok(LoadResult::TypeChecked(finish( state, solved_subs, - exposed_aliases_by_symbol, + exposed_values, exposed_vars_by_symbol, documentation, ))); @@ -1943,7 +1945,7 @@ fn update<'a>( .send(Msg::FinishedAllTypeChecking { solved_subs, exposed_vars_by_symbol: solved_module.exposed_vars_by_symbol, - exposed_aliases_by_symbol: solved_module.aliases, + exposed_values: solved_module.exposed_symbols, documentation, }) .map_err(|_| LoadingProblem::MsgChannelDied)?; @@ -2268,7 +2270,7 @@ fn finish_specialization( fn finish( state: State, solved: Solved, - exposed_aliases_by_symbol: MutMap, + exposed_values: Vec, exposed_vars_by_symbol: MutMap, documentation: MutMap, ) -> LoadedModule { @@ -2303,8 +2305,8 @@ fn finish( can_problems: state.module_cache.can_problems, type_problems: state.module_cache.type_problems, declarations_by_id: state.declarations_by_id, + exposed_values, exposed_to_host: exposed_vars_by_symbol.into_iter().collect(), - exposed_aliases: exposed_aliases_by_symbol, header_sources, sources, timings: state.timings, @@ -3297,6 +3299,7 @@ fn run_solve<'a>( let solved_module = SolvedModule { exposed_vars_by_symbol, + exposed_symbols: exposed_symbols.into_iter().collect::>(), solved_types, problems, aliases: solved_env.aliases, @@ -3500,8 +3503,8 @@ fn fabricate_effects_module<'a>( let mut declarations = Vec::new(); - let exposed_symbols: MutSet = { - let mut exposed_symbols = MutSet::default(); + let exposed_symbols: Vec = { + let mut exposed_symbols = Vec::new(); { for (ident, ann) in effect_entries { @@ -3534,7 +3537,7 @@ fn fabricate_effects_module<'a>( annotation, ); - exposed_symbols.insert(symbol); + exposed_symbols.push(symbol); declarations.push(Declaration::Declare(def)); } @@ -3648,7 +3651,7 @@ fn canonicalize_and_constrain<'a, F>( arena: &'a Bump, module_ids: &ModuleIds, dep_idents: MutMap, - exposed_symbols: MutSet, + exposed_symbols: Vec, aliases: MutMap, parsed: ParsedModule<'a>, look_up_builtins: F, diff --git a/compiler/solve/src/module.rs b/compiler/solve/src/module.rs index f888e2208e..f921b20709 100644 --- a/compiler/solve/src/module.rs +++ b/compiler/solve/src/module.rs @@ -11,6 +11,7 @@ use roc_types::types::Alias; pub struct SolvedModule { pub solved_types: MutMap, pub aliases: MutMap, + pub exposed_symbols: Vec, pub exposed_vars_by_symbol: MutMap, pub problems: Vec, } diff --git a/docs/src/lib.rs b/docs/src/lib.rs index 05cb4aba02..7973bd23dd 100644 --- a/docs/src/lib.rs +++ b/docs/src/lib.rs @@ -63,23 +63,12 @@ pub fn generate(filenames: Vec, std_lib: StdLib, build_dir: &Path) { // Write each package's module docs html file for loaded_module in package.modules.iter_mut() { - let mut exposed_values = loaded_module - .exposed_to_host + let exports = loaded_module + .exposed_values .iter() - .map(|(symbol, _)| symbol.ident_string(&loaded_module.interns).to_string()) + .map(|symbol| symbol.ident_string(&loaded_module.interns).to_string()) .collect::>(); - let mut exposed_aliases = loaded_module - .exposed_aliases - .iter() - .map(|(symbol, _)| symbol.ident_string(&loaded_module.interns).to_string()) - .collect::>(); - - let mut exports = Vec::new(); - - exports.append(&mut exposed_values); - exports.append(&mut exposed_aliases); - for module in loaded_module.documentation.values_mut() { let module_dir = build_dir.join(module.name.replace(".", "/").as_str()); @@ -122,61 +111,64 @@ fn render_main_content( ); for entry in &module.entries { + let mut should_render_entry = true; + if let DocDef(def) = entry { - if !exposed_values.contains(&def.name) { - break; - } + // We dont want to render entries that arent exposed + should_render_entry = exposed_values.contains(&def.name); } - match entry { - DocEntry::DocDef(doc_def) => { - let mut href = String::new(); - href.push('#'); - href.push_str(doc_def.name.as_str()); + if should_render_entry { + match entry { + DocEntry::DocDef(doc_def) => { + let mut href = String::new(); + href.push('#'); + href.push_str(doc_def.name.as_str()); - let name = doc_def.name.as_str(); + let name = doc_def.name.as_str(); - let mut content = String::new(); + let mut content = String::new(); - content.push_str(html_node("a", vec![("href", href.as_str())], name).as_str()); + content.push_str(html_node("a", vec![("href", href.as_str())], name).as_str()); - for type_var in &doc_def.type_vars { - content.push(' '); - content.push_str(type_var.as_str()); - } + for type_var in &doc_def.type_vars { + content.push(' '); + content.push_str(type_var.as_str()); + } - let type_ann = &doc_def.type_annotation; + let type_ann = &doc_def.type_annotation; - match type_ann { - TypeAnnotation::NoTypeAnn => {} - _ => { - content.push_str(" : "); + match type_ann { + TypeAnnotation::NoTypeAnn => {} + _ => { + content.push_str(" : "); + } + } + + type_annotation_to_html(0, &mut content, &type_ann); + + buf.push_str( + html_node( + "h3", + vec![("id", name), ("class", "entry-name")], + content.as_str(), + ) + .as_str(), + ); + + if let Some(docs) = &doc_def.docs { + buf.push_str( + markdown_to_html(&mut module.scope, interns, docs.to_string()).as_str(), + ); } } - - type_annotation_to_html(0, &mut content, &type_ann); - - buf.push_str( - html_node( - "h3", - vec![("id", name), ("class", "entry-name")], - content.as_str(), - ) - .as_str(), - ); - - if let Some(docs) = &doc_def.docs { + DocEntry::DetachedDoc(docs) => { buf.push_str( markdown_to_html(&mut module.scope, interns, docs.to_string()).as_str(), ); } - } - DocEntry::DetachedDoc(docs) => { - buf.push_str( - markdown_to_html(&mut module.scope, interns, docs.to_string()).as_str(), - ); - } - }; + }; + } } buf From 11a1111e3331b11123850a4547a467f16ecf67c5 Mon Sep 17 00:00:00 2001 From: rvcas Date: Mon, 28 Jun 2021 00:12:37 -0400 Subject: [PATCH 396/496] feat(ValueDef): add expr and some hacks to get this to compile --- editor/src/lang/ast.rs | 10 ++++++---- editor/src/lang/def.rs | 5 ++++- editor/src/lang/module.rs | 38 +++++++++++++++++++------------------- 3 files changed, 29 insertions(+), 24 deletions(-) diff --git a/editor/src/lang/ast.rs b/editor/src/lang/ast.rs index 717428038c..d8137aa2c4 100644 --- a/editor/src/lang/ast.rs +++ b/editor/src/lang/ast.rs @@ -218,17 +218,19 @@ pub enum Expr2 { #[derive(Debug)] pub struct ValueDef { - pub pattern: PatternId, // 4B - pub expr_type: Option<(TypeId, Rigids)>, // ? - pub expr_var: Variable, // 4B + pub pattern: PatternId, // 4B + pub expr: ExprId, // 4B + pub expr_type: Option, // ? + pub expr_var: Variable, // 4B } impl ShallowClone for ValueDef { fn shallow_clone(&self) -> Self { Self { pattern: self.pattern, + expr: self.expr, expr_type: match &self.expr_type { - Some((id, rigids)) => Some((*id, rigids.shallow_clone())), + Some(rigids) => Some(rigids.shallow_clone()), None => None, }, expr_var: self.expr_var, diff --git a/editor/src/lang/def.rs b/editor/src/lang/def.rs index 8d60444847..3baaadf06b 100644 --- a/editor/src/lang/def.rs +++ b/editor/src/lang/def.rs @@ -626,7 +626,9 @@ fn canonicalize_pending_def<'a>( let value_def = ValueDef { pattern: loc_can_pattern, - expr_type: Some((annotation, rigids)), + expr: env.pool.add(loc_can_expr), + // annotation + expr_type: Some(rigids), expr_var: env.var_store.fresh(), }; @@ -747,6 +749,7 @@ fn canonicalize_pending_def<'a>( _ => { let value_def = ValueDef { pattern: loc_can_pattern, + expr: env.pool.add(loc_can_expr), expr_type: None, expr_var: env.var_store.fresh(), }; diff --git a/editor/src/lang/module.rs b/editor/src/lang/module.rs index a8b33481df..7cd3e039aa 100644 --- a/editor/src/lang/module.rs +++ b/editor/src/lang/module.rs @@ -175,7 +175,7 @@ pub fn canonicalize_module_defs<'a>( // this is now done later, in file.rs. match sort_can_defs(&mut env, defs, Output::default()) { - (Ok(mut declarations), output) => { + (Ok(declarations), output) => { use Declaration::*; for decl in declarations.iter() { @@ -238,29 +238,29 @@ pub fn canonicalize_module_defs<'a>( // exposed_symbols and added to exposed_vars_by_symbol. If any were // not, that means they were declared as exposed but there was // no actual declaration with that name! - for symbol in exposed_symbols { - env.problem(Problem::ExposedButNotDefined(symbol)); + // for symbol in exposed_symbols { + // env.problem(Problem::ExposedButNotDefined(symbol)); - // In case this exposed value is referenced by other modules, - // create a decl for it whose implementation is a runtime error. - let mut pattern_vars = SendMap::default(); - pattern_vars.insert(symbol, env.var_store.fresh()); + // // In case this exposed value is referenced by other modules, + // // create a decl for it whose implementation is a runtime error. + // let mut pattern_vars = SendMap::default(); + // pattern_vars.insert(symbol, env.var_store.fresh()); - let runtime_error = RuntimeError::ExposedButNotDefined(symbol); + // let runtime_error = RuntimeError::ExposedButNotDefined(symbol); - let value_def = { - let pattern = env.pool.add(Pattern2::Identifier(symbol)); - ValueDef { - pattern, - expr_type: None, - expr_var: env.var_store.fresh(), - } - }; + // let value_def = { + // let pattern = env.pool.add(Pattern2::Identifier(symbol)); + // ValueDef { + // pattern, + // expr_type: None, + // expr_var: env.var_store.fresh(), + // } + // }; - let def = Def::Value(value_def); + // let def = Def::Value(value_def); - declarations.push(Declaration::Declare(def)); - } + // declarations.push(Declaration::Declare(def)); + // } // Incorporate any remaining output.lookups entries into references. for symbol in output.references.lookups { From 8ae8f50a0ad89d4b15451d7f4556d408f710dbda Mon Sep 17 00:00:00 2001 From: rvcas Date: Mon, 28 Jun 2021 00:13:19 -0400 Subject: [PATCH 397/496] fix: LetValue constraint gen --- editor/src/lang/constrain.rs | 78 +++++++++++++++++++----------------- 1 file changed, 42 insertions(+), 36 deletions(-) diff --git a/editor/src/lang/constrain.rs b/editor/src/lang/constrain.rs index cdad0e3d3f..968eaabb8c 100644 --- a/editor/src/lang/constrain.rs +++ b/editor/src/lang/constrain.rs @@ -765,52 +765,58 @@ pub fn constrain_expr<'a>( let value_def = env.pool.get(*def_id); let body = env.pool.get(*body_id); - let mut body_con = constrain_expr(arena, env, body, expected.shallow_clone(), region); + let body_con = constrain_expr(arena, env, body, expected.shallow_clone(), region); + let pattern = env.pool.get(value_def.pattern); - if let Some((expr_type_id, _)) = value_def.expr_type { - let mut flex_vars = BumpVec::with_capacity_in(1, arena); - flex_vars.push(*body_var); + let mut flex_vars = BumpVec::with_capacity_in(1, arena); + flex_vars.push(*body_var); - // Constrain Def - let mut and_constraints = BumpVec::with_capacity_in(1, arena); + let expr_type = Type2::Variable(value_def.expr_var); - let pattern = env.pool.get(value_def.pattern); + let pattern_expected = PExpected::NoExpectation(expr_type.shallow_clone()); + let mut state = PatternState2 { + headers: BumpMap::new_in(arena), + vars: BumpVec::with_capacity_in(1, arena), + constraints: BumpVec::with_capacity_in(1, arena), + }; - let expr_type = env.pool.get(expr_type_id); + constrain_pattern(arena, env, pattern, region, pattern_expected, &mut state); + state.vars.push(value_def.expr_var); - let pattern_expected = PExpected::NoExpectation(expr_type.shallow_clone()); + let def_expr = env.pool.get(value_def.expr); - let mut state = PatternState2 { - headers: BumpMap::new_in(arena), - vars: BumpVec::with_capacity_in(1, arena), - constraints: BumpVec::with_capacity_in(1, arena), - }; - - constrain_pattern(arena, env, pattern, region, pattern_expected, &mut state); - - state.vars.push(value_def.expr_var); - - let constrained_def = Let(arena.alloc(LetConstraint { - rigid_vars: BumpVec::new_in(arena), - flex_vars: state.vars, - def_types: state.headers, + let constrained_def = Let(arena.alloc(LetConstraint { + rigid_vars: BumpVec::new_in(arena), + flex_vars: state.vars, + def_types: state.headers, + defs_constraint: Let(arena.alloc(LetConstraint { + rigid_vars: BumpVec::new_in(arena), // always empty + flex_vars: BumpVec::new_in(arena), // empty, because our functions have no arguments + def_types: BumpMap::new_in(arena), // empty, because our functions have no arguments! defs_constraint: And(state.constraints), - ret_constraint: body_con, - })); + ret_constraint: constrain_expr( + arena, + env, + def_expr, + Expected::NoExpectation(expr_type), + region, + ), + })), + ret_constraint: body_con, + })); - and_constraints.push(constrained_def); - and_constraints.push(Eq( - Type2::Variable(*body_var), - expected, - Category::Storage(std::file!(), std::line!()), - // TODO: needs to be ret region - region, - )); + let mut and_constraints = BumpVec::with_capacity_in(1, arena); - body_con = exists(arena, flex_vars, And(and_constraints)); - } + and_constraints.push(constrained_def); + and_constraints.push(Eq( + Type2::Variable(*body_var), + expected, + Category::Storage(std::file!(), std::line!()), + // TODO: needs to be ret region + region, + )); - body_con + exists(arena, flex_vars, And(and_constraints)) } Expr2::Update { symbol, From 0657e21fdb265fbb58f7cd5f634fb1634517aaf6 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Mon, 28 Jun 2021 15:54:19 +0200 Subject: [PATCH 398/496] can make empty list in editor, panic on type tooltip --- compiler/module/src/symbol.rs | 4 ++ compiler/mono/src/alias_analysis.rs | 4 +- compiler/types/src/pretty_print.rs | 2 + editor/src/editor/markup/nodes.rs | 2 + editor/src/editor/mvc/ed_model.rs | 1 - editor/src/editor/mvc/ed_update.rs | 28 ++++++++- editor/src/editor/mvc/list_update.rs | 88 ++++++++++++++++++++++++++++ editor/src/editor/mvc/mod.rs | 1 + editor/src/lang/ast.rs | 43 ++++++++++---- editor/tests/solve_expr2.rs | 4 +- 10 files changed, 160 insertions(+), 17 deletions(-) create mode 100644 editor/src/editor/mvc/list_update.rs diff --git a/compiler/module/src/symbol.rs b/compiler/module/src/symbol.rs index d107bdffe4..b482200b32 100644 --- a/compiler/module/src/symbol.rs +++ b/compiler/module/src/symbol.rs @@ -66,6 +66,10 @@ impl Symbol { } pub fn ident_string(self, interns: &Interns) -> &InlinableString { + + dbg!(&self.module_id()); + dbg!(interns); + println!("DONE"); let ident_ids = interns .all_ident_ids .get(&self.module_id()) diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 5a59917ed8..beb8c79917 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -166,9 +166,9 @@ where p.build()? }; - if DEBUG { + /*if DEBUG { eprintln!("{}", program.to_source_string()); - } + }*/ morphic_lib::solve(program) } diff --git a/compiler/types/src/pretty_print.rs b/compiler/types/src/pretty_print.rs index 8df08669d1..98ab8c65b2 100644 --- a/compiler/types/src/pretty_print.rs +++ b/compiler/types/src/pretty_print.rs @@ -356,6 +356,8 @@ fn write_content(env: &Env, content: Content, subs: &Subs, buf: &mut String, par fn write_flat_type(env: &Env, flat_type: FlatType, subs: &Subs, buf: &mut String, parens: Parens) { use crate::subs::FlatType::*; + println!("REMOVE ME"); + match flat_type { Apply(symbol, args) => write_apply(env, symbol, args, subs, buf, parens), EmptyRecord => buf.push_str(EMPTY_RECORD), diff --git a/editor/src/editor/markup/nodes.rs b/editor/src/editor/markup/nodes.rs index 2d09f21ed6..84864225b2 100644 --- a/editor/src/editor/markup/nodes.rs +++ b/editor/src/editor/markup/nodes.rs @@ -143,6 +143,8 @@ fn get_string<'a>(env: &Env<'a>, pool_str: &PoolStr) -> String { pub const BLANK_PLACEHOLDER: &str = " "; pub const LEFT_ACCOLADE: &str = "{ "; pub const RIGHT_ACCOLADE: &str = " }"; +pub const LEFT_SQUARE_BR: &str = "[ "; +pub const RIGHT_SQUARE_BR: &str = " ]"; pub const COLON: &str = ": "; pub const STRING_QUOTES: &str = "\"\""; diff --git a/editor/src/editor/mvc/ed_model.rs b/editor/src/editor/mvc/ed_model.rs index 64b36ecf7e..64a264a7a9 100644 --- a/editor/src/editor/mvc/ed_model.rs +++ b/editor/src/editor/mvc/ed_model.rs @@ -196,7 +196,6 @@ pub mod test_ed_model { let file_path = Path::new(""); let dep_idents = IdentIds::exposed_builtins(8); - let exposed_ident_ids = IdentIds::default(); let mod_id = ed_model_refs.module_ids.get_or_insert(&"ModId123".into()); diff --git a/editor/src/editor/mvc/ed_update.rs b/editor/src/editor/mvc/ed_update.rs index 5562261a69..7199035865 100644 --- a/editor/src/editor/mvc/ed_update.rs +++ b/editor/src/editor/mvc/ed_update.rs @@ -21,6 +21,7 @@ use crate::editor::mvc::record_update::update_record_field; use crate::editor::mvc::string_update::start_new_string; use crate::editor::mvc::string_update::update_small_string; use crate::editor::mvc::string_update::update_string; +use crate::editor::mvc::list_update::start_new_list; use crate::editor::slow_pool::MarkNodeId; use crate::editor::slow_pool::SlowPool; use crate::editor::syntax_highlight::HighlightStyle; @@ -44,7 +45,7 @@ use bumpalo::Bump; use roc_can::expected::Expected; use roc_collections::all::MutMap; use roc_module::ident::Lowercase; -use roc_module::symbol::Symbol; +use roc_module::symbol::{Interns, Symbol}; use roc_region::all::Region; use roc_types::solved_types::Solved; use roc_types::subs::{Subs, Variable}; @@ -264,8 +265,13 @@ impl<'a> EdModel<'a> { let content = subs.get(var).content; + let interns = Interns { + module_ids: *self.module.env.module_ids, + all_ident_ids: self.module.env.dep_idents, + }; + PoolStr::new( - &content_to_string(content, &subs, self.module.env.home, &Default::default()), + &content_to_string(content, &subs, self.module.env.home, &interns), self.module.env.pool, ) } @@ -581,6 +587,10 @@ pub fn handle_new_char(received_char: &char, ed_model: &mut EdModel) -> EdResult '0'..='9' => { start_new_int(ed_model, ch)? } + '[' => { + // this can also be a tag union or become a set, assuming list for now + start_new_list(ed_model)? + } _ => InputOutcome::Ignored } } else if let Some(prev_mark_node_id) = prev_mark_node_id_opt{ @@ -1724,6 +1734,20 @@ pub mod test_ed_update { Ok(()) } + #[test] + fn test_ctrl_shift_up_list() -> Result<(), String> { + assert_ctrl_shift_up(&["[ ┃ ]"], &["┃❮[ ]❯"])?; + assert_ctrl_shift_up(&["[┃ ]"], &["┃❮[ ]❯"])?; + assert_ctrl_shift_up(&["[ ┃]"], &["┃❮[ ]❯"])?; + assert_ctrl_shift_up(&["┃[ ]"], &["┃❮[ ]❯"])?; + assert_ctrl_shift_up(&["[ ]┃"], &["┃❮[ ]❯"])?; + + assert_ctrl_shift_up_repeat(&["[ ┃ ]"], &["┃❮[ ]❯"], 4)?; + + //TODO non-empty list + Ok(()) + } + // Create ed_model from pre_lines DSL, do handle_new_char() with new_char_seq, select current Expr2, // check if generated tooltips match expected_tooltips. pub fn assert_type_tooltips_seq( diff --git a/editor/src/editor/mvc/list_update.rs b/editor/src/editor/mvc/list_update.rs new file mode 100644 index 0000000000..e674fe59ed --- /dev/null +++ b/editor/src/editor/mvc/list_update.rs @@ -0,0 +1,88 @@ + +use crate::editor::ed_error::EdResult; +use crate::editor::markup::attribute::Attributes; +use crate::editor::markup::nodes; +use crate::editor::markup::nodes::MarkupNode; +use crate::editor::mvc::app_update::InputOutcome; +use crate::editor::mvc::ed_model::EdModel; +use crate::editor::mvc::ed_update::get_node_context; +use crate::editor::mvc::ed_update::NodeContext; +use crate::editor::syntax_highlight::HighlightStyle; +use crate::lang::ast::Expr2; +use crate::lang::pool::{PoolVec}; + +pub fn start_new_list(ed_model: &mut EdModel) -> EdResult { + let NodeContext { + old_caret_pos, + curr_mark_node_id, + curr_mark_node, + parent_id_opt, + ast_node_id, + } = get_node_context(&ed_model)?; + + let is_blank_node = curr_mark_node.is_blank(); + + let expr2_node = + Expr2::List{ + elem_var: ed_model.module.env.var_store.fresh(), + elems: PoolVec::empty(ed_model.module.env.pool) + }; + + let mark_node_pool = &mut ed_model.markup_node_pool; + + ed_model.module.env.pool.set(ast_node_id, expr2_node); + + let left_bracket_node = MarkupNode::Text { + content: nodes::LEFT_SQUARE_BR.to_owned(), + ast_node_id, + syn_high_style: HighlightStyle::Bracket, + attributes: Attributes::new(), + parent_id_opt: Some(curr_mark_node_id), // current node will be replaced with nested one + }; + + let left_bracket_node_id = mark_node_pool.add(left_bracket_node); + + let right_bracket_node = MarkupNode::Text { + content: nodes::RIGHT_SQUARE_BR.to_owned(), + ast_node_id, + syn_high_style: HighlightStyle::Bracket, + attributes: Attributes::new(), + parent_id_opt: Some(curr_mark_node_id), // current node will be replaced with nested one + }; + + let right_bracket_node_id = mark_node_pool.add(right_bracket_node); + + let nested_node = MarkupNode::Nested { + ast_node_id, + children_ids: vec![left_bracket_node_id, right_bracket_node_id], + parent_id_opt, + }; + + if is_blank_node { + mark_node_pool.replace_node(curr_mark_node_id, nested_node); + + // remove data corresponding to Blank node + ed_model.del_at_line(old_caret_pos.line, old_caret_pos.column)?; + + ed_model.simple_move_carets_right(nodes::LEFT_SQUARE_BR.len()); + + // update GridNodeMap and CodeLines + ed_model.insert_between_line( + old_caret_pos.line, + old_caret_pos.column, + nodes::LEFT_SQUARE_BR, + left_bracket_node_id, + )?; + + ed_model.insert_between_line( + old_caret_pos.line, + old_caret_pos.column + nodes::LEFT_SQUARE_BR.len(), + nodes::RIGHT_SQUARE_BR, + right_bracket_node_id, + )?; + + Ok(InputOutcome::Accepted) + } else { + Ok(InputOutcome::Ignored) + } +} \ No newline at end of file diff --git a/editor/src/editor/mvc/mod.rs b/editor/src/editor/mvc/mod.rs index b393cfd0a2..64ee02304f 100644 --- a/editor/src/editor/mvc/mod.rs +++ b/editor/src/editor/mvc/mod.rs @@ -6,4 +6,5 @@ pub mod ed_view; mod int_update; mod lookup_update; mod record_update; +mod list_update; mod string_update; diff --git a/editor/src/lang/ast.rs b/editor/src/lang/ast.rs index b1b75b0554..d61669e39a 100644 --- a/editor/src/lang/ast.rs +++ b/editor/src/lang/ast.rs @@ -347,8 +347,9 @@ impl RecordField { pub fn expr2_to_string(node_id: NodeId, pool: &Pool) -> String { let mut full_string = String::new(); + let expr2 = pool.get(node_id); - expr2_to_string_helper(node_id, 0, pool, &mut full_string); + expr2_to_string_helper(expr2, 0, pool, &mut full_string); full_string } @@ -361,13 +362,11 @@ fn get_spacing(indent_level: usize) -> String { } fn expr2_to_string_helper( - node_id: NodeId, + expr2: &Expr2, indent_level: usize, pool: &Pool, out_string: &mut String, ) { - let expr2 = pool.get(node_id); - out_string.push_str(&get_spacing(indent_level)); match expr2 { @@ -384,11 +383,7 @@ fn expr2_to_string_helper( Expr2::EmptyRecord => out_string.push_str("EmptyRecord"), Expr2::Record { record_var, fields } => { out_string.push_str("Record:\n"); - out_string.push_str(&format!( - "{}Var({:?})\n", - get_spacing(indent_level + 1), - record_var - )); + out_string.push_str(&var_to_string(&record_var, indent_level + 1)); out_string.push_str(&format!("{}fields: [\n", get_spacing(indent_level + 1))); @@ -427,7 +422,8 @@ fn expr2_to_string_helper( var, )); - expr2_to_string_helper(*val_node_id, indent_level + 3, pool, out_string); + let val_expr2 = pool.get(*val_node_id); + expr2_to_string_helper(val_expr2, indent_level + 3, pool, out_string); out_string.push_str(&format!("{})\n", get_spacing(indent_level + 2))); } } @@ -435,6 +431,25 @@ fn expr2_to_string_helper( out_string.push_str(&format!("{}]\n", get_spacing(indent_level + 1))); } + Expr2::List { elem_var, elems} => { + out_string.push_str("List:\n"); + out_string.push_str(&var_to_string(elem_var, indent_level + 1)); + out_string.push_str(&format!("{}elems: [\n", get_spacing(indent_level + 1))); + + let mut first_elt = true; + + for elem_expr2 in elems.iter(pool) { + if !first_elt { + out_string.push_str(", ") + } else { + first_elt = false; + } + + expr2_to_string_helper(elem_expr2, indent_level + 1, pool, out_string) + } + + out_string.push_str(&format!("{}]\n", get_spacing(indent_level + 1))); + } Expr2::InvalidLookup(pool_str) => { out_string.push_str(&format!("InvalidLookup({})", pool_str.as_str(pool))); } @@ -447,6 +462,14 @@ fn expr2_to_string_helper( out_string.push('\n'); } +fn var_to_string( some_var: &Variable, indent_level: usize) -> String { + format!( + "{}Var({:?})\n", + get_spacing(indent_level + 1), + some_var + ) +} + #[test] fn size_of_expr() { assert_eq!(std::mem::size_of::(), crate::lang::pool::NODE_BYTES); diff --git a/editor/tests/solve_expr2.rs b/editor/tests/solve_expr2.rs index 374afd6590..91a2964fc9 100644 --- a/editor/tests/solve_expr2.rs +++ b/editor/tests/solve_expr2.rs @@ -62,7 +62,6 @@ fn infer_eq(actual: &str, expected_str: &str) { let mut var_store = VarStore::default(); let var = var_store.fresh(); let dep_idents = IdentIds::exposed_builtins(8); - let exposed_ident_ids = IdentIds::default(); let mut module_ids = ModuleIds::default(); let mod_id = module_ids.get_or_insert(&"ModId123".into()); @@ -121,6 +120,7 @@ fn infer_eq(actual: &str, expected_str: &str) { module_ids, all_ident_ids: dep_idents, }; + let actual_str = content_to_string(content, &subs, mod_id, &interns); assert_eq!(actual_str, expected_str); @@ -208,7 +208,7 @@ fn constrain_empty_list() { infer_eq( indoc!( r#" - [] + [ ] "# ), "List *", From a00a8c8e97aed389256ab940047e136c8594059a Mon Sep 17 00:00:00 2001 From: rvcas Date: Mon, 28 Jun 2021 11:52:51 -0400 Subject: [PATCH 399/496] fix: imports --- editor/src/lang/expr.rs | 27 ++++++++++++--------------- 1 file changed, 12 insertions(+), 15 deletions(-) diff --git a/editor/src/lang/expr.rs b/editor/src/lang/expr.rs index a383b6b00d..b98e98f453 100644 --- a/editor/src/lang/expr.rs +++ b/editor/src/lang/expr.rs @@ -1,21 +1,22 @@ #![allow(clippy::all)] #![allow(dead_code)] #![allow(unused_imports)] +use bumpalo::{collections::Vec as BumpVec, Bump}; +use inlinable_string::InlinableString; use std::collections::HashMap; -use crate::lang::ast::expr2_to_string; -use crate::lang::ast::RecordField; -use crate::lang::ast::{ClosureExtra, Expr2, ExprId, FloatVal, IntStyle, IntVal, WhenBranch}; -use crate::lang::def::canonicalize_defs; -use crate::lang::def::sort_can_defs; -use crate::lang::def::Def; -use crate::lang::def::{CanDefs, PendingDef, References}; -use crate::lang::pattern::{to_pattern2, Pattern2}; +use crate::lang::ast::{ + expr2_to_string, ClosureExtra, Expr2, ExprId, FloatVal, IntStyle, IntVal, RecordField, + WhenBranch, +}; +use crate::lang::def::{ + canonicalize_defs, sort_can_defs, CanDefs, Declaration, Def, PendingDef, References, +}; +use crate::lang::pattern::{to_pattern2, Pattern2, PatternId}; use crate::lang::pool::{NodeId, Pool, PoolStr, PoolVec, ShallowClone}; use crate::lang::scope::Scope; -use crate::lang::types::{Alias, Type2, TypeId}; -use bumpalo::Bump; -use inlinable_string::InlinableString; +use crate::lang::types::{Alias, Annotation2, Type2, TypeId}; + use roc_can::expr::Recursive; use roc_can::num::{finish_parsing_base, finish_parsing_float, finish_parsing_int}; use roc_can::operator::desugar_expr; @@ -34,10 +35,6 @@ use roc_problem::can::{Problem, RuntimeError}; use roc_region::all::{Located, Region}; use roc_types::subs::{VarStore, Variable}; -use super::def::Declaration; -use super::pattern::PatternId; -use super::types::Annotation2; - #[derive(Clone, Debug, PartialEq, Default)] pub struct IntroducedVariables { // NOTE on rigids From 6b882b85de59096e7a92c98a7e28f0e0c4548b25 Mon Sep 17 00:00:00 2001 From: rvcas Date: Mon, 28 Jun 2021 11:53:47 -0400 Subject: [PATCH 400/496] feat(Expr2): implement Env::problem --- editor/src/lang/expr.rs | 22 +++++++++++----------- editor/tests/solve_expr2.rs | 2 +- 2 files changed, 12 insertions(+), 12 deletions(-) diff --git a/editor/src/lang/expr.rs b/editor/src/lang/expr.rs index b98e98f453..ca216f35d2 100644 --- a/editor/src/lang/expr.rs +++ b/editor/src/lang/expr.rs @@ -113,6 +113,8 @@ pub struct Env<'a> { pub pool: &'a mut Pool, pub arena: &'a Bump, + pub problems: BumpVec<'a, Problem>, + pub dep_idents: MutMap, pub module_ids: &'a ModuleIds, pub ident_ids: IdentIds, @@ -142,6 +144,7 @@ impl<'a> Env<'a> { home, arena, pool, + problems: BumpVec::new_in(arena), var_store, dep_idents, module_ids, @@ -162,8 +165,8 @@ impl<'a> Env<'a> { id } - pub fn problem(&mut self, _problem: Problem) { - todo!(); + pub fn problem(&mut self, problem: Problem) { + self.problems.push(problem); } pub fn set_region(&mut self, _node_id: NodeId, _region: Region) { @@ -1374,11 +1377,10 @@ fn canonicalize_lookup( Var(symbol) } - Err(_problem) => { - // env.problem(Problem::RuntimeError(problem.clone())); + Err(problem) => { + env.problem(Problem::RuntimeError(problem.clone())); - // RuntimeError(problem) - todo!() + RuntimeError() } } } else { @@ -1390,14 +1392,12 @@ fn canonicalize_lookup( Var(symbol) } - Err(_problem) => { + Err(problem) => { // Either the module wasn't imported, or // it was imported but it doesn't expose this ident. - // env.problem(Problem::RuntimeError(problem.clone())); + env.problem(Problem::RuntimeError(problem.clone())); - // RuntimeError(problem) - - todo!() + RuntimeError() } } }; diff --git a/editor/tests/solve_expr2.rs b/editor/tests/solve_expr2.rs index f2bcf0bdd9..4f3bf8b254 100644 --- a/editor/tests/solve_expr2.rs +++ b/editor/tests/solve_expr2.rs @@ -118,7 +118,7 @@ fn infer_eq(actual: &str, expected_str: &str) { let content = subs.get(var).content; let interns = Interns { - module_ids, + module_ids: env.module_ids.clone(), all_ident_ids: dep_idents, }; let actual_str = content_to_string(content, &subs, mod_id, &interns); From d817ecb51d361ad84a079ef903f192d60669c570 Mon Sep 17 00:00:00 2001 From: rvcas Date: Mon, 28 Jun 2021 11:54:19 -0400 Subject: [PATCH 401/496] feat(markup): add explicit case for RuntimeError --- editor/src/editor/markup/nodes.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/editor/src/editor/markup/nodes.rs b/editor/src/editor/markup/nodes.rs index 2d09f21ed6..e40a38c714 100644 --- a/editor/src/editor/markup/nodes.rs +++ b/editor/src/editor/markup/nodes.rs @@ -347,6 +347,9 @@ pub fn expr2_to_markup<'a, 'b>( syn_high_style: HighlightStyle::Blank, parent_id_opt: None, }), + Expr2::RuntimeError() => { + todo!("Handle Expr2::RuntimeError") + } rest => todo!("implement expr2_to_markup for {:?}", rest), } } From f4b6bdd7582bb8d7d3fe8d9ed31688e0dde71bcb Mon Sep 17 00:00:00 2001 From: rvcas Date: Mon, 28 Jun 2021 12:00:54 -0400 Subject: [PATCH 402/496] fix: capacity 2 --- editor/src/lang/constrain.rs | 2 +- editor/src/lang/expr.rs | 6 ++---- 2 files changed, 3 insertions(+), 5 deletions(-) diff --git a/editor/src/lang/constrain.rs b/editor/src/lang/constrain.rs index 968eaabb8c..a22ab39334 100644 --- a/editor/src/lang/constrain.rs +++ b/editor/src/lang/constrain.rs @@ -805,7 +805,7 @@ pub fn constrain_expr<'a>( ret_constraint: body_con, })); - let mut and_constraints = BumpVec::with_capacity_in(1, arena); + let mut and_constraints = BumpVec::with_capacity_in(2, arena); and_constraints.push(constrained_def); and_constraints.push(Eq( diff --git a/editor/src/lang/expr.rs b/editor/src/lang/expr.rs index ca216f35d2..936da9242d 100644 --- a/editor/src/lang/expr.rs +++ b/editor/src/lang/expr.rs @@ -37,16 +37,14 @@ use roc_types::subs::{VarStore, Variable}; #[derive(Clone, Debug, PartialEq, Default)] pub struct IntroducedVariables { - // NOTE on rigids - // // Rigids must be unique within a type annoation. // E.g. in `identity : a -> a`, there should only be one // variable (a rigid one, with name "a"). - // Hence `rigids : ImMap` + // Hence `rigids : Map` // // But then between annotations, the same name can occur multiple times, // but a variable can only have one name. Therefore - // `ftv : SendMap`. + // `ftv : Map`. pub wildcards: Vec, pub var_by_name: MutMap, pub name_by_var: MutMap, From 0d07c2ef845f2882086940faee17ae83cd4e4f0b Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 28 Jun 2021 20:03:49 +0200 Subject: [PATCH 403/496] make tag id less hardcoded --- compiler/gen_llvm/src/llvm/build.rs | 63 +++++++++++++++-------- compiler/gen_llvm/src/llvm/refcounting.rs | 10 ++-- compiler/mono/src/layout.rs | 8 ++- 3 files changed, 52 insertions(+), 29 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index fa4e942bcb..97338c9937 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -1081,8 +1081,15 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( let field_layouts = tag_layouts[*tag_id as usize]; + let tag_id_type = basic_type_from_layout( + env, + &UnionLayout::tag_id_layout_from_slices(tag_layouts), + ) + .into_int_type(); + lookup_at_index_ptr2( env, + tag_id_type, field_layouts, *index as usize, argument.into_pointer_value(), @@ -1117,8 +1124,15 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( let field_layouts = other_tags[tag_index as usize]; + let tag_id_type = basic_type_from_layout( + env, + &UnionLayout::tag_id_layout_from_slices(other_tags), + ) + .into_int_type(); + lookup_at_index_ptr2( env, + tag_id_type, field_layouts, *index as usize, argument.into_pointer_value(), @@ -1170,7 +1184,7 @@ pub fn build_tag<'a, 'ctx, 'env>( arguments: &[Symbol], ) -> BasicValueEnum<'ctx> { match union_layout { - UnionLayout::NonRecursive(fields) => { + UnionLayout::NonRecursive(tags) => { debug_assert!(union_size > 1); let ctx = env.context; @@ -1181,7 +1195,7 @@ pub fn build_tag<'a, 'ctx, 'env>( let mut field_types = Vec::with_capacity_in(num_fields, env.arena); let mut field_vals = Vec::with_capacity_in(num_fields, env.arena); - let tag_field_layouts = &fields[tag_id as usize]; + let tag_field_layouts = &tags[tag_id as usize]; for (field_symbol, tag_field_layout) in arguments.iter().zip(tag_field_layouts.iter()) { let (val, _val_layout) = load_symbol_and_layout(scope, field_symbol); @@ -1237,10 +1251,12 @@ pub fn build_tag<'a, 'ctx, 'env>( // This tricks comes from // https://github.com/raviqqe/ssf/blob/bc32aae68940d5bddf5984128e85af75ca4f4686/ssf-llvm/src/expression_compiler.rs#L116 - let internal_type = block_of_memory_slices(env.context, fields, env.ptr_bytes); + let internal_type = block_of_memory_slices(env.context, tags, env.ptr_bytes); let data = cast_tag_to_block_of_memory(builder, struct_val, internal_type); - let tag_id_type = env.context.i64_type(); + let tag_id_type = + basic_type_from_layout(env, &UnionLayout::tag_id_layout_from_slices(tags)) + .into_int_type(); let wrapper_type = env .context .struct_type(&[data.get_type(), tag_id_type.into()], false); @@ -1301,7 +1317,10 @@ pub fn build_tag<'a, 'ctx, 'env>( .build_struct_gep(raw_data_ptr, TAG_ID_INDEX, "tag_id_index") .unwrap(); - let tag_id_type = env.context.i64_type(); + let tag_id_type = + basic_type_from_layout(env, &UnionLayout::tag_id_layout_from_slices(tags)) + .into_int_type(); + env.builder .build_store(tag_id_ptr, tag_id_type.const_int(tag_id as u64, false)); @@ -1463,7 +1482,10 @@ pub fn build_tag<'a, 'ctx, 'env>( .build_struct_gep(raw_data_ptr, TAG_ID_INDEX, "tag_id_index") .unwrap(); - let tag_id_type = env.context.i64_type(); + let tag_id_type = + basic_type_from_layout(env, &UnionLayout::tag_id_layout_from_slices(tags)) + .into_int_type(); + env.builder .build_store(tag_id_ptr, tag_id_type.const_int(tag_id as u64, false)); @@ -1590,11 +1612,9 @@ pub fn get_tag_id<'a, 'ctx, 'env>( UnionLayout::NonRecursive(_) => { let tag = argument.into_struct_value(); - extract_tag_discriminant_non_recursive(env, tag) - } - UnionLayout::Recursive(_) => { - extract_tag_discriminant_ptr(env, argument.into_pointer_value()) + get_tag_id_non_recursive(env, tag) } + UnionLayout::Recursive(_) => get_tag_id_wrapped(env, argument.into_pointer_value()), UnionLayout::NonNullableUnwrapped(_) => env.context.i64_type().const_zero(), UnionLayout::NullableWrapped { nullable_id, .. } => { let argument_ptr = argument.into_pointer_value(); @@ -1619,7 +1639,7 @@ pub fn get_tag_id<'a, 'ctx, 'env>( { env.builder.position_at_end(else_block); - let tag_id = extract_tag_discriminant_ptr(env, argument_ptr); + let tag_id = get_tag_id_wrapped(env, argument_ptr); env.builder.build_store(result, tag_id); env.builder.build_unconditional_branch(cont_block); } @@ -1687,6 +1707,7 @@ fn lookup_at_index_ptr<'a, 'ctx, 'env>( fn lookup_at_index_ptr2<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, + tag_id_type: IntType<'ctx>, field_layouts: &[Layout<'_>], index: usize, value: PointerValue<'ctx>, @@ -1696,7 +1717,6 @@ fn lookup_at_index_ptr2<'a, 'ctx, 'env>( let struct_layout = Layout::Struct(field_layouts); let struct_type = basic_type_from_layout(env, &struct_layout); - let tag_id_type = env.context.i64_type(); let wrapper_type = env .context .struct_type(&[struct_type, tag_id_type.into()], false); @@ -1724,12 +1744,12 @@ fn lookup_at_index_ptr2<'a, 'ctx, 'env>( // a recursive field is stored as a `i64*`, to use it we must cast it to // a pointer to the block of memory representation - let struct_type = block_of_memory_slices(env.context, &[field_layouts], env.ptr_bytes); - let tag_id_type = env.context.i64_type(); + let tags = &[field_layouts]; + let struct_type = block_of_memory_slices(env.context, tags, env.ptr_bytes); + let tag_id_type = + basic_type_from_layout(env, &UnionLayout::tag_id_layout_from_slices(tags)); - let opaque_wrapper_type = env - .context - .struct_type(&[struct_type, tag_id_type.into()], false); + let opaque_wrapper_type = env.context.struct_type(&[struct_type, tag_id_type], false); builder.build_bitcast( result, @@ -1765,10 +1785,10 @@ fn reserve_with_refcount_union_as_block_of_memory<'a, 'ctx, 'env>( .map(|l| l.stack_size(env.ptr_bytes)); let basic_type = if tag_id_stack_size.is_some() { - let tag_id_type = env.context.i64_type(); + let tag_id_type = basic_type_from_layout(env, &union_layout.tag_id_layout().unwrap()); env.context - .struct_type(&[block_type, tag_id_type.into()], false) + .struct_type(&[block_type, tag_id_type], false) .into() } else { block_type @@ -2546,7 +2566,8 @@ pub fn complex_bitcast<'ctx>( } } -fn extract_tag_discriminant_ptr<'a, 'ctx, 'env>( +/// get the tag id out of a pointer to a wrapped (i.e. stores the tag id at runtime) layout +fn get_tag_id_wrapped<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, from_value: PointerValue<'ctx>, ) -> IntValue<'ctx> { @@ -2560,7 +2581,7 @@ fn extract_tag_discriminant_ptr<'a, 'ctx, 'env>( .into_int_value() } -fn extract_tag_discriminant_non_recursive<'a, 'ctx, 'env>( +pub fn get_tag_id_non_recursive<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, tag: StructValue<'ctx>, ) -> IntValue<'ctx> { diff --git a/compiler/gen_llvm/src/llvm/refcounting.rs b/compiler/gen_llvm/src/llvm/refcounting.rs index 856dd0e8c1..4bc81ab803 100644 --- a/compiler/gen_llvm/src/llvm/refcounting.rs +++ b/compiler/gen_llvm/src/llvm/refcounting.rs @@ -1,7 +1,7 @@ use crate::debug_info_init; use crate::llvm::build::{ - add_func, cast_basic_basic, cast_block_of_memory_to_tag, get_tag_id, Env, FAST_CALL_CONV, - LLVM_SADD_WITH_OVERFLOW_I64, TAG_DATA_INDEX, TAG_ID_INDEX, + add_func, cast_basic_basic, cast_block_of_memory_to_tag, get_tag_id, get_tag_id_non_recursive, + Env, FAST_CALL_CONV, LLVM_SADD_WITH_OVERFLOW_I64, TAG_DATA_INDEX, }; use crate::llvm::build_list::{incrementing_elem_loop, list_len, load_list}; use crate::llvm::convert::{ @@ -1638,11 +1638,7 @@ fn modify_refcount_union_help<'a, 'ctx, 'env>( let wrapper_struct = arg_val.into_struct_value(); // read the tag_id - let tag_id = env - .builder - .build_extract_value(wrapper_struct, TAG_ID_INDEX, "read_tag_id") - .unwrap() - .into_int_value(); + let tag_id = get_tag_id_non_recursive(env, wrapper_struct); let tag_id_u8 = env .builder diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index ae3e01bab3..96edf287a6 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -153,11 +153,17 @@ impl<'a> UnionLayout<'a> { } } + const BIGGEST_TAG_ID_TYPE: Layout<'static> = Layout::Builtin(Builtin::Int64); + + pub fn tag_id_layout_from_slices(_slices: &[&[Layout<'a>]]) -> Layout<'a> { + Self::BIGGEST_TAG_ID_TYPE + } + pub fn tag_id_layout(&self) -> Option> { match self { UnionLayout::NonRecursive(_) | UnionLayout::Recursive(_) - | UnionLayout::NullableWrapped { .. } => Some(Layout::Builtin(Builtin::Int64)), + | UnionLayout::NullableWrapped { .. } => Some(Self::BIGGEST_TAG_ID_TYPE), UnionLayout::NonNullableUnwrapped(_) | UnionLayout::NullableUnwrapped { .. } => None, } } From 1d1bcaea63804af577a6838cd56a26a1ad2e1349 Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 28 Jun 2021 20:16:39 +0200 Subject: [PATCH 404/496] make ir use different tag id types --- compiler/gen_llvm/src/llvm/build.rs | 12 +++++------- compiler/mono/src/decision_tree.rs | 6 ++++-- compiler/mono/src/ir.rs | 4 ++-- compiler/mono/src/layout.rs | 17 ++++++++++++++--- 4 files changed, 25 insertions(+), 14 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 97338c9937..7d59d69f25 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -1780,12 +1780,8 @@ fn reserve_with_refcount_union_as_block_of_memory<'a, 'ctx, 'env>( ) -> PointerValue<'ctx> { let block_type = block_of_memory_slices(env.context, fields, env.ptr_bytes); - let tag_id_stack_size = union_layout - .tag_id_layout() - .map(|l| l.stack_size(env.ptr_bytes)); - - let basic_type = if tag_id_stack_size.is_some() { - let tag_id_type = basic_type_from_layout(env, &union_layout.tag_id_layout().unwrap()); + let basic_type = if union_layout.stores_tag_id() { + let tag_id_type = basic_type_from_layout(env, &union_layout.tag_id_layout()); env.context .struct_type(&[block_type, tag_id_type], false) @@ -1800,7 +1796,9 @@ fn reserve_with_refcount_union_as_block_of_memory<'a, 'ctx, 'env>( .max() .unwrap_or_default(); - stack_size += tag_id_stack_size.unwrap_or_default(); + if union_layout.stores_tag_id() { + stack_size += union_layout.tag_id_layout().stack_size(env.ptr_bytes); + } let alignment_bytes = fields .iter() diff --git a/compiler/mono/src/decision_tree.rs b/compiler/mono/src/decision_tree.rs index b8f348520c..fcb851d539 100644 --- a/compiler/mono/src/decision_tree.rs +++ b/compiler/mono/src/decision_tree.rs @@ -1122,8 +1122,10 @@ fn test_to_equality<'a>( let lhs_symbol = env.unique_symbol(); let rhs_symbol = env.unique_symbol(); - stores.push((lhs_symbol, Layout::Builtin(Builtin::Int64), lhs)); - stores.push((rhs_symbol, Layout::Builtin(Builtin::Int64), rhs)); + let tag_id_layout = union_layout.tag_id_layout(); + + stores.push((lhs_symbol, tag_id_layout, lhs)); + stores.push((rhs_symbol, tag_id_layout, rhs)); ( stores, diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 6453da663b..1b1b74586d 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -7698,7 +7698,7 @@ where Stmt::Let( closure_tag_id_symbol, expr, - Layout::Builtin(Builtin::Int64), + union_layout.tag_id_layout(), env.arena.alloc(result), ) } @@ -7857,7 +7857,7 @@ fn match_on_lambda_set<'a>( Stmt::Let( closure_tag_id_symbol, expr, - Layout::Builtin(Builtin::Int64), + union_layout.tag_id_layout(), env.arena.alloc(result), ) } diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index 96edf287a6..05aceea477 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -159,12 +159,23 @@ impl<'a> UnionLayout<'a> { Self::BIGGEST_TAG_ID_TYPE } - pub fn tag_id_layout(&self) -> Option> { + pub fn tag_id_layout(&self) -> Layout<'a> { match self { UnionLayout::NonRecursive(_) | UnionLayout::Recursive(_) - | UnionLayout::NullableWrapped { .. } => Some(Self::BIGGEST_TAG_ID_TYPE), - UnionLayout::NonNullableUnwrapped(_) | UnionLayout::NullableUnwrapped { .. } => None, + | UnionLayout::NullableWrapped { .. } => Self::BIGGEST_TAG_ID_TYPE, + UnionLayout::NonNullableUnwrapped(_) | UnionLayout::NullableUnwrapped { .. } => { + Self::BIGGEST_TAG_ID_TYPE + } + } + } + + pub fn stores_tag_id(&self) -> bool { + match self { + UnionLayout::NonRecursive(_) + | UnionLayout::Recursive(_) + | UnionLayout::NullableWrapped { .. } => true, + UnionLayout::NonNullableUnwrapped(_) | UnionLayout::NullableUnwrapped { .. } => false, } } } From 978cea4b8a469f83fc8239d1fe2411d9421f9f29 Mon Sep 17 00:00:00 2001 From: Folkert Date: Mon, 28 Jun 2021 22:28:47 +0200 Subject: [PATCH 405/496] passing tests --- cli/src/repl/eval.rs | 204 ++++++++++++---------- compiler/build/src/program.rs | 5 +- compiler/gen_llvm/src/llvm/build.rs | 71 ++++---- compiler/gen_llvm/src/llvm/build_hash.rs | 21 ++- compiler/gen_llvm/src/llvm/compare.rs | 15 +- compiler/gen_llvm/src/llvm/convert.rs | 15 +- compiler/gen_llvm/src/llvm/refcounting.rs | 17 +- compiler/mono/src/decision_tree.rs | 9 +- compiler/mono/src/ir.rs | 22 +-- compiler/mono/src/layout.rs | 40 +++-- compiler/test_gen/src/gen_tags.rs | 16 +- compiler/test_gen/src/helpers/eval.rs | 2 +- 12 files changed, 230 insertions(+), 207 deletions(-) diff --git a/cli/src/repl/eval.rs b/cli/src/repl/eval.rs index a8630e6634..7d150a4756 100644 --- a/cli/src/repl/eval.rs +++ b/cli/src/repl/eval.rs @@ -198,114 +198,134 @@ fn jit_to_ast_help<'a>( |bytes: *const u8| { ptr_to_ast(bytes as *const u8) } ) } - Layout::Union(UnionLayout::NonRecursive(union_layouts)) => match content { - Content::Structure(FlatType::TagUnion(tags, _)) => { - debug_assert_eq!(union_layouts.len(), tags.len()); + Layout::Union(UnionLayout::NonRecursive(union_layouts)) => { + let union_layout = UnionLayout::NonRecursive(union_layouts); - let tags_vec: std::vec::Vec<(TagName, std::vec::Vec)> = - tags.iter().map(|(a, b)| (a.clone(), b.clone())).collect(); + match content { + Content::Structure(FlatType::TagUnion(tags, _)) => { + debug_assert_eq!(union_layouts.len(), tags.len()); - let union_variant = union_sorted_tags_help(env.arena, tags_vec, None, env.subs); + let tags_vec: std::vec::Vec<(TagName, std::vec::Vec)> = + tags.iter().map(|(a, b)| (a.clone(), b.clone())).collect(); - let size = layout.stack_size(env.ptr_bytes); - use roc_mono::layout::WrappedVariant::*; - match union_variant { - UnionVariant::Wrapped(variant) => { - match variant { - NonRecursive { - sorted_tag_layouts: tags_and_layouts, - } => { - Ok(run_jit_function_dynamic_type!( - lib, - main_fn_name, - size as usize, - |ptr: *const u8| { - // Because this is a `Wrapped`, the first 8 bytes encode the tag ID - let offset = tags_and_layouts - .iter() - .map(|(_, fields)| { - fields - .iter() - .map(|l| l.stack_size(env.ptr_bytes)) - .sum() - }) - .max() - .unwrap_or(0); + let union_variant = union_sorted_tags_help(env.arena, tags_vec, None, env.subs); - let tag_id = *(ptr.add(offset as usize) as *const i64); + let size = layout.stack_size(env.ptr_bytes); + use roc_mono::layout::WrappedVariant::*; + match union_variant { + UnionVariant::Wrapped(variant) => { + match variant { + NonRecursive { + sorted_tag_layouts: tags_and_layouts, + } => { + Ok(run_jit_function_dynamic_type!( + lib, + main_fn_name, + size as usize, + |ptr: *const u8| { + // Because this is a `Wrapped`, the first 8 bytes encode the tag ID + let offset = tags_and_layouts + .iter() + .map(|(_, fields)| { + fields + .iter() + .map(|l| l.stack_size(env.ptr_bytes)) + .sum() + }) + .max() + .unwrap_or(0); - // use the tag ID as an index, to get its name and layout of any arguments - let (tag_name, arg_layouts) = - &tags_and_layouts[tag_id as usize]; + let tag_id = match union_layout.tag_id_builtin() { + Builtin::Int1 => { + *(ptr.add(offset as usize) as *const i8) as i64 + } + Builtin::Int8 => { + *(ptr.add(offset as usize) as *const i8) as i64 + } + Builtin::Int16 => { + *(ptr.add(offset as usize) as *const i16) as i64 + } + _ => unreachable!("invalid tag id layout"), + }; - let tag_expr = tag_name_to_expr(env, tag_name); - let loc_tag_expr = - &*env.arena.alloc(Located::at_zero(tag_expr)); + // use the tag ID as an index, to get its name and layout of any arguments + let (tag_name, arg_layouts) = + &tags_and_layouts[tag_id as usize]; - let variables = &tags[tag_name]; + let tag_expr = tag_name_to_expr(env, tag_name); + let loc_tag_expr = + &*env.arena.alloc(Located::at_zero(tag_expr)); - debug_assert_eq!(arg_layouts.len(), variables.len()); + let variables = &tags[tag_name]; - // NOTE assumes the data bytes are the first bytes - let it = variables.iter().copied().zip(arg_layouts.iter()); - let output = sequence_of_expr(env, ptr, it); - let output = output.into_bump_slice(); + debug_assert_eq!(arg_layouts.len(), variables.len()); - Expr::Apply(loc_tag_expr, output, CalledVia::Space) - } - )) + // NOTE assumes the data bytes are the first bytes + let it = + variables.iter().copied().zip(arg_layouts.iter()); + let output = sequence_of_expr(env, ptr, it); + let output = output.into_bump_slice(); + + Expr::Apply(loc_tag_expr, output, CalledVia::Space) + } + )) + } + Recursive { + sorted_tag_layouts: tags_and_layouts, + } => { + Ok(run_jit_function_dynamic_type!( + lib, + main_fn_name, + size as usize, + |ptr: *const u8| { + // Because this is a `Wrapped`, the first 8 bytes encode the tag ID + let tag_id = *(ptr as *const i64); + + // use the tag ID as an index, to get its name and layout of any arguments + let (tag_name, arg_layouts) = + &tags_and_layouts[tag_id as usize]; + + let tag_expr = tag_name_to_expr(env, tag_name); + let loc_tag_expr = + &*env.arena.alloc(Located::at_zero(tag_expr)); + + let variables = &tags[tag_name]; + + // because the arg_layouts include the tag ID, it is one longer + debug_assert_eq!( + arg_layouts.len() - 1, + variables.len() + ); + + // skip forward to the start of the first element, ignoring the tag id + let ptr = ptr.offset(8); + + let it = + variables.iter().copied().zip(&arg_layouts[1..]); + let output = sequence_of_expr(env, ptr, it); + let output = output.into_bump_slice(); + + Expr::Apply(loc_tag_expr, output, CalledVia::Space) + } + )) + } + _ => todo!(), } - Recursive { - sorted_tag_layouts: tags_and_layouts, - } => { - Ok(run_jit_function_dynamic_type!( - lib, - main_fn_name, - size as usize, - |ptr: *const u8| { - // Because this is a `Wrapped`, the first 8 bytes encode the tag ID - let tag_id = *(ptr as *const i64); - - // use the tag ID as an index, to get its name and layout of any arguments - let (tag_name, arg_layouts) = - &tags_and_layouts[tag_id as usize]; - - let tag_expr = tag_name_to_expr(env, tag_name); - let loc_tag_expr = - &*env.arena.alloc(Located::at_zero(tag_expr)); - - let variables = &tags[tag_name]; - - // because the arg_layouts include the tag ID, it is one longer - debug_assert_eq!(arg_layouts.len() - 1, variables.len()); - - // skip forward to the start of the first element, ignoring the tag id - let ptr = ptr.offset(8); - - let it = variables.iter().copied().zip(&arg_layouts[1..]); - let output = sequence_of_expr(env, ptr, it); - let output = output.into_bump_slice(); - - Expr::Apply(loc_tag_expr, output, CalledVia::Space) - } - )) - } - _ => todo!(), } + _ => unreachable!("any other variant would have a different layout"), } - _ => unreachable!("any other variant would have a different layout"), } - } - Content::Structure(FlatType::RecursiveTagUnion(_, _, _)) => { - todo!("print recursive tag unions in the REPL") - } - Content::Alias(_, _, actual) => { - let content = env.subs.get_without_compacting(*actual).content; + Content::Structure(FlatType::RecursiveTagUnion(_, _, _)) => { + todo!("print recursive tag unions in the REPL") + } + Content::Alias(_, _, actual) => { + let content = env.subs.get_without_compacting(*actual).content; - jit_to_ast_help(env, lib, main_fn_name, layout, &content) + jit_to_ast_help(env, lib, main_fn_name, layout, &content) + } + other => unreachable!("Weird content for Union layout: {:?}", other), } - other => unreachable!("Weird content for Union layout: {:?}", other), - }, + } Layout::Union(UnionLayout::Recursive(_)) | Layout::Union(UnionLayout::NullableWrapped { .. }) | Layout::Union(UnionLayout::NullableUnwrapped { .. }) diff --git a/compiler/build/src/program.rs b/compiler/build/src/program.rs index c7dfb22c2f..82d7261950 100644 --- a/compiler/build/src/program.rs +++ b/compiler/build/src/program.rs @@ -164,8 +164,9 @@ pub fn gen_from_mono_module( env.module.print_to_file(&app_ll_file).unwrap(); panic!( - "😱 LLVM errors when defining module; I wrote the full LLVM IR to {:?}\n\n {:?}", - app_ll_file, errors, + "😱 LLVM errors when defining module; I wrote the full LLVM IR to {:?}\n\n {}", + app_ll_file, + errors.to_string(), ); } diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 7d59d69f25..815e636473 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -632,6 +632,7 @@ pub fn int_with_precision<'a, 'ctx, 'env>( Builtin::Int32 => env.context.i32_type().const_int(value as u64, false), Builtin::Int16 => env.context.i16_type().const_int(value as u64, false), Builtin::Int8 => env.context.i8_type().const_int(value as u64, false), + Builtin::Int1 => env.context.bool_type().const_int(value as u64, false), _ => panic!("Invalid layout for int literal = {:?}", precision), } } @@ -1081,11 +1082,8 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( let field_layouts = tag_layouts[*tag_id as usize]; - let tag_id_type = basic_type_from_layout( - env, - &UnionLayout::tag_id_layout_from_slices(tag_layouts), - ) - .into_int_type(); + let tag_id_type = + basic_type_from_layout(env, &union_layout.tag_id_layout()).into_int_type(); lookup_at_index_ptr2( env, @@ -1124,11 +1122,8 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( let field_layouts = other_tags[tag_index as usize]; - let tag_id_type = basic_type_from_layout( - env, - &UnionLayout::tag_id_layout_from_slices(other_tags), - ) - .into_int_type(); + let tag_id_type = + basic_type_from_layout(env, &union_layout.tag_id_layout()).into_int_type(); lookup_at_index_ptr2( env, @@ -1183,6 +1178,8 @@ pub fn build_tag<'a, 'ctx, 'env>( tag_id: u8, arguments: &[Symbol], ) -> BasicValueEnum<'ctx> { + let tag_id_layout = union_layout.tag_id_layout(); + match union_layout { UnionLayout::NonRecursive(tags) => { debug_assert!(union_size > 1); @@ -1254,9 +1251,7 @@ pub fn build_tag<'a, 'ctx, 'env>( let internal_type = block_of_memory_slices(env.context, tags, env.ptr_bytes); let data = cast_tag_to_block_of_memory(builder, struct_val, internal_type); - let tag_id_type = - basic_type_from_layout(env, &UnionLayout::tag_id_layout_from_slices(tags)) - .into_int_type(); + let tag_id_type = basic_type_from_layout(env, &tag_id_layout).into_int_type(); let wrapper_type = env .context .struct_type(&[data.get_type(), tag_id_type.into()], false); @@ -1264,8 +1259,8 @@ pub fn build_tag<'a, 'ctx, 'env>( let tag_id_intval = tag_id_type.const_int(tag_id as u64, false); let field_vals = [ - (TAG_ID_INDEX as usize, tag_id_intval.into()), (TAG_DATA_INDEX as usize, data), + (TAG_ID_INDEX as usize, tag_id_intval.into()), ]; struct_from_fields(env, wrapper_type, field_vals.iter().copied()).into() @@ -1317,9 +1312,7 @@ pub fn build_tag<'a, 'ctx, 'env>( .build_struct_gep(raw_data_ptr, TAG_ID_INDEX, "tag_id_index") .unwrap(); - let tag_id_type = - basic_type_from_layout(env, &UnionLayout::tag_id_layout_from_slices(tags)) - .into_int_type(); + let tag_id_type = basic_type_from_layout(env, &tag_id_layout).into_int_type(); env.builder .build_store(tag_id_ptr, tag_id_type.const_int(tag_id as u64, false)); @@ -1482,9 +1475,7 @@ pub fn build_tag<'a, 'ctx, 'env>( .build_struct_gep(raw_data_ptr, TAG_ID_INDEX, "tag_id_index") .unwrap(); - let tag_id_type = - basic_type_from_layout(env, &UnionLayout::tag_id_layout_from_slices(tags)) - .into_int_type(); + let tag_id_type = basic_type_from_layout(env, &tag_id_layout).into_int_type(); env.builder .build_store(tag_id_ptr, tag_id_type.const_int(tag_id as u64, false)); @@ -1608,6 +1599,10 @@ pub fn get_tag_id<'a, 'ctx, 'env>( argument: BasicValueEnum<'ctx>, ) -> IntValue<'ctx> { let builder = env.builder; + + let tag_id_layout = union_layout.tag_id_layout(); + let tag_id_int_type = basic_type_from_layout(env, &tag_id_layout).into_int_type(); + match union_layout { UnionLayout::NonRecursive(_) => { let tag = argument.into_struct_value(); @@ -1615,7 +1610,7 @@ pub fn get_tag_id<'a, 'ctx, 'env>( get_tag_id_non_recursive(env, tag) } UnionLayout::Recursive(_) => get_tag_id_wrapped(env, argument.into_pointer_value()), - UnionLayout::NonNullableUnwrapped(_) => env.context.i64_type().const_zero(), + UnionLayout::NonNullableUnwrapped(_) => tag_id_int_type.const_zero(), UnionLayout::NullableWrapped { nullable_id, .. } => { let argument_ptr = argument.into_pointer_value(); let is_null = env.builder.build_is_null(argument_ptr, "is_null"); @@ -1625,14 +1620,14 @@ pub fn get_tag_id<'a, 'ctx, 'env>( let else_block = ctx.append_basic_block(parent, "else"); let cont_block = ctx.append_basic_block(parent, "cont"); - let result = builder.build_alloca(ctx.i64_type(), "result"); + let result = builder.build_alloca(tag_id_int_type, "result"); env.builder .build_conditional_branch(is_null, then_block, else_block); { env.builder.position_at_end(then_block); - let tag_id = ctx.i64_type().const_int(*nullable_id as u64, false); + let tag_id = tag_id_int_type.const_int(*nullable_id as u64, false); env.builder.build_store(result, tag_id); env.builder.build_unconditional_branch(cont_block); } @@ -1654,10 +1649,8 @@ pub fn get_tag_id<'a, 'ctx, 'env>( let argument_ptr = argument.into_pointer_value(); let is_null = env.builder.build_is_null(argument_ptr, "is_null"); - let ctx = env.context; - - let then_value = ctx.i64_type().const_int(*nullable_id as u64, false); - let else_value = ctx.i64_type().const_int(!*nullable_id as u64, false); + let then_value = tag_id_int_type.const_int(*nullable_id as u64, false); + let else_value = tag_id_int_type.const_int(!*nullable_id as u64, false); env.builder .build_select(is_null, then_value, else_value, "select_tag_id") @@ -1746,10 +1739,10 @@ fn lookup_at_index_ptr2<'a, 'ctx, 'env>( let tags = &[field_layouts]; let struct_type = block_of_memory_slices(env.context, tags, env.ptr_bytes); - let tag_id_type = - basic_type_from_layout(env, &UnionLayout::tag_id_layout_from_slices(tags)); - let opaque_wrapper_type = env.context.struct_type(&[struct_type, tag_id_type], false); + let opaque_wrapper_type = env + .context + .struct_type(&[struct_type, tag_id_type.into()], false); builder.build_bitcast( result, @@ -2741,18 +2734,14 @@ fn build_switch_ir<'a, 'ctx, 'env>( // ] // // they either need to all be i8, or i64 - let int_val = match cond_layout { - Layout::Builtin(Builtin::Usize) => { - ptr_int(env.context, env.ptr_bytes).const_int(*int as u64, false) - } - Layout::Builtin(Builtin::Int64) => context.i64_type().const_int(*int as u64, false), - Layout::Builtin(Builtin::Int128) => const_i128(env, *int as i128), - Layout::Builtin(Builtin::Int32) => context.i32_type().const_int(*int as u64, false), - Layout::Builtin(Builtin::Int16) => context.i16_type().const_int(*int as u64, false), - Layout::Builtin(Builtin::Int8) => context.i8_type().const_int(*int as u64, false), - Layout::Builtin(Builtin::Int1) => context.bool_type().const_int(*int as u64, false), - _ => panic!("Can't cast to cond_layout = {:?}", cond_layout), + let condition_int_type = cond.get_type(); + + let int_val = if condition_int_type == context.i128_type() { + const_i128(env, *int as i128) + } else { + condition_int_type.const_int(*int as u64, false) }; + let block = context.append_basic_block(parent, format!("branch{}", int).as_str()); cases.push((int_val, block)); diff --git a/compiler/gen_llvm/src/llvm/build_hash.rs b/compiler/gen_llvm/src/llvm/build_hash.rs index a42aaf2f7d..8195b864c5 100644 --- a/compiler/gen_llvm/src/llvm/build_hash.rs +++ b/compiler/gen_llvm/src/llvm/build_hash.rs @@ -401,12 +401,14 @@ fn hash_tag<'a, 'ctx, 'env>( let merge_block = env.context.append_basic_block(parent, "merge_block"); env.builder.position_at_end(merge_block); - let merge_phi = env.builder.build_phi(env.context.i64_type(), "merge_hash"); + let tag_id_basic_type = basic_type_from_layout(env, &union_layout.tag_id_layout()); + + let merge_phi = env.builder.build_phi(seed.get_type(), "merge_hash"); env.builder.position_at_end(entry_block); match union_layout { NonRecursive(tags) => { - let tag_id = get_tag_id(env, parent, union_layout, tag); + let current_tag_id = get_tag_id(env, parent, union_layout, tag); let mut cases = Vec::with_capacity_in(tags.len(), env.arena); @@ -414,7 +416,6 @@ fn hash_tag<'a, 'ctx, 'env>( let block = env.context.append_basic_block(parent, "tag_id_modify"); env.builder.position_at_end(block); - // TODO drop tag id? let struct_layout = Layout::Struct(field_layouts); let wrapper_type = basic_type_from_layout(env, &struct_layout); @@ -436,7 +437,7 @@ fn hash_tag<'a, 'ctx, 'env>( env.builder.build_unconditional_branch(merge_block); cases.push(( - env.context.i64_type().const_int(tag_id as u64, false), + current_tag_id.get_type().const_int(tag_id as u64, false), block, )); } @@ -445,10 +446,10 @@ fn hash_tag<'a, 'ctx, 'env>( let default = cases.pop().unwrap().1; - env.builder.build_switch(tag_id, default, &cases); + env.builder.build_switch(current_tag_id, default, &cases); } Recursive(tags) => { - let tag_id = get_tag_id(env, parent, union_layout, tag); + let current_tag_id = get_tag_id(env, parent, union_layout, tag); let mut cases = Vec::with_capacity_in(tags.len(), env.arena); @@ -469,7 +470,7 @@ fn hash_tag<'a, 'ctx, 'env>( env.builder.build_unconditional_branch(merge_block); cases.push(( - env.context.i64_type().const_int(tag_id as u64, false), + current_tag_id.get_type().const_int(tag_id as u64, false), block, )); } @@ -478,7 +479,7 @@ fn hash_tag<'a, 'ctx, 'env>( let default = cases.pop().unwrap().1; - env.builder.build_switch(tag_id, default, &cases); + env.builder.build_switch(current_tag_id, default, &cases); } NullableUnwrapped { other_fields, .. } => { let tag = tag.into_pointer_value(); @@ -544,7 +545,9 @@ fn hash_tag<'a, 'ctx, 'env>( env.builder.build_unconditional_branch(merge_block); cases.push(( - env.context.i64_type().const_int(tag_id as u64, false), + tag_id_basic_type + .into_int_type() + .const_int(tag_id as u64, false), block, )); } diff --git a/compiler/gen_llvm/src/llvm/compare.rs b/compiler/gen_llvm/src/llvm/compare.rs index 4116ce67ef..2a9d1d3fa3 100644 --- a/compiler/gen_llvm/src/llvm/compare.rs +++ b/compiler/gen_llvm/src/llvm/compare.rs @@ -896,10 +896,7 @@ fn build_tag_eq_help<'a, 'ctx, 'env>( env.builder.build_return(Some(&answer)); - cases.push(( - env.context.i64_type().const_int(tag_id as u64, false), - block, - )); + cases.push((id1.get_type().const_int(tag_id as u64, false), block)); } env.builder.position_at_end(compare_tag_fields); @@ -958,10 +955,7 @@ fn build_tag_eq_help<'a, 'ctx, 'env>( env.builder.build_return(Some(&answer)); - cases.push(( - env.context.i64_type().const_int(tag_id as u64, false), - block, - )); + cases.push((id1.get_type().const_int(tag_id as u64, false), block)); } env.builder.position_at_end(compare_tag_fields); @@ -1110,10 +1104,7 @@ fn build_tag_eq_help<'a, 'ctx, 'env>( env.builder.build_return(Some(&answer)); - cases.push(( - env.context.i64_type().const_int(tag_id as u64, false), - block, - )); + cases.push((id1.get_type().const_int(tag_id as u64, false), block)); } env.builder.position_at_end(compare_tag_fields); diff --git a/compiler/gen_llvm/src/llvm/convert.rs b/compiler/gen_llvm/src/llvm/convert.rs index e00861a381..1cb299c0ae 100644 --- a/compiler/gen_llvm/src/llvm/convert.rs +++ b/compiler/gen_llvm/src/llvm/convert.rs @@ -33,6 +33,9 @@ pub fn basic_type_from_layout<'a, 'ctx, 'env>( Struct(sorted_fields) => basic_type_from_record(env, sorted_fields), Union(variant) => { use UnionLayout::*; + + let tag_id_type = basic_type_from_layout(env, &variant.tag_id_layout()); + match variant { NullableWrapped { other_tags: tags, .. @@ -40,7 +43,7 @@ pub fn basic_type_from_layout<'a, 'ctx, 'env>( let data = block_of_memory_slices(env.context, tags, env.ptr_bytes); env.context - .struct_type(&[data, env.context.i64_type().into()], false) + .struct_type(&[data, tag_id_type], false) .ptr_type(AddressSpace::Generic) .into() } @@ -57,16 +60,14 @@ pub fn basic_type_from_layout<'a, 'ctx, 'env>( let data = block_of_memory_slices(env.context, tags, env.ptr_bytes); env.context - .struct_type(&[data, env.context.i64_type().into()], false) + .struct_type(&[data, tag_id_type], false) .ptr_type(AddressSpace::Generic) .into() } NonRecursive(tags) => { let data = block_of_memory_slices(env.context, tags, env.ptr_bytes); - env.context - .struct_type(&[data, env.context.i64_type().into()], false) - .into() + env.context.struct_type(&[data, tag_id_type], false).into() } } } @@ -146,12 +147,12 @@ pub fn union_data_is_struct_type<'ctx>( pub fn union_data_block_of_memory<'ctx>( context: &'ctx Context, + tag_id_int_type: IntType<'ctx>, layouts: &[&[Layout<'_>]], ptr_bytes: u32, ) -> StructType<'ctx> { - let tag_id_type = context.i64_type(); let data_type = block_of_memory_slices(context, layouts, ptr_bytes); - context.struct_type(&[data_type, tag_id_type.into()], false) + context.struct_type(&[data_type, tag_id_int_type.into()], false) } pub fn block_of_memory<'ctx>( diff --git a/compiler/gen_llvm/src/llvm/refcounting.rs b/compiler/gen_llvm/src/llvm/refcounting.rs index 4bc81ab803..4dd072f622 100644 --- a/compiler/gen_llvm/src/llvm/refcounting.rs +++ b/compiler/gen_llvm/src/llvm/refcounting.rs @@ -1394,6 +1394,9 @@ fn build_rec_union_recursive_decrement<'a, 'ctx, 'env>( // next, make a jump table for all possible values of the tag_id let mut cases = Vec::with_capacity_in(tags.len(), env.arena); + let tag_id_int_type = + basic_type_from_layout(env, &union_layout.tag_id_layout()).into_int_type(); + for (tag_id, field_layouts) in tags.iter().enumerate() { // if none of the fields are or contain anything refcounted, just move on if !field_layouts @@ -1439,11 +1442,16 @@ fn build_rec_union_recursive_decrement<'a, 'ctx, 'env>( debug_assert!(ptr_as_i64_ptr.is_pointer_value()); // therefore we must cast it to our desired type - let union_type = match union_layout { UnionLayout::NonRecursive(_) => unreachable!(), UnionLayout::Recursive(_) | UnionLayout::NullableWrapped { .. } => { - union_data_block_of_memory(env.context, tags, env.ptr_bytes).into() + union_data_block_of_memory( + env.context, + tag_id_int_type, + tags, + env.ptr_bytes, + ) + .into() } UnionLayout::NonNullableUnwrapped { .. } | UnionLayout::NullableUnwrapped { .. } => { @@ -1501,10 +1509,7 @@ fn build_rec_union_recursive_decrement<'a, 'ctx, 'env>( // this function returns void builder.build_return(None); - cases.push(( - env.context.i64_type().const_int(tag_id as u64, false), - block, - )); + cases.push((tag_id_int_type.const_int(tag_id as u64, false), block)); } env.builder.position_at_end(match_block); diff --git a/compiler/mono/src/decision_tree.rs b/compiler/mono/src/decision_tree.rs index fcb851d539..c991118612 100644 --- a/compiler/mono/src/decision_tree.rs +++ b/compiler/mono/src/decision_tree.rs @@ -1691,7 +1691,7 @@ fn decide_to_branching<'a>( let tag_id_symbol = env.unique_symbol(); let temp = Stmt::Switch { - cond_layout: Layout::TAG_SIZE, + cond_layout: union_layout.tag_id_layout(), cond_symbol: tag_id_symbol, branches: branches.into_bump_slice(), default_branch: (default_branch_info, env.arena.alloc(default_branch)), @@ -1703,7 +1703,12 @@ fn decide_to_branching<'a>( union_layout, }; - Stmt::Let(tag_id_symbol, expr, Layout::TAG_SIZE, env.arena.alloc(temp)) + Stmt::Let( + tag_id_symbol, + expr, + union_layout.tag_id_layout(), + env.arena.alloc(temp), + ) } else { Stmt::Switch { cond_layout: inner_cond_layout, diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 1b1b74586d..94877e4ad0 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -4,7 +4,7 @@ use self::InProgressProc::*; use crate::exhaustive::{Ctor, Guard, RenderAs, TagId}; use crate::layout::{ Builtin, ClosureRepresentation, LambdaSet, Layout, LayoutCache, LayoutProblem, - RawFunctionLayout, UnionLayout, WrappedVariant, TAG_SIZE, + RawFunctionLayout, UnionLayout, WrappedVariant, }; use bumpalo::collections::Vec; use bumpalo::Bump; @@ -4176,7 +4176,7 @@ fn convert_tag_union<'a>( let opt_tag_id_symbol; use WrappedVariant::*; - let (tag, layout) = match variant { + let (tag, union_layout) = match variant { Recursive { sorted_tag_layouts } => { debug_assert!(sorted_tag_layouts.len() > 1); opt_tag_id_symbol = None; @@ -4207,7 +4207,7 @@ fn convert_tag_union<'a>( arguments: field_symbols, }; - (tag, Layout::Union(union_layout)) + (tag, union_layout) } NonNullableUnwrapped { fields, @@ -4235,7 +4235,7 @@ fn convert_tag_union<'a>( arguments: field_symbols, }; - (tag, Layout::Union(union_layout)) + (tag, union_layout) } NonRecursive { sorted_tag_layouts } => { opt_tag_id_symbol = None; @@ -4265,7 +4265,7 @@ fn convert_tag_union<'a>( arguments: field_symbols, }; - (tag, Layout::Union(union_layout)) + (tag, union_layout) } NullableWrapped { nullable_id, @@ -4302,7 +4302,7 @@ fn convert_tag_union<'a>( arguments: field_symbols, }; - (tag, Layout::Union(union_layout)) + (tag, union_layout) } NullableUnwrapped { nullable_id, @@ -4335,11 +4335,11 @@ fn convert_tag_union<'a>( arguments: field_symbols, }; - (tag, Layout::Union(union_layout)) + (tag, union_layout) } }; - let mut stmt = Stmt::Let(assigned, tag, layout, hole); + let mut stmt = Stmt::Let(assigned, tag, Layout::Union(union_layout), hole); let iter = field_symbols_temp .into_iter() .map(|x| x.2 .0) @@ -4353,7 +4353,7 @@ fn convert_tag_union<'a>( stmt = Stmt::Let( tag_id_symbol, Expr::Literal(Literal::Int(tag_id as i128)), - Layout::Builtin(TAG_SIZE), + union_layout.tag_id_layout(), arena.alloc(stmt), ); } @@ -7680,7 +7680,7 @@ where env, lambda_set.set, closure_tag_id_symbol, - Layout::Builtin(crate::layout::TAG_SIZE), + union_layout.tag_id_layout(), closure_data_symbol, lambda_set.is_represented(), to_lowlevel_call, @@ -7839,7 +7839,7 @@ fn match_on_lambda_set<'a>( lambda_set.set, lambda_set.runtime_representation(), closure_tag_id_symbol, - Layout::Builtin(crate::layout::TAG_SIZE), + union_layout.tag_id_layout(), closure_data_symbol, argument_symbols, argument_layouts, diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index 05aceea477..6152b73304 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -14,11 +14,6 @@ const GENERATE_NULLABLE: bool = true; /// If a (Num *) gets translated to a Layout, this is the numeric type it defaults to. const DEFAULT_NUM_BUILTIN: Builtin<'_> = Builtin::Int64; -pub const TAG_SIZE: Builtin<'_> = Builtin::Int64; - -impl Layout<'_> { - pub const TAG_SIZE: Layout<'static> = Layout::Builtin(Builtin::Int64); -} #[derive(Debug, Clone)] pub enum LayoutProblem { @@ -153,21 +148,34 @@ impl<'a> UnionLayout<'a> { } } - const BIGGEST_TAG_ID_TYPE: Layout<'static> = Layout::Builtin(Builtin::Int64); + fn tag_id_builtin_help(union_size: usize) -> Builtin<'a> { + if union_size <= u8::MAX as usize { + Builtin::Int8 + } else if union_size <= u16::MAX as usize { + Builtin::Int16 + } else { + panic!("tag union is too big") + } + } - pub fn tag_id_layout_from_slices(_slices: &[&[Layout<'a>]]) -> Layout<'a> { - Self::BIGGEST_TAG_ID_TYPE + pub fn tag_id_builtin(&self) -> Builtin<'a> { + match self { + UnionLayout::NonRecursive(tags) | UnionLayout::Recursive(tags) => { + let union_size = tags.len(); + + Self::tag_id_builtin_help(union_size) + } + + UnionLayout::NullableWrapped { other_tags, .. } => { + Self::tag_id_builtin_help(other_tags.len() + 1) + } + UnionLayout::NonNullableUnwrapped(_) => Builtin::Int1, + UnionLayout::NullableUnwrapped { .. } => Builtin::Int1, + } } pub fn tag_id_layout(&self) -> Layout<'a> { - match self { - UnionLayout::NonRecursive(_) - | UnionLayout::Recursive(_) - | UnionLayout::NullableWrapped { .. } => Self::BIGGEST_TAG_ID_TYPE, - UnionLayout::NonNullableUnwrapped(_) | UnionLayout::NullableUnwrapped { .. } => { - Self::BIGGEST_TAG_ID_TYPE - } - } + Layout::Builtin(self.tag_id_builtin()) } pub fn stores_tag_id(&self) -> bool { diff --git a/compiler/test_gen/src/gen_tags.rs b/compiler/test_gen/src/gen_tags.rs index 4359836051..776c06ff07 100644 --- a/compiler/test_gen/src/gen_tags.rs +++ b/compiler/test_gen/src/gen_tags.rs @@ -634,7 +634,7 @@ fn nested_tag_union() { "# ), ((41, 0), 0), - ((i64, i64), i64) + ((i64, u8), u8) ); } #[test] @@ -799,14 +799,14 @@ fn alignment_in_multi_tag_construction() { indoc!( r"# x : [ Three Bool I64, Empty ] - x = Three (1 == 1) 32 + x = Three (1 == 1) 32 x #" ), - (32i64, true, 1), - (i64, bool, i64) + ((32i64, true), 1), + ((i64, bool), u8) ); assert_evals_to!( @@ -818,8 +818,8 @@ fn alignment_in_multi_tag_construction() { x #" ), - (32i64, true, 2u8, 1), - (i64, bool, u8, i64) + ((32i64, true, 2u8), 1), + ((i64, bool, u8), u8) ); } @@ -948,8 +948,8 @@ fn nested_recursive_literal() { #" ), 0, - &(i64, i64, i64), - |x: &(i64, i64, i64)| x.2 + &(i64, i64, u8), + |x: &(i64, i64, u8)| x.2 ); } diff --git a/compiler/test_gen/src/helpers/eval.rs b/compiler/test_gen/src/helpers/eval.rs index 9f9dfb83ca..713f1b8a30 100644 --- a/compiler/test_gen/src/helpers/eval.rs +++ b/compiler/test_gen/src/helpers/eval.rs @@ -246,7 +246,7 @@ pub fn helper<'a>( // Verify the module if let Err(errors) = env.module.verify() { - panic!("Errors defining module: {:?}", errors); + panic!("Errors defining module:\n\n{}", errors.to_string()); } // Uncomment this to see the module's optimized LLVM instruction output: From 5afcbeed206eac311a57a4b88787e7178035fd1e Mon Sep 17 00:00:00 2001 From: rvcas Date: Mon, 28 Jun 2021 18:54:21 -0400 Subject: [PATCH 406/496] fix: better RunTimeError case in nodes --- editor/src/editor/markup/nodes.rs | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/editor/src/editor/markup/nodes.rs b/editor/src/editor/markup/nodes.rs index e40a38c714..f5bc37f95a 100644 --- a/editor/src/editor/markup/nodes.rs +++ b/editor/src/editor/markup/nodes.rs @@ -347,9 +347,12 @@ pub fn expr2_to_markup<'a, 'b>( syn_high_style: HighlightStyle::Blank, parent_id_opt: None, }), - Expr2::RuntimeError() => { - todo!("Handle Expr2::RuntimeError") - } + Expr2::RuntimeError() => new_markup_node( + "RunTimeError".to_string(), + expr2_node_id, + HighlightStyle::Blank, + markup_node_pool, + ), rest => todo!("implement expr2_to_markup for {:?}", rest), } } From 8f97637d1cb3e7a003b0787502a3c671ce94ab02 Mon Sep 17 00:00:00 2001 From: rvcas Date: Mon, 28 Jun 2021 18:54:44 -0400 Subject: [PATCH 407/496] tests: deal with new changes for RunTimeError --- editor/src/editor/mvc/ed_update.rs | 168 ++++++++++++++++------------- 1 file changed, 96 insertions(+), 72 deletions(-) diff --git a/editor/src/editor/mvc/ed_update.rs b/editor/src/editor/mvc/ed_update.rs index 5562261a69..47ada05250 100644 --- a/editor/src/editor/mvc/ed_update.rs +++ b/editor/src/editor/mvc/ed_update.rs @@ -1016,27 +1016,27 @@ pub mod test_ed_update { fn test_record() -> Result<(), String> { assert_insert(&["┃"], &["{ ┃ }"], '{')?; assert_insert(&["{ ┃ }"], &["{ a┃ }"], 'a')?; - assert_insert(&["{ a┃ }"], &["{ ab┃ }"], 'b')?; - assert_insert(&["{ a┃ }"], &["{ a1┃ }"], '1')?; - assert_insert(&["{ a1┃ }"], &["{ a1z┃ }"], 'z')?; - assert_insert(&["{ a1┃ }"], &["{ a15┃ }"], '5')?; - assert_insert(&["{ ab┃ }"], &["{ abc┃ }"], 'c')?; - assert_insert(&["{ ┃abc }"], &["{ z┃abc }"], 'z')?; - assert_insert(&["{ a┃b }"], &["{ az┃b }"], 'z')?; - assert_insert(&["{ a┃b }"], &["{ a9┃b }"], '9')?; + assert_insert(&["{ a┃ }"], &["{ ab┃: RunTimeError }"], 'b')?; + assert_insert(&["{ a┃ }"], &["{ a1┃: RunTimeError }"], '1')?; + assert_insert(&["{ a1┃ }"], &["{ a1z┃: RunTimeError }"], 'z')?; + assert_insert(&["{ a1┃ }"], &["{ a15┃: RunTimeError }"], '5')?; + assert_insert(&["{ ab┃ }"], &["{ abc┃: RunTimeError }"], 'c')?; + assert_insert(&["{ ┃abc }"], &["{ z┃abc: RunTimeError }"], 'z')?; + assert_insert(&["{ a┃b }"], &["{ az┃b: RunTimeError }"], 'z')?; + assert_insert(&["{ a┃b }"], &["{ a9┃b: RunTimeError }"], '9')?; // extra space for Blank node - assert_insert(&["{ a┃ }"], &["{ a: ┃ }"], ':')?; - assert_insert(&["{ abc┃ }"], &["{ abc: ┃ }"], ':')?; - assert_insert(&["{ aBc┃ }"], &["{ aBc: ┃ }"], ':')?; + assert_insert(&["{ a┃ }"], &["{ a┃: RunTimeError }"], ':')?; + assert_insert(&["{ abc┃ }"], &["{ abc┃: RunTimeError }"], ':')?; + assert_insert(&["{ aBc┃ }"], &["{ aBc┃: RunTimeError }"], ':')?; - assert_insert_seq(&["{ a┃ }"], &["{ a: \"┃\" }"], ":\"")?; - assert_insert_seq(&["{ abc┃ }"], &["{ abc: \"┃\" }"], ":\"")?; + assert_insert_seq(&["{ a┃ }"], &["{ a┃: RunTimeError }"], ":\"")?; + assert_insert_seq(&["{ abc┃ }"], &["{ abc┃: RunTimeError }"], ":\"")?; - assert_insert_seq(&["{ a┃ }"], &["{ a: 0┃ }"], ":0")?; - assert_insert_seq(&["{ abc┃ }"], &["{ abc: 9┃ }"], ":9")?; - assert_insert_seq(&["{ a┃ }"], &["{ a: 1000┃ }"], ":1000")?; - assert_insert_seq(&["{ abc┃ }"], &["{ abc: 98761┃ }"], ":98761")?; + assert_insert_seq(&["{ a┃ }"], &["{ a0┃: RunTimeError }"], ":0")?; + assert_insert_seq(&["{ abc┃ }"], &["{ abc9┃: RunTimeError }"], ":9")?; + assert_insert_seq(&["{ a┃ }"], &["{ a1000┃: RunTimeError }"], ":1000")?; + assert_insert_seq(&["{ abc┃ }"], &["{ abc98761┃: RunTimeError }"], ":98761")?; assert_insert(&["{ a: \"┃\" }"], &["{ a: \"a┃\" }"], 'a')?; assert_insert(&["{ a: \"a┃\" }"], &["{ a: \"ab┃\" }"], 'b')?; @@ -1092,9 +1092,9 @@ pub mod test_ed_update { #[test] fn test_nested_record() -> Result<(), String> { - assert_insert_seq(&["{ a┃ }"], &["{ a: { ┃ } }"], ":{")?; - assert_insert_seq(&["{ abc┃ }"], &["{ abc: { ┃ } }"], ":{")?; - assert_insert_seq(&["{ camelCase┃ }"], &["{ camelCase: { ┃ } }"], ":{")?; + assert_insert_seq(&["{ a┃ }"], &["{ a┃: RunTimeError }"], ":{")?; + assert_insert_seq(&["{ abc┃ }"], &["{ abc┃: RunTimeError }"], ":{")?; + assert_insert_seq(&["{ camelCase┃ }"], &["{ camelCase┃: RunTimeError }"], ":{")?; assert_insert_seq(&["{ a: { ┃ } }"], &["{ a: { zulu┃ } }"], "zulu")?; assert_insert_seq( @@ -1104,35 +1104,51 @@ pub mod test_ed_update { )?; assert_insert_seq(&["{ camelCase: { ┃ } }"], &["{ camelCase: { z┃ } }"], "z")?; - assert_insert_seq(&["{ a: { zulu┃ } }"], &["{ a: { zulu: ┃ } }"], ":")?; + assert_insert_seq( + &["{ a: { zulu┃ } }"], + &["{ a: { zulu┃: RunTimeError } }"], + ":", + )?; assert_insert_seq( &["{ abc: { camelCase┃ } }"], - &["{ abc: { camelCase: ┃ } }"], + &["{ abc: { camelCase┃: RunTimeError } }"], ":", )?; assert_insert_seq( &["{ camelCase: { z┃ } }"], - &["{ camelCase: { z: ┃ } }"], + &["{ camelCase: { z┃: RunTimeError } }"], ":", )?; - assert_insert_seq(&["{ a┃: { zulu } }"], &["{ a0┃: { zulu } }"], "0")?; + assert_insert_seq( + &["{ a┃: { zulu } }"], + &["{ a0┃: { zulu: RunTimeError } }"], + "0", + )?; assert_insert_seq( &["{ ab┃c: { camelCase } }"], - &["{ abz┃c: { camelCase } }"], + &["{ abz┃c: { camelCase: RunTimeError } }"], "z", )?; - assert_insert_seq(&["{ ┃camelCase: { z } }"], &["{ x┃camelCase: { z } }"], "x")?; + assert_insert_seq( + &["{ ┃camelCase: { z } }"], + &["{ x┃camelCase: { z: RunTimeError } }"], + "x", + )?; - assert_insert_seq(&["{ a: { zulu┃ } }"], &["{ a: { zulu: \"┃\" } }"], ":\"")?; + assert_insert_seq( + &["{ a: { zulu┃ } }"], + &["{ a: { zulu┃: RunTimeError } }"], + ":\"", + )?; assert_insert_seq( &["{ abc: { camelCase┃ } }"], - &["{ abc: { camelCase: \"┃\" } }"], + &["{ abc: { camelCase┃: RunTimeError } }"], ":\"", )?; assert_insert_seq( &["{ camelCase: { z┃ } }"], - &["{ camelCase: { z: \"┃\" } }"], + &["{ camelCase: { z┃: RunTimeError } }"], ":\"", )?; @@ -1147,15 +1163,19 @@ pub mod test_ed_update { "ul", )?; - assert_insert_seq(&["{ a: { zulu┃ } }"], &["{ a: { zulu: 1┃ } }"], ":1")?; + assert_insert_seq( + &["{ a: { zulu┃ } }"], + &["{ a: { zulu1┃: RunTimeError } }"], + ":1", + )?; assert_insert_seq( &["{ abc: { camelCase┃ } }"], - &["{ abc: { camelCase: 0┃ } }"], + &["{ abc: { camelCase0┃: RunTimeError } }"], ":0", )?; assert_insert_seq( &["{ camelCase: { z┃ } }"], - &["{ camelCase: { z: 45┃ } }"], + &["{ camelCase: { z45┃: RunTimeError } }"], ":45", )?; @@ -1166,15 +1186,19 @@ pub mod test_ed_update { "77", )?; - assert_insert_seq(&["{ a: { zulu┃ } }"], &["{ a: { zulu: { ┃ } } }"], ":{")?; + assert_insert_seq( + &["{ a: { zulu┃ } }"], + &["{ a: { zulu┃: RunTimeError } }"], + ":{", + )?; assert_insert_seq( &["{ abc: { camelCase┃ } }"], - &["{ abc: { camelCase: { ┃ } } }"], + &["{ abc: { camelCase┃: RunTimeError } }"], ":{", )?; assert_insert_seq( &["{ camelCase: { z┃ } }"], - &["{ camelCase: { z: { ┃ } } }"], + &["{ camelCase: { z┃: RunTimeError } }"], ":{", )?; @@ -1201,17 +1225,17 @@ pub mod test_ed_update { assert_insert_seq( &["{ a┃: { bcD: { eFgHij: { k15 } } } }"], - &["{ a4┃: { bcD: { eFgHij: { k15 } } } }"], + &["{ a4┃: { bcD: { eFgHij: { k15: RunTimeError } } } }"], "4", )?; assert_insert_seq( &["{ ┃a: { bcD: { eFgHij: { k15 } } } }"], - &["{ y┃a: { bcD: { eFgHij: { k15 } } } }"], + &["{ y┃a: { bcD: { eFgHij: { k15: RunTimeError } } } }"], "y", )?; assert_insert_seq( &["{ a: { bcD: { eF┃gHij: { k15 } } } }"], - &["{ a: { bcD: { eFxyz┃gHij: { k15 } } } }"], + &["{ a: { bcD: { eFxyz┃gHij: { k15: RunTimeError } } } }"], "xyz", )?; @@ -1236,23 +1260,23 @@ pub mod test_ed_update { assert_insert_seq_ignore(&["{ ┃}"], IGNORE_CHARS)?; assert_insert_seq_ignore(&["{ ┃ }"], IGNORE_NO_LTR)?; - assert_insert_seq_ignore(&["{ ┃a }"], IGNORE_NO_LTR)?; - assert_insert_seq_ignore(&["{ ┃abc }"], IGNORE_NO_LTR)?; + assert_insert_seq_ignore(&["{ ┃a: RunTimeError }"], IGNORE_NO_LTR)?; + assert_insert_seq_ignore(&["{ ┃abc: RunTimeError }"], IGNORE_NO_LTR)?; - assert_insert_seq_ignore(&["┃{ a }"], IGNORE_CHARS)?; - assert_insert_seq_ignore(&["{ a }┃"], IGNORE_CHARS)?; - assert_insert_seq_ignore(&["{┃ a }"], IGNORE_CHARS)?; - assert_insert_seq_ignore(&["{ a ┃}"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["┃{ a: RunTimeError }"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["{ a: ┃RunTimeError }"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["{┃ a: RunTimeError }"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["{ a:┃ RunTimeError }"], IGNORE_CHARS)?; - assert_insert_seq_ignore(&["┃{ a15 }"], IGNORE_CHARS)?; - assert_insert_seq_ignore(&["{ a15 }┃"], IGNORE_CHARS)?; - assert_insert_seq_ignore(&["{┃ a15 }"], IGNORE_CHARS)?; - assert_insert_seq_ignore(&["{ a15 ┃}"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["┃{ a15: RunTimeError }"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["{ a15: ┃RunTimeError }"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["{┃ a15: RunTimeError }"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["{ a15:┃ RunTimeError }"], IGNORE_CHARS)?; - assert_insert_seq_ignore(&["┃{ camelCase }"], IGNORE_CHARS)?; - assert_insert_seq_ignore(&["{ camelCase }┃"], IGNORE_CHARS)?; - assert_insert_seq_ignore(&["{┃ camelCase }"], IGNORE_CHARS)?; - assert_insert_seq_ignore(&["{ camelCase ┃}"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["┃{ camelCase: RunTimeError }"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["{ camelCase: ┃RunTimeError }"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["{┃ camelCase: RunTimeError }"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["{ camelCase:┃ RunTimeError }"], IGNORE_CHARS)?; assert_insert_seq_ignore(&["┃{ a: \"\" }"], IGNORE_CHARS)?; assert_insert_seq_ignore(&["{┃ a: \"\" }"], IGNORE_CHARS)?; @@ -1328,17 +1352,17 @@ pub mod test_ed_update { assert_insert_seq_ignore(&["┃{ a: { } }"], IGNORE_NO_LTR)?; assert_insert_seq_ignore(&["{ ┃a: { } }"], "1")?; - assert_insert_seq_ignore(&["{ camelCaseB1: { z15a ┃} }"], IGNORE_NO_LTR)?; - assert_insert_seq_ignore(&["{ camelCaseB1: {┃ z15a } }"], IGNORE_NO_LTR)?; - assert_insert_seq_ignore(&["{ camelCaseB1: ┃{ z15a } }"], IGNORE_NO_LTR)?; - assert_insert_seq_ignore(&["{ camelCaseB1: { z15a }┃ }"], IGNORE_NO_LTR)?; - assert_insert_seq_ignore(&["{ camelCaseB1: { z15a } ┃}"], IGNORE_NO_LTR)?; - assert_insert_seq_ignore(&["{ camelCaseB1: { z15a } }┃"], IGNORE_NO_LTR)?; - assert_insert_seq_ignore(&["{ camelCaseB1:┃ { z15a } }"], IGNORE_NO_LTR)?; - assert_insert_seq_ignore(&["{┃ camelCaseB1: { z15a } }"], IGNORE_NO_LTR)?; - assert_insert_seq_ignore(&["┃{ camelCaseB1: { z15a } }"], IGNORE_NO_LTR)?; - assert_insert_seq_ignore(&["{ ┃camelCaseB1: { z15a } }"], "1")?; - assert_insert_seq_ignore(&["{ camelCaseB1: { ┃z15a } }"], "1")?; + assert_insert_seq_ignore(&["{ camelCaseB1: { z15a:┃ RunTimeError } }"], IGNORE_NO_LTR)?; + assert_insert_seq_ignore(&["{ camelCaseB1: {┃ z15a: RunTimeError } }"], IGNORE_NO_LTR)?; + assert_insert_seq_ignore(&["{ camelCaseB1: ┃{ z15a: RunTimeError } }"], IGNORE_NO_LTR)?; + assert_insert_seq_ignore(&["{ camelCaseB1: { z15a: ┃RunTimeError } }"], IGNORE_NO_LTR)?; + assert_insert_seq_ignore(&["{ camelCaseB1: { z15a: R┃unTimeError } }"], IGNORE_NO_LTR)?; + assert_insert_seq_ignore(&["{ camelCaseB1: { z15a: Ru┃nTimeError } }"], IGNORE_NO_LTR)?; + assert_insert_seq_ignore(&["{ camelCaseB1:┃ { z15a: RunTimeError } }"], IGNORE_NO_LTR)?; + assert_insert_seq_ignore(&["{┃ camelCaseB1: { z15a: RunTimeError } }"], IGNORE_NO_LTR)?; + assert_insert_seq_ignore(&["┃{ camelCaseB1: { z15a: RunTimeError } }"], IGNORE_NO_LTR)?; + assert_insert_seq_ignore(&["{ ┃camelCaseB1: { z15a: RunTimeError } }"], "1")?; + assert_insert_seq_ignore(&["{ camelCaseB1: { ┃z15a: RunTimeError } }"], "1")?; assert_insert_seq_ignore(&["{ camelCaseB1: { z15a: \"\"┃ } }"], IGNORE_NO_LTR)?; assert_insert_seq_ignore(&["{ camelCaseB1: { z15a: ┃\"\" } }"], IGNORE_NO_LTR)?; @@ -1428,39 +1452,39 @@ pub mod test_ed_update { )?; assert_insert_seq_ignore( - &["{ g: { oi: { ng: { d: { e: { e: { p: { camelCase ┃} } } } } } } }"], + &["{ g: { oi: { ng: { d: { e: { e: { p: { camelCase:┃ RunTimeError } } } } } } } }"], IGNORE_NO_LTR, )?; assert_insert_seq_ignore( - &["{ g: { oi: { ng: { d: { e: { e: { p: { camelCase } ┃} } } } } } }"], + &["{ g: { oi: { ng: { d: { e: { e: { p: { camelCase: R┃unTimeError } } } } } } } }"], IGNORE_NO_LTR, )?; assert_insert_seq_ignore( - &["{ g: { oi: { ng: { d: { e: { e: { p: { camelCase } } } } } } } }┃"], + &["{ g: { oi: { ng: { d: { e: { e: { p: { camelCase: RunTimeError } } } } } } } }┃"], IGNORE_NO_LTR, )?; assert_insert_seq_ignore( - &["{ g: { oi: { ng: { d: { e: { e: { p: { camelCase } } } } } ┃} } }"], + &["{ g: { oi: { ng: { d: { e: { e: { p: { camelCase: RunTimeEr┃ror } } } } } } } }"], IGNORE_NO_LTR, )?; assert_insert_seq_ignore( - &["{ g: { oi: { ng: { d: { e: {┃ e: { p: { camelCase } } } } } } } }"], + &["{ g: { oi: { ng: { d: { e: {┃ e: { p: { camelCase: RunTimeError } } } } } } } }"], IGNORE_NO_LTR, )?; assert_insert_seq_ignore( - &["{ g: { oi: { ng: { d: { e: { e:┃ { p: { camelCase } } } } } } } }"], + &["{ g: { oi: { ng: { d: { e: { e:┃ { p: { camelCase: RunTimeError } } } } } } } }"], IGNORE_NO_LTR, )?; assert_insert_seq_ignore( - &["{┃ g: { oi: { ng: { d: { e: { e: { p: { camelCase } } } } } } } }"], + &["{┃ g: { oi: { ng: { d: { e: { e: { p: { camelCase: RunTimeError } } } } } } } }"], IGNORE_NO_LTR, )?; assert_insert_seq_ignore( - &["┃{ g: { oi: { ng: { d: { e: { e: { p: { camelCase } } } } } } } }"], + &["┃{ g: { oi: { ng: { d: { e: { e: { p: { camelCase: RunTimeError } } } } } } } }"], IGNORE_NO_LTR, )?; assert_insert_seq_ignore( - &["{ ┃g: { oi: { ng: { d: { e: { e: { p: { camelCase } } } } } } } }"], + &["{ ┃g: { oi: { ng: { d: { e: { e: { p: { camelCase: RunTimeError } } } } } } } }"], "2", )?; Ok(()) From 3bec3b9d0386b1a05366f4d65a8b3a45cf8a6787 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Tue, 29 Jun 2021 15:25:16 +0200 Subject: [PATCH 408/496] single element lists, nested lists --- compiler/module/src/symbol.rs | 4 - compiler/types/src/pretty_print.rs | 4 +- editor/src/editor/ed_error.rs | 22 +++- editor/src/editor/main.rs | 10 +- editor/src/editor/markup/nodes.rs | 4 +- editor/src/editor/mvc/ed_model.rs | 28 ++++- editor/src/editor/mvc/ed_update.rs | 148 ++++++++++++++++++++----- editor/src/editor/mvc/list_update.rs | 92 +++++++++++++-- editor/src/editor/mvc/mod.rs | 2 +- editor/src/editor/resources/strings.rs | 2 +- editor/src/lang/ast.rs | 12 +- editor/tests/solve_expr2.rs | 2 +- 12 files changed, 266 insertions(+), 64 deletions(-) diff --git a/compiler/module/src/symbol.rs b/compiler/module/src/symbol.rs index b482200b32..d107bdffe4 100644 --- a/compiler/module/src/symbol.rs +++ b/compiler/module/src/symbol.rs @@ -66,10 +66,6 @@ impl Symbol { } pub fn ident_string(self, interns: &Interns) -> &InlinableString { - - dbg!(&self.module_id()); - dbg!(interns); - println!("DONE"); let ident_ids = interns .all_ident_ids .get(&self.module_id()) diff --git a/compiler/types/src/pretty_print.rs b/compiler/types/src/pretty_print.rs index 98ab8c65b2..fe58c39848 100644 --- a/compiler/types/src/pretty_print.rs +++ b/compiler/types/src/pretty_print.rs @@ -355,9 +355,7 @@ fn write_content(env: &Env, content: Content, subs: &Subs, buf: &mut String, par fn write_flat_type(env: &Env, flat_type: FlatType, subs: &Subs, buf: &mut String, parens: Parens) { use crate::subs::FlatType::*; - - println!("REMOVE ME"); - + match flat_type { Apply(symbol, args) => write_apply(env, symbol, args, subs, buf, parens), EmptyRecord => buf.push_str(EMPTY_RECORD), diff --git a/editor/src/editor/ed_error.rs b/editor/src/editor/ed_error.rs index 0f80a0398a..a21cb2de86 100644 --- a/editor/src/editor/ed_error.rs +++ b/editor/src/editor/ed_error.rs @@ -111,6 +111,26 @@ pub enum EdError { backtrace: Backtrace, }, + #[snafu(display( + "UnexpectedASTNode: required a {} at this position, node was a {}.", + required_node_type, + encountered_node_type + ))] + UnexpectedASTNode { + required_node_type: String, + encountered_node_type: String, + backtrace: Backtrace, + }, + + #[snafu(display( + "UnexpectedEmptyPoolVec: expected PoolVec {} to have at least one element.", + descriptive_vec_name + ))] + UnexpectedEmptyPoolVec { + descriptive_vec_name: String, + backtrace: Backtrace, + }, + #[snafu(display( "OutOfBounds: index {} was out of bounds for {} with length {}.", index, @@ -127,7 +147,7 @@ pub enum EdError { #[snafu(display("ParseError: Failed to parse AST: SyntaxError: {}.", syntax_err))] ParseError { syntax_err: String }, - #[snafu(display("RecordWithoutFields: expected record to have at least one field because it is not an EmpyRecord."))] + #[snafu(display("RecordWithoutFields: expected record to have at least one field because it is not an EmptyRecord."))] RecordWithoutFields { backtrace: Backtrace }, #[snafu(display("StringParseError: {}", msg))] diff --git a/editor/src/editor/main.rs b/editor/src/editor/main.rs index 352adc5818..94cdf006e1 100644 --- a/editor/src/editor/main.rs +++ b/editor/src/editor/main.rs @@ -26,6 +26,7 @@ use bumpalo::collections::String as BumpString; use bumpalo::Bump; use cgmath::Vector2; use pipelines::RectResources; +use roc_module::symbol::Interns; use roc_module::symbol::{IdentIds, ModuleIds}; use roc_types::subs::VarStore; use std::{error::Error, io, path::Path}; @@ -140,13 +141,18 @@ fn run_event_loop(file_path_opt: Option<&Path>) -> Result<(), Box> { let mut module_ids = ModuleIds::default(); let mod_id = module_ids.get_or_insert(&"ModId123".into()); + let interns = Interns { + module_ids, + all_ident_ids: IdentIds::exposed_builtins(8), + }; + let env = Env::new( mod_id, &env_arena, &mut env_pool, &mut var_store, dep_idents, - &module_ids, + &interns.module_ids, exposed_ident_ids, ); @@ -172,7 +178,7 @@ fn run_event_loop(file_path_opt: Option<&Path>) -> Result<(), Box> { }; let ed_model_opt = { - let ed_model_res = ed_model::init_model(&code_str, file_path, env, &code_arena); + let ed_model_res = ed_model::init_model(&code_str, file_path, env, &interns, &code_arena); match ed_model_res { Ok(mut ed_model) => { diff --git a/editor/src/editor/markup/nodes.rs b/editor/src/editor/markup/nodes.rs index 84864225b2..8faf0cbf4b 100644 --- a/editor/src/editor/markup/nodes.rs +++ b/editor/src/editor/markup/nodes.rs @@ -211,7 +211,7 @@ pub fn expr2_to_markup<'a, 'b>( } Expr2::List { elems, .. } => { let mut children_ids = vec![new_markup_node( - "[ ".to_string(), + LEFT_SQUARE_BR.to_string(), expr2_node_id, HighlightStyle::Bracket, markup_node_pool, @@ -238,7 +238,7 @@ pub fn expr2_to_markup<'a, 'b>( } } children_ids.push(new_markup_node( - "] ".to_string(), + RIGHT_SQUARE_BR.to_string(), expr2_node_id, HighlightStyle::Bracket, markup_node_pool, diff --git a/editor/src/editor/mvc/ed_model.rs b/editor/src/editor/mvc/ed_model.rs index 64a264a7a9..3700163417 100644 --- a/editor/src/editor/mvc/ed_model.rs +++ b/editor/src/editor/mvc/ed_model.rs @@ -21,6 +21,7 @@ use crate::ui::ui_error::UIResult; use bumpalo::collections::String as BumpString; use bumpalo::Bump; use nonempty::NonEmpty; +use roc_module::symbol::Interns; use roc_region::all::Region; use std::path::Path; @@ -38,6 +39,7 @@ pub struct EdModel<'a> { pub has_focus: bool, pub caret_w_select_vec: NonEmpty<(CaretWSelect, Option)>, pub selected_expr_opt: Option, + pub interns: &'a Interns, // this should eventually come from LoadedModule, see #1442 pub show_debug_view: bool, // EdModel is dirty if it has changed since the previous render. pub dirty: bool, @@ -54,6 +56,7 @@ pub fn init_model<'a>( code_str: &'a BumpString, file_path: &'a Path, env: Env<'a>, + interns: &'a Interns, code_arena: &'a Bump, ) -> EdResult> { let mut module = EdModule::new(&code_str, env, code_arena)?; @@ -99,6 +102,7 @@ pub fn init_model<'a>( has_focus: true, caret_w_select_vec: NonEmpty::new((CaretWSelect::default(), None)), selected_expr_opt: None, + interns, show_debug_view: false, dirty: true, }) @@ -185,7 +189,7 @@ pub mod test_ed_model { use bumpalo::collections::String as BumpString; use bumpalo::Bump; use ed_model::EdModel; - use roc_module::symbol::{IdentIds, ModuleIds}; + use roc_module::symbol::{IdentIds, Interns, ModuleIds}; use roc_types::subs::VarStore; use std::path::Path; @@ -197,7 +201,10 @@ pub mod test_ed_model { let dep_idents = IdentIds::exposed_builtins(8); let exposed_ident_ids = IdentIds::default(); - let mod_id = ed_model_refs.module_ids.get_or_insert(&"ModId123".into()); + let mod_id = ed_model_refs + .interns + .module_ids + .get_or_insert(&"ModId123".into()); let env = Env::new( mod_id, @@ -205,11 +212,17 @@ pub mod test_ed_model { &mut ed_model_refs.env_pool, &mut ed_model_refs.var_store, dep_idents, - &ed_model_refs.module_ids, + &ed_model_refs.interns.module_ids, exposed_ident_ids, ); - ed_model::init_model(&code_str, file_path, env, &ed_model_refs.code_arena) + ed_model::init_model( + &code_str, + file_path, + env, + &ed_model_refs.interns, + &ed_model_refs.code_arena, + ) } pub struct EdModelRefs { @@ -217,7 +230,7 @@ pub mod test_ed_model { env_arena: Bump, env_pool: Pool, var_store: VarStore, - module_ids: ModuleIds, + interns: Interns, } pub fn init_model_refs() -> EdModelRefs { @@ -226,7 +239,10 @@ pub mod test_ed_model { env_arena: Bump::new(), env_pool: Pool::with_capacity(1024), var_store: VarStore::default(), - module_ids: ModuleIds::default(), + interns: Interns { + module_ids: ModuleIds::default(), + all_ident_ids: IdentIds::exposed_builtins(8), + }, } } diff --git a/editor/src/editor/mvc/ed_update.rs b/editor/src/editor/mvc/ed_update.rs index 7199035865..e0ad11da87 100644 --- a/editor/src/editor/mvc/ed_update.rs +++ b/editor/src/editor/mvc/ed_update.rs @@ -13,6 +13,7 @@ use crate::editor::mvc::ed_model::EdModel; use crate::editor::mvc::ed_model::SelectedExpression; use crate::editor::mvc::int_update::start_new_int; use crate::editor::mvc::int_update::update_int; +use crate::editor::mvc::list_update::{prep_empty_list, start_new_list}; use crate::editor::mvc::lookup_update::update_invalid_lookup; use crate::editor::mvc::record_update::start_new_record; use crate::editor::mvc::record_update::update_empty_record; @@ -21,7 +22,6 @@ use crate::editor::mvc::record_update::update_record_field; use crate::editor::mvc::string_update::start_new_string; use crate::editor::mvc::string_update::update_small_string; use crate::editor::mvc::string_update::update_string; -use crate::editor::mvc::list_update::start_new_list; use crate::editor::slow_pool::MarkNodeId; use crate::editor::slow_pool::SlowPool; use crate::editor::syntax_highlight::HighlightStyle; @@ -45,7 +45,7 @@ use bumpalo::Bump; use roc_can::expected::Expected; use roc_collections::all::MutMap; use roc_module::ident::Lowercase; -use roc_module::symbol::{Interns, Symbol}; +use roc_module::symbol::Symbol; use roc_region::all::Region; use roc_types::solved_types::Solved; use roc_types::subs::{Subs, Variable}; @@ -265,13 +265,8 @@ impl<'a> EdModel<'a> { let content = subs.get(var).content; - let interns = Interns { - module_ids: *self.module.env.module_ids, - all_ident_ids: self.module.env.dep_idents, - }; - PoolStr::new( - &content_to_string(content, &subs, self.module.env.home, &interns), + &content_to_string(content, &subs, self.module.env.home, self.interns), self.module.env.pool, ) } @@ -596,6 +591,9 @@ pub fn handle_new_char(received_char: &char, ed_model: &mut EdModel) -> EdResult } else if let Some(prev_mark_node_id) = prev_mark_node_id_opt{ if prev_mark_node_id == curr_mark_node_id { match ast_node_ref { + Expr2::SmallInt{ .. } => { + update_int(ed_model, curr_mark_node_id, ch)? + } Expr2::SmallStr(old_arr_str) => { update_small_string( &ch, old_arr_str, ed_model @@ -632,9 +630,6 @@ pub fn handle_new_char(received_char: &char, ed_model: &mut EdModel) -> EdResult InputOutcome::Ignored } } - Expr2::SmallInt{ .. } => { - update_int(ed_model, curr_mark_node_id, ch)? - } _ => InputOutcome::Ignored } } else if ch.is_ascii_alphanumeric() { // prev_mark_node_id != curr_mark_node_id @@ -653,6 +648,9 @@ pub fn handle_new_char(received_char: &char, ed_model: &mut EdModel) -> EdResult let prev_node_ref = ed_model.module.env.pool.get(prev_ast_node_id); match prev_node_ref { + Expr2::SmallInt{ .. } => { + update_int(ed_model, prev_mark_node_id, ch)? + } Expr2::InvalidLookup(old_pool_str) => { update_invalid_lookup( &ch.to_string(), @@ -686,8 +684,19 @@ pub fn handle_new_char(received_char: &char, ed_model: &mut EdModel) -> EdResult InputOutcome::Ignored } } - Expr2::SmallInt{ .. } => { - update_int(ed_model, prev_mark_node_id, ch)? + Expr2::List{ elem_var: _, elems: _} => { + let prev_mark_node = ed_model.markup_node_pool.get(prev_mark_node_id); + + if prev_mark_node.get_content()? == nodes::LEFT_SQUARE_BR { + if curr_mark_node.get_content()? == nodes::RIGHT_SQUARE_BR { + prep_empty_list(ed_model)?; // insert a Blank first, this results in cleaner code + handle_new_char(received_char, ed_model)? + } else { + InputOutcome::Ignored + } + } else { + InputOutcome::Ignored + } } _ => { match ast_node_ref { @@ -717,6 +726,19 @@ pub fn handle_new_char(received_char: &char, ed_model: &mut EdModel) -> EdResult } else { InputOutcome::Ignored } + } else if "\"{[".contains(*ch) { + let prev_mark_node = ed_model.markup_node_pool.get(prev_mark_node_id); + + if prev_mark_node.get_content()? == nodes::LEFT_SQUARE_BR { + if curr_mark_node.get_content()? == nodes::RIGHT_SQUARE_BR { + prep_empty_list(ed_model)?; // insert a Blank first, this results in cleaner code + handle_new_char(received_char, ed_model)? + } else { + InputOutcome::Ignored + } + } else { + InputOutcome::Ignored + } } else { InputOutcome::Ignored } @@ -1476,6 +1498,90 @@ pub mod test_ed_update { Ok(()) } + #[test] + fn test_list() -> Result<(), String> { + assert_insert(&["┃"], &["[ ┃ ]"], '[')?; + + assert_insert_seq(&["┃"], &["[ 0┃ ]"], "[0")?; + assert_insert_seq(&["┃"], &["[ 1┃ ]"], "[1")?; + assert_insert_seq(&["┃"], &["[ 9┃ ]"], "[9")?; + + assert_insert_seq(&["┃"], &["[ \"┃\" ]"], "[\"")?; + assert_insert_seq( + &["┃"], + &["[ \"hello, hello.0123456789ZXY{}[]-><-┃\" ]"], + "[\"hello, hello.0123456789ZXY{}[]-><-", + )?; + + assert_insert_seq(&["┃"], &["[ { ┃ } ]"], "[{")?; + assert_insert_seq(&["┃"], &["[ { a┃ } ]"], "[{a")?; + assert_insert_seq( + &["┃"], + &["[ { camelCase: { zulu: \"nested┃\" } } ]"], + "[{camelCase:{zulu:\"nested", + )?; + + assert_insert_seq(&["┃"], &["[ [ ┃ ] ]"], "[[")?; + assert_insert_seq(&["┃"], &["[ [ [ ┃ ] ] ]"], "[[[")?; + assert_insert_seq(&["┃"], &["[ [ 0┃ ] ]"], "[[0")?; + assert_insert_seq(&["┃"], &["[ [ \"abc┃\" ] ]"], "[[\"abc")?; + assert_insert_seq( + &["┃"], + &["[ [ { camelCase: { a: 79000┃ } } ] ]"], + "[[{camelCase:{a:79000", + )?; + + Ok(()) + } + + #[test] + fn test_ignore_list() -> Result<(), String> { + assert_insert_seq_ignore(&["┃[ ]"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["[ ]┃"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["[┃ ]"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["[ ┃]"], IGNORE_CHARS)?; + + assert_insert_seq_ignore(&["┃[ 0 ]"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["[ 0 ]┃"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["[┃ 0 ]"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["[ 0 ┃]"], IGNORE_CHARS)?; + + assert_insert_seq_ignore(&["┃[ 137 ]"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["[ 137 ]┃"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["[┃ 137 ]"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["[ 137 ┃]"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["[ ┃137 ]"], IGNORE_NO_NUM)?; + assert_insert_seq_ignore(&["[ 137┃ ]"], IGNORE_NO_NUM)?; + + assert_insert_seq_ignore(&["┃[ \"teststring\" ]"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["[ \"teststring\" ]┃"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["[┃ \"teststring\" ]"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["[ \"teststring\" ┃]"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["[ ┃\"teststring\" ]"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["[ \"teststring\"┃ ]"], IGNORE_CHARS)?; + + assert_insert_seq_ignore(&["┃[ { a: 1 } ]"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["[ { a: 1 } ]┃"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["[┃ { a: 1 } ]"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["[ { a: 1 } ┃]"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["[ ┃{ a: 1 } ]"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["[ {┃ a: 1 } ]"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["[ { a:┃ 1 } ]"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["[ { a: 1 ┃} ]"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["[ { a: 1 }┃ ]"], IGNORE_CHARS)?; + + assert_insert_seq_ignore(&["┃[ [ ] ]"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["[ [ ] ]┃"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["[┃ [ ] ]"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["[ [ ] ┃]"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["[ ┃[ ] ]"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["[ [ ]┃ ]"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["[ [┃ ] ]"], IGNORE_CHARS)?; + assert_insert_seq_ignore(&["[ [ ┃] ]"], IGNORE_CHARS)?; + + Ok(()) + } + // Create ed_model from pre_lines DSL, do ctrl+shift+up as many times as repeat. // check if modified ed_model has expected string representation of code, caret position and active selection. pub fn assert_ctrl_shift_up_repeat( @@ -1734,20 +1840,6 @@ pub mod test_ed_update { Ok(()) } - #[test] - fn test_ctrl_shift_up_list() -> Result<(), String> { - assert_ctrl_shift_up(&["[ ┃ ]"], &["┃❮[ ]❯"])?; - assert_ctrl_shift_up(&["[┃ ]"], &["┃❮[ ]❯"])?; - assert_ctrl_shift_up(&["[ ┃]"], &["┃❮[ ]❯"])?; - assert_ctrl_shift_up(&["┃[ ]"], &["┃❮[ ]❯"])?; - assert_ctrl_shift_up(&["[ ]┃"], &["┃❮[ ]❯"])?; - - assert_ctrl_shift_up_repeat(&["[ ┃ ]"], &["┃❮[ ]❯"], 4)?; - - //TODO non-empty list - Ok(()) - } - // Create ed_model from pre_lines DSL, do handle_new_char() with new_char_seq, select current Expr2, // check if generated tooltips match expected_tooltips. pub fn assert_type_tooltips_seq( @@ -1837,6 +1929,8 @@ pub mod test_ed_update { ], )?; + assert_type_tooltip(&["┃"], "List *", '[')?; + Ok(()) } diff --git a/editor/src/editor/mvc/list_update.rs b/editor/src/editor/mvc/list_update.rs index e674fe59ed..8533967209 100644 --- a/editor/src/editor/mvc/list_update.rs +++ b/editor/src/editor/mvc/list_update.rs @@ -1,5 +1,5 @@ - use crate::editor::ed_error::EdResult; +use crate::editor::ed_error::{MissingParent, UnexpectedASTNode, UnexpectedEmptyPoolVec}; use crate::editor::markup::attribute::Attributes; use crate::editor::markup::nodes; use crate::editor::markup::nodes::MarkupNode; @@ -8,8 +8,10 @@ use crate::editor::mvc::ed_model::EdModel; use crate::editor::mvc::ed_update::get_node_context; use crate::editor::mvc::ed_update::NodeContext; use crate::editor::syntax_highlight::HighlightStyle; +use crate::lang::ast::expr2_to_string; use crate::lang::ast::Expr2; -use crate::lang::pool::{PoolVec}; +use crate::lang::pool::PoolVec; +use snafu::OptionExt; pub fn start_new_list(ed_model: &mut EdModel) -> EdResult { let NodeContext { @@ -22,11 +24,10 @@ pub fn start_new_list(ed_model: &mut EdModel) -> EdResult { let is_blank_node = curr_mark_node.is_blank(); - let expr2_node = - Expr2::List{ - elem_var: ed_model.module.env.var_store.fresh(), - elems: PoolVec::empty(ed_model.module.env.pool) - }; + let expr2_node = Expr2::List { + elem_var: ed_model.module.env.var_store.fresh(), + elems: PoolVec::empty(ed_model.module.env.pool), + }; let mark_node_pool = &mut ed_model.markup_node_pool; @@ -85,4 +86,79 @@ pub fn start_new_list(ed_model: &mut EdModel) -> EdResult { } else { Ok(InputOutcome::Ignored) } -} \ No newline at end of file +} + +// insert Blank at current position for easy code reuse +pub fn prep_empty_list(ed_model: &mut EdModel) -> EdResult { + let NodeContext { + old_caret_pos, + curr_mark_node_id, + curr_mark_node: _, + parent_id_opt, + ast_node_id, + } = get_node_context(&ed_model)?; + + let blank_elt = Expr2::Blank; + + let list_ast_node = ed_model.module.env.pool.get(ast_node_id); + + match list_ast_node { + Expr2::List { elem_var, elems: _ } => { + let children: Vec = vec![blank_elt]; + let children_pool_vec = PoolVec::new(children.into_iter(), ed_model.module.env.pool); + + let blank_elt_id = + children_pool_vec + .iter_node_ids() + .next() + .context(UnexpectedEmptyPoolVec { + descriptive_vec_name: "\"children of List AST node\"", + })?; + + let new_list_node = Expr2::List { + elem_var: *elem_var, + elems: children_pool_vec, + }; + + ed_model.module.env.pool.set(ast_node_id, new_list_node); + + let blank_mark_node = MarkupNode::Blank { + ast_node_id: blank_elt_id, + syn_high_style: HighlightStyle::Blank, + attributes: Attributes::new(), + parent_id_opt, + }; + + let blank_mark_node_id = ed_model.markup_node_pool.add(blank_mark_node); + + // add blank mark node to nested mark node from list + if let Some(parent_id) = parent_id_opt { + let parent = ed_model.markup_node_pool.get_mut(parent_id); + + let new_child_index = 1; // 1 because left bracket is first element + + parent.add_child_at_index(new_child_index, blank_mark_node_id)?; + } else { + MissingParent { + node_id: curr_mark_node_id, + } + .fail()? + } + + // update GridNodeMap and CodeLines + ed_model.insert_between_line( + old_caret_pos.line, + old_caret_pos.column, + nodes::BLANK_PLACEHOLDER, + blank_mark_node_id, + )?; + + Ok(InputOutcome::Accepted) + } + _ => UnexpectedASTNode { + required_node_type: "List".to_string(), + encountered_node_type: expr2_to_string(ast_node_id, ed_model.module.env.pool), + } + .fail()?, + } +} diff --git a/editor/src/editor/mvc/mod.rs b/editor/src/editor/mvc/mod.rs index 64ee02304f..4088a4a1ad 100644 --- a/editor/src/editor/mvc/mod.rs +++ b/editor/src/editor/mvc/mod.rs @@ -4,7 +4,7 @@ pub mod ed_model; pub mod ed_update; pub mod ed_view; mod int_update; +mod list_update; mod lookup_update; mod record_update; -mod list_update; mod string_update; diff --git a/editor/src/editor/resources/strings.rs b/editor/src/editor/resources/strings.rs index d4731e8174..366e34f813 100644 --- a/editor/src/editor/resources/strings.rs +++ b/editor/src/editor/resources/strings.rs @@ -1,3 +1,3 @@ pub const NOTHING_OPENED: &str = "Execute `cargo run edit ` to open a file."; pub const START_TIP: &str = - "Start by typing '{', '\"' or a number.\nInput chars that would create parse errors will be ignored."; + "Start by typing '[', '{', '\"' or a number.\nInput chars that would create parse errors will be ignored."; diff --git a/editor/src/lang/ast.rs b/editor/src/lang/ast.rs index d61669e39a..4b95b1dc62 100644 --- a/editor/src/lang/ast.rs +++ b/editor/src/lang/ast.rs @@ -431,7 +431,7 @@ fn expr2_to_string_helper( out_string.push_str(&format!("{}]\n", get_spacing(indent_level + 1))); } - Expr2::List { elem_var, elems} => { + Expr2::List { elem_var, elems } => { out_string.push_str("List:\n"); out_string.push_str(&var_to_string(elem_var, indent_level + 1)); out_string.push_str(&format!("{}elems: [\n", get_spacing(indent_level + 1))); @@ -445,7 +445,7 @@ fn expr2_to_string_helper( first_elt = false; } - expr2_to_string_helper(elem_expr2, indent_level + 1, pool, out_string) + expr2_to_string_helper(elem_expr2, indent_level + 2, pool, out_string) } out_string.push_str(&format!("{}]\n", get_spacing(indent_level + 1))); @@ -462,12 +462,8 @@ fn expr2_to_string_helper( out_string.push('\n'); } -fn var_to_string( some_var: &Variable, indent_level: usize) -> String { - format!( - "{}Var({:?})\n", - get_spacing(indent_level + 1), - some_var - ) +fn var_to_string(some_var: &Variable, indent_level: usize) -> String { + format!("{}Var({:?})\n", get_spacing(indent_level + 1), some_var) } #[test] diff --git a/editor/tests/solve_expr2.rs b/editor/tests/solve_expr2.rs index 91a2964fc9..bfe7d97866 100644 --- a/editor/tests/solve_expr2.rs +++ b/editor/tests/solve_expr2.rs @@ -120,7 +120,7 @@ fn infer_eq(actual: &str, expected_str: &str) { module_ids, all_ident_ids: dep_idents, }; - + let actual_str = content_to_string(content, &subs, mod_id, &interns); assert_eq!(actual_str, expected_str); From bf69daa3bc7662638cadfbca6599a7f30d42aa72 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Tue, 29 Jun 2021 16:11:20 +0200 Subject: [PATCH 409/496] more type tooltip tests --- compiler/mono/src/alias_analysis.rs | 4 ++-- compiler/types/src/pretty_print.rs | 2 +- editor/src/editor/mvc/ed_update.rs | 7 ++++++- 3 files changed, 9 insertions(+), 4 deletions(-) diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index ebd467954d..2b4354d26e 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -166,9 +166,9 @@ where p.build()? }; - /*if DEBUG { + if DEBUG { eprintln!("{}", program.to_source_string()); - }*/ + } morphic_lib::solve(program) } diff --git a/compiler/types/src/pretty_print.rs b/compiler/types/src/pretty_print.rs index fe58c39848..8df08669d1 100644 --- a/compiler/types/src/pretty_print.rs +++ b/compiler/types/src/pretty_print.rs @@ -355,7 +355,7 @@ fn write_content(env: &Env, content: Content, subs: &Subs, buf: &mut String, par fn write_flat_type(env: &Env, flat_type: FlatType, subs: &Subs, buf: &mut String, parens: Parens) { use crate::subs::FlatType::*; - + match flat_type { Apply(symbol, args) => write_apply(env, symbol, args, subs, buf, parens), EmptyRecord => buf.push_str(EMPTY_RECORD), diff --git a/editor/src/editor/mvc/ed_update.rs b/editor/src/editor/mvc/ed_update.rs index e0ad11da87..9e19802dd8 100644 --- a/editor/src/editor/mvc/ed_update.rs +++ b/editor/src/editor/mvc/ed_update.rs @@ -1930,7 +1930,12 @@ pub mod test_ed_update { )?; assert_type_tooltip(&["┃"], "List *", '[')?; - + assert_type_tooltips_seq(&["┃"], &vec!["List (Num *)"], "[0")?; + assert_type_tooltips_seq(&["┃"], &vec!["List (Num *)", "List (List (Num *))"], "[[0")?; + assert_type_tooltips_seq(&["┃"], &vec!["Str", "List Str"], "[\"a")?; + assert_type_tooltips_seq(&["┃"], &vec!["Str", "List Str", "List (List Str)", "List (List (List Str))"], "[[[\"a")?; + assert_type_tooltips_seq(&["┃"], &vec!["{ a : Num * }", "List { a : Num * }", "List (List { a : Num * })"], "[[{a:1")?; + Ok(()) } From df4008438e5c9fe314f3a2b16af30356b53d1974 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Tue, 29 Jun 2021 16:14:35 +0200 Subject: [PATCH 410/496] fmt --- editor/src/editor/mvc/ed_update.rs | 23 ++++++++++++++++++++--- 1 file changed, 20 insertions(+), 3 deletions(-) diff --git a/editor/src/editor/mvc/ed_update.rs b/editor/src/editor/mvc/ed_update.rs index 9e19802dd8..859f01cece 100644 --- a/editor/src/editor/mvc/ed_update.rs +++ b/editor/src/editor/mvc/ed_update.rs @@ -1933,9 +1933,26 @@ pub mod test_ed_update { assert_type_tooltips_seq(&["┃"], &vec!["List (Num *)"], "[0")?; assert_type_tooltips_seq(&["┃"], &vec!["List (Num *)", "List (List (Num *))"], "[[0")?; assert_type_tooltips_seq(&["┃"], &vec!["Str", "List Str"], "[\"a")?; - assert_type_tooltips_seq(&["┃"], &vec!["Str", "List Str", "List (List Str)", "List (List (List Str))"], "[[[\"a")?; - assert_type_tooltips_seq(&["┃"], &vec!["{ a : Num * }", "List { a : Num * }", "List (List { a : Num * })"], "[[{a:1")?; - + assert_type_tooltips_seq( + &["┃"], + &vec![ + "Str", + "List Str", + "List (List Str)", + "List (List (List Str))", + ], + "[[[\"a", + )?; + assert_type_tooltips_seq( + &["┃"], + &vec![ + "{ a : Num * }", + "List { a : Num * }", + "List (List { a : Num * })", + ], + "[[{a:1", + )?; + Ok(()) } From 166c8ac2176ef0901600e45705c7f89f92c24008 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Tue, 29 Jun 2021 16:57:00 +0200 Subject: [PATCH 411/496] undo list space change --- editor/tests/solve_expr2.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/editor/tests/solve_expr2.rs b/editor/tests/solve_expr2.rs index bfe7d97866..9e9d593e5d 100644 --- a/editor/tests/solve_expr2.rs +++ b/editor/tests/solve_expr2.rs @@ -208,7 +208,7 @@ fn constrain_empty_list() { infer_eq( indoc!( r#" - [ ] + [] "# ), "List *", From 6223892c6b261ed927cbfdcb7590db69bb598865 Mon Sep 17 00:00:00 2001 From: Folkert Date: Tue, 29 Jun 2021 22:30:36 +0200 Subject: [PATCH 412/496] include the tag id in the hash! --- compiler/builtins/bitcode/src/hash.zig | 5 +- compiler/gen_llvm/src/llvm/build_hash.rs | 89 ++++++++++++++++++++---- compiler/test_gen/src/gen_hash.rs | 82 ++++++++++++++++++++-- 3 files changed, 156 insertions(+), 20 deletions(-) diff --git a/compiler/builtins/bitcode/src/hash.zig b/compiler/builtins/bitcode/src/hash.zig index 1ceedadd82..10687a3231 100644 --- a/compiler/builtins/bitcode/src/hash.zig +++ b/compiler/builtins/bitcode/src/hash.zig @@ -8,10 +8,9 @@ const str = @import("str.zig"); const mem = std.mem; pub fn wyhash(seed: u64, bytes: ?[*]const u8, length: usize) callconv(.C) u64 { - const stdout = std.io.getStdOut().writer(); - if (bytes) |nonnull| { - return wyhash_hash(seed, nonnull[0..length]); + const slice = nonnull[0..length]; + return wyhash_hash(seed, slice); } else { return 42; } diff --git a/compiler/gen_llvm/src/llvm/build_hash.rs b/compiler/gen_llvm/src/llvm/build_hash.rs index 8195b864c5..61a74dd232 100644 --- a/compiler/gen_llvm/src/llvm/build_hash.rs +++ b/compiler/gen_llvm/src/llvm/build_hash.rs @@ -401,7 +401,8 @@ fn hash_tag<'a, 'ctx, 'env>( let merge_block = env.context.append_basic_block(parent, "merge_block"); env.builder.position_at_end(merge_block); - let tag_id_basic_type = basic_type_from_layout(env, &union_layout.tag_id_layout()); + let tag_id_layout = union_layout.tag_id_layout(); + let tag_id_basic_type = basic_type_from_layout(env, &tag_id_layout); let merge_phi = env.builder.build_phi(seed.get_type(), "merge_hash"); @@ -424,6 +425,24 @@ fn hash_tag<'a, 'ctx, 'env>( let as_struct = cast_block_of_memory_to_tag(env.builder, tag.into_struct_value(), wrapper_type); + // hash the tag id + let hash_bytes = store_and_use_as_u8_ptr( + env, + tag_id_basic_type + .into_int_type() + .const_int(tag_id as u64, false) + .into(), + &tag_id_layout, + ); + + let seed = hash_bitcode_fn( + env, + seed, + hash_bytes, + tag_id_layout.stack_size(env.ptr_bytes), + ); + + // hash the tag data let answer = build_hash_struct( env, layout_ids, @@ -457,6 +476,23 @@ fn hash_tag<'a, 'ctx, 'env>( let block = env.context.append_basic_block(parent, "tag_id_modify"); env.builder.position_at_end(block); + // hash the tag id + let hash_bytes = store_and_use_as_u8_ptr( + env, + tag_id_basic_type + .into_int_type() + .const_int(tag_id as u64, false) + .into(), + &tag_id_layout, + ); + let seed = hash_bitcode_fn( + env, + seed, + hash_bytes, + tag_id_layout.stack_size(env.ptr_bytes), + ); + + // hash the tag data let answer = hash_ptr_to_struct( env, layout_ids, @@ -511,7 +547,10 @@ fn hash_tag<'a, 'ctx, 'env>( env.builder.build_unconditional_branch(merge_block); } } - NullableWrapped { other_tags, .. } => { + NullableWrapped { + other_tags, + nullable_id, + } => { let tag = tag.into_pointer_value(); let is_null = env.builder.build_is_null(tag, "is_null"); @@ -534,12 +573,39 @@ fn hash_tag<'a, 'ctx, 'env>( { let mut cases = Vec::with_capacity_in(other_tags.len(), env.arena); - for (tag_id, field_layouts) in other_tags.iter().enumerate() { + for (mut tag_id, field_layouts) in other_tags.iter().enumerate() { + if tag_id >= *nullable_id as usize { + tag_id += 1; + } + let block = env.context.append_basic_block(parent, "tag_id_modify"); env.builder.position_at_end(block); - let answer = - hash_ptr_to_struct(env, layout_ids, union_layout, field_layouts, seed, tag); + // hash the tag id + let hash_bytes = store_and_use_as_u8_ptr( + env, + tag_id_basic_type + .into_int_type() + .const_int(tag_id as u64, false) + .into(), + &tag_id_layout, + ); + let seed1 = hash_bitcode_fn( + env, + seed, + hash_bytes, + tag_id_layout.stack_size(env.ptr_bytes), + ); + + // hash tag data + let answer = hash_ptr_to_struct( + env, + layout_ids, + union_layout, + field_layouts, + seed1, + tag, + ); merge_phi.add_incoming(&[(&answer, block)]); env.builder.build_unconditional_branch(merge_block); @@ -810,14 +876,13 @@ fn store_and_use_as_u8_ptr<'a, 'ctx, 'env>( let alloc = env.builder.build_alloca(basic_type, "store"); env.builder.build_store(alloc, value); + let u8_ptr = env + .context + .i8_type() + .ptr_type(inkwell::AddressSpace::Generic); + env.builder - .build_bitcast( - alloc, - env.context - .i8_type() - .ptr_type(inkwell::AddressSpace::Generic), - "as_u8_ptr", - ) + .build_bitcast(alloc, u8_ptr, "as_u8_ptr") .into_pointer_value() } diff --git a/compiler/test_gen/src/gen_hash.rs b/compiler/test_gen/src/gen_hash.rs index 3b41cca607..616b377f10 100644 --- a/compiler/test_gen/src/gen_hash.rs +++ b/compiler/test_gen/src/gen_hash.rs @@ -37,7 +37,7 @@ fn hash_record() { fn hash_result() { assert_evals_to!( "Dict.hashTestOnly 0 (List.get [ 0x1 ] 0) ", - 10806428154792634888, + 6707068610910845221, u64 ); } @@ -85,10 +85,13 @@ fn hash_expr() { x : Expr x = Val 1 - Dict.hashTestOnly 0 (Add x x) + add : Expr + add = Add x x + + Dict.hashTestOnly 0 add "# ), - 2878521786781103245, + 10825806964604997723, u64 ); } @@ -103,10 +106,13 @@ fn hash_nullable_expr() { x : Expr x = Val 1 - Dict.hashTestOnly 0 (Add x x) + add : Expr + add = Add x x + + Dict.hashTestOnly 0 add "# ), - 2878521786781103245, + 1907558799788307114, u64 ); } @@ -129,6 +135,72 @@ fn hash_rosetree() { ); } +#[test] +fn hash_union_same_content() { + assert_evals_to!( + indoc!( + r#" + Foo : [ A I64, B I64 ] + + a : Foo + a = A 42 + + b : Foo + b = B 42 + + { a: Dict.hashTestOnly 0 a, b : Dict.hashTestOnly 0 b } + "# + ), + true, + (i64, i64), + |(a, b)| a != b + ); +} + +#[test] +fn hash_recursive_union_same_content() { + assert_evals_to!( + indoc!( + r#" + Expr : [ Add Expr Expr, Mul Expr Expr, Val1 I64, Val2 I64 ] + + v1 : Expr + v1 = Val1 42 + + v2 : Expr + v2 = Val2 42 + + { a: Dict.hashTestOnly 0 v1, b : Dict.hashTestOnly 0 v2 } + "# + ), + true, + (i64, i64), + |(a, b)| a != b + ); +} + +#[test] +fn hash_nullable_recursive_union_same_content() { + assert_evals_to!( + indoc!( + r#" + Expr : [ Add Expr Expr, Mul Expr Expr, Val1 I64, Val2 I64, Empty ] + + v1 : Expr + v1 = Val1 42 + + v2 : Expr + v2 = Val2 42 + + { a: Dict.hashTestOnly 0 v1, b : Dict.hashTestOnly 0 v2 } + "# + ), + true, + (i64, i64), + |(a, b)| a != b + ); +} + #[test] fn hash_list() { assert_evals_to!( From eb478cdaac346bbbcf6672bf6e400bbd80a05756 Mon Sep 17 00:00:00 2001 From: Folkert Date: Tue, 29 Jun 2021 22:35:12 +0200 Subject: [PATCH 413/496] add eq tests for non-equal tags --- compiler/test_gen/src/gen_compare.rs | 63 ++++++++++++++++++++++++++++ 1 file changed, 63 insertions(+) diff --git a/compiler/test_gen/src/gen_compare.rs b/compiler/test_gen/src/gen_compare.rs index 99bd2649a6..ffe42bb52f 100644 --- a/compiler/test_gen/src/gen_compare.rs +++ b/compiler/test_gen/src/gen_compare.rs @@ -442,4 +442,67 @@ mod gen_compare { assert_evals_to!("[[1]] != [[1]]", false, bool); assert_evals_to!("[[2]] != [[1]]", true, bool); } + + #[test] + fn compare_union_same_content() { + assert_evals_to!( + indoc!( + r#" + Foo : [ A I64, B I64 ] + + a : Foo + a = A 42 + + b : Foo + b = B 42 + + a == b + "# + ), + false, + bool + ); + } + + #[test] + fn compare_recursive_union_same_content() { + assert_evals_to!( + indoc!( + r#" + Expr : [ Add Expr Expr, Mul Expr Expr, Val1 I64, Val2 I64 ] + + v1 : Expr + v1 = Val1 42 + + v2 : Expr + v2 = Val2 42 + + v1 == v2 + "# + ), + false, + bool + ); + } + + #[test] + fn compare_nullable_recursive_union_same_content() { + assert_evals_to!( + indoc!( + r#" + Expr : [ Add Expr Expr, Mul Expr Expr, Val1 I64, Val2 I64, Empty ] + + v1 : Expr + v1 = Val1 42 + + v2 : Expr + v2 = Val2 42 + + v1 == v2 + "# + ), + false, + bool + ); + } } From ece2a2b9d35731399974c9028087bfc24ce6fd1b Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Wed, 30 Jun 2021 10:30:37 +0200 Subject: [PATCH 414/496] better error message when trying to open file with editor --- editor/src/editor/main.rs | 2 ++ editor/src/editor/resources/strings.rs | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/editor/src/editor/main.rs b/editor/src/editor/main.rs index 94cdf006e1..ad8294a9a6 100644 --- a/editor/src/editor/main.rs +++ b/editor/src/editor/main.rs @@ -330,6 +330,8 @@ fn run_event_loop(file_path_opt: Option<&Path>) -> Result<(), Box> { ) } } else { + begin_render_pass(&mut encoder, &frame.view, &ed_theme); + queue_no_file_text( &size, NOTHING_OPENED, diff --git a/editor/src/editor/resources/strings.rs b/editor/src/editor/resources/strings.rs index 366e34f813..214dc55682 100644 --- a/editor/src/editor/resources/strings.rs +++ b/editor/src/editor/resources/strings.rs @@ -1,3 +1,3 @@ -pub const NOTHING_OPENED: &str = "Execute `cargo run edit ` to open a file."; +pub const NOTHING_OPENED: &str = "Opening files is not yet supported. Execute `cargo run edit` from the root folder of the repo to try the editor."; pub const START_TIP: &str = "Start by typing '[', '{', '\"' or a number.\nInput chars that would create parse errors will be ignored."; From d091c62f05fa9cf91cda83a5c3b2790bf5cc7a6a Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Thu, 1 Jul 2021 13:49:36 +0200 Subject: [PATCH 415/496] more editor ideas and inspiration --- editor/editor-ideas.md | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/editor/editor-ideas.md b/editor/editor-ideas.md index 51ab70dcc5..42593da5bb 100644 --- a/editor/editor-ideas.md +++ b/editor/editor-ideas.md @@ -137,12 +137,14 @@ e.g. you have a test `calculate_sum_test` that only uses the function `add`, whe - Machine Learning: * GPT-3 can generate correct python functions based on a comment describing the functionality, video [here](https://www.youtube.com/watch?v=utuz7wBGjKM). It's possible that training a model using ast's may lead to better results than text based models. - Current autocomplete lacks flow, moving through suggestions with arrows is slow. Being able to code by weaving together autocomplete suggestions laid out in rows using eye tracking, that could flow. +- It's possible that with strong static types, pure functions and a good search algorithm we can develop a more reliable autocomplete than one with machine learning. #### Productivity Inspiration * [Kite](https://www.kite.com/) AI autocomplete and doc viewer. * [Tabnine](https://www.tabnine.com/) AI autocomplete. * [Codota](https://www.codota.com) AI autocomplete and example searching. +* [Github copilot](https://copilot.github.com/) AI autocomplete. * [Aroma](https://ai.facebook.com/blog/aroma-ml-for-code-recommendation) showing examples similar to current code. * [MISM](https://arxiv.org/abs/2006.05265) neural network based code similarity scoring. * [Inquisitive code editor](https://web.eecs.utk.edu/~azh/blog/inquisitivecodeeditor.html) Interactive bug detection with doc+test generation. @@ -169,7 +171,7 @@ e.g. you have a test `calculate_sum_test` that only uses the function `add`, whe * See [codata](https://www.codota.com/code/java/classes/okhttp3.OkHttpClient) for inspiration on a snippet/example finder. * Fuzzy natural language based setting adjustment in search bar or with voice input: increase font size, enable autosave, switch to light theme... * Detect deviation of best practices, example case: alert developer when they are defining a color inline (rgb(30,30,30)) while all colors have been previously imported from a single file. See also [Codota](https://www.codota.com). -* It would be valuable to record the user's interactions with the editor when debugging as well as the AST. On enough data we could train a model to perform a bunch of debugging steps and show values of the most important variables in relation to the bug. Having assistance in finding the exact code that causes the problem could be super valuable. There could be sensitive data, so it should only be recorded and or shared for open source codebases with explicit user permission. +* It would be valuable to record the user's interactions with the editor when debugging as well as the AST. On enough data we could train a model to perform a bunch of debugging steps and show values of the most important variables in relation to the bug. Having assistance in finding the exact code that causes the problem could be super valuable. There could be sensitive data, so it should only be recorded and or shared for open source codebases with permissive licenses and with explicit user permission. ## Testing @@ -194,6 +196,7 @@ e.g. you have a test `calculate_sum_test` that only uses the function `add`, whe * Ability to see module as it would be presented on a package website. * Modern editors may guide developers to the source code too easily. The API and documentation are meant to interface with humans. +* [DocC](https://developer.apple.com/videos/play/wwdc2021/10166/) neat documentation approach for swift. ## General Thoughts/Ideas From fdb0aa9eb7e78ad548eebbb5cd24ae8473e5e14c Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Thu, 1 Jul 2021 19:08:39 +0200 Subject: [PATCH 416/496] multi element lists without updating ast nodes --- compiler/mono/src/alias_analysis.rs | 4 +- editor/src/editor/markup/nodes.rs | 13 ++- editor/src/editor/mvc/ed_update.rs | 27 ++++- editor/src/editor/mvc/list_update.rs | 167 +++++++++++++++++---------- editor/src/lang/ast.rs | 8 +- editor/src/lang/constrain.rs | 7 +- editor/src/lang/expr.rs | 11 +- 7 files changed, 163 insertions(+), 74 deletions(-) diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index 2b4354d26e..ebd467954d 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -166,9 +166,9 @@ where p.build()? }; - if DEBUG { + /*if DEBUG { eprintln!("{}", program.to_source_string()); - } + }*/ morphic_lib::solve(program) } diff --git a/editor/src/editor/markup/nodes.rs b/editor/src/editor/markup/nodes.rs index 8faf0cbf4b..590fc05c5b 100644 --- a/editor/src/editor/markup/nodes.rs +++ b/editor/src/editor/markup/nodes.rs @@ -6,6 +6,7 @@ use crate::editor::ed_error::NestedNodeRequired; use crate::editor::slow_pool::MarkNodeId; use crate::editor::slow_pool::SlowPool; use crate::editor::syntax_highlight::HighlightStyle; +use crate::lang::ast::ExprId; use crate::lang::ast::RecordField; use crate::lang::{ ast::Expr2, @@ -146,6 +147,7 @@ pub const RIGHT_ACCOLADE: &str = " }"; pub const LEFT_SQUARE_BR: &str = "[ "; pub const RIGHT_SQUARE_BR: &str = " ]"; pub const COLON: &str = ": "; +pub const COMMA: &str = ", "; pub const STRING_QUOTES: &str = "\"\""; fn new_markup_node( @@ -217,21 +219,24 @@ pub fn expr2_to_markup<'a, 'b>( markup_node_pool, )]; - for (idx, node_id) in elems.iter_node_ids().enumerate() { - let sub_expr2 = env.pool.get(node_id); + let indexed_node_ids: Vec<(usize, ExprId)> = + elems.iter(env.pool).copied().enumerate().collect(); + + for (idx, node_id) in indexed_node_ids.iter() { + let sub_expr2 = env.pool.get(*node_id); children_ids.push(expr2_to_markup( arena, env, sub_expr2, - node_id, + *node_id, markup_node_pool, )); if idx + 1 < elems.len() { children_ids.push(new_markup_node( ", ".to_string(), - node_id, + *node_id, HighlightStyle::Operator, markup_node_pool, )); diff --git a/editor/src/editor/mvc/ed_update.rs b/editor/src/editor/mvc/ed_update.rs index 859f01cece..4ea9faac9d 100644 --- a/editor/src/editor/mvc/ed_update.rs +++ b/editor/src/editor/mvc/ed_update.rs @@ -13,7 +13,7 @@ use crate::editor::mvc::ed_model::EdModel; use crate::editor::mvc::ed_model::SelectedExpression; use crate::editor::mvc::int_update::start_new_int; use crate::editor::mvc::int_update::update_int; -use crate::editor::mvc::list_update::{prep_empty_list, start_new_list}; +use crate::editor::mvc::list_update::{add_blank_child, start_new_list}; use crate::editor::mvc::lookup_update::update_invalid_lookup; use crate::editor::mvc::record_update::start_new_record; use crate::editor::mvc::record_update::update_empty_record; @@ -689,7 +689,7 @@ pub fn handle_new_char(received_char: &char, ed_model: &mut EdModel) -> EdResult if prev_mark_node.get_content()? == nodes::LEFT_SQUARE_BR { if curr_mark_node.get_content()? == nodes::RIGHT_SQUARE_BR { - prep_empty_list(ed_model)?; // insert a Blank first, this results in cleaner code + add_blank_child(ed_model)?; // insert a Blank first, this results in cleaner code handle_new_char(received_char, ed_model)? } else { InputOutcome::Ignored @@ -726,12 +726,33 @@ pub fn handle_new_char(received_char: &char, ed_model: &mut EdModel) -> EdResult } else { InputOutcome::Ignored } + } else if *ch == ',' { + let mark_parent_id_opt = curr_mark_node.get_parent_id_opt(); + + if let Some(mark_parent_id) = mark_parent_id_opt { + let parent_ast_id = ed_model.markup_node_pool.get(mark_parent_id).get_ast_node_id(); + let parent_expr2 = ed_model.module.env.pool.get(parent_ast_id); + + match parent_expr2 { + Expr2::List { elem_var:_, elems:_} => { + add_blank_child(ed_model)? + } + Expr2::Record { record_var:_, fields:_ } => { + todo!("multiple record fields") + } + _ => { + InputOutcome::Ignored + } + } + } else { + InputOutcome::Ignored + } } else if "\"{[".contains(*ch) { let prev_mark_node = ed_model.markup_node_pool.get(prev_mark_node_id); if prev_mark_node.get_content()? == nodes::LEFT_SQUARE_BR { if curr_mark_node.get_content()? == nodes::RIGHT_SQUARE_BR { - prep_empty_list(ed_model)?; // insert a Blank first, this results in cleaner code + add_blank_child(ed_model)?; // insert a Blank first, this results in cleaner code handle_new_char(received_char, ed_model)? } else { InputOutcome::Ignored diff --git a/editor/src/editor/mvc/list_update.rs b/editor/src/editor/mvc/list_update.rs index 8533967209..ee9366f7bd 100644 --- a/editor/src/editor/mvc/list_update.rs +++ b/editor/src/editor/mvc/list_update.rs @@ -1,5 +1,5 @@ use crate::editor::ed_error::EdResult; -use crate::editor::ed_error::{MissingParent, UnexpectedASTNode, UnexpectedEmptyPoolVec}; +use crate::editor::ed_error::{MissingParent, UnexpectedASTNode}; use crate::editor::markup::attribute::Attributes; use crate::editor::markup::nodes; use crate::editor::markup::nodes::MarkupNode; @@ -7,11 +7,12 @@ use crate::editor::mvc::app_update::InputOutcome; use crate::editor::mvc::ed_model::EdModel; use crate::editor::mvc::ed_update::get_node_context; use crate::editor::mvc::ed_update::NodeContext; +use crate::editor::slow_pool::MarkNodeId; use crate::editor::syntax_highlight::HighlightStyle; -use crate::lang::ast::expr2_to_string; use crate::lang::ast::Expr2; +use crate::lang::ast::{expr2_to_string, ExprId}; use crate::lang::pool::PoolVec; -use snafu::OptionExt; +use crate::ui::text::text_pos::TextPos; pub fn start_new_list(ed_model: &mut EdModel) -> EdResult { let NodeContext { @@ -89,7 +90,7 @@ pub fn start_new_list(ed_model: &mut EdModel) -> EdResult { } // insert Blank at current position for easy code reuse -pub fn prep_empty_list(ed_model: &mut EdModel) -> EdResult { +pub fn add_blank_child(ed_model: &mut EdModel) -> EdResult { let NodeContext { old_caret_pos, curr_mark_node_id, @@ -98,67 +99,117 @@ pub fn prep_empty_list(ed_model: &mut EdModel) -> EdResult { ast_node_id, } = get_node_context(&ed_model)?; - let blank_elt = Expr2::Blank; + let trip_result: EdResult<(ExprId, usize, ExprId, MarkNodeId)> = + if let Some(parent_id) = parent_id_opt { + let parent = ed_model.markup_node_pool.get(parent_id); - let list_ast_node = ed_model.module.env.pool.get(ast_node_id); + let new_child_index = parent.get_children_ids().len() - 1; // TODO support adding child at place other than end - match list_ast_node { - Expr2::List { elem_var, elems: _ } => { - let children: Vec = vec![blank_elt]; - let children_pool_vec = PoolVec::new(children.into_iter(), ed_model.module.env.pool); + let list_ast_node_id = parent.get_ast_node_id(); + let list_ast_node = ed_model.module.env.pool.get(list_ast_node_id); - let blank_elt_id = - children_pool_vec - .iter_node_ids() - .next() - .context(UnexpectedEmptyPoolVec { - descriptive_vec_name: "\"children of List AST node\"", - })?; + match list_ast_node { + Expr2::List { + elem_var: _, + elems: _, + } => { + let blank_elt = Expr2::Blank; + let blank_elt_id = ed_model.module.env.pool.add(blank_elt); - let new_list_node = Expr2::List { - elem_var: *elem_var, - elems: children_pool_vec, - }; - - ed_model.module.env.pool.set(ast_node_id, new_list_node); - - let blank_mark_node = MarkupNode::Blank { - ast_node_id: blank_elt_id, - syn_high_style: HighlightStyle::Blank, - attributes: Attributes::new(), - parent_id_opt, - }; - - let blank_mark_node_id = ed_model.markup_node_pool.add(blank_mark_node); - - // add blank mark node to nested mark node from list - if let Some(parent_id) = parent_id_opt { - let parent = ed_model.markup_node_pool.get_mut(parent_id); - - let new_child_index = 1; // 1 because left bracket is first element - - parent.add_child_at_index(new_child_index, blank_mark_node_id)?; - } else { - MissingParent { - node_id: curr_mark_node_id, + Ok((blank_elt_id, new_child_index, list_ast_node_id, parent_id)) } - .fail()? + _ => UnexpectedASTNode { + required_node_type: "List".to_string(), + encountered_node_type: expr2_to_string(ast_node_id, ed_model.module.env.pool), + } + .fail(), } + } else { + MissingParent { + node_id: curr_mark_node_id, + } + .fail() + }; - // update GridNodeMap and CodeLines - ed_model.insert_between_line( - old_caret_pos.line, - old_caret_pos.column, - nodes::BLANK_PLACEHOLDER, - blank_mark_node_id, - )?; + let (blank_elt_id, new_child_index, list_ast_node_id, parent_id) = trip_result?; - Ok(InputOutcome::Accepted) - } - _ => UnexpectedASTNode { - required_node_type: "List".to_string(), - encountered_node_type: expr2_to_string(ast_node_id, ed_model.module.env.pool), - } - .fail()?, + let new_mark_children = make_mark_children( + new_child_index, + blank_elt_id, + list_ast_node_id, + old_caret_pos, + parent_id_opt, + ed_model, + )?; + + let parent = ed_model.markup_node_pool.get_mut(parent_id); + + for (indx, child) in new_mark_children.iter().enumerate() { + parent.add_child_at_index(new_child_index + indx, *child)?; } + + //TODO add ast children + + Ok(InputOutcome::Accepted) +} + +pub fn make_mark_children( + new_child_index: usize, + blank_elt_id: ExprId, + list_ast_node_id: ExprId, + old_caret_pos: TextPos, + parent_id_opt: Option, + ed_model: &mut EdModel, +) -> EdResult> { + let blank_mark_node = MarkupNode::Blank { + ast_node_id: blank_elt_id, + syn_high_style: HighlightStyle::Blank, + attributes: Attributes::new(), + parent_id_opt, + }; + + let blank_mark_node_id = ed_model.markup_node_pool.add(blank_mark_node); + + let mut children: Vec = vec![]; + + if new_child_index > 1 { + let comma_mark_node = MarkupNode::Text { + content: nodes::COMMA.to_owned(), + ast_node_id: list_ast_node_id, + syn_high_style: HighlightStyle::Blank, + attributes: Attributes::new(), + parent_id_opt, + }; + + let comma_mark_node_id = ed_model.markup_node_pool.add(comma_mark_node); + + ed_model.simple_move_carets_right(nodes::COMMA.len()); + + ed_model.insert_between_line( + old_caret_pos.line, + old_caret_pos.column, + nodes::COMMA, + comma_mark_node_id, + )?; + + children.push(comma_mark_node_id); + } + + children.push(blank_mark_node_id); + + let comma_shift = if new_child_index == 1 { + 0 + } else { + nodes::COMMA.len() + }; + + // update GridNodeMap and CodeLines + ed_model.insert_between_line( + old_caret_pos.line, + old_caret_pos.column + comma_shift, + nodes::BLANK_PLACEHOLDER, + blank_mark_node_id, + )?; + + Ok(children) } diff --git a/editor/src/lang/ast.rs b/editor/src/lang/ast.rs index 4b95b1dc62..1e3cba1495 100644 --- a/editor/src/lang/ast.rs +++ b/editor/src/lang/ast.rs @@ -114,8 +114,8 @@ pub enum Expr2 { InvalidLookup(PoolStr), // 8B List { - elem_var: Variable, // 4B - elems: PoolVec, // 8B + elem_var: Variable, // 4B + elems: PoolVec, // 8B }, If { cond_var: Variable, // 4B @@ -438,13 +438,15 @@ fn expr2_to_string_helper( let mut first_elt = true; - for elem_expr2 in elems.iter(pool) { + for elem_expr2_id in elems.iter(pool) { if !first_elt { out_string.push_str(", ") } else { first_elt = false; } + let elem_expr2 = pool.get(*elem_expr2_id); + expr2_to_string_helper(elem_expr2, indent_level + 2, pool, out_string) } diff --git a/editor/src/lang/constrain.rs b/editor/src/lang/constrain.rs index 106eea2f1f..f2ad95ed81 100644 --- a/editor/src/lang/constrain.rs +++ b/editor/src/lang/constrain.rs @@ -1,7 +1,7 @@ use bumpalo::{collections::Vec as BumpVec, Bump}; use crate::lang::{ - ast::{Expr2, RecordField, WhenBranch}, + ast::{Expr2, ExprId, RecordField, WhenBranch}, expr::Env, pattern::{DestructType, Pattern2, PatternState2, RecordDestruct}, pool::{Pool, PoolStr, PoolVec, ShallowClone}, @@ -131,7 +131,10 @@ pub fn constrain_expr<'a>( let list_elem_type = Type2::Variable(*elem_var); - for (index, elem_node_id) in elems.iter_node_ids().enumerate() { + let indexed_node_ids: Vec<(usize, ExprId)> = + elems.iter(env.pool).copied().enumerate().collect(); + + for (index, elem_node_id) in indexed_node_ids { let elem_expr = env.pool.get(elem_node_id); let elem_expected = Expected::ForReason( diff --git a/editor/src/lang/expr.rs b/editor/src/lang/expr.rs index 2a9626bd5b..54843e2576 100644 --- a/editor/src/lang/expr.rs +++ b/editor/src/lang/expr.rs @@ -19,6 +19,7 @@ use roc_module::low_level::LowLevel; use roc_module::operator::CalledVia; use roc_module::symbol::{IdentIds, ModuleId, ModuleIds, Symbol}; use roc_parse::ast; +use roc_parse::ast::Expr; use roc_parse::ast::StrLiteral; use roc_parse::parser::{loc, Parser, State, SyntaxError}; use roc_problem::can::{Problem, RuntimeError}; @@ -337,12 +338,18 @@ pub fn to_expr2<'a>( let elems = PoolVec::with_capacity(items.len() as u32, env.pool); - for (node_id, item) in elems.iter_node_ids().zip(items.iter()) { + let node_id_item_tups: Vec<(ExprId, &Located)> = elems + .iter(env.pool) + .map(|node_ref| *node_ref) + .zip(items.iter().map(|item_ref| *item_ref)) + .collect(); + + for (node_id, item) in node_id_item_tups.iter() { let (expr, sub_output) = to_expr2(env, scope, &item.value, item.region); output_ref.union(sub_output); - env.pool[node_id] = expr; + env.pool.set(*node_id, expr); } let expr = Expr2::List { From 544ac8634329fea6d5fd670b02f2271cff2f4c36 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Fri, 2 Jul 2021 16:27:01 +0200 Subject: [PATCH 417/496] fixed poolvec bug, ast nodes are added to list --- editor/src/editor/mvc/list_update.rs | 31 ++++++++++++++++++++++++++-- editor/src/lang/pool.rs | 16 ++++++++++++-- 2 files changed, 43 insertions(+), 4 deletions(-) diff --git a/editor/src/editor/mvc/list_update.rs b/editor/src/editor/mvc/list_update.rs index ee9366f7bd..421a193c17 100644 --- a/editor/src/editor/mvc/list_update.rs +++ b/editor/src/editor/mvc/list_update.rs @@ -133,6 +133,35 @@ pub fn add_blank_child(ed_model: &mut EdModel) -> EdResult { let (blank_elt_id, new_child_index, list_ast_node_id, parent_id) = trip_result?; + let list_ast_node = ed_model.module.env.pool.get(list_ast_node_id); + + match list_ast_node { + Expr2::List { + elem_var, + elems, + } => { + let mut new_elems: Vec = + elems.iter(ed_model.module.env.pool).copied().collect(); + + new_elems.push(blank_elt_id); + + let new_list_node = + Expr2::List { + elem_var: *elem_var, + elems: PoolVec::new(new_elems.into_iter(), ed_model.module.env.pool), + }; + + ed_model.module.env.pool.set(list_ast_node_id, new_list_node); + + Ok(()) + } + _ => UnexpectedASTNode { + required_node_type: "List".to_string(), + encountered_node_type: expr2_to_string(ast_node_id, ed_model.module.env.pool), + } + .fail(), + }?; + let new_mark_children = make_mark_children( new_child_index, blank_elt_id, @@ -148,8 +177,6 @@ pub fn add_blank_child(ed_model: &mut EdModel) -> EdResult { parent.add_child_at_index(new_child_index + indx, *child)?; } - //TODO add ast children - Ok(InputOutcome::Accepted) } diff --git a/editor/src/lang/pool.rs b/editor/src/lang/pool.rs index 1d77814b46..e47bd79107 100644 --- a/editor/src/lang/pool.rs +++ b/editor/src/lang/pool.rs @@ -352,11 +352,11 @@ impl<'a, T: 'a + Sized> PoolVec { let index = first_node_id.index as isize; let mut next_node_ptr = unsafe { pool.nodes.offset(index) } as *mut T; - for node in nodes { + for (indx_inc, node) in nodes.enumerate() { unsafe { *next_node_ptr = node; - next_node_ptr = next_node_ptr.offset(1); + next_node_ptr = pool.nodes.offset(index + (indx_inc as isize) + 1) as *mut T; } } @@ -603,6 +603,18 @@ impl Iterator for PoolVecIterNodeIds { } } +#[test] +fn pool_vec_iter_test() { + let expected_vec: Vec = vec![2, 4, 8, 16]; + + let mut test_pool = Pool::with_capacity(1024); + let pool_vec = PoolVec::new(expected_vec.clone().into_iter(), &mut test_pool); + + let current_vec: Vec = pool_vec.iter(&test_pool).copied().collect(); + + assert_eq!(current_vec, expected_vec); +} + /// Clones the outer node, but does not clone any nodeids pub trait ShallowClone { fn shallow_clone(&self) -> Self; From 659f33c44b3bacd4f800cd56d5362eb8261a67cf Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Fri, 2 Jul 2021 19:08:05 +0200 Subject: [PATCH 418/496] some multi element list tests --- editor/src/editor/mvc/ed_update.rs | 32 ++++++++++++++++++++++++++-- editor/src/editor/mvc/list_update.rs | 20 ++++++++--------- 2 files changed, 40 insertions(+), 12 deletions(-) diff --git a/editor/src/editor/mvc/ed_update.rs b/editor/src/editor/mvc/ed_update.rs index 4ea9faac9d..a23565550a 100644 --- a/editor/src/editor/mvc/ed_update.rs +++ b/editor/src/editor/mvc/ed_update.rs @@ -870,7 +870,11 @@ pub mod test_ed_update { let mut ed_model = ed_model_from_dsl(&code_str, pre_lines, &mut model_refs)?; for input_char in new_char_seq.chars() { - ed_res_to_res(handle_new_char(&input_char, &mut ed_model))?; + if input_char == '➔' { + ed_model.simple_move_carets_right(1); + } else { + ed_res_to_res(handle_new_char(&input_char, &mut ed_model))?; + } } let post_lines = ui_res_to_res(ed_model_to_dsl(&ed_model))?; @@ -1520,7 +1524,7 @@ pub mod test_ed_update { } #[test] - fn test_list() -> Result<(), String> { + fn test_single_elt_list() -> Result<(), String> { assert_insert(&["┃"], &["[ ┃ ]"], '[')?; assert_insert_seq(&["┃"], &["[ 0┃ ]"], "[0")?; @@ -1555,6 +1559,30 @@ pub mod test_ed_update { Ok(()) } + #[test] + fn test_multi_elt_list() -> Result<(), String> { + assert_insert_seq(&["┃"], &["[ 0, 1┃ ]"], "[0,1")?; + assert_insert_seq(&["┃"], &["[ 987, 6543, 210┃ ]"], "[987,6543,210")?; + + assert_insert_seq( + &["┃"], + &["[ \"a\", \"bcd\", \"EFGH┃\" ]"], + "[\"a➔,\"bcd➔,\"EFGH", + )?; + + assert_insert_seq( + &["┃"], + &["[ { a: 1 }, { b: 23 }, { c: 456┃ } ]"], + "[{a:1➔➔,{b:23➔➔,{c:456", + )?; + + assert_insert_seq(&["┃"], &["[ [ 1 ], [ 23 ], [ 456┃ ] ]"], "[[1➔➔,[23➔➔,[456")?; + + // TODO issue #1448: assert_insert_seq(&["┃"], &["[ 0, ┃ ]"], "[0,\"")?; + // assert_insert_seq(&["┃"], &["[ [ [ 0 ], [ 1 ] ], ┃"], "[[[0➔➔,[1➔➔➔➔,[[\"")? + Ok(()) + } + #[test] fn test_ignore_list() -> Result<(), String> { assert_insert_seq_ignore(&["┃[ ]"], IGNORE_CHARS)?; diff --git a/editor/src/editor/mvc/list_update.rs b/editor/src/editor/mvc/list_update.rs index 421a193c17..67ed064e0a 100644 --- a/editor/src/editor/mvc/list_update.rs +++ b/editor/src/editor/mvc/list_update.rs @@ -136,22 +136,22 @@ pub fn add_blank_child(ed_model: &mut EdModel) -> EdResult { let list_ast_node = ed_model.module.env.pool.get(list_ast_node_id); match list_ast_node { - Expr2::List { - elem_var, - elems, - } => { + Expr2::List { elem_var, elems } => { let mut new_elems: Vec = elems.iter(ed_model.module.env.pool).copied().collect(); new_elems.push(blank_elt_id); - let new_list_node = - Expr2::List { - elem_var: *elem_var, - elems: PoolVec::new(new_elems.into_iter(), ed_model.module.env.pool), - }; + let new_list_node = Expr2::List { + elem_var: *elem_var, + elems: PoolVec::new(new_elems.into_iter(), ed_model.module.env.pool), + }; - ed_model.module.env.pool.set(list_ast_node_id, new_list_node); + ed_model + .module + .env + .pool + .set(list_ast_node_id, new_list_node); Ok(()) } From 528e1f543b135c6be1a1a522a6e1fd3b6e3a3d84 Mon Sep 17 00:00:00 2001 From: rvcas Date: Fri, 2 Jul 2021 16:17:26 -0400 Subject: [PATCH 419/496] fix: value def adjustments --- editor/src/lang/ast.rs | 12 +++++------ editor/src/lang/def.rs | 4 ++-- editor/src/lang/module.rs | 42 ++++++++++++++++++++------------------- 3 files changed, 30 insertions(+), 28 deletions(-) diff --git a/editor/src/lang/ast.rs b/editor/src/lang/ast.rs index d8137aa2c4..50e0d32891 100644 --- a/editor/src/lang/ast.rs +++ b/editor/src/lang/ast.rs @@ -218,10 +218,10 @@ pub enum Expr2 { #[derive(Debug)] pub struct ValueDef { - pub pattern: PatternId, // 4B - pub expr: ExprId, // 4B - pub expr_type: Option, // ? - pub expr_var: Variable, // 4B + pub pattern: PatternId, // 4B + pub expr: ExprId, // 4B + pub opt_expr_type: Option<(TypeId, Rigids)>, // ? + pub expr_var: Variable, // 4B } impl ShallowClone for ValueDef { @@ -229,8 +229,8 @@ impl ShallowClone for ValueDef { Self { pattern: self.pattern, expr: self.expr, - expr_type: match &self.expr_type { - Some(rigids) => Some(rigids.shallow_clone()), + opt_expr_type: match &self.opt_expr_type { + Some((annotation, rigids)) => Some((*annotation, rigids.shallow_clone())), None => None, }, expr_var: self.expr_var, diff --git a/editor/src/lang/def.rs b/editor/src/lang/def.rs index 3baaadf06b..afdef67359 100644 --- a/editor/src/lang/def.rs +++ b/editor/src/lang/def.rs @@ -628,7 +628,7 @@ fn canonicalize_pending_def<'a>( pattern: loc_can_pattern, expr: env.pool.add(loc_can_expr), // annotation - expr_type: Some(rigids), + opt_expr_type: Some((annotation, rigids)), expr_var: env.var_store.fresh(), }; @@ -750,7 +750,7 @@ fn canonicalize_pending_def<'a>( let value_def = ValueDef { pattern: loc_can_pattern, expr: env.pool.add(loc_can_expr), - expr_type: None, + opt_expr_type: None, expr_var: env.var_store.fresh(), }; diff --git a/editor/src/lang/module.rs b/editor/src/lang/module.rs index 7cd3e039aa..3fbc93228f 100644 --- a/editor/src/lang/module.rs +++ b/editor/src/lang/module.rs @@ -2,7 +2,7 @@ #![allow(dead_code)] #![allow(unused_imports)] #![allow(unused_variables)] -use crate::lang::ast::{FunctionDef, ValueDef}; +use crate::lang::ast::{Expr2, FunctionDef, ValueDef}; use crate::lang::def::{canonicalize_defs, sort_can_defs, Declaration, Def}; use crate::lang::expr::Env; use crate::lang::expr::Output; @@ -175,7 +175,7 @@ pub fn canonicalize_module_defs<'a>( // this is now done later, in file.rs. match sort_can_defs(&mut env, defs, Output::default()) { - (Ok(declarations), output) => { + (Ok(mut declarations), output) => { use Declaration::*; for decl in declarations.iter() { @@ -238,29 +238,31 @@ pub fn canonicalize_module_defs<'a>( // exposed_symbols and added to exposed_vars_by_symbol. If any were // not, that means they were declared as exposed but there was // no actual declaration with that name! - // for symbol in exposed_symbols { - // env.problem(Problem::ExposedButNotDefined(symbol)); + for symbol in exposed_symbols { + env.problem(Problem::ExposedButNotDefined(symbol)); - // // In case this exposed value is referenced by other modules, - // // create a decl for it whose implementation is a runtime error. - // let mut pattern_vars = SendMap::default(); - // pattern_vars.insert(symbol, env.var_store.fresh()); + // In case this exposed value is referenced by other modules, + // create a decl for it whose implementation is a runtime error. + let mut pattern_vars = SendMap::default(); + pattern_vars.insert(symbol, env.var_store.fresh()); - // let runtime_error = RuntimeError::ExposedButNotDefined(symbol); + let runtime_error = RuntimeError::ExposedButNotDefined(symbol); - // let value_def = { - // let pattern = env.pool.add(Pattern2::Identifier(symbol)); - // ValueDef { - // pattern, - // expr_type: None, - // expr_var: env.var_store.fresh(), - // } - // }; + let value_def = { + let pattern = env.pool.add(Pattern2::Identifier(symbol)); + let expr = env.pool.add(Expr2::RuntimeError()); + ValueDef { + pattern, + expr, + opt_expr_type: None, + expr_var: env.var_store.fresh(), + } + }; - // let def = Def::Value(value_def); + let def = Def::Value(value_def); - // declarations.push(Declaration::Declare(def)); - // } + declarations.push(Declaration::Declare(def)); + } // Incorporate any remaining output.lookups entries into references. for symbol in output.references.lookups { From 54bcf54f303c1c46cdda805d86a5960b92971306 Mon Sep 17 00:00:00 2001 From: rvcas Date: Fri, 2 Jul 2021 18:35:13 -0400 Subject: [PATCH 420/496] chore: dec remove redundant comptime --- compiler/builtins/bitcode/src/dec.zig | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/compiler/builtins/bitcode/src/dec.zig b/compiler/builtins/bitcode/src/dec.zig index 1aa38da759..011e37cac1 100644 --- a/compiler/builtins/bitcode/src/dec.zig +++ b/compiler/builtins/bitcode/src/dec.zig @@ -7,16 +7,16 @@ const RocStr = str.RocStr; pub const RocDec = struct { num: i128, - pub const decimal_places: comptime u5 = 18; - pub const whole_number_places: comptime u5 = 21; - const max_digits: comptime u6 = 39; - const leading_zeros: comptime [17]u8 = "00000000000000000".*; + pub const decimal_places: u5 = 18; + pub const whole_number_places: u5 = 21; + const max_digits: u6 = 39; + const leading_zeros: [17]u8 = "00000000000000000".*; - pub const min: comptime RocDec = .{ .num = math.minInt(i128) }; - pub const max: comptime RocDec = .{ .num = math.maxInt(i128) }; + pub const min: RocDec = .{ .num = math.minInt(i128) }; + pub const max: RocDec = .{ .num = math.maxInt(i128) }; - pub const one_point_zero_i128: comptime i128 = comptime math.pow(i128, 10, RocDec.decimal_places); - pub const one_point_zero: comptime RocDec = .{ .num = one_point_zero_i128 }; + pub const one_point_zero_i128: i128 = math.pow(i128, 10, RocDec.decimal_places); + pub const one_point_zero: RocDec = .{ .num = one_point_zero_i128 }; pub fn fromU64(num: u64) RocDec { return .{ .num = num * one_point_zero_i128 }; @@ -362,7 +362,7 @@ fn mul_and_decimalize(a: u128, b: u128) i128 { const lk = mul_u128(lhs_hi, rhs_hi); const e = ea.hi; - const _a = ea.lo; + // const _a = ea.lo; const g = gf.hi; const f = gf.lo; From 60f017cbd59f52e23535f6a1eaf932e752c665e1 Mon Sep 17 00:00:00 2001 From: rvcas Date: Fri, 2 Jul 2021 18:35:51 -0400 Subject: [PATCH 421/496] chore: utils ignore unused vars --- compiler/builtins/bitcode/src/utils.zig | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/compiler/builtins/bitcode/src/utils.zig b/compiler/builtins/bitcode/src/utils.zig index be99cab009..b679c20153 100644 --- a/compiler/builtins/bitcode/src/utils.zig +++ b/compiler/builtins/bitcode/src/utils.zig @@ -20,18 +20,18 @@ comptime { } } -fn testing_roc_alloc(size: usize, alignment: u32) callconv(.C) ?*c_void { +fn testing_roc_alloc(size: usize, _: u32) callconv(.C) ?*c_void { return @ptrCast(?*c_void, std.testing.allocator.alloc(u8, size) catch unreachable); } -fn testing_roc_realloc(c_ptr: *c_void, new_size: usize, old_size: usize, alignment: u32) callconv(.C) ?*c_void { +fn testing_roc_realloc(c_ptr: *c_void, new_size: usize, old_size: usize, _: u32) callconv(.C) ?*c_void { const ptr = @ptrCast([*]u8, @alignCast(16, c_ptr)); const slice = ptr[0..old_size]; return @ptrCast(?*c_void, std.testing.allocator.realloc(slice, new_size) catch unreachable); } -fn testing_roc_dealloc(c_ptr: *c_void, alignment: u32) callconv(.C) void { +fn testing_roc_dealloc(c_ptr: *c_void, _: u32) callconv(.C) void { const ptr = @ptrCast([*]u8, @alignCast(16, c_ptr)); std.testing.allocator.destroy(ptr); @@ -53,8 +53,8 @@ pub const Inc = fn (?[*]u8) callconv(.C) void; pub const IncN = fn (?[*]u8, u64) callconv(.C) void; pub const Dec = fn (?[*]u8) callconv(.C) void; -const REFCOUNT_MAX_ISIZE: comptime isize = 0; -pub const REFCOUNT_ONE_ISIZE: comptime isize = std.math.minInt(isize); +const REFCOUNT_MAX_ISIZE: isize = 0; +pub const REFCOUNT_ONE_ISIZE: isize = std.math.minInt(isize); pub const REFCOUNT_ONE: usize = @bitCast(usize, REFCOUNT_ONE_ISIZE); pub const IntWidth = enum(u8) { @@ -110,7 +110,7 @@ pub fn allocateWithRefcount( data_bytes: usize, alignment: u32, ) [*]u8 { - comptime const result_in_place = false; + const result_in_place = false; switch (alignment) { 16 => { From fb12715aba437a4dfb2331ff36a4010a687680bf Mon Sep 17 00:00:00 2001 From: rvcas Date: Fri, 2 Jul 2021 18:36:17 -0400 Subject: [PATCH 422/496] chore: list remove unused vars --- compiler/builtins/bitcode/src/list.zig | 16 ++------- compiler/gen_llvm/src/llvm/build_list.rs | 42 ++++++++++++++---------- 2 files changed, 28 insertions(+), 30 deletions(-) diff --git a/compiler/builtins/bitcode/src/list.zig b/compiler/builtins/bitcode/src/list.zig index a45e6564dd..602b680d21 100644 --- a/compiler/builtins/bitcode/src/list.zig +++ b/compiler/builtins/bitcode/src/list.zig @@ -626,7 +626,6 @@ pub fn listWalkUntil( output: Opaque, ) callconv(.C) void { // [ Continue a, Stop a ] - const CONTINUE: usize = 0; if (accum_width == 0) { return; @@ -922,7 +921,7 @@ inline fn swapHelp(width: usize, temporary: [*]u8, ptr1: [*]u8, ptr2: [*]u8) voi } fn swap(width_initial: usize, p1: [*]u8, p2: [*]u8) void { - const threshold: comptime usize = 64; + const threshold: usize = 64; var width = width_initial; @@ -948,11 +947,6 @@ fn swap(width_initial: usize, p1: [*]u8, p2: [*]u8) void { } fn swapElements(source_ptr: [*]u8, element_width: usize, index_1: usize, index_2: usize) void { - const threshold: comptime usize = 64; - - var buffer_actual: [threshold]u8 = undefined; - var buffer: [*]u8 = buffer_actual[0..]; - var element_at_i = source_ptr + (index_1 * element_width); var element_at_j = source_ptr + (index_2 * element_width); @@ -1029,8 +1023,6 @@ pub fn listConcat(list_a: RocList, list_b: RocList, alignment: u32, element_widt pub fn listSetInPlace( bytes: ?[*]u8, - length: usize, - alignment: u32, index: usize, element: Opaque, element_width: usize, @@ -1043,7 +1035,7 @@ pub fn listSetInPlace( // so we don't do a bounds check here. Hence, the list is also non-empty, // because inserting into an empty list is always out of bounds - return listSetInPlaceHelp(bytes, length, alignment, index, element, element_width, dec); + return listSetInPlaceHelp(bytes, index, element, element_width, dec); } pub fn listSet( @@ -1064,7 +1056,7 @@ pub fn listSet( const ptr: [*]usize = @ptrCast([*]usize, @alignCast(8, bytes)); if ((ptr - 1)[0] == utils.REFCOUNT_ONE) { - return listSetInPlaceHelp(bytes, length, alignment, index, element, element_width, dec); + return listSetInPlaceHelp(bytes, index, element, element_width, dec); } else { return listSetImmutable(bytes, length, alignment, index, element, element_width, dec); } @@ -1072,8 +1064,6 @@ pub fn listSet( inline fn listSetInPlaceHelp( bytes: ?[*]u8, - length: usize, - alignment: u32, index: usize, element: Opaque, element_width: usize, diff --git a/compiler/gen_llvm/src/llvm/build_list.rs b/compiler/gen_llvm/src/llvm/build_list.rs index a6b6456557..7aa7e07ead 100644 --- a/compiler/gen_llvm/src/llvm/build_list.rs +++ b/compiler/gen_llvm/src/llvm/build_list.rs @@ -361,25 +361,33 @@ pub fn list_set<'a, 'ctx, 'env>( env.context.i8_type().ptr_type(AddressSpace::Generic), ); - let symbol = match update_mode { - UpdateMode::InPlace => bitcode::LIST_SET_IN_PLACE, - UpdateMode::Immutable => bitcode::LIST_SET, + let new_bytes = match update_mode { + UpdateMode::InPlace => call_bitcode_fn( + env, + &[ + bytes.into(), + index.into(), + pass_element_as_opaque(env, element), + layout_width(env, element_layout), + dec_element_fn.as_global_value().as_pointer_value().into(), + ], + bitcode::LIST_SET_IN_PLACE, + ), + UpdateMode::Immutable => call_bitcode_fn( + env, + &[ + bytes.into(), + length.into(), + env.alignment_intvalue(&element_layout), + index.into(), + pass_element_as_opaque(env, element), + layout_width(env, element_layout), + dec_element_fn.as_global_value().as_pointer_value().into(), + ], + bitcode::LIST_SET, + ), }; - let new_bytes = call_bitcode_fn( - env, - &[ - bytes.into(), - length.into(), - env.alignment_intvalue(&element_layout), - index.into(), - pass_element_as_opaque(env, element), - layout_width(env, element_layout), - dec_element_fn.as_global_value().as_pointer_value().into(), - ], - &symbol, - ); - store_list(env, new_bytes.into_pointer_value(), length) } From 3452037d44247f6073f53625ccc508cbdf4e6da6 Mon Sep 17 00:00:00 2001 From: rvcas Date: Fri, 2 Jul 2021 18:36:30 -0400 Subject: [PATCH 423/496] chore: dict remove unused vars --- compiler/builtins/bitcode/src/dict.zig | 20 +------------------- compiler/gen_llvm/src/llvm/build.rs | 1 - compiler/gen_llvm/src/llvm/build_dict.rs | 6 ------ 3 files changed, 1 insertion(+), 26 deletions(-) diff --git a/compiler/builtins/bitcode/src/dict.zig b/compiler/builtins/bitcode/src/dict.zig index 2780652f1b..ea9ea768fc 100644 --- a/compiler/builtins/bitcode/src/dict.zig +++ b/compiler/builtins/bitcode/src/dict.zig @@ -568,14 +568,6 @@ pub fn dictKeys(dict: RocDict, alignment: Alignment, key_width: usize, value_wid const data_bytes = length * key_width; var ptr = allocateWithRefcount(data_bytes, alignment); - var offset = blk: { - if (alignment.keyFirst()) { - break :blk 0; - } else { - break :blk (dict.capacity() * value_width); - } - }; - i = 0; var copied: usize = 0; while (i < size) : (i += 1) { @@ -617,14 +609,6 @@ pub fn dictValues(dict: RocDict, alignment: Alignment, key_width: usize, value_w const data_bytes = length * value_width; var ptr = allocateWithRefcount(data_bytes, alignment); - var offset = blk: { - if (alignment.keyFirst()) { - break :blk (dict.capacity() * key_width); - } else { - break :blk 0; - } - }; - i = 0; var copied: usize = 0; while (i < size) : (i += 1) { @@ -644,7 +628,7 @@ pub fn dictValues(dict: RocDict, alignment: Alignment, key_width: usize, value_w output.* = RocList{ .bytes = ptr, .length = length }; } -fn doNothing(ptr: Opaque) callconv(.C) void { +fn doNothing(_: Opaque) callconv(.C) void { return; } @@ -764,8 +748,6 @@ pub fn dictWalk( key_width: usize, value_width: usize, accum_width: usize, - inc_key: Inc, - inc_value: Inc, output: Opaque, ) callconv(.C) void { const alignment_u32 = alignment.toU32(); diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 815e636473..6e87423b3f 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -4200,7 +4200,6 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>( dict_walk( env, - layout_ids, roc_function_call, dict, default, diff --git a/compiler/gen_llvm/src/llvm/build_dict.rs b/compiler/gen_llvm/src/llvm/build_dict.rs index 7b818ed41c..73f799466e 100644 --- a/compiler/gen_llvm/src/llvm/build_dict.rs +++ b/compiler/gen_llvm/src/llvm/build_dict.rs @@ -635,7 +635,6 @@ fn dict_intersect_or_difference<'a, 'ctx, 'env>( #[allow(clippy::too_many_arguments)] pub fn dict_walk<'a, 'ctx, 'env>( env: &Env<'a, 'ctx, 'env>, - layout_ids: &mut LayoutIds<'a>, roc_function_call: RocFunctionCall<'ctx>, dict: BasicValueEnum<'ctx>, accum: BasicValueEnum<'ctx>, @@ -660,9 +659,6 @@ pub fn dict_walk<'a, 'ctx, 'env>( let output_ptr = builder.build_alloca(accum_bt, "output_ptr"); - let inc_key_fn = build_inc_wrapper(env, layout_ids, key_layout); - let inc_value_fn = build_inc_wrapper(env, layout_ids, value_layout); - call_void_bitcode_fn( env, &[ @@ -676,8 +672,6 @@ pub fn dict_walk<'a, 'ctx, 'env>( layout_width(env, key_layout), layout_width(env, value_layout), layout_width(env, accum_layout), - inc_key_fn.as_global_value().as_pointer_value().into(), - inc_value_fn.as_global_value().as_pointer_value().into(), env.builder.build_bitcast(output_ptr, u8_ptr, "to_opaque"), ], &bitcode::DICT_WALK, From e4bc0adc598e4954489264d46e0289b8bdec0138 Mon Sep 17 00:00:00 2001 From: rvcas Date: Fri, 2 Jul 2021 20:53:37 -0400 Subject: [PATCH 424/496] feat: make ValueDef an enum --- editor/src/lang/ast.rs | 49 +++++++++++++----- editor/src/lang/constrain.rs | 98 ++++++++++++++++++++---------------- editor/src/lang/def.rs | 25 +++++---- editor/src/lang/module.rs | 11 ++-- 4 files changed, 110 insertions(+), 73 deletions(-) diff --git a/editor/src/lang/ast.rs b/editor/src/lang/ast.rs index 86a37e4ed4..9d8d413c88 100644 --- a/editor/src/lang/ast.rs +++ b/editor/src/lang/ast.rs @@ -217,23 +217,48 @@ pub enum Expr2 { } #[derive(Debug)] -pub struct ValueDef { - pub pattern: PatternId, // 4B - pub expr: ExprId, // 4B - pub opt_expr_type: Option<(TypeId, Rigids)>, // ? - pub expr_var: Variable, // 4B +pub enum ValueDef { + WithAnnotation { + pattern_id: PatternId, // 4B + expr_id: ExprId, // 4B + type_id: TypeId, + rigids: NodeId, + expr_var: Variable, // 4B + }, + NoAnnotation { + pattern_id: PatternId, // 4B + expr_id: ExprId, // 4B + expr_var: Variable, // 4B + }, } impl ShallowClone for ValueDef { fn shallow_clone(&self) -> Self { - Self { - pattern: self.pattern, - expr: self.expr, - opt_expr_type: match &self.opt_expr_type { - Some((annotation, rigids)) => Some((*annotation, rigids.shallow_clone())), - None => None, + match self { + Self::WithAnnotation { + pattern_id, + expr_id, + type_id, + rigids, + expr_var, + padding, + } => Self::WithAnnotation { + pattern_id: *pattern_id, + expr_id: *expr_id, + type_id: *type_id, + rigids: *rigids, + expr_var: *expr_var, + padding: *padding, + }, + Self::NoAnnotation { + pattern_id, + expr_id, + expr_var, + } => Self::NoAnnotation { + pattern_id: *pattern_id, + expr_id: *expr_id, + expr_var: *expr_var, }, - expr_var: self.expr_var, } } } diff --git a/editor/src/lang/constrain.rs b/editor/src/lang/constrain.rs index a22ab39334..b813d76153 100644 --- a/editor/src/lang/constrain.rs +++ b/editor/src/lang/constrain.rs @@ -1,7 +1,7 @@ use bumpalo::{collections::Vec as BumpVec, Bump}; use crate::lang::{ - ast::{Expr2, RecordField, WhenBranch}, + ast::{Expr2, RecordField, ValueDef, WhenBranch}, expr::Env, pattern::{DestructType, Pattern2, PatternState2, RecordDestruct}, pool::{Pool, PoolStr, PoolVec, ShallowClone}, @@ -766,57 +766,67 @@ pub fn constrain_expr<'a>( let body = env.pool.get(*body_id); let body_con = constrain_expr(arena, env, body, expected.shallow_clone(), region); - let pattern = env.pool.get(value_def.pattern); - let mut flex_vars = BumpVec::with_capacity_in(1, arena); - flex_vars.push(*body_var); + match value_def { + ValueDef::WithAnnotation { .. } => todo!("implement {:?}", value_def), + ValueDef::NoAnnotation { + pattern_id, + expr_id, + expr_var, + } => { + let pattern = env.pool.get(*pattern_id); - let expr_type = Type2::Variable(value_def.expr_var); + let mut flex_vars = BumpVec::with_capacity_in(1, arena); + flex_vars.push(*body_var); - let pattern_expected = PExpected::NoExpectation(expr_type.shallow_clone()); - let mut state = PatternState2 { - headers: BumpMap::new_in(arena), - vars: BumpVec::with_capacity_in(1, arena), - constraints: BumpVec::with_capacity_in(1, arena), - }; + let expr_type = Type2::Variable(*expr_var); - constrain_pattern(arena, env, pattern, region, pattern_expected, &mut state); - state.vars.push(value_def.expr_var); + let pattern_expected = PExpected::NoExpectation(expr_type.shallow_clone()); + let mut state = PatternState2 { + headers: BumpMap::new_in(arena), + vars: BumpVec::with_capacity_in(1, arena), + constraints: BumpVec::with_capacity_in(1, arena), + }; - let def_expr = env.pool.get(value_def.expr); + constrain_pattern(arena, env, pattern, region, pattern_expected, &mut state); + state.vars.push(*expr_var); - let constrained_def = Let(arena.alloc(LetConstraint { - rigid_vars: BumpVec::new_in(arena), - flex_vars: state.vars, - def_types: state.headers, - defs_constraint: Let(arena.alloc(LetConstraint { - rigid_vars: BumpVec::new_in(arena), // always empty - flex_vars: BumpVec::new_in(arena), // empty, because our functions have no arguments - def_types: BumpMap::new_in(arena), // empty, because our functions have no arguments! - defs_constraint: And(state.constraints), - ret_constraint: constrain_expr( - arena, - env, - def_expr, - Expected::NoExpectation(expr_type), + let def_expr = env.pool.get(*expr_id); + + let constrained_def = Let(arena.alloc(LetConstraint { + rigid_vars: BumpVec::new_in(arena), + flex_vars: state.vars, + def_types: state.headers, + defs_constraint: Let(arena.alloc(LetConstraint { + rigid_vars: BumpVec::new_in(arena), // always empty + flex_vars: BumpVec::new_in(arena), // empty, because our functions have no arguments + def_types: BumpMap::new_in(arena), // empty, because our functions have no arguments! + defs_constraint: And(state.constraints), + ret_constraint: constrain_expr( + arena, + env, + def_expr, + Expected::NoExpectation(expr_type), + region, + ), + })), + ret_constraint: body_con, + })); + + let mut and_constraints = BumpVec::with_capacity_in(2, arena); + + and_constraints.push(constrained_def); + and_constraints.push(Eq( + Type2::Variable(*body_var), + expected, + Category::Storage(std::file!(), std::line!()), + // TODO: needs to be ret region region, - ), - })), - ret_constraint: body_con, - })); + )); - let mut and_constraints = BumpVec::with_capacity_in(2, arena); - - and_constraints.push(constrained_def); - and_constraints.push(Eq( - Type2::Variable(*body_var), - expected, - Category::Storage(std::file!(), std::line!()), - // TODO: needs to be ret region - region, - )); - - exists(arena, flex_vars, And(and_constraints)) + exists(arena, flex_vars, And(and_constraints)) + } + } } Expr2::Update { symbol, diff --git a/editor/src/lang/def.rs b/editor/src/lang/def.rs index afdef67359..f7f4deaa52 100644 --- a/editor/src/lang/def.rs +++ b/editor/src/lang/def.rs @@ -46,8 +46,11 @@ impl Def { match self { Def::AnnotationOnly { .. } => todo!("lost pattern information here ... "), - Def::Value(ValueDef { pattern, .. }) => { - let pattern2 = &pool[*pattern]; + Def::Value( + ValueDef::WithAnnotation { pattern_id, .. } + | ValueDef::NoAnnotation { pattern_id, .. }, + ) => { + let pattern2 = &pool[*pattern_id]; output.extend(symbols_from_pattern(pool, pattern2)); } Def::Function(function_def) => match function_def { @@ -624,12 +627,13 @@ fn canonicalize_pending_def<'a>( }; let annotation = env.add(annotation, loc_ann.region); - let value_def = ValueDef { - pattern: loc_can_pattern, - expr: env.pool.add(loc_can_expr), - // annotation - opt_expr_type: Some((annotation, rigids)), + let value_def = ValueDef::WithAnnotation { + pattern_id: loc_can_pattern, + expr_id: env.pool.add(loc_can_expr), + type_id: annotation, + rigids: env.pool.add(rigids), expr_var: env.var_store.fresh(), + padding: Default::default(), }; let def = Def::Value(value_def); @@ -747,10 +751,9 @@ fn canonicalize_pending_def<'a>( } _ => { - let value_def = ValueDef { - pattern: loc_can_pattern, - expr: env.pool.add(loc_can_expr), - opt_expr_type: None, + let value_def = ValueDef::NoAnnotation { + pattern_id: loc_can_pattern, + expr_id: env.pool.add(loc_can_expr), expr_var: env.var_store.fresh(), }; diff --git a/editor/src/lang/module.rs b/editor/src/lang/module.rs index 3fbc93228f..c0494d3193 100644 --- a/editor/src/lang/module.rs +++ b/editor/src/lang/module.rs @@ -249,12 +249,11 @@ pub fn canonicalize_module_defs<'a>( let runtime_error = RuntimeError::ExposedButNotDefined(symbol); let value_def = { - let pattern = env.pool.add(Pattern2::Identifier(symbol)); - let expr = env.pool.add(Expr2::RuntimeError()); - ValueDef { - pattern, - expr, - opt_expr_type: None, + let pattern_id = env.pool.add(Pattern2::Identifier(symbol)); + let expr_id = env.pool.add(Expr2::RuntimeError()); + ValueDef::NoAnnotation { + pattern_id, + expr_id, expr_var: env.var_store.fresh(), } }; From a6c6760c2a20473cbc070abe6e24abb9cdff5521 Mon Sep 17 00:00:00 2001 From: rvcas Date: Fri, 2 Jul 2021 21:00:57 -0400 Subject: [PATCH 425/496] this compiles but has a lot of indirection --- editor/src/lang/ast.rs | 12 +++++------- editor/src/lang/def.rs | 8 +++++--- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/editor/src/lang/ast.rs b/editor/src/lang/ast.rs index 9d8d413c88..f47fc68dda 100644 --- a/editor/src/lang/ast.rs +++ b/editor/src/lang/ast.rs @@ -219,9 +219,9 @@ pub enum Expr2 { #[derive(Debug)] pub enum ValueDef { WithAnnotation { - pattern_id: PatternId, // 4B - expr_id: ExprId, // 4B - type_id: TypeId, + pattern_id: PatternId, // 4B + expr_id: PoolVec, // 4B + type_id: PoolVec, rigids: NodeId, expr_var: Variable, // 4B }, @@ -241,14 +241,12 @@ impl ShallowClone for ValueDef { type_id, rigids, expr_var, - padding, } => Self::WithAnnotation { pattern_id: *pattern_id, - expr_id: *expr_id, - type_id: *type_id, + expr_id: expr_id.shallow_clone(), + type_id: type_id.shallow_clone(), rigids: *rigids, expr_var: *expr_var, - padding: *padding, }, Self::NoAnnotation { pattern_id, diff --git a/editor/src/lang/def.rs b/editor/src/lang/def.rs index f7f4deaa52..3b6d87b076 100644 --- a/editor/src/lang/def.rs +++ b/editor/src/lang/def.rs @@ -629,11 +629,13 @@ fn canonicalize_pending_def<'a>( let value_def = ValueDef::WithAnnotation { pattern_id: loc_can_pattern, - expr_id: env.pool.add(loc_can_expr), - type_id: annotation, + expr_id: PoolVec::new( + vec![env.pool.add(loc_can_expr)].into_iter(), + env.pool, + ), + type_id: PoolVec::new(vec![annotation].into_iter(), env.pool), rigids: env.pool.add(rigids), expr_var: env.var_store.fresh(), - padding: Default::default(), }; let def = Def::Value(value_def); From 197a34c41d3efc4c09e48015707629d0cb10b10c Mon Sep 17 00:00:00 2001 From: rvcas Date: Fri, 2 Jul 2021 21:24:34 -0400 Subject: [PATCH 426/496] fix: accidentally used experimental feature --- editor/src/lang/def.rs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/editor/src/lang/def.rs b/editor/src/lang/def.rs index 3b6d87b076..c9ae1bfc4a 100644 --- a/editor/src/lang/def.rs +++ b/editor/src/lang/def.rs @@ -46,13 +46,13 @@ impl Def { match self { Def::AnnotationOnly { .. } => todo!("lost pattern information here ... "), - Def::Value( + Def::Value(value_def) => match value_def { ValueDef::WithAnnotation { pattern_id, .. } - | ValueDef::NoAnnotation { pattern_id, .. }, - ) => { - let pattern2 = &pool[*pattern_id]; - output.extend(symbols_from_pattern(pool, pattern2)); - } + | ValueDef::NoAnnotation { pattern_id, .. } => { + let pattern2 = &pool[*pattern_id]; + output.extend(symbols_from_pattern(pool, pattern2)); + } + }, Def::Function(function_def) => match function_def { FunctionDef::NoAnnotation { name, .. } | FunctionDef::WithAnnotation { name, .. } => { From f46a5fe4a897c2248ecdc587a1bebceea8d94b9e Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Sat, 3 Jul 2021 16:48:20 +0200 Subject: [PATCH 427/496] Added editor ideas and inspiration --- editor/editor-ideas.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/editor/editor-ideas.md b/editor/editor-ideas.md index 42593da5bb..547d120f05 100644 --- a/editor/editor-ideas.md +++ b/editor/editor-ideas.md @@ -32,6 +32,8 @@ Nice collection of research on innovative editors, [link](https://futureofcoding * [Primitive](https://primitive.io/) code exploration in Virtual Reality * [Luna](https://www.luna-lang.org/) language for interactive data processing and visualization * [Hazel Livelits](https://hazel.org/papers/livelits-paper.pdf) interactive plugins, see GIF's [here](https://twitter.com/disconcision/status/1408155781120376833). +* [Thorough review](https://drossbucket.com/2021/06/30/hacker-news-folk-wisdom-on-visual-programming/) of pros and cons of text versus visual programming. + ### Debugging * [VS code debug visualization](https://marketplace.visualstudio.com/items?itemName=hediet.debug-visualizer) @@ -44,6 +46,8 @@ Nice collection of research on innovative editors, [link](https://futureofcoding e.g. you have a test `calculate_sum_test` that only uses the function `add`, when the test fails you should be able to see a diff showing only what changed for the function `add`. It would also be great to have a diff of [expression values](https://homepages.cwi.nl/~storm/livelit/images/bret.png) Bret Victor style. An ambitious project would be to suggest or automatically try fixes based on these diffs. * I think it could be possible to create a minimal reproduction of a program / block of code / code used by a single test. So for a failing unit test I would expect it to extract imports, the platform, types and functions that are necessary to run only that unit test and put them in a standalone roc project. This would be useful for sharing bugs with library+application authors and colleagues, for profiling or debugging with all "clutter" removed. * Ability to share program state at a breakpoint with someone else. +* For debugging we should aim for maximal useful observability. For example Rust's enum values can not be easily viewed in the CodeLLDB debugger, you actually need to call a print method that does pattern matching to be able to view useful information. +* We previuously discussed recording full traces of programs so they do not have to be re-run multiple times in the debugging process. We should encourage roc developers to experiment with creating debugging representations of this AST+"execution trace", it could lead to some cool stuff. ### Cool regular editors @@ -71,6 +75,7 @@ e.g. you have a test `calculate_sum_test` that only uses the function `add`, whe * [Sourcetrail](https://www.sourcetrail.com/) nice tree-like source explorer. * [Unisonweb](https://www.unisonweb.org), definition based [editor](https://twitter.com/shojberg/status/1364666092598288385) as opposed to file based. * [Utopia](https://utopia.app/) integrated design and development environment for React. Design and code update each other, in real time. +* [Paredit](https://calva.io/paredit/) structural clojure editing, navigation and selection. [Another overview](http://danmidwood.com/content/2014/11/21/animated-paredit.html) ### Voice Interaction Related From 8deb377d30128eebd96090725b3a63705b904aa0 Mon Sep 17 00:00:00 2001 From: Eric Correia Date: Sat, 3 Jul 2021 12:06:48 -0400 Subject: [PATCH 428/496] tag must be its own type fix --- compiler/mono/src/ir.rs | 21 +++++++++++---------- compiler/test_gen/src/gen_tags.rs | 17 +++++++++++++++++ 2 files changed, 28 insertions(+), 10 deletions(-) diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 94877e4ad0..9729d7b27d 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -4126,17 +4126,18 @@ fn convert_tag_union<'a>( hole, ), ByteUnion(tag_names) => { - let tag_id = tag_names - .iter() - .position(|key| key == &tag_name) - .expect("tag must be in its own type"); + let opt_tag_id = tag_names.iter().position(|key| key == &tag_name); + // .expect("tag must be in its own type"); - Stmt::Let( - assigned, - Expr::Literal(Literal::Byte(tag_id as u8)), - Layout::Builtin(Builtin::Int8), - hole, - ) + match opt_tag_id { + Some(tag_id) => Stmt::Let( + assigned, + Expr::Literal(Literal::Byte(tag_id as u8)), + Layout::Builtin(Builtin::Int8), + hole, + ), + None => Stmt::RuntimeError("tag must be in its own type"), + } } Newtype { diff --git a/compiler/test_gen/src/gen_tags.rs b/compiler/test_gen/src/gen_tags.rs index 776c06ff07..cfd11b807f 100644 --- a/compiler/test_gen/src/gen_tags.rs +++ b/compiler/test_gen/src/gen_tags.rs @@ -1033,3 +1033,20 @@ fn applied_tag_function_linked_list() { i64 ); } + +#[test] +#[should_panic(expected = "")] +fn tag_must_be_its_own_type() { + assert_evals_to!( + indoc!( + r#" + z : [ A, B, C ] + z = Z + + z + "# + ), + 1, + i64 + ); +} From aa123635fa23c022f24f8b285ee04efc88df4e27 Mon Sep 17 00:00:00 2001 From: Eric Correia Date: Sat, 3 Jul 2021 12:08:42 -0400 Subject: [PATCH 429/496] remove comment --- compiler/mono/src/ir.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 9729d7b27d..87080476cb 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -4127,7 +4127,6 @@ fn convert_tag_union<'a>( ), ByteUnion(tag_names) => { let opt_tag_id = tag_names.iter().position(|key| key == &tag_name); - // .expect("tag must be in its own type"); match opt_tag_id { Some(tag_id) => Stmt::Let( From 16542f0e1e0a98a30ad296fcd15d466b6fee2608 Mon Sep 17 00:00:00 2001 From: rvcas Date: Sat, 3 Jul 2021 13:04:38 -0400 Subject: [PATCH 430/496] test: incompatible type params in if --- compiler/test_gen/src/gen_list.rs | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/compiler/test_gen/src/gen_list.rs b/compiler/test_gen/src/gen_list.rs index b6384a8ba5..9a964c3213 100644 --- a/compiler/test_gen/src/gen_list.rs +++ b/compiler/test_gen/src/gen_list.rs @@ -1939,3 +1939,23 @@ fn list_sort_with() { RocList ); } + +#[test] +#[should_panic(expected = r#"Roc failed with message: "invalid ret_layout""#)] +fn lists_with_incompatible_type_param_in_if() { + assert_evals_to!( + indoc!( + r#" + list1 = [ {} ] + + list2 = [ "" ] + + x = if True then list1 else list2 + + "" + "# + ), + RocStr::empty(), + RocStr + ); +} From 39d39c218f2c71886ecbd3c07449c463c0bc9467 Mon Sep 17 00:00:00 2001 From: rvcas Date: Sat, 3 Jul 2021 13:05:30 -0400 Subject: [PATCH 431/496] feat(mono): return Stmt::RuntimeError on bad layouts for If --- compiler/mono/src/ir.rs | 213 ++++++++++++++++++++-------------------- 1 file changed, 109 insertions(+), 104 deletions(-) diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 94877e4ad0..a1f595fcf0 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -3150,118 +3150,123 @@ pub fn with_hole<'a>( branches, final_else, } => { - let ret_layout = layout_cache - .from_var(env.arena, branch_var, env.subs) - .expect("invalid ret_layout"); - let cond_layout = layout_cache - .from_var(env.arena, cond_var, env.subs) - .expect("invalid cond_layout"); + match ( + layout_cache.from_var(env.arena, branch_var, env.subs), + layout_cache.from_var(env.arena, cond_var, env.subs), + ) { + (Ok(ret_layout), Ok(cond_layout)) => { + // if the hole is a return, then we don't need to merge the two + // branches together again, we can just immediately return + let is_terminated = matches!(hole, Stmt::Ret(_)); - // if the hole is a return, then we don't need to merge the two - // branches together again, we can just immediately return - let is_terminated = matches!(hole, Stmt::Ret(_)); + if is_terminated { + let terminator = hole; - if is_terminated { - let terminator = hole; + let mut stmt = with_hole( + env, + final_else.value, + branch_var, + procs, + layout_cache, + assigned, + terminator, + ); - let mut stmt = with_hole( - env, - final_else.value, - branch_var, - procs, - layout_cache, - assigned, - terminator, - ); + for (loc_cond, loc_then) in branches.into_iter().rev() { + let branching_symbol = env.unique_symbol(); - for (loc_cond, loc_then) in branches.into_iter().rev() { - let branching_symbol = env.unique_symbol(); + let then = with_hole( + env, + loc_then.value, + branch_var, + procs, + layout_cache, + assigned, + terminator, + ); - let then = with_hole( - env, - loc_then.value, - branch_var, - procs, - layout_cache, - assigned, - terminator, - ); + stmt = cond(env, branching_symbol, cond_layout, then, stmt, ret_layout); - stmt = cond(env, branching_symbol, cond_layout, then, stmt, ret_layout); + // add condition + stmt = with_hole( + env, + loc_cond.value, + cond_var, + procs, + layout_cache, + branching_symbol, + env.arena.alloc(stmt), + ); + } + stmt + } else { + let assigned_in_jump = env.unique_symbol(); + let id = JoinPointId(env.unique_symbol()); - // add condition - stmt = with_hole( - env, - loc_cond.value, - cond_var, - procs, - layout_cache, - branching_symbol, - env.arena.alloc(stmt), - ); - } - stmt - } else { - let assigned_in_jump = env.unique_symbol(); - let id = JoinPointId(env.unique_symbol()); - - let terminator = env - .arena - .alloc(Stmt::Jump(id, env.arena.alloc([assigned_in_jump]))); - - let mut stmt = with_hole( - env, - final_else.value, - branch_var, - procs, - layout_cache, - assigned_in_jump, - terminator, - ); - - for (loc_cond, loc_then) in branches.into_iter().rev() { - let branching_symbol = possible_reuse_symbol(env, procs, &loc_cond.value); - - let then = with_hole( - env, - loc_then.value, - branch_var, - procs, - layout_cache, - assigned_in_jump, - terminator, - ); - - stmt = cond(env, branching_symbol, cond_layout, then, stmt, ret_layout); - - // add condition - stmt = assign_to_symbol( - env, - procs, - layout_cache, - cond_var, - loc_cond, - branching_symbol, - stmt, - ); - } - - let layout = layout_cache - .from_var(env.arena, branch_var, env.subs) - .unwrap_or_else(|err| panic!("TODO turn fn_var into a RuntimeError {:?}", err)); - - let param = Param { - symbol: assigned, - layout, - borrow: false, - }; - - Stmt::Join { - id, - parameters: env.arena.alloc([param]), - remainder: env.arena.alloc(stmt), - body: hole, + let terminator = env + .arena + .alloc(Stmt::Jump(id, env.arena.alloc([assigned_in_jump]))); + + let mut stmt = with_hole( + env, + final_else.value, + branch_var, + procs, + layout_cache, + assigned_in_jump, + terminator, + ); + + for (loc_cond, loc_then) in branches.into_iter().rev() { + let branching_symbol = + possible_reuse_symbol(env, procs, &loc_cond.value); + + let then = with_hole( + env, + loc_then.value, + branch_var, + procs, + layout_cache, + assigned_in_jump, + terminator, + ); + + stmt = cond(env, branching_symbol, cond_layout, then, stmt, ret_layout); + + // add condition + stmt = assign_to_symbol( + env, + procs, + layout_cache, + cond_var, + loc_cond, + branching_symbol, + stmt, + ); + } + + let layout = layout_cache + .from_var(env.arena, branch_var, env.subs) + .unwrap_or_else(|err| { + panic!("TODO turn fn_var into a RuntimeError {:?}", err) + }); + + let param = Param { + symbol: assigned, + layout, + borrow: false, + }; + + Stmt::Join { + id, + parameters: env.arena.alloc([param]), + remainder: env.arena.alloc(stmt), + body: hole, + } + } } + (Err(_), _) => Stmt::RuntimeError("invalid ret_layout"), + (_, Err(_)) => Stmt::RuntimeError("invalid cond_layout"), } } From 3fa5b4363e8caecaf8818e37be9639e04ca66ea9 Mon Sep 17 00:00:00 2001 From: rvcas Date: Sat, 3 Jul 2021 14:23:21 -0400 Subject: [PATCH 432/496] feat(cli): do not run executable if build failed --- cli/src/build.rs | 9 ++++++--- cli/src/lib.rs | 5 ++++- 2 files changed, 10 insertions(+), 4 deletions(-) diff --git a/cli/src/build.rs b/cli/src/build.rs index a1f3add2bc..26ddc1e37c 100644 --- a/cli/src/build.rs +++ b/cli/src/build.rs @@ -204,12 +204,15 @@ pub fn build_file<'a>( let total_time = compilation_start.elapsed().unwrap(); + // TODO change this to report whether there were errors or warnings! + let outcome = match &cmd_result { + Ok(exit_status) if exit_status.success() => BuildOutcome::NoProblems, + _ => BuildOutcome::Errors, + }; + // If the cmd errored out, return the Err. cmd_result?; - // TODO change this to report whether there were errors or warnings! - let outcome = BuildOutcome::NoProblems; - Ok(BuiltFile { binary_path, outcome, diff --git a/cli/src/lib.rs b/cli/src/lib.rs index a86c3ec56c..d5a80eb53f 100644 --- a/cli/src/lib.rs +++ b/cli/src/lib.rs @@ -231,7 +231,10 @@ pub fn build(target: &Triple, matches: &ArgMatches, config: BuildConfig) -> io:: } } - roc_run(cmd.current_dir(original_cwd)) + match outcome { + BuildOutcome::Errors => Ok(2), + _ => roc_run(cmd.current_dir(original_cwd)), + } } } } From a82b403aa41c3d100cf9bf2e9255704892afaac5 Mon Sep 17 00:00:00 2001 From: rvcas Date: Sat, 3 Jul 2021 14:41:58 -0400 Subject: [PATCH 433/496] feat(cli): impl BuildOutcome::status_code --- cli/src/build.rs | 10 ++++++++++ cli/src/lib.rs | 12 +++--------- 2 files changed, 13 insertions(+), 9 deletions(-) diff --git a/cli/src/build.rs b/cli/src/build.rs index 26ddc1e37c..1682aff916 100644 --- a/cli/src/build.rs +++ b/cli/src/build.rs @@ -26,6 +26,16 @@ pub enum BuildOutcome { Errors, } +impl BuildOutcome { + pub fn status_code(&self) -> i32 { + match self { + Self::NoProblems => 0, + Self::OnlyWarnings => 1, + Self::Errors => 2, + } + } +} + pub struct BuiltFile { pub binary_path: PathBuf, pub outcome: BuildOutcome, diff --git a/cli/src/lib.rs b/cli/src/lib.rs index d5a80eb53f..1cd2ea0eab 100644 --- a/cli/src/lib.rs +++ b/cli/src/lib.rs @@ -196,13 +196,6 @@ pub fn build(target: &Triple, matches: &ArgMatches, config: BuildConfig) -> io:: .strip_prefix(env::current_dir().unwrap()) .unwrap_or(&binary_path); - // Return a nonzero exit code if there were problems - let status_code = match outcome { - BuildOutcome::NoProblems => 0, - BuildOutcome::OnlyWarnings => 1, - BuildOutcome::Errors => 2, - }; - // No need to waste time freeing this memory, // since the process is about to exit anyway. std::mem::forget(arena); @@ -213,7 +206,8 @@ pub fn build(target: &Triple, matches: &ArgMatches, config: BuildConfig) -> io:: total_time.as_millis() ); - Ok(status_code) + // Return a nonzero exit code if there were problems + Ok(outcome.status_code()) } BuildAndRun { roc_file_arg_index } => { let mut cmd = Command::new(binary_path); @@ -232,7 +226,7 @@ pub fn build(target: &Triple, matches: &ArgMatches, config: BuildConfig) -> io:: } match outcome { - BuildOutcome::Errors => Ok(2), + BuildOutcome::Errors => Ok(outcome.status_code()), _ => roc_run(cmd.current_dir(original_cwd)), } } From 62d56335469da8907524a3b9a0b6ec753b021d3d Mon Sep 17 00:00:00 2001 From: Chadtech Date: Sat, 3 Jul 2021 14:51:40 -0400 Subject: [PATCH 434/496] Fixed problems with docs failing to render and included test to validate that behavior --- Cargo.lock | 1 + compiler/can/src/module.rs | 20 ++---- compiler/load/src/docs.rs | 5 +- compiler/load/src/effect_module.rs | 4 +- compiler/load/src/file.rs | 15 ++-- docs/Cargo.toml | 1 + docs/src/lib.rs | 110 +++++++++++++++-------------- docs/tests/insert_links.rs | 43 +++++++++++ 8 files changed, 120 insertions(+), 79 deletions(-) create mode 100644 docs/tests/insert_links.rs diff --git a/Cargo.lock b/Cargo.lock index 0b9b0b0c1c..f0b1a3fe97 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3139,6 +3139,7 @@ dependencies = [ "roc_load", "roc_module", "roc_region", + "roc_types", ] [[package]] diff --git a/compiler/can/src/module.rs b/compiler/can/src/module.rs index 2b45a14f32..345bb0853e 100644 --- a/compiler/can/src/module.rs +++ b/compiler/can/src/module.rs @@ -20,7 +20,7 @@ use roc_types::types::Alias; pub struct Module { pub module_id: ModuleId, pub exposed_imports: MutMap, - pub exposed_symbols: Vec, + pub exposed_symbols: MutSet, pub references: MutSet, pub aliases: MutMap, pub rigid_variables: MutMap, @@ -50,7 +50,7 @@ pub fn canonicalize_module_defs<'a, F>( dep_idents: MutMap, aliases: MutMap, exposed_imports: MutMap, - exposed_symbols: &Vec, + exposed_symbols: &MutSet, var_store: &mut VarStore, look_up_builtin: F, ) -> Result @@ -203,11 +203,7 @@ where // we can see if there were any // exposed symbols which did not have // corresponding defs. - if let Some(index) = - exposed_but_not_defined.iter().position(|s| *s == *symbol) - { - exposed_but_not_defined.remove(index); - } + exposed_but_not_defined.remove(symbol); } } } @@ -220,11 +216,7 @@ where // we can see if there were any // exposed symbols which did not have // corresponding defs. - if let Some(index) = - exposed_but_not_defined.iter().position(|s| *s == *symbol) - { - exposed_but_not_defined.remove(index); - } + exposed_but_not_defined.remove(symbol); } } } @@ -252,9 +244,7 @@ where // we can see if there were any // exposed symbols which did not have // corresponding defs. - if let Some(index) = exposed_but_not_defined.iter().position(|s| *s == symbol) { - exposed_but_not_defined.remove(index); - } + exposed_but_not_defined.remove(&symbol); aliases.insert(symbol, alias); } diff --git a/compiler/load/src/docs.rs b/compiler/load/src/docs.rs index f8dae3f72f..1fa5db439d 100644 --- a/compiler/load/src/docs.rs +++ b/compiler/load/src/docs.rs @@ -123,7 +123,10 @@ fn detached_docs_from_comments_and_new_lines<'a>( } CommentOrNewline::LineComment(_) | CommentOrNewline::Newline => { - detached_docs.push(docs.clone()); + if !docs.is_empty() { + detached_docs.push(docs.clone()); + } + docs = String::new(); } } diff --git a/compiler/load/src/effect_module.rs b/compiler/load/src/effect_module.rs index 81be7ecf60..5dab90a4f8 100644 --- a/compiler/load/src/effect_module.rs +++ b/compiler/load/src/effect_module.rs @@ -48,7 +48,7 @@ pub fn build_effect_builtins( scope: &mut Scope, effect_symbol: Symbol, var_store: &mut VarStore, - exposed_symbols: &mut Vec, + exposed_symbols: &mut MutSet, declarations: &mut Vec, ) { for (_, f) in BUILTIN_EFFECT_FUNCTIONS.iter() { @@ -60,7 +60,7 @@ pub fn build_effect_builtins( var_store, ); - exposed_symbols.push(symbol); + exposed_symbols.insert(symbol); declarations.push(Declaration::Declare(def)); } } diff --git a/compiler/load/src/file.rs b/compiler/load/src/file.rs index 8e9533102f..86965ddc2d 100644 --- a/compiler/load/src/file.rs +++ b/compiler/load/src/file.rs @@ -487,9 +487,7 @@ fn start_phase<'a>( let exposed_symbols = state .exposed_symbols_by_module .remove(&module_id) - .expect("Could not find listener ID in exposed_symbols_by_module") - .into_iter() - .collect::>(); + .expect("Could not find listener ID in exposed_symbols_by_module"); let mut aliases = MutMap::default(); @@ -974,7 +972,7 @@ enum BuildTask<'a> { parsed: ParsedModule<'a>, module_ids: ModuleIds, dep_idents: MutMap, - exposed_symbols: Vec, + exposed_symbols: MutSet, aliases: MutMap, }, Solve { @@ -3503,8 +3501,8 @@ fn fabricate_effects_module<'a>( let mut declarations = Vec::new(); - let exposed_symbols: Vec = { - let mut exposed_symbols = Vec::new(); + let exposed_symbols: MutSet = { + let mut exposed_symbols = MutSet::default(); { for (ident, ann) in effect_entries { @@ -3536,8 +3534,7 @@ fn fabricate_effects_module<'a>( &mut var_store, annotation, ); - - exposed_symbols.push(symbol); + exposed_symbols.insert(symbol); declarations.push(Declaration::Declare(def)); } @@ -3651,7 +3648,7 @@ fn canonicalize_and_constrain<'a, F>( arena: &'a Bump, module_ids: &ModuleIds, dep_idents: MutMap, - exposed_symbols: Vec, + exposed_symbols: MutSet, aliases: MutMap, parsed: ParsedModule<'a>, look_up_builtins: F, diff --git a/docs/Cargo.toml b/docs/Cargo.toml index 2b6c47da05..d57e99ece4 100644 --- a/docs/Cargo.toml +++ b/docs/Cargo.toml @@ -14,6 +14,7 @@ roc_builtins = { path = "../compiler/builtins" } roc_can = { path = "../compiler/can" } roc_module = { path = "../compiler/module" } roc_region = { path = "../compiler/region" } +roc_types = { path = "../compiler/types" } roc_collections = { path = "../compiler/collections" } bumpalo = { version = "3.2", features = ["collections"] } diff --git a/docs/src/lib.rs b/docs/src/lib.rs index 7973bd23dd..facb4644f1 100644 --- a/docs/src/lib.rs +++ b/docs/src/lib.rs @@ -163,9 +163,8 @@ fn render_main_content( } } DocEntry::DetachedDoc(docs) => { - buf.push_str( - markdown_to_html(&mut module.scope, interns, docs.to_string()).as_str(), - ); + let markdown = markdown_to_html(&mut module.scope, interns, docs.to_string()); + buf.push_str(markdown.as_str()); } }; } @@ -526,7 +525,7 @@ fn type_annotation_to_html(indent_level: usize, buf: &mut String, type_ann: &Typ } } -fn insert_doc_links(scope: &mut Scope, interns: &Interns, markdown: String) -> String { +pub fn insert_doc_links(scope: &mut Scope, interns: &Interns, markdown: String) -> String { let buf = &markdown; let mut result = String::new(); @@ -572,7 +571,11 @@ fn insert_doc_links(scope: &mut Scope, interns: &Interns, markdown: String) -> S } } - result + if chomping_from == None { + markdown + } else { + result + } } fn make_doc_link(scope: &mut Scope, interns: &Interns, doc_item: &str) -> String { @@ -619,62 +622,65 @@ fn markdown_to_html(scope: &mut Scope, interns: &Interns, markdown: String) -> S let mut docs_parser = vec![]; let (_, _) = pulldown_cmark::Parser::new_ext(&markdown_with_links, markdown_options).fold( (0, 0), - |(start_quote_count, end_quote_count), event| match event { - // Replace this sequence (`>>>` syntax): - // Start(BlockQuote) - // Start(BlockQuote) - // Start(BlockQuote) - // Start(Paragraph) - // For `Start(CodeBlock(Fenced(Borrowed("roc"))))` - Event::Start(BlockQuote) => { - docs_parser.push(event); - (start_quote_count + 1, 0) - } - Event::Start(Paragraph) => { - if start_quote_count == 3 { - docs_parser.pop(); - docs_parser.pop(); - docs_parser.pop(); - docs_parser.push(Event::Start(CodeBlock(CodeBlockKind::Fenced( - CowStr::Borrowed("roc"), - )))); - } else { + |(start_quote_count, end_quote_count), event| { + match event { + // Replace this sequence (`>>>` syntax): + // Start(BlockQuote) + // Start(BlockQuote) + // Start(BlockQuote) + // Start(Paragraph) + // For `Start(CodeBlock(Fenced(Borrowed("roc"))))` + Event::Start(BlockQuote) => { docs_parser.push(event); + (start_quote_count + 1, 0) } - (0, 0) - } - // Replace this sequence (`>>>` syntax): - // End(Paragraph) - // End(BlockQuote) - // End(BlockQuote) - // End(BlockQuote) - // For `End(CodeBlock(Fenced(Borrowed("roc"))))` - Event::End(Paragraph) => { - docs_parser.push(event); - (0, 1) - } - Event::End(BlockQuote) => { - if end_quote_count == 3 { - docs_parser.pop(); - docs_parser.pop(); - docs_parser.pop(); - docs_parser.push(Event::End(CodeBlock(CodeBlockKind::Fenced( - CowStr::Borrowed("roc"), - )))); + Event::Start(Paragraph) => { + if start_quote_count == 3 { + docs_parser.pop(); + docs_parser.pop(); + docs_parser.pop(); + docs_parser.push(Event::Start(CodeBlock(CodeBlockKind::Fenced( + CowStr::Borrowed("roc"), + )))); + } else { + docs_parser.push(event); + } + (0, 0) + } + // Replace this sequence (`>>>` syntax): + // End(Paragraph) + // End(BlockQuote) + // End(BlockQuote) + // End(BlockQuote) + // For `End(CodeBlock(Fenced(Borrowed("roc"))))` + Event::End(Paragraph) => { + docs_parser.push(event); + (0, 1) + } + Event::End(BlockQuote) => { + if end_quote_count == 3 { + docs_parser.pop(); + docs_parser.pop(); + docs_parser.pop(); + docs_parser.push(Event::End(CodeBlock(CodeBlockKind::Fenced( + CowStr::Borrowed("roc"), + )))); + (0, 0) + } else { + docs_parser.push(event); + (0, end_quote_count + 1) + } + } + _ => { + docs_parser.push(event); (0, 0) - } else { - docs_parser.push(event); - (0, end_quote_count + 1) } - } - _ => { - docs_parser.push(event); - (0, 0) } }, ); let mut docs_html = String::new(); + pulldown_cmark::html::push_html(&mut docs_html, docs_parser.into_iter()); docs_html diff --git a/docs/tests/insert_links.rs b/docs/tests/insert_links.rs new file mode 100644 index 0000000000..e01e3eca5b --- /dev/null +++ b/docs/tests/insert_links.rs @@ -0,0 +1,43 @@ +#[macro_use] +extern crate pretty_assertions; + +#[cfg(test)] +mod insert_doc_links { + use roc_can::env::Env; + use roc_can::scope::Scope; + use roc_collections::all::MutMap; + use roc_docs::insert_doc_links; + use roc_module::symbol::{IdentIds, Interns, ModuleIds}; + use roc_types::subs::VarStore; + + #[test] + fn no_doc_links() { + let home = ModuleIds::default().get_or_insert(&"Test".into()); + + let module_ids = ModuleIds::default(); + + let dep_idents = IdentIds::exposed_builtins(0); + + let env = Env::new(home, dep_idents, &module_ids, IdentIds::default()); + + let all_ident_ids = MutMap::default(); + + let interns = Interns { + module_ids: env.module_ids.clone(), + all_ident_ids, + }; + + let var_store = &mut VarStore::default(); + let scope = &mut Scope::new(home, var_store); + + let markdown = r#" + # Hello + Hello thanks for using my package + "#; + + assert_eq!( + markdown, + insert_doc_links(scope, &interns, markdown.to_string()), + ); + } +} From fe7e492572b61590209e91f2006fe76fd07ac8db Mon Sep 17 00:00:00 2001 From: rvcas Date: Sat, 3 Jul 2021 14:54:05 -0400 Subject: [PATCH 435/496] chore: cleaner way to check status code --- cli/src/build.rs | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/cli/src/build.rs b/cli/src/build.rs index 1682aff916..d75bf0361b 100644 --- a/cli/src/build.rs +++ b/cli/src/build.rs @@ -214,14 +214,15 @@ pub fn build_file<'a>( let total_time = compilation_start.elapsed().unwrap(); - // TODO change this to report whether there were errors or warnings! - let outcome = match &cmd_result { - Ok(exit_status) if exit_status.success() => BuildOutcome::NoProblems, - _ => BuildOutcome::Errors, - }; - // If the cmd errored out, return the Err. - cmd_result?; + let exit_status = cmd_result?; + + // TODO change this to report whether there were errors or warnings! + let outcome = if exit_status.success() { + BuildOutcome::NoProblems + } else { + BuildOutcome::Errors + }; Ok(BuiltFile { binary_path, From b2792af5f652872adfe7f65c2562455b96467520 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 4 Jul 2021 15:10:32 +0200 Subject: [PATCH 436/496] add helper function --- compiler/mono/src/decision_tree.rs | 7 +------ compiler/mono/src/layout.rs | 9 +++++++++ 2 files changed, 10 insertions(+), 6 deletions(-) diff --git a/compiler/mono/src/decision_tree.rs b/compiler/mono/src/decision_tree.rs index c991118612..67621e1001 100644 --- a/compiler/mono/src/decision_tree.rs +++ b/compiler/mono/src/decision_tree.rs @@ -217,12 +217,7 @@ fn flatten<'a>( tag_id, tag_name, layout, - } if union.alternatives.len() == 1 - && !matches!( - layout, - UnionLayout::NullableWrapped { .. } | UnionLayout::NullableUnwrapped { .. } - ) => - { + } if union.alternatives.len() == 1 && !layout.is_nullable() => { // TODO ^ do we need to check that guard.is_none() here? let path = path_pattern.0; diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index 6152b73304..f55063eb97 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -186,6 +186,15 @@ impl<'a> UnionLayout<'a> { UnionLayout::NonNullableUnwrapped(_) | UnionLayout::NullableUnwrapped { .. } => false, } } + + pub fn is_nullable(&self) -> bool { + match self { + UnionLayout::NonRecursive(_) + | UnionLayout::Recursive(_) + | UnionLayout::NonNullableUnwrapped { .. } => true, + UnionLayout::NullableWrapped { .. } | UnionLayout::NullableUnwrapped { .. } => true, + } + } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] From b99f710c4980ebaa4005be9daf0bf0d063e9b85f Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 4 Jul 2021 20:12:50 +0200 Subject: [PATCH 437/496] refactor --- compiler/mono/src/decision_tree.rs | 24 +++++++++++++++--------- 1 file changed, 15 insertions(+), 9 deletions(-) diff --git a/compiler/mono/src/decision_tree.rs b/compiler/mono/src/decision_tree.rs index 67621e1001..51f481f36b 100644 --- a/compiler/mono/src/decision_tree.rs +++ b/compiler/mono/src/decision_tree.rs @@ -155,19 +155,25 @@ fn to_decision_tree(raw_branches: Vec) -> DecisionTree { .map(|(a, b)| (a, to_decision_tree(b))) .collect(); - match (decision_edges.split_last_mut(), fallback.split_last()) { - (Some(((_tag, decision_tree), rest)), None) if rest.is_empty() => { - // TODO remove clone - decision_tree.clone() + match (decision_edges.as_slice(), fallback.as_slice()) { + ([(_test, _decision_tree)], []) => { + // only one test with no fallback: we will always enter this branch + + // get the `_decision_tree` without cloning + decision_edges.pop().unwrap().1 } - (_, None) => DecisionTree::Decision { - path: path.clone(), + (_, []) => DecisionTree::Decision { + path, edges: decision_edges, default: None, }, - (None, Some(_)) => to_decision_tree(fallback), - _ => DecisionTree::Decision { - path: path.clone(), + ([], _) => { + // should be guaranteed by the patterns + debug_assert!(!fallback.is_empty()); + to_decision_tree(fallback) + } + (_, _) => DecisionTree::Decision { + path, edges: decision_edges, default: Some(Box::new(to_decision_tree(fallback))), }, From e7c88cac980abec977eced711b305591efb5ad15 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 4 Jul 2021 21:17:57 +0200 Subject: [PATCH 438/496] refactor guards --- compiler/mono/src/decision_tree.rs | 209 +++++++++++++++++- compiler/test_gen/src/gen_tags.rs | 19 ++ .../generated/guard_pattern_true.txt | 14 +- 3 files changed, 230 insertions(+), 12 deletions(-) diff --git a/compiler/mono/src/decision_tree.rs b/compiler/mono/src/decision_tree.rs index 51f481f36b..863001fc72 100644 --- a/compiler/mono/src/decision_tree.rs +++ b/compiler/mono/src/decision_tree.rs @@ -933,6 +933,17 @@ fn small_branching_factor(branches: &[Branch], path: &[PathInstruction]) -> usiz #[derive(Clone, Debug, PartialEq)] enum Decider<'a, T> { Leaf(T), + Guarded { + /// Symbol that stores a boolean + /// when true this branch is picked, otherwise skipped + symbol: Symbol, + /// after assigning to symbol, the stmt jumps to this label + id: JoinPointId, + stmt: Stmt<'a>, + + success: Box>, + failure: Box>, + }, Chain { test_chain: Vec<(Vec, Test<'a>)>, success: Box>, @@ -1532,6 +1543,62 @@ fn decide_to_branching<'a>( Stmt::Jump(jumps[index].1, &[]) } Leaf(Inline(expr)) => expr, + Guarded { + symbol, + id, + stmt, + success, + failure, + } => { + // the guard is the final thing that we check, so needs to be layered on first! + let test_symbol = env.unique_symbol(); + let arena = env.arena; + + let pass_expr = decide_to_branching( + env, + procs, + layout_cache, + cond_symbol, + cond_layout, + ret_layout, + *success, + jumps, + ); + + let fail_expr = decide_to_branching( + env, + procs, + layout_cache, + cond_symbol, + cond_layout, + ret_layout, + *failure, + jumps, + ); + + let decide = crate::ir::cond( + env, + test_symbol, + Layout::Builtin(Builtin::Int1), + pass_expr, + fail_expr, + ret_layout, + ); + + // calculate the guard value + let param = Param { + symbol: test_symbol, + layout: Layout::Builtin(Builtin::Int1), + borrow: false, + }; + + Stmt::Join { + id, + parameters: arena.alloc([param]), + remainder: arena.alloc(stmt), + body: arena.alloc(decide), + } + } Chain { test_chain, success, @@ -1566,6 +1633,8 @@ fn decide_to_branching<'a>( let (tests, guard) = stores_and_condition(env, cond_symbol, &cond_layout, test_chain); + debug_assert!(guard.is_none()); + let number_of_tests = tests.len() as i64 + guard.is_some() as i64; debug_assert!(number_of_tests > 0); @@ -1792,23 +1861,75 @@ fn tree_to_decider(tree: DecisionTree) -> Decider { if test_always_succeeds(&test) { tree_to_decider(success_tree) + } else if let Test::Guarded { + symbol, + id, + stmt, + opt_test, + } = test + { + let failure = Box::new(tree_to_decider(failure_tree)); + let success = Box::new(tree_to_decider(success_tree)); + + let guarded = Decider::Guarded { + symbol, + id, + stmt, + success, + failure: failure.clone(), + }; + + match opt_test { + Some(test) => Chain { + test_chain: vec![(path, *test)], + success: Box::new(guarded), + failure, + }, + None => guarded, + } } else { to_chain(path, test, success_tree, failure_tree) } } _ => { - let fallback = edges.remove(edges.len() - 1).1; + let fallback_tree = edges.remove(edges.len() - 1).1; + let fallback_decider = tree_to_decider(fallback_tree); let necessary_tests = edges .into_iter() - .map(|(test, decider)| (test, tree_to_decider(decider))) + .map(|(test, dectree)| { + let decider = tree_to_decider(dectree); + + if let Test::Guarded { + symbol, + id, + stmt, + opt_test, + } = test + { + let guarded = Decider::Guarded { + symbol, + id, + stmt, + success: Box::new(decider), + failure: Box::new(fallback_decider.clone()), + }; + + match opt_test { + Some(test) => (*test, guarded), + None => todo!(), + } + } else { + (test, decider) + } + }) .collect(); FanOut { path, tests: necessary_tests, - fallback: Box::new(tree_to_decider(fallback)), + fallback: Box::new(fallback_decider), } } }, @@ -1821,6 +1942,32 @@ fn tree_to_decider(tree: DecisionTree) -> Decider { if test_always_succeeds(&test) { tree_to_decider(success_tree) + } else if let Test::Guarded { + symbol, + id, + stmt, + opt_test, + } = test + { + let failure = Box::new(tree_to_decider(failure_tree)); + let success = Box::new(tree_to_decider(success_tree)); + + let guarded = Decider::Guarded { + symbol, + id, + stmt, + success, + failure: failure.clone(), + }; + + match opt_test { + Some(test) => Chain { + test_chain: vec![(path, *test)], + success: Box::new(guarded), + failure, + }, + None => guarded, + } } else { to_chain(path, test, success_tree, failure_tree) } @@ -1828,16 +1975,47 @@ fn tree_to_decider(tree: DecisionTree) -> Decider { _ => { let fallback = *last; + let fallback_decider = tree_to_decider(fallback); + + // let necessary_tests = edges + // .into_iter() + // .map(|(test, decider)| (test, tree_to_decider(decider))) + // .collect(); let necessary_tests = edges .into_iter() - .map(|(test, decider)| (test, tree_to_decider(decider))) + .map(|(test, dectree)| { + let decider = tree_to_decider(dectree); + + if let Test::Guarded { + symbol, + id, + stmt, + opt_test, + } = test + { + let guarded = Decider::Guarded { + symbol, + id, + stmt, + success: Box::new(decider), + failure: Box::new(fallback_decider.clone()), + }; + + match opt_test { + Some(test) => (*test, guarded), + None => todo!(), + } + } else { + (test, decider) + } + }) .collect(); FanOut { path, tests: necessary_tests, - fallback: Box::new(tree_to_decider(fallback)), + fallback: Box::new(fallback_decider), } } }, @@ -1894,6 +2072,13 @@ fn count_targets(targets: &mut bumpalo::collections::Vec, initial: &Decider targets[*target as usize] += 1; } + Guarded { + success, failure, .. + } => { + stack.push(success); + stack.push(failure); + } + Chain { success, failure, .. } => { @@ -1942,6 +2127,20 @@ fn insert_choices<'a>( Leaf(choice_dict[&target].clone()) } + Guarded { + symbol, + id, + stmt, + success, + failure, + } => Guarded { + symbol, + id, + stmt, + success: Box::new(insert_choices(choice_dict, *success)), + failure: Box::new(insert_choices(choice_dict, *failure)), + }, + Chain { test_chain, success, diff --git a/compiler/test_gen/src/gen_tags.rs b/compiler/test_gen/src/gen_tags.rs index cfd11b807f..875c4d9f5f 100644 --- a/compiler/test_gen/src/gen_tags.rs +++ b/compiler/test_gen/src/gen_tags.rs @@ -468,6 +468,7 @@ fn nested_pattern_match() { i64 ); } + #[test] fn if_guard_pattern_false() { assert_evals_to!( @@ -486,6 +487,24 @@ fn if_guard_pattern_false() { ); } +#[test] +fn if_guard_switch() { + assert_evals_to!( + indoc!( + r#" + wrapper = \{} -> + when 2 is + 2 | 3 if False -> 0 + _ -> 42 + + wrapper {} + "# + ), + 42, + i64 + ); +} + #[test] fn if_guard_pattern_true() { assert_evals_to!( diff --git a/compiler/test_mono/generated/guard_pattern_true.txt b/compiler/test_mono/generated/guard_pattern_true.txt index ef390e692d..c0ee2f046d 100644 --- a/compiler/test_mono/generated/guard_pattern_true.txt +++ b/compiler/test_mono/generated/guard_pattern_true.txt @@ -1,23 +1,23 @@ procedure Test.1 (Test.3): let Test.6 = 2i64; - joinpoint Test.12: + joinpoint Test.11: let Test.10 = 0i64; ret Test.10; in - let Test.11 = 2i64; - let Test.14 = lowlevel Eq Test.11 Test.6; + let Test.13 = 2i64; + let Test.14 = lowlevel Eq Test.13 Test.6; if Test.14 then - joinpoint Test.8 Test.13: - if Test.13 then + joinpoint Test.8 Test.12: + if Test.12 then let Test.7 = 42i64; ret Test.7; else - jump Test.12; + jump Test.11; in let Test.9 = false; jump Test.8 Test.9; else - jump Test.12; + jump Test.11; procedure Test.0 (): let Test.5 = Struct {}; From 8f0c13ecc136a009415aba74625791ca31ca33cd Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 4 Jul 2021 21:19:39 +0200 Subject: [PATCH 439/496] remove old handling of guard --- compiler/mono/src/decision_tree.rs | 43 ++++++++++-------------------- 1 file changed, 14 insertions(+), 29 deletions(-) diff --git a/compiler/mono/src/decision_tree.rs b/compiler/mono/src/decision_tree.rs index 863001fc72..3bcddaba45 100644 --- a/compiler/mono/src/decision_tree.rs +++ b/compiler/mono/src/decision_tree.rs @@ -1443,17 +1443,11 @@ fn compile_tests<'a>( env: &mut Env<'a, '_>, ret_layout: Layout<'a>, tests: Tests<'a>, - opt_guard: Option<(Symbol, JoinPointId, Stmt<'a>)>, fail: &'a Stmt<'a>, mut cond: Stmt<'a>, ) -> Stmt<'a> { let arena = env.arena; - // the guard is the final thing that we check, so needs to be layered on first! - if let Some((_, id, stmt)) = opt_guard { - cond = compile_guard(env, ret_layout, id, arena.alloc(stmt), fail, cond); - } - for (new_stores, lhs, rhs, _layout, opt_constructor_info) in tests.into_iter() { match opt_constructor_info { None => { @@ -1631,11 +1625,9 @@ fn decide_to_branching<'a>( let chain_branch_info = ConstructorKnown::from_test_chain(cond_symbol, &cond_layout, &test_chain); - let (tests, guard) = stores_and_condition(env, cond_symbol, &cond_layout, test_chain); + let (tests, _) = stores_and_condition(env, cond_symbol, &cond_layout, test_chain); - debug_assert!(guard.is_none()); - - let number_of_tests = tests.len() as i64 + guard.is_some() as i64; + let number_of_tests = tests.len() as i64; debug_assert!(number_of_tests > 0); @@ -1643,32 +1635,25 @@ fn decide_to_branching<'a>( if number_of_tests == 1 { // if there is just one test, compile to a simple if-then-else - if guard.is_none() { - // use knowledge about constructors for optimization - debug_assert_eq!(tests.len(), 1); + let (new_stores, lhs, rhs, _layout, _cinfo) = tests.into_iter().next().unwrap(); - let (new_stores, lhs, rhs, _layout, _cinfo) = tests.into_iter().next().unwrap(); - - compile_test_help( - env, - chain_branch_info, - ret_layout, - new_stores, - lhs, - rhs, - fail, - pass_expr, - ) - } else { - compile_tests(env, ret_layout, tests, guard, fail, pass_expr) - } + compile_test_help( + env, + chain_branch_info, + ret_layout, + new_stores, + lhs, + rhs, + fail, + pass_expr, + ) } else { // otherwise, we use a join point so the code for the `else` case // is only generated once. let fail_jp_id = JoinPointId(env.unique_symbol()); let jump = arena.alloc(Stmt::Jump(fail_jp_id, &[])); - let test_stmt = compile_tests(env, ret_layout, tests, guard, jump, pass_expr); + let test_stmt = compile_tests(env, ret_layout, tests, jump, pass_expr); Stmt::Join { id: fail_jp_id, From 40bb078882a76b7e43abd10d815e6b30f90e2e87 Mon Sep 17 00:00:00 2001 From: rvcas Date: Sun, 4 Jul 2021 15:32:48 -0400 Subject: [PATCH 440/496] feat: adjust rigids to let it fit better in ValueDef --- editor/src/lang/ast.rs | 81 ++++++++++++++++++++++++++++++++++++------ editor/src/lang/def.rs | 69 ++++++++--------------------------- 2 files changed, 84 insertions(+), 66 deletions(-) diff --git a/editor/src/lang/ast.rs b/editor/src/lang/ast.rs index f47fc68dda..b5fbd154cc 100644 --- a/editor/src/lang/ast.rs +++ b/editor/src/lang/ast.rs @@ -1,11 +1,15 @@ #![allow(clippy::manual_map)] +use std::collections::{HashMap, HashSet}; +use std::hash::BuildHasherDefault; + use crate::lang::pattern::{Pattern2, PatternId}; use crate::lang::pool::Pool; use crate::lang::pool::{NodeId, PoolStr, PoolVec, ShallowClone}; use crate::lang::types::{Type2, TypeId}; use arraystring::{typenum::U30, ArrayString}; use roc_can::expr::Recursive; +use roc_collections::all::WyHash; use roc_module::low_level::LowLevel; use roc_module::operator::CalledVia; use roc_module::symbol::Symbol; @@ -219,10 +223,10 @@ pub enum Expr2 { #[derive(Debug)] pub enum ValueDef { WithAnnotation { - pattern_id: PatternId, // 4B - expr_id: PoolVec, // 4B - type_id: PoolVec, - rigids: NodeId, + pattern_id: PatternId, // 4B + expr_id: ExprId, // 4B + type_id: TypeId, + rigids: Rigids, expr_var: Variable, // 4B }, NoAnnotation { @@ -243,9 +247,9 @@ impl ShallowClone for ValueDef { expr_var, } => Self::WithAnnotation { pattern_id: *pattern_id, - expr_id: expr_id.shallow_clone(), - type_id: type_id.shallow_clone(), - rigids: *rigids, + expr_id: *expr_id, + type_id: *type_id, + rigids: rigids.shallow_clone(), expr_var: *expr_var, }, Self::NoAnnotation { @@ -312,8 +316,63 @@ impl ShallowClone for FunctionDef { #[derive(Debug)] pub struct Rigids { - pub named: PoolVec<(PoolStr, Variable)>, // 8B - pub unnamed: PoolVec, // 8B + pub names: PoolVec<(Option, Variable)>, // 8B + padding: [u8; 1], +} + +impl Rigids { + pub fn new( + named: HashMap<&str, Variable, BuildHasherDefault>, + unnamed: HashSet>, + pool: &mut Pool, + ) -> Self { + let names = PoolVec::with_capacity((named.len() + unnamed.len()) as u32, pool); + + let mut temp_names = Vec::new(); + + temp_names.extend(named.iter().map(|(name, var)| (Some(*name), *var))); + + temp_names.extend(unnamed.iter().map(|var| (None, *var))); + + for (node_id, (opt_name, variable)) in names.iter_node_ids().zip(temp_names) { + let poolstr = opt_name.map(|name| PoolStr::new(name, pool)); + + pool[node_id] = (poolstr, variable); + } + + Self { + names, + padding: Default::default(), + } + } + + pub fn named(&self, pool: &Pool) -> Vec<(PoolStr, Variable)> { + let mut named = Vec::new(); + + for node_id in self.names.iter_node_ids() { + let (opt_pool_str, var) = pool.get(node_id); + + if let Some(pool_str) = opt_pool_str { + named.push((*pool_str, *var)); + } + } + + named + } + + pub fn unnamed(&self, pool: &Pool) -> Vec { + let mut unnamed = Vec::new(); + + for node_id in self.names.iter_node_ids() { + let (opt_pool_str, var) = pool.get(node_id); + + if opt_pool_str.is_none() { + unnamed.push(*var); + } + } + + unnamed + } } /// This is overflow data from a Closure variant, which needs to store @@ -499,8 +558,8 @@ fn size_of_expr() { impl ShallowClone for Rigids { fn shallow_clone(&self) -> Self { Self { - named: self.named.shallow_clone(), - unnamed: self.unnamed.shallow_clone(), + names: self.names.shallow_clone(), + padding: self.padding, } } } diff --git a/editor/src/lang/def.rs b/editor/src/lang/def.rs index c9ae1bfc4a..84dfbb9ba6 100644 --- a/editor/src/lang/def.rs +++ b/editor/src/lang/def.rs @@ -318,23 +318,7 @@ fn from_pending_alias<'a>( } } - let named = PoolVec::with_capacity(named_rigids.len() as u32, env.pool); - let unnamed = PoolVec::with_capacity(unnamed_rigids.len() as u32, env.pool); - - for (node_id, (name, variable)) in named.iter_node_ids().zip(named_rigids) { - let poolstr = PoolStr::new(name, env.pool); - - env.pool[node_id] = (poolstr, variable); - } - - for (node_id, rigid) in unnamed.iter_node_ids().zip(unnamed_rigids) { - env.pool[node_id] = rigid; - } - - let rigids = Rigids { - named: named.shallow_clone(), - unnamed, - }; + let rigids = Rigids::new(named_rigids, unnamed_rigids, env.pool); let annotation = match signature { Signature::Value { annotation } => annotation, @@ -358,14 +342,20 @@ fn from_pending_alias<'a>( rec_type_union.substitute_alias(env.pool, symbol, Type2::Variable(rec_var)); let annotation_id = env.add(rec_type_union, ann.region); - scope.add_alias(env.pool, symbol, named, annotation_id); + let named = rigids.named(env.pool); + let named_pool_vec = PoolVec::new(named.into_iter(), env.pool); + + scope.add_alias(env.pool, symbol, named_pool_vec, annotation_id); } else { env.problem(Problem::CyclicAlias(symbol, name.region, vec![])); return output; } } else { let annotation_id = env.add(annotation, ann.region); - scope.add_alias(env.pool, symbol, named, annotation_id); + let named = rigids.named(env.pool); + let named_pool_vec = PoolVec::new(named.into_iter(), env.pool); + + scope.add_alias(env.pool, symbol, named_pool_vec, annotation_id); } output @@ -410,21 +400,7 @@ fn canonicalize_pending_def<'a>( output.references.referenced_aliases.insert(symbol); } - let rigids = { - let named = PoolVec::with_capacity(named_rigids.len() as u32, env.pool); - let unnamed = PoolVec::with_capacity(unnamed_rigids.len() as u32, env.pool); - - for (node_id, (name, variable)) in named.iter_node_ids().zip(named_rigids) { - let poolstr = PoolStr::new(name, env.pool); - env.pool[node_id] = (poolstr, variable); - } - - for (node_id, rigid) in unnamed.iter_node_ids().zip(unnamed_rigids) { - env.pool[node_id] = rigid; - } - - Rigids { named, unnamed } - }; + let rigids = Rigids::new(named_rigids, unnamed_rigids, env.pool); let annotation = match signature { Signature::Value { annotation } => annotation, @@ -473,21 +449,7 @@ fn canonicalize_pending_def<'a>( output.references.referenced_aliases.insert(symbol); } - let rigids = { - let named = PoolVec::with_capacity(named_rigids.len() as u32, env.pool); - let unnamed = PoolVec::with_capacity(unnamed_rigids.len() as u32, env.pool); - - for (node_id, (name, variable)) in named.iter_node_ids().zip(named_rigids) { - let poolstr = PoolStr::new(name, env.pool); - env.pool[node_id] = (poolstr, variable); - } - - for (node_id, rigid) in unnamed.iter_node_ids().zip(unnamed_rigids) { - env.pool[node_id] = rigid; - } - - Rigids { named, unnamed } - }; + let rigids = Rigids::new(named_rigids, unnamed_rigids, env.pool); // bookkeeping for tail-call detection. If we're assigning to an // identifier (e.g. `f = \x -> ...`), then this symbol can be tail-called. @@ -629,12 +591,9 @@ fn canonicalize_pending_def<'a>( let value_def = ValueDef::WithAnnotation { pattern_id: loc_can_pattern, - expr_id: PoolVec::new( - vec![env.pool.add(loc_can_expr)].into_iter(), - env.pool, - ), - type_id: PoolVec::new(vec![annotation].into_iter(), env.pool), - rigids: env.pool.add(rigids), + expr_id: env.pool.add(loc_can_expr), + type_id: annotation, + rigids: rigids, expr_var: env.var_store.fresh(), }; From d4da68e1d470cc91e3d6eb90e01e83c33afbf446 Mon Sep 17 00:00:00 2001 From: rvcas Date: Sun, 4 Jul 2021 15:58:59 -0400 Subject: [PATCH 441/496] feat: use filter_map --- editor/src/lang/ast.rs | 40 ++++++++++++++++++++++------------------ 1 file changed, 22 insertions(+), 18 deletions(-) diff --git a/editor/src/lang/ast.rs b/editor/src/lang/ast.rs index b5fbd154cc..c1f9ca9bf5 100644 --- a/editor/src/lang/ast.rs +++ b/editor/src/lang/ast.rs @@ -347,29 +347,33 @@ impl Rigids { } pub fn named(&self, pool: &Pool) -> Vec<(PoolStr, Variable)> { - let mut named = Vec::new(); - - for node_id in self.names.iter_node_ids() { - let (opt_pool_str, var) = pool.get(node_id); - - if let Some(pool_str) = opt_pool_str { - named.push((*pool_str, *var)); - } - } + let named = self + .names + .iter(pool) + .filter_map(|(opt_pool_str, var)| { + if let Some(pool_str) = opt_pool_str { + Some((*pool_str, *var)) + } else { + None + } + }) + .collect(); named } pub fn unnamed(&self, pool: &Pool) -> Vec { - let mut unnamed = Vec::new(); - - for node_id in self.names.iter_node_ids() { - let (opt_pool_str, var) = pool.get(node_id); - - if opt_pool_str.is_none() { - unnamed.push(*var); - } - } + let unnamed = self + .names + .iter(pool) + .filter_map(|(opt_pool_str, var)| { + if opt_pool_str.is_none() { + Some(*var) + } else { + None + } + }) + .collect(); unnamed } From 1349da3f39c2948e93c30b1d172bfae1bff57cc9 Mon Sep 17 00:00:00 2001 From: rvcas Date: Sun, 4 Jul 2021 16:08:48 -0400 Subject: [PATCH 442/496] feat: return PoolVec directly, duplication seems inevitable --- editor/src/lang/ast.rs | 12 ++++++------ editor/src/lang/def.rs | 6 ++---- 2 files changed, 8 insertions(+), 10 deletions(-) diff --git a/editor/src/lang/ast.rs b/editor/src/lang/ast.rs index c1f9ca9bf5..4585b04ff4 100644 --- a/editor/src/lang/ast.rs +++ b/editor/src/lang/ast.rs @@ -346,7 +346,7 @@ impl Rigids { } } - pub fn named(&self, pool: &Pool) -> Vec<(PoolStr, Variable)> { + pub fn named(&self, pool: &mut Pool) -> PoolVec<(PoolStr, Variable)> { let named = self .names .iter(pool) @@ -357,12 +357,12 @@ impl Rigids { None } }) - .collect(); + .collect::>(); - named + PoolVec::new(named.into_iter(), pool) } - pub fn unnamed(&self, pool: &Pool) -> Vec { + pub fn unnamed(&self, pool: &mut Pool) -> PoolVec { let unnamed = self .names .iter(pool) @@ -373,9 +373,9 @@ impl Rigids { None } }) - .collect(); + .collect::>(); - unnamed + PoolVec::new(unnamed.into_iter(), pool) } } diff --git a/editor/src/lang/def.rs b/editor/src/lang/def.rs index 84dfbb9ba6..0cd3b25ba0 100644 --- a/editor/src/lang/def.rs +++ b/editor/src/lang/def.rs @@ -343,9 +343,8 @@ fn from_pending_alias<'a>( let annotation_id = env.add(rec_type_union, ann.region); let named = rigids.named(env.pool); - let named_pool_vec = PoolVec::new(named.into_iter(), env.pool); - scope.add_alias(env.pool, symbol, named_pool_vec, annotation_id); + scope.add_alias(env.pool, symbol, named, annotation_id); } else { env.problem(Problem::CyclicAlias(symbol, name.region, vec![])); return output; @@ -353,9 +352,8 @@ fn from_pending_alias<'a>( } else { let annotation_id = env.add(annotation, ann.region); let named = rigids.named(env.pool); - let named_pool_vec = PoolVec::new(named.into_iter(), env.pool); - scope.add_alias(env.pool, symbol, named_pool_vec, annotation_id); + scope.add_alias(env.pool, symbol, named, annotation_id); } output From 879bea2339d597757db53f5413498588600142df Mon Sep 17 00:00:00 2001 From: rvcas Date: Sun, 4 Jul 2021 16:16:50 -0400 Subject: [PATCH 443/496] chore: clippy is wrong :p --- editor/src/lang/ast.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/editor/src/lang/ast.rs b/editor/src/lang/ast.rs index 4585b04ff4..d0d42ad1b6 100644 --- a/editor/src/lang/ast.rs +++ b/editor/src/lang/ast.rs @@ -320,6 +320,7 @@ pub struct Rigids { padding: [u8; 1], } +#[allow(clippy::needless_collect)] impl Rigids { pub fn new( named: HashMap<&str, Variable, BuildHasherDefault>, From 2c0aa8a5a1ab1ac337e312a92ecf95fbab09aef6 Mon Sep 17 00:00:00 2001 From: Folkert Date: Sun, 4 Jul 2021 22:35:00 +0200 Subject: [PATCH 444/496] handle guards in a first-class way --- compiler/mono/src/decision_tree.rs | 469 ++++++++++++++--------------- 1 file changed, 234 insertions(+), 235 deletions(-) diff --git a/compiler/mono/src/decision_tree.rs b/compiler/mono/src/decision_tree.rs index 3bcddaba45..e1987709c1 100644 --- a/compiler/mono/src/decision_tree.rs +++ b/compiler/mono/src/decision_tree.rs @@ -17,7 +17,7 @@ const RECORD_TAG_NAME: &str = "#Record"; /// some normal branches and gives out a decision tree that has "labels" at all /// the leafs and a dictionary that maps these "labels" to the code that should /// run. -pub fn compile<'a>(raw_branches: Vec<(Guard<'a>, Pattern<'a>, u64)>) -> DecisionTree<'a> { +fn compile<'a>(raw_branches: Vec<(Guard<'a>, Pattern<'a>, u64)>) -> DecisionTree<'a> { let formatted = raw_branches .into_iter() .map(|(guard, pattern, index)| Branch { @@ -49,15 +49,35 @@ impl<'a> Guard<'a> { } #[derive(Clone, Debug, PartialEq)] -pub enum DecisionTree<'a> { +enum DecisionTree<'a> { Match(Label), Decision { path: Vec, - edges: Vec<(Test<'a>, DecisionTree<'a>)>, + edges: Vec<(GuardedTest<'a>, DecisionTree<'a>)>, default: Option>>, }, } +#[derive(Clone, Debug, PartialEq)] +pub enum GuardedTest<'a> { + TestGuarded { + test: Test<'a>, + + /// after assigning to symbol, the stmt jumps to this label + id: JoinPointId, + stmt: Stmt<'a>, + }, + // e.g. `_ if True -> ...` + GuardedNoTest { + /// after assigning to symbol, the stmt jumps to this label + id: JoinPointId, + stmt: Stmt<'a>, + }, + TestNotGuarded { + test: Test<'a>, + }, +} + #[derive(Clone, Debug, PartialEq)] pub enum Test<'a> { IsCtor { @@ -75,16 +95,6 @@ pub enum Test<'a> { tag_id: u8, num_alts: usize, }, - // A pattern that always succeeds (like `_`) can still have a guard - Guarded { - opt_test: Option>>, - /// Symbol that stores a boolean - /// when true this branch is picked, otherwise skipped - symbol: Symbol, - /// after assigning to symbol, the stmt jumps to this label - id: JoinPointId, - stmt: Stmt<'a>, - }, } use std::hash::{Hash, Hasher}; impl<'a> Hash for Test<'a> { @@ -118,15 +128,23 @@ impl<'a> Hash for Test<'a> { tag_id.hash(state); num_alts.hash(state); } - Guarded { opt_test: None, .. } => { - state.write_u8(6); + } + } +} + +impl<'a> Hash for GuardedTest<'a> { + fn hash(&self, state: &mut H) { + match self { + GuardedTest::TestGuarded { test, .. } => { + state.write_u8(0); + test.hash(state); } - Guarded { - opt_test: Some(nested), - .. - } => { - state.write_u8(7); - nested.hash(state); + GuardedTest::GuardedNoTest { id, stmt } => { + state.write_u8(1); + } + GuardedTest::TestNotGuarded { test } => { + state.write_u8(2); + test.hash(state); } } } @@ -182,20 +200,32 @@ fn to_decision_tree(raw_branches: Vec) -> DecisionTree { } } -fn is_complete(tests: &[Test]) -> bool { +fn guarded_tests_are_complete(tests: &[GuardedTest]) -> bool { let length = tests.len(); debug_assert!(length > 0); - match tests.last() { - None => unreachable!("should never happen"), - Some(v) => match v { - Test::IsCtor { union, .. } => length == union.alternatives.len(), - Test::IsByte { num_alts, .. } => length == *num_alts, - Test::IsBit(_) => length == 2, - Test::IsInt(_) => false, - Test::IsFloat(_) => false, - Test::IsStr(_) => false, - Test::Guarded { .. } => false, - }, + + match tests.last().unwrap() { + GuardedTest::TestGuarded { .. } => false, + GuardedTest::GuardedNoTest { .. } => false, + GuardedTest::TestNotGuarded { test } => tests_are_complete_help(test, length), + } +} + +fn tests_are_complete(tests: &[Test]) -> bool { + let length = tests.len(); + debug_assert!(length > 0); + + tests_are_complete_help(tests.last().unwrap(), length) +} + +fn tests_are_complete_help(last_test: &Test, number_of_tests: usize) -> bool { + match last_test { + Test::IsCtor { union, .. } => number_of_tests == union.alternatives.len(), + Test::IsByte { num_alts, .. } => number_of_tests == *num_alts, + Test::IsBit(_) => number_of_tests == 2, + Test::IsInt(_) => false, + Test::IsFloat(_) => false, + Test::IsStr(_) => false, } } @@ -293,10 +323,10 @@ fn check_for_match(branches: &[Branch]) -> Option