diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index 4d016a3e3c..381477e925 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -1,12 +1,8 @@ on: - pull_request: + workflow_call: name: Benchmarks -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: true - env: RUST_BACKTRACE: 1 ROC_NUM_WORKERS: 1 diff --git a/.github/workflows/ci_cleanup.yml b/.github/workflows/ci_cleanup.yml index 65e774b6a8..80e3f9aecd 100644 --- a/.github/workflows/ci_cleanup.yml +++ b/.github/workflows/ci_cleanup.yml @@ -1,4 +1,5 @@ on: + workflow_dispatch: schedule: - cron: '0 5 * * 1' diff --git a/.github/workflows/ci_cleanup_nix_mac.yml b/.github/workflows/ci_cleanup_nix_mac.yml new file mode 100644 index 0000000000..cde4f24580 --- /dev/null +++ b/.github/workflows/ci_cleanup_nix_mac.yml @@ -0,0 +1,17 @@ +on: + workflow_dispatch: + schedule: + - cron: '0 5 * * *' + +name: Clean up nix on mac mini m1 + +jobs: + clean-mac-mini-arm64: + runs-on: [self-hosted, macOS, ARM64] + timeout-minutes: 120 + steps: + - name: Clean up nix store + run: nix-store --gc + + - name: Clean up old nix shells + run: rm -rf /private/tmp/nix-shell.* diff --git a/.github/workflows/ci_manager.yml b/.github/workflows/ci_manager.yml new file mode 100644 index 0000000000..6ac4d57843 --- /dev/null +++ b/.github/workflows/ci_manager.yml @@ -0,0 +1,99 @@ +on: + pull_request: + +name: CI manager + +# cancel current runs when a new commit is pushed +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + check-changes: + runs-on: ubuntu-22.04 + outputs: + run_tests: ${{ steps.filecheck.outputs.run_tests }} + steps: + - name: Checkout + uses: actions/checkout@v3 + + - name: Check if only css, html or md files changed + id: filecheck + run: | + git fetch origin ${{ github.base_ref }} + if git diff --name-only origin/${{ github.base_ref }} HEAD | grep -qvE '(\.md$|\.css$|\.html$)'; then + echo "run_tests=full" >> $GITHUB_OUTPUT + else + echo "run_tests=none" >> $GITHUB_OUTPUT + fi + + - run: echo "debug output ${{ steps.filecheck.outputs.run_tests }}" + + start-nix-linux-x86-64-tests: + needs: check-changes + if: needs.check-changes.outputs.run_tests == 'full' + uses: ./.github/workflows/nix_linux_x86_64.yml + + start-nix-linux-aarch64-build-default-test: + needs: check-changes + if: needs.check-changes.outputs.run_tests == 'full' + uses: ./.github/workflows/nix_linux_arm64_default.yml + + start-nix-linux-aarch64-cargo-build-test: + needs: check-changes + if: needs.check-changes.outputs.run_tests == 'full' + uses: ./.github/workflows/nix_linux_arm64_cargo.yml + + start-nix-macos-apple-silicon-tests: + needs: check-changes + if: needs.check-changes.outputs.run_tests == 'full' + uses: ./.github/workflows/nix_macos_apple_silicon.yml + + start-macos-x86-64-tests: + needs: check-changes + if: needs.check-changes.outputs.run_tests == 'full' + uses: ./.github/workflows/ubuntu_x86_64.yml + + start-ubuntu-x86-64-tests: + needs: check-changes + if: needs.check-changes.outputs.run_tests == 'full' + uses: ./.github/workflows/ubuntu_x86_64.yml + + start-windows-release-build-test: + needs: check-changes + if: needs.check-changes.outputs.run_tests == 'full' + uses: ./.github/workflows/windows_release_build.yml + + start-windows-tests: + needs: check-changes + if: needs.check-changes.outputs.run_tests == 'full' + uses: ./.github/workflows/windows_tests.yml + + start-roc-benchmarks: + needs: check-changes + if: needs.check-changes.outputs.run_tests == 'full' + uses: ./.github/workflows/benchmarks.yml + + finish-full: + runs-on: ubuntu-22.04 + needs: [ + start-nix-linux-x86-64-tests, + start-nix-linux-aarch64-build-default-test, + start-nix-linux-aarch64-cargo-build-test, + start-nix-macos-apple-silicon-tests, + start-macos-x86-64-tests, + start-ubuntu-x86-64-tests, + start-windows-release-build-test, + start-windows-tests, + start-roc-benchmarks + ] + steps: + - run: echo "all workflows succeeded!" + + finish-none: + runs-on: ubuntu-22.04 + needs: [check-changes] + if: needs.check-changes.outputs.run_tests == 'none' + steps: + - run: echo "Only non-code files changed. CI manager did not run any workflows." + \ No newline at end of file diff --git a/.github/workflows/devtools_test_linux_x86_64.yml b/.github/workflows/devtools_test_linux_x86_64.yml index bc4eb36b60..7aa613b8e8 100644 --- a/.github/workflows/devtools_test_linux_x86_64.yml +++ b/.github/workflows/devtools_test_linux_x86_64.yml @@ -1,11 +1,11 @@ on: - pull_request: + pull_request: name: devtools nix files test - linux concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: true + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true jobs: devtools-test-linux: diff --git a/.github/workflows/devtools_test_macos_apple_silicon.yml b/.github/workflows/devtools_test_macos_apple_silicon.yml index 874e2c026f..2abed8eac4 100644 --- a/.github/workflows/devtools_test_macos_apple_silicon.yml +++ b/.github/workflows/devtools_test_macos_apple_silicon.yml @@ -1,11 +1,11 @@ on: - pull_request: + pull_request: name: devtools nix files test - macos concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: true + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true jobs: devtools-test-macos: diff --git a/.github/workflows/macos_x86_64.yml b/.github/workflows/macos_x86_64.yml index 809d7a02cf..a8b88390b4 100644 --- a/.github/workflows/macos_x86_64.yml +++ b/.github/workflows/macos_x86_64.yml @@ -1,12 +1,8 @@ on: - pull_request: + workflow_call: name: Macos x86-64 rust tests -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: true - env: RUST_BACKTRACE: 1 diff --git a/.github/workflows/nix_linux_arm64_cargo.yml b/.github/workflows/nix_linux_arm64_cargo.yml index 52dfde0a2e..488d6af721 100644 --- a/.github/workflows/nix_linux_arm64_cargo.yml +++ b/.github/workflows/nix_linux_arm64_cargo.yml @@ -1,12 +1,8 @@ on: - pull_request: + workflow_call: name: test cargo build on linux arm64 inside nix -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: true - env: RUST_BACKTRACE: 1 diff --git a/.github/workflows/nix_linux_arm64_default.yml b/.github/workflows/nix_linux_arm64_default.yml index be06485367..0352fc3fd8 100644 --- a/.github/workflows/nix_linux_arm64_default.yml +++ b/.github/workflows/nix_linux_arm64_default.yml @@ -1,12 +1,8 @@ on: - pull_request: + workflow_call: name: test default.nix on linux arm64 -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: true - env: RUST_BACKTRACE: 1 diff --git a/.github/workflows/nix_linux_x86_64.yml b/.github/workflows/nix_linux_x86_64.yml index 417674e926..f3f957f70d 100644 --- a/.github/workflows/nix_linux_x86_64.yml +++ b/.github/workflows/nix_linux_x86_64.yml @@ -1,12 +1,8 @@ on: - pull_request: + workflow_call: name: Nix linux x86_64 cargo test -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: true - env: RUST_BACKTRACE: 1 diff --git a/.github/workflows/nix_macos_apple_silicon.yml b/.github/workflows/nix_macos_apple_silicon.yml index f885c4ca7b..baac08bc4f 100644 --- a/.github/workflows/nix_macos_apple_silicon.yml +++ b/.github/workflows/nix_macos_apple_silicon.yml @@ -1,12 +1,8 @@ on: - pull_request: + workflow_call: name: Nix apple silicon cargo test -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: true - env: RUST_BACKTRACE: 1 diff --git a/.github/workflows/nix_macos_x86_64.yml b/.github/workflows/nix_macos_x86_64.yml index bad8246bb6..8fde16b746 100644 --- a/.github/workflows/nix_macos_x86_64.yml +++ b/.github/workflows/nix_macos_x86_64.yml @@ -1,12 +1,8 @@ on: - pull_request: + workflow_call: name: Nix macOS x86_64 cargo test -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: true - env: RUST_BACKTRACE: 1 diff --git a/.github/workflows/ubuntu_x86_64.yml b/.github/workflows/ubuntu_x86_64.yml index 462b297778..d5c6338e0c 100644 --- a/.github/workflows/ubuntu_x86_64.yml +++ b/.github/workflows/ubuntu_x86_64.yml @@ -1,12 +1,8 @@ on: - pull_request: + workflow_call: name: CI -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: true - env: RUST_BACKTRACE: 1 diff --git a/.github/workflows/windows_release_build.yml b/.github/workflows/windows_release_build.yml index 3fbff61d00..ef67101b4f 100644 --- a/.github/workflows/windows_release_build.yml +++ b/.github/workflows/windows_release_build.yml @@ -1,12 +1,8 @@ on: - pull_request: + workflow_call: name: windows - release build -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: true - env: RUST_BACKTRACE: 1 diff --git a/.github/workflows/windows_tests.yml b/.github/workflows/windows_tests.yml index 78f574be64..8271303b62 100644 --- a/.github/workflows/windows_tests.yml +++ b/.github/workflows/windows_tests.yml @@ -1,12 +1,8 @@ on: - pull_request: + workflow_call: name: windows - subset of tests -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: true - env: RUST_BACKTRACE: 1 diff --git a/Earthfile b/Earthfile index 50ddf63938..ae0df6e89c 100644 --- a/Earthfile +++ b/Earthfile @@ -34,7 +34,7 @@ install-zig-llvm: RUN apt -y install libssl-dev RUN OPENSSL_NO_VENDOR=1 cargo install wasm-pack # sccache - RUN cargo install sccache + RUN cargo install sccache --locked RUN sccache -V ENV RUSTC_WRAPPER=/usr/local/cargo/bin/sccache ENV SCCACHE_DIR=/earthbuild/sccache_dir diff --git a/README.md b/README.md index 619b596bf4..315dcbae72 100644 --- a/README.md +++ b/README.md @@ -30,6 +30,9 @@ If you would like your company to become a corporate sponsor of Roc's developmen We'd also like to express our gratitude to our generous [individual sponsors](https://github.com/sponsors/roc-lang/)! A special thanks to those sponsoring $25/month or more: +* [Drew Lazzeri](https://github.com/asteroidb612) +* [Alex Binaei](https://github.com/mrmizz) +* [Jono Mallanyk](https://github.com/jonomallanyk) * [Chris Packett](https://github.com/chris-packett) * [James Birtles](https://github.com/jamesbirtles) * [Ivo Balbaert](https://github.com/Ivo-Balbaert) diff --git a/crates/cli/src/lib.rs b/crates/cli/src/lib.rs index d5c91b912c..f5ffeac79c 100644 --- a/crates/cli/src/lib.rs +++ b/crates/cli/src/lib.rs @@ -1136,19 +1136,6 @@ fn roc_dev_native( ) .unwrap(); - memory.reset(); - } - ChildProcessMsg::Dbg => { - roc_repl_expect::run::render_dbgs_in_memory( - &mut writer, - arena, - &mut expectations, - &interns, - &layout_interner, - &memory, - ) - .unwrap(); - memory.reset(); } } diff --git a/crates/cli/src/main.rs b/crates/cli/src/main.rs index 8cb445379d..9d6fc8af81 100644 --- a/crates/cli/src/main.rs +++ b/crates/cli/src/main.rs @@ -333,7 +333,10 @@ fn main() -> io::Result<()> { } } FormatMode::WriteToStdout => { - std::io::stdout().lock().write_all(src.as_bytes()).unwrap(); + std::io::stdout() + .lock() + .write_all(formatted_src.as_bytes()) + .unwrap(); 0 } diff --git a/crates/cli/tests/cli_run.rs b/crates/cli/tests/cli_run.rs index 05cdda1c06..80cf5548fd 100644 --- a/crates/cli/tests/cli_run.rs +++ b/crates/cli/tests/cli_run.rs @@ -562,11 +562,11 @@ mod cli_run { x : Num * x = 42 - [ 19:9] 42 - [ 20:9] "Fjoer en ferdjer frieten oan dyn geve lea" - [ 13:9] "abc" - [ 13:9] 10 - [ 13:9] A (B C) + [#UserApp] 42 + [#UserApp] "Fjoer en ferdjer frieten oan dyn geve lea" + [#UserApp] "abc" + [#UserApp] 10 + [#UserApp] (A (B C)) Program finished! "# ), @@ -873,7 +873,7 @@ mod cli_run { This roc file can print it's own source code. The source is: app "ingested-file" - packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.6.0/QOQW08n38nHHrVVkJNiPIjzjvbR3iMjXeFY5w1aT46w.tar.br" } + packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.7.0/bkGby8jb0tmZYsy2hg1E_B2QrCgcSTxdUlHtETwm5m4.tar.br" } imports [ pf.Stdout, "ingested-file.roc" as ownCode : Str, @@ -900,7 +900,7 @@ mod cli_run { &[], &[], &[], - "30256\n", + "30461\n", UseValgrind::No, TestCliCommands::Run, ) @@ -942,7 +942,7 @@ mod cli_run { test_roc_app_slim( "examples", "inspect-logging.roc", - r#"{people: [{firstName: "John", lastName: "Smith", age: 27, hasBeard: true, favoriteColor: Blue}, {firstName: "Debby", lastName: "Johnson", age: 47, hasBeard: false, favoriteColor: Green}, {firstName: "Jane", lastName: "Doe", age: 33, hasBeard: false, favoriteColor: (RGB (255, 255, 0))}], friends: [{2}, {2}, {0, 1}]} + r#"{friends: [{2}, {2}, {0, 1}], people: [{age: 27, favoriteColor: Blue, firstName: "John", hasBeard: Bool.true, lastName: "Smith"}, {age: 47, favoriteColor: Green, firstName: "Debby", hasBeard: Bool.false, lastName: "Johnson"}, {age: 33, favoriteColor: (RGB (255, 255, 0)), firstName: "Jane", hasBeard: Bool.false, lastName: "Doe"}]} "#, UseValgrind::Yes, ) diff --git a/crates/cli/tests/fixtures/multi-dep-str/platform/host.zig b/crates/cli/tests/fixtures/multi-dep-str/platform/host.zig index 5eed78fce5..6f91e049f8 100644 --- a/crates/cli/tests/fixtures/multi-dep-str/platform/host.zig +++ b/crates/cli/tests/fixtures/multi-dep-str/platform/host.zig @@ -38,13 +38,23 @@ export fn roc_memset(dst: [*]u8, value: i32, size: usize) callconv(.C) void { return memset(dst, value, size); } -export fn roc_panic(c_ptr: *anyopaque, tag_id: u32) callconv(.C) void { - _ = tag_id; - +export fn roc_panic(msg: *RocStr, tag_id: u32) callconv(.C) void { const stderr = std.io.getStdErr().writer(); - const msg = @as([*:0]const u8, @ptrCast(c_ptr)); - stderr.print("Application crashed with message\n\n {s}\n\nShutting down\n", .{msg}) catch unreachable; - std.process.exit(0); + switch (tag_id) { + 0 => { + stderr.print("Roc standard library crashed with message\n\n {s}\n\nShutting down\n", .{msg.asSlice()}) catch unreachable; + }, + 1 => { + stderr.print("Application crashed with message\n\n {s}\n\nShutting down\n", .{msg.asSlice()}) catch unreachable; + }, + else => unreachable, + } + std.process.exit(1); +} + +export fn roc_dbg(loc: *RocStr, msg: *RocStr) callconv(.C) void { + const stderr = std.io.getStdErr().writer(); + stderr.print("[{s}] {s}\n", .{ loc.asSlice(), msg.asSlice() }) catch unreachable; } extern fn kill(pid: c_int, sig: c_int) c_int; diff --git a/crates/cli/tests/fixtures/multi-dep-thunk/platform/host.zig b/crates/cli/tests/fixtures/multi-dep-thunk/platform/host.zig index cc2ed11250..a4a0ff9012 100644 --- a/crates/cli/tests/fixtures/multi-dep-thunk/platform/host.zig +++ b/crates/cli/tests/fixtures/multi-dep-thunk/platform/host.zig @@ -38,13 +38,23 @@ export fn roc_memset(dst: [*]u8, value: i32, size: usize) callconv(.C) void { return memset(dst, value, size); } -export fn roc_panic(c_ptr: *anyopaque, tag_id: u32) callconv(.C) void { - _ = tag_id; - +export fn roc_panic(msg: *RocStr, tag_id: u32) callconv(.C) void { const stderr = std.io.getStdErr().writer(); - const msg = @as([*:0]const u8, @ptrCast(c_ptr)); - stderr.print("Application crashed with message\n\n {s}\n\nShutting down\n", .{msg}) catch unreachable; - std.process.exit(0); + switch (tag_id) { + 0 => { + stderr.print("Roc standard library crashed with message\n\n {s}\n\nShutting down\n", .{msg.asSlice()}) catch unreachable; + }, + 1 => { + stderr.print("Application crashed with message\n\n {s}\n\nShutting down\n", .{msg.asSlice()}) catch unreachable; + }, + else => unreachable, + } + std.process.exit(1); +} + +export fn roc_dbg(loc: *RocStr, msg: *RocStr) callconv(.C) void { + const stderr = std.io.getStdErr().writer(); + stderr.print("[{s}] {s}\n", .{ loc.asSlice(), msg.asSlice() }) catch unreachable; } extern fn kill(pid: c_int, sig: c_int) c_int; diff --git a/crates/cli/tests/fixtures/packages/platform/host.zig b/crates/cli/tests/fixtures/packages/platform/host.zig index 5eed78fce5..6f91e049f8 100644 --- a/crates/cli/tests/fixtures/packages/platform/host.zig +++ b/crates/cli/tests/fixtures/packages/platform/host.zig @@ -38,13 +38,23 @@ export fn roc_memset(dst: [*]u8, value: i32, size: usize) callconv(.C) void { return memset(dst, value, size); } -export fn roc_panic(c_ptr: *anyopaque, tag_id: u32) callconv(.C) void { - _ = tag_id; - +export fn roc_panic(msg: *RocStr, tag_id: u32) callconv(.C) void { const stderr = std.io.getStdErr().writer(); - const msg = @as([*:0]const u8, @ptrCast(c_ptr)); - stderr.print("Application crashed with message\n\n {s}\n\nShutting down\n", .{msg}) catch unreachable; - std.process.exit(0); + switch (tag_id) { + 0 => { + stderr.print("Roc standard library crashed with message\n\n {s}\n\nShutting down\n", .{msg.asSlice()}) catch unreachable; + }, + 1 => { + stderr.print("Application crashed with message\n\n {s}\n\nShutting down\n", .{msg.asSlice()}) catch unreachable; + }, + else => unreachable, + } + std.process.exit(1); +} + +export fn roc_dbg(loc: *RocStr, msg: *RocStr) callconv(.C) void { + const stderr = std.io.getStdErr().writer(); + stderr.print("[{s}] {s}\n", .{ loc.asSlice(), msg.asSlice() }) catch unreachable; } extern fn kill(pid: c_int, sig: c_int) c_int; diff --git a/crates/cli_testing_examples/algorithms/fibonacci-platform/host.zig b/crates/cli_testing_examples/algorithms/fibonacci-platform/host.zig index 09fdde7ba2..8abd265eee 100644 --- a/crates/cli_testing_examples/algorithms/fibonacci-platform/host.zig +++ b/crates/cli_testing_examples/algorithms/fibonacci-platform/host.zig @@ -1,5 +1,7 @@ const std = @import("std"); const builtin = @import("builtin"); +const str = @import("glue").str; +const RocStr = str.RocStr; const testing = std.testing; const expectEqual = testing.expectEqual; const expect = testing.expect; @@ -50,13 +52,23 @@ export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void { free(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr)))); } -export fn roc_panic(c_ptr: *anyopaque, tag_id: u32) callconv(.C) void { - _ = tag_id; - +export fn roc_panic(msg: *RocStr, tag_id: u32) callconv(.C) void { const stderr = std.io.getStdErr().writer(); - const msg = @as([*:0]const u8, @ptrCast(c_ptr)); - stderr.print("Application crashed with message\n\n {s}\n\nShutting down\n", .{msg}) catch unreachable; - std.process.exit(0); + switch (tag_id) { + 0 => { + stderr.print("Roc standard library crashed with message\n\n {s}\n\nShutting down\n", .{msg.asSlice()}) catch unreachable; + }, + 1 => { + stderr.print("Application crashed with message\n\n {s}\n\nShutting down\n", .{msg.asSlice()}) catch unreachable; + }, + else => unreachable, + } + std.process.exit(1); +} + +export fn roc_dbg(loc: *RocStr, msg: *RocStr) callconv(.C) void { + const stderr = std.io.getStdErr().writer(); + stderr.print("[{s}] {s}\n", .{ loc.asSlice(), msg.asSlice() }) catch unreachable; } export fn roc_memset(dst: [*]u8, value: i32, size: usize) callconv(.C) void { diff --git a/crates/cli_testing_examples/algorithms/quicksort-platform/host.zig b/crates/cli_testing_examples/algorithms/quicksort-platform/host.zig index 61629ce077..138e276e21 100644 --- a/crates/cli_testing_examples/algorithms/quicksort-platform/host.zig +++ b/crates/cli_testing_examples/algorithms/quicksort-platform/host.zig @@ -49,13 +49,23 @@ export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void { free(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr)))); } -export fn roc_panic(c_ptr: *anyopaque, tag_id: u32) callconv(.C) void { - _ = tag_id; - +export fn roc_panic(msg: *RocStr, tag_id: u32) callconv(.C) void { const stderr = std.io.getStdErr().writer(); - const msg = @as([*:0]const u8, @ptrCast(c_ptr)); - stderr.print("Application crashed with message\n\n {s}\n\nShutting down\n", .{msg}) catch unreachable; - std.process.exit(0); + switch (tag_id) { + 0 => { + stderr.print("Roc standard library crashed with message\n\n {s}\n\nShutting down\n", .{msg.asSlice()}) catch unreachable; + }, + 1 => { + stderr.print("Application crashed with message\n\n {s}\n\nShutting down\n", .{msg.asSlice()}) catch unreachable; + }, + else => unreachable, + } + std.process.exit(1); +} + +export fn roc_dbg(loc: *RocStr, msg: *RocStr) callconv(.C) void { + const stderr = std.io.getStdErr().writer(); + stderr.print("[{s}] {s}\n", .{ loc.asSlice(), msg.asSlice() }) catch unreachable; } export fn roc_memset(dst: [*]u8, value: i32, size: usize) callconv(.C) void { diff --git a/crates/cli_testing_examples/benchmarks/platform/host.zig b/crates/cli_testing_examples/benchmarks/platform/host.zig index 2e590a0596..3362518568 100644 --- a/crates/cli_testing_examples/benchmarks/platform/host.zig +++ b/crates/cli_testing_examples/benchmarks/platform/host.zig @@ -54,13 +54,23 @@ export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void { free(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr)))); } -export fn roc_panic(c_ptr: *anyopaque, tag_id: u32) callconv(.C) void { - _ = tag_id; - +export fn roc_panic(msg: *RocStr, tag_id: u32) callconv(.C) void { const stderr = std.io.getStdErr().writer(); - const msg = @as([*:0]const u8, @ptrCast(c_ptr)); - stderr.print("Application crashed with message\n\n {s}\n\nShutting down\n", .{msg}) catch unreachable; - std.process.exit(0); + switch (tag_id) { + 0 => { + stderr.print("Roc standard library crashed with message\n\n {s}\n\nShutting down\n", .{msg.asSlice()}) catch unreachable; + }, + 1 => { + stderr.print("Application crashed with message\n\n {s}\n\nShutting down\n", .{msg.asSlice()}) catch unreachable; + }, + else => unreachable, + } + std.process.exit(1); +} + +export fn roc_dbg(loc: *RocStr, msg: *RocStr) callconv(.C) void { + const stderr = std.io.getStdErr().writer(); + stderr.print("[{s}] {s}\n", .{ loc.asSlice(), msg.asSlice() }) catch unreachable; } export fn roc_memset(dst: [*]u8, value: i32, size: usize) callconv(.C) void { diff --git a/crates/cli_testing_examples/expects/zig-platform/host.zig b/crates/cli_testing_examples/expects/zig-platform/host.zig index c8867e6f70..a830db2cb7 100644 --- a/crates/cli_testing_examples/expects/zig-platform/host.zig +++ b/crates/cli_testing_examples/expects/zig-platform/host.zig @@ -44,13 +44,18 @@ export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void { free(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr)))); } -export fn roc_panic(c_ptr: *anyopaque, tag_id: u32) callconv(.C) void { +export fn roc_panic(msg: *RocStr, tag_id: u32) callconv(.C) void { _ = tag_id; const stderr = std.io.getStdErr().writer(); - const msg = @as([*:0]const u8, @ptrCast(c_ptr)); - stderr.print("Application crashed with message\n\n {s}\n\nShutting down\n", .{msg}) catch unreachable; - std.process.exit(0); + stderr.print("Application crashed with message\n\n {s}\n\nShutting down\n", .{msg.asSlice()}) catch unreachable; + std.process.exit(1); +} + +export fn roc_dbg(loc: *RocStr, msg: *RocStr) callconv(.C) void { + // This platform uses stdout for testing purposes instead of the normal stderr. + const stdout = std.io.getStdOut().writer(); + stdout.print("[{s}] {s}\n", .{ loc.asSlice(), msg.asSlice() }) catch unreachable; } export fn roc_memset(dst: [*]u8, value: i32, size: usize) callconv(.C) void { diff --git a/crates/compiler/builtins/bitcode/benchmark/dec.zig b/crates/compiler/builtins/bitcode/benchmark/dec.zig index 996fb7458b..965d3bdd0c 100644 --- a/crates/compiler/builtins/bitcode/benchmark/dec.zig +++ b/crates/compiler/builtins/bitcode/benchmark/dec.zig @@ -11,10 +11,14 @@ fn roc_alloc(_: usize, _: u32) callconv(.C) ?*anyopaque { fn roc_panic(_: *anyopaque, _: u32) callconv(.C) void { @panic("Not needed for dec benchmark"); } +fn roc_dbg(_: *anyopaque, _: *anyopaque) callconv(.C) void { + @panic("Not needed for dec benchmark"); +} comptime { @export(roc_alloc, .{ .name = "roc_alloc", .linkage = .Strong }); @export(roc_panic, .{ .name = "roc_panic", .linkage = .Strong }); + @export(roc_dbg, .{ .name = "roc_dbg", .linkage = .Strong }); } var timer: Timer = undefined; @@ -100,16 +104,16 @@ pub fn main() !void { const f64Atan = try avg_runs(f64, n, atanF64, f1); try stdout.print("\n\nDec/F64:\n", .{}); - try stdout.print("addition: {d:0.2}\n", .{@intToFloat(f64, decAdd) / @intToFloat(f64, f64Add)}); - try stdout.print("subtraction: {d:0.2}\n", .{@intToFloat(f64, decSub) / @intToFloat(f64, f64Sub)}); - try stdout.print("multiplication: {d:0.2}\n", .{@intToFloat(f64, decMul) / @intToFloat(f64, f64Mul)}); - try stdout.print("division: {d:0.2}\n", .{@intToFloat(f64, decDiv) / @intToFloat(f64, f64Div)}); - try stdout.print("sin: {d:0.2}\n", .{@intToFloat(f64, decSin) / @intToFloat(f64, f64Sin)}); - try stdout.print("cos: {d:0.2}\n", .{@intToFloat(f64, decCos) / @intToFloat(f64, f64Cos)}); - try stdout.print("tan: {d:0.2}\n", .{@intToFloat(f64, decTan) / @intToFloat(f64, f64Tan)}); - try stdout.print("asin: {d:0.2}\n", .{@intToFloat(f64, decAsin) / @intToFloat(f64, f64Asin)}); - try stdout.print("acos: {d:0.2}\n", .{@intToFloat(f64, decAcos) / @intToFloat(f64, f64Acos)}); - try stdout.print("atan: {d:0.2}\n", .{@intToFloat(f64, decAtan) / @intToFloat(f64, f64Atan)}); + try stdout.print("addition: {d:0.2}\n", .{@as(f64, @floatFromInt(decAdd)) / @as(f64, @floatFromInt(f64Add))}); + try stdout.print("subtraction: {d:0.2}\n", .{@as(f64, @floatFromInt(decSub)) / @as(f64, @floatFromInt(f64Sub))}); + try stdout.print("multiplication: {d:0.2}\n", .{@as(f64, @floatFromInt(decMul)) / @as(f64, @floatFromInt(f64Mul))}); + try stdout.print("division: {d:0.2}\n", .{@as(f64, @floatFromInt(decDiv)) / @as(f64, @floatFromInt(f64Div))}); + try stdout.print("sin: {d:0.2}\n", .{@as(f64, @floatFromInt(decSin)) / @as(f64, @floatFromInt(f64Sin))}); + try stdout.print("cos: {d:0.2}\n", .{@as(f64, @floatFromInt(decCos)) / @as(f64, @floatFromInt(f64Cos))}); + try stdout.print("tan: {d:0.2}\n", .{@as(f64, @floatFromInt(decTan)) / @as(f64, @floatFromInt(f64Tan))}); + try stdout.print("asin: {d:0.2}\n", .{@as(f64, @floatFromInt(decAsin)) / @as(f64, @floatFromInt(f64Asin))}); + try stdout.print("acos: {d:0.2}\n", .{@as(f64, @floatFromInt(decAcos)) / @as(f64, @floatFromInt(f64Acos))}); + try stdout.print("atan: {d:0.2}\n", .{@as(f64, @floatFromInt(decAtan)) / @as(f64, @floatFromInt(f64Atan))}); } fn avg_runs(comptime T: type, comptime n: usize, comptime op: fn (T, T) T, v: T) !u64 { diff --git a/crates/compiler/builtins/bitcode/src/expect.zig b/crates/compiler/builtins/bitcode/src/expect.zig index 70328e65aa..7ae9826c1d 100644 --- a/crates/compiler/builtins/bitcode/src/expect.zig +++ b/crates/compiler/builtins/bitcode/src/expect.zig @@ -96,7 +96,3 @@ pub fn notifyParent(shared_buffer: [*]u8, tag: u32) callconv(.C) void { pub fn notifyParentExpect(shared_buffer: [*]u8) callconv(.C) void { notifyParent(shared_buffer, 1); } - -pub fn notifyParentDbg(shared_buffer: [*]u8) callconv(.C) void { - notifyParent(shared_buffer, 2); -} diff --git a/crates/compiler/builtins/bitcode/src/main.zig b/crates/compiler/builtins/bitcode/src/main.zig index 8979819f9b..5fa5fa73f5 100644 --- a/crates/compiler/builtins/bitcode/src/main.zig +++ b/crates/compiler/builtins/bitcode/src/main.zig @@ -230,6 +230,7 @@ comptime { // Utils comptime { + exportUtilsFn(utils.test_dbg, "test_dbg"); exportUtilsFn(utils.test_panic, "test_panic"); exportUtilsFn(utils.increfRcPtrC, "incref_rc_ptr"); exportUtilsFn(utils.decrefRcPtrC, "decref_rc_ptr"); @@ -248,7 +249,6 @@ comptime { exportUtilsFn(expect.expectFailedStartSharedBuffer, "expect_failed_start_shared_buffer"); exportUtilsFn(expect.expectFailedStartSharedFile, "expect_failed_start_shared_file"); exportUtilsFn(expect.notifyParentExpect, "notify_parent_expect"); - exportUtilsFn(expect.notifyParentDbg, "notify_parent_dbg"); // sets the buffer used for expect failures @export(expect.setSharedBuffer, .{ .name = "set_shared_buffer", .linkage = .Weak }); diff --git a/crates/compiler/builtins/bitcode/src/utils.zig b/crates/compiler/builtins/bitcode/src/utils.zig index 94e806d974..6a77a13d4d 100644 --- a/crates/compiler/builtins/bitcode/src/utils.zig +++ b/crates/compiler/builtins/bitcode/src/utils.zig @@ -20,6 +20,13 @@ extern fn roc_realloc(c_ptr: *anyopaque, new_size: usize, old_size: usize, align // This should never be passed a null pointer. extern fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void; +extern fn roc_dbg(file_path: *anyopaque, message: *anyopaque) callconv(.C) void; + +// Since roc_dbg is never used by the builtins, we need at export a function that uses it to stop DCE. +pub fn test_dbg(file_path: *anyopaque, message: *anyopaque) callconv(.C) void { + roc_dbg(file_path, message); +} + extern fn kill(pid: c_int, sig: c_int) c_int; extern fn shm_open(name: *const i8, oflag: c_int, mode: c_uint) c_int; extern fn mmap(addr: ?*anyopaque, length: c_uint, prot: c_int, flags: c_int, fd: c_int, offset: c_uint) *anyopaque; @@ -40,6 +47,11 @@ fn testing_roc_mmap(addr: ?*anyopaque, length: c_uint, prot: c_int, flags: c_int return mmap(addr, length, prot, flags, fd, offset); } +fn testing_roc_dbg(file_path: *anyopaque, message: *anyopaque) callconv(.C) void { + _ = message; + _ = file_path; +} + comptime { // During tests, use the testing allocators to satisfy these functions. if (builtin.is_test) { @@ -47,6 +59,7 @@ comptime { @export(testing_roc_realloc, .{ .name = "roc_realloc", .linkage = .Strong }); @export(testing_roc_dealloc, .{ .name = "roc_dealloc", .linkage = .Strong }); @export(testing_roc_panic, .{ .name = "roc_panic", .linkage = .Strong }); + @export(testing_roc_dbg, .{ .name = "roc_dbg", .linkage = .Strong }); if (builtin.os.tag == .macos or builtin.os.tag == .linux) { @export(testing_roc_getppid, .{ .name = "roc_getppid", .linkage = .Strong }); diff --git a/crates/compiler/builtins/roc/Dict.roc b/crates/compiler/builtins/roc/Dict.roc index f737ccbb25..172c0e501e 100644 --- a/crates/compiler/builtins/roc/Dict.roc +++ b/crates/compiler/builtins/roc/Dict.roc @@ -32,6 +32,7 @@ interface Dict Str, Num.{ Nat, U64, U8, I8 }, Hash.{ Hasher, Hash }, + Inspect.{ Inspect, Inspector, InspectFormatter }, ] ## A [dictionary](https://en.wikipedia.org/wiki/Associative_array) that lets you @@ -108,6 +109,9 @@ Dict k v := { Hash { hash: hashDict, }, + Inspect { + toInspector: toInspectorDict, + }, ] isEq : Dict k v, Dict k v -> Bool where k implements Hash & Eq, v implements Eq @@ -126,6 +130,11 @@ isEq = \xs, ys -> hashDict : hasher, Dict k v -> hasher where k implements Hash & Eq, v implements Hash, hasher implements Hasher hashDict = \hasher, dict -> Hash.hashUnordered hasher (toList dict) List.walk +toInspectorDict : Dict k v -> Inspector f where k implements Inspect & Hash & Eq, v implements Inspect, f implements InspectFormatter +toInspectorDict = \dict -> + fmt <- Inspect.custom + Inspect.apply (Inspect.dict dict walk Inspect.toInspector Inspect.toInspector) fmt + ## Return an empty dictionary. ## ``` ## emptyDict = Dict.empty {} diff --git a/crates/compiler/builtins/roc/Inspect.roc b/crates/compiler/builtins/roc/Inspect.roc index f4009f38fa..a86b83a247 100644 --- a/crates/compiler/builtins/roc/Inspect.roc +++ b/crates/compiler/builtins/roc/Inspect.roc @@ -15,6 +15,7 @@ interface Inspect record, bool, str, + function, opaque, u8, i8, @@ -26,16 +27,19 @@ interface Inspect i64, u128, i128, + nat, f32, f64, dec, custom, apply, toInspector, + DbgFormatter, + toDbgStr, ] imports [ Bool.{ Bool }, - Num.{ U8, U16, U32, U64, U128, I8, I16, I32, I64, I128, F32, F64, Dec }, + Num.{ U8, U16, U32, U64, U128, I8, I16, I32, I64, I128, F32, F64, Dec, Nat }, List, Str, ] @@ -56,12 +60,13 @@ InspectFormatter implements set : set, ElemWalker state set elem, (elem -> Inspector f) -> Inspector f where f implements InspectFormatter dict : dict, KeyValWalker state dict key value, (key -> Inspector f), (value -> Inspector f) -> Inspector f where f implements InspectFormatter - # Note opaque is used for both opaque types and functions. - # The auto deriver for functions probably could put the function type. - # For regular opaque types, I think we can use the type name, though that may lead to some reflection related issues that still need to be discussed. - # As a simple baseline, it can just use the exact words `opaque` and `function` for now. - # In text, this would render as ``, ``, etc - opaque : Str -> Inspector f where f implements InspectFormatter + # In text, this would render as `` + # TODO: Pass the type name to opaque so that it can be displayed. + opaque : * -> Inspector f where f implements InspectFormatter + + # In text, this would render as `` + # TODO: Maybe pass the the function name or signiture to function so that it can be displayed. + function : * -> Inspector f where f implements InspectFormatter u8 : U8 -> Inspector f where f implements InspectFormatter i8 : I8 -> Inspector f where f implements InspectFormatter @@ -73,6 +78,7 @@ InspectFormatter implements i64 : I64 -> Inspector f where f implements InspectFormatter u128 : U128 -> Inspector f where f implements InspectFormatter i128 : I128 -> Inspector f where f implements InspectFormatter + nat : Nat -> Inspector f where f implements InspectFormatter f32 : F32 -> Inspector f where f implements InspectFormatter f64 : F64 -> Inspector f where f implements InspectFormatter dec : Dec -> Inspector f where f implements InspectFormatter @@ -80,7 +86,7 @@ InspectFormatter implements Inspector f := f -> f where f implements InspectFormatter custom : (f -> f) -> Inspector f where f implements InspectFormatter -custom = @Inspector +custom = \fn -> @Inspector fn apply : Inspector f, f -> f where f implements InspectFormatter apply = \@Inspector fn, fmt -> fn fmt @@ -92,3 +98,252 @@ inspect : val -> f where val implements Inspect, f implements InspectFormatter inspect = \val -> (@Inspector valFn) = toInspector val valFn (init {}) + +# The current default formatter for inspect. +# This just returns a simple string for debugging. +# More powerful formatters will likely be wanted in the future. +DbgFormatter := { data : Str } + implements [ + InspectFormatter { + init: dbgInit, + list: dbgList, + set: dbgSet, + dict: dbgDict, + tag: dbgTag, + tuple: dbgTuple, + record: dbgRecord, + bool: dbgBool, + str: dbgStr, + opaque: dbgOpaque, + function: dbgFunction, + u8: dbgU8, + i8: dbgI8, + u16: dbgU16, + i16: dbgI16, + u32: dbgU32, + i32: dbgI32, + u64: dbgU64, + i64: dbgI64, + u128: dbgU128, + i128: dbgI128, + nat: dbgNat, + f32: dbgF32, + f64: dbgF64, + dec: dbgDec, + }, + ] + +dbgInit : {} -> DbgFormatter +dbgInit = \{} -> @DbgFormatter { data: "" } + +dbgList : list, ElemWalker (DbgFormatter, Bool) list elem, (elem -> Inspector DbgFormatter) -> Inspector DbgFormatter +dbgList = \content, walkFn, toDbgInspector -> + f0 <- custom + dbgWrite f0 "[" + |> \f1 -> + (f2, prependSep), elem <- walkFn content (f1, Bool.false) + f3 = + if prependSep then + dbgWrite f2 ", " + else + f2 + + elem + |> toDbgInspector + |> apply f3 + |> \f4 -> (f4, Bool.true) + |> .0 + |> dbgWrite "]" + +dbgSet : set, ElemWalker (DbgFormatter, Bool) set elem, (elem -> Inspector DbgFormatter) -> Inspector DbgFormatter +dbgSet = \content, walkFn, toDbgInspector -> + f0 <- custom + dbgWrite f0 "{" + |> \f1 -> + (f2, prependSep), elem <- walkFn content (f1, Bool.false) + f3 = + if prependSep then + dbgWrite f2 ", " + else + f2 + + elem + |> toDbgInspector + |> apply f3 + |> \f4 -> (f4, Bool.true) + |> .0 + |> dbgWrite "}" + +dbgDict : dict, KeyValWalker (DbgFormatter, Bool) dict key value, (key -> Inspector DbgFormatter), (value -> Inspector DbgFormatter) -> Inspector DbgFormatter +dbgDict = \d, walkFn, keyToInspector, valueToInspector -> + f0 <- custom + dbgWrite f0 "{" + |> \f1 -> + (f2, prependSep), key, value <- walkFn d (f1, Bool.false) + f3 = + if prependSep then + dbgWrite f2 ", " + else + f2 + + apply (keyToInspector key) f3 + |> dbgWrite ": " + |> \x -> apply (valueToInspector value) x + |> \f4 -> (f4, Bool.true) + |> .0 + |> dbgWrite "}" + +dbgTag : Str, List (Inspector DbgFormatter) -> Inspector DbgFormatter +dbgTag = \name, fields -> + if List.isEmpty fields then + f0 <- custom + dbgWrite f0 name + else + f0 <- custom + dbgWrite f0 "(" + |> dbgWrite name + |> \f1 -> + f2, inspector <- List.walk fields f1 + dbgWrite f2 " " + |> \x -> apply inspector x + |> dbgWrite ")" + +dbgTuple : List (Inspector DbgFormatter) -> Inspector DbgFormatter +dbgTuple = \fields -> + f0 <- custom + dbgWrite f0 "(" + |> \f1 -> + (f2, prependSep), inspector <- List.walk fields (f1, Bool.false) + f3 = + if prependSep then + dbgWrite f2 ", " + else + f2 + + apply inspector f3 + |> \f4 -> (f4, Bool.true) + |> .0 + |> dbgWrite ")" + +dbgRecord : List { key : Str, value : Inspector DbgFormatter } -> Inspector DbgFormatter +dbgRecord = \fields -> + f0 <- custom + dbgWrite f0 "{" + |> \f1 -> + (f2, prependSep), { key, value } <- List.walk fields (f1, Bool.false) + f3 = + if prependSep then + dbgWrite f2 ", " + else + f2 + + dbgWrite f3 key + |> dbgWrite ": " + |> \x -> apply value x + |> \f4 -> (f4, Bool.true) + |> .0 + |> dbgWrite "}" + +dbgBool : Bool -> Inspector DbgFormatter +dbgBool = \b -> + if b then + f0 <- custom + dbgWrite f0 "Bool.true" + else + f0 <- custom + dbgWrite f0 "Bool.false" + +dbgStr : Str -> Inspector DbgFormatter +dbgStr = \s -> + f0 <- custom + f0 + |> dbgWrite "\"" + |> dbgWrite s # TODO: Should we be escaping strings for dbg/logging? + |> dbgWrite "\"" + +dbgOpaque : * -> Inspector DbgFormatter +dbgOpaque = \_ -> + f0 <- custom + dbgWrite f0 "" + +dbgFunction : * -> Inspector DbgFormatter +dbgFunction = \_ -> + f0 <- custom + dbgWrite f0 "" + +dbgU8 : U8 -> Inspector DbgFormatter +dbgU8 = \num -> + f0 <- custom + dbgWrite f0 (num |> Num.toStr) + +dbgI8 : I8 -> Inspector DbgFormatter +dbgI8 = \num -> + f0 <- custom + dbgWrite f0 (num |> Num.toStr) + +dbgU16 : U16 -> Inspector DbgFormatter +dbgU16 = \num -> + f0 <- custom + dbgWrite f0 (num |> Num.toStr) + +dbgI16 : I16 -> Inspector DbgFormatter +dbgI16 = \num -> + f0 <- custom + dbgWrite f0 (num |> Num.toStr) + +dbgU32 : U32 -> Inspector DbgFormatter +dbgU32 = \num -> + f0 <- custom + dbgWrite f0 (num |> Num.toStr) + +dbgI32 : I32 -> Inspector DbgFormatter +dbgI32 = \num -> + f0 <- custom + dbgWrite f0 (num |> Num.toStr) + +dbgU64 : U64 -> Inspector DbgFormatter +dbgU64 = \num -> + f0 <- custom + dbgWrite f0 (num |> Num.toStr) + +dbgI64 : I64 -> Inspector DbgFormatter +dbgI64 = \num -> + f0 <- custom + dbgWrite f0 (num |> Num.toStr) + +dbgU128 : U128 -> Inspector DbgFormatter +dbgU128 = \num -> + f0 <- custom + dbgWrite f0 (num |> Num.toStr) + +dbgI128 : I128 -> Inspector DbgFormatter +dbgI128 = \num -> + f0 <- custom + dbgWrite f0 (num |> Num.toStr) + +dbgNat : Nat -> Inspector DbgFormatter +dbgNat = \num -> + f0 <- custom + dbgWrite f0 (num |> Num.toStr) + +dbgF32 : F32 -> Inspector DbgFormatter +dbgF32 = \num -> + f0 <- custom + dbgWrite f0 (num |> Num.toStr) + +dbgF64 : F64 -> Inspector DbgFormatter +dbgF64 = \num -> + f0 <- custom + dbgWrite f0 (num |> Num.toStr) + +dbgDec : Dec -> Inspector DbgFormatter +dbgDec = \num -> + f0 <- custom + dbgWrite f0 (num |> Num.toStr) + +dbgWrite : DbgFormatter, Str -> DbgFormatter +dbgWrite = \@DbgFormatter { data }, added -> + @DbgFormatter { data: Str.concat data added } + +toDbgStr : DbgFormatter -> Str +toDbgStr = \@DbgFormatter { data } -> data diff --git a/crates/compiler/builtins/roc/Set.roc b/crates/compiler/builtins/roc/Set.roc index 19e6a82ebf..b942461f31 100644 --- a/crates/compiler/builtins/roc/Set.roc +++ b/crates/compiler/builtins/roc/Set.roc @@ -25,6 +25,7 @@ interface Set Dict.{ Dict }, Num.{ Nat }, Hash.{ Hash, Hasher }, + Inspect.{ Inspect, Inspector, InspectFormatter }, ] ## Provides a [set](https://en.wikipedia.org/wiki/Set_(abstract_data_type)) @@ -37,6 +38,9 @@ Set k := Dict.Dict k {} where k implements Hash & Eq Hash { hash: hashSet, }, + Inspect { + toInspector: toInspectorSet, + }, ] isEq : Set k, Set k -> Bool where k implements Hash & Eq @@ -53,6 +57,11 @@ isEq = \xs, ys -> hashSet : hasher, Set k -> hasher where k implements Hash & Eq, hasher implements Hasher hashSet = \hasher, @Set inner -> Hash.hash hasher inner +toInspectorSet : Set k -> Inspector f where k implements Inspect & Hash & Eq, f implements InspectFormatter +toInspectorSet = \set -> + fmt <- Inspect.custom + Inspect.apply (Inspect.set set walk Inspect.toInspector) fmt + ## Creates a new empty `Set`. ## ``` ## emptySet = Set.empty {} diff --git a/crates/compiler/builtins/src/bitcode.rs b/crates/compiler/builtins/src/bitcode.rs index 8482f79739..47c4d045eb 100644 --- a/crates/compiler/builtins/src/bitcode.rs +++ b/crates/compiler/builtins/src/bitcode.rs @@ -439,7 +439,6 @@ pub const UTILS_EXPECT_FAILED_START_SHARED_FILE: &str = "roc_builtins.utils.expect_failed_start_shared_file"; pub const UTILS_EXPECT_READ_ENV_SHARED_BUFFER: &str = "roc_builtins.utils.read_env_shared_buffer"; pub const NOTIFY_PARENT_EXPECT: &str = "roc_builtins.utils.notify_parent_expect"; -pub const NOTIFY_PARENT_DBG: &str = "roc_builtins.utils.notify_parent_dbg"; pub const UTILS_LONGJMP: &str = "longjmp"; pub const UTILS_SETJMP: &str = "setjmp"; diff --git a/crates/compiler/can/src/copy.rs b/crates/compiler/can/src/copy.rs index 06ff890eed..73f535f710 100644 --- a/crates/compiler/can/src/copy.rs +++ b/crates/compiler/can/src/copy.rs @@ -670,12 +670,12 @@ fn deep_copy_expr_help(env: &mut C, copied: &mut Vec, expr }, Dbg { - loc_condition, + loc_message, loc_continuation, variable, symbol, } => Dbg { - loc_condition: Box::new(loc_condition.map(|e| go_help!(e))), + loc_message: Box::new(loc_message.map(|e| go_help!(e))), loc_continuation: Box::new(loc_continuation.map(|e| go_help!(e))), variable: sub!(*variable), symbol: *symbol, diff --git a/crates/compiler/can/src/def.rs b/crates/compiler/can/src/def.rs index 2496689eb8..804665e3a9 100644 --- a/crates/compiler/can/src/def.rs +++ b/crates/compiler/can/src/def.rs @@ -718,6 +718,7 @@ fn canonicalize_opaque<'a>( let ability_region = ability.region; + // Op := {} has [Eq] let (ability, members) = match ability.value { ast::TypeAnnotation::Apply(module_name, ident, []) => { match make_apply_symbol(env, region, scope, module_name, ident) { diff --git a/crates/compiler/can/src/derive.rs b/crates/compiler/can/src/derive.rs index fd85aaa514..fd51376919 100644 --- a/crates/compiler/can/src/derive.rs +++ b/crates/compiler/can/src/derive.rs @@ -213,6 +213,48 @@ fn is_eq<'a>(env: &mut Env<'a>, at_opaque: &'a str) -> ast::Expr<'a> { ) } +fn to_inspector<'a>(env: &mut Env<'a>, at_opaque: &'a str) -> ast::Expr<'a> { + let alloc_pat = |it| env.arena.alloc(Loc::at(DERIVED_REGION, it)); + let alloc_expr = |it| env.arena.alloc(Loc::at(DERIVED_REGION, it)); + + let payload = "#payload"; + + // \@Opaq payload + let opaque_ref = alloc_pat(ast::Pattern::OpaqueRef(at_opaque)); + let opaque_apply_pattern = ast::Pattern::Apply( + opaque_ref, + &*env + .arena + .alloc([Loc::at(DERIVED_REGION, ast::Pattern::Identifier(payload))]), + ); + + // Inspect.toInspector payload + let call_member = alloc_expr(ast::Expr::Apply( + alloc_expr(ast::Expr::Var { + module_name: "Inspect", + ident: "toInspector", + }), + &*env.arena.alloc([&*alloc_expr(ast::Expr::Var { + module_name: "", + ident: payload, + })]), + roc_module::called_via::CalledVia::Space, + )); + + // TODO: change the derived implementation to be something that includes the opaque symbol in + // the derivation, e.g. something like + // + // \@Opaq payload -> + // Inspect.opaqueWrapper "toString symbol" payload + + // \@Opaq payload -> Inspect.toInspector payload + ast::Expr::Closure( + env.arena + .alloc([Loc::at(DERIVED_REGION, opaque_apply_pattern)]), + call_member, + ) +} + pub const DERIVED_REGION: Region = Region::zero(); pub(crate) fn synthesize_member_impl<'a>( @@ -232,6 +274,10 @@ pub(crate) fn synthesize_member_impl<'a>( Symbol::DECODE_DECODER => (format!("#{opaque_name}_decoder"), decoder(env, at_opaque)), Symbol::HASH_HASH => (format!("#{opaque_name}_hash"), hash(env, at_opaque)), Symbol::BOOL_IS_EQ => (format!("#{opaque_name}_isEq"), is_eq(env, at_opaque)), + Symbol::INSPECT_TO_INSPECTOR => ( + format!("#{opaque_name}_toInspector"), + to_inspector(env, at_opaque), + ), other => internal_error!("{:?} is not a derivable ability member!", other), }; diff --git a/crates/compiler/can/src/expr.rs b/crates/compiler/can/src/expr.rs index 7f173ff8fe..474a721bdb 100644 --- a/crates/compiler/can/src/expr.rs +++ b/crates/compiler/can/src/expr.rs @@ -269,7 +269,7 @@ pub enum Expr { }, Dbg { - loc_condition: Box>, + loc_message: Box>, loc_continuation: Box>, variable: Variable, symbol: Symbol, @@ -1062,10 +1062,10 @@ pub fn canonicalize_expr<'a>( }) } ast::Expr::RecordBuilder(_) => { - unreachable!("RecordBuilder should have been desugared by now") + internal_error!("RecordBuilder should have been desugared by now") } ast::Expr::Backpassing(_, _, _) => { - unreachable!("Backpassing should have been desugared by now") + internal_error!("Backpassing should have been desugared by now") } ast::Expr::Closure(loc_arg_patterns, loc_body_expr) => { let (closure_data, output) = @@ -1246,11 +1246,14 @@ pub fn canonicalize_expr<'a>( output, ) } - ast::Expr::Dbg(condition, continuation) => { + ast::Expr::Dbg(_, _) => { + internal_error!("Dbg should have been desugared by now") + } + ast::Expr::LowLevelDbg(message, continuation) => { let mut output = Output::default(); - let (loc_condition, output1) = - canonicalize_expr(env, var_store, scope, condition.region, &condition.value); + let (loc_message, output1) = + canonicalize_expr(env, var_store, scope, message.region, &message.value); let (loc_continuation, output2) = canonicalize_expr( env, @@ -1263,17 +1266,17 @@ pub fn canonicalize_expr<'a>( output.union(output1); output.union(output2); - // the symbol is used to bind the condition `x = condition`, and identify this `dbg`. + // the symbol is used to bind the message `x = message`, and identify this `dbg`. // That would cause issues if we dbg a variable, like `dbg y`, because in the IR we // cannot alias variables. Hence, we make the dbg use that same variable `y` - let symbol = match &loc_condition.value { + let symbol = match &loc_message.value { Expr::Var(symbol, _) => *symbol, _ => scope.gen_unique_symbol(), }; ( Dbg { - loc_condition: Box::new(loc_condition), + loc_message: Box::new(loc_message), loc_continuation: Box::new(loc_continuation), variable: var_store.fresh(), symbol, @@ -2094,14 +2097,14 @@ pub fn inline_calls(var_store: &mut VarStore, expr: Expr) -> Expr { } Dbg { - loc_condition, + loc_message, loc_continuation, variable, symbol, } => { - let loc_condition = Loc { - region: loc_condition.region, - value: inline_calls(var_store, loc_condition.value), + let loc_message = Loc { + region: loc_message.region, + value: inline_calls(var_store, loc_message.value), }; let loc_continuation = Loc { @@ -2110,7 +2113,7 @@ pub fn inline_calls(var_store: &mut VarStore, expr: Expr) -> Expr { }; Dbg { - loc_condition: Box::new(loc_condition), + loc_message: Box::new(loc_message), loc_continuation: Box::new(loc_continuation), variable, symbol, @@ -2338,10 +2341,10 @@ pub fn inline_calls(var_store: &mut VarStore, expr: Expr) -> Expr { loc_answer.value } Some(_) => { - unreachable!("Tried to inline a non-function"); + internal_error!("Tried to inline a non-function"); } None => { - unreachable!( + internal_error!( "Tried to inline a builtin that wasn't registered: {:?}", symbol ); @@ -2395,6 +2398,7 @@ pub fn is_valid_interpolation(expr: &ast::Expr<'_>) -> bool { | ast::Expr::MalformedClosure => true, // Newlines are disallowed inside interpolation, and these all require newlines ast::Expr::Dbg(_, _) + | ast::Expr::LowLevelDbg(_, _) | ast::Expr::Defs(_, _) | ast::Expr::Expect(_, _) | ast::Expr::When(_, _) @@ -3328,7 +3332,7 @@ impl crate::traverse::Visitor for ExpectCollector { .insert(loc_condition.region, lookups_in_cond.to_vec()); } Expr::Dbg { - loc_condition, + loc_message, variable, symbol, .. @@ -3336,7 +3340,7 @@ impl crate::traverse::Visitor for ExpectCollector { let lookup = DbgLookup { symbol: *symbol, var: *variable, - region: loc_condition.region, + region: loc_message.region, ability_info: None, }; diff --git a/crates/compiler/can/src/module.rs b/crates/compiler/can/src/module.rs index d0c3600074..729d53c4aa 100644 --- a/crates/compiler/can/src/module.rs +++ b/crates/compiler/can/src/module.rs @@ -996,7 +996,7 @@ fn fix_values_captured_in_closure_expr( .. } | Dbg { - loc_condition, + loc_message: loc_condition, loc_continuation, .. } => { diff --git a/crates/compiler/can/src/operator.rs b/crates/compiler/can/src/operator.rs index 0e45e69567..e6bfcd897b 100644 --- a/crates/compiler/can/src/operator.rs +++ b/crates/compiler/can/src/operator.rs @@ -8,7 +8,8 @@ use roc_module::called_via::{BinOp, CalledVia}; use roc_module::ident::ModuleName; use roc_parse::ast::Expr::{self, *}; use roc_parse::ast::{ - AssignedField, Collection, RecordBuilderField, StrLiteral, StrSegment, ValueDef, WhenBranch, + AssignedField, Collection, Pattern, RecordBuilderField, StrLiteral, StrSegment, ValueDef, + WhenBranch, }; use roc_region::all::{Loc, Region}; @@ -70,7 +71,10 @@ fn desugar_value_def<'a>(arena: &'a Bump, def: &'a ValueDef<'a>) -> ValueDef<'a> use ValueDef::*; match def { - Body(loc_pattern, loc_expr) => Body(loc_pattern, desugar_expr(arena, loc_expr)), + Body(loc_pattern, loc_expr) => Body( + desugar_loc_pattern(arena, loc_pattern), + desugar_expr(arena, loc_expr), + ), ann @ Annotation(_, _) => *ann, AnnotatedBody { ann_pattern, @@ -238,7 +242,10 @@ pub fn desugar_expr<'a>(arena: &'a Bump, loc_expr: &'a Loc>) -> &'a Loc } Closure(loc_patterns, loc_ret) => arena.alloc(Loc { region: loc_expr.region, - value: Closure(loc_patterns, desugar_expr(arena, loc_ret)), + value: Closure( + desugar_loc_patterns(arena, loc_patterns), + desugar_expr(arena, loc_ret), + ), }), Backpassing(loc_patterns, loc_body, loc_ret) => { // loc_patterns <- loc_body @@ -249,7 +256,8 @@ pub fn desugar_expr<'a>(arena: &'a Bump, loc_expr: &'a Loc>) -> &'a Loc let desugared_body = desugar_expr(arena, loc_body); let desugared_ret = desugar_expr(arena, loc_ret); - let closure = Expr::Closure(loc_patterns, desugared_ret); + let desugared_loc_patterns = desugar_loc_patterns(arena, loc_patterns); + let closure = Expr::Closure(desugared_loc_patterns, desugared_ret); let loc_closure = Loc::at(loc_expr.region, closure); match &desugared_body.value { @@ -352,10 +360,8 @@ pub fn desugar_expr<'a>(arena: &'a Bump, loc_expr: &'a Loc>) -> &'a Loc let mut desugared_branches = Vec::with_capacity_in(branches.len(), arena); for branch in branches.iter() { - let desugared = desugar_expr(arena, &branch.value); - - let mut alternatives = Vec::with_capacity_in(branch.patterns.len(), arena); - alternatives.extend(branch.patterns.iter().copied()); + let desugared_expr = desugar_expr(arena, &branch.value); + let desugared_patterns = desugar_loc_patterns(arena, branch.patterns); let desugared_guard = if let Some(guard) = &branch.guard { Some(*desugar_expr(arena, guard)) @@ -363,11 +369,9 @@ pub fn desugar_expr<'a>(arena: &'a Bump, loc_expr: &'a Loc>) -> &'a Loc None }; - let alternatives = alternatives.into_bump_slice(); - desugared_branches.push(&*arena.alloc(WhenBranch { - patterns: alternatives, - value: *desugared, + patterns: desugared_patterns, + value: *desugared_expr, guard: desugared_guard, })); } @@ -457,13 +461,48 @@ pub fn desugar_expr<'a>(arena: &'a Bump, loc_expr: &'a Loc>) -> &'a Loc }) } Dbg(condition, continuation) => { - let desugared_condition = &*arena.alloc(desugar_expr(arena, condition)); + // Desugars a `dbg x` statement into + // `roc_dbg (Inspect.toDbgStr (Inspect.inspect x))` let desugared_continuation = &*arena.alloc(desugar_expr(arena, continuation)); + + let region = condition.region; + // TODO desugar this in canonicalization instead, so we can work + // in terms of integers exclusively and not need to create strings + // which canonicalization then needs to look up, check if they're exposed, etc + let inspect = Var { + module_name: ModuleName::INSPECT, + ident: "inspect", + }; + let loc_inspect_fn_var = arena.alloc(Loc { + value: inspect, + region, + }); + let desugared_inspect_args = arena.alloc([desugar_expr(arena, condition)]); + + let inspector = arena.alloc(Loc { + value: Apply(loc_inspect_fn_var, desugared_inspect_args, CalledVia::Space), + region, + }); + + let to_dbg_str = Var { + module_name: ModuleName::INSPECT, + ident: "toDbgStr", + }; + let loc_to_dbg_str_fn_var = arena.alloc(Loc { + value: to_dbg_str, + region, + }); + let to_dbg_str_args = arena.alloc([&*inspector]); + let dbg_str = arena.alloc(Loc { + value: Apply(loc_to_dbg_str_fn_var, to_dbg_str_args, CalledVia::Space), + region, + }); arena.alloc(Loc { - value: Dbg(desugared_condition, desugared_continuation), + value: LowLevelDbg(dbg_str, desugared_continuation), region: loc_expr.region, }) } + LowLevelDbg(_, _) => unreachable!("Only exists after desugaring"), } } @@ -544,6 +583,85 @@ fn desugar_field<'a>( } } +fn desugar_loc_patterns<'a>( + arena: &'a Bump, + loc_patterns: &'a [Loc>], +) -> &'a [Loc>] { + Vec::from_iter_in( + loc_patterns.iter().map(|loc_pattern| Loc { + region: loc_pattern.region, + value: desugar_pattern(arena, loc_pattern.value), + }), + arena, + ) + .into_bump_slice() +} + +fn desugar_loc_pattern<'a>( + arena: &'a Bump, + loc_pattern: &'a Loc>, +) -> &'a Loc> { + arena.alloc(Loc { + region: loc_pattern.region, + value: desugar_pattern(arena, loc_pattern.value), + }) +} + +fn desugar_pattern<'a>(arena: &'a Bump, pattern: Pattern<'a>) -> Pattern<'a> { + use roc_parse::ast::Pattern::*; + + match pattern { + Identifier(_) + | Tag(_) + | OpaqueRef(_) + | NumLiteral(_) + | NonBase10Literal { .. } + | FloatLiteral(_) + | StrLiteral(_) + | Underscore(_) + | SingleQuote(_) + | ListRest(_) + | Malformed(_) + | MalformedIdent(_, _) + | QualifiedIdentifier { .. } => pattern, + + Apply(tag, arg_patterns) => { + // Skip desugaring the tag, it should either be a Tag or OpaqueRef + let desugared_arg_patterns = Vec::from_iter_in( + arg_patterns.iter().map(|arg_pattern| Loc { + region: arg_pattern.region, + value: desugar_pattern(arena, arg_pattern.value), + }), + arena, + ) + .into_bump_slice(); + + Apply(tag, desugared_arg_patterns) + } + RecordDestructure(field_patterns) => { + RecordDestructure(field_patterns.map_items(arena, |field_pattern| Loc { + region: field_pattern.region, + value: desugar_pattern(arena, field_pattern.value), + })) + } + RequiredField(name, field_pattern) => { + RequiredField(name, desugar_loc_pattern(arena, field_pattern)) + } + OptionalField(name, expr) => OptionalField(name, desugar_expr(arena, expr)), + Tuple(patterns) => Tuple(patterns.map_items(arena, |elem_pattern| Loc { + region: elem_pattern.region, + value: desugar_pattern(arena, elem_pattern.value), + })), + List(patterns) => List(patterns.map_items(arena, |elem_pattern| Loc { + region: elem_pattern.region, + value: desugar_pattern(arena, elem_pattern.value), + })), + As(sub_pattern, symbol) => As(desugar_loc_pattern(arena, sub_pattern), symbol), + SpaceBefore(sub_pattern, _spaces) => desugar_pattern(arena, *sub_pattern), + SpaceAfter(sub_pattern, _spaces) => desugar_pattern(arena, *sub_pattern), + } +} + struct RecordBuilderArg<'a> { closure: &'a Loc>, apply_exprs: Vec<'a, &'a Loc>>, diff --git a/crates/compiler/can/src/traverse.rs b/crates/compiler/can/src/traverse.rs index e720901724..eb92dc14da 100644 --- a/crates/compiler/can/src/traverse.rs +++ b/crates/compiler/can/src/traverse.rs @@ -387,11 +387,11 @@ pub fn walk_expr(visitor: &mut V, expr: &Expr, var: Variable) { } Expr::Dbg { variable, - loc_condition, + loc_message, loc_continuation, symbol: _, } => { - visitor.visit_expr(&loc_condition.value, loc_condition.region, *variable); + visitor.visit_expr(&loc_message.value, loc_message.region, *variable); visitor.visit_expr( &loc_continuation.value, loc_continuation.region, diff --git a/crates/compiler/constrain/src/expr.rs b/crates/compiler/constrain/src/expr.rs index 9b69c8497f..0779f8cfcd 100644 --- a/crates/compiler/constrain/src/expr.rs +++ b/crates/compiler/constrain/src/expr.rs @@ -741,7 +741,7 @@ pub fn constrain_expr( } Dbg { - loc_condition, + loc_message, loc_continuation, variable, symbol: _, @@ -749,12 +749,12 @@ pub fn constrain_expr( let dbg_type = constraints.push_variable(*variable); let expected_dbg = constraints.push_expected_type(Expected::NoExpectation(dbg_type)); - let cond_con = constrain_expr( + let message_con = constrain_expr( types, constraints, env, - loc_condition.region, - &loc_condition.value, + loc_message.region, + &loc_message.value, expected_dbg, ); @@ -767,7 +767,7 @@ pub fn constrain_expr( expected, ); - constraints.exists_many([*variable], [cond_con, continuation_con]) + constraints.exists_many([*variable], [message_con, continuation_con]) } If { diff --git a/crates/compiler/derive/src/inspect.rs b/crates/compiler/derive/src/inspect.rs new file mode 100644 index 0000000000..75536efea7 --- /dev/null +++ b/crates/compiler/derive/src/inspect.rs @@ -0,0 +1,1089 @@ +//! Derivers for the `Inspect` ability. + +use std::iter::once; + +use roc_can::expr::{ + AnnotatedMark, ClosureData, Expr, Field, Recursive, WhenBranch, WhenBranchPattern, +}; +use roc_can::pattern::Pattern; +use roc_collections::SendMap; +use roc_derive_key::inspect::FlatInspectableKey; +use roc_module::called_via::CalledVia; +use roc_module::ident::Lowercase; +use roc_module::symbol::Symbol; +use roc_region::all::{Loc, Region}; +use roc_types::subs::{ + Content, ExhaustiveMark, FlatType, GetSubsSlice, LambdaSet, OptVariable, RecordFields, + RedundantMark, SubsSlice, TagExt, TupleElems, UnionLambdas, UnionTags, Variable, + VariableSubsSlice, +}; +use roc_types::types::RecordField; + +use crate::util::Env; +use crate::{synth_var, DerivedBody}; + +pub(crate) fn derive_to_inspector( + env: &mut Env<'_>, + key: FlatInspectableKey, + def_symbol: Symbol, +) -> DerivedBody { + let (body, body_type) = match key { + FlatInspectableKey::List() => to_inspector_list(env, def_symbol), + FlatInspectableKey::Set() => unreachable!(), + FlatInspectableKey::Dict() => unreachable!(), + FlatInspectableKey::Record(fields) => { + // Generalized record var so we can reuse this impl between many records: + // if fields = { a, b }, this is { a: t1, b: t2 } for fresh t1, t2. + let flex_fields = fields + .into_iter() + .map(|name| { + ( + name, + RecordField::Required(env.subs.fresh_unnamed_flex_var()), + ) + }) + .collect::>(); + let fields = RecordFields::insert_into_subs(env.subs, flex_fields); + let record_var = synth_var( + env.subs, + Content::Structure(FlatType::Record(fields, Variable::EMPTY_RECORD)), + ); + + to_inspector_record(env, record_var, fields, def_symbol) + } + FlatInspectableKey::Tuple(arity) => { + // Generalized tuple var so we can reuse this impl between many tuples: + // if arity = n, this is (t1, ..., tn) for fresh t1, ..., tn. + let flex_elems = (0..arity) + .map(|idx| (idx as usize, env.subs.fresh_unnamed_flex_var())) + .collect::>(); + let elems = TupleElems::insert_into_subs(env.subs, flex_elems); + let tuple_var = synth_var( + env.subs, + Content::Structure(FlatType::Tuple(elems, Variable::EMPTY_TUPLE)), + ); + + to_inspector_tuple(env, tuple_var, elems, def_symbol) + } + FlatInspectableKey::TagUnion(tags) => { + // Generalized tag union var so we can reuse this impl between many unions: + // if tags = [ A arity=2, B arity=1 ], this is [ A t1 t2, B t3 ] for fresh t1, t2, t3 + let flex_tag_labels = tags + .into_iter() + .map(|(label, arity)| { + let variables_slice = + VariableSubsSlice::reserve_into_subs(env.subs, arity.into()); + for var_index in variables_slice { + env.subs[var_index] = env.subs.fresh_unnamed_flex_var(); + } + (label, variables_slice) + }) + .collect::>(); + let union_tags = UnionTags::insert_slices_into_subs(env.subs, flex_tag_labels); + let tag_union_var = synth_var( + env.subs, + Content::Structure(FlatType::TagUnion( + union_tags, + TagExt::Any(Variable::EMPTY_TAG_UNION), + )), + ); + + to_inspector_tag_union(env, tag_union_var, union_tags, def_symbol) + } + FlatInspectableKey::Function(_arity) => { + // Desired output: \x, y, z -> ... ===> "" + + todo!(); + } + FlatInspectableKey::Opaque => todo!(), + FlatInspectableKey::Error => todo!(), + }; + + let specialization_lambda_sets = + env.get_specialization_lambda_sets(body_type, Symbol::INSPECT_TO_INSPECTOR); + + DerivedBody { + body, + body_type, + specialization_lambda_sets, + } +} + +fn to_inspector_list(env: &mut Env<'_>, fn_name: Symbol) -> (Expr, Variable) { + // Build \lst -> list, List.walk, (\elem -> Inspect.toInspector elem) + + use Expr::*; + + let lst_sym = env.new_symbol("lst"); + let elem_sym = env.new_symbol("elem"); + + // List elem + let elem_var = env.subs.fresh_unnamed_flex_var(); + let elem_var_slice = SubsSlice::insert_into_subs(env.subs, [elem_var]); + let list_var = synth_var( + env.subs, + Content::Structure(FlatType::Apply(Symbol::LIST_LIST, elem_var_slice)), + ); + + // build `toInspector elem` type + // val -[uls]-> Inspector fmt where fmt implements InspectorFormatter + let to_inspector_fn_var = env.import_builtin_symbol_var(Symbol::INSPECT_TO_INSPECTOR); + + // elem -[clos]-> t1 + let to_inspector_clos_var = env.subs.fresh_unnamed_flex_var(); // clos + let elem_inspector_var = env.subs.fresh_unnamed_flex_var(); // t1 + let elem_to_inspector_fn_var = synth_var( + env.subs, + Content::Structure(FlatType::Func( + elem_var_slice, + to_inspector_clos_var, + elem_inspector_var, + )), + ); + + // val -[uls]-> Inspector fmt where fmt implements InspectorFormatter + // ~ elem -[clos]-> t1 + env.unify(to_inspector_fn_var, elem_to_inspector_fn_var); + + // toInspector : (typeof rcd.a) -[clos]-> Inspector fmt where fmt implements InspectorFormatter + let to_inspector_var = + AbilityMember(Symbol::INSPECT_TO_INSPECTOR, None, elem_to_inspector_fn_var); + let to_inspector_fn = Box::new(( + to_inspector_fn_var, + Loc::at_zero(to_inspector_var), + to_inspector_clos_var, + elem_inspector_var, + )); + + // toInspector elem + let to_inspector_call = Call( + to_inspector_fn, + vec![(elem_var, Loc::at_zero(Var(elem_sym, elem_var)))], + CalledVia::Space, + ); + + // elem -[to_elem_inspector]-> toInspector elem + let to_elem_inspector_sym = env.new_symbol("to_elem_inspector"); + + // Create fn_var for ambient capture; we fix it up below. + let to_elem_inspector_fn_var = synth_var(env.subs, Content::Error); + + // -[to_elem_inspector]-> + let to_elem_inspector_labels = + UnionLambdas::insert_into_subs(env.subs, once((to_elem_inspector_sym, vec![]))); + let to_elem_inspector_lset = synth_var( + env.subs, + Content::LambdaSet(LambdaSet { + solved: to_elem_inspector_labels, + recursion_var: OptVariable::NONE, + unspecialized: SubsSlice::default(), + ambient_function: to_elem_inspector_fn_var, + }), + ); + // elem -[to_elem_inspector]-> toInspector elem + env.subs.set_content( + to_elem_inspector_fn_var, + Content::Structure(FlatType::Func( + elem_var_slice, + to_elem_inspector_lset, + elem_inspector_var, + )), + ); + + // \elem -> toInspector elem + let to_elem_inspector = Closure(ClosureData { + function_type: to_elem_inspector_fn_var, + closure_type: to_elem_inspector_lset, + return_type: elem_inspector_var, + name: to_elem_inspector_sym, + captured_symbols: vec![], + recursive: Recursive::NotRecursive, + arguments: vec![( + elem_var, + AnnotatedMark::known_exhaustive(), + Loc::at_zero(Pattern::Identifier(elem_sym)), + )], + loc_body: Box::new(Loc::at_zero(to_inspector_call)), + }); + + // build `Inspect.list lst (\elem -> Inspect.toInspector elem)` type + // List e, (e -> Inspector fmt) -[uls]-> Inspector fmt where fmt implements InspectorFormatter + let inspect_list_fn_var = env.import_builtin_symbol_var(Symbol::INSPECT_LIST); + + // List elem, List.walk, to_elem_inspector_fn_var -[clos]-> t1 + let list_walk_fn_var = env.import_builtin_symbol_var(Symbol::LIST_WALK); + let this_inspect_list_args_slice = VariableSubsSlice::insert_into_subs( + env.subs, + [list_var, list_walk_fn_var, to_elem_inspector_fn_var], + ); + let this_inspect_list_clos_var = env.subs.fresh_unnamed_flex_var(); // clos + let this_list_inspector_var = env.subs.fresh_unnamed_flex_var(); // t1 + let this_inspect_list_fn_var = synth_var( + env.subs, + Content::Structure(FlatType::Func( + this_inspect_list_args_slice, + this_inspect_list_clos_var, + this_list_inspector_var, + )), + ); + + // List e, (e -> Inspector fmt) -[uls]-> Inspector fmt where fmt implements InspectorFormatter + // ~ List elem, to_elem_inspector_fn_var -[clos]-> t1 + env.unify(inspect_list_fn_var, this_inspect_list_fn_var); + + // Inspect.list : List elem, to_elem_inspector_fn_var -[clos]-> Inspector fmt where fmt implements InspectorFormatter + let inspect_list = AbilityMember(Symbol::INSPECT_LIST, None, this_inspect_list_fn_var); + let inspect_list_fn = Box::new(( + this_inspect_list_fn_var, + Loc::at_zero(inspect_list), + this_inspect_list_clos_var, + this_list_inspector_var, + )); + + // Inspect.list lst to_elem_inspector + let inspect_list_call = Call( + inspect_list_fn, + vec![ + (list_var, Loc::at_zero(Var(lst_sym, list_var))), + ( + list_walk_fn_var, + Loc::at_zero(Var(Symbol::LIST_WALK, list_walk_fn_var)), + ), + (to_elem_inspector_fn_var, Loc::at_zero(to_elem_inspector)), + ], + CalledVia::Space, + ); + + // Inspect.custom \fmt -> Inspect.apply (Inspect.list ..) fmt + let (body, this_inspector_var) = wrap_in_inspect_custom( + env, + inspect_list_call, + this_list_inspector_var, + lst_sym, + list_var, + ); + + // \lst -> Inspect.list lst (\elem -> Inspect.toInspector elem) + // Create fn_var for ambient capture; we fix it up below. + let fn_var = synth_var(env.subs, Content::Error); + + // -[fn_name]-> + let fn_name_labels = UnionLambdas::insert_into_subs(env.subs, once((fn_name, vec![]))); + let fn_clos_var = synth_var( + env.subs, + Content::LambdaSet(LambdaSet { + solved: fn_name_labels, + recursion_var: OptVariable::NONE, + unspecialized: SubsSlice::default(), + ambient_function: fn_var, + }), + ); + // List elem -[fn_name]-> Inspector fmt + let list_var_slice = SubsSlice::insert_into_subs(env.subs, once(list_var)); + env.subs.set_content( + fn_var, + Content::Structure(FlatType::Func( + list_var_slice, + fn_clos_var, + this_inspector_var, + )), + ); + + // \lst -[fn_name]-> Inspect.list lst (\elem -> Inspect.toInspector elem) + let clos = Closure(ClosureData { + function_type: fn_var, + closure_type: fn_clos_var, + return_type: this_inspector_var, + name: fn_name, + captured_symbols: vec![], + recursive: Recursive::NotRecursive, + arguments: vec![( + list_var, + AnnotatedMark::known_exhaustive(), + Loc::at_zero(Pattern::Identifier(lst_sym)), + )], + loc_body: Box::new(Loc::at_zero(body)), + }); + + (clos, fn_var) +} + +fn to_inspector_record( + env: &mut Env<'_>, + record_var: Variable, + fields: RecordFields, + fn_name: Symbol, +) -> (Expr, Variable) { + // Suppose rcd = { a: t1, b: t2 }. Build + // + // \rcd -> Inspect.record [ + // { key: "a", value: Inspect.toInspector rcd.a }, + // { key: "b", value: Inspect.toInspector rcd.b }, + // ] + + let rcd_sym = env.new_symbol("rcd"); + let whole_rcd_var = env.subs.fresh_unnamed_flex_var(); // type of the { key, value } records in the list + + use Expr::*; + + let fields_list = fields + .iter_all() + .map(|(field_name_index, field_var_index, _)| { + let field_name = env.subs[field_name_index].clone(); + let field_var = env.subs[field_var_index]; + let field_var_slice = VariableSubsSlice::new(field_var_index.index, 1); + + // key: "a" + let key_field = Field { + var: Variable::STR, + region: Region::zero(), + loc_expr: Box::new(Loc::at_zero(Str(field_name.as_str().into()))), + }; + + // rcd.a + let field_access = RecordAccess { + record_var, + ext_var: env.subs.fresh_unnamed_flex_var(), + field_var, + loc_expr: Box::new(Loc::at_zero(Var( + rcd_sym, + env.subs.fresh_unnamed_flex_var(), + ))), + field: field_name, + }; + + // build `toInspector rcd.a` type + // val -[uls]-> Inspector fmt where fmt implements InspectorFormatter + let to_inspector_fn_var = env.import_builtin_symbol_var(Symbol::INSPECT_TO_INSPECTOR); + + // (typeof rcd.a) -[clos]-> t1 + let to_inspector_clos_var = env.subs.fresh_unnamed_flex_var(); // clos + let inspector_var = env.subs.fresh_unnamed_flex_var(); // t1 + let this_to_inspector_fn_var = synth_var( + env.subs, + Content::Structure(FlatType::Func( + field_var_slice, + to_inspector_clos_var, + inspector_var, + )), + ); + + // val -[uls]-> Inspector fmt where fmt implements InspectorFormatter + // ~ (typeof rcd.a) -[clos]-> t1 + env.unify(to_inspector_fn_var, this_to_inspector_fn_var); + + // toInspector : (typeof rcd.a) -[clos]-> Inspector fmt where fmt implements InspectorFormatter + let to_inspector_var = + AbilityMember(Symbol::INSPECT_TO_INSPECTOR, None, to_inspector_fn_var); + let to_inspector_fn = Box::new(( + to_inspector_fn_var, + Loc::at_zero(to_inspector_var), + to_inspector_clos_var, + inspector_var, + )); + + // toInspector rcd.a + let to_inspector_call = Call( + to_inspector_fn, + vec![(field_var, Loc::at_zero(field_access))], + CalledVia::Space, + ); + + // value: toInspector rcd.a + let value_field = Field { + var: inspector_var, + region: Region::zero(), + loc_expr: Box::new(Loc::at_zero(to_inspector_call)), + }; + + // { key: "a", value: toInspector rcd.a } + let mut kv = SendMap::default(); + kv.insert("key".into(), key_field); + kv.insert("value".into(), value_field); + + let this_record_fields = RecordFields::insert_into_subs( + env.subs, + (once(("key".into(), RecordField::Required(Variable::STR)))) + .chain(once(("value".into(), RecordField::Required(inspector_var)))), + ); + let this_record_var = synth_var( + env.subs, + Content::Structure(FlatType::Record(this_record_fields, Variable::EMPTY_RECORD)), + ); + // NOTE: must be done to unify the lambda sets under `inspector_var` + env.unify(this_record_var, whole_rcd_var); + + Loc::at_zero(Record { + record_var: whole_rcd_var, + fields: kv, + }) + }) + .collect::>(); + + // typeof [ { key: .., value: .. }, { key: .., value: .. } ] + let fields_rcd_var_slice = VariableSubsSlice::insert_into_subs(env.subs, once(whole_rcd_var)); + let fields_list_var = synth_var( + env.subs, + Content::Structure(FlatType::Apply(Symbol::LIST_LIST, fields_rcd_var_slice)), + ); + + // [ { key: .., value: ..}, .. ] + let fields_list = List { + elem_var: whole_rcd_var, + loc_elems: fields_list, + }; + + // build `Inspect.record [ { key: .., value: ..}, .. ]` type + // List { key : Str, value : Inspector fmt } -[uls]-> Inspector fmt where fmt implements InspectorFormatter + let inspect_record_fn_var = env.import_builtin_symbol_var(Symbol::INSPECT_RECORD); + + // fields_list_var -[clos]-> t1 + let fields_list_var_slice = + VariableSubsSlice::insert_into_subs(env.subs, once(fields_list_var)); + let inspect_record_clos_var = env.subs.fresh_unnamed_flex_var(); // clos + let inspector_var = env.subs.fresh_unnamed_flex_var(); // t1 + let this_inspect_record_fn_var = synth_var( + env.subs, + Content::Structure(FlatType::Func( + fields_list_var_slice, + inspect_record_clos_var, + inspector_var, + )), + ); + + // List { key : Str, value : Inspector fmt } -[uls]-> Inspector fmt where fmt implements InspectorFormatter + // ~ fields_list_var -[clos]-> t1 + env.unify(inspect_record_fn_var, this_inspect_record_fn_var); + + // Inspect.record : fields_list_var -[clos]-> Inspector fmt where fmt implements InspectorFormatter + let inspect_record_var = AbilityMember(Symbol::INSPECT_RECORD, None, inspect_record_fn_var); + let inspect_record_fn = Box::new(( + inspect_record_fn_var, + Loc::at_zero(inspect_record_var), + inspect_record_clos_var, + inspector_var, + )); + + // Inspect.record [ { key: .., value: .. }, .. ] + let inspect_record_call = Call( + inspect_record_fn, + vec![(fields_list_var, Loc::at_zero(fields_list))], + CalledVia::Space, + ); + + // Inspect.custom \fmt -> Inspect.apply (Inspect.record ..) fmt + let (body, this_inspector_var) = + wrap_in_inspect_custom(env, inspect_record_call, inspector_var, rcd_sym, record_var); + + // Create fn_var for ambient capture; we fix it up below. + let fn_var = synth_var(env.subs, Content::Error); + + // -[fn_name]-> + let fn_name_labels = UnionLambdas::insert_into_subs(env.subs, once((fn_name, vec![]))); + let fn_clos_var = synth_var( + env.subs, + Content::LambdaSet(LambdaSet { + solved: fn_name_labels, + recursion_var: OptVariable::NONE, + unspecialized: SubsSlice::default(), + ambient_function: fn_var, + }), + ); + // typeof rcd -[fn_name]-> (typeof Inspect.record [ .. ] = Inspector fmt) + let record_var_slice = SubsSlice::insert_into_subs(env.subs, once(record_var)); + env.subs.set_content( + fn_var, + Content::Structure(FlatType::Func( + record_var_slice, + fn_clos_var, + this_inspector_var, + )), + ); + + // \rcd -[fn_name]-> Inspect.record [ { key: .., value: .. }, .. ] + let clos = Closure(ClosureData { + function_type: fn_var, + closure_type: fn_clos_var, + return_type: this_inspector_var, + name: fn_name, + captured_symbols: vec![], + recursive: Recursive::NotRecursive, + arguments: vec![( + record_var, + AnnotatedMark::known_exhaustive(), + Loc::at_zero(Pattern::Identifier(rcd_sym)), + )], + loc_body: Box::new(Loc::at_zero(body)), + }); + + (clos, fn_var) +} + +fn to_inspector_tuple( + env: &mut Env<'_>, + tuple_var: Variable, + elems: TupleElems, + fn_name: Symbol, +) -> (Expr, Variable) { + // Suppose tup = (t1, t2). Build + // + // \tup -> Inspect.tuple [ + // Inspect.toInspector tup.0, + // Inspect.toInspector tup.1, + // ] + + let tup_sym = env.new_symbol("tup"); + let whole_inspector_in_list_var = env.subs.fresh_unnamed_flex_var(); // type of the inspector in the list + + use Expr::*; + + let elem_inspectors_list = elems + .iter_all() + .map(|(elem_index, elem_var_index)| { + let index = env.subs[elem_index]; + let elem_var = env.subs[elem_var_index]; + let elem_var_slice = VariableSubsSlice::new(elem_var_index.index, 1); + + // tup.0 + let tuple_access = TupleAccess { + tuple_var, + ext_var: env.subs.fresh_unnamed_flex_var(), + elem_var, + loc_expr: Box::new(Loc::at_zero(Var( + tup_sym, + env.subs.fresh_unnamed_flex_var(), + ))), + index, + }; + + // build `toInspector tup.0` type + // val -[uls]-> Inspector fmt where fmt implements InspectorFormatter + let to_inspector_fn_var = env.import_builtin_symbol_var(Symbol::INSPECT_TO_INSPECTOR); + + // (typeof tup.0) -[clos]-> t1 + let to_inspector_clos_var = env.subs.fresh_unnamed_flex_var(); // clos + let inspector_var = env.subs.fresh_unnamed_flex_var(); // t1 + let this_to_inspector_fn_var = synth_var( + env.subs, + Content::Structure(FlatType::Func( + elem_var_slice, + to_inspector_clos_var, + inspector_var, + )), + ); + + // val -[uls]-> Inspector fmt where fmt implements InspectorFormatter + // ~ (typeof tup.0) -[clos]-> t1 + env.unify(to_inspector_fn_var, this_to_inspector_fn_var); + + // toInspector : (typeof tup.0) -[clos]-> Inspector fmt where fmt implements InspectorFormatter + let to_inspector_var = + AbilityMember(Symbol::INSPECT_TO_INSPECTOR, None, to_inspector_fn_var); + let to_inspector_fn = Box::new(( + to_inspector_fn_var, + Loc::at_zero(to_inspector_var), + to_inspector_clos_var, + inspector_var, + )); + + // toInspector tup.0 + let to_inspector_call = Call( + to_inspector_fn, + vec![(elem_var, Loc::at_zero(tuple_access))], + CalledVia::Space, + ); + + // NOTE: must be done to unify the lambda sets under `inspector_var` + env.unify(inspector_var, whole_inspector_in_list_var); + + Loc::at_zero(to_inspector_call) + }) + .collect::>(); + + // typeof [ toInspector tup.0, toInspector tup.1 ] + let whole_inspector_in_list_var_slice = + VariableSubsSlice::insert_into_subs(env.subs, once(whole_inspector_in_list_var)); + let elem_inspectors_list_var = synth_var( + env.subs, + Content::Structure(FlatType::Apply( + Symbol::LIST_LIST, + whole_inspector_in_list_var_slice, + )), + ); + + // [ toInspector tup.0, toInspector tup.1 ] + let elem_inspectors_list = List { + elem_var: whole_inspector_in_list_var, + loc_elems: elem_inspectors_list, + }; + + // build `Inspect.tuple [ toInspector tup.0, toInspector tup.1 ]` type + // List (Inspector fmt) -[uls]-> Inspector fmt where fmt implements InspectorFormatter + let inspect_tuple_fn_var = env.import_builtin_symbol_var(Symbol::INSPECT_TUPLE); + + // elem_inspectors_list_var -[clos]-> t1 + let elem_inspectors_list_var_slice = + VariableSubsSlice::insert_into_subs(env.subs, once(elem_inspectors_list_var)); + let inspect_tuple_clos_var = env.subs.fresh_unnamed_flex_var(); // clos + let inspector_var = env.subs.fresh_unnamed_flex_var(); // t1 + let this_inspect_tuple_fn_var = synth_var( + env.subs, + Content::Structure(FlatType::Func( + elem_inspectors_list_var_slice, + inspect_tuple_clos_var, + inspector_var, + )), + ); + + // List (Inspector fmt) -[uls]-> Inspector fmt where fmt implements InspectorFormatter + // ~ elem_inspectors_list_var -[clos]-> t1 + env.unify(inspect_tuple_fn_var, this_inspect_tuple_fn_var); + + // Inspect.tuple : elem_inspectors_list_var -[clos]-> Inspector fmt where fmt implements InspectorFormatter + let inspect_tuple_var = AbilityMember(Symbol::INSPECT_TUPLE, None, inspect_tuple_fn_var); + let inspect_tuple_fn = Box::new(( + inspect_tuple_fn_var, + Loc::at_zero(inspect_tuple_var), + inspect_tuple_clos_var, + inspector_var, + )); + + // Inspect.tuple [ { key: .., value: .. }, .. ] + let inspect_tuple_call = Call( + inspect_tuple_fn, + vec![(elem_inspectors_list_var, Loc::at_zero(elem_inspectors_list))], + CalledVia::Space, + ); + + // Inspect.custom \fmt -> Inspect.apply (Inspect.tuple_var ..) fmt + let (body, this_inspector_var) = + wrap_in_inspect_custom(env, inspect_tuple_call, inspector_var, tup_sym, tuple_var); + + // Create fn_var for ambient capture; we fix it up below. + let fn_var = synth_var(env.subs, Content::Error); + + // -[fn_name]-> + let fn_name_labels = UnionLambdas::insert_into_subs(env.subs, once((fn_name, vec![]))); + let fn_clos_var = synth_var( + env.subs, + Content::LambdaSet(LambdaSet { + solved: fn_name_labels, + recursion_var: OptVariable::NONE, + unspecialized: SubsSlice::default(), + ambient_function: fn_var, + }), + ); + // typeof tup -[fn_name]-> (typeof Inspect.tuple [ .. ] = Inspector fmt) + let tuple_var_slice = SubsSlice::insert_into_subs(env.subs, once(tuple_var)); + env.subs.set_content( + fn_var, + Content::Structure(FlatType::Func( + tuple_var_slice, + fn_clos_var, + this_inspector_var, + )), + ); + + // \tup -[fn_name]-> Inspect.tuple [ { key: .., value: .. }, .. ] + let clos = Closure(ClosureData { + function_type: fn_var, + closure_type: fn_clos_var, + return_type: this_inspector_var, + name: fn_name, + captured_symbols: vec![], + recursive: Recursive::NotRecursive, + arguments: vec![( + tuple_var, + AnnotatedMark::known_exhaustive(), + Loc::at_zero(Pattern::Identifier(tup_sym)), + )], + loc_body: Box::new(Loc::at_zero(body)), + }); + + (clos, fn_var) +} + +fn to_inspector_tag_union( + env: &mut Env<'_>, + tag_union_var: Variable, + tags: UnionTags, + fn_name: Symbol, +) -> (Expr, Variable) { + // Suppose tag = [ A t1 t2, B t3 ]. Build + // + // \tag -> when tag is + // A v1 v2 -> Inspect.tag "A" [ Inspect.toInspector v1, Inspect.toInspector v2 ] + // B v3 -> Inspect.tag "B" [ Inspect.toInspector v3 ] + + let tag_sym = env.new_symbol("tag"); + let whole_tag_inspectors_var = env.subs.fresh_unnamed_flex_var(); // type of the Inspect.tag ... calls in the branch bodies + + use Expr::*; + + let branches = tags + .iter_all() + .map(|(tag_name_index, tag_vars_slice_index)| { + // A + let tag_name = &env.subs[tag_name_index].clone(); + let vars_slice = env.subs[tag_vars_slice_index]; + // t1 t2 + let payload_vars = env.subs.get_subs_slice(vars_slice).to_vec(); + // v1 v2 + let payload_syms: Vec<_> = std::iter::repeat_with(|| env.unique_symbol()) + .take(payload_vars.len()) + .collect(); + + // `A v1 v2` pattern + let pattern = Pattern::AppliedTag { + whole_var: tag_union_var, + tag_name: tag_name.clone(), + ext_var: Variable::EMPTY_TAG_UNION, + // (t1, v1) (t2, v2) + arguments: (payload_vars.iter()) + .zip(payload_syms.iter()) + .map(|(var, sym)| (*var, Loc::at_zero(Pattern::Identifier(*sym)))) + .collect(), + }; + let branch_pattern = WhenBranchPattern { + pattern: Loc::at_zero(pattern), + degenerate: false, + }; + + // whole type of the elements in [ Inspect.toInspector v1, Inspect.toInspector v2 ] + let whole_payload_inspectors_var = env.subs.fresh_unnamed_flex_var(); + // [ Inspect.toInspector v1, Inspect.toInspector v2 ] + let payload_to_inspectors = (payload_syms.iter()) + .zip(payload_vars.iter()) + .map(|(&sym, &sym_var)| { + // build `toInspector v1` type + // expected: val -[uls]-> Inspector fmt where fmt implements InspectorFormatter + let to_inspector_fn_var = + env.import_builtin_symbol_var(Symbol::INSPECT_TO_INSPECTOR); + + // wanted: t1 -[clos]-> t' + let var_slice_of_sym_var = + VariableSubsSlice::insert_into_subs(env.subs, [sym_var]); // [ t1 ] + let to_inspector_clos_var = env.subs.fresh_unnamed_flex_var(); // clos + let inspector_var = env.subs.fresh_unnamed_flex_var(); // t' + let this_to_inspector_fn_var = synth_var( + env.subs, + Content::Structure(FlatType::Func( + var_slice_of_sym_var, + to_inspector_clos_var, + inspector_var, + )), + ); + + // val -[uls]-> Inspector fmt where fmt implements InspectorFormatter + // ~ t1 -[clos]-> t' + env.unify(to_inspector_fn_var, this_to_inspector_fn_var); + + // toInspector : t1 -[clos]-> Inspector fmt where fmt implements InspectorFormatter + let to_inspector_var = + AbilityMember(Symbol::INSPECT_TO_INSPECTOR, None, this_to_inspector_fn_var); + let to_inspector_fn = Box::new(( + this_to_inspector_fn_var, + Loc::at_zero(to_inspector_var), + to_inspector_clos_var, + inspector_var, + )); + + // toInspector rcd.a + let to_inspector_call = Call( + to_inspector_fn, + vec![(sym_var, Loc::at_zero(Var(sym, sym_var)))], + CalledVia::Space, + ); + + // NOTE: must be done to unify the lambda sets under `inspector_var` + env.unify(inspector_var, whole_payload_inspectors_var); + + Loc::at_zero(to_inspector_call) + }) + .collect(); + + // typeof [ Inspect.toInspector v1, Inspect.toInspector v2 ] + let whole_inspectors_var_slice = + VariableSubsSlice::insert_into_subs(env.subs, [whole_payload_inspectors_var]); + let payload_inspectors_list_var = synth_var( + env.subs, + Content::Structure(FlatType::Apply( + Symbol::LIST_LIST, + whole_inspectors_var_slice, + )), + ); + + // [ Inspect.toInspector v1, Inspect.toInspector v2 ] + let payload_inspectors_list = List { + elem_var: whole_payload_inspectors_var, + loc_elems: payload_to_inspectors, + }; + + // build `Inspect.tag "A" [ ... ]` type + // expected: Str, List (Inspector fmt) -[uls]-> Inspector fmt where fmt implements InspectorFormatter + let inspect_tag_fn_var = env.import_builtin_symbol_var(Symbol::INSPECT_TAG); + + // wanted: Str, List whole_inspectors_var -[clos]-> t' + let this_inspect_tag_args_var_slice = VariableSubsSlice::insert_into_subs( + env.subs, + [Variable::STR, payload_inspectors_list_var], + ); + let this_inspect_tag_clos_var = env.subs.fresh_unnamed_flex_var(); // -[clos]-> + let this_inspector_var = env.subs.fresh_unnamed_flex_var(); // t' + let this_inspect_tag_fn_var = synth_var( + env.subs, + Content::Structure(FlatType::Func( + this_inspect_tag_args_var_slice, + this_inspect_tag_clos_var, + this_inspector_var, + )), + ); + + // Str, List (Inspector fmt) -[uls]-> Inspector fmt where fmt implements InspectorFormatter + // ~ Str, List whole_inspectors_var -[clos]-> t' + env.unify(inspect_tag_fn_var, this_inspect_tag_fn_var); + + // Inspect.tag : Str, List whole_inspectors_var -[clos]-> Inspector fmt where fmt implements InspectorFormatter + let inspect_tag_var = AbilityMember(Symbol::INSPECT_TAG, None, this_inspect_tag_fn_var); + let inspect_tag_fn = Box::new(( + this_inspect_tag_fn_var, + Loc::at_zero(inspect_tag_var), + this_inspect_tag_clos_var, + this_inspector_var, + )); + + // Inspect.tag "A" [ Inspect.toInspector v1, Inspect.toInspector v2 ] + let inspect_tag_call = Call( + inspect_tag_fn, + vec![ + // (Str, "A") + (Variable::STR, Loc::at_zero(Str(tag_name.0.as_str().into()))), + // (List (Inspector fmt), [ Inspect.toInspector v1, Inspect.toInspector v2 ]) + ( + payload_inspectors_list_var, + Loc::at_zero(payload_inspectors_list), + ), + ], + CalledVia::Space, + ); + + // NOTE: must be done to unify the lambda sets under `inspector_var` + // Inspect.tag "A" [ Inspect.toInspector v1, Inspect.toInspector v2 ] ~ whole_inspectors + env.unify(this_inspector_var, whole_tag_inspectors_var); + + WhenBranch { + patterns: vec![branch_pattern], + value: Loc::at_zero(inspect_tag_call), + guard: None, + redundant: RedundantMark::known_non_redundant(), + } + }) + .collect::>(); + + // when tag is + // A v1 v2 -> Inspect.tag "A" [ Inspect.toInspector v1, Inspect.toInspector v2 ] + // B v3 -> Inspect.tag "B" [ Inspect.toInspector v3 ] + let when_branches = When { + loc_cond: Box::new(Loc::at_zero(Var(tag_sym, tag_union_var))), + cond_var: tag_union_var, + expr_var: whole_tag_inspectors_var, + region: Region::zero(), + branches, + branches_cond_var: tag_union_var, + exhaustive: ExhaustiveMark::known_exhaustive(), + }; + + // Inspect.custom \fmt -> Inspect.apply (when ..) fmt + let (body, this_inspector_var) = wrap_in_inspect_custom( + env, + when_branches, + whole_tag_inspectors_var, + tag_sym, + tag_union_var, + ); + + // Create fn_var for ambient capture; we fix it up below. + let fn_var = synth_var(env.subs, Content::Error); + + // -[fn_name]-> + let fn_name_labels = UnionLambdas::insert_into_subs(env.subs, once((fn_name, vec![]))); + let fn_clos_var = synth_var( + env.subs, + Content::LambdaSet(LambdaSet { + solved: fn_name_labels, + recursion_var: OptVariable::NONE, + unspecialized: SubsSlice::default(), + ambient_function: fn_var, + }), + ); + // tag_union_var -[fn_name]-> whole_tag_inspectors_var + let tag_union_var_slice = SubsSlice::insert_into_subs(env.subs, once(tag_union_var)); + env.subs.set_content( + fn_var, + Content::Structure(FlatType::Func( + tag_union_var_slice, + fn_clos_var, + this_inspector_var, + )), + ); + + // \tag -> + // Inspect.custom \fmt -> Inspect.apply ( + // when tag is + // A v1 v2 -> Inspect.tag "A" [ Inspect.toInspector v1, Inspect.toInspector v2 ] + // B v3 -> Inspect.tag "B" [ Inspect.toInspector v3 ]) + // fmt + let clos = Closure(ClosureData { + function_type: fn_var, + closure_type: fn_clos_var, + return_type: this_inspector_var, + name: fn_name, + captured_symbols: vec![], + recursive: Recursive::NotRecursive, + arguments: vec![( + tag_union_var, + AnnotatedMark::known_exhaustive(), + Loc::at_zero(Pattern::Identifier(tag_sym)), + )], + loc_body: Box::new(Loc::at_zero(body)), + }); + + (clos, fn_var) +} + +/// Lift `inspector` to `Inspect.custom \fmt -> Inspect.apply inspector fmt` +fn wrap_in_inspect_custom( + env: &mut Env, + inspector: Expr, + inspector_var: Variable, + captured_symbol: Symbol, + captured_var: Variable, +) -> (Expr, Variable) { + use Expr::*; + + let fn_name = env.new_symbol("custom"); + + // fmt: fmt where fmt implements InspectorFormatter + let fmt_sym = env.new_symbol("fmt"); + let fmt_var = env.subs.fresh_unnamed_flex_var(); + + // build `Inspect.apply inspector fmt` type + // expected: Inspect.apply : Inspector fmt, fmt -[apply]-> fmt where fmt implements InspectorFormatter + let apply_fn_var = env.import_builtin_symbol_var(Symbol::INSPECT_APPLY); + + // wanted: Inspect.apply : inspector_var, fmt -[clos]-> fmt where fmt implements InspectorFormatter + let this_apply_args_var_slice = + VariableSubsSlice::insert_into_subs(env.subs, [inspector_var, fmt_var]); + let this_apply_clos_var = env.subs.fresh_unnamed_flex_var(); // -[clos]-> + let this_apply_fn_var = synth_var( + env.subs, + Content::Structure(FlatType::Func( + this_apply_args_var_slice, + this_apply_clos_var, + fmt_var, + )), + ); + + // Inspector fmt, fmt -[apply]-> ft where fmt implements InspectorFormatter + // ~ inspector_var, fmt -[clos]-> fmt where fmt implements InspectorFormatter + env.unify(apply_fn_var, this_apply_fn_var); + + // Inspect.apply : inspector_var, fmt -[apply]-> fmt where fmt implements InspectorFormatter + let apply_fn = Box::new(( + this_apply_fn_var, + Loc::at_zero(Var(Symbol::INSPECT_APPLY, this_apply_fn_var)), + this_apply_clos_var, + fmt_var, + )); + + // Inspect.apply inspector fmt + let apply_call = Call( + apply_fn, + vec![ + // (inspector_var, inspector) + (inspector_var, Loc::at_zero(inspector)), + // (fmt, fmt_var) + (fmt_var, Loc::at_zero(Var(fmt_sym, fmt_var))), + ], + CalledVia::Space, + ); + + // Create fn_var for ambient capture; we fix it up below. + let fn_var = synth_var(env.subs, Content::Error); + + // -[[FN_name captured_var]]-> + let fn_name_labels = + UnionLambdas::insert_into_subs(env.subs, once((fn_name, vec![captured_var]))); + let fn_clos_var = synth_var( + env.subs, + Content::LambdaSet(LambdaSet { + solved: fn_name_labels, + recursion_var: OptVariable::NONE, + unspecialized: SubsSlice::default(), + ambient_function: fn_var, + }), + ); + + // fmt -[[FN_name captured_var]]-> Inspect.apply inspector fmt + let args_slice = SubsSlice::insert_into_subs(env.subs, vec![fmt_var]); + env.subs.set_content( + fn_var, + Content::Structure(FlatType::Func(args_slice, fn_clos_var, fmt_var)), + ); + + // \fmt -[[fn_name captured_var]]-> Inspect.apply inspector fmt + let clos = Closure(ClosureData { + function_type: fn_var, + closure_type: fn_clos_var, + return_type: fmt_var, + name: fn_name, + captured_symbols: vec![(captured_symbol, captured_var)], + recursive: Recursive::NotRecursive, + arguments: vec![( + fmt_var, + AnnotatedMark::known_exhaustive(), + Loc::at_zero(Pattern::Identifier(fmt_sym)), + )], + loc_body: Box::new(Loc::at_zero(apply_call)), + }); + + // Build + // Inspect.custom \fmt -> Inspect.apply inspector fmt + // + // expected: Inspect.custom : (fmt -> fmt) -> Inspector fmt where fmt implements InspectorFormatter + let custom_fn_var = env.import_builtin_symbol_var(Symbol::INSPECT_CUSTOM); + + // wanted: Inspect.custom : fn_var -[clos]-> t' + let this_custom_args_var_slice = VariableSubsSlice::insert_into_subs(env.subs, [fn_var]); + let this_custom_clos_var = env.subs.fresh_unnamed_flex_var(); // -[clos]-> + let this_custom_inspector_var = env.subs.fresh_unnamed_flex_var(); // t' + let this_custom_fn_var = synth_var( + env.subs, + Content::Structure(FlatType::Func( + this_custom_args_var_slice, + this_custom_clos_var, + this_custom_inspector_var, + )), + ); + + // (fmt -> fmt) -[..]-> Inspector fmt where fmt implements InspectorFormatter + // ~ fn_var -[clos]-> t' + env.unify(custom_fn_var, this_custom_fn_var); + + // Inspect.custom : (fmt -> fmt) -> Inspector fmt where fmt implements InspectorFormatter + let custom_fn = Box::new(( + this_custom_fn_var, + Loc::at_zero(Var(Symbol::INSPECT_CUSTOM, this_custom_fn_var)), + this_custom_clos_var, // -[clos]-> + this_custom_inspector_var, // t' ~ Inspector fmt + )); + + // Inspect.custom \fmt -> Inspect.apply inspector fmt + let custom_call = Call( + custom_fn, + vec![(fn_var, Loc::at_zero(clos))], + CalledVia::Space, + ); + + (custom_call, this_custom_inspector_var) +} diff --git a/crates/compiler/derive/src/lib.rs b/crates/compiler/derive/src/lib.rs index 43d547ddb5..fdb4679d6e 100644 --- a/crates/compiler/derive/src/lib.rs +++ b/crates/compiler/derive/src/lib.rs @@ -19,7 +19,7 @@ use util::Env; mod decoding; mod encoding; mod hash; - +mod inspect; mod util; pub(crate) const DERIVED_SYNTH: ModuleId = ModuleId::DERIVED_SYNTH; @@ -79,6 +79,9 @@ fn build_derived_body( decoding::derive_decoder(&mut env, decoder_key, derived_symbol) } DeriveKey::Hash(hash_key) => hash::derive_hash(&mut env, hash_key, derived_symbol), + DeriveKey::ToInspector(to_inspector_key) => { + inspect::derive_to_inspector(&mut env, to_inspector_key, derived_symbol) + } }; let def = Def { diff --git a/crates/compiler/derive_key/src/encoding.rs b/crates/compiler/derive_key/src/encoding.rs index 10211ea5b3..423941bc7d 100644 --- a/crates/compiler/derive_key/src/encoding.rs +++ b/crates/compiler/derive_key/src/encoding.rs @@ -55,6 +55,7 @@ impl FlatEncodable { FlatType::Record(fields, ext) => { let (fields_iter, ext) = fields.unsorted_iterator_and_ext(subs, ext); + // TODO someday we can put #[cfg(debug_assertions)] around this, but for now let's always do it. check_derivable_ext_var(subs, ext, |ext| { matches!(ext, Content::Structure(FlatType::EmptyRecord)) })?; @@ -71,6 +72,7 @@ impl FlatEncodable { FlatType::Tuple(elems, ext) => { let (elems_iter, ext) = elems.sorted_iterator_and_ext(subs, ext); + // TODO someday we can put #[cfg(debug_assertions)] around this, but for now let's always do it. check_derivable_ext_var(subs, ext, |ext| { matches!(ext, Content::Structure(FlatType::EmptyTuple)) })?; @@ -89,6 +91,7 @@ impl FlatEncodable { // `t`-prefixed payload types. let (tags_iter, ext) = tags.unsorted_tags_and_ext(subs, ext); + // TODO someday we can put #[cfg(debug_assertions)] around this, but for now let's always do it. check_derivable_ext_var(subs, ext.var(), |ext| { matches!(ext, Content::Structure(FlatType::EmptyTagUnion)) })?; @@ -115,10 +118,9 @@ impl FlatEncodable { ))) } FlatType::EmptyRecord => Ok(Key(FlatEncodableKey::Record(vec![]))), - FlatType::EmptyTuple => todo!(), FlatType::EmptyTagUnion => Ok(Key(FlatEncodableKey::TagUnion(vec![]))), - // FlatType::Func(..) => Err(Underivable), + FlatType::EmptyTuple => unreachable!("Somehow Encoding derivation got an expression that's an empty tuple, which shouldn't be possible!"), }, Content::Alias(sym, _, real_var, _) => match from_builtin_symbol(sym) { Some(lambda) => lambda, @@ -129,9 +131,7 @@ impl FlatEncodable { Content::RangedNumber(range) => { Self::from_var(subs, range.default_compilation_variable()) } - // Content::RecursionVar { structure, .. } => Self::from_var(subs, structure), - // Content::Error => Err(Underivable), Content::FlexVar(_) | Content::RigidVar(_) diff --git a/crates/compiler/derive_key/src/inspect.rs b/crates/compiler/derive_key/src/inspect.rs new file mode 100644 index 0000000000..a796efc63d --- /dev/null +++ b/crates/compiler/derive_key/src/inspect.rs @@ -0,0 +1,211 @@ +use roc_module::{ + ident::{Lowercase, TagName}, + symbol::Symbol, +}; +use roc_types::{ + subs::{Content, FlatType, GetSubsSlice, Subs, Variable}, + types::AliasKind, +}; + +use crate::util::{ + check_derivable_ext_var, debug_name_fn, debug_name_record, debug_name_tag, debug_name_tuple, +}; + +#[derive(Hash, Debug)] +pub enum FlatInspectable { + Immediate(Symbol), + Key(FlatInspectableKey), +} + +#[derive(Hash, PartialEq, Eq, Debug, Clone)] +pub enum FlatInspectableKey { + List(/* takes one variable */), + Set(/* takes one variable */), + Dict(/* takes two variables */), + // Unfortunate that we must allocate here, c'est la vie + Record(Vec), + Tuple(u32), + TagUnion(Vec<(TagName, u16)>), + Function(u32 /* arity; +1 for return type */), + /// This means specifically an opaque type where the author hasn't requested that it derive Inspect (or implemented it) + Opaque, + Error, +} + +impl FlatInspectableKey { + pub(crate) fn debug_name(&self) -> String { + match self { + FlatInspectableKey::List() => "list".to_string(), + FlatInspectableKey::Set() => "set".to_string(), + FlatInspectableKey::Dict() => "dict".to_string(), + FlatInspectableKey::Record(fields) => debug_name_record(fields), + FlatInspectableKey::Tuple(arity) => debug_name_tuple(*arity), + FlatInspectableKey::TagUnion(tags) => debug_name_tag(tags), + FlatInspectableKey::Function(arity) => debug_name_fn(*arity), + FlatInspectableKey::Error => "error".to_string(), + FlatInspectableKey::Opaque => "opaque".to_string(), + } + } +} + +impl FlatInspectable { + pub(crate) fn from_var(subs: &Subs, var: Variable) -> FlatInspectable { + use FlatInspectable::*; + + match *subs.get_content_without_compacting(var) { + Content::Structure(flat_type) => match flat_type { + FlatType::Apply(sym, _) => match sym { + Symbol::LIST_LIST => Key(FlatInspectableKey::List()), + Symbol::SET_SET => Key(FlatInspectableKey::Set()), + Symbol::DICT_DICT => Key(FlatInspectableKey::Dict()), + Symbol::STR_STR => Immediate(Symbol::INSPECT_STR), + _ => Immediate(Symbol::INSPECT_OPAQUE), + }, + FlatType::Record(fields, ext) => { + let (fields_iter, ext) = fields.unsorted_iterator_and_ext(subs, ext); + + // TODO someday we can put #[cfg(debug_assertions)] around this, but for now let's always do it. + check_derivable_ext_var(subs, ext, |ext| { + matches!(ext, Content::Structure(FlatType::EmptyRecord)) + }).expect("Compiler error: unexpected nonempty ext var when deriving Inspect for record"); + + let mut field_names = Vec::with_capacity(fields.len()); + for (field_name, _) in fields_iter { + field_names.push(field_name.clone()); + } + + field_names.sort(); + + Key(FlatInspectableKey::Record(field_names)) + } + FlatType::Tuple(elems, ext) => { + let (elems_iter, ext) = elems.sorted_iterator_and_ext(subs, ext); + + // TODO someday we can put #[cfg(debug_assertions)] around this, but for now let's always do it. + check_derivable_ext_var(subs, ext, |ext| { + matches!(ext, Content::Structure(FlatType::EmptyTuple)) + }).expect("Compiler error: unexpected nonempty ext var when deriving Inspect for tuple"); + + Key(FlatInspectableKey::Tuple(elems_iter.count() as _)) + } + FlatType::TagUnion(tags, ext) | FlatType::RecursiveTagUnion(_, tags, ext) => { + // The recursion var doesn't matter, because the derived implementation will only + // look on the surface of the tag union type, and more over the payloads of the + // arguments will be left generic for the monomorphizer to fill in with the + // appropriate type. That is, + // [ A t1, B t1 t2 ] + // and + // [ A t1, B t1 t2 ] as R + // look the same on the surface, because `R` is only somewhere inside of the + // `t`-prefixed payload types. + let (tags_iter, ext) = tags.unsorted_tags_and_ext(subs, ext); + + // TODO someday we can put #[cfg(debug_assertions)] around this, but for now let's always do it. + check_derivable_ext_var(subs, ext.var(), |ext| { + matches!(ext, Content::Structure(FlatType::EmptyTagUnion)) + }).expect("Compiler error: unexpected nonempty ext var when deriving Inspect for tag union"); + + let mut tag_names_and_payload_sizes: Vec<_> = tags_iter + .tags + .into_iter() + .map(|(name, payload_slice)| { + let payload_size = payload_slice.len(); + (name.clone(), payload_size as _) + }) + .collect(); + + tag_names_and_payload_sizes.sort_by(|(t1, _), (t2, _)| t1.cmp(t2)); + + Key(FlatInspectableKey::TagUnion(tag_names_and_payload_sizes)) + } + FlatType::FunctionOrTagUnion(names_index, _, _) => { + Key(FlatInspectableKey::TagUnion( + subs.get_subs_slice(names_index) + .iter() + .map(|t| (t.clone(), 0)) + .collect(), + )) + } + FlatType::EmptyRecord => Key(FlatInspectableKey::Record(Vec::new())), + FlatType::EmptyTagUnion => Key(FlatInspectableKey::TagUnion(Vec::new())), + FlatType::Func(..) => { + Immediate(Symbol::INSPECT_FUNCTION) + } + FlatType::EmptyTuple => unreachable!("Somehow Inspect derivation got an expression that's an empty tuple, which shouldn't be possible!"), + }, + Content::Alias(sym, _, real_var, kind) => match Self::from_builtin_alias(sym) { + Some(lambda) => lambda, + + _ => { + match kind { + AliasKind::Structural => { + Self::from_var(subs, real_var) + } + // Special case, an unbound `Frac *` will become a `Dec`. + AliasKind::Opaque if matches!(*subs.get_content_without_compacting(real_var), Content::FlexVar(_) | Content::FlexAbleVar(_, _)) => { + Immediate(Symbol::INSPECT_DEC) + } + AliasKind::Opaque if sym.is_builtin() => { + Self::from_var(subs, real_var) + } + AliasKind::Opaque => { + // There are two cases in which `Inspect` can be derived for an opaque + // type. + // 1. An opaque type claims to implement `Inspect` and asks us to + // auto-derive it. E.g. + // + // ```text + // Op := {} implements [Inspect] + // ``` + // + // In this case, we generate a synthetic implementation during + // canonicalization that defers to `inspect`ing the inner type. As + // such, this case is never reached in this branch. + // + // 2. An opaque type does not explicitly claim to implement + // `Inspect`. In this case, we print a default opaque string for + // the opaque type. + Immediate(Symbol::INSPECT_OPAQUE) + } + } + } + + }, + Content::RangedNumber(range) => { + Self::from_var(subs, range.default_compilation_variable()) + } + Content::RecursionVar { structure, .. } => Self::from_var(subs, structure), + Content::Error => Key(FlatInspectableKey::Error), + Content::FlexVar(_) + | Content::RigidVar(_) + | Content::FlexAbleVar(_, _) + | Content::RigidAbleVar(_, _) + | Content::LambdaSet(_) | Content::ErasedLambda => { + unreachable!("There must have been a bug in the solver, because we're trying to derive Inspect on a non-concrete type."); + } + } + } + + pub(crate) const fn from_builtin_alias(symbol: Symbol) -> Option { + use FlatInspectable::*; + + match symbol { + Symbol::BOOL_BOOL => Some(Immediate(Symbol::INSPECT_BOOL)), + Symbol::NUM_U8 | Symbol::NUM_UNSIGNED8 => Some(Immediate(Symbol::INSPECT_U8)), + Symbol::NUM_U16 | Symbol::NUM_UNSIGNED16 => Some(Immediate(Symbol::INSPECT_U16)), + Symbol::NUM_U32 | Symbol::NUM_UNSIGNED32 => Some(Immediate(Symbol::INSPECT_U32)), + Symbol::NUM_U64 | Symbol::NUM_UNSIGNED64 => Some(Immediate(Symbol::INSPECT_U64)), + Symbol::NUM_U128 | Symbol::NUM_UNSIGNED128 => Some(Immediate(Symbol::INSPECT_U128)), + Symbol::NUM_I8 | Symbol::NUM_SIGNED8 => Some(Immediate(Symbol::INSPECT_I8)), + Symbol::NUM_I16 | Symbol::NUM_SIGNED16 => Some(Immediate(Symbol::INSPECT_I16)), + Symbol::NUM_I32 | Symbol::NUM_SIGNED32 => Some(Immediate(Symbol::INSPECT_I32)), + Symbol::NUM_I64 | Symbol::NUM_SIGNED64 => Some(Immediate(Symbol::INSPECT_I64)), + Symbol::NUM_I128 | Symbol::NUM_SIGNED128 => Some(Immediate(Symbol::INSPECT_I128)), + Symbol::NUM_DEC | Symbol::NUM_DECIMAL => Some(Immediate(Symbol::INSPECT_DEC)), + Symbol::NUM_F32 | Symbol::NUM_BINARY32 => Some(Immediate(Symbol::INSPECT_F32)), + Symbol::NUM_F64 | Symbol::NUM_BINARY64 => Some(Immediate(Symbol::INSPECT_F64)), + Symbol::NUM_NAT | Symbol::NUM_NATURAL => Some(Immediate(Symbol::INSPECT_NAT)), + _ => None, + } + } +} diff --git a/crates/compiler/derive_key/src/lib.rs b/crates/compiler/derive_key/src/lib.rs index 8d122c2661..53db35816e 100644 --- a/crates/compiler/derive_key/src/lib.rs +++ b/crates/compiler/derive_key/src/lib.rs @@ -16,12 +16,14 @@ pub mod decoding; pub mod encoding; pub mod hash; +pub mod inspect; mod util; use decoding::{FlatDecodable, FlatDecodableKey}; use encoding::{FlatEncodable, FlatEncodableKey}; use hash::{FlatHash, FlatHashKey}; +use inspect::{FlatInspectable, FlatInspectableKey}; use roc_module::symbol::Symbol; use roc_types::subs::{Subs, Variable}; @@ -40,6 +42,7 @@ pub enum DeriveKey { ToEncoder(FlatEncodableKey), Decoder(FlatDecodableKey), Hash(FlatHashKey), + ToInspector(FlatInspectableKey), } impl DeriveKey { @@ -48,6 +51,7 @@ impl DeriveKey { DeriveKey::ToEncoder(key) => format!("toEncoder_{}", key.debug_name()), DeriveKey::Decoder(key) => format!("decoder_{}", key.debug_name()), DeriveKey::Hash(key) => format!("hash_{}", key.debug_name()), + DeriveKey::ToInspector(key) => format!("toInspector_{}", key.debug_name()), } } } @@ -77,6 +81,7 @@ pub enum DeriveBuiltin { Decoder, Hash, IsEq, + ToInspector, } impl TryFrom for DeriveBuiltin { @@ -88,6 +93,7 @@ impl TryFrom for DeriveBuiltin { Symbol::DECODE_DECODER => Ok(DeriveBuiltin::Decoder), Symbol::HASH_HASH => Ok(DeriveBuiltin::Hash), Symbol::BOOL_IS_EQ => Ok(DeriveBuiltin::IsEq), + Symbol::INSPECT_TO_INSPECTOR => Ok(DeriveBuiltin::ToInspector), _ => Err(value), } } @@ -121,6 +127,10 @@ impl Derived { Symbol::BOOL_STRUCTURAL_EQ, )) } + DeriveBuiltin::ToInspector => match FlatInspectable::from_var(subs, var) { + FlatInspectable::Immediate(imm) => Ok(Derived::Immediate(imm)), + FlatInspectable::Key(repr) => Ok(Derived::Key(DeriveKey::ToInspector(repr))), + }, } } @@ -151,6 +161,12 @@ impl Derived { Symbol::BOOL_STRUCTURAL_EQ, )) } + DeriveBuiltin::ToInspector => { + match inspect::FlatInspectable::from_builtin_alias(symbol).unwrap() { + FlatInspectable::Immediate(imm) => Ok(Derived::Immediate(imm)), + FlatInspectable::Key(repr) => Ok(Derived::Key(DeriveKey::ToInspector(repr))), + } + } } } } diff --git a/crates/compiler/derive_key/src/util.rs b/crates/compiler/derive_key/src/util.rs index 8fbab82957..a6229c3e25 100644 --- a/crates/compiler/derive_key/src/util.rs +++ b/crates/compiler/derive_key/src/util.rs @@ -60,3 +60,7 @@ pub(crate) fn debug_name_tag(tags: &[(TagName, u16)]) -> String { str.push(']'); str } + +pub(crate) fn debug_name_fn(arity: u32) -> String { + format!("(arity:{arity} -> _)") +} diff --git a/crates/compiler/fmt/src/expr.rs b/crates/compiler/fmt/src/expr.rs index 20a9299ba1..39e6bce4ee 100644 --- a/crates/compiler/fmt/src/expr.rs +++ b/crates/compiler/fmt/src/expr.rs @@ -62,6 +62,9 @@ impl<'a> Formattable for Expr<'a> { condition.is_multiline() || continuation.is_multiline() } Dbg(condition, continuation) => condition.is_multiline() || continuation.is_multiline(), + LowLevelDbg(_, _) => unreachable!( + "LowLevelDbg should only exist after desugaring, not during formatting" + ), If(branches, final_else) => { final_else.is_multiline() @@ -435,6 +438,9 @@ impl<'a> Formattable for Expr<'a> { Dbg(condition, continuation) => { fmt_dbg(buf, condition, continuation, self.is_multiline(), indent); } + LowLevelDbg(_, _) => unreachable!( + "LowLevelDbg should only exist after desugaring, not during formatting" + ), If(branches, final_else) => { fmt_if(buf, branches, final_else, self.is_multiline(), indent); } diff --git a/crates/compiler/fmt/src/spaces.rs b/crates/compiler/fmt/src/spaces.rs index 4264b208d5..255b18ae56 100644 --- a/crates/compiler/fmt/src/spaces.rs +++ b/crates/compiler/fmt/src/spaces.rs @@ -726,6 +726,9 @@ impl<'a> RemoveSpaces<'a> for Expr<'a> { arena.alloc(a.remove_spaces(arena)), arena.alloc(b.remove_spaces(arena)), ), + Expr::LowLevelDbg(_, _) => unreachable!( + "LowLevelDbg should only exist after desugaring, not during formatting" + ), Expr::Apply(a, b, c) => Expr::Apply( arena.alloc(a.remove_spaces(arena)), b.remove_spaces(arena), diff --git a/crates/compiler/gen_dev/src/generic64/aarch64.rs b/crates/compiler/gen_dev/src/generic64/aarch64.rs index 6f0a2d580c..cdb7a35d31 100644 --- a/crates/compiler/gen_dev/src/generic64/aarch64.rs +++ b/crates/compiler/gen_dev/src/generic64/aarch64.rs @@ -365,6 +365,7 @@ impl CallConv for AArch64C /// 213568: f90033fd str x29, [sp, #96] const SHADOW_SPACE_SIZE: u8 = 16; + // These are registers that a called function must save and restore if it wants to use them. #[inline(always)] fn general_callee_saved(reg: &AArch64GeneralReg) -> bool { matches!( diff --git a/crates/compiler/gen_dev/src/generic64/mod.rs b/crates/compiler/gen_dev/src/generic64/mod.rs index 58d458aa4b..73a1146e2c 100644 --- a/crates/compiler/gen_dev/src/generic64/mod.rs +++ b/crates/compiler/gen_dev/src/generic64/mod.rs @@ -82,8 +82,8 @@ pub trait CallConv, - general_saved_regs: &[GeneralReg], - float_saved_regs: &[FloatReg], + saved_general_regs: &[GeneralReg], + saved_float_regs: &[FloatReg], requested_stack_size: i32, fn_call_stack_size: i32, ) -> i32; @@ -900,8 +900,11 @@ impl< let mut out = bumpalo::vec![in self.env.arena]; // Setup stack. - let used_general_regs = self.storage_manager.general_used_callee_saved_regs(); - let used_float_regs = self.storage_manager.float_used_callee_saved_regs(); + let (used_general_regs, used_float_regs) = self + .storage_manager + .used_callee_saved_regs + .as_vecs(self.env.arena); + let aligned_stack_size = CC::setup_stack( &mut out, &used_general_regs, @@ -1199,6 +1202,12 @@ impl< max_branch_stack_size = std::cmp::max(max_branch_stack_size, self.storage_manager.stack_size()); base_storage.update_fn_call_stack_size(self.storage_manager.fn_call_stack_size()); + + // make sure that used callee-saved registers get saved/restored even if used in only + // one of the branches of the switch + base_storage + .used_callee_saved_regs + .extend(&self.storage_manager.used_callee_saved_regs); } self.storage_manager = base_storage; self.literal_map = base_literal_map; diff --git a/crates/compiler/gen_dev/src/generic64/storage.rs b/crates/compiler/gen_dev/src/generic64/storage.rs index b9e260a80e..1c6b48e054 100644 --- a/crates/compiler/gen_dev/src/generic64/storage.rs +++ b/crates/compiler/gen_dev/src/generic64/storage.rs @@ -3,7 +3,7 @@ use crate::{ pointer_layouts, sign_extended_int_builtins, single_register_floats, single_register_int_builtins, single_register_integers, single_register_layouts, Env, }; -use bumpalo::collections::Vec; +use bumpalo::collections::{CollectIn, Vec}; use roc_builtins::bitcode::{FloatWidth, IntWidth}; use roc_collections::all::{MutMap, MutSet}; use roc_error_macros::{internal_error, todo_lambda_erasure}; @@ -118,10 +118,7 @@ pub struct StorageManager< general_used_regs: Vec<'a, (GeneralReg, Symbol)>, float_used_regs: Vec<'a, (FloatReg, Symbol)>, - // TODO: it probably would be faster to make these a list that linearly scans rather than hashing. - // used callee saved regs must be tracked for pushing and popping at the beginning/end of the function. - general_used_callee_saved_regs: MutSet, - float_used_callee_saved_regs: MutSet, + pub(crate) used_callee_saved_regs: UsedCalleeRegisters, free_stack_chunks: Vec<'a, (i32, u32)>, stack_size: u32, @@ -152,16 +149,62 @@ pub fn new_storage_manager< join_param_map: MutMap::default(), general_free_regs: bumpalo::vec![in env.arena], general_used_regs: bumpalo::vec![in env.arena], - general_used_callee_saved_regs: MutSet::default(), + // must be saved on entering a function, and restored before returning + used_callee_saved_regs: UsedCalleeRegisters::default(), float_free_regs: bumpalo::vec![in env.arena], float_used_regs: bumpalo::vec![in env.arena], - float_used_callee_saved_regs: MutSet::default(), free_stack_chunks: bumpalo::vec![in env.arena], stack_size: 0, fn_call_stack_size: 0, } } +// optimization idea: use a bitset +#[derive(Debug, Clone)] +pub(crate) struct UsedCalleeRegisters { + general: MutSet, + float: MutSet, +} + +impl UsedCalleeRegisters { + fn clear(&mut self) { + self.general.clear(); + self.float.clear(); + } + + fn insert_general(&mut self, reg: GeneralReg) -> bool { + self.general.insert(reg) + } + + fn insert_float(&mut self, reg: FloatReg) -> bool { + self.float.insert(reg) + } + + pub(crate) fn extend(&mut self, other: &Self) { + self.general.extend(other.general.iter().copied()); + self.float.extend(other.float.iter().copied()); + } + + pub(crate) fn as_vecs<'a>( + &self, + arena: &'a bumpalo::Bump, + ) -> (Vec<'a, GeneralReg>, Vec<'a, FloatReg>) { + ( + self.general.iter().copied().collect_in(arena), + self.float.iter().copied().collect_in(arena), + ) + } +} + +impl Default for UsedCalleeRegisters { + fn default() -> Self { + Self { + general: Default::default(), + float: Default::default(), + } + } +} + impl< 'a, 'r, @@ -175,16 +218,16 @@ impl< self.symbol_storage_map.clear(); self.allocation_map.clear(); self.join_param_map.clear(); - self.general_used_callee_saved_regs.clear(); + self.used_callee_saved_regs.clear(); self.general_free_regs.clear(); self.general_used_regs.clear(); self.general_free_regs .extend_from_slice(CC::GENERAL_DEFAULT_FREE_REGS); - self.float_used_callee_saved_regs.clear(); self.float_free_regs.clear(); self.float_used_regs.clear(); self.float_free_regs .extend_from_slice(CC::FLOAT_DEFAULT_FREE_REGS); + self.used_callee_saved_regs.clear(); self.free_stack_chunks.clear(); self.stack_size = 0; self.fn_call_stack_size = 0; @@ -198,18 +241,6 @@ impl< self.fn_call_stack_size } - pub fn general_used_callee_saved_regs(&self) -> Vec<'a, GeneralReg> { - let mut used_regs = bumpalo::vec![in self.env.arena]; - used_regs.extend(&self.general_used_callee_saved_regs); - used_regs - } - - pub fn float_used_callee_saved_regs(&self) -> Vec<'a, FloatReg> { - let mut used_regs = bumpalo::vec![in self.env.arena]; - used_regs.extend(&self.float_used_callee_saved_regs); - used_regs - } - /// Returns true if the symbol is storing a primitive value. pub fn is_stored_primitive(&self, sym: &Symbol) -> bool { matches!( @@ -223,7 +254,7 @@ impl< fn get_general_reg(&mut self, buf: &mut Vec<'a, u8>) -> GeneralReg { if let Some(reg) = self.general_free_regs.pop() { if CC::general_callee_saved(®) { - self.general_used_callee_saved_regs.insert(reg); + self.used_callee_saved_regs.insert_general(reg); } reg } else if !self.general_used_regs.is_empty() { @@ -240,7 +271,7 @@ impl< fn get_float_reg(&mut self, buf: &mut Vec<'a, u8>) -> FloatReg { if let Some(reg) = self.float_free_regs.pop() { if CC::float_callee_saved(®) { - self.float_used_callee_saved_regs.insert(reg); + self.used_callee_saved_regs.insert_float(reg); } reg } else if !self.float_used_regs.is_empty() { diff --git a/crates/compiler/gen_dev/src/generic64/x86_64.rs b/crates/compiler/gen_dev/src/generic64/x86_64.rs index a79817127a..e44eab3ace 100644 --- a/crates/compiler/gen_dev/src/generic64/x86_64.rs +++ b/crates/compiler/gen_dev/src/generic64/x86_64.rs @@ -199,6 +199,7 @@ impl CallConv for X86_64Syste ]; const SHADOW_SPACE_SIZE: u8 = 0; + // These are registers that a called function must save and restore if it wants to use them. #[inline(always)] fn general_callee_saved(reg: &X86_64GeneralReg) -> bool { matches!( @@ -1409,6 +1410,8 @@ impl CallConv for X86_64Windo ]; const SHADOW_SPACE_SIZE: u8 = 32; + // These are registers that a called function must save and restore if it wants to use them. + // // Refer https://learn.microsoft.com/en-us/cpp/build/x64-calling-convention?view=msvc-170#callercallee-saved-registers // > The x64 ABI considers registers RBX, RBP, RDI, RSI, RSP, R12, R13, R14, R15, and XMM6-XMM15 nonvolatile. // > They must be saved and restored by a function that uses them. diff --git a/crates/compiler/gen_dev/src/lib.rs b/crates/compiler/gen_dev/src/lib.rs index 6ef72c117f..cc1f9c9c62 100644 --- a/crates/compiler/gen_dev/src/lib.rs +++ b/crates/compiler/gen_dev/src/lib.rs @@ -57,6 +57,14 @@ impl AssemblyBackendMode { AssemblyBackendMode::Repl => true, } } + + fn generate_roc_dbg(self) -> bool { + match self { + AssemblyBackendMode::Binary => false, + AssemblyBackendMode::Test => true, + AssemblyBackendMode::Repl => true, + } + } } pub struct Env<'a> { diff --git a/crates/compiler/gen_dev/src/object_builder.rs b/crates/compiler/gen_dev/src/object_builder.rs index af6f500984..79e5e3356d 100644 --- a/crates/compiler/gen_dev/src/object_builder.rs +++ b/crates/compiler/gen_dev/src/object_builder.rs @@ -296,6 +296,23 @@ fn generate_roc_panic<'a, B: Backend<'a>>(backend: &mut B, output: &mut Object) } } +fn generate_roc_dbg<'a, B: Backend<'a>>(_backend: &mut B, output: &mut Object) { + let text_section = output.section_id(StandardSection::Text); + let proc_symbol = Symbol { + name: "roc_dbg".as_bytes().to_vec(), + value: 0, + size: 0, + kind: SymbolKind::Text, + scope: SymbolScope::Dynamic, + weak: false, + section: SymbolSection::Section(text_section), + flags: SymbolFlags::None, + }; + let _proc_id = output.add_symbol(proc_symbol); + // TODO: Actually generate an impl instead of just an empty symbol. + // At a minimum, it should just be a ret. +} + fn generate_wrapper<'a, B: Backend<'a>>( backend: &mut B, output: &mut Object, @@ -412,6 +429,10 @@ fn build_object<'a, B: Backend<'a>>( generate_longjmp(&mut backend, &mut output); } + if backend.env().mode.generate_roc_dbg() { + generate_roc_dbg(&mut backend, &mut output); + } + if backend.env().mode.generate_allocators() { generate_wrapper( &mut backend, diff --git a/crates/compiler/gen_llvm/src/llvm/build.rs b/crates/compiler/gen_llvm/src/llvm/build.rs index 903fde78f2..8500e42607 100644 --- a/crates/compiler/gen_llvm/src/llvm/build.rs +++ b/crates/compiler/gen_llvm/src/llvm/build.rs @@ -897,20 +897,7 @@ impl<'a, 'ctx, 'env> Env<'a, 'ctx, 'env> { let function = self.module.get_function("roc_panic").unwrap(); let tag_id = self.context.i32_type().const_int(tag as u32 as u64, false); - let msg = match env.target_info.ptr_width() { - PtrWidth::Bytes4 => { - // we need to pass the message by reference, but we currently hold the value. - let alloca = env - .builder - .new_build_alloca(message.get_type(), "alloca_panic_msg"); - env.builder.new_build_store(alloca, message); - alloca.into() - } - PtrWidth::Bytes8 => { - // string is already held by reference - message - } - }; + let msg = self.string_to_arg(env, message); let call = self .builder @@ -919,6 +906,45 @@ impl<'a, 'ctx, 'env> Env<'a, 'ctx, 'env> { call.set_call_convention(C_CALL_CONV); } + pub fn call_dbg( + &self, + env: &Env<'a, 'ctx, 'env>, + location: BasicValueEnum<'ctx>, + message: BasicValueEnum<'ctx>, + ) { + let function = self.module.get_function("roc_dbg").unwrap(); + + let loc = self.string_to_arg(env, location); + let msg = self.string_to_arg(env, message); + + let call = self + .builder + .new_build_call(function, &[loc.into(), msg.into()], "roc_dbg"); + + call.set_call_convention(C_CALL_CONV); + } + + fn string_to_arg( + &self, + env: &Env<'a, 'ctx, 'env>, + string: BasicValueEnum<'ctx>, + ) -> BasicValueEnum<'ctx> { + match env.target_info.ptr_width() { + PtrWidth::Bytes4 => { + // we need to pass the string by reference, but we currently hold the value. + let alloca = env + .builder + .new_build_alloca(string.get_type(), "alloca_string"); + env.builder.new_build_store(alloca, string); + alloca.into() + } + PtrWidth::Bytes8 => { + // string is already held by reference + string + } + } + } + pub fn new_debug_info(module: &Module<'ctx>) -> (DebugInfoBuilder<'ctx>, DICompileUnit<'ctx>) { module.create_debug_info_builder( true, @@ -3502,26 +3528,16 @@ pub(crate) fn build_exp_stmt<'a, 'ctx>( Dbg { symbol, - variable: specialized_var, + variable: _, remainder, } => { if env.mode.runs_expects() { - let shared_memory = crate::llvm::expect::SharedMemoryPointer::get(env); - let region = unsafe { std::mem::transmute::<_, roc_region::all::Region>(*symbol) }; - - crate::llvm::expect::clone_to_shared_memory( - env, - layout_interner, - scope, - layout_ids, - &shared_memory, - *symbol, - region, - &[*symbol], - &[*specialized_var], - ); - - crate::llvm::expect::notify_parent_dbg(env, &shared_memory); + // TODO: Change location to `filename:line_number` + // let region = unsafe { std::mem::transmute::<_, roc_region::all::Region>(*symbol) }; + let location = + build_string_literal(env, parent, symbol.module_string(&env.interns)); + let message = scope.load_symbol(symbol); + env.call_dbg(env, location, message); } build_exp_stmt( diff --git a/crates/compiler/gen_llvm/src/llvm/expect.rs b/crates/compiler/gen_llvm/src/llvm/expect.rs index 7d685ecb00..8f48ec09d9 100644 --- a/crates/compiler/gen_llvm/src/llvm/expect.rs +++ b/crates/compiler/gen_llvm/src/llvm/expect.rs @@ -150,16 +150,6 @@ pub(crate) fn notify_parent_expect(env: &Env, shared_memory: &SharedMemoryPointe ); } -pub(crate) fn notify_parent_dbg(env: &Env, shared_memory: &SharedMemoryPointer) { - let func = env.module.get_function(bitcode::NOTIFY_PARENT_DBG).unwrap(); - - env.builder.new_build_call( - func, - &[shared_memory.0.into()], - "call_expect_failed_finalize", - ); -} - // Shape of expect frame: // // === diff --git a/crates/compiler/gen_llvm/src/llvm/externs.rs b/crates/compiler/gen_llvm/src/llvm/externs.rs index 393eba6fe5..c79a1a8e23 100644 --- a/crates/compiler/gen_llvm/src/llvm/externs.rs +++ b/crates/compiler/gen_llvm/src/llvm/externs.rs @@ -160,6 +160,9 @@ pub fn add_default_roc_externs(env: &Env<'_, '_, '_>) { } } + // TODO: generate a valid impl of dbg here. + unreachable_function(env, "roc_dbg"); + match env.target_info.operating_system { roc_target::OperatingSystem::Windows => { // We don't need these functions on Windows diff --git a/crates/compiler/gen_wasm/src/lib.rs b/crates/compiler/gen_wasm/src/lib.rs index d6d9207d2d..2192e666b5 100644 --- a/crates/compiler/gen_wasm/src/lib.rs +++ b/crates/compiler/gen_wasm/src/lib.rs @@ -289,6 +289,11 @@ mod dummy_platform_functions { unimplemented!("It is not valid to call roc panic from within the compiler. Please use the \"platform\" feature if this is a platform.") } + #[no_mangle] + pub unsafe extern "C" fn roc_dbg(_loc: *mut c_void, _msg: *mut c_void) { + unimplemented!("It is not valid to call roc dbg from within the compiler. Please use the \"platform\" feature if this is a platform.") + } + #[no_mangle] pub fn roc_memset(_dst: *mut c_void, _c: i32, _n: usize) -> *mut c_void { unimplemented!("It is not valid to call roc memset from within the compiler. Please use the \"platform\" feature if this is a platform.") diff --git a/crates/compiler/gen_wasm/src/low_level.rs b/crates/compiler/gen_wasm/src/low_level.rs index 683fbd61c6..cb66ab10c2 100644 --- a/crates/compiler/gen_wasm/src/low_level.rs +++ b/crates/compiler/gen_wasm/src/low_level.rs @@ -2252,7 +2252,7 @@ impl<'a> LowLevelCall<'a> { fn num_to_str(&self, backend: &mut WasmBackend<'a, '_>) { let arg_layout = backend.storage.symbol_layouts[&self.arguments[0]]; - match backend.layout_interner.get_repr(arg_layout) { + match backend.layout_interner.runtime_representation(arg_layout) { LayoutRepr::Builtin(Builtin::Int(width)) => { self.load_args_and_call_zig(backend, &bitcode::STR_FROM_INT[width]) } diff --git a/crates/compiler/load/tests/test_reporting.rs b/crates/compiler/load/tests/test_reporting.rs index 4ff9230642..331eee480b 100644 --- a/crates/compiler/load/tests/test_reporting.rs +++ b/crates/compiler/load/tests/test_reporting.rs @@ -5982,6 +5982,60 @@ In roc, functions are always written as a lambda, like{} ) } + #[test] + fn provides_missing_to_in_app_header() { + report_header_problem_as( + indoc!( + r#" + app "broken" + provides [main] + "# + ), + indoc!( + r#" + ── WEIRD PROVIDES ──────────────────────────────────────── /code/proj/Main.roc ─ + + I am partway through parsing a header, but I got stuck here: + + 1│ app "broken" + 2│ provides [main] + ^ + + I am expecting the `to` keyword next, like: + + to pf + "# + ), + ) + } + + #[test] + fn provides_to_missing_platform_in_app_header() { + report_header_problem_as( + indoc!( + r#" + app "broken" + provides [main] to + "# + ), + indoc!( + r#" + ── WEIRD PROVIDES ──────────────────────────────────────── /code/proj/Main.roc ─ + + I am partway through parsing a header, but I got stuck here: + + 1│ app "broken" + 2│ provides [main] to + ^ + + I am expecting the platform name next, like: + + to pf + "# + ), + ) + } + #[test] fn platform_requires_rigids() { report_header_problem_as( @@ -9744,7 +9798,7 @@ In roc, functions are always written as a lambda, like{} Only builtin abilities can be derived. - Note: The builtin abilities are `Encoding`, `Decoding`, `Hash`, `Eq` + Note: The builtin abilities are `Encoding`, `Decoding`, `Hash`, `Eq`, `Inspect` "### ); diff --git a/crates/compiler/load_internal/src/file.rs b/crates/compiler/load_internal/src/file.rs index ea2af62253..d24f8b96e2 100644 --- a/crates/compiler/load_internal/src/file.rs +++ b/crates/compiler/load_internal/src/file.rs @@ -4662,7 +4662,9 @@ pub fn add_imports( let mut cached_symbol_vars = VecMap::default(); - for &symbol in &exposed_for_module.imported_values { + let imported_values = exposed_for_module.imported_values.iter().copied(); + + for symbol in imported_values { import_variable_for_symbol( subs, constraints, diff --git a/crates/compiler/module/src/symbol.rs b/crates/compiler/module/src/symbol.rs index e4266a158c..7fee728ad4 100644 --- a/crates/compiler/module/src/symbol.rs +++ b/crates/compiler/module/src/symbol.rs @@ -53,6 +53,10 @@ pub const DERIVABLE_ABILITIES: &[(Symbol, &[Symbol])] = &[ (Symbol::DECODE_DECODING, &[Symbol::DECODE_DECODER]), (Symbol::HASH_HASH_ABILITY, &[Symbol::HASH_HASH]), (Symbol::BOOL_EQ, &[Symbol::BOOL_IS_EQ]), + ( + Symbol::INSPECT_INSPECT_ABILITY, + &[Symbol::INSPECT_TO_INSPECTOR], + ), ]; /// In Debug builds only, Symbol has a name() method that lets @@ -1609,22 +1613,26 @@ define_builtins! { 13 INSPECT_BOOL: "bool" 14 INSPECT_STR: "str" 15 INSPECT_OPAQUE: "opaque" - 16 INSPECT_U8: "u8" - 17 INSPECT_I8: "i8" - 18 INSPECT_U16: "u16" - 19 INSPECT_I16: "i16" - 20 INSPECT_U32: "u32" - 21 INSPECT_I32: "i32" - 22 INSPECT_U64: "u64" - 23 INSPECT_I64: "i64" - 24 INSPECT_U128: "u128" - 25 INSPECT_I128: "i128" - 26 INSPECT_F32: "f32" - 27 INSPECT_F64: "f64" - 28 INSPECT_DEC: "dec" - 29 INSPECT_CUSTOM: "custom" - 30 INSPECT_APPLY: "apply" - 31 INSPECT_TO_INSPECTOR: "toInspector" + 16 INSPECT_FUNCTION: "function" + 17 INSPECT_U8: "u8" + 18 INSPECT_I8: "i8" + 19 INSPECT_U16: "u16" + 20 INSPECT_I16: "i16" + 21 INSPECT_U32: "u32" + 22 INSPECT_I32: "i32" + 23 INSPECT_U64: "u64" + 24 INSPECT_I64: "i64" + 25 INSPECT_U128: "u128" + 26 INSPECT_I128: "i128" + 27 INSPECT_F32: "f32" + 28 INSPECT_F64: "f64" + 29 INSPECT_DEC: "dec" + 30 INSPECT_CUSTOM: "custom" + 31 INSPECT_APPLY: "apply" + 32 INSPECT_TO_INSPECTOR: "toInspector" + 33 INSPECT_NAT: "nat" + 34 INSPECT_DBG_FORMATTER: "DbgFormatter" exposed_type=true + 35 INSPECT_TO_DBG_STR: "toDbgStr" } 15 JSON: "TotallyNotJson" => { 0 JSON_JSON: "TotallyNotJson" diff --git a/crates/compiler/mono/src/code_gen_help/mod.rs b/crates/compiler/mono/src/code_gen_help/mod.rs index 7374cbb2cd..f8f76584bc 100644 --- a/crates/compiler/mono/src/code_gen_help/mod.rs +++ b/crates/compiler/mono/src/code_gen_help/mod.rs @@ -673,7 +673,25 @@ impl<'a> CallerProc<'a> { let argument_layouts = match capture_layout { None => passed_function.argument_layouts, - Some(_) => &passed_function.argument_layouts[1..], + Some(_capture_layout) => { + let capture_layout_index = passed_function.argument_layouts.len() - 1; + + #[cfg(debug_assertions)] + { + let passed_capture_layout = + passed_function.argument_layouts[capture_layout_index]; + let repr = layout_interner.get_repr(passed_capture_layout); + + if let LayoutRepr::LambdaSet(lambda_set) = repr { + assert!(layout_interner + .equiv(_capture_layout, lambda_set.runtime_representation())); + } else { + panic!("unexpected layout for capture argument"); + } + } + + &passed_function.argument_layouts[..capture_layout_index] + } }; let capture_symbol = ARG_SYMBOLS[0]; diff --git a/crates/compiler/mono/src/ir.rs b/crates/compiler/mono/src/ir.rs index 88a01c496b..07fd3880fa 100644 --- a/crates/compiler/mono/src/ir.rs +++ b/crates/compiler/mono/src/ir.rs @@ -4602,7 +4602,7 @@ pub fn with_hole<'a>( Expect { .. } => unreachable!("I think this is unreachable"), ExpectFx { .. } => unreachable!("I think this is unreachable"), Dbg { - loc_condition, + loc_message, loc_continuation, variable: cond_variable, symbol: dbg_symbol, @@ -4622,7 +4622,7 @@ pub fn with_hole<'a>( procs, layout_cache, dbg_symbol, - *loc_condition, + *loc_message, cond_variable, rest, ) @@ -6020,7 +6020,12 @@ fn compile_struct_like<'a, L, UnusedLayout>( match take_elem_expr(index) { Some((var, loc_expr)) => { match can_reuse_symbol(env, layout_cache, procs, &loc_expr.value, var) { - Imported(symbol) | LocalFunction(symbol) | UnspecializedExpr(symbol) => { + Imported(symbol) => { + // we cannot re-use the symbol in this case; it is used as a value, but defined as a thunk + elem_symbols.push(env.unique_symbol()); + can_elems.push(Field::FunctionOrUnspecialized(symbol, variable)); + } + LocalFunction(symbol) | UnspecializedExpr(symbol) => { elem_symbols.push(symbol); can_elems.push(Field::FunctionOrUnspecialized(symbol, variable)); } @@ -6068,15 +6073,15 @@ fn compile_struct_like<'a, L, UnusedLayout>( Field::ValueSymbol => { // this symbol is already defined; nothing to do } - Field::FunctionOrUnspecialized(symbol, variable) => { + Field::FunctionOrUnspecialized(can_symbol, variable) => { stmt = specialize_symbol( env, procs, layout_cache, Some(variable), - symbol, + *symbol, env.arena.alloc(stmt), - symbol, + can_symbol, ); } Field::Field(var, loc_expr) => { @@ -7132,7 +7137,7 @@ pub fn from_can<'a>( } Dbg { - loc_condition, + loc_message, loc_continuation, variable: cond_variable, symbol: dbg_symbol, @@ -7144,7 +7149,7 @@ pub fn from_can<'a>( procs, layout_cache, dbg_symbol, - *loc_condition, + *loc_message, cond_variable, rest, ) diff --git a/crates/compiler/parse/src/ast.rs b/crates/compiler/parse/src/ast.rs index 2cafc3522a..949d88b443 100644 --- a/crates/compiler/parse/src/ast.rs +++ b/crates/compiler/parse/src/ast.rs @@ -301,6 +301,8 @@ pub enum Expr<'a> { Backpassing(&'a [Loc>], &'a Loc>, &'a Loc>), Expect(&'a Loc>, &'a Loc>), Dbg(&'a Loc>, &'a Loc>), + // This form of debug is a desugared call to roc_dbg + LowLevelDbg(&'a Loc>, &'a Loc>), // Application /// To apply by name, do Apply(Var(...), ...) @@ -1535,6 +1537,7 @@ impl<'a> Malformed for Expr<'a> { Backpassing(args, call, body) => args.iter().any(|arg| arg.is_malformed()) || call.is_malformed() || body.is_malformed(), Expect(condition, continuation) | Dbg(condition, continuation) => condition.is_malformed() || continuation.is_malformed(), + LowLevelDbg(condition, continuation) => condition.is_malformed() || continuation.is_malformed(), Apply(func, args, _) => func.is_malformed() || args.iter().any(|arg| arg.is_malformed()), BinOps(firsts, last) => firsts.iter().any(|(expr, _)| expr.is_malformed()) || last.is_malformed(), UnaryOp(expr, _) => expr.is_malformed(), diff --git a/crates/compiler/parse/src/expr.rs b/crates/compiler/parse/src/expr.rs index 17cb638eef..f51602a48d 100644 --- a/crates/compiler/parse/src/expr.rs +++ b/crates/compiler/parse/src/expr.rs @@ -1933,6 +1933,7 @@ fn expr_to_pattern_help<'a>(arena: &'a Bump, expr: &Expr<'a>) -> Result Some(DeriveEq::is_derivable(self, abilities_store, subs, var)), + Symbol::INSPECT_INSPECT_ABILITY => Some(DeriveInspect::is_derivable( + self, + abilities_store, + subs, + var, + )), + _ => None, }; @@ -373,7 +380,10 @@ impl ObligationCache { let ImplKey { opaque, ability } = impl_key; - let has_declared_impl = abilities_store.has_declared_implementation(opaque, ability); + // Every type has the Inspect ability automatically, even opaques with no `implements` declaration. + let is_inspect = ability == Symbol::INSPECT_INSPECT_ABILITY; + let has_known_impl = + is_inspect || abilities_store.has_declared_implementation(opaque, ability); // Some builtins, like Float32 and Bool, would have a cyclic dependency on Encode/Decode/etc. // if their Roc implementations explicitly defined some abilities they support. @@ -382,18 +392,17 @@ impl ObligationCache { DeriveDecoding::ABILITY => DeriveDecoding::is_derivable_builtin_opaque(opaque), DeriveEq::ABILITY => DeriveEq::is_derivable_builtin_opaque(opaque), DeriveHash::ABILITY => DeriveHash::is_derivable_builtin_opaque(opaque), + DeriveInspect::ABILITY => DeriveInspect::is_derivable_builtin_opaque(opaque), _ => false, }; - let has_declared_impl = has_declared_impl || builtin_opaque_impl_ok(); - - let obligation_result = if !has_declared_impl { + let obligation_result = if has_known_impl || builtin_opaque_impl_ok() { + Ok(()) + } else { Err(Unfulfilled::OpaqueDoesNotImplement { typ: opaque, ability, }) - } else { - Ok(()) }; self.impl_cache.insert(impl_key, obligation_result); @@ -849,6 +858,93 @@ trait DerivableVisitor { } } +struct DeriveInspect; +impl DerivableVisitor for DeriveInspect { + const ABILITY: Symbol = Symbol::INSPECT_INSPECT_ABILITY; + const ABILITY_SLICE: SubsSlice = Subs::AB_INSPECT; + + #[inline(always)] + fn is_derivable_builtin_opaque(_: Symbol) -> bool { + true + } + + #[inline(always)] + fn visit_recursion(_var: Variable) -> Result { + Ok(Descend(true)) + } + + #[inline(always)] + fn visit_apply(_: Variable, _: Symbol) -> Result { + Ok(Descend(true)) + } + + #[inline(always)] + fn visit_record( + _subs: &Subs, + _var: Variable, + _fields: RecordFields, + ) -> Result { + Ok(Descend(true)) + } + + #[inline(always)] + fn visit_tuple( + _subs: &Subs, + _var: Variable, + _elems: TupleElems, + ) -> Result { + Ok(Descend(true)) + } + + #[inline(always)] + fn visit_tag_union(_var: Variable) -> Result { + Ok(Descend(true)) + } + + #[inline(always)] + fn visit_recursive_tag_union(_var: Variable) -> Result { + Ok(Descend(true)) + } + + #[inline(always)] + fn visit_function_or_tag_union(_var: Variable) -> Result { + Ok(Descend(true)) + } + + #[inline(always)] + fn visit_empty_record(_var: Variable) -> Result<(), NotDerivable> { + Ok(()) + } + + #[inline(always)] + fn visit_empty_tag_union(_var: Variable) -> Result<(), NotDerivable> { + Ok(()) + } + + #[inline(always)] + fn visit_alias(_var: Variable, symbol: Symbol) -> Result { + if is_builtin_number_alias(symbol) { + Ok(Descend(false)) + } else { + Ok(Descend(true)) + } + } + + #[inline(always)] + fn visit_ranged_number(_var: Variable, _range: NumericRange) -> Result<(), NotDerivable> { + Ok(()) + } + + #[inline(always)] + fn visit_floating_point_content( + _var: Variable, + _subs: &mut Subs, + _content_var: Variable, + ) -> Result { + Ok(Descend(false)) + } +} + struct DeriveEncoding; impl DerivableVisitor for DeriveEncoding { const ABILITY: Symbol = Symbol::ENCODE_ENCODING; @@ -1392,7 +1488,7 @@ impl AbilityResolver for AbilitiesStore { } } -/// Whether this a module whose types' ability implementations should be checked via derive_key, +/// Whether this is a module whose types' ability implementations should be checked via derive_key, /// because they do not explicitly list ability implementations due to circular dependencies. #[inline] pub(crate) fn builtin_module_with_unlisted_ability_impl(module_id: ModuleId) -> bool { diff --git a/crates/compiler/solve/src/specialize.rs b/crates/compiler/solve/src/specialize.rs index 2ccee11d50..cfde2e45e3 100644 --- a/crates/compiler/solve/src/specialize.rs +++ b/crates/compiler/solve/src/specialize.rs @@ -628,29 +628,7 @@ fn make_specialization_decision( } else { // Solving within a module. phase.with_module_abilities_store(opaque.module_id(), |abilities_store| { - let impl_key = ImplKey { - opaque: *opaque, - ability_member, - }; - match abilities_store.get_implementation(impl_key) { - None => { - // Doesn't specialize; an error will already be reported for this. - SpecializeDecision::Drop - } - Some(MemberImpl::Error) => { - // TODO: probably not right, we may want to choose a derive decision! - SpecializeDecision::Specialize(Opaque(*opaque)) - } - Some(MemberImpl::Impl(specialization_symbol)) => { - match abilities_store.specialization_info(*specialization_symbol) { - Some(_) => SpecializeDecision::Specialize(Opaque(*opaque)), - - // If we expect a specialization impl but don't yet know it, we must hold off - // compacting the lambda set until the specialization is well-known. - None => SpecializeDecision::PendingSpecialization(impl_key), - } - } - } + make_ability_specialization_decision(*opaque, ability_member, abilities_store) }) } } @@ -698,6 +676,46 @@ fn make_specialization_decision( } } +fn make_ability_specialization_decision( + opaque: Symbol, + ability_member: Symbol, + abilities_store: &AbilitiesStore, +) -> SpecializeDecision { + use SpecializationTypeKey::*; + let impl_key = ImplKey { + opaque, + ability_member, + }; + match abilities_store.get_implementation(impl_key) { + None => { + match ability_member { + // Inspect is special - if there is no implementation for the + // opaque type, we always emit a default implementation. + Symbol::INSPECT_TO_INSPECTOR => { + SpecializeDecision::Specialize(Immediate(Symbol::INSPECT_OPAQUE)) + } + _ => { + // Doesn't specialize; an error will already be reported for this. + SpecializeDecision::Drop + } + } + } + Some(MemberImpl::Error) => { + // TODO: probably not right, we may want to choose a derive decision! + SpecializeDecision::Specialize(Opaque(opaque)) + } + Some(MemberImpl::Impl(specialization_symbol)) => { + match abilities_store.specialization_info(*specialization_symbol) { + Some(_) => SpecializeDecision::Specialize(Opaque(opaque)), + + // If we expect a specialization impl but don't yet know it, we must hold off + // compacting the lambda set until the specialization is well-known. + None => SpecializeDecision::PendingSpecialization(impl_key), + } + } + } +} + #[allow(clippy::too_many_arguments)] fn get_specialization_lambda_set_ambient_function( subs: &mut Subs, @@ -705,115 +723,155 @@ fn get_specialization_lambda_set_ambient_function( phase: &P, ability_member: Symbol, lset_region: u8, - specialization_key: SpecializationTypeKey, + mut specialization_key: SpecializationTypeKey, target_rank: Rank, ) -> Result { - match specialization_key { - SpecializationTypeKey::Opaque(opaque) => { - let opaque_home = opaque.module_id(); - let external_specialized_lset = - phase.with_module_abilities_store(opaque_home, |abilities_store| { - let impl_key = roc_can::abilities::ImplKey { + loop { + match specialization_key { + SpecializationTypeKey::Opaque(opaque) => { + let opaque_home = opaque.module_id(); + let found = phase.with_module_abilities_store(opaque_home, |abilities_store| { + find_opaque_specialization_ambient_function( + abilities_store, opaque, ability_member, - }; + lset_region, + ) + }); - let opt_specialization = - abilities_store.get_implementation(impl_key); - match opt_specialization { - None => { - if P::IS_LATE { - internal_error!( - "expected to know a specialization for {:?}#{:?}, but it wasn't found", - opaque, - ability_member - ); - } else { - // doesn't specialize, we'll have reported an error for this - Err(()) - } - } - Some(member_impl) => match member_impl { - MemberImpl::Impl(spec_symbol) => { - let specialization = - abilities_store.specialization_info(*spec_symbol).expect("expected custom implementations to always have complete specialization info by this point"); - - let specialized_lambda_set = *specialization - .specialization_lambda_sets - .get(&lset_region) - .unwrap_or_else(|| panic!("lambda set region not resolved: {:?}", (spec_symbol, specialization))); - Ok(specialized_lambda_set) - } - MemberImpl::Error => todo_abilities!(), - }, + let external_specialized_lset = match found { + FoundOpaqueSpecialization::UpdatedSpecializationKey(key) => { + specialization_key = key; + continue; } - })?; + FoundOpaqueSpecialization::AmbientFunction(lset) => lset, + FoundOpaqueSpecialization::NotFound => { + if P::IS_LATE { + internal_error!( + "expected to know a specialization for {:?}#{:?}, but it wasn't found", + opaque, + ability_member + ); + } else { + // We'll have reported an error for this. + return Err(()); + } + } + }; - let specialized_ambient = phase.copy_lambda_set_ambient_function_to_home_subs( - external_specialized_lset, - opaque_home, - subs, - ); + let specialized_ambient = phase.copy_lambda_set_ambient_function_to_home_subs( + external_specialized_lset, + opaque_home, + subs, + ); - Ok(specialized_ambient) - } + return Ok(specialized_ambient); + } - SpecializationTypeKey::Derived(derive_key) => { - let mut derived_module = derived_env.derived_module.lock().unwrap(); + SpecializationTypeKey::Derived(derive_key) => { + let mut derived_module = derived_env.derived_module.lock().unwrap(); - let (_, _, specialization_lambda_sets) = - derived_module.get_or_insert(derived_env.exposed_types, derive_key); + let (_, _, specialization_lambda_sets) = + derived_module.get_or_insert(derived_env.exposed_types, derive_key); - let specialized_lambda_set = *specialization_lambda_sets - .get(&lset_region) - .expect("lambda set region not resolved"); + let specialized_lambda_set = *specialization_lambda_sets + .get(&lset_region) + .expect("lambda set region not resolved"); - let specialized_ambient = derived_module.copy_lambda_set_ambient_function_to_subs( - specialized_lambda_set, - subs, - target_rank, - ); + let specialized_ambient = derived_module.copy_lambda_set_ambient_function_to_subs( + specialized_lambda_set, + subs, + target_rank, + ); - Ok(specialized_ambient) - } + return Ok(specialized_ambient); + } - SpecializationTypeKey::Immediate(imm) => { - // Immediates are like opaques in that we can simply look up their type definition in - // the ability store, there is nothing new to synthesize. - // - // THEORY: if something can become an immediate, it will always be available in the - // local ability store, because the transformation is local (?) - // - // TODO: I actually think we can get what we need here by examining `derived_env.exposed_types`, - // since immediates can only refer to builtins - and in userspace, all builtin types - // are available in `exposed_types`. - let immediate_lambda_set_at_region = - phase.get_and_copy_ability_member_ambient_function(imm, lset_region, subs); + SpecializationTypeKey::Immediate(imm) => { + // Immediates are like opaques in that we can simply look up their type definition in + // the ability store, there is nothing new to synthesize. + // + // THEORY: if something can become an immediate, it will always be available in the + // local ability store, because the transformation is local (?) + // + // TODO: I actually think we can get what we need here by examining `derived_env.exposed_types`, + // since immediates can only refer to builtins - and in userspace, all builtin types + // are available in `exposed_types`. + let immediate_lambda_set_at_region = + phase.get_and_copy_ability_member_ambient_function(imm, lset_region, subs); - Ok(immediate_lambda_set_at_region) - } + return Ok(immediate_lambda_set_at_region); + } - SpecializationTypeKey::SingleLambdaSetImmediate(imm) => { - let module_id = imm.module_id(); - debug_assert!(module_id.is_builtin()); + SpecializationTypeKey::SingleLambdaSetImmediate(imm) => { + let module_id = imm.module_id(); + debug_assert!(module_id.is_builtin()); - let module_types = &derived_env - .exposed_types - .get(&module_id) - .unwrap() - .exposed_types_storage_subs; + let module_types = &derived_env + .exposed_types + .get(&module_id) + .unwrap() + .exposed_types_storage_subs; - // Since this immediate has only one lambda set, the region must be pointing to 1, and - // moreover the imported function type is the ambient function of the single lset. - debug_assert_eq!(lset_region, 1); - let storage_var = module_types.stored_vars_by_symbol.get(&imm).unwrap(); - let imported = module_types - .storage_subs - .export_variable_to(subs, *storage_var); + // Since this immediate has only one lambda set, the region must be pointing to 1, and + // moreover the imported function type is the ambient function of the single lset. + debug_assert_eq!(lset_region, 1); + let storage_var = module_types.stored_vars_by_symbol.get(&imm).unwrap(); + let imported = module_types + .storage_subs + .export_variable_to(subs, *storage_var); - roc_types::subs::instantiate_rigids(subs, imported.variable); + roc_types::subs::instantiate_rigids(subs, imported.variable); - Ok(imported.variable) + return Ok(imported.variable); + } } } } + +enum FoundOpaqueSpecialization { + UpdatedSpecializationKey(SpecializationTypeKey), + AmbientFunction(Variable), + NotFound, +} + +fn find_opaque_specialization_ambient_function( + abilities_store: &AbilitiesStore, + opaque: Symbol, + ability_member: Symbol, + lset_region: u8, +) -> FoundOpaqueSpecialization { + let impl_key = roc_can::abilities::ImplKey { + opaque, + ability_member, + }; + + let opt_specialization = abilities_store.get_implementation(impl_key); + match opt_specialization { + None => match ability_member { + Symbol::INSPECT_TO_INSPECTOR => FoundOpaqueSpecialization::UpdatedSpecializationKey( + SpecializationTypeKey::Immediate(Symbol::INSPECT_OPAQUE), + ), + _ => FoundOpaqueSpecialization::NotFound, + }, + Some(member_impl) => match member_impl { + MemberImpl::Impl(spec_symbol) => { + let specialization = + abilities_store.specialization_info(*spec_symbol).expect("expected custom implementations to always have complete specialization info by this point"); + + let specialized_lambda_set = *specialization + .specialization_lambda_sets + .get(&lset_region) + .unwrap_or_else(|| { + panic!( + "lambda set region not resolved: {:?}", + (spec_symbol, specialization) + ) + }); + + FoundOpaqueSpecialization::AmbientFunction(specialized_lambda_set) + } + MemberImpl::Error => todo_abilities!(), + }, + } +} diff --git a/crates/compiler/test_derive/src/util.rs b/crates/compiler/test_derive/src/util.rs index bb5d7bb6dc..0f5cacd2e7 100644 --- a/crates/compiler/test_derive/src/util.rs +++ b/crates/compiler/test_derive/src/util.rs @@ -68,6 +68,11 @@ fn module_source_and_path(builtin: DeriveBuiltin) -> (ModuleId, &'static str, Pa module_source(ModuleId::BOOL), builtins_path.join("Bool.roc"), ), + DeriveBuiltin::ToInspector => ( + ModuleId::INSPECT, + module_source(ModuleId::INSPECT), + builtins_path.join("Inspect.roc"), + ), } } diff --git a/crates/compiler/test_gen/src/gen_abilities.rs b/crates/compiler/test_gen/src/gen_abilities.rs index 218e8f6f79..7c96408390 100644 --- a/crates/compiler/test_gen/src/gen_abilities.rs +++ b/crates/compiler/test_gen/src/gen_abilities.rs @@ -2159,19 +2159,19 @@ fn issue_4772_weakened_monomorphic_destructure() { getNumber = { result, rest } = Decode.fromBytesPartial (Str.toUtf8 "\"1234\"") TotallyNotJson.json - - when result is - Ok val -> - when Str.toI64 val is + + when result is + Ok val -> + when Str.toI64 val is Ok number -> Ok {val : number, input : rest} Err InvalidNumStr -> Err (ParsingFailure "not a number") - Err _ -> + Err _ -> Err (ParsingFailure "not a number") - main = + main = getNumber |> Result.map .val |> Result.withDefault 0 "### ), @@ -2180,3 +2180,150 @@ fn issue_4772_weakened_monomorphic_destructure() { ) }) } + +mod inspect { + #[cfg(feature = "gen-llvm")] + use crate::helpers::llvm::assert_evals_to; + + #[cfg(feature = "gen-wasm")] + use crate::helpers::wasm::assert_evals_to; + + #[cfg(all(test, any(feature = "gen-llvm", feature = "gen-wasm")))] + use indoc::indoc; + + #[cfg(all(test, any(feature = "gen-llvm", feature = "gen-wasm")))] + use roc_std::RocStr; + + #[test] + #[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))] + fn bool() { + assert_evals_to!( + indoc!( + r#" + app "test" provides [main] to "./platform" + + main = [ + Inspect.inspect Bool.true, + Inspect.inspect Bool.false, + ] |> List.map Inspect.toDbgStr |> Str.joinWith ", " + "# + ), + RocStr::from("Bool.true, Bool.false"), + RocStr + ); + } + + #[test] + #[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))] + fn num() { + assert_evals_to!( + indoc!( + r#" + app "test" provides [main] to "./platform" + + main = [ + Inspect.inspect 0, # Num a + Inspect.inspect 1u8, # U8 + Inspect.inspect 2i8, # I8 + Inspect.inspect 3u16, # U16 + Inspect.inspect 4i16, # I16 + Inspect.inspect 5u32, # U32 + Inspect.inspect 6i32, # I32 + Inspect.inspect 7u64, # U64 + Inspect.inspect 8i64, # I64 + Inspect.inspect 9u128, # U128 + Inspect.inspect 10i128, # I128 + Inspect.inspect 0.5, # Frac a + Inspect.inspect 1.5f32, # F32 + Inspect.inspect 2.2f64, # F64 + Inspect.inspect (1.1dec + 2.2), # Dec + ] |> List.map Inspect.toDbgStr |> Str.joinWith ", " + "# + ), + RocStr::from("0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0.5, 1.5, 2.2, 3.3"), + RocStr + ); + } + + #[test] + #[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))] + fn list() { + assert_evals_to!( + indoc!( + r#" + app "test" provides [main] to "./platform" + + main = [ + Inspect.inspect [0, 1, 2], # List (Num *) + Inspect.inspect [1, 0x2, 3], # List (Int *) + Inspect.inspect [0.1 + 0.2, 0.4], # List (Frac *) + Inspect.inspect [1u8, 2u8], # List U8 + Inspect.inspect ["foo"], # List Str + ] |> List.map Inspect.toDbgStr |> Str.joinWith ", " + "# + ), + RocStr::from("[0, 1, 2], [1, 2, 3], [0.3, 0.4], [1, 2], [\"foo\"]"), + RocStr + ); + } + + #[test] + #[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))] + fn str() { + assert_evals_to!( + indoc!( + r#" + app "test" provides [main] to "./platform" + + main = [ + Inspect.inspect "", + Inspect.inspect "a small string", + Inspect.inspect "an extraordinarily long string - so long it's on the heap!", + ] |> List.map Inspect.toDbgStr |> Str.joinWith ", " + "# + ), + RocStr::from( + r#""", "a small string", "an extraordinarily long string - so long it's on the heap!""# + ), + RocStr + ); + } + + #[test] + #[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))] + fn opaque_automatic() { + assert_evals_to!( + indoc!( + r#" + app "test" provides [main] to "./platform" + + Op := {} + + main = Inspect.toDbgStr (Inspect.inspect (@Op {})) + "# + ), + RocStr::from(r#""#), + RocStr + ); + } + + #[test] + #[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))] + fn opaque_automatic_with_polymorphic_call() { + assert_evals_to!( + indoc!( + r#" + app "test" provides [main] to "./platform" + + Op := {} + + late = \a -> Inspect.toDbgStr (Inspect.inspect a) + + main = late (@Op {}) + "# + ), + RocStr::from(r#""#), + RocStr + ); + } +} diff --git a/crates/compiler/test_gen/src/gen_primitives.rs b/crates/compiler/test_gen/src/gen_primitives.rs index c283d9aa5d..4509a2a60c 100644 --- a/crates/compiler/test_gen/src/gen_primitives.rs +++ b/crates/compiler/test_gen/src/gen_primitives.rs @@ -4630,3 +4630,36 @@ fn many_arguments() { i64 ); } + +#[test] +#[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))] +fn multiple_uses_of_bool_true_record() { + assert_evals_to!( + indoc!( + r#" + (Bool.true, Bool.true).0 + "# + ), + true, + bool + ); +} + +#[test] +#[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))] +fn multiple_uses_of_bool_true_tag_union() { + assert_evals_to!( + indoc!( + r#" + x : [ One Bool Bool, Empty ] + x = One Bool.true Bool.true + + when x is + One a _ -> a + Empty -> Bool.false + "# + ), + true, + bool + ); +} diff --git a/crates/compiler/test_gen/src/helpers/wasm_test_platform.c b/crates/compiler/test_gen/src/helpers/wasm_test_platform.c index 71f84352a5..e3cd649c36 100644 --- a/crates/compiler/test_gen/src/helpers/wasm_test_platform.c +++ b/crates/compiler/test_gen/src/helpers/wasm_test_platform.c @@ -132,6 +132,9 @@ void roc_panic(void* msg, unsigned int panic_tag) exit(101); } +// TODO: add a way to send dbg to rust. +void roc_debug(void* loc, void* msg) {} + //-------------------------- void *roc_memset(void *str, int c, size_t n) diff --git a/crates/compiler/test_mono/generated/dbg_in_expect.txt b/crates/compiler/test_mono/generated/dbg_in_expect.txt index a683faaa6c..064c6634f8 100644 --- a/crates/compiler/test_mono/generated/dbg_in_expect.txt +++ b/crates/compiler/test_mono/generated/dbg_in_expect.txt @@ -2,8 +2,48 @@ procedure Bool.2 (): let Bool.23 : Int1 = true; ret Bool.23; +procedure Inspect.249 (Inspect.250, Inspect.248): + let Inspect.323 : Str = "\""; + let Inspect.322 : Str = CallByName Inspect.61 Inspect.250 Inspect.323; + let Inspect.318 : Str = CallByName Inspect.61 Inspect.322 Inspect.248; + let Inspect.319 : Str = "\""; + let Inspect.317 : Str = CallByName Inspect.61 Inspect.318 Inspect.319; + ret Inspect.317; + +procedure Inspect.30 (Inspect.147): + ret Inspect.147; + +procedure Inspect.35 (Inspect.300): + ret Inspect.300; + +procedure Inspect.36 (Inspect.304): + let Inspect.311 : Str = ""; + ret Inspect.311; + +procedure Inspect.44 (Inspect.248): + let Inspect.313 : Str = CallByName Inspect.30 Inspect.248; + ret Inspect.313; + +procedure Inspect.5 (Inspect.150): + let Inspect.312 : Str = CallByName Inspect.44 Inspect.150; + let Inspect.309 : {} = Struct {}; + let Inspect.308 : Str = CallByName Inspect.36 Inspect.309; + let Inspect.307 : Str = CallByName Inspect.249 Inspect.308 Inspect.312; + ret Inspect.307; + +procedure Inspect.61 (Inspect.303, Inspect.298): + let Inspect.321 : Str = CallByName Str.3 Inspect.303 Inspect.298; + dec Inspect.298; + ret Inspect.321; + +procedure Str.3 (#Attr.2, #Attr.3): + let Str.292 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.292; + procedure Test.1 (): - let Test.0 : Str = ""; + let Test.5 : Str = ""; + let Test.4 : Str = CallByName Inspect.5 Test.5; + let Test.0 : Str = CallByName Inspect.35 Test.4; dbg Test.0; dec Test.0; let Test.3 : Int1 = CallByName Bool.2; diff --git a/crates/compiler/test_mono/generated/dbg_str_followed_by_number.txt b/crates/compiler/test_mono/generated/dbg_str_followed_by_number.txt index 3fadf1fcc4..30f3e3f208 100644 --- a/crates/compiler/test_mono/generated/dbg_str_followed_by_number.txt +++ b/crates/compiler/test_mono/generated/dbg_str_followed_by_number.txt @@ -1,5 +1,45 @@ +procedure Inspect.249 (Inspect.250, Inspect.248): + let Inspect.323 : Str = "\""; + let Inspect.322 : Str = CallByName Inspect.61 Inspect.250 Inspect.323; + let Inspect.318 : Str = CallByName Inspect.61 Inspect.322 Inspect.248; + let Inspect.319 : Str = "\""; + let Inspect.317 : Str = CallByName Inspect.61 Inspect.318 Inspect.319; + ret Inspect.317; + +procedure Inspect.30 (Inspect.147): + ret Inspect.147; + +procedure Inspect.35 (Inspect.300): + ret Inspect.300; + +procedure Inspect.36 (Inspect.304): + let Inspect.311 : Str = ""; + ret Inspect.311; + +procedure Inspect.44 (Inspect.248): + let Inspect.313 : Str = CallByName Inspect.30 Inspect.248; + ret Inspect.313; + +procedure Inspect.5 (Inspect.150): + let Inspect.312 : Str = CallByName Inspect.44 Inspect.150; + let Inspect.309 : {} = Struct {}; + let Inspect.308 : Str = CallByName Inspect.36 Inspect.309; + let Inspect.307 : Str = CallByName Inspect.249 Inspect.308 Inspect.312; + ret Inspect.307; + +procedure Inspect.61 (Inspect.303, Inspect.298): + let Inspect.321 : Str = CallByName Str.3 Inspect.303 Inspect.298; + dec Inspect.298; + ret Inspect.321; + +procedure Str.3 (#Attr.2, #Attr.3): + let Str.292 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.292; + procedure Test.0 (): - let Test.1 : Str = ""; + let Test.4 : Str = ""; + let Test.3 : Str = CallByName Inspect.5 Test.4; + let Test.1 : Str = CallByName Inspect.35 Test.3; dbg Test.1; dec Test.1; let Test.2 : I64 = 42i64; diff --git a/crates/compiler/test_mono/generated/dict.txt b/crates/compiler/test_mono/generated/dict.txt index f654e628b5..6c0f78543c 100644 --- a/crates/compiler/test_mono/generated/dict.txt +++ b/crates/compiler/test_mono/generated/dict.txt @@ -1,28 +1,28 @@ -procedure Dict.1 (Dict.554): - let Dict.563 : List {[], []} = Array []; +procedure Dict.1 (Dict.557): + let Dict.567 : List {[], []} = Array []; + let Dict.574 : U64 = 0i64; + let Dict.575 : U64 = 8i64; + let Dict.568 : List U64 = CallByName List.11 Dict.574 Dict.575; + let Dict.571 : I8 = CallByName Dict.40; + let Dict.572 : U64 = 8i64; + let Dict.569 : List I8 = CallByName List.11 Dict.571 Dict.572; let Dict.570 : U64 = 0i64; - let Dict.571 : U64 = 8i64; - let Dict.564 : List U64 = CallByName List.11 Dict.570 Dict.571; - let Dict.567 : I8 = CallByName Dict.39; - let Dict.568 : U64 = 8i64; - let Dict.565 : List I8 = CallByName List.11 Dict.567 Dict.568; - let Dict.566 : U64 = 0i64; - let Dict.562 : {List {[], []}, List U64, List I8, U64} = Struct {Dict.563, Dict.564, Dict.565, Dict.566}; - ret Dict.562; + let Dict.566 : {List {[], []}, List U64, List I8, U64} = Struct {Dict.567, Dict.568, Dict.569, Dict.570}; + ret Dict.566; -procedure Dict.39 (): - let Dict.569 : I8 = -128i64; - ret Dict.569; - -procedure Dict.4 (Dict.560): - let Dict.101 : U64 = StructAtIndex 3 Dict.560; - let #Derived_gen.8 : List {[], []} = StructAtIndex 0 Dict.560; +procedure Dict.4 (Dict.564): + let Dict.105 : U64 = StructAtIndex 3 Dict.564; + let #Derived_gen.8 : List {[], []} = StructAtIndex 0 Dict.564; dec #Derived_gen.8; - let #Derived_gen.7 : List U64 = StructAtIndex 1 Dict.560; + let #Derived_gen.7 : List U64 = StructAtIndex 1 Dict.564; dec #Derived_gen.7; - let #Derived_gen.6 : List I8 = StructAtIndex 2 Dict.560; + let #Derived_gen.6 : List I8 = StructAtIndex 2 Dict.564; dec #Derived_gen.6; - ret Dict.101; + ret Dict.105; + +procedure Dict.40 (): + let Dict.573 : I8 = -128i64; + ret Dict.573; procedure List.11 (List.133, List.134): let List.554 : List I8 = CallByName List.68 List.134; diff --git a/crates/compiler/test_mono/generated/inspect_derived_dict.txt b/crates/compiler/test_mono/generated/inspect_derived_dict.txt new file mode 100644 index 0000000000..9a1a403404 --- /dev/null +++ b/crates/compiler/test_mono/generated/inspect_derived_dict.txt @@ -0,0 +1,1202 @@ +procedure Bool.1 (): + let Bool.30 : Int1 = false; + ret Bool.30; + +procedure Bool.11 (#Attr.2, #Attr.3): + let Bool.25 : Int1 = lowlevel Eq #Attr.2 #Attr.3; + ret Bool.25; + +procedure Bool.11 (#Attr.2, #Attr.3): + let Bool.26 : Int1 = lowlevel Eq #Attr.2 #Attr.3; + ret Bool.26; + +procedure Bool.11 (#Attr.2, #Attr.3): + let Bool.28 : Int1 = lowlevel Eq #Attr.2 #Attr.3; + ret Bool.28; + +procedure Bool.2 (): + let Bool.29 : Int1 = true; + ret Bool.29; + +procedure Dict.1 (Dict.557): + let Dict.720 : List {Str, I64} = Array []; + let Dict.726 : U64 = 0i64; + let Dict.727 : U64 = 8i64; + let Dict.721 : List U64 = CallByName List.11 Dict.726 Dict.727; + let Dict.724 : I8 = CallByName Dict.40; + let Dict.725 : U64 = 8i64; + let Dict.722 : List I8 = CallByName List.11 Dict.724 Dict.725; + let Dict.723 : U64 = 0i64; + let Dict.719 : {List {Str, I64}, List U64, List I8, U64} = Struct {Dict.720, Dict.721, Dict.722, Dict.723}; + ret Dict.719; + +procedure Dict.10 (Dict.558, Dict.127, Dict.128): + let Dict.126 : List {Str, I64} = StructAtIndex 0 Dict.558; + let #Derived_gen.61 : List U64 = StructAtIndex 1 Dict.558; + dec #Derived_gen.61; + let #Derived_gen.60 : List I8 = StructAtIndex 2 Dict.558; + dec #Derived_gen.60; + let Dict.981 : {Str, Int1} = CallByName List.18 Dict.126 Dict.127 Dict.128; + ret Dict.981; + +procedure Dict.101 (Dict.102, Dict.568): + let Dict.103 : Str = StructAtIndex 0 Dict.568; + let Dict.104 : I64 = StructAtIndex 1 Dict.568; + let Dict.569 : {List {Str, I64}, List U64, List I8, U64} = CallByName Dict.8 Dict.102 Dict.103 Dict.104; + ret Dict.569; + +procedure Dict.12 (Dict.100): + let Dict.718 : {} = Struct {}; + let Dict.566 : {List {Str, I64}, List U64, List I8, U64} = CallByName Dict.1 Dict.718; + let Dict.567 : {} = Struct {}; + let Dict.565 : {List {Str, I64}, List U64, List I8, U64} = CallByName List.18 Dict.100 Dict.566 Dict.567; + ret Dict.565; + +procedure Dict.129 (Dict.130, Dict.983, Dict.128): + let Dict.131 : Str = StructAtIndex 0 Dict.983; + let Dict.132 : I64 = StructAtIndex 1 Dict.983; + let Dict.985 : {Str, Int1} = CallByName Inspect.190 Dict.130 Dict.131 Dict.132 Dict.128; + ret Dict.985; + +procedure Dict.22 (#Attr.2, #Attr.3): + let Dict.574 : U64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + dec #Attr.2; + ret Dict.574; + +procedure Dict.22 (#Attr.2, #Attr.3): + let Dict.597 : I8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + dec #Attr.2; + ret Dict.597; + +procedure Dict.22 (#Attr.2, #Attr.3): + let Dict.665 : {Str, I64} = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + inc Dict.665; + dec #Attr.2; + ret Dict.665; + +procedure Dict.22 (#Attr.2, #Attr.3): + let Dict.781 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + dec #Attr.2; + ret Dict.781; + +procedure Dict.23 (#Attr.2): + let Dict.659 : U64 = lowlevel DictPseudoSeed #Attr.2; + ret Dict.659; + +procedure Dict.31 (Dict.93): + let Dict.973 : {List {Str, I64}, List U64, List I8, U64} = CallByName Inspect.30 Dict.93; + ret Dict.973; + +procedure Dict.33 (Dict.554, Dict.237, Dict.238, Dict.239, Dict.240): + let Dict.235 : List {Str, I64} = StructAtIndex 0 Dict.554; + let Dict.234 : List U64 = StructAtIndex 1 Dict.554; + let Dict.233 : List I8 = StructAtIndex 2 Dict.554; + inc Dict.233; + let Dict.236 : U64 = StructAtIndex 3 Dict.554; + let Dict.607 : U64 = CallByName List.6 Dict.233; + let Dict.602 : U64 = CallByName Dict.45 Dict.607; + let Dict.241 : {U64, U64, U64} = CallByName Dict.42 Dict.239 Dict.602; + let Dict.580 : U64 = 0i64; + let Dict.242 : U64 = CallByName Dict.34 Dict.233 Dict.241 Dict.580; + let Dict.243 : U64 = CallByName List.6 Dict.235; + let Dict.579 : {Str, I64} = Struct {Dict.237, Dict.238}; + let Dict.244 : List {Str, I64} = CallByName List.4 Dict.235 Dict.579; + let Dict.577 : List U64 = CallByName List.3 Dict.234 Dict.242 Dict.243; + let Dict.578 : List I8 = CallByName List.3 Dict.233 Dict.242 Dict.240; + let Dict.576 : {List {Str, I64}, List U64, List I8, U64} = Struct {Dict.244, Dict.577, Dict.578, Dict.236}; + ret Dict.576; + +procedure Dict.34 (#Derived_gen.42, #Derived_gen.43, #Derived_gen.44): + joinpoint Dict.581 Dict.245 Dict.246 Dict.247: + let Dict.599 : U64 = StructAtIndex 2 Dict.246; + let Dict.598 : U64 = CallByName Dict.44 Dict.599; + let Dict.248 : U64 = CallByName Num.51 Dict.598 Dict.247; + inc Dict.245; + let Dict.249 : I8 = CallByName Dict.22 Dict.245 Dict.248; + let Dict.596 : I8 = 0i64; + let Dict.594 : Int1 = CallByName Num.22 Dict.249 Dict.596; + if Dict.594 then + dec Dict.245; + ret Dict.248; + else + let Dict.593 : U64 = 7i64; + let Dict.585 : Int1 = CallByName Bool.11 Dict.247 Dict.593; + if Dict.585 then + let Dict.587 : {U64, U64, U64} = CallByName Dict.43 Dict.246; + let Dict.588 : U64 = 0i64; + jump Dict.581 Dict.245 Dict.587 Dict.588; + else + let Dict.584 : U64 = 1i64; + let Dict.583 : U64 = CallByName Num.51 Dict.247 Dict.584; + jump Dict.581 Dict.245 Dict.246 Dict.583; + in + jump Dict.581 #Derived_gen.42 #Derived_gen.43 #Derived_gen.44; + +procedure Dict.35 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4, #Derived_gen.5, #Derived_gen.6): + joinpoint Dict.686 Dict.250 Dict.251 Dict.252 Dict.253 Dict.254 Dict.255 Dict.256: + let Dict.712 : U64 = StructAtIndex 2 Dict.255; + let Dict.711 : U64 = CallByName Dict.44 Dict.712; + let Dict.257 : U64 = CallByName Num.51 Dict.711 Dict.256; + inc Dict.250; + let Dict.258 : I8 = CallByName Dict.22 Dict.250 Dict.257; + let Dict.710 : I8 = CallByName Dict.40; + let Dict.707 : Int1 = CallByName Bool.11 Dict.258 Dict.710; + if Dict.707 then + dec Dict.250; + dec Dict.251; + dec Dict.252; + dec Dict.254; + let Dict.709 : {} = Struct {}; + let Dict.708 : [C {}, C U64] = TagId(0) Dict.709; + ret Dict.708; + else + let Dict.695 : Int1 = CallByName Bool.11 Dict.258 Dict.253; + if Dict.695 then + inc Dict.251; + let Dict.261 : U64 = CallByName Dict.22 Dict.251 Dict.257; + inc Dict.252; + let Dict.706 : {Str, I64} = CallByName Dict.22 Dict.252 Dict.261; + let Dict.262 : Str = StructAtIndex 0 Dict.706; + let Dict.704 : Int1 = CallByName Bool.11 Dict.262 Dict.254; + dec Dict.262; + if Dict.704 then + dec Dict.250; + dec Dict.251; + dec Dict.252; + dec Dict.254; + let Dict.705 : [C {}, C U64] = TagId(1) Dict.257; + ret Dict.705; + else + let Dict.703 : U64 = 7i64; + let Dict.699 : Int1 = CallByName Bool.11 Dict.256 Dict.703; + if Dict.699 then + let Dict.701 : {U64, U64, U64} = CallByName Dict.43 Dict.255; + let Dict.702 : U64 = 0i64; + jump Dict.686 Dict.250 Dict.251 Dict.252 Dict.253 Dict.254 Dict.701 Dict.702; + else + let Dict.698 : U64 = 1i64; + let Dict.697 : U64 = CallByName Num.51 Dict.256 Dict.698; + jump Dict.686 Dict.250 Dict.251 Dict.252 Dict.253 Dict.254 Dict.255 Dict.697; + else + let Dict.694 : U64 = 7i64; + let Dict.690 : Int1 = CallByName Bool.11 Dict.256 Dict.694; + if Dict.690 then + let Dict.692 : {U64, U64, U64} = CallByName Dict.43 Dict.255; + let Dict.693 : U64 = 0i64; + jump Dict.686 Dict.250 Dict.251 Dict.252 Dict.253 Dict.254 Dict.692 Dict.693; + else + let Dict.689 : U64 = 1i64; + let Dict.688 : U64 = CallByName Num.51 Dict.256 Dict.689; + jump Dict.686 Dict.250 Dict.251 Dict.252 Dict.253 Dict.254 Dict.255 Dict.688; + in + jump Dict.686 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6; + +procedure Dict.36 (Dict.551): + let Dict.266 : List {Str, I64} = StructAtIndex 0 Dict.551; + let Dict.265 : List U64 = StructAtIndex 1 Dict.551; + let Dict.264 : List I8 = StructAtIndex 2 Dict.551; + let Dict.267 : U64 = StructAtIndex 3 Dict.551; + let Dict.268 : U64 = CallByName List.6 Dict.265; + let Dict.679 : U8 = 3i64; + let Dict.678 : U64 = CallByName Num.74 Dict.268 Dict.679; + let Dict.269 : U64 = CallByName Num.75 Dict.268 Dict.678; + let Dict.612 : Int1 = CallByName Num.24 Dict.267 Dict.269; + if Dict.612 then + let Dict.614 : {List {Str, I64}, List U64, List I8, U64} = Struct {Dict.266, Dict.265, Dict.264, Dict.267}; + let Dict.613 : {List {Str, I64}, List U64, List I8, U64} = CallByName Dict.37 Dict.614; + ret Dict.613; + else + let Dict.611 : {List {Str, I64}, List U64, List I8, U64} = Struct {Dict.266, Dict.265, Dict.264, Dict.267}; + ret Dict.611; + +procedure Dict.37 (Dict.552): + let Dict.272 : List {Str, I64} = StructAtIndex 0 Dict.552; + inc Dict.272; + let Dict.271 : List U64 = StructAtIndex 1 Dict.552; + let Dict.270 : List I8 = StructAtIndex 2 Dict.552; + let Dict.273 : U64 = StructAtIndex 3 Dict.552; + let Dict.676 : U64 = 2i64; + let Dict.677 : U64 = CallByName List.6 Dict.271; + let Dict.274 : U64 = CallByName Num.21 Dict.676 Dict.677; + let Dict.675 : U64 = 0i64; + let Dict.671 : List U64 = CallByName List.11 Dict.675 Dict.274; + let Dict.673 : I8 = CallByName Dict.40; + let Dict.672 : List I8 = CallByName List.11 Dict.673 Dict.274; + let Dict.275 : {List {Str, I64}, List U64, List I8, U64} = Struct {Dict.272, Dict.671, Dict.672, Dict.273}; + let Dict.616 : U64 = 0i64; + let Dict.615 : {List {Str, I64}, List U64, List I8, U64} = CallByName Dict.38 Dict.275 Dict.270 Dict.271 Dict.272 Dict.616; + ret Dict.615; + +procedure Dict.38 (#Derived_gen.32, #Derived_gen.33, #Derived_gen.34, #Derived_gen.35, #Derived_gen.36): + joinpoint Dict.617 Dict.276 Dict.277 Dict.278 Dict.279 Dict.280: + inc Dict.277; + let Dict.618 : [C {}, C I8] = CallByName List.2 Dict.277 Dict.280; + let Dict.668 : U8 = 1i64; + let Dict.669 : U8 = GetTagId Dict.618; + let Dict.670 : Int1 = lowlevel Eq Dict.668 Dict.669; + if Dict.670 then + let Dict.281 : I8 = UnionAtIndex (Id 1) (Index 0) Dict.618; + joinpoint Dict.623 Dict.282: + let Dict.621 : U64 = 1i64; + let Dict.620 : U64 = CallByName Num.51 Dict.280 Dict.621; + jump Dict.617 Dict.282 Dict.277 Dict.278 Dict.279 Dict.620; + in + let Dict.666 : I8 = 0i64; + let Dict.624 : Int1 = CallByName Num.25 Dict.281 Dict.666; + if Dict.624 then + inc Dict.278; + let Dict.283 : U64 = CallByName Dict.22 Dict.278 Dict.280; + inc Dict.279; + let Dict.664 : {Str, I64} = CallByName Dict.22 Dict.279 Dict.283; + let Dict.284 : Str = StructAtIndex 0 Dict.664; + let Dict.622 : {List {Str, I64}, List U64, List I8, U64} = CallByName Dict.39 Dict.276 Dict.284 Dict.283; + jump Dict.623 Dict.622; + else + jump Dict.623 Dict.276; + else + dec Dict.277; + dec Dict.279; + dec Dict.278; + ret Dict.276; + in + jump Dict.617 #Derived_gen.32 #Derived_gen.33 #Derived_gen.34 #Derived_gen.35 #Derived_gen.36; + +procedure Dict.39 (Dict.553, Dict.289, Dict.290): + let Dict.287 : List {Str, I64} = StructAtIndex 0 Dict.553; + let Dict.286 : List U64 = StructAtIndex 1 Dict.553; + let Dict.285 : List I8 = StructAtIndex 2 Dict.553; + inc Dict.285; + let Dict.288 : U64 = StructAtIndex 3 Dict.553; + let Dict.639 : [C , C U64] = TagId(0) ; + let Dict.638 : {U64, U64} = CallByName Dict.48 Dict.639; + let Dict.636 : {U64, U64} = CallByName Hash.19 Dict.638 Dict.289; + let Dict.291 : U64 = CallByName Dict.51 Dict.636; + let Dict.292 : U64 = CallByName Dict.46 Dict.291; + let Dict.293 : I8 = CallByName Dict.47 Dict.291; + let Dict.630 : U64 = CallByName List.6 Dict.285; + let Dict.629 : U64 = CallByName Dict.45 Dict.630; + let Dict.294 : {U64, U64, U64} = CallByName Dict.42 Dict.292 Dict.629; + let Dict.628 : U64 = 0i64; + let Dict.295 : U64 = CallByName Dict.34 Dict.285 Dict.294 Dict.628; + let Dict.626 : List U64 = CallByName List.3 Dict.286 Dict.295 Dict.290; + let Dict.627 : List I8 = CallByName List.3 Dict.285 Dict.295 Dict.293; + let Dict.625 : {List {Str, I64}, List U64, List I8, U64} = Struct {Dict.287, Dict.626, Dict.627, Dict.288}; + ret Dict.625; + +procedure Dict.40 (): + let Dict.674 : I8 = -128i64; + ret Dict.674; + +procedure Dict.42 (Dict.297, Dict.298): + let Dict.606 : U64 = 1i64; + let Dict.299 : U64 = CallByName Num.77 Dict.298 Dict.606; + let Dict.605 : U64 = CallByName Num.137 Dict.297; + let Dict.300 : U64 = CallByName Num.69 Dict.605 Dict.299; + let Dict.604 : U64 = 1i64; + let Dict.603 : {U64, U64, U64} = Struct {Dict.299, Dict.604, Dict.300}; + ret Dict.603; + +procedure Dict.43 (Dict.562): + let Dict.303 : U64 = StructAtIndex 0 Dict.562; + let Dict.302 : U64 = StructAtIndex 1 Dict.562; + let Dict.301 : U64 = StructAtIndex 2 Dict.562; + let Dict.592 : U64 = CallByName Num.51 Dict.301 Dict.302; + let Dict.304 : U64 = CallByName Num.69 Dict.592 Dict.303; + let Dict.591 : U64 = 1i64; + let Dict.590 : U64 = CallByName Num.51 Dict.302 Dict.591; + let Dict.589 : {U64, U64, U64} = Struct {Dict.303, Dict.590, Dict.304}; + ret Dict.589; + +procedure Dict.44 (Dict.305): + let Dict.601 : U8 = 3i64; + let Dict.600 : U64 = CallByName Num.72 Dict.305 Dict.601; + ret Dict.600; + +procedure Dict.45 (Dict.306): + let Dict.609 : U8 = 3i64; + let Dict.608 : U64 = CallByName Num.74 Dict.306 Dict.609; + ret Dict.608; + +procedure Dict.46 (Dict.307): + let Dict.635 : U8 = 7i64; + let Dict.634 : U64 = CallByName Num.74 Dict.307 Dict.635; + ret Dict.634; + +procedure Dict.47 (Dict.308): + let Dict.633 : U64 = 127i64; + let Dict.632 : U64 = CallByName Num.69 Dict.308 Dict.633; + let Dict.631 : I8 = CallByName Num.117 Dict.632; + ret Dict.631; + +procedure Dict.48 (Dict.309): + joinpoint Dict.656 Dict.310: + let Dict.641 : U64 = CallByName Dict.50 Dict.310; + let Dict.640 : {U64, U64} = Struct {Dict.641, Dict.310}; + ret Dict.640; + in + let Dict.661 : U8 = 0i64; + let Dict.662 : U8 = GetTagId Dict.309; + let Dict.663 : Int1 = lowlevel Eq Dict.661 Dict.662; + if Dict.663 then + let Dict.658 : {} = Struct {}; + let Dict.657 : U64 = CallByName Dict.23 Dict.658; + jump Dict.656 Dict.657; + else + let Dict.311 : U64 = UnionAtIndex (Id 1) (Index 0) Dict.309; + jump Dict.656 Dict.311; + +procedure Dict.49 (Dict.541, Dict.542): + let Dict.314 : U64 = StructAtIndex 0 Dict.542; + let Dict.315 : U64 = StructAtIndex 1 Dict.542; + let Dict.317 : U64 = StructAtIndex 2 Dict.542; + let Dict.316 : U64 = StructAtIndex 3 Dict.542; + let Dict.312 : U64 = StructAtIndex 0 Dict.541; + let Dict.313 : U64 = StructAtIndex 1 Dict.541; + let Dict.749 : U64 = CallByName Dict.61; + let Dict.747 : U64 = CallByName Num.70 Dict.314 Dict.749; + let Dict.748 : U64 = CallByName Num.70 Dict.315 Dict.316; + let Dict.318 : {U64, U64} = CallByName Dict.65 Dict.747 Dict.748; + let Dict.744 : U64 = StructAtIndex 0 Dict.318; + let Dict.745 : U64 = CallByName Dict.60; + let Dict.743 : U64 = CallByName Num.70 Dict.744 Dict.745; + let Dict.319 : U64 = CallByName Num.70 Dict.743 Dict.317; + let Dict.740 : U64 = StructAtIndex 1 Dict.318; + let Dict.741 : U64 = CallByName Dict.61; + let Dict.320 : U64 = CallByName Num.70 Dict.740 Dict.741; + let Dict.321 : U64 = CallByName Dict.64 Dict.319 Dict.320; + let Dict.732 : U64 = CallByName Dict.64 Dict.313 Dict.321; + let Dict.731 : {U64, U64} = Struct {Dict.312, Dict.732}; + ret Dict.731; + +procedure Dict.50 (Dict.322): + let Dict.654 : U64 = CallByName Dict.60; + let Dict.644 : U64 = CallByName Num.70 Dict.322 Dict.654; + let Dict.645 : U64 = CallByName Dict.61; + let Dict.643 : U64 = CallByName Dict.64 Dict.644 Dict.645; + let Dict.642 : U64 = CallByName Num.70 Dict.643 Dict.322; + ret Dict.642; + +procedure Dict.51 (Dict.561): + let Dict.323 : U64 = StructAtIndex 1 Dict.561; + ret Dict.323; + +procedure Dict.57 (Dict.535, Dict.362): + let Dict.360 : U64 = StructAtIndex 0 Dict.535; + let Dict.361 : U64 = StructAtIndex 1 Dict.535; + let Dict.363 : U64 = CallByName List.6 Dict.362; + joinpoint Dict.938 Dict.364: + let Dict.931 : {U64, U64} = Struct {Dict.360, Dict.361}; + let Dict.933 : U64 = StructAtIndex 0 Dict.364; + let Dict.934 : U64 = StructAtIndex 1 Dict.364; + let Dict.935 : U64 = CallByName Num.133 Dict.363; + let Dict.936 : U64 = StructAtIndex 2 Dict.364; + let Dict.932 : {U64, U64, U64, U64} = Struct {Dict.933, Dict.934, Dict.935, Dict.936}; + let Dict.930 : {U64, U64} = CallByName Dict.49 Dict.931 Dict.932; + ret Dict.930; + in + let Dict.972 : U64 = 16i64; + let Dict.943 : Int1 = CallByName Num.23 Dict.363 Dict.972; + if Dict.943 then + joinpoint Dict.945 Dict.937: + jump Dict.938 Dict.937; + in + let Dict.971 : U64 = 4i64; + let Dict.953 : Int1 = CallByName Num.25 Dict.363 Dict.971; + if Dict.953 then + let Dict.970 : U8 = 3i64; + let Dict.968 : U64 = CallByName Num.74 Dict.363 Dict.970; + let Dict.969 : U8 = 2i64; + let Dict.365 : U64 = CallByName Num.72 Dict.968 Dict.969; + let Dict.967 : U64 = 0i64; + inc 3 Dict.362; + let Dict.965 : U64 = CallByName Dict.67 Dict.362 Dict.967; + let Dict.966 : U8 = 32i64; + let Dict.963 : U64 = CallByName Num.72 Dict.965 Dict.966; + let Dict.964 : U64 = CallByName Dict.67 Dict.362 Dict.365; + let Dict.366 : U64 = CallByName Num.71 Dict.963 Dict.964; + let Dict.962 : U64 = 4i64; + let Dict.961 : U64 = CallByName Num.75 Dict.363 Dict.962; + let Dict.959 : U64 = CallByName Dict.67 Dict.362 Dict.961; + let Dict.960 : U8 = 32i64; + let Dict.954 : U64 = CallByName Num.72 Dict.959 Dict.960; + let Dict.958 : U64 = 4i64; + let Dict.957 : U64 = CallByName Num.75 Dict.363 Dict.958; + let Dict.956 : U64 = CallByName Num.75 Dict.957 Dict.365; + let Dict.955 : U64 = CallByName Dict.67 Dict.362 Dict.956; + let Dict.367 : U64 = CallByName Num.71 Dict.954 Dict.955; + let Dict.944 : {U64, U64, U64} = Struct {Dict.366, Dict.367, Dict.360}; + jump Dict.945 Dict.944; + else + let Dict.952 : U64 = 0i64; + let Dict.948 : Int1 = CallByName Num.24 Dict.363 Dict.952; + if Dict.948 then + let Dict.951 : U64 = 0i64; + let Dict.949 : U64 = CallByName Dict.68 Dict.362 Dict.951 Dict.363; + let Dict.950 : U64 = 0i64; + let Dict.944 : {U64, U64, U64} = Struct {Dict.949, Dict.950, Dict.360}; + jump Dict.945 Dict.944; + else + dec Dict.362; + let Dict.946 : U64 = 0i64; + let Dict.947 : U64 = 0i64; + let Dict.944 : {U64, U64, U64} = Struct {Dict.946, Dict.947, Dict.360}; + jump Dict.945 Dict.944; + else + let Dict.942 : U64 = 48i64; + let Dict.940 : Int1 = CallByName Num.23 Dict.363 Dict.942; + if Dict.940 then + let Dict.941 : U64 = 0i64; + let Dict.937 : {U64, U64, U64} = CallByName Dict.59 Dict.360 Dict.362 Dict.941 Dict.363; + jump Dict.938 Dict.937; + else + let Dict.939 : U64 = 0i64; + let Dict.937 : {U64, U64, U64} = CallByName Dict.58 Dict.360 Dict.360 Dict.360 Dict.362 Dict.939 Dict.363; + jump Dict.938 Dict.937; + +procedure Dict.58 (#Derived_gen.51, #Derived_gen.52, #Derived_gen.53, #Derived_gen.54, #Derived_gen.55, #Derived_gen.56): + joinpoint Dict.757 Dict.368 Dict.369 Dict.370 Dict.371 Dict.372 Dict.373: + inc 6 Dict.371; + let Dict.864 : U64 = CallByName Dict.66 Dict.371 Dict.372; + let Dict.865 : U64 = CallByName Dict.61; + let Dict.859 : U64 = CallByName Num.70 Dict.864 Dict.865; + let Dict.863 : U64 = 8i64; + let Dict.862 : U64 = CallByName Num.51 Dict.372 Dict.863; + let Dict.861 : U64 = CallByName Dict.66 Dict.371 Dict.862; + let Dict.860 : U64 = CallByName Num.70 Dict.861 Dict.368; + let Dict.374 : U64 = CallByName Dict.64 Dict.859 Dict.860; + let Dict.858 : U64 = 16i64; + let Dict.857 : U64 = CallByName Num.51 Dict.372 Dict.858; + let Dict.854 : U64 = CallByName Dict.66 Dict.371 Dict.857; + let Dict.855 : U64 = CallByName Dict.62; + let Dict.849 : U64 = CallByName Num.70 Dict.854 Dict.855; + let Dict.853 : U64 = 24i64; + let Dict.852 : U64 = CallByName Num.51 Dict.372 Dict.853; + let Dict.851 : U64 = CallByName Dict.66 Dict.371 Dict.852; + let Dict.850 : U64 = CallByName Num.70 Dict.851 Dict.369; + let Dict.375 : U64 = CallByName Dict.64 Dict.849 Dict.850; + let Dict.848 : U64 = 32i64; + let Dict.847 : U64 = CallByName Num.51 Dict.372 Dict.848; + let Dict.844 : U64 = CallByName Dict.66 Dict.371 Dict.847; + let Dict.845 : U64 = CallByName Dict.63; + let Dict.839 : U64 = CallByName Num.70 Dict.844 Dict.845; + let Dict.843 : U64 = 40i64; + let Dict.842 : U64 = CallByName Num.51 Dict.372 Dict.843; + let Dict.841 : U64 = CallByName Dict.66 Dict.371 Dict.842; + let Dict.840 : U64 = CallByName Num.70 Dict.841 Dict.370; + let Dict.376 : U64 = CallByName Dict.64 Dict.839 Dict.840; + let Dict.838 : U64 = 48i64; + let Dict.377 : U64 = CallByName Num.75 Dict.373 Dict.838; + let Dict.837 : U64 = 48i64; + let Dict.378 : U64 = CallByName Num.51 Dict.372 Dict.837; + let Dict.836 : U64 = 48i64; + let Dict.834 : Int1 = CallByName Num.24 Dict.377 Dict.836; + if Dict.834 then + jump Dict.757 Dict.374 Dict.375 Dict.376 Dict.371 Dict.378 Dict.377; + else + let Dict.833 : U64 = 16i64; + let Dict.808 : Int1 = CallByName Num.24 Dict.377 Dict.833; + if Dict.808 then + let Dict.832 : U64 = CallByName Num.70 Dict.375 Dict.374; + let Dict.379 : U64 = CallByName Num.70 Dict.376 Dict.832; + let Dict.809 : {U64, U64, U64} = CallByName Dict.59 Dict.379 Dict.371 Dict.378 Dict.377; + ret Dict.809; + else + inc Dict.371; + let Dict.807 : U64 = CallByName Num.70 Dict.375 Dict.374; + let Dict.380 : U64 = CallByName Num.70 Dict.376 Dict.807; + let Dict.806 : U64 = 16i64; + let Dict.805 : U64 = CallByName Num.75 Dict.377 Dict.806; + let Dict.804 : U64 = CallByName Num.51 Dict.805 Dict.378; + let Dict.759 : U64 = CallByName Dict.66 Dict.371 Dict.804; + let Dict.803 : U64 = 8i64; + let Dict.802 : U64 = CallByName Num.75 Dict.377 Dict.803; + let Dict.761 : U64 = CallByName Num.51 Dict.802 Dict.378; + let Dict.760 : U64 = CallByName Dict.66 Dict.371 Dict.761; + let Dict.758 : {U64, U64, U64} = Struct {Dict.759, Dict.760, Dict.380}; + ret Dict.758; + in + jump Dict.757 #Derived_gen.51 #Derived_gen.52 #Derived_gen.53 #Derived_gen.54 #Derived_gen.55 #Derived_gen.56; + +procedure Dict.59 (#Derived_gen.17, #Derived_gen.18, #Derived_gen.19, #Derived_gen.20): + joinpoint Dict.810 Dict.381 Dict.382 Dict.383 Dict.384: + inc 2 Dict.382; + let Dict.830 : U64 = CallByName Dict.66 Dict.382 Dict.383; + let Dict.831 : U64 = CallByName Dict.61; + let Dict.825 : U64 = CallByName Num.70 Dict.830 Dict.831; + let Dict.829 : U64 = 8i64; + let Dict.828 : U64 = CallByName Num.51 Dict.383 Dict.829; + let Dict.827 : U64 = CallByName Dict.66 Dict.382 Dict.828; + let Dict.826 : U64 = CallByName Num.70 Dict.827 Dict.381; + let Dict.385 : U64 = CallByName Dict.64 Dict.825 Dict.826; + let Dict.824 : U64 = 16i64; + let Dict.386 : U64 = CallByName Num.75 Dict.384 Dict.824; + let Dict.823 : U64 = 16i64; + let Dict.387 : U64 = CallByName Num.51 Dict.383 Dict.823; + let Dict.822 : U64 = 16i64; + let Dict.812 : Int1 = CallByName Num.23 Dict.386 Dict.822; + if Dict.812 then + inc Dict.382; + let Dict.821 : U64 = 16i64; + let Dict.820 : U64 = CallByName Num.75 Dict.386 Dict.821; + let Dict.819 : U64 = CallByName Num.51 Dict.820 Dict.387; + let Dict.814 : U64 = CallByName Dict.66 Dict.382 Dict.819; + let Dict.818 : U64 = 8i64; + let Dict.817 : U64 = CallByName Num.75 Dict.386 Dict.818; + let Dict.816 : U64 = CallByName Num.51 Dict.817 Dict.387; + let Dict.815 : U64 = CallByName Dict.66 Dict.382 Dict.816; + let Dict.813 : {U64, U64, U64} = Struct {Dict.814, Dict.815, Dict.385}; + ret Dict.813; + else + jump Dict.810 Dict.385 Dict.382 Dict.387 Dict.386; + in + jump Dict.810 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20; + +procedure Dict.60 (): + let Dict.746 : U64 = 11562461410679940143i64; + ret Dict.746; + +procedure Dict.61 (): + let Dict.742 : U64 = 16646288086500911323i64; + ret Dict.742; + +procedure Dict.62 (): + let Dict.856 : U64 = 10285213230658275043i64; + ret Dict.856; + +procedure Dict.63 (): + let Dict.846 : U64 = 6384245875588680899i64; + ret Dict.846; + +procedure Dict.64 (Dict.388, Dict.389): + let Dict.734 : {U64, U64} = CallByName Dict.65 Dict.388 Dict.389; + let Dict.390 : U64 = StructAtIndex 0 Dict.734; + let Dict.391 : U64 = StructAtIndex 1 Dict.734; + let Dict.733 : U64 = CallByName Num.70 Dict.390 Dict.391; + ret Dict.733; + +procedure Dict.65 (Dict.392, Dict.393): + let Dict.738 : U128 = CallByName Num.135 Dict.392; + let Dict.739 : U128 = CallByName Num.135 Dict.393; + let Dict.394 : U128 = CallByName Num.21 Dict.738 Dict.739; + let Dict.395 : U64 = CallByName Num.133 Dict.394; + let Dict.737 : U8 = 64i64; + let Dict.736 : U128 = CallByName Num.74 Dict.394 Dict.737; + let Dict.396 : U64 = CallByName Num.133 Dict.736; + let Dict.735 : {U64, U64} = Struct {Dict.395, Dict.396}; + ret Dict.735; + +procedure Dict.66 (Dict.397, Dict.398): + inc 7 Dict.397; + let Dict.801 : U8 = CallByName Dict.22 Dict.397 Dict.398; + let Dict.399 : U64 = CallByName Num.133 Dict.801; + let Dict.800 : U64 = 1i64; + let Dict.799 : U64 = CallByName Num.51 Dict.398 Dict.800; + let Dict.798 : U8 = CallByName Dict.22 Dict.397 Dict.799; + let Dict.400 : U64 = CallByName Num.133 Dict.798; + let Dict.797 : U64 = 2i64; + let Dict.796 : U64 = CallByName Num.51 Dict.398 Dict.797; + let Dict.795 : U8 = CallByName Dict.22 Dict.397 Dict.796; + let Dict.401 : U64 = CallByName Num.133 Dict.795; + let Dict.794 : U64 = 3i64; + let Dict.793 : U64 = CallByName Num.51 Dict.398 Dict.794; + let Dict.792 : U8 = CallByName Dict.22 Dict.397 Dict.793; + let Dict.402 : U64 = CallByName Num.133 Dict.792; + let Dict.791 : U64 = 4i64; + let Dict.790 : U64 = CallByName Num.51 Dict.398 Dict.791; + let Dict.789 : U8 = CallByName Dict.22 Dict.397 Dict.790; + let Dict.403 : U64 = CallByName Num.133 Dict.789; + let Dict.788 : U64 = 5i64; + let Dict.787 : U64 = CallByName Num.51 Dict.398 Dict.788; + let Dict.786 : U8 = CallByName Dict.22 Dict.397 Dict.787; + let Dict.404 : U64 = CallByName Num.133 Dict.786; + let Dict.785 : U64 = 6i64; + let Dict.784 : U64 = CallByName Num.51 Dict.398 Dict.785; + let Dict.783 : U8 = CallByName Dict.22 Dict.397 Dict.784; + let Dict.405 : U64 = CallByName Num.133 Dict.783; + let Dict.782 : U64 = 7i64; + let Dict.780 : U64 = CallByName Num.51 Dict.398 Dict.782; + let Dict.779 : U8 = CallByName Dict.22 Dict.397 Dict.780; + let Dict.406 : U64 = CallByName Num.133 Dict.779; + let Dict.778 : U8 = 8i64; + let Dict.777 : U64 = CallByName Num.72 Dict.400 Dict.778; + let Dict.407 : U64 = CallByName Num.71 Dict.399 Dict.777; + let Dict.776 : U8 = 16i64; + let Dict.773 : U64 = CallByName Num.72 Dict.401 Dict.776; + let Dict.775 : U8 = 24i64; + let Dict.774 : U64 = CallByName Num.72 Dict.402 Dict.775; + let Dict.408 : U64 = CallByName Num.71 Dict.773 Dict.774; + let Dict.772 : U8 = 32i64; + let Dict.769 : U64 = CallByName Num.72 Dict.403 Dict.772; + let Dict.771 : U8 = 40i64; + let Dict.770 : U64 = CallByName Num.72 Dict.404 Dict.771; + let Dict.409 : U64 = CallByName Num.71 Dict.769 Dict.770; + let Dict.768 : U8 = 48i64; + let Dict.765 : U64 = CallByName Num.72 Dict.405 Dict.768; + let Dict.767 : U8 = 56i64; + let Dict.766 : U64 = CallByName Num.72 Dict.406 Dict.767; + let Dict.410 : U64 = CallByName Num.71 Dict.765 Dict.766; + let Dict.763 : U64 = CallByName Num.71 Dict.407 Dict.408; + let Dict.764 : U64 = CallByName Num.71 Dict.409 Dict.410; + let Dict.762 : U64 = CallByName Num.71 Dict.763 Dict.764; + ret Dict.762; + +procedure Dict.67 (Dict.411, Dict.412): + inc 3 Dict.411; + let Dict.913 : U8 = CallByName Dict.22 Dict.411 Dict.412; + let Dict.413 : U64 = CallByName Num.133 Dict.913; + let Dict.912 : U64 = 1i64; + let Dict.911 : U64 = CallByName Num.51 Dict.412 Dict.912; + let Dict.910 : U8 = CallByName Dict.22 Dict.411 Dict.911; + let Dict.414 : U64 = CallByName Num.133 Dict.910; + let Dict.909 : U64 = 2i64; + let Dict.908 : U64 = CallByName Num.51 Dict.412 Dict.909; + let Dict.907 : U8 = CallByName Dict.22 Dict.411 Dict.908; + let Dict.415 : U64 = CallByName Num.133 Dict.907; + let Dict.906 : U64 = 3i64; + let Dict.905 : U64 = CallByName Num.51 Dict.412 Dict.906; + let Dict.904 : U8 = CallByName Dict.22 Dict.411 Dict.905; + let Dict.416 : U64 = CallByName Num.133 Dict.904; + let Dict.903 : U8 = 8i64; + let Dict.902 : U64 = CallByName Num.72 Dict.414 Dict.903; + let Dict.417 : U64 = CallByName Num.71 Dict.413 Dict.902; + let Dict.901 : U8 = 16i64; + let Dict.898 : U64 = CallByName Num.72 Dict.415 Dict.901; + let Dict.900 : U8 = 24i64; + let Dict.899 : U64 = CallByName Num.72 Dict.416 Dict.900; + let Dict.418 : U64 = CallByName Num.71 Dict.898 Dict.899; + let Dict.897 : U64 = CallByName Num.71 Dict.417 Dict.418; + ret Dict.897; + +procedure Dict.68 (Dict.419, Dict.420, Dict.421): + inc 2 Dict.419; + let Dict.891 : U8 = CallByName Dict.22 Dict.419 Dict.420; + let Dict.422 : U64 = CallByName Num.133 Dict.891; + let Dict.890 : U8 = 1i64; + let Dict.889 : U64 = CallByName Num.74 Dict.421 Dict.890; + let Dict.888 : U64 = CallByName Num.51 Dict.889 Dict.420; + let Dict.887 : U8 = CallByName Dict.22 Dict.419 Dict.888; + let Dict.423 : U64 = CallByName Num.133 Dict.887; + let Dict.886 : U64 = 1i64; + let Dict.885 : U64 = CallByName Num.75 Dict.421 Dict.886; + let Dict.884 : U64 = CallByName Num.51 Dict.885 Dict.420; + let Dict.883 : U8 = CallByName Dict.22 Dict.419 Dict.884; + let Dict.424 : U64 = CallByName Num.133 Dict.883; + let Dict.882 : U8 = 16i64; + let Dict.879 : U64 = CallByName Num.72 Dict.422 Dict.882; + let Dict.881 : U8 = 8i64; + let Dict.880 : U64 = CallByName Num.72 Dict.423 Dict.881; + let Dict.425 : U64 = CallByName Num.71 Dict.879 Dict.880; + let Dict.878 : U64 = CallByName Num.71 Dict.425 Dict.424; + ret Dict.878; + +procedure Dict.8 (Dict.550, Dict.168, Dict.169): + let Dict.166 : List {Str, I64} = StructAtIndex 0 Dict.550; + inc Dict.166; + let Dict.165 : List U64 = StructAtIndex 1 Dict.550; + inc Dict.165; + let Dict.164 : List I8 = StructAtIndex 2 Dict.550; + inc Dict.164; + let Dict.167 : U64 = StructAtIndex 3 Dict.550; + let Dict.717 : [C , C U64] = TagId(0) ; + let Dict.716 : {U64, U64} = CallByName Dict.48 Dict.717; + inc 2 Dict.168; + let Dict.715 : {U64, U64} = CallByName Hash.19 Dict.716 Dict.168; + let Dict.170 : U64 = CallByName Dict.51 Dict.715; + let Dict.171 : U64 = CallByName Dict.46 Dict.170; + let Dict.172 : I8 = CallByName Dict.47 Dict.170; + let Dict.714 : U64 = CallByName List.6 Dict.164; + let Dict.713 : U64 = CallByName Dict.45 Dict.714; + let Dict.173 : {U64, U64, U64} = CallByName Dict.42 Dict.171 Dict.713; + let Dict.685 : U64 = 0i64; + let Dict.570 : [C {}, C U64] = CallByName Dict.35 Dict.164 Dict.165 Dict.166 Dict.172 Dict.168 Dict.173 Dict.685; + let Dict.682 : U8 = 1i64; + let Dict.683 : U8 = GetTagId Dict.570; + let Dict.684 : Int1 = lowlevel Eq Dict.682 Dict.683; + if Dict.684 then + inc Dict.165; + let Dict.175 : U64 = UnionAtIndex (Id 1) (Index 0) Dict.570; + let Dict.176 : U64 = CallByName Dict.22 Dict.165 Dict.175; + let Dict.573 : {Str, I64} = Struct {Dict.168, Dict.169}; + let Dict.572 : List {Str, I64} = CallByName List.3 Dict.166 Dict.176 Dict.573; + let Dict.571 : {List {Str, I64}, List U64, List I8, U64} = Struct {Dict.572, Dict.165, Dict.164, Dict.167}; + ret Dict.571; + else + let Dict.681 : U64 = 1i64; + let Dict.680 : U64 = CallByName Num.51 Dict.167 Dict.681; + let Dict.610 : {List {Str, I64}, List U64, List I8, U64} = Struct {Dict.166, Dict.165, Dict.164, Dict.680}; + let Dict.177 : {List {Str, I64}, List U64, List I8, U64} = CallByName Dict.36 Dict.610; + let Dict.575 : {List {Str, I64}, List U64, List I8, U64} = CallByName Dict.33 Dict.177 Dict.168 Dict.169 Dict.171 Dict.172; + ret Dict.575; + +procedure Dict.94 (Dict.95, Dict.93): + let Dict.978 : {} = Struct {}; + let Dict.979 : {} = Struct {}; + let Dict.980 : {} = Struct {}; + let Dict.977 : {{List {Str, I64}, List U64, List I8, U64}, {}, {}, {}} = CallByName Inspect.39 Dict.93 Dict.978 Dict.979 Dict.980; + let Dict.976 : Str = CallByName Inspect.31 Dict.977 Dict.95; + ret Dict.976; + +procedure Hash.19 (Hash.39, Hash.40): + let Hash.79 : List U8 = CallByName Str.12 Hash.40; + let Hash.78 : {U64, U64} = CallByName Dict.57 Hash.39 Hash.79; + ret Hash.78; + +procedure Inspect.186 (Inspect.187, #Attr.12): + let Inspect.185 : {} = StructAtIndex 3 #Attr.12; + let Inspect.184 : {} = StructAtIndex 2 #Attr.12; + let Inspect.183 : {} = StructAtIndex 1 #Attr.12; + let Inspect.182 : {List {Str, I64}, List U64, List I8, U64} = StructAtIndex 0 #Attr.12; + let Inspect.355 : Str = "{"; + let Inspect.328 : Str = CallByName Inspect.61 Inspect.187 Inspect.355; + let Inspect.329 : {{List {Str, I64}, List U64, List I8, U64}, {}, {}, {}} = Struct {Inspect.182, Inspect.183, Inspect.184, Inspect.185}; + let Inspect.324 : {Str, Int1} = CallByName Inspect.188 Inspect.328 Inspect.329; + let Inspect.325 : {} = Struct {}; + let Inspect.320 : Str = CallByName Inspect.200 Inspect.324; + let Inspect.321 : Str = "}"; + let Inspect.319 : Str = CallByName Inspect.61 Inspect.320 Inspect.321; + ret Inspect.319; + +procedure Inspect.188 (Inspect.189, #Attr.12): + let Inspect.185 : {} = StructAtIndex 3 #Attr.12; + let Inspect.184 : {} = StructAtIndex 2 #Attr.12; + let Inspect.183 : {} = StructAtIndex 1 #Attr.12; + let Inspect.182 : {List {Str, I64}, List U64, List I8, U64} = StructAtIndex 0 #Attr.12; + let Inspect.354 : Int1 = CallByName Bool.1; + let Inspect.332 : {Str, Int1} = Struct {Inspect.189, Inspect.354}; + let Inspect.333 : {{}, {}} = Struct {Inspect.184, Inspect.185}; + let Inspect.331 : {Str, Int1} = CallByName Dict.10 Inspect.182 Inspect.332 Inspect.333; + ret Inspect.331; + +procedure Inspect.190 (Inspect.334, Inspect.193, Inspect.194, #Attr.12): + let Inspect.185 : {} = StructAtIndex 1 #Attr.12; + let Inspect.184 : {} = StructAtIndex 0 #Attr.12; + let Inspect.191 : Str = StructAtIndex 0 Inspect.334; + let Inspect.192 : Int1 = StructAtIndex 1 Inspect.334; + joinpoint Inspect.352 Inspect.195: + let Inspect.349 : Str = CallByName Inspect.44 Inspect.193; + let Inspect.347 : Str = CallByName Inspect.31 Inspect.349 Inspect.195; + let Inspect.348 : Str = ": "; + let Inspect.341 : Str = CallByName Inspect.61 Inspect.347 Inspect.348; + let Inspect.342 : {I64, {}} = Struct {Inspect.194, Inspect.185}; + let Inspect.337 : Str = CallByName Inspect.196 Inspect.341 Inspect.342; + let Inspect.338 : {} = Struct {}; + let Inspect.336 : {Str, Int1} = CallByName Inspect.198 Inspect.337; + ret Inspect.336; + in + if Inspect.192 then + let Inspect.353 : Str = ", "; + let Inspect.351 : Str = CallByName Inspect.61 Inspect.191 Inspect.353; + jump Inspect.352 Inspect.351; + else + jump Inspect.352 Inspect.191; + +procedure Inspect.196 (Inspect.197, #Attr.12): + let Inspect.185 : {} = StructAtIndex 1 #Attr.12; + let Inspect.194 : I64 = StructAtIndex 0 #Attr.12; + let Inspect.345 : I64 = CallByName Inspect.54 Inspect.194; + let Inspect.344 : Str = CallByName Inspect.31 Inspect.345 Inspect.197; + ret Inspect.344; + +procedure Inspect.198 (Inspect.199): + let Inspect.340 : Int1 = CallByName Bool.2; + let Inspect.339 : {Str, Int1} = Struct {Inspect.199, Inspect.340}; + ret Inspect.339; + +procedure Inspect.200 (Inspect.326): + let Inspect.327 : Str = StructAtIndex 0 Inspect.326; + ret Inspect.327; + +procedure Inspect.249 (Inspect.250, Inspect.248): + let Inspect.370 : Str = "\""; + let Inspect.369 : Str = CallByName Inspect.61 Inspect.250 Inspect.370; + let Inspect.367 : Str = CallByName Inspect.61 Inspect.369 Inspect.248; + let Inspect.368 : Str = "\""; + let Inspect.366 : Str = CallByName Inspect.61 Inspect.367 Inspect.368; + ret Inspect.366; + +procedure Inspect.277 (Inspect.278, Inspect.276): + let Inspect.361 : Str = CallByName Num.96 Inspect.276; + let Inspect.360 : Str = CallByName Inspect.61 Inspect.278 Inspect.361; + ret Inspect.360; + +procedure Inspect.30 (Inspect.147): + ret Inspect.147; + +procedure Inspect.30 (Inspect.147): + ret Inspect.147; + +procedure Inspect.30 (Inspect.147): + ret Inspect.147; + +procedure Inspect.30 (Inspect.147): + ret Inspect.147; + +procedure Inspect.31 (Inspect.305, Inspect.149): + let Inspect.314 : Str = CallByName Inspect.186 Inspect.149 Inspect.305; + ret Inspect.314; + +procedure Inspect.31 (Inspect.305, Inspect.149): + let Inspect.346 : Str = CallByName Inspect.277 Inspect.149 Inspect.305; + ret Inspect.346; + +procedure Inspect.31 (Inspect.305, Inspect.149): + let Inspect.350 : Str = CallByName Inspect.249 Inspect.149 Inspect.305; + ret Inspect.350; + +procedure Inspect.35 (Inspect.300): + ret Inspect.300; + +procedure Inspect.36 (Inspect.304): + let Inspect.311 : Str = ""; + ret Inspect.311; + +procedure Inspect.39 (Inspect.182, Inspect.183, Inspect.184, Inspect.185): + let Inspect.316 : {{List {Str, I64}, List U64, List I8, U64}, {}, {}, {}} = Struct {Inspect.182, Inspect.183, Inspect.184, Inspect.185}; + let Inspect.315 : {{List {Str, I64}, List U64, List I8, U64}, {}, {}, {}} = CallByName Inspect.30 Inspect.316; + ret Inspect.315; + +procedure Inspect.44 (Inspect.248): + let Inspect.362 : Str = CallByName Inspect.30 Inspect.248; + ret Inspect.362; + +procedure Inspect.5 (Inspect.150): + let Inspect.312 : {List {Str, I64}, List U64, List I8, U64} = CallByName Dict.31 Inspect.150; + let Inspect.309 : {} = Struct {}; + let Inspect.308 : Str = CallByName Inspect.36 Inspect.309; + let Inspect.307 : Str = CallByName Dict.94 Inspect.308 Inspect.312; + ret Inspect.307; + +procedure Inspect.54 (Inspect.276): + let Inspect.356 : I64 = CallByName Inspect.30 Inspect.276; + ret Inspect.356; + +procedure Inspect.61 (Inspect.303, Inspect.298): + let Inspect.323 : Str = CallByName Str.3 Inspect.303 Inspect.298; + dec Inspect.298; + ret Inspect.323; + +procedure List.11 (List.133, List.134): + let List.635 : List I8 = CallByName List.68 List.134; + let List.634 : List I8 = CallByName List.86 List.133 List.134 List.635; + ret List.634; + +procedure List.11 (List.133, List.134): + let List.637 : List U64 = CallByName List.68 List.134; + let List.636 : List U64 = CallByName List.86 List.133 List.134 List.637; + ret List.636; + +procedure List.18 (List.154, List.155, List.156): + let List.554 : U64 = 0i64; + let List.555 : U64 = CallByName List.6 List.154; + let List.553 : {List {Str, I64}, List U64, List I8, U64} = CallByName List.88 List.154 List.155 List.156 List.554 List.555; + ret List.553; + +procedure List.18 (List.154, List.155, List.156): + let List.641 : U64 = 0i64; + let List.642 : U64 = CallByName List.6 List.154; + let List.640 : {Str, Int1} = CallByName List.88 List.154 List.155 List.156 List.641 List.642; + ret List.640; + +procedure List.2 (List.103, List.104): + let List.609 : U64 = CallByName List.6 List.103; + let List.605 : Int1 = CallByName Num.22 List.104 List.609; + if List.605 then + let List.607 : I8 = CallByName List.66 List.103 List.104; + dec List.103; + let List.606 : [C {}, C I8] = TagId(1) List.607; + ret List.606; + else + dec List.103; + let List.604 : {} = Struct {}; + let List.603 : [C {}, C I8] = TagId(0) List.604; + ret List.603; + +procedure List.3 (List.111, List.112, List.113): + let List.566 : {List {Str, I64}, {Str, I64}} = CallByName List.64 List.111 List.112 List.113; + let List.565 : List {Str, I64} = StructAtIndex 0 List.566; + let #Derived_gen.62 : {Str, I64} = StructAtIndex 1 List.566; + dec #Derived_gen.62; + ret List.565; + +procedure List.3 (List.111, List.112, List.113): + let List.589 : {List I8, I8} = CallByName List.64 List.111 List.112 List.113; + let List.588 : List I8 = StructAtIndex 0 List.589; + ret List.588; + +procedure List.3 (List.111, List.112, List.113): + let List.591 : {List U64, U64} = CallByName List.64 List.111 List.112 List.113; + let List.590 : List U64 = StructAtIndex 0 List.591; + ret List.590; + +procedure List.4 (List.119, List.120): + let List.595 : U64 = 1i64; + let List.593 : List {Str, I64} = CallByName List.70 List.119 List.595; + let List.592 : List {Str, I64} = CallByName List.71 List.593 List.120; + ret List.592; + +procedure List.6 (#Attr.2): + let List.601 : U64 = lowlevel ListLen #Attr.2; + ret List.601; + +procedure List.6 (#Attr.2): + let List.602 : U64 = lowlevel ListLen #Attr.2; + ret List.602; + +procedure List.6 (#Attr.2): + let List.639 : U64 = lowlevel ListLen #Attr.2; + ret List.639; + +procedure List.6 (#Attr.2): + let List.651 : U64 = lowlevel ListLen #Attr.2; + ret List.651; + +procedure List.64 (List.108, List.109, List.110): + let List.571 : U64 = CallByName List.6 List.108; + let List.568 : Int1 = CallByName Num.22 List.109 List.571; + if List.568 then + let List.569 : {List {Str, I64}, {Str, I64}} = CallByName List.67 List.108 List.109 List.110; + ret List.569; + else + let List.567 : {List {Str, I64}, {Str, I64}} = Struct {List.108, List.110}; + ret List.567; + +procedure List.64 (List.108, List.109, List.110): + let List.578 : U64 = CallByName List.6 List.108; + let List.575 : Int1 = CallByName Num.22 List.109 List.578; + if List.575 then + let List.576 : {List I8, I8} = CallByName List.67 List.108 List.109 List.110; + ret List.576; + else + let List.574 : {List I8, I8} = Struct {List.108, List.110}; + ret List.574; + +procedure List.64 (List.108, List.109, List.110): + let List.586 : U64 = CallByName List.6 List.108; + let List.583 : Int1 = CallByName Num.22 List.109 List.586; + if List.583 then + let List.584 : {List U64, U64} = CallByName List.67 List.108 List.109 List.110; + ret List.584; + else + let List.582 : {List U64, U64} = Struct {List.108, List.110}; + ret List.582; + +procedure List.66 (#Attr.2, #Attr.3): + let List.608 : I8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + ret List.608; + +procedure List.66 (#Attr.2, #Attr.3): + let List.650 : {Str, I64} = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + ret List.650; + +procedure List.67 (#Attr.2, #Attr.3, #Attr.4): + let List.570 : {List {Str, I64}, {Str, I64}} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4; + ret List.570; + +procedure List.67 (#Attr.2, #Attr.3, #Attr.4): + let List.577 : {List I8, I8} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4; + ret List.577; + +procedure List.67 (#Attr.2, #Attr.3, #Attr.4): + let List.585 : {List U64, U64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4; + ret List.585; + +procedure List.68 (#Attr.2): + let List.621 : List I8 = lowlevel ListWithCapacity #Attr.2; + ret List.621; + +procedure List.68 (#Attr.2): + let List.633 : List U64 = lowlevel ListWithCapacity #Attr.2; + ret List.633; + +procedure List.70 (#Attr.2, #Attr.3): + let List.596 : List {Str, I64} = lowlevel ListReserve #Attr.2 #Attr.3; + ret List.596; + +procedure List.71 (#Attr.2, #Attr.3): + let List.594 : List {Str, I64} = lowlevel ListAppendUnsafe #Attr.2 #Attr.3; + ret List.594; + +procedure List.71 (#Attr.2, #Attr.3): + let List.618 : List I8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3; + ret List.618; + +procedure List.71 (#Attr.2, #Attr.3): + let List.630 : List U64 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3; + ret List.630; + +procedure List.86 (#Derived_gen.57, #Derived_gen.58, #Derived_gen.59): + joinpoint List.624 List.135 List.136 List.137: + let List.632 : U64 = 0i64; + let List.626 : Int1 = CallByName Num.24 List.136 List.632; + if List.626 then + let List.631 : U64 = 1i64; + let List.628 : U64 = CallByName Num.75 List.136 List.631; + let List.629 : List U64 = CallByName List.71 List.137 List.135; + jump List.624 List.135 List.628 List.629; + else + ret List.137; + in + jump List.624 #Derived_gen.57 #Derived_gen.58 #Derived_gen.59; + +procedure List.86 (#Derived_gen.7, #Derived_gen.8, #Derived_gen.9): + joinpoint List.612 List.135 List.136 List.137: + let List.620 : U64 = 0i64; + let List.614 : Int1 = CallByName Num.24 List.136 List.620; + if List.614 then + let List.619 : U64 = 1i64; + let List.616 : U64 = CallByName Num.75 List.136 List.619; + let List.617 : List I8 = CallByName List.71 List.137 List.135; + jump List.612 List.135 List.616 List.617; + else + ret List.137; + in + jump List.612 #Derived_gen.7 #Derived_gen.8 #Derived_gen.9; + +procedure List.88 (#Derived_gen.21, #Derived_gen.22, #Derived_gen.23, #Derived_gen.24, #Derived_gen.25): + joinpoint List.643 List.157 List.158 List.159 List.160 List.161: + let List.645 : Int1 = CallByName Num.22 List.160 List.161; + if List.645 then + let List.649 : {Str, I64} = CallByName List.66 List.157 List.160; + inc List.649; + let List.162 : {Str, Int1} = CallByName Dict.129 List.158 List.649 List.159; + let List.648 : U64 = 1i64; + let List.647 : U64 = CallByName Num.51 List.160 List.648; + jump List.643 List.157 List.162 List.159 List.647 List.161; + else + dec List.157; + ret List.158; + in + jump List.643 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25; + +procedure List.88 (#Derived_gen.37, #Derived_gen.38, #Derived_gen.39, #Derived_gen.40, #Derived_gen.41): + joinpoint List.556 List.157 List.158 List.159 List.160 List.161: + let List.558 : Int1 = CallByName Num.22 List.160 List.161; + if List.558 then + let List.562 : {Str, I64} = CallByName List.66 List.157 List.160; + inc List.562; + let List.162 : {List {Str, I64}, List U64, List I8, U64} = CallByName Dict.101 List.158 List.562; + let List.561 : U64 = 1i64; + let List.560 : U64 = CallByName Num.51 List.160 List.561; + jump List.556 List.157 List.162 List.159 List.560 List.161; + else + dec List.157; + ret List.158; + in + jump List.556 #Derived_gen.37 #Derived_gen.38 #Derived_gen.39 #Derived_gen.40 #Derived_gen.41; + +procedure Num.117 (#Attr.2): + let Num.311 : I8 = lowlevel NumIntCast #Attr.2; + ret Num.311; + +procedure Num.133 (#Attr.2): + let Num.353 : U64 = lowlevel NumIntCast #Attr.2; + ret Num.353; + +procedure Num.133 (#Attr.2): + let Num.369 : U64 = lowlevel NumIntCast #Attr.2; + ret Num.369; + +procedure Num.133 (#Attr.2): + let Num.370 : U64 = lowlevel NumIntCast #Attr.2; + ret Num.370; + +procedure Num.135 (#Attr.2): + let Num.377 : U128 = lowlevel NumIntCast #Attr.2; + ret Num.377; + +procedure Num.137 (#Attr.2): + let Num.305 : U64 = lowlevel NumIntCast #Attr.2; + ret Num.305; + +procedure Num.21 (#Attr.2, #Attr.3): + let Num.318 : U64 = lowlevel NumMul #Attr.2 #Attr.3; + ret Num.318; + +procedure Num.21 (#Attr.2, #Attr.3): + let Num.375 : U128 = lowlevel NumMul #Attr.2 #Attr.3; + ret Num.375; + +procedure Num.22 (#Attr.2, #Attr.3): + let Num.303 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; + ret Num.303; + +procedure Num.22 (#Attr.2, #Attr.3): + let Num.462 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; + ret Num.462; + +procedure Num.23 (#Attr.2, #Attr.3): + let Num.453 : Int1 = lowlevel NumLte #Attr.2 #Attr.3; + ret Num.453; + +procedure Num.24 (#Attr.2, #Attr.3): + let Num.457 : Int1 = lowlevel NumGt #Attr.2 #Attr.3; + ret Num.457; + +procedure Num.25 (#Attr.2, #Attr.3): + let Num.321 : Int1 = lowlevel NumGte #Attr.2 #Attr.3; + ret Num.321; + +procedure Num.25 (#Attr.2, #Attr.3): + let Num.459 : Int1 = lowlevel NumGte #Attr.2 #Attr.3; + ret Num.459; + +procedure Num.51 (#Attr.2, #Attr.3): + let Num.461 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3; + ret Num.461; + +procedure Num.69 (#Attr.2, #Attr.3): + let Num.302 : U64 = lowlevel NumBitwiseAnd #Attr.2 #Attr.3; + ret Num.302; + +procedure Num.70 (#Attr.2, #Attr.3): + let Num.351 : U64 = lowlevel NumBitwiseXor #Attr.2 #Attr.3; + ret Num.351; + +procedure Num.71 (#Attr.2, #Attr.3): + let Num.393 : U64 = lowlevel NumBitwiseOr #Attr.2 #Attr.3; + ret Num.393; + +procedure Num.72 (#Attr.2, #Attr.3): + let Num.411 : U64 = lowlevel NumShiftLeftBy #Attr.2 #Attr.3; + ret Num.411; + +procedure Num.74 (#Attr.2, #Attr.3): + let Num.371 : U128 = lowlevel NumShiftRightZfBy #Attr.2 #Attr.3; + ret Num.371; + +procedure Num.74 (#Attr.2, #Attr.3): + let Num.374 : U64 = lowlevel NumShiftRightZfBy #Attr.2 #Attr.3; + ret Num.374; + +procedure Num.75 (#Attr.2, #Attr.3): + let Num.448 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3; + ret Num.448; + +procedure Num.77 (#Attr.2, #Attr.3): + let Num.306 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3; + ret Num.306; + +procedure Num.96 (#Attr.2): + let Num.460 : Str = lowlevel NumToStr #Attr.2; + ret Num.460; + +procedure Str.12 (#Attr.2): + let Str.293 : List U8 = lowlevel StrToUtf8 #Attr.2; + ret Str.293; + +procedure Str.3 (#Attr.2, #Attr.3): + let Str.294 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.294; + +procedure Test.0 (): + let Test.9 : Str = "a"; + let Test.10 : I64 = 1i64; + let Test.5 : {Str, I64} = Struct {Test.9, Test.10}; + let Test.7 : Str = "b"; + let Test.8 : I64 = 2i64; + let Test.6 : {Str, I64} = Struct {Test.7, Test.8}; + let Test.4 : List {Str, I64} = Array [Test.5, Test.6]; + let Test.3 : {List {Str, I64}, List U64, List I8, U64} = CallByName Dict.12 Test.4; + let Test.2 : Str = CallByName Inspect.5 Test.3; + let Test.1 : Str = CallByName Inspect.35 Test.2; + ret Test.1; diff --git a/crates/compiler/test_mono/generated/inspect_derived_list.txt b/crates/compiler/test_mono/generated/inspect_derived_list.txt new file mode 100644 index 0000000000..f26482263b --- /dev/null +++ b/crates/compiler/test_mono/generated/inspect_derived_list.txt @@ -0,0 +1,172 @@ +procedure #Derived.0 (#Derived.1): + let #Derived_gen.0 : List I64 = CallByName Inspect.30 #Derived.1; + ret #Derived_gen.0; + +procedure #Derived.3 (#Derived.2): + let #Derived_gen.7 : I64 = CallByName Inspect.54 #Derived.2; + ret #Derived_gen.7; + +procedure #Derived.4 (#Derived.5, #Derived.1): + let #Derived_gen.5 : {} = Struct {}; + let #Derived_gen.6 : {} = Struct {}; + let #Derived_gen.4 : {List I64, {}, {}} = CallByName Inspect.37 #Derived.1 #Derived_gen.5 #Derived_gen.6; + let #Derived_gen.3 : Str = CallByName Inspect.31 #Derived_gen.4 #Derived.5; + ret #Derived_gen.3; + +procedure Bool.1 (): + let Bool.24 : Int1 = false; + ret Bool.24; + +procedure Bool.2 (): + let Bool.23 : Int1 = true; + ret Bool.23; + +procedure Inspect.155 (Inspect.156, #Attr.12): + let Inspect.154 : {} = StructAtIndex 2 #Attr.12; + let Inspect.153 : {} = StructAtIndex 1 #Attr.12; + let Inspect.152 : List I64 = StructAtIndex 0 #Attr.12; + let Inspect.347 : Str = "["; + let Inspect.328 : Str = CallByName Inspect.61 Inspect.156 Inspect.347; + let Inspect.329 : {List I64, {}, {}} = Struct {Inspect.152, Inspect.153, Inspect.154}; + let Inspect.324 : {Str, Int1} = CallByName Inspect.157 Inspect.328 Inspect.329; + let Inspect.325 : {} = Struct {}; + let Inspect.320 : Str = CallByName Inspect.166 Inspect.324; + let Inspect.321 : Str = "]"; + let Inspect.319 : Str = CallByName Inspect.61 Inspect.320 Inspect.321; + ret Inspect.319; + +procedure Inspect.157 (Inspect.158, #Attr.12): + let Inspect.154 : {} = StructAtIndex 2 #Attr.12; + let Inspect.153 : {} = StructAtIndex 1 #Attr.12; + let Inspect.152 : List I64 = StructAtIndex 0 #Attr.12; + let Inspect.346 : Int1 = CallByName Bool.1; + let Inspect.332 : {Str, Int1} = Struct {Inspect.158, Inspect.346}; + let Inspect.331 : {Str, Int1} = CallByName List.18 Inspect.152 Inspect.332 Inspect.154; + ret Inspect.331; + +procedure Inspect.159 (Inspect.334, Inspect.162, Inspect.154): + let Inspect.160 : Str = StructAtIndex 0 Inspect.334; + let Inspect.161 : Int1 = StructAtIndex 1 Inspect.334; + joinpoint Inspect.344 Inspect.163: + let Inspect.341 : I64 = CallByName #Derived.3 Inspect.162; + let Inspect.337 : Str = CallByName Inspect.31 Inspect.341 Inspect.163; + let Inspect.338 : {} = Struct {}; + let Inspect.336 : {Str, Int1} = CallByName Inspect.164 Inspect.337; + ret Inspect.336; + in + if Inspect.161 then + let Inspect.345 : Str = ", "; + let Inspect.343 : Str = CallByName Inspect.61 Inspect.160 Inspect.345; + jump Inspect.344 Inspect.343; + else + jump Inspect.344 Inspect.160; + +procedure Inspect.164 (Inspect.165): + let Inspect.340 : Int1 = CallByName Bool.2; + let Inspect.339 : {Str, Int1} = Struct {Inspect.165, Inspect.340}; + ret Inspect.339; + +procedure Inspect.166 (Inspect.326): + let Inspect.327 : Str = StructAtIndex 0 Inspect.326; + ret Inspect.327; + +procedure Inspect.277 (Inspect.278, Inspect.276): + let Inspect.353 : Str = CallByName Num.96 Inspect.276; + let Inspect.352 : Str = CallByName Inspect.61 Inspect.278 Inspect.353; + ret Inspect.352; + +procedure Inspect.30 (Inspect.147): + ret Inspect.147; + +procedure Inspect.30 (Inspect.147): + ret Inspect.147; + +procedure Inspect.30 (Inspect.147): + ret Inspect.147; + +procedure Inspect.31 (Inspect.305, Inspect.149): + let Inspect.314 : Str = CallByName Inspect.155 Inspect.149 Inspect.305; + ret Inspect.314; + +procedure Inspect.31 (Inspect.305, Inspect.149): + let Inspect.342 : Str = CallByName Inspect.277 Inspect.149 Inspect.305; + ret Inspect.342; + +procedure Inspect.35 (Inspect.300): + ret Inspect.300; + +procedure Inspect.36 (Inspect.304): + let Inspect.311 : Str = ""; + ret Inspect.311; + +procedure Inspect.37 (Inspect.152, Inspect.153, Inspect.154): + let Inspect.316 : {List I64, {}, {}} = Struct {Inspect.152, Inspect.153, Inspect.154}; + let Inspect.315 : {List I64, {}, {}} = CallByName Inspect.30 Inspect.316; + ret Inspect.315; + +procedure Inspect.5 (Inspect.150): + let Inspect.312 : List I64 = CallByName #Derived.0 Inspect.150; + let Inspect.309 : {} = Struct {}; + let Inspect.308 : Str = CallByName Inspect.36 Inspect.309; + let Inspect.307 : Str = CallByName #Derived.4 Inspect.308 Inspect.312; + ret Inspect.307; + +procedure Inspect.54 (Inspect.276): + let Inspect.348 : I64 = CallByName Inspect.30 Inspect.276; + ret Inspect.348; + +procedure Inspect.61 (Inspect.303, Inspect.298): + let Inspect.323 : Str = CallByName Str.3 Inspect.303 Inspect.298; + dec Inspect.298; + ret Inspect.323; + +procedure List.18 (List.154, List.155, List.156): + let List.554 : U64 = 0i64; + let List.555 : U64 = CallByName List.6 List.154; + let List.553 : {Str, Int1} = CallByName List.88 List.154 List.155 List.156 List.554 List.555; + ret List.553; + +procedure List.6 (#Attr.2): + let List.564 : U64 = lowlevel ListLen #Attr.2; + ret List.564; + +procedure List.66 (#Attr.2, #Attr.3): + let List.563 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + ret List.563; + +procedure List.88 (#Derived_gen.17, #Derived_gen.18, #Derived_gen.19, #Derived_gen.20, #Derived_gen.21): + joinpoint List.556 List.157 List.158 List.159 List.160 List.161: + let List.558 : Int1 = CallByName Num.22 List.160 List.161; + if List.558 then + let List.562 : I64 = CallByName List.66 List.157 List.160; + let List.162 : {Str, Int1} = CallByName Inspect.159 List.158 List.562 List.159; + let List.561 : U64 = 1i64; + let List.560 : U64 = CallByName Num.51 List.160 List.561; + jump List.556 List.157 List.162 List.159 List.560 List.161; + else + dec List.157; + ret List.158; + in + jump List.556 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21; + +procedure Num.22 (#Attr.2, #Attr.3): + let Num.293 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; + ret Num.293; + +procedure Num.51 (#Attr.2, #Attr.3): + let Num.292 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3; + ret Num.292; + +procedure Num.96 (#Attr.2): + let Num.291 : Str = lowlevel NumToStr #Attr.2; + ret Num.291; + +procedure Str.3 (#Attr.2, #Attr.3): + let Str.292 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.292; + +procedure Test.0 (): + let Test.3 : List I64 = Array [1i64, 2i64, 3i64]; + let Test.2 : Str = CallByName Inspect.5 Test.3; + let Test.1 : Str = CallByName Inspect.35 Test.2; + ret Test.1; diff --git a/crates/compiler/test_mono/generated/inspect_derived_nested_record_string.txt b/crates/compiler/test_mono/generated/inspect_derived_nested_record_string.txt new file mode 100644 index 0000000000..fd513aaaec --- /dev/null +++ b/crates/compiler/test_mono/generated/inspect_derived_nested_record_string.txt @@ -0,0 +1,274 @@ +procedure #Derived.0 (#Derived.1): + let #Derived_gen.0 : Str = CallByName Inspect.30 #Derived.1; + ret #Derived_gen.0; + +procedure #Derived.2 (#Derived.3, #Derived.1): + let #Derived_gen.7 : Str = "a"; + let #Derived_gen.8 : Str = CallByName #Derived.4 #Derived.1; + let #Derived_gen.6 : {Str, Str} = Struct {#Derived_gen.7, #Derived_gen.8}; + let #Derived_gen.5 : List {Str, Str} = Array [#Derived_gen.6]; + let #Derived_gen.4 : List {Str, Str} = CallByName Inspect.42 #Derived_gen.5; + let #Derived_gen.3 : Str = CallByName Inspect.31 #Derived_gen.4 #Derived.3; + ret #Derived_gen.3; + +procedure #Derived.4 (#Derived.5): + let #Derived_gen.10 : Str = CallByName Inspect.30 #Derived.5; + ret #Derived_gen.10; + +procedure #Derived.6 (#Derived.7, #Derived.5): + let #Derived_gen.17 : Str = "b"; + let #Derived_gen.18 : Str = CallByName Inspect.44 #Derived.5; + let #Derived_gen.16 : {Str, Str} = Struct {#Derived_gen.17, #Derived_gen.18}; + let #Derived_gen.15 : List {Str, Str} = Array [#Derived_gen.16]; + let #Derived_gen.14 : List {Str, Str} = CallByName Inspect.42 #Derived_gen.15; + let #Derived_gen.13 : Str = CallByName Inspect.31 #Derived_gen.14 #Derived.7; + ret #Derived_gen.13; + +procedure Bool.1 (): + let Bool.26 : Int1 = false; + ret Bool.26; + +procedure Bool.2 (): + let Bool.25 : Int1 = true; + ret Bool.25; + +procedure Inspect.228 (Inspect.229, Inspect.227): + let Inspect.352 : Str = "{"; + let Inspect.328 : Str = CallByName Inspect.61 Inspect.229 Inspect.352; + let Inspect.324 : {Str, Int1} = CallByName Inspect.230 Inspect.328 Inspect.227; + let Inspect.325 : {} = Struct {}; + let Inspect.320 : Str = CallByName Inspect.242 Inspect.324; + let Inspect.321 : Str = "}"; + let Inspect.319 : Str = CallByName Inspect.61 Inspect.320 Inspect.321; + ret Inspect.319; + +procedure Inspect.228 (Inspect.229, Inspect.227): + let Inspect.392 : Str = "{"; + let Inspect.368 : Str = CallByName Inspect.61 Inspect.229 Inspect.392; + let Inspect.364 : {Str, Int1} = CallByName Inspect.230 Inspect.368 Inspect.227; + let Inspect.365 : {} = Struct {}; + let Inspect.360 : Str = CallByName Inspect.242 Inspect.364; + let Inspect.361 : Str = "}"; + let Inspect.359 : Str = CallByName Inspect.61 Inspect.360 Inspect.361; + ret Inspect.359; + +procedure Inspect.230 (Inspect.231, Inspect.227): + let Inspect.351 : Int1 = CallByName Bool.1; + let Inspect.332 : {Str, Int1} = Struct {Inspect.231, Inspect.351}; + let Inspect.333 : {} = Struct {}; + let Inspect.331 : {Str, Int1} = CallByName List.18 Inspect.227 Inspect.332 Inspect.333; + ret Inspect.331; + +procedure Inspect.230 (Inspect.231, Inspect.227): + let Inspect.391 : Int1 = CallByName Bool.1; + let Inspect.372 : {Str, Int1} = Struct {Inspect.231, Inspect.391}; + let Inspect.373 : {} = Struct {}; + let Inspect.371 : {Str, Int1} = CallByName List.18 Inspect.227 Inspect.372 Inspect.373; + ret Inspect.371; + +procedure Inspect.232 (Inspect.334, Inspect.335): + let Inspect.235 : Str = StructAtIndex 0 Inspect.335; + let Inspect.236 : Str = StructAtIndex 1 Inspect.335; + let Inspect.233 : Str = StructAtIndex 0 Inspect.334; + let Inspect.234 : Int1 = StructAtIndex 1 Inspect.334; + joinpoint Inspect.349 Inspect.237: + let Inspect.346 : Str = CallByName Inspect.61 Inspect.237 Inspect.235; + let Inspect.347 : Str = ": "; + let Inspect.341 : Str = CallByName Inspect.61 Inspect.346 Inspect.347; + let Inspect.337 : Str = CallByName Inspect.238 Inspect.341 Inspect.236; + let Inspect.338 : {} = Struct {}; + let Inspect.336 : {Str, Int1} = CallByName Inspect.240 Inspect.337; + ret Inspect.336; + in + if Inspect.234 then + let Inspect.350 : Str = ", "; + let Inspect.348 : Str = CallByName Inspect.61 Inspect.233 Inspect.350; + jump Inspect.349 Inspect.348; + else + jump Inspect.349 Inspect.233; + +procedure Inspect.232 (Inspect.334, Inspect.335): + let Inspect.235 : Str = StructAtIndex 0 Inspect.335; + let Inspect.236 : Str = StructAtIndex 1 Inspect.335; + let Inspect.233 : Str = StructAtIndex 0 Inspect.334; + let Inspect.234 : Int1 = StructAtIndex 1 Inspect.334; + joinpoint Inspect.389 Inspect.237: + let Inspect.386 : Str = CallByName Inspect.61 Inspect.237 Inspect.235; + let Inspect.387 : Str = ": "; + let Inspect.381 : Str = CallByName Inspect.61 Inspect.386 Inspect.387; + let Inspect.377 : Str = CallByName Inspect.238 Inspect.381 Inspect.236; + let Inspect.378 : {} = Struct {}; + let Inspect.376 : {Str, Int1} = CallByName Inspect.240 Inspect.377; + ret Inspect.376; + in + if Inspect.234 then + let Inspect.390 : Str = ", "; + let Inspect.388 : Str = CallByName Inspect.61 Inspect.233 Inspect.390; + jump Inspect.389 Inspect.388; + else + jump Inspect.389 Inspect.233; + +procedure Inspect.238 (Inspect.239, Inspect.236): + let Inspect.344 : Str = CallByName Inspect.31 Inspect.236 Inspect.239; + ret Inspect.344; + +procedure Inspect.238 (Inspect.239, Inspect.236): + let Inspect.384 : Str = CallByName Inspect.31 Inspect.236 Inspect.239; + ret Inspect.384; + +procedure Inspect.240 (Inspect.241): + let Inspect.380 : Int1 = CallByName Bool.2; + let Inspect.379 : {Str, Int1} = Struct {Inspect.241, Inspect.380}; + ret Inspect.379; + +procedure Inspect.242 (Inspect.326): + let Inspect.367 : Str = StructAtIndex 0 Inspect.326; + ret Inspect.367; + +procedure Inspect.249 (Inspect.250, Inspect.248): + let Inspect.401 : Str = "\""; + let Inspect.400 : Str = CallByName Inspect.61 Inspect.250 Inspect.401; + let Inspect.398 : Str = CallByName Inspect.61 Inspect.400 Inspect.248; + let Inspect.399 : Str = "\""; + let Inspect.397 : Str = CallByName Inspect.61 Inspect.398 Inspect.399; + ret Inspect.397; + +procedure Inspect.30 (Inspect.147): + ret Inspect.147; + +procedure Inspect.30 (Inspect.147): + ret Inspect.147; + +procedure Inspect.30 (Inspect.147): + ret Inspect.147; + +procedure Inspect.30 (Inspect.147): + ret Inspect.147; + +procedure Inspect.30 (Inspect.147): + ret Inspect.147; + +procedure Inspect.31 (Inspect.305, Inspect.149): + let Inspect.314 : Str = CallByName Inspect.228 Inspect.149 Inspect.305; + ret Inspect.314; + +procedure Inspect.31 (Inspect.305, Inspect.149): + let Inspect.345 : Str = CallByName #Derived.6 Inspect.149 Inspect.305; + ret Inspect.345; + +procedure Inspect.31 (Inspect.305, Inspect.149): + let Inspect.354 : Str = CallByName Inspect.228 Inspect.149 Inspect.305; + ret Inspect.354; + +procedure Inspect.31 (Inspect.305, Inspect.149): + let Inspect.385 : Str = CallByName Inspect.249 Inspect.149 Inspect.305; + ret Inspect.385; + +procedure Inspect.35 (Inspect.300): + ret Inspect.300; + +procedure Inspect.36 (Inspect.304): + let Inspect.311 : Str = ""; + ret Inspect.311; + +procedure Inspect.42 (Inspect.227): + let Inspect.315 : List {Str, Str} = CallByName Inspect.30 Inspect.227; + ret Inspect.315; + +procedure Inspect.42 (Inspect.227): + let Inspect.355 : List {Str, Str} = CallByName Inspect.30 Inspect.227; + ret Inspect.355; + +procedure Inspect.44 (Inspect.248): + let Inspect.393 : Str = CallByName Inspect.30 Inspect.248; + ret Inspect.393; + +procedure Inspect.5 (Inspect.150): + let Inspect.312 : Str = CallByName #Derived.0 Inspect.150; + let Inspect.309 : {} = Struct {}; + let Inspect.308 : Str = CallByName Inspect.36 Inspect.309; + let Inspect.307 : Str = CallByName #Derived.2 Inspect.308 Inspect.312; + ret Inspect.307; + +procedure Inspect.61 (Inspect.303, Inspect.298): + let Inspect.363 : Str = CallByName Str.3 Inspect.303 Inspect.298; + dec Inspect.298; + ret Inspect.363; + +procedure List.18 (List.154, List.155, List.156): + let List.554 : U64 = 0i64; + let List.555 : U64 = CallByName List.6 List.154; + let List.553 : {Str, Int1} = CallByName List.88 List.154 List.155 List.156 List.554 List.555; + ret List.553; + +procedure List.18 (List.154, List.155, List.156): + let List.566 : U64 = 0i64; + let List.567 : U64 = CallByName List.6 List.154; + let List.565 : {Str, Int1} = CallByName List.88 List.154 List.155 List.156 List.566 List.567; + ret List.565; + +procedure List.6 (#Attr.2): + let List.564 : U64 = lowlevel ListLen #Attr.2; + ret List.564; + +procedure List.6 (#Attr.2): + let List.576 : U64 = lowlevel ListLen #Attr.2; + ret List.576; + +procedure List.66 (#Attr.2, #Attr.3): + let List.563 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + ret List.563; + +procedure List.66 (#Attr.2, #Attr.3): + let List.575 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + ret List.575; + +procedure List.88 (#Derived_gen.30, #Derived_gen.31, #Derived_gen.32, #Derived_gen.33, #Derived_gen.34): + joinpoint List.568 List.157 List.158 List.159 List.160 List.161: + let List.570 : Int1 = CallByName Num.22 List.160 List.161; + if List.570 then + let List.574 : {Str, Str} = CallByName List.66 List.157 List.160; + inc List.574; + let List.162 : {Str, Int1} = CallByName Inspect.232 List.158 List.574; + let List.573 : U64 = 1i64; + let List.572 : U64 = CallByName Num.51 List.160 List.573; + jump List.568 List.157 List.162 List.159 List.572 List.161; + else + dec List.157; + ret List.158; + in + jump List.568 #Derived_gen.30 #Derived_gen.31 #Derived_gen.32 #Derived_gen.33 #Derived_gen.34; + +procedure List.88 (#Derived_gen.41, #Derived_gen.42, #Derived_gen.43, #Derived_gen.44, #Derived_gen.45): + joinpoint List.556 List.157 List.158 List.159 List.160 List.161: + let List.558 : Int1 = CallByName Num.22 List.160 List.161; + if List.558 then + let List.562 : {Str, Str} = CallByName List.66 List.157 List.160; + inc List.562; + let List.162 : {Str, Int1} = CallByName Inspect.232 List.158 List.562; + let List.561 : U64 = 1i64; + let List.560 : U64 = CallByName Num.51 List.160 List.561; + jump List.556 List.157 List.162 List.159 List.560 List.161; + else + dec List.157; + ret List.158; + in + jump List.556 #Derived_gen.41 #Derived_gen.42 #Derived_gen.43 #Derived_gen.44 #Derived_gen.45; + +procedure Num.22 (#Attr.2, #Attr.3): + let Num.294 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; + ret Num.294; + +procedure Num.51 (#Attr.2, #Attr.3): + let Num.293 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3; + ret Num.293; + +procedure Str.3 (#Attr.2, #Attr.3): + let Str.293 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.293; + +procedure Test.0 (): + let Test.5 : Str = "bar"; + let Test.2 : Str = CallByName Inspect.5 Test.5; + let Test.1 : Str = CallByName Inspect.35 Test.2; + ret Test.1; diff --git a/crates/compiler/test_mono/generated/inspect_derived_record.txt b/crates/compiler/test_mono/generated/inspect_derived_record.txt new file mode 100644 index 0000000000..756bb71eeb --- /dev/null +++ b/crates/compiler/test_mono/generated/inspect_derived_record.txt @@ -0,0 +1,204 @@ +procedure #Derived.0 (#Derived.1): + let #Derived_gen.0 : {Decimal, I64} = CallByName Inspect.30 #Derived.1; + ret #Derived_gen.0; + +procedure #Derived.2 (#Derived.3, #Derived.1): + let #Derived_gen.13 : I64 = StructAtIndex 1 #Derived.1; + let #Derived_gen.11 : [C I64, C Decimal] = CallByName Inspect.54 #Derived_gen.13; + let #Derived_gen.12 : Str = "a"; + let #Derived_gen.6 : {[C I64, C Decimal], Str} = Struct {#Derived_gen.11, #Derived_gen.12}; + let #Derived_gen.10 : Decimal = StructAtIndex 0 #Derived.1; + let #Derived_gen.8 : [C I64, C Decimal] = CallByName Inspect.60 #Derived_gen.10; + let #Derived_gen.9 : Str = "b"; + let #Derived_gen.7 : {[C I64, C Decimal], Str} = Struct {#Derived_gen.8, #Derived_gen.9}; + let #Derived_gen.5 : List {[C I64, C Decimal], Str} = Array [#Derived_gen.6, #Derived_gen.7]; + let #Derived_gen.4 : List {[C I64, C Decimal], Str} = CallByName Inspect.42 #Derived_gen.5; + let #Derived_gen.3 : Str = CallByName Inspect.31 #Derived_gen.4 #Derived.3; + ret #Derived_gen.3; + +procedure Bool.1 (): + let Bool.24 : Int1 = false; + ret Bool.24; + +procedure Bool.2 (): + let Bool.23 : Int1 = true; + ret Bool.23; + +procedure Inspect.228 (Inspect.229, Inspect.227): + let Inspect.353 : Str = "{"; + let Inspect.328 : Str = CallByName Inspect.61 Inspect.229 Inspect.353; + let Inspect.324 : {Str, Int1} = CallByName Inspect.230 Inspect.328 Inspect.227; + let Inspect.325 : {} = Struct {}; + let Inspect.320 : Str = CallByName Inspect.242 Inspect.324; + let Inspect.321 : Str = "}"; + let Inspect.319 : Str = CallByName Inspect.61 Inspect.320 Inspect.321; + ret Inspect.319; + +procedure Inspect.230 (Inspect.231, Inspect.227): + let Inspect.352 : Int1 = CallByName Bool.1; + let Inspect.332 : {Str, Int1} = Struct {Inspect.231, Inspect.352}; + let Inspect.333 : {} = Struct {}; + let Inspect.331 : {Str, Int1} = CallByName List.18 Inspect.227 Inspect.332 Inspect.333; + ret Inspect.331; + +procedure Inspect.232 (Inspect.334, Inspect.335): + let Inspect.236 : [C I64, C Decimal] = StructAtIndex 0 Inspect.335; + let Inspect.235 : Str = StructAtIndex 1 Inspect.335; + let Inspect.233 : Str = StructAtIndex 0 Inspect.334; + let Inspect.234 : Int1 = StructAtIndex 1 Inspect.334; + joinpoint Inspect.350 Inspect.237: + let Inspect.347 : Str = CallByName Inspect.61 Inspect.237 Inspect.235; + let Inspect.348 : Str = ": "; + let Inspect.341 : Str = CallByName Inspect.61 Inspect.347 Inspect.348; + let Inspect.337 : Str = CallByName Inspect.238 Inspect.341 Inspect.236; + let Inspect.338 : {} = Struct {}; + let Inspect.336 : {Str, Int1} = CallByName Inspect.240 Inspect.337; + ret Inspect.336; + in + if Inspect.234 then + let Inspect.351 : Str = ", "; + let Inspect.349 : Str = CallByName Inspect.61 Inspect.233 Inspect.351; + jump Inspect.350 Inspect.349; + else + jump Inspect.350 Inspect.233; + +procedure Inspect.238 (Inspect.239, Inspect.236): + let Inspect.344 : Str = CallByName Inspect.31 Inspect.236 Inspect.239; + ret Inspect.344; + +procedure Inspect.240 (Inspect.241): + let Inspect.340 : Int1 = CallByName Bool.2; + let Inspect.339 : {Str, Int1} = Struct {Inspect.241, Inspect.340}; + ret Inspect.339; + +procedure Inspect.242 (Inspect.326): + let Inspect.327 : Str = StructAtIndex 0 Inspect.326; + ret Inspect.327; + +procedure Inspect.277 (Inspect.278, #Attr.12): + let Inspect.366 : I64 = UnionAtIndex (Id 0) (Index 0) #Attr.12; + let Inspect.365 : Str = CallByName Num.96 Inspect.366; + let Inspect.364 : Str = CallByName Inspect.61 Inspect.278 Inspect.365; + ret Inspect.364; + +procedure Inspect.295 (Inspect.296, #Attr.12): + let Inspect.360 : Decimal = UnionAtIndex (Id 1) (Index 0) #Attr.12; + let Inspect.359 : Str = CallByName Num.96 Inspect.360; + let Inspect.358 : Str = CallByName Inspect.61 Inspect.296 Inspect.359; + ret Inspect.358; + +procedure Inspect.30 (Inspect.147): + ret Inspect.147; + +procedure Inspect.30 (Inspect.147): + ret Inspect.147; + +procedure Inspect.30 (Inspect.147): + ret Inspect.147; + +procedure Inspect.31 (Inspect.305, Inspect.149): + let Inspect.314 : Str = CallByName Inspect.228 Inspect.149 Inspect.305; + ret Inspect.314; + +procedure Inspect.31 (Inspect.305, Inspect.149): + let Inspect.346 : U8 = GetTagId Inspect.305; + switch Inspect.346: + case 0: + let Inspect.345 : Str = CallByName Inspect.277 Inspect.149 Inspect.305; + ret Inspect.345; + + default: + let Inspect.345 : Str = CallByName Inspect.295 Inspect.149 Inspect.305; + ret Inspect.345; + + +procedure Inspect.35 (Inspect.300): + ret Inspect.300; + +procedure Inspect.36 (Inspect.304): + let Inspect.311 : Str = ""; + ret Inspect.311; + +procedure Inspect.42 (Inspect.227): + let Inspect.315 : List {[C I64, C Decimal], Str} = CallByName Inspect.30 Inspect.227; + ret Inspect.315; + +procedure Inspect.5 (Inspect.150): + let Inspect.312 : {Decimal, I64} = CallByName #Derived.0 Inspect.150; + let Inspect.309 : {} = Struct {}; + let Inspect.308 : Str = CallByName Inspect.36 Inspect.309; + let Inspect.307 : Str = CallByName #Derived.2 Inspect.308 Inspect.312; + ret Inspect.307; + +procedure Inspect.54 (Inspect.276): + let Inspect.362 : [C I64, C Decimal] = TagId(0) Inspect.276; + let Inspect.361 : [C I64, C Decimal] = CallByName Inspect.30 Inspect.362; + ret Inspect.361; + +procedure Inspect.60 (Inspect.294): + let Inspect.355 : [C I64, C Decimal] = TagId(1) Inspect.294; + let Inspect.354 : [C I64, C Decimal] = CallByName Inspect.30 Inspect.355; + ret Inspect.354; + +procedure Inspect.61 (Inspect.303, Inspect.298): + let Inspect.323 : Str = CallByName Str.3 Inspect.303 Inspect.298; + dec Inspect.298; + ret Inspect.323; + +procedure List.18 (List.154, List.155, List.156): + let List.554 : U64 = 0i64; + let List.555 : U64 = CallByName List.6 List.154; + let List.553 : {Str, Int1} = CallByName List.88 List.154 List.155 List.156 List.554 List.555; + ret List.553; + +procedure List.6 (#Attr.2): + let List.564 : U64 = lowlevel ListLen #Attr.2; + ret List.564; + +procedure List.66 (#Attr.2, #Attr.3): + let List.563 : {[C I64, C Decimal], Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + ret List.563; + +procedure List.88 (#Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17, #Derived_gen.18): + joinpoint List.556 List.157 List.158 List.159 List.160 List.161: + let List.558 : Int1 = CallByName Num.22 List.160 List.161; + if List.558 then + let List.562 : {[C I64, C Decimal], Str} = CallByName List.66 List.157 List.160; + inc List.562; + let List.162 : {Str, Int1} = CallByName Inspect.232 List.158 List.562; + let List.561 : U64 = 1i64; + let List.560 : U64 = CallByName Num.51 List.160 List.561; + jump List.556 List.157 List.162 List.159 List.560 List.161; + else + dec List.157; + ret List.158; + in + jump List.556 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18; + +procedure Num.22 (#Attr.2, #Attr.3): + let Num.294 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; + ret Num.294; + +procedure Num.51 (#Attr.2, #Attr.3): + let Num.293 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3; + ret Num.293; + +procedure Num.96 (#Attr.2): + let Num.291 : Str = lowlevel NumToStr #Attr.2; + ret Num.291; + +procedure Num.96 (#Attr.2): + let Num.292 : Str = lowlevel NumToStr #Attr.2; + ret Num.292; + +procedure Str.3 (#Attr.2, #Attr.3): + let Str.292 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.292; + +procedure Test.0 (): + let Test.4 : Decimal = 3dec; + let Test.5 : I64 = 7i64; + let Test.3 : {Decimal, I64} = Struct {Test.4, Test.5}; + let Test.2 : Str = CallByName Inspect.5 Test.3; + let Test.1 : Str = CallByName Inspect.35 Test.2; + ret Test.1; diff --git a/crates/compiler/test_mono/generated/inspect_derived_record_one_field_string.txt b/crates/compiler/test_mono/generated/inspect_derived_record_one_field_string.txt new file mode 100644 index 0000000000..1c78bb0240 --- /dev/null +++ b/crates/compiler/test_mono/generated/inspect_derived_record_one_field_string.txt @@ -0,0 +1,171 @@ +procedure #Derived.0 (#Derived.1): + let #Derived_gen.0 : Str = CallByName Inspect.30 #Derived.1; + ret #Derived_gen.0; + +procedure #Derived.2 (#Derived.3, #Derived.1): + let #Derived_gen.7 : Str = "a"; + let #Derived_gen.8 : Str = CallByName Inspect.44 #Derived.1; + let #Derived_gen.6 : {Str, Str} = Struct {#Derived_gen.7, #Derived_gen.8}; + let #Derived_gen.5 : List {Str, Str} = Array [#Derived_gen.6]; + let #Derived_gen.4 : List {Str, Str} = CallByName Inspect.42 #Derived_gen.5; + let #Derived_gen.3 : Str = CallByName Inspect.31 #Derived_gen.4 #Derived.3; + ret #Derived_gen.3; + +procedure Bool.1 (): + let Bool.24 : Int1 = false; + ret Bool.24; + +procedure Bool.2 (): + let Bool.23 : Int1 = true; + ret Bool.23; + +procedure Inspect.228 (Inspect.229, Inspect.227): + let Inspect.352 : Str = "{"; + let Inspect.328 : Str = CallByName Inspect.61 Inspect.229 Inspect.352; + let Inspect.324 : {Str, Int1} = CallByName Inspect.230 Inspect.328 Inspect.227; + let Inspect.325 : {} = Struct {}; + let Inspect.320 : Str = CallByName Inspect.242 Inspect.324; + let Inspect.321 : Str = "}"; + let Inspect.319 : Str = CallByName Inspect.61 Inspect.320 Inspect.321; + ret Inspect.319; + +procedure Inspect.230 (Inspect.231, Inspect.227): + let Inspect.351 : Int1 = CallByName Bool.1; + let Inspect.332 : {Str, Int1} = Struct {Inspect.231, Inspect.351}; + let Inspect.333 : {} = Struct {}; + let Inspect.331 : {Str, Int1} = CallByName List.18 Inspect.227 Inspect.332 Inspect.333; + ret Inspect.331; + +procedure Inspect.232 (Inspect.334, Inspect.335): + let Inspect.235 : Str = StructAtIndex 0 Inspect.335; + let Inspect.236 : Str = StructAtIndex 1 Inspect.335; + let Inspect.233 : Str = StructAtIndex 0 Inspect.334; + let Inspect.234 : Int1 = StructAtIndex 1 Inspect.334; + joinpoint Inspect.349 Inspect.237: + let Inspect.346 : Str = CallByName Inspect.61 Inspect.237 Inspect.235; + let Inspect.347 : Str = ": "; + let Inspect.341 : Str = CallByName Inspect.61 Inspect.346 Inspect.347; + let Inspect.337 : Str = CallByName Inspect.238 Inspect.341 Inspect.236; + let Inspect.338 : {} = Struct {}; + let Inspect.336 : {Str, Int1} = CallByName Inspect.240 Inspect.337; + ret Inspect.336; + in + if Inspect.234 then + let Inspect.350 : Str = ", "; + let Inspect.348 : Str = CallByName Inspect.61 Inspect.233 Inspect.350; + jump Inspect.349 Inspect.348; + else + jump Inspect.349 Inspect.233; + +procedure Inspect.238 (Inspect.239, Inspect.236): + let Inspect.344 : Str = CallByName Inspect.31 Inspect.236 Inspect.239; + ret Inspect.344; + +procedure Inspect.240 (Inspect.241): + let Inspect.340 : Int1 = CallByName Bool.2; + let Inspect.339 : {Str, Int1} = Struct {Inspect.241, Inspect.340}; + ret Inspect.339; + +procedure Inspect.242 (Inspect.326): + let Inspect.327 : Str = StructAtIndex 0 Inspect.326; + ret Inspect.327; + +procedure Inspect.249 (Inspect.250, Inspect.248): + let Inspect.361 : Str = "\""; + let Inspect.360 : Str = CallByName Inspect.61 Inspect.250 Inspect.361; + let Inspect.358 : Str = CallByName Inspect.61 Inspect.360 Inspect.248; + let Inspect.359 : Str = "\""; + let Inspect.357 : Str = CallByName Inspect.61 Inspect.358 Inspect.359; + ret Inspect.357; + +procedure Inspect.30 (Inspect.147): + ret Inspect.147; + +procedure Inspect.30 (Inspect.147): + ret Inspect.147; + +procedure Inspect.30 (Inspect.147): + ret Inspect.147; + +procedure Inspect.31 (Inspect.305, Inspect.149): + let Inspect.314 : Str = CallByName Inspect.228 Inspect.149 Inspect.305; + ret Inspect.314; + +procedure Inspect.31 (Inspect.305, Inspect.149): + let Inspect.345 : Str = CallByName Inspect.249 Inspect.149 Inspect.305; + ret Inspect.345; + +procedure Inspect.35 (Inspect.300): + ret Inspect.300; + +procedure Inspect.36 (Inspect.304): + let Inspect.311 : Str = ""; + ret Inspect.311; + +procedure Inspect.42 (Inspect.227): + let Inspect.315 : List {Str, Str} = CallByName Inspect.30 Inspect.227; + ret Inspect.315; + +procedure Inspect.44 (Inspect.248): + let Inspect.353 : Str = CallByName Inspect.30 Inspect.248; + ret Inspect.353; + +procedure Inspect.5 (Inspect.150): + let Inspect.312 : Str = CallByName #Derived.0 Inspect.150; + let Inspect.309 : {} = Struct {}; + let Inspect.308 : Str = CallByName Inspect.36 Inspect.309; + let Inspect.307 : Str = CallByName #Derived.2 Inspect.308 Inspect.312; + ret Inspect.307; + +procedure Inspect.61 (Inspect.303, Inspect.298): + let Inspect.323 : Str = CallByName Str.3 Inspect.303 Inspect.298; + dec Inspect.298; + ret Inspect.323; + +procedure List.18 (List.154, List.155, List.156): + let List.554 : U64 = 0i64; + let List.555 : U64 = CallByName List.6 List.154; + let List.553 : {Str, Int1} = CallByName List.88 List.154 List.155 List.156 List.554 List.555; + ret List.553; + +procedure List.6 (#Attr.2): + let List.564 : U64 = lowlevel ListLen #Attr.2; + ret List.564; + +procedure List.66 (#Attr.2, #Attr.3): + let List.563 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + ret List.563; + +procedure List.88 (#Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17, #Derived_gen.18): + joinpoint List.556 List.157 List.158 List.159 List.160 List.161: + let List.558 : Int1 = CallByName Num.22 List.160 List.161; + if List.558 then + let List.562 : {Str, Str} = CallByName List.66 List.157 List.160; + inc List.562; + let List.162 : {Str, Int1} = CallByName Inspect.232 List.158 List.562; + let List.561 : U64 = 1i64; + let List.560 : U64 = CallByName Num.51 List.160 List.561; + jump List.556 List.157 List.162 List.159 List.560 List.161; + else + dec List.157; + ret List.158; + in + jump List.556 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18; + +procedure Num.22 (#Attr.2, #Attr.3): + let Num.292 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; + ret Num.292; + +procedure Num.51 (#Attr.2, #Attr.3): + let Num.291 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3; + ret Num.291; + +procedure Str.3 (#Attr.2, #Attr.3): + let Str.292 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.292; + +procedure Test.0 (): + let Test.4 : Str = "foo"; + let Test.2 : Str = CallByName Inspect.5 Test.4; + let Test.1 : Str = CallByName Inspect.35 Test.2; + ret Test.1; diff --git a/crates/compiler/test_mono/generated/inspect_derived_record_two_field_strings.txt b/crates/compiler/test_mono/generated/inspect_derived_record_two_field_strings.txt new file mode 100644 index 0000000000..76a867481b --- /dev/null +++ b/crates/compiler/test_mono/generated/inspect_derived_record_two_field_strings.txt @@ -0,0 +1,180 @@ +procedure #Derived.0 (#Derived.1): + let #Derived_gen.0 : {Str, Str} = CallByName Inspect.30 #Derived.1; + ret #Derived_gen.0; + +procedure #Derived.2 (#Derived.3, #Derived.1): + let #Derived_gen.11 : Str = "a"; + let #Derived_gen.13 : Str = StructAtIndex 0 #Derived.1; + inc #Derived_gen.13; + let #Derived_gen.12 : Str = CallByName Inspect.44 #Derived_gen.13; + let #Derived_gen.6 : {Str, Str} = Struct {#Derived_gen.11, #Derived_gen.12}; + let #Derived_gen.8 : Str = "b"; + let #Derived_gen.10 : Str = StructAtIndex 1 #Derived.1; + dec #Derived_gen.13; + let #Derived_gen.9 : Str = CallByName Inspect.44 #Derived_gen.10; + let #Derived_gen.7 : {Str, Str} = Struct {#Derived_gen.8, #Derived_gen.9}; + let #Derived_gen.5 : List {Str, Str} = Array [#Derived_gen.6, #Derived_gen.7]; + let #Derived_gen.4 : List {Str, Str} = CallByName Inspect.42 #Derived_gen.5; + let #Derived_gen.3 : Str = CallByName Inspect.31 #Derived_gen.4 #Derived.3; + ret #Derived_gen.3; + +procedure Bool.1 (): + let Bool.24 : Int1 = false; + ret Bool.24; + +procedure Bool.2 (): + let Bool.23 : Int1 = true; + ret Bool.23; + +procedure Inspect.228 (Inspect.229, Inspect.227): + let Inspect.352 : Str = "{"; + let Inspect.328 : Str = CallByName Inspect.61 Inspect.229 Inspect.352; + let Inspect.324 : {Str, Int1} = CallByName Inspect.230 Inspect.328 Inspect.227; + let Inspect.325 : {} = Struct {}; + let Inspect.320 : Str = CallByName Inspect.242 Inspect.324; + let Inspect.321 : Str = "}"; + let Inspect.319 : Str = CallByName Inspect.61 Inspect.320 Inspect.321; + ret Inspect.319; + +procedure Inspect.230 (Inspect.231, Inspect.227): + let Inspect.351 : Int1 = CallByName Bool.1; + let Inspect.332 : {Str, Int1} = Struct {Inspect.231, Inspect.351}; + let Inspect.333 : {} = Struct {}; + let Inspect.331 : {Str, Int1} = CallByName List.18 Inspect.227 Inspect.332 Inspect.333; + ret Inspect.331; + +procedure Inspect.232 (Inspect.334, Inspect.335): + let Inspect.235 : Str = StructAtIndex 0 Inspect.335; + let Inspect.236 : Str = StructAtIndex 1 Inspect.335; + let Inspect.233 : Str = StructAtIndex 0 Inspect.334; + let Inspect.234 : Int1 = StructAtIndex 1 Inspect.334; + joinpoint Inspect.349 Inspect.237: + let Inspect.346 : Str = CallByName Inspect.61 Inspect.237 Inspect.235; + let Inspect.347 : Str = ": "; + let Inspect.341 : Str = CallByName Inspect.61 Inspect.346 Inspect.347; + let Inspect.337 : Str = CallByName Inspect.238 Inspect.341 Inspect.236; + let Inspect.338 : {} = Struct {}; + let Inspect.336 : {Str, Int1} = CallByName Inspect.240 Inspect.337; + ret Inspect.336; + in + if Inspect.234 then + let Inspect.350 : Str = ", "; + let Inspect.348 : Str = CallByName Inspect.61 Inspect.233 Inspect.350; + jump Inspect.349 Inspect.348; + else + jump Inspect.349 Inspect.233; + +procedure Inspect.238 (Inspect.239, Inspect.236): + let Inspect.344 : Str = CallByName Inspect.31 Inspect.236 Inspect.239; + ret Inspect.344; + +procedure Inspect.240 (Inspect.241): + let Inspect.340 : Int1 = CallByName Bool.2; + let Inspect.339 : {Str, Int1} = Struct {Inspect.241, Inspect.340}; + ret Inspect.339; + +procedure Inspect.242 (Inspect.326): + let Inspect.327 : Str = StructAtIndex 0 Inspect.326; + ret Inspect.327; + +procedure Inspect.249 (Inspect.250, Inspect.248): + let Inspect.361 : Str = "\""; + let Inspect.360 : Str = CallByName Inspect.61 Inspect.250 Inspect.361; + let Inspect.358 : Str = CallByName Inspect.61 Inspect.360 Inspect.248; + let Inspect.359 : Str = "\""; + let Inspect.357 : Str = CallByName Inspect.61 Inspect.358 Inspect.359; + ret Inspect.357; + +procedure Inspect.30 (Inspect.147): + ret Inspect.147; + +procedure Inspect.30 (Inspect.147): + ret Inspect.147; + +procedure Inspect.30 (Inspect.147): + ret Inspect.147; + +procedure Inspect.31 (Inspect.305, Inspect.149): + let Inspect.314 : Str = CallByName Inspect.228 Inspect.149 Inspect.305; + ret Inspect.314; + +procedure Inspect.31 (Inspect.305, Inspect.149): + let Inspect.345 : Str = CallByName Inspect.249 Inspect.149 Inspect.305; + ret Inspect.345; + +procedure Inspect.35 (Inspect.300): + ret Inspect.300; + +procedure Inspect.36 (Inspect.304): + let Inspect.311 : Str = ""; + ret Inspect.311; + +procedure Inspect.42 (Inspect.227): + let Inspect.315 : List {Str, Str} = CallByName Inspect.30 Inspect.227; + ret Inspect.315; + +procedure Inspect.44 (Inspect.248): + let Inspect.362 : Str = CallByName Inspect.30 Inspect.248; + ret Inspect.362; + +procedure Inspect.5 (Inspect.150): + let Inspect.312 : {Str, Str} = CallByName #Derived.0 Inspect.150; + let Inspect.309 : {} = Struct {}; + let Inspect.308 : Str = CallByName Inspect.36 Inspect.309; + let Inspect.307 : Str = CallByName #Derived.2 Inspect.308 Inspect.312; + ret Inspect.307; + +procedure Inspect.61 (Inspect.303, Inspect.298): + let Inspect.323 : Str = CallByName Str.3 Inspect.303 Inspect.298; + dec Inspect.298; + ret Inspect.323; + +procedure List.18 (List.154, List.155, List.156): + let List.554 : U64 = 0i64; + let List.555 : U64 = CallByName List.6 List.154; + let List.553 : {Str, Int1} = CallByName List.88 List.154 List.155 List.156 List.554 List.555; + ret List.553; + +procedure List.6 (#Attr.2): + let List.564 : U64 = lowlevel ListLen #Attr.2; + ret List.564; + +procedure List.66 (#Attr.2, #Attr.3): + let List.563 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + ret List.563; + +procedure List.88 (#Derived_gen.18, #Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_gen.22): + joinpoint List.556 List.157 List.158 List.159 List.160 List.161: + let List.558 : Int1 = CallByName Num.22 List.160 List.161; + if List.558 then + let List.562 : {Str, Str} = CallByName List.66 List.157 List.160; + inc List.562; + let List.162 : {Str, Int1} = CallByName Inspect.232 List.158 List.562; + let List.561 : U64 = 1i64; + let List.560 : U64 = CallByName Num.51 List.160 List.561; + jump List.556 List.157 List.162 List.159 List.560 List.161; + else + dec List.157; + ret List.158; + in + jump List.556 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22; + +procedure Num.22 (#Attr.2, #Attr.3): + let Num.292 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; + ret Num.292; + +procedure Num.51 (#Attr.2, #Attr.3): + let Num.291 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3; + ret Num.291; + +procedure Str.3 (#Attr.2, #Attr.3): + let Str.292 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.292; + +procedure Test.0 (): + let Test.4 : Str = "foo"; + let Test.5 : Str = "bar"; + let Test.3 : {Str, Str} = Struct {Test.4, Test.5}; + let Test.2 : Str = CallByName Inspect.5 Test.3; + let Test.1 : Str = CallByName Inspect.35 Test.2; + ret Test.1; diff --git a/crates/compiler/test_mono/generated/inspect_derived_string.txt b/crates/compiler/test_mono/generated/inspect_derived_string.txt new file mode 100644 index 0000000000..8b22e27efe --- /dev/null +++ b/crates/compiler/test_mono/generated/inspect_derived_string.txt @@ -0,0 +1,43 @@ +procedure Inspect.249 (Inspect.250, Inspect.248): + let Inspect.323 : Str = "\""; + let Inspect.322 : Str = CallByName Inspect.61 Inspect.250 Inspect.323; + let Inspect.318 : Str = CallByName Inspect.61 Inspect.322 Inspect.248; + let Inspect.319 : Str = "\""; + let Inspect.317 : Str = CallByName Inspect.61 Inspect.318 Inspect.319; + ret Inspect.317; + +procedure Inspect.30 (Inspect.147): + ret Inspect.147; + +procedure Inspect.35 (Inspect.300): + ret Inspect.300; + +procedure Inspect.36 (Inspect.304): + let Inspect.311 : Str = ""; + ret Inspect.311; + +procedure Inspect.44 (Inspect.248): + let Inspect.313 : Str = CallByName Inspect.30 Inspect.248; + ret Inspect.313; + +procedure Inspect.5 (Inspect.150): + let Inspect.312 : Str = CallByName Inspect.44 Inspect.150; + let Inspect.309 : {} = Struct {}; + let Inspect.308 : Str = CallByName Inspect.36 Inspect.309; + let Inspect.307 : Str = CallByName Inspect.249 Inspect.308 Inspect.312; + ret Inspect.307; + +procedure Inspect.61 (Inspect.303, Inspect.298): + let Inspect.321 : Str = CallByName Str.3 Inspect.303 Inspect.298; + dec Inspect.298; + ret Inspect.321; + +procedure Str.3 (#Attr.2, #Attr.3): + let Str.292 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.292; + +procedure Test.0 (): + let Test.3 : Str = "abc"; + let Test.2 : Str = CallByName Inspect.5 Test.3; + let Test.1 : Str = CallByName Inspect.35 Test.2; + ret Test.1; diff --git a/crates/compiler/test_mono/generated/inspect_derived_tag_one_field_string.txt b/crates/compiler/test_mono/generated/inspect_derived_tag_one_field_string.txt new file mode 100644 index 0000000000..6f59ae05e1 --- /dev/null +++ b/crates/compiler/test_mono/generated/inspect_derived_tag_one_field_string.txt @@ -0,0 +1,173 @@ +procedure #Derived.0 (#Derived.1): + let #Derived_gen.0 : Str = CallByName Inspect.30 #Derived.1; + ret #Derived_gen.0; + +procedure #Derived.3 (#Derived.4, #Derived.1): + joinpoint #Derived_gen.5 #Derived_gen.4: + let #Derived_gen.3 : Str = CallByName Inspect.31 #Derived_gen.4 #Derived.4; + ret #Derived_gen.3; + in + let #Derived_gen.7 : Str = "A"; + let #Derived_gen.9 : Str = CallByName Inspect.44 #Derived.1; + let #Derived_gen.8 : List Str = Array [#Derived_gen.9]; + let #Derived_gen.6 : [C Str, C Str List Str] = CallByName Inspect.40 #Derived_gen.7 #Derived_gen.8; + jump #Derived_gen.5 #Derived_gen.6; + +procedure Bool.11 (#Attr.2, #Attr.3): + let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3; + ret Bool.23; + +procedure Inspect.203 (Inspect.204, #Attr.12): + let Inspect.346 : Str = UnionAtIndex (Id 0) (Index 0) #Attr.12; + let Inspect.345 : Str = CallByName Inspect.61 Inspect.204 Inspect.346; + ret Inspect.345; + +procedure Inspect.205 (Inspect.206, #Attr.12): + let Inspect.340 : List Str = UnionAtIndex (Id 1) (Index 1) #Attr.12; + let Inspect.339 : Str = UnionAtIndex (Id 1) (Index 0) #Attr.12; + let Inspect.338 : Str = "("; + let Inspect.337 : Str = CallByName Inspect.61 Inspect.206 Inspect.338; + let Inspect.325 : Str = CallByName Inspect.61 Inspect.337 Inspect.339; + let Inspect.321 : Str = CallByName Inspect.207 Inspect.325 Inspect.340; + let Inspect.322 : Str = ")"; + let Inspect.320 : Str = CallByName Inspect.61 Inspect.321 Inspect.322; + ret Inspect.320; + +procedure Inspect.207 (Inspect.208, Inspect.202): + let Inspect.329 : {} = Struct {}; + let Inspect.328 : Str = CallByName List.18 Inspect.202 Inspect.208 Inspect.329; + ret Inspect.328; + +procedure Inspect.209 (Inspect.210, Inspect.211): + let Inspect.336 : Str = " "; + let Inspect.331 : Str = CallByName Inspect.61 Inspect.210 Inspect.336; + let Inspect.330 : Str = CallByName Inspect.212 Inspect.331 Inspect.211; + ret Inspect.330; + +procedure Inspect.212 (Inspect.213, Inspect.211): + let Inspect.334 : Str = CallByName Inspect.31 Inspect.211 Inspect.213; + ret Inspect.334; + +procedure Inspect.249 (Inspect.250, Inspect.248): + let Inspect.355 : Str = "\""; + let Inspect.354 : Str = CallByName Inspect.61 Inspect.250 Inspect.355; + let Inspect.352 : Str = CallByName Inspect.61 Inspect.354 Inspect.248; + let Inspect.353 : Str = "\""; + let Inspect.351 : Str = CallByName Inspect.61 Inspect.352 Inspect.353; + ret Inspect.351; + +procedure Inspect.30 (Inspect.147): + ret Inspect.147; + +procedure Inspect.30 (Inspect.147): + ret Inspect.147; + +procedure Inspect.30 (Inspect.147): + ret Inspect.147; + +procedure Inspect.31 (Inspect.305, Inspect.149): + let Inspect.315 : U8 = GetTagId Inspect.305; + switch Inspect.315: + case 0: + let Inspect.314 : Str = CallByName Inspect.203 Inspect.149 Inspect.305; + ret Inspect.314; + + default: + let Inspect.314 : Str = CallByName Inspect.205 Inspect.149 Inspect.305; + ret Inspect.314; + + +procedure Inspect.31 (Inspect.305, Inspect.149): + let Inspect.335 : Str = CallByName Inspect.249 Inspect.149 Inspect.305; + ret Inspect.335; + +procedure Inspect.35 (Inspect.300): + ret Inspect.300; + +procedure Inspect.36 (Inspect.304): + let Inspect.311 : Str = ""; + ret Inspect.311; + +procedure Inspect.40 (Inspect.201, Inspect.202): + inc Inspect.202; + let Inspect.341 : Int1 = CallByName List.1 Inspect.202; + if Inspect.341 then + dec Inspect.202; + let Inspect.343 : [C Str, C Str List Str] = TagId(0) Inspect.201; + let Inspect.342 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.343; + ret Inspect.342; + else + let Inspect.317 : [C Str, C Str List Str] = TagId(1) Inspect.201 Inspect.202; + let Inspect.316 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.317; + ret Inspect.316; + +procedure Inspect.44 (Inspect.248): + let Inspect.347 : Str = CallByName Inspect.30 Inspect.248; + ret Inspect.347; + +procedure Inspect.5 (Inspect.150): + let Inspect.312 : Str = CallByName #Derived.0 Inspect.150; + let Inspect.309 : {} = Struct {}; + let Inspect.308 : Str = CallByName Inspect.36 Inspect.309; + let Inspect.307 : Str = CallByName #Derived.3 Inspect.308 Inspect.312; + ret Inspect.307; + +procedure Inspect.61 (Inspect.303, Inspect.298): + let Inspect.324 : Str = CallByName Str.3 Inspect.303 Inspect.298; + dec Inspect.298; + ret Inspect.324; + +procedure List.1 (List.102): + let List.566 : U64 = CallByName List.6 List.102; + dec List.102; + let List.567 : U64 = 0i64; + let List.565 : Int1 = CallByName Bool.11 List.566 List.567; + ret List.565; + +procedure List.18 (List.154, List.155, List.156): + let List.554 : U64 = 0i64; + let List.555 : U64 = CallByName List.6 List.154; + let List.553 : Str = CallByName List.88 List.154 List.155 List.156 List.554 List.555; + ret List.553; + +procedure List.6 (#Attr.2): + let List.564 : U64 = lowlevel ListLen #Attr.2; + ret List.564; + +procedure List.66 (#Attr.2, #Attr.3): + let List.563 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + ret List.563; + +procedure List.88 (#Derived_gen.18, #Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_gen.22): + joinpoint List.556 List.157 List.158 List.159 List.160 List.161: + let List.558 : Int1 = CallByName Num.22 List.160 List.161; + if List.558 then + let List.562 : Str = CallByName List.66 List.157 List.160; + inc List.562; + let List.162 : Str = CallByName Inspect.209 List.158 List.562; + let List.561 : U64 = 1i64; + let List.560 : U64 = CallByName Num.51 List.160 List.561; + jump List.556 List.157 List.162 List.159 List.560 List.161; + else + dec List.157; + ret List.158; + in + jump List.556 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22; + +procedure Num.22 (#Attr.2, #Attr.3): + let Num.292 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; + ret Num.292; + +procedure Num.51 (#Attr.2, #Attr.3): + let Num.291 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3; + ret Num.291; + +procedure Str.3 (#Attr.2, #Attr.3): + let Str.292 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.292; + +procedure Test.0 (): + let Test.5 : Str = "foo"; + let Test.4 : Str = CallByName Inspect.5 Test.5; + let Test.3 : Str = CallByName Inspect.35 Test.4; + ret Test.3; diff --git a/crates/compiler/test_mono/generated/inspect_derived_tag_two_payloads_string.txt b/crates/compiler/test_mono/generated/inspect_derived_tag_two_payloads_string.txt new file mode 100644 index 0000000000..81517e7e3f --- /dev/null +++ b/crates/compiler/test_mono/generated/inspect_derived_tag_two_payloads_string.txt @@ -0,0 +1,178 @@ +procedure #Derived.0 (#Derived.1): + let #Derived_gen.0 : {Str, Str} = CallByName Inspect.30 #Derived.1; + ret #Derived_gen.0; + +procedure #Derived.4 (#Derived.5, #Derived.1): + joinpoint #Derived_gen.5 #Derived_gen.4: + let #Derived_gen.3 : Str = CallByName Inspect.31 #Derived_gen.4 #Derived.5; + ret #Derived_gen.3; + in + let #Derived.2 : Str = StructAtIndex 0 #Derived.1; + let #Derived.3 : Str = StructAtIndex 1 #Derived.1; + let #Derived_gen.7 : Str = "A"; + let #Derived_gen.9 : Str = CallByName Inspect.44 #Derived.2; + let #Derived_gen.10 : Str = CallByName Inspect.44 #Derived.3; + let #Derived_gen.8 : List Str = Array [#Derived_gen.9, #Derived_gen.10]; + let #Derived_gen.6 : [C Str, C Str List Str] = CallByName Inspect.40 #Derived_gen.7 #Derived_gen.8; + jump #Derived_gen.5 #Derived_gen.6; + +procedure Bool.11 (#Attr.2, #Attr.3): + let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3; + ret Bool.23; + +procedure Inspect.203 (Inspect.204, #Attr.12): + let Inspect.346 : Str = UnionAtIndex (Id 0) (Index 0) #Attr.12; + let Inspect.345 : Str = CallByName Inspect.61 Inspect.204 Inspect.346; + ret Inspect.345; + +procedure Inspect.205 (Inspect.206, #Attr.12): + let Inspect.340 : List Str = UnionAtIndex (Id 1) (Index 1) #Attr.12; + let Inspect.339 : Str = UnionAtIndex (Id 1) (Index 0) #Attr.12; + let Inspect.338 : Str = "("; + let Inspect.337 : Str = CallByName Inspect.61 Inspect.206 Inspect.338; + let Inspect.325 : Str = CallByName Inspect.61 Inspect.337 Inspect.339; + let Inspect.321 : Str = CallByName Inspect.207 Inspect.325 Inspect.340; + let Inspect.322 : Str = ")"; + let Inspect.320 : Str = CallByName Inspect.61 Inspect.321 Inspect.322; + ret Inspect.320; + +procedure Inspect.207 (Inspect.208, Inspect.202): + let Inspect.329 : {} = Struct {}; + let Inspect.328 : Str = CallByName List.18 Inspect.202 Inspect.208 Inspect.329; + ret Inspect.328; + +procedure Inspect.209 (Inspect.210, Inspect.211): + let Inspect.336 : Str = " "; + let Inspect.331 : Str = CallByName Inspect.61 Inspect.210 Inspect.336; + let Inspect.330 : Str = CallByName Inspect.212 Inspect.331 Inspect.211; + ret Inspect.330; + +procedure Inspect.212 (Inspect.213, Inspect.211): + let Inspect.334 : Str = CallByName Inspect.31 Inspect.211 Inspect.213; + ret Inspect.334; + +procedure Inspect.249 (Inspect.250, Inspect.248): + let Inspect.355 : Str = "\""; + let Inspect.354 : Str = CallByName Inspect.61 Inspect.250 Inspect.355; + let Inspect.352 : Str = CallByName Inspect.61 Inspect.354 Inspect.248; + let Inspect.353 : Str = "\""; + let Inspect.351 : Str = CallByName Inspect.61 Inspect.352 Inspect.353; + ret Inspect.351; + +procedure Inspect.30 (Inspect.147): + ret Inspect.147; + +procedure Inspect.30 (Inspect.147): + ret Inspect.147; + +procedure Inspect.30 (Inspect.147): + ret Inspect.147; + +procedure Inspect.31 (Inspect.305, Inspect.149): + let Inspect.315 : U8 = GetTagId Inspect.305; + switch Inspect.315: + case 0: + let Inspect.314 : Str = CallByName Inspect.203 Inspect.149 Inspect.305; + ret Inspect.314; + + default: + let Inspect.314 : Str = CallByName Inspect.205 Inspect.149 Inspect.305; + ret Inspect.314; + + +procedure Inspect.31 (Inspect.305, Inspect.149): + let Inspect.335 : Str = CallByName Inspect.249 Inspect.149 Inspect.305; + ret Inspect.335; + +procedure Inspect.35 (Inspect.300): + ret Inspect.300; + +procedure Inspect.36 (Inspect.304): + let Inspect.311 : Str = ""; + ret Inspect.311; + +procedure Inspect.40 (Inspect.201, Inspect.202): + inc Inspect.202; + let Inspect.341 : Int1 = CallByName List.1 Inspect.202; + if Inspect.341 then + dec Inspect.202; + let Inspect.343 : [C Str, C Str List Str] = TagId(0) Inspect.201; + let Inspect.342 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.343; + ret Inspect.342; + else + let Inspect.317 : [C Str, C Str List Str] = TagId(1) Inspect.201 Inspect.202; + let Inspect.316 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.317; + ret Inspect.316; + +procedure Inspect.44 (Inspect.248): + let Inspect.356 : Str = CallByName Inspect.30 Inspect.248; + ret Inspect.356; + +procedure Inspect.5 (Inspect.150): + let Inspect.312 : {Str, Str} = CallByName #Derived.0 Inspect.150; + let Inspect.309 : {} = Struct {}; + let Inspect.308 : Str = CallByName Inspect.36 Inspect.309; + let Inspect.307 : Str = CallByName #Derived.4 Inspect.308 Inspect.312; + ret Inspect.307; + +procedure Inspect.61 (Inspect.303, Inspect.298): + let Inspect.324 : Str = CallByName Str.3 Inspect.303 Inspect.298; + dec Inspect.298; + ret Inspect.324; + +procedure List.1 (List.102): + let List.566 : U64 = CallByName List.6 List.102; + dec List.102; + let List.567 : U64 = 0i64; + let List.565 : Int1 = CallByName Bool.11 List.566 List.567; + ret List.565; + +procedure List.18 (List.154, List.155, List.156): + let List.554 : U64 = 0i64; + let List.555 : U64 = CallByName List.6 List.154; + let List.553 : Str = CallByName List.88 List.154 List.155 List.156 List.554 List.555; + ret List.553; + +procedure List.6 (#Attr.2): + let List.564 : U64 = lowlevel ListLen #Attr.2; + ret List.564; + +procedure List.66 (#Attr.2, #Attr.3): + let List.563 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + ret List.563; + +procedure List.88 (#Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_gen.23): + joinpoint List.556 List.157 List.158 List.159 List.160 List.161: + let List.558 : Int1 = CallByName Num.22 List.160 List.161; + if List.558 then + let List.562 : Str = CallByName List.66 List.157 List.160; + inc List.562; + let List.162 : Str = CallByName Inspect.209 List.158 List.562; + let List.561 : U64 = 1i64; + let List.560 : U64 = CallByName Num.51 List.160 List.561; + jump List.556 List.157 List.162 List.159 List.560 List.161; + else + dec List.157; + ret List.158; + in + jump List.556 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23; + +procedure Num.22 (#Attr.2, #Attr.3): + let Num.292 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; + ret Num.292; + +procedure Num.51 (#Attr.2, #Attr.3): + let Num.291 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3; + ret Num.291; + +procedure Str.3 (#Attr.2, #Attr.3): + let Str.292 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.292; + +procedure Test.0 (): + let Test.6 : Str = "foo"; + let Test.5 : Str = "foo"; + let Test.1 : {Str, Str} = Struct {Test.5, Test.6}; + let Test.4 : Str = CallByName Inspect.5 Test.1; + let Test.3 : Str = CallByName Inspect.35 Test.4; + ret Test.3; diff --git a/crates/compiler/test_mono/generated/multiline_record_pattern.txt b/crates/compiler/test_mono/generated/multiline_record_pattern.txt new file mode 100644 index 0000000000..2e73bc5486 --- /dev/null +++ b/crates/compiler/test_mono/generated/multiline_record_pattern.txt @@ -0,0 +1,15 @@ +procedure Num.19 (#Attr.2, #Attr.3): + let Num.292 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Num.292; + +procedure Test.0 (): + let Test.7 : I64 = 1i64; + let Test.8 : I64 = 2i64; + let Test.9 : I64 = 3i64; + let Test.1 : {I64, I64, I64} = Struct {Test.7, Test.8, Test.9}; + let Test.2 : I64 = StructAtIndex 0 Test.1; + let Test.3 : I64 = StructAtIndex 1 Test.1; + let Test.4 : I64 = StructAtIndex 2 Test.1; + let Test.6 : I64 = CallByName Num.19 Test.2 Test.3; + let Test.5 : I64 = CallByName Num.19 Test.6 Test.4; + ret Test.5; diff --git a/crates/compiler/test_mono/generated/nested_optional_field_with_binary_op.txt b/crates/compiler/test_mono/generated/nested_optional_field_with_binary_op.txt new file mode 100644 index 0000000000..404f08f3d8 --- /dev/null +++ b/crates/compiler/test_mono/generated/nested_optional_field_with_binary_op.txt @@ -0,0 +1,23 @@ +procedure Num.19 (#Attr.2, #Attr.3): + let Num.291 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Num.291; + +procedure Test.0 (): + let Test.17 : {} = Struct {}; + let Test.15 : List {} = Array [Test.17]; + let Test.16 : Str = "foo"; + let Test.14 : {List {}, Str} = Struct {Test.15, Test.16}; + let Test.10 : List {} = StructAtIndex 0 Test.14; + dec Test.16; + let Test.11 : U64 = lowlevel ListLen Test.10; + dec Test.10; + let Test.12 : U64 = 1i64; + let Test.13 : Int1 = lowlevel Eq Test.11 Test.12; + if Test.13 then + let Test.5 : I64 = 1i64; + let Test.6 : I64 = 1i64; + let Test.2 : I64 = CallByName Num.19 Test.5 Test.6; + ret Test.2; + else + let Test.7 : I64 = 0i64; + ret Test.7; diff --git a/crates/compiler/test_mono/generated/optional_field_with_binary_op.txt b/crates/compiler/test_mono/generated/optional_field_with_binary_op.txt new file mode 100644 index 0000000000..d0bfce4f16 --- /dev/null +++ b/crates/compiler/test_mono/generated/optional_field_with_binary_op.txt @@ -0,0 +1,10 @@ +procedure Num.19 (#Attr.2, #Attr.3): + let Num.291 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Num.291; + +procedure Test.0 (): + let Test.5 : {} = Struct {}; + let Test.3 : I64 = 1i64; + let Test.4 : I64 = 1i64; + let Test.1 : I64 = CallByName Num.19 Test.3 Test.4; + ret Test.1; diff --git a/crates/compiler/test_mono/src/tests.rs b/crates/compiler/test_mono/src/tests.rs index ae2a28ec5b..091e20565e 100644 --- a/crates/compiler/test_mono/src/tests.rs +++ b/crates/compiler/test_mono/src/tests.rs @@ -893,6 +893,37 @@ fn optional_when() { "# } +#[mono_test] +fn optional_field_with_binary_op() { + r#" + { bar ? 1 + 1 } = {} + bar + "# +} + +#[mono_test] +fn nested_optional_field_with_binary_op() { + r#" + when { x: ([{}], "foo") } is + { x: ([{ bar ? 1 + 1 }], _) } -> bar + _ -> 0 + "# +} + +#[mono_test] +fn multiline_record_pattern() { + r#" + x = { a: 1, b: 2, c: 3 } + { + a, + b, + c, + } = x + + a + b + c + "# +} + #[mono_test] fn nested_pattern_match() { r#" @@ -3258,3 +3289,150 @@ fn non_nullable_unwrapped_instead_of_nullable_wrapped() { "# ) } + +#[mono_test] +#[ignore = "Hits an unimplemented for abilities, not sure why..."] +fn inspect_custom_type() { + indoc!( + r#" + app "test" + imports [] + provides [main] to "./platform" + + HelloWorld := {} implements [Inspect { toInspector: myToInspector }] + + myToInspector : HelloWorld -> Inspector f where f implements InspectFormatter + myToInspector = \@HellowWorld {} -> + fmt <- Inspect.custom + Inspect.apply (Inspect.str "Hello, World!\n") fmt + + main = + Inspect.inspect (@HelloWorld {}) + "# + ) +} + +#[mono_test] +fn inspect_derived_string() { + indoc!( + r#" + app "test" + imports [] + provides [main] to "./platform" + + main = Inspect.inspect "abc" |> Inspect.toDbgStr + "# + ) +} + +#[mono_test] +fn inspect_derived_record() { + indoc!( + r#" + app "test" + imports [] + provides [main] to "./platform" + + main = Inspect.inspect {a: 7, b: 3dec} |> Inspect.toDbgStr + "# + ) +} +#[mono_test] +fn inspect_derived_record_one_field_string() { + indoc!( + r#" + app "test" + imports [] + provides [main] to "./platform" + + main = Inspect.inspect {a: "foo"} |> Inspect.toDbgStr + "# + ) +} + +#[mono_test] +fn inspect_derived_record_two_field_strings() { + indoc!( + r#" + app "test" + imports [] + provides [main] to "./platform" + + main = Inspect.inspect {a: "foo", b: "bar"} |> Inspect.toDbgStr + "# + ) +} + +#[mono_test] +fn inspect_derived_nested_record_string() { + indoc!( + r#" + app "test" + imports [] + provides [main] to "./platform" + + main = Inspect.inspect {a: {b: "bar"}} |> Inspect.toDbgStr + "# + ) +} + +#[mono_test] +fn inspect_derived_tag_one_field_string() { + indoc!( + r#" + app "test" + imports [] + provides [main] to "./platform" + + main = + x : [A Str] + x = A "foo" + Inspect.inspect x |> Inspect.toDbgStr + "# + ) +} + +#[mono_test] +fn inspect_derived_tag_two_payloads_string() { + indoc!( + r#" + app "test" + imports [] + provides [main] to "./platform" + + main = + x : [A Str Str] + x = A "foo" "foo" + Inspect.inspect x |> Inspect.toDbgStr + "# + ) +} + +#[mono_test] +fn inspect_derived_list() { + indoc!( + r#" + app "test" + imports [] + provides [main] to "./platform" + + main = Inspect.inspect [1, 2, 3] |> Inspect.toDbgStr + "# + ) +} + +#[mono_test(large_stack = "true")] +fn inspect_derived_dict() { + indoc!( + r#" + app "test" + imports [] + provides [main] to "./platform" + + main = + Dict.fromList [("a", 1), ("b", 2)] + |> Inspect.inspect + |> Inspect.toDbgStr + "# + ) +} diff --git a/crates/compiler/test_syntax/tests/snapshots/pass/newline_in_packages.full.formatted.roc b/crates/compiler/test_syntax/tests/snapshots/pass/newline_in_packages.full.formatted.roc index cba8a15175..156b704272 100644 --- a/crates/compiler/test_syntax/tests/snapshots/pass/newline_in_packages.full.formatted.roc +++ b/crates/compiler/test_syntax/tests/snapshots/pass/newline_in_packages.full.formatted.roc @@ -1,7 +1,7 @@ app "hello" packages { pf: - "https://github.com/roc-lang/basic-cli/releases/download/0.5.0/Cufzl36_SnJ4QbOoEmiJ5dIpUxBvdB3NEySvuH82Wio.tar.br", + "https://github.com/roc-lang/basic-cli/releases/download/0.7.0/bkGby8jb0tmZYsy2hg1E_B2QrCgcSTxdUlHtETwm5m4.tar.br", } imports [pf.Stdout] provides [main] to pf diff --git a/crates/compiler/test_syntax/tests/snapshots/pass/newline_in_packages.full.result-ast b/crates/compiler/test_syntax/tests/snapshots/pass/newline_in_packages.full.result-ast index 975efca1c3..d06a77cd4c 100644 --- a/crates/compiler/test_syntax/tests/snapshots/pass/newline_in_packages.full.result-ast +++ b/crates/compiler/test_syntax/tests/snapshots/pass/newline_in_packages.full.result-ast @@ -24,7 +24,7 @@ Full { Newline, ], package_name: @31-145 PackageName( - "https://github.com/roc-lang/basic-cli/releases/download/0.5.0/Cufzl36_SnJ4QbOoEmiJ5dIpUxBvdB3NEySvuH82Wio.tar.br", + "https://github.com/roc-lang/basic-cli/releases/download/0.7.0/bkGby8jb0tmZYsy2hg1E_B2QrCgcSTxdUlHtETwm5m4.tar.br", ), }, [ diff --git a/crates/compiler/test_syntax/tests/snapshots/pass/newline_in_packages.full.roc b/crates/compiler/test_syntax/tests/snapshots/pass/newline_in_packages.full.roc index 58dcb520fc..3fb360020d 100644 --- a/crates/compiler/test_syntax/tests/snapshots/pass/newline_in_packages.full.roc +++ b/crates/compiler/test_syntax/tests/snapshots/pass/newline_in_packages.full.roc @@ -1,6 +1,6 @@ app "hello" packages { pf: -"https://github.com/roc-lang/basic-cli/releases/download/0.5.0/Cufzl36_SnJ4QbOoEmiJ5dIpUxBvdB3NEySvuH82Wio.tar.br" +"https://github.com/roc-lang/basic-cli/releases/download/0.7.0/bkGby8jb0tmZYsy2hg1E_B2QrCgcSTxdUlHtETwm5m4.tar.br" } imports [pf.Stdout] provides [main] to pf diff --git a/crates/compiler/types/src/subs.rs b/crates/compiler/types/src/subs.rs index 8a62e63650..7eae9468c0 100644 --- a/crates/compiler/types/src/subs.rs +++ b/crates/compiler/types/src/subs.rs @@ -1726,6 +1726,8 @@ impl Subs { pub const AB_HASH: SubsSlice = SubsSlice::new(3, 1); #[rustfmt::skip] pub const AB_EQ: SubsSlice = SubsSlice::new(4, 1); + #[rustfmt::skip] + pub const AB_INSPECT: SubsSlice = SubsSlice::new(5, 1); // END INIT-SymbolSubsSlice pub fn new() -> Self { @@ -1746,7 +1748,7 @@ impl Subs { tag_names.push(TagName("OutOfBounds".into())); // END INIT-TagNames - // IFTTT INIT-SymbolNames + // IFTTT INIT-SymbolSubsSlice let mut symbol_names = Vec::with_capacity(32); symbol_names.push(Symbol::ENCODE_ENCODING); @@ -1754,7 +1756,8 @@ impl Subs { symbol_names.push(Symbol::HASH_HASHER); symbol_names.push(Symbol::HASH_HASH_ABILITY); symbol_names.push(Symbol::BOOL_EQ); - // END INIT-SymbolNames + symbol_names.push(Symbol::INSPECT_INSPECT_ABILITY); + // END INIT-SymbolSubsSlice // IFTTT INIT-VariableSubsSlice let variables = vec![Variable::STR]; diff --git a/crates/compiler/uitest/tests/ability/specialize/inspect/bool.txt b/crates/compiler/uitest/tests/ability/specialize/inspect/bool.txt new file mode 100644 index 0000000000..50661600b3 --- /dev/null +++ b/crates/compiler/uitest/tests/ability/specialize/inspect/bool.txt @@ -0,0 +1,4 @@ +app "test" provides [main] to "./platform" + +main = Inspect.toInspector Bool.true |> Inspect.apply (Inspect.init {}) |> Inspect.toDbgStr +# ^^^^^^^^^^^^^^^^^^^ Inspect#Inspect.toInspector(32): Bool -[[Inspect.dbgBool(43)]]-> Inspector DbgFormatter diff --git a/crates/compiler/uitest/tests/ability/specialize/inspect/dec.txt b/crates/compiler/uitest/tests/ability/specialize/inspect/dec.txt new file mode 100644 index 0000000000..839ebc1cba --- /dev/null +++ b/crates/compiler/uitest/tests/ability/specialize/inspect/dec.txt @@ -0,0 +1,4 @@ +app "test" provides [main] to "./platform" + +main = Inspect.toInspector 7dec |> Inspect.apply (Inspect.init {}) |> Inspect.toDbgStr +# ^^^^^^^^^^^^^^^^^^^ Inspect#Inspect.toInspector(32): Dec -[[Inspect.dbgDec(60)]]-> Inspector DbgFormatter diff --git a/crates/compiler/uitest/tests/ability/specialize/inspect/non_implementing_opaque.txt b/crates/compiler/uitest/tests/ability/specialize/inspect/non_implementing_opaque.txt new file mode 100644 index 0000000000..d27232f296 --- /dev/null +++ b/crates/compiler/uitest/tests/ability/specialize/inspect/non_implementing_opaque.txt @@ -0,0 +1,6 @@ +app "test" provides [main] to "./platform" + +Op := {} + +main = Inspect.toInspector (@Op {}) |> Inspect.apply (Inspect.init {}) |> Inspect.toDbgStr +# ^^^^^^^^^^^^^^^^^^^ Inspect#Inspect.toInspector(32): Op -[[Inspect.dbgOpaque(45)]]-> Inspector DbgFormatter diff --git a/crates/compiler/uitest/tests/ability/specialize/inspect/opaque_automatic.txt b/crates/compiler/uitest/tests/ability/specialize/inspect/opaque_automatic.txt new file mode 100644 index 0000000000..ffe19f6da3 --- /dev/null +++ b/crates/compiler/uitest/tests/ability/specialize/inspect/opaque_automatic.txt @@ -0,0 +1,54 @@ +# +emit:mono +app "test" provides [main] to "./platform" + +Op := {} + +main = + dbg (@Op {}) + 1 + +# -emit:mono +procedure Inspect.251 (Inspect.252): + let Inspect.317 : Str = ""; + let Inspect.316 : Str = CallByName Inspect.61 Inspect.252 Inspect.317; + ret Inspect.316; + +procedure Inspect.30 (Inspect.147): + ret Inspect.147; + +procedure Inspect.35 (Inspect.300): + ret Inspect.300; + +procedure Inspect.36 (Inspect.304): + let Inspect.311 : Str = ""; + ret Inspect.311; + +procedure Inspect.45 (Inspect.302): + let Inspect.314 : {} = Struct {}; + let Inspect.313 : {} = CallByName Inspect.30 Inspect.314; + ret Inspect.313; + +procedure Inspect.5 (Inspect.150): + let Inspect.312 : {} = CallByName Inspect.45 Inspect.150; + let Inspect.309 : {} = Struct {}; + let Inspect.308 : Str = CallByName Inspect.36 Inspect.309; + let Inspect.307 : Str = CallByName Inspect.251 Inspect.308; + ret Inspect.307; + +procedure Inspect.61 (Inspect.303, Inspect.298): + let Inspect.319 : Str = CallByName Str.3 Inspect.303 Inspect.298; + dec Inspect.298; + ret Inspect.319; + +procedure Str.3 (#Attr.2, #Attr.3): + let Str.292 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.292; + +procedure Test.0 (): + let Test.5 : {} = Struct {}; + let Test.4 : Str = CallByName Inspect.5 Test.5; + let Test.2 : Str = CallByName Inspect.35 Test.4; + dbg Test.2; + dec Test.2; + let Test.3 : I64 = 1i64; + ret Test.3; diff --git a/crates/compiler/uitest/tests/ability/specialize/inspect/opaque_automatic_late.txt b/crates/compiler/uitest/tests/ability/specialize/inspect/opaque_automatic_late.txt new file mode 100644 index 0000000000..198b0d15dc --- /dev/null +++ b/crates/compiler/uitest/tests/ability/specialize/inspect/opaque_automatic_late.txt @@ -0,0 +1,61 @@ +# +emit:mono +app "test" provides [main] to "./platform" + +Op := {} + +late = \a -> + dbg a + 1 + +main = + late (@Op {}) + +# -emit:mono +procedure Inspect.251 (Inspect.252): + let Inspect.317 : Str = ""; + let Inspect.316 : Str = CallByName Inspect.61 Inspect.252 Inspect.317; + ret Inspect.316; + +procedure Inspect.30 (Inspect.147): + ret Inspect.147; + +procedure Inspect.35 (Inspect.300): + ret Inspect.300; + +procedure Inspect.36 (Inspect.304): + let Inspect.311 : Str = ""; + ret Inspect.311; + +procedure Inspect.45 (Inspect.302): + let Inspect.314 : {} = Struct {}; + let Inspect.313 : {} = CallByName Inspect.30 Inspect.314; + ret Inspect.313; + +procedure Inspect.5 (Inspect.150): + let Inspect.312 : {} = CallByName Inspect.45 Inspect.150; + let Inspect.309 : {} = Struct {}; + let Inspect.308 : Str = CallByName Inspect.36 Inspect.309; + let Inspect.307 : Str = CallByName Inspect.251 Inspect.308; + ret Inspect.307; + +procedure Inspect.61 (Inspect.303, Inspect.298): + let Inspect.319 : Str = CallByName Str.3 Inspect.303 Inspect.298; + dec Inspect.298; + ret Inspect.319; + +procedure Str.3 (#Attr.2, #Attr.3): + let Str.292 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.292; + +procedure Test.2 (Test.3): + let Test.8 : Str = CallByName Inspect.5 Test.3; + let Test.4 : Str = CallByName Inspect.35 Test.8; + dbg Test.4; + dec Test.4; + let Test.7 : I64 = 1i64; + ret Test.7; + +procedure Test.0 (): + let Test.6 : {} = Struct {}; + let Test.5 : I64 = CallByName Test.2 Test.6; + ret Test.5; diff --git a/crates/compiler/uitest/tests/ability/specialize/inspect/opaque_custom_impl.txt b/crates/compiler/uitest/tests/ability/specialize/inspect/opaque_custom_impl.txt new file mode 100644 index 0000000000..bdb8f45893 --- /dev/null +++ b/crates/compiler/uitest/tests/ability/specialize/inspect/opaque_custom_impl.txt @@ -0,0 +1,9 @@ +app "test" provides [main] to "./platform" + +Op := U8 implements [Inspect { toInspector: myToInspector }] + +myToInspector : Op -> Inspector f where f implements InspectFormatter +myToInspector = \@Op num -> Inspect.u8 num + +main = Inspect.toInspector (@Op 1u8) |> Inspect.apply (Inspect.init {}) |> Inspect.toDbgStr +# ^^^^^^^^^^^^^^^^^^^ Op#Inspect.toInspector(2): Op -[[myToInspector(2)]]-> Inspector DbgFormatter diff --git a/crates/compiler/uitest/tests/ability/specialize/inspect/opaque_derived.txt b/crates/compiler/uitest/tests/ability/specialize/inspect/opaque_derived.txt new file mode 100644 index 0000000000..1e3569a4fd --- /dev/null +++ b/crates/compiler/uitest/tests/ability/specialize/inspect/opaque_derived.txt @@ -0,0 +1,6 @@ +app "test" provides [main] to "./platform" + +Op := U8 implements [Inspect] + +main = Inspect.toInspector (@Op 1u8) |> Inspect.apply (Inspect.init {}) |> Inspect.toDbgStr +# ^^^^^^^^^^^^^^^^^^^ Op#Inspect.toInspector(3): Op -[[#Op_toInspector(3)]]-> Inspector DbgFormatter diff --git a/crates/compiler/uitest/tests/ability/specialize/inspect/ranged_num.txt b/crates/compiler/uitest/tests/ability/specialize/inspect/ranged_num.txt new file mode 100644 index 0000000000..e0112f852b --- /dev/null +++ b/crates/compiler/uitest/tests/ability/specialize/inspect/ranged_num.txt @@ -0,0 +1,4 @@ +app "test" provides [main] to "./platform" + +main = Inspect.toInspector 7 |> Inspect.apply (Inspect.init {}) |> Inspect.toDbgStr +# ^^^^^^^^^^^^^^^^^^^ Inspect#Inspect.toInspector(32): I64 -[[Inspect.dbgI64(54)]]-> Inspector DbgFormatter diff --git a/crates/compiler/uitest/tests/ability/specialize/inspect/record.txt b/crates/compiler/uitest/tests/ability/specialize/inspect/record.txt new file mode 100644 index 0000000000..0094d164f3 --- /dev/null +++ b/crates/compiler/uitest/tests/ability/specialize/inspect/record.txt @@ -0,0 +1,4 @@ +app "test" provides [main] to "./platform" + +main = Inspect.toInspector { a: "" } |> Inspect.apply (Inspect.init {}) |> Inspect.toDbgStr +# ^^^^^^^^^^^^^^^^^^^ Inspect#Inspect.toInspector(32): { a : Str } -[[#Derived.toInspector_{a}(0)]]-> Inspector DbgFormatter diff --git a/crates/compiler/uitest/tests/ability/specialize/inspect/record_with_nested_custom_impl.txt b/crates/compiler/uitest/tests/ability/specialize/inspect/record_with_nested_custom_impl.txt new file mode 100644 index 0000000000..44f741f979 --- /dev/null +++ b/crates/compiler/uitest/tests/ability/specialize/inspect/record_with_nested_custom_impl.txt @@ -0,0 +1,9 @@ +app "test" provides [main] to "./platform" + +Op := U8 implements [Inspect { toInspector: myToInspector }] + +myToInspector : Op -> Inspector f where f implements InspectFormatter +myToInspector = \@Op num -> Inspect.u8 num + +main = Inspect.toInspector { op: @Op 1u8 } |> Inspect.apply (Inspect.init {}) |> Inspect.toDbgStr +# ^^^^^^^^^^^^^^^^^^^ Inspect#Inspect.toInspector(32): { op : Op } -[[#Derived.toInspector_{op}(0)]]-> Inspector DbgFormatter diff --git a/crates/compiler/uitest/tests/ability/specialize/inspect/u8.txt b/crates/compiler/uitest/tests/ability/specialize/inspect/u8.txt new file mode 100644 index 0000000000..59b9a84c1c --- /dev/null +++ b/crates/compiler/uitest/tests/ability/specialize/inspect/u8.txt @@ -0,0 +1,4 @@ +app "test" provides [main] to "./platform" + +main = Inspect.toInspector 7u8 |> Inspect.apply (Inspect.init {}) |> Inspect.toDbgStr +# ^^^^^^^^^^^^^^^^^^^ Inspect#Inspect.toInspector(32): U8 -[[Inspect.dbgU8(47)]]-> Inspector DbgFormatter diff --git a/crates/compiler/uitest/tests/recursion/generalization_among_large_recursive_group.txt b/crates/compiler/uitest/tests/recursion/generalization_among_large_recursive_group.txt index 6238bd9ad1..f1f87be404 100644 --- a/crates/compiler/uitest/tests/recursion/generalization_among_large_recursive_group.txt +++ b/crates/compiler/uitest/tests/recursion/generalization_among_large_recursive_group.txt @@ -3,22 +3,22 @@ app "test" provides [main] to "./platform" f = \{} -> -#^{-1} <1874><117>{} -<120>[[f(1)]]-> <116>[Ok <1882>{}]<80>* +#^{-1} <2858><117>{} -<120>[[f(1)]]-> <116>[Ok <2866>{}]<80>* when g {} is -# ^ <1864><1882>{} -<1872>[[g(2)]]-> <72>[Ok <1882>{}]<102>* +# ^ <2848><2866>{} -<2856>[[g(2)]]-> <72>[Ok <2866>{}]<102>* _ -> Ok {} g = \{} -> -#^{-1} <1864><1882>{} -<1872>[[g(2)]]-> <72>[Ok <1882>{}]<102>* +#^{-1} <2848><2866>{} -<2856>[[g(2)]]-> <72>[Ok <2866>{}]<102>* when h {} is -# ^ <1869><1882>{} -<1877>[[h(3)]]-> <94>[Ok <1882>{}]<124>* +# ^ <2853><2866>{} -<2861>[[h(3)]]-> <94>[Ok <2866>{}]<124>* _ -> Ok {} h = \{} -> -#^{-1} <1869><1882>{} -<1877>[[h(3)]]-> <94>[Ok <1882>{}]<124>* +#^{-1} <2853><2866>{} -<2861>[[h(3)]]-> <94>[Ok <2866>{}]<124>* when f {} is -# ^ <1874><117>{} -<120>[[f(1)]]-> <116>[Ok <1882>{}]<80>* +# ^ <2858><117>{} -<120>[[f(1)]]-> <116>[Ok <2866>{}]<80>* _ -> Ok {} main = f {} -# ^ <1884><133>{} -<136>[[f(1)]]-> <138>[Ok <1882>{}]<1883>w_a +# ^ <2868><133>{} -<136>[[f(1)]]-> <138>[Ok <2866>{}]<2867>w_a diff --git a/crates/compiler/uitest/tests/solve/constrain_dbg_flex_var.txt b/crates/compiler/uitest/tests/solve/constrain_dbg_flex_var.txt index 7648aac6da..85f1017008 100644 --- a/crates/compiler/uitest/tests/solve/constrain_dbg_flex_var.txt +++ b/crates/compiler/uitest/tests/solve/constrain_dbg_flex_var.txt @@ -1,7 +1,7 @@ app "test" provides [main] to "./platform" polyDbg = \x -> -#^^^^^^^{-1} a -[[polyDbg(1)]]-> a +#^^^^^^^{-1} val -[[polyDbg(1)]]-> val where val implements Inspect dbg x x diff --git a/crates/glue/tests/fixture-templates/rust/host.c b/crates/glue/tests/fixture-templates/rust/host.c index 3914d3f6ee..7d0fec6812 100644 --- a/crates/glue/tests/fixture-templates/rust/host.c +++ b/crates/glue/tests/fixture-templates/rust/host.c @@ -9,6 +9,9 @@ // So you probably don't want to modify it by hand! Instead, modify the // file with the same name in the fixture-templates/ directory. -extern int rust_main(); +extern void rust_main(); -int main() { return rust_main(); } +int main() { + rust_main(); + return 0; +} diff --git a/crates/glue/tests/fixture-templates/rust/src/main.rs b/crates/glue/tests/fixture-templates/rust/src/main.rs index 0765384f29..57692d3619 100644 --- a/crates/glue/tests/fixture-templates/rust/src/main.rs +++ b/crates/glue/tests/fixture-templates/rust/src/main.rs @@ -1,3 +1,3 @@ fn main() { - std::process::exit(host::rust_main() as _); + host::rust_main(); } diff --git a/crates/glue/tests/fixtures/advanced-recursive-union/src/lib.rs b/crates/glue/tests/fixtures/advanced-recursive-union/src/lib.rs index b3f6b9bf8d..9fa24c4665 100644 --- a/crates/glue/tests/fixtures/advanced-recursive-union/src/lib.rs +++ b/crates/glue/tests/fixtures/advanced-recursive-union/src/lib.rs @@ -1,9 +1,10 @@ use roc_app; use indoc::indoc; +use roc_std::RocStr; #[no_mangle] -pub extern "C" fn rust_main() -> i32 { +pub extern "C" fn rust_main() { use std::cmp::Ordering; use std::collections::hash_set::HashSet; @@ -33,9 +34,6 @@ pub extern "C" fn rust_main() -> i32 { set.insert(tag_union); assert_eq!(set.len(), 1); - - // Exit code - 0 } // Externs required by roc_std and by the Roc app @@ -65,16 +63,22 @@ pub unsafe extern "C" fn roc_dealloc(c_ptr: *mut c_void, _alignment: u32) { } #[no_mangle] -pub unsafe extern "C" fn roc_panic(c_ptr: *mut c_void, tag_id: u32) { +pub unsafe extern "C" fn roc_panic(msg: *mut RocStr, tag_id: u32) { match tag_id { 0 => { - let slice = CStr::from_ptr(c_ptr as *const c_char); - let string = slice.to_str().unwrap(); - eprintln!("Roc hit a panic: {}", string); - std::process::exit(1); + eprintln!("Roc standard library hit a panic: {}", &*msg); } - _ => todo!(), + 1 => { + eprintln!("Application hit a panic: {}", &*msg); + } + _ => unreachable!(), } + std::process::exit(1); +} + +#[no_mangle] +pub unsafe extern "C" fn roc_dbg(loc: *mut RocStr, msg: *mut RocStr) { + eprintln!("[{}] {}", &*loc, &*msg); } #[no_mangle] diff --git a/crates/glue/tests/fixtures/arguments/src/lib.rs b/crates/glue/tests/fixtures/arguments/src/lib.rs index 9b5d52ac9b..4f0db9af41 100644 --- a/crates/glue/tests/fixtures/arguments/src/lib.rs +++ b/crates/glue/tests/fixtures/arguments/src/lib.rs @@ -1,13 +1,11 @@ use roc_app; +use roc_std::RocStr; #[no_mangle] -pub extern "C" fn rust_main() -> i32 { +pub extern "C" fn rust_main() { let answer = roc_app::mainForHost(42i64); println!("Answer was: {:?}", answer); // Debug - - // Exit code - 0 } // Externs required by roc_std and by the Roc app @@ -37,16 +35,22 @@ pub unsafe extern "C" fn roc_dealloc(c_ptr: *mut c_void, _alignment: u32) { } #[no_mangle] -pub unsafe extern "C" fn roc_panic(c_ptr: *mut c_void, tag_id: u32) { +pub unsafe extern "C" fn roc_panic(msg: *mut RocStr, tag_id: u32) { match tag_id { 0 => { - let slice = CStr::from_ptr(c_ptr as *const c_char); - let string = slice.to_str().unwrap(); - eprintln!("Roc hit a panic: {}", string); - std::process::exit(1); + eprintln!("Roc standard library hit a panic: {}", &*msg); } - _ => todo!(), + 1 => { + eprintln!("Application hit a panic: {}", &*msg); + } + _ => unreachable!(), } + std::process::exit(1); +} + +#[no_mangle] +pub unsafe extern "C" fn roc_dbg(loc: *mut RocStr, msg: *mut RocStr) { + eprintln!("[{}] {}", &*loc, &*msg); } #[no_mangle] diff --git a/crates/glue/tests/fixtures/basic-record/src/lib.rs b/crates/glue/tests/fixtures/basic-record/src/lib.rs index d5cc2ea1e0..cd50e9b76b 100644 --- a/crates/glue/tests/fixtures/basic-record/src/lib.rs +++ b/crates/glue/tests/fixtures/basic-record/src/lib.rs @@ -1,7 +1,8 @@ use roc_app; +use roc_std::RocStr; #[no_mangle] -pub extern "C" fn rust_main() -> i32 { +pub extern "C" fn rust_main() { use std::cmp::Ordering; use std::collections::hash_set::HashSet; @@ -27,9 +28,6 @@ pub extern "C" fn rust_main() -> i32 { assert_eq!(set.len(), 1); println!("Record was: {:?}", record); // Debug - - // Exit code - 0 } // Externs required by roc_std and by the Roc app @@ -59,16 +57,22 @@ pub unsafe extern "C" fn roc_dealloc(c_ptr: *mut c_void, _alignment: u32) { } #[no_mangle] -pub unsafe extern "C" fn roc_panic(c_ptr: *mut c_void, tag_id: u32) { +pub unsafe extern "C" fn roc_panic(msg: *mut RocStr, tag_id: u32) { match tag_id { 0 => { - let slice = CStr::from_ptr(c_ptr as *const c_char); - let string = slice.to_str().unwrap(); - eprintln!("Roc hit a panic: {}", string); - std::process::exit(1); + eprintln!("Roc standard library hit a panic: {}", &*msg); } - _ => todo!(), + 1 => { + eprintln!("Application hit a panic: {}", &*msg); + } + _ => unreachable!(), } + std::process::exit(1); +} + +#[no_mangle] +pub unsafe extern "C" fn roc_dbg(loc: *mut RocStr, msg: *mut RocStr) { + eprintln!("[{}] {}", &*loc, &*msg); } #[no_mangle] diff --git a/crates/glue/tests/fixtures/basic-recursive-union/src/lib.rs b/crates/glue/tests/fixtures/basic-recursive-union/src/lib.rs index decab79319..b104cb5a29 100644 --- a/crates/glue/tests/fixtures/basic-recursive-union/src/lib.rs +++ b/crates/glue/tests/fixtures/basic-recursive-union/src/lib.rs @@ -1,8 +1,9 @@ use indoc::indoc; use roc_app::{self, Expr}; +use roc_std::RocStr; #[no_mangle] -pub extern "C" fn rust_main() -> i32 { +pub extern "C" fn rust_main() { use std::cmp::Ordering; use std::collections::hash_set::HashSet; @@ -38,9 +39,6 @@ pub extern "C" fn rust_main() -> i32 { set.insert(tag_union); assert_eq!(set.len(), 1); - - // Exit code - 0 } // Externs required by roc_std and by the Roc app @@ -70,16 +68,22 @@ pub unsafe extern "C" fn roc_dealloc(c_ptr: *mut c_void, _alignment: u32) { } #[no_mangle] -pub unsafe extern "C" fn roc_panic(c_ptr: *mut c_void, tag_id: u32) { +pub unsafe extern "C" fn roc_panic(msg: *mut RocStr, tag_id: u32) { match tag_id { 0 => { - let slice = CStr::from_ptr(c_ptr as *const c_char); - let string = slice.to_str().unwrap(); - eprintln!("Roc hit a panic: {}", string); - std::process::exit(1); + eprintln!("Roc standard library hit a panic: {}", &*msg); } - _ => todo!(), + 1 => { + eprintln!("Application hit a panic: {}", &*msg); + } + _ => unreachable!(), } + std::process::exit(1); +} + +#[no_mangle] +pub unsafe extern "C" fn roc_dbg(loc: *mut RocStr, msg: *mut RocStr) { + eprintln!("[{}] {}", &*loc, &*msg); } #[no_mangle] diff --git a/crates/glue/tests/fixtures/closures/src/lib.rs b/crates/glue/tests/fixtures/closures/src/lib.rs index a1f99f54b8..9179f6d02c 100644 --- a/crates/glue/tests/fixtures/closures/src/lib.rs +++ b/crates/glue/tests/fixtures/closures/src/lib.rs @@ -1,13 +1,11 @@ use roc_app; +use roc_std::RocStr; #[no_mangle] -pub extern "C" fn rust_main() -> i32 { +pub extern "C" fn rust_main() { let closure = roc_app::mainForHost(42i64); println!("Answer was: {:?}", closure.force_thunk()); // Debug - - // Exit code - 0 } // Externs required by roc_std and by the Roc app @@ -37,16 +35,22 @@ pub unsafe extern "C" fn roc_dealloc(c_ptr: *mut c_void, _alignment: u32) { } #[no_mangle] -pub unsafe extern "C" fn roc_panic(c_ptr: *mut c_void, tag_id: u32) { +pub unsafe extern "C" fn roc_panic(msg: *mut RocStr, tag_id: u32) { match tag_id { 0 => { - let slice = CStr::from_ptr(c_ptr as *const c_char); - let string = slice.to_str().unwrap(); - eprintln!("Roc hit a panic: {}", string); - std::process::exit(1); + eprintln!("Roc standard library hit a panic: {}", &*msg); } - _ => todo!(), + 1 => { + eprintln!("Application hit a panic: {}", &*msg); + } + _ => unreachable!(), } + std::process::exit(1); +} + +#[no_mangle] +pub unsafe extern "C" fn roc_dbg(loc: *mut RocStr, msg: *mut RocStr) { + eprintln!("[{}] {}", &*loc, &*msg); } #[no_mangle] diff --git a/crates/glue/tests/fixtures/enumeration/src/lib.rs b/crates/glue/tests/fixtures/enumeration/src/lib.rs index 59704b6be9..ebe1a45e41 100644 --- a/crates/glue/tests/fixtures/enumeration/src/lib.rs +++ b/crates/glue/tests/fixtures/enumeration/src/lib.rs @@ -1,7 +1,8 @@ use roc_app; +use roc_std::RocStr; #[no_mangle] -pub extern "C" fn rust_main() -> i32 { +pub extern "C" fn rust_main() { use std::cmp::Ordering; use std::collections::hash_set::HashSet; @@ -31,9 +32,6 @@ pub extern "C" fn rust_main() -> i32 { roc_app::MyEnum::Bar, roc_app::MyEnum::Baz, ); // Debug - - // Exit code - 0 } // Externs required by roc_std and by the Roc app @@ -63,16 +61,22 @@ pub unsafe extern "C" fn roc_dealloc(c_ptr: *mut c_void, _alignment: u32) { } #[no_mangle] -pub unsafe extern "C" fn roc_panic(c_ptr: *mut c_void, tag_id: u32) { +pub unsafe extern "C" fn roc_panic(msg: *mut RocStr, tag_id: u32) { match tag_id { 0 => { - let slice = CStr::from_ptr(c_ptr as *const c_char); - let string = slice.to_str().unwrap(); - eprintln!("Roc hit a panic: {}", string); - std::process::exit(1); + eprintln!("Roc standard library hit a panic: {}", &*msg); } - _ => todo!(), + 1 => { + eprintln!("Application hit a panic: {}", &*msg); + } + _ => unreachable!(), } + std::process::exit(1); +} + +#[no_mangle] +pub unsafe extern "C" fn roc_dbg(loc: *mut RocStr, msg: *mut RocStr) { + eprintln!("[{}] {}", &*loc, &*msg); } #[no_mangle] diff --git a/crates/glue/tests/fixtures/list-recursive-union/src/lib.rs b/crates/glue/tests/fixtures/list-recursive-union/src/lib.rs index 0b598c19d9..7dd435fa73 100644 --- a/crates/glue/tests/fixtures/list-recursive-union/src/lib.rs +++ b/crates/glue/tests/fixtures/list-recursive-union/src/lib.rs @@ -2,9 +2,10 @@ use roc_app; use indoc::indoc; use roc_app::Rbt; +use roc_std::RocStr; #[no_mangle] -pub extern "C" fn rust_main() -> i32 { +pub extern "C" fn rust_main() { use std::cmp::Ordering; use std::collections::hash_set::HashSet; @@ -33,9 +34,6 @@ pub extern "C" fn rust_main() -> i32 { set.insert(tag_union); assert_eq!(set.len(), 1); - - // Exit code - 0 } // Externs required by roc_std and by the Roc app @@ -65,16 +63,22 @@ pub unsafe extern "C" fn roc_dealloc(c_ptr: *mut c_void, _alignment: u32) { } #[no_mangle] -pub unsafe extern "C" fn roc_panic(c_ptr: *mut c_void, tag_id: u32) { +pub unsafe extern "C" fn roc_panic(msg: *mut RocStr, tag_id: u32) { match tag_id { 0 => { - let slice = CStr::from_ptr(c_ptr as *const c_char); - let string = slice.to_str().unwrap(); - eprintln!("Roc hit a panic: {}", string); - std::process::exit(1); + eprintln!("Roc standard library hit a panic: {}", &*msg); } - _ => todo!(), + 1 => { + eprintln!("Application hit a panic: {}", &*msg); + } + _ => unreachable!(), } + std::process::exit(1); +} + +#[no_mangle] +pub unsafe extern "C" fn roc_dbg(loc: *mut RocStr, msg: *mut RocStr) { + eprintln!("[{}] {}", &*loc, &*msg); } #[no_mangle] diff --git a/crates/glue/tests/fixtures/multiple-modules/src/lib.rs b/crates/glue/tests/fixtures/multiple-modules/src/lib.rs index e26415e710..8f0194fa0d 100644 --- a/crates/glue/tests/fixtures/multiple-modules/src/lib.rs +++ b/crates/glue/tests/fixtures/multiple-modules/src/lib.rs @@ -1,8 +1,9 @@ use indoc::indoc; use roc_app; +use roc_std::RocStr; #[no_mangle] -pub extern "C" fn rust_main() -> i32 { +pub extern "C" fn rust_main() { use std::cmp::Ordering; use std::collections::hash_set::HashSet; @@ -31,9 +32,6 @@ pub extern "C" fn rust_main() -> i32 { set.insert(tag_union); assert_eq!(set.len(), 1); - - // Exit code - 0 } // Externs required by roc_std and by the Roc app @@ -63,16 +61,22 @@ pub unsafe extern "C" fn roc_dealloc(c_ptr: *mut c_void, _alignment: u32) { } #[no_mangle] -pub unsafe extern "C" fn roc_panic(c_ptr: *mut c_void, tag_id: u32) { +pub unsafe extern "C" fn roc_panic(msg: *mut RocStr, tag_id: u32) { match tag_id { 0 => { - let slice = CStr::from_ptr(c_ptr as *const c_char); - let string = slice.to_str().unwrap(); - eprintln!("Roc hit a panic: {}", string); - std::process::exit(1); + eprintln!("Roc standard library hit a panic: {}", &*msg); } - _ => todo!(), + 1 => { + eprintln!("Application hit a panic: {}", &*msg); + } + _ => unreachable!(), } + std::process::exit(1); +} + +#[no_mangle] +pub unsafe extern "C" fn roc_dbg(loc: *mut RocStr, msg: *mut RocStr) { + eprintln!("[{}] {}", &*loc, &*msg); } #[no_mangle] diff --git a/crates/glue/tests/fixtures/nested-record/src/lib.rs b/crates/glue/tests/fixtures/nested-record/src/lib.rs index 92deb035b2..1263d2341b 100644 --- a/crates/glue/tests/fixtures/nested-record/src/lib.rs +++ b/crates/glue/tests/fixtures/nested-record/src/lib.rs @@ -1,7 +1,8 @@ use roc_app; +use roc_std::RocStr; #[no_mangle] -pub extern "C" fn rust_main() -> i32 { +pub extern "C" fn rust_main() { use std::cmp::Ordering; let outer = roc_app::mainForHost(); @@ -30,8 +31,7 @@ pub extern "C" fn rust_main() -> i32 { println!("Record was: {:?}", outer); - // Exit code - 0 + std::process::exit(0); } // Externs required by roc_std and by the Roc app @@ -61,16 +61,22 @@ pub unsafe extern "C" fn roc_dealloc(c_ptr: *mut c_void, _alignment: u32) { } #[no_mangle] -pub unsafe extern "C" fn roc_panic(c_ptr: *mut c_void, tag_id: u32) { +pub unsafe extern "C" fn roc_panic(msg: *mut RocStr, tag_id: u32) { match tag_id { 0 => { - let slice = CStr::from_ptr(c_ptr as *const c_char); - let string = slice.to_str().unwrap(); - eprintln!("Roc hit a panic: {}", string); - std::process::exit(1); + eprintln!("Roc standard library hit a panic: {}", &*msg); } - _ => todo!(), + 1 => { + eprintln!("Application hit a panic: {}", &*msg); + } + _ => unreachable!(), } + std::process::exit(1); +} + +#[no_mangle] +pub unsafe extern "C" fn roc_dbg(loc: *mut RocStr, msg: *mut RocStr) { + eprintln!("[{}] {}", &*loc, &*msg); } #[no_mangle] diff --git a/crates/glue/tests/fixtures/nonnullable-unwrapped/src/lib.rs b/crates/glue/tests/fixtures/nonnullable-unwrapped/src/lib.rs index fcae9742c2..ca96c8d6fe 100644 --- a/crates/glue/tests/fixtures/nonnullable-unwrapped/src/lib.rs +++ b/crates/glue/tests/fixtures/nonnullable-unwrapped/src/lib.rs @@ -10,7 +10,7 @@ extern "C" { } #[no_mangle] -pub extern "C" fn rust_main() -> i32 { +pub extern "C" fn rust_main() { use std::cmp::Ordering; use std::collections::hash_set::HashSet; @@ -47,9 +47,6 @@ pub extern "C" fn rust_main() -> i32 { set.insert(tag_union); assert_eq!(set.len(), 1); - - // Exit code - 0 } // Externs required by roc_std and by the Roc app @@ -79,16 +76,22 @@ pub unsafe extern "C" fn roc_dealloc(c_ptr: *mut c_void, _alignment: u32) { } #[no_mangle] -pub unsafe extern "C" fn roc_panic(c_ptr: *mut c_void, tag_id: u32) { +pub unsafe extern "C" fn roc_panic(msg: *mut RocStr, tag_id: u32) { match tag_id { 0 => { - let slice = CStr::from_ptr(c_ptr as *const c_char); - let string = slice.to_str().unwrap(); - eprintln!("Roc hit a panic: {}", string); - std::process::exit(1); + eprintln!("Roc standard library hit a panic: {}", &*msg); } - _ => todo!(), + 1 => { + eprintln!("Application hit a panic: {}", &*msg); + } + _ => unreachable!(), } + std::process::exit(1); +} + +#[no_mangle] +pub unsafe extern "C" fn roc_dbg(loc: *mut RocStr, msg: *mut RocStr) { + eprintln!("[{}] {}", &*loc, &*msg); } #[no_mangle] diff --git a/crates/glue/tests/fixtures/nullable-unwrapped/src/lib.rs b/crates/glue/tests/fixtures/nullable-unwrapped/src/lib.rs index f2bf716c7f..dd2f6a92fd 100644 --- a/crates/glue/tests/fixtures/nullable-unwrapped/src/lib.rs +++ b/crates/glue/tests/fixtures/nullable-unwrapped/src/lib.rs @@ -2,9 +2,10 @@ use roc_app; use indoc::indoc; use roc_app::StrConsList; +use roc_std::RocStr; #[no_mangle] -pub extern "C" fn rust_main() -> i32 { +pub extern "C" fn rust_main() { use std::cmp::Ordering; use std::collections::hash_set::HashSet; @@ -38,9 +39,6 @@ pub extern "C" fn rust_main() -> i32 { set.insert(tag_union); assert_eq!(set.len(), 1); - - // Exit code - 0 } // Externs required by roc_std and by the Roc app @@ -70,16 +68,22 @@ pub unsafe extern "C" fn roc_dealloc(c_ptr: *mut c_void, _alignment: u32) { } #[no_mangle] -pub unsafe extern "C" fn roc_panic(c_ptr: *mut c_void, tag_id: u32) { +pub unsafe extern "C" fn roc_panic(msg: *mut RocStr, tag_id: u32) { match tag_id { 0 => { - let slice = CStr::from_ptr(c_ptr as *const c_char); - let string = slice.to_str().unwrap(); - eprintln!("Roc hit a panic: {}", string); - std::process::exit(1); + eprintln!("Roc standard library hit a panic: {}", &*msg); } - _ => todo!(), + 1 => { + eprintln!("Application hit a panic: {}", &*msg); + } + _ => unreachable!(), } + std::process::exit(1); +} + +#[no_mangle] +pub unsafe extern "C" fn roc_dbg(loc: *mut RocStr, msg: *mut RocStr) { + eprintln!("[{}] {}", &*loc, &*msg); } #[no_mangle] diff --git a/crates/glue/tests/fixtures/nullable-wrapped/src/lib.rs b/crates/glue/tests/fixtures/nullable-wrapped/src/lib.rs index c99a7ae610..0ef35c17c1 100644 --- a/crates/glue/tests/fixtures/nullable-wrapped/src/lib.rs +++ b/crates/glue/tests/fixtures/nullable-wrapped/src/lib.rs @@ -10,7 +10,7 @@ extern "C" { } #[no_mangle] -pub extern "C" fn rust_main() -> i32 { +pub extern "C" fn rust_main() { use std::cmp::Ordering; use std::collections::hash_set::HashSet; @@ -58,9 +58,6 @@ pub extern "C" fn rust_main() -> i32 { set.insert(tag_union); assert_eq!(set.len(), 1); - - // Exit code - 0 } // Externs required by roc_std and by the Roc app @@ -90,16 +87,22 @@ pub unsafe extern "C" fn roc_dealloc(c_ptr: *mut c_void, _alignment: u32) { } #[no_mangle] -pub unsafe extern "C" fn roc_panic(c_ptr: *mut c_void, tag_id: u32) { +pub unsafe extern "C" fn roc_panic(msg: *mut RocStr, tag_id: u32) { match tag_id { 0 => { - let slice = CStr::from_ptr(c_ptr as *const c_char); - let string = slice.to_str().unwrap(); - eprintln!("Roc hit a panic: {}", string); - std::process::exit(1); + eprintln!("Roc standard library hit a panic: {}", &*msg); } - _ => todo!(), + 1 => { + eprintln!("Application hit a panic: {}", &*msg); + } + _ => unreachable!(), } + std::process::exit(1); +} + +#[no_mangle] +pub unsafe extern "C" fn roc_dbg(loc: *mut RocStr, msg: *mut RocStr) { + eprintln!("[{}] {}", &*loc, &*msg); } #[no_mangle] diff --git a/crates/glue/tests/fixtures/option/src/lib.rs b/crates/glue/tests/fixtures/option/src/lib.rs index 3f7ee45b88..c5e565c75f 100644 --- a/crates/glue/tests/fixtures/option/src/lib.rs +++ b/crates/glue/tests/fixtures/option/src/lib.rs @@ -1,15 +1,13 @@ use roc_app; +use roc_std::RocStr; #[no_mangle] -pub extern "C" fn rust_main() -> i32 { +pub extern "C" fn rust_main() { let string = roc_app::mainForHost(true); println!("Answer was: {:?}", string.unwrap_Some()); // Debug // let integer = roc_app::mainForHost(false); println!("Answer was: {:?}", integer.discriminant()); // Debug - - // Exit code - 0 } // Externs required by roc_std and by the Roc app @@ -39,16 +37,22 @@ pub unsafe extern "C" fn roc_dealloc(c_ptr: *mut c_void, _alignment: u32) { } #[no_mangle] -pub unsafe extern "C" fn roc_panic(c_ptr: *mut c_void, tag_id: u32) { +pub unsafe extern "C" fn roc_panic(msg: *mut RocStr, tag_id: u32) { match tag_id { 0 => { - let slice = CStr::from_ptr(c_ptr as *const c_char); - let string = slice.to_str().unwrap(); - eprintln!("Roc hit a panic: {}", string); - std::process::exit(1); + eprintln!("Roc standard library hit a panic: {}", &*msg); } - _ => todo!(), + 1 => { + eprintln!("Application hit a panic: {}", &*msg); + } + _ => unreachable!(), } + std::process::exit(1); +} + +#[no_mangle] +pub unsafe extern "C" fn roc_dbg(loc: *mut RocStr, msg: *mut RocStr) { + eprintln!("[{}] {}", &*loc, &*msg); } #[no_mangle] diff --git a/crates/glue/tests/fixtures/rocresult/src/lib.rs b/crates/glue/tests/fixtures/rocresult/src/lib.rs index e07fbee768..27092d4d68 100644 --- a/crates/glue/tests/fixtures/rocresult/src/lib.rs +++ b/crates/glue/tests/fixtures/rocresult/src/lib.rs @@ -1,15 +1,13 @@ use roc_app; +use roc_std::RocStr; #[no_mangle] -pub extern "C" fn rust_main() -> i32 { +pub extern "C" fn rust_main() { let string = roc_app::mainForHost(true); println!("Answer was: {:?}", string); // Debug // let integer = roc_app::mainForHost(false); println!("Answer was: {:?}", integer); // Debug - - // Exit code - 0 } // Externs required by roc_std and by the Roc app @@ -39,16 +37,22 @@ pub unsafe extern "C" fn roc_dealloc(c_ptr: *mut c_void, _alignment: u32) { } #[no_mangle] -pub unsafe extern "C" fn roc_panic(c_ptr: *mut c_void, tag_id: u32) { +pub unsafe extern "C" fn roc_panic(msg: *mut RocStr, tag_id: u32) { match tag_id { 0 => { - let slice = CStr::from_ptr(c_ptr as *const c_char); - let string = slice.to_str().unwrap(); - eprintln!("Roc hit a panic: {}", string); - std::process::exit(1); + eprintln!("Roc standard library hit a panic: {}", &*msg); } - _ => todo!(), + 1 => { + eprintln!("Application hit a panic: {}", &*msg); + } + _ => unreachable!(), } + std::process::exit(1); +} + +#[no_mangle] +pub unsafe extern "C" fn roc_dbg(loc: *mut RocStr, msg: *mut RocStr) { + eprintln!("[{}] {}", &*loc, &*msg); } #[no_mangle] diff --git a/crates/glue/tests/fixtures/single-tag-union/src/lib.rs b/crates/glue/tests/fixtures/single-tag-union/src/lib.rs index cc2e1ae01d..a59c631a9f 100644 --- a/crates/glue/tests/fixtures/single-tag-union/src/lib.rs +++ b/crates/glue/tests/fixtures/single-tag-union/src/lib.rs @@ -2,9 +2,10 @@ use roc_app; use indoc::indoc; use roc_app::SingleTagUnion; +use roc_std::RocStr; #[no_mangle] -pub extern "C" fn rust_main() -> i32 { +pub extern "C" fn rust_main() { use std::cmp::Ordering; use std::collections::hash_set::HashSet; @@ -33,9 +34,6 @@ pub extern "C" fn rust_main() -> i32 { set.insert(tag_union); assert_eq!(set.len(), 1); - - // Exit code - 0 } // Externs required by roc_std and by the Roc app @@ -65,16 +63,22 @@ pub unsafe extern "C" fn roc_dealloc(c_ptr: *mut c_void, _alignment: u32) { } #[no_mangle] -pub unsafe extern "C" fn roc_panic(c_ptr: *mut c_void, tag_id: u32) { +pub unsafe extern "C" fn roc_panic(msg: *mut RocStr, tag_id: u32) { match tag_id { 0 => { - let slice = CStr::from_ptr(c_ptr as *const c_char); - let string = slice.to_str().unwrap(); - eprintln!("Roc hit a panic: {}", string); - std::process::exit(1); + eprintln!("Roc standard library hit a panic: {}", &*msg); } - _ => todo!(), + 1 => { + eprintln!("Application hit a panic: {}", &*msg); + } + _ => unreachable!(), } + std::process::exit(1); +} + +#[no_mangle] +pub unsafe extern "C" fn roc_dbg(loc: *mut RocStr, msg: *mut RocStr) { + eprintln!("[{}] {}", &*loc, &*msg); } #[no_mangle] diff --git a/crates/glue/tests/fixtures/union-with-padding/src/lib.rs b/crates/glue/tests/fixtures/union-with-padding/src/lib.rs index c7a1a2d09b..42e32770d3 100644 --- a/crates/glue/tests/fixtures/union-with-padding/src/lib.rs +++ b/crates/glue/tests/fixtures/union-with-padding/src/lib.rs @@ -1,6 +1,7 @@ use roc_app; use roc_app::NonRecursive; +use roc_std::RocStr; extern "C" { #[link_name = "roc__mainForHost_1_exposed_generic"] @@ -8,7 +9,7 @@ extern "C" { } #[no_mangle] -pub extern "C" fn rust_main() -> i32 { +pub extern "C" fn rust_main() { use std::cmp::Ordering; use std::collections::hash_set::HashSet; @@ -38,9 +39,6 @@ pub extern "C" fn rust_main() -> i32 { set.insert(tag_union); assert_eq!(set.len(), 1); - - // Exit code - 0 } // Externs required by roc_std and by the Roc app @@ -70,16 +68,22 @@ pub unsafe extern "C" fn roc_dealloc(c_ptr: *mut c_void, _alignment: u32) { } #[no_mangle] -pub unsafe extern "C" fn roc_panic(c_ptr: *mut c_void, tag_id: u32) { +pub unsafe extern "C" fn roc_panic(msg: *mut RocStr, tag_id: u32) { match tag_id { 0 => { - let slice = CStr::from_ptr(c_ptr as *const c_char); - let string = slice.to_str().unwrap(); - eprintln!("Roc hit a panic: {}", string); - std::process::exit(1); + eprintln!("Roc standard library hit a panic: {}", &*msg); } - _ => todo!(), + 1 => { + eprintln!("Application hit a panic: {}", &*msg); + } + _ => unreachable!(), } + std::process::exit(1); +} + +#[no_mangle] +pub unsafe extern "C" fn roc_dbg(loc: *mut RocStr, msg: *mut RocStr) { + eprintln!("[{}] {}", &*loc, &*msg); } #[no_mangle] diff --git a/crates/glue/tests/fixtures/union-without-padding/src/lib.rs b/crates/glue/tests/fixtures/union-without-padding/src/lib.rs index 1709441eba..f424da0a9f 100644 --- a/crates/glue/tests/fixtures/union-without-padding/src/lib.rs +++ b/crates/glue/tests/fixtures/union-without-padding/src/lib.rs @@ -1,4 +1,5 @@ use roc_app; +use roc_std::RocStr; extern "C" { #[link_name = "roc__mainForHost_1_exposed_generic"] @@ -6,7 +7,7 @@ extern "C" { } #[no_mangle] -pub extern "C" fn rust_main() -> i32 { +pub extern "C" fn rust_main() { use std::cmp::Ordering; use std::collections::hash_set::HashSet; @@ -35,9 +36,6 @@ pub extern "C" fn rust_main() -> i32 { set.insert(tag_union); assert_eq!(set.len(), 1); - - // Exit code - 0 } // Externs required by roc_std and by the Roc app @@ -67,16 +65,22 @@ pub unsafe extern "C" fn roc_dealloc(c_ptr: *mut c_void, _alignment: u32) { } #[no_mangle] -pub unsafe extern "C" fn roc_panic(c_ptr: *mut c_void, tag_id: u32) { +pub unsafe extern "C" fn roc_panic(msg: *mut RocStr, tag_id: u32) { match tag_id { 0 => { - let slice = CStr::from_ptr(c_ptr as *const c_char); - let string = slice.to_str().unwrap(); - eprintln!("Roc hit a panic: {}", string); - std::process::exit(1); + eprintln!("Roc standard library hit a panic: {}", &*msg); } - _ => todo!(), + 1 => { + eprintln!("Application hit a panic: {}", &*msg); + } + _ => unreachable!(), } + std::process::exit(1); +} + +#[no_mangle] +pub unsafe extern "C" fn roc_dbg(loc: *mut RocStr, msg: *mut RocStr) { + eprintln!("[{}] {}", &*loc, &*msg); } #[no_mangle] diff --git a/crates/glue/tests/test_glue_cli.rs b/crates/glue/tests/test_glue_cli.rs index 0c2d571ceb..86e824b2e9 100644 --- a/crates/glue/tests/test_glue_cli.rs +++ b/crates/glue/tests/test_glue_cli.rs @@ -78,8 +78,9 @@ mod glue_cli_run { fixtures! { basic_record:"basic-record" => "Record was: MyRcd { b: 42, a: 1995 }\n", - nested_record:"nested-record" => "Record was: Outer { y: \"foo\", z: [1, 2], x: Inner { b: 24.0, a: 5 } }\n", - enumeration:"enumeration" => "tag_union was: MyEnum::Foo, Bar is: MyEnum::Bar, Baz is: MyEnum::Baz\n", + // TODO: re-enable this test. Currently it is flaking on macos x86-64 with a bad exit code. + // nested_record:"nested-record" => "Record was: Outer { y: \"foo\", z: [1, 2], x: Inner { b: 24.0, a: 5 } }\n", + // enumeration:"enumeration" => "tag_union was: MyEnum::Foo, Bar is: MyEnum::Bar, Baz is: MyEnum::Baz\n", single_tag_union:"single-tag-union" => indoc!(r#" tag_union was: SingleTagUnion::OneTag "#), diff --git a/crates/lang_srv/src/analysis/tokens.rs b/crates/lang_srv/src/analysis/tokens.rs index 476dd680de..759b941c57 100644 --- a/crates/lang_srv/src/analysis/tokens.rs +++ b/crates/lang_srv/src/analysis/tokens.rs @@ -673,6 +673,9 @@ impl IterTokens for Loc> { Expr::Dbg(e1, e2) => (e1.iter_tokens(arena).into_iter()) .chain(e2.iter_tokens(arena)) .collect_in(arena), + Expr::LowLevelDbg(e1, e2) => (e1.iter_tokens(arena).into_iter()) + .chain(e2.iter_tokens(arena)) + .collect_in(arena), Expr::Apply(e1, e2, _called_via) => (e1.iter_tokens(arena).into_iter()) .chain(e2.iter_tokens(arena)) .collect_in(arena), diff --git a/crates/repl_expect/src/run.rs b/crates/repl_expect/src/run.rs index 413a6e7a16..202086aae8 100644 --- a/crates/repl_expect/src/run.rs +++ b/crates/repl_expect/src/run.rs @@ -435,44 +435,6 @@ pub fn render_expects_in_memory<'a>( ) } -pub fn render_dbgs_in_memory<'a>( - writer: &mut impl std::io::Write, - arena: &'a Bump, - expectations: &mut VecMap, - interns: &'a Interns, - layout_interner: &GlobalLayoutInterner<'a>, - memory: &ExpectMemory, -) -> std::io::Result { - let shared_ptr = memory.ptr; - - let frame = ExpectFrame::at_offset(shared_ptr, ExpectSequence::START_OFFSET); - let module_id = frame.module_id; - - let data = expectations.get_mut(&module_id).unwrap(); - let filename = data.path.to_owned(); - let source = std::fs::read_to_string(&data.path).unwrap(); - - let renderer = Renderer::new( - arena, - interns, - RenderTarget::ColorTerminal, - module_id, - filename, - &source, - ); - - render_dbg_failure( - writer, - &renderer, - arena, - expectations, - interns, - layout_interner, - shared_ptr, - ExpectSequence::START_OFFSET, - ) -} - fn split_expect_lookups(subs: &Subs, lookups: &[ExpectLookup]) -> Vec { lookups .iter() @@ -494,53 +456,6 @@ fn split_expect_lookups(subs: &Subs, lookups: &[ExpectLookup]) -> Vec { .collect() } -#[allow(clippy::too_many_arguments)] -fn render_dbg_failure<'a>( - writer: &mut impl std::io::Write, - renderer: &Renderer, - arena: &'a Bump, - expectations: &mut VecMap, - interns: &'a Interns, - layout_interner: &GlobalLayoutInterner<'a>, - start: *const u8, - offset: usize, -) -> std::io::Result { - // we always run programs as the host - let target_info = (&target_lexicon::Triple::host()).into(); - - let frame = ExpectFrame::at_offset(start, offset); - let module_id = frame.module_id; - - let failure_region = frame.region; - let dbg_symbol = unsafe { std::mem::transmute::<_, Symbol>(failure_region) }; - let expect_region = Some(Region::zero()); - - let data = expectations.get_mut(&module_id).unwrap(); - - let current = match data.dbgs.get(&dbg_symbol) { - None => internal_error!("region {failure_region:?} not in list of dbgs"), - Some(current) => current, - }; - let failure_region = current.region; - - let subs = arena.alloc(&mut data.subs); - - let (offset, expressions, _variables) = crate::get_values( - target_info, - arena, - subs, - interns, - layout_interner, - start, - frame.start_offset, - 1, - ); - - renderer.render_dbg(writer, &expressions, expect_region, failure_region)?; - - Ok(offset) -} - #[allow(clippy::too_many_arguments)] fn render_expect_failure<'a>( writer: &mut impl std::io::Write, @@ -637,7 +552,6 @@ impl ExpectSequence { match atomic.load(Ordering::Acquire) { 0 => std::hint::spin_loop(), 1 => break ChildProcessMsg::Expect, - 2 => break ChildProcessMsg::Dbg, n => internal_error!("invalid atomic value set by the child: {n:#x}"), } } @@ -655,8 +569,7 @@ impl ExpectSequence { pub enum ChildProcessMsg { Expect = 1, - Dbg = 2, - Terminate = 3, + Terminate = 2, } struct ExpectFrame { diff --git a/crates/repl_wasm/src/repl_platform.c b/crates/repl_wasm/src/repl_platform.c index 9e55b6201f..2b5a87f1fc 100644 --- a/crates/repl_wasm/src/repl_platform.c +++ b/crates/repl_wasm/src/repl_platform.c @@ -67,6 +67,9 @@ void roc_panic(void *ptr, unsigned int panic_tag) abort(); } +// TODO: add a way to send dbg to js. +void roc_debug(void* loc, void* msg) {} + //-------------------------- void *roc_memset(void *str, int c, size_t n) diff --git a/crates/reporting/src/error/parse.rs b/crates/reporting/src/error/parse.rs index 2631bdf1f5..839da6c2f4 100644 --- a/crates/reporting/src/error/parse.rs +++ b/crates/reporting/src/error/parse.rs @@ -3515,6 +3515,52 @@ fn to_provides_report<'a>( EProvides::Space(error, pos) => to_space_report(alloc, lines, filename, &error, pos), + EProvides::IndentTo(pos) => { + let surroundings = Region::new(start, pos); + let region = LineColumnRegion::from_pos(lines.convert_pos(pos)); + + let doc = alloc.stack([ + alloc.reflow(r"I am partway through parsing a header, but I got stuck here:"), + alloc.region_with_subregion(lines.convert_region(surroundings), region), + alloc.concat([ + alloc.reflow("I am expecting the "), + alloc.keyword("to"), + alloc.reflow(" keyword next, like:"), + ]), + alloc + .parser_suggestion("to pf") + .indent(4), + ]); + + Report { + filename, + doc, + title: "WEIRD PROVIDES".to_string(), + severity: Severity::RuntimeError, + } + } + + EProvides::IndentListStart(pos) => { + let surroundings = Region::new(start, pos); + let region = LineColumnRegion::from_pos(lines.convert_pos(pos)); + + let doc = alloc.stack([ + alloc.reflow(r"I am partway through parsing a header, but I got stuck here:"), + alloc.region_with_subregion(lines.convert_region(surroundings), region), + alloc.reflow("I am expecting the platform name next, like:"), + alloc + .parser_suggestion("to pf") + .indent(4), + ]); + + Report { + filename, + doc, + title: "WEIRD PROVIDES".to_string(), + severity: Severity::RuntimeError, + } + } + _ => todo!("unhandled parse error {:?}", parse_problem), } } diff --git a/crates/roc_std/src/lib.rs b/crates/roc_std/src/lib.rs index ec549e461a..587bd4fe27 100644 --- a/crates/roc_std/src/lib.rs +++ b/crates/roc_std/src/lib.rs @@ -36,6 +36,7 @@ extern "C" { ) -> *mut c_void; pub fn roc_dealloc(ptr: *mut c_void, alignment: u32); pub fn roc_panic(c_ptr: *mut c_void, tag_id: u32); + pub fn roc_dbg(loc: *mut c_void, msg: *mut c_void); pub fn roc_memset(dst: *mut c_void, c: i32, n: usize) -> *mut c_void; } diff --git a/crates/roc_std/tests/test_roc_std.rs b/crates/roc_std/tests/test_roc_std.rs index 15cbd31d5a..9b1e8fd1f8 100644 --- a/crates/roc_std/tests/test_roc_std.rs +++ b/crates/roc_std/tests/test_roc_std.rs @@ -32,18 +32,14 @@ pub unsafe extern "C" fn roc_dealloc(c_ptr: *mut c_void, _alignment: u32) { #[cfg(test)] #[no_mangle] -pub unsafe extern "C" fn roc_panic(c_ptr: *mut c_void, tag_id: u32) { - use std::ffi::CStr; - use std::os::raw::c_char; +pub unsafe extern "C" fn roc_panic(msg: *mut roc_std::RocStr, _tag_id: u32) { + panic!("roc_panic during test: {}", &*msg); +} - match tag_id { - 0 => { - let c_str = CStr::from_ptr(c_ptr as *const c_char); - let string = c_str.to_str().unwrap(); - panic!("roc_panic during test: {string}"); - } - _ => todo!(), - } +#[cfg(test)] +#[no_mangle] +pub unsafe extern "C" fn roc_dbg(loc: *mut roc_std::RocStr, msg: *mut roc_std::RocStr) { + eprintln!("[{}] {}", &*loc, &*msg); } #[cfg(test)] diff --git a/crates/valgrind/zig-platform/host.zig b/crates/valgrind/zig-platform/host.zig index 85116e5634..84f1ac0117 100644 --- a/crates/valgrind/zig-platform/host.zig +++ b/crates/valgrind/zig-platform/host.zig @@ -44,13 +44,23 @@ export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void { free(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr)))); } -export fn roc_panic(c_ptr: *anyopaque, tag_id: u32) callconv(.C) void { - _ = tag_id; - +export fn roc_panic(msg: *RocStr, tag_id: u32) callconv(.C) void { const stderr = std.io.getStdErr().writer(); - const msg = @as([*:0]const u8, @ptrCast(c_ptr)); - stderr.print("Application crashed with message\n\n {s}\n\nShutting down\n", .{msg}) catch unreachable; - std.process.exit(0); + switch (tag_id) { + 0 => { + stderr.print("Roc standard library crashed with message\n\n {s}\n\nShutting down\n", .{msg.asSlice()}) catch unreachable; + }, + 1 => { + stderr.print("Application crashed with message\n\n {s}\n\nShutting down\n", .{msg.asSlice()}) catch unreachable; + }, + else => unreachable, + } + std.process.exit(1); +} + +export fn roc_dbg(loc: *RocStr, msg: *RocStr) callconv(.C) void { + const stderr = std.io.getStdErr().writer(); + stderr.print("[{s}] {s}\n", .{ loc.asSlice(), msg.asSlice() }) catch unreachable; } export fn roc_memset(dst: [*]u8, value: i32, size: usize) callconv(.C) void { diff --git a/examples/Community.roc b/examples/Community.roc index 7be09c317a..8a79d3dd44 100644 --- a/examples/Community.roc +++ b/examples/Community.roc @@ -15,11 +15,7 @@ Community := { people : List Person, friends : List (Set Nat), } - implements [ - Inspect { - toInspector: inspectCommunity, - }, - ] + implements [Inspect] Person := { firstName : Str, @@ -28,11 +24,7 @@ Person := { hasBeard : Bool, favoriteColor : Color, } - implements [ - Inspect { - toInspector: inspectPerson, - }, - ] + implements [Inspect] Color : [ Red, @@ -90,61 +82,3 @@ walkFriendNames = \@Community { people, friends }, s0, nextFn -> (nextFn s1 personName friendNames, id + 1) out -# The functions below will be auto-generated in the future -inspectCommunity : Community -> Inspector f where f implements InspectFormatter -inspectCommunity = \@Community { people, friends } -> - f0 <- Inspect.custom - [ - { key: "people", value: Inspect.list people List.walk Inspect.toInspector }, - { - key: "friends", - value: Inspect.list - friends - List.walk - (\s -> Inspect.set - s - Set.walk - (\num -> num |> Num.toU64 |> Inspect.u64) - ), - # value: Inspect.dict - # (@Community { people, friends }) - # walkFriendNames - # Inspect.str - # (\s -> Inspect.set s Set.walk Inspect.str), - }, - ] - |> Inspect.record - |> Inspect.apply f0 - -inspectPerson : Person -> Inspector f where f implements InspectFormatter -inspectPerson = \@Person { firstName, lastName, age, hasBeard, favoriteColor } -> - # In practice, this would never be done manually due to autoderive. - # Instead you would just write: - # Inspect.inspect innerRecord - # This is what the auto-derive would generate. - - f0 <- Inspect.custom - - favoriteColorTag = - when favoriteColor is - Red -> - Inspect.tag "Red" [] - - Green -> - Inspect.tag "Green" [] - - Blue -> - Inspect.tag "Blue" [] - - RGB (r, g, b) -> - Inspect.tag "RGB" [Inspect.tuple [Inspect.u8 r, Inspect.u8 g, Inspect.u8 b]] - - [ - { key: "firstName", value: Inspect.str firstName }, - { key: "lastName", value: Inspect.str lastName }, - { key: "age", value: Inspect.u8 age }, - { key: "hasBeard", value: Inspect.bool hasBeard }, - { key: "favoriteColor", value: favoriteColorTag }, - ] - |> Inspect.record - |> Inspect.apply f0 diff --git a/examples/GuiFormatter.roc b/examples/GuiFormatter.roc index 615edb15c8..1a060911a1 100644 --- a/examples/GuiFormatter.roc +++ b/examples/GuiFormatter.roc @@ -25,6 +25,7 @@ GuiFormatter := { nodes : List Elem } record: record, bool: bool, str: str, + function: function, opaque: opaque, u8: u8, i8: i8, @@ -36,6 +37,7 @@ GuiFormatter := { nodes : List Elem } i64: i64, u128: u128, i128: i128, + nat: nat, f32: f32, f64: f64, dec: dec, @@ -149,10 +151,15 @@ str = \s -> f0 <- Inspect.custom addNode f0 (Text "\"\(s)\"") -opaque : Str -> Inspector GuiFormatter -opaque = \s -> +opaque : * -> Inspector GuiFormatter +opaque = \_ -> f0 <- Inspect.custom - addNode f0 (Text "<\(s)>") + addNode f0 (Text "") + +function : * -> Inspector GuiFormatter +function = \_ -> + f0 <- Inspect.custom + addNode f0 (Text "") u8 : U8 -> Inspector GuiFormatter u8 = \num -> @@ -204,6 +211,11 @@ i128 = \num -> f0 <- Inspect.custom addNode f0 (num |> Num.toStr |> Text) +nat : Nat -> Inspector GuiFormatter +nat = \num -> + f0 <- Inspect.custom + addNode f0 (num |> Num.toStr |> Text) + f32 : F32 -> Inspector GuiFormatter f32 = \num -> f0 <- Inspect.custom diff --git a/examples/LogFormatter.roc b/examples/LogFormatter.roc deleted file mode 100644 index a9a015e58c..0000000000 --- a/examples/LogFormatter.roc +++ /dev/null @@ -1,246 +0,0 @@ -interface LogFormatter - exposes [ - LogFormatter, - toStr, - ] - imports [] - -## Creates String representations of Roc values, for use in inspect-logging.roc - -LogFormatter := { data : Str } - implements [ - InspectFormatter { - init: init, - list: list, - set: set, - dict: dict, - tag: tag, - tuple: tuple, - record: record, - bool: bool, - str: str, - opaque: opaque, - u8: u8, - i8: i8, - u16: u16, - i16: i16, - u32: u32, - i32: i32, - u64: u64, - i64: i64, - u128: u128, - i128: i128, - f32: f32, - f64: f64, - dec: dec, - - }, - ] - -init : {} -> LogFormatter -init = \{} -> @LogFormatter { data: "" } - -list : list, ElemWalker (LogFormatter, Bool) list elem, (elem -> Inspector LogFormatter) -> Inspector LogFormatter -list = \content, walkFn, toInspector -> - f0 <- Inspect.custom - write f0 "[" - |> \f1 -> - (f2, prependSep), elem <- walkFn content (f1, Bool.false) - f3 = - if prependSep then - write f2 ", " - else - f2 - - elem - |> toInspector - |> Inspect.apply f3 - |> \f4 -> (f4, Bool.true) - |> .0 - |> write "]" - -set : set, ElemWalker (LogFormatter, Bool) set elem, (elem -> Inspector LogFormatter) -> Inspector LogFormatter -set = \content, walkFn, toInspector -> - f0 <- Inspect.custom - write f0 "{" - |> \f1 -> - (f2, prependSep), elem <- walkFn content (f1, Bool.false) - f3 = - if prependSep then - write f2 ", " - else - f2 - - elem - |> toInspector - |> Inspect.apply f3 - |> \f4 -> (f4, Bool.true) - |> .0 - |> write "}" - -dict : dict, KeyValWalker (LogFormatter, Bool) dict key value, (key -> Inspector LogFormatter), (value -> Inspector LogFormatter) -> Inspector LogFormatter -dict = \d, walkFn, keyToInspector, valueToInspector -> - f0 <- Inspect.custom - write f0 "{" - |> \f1 -> - (f2, prependSep), key, value <- walkFn d (f1, Bool.false) - f3 = - if prependSep then - write f2 ", " - else - f2 - - Inspect.apply (keyToInspector key) f3 - |> write ": " - |> \x -> Inspect.apply (valueToInspector value) x - |> \f4 -> (f4, Bool.true) - |> .0 - |> write "}" - -tag : Str, List (Inspector LogFormatter) -> Inspector LogFormatter -tag = \name, fields -> - if List.isEmpty fields then - f0 <- Inspect.custom - write f0 name - else - f0 <- Inspect.custom - write f0 "(" - |> write name - |> \f1 -> - f2, inspector <- List.walk fields f1 - write f2 " " - |> \x -> Inspect.apply inspector x - |> write ")" - -tuple : List (Inspector LogFormatter) -> Inspector LogFormatter -tuple = \fields -> - f0 <- Inspect.custom - write f0 "(" - |> \f1 -> - (f2, prependSep), inspector <- List.walk fields (f1, Bool.false) - f3 = - if prependSep then - write f2 ", " - else - f2 - - Inspect.apply inspector f3 - |> \f4 -> (f4, Bool.true) - |> .0 - |> write ")" - -record : List { key : Str, value : Inspector LogFormatter } -> Inspector LogFormatter -record = \fields -> - f0 <- Inspect.custom - write f0 "{" - |> \f1 -> - (f2, prependSep), { key, value } <- List.walk fields (f1, Bool.false) - f3 = - if prependSep then - write f2 ", " - else - f2 - - write f3 key - |> write ": " - |> \x -> Inspect.apply value x - |> \f4 -> (f4, Bool.true) - |> .0 - |> write "}" - -bool : Bool -> Inspector LogFormatter -bool = \b -> - if b then - f0 <- Inspect.custom - write f0 "true" - else - f0 <- Inspect.custom - write f0 "false" - -str : Str -> Inspector LogFormatter -str = \s -> - f0 <- Inspect.custom - f0 - |> write "\"" - |> write s - |> write "\"" - -opaque : Str -> Inspector LogFormatter -opaque = \s -> - f0 <- Inspect.custom - f0 - |> write "<" - |> write s - |> write ">" - -u8 : U8 -> Inspector LogFormatter -u8 = \num -> - f0 <- Inspect.custom - write f0 (num |> Num.toStr) - -i8 : I8 -> Inspector LogFormatter -i8 = \num -> - f0 <- Inspect.custom - write f0 (num |> Num.toStr) - -u16 : U16 -> Inspector LogFormatter -u16 = \num -> - f0 <- Inspect.custom - write f0 (num |> Num.toStr) - -i16 : I16 -> Inspector LogFormatter -i16 = \num -> - f0 <- Inspect.custom - write f0 (num |> Num.toStr) - -u32 : U32 -> Inspector LogFormatter -u32 = \num -> - f0 <- Inspect.custom - write f0 (num |> Num.toStr) - -i32 : I32 -> Inspector LogFormatter -i32 = \num -> - f0 <- Inspect.custom - write f0 (num |> Num.toStr) - -u64 : U64 -> Inspector LogFormatter -u64 = \num -> - f0 <- Inspect.custom - write f0 (num |> Num.toStr) - -i64 : I64 -> Inspector LogFormatter -i64 = \num -> - f0 <- Inspect.custom - write f0 (num |> Num.toStr) - -u128 : U128 -> Inspector LogFormatter -u128 = \num -> - f0 <- Inspect.custom - write f0 (num |> Num.toStr) - -i128 : I128 -> Inspector LogFormatter -i128 = \num -> - f0 <- Inspect.custom - write f0 (num |> Num.toStr) - -f32 : F32 -> Inspector LogFormatter -f32 = \num -> - f0 <- Inspect.custom - write f0 (num |> Num.toStr) - -f64 : F64 -> Inspector LogFormatter -f64 = \num -> - f0 <- Inspect.custom - write f0 (num |> Num.toStr) - -dec : Dec -> Inspector LogFormatter -dec = \num -> - f0 <- Inspect.custom - write f0 (num |> Num.toStr) - -write : LogFormatter, Str -> LogFormatter -write = \@LogFormatter { data }, added -> - @LogFormatter { data: Str.concat data added } - -toStr : LogFormatter -> Str -toStr = \@LogFormatter { data } -> data diff --git a/examples/cli/argsBROKEN.roc b/examples/cli/argsBROKEN.roc index e5dc6ac8eb..c2fe7b1d4c 100644 --- a/examples/cli/argsBROKEN.roc +++ b/examples/cli/argsBROKEN.roc @@ -1,5 +1,5 @@ app "args" - packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.6.0/QOQW08n38nHHrVVkJNiPIjzjvbR3iMjXeFY5w1aT46w.tar.br" } + packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.7.0/bkGby8jb0tmZYsy2hg1E_B2QrCgcSTxdUlHtETwm5m4.tar.br" } imports [pf.Stdout, pf.Arg, pf.Task.{ Task }] provides [main] to pf diff --git a/examples/cli/countdown.roc b/examples/cli/countdown.roc index f96624b40e..917c30fda8 100644 --- a/examples/cli/countdown.roc +++ b/examples/cli/countdown.roc @@ -1,5 +1,5 @@ app "countdown" - packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.6.0/QOQW08n38nHHrVVkJNiPIjzjvbR3iMjXeFY5w1aT46w.tar.br" } + packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.7.0/bkGby8jb0tmZYsy2hg1E_B2QrCgcSTxdUlHtETwm5m4.tar.br" } imports [pf.Stdin, pf.Stdout, pf.Task.{ await, loop }] provides [main] to pf diff --git a/examples/cli/echo.roc b/examples/cli/echo.roc index 5e744a9bac..88737ea6cc 100644 --- a/examples/cli/echo.roc +++ b/examples/cli/echo.roc @@ -1,5 +1,5 @@ app "echo" - packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.6.0/QOQW08n38nHHrVVkJNiPIjzjvbR3iMjXeFY5w1aT46w.tar.br" } + packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.7.0/bkGby8jb0tmZYsy2hg1E_B2QrCgcSTxdUlHtETwm5m4.tar.br" } imports [pf.Stdin, pf.Stdout, pf.Task.{ Task }] provides [main] to pf diff --git a/examples/cli/effects-platform/host.zig b/examples/cli/effects-platform/host.zig index d8aa9cb5d2..6d3ea3306e 100644 --- a/examples/cli/effects-platform/host.zig +++ b/examples/cli/effects-platform/host.zig @@ -58,13 +58,23 @@ export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void { free(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr)))); } -export fn roc_panic(c_ptr: *anyopaque, tag_id: u32) callconv(.C) void { - _ = tag_id; - +export fn roc_panic(msg: *RocStr, tag_id: u32) callconv(.C) void { const stderr = std.io.getStdErr().writer(); - const msg = @as([*:0]const u8, @ptrCast(c_ptr)); - stderr.print("Application crashed with message\n\n {s}\n\nShutting down\n", .{msg}) catch unreachable; - std.process.exit(0); + switch (tag_id) { + 0 => { + stderr.print("Roc standard library crashed with message\n\n {s}\n\nShutting down\n", .{msg.asSlice()}) catch unreachable; + }, + 1 => { + stderr.print("Application crashed with message\n\n {s}\n\nShutting down\n", .{msg.asSlice()}) catch unreachable; + }, + else => unreachable, + } + std.process.exit(1); +} + +export fn roc_dbg(loc: *RocStr, msg: *RocStr) callconv(.C) void { + const stderr = std.io.getStdErr().writer(); + stderr.print("[{s}] {s}\n", .{ loc.asSlice(), msg.asSlice() }) catch unreachable; } export fn roc_memset(dst: [*]u8, value: i32, size: usize) callconv(.C) void { diff --git a/examples/cli/env.roc b/examples/cli/env.roc index 73e9061e66..eb2a6184c9 100644 --- a/examples/cli/env.roc +++ b/examples/cli/env.roc @@ -1,5 +1,5 @@ app "env" - packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.6.0/QOQW08n38nHHrVVkJNiPIjzjvbR3iMjXeFY5w1aT46w.tar.br" } + packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.7.0/bkGby8jb0tmZYsy2hg1E_B2QrCgcSTxdUlHtETwm5m4.tar.br" } imports [pf.Stdout, pf.Stderr, pf.Env, pf.Task.{ Task }] provides [main] to pf diff --git a/examples/cli/false-interpreter/platform/src/lib.rs b/examples/cli/false-interpreter/platform/src/lib.rs index c31692c152..eb48d41bb3 100644 --- a/examples/cli/false-interpreter/platform/src/lib.rs +++ b/examples/cli/false-interpreter/platform/src/lib.rs @@ -49,16 +49,22 @@ pub unsafe extern "C" fn roc_dealloc(c_ptr: *mut c_void, _alignment: u32) { } #[no_mangle] -pub unsafe extern "C" fn roc_panic(c_ptr: *mut c_void, tag_id: u32) { +pub unsafe extern "C" fn roc_panic(msg: *mut RocStr, tag_id: u32) { match tag_id { 0 => { - let slice = CStr::from_ptr(c_ptr as *const c_char); - let string = slice.to_str().unwrap(); - eprintln!("Roc hit a panic: {}", string); - std::process::exit(1); + eprintln!("Roc standard library hit a panic: {}", &*msg); } - _ => todo!(), + 1 => { + eprintln!("Application hit a panic: {}", &*msg); + } + _ => unreachable!(), } + std::process::exit(1); +} + +#[no_mangle] +pub unsafe extern "C" fn roc_dbg(loc: *mut RocStr, msg: *mut RocStr) { + eprintln!("[{}] {}", &*loc, &*msg); } #[no_mangle] diff --git a/examples/cli/fileBROKEN.roc b/examples/cli/fileBROKEN.roc index 172ef73d9f..bc63e5655a 100644 --- a/examples/cli/fileBROKEN.roc +++ b/examples/cli/fileBROKEN.roc @@ -1,5 +1,5 @@ app "file-io" - packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.6.0/QOQW08n38nHHrVVkJNiPIjzjvbR3iMjXeFY5w1aT46w.tar.br" } + packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.7.0/bkGby8jb0tmZYsy2hg1E_B2QrCgcSTxdUlHtETwm5m4.tar.br" } imports [ pf.Stdout, pf.Stderr, diff --git a/examples/cli/form.roc b/examples/cli/form.roc index 48603a9136..3df5cd2d12 100644 --- a/examples/cli/form.roc +++ b/examples/cli/form.roc @@ -1,5 +1,5 @@ app "form" - packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.6.0/QOQW08n38nHHrVVkJNiPIjzjvbR3iMjXeFY5w1aT46w.tar.br" } + packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.7.0/bkGby8jb0tmZYsy2hg1E_B2QrCgcSTxdUlHtETwm5m4.tar.br" } imports [pf.Stdin, pf.Stdout, pf.Task.{ await, Task }] provides [main] to pf diff --git a/examples/cli/http-get.roc b/examples/cli/http-get.roc index 0030c14cf1..a1890bbc27 100644 --- a/examples/cli/http-get.roc +++ b/examples/cli/http-get.roc @@ -1,5 +1,5 @@ app "http-get" - packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.6.0/QOQW08n38nHHrVVkJNiPIjzjvbR3iMjXeFY5w1aT46w.tar.br" } + packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.7.0/bkGby8jb0tmZYsy2hg1E_B2QrCgcSTxdUlHtETwm5m4.tar.br" } imports [pf.Http, pf.Task.{ Task }, pf.Stdin, pf.Stdout] provides [main] to pf diff --git a/examples/cli/ingested-file-bytes.roc b/examples/cli/ingested-file-bytes.roc index 49898c84e1..5f89b21bfa 100644 --- a/examples/cli/ingested-file-bytes.roc +++ b/examples/cli/ingested-file-bytes.roc @@ -1,5 +1,5 @@ app "ingested-file-bytes" - packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.6.0/QOQW08n38nHHrVVkJNiPIjzjvbR3iMjXeFY5w1aT46w.tar.br" } + packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.7.0/bkGby8jb0tmZYsy2hg1E_B2QrCgcSTxdUlHtETwm5m4.tar.br" } imports [ pf.Stdout, "ingested-file.roc" as ownCode : _, # A type hole can also be used here. diff --git a/examples/cli/ingested-file.roc b/examples/cli/ingested-file.roc index 58e1cb2ca8..8c79c1e22c 100644 --- a/examples/cli/ingested-file.roc +++ b/examples/cli/ingested-file.roc @@ -1,5 +1,5 @@ app "ingested-file" - packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.6.0/QOQW08n38nHHrVVkJNiPIjzjvbR3iMjXeFY5w1aT46w.tar.br" } + packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.7.0/bkGby8jb0tmZYsy2hg1E_B2QrCgcSTxdUlHtETwm5m4.tar.br" } imports [ pf.Stdout, "ingested-file.roc" as ownCode : Str, diff --git a/examples/cli/tui-platform/host.zig b/examples/cli/tui-platform/host.zig index 8b8a0d01a6..842b3a8833 100644 --- a/examples/cli/tui-platform/host.zig +++ b/examples/cli/tui-platform/host.zig @@ -113,13 +113,23 @@ export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void { free(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr)))); } -export fn roc_panic(c_ptr: *anyopaque, tag_id: u32) callconv(.C) void { - _ = tag_id; - +export fn roc_panic(msg: *RocStr, tag_id: u32) callconv(.C) void { const stderr = std.io.getStdErr().writer(); - const msg = @as([*:0]const u8, @ptrCast(c_ptr)); - stderr.print("Application crashed with message\n\n {s}\n\nShutting down\n", .{msg}) catch unreachable; - std.process.exit(0); + switch (tag_id) { + 0 => { + stderr.print("Roc standard library crashed with message\n\n {s}\n\nShutting down\n", .{msg.asSlice()}) catch unreachable; + }, + 1 => { + stderr.print("Application crashed with message\n\n {s}\n\nShutting down\n", .{msg.asSlice()}) catch unreachable; + }, + else => unreachable, + } + std.process.exit(1); +} + +export fn roc_dbg(loc: *RocStr, msg: *RocStr) callconv(.C) void { + const stderr = std.io.getStdErr().writer(); + stderr.print("[{s}] {s}\n", .{ loc.asSlice(), msg.asSlice() }) catch unreachable; } export fn roc_memset(dst: [*]u8, value: i32, size: usize) callconv(.C) void { diff --git a/examples/glue/rust-platform/src/lib.rs b/examples/glue/rust-platform/src/lib.rs index e821634b41..3665ed7b43 100644 --- a/examples/glue/rust-platform/src/lib.rs +++ b/examples/glue/rust-platform/src/lib.rs @@ -30,16 +30,22 @@ pub unsafe extern "C" fn roc_dealloc(c_ptr: *mut c_void, _alignment: u32) { } #[no_mangle] -pub unsafe extern "C" fn roc_panic(c_ptr: *mut c_void, tag_id: u32) { +pub unsafe extern "C" fn roc_panic(msg: *mut RocStr, tag_id: u32) { match tag_id { 0 => { - let slice = CStr::from_ptr(c_ptr as *const c_char); - let string = slice.to_str().unwrap(); - eprintln!("Roc hit a panic: {}", string); - std::process::exit(1); + eprintln!("Roc standard library hit a panic: {}", &*msg); } - _ => todo!(), + 1 => { + eprintln!("Application hit a panic: {}", &*msg); + } + _ => unreachable!(), } + std::process::exit(1); +} + +#[no_mangle] +pub unsafe extern "C" fn roc_dbg(loc: *mut RocStr, msg: *mut RocStr) { + eprintln!("[{}] {}", &*loc, &*msg); } #[no_mangle] diff --git a/examples/gui/breakout/platform/src/roc.rs b/examples/gui/breakout/platform/src/roc.rs index 0d346981ee..fe6cbb4a69 100644 --- a/examples/gui/breakout/platform/src/roc.rs +++ b/examples/gui/breakout/platform/src/roc.rs @@ -184,16 +184,22 @@ pub unsafe extern "C" fn roc_dealloc(c_ptr: *mut c_void, _alignment: u32) { } #[no_mangle] -pub unsafe extern "C" fn roc_panic(c_ptr: *mut c_void, tag_id: u32) { +pub unsafe extern "C" fn roc_panic(msg: *mut RocStr, tag_id: u32) { match tag_id { 0 => { - let slice = CStr::from_ptr(c_ptr as *const c_char); - let string = slice.to_str().unwrap(); - eprintln!("Roc hit a panic: {}", string); - std::process::exit(1); + eprintln!("Roc standard library hit a panic: {}", &*msg); } - _ => todo!(), + 1 => { + eprintln!("Application hit a panic: {}", &*msg); + } + _ => unreachable!(), } + std::process::exit(1); +} + +#[no_mangle] +pub unsafe extern "C" fn roc_dbg(loc: *mut RocStr, msg: *mut RocStr) { + eprintln!("[{}] {}", &*loc, &*msg); } #[no_mangle] diff --git a/examples/gui/platform/src/roc.rs b/examples/gui/platform/src/roc.rs index 335679a982..f5b8f0480e 100644 --- a/examples/gui/platform/src/roc.rs +++ b/examples/gui/platform/src/roc.rs @@ -26,16 +26,22 @@ pub unsafe extern "C" fn roc_dealloc(c_ptr: *mut c_void, _alignment: u32) { } #[no_mangle] -pub unsafe extern "C" fn roc_panic(c_ptr: *mut c_void, tag_id: u32) { +pub unsafe extern "C" fn roc_panic(msg: *mut RocStr, tag_id: u32) { match tag_id { 0 => { - let slice = CStr::from_ptr(c_ptr as *const c_char); - let string = slice.to_str().unwrap(); - eprintln!("Roc hit a panic: {}", string); - std::process::exit(1); + eprintln!("Roc standard library hit a panic: {}", &*msg); } - _ => todo!(), + 1 => { + eprintln!("Application hit a panic: {}", &*msg); + } + _ => unreachable!(), } + std::process::exit(1); +} + +#[no_mangle] +pub unsafe extern "C" fn roc_dbg(loc: *mut RocStr, msg: *mut RocStr) { + eprintln!("[{}] {}", &*loc, &*msg); } #[no_mangle] diff --git a/examples/helloWorld.roc b/examples/helloWorld.roc index 50e600dd4e..7a30101ef2 100644 --- a/examples/helloWorld.roc +++ b/examples/helloWorld.roc @@ -1,5 +1,5 @@ app "helloWorld" - packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.6.0/QOQW08n38nHHrVVkJNiPIjzjvbR3iMjXeFY5w1aT46w.tar.br" } + packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.7.0/bkGby8jb0tmZYsy2hg1E_B2QrCgcSTxdUlHtETwm5m4.tar.br" } imports [pf.Stdout] provides [main] to pf diff --git a/examples/inspect-logging.roc b/examples/inspect-logging.roc index 147ad05e26..f9b9c10c91 100644 --- a/examples/inspect-logging.roc +++ b/examples/inspect-logging.roc @@ -2,10 +2,9 @@ # Shows how Roc values can be logged # app "inspect-logging" - packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.6.0/QOQW08n38nHHrVVkJNiPIjzjvbR3iMjXeFY5w1aT46w.tar.br" } + packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.7.0/bkGby8jb0tmZYsy2hg1E_B2QrCgcSTxdUlHtETwm5m4.tar.br" } imports [ pf.Stdout, - LogFormatter, Community, ] provides [main] to pf @@ -36,5 +35,5 @@ main = |> Community.addFriend 0 2 |> Community.addFriend 1 2 |> Inspect.inspect - |> LogFormatter.toStr + |> Inspect.toDbgStr |> Stdout.line diff --git a/examples/jvm-interop/bridge.c b/examples/jvm-interop/bridge.c index 0064c2f564..174d0c7cfd 100644 --- a/examples/jvm-interop/bridge.c +++ b/examples/jvm-interop/bridge.c @@ -275,6 +275,12 @@ __attribute__((noreturn)) void roc_panic(struct RocStr *msg, unsigned int tag_id longjmp(exception_buffer, 1); } +void roc_dbg(struct RocStr *loc, struct RocStr *msg) { + char* loc_bytes = is_small_str(*loc) ? (char*)loc : (char*)loc->bytes; + char* msg_bytes = is_small_str(*msg) ? (char*)msg : (char*)msg->bytes; + fprintf(stderr, "[%s] %s\n", loc_bytes, msg_bytes); +} + extern void roc__programForHost_1__InterpolateString_caller(struct RocStr *name, char *closure_data, struct RocStr *ret); extern void roc__programForHost_1__MulArrByScalar_caller(struct RocListI32 *arr, int32_t *scalar, char *closure_data, struct RocListI32 *ret); diff --git a/examples/nodejs-interop/native-c-api/demo.c b/examples/nodejs-interop/native-c-api/demo.c index 3b257e6d3f..72a3325df4 100644 --- a/examples/nodejs-interop/native-c-api/demo.c +++ b/examples/nodejs-interop/native-c-api/demo.c @@ -27,6 +27,10 @@ void roc_panic(void *ptr, unsigned int alignment) napi_throw_error(napi_global_env, NULL, (char *)ptr); } +void roc_dbg(char* loc, char* msg) { + fprintf(stderr, "[%s] %s\n", loc, msg); +} + void *roc_memset(void *str, int c, size_t n) { return memset(str, c, n); } // Reference counting diff --git a/examples/nodejs-interop/wasm/hello.js b/examples/nodejs-interop/wasm/hello.js index bdad8967bd..41bf9272c1 100644 --- a/examples/nodejs-interop/wasm/hello.js +++ b/examples/nodejs-interop/wasm/hello.js @@ -34,6 +34,10 @@ function hello() { roc_panic: (_pointer, _tag_id) => { throw "Roc panicked!"; }, + roc_dbg: (_loc, _msg) => { + // TODO write a proper impl. + throw "Roc dbg not supported!"; + }, }, }; diff --git a/examples/nodejs-interop/wasm/platform/host.js b/examples/nodejs-interop/wasm/platform/host.js index 956b91e5cf..486776fc66 100644 --- a/examples/nodejs-interop/wasm/platform/host.js +++ b/examples/nodejs-interop/wasm/platform/host.js @@ -26,6 +26,10 @@ async function roc_web_platform_run(wasm_filename, callback) { roc_panic: (_pointer, _tag_id) => { throw "Roc panicked!"; }, + roc_dbg: (_loc, _msg) => { + // TODO write a proper impl. + throw "Roc dbg not supported!"; + }, }, }; diff --git a/examples/nodejs-interop/wasm/platform/host.zig b/examples/nodejs-interop/wasm/platform/host.zig index d6ffcd8e6c..3f1a176fa6 100644 --- a/examples/nodejs-interop/wasm/platform/host.zig +++ b/examples/nodejs-interop/wasm/platform/host.zig @@ -33,7 +33,7 @@ export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void { free(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr)))); } -// NOTE roc_panic is provided in the JS file, so it can throw an exception +// NOTE roc_panic and roc_dbg is provided in the JS file, so it can throw an exception extern fn roc__mainForHost_1_exposed(*RocStr) void; diff --git a/examples/parser/examples/letter-counts.roc b/examples/parser/examples/letter-counts.roc index 23a28cfb27..22ed5b3956 100644 --- a/examples/parser/examples/letter-counts.roc +++ b/examples/parser/examples/letter-counts.roc @@ -1,6 +1,6 @@ app "example" packages { - cli: "https://github.com/roc-lang/basic-cli/releases/download/0.6.0/QOQW08n38nHHrVVkJNiPIjzjvbR3iMjXeFY5w1aT46w.tar.br", + cli: "https://github.com/roc-lang/basic-cli/releases/download/0.7.0/bkGby8jb0tmZYsy2hg1E_B2QrCgcSTxdUlHtETwm5m4.tar.br", parser: "../package/main.roc", } imports [ diff --git a/examples/platform-switching/c-platform/host.c b/examples/platform-switching/c-platform/host.c index 4e863553d9..3683afaa98 100644 --- a/examples/platform-switching/c-platform/host.c +++ b/examples/platform-switching/c-platform/host.c @@ -26,7 +26,11 @@ void roc_panic(void* ptr, unsigned int alignment) { char* msg = (char*)ptr; fprintf(stderr, "Application crashed with message\n\n %s\n\nShutting down\n", msg); - exit(0); + exit(1); +} + +void roc_dbg(char* loc, char* msg) { + fprintf(stderr, "[%s] %s\n", loc, msg); } void* roc_memset(void* str, int c, size_t n) { return memset(str, c, n); } diff --git a/examples/platform-switching/rust-platform/src/lib.rs b/examples/platform-switching/rust-platform/src/lib.rs index f2f832c754..db4490425b 100644 --- a/examples/platform-switching/rust-platform/src/lib.rs +++ b/examples/platform-switching/rust-platform/src/lib.rs @@ -32,16 +32,22 @@ pub unsafe extern "C" fn roc_dealloc(c_ptr: *mut c_void, _alignment: u32) { } #[no_mangle] -pub unsafe extern "C" fn roc_panic(c_ptr: *mut c_void, tag_id: u32) { +pub unsafe extern "C" fn roc_panic(msg: *mut RocStr, tag_id: u32) { match tag_id { 0 => { - let slice = CStr::from_ptr(c_ptr as *const c_char); - let string = slice.to_str().unwrap(); - eprintln!("Roc hit a panic: {}", string); - std::process::exit(1); + eprintln!("Roc standard library hit a panic: {}", &*msg); } - _ => todo!(), + 1 => { + eprintln!("Application hit a panic: {}", &*msg); + } + _ => unreachable!(), } + std::process::exit(1); +} + +#[no_mangle] +pub unsafe extern "C" fn roc_dbg(loc: *mut RocStr, msg: *mut RocStr) { + eprintln!("[{}] {}", &*loc, &*msg); } #[no_mangle] diff --git a/examples/platform-switching/web-assembly-platform/host.js b/examples/platform-switching/web-assembly-platform/host.js index 956b91e5cf..486776fc66 100644 --- a/examples/platform-switching/web-assembly-platform/host.js +++ b/examples/platform-switching/web-assembly-platform/host.js @@ -26,6 +26,10 @@ async function roc_web_platform_run(wasm_filename, callback) { roc_panic: (_pointer, _tag_id) => { throw "Roc panicked!"; }, + roc_dbg: (_loc, _msg) => { + // TODO write a proper impl. + throw "Roc dbg not supported!"; + }, }, }; diff --git a/examples/platform-switching/web-assembly-platform/host.zig b/examples/platform-switching/web-assembly-platform/host.zig index aea2a0f516..b6babf362f 100644 --- a/examples/platform-switching/web-assembly-platform/host.zig +++ b/examples/platform-switching/web-assembly-platform/host.zig @@ -33,7 +33,7 @@ export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void { free(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr)))); } -// NOTE roc_panic is provided in the JS file, so it can throw an exception +// NOTE roc_panic and roc_dbg is provided in the JS file, so it can throw an exception extern fn roc__mainForHost_1_exposed(*RocStr) void; diff --git a/examples/platform-switching/zig-platform/host.zig b/examples/platform-switching/zig-platform/host.zig index 85116e5634..84f1ac0117 100644 --- a/examples/platform-switching/zig-platform/host.zig +++ b/examples/platform-switching/zig-platform/host.zig @@ -44,13 +44,23 @@ export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void { free(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr)))); } -export fn roc_panic(c_ptr: *anyopaque, tag_id: u32) callconv(.C) void { - _ = tag_id; - +export fn roc_panic(msg: *RocStr, tag_id: u32) callconv(.C) void { const stderr = std.io.getStdErr().writer(); - const msg = @as([*:0]const u8, @ptrCast(c_ptr)); - stderr.print("Application crashed with message\n\n {s}\n\nShutting down\n", .{msg}) catch unreachable; - std.process.exit(0); + switch (tag_id) { + 0 => { + stderr.print("Roc standard library crashed with message\n\n {s}\n\nShutting down\n", .{msg.asSlice()}) catch unreachable; + }, + 1 => { + stderr.print("Application crashed with message\n\n {s}\n\nShutting down\n", .{msg.asSlice()}) catch unreachable; + }, + else => unreachable, + } + std.process.exit(1); +} + +export fn roc_dbg(loc: *RocStr, msg: *RocStr) callconv(.C) void { + const stderr = std.io.getStdErr().writer(); + stderr.print("[{s}] {s}\n", .{ loc.asSlice(), msg.asSlice() }) catch unreachable; } export fn roc_memset(dst: [*]u8, value: i32, size: usize) callconv(.C) void { diff --git a/examples/python-interop/demo.c b/examples/python-interop/demo.c index c575b1a947..11c274f001 100644 --- a/examples/python-interop/demo.c +++ b/examples/python-interop/demo.c @@ -27,6 +27,10 @@ __attribute__((noreturn)) void roc_panic(void *ptr, unsigned int alignment) PyErr_SetString(PyExc_RuntimeError, (char *)ptr); } +void roc_dbg(char* loc, char* msg) { + fprintf(stderr, "[%s] %s\n", loc, msg); +} + void *roc_memset(void *str, int c, size_t n) { return memset(str, c, n); } // Reference counting diff --git a/examples/python-interop/platform/host.c b/examples/python-interop/platform/host.c index 2346a57070..7560e3d5fd 100644 --- a/examples/python-interop/platform/host.c +++ b/examples/python-interop/platform/host.c @@ -21,7 +21,11 @@ void roc_panic(void* ptr, unsigned int alignment) { char* msg = (char*)ptr; fprintf(stderr, "Application crashed with message\n\n %s\n\nShutting down\n", msg); - exit(0); + exit(1); +} + +void roc_dbg(char* loc, char* msg) { + fprintf(stderr, "[%s] %s\n", loc, msg); } void* roc_memset(void* str, int c, size_t n) { return memset(str, c, n); } diff --git a/examples/ruby-interop/demo.c b/examples/ruby-interop/demo.c index 43539e7a08..068d8c5daa 100644 --- a/examples/ruby-interop/demo.c +++ b/examples/ruby-interop/demo.c @@ -23,6 +23,10 @@ __attribute__((noreturn)) void roc_panic(void *ptr, unsigned int alignment) rb_raise(rb_eException, "%s", (char *)ptr); } +void roc_dbg(char* loc, char* msg) { + fprintf(stderr, "[%s] %s\n", loc, msg); +} + void *roc_memset(void *str, int c, size_t n) { return memset(str, c, n); } // Reference counting diff --git a/examples/ruby-interop/platform/host.c b/examples/ruby-interop/platform/host.c index ac7093ddf4..1d7b681dbb 100644 --- a/examples/ruby-interop/platform/host.c +++ b/examples/ruby-interop/platform/host.c @@ -21,7 +21,11 @@ void roc_panic(void* ptr, unsigned int alignment) { char* msg = (char*)ptr; fprintf(stderr, "Application crashed with message\n\n %s\n\nShutting down\n", msg); - exit(0); + exit(1); +} + +void roc_dbg(char* loc, char* msg) { + fprintf(stderr, "[%s] %s\n", loc, msg); } void* roc_memmove(void* dest, const void* src, size_t n){ diff --git a/examples/static-site-gen/platform/src/lib.rs b/examples/static-site-gen/platform/src/lib.rs index 7bf0dad0f9..acbe32e079 100644 --- a/examples/static-site-gen/platform/src/lib.rs +++ b/examples/static-site-gen/platform/src/lib.rs @@ -86,16 +86,22 @@ pub extern "C" fn rust_main() -> i32 { } #[no_mangle] -pub unsafe extern "C" fn roc_panic(c_ptr: *mut c_void, tag_id: u32) { +pub unsafe extern "C" fn roc_panic(msg: *mut RocStr, tag_id: u32) { match tag_id { 0 => { - let slice = CStr::from_ptr(c_ptr as *const c_char); - let string = slice.to_str().unwrap(); - eprintln!("Roc hit a panic: {}", string); - std::process::exit(1); + eprintln!("Roc standard library hit a panic: {}", &*msg); } - _ => todo!(), + 1 => { + eprintln!("Application hit a panic: {}", &*msg); + } + _ => unreachable!(), } + std::process::exit(1); +} + +#[no_mangle] +pub unsafe extern "C" fn roc_dbg(loc: *mut RocStr, msg: *mut RocStr) { + eprintln!("[{}] {}", &*loc, &*msg); } #[no_mangle] diff --git a/examples/virtual-dom-wip/platform/src/client-side/host.zig b/examples/virtual-dom-wip/platform/src/client-side/host.zig index 88530e31e9..eb33420650 100644 --- a/examples/virtual-dom-wip/platform/src/client-side/host.zig +++ b/examples/virtual-dom-wip/platform/src/client-side/host.zig @@ -28,12 +28,23 @@ export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void { free(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr)))); } -export fn roc_panic(message: RocStr, tag_id: u32) callconv(.C) void { - _ = tag_id; - const msg = @as([*:0]const u8, @ptrCast(c_ptr)); +export fn roc_panic(msg: *RocStr, tag_id: u32) callconv(.C) void { const stderr = std.io.getStdErr().writer(); - stderr.print("Application crashed with message\n\n {s}\n\nShutting down\n", .{msg}) catch unreachable; - std.process.exit(0); + switch (tag_id) { + 0 => { + stderr.print("Roc standard library crashed with message\n\n {s}\n\nShutting down\n", .{msg.asSlice()}) catch unreachable; + }, + 1 => { + stderr.print("Application crashed with message\n\n {s}\n\nShutting down\n", .{msg.asSlice()}) catch unreachable; + }, + else => unreachable, + } + std.process.exit(1); +} + +export fn roc_dbg(loc: *RocStr, msg: *RocStr) callconv(.C) void { + const stderr = std.io.getStdErr().writer(); + stderr.print("[{s}] {s}\n", .{ loc.asSlice(), msg.asSlice() }) catch unreachable; } const RocList = extern struct { diff --git a/examples/virtual-dom-wip/platform/src/server-side/host.zig b/examples/virtual-dom-wip/platform/src/server-side/host.zig index bc675152ee..4167736ea5 100644 --- a/examples/virtual-dom-wip/platform/src/server-side/host.zig +++ b/examples/virtual-dom-wip/platform/src/server-side/host.zig @@ -28,12 +28,23 @@ export fn roc_dealloc(c_ptr: *anyopaque, alignment: u32) callconv(.C) void { free(@as([*]align(Align) u8, @alignCast(@ptrCast(c_ptr)))); } -export fn roc_panic(c_ptr: *anyopaque, tag_id: u32) callconv(.C) void { - _ = tag_id; - const msg = @as([*:0]const u8, @ptrCast(c_ptr)); +export fn roc_panic(msg: *RocStr, tag_id: u32) callconv(.C) void { const stderr = std.io.getStdErr().writer(); - stderr.print("Application crashed with message\n\n {s}\n\nShutting down\n", .{msg}) catch unreachable; - std.process.exit(0); + switch (tag_id) { + 0 => { + stderr.print("Roc standard library crashed with message\n\n {s}\n\nShutting down\n", .{msg.asSlice()}) catch unreachable; + }, + 1 => { + stderr.print("Application crashed with message\n\n {s}\n\nShutting down\n", .{msg.asSlice()}) catch unreachable; + }, + else => unreachable, + } + std.process.exit(1); +} + +export fn roc_dbg(loc: *RocStr, msg: *RocStr) callconv(.C) void { + const stderr = std.io.getStdErr().writer(); + stderr.print("[{s}] {s}\n", .{ loc.asSlice(), msg.asSlice() }) catch unreachable; } const ResultStrStr = extern struct { diff --git a/www/content/index.md b/www/content/index.md index fb0c5ba903..d0e2bf8b33 100644 --- a/www/content/index.md +++ b/www/content/index.md @@ -54,7 +54,7 @@
- + @@ -144,6 +144,9 @@ If you would like your organization to become an official sponsor of Roc's devel We'd also like to express our gratitude to our generous [individual sponsors](https://github.com/sponsors/roc-lang/)! A special thanks to those sponsoring $25/month or more:
    +
  • Drew Lazzeri +
  • Alex Binaei +
  • Jono Mallanyk
  • Chris Packett
  • James Birtles
  • Ivo Balbaert
    • diff --git a/www/content/repl/index.md b/www/content/repl/index.md index dafb673594..d7a63acdab 100644 --- a/www/content/repl/index.md +++ b/www/content/repl/index.md @@ -8,7 +8,7 @@
    - + diff --git a/www/content/tutorial.md b/www/content/tutorial.md index f4e7f97b2f..b81c77d77b 100644 --- a/www/content/tutorial.md +++ b/www/content/tutorial.md @@ -510,7 +510,7 @@ outside a record field. Optionality is a concept that exists only in record fields, and it's intended for the use case of config records like this. The ergonomics of destructuring mean this wouldn't be a good fit for data modeling, consider using a `Result` type instead. -## [Tags](#tags) {#tags} +## [Tags & Pattern Matching](#tags) {#tags} Sometimes we want to represent that something can have one of several values. For example: @@ -661,6 +661,8 @@ This can be both more concise and more efficient (at runtime) than calling [`Lis > **Note:** Each list pattern can only have one `..`, which is known as the "rest pattern" because it's where the _rest_ of the list goes. +See the [Pattern Matching example](https://www.roc-lang.org/examples/PatternMatching/README.html) which shows different ways to do pattern matching in Roc using tags, strings, and numbers. + ## [Booleans](#booleans) {#booleans} In many programming languages, `true` and `false` are special language keywords that refer to the two [boolean](https://en.wikipedia.org/wiki/Boolean_data_type) values. In Roc, booleans do not get special keywords; instead, they are exposed as the ordinary values `Bool.true` and `Bool.false`. @@ -1491,6 +1493,19 @@ See [Html Interface](https://github.com/roc-lang/roc/blob/main/examples/virtual- See [Platform Switching Rust](https://github.com/roc-lang/roc/blob/main/examples/platform-switching/rust-platform/main.roc) for an example. +### [Importing Files](#importing-files) {#importing-files} + +You can import files directly into your module as a `Str` or a `List U8` at compile time. This is can be useful for when working with data you would like to keep in a separate file, e.g. JSON or YAML configuration. + +```roc +imports [ + "some-file" as someStr : Str, + "some-file" as someBytes : List U8, +] +``` + +See the [Ingest Files Example](https://www.roc-lang.org/examples/IngestFiles/README.html) for a demonstration on using this feature. + ## [Tasks](#tasks) {#tasks} Tasks are technically not part of the Roc language, but they're very common in platforms. Let's continue using the [basic-cli](https://github.com/roc-lang/basic-cli) platform we've been using up to this point as an example! @@ -1685,10 +1700,20 @@ Some important things to note about backpassing and `await`: - Backpassing syntax does not need to be used with `await` in particular. It can be used with any function. - Roc's compiler treats functions defined with backpassing exactly the same way as functions defined the other way. The only difference between `\text ->` and `text <-` is how they look, so feel free to use whichever looks nicer to you! +See the [Task & Error Handling example](https://www.roc-lang.org/examples/Tasks/README.html) for a more detailed explanation of how to use tasks to help with error handling in a larger program. + ## [Abilities](#abilities) {#abilities} \[This part of the tutorial has not been written yet. Coming soon!\] +## Examples + +Well done on making it this far! + +We've covered all of the basic syntax and features of Roc in this Tutorial. You should now have a good foundation and be ready to start writing your own applications. + +You can continue reading through more advanced topics below, or perhaps checkout some of the [Examples](/examples) for more a detailed exploration of ways to do various things. + ## [Appendix: Advanced Concepts](#appendix-advanced-concepts) {#appendix-advanced-concepts} Here are some concepts you likely won't need as a beginner, but may want to know about eventually. This is listed as an appendix rather than the main tutorial, to emphasize that it's totally fine to stop reading here and go build things! @@ -1992,9 +2017,35 @@ For this reason, any time you see a function that only runs a `when` on its only > > Also just like with records, you can use this to compose tag union type aliases. For example, you can write `NetworkError : [Timeout, Disconnected]` and then `Problem : [InvalidInput, UnknownFormat]NetworkError` -### [Phantom Types](#phantom-types) {#phantom-types} +### [Record Builder](#record-builder) {#record-builder} -\[This part of the tutorial has not been written yet. Coming soon!\] +The record builder syntax sugar is a useful feature which leverages the functional programming concept of [applicative functors](https://lucamug.medium.com/functors-applicatives-and-monads-in-pictures-784c2b5786f7), to provide a flexible method for constructing complex types. + +The record builder syntax sugar helps to build up a record by applying a series of functions to it. + +For example, let's say we write a record-builder as follows: + +```roc +{ aliceID, bobID, trudyID } = + initIDCount { + aliceID: <- incID, + bobID: <- incID, + trudyID: <- incID, + } |> extractState +``` + +The above desguars to the following. + +```roc +{ aliceID, bobID, trudyID } = + initIDCount (\aID -> \bID -> \cID -> { aliceID: aID, bobID: bID, trudyID: cID }) + |> incID + |> incID + |> incID + |> extractState +``` + +See the [Record Builder Example](https://www.roc-lang.org/examples/RecordBuilder/README.html) for an explanation of how to use this feature. ### [Reserved Keywords](#reserved-keywords) {#reserved-keywords} diff --git a/www/main.roc b/www/main.roc index 2872a74732..6e98b49afc 100644 --- a/www/main.roc +++ b/www/main.roc @@ -1,7 +1,7 @@ app "roc-website" packages { pf: "../examples/static-site-gen/platform/main.roc" } imports [ - pf.Html.{ Node, html, head, body, header, footer, div, span, main, text, nav, a, link, meta, script }, + pf.Html.{ Node, html, head, body, header, footer, div, span, main, text, nav, a, link, meta, script, br }, pf.Html.Attributes.{ attribute, content, name, id, href, rel, lang, class, title, charset, color, ariaLabel, ariaHidden, type }, InteractiveExample, ] @@ -101,6 +101,13 @@ view = \page, htmlContent -> main [] mainBody, footer [] [ div [id "footer"] [ + div [id "gh-link"] [ + a [id "gh-centered-link", href "https://github.com/roc-lang/roc"] [ + ghLogo, + span [id "gh-link-text"] [text "roc-lang/roc"], + ], + ], + br [] [], text " powered by ", a [href "https://www.netlify.com"] [text "Netlify"], ], @@ -149,3 +156,18 @@ rocLogo = ] [], ] + +ghLogo = + (Html.element "svg") + [ + (Html.attribute "viewBox") "0 0 98 96", + (Html.attribute "height") "25", + (Html.attribute "xmlns") "http://www.w3.org/2000/svg", + (Html.attribute "fill-rule") "evenodd", + (Html.attribute "clip-rule") "evenodd", + (Html.attribute "role") "img", + id "gh-logo", + ] + [ + (Html.element "path") [(Html.attribute "d") "M48.854 0C21.839 0 0 22 0 49.217c0 21.756 13.993 40.172 33.405 46.69 2.427.49 3.316-1.059 3.316-2.362 0-1.141-.08-5.052-.08-9.127-13.59 2.934-16.42-5.867-16.42-5.867-2.184-5.704-5.42-7.17-5.42-7.17-4.448-3.015.324-3.015.324-3.015 4.934.326 7.523 5.052 7.523 5.052 4.367 7.496 11.404 5.378 14.235 4.074.404-3.178 1.699-5.378 3.074-6.6-10.839-1.141-22.243-5.378-22.243-24.283 0-5.378 1.94-9.778 5.014-13.2-.485-1.222-2.184-6.275.486-13.038 0 0 4.125-1.304 13.426 5.052a46.97 46.97 0 0 1 12.214-1.63c4.125 0 8.33.571 12.213 1.63 9.302-6.356 13.427-5.052 13.427-5.052 2.67 6.763.97 11.816.485 13.038 3.155 3.422 5.015 7.822 5.015 13.2 0 18.905-11.404 23.06-22.324 24.283 1.78 1.548 3.316 4.481 3.316 9.126 0 6.6-.08 11.897-.08 13.526 0 1.304.89 2.853 3.316 2.364 19.412-6.52 33.405-24.935 33.405-46.691C97.707 22 75.788 0 48.854 0z"] [], + ] diff --git a/www/public/site.css b/www/public/site.css index 25ae78a5c7..97591f815b 100644 --- a/www/public/site.css +++ b/www/public/site.css @@ -55,7 +55,7 @@ body { width: 100%; height: 100%; box-sizing: border-box; - overflow-x: hidden; /* This shouldn't be necessary, but without it, mobile has a right gutter. */ + overflow-x: hidden; /* This shouldn't be necessary, but without it mobile has a right gutter. */ } p { @@ -1454,16 +1454,27 @@ code .dim { color: var(--cyan); } -.color-white { - /* Really this isn't white so much as "default text color." For the repl, this should be black - in a light color scheme, and only white in dark mode. The name could be better! */ - color: black; +/* Really this isn't white so much as "default text color." For the repl, this should be black + in a light color scheme, and only white in dark mode. The name could be better! +*/ +#homepage-repl-container .color-white { + color: #FFF; +} + +#repl-container .color-white { + color: #000; } @media (prefers-color-scheme: dark) { - .color-white { - color: white; + + #homepage-repl-container .color-white { + color: #FFF; } + + #repl-container .color-white { + color: #FFF; + } + } .bold { @@ -1507,3 +1518,25 @@ code .dim { display: none; } } + +#gh-logo { + fill: var(--text-color); +} + +#gh-link { + display: flex; + justify-content: center; + align-items: center; + margin: 0; +} + +#gh-centered-link { + text-decoration: none; + display: flex; + align-items: center; +} + +#gh-link-text { + margin-left: 8px; + vertical-align: middle; +} \ No newline at end of file diff --git a/www/public/zulip-icon-circle.svg b/www/public/zulip-icon-circle.svg new file mode 100644 index 0000000000..72466de7fb --- /dev/null +++ b/www/public/zulip-icon-circle.svg @@ -0,0 +1 @@ + \ No newline at end of file