Merge remote-tracking branch 'origin/main' into wip-website-updates

.github/workflows/devtools_test_linux_x86_64.yml

@@ -1,38 +1,39 @@
 on:
     pull_request:
   
-name: Test the devtools nix files
+name: devtools nix files test - linux
 
 concurrency:
     group: ${{ github.workflow }}-${{ github.ref }}
     cancel-in-progress: true
 
 jobs:
-    devtools-test:
+    devtools-test-linux:
-        name: devtools-test
+        name: devtools-test-linux
         runs-on: [ubuntu-20.04]
         timeout-minutes: 120
         steps:
             - uses: actions/checkout@v3
 
-            - name: Only run all steps if flake.lock changed
+            - name: Only run all steps if flake.lock or flake.nix changed
               id: checklock
               run: |
-                if git diff --name-only ${{ github.event.before }} ${{ github.sha }} | grep 'flake.lock'; then
+                if git diff --name-only ${{ github.event.before }} ${{ github.sha }} | grep 'flake'; then
-                  echo "Flake.lock was changed. Testing devtools nix files..."
+                  echo "A flake file was changed. Testing devtools nix files..."
-                  echo "::set-output name=changed::true"
+                  echo "flake_changed=true" >> $GITHUB_ENV
                 else
-                  echo "Flake.lock was not changed. No need to run tests."
+                  echo "No flake file was changed. No need to run tests."
-                  echo "::set-output name=changed::false"
+                  echo "flake_changed=false" >> $GITHUB_ENV
                 fi
+            
 
             - uses: cachix/install-nix-action@v23
-              if: steps.checklock.outputs.changed == 'true'
+              if: env.flake_changed == 'true'
               with:
                 nix_path: nixpkgs=channel:nixos-unstable
 
             - name: test devtools/flake.nix
-              if: steps.checklock.outputs.changed == 'true'
+              if: env.flake_changed == 'true'
               id: devtools_test_step
               run: |
                 sed -i "s|/home/username/gitrepos/roc|$(realpath .)|g" devtools/flake.nix

.github/workflows/devtools_test_macos_apple_silicon.yml

@@ -0,0 +1,52 @@
+on:
+    pull_request:
+
+name: devtools nix files test - macos
+
+concurrency:
+    group: ${{ github.workflow }}-${{ github.ref }}
+    cancel-in-progress: true
+
+jobs:
+    devtools-test-macos:
+        name: devtools-test-mac
+        runs-on: [self-hosted, macOS, ARM64]
+        timeout-minutes: 120
+        steps:
+            - uses: actions/checkout@v3
+
+            - name: Only run all steps if flake.lock or flake.nix changed
+              id: checklock
+              run: |
+                if git diff --name-only ${{ github.event.before }} ${{ github.sha }} | grep 'flake'; then
+                  echo "A flake file was changed. Testing devtools nix files..."
+                  echo "flake_changed=true" >> $GITHUB_ENV
+                else
+                  echo "No flake file was changed. No need to run tests."
+                  echo "flake_changed=false" >> $GITHUB_ENV
+                fi
+
+            - name: test devtools/flake.nix
+              if: env.flake_changed == 'true'
+              id: devtools_test_step
+              run: |
+                sed -i '' "s|/home/username/gitrepos/roc|$(realpath .)|g" devtools/flake.nix
+                cat devtools/flake.nix
+                mkdir -p ../temp
+                cp devtools/flake.nix ../temp
+                cp devtools/flake.lock ../temp
+                cd ../temp
+                git init
+                git add flake.nix flake.lock
+                nix develop --show-trace
+
+            - name: Print tip on fail
+              if: env.flake_changed == 'true'
+              run: |
+                echo "The devtools test failed, this can likely be fixed by"
+                echo "locally deleting devtools/flake.lock and following the"
+                echo "instructions in devtools/README.md. This will create a"
+                echo "new flake.lock you should use to replace the old devtools/flake.lock"
+
+
+  

.github/workflows/macos_x86_64.yml

@@ -17,9 +17,7 @@ jobs:
     env:
       RUSTC_WRAPPER: /Users/username1/.cargo/bin/sccache
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
-        with:
-          clean: "true"
 
       - name: test_gen llvm tests
         run: cargo nextest-gen-llvm --release --no-fail-fast --locked -E "package(test_gen) - test(gen_str::str_append_scalar)"

.github/workflows/nix_linux_arm64_cargo.yml

@@ -0,0 +1,26 @@
+on:
+    pull_request:
+    
+name: test cargo build on linux arm64 inside nix
+
+concurrency:
+    group: ${{ github.workflow }}-${{ github.ref }}
+    cancel-in-progress: true
+
+env:
+    RUST_BACKTRACE: 1
+
+jobs:
+    nix-linux-arm64-cargo:
+        name: nix-linux-arm64
+        runs-on: [self-hosted, Linux, ARM64]
+        timeout-minutes: 150
+        steps:
+            - uses: actions/checkout@v3
+
+            - name: test release build
+              run: nix develop -c cargo build --release --locked
+
+            # TODO  
+            #- name: build tests without running
+            #  run: cargo test --no-run --release

.github/workflows/nix_linux_arm64_default.yml

@@ -0,0 +1,22 @@
+on:
+  pull_request:
+  
+name: test default.nix on linux arm64 
+
+concurrency:
+    group: ${{ github.workflow }}-${{ github.ref }}
+    cancel-in-progress: true
+
+env:
+    RUST_BACKTRACE: 1
+
+jobs:
+    nix-linux-arm64-default:
+        name: nix-linux-arm64
+        runs-on: [self-hosted, Linux, ARM64]
+        timeout-minutes: 150
+        steps:
+            - uses: actions/checkout@v3
+               
+            - name: test building default.nix
+              run: nix-build

.github/workflows/nix_linux_x86_64.yml

@@ -17,8 +17,6 @@ jobs:
     timeout-minutes: 90
     steps:
       - uses: actions/checkout@v3
-        with:
-          clean: "true"
           
       - name: test building default.nix
         run: nix-build 

.github/workflows/nix_macos_apple_silicon.yml

@@ -17,8 +17,6 @@ jobs:
     timeout-minutes: 90
     steps:
       - uses: actions/checkout@v3
-        with:
-          clean: "true"
 
       - name: check formatting with rustfmt
         run: nix develop -c cargo fmt --all -- --check
@@ -27,7 +25,7 @@ jobs:
         run: nix develop -c cargo clippy --workspace --tests -- --deny warnings
 
       - name: check code style with clippy --release
-        run: cargo clippy --workspace --tests --release -- --deny warnings
+        run: nix develop -c cargo clippy --workspace --tests --release -- --deny warnings
 
       - name: test building default.nix
         run: nix-build
@@ -42,7 +40,7 @@ jobs:
         run: cd examples/platform-switching/rust-platform && nix develop -c cargo test --release --locked
 
       - name: test aarch64 dev backend
-        run: nix develop -c cargo nextest-gen-dev --locked --release --no-fail-fast -E 'test(gen_num) + test(gen_records)'
+        run: nix develop -c cargo nextest-gen-dev --locked --release --no-fail-fast
 
       # we run the llvm wasm tests only on this machine because it is fast and wasm should be cross-target
       - name: execute llvm wasm tests with --release

.github/workflows/nix_macos_x86_64.yml

@@ -16,9 +16,7 @@ jobs:
     runs-on: [macos-12]
     timeout-minutes: 90
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
-        with:
-          clean: "true"
 
       - uses: cachix/install-nix-action@v22
 

.github/workflows/nix_store_cleanup.yml

@@ -26,9 +26,23 @@ jobs:
       - name: Clean up nix store
         run: nix-store --gc
 
+  clean-nix-store-rpi-1:
+    runs-on: [self-hosted, pi-4-8GB-aarch64]
+    timeout-minutes: 120
+    steps:
+      - name: Clean up nix store
+        run: nix-store --gc
+
+  clean-nix-store-rpi-2:
+    runs-on: [self-hosted, rpiGreen]
+    timeout-minutes: 120
+    steps:
+      - name: Clean up nix store
+        run: nix-store --gc
+
   clean-nix-store-mac-mini-x86-64:
     runs-on: [self-hosted, macOS, X64]
     timeout-minutes: 120
     steps:
       - name: Clean up nix store
-        run: nix-store --gc
+        run: nix-store --gc

.github/workflows/spellcheck.yml

@@ -19,8 +19,6 @@ jobs:
       FORCE_COLOR: 1
     steps:
       - uses: actions/checkout@v3
-        with:
-          clean: "true"
 
       - run: cargo install typos-cli --version 1.0.11
 

.github/workflows/test_nightly_macos_apple_silicon.yml

@@ -14,8 +14,8 @@ jobs:
       - name: get the latest release archive
         run: curl -fOL https://github.com/roc-lang/roc/releases/download/nightly/roc_nightly-macos_apple_silicon-latest.tar.gz
 
-      - name: remove everything in this dir except the tar # we want to test like a user who would have downloaded the release, so we clean up all files from the repo checkout
+      - name: remove everything in this dir except the tar and ci folder # we want to test like a user who would have downloaded the release, so we clean up all files from the repo checkout
-        run: ls | grep -v "roc_nightly.*tar\.gz" | xargs rm -rf
+        run: ls | grep -v "roc_nightly.*tar\.gz" | grep -v "^ci$" | xargs rm -rf
 
       - name: decompress the tar
         run: ls | grep "roc_nightly.*tar\.gz" | xargs tar -xzvf
@@ -38,5 +38,13 @@ jobs:
       - name: test platform switching c
         run: cd roc_nightly && ./roc examples/platform-switching/rocLovesC.roc
 
+      - name: test repl
+        run: |
+          cd ci/repl_basic_test
+          cargo build --release
+          cp target/release/repl_basic_test ../../roc_nightly
+          cd ../../roc_nightly
+          ./repl_basic_test
+
 
         

.github/workflows/test_nightly_many_os.yml

@@ -1,5 +1,4 @@
 on:
-  #pull_request:
   workflow_dispatch:
 
 name: Test latest nightly releases for macOS and Linux x86_64
@@ -21,7 +20,9 @@ jobs:
 
       - name: get the latest release archive for linux (x86_64)
         if: startsWith(matrix.os, 'ubuntu')
-        run: curl -fOL https://github.com/roc-lang/roc/releases/download/nightly/roc_nightly-linux_x86_64-latest.tar.gz
+        run:  | 
+          curl -fOL https://github.com/roc-lang/roc/releases/download/nightly/roc_nightly-linux_x86_64-latest.tar.gz
+
 
       - name: get the latest release archive for macos (x86_64)
         if: startsWith(matrix.os, 'macos')

.github/workflows/ubuntu_x86_64.yml

@@ -18,9 +18,7 @@ jobs:
     env:
       RUSTC_WRAPPER: /home/small-ci-user/.cargo/bin/sccache
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
-        with:
-          clean: "true"
 
       - name: Check for duplicate AUTHORS
         run: diff <(sort AUTHORS) <(sort AUTHORS | uniq) # The < operator treats a string as a file. diff 'succeeds' if no difference.

.github/workflows/windows_release_build.yml

@@ -19,7 +19,7 @@ jobs:
 
     timeout-minutes: 150
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
 
       - run: Add-Content -Path "$env:GITHUB_ENV" -Value "GITHUB_RUNNER_CPU=$((Get-CimInstance Win32_Processor).Name)"
 
@@ -33,8 +33,8 @@ jobs:
       - name: zig version
         run: zig version
 
-      - name: install rust nightly 1.70.0
+      - name: install rust nightly 1.71.0
-        run: rustup install nightly-2023-04-15
+        run: rustup install nightly-2023-05-28
 
       - name: set up llvm 13
         run: |

.github/workflows/windows_tests.yml

@@ -19,7 +19,7 @@ jobs:
 
     timeout-minutes: 150
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
 
       - run: Add-Content -Path "$env:GITHUB_ENV" -Value "GITHUB_RUNNER_CPU=$((Get-CimInstance Win32_Processor).Name)"
 
@@ -41,8 +41,8 @@ jobs:
           cd crates\compiler\builtins\bitcode\
           zig build test
 
-      - name: install rust nightly 1.70.0
+      - name: install rust nightly 1.71.0
-        run: rustup install nightly-2023-04-15
+        run: rustup install nightly-2023-05-28
 
       - name: set up llvm 13
         run: |

Cargo.lock

@@ -526,6 +526,16 @@ version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "13418e745008f7349ec7e449155f419a61b92b58a99cc3616942b926825ec76b"
 
+[[package]]
+name = "core-foundation"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "194a7a9e6de53fa55116934067c844d9d749312f75c6f6d0980e8c252f8c2146"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
 [[package]]
 name = "core-foundation-sys"
 version = "0.8.4"
@@ -1185,10 +1195,11 @@ dependencies = [
 
 [[package]]
 name = "hyper-rustls"
-version = "0.23.2"
+version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1788965e61b367cd03a62950836d5cd41560c3577d90e40e0819373194d1661c"
+checksum = "8d78e1e73ec14cf7375674f74d7dde185c8206fd9dea6fb6295e8a98098aaa97"
 dependencies = [
+ "futures-util",
  "http",
  "hyper",
  "rustls",
@@ -1863,9 +1874,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.57"
+version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4ec6d5fe0b140acb27c9a0444118cf55bfbb4e0b259739429abb4521dd67c16"
+checksum = "134c189feb4956b20f6f547d2cf727d4c0fe06722b20a0eec87ed445a97f92da"
 dependencies = [
  "unicode-ident",
 ]
@@ -2129,9 +2140,9 @@ dependencies = [
 
 [[package]]
 name = "reqwest"
-version = "0.11.17"
+version = "0.11.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13293b639a097af28fc8a90f22add145a9c954e49d77da06263d58cf44d5fb91"
+checksum = "046cd98826c46c2ac8ddecae268eb5c2e58628688a5fc7a2643704a73faba95b"
 dependencies = [
  "base64 0.21.0",
  "bytes",
@@ -2155,6 +2166,7 @@ dependencies = [
  "serde",
  "serde_json",
  "serde_urlencoded",
+ "system-configuration",
  "tokio",
  "tokio-rustls",
  "tower-service",
@@ -3143,9 +3155,9 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "0.37.19"
+version = "0.37.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "acf8729d8542766f1b2cf77eb034d52f40d375bb8b615d0b147089946e16613d"
+checksum = "d4eb579851244c2c03e7c24f501c3432bed80b8f720af1d6e5b0e0f01555a035"
 dependencies = [
  "bitflags",
  "errno",
@@ -3157,14 +3169,14 @@ dependencies = [
 
 [[package]]
 name = "rustls"
-version = "0.20.8"
+version = "0.21.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fff78fc74d175294f4e83b28343315ffcfb114b156f0185e9741cb5570f50e2f"
+checksum = "cd8d6c9f025a446bc4d18ad9632e69aec8f287aa84499ee335599fabd20c3fd8"
 dependencies = [
  "log",
  "ring",
+ "rustls-webpki",
  "sct",
- "webpki",
 ]
 
 [[package]]
@@ -3176,6 +3188,16 @@ dependencies = [
  "base64 0.21.0",
 ]
 
+[[package]]
+name = "rustls-webpki"
+version = "0.101.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c7d5dece342910d9ba34d259310cae3e0154b873b35408b787b59bce53d34fe"
+dependencies = [
+ "ring",
+ "untrusted",
+]
+
 [[package]]
 name = "rustversion"
 version = "1.0.12"
@@ -3598,6 +3620,27 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "system-configuration"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba3a3adc5c275d719af8cb4272ea1c4a6d668a777f37e115f6d11ddbc1c8e0e7"
+dependencies = [
+ "bitflags",
+ "core-foundation",
+ "system-configuration-sys",
+]
+
+[[package]]
+name = "system-configuration-sys"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75fb188eb626b924683e3b95e3a48e63551fcfb51949de2f06a9d91dbee93c9"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
 [[package]]
 name = "tap"
 version = "1.0.1"
@@ -3909,13 +3952,12 @@ dependencies = [
 
 [[package]]
 name = "tokio-rustls"
-version = "0.23.4"
+version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c43ee83903113e03984cb9e5cebe6c04a5116269e900e3ddba8f068a62adda59"
+checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081"
 dependencies = [
  "rustls",
  "tokio",
- "webpki",
 ]
 
 [[package]]
@@ -4342,24 +4384,11 @@ dependencies = [
  "wasm-bindgen",
 ]
 
-[[package]]
-name = "webpki"
-version = "0.22.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0e74f82d49d545ad128049b7e88f6576df2da6b02e9ce565c6f533be576957e"
-dependencies = [
- "ring",
- "untrusted",
-]
-
 [[package]]
 name = "webpki-roots"
-version = "0.22.6"
+version = "0.25.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6c71e40d7d2c34a5106301fb632274ca37242cd0c9d3e64dbece371a40a2d87"
+checksum = "14247bb57be4f377dfb94c72830b8ce8fc6beac03cf4bf7b9732eadd414123fc"
-dependencies = [
- "webpki",
-]
 
 [[package]]
 name = "winapi"
@@ -4550,11 +4579,12 @@ checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a"
 
 [[package]]
 name = "winreg"
-version = "0.10.1"
+version = "0.50.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80d0f4e272c85def139476380b12f9ac60926689dd2e01d4923222f40580869d"
+checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1"
 dependencies = [
- "winapi",
+ "cfg-if",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]

Cargo.toml

@@ -30,6 +30,7 @@ members = [
 
 exclude = [
   "ci/benchmarks/bench-runner",
+  "ci/repl_basic_test",
   # Examples sometimes have Rust hosts in their platforms. The compiler should ignore those.
   "crates/cli_testing_examples",
   "examples",
@@ -127,7 +128,7 @@ perfcnt = "0.8.0"
 pest = "2.5.6"
 pest_derive = "2.5.6"
 pretty_assertions = "1.3.0" # update roc_std/Cargo.toml on change
-proc-macro2 = "1.0.51"
+proc-macro2 = "1.0.63"
 proptest = "1.1.0"
 pulldown-cmark = { version = "0.9.2", default-features = false }
 quickcheck = "1.0.3" # update roc_std/Cargo.toml on change
@@ -136,7 +137,7 @@ quote = "1.0.23"
 rand = "0.8.5"
 regex = "1.7.1"
 remove_dir_all = "0.8.1"
-reqwest = { version = "0.11.14", default-features = false, features = ["blocking", "rustls-tls"] }                       # default-features=false removes libopenssl as a dependency on Linux, which might not be available!
+reqwest = { version = "0.11.20", default-features = false, features = ["blocking", "rustls-tls"] }                       # default-features=false removes libopenssl as a dependency on Linux, which might not be available!
 rlimit = "0.9.1"
 rustyline = { git = "https://github.com/roc-lang/rustyline", rev = "e74333c" }
 rustyline-derive = { git = "https://github.com/roc-lang/rustyline", rev = "e74333c" }
@@ -174,16 +175,23 @@ wyhash = "0.5.0"
 # Optimizations based on https://deterministic.space/high-performance-rust.html
 [profile.release]
 codegen-units = 1
-
 # debug = true # enable when profiling
+
+[profile.dev]
+debug = "line-tables-only"
+
 [profile.bench]
 codegen-units = 1
 lto = "thin"
 
 [profile.release-with-debug]
-debug = true
 inherits = "release"
+debug = true
 
 [profile.release-with-lto]
-lto = "thin" # TODO: We could consider full here since this is only used for packaged release on github.
 inherits = "release"
+lto = "thin" # TODO: We could consider full here since this is only used for packaged release on github.
+
+[profile.debug-full]
+inherits = "dev"
+debug = true

Earthfile

@@ -1,6 +1,6 @@
 
 VERSION 0.6
-FROM rust:1.70.0-slim-buster # make sure to update rust-toolchain.toml too so that everything uses the same rust version
+FROM rust:1.71.1-slim-buster # make sure to update rust-toolchain.toml too so that everything uses the same rust version
 WORKDIR /earthbuild
 
 prep-debian:

FAQ.md

@@ -293,8 +293,8 @@ The way `|>` works in Roc has a second benefit when it comes to higher-order fun
 answer = List.map numbers \num ->
     someFunction
         "some argument"
+        num
         anotherArg
-        someOtherArg
 ```
 
 ```elixir
@@ -312,8 +312,8 @@ This means the first example would have to change from this...
 answer = List.map numbers \num ->
     someFunction
         "some argument"
+        num
         anotherArg
-        someOtherArg
 ```
 
 ...to this:
@@ -324,8 +324,8 @@ answer =
         (\num ->
             someFunction
                 "some argument"
+                num
                 anotherArg
-                someOtherArg
         )
         numbers
 ```

LEGAL_DETAILS

@@ -171,7 +171,7 @@ limitations under the License.
 
 * Zig - https://ziglang.org
 
-This source code can be found in compiler/builtins/bitcode/src/hash.zig, highlight/tests/peg_grammar.rs and highlight/src/highlight_parser.rs and is licensed under the following terms:
+This source code can be found in highlight/tests/peg_grammar.rs and highlight/src/highlight_parser.rs and is licensed under the following terms:
 
 
 The MIT License (Expat)

ci/basic_nightly_test.sh

@@ -31,6 +31,7 @@ cd roc_nightly
 # test roc hello world
 ./roc examples/helloWorld.roc
 
+# test rust platform
 ./roc examples/platform-switching/rocLovesRust.roc
 
 run_zig_test=true
@@ -47,9 +48,19 @@ if [[ "$(uname)" == "Darwin" ]]; then
 fi
 
 if $run_zig_test ; then
+    # test zig platform
     ./roc examples/platform-switching/rocLovesZig.roc
 fi
 
+# test C platform
 ./roc examples/platform-switching/rocLovesC.roc
 
+# test repl
+cd ../ci/repl_basic_test
+cargo build --release
+cp target/release/repl_basic_test ../../roc_nightly
+cd ../../roc_nightly
+./repl_basic_test
+
+
 cd ..

ci/repl_basic_test/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "repl_basic_test"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+rexpect = "0.5.0"

ci/repl_basic_test/src/main.rs

@@ -0,0 +1,36 @@
+use rexpect::error::Error;
+use rexpect::session::PtyReplSession;
+use rexpect::spawn;
+use std::thread;
+use std::time::Duration;
+
+fn roc_repl_session() -> Result<PtyReplSession, Error> {
+    let roc_repl = PtyReplSession {
+        echo_on: false,
+        prompt: "\u{1b}[0K\u{1b}[34m»\u{1b}[0m ".to_string(),
+        pty_session: spawn("./roc repl", Some(7000))?,
+        quit_command: None,
+    };
+    thread::sleep(Duration::from_secs(1));
+    Ok(roc_repl)
+}
+
+fn main() -> Result<(), Error> {
+    let mut repl = roc_repl_session()?;
+    
+    repl.exp_regex(".*roc repl.*")?;
+    repl.send_line("1+1")?;
+    
+    thread::sleep(Duration::from_secs(1));
+
+    match repl.exp_regex(r".*2\u{1b}\[35m : \u{1b}\[0mNum *.*") {
+        Ok((a, b)) => {
+            println!("Expected output received.");
+            return Ok(());
+        }
+        Err(_) => {
+            eprintln!("\nError: output was different from expected value.");
+            std::process::exit(1);
+        }
+    }
+}

crates/cli/tests/cli_run.rs

@@ -561,7 +561,6 @@ mod cli_run {
     }
 
     #[test]
-    #[cfg_attr(windows, ignore)]
     fn expects_dev_and_test() {
         // these are in the same test function so we don't have to worry about race conditions
         // on the building of the platform
@@ -647,7 +646,10 @@ mod cli_run {
     }
 
     #[test]
-    #[cfg_attr(windows, ignore)]
+    #[cfg_attr(
+        windows,
+        ignore = "Flaky failure: Roc command failed with status ExitStatus(ExitStatus(3221225477))"
+    )]
     fn fibonacci() {
         test_roc_app_slim(
             "crates/cli_testing_examples/algorithms",
@@ -791,7 +793,7 @@ mod cli_run {
     }
 
     #[test]
-    #[cfg_attr(windows, ignore)]
+    #[cfg_attr(any(target_os = "windows", target_os = "linux"), ignore = "Segfault")]
     fn false_interpreter() {
         test_roc_app(
             "examples/cli/false-interpreter",
@@ -1352,7 +1354,10 @@ mod cli_run {
 
     #[test]
     #[serial(multi_dep_thunk)]
-    #[cfg_attr(windows, ignore)]
+    #[cfg_attr(
+        windows,
+        ignore = "Flaky failure: Roc command failed with status ExitStatus(ExitStatus(3221225477))"
+    )]
     fn run_multi_dep_thunk_optimized() {
         check_output_with_stdin(
             &fixture_file("multi-dep-thunk", "Main.roc"),

crates/compiler/arena_pool/src/pool.rs

@@ -205,7 +205,7 @@ impl<T> ArenaPool<T> {
         // Add the arena's extra chunks to our own, so their memory remains live
         // after the arena gets dropped. This is important, because at this
         // point their pointers can still potentially be dereferenced!
-        self.extra_chunks.extend(arena.extra_chunks.into_iter());
+        self.extra_chunks.extend(arena.extra_chunks);
 
         self.num_leased -= 1;
     }

crates/compiler/build/src/link.rs

@@ -531,7 +531,7 @@ pub fn rebuild_host(
             // on windows, we need the nightly toolchain so we can use `-Z export-executable-symbols`
             // using `+nightly` only works when running cargo through rustup
             let mut cmd = rustup();
-            cmd.args(["run", "nightly-2023-04-15", "cargo"]);
+            cmd.args(["run", "nightly-2023-05-28", "cargo"]);
 
             cmd
         } else {
@@ -548,7 +548,7 @@ pub fn rebuild_host(
             let rust_flags = if cfg!(windows) {
                 "-Z export-executable-symbols"
             } else {
-                "-C link-dead-code"
+                "-C link-args=-rdynamic"
             };
             cargo_cmd.env("RUSTFLAGS", rust_flags);
             cargo_cmd.args(["--bin", "host"]);
@@ -918,10 +918,15 @@ fn link_linux(
                     eprintln!("You may need to install libgcc\n");
                 }
                 if maybe_crti.is_none() | maybe_crtn.is_none() | maybe_scrt1.is_none() {
-                    eprintln!("Couldn't find the glibc development files!");
+                    eprintln!("Couldn't find the libc development files!");
-                    eprintln!("We need the objects crti.o, crtn.o, and Scrt1.o");
+                    eprintln!("We need the files crti.o, crtn.o, and Scrt1.o");
-                    eprintln!("You may need to install the glibc development package");
+                    eprintln!();
-                    eprintln!("(probably called glibc-dev or glibc-devel)\n");
+                    eprintln!("On Ubuntu/Debian execute:");
+                    eprintln!("\tsudo apt install libc-dev\n");
+                    eprintln!("On ArchLinux/Manjaro execute:");
+                    eprintln!("\tsudo pacman -S glibc\n");
+                    eprintln!("On Fedora execute:");
+                    eprintln!("\tsudo dnf install glibc-devel\n");
                 }
 
                 let dirs = lib_dirs

crates/compiler/build/src/program.rs

@@ -41,7 +41,6 @@ pub struct CodeGenTiming {
 
 pub fn report_problems_monomorphized(loaded: &mut MonomorphizedModule) -> Problems {
     report_problems(
-        loaded.total_problems(),
         &loaded.sources,
         &loaded.interns,
         &mut loaded.can_problems,
@@ -51,7 +50,6 @@ pub fn report_problems_monomorphized(loaded: &mut MonomorphizedModule) -> Proble
 
 pub fn report_problems_typechecked(loaded: &mut LoadedModule) -> Problems {
     report_problems(
-        loaded.total_problems(),
         &loaded.sources,
         &loaded.interns,
         &mut loaded.can_problems,

crates/compiler/build/src/target.rs

@@ -149,19 +149,24 @@ pub fn target_machine(
 
     init_arch(target);
 
-    // We used to have a problem that LLVM 12 would not compile our programs without a large code model.
+    let code_model = match target {
-    // The reason was not totally clear to us, but one guess is a few special-cases in
+        Triple {
-    //   llvm/lib/Target/AArch64/AArch64ISelLowering.cpp (instructions)
+            operating_system: OperatingSystem::Darwin,
-    //   llvm/lib/Target/AArch64/AArch64Subtarget.cpp (GoT tables)
+            architecture: Architecture::Aarch64(_),
-    // Revisit when upgrading to LLVM 13.
+            ..
-    //
+        } => {
-    // Most recently, we seem to only see this problem on macOS ARM64; removing this
+            // We used to have a problem that LLVM 12 would not compile our programs without a large code model.
-    // failed macOS CI here: https://github.com/roc-lang/roc/pull/5644
+            // The reason was not totally clear to us, but one guess is a few special-cases in
-    #[cfg(all(target_arch = "aarch64", target_os = "macos"))]
+            //   llvm/lib/Target/AArch64/AArch64ISelLowering.cpp (instructions)
-    let code_model = CodeModel::Large;
+            //   llvm/lib/Target/AArch64/AArch64Subtarget.cpp (GoT tables)
-
+            // Revisit when upgrading to LLVM 13.
-    #[cfg(not(all(target_arch = "aarch64", target_os = "macos")))]
+            //
-    let code_model = CodeModel::Default;
+            // Most recently, we seem to only see this problem on macOS ARM64; removing this
+            // failed macOS CI here: https://github.com/roc-lang/roc/pull/5644
+            CodeModel::Large
+        }
+        _ => CodeModel::Default,
+    };
 
     Target::from_name(arch).unwrap().create_target_machine(
         &TargetTriple::create(target_triple_str(target)),

crates/compiler/builtins/bitcode/benchmark/dec.zig

@@ -24,19 +24,25 @@ pub fn main() !void {
     try stdout.print("Warning: Timer seems to step in units of 41ns\n\n", .{});
     timer = try Timer.start();
 
-    const n = 10000;
+    const n = 1000;
+
+    // Add/Sub are too fast and need a higher n.
+    const add_sub_n = 10000;
 
     // This number are very close to 1 to avoid over and underflow.
-    const str1 = "1.00123";
     const f1 = 1.00123;
-    const dec1 = RocDec.fromStr(RocStr.init(str1, 3)).?;
+    const dec1 = RocDec.fromF64(f1).?;
+
+    // `asin` and `acos` have a limited range, so they will use this value.
+    const f2 = 0.00130000847;
+    const dec2 = RocDec.fromF64(f2).?;
 
     try stdout.print("Dec:\n", .{});
-    try stdout.print("{} additions took ", .{n});
+    try stdout.print("{} additions took ", .{add_sub_n});
-    const decAdd = try avg_runs(RocDec, n, RocDec.add, dec1);
+    const decAdd = try avg_runs(RocDec, add_sub_n, RocDec.add, dec1);
 
-    try stdout.print("{} subtractions took ", .{n});
+    try stdout.print("{} subtractions took ", .{add_sub_n});
-    const decSub = try avg_runs(RocDec, n, RocDec.sub, dec1);
+    const decSub = try avg_runs(RocDec, add_sub_n, RocDec.sub, dec1);
 
     try stdout.print("{} multiplications took ", .{n});
     const decMul = try avg_runs(RocDec, n, RocDec.mul, dec1);
@@ -47,15 +53,27 @@ pub fn main() !void {
     try stdout.print("{} sin took ", .{n});
     const decSin = try avg_runs(RocDec, n, sinDec, dec1);
 
+    try stdout.print("{} cos took ", .{n});
+    const decCos = try avg_runs(RocDec, n, cosDec, dec1);
+
+    try stdout.print("{} tan took ", .{n});
+    const decTan = try avg_runs(RocDec, n, tanDec, dec1);
+
     try stdout.print("{} asin took ", .{n});
-    const decAsin = try avg_runs(RocDec, n, asinDec, dec1);
+    const decAsin = try avg_runs(RocDec, n, asinDec, dec2);
+
+    try stdout.print("{} acos took ", .{n});
+    const decAcos = try avg_runs(RocDec, n, acosDec, dec2);
+
+    try stdout.print("{} atan took ", .{n});
+    const decAtan = try avg_runs(RocDec, n, atanDec, dec1);
 
     try stdout.print("\n\nF64:\n", .{});
-    try stdout.print("{} additions took ", .{n});
+    try stdout.print("{} additions took ", .{add_sub_n});
-    const f64Add = try avg_runs(f64, n, addF64, f1);
+    const f64Add = try avg_runs(f64, add_sub_n, addF64, f1);
 
-    try stdout.print("{} subtractions took ", .{n});
+    try stdout.print("{} subtractions took ", .{add_sub_n});
-    const f64Sub = try avg_runs(f64, n, subF64, f1);
+    const f64Sub = try avg_runs(f64, add_sub_n, subF64, f1);
 
     try stdout.print("{} multiplications took ", .{n});
     const f64Mul = try avg_runs(f64, n, mulF64, f1);
@@ -66,8 +84,20 @@ pub fn main() !void {
     try stdout.print("{} sin took ", .{n});
     const f64Sin = try avg_runs(f64, n, sinF64, f1);
 
+    try stdout.print("{} cos took ", .{n});
+    const f64Cos = try avg_runs(f64, n, cosF64, f1);
+
+    try stdout.print("{} tan took ", .{n});
+    const f64Tan = try avg_runs(f64, n, tanF64, f1);
+
     try stdout.print("{} asin took ", .{n});
-    const f64Asin = try avg_runs(f64, n, asinF64, f1);
+    const f64Asin = try avg_runs(f64, n, asinF64, f2);
+
+    try stdout.print("{} acos took ", .{n});
+    const f64Acos = try avg_runs(f64, n, acosF64, f2);
+
+    try stdout.print("{} atan took ", .{n});
+    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)});
@@ -75,67 +105,72 @@ pub fn main() !void {
     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)});
 }
 
-fn avg_runs(comptime T: type, comptime n: usize, op: fn (T, T) T, v: T) !u64 {
+fn avg_runs(comptime T: type, comptime n: usize, comptime op: fn (T, T) T, v: T) !u64 {
     const stdout = std.io.getStdOut().writer();
 
-    const repeats = 1000;
+    const warmups = 10000;
-    var runs = [_]u64{0} ** repeats;
+    const repeats = 10000;
+    var runs = [_]u64{0} ** (warmups + repeats);
 
     var i: usize = 0;
-    while (i < repeats) : (i += 1) {
+    while (i < warmups + repeats) : (i += 1) {
-        runs[i] = run(T, n, op, v);
+        // Never inline run to ensure it doesn't optimize for the value of `v`.
+        runs[i] = callWrapper(u64, .never_inline, run, .{ T, n, op, v });
     }
 
-    std.sort.sort(u64, &runs, {}, comptime std.sort.asc(u64));
+    var real_runs = runs[warmups..runs.len];
+    std.sort.sort(u64, real_runs, {}, comptime std.sort.asc(u64));
 
-    const median = runs[runs.len / 2];
+    const median = real_runs[real_runs.len / 2];
-    const highest = runs[runs.len - 1];
+    const highest = real_runs[real_runs.len - 1];
-    const lowest = runs[0];
+    const lowest = real_runs[0];
 
     try stdout.print("{}ns (lowest: {}ns, highest: {}ns)\n", .{ median, lowest, highest });
     return median;
 }
 
-fn run(comptime T: type, comptime n: usize, op: fn (T, T) T, v: T) u64 {
+fn run(comptime T: type, comptime n: usize, comptime op: fn (T, T) T, v: T) u64 {
     var a = v;
     timer.reset();
 
     // Split into outer and inner loop to avoid breaking comptime.
-    comptime var outer = n / 500;
+    const max_inline = 100;
-    comptime var inner = std.math.min(n, 500);
+    comptime var outer = n / max_inline;
+    comptime var inner = std.math.min(n, max_inline);
     var i: usize = 0;
     while (i < outer) : (i += 1) {
         comptime var j = 0;
         inline while (j < inner) : (j += 1) {
-            a = op(a, v);
+            a = callWrapper(T, .always_inline, op, .{ a, v });
-
-            // Clobber a to avoid optimizations and removal of dead code.
-            asm volatile (""
-                :
-                : [a] "r,m" (&a),
-                : "memory"
-            );
         }
     }
-    comptime var rem = n % 500;
+    const rem = n % max_inline;
-    i = 0;
+    comptime var j = 0;
-    inline while (i < rem) : (i += 1) {
+    inline while (j < rem) : (j += 1) {
-        a = op(a, v);
+        a = callWrapper(T, .always_inline, op, .{ a, v });
-
-        // Clobber a to avoid optimizations and removal of dead code.
-        asm volatile (""
-            :
-            : [a] "r,m" (&a),
-            : "memory"
-        );
     }
 
+    // Clobber `a` to avoid removal as dead code.
+    asm volatile (""
+        :
+        : [a] "r,m" (&a),
+        : "memory"
+    );
     return timer.read();
 }
 
+// This is needed to work around a bug with using `@call` in loops.
+inline fn callWrapper(comptime T: type, call_modifier: anytype, comptime func: anytype, params: anytype) T {
+    return @call(.{ .modifier = call_modifier }, func, params);
+}
+
 fn addF64(x: f64, y: f64) f64 {
     return x + y;
 }
@@ -151,13 +186,43 @@ fn divF64(x: f64, y: f64) f64 {
 fn sinF64(x: f64, _: f64) f64 {
     return std.math.sin(x);
 }
+fn cosF64(x: f64, _: f64) f64 {
+    return std.math.cos(x);
+}
+fn tanF64(x: f64, _: f64) f64 {
+    return std.math.tan(x);
+}
 fn asinF64(x: f64, _: f64) f64 {
     return std.math.asin(x);
 }
+const pi_over_2 = std.math.pi / 2.0;
+fn acosF64(x: f64, _: f64) f64 {
+    // acos is only stable if we subtract pi/2.
+    // The perf should be essentially the same because subtraction is much faster than acos.
+    return std.math.acos(x) - pi_over_2;
+}
+fn atanF64(x: f64, _: f64) f64 {
+    return std.math.atan(x);
+}
 
 fn sinDec(x: RocDec, _: RocDec) RocDec {
     return x.sin();
 }
+fn cosDec(x: RocDec, _: RocDec) RocDec {
+    return x.cos();
+}
+fn tanDec(x: RocDec, _: RocDec) RocDec {
+    return x.tan();
+}
 fn asinDec(x: RocDec, _: RocDec) RocDec {
     return x.asin();
 }
+const pi_over_2_dec = RocDec.fromF64(pi_over_2).?;
+fn acosDec(x: RocDec, _: RocDec) RocDec {
+    // acos is only stable if we subtract pi/2.
+    // The perf should be essentially the same because subtraction is much faster than acos.
+    return x.acos().sub(pi_over_2_dec);
+}
+fn atanDec(x: RocDec, _: RocDec) RocDec {
+    return x.atan();
+}

crates/compiler/builtins/bitcode/src/dec.zig

@@ -235,6 +235,11 @@ pub const RocDec = extern struct {
         return if (negated) |n| .{ .num = n } else null;
     }
 
+    pub fn abs(self: RocDec) !RocDec {
+        const absolute = try math.absInt(self.num);
+        return RocDec{ .num = absolute };
+    }
+
     pub fn addWithOverflow(self: RocDec, other: RocDec) WithOverflow(RocDec) {
         var answer: i128 = undefined;
         const overflowed = @addWithOverflow(i128, self.num, other.num, &answer);
@@ -1244,6 +1249,11 @@ pub fn negateC(arg: RocDec) callconv(.C) i128 {
     return if (@call(.{ .modifier = always_inline }, RocDec.negate, .{arg})) |dec| dec.num else @panic("TODO overflow for negating RocDec");
 }
 
+pub fn absC(arg: RocDec) callconv(.C) i128 {
+    const result = @call(.{ .modifier = always_inline }, RocDec.abs, .{arg}) catch @panic("TODO overflow for calling absolute value on RocDec");
+    return result.num;
+}
+
 pub fn addC(arg1: RocDec, arg2: RocDec) callconv(.C) WithOverflow(RocDec) {
     return @call(.{ .modifier = always_inline }, RocDec.addWithOverflow, .{ arg1, arg2 });
 }

crates/compiler/builtins/bitcode/src/hash.zig

@@ -1,254 +0,0 @@
-// SPDX-License-Identifier: MIT
-// Copyright (c) 2015-2021 Zig Contributors
-// This file is part of [zig](https://ziglang.org/), which is MIT licensed.
-// The MIT license requires this copyright notice to be included in all copies
-// and substantial portions of the software.
-const std = @import("std");
-const str = @import("str.zig");
-const mem = std.mem;
-
-pub fn wyhash(seed: u64, bytes: ?[*]const u8, length: usize) callconv(.C) u64 {
-    if (bytes) |nonnull| {
-        const slice = nonnull[0..length];
-        return wyhash_hash(seed, slice);
-    } else {
-        return 42;
-    }
-}
-
-pub fn wyhash_rocstr(seed: u64, input: str.RocStr) callconv(.C) u64 {
-    return wyhash_hash(seed, input.asSlice());
-}
-
-const primes = [_]u64{
-    0xa0761d6478bd642f,
-    0xe7037ed1a0b428db,
-    0x8ebc6af09c88c6e3,
-    0x589965cc75374cc3,
-    0x1d8e4e27c47d124f,
-};
-
-fn read_bytes(comptime bytes: u8, data: []const u8) u64 {
-    const T = std.meta.Int(.unsigned, 8 * bytes);
-    return mem.readIntLittle(T, data[0..bytes]);
-}
-
-fn read_8bytes_swapped(data: []const u8) u64 {
-    return (read_bytes(4, data) << 32 | read_bytes(4, data[4..]));
-}
-
-fn mum(a: u64, b: u64) u64 {
-    var r = std.math.mulWide(u64, a, b);
-    r = (r >> 64) ^ r;
-    return @truncate(u64, r);
-}
-
-fn mix0(a: u64, b: u64, seed: u64) u64 {
-    return mum(a ^ seed ^ primes[0], b ^ seed ^ primes[1]);
-}
-
-fn mix1(a: u64, b: u64, seed: u64) u64 {
-    return mum(a ^ seed ^ primes[2], b ^ seed ^ primes[3]);
-}
-
-// Wyhash version which does not store internal state for handling partial buffers.
-// This is needed so that we can maximize the speed for the short key case, which will
-// use the non-iterative api which the public Wyhash exposes.
-const WyhashStateless = struct {
-    seed: u64,
-    msg_len: usize,
-
-    pub fn init(seed: u64) WyhashStateless {
-        return WyhashStateless{
-            .seed = seed,
-            .msg_len = 0,
-        };
-    }
-
-    fn round(self: *WyhashStateless, b: []const u8) void {
-        std.debug.assert(b.len == 32);
-
-        self.seed = mix0(
-            read_bytes(8, b[0..]),
-            read_bytes(8, b[8..]),
-            self.seed,
-        ) ^ mix1(
-            read_bytes(8, b[16..]),
-            read_bytes(8, b[24..]),
-            self.seed,
-        );
-    }
-
-    pub fn update(self: *WyhashStateless, b: []const u8) void {
-        std.debug.assert(b.len % 32 == 0);
-
-        var off: usize = 0;
-        while (off < b.len) : (off += 32) {
-            @call(.{ .modifier = .always_inline }, self.round, .{b[off .. off + 32]});
-        }
-
-        self.msg_len += b.len;
-    }
-
-    pub fn final(self: *WyhashStateless, b: []const u8) u64 {
-        std.debug.assert(b.len < 32);
-
-        const seed = self.seed;
-        const rem_len = @intCast(u5, b.len);
-        const rem_key = b[0..rem_len];
-
-        self.seed = switch (rem_len) {
-            0 => seed,
-            1 => mix0(read_bytes(1, rem_key), primes[4], seed),
-            2 => mix0(read_bytes(2, rem_key), primes[4], seed),
-            3 => mix0((read_bytes(2, rem_key) << 8) | read_bytes(1, rem_key[2..]), primes[4], seed),
-            4 => mix0(read_bytes(4, rem_key), primes[4], seed),
-            5 => mix0((read_bytes(4, rem_key) << 8) | read_bytes(1, rem_key[4..]), primes[4], seed),
-            6 => mix0((read_bytes(4, rem_key) << 16) | read_bytes(2, rem_key[4..]), primes[4], seed),
-            7 => mix0((read_bytes(4, rem_key) << 24) | (read_bytes(2, rem_key[4..]) << 8) | read_bytes(1, rem_key[6..]), primes[4], seed),
-            8 => mix0(read_8bytes_swapped(rem_key), primes[4], seed),
-            9 => mix0(read_8bytes_swapped(rem_key), read_bytes(1, rem_key[8..]), seed),
-            10 => mix0(read_8bytes_swapped(rem_key), read_bytes(2, rem_key[8..]), seed),
-            11 => mix0(read_8bytes_swapped(rem_key), (read_bytes(2, rem_key[8..]) << 8) | read_bytes(1, rem_key[10..]), seed),
-            12 => mix0(read_8bytes_swapped(rem_key), read_bytes(4, rem_key[8..]), seed),
-            13 => mix0(read_8bytes_swapped(rem_key), (read_bytes(4, rem_key[8..]) << 8) | read_bytes(1, rem_key[12..]), seed),
-            14 => mix0(read_8bytes_swapped(rem_key), (read_bytes(4, rem_key[8..]) << 16) | read_bytes(2, rem_key[12..]), seed),
-            15 => mix0(read_8bytes_swapped(rem_key), (read_bytes(4, rem_key[8..]) << 24) | (read_bytes(2, rem_key[12..]) << 8) | read_bytes(1, rem_key[14..]), seed),
-            16 => mix0(read_8bytes_swapped(rem_key), read_8bytes_swapped(rem_key[8..]), seed),
-            17 => mix0(read_8bytes_swapped(rem_key), read_8bytes_swapped(rem_key[8..]), seed) ^ mix1(read_bytes(1, rem_key[16..]), primes[4], seed),
-            18 => mix0(read_8bytes_swapped(rem_key), read_8bytes_swapped(rem_key[8..]), seed) ^ mix1(read_bytes(2, rem_key[16..]), primes[4], seed),
-            19 => mix0(read_8bytes_swapped(rem_key), read_8bytes_swapped(rem_key[8..]), seed) ^ mix1((read_bytes(2, rem_key[16..]) << 8) | read_bytes(1, rem_key[18..]), primes[4], seed),
-            20 => mix0(read_8bytes_swapped(rem_key), read_8bytes_swapped(rem_key[8..]), seed) ^ mix1(read_bytes(4, rem_key[16..]), primes[4], seed),
-            21 => mix0(read_8bytes_swapped(rem_key), read_8bytes_swapped(rem_key[8..]), seed) ^ mix1((read_bytes(4, rem_key[16..]) << 8) | read_bytes(1, rem_key[20..]), primes[4], seed),
-            22 => mix0(read_8bytes_swapped(rem_key), read_8bytes_swapped(rem_key[8..]), seed) ^ mix1((read_bytes(4, rem_key[16..]) << 16) | read_bytes(2, rem_key[20..]), primes[4], seed),
-            23 => mix0(read_8bytes_swapped(rem_key), read_8bytes_swapped(rem_key[8..]), seed) ^ mix1((read_bytes(4, rem_key[16..]) << 24) | (read_bytes(2, rem_key[20..]) << 8) | read_bytes(1, rem_key[22..]), primes[4], seed),
-            24 => mix0(read_8bytes_swapped(rem_key), read_8bytes_swapped(rem_key[8..]), seed) ^ mix1(read_8bytes_swapped(rem_key[16..]), primes[4], seed),
-            25 => mix0(read_8bytes_swapped(rem_key), read_8bytes_swapped(rem_key[8..]), seed) ^ mix1(read_8bytes_swapped(rem_key[16..]), read_bytes(1, rem_key[24..]), seed),
-            26 => mix0(read_8bytes_swapped(rem_key), read_8bytes_swapped(rem_key[8..]), seed) ^ mix1(read_8bytes_swapped(rem_key[16..]), read_bytes(2, rem_key[24..]), seed),
-            27 => mix0(read_8bytes_swapped(rem_key), read_8bytes_swapped(rem_key[8..]), seed) ^ mix1(read_8bytes_swapped(rem_key[16..]), (read_bytes(2, rem_key[24..]) << 8) | read_bytes(1, rem_key[26..]), seed),
-            28 => mix0(read_8bytes_swapped(rem_key), read_8bytes_swapped(rem_key[8..]), seed) ^ mix1(read_8bytes_swapped(rem_key[16..]), read_bytes(4, rem_key[24..]), seed),
-            29 => mix0(read_8bytes_swapped(rem_key), read_8bytes_swapped(rem_key[8..]), seed) ^ mix1(read_8bytes_swapped(rem_key[16..]), (read_bytes(4, rem_key[24..]) << 8) | read_bytes(1, rem_key[28..]), seed),
-            30 => mix0(read_8bytes_swapped(rem_key), read_8bytes_swapped(rem_key[8..]), seed) ^ mix1(read_8bytes_swapped(rem_key[16..]), (read_bytes(4, rem_key[24..]) << 16) | read_bytes(2, rem_key[28..]), seed),
-            31 => mix0(read_8bytes_swapped(rem_key), read_8bytes_swapped(rem_key[8..]), seed) ^ mix1(read_8bytes_swapped(rem_key[16..]), (read_bytes(4, rem_key[24..]) << 24) | (read_bytes(2, rem_key[28..]) << 8) | read_bytes(1, rem_key[30..]), seed),
-        };
-
-        self.msg_len += b.len;
-        return mum(self.seed ^ self.msg_len, primes[4]);
-    }
-
-    pub fn hash(seed: u64, input: []const u8) u64 {
-        const aligned_len = input.len - (input.len % 32);
-
-        var c = WyhashStateless.init(seed);
-        @call(.{ .modifier = .always_inline }, c.update, .{input[0..aligned_len]});
-        return @call(.{ .modifier = .always_inline }, c.final, .{input[aligned_len..]});
-    }
-};
-
-/// Fast non-cryptographic 64bit hash function.
-/// See https://github.com/wangyi-fudan/wyhash
-pub const Wyhash = struct {
-    state: WyhashStateless,
-
-    buf: [32]u8,
-    buf_len: usize,
-
-    pub fn init(seed: u64) Wyhash {
-        return Wyhash{
-            .state = WyhashStateless.init(seed),
-            .buf = undefined,
-            .buf_len = 0,
-        };
-    }
-
-    pub fn update(self: *Wyhash, b: []const u8) void {
-        var off: usize = 0;
-
-        if (self.buf_len != 0 and self.buf_len + b.len >= 32) {
-            off += 32 - self.buf_len;
-            mem.copy(u8, self.buf[self.buf_len..], b[0..off]);
-            self.state.update(self.buf[0..]);
-            self.buf_len = 0;
-        }
-
-        const remain_len = b.len - off;
-        const aligned_len = remain_len - (remain_len % 32);
-        self.state.update(b[off .. off + aligned_len]);
-
-        mem.copy(u8, self.buf[self.buf_len..], b[off + aligned_len ..]);
-        self.buf_len += @intCast(u8, b[off + aligned_len ..].len);
-    }
-
-    pub fn final(self: *Wyhash) u64 {
-        // const seed = self.state.seed;
-        // const rem_len = @intCast(u5, self.buf_len);
-        const rem_key = self.buf[0..self.buf_len];
-
-        return self.state.final(rem_key);
-    }
-
-    pub fn hash(seed: u64, input: []const u8) u64 {
-        return WyhashStateless.hash(seed, input);
-    }
-};
-
-fn wyhash_hash(seed: u64, input: []const u8) u64 {
-    return Wyhash.hash(seed, input);
-}
-
-const expectEqual = std.testing.expectEqual;
-
-test "test vectors" {
-    const hash = Wyhash.hash;
-
-    try expectEqual(hash(0, ""), 0x0);
-    try expectEqual(hash(1, "a"), 0xbed235177f41d328);
-    try expectEqual(hash(2, "abc"), 0xbe348debe59b27c3);
-    try expectEqual(hash(3, "message digest"), 0x37320f657213a290);
-    try expectEqual(hash(4, "abcdefghijklmnopqrstuvwxyz"), 0xd0b270e1d8a7019c);
-    try expectEqual(hash(5, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"), 0x602a1894d3bbfe7f);
-    try expectEqual(hash(6, "12345678901234567890123456789012345678901234567890123456789012345678901234567890"), 0x829e9c148b75970e);
-}
-
-test "test vectors streaming" {
-    var wh = Wyhash.init(5);
-    for ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") |e| {
-        wh.update(mem.asBytes(&e));
-    }
-    try expectEqual(wh.final(), 0x602a1894d3bbfe7f);
-
-    const pattern = "1234567890";
-    const count = 8;
-    const result = 0x829e9c148b75970e;
-    try expectEqual(Wyhash.hash(6, pattern ** 8), result);
-
-    wh = Wyhash.init(6);
-    var i: u32 = 0;
-    while (i < count) : (i += 1) {
-        wh.update(pattern);
-    }
-    try expectEqual(wh.final(), result);
-}
-
-test "iterative non-divisible update" {
-    var buf: [8192]u8 = undefined;
-    for (buf) |*e, i| {
-        e.* = @truncate(u8, i);
-    }
-
-    const seed = 0x128dad08f;
-
-    var end: usize = 32;
-    while (end < buf.len) : (end += 32) {
-        const non_iterative_hash = Wyhash.hash(seed, buf[0..end]);
-
-        var wy = Wyhash.init(seed);
-        var i: usize = 0;
-        while (i < end) : (i += 33) {
-            wy.update(buf[i..std.math.min(i + 33, end)]);
-        }
-        const iterative_hash = wy.final();
-
-        try std.testing.expectEqual(iterative_hash, non_iterative_hash);
-    }
-}

crates/compiler/builtins/bitcode/src/main.zig

@@ -18,40 +18,37 @@ const STR = "str";
 const dec = @import("dec.zig");
 
 comptime {
-    exportDecFn(dec.fromStr, "from_str");
+    exportDecFn(dec.absC, "abs");
-    exportDecFn(dec.toStr, "to_str");
-    exportDecFn(dec.fromU64C, "from_u64");
-    exportDecFn(dec.toI128, "to_i128");
-    exportDecFn(dec.toF64, "to_f64");
-    exportDecFn(dec.eqC, "eq");
-    exportDecFn(dec.neqC, "neq");
-    exportDecFn(dec.negateC, "negate");
-    exportDecFn(dec.divC, "div");
-    exportDecFn(dec.sinC, "sin");
-    exportDecFn(dec.cosC, "cos");
-    exportDecFn(dec.tanC, "tan");
-    exportDecFn(dec.asinC, "asin");
     exportDecFn(dec.acosC, "acos");
-    exportDecFn(dec.atanC, "atan");
-
     exportDecFn(dec.addC, "add_with_overflow");
     exportDecFn(dec.addOrPanicC, "add_or_panic");
     exportDecFn(dec.addSaturatedC, "add_saturated");
-
+    exportDecFn(dec.asinC, "asin");
-    exportDecFn(dec.subC, "sub_with_overflow");
+    exportDecFn(dec.atanC, "atan");
-    exportDecFn(dec.subOrPanicC, "sub_or_panic");
+    exportDecFn(dec.cosC, "cos");
-    exportDecFn(dec.subSaturatedC, "sub_saturated");
+    exportDecFn(dec.divC, "div");
-
+    exportDecFn(dec.eqC, "eq");
+    exportDecFn(dec.fromF32C, "from_float.f32");
+    exportDecFn(dec.fromF64C, "from_float.f64");
+    exportDecFn(dec.fromStr, "from_str");
+    exportDecFn(dec.fromU64C, "from_u64");
     exportDecFn(dec.mulC, "mul_with_overflow");
     exportDecFn(dec.mulOrPanicC, "mul_or_panic");
     exportDecFn(dec.mulSaturatedC, "mul_saturated");
+    exportDecFn(dec.negateC, "negate");
+    exportDecFn(dec.neqC, "neq");
+    exportDecFn(dec.sinC, "sin");
+    exportDecFn(dec.subC, "sub_with_overflow");
+    exportDecFn(dec.subOrPanicC, "sub_or_panic");
+    exportDecFn(dec.subSaturatedC, "sub_saturated");
+    exportDecFn(dec.tanC, "tan");
+    exportDecFn(dec.toF64, "to_f64");
+    exportDecFn(dec.toI128, "to_i128");
+    exportDecFn(dec.toStr, "to_str");
 
     inline for (INTEGERS) |T| {
         dec.exportFromInt(T, ROC_BUILTINS ++ ".dec.from_int.");
     }
-
-    exportDecFn(dec.fromF32C, "from_float.f32");
-    exportDecFn(dec.fromF64C, "from_float.f64");
 }
 
 // List Module

crates/compiler/builtins/bitcode/src/str.zig

@@ -259,19 +259,41 @@ pub const RocStr = extern struct {
         const old_length = self.len();
         const delta_length = new_length - old_length;
 
-        var result = RocStr.allocate(new_length);
+        const element_width = 1;
+        const result_is_big = new_length >= SMALL_STRING_SIZE;
 
-        // transfer the memory
+        if (result_is_big) {
+            const capacity = utils.calculateCapacity(0, new_length, element_width);
+            var result = RocStr.allocateBig(new_length, capacity);
 
-        const source_ptr = self.asU8ptr();
+            // transfer the memory
-        const dest_ptr = result.asU8ptrMut();
 
-        @memcpy(dest_ptr, source_ptr, old_length);
+            const source_ptr = self.asU8ptr();
-        @memset(dest_ptr + old_length, 0, delta_length);
+            const dest_ptr = result.asU8ptrMut();
 
-        self.decref();
+            std.mem.copy(u8, dest_ptr[0..old_length], source_ptr[0..old_length]);
+            std.mem.set(u8, dest_ptr[old_length .. old_length + delta_length], 0);
 
-        return result;
+            self.decref();
+
+            return result;
+        } else {
+            var string = RocStr.empty();
+
+            // I believe taking this reference on the stack here is important for correctness.
+            // Doing it via a method call seemed to cause issues
+            const dest_ptr = @ptrCast([*]u8, &string);
+            dest_ptr[@sizeOf(RocStr) - 1] = @intCast(u8, new_length) | 0b1000_0000;
+
+            const source_ptr = self.asU8ptr();
+
+            std.mem.copy(u8, dest_ptr[0..old_length], source_ptr[0..old_length]);
+            std.mem.set(u8, dest_ptr[old_length .. old_length + delta_length], 0);
+
+            self.decref();
+
+            return string;
+        }
     }
 
     pub fn isSmallStr(self: RocStr) bool {
@@ -1857,13 +1879,12 @@ const CountAndStart = extern struct {
 };
 
 pub fn fromUtf8RangeC(
-    output: *FromUtf8Result,
     list: RocList,
     start: usize,
     count: usize,
     update_mode: UpdateMode,
-) callconv(.C) void {
+) callconv(.C) FromUtf8Result {
-    output.* = @call(.{ .modifier = always_inline }, fromUtf8Range, .{ list, start, count, update_mode });
+    return fromUtf8Range(list, start, count, update_mode);
 }
 
 pub fn fromUtf8Range(arg: RocList, start: usize, count: usize, update_mode: UpdateMode) FromUtf8Result {

crates/compiler/builtins/roc/List.roc

@@ -67,6 +67,7 @@ interface List
         releaseExcessCapacity,
         walkBackwardsUntil,
         countIf,
+        chunksOf,
     ]
     imports [
         Bool.{ Bool, Eq },
@@ -1197,6 +1198,26 @@ splitLast = \list, delimiter ->
 
         Err NotFound -> Err NotFound
 
+## Splits the list into many chunks, each of which is length of the given chunk
+## size. The last chunk will be shorter if the list does not evenly divide by the
+## chunk size. If the provided list is empty or if the chunk size is 0 then the
+## result is an empty list.
+chunksOf : List a, Nat -> List (List a)
+chunksOf = \list, chunkSize ->
+    if chunkSize == 0 || List.isEmpty list then
+        []
+    else
+        chunkCapacity = Num.divCeil (List.len list) chunkSize
+        chunksOfHelp list chunkSize (List.withCapacity chunkCapacity)
+
+chunksOfHelp : List a, Nat, List (List a) -> List (List a)
+chunksOfHelp = \listRest, chunkSize, chunks ->
+    if List.isEmpty listRest then
+        chunks
+    else
+        { before, others } = List.split listRest chunkSize
+        chunksOfHelp others chunkSize (List.append chunks before)
+
 ## Like [List.map], except the transformation function returns a [Result].
 ## If that function ever returns `Err`, [mapTry] immediately returns that `Err`.
 ## If it returns `Ok` for every element, [mapTry] returns `Ok` with the transformed list.

crates/compiler/builtins/roc/Num.roc

@@ -514,12 +514,16 @@ F32 : Num (FloatingPoint Binary32)
 ##
 ## Here's a comparison of about how long [Dec] takes to perform a given operation compared to [F64],
 ## based on benchmarks on an [M1](https://en.wikipedia.org/wiki/Apple_M1) CPU:
-## * [add] 0.75x
+## * [add]  0.6x
-## * [sub] 0.75x
+## * [sub]  0.6x
-## * [mul] 4x
+## * [mul]  15x
-## * [div] 32x
+## * [div]  55x
-## * [sin] 3x
+## * [sin]  3.9x
-## * [asin] 9x
+## * [cos]  3.6x
+## * [tan]  2.3x
+## * [asin] 1.8x
+## * [acos] 1.7x
+## * [atan] 1.7x
 ##
 ## Keep in mind that arithmetic instructions are basically [the fastest thing a CPU does](http://norvig.com/21-days.html#answers),
 ## so (for example) a network request that takes 10 milliseconds to complete would go on this

crates/compiler/builtins/roc/Str.roc

@@ -135,6 +135,7 @@ interface Str
         withCapacity,
         withPrefix,
         graphemes,
+        contains,
     ]
     imports [
         Bool.{ Bool, Eq },
@@ -995,3 +996,15 @@ strToNumHelp = \string ->
 ## ```
 withPrefix : Str, Str -> Str
 withPrefix = \str, prefix -> Str.concat prefix str
+
+## Determines whether or not the first Str contains the second.
+## ```
+## expect Str.contains "foobarbaz" "bar"
+## expect !(Str.contains "apple" "orange")
+## expect Str.contains "anything" ""
+## ```
+contains : Str, Str -> Bool
+contains = \haystack, needle ->
+    when firstMatch haystack needle is
+        Some _index -> Bool.true
+        None -> Bool.false

crates/compiler/builtins/src/bitcode.rs

@@ -393,32 +393,33 @@ pub const LIST_CAPACITY: &str = "roc_builtins.list.capacity";
 pub const LIST_REFCOUNT_PTR: &str = "roc_builtins.list.refcount_ptr";
 pub const LIST_RELEASE_EXCESS_CAPACITY: &str = "roc_builtins.list.release_excess_capacity";
 
-pub const DEC_FROM_STR: &str = "roc_builtins.dec.from_str";
+pub const DEC_ABS: &str = "roc_builtins.dec.abs";
-pub const DEC_TO_STR: &str = "roc_builtins.dec.to_str";
+pub const DEC_ACOS: &str = "roc_builtins.dec.acos";
-pub const DEC_FROM_F64: &str = "roc_builtins.dec.from_f64";
-pub const DEC_FROM_U64: &str = "roc_builtins.dec.from_u64";
-pub const DEC_FROM_INT: IntrinsicName = int_intrinsic!("roc_builtins.dec.from_int");
-pub const DEC_FROM_FLOAT: IntrinsicName = float_intrinsic!("roc_builtins.dec.from_float");
-pub const DEC_TO_I128: &str = "roc_builtins.dec.to_i128";
-pub const DEC_EQ: &str = "roc_builtins.dec.eq";
-pub const DEC_NEQ: &str = "roc_builtins.dec.neq";
-pub const DEC_NEGATE: &str = "roc_builtins.dec.negate";
-pub const DEC_MUL_WITH_OVERFLOW: &str = "roc_builtins.dec.mul_with_overflow";
-pub const DEC_DIV: &str = "roc_builtins.dec.div";
-pub const DEC_ADD_WITH_OVERFLOW: &str = "roc_builtins.dec.add_with_overflow";
 pub const DEC_ADD_OR_PANIC: &str = "roc_builtins.dec.add_or_panic";
 pub const DEC_ADD_SATURATED: &str = "roc_builtins.dec.add_saturated";
-pub const DEC_SUB_WITH_OVERFLOW: &str = "roc_builtins.dec.sub_with_overflow";
+pub const DEC_ADD_WITH_OVERFLOW: &str = "roc_builtins.dec.add_with_overflow";
-pub const DEC_SUB_OR_PANIC: &str = "roc_builtins.dec.sub_or_panic";
+pub const DEC_ASIN: &str = "roc_builtins.dec.asin";
-pub const DEC_SUB_SATURATED: &str = "roc_builtins.dec.sub_saturated";
+pub const DEC_ATAN: &str = "roc_builtins.dec.atan";
+pub const DEC_COS: &str = "roc_builtins.dec.cos";
+pub const DEC_DIV: &str = "roc_builtins.dec.div";
+pub const DEC_EQ: &str = "roc_builtins.dec.eq";
+pub const DEC_FROM_F64: &str = "roc_builtins.dec.from_f64";
+pub const DEC_FROM_FLOAT: IntrinsicName = float_intrinsic!("roc_builtins.dec.from_float");
+pub const DEC_FROM_INT: IntrinsicName = int_intrinsic!("roc_builtins.dec.from_int");
+pub const DEC_FROM_STR: &str = "roc_builtins.dec.from_str";
+pub const DEC_FROM_U64: &str = "roc_builtins.dec.from_u64";
 pub const DEC_MUL_OR_PANIC: &str = "roc_builtins.dec.mul_or_panic";
 pub const DEC_MUL_SATURATED: &str = "roc_builtins.dec.mul_saturated";
+pub const DEC_MUL_WITH_OVERFLOW: &str = "roc_builtins.dec.mul_with_overflow";
+pub const DEC_NEGATE: &str = "roc_builtins.dec.negate";
+pub const DEC_NEQ: &str = "roc_builtins.dec.neq";
 pub const DEC_SIN: &str = "roc_builtins.dec.sin";
-pub const DEC_COS: &str = "roc_builtins.dec.cos";
+pub const DEC_SUB_OR_PANIC: &str = "roc_builtins.dec.sub_or_panic";
+pub const DEC_SUB_SATURATED: &str = "roc_builtins.dec.sub_saturated";
+pub const DEC_SUB_WITH_OVERFLOW: &str = "roc_builtins.dec.sub_with_overflow";
 pub const DEC_TAN: &str = "roc_builtins.dec.tan";
-pub const DEC_ASIN: &str = "roc_builtins.dec.asin";
+pub const DEC_TO_I128: &str = "roc_builtins.dec.to_i128";
-pub const DEC_ACOS: &str = "roc_builtins.dec.acos";
+pub const DEC_TO_STR: &str = "roc_builtins.dec.to_str";
-pub const DEC_ATAN: &str = "roc_builtins.dec.atan";
 
 pub const UTILS_TEST_PANIC: &str = "roc_builtins.utils.test_panic";
 pub const UTILS_ALLOCATE_WITH_REFCOUNT: &str = "roc_builtins.utils.allocate_with_refcount";

crates/compiler/can/src/exhaustive.rs

@@ -701,7 +701,7 @@ fn convert_tag(subs: &Subs, whole_var: Variable, this_tag: &TagName) -> (Union,
     let mut my_tag_id = TagId(num_tags as TagIdIntType);
 
     let mut alternatives = Vec::with_capacity(num_tags);
-    let alternatives_iter = sorted_tags.into_iter().chain(opt_openness_tag.into_iter());
+    let alternatives_iter = sorted_tags.into_iter().chain(opt_openness_tag);
 
     let mut index = 0;
     for (tag, args) in alternatives_iter {

crates/compiler/collections/src/soa.rs

@@ -21,10 +21,7 @@ impl<T> std::hash::Hash for Index<T> {
 
 impl<T> Clone for Index<T> {
     fn clone(&self) -> Self {
-        Self {
+        *self
-            index: self.index,
-            _marker: self._marker,
-        }
     }
 }
 
@@ -70,11 +67,7 @@ pub struct Slice<T> {
 
 impl<T> Clone for Slice<T> {
     fn clone(&self) -> Self {
-        Self {
+        *self
-            start: self.start,
-            length: self.length,
-            _marker: self._marker,
-        }
     }
 }
 
@@ -151,10 +144,7 @@ pub struct EitherIndex<T, U> {
 
 impl<T, U> Clone for EitherIndex<T, U> {
     fn clone(&self) -> Self {
-        Self {
+        *self
-            index: self.index,
-            _marker: self._marker,
-        }
     }
 }
 

crates/compiler/gen_dev/src/generic64/aarch64.rs

@@ -405,67 +405,63 @@ impl CallConv<AArch64GeneralReg, AArch64FloatReg, AArch64Assembler> for AArch64C
         requested_stack_size: i32,
         fn_call_stack_size: i32,
     ) -> i32 {
+        let frame_pointer_link_register = 16;
+
         // Full size is upcast to i64 to make sure we don't overflow here.
         let full_stack_size = match requested_stack_size
-            .checked_add(8 * (saved_general_regs.len() + saved_float_regs.len()) as i32 + 8) // The extra 8 is space to store the frame pointer.
+            .checked_add(8 * (saved_general_regs.len() + saved_float_regs.len()) as i32)
+            // space for the frame pointer FP and the link register LR
+            .and_then(|size| size.checked_add(frame_pointer_link_register))
+            // extra space for arguments that did not fit into registers
             .and_then(|size| size.checked_add(fn_call_stack_size))
         {
             Some(size) => size,
             _ => internal_error!("Ran out of stack space"),
         };
 
-        let alignment = if full_stack_size <= 0 {
+        const fn next_multiple_of(lhs: i32, rhs: i32) -> i32 {
-            0
+            match lhs % rhs {
-        } else {
+                0 => lhs,
-            full_stack_size % STACK_ALIGNMENT as i32
+                r => lhs + (rhs - r),
-        };
-
-        let offset = if alignment == 0 {
-            0
-        } else {
-            STACK_ALIGNMENT - alignment as u8
-        };
-
-        if let Some(aligned_stack_size) = full_stack_size.checked_add(offset as i32) {
-            if aligned_stack_size > 0 {
-                // sub     sp, sp, #0x10
-                AArch64Assembler::sub_reg64_reg64_imm32(
-                    buf,
-                    AArch64GeneralReg::ZRSP,
-                    AArch64GeneralReg::ZRSP,
-                    aligned_stack_size,
-                );
-
-                // All the following stores could be optimized by using `STP` to store pairs.
-                let mut offset = aligned_stack_size;
-                offset -= 8;
-                AArch64Assembler::mov_stack32_reg64(buf, offset, AArch64GeneralReg::LR);
-                offset -= 8;
-                AArch64Assembler::mov_stack32_reg64(buf, offset, AArch64GeneralReg::FP);
-
-                // update the frame pointer
-                AArch64Assembler::add_reg64_reg64_imm32(
-                    buf,
-                    AArch64GeneralReg::FP,
-                    AArch64GeneralReg::ZRSP,
-                    offset,
-                );
-
-                offset = aligned_stack_size - fn_call_stack_size;
-                for reg in saved_general_regs {
-                    offset -= 8;
-                    AArch64Assembler::mov_base32_reg64(buf, offset, *reg);
-                }
-                for reg in saved_float_regs {
-                    offset -= 8;
-                    AArch64Assembler::mov_base32_freg64(buf, offset, *reg);
-                }
-                aligned_stack_size
-            } else {
-                0
             }
+        }
+
+        let aligned_stack_size = next_multiple_of(full_stack_size, STACK_ALIGNMENT as i32);
+
+        if aligned_stack_size > 0 {
+            // sub     sp, sp, #0x10
+            AArch64Assembler::sub_reg64_reg64_imm32(
+                buf,
+                AArch64GeneralReg::ZRSP,
+                AArch64GeneralReg::ZRSP,
+                aligned_stack_size,
+            );
+
+            // All the following stores could be optimized by using `STP` to store pairs.
+            let w = aligned_stack_size;
+            AArch64Assembler::mov_stack32_reg64(buf, w - 0x10, AArch64GeneralReg::FP);
+            AArch64Assembler::mov_stack32_reg64(buf, w - 0x08, AArch64GeneralReg::LR);
+
+            // update the frame pointer
+            AArch64Assembler::add_reg64_reg64_imm32(
+                buf,
+                AArch64GeneralReg::FP,
+                AArch64GeneralReg::ZRSP,
+                w - frame_pointer_link_register,
+            );
+
+            let mut offset = aligned_stack_size - fn_call_stack_size - frame_pointer_link_register;
+            for reg in saved_general_regs {
+                AArch64Assembler::mov_base32_reg64(buf, -offset, *reg);
+                offset -= 8;
+            }
+            for reg in saved_float_regs {
+                AArch64Assembler::mov_base32_freg64(buf, -offset, *reg);
+                offset -= 8;
+            }
+            aligned_stack_size
         } else {
-            internal_error!("Ran out of stack space");
+            0
         }
     }
 
@@ -477,23 +473,26 @@ impl CallConv<AArch64GeneralReg, AArch64FloatReg, AArch64Assembler> for AArch64C
         aligned_stack_size: i32,
         fn_call_stack_size: i32,
     ) {
+        let frame_pointer_link_register = 16;
+
         if aligned_stack_size > 0 {
             // All the following stores could be optimized by using `STP` to store pairs.
-            let mut offset = aligned_stack_size;
+            let mut offset = aligned_stack_size - fn_call_stack_size - frame_pointer_link_register;
-            offset -= 8;
-            AArch64Assembler::mov_reg64_stack32(buf, AArch64GeneralReg::LR, offset);
-            offset -= 8;
-            AArch64Assembler::mov_reg64_stack32(buf, AArch64GeneralReg::FP, offset);
 
-            offset = aligned_stack_size - fn_call_stack_size;
             for reg in saved_general_regs {
+                AArch64Assembler::mov_reg64_base32(buf, *reg, -offset);
                 offset -= 8;
-                AArch64Assembler::mov_reg64_base32(buf, *reg, offset);
             }
+
             for reg in saved_float_regs {
+                AArch64Assembler::mov_freg64_base32(buf, *reg, -offset);
                 offset -= 8;
-                AArch64Assembler::mov_freg64_base32(buf, *reg, offset);
             }
+
+            let w = aligned_stack_size;
+            AArch64Assembler::mov_reg64_stack32(buf, AArch64GeneralReg::FP, w - 0x10);
+            AArch64Assembler::mov_reg64_stack32(buf, AArch64GeneralReg::LR, w - 0x08);
+
             AArch64Assembler::add_reg64_reg64_imm32(
                 buf,
                 AArch64GeneralReg::ZRSP,
@@ -511,6 +510,7 @@ impl CallConv<AArch64GeneralReg, AArch64FloatReg, AArch64Assembler> for AArch64C
         args: &'a [(InLayout<'a>, Symbol)],
         ret_layout: &InLayout<'a>,
     ) {
+        // loading arguments occurs at an offset (but storing arguments does not)
         let mut state = AArch64CallLoadArgs {
             general_i: 0,
             float_i: 0,
@@ -551,10 +551,11 @@ impl CallConv<AArch64GeneralReg, AArch64FloatReg, AArch64Assembler> for AArch64C
             );
         }
 
+        // storing arguments does not have a stack offset (loading arguments does)
         let mut state = AArch64CallStoreArgs {
             general_i: 0,
             float_i: 0,
-            tmp_stack_offset: Self::SHADOW_SPACE_SIZE as i32,
+            tmp_stack_offset: 0,
         };
 
         for (sym, in_layout) in args.iter().zip(arg_layouts.iter()) {
@@ -647,16 +648,145 @@ impl CallConv<AArch64GeneralReg, AArch64FloatReg, AArch64Assembler> for AArch64C
         }
     }
 
-    fn setjmp(_buf: &mut Vec<'_, u8>) {
+    fn setjmp(buf: &mut Vec<'_, u8>) {
-        eprintln!("setjmp is not implemented on this target!");
+        use AArch64GeneralReg::*;
+        type ASM = AArch64Assembler;
+
+        // based on the musl libc setjmp implementation
+        //
+        // 0000000000211570 <__setjmp>:
+        //   211570:       a9005013        stp     x19, x20, [x0]
+        //   211574:       a9015815        stp     x21, x22, [x0, #16]
+        //   211578:       a9026017        stp     x23, x24, [x0, #32]
+        //   21157c:       a9036819        stp     x25, x26, [x0, #48]
+        //   211580:       a904701b        stp     x27, x28, [x0, #64]
+        //   211584:       a905781d        stp     x29, x30, [x0, #80]
+        //   211588:       910003e2        mov     x2, sp
+        //   21158c:       f9003402        str     x2, [x0, #104]
+        //   211590:       6d072408        stp     d8, d9, [x0, #112]
+        //   211594:       6d082c0a        stp     d10, d11, [x0, #128]
+        //   211598:       6d09340c        stp     d12, d13, [x0, #144]
+        //   21159c:       6d0a3c0e        stp     d14, d15, [x0, #160]
+        //   2115a0:       d2800000        mov     x0, #0x0                        // #0
+        //   2115a4:       d65f03c0        ret
+
+        let env = X0;
+
+        // store caller-saved (i.e. non-volatile) registers
+        ASM::mov_mem64_offset32_reg64(buf, env, 0x00, X19);
+        ASM::mov_mem64_offset32_reg64(buf, env, 0x08, X20);
+        ASM::mov_mem64_offset32_reg64(buf, env, 0x10, X21);
+        ASM::mov_mem64_offset32_reg64(buf, env, 0x18, X22);
+        ASM::mov_mem64_offset32_reg64(buf, env, 0x20, X23);
+        ASM::mov_mem64_offset32_reg64(buf, env, 0x28, X24);
+        ASM::mov_mem64_offset32_reg64(buf, env, 0x30, X25);
+        ASM::mov_mem64_offset32_reg64(buf, env, 0x38, X26);
+        ASM::mov_mem64_offset32_reg64(buf, env, 0x40, X27);
+        ASM::mov_mem64_offset32_reg64(buf, env, 0x48, X28);
+        ASM::mov_mem64_offset32_reg64(buf, env, 0x50, FP);
+        ASM::mov_mem64_offset32_reg64(buf, env, 0x58, LR);
+
+        // mov of sp requires an addition with zero
+        ASM::add_reg64_reg64_imm32(buf, X2, ZRSP, 0);
+        ASM::mov_mem64_offset32_reg64(buf, env, 104, X2);
+
+        ASM::mov_mem64_offset32_freg64(buf, env, 112, AArch64FloatReg::V8);
+        ASM::mov_mem64_offset32_freg64(buf, env, 120, AArch64FloatReg::V9);
+        ASM::mov_mem64_offset32_freg64(buf, env, 128, AArch64FloatReg::V10);
+        ASM::mov_mem64_offset32_freg64(buf, env, 136, AArch64FloatReg::V11);
+        ASM::mov_mem64_offset32_freg64(buf, env, 144, AArch64FloatReg::V12);
+        ASM::mov_mem64_offset32_freg64(buf, env, 152, AArch64FloatReg::V13);
+        ASM::mov_mem64_offset32_freg64(buf, env, 160, AArch64FloatReg::V14);
+        ASM::mov_mem64_offset32_freg64(buf, env, 168, AArch64FloatReg::V15);
+
+        ASM::mov_reg64_imm64(buf, X0, 0);
+
+        ASM::ret(buf)
     }
 
-    fn longjmp(_buf: &mut Vec<'_, u8>) {
+    fn longjmp(buf: &mut Vec<'_, u8>) {
-        eprintln!("longjmp is not implemented on this target!");
+        use AArch64GeneralReg::*;
+        type ASM = AArch64Assembler;
+
+        // 0000000000211534 <_longjmp>:
+        //   211534:       a9405013        ldp     x19, x20, [x0]
+        //   211538:       a9415815        ldp     x21, x22, [x0, #16]
+        //   21153c:       a9426017        ldp     x23, x24, [x0, #32]
+        //   211540:       a9436819        ldp     x25, x26, [x0, #48]
+        //   211544:       a944701b        ldp     x27, x28, [x0, #64]
+        //   211548:       a945781d        ldp     x29, x30, [x0, #80]
+        //   21154c:       f9403402        ldr     x2, [x0, #104]
+        //   211550:       9100005f        mov     sp, x2
+        //   211554:       6d472408        ldp     d8, d9, [x0, #112]
+        //   211558:       6d482c0a        ldp     d10, d11, [x0, #128]
+        //   21155c:       6d49340c        ldp     d12, d13, [x0, #144]
+        //   211560:       6d4a3c0e        ldp     d14, d15, [x0, #160]
+        //   211564:       7100003f        cmp     w1, #0x0
+        //   211568:       1a9f1420        csinc   w0, w1, wzr, ne  // ne = any
+        //   21156c:       d61f03c0        br      x30
+
+        // load the caller-saved registers
+        let env = X0;
+
+        ASM::mov_reg64_mem64_offset32(buf, X19, env, 0x00);
+        ASM::mov_reg64_mem64_offset32(buf, X20, env, 0x08);
+        ASM::mov_reg64_mem64_offset32(buf, X21, env, 0x10);
+        ASM::mov_reg64_mem64_offset32(buf, X22, env, 0x18);
+        ASM::mov_reg64_mem64_offset32(buf, X23, env, 0x20);
+        ASM::mov_reg64_mem64_offset32(buf, X24, env, 0x28);
+        ASM::mov_reg64_mem64_offset32(buf, X25, env, 0x30);
+        ASM::mov_reg64_mem64_offset32(buf, X26, env, 0x38);
+        ASM::mov_reg64_mem64_offset32(buf, X27, env, 0x40);
+        ASM::mov_reg64_mem64_offset32(buf, X28, env, 0x48);
+        ASM::mov_reg64_mem64_offset32(buf, FP, env, 0x50);
+        ASM::mov_reg64_mem64_offset32(buf, LR, env, 0x58);
+
+        ASM::mov_reg64_mem64_offset32(buf, X2, env, 104);
+        ASM::add_reg64_reg64_imm32(buf, ZRSP, X2, 0);
+
+        ASM::mov_freg64_mem64_offset32(buf, AArch64FloatReg::V8, env, 112);
+        ASM::mov_freg64_mem64_offset32(buf, AArch64FloatReg::V9, env, 120);
+        ASM::mov_freg64_mem64_offset32(buf, AArch64FloatReg::V10, env, 128);
+        ASM::mov_freg64_mem64_offset32(buf, AArch64FloatReg::V11, env, 136);
+        ASM::mov_freg64_mem64_offset32(buf, AArch64FloatReg::V12, env, 144);
+        ASM::mov_freg64_mem64_offset32(buf, AArch64FloatReg::V13, env, 152);
+        ASM::mov_freg64_mem64_offset32(buf, AArch64FloatReg::V14, env, 160);
+        ASM::mov_freg64_mem64_offset32(buf, AArch64FloatReg::V15, env, 168);
+
+        // Move the string pointer into X0
+        // Move the panic tag into X1
+        ASM::mov_reg64_reg64(buf, X0, X1);
+        ASM::mov_reg64_reg64(buf, X1, X10);
+
+        // Break to the value of the link register
+        jmp_reg64(buf, LR);
     }
 
-    fn roc_panic(_buf: &mut Vec<'_, u8>, _relocs: &mut Vec<'_, Relocation>) {
+    fn roc_panic(buf: &mut Vec<'_, u8>, relocs: &mut Vec<'_, Relocation>) {
-        eprintln!("roc_panic is not implemented on this target!");
+        use AArch64GeneralReg::*;
+        type ASM = AArch64Assembler;
+
+        // move the first argument to roc_panic (a *RocStr) into x9
+        ASM::mov_reg64_reg64(buf, X9, X0);
+
+        // move the crash tag into the second return register. We add 1 to it because the 0 value
+        // is already used for "no crash occurred"
+        ASM::add_reg64_reg64_imm32(buf, X10, X1, 1);
+
+        // the setlongjmp_buffer
+        ASM::data_pointer(buf, relocs, String::from("setlongjmp_buffer"), X0);
+
+        // the value to return from the longjmp. It is a pointer to the last 3 words of the setlongjmp_buffer
+        // they represent the error message. (168 + 8) which is after V15 register.
+        ASM::mov_reg64_imm64(buf, X1, 176);
+        ASM::add_reg64_reg64_reg64(buf, X1, X1, X0);
+
+        for offset in [0, 8, 16] {
+            ASM::mov_reg64_mem64_offset32(buf, X11, X9, offset);
+            ASM::mov_mem64_offset32_reg64(buf, X1, offset, X11);
+        }
+
+        Self::longjmp(buf)
     }
 }
 
@@ -743,18 +873,48 @@ impl AArch64CallLoadArgs {
         sym: Symbol,
         in_layout: InLayout<'a>,
     ) {
+        use Builtin::{Decimal, Int};
+
         let stack_size = layout_interner.stack_size(in_layout);
         match layout_interner.get_repr(in_layout) {
             single_register_integers!() => self.load_arg_general(storage_manager, sym),
             pointer_layouts!() => self.load_arg_general(storage_manager, sym),
             single_register_floats!() => self.load_arg_float(storage_manager, sym),
+            LayoutRepr::Builtin(Int(IntWidth::U128 | IntWidth::I128) | Decimal) => {
+                self.load_arg_general_128bit(buf, storage_manager, layout_interner, sym, in_layout);
+            }
             _ if stack_size == 0 => {
                 storage_manager.no_data(&sym);
             }
             _ if stack_size > 16 => {
-                // TODO: Double check this.
+                match AArch64Call::GENERAL_PARAM_REGS.get(self.general_i) {
-                storage_manager.complex_stack_arg(&sym, self.argument_offset, stack_size);
+                    Some(ptr_reg) => {
-                self.argument_offset += stack_size as i32;
+                        // if there is a general purpose register available, use it to store a pointer to the value
+                        let base_offset = storage_manager.claim_stack_area_layout(
+                            layout_interner,
+                            sym,
+                            in_layout,
+                        );
+
+                        let tmp_reg = AArch64GeneralReg::X15;
+
+                        super::x86_64::copy_to_base_offset::<_, _, AArch64Assembler>(
+                            buf,
+                            base_offset,
+                            stack_size,
+                            *ptr_reg,
+                            tmp_reg,
+                            0,
+                        );
+
+                        self.general_i += 1;
+                    }
+                    None => {
+                        // else, pass the value implicitly by copying to the stack (of the new frame)
+                        storage_manager.complex_stack_arg(&sym, self.argument_offset, stack_size);
+                        self.argument_offset += stack_size as i32;
+                    }
+                }
             }
             LayoutRepr::LambdaSet(lambda_set) => self.load_arg(
                 buf,
@@ -763,21 +923,26 @@ impl AArch64CallLoadArgs {
                 sym,
                 lambda_set.runtime_representation(),
             ),
-            LayoutRepr::Struct { .. } => {
+            LayoutRepr::Struct { .. } | LayoutRepr::Union(UnionLayout::NonRecursive(_)) => {
-                // for now, just also store this on the stack
+                if stack_size <= 8 {
-                storage_manager.complex_stack_arg(&sym, self.argument_offset, stack_size);
+                    self.load_arg_general_64bit(
-                self.argument_offset += stack_size as i32;
+                        buf,
-            }
+                        storage_manager,
-            LayoutRepr::Builtin(Builtin::Int(IntWidth::U128 | IntWidth::I128)) => {
+                        layout_interner,
-                self.load_arg_general_128bit(buf, storage_manager, sym);
+                        sym,
-            }
+                        in_layout,
-            LayoutRepr::Builtin(Builtin::Decimal) => {
+                    );
-                self.load_arg_general_128bit(buf, storage_manager, sym);
+                } else if stack_size <= 16 {
-            }
+                    self.load_arg_general_128bit(
-            LayoutRepr::Union(UnionLayout::NonRecursive(_)) => {
+                        buf,
-                // for now, just also store this on the stack
+                        storage_manager,
-                storage_manager.complex_stack_arg(&sym, self.argument_offset, stack_size);
+                        layout_interner,
-                self.argument_offset += stack_size as i32;
+                        sym,
+                        in_layout,
+                    );
+                } else {
+                    unreachable!("covered by an earlier branch")
+                }
             }
             _ => {
                 todo!(
@@ -802,11 +967,41 @@ impl AArch64CallLoadArgs {
         }
     }
 
+    fn load_arg_general_64bit(
+        &mut self,
+        buf: &mut Vec<u8>,
+        storage_manager: &mut AArch64StorageManager<'_, '_>,
+        layout_interner: &mut STLayoutInterner<'_>,
+        sym: Symbol,
+        in_layout: InLayout<'_>,
+    ) {
+        type ASM = AArch64Assembler;
+
+        let reg1 = AArch64Call::GENERAL_PARAM_REGS.get(self.general_i);
+
+        match reg1 {
+            Some(reg1) => {
+                let offset =
+                    storage_manager.claim_stack_area_layout(layout_interner, sym, in_layout);
+
+                ASM::mov_base32_reg64(buf, offset, *reg1);
+
+                self.general_i += 1;
+            }
+            None => {
+                storage_manager.complex_stack_arg(&sym, self.argument_offset, 8);
+                self.argument_offset += 8;
+            }
+        }
+    }
+
     fn load_arg_general_128bit(
         &mut self,
         buf: &mut Vec<u8>,
         storage_manager: &mut AArch64StorageManager<'_, '_>,
+        layout_interner: &mut STLayoutInterner<'_>,
         sym: Symbol,
+        in_layout: InLayout<'_>,
     ) {
         type ASM = AArch64Assembler;
 
@@ -815,7 +1010,8 @@ impl AArch64CallLoadArgs {
 
         match (reg1, reg2) {
             (Some(reg1), Some(reg2)) => {
-                let offset = storage_manager.claim_stack_area_with_alignment(sym, 16, 16);
+                let offset =
+                    storage_manager.claim_stack_area_layout(layout_interner, sym, in_layout);
 
                 ASM::mov_base32_reg64(buf, offset, *reg1);
                 ASM::mov_base32_reg64(buf, offset + 8, *reg2);
@@ -848,7 +1044,6 @@ struct AArch64CallStoreArgs {
 
 impl AArch64CallStoreArgs {
     const GENERAL_PARAM_REGS: &'static [AArch64GeneralReg] = AArch64Call::GENERAL_PARAM_REGS;
-    const GENERAL_RETURN_REGS: &'static [AArch64GeneralReg] = AArch64Call::GENERAL_RETURN_REGS;
 
     const FLOAT_PARAM_REGS: &'static [AArch64FloatReg] = AArch64Call::FLOAT_PARAM_REGS;
     const FLOAT_RETURN_REGS: &'static [AArch64FloatReg] = AArch64Call::FLOAT_RETURN_REGS;
@@ -865,51 +1060,41 @@ impl AArch64CallStoreArgs {
         type ASM = AArch64Assembler;
 
         // we use the return register as a temporary register; it will be overwritten anyway
-        let tmp_reg = Self::GENERAL_RETURN_REGS[0];
+        let tmp_reg = AArch64GeneralReg::X15;
 
         match layout_interner.get_repr(in_layout) {
             single_register_integers!() => self.store_arg_general(buf, storage_manager, sym),
             pointer_layouts!() => self.store_arg_general(buf, storage_manager, sym),
             single_register_floats!() => self.store_arg_float(buf, storage_manager, sym),
             LayoutRepr::I128 | LayoutRepr::U128 | LayoutRepr::DEC => {
-                let (offset, _) = storage_manager.stack_offset_and_size(&sym);
+                self.store_arg_128bit(buf, storage_manager, sym)
-
-                if self.general_i + 1 < Self::GENERAL_PARAM_REGS.len() {
-                    let reg1 = Self::GENERAL_PARAM_REGS[self.general_i];
-                    let reg2 = Self::GENERAL_PARAM_REGS[self.general_i + 1];
-
-                    ASM::mov_reg64_base32(buf, reg1, offset);
-                    ASM::mov_reg64_base32(buf, reg2, offset + 8);
-
-                    self.general_i += 2;
-                } else {
-                    // Copy to stack using return reg as buffer.
-                    let reg = Self::GENERAL_RETURN_REGS[0];
-
-                    ASM::mov_reg64_base32(buf, reg, offset);
-                    ASM::mov_stack32_reg64(buf, self.tmp_stack_offset, reg);
-
-                    ASM::mov_reg64_base32(buf, reg, offset + 8);
-                    ASM::mov_stack32_reg64(buf, self.tmp_stack_offset + 8, reg);
-
-                    self.tmp_stack_offset += 16;
-                }
             }
             _ if layout_interner.stack_size(in_layout) == 0 => {}
             _ if layout_interner.stack_size(in_layout) > 16 => {
-                // TODO: Double check this.
+                match Self::GENERAL_PARAM_REGS.get(self.general_i) {
-                // Just copy onto the stack.
+                    Some(reg) => {
-                let stack_offset = self.tmp_stack_offset;
+                        // if there is a general purpose register available, use it to store a pointer to the value
+                        let (base_offset, _size) = storage_manager.stack_offset_and_size(&sym);
 
-                let size = copy_symbol_to_stack_offset::<CC>(
+                        ASM::add_reg64_reg64_imm32(buf, *reg, AArch64GeneralReg::FP, base_offset);
-                    buf,
-                    storage_manager,
-                    sym,
-                    tmp_reg,
-                    stack_offset,
-                );
 
-                self.tmp_stack_offset += size as i32;
+                        self.general_i += 1;
+                    }
+                    None => {
+                        // else, pass the value implicitly by copying to the stack (of the new frame)
+                        let stack_offset = self.tmp_stack_offset;
+
+                        let size = copy_symbol_to_stack_offset::<CC>(
+                            buf,
+                            storage_manager,
+                            sym,
+                            tmp_reg,
+                            stack_offset,
+                        );
+
+                        self.tmp_stack_offset += size as i32;
+                    }
+                }
             }
             LayoutRepr::LambdaSet(lambda_set) => self.store_arg(
                 buf,
@@ -918,31 +1103,15 @@ impl AArch64CallStoreArgs {
                 sym,
                 lambda_set.runtime_representation(),
             ),
-            LayoutRepr::Struct { .. } => {
+            LayoutRepr::Struct { .. } | LayoutRepr::Union(UnionLayout::NonRecursive(_)) => {
-                let stack_offset = self.tmp_stack_offset;
+                let stack_size = layout_interner.stack_size(in_layout);
-
+                if stack_size <= 8 {
-                let size = copy_symbol_to_stack_offset::<CC>(
+                    self.store_arg_64bit(buf, storage_manager, sym);
-                    buf,
+                } else if stack_size <= 16 {
-                    storage_manager,
+                    self.store_arg_128bit(buf, storage_manager, sym);
-                    sym,
+                } else {
-                    tmp_reg,
+                    unreachable!("covered by earlier branch");
-                    stack_offset,
+                }
-                );
-
-                self.tmp_stack_offset += size as i32;
-            }
-            LayoutRepr::Union(UnionLayout::NonRecursive(_)) => {
-                let stack_offset = self.tmp_stack_offset;
-
-                let size = copy_symbol_to_stack_offset::<CC>(
-                    buf,
-                    storage_manager,
-                    sym,
-                    tmp_reg,
-                    stack_offset,
-                );
-
-                self.tmp_stack_offset += size as i32;
             }
             _ => {
                 todo!(
@@ -953,6 +1122,62 @@ impl AArch64CallStoreArgs {
         }
     }
 
+    fn store_arg_64bit<'a>(
+        &mut self,
+        buf: &mut Vec<'a, u8>,
+        storage_manager: &mut AArch64StorageManager<'a, '_>,
+        sym: Symbol,
+    ) {
+        type ASM = AArch64Assembler;
+
+        let (offset, _) = storage_manager.stack_offset_and_size(&sym);
+
+        match Self::GENERAL_PARAM_REGS.get(self.general_i) {
+            Some(reg) => {
+                ASM::mov_reg64_base32(buf, *reg, offset);
+
+                self.general_i += 1;
+            }
+            None => {
+                let tmp = AArch64GeneralReg::X15;
+                ASM::mov_reg64_base32(buf, tmp, offset);
+                ASM::mov_stack32_reg64(buf, self.tmp_stack_offset, tmp);
+
+                self.tmp_stack_offset += 8;
+            }
+        }
+    }
+
+    fn store_arg_128bit<'a>(
+        &mut self,
+        buf: &mut Vec<'a, u8>,
+        storage_manager: &mut AArch64StorageManager<'a, '_>,
+        sym: Symbol,
+    ) {
+        type ASM = AArch64Assembler;
+
+        let (offset, _) = storage_manager.stack_offset_and_size(&sym);
+
+        if self.general_i + 1 < Self::GENERAL_PARAM_REGS.len() {
+            let reg1 = Self::GENERAL_PARAM_REGS[self.general_i];
+            let reg2 = Self::GENERAL_PARAM_REGS[self.general_i + 1];
+
+            ASM::mov_reg64_base32(buf, reg1, offset);
+            ASM::mov_reg64_base32(buf, reg2, offset + 8);
+
+            self.general_i += 2;
+        } else {
+            let reg = AArch64GeneralReg::X15;
+            ASM::mov_reg64_base32(buf, reg, offset);
+            ASM::mov_stack32_reg64(buf, self.tmp_stack_offset, reg);
+
+            ASM::mov_reg64_base32(buf, reg, offset + 8);
+            ASM::mov_stack32_reg64(buf, self.tmp_stack_offset + 8, reg);
+
+            self.tmp_stack_offset += 16;
+        }
+    }
+
     fn store_arg_general<'a>(
         &mut self,
         buf: &mut Vec<'a, u8>,
@@ -965,8 +1190,7 @@ impl AArch64CallStoreArgs {
                 self.general_i += 1;
             }
             None => {
-                // Copy to stack using return reg as buffer.
+                let tmp = AArch64GeneralReg::X15;
-                let tmp = Self::GENERAL_RETURN_REGS[0];
 
                 storage_manager.load_to_specified_general_reg(buf, &sym, tmp);
                 AArch64Assembler::mov_stack32_reg64(buf, self.tmp_stack_offset, tmp);
@@ -1072,22 +1296,44 @@ impl Assembler<AArch64GeneralReg, AArch64FloatReg> for AArch64Assembler {
 
     #[inline(always)]
     fn function_pointer(
-        _buf: &mut Vec<'_, u8>,
+        buf: &mut Vec<'_, u8>,
-        _relocs: &mut Vec<'_, Relocation>,
+        relocs: &mut Vec<'_, Relocation>,
-        _fn_name: String,
+        fn_name: String,
-        _dst: AArch64GeneralReg,
+        dst: AArch64GeneralReg,
     ) {
-        todo!("function pointer for AArch64");
+        // a function pointer is the same as a data pointer on AArch64
+        Self::data_pointer(buf, relocs, fn_name, dst)
     }
 
     #[inline(always)]
     fn data_pointer(
-        _buf: &mut Vec<'_, u8>,
+        buf: &mut Vec<'_, u8>,
-        _relocs: &mut Vec<'_, Relocation>,
+        relocs: &mut Vec<'_, Relocation>,
-        _fn_name: String,
+        fn_name: String,
-        _dst: AArch64GeneralReg,
+        dst: AArch64GeneralReg,
     ) {
-        eprintln!("data_pointer not implemented for this target");
+        // an `adrp` instruction and an addition to add in the lower bits
+        buf.extend((0x9000_0000u32 | dst.id() as u32).to_le_bytes());
+        Self::add_reg64_reg64_imm32(buf, dst, dst, 0);
+
+        // with elf
+        //
+        //     700: 90000001     	adrp	x1, 0x0 <std.builtin.default_panic>
+        //		0000000000000700:  R_AARCH64_ADR_PREL_PG_HI21	.rodata+0x650
+        //     704: 91000021     	add	x1, x1, #0x0
+        //		0000000000000704:  R_AARCH64_ADD_ABS_LO12_NC	.rodata+0x650
+        //
+        // with macho
+        //
+        //     4dc: 90000001     	adrp	x1, 0x0 <ltmp0>
+        //		00000000000004dc:  ARM64_RELOC_PAGE21	___unnamed_6
+        //     4e0: 91000021     	add	x1, x1, #0x0
+        //		00000000000004e0:  ARM64_RELOC_PAGEOFF12	___unnamed_6
+
+        relocs.push(Relocation::LinkedData {
+            offset: buf.len() as u64 - 8,
+            name: fn_name,
+        });
     }
 
     #[inline(always)]
@@ -1240,10 +1486,9 @@ impl Assembler<AArch64GeneralReg, AArch64FloatReg> for AArch64Assembler {
         if imm < (1 << 12) {
             cmp_reg64_imm12(buf, reg, imm as u16);
         } else {
-            todo!(
+            let tmp = AArch64GeneralReg::X15;
-                "cmp immediate with value over 12 bits for AArch64: {:#x}",
+            Self::mov_reg64_imm64(buf, tmp, i64::from_ne_bytes(imm.to_ne_bytes()));
-                imm
+            cmp_reg64_reg64(buf, reg, tmp);
-            );
         }
 
         if (-(1 << 20)..(1 << 20)).contains(&offset) {
@@ -1478,7 +1723,7 @@ impl Assembler<AArch64GeneralReg, AArch64FloatReg> for AArch64Assembler {
         offset: i32,
         src: AArch64FloatReg,
     ) {
-        if offset < 0 {
+        if (-256..256).contains(&offset) {
             stur_freg64_reg64_imm9(buf, src, dst, offset as i16)
         } else if (0..=u16::MAX as i32).contains(&offset) {
             debug_assert!(offset % 8 == 0);
@@ -1810,13 +2055,16 @@ impl Assembler<AArch64GeneralReg, AArch64FloatReg> for AArch64Assembler {
         src: AArch64GeneralReg,
         offset: i32,
     ) {
-        if offset < 0 {
+        if (-256..256).contains(&offset) {
             ldur_freg64_reg64_imm9(buf, dst, src, offset as i16)
         } else if (0..=u16::MAX as i32).contains(&offset) {
             debug_assert!(offset % 8 == 0);
             ldr_freg64_reg64_imm12(buf, dst, src, (offset as u16) >> 3);
         } else {
-            todo!("base offsets over 32k for AArch64");
+            let tmp = AArch64GeneralReg::X15;
+            Self::mov_reg64_imm64(buf, tmp, offset as i64);
+            Self::add_reg64_reg64_reg64(buf, tmp, tmp, src);
+            ldr_freg64_reg64_imm12(buf, dst, tmp, 0);
         }
     }
 
@@ -3978,6 +4226,13 @@ fn scvtf_freg_reg64(
     buf.extend(inst.bytes());
 }
 
+#[inline(always)]
+fn jmp_reg64(buf: &mut Vec<'_, u8>, base: AArch64GeneralReg) {
+    let inst = 0b11010110000111110000000000000000 | ((base as u32) << 5);
+
+    buf.extend(inst.to_le_bytes());
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

crates/compiler/gen_dev/src/generic64/mod.rs

@@ -1048,9 +1048,6 @@ impl<
 
         // now, this gives a pointer to the value
         ASM::data_pointer(&mut self.buf, &mut self.relocs, data_name, reg);
-
-        // dereference
-        ASM::mov_reg64_mem64_offset32(&mut self.buf, reg, reg, 0);
     }
 
     fn build_fn_call(
@@ -1803,6 +1800,11 @@ impl<
 
                 self.free_symbol(tmp);
             }
+            LayoutRepr::Union(UnionLayout::NonRecursive([])) => {
+                // This instruction will never execute, but we need a value the symbol
+                let dst_reg = self.storage_manager.claim_general_reg(&mut self.buf, dst);
+                ASM::mov_reg64_imm64(&mut self.buf, dst_reg, 1);
+            }
             _ => {
                 let ident_ids = self
                     .interns
@@ -1879,6 +1881,11 @@ impl<
 
                 self.free_symbol(tmp)
             }
+            LayoutRepr::Union(UnionLayout::NonRecursive([])) => {
+                // This instruction will never execute, but we need a value the symbol
+                let dst_reg = self.storage_manager.claim_general_reg(&mut self.buf, dst);
+                ASM::mov_reg64_imm64(&mut self.buf, dst_reg, 1);
+            }
             _ => {
                 // defer to equality
 
@@ -1904,11 +1911,13 @@ impl<
                 let dst_reg = self.storage_manager.claim_general_reg(&mut self.buf, dst);
                 let src_reg = self.storage_manager.load_to_general_reg(&mut self.buf, src);
 
-                // Not would usually be implemented as `xor src, -1` followed by `and src, 1`
+                ASM::mov_reg64_imm64(&mut self.buf, dst_reg, 1);
-                // but since our booleans are represented as `0x101010101010101` currently, we can simply XOR with that
-                let bool_val = [true as u8; 8];
-                ASM::mov_reg64_imm64(&mut self.buf, dst_reg, i64::from_ne_bytes(bool_val));
                 ASM::xor_reg64_reg64_reg64(&mut self.buf, src_reg, src_reg, dst_reg);
+
+                // we may need to mask out other bits in the end? but a boolean should be 0 or 1.
+                // if that invariant is upheld, this mask should not be required
+                // ASM::and_reg64_reg64_reg64(&mut self.buf, src_reg, src_reg, dst_reg);
+
                 ASM::mov_reg64_reg64(&mut self.buf, dst_reg, src_reg);
             }
             x => todo!("Not: layout, {:?}", x),
@@ -3153,9 +3162,10 @@ impl<
     ) {
         let element_layout = self.layout_interner.get_repr(*element_in_layout);
         let element_width = self.layout_interner.stack_size(*element_in_layout) as u64;
+        let element_alignment = self.layout_interner.alignment_bytes(*element_in_layout) as u64;
 
         // load the total size of the data we want to store (excludes refcount)
-        let data_bytes_symbol = Symbol::DEV_TMP;
+        let data_bytes_symbol = self.debug_symbol("data_bytes");
         let data_bytes = element_width * elements.len() as u64;
         self.load_literal(
             &data_bytes_symbol,
@@ -3164,7 +3174,7 @@ impl<
         );
 
         // Load allocation alignment (u32)
-        let element_alignment_symbol = Symbol::DEV_TMP2;
+        let element_alignment_symbol = self.debug_symbol("element_alignment");
         self.load_layout_alignment(*element_in_layout, element_alignment_symbol);
 
         let allocation_symbol = self.debug_symbol("list_allocation");
@@ -3177,6 +3187,33 @@ impl<
         self.free_symbol(&data_bytes_symbol);
         self.free_symbol(&element_alignment_symbol);
 
+        enum Origin {
+            S(Symbol),
+            L(Symbol),
+        }
+
+        let mut element_symbols = std::vec::Vec::new();
+
+        // NOTE: this realizes all the list elements on the stack before they are put into the
+        // list. This turns out to be important. Creating the literals as we go causes issues with
+        // register usage.
+        //
+        // Of course this is inefficient when there are many elements (causes lots of stack
+        // spillage.
+        for (i, elem) in elements.iter().enumerate() {
+            match elem {
+                ListLiteralElement::Symbol(sym) => {
+                    self.load_literal_symbols(&[*sym]);
+                    element_symbols.push(Origin::S(*sym));
+                }
+                ListLiteralElement::Literal(lit) => {
+                    let sym = self.debug_symbol(&format!("lit_{i}"));
+                    self.load_literal(&sym, element_in_layout, lit);
+                    element_symbols.push(Origin::L(sym));
+                }
+            }
+        }
+
         // The pointer already points to the first element
         let ptr_reg = self
             .storage_manager
@@ -3184,21 +3221,9 @@ impl<
 
         // Copy everything into output array.
         let mut element_offset = 0;
-        for elem in elements {
+        for elem in element_symbols {
-            // TODO: this could be a lot faster when loading large lists
-            // if we move matching on the element layout to outside this loop.
-            // It also greatly bloats the code here.
-            // Refactor this and switch to one external match.
-            // We also could make loadining indivitual literals much faster
             let element_symbol = match elem {
-                ListLiteralElement::Symbol(sym) => {
+                Origin::S(s) | Origin::L(s) => s,
-                    self.load_literal_symbols(&[*sym]);
-                    *sym
-                }
-                ListLiteralElement::Literal(lit) => {
-                    self.load_literal(&Symbol::DEV_TMP, element_in_layout, lit);
-                    Symbol::DEV_TMP
-                }
             };
 
             Self::ptr_write(
@@ -3213,7 +3238,7 @@ impl<
             );
 
             element_offset += element_width as i32;
-            if element_symbol == Symbol::DEV_TMP {
+            if let Origin::L(element_symbol) = elem {
                 self.free_symbol(&element_symbol);
             }
         }
@@ -3222,7 +3247,9 @@ impl<
         self.storage_manager.with_tmp_general_reg(
             &mut self.buf,
             |storage_manager, buf, tmp_reg| {
-                let base_offset = storage_manager.claim_stack_area_with_alignment(*sym, 24, 8);
+                let alignment = Ord::max(8, element_alignment) as u32;
+                let base_offset =
+                    storage_manager.claim_stack_area_with_alignment(*sym, 24, alignment);
                 ASM::mov_base32_reg64(buf, base_offset, ptr_reg);
 
                 ASM::mov_reg64_imm64(buf, tmp_reg, elements.len() as i64);
@@ -3904,7 +3931,7 @@ impl<
                     // it's just a null pointer
                     self.load_literal_i64(sym, 0);
                 } else {
-                    let (largest_variant, _largest_variant_size) = other_tags
+                    let (largest_variant_fields, _largest_variant_size) = other_tags
                         .iter()
                         .map(|fields| {
                             let struct_layout = self
@@ -3919,6 +3946,16 @@ impl<
                         .max_by(|(_, a), (_, b)| a.cmp(b))
                         .unwrap();
 
+                    let largest_variant =
+                        if union_layout.stores_tag_id_as_data(self.storage_manager.target_info) {
+                            self.layout_interner
+                                .insert_direct_no_semantic(LayoutRepr::Struct(
+                                    self.env.arena.alloc([largest_variant_fields, Layout::U8]),
+                                ))
+                        } else {
+                            largest_variant_fields
+                        };
+
                     let other_fields = if tag_id < nullable_id {
                         other_tags[tag_id as usize]
                     } else {
@@ -4029,7 +4066,7 @@ impl<
                 let stores_tag_id_as_data =
                     union_layout.stores_tag_id_as_data(self.storage_manager.target_info);
 
-                let (largest_variant, _largest_variant_size) = tags
+                let (largest_variant_fields, _largest_variant_size) = tags
                     .iter()
                     .map(|fields| {
                         let struct_layout = self
@@ -4044,6 +4081,15 @@ impl<
                     .max_by(|(_, a), (_, b)| a.cmp(b))
                     .unwrap();
 
+                let largest_variant = if stores_tag_id_as_data {
+                    self.layout_interner
+                        .insert_direct_no_semantic(LayoutRepr::Struct(
+                            self.env.arena.alloc([largest_variant_fields, Layout::U8]),
+                        ))
+                } else {
+                    largest_variant_fields
+                };
+
                 // construct the payload as a struct on the stack
                 let data_struct_layout = self
                     .layout_interner

crates/compiler/gen_dev/src/generic64/storage.rs

@@ -126,7 +126,8 @@ pub struct StorageManager<
     free_stack_chunks: Vec<'a, (i32, u32)>,
     stack_size: u32,
 
-    // The amount of extra stack space needed to pass args for function calling.
+    /// Amount of extra stack space needed to pass arguments for a function call
+    /// This is usually zero, and only used when the argument passing registers are all used
     fn_call_stack_size: u32,
 }
 
@@ -692,6 +693,7 @@ impl<
         if let LayoutRepr::Struct(field_layouts) = layout {
             let mut current_offset = base_offset;
             for (field, field_layout) in fields.iter().zip(field_layouts.iter()) {
+                let field_size = layout_interner.stack_size(*field_layout);
                 self.copy_symbol_to_stack_offset(
                     layout_interner,
                     buf,
@@ -699,7 +701,6 @@ impl<
                     field,
                     field_layout,
                 );
-                let field_size = layout_interner.stack_size(*field_layout);
                 current_offset += field_size as i32;
             }
         } else {

crates/compiler/gen_dev/src/generic64/x86_64.rs

@@ -531,7 +531,6 @@ impl CallConv<X86_64GeneralReg, X86_64FloatReg, X86_64Assembler> for X86_64Syste
 
         // the setlongjmp_buffer
         ASM::data_pointer(buf, relocs, String::from("setlongjmp_buffer"), RDI);
-        ASM::mov_reg64_mem64_offset32(buf, RDI, RDI, 0);
 
         // the value to return from the longjmp. It is a pointer to the last 3 words of the setlongjmp_buffer
         // they represent the errore message.
@@ -563,7 +562,7 @@ where
     let (base_offset, size) = storage_manager.stack_offset_and_size(&sym);
 
     if size - copied >= 8 {
-        for _ in (0..(size - copied)).step_by(8) {
+        for _ in 0..(size - copied) / 8 {
             ASM::mov_reg64_base32(buf, tmp_reg, base_offset + copied as i32);
             ASM::mov_stack32_reg64(buf, stack_offset + copied as i32, tmp_reg);
 
@@ -572,7 +571,7 @@ where
     }
 
     if size - copied >= 4 {
-        for _ in (0..(size - copied)).step_by(4) {
+        for _ in 0..(size - copied) / 4 {
             ASM::mov_reg32_base32(buf, tmp_reg, base_offset + copied as i32);
             ASM::mov_stack32_reg32(buf, stack_offset + copied as i32, tmp_reg);
 
@@ -581,7 +580,7 @@ where
     }
 
     if size - copied >= 2 {
-        for _ in (0..(size - copied)).step_by(2) {
+        for _ in 0..(size - copied) / 2 {
             ASM::mov_reg16_base32(buf, tmp_reg, base_offset + copied as i32);
             ASM::mov_stack32_reg16(buf, stack_offset + copied as i32, tmp_reg);
 
@@ -590,7 +589,7 @@ where
     }
 
     if size - copied >= 1 {
-        for _ in (0..(size - copied)).step_by(1) {
+        for _ in 0..(size - copied) {
             ASM::mov_reg8_base32(buf, tmp_reg, base_offset + copied as i32);
             ASM::mov_stack32_reg8(buf, stack_offset + copied as i32, tmp_reg);
 
@@ -601,7 +600,7 @@ where
     size
 }
 
-fn copy_to_base_offset<GeneralReg, FloatReg, ASM>(
+pub(crate) fn copy_to_base_offset<GeneralReg, FloatReg, ASM>(
     buf: &mut Vec<'_, u8>,
     dst_base_offset: i32,
     stack_size: u32,
@@ -727,12 +726,14 @@ impl X64_64SystemVStoreArgs {
                 lambda_set.runtime_representation(),
             ),
             LayoutRepr::Struct { .. } => {
-                let stack_offset = self.tmp_stack_offset;
+                let stack_size = layout_interner.stack_size(in_layout);
-
+                if stack_size <= 8 {
-                let size =
+                    self.store_arg_64bit(buf, storage_manager, sym);
-                    copy_symbol_to_stack_offset(buf, storage_manager, sym, tmp_reg, stack_offset);
+                } else if stack_size <= 16 {
-
+                    self.store_arg_128bit(buf, storage_manager, sym);
-                self.tmp_stack_offset += size as i32;
+                } else {
+                    unreachable!("covered by earlier branch");
+                }
             }
             LayoutRepr::Union(UnionLayout::NonRecursive(_)) => {
                 let stack_offset = self.tmp_stack_offset;
@@ -796,6 +797,66 @@ impl X64_64SystemVStoreArgs {
             }
         }
     }
+
+    fn store_arg_64bit<'a>(
+        &mut self,
+        buf: &mut Vec<'a, u8>,
+        storage_manager: &mut X86_64StorageManager<'a, '_, X86_64SystemV>,
+        sym: Symbol,
+    ) {
+        type ASM = X86_64Assembler;
+
+        let (offset, _) = storage_manager.stack_offset_and_size(&sym);
+
+        match Self::GENERAL_PARAM_REGS.get(self.general_i) {
+            Some(reg) => {
+                ASM::mov_reg64_base32(buf, *reg, offset);
+
+                self.general_i += 1;
+            }
+            None => {
+                // Copy to stack using return reg as buffer.
+                let reg = X86_64GeneralReg::RAX;
+
+                ASM::mov_reg64_base32(buf, reg, offset);
+                ASM::mov_stack32_reg64(buf, self.tmp_stack_offset, reg);
+
+                self.tmp_stack_offset += 8;
+            }
+        }
+    }
+
+    fn store_arg_128bit<'a>(
+        &mut self,
+        buf: &mut Vec<'a, u8>,
+        storage_manager: &mut X86_64StorageManager<'a, '_, X86_64SystemV>,
+        sym: Symbol,
+    ) {
+        type ASM = X86_64Assembler;
+
+        let (offset, _) = storage_manager.stack_offset_and_size(&sym);
+
+        if self.general_i + 1 < Self::GENERAL_PARAM_REGS.len() {
+            let reg1 = Self::GENERAL_PARAM_REGS[self.general_i];
+            let reg2 = Self::GENERAL_PARAM_REGS[self.general_i + 1];
+
+            ASM::mov_reg64_base32(buf, reg1, offset);
+            ASM::mov_reg64_base32(buf, reg2, offset + 8);
+
+            self.general_i += 2;
+        } else {
+            // Copy to stack using return reg as buffer.
+            let reg = X86_64GeneralReg::RAX;
+
+            ASM::mov_reg64_base32(buf, reg, offset);
+            ASM::mov_stack32_reg64(buf, self.tmp_stack_offset, reg);
+
+            ASM::mov_reg64_base32(buf, reg, offset + 8);
+            ASM::mov_stack32_reg64(buf, self.tmp_stack_offset + 8, reg);
+
+            self.tmp_stack_offset += 16;
+        }
+    }
 }
 
 struct X64_64WindowsFastCallStoreArgs {
@@ -1001,15 +1062,31 @@ impl X64_64SystemVLoadArgs {
                 lambda_set.runtime_representation(),
             ),
             LayoutRepr::Struct { .. } => {
-                // for now, just also store this on the stack
+                if stack_size <= 8 {
-                storage_manager.complex_stack_arg(&sym, self.argument_offset, stack_size);
+                    self.load_arg_general_64bit(
-                self.argument_offset += stack_size as i32;
+                        buf,
+                        storage_manager,
+                        layout_interner,
+                        sym,
+                        in_layout,
+                    );
+                } else if stack_size <= 16 {
+                    self.load_arg_general_128bit(
+                        buf,
+                        storage_manager,
+                        layout_interner,
+                        sym,
+                        in_layout,
+                    );
+                } else {
+                    unreachable!("covered by an earlier branch")
+                }
             }
             LayoutRepr::Builtin(Builtin::Int(IntWidth::U128 | IntWidth::I128)) => {
-                self.load_arg_general_128bit(buf, storage_manager, sym);
+                self.load_arg_general_128bit(buf, storage_manager, layout_interner, sym, in_layout);
             }
             LayoutRepr::Builtin(Builtin::Decimal) => {
-                self.load_arg_general_128bit(buf, storage_manager, sym);
+                self.load_arg_general_128bit(buf, storage_manager, layout_interner, sym, in_layout);
             }
             LayoutRepr::Union(UnionLayout::NonRecursive(_)) => {
                 // for now, just also store this on the stack
@@ -1039,11 +1116,41 @@ impl X64_64SystemVLoadArgs {
         }
     }
 
+    fn load_arg_general_64bit(
+        &mut self,
+        buf: &mut Vec<u8>,
+        storage_manager: &mut X86_64StorageManager<'_, '_, X86_64SystemV>,
+        layout_interner: &mut STLayoutInterner<'_>,
+        sym: Symbol,
+        in_layout: InLayout<'_>,
+    ) {
+        type ASM = X86_64Assembler;
+
+        let reg1 = X86_64SystemV::GENERAL_PARAM_REGS.get(self.general_i);
+
+        match reg1 {
+            Some(reg1) => {
+                let offset =
+                    storage_manager.claim_stack_area_layout(layout_interner, sym, in_layout);
+
+                ASM::mov_base32_reg64(buf, offset, *reg1);
+
+                self.general_i += 1;
+            }
+            None => {
+                storage_manager.complex_stack_arg(&sym, self.argument_offset, 8);
+                self.argument_offset += 8;
+            }
+        }
+    }
+
     fn load_arg_general_128bit(
         &mut self,
         buf: &mut Vec<u8>,
         storage_manager: &mut X86_64StorageManager<'_, '_, X86_64SystemV>,
+        layout_interner: &mut STLayoutInterner<'_>,
         sym: Symbol,
+        in_layout: InLayout<'_>,
     ) {
         type ASM = X86_64Assembler;
 
@@ -1052,7 +1159,8 @@ impl X64_64SystemVLoadArgs {
 
         match (reg1, reg2) {
             (Some(reg1), Some(reg2)) => {
-                let offset = storage_manager.claim_stack_area_with_alignment(sym, 16, 16);
+                let offset =
+                    storage_manager.claim_stack_area_layout(layout_interner, sym, in_layout);
 
                 ASM::mov_base32_reg64(buf, offset, *reg1);
                 ASM::mov_base32_reg64(buf, offset + 8, *reg2);
@@ -1660,7 +1768,6 @@ impl CallConv<X86_64GeneralReg, X86_64FloatReg, X86_64Assembler> for X86_64Windo
         // the setlongjmp_buffer
         let env = R8;
         ASM::data_pointer(buf, relocs, String::from("setlongjmp_buffer"), env);
-        ASM::mov_reg64_mem64_offset32(buf, env, env, 0);
 
         // move the roc_str bytes into the setlongjmp_buffer
         for offset in [0, 8, 16] {
@@ -1931,6 +2038,10 @@ impl Assembler<X86_64GeneralReg, X86_64FloatReg> for X86_64Assembler {
             offset: buf.len() as u64 - 4,
             name: fn_name,
         });
+
+        // on X86_64, we actually get a pointer to a pointer
+        // so we just dereference to get just a pointer to the data
+        X86_64Assembler::mov_reg64_mem64_offset32(buf, dst, dst, 0);
     }
 
     #[inline(always)]

crates/compiler/gen_dev/src/lib.rs

@@ -1520,20 +1520,18 @@ trait Backend<'a> {
                 arg_layouts,
                 ret_layout,
             ),
-            LowLevel::StrFromUtf8Range => self.build_fn_call(
+            LowLevel::StrFromUtf8Range => {
-                sym,
+                let update_mode = self.debug_symbol("update_mode");
-                bitcode::STR_FROM_UTF8_RANGE.to_string(),
+                self.load_literal_i8(&update_mode, UpdateMode::Immutable as i8);
-                args,
+
-                arg_layouts,
+                self.build_fn_call(
-                ret_layout,
+                    sym,
-            ),
+                    bitcode::STR_FROM_UTF8_RANGE.to_string(),
-            //            LowLevel::StrToUtf8 => self.build_fn_call(
+                    &[args[0], args[1], args[2], update_mode],
-            //                sym,
+                    &[arg_layouts[0], arg_layouts[1], arg_layouts[2], Layout::U8],
-            //                bitcode::STR_TO_UTF8.to_string(),
+                    ret_layout,
-            //                args,
+                )
-            //                arg_layouts,
+            }
-            //                ret_layout,
-            //            ),
             LowLevel::StrRepeat => self.build_fn_call(
                 sym,
                 bitcode::STR_REPEAT.to_string(),

crates/compiler/gen_dev/src/object_builder.rs

@@ -147,7 +147,7 @@ fn define_setlongjmp_buffer(output: &mut Object) -> SymbolId {
         value: 0,
         size: SIZE as u64,
         kind: SymbolKind::Data,
-        scope: SymbolScope::Dynamic,
+        scope: SymbolScope::Linkage,
         weak: false,
         section: SymbolSection::Section(bss_section),
         flags: SymbolFlags::None,
@@ -217,13 +217,69 @@ fn generate_roc_panic<'a, B: Backend<'a>>(backend: &mut B, output: &mut Object)
         let relocation = match r {
             Relocation::LinkedData { offset, name } => {
                 if let Some(sym_id) = output.symbol_id(name.as_bytes()) {
-                    write::Relocation {
+                    if cfg!(all(target_arch = "aarch64", target_os = "linux")) {
-                        offset: offset + proc_offset,
+                        //     700: 90000001        adrp    x1, 0x0 <std.builtin.default_panic>
-                        size: 32,
+                        //      0000000000000700:  R_AARCH64_ADR_PREL_PG_HI21   .rodata+0x650
-                        kind: RelocationKind::GotRelative,
+                        let relocation = write::Relocation {
-                        encoding: RelocationEncoding::Generic,
+                            offset: offset + proc_offset,
-                        symbol: sym_id,
+                            size: 21,
-                        addend: -4,
+                            kind: RelocationKind::Elf(object::elf::R_AARCH64_ADR_PREL_PG_HI21),
+                            encoding: RelocationEncoding::Generic,
+                            symbol: sym_id,
+                            addend: 0,
+                        };
+
+                        output.add_relocation(text_section, relocation).unwrap();
+
+                        //     704: 91000021        add x1, x1, #0x0
+                        //      0000000000000704:  R_AARCH64_ADD_ABS_LO12_NC    .rodata+0x650
+                        write::Relocation {
+                            offset: offset + proc_offset + 4,
+                            size: 12,
+                            kind: RelocationKind::Elf(object::elf::R_AARCH64_ADD_ABS_LO12_NC),
+                            encoding: RelocationEncoding::Generic,
+                            symbol: sym_id,
+                            addend: 0,
+                        }
+                    } else if cfg!(all(target_arch = "aarch64", target_os = "macos")) {
+                        //     4dc: 90000001        adrp    x1, 0x0 <ltmp0>
+                        //      00000000000004dc:  ARM64_RELOC_PAGE21   ___unnamed_6
+                        let relocation = write::Relocation {
+                            offset: offset + proc_offset,
+                            size: 32,
+                            kind: RelocationKind::MachO {
+                                value: object::macho::ARM64_RELOC_PAGE21,
+                                relative: true,
+                            },
+                            encoding: RelocationEncoding::Generic,
+                            symbol: sym_id,
+                            addend: 0,
+                        };
+
+                        output.add_relocation(text_section, relocation).unwrap();
+
+                        //     4e0: 91000021        add x1, x1, #0x0
+                        //      00000000000004e0:  ARM64_RELOC_PAGEOFF12    ___unnamed_6
+                        write::Relocation {
+                            offset: offset + proc_offset + 4,
+                            size: 32,
+                            kind: RelocationKind::MachO {
+                                value: object::macho::ARM64_RELOC_PAGEOFF12,
+                                relative: false,
+                            },
+                            encoding: RelocationEncoding::Generic,
+                            symbol: sym_id,
+                            addend: 0,
+                        }
+                    } else {
+                        write::Relocation {
+                            offset: offset + proc_offset,
+                            size: 32,
+                            kind: RelocationKind::GotRelative,
+                            encoding: RelocationEncoding::Generic,
+                            symbol: sym_id,
+                            addend: -4,
+                        }
                     }
                 } else {
                     internal_error!("failed to find data symbol for {:?}", name);
@@ -591,7 +647,7 @@ fn build_object<'a, B: Backend<'a>>(
             // The symbol isn't defined yet and will just be used by other rc procs.
             let section_id = output.add_section(
                 output.segment_name(StandardSegment::Text).to_vec(),
-                format!(".text.{:x}", sym.as_u64()).as_bytes().to_vec(),
+                format_symbol_name(sym),
                 SectionKind::Text,
             );
 
@@ -781,7 +837,7 @@ fn build_proc_symbol<'a, B: Backend<'a>>(
 
     let section_id = output.add_section(
         output.segment_name(StandardSegment::Text).to_vec(),
-        format!(".text.{:x}", sym.as_u64()).as_bytes().to_vec(),
+        format_symbol_name(sym),
         SectionKind::Text,
     );
 
@@ -864,14 +920,72 @@ fn build_proc<'a, B: Backend<'a>>(
                 }
             }
             Relocation::LinkedData { offset, name } => {
+                add_undefined_rc_proc(output, name, &rc_proc_names);
+
                 if let Some(sym_id) = output.symbol_id(name.as_bytes()) {
-                    write::Relocation {
+                    if cfg!(all(target_arch = "aarch64", target_os = "linux")) {
-                        offset: offset + proc_offset,
+                        //     700: 90000001        adrp    x1, 0x0 <std.builtin.default_panic>
-                        size: 32,
+                        //      0000000000000700:  R_AARCH64_ADR_PREL_PG_HI21   .rodata+0x650
-                        kind: RelocationKind::GotRelative,
+                        let r = write::Relocation {
-                        encoding: RelocationEncoding::Generic,
+                            offset: proc_offset + offset,
-                        symbol: sym_id,
+                            size: 21,
-                        addend: -4,
+                            kind: RelocationKind::Elf(object::elf::R_AARCH64_ADR_PREL_PG_HI21),
+                            encoding: RelocationEncoding::Generic,
+                            symbol: sym_id,
+                            addend: -4,
+                        };
+
+                        relocations.push((section_id, r));
+
+                        //     704: 91000021        add x1, x1, #0x0
+                        //      0000000000000704:  R_AARCH64_ADD_ABS_LO12_NC    .rodata+0x650
+                        write::Relocation {
+                            offset: proc_offset + offset + 4,
+                            size: 12,
+                            kind: RelocationKind::Elf(object::elf::R_AARCH64_ADD_ABS_LO12_NC),
+                            encoding: RelocationEncoding::Generic,
+                            symbol: sym_id,
+                            addend: 0,
+                        }
+                    } else if cfg!(all(target_arch = "aarch64", target_os = "macos")) {
+                        //    4ed0: 90000000        adrp    x0, 0x4000 <_std.unicode.utf8Decode4+0x16c>
+                        //      0000000000004ed0:  ARM64_RELOC_PAGE21   ___unnamed_11
+                        let r = write::Relocation {
+                            offset: proc_offset + offset,
+                            size: 21,
+                            kind: RelocationKind::MachO {
+                                value: object::macho::ARM64_RELOC_PAGE21,
+                                relative: true,
+                            },
+                            encoding: RelocationEncoding::Generic,
+                            symbol: sym_id,
+                            addend: 0,
+                        };
+
+                        relocations.push((section_id, r));
+
+                        //  4ed4: 91000000      add x0, x0, #0x0
+                        //      0000000000004ed4:  ARM64_RELOC_PAGEOFF12    ___unnamed_11
+                        write::Relocation {
+                            offset: proc_offset + offset + 4,
+                            size: 12,
+                            kind: RelocationKind::MachO {
+                                value: object::macho::ARM64_RELOC_PAGEOFF12,
+                                relative: false,
+                            },
+                            encoding: RelocationEncoding::Generic,
+                            symbol: sym_id,
+                            addend: 0,
+                        }
+                    } else {
+                        write::Relocation {
+                            offset: offset + proc_offset,
+                            size: 32,
+                            kind: RelocationKind::GotRelative,
+                            encoding: RelocationEncoding::Generic,
+                            symbol: sym_id,
+                            addend: -4,
+                        }
                     }
                 } else {
                     internal_error!("failed to find data symbol for {:?}", name);
@@ -893,30 +1007,7 @@ fn build_proc<'a, B: Backend<'a>>(
                     output.add_symbol(builtin_symbol);
                 }
 
-                // If the symbol is an undefined reference counting procedure, we need to add it here.
+                add_undefined_rc_proc(output, name, &rc_proc_names);
-                if output.symbol_id(name.as_bytes()).is_none() {
-                    for (sym, rc_name) in rc_proc_names.iter() {
-                        if name == rc_name {
-                            let section_id = output.add_section(
-                                output.segment_name(StandardSegment::Text).to_vec(),
-                                format!(".text.{:x}", sym.as_u64()).as_bytes().to_vec(),
-                                SectionKind::Text,
-                            );
-
-                            let rc_symbol = Symbol {
-                                name: name.as_bytes().to_vec(),
-                                value: 0,
-                                size: 0,
-                                kind: SymbolKind::Text,
-                                scope: SymbolScope::Linkage,
-                                weak: false,
-                                section: SymbolSection::Section(section_id),
-                                flags: SymbolFlags::None,
-                            };
-                            output.add_symbol(rc_symbol);
-                        }
-                    }
-                }
 
                 if let Some(sym_id) = output.symbol_id(name.as_bytes()) {
                     create_relocation(target_info, sym_id, offset + proc_offset)
@@ -929,3 +1020,41 @@ fn build_proc<'a, B: Backend<'a>>(
         relocations.push((section_id, elfreloc));
     }
 }
+
+fn add_undefined_rc_proc(
+    output: &mut Object<'_>,
+    name: &String,
+    rc_proc_names: &Vec<'_, (symbol::Symbol, String)>,
+) {
+    // If the symbol is an undefined reference counting procedure, we need to add it here.
+    if output.symbol_id(name.as_bytes()).is_none() {
+        for (sym, rc_name) in rc_proc_names.iter() {
+            if name == rc_name {
+                let section_id = output.add_section(
+                    output.segment_name(StandardSegment::Text).to_vec(),
+                    format_symbol_name(*sym),
+                    SectionKind::Text,
+                );
+
+                let rc_symbol = Symbol {
+                    name: name.as_bytes().to_vec(),
+                    value: 0,
+                    size: 0,
+                    kind: SymbolKind::Text,
+                    scope: SymbolScope::Linkage,
+                    weak: false,
+                    section: SymbolSection::Section(section_id),
+                    flags: SymbolFlags::None,
+                };
+                output.add_symbol(rc_symbol);
+            }
+        }
+    }
+}
+
+fn format_symbol_name(sym: roc_module::symbol::Symbol) -> std::vec::Vec<u8> {
+    let name = format!(".text.{:x}", sym.as_u64());
+    let length = Ord::min(name.len(), 16);
+
+    name.as_bytes()[..length].to_vec()
+}

crates/compiler/gen_llvm/src/llvm/build.rs

@@ -1886,10 +1886,9 @@ fn build_tag<'a, 'ctx>(
                 &[fields],
             );
 
-            let struct_type = env.context.struct_type(
+            let struct_type = env
-                env.arena.alloc_slice_fill_iter(field_types.into_iter()),
+                .context
-                false,
+                .struct_type(env.arena.alloc_slice_fill_iter(field_types), false);
-            );
 
             struct_pointer_from_fields(
                 env,
@@ -5911,8 +5910,18 @@ fn to_cc_type<'a, 'ctx>(
     layout_interner: &STLayoutInterner<'a>,
     layout: InLayout<'a>,
 ) -> BasicTypeEnum<'ctx> {
-    match layout_interner.runtime_representation(layout) {
+    let layout_repr = layout_interner.runtime_representation(layout);
+    match layout_repr {
         LayoutRepr::Builtin(builtin) => to_cc_type_builtin(env, &builtin),
+        LayoutRepr::Struct(_) => {
+            let stack_type = basic_type_from_layout(env, layout_interner, layout_repr);
+
+            if layout_repr.is_passed_by_reference(layout_interner) {
+                stack_type.ptr_type(AddressSpace::default()).into()
+            } else {
+                stack_type
+            }
+        }
         _ => {
             // TODO this is almost certainly incorrect for bigger structs
             basic_type_from_layout(env, layout_interner, layout_interner.get_repr(layout))

crates/compiler/gen_llvm/src/llvm/lowlevel.rs

@@ -2168,12 +2168,13 @@ fn build_dec_unary_op<'a, 'ctx>(
     use roc_module::low_level::LowLevel::*;
 
     match op {
-        NumSin => dec_unary_op(env, bitcode::DEC_SIN, arg),
+        NumAbs => dec_unary_op(env, bitcode::DEC_ABS, arg),
-        NumCos => dec_unary_op(env, bitcode::DEC_COS, arg),
-        NumTan => dec_unary_op(env, bitcode::DEC_TAN, arg),
-        NumAsin => dec_unary_op(env, bitcode::DEC_ASIN, arg),
         NumAcos => dec_unary_op(env, bitcode::DEC_ACOS, arg),
+        NumAsin => dec_unary_op(env, bitcode::DEC_ASIN, arg),
         NumAtan => dec_unary_op(env, bitcode::DEC_ATAN, arg),
+        NumCos => dec_unary_op(env, bitcode::DEC_COS, arg),
+        NumSin => dec_unary_op(env, bitcode::DEC_SIN, arg),
+        NumTan => dec_unary_op(env, bitcode::DEC_TAN, arg),
 
         _ => {
             unreachable!("Unrecognized dec unary operation: {:?}", op);
@@ -2233,6 +2234,16 @@ fn build_dec_binop<'a, 'ctx>(
 
         NumLt => call_bitcode_fn(env, &[lhs, rhs], &bitcode::NUM_LESS_THAN[IntWidth::I128]),
         NumGt => call_bitcode_fn(env, &[lhs, rhs], &bitcode::NUM_GREATER_THAN[IntWidth::I128]),
+        NumLte => call_bitcode_fn(
+            env,
+            &[lhs, rhs],
+            &bitcode::NUM_LESS_THAN_OR_EQUAL[IntWidth::I128],
+        ),
+        NumGte => call_bitcode_fn(
+            env,
+            &[lhs, rhs],
+            &bitcode::NUM_GREATER_THAN_OR_EQUAL[IntWidth::I128],
+        ),
         _ => {
             unreachable!("Unrecognized dec binary operation: {:?}", op);
         }

crates/compiler/ident/src/lib.rs

@@ -276,7 +276,7 @@ impl Eq for IdentStr {}
 
 impl PartialOrd for IdentStr {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        self.as_str().partial_cmp(other.as_str())
+        Some(self.cmp(other))
     }
 }
 

crates/compiler/load/build.rs

@@ -105,7 +105,6 @@ fn write_types_for_module_real(module_id: ModuleId, filename: &str, output_path:
     };
 
     let problems = report_problems(
-        module.total_problems(),
         &module.sources,
         &module.interns,
         &mut module.can_problems,

crates/compiler/load_internal/src/file.rs

@@ -954,7 +954,6 @@ pub enum LoadingProblem<'a> {
     ParsingFailed(FileError<'a, SyntaxError<'a>>),
     UnexpectedHeader(String),
 
-    MsgChannelDied,
     ErrJoiningWorkerThreads,
     TriedToImportAppModule,
 
@@ -964,6 +963,27 @@ pub enum LoadingProblem<'a> {
     ImportCycle(PathBuf, Vec<ModuleId>),
     IncorrectModuleName(FileError<'a, IncorrectModuleName<'a>>),
     CouldNotFindCacheDir,
+    ChannelProblem(ChannelProblem),
+}
+
+#[derive(Debug)]
+pub enum ChannelProblem {
+    FailedToEnqueueTask(Box<PanicReportInfo>),
+    FailedToSendRootMsg,
+    FailedToSendWorkerShutdownMsg,
+    ChannelDisconnected,
+    FailedToSendManyMsg,
+    FailedToSendFinishedSpecializationsMsg,
+    FailedToSendTaskMsg,
+    FailedToSendFinishedTypeCheckingMsg,
+}
+
+#[derive(Debug)]
+pub struct PanicReportInfo {
+    can_problems: MutMap<ModuleId, Vec<roc_problem::can::Problem>>,
+    type_problems: MutMap<ModuleId, Vec<TypeError>>,
+    sources: MutMap<ModuleId, (PathBuf, Box<str>)>,
+    interns: Interns,
 }
 
 pub enum Phases {
@@ -980,13 +1000,35 @@ fn enqueue_task<'a>(
     injector: &Injector<BuildTask<'a>>,
     listeners: &[Sender<WorkerMsg>],
     task: BuildTask<'a>,
+    state: &State<'a>,
 ) -> Result<(), LoadingProblem<'a>> {
     injector.push(task);
 
     for listener in listeners {
-        listener
+        listener.send(WorkerMsg::TaskAdded).map_err(|_| {
-            .send(WorkerMsg::TaskAdded)
+            let module_ids = { (*state.arc_modules).lock().clone() }.into_module_ids();
-            .map_err(|_| LoadingProblem::MsgChannelDied)?;
+
+            let interns = Interns {
+                module_ids,
+                all_ident_ids: state.constrained_ident_ids.clone(),
+            };
+
+            LoadingProblem::ChannelProblem(ChannelProblem::FailedToEnqueueTask(Box::new(
+                PanicReportInfo {
+                    can_problems: state.module_cache.can_problems.clone(),
+                    type_problems: state.module_cache.type_problems.clone(),
+                    interns,
+                    sources: state
+                        .module_cache
+                        .sources
+                        .iter()
+                        .map(|(key, (path, str_ref))| {
+                            (*key, (path.clone(), str_ref.to_string().into_boxed_str()))
+                        })
+                        .collect(),
+                },
+            )))
+        })?;
     }
 
     Ok(())
@@ -1030,7 +1072,7 @@ pub fn load_and_typecheck_str<'a>(
         roc_cache_dir,
         load_config,
     )? {
-        Monomorphized(_) => unreachable!(""),
+        Monomorphized(_) => unreachable!(),
         TypeChecked(module) => Ok(module),
     }
 }
@@ -1325,7 +1367,7 @@ pub fn load_single_threaded<'a>(
 
     msg_tx
         .send(root_msg)
-        .map_err(|_| LoadingProblem::MsgChannelDied)?;
+        .map_err(|_| LoadingProblem::ChannelProblem(ChannelProblem::FailedToSendRootMsg))?;
 
     let number_of_workers = 1;
     let mut state = State::new(
@@ -1575,7 +1617,9 @@ fn state_thread_step<'a>(
         }
         Err(err) => match err {
             crossbeam::channel::TryRecvError::Empty => Ok(ControlFlow::Continue(state)),
-            crossbeam::channel::TryRecvError::Disconnected => Err(LoadingProblem::MsgChannelDied),
+            crossbeam::channel::TryRecvError::Disconnected => Err(LoadingProblem::ChannelProblem(
+                ChannelProblem::ChannelDisconnected,
+            )),
         },
     }
 }
@@ -1647,7 +1691,7 @@ fn load_multi_threaded<'a>(
     let (msg_tx, msg_rx) = bounded(1024);
     msg_tx
         .send(root_msg)
-        .map_err(|_| LoadingProblem::MsgChannelDied)?;
+        .map_err(|_| LoadingProblem::ChannelProblem(ChannelProblem::FailedToSendRootMsg))?;
 
     // Reserve one CPU for the main thread, and let all the others be eligible
     // to spawn workers.
@@ -1705,10 +1749,15 @@ fn load_multi_threaded<'a>(
     // Get a reference to the completed stealers, so we can send that
     // reference to each worker. (Slices are Sync, but bumpalo Vecs are not.)
     let stealers = stealers.into_bump_slice();
-
     let it = worker_arenas.iter_mut();
+
+    let mut can_problems_recorded = MutMap::default();
+    let mut type_problems_recorded = MutMap::default();
+    let mut sources_recorded = MutMap::default();
+    let mut interns_recorded = Interns::default();
+
     {
-        thread::scope(|thread_scope| {
+        let thread_result = thread::scope(|thread_scope| {
             let mut worker_listeners =
                 bumpalo::collections::Vec::with_capacity_in(num_workers, arena);
 
@@ -1744,7 +1793,9 @@ fn load_multi_threaded<'a>(
                         )
                     });
 
-                res_join_handle.unwrap();
+                res_join_handle.unwrap_or_else(|_| {
+                    panic!("Join handle panicked!");
+                });
             }
 
             // We've now distributed one worker queue to each thread.
@@ -1760,9 +1811,13 @@ fn load_multi_threaded<'a>(
             macro_rules! shut_down_worker_threads {
                 () => {
                     for listener in worker_listeners {
-                        listener
+                        // We intentionally don't propagate this Result, because even if
-                            .send(WorkerMsg::Shutdown)
+                        // shutting down a worker failed (which can happen if a a panic
-                            .map_err(|_| LoadingProblem::MsgChannelDied)?;
+                        // occurred on that thread), we want to continue shutting down
+                        // the others regardless.
+                        if listener.send(WorkerMsg::Shutdown).is_err() {
+                            log!("There was an error trying to shutdown a worker thread. One reason this can happen is if the thread panicked.");
+                        }
                     }
                 };
             }
@@ -1788,6 +1843,36 @@ fn load_multi_threaded<'a>(
                         state = new_state;
                         continue;
                     }
+                    Err(LoadingProblem::ChannelProblem(ChannelProblem::FailedToEnqueueTask(
+                        info,
+                    ))) => {
+                        let PanicReportInfo {
+                            can_problems,
+                            type_problems,
+                            sources,
+                            interns,
+                        } = *info;
+
+                        // Record these for later.
+                        can_problems_recorded = can_problems;
+                        type_problems_recorded = type_problems;
+                        sources_recorded = sources;
+                        interns_recorded = interns;
+
+                        shut_down_worker_threads!();
+
+                        return Err(LoadingProblem::ChannelProblem(
+                            ChannelProblem::FailedToEnqueueTask(Box::new(PanicReportInfo {
+                                // This return value never gets used, so don't bother
+                                // cloning these in order to be able to return them.
+                                // Really, anything could go here.
+                                can_problems: Default::default(),
+                                type_problems: Default::default(),
+                                sources: Default::default(),
+                                interns: Default::default(),
+                            })),
+                        ));
+                    }
                     Err(e) => {
                         shut_down_worker_threads!();
 
@@ -1795,9 +1880,33 @@ fn load_multi_threaded<'a>(
                     }
                 }
             }
+        });
+
+        thread_result.unwrap_or_else(|_| {
+            // This most likely means a panic occurred in one of the threads.
+            // Therefore, print all the error info we've accumulated, and note afterwards
+            // that there was a compiler crash.
+            //
+            // Unfortunately, this often has no information to report if there's a panic in mono.
+            // Consequently, the following ends up being more misleading than helpful.
+            //
+            // roc_reporting::cli::report_problems(
+            //     &sources_recorded,
+            //     &mut interns_recorded,
+            //     &mut can_problems_recorded,
+            //     &mut type_problems_recorded,
+            // )
+            // .print_to_stdout(Duration::default()); // TODO determine total elapsed time and use it here
+
+            Err(LoadingProblem::FormattedReport(
+                concat!(
+                    "\n\nThere was an unrecoverable error in the Roc compiler. The `roc check` ",
+                    "command can sometimes give a more helpful error report than other commands.\n\n"
+                )
+                .to_string(),
+            ))
         })
     }
-    .unwrap()
 }
 
 fn worker_task_step<'a>(
@@ -1843,8 +1952,8 @@ fn worker_task_step<'a>(
 
                         match result {
                             Ok(()) => {}
-                            Err(LoadingProblem::MsgChannelDied) => {
+                            Err(LoadingProblem::ChannelProblem(problem)) => {
-                                panic!("Msg channel closed unexpectedly.")
+                                panic!("Channel problem: {problem:?}");
                             }
                             Err(LoadingProblem::ParsingFailed(problem)) => {
                                 msg_tx.send(Msg::FailedToParse(problem)).unwrap();
@@ -1942,8 +2051,8 @@ fn worker_task<'a>(
 
                     match result {
                         Ok(()) => {}
-                        Err(LoadingProblem::MsgChannelDied) => {
+                        Err(LoadingProblem::ChannelProblem(problem)) => {
-                            panic!("Msg channel closed unexpectedly.")
+                            panic!("Channel problem: {problem:?}");
                         }
                         Err(LoadingProblem::ParsingFailed(problem)) => {
                             msg_tx.send(Msg::FailedToParse(problem)).unwrap();
@@ -1976,8 +2085,10 @@ fn start_tasks<'a>(
     worker_listeners: &'a [Sender<WorkerMsg>],
 ) -> Result<(), LoadingProblem<'a>> {
     for (module_id, phase) in work {
-        for task in start_phase(module_id, phase, arena, state) {
+        let tasks = start_phase(module_id, phase, arena, state);
-            enqueue_task(injector, worker_listeners, task)?
+
+        for task in tasks {
+            enqueue_task(injector, worker_listeners, task, state)?
         }
     }
 
@@ -2086,9 +2197,9 @@ fn update<'a>(
         Many(messages) => {
             // enqueue all these message
             for msg in messages {
-                msg_tx
+                msg_tx.send(msg).map_err(|_| {
-                    .send(msg)
+                    LoadingProblem::ChannelProblem(ChannelProblem::FailedToSendManyMsg)
-                    .map_err(|_| LoadingProblem::MsgChannelDied)?;
+                })?;
             }
 
             Ok(state)
@@ -2237,7 +2348,7 @@ fn update<'a>(
                         // If we're building an app module, and this was the platform
                         // specified in its header's `to` field, record it as our platform.
                         if state.opt_platform_shorthand == Some(config_shorthand) {
-                            debug_assert!(matches!(state.platform_data, None));
+                            debug_assert!(state.platform_data.is_none());
 
                             state.platform_data = Some(PlatformData {
                                 module_id: header.module_id,
@@ -2552,7 +2663,11 @@ fn update<'a>(
                         #[cfg(debug_assertions)]
                         checkmate,
                     })
-                    .map_err(|_| LoadingProblem::MsgChannelDied)?;
+                    .map_err(|_| {
+                        LoadingProblem::ChannelProblem(
+                            ChannelProblem::FailedToSendFinishedTypeCheckingMsg,
+                        )
+                    })?;
 
                 // bookkeeping
                 state.declarations_by_id.insert(module_id, decls);
@@ -2874,7 +2989,11 @@ fn update<'a>(
                             exposed_to_host: state.exposed_to_host.clone(),
                             module_expectations,
                         })
-                        .map_err(|_| LoadingProblem::MsgChannelDied)?;
+                        .map_err(|_| {
+                            LoadingProblem::ChannelProblem(
+                                ChannelProblem::FailedToSendFinishedSpecializationsMsg,
+                            )
+                        })?;
 
                     Ok(state)
                 }
@@ -6308,7 +6427,7 @@ fn run_task<'a>(
 
     msg_tx
         .send(msg)
-        .map_err(|_| LoadingProblem::MsgChannelDied)?;
+        .map_err(|_| LoadingProblem::ChannelProblem(ChannelProblem::FailedToSendTaskMsg))?;
 
     Ok(())
 }

crates/compiler/load_internal/src/module.rs

@@ -223,22 +223,6 @@ pub struct ExposedToHost {
     pub getters: Vec<Symbol>,
 }
 
-impl<'a> MonomorphizedModule<'a> {
-    pub fn total_problems(&self) -> usize {
-        let mut total = 0;
-
-        for problems in self.can_problems.values() {
-            total += problems.len();
-        }
-
-        for problems in self.type_problems.values() {
-            total += problems.len();
-        }
-
-        total
-    }
-}
-
 #[derive(Debug)]
 pub struct ModuleTiming {
     pub read_roc_file: Duration,

crates/compiler/load_internal/src/work.rs

@@ -70,7 +70,7 @@ impl MakeSpecializationsDependents {
             "already added successors for module '{module_id:?}'"
         );
 
-        entry.succ.extend(succ.into_iter());
+        entry.succ.extend(succ);
 
         // The module for derives implicitly depends on every other module
         entry.succ.insert(ModuleId::DERIVED_GEN);
@@ -331,16 +331,13 @@ impl<'a> Dependencies<'a> {
                     None | Some(Status::NotStarted) | Some(Status::Pending) => {
                         // this shorthand is not resolved, add a dependency
                         {
-                            let entry = self
+                            let entry = self.waiting_for.entry(next_step.clone()).or_default();
-                                .waiting_for
-                                .entry(next_step.clone())
-                                .or_insert_with(Default::default);
 
                             entry.insert(job.clone());
                         }
 
                         {
-                            let entry = self.notifies.entry(job).or_insert_with(Default::default);
+                            let entry = self.notifies.entry(job).or_default();
 
                             entry.insert(next_step);
                         }

crates/compiler/module/src/symbol.rs

@@ -1346,6 +1346,7 @@ define_builtins! {
         56 STR_IS_VALID_SCALAR: "isValidScalar"
         57 STR_RELEASE_EXCESS_CAPACITY: "releaseExcessCapacity"
         58 STR_WALK_UTF8: "walkUtf8"
+        59 STR_CONTAINS: "contains"
     }
     6 LIST: "List" => {
         0 LIST_LIST: "List" exposed_apply_type=true // the List.List type alias
@@ -1432,6 +1433,7 @@ define_builtins! {
         81 LIST_RELEASE_EXCESS_CAPACITY: "releaseExcessCapacity"
         82 LIST_UPDATE: "update"
         83 LIST_WALK_WITH_INDEX: "walkWithIndex"
+        84 LIST_CHUNKS_OF: "chunksOf"
     }
     7 RESULT: "Result" => {
         0 RESULT_RESULT: "Result" exposed_type=true // the Result.Result type alias

crates/compiler/mono/src/ir.rs

@@ -77,8 +77,8 @@ roc_error_macros::assert_sizeof_wasm!(Call, 44);
 roc_error_macros::assert_sizeof_wasm!(CallType, 36);
 
 roc_error_macros::assert_sizeof_non_wasm!(Literal, 3 * 8);
-roc_error_macros::assert_sizeof_non_wasm!(Expr, 10 * 8);
+roc_error_macros::assert_sizeof_non_wasm!(Expr, 9 * 8);
-roc_error_macros::assert_sizeof_non_wasm!(Stmt, 13 * 8);
+roc_error_macros::assert_sizeof_non_wasm!(Stmt, 12 * 8);
 roc_error_macros::assert_sizeof_non_wasm!(ProcLayout, 5 * 8);
 roc_error_macros::assert_sizeof_non_wasm!(Call, 9 * 8);
 roc_error_macros::assert_sizeof_non_wasm!(CallType, 7 * 8);
@@ -198,7 +198,7 @@ impl<'a> PartialProcs<'a> {
     pub fn drain(self) -> impl Iterator<Item = (Symbol, PartialProc<'a>)> {
         debug_assert_eq!(self.symbols.len(), self.partial_procs.len());
 
-        self.symbols.into_iter().zip(self.partial_procs.into_iter())
+        self.symbols.into_iter().zip(self.partial_procs)
     }
 }
 
@@ -541,7 +541,7 @@ impl<'a> ExternalSpecializations<'a> {
             self.storage.into_storage_subs(),
             self.symbol_or_lambda
                 .into_iter()
-                .zip(self.types_to_specialize.into_iter()),
+                .zip(self.types_to_specialize),
         )
     }
 
@@ -656,8 +656,8 @@ impl<'a> Specialized<'a> {
     fn into_iter_assert_done(self) -> impl Iterator<Item = (Symbol, ProcLayout<'a>, Proc<'a>)> {
         self.symbols
             .into_iter()
-            .zip(self.proc_layouts.into_iter())
+            .zip(self.proc_layouts)
-            .zip(self.procedures.into_iter())
+            .zip(self.procedures)
             .filter_map(|((s, l), in_progress)| {
                 if let Symbol::REMOVED_SPECIALIZATION = s {
                     None

crates/compiler/mono/src/layout.rs

@@ -1937,7 +1937,7 @@ impl<'a> LambdaSet<'a> {
                     // it to both vectors.
                     let mut joined = set
                         .into_iter()
-                        .zip(set_with_variables.into_iter())
+                        .zip(set_with_variables)
                         .collect::<std::vec::Vec<_>>();
                     joined.sort_by(|(lam_and_captures1, _), (lam_and_captures2, _)| {
                         lam_and_captures1.cmp(lam_and_captures2)

crates/compiler/parse/src/keyword.rs

@@ -14,6 +14,4 @@ pub const CRASH: &str = "crash";
 pub const IMPLEMENTS: &str = "implements";
 pub const WHERE: &str = "where";
 
-pub const KEYWORDS: [&str; 11] = [
+pub const KEYWORDS: [&str; 10] = [IF, THEN, ELSE, WHEN, AS, IS, DBG, EXPECT, EXPECT_FX, CRASH];
-    IF, THEN, ELSE, WHEN, AS, IS, DBG, EXPECT, EXPECT_FX, CRASH, WHERE,
-];

crates/compiler/parse/src/parser.rs

@@ -1634,6 +1634,7 @@ macro_rules! word1_check_indent {
 macro_rules! map {
     ($parser:expr, $transform:expr) => {
         move |arena, state, min_indent| {
+            #[allow(clippy::redundant_closure_call)]
             $parser
                 .parse(arena, state, min_indent)
                 .map(|(progress, output, next_state)| (progress, $transform(output), next_state))
@@ -1645,6 +1646,7 @@ macro_rules! map {
 macro_rules! map_with_arena {
     ($parser:expr, $transform:expr) => {
         move |arena, state, min_indent| {
+            #[allow(clippy::redundant_closure_call)]
             $parser
                 .parse(arena, state, min_indent)
                 .map(|(progress, output, next_state)| {

crates/compiler/parse/src/type_annotation.rs

@@ -729,7 +729,9 @@ fn parse_type_variable<'a>(
         min_indent,
     ) {
         Ok((_, name, state)) => {
-            if name == crate::keyword::IMPLEMENTS && stop_at_surface_has {
+            if name == crate::keyword::WHERE
+                || (name == crate::keyword::IMPLEMENTS && stop_at_surface_has)
+            {
                 Err((NoProgress, EType::TEnd(state.pos())))
             } else {
                 let answer = TypeAnnotation::BoundVariable(name);

crates/compiler/test_gen/src/gen_abilities.rs

@@ -808,7 +808,7 @@ fn encode_derived_list_of_lists_of_strings() {
 
 #[test]
 #[cfg(not(debug_assertions))]
-#[cfg(all(any(feature = "gen-llvm", feature = "gen-wasm")))]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
 fn encode_derived_record_with_many_types() {
     assert_evals_to!(
         indoc!(
@@ -882,7 +882,7 @@ fn encode_derived_tuple_of_tuples() {
 
 #[test]
 #[cfg(not(debug_assertions))]
-#[cfg(all(any(feature = "gen-llvm", feature = "gen-wasm")))]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
 fn encode_derived_generic_record_with_different_field_types() {
     assert_evals_to!(
         indoc!(
@@ -908,7 +908,7 @@ fn encode_derived_generic_record_with_different_field_types() {
 }
 
 #[test]
-#[cfg(all(any(feature = "gen-llvm", feature = "gen-wasm")))]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
 fn encode_derived_generic_tag_with_different_field_types() {
     assert_evals_to!(
         indoc!(
@@ -1057,13 +1057,13 @@ mod decode_immediate {
     #[cfg(all(test, any(feature = "gen-llvm", feature = "gen-wasm")))]
     use indoc::indoc;
 
-    #[cfg(all(test, any(feature = "gen-llvm")))]
+    #[cfg(all(test, feature = "gen-llvm"))]
     use roc_std::RocStr;
 
     use crate::helpers::with_larger_debug_stack;
 
     #[test]
-    #[cfg(any(feature = "gen-llvm"))]
+    #[cfg(feature = "gen-llvm")]
     fn string() {
         with_larger_debug_stack(|| {
             assert_evals_to!(
@@ -1084,7 +1084,7 @@ mod decode_immediate {
     }
 
     #[test]
-    #[cfg(any(feature = "gen-llvm"))]
+    #[cfg(feature = "gen-llvm")]
     fn ranged_number() {
         assert_evals_to!(
             indoc!(
@@ -1106,7 +1106,7 @@ mod decode_immediate {
     }
 
     #[test]
-    #[cfg(any(feature = "gen-llvm"))]
+    #[cfg(feature = "gen-llvm")]
     fn bool() {
         assert_evals_to!(
             indoc!(
@@ -1127,7 +1127,7 @@ mod decode_immediate {
     macro_rules! num_immediate {
         ($($num:expr, $typ:ident)*) => {$(
             #[test]
-            #[cfg(any(feature = "gen-llvm"))]
+            #[cfg(feature = "gen-llvm")]
             fn $typ() {
                 assert_evals_to!(
                     &format!(indoc!(
@@ -1206,7 +1206,7 @@ fn decode_list_of_strings() {
 }
 
 #[test]
-#[cfg(all(any(feature = "gen-llvm", feature = "gen-wasm")))]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
 fn encode_then_decode_list_of_strings() {
     with_larger_debug_stack(|| {
         assert_evals_to!(
@@ -1227,7 +1227,7 @@ fn encode_then_decode_list_of_strings() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 #[ignore = "#3696: Currently hits some weird panic in borrow checking, not sure if it's directly related to abilities."]
 fn encode_then_decode_list_of_lists_of_strings() {
     with_larger_debug_stack(|| {

crates/compiler/test_gen/src/gen_erased.rs

@@ -4,7 +4,7 @@ use crate::helpers::llvm::assert_evals_to_erased;
 use indoc::indoc;
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn capture_multiple() {
     assert_evals_to_erased!(
         indoc!(
@@ -23,7 +23,7 @@ fn capture_multiple() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn multi_branch_capturing() {
     assert_evals_to_erased!(
         indoc!(

crates/compiler/test_gen/src/gen_list.rs

@@ -487,6 +487,38 @@ fn list_split_last() {
     );
 }
 
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
+fn list_chunks_of() {
+    assert_evals_to!(
+        "List.chunksOf [1, 2, 3, 4, 5, 6, 7, 8] 3",
+        RocList::<RocList<i64>>::from_slice(&[
+            RocList::from_slice(&[1, 2, 3]),
+            RocList::from_slice(&[4, 5, 6]),
+            RocList::from_slice(&[7, 8]),
+        ]),
+        RocList<RocList<i64>>
+    );
+
+    assert_evals_to!(
+        "List.chunksOf [1, 2, 3, 4] 5",
+        RocList::<RocList<i64>>::from_slice(&[RocList::from_slice(&[1, 2, 3, 4]),]),
+        RocList<RocList<i64>>
+    );
+
+    assert_evals_to!(
+        "List.chunksOf [1, 2, 3] 0",
+        RocList::<RocList<i64>>::from_slice(&[]),
+        RocList<RocList<i64>>
+    );
+
+    assert_evals_to!(
+        "List.chunksOf [] 5",
+        RocList::<RocList<i64>>::from_slice(&[]),
+        RocList<RocList<i64>>
+    );
+}
+
 #[test]
 #[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
 fn list_drop() {
@@ -3014,7 +3046,7 @@ fn list_all() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn list_all_empty_with_unknown_element_type() {
     assert_evals_to!("List.all [] (\\_ -> Bool.true)", true, bool);
 }

crates/compiler/test_gen/src/gen_num.rs

@@ -1558,7 +1558,7 @@ fn tail_call_elimination() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-dev"))]
+#[cfg(feature = "gen-dev")]
 fn int_negate_dev() {
     // TODO
     // dev backend yet to have `Num.maxI64` or `Num.minI64`.
@@ -2317,7 +2317,7 @@ fn min_f32() {
 }
 
 #[test]
-#[cfg(all(any(feature = "gen-llvm"), not(feature = "gen-llvm-wasm")))]
+#[cfg(all(feature = "gen-llvm", not(feature = "gen-llvm-wasm")))]
 fn to_nat_truncate_wraps() {
     let input = "Num.toNat 10_000_000_000_000_000_000_000i128";
     assert_evals_to!(input, 1864712049423024128, u64)
@@ -3885,7 +3885,7 @@ fn num_abs_diff_int() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn num_abs_diff_large_bits() {
     assert_evals_to!(r#"Num.absDiff 0u128 0u128"#, 0, u128);
     assert_evals_to!(r#"Num.absDiff 1u128 2u128"#, 1, u128);
@@ -3918,7 +3918,7 @@ fn num_abs_int_min_overflow() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 #[should_panic(expected = r#"Roc failed with message: "integer subtraction overflowed!"#)]
 fn num_abs_large_bits_min_overflow() {
     assert_evals_to!(r#"Num.absDiff Num.minI128 0"#, 0, i128);

crates/compiler/test_gen/src/gen_primitives.rs

@@ -3332,6 +3332,26 @@ fn box_num() {
     assert_evals_to!("Box.box 123u64", RocBox::new(123), RocBox<u64>)
 }
 
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
+fn box_record_2_u64() {
+    assert_evals_to!(
+        "Box.box { x: 1u64, y: 2u64 }",
+        RocBox::new((1u64, 2u64)),
+        RocBox<(u64, u64)>
+    );
+}
+
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
+fn box_record_3_u64() {
+    assert_evals_to!(
+        "Box.box { x: 1u64, y: 2u64, z: 3u64 }",
+        RocBox::new((1u64, 2u64, 3u64)),
+        RocBox<(u64, u64, u64)>
+    );
+}
+
 #[test]
 #[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
 fn box_str() {
@@ -3386,7 +3406,35 @@ fn box_and_unbox_f32() {
 
 #[test]
 #[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
-fn box_and_unbox_record() {
+fn box_and_unbox_record_2_u64() {
+    assert_evals_to!(
+        indoc!(
+            r#"
+            Box.unbox (Box.box { a: 15u64, b: 27u64 })
+            "#
+        ),
+        (15, 27),
+        (u64, u64)
+    )
+}
+
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
+fn box_and_unbox_record_3_u64() {
+    assert_evals_to!(
+        indoc!(
+            r#"
+            Box.unbox (Box.box { a: 15u64, b: 27u64, c: 34u64 })
+            "#
+        ),
+        (15, 27, 34),
+        (u64, u64, u64)
+    )
+}
+
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
+fn box_and_unbox_record_2_u8() {
     assert_evals_to!(
         indoc!(
             r#"
@@ -3398,6 +3446,20 @@ fn box_and_unbox_record() {
     )
 }
 
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
+fn box_and_unbox_record_3_u8() {
+    assert_evals_to!(
+        indoc!(
+            r#"
+            Box.unbox (Box.box { a: 15u8, b: 27u8, c: 34u8 })
+            "#
+        ),
+        (15, 27, 34),
+        (u8, u8, u8)
+    )
+}
+
 #[test]
 #[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
 fn box_and_unbox_tag_union() {
@@ -4460,7 +4522,7 @@ fn layout_cache_structure_with_multiple_recursive_structures() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn reset_recursive_type_wraps_in_named_type() {
     assert_evals_to!(
         indoc!(
@@ -4550,3 +4612,21 @@ fn linked_list_trmc() {
         i64
     );
 }
+
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))]
+fn many_arguments() {
+    // exhausts all argument registers on x86 and aarch
+    assert_evals_to!(
+        indoc!(
+            r#"
+            fun = \a,b,c,d, e,f,g,h, i ->
+                (a + b + c + d) + (e + f + g + h) + i
+
+            fun 0i64 1 2 3 4 5 6 7 8
+            "#
+        ),
+        1 + 2 + 3 + 4 + 5 + 6 + 7 + 8,
+        i64
+    );
+}

crates/compiler/test_gen/src/gen_records.rs

@@ -87,6 +87,26 @@ fn f64_record() {
     );
 }
 
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
+fn pass_bool_record() {
+    // found a bug there the register to use was not incremented correctly
+    assert_evals_to!(
+        indoc!(
+            r#"
+               true : Bool
+               true = Bool.true
+
+               f = \_, x -> x
+
+               f { x: true, y: true } 23
+               "#
+        ),
+        23,
+        i64
+    );
+}
+
 #[test]
 #[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
 fn fn_record() {

crates/compiler/test_gen/src/gen_refcount.rs

@@ -13,7 +13,7 @@ use roc_std::{RocList, RocStr};
 type Pointer = usize;
 
 #[test]
-#[cfg(any(feature = "gen-wasm"))]
+#[cfg(feature = "gen-wasm")]
 fn str_inc() {
     assert_refcounts!(
         indoc!(
@@ -32,7 +32,7 @@ fn str_inc() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-wasm"))]
+#[cfg(feature = "gen-wasm")]
 fn str_dealloc() {
     assert_refcounts!(
         indoc!(
@@ -48,7 +48,7 @@ fn str_dealloc() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-wasm"))]
+#[cfg(feature = "gen-wasm")]
 fn list_int_inc() {
     assert_refcounts!(
         indoc!(
@@ -66,7 +66,7 @@ fn list_int_inc() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-wasm"))]
+#[cfg(feature = "gen-wasm")]
 fn list_int_dealloc() {
     assert_refcounts!(
         indoc!(
@@ -84,7 +84,7 @@ fn list_int_dealloc() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-wasm"))]
+#[cfg(feature = "gen-wasm")]
 fn list_str_inc() {
     assert_refcounts!(
         indoc!(
@@ -104,7 +104,7 @@ fn list_str_inc() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-wasm"))]
+#[cfg(feature = "gen-wasm")]
 fn list_str_dealloc() {
     assert_refcounts!(
         indoc!(
@@ -124,7 +124,7 @@ fn list_str_dealloc() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-wasm"))]
+#[cfg(feature = "gen-wasm")]
 fn struct_inc() {
     assert_refcounts!(
         indoc!(
@@ -141,7 +141,7 @@ fn struct_inc() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-wasm"))]
+#[cfg(feature = "gen-wasm")]
 fn struct_dealloc() {
     assert_refcounts!(
         indoc!(
@@ -159,7 +159,7 @@ fn struct_dealloc() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-wasm"))]
+#[cfg(feature = "gen-wasm")]
 fn union_nonrecursive_inc() {
     type TwoStr = (RocStr, RocStr, i64);
 
@@ -185,7 +185,7 @@ fn union_nonrecursive_inc() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-wasm"))]
+#[cfg(feature = "gen-wasm")]
 fn union_nonrecursive_dec() {
     assert_refcounts!(
         indoc!(
@@ -208,7 +208,7 @@ fn union_nonrecursive_dec() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-wasm"))]
+#[cfg(feature = "gen-wasm")]
 fn union_recursive_inc() {
     assert_refcounts!(
         indoc!(
@@ -236,7 +236,7 @@ fn union_recursive_inc() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-wasm"))]
+#[cfg(feature = "gen-wasm")]
 fn union_recursive_dec() {
     assert_refcounts!(
         indoc!(
@@ -266,7 +266,7 @@ fn union_recursive_dec() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-wasm"))]
+#[cfg(feature = "gen-wasm")]
 fn refcount_different_rosetrees_inc() {
     // Requires two different Inc procedures for `List (Rose I64)` and `List (Rose Str)`
     // even though both appear in the mono Layout as `List(RecursivePointer)`
@@ -306,7 +306,7 @@ fn refcount_different_rosetrees_inc() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-wasm"))]
+#[cfg(feature = "gen-wasm")]
 fn refcount_different_rosetrees_dec() {
     // Requires two different Dec procedures for `List (Rose I64)` and `List (Rose Str)`
     // even though both appear in the mono Layout as `List(RecursivePointer)`
@@ -347,7 +347,7 @@ fn refcount_different_rosetrees_dec() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-wasm"))]
+#[cfg(feature = "gen-wasm")]
 fn union_linked_list_inc() {
     assert_refcounts!(
         indoc!(
@@ -373,7 +373,7 @@ fn union_linked_list_inc() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-wasm"))]
+#[cfg(feature = "gen-wasm")]
 fn union_linked_list_dec() {
     assert_refcounts!(
         indoc!(
@@ -401,7 +401,7 @@ fn union_linked_list_dec() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-wasm"))]
+#[cfg(feature = "gen-wasm")]
 fn union_linked_list_nil_dec() {
     let no_refcounts: &[crate::helpers::RefCount] = &[];
     assert_refcounts!(
@@ -423,7 +423,7 @@ fn union_linked_list_nil_dec() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-wasm"))]
+#[cfg(feature = "gen-wasm")]
 fn union_linked_list_long_dec() {
     assert_refcounts!(
         indoc!(
@@ -455,7 +455,7 @@ fn union_linked_list_long_dec() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-wasm"))]
+#[cfg(feature = "gen-wasm")]
 fn boxed_str_inc() {
     assert_refcounts!(
         indoc!(
@@ -475,7 +475,7 @@ fn boxed_str_inc() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-wasm"))]
+#[cfg(feature = "gen-wasm")]
 fn boxed_str_dec() {
     assert_refcounts!(
         indoc!(
@@ -498,7 +498,7 @@ fn boxed_str_dec() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-wasm"))]
+#[cfg(feature = "gen-wasm")]
 fn non_nullable_unwrapped_alignment_8() {
     assert_refcounts!(
         indoc!(
@@ -528,7 +528,7 @@ fn non_nullable_unwrapped_alignment_8() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-wasm"))]
+#[cfg(feature = "gen-wasm")]
 fn reset_reuse_alignment_8() {
     assert_refcounts!(
         indoc!(

crates/compiler/test_gen/src/gen_result.rs

@@ -13,7 +13,7 @@ use indoc::indoc;
 use roc_std::{RocResult, RocStr};
 
 #[test]
-#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
 fn with_default_ok() {
     assert_evals_to!(
         indoc!(
@@ -30,7 +30,7 @@ fn with_default_ok() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
 fn with_default_err() {
     assert_evals_to!(
         indoc!(
@@ -47,7 +47,7 @@ fn with_default_err() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
 fn result_map() {
     assert_evals_to!(
         indoc!(
@@ -81,7 +81,7 @@ fn result_map() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
 fn result_map_err() {
     assert_evals_to!(
         indoc!(
@@ -115,7 +115,7 @@ fn result_map_err() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
 fn err_type_var() {
     assert_evals_to!(
         indoc!(
@@ -130,7 +130,7 @@ fn err_type_var() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
 fn err_type_var_annotation() {
     assert_evals_to!(
         indoc!(
@@ -148,7 +148,7 @@ fn err_type_var_annotation() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
 fn err_empty_tag_union() {
     assert_evals_to!(
         indoc!(
@@ -166,7 +166,7 @@ fn err_empty_tag_union() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
 fn is_ok() {
     assert_evals_to!(
         indoc!(
@@ -196,7 +196,7 @@ fn is_ok() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
 fn is_err() {
     assert_evals_to!(
         indoc!(
@@ -243,7 +243,7 @@ fn roc_result_ok_i64() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
 fn roc_result_ok_f64() {
     // NOTE: the dev backend does not currently use float registers when returning a more
     // complex type, but the rust side does expect it to. Hence this test fails with gen-dev
@@ -280,7 +280,7 @@ fn roc_result_err() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
 fn issue_2583_specialize_errors_behind_unified_branches() {
     assert_evals_to!(
         r#"
@@ -292,7 +292,7 @@ fn issue_2583_specialize_errors_behind_unified_branches() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
 fn roc_result_after_on_ok() {
     assert_evals_to!(indoc!(
         r#"
@@ -308,7 +308,7 @@ fn roc_result_after_on_ok() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
 fn roc_result_after_on_err() {
     assert_evals_to!(indoc!(
         r#"
@@ -324,7 +324,7 @@ fn roc_result_after_on_err() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
 fn roc_result_after_err() {
     assert_evals_to!(
         indoc!(

crates/compiler/test_gen/src/gen_set.rs

@@ -1,5 +1,5 @@
 #![cfg(all(
-    any(feature = "gen-llvm"),
+    feature = "gen-llvm",
     not(debug_assertions) // https://github.com/roc-lang/roc/issues/3898
 ))]
 
@@ -16,7 +16,7 @@ use indoc::indoc;
 use roc_std::RocList;
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn empty_len() {
     assert_evals_to!(
         indoc!(
@@ -30,7 +30,7 @@ fn empty_len() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn single_len() {
     assert_evals_to!(
         indoc!(
@@ -44,7 +44,7 @@ fn single_len() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn single_to_list() {
     assert_evals_to!(
         indoc!(
@@ -68,7 +68,7 @@ fn single_to_list() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn insert() {
     assert_evals_to!(
         indoc!(
@@ -86,7 +86,7 @@ fn insert() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn remove() {
     assert_evals_to!(
         indoc!(
@@ -105,7 +105,7 @@ fn remove() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn union() {
     assert_evals_to!(
         indoc!(
@@ -126,7 +126,7 @@ fn union() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn difference() {
     assert_evals_to!(
         indoc!(
@@ -147,7 +147,7 @@ fn difference() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn intersection() {
     assert_evals_to!(
         indoc!(
@@ -168,7 +168,7 @@ fn intersection() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn walk_sum() {
     assert_evals_to!(
         indoc!(
@@ -182,7 +182,7 @@ fn walk_sum() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn contains() {
     assert_evals_to!(
         indoc!(
@@ -206,7 +206,7 @@ fn contains() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn from_list() {
     assert_evals_to!(
         indoc!(
@@ -238,7 +238,7 @@ fn from_list() {
 
 #[test]
 #[ignore]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn from_list_void() {
     assert_evals_to!(
         indoc!(
@@ -254,7 +254,7 @@ fn from_list_void() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn to_list_empty() {
     assert_evals_to!(
         indoc!(
@@ -268,7 +268,7 @@ fn to_list_empty() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn from_list_result() {
     assert_evals_to!(
         indoc!(
@@ -289,7 +289,7 @@ fn from_list_result() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn resolve_set_eq_issue_4671() {
     assert_evals_to!(
         indoc!(

crates/compiler/test_gen/src/gen_str.rs

@@ -868,7 +868,7 @@ fn str_clone() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn nested_recursive_literal() {
     assert_evals_to!(
         indoc!(
@@ -1160,7 +1160,7 @@ fn str_trim_large_to_small_unique() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn str_trim_large_to_large_shared() {
     assert_evals_to!(
         indoc!(
@@ -1180,7 +1180,7 @@ fn str_trim_large_to_large_shared() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn str_trim_large_to_small_shared() {
     assert_evals_to!(
         indoc!(
@@ -1200,7 +1200,7 @@ fn str_trim_large_to_small_shared() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn str_trim_small_to_small_shared() {
     assert_evals_to!(
         indoc!(
@@ -1253,7 +1253,7 @@ fn str_trim_start_large_to_small_unique() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn str_trim_start_large_to_large_shared() {
     assert_evals_to!(
         indoc!(
@@ -1273,7 +1273,7 @@ fn str_trim_start_large_to_large_shared() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn str_trim_start_large_to_small_shared() {
     assert_evals_to!(
         indoc!(
@@ -1293,7 +1293,7 @@ fn str_trim_start_large_to_small_shared() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn str_trim_start_small_to_small_shared() {
     assert_evals_to!(
         indoc!(
@@ -1346,7 +1346,7 @@ fn str_trim_end_large_to_small_unique() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn str_trim_end_large_to_large_shared() {
     assert_evals_to!(
         indoc!(
@@ -1366,7 +1366,7 @@ fn str_trim_end_large_to_large_shared() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn str_trim_end_large_to_small_shared() {
     assert_evals_to!(
         indoc!(
@@ -1386,7 +1386,7 @@ fn str_trim_end_large_to_small_shared() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn str_trim_end_small_to_small_shared() {
     assert_evals_to!(
         indoc!(
@@ -1417,7 +1417,7 @@ fn str_to_nat() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn str_to_i128() {
     assert_evals_to!(
         indoc!(
@@ -1431,7 +1431,7 @@ fn str_to_i128() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn str_to_u128() {
     assert_evals_to!(
         indoc!(
@@ -1473,7 +1473,7 @@ fn str_to_u64() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn str_to_i32() {
     assert_evals_to!(
         indoc!(
@@ -1487,7 +1487,7 @@ fn str_to_i32() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn str_to_u32() {
     assert_evals_to!(
         indoc!(
@@ -1501,7 +1501,7 @@ fn str_to_u32() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn str_to_i16() {
     assert_evals_to!(
         indoc!(
@@ -1515,7 +1515,7 @@ fn str_to_i16() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn str_to_u16() {
     assert_evals_to!(
         indoc!(
@@ -1529,7 +1529,7 @@ fn str_to_u16() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn str_to_i8() {
     assert_evals_to!(
         indoc!(
@@ -1543,7 +1543,7 @@ fn str_to_i8() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn str_to_u8() {
     assert_evals_to!(
         indoc!(
@@ -1557,7 +1557,7 @@ fn str_to_u8() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn str_to_f64() {
     assert_evals_to!(
         indoc!(
@@ -1574,7 +1574,7 @@ fn str_to_f64() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn str_to_f32() {
     assert_evals_to!(
         indoc!(
@@ -1591,7 +1591,7 @@ fn str_to_f32() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn str_to_dec() {
     use roc_std::RocDec;
 
@@ -1910,7 +1910,7 @@ fn str_walk_utf8_with_index() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn str_append_scalar() {
     assert_evals_to!(
         indoc!(
@@ -1938,7 +1938,7 @@ fn str_walk_scalars() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm-wasm"))]
+#[cfg(feature = "gen-llvm-wasm")]
 fn llvm_wasm_str_layout() {
     assert_evals_to!(
         indoc!(
@@ -1954,7 +1954,7 @@ fn llvm_wasm_str_layout() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm-wasm"))]
+#[cfg(feature = "gen-llvm-wasm")]
 fn llvm_wasm_str_layout_small() {
     // exposed an error in using bitcast instead of zextend
     assert_evals_to!(
@@ -2144,3 +2144,63 @@ fn release_excess_capacity_empty() {
         |value: RocStr| (value.capacity(), value)
     );
 }
+
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
+fn str_contains_positive() {
+    assert_evals_to!(
+        r#"
+        Str.contains "foobarbaz" "bar"
+        "#,
+        true,
+        bool
+    );
+}
+
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
+fn str_contains_negative() {
+    assert_evals_to!(
+        r#"
+        Str.contains "apple" "orange"
+        "#,
+        false,
+        bool
+    );
+}
+
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
+fn str_contains_empty_positive() {
+    assert_evals_to!(
+        r#"
+        Str.contains "anything" ""
+        "#,
+        true,
+        bool
+    );
+}
+
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
+fn str_contains_empty_negative() {
+    assert_evals_to!(
+        r#"
+        Str.contains "" "anything"
+        "#,
+        false,
+        bool
+    );
+}
+
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
+fn str_contains_self() {
+    assert_evals_to!(
+        r#"
+        Str.contains "self" "self"
+        "#,
+        true,
+        bool
+    );
+}

crates/compiler/test_gen/src/gen_tags.rs

@@ -1381,7 +1381,7 @@ fn issue_2445() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn issue_2458() {
     assert_evals_to!(
         indoc!(

crates/compiler/test_gen/src/gen_tuples.rs

@@ -319,7 +319,7 @@ fn bool_tuple4_literal() {
 // Not supported by wasm because of the size of the tuple:
 // FromWasm32Memory is only implemented for tuples of up to 4 elements
 #[test]
-#[cfg(any(feature = "gen-llvm"))]
+#[cfg(feature = "gen-llvm")]
 fn i64_tuple9_literal() {
     assert_evals_to!(
         indoc!(

crates/compiler/test_gen/src/helpers/dev.rs

@@ -316,12 +316,6 @@ fn get_test_main_fn<T>(
     get_raw_fn("test_main", lib)
 }
 
-pub(crate) fn run_function<T>(fn_name: &str, lib: &libloading::Library) -> T {
-    let main = get_raw_fn::<T>(fn_name, lib);
-
-    unsafe { main() }
-}
-
 pub(crate) fn run_test_main<T>(lib: &libloading::Library) -> Result<T, (String, CrashTag)> {
     let main = get_test_main_fn::<T>(lib);
 
@@ -336,10 +330,58 @@ impl<T: Sized> From<RocCallResult<T>> for Result<T, (String, CrashTag)> {
     }
 }
 
+// only used in tests
+pub(crate) fn asm_evals_to<T, U, F>(
+    src: &str,
+    expected: U,
+    transform: F,
+    leak: bool,
+    lazy_literals: bool,
+) where
+    U: PartialEq + std::fmt::Debug,
+    F: FnOnce(T) -> U,
+{
+    use bumpalo::Bump;
+
+    let arena = Bump::new();
+    let (_main_fn_name, errors, lib) =
+        crate::helpers::dev::helper(&arena, src, leak, lazy_literals);
+
+    let result = crate::helpers::dev::run_test_main::<T>(&lib);
+
+    if !errors.is_empty() {
+        dbg!(&errors);
+
+        assert_eq!(
+            errors,
+            std::vec::Vec::new(),
+            "Encountered errors: {:?}",
+            errors
+        );
+    }
+
+    match result {
+        Ok(value) => {
+            let expected = expected;
+            #[allow(clippy::redundant_closure_call)]
+            let given = transform(value);
+            assert_eq!(&given, &expected, "output is different");
+        }
+        Err((msg, tag)) => match tag {
+            CrashTag::Roc => panic!(r#"Roc failed with message: "{msg}""#),
+            CrashTag::User => panic!(r#"User crash with message: "{msg}""#),
+        },
+    }
+}
+
+pub(crate) fn identity<T>(x: T) -> T {
+    x
+}
+
 #[allow(unused_macros)]
 macro_rules! assert_evals_to {
     ($src:expr, $expected:expr, $ty:ty) => {{
-        assert_evals_to!($src, $expected, $ty, (|val| val));
+        assert_evals_to!($src, $expected, $ty, $crate::helpers::dev::identity);
     }};
     ($src:expr, $expected:expr, $ty:ty, $transform:expr) => {
         // Same as above, except with an additional transformation argument.
@@ -357,50 +399,13 @@ macro_rules! assert_evals_to {
         }
     };
     ($src:expr, $expected:expr, $ty:ty, $transform:expr, $leak:expr, $lazy_literals:expr) => {
-        use bumpalo::Bump;
+        $crate::helpers::dev::asm_evals_to::<$ty, _, _>(
-
+            $src,
-        let arena = Bump::new();
+            $expected,
-        let (_main_fn_name, errors, lib) =
+            $transform,
-            $crate::helpers::dev::helper(&arena, $src, $leak, $lazy_literals);
+            $leak,
-
+            $lazy_literals,
-        // NOTE: on aarch64 our infrastructure for roc_panic does not work yet. Therefore we call
+        );
-        // just the main roc function which does not do anything to catch/report panics.
-        let result = if cfg!(target_arch = "aarch64") {
-            let typ = std::any::type_name::<$ty>();
-            println!("calling the `{_main_fn_name}: {typ}` function");
-            let result = $crate::helpers::dev::run_function::<$ty>(&_main_fn_name, &lib);
-            Ok(result)
-        } else {
-            $crate::helpers::dev::run_test_main::<$ty>(&lib)
-        };
-
-        if !errors.is_empty() {
-            dbg!(&errors);
-
-            assert_eq!(
-                errors,
-                std::vec::Vec::new(),
-                "Encountered errors: {:?}",
-                errors
-            );
-        }
-
-        match result {
-            Ok(value) => {
-                let expected = $expected;
-                #[allow(clippy::redundant_closure_call)]
-                let given = $transform(value);
-                assert_eq!(&given, &expected, "output is different");
-            }
-            Err((msg, tag)) => {
-                use roc_mono::ir::CrashTag;
-
-                match tag {
-                    CrashTag::Roc => panic!(r#"Roc failed with message: "{msg}""#),
-                    CrashTag::User => panic!(r#"User crash with message: "{msg}""#),
-                }
-            }
-        }
     };
 }
 

crates/compiler/test_gen/src/wasm_str.rs

@@ -265,7 +265,7 @@ fn str_concat_big_to_big() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-wasm"))]
+#[cfg(feature = "gen-wasm")]
 fn small_str_literal() {
     assert_evals_to!(
         "\"01234567890\"",
@@ -275,7 +275,7 @@ fn small_str_literal() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-wasm"))]
+#[cfg(feature = "gen-wasm")]
 fn small_str_zeroed_literal() {
     // Verifies that we zero out unused bytes in the string.
     // This is important so that string equality tests don't randomly

crates/compiler/test_mono/generated/anonymous_closure_in_polymorphic_expression_issue_4717.txt

@@ -2,88 +2,88 @@ procedure Bool.11 (#Attr.2, #Attr.3):
     let Bool.24 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
     ret Bool.24;
 
-procedure List.26 (List.172, List.173, List.174):
+procedure List.26 (List.174, List.175, List.176):
-    let List.550 : [C U64, C U64] = CallByName List.96 List.172 List.173 List.174;
+    let List.560 : [C U64, C U64] = CallByName List.98 List.174 List.175 List.176;
-    let List.553 : U8 = 1i64;
+    let List.563 : U8 = 1i64;
-    let List.554 : U8 = GetTagId List.550;
+    let List.564 : U8 = GetTagId List.560;
-    let List.555 : Int1 = lowlevel Eq List.553 List.554;
+    let List.565 : Int1 = lowlevel Eq List.563 List.564;
-    if List.555 then
+    if List.565 then
-        let List.175 : U64 = UnionAtIndex (Id 1) (Index 0) List.550;
+        let List.177 : U64 = UnionAtIndex (Id 1) (Index 0) List.560;
-        ret List.175;
+        ret List.177;
     else
-        let List.176 : U64 = UnionAtIndex (Id 0) (Index 0) List.550;
+        let List.178 : U64 = UnionAtIndex (Id 0) (Index 0) List.560;
-        ret List.176;
+        ret List.178;
 
-procedure List.29 (List.317, List.318):
+procedure List.29 (List.319, List.320):
-    let List.549 : U64 = CallByName List.6 List.317;
+    let List.559 : U64 = CallByName List.6 List.319;
-    let List.319 : U64 = CallByName Num.77 List.549 List.318;
+    let List.321 : U64 = CallByName Num.77 List.559 List.320;
-    let List.535 : List U8 = CallByName List.43 List.317 List.319;
+    let List.545 : List U8 = CallByName List.43 List.319 List.321;
-    ret List.535;
+    ret List.545;
 
-procedure List.43 (List.315, List.316):
+procedure List.43 (List.317, List.318):
-    let List.547 : U64 = CallByName List.6 List.315;
+    let List.557 : U64 = CallByName List.6 List.317;
-    let List.546 : U64 = CallByName Num.77 List.547 List.316;
+    let List.556 : U64 = CallByName Num.77 List.557 List.318;
-    let List.537 : {U64, U64} = Struct {List.316, List.546};
+    let List.547 : {U64, U64} = Struct {List.318, List.556};
-    let List.536 : List U8 = CallByName List.49 List.315 List.537;
+    let List.546 : List U8 = CallByName List.49 List.317 List.547;
-    ret List.536;
+    ret List.546;
 
-procedure List.49 (List.390, List.391):
+procedure List.49 (List.392, List.393):
-    let List.544 : U64 = StructAtIndex 0 List.391;
+    let List.554 : U64 = StructAtIndex 0 List.393;
-    let List.545 : U64 = 0i64;
+    let List.555 : U64 = 0i64;
-    let List.542 : Int1 = CallByName Bool.11 List.544 List.545;
+    let List.552 : Int1 = CallByName Bool.11 List.554 List.555;
-    if List.542 then
+    if List.552 then
-        dec List.390;
+        dec List.392;
-        let List.543 : List U8 = Array [];
+        let List.553 : List U8 = Array [];
-        ret List.543;
+        ret List.553;
     else
-        let List.539 : U64 = StructAtIndex 1 List.391;
+        let List.549 : U64 = StructAtIndex 1 List.393;
-        let List.540 : U64 = StructAtIndex 0 List.391;
+        let List.550 : U64 = StructAtIndex 0 List.393;
-        let List.538 : List U8 = CallByName List.72 List.390 List.539 List.540;
+        let List.548 : List U8 = CallByName List.72 List.392 List.549 List.550;
-        ret List.538;
+        ret List.548;
 
 procedure List.6 (#Attr.2):
-    let List.548 : U64 = lowlevel ListLen #Attr.2;
+    let List.558 : U64 = lowlevel ListLen #Attr.2;
-    ret List.548;
+    ret List.558;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.571 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.581 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.571;
+    ret List.581;
 
 procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
-    let List.541 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
+    let List.551 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
-    ret List.541;
+    ret List.551;
 
 procedure List.80 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
-    joinpoint List.559 List.453 List.454 List.455 List.456 List.457:
+    joinpoint List.569 List.463 List.464 List.465 List.466 List.467:
-        let List.561 : Int1 = CallByName Num.22 List.456 List.457;
+        let List.571 : Int1 = CallByName Num.22 List.466 List.467;
-        if List.561 then
+        if List.571 then
-            let List.570 : U8 = CallByName List.66 List.453 List.456;
+            let List.580 : U8 = CallByName List.66 List.463 List.466;
-            let List.562 : [C U64, C U64] = CallByName Test.4 List.454 List.570;
+            let List.572 : [C U64, C U64] = CallByName Test.4 List.464 List.580;
-            let List.567 : U8 = 1i64;
+            let List.577 : U8 = 1i64;
-            let List.568 : U8 = GetTagId List.562;
+            let List.578 : U8 = GetTagId List.572;
-            let List.569 : Int1 = lowlevel Eq List.567 List.568;
+            let List.579 : Int1 = lowlevel Eq List.577 List.578;
-            if List.569 then
+            if List.579 then
-                let List.458 : U64 = UnionAtIndex (Id 1) (Index 0) List.562;
+                let List.468 : U64 = UnionAtIndex (Id 1) (Index 0) List.572;
-                let List.565 : U64 = 1i64;
+                let List.575 : U64 = 1i64;
-                let List.564 : U64 = CallByName Num.51 List.456 List.565;
+                let List.574 : U64 = CallByName Num.51 List.466 List.575;
-                jump List.559 List.453 List.458 List.455 List.564 List.457;
+                jump List.569 List.463 List.468 List.465 List.574 List.467;
             else
-                dec List.453;
+                dec List.463;
-                let List.459 : U64 = UnionAtIndex (Id 0) (Index 0) List.562;
+                let List.469 : U64 = UnionAtIndex (Id 0) (Index 0) List.572;
-                let List.566 : [C U64, C U64] = TagId(0) List.459;
+                let List.576 : [C U64, C U64] = TagId(0) List.469;
-                ret List.566;
+                ret List.576;
         else
-            dec List.453;
+            dec List.463;
-            let List.560 : [C U64, C U64] = TagId(1) List.454;
+            let List.570 : [C U64, C U64] = TagId(1) List.464;
-            ret List.560;
+            ret List.570;
     in
-    jump List.559 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
+    jump List.569 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
 
-procedure List.96 (List.450, List.451, List.452):
+procedure List.98 (List.460, List.461, List.462):
-    let List.557 : U64 = 0i64;
+    let List.567 : U64 = 0i64;
-    let List.558 : U64 = CallByName List.6 List.450;
+    let List.568 : U64 = CallByName List.6 List.460;
-    let List.556 : [C U64, C U64] = CallByName List.80 List.450 List.451 List.452 List.557 List.558;
+    let List.566 : [C U64, C U64] = CallByName List.80 List.460 List.461 List.462 List.567 List.568;
-    ret List.556;
+    ret List.566;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.294 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/call_function_in_empty_list.txt

@@ -1,7 +1,7 @@
 procedure List.5 (#Attr.2, #Attr.3):
-    let List.535 : List {} = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.2 #Attr.3;
+    let List.545 : List {} = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.2 #Attr.3;
     decref #Attr.2;
-    ret List.535;
+    ret List.545;
 
 procedure Test.2 (Test.3):
     let Test.7 : {} = Struct {};

crates/compiler/test_mono/generated/call_function_in_empty_list_unbound.txt

@@ -1,7 +1,7 @@
 procedure List.5 (#Attr.2, #Attr.3):
-    let List.535 : List [] = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.2 #Attr.3;
+    let List.545 : List [] = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.2 #Attr.3;
     decref #Attr.2;
-    ret List.535;
+    ret List.545;
 
 procedure Test.2 (Test.3):
     let Test.7 : {} = Struct {};

crates/compiler/test_mono/generated/capture_void_layout_task.txt

@@ -1,31 +1,31 @@
-procedure List.18 (List.145, List.146, List.147):
+procedure List.18 (List.147, List.148, List.149):
-    let List.536 : U64 = 0i64;
+    let List.546 : U64 = 0i64;
-    let List.537 : U64 = CallByName List.6 List.145;
+    let List.547 : U64 = CallByName List.6 List.147;
-    let List.535 : [<r>C {}, C *self {{}, []}] = CallByName List.86 List.145 List.146 List.147 List.536 List.537;
+    let List.545 : [<r>C {}, C *self {{}, []}] = CallByName List.87 List.147 List.148 List.149 List.546 List.547;
-    ret List.535;
-
-procedure List.6 (#Attr.2):
-    let List.546 : U64 = lowlevel ListLen #Attr.2;
-    ret List.546;
-
-procedure List.66 (#Attr.2, #Attr.3):
-    let List.545 : [] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
     ret List.545;
 
-procedure List.86 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17):
+procedure List.6 (#Attr.2):
-    joinpoint List.538 List.148 List.149 List.150 List.151 List.152:
+    let List.556 : U64 = lowlevel ListLen #Attr.2;
-        let List.540 : Int1 = CallByName Num.22 List.151 List.152;
+    ret List.556;
-        if List.540 then
+
-            let List.544 : [] = CallByName List.66 List.148 List.151;
+procedure List.66 (#Attr.2, #Attr.3):
-            let List.153 : [<r>C {}, C *self {{}, []}] = CallByName Test.29 List.149 List.544 List.150;
+    let List.555 : [] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-            let List.543 : U64 = 1i64;
+    ret List.555;
-            let List.542 : U64 = CallByName Num.51 List.151 List.543;
+
-            jump List.538 List.148 List.153 List.150 List.542 List.152;
+procedure List.87 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17):
+    joinpoint List.548 List.150 List.151 List.152 List.153 List.154:
+        let List.550 : Int1 = CallByName Num.22 List.153 List.154;
+        if List.550 then
+            let List.554 : [] = CallByName List.66 List.150 List.153;
+            let List.155 : [<r>C {}, C *self {{}, []}] = CallByName Test.29 List.151 List.554 List.152;
+            let List.553 : U64 = 1i64;
+            let List.552 : U64 = CallByName Num.51 List.153 List.553;
+            jump List.548 List.150 List.155 List.152 List.552 List.154;
         else
-            dec List.148;
+            dec List.150;
-            ret List.149;
+            ret List.151;
     in
-    jump List.538 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17;
+    jump List.548 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.292 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/choose_correct_recursion_var_under_record.txt

@@ -2,49 +2,49 @@ procedure Bool.1 ():
     let Bool.24 : Int1 = false;
     ret Bool.24;
 
-procedure List.2 (List.100, List.101):
+procedure List.2 (List.102, List.103):
-    let List.549 : U64 = CallByName List.6 List.100;
+    let List.559 : U64 = CallByName List.6 List.102;
-    let List.545 : Int1 = CallByName Num.22 List.101 List.549;
+    let List.555 : Int1 = CallByName Num.22 List.103 List.559;
-    if List.545 then
+    if List.555 then
-        let List.547 : Str = CallByName List.66 List.100 List.101;
+        let List.557 : Str = CallByName List.66 List.102 List.103;
-        inc List.547;
+        inc List.557;
-        dec List.100;
+        dec List.102;
-        let List.546 : [C {}, C Str] = TagId(1) List.547;
+        let List.556 : [C {}, C Str] = TagId(1) List.557;
-        ret List.546;
+        ret List.556;
     else
-        dec List.100;
+        dec List.102;
-        let List.544 : {} = Struct {};
+        let List.554 : {} = Struct {};
-        let List.543 : [C {}, C Str] = TagId(0) List.544;
+        let List.553 : [C {}, C Str] = TagId(0) List.554;
-        ret List.543;
+        ret List.553;
 
 procedure List.5 (#Attr.2, #Attr.3):
-    let List.551 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.10 #Attr.3;
+    let List.561 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.10 #Attr.3;
     decref #Attr.2;
-    ret List.551;
+    ret List.561;
 
 procedure List.6 (#Attr.2):
-    let List.550 : U64 = lowlevel ListLen #Attr.2;
+    let List.560 : U64 = lowlevel ListLen #Attr.2;
-    ret List.550;
+    ret List.560;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.548 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.558 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.548;
+    ret List.558;
 
-procedure List.9 (List.306):
+procedure List.9 (List.308):
-    let List.542 : U64 = 0i64;
+    let List.552 : U64 = 0i64;
-    let List.535 : [C {}, C Str] = CallByName List.2 List.306 List.542;
+    let List.545 : [C {}, C Str] = CallByName List.2 List.308 List.552;
-    let List.539 : U8 = 1i64;
+    let List.549 : U8 = 1i64;
-    let List.540 : U8 = GetTagId List.535;
+    let List.550 : U8 = GetTagId List.545;
-    let List.541 : Int1 = lowlevel Eq List.539 List.540;
+    let List.551 : Int1 = lowlevel Eq List.549 List.550;
-    if List.541 then
+    if List.551 then
-        let List.307 : Str = UnionAtIndex (Id 1) (Index 0) List.535;
+        let List.309 : Str = UnionAtIndex (Id 1) (Index 0) List.545;
-        let List.536 : [C {}, C Str] = TagId(1) List.307;
+        let List.546 : [C {}, C Str] = TagId(1) List.309;
-        ret List.536;
+        ret List.546;
     else
-        dec List.535;
+        dec List.545;
-        let List.538 : {} = Struct {};
+        let List.548 : {} = Struct {};
-        let List.537 : [C {}, C Str] = TagId(0) List.538;
+        let List.547 : [C {}, C Str] = TagId(0) List.548;
-        ret List.537;
+        ret List.547;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.291 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/closure_in_list.txt

@@ -1,6 +1,6 @@
 procedure List.6 (#Attr.2):
-    let List.535 : U64 = lowlevel ListLen #Attr.2;
+    let List.545 : U64 = lowlevel ListLen #Attr.2;
-    ret List.535;
+    ret List.545;
 
 procedure Test.1 (Test.5):
     let Test.2 : I64 = 41i64;

crates/compiler/test_mono/generated/compose_recursive_lambda_set_productive_nullable_wrapped.txt

@@ -2,34 +2,34 @@ procedure Bool.2 ():
     let Bool.23 : Int1 = true;
     ret Bool.23;
 
-procedure List.18 (List.145, List.146, List.147):
+procedure List.18 (List.147, List.148, List.149):
-    let List.536 : U64 = 0i64;
+    let List.546 : U64 = 0i64;
-    let List.537 : U64 = CallByName List.6 List.145;
+    let List.547 : U64 = CallByName List.6 List.147;
-    let List.535 : [<rnw><null>, C *self Int1, C *self Int1] = CallByName List.86 List.145 List.146 List.147 List.536 List.537;
+    let List.545 : [<rnw><null>, C *self Int1, C *self Int1] = CallByName List.87 List.147 List.148 List.149 List.546 List.547;
-    ret List.535;
-
-procedure List.6 (#Attr.2):
-    let List.546 : U64 = lowlevel ListLen #Attr.2;
-    ret List.546;
-
-procedure List.66 (#Attr.2, #Attr.3):
-    let List.545 : Int1 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
     ret List.545;
 
-procedure List.86 (#Derived_gen.3, #Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7):
+procedure List.6 (#Attr.2):
-    joinpoint List.538 List.148 List.149 List.150 List.151 List.152:
+    let List.556 : U64 = lowlevel ListLen #Attr.2;
-        let List.540 : Int1 = CallByName Num.22 List.151 List.152;
+    ret List.556;
-        if List.540 then
+
-            let List.544 : Int1 = CallByName List.66 List.148 List.151;
+procedure List.66 (#Attr.2, #Attr.3):
-            let List.153 : [<rnw><null>, C *self Int1, C *self Int1] = CallByName Test.6 List.149 List.544 List.150;
+    let List.555 : Int1 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-            let List.543 : U64 = 1i64;
+    ret List.555;
-            let List.542 : U64 = CallByName Num.51 List.151 List.543;
+
-            jump List.538 List.148 List.153 List.150 List.542 List.152;
+procedure List.87 (#Derived_gen.5, #Derived_gen.6, #Derived_gen.7, #Derived_gen.8, #Derived_gen.9):
+    joinpoint List.548 List.150 List.151 List.152 List.153 List.154:
+        let List.550 : Int1 = CallByName Num.22 List.153 List.154;
+        if List.550 then
+            let List.554 : Int1 = CallByName List.66 List.150 List.153;
+            let List.155 : [<rnw><null>, C *self Int1, C *self Int1] = CallByName Test.6 List.151 List.554 List.152;
+            let List.553 : U64 = 1i64;
+            let List.552 : U64 = CallByName Num.51 List.153 List.553;
+            jump List.548 List.150 List.155 List.152 List.552 List.154;
         else
-            dec List.148;
+            dec List.150;
-            ret List.149;
+            ret List.151;
     in
-    jump List.538 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7;
+    jump List.548 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7 #Derived_gen.8 #Derived_gen.9;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.292 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
@@ -40,13 +40,13 @@ procedure Num.51 (#Attr.2, #Attr.3):
     ret Num.291;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.291 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    let Str.294 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.291;
+    ret Str.294;
 
 procedure Test.1 (Test.5):
     ret Test.5;
 
-procedure Test.11 (#Derived_gen.8, #Derived_gen.9):
+procedure Test.11 (#Derived_gen.3, #Derived_gen.4):
     joinpoint Test.27 Test.12 #Attr.12:
         let Test.34 : Int1 = UnionAtIndex (Id 2) (Index 1) #Attr.12;
         let Test.33 : [<rnw><null>, C *self Int1, C *self Int1] = UnionAtIndex (Id 2) (Index 0) #Attr.12;
@@ -86,7 +86,7 @@ procedure Test.11 (#Derived_gen.8, #Derived_gen.9):
             decref #Attr.12;
             jump #Derived_gen.12;
     in
-    jump Test.27 #Derived_gen.8 #Derived_gen.9;
+    jump Test.27 #Derived_gen.3 #Derived_gen.4;
 
 procedure Test.2 (Test.13):
     ret Test.13;

crates/compiler/test_mono/generated/dict.txt

@@ -24,59 +24,59 @@ procedure Dict.4 (Dict.560):
     dec #Derived_gen.6;
     ret Dict.101;
 
-procedure List.11 (List.124, List.125):
+procedure List.11 (List.126, List.127):
-    let List.536 : List I8 = CallByName List.68 List.125;
+    let List.546 : List I8 = CallByName List.68 List.127;
-    let List.535 : List I8 = CallByName List.84 List.124 List.125 List.536;
+    let List.545 : List I8 = CallByName List.85 List.126 List.127 List.546;
-    ret List.535;
+    ret List.545;
 
-procedure List.11 (List.124, List.125):
+procedure List.11 (List.126, List.127):
-    let List.548 : List U64 = CallByName List.68 List.125;
+    let List.558 : List U64 = CallByName List.68 List.127;
-    let List.547 : List U64 = CallByName List.84 List.124 List.125 List.548;
+    let List.557 : List U64 = CallByName List.85 List.126 List.127 List.558;
-    ret List.547;
+    ret List.557;
 
 procedure List.68 (#Attr.2):
-    let List.546 : List I8 = lowlevel ListWithCapacity #Attr.2;
+    let List.556 : List I8 = lowlevel ListWithCapacity #Attr.2;
-    ret List.546;
+    ret List.556;
 
 procedure List.68 (#Attr.2):
-    let List.558 : List U64 = lowlevel ListWithCapacity #Attr.2;
+    let List.568 : List U64 = lowlevel ListWithCapacity #Attr.2;
-    ret List.558;
+    ret List.568;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.543 : List I8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    let List.553 : List I8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.543;
+    ret List.553;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.555 : List U64 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    let List.565 : List U64 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.555;
+    ret List.565;
 
-procedure List.84 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2):
+procedure List.85 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2):
-    joinpoint List.537 List.126 List.127 List.128:
+    joinpoint List.559 List.128 List.129 List.130:
-        let List.545 : U64 = 0i64;
+        let List.567 : U64 = 0i64;
-        let List.539 : Int1 = CallByName Num.24 List.127 List.545;
+        let List.561 : Int1 = CallByName Num.24 List.129 List.567;
-        if List.539 then
+        if List.561 then
-            let List.544 : U64 = 1i64;
+            let List.566 : U64 = 1i64;
-            let List.541 : U64 = CallByName Num.75 List.127 List.544;
+            let List.563 : U64 = CallByName Num.75 List.129 List.566;
-            let List.542 : List I8 = CallByName List.71 List.128 List.126;
+            let List.564 : List U64 = CallByName List.71 List.130 List.128;
-            jump List.537 List.126 List.541 List.542;
+            jump List.559 List.128 List.563 List.564;
         else
-            ret List.128;
+            ret List.130;
     in
-    jump List.537 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2;
+    jump List.559 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2;
 
-procedure List.84 (#Derived_gen.3, #Derived_gen.4, #Derived_gen.5):
+procedure List.85 (#Derived_gen.3, #Derived_gen.4, #Derived_gen.5):
-    joinpoint List.549 List.126 List.127 List.128:
+    joinpoint List.547 List.128 List.129 List.130:
-        let List.557 : U64 = 0i64;
+        let List.555 : U64 = 0i64;
-        let List.551 : Int1 = CallByName Num.24 List.127 List.557;
+        let List.549 : Int1 = CallByName Num.24 List.129 List.555;
-        if List.551 then
+        if List.549 then
-            let List.556 : U64 = 1i64;
+            let List.554 : U64 = 1i64;
-            let List.553 : U64 = CallByName Num.75 List.127 List.556;
+            let List.551 : U64 = CallByName Num.75 List.129 List.554;
-            let List.554 : List U64 = CallByName List.71 List.128 List.126;
+            let List.552 : List I8 = CallByName List.71 List.130 List.128;
-            jump List.549 List.126 List.553 List.554;
+            jump List.547 List.128 List.551 List.552;
         else
-            ret List.128;
+            ret List.130;
     in
-    jump List.549 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5;
+    jump List.547 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5;
 
 procedure Num.24 (#Attr.2, #Attr.3):
     let Num.294 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/empty_list_of_function_type.txt

@@ -2,27 +2,27 @@ procedure Bool.1 ():
     let Bool.23 : Int1 = false;
     ret Bool.23;
 
-procedure List.2 (List.100, List.101):
+procedure List.2 (List.102, List.103):
-    let List.541 : U64 = CallByName List.6 List.100;
+    let List.551 : U64 = CallByName List.6 List.102;
-    let List.537 : Int1 = CallByName Num.22 List.101 List.541;
+    let List.547 : Int1 = CallByName Num.22 List.103 List.551;
-    if List.537 then
+    if List.547 then
-        let List.539 : {} = CallByName List.66 List.100 List.101;
+        let List.549 : {} = CallByName List.66 List.102 List.103;
-        dec List.100;
+        dec List.102;
-        let List.538 : [C {}, C {}] = TagId(1) List.539;
+        let List.548 : [C {}, C {}] = TagId(1) List.549;
-        ret List.538;
+        ret List.548;
     else
-        dec List.100;
+        dec List.102;
-        let List.536 : {} = Struct {};
+        let List.546 : {} = Struct {};
-        let List.535 : [C {}, C {}] = TagId(0) List.536;
+        let List.545 : [C {}, C {}] = TagId(0) List.546;
-        ret List.535;
+        ret List.545;
 
 procedure List.6 (#Attr.2):
-    let List.542 : U64 = lowlevel ListLen #Attr.2;
+    let List.552 : U64 = lowlevel ListLen #Attr.2;
-    ret List.542;
+    ret List.552;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.540 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.550 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.540;
+    ret List.550;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.291 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/encode.txt

@@ -1,16 +1,16 @@
-procedure List.4 (List.116, List.117):
+procedure List.4 (List.118, List.119):
-    let List.538 : U64 = 1i64;
+    let List.548 : U64 = 1i64;
-    let List.536 : List U8 = CallByName List.70 List.116 List.538;
+    let List.546 : List U8 = CallByName List.70 List.118 List.548;
-    let List.535 : List U8 = CallByName List.71 List.536 List.117;
+    let List.545 : List U8 = CallByName List.71 List.546 List.119;
-    ret List.535;
+    ret List.545;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.539 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    let List.549 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.539;
+    ret List.549;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.537 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    let List.547 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.537;
+    ret List.547;
 
 procedure Test.23 (Test.24, Test.35, Test.22):
     let Test.37 : List U8 = CallByName List.4 Test.24 Test.22;

crates/compiler/test_mono/generated/encode_derived_nested_record_string.txt

@@ -78,235 +78,235 @@ procedure Encode.26 (Encode.105, Encode.106):
     ret Encode.108;
 
 procedure List.13 (#Attr.2, #Attr.3):
-    let List.679 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3;
+    let List.689 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3;
-    ret List.679;
+    ret List.689;
 
-procedure List.18 (List.145, List.146, List.147):
+procedure List.18 (List.147, List.148, List.149):
-    let List.565 : U64 = 0i64;
+    let List.575 : U64 = 0i64;
-    let List.566 : U64 = CallByName List.6 List.145;
+    let List.576 : U64 = CallByName List.6 List.147;
-    let List.564 : {List U8, U64} = CallByName List.86 List.145 List.146 List.147 List.565 List.566;
+    let List.574 : {List U8, U64} = CallByName List.87 List.147 List.148 List.149 List.575 List.576;
-    ret List.564;
-
-procedure List.18 (List.145, List.146, List.147):
-    let List.625 : U64 = 0i64;
-    let List.626 : U64 = CallByName List.6 List.145;
-    let List.624 : {List U8, U64} = CallByName List.86 List.145 List.146 List.147 List.625 List.626;
-    ret List.624;
-
-procedure List.18 (List.145, List.146, List.147):
-    let List.637 : U64 = 0i64;
-    let List.638 : U64 = CallByName List.6 List.145;
-    let List.636 : List U8 = CallByName List.86 List.145 List.146 List.147 List.637 List.638;
-    ret List.636;
-
-procedure List.26 (List.172, List.173, List.174):
-    let List.696 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.96 List.172 List.173 List.174;
-    let List.699 : U8 = 1i64;
-    let List.700 : U8 = GetTagId List.696;
-    let List.701 : Int1 = lowlevel Eq List.699 List.700;
-    if List.701 then
-        let List.175 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.696;
-        ret List.175;
-    else
-        let List.176 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.696;
-        ret List.176;
-
-procedure List.31 (#Attr.2, #Attr.3):
-    let List.661 : List Str = lowlevel ListDropAt #Attr.2 #Attr.3;
-    ret List.661;
-
-procedure List.38 (List.311):
-    let List.669 : U64 = 0i64;
-    let List.668 : List Str = CallByName List.31 List.311 List.669;
-    ret List.668;
-
-procedure List.4 (List.116, List.117):
-    let List.620 : U64 = 1i64;
-    let List.619 : List Str = CallByName List.70 List.116 List.620;
-    let List.618 : List Str = CallByName List.71 List.619 List.117;
-    ret List.618;
-
-procedure List.4 (List.116, List.117):
-    let List.623 : U64 = 1i64;
-    let List.622 : List U8 = CallByName List.70 List.116 List.623;
-    let List.621 : List U8 = CallByName List.71 List.622 List.117;
-    ret List.621;
-
-procedure List.49 (List.390, List.391):
-    let List.688 : U64 = StructAtIndex 0 List.391;
-    let List.689 : U64 = 0i64;
-    let List.686 : Int1 = CallByName Bool.11 List.688 List.689;
-    if List.686 then
-        dec List.390;
-        let List.687 : List U8 = Array [];
-        ret List.687;
-    else
-        let List.683 : U64 = StructAtIndex 1 List.391;
-        let List.684 : U64 = StructAtIndex 0 List.391;
-        let List.682 : List U8 = CallByName List.72 List.390 List.683 List.684;
-        ret List.682;
-
-procedure List.52 (List.405, List.406):
-    let List.407 : U64 = CallByName List.6 List.405;
-    joinpoint List.694 List.408:
-        let List.692 : U64 = 0i64;
-        let List.691 : {U64, U64} = Struct {List.408, List.692};
-        inc List.405;
-        let List.409 : List U8 = CallByName List.49 List.405 List.691;
-        let List.690 : U64 = CallByName Num.75 List.407 List.408;
-        let List.681 : {U64, U64} = Struct {List.690, List.408};
-        let List.410 : List U8 = CallByName List.49 List.405 List.681;
-        let List.680 : {List U8, List U8} = Struct {List.409, List.410};
-        ret List.680;
-    in
-    let List.695 : Int1 = CallByName Num.24 List.407 List.406;
-    if List.695 then
-        jump List.694 List.406;
-    else
-        jump List.694 List.407;
-
-procedure List.6 (#Attr.2):
-    let List.594 : U64 = lowlevel ListLen #Attr.2;
-    ret List.594;
-
-procedure List.6 (#Attr.2):
-    let List.675 : U64 = lowlevel ListLen #Attr.2;
-    ret List.675;
-
-procedure List.6 (#Attr.2):
-    let List.676 : U64 = lowlevel ListLen #Attr.2;
-    ret List.676;
-
-procedure List.6 (#Attr.2):
-    let List.678 : U64 = lowlevel ListLen #Attr.2;
-    ret List.678;
-
-procedure List.66 (#Attr.2, #Attr.3):
-    let List.574 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
     ret List.574;
 
-procedure List.66 (#Attr.2, #Attr.3):
+procedure List.18 (List.147, List.148, List.149):
-    let List.634 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.635 : U64 = 0i64;
+    let List.636 : U64 = CallByName List.6 List.147;
+    let List.634 : {List U8, U64} = CallByName List.87 List.147 List.148 List.149 List.635 List.636;
     ret List.634;
 
-procedure List.66 (#Attr.2, #Attr.3):
+procedure List.18 (List.147, List.148, List.149):
-    let List.646 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.647 : U64 = 0i64;
+    let List.648 : U64 = CallByName List.6 List.147;
+    let List.646 : List U8 = CallByName List.87 List.147 List.148 List.149 List.647 List.648;
     ret List.646;
 
-procedure List.68 (#Attr.2):
+procedure List.26 (List.174, List.175, List.176):
-    let List.671 : List Str = lowlevel ListWithCapacity #Attr.2;
+    let List.706 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.98 List.174 List.175 List.176;
+    let List.709 : U8 = 1i64;
+    let List.710 : U8 = GetTagId List.706;
+    let List.711 : Int1 = lowlevel Eq List.709 List.710;
+    if List.711 then
+        let List.177 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.706;
+        ret List.177;
+    else
+        let List.178 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.706;
+        ret List.178;
+
+procedure List.31 (#Attr.2, #Attr.3):
+    let List.671 : List Str = lowlevel ListDropAt #Attr.2 #Attr.3;
     ret List.671;
 
-procedure List.68 (#Attr.2):
+procedure List.38 (List.313):
-    let List.673 : List U8 = lowlevel ListWithCapacity #Attr.2;
+    let List.679 : U64 = 0i64;
-    ret List.673;
+    let List.678 : List Str = CallByName List.31 List.313 List.679;
+    ret List.678;
 
-procedure List.70 (#Attr.2, #Attr.3):
+procedure List.4 (List.118, List.119):
-    let List.600 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    let List.630 : U64 = 1i64;
-    ret List.600;
+    let List.629 : List Str = CallByName List.70 List.118 List.630;
+    let List.628 : List Str = CallByName List.71 List.629 List.119;
+    ret List.628;
 
-procedure List.70 (#Attr.2, #Attr.3):
+procedure List.4 (List.118, List.119):
-    let List.617 : List Str = lowlevel ListReserve #Attr.2 #Attr.3;
+    let List.633 : U64 = 1i64;
-    ret List.617;
+    let List.632 : List U8 = CallByName List.70 List.118 List.633;
+    let List.631 : List U8 = CallByName List.71 List.632 List.119;
+    ret List.631;
 
-procedure List.71 (#Attr.2, #Attr.3):
+procedure List.49 (List.392, List.393):
-    let List.598 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    let List.698 : U64 = StructAtIndex 0 List.393;
-    ret List.598;
+    let List.699 : U64 = 0i64;
+    let List.696 : Int1 = CallByName Bool.11 List.698 List.699;
+    if List.696 then
+        dec List.392;
+        let List.697 : List U8 = Array [];
+        ret List.697;
+    else
+        let List.693 : U64 = StructAtIndex 1 List.393;
+        let List.694 : U64 = StructAtIndex 0 List.393;
+        let List.692 : List U8 = CallByName List.72 List.392 List.693 List.694;
+        ret List.692;
 
-procedure List.71 (#Attr.2, #Attr.3):
+procedure List.52 (List.407, List.408):
-    let List.615 : List Str = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    let List.409 : U64 = CallByName List.6 List.407;
-    ret List.615;
+    joinpoint List.704 List.410:
+        let List.702 : U64 = 0i64;
+        let List.701 : {U64, U64} = Struct {List.410, List.702};
+        inc List.407;
+        let List.411 : List U8 = CallByName List.49 List.407 List.701;
+        let List.700 : U64 = CallByName Num.75 List.409 List.410;
+        let List.691 : {U64, U64} = Struct {List.700, List.410};
+        let List.412 : List U8 = CallByName List.49 List.407 List.691;
+        let List.690 : {List U8, List U8} = Struct {List.411, List.412};
+        ret List.690;
+    in
+    let List.705 : Int1 = CallByName Num.24 List.409 List.408;
+    if List.705 then
+        jump List.704 List.408;
+    else
+        jump List.704 List.409;
 
-procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
+procedure List.6 (#Attr.2):
-    let List.685 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
+    let List.604 : U64 = lowlevel ListLen #Attr.2;
+    ret List.604;
+
+procedure List.6 (#Attr.2):
+    let List.685 : U64 = lowlevel ListLen #Attr.2;
     ret List.685;
 
-procedure List.8 (#Attr.2, #Attr.3):
+procedure List.6 (#Attr.2):
-    let List.650 : List Str = lowlevel ListConcat #Attr.2 #Attr.3;
+    let List.686 : U64 = lowlevel ListLen #Attr.2;
-    ret List.650;
+    ret List.686;
+
+procedure List.6 (#Attr.2):
+    let List.688 : U64 = lowlevel ListLen #Attr.2;
+    ret List.688;
+
+procedure List.66 (#Attr.2, #Attr.3):
+    let List.584 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.584;
+
+procedure List.66 (#Attr.2, #Attr.3):
+    let List.644 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.644;
+
+procedure List.66 (#Attr.2, #Attr.3):
+    let List.656 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.656;
+
+procedure List.68 (#Attr.2):
+    let List.681 : List Str = lowlevel ListWithCapacity #Attr.2;
+    ret List.681;
+
+procedure List.68 (#Attr.2):
+    let List.683 : List U8 = lowlevel ListWithCapacity #Attr.2;
+    ret List.683;
+
+procedure List.70 (#Attr.2, #Attr.3):
+    let List.610 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    ret List.610;
+
+procedure List.70 (#Attr.2, #Attr.3):
+    let List.627 : List Str = lowlevel ListReserve #Attr.2 #Attr.3;
+    ret List.627;
+
+procedure List.71 (#Attr.2, #Attr.3):
+    let List.608 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.608;
+
+procedure List.71 (#Attr.2, #Attr.3):
+    let List.625 : List Str = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.625;
+
+procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
+    let List.695 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
+    ret List.695;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.658 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    let List.660 : List Str = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.658;
+    ret List.660;
 
-procedure List.80 (#Derived_gen.30, #Derived_gen.31, #Derived_gen.32, #Derived_gen.33, #Derived_gen.34):
+procedure List.8 (#Attr.2, #Attr.3):
-    joinpoint List.705 List.453 List.454 List.455 List.456 List.457:
+    let List.668 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
-        let List.707 : Int1 = CallByName Num.22 List.456 List.457;
+    ret List.668;
-        if List.707 then
+
-            let List.716 : U8 = CallByName List.66 List.453 List.456;
+procedure List.80 (#Derived_gen.35, #Derived_gen.36, #Derived_gen.37, #Derived_gen.38, #Derived_gen.39):
-            let List.708 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.454 List.716;
+    joinpoint List.715 List.463 List.464 List.465 List.466 List.467:
-            let List.713 : U8 = 1i64;
+        let List.717 : Int1 = CallByName Num.22 List.466 List.467;
-            let List.714 : U8 = GetTagId List.708;
+        if List.717 then
-            let List.715 : Int1 = lowlevel Eq List.713 List.714;
+            let List.726 : U8 = CallByName List.66 List.463 List.466;
-            if List.715 then
+            let List.718 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.464 List.726;
-                let List.458 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.708;
+            let List.723 : U8 = 1i64;
-                let List.711 : U64 = 1i64;
+            let List.724 : U8 = GetTagId List.718;
-                let List.710 : U64 = CallByName Num.51 List.456 List.711;
+            let List.725 : Int1 = lowlevel Eq List.723 List.724;
-                jump List.705 List.453 List.458 List.455 List.710 List.457;
+            if List.725 then
+                let List.468 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.718;
+                let List.721 : U64 = 1i64;
+                let List.720 : U64 = CallByName Num.51 List.466 List.721;
+                jump List.715 List.463 List.468 List.465 List.720 List.467;
             else
-                dec List.453;
+                dec List.463;
-                let List.459 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.708;
+                let List.469 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.718;
-                let List.712 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.459;
+                let List.722 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.469;
-                ret List.712;
+                ret List.722;
         else
-            dec List.453;
+            dec List.463;
-            let List.706 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.454;
+            let List.716 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.464;
-            ret List.706;
+            ret List.716;
     in
-    jump List.705 #Derived_gen.30 #Derived_gen.31 #Derived_gen.32 #Derived_gen.33 #Derived_gen.34;
+    jump List.715 #Derived_gen.35 #Derived_gen.36 #Derived_gen.37 #Derived_gen.38 #Derived_gen.39;
 
-procedure List.86 (#Derived_gen.35, #Derived_gen.36, #Derived_gen.37, #Derived_gen.38, #Derived_gen.39):
+procedure List.87 (#Derived_gen.23, #Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_gen.27):
-    joinpoint List.567 List.148 List.149 List.150 List.151 List.152:
+    joinpoint List.649 List.150 List.151 List.152 List.153 List.154:
-        let List.569 : Int1 = CallByName Num.22 List.151 List.152;
+        let List.651 : Int1 = CallByName Num.22 List.153 List.154;
-        if List.569 then
+        if List.651 then
-            let List.573 : {Str, Str} = CallByName List.66 List.148 List.151;
+            let List.655 : U8 = CallByName List.66 List.150 List.153;
-            inc List.573;
+            let List.155 : List U8 = CallByName TotallyNotJson.215 List.151 List.655;
-            let List.153 : {List U8, U64} = CallByName TotallyNotJson.237 List.149 List.573 List.150;
+            let List.654 : U64 = 1i64;
-            let List.572 : U64 = 1i64;
+            let List.653 : U64 = CallByName Num.51 List.153 List.654;
-            let List.571 : U64 = CallByName Num.51 List.151 List.572;
+            jump List.649 List.150 List.155 List.152 List.653 List.154;
-            jump List.567 List.148 List.153 List.150 List.571 List.152;
         else
-            dec List.148;
+            dec List.150;
-            ret List.149;
+            ret List.151;
     in
-    jump List.567 #Derived_gen.35 #Derived_gen.36 #Derived_gen.37 #Derived_gen.38 #Derived_gen.39;
+    jump List.649 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27;
 
-procedure List.86 (#Derived_gen.46, #Derived_gen.47, #Derived_gen.48, #Derived_gen.49, #Derived_gen.50):
+procedure List.87 (#Derived_gen.40, #Derived_gen.41, #Derived_gen.42, #Derived_gen.43, #Derived_gen.44):
-    joinpoint List.639 List.148 List.149 List.150 List.151 List.152:
+    joinpoint List.577 List.150 List.151 List.152 List.153 List.154:
-        let List.641 : Int1 = CallByName Num.22 List.151 List.152;
+        let List.579 : Int1 = CallByName Num.22 List.153 List.154;
-        if List.641 then
+        if List.579 then
-            let List.645 : U8 = CallByName List.66 List.148 List.151;
+            let List.583 : {Str, Str} = CallByName List.66 List.150 List.153;
-            let List.153 : List U8 = CallByName TotallyNotJson.215 List.149 List.645;
+            inc List.583;
-            let List.644 : U64 = 1i64;
+            let List.155 : {List U8, U64} = CallByName TotallyNotJson.237 List.151 List.583 List.152;
-            let List.643 : U64 = CallByName Num.51 List.151 List.644;
+            let List.582 : U64 = 1i64;
-            jump List.639 List.148 List.153 List.150 List.643 List.152;
+            let List.581 : U64 = CallByName Num.51 List.153 List.582;
+            jump List.577 List.150 List.155 List.152 List.581 List.154;
         else
-            dec List.148;
+            dec List.150;
-            ret List.149;
+            ret List.151;
     in
-    jump List.639 #Derived_gen.46 #Derived_gen.47 #Derived_gen.48 #Derived_gen.49 #Derived_gen.50;
+    jump List.577 #Derived_gen.40 #Derived_gen.41 #Derived_gen.42 #Derived_gen.43 #Derived_gen.44;
 
-procedure List.86 (#Derived_gen.52, #Derived_gen.53, #Derived_gen.54, #Derived_gen.55, #Derived_gen.56):
+procedure List.87 (#Derived_gen.51, #Derived_gen.52, #Derived_gen.53, #Derived_gen.54, #Derived_gen.55):
-    joinpoint List.627 List.148 List.149 List.150 List.151 List.152:
+    joinpoint List.637 List.150 List.151 List.152 List.153 List.154:
-        let List.629 : Int1 = CallByName Num.22 List.151 List.152;
+        let List.639 : Int1 = CallByName Num.22 List.153 List.154;
-        if List.629 then
+        if List.639 then
-            let List.633 : {Str, Str} = CallByName List.66 List.148 List.151;
+            let List.643 : {Str, Str} = CallByName List.66 List.150 List.153;
-            inc List.633;
+            inc List.643;
-            let List.153 : {List U8, U64} = CallByName TotallyNotJson.237 List.149 List.633 List.150;
+            let List.155 : {List U8, U64} = CallByName TotallyNotJson.237 List.151 List.643 List.152;
-            let List.632 : U64 = 1i64;
+            let List.642 : U64 = 1i64;
-            let List.631 : U64 = CallByName Num.51 List.151 List.632;
+            let List.641 : U64 = CallByName Num.51 List.153 List.642;
-            jump List.627 List.148 List.153 List.150 List.631 List.152;
+            jump List.637 List.150 List.155 List.152 List.641 List.154;
         else
-            dec List.148;
+            dec List.150;
-            ret List.149;
+            ret List.151;
     in
-    jump List.627 #Derived_gen.52 #Derived_gen.53 #Derived_gen.54 #Derived_gen.55 #Derived_gen.56;
+    jump List.637 #Derived_gen.51 #Derived_gen.52 #Derived_gen.53 #Derived_gen.54 #Derived_gen.55;
 
-procedure List.96 (List.450, List.451, List.452):
+procedure List.98 (List.460, List.461, List.462):
-    let List.703 : U64 = 0i64;
+    let List.713 : U64 = 0i64;
-    let List.704 : U64 = CallByName List.6 List.450;
+    let List.714 : U64 = CallByName List.6 List.460;
-    let List.702 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.450 List.451 List.452 List.703 List.704;
+    let List.712 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.460 List.461 List.462 List.713 List.714;
-    ret List.702;
+    ret List.712;
 
 procedure Num.127 (#Attr.2):
     let Num.306 : U8 = lowlevel NumIntCast #Attr.2;
@@ -345,38 +345,38 @@ procedure Num.94 (#Attr.2, #Attr.3):
     ret Num.311;
 
 procedure Str.12 (#Attr.2):
-    let Str.307 : List U8 = lowlevel StrToUtf8 #Attr.2;
+    let Str.310 : List U8 = lowlevel StrToUtf8 #Attr.2;
-    ret Str.307;
-
-procedure Str.4 (#Attr.2, #Attr.3):
-    let Str.310 : Str = lowlevel StrJoinWith #Attr.2 #Attr.3;
     ret Str.310;
 
-procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
+procedure Str.4 (#Attr.2, #Attr.3):
-    let Str.298 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
+    let Str.313 : Str = lowlevel StrJoinWith #Attr.2 #Attr.3;
-    ret Str.298;
-
-procedure Str.55 (#Attr.2):
-    let Str.313 : List Str = lowlevel StrGraphemes #Attr.2;
     ret Str.313;
 
-procedure Str.9 (Str.79):
+procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
-    let Str.296 : U64 = 0i64;
+    let Str.301 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
-    let Str.297 : U64 = CallByName List.6 Str.79;
+    ret Str.301;
-    let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.296 Str.297;
+
-    let Str.293 : Int1 = StructAtIndex 2 Str.80;
+procedure Str.55 (#Attr.2):
-    if Str.293 then
+    let Str.316 : List Str = lowlevel StrGraphemes #Attr.2;
-        let Str.295 : Str = StructAtIndex 1 Str.80;
+    ret Str.316;
-        let Str.294 : [C {U64, U8}, C Str] = TagId(1) Str.295;
+
-        ret Str.294;
+procedure Str.9 (Str.80):
+    let Str.299 : U64 = 0i64;
+    let Str.300 : U64 = CallByName List.6 Str.80;
+    let Str.81 : {U64, Str, Int1, U8} = CallByName Str.48 Str.80 Str.299 Str.300;
+    let Str.296 : Int1 = StructAtIndex 2 Str.81;
+    if Str.296 then
+        let Str.298 : Str = StructAtIndex 1 Str.81;
+        let Str.297 : [C {U64, U8}, C Str] = TagId(1) Str.298;
+        ret Str.297;
     else
-        let Str.291 : U8 = StructAtIndex 3 Str.80;
+        let Str.294 : U8 = StructAtIndex 3 Str.81;
-        let Str.292 : U64 = StructAtIndex 0 Str.80;
+        let Str.295 : U64 = StructAtIndex 0 Str.81;
-        let #Derived_gen.58 : Str = StructAtIndex 1 Str.80;
+        let #Derived_gen.58 : Str = StructAtIndex 1 Str.81;
         dec #Derived_gen.58;
-        let Str.290 : {U64, U8} = Struct {Str.292, Str.291};
+        let Str.293 : {U64, U8} = Struct {Str.295, Str.294};
-        let Str.289 : [C {U64, U8}, C Str] = TagId(0) Str.290;
+        let Str.292 : [C {U64, U8}, C Str] = TagId(0) Str.293;
-        ret Str.289;
+        ret Str.292;
 
 procedure TotallyNotJson.100 (TotallyNotJson.850):
     let TotallyNotJson.1830 : Str = "a";
@@ -1377,7 +1377,7 @@ procedure TotallyNotJson.95 (TotallyNotJson.829):
     dec TotallyNotJson.1840;
     ret TotallyNotJson.1839;
 
-procedure TotallyNotJson.96 (#Derived_gen.51):
+procedure TotallyNotJson.96 (#Derived_gen.56):
     joinpoint TotallyNotJson.1847 TotallyNotJson.1168:
         let TotallyNotJson.834 : List Str = StructAtIndex 0 TotallyNotJson.1168;
         let TotallyNotJson.833 : List Str = StructAtIndex 1 TotallyNotJson.1168;
@@ -1413,7 +1413,7 @@ procedure TotallyNotJson.96 (#Derived_gen.51):
             let TotallyNotJson.1848 : {List Str, List Str} = Struct {TotallyNotJson.834, TotallyNotJson.833};
             ret TotallyNotJson.1848;
     in
-    jump TotallyNotJson.1847 #Derived_gen.51;
+    jump TotallyNotJson.1847 #Derived_gen.56;
 
 procedure TotallyNotJson.97 (TotallyNotJson.837):
     let TotallyNotJson.838 : List Str = CallByName Str.55 TotallyNotJson.837;
@@ -1430,7 +1430,7 @@ procedure TotallyNotJson.97 (TotallyNotJson.837):
     dec TotallyNotJson.1562;
     ret TotallyNotJson.1560;
 
-procedure TotallyNotJson.98 (#Derived_gen.29):
+procedure TotallyNotJson.98 (#Derived_gen.34):
     joinpoint TotallyNotJson.1568 TotallyNotJson.1169:
         let TotallyNotJson.842 : List Str = StructAtIndex 0 TotallyNotJson.1169;
         let TotallyNotJson.841 : List Str = StructAtIndex 1 TotallyNotJson.1169;
@@ -1466,7 +1466,7 @@ procedure TotallyNotJson.98 (#Derived_gen.29):
             let TotallyNotJson.1569 : {List Str, List Str} = Struct {TotallyNotJson.842, TotallyNotJson.841};
             ret TotallyNotJson.1569;
     in
-    jump TotallyNotJson.1568 #Derived_gen.29;
+    jump TotallyNotJson.1568 #Derived_gen.34;
 
 procedure Test.0 ():
     let Test.12 : Str = "bar";

crates/compiler/test_mono/generated/encode_derived_record_one_field_string.txt

@@ -51,205 +51,205 @@ procedure Encode.26 (Encode.105, Encode.106):
     ret Encode.108;
 
 procedure List.13 (#Attr.2, #Attr.3):
-    let List.619 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3;
+    let List.629 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3;
-    ret List.619;
+    ret List.629;
 
-procedure List.18 (List.145, List.146, List.147):
+procedure List.18 (List.147, List.148, List.149):
-    let List.565 : U64 = 0i64;
+    let List.575 : U64 = 0i64;
-    let List.566 : U64 = CallByName List.6 List.145;
+    let List.576 : U64 = CallByName List.6 List.147;
-    let List.564 : {List U8, U64} = CallByName List.86 List.145 List.146 List.147 List.565 List.566;
+    let List.574 : {List U8, U64} = CallByName List.87 List.147 List.148 List.149 List.575 List.576;
-    ret List.564;
-
-procedure List.18 (List.145, List.146, List.147):
-    let List.577 : U64 = 0i64;
-    let List.578 : U64 = CallByName List.6 List.145;
-    let List.576 : List U8 = CallByName List.86 List.145 List.146 List.147 List.577 List.578;
-    ret List.576;
-
-procedure List.26 (List.172, List.173, List.174):
-    let List.636 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.96 List.172 List.173 List.174;
-    let List.639 : U8 = 1i64;
-    let List.640 : U8 = GetTagId List.636;
-    let List.641 : Int1 = lowlevel Eq List.639 List.640;
-    if List.641 then
-        let List.175 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.636;
-        ret List.175;
-    else
-        let List.176 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.636;
-        ret List.176;
-
-procedure List.31 (#Attr.2, #Attr.3):
-    let List.601 : List Str = lowlevel ListDropAt #Attr.2 #Attr.3;
-    ret List.601;
-
-procedure List.38 (List.311):
-    let List.609 : U64 = 0i64;
-    let List.608 : List Str = CallByName List.31 List.311 List.609;
-    ret List.608;
-
-procedure List.4 (List.116, List.117):
-    let List.560 : U64 = 1i64;
-    let List.559 : List Str = CallByName List.70 List.116 List.560;
-    let List.558 : List Str = CallByName List.71 List.559 List.117;
-    ret List.558;
-
-procedure List.4 (List.116, List.117):
-    let List.563 : U64 = 1i64;
-    let List.562 : List U8 = CallByName List.70 List.116 List.563;
-    let List.561 : List U8 = CallByName List.71 List.562 List.117;
-    ret List.561;
-
-procedure List.49 (List.390, List.391):
-    let List.628 : U64 = StructAtIndex 0 List.391;
-    let List.629 : U64 = 0i64;
-    let List.626 : Int1 = CallByName Bool.11 List.628 List.629;
-    if List.626 then
-        dec List.390;
-        let List.627 : List U8 = Array [];
-        ret List.627;
-    else
-        let List.623 : U64 = StructAtIndex 1 List.391;
-        let List.624 : U64 = StructAtIndex 0 List.391;
-        let List.622 : List U8 = CallByName List.72 List.390 List.623 List.624;
-        ret List.622;
-
-procedure List.52 (List.405, List.406):
-    let List.407 : U64 = CallByName List.6 List.405;
-    joinpoint List.634 List.408:
-        let List.632 : U64 = 0i64;
-        let List.631 : {U64, U64} = Struct {List.408, List.632};
-        inc List.405;
-        let List.409 : List U8 = CallByName List.49 List.405 List.631;
-        let List.630 : U64 = CallByName Num.75 List.407 List.408;
-        let List.621 : {U64, U64} = Struct {List.630, List.408};
-        let List.410 : List U8 = CallByName List.49 List.405 List.621;
-        let List.620 : {List U8, List U8} = Struct {List.409, List.410};
-        ret List.620;
-    in
-    let List.635 : Int1 = CallByName Num.24 List.407 List.406;
-    if List.635 then
-        jump List.634 List.406;
-    else
-        jump List.634 List.407;
-
-procedure List.6 (#Attr.2):
-    let List.615 : U64 = lowlevel ListLen #Attr.2;
-    ret List.615;
-
-procedure List.6 (#Attr.2):
-    let List.616 : U64 = lowlevel ListLen #Attr.2;
-    ret List.616;
-
-procedure List.6 (#Attr.2):
-    let List.618 : U64 = lowlevel ListLen #Attr.2;
-    ret List.618;
-
-procedure List.66 (#Attr.2, #Attr.3):
-    let List.574 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
     ret List.574;
 
-procedure List.66 (#Attr.2, #Attr.3):
+procedure List.18 (List.147, List.148, List.149):
-    let List.586 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.587 : U64 = 0i64;
+    let List.588 : U64 = CallByName List.6 List.147;
+    let List.586 : List U8 = CallByName List.87 List.147 List.148 List.149 List.587 List.588;
     ret List.586;
 
-procedure List.68 (#Attr.2):
+procedure List.26 (List.174, List.175, List.176):
-    let List.611 : List Str = lowlevel ListWithCapacity #Attr.2;
+    let List.646 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.98 List.174 List.175 List.176;
+    let List.649 : U8 = 1i64;
+    let List.650 : U8 = GetTagId List.646;
+    let List.651 : Int1 = lowlevel Eq List.649 List.650;
+    if List.651 then
+        let List.177 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.646;
+        ret List.177;
+    else
+        let List.178 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.646;
+        ret List.178;
+
+procedure List.31 (#Attr.2, #Attr.3):
+    let List.611 : List Str = lowlevel ListDropAt #Attr.2 #Attr.3;
     ret List.611;
 
-procedure List.68 (#Attr.2):
+procedure List.38 (List.313):
-    let List.613 : List U8 = lowlevel ListWithCapacity #Attr.2;
+    let List.619 : U64 = 0i64;
-    ret List.613;
+    let List.618 : List Str = CallByName List.31 List.313 List.619;
+    ret List.618;
 
-procedure List.70 (#Attr.2, #Attr.3):
+procedure List.4 (List.118, List.119):
-    let List.540 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    let List.570 : U64 = 1i64;
-    ret List.540;
+    let List.569 : List Str = CallByName List.70 List.118 List.570;
+    let List.568 : List Str = CallByName List.71 List.569 List.119;
+    ret List.568;
 
-procedure List.70 (#Attr.2, #Attr.3):
+procedure List.4 (List.118, List.119):
-    let List.557 : List Str = lowlevel ListReserve #Attr.2 #Attr.3;
+    let List.573 : U64 = 1i64;
-    ret List.557;
+    let List.572 : List U8 = CallByName List.70 List.118 List.573;
+    let List.571 : List U8 = CallByName List.71 List.572 List.119;
+    ret List.571;
 
-procedure List.71 (#Attr.2, #Attr.3):
+procedure List.49 (List.392, List.393):
-    let List.538 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    let List.638 : U64 = StructAtIndex 0 List.393;
-    ret List.538;
+    let List.639 : U64 = 0i64;
+    let List.636 : Int1 = CallByName Bool.11 List.638 List.639;
+    if List.636 then
+        dec List.392;
+        let List.637 : List U8 = Array [];
+        ret List.637;
+    else
+        let List.633 : U64 = StructAtIndex 1 List.393;
+        let List.634 : U64 = StructAtIndex 0 List.393;
+        let List.632 : List U8 = CallByName List.72 List.392 List.633 List.634;
+        ret List.632;
 
-procedure List.71 (#Attr.2, #Attr.3):
+procedure List.52 (List.407, List.408):
-    let List.555 : List Str = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    let List.409 : U64 = CallByName List.6 List.407;
-    ret List.555;
+    joinpoint List.644 List.410:
+        let List.642 : U64 = 0i64;
+        let List.641 : {U64, U64} = Struct {List.410, List.642};
+        inc List.407;
+        let List.411 : List U8 = CallByName List.49 List.407 List.641;
+        let List.640 : U64 = CallByName Num.75 List.409 List.410;
+        let List.631 : {U64, U64} = Struct {List.640, List.410};
+        let List.412 : List U8 = CallByName List.49 List.407 List.631;
+        let List.630 : {List U8, List U8} = Struct {List.411, List.412};
+        ret List.630;
+    in
+    let List.645 : Int1 = CallByName Num.24 List.409 List.408;
+    if List.645 then
+        jump List.644 List.408;
+    else
+        jump List.644 List.409;
 
-procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
+procedure List.6 (#Attr.2):
-    let List.625 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
+    let List.625 : U64 = lowlevel ListLen #Attr.2;
     ret List.625;
 
-procedure List.8 (#Attr.2, #Attr.3):
+procedure List.6 (#Attr.2):
-    let List.590 : List Str = lowlevel ListConcat #Attr.2 #Attr.3;
+    let List.626 : U64 = lowlevel ListLen #Attr.2;
-    ret List.590;
+    ret List.626;
+
+procedure List.6 (#Attr.2):
+    let List.628 : U64 = lowlevel ListLen #Attr.2;
+    ret List.628;
+
+procedure List.66 (#Attr.2, #Attr.3):
+    let List.584 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.584;
+
+procedure List.66 (#Attr.2, #Attr.3):
+    let List.596 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.596;
+
+procedure List.68 (#Attr.2):
+    let List.621 : List Str = lowlevel ListWithCapacity #Attr.2;
+    ret List.621;
+
+procedure List.68 (#Attr.2):
+    let List.623 : List U8 = lowlevel ListWithCapacity #Attr.2;
+    ret List.623;
+
+procedure List.70 (#Attr.2, #Attr.3):
+    let List.550 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    ret List.550;
+
+procedure List.70 (#Attr.2, #Attr.3):
+    let List.567 : List Str = lowlevel ListReserve #Attr.2 #Attr.3;
+    ret List.567;
+
+procedure List.71 (#Attr.2, #Attr.3):
+    let List.548 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.548;
+
+procedure List.71 (#Attr.2, #Attr.3):
+    let List.565 : List Str = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.565;
+
+procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
+    let List.635 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
+    ret List.635;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.598 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    let List.600 : List Str = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.598;
+    ret List.600;
+
+procedure List.8 (#Attr.2, #Attr.3):
+    let List.608 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    ret List.608;
 
 procedure List.80 (#Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14, #Derived_gen.15):
-    joinpoint List.645 List.453 List.454 List.455 List.456 List.457:
+    joinpoint List.655 List.463 List.464 List.465 List.466 List.467:
-        let List.647 : Int1 = CallByName Num.22 List.456 List.457;
+        let List.657 : Int1 = CallByName Num.22 List.466 List.467;
-        if List.647 then
+        if List.657 then
-            let List.656 : U8 = CallByName List.66 List.453 List.456;
+            let List.666 : U8 = CallByName List.66 List.463 List.466;
-            let List.648 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.454 List.656;
+            let List.658 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.464 List.666;
-            let List.653 : U8 = 1i64;
+            let List.663 : U8 = 1i64;
-            let List.654 : U8 = GetTagId List.648;
+            let List.664 : U8 = GetTagId List.658;
-            let List.655 : Int1 = lowlevel Eq List.653 List.654;
+            let List.665 : Int1 = lowlevel Eq List.663 List.664;
-            if List.655 then
+            if List.665 then
-                let List.458 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.648;
+                let List.468 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.658;
-                let List.651 : U64 = 1i64;
+                let List.661 : U64 = 1i64;
-                let List.650 : U64 = CallByName Num.51 List.456 List.651;
+                let List.660 : U64 = CallByName Num.51 List.466 List.661;
-                jump List.645 List.453 List.458 List.455 List.650 List.457;
+                jump List.655 List.463 List.468 List.465 List.660 List.467;
             else
-                dec List.453;
+                dec List.463;
-                let List.459 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.648;
+                let List.469 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.658;
-                let List.652 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.459;
+                let List.662 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.469;
-                ret List.652;
+                ret List.662;
         else
-            dec List.453;
+            dec List.463;
-            let List.646 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.454;
+            let List.656 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.464;
-            ret List.646;
+            ret List.656;
     in
-    jump List.645 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15;
+    jump List.655 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15;
 
-procedure List.86 (#Derived_gen.26, #Derived_gen.27, #Derived_gen.28, #Derived_gen.29, #Derived_gen.30):
+procedure List.87 (#Derived_gen.25, #Derived_gen.26, #Derived_gen.27, #Derived_gen.28, #Derived_gen.29):
-    joinpoint List.579 List.148 List.149 List.150 List.151 List.152:
+    joinpoint List.589 List.150 List.151 List.152 List.153 List.154:
-        let List.581 : Int1 = CallByName Num.22 List.151 List.152;
+        let List.591 : Int1 = CallByName Num.22 List.153 List.154;
-        if List.581 then
+        if List.591 then
-            let List.585 : U8 = CallByName List.66 List.148 List.151;
+            let List.595 : U8 = CallByName List.66 List.150 List.153;
-            let List.153 : List U8 = CallByName TotallyNotJson.215 List.149 List.585;
+            let List.155 : List U8 = CallByName TotallyNotJson.215 List.151 List.595;
-            let List.584 : U64 = 1i64;
+            let List.594 : U64 = 1i64;
-            let List.583 : U64 = CallByName Num.51 List.151 List.584;
+            let List.593 : U64 = CallByName Num.51 List.153 List.594;
-            jump List.579 List.148 List.153 List.150 List.583 List.152;
+            jump List.589 List.150 List.155 List.152 List.593 List.154;
         else
-            dec List.148;
+            dec List.150;
-            ret List.149;
+            ret List.151;
     in
-    jump List.579 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30;
+    jump List.589 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29;
 
-procedure List.86 (#Derived_gen.31, #Derived_gen.32, #Derived_gen.33, #Derived_gen.34, #Derived_gen.35):
+procedure List.87 (#Derived_gen.31, #Derived_gen.32, #Derived_gen.33, #Derived_gen.34, #Derived_gen.35):
-    joinpoint List.567 List.148 List.149 List.150 List.151 List.152:
+    joinpoint List.577 List.150 List.151 List.152 List.153 List.154:
-        let List.569 : Int1 = CallByName Num.22 List.151 List.152;
+        let List.579 : Int1 = CallByName Num.22 List.153 List.154;
-        if List.569 then
+        if List.579 then
-            let List.573 : {Str, Str} = CallByName List.66 List.148 List.151;
+            let List.583 : {Str, Str} = CallByName List.66 List.150 List.153;
-            inc List.573;
+            inc List.583;
-            let List.153 : {List U8, U64} = CallByName TotallyNotJson.237 List.149 List.573 List.150;
+            let List.155 : {List U8, U64} = CallByName TotallyNotJson.237 List.151 List.583 List.152;
-            let List.572 : U64 = 1i64;
+            let List.582 : U64 = 1i64;
-            let List.571 : U64 = CallByName Num.51 List.151 List.572;
+            let List.581 : U64 = CallByName Num.51 List.153 List.582;
-            jump List.567 List.148 List.153 List.150 List.571 List.152;
+            jump List.577 List.150 List.155 List.152 List.581 List.154;
         else
-            dec List.148;
+            dec List.150;
-            ret List.149;
+            ret List.151;
     in
-    jump List.567 #Derived_gen.31 #Derived_gen.32 #Derived_gen.33 #Derived_gen.34 #Derived_gen.35;
+    jump List.577 #Derived_gen.31 #Derived_gen.32 #Derived_gen.33 #Derived_gen.34 #Derived_gen.35;
 
-procedure List.96 (List.450, List.451, List.452):
+procedure List.98 (List.460, List.461, List.462):
-    let List.643 : U64 = 0i64;
+    let List.653 : U64 = 0i64;
-    let List.644 : U64 = CallByName List.6 List.450;
+    let List.654 : U64 = CallByName List.6 List.460;
-    let List.642 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.450 List.451 List.452 List.643 List.644;
+    let List.652 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.460 List.461 List.462 List.653 List.654;
-    ret List.642;
+    ret List.652;
 
 procedure Num.127 (#Attr.2):
     let Num.296 : U8 = lowlevel NumIntCast #Attr.2;
@@ -288,38 +288,38 @@ procedure Num.94 (#Attr.2, #Attr.3):
     ret Num.301;
 
 procedure Str.12 (#Attr.2):
-    let Str.300 : List U8 = lowlevel StrToUtf8 #Attr.2;
+    let Str.303 : List U8 = lowlevel StrToUtf8 #Attr.2;
-    ret Str.300;
-
-procedure Str.4 (#Attr.2, #Attr.3):
-    let Str.303 : Str = lowlevel StrJoinWith #Attr.2 #Attr.3;
     ret Str.303;
 
-procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
+procedure Str.4 (#Attr.2, #Attr.3):
-    let Str.298 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
+    let Str.306 : Str = lowlevel StrJoinWith #Attr.2 #Attr.3;
-    ret Str.298;
-
-procedure Str.55 (#Attr.2):
-    let Str.306 : List Str = lowlevel StrGraphemes #Attr.2;
     ret Str.306;
 
-procedure Str.9 (Str.79):
+procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
-    let Str.296 : U64 = 0i64;
+    let Str.301 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
-    let Str.297 : U64 = CallByName List.6 Str.79;
+    ret Str.301;
-    let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.296 Str.297;
+
-    let Str.293 : Int1 = StructAtIndex 2 Str.80;
+procedure Str.55 (#Attr.2):
-    if Str.293 then
+    let Str.309 : List Str = lowlevel StrGraphemes #Attr.2;
-        let Str.295 : Str = StructAtIndex 1 Str.80;
+    ret Str.309;
-        let Str.294 : [C {U64, U8}, C Str] = TagId(1) Str.295;
+
-        ret Str.294;
+procedure Str.9 (Str.80):
+    let Str.299 : U64 = 0i64;
+    let Str.300 : U64 = CallByName List.6 Str.80;
+    let Str.81 : {U64, Str, Int1, U8} = CallByName Str.48 Str.80 Str.299 Str.300;
+    let Str.296 : Int1 = StructAtIndex 2 Str.81;
+    if Str.296 then
+        let Str.298 : Str = StructAtIndex 1 Str.81;
+        let Str.297 : [C {U64, U8}, C Str] = TagId(1) Str.298;
+        ret Str.297;
     else
-        let Str.291 : U8 = StructAtIndex 3 Str.80;
+        let Str.294 : U8 = StructAtIndex 3 Str.81;
-        let Str.292 : U64 = StructAtIndex 0 Str.80;
+        let Str.295 : U64 = StructAtIndex 0 Str.81;
-        let #Derived_gen.36 : Str = StructAtIndex 1 Str.80;
+        let #Derived_gen.36 : Str = StructAtIndex 1 Str.81;
         dec #Derived_gen.36;
-        let Str.290 : {U64, U8} = Struct {Str.292, Str.291};
+        let Str.293 : {U64, U8} = Struct {Str.295, Str.294};
-        let Str.289 : [C {U64, U8}, C Str] = TagId(0) Str.290;
+        let Str.292 : [C {U64, U8}, C Str] = TagId(0) Str.293;
-        ret Str.289;
+        ret Str.292;
 
 procedure TotallyNotJson.100 (TotallyNotJson.850):
     let TotallyNotJson.1479 : Str = "a";
@@ -1269,7 +1269,7 @@ procedure TotallyNotJson.95 (TotallyNotJson.829):
     dec TotallyNotJson.1489;
     ret TotallyNotJson.1488;
 
-procedure TotallyNotJson.96 (#Derived_gen.25):
+procedure TotallyNotJson.96 (#Derived_gen.30):
     joinpoint TotallyNotJson.1496 TotallyNotJson.1168:
         let TotallyNotJson.834 : List Str = StructAtIndex 0 TotallyNotJson.1168;
         let TotallyNotJson.833 : List Str = StructAtIndex 1 TotallyNotJson.1168;
@@ -1305,7 +1305,7 @@ procedure TotallyNotJson.96 (#Derived_gen.25):
             let TotallyNotJson.1497 : {List Str, List Str} = Struct {TotallyNotJson.834, TotallyNotJson.833};
             ret TotallyNotJson.1497;
     in
-    jump TotallyNotJson.1496 #Derived_gen.25;
+    jump TotallyNotJson.1496 #Derived_gen.30;
 
 procedure TotallyNotJson.97 (TotallyNotJson.837):
     let TotallyNotJson.838 : List Str = CallByName Str.55 TotallyNotJson.837;

crates/compiler/test_mono/generated/encode_derived_record_two_field_strings.txt

@@ -58,205 +58,205 @@ procedure Encode.26 (Encode.105, Encode.106):
     ret Encode.108;
 
 procedure List.13 (#Attr.2, #Attr.3):
-    let List.619 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3;
+    let List.629 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3;
-    ret List.619;
+    ret List.629;
 
-procedure List.18 (List.145, List.146, List.147):
+procedure List.18 (List.147, List.148, List.149):
-    let List.565 : U64 = 0i64;
+    let List.575 : U64 = 0i64;
-    let List.566 : U64 = CallByName List.6 List.145;
+    let List.576 : U64 = CallByName List.6 List.147;
-    let List.564 : {List U8, U64} = CallByName List.86 List.145 List.146 List.147 List.565 List.566;
+    let List.574 : {List U8, U64} = CallByName List.87 List.147 List.148 List.149 List.575 List.576;
-    ret List.564;
-
-procedure List.18 (List.145, List.146, List.147):
-    let List.577 : U64 = 0i64;
-    let List.578 : U64 = CallByName List.6 List.145;
-    let List.576 : List U8 = CallByName List.86 List.145 List.146 List.147 List.577 List.578;
-    ret List.576;
-
-procedure List.26 (List.172, List.173, List.174):
-    let List.636 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.96 List.172 List.173 List.174;
-    let List.639 : U8 = 1i64;
-    let List.640 : U8 = GetTagId List.636;
-    let List.641 : Int1 = lowlevel Eq List.639 List.640;
-    if List.641 then
-        let List.175 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.636;
-        ret List.175;
-    else
-        let List.176 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.636;
-        ret List.176;
-
-procedure List.31 (#Attr.2, #Attr.3):
-    let List.601 : List Str = lowlevel ListDropAt #Attr.2 #Attr.3;
-    ret List.601;
-
-procedure List.38 (List.311):
-    let List.609 : U64 = 0i64;
-    let List.608 : List Str = CallByName List.31 List.311 List.609;
-    ret List.608;
-
-procedure List.4 (List.116, List.117):
-    let List.560 : U64 = 1i64;
-    let List.559 : List Str = CallByName List.70 List.116 List.560;
-    let List.558 : List Str = CallByName List.71 List.559 List.117;
-    ret List.558;
-
-procedure List.4 (List.116, List.117):
-    let List.563 : U64 = 1i64;
-    let List.562 : List U8 = CallByName List.70 List.116 List.563;
-    let List.561 : List U8 = CallByName List.71 List.562 List.117;
-    ret List.561;
-
-procedure List.49 (List.390, List.391):
-    let List.628 : U64 = StructAtIndex 0 List.391;
-    let List.629 : U64 = 0i64;
-    let List.626 : Int1 = CallByName Bool.11 List.628 List.629;
-    if List.626 then
-        dec List.390;
-        let List.627 : List U8 = Array [];
-        ret List.627;
-    else
-        let List.623 : U64 = StructAtIndex 1 List.391;
-        let List.624 : U64 = StructAtIndex 0 List.391;
-        let List.622 : List U8 = CallByName List.72 List.390 List.623 List.624;
-        ret List.622;
-
-procedure List.52 (List.405, List.406):
-    let List.407 : U64 = CallByName List.6 List.405;
-    joinpoint List.634 List.408:
-        let List.632 : U64 = 0i64;
-        let List.631 : {U64, U64} = Struct {List.408, List.632};
-        inc List.405;
-        let List.409 : List U8 = CallByName List.49 List.405 List.631;
-        let List.630 : U64 = CallByName Num.75 List.407 List.408;
-        let List.621 : {U64, U64} = Struct {List.630, List.408};
-        let List.410 : List U8 = CallByName List.49 List.405 List.621;
-        let List.620 : {List U8, List U8} = Struct {List.409, List.410};
-        ret List.620;
-    in
-    let List.635 : Int1 = CallByName Num.24 List.407 List.406;
-    if List.635 then
-        jump List.634 List.406;
-    else
-        jump List.634 List.407;
-
-procedure List.6 (#Attr.2):
-    let List.615 : U64 = lowlevel ListLen #Attr.2;
-    ret List.615;
-
-procedure List.6 (#Attr.2):
-    let List.616 : U64 = lowlevel ListLen #Attr.2;
-    ret List.616;
-
-procedure List.6 (#Attr.2):
-    let List.618 : U64 = lowlevel ListLen #Attr.2;
-    ret List.618;
-
-procedure List.66 (#Attr.2, #Attr.3):
-    let List.574 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
     ret List.574;
 
-procedure List.66 (#Attr.2, #Attr.3):
+procedure List.18 (List.147, List.148, List.149):
-    let List.586 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.587 : U64 = 0i64;
+    let List.588 : U64 = CallByName List.6 List.147;
+    let List.586 : List U8 = CallByName List.87 List.147 List.148 List.149 List.587 List.588;
     ret List.586;
 
-procedure List.68 (#Attr.2):
+procedure List.26 (List.174, List.175, List.176):
-    let List.611 : List Str = lowlevel ListWithCapacity #Attr.2;
+    let List.646 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.98 List.174 List.175 List.176;
+    let List.649 : U8 = 1i64;
+    let List.650 : U8 = GetTagId List.646;
+    let List.651 : Int1 = lowlevel Eq List.649 List.650;
+    if List.651 then
+        let List.177 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.646;
+        ret List.177;
+    else
+        let List.178 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.646;
+        ret List.178;
+
+procedure List.31 (#Attr.2, #Attr.3):
+    let List.611 : List Str = lowlevel ListDropAt #Attr.2 #Attr.3;
     ret List.611;
 
-procedure List.68 (#Attr.2):
+procedure List.38 (List.313):
-    let List.613 : List U8 = lowlevel ListWithCapacity #Attr.2;
+    let List.619 : U64 = 0i64;
-    ret List.613;
+    let List.618 : List Str = CallByName List.31 List.313 List.619;
+    ret List.618;
 
-procedure List.70 (#Attr.2, #Attr.3):
+procedure List.4 (List.118, List.119):
-    let List.540 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    let List.570 : U64 = 1i64;
-    ret List.540;
+    let List.569 : List Str = CallByName List.70 List.118 List.570;
+    let List.568 : List Str = CallByName List.71 List.569 List.119;
+    ret List.568;
 
-procedure List.70 (#Attr.2, #Attr.3):
+procedure List.4 (List.118, List.119):
-    let List.557 : List Str = lowlevel ListReserve #Attr.2 #Attr.3;
+    let List.573 : U64 = 1i64;
-    ret List.557;
+    let List.572 : List U8 = CallByName List.70 List.118 List.573;
+    let List.571 : List U8 = CallByName List.71 List.572 List.119;
+    ret List.571;
 
-procedure List.71 (#Attr.2, #Attr.3):
+procedure List.49 (List.392, List.393):
-    let List.538 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    let List.638 : U64 = StructAtIndex 0 List.393;
-    ret List.538;
+    let List.639 : U64 = 0i64;
+    let List.636 : Int1 = CallByName Bool.11 List.638 List.639;
+    if List.636 then
+        dec List.392;
+        let List.637 : List U8 = Array [];
+        ret List.637;
+    else
+        let List.633 : U64 = StructAtIndex 1 List.393;
+        let List.634 : U64 = StructAtIndex 0 List.393;
+        let List.632 : List U8 = CallByName List.72 List.392 List.633 List.634;
+        ret List.632;
 
-procedure List.71 (#Attr.2, #Attr.3):
+procedure List.52 (List.407, List.408):
-    let List.555 : List Str = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    let List.409 : U64 = CallByName List.6 List.407;
-    ret List.555;
+    joinpoint List.644 List.410:
+        let List.642 : U64 = 0i64;
+        let List.641 : {U64, U64} = Struct {List.410, List.642};
+        inc List.407;
+        let List.411 : List U8 = CallByName List.49 List.407 List.641;
+        let List.640 : U64 = CallByName Num.75 List.409 List.410;
+        let List.631 : {U64, U64} = Struct {List.640, List.410};
+        let List.412 : List U8 = CallByName List.49 List.407 List.631;
+        let List.630 : {List U8, List U8} = Struct {List.411, List.412};
+        ret List.630;
+    in
+    let List.645 : Int1 = CallByName Num.24 List.409 List.408;
+    if List.645 then
+        jump List.644 List.408;
+    else
+        jump List.644 List.409;
 
-procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
+procedure List.6 (#Attr.2):
-    let List.625 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
+    let List.625 : U64 = lowlevel ListLen #Attr.2;
     ret List.625;
 
-procedure List.8 (#Attr.2, #Attr.3):
+procedure List.6 (#Attr.2):
-    let List.590 : List Str = lowlevel ListConcat #Attr.2 #Attr.3;
+    let List.626 : U64 = lowlevel ListLen #Attr.2;
-    ret List.590;
+    ret List.626;
+
+procedure List.6 (#Attr.2):
+    let List.628 : U64 = lowlevel ListLen #Attr.2;
+    ret List.628;
+
+procedure List.66 (#Attr.2, #Attr.3):
+    let List.584 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.584;
+
+procedure List.66 (#Attr.2, #Attr.3):
+    let List.596 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.596;
+
+procedure List.68 (#Attr.2):
+    let List.621 : List Str = lowlevel ListWithCapacity #Attr.2;
+    ret List.621;
+
+procedure List.68 (#Attr.2):
+    let List.623 : List U8 = lowlevel ListWithCapacity #Attr.2;
+    ret List.623;
+
+procedure List.70 (#Attr.2, #Attr.3):
+    let List.550 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    ret List.550;
+
+procedure List.70 (#Attr.2, #Attr.3):
+    let List.567 : List Str = lowlevel ListReserve #Attr.2 #Attr.3;
+    ret List.567;
+
+procedure List.71 (#Attr.2, #Attr.3):
+    let List.548 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.548;
+
+procedure List.71 (#Attr.2, #Attr.3):
+    let List.565 : List Str = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.565;
+
+procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
+    let List.635 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
+    ret List.635;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.598 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    let List.600 : List Str = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.598;
+    ret List.600;
+
+procedure List.8 (#Attr.2, #Attr.3):
+    let List.608 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    ret List.608;
 
 procedure List.80 (#Derived_gen.15, #Derived_gen.16, #Derived_gen.17, #Derived_gen.18, #Derived_gen.19):
-    joinpoint List.645 List.453 List.454 List.455 List.456 List.457:
+    joinpoint List.655 List.463 List.464 List.465 List.466 List.467:
-        let List.647 : Int1 = CallByName Num.22 List.456 List.457;
+        let List.657 : Int1 = CallByName Num.22 List.466 List.467;
-        if List.647 then
+        if List.657 then
-            let List.656 : U8 = CallByName List.66 List.453 List.456;
+            let List.666 : U8 = CallByName List.66 List.463 List.466;
-            let List.648 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.454 List.656;
+            let List.658 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.464 List.666;
-            let List.653 : U8 = 1i64;
+            let List.663 : U8 = 1i64;
-            let List.654 : U8 = GetTagId List.648;
+            let List.664 : U8 = GetTagId List.658;
-            let List.655 : Int1 = lowlevel Eq List.653 List.654;
+            let List.665 : Int1 = lowlevel Eq List.663 List.664;
-            if List.655 then
+            if List.665 then
-                let List.458 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.648;
+                let List.468 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.658;
-                let List.651 : U64 = 1i64;
+                let List.661 : U64 = 1i64;
-                let List.650 : U64 = CallByName Num.51 List.456 List.651;
+                let List.660 : U64 = CallByName Num.51 List.466 List.661;
-                jump List.645 List.453 List.458 List.455 List.650 List.457;
+                jump List.655 List.463 List.468 List.465 List.660 List.467;
             else
-                dec List.453;
+                dec List.463;
-                let List.459 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.648;
+                let List.469 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.658;
-                let List.652 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.459;
+                let List.662 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.469;
-                ret List.652;
+                ret List.662;
         else
-            dec List.453;
+            dec List.463;
-            let List.646 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.454;
+            let List.656 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.464;
-            ret List.646;
+            ret List.656;
     in
-    jump List.645 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19;
+    jump List.655 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19;
 
-procedure List.86 (#Derived_gen.30, #Derived_gen.31, #Derived_gen.32, #Derived_gen.33, #Derived_gen.34):
+procedure List.87 (#Derived_gen.29, #Derived_gen.30, #Derived_gen.31, #Derived_gen.32, #Derived_gen.33):
-    joinpoint List.579 List.148 List.149 List.150 List.151 List.152:
+    joinpoint List.589 List.150 List.151 List.152 List.153 List.154:
-        let List.581 : Int1 = CallByName Num.22 List.151 List.152;
+        let List.591 : Int1 = CallByName Num.22 List.153 List.154;
-        if List.581 then
+        if List.591 then
-            let List.585 : U8 = CallByName List.66 List.148 List.151;
+            let List.595 : U8 = CallByName List.66 List.150 List.153;
-            let List.153 : List U8 = CallByName TotallyNotJson.215 List.149 List.585;
+            let List.155 : List U8 = CallByName TotallyNotJson.215 List.151 List.595;
-            let List.584 : U64 = 1i64;
+            let List.594 : U64 = 1i64;
-            let List.583 : U64 = CallByName Num.51 List.151 List.584;
+            let List.593 : U64 = CallByName Num.51 List.153 List.594;
-            jump List.579 List.148 List.153 List.150 List.583 List.152;
+            jump List.589 List.150 List.155 List.152 List.593 List.154;
         else
-            dec List.148;
+            dec List.150;
-            ret List.149;
+            ret List.151;
     in
-    jump List.579 #Derived_gen.30 #Derived_gen.31 #Derived_gen.32 #Derived_gen.33 #Derived_gen.34;
+    jump List.589 #Derived_gen.29 #Derived_gen.30 #Derived_gen.31 #Derived_gen.32 #Derived_gen.33;
 
-procedure List.86 (#Derived_gen.35, #Derived_gen.36, #Derived_gen.37, #Derived_gen.38, #Derived_gen.39):
+procedure List.87 (#Derived_gen.35, #Derived_gen.36, #Derived_gen.37, #Derived_gen.38, #Derived_gen.39):
-    joinpoint List.567 List.148 List.149 List.150 List.151 List.152:
+    joinpoint List.577 List.150 List.151 List.152 List.153 List.154:
-        let List.569 : Int1 = CallByName Num.22 List.151 List.152;
+        let List.579 : Int1 = CallByName Num.22 List.153 List.154;
-        if List.569 then
+        if List.579 then
-            let List.573 : {Str, Str} = CallByName List.66 List.148 List.151;
+            let List.583 : {Str, Str} = CallByName List.66 List.150 List.153;
-            inc List.573;
+            inc List.583;
-            let List.153 : {List U8, U64} = CallByName TotallyNotJson.237 List.149 List.573 List.150;
+            let List.155 : {List U8, U64} = CallByName TotallyNotJson.237 List.151 List.583 List.152;
-            let List.572 : U64 = 1i64;
+            let List.582 : U64 = 1i64;
-            let List.571 : U64 = CallByName Num.51 List.151 List.572;
+            let List.581 : U64 = CallByName Num.51 List.153 List.582;
-            jump List.567 List.148 List.153 List.150 List.571 List.152;
+            jump List.577 List.150 List.155 List.152 List.581 List.154;
         else
-            dec List.148;
+            dec List.150;
-            ret List.149;
+            ret List.151;
     in
-    jump List.567 #Derived_gen.35 #Derived_gen.36 #Derived_gen.37 #Derived_gen.38 #Derived_gen.39;
+    jump List.577 #Derived_gen.35 #Derived_gen.36 #Derived_gen.37 #Derived_gen.38 #Derived_gen.39;
 
-procedure List.96 (List.450, List.451, List.452):
+procedure List.98 (List.460, List.461, List.462):
-    let List.643 : U64 = 0i64;
+    let List.653 : U64 = 0i64;
-    let List.644 : U64 = CallByName List.6 List.450;
+    let List.654 : U64 = CallByName List.6 List.460;
-    let List.642 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.450 List.451 List.452 List.643 List.644;
+    let List.652 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.460 List.461 List.462 List.653 List.654;
-    ret List.642;
+    ret List.652;
 
 procedure Num.127 (#Attr.2):
     let Num.296 : U8 = lowlevel NumIntCast #Attr.2;
@@ -295,38 +295,38 @@ procedure Num.94 (#Attr.2, #Attr.3):
     ret Num.301;
 
 procedure Str.12 (#Attr.2):
-    let Str.300 : List U8 = lowlevel StrToUtf8 #Attr.2;
+    let Str.303 : List U8 = lowlevel StrToUtf8 #Attr.2;
-    ret Str.300;
-
-procedure Str.4 (#Attr.2, #Attr.3):
-    let Str.303 : Str = lowlevel StrJoinWith #Attr.2 #Attr.3;
     ret Str.303;
 
-procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
+procedure Str.4 (#Attr.2, #Attr.3):
-    let Str.298 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
+    let Str.306 : Str = lowlevel StrJoinWith #Attr.2 #Attr.3;
-    ret Str.298;
-
-procedure Str.55 (#Attr.2):
-    let Str.306 : List Str = lowlevel StrGraphemes #Attr.2;
     ret Str.306;
 
-procedure Str.9 (Str.79):
+procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
-    let Str.296 : U64 = 0i64;
+    let Str.301 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
-    let Str.297 : U64 = CallByName List.6 Str.79;
+    ret Str.301;
-    let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.296 Str.297;
+
-    let Str.293 : Int1 = StructAtIndex 2 Str.80;
+procedure Str.55 (#Attr.2):
-    if Str.293 then
+    let Str.309 : List Str = lowlevel StrGraphemes #Attr.2;
-        let Str.295 : Str = StructAtIndex 1 Str.80;
+    ret Str.309;
-        let Str.294 : [C {U64, U8}, C Str] = TagId(1) Str.295;
+
-        ret Str.294;
+procedure Str.9 (Str.80):
+    let Str.299 : U64 = 0i64;
+    let Str.300 : U64 = CallByName List.6 Str.80;
+    let Str.81 : {U64, Str, Int1, U8} = CallByName Str.48 Str.80 Str.299 Str.300;
+    let Str.296 : Int1 = StructAtIndex 2 Str.81;
+    if Str.296 then
+        let Str.298 : Str = StructAtIndex 1 Str.81;
+        let Str.297 : [C {U64, U8}, C Str] = TagId(1) Str.298;
+        ret Str.297;
     else
-        let Str.291 : U8 = StructAtIndex 3 Str.80;
+        let Str.294 : U8 = StructAtIndex 3 Str.81;
-        let Str.292 : U64 = StructAtIndex 0 Str.80;
+        let Str.295 : U64 = StructAtIndex 0 Str.81;
-        let #Derived_gen.40 : Str = StructAtIndex 1 Str.80;
+        let #Derived_gen.40 : Str = StructAtIndex 1 Str.81;
         dec #Derived_gen.40;
-        let Str.290 : {U64, U8} = Struct {Str.292, Str.291};
+        let Str.293 : {U64, U8} = Struct {Str.295, Str.294};
-        let Str.289 : [C {U64, U8}, C Str] = TagId(0) Str.290;
+        let Str.292 : [C {U64, U8}, C Str] = TagId(0) Str.293;
-        ret Str.289;
+        ret Str.292;
 
 procedure TotallyNotJson.100 (TotallyNotJson.850):
     let TotallyNotJson.1479 : Str = "a";
@@ -1276,7 +1276,7 @@ procedure TotallyNotJson.95 (TotallyNotJson.829):
     dec TotallyNotJson.1489;
     ret TotallyNotJson.1488;
 
-procedure TotallyNotJson.96 (#Derived_gen.29):
+procedure TotallyNotJson.96 (#Derived_gen.34):
     joinpoint TotallyNotJson.1496 TotallyNotJson.1168:
         let TotallyNotJson.834 : List Str = StructAtIndex 0 TotallyNotJson.1168;
         let TotallyNotJson.833 : List Str = StructAtIndex 1 TotallyNotJson.1168;
@@ -1312,7 +1312,7 @@ procedure TotallyNotJson.96 (#Derived_gen.29):
             let TotallyNotJson.1497 : {List Str, List Str} = Struct {TotallyNotJson.834, TotallyNotJson.833};
             ret TotallyNotJson.1497;
     in
-    jump TotallyNotJson.1496 #Derived_gen.29;
+    jump TotallyNotJson.1496 #Derived_gen.34;
 
 procedure TotallyNotJson.97 (TotallyNotJson.837):
     let TotallyNotJson.838 : List Str = CallByName Str.55 TotallyNotJson.837;

crates/compiler/test_mono/generated/encode_derived_string.txt

@@ -15,123 +15,123 @@ procedure Encode.26 (Encode.105, Encode.106):
     let Encode.108 : List U8 = CallByName Encode.24 Encode.109 Encode.110 Encode.106;
     ret Encode.108;
 
-procedure List.18 (List.145, List.146, List.147):
+procedure List.18 (List.147, List.148, List.149):
-    let List.549 : U64 = 0i64;
+    let List.559 : U64 = 0i64;
-    let List.550 : U64 = CallByName List.6 List.145;
+    let List.560 : U64 = CallByName List.6 List.147;
-    let List.548 : List U8 = CallByName List.86 List.145 List.146 List.147 List.549 List.550;
+    let List.558 : List U8 = CallByName List.87 List.147 List.148 List.149 List.559 List.560;
-    ret List.548;
-
-procedure List.26 (List.172, List.173, List.174):
-    let List.575 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.96 List.172 List.173 List.174;
-    let List.578 : U8 = 1i64;
-    let List.579 : U8 = GetTagId List.575;
-    let List.580 : Int1 = lowlevel Eq List.578 List.579;
-    if List.580 then
-        let List.175 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.575;
-        ret List.175;
-    else
-        let List.176 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.575;
-        ret List.176;
-
-procedure List.49 (List.390, List.391):
-    let List.567 : U64 = StructAtIndex 0 List.391;
-    let List.568 : U64 = 0i64;
-    let List.565 : Int1 = CallByName Bool.11 List.567 List.568;
-    if List.565 then
-        dec List.390;
-        let List.566 : List U8 = Array [];
-        ret List.566;
-    else
-        let List.562 : U64 = StructAtIndex 1 List.391;
-        let List.563 : U64 = StructAtIndex 0 List.391;
-        let List.561 : List U8 = CallByName List.72 List.390 List.562 List.563;
-        ret List.561;
-
-procedure List.52 (List.405, List.406):
-    let List.407 : U64 = CallByName List.6 List.405;
-    joinpoint List.573 List.408:
-        let List.571 : U64 = 0i64;
-        let List.570 : {U64, U64} = Struct {List.408, List.571};
-        inc List.405;
-        let List.409 : List U8 = CallByName List.49 List.405 List.570;
-        let List.569 : U64 = CallByName Num.75 List.407 List.408;
-        let List.560 : {U64, U64} = Struct {List.569, List.408};
-        let List.410 : List U8 = CallByName List.49 List.405 List.560;
-        let List.559 : {List U8, List U8} = Struct {List.409, List.410};
-        ret List.559;
-    in
-    let List.574 : Int1 = CallByName Num.24 List.407 List.406;
-    if List.574 then
-        jump List.573 List.406;
-    else
-        jump List.573 List.407;
-
-procedure List.6 (#Attr.2):
-    let List.547 : U64 = lowlevel ListLen #Attr.2;
-    ret List.547;
-
-procedure List.66 (#Attr.2, #Attr.3):
-    let List.558 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
     ret List.558;
 
+procedure List.26 (List.174, List.175, List.176):
+    let List.585 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.98 List.174 List.175 List.176;
+    let List.588 : U8 = 1i64;
+    let List.589 : U8 = GetTagId List.585;
+    let List.590 : Int1 = lowlevel Eq List.588 List.589;
+    if List.590 then
+        let List.177 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.585;
+        ret List.177;
+    else
+        let List.178 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.585;
+        ret List.178;
+
+procedure List.49 (List.392, List.393):
+    let List.577 : U64 = StructAtIndex 0 List.393;
+    let List.578 : U64 = 0i64;
+    let List.575 : Int1 = CallByName Bool.11 List.577 List.578;
+    if List.575 then
+        dec List.392;
+        let List.576 : List U8 = Array [];
+        ret List.576;
+    else
+        let List.572 : U64 = StructAtIndex 1 List.393;
+        let List.573 : U64 = StructAtIndex 0 List.393;
+        let List.571 : List U8 = CallByName List.72 List.392 List.572 List.573;
+        ret List.571;
+
+procedure List.52 (List.407, List.408):
+    let List.409 : U64 = CallByName List.6 List.407;
+    joinpoint List.583 List.410:
+        let List.581 : U64 = 0i64;
+        let List.580 : {U64, U64} = Struct {List.410, List.581};
+        inc List.407;
+        let List.411 : List U8 = CallByName List.49 List.407 List.580;
+        let List.579 : U64 = CallByName Num.75 List.409 List.410;
+        let List.570 : {U64, U64} = Struct {List.579, List.410};
+        let List.412 : List U8 = CallByName List.49 List.407 List.570;
+        let List.569 : {List U8, List U8} = Struct {List.411, List.412};
+        ret List.569;
+    in
+    let List.584 : Int1 = CallByName Num.24 List.409 List.408;
+    if List.584 then
+        jump List.583 List.408;
+    else
+        jump List.583 List.409;
+
+procedure List.6 (#Attr.2):
+    let List.557 : U64 = lowlevel ListLen #Attr.2;
+    ret List.557;
+
+procedure List.66 (#Attr.2, #Attr.3):
+    let List.568 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.568;
+
 procedure List.68 (#Attr.2):
-    let List.545 : List U8 = lowlevel ListWithCapacity #Attr.2;
+    let List.555 : List U8 = lowlevel ListWithCapacity #Attr.2;
-    ret List.545;
+    ret List.555;
 
 procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
-    let List.564 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
+    let List.574 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
-    ret List.564;
+    ret List.574;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.543 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    let List.553 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.543;
+    ret List.553;
 
 procedure List.80 (#Derived_gen.8, #Derived_gen.9, #Derived_gen.10, #Derived_gen.11, #Derived_gen.12):
-    joinpoint List.584 List.453 List.454 List.455 List.456 List.457:
+    joinpoint List.594 List.463 List.464 List.465 List.466 List.467:
-        let List.586 : Int1 = CallByName Num.22 List.456 List.457;
+        let List.596 : Int1 = CallByName Num.22 List.466 List.467;
-        if List.586 then
+        if List.596 then
-            let List.595 : U8 = CallByName List.66 List.453 List.456;
+            let List.605 : U8 = CallByName List.66 List.463 List.466;
-            let List.587 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.454 List.595;
+            let List.597 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.464 List.605;
-            let List.592 : U8 = 1i64;
+            let List.602 : U8 = 1i64;
-            let List.593 : U8 = GetTagId List.587;
+            let List.603 : U8 = GetTagId List.597;
-            let List.594 : Int1 = lowlevel Eq List.592 List.593;
+            let List.604 : Int1 = lowlevel Eq List.602 List.603;
-            if List.594 then
+            if List.604 then
-                let List.458 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.587;
+                let List.468 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.597;
-                let List.590 : U64 = 1i64;
+                let List.600 : U64 = 1i64;
-                let List.589 : U64 = CallByName Num.51 List.456 List.590;
+                let List.599 : U64 = CallByName Num.51 List.466 List.600;
-                jump List.584 List.453 List.458 List.455 List.589 List.457;
+                jump List.594 List.463 List.468 List.465 List.599 List.467;
             else
-                dec List.453;
+                dec List.463;
-                let List.459 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.587;
+                let List.469 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.597;
-                let List.591 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.459;
+                let List.601 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.469;
-                ret List.591;
+                ret List.601;
         else
-            dec List.453;
+            dec List.463;
-            let List.585 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.454;
+            let List.595 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.464;
-            ret List.585;
+            ret List.595;
     in
-    jump List.584 #Derived_gen.8 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12;
+    jump List.594 #Derived_gen.8 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12;
 
-procedure List.86 (#Derived_gen.3, #Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7):
+procedure List.87 (#Derived_gen.3, #Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7):
-    joinpoint List.551 List.148 List.149 List.150 List.151 List.152:
+    joinpoint List.561 List.150 List.151 List.152 List.153 List.154:
-        let List.553 : Int1 = CallByName Num.22 List.151 List.152;
+        let List.563 : Int1 = CallByName Num.22 List.153 List.154;
-        if List.553 then
+        if List.563 then
-            let List.557 : U8 = CallByName List.66 List.148 List.151;
+            let List.567 : U8 = CallByName List.66 List.150 List.153;
-            let List.153 : List U8 = CallByName TotallyNotJson.215 List.149 List.557;
+            let List.155 : List U8 = CallByName TotallyNotJson.215 List.151 List.567;
-            let List.556 : U64 = 1i64;
+            let List.566 : U64 = 1i64;
-            let List.555 : U64 = CallByName Num.51 List.151 List.556;
+            let List.565 : U64 = CallByName Num.51 List.153 List.566;
-            jump List.551 List.148 List.153 List.150 List.555 List.152;
+            jump List.561 List.150 List.155 List.152 List.565 List.154;
         else
-            dec List.148;
+            dec List.150;
-            ret List.149;
+            ret List.151;
     in
-    jump List.551 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7;
+    jump List.561 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7;
 
-procedure List.96 (List.450, List.451, List.452):
+procedure List.98 (List.460, List.461, List.462):
-    let List.582 : U64 = 0i64;
+    let List.592 : U64 = 0i64;
-    let List.583 : U64 = CallByName List.6 List.450;
+    let List.593 : U64 = CallByName List.6 List.460;
-    let List.581 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.450 List.451 List.452 List.582 List.583;
+    let List.591 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.460 List.461 List.462 List.592 List.593;
-    ret List.581;
+    ret List.591;
 
 procedure Num.19 (#Attr.2, #Attr.3):
     let Num.292 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
@@ -162,30 +162,30 @@ procedure Num.94 (#Attr.2, #Attr.3):
     ret Num.293;
 
 procedure Str.12 (#Attr.2):
-    let Str.299 : List U8 = lowlevel StrToUtf8 #Attr.2;
+    let Str.302 : List U8 = lowlevel StrToUtf8 #Attr.2;
-    ret Str.299;
+    ret Str.302;
 
 procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
-    let Str.298 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
+    let Str.301 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
-    ret Str.298;
+    ret Str.301;
 
-procedure Str.9 (Str.79):
+procedure Str.9 (Str.80):
-    let Str.296 : U64 = 0i64;
+    let Str.299 : U64 = 0i64;
-    let Str.297 : U64 = CallByName List.6 Str.79;
+    let Str.300 : U64 = CallByName List.6 Str.80;
-    let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.296 Str.297;
+    let Str.81 : {U64, Str, Int1, U8} = CallByName Str.48 Str.80 Str.299 Str.300;
-    let Str.293 : Int1 = StructAtIndex 2 Str.80;
+    let Str.296 : Int1 = StructAtIndex 2 Str.81;
-    if Str.293 then
+    if Str.296 then
-        let Str.295 : Str = StructAtIndex 1 Str.80;
+        let Str.298 : Str = StructAtIndex 1 Str.81;
-        let Str.294 : [C {U64, U8}, C Str] = TagId(1) Str.295;
+        let Str.297 : [C {U64, U8}, C Str] = TagId(1) Str.298;
-        ret Str.294;
+        ret Str.297;
     else
-        let Str.291 : U8 = StructAtIndex 3 Str.80;
+        let Str.294 : U8 = StructAtIndex 3 Str.81;
-        let Str.292 : U64 = StructAtIndex 0 Str.80;
+        let Str.295 : U64 = StructAtIndex 0 Str.81;
-        let #Derived_gen.13 : Str = StructAtIndex 1 Str.80;
+        let #Derived_gen.13 : Str = StructAtIndex 1 Str.81;
         dec #Derived_gen.13;
-        let Str.290 : {U64, U8} = Struct {Str.292, Str.291};
+        let Str.293 : {U64, U8} = Struct {Str.295, Str.294};
-        let Str.289 : [C {U64, U8}, C Str] = TagId(0) Str.290;
+        let Str.292 : [C {U64, U8}, C Str] = TagId(0) Str.293;
-        ret Str.289;
+        ret Str.292;
 
 procedure TotallyNotJson.182 (TotallyNotJson.183, TotallyNotJson.1175, TotallyNotJson.181):
     let TotallyNotJson.1178 : List U8 = CallByName TotallyNotJson.26 TotallyNotJson.181;

crates/compiler/test_mono/generated/encode_derived_tag_one_field_string.txt

@@ -44,167 +44,167 @@ procedure Encode.26 (Encode.105, Encode.106):
     let Encode.108 : List U8 = CallByName Encode.24 Encode.109 Encode.110 Encode.106;
     ret Encode.108;
 
-procedure List.18 (List.145, List.146, List.147):
+procedure List.18 (List.147, List.148, List.149):
-    let List.563 : U64 = 0i64;
+    let List.573 : U64 = 0i64;
-    let List.564 : U64 = CallByName List.6 List.145;
+    let List.574 : U64 = CallByName List.6 List.147;
-    let List.562 : {List U8, U64} = CallByName List.86 List.145 List.146 List.147 List.563 List.564;
+    let List.572 : {List U8, U64} = CallByName List.87 List.147 List.148 List.149 List.573 List.574;
-    ret List.562;
-
-procedure List.18 (List.145, List.146, List.147):
-    let List.575 : U64 = 0i64;
-    let List.576 : U64 = CallByName List.6 List.145;
-    let List.574 : List U8 = CallByName List.86 List.145 List.146 List.147 List.575 List.576;
-    ret List.574;
-
-procedure List.26 (List.172, List.173, List.174):
-    let List.616 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.96 List.172 List.173 List.174;
-    let List.619 : U8 = 1i64;
-    let List.620 : U8 = GetTagId List.616;
-    let List.621 : Int1 = lowlevel Eq List.619 List.620;
-    if List.621 then
-        let List.175 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.616;
-        ret List.175;
-    else
-        let List.176 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.616;
-        ret List.176;
-
-procedure List.4 (List.116, List.117):
-    let List.561 : U64 = 1i64;
-    let List.560 : List U8 = CallByName List.70 List.116 List.561;
-    let List.559 : List U8 = CallByName List.71 List.560 List.117;
-    ret List.559;
-
-procedure List.49 (List.390, List.391):
-    let List.608 : U64 = StructAtIndex 0 List.391;
-    let List.609 : U64 = 0i64;
-    let List.606 : Int1 = CallByName Bool.11 List.608 List.609;
-    if List.606 then
-        dec List.390;
-        let List.607 : List U8 = Array [];
-        ret List.607;
-    else
-        let List.603 : U64 = StructAtIndex 1 List.391;
-        let List.604 : U64 = StructAtIndex 0 List.391;
-        let List.602 : List U8 = CallByName List.72 List.390 List.603 List.604;
-        ret List.602;
-
-procedure List.52 (List.405, List.406):
-    let List.407 : U64 = CallByName List.6 List.405;
-    joinpoint List.614 List.408:
-        let List.612 : U64 = 0i64;
-        let List.611 : {U64, U64} = Struct {List.408, List.612};
-        inc List.405;
-        let List.409 : List U8 = CallByName List.49 List.405 List.611;
-        let List.610 : U64 = CallByName Num.75 List.407 List.408;
-        let List.601 : {U64, U64} = Struct {List.610, List.408};
-        let List.410 : List U8 = CallByName List.49 List.405 List.601;
-        let List.600 : {List U8, List U8} = Struct {List.409, List.410};
-        ret List.600;
-    in
-    let List.615 : Int1 = CallByName Num.24 List.407 List.406;
-    if List.615 then
-        jump List.614 List.406;
-    else
-        jump List.614 List.407;
-
-procedure List.6 (#Attr.2):
-    let List.586 : U64 = lowlevel ListLen #Attr.2;
-    ret List.586;
-
-procedure List.6 (#Attr.2):
-    let List.588 : U64 = lowlevel ListLen #Attr.2;
-    ret List.588;
-
-procedure List.66 (#Attr.2, #Attr.3):
-    let List.572 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
     ret List.572;
 
-procedure List.66 (#Attr.2, #Attr.3):
+procedure List.18 (List.147, List.148, List.149):
-    let List.584 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.585 : U64 = 0i64;
+    let List.586 : U64 = CallByName List.6 List.147;
+    let List.584 : List U8 = CallByName List.87 List.147 List.148 List.149 List.585 List.586;
     ret List.584;
 
+procedure List.26 (List.174, List.175, List.176):
+    let List.626 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.98 List.174 List.175 List.176;
+    let List.629 : U8 = 1i64;
+    let List.630 : U8 = GetTagId List.626;
+    let List.631 : Int1 = lowlevel Eq List.629 List.630;
+    if List.631 then
+        let List.177 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.626;
+        ret List.177;
+    else
+        let List.178 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.626;
+        ret List.178;
+
+procedure List.4 (List.118, List.119):
+    let List.571 : U64 = 1i64;
+    let List.570 : List U8 = CallByName List.70 List.118 List.571;
+    let List.569 : List U8 = CallByName List.71 List.570 List.119;
+    ret List.569;
+
+procedure List.49 (List.392, List.393):
+    let List.618 : U64 = StructAtIndex 0 List.393;
+    let List.619 : U64 = 0i64;
+    let List.616 : Int1 = CallByName Bool.11 List.618 List.619;
+    if List.616 then
+        dec List.392;
+        let List.617 : List U8 = Array [];
+        ret List.617;
+    else
+        let List.613 : U64 = StructAtIndex 1 List.393;
+        let List.614 : U64 = StructAtIndex 0 List.393;
+        let List.612 : List U8 = CallByName List.72 List.392 List.613 List.614;
+        ret List.612;
+
+procedure List.52 (List.407, List.408):
+    let List.409 : U64 = CallByName List.6 List.407;
+    joinpoint List.624 List.410:
+        let List.622 : U64 = 0i64;
+        let List.621 : {U64, U64} = Struct {List.410, List.622};
+        inc List.407;
+        let List.411 : List U8 = CallByName List.49 List.407 List.621;
+        let List.620 : U64 = CallByName Num.75 List.409 List.410;
+        let List.611 : {U64, U64} = Struct {List.620, List.410};
+        let List.412 : List U8 = CallByName List.49 List.407 List.611;
+        let List.610 : {List U8, List U8} = Struct {List.411, List.412};
+        ret List.610;
+    in
+    let List.625 : Int1 = CallByName Num.24 List.409 List.408;
+    if List.625 then
+        jump List.624 List.408;
+    else
+        jump List.624 List.409;
+
+procedure List.6 (#Attr.2):
+    let List.596 : U64 = lowlevel ListLen #Attr.2;
+    ret List.596;
+
+procedure List.6 (#Attr.2):
+    let List.598 : U64 = lowlevel ListLen #Attr.2;
+    ret List.598;
+
+procedure List.66 (#Attr.2, #Attr.3):
+    let List.582 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.582;
+
+procedure List.66 (#Attr.2, #Attr.3):
+    let List.594 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.594;
+
 procedure List.68 (#Attr.2):
-    let List.599 : List U8 = lowlevel ListWithCapacity #Attr.2;
+    let List.609 : List U8 = lowlevel ListWithCapacity #Attr.2;
-    ret List.599;
+    ret List.609;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.540 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    let List.550 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.540;
+    ret List.550;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.538 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    let List.548 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.538;
+    ret List.548;
 
 procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
-    let List.605 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
+    let List.615 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
-    ret List.605;
+    ret List.615;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.597 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    let List.607 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.597;
+    ret List.607;
 
-procedure List.80 (#Derived_gen.16, #Derived_gen.17, #Derived_gen.18, #Derived_gen.19, #Derived_gen.20):
+procedure List.80 (#Derived_gen.21, #Derived_gen.22, #Derived_gen.23, #Derived_gen.24, #Derived_gen.25):
-    joinpoint List.625 List.453 List.454 List.455 List.456 List.457:
+    joinpoint List.635 List.463 List.464 List.465 List.466 List.467:
-        let List.627 : Int1 = CallByName Num.22 List.456 List.457;
+        let List.637 : Int1 = CallByName Num.22 List.466 List.467;
-        if List.627 then
+        if List.637 then
-            let List.636 : U8 = CallByName List.66 List.453 List.456;
+            let List.646 : U8 = CallByName List.66 List.463 List.466;
-            let List.628 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.454 List.636;
+            let List.638 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.464 List.646;
-            let List.633 : U8 = 1i64;
+            let List.643 : U8 = 1i64;
-            let List.634 : U8 = GetTagId List.628;
+            let List.644 : U8 = GetTagId List.638;
-            let List.635 : Int1 = lowlevel Eq List.633 List.634;
+            let List.645 : Int1 = lowlevel Eq List.643 List.644;
-            if List.635 then
+            if List.645 then
-                let List.458 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.628;
+                let List.468 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.638;
-                let List.631 : U64 = 1i64;
+                let List.641 : U64 = 1i64;
-                let List.630 : U64 = CallByName Num.51 List.456 List.631;
+                let List.640 : U64 = CallByName Num.51 List.466 List.641;
-                jump List.625 List.453 List.458 List.455 List.630 List.457;
+                jump List.635 List.463 List.468 List.465 List.640 List.467;
             else
-                dec List.453;
+                dec List.463;
-                let List.459 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.628;
+                let List.469 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.638;
-                let List.632 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.459;
+                let List.642 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.469;
-                ret List.632;
+                ret List.642;
         else
-            dec List.453;
+            dec List.463;
-            let List.626 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.454;
+            let List.636 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.464;
-            ret List.626;
+            ret List.636;
     in
-    jump List.625 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20;
+    jump List.635 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25;
 
-procedure List.86 (#Derived_gen.21, #Derived_gen.22, #Derived_gen.23, #Derived_gen.24, #Derived_gen.25):
+procedure List.87 (#Derived_gen.10, #Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14):
-    joinpoint List.577 List.148 List.149 List.150 List.151 List.152:
+    joinpoint List.575 List.150 List.151 List.152 List.153 List.154:
-        let List.579 : Int1 = CallByName Num.22 List.151 List.152;
+        let List.577 : Int1 = CallByName Num.22 List.153 List.154;
-        if List.579 then
+        if List.577 then
-            let List.583 : U8 = CallByName List.66 List.148 List.151;
+            let List.581 : Str = CallByName List.66 List.150 List.153;
-            let List.153 : List U8 = CallByName TotallyNotJson.215 List.149 List.583;
+            inc List.581;
-            let List.582 : U64 = 1i64;
+            let List.155 : {List U8, U64} = CallByName TotallyNotJson.267 List.151 List.581 List.152;
-            let List.581 : U64 = CallByName Num.51 List.151 List.582;
+            let List.580 : U64 = 1i64;
-            jump List.577 List.148 List.153 List.150 List.581 List.152;
+            let List.579 : U64 = CallByName Num.51 List.153 List.580;
+            jump List.575 List.150 List.155 List.152 List.579 List.154;
         else
-            dec List.148;
+            dec List.150;
-            ret List.149;
+            ret List.151;
     in
-    jump List.577 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25;
+    jump List.575 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14;
 
-procedure List.86 (#Derived_gen.26, #Derived_gen.27, #Derived_gen.28, #Derived_gen.29, #Derived_gen.30):
+procedure List.87 (#Derived_gen.26, #Derived_gen.27, #Derived_gen.28, #Derived_gen.29, #Derived_gen.30):
-    joinpoint List.565 List.148 List.149 List.150 List.151 List.152:
+    joinpoint List.587 List.150 List.151 List.152 List.153 List.154:
-        let List.567 : Int1 = CallByName Num.22 List.151 List.152;
+        let List.589 : Int1 = CallByName Num.22 List.153 List.154;
-        if List.567 then
+        if List.589 then
-            let List.571 : Str = CallByName List.66 List.148 List.151;
+            let List.593 : U8 = CallByName List.66 List.150 List.153;
-            inc List.571;
+            let List.155 : List U8 = CallByName TotallyNotJson.215 List.151 List.593;
-            let List.153 : {List U8, U64} = CallByName TotallyNotJson.267 List.149 List.571 List.150;
+            let List.592 : U64 = 1i64;
-            let List.570 : U64 = 1i64;
+            let List.591 : U64 = CallByName Num.51 List.153 List.592;
-            let List.569 : U64 = CallByName Num.51 List.151 List.570;
+            jump List.587 List.150 List.155 List.152 List.591 List.154;
-            jump List.565 List.148 List.153 List.150 List.569 List.152;
         else
-            dec List.148;
+            dec List.150;
-            ret List.149;
+            ret List.151;
     in
-    jump List.565 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30;
+    jump List.587 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30;
 
-procedure List.96 (List.450, List.451, List.452):
+procedure List.98 (List.460, List.461, List.462):
-    let List.623 : U64 = 0i64;
+    let List.633 : U64 = 0i64;
-    let List.624 : U64 = CallByName List.6 List.450;
+    let List.634 : U64 = CallByName List.6 List.460;
-    let List.622 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.450 List.451 List.452 List.623 List.624;
+    let List.632 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.460 List.461 List.462 List.633 List.634;
-    ret List.622;
+    ret List.632;
 
 procedure Num.127 (#Attr.2):
     let Num.298 : U8 = lowlevel NumIntCast #Attr.2;
@@ -243,30 +243,30 @@ procedure Num.94 (#Attr.2, #Attr.3):
     ret Num.303;
 
 procedure Str.12 (#Attr.2):
-    let Str.300 : List U8 = lowlevel StrToUtf8 #Attr.2;
+    let Str.303 : List U8 = lowlevel StrToUtf8 #Attr.2;
-    ret Str.300;
+    ret Str.303;
 
 procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
-    let Str.298 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
+    let Str.301 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
-    ret Str.298;
+    ret Str.301;
 
-procedure Str.9 (Str.79):
+procedure Str.9 (Str.80):
-    let Str.296 : U64 = 0i64;
+    let Str.299 : U64 = 0i64;
-    let Str.297 : U64 = CallByName List.6 Str.79;
+    let Str.300 : U64 = CallByName List.6 Str.80;
-    let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.296 Str.297;
+    let Str.81 : {U64, Str, Int1, U8} = CallByName Str.48 Str.80 Str.299 Str.300;
-    let Str.293 : Int1 = StructAtIndex 2 Str.80;
+    let Str.296 : Int1 = StructAtIndex 2 Str.81;
-    if Str.293 then
+    if Str.296 then
-        let Str.295 : Str = StructAtIndex 1 Str.80;
+        let Str.298 : Str = StructAtIndex 1 Str.81;
-        let Str.294 : [C {U64, U8}, C Str] = TagId(1) Str.295;
+        let Str.297 : [C {U64, U8}, C Str] = TagId(1) Str.298;
-        ret Str.294;
+        ret Str.297;
     else
-        let Str.291 : U8 = StructAtIndex 3 Str.80;
+        let Str.294 : U8 = StructAtIndex 3 Str.81;
-        let Str.292 : U64 = StructAtIndex 0 Str.80;
+        let Str.295 : U64 = StructAtIndex 0 Str.81;
-        let #Derived_gen.34 : Str = StructAtIndex 1 Str.80;
+        let #Derived_gen.34 : Str = StructAtIndex 1 Str.81;
         dec #Derived_gen.34;
-        let Str.290 : {U64, U8} = Struct {Str.292, Str.291};
+        let Str.293 : {U64, U8} = Struct {Str.295, Str.294};
-        let Str.289 : [C {U64, U8}, C Str] = TagId(0) Str.290;
+        let Str.292 : [C {U64, U8}, C Str] = TagId(0) Str.293;
-        ret Str.289;
+        ret Str.292;
 
 procedure TotallyNotJson.182 (TotallyNotJson.183, TotallyNotJson.1216, TotallyNotJson.181):
     let TotallyNotJson.1219 : List U8 = CallByName TotallyNotJson.26 TotallyNotJson.181;

crates/compiler/test_mono/generated/encode_derived_tag_two_payloads_string.txt

@@ -47,167 +47,167 @@ procedure Encode.26 (Encode.105, Encode.106):
     let Encode.108 : List U8 = CallByName Encode.24 Encode.109 Encode.110 Encode.106;
     ret Encode.108;
 
-procedure List.18 (List.145, List.146, List.147):
+procedure List.18 (List.147, List.148, List.149):
-    let List.563 : U64 = 0i64;
+    let List.573 : U64 = 0i64;
-    let List.564 : U64 = CallByName List.6 List.145;
+    let List.574 : U64 = CallByName List.6 List.147;
-    let List.562 : {List U8, U64} = CallByName List.86 List.145 List.146 List.147 List.563 List.564;
+    let List.572 : {List U8, U64} = CallByName List.87 List.147 List.148 List.149 List.573 List.574;
-    ret List.562;
-
-procedure List.18 (List.145, List.146, List.147):
-    let List.575 : U64 = 0i64;
-    let List.576 : U64 = CallByName List.6 List.145;
-    let List.574 : List U8 = CallByName List.86 List.145 List.146 List.147 List.575 List.576;
-    ret List.574;
-
-procedure List.26 (List.172, List.173, List.174):
-    let List.616 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.96 List.172 List.173 List.174;
-    let List.619 : U8 = 1i64;
-    let List.620 : U8 = GetTagId List.616;
-    let List.621 : Int1 = lowlevel Eq List.619 List.620;
-    if List.621 then
-        let List.175 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.616;
-        ret List.175;
-    else
-        let List.176 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.616;
-        ret List.176;
-
-procedure List.4 (List.116, List.117):
-    let List.561 : U64 = 1i64;
-    let List.560 : List U8 = CallByName List.70 List.116 List.561;
-    let List.559 : List U8 = CallByName List.71 List.560 List.117;
-    ret List.559;
-
-procedure List.49 (List.390, List.391):
-    let List.608 : U64 = StructAtIndex 0 List.391;
-    let List.609 : U64 = 0i64;
-    let List.606 : Int1 = CallByName Bool.11 List.608 List.609;
-    if List.606 then
-        dec List.390;
-        let List.607 : List U8 = Array [];
-        ret List.607;
-    else
-        let List.603 : U64 = StructAtIndex 1 List.391;
-        let List.604 : U64 = StructAtIndex 0 List.391;
-        let List.602 : List U8 = CallByName List.72 List.390 List.603 List.604;
-        ret List.602;
-
-procedure List.52 (List.405, List.406):
-    let List.407 : U64 = CallByName List.6 List.405;
-    joinpoint List.614 List.408:
-        let List.612 : U64 = 0i64;
-        let List.611 : {U64, U64} = Struct {List.408, List.612};
-        inc List.405;
-        let List.409 : List U8 = CallByName List.49 List.405 List.611;
-        let List.610 : U64 = CallByName Num.75 List.407 List.408;
-        let List.601 : {U64, U64} = Struct {List.610, List.408};
-        let List.410 : List U8 = CallByName List.49 List.405 List.601;
-        let List.600 : {List U8, List U8} = Struct {List.409, List.410};
-        ret List.600;
-    in
-    let List.615 : Int1 = CallByName Num.24 List.407 List.406;
-    if List.615 then
-        jump List.614 List.406;
-    else
-        jump List.614 List.407;
-
-procedure List.6 (#Attr.2):
-    let List.586 : U64 = lowlevel ListLen #Attr.2;
-    ret List.586;
-
-procedure List.6 (#Attr.2):
-    let List.588 : U64 = lowlevel ListLen #Attr.2;
-    ret List.588;
-
-procedure List.66 (#Attr.2, #Attr.3):
-    let List.572 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
     ret List.572;
 
-procedure List.66 (#Attr.2, #Attr.3):
+procedure List.18 (List.147, List.148, List.149):
-    let List.584 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.585 : U64 = 0i64;
+    let List.586 : U64 = CallByName List.6 List.147;
+    let List.584 : List U8 = CallByName List.87 List.147 List.148 List.149 List.585 List.586;
     ret List.584;
 
+procedure List.26 (List.174, List.175, List.176):
+    let List.626 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.98 List.174 List.175 List.176;
+    let List.629 : U8 = 1i64;
+    let List.630 : U8 = GetTagId List.626;
+    let List.631 : Int1 = lowlevel Eq List.629 List.630;
+    if List.631 then
+        let List.177 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.626;
+        ret List.177;
+    else
+        let List.178 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.626;
+        ret List.178;
+
+procedure List.4 (List.118, List.119):
+    let List.571 : U64 = 1i64;
+    let List.570 : List U8 = CallByName List.70 List.118 List.571;
+    let List.569 : List U8 = CallByName List.71 List.570 List.119;
+    ret List.569;
+
+procedure List.49 (List.392, List.393):
+    let List.618 : U64 = StructAtIndex 0 List.393;
+    let List.619 : U64 = 0i64;
+    let List.616 : Int1 = CallByName Bool.11 List.618 List.619;
+    if List.616 then
+        dec List.392;
+        let List.617 : List U8 = Array [];
+        ret List.617;
+    else
+        let List.613 : U64 = StructAtIndex 1 List.393;
+        let List.614 : U64 = StructAtIndex 0 List.393;
+        let List.612 : List U8 = CallByName List.72 List.392 List.613 List.614;
+        ret List.612;
+
+procedure List.52 (List.407, List.408):
+    let List.409 : U64 = CallByName List.6 List.407;
+    joinpoint List.624 List.410:
+        let List.622 : U64 = 0i64;
+        let List.621 : {U64, U64} = Struct {List.410, List.622};
+        inc List.407;
+        let List.411 : List U8 = CallByName List.49 List.407 List.621;
+        let List.620 : U64 = CallByName Num.75 List.409 List.410;
+        let List.611 : {U64, U64} = Struct {List.620, List.410};
+        let List.412 : List U8 = CallByName List.49 List.407 List.611;
+        let List.610 : {List U8, List U8} = Struct {List.411, List.412};
+        ret List.610;
+    in
+    let List.625 : Int1 = CallByName Num.24 List.409 List.408;
+    if List.625 then
+        jump List.624 List.408;
+    else
+        jump List.624 List.409;
+
+procedure List.6 (#Attr.2):
+    let List.596 : U64 = lowlevel ListLen #Attr.2;
+    ret List.596;
+
+procedure List.6 (#Attr.2):
+    let List.598 : U64 = lowlevel ListLen #Attr.2;
+    ret List.598;
+
+procedure List.66 (#Attr.2, #Attr.3):
+    let List.582 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.582;
+
+procedure List.66 (#Attr.2, #Attr.3):
+    let List.594 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.594;
+
 procedure List.68 (#Attr.2):
-    let List.599 : List U8 = lowlevel ListWithCapacity #Attr.2;
+    let List.609 : List U8 = lowlevel ListWithCapacity #Attr.2;
-    ret List.599;
+    ret List.609;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.540 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    let List.550 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.540;
+    ret List.550;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.538 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    let List.548 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.538;
+    ret List.548;
 
 procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
-    let List.605 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
+    let List.615 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
-    ret List.605;
+    ret List.615;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.597 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    let List.607 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.597;
+    ret List.607;
 
 procedure List.80 (#Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17, #Derived_gen.18):
-    joinpoint List.625 List.453 List.454 List.455 List.456 List.457:
+    joinpoint List.635 List.463 List.464 List.465 List.466 List.467:
-        let List.627 : Int1 = CallByName Num.22 List.456 List.457;
+        let List.637 : Int1 = CallByName Num.22 List.466 List.467;
-        if List.627 then
+        if List.637 then
-            let List.636 : U8 = CallByName List.66 List.453 List.456;
+            let List.646 : U8 = CallByName List.66 List.463 List.466;
-            let List.628 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.454 List.636;
+            let List.638 : [C {U64, Int1}, C {U64, Int1}] = CallByName TotallyNotJson.189 List.464 List.646;
-            let List.633 : U8 = 1i64;
+            let List.643 : U8 = 1i64;
-            let List.634 : U8 = GetTagId List.628;
+            let List.644 : U8 = GetTagId List.638;
-            let List.635 : Int1 = lowlevel Eq List.633 List.634;
+            let List.645 : Int1 = lowlevel Eq List.643 List.644;
-            if List.635 then
+            if List.645 then
-                let List.458 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.628;
+                let List.468 : {U64, Int1} = UnionAtIndex (Id 1) (Index 0) List.638;
-                let List.631 : U64 = 1i64;
+                let List.641 : U64 = 1i64;
-                let List.630 : U64 = CallByName Num.51 List.456 List.631;
+                let List.640 : U64 = CallByName Num.51 List.466 List.641;
-                jump List.625 List.453 List.458 List.455 List.630 List.457;
+                jump List.635 List.463 List.468 List.465 List.640 List.467;
             else
-                dec List.453;
+                dec List.463;
-                let List.459 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.628;
+                let List.469 : {U64, Int1} = UnionAtIndex (Id 0) (Index 0) List.638;
-                let List.632 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.459;
+                let List.642 : [C {U64, Int1}, C {U64, Int1}] = TagId(0) List.469;
-                ret List.632;
+                ret List.642;
         else
-            dec List.453;
+            dec List.463;
-            let List.626 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.454;
+            let List.636 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.464;
-            ret List.626;
+            ret List.636;
     in
-    jump List.625 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18;
+    jump List.635 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18;
 
-procedure List.86 (#Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_gen.23):
+procedure List.87 (#Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_gen.23):
-    joinpoint List.565 List.148 List.149 List.150 List.151 List.152:
+    joinpoint List.587 List.150 List.151 List.152 List.153 List.154:
-        let List.567 : Int1 = CallByName Num.22 List.151 List.152;
+        let List.589 : Int1 = CallByName Num.22 List.153 List.154;
-        if List.567 then
+        if List.589 then
-            let List.571 : Str = CallByName List.66 List.148 List.151;
+            let List.593 : U8 = CallByName List.66 List.150 List.153;
-            inc List.571;
+            let List.155 : List U8 = CallByName TotallyNotJson.215 List.151 List.593;
-            let List.153 : {List U8, U64} = CallByName TotallyNotJson.267 List.149 List.571 List.150;
+            let List.592 : U64 = 1i64;
-            let List.570 : U64 = 1i64;
+            let List.591 : U64 = CallByName Num.51 List.153 List.592;
-            let List.569 : U64 = CallByName Num.51 List.151 List.570;
+            jump List.587 List.150 List.155 List.152 List.591 List.154;
-            jump List.565 List.148 List.153 List.150 List.569 List.152;
         else
-            dec List.148;
+            dec List.150;
-            ret List.149;
+            ret List.151;
     in
-    jump List.565 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23;
+    jump List.587 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23;
 
-procedure List.86 (#Derived_gen.27, #Derived_gen.28, #Derived_gen.29, #Derived_gen.30, #Derived_gen.31):
+procedure List.87 (#Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_gen.27, #Derived_gen.28):
-    joinpoint List.577 List.148 List.149 List.150 List.151 List.152:
+    joinpoint List.575 List.150 List.151 List.152 List.153 List.154:
-        let List.579 : Int1 = CallByName Num.22 List.151 List.152;
+        let List.577 : Int1 = CallByName Num.22 List.153 List.154;
-        if List.579 then
+        if List.577 then
-            let List.583 : U8 = CallByName List.66 List.148 List.151;
+            let List.581 : Str = CallByName List.66 List.150 List.153;
-            let List.153 : List U8 = CallByName TotallyNotJson.215 List.149 List.583;
+            inc List.581;
-            let List.582 : U64 = 1i64;
+            let List.155 : {List U8, U64} = CallByName TotallyNotJson.267 List.151 List.581 List.152;
-            let List.581 : U64 = CallByName Num.51 List.151 List.582;
+            let List.580 : U64 = 1i64;
-            jump List.577 List.148 List.153 List.150 List.581 List.152;
+            let List.579 : U64 = CallByName Num.51 List.153 List.580;
+            jump List.575 List.150 List.155 List.152 List.579 List.154;
         else
-            dec List.148;
+            dec List.150;
-            ret List.149;
+            ret List.151;
     in
-    jump List.577 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30 #Derived_gen.31;
+    jump List.575 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28;
 
-procedure List.96 (List.450, List.451, List.452):
+procedure List.98 (List.460, List.461, List.462):
-    let List.623 : U64 = 0i64;
+    let List.633 : U64 = 0i64;
-    let List.624 : U64 = CallByName List.6 List.450;
+    let List.634 : U64 = CallByName List.6 List.460;
-    let List.622 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.450 List.451 List.452 List.623 List.624;
+    let List.632 : [C {U64, Int1}, C {U64, Int1}] = CallByName List.80 List.460 List.461 List.462 List.633 List.634;
-    ret List.622;
+    ret List.632;
 
 procedure Num.127 (#Attr.2):
     let Num.298 : U8 = lowlevel NumIntCast #Attr.2;
@@ -246,30 +246,30 @@ procedure Num.94 (#Attr.2, #Attr.3):
     ret Num.303;
 
 procedure Str.12 (#Attr.2):
-    let Str.300 : List U8 = lowlevel StrToUtf8 #Attr.2;
+    let Str.303 : List U8 = lowlevel StrToUtf8 #Attr.2;
-    ret Str.300;
+    ret Str.303;
 
 procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
-    let Str.298 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
+    let Str.301 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
-    ret Str.298;
+    ret Str.301;
 
-procedure Str.9 (Str.79):
+procedure Str.9 (Str.80):
-    let Str.296 : U64 = 0i64;
+    let Str.299 : U64 = 0i64;
-    let Str.297 : U64 = CallByName List.6 Str.79;
+    let Str.300 : U64 = CallByName List.6 Str.80;
-    let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.296 Str.297;
+    let Str.81 : {U64, Str, Int1, U8} = CallByName Str.48 Str.80 Str.299 Str.300;
-    let Str.293 : Int1 = StructAtIndex 2 Str.80;
+    let Str.296 : Int1 = StructAtIndex 2 Str.81;
-    if Str.293 then
+    if Str.296 then
-        let Str.295 : Str = StructAtIndex 1 Str.80;
+        let Str.298 : Str = StructAtIndex 1 Str.81;
-        let Str.294 : [C {U64, U8}, C Str] = TagId(1) Str.295;
+        let Str.297 : [C {U64, U8}, C Str] = TagId(1) Str.298;
-        ret Str.294;
+        ret Str.297;
     else
-        let Str.291 : U8 = StructAtIndex 3 Str.80;
+        let Str.294 : U8 = StructAtIndex 3 Str.81;
-        let Str.292 : U64 = StructAtIndex 0 Str.80;
+        let Str.295 : U64 = StructAtIndex 0 Str.81;
-        let #Derived_gen.35 : Str = StructAtIndex 1 Str.80;
+        let #Derived_gen.35 : Str = StructAtIndex 1 Str.81;
         dec #Derived_gen.35;
-        let Str.290 : {U64, U8} = Struct {Str.292, Str.291};
+        let Str.293 : {U64, U8} = Struct {Str.295, Str.294};
-        let Str.289 : [C {U64, U8}, C Str] = TagId(0) Str.290;
+        let Str.292 : [C {U64, U8}, C Str] = TagId(0) Str.293;
-        ret Str.289;
+        ret Str.292;
 
 procedure TotallyNotJson.182 (TotallyNotJson.183, TotallyNotJson.1216, TotallyNotJson.181):
     let TotallyNotJson.1219 : List U8 = CallByName TotallyNotJson.26 TotallyNotJson.181;

crates/compiler/test_mono/generated/ir_int_add.txt

@@ -1,6 +1,6 @@
 procedure List.6 (#Attr.2):
-    let List.535 : U64 = lowlevel ListLen #Attr.2;
+    let List.545 : U64 = lowlevel ListLen #Attr.2;
-    ret List.535;
+    ret List.545;
 
 procedure Num.19 (#Attr.2, #Attr.3):
     let Num.293 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/issue_2583_specialize_errors_behind_unified_branches.txt

@@ -6,69 +6,69 @@ procedure Bool.2 ():
     let Bool.23 : Int1 = true;
     ret Bool.23;
 
-procedure List.2 (List.100, List.101):
+procedure List.2 (List.102, List.103):
-    let List.549 : U64 = CallByName List.6 List.100;
+    let List.559 : U64 = CallByName List.6 List.102;
-    let List.545 : Int1 = CallByName Num.22 List.101 List.549;
+    let List.555 : Int1 = CallByName Num.22 List.103 List.559;
-    if List.545 then
+    if List.555 then
-        let List.547 : I64 = CallByName List.66 List.100 List.101;
+        let List.557 : I64 = CallByName List.66 List.102 List.103;
-        dec List.100;
+        dec List.102;
-        let List.546 : [C {}, C I64] = TagId(1) List.547;
+        let List.556 : [C {}, C I64] = TagId(1) List.557;
-        ret List.546;
+        ret List.556;
     else
-        dec List.100;
+        dec List.102;
-        let List.544 : {} = Struct {};
+        let List.554 : {} = Struct {};
-        let List.543 : [C {}, C I64] = TagId(0) List.544;
+        let List.553 : [C {}, C I64] = TagId(0) List.554;
-        ret List.543;
+        ret List.553;
 
 procedure List.6 (#Attr.2):
-    let List.550 : U64 = lowlevel ListLen #Attr.2;
+    let List.560 : U64 = lowlevel ListLen #Attr.2;
-    ret List.550;
+    ret List.560;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.548 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.558 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.548;
+    ret List.558;
 
-procedure List.9 (List.306):
+procedure List.9 (List.308):
-    let List.542 : U64 = 0i64;
+    let List.552 : U64 = 0i64;
-    let List.535 : [C {}, C I64] = CallByName List.2 List.306 List.542;
+    let List.545 : [C {}, C I64] = CallByName List.2 List.308 List.552;
-    let List.539 : U8 = 1i64;
+    let List.549 : U8 = 1i64;
-    let List.540 : U8 = GetTagId List.535;
+    let List.550 : U8 = GetTagId List.545;
-    let List.541 : Int1 = lowlevel Eq List.539 List.540;
+    let List.551 : Int1 = lowlevel Eq List.549 List.550;
-    if List.541 then
+    if List.551 then
-        let List.307 : I64 = UnionAtIndex (Id 1) (Index 0) List.535;
+        let List.309 : I64 = UnionAtIndex (Id 1) (Index 0) List.545;
-        let List.536 : [C Int1, C I64] = TagId(1) List.307;
+        let List.546 : [C Int1, C I64] = TagId(1) List.309;
-        ret List.536;
+        ret List.546;
     else
-        let List.538 : Int1 = true;
+        let List.548 : Int1 = true;
-        let List.537 : [C Int1, C I64] = TagId(0) List.538;
+        let List.547 : [C Int1, C I64] = TagId(0) List.548;
-        ret List.537;
+        ret List.547;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.291 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
     ret Num.291;
 
-procedure Str.27 (Str.99):
+procedure Str.27 (Str.100):
-    let Str.289 : [C Int1, C I64] = CallByName Str.72 Str.99;
+    let Str.292 : [C Int1, C I64] = CallByName Str.73 Str.100;
-    ret Str.289;
+    ret Str.292;
 
 procedure Str.47 (#Attr.2):
-    let Str.297 : {I64, U8} = lowlevel StrToNum #Attr.2;
+    let Str.300 : {I64, U8} = lowlevel StrToNum #Attr.2;
-    ret Str.297;
+    ret Str.300;
 
-procedure Str.72 (Str.235):
+procedure Str.73 (Str.236):
-    let Str.236 : {I64, U8} = CallByName Str.47 Str.235;
+    let Str.237 : {I64, U8} = CallByName Str.47 Str.236;
-    dec Str.235;
+    dec Str.236;
-    let Str.295 : U8 = StructAtIndex 1 Str.236;
+    let Str.298 : U8 = StructAtIndex 1 Str.237;
-    let Str.296 : U8 = 0i64;
+    let Str.299 : U8 = 0i64;
-    let Str.292 : Int1 = CallByName Bool.11 Str.295 Str.296;
+    let Str.295 : Int1 = CallByName Bool.11 Str.298 Str.299;
-    if Str.292 then
+    if Str.295 then
-        let Str.294 : I64 = StructAtIndex 0 Str.236;
+        let Str.297 : I64 = StructAtIndex 0 Str.237;
-        let Str.293 : [C Int1, C I64] = TagId(1) Str.294;
+        let Str.296 : [C Int1, C I64] = TagId(1) Str.297;
-        ret Str.293;
+        ret Str.296;
     else
-        let Str.291 : Int1 = false;
+        let Str.294 : Int1 = false;
-        let Str.290 : [C Int1, C I64] = TagId(0) Str.291;
+        let Str.293 : [C Int1, C I64] = TagId(0) Str.294;
-        ret Str.290;
+        ret Str.293;
 
 procedure Test.0 ():
     let Test.3 : Int1 = CallByName Bool.2;

crates/compiler/test_mono/generated/issue_4749.txt

@@ -64,136 +64,136 @@ procedure Decode.27 (Decode.107, Decode.108):
         let Decode.123 : [C [C List U8, C ], C Str] = TagId(0) Decode.124;
         ret Decode.123;
 
-procedure List.1 (List.99):
+procedure List.1 (List.101):
-    let List.602 : U64 = CallByName List.6 List.99;
+    let List.612 : U64 = CallByName List.6 List.101;
-    dec List.99;
+    dec List.101;
-    let List.603 : U64 = 0i64;
+    let List.613 : U64 = 0i64;
-    let List.601 : Int1 = CallByName Bool.11 List.602 List.603;
+    let List.611 : Int1 = CallByName Bool.11 List.612 List.613;
-    ret List.601;
+    ret List.611;
 
-procedure List.2 (List.100, List.101):
+procedure List.2 (List.102, List.103):
-    let List.585 : U64 = CallByName List.6 List.100;
+    let List.595 : U64 = CallByName List.6 List.102;
-    let List.582 : Int1 = CallByName Num.22 List.101 List.585;
+    let List.592 : Int1 = CallByName Num.22 List.103 List.595;
-    if List.582 then
+    if List.592 then
-        let List.584 : U8 = CallByName List.66 List.100 List.101;
+        let List.594 : U8 = CallByName List.66 List.102 List.103;
-        dec List.100;
+        dec List.102;
-        let List.583 : [C {}, C U8] = TagId(1) List.584;
+        let List.593 : [C {}, C U8] = TagId(1) List.594;
-        ret List.583;
+        ret List.593;
     else
-        dec List.100;
+        dec List.102;
-        let List.581 : {} = Struct {};
+        let List.591 : {} = Struct {};
-        let List.580 : [C {}, C U8] = TagId(0) List.581;
+        let List.590 : [C {}, C U8] = TagId(0) List.591;
-        ret List.580;
+        ret List.590;
 
-procedure List.26 (List.172, List.173, List.174):
+procedure List.26 (List.174, List.175, List.176):
-    let List.604 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName List.96 List.172 List.173 List.174;
+    let List.614 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName List.98 List.174 List.175 List.176;
-    let List.607 : U8 = 1i64;
+    let List.617 : U8 = 1i64;
-    let List.608 : U8 = GetTagId List.604;
+    let List.618 : U8 = GetTagId List.614;
-    let List.609 : Int1 = lowlevel Eq List.607 List.608;
+    let List.619 : Int1 = lowlevel Eq List.617 List.618;
-    if List.609 then
+    if List.619 then
-        let List.175 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 1) (Index 0) List.604;
+        let List.177 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 1) (Index 0) List.614;
-        ret List.175;
+        ret List.177;
     else
-        let List.176 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 0) (Index 0) List.604;
+        let List.178 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 0) (Index 0) List.614;
-        ret List.176;
+        ret List.178;
 
-procedure List.29 (List.317, List.318):
+procedure List.29 (List.319, List.320):
-    let List.559 : U64 = CallByName List.6 List.317;
+    let List.569 : U64 = CallByName List.6 List.319;
-    let List.319 : U64 = CallByName Num.77 List.559 List.318;
+    let List.321 : U64 = CallByName Num.77 List.569 List.320;
-    let List.558 : List U8 = CallByName List.43 List.317 List.319;
+    let List.568 : List U8 = CallByName List.43 List.319 List.321;
-    ret List.558;
+    ret List.568;
 
 procedure List.31 (#Attr.2, #Attr.3):
-    let List.572 : List U8 = lowlevel ListDropAt #Attr.2 #Attr.3;
+    let List.582 : List U8 = lowlevel ListDropAt #Attr.2 #Attr.3;
-    ret List.572;
+    ret List.582;
 
-procedure List.38 (List.311):
+procedure List.38 (List.313):
-    let List.571 : U64 = 0i64;
+    let List.581 : U64 = 0i64;
-    let List.570 : List U8 = CallByName List.31 List.311 List.571;
+    let List.580 : List U8 = CallByName List.31 List.313 List.581;
-    ret List.570;
+    ret List.580;
 
-procedure List.4 (List.116, List.117):
+procedure List.4 (List.118, List.119):
-    let List.569 : U64 = 1i64;
+    let List.579 : U64 = 1i64;
-    let List.568 : List U8 = CallByName List.70 List.116 List.569;
+    let List.578 : List U8 = CallByName List.70 List.118 List.579;
-    let List.567 : List U8 = CallByName List.71 List.568 List.117;
+    let List.577 : List U8 = CallByName List.71 List.578 List.119;
-    ret List.567;
+    ret List.577;
 
-procedure List.43 (List.315, List.316):
+procedure List.43 (List.317, List.318):
-    let List.551 : U64 = CallByName List.6 List.315;
+    let List.561 : U64 = CallByName List.6 List.317;
-    let List.550 : U64 = CallByName Num.77 List.551 List.316;
+    let List.560 : U64 = CallByName Num.77 List.561 List.318;
-    let List.541 : {U64, U64} = Struct {List.316, List.550};
+    let List.551 : {U64, U64} = Struct {List.318, List.560};
-    let List.540 : List U8 = CallByName List.49 List.315 List.541;
+    let List.550 : List U8 = CallByName List.49 List.317 List.551;
-    ret List.540;
+    ret List.550;
 
-procedure List.49 (List.390, List.391):
+procedure List.49 (List.392, List.393):
-    let List.598 : U64 = StructAtIndex 0 List.391;
+    let List.608 : U64 = StructAtIndex 0 List.393;
-    let List.599 : U64 = 0i64;
+    let List.609 : U64 = 0i64;
-    let List.596 : Int1 = CallByName Bool.11 List.598 List.599;
+    let List.606 : Int1 = CallByName Bool.11 List.608 List.609;
-    if List.596 then
+    if List.606 then
-        dec List.390;
+        dec List.392;
-        let List.597 : List U8 = Array [];
+        let List.607 : List U8 = Array [];
-        ret List.597;
+        ret List.607;
     else
-        let List.594 : U64 = StructAtIndex 1 List.391;
+        let List.604 : U64 = StructAtIndex 1 List.393;
-        let List.595 : U64 = StructAtIndex 0 List.391;
+        let List.605 : U64 = StructAtIndex 0 List.393;
-        let List.593 : List U8 = CallByName List.72 List.390 List.594 List.595;
+        let List.603 : List U8 = CallByName List.72 List.392 List.604 List.605;
-        ret List.593;
+        ret List.603;
 
 procedure List.6 (#Attr.2):
-    let List.625 : U64 = lowlevel ListLen #Attr.2;
+    let List.635 : U64 = lowlevel ListLen #Attr.2;
-    ret List.625;
+    ret List.635;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.578 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.588 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.578;
+    ret List.588;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.566 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    let List.576 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.566;
+    ret List.576;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.564 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    let List.574 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.564;
+    ret List.574;
 
 procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
-    let List.545 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
+    let List.555 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
-    ret List.545;
+    ret List.555;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.561 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    let List.571 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.561;
+    ret List.571;
 
 procedure List.80 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
-    joinpoint List.613 List.453 List.454 List.455 List.456 List.457:
+    joinpoint List.623 List.463 List.464 List.465 List.466 List.467:
-        let List.615 : Int1 = CallByName Num.22 List.456 List.457;
+        let List.625 : Int1 = CallByName Num.22 List.466 List.467;
-        if List.615 then
+        if List.625 then
-            let List.624 : U8 = CallByName List.66 List.453 List.456;
+            let List.634 : U8 = CallByName List.66 List.463 List.466;
-            let List.616 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName TotallyNotJson.62 List.454 List.624;
+            let List.626 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName TotallyNotJson.62 List.464 List.634;
-            let List.621 : U8 = 1i64;
+            let List.631 : U8 = 1i64;
-            let List.622 : U8 = GetTagId List.616;
+            let List.632 : U8 = GetTagId List.626;
-            let List.623 : Int1 = lowlevel Eq List.621 List.622;
+            let List.633 : Int1 = lowlevel Eq List.631 List.632;
-            if List.623 then
+            if List.633 then
-                let List.458 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 1) (Index 0) List.616;
+                let List.468 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 1) (Index 0) List.626;
-                let List.619 : U64 = 1i64;
+                let List.629 : U64 = 1i64;
-                let List.618 : U64 = CallByName Num.51 List.456 List.619;
+                let List.628 : U64 = CallByName Num.51 List.466 List.629;
-                jump List.613 List.453 List.458 List.455 List.618 List.457;
+                jump List.623 List.463 List.468 List.465 List.628 List.467;
             else
-                dec List.453;
+                dec List.463;
-                let List.459 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 0) (Index 0) List.616;
+                let List.469 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 0) (Index 0) List.626;
-                let List.620 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = TagId(0) List.459;
+                let List.630 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = TagId(0) List.469;
-                ret List.620;
+                ret List.630;
         else
-            dec List.453;
+            dec List.463;
-            let List.614 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = TagId(1) List.454;
+            let List.624 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = TagId(1) List.464;
-            ret List.614;
+            ret List.624;
     in
-    jump List.613 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
+    jump List.623 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
 
-procedure List.96 (List.450, List.451, List.452):
+procedure List.98 (List.460, List.461, List.462):
-    let List.611 : U64 = 0i64;
+    let List.621 : U64 = 0i64;
-    let List.612 : U64 = CallByName List.6 List.450;
+    let List.622 : U64 = CallByName List.6 List.460;
-    let List.610 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName List.80 List.450 List.451 List.452 List.611 List.612;
+    let List.620 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName List.80 List.460 List.461 List.462 List.621 List.622;
-    ret List.610;
+    ret List.620;
 
 procedure Num.19 (#Attr.2, #Attr.3):
     let Num.294 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
@@ -236,26 +236,26 @@ procedure Num.77 (#Attr.2, #Attr.3):
     ret Num.324;
 
 procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
-    let Str.298 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
+    let Str.301 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
-    ret Str.298;
+    ret Str.301;
 
-procedure Str.9 (Str.79):
+procedure Str.9 (Str.80):
-    let Str.296 : U64 = 0i64;
+    let Str.299 : U64 = 0i64;
-    let Str.297 : U64 = CallByName List.6 Str.79;
+    let Str.300 : U64 = CallByName List.6 Str.80;
-    let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.296 Str.297;
+    let Str.81 : {U64, Str, Int1, U8} = CallByName Str.48 Str.80 Str.299 Str.300;
-    let Str.293 : Int1 = StructAtIndex 2 Str.80;
+    let Str.296 : Int1 = StructAtIndex 2 Str.81;
-    if Str.293 then
+    if Str.296 then
-        let Str.295 : Str = StructAtIndex 1 Str.80;
+        let Str.298 : Str = StructAtIndex 1 Str.81;
-        let Str.294 : [C {U64, U8}, C Str] = TagId(1) Str.295;
+        let Str.297 : [C {U64, U8}, C Str] = TagId(1) Str.298;
-        ret Str.294;
+        ret Str.297;
     else
-        let Str.291 : U8 = StructAtIndex 3 Str.80;
+        let Str.294 : U8 = StructAtIndex 3 Str.81;
-        let Str.292 : U64 = StructAtIndex 0 Str.80;
+        let Str.295 : U64 = StructAtIndex 0 Str.81;
-        let #Derived_gen.6 : Str = StructAtIndex 1 Str.80;
+        let #Derived_gen.6 : Str = StructAtIndex 1 Str.81;
         dec #Derived_gen.6;
-        let Str.290 : {U64, U8} = Struct {Str.292, Str.291};
+        let Str.293 : {U64, U8} = Struct {Str.295, Str.294};
-        let Str.289 : [C {U64, U8}, C Str] = TagId(0) Str.290;
+        let Str.292 : [C {U64, U8}, C Str] = TagId(0) Str.293;
-        ret Str.289;
+        ret Str.292;
 
 procedure Test.3 ():
     let Test.0 : List U8 = Array [82i64, 111i64, 99i64];

crates/compiler/test_mono/generated/issue_4770.txt

@@ -6,80 +6,80 @@ procedure Bool.2 ():
     let Bool.24 : Int1 = true;
     ret Bool.24;
 
-procedure List.207 (List.537, List.208, List.206):
+procedure List.209 (List.547, List.210, List.208):
-    let List.567 : Int1 = CallByName Test.1 List.208;
+    let List.577 : Int1 = CallByName Test.1 List.210;
-    if List.567 then
+    if List.577 then
-        let List.569 : {} = Struct {};
+        let List.579 : {} = Struct {};
-        let List.568 : [C {}, C {}] = TagId(1) List.569;
+        let List.578 : [C {}, C {}] = TagId(1) List.579;
-        ret List.568;
+        ret List.578;
     else
-        let List.566 : {} = Struct {};
+        let List.576 : {} = Struct {};
-        let List.565 : [C {}, C {}] = TagId(0) List.566;
+        let List.575 : [C {}, C {}] = TagId(0) List.576;
-        ret List.565;
+        ret List.575;
 
 procedure List.23 (#Attr.2, #Attr.3, #Attr.4):
-    let List.570 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = lowlevel ListMap2 { xs: `#Attr.#arg1`, ys: `#Attr.#arg2` } #Attr.2 #Attr.3 Test.15 #Attr.4;
+    let List.580 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = lowlevel ListMap2 { xs: `#Attr.#arg1`, ys: `#Attr.#arg2` } #Attr.2 #Attr.3 Test.15 #Attr.4;
     decref #Attr.3;
     decref #Attr.2;
-    ret List.570;
+    ret List.580;
 
-procedure List.56 (List.205, List.206):
+procedure List.56 (List.207, List.208):
-    let List.546 : {} = Struct {};
+    let List.556 : {} = Struct {};
-    let List.538 : [C {}, C {}] = CallByName List.96 List.205 List.546 List.206;
+    let List.548 : [C {}, C {}] = CallByName List.98 List.207 List.556 List.208;
-    let List.543 : U8 = 1i64;
+    let List.553 : U8 = 1i64;
-    let List.544 : U8 = GetTagId List.538;
+    let List.554 : U8 = GetTagId List.548;
-    let List.545 : Int1 = lowlevel Eq List.543 List.544;
+    let List.555 : Int1 = lowlevel Eq List.553 List.554;
-    if List.545 then
+    if List.555 then
-        let List.539 : Int1 = CallByName Bool.2;
+        let List.549 : Int1 = CallByName Bool.2;
-        ret List.539;
+        ret List.549;
     else
-        let List.540 : Int1 = CallByName Bool.1;
+        let List.550 : Int1 = CallByName Bool.1;
-        ret List.540;
+        ret List.550;
 
 procedure List.6 (#Attr.2):
-    let List.536 : U64 = lowlevel ListLen #Attr.2;
+    let List.546 : U64 = lowlevel ListLen #Attr.2;
-    ret List.536;
+    ret List.546;
 
 procedure List.6 (#Attr.2):
-    let List.564 : U64 = lowlevel ListLen #Attr.2;
+    let List.574 : U64 = lowlevel ListLen #Attr.2;
-    ret List.564;
+    ret List.574;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.563 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.573 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.563;
+    ret List.573;
 
 procedure List.80 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4, #Derived_gen.5):
-    joinpoint List.551 List.453 List.454 List.455 List.456 List.457:
+    joinpoint List.561 List.463 List.464 List.465 List.466 List.467:
-        let List.553 : Int1 = CallByName Num.22 List.456 List.457;
+        let List.563 : Int1 = CallByName Num.22 List.466 List.467;
-        if List.553 then
+        if List.563 then
-            let List.562 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.66 List.453 List.456;
+            let List.572 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.66 List.463 List.466;
-            inc List.562;
+            inc List.572;
-            let List.554 : [C {}, C {}] = CallByName List.207 List.454 List.562 List.455;
+            let List.564 : [C {}, C {}] = CallByName List.209 List.464 List.572 List.465;
-            let List.559 : U8 = 1i64;
+            let List.569 : U8 = 1i64;
-            let List.560 : U8 = GetTagId List.554;
+            let List.570 : U8 = GetTagId List.564;
-            let List.561 : Int1 = lowlevel Eq List.559 List.560;
+            let List.571 : Int1 = lowlevel Eq List.569 List.570;
-            if List.561 then
+            if List.571 then
-                let List.458 : {} = UnionAtIndex (Id 1) (Index 0) List.554;
+                let List.468 : {} = UnionAtIndex (Id 1) (Index 0) List.564;
-                let List.557 : U64 = 1i64;
+                let List.567 : U64 = 1i64;
-                let List.556 : U64 = CallByName Num.51 List.456 List.557;
+                let List.566 : U64 = CallByName Num.51 List.466 List.567;
-                jump List.551 List.453 List.458 List.455 List.556 List.457;
+                jump List.561 List.463 List.468 List.465 List.566 List.467;
             else
-                dec List.453;
+                dec List.463;
-                let List.459 : {} = UnionAtIndex (Id 0) (Index 0) List.554;
+                let List.469 : {} = UnionAtIndex (Id 0) (Index 0) List.564;
-                let List.558 : [C {}, C {}] = TagId(0) List.459;
+                let List.568 : [C {}, C {}] = TagId(0) List.469;
-                ret List.558;
+                ret List.568;
         else
-            dec List.453;
+            dec List.463;
-            let List.552 : [C {}, C {}] = TagId(1) List.454;
+            let List.562 : [C {}, C {}] = TagId(1) List.464;
-            ret List.552;
+            ret List.562;
     in
-    jump List.551 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5;
+    jump List.561 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5;
 
-procedure List.96 (List.450, List.451, List.452):
+procedure List.98 (List.460, List.461, List.462):
-    let List.549 : U64 = 0i64;
+    let List.559 : U64 = 0i64;
-    let List.550 : U64 = CallByName List.6 List.450;
+    let List.560 : U64 = CallByName List.6 List.460;
-    let List.548 : [C {}, C {}] = CallByName List.80 List.450 List.451 List.452 List.549 List.550;
+    let List.558 : [C {}, C {}] = CallByName List.80 List.460 List.461 List.462 List.559 List.560;
-    ret List.548;
+    ret List.558;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.291 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/issue_4772_weakened_monomorphic_destructure.txt

@@ -38,136 +38,136 @@ procedure Decode.26 (Decode.105, Decode.106):
     let Decode.122 : {List U8, [C {}, C Str]} = CallByName Decode.25 Decode.105 Decode.123 Decode.106;
     ret Decode.122;
 
-procedure List.1 (List.99):
+procedure List.1 (List.101):
-    let List.598 : U64 = CallByName List.6 List.99;
+    let List.608 : U64 = CallByName List.6 List.101;
-    dec List.99;
+    dec List.101;
-    let List.599 : U64 = 0i64;
+    let List.609 : U64 = 0i64;
-    let List.597 : Int1 = CallByName Bool.11 List.598 List.599;
+    let List.607 : Int1 = CallByName Bool.11 List.608 List.609;
-    ret List.597;
+    ret List.607;
 
-procedure List.2 (List.100, List.101):
+procedure List.2 (List.102, List.103):
-    let List.581 : U64 = CallByName List.6 List.100;
+    let List.591 : U64 = CallByName List.6 List.102;
-    let List.578 : Int1 = CallByName Num.22 List.101 List.581;
+    let List.588 : Int1 = CallByName Num.22 List.103 List.591;
-    if List.578 then
+    if List.588 then
-        let List.580 : U8 = CallByName List.66 List.100 List.101;
+        let List.590 : U8 = CallByName List.66 List.102 List.103;
-        dec List.100;
+        dec List.102;
-        let List.579 : [C {}, C U8] = TagId(1) List.580;
+        let List.589 : [C {}, C U8] = TagId(1) List.590;
-        ret List.579;
+        ret List.589;
     else
-        dec List.100;
+        dec List.102;
-        let List.577 : {} = Struct {};
+        let List.587 : {} = Struct {};
-        let List.576 : [C {}, C U8] = TagId(0) List.577;
+        let List.586 : [C {}, C U8] = TagId(0) List.587;
-        ret List.576;
+        ret List.586;
 
-procedure List.26 (List.172, List.173, List.174):
+procedure List.26 (List.174, List.175, List.176):
-    let List.600 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName List.96 List.172 List.173 List.174;
+    let List.610 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName List.98 List.174 List.175 List.176;
-    let List.603 : U8 = 1i64;
+    let List.613 : U8 = 1i64;
-    let List.604 : U8 = GetTagId List.600;
+    let List.614 : U8 = GetTagId List.610;
-    let List.605 : Int1 = lowlevel Eq List.603 List.604;
+    let List.615 : Int1 = lowlevel Eq List.613 List.614;
-    if List.605 then
+    if List.615 then
-        let List.175 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 1) (Index 0) List.600;
+        let List.177 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 1) (Index 0) List.610;
-        ret List.175;
+        ret List.177;
     else
-        let List.176 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 0) (Index 0) List.600;
+        let List.178 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 0) (Index 0) List.610;
-        ret List.176;
+        ret List.178;
 
-procedure List.29 (List.317, List.318):
+procedure List.29 (List.319, List.320):
-    let List.555 : U64 = CallByName List.6 List.317;
+    let List.565 : U64 = CallByName List.6 List.319;
-    let List.319 : U64 = CallByName Num.77 List.555 List.318;
+    let List.321 : U64 = CallByName Num.77 List.565 List.320;
-    let List.554 : List U8 = CallByName List.43 List.317 List.319;
+    let List.564 : List U8 = CallByName List.43 List.319 List.321;
-    ret List.554;
+    ret List.564;
 
 procedure List.31 (#Attr.2, #Attr.3):
-    let List.568 : List U8 = lowlevel ListDropAt #Attr.2 #Attr.3;
+    let List.578 : List U8 = lowlevel ListDropAt #Attr.2 #Attr.3;
-    ret List.568;
+    ret List.578;
 
-procedure List.38 (List.311):
+procedure List.38 (List.313):
-    let List.567 : U64 = 0i64;
+    let List.577 : U64 = 0i64;
-    let List.566 : List U8 = CallByName List.31 List.311 List.567;
+    let List.576 : List U8 = CallByName List.31 List.313 List.577;
-    ret List.566;
+    ret List.576;
 
-procedure List.4 (List.116, List.117):
+procedure List.4 (List.118, List.119):
-    let List.565 : U64 = 1i64;
+    let List.575 : U64 = 1i64;
-    let List.564 : List U8 = CallByName List.70 List.116 List.565;
+    let List.574 : List U8 = CallByName List.70 List.118 List.575;
-    let List.563 : List U8 = CallByName List.71 List.564 List.117;
+    let List.573 : List U8 = CallByName List.71 List.574 List.119;
-    ret List.563;
+    ret List.573;
 
-procedure List.43 (List.315, List.316):
+procedure List.43 (List.317, List.318):
-    let List.547 : U64 = CallByName List.6 List.315;
+    let List.557 : U64 = CallByName List.6 List.317;
-    let List.546 : U64 = CallByName Num.77 List.547 List.316;
+    let List.556 : U64 = CallByName Num.77 List.557 List.318;
-    let List.537 : {U64, U64} = Struct {List.316, List.546};
+    let List.547 : {U64, U64} = Struct {List.318, List.556};
-    let List.536 : List U8 = CallByName List.49 List.315 List.537;
+    let List.546 : List U8 = CallByName List.49 List.317 List.547;
-    ret List.536;
+    ret List.546;
 
-procedure List.49 (List.390, List.391):
+procedure List.49 (List.392, List.393):
-    let List.594 : U64 = StructAtIndex 0 List.391;
+    let List.604 : U64 = StructAtIndex 0 List.393;
-    let List.595 : U64 = 0i64;
+    let List.605 : U64 = 0i64;
-    let List.592 : Int1 = CallByName Bool.11 List.594 List.595;
+    let List.602 : Int1 = CallByName Bool.11 List.604 List.605;
-    if List.592 then
+    if List.602 then
-        dec List.390;
+        dec List.392;
-        let List.593 : List U8 = Array [];
+        let List.603 : List U8 = Array [];
-        ret List.593;
+        ret List.603;
     else
-        let List.590 : U64 = StructAtIndex 1 List.391;
+        let List.600 : U64 = StructAtIndex 1 List.393;
-        let List.591 : U64 = StructAtIndex 0 List.391;
+        let List.601 : U64 = StructAtIndex 0 List.393;
-        let List.589 : List U8 = CallByName List.72 List.390 List.590 List.591;
+        let List.599 : List U8 = CallByName List.72 List.392 List.600 List.601;
-        ret List.589;
+        ret List.599;
 
 procedure List.6 (#Attr.2):
-    let List.621 : U64 = lowlevel ListLen #Attr.2;
+    let List.631 : U64 = lowlevel ListLen #Attr.2;
-    ret List.621;
+    ret List.631;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.574 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.584 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.574;
+    ret List.584;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.562 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    let List.572 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.562;
+    ret List.572;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.560 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    let List.570 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.560;
+    ret List.570;
 
 procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
-    let List.541 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
+    let List.551 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
-    ret List.541;
+    ret List.551;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.557 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    let List.567 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.557;
+    ret List.567;
 
 procedure List.80 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
-    joinpoint List.609 List.453 List.454 List.455 List.456 List.457:
+    joinpoint List.619 List.463 List.464 List.465 List.466 List.467:
-        let List.611 : Int1 = CallByName Num.22 List.456 List.457;
+        let List.621 : Int1 = CallByName Num.22 List.466 List.467;
-        if List.611 then
+        if List.621 then
-            let List.620 : U8 = CallByName List.66 List.453 List.456;
+            let List.630 : U8 = CallByName List.66 List.463 List.466;
-            let List.612 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName TotallyNotJson.62 List.454 List.620;
+            let List.622 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName TotallyNotJson.62 List.464 List.630;
-            let List.617 : U8 = 1i64;
+            let List.627 : U8 = 1i64;
-            let List.618 : U8 = GetTagId List.612;
+            let List.628 : U8 = GetTagId List.622;
-            let List.619 : Int1 = lowlevel Eq List.617 List.618;
+            let List.629 : Int1 = lowlevel Eq List.627 List.628;
-            if List.619 then
+            if List.629 then
-                let List.458 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 1) (Index 0) List.612;
+                let List.468 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 1) (Index 0) List.622;
-                let List.615 : U64 = 1i64;
+                let List.625 : U64 = 1i64;
-                let List.614 : U64 = CallByName Num.51 List.456 List.615;
+                let List.624 : U64 = CallByName Num.51 List.466 List.625;
-                jump List.609 List.453 List.458 List.455 List.614 List.457;
+                jump List.619 List.463 List.468 List.465 List.624 List.467;
             else
-                dec List.453;
+                dec List.463;
-                let List.459 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 0) (Index 0) List.612;
+                let List.469 : [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64] = UnionAtIndex (Id 0) (Index 0) List.622;
-                let List.616 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = TagId(0) List.459;
+                let List.626 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = TagId(0) List.469;
-                ret List.616;
+                ret List.626;
         else
-            dec List.453;
+            dec List.463;
-            let List.610 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = TagId(1) List.454;
+            let List.620 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = TagId(1) List.464;
-            ret List.610;
+            ret List.620;
     in
-    jump List.609 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
+    jump List.619 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
 
-procedure List.96 (List.450, List.451, List.452):
+procedure List.98 (List.460, List.461, List.462):
-    let List.607 : U64 = 0i64;
+    let List.617 : U64 = 0i64;
-    let List.608 : U64 = CallByName List.6 List.450;
+    let List.618 : U64 = CallByName List.6 List.460;
-    let List.606 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName List.80 List.450 List.451 List.452 List.607 List.608;
+    let List.616 : [C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64], C [C U64, C U64, C U64, C , C , C U64, C U64, C U64, C U64]] = CallByName List.80 List.460 List.461 List.462 List.617 List.618;
-    ret List.606;
+    ret List.616;
 
 procedure Num.19 (#Attr.2, #Attr.3):
     let Num.294 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
@@ -210,53 +210,53 @@ procedure Num.77 (#Attr.2, #Attr.3):
     ret Num.324;
 
 procedure Str.12 (#Attr.2):
-    let Str.298 : List U8 = lowlevel StrToUtf8 #Attr.2;
+    let Str.301 : List U8 = lowlevel StrToUtf8 #Attr.2;
-    ret Str.298;
+    ret Str.301;
 
-procedure Str.27 (Str.99):
+procedure Str.27 (Str.100):
-    let Str.289 : [C {}, C I64] = CallByName Str.72 Str.99;
+    let Str.292 : [C {}, C I64] = CallByName Str.73 Str.100;
-    ret Str.289;
+    ret Str.292;
 
 procedure Str.47 (#Attr.2):
-    let Str.297 : {I64, U8} = lowlevel StrToNum #Attr.2;
+    let Str.300 : {I64, U8} = lowlevel StrToNum #Attr.2;
-    ret Str.297;
+    ret Str.300;
 
 procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
-    let Str.308 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
+    let Str.311 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
-    ret Str.308;
+    ret Str.311;
 
-procedure Str.72 (Str.235):
+procedure Str.73 (Str.236):
-    let Str.236 : {I64, U8} = CallByName Str.47 Str.235;
+    let Str.237 : {I64, U8} = CallByName Str.47 Str.236;
-    dec Str.235;
+    dec Str.236;
-    let Str.295 : U8 = StructAtIndex 1 Str.236;
+    let Str.298 : U8 = StructAtIndex 1 Str.237;
-    let Str.296 : U8 = 0i64;
+    let Str.299 : U8 = 0i64;
-    let Str.292 : Int1 = CallByName Bool.11 Str.295 Str.296;
+    let Str.295 : Int1 = CallByName Bool.11 Str.298 Str.299;
-    if Str.292 then
+    if Str.295 then
-        let Str.294 : I64 = StructAtIndex 0 Str.236;
+        let Str.297 : I64 = StructAtIndex 0 Str.237;
-        let Str.293 : [C {}, C I64] = TagId(1) Str.294;
+        let Str.296 : [C {}, C I64] = TagId(1) Str.297;
+        ret Str.296;
+    else
+        let Str.294 : {} = Struct {};
+        let Str.293 : [C {}, C I64] = TagId(0) Str.294;
         ret Str.293;
-    else
-        let Str.291 : {} = Struct {};
-        let Str.290 : [C {}, C I64] = TagId(0) Str.291;
-        ret Str.290;
 
-procedure Str.9 (Str.79):
+procedure Str.9 (Str.80):
-    let Str.306 : U64 = 0i64;
+    let Str.309 : U64 = 0i64;
-    let Str.307 : U64 = CallByName List.6 Str.79;
+    let Str.310 : U64 = CallByName List.6 Str.80;
-    let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.306 Str.307;
+    let Str.81 : {U64, Str, Int1, U8} = CallByName Str.48 Str.80 Str.309 Str.310;
-    let Str.303 : Int1 = StructAtIndex 2 Str.80;
+    let Str.306 : Int1 = StructAtIndex 2 Str.81;
-    if Str.303 then
+    if Str.306 then
-        let Str.305 : Str = StructAtIndex 1 Str.80;
+        let Str.308 : Str = StructAtIndex 1 Str.81;
-        let Str.304 : [C {U64, U8}, C Str] = TagId(1) Str.305;
+        let Str.307 : [C {U64, U8}, C Str] = TagId(1) Str.308;
-        ret Str.304;
+        ret Str.307;
     else
-        let Str.301 : U8 = StructAtIndex 3 Str.80;
+        let Str.304 : U8 = StructAtIndex 3 Str.81;
-        let Str.302 : U64 = StructAtIndex 0 Str.80;
+        let Str.305 : U64 = StructAtIndex 0 Str.81;
-        let #Derived_gen.6 : Str = StructAtIndex 1 Str.80;
+        let #Derived_gen.6 : Str = StructAtIndex 1 Str.81;
         dec #Derived_gen.6;
-        let Str.300 : {U64, U8} = Struct {Str.302, Str.301};
+        let Str.303 : {U64, U8} = Struct {Str.305, Str.304};
-        let Str.299 : [C {U64, U8}, C Str] = TagId(0) Str.300;
+        let Str.302 : [C {U64, U8}, C Str] = TagId(0) Str.303;
-        ret Str.299;
+        ret Str.302;
 
 procedure Test.0 ():
     let Test.37 : Str = "-1234";

crates/compiler/test_mono/generated/layout_cache_structure_with_multiple_recursive_structures.txt

@@ -1,32 +1,32 @@
-procedure List.18 (List.145, List.146, List.147):
+procedure List.18 (List.147, List.148, List.149):
-    let List.536 : U64 = 0i64;
+    let List.546 : U64 = 0i64;
-    let List.537 : U64 = CallByName List.6 List.145;
+    let List.547 : U64 = CallByName List.6 List.147;
-    let List.535 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = CallByName List.86 List.145 List.146 List.147 List.536 List.537;
+    let List.545 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = CallByName List.87 List.147 List.148 List.149 List.546 List.547;
-    ret List.535;
-
-procedure List.6 (#Attr.2):
-    let List.546 : U64 = lowlevel ListLen #Attr.2;
-    ret List.546;
-
-procedure List.66 (#Attr.2, #Attr.3):
-    let List.545 : [<rnu>C *self, <null>] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
     ret List.545;
 
-procedure List.86 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
+procedure List.6 (#Attr.2):
-    joinpoint List.538 List.148 List.149 List.150 List.151 List.152:
+    let List.556 : U64 = lowlevel ListLen #Attr.2;
-        let List.540 : Int1 = CallByName Num.22 List.151 List.152;
+    ret List.556;
-        if List.540 then
+
-            let List.544 : [<rnu>C *self, <null>] = CallByName List.66 List.148 List.151;
+procedure List.66 (#Attr.2, #Attr.3):
-            inc List.544;
+    let List.555 : [<rnu>C *self, <null>] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-            let List.153 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = CallByName Test.7 List.149 List.544;
+    ret List.555;
-            let List.543 : U64 = 1i64;
+
-            let List.542 : U64 = CallByName Num.51 List.151 List.543;
+procedure List.87 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
-            jump List.538 List.148 List.153 List.150 List.542 List.152;
+    joinpoint List.548 List.150 List.151 List.152 List.153 List.154:
+        let List.550 : Int1 = CallByName Num.22 List.153 List.154;
+        if List.550 then
+            let List.554 : [<rnu>C *self, <null>] = CallByName List.66 List.150 List.153;
+            inc List.554;
+            let List.155 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = CallByName Test.7 List.151 List.554;
+            let List.553 : U64 = 1i64;
+            let List.552 : U64 = CallByName Num.51 List.153 List.553;
+            jump List.548 List.150 List.155 List.152 List.552 List.154;
         else
-            dec List.148;
+            dec List.150;
-            ret List.149;
+            ret List.151;
     in
-    jump List.538 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
+    jump List.548 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.292 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/list_append.txt

@@ -1,16 +1,16 @@
-procedure List.4 (List.116, List.117):
+procedure List.4 (List.118, List.119):
-    let List.538 : U64 = 1i64;
+    let List.548 : U64 = 1i64;
-    let List.536 : List I64 = CallByName List.70 List.116 List.538;
+    let List.546 : List I64 = CallByName List.70 List.118 List.548;
-    let List.535 : List I64 = CallByName List.71 List.536 List.117;
+    let List.545 : List I64 = CallByName List.71 List.546 List.119;
-    ret List.535;
+    ret List.545;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.539 : List I64 = lowlevel ListReserve #Attr.2 #Attr.3;
+    let List.549 : List I64 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.539;
+    ret List.549;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.537 : List I64 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    let List.547 : List I64 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.537;
+    ret List.547;
 
 procedure Test.0 ():
     let Test.2 : List I64 = Array [1i64];

crates/compiler/test_mono/generated/list_append_closure.txt

@@ -1,16 +1,16 @@
-procedure List.4 (List.116, List.117):
+procedure List.4 (List.118, List.119):
-    let List.538 : U64 = 1i64;
+    let List.548 : U64 = 1i64;
-    let List.536 : List I64 = CallByName List.70 List.116 List.538;
+    let List.546 : List I64 = CallByName List.70 List.118 List.548;
-    let List.535 : List I64 = CallByName List.71 List.536 List.117;
+    let List.545 : List I64 = CallByName List.71 List.546 List.119;
-    ret List.535;
+    ret List.545;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.539 : List I64 = lowlevel ListReserve #Attr.2 #Attr.3;
+    let List.549 : List I64 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.539;
+    ret List.549;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.537 : List I64 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    let List.547 : List I64 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.537;
+    ret List.547;
 
 procedure Test.1 (Test.2):
     let Test.6 : I64 = 42i64;

crates/compiler/test_mono/generated/list_cannot_update_inplace.txt

@@ -1,25 +1,25 @@
-procedure List.3 (List.108, List.109, List.110):
+procedure List.3 (List.110, List.111, List.112):
-    let List.538 : {List I64, I64} = CallByName List.64 List.108 List.109 List.110;
+    let List.548 : {List I64, I64} = CallByName List.64 List.110 List.111 List.112;
-    let List.537 : List I64 = StructAtIndex 0 List.538;
+    let List.547 : List I64 = StructAtIndex 0 List.548;
-    ret List.537;
+    ret List.547;
 
 procedure List.6 (#Attr.2):
-    let List.536 : U64 = lowlevel ListLen #Attr.2;
+    let List.546 : U64 = lowlevel ListLen #Attr.2;
-    ret List.536;
+    ret List.546;
 
-procedure List.64 (List.105, List.106, List.107):
+procedure List.64 (List.107, List.108, List.109):
-    let List.543 : U64 = CallByName List.6 List.105;
+    let List.553 : U64 = CallByName List.6 List.107;
-    let List.540 : Int1 = CallByName Num.22 List.106 List.543;
+    let List.550 : Int1 = CallByName Num.22 List.108 List.553;
-    if List.540 then
+    if List.550 then
-        let List.541 : {List I64, I64} = CallByName List.67 List.105 List.106 List.107;
+        let List.551 : {List I64, I64} = CallByName List.67 List.107 List.108 List.109;
-        ret List.541;
+        ret List.551;
     else
-        let List.539 : {List I64, I64} = Struct {List.105, List.107};
+        let List.549 : {List I64, I64} = Struct {List.107, List.109};
-        ret List.539;
+        ret List.549;
 
 procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
-    let List.542 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
+    let List.552 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
-    ret List.542;
+    ret List.552;
 
 procedure Num.19 (#Attr.2, #Attr.3):
     let Num.291 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/list_get.txt

@@ -1,24 +1,24 @@
-procedure List.2 (List.100, List.101):
+procedure List.2 (List.102, List.103):
-    let List.541 : U64 = CallByName List.6 List.100;
+    let List.551 : U64 = CallByName List.6 List.102;
-    let List.537 : Int1 = CallByName Num.22 List.101 List.541;
+    let List.547 : Int1 = CallByName Num.22 List.103 List.551;
-    if List.537 then
+    if List.547 then
-        let List.539 : I64 = CallByName List.66 List.100 List.101;
+        let List.549 : I64 = CallByName List.66 List.102 List.103;
-        dec List.100;
+        dec List.102;
-        let List.538 : [C {}, C I64] = TagId(1) List.539;
+        let List.548 : [C {}, C I64] = TagId(1) List.549;
-        ret List.538;
+        ret List.548;
     else
-        dec List.100;
+        dec List.102;
-        let List.536 : {} = Struct {};
+        let List.546 : {} = Struct {};
-        let List.535 : [C {}, C I64] = TagId(0) List.536;
+        let List.545 : [C {}, C I64] = TagId(0) List.546;
-        ret List.535;
+        ret List.545;
 
 procedure List.6 (#Attr.2):
-    let List.542 : U64 = lowlevel ListLen #Attr.2;
+    let List.552 : U64 = lowlevel ListLen #Attr.2;
-    ret List.542;
+    ret List.552;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.540 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.550 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.540;
+    ret List.550;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.291 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/list_len.txt

@@ -1,10 +1,10 @@
 procedure List.6 (#Attr.2):
-    let List.535 : U64 = lowlevel ListLen #Attr.2;
+    let List.545 : U64 = lowlevel ListLen #Attr.2;
-    ret List.535;
+    ret List.545;
 
 procedure List.6 (#Attr.2):
-    let List.536 : U64 = lowlevel ListLen #Attr.2;
+    let List.546 : U64 = lowlevel ListLen #Attr.2;
-    ret List.536;
+    ret List.546;
 
 procedure Num.19 (#Attr.2, #Attr.3):
     let Num.291 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/list_map_closure_borrows.txt

@@ -1,42 +1,42 @@
-procedure List.2 (List.100, List.101):
+procedure List.2 (List.102, List.103):
-    let List.541 : U64 = CallByName List.6 List.100;
+    let List.551 : U64 = CallByName List.6 List.102;
-    let List.537 : Int1 = CallByName Num.22 List.101 List.541;
+    let List.547 : Int1 = CallByName Num.22 List.103 List.551;
-    if List.537 then
+    if List.547 then
-        let List.539 : Str = CallByName List.66 List.100 List.101;
+        let List.549 : Str = CallByName List.66 List.102 List.103;
-        inc List.539;
+        inc List.549;
-        dec List.100;
+        dec List.102;
-        let List.538 : [C {}, C Str] = TagId(1) List.539;
+        let List.548 : [C {}, C Str] = TagId(1) List.549;
-        ret List.538;
+        ret List.548;
     else
-        dec List.100;
+        dec List.102;
-        let List.536 : {} = Struct {};
+        let List.546 : {} = Struct {};
-        let List.535 : [C {}, C Str] = TagId(0) List.536;
+        let List.545 : [C {}, C Str] = TagId(0) List.546;
-        ret List.535;
+        ret List.545;
 
 procedure List.5 (#Attr.2, #Attr.3):
-    let List.543 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
+    let List.553 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
     decref #Attr.2;
-    ret List.543;
+    ret List.553;
 
 procedure List.6 (#Attr.2):
-    let List.542 : U64 = lowlevel ListLen #Attr.2;
+    let List.552 : U64 = lowlevel ListLen #Attr.2;
-    ret List.542;
+    ret List.552;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.540 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.550 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.540;
+    ret List.550;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.291 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
     ret Num.291;
 
 procedure Str.16 (#Attr.2, #Attr.3):
-    let Str.289 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;
+    let Str.292 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;
-    ret Str.289;
+    ret Str.292;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.290 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    let Str.293 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.290;
+    ret Str.293;
 
 procedure Test.1 ():
     let Test.21 : Str = "lllllllllllllllllllllooooooooooong";