Merge pull request #8724 from roc-lang/langref-more

More langref

.github/actions/flaky-retry/README.md

@@ -0,0 +1,30 @@
+# Flaky Retry Action
+
+A GitHub Action that retries a command if it fails with a specific error string.
+
+## Inputs
+
+- `command` (required): The command to run
+- `error_string_contains` (required): Retry only if error output contains this string
+- `retry_count` (optional): Number of times to retry on failure (default: 3)
+
+## Usage
+
+```yaml
+- name: Run flaky test
+  uses: ./.github/actions/flaky-retry
+  with:
+    command: 'cargo test my_flaky_test'
+    error_string_contains: 'connection timeout'
+    retry_count: 5
+```
+
+## Behavior
+
+- Runs the specified command
+- If the command succeeds (exit code 0), the action succeeds immediately
+- If the command fails (non-zero exit code):
+  - Checks if the error output contains the specified string
+  - If it does, retries up to `retry_count` times
+  - If it doesn't, fails immediately without retrying
+- After all retries are exhausted, the action fails with the last exit code

.github/actions/flaky-retry/action.yml

@@ -0,0 +1,101 @@
+name: 'Flaky Retry'
+description: 'Retry a command if it fails with a specific error string'
+inputs:
+  retry_count:
+    description: 'Number of times to retry on failure'
+    required: false
+    default: '3'
+  error_string_contains:
+    description: 'Retry only if error output contains this string'
+    required: true
+  command:
+    description: 'The command to run'
+    required: true
+runs:
+  using: 'composite'
+  steps:
+    - name: Run command with retry logic (Unix)
+      if: runner.os != 'Windows'
+      shell: bash
+      run: |
+        attempt=1
+        max_attempts=$((${{ inputs.retry_count }} + 1))
+
+        while [ $attempt -le $max_attempts ]; do
+          echo "Attempt $attempt of $max_attempts"
+          echo "Running command: ${{ inputs.command }}"
+
+          # Run command and capture output and exit code
+          output_file=$(mktemp)
+          trap 'rm -f "$output_file"' EXIT
+
+          set +e
+          eval "${{ inputs.command }}" 2>&1 | tee "$output_file"
+          exit_code=${PIPESTATUS[0]}
+          set -e
+
+
+          # Check if command succeeded
+          if [ $exit_code -eq 0 ]; then
+            echo "Command succeeded"
+            exit 0
+          fi
+
+          # Command failed - check if we should retry
+          if [ $attempt -ge $max_attempts ]; then
+            echo "Command failed after $max_attempts attempts"
+            exit $exit_code
+          fi
+
+          # Check if error matches retry condition
+          if grep -Eq "${{ inputs.error_string_contains }}" "$output_file"; then
+            echo "Command failed with exit code $exit_code and error output contains '${{ inputs.error_string_contains }}'"
+            echo "Retrying..."
+            attempt=$((attempt + 1))
+            sleep 2
+          else
+            echo "Command failed with exit code $exit_code."
+            exit $exit_code
+          fi
+        done
+
+    - name: Run command with retry logic (Windows)
+      if: runner.os == 'Windows'
+      shell: powershell
+      run: |
+        $attempt = 1
+        $maxAttempts = [int]"${{ inputs.retry_count }}" + 1
+
+        while ($attempt -le $maxAttempts) {
+          Write-Host "Attempt $attempt of $maxAttempts"
+          Write-Host "Running command: ${{ inputs.command }}"
+
+          # Run command and capture output
+          $ErrorActionPreference = 'Continue'
+          $output = & cmd /c "${{ inputs.command }} 2>&1"
+          $exitCode = $LASTEXITCODE
+          Write-Host $output
+
+          # Check if command succeeded
+          if ($exitCode -eq 0) {
+            Write-Host "Command succeeded"
+            exit 0
+          }
+
+          # Command failed - check if we should retry
+          if ($attempt -ge $maxAttempts) {
+            Write-Host "Command failed after $maxAttempts attempts"
+            exit $exitCode
+          }
+
+          # Check if error matches retry condition
+          if ($output -match "${{ inputs.error_string_contains }}") {
+            Write-Host "Command failed with exit code $exitCode and error output contains '${{ inputs.error_string_contains }}'"
+            Write-Host "Retrying..."
+            $attempt++
+            Start-Sleep -Seconds 2
+          } else {
+            Write-Host "Command failed with exit code $exitCode."
+            exit $exitCode
+          }
+        }

.github/workflows/alwayscheck.yml

@@ -32,9 +32,9 @@ jobs:
 
       - name: setup Roc
         run: |
-          curl -s -OL https://github.com/roc-lang/roc/releases/download/alpha3-rolling/roc-linux_x86_64-alpha3-rolling.tar.gz
-          tar -xf roc-linux_x86_64-alpha3-rolling.tar.gz
-          rm roc-linux_x86_64-alpha3-rolling.tar.gz
+          curl -s -OL https://github.com/roc-lang/roc/releases/download/alpha4-rolling/roc-linux_x86_64-alpha4-rolling.tar.gz
+          tar -xf roc-linux_x86_64-alpha4-rolling.tar.gz
+          rm roc-linux_x86_64-alpha4-rolling.tar.gz
           cd roc_nightly-*
           # make roc binary available
           echo "$(pwd)" >> $GITHUB_PATH

.github/workflows/basic_cli_build_release.yml

@@ -96,7 +96,7 @@ jobs:
             basic-cli/platform/linux-arm64.a
 
   build-macos-x86_64-files:
-    runs-on: [macos-13] # I expect the generated files to work on macOS 13 and up
+    runs-on: [macos-15-intel] # should work on macOS 15+
     needs: [prepare]
     steps:
       - uses: actions/checkout@v4
@@ -207,7 +207,7 @@ jobs:
     needs: [create-release-archive]
     strategy:
       matrix:
-        os: [ubuntu-22.04, ubuntu-24.04, ubuntu-24.04-arm, macos-13, macos-14, macos-15]
+        os: [ubuntu-22.04, ubuntu-24.04, ubuntu-24.04-arm, macos-15-intel, macos-14, macos-15]
     runs-on: ${{ matrix.os }}
     steps:
       - name: Download the previously uploaded files
@@ -220,7 +220,7 @@ jobs:
             echo "os_pattern=linux_arm64" >> $GITHUB_OUTPUT
           elif [[ "${{ matrix.os }}" =~ ^ubuntu- ]]; then
             echo "os_pattern=linux_x86_64" >> $GITHUB_OUTPUT
-          elif [ "${{ matrix.os }}" = "macos-13" ]; then
+          elif [ "${{ matrix.os }}" = "macos-15-intel" ]; then
             echo "os_pattern=macos_x86_64" >> $GITHUB_OUTPUT
           else
             echo "os_pattern=macos_apple_silicon" >> $GITHUB_OUTPUT

.github/workflows/basic_cli_test_arm64.yml

@@ -56,5 +56,9 @@ jobs:
           git fetch --tags
           latestTag=$(git describe --tags $(git rev-list --tags --max-count=1))
           git checkout $latestTag
+          # remove things that don't work on musl
+          rm ./examples/file-accessed-modified-created-time.roc
+          sed -i.bak -e '/time_accessed!,$/d' -e '/time_modified!,$/d' -e '/time_created!,$/d' -e '/^time_accessed!/,/^$/d' -e '/^time_modified!/,/^$/d' -e '/^time_created!/,/^$/d' -e '/^import Utc exposing \[Utc\]$/d' ./platform/File.roc
+          rm ./platform/File.roc.bak
           sed -i 's/x86_64/arm64/g' ./ci/test_latest_release.sh
-          EXAMPLES_DIR=./examples/ ./ci/test_latest_release.sh
+          GITHUB_TOKEN=${{ secrets.GITHUB_TOKEN }} EXAMPLES_DIR=./examples/ ./ci/test_latest_release.sh

.github/workflows/basic_webserver_build_release.yml

@@ -77,7 +77,7 @@ jobs:
             basic-webserver/platform/linux-arm64.a
 
   build-macos-x86_64-files:
-    runs-on: [macos-13] # I expect the generated files to work on macOS 13 and up
+    runs-on: [macos-15-intel] # should work on macOS 15+
     needs: [fetch-releases]
     steps:
       - uses: actions/checkout@v4
@@ -187,7 +187,7 @@ jobs:
     needs: [create-release-archive]
     strategy:
       matrix:
-        os: [ubuntu-22.04, ubuntu-24.04, ubuntu-24.04-arm, macos-13, macos-14, macos-15]
+        os: [ubuntu-22.04, ubuntu-24.04, ubuntu-24.04-arm, macos-15-intel, macos-14, macos-15]
     runs-on: ${{ matrix.os }}
     steps:
       - name: Download the previously uploaded files
@@ -200,7 +200,7 @@ jobs:
             echo "os_pattern=linux_arm64" >> $GITHUB_OUTPUT
           elif [[ "${{ matrix.os }}" =~ ^ubuntu- ]]; then
             echo "os_pattern=linux_x86_64" >> $GITHUB_OUTPUT
-          elif [ "${{ matrix.os }}" = "macos-13" ]; then
+          elif [ "${{ matrix.os }}" = "macos-15-intel" ]; then
             echo "os_pattern=macos_x86_64" >> $GITHUB_OUTPUT
           else
             echo "os_pattern=macos_apple_silicon" >> $GITHUB_OUTPUT

.github/workflows/ci_cross_compile.yml

@@ -0,0 +1,139 @@
+on:
+  workflow_call:
+
+name: Cross Compilation Test
+
+# Do not add permissions here! Configure them at the job level!
+permissions: {}
+
+jobs:
+  # Cross-compile all fx platform tests from all host platforms
+  cross-compile-fx-tests:
+    runs-on: ${{ matrix.host }}
+    strategy:
+      fail-fast: false
+      matrix:
+        host: [
+            ubuntu-22.04, # Linux x64 host
+            macos-15-intel, # macOS x64 host
+            macos-15, # macOS ARM64 host
+            windows-2022, # Windows x64 host
+          ]
+        target: [
+            x64musl, # Linux x86_64 musl (static linking)
+            arm64musl, # Linux ARM64 musl (static linking)
+          ]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+
+      - uses: mlugg/setup-zig@8d6198c65fb0feaa111df26e6b467fea8345e46f # 2.0.5
+        with:
+          version: 0.15.2
+          use-cache: false
+
+      - name: Setup MSVC (Windows)
+        if: runner.os == 'Windows'
+        uses: ilammy/msvc-dev-cmd@0b201ec74fa43914dc39ae48a89fd1d8cb592756  # ratchet:ilammy/msvc-dev-cmd@v1.13.0
+        with:
+          arch: x64
+
+      - name: Build roc compiler and test_runner
+        uses: ./.github/actions/flaky-retry
+        with:
+          command: 'zig build'
+          error_string_contains: 'EndOfStream|503|Timeout'
+          retry_count: 3
+
+      - name: Run fx platform cross-compilation tests (Unix)
+        if: runner.os != 'Windows'
+        run: |
+          echo "Cross-compiling fx tests from ${{ matrix.host }} to ${{ matrix.target }}"
+          ./zig-out/bin/test_runner ./zig-out/bin/roc fx --target=${{ matrix.target }} --mode=cross
+
+      - name: Run fx platform cross-compilation tests (Windows)
+        if: runner.os == 'Windows'
+        run: |
+          echo "Cross-compiling fx tests from ${{ matrix.host }} to ${{ matrix.target }}"
+          zig-out\bin\test_runner.exe zig-out\bin\roc.exe fx --target=${{ matrix.target }} --mode=cross
+
+      - name: Cross-compile int platform test app (Unix)
+        if: runner.os != 'Windows'
+        run: |
+          echo "Cross-compiling int platform from ${{ matrix.host }} to ${{ matrix.target }}"
+          ./zig-out/bin/roc build --target=${{ matrix.target }} --output=int_app_${{ matrix.target }}_${{ matrix.host }} test/int/app.roc
+
+      - name: Cross-compile int platform test app (Windows)
+        if: runner.os == 'Windows'
+        run: |
+          echo "Cross-compiling int platform from ${{ matrix.host }} to ${{ matrix.target }}"
+          zig-out\bin\roc.exe build --target=${{ matrix.target }} --output=int_app_${{ matrix.target }}_${{ matrix.host }} test/int/app.roc
+
+      - name: Upload cross-compiled int app executables
+        uses: actions/upload-artifact@v4 # ratchet:actions/upload-artifact@v4
+        with:
+          name: cross-compiled-${{ matrix.host }}-${{ matrix.target }}
+          path: |
+            int_app_${{ matrix.target }}_*
+          retention-days: 1
+
+  # Test cross-compiled int platform executables on actual target platforms
+  test-int-on-target:
+    needs: [cross-compile-fx-tests]
+    runs-on: ${{ matrix.target_os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # Test x64musl executables on Linux x64
+          - target: x64musl
+            target_os: ubuntu-22.04
+            arch: x64
+          # Test arm64musl executables on Linux ARM64
+          - target: arm64musl
+            target_os: ubuntu-24.04-arm
+            arch: arm64
+    steps:
+      - name: Download all cross-compiled artifacts
+        uses: actions/download-artifact@v4
+        with:
+          pattern: cross-compiled-*-${{ matrix.target }}
+          merge-multiple: true
+
+      - name: List downloaded files
+        run: |
+          echo "Downloaded cross-compiled executables:"
+          ls -la *_${{ matrix.target }}* || echo "No files found"
+
+      - name: Test cross-compiled executables from all hosts
+        run: |
+          success_count=0
+          total_count=0
+
+          echo "Testing ${{ matrix.target }} executables on ${{ matrix.target_os }} (${{ matrix.arch }})"
+
+          # Test int apps from all host platforms
+          for int_app in int_app_${{ matrix.target }}_*; do
+            if [ -f "$int_app" ]; then
+              echo ""
+              echo "Testing $int_app:"
+              chmod +x "$int_app"
+              if ./"$int_app"; then
+                echo "✅ $int_app: SUCCESS"
+                success_count=$((success_count + 1))
+              else
+                echo "❌ $int_app: FAILED"
+              fi
+              total_count=$((total_count + 1))
+            fi
+          done
+
+          echo ""
+          echo "Summary: $success_count/$total_count executables passed"
+
+          if [ $success_count -eq $total_count ] && [ $total_count -gt 0 ]; then
+            echo "🎉 All cross-compiled executables work correctly!"
+          else
+            echo "💥 Some cross-compiled executables failed"
+            exit 1
+          fi

.github/workflows/ci_manager.yml

@@ -31,7 +31,12 @@ jobs:
               - 'build.zig'
               - 'build.zig.zon'
               - '.github/workflows/ci_zig.yml'
+              - '.github/workflows/ci_cross_compile.yml'
+              - '.github/actions/flaky-retry/action.yml'
               - 'ci/zig_lints.sh'
+              - 'ci/check_test_wiring.zig'
+              - 'ci/custom_valgrind.sh'
+              - 'ci/valgrind.supp'
       - uses: dorny/paths-filter@v3
         id: other_filter
         with:
@@ -46,10 +51,16 @@ jobs:
               - '!build.zig'
               - '!build.zig.zon'
               - '!.github/workflows/ci_zig.yml'
+              - '!.github/workflows/ci_cross_compile.yml'
+              - '!.github/actions/flaky-retry/action.yml'
               - '!ci/zig_lints.sh'
+              - '!ci/check_test_wiring.zig'
+              - '!ci/custom_valgrind.sh'
+              - '!ci/valgrind.supp'
               # Files that ci manager workflows should not run on.
               - '!.gitignore'
               - '!.reuse'
+              - '!.rules'
               - '!authors'
               - '!legal_details'
               - '!LICENSE'

.github/workflows/ci_zig.yml

@@ -1,5 +1,6 @@
 on:
   workflow_call:
+  workflow_dispatch:
 
 name: CI New Compiler
 
@@ -13,22 +14,27 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # ratchet:actions/checkout@v4
-      - uses: mlugg/setup-zig@475c97be87a204e6c57fe851f970bd02005a70f0 # ratchet:mlugg/setup-zig@v2
+      - uses: mlugg/setup-zig@8d6198c65fb0feaa111df26e6b467fea8345e46f # ratchet:mlugg/setup-zig@v2.0.5
         with:
-          version: 0.14.1
-          # Do not cache the zig cache.
-          # Just cache the zig executable.
-          # Zig cache corrupts sometimes and uses tons of space.
-          use-cache: false
+          version: 0.15.2
+          use-cache: true
 
       - name: zig lints
         run: |
-          ./ci/zig_lints.sh
+          zig run ci/zig_lints.zig
 
           zig build check-fmt
 
-        # We run zig check with tracy enabled.
-        # This ensure it compiles and doesn't go stale.
+      - name: Check that test is actually wired up
+        run: |
+          zig run ci/check_test_wiring.zig
+
+      - name: Check fx platform test coverage
+        run: |
+          zig build checkfx
+
+      # We run zig check with tracy enabled.
+      # This ensure it compiles and doesn't go stale.
       - name: Checkout Tracy
         uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # ratchet:actions/checkout@v4
         with:
@@ -38,7 +44,6 @@ jobs:
 
       - name: zig check
         run: |
-          # -Dllvm incurs a costly download step, leave that for later.
           # Just the do super fast check step for now.
           zig build -Dno-bin -Dfuzz -Dtracy=./tracy
 
@@ -65,7 +70,11 @@ jobs:
 
       - name: Run Playground Tests
         run: |
-          zig build playground-test -Doptimize=ReleaseSmall -- --verbose
+          zig build test-playground -Doptimize=ReleaseSmall -- --verbose
+
+      - name: Verify Serialized Type Sizes
+        run: |
+          zig build test-serialization-sizes
 
   zig-tests:
     needs: check-once
@@ -73,51 +82,84 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [
-            macos-13,
-            macos-15,
-            ubuntu-22.04,
-            ubuntu-24.04-arm,
-            windows-2022,
-            windows-2025,
-            windows-11-arm,
-          ] # macos-13 uses x64, macos-15 uses arm64
+        include:
+          - os: macos-15-intel
+            cpu_flag: -Dcpu=x86_64_v3
+            target_flag: ''
+          - os: macos-15
+            cpu_flag: ''
+            target_flag: ''
+          - os: ubuntu-22.04
+            cpu_flag: -Dcpu=x86_64_v3
+            target_flag: -Dtarget=x86_64-linux-musl
+          - os: ubuntu-24.04-arm
+            cpu_flag: ''
+            target_flag: -Dtarget=aarch64-linux-musl
+          - os: windows-2022
+            cpu_flag: -Dcpu=x86_64_v3
+            target_flag: ''
+          - os: windows-2025
+            cpu_flag: -Dcpu=x86_64_v3
+            target_flag: ''
+          - os: windows-11-arm
+            cpu_flag: ''
+            target_flag: ''
+
     steps:
       - name: Checkout
         uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # ratchet:actions/checkout@v4
-      - uses: mlugg/setup-zig@475c97be87a204e6c57fe851f970bd02005a70f0 # ratchet:mlugg/setup-zig@v2
+      - uses: mlugg/setup-zig@8d6198c65fb0feaa111df26e6b467fea8345e46f # ratchet:mlugg/setup-zig@v2.0.5
         with:
-          version: 0.14.1
-          # Do not cache the zig cache.
-          # Just cache the zig executable.
-          # Zig cache corrupts sometimes and uses tons of space.
-          use-cache: false
+          version: 0.15.2
+          use-cache: true
       - if: startsWith(matrix.os, 'ubuntu') || startsWith(matrix.os, 'macos')
         uses: cachix/install-nix-action@02a151ada4993995686f9ed4f1be7cfbb229e56f # ratchet:cachix/install-nix-action@v31
         with:
           nix_path: nixpkgs=channel:nixos-25.05
 
-      - name: build roc
+      # temp fix, see https://roc.zulipchat.com/#narrow/channel/395097-compiler-development/topic/CI/near/542085291
+      - name: delete llvm-config
+        if: startsWith(matrix.os, 'ubuntu') && endsWith(matrix.os, '-arm')
         run: |
-          zig build -Dllvm -Dfuzz -Dsystem-afl=false
+          sudo rm /usr/lib/llvm-18/bin/llvm-config
+
+      - name: build roc + repro executables
+        uses: ./.github/actions/flaky-retry
+        with:
+          command: "zig build -Dfuzz -Dsystem-afl=false -Doptimize=ReleaseFast ${{ matrix.cpu_flag }} ${{ matrix.target_flag }}"
+          error_string_contains: "EndOfStream|Timeout"
+          retry_count: 3
+
+      - name: Check Builtin.roc formatting (Unix)
+        if: runner.os != 'Windows'
+        run: |
+          ./zig-out/bin/roc fmt --check src/build/roc/Builtin.roc
+
+      - name: Check Builtin.roc formatting (Windows)
+        if: runner.os == 'Windows'
+        run: |
+          zig-out\bin\roc.exe fmt --check src/build/roc/Builtin.roc
 
       - name: Run Test Platforms (Unix)
         if: runner.os != 'Windows'
         run: |
-          ./zig-out/bin/roc --no-cache test/str/app.roc
-          ./zig-out/bin/roc --no-cache test/int/app.roc
+          zig build test-cli ${{ matrix.target_flag }}
 
       - name: Setup MSVC (Windows)
         if: runner.os == 'Windows'
-        uses: ilammy/msvc-dev-cmd@v1
+        uses: ilammy/msvc-dev-cmd@0b201ec74fa43914dc39ae48a89fd1d8cb592756  # ratchet:ilammy/msvc-dev-cmd@v1.13.0
         with:
           arch: ${{ matrix.os == 'windows-11-arm' && 'arm64' || 'x64' }}
 
       - name: Run Test Platforms (Windows)
         if: runner.os == 'Windows'
         run: |
-          zig-out\bin\roc.exe --no-cache test/str/app.roc
-          zig-out\bin\roc.exe --no-cache test/int/app.roc
+          zig build test-cli
+
+      - name: Build Test Platforms (cross-compile)
+        if: runner.os != 'Windows'
+        run: |
+          ./zig-out/bin/test_runner ./zig-out/bin/roc int --mode=cross
 
       - name: roc executable minimal check (Unix)
         if: runner.os != 'Windows'
@@ -130,11 +172,23 @@ jobs:
           zig-out\bin\roc.exe check ./src/PROFILING/bench_repeated_check.roc
 
       - name: zig snapshot tests
-        run: zig build snapshot -- --debug
+        run: zig build snapshot ${{ matrix.target_flag }} -- --debug
 
-      - name: zig tests
-        run: |
-          zig build test -Dllvm -Dfuzz -Dsystem-afl=false
+      # 1) in debug mode
+      - name: build and execute tests, build repro executables
+        uses: ./.github/actions/flaky-retry
+        with:
+          command: "zig build test -Dfuzz -Dsystem-afl=false ${{ matrix.target_flag }}"
+          error_string_contains: "double roundtrip bundle|connectTcp|downloadToFile"
+          retry_count: 3
+
+      # 2) in release mode
+      - name: Build and execute tests, build repro executables. All in release mode.
+        uses: ./.github/actions/flaky-retry
+        with:
+          command: "zig build test -Doptimize=ReleaseFast -Dfuzz -Dsystem-afl=false ${{ matrix.cpu_flag }} ${{ matrix.target_flag }}"
+          error_string_contains: "double roundtrip bundle|connectTcp|downloadToFile"
+          retry_count: 3
 
       - name: Check for snapshot changes
         run: |
@@ -143,22 +197,33 @@ jobs:
             echo ""
             echo "OOPS! It looks like the snapshots in 'test/snapshots' have changed.";
             echo "Please run 'zig build snapshot' locally, review the updates, and commit the changes.";
+            echo ""
+            echo "NOTE: If snapshots pass locally but fail in CI, you may need to merge origin/main";
+            echo "into your branch first, then regenerate snapshots. CI tests your branch merged with";
+            echo "main, so new snapshots from main can cause diffs when regenerated with your changes.";
+            echo ""
             echo "Here's what changed:";
             echo ""
             git diff test/snapshots;
             exit 1;
           }
 
-      - name: check snapshots with valgrind (ubuntu)
+      - name: test with valgrind (ubuntu)
         # Sadly, with zig 0.14.1, this had to be disabled on arm.
         # Valgrind as of 3.25.1 does not support some arm instructions zig generates.
         # So valgrind only works happily on x86_64 linux.
         # We can re-evaluate as new version of zig/valgrind come out.
         if: ${{ matrix.os == 'ubuntu-22.04' }}
         run: |
-          sudo apt install -y valgrind
+          # Install libc6-dbg which is required for Valgrind's function redirections
+          sudo apt-get update && sudo apt-get install -y libc6-dbg
+          sudo snap install valgrind --classic
           valgrind --version
-          valgrind --leak-check=full --error-exitcode=1 --errors-for-leak-kinds=definite,possible ./zig-out/bin/snapshot --debug
+          ./ci/custom_valgrind.sh ./zig-out/bin/snapshot --debug --verbose
+          ./ci/custom_valgrind.sh ./zig-out/bin/roc --no-cache test/str/app.roc
+          ./ci/custom_valgrind.sh ./zig-out/bin/roc --no-cache test/int/app.roc
+          # valgrind all app files in test/fx except those that read from stdin
+          # find test/fx -maxdepth 1 -name "*.roc" -type f -exec grep -l "app \[main" {} + | xargs -I {} sh -c 'grep -L "Stdin" {} || true' | xargs -I {} ./ci/custom_valgrind.sh ./zig-out/bin/roc --no-cache {}
 
       - name: check if statically linked (ubuntu)
         if: startsWith(matrix.os, 'ubuntu')
@@ -188,11 +253,11 @@ jobs:
           }
 
       - name: Test inside nix too
-        if: startsWith(matrix.os, 'ubuntu') || startsWith(matrix.os, 'macos')
+        if: ${{ runner.os == 'Linux' || (runner.os == 'macOS' && runner.arch != 'X64') }}
         run: |
           git clean -fdx
           git reset --hard HEAD
-          nix develop ./src/flake.nix -c zig build snapshot && zig build test
+          nix develop ./src/ -c zig build ${{ matrix.target_flag }} && zig build snapshot ${{ matrix.target_flag }} && zig build test ${{ matrix.target_flag }}
 
   zig-cross-compile:
     needs: check-once
@@ -213,14 +278,17 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # ratchet:actions/checkout@v4
-      - uses: mlugg/setup-zig@475c97be87a204e6c57fe851f970bd02005a70f0 # ratchet:mlugg/setup-zig@v2
+      - uses: mlugg/setup-zig@8d6198c65fb0feaa111df26e6b467fea8345e46f # ratchet:mlugg/setup-zig@v2.0.5
         with:
-          version: 0.14.1
-          # Do not cache the zig cache.
-          # Just cache the zig executable.
-          # Zig cache corrupts sometimes and uses tons of space.
-          use-cache: false
+          version: 0.15.2
+          use-cache: true
 
       - name: cross compile with llvm
-        run: |
-          ./ci/retry_flaky.sh zig build -Dtarget=${{ matrix.target }} -Dllvm
+        uses: ./.github/actions/flaky-retry
+        with:
+          command: zig build -Dtarget=${{ matrix.target }}
+          error_string_contains: "error: bad HTTP response code: '500 Internal Server Error'|TemporaryNameServerFailure|503|Timeout"
+
+  # Test cross-compilation with Roc's cross-compilation system (musl + glibc)
+  roc-cross-compile:
+    uses: ./.github/workflows/ci_cross_compile.yml

.github/workflows/nightly_linux_arm64.yml

@@ -18,7 +18,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - uses: mlugg/setup-zig@475c97be87a204e6c57fe851f970bd02005a70f0
+      - uses: mlugg/setup-zig@8d6198c65fb0feaa111df26e6b467fea8345e46f # 2.0.5
         with:
           version: 0.13.0
 
@@ -66,6 +66,9 @@ jobs:
       - name: Make nightly release tar archive
         run: ./ci/package_release.sh ${{ env.RELEASE_FOLDER_NAME }}
 
+      - name: Calculate archive hash for security purposes
+        run: ls | grep "roc_nightly.*tar\.gz" | xargs sha256sum
+
       - name: Upload roc nightly tar. Actually uploading to github releases has to be done manually.
         uses: actions/upload-artifact@v4
         with:

.github/workflows/nightly_linux_x86_64.yml

@@ -60,6 +60,9 @@ jobs:
       - name: Make nightly release tar archive
         run: ./ci/package_release.sh ${{ env.RELEASE_FOLDER_NAME }}
 
+      - name: Calculate archive hash for security purposes
+        run: ls | grep "roc_nightly.*tar\.gz" | xargs sha256sum
+
       - name: Upload roc nightly tar. Actually uploading to github releases has to be done manually.
         uses: actions/upload-artifact@v4
         with:

.github/workflows/nightly_macos_apple_silicon.yml

@@ -53,6 +53,9 @@ jobs:
       - name: package release
         run: ./ci/package_release.sh ${{ env.RELEASE_FOLDER_NAME }}
 
+      - name: Calculate archive hash for security purposes
+        run: ls | grep "roc_nightly.*tar\.gz" | xargs shasum -a 256 
+
       - name: delete everything except the tar
         run: ls | grep -v "roc_nightly.*tar\.gz" | xargs rm -rf
 

.github/workflows/nightly_macos_x86_64.yml

@@ -61,6 +61,9 @@ jobs:
       - name: package release
         run: ./ci/package_release.sh ${{ env.RELEASE_FOLDER_NAME }}
 
+      - name: Calculate archive hash for security purposes
+        run: ls | grep "roc_nightly.*tar\.gz" | xargs shasum -a 256 
+
       - name: Upload artifact. Actually uploading to github releases has to be done manually.
         uses: actions/upload-artifact@v4
         with:

.github/workflows/nightly_new_compiler_all_os.yml

@@ -0,0 +1,134 @@
+on:
+#  pull_request:
+  workflow_dispatch:
+  schedule:
+    - cron: "0 9 * * *"
+
+name: Nightly release for new compiler
+
+# Do not add permissions here! Configure them at the job level!
+permissions: {}
+
+jobs:
+  build-and-package:
+    name: build and package nightly release
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: macos-15-intel
+            artifact_name: macos_x86_64
+          - os: macos-15
+            artifact_name: macos_apple_silicon
+          - os: ubuntu-22.04
+            artifact_name: linux_x86_64
+          - os: ubuntu-24.04-arm
+            artifact_name: linux_arm64
+          - os: windows-2022
+            artifact_name: windows_x86_64
+          - os: windows-11-arm
+            artifact_name: windows_arm64
+
+    defaults:
+      run:
+        shell: bash
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # ratchet:actions/checkout@v4
+
+      - uses: mlugg/setup-zig@8d6198c65fb0feaa111df26e6b467fea8345e46f # ratchet:mlugg/setup-zig@v2.0.5
+        with:
+          version: 0.15.2
+          use-cache: true
+
+      # temp fix, see https://roc.zulipchat.com/#narrow/channel/395097-compiler-development/topic/CI/near/542085291
+      - name: delete llvm-config
+        if: startsWith(matrix.os, 'ubuntu') && endsWith(matrix.os, '-arm')
+        run: |
+          sudo rm /usr/lib/llvm-18/bin/llvm-config
+
+      - name: Setup MSVC (Windows)
+        if: runner.os == 'Windows'
+        uses: ilammy/msvc-dev-cmd@0b201ec74fa43914dc39ae48a89fd1d8cb592756 # ratchet:ilammy/msvc-dev-cmd@v1.13.0
+        with:
+          arch: ${{ matrix.os == 'windows-11-arm' && 'arm64' || 'x64' }}
+
+      - name: create version.txt
+        run: ./ci/write_version.sh
+
+      - name: get commit SHA
+        run: echo "SHA=$(git rev-parse --short "$GITHUB_SHA")" >> $GITHUB_ENV
+
+      - name: get date
+        run: echo "DATE=$(date "+%Y-%m-%d")" >> $GITHUB_ENV
+
+      - name: build release
+        uses: ./.github/actions/flaky-retry
+        with:
+          command: 'zig build roc -Doptimize=ReleaseFast'
+          error_string_contains: 'EndOfStream'
+          retry_count: 3
+
+      - name: build file name
+        env:
+          DATE: ${{ env.DATE }}
+          SHA: ${{ env.SHA }}
+        run: echo "RELEASE_FOLDER_NAME=new_roc_nightly-${{ matrix.artifact_name }}-$DATE-$SHA" >> $GITHUB_ENV
+
+      - name: Package release
+        run: |
+          mkdir -p ${{ env.RELEASE_FOLDER_NAME }}
+          cp ./zig-out/bin/roc ${{ env.RELEASE_FOLDER_NAME }}/
+          cp LICENSE legal_details ${{ env.RELEASE_FOLDER_NAME }}/
+
+      - name: Compress release (Unix)
+        if: runner.os != 'Windows'
+        run: tar -czvf "${{ env.RELEASE_FOLDER_NAME }}.tar.gz" ${{ env.RELEASE_FOLDER_NAME }}
+
+      - name: Compress release (Windows)
+        if: runner.os == 'Windows'
+        run: 7z a -tzip "${{ env.RELEASE_FOLDER_NAME }}.zip" ${{ env.RELEASE_FOLDER_NAME }}
+
+      - name: Calculate archive hash for security purposes (Unix)
+        if: runner.os != 'Windows'
+        run: sha256sum ${{ env.RELEASE_FOLDER_NAME }}.tar.gz
+
+      - name: Calculate archive hash for security purposes (Windows)
+        if: runner.os == 'Windows'
+        run: sha256sum ${{ env.RELEASE_FOLDER_NAME }}.zip
+
+      - name: Upload roc nightly archive (Unix)
+        if: runner.os != 'Windows'
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ env.RELEASE_FOLDER_NAME }}.tar.gz
+          path: ${{ env.RELEASE_FOLDER_NAME }}.tar.gz
+          retention-days: 4
+
+      - name: Upload roc nightly archive (Windows)
+        if: runner.os == 'Windows'
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ env.RELEASE_FOLDER_NAME }}.zip
+          path: ${{ env.RELEASE_FOLDER_NAME }}.zip
+          retention-days: 4
+
+      - name: Clean workspace for test
+        run: |
+          find . -mindepth 1 -maxdepth 1 ! -name "${{ env.RELEASE_FOLDER_NAME }}.tar.gz" ! -name "${{ env.RELEASE_FOLDER_NAME }}.zip" ! -name "src" -exec rm -rf {} +
+          find src -mindepth 1 ! -path "src/PROFILING*" -exec rm -rf {} +
+          find src/PROFILING -mindepth 1 ! -name "bench_repeated_check.roc" -exec rm -rf {} +
+
+      - name: Test archive (Unix)
+        if: runner.os != 'Windows'
+        run: |
+          tar -xzf "${{ env.RELEASE_FOLDER_NAME }}.tar.gz"
+          ./${{ env.RELEASE_FOLDER_NAME }}/roc check src/PROFILING/bench_repeated_check.roc
+
+      - name: Test archive (Windows)
+        if: runner.os == 'Windows'
+        run: |
+          7z x "${{ env.RELEASE_FOLDER_NAME }}.zip"
+          ./${{ env.RELEASE_FOLDER_NAME }}/roc check src/PROFILING/bench_repeated_check.roc

.github/workflows/nix_macos_apple_silicon.yml

@@ -13,7 +13,7 @@ jobs:
   nix-apple-silicon:
     name: nix-apple-silicon
     runs-on: [self-hosted, macOS, ARM64]
-    timeout-minutes: 90
+    timeout-minutes: 130
     steps:
       - uses: actions/checkout@v4
 

.github/workflows/nix_macos_x86_64.yml

@@ -12,7 +12,7 @@ env:
 jobs:
   nix-macos-x86-64:
     name: nix-macos-x86-64
-    runs-on: [macos-13]
+    runs-on: [macos-15-intel]
     timeout-minutes: 90
     steps:
       - uses: actions/checkout@v4

.github/workflows/test_alpha_many_os.yml

@@ -9,16 +9,16 @@ permissions: {}
 
 jobs:
   test-alpha:
-    name: test alpha macos 13 (x64), macos 14 (aarch64), ubuntu 22.04-24.04 (x64), ubuntu 22.04-24.04 (aarch64)
+    name: test alpha macos 15 intel (x64), macos 14 (aarch64), ubuntu 22.04-24.04 (x64), ubuntu 22.04-24.04 (aarch64)
     strategy:
       fail-fast: false
       matrix:
-        os: [macos-13, macos-14, ubuntu-22.04, ubuntu-24.04, ubuntu-22.04-arm, ubuntu-24.04-arm]
+        os: [macos-15-intel, macos-14, ubuntu-22.04, ubuntu-24.04, ubuntu-22.04-arm, ubuntu-24.04-arm]
     runs-on: ${{ matrix.os }}
     timeout-minutes: 90
     steps:
       - uses: actions/checkout@v4
-      - uses: mlugg/setup-zig@v1
+      - uses: mlugg/setup-zig@8d6198c65fb0feaa111df26e6b467fea8345e46f # 2.0.5
         with:
           version: 0.13.0
 
@@ -46,8 +46,8 @@ jobs:
           DOWNLOAD_URL=$(curl -sH "Authorization: token ${{ secrets.GITHUB_TOKEN }}" "$ASSETS_URL" | jq -r '.[] | select(.name | startswith("roc-linux_arm64-") and (contains("old") | not)) | .browser_download_url')
           curl -fLH "Authorization: token ${{ secrets.GITHUB_TOKEN }}" "$DOWNLOAD_URL" -o roc_release.tar.gz
 
-      - name: get the latest release archive for macos 13 (x86_64)
-        if: matrix.os == 'macos-13'
+      - name: get the latest release archive for macos 15 intel (x86_64)
+        if: matrix.os == 'macos-15'
         run: |
           ASSETS_URL="${{ steps.get_release.outputs.assets_url }}"
           DOWNLOAD_URL=$(curl -sH "Authorization: token ${{ secrets.GITHUB_TOKEN }}" "$ASSETS_URL" | jq -r '.[] | select(.name | startswith("roc-macos_x86_64-")) | .browser_download_url')

.github/workflows/test_nightly_many_os.yml

@@ -9,16 +9,16 @@ permissions: {}
 
 jobs:
   test-nightly:
-    name: test nightly macos 13 (x64), macos 14 (aarch64), ubuntu 22.04-24.04 (x64), ubuntu 22.04-24.04 (aarch64)
+    name: test nightly macos 15 intel (x64), macos 14 (aarch64), ubuntu 22.04-24.04 (x64), ubuntu 22.04-24.04 (aarch64)
     strategy:
       fail-fast: false
       matrix:
-        os: [macos-13, macos-14, ubuntu-22.04, ubuntu-24.04, ubuntu-22.04-arm, ubuntu-24.04-arm]
+        os: [macos-15-intel, macos-14, ubuntu-22.04, ubuntu-24.04, ubuntu-22.04-arm, ubuntu-24.04-arm]
     runs-on: ${{ matrix.os }}
     timeout-minutes: 90
     steps:
       - uses: actions/checkout@v4
-      - uses: mlugg/setup-zig@v1
+      - uses: mlugg/setup-zig@8d6198c65fb0feaa111df26e6b467fea8345e46f # 2.0.5
         with:
           version: 0.13.0
 
@@ -35,8 +35,8 @@ jobs:
         run: |
           curl -fL https://github.com/roc-lang/roc/releases/download/nightly/roc_nightly-linux_arm64-latest.tar.gz -o roc_release.tar.gz
 
-      - name: get the latest release archive for macos 13 (x86_64)
-        if: matrix.os == 'macos-13'
+      - name: get the latest release archive for macos 15 intel (x86_64)
+        if: matrix.os == 'macos-15-intel'
         run: curl -fL https://github.com/roc-lang/roc/releases/download/nightly/roc_nightly-macos_x86_64-latest.tar.gz -o roc_release.tar.gz
 
       - name: get the latest release archive for macos 14 (aarch64)

.github/workflows/ubuntu_x86_64.yml

@@ -29,7 +29,7 @@ jobs:
       - name: zig fmt check, zig tests
         run: cd crates/compiler/builtins/bitcode && ./run-tests.sh
 
-      - name: roc format check on builtins
+      - name: roc fmt check on builtins
         run: cargo run --locked --release format --check crates/compiler/builtins/roc
 
       - name: ensure there are no unused dependencies

.gitignore

@@ -23,6 +23,7 @@
 
 # Ignore the following directories and file extensions
 target
+!src/target
 generated-docs
 
 zig-out
@@ -32,6 +33,7 @@ zig-out
 *.rs.bk
 *.o
 *.a
+*.s
 *.so
 *.so.*
 *.obj
@@ -65,6 +67,7 @@ metadata
 .exrc
 .vimrc
 .nvimrc
+.zed/
 
 # rust cache (sccache folder)
 sccache_dir
@@ -140,3 +143,5 @@ src/snapshots/**/*.html
 
 # Local claude-code settings
 .claude/settings.local.json
+
+*.bak

.rules

@@ -1,8 +1,8 @@
 # Roc Compiler
 
-This repository contains the source code for the Roc compiler -- both the original prototype written in Rust, and the new production version written in Zig.
+This repo contains the source code for the Roc compiler and related tools. There is the original prototype written in Rust (crates folder), and the new version written in Zig.
 
-All discussion, unless otherwise explicitly requested, is regarding the new Zig production version. Therefore, ONLY files under the `src/` directory should be considered moving forward.
+All discussion, unless otherwise explicitly requested, is regarding the new version in zig. Ignore everything in the crates folder at the root of the repo, always exclude it from searches.
 
 ## Documentation
 
@@ -19,12 +19,15 @@ Roc uses two different test strategies to Verify Correctness, and Validate Behav
 1. **Verify Correctness:** Where necessary, we add unit tests to ensure low-level or specific implementation details remain correct. These are written in `.zig` files using the `test` keyword alongside the code they are testing. These tests are typically limited in scope to a single function.
 2. **Validate Behaviour:** More commonly, we add snapshot tests to provide assurance that the compiler continues to behave as expected. Snapshot files `.md` concurrently exercise many parts of the compiler by presenting the output of each stage for a given snippet of Roc code. Unlike unit tests, this has relevant debug-level information depth and multiple-compiler stage breadth.
 
-### Usage
+When you are requested to add a test without a specific location, take some time to look around and find the best location for the test in the repo.
 
-- **Run Unit Tests** `zig build test` (note `zig test` doesn't work as we have a complicated build system, therefore we use `zig build test` also for individual tests).
-- **Generate or Update All Snapshots Files** `zig build snapshot`
-- **Generate or Update Specific Snapshot File** `zig build snapshot -- <file_path>`
-- **Update EXPECTED from PROBLEMS in Snapshot File** `zig build update-expected -- <file_path>`
+### Common Commands
+
+- Run all tests: `zig build test`. To run a specific test: `zig build test -- --test-filter "name of test"`. NEVER use the standard `zig test`, it does not work with our project.
+- Generate or update all snapshots files: `zig build snapshot`
+- Generate or update specific snapshot file: `zig build snapshot -- <file_path>`
+- Update EXPECTED from PROBLEMS in snapshot file: `zig build update-expected -- <file_path>`
+- To generate (or update) AND test the snapshots: `zig build snapshot && zig build test`.
 
 ### Snapshot File Structure
 

BUILDING_FROM_SOURCE.md

@@ -6,7 +6,7 @@ If you run into any problems getting Roc built from source, please ask for help
 
 ## Recommended way
 
-[Download zig 0.14.1](https://ziglang.org/download/) and add it to your PATH.
+[Download zig 0.15.2](https://ziglang.org/download/) and add it to your PATH.
 [Search "Setting up PATH"](https://ziglang.org/learn/getting-started/) for more details.
 
 Do a test run with

CONTRIBUTING.md

@@ -33,6 +33,11 @@ zig build test
 zig build fmt
 ```
 
+To run a specific test:
+```sh
+zig build test -- --test-filter "name of test"
+```
+
 ## Contribution Tips
 
 - If you've never made a pull request on github before, [this](https://www.freecodecamp.org/news/how-to-make-your-first-pull-request-on-github-3/) will be a good place to start.

Glossary.md

@@ -522,6 +522,50 @@ Another approach, manual memory management, would allow you to produce the faste
 Reference counting implementation:
 - Old compiler: [Mono folder](crates/compiler/mono/src) (search ref)
 
+## Borrow
+
+A **borrowing** function reads its argument without affecting its reference count.
+The caller retains ownership and can continue using the value after the call.
+
+Example builtins that borrow: `strEqual`, `listLen`, `strContains`
+
+See [src/builtins/OWNERSHIP.md](src/builtins/OWNERSHIP.md) for detailed ownership semantics.
+
+## Consume
+
+A **consuming** function takes ownership of its argument. The caller transfers
+ownership to the callee and must not use the argument after the call. The function
+is responsible for cleanup (decref when done).
+
+Example builtins that consume: `strConcat`, `listConcat`, `strJoinWith`
+
+See [src/builtins/OWNERSHIP.md](src/builtins/OWNERSHIP.md) for detailed ownership semantics.
+
+## Copy-on-Write
+
+A variant of consuming where the function may return the same allocation if the
+input is unique (reference count == 1). If the input is shared, the function
+decrefs the original and allocates a new copy.
+
+Example builtins: `strWithAsciiUppercased`, `strTrim`, `listAppend`
+
+## Seamless Slice
+
+A memory optimization where the result shares underlying data with the input
+via a slice that holds a reference to the original allocation.
+
+There are two variants:
+
+1. **Borrowing seamless slice**: The builtin borrows the input and calls `incref`
+   to share the allocation. The interpreter should decref the input after the call.
+   Example: `strToUtf8`
+
+2. **Consuming seamless slice**: The builtin consumes the input and the slice
+   inherits the reference (no incref). The interpreter should NOT decref.
+   Example: `strTrim` (when it creates an offset slice)
+
+See [src/builtins/OWNERSHIP.md](src/builtins/OWNERSHIP.md) for detailed ownership semantics.
+
 ## Mutate in place
 
 TODO

build.zig.zon

@@ -1,59 +1,59 @@
 .{
     .name = .roc,
     .version = "0.0.0",
-    .minimum_zig_version = "0.14.0",
+    .minimum_zig_version = "0.15.2",
     .dependencies = .{
         .afl_kit = .{
-            .url = "git+https://github.com/bhansconnect/zig-afl-kit?ref=zig-0.14.0#9f09f8e5c29102b94d775305801315320515a2b8",
-            .hash = "afl_kit-0.1.0-uhOgGEEbAADSSVtFLWc0eoZFxVLiELWLNldB9K_f9x5L",
+            .url = "git+https://github.com/bhansconnect/zig-afl-kit?ref=main#b863c41ca47ed05729e0b509fb1926c111aa2800",
+            .hash = "afl_kit-0.1.0-NdJ3cncdAAA4154gtkRqNApovBYfOs-LWADNE-9BzzPC",
             .lazy = true,
         },
         .roc_deps_aarch64_macos_none = .{
-            .url = "https://github.com/roc-lang/roc-bootstrap/releases/download/zig-0.13.0/aarch64-macos-none.tar.xz?response-content-disposition=attachment",
-            .hash = "122044a065bfe8f6286901b110a1b0b5a764f9fcb2d1472a5eeb3423527e95419427",
+            .url = "https://github.com/roc-lang/roc-bootstrap/releases/download/zig-0.15.1/aarch64-macos-none.tar.xz?response-content-disposition=attachment",
+            .hash = "N-V-__8AAJuttw4mNdQg3ig107ac4uyAhcFPznGHmpnmX58C",
             .lazy = true,
         },
         .roc_deps_aarch64_linux_musl = .{
-            .url = "https://github.com/roc-lang/roc-bootstrap/releases/download/zig-0.13.0/aarch64-linux-musl.tar.xz?response-content-disposition=attachment",
-            .hash = "1220949c8b509cbdac3eb9de5656906ea3e777dfea9e7333f32462754cb1d7708bf2",
+            .url = "https://github.com/roc-lang/roc-bootstrap/releases/download/zig-0.15.1/aarch64-linux-musl.tar.xz?response-content-disposition=attachment",
+            .hash = "N-V-__8AABnBVRNhZGWHvWKm8PO-N4Js4Zr65NnswmkZ0nYX",
             .lazy = true,
         },
         .roc_deps_aarch64_windows_gnu = .{
-            .url = "https://github.com/roc-lang/roc-bootstrap/releases/download/zig-0.13.0/aarch64-windows-gnu.zip?response-content-disposition=attachment",
-            .hash = "1220fcd7dcb6768b907f20369ec6390adb4de41bd5c1c34dc0f1611af50a331b3e01",
+            .url = "https://github.com/roc-lang/roc-bootstrap/releases/download/zig-0.15.1/aarch64-windows-gnu.zip?response-content-disposition=attachment",
+            .hash = "N-V-__8AAEbXoBTC007kkcMVW2_P5yIKMxPKQ-L5sYEc3_qH",
             .lazy = true,
         },
         .roc_deps_arm_linux_musleabihf = .{
-            .url = "https://github.com/roc-lang/roc-bootstrap/releases/download/zig-0.13.0/arm-linux-musleabihf.tar.xz?response-content-disposition=attachment",
-            .hash = "122037ecc8654feb3d34da5424ca6a73f140dbd30475e3d4f23a6f29844e799d51a3",
+            .url = "https://github.com/roc-lang/roc-bootstrap/releases/download/zig-0.15.1/arm-linux-musleabihf.tar.xz?response-content-disposition=attachment",
+            .hash = "N-V-__8AAE9SyhMGHGnkgRenWYw-birLp2Nl-IYGqIbdlga3",
             .lazy = true,
         },
         .roc_deps_x86_linux_musl = .{
-            .url = "https://github.com/roc-lang/roc-bootstrap/releases/download/zig-0.13.0/x86-linux-musl.tar.xz?response-content-disposition=attachment",
-            .hash = "12208fbefa56ba6571399c60d96810d00a561af1926cf566e07fc32c748fbbb70ccf",
+            .url = "https://github.com/roc-lang/roc-bootstrap/releases/download/zig-0.15.1/x86-linux-musl.tar.xz?response-content-disposition=attachment",
+            .hash = "N-V-__8AAGXNmxEQQYT5QBEheV2NJzSQjwaBuUx8wj_tGdoy",
             .lazy = true,
         },
         .roc_deps_x86_64_linux_musl = .{
-            .url = "https://github.com/roc-lang/roc-bootstrap/releases/download/zig-0.13.0/x86_64-linux-musl.tar.xz?response-content-disposition=attachment",
-            .hash = "1220aff2ba681359149edde57256206d87695f84d33375082a3a442da9ba8dfc177f",
+            .url = "https://github.com/roc-lang/roc-bootstrap/releases/download/zig-0.15.1/x86_64-linux-musl.tar.xz?response-content-disposition=attachment",
+            .hash = "N-V-__8AAL1yjxS0Lef6Fv5mMGaqNa0rGcPJxOftYK0NYuJu",
             .lazy = true,
         },
         .roc_deps_x86_64_macos_none = .{
-            .url = "https://github.com/roc-lang/roc-bootstrap/releases/download/zig-0.13.0/x86_64-macos-none.tar.xz?response-content-disposition=attachment",
-            .hash = "1220a0714d1cd12799885b5217252511012cca5d2d679d318520515d2487b80533db",
+            .url = "https://github.com/roc-lang/roc-bootstrap/releases/download/zig-0.15.1/x86_64-macos-none.tar.xz?response-content-disposition=attachment",
+            .hash = "N-V-__8AAInnSA9gFeMzlB67m7Nu-NYBUOXqDrzYmYgatUHk",
             .lazy = true,
         },
         .roc_deps_x86_64_windows_gnu = .{
-            .url = "https://github.com/roc-lang/roc-bootstrap/releases/download/zig-0.13.0/x86_64-windows-gnu.zip?response-content-disposition=attachment",
-            .hash = "122070972a9f996fc1a167b78d3a6a8c10f85349f9369383f5e26af1c5eed3cc41b0",
+            .url = "https://github.com/roc-lang/roc-bootstrap/releases/download/zig-0.15.1/x86_64-windows-gnu.zip?response-content-disposition=attachment",
+            .hash = "N-V-__8AANpEpBfszYPGDvz9XJK8VRBNG7eQzzK1iNSlkdVG",
             .lazy = true,
         },
         .bytebox = .{
-            .url = "git+https://github.com/lukewilliamboswell/bytebox.git#694b53b748dba8078751a8836f1b3cead792dcca",
-            .hash = "bytebox-0.0.1-SXc2sSfbDgCLYYKaTGdlU4Dl3ncfvesPax1bkLHAlCg6",
+            .url = "git+https://github.com/rdunnington/bytebox#5c8753ba11c394e4d642dddbb459edcd7c97ac26",
+            .hash = "bytebox-0.0.1-SXc2seA2DwAUHbrqTMz_mAQQGqO0EVPYmZ89YZn4KsTi",
         },
         .zstd = .{
-            .url = "git+https://github.com/allyourcodebase/zstd.git#1.5.7",
+            .url = "git+https://github.com/allyourcodebase/zstd.git#01327d49cbc56dc24c20a167bb0055d7fc23de84", // 1.5.7
             .hash = "1220b9feb4652a62df95843e78a5db008401599366989b52d7cab421bf6263fa73d0",
         },
     },

ci/check_test_wiring.zig

@@ -0,0 +1,417 @@
+const std = @import("std");
+
+const Allocator = std.mem.Allocator;
+const Ast = std.zig.Ast;
+const PathList = std.ArrayList([]u8);
+
+const max_file_bytes: usize = 16 * 1024 * 1024;
+
+const test_file_exclusions = [_][]const u8{
+    // TODO Fixing in progress...
+    "src/cli/test_docs.zig",
+};
+
+const TermColor = struct {
+    pub const red = "\x1b[0;31m";
+    pub const green = "\x1b[0;32m";
+    pub const yellow = "\x1b[1;33m";
+    pub const reset = "\x1b[0m";
+};
+
+pub fn main() !void {
+    var gpa_impl = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa_impl.deinit();
+    const gpa = gpa_impl.allocator();
+
+    var stdout_buffer: [4096]u8 = undefined;
+    var stdout_state = std.fs.File.stdout().writer(&stdout_buffer);
+    const stdout = &stdout_state.interface;
+
+    try stdout.print("Checking test wiring in src/ directory...\n\n", .{});
+
+    try stdout.print("Step 1: Finding all potential test files...\n", .{});
+    var test_files = PathList{};
+    defer freePathList(&test_files, gpa);
+
+    var mod_files = PathList{};
+    defer freePathList(&mod_files, gpa);
+
+    try walkTree(gpa, "src", &test_files, &mod_files);
+    try stdout.print("Found {d} potential test files\n\n", .{test_files.items.len});
+
+    // Some tests are wired through build.zig rather than mod.zig files.
+    // For example, the CLI tests are driven via src/cli/main.zig and
+    // src/cli/test/roc_subcommands.zig test roots.
+    //
+    // To avoid false positives, we:
+    // - Treat src/cli/main.zig as an additional aggregator when scanning @import()
+    //   statements for wired test files.
+    // - Treat src/cli/test/fx_platform_test.zig as an aggregator since it imports
+    //   fx_test_specs.zig which contains shared test specifications.
+    if (fileExists("src/cli/main.zig")) {
+        try mod_files.append(gpa, try gpa.dupe(u8, "src/cli/main.zig"));
+    }
+    if (fileExists("src/cli/test/fx_platform_test.zig")) {
+        try mod_files.append(gpa, try gpa.dupe(u8, "src/cli/test/fx_platform_test.zig"));
+    }
+    if (fileExists("src/cli/test/test_runner.zig")) {
+        try mod_files.append(gpa, try gpa.dupe(u8, "src/cli/test/test_runner.zig"));
+    }
+    if (fileExists("src/cli/cli_error.zig")) {
+        try mod_files.append(gpa, try gpa.dupe(u8, "src/cli/cli_error.zig"));
+    }
+
+    if (test_files.items.len == 0) {
+        try stdout.print("{s}[OK]{s} No test files found to check\n", .{ TermColor.green, TermColor.reset });
+        try stdout.flush();
+        return;
+    }
+
+    try stdout.print("Step 2: Extracting test references from mod.zig files...\n", .{});
+    var referenced = std.StringHashMap(void).init(gpa);
+    defer {
+        var it = referenced.keyIterator();
+        while (it.next()) |key| {
+            gpa.free(@constCast(key.*));
+        }
+        referenced.deinit();
+    }
+
+    for (mod_files.items) |mod_path| {
+        try collectModImports(gpa, mod_path, &referenced);
+    }
+    // Also treat test roots declared in build.zig (b.addTest root_source_file)
+    // as valid wiring for the corresponding files (e.g. src/cli/main.zig and
+    // src/cli/test/roc_subcommands.zig).
+    try markBuildTestRootsAsReferenced(gpa, &referenced);
+
+    try stdout.print(
+        "Found {d} file references in mod.zig files and build.zig test roots\n\n",
+        .{referenced.count()},
+    );
+
+    try stdout.print("Step 3: Checking if all test files are properly wired...\n\n", .{});
+    var unwired = PathList{};
+    defer freePathList(&unwired, gpa);
+
+    for (test_files.items) |test_path| {
+        const key: []const u8 = test_path;
+        if (!referenced.contains(key)) {
+            try unwired.append(gpa, try gpa.dupe(u8, key));
+        }
+    }
+
+    if (unwired.items.len > 0) {
+        std.mem.sort([]u8, unwired.items, {}, lessThanPath);
+        try stdout.print(
+            "{s}[ERR]{s} Found {d} test file(s) that are NOT wired through mod.zig:\n\n",
+            .{ TermColor.red, TermColor.reset, unwired.items.len },
+        );
+
+        for (unwired.items) |path| {
+            const path_text: []const u8 = path;
+            try stdout.print("  {s}[MISSING]{s} {s}\n", .{ TermColor.red, TermColor.reset, path_text });
+            try printSuggestion(gpa, stdout, path_text);
+            try stdout.print("\n", .{});
+        }
+
+        try stdout.print("{s}[ERR]{s} Test wiring issues found. Please fix the issues above.\n\n", .{
+            TermColor.red,
+            TermColor.reset,
+        });
+        try stdout.print("To fix:\n", .{});
+        try stdout.print("1. Add missing std.testing.refAllDecls() calls to the appropriate mod.zig files\n", .{});
+        try stdout.print("2. Ensure all modules with tests are listed in src/build/modules.zig test_configs\n\n", .{});
+    } else {
+        try stdout.print("{s}[OK]{s} All tests are properly wired!\n\n", .{ TermColor.green, TermColor.reset });
+    }
+
+    if (unwired.items.len > 0) {
+        try stdout.flush();
+        std.process.exit(1);
+    }
+
+    try stdout.flush();
+}
+
+/// Normalize path separators to forward slashes for consistent cross-platform comparison.
+/// This is important because:
+/// 1. Zig @import paths always use forward slashes
+/// 2. We need consistent path comparison between walked files and mod.zig imports
+fn normalizePath(allocator: Allocator, path: []u8) ![]u8 {
+    if (comptime @import("builtin").os.tag == .windows) {
+        const normalized = try allocator.dupe(u8, path);
+        for (normalized) |*c| {
+            if (c.* == '\\') c.* = '/';
+        }
+        allocator.free(path);
+        return normalized;
+    }
+    return path;
+}
+
+fn walkTree(
+    allocator: Allocator,
+    dir_path: []const u8,
+    test_files: *PathList,
+    mod_files: *PathList,
+) !void {
+    var dir = try std.fs.cwd().openDir(dir_path, .{ .iterate = true });
+    defer dir.close();
+
+    var it = dir.iterate();
+    while (try it.next()) |entry| {
+        if (entry.kind == .sym_link) continue;
+
+        const joined_path = try std.fs.path.join(allocator, &.{ dir_path, entry.name });
+        const next_path = try normalizePath(allocator, joined_path);
+
+        switch (entry.kind) {
+            .directory => {
+                defer allocator.free(next_path);
+                try walkTree(allocator, next_path, test_files, mod_files);
+            },
+            .file => {
+                try handleFile(allocator, next_path, entry.name, test_files, mod_files);
+            },
+            else => allocator.free(next_path),
+        }
+    }
+}
+
+fn handleFile(
+    allocator: Allocator,
+    path: []u8,
+    file_name: []const u8,
+    test_files: *PathList,
+    mod_files: *PathList,
+) !void {
+    if (!std.mem.endsWith(u8, file_name, ".zig")) {
+        allocator.free(path);
+        return;
+    }
+
+    if (std.mem.eql(u8, file_name, "mod.zig")) {
+        try mod_files.append(allocator, path);
+        return;
+    }
+
+    if (shouldSkipTestFile(path)) {
+        allocator.free(path);
+        return;
+    }
+
+    if (try fileHasTestDecl(allocator, path)) {
+        try test_files.append(allocator, path);
+        return;
+    }
+
+    allocator.free(path);
+}
+
+fn shouldSkipTestFile(path: []const u8) bool {
+    for (test_file_exclusions) |excluded| {
+        if (std.mem.eql(u8, path, excluded)) return true;
+    }
+    return false;
+}
+
+fn fileHasTestDecl(allocator: Allocator, path: []const u8) !bool {
+    const source = try readSourceFile(allocator, path);
+    defer allocator.free(source);
+    var tree = try Ast.parse(allocator, source, .zig);
+    defer tree.deinit(allocator);
+
+    const tags = tree.nodes.items(.tag);
+    for (tags) |tag| {
+        if (tag == .test_decl) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+fn readSourceFile(allocator: Allocator, path: []const u8) ![:0]u8 {
+    return try std.fs.cwd().readFileAllocOptions(
+        allocator,
+        path,
+        max_file_bytes,
+        null,
+        std.mem.Alignment.of(u8),
+        0,
+    );
+}
+
+fn collectModImports(
+    allocator: Allocator,
+    mod_path: []const u8,
+    referenced: *std.StringHashMap(void),
+) !void {
+    const source = try readSourceFile(allocator, mod_path);
+    defer allocator.free(source);
+
+    var tree = try Ast.parse(allocator, source, .zig);
+    defer tree.deinit(allocator);
+
+    const tags = tree.tokens.items(.tag);
+    var idx: usize = 0;
+    while (idx < tree.tokens.len) : (idx += 1) {
+        if (tags[idx] != .builtin) continue;
+        const token_index = @as(Ast.TokenIndex, @intCast(idx));
+        if (!std.mem.eql(u8, tree.tokenSlice(token_index), "@import")) continue;
+
+        const import_path = try extractImportPath(allocator, &tree, idx) orelse continue;
+        defer allocator.free(import_path);
+
+        if (!std.mem.endsWith(u8, import_path, ".zig")) continue;
+
+        const resolved = try resolveImportPath(allocator, mod_path, import_path);
+        if (referenced.contains(resolved)) {
+            allocator.free(resolved);
+        } else {
+            try referenced.put(resolved, {});
+        }
+    }
+}
+
+fn extractImportPath(
+    allocator: Allocator,
+    tree: *const Ast,
+    builtin_token_index: usize,
+) !?[]u8 {
+    var cursor = builtin_token_index + 1;
+    if (cursor >= tree.tokens.len) return null;
+    if (tree.tokenTag(@intCast(cursor)) != .l_paren) return null;
+
+    cursor += 1;
+    if (cursor >= tree.tokens.len) return null;
+    const str_token_index = @as(Ast.TokenIndex, @intCast(cursor));
+    const tag = tree.tokenTag(str_token_index);
+    if (tag != .string_literal) return null;
+
+    const literal = tree.tokenSlice(str_token_index);
+    if (literal.len < 2) return null;
+    return try allocator.dupe(u8, literal[1 .. literal.len - 1]);
+}
+
+fn resolveImportPath(
+    allocator: Allocator,
+    mod_path: []const u8,
+    import_path: []const u8,
+) ![]u8 {
+    const mod_dir = std.fs.path.dirname(mod_path) orelse ".";
+    return std.fs.path.resolvePosix(allocator, &.{ mod_dir, import_path });
+}
+
+/// Mark files that are used as test roots in build.zig as "wired".
+///
+/// In addition to mod.zig imports, some tests are hooked up via explicit
+/// `b.addTest` calls in build.zig (for example the CLI tests). Any Zig
+/// file that is used as a `root_source_file = b.path("...")` in such a
+/// test configuration should not be reported as missing wiring.
+fn markBuildTestRootsAsReferenced(
+    allocator: Allocator,
+    referenced: *std.StringHashMap(void),
+) !void {
+    const build_path = "build.zig";
+    if (!fileExists(build_path)) return;
+
+    const source = try readSourceFile(allocator, build_path);
+    defer allocator.free(source);
+
+    const pattern = ".root_source_file = b.path(\"";
+    var search_index: usize = 0;
+
+    while (std.mem.indexOfPos(u8, source, search_index, pattern)) |match_pos| {
+        const literal_start = match_pos + pattern.len;
+        var cursor = literal_start;
+
+        // Find end of the string literal.
+        while (cursor < source.len and source[cursor] != '"') : (cursor += 1) {}
+        if (cursor >= source.len) break;
+
+        const rel_path = source[literal_start..cursor];
+
+        // Only consider Zig source files under src/ as potential test roots.
+        if (!std.mem.endsWith(u8, rel_path, ".zig")) {
+            search_index = cursor + 1;
+            continue;
+        }
+        if (!std.mem.startsWith(u8, rel_path, "src/")) {
+            search_index = cursor + 1;
+            continue;
+        }
+
+        const key = try allocator.dupe(u8, rel_path);
+        if (referenced.contains(key)) {
+            allocator.free(key);
+        } else {
+            try referenced.put(key, {});
+        }
+
+        search_index = cursor + 1;
+    }
+}
+
+fn lessThanPath(_: void, lhs: []u8, rhs: []u8) bool {
+    const l: []const u8 = lhs;
+    const r: []const u8 = rhs;
+    return std.mem.lessThan(u8, l, r);
+}
+
+fn printSuggestion(
+    allocator: Allocator,
+    writer: anytype,
+    test_path: []const u8,
+) !void {
+    const maybe_mod = try findNearestMod(allocator, test_path);
+    if (maybe_mod) |mod_path| {
+        defer allocator.free(mod_path);
+
+        const mod_dir = std.fs.path.dirname(mod_path) orelse ".";
+        const relative = try std.fs.path.relativePosix(allocator, mod_dir, test_path);
+        defer allocator.free(relative);
+
+        try writer.print("    {s}[HINT]{s} Should be added to {s}\n", .{
+            TermColor.yellow,
+            TermColor.reset,
+            mod_path,
+        });
+        try writer.print(
+            "    {s}[HINT]{s} Add: std.testing.refAllDecls(@import(\"{s}\"));\n",
+            .{ TermColor.yellow, TermColor.reset, relative },
+        );
+    } else {
+        try writer.print(
+            "    {s}[HINT]{s} No nearby mod.zig found for this test file\n",
+            .{ TermColor.yellow, TermColor.reset },
+        );
+    }
+}
+
+fn findNearestMod(allocator: Allocator, file_path: []const u8) !?[]u8 {
+    var current_dir_opt = std.fs.path.dirname(file_path);
+    while (current_dir_opt) |current_dir| {
+        const joined = try std.fs.path.join(allocator, &.{ current_dir, "mod.zig" });
+        const candidate = try normalizePath(allocator, joined);
+        if (fileExists(candidate)) {
+            return candidate;
+        }
+        allocator.free(candidate);
+        current_dir_opt = std.fs.path.dirname(current_dir);
+    }
+    return null;
+}
+
+fn fileExists(path: []const u8) bool {
+    _ = std.fs.cwd().statFile(path) catch return false;
+    return true;
+}
+
+fn freePathList(list: *PathList, allocator: Allocator) void {
+    for (list.items) |path| {
+        allocator.free(path);
+    }
+    list.deinit(allocator);
+}

ci/custom_valgrind.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+
+# Get the directory where this script is located
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+valgrind \
+  --suppressions="$SCRIPT_DIR/valgrind.supp" \
+  --leak-check=full \
+  --error-exitcode=1 \
+  --errors-for-leak-kinds=definite,possible \
+  "$@" 2>&1 | grep -v "Warning: DWARF2 reader: Badly formed extended line op encountered"
+exit ${PIPESTATUS[0]}

ci/glossary-link-checker.roc

@@ -1,8 +1,8 @@
-app [main!] { cli: platform "https://github.com/roc-lang/basic-cli/releases/download/0.19.0/Hj-J_zxz7V9YurCSTFcFdu6cQJie4guzsPMUi5kBYUk.tar.br" }
+app [main!] { cli: platform "https://github.com/roc-lang/basic-cli/releases/download/0.20.0/X73hGh05nNTkDHU06FHC0YfFaQB1pimX7gncRcao5mU.tar.br" }
 
 import cli.Stdout
 import cli.Stderr
-import cli.Path
+import cli.File
 import "../Glossary.md" as glossary_as_str : Str
 
 # This script checks if all markdown links that point to files or dirs are valid for the file Glossary.md
@@ -81,12 +81,8 @@ check_link! = |link_str|
         # TODO check links to other markdown headers as well, e.g. #tokenization
         Ok({})
     else
-        path = Path.from_str(link_str)
+        _ = File.exists!(link_str) ? |_| BadLink(link_str)
 
-        when Path.type!(path) is
-            Ok(_) ->
-                Ok({})
-            Err(_) ->
-                Err(BadLink(link_str))
+        Ok({})
         
     

ci/retry_flaky.sh

@@ -1,14 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-
-for i in {1..3}; do
-  output="$("$@" 2>&1)" && break
-  if echo "$output" | grep -q "error: bad HTTP response code: '500 Internal Server Error'"; then
-    echo "Retrying due to HTTP 500 error ($i/3)..."
-    sleep 2
-  else
-    echo "$output"
-    exit 1
-  fi
-done

ci/valgrind.supp

@@ -0,0 +1,57 @@
+# Valgrind suppression file for Roc
+#
+# These suppressions address false positives from the interaction between
+# LLVM and musl's mallocng allocator. The uninitialised values originate
+# from LLVM code (DebugCounter::registerCounter and scc_iterator::DFSVisitChildren)
+# and propagate through to musl's malloc where they trigger conditional jumps
+# in the enframe function. These are safe because:
+# 1. musl's mallocng is designed to handle these patterns
+# 2. Fresh mmap'd memory will be zeroed, reused memory has valid values
+# 3. The program runs correctly and produces correct results
+
+# Suppress uninitialised value errors in musl's malloc enframe function
+# when called from LLVM code paths
+{
+   musl-mallocng-enframe-llvm-global-init
+   Memcheck:Cond
+   fun:enframe
+   fun:__libc_malloc_impl
+   ...
+   fun:_GLOBAL__sub_I_*
+}
+
+{
+   musl-mallocng-enframe-llvm-allocate
+   Memcheck:Cond
+   fun:enframe
+   fun:__libc_malloc_impl
+   fun:aligned_alloc
+   ...
+   fun:*llvm*
+}
+
+{
+   musl-mallocng-enframe-lld
+   Memcheck:Cond
+   fun:enframe
+   fun:__libc_malloc_impl
+   ...
+   fun:*lld*
+}
+
+{
+   musl-mallocng-enframe-smallvector
+   Memcheck:Cond
+   fun:enframe
+   fun:__libc_malloc_impl
+   fun:*SmallVector*
+}
+
+{
+   musl-mallocng-enframe-llvm-mcregisterinfo
+   Memcheck:Cond
+   fun:enframe
+   fun:__libc_malloc_impl
+   ...
+   fun:*llvm*MCRegisterInfo*
+}

ci/zig_lints.sh

@@ -1,64 +0,0 @@
-#!/usr/bin/env bash
-
-# https://vaneyckt.io/posts/safer_bash_scripts_with_set_euxo_pipefail/
-set -euo pipefail
-
-# Check for pub declarations without doc comments
-
-found_errors=false
-
-# Lint all zig files in src/
-while read -r file; do
-    errors=$(awk '
-        /^pub / {
-            if (prev !~ /^\/\/\//) {
-                # Skip doc comment requirements for init, deinit, @import, and pub const re-exports
-                if ($0 !~ /pub.*fn init\(/ &&
-                    $0 !~ /pub.*fn deinit/ &&
-                    $0 !~ /pub.*@import/ &&
-                    $0 !~ /pub.*const.*=[[:space:]]*[a-z][^[:space:]]*\.[^([:space:]]*;/) {
-                    print FILENAME ":" FNR ": pub declaration without doc comment `///`"
-                }
-            }
-        }
-        { prev = $0 }
-    ' "$file")
-    if [[ -n "$errors" ]]; then
-        echo "$errors"
-        found_errors=true
-    fi
-done < <(find src -type f -name "*.zig" -not -path "*/.zig-cache/*")
-
-if [[ "$found_errors" == true ]]; then
-    echo ""
-    echo "Please add doc comments to the spots listed above, they make the code easier to understand for everyone."
-    echo ""
-    exit 1
-fi
-
-# Check for top level comments in new Zig files
-
-NEW_ZIG_FILES=$(git diff --name-only --diff-filter=A origin/main HEAD -- | grep 'src/' | grep '\.zig$' || echo "")
-
-if [ -z "$NEW_ZIG_FILES" ]; then
-    # No new Zig files found
-    exit 0
-fi
-
-FAILED_FILES=""
-
-for FILE in $NEW_ZIG_FILES; do
-    if ! grep -q "//!" "$FILE"; then
-    echo "Error: $FILE is missing top level comment (//!)"
-    FAILED_FILES="$FAILED_FILES $FILE"
-    fi
-done
-
-if [ -n "$FAILED_FILES" ]; then
-    echo ""
-    echo "The following files are missing a top level comment:"
-    echo "    $FAILED_FILES"
-    echo ""
-    echo "Add a //! comment BEFORE any other code that explains the purpose of the file."
-    exit 1
-fi

ci/zig_lints.zig

@@ -0,0 +1,364 @@
+const std = @import("std");
+
+const Allocator = std.mem.Allocator;
+const PathList = std.ArrayList([]u8);
+
+const max_file_bytes: usize = 16 * 1024 * 1024;
+
+const TermColor = struct {
+    pub const red = "\x1b[0;31m";
+    pub const green = "\x1b[0;32m";
+    pub const reset = "\x1b[0m";
+};
+
+pub fn main() !void {
+    var gpa_impl = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa_impl.deinit();
+    const gpa = gpa_impl.allocator();
+
+    var stdout_buffer: [4096]u8 = undefined;
+    var stdout_state = std.fs.File.stdout().writer(&stdout_buffer);
+    const stdout = &stdout_state.interface;
+
+    var found_errors = false;
+
+    // Lint 1: Check for separator comments (// ====)
+    try stdout.print("Checking for separator comments (// ====)...\n", .{});
+
+    {
+        var zig_files = PathList{};
+        defer freePathList(&zig_files, gpa);
+
+        // Scan src/, build.zig, and test/ (not ci/ since zig_lints.zig mentions the pattern)
+        try walkTree(gpa, "src", &zig_files);
+        try walkTree(gpa, "test", &zig_files);
+
+        // Add build.zig directly
+        try zig_files.append(gpa, try gpa.dupe(u8, "build.zig"));
+
+        for (zig_files.items) |file_path| {
+            const errors = try checkSeparatorComments(gpa, file_path);
+            defer gpa.free(errors);
+
+            if (errors.len > 0) {
+                try stdout.print("{s}", .{errors});
+                found_errors = true;
+            }
+        }
+
+        if (found_errors) {
+            try stdout.print("\n", .{});
+            try stdout.print("Separator comments like '// ====' are not allowed. Please delete these lines.\n", .{});
+            try stdout.print("\n", .{});
+            try stdout.flush();
+            std.process.exit(1);
+        }
+    }
+
+    // Lint 2: Check for pub declarations without doc comments
+    try stdout.print("Checking for pub declarations without doc comments...\n", .{});
+
+    var zig_files = PathList{};
+    defer freePathList(&zig_files, gpa);
+
+    try walkTree(gpa, "src", &zig_files);
+
+    for (zig_files.items) |file_path| {
+        const errors = try checkPubDocComments(gpa, file_path);
+        defer gpa.free(errors);
+
+        if (errors.len > 0) {
+            try stdout.print("{s}", .{errors});
+            found_errors = true;
+        }
+    }
+
+    if (found_errors) {
+        try stdout.print("\n", .{});
+        try stdout.print("Please add doc comments to the spots listed above, they make the code easier to understand for everyone.\n", .{});
+        try stdout.print("\n", .{});
+        try stdout.flush();
+        std.process.exit(1);
+    }
+
+    // Lint 2: Check for top level comments in new Zig files
+    try stdout.print("Checking for top level comments in new Zig files...\n", .{});
+
+    var new_zig_files = try getNewZigFiles(gpa);
+    defer {
+        for (new_zig_files.items) |path| {
+            gpa.free(path);
+        }
+        new_zig_files.deinit(gpa);
+    }
+
+    if (new_zig_files.items.len == 0) {
+        try stdout.print("{s}[OK]{s} All lints passed!\n", .{ TermColor.green, TermColor.reset });
+        try stdout.flush();
+        return;
+    }
+
+    var failed_files = PathList{};
+    defer freePathList(&failed_files, gpa);
+
+    for (new_zig_files.items) |file_path| {
+        if (!try fileHasTopLevelComment(gpa, file_path)) {
+            try stdout.print("Error: {s} is missing top level comment (//!)\n", .{file_path});
+            try failed_files.append(gpa, try gpa.dupe(u8, file_path));
+        }
+    }
+
+    if (failed_files.items.len > 0) {
+        try stdout.print("\n", .{});
+        try stdout.print("The following files are missing a top level comment:\n", .{});
+        for (failed_files.items) |path| {
+            try stdout.print("    {s}\n", .{path});
+        }
+        try stdout.print("\n", .{});
+        try stdout.print("Add a //! comment that explains the purpose of the file BEFORE any other code.\n", .{});
+        try stdout.flush();
+        std.process.exit(1);
+    }
+
+    try stdout.print("{s}[OK]{s} All lints passed!\n", .{ TermColor.green, TermColor.reset });
+    try stdout.flush();
+}
+
+fn walkTree(allocator: Allocator, dir_path: []const u8, zig_files: *PathList) !void {
+    var dir = try std.fs.cwd().openDir(dir_path, .{ .iterate = true });
+    defer dir.close();
+
+    var it = dir.iterate();
+    while (try it.next()) |entry| {
+        if (entry.kind == .sym_link) continue;
+
+        const next_path = try std.fs.path.join(allocator, &.{ dir_path, entry.name });
+
+        switch (entry.kind) {
+            .directory => {
+                // Skip .zig-cache directories
+                if (std.mem.eql(u8, entry.name, ".zig-cache")) {
+                    allocator.free(next_path);
+                    continue;
+                }
+                defer allocator.free(next_path);
+                try walkTree(allocator, next_path, zig_files);
+            },
+            .file => {
+                if (std.mem.endsWith(u8, entry.name, ".zig")) {
+                    try zig_files.append(allocator, next_path);
+                } else {
+                    allocator.free(next_path);
+                }
+            },
+            else => allocator.free(next_path),
+        }
+    }
+}
+
+fn checkSeparatorComments(allocator: Allocator, file_path: []const u8) ![]u8 {
+    const source = readSourceFile(allocator, file_path) catch |err| {
+        // Skip files we can't read
+        if (err == error.FileNotFound) return try allocator.dupe(u8, "");
+        return err;
+    };
+    defer allocator.free(source);
+
+    var errors = std.ArrayList(u8){};
+    errdefer errors.deinit(allocator);
+
+    var line_num: usize = 1;
+    var lines = std.mem.splitScalar(u8, source, '\n');
+
+    while (lines.next()) |line| {
+        defer line_num += 1;
+
+        // Trim leading whitespace
+        const trimmed = std.mem.trimLeft(u8, line, " \t");
+
+        // Check if line starts with // and is a separator comment
+        // Separator comments are lines like "// ====" or "// ==== Section ===="
+        // We detect them by checking if, after the //, the line consists only of
+        // whitespace, equals signs, and letters (for section titles)
+        if (std.mem.startsWith(u8, trimmed, "//")) {
+            const after_slashes = trimmed[2..];
+            if (isSeparatorComment(after_slashes)) {
+                try errors.writer(allocator).print("{s}:{d}: separator comment '// ====' not allowed\n", .{ file_path, line_num });
+            }
+        }
+    }
+
+    return errors.toOwnedSlice(allocator);
+}
+
+/// Checks if a line (after the //) is a separator comment.
+/// Separator comments are lines consisting only of equals signs (with optional
+/// whitespace and a section title between them).
+/// Examples that should match:
+///   " ===="
+///   " ===== Section ====="
+///   " ==== Title ===="
+/// Examples that should NOT match:
+///   " 2. Stdout contains "=====""
+///   " This is a normal comment about ===="
+fn isSeparatorComment(after_slashes: []const u8) bool {
+    // Must contain ====
+    if (std.mem.indexOf(u8, after_slashes, "====") == null) return false;
+
+    // Trim whitespace
+    const content = std.mem.trim(u8, after_slashes, " \t");
+    if (content.len == 0) return false;
+
+    // Must start with ====
+    if (!std.mem.startsWith(u8, content, "====")) return false;
+
+    // Find where the leading equals end
+    var i: usize = 0;
+    while (i < content.len and content[i] == '=') : (i += 1) {}
+
+    // Everything after leading equals should be whitespace, letters, or trailing equals
+    while (i < content.len) : (i += 1) {
+        const c = content[i];
+        if (c == '=' or c == ' ' or c == '\t' or (c >= 'A' and c <= 'Z') or (c >= 'a' and c <= 'z')) {
+            continue;
+        }
+        // Found a character that's not allowed in separator comments
+        return false;
+    }
+
+    return true;
+}
+
+fn checkPubDocComments(allocator: Allocator, file_path: []const u8) ![]u8 {
+    const source = readSourceFile(allocator, file_path) catch |err| {
+        // Skip files we can't read
+        if (err == error.FileNotFound) return try allocator.dupe(u8, "");
+        return err;
+    };
+    defer allocator.free(source);
+
+    var errors = std.ArrayList(u8){};
+    errdefer errors.deinit(allocator);
+
+    var line_num: usize = 1;
+    var prev_line: []const u8 = "";
+    var lines = std.mem.splitScalar(u8, source, '\n');
+
+    while (lines.next()) |line| {
+        defer {
+            prev_line = line;
+            line_num += 1;
+        }
+
+        // Check if line starts with "pub " (no leading whitespace - only top-level declarations)
+        if (!std.mem.startsWith(u8, line, "pub ")) continue;
+
+        // Check if previous line is a doc comment (allow indented doc comments)
+        const prev_trimmed = std.mem.trimLeft(u8, prev_line, " \t");
+        if (std.mem.startsWith(u8, prev_trimmed, "///")) continue;
+
+        // Skip exceptions: init, deinit, @import, and pub const re-exports
+        // Note: "pub.*fn init\(" in bash matches "init" anywhere in function name
+        if (std.mem.indexOf(u8, line, "fn init") != null) continue;
+        if (std.mem.indexOf(u8, line, "fn deinit") != null) continue;
+        if (std.mem.indexOf(u8, line, "@import") != null) continue;
+
+        // Check for pub const re-exports (e.g., "pub const Foo = bar.Baz;")
+        if (isReExport(line)) continue;
+
+        try errors.writer(allocator).print("{s}:{d}: pub declaration without doc comment `///`\n", .{ file_path, line_num });
+    }
+
+    return errors.toOwnedSlice(allocator);
+}
+
+fn isReExport(line: []const u8) bool {
+    // Match pattern: pub const X = lowercase.something;
+    // This detects re-exports like "pub const Foo = bar.Baz;"
+    if (!std.mem.startsWith(u8, line, "pub const ")) return false;
+
+    // Find the '=' sign
+    const eq_pos = std.mem.indexOf(u8, line, "=") orelse return false;
+    const after_eq = std.mem.trimLeft(u8, line[eq_pos + 1 ..], " \t");
+
+    // Check if it starts with a lowercase letter (module reference)
+    if (after_eq.len == 0) return false;
+    const first_char = after_eq[0];
+    if (first_char < 'a' or first_char > 'z') return false;
+
+    // Check if it contains a dot and ends with semicolon (but not a function call)
+    if (std.mem.indexOf(u8, after_eq, ".") == null) return false;
+    if (std.mem.indexOf(u8, after_eq, "(") != null) return false;
+    if (!std.mem.endsWith(u8, std.mem.trimRight(u8, after_eq, " \t"), ";")) return false;
+
+    return true;
+}
+
+fn getNewZigFiles(allocator: Allocator) !PathList {
+    var result = PathList{};
+    errdefer {
+        for (result.items) |path| {
+            allocator.free(path);
+        }
+        result.deinit(allocator);
+    }
+
+    // Run git diff to get new files
+    var child = std.process.Child.init(&.{ "git", "diff", "--name-only", "--diff-filter=A", "origin/main", "HEAD", "--", "src/" }, allocator);
+    child.stdout_behavior = .Pipe;
+    child.stderr_behavior = .Ignore;
+
+    _ = child.spawn() catch {
+        // Git not available or not in a repo - return empty list
+        return result;
+    };
+
+    const stdout = child.stdout orelse return result;
+    const output = stdout.readToEndAlloc(allocator, max_file_bytes) catch return result;
+    defer allocator.free(output);
+
+    const term = child.wait() catch return result;
+    if (term.Exited != 0) return result;
+
+    // Parse output line by line
+    var lines = std.mem.splitScalar(u8, output, '\n');
+    while (lines.next()) |line| {
+        if (line.len == 0) continue;
+        if (!std.mem.endsWith(u8, line, ".zig")) continue;
+
+        try result.append(allocator, try allocator.dupe(u8, line));
+    }
+
+    return result;
+}
+
+fn fileHasTopLevelComment(allocator: Allocator, file_path: []const u8) !bool {
+    const source = readSourceFile(allocator, file_path) catch |err| {
+        if (err == error.FileNotFound) {
+            // File was deleted but still shows in git diff - skip it
+            return true;
+        }
+        return err;
+    };
+    defer allocator.free(source);
+
+    return std.mem.indexOf(u8, source, "//!") != null;
+}
+
+fn readSourceFile(allocator: Allocator, path: []const u8) ![:0]u8 {
+    return try std.fs.cwd().readFileAllocOptions(
+        allocator,
+        path,
+        max_file_bytes,
+        null,
+        std.mem.Alignment.of(u8),
+        0,
+    );
+}
+
+fn freePathList(list: *PathList, allocator: Allocator) void {
+    for (list.items) |path| {
+        allocator.free(path);
+    }
+    list.deinit(allocator);
+}

crates/cli/tests/cli_tests.rs

@@ -1111,6 +1111,20 @@ mod cli_tests {
             let cli_dev_out = cli_dev.run();
             cli_dev_out.assert_clean_success();
         }
+
+        #[test]
+        #[cfg_attr(windows, ignore)]
+        fn effectful_join_map() {
+            build_platform_host();
+
+            let cli_dev = ExecCli::new(
+                roc_cli::CMD_DEV,
+                file_from_root("crates/cli/tests/test-projects/effectful", "join_map.roc"),
+            );
+
+            let cli_dev_out = cli_dev.run();
+            cli_dev_out.assert_clean_success();
+        }
     }
 
     // this is for testing the benchmarks (on small inputs), to perform proper benchmarks see crates/cli/benches/README.md

crates/cli/tests/test-projects/effectful/join_map.roc

@@ -0,0 +1,21 @@
+app [main!] { pf: platform "../test-platform-effects-zig/main.roc" }
+
+import pf.Effect
+
+main! : {} => {}
+main! = \{} ->
+    flattened = List.join_map!([1, 2, 3], duplicate!)
+    expect flattened == Ok([1, 1, 2, 2, 3, 3])
+
+    with_zero = List.join_map!([0, 2], duplicate!)
+    expect with_zero == Ok([0, 0, 2, 2])
+
+    empty = List.join_map!([], duplicate!)
+    expect empty == Ok([])
+
+    {}
+
+duplicate! : U64 => Result (List U64) _
+duplicate! = \num ->
+    value = Effect.id_effectful!(num)
+    Ok([value, value])

crates/compiler/builtins/roc/Decode.roc

@@ -60,7 +60,7 @@ DecodeError : [TooShort]
 ## ```roc
 ## expect
 ##     input = "\"hello\", " |> Str.to_utf8
-##     actual = Decode.from_bytes_partial(input, Json.json)
+##     actual = Decode.from_bytes_partial(input, Json.utf8)
 ##     expected = Ok("hello")
 ##
 ##     actual.result == expected
@@ -133,7 +133,7 @@ decode_with = |bytes, @Decoder(decode), fmt| decode(bytes, fmt)
 ## ```roc
 ## expect
 ##     input = "\"hello\", " |> Str.to_utf8
-##     actual = Decode.from_bytes_partial(input Json.json)
+##     actual = Decode.from_bytes_partial(input Json.utf8)
 ##     expected = Ok("hello")
 ##
 ##     actual.result == expected
@@ -147,7 +147,7 @@ from_bytes_partial = |bytes, fmt| decode_with(bytes, decoder, fmt)
 ## ```roc
 ## expect
 ##     input = "\"hello\", " |> Str.to_utf8
-##     actual = Decode.from_bytes(input, Json.json)
+##     actual = Decode.from_bytes(input, Json.utf8)
 ##     expected = Ok("hello")
 ##
 ##     actual == expected

crates/compiler/builtins/roc/Encode.roc

@@ -78,7 +78,7 @@ EncoderFormatting implements
 ##     # Appends the byte 42
 ##     custom_encoder = Encode.custom(\bytes, _fmt -> List.append(bytes, 42))
 ##
-##     actual = Encode.append_with([], custom_encoder, Core.json)
+##     actual = Encode.append_with([], custom_encoder, Json.utf8)
 ##     expected = [42] # Expected result is a list with a single byte, 42
 ##
 ##     actual == expected
@@ -93,7 +93,7 @@ append_with = |lst, @Encoder(do_encoding), fmt| do_encoding(lst, fmt)
 ##
 ## ```roc
 ## expect
-##     actual = Encode.append([], { foo: 43 }, Core.json)
+##     actual = Encode.append([], { foo: 43 }, Json.utf8)
 ##     expected = Str.to_utf8("""{"foo":43}""")
 ##
 ##     actual == expected
@@ -107,7 +107,7 @@ append = |lst, val, fmt| append_with(lst, to_encoder(val), fmt)
 ## expect
 ##     foo_rec = { foo: 42 }
 ##
-##     actual = Encode.to_bytes(foo_rec, Core.json)
+##     actual = Encode.to_bytes(foo_rec, Json.utf8)
 ##     expected = Str.to_utf8("""{"foo":42}""")
 ##
 ##     actual == expected

crates/compiler/builtins/roc/List.roc

@@ -38,6 +38,7 @@ module [
     map3,
     map4,
     join_map,
+    join_map!,
     product,
     walk_with_index,
     walk_until,
@@ -1156,6 +1157,26 @@ join_map : List a, (a -> List b) -> List b
 join_map = |list, mapper|
     List.walk(list, [], |state, elem| List.concat(state, mapper(elem)))
 
+## Like [List.join_map], except the transformation function can have effects.
+##
+## ```
+## log_and_split! : List Str => Result (List Str) _
+## log_and_split! = |paths|
+##    List.join_map!(
+##        paths,
+##        |path|
+##            Result.map_ok(Stdout.line!(path), |_| Str.split_on(path, "/")),
+##    )
+## ```
+join_map! : List a, (a => Result (List b) err) => Result (List b) err
+join_map! = |list, mapper!|
+    List.walk_try!(
+        list,
+        [],
+        |state, elem|
+            Result.map_ok(mapper!(elem), |mapper_list| List.concat(state, mapper_list)),
+    )
+
 ## Returns the first element of the list satisfying a predicate function.
 ## If no satisfying element is found, an `Err NotFound` is returned.
 find_first : List elem, (elem -> Bool) -> Result elem [NotFound]

crates/compiler/builtins/roc/Str.roc

@@ -49,6 +49,16 @@
 ##
 ## Interpolation can be used in multiline strings, but the part inside the parentheses must still be on one line.
 ##
+## ### Import Str from File
+##
+## To avoid verbose code to read the contents of a file into a Str, you can import it directly:
+##
+## ```
+## import "some-file.txt" as some_str : Str
+## ```
+##
+## Note: The file content is included in the Roc app executable, if you publish the executable, you do not need to provide the file alongside it.
+##
 ## ### Escapes
 ##
 ## There are a few special escape sequences in strings:

crates/compiler/checkmate/www/package-lock.json

@@ -91,6 +91,7 @@
       "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.22.9.tgz",
       "integrity": "sha512-G2EgeufBcYw27U4hhoIwFcgc1XU7TlXJ3mv04oOv1WCuo900U/anZSPzEqNjwdjgffkk2Gs0AN0dW1CKVLcG7w==",
       "dev": true,
+      "peer": true,
       "dependencies": {
         "@ampproject/remapping": "^2.2.0",
         "@babel/code-frame": "^7.22.5",
@@ -812,6 +813,7 @@
       "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-flow/-/plugin-syntax-flow-7.22.5.tgz",
       "integrity": "sha512-9RdCl0i+q0QExayk2nOS7853w08yLucnnPML6EN9S8fgMPVtdLDCdx/cOQ/i44Lb9UeQX9A35yaqBBOMMZxPxQ==",
       "dev": true,
+      "peer": true,
       "dependencies": {
         "@babel/helper-plugin-utils": "^7.22.5"
       },
@@ -1677,6 +1679,7 @@
       "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx/-/plugin-transform-react-jsx-7.22.5.tgz",
       "integrity": "sha512-rog5gZaVbUip5iWDMTYbVM15XQq+RkUKhET/IHR6oizR+JEoN6CAfTTuHcK4vwUyzca30qqHqEpzBOnaRMWYMA==",
       "dev": true,
+      "peer": true,
       "dependencies": {
         "@babel/helper-annotate-as-pure": "^7.22.5",
         "@babel/helper-module-imports": "^7.22.5",
@@ -2201,10 +2204,11 @@
       "dev": true
     },
     "node_modules/@bcherny/json-schema-ref-parser/node_modules/js-yaml": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
-      "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
+      "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
         "argparse": "^2.0.1"
       },
@@ -2573,10 +2577,11 @@
       }
     },
     "node_modules/@eslint/eslintrc/node_modules/js-yaml": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
-      "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
+      "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
         "argparse": "^2.0.1"
       },
@@ -4691,6 +4696,7 @@
       "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.62.0.tgz",
       "integrity": "sha512-TiZzBSJja/LbhNPvk6yc0JrX9XqhQ0hdh6M2svYfsHGejaKFIAGd9MQ+ERIMzLGlN/kZoYIgdxFV0PuljTKXag==",
       "dev": true,
+      "peer": true,
       "dependencies": {
         "@eslint-community/regexpp": "^4.4.0",
         "@typescript-eslint/scope-manager": "5.62.0",
@@ -4744,6 +4750,7 @@
       "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-5.62.0.tgz",
       "integrity": "sha512-VlJEV0fOQ7BExOsHYAGrgbEiZoi8D+Bl2+f6V2RrXerRSylnp+ZBHmPvaIa8cz0Ajx7WO7Z5RqfgYg7ED1nRhA==",
       "dev": true,
+      "peer": true,
       "dependencies": {
         "@typescript-eslint/scope-manager": "5.62.0",
         "@typescript-eslint/types": "5.62.0",
@@ -5097,6 +5104,7 @@
       "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.10.0.tgz",
       "integrity": "sha512-F0SAmZ8iUtS//m8DmCTA0jlh6TDKkHQyK6xc6V4KDTyZKA9dnvX9/3sRTVQrWm79glUAZbnmmNcdYwUIHWVybw==",
       "dev": true,
+      "peer": true,
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -5192,6 +5200,7 @@
       "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
       "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
       "dev": true,
+      "peer": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.1",
         "fast-json-stable-stringify": "^2.0.0",
@@ -6041,6 +6050,7 @@
           "url": "https://github.com/sponsors/ai"
         }
       ],
+      "peer": true,
       "dependencies": {
         "caniuse-lite": "^1.0.30001646",
         "electron-to-chromium": "^1.5.4",
@@ -6785,6 +6795,7 @@
       "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.12.0.tgz",
       "integrity": "sha512-sRu1kpcO9yLtYxBKvqfTeh9KzZEwO3STyX1HT+4CaDzC6HpTGYhIhPIzj9XuKU7KYDwnaeh5hcOwjy1QuJzBPA==",
       "dev": true,
+      "peer": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.1",
         "json-schema-traverse": "^1.0.0",
@@ -7148,6 +7159,7 @@
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/d3-selection/-/d3-selection-3.0.0.tgz",
       "integrity": "sha512-fmTRWbNMmsmWq6xJV8D19U/gw/bwrHfNXxrIN+HfZgnzqTHp9jOmKMhsTUjXOJnZOdZY9Q28y4yebKzqDKlxlQ==",
+      "peer": true,
       "engines": {
         "node": ">=12"
       }
@@ -7944,6 +7956,7 @@
       "resolved": "https://registry.npmjs.org/eslint/-/eslint-8.45.0.tgz",
       "integrity": "sha512-pd8KSxiQpdYRfYa9Wufvdoct3ZPQQuVuU5O6scNgMuOMYuxvH0IGaYK0wUFjo4UYYQQCUndlXiMbnxopwvvTiw==",
       "dev": true,
+      "peer": true,
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.2.0",
         "@eslint-community/regexpp": "^4.4.0",
@@ -8359,6 +8372,7 @@
       "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.12.0.tgz",
       "integrity": "sha512-sRu1kpcO9yLtYxBKvqfTeh9KzZEwO3STyX1HT+4CaDzC6HpTGYhIhPIzj9XuKU7KYDwnaeh5hcOwjy1QuJzBPA==",
       "dev": true,
+      "peer": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.1",
         "json-schema-traverse": "^1.0.0",
@@ -8537,10 +8551,11 @@
       }
     },
     "node_modules/eslint/node_modules/js-yaml": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
-      "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
+      "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
         "argparse": "^2.0.1"
       },
@@ -9490,6 +9505,7 @@
       "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
       "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
       "dev": true,
+      "peer": true,
       "dependencies": {
         "fs.realpath": "^1.0.0",
         "inflight": "^1.0.4",
@@ -10093,6 +10109,7 @@
       "resolved": "https://registry.npmjs.org/immer/-/immer-9.0.21.tgz",
       "integrity": "sha512-bc4NBHqOqSfRW7POMkHd51LvClaeMXpm8dx0e8oE2GORbq5aRK7Bxl4FyzVLdGtLmvLKL7BTDBG5ACQm4HWjTA==",
       "devOptional": true,
+      "peer": true,
       "funding": {
         "type": "opencollective",
         "url": "https://opencollective.com/immer"
@@ -10780,6 +10797,7 @@
       "resolved": "https://registry.npmjs.org/jest/-/jest-27.5.1.tgz",
       "integrity": "sha512-Yn0mADZB89zTtjkPJEXwrac3LHudkQMR+Paqa8uxJHCBr9agxztUifWCyiYrjhMPBoUVBjyny0I7XH6ozDr7QQ==",
       "dev": true,
+      "peer": true,
       "dependencies": {
         "@jest/core": "^27.5.1",
         "import-local": "^3.0.2",
@@ -12816,10 +12834,11 @@
       "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ=="
     },
     "node_modules/js-yaml": {
-      "version": "3.14.1",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz",
-      "integrity": "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==",
+      "version": "3.14.2",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.2.tgz",
+      "integrity": "sha512-PMSmkqxr106Xa156c2M265Z+FTrPl+oxd/rgOQy2tijQeK5TxQ43psO1ZCwhVOSdnn+RzkzlRz/eY4BgJBYVpg==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
         "argparse": "^1.0.7",
         "esprima": "^4.0.0"
@@ -13406,6 +13425,7 @@
       "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.12.0.tgz",
       "integrity": "sha512-sRu1kpcO9yLtYxBKvqfTeh9KzZEwO3STyX1HT+4CaDzC6HpTGYhIhPIzj9XuKU7KYDwnaeh5hcOwjy1QuJzBPA==",
       "dev": true,
+      "peer": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.1",
         "json-schema-traverse": "^1.0.0",
@@ -13585,10 +13605,11 @@
       }
     },
     "node_modules/node-forge": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/node-forge/-/node-forge-1.3.1.tgz",
-      "integrity": "sha512-dPEtOeMvF9VMcYV/1Wb8CPoVAXtp6MKMlcbAt4ddqmGqUJ6fQZFXkNZNkNlfevtNkGtaSoXf/vNNNSvgrdXwtA==",
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/node-forge/-/node-forge-1.3.2.tgz",
+      "integrity": "sha512-6xKiQ+cph9KImrRh0VsjH2d8/GXA4FIMlgU4B757iI1ApvcyA9VlouP0yZJha01V+huImO+kKMU7ih+2+E14fw==",
       "dev": true,
+      "license": "(BSD-3-Clause OR GPL-2.0)",
       "engines": {
         "node": ">= 6.13.0"
       }
@@ -14249,6 +14270,7 @@
           "url": "https://github.com/sponsors/ai"
         }
       ],
+      "peer": true,
       "dependencies": {
         "nanoid": "^3.3.6",
         "picocolors": "^1.0.0",
@@ -15383,6 +15405,7 @@
       "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.0.13.tgz",
       "integrity": "sha512-EaV1Gl4mUEV4ddhDnv/xtj7sxwrwxdetHdWUGnT4VJQf+4d05v6lHYZr8N573k5Z0BViss7BDhfWtKS3+sfAqQ==",
       "dev": true,
+      "peer": true,
       "dependencies": {
         "cssesc": "^3.0.0",
         "util-deprecate": "^1.0.2"
@@ -15756,6 +15779,7 @@
       "version": "18.2.0",
       "resolved": "https://registry.npmjs.org/react/-/react-18.2.0.tgz",
       "integrity": "sha512-/3IjMdb2L9QbBdWiW5e3P2/npwMBaU9mHCSCUzNln0ZCYbcfTsGbTJrU/kGemdH2IWmB2ioZ+zkxtmq6g09fGQ==",
+      "peer": true,
       "dependencies": {
         "loose-envify": "^1.1.0"
       },
@@ -15910,6 +15934,7 @@
       "version": "18.2.0",
       "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.2.0.tgz",
       "integrity": "sha512-6IMTriUmvsjHUjNtEDudZfuDQUoWXVxKHhlEGSk81n4YFS+r/Kl99wXiwlVXtPBtJenozv2P+hxDsw9eA7Xo6g==",
+      "peer": true,
       "dependencies": {
         "loose-envify": "^1.1.0",
         "scheduler": "^0.23.0"
@@ -15935,6 +15960,7 @@
       "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.11.0.tgz",
       "integrity": "sha512-F27qZr8uUqwhWZboondsPx8tnC3Ct3SxZA3V5WyEvujRyyNv0VYPhoBg1gZ8/MV5tubQp76Trw8lTv9hzRBa+A==",
       "dev": true,
+      "peer": true,
       "engines": {
         "node": ">=0.10.0"
       }
@@ -15957,6 +15983,7 @@
       "version": "6.14.2",
       "resolved": "https://registry.npmjs.org/react-router-dom/-/react-router-dom-6.14.2.tgz",
       "integrity": "sha512-5pWX0jdKR48XFZBuJqHosX3AAHjRAzygouMTyimnBPOLdY3WjzUSKhus2FVMihUFWzeLebDgr4r8UeQFAct7Bg==",
+      "peer": true,
       "dependencies": {
         "@remix-run/router": "1.7.2",
         "react-router": "6.14.2"
@@ -16417,6 +16444,7 @@
       "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.79.2.tgz",
       "integrity": "sha512-fS6iqSPZDs3dr/y7Od6y5nha8dW1YnbgtsyotCVvoFGKbERG++CVRFv1meyGDE1SNItQA8BrnCw7ScdAhRJ3XQ==",
       "dev": true,
+      "peer": true,
       "bin": {
         "rollup": "dist/bin/rollup"
       },
@@ -17937,6 +17965,7 @@
       "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.21.3.tgz",
       "integrity": "sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==",
       "dev": true,
+      "peer": true,
       "engines": {
         "node": ">=10"
       },
@@ -18036,6 +18065,7 @@
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.9.5.tgz",
       "integrity": "sha512-1FXk9E2Hm+QzZQ7z+McJiHL4NW1F2EzMu9Nq9i3zAaGqibafqYwCVU6WyWAuyQRRzOlxou8xZSyXLEN8oKj24g==",
       "dev": true,
+      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
@@ -18337,6 +18367,7 @@
       "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.94.0.tgz",
       "integrity": "sha512-KcsGn50VT+06JH/iunZJedYGUJS5FGjow8wb9c0v5n1Om8O1g4L6LjtfxwlXIATopoQu+vOXXa7gYisWxCoPyg==",
       "dev": true,
+      "peer": true,
       "dependencies": {
         "@types/estree": "^1.0.5",
         "@webassemblyjs/ast": "^1.12.1",
@@ -18406,6 +18437,7 @@
       "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.12.0.tgz",
       "integrity": "sha512-sRu1kpcO9yLtYxBKvqfTeh9KzZEwO3STyX1HT+4CaDzC6HpTGYhIhPIzj9XuKU7KYDwnaeh5hcOwjy1QuJzBPA==",
       "dev": true,
+      "peer": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.1",
         "json-schema-traverse": "^1.0.0",
@@ -18459,6 +18491,7 @@
       "resolved": "https://registry.npmjs.org/webpack-dev-server/-/webpack-dev-server-4.15.1.tgz",
       "integrity": "sha512-5hbAst3h3C3L8w6W4P96L5vaV0PxSmJhxZvWKYIdgxOQm8pNZ5dEOmmSLBVpP85ReeyRt6AS1QJNyo/oFFPeVA==",
       "dev": true,
+      "peer": true,
       "dependencies": {
         "@types/bonjour": "^3.5.9",
         "@types/connect-history-api-fallback": "^1.3.5",
@@ -18518,6 +18551,7 @@
       "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.12.0.tgz",
       "integrity": "sha512-sRu1kpcO9yLtYxBKvqfTeh9KzZEwO3STyX1HT+4CaDzC6HpTGYhIhPIzj9XuKU7KYDwnaeh5hcOwjy1QuJzBPA==",
       "dev": true,
+      "peer": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.1",
         "json-schema-traverse": "^1.0.0",
@@ -18866,6 +18900,7 @@
       "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.12.0.tgz",
       "integrity": "sha512-sRu1kpcO9yLtYxBKvqfTeh9KzZEwO3STyX1HT+4CaDzC6HpTGYhIhPIzj9XuKU7KYDwnaeh5hcOwjy1QuJzBPA==",
       "dev": true,
+      "peer": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.1",
         "json-schema-traverse": "^1.0.0",

crates/compiler/fmt/src/migrate.rs

@@ -864,6 +864,7 @@ fn is_static_method(module_name: &str, ident: &str) -> bool {
                 | "map_try"
                 | "walk_try"
                 | "join_map"
+                | "join_map!"
                 | "any"
                 | "take_first"
                 | "take_last"

crates/compiler/module/src/symbol.rs

@@ -1533,6 +1533,7 @@ define_builtins! {
         95 LIST_WALK_TRY_FX: "walk_try!"
         96 LIST_MAP_TRY_FX: "map_try!"
         97 LIST_KEEP_IF_TRY_FX: "keep_if_try!"
+        98 LIST_JOIN_MAP_FX: "join_map!"
     }
     7 RESULT: "Result" => {
         0 RESULT_RESULT: "Result" exposed_type=true // the Result.Result type alias

crates/compiler/test_mono/generated/anonymous_closure_in_polymorphic_expression_issue_4717.txt

@@ -2,81 +2,81 @@ procedure Bool.9 (#Attr.2, #Attr.3):
     let Bool.21 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
     ret Bool.21;
 
-procedure List.119 (List.582, List.583, List.584):
-    let List.712 : U64 = 0i64;
-    let List.713 : U64 = CallByName List.6 List.582;
-    let List.711 : [C U64, C U64] = CallByName List.80 List.582 List.583 List.584 List.712 List.713;
-    ret List.711;
+procedure List.120 (List.590, List.591, List.592):
+    let List.720 : U64 = 0i64;
+    let List.721 : U64 = CallByName List.6 List.590;
+    let List.719 : [C U64, C U64] = CallByName List.80 List.590 List.591 List.592 List.720 List.721;
+    ret List.719;
 
-procedure List.26 (List.216, List.217, List.218):
-    let List.705 : [C U64, C U64] = CallByName List.119 List.216 List.217 List.218;
-    let List.708 : U8 = 1i64;
-    let List.709 : U8 = GetTagId List.705;
-    let List.710 : Int1 = lowlevel Eq List.708 List.709;
-    if List.710 then
-        let List.219 : U64 = UnionAtIndex (Id 1) (Index 0) List.705;
-        ret List.219;
-    else
-        let List.220 : U64 = UnionAtIndex (Id 0) (Index 0) List.705;
+procedure List.26 (List.217, List.218, List.219):
+    let List.713 : [C U64, C U64] = CallByName List.120 List.217 List.218 List.219;
+    let List.716 : U8 = 1i64;
+    let List.717 : U8 = GetTagId List.713;
+    let List.718 : Int1 = lowlevel Eq List.716 List.717;
+    if List.718 then
+        let List.220 : U64 = UnionAtIndex (Id 1) (Index 0) List.713;
         ret List.220;
+    else
+        let List.221 : U64 = UnionAtIndex (Id 0) (Index 0) List.713;
+        ret List.221;
 
-procedure List.38 (List.413, List.414):
-    let List.704 : U64 = CallByName List.6 List.413;
-    let List.415 : U64 = CallByName Num.77 List.704 List.414;
-    let List.694 : List U8 = CallByName List.43 List.413 List.415;
-    ret List.694;
+procedure List.38 (List.414, List.415):
+    let List.712 : U64 = CallByName List.6 List.414;
+    let List.416 : U64 = CallByName Num.77 List.712 List.415;
+    let List.702 : List U8 = CallByName List.43 List.414 List.416;
+    ret List.702;
 
-procedure List.43 (List.411, List.412):
-    let List.702 : U64 = CallByName List.6 List.411;
-    let List.701 : U64 = CallByName Num.77 List.702 List.412;
-    let List.696 : {U64, U64} = Struct {List.412, List.701};
-    let List.695 : List U8 = CallByName List.49 List.411 List.696;
-    ret List.695;
-
-procedure List.49 (List.489, List.490):
-    let List.698 : U64 = StructAtIndex 1 List.490;
-    let List.699 : U64 = StructAtIndex 0 List.490;
-    let List.697 : List U8 = CallByName List.72 List.489 List.698 List.699;
-    ret List.697;
-
-procedure List.6 (#Attr.2):
-    let List.703 : U64 = lowlevel ListLenU64 #Attr.2;
+procedure List.43 (List.412, List.413):
+    let List.710 : U64 = CallByName List.6 List.412;
+    let List.709 : U64 = CallByName Num.77 List.710 List.413;
+    let List.704 : {U64, U64} = Struct {List.413, List.709};
+    let List.703 : List U8 = CallByName List.49 List.412 List.704;
     ret List.703;
 
+procedure List.49 (List.497, List.498):
+    let List.706 : U64 = StructAtIndex 1 List.498;
+    let List.707 : U64 = StructAtIndex 0 List.498;
+    let List.705 : List U8 = CallByName List.72 List.497 List.706 List.707;
+    ret List.705;
+
+procedure List.6 (#Attr.2):
+    let List.711 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.711;
+
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.726 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.726;
+    let List.734 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.734;
 
 procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
-    let List.700 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
-    ret List.700;
+    let List.708 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
+    ret List.708;
 
 procedure List.80 (Bool.22, Bool.23, Bool.24, Bool.25, Bool.26):
-    joinpoint List.714 List.585 List.586 List.587 List.588 List.589:
-        let List.716 : Int1 = CallByName Num.22 List.588 List.589;
-        if List.716 then
-            let List.725 : U8 = CallByName List.66 List.585 List.588;
-            let List.717 : [C U64, C U64] = CallByName Test.4 List.586 List.725;
-            let List.722 : U8 = 1i64;
-            let List.723 : U8 = GetTagId List.717;
-            let List.724 : Int1 = lowlevel Eq List.722 List.723;
-            if List.724 then
-                let List.590 : U64 = UnionAtIndex (Id 1) (Index 0) List.717;
-                let List.720 : U64 = 1i64;
-                let List.719 : U64 = CallByName Num.51 List.588 List.720;
-                jump List.714 List.585 List.590 List.587 List.719 List.589;
+    joinpoint List.722 List.593 List.594 List.595 List.596 List.597:
+        let List.724 : Int1 = CallByName Num.22 List.596 List.597;
+        if List.724 then
+            let List.733 : U8 = CallByName List.66 List.593 List.596;
+            let List.725 : [C U64, C U64] = CallByName Test.4 List.594 List.733;
+            let List.730 : U8 = 1i64;
+            let List.731 : U8 = GetTagId List.725;
+            let List.732 : Int1 = lowlevel Eq List.730 List.731;
+            if List.732 then
+                let List.598 : U64 = UnionAtIndex (Id 1) (Index 0) List.725;
+                let List.728 : U64 = 1i64;
+                let List.727 : U64 = CallByName Num.51 List.596 List.728;
+                jump List.722 List.593 List.598 List.595 List.727 List.597;
             else
-                dec List.585;
-                let List.591 : U64 = UnionAtIndex (Id 0) (Index 0) List.717;
-                let List.721 : [C U64, C U64] = TagId(0) List.591;
-                ret List.721;
+                dec List.593;
+                let List.599 : U64 = UnionAtIndex (Id 0) (Index 0) List.725;
+                let List.729 : [C U64, C U64] = TagId(0) List.599;
+                ret List.729;
         else
-            dec List.585;
-            let List.715 : [C U64, C U64] = TagId(1) List.586;
-            ret List.715;
+            dec List.593;
+            let List.723 : [C U64, C U64] = TagId(1) List.594;
+            ret List.723;
     in
     inc Bool.22;
-    jump List.714 Bool.22 Bool.23 Bool.24 Bool.25 Bool.26;
+    jump List.722 Bool.22 Bool.23 Bool.24 Bool.25 Bool.26;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.292 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/call_function_in_empty_list.txt

@@ -1,51 +1,51 @@
-procedure List.103 (Bool.21, Bool.22, Bool.23, Bool.24, Bool.25):
-    joinpoint List.700 List.178 List.179 List.180 List.181 List.182:
-        let List.702 : Int1 = CallByName Num.22 List.181 List.182;
-        if List.702 then
-            let List.706 : [] = CallByName List.66 List.178 List.181;
-            let List.183 : List {} = CallByName List.296 List.179 List.706 List.180;
-            let List.705 : U64 = 1i64;
-            let List.704 : U64 = CallByName Num.51 List.181 List.705;
-            jump List.700 List.178 List.183 List.180 List.704 List.182;
+procedure List.104 (Bool.21, Bool.22, Bool.23, Bool.24, Bool.25):
+    joinpoint List.708 List.179 List.180 List.181 List.182 List.183:
+        let List.710 : Int1 = CallByName Num.22 List.182 List.183;
+        if List.710 then
+            let List.714 : [] = CallByName List.66 List.179 List.182;
+            let List.184 : List {} = CallByName List.297 List.180 List.714 List.181;
+            let List.713 : U64 = 1i64;
+            let List.712 : U64 = CallByName Num.51 List.182 List.713;
+            jump List.708 List.179 List.184 List.181 List.712 List.183;
         else
-            dec List.178;
-            ret List.179;
+            dec List.179;
+            ret List.180;
     in
     inc Bool.21;
-    jump List.700 Bool.21 Bool.22 Bool.23 Bool.24 Bool.25;
+    jump List.708 Bool.21 Bool.22 Bool.23 Bool.24 Bool.25;
 
-procedure List.18 (List.175, List.176, List.177):
-    let List.698 : U64 = 0i64;
-    let List.699 : U64 = CallByName List.6 List.175;
-    let List.697 : List {} = CallByName List.103 List.175 List.176 List.177 List.698 List.699;
-    ret List.697;
+procedure List.18 (List.176, List.177, List.178):
+    let List.706 : U64 = 0i64;
+    let List.707 : U64 = CallByName List.6 List.176;
+    let List.705 : List {} = CallByName List.104 List.176 List.177 List.178 List.706 List.707;
+    ret List.705;
 
-procedure List.296 (List.297, List.298, List.294):
-    let List.711 : {} = CallByName Test.2 List.298;
-    let List.710 : List {} = CallByName List.71 List.297 List.711;
-    ret List.710;
+procedure List.297 (List.298, List.299, List.295):
+    let List.719 : {} = CallByName Test.2 List.299;
+    let List.718 : List {} = CallByName List.71 List.298 List.719;
+    ret List.718;
 
-procedure List.5 (List.293, List.294):
-    let List.295 : U64 = CallByName List.6 List.293;
-    let List.695 : List {} = CallByName List.68 List.295;
-    let List.694 : List {} = CallByName List.18 List.293 List.695 List.294;
-    ret List.694;
+procedure List.5 (List.294, List.295):
+    let List.296 : U64 = CallByName List.6 List.294;
+    let List.703 : List {} = CallByName List.68 List.296;
+    let List.702 : List {} = CallByName List.18 List.294 List.703 List.295;
+    ret List.702;
 
 procedure List.6 (#Attr.2):
-    let List.708 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.708;
+    let List.716 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.716;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.707 : [] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.707;
+    let List.715 : [] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.715;
 
 procedure List.68 (#Attr.2):
-    let List.713 : List {} = lowlevel ListWithCapacity #Attr.2;
-    ret List.713;
+    let List.721 : List {} = lowlevel ListWithCapacity #Attr.2;
+    ret List.721;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.712 : List {} = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.712;
+    let List.720 : List {} = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.720;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.290 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/call_function_in_empty_list_unbound.txt

@@ -1,51 +1,51 @@
-procedure List.103 (Bool.21, Bool.22, Bool.23, Bool.24, Bool.25):
-    joinpoint List.700 List.178 List.179 List.180 List.181 List.182:
-        let List.702 : Int1 = CallByName Num.22 List.181 List.182;
-        if List.702 then
-            let List.706 : [] = CallByName List.66 List.178 List.181;
-            let List.183 : List [] = CallByName List.296 List.179 List.706 List.180;
-            let List.705 : U64 = 1i64;
-            let List.704 : U64 = CallByName Num.51 List.181 List.705;
-            jump List.700 List.178 List.183 List.180 List.704 List.182;
+procedure List.104 (Bool.21, Bool.22, Bool.23, Bool.24, Bool.25):
+    joinpoint List.708 List.179 List.180 List.181 List.182 List.183:
+        let List.710 : Int1 = CallByName Num.22 List.182 List.183;
+        if List.710 then
+            let List.714 : [] = CallByName List.66 List.179 List.182;
+            let List.184 : List [] = CallByName List.297 List.180 List.714 List.181;
+            let List.713 : U64 = 1i64;
+            let List.712 : U64 = CallByName Num.51 List.182 List.713;
+            jump List.708 List.179 List.184 List.181 List.712 List.183;
         else
-            dec List.178;
-            ret List.179;
+            dec List.179;
+            ret List.180;
     in
     inc Bool.21;
-    jump List.700 Bool.21 Bool.22 Bool.23 Bool.24 Bool.25;
+    jump List.708 Bool.21 Bool.22 Bool.23 Bool.24 Bool.25;
 
-procedure List.18 (List.175, List.176, List.177):
-    let List.698 : U64 = 0i64;
-    let List.699 : U64 = CallByName List.6 List.175;
-    let List.697 : List [] = CallByName List.103 List.175 List.176 List.177 List.698 List.699;
-    ret List.697;
+procedure List.18 (List.176, List.177, List.178):
+    let List.706 : U64 = 0i64;
+    let List.707 : U64 = CallByName List.6 List.176;
+    let List.705 : List [] = CallByName List.104 List.176 List.177 List.178 List.706 List.707;
+    ret List.705;
 
-procedure List.296 (List.297, List.298, List.294):
-    let List.711 : [] = CallByName Test.2 List.298;
-    let List.710 : List [] = CallByName List.71 List.297 List.711;
-    ret List.710;
+procedure List.297 (List.298, List.299, List.295):
+    let List.719 : [] = CallByName Test.2 List.299;
+    let List.718 : List [] = CallByName List.71 List.298 List.719;
+    ret List.718;
 
-procedure List.5 (List.293, List.294):
-    let List.295 : U64 = CallByName List.6 List.293;
-    let List.695 : List [] = CallByName List.68 List.295;
-    let List.694 : List [] = CallByName List.18 List.293 List.695 List.294;
-    ret List.694;
+procedure List.5 (List.294, List.295):
+    let List.296 : U64 = CallByName List.6 List.294;
+    let List.703 : List [] = CallByName List.68 List.296;
+    let List.702 : List [] = CallByName List.18 List.294 List.703 List.295;
+    ret List.702;
 
 procedure List.6 (#Attr.2):
-    let List.708 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.708;
+    let List.716 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.716;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.707 : [] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.707;
+    let List.715 : [] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.715;
 
 procedure List.68 (#Attr.2):
-    let List.713 : List [] = lowlevel ListWithCapacity #Attr.2;
-    ret List.713;
+    let List.721 : List [] = lowlevel ListWithCapacity #Attr.2;
+    ret List.721;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.712 : List [] = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.712;
+    let List.720 : List [] = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.720;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.290 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/capture_void_layout_task.txt

@@ -1,32 +1,32 @@
-procedure List.103 (Bool.34, Bool.35, Bool.36, Bool.37, Bool.38):
-    joinpoint List.697 List.178 List.179 List.180 List.181 List.182:
-        let List.699 : Int1 = CallByName Num.22 List.181 List.182;
-        if List.699 then
-            let List.703 : [] = CallByName List.66 List.178 List.181;
-            let List.183 : [<r>C {}, C *self {{}, []}] = CallByName Test.29 List.179 List.703 List.180;
-            let List.702 : U64 = 1i64;
-            let List.701 : U64 = CallByName Num.51 List.181 List.702;
-            jump List.697 List.178 List.183 List.180 List.701 List.182;
+procedure List.104 (Bool.34, Bool.35, Bool.36, Bool.37, Bool.38):
+    joinpoint List.705 List.179 List.180 List.181 List.182 List.183:
+        let List.707 : Int1 = CallByName Num.22 List.182 List.183;
+        if List.707 then
+            let List.711 : [] = CallByName List.66 List.179 List.182;
+            let List.184 : [<r>C {}, C *self {{}, []}] = CallByName Test.29 List.180 List.711 List.181;
+            let List.710 : U64 = 1i64;
+            let List.709 : U64 = CallByName Num.51 List.182 List.710;
+            jump List.705 List.179 List.184 List.181 List.709 List.183;
         else
-            dec List.178;
-            ret List.179;
+            dec List.179;
+            ret List.180;
     in
     inc Bool.34;
-    jump List.697 Bool.34 Bool.35 Bool.36 Bool.37 Bool.38;
+    jump List.705 Bool.34 Bool.35 Bool.36 Bool.37 Bool.38;
 
-procedure List.18 (List.175, List.176, List.177):
-    let List.695 : U64 = 0i64;
-    let List.696 : U64 = CallByName List.6 List.175;
-    let List.694 : [<r>C {}, C *self {{}, []}] = CallByName List.103 List.175 List.176 List.177 List.695 List.696;
-    ret List.694;
+procedure List.18 (List.176, List.177, List.178):
+    let List.703 : U64 = 0i64;
+    let List.704 : U64 = CallByName List.6 List.176;
+    let List.702 : [<r>C {}, C *self {{}, []}] = CallByName List.104 List.176 List.177 List.178 List.703 List.704;
+    ret List.702;
 
 procedure List.6 (#Attr.2):
-    let List.705 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.705;
+    let List.713 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.713;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.704 : [] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.704;
+    let List.712 : [] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.712;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.290 : 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.694 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.694;
+    let List.702 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.702;
 
 procedure Test.1 (Test.5):
     let Test.2 : I64 = 41i64;

crates/compiler/test_mono/generated/compose_recursive_lambda_set_productive_nullable_wrapped.txt

@@ -2,35 +2,35 @@ procedure Bool.2 ():
     let Bool.21 : Int1 = true;
     ret Bool.21;
 
-procedure List.103 (Bool.29, Bool.30, Bool.31, Bool.32, Bool.33):
-    joinpoint List.697 List.178 List.179 List.180 List.181 List.182:
-        let List.699 : Int1 = CallByName Num.22 List.181 List.182;
-        if List.699 then
-            let List.703 : Int1 = CallByName List.66 List.178 List.181;
-            let List.183 : [<rnw><null>, C *self Int1, C *self Int1] = CallByName Test.6 List.179 List.703 List.180;
-            let List.702 : U64 = 1i64;
-            let List.701 : U64 = CallByName Num.51 List.181 List.702;
-            jump List.697 List.178 List.183 List.180 List.701 List.182;
+procedure List.104 (Bool.29, Bool.30, Bool.31, Bool.32, Bool.33):
+    joinpoint List.705 List.179 List.180 List.181 List.182 List.183:
+        let List.707 : Int1 = CallByName Num.22 List.182 List.183;
+        if List.707 then
+            let List.711 : Int1 = CallByName List.66 List.179 List.182;
+            let List.184 : [<rnw><null>, C *self Int1, C *self Int1] = CallByName Test.6 List.180 List.711 List.181;
+            let List.710 : U64 = 1i64;
+            let List.709 : U64 = CallByName Num.51 List.182 List.710;
+            jump List.705 List.179 List.184 List.181 List.709 List.183;
         else
-            dec List.178;
-            ret List.179;
+            dec List.179;
+            ret List.180;
     in
     inc Bool.29;
-    jump List.697 Bool.29 Bool.30 Bool.31 Bool.32 Bool.33;
+    jump List.705 Bool.29 Bool.30 Bool.31 Bool.32 Bool.33;
 
-procedure List.18 (List.175, List.176, List.177):
-    let List.695 : U64 = 0i64;
-    let List.696 : U64 = CallByName List.6 List.175;
-    let List.694 : [<rnw><null>, C *self Int1, C *self Int1] = CallByName List.103 List.175 List.176 List.177 List.695 List.696;
-    ret List.694;
+procedure List.18 (List.176, List.177, List.178):
+    let List.703 : U64 = 0i64;
+    let List.704 : U64 = CallByName List.6 List.176;
+    let List.702 : [<rnw><null>, C *self Int1, C *self Int1] = CallByName List.104 List.176 List.177 List.178 List.703 List.704;
+    ret List.702;
 
 procedure List.6 (#Attr.2):
-    let List.705 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.705;
+    let List.713 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.713;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.704 : Int1 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.704;
+    let List.712 : Int1 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.712;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.290 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/dict.txt

@@ -26,8 +26,8 @@ procedure Dict.52 ():
     ret Dict.744;
 
 procedure List.6 (#Attr.2):
-    let List.694 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.694;
+    let List.702 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.702;
 
 procedure Num.75 (#Attr.2, #Attr.3):
     let Num.289 : U8 = lowlevel NumSubWrap #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/empty_list_of_function_type.txt

@@ -2,25 +2,25 @@ procedure Bool.1 ():
     let Bool.21 : Int1 = false;
     ret Bool.21;
 
-procedure List.2 (List.123, List.124):
-    let List.700 : U64 = CallByName List.6 List.123;
-    let List.696 : Int1 = CallByName Num.22 List.124 List.700;
-    if List.696 then
-        let List.698 : {} = CallByName List.66 List.123 List.124;
-        let List.697 : [C {}, C {}] = TagId(1) List.698;
-        ret List.697;
+procedure List.2 (List.124, List.125):
+    let List.708 : U64 = CallByName List.6 List.124;
+    let List.704 : Int1 = CallByName Num.22 List.125 List.708;
+    if List.704 then
+        let List.706 : {} = CallByName List.66 List.124 List.125;
+        let List.705 : [C {}, C {}] = TagId(1) List.706;
+        ret List.705;
     else
-        let List.695 : {} = Struct {};
-        let List.694 : [C {}, C {}] = TagId(0) List.695;
-        ret List.694;
+        let List.703 : {} = Struct {};
+        let List.702 : [C {}, C {}] = TagId(0) List.703;
+        ret List.702;
 
 procedure List.6 (#Attr.2):
-    let List.701 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.701;
+    let List.709 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.709;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.699 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.699;
+    let List.707 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.707;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.289 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/encode.txt

@@ -1,16 +1,16 @@
-procedure List.4 (List.139, List.140):
-    let List.697 : U64 = 1i64;
-    let List.695 : List U8 = CallByName List.70 List.139 List.697;
-    let List.694 : List U8 = CallByName List.71 List.695 List.140;
-    ret List.694;
+procedure List.4 (List.140, List.141):
+    let List.705 : U64 = 1i64;
+    let List.703 : List U8 = CallByName List.70 List.140 List.705;
+    let List.702 : List U8 = CallByName List.71 List.703 List.141;
+    ret List.702;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.698 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.698;
+    let List.706 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    ret List.706;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.696 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.696;
+    let List.704 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.704;
 
 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

@@ -67,85 +67,85 @@ procedure Encode.26 (Encode.107, Encode.108):
     let Encode.110 : List U8 = CallByName Encode.24 Encode.111 Encode.112 Encode.108;
     ret Encode.110;
 
-procedure List.103 (#Derived_gen.35, #Derived_gen.36, #Derived_gen.37, #Derived_gen.38, #Derived_gen.39):
-    joinpoint List.697 List.178 List.179 List.180 List.181 List.182:
-        let List.699 : Int1 = CallByName Num.22 List.181 List.182;
-        if List.699 then
-            let List.703 : {Str, Str} = CallByName List.66 List.178 List.181;
-            inc List.703;
-            let List.183 : List U8 = CallByName Test.71 List.179 List.703;
-            let List.702 : U64 = 1i64;
-            let List.701 : U64 = CallByName Num.51 List.181 List.702;
-            jump List.697 List.178 List.183 List.180 List.701 List.182;
+procedure List.104 (#Derived_gen.35, #Derived_gen.36, #Derived_gen.37, #Derived_gen.38, #Derived_gen.39):
+    joinpoint List.731 List.179 List.180 List.181 List.182 List.183:
+        let List.733 : Int1 = CallByName Num.22 List.182 List.183;
+        if List.733 then
+            let List.737 : {Str, Str} = CallByName List.66 List.179 List.182;
+            inc List.737;
+            let List.184 : List U8 = CallByName Test.71 List.180 List.737;
+            let List.736 : U64 = 1i64;
+            let List.735 : U64 = CallByName Num.51 List.182 List.736;
+            jump List.731 List.179 List.184 List.181 List.735 List.183;
         else
-            dec List.178;
-            ret List.179;
+            dec List.179;
+            ret List.180;
     in
     inc #Derived_gen.35;
-    jump List.697 #Derived_gen.35 #Derived_gen.36 #Derived_gen.37 #Derived_gen.38 #Derived_gen.39;
+    jump List.731 #Derived_gen.35 #Derived_gen.36 #Derived_gen.37 #Derived_gen.38 #Derived_gen.39;
 
-procedure List.103 (#Derived_gen.40, #Derived_gen.41, #Derived_gen.42, #Derived_gen.43, #Derived_gen.44):
-    joinpoint List.723 List.178 List.179 List.180 List.181 List.182:
-        let List.725 : Int1 = CallByName Num.22 List.181 List.182;
-        if List.725 then
-            let List.729 : {Str, Str} = CallByName List.66 List.178 List.181;
-            inc List.729;
-            let List.183 : List U8 = CallByName Test.71 List.179 List.729;
-            let List.728 : U64 = 1i64;
-            let List.727 : U64 = CallByName Num.51 List.181 List.728;
-            jump List.723 List.178 List.183 List.180 List.727 List.182;
+procedure List.104 (#Derived_gen.40, #Derived_gen.41, #Derived_gen.42, #Derived_gen.43, #Derived_gen.44):
+    joinpoint List.705 List.179 List.180 List.181 List.182 List.183:
+        let List.707 : Int1 = CallByName Num.22 List.182 List.183;
+        if List.707 then
+            let List.711 : {Str, Str} = CallByName List.66 List.179 List.182;
+            inc List.711;
+            let List.184 : List U8 = CallByName Test.71 List.180 List.711;
+            let List.710 : U64 = 1i64;
+            let List.709 : U64 = CallByName Num.51 List.182 List.710;
+            jump List.705 List.179 List.184 List.181 List.709 List.183;
         else
-            dec List.178;
-            ret List.179;
+            dec List.179;
+            ret List.180;
     in
     inc #Derived_gen.40;
-    jump List.723 #Derived_gen.40 #Derived_gen.41 #Derived_gen.42 #Derived_gen.43 #Derived_gen.44;
+    jump List.705 #Derived_gen.40 #Derived_gen.41 #Derived_gen.42 #Derived_gen.43 #Derived_gen.44;
 
-procedure List.18 (List.175, List.176, List.177):
-    let List.695 : U64 = 0i64;
-    let List.696 : U64 = CallByName List.6 List.175;
-    let List.694 : List U8 = CallByName List.103 List.175 List.176 List.177 List.695 List.696;
-    ret List.694;
+procedure List.18 (List.176, List.177, List.178):
+    let List.703 : U64 = 0i64;
+    let List.704 : U64 = CallByName List.6 List.176;
+    let List.702 : List U8 = CallByName List.104 List.176 List.177 List.178 List.703 List.704;
+    ret List.702;
 
-procedure List.18 (List.175, List.176, List.177):
-    let List.721 : U64 = 0i64;
-    let List.722 : U64 = CallByName List.6 List.175;
-    let List.720 : List U8 = CallByName List.103 List.175 List.176 List.177 List.721 List.722;
-    ret List.720;
+procedure List.18 (List.176, List.177, List.178):
+    let List.729 : U64 = 0i64;
+    let List.730 : U64 = CallByName List.6 List.176;
+    let List.728 : List U8 = CallByName List.104 List.176 List.177 List.178 List.729 List.730;
+    ret List.728;
 
-procedure List.4 (List.139, List.140):
-    let List.742 : U64 = 1i64;
-    let List.741 : List U8 = CallByName List.70 List.139 List.742;
-    let List.740 : List U8 = CallByName List.71 List.741 List.140;
-    ret List.740;
+procedure List.4 (List.140, List.141):
+    let List.750 : U64 = 1i64;
+    let List.749 : List U8 = CallByName List.70 List.140 List.750;
+    let List.748 : List U8 = CallByName List.71 List.749 List.141;
+    ret List.748;
 
 procedure List.6 (#Attr.2):
-    let List.719 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.719;
+    let List.727 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.727;
 
 procedure List.6 (#Attr.2):
-    let List.745 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.745;
+    let List.753 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.753;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.704 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.704;
+    let List.712 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.712;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.730 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.730;
+    let List.738 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.738;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.736 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.736;
+    let List.744 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    ret List.744;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.734 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.734;
+    let List.742 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.742;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.744 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.744;
+    let List.752 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    ret List.752;
 
 procedure Num.127 (#Attr.2):
     let Num.294 : U8 = lowlevel NumIntCast #Attr.2;

crates/compiler/test_mono/generated/encode_derived_record_one_field_string.txt

@@ -39,54 +39,54 @@ procedure Encode.26 (Encode.107, Encode.108):
     let Encode.110 : List U8 = CallByName Encode.24 Encode.111 Encode.112 Encode.108;
     ret Encode.110;
 
-procedure List.103 (#Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_gen.23):
-    joinpoint List.697 List.178 List.179 List.180 List.181 List.182:
-        let List.699 : Int1 = CallByName Num.22 List.181 List.182;
-        if List.699 then
-            let List.703 : {Str, Str} = CallByName List.66 List.178 List.181;
-            inc List.703;
-            let List.183 : List U8 = CallByName Test.71 List.179 List.703;
-            let List.702 : U64 = 1i64;
-            let List.701 : U64 = CallByName Num.51 List.181 List.702;
-            jump List.697 List.178 List.183 List.180 List.701 List.182;
+procedure List.104 (#Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_gen.23):
+    joinpoint List.705 List.179 List.180 List.181 List.182 List.183:
+        let List.707 : Int1 = CallByName Num.22 List.182 List.183;
+        if List.707 then
+            let List.711 : {Str, Str} = CallByName List.66 List.179 List.182;
+            inc List.711;
+            let List.184 : List U8 = CallByName Test.71 List.180 List.711;
+            let List.710 : U64 = 1i64;
+            let List.709 : U64 = CallByName Num.51 List.182 List.710;
+            jump List.705 List.179 List.184 List.181 List.709 List.183;
         else
-            dec List.178;
-            ret List.179;
+            dec List.179;
+            ret List.180;
     in
     inc #Derived_gen.19;
-    jump List.697 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23;
+    jump List.705 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23;
 
-procedure List.18 (List.175, List.176, List.177):
-    let List.695 : U64 = 0i64;
-    let List.696 : U64 = CallByName List.6 List.175;
-    let List.694 : List U8 = CallByName List.103 List.175 List.176 List.177 List.695 List.696;
-    ret List.694;
+procedure List.18 (List.176, List.177, List.178):
+    let List.703 : U64 = 0i64;
+    let List.704 : U64 = CallByName List.6 List.176;
+    let List.702 : List U8 = CallByName List.104 List.176 List.177 List.178 List.703 List.704;
+    ret List.702;
 
-procedure List.4 (List.139, List.140):
-    let List.716 : U64 = 1i64;
-    let List.715 : List U8 = CallByName List.70 List.139 List.716;
-    let List.714 : List U8 = CallByName List.71 List.715 List.140;
-    ret List.714;
+procedure List.4 (List.140, List.141):
+    let List.724 : U64 = 1i64;
+    let List.723 : List U8 = CallByName List.70 List.140 List.724;
+    let List.722 : List U8 = CallByName List.71 List.723 List.141;
+    ret List.722;
 
 procedure List.6 (#Attr.2):
-    let List.719 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.719;
+    let List.727 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.727;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.704 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.704;
+    let List.712 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.712;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.710 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.710;
+    let List.718 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    ret List.718;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.708 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.708;
+    let List.716 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.716;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.718 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.718;
+    let List.726 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    ret List.726;
 
 procedure Num.127 (#Attr.2):
     let Num.290 : U8 = lowlevel NumIntCast #Attr.2;

crates/compiler/test_mono/generated/encode_derived_record_two_field_strings.txt

@@ -46,54 +46,54 @@ procedure Encode.26 (Encode.107, Encode.108):
     let Encode.110 : List U8 = CallByName Encode.24 Encode.111 Encode.112 Encode.108;
     ret Encode.110;
 
-procedure List.103 (#Derived_gen.23, #Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_gen.27):
-    joinpoint List.697 List.178 List.179 List.180 List.181 List.182:
-        let List.699 : Int1 = CallByName Num.22 List.181 List.182;
-        if List.699 then
-            let List.703 : {Str, Str} = CallByName List.66 List.178 List.181;
-            inc List.703;
-            let List.183 : List U8 = CallByName Test.71 List.179 List.703;
-            let List.702 : U64 = 1i64;
-            let List.701 : U64 = CallByName Num.51 List.181 List.702;
-            jump List.697 List.178 List.183 List.180 List.701 List.182;
+procedure List.104 (#Derived_gen.23, #Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_gen.27):
+    joinpoint List.705 List.179 List.180 List.181 List.182 List.183:
+        let List.707 : Int1 = CallByName Num.22 List.182 List.183;
+        if List.707 then
+            let List.711 : {Str, Str} = CallByName List.66 List.179 List.182;
+            inc List.711;
+            let List.184 : List U8 = CallByName Test.71 List.180 List.711;
+            let List.710 : U64 = 1i64;
+            let List.709 : U64 = CallByName Num.51 List.182 List.710;
+            jump List.705 List.179 List.184 List.181 List.709 List.183;
         else
-            dec List.178;
-            ret List.179;
+            dec List.179;
+            ret List.180;
     in
     inc #Derived_gen.23;
-    jump List.697 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27;
+    jump List.705 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27;
 
-procedure List.18 (List.175, List.176, List.177):
-    let List.695 : U64 = 0i64;
-    let List.696 : U64 = CallByName List.6 List.175;
-    let List.694 : List U8 = CallByName List.103 List.175 List.176 List.177 List.695 List.696;
-    ret List.694;
+procedure List.18 (List.176, List.177, List.178):
+    let List.703 : U64 = 0i64;
+    let List.704 : U64 = CallByName List.6 List.176;
+    let List.702 : List U8 = CallByName List.104 List.176 List.177 List.178 List.703 List.704;
+    ret List.702;
 
-procedure List.4 (List.139, List.140):
-    let List.716 : U64 = 1i64;
-    let List.715 : List U8 = CallByName List.70 List.139 List.716;
-    let List.714 : List U8 = CallByName List.71 List.715 List.140;
-    ret List.714;
+procedure List.4 (List.140, List.141):
+    let List.724 : U64 = 1i64;
+    let List.723 : List U8 = CallByName List.70 List.140 List.724;
+    let List.722 : List U8 = CallByName List.71 List.723 List.141;
+    ret List.722;
 
 procedure List.6 (#Attr.2):
-    let List.719 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.719;
+    let List.727 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.727;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.704 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.704;
+    let List.712 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.712;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.710 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.710;
+    let List.718 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    ret List.718;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.708 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.708;
+    let List.716 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.716;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.718 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.718;
+    let List.726 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    ret List.726;
 
 procedure Num.127 (#Attr.2):
     let Num.290 : U8 = lowlevel NumIntCast #Attr.2;

crates/compiler/test_mono/generated/encode_derived_string.txt

@@ -11,23 +11,23 @@ procedure Encode.26 (Encode.107, Encode.108):
     let Encode.110 : List U8 = CallByName Encode.24 Encode.111 Encode.112 Encode.108;
     ret Encode.110;
 
-procedure List.4 (List.139, List.140):
-    let List.704 : U64 = 1i64;
-    let List.703 : List U8 = CallByName List.70 List.139 List.704;
-    let List.702 : List U8 = CallByName List.71 List.703 List.140;
-    ret List.702;
+procedure List.4 (List.140, List.141):
+    let List.712 : U64 = 1i64;
+    let List.711 : List U8 = CallByName List.70 List.140 List.712;
+    let List.710 : List U8 = CallByName List.71 List.711 List.141;
+    ret List.710;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.698 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.698;
+    let List.706 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    ret List.706;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.696 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.696;
+    let List.704 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.704;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.706 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.706;
+    let List.714 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    ret List.714;
 
 procedure Num.127 (#Attr.2):
     let Num.290 : U8 = lowlevel NumIntCast #Attr.2;

crates/compiler/test_mono/generated/encode_derived_tag_one_field_string.txt

@@ -40,58 +40,58 @@ procedure Encode.26 (Encode.107, Encode.108):
     let Encode.110 : List U8 = CallByName Encode.24 Encode.111 Encode.112 Encode.108;
     ret Encode.110;
 
-procedure List.103 (#Derived_gen.22, #Derived_gen.23, #Derived_gen.24, #Derived_gen.25, #Derived_gen.26):
-    joinpoint List.697 List.178 List.179 List.180 List.181 List.182:
-        let List.699 : Int1 = CallByName Num.22 List.181 List.182;
-        if List.699 then
-            let List.703 : Str = CallByName List.66 List.178 List.181;
-            inc List.703;
-            let List.183 : List U8 = CallByName Test.64 List.179 List.703 List.180;
-            let List.702 : U64 = 1i64;
-            let List.701 : U64 = CallByName Num.51 List.181 List.702;
-            jump List.697 List.178 List.183 List.180 List.701 List.182;
+procedure List.104 (#Derived_gen.22, #Derived_gen.23, #Derived_gen.24, #Derived_gen.25, #Derived_gen.26):
+    joinpoint List.705 List.179 List.180 List.181 List.182 List.183:
+        let List.707 : Int1 = CallByName Num.22 List.182 List.183;
+        if List.707 then
+            let List.711 : Str = CallByName List.66 List.179 List.182;
+            inc List.711;
+            let List.184 : List U8 = CallByName Test.64 List.180 List.711 List.181;
+            let List.710 : U64 = 1i64;
+            let List.709 : U64 = CallByName Num.51 List.182 List.710;
+            jump List.705 List.179 List.184 List.181 List.709 List.183;
         else
-            dec List.178;
-            ret List.179;
+            dec List.179;
+            ret List.180;
     in
     inc #Derived_gen.22;
-    jump List.697 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26;
+    jump List.705 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26;
 
 procedure List.13 (#Attr.2, #Attr.3):
-    let List.720 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3;
-    ret List.720;
+    let List.728 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3;
+    ret List.728;
 
-procedure List.18 (List.175, List.176, List.177):
-    let List.695 : U64 = 0i64;
-    let List.696 : U64 = CallByName List.6 List.175;
-    let List.694 : List U8 = CallByName List.103 List.175 List.176 List.177 List.695 List.696;
-    ret List.694;
+procedure List.18 (List.176, List.177, List.178):
+    let List.703 : U64 = 0i64;
+    let List.704 : U64 = CallByName List.6 List.176;
+    let List.702 : List U8 = CallByName List.104 List.176 List.177 List.178 List.703 List.704;
+    ret List.702;
 
-procedure List.4 (List.139, List.140):
-    let List.716 : U64 = 1i64;
-    let List.715 : List U8 = CallByName List.70 List.139 List.716;
-    let List.714 : List U8 = CallByName List.71 List.715 List.140;
-    ret List.714;
+procedure List.4 (List.140, List.141):
+    let List.724 : U64 = 1i64;
+    let List.723 : List U8 = CallByName List.70 List.140 List.724;
+    let List.722 : List U8 = CallByName List.71 List.723 List.141;
+    ret List.722;
 
 procedure List.6 (#Attr.2):
-    let List.719 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.719;
+    let List.727 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.727;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.704 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.704;
+    let List.712 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.712;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.710 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.710;
+    let List.718 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    ret List.718;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.708 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.708;
+    let List.716 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.716;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.718 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.718;
+    let List.726 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    ret List.726;
 
 procedure Num.127 (#Attr.2):
     let Num.290 : U8 = lowlevel NumIntCast #Attr.2;

crates/compiler/test_mono/generated/encode_derived_tag_two_payloads_string.txt

@@ -43,58 +43,58 @@ procedure Encode.26 (Encode.107, Encode.108):
     let Encode.110 : List U8 = CallByName Encode.24 Encode.111 Encode.112 Encode.108;
     ret Encode.110;
 
-procedure List.103 (#Derived_gen.23, #Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_gen.27):
-    joinpoint List.697 List.178 List.179 List.180 List.181 List.182:
-        let List.699 : Int1 = CallByName Num.22 List.181 List.182;
-        if List.699 then
-            let List.703 : Str = CallByName List.66 List.178 List.181;
-            inc List.703;
-            let List.183 : List U8 = CallByName Test.64 List.179 List.703 List.180;
-            let List.702 : U64 = 1i64;
-            let List.701 : U64 = CallByName Num.51 List.181 List.702;
-            jump List.697 List.178 List.183 List.180 List.701 List.182;
+procedure List.104 (#Derived_gen.23, #Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_gen.27):
+    joinpoint List.705 List.179 List.180 List.181 List.182 List.183:
+        let List.707 : Int1 = CallByName Num.22 List.182 List.183;
+        if List.707 then
+            let List.711 : Str = CallByName List.66 List.179 List.182;
+            inc List.711;
+            let List.184 : List U8 = CallByName Test.64 List.180 List.711 List.181;
+            let List.710 : U64 = 1i64;
+            let List.709 : U64 = CallByName Num.51 List.182 List.710;
+            jump List.705 List.179 List.184 List.181 List.709 List.183;
         else
-            dec List.178;
-            ret List.179;
+            dec List.179;
+            ret List.180;
     in
     inc #Derived_gen.23;
-    jump List.697 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27;
+    jump List.705 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27;
 
 procedure List.13 (#Attr.2, #Attr.3):
-    let List.720 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3;
-    ret List.720;
+    let List.728 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3;
+    ret List.728;
 
-procedure List.18 (List.175, List.176, List.177):
-    let List.695 : U64 = 0i64;
-    let List.696 : U64 = CallByName List.6 List.175;
-    let List.694 : List U8 = CallByName List.103 List.175 List.176 List.177 List.695 List.696;
-    ret List.694;
+procedure List.18 (List.176, List.177, List.178):
+    let List.703 : U64 = 0i64;
+    let List.704 : U64 = CallByName List.6 List.176;
+    let List.702 : List U8 = CallByName List.104 List.176 List.177 List.178 List.703 List.704;
+    ret List.702;
 
-procedure List.4 (List.139, List.140):
-    let List.716 : U64 = 1i64;
-    let List.715 : List U8 = CallByName List.70 List.139 List.716;
-    let List.714 : List U8 = CallByName List.71 List.715 List.140;
-    ret List.714;
+procedure List.4 (List.140, List.141):
+    let List.724 : U64 = 1i64;
+    let List.723 : List U8 = CallByName List.70 List.140 List.724;
+    let List.722 : List U8 = CallByName List.71 List.723 List.141;
+    ret List.722;
 
 procedure List.6 (#Attr.2):
-    let List.719 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.719;
+    let List.727 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.727;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.704 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.704;
+    let List.712 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.712;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.710 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.710;
+    let List.718 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    ret List.718;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.708 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.708;
+    let List.716 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.716;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.718 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.718;
+    let List.726 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    ret List.726;
 
 procedure Num.127 (#Attr.2):
     let Num.290 : U8 = lowlevel NumIntCast #Attr.2;

crates/compiler/test_mono/generated/inspect_derived_dict.txt

@@ -898,171 +898,171 @@ procedure Inspect.63 (Inspect.295, Inspect.291):
 procedure Inspect.64 (Inspect.297):
     ret Inspect.297;
 
-procedure List.101 (#Derived_gen.34, #Derived_gen.35, #Derived_gen.36):
-    joinpoint List.745 List.155 List.156 List.157:
-        let List.753 : U64 = 0i64;
-        let List.747 : Int1 = CallByName Num.24 List.156 List.753;
-        if List.747 then
-            let List.752 : U64 = 1i64;
-            let List.749 : U64 = CallByName Num.75 List.156 List.752;
-            let List.750 : List {U32, U32} = CallByName List.71 List.157 List.155;
-            jump List.745 List.155 List.749 List.750;
+procedure List.102 (#Derived_gen.34, #Derived_gen.35, #Derived_gen.36):
+    joinpoint List.753 List.156 List.157 List.158:
+        let List.761 : U64 = 0i64;
+        let List.755 : Int1 = CallByName Num.24 List.157 List.761;
+        if List.755 then
+            let List.760 : U64 = 1i64;
+            let List.757 : U64 = CallByName Num.75 List.157 List.760;
+            let List.758 : List {U32, U32} = CallByName List.71 List.158 List.156;
+            jump List.753 List.156 List.757 List.758;
         else
-            ret List.157;
+            ret List.158;
     in
-    jump List.745 #Derived_gen.34 #Derived_gen.35 #Derived_gen.36;
+    jump List.753 #Derived_gen.34 #Derived_gen.35 #Derived_gen.36;
 
-procedure List.103 (#Derived_gen.37, #Derived_gen.38, #Derived_gen.39, #Derived_gen.40, #Derived_gen.41):
-    joinpoint List.697 List.178 List.179 List.180 List.181 List.182:
-        let List.699 : Int1 = CallByName Num.22 List.181 List.182;
-        if List.699 then
-            let List.703 : {Str, I64} = CallByName List.66 List.178 List.181;
-            inc List.703;
-            let List.183 : {List {U32, U32}, List {Str, I64}, U64, Float32, U8} = CallByName Dict.159 List.179 List.703;
-            let List.702 : U64 = 1i64;
-            let List.701 : U64 = CallByName Num.51 List.181 List.702;
-            jump List.697 List.178 List.183 List.180 List.701 List.182;
+procedure List.104 (#Derived_gen.37, #Derived_gen.38, #Derived_gen.39, #Derived_gen.40, #Derived_gen.41):
+    joinpoint List.705 List.179 List.180 List.181 List.182 List.183:
+        let List.707 : Int1 = CallByName Num.22 List.182 List.183;
+        if List.707 then
+            let List.711 : {Str, I64} = CallByName List.66 List.179 List.182;
+            inc List.711;
+            let List.184 : {List {U32, U32}, List {Str, I64}, U64, Float32, U8} = CallByName Dict.159 List.180 List.711;
+            let List.710 : U64 = 1i64;
+            let List.709 : U64 = CallByName Num.51 List.182 List.710;
+            jump List.705 List.179 List.184 List.181 List.709 List.183;
         else
-            dec List.178;
-            ret List.179;
+            dec List.179;
+            ret List.180;
     in
     inc #Derived_gen.37;
-    jump List.697 #Derived_gen.37 #Derived_gen.38 #Derived_gen.39 #Derived_gen.40 #Derived_gen.41;
+    jump List.705 #Derived_gen.37 #Derived_gen.38 #Derived_gen.39 #Derived_gen.40 #Derived_gen.41;
 
-procedure List.103 (#Derived_gen.42, #Derived_gen.43, #Derived_gen.44, #Derived_gen.45, #Derived_gen.46):
-    joinpoint List.760 List.178 List.179 List.180 List.181 List.182:
-        let List.762 : Int1 = CallByName Num.22 List.181 List.182;
-        if List.762 then
-            let List.766 : {Str, I64} = CallByName List.66 List.178 List.181;
-            inc List.766;
-            let List.183 : {Str, Int1} = CallByName Dict.188 List.179 List.766 List.180;
-            let List.765 : U64 = 1i64;
-            let List.764 : U64 = CallByName Num.51 List.181 List.765;
-            jump List.760 List.178 List.183 List.180 List.764 List.182;
+procedure List.104 (#Derived_gen.42, #Derived_gen.43, #Derived_gen.44, #Derived_gen.45, #Derived_gen.46):
+    joinpoint List.768 List.179 List.180 List.181 List.182 List.183:
+        let List.770 : Int1 = CallByName Num.22 List.182 List.183;
+        if List.770 then
+            let List.774 : {Str, I64} = CallByName List.66 List.179 List.182;
+            inc List.774;
+            let List.184 : {Str, Int1} = CallByName Dict.188 List.180 List.774 List.181;
+            let List.773 : U64 = 1i64;
+            let List.772 : U64 = CallByName Num.51 List.182 List.773;
+            jump List.768 List.179 List.184 List.181 List.772 List.183;
         else
-            dec List.178;
-            ret List.179;
+            dec List.179;
+            ret List.180;
     in
     inc #Derived_gen.42;
-    jump List.760 #Derived_gen.42 #Derived_gen.43 #Derived_gen.44 #Derived_gen.45 #Derived_gen.46;
+    jump List.768 #Derived_gen.42 #Derived_gen.43 #Derived_gen.44 #Derived_gen.45 #Derived_gen.46;
 
-procedure List.104 (#Derived_gen.47, #Derived_gen.48, #Derived_gen.49, #Derived_gen.50, #Derived_gen.51):
-    joinpoint List.736 List.187 List.188 List.189 List.190 List.191:
-        let List.738 : Int1 = CallByName Num.22 List.190 List.191;
-        if List.738 then
-            let List.742 : {Str, I64} = CallByName List.66 List.187 List.190;
-            inc List.742;
-            let List.192 : List {U32, U32} = CallByName Dict.407 List.188 List.742 List.190 List.189;
-            let List.741 : U64 = 1i64;
-            let List.740 : U64 = CallByName Num.51 List.190 List.741;
-            jump List.736 List.187 List.192 List.189 List.740 List.191;
+procedure List.105 (#Derived_gen.47, #Derived_gen.48, #Derived_gen.49, #Derived_gen.50, #Derived_gen.51):
+    joinpoint List.744 List.188 List.189 List.190 List.191 List.192:
+        let List.746 : Int1 = CallByName Num.22 List.191 List.192;
+        if List.746 then
+            let List.750 : {Str, I64} = CallByName List.66 List.188 List.191;
+            inc List.750;
+            let List.193 : List {U32, U32} = CallByName Dict.407 List.189 List.750 List.191 List.190;
+            let List.749 : U64 = 1i64;
+            let List.748 : U64 = CallByName Num.51 List.191 List.749;
+            jump List.744 List.188 List.193 List.190 List.748 List.192;
         else
-            dec List.187;
-            ret List.188;
+            dec List.188;
+            ret List.189;
     in
     inc #Derived_gen.47;
-    jump List.736 #Derived_gen.47 #Derived_gen.48 #Derived_gen.49 #Derived_gen.50 #Derived_gen.51;
+    jump List.744 #Derived_gen.47 #Derived_gen.48 #Derived_gen.49 #Derived_gen.50 #Derived_gen.51;
 
-procedure List.11 (List.153, List.154):
-    let List.756 : List {U32, U32} = CallByName List.68 List.154;
-    let List.755 : List {U32, U32} = CallByName List.101 List.153 List.154 List.756;
-    ret List.755;
+procedure List.11 (List.154, List.155):
+    let List.764 : List {U32, U32} = CallByName List.68 List.155;
+    let List.763 : List {U32, U32} = CallByName List.102 List.154 List.155 List.764;
+    ret List.763;
 
-procedure List.18 (List.175, List.176, List.177):
-    let List.695 : U64 = 0i64;
-    let List.696 : U64 = CallByName List.6 List.175;
-    let List.694 : {List {U32, U32}, List {Str, I64}, U64, Float32, U8} = CallByName List.103 List.175 List.176 List.177 List.695 List.696;
-    ret List.694;
+procedure List.18 (List.176, List.177, List.178):
+    let List.703 : U64 = 0i64;
+    let List.704 : U64 = CallByName List.6 List.176;
+    let List.702 : {List {U32, U32}, List {Str, I64}, U64, Float32, U8} = CallByName List.104 List.176 List.177 List.178 List.703 List.704;
+    ret List.702;
 
-procedure List.18 (List.175, List.176, List.177):
-    let List.758 : U64 = 0i64;
-    let List.759 : U64 = CallByName List.6 List.175;
-    let List.757 : {Str, Int1} = CallByName List.103 List.175 List.176 List.177 List.758 List.759;
-    ret List.757;
+procedure List.18 (List.176, List.177, List.178):
+    let List.766 : U64 = 0i64;
+    let List.767 : U64 = CallByName List.6 List.176;
+    let List.765 : {Str, Int1} = CallByName List.104 List.176 List.177 List.178 List.766 List.767;
+    ret List.765;
 
-procedure List.3 (List.131, List.132, List.133):
-    let List.720 : {List {U32, U32}, {U32, U32}} = CallByName List.64 List.131 List.132 List.133;
-    let List.719 : List {U32, U32} = StructAtIndex 0 List.720;
-    ret List.719;
+procedure List.3 (List.132, List.133, List.134):
+    let List.728 : {List {U32, U32}, {U32, U32}} = CallByName List.64 List.132 List.133 List.134;
+    let List.727 : List {U32, U32} = StructAtIndex 0 List.728;
+    ret List.727;
 
-procedure List.3 (List.131, List.132, List.133):
-    let List.722 : {List {Str, I64}, {Str, I64}} = CallByName List.64 List.131 List.132 List.133;
-    let List.721 : List {Str, I64} = StructAtIndex 0 List.722;
-    let #Derived_gen.74 : {Str, I64} = StructAtIndex 1 List.722;
+procedure List.3 (List.132, List.133, List.134):
+    let List.730 : {List {Str, I64}, {Str, I64}} = CallByName List.64 List.132 List.133 List.134;
+    let List.729 : List {Str, I64} = StructAtIndex 0 List.730;
+    let #Derived_gen.74 : {Str, I64} = StructAtIndex 1 List.730;
     dec #Derived_gen.74;
-    ret List.721;
+    ret List.729;
 
-procedure List.4 (List.139, List.140):
-    let List.731 : U64 = 1i64;
-    let List.729 : List {Str, I64} = CallByName List.70 List.139 List.731;
-    let List.728 : List {Str, I64} = CallByName List.71 List.729 List.140;
-    ret List.728;
+procedure List.4 (List.140, List.141):
+    let List.739 : U64 = 1i64;
+    let List.737 : List {Str, I64} = CallByName List.70 List.140 List.739;
+    let List.736 : List {Str, I64} = CallByName List.71 List.737 List.141;
+    ret List.736;
 
 procedure List.6 (#Attr.2):
-    let List.710 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.710;
+    let List.718 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.718;
 
 procedure List.6 (#Attr.2):
-    let List.768 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.768;
+    let List.776 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.776;
 
 procedure List.6 (#Attr.2):
-    let List.769 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.769;
+    let List.777 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.777;
 
-procedure List.64 (List.128, List.129, List.130):
-    let List.718 : U64 = CallByName List.6 List.128;
-    let List.715 : Int1 = CallByName Num.22 List.129 List.718;
-    if List.715 then
-        let List.716 : {List {U32, U32}, {U32, U32}} = CallByName List.67 List.128 List.129 List.130;
-        ret List.716;
+procedure List.64 (List.129, List.130, List.131):
+    let List.726 : U64 = CallByName List.6 List.129;
+    let List.723 : Int1 = CallByName Num.22 List.130 List.726;
+    if List.723 then
+        let List.724 : {List {U32, U32}, {U32, U32}} = CallByName List.67 List.129 List.130 List.131;
+        ret List.724;
     else
-        let List.714 : {List {U32, U32}, {U32, U32}} = Struct {List.128, List.130};
-        ret List.714;
+        let List.722 : {List {U32, U32}, {U32, U32}} = Struct {List.129, List.131};
+        ret List.722;
 
-procedure List.64 (List.128, List.129, List.130):
-    let List.727 : U64 = CallByName List.6 List.128;
-    let List.724 : Int1 = CallByName Num.22 List.129 List.727;
-    if List.724 then
-        let List.725 : {List {Str, I64}, {Str, I64}} = CallByName List.67 List.128 List.129 List.130;
-        ret List.725;
+procedure List.64 (List.129, List.130, List.131):
+    let List.735 : U64 = CallByName List.6 List.129;
+    let List.732 : Int1 = CallByName Num.22 List.130 List.735;
+    if List.732 then
+        let List.733 : {List {Str, I64}, {Str, I64}} = CallByName List.67 List.129 List.130 List.131;
+        ret List.733;
     else
-        let List.723 : {List {Str, I64}, {Str, I64}} = Struct {List.128, List.130};
-        ret List.723;
+        let List.731 : {List {Str, I64}, {Str, I64}} = Struct {List.129, List.131};
+        ret List.731;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.767 : {Str, I64} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.767;
+    let List.775 : {Str, I64} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.775;
 
 procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
-    let List.717 : {List {U32, U32}, {U32, U32}} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
-    ret List.717;
+    let List.725 : {List {U32, U32}, {U32, U32}} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
+    ret List.725;
 
 procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
-    let List.726 : {List {Str, I64}, {Str, I64}} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
-    ret List.726;
+    let List.734 : {List {Str, I64}, {Str, I64}} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
+    ret List.734;
 
 procedure List.68 (#Attr.2):
-    let List.754 : List {U32, U32} = lowlevel ListWithCapacity #Attr.2;
-    ret List.754;
+    let List.762 : List {U32, U32} = lowlevel ListWithCapacity #Attr.2;
+    ret List.762;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.732 : List {Str, I64} = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.732;
+    let List.740 : List {Str, I64} = lowlevel ListReserve #Attr.2 #Attr.3;
+    ret List.740;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.730 : List {Str, I64} = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.730;
+    let List.738 : List {Str, I64} = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.738;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.751 : List {U32, U32} = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.751;
+    let List.759 : List {U32, U32} = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.759;
 
-procedure List.83 (List.184, List.185, List.186):
-    let List.734 : U64 = 0i64;
-    let List.735 : U64 = CallByName List.6 List.184;
-    let List.733 : List {U32, U32} = CallByName List.104 List.184 List.185 List.186 List.734 List.735;
-    ret List.733;
+procedure List.83 (List.185, List.186, List.187):
+    let List.742 : U64 = 0i64;
+    let List.743 : U64 = CallByName List.6 List.185;
+    let List.741 : List {U32, U32} = CallByName List.105 List.185 List.186 List.187 List.742 List.743;
+    ret List.741;
 
 procedure Num.131 (#Attr.2):
     let Num.297 : U32 = lowlevel NumIntCast #Attr.2;

crates/compiler/test_mono/generated/inspect_derived_list.txt

@@ -120,35 +120,35 @@ procedure Inspect.63 (Inspect.295, Inspect.291):
 procedure Inspect.64 (Inspect.297):
     ret Inspect.297;
 
-procedure List.103 (#Derived_gen.10, #Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14):
-    joinpoint List.697 List.178 List.179 List.180 List.181 List.182:
-        let List.699 : Int1 = CallByName Num.22 List.181 List.182;
-        if List.699 then
-            let List.703 : I64 = CallByName List.66 List.178 List.181;
-            let List.183 : {Str, Int1} = CallByName Inspect.160 List.179 List.703 List.180;
-            let List.702 : U64 = 1i64;
-            let List.701 : U64 = CallByName Num.51 List.181 List.702;
-            jump List.697 List.178 List.183 List.180 List.701 List.182;
+procedure List.104 (#Derived_gen.10, #Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14):
+    joinpoint List.705 List.179 List.180 List.181 List.182 List.183:
+        let List.707 : Int1 = CallByName Num.22 List.182 List.183;
+        if List.707 then
+            let List.711 : I64 = CallByName List.66 List.179 List.182;
+            let List.184 : {Str, Int1} = CallByName Inspect.160 List.180 List.711 List.181;
+            let List.710 : U64 = 1i64;
+            let List.709 : U64 = CallByName Num.51 List.182 List.710;
+            jump List.705 List.179 List.184 List.181 List.709 List.183;
         else
-            dec List.178;
-            ret List.179;
+            dec List.179;
+            ret List.180;
     in
     inc #Derived_gen.10;
-    jump List.697 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14;
+    jump List.705 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14;
 
-procedure List.18 (List.175, List.176, List.177):
-    let List.695 : U64 = 0i64;
-    let List.696 : U64 = CallByName List.6 List.175;
-    let List.694 : {Str, Int1} = CallByName List.103 List.175 List.176 List.177 List.695 List.696;
-    ret List.694;
+procedure List.18 (List.176, List.177, List.178):
+    let List.703 : U64 = 0i64;
+    let List.704 : U64 = CallByName List.6 List.176;
+    let List.702 : {Str, Int1} = CallByName List.104 List.176 List.177 List.178 List.703 List.704;
+    ret List.702;
 
 procedure List.6 (#Attr.2):
-    let List.705 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.705;
+    let List.713 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.713;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.704 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.704;
+    let List.712 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.712;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.291 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/inspect_derived_nested_record_string.txt

@@ -231,67 +231,67 @@ procedure Inspect.63 (Inspect.295, Inspect.291):
 procedure Inspect.64 (Inspect.297):
     ret Inspect.297;
 
-procedure List.103 (#Derived_gen.33, #Derived_gen.34, #Derived_gen.35, #Derived_gen.36, #Derived_gen.37):
-    joinpoint List.697 List.178 List.179 List.180 List.181 List.182:
-        let List.699 : Int1 = CallByName Num.22 List.181 List.182;
-        if List.699 then
-            let List.703 : {Str, Str} = CallByName List.66 List.178 List.181;
-            inc List.703;
-            let List.183 : {Str, Int1} = CallByName Inspect.229 List.179 List.703;
-            let List.702 : U64 = 1i64;
-            let List.701 : U64 = CallByName Num.51 List.181 List.702;
-            jump List.697 List.178 List.183 List.180 List.701 List.182;
+procedure List.104 (#Derived_gen.33, #Derived_gen.34, #Derived_gen.35, #Derived_gen.36, #Derived_gen.37):
+    joinpoint List.705 List.179 List.180 List.181 List.182 List.183:
+        let List.707 : Int1 = CallByName Num.22 List.182 List.183;
+        if List.707 then
+            let List.711 : {Str, Str} = CallByName List.66 List.179 List.182;
+            inc List.711;
+            let List.184 : {Str, Int1} = CallByName Inspect.229 List.180 List.711;
+            let List.710 : U64 = 1i64;
+            let List.709 : U64 = CallByName Num.51 List.182 List.710;
+            jump List.705 List.179 List.184 List.181 List.709 List.183;
         else
-            dec List.178;
-            ret List.179;
+            dec List.179;
+            ret List.180;
     in
     inc #Derived_gen.33;
-    jump List.697 #Derived_gen.33 #Derived_gen.34 #Derived_gen.35 #Derived_gen.36 #Derived_gen.37;
+    jump List.705 #Derived_gen.33 #Derived_gen.34 #Derived_gen.35 #Derived_gen.36 #Derived_gen.37;
 
-procedure List.103 (#Derived_gen.38, #Derived_gen.39, #Derived_gen.40, #Derived_gen.41, #Derived_gen.42):
-    joinpoint List.709 List.178 List.179 List.180 List.181 List.182:
-        let List.711 : Int1 = CallByName Num.22 List.181 List.182;
-        if List.711 then
-            let List.715 : {Str, Str} = CallByName List.66 List.178 List.181;
-            inc List.715;
-            let List.183 : {Str, Int1} = CallByName Inspect.229 List.179 List.715;
-            let List.714 : U64 = 1i64;
-            let List.713 : U64 = CallByName Num.51 List.181 List.714;
-            jump List.709 List.178 List.183 List.180 List.713 List.182;
+procedure List.104 (#Derived_gen.38, #Derived_gen.39, #Derived_gen.40, #Derived_gen.41, #Derived_gen.42):
+    joinpoint List.717 List.179 List.180 List.181 List.182 List.183:
+        let List.719 : Int1 = CallByName Num.22 List.182 List.183;
+        if List.719 then
+            let List.723 : {Str, Str} = CallByName List.66 List.179 List.182;
+            inc List.723;
+            let List.184 : {Str, Int1} = CallByName Inspect.229 List.180 List.723;
+            let List.722 : U64 = 1i64;
+            let List.721 : U64 = CallByName Num.51 List.182 List.722;
+            jump List.717 List.179 List.184 List.181 List.721 List.183;
         else
-            dec List.178;
-            ret List.179;
+            dec List.179;
+            ret List.180;
     in
     inc #Derived_gen.38;
-    jump List.709 #Derived_gen.38 #Derived_gen.39 #Derived_gen.40 #Derived_gen.41 #Derived_gen.42;
+    jump List.717 #Derived_gen.38 #Derived_gen.39 #Derived_gen.40 #Derived_gen.41 #Derived_gen.42;
 
-procedure List.18 (List.175, List.176, List.177):
-    let List.695 : U64 = 0i64;
-    let List.696 : U64 = CallByName List.6 List.175;
-    let List.694 : {Str, Int1} = CallByName List.103 List.175 List.176 List.177 List.695 List.696;
-    ret List.694;
+procedure List.18 (List.176, List.177, List.178):
+    let List.703 : U64 = 0i64;
+    let List.704 : U64 = CallByName List.6 List.176;
+    let List.702 : {Str, Int1} = CallByName List.104 List.176 List.177 List.178 List.703 List.704;
+    ret List.702;
 
-procedure List.18 (List.175, List.176, List.177):
-    let List.707 : U64 = 0i64;
-    let List.708 : U64 = CallByName List.6 List.175;
-    let List.706 : {Str, Int1} = CallByName List.103 List.175 List.176 List.177 List.707 List.708;
-    ret List.706;
+procedure List.18 (List.176, List.177, List.178):
+    let List.715 : U64 = 0i64;
+    let List.716 : U64 = CallByName List.6 List.176;
+    let List.714 : {Str, Int1} = CallByName List.104 List.176 List.177 List.178 List.715 List.716;
+    ret List.714;
 
 procedure List.6 (#Attr.2):
-    let List.705 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.705;
+    let List.713 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.713;
 
 procedure List.6 (#Attr.2):
-    let List.717 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.717;
+    let List.725 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.725;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.704 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.704;
+    let List.712 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.712;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.716 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.716;
+    let List.724 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.724;
 
 procedure Num.20 (#Attr.2, #Attr.3):
     let Num.296 : U64 = lowlevel NumSub #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/inspect_derived_record.txt

@@ -150,36 +150,36 @@ procedure Inspect.63 (Inspect.295, Inspect.291):
 procedure Inspect.64 (Inspect.297):
     ret Inspect.297;
 
-procedure List.103 (#Derived_gen.16, #Derived_gen.17, #Derived_gen.18, #Derived_gen.19, #Derived_gen.20):
-    joinpoint List.697 List.178 List.179 List.180 List.181 List.182:
-        let List.699 : Int1 = CallByName Num.22 List.181 List.182;
-        if List.699 then
-            let List.703 : {[C I64, C Decimal], Str} = CallByName List.66 List.178 List.181;
-            inc List.703;
-            let List.183 : {Str, Int1} = CallByName Inspect.229 List.179 List.703;
-            let List.702 : U64 = 1i64;
-            let List.701 : U64 = CallByName Num.51 List.181 List.702;
-            jump List.697 List.178 List.183 List.180 List.701 List.182;
+procedure List.104 (#Derived_gen.16, #Derived_gen.17, #Derived_gen.18, #Derived_gen.19, #Derived_gen.20):
+    joinpoint List.705 List.179 List.180 List.181 List.182 List.183:
+        let List.707 : Int1 = CallByName Num.22 List.182 List.183;
+        if List.707 then
+            let List.711 : {[C I64, C Decimal], Str} = CallByName List.66 List.179 List.182;
+            inc List.711;
+            let List.184 : {Str, Int1} = CallByName Inspect.229 List.180 List.711;
+            let List.710 : U64 = 1i64;
+            let List.709 : U64 = CallByName Num.51 List.182 List.710;
+            jump List.705 List.179 List.184 List.181 List.709 List.183;
         else
-            dec List.178;
-            ret List.179;
+            dec List.179;
+            ret List.180;
     in
     inc #Derived_gen.16;
-    jump List.697 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20;
+    jump List.705 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20;
 
-procedure List.18 (List.175, List.176, List.177):
-    let List.695 : U64 = 0i64;
-    let List.696 : U64 = CallByName List.6 List.175;
-    let List.694 : {Str, Int1} = CallByName List.103 List.175 List.176 List.177 List.695 List.696;
-    ret List.694;
+procedure List.18 (List.176, List.177, List.178):
+    let List.703 : U64 = 0i64;
+    let List.704 : U64 = CallByName List.6 List.176;
+    let List.702 : {Str, Int1} = CallByName List.104 List.176 List.177 List.178 List.703 List.704;
+    ret List.702;
 
 procedure List.6 (#Attr.2):
-    let List.705 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.705;
+    let List.713 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.713;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.704 : {[C I64, C Decimal], Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.704;
+    let List.712 : {[C I64, C Decimal], Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.712;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.292 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/inspect_derived_record_one_field_string.txt

@@ -156,36 +156,36 @@ procedure Inspect.63 (Inspect.295, Inspect.291):
 procedure Inspect.64 (Inspect.297):
     ret Inspect.297;
 
-procedure List.103 (#Derived_gen.21, #Derived_gen.22, #Derived_gen.23, #Derived_gen.24, #Derived_gen.25):
-    joinpoint List.697 List.178 List.179 List.180 List.181 List.182:
-        let List.699 : Int1 = CallByName Num.22 List.181 List.182;
-        if List.699 then
-            let List.703 : {Str, Str} = CallByName List.66 List.178 List.181;
-            inc List.703;
-            let List.183 : {Str, Int1} = CallByName Inspect.229 List.179 List.703;
-            let List.702 : U64 = 1i64;
-            let List.701 : U64 = CallByName Num.51 List.181 List.702;
-            jump List.697 List.178 List.183 List.180 List.701 List.182;
+procedure List.104 (#Derived_gen.21, #Derived_gen.22, #Derived_gen.23, #Derived_gen.24, #Derived_gen.25):
+    joinpoint List.705 List.179 List.180 List.181 List.182 List.183:
+        let List.707 : Int1 = CallByName Num.22 List.182 List.183;
+        if List.707 then
+            let List.711 : {Str, Str} = CallByName List.66 List.179 List.182;
+            inc List.711;
+            let List.184 : {Str, Int1} = CallByName Inspect.229 List.180 List.711;
+            let List.710 : U64 = 1i64;
+            let List.709 : U64 = CallByName Num.51 List.182 List.710;
+            jump List.705 List.179 List.184 List.181 List.709 List.183;
         else
-            dec List.178;
-            ret List.179;
+            dec List.179;
+            ret List.180;
     in
     inc #Derived_gen.21;
-    jump List.697 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25;
+    jump List.705 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25;
 
-procedure List.18 (List.175, List.176, List.177):
-    let List.695 : U64 = 0i64;
-    let List.696 : U64 = CallByName List.6 List.175;
-    let List.694 : {Str, Int1} = CallByName List.103 List.175 List.176 List.177 List.695 List.696;
-    ret List.694;
+procedure List.18 (List.176, List.177, List.178):
+    let List.703 : U64 = 0i64;
+    let List.704 : U64 = CallByName List.6 List.176;
+    let List.702 : {Str, Int1} = CallByName List.104 List.176 List.177 List.178 List.703 List.704;
+    ret List.702;
 
 procedure List.6 (#Attr.2):
-    let List.705 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.705;
+    let List.713 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.713;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.704 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.704;
+    let List.712 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.712;
 
 procedure Num.20 (#Attr.2, #Attr.3):
     let Num.294 : U64 = lowlevel NumSub #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/inspect_derived_record_two_field_strings.txt

@@ -163,36 +163,36 @@ procedure Inspect.63 (Inspect.295, Inspect.291):
 procedure Inspect.64 (Inspect.297):
     ret Inspect.297;
 
-procedure List.103 (#Derived_gen.25, #Derived_gen.26, #Derived_gen.27, #Derived_gen.28, #Derived_gen.29):
-    joinpoint List.697 List.178 List.179 List.180 List.181 List.182:
-        let List.699 : Int1 = CallByName Num.22 List.181 List.182;
-        if List.699 then
-            let List.703 : {Str, Str} = CallByName List.66 List.178 List.181;
-            inc List.703;
-            let List.183 : {Str, Int1} = CallByName Inspect.229 List.179 List.703;
-            let List.702 : U64 = 1i64;
-            let List.701 : U64 = CallByName Num.51 List.181 List.702;
-            jump List.697 List.178 List.183 List.180 List.701 List.182;
+procedure List.104 (#Derived_gen.25, #Derived_gen.26, #Derived_gen.27, #Derived_gen.28, #Derived_gen.29):
+    joinpoint List.705 List.179 List.180 List.181 List.182 List.183:
+        let List.707 : Int1 = CallByName Num.22 List.182 List.183;
+        if List.707 then
+            let List.711 : {Str, Str} = CallByName List.66 List.179 List.182;
+            inc List.711;
+            let List.184 : {Str, Int1} = CallByName Inspect.229 List.180 List.711;
+            let List.710 : U64 = 1i64;
+            let List.709 : U64 = CallByName Num.51 List.182 List.710;
+            jump List.705 List.179 List.184 List.181 List.709 List.183;
         else
-            dec List.178;
-            ret List.179;
+            dec List.179;
+            ret List.180;
     in
     inc #Derived_gen.25;
-    jump List.697 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29;
+    jump List.705 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29;
 
-procedure List.18 (List.175, List.176, List.177):
-    let List.695 : U64 = 0i64;
-    let List.696 : U64 = CallByName List.6 List.175;
-    let List.694 : {Str, Int1} = CallByName List.103 List.175 List.176 List.177 List.695 List.696;
-    ret List.694;
+procedure List.18 (List.176, List.177, List.178):
+    let List.703 : U64 = 0i64;
+    let List.704 : U64 = CallByName List.6 List.176;
+    let List.702 : {Str, Int1} = CallByName List.104 List.176 List.177 List.178 List.703 List.704;
+    ret List.702;
 
 procedure List.6 (#Attr.2):
-    let List.705 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.705;
+    let List.713 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.713;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.704 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.704;
+    let List.712 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.712;
 
 procedure Num.20 (#Attr.2, #Attr.3):
     let Num.294 : U64 = lowlevel NumSub #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/inspect_derived_tag_one_field_string.txt

@@ -156,43 +156,43 @@ procedure Inspect.63 (Inspect.295, Inspect.291):
 procedure Inspect.64 (Inspect.297):
     ret Inspect.297;
 
-procedure List.1 (List.122):
-    let List.707 : U64 = CallByName List.6 List.122;
-    let List.708 : U64 = 0i64;
-    let List.706 : Int1 = CallByName Bool.9 List.707 List.708;
-    ret List.706;
+procedure List.1 (List.123):
+    let List.715 : U64 = CallByName List.6 List.123;
+    let List.716 : U64 = 0i64;
+    let List.714 : Int1 = CallByName Bool.9 List.715 List.716;
+    ret List.714;
 
-procedure List.103 (#Derived_gen.21, #Derived_gen.22, #Derived_gen.23, #Derived_gen.24, #Derived_gen.25):
-    joinpoint List.697 List.178 List.179 List.180 List.181 List.182:
-        let List.699 : Int1 = CallByName Num.22 List.181 List.182;
-        if List.699 then
-            let List.703 : Str = CallByName List.66 List.178 List.181;
-            inc List.703;
-            let List.183 : Str = CallByName Inspect.207 List.179 List.703;
-            dec List.703;
-            let List.702 : U64 = 1i64;
-            let List.701 : U64 = CallByName Num.51 List.181 List.702;
-            jump List.697 List.178 List.183 List.180 List.701 List.182;
+procedure List.104 (#Derived_gen.21, #Derived_gen.22, #Derived_gen.23, #Derived_gen.24, #Derived_gen.25):
+    joinpoint List.705 List.179 List.180 List.181 List.182 List.183:
+        let List.707 : Int1 = CallByName Num.22 List.182 List.183;
+        if List.707 then
+            let List.711 : Str = CallByName List.66 List.179 List.182;
+            inc List.711;
+            let List.184 : Str = CallByName Inspect.207 List.180 List.711;
+            dec List.711;
+            let List.710 : U64 = 1i64;
+            let List.709 : U64 = CallByName Num.51 List.182 List.710;
+            jump List.705 List.179 List.184 List.181 List.709 List.183;
         else
-            dec List.178;
-            ret List.179;
+            dec List.179;
+            ret List.180;
     in
     inc #Derived_gen.21;
-    jump List.697 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25;
+    jump List.705 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25;
 
-procedure List.18 (List.175, List.176, List.177):
-    let List.695 : U64 = 0i64;
-    let List.696 : U64 = CallByName List.6 List.175;
-    let List.694 : Str = CallByName List.103 List.175 List.176 List.177 List.695 List.696;
-    ret List.694;
+procedure List.18 (List.176, List.177, List.178):
+    let List.703 : U64 = 0i64;
+    let List.704 : U64 = CallByName List.6 List.176;
+    let List.702 : Str = CallByName List.104 List.176 List.177 List.178 List.703 List.704;
+    ret List.702;
 
 procedure List.6 (#Attr.2):
-    let List.705 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.705;
+    let List.713 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.713;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.704 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.704;
+    let List.712 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.712;
 
 procedure Num.20 (#Attr.2, #Attr.3):
     let Num.294 : U64 = lowlevel NumSub #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/inspect_derived_tag_two_payloads_string.txt

@@ -159,43 +159,43 @@ procedure Inspect.63 (Inspect.295, Inspect.291):
 procedure Inspect.64 (Inspect.297):
     ret Inspect.297;
 
-procedure List.1 (List.122):
-    let List.707 : U64 = CallByName List.6 List.122;
-    let List.708 : U64 = 0i64;
-    let List.706 : Int1 = CallByName Bool.9 List.707 List.708;
-    ret List.706;
+procedure List.1 (List.123):
+    let List.715 : U64 = CallByName List.6 List.123;
+    let List.716 : U64 = 0i64;
+    let List.714 : Int1 = CallByName Bool.9 List.715 List.716;
+    ret List.714;
 
-procedure List.103 (#Derived_gen.22, #Derived_gen.23, #Derived_gen.24, #Derived_gen.25, #Derived_gen.26):
-    joinpoint List.697 List.178 List.179 List.180 List.181 List.182:
-        let List.699 : Int1 = CallByName Num.22 List.181 List.182;
-        if List.699 then
-            let List.703 : Str = CallByName List.66 List.178 List.181;
-            inc List.703;
-            let List.183 : Str = CallByName Inspect.207 List.179 List.703;
-            dec List.703;
-            let List.702 : U64 = 1i64;
-            let List.701 : U64 = CallByName Num.51 List.181 List.702;
-            jump List.697 List.178 List.183 List.180 List.701 List.182;
+procedure List.104 (#Derived_gen.22, #Derived_gen.23, #Derived_gen.24, #Derived_gen.25, #Derived_gen.26):
+    joinpoint List.705 List.179 List.180 List.181 List.182 List.183:
+        let List.707 : Int1 = CallByName Num.22 List.182 List.183;
+        if List.707 then
+            let List.711 : Str = CallByName List.66 List.179 List.182;
+            inc List.711;
+            let List.184 : Str = CallByName Inspect.207 List.180 List.711;
+            dec List.711;
+            let List.710 : U64 = 1i64;
+            let List.709 : U64 = CallByName Num.51 List.182 List.710;
+            jump List.705 List.179 List.184 List.181 List.709 List.183;
         else
-            dec List.178;
-            ret List.179;
+            dec List.179;
+            ret List.180;
     in
     inc #Derived_gen.22;
-    jump List.697 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26;
+    jump List.705 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26;
 
-procedure List.18 (List.175, List.176, List.177):
-    let List.695 : U64 = 0i64;
-    let List.696 : U64 = CallByName List.6 List.175;
-    let List.694 : Str = CallByName List.103 List.175 List.176 List.177 List.695 List.696;
-    ret List.694;
+procedure List.18 (List.176, List.177, List.178):
+    let List.703 : U64 = 0i64;
+    let List.704 : U64 = CallByName List.6 List.176;
+    let List.702 : Str = CallByName List.104 List.176 List.177 List.178 List.703 List.704;
+    ret List.702;
 
 procedure List.6 (#Attr.2):
-    let List.705 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.705;
+    let List.713 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.713;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.704 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.704;
+    let List.712 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.712;
 
 procedure Num.20 (#Attr.2, #Attr.3):
     let Num.294 : U64 = lowlevel NumSub #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/ir_int_add.txt

@@ -1,6 +1,6 @@
 procedure List.6 (#Attr.2):
-    let List.694 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.694;
+    let List.702 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.702;
 
 procedure Num.19 (#Attr.2, #Attr.3):
     let Num.291 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/issue_2583_specialize_errors_behind_unified_branches.txt

@@ -6,40 +6,40 @@ procedure Bool.9 (#Attr.2, #Attr.3):
     let Bool.22 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
     ret Bool.22;
 
-procedure List.2 (List.123, List.124):
-    let List.708 : U64 = CallByName List.6 List.123;
-    let List.704 : Int1 = CallByName Num.22 List.124 List.708;
-    if List.704 then
-        let List.706 : I64 = CallByName List.66 List.123 List.124;
-        let List.705 : [C {}, C I64] = TagId(1) List.706;
-        ret List.705;
+procedure List.2 (List.124, List.125):
+    let List.716 : U64 = CallByName List.6 List.124;
+    let List.712 : Int1 = CallByName Num.22 List.125 List.716;
+    if List.712 then
+        let List.714 : I64 = CallByName List.66 List.124 List.125;
+        let List.713 : [C {}, C I64] = TagId(1) List.714;
+        ret List.713;
     else
-        let List.703 : {} = Struct {};
-        let List.702 : [C {}, C I64] = TagId(0) List.703;
-        ret List.702;
+        let List.711 : {} = Struct {};
+        let List.710 : [C {}, C I64] = TagId(0) List.711;
+        ret List.710;
 
 procedure List.6 (#Attr.2):
-    let List.709 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.709;
+    let List.717 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.717;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.707 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.707;
+    let List.715 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.715;
 
-procedure List.9 (List.404):
-    let List.701 : U64 = 0i64;
-    let List.694 : [C {}, C I64] = CallByName List.2 List.404 List.701;
-    let List.698 : U8 = 1i64;
-    let List.699 : U8 = GetTagId List.694;
-    let List.700 : Int1 = lowlevel Eq List.698 List.699;
-    if List.700 then
-        let List.405 : I64 = UnionAtIndex (Id 1) (Index 0) List.694;
-        let List.695 : [C Int1, C I64] = TagId(1) List.405;
-        ret List.695;
+procedure List.9 (List.405):
+    let List.709 : U64 = 0i64;
+    let List.702 : [C {}, C I64] = CallByName List.2 List.405 List.709;
+    let List.706 : U8 = 1i64;
+    let List.707 : U8 = GetTagId List.702;
+    let List.708 : Int1 = lowlevel Eq List.706 List.707;
+    if List.708 then
+        let List.406 : I64 = UnionAtIndex (Id 1) (Index 0) List.702;
+        let List.703 : [C Int1, C I64] = TagId(1) List.406;
+        ret List.703;
     else
-        let List.697 : Int1 = true;
-        let List.696 : [C Int1, C I64] = TagId(0) List.697;
-        ret List.696;
+        let List.705 : Int1 = true;
+        let List.704 : [C Int1, C I64] = TagId(0) List.705;
+        ret List.704;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.289 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/issue_4770.txt

@@ -6,118 +6,118 @@ procedure Bool.2 ():
     let Bool.22 : Int1 = true;
     ret Bool.22;
 
-procedure List.109 (Bool.30, Bool.31, Bool.32, Bool.33, Bool.34, Bool.35):
-    joinpoint List.732 List.303 List.304 List.305 List.306 List.307 List.308:
-        let List.734 : Int1 = CallByName Num.22 List.307 List.308;
-        if List.734 then
-            let List.740 : [<r>C I64, C List *self] = CallByName List.66 List.303 List.307;
-            inc List.740;
-            let List.741 : [<r>C I64, C List *self] = CallByName List.66 List.304 List.307;
-            inc List.741;
-            let List.309 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName Test.15 List.740 List.741;
-            let List.736 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.71 List.305 List.309;
-            let List.738 : U64 = 1i64;
-            let List.737 : U64 = CallByName Num.51 List.307 List.738;
-            jump List.732 List.303 List.304 List.736 List.306 List.737 List.308;
+procedure List.110 (Bool.30, Bool.31, Bool.32, Bool.33, Bool.34, Bool.35):
+    joinpoint List.740 List.304 List.305 List.306 List.307 List.308 List.309:
+        let List.742 : Int1 = CallByName Num.22 List.308 List.309;
+        if List.742 then
+            let List.748 : [<r>C I64, C List *self] = CallByName List.66 List.304 List.308;
+            inc List.748;
+            let List.749 : [<r>C I64, C List *self] = CallByName List.66 List.305 List.308;
+            inc List.749;
+            let List.310 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName Test.15 List.748 List.749;
+            let List.744 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.71 List.306 List.310;
+            let List.746 : U64 = 1i64;
+            let List.745 : U64 = CallByName Num.51 List.308 List.746;
+            jump List.740 List.304 List.305 List.744 List.307 List.745 List.309;
         else
             dec List.304;
-            dec List.303;
-            ret List.305;
+            dec List.305;
+            ret List.306;
     in
     inc Bool.30;
     inc Bool.31;
-    jump List.732 Bool.30 Bool.31 Bool.32 Bool.33 Bool.34 Bool.35;
+    jump List.740 Bool.30 Bool.31 Bool.32 Bool.33 Bool.34 Bool.35;
 
-procedure List.119 (List.582, List.583, List.584):
-    let List.708 : U64 = 0i64;
-    let List.709 : U64 = CallByName List.6 List.582;
-    let List.707 : [C {}, C {}] = CallByName List.80 List.582 List.583 List.584 List.708 List.709;
-    ret List.707;
+procedure List.120 (List.590, List.591, List.592):
+    let List.716 : U64 = 0i64;
+    let List.717 : U64 = CallByName List.6 List.590;
+    let List.715 : [C {}, C {}] = CallByName List.80 List.590 List.591 List.592 List.716 List.717;
+    ret List.715;
 
-procedure List.23 (List.299, List.300, List.301):
-    let List.744 : U64 = CallByName List.6 List.299;
-    let List.745 : U64 = CallByName List.6 List.300;
-    let List.302 : U64 = CallByName Num.148 List.744 List.745;
-    let List.730 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.68 List.302;
-    let List.731 : U64 = 0i64;
-    let List.729 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.109 List.299 List.300 List.730 List.301 List.731 List.302;
-    ret List.729;
+procedure List.23 (List.300, List.301, List.302):
+    let List.752 : U64 = CallByName List.6 List.300;
+    let List.753 : U64 = CallByName List.6 List.301;
+    let List.303 : U64 = CallByName Num.148 List.752 List.753;
+    let List.738 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.68 List.303;
+    let List.739 : U64 = 0i64;
+    let List.737 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.110 List.300 List.301 List.738 List.302 List.739 List.303;
+    ret List.737;
 
-procedure List.251 (List.696, List.252, List.250):
-    let List.726 : Int1 = CallByName Test.1 List.252;
-    if List.726 then
-        let List.728 : {} = Struct {};
-        let List.727 : [C {}, C {}] = TagId(1) List.728;
-        ret List.727;
+procedure List.252 (List.704, List.253, List.251):
+    let List.734 : Int1 = CallByName Test.1 List.253;
+    if List.734 then
+        let List.736 : {} = Struct {};
+        let List.735 : [C {}, C {}] = TagId(1) List.736;
+        ret List.735;
     else
-        let List.725 : {} = Struct {};
-        let List.724 : [C {}, C {}] = TagId(0) List.725;
-        ret List.724;
+        let List.733 : {} = Struct {};
+        let List.732 : [C {}, C {}] = TagId(0) List.733;
+        ret List.732;
 
-procedure List.56 (List.249, List.250):
-    let List.705 : {} = Struct {};
-    let List.697 : [C {}, C {}] = CallByName List.119 List.249 List.705 List.250;
-    let List.702 : U8 = 1i64;
-    let List.703 : U8 = GetTagId List.697;
-    let List.704 : Int1 = lowlevel Eq List.702 List.703;
-    if List.704 then
-        let List.698 : Int1 = CallByName Bool.2;
-        ret List.698;
+procedure List.56 (List.250, List.251):
+    let List.713 : {} = Struct {};
+    let List.705 : [C {}, C {}] = CallByName List.120 List.250 List.713 List.251;
+    let List.710 : U8 = 1i64;
+    let List.711 : U8 = GetTagId List.705;
+    let List.712 : Int1 = lowlevel Eq List.710 List.711;
+    if List.712 then
+        let List.706 : Int1 = CallByName Bool.2;
+        ret List.706;
     else
-        let List.699 : Int1 = CallByName Bool.1;
-        ret List.699;
+        let List.707 : Int1 = CallByName Bool.1;
+        ret List.707;
 
 procedure List.6 (#Attr.2):
-    let List.695 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.695;
+    let List.703 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.703;
 
 procedure List.6 (#Attr.2):
-    let List.723 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.723;
+    let List.731 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.731;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.722 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.722;
+    let List.730 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.730;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.742 : [<r>C I64, C List *self] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.742;
+    let List.750 : [<r>C I64, C List *self] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.750;
 
 procedure List.68 (#Attr.2):
-    let List.743 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = lowlevel ListWithCapacity #Attr.2;
-    ret List.743;
+    let List.751 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = lowlevel ListWithCapacity #Attr.2;
+    ret List.751;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.739 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.739;
+    let List.747 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.747;
 
 procedure List.80 (Bool.25, Bool.26, Bool.27, Bool.28, Bool.29):
-    joinpoint List.710 List.585 List.586 List.587 List.588 List.589:
-        let List.712 : Int1 = CallByName Num.22 List.588 List.589;
-        if List.712 then
-            let List.721 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.66 List.585 List.588;
-            inc List.721;
-            let List.713 : [C {}, C {}] = CallByName List.251 List.586 List.721 List.587;
-            let List.718 : U8 = 1i64;
-            let List.719 : U8 = GetTagId List.713;
-            let List.720 : Int1 = lowlevel Eq List.718 List.719;
-            if List.720 then
-                let List.590 : {} = UnionAtIndex (Id 1) (Index 0) List.713;
-                let List.716 : U64 = 1i64;
-                let List.715 : U64 = CallByName Num.51 List.588 List.716;
-                jump List.710 List.585 List.590 List.587 List.715 List.589;
+    joinpoint List.718 List.593 List.594 List.595 List.596 List.597:
+        let List.720 : Int1 = CallByName Num.22 List.596 List.597;
+        if List.720 then
+            let List.729 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.66 List.593 List.596;
+            inc List.729;
+            let List.721 : [C {}, C {}] = CallByName List.252 List.594 List.729 List.595;
+            let List.726 : U8 = 1i64;
+            let List.727 : U8 = GetTagId List.721;
+            let List.728 : Int1 = lowlevel Eq List.726 List.727;
+            if List.728 then
+                let List.598 : {} = UnionAtIndex (Id 1) (Index 0) List.721;
+                let List.724 : U64 = 1i64;
+                let List.723 : U64 = CallByName Num.51 List.596 List.724;
+                jump List.718 List.593 List.598 List.595 List.723 List.597;
             else
-                dec List.585;
-                let List.591 : {} = UnionAtIndex (Id 0) (Index 0) List.713;
-                let List.717 : [C {}, C {}] = TagId(0) List.591;
-                ret List.717;
+                dec List.593;
+                let List.599 : {} = UnionAtIndex (Id 0) (Index 0) List.721;
+                let List.725 : [C {}, C {}] = TagId(0) List.599;
+                ret List.725;
         else
-            dec List.585;
-            let List.711 : [C {}, C {}] = TagId(1) List.586;
-            ret List.711;
+            dec List.593;
+            let List.719 : [C {}, C {}] = TagId(1) List.594;
+            ret List.719;
     in
     inc Bool.25;
-    jump List.710 Bool.25 Bool.26 Bool.27 Bool.28 Bool.29;
+    jump List.718 Bool.25 Bool.26 Bool.27 Bool.28 Bool.29;
 
 procedure Num.148 (Num.232, Num.233):
     let Num.296 : Int1 = CallByName Num.22 Num.232 Num.233;

crates/compiler/test_mono/generated/layout_cache_structure_with_multiple_recursive_structures.txt

@@ -1,33 +1,33 @@
-procedure List.103 (Bool.21, Bool.22, Bool.23, Bool.24, Bool.25):
-    joinpoint List.697 List.178 List.179 List.180 List.181 List.182:
-        let List.699 : Int1 = CallByName Num.22 List.181 List.182;
-        if List.699 then
-            let List.703 : [<rnu>C *self, <null>] = CallByName List.66 List.178 List.181;
-            inc List.703;
-            let List.183 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = CallByName Test.7 List.179 List.703;
-            let List.702 : U64 = 1i64;
-            let List.701 : U64 = CallByName Num.51 List.181 List.702;
-            jump List.697 List.178 List.183 List.180 List.701 List.182;
+procedure List.104 (Bool.21, Bool.22, Bool.23, Bool.24, Bool.25):
+    joinpoint List.705 List.179 List.180 List.181 List.182 List.183:
+        let List.707 : Int1 = CallByName Num.22 List.182 List.183;
+        if List.707 then
+            let List.711 : [<rnu>C *self, <null>] = CallByName List.66 List.179 List.182;
+            inc List.711;
+            let List.184 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = CallByName Test.7 List.180 List.711;
+            let List.710 : U64 = 1i64;
+            let List.709 : U64 = CallByName Num.51 List.182 List.710;
+            jump List.705 List.179 List.184 List.181 List.709 List.183;
         else
-            dec List.178;
-            ret List.179;
+            dec List.179;
+            ret List.180;
     in
     inc Bool.21;
-    jump List.697 Bool.21 Bool.22 Bool.23 Bool.24 Bool.25;
+    jump List.705 Bool.21 Bool.22 Bool.23 Bool.24 Bool.25;
 
-procedure List.18 (List.175, List.176, List.177):
-    let List.695 : U64 = 0i64;
-    let List.696 : U64 = CallByName List.6 List.175;
-    let List.694 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = CallByName List.103 List.175 List.176 List.177 List.695 List.696;
-    ret List.694;
+procedure List.18 (List.176, List.177, List.178):
+    let List.703 : U64 = 0i64;
+    let List.704 : U64 = CallByName List.6 List.176;
+    let List.702 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = CallByName List.104 List.176 List.177 List.178 List.703 List.704;
+    ret List.702;
 
 procedure List.6 (#Attr.2):
-    let List.705 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.705;
+    let List.713 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.713;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.704 : [<rnu>C *self, <null>] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.704;
+    let List.712 : [<rnu>C *self, <null>] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.712;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.290 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/list_append.txt

@@ -1,16 +1,16 @@
-procedure List.4 (List.139, List.140):
-    let List.697 : U64 = 1i64;
-    let List.695 : List I64 = CallByName List.70 List.139 List.697;
-    let List.694 : List I64 = CallByName List.71 List.695 List.140;
-    ret List.694;
+procedure List.4 (List.140, List.141):
+    let List.705 : U64 = 1i64;
+    let List.703 : List I64 = CallByName List.70 List.140 List.705;
+    let List.702 : List I64 = CallByName List.71 List.703 List.141;
+    ret List.702;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.698 : List I64 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.698;
+    let List.706 : List I64 = lowlevel ListReserve #Attr.2 #Attr.3;
+    ret List.706;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.696 : List I64 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.696;
+    let List.704 : List I64 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.704;
 
 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.139, List.140):
-    let List.697 : U64 = 1i64;
-    let List.695 : List I64 = CallByName List.70 List.139 List.697;
-    let List.694 : List I64 = CallByName List.71 List.695 List.140;
-    ret List.694;
+procedure List.4 (List.140, List.141):
+    let List.705 : U64 = 1i64;
+    let List.703 : List I64 = CallByName List.70 List.140 List.705;
+    let List.702 : List I64 = CallByName List.71 List.703 List.141;
+    ret List.702;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.698 : List I64 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.698;
+    let List.706 : List I64 = lowlevel ListReserve #Attr.2 #Attr.3;
+    ret List.706;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.696 : List I64 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.696;
+    let List.704 : List I64 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.704;
 
 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.131, List.132, List.133):
-    let List.697 : {List I64, I64} = CallByName List.64 List.131 List.132 List.133;
-    let List.696 : List I64 = StructAtIndex 0 List.697;
-    ret List.696;
+procedure List.3 (List.132, List.133, List.134):
+    let List.705 : {List I64, I64} = CallByName List.64 List.132 List.133 List.134;
+    let List.704 : List I64 = StructAtIndex 0 List.705;
+    ret List.704;
 
 procedure List.6 (#Attr.2):
-    let List.695 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.695;
+    let List.703 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.703;
 
-procedure List.64 (List.128, List.129, List.130):
-    let List.702 : U64 = CallByName List.6 List.128;
-    let List.699 : Int1 = CallByName Num.22 List.129 List.702;
-    if List.699 then
-        let List.700 : {List I64, I64} = CallByName List.67 List.128 List.129 List.130;
-        ret List.700;
+procedure List.64 (List.129, List.130, List.131):
+    let List.710 : U64 = CallByName List.6 List.129;
+    let List.707 : Int1 = CallByName Num.22 List.130 List.710;
+    if List.707 then
+        let List.708 : {List I64, I64} = CallByName List.67 List.129 List.130 List.131;
+        ret List.708;
     else
-        let List.698 : {List I64, I64} = Struct {List.128, List.130};
-        ret List.698;
+        let List.706 : {List I64, I64} = Struct {List.129, List.131};
+        ret List.706;
 
 procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
-    let List.701 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
-    ret List.701;
+    let List.709 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
+    ret List.709;
 
 procedure Num.19 (#Attr.2, #Attr.3):
     let Num.289 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/list_get.txt

@@ -1,22 +1,22 @@
-procedure List.2 (List.123, List.124):
-    let List.700 : U64 = CallByName List.6 List.123;
-    let List.696 : Int1 = CallByName Num.22 List.124 List.700;
-    if List.696 then
-        let List.698 : I64 = CallByName List.66 List.123 List.124;
-        let List.697 : [C {}, C I64] = TagId(1) List.698;
-        ret List.697;
+procedure List.2 (List.124, List.125):
+    let List.708 : U64 = CallByName List.6 List.124;
+    let List.704 : Int1 = CallByName Num.22 List.125 List.708;
+    if List.704 then
+        let List.706 : I64 = CallByName List.66 List.124 List.125;
+        let List.705 : [C {}, C I64] = TagId(1) List.706;
+        ret List.705;
     else
-        let List.695 : {} = Struct {};
-        let List.694 : [C {}, C I64] = TagId(0) List.695;
-        ret List.694;
+        let List.703 : {} = Struct {};
+        let List.702 : [C {}, C I64] = TagId(0) List.703;
+        ret List.702;
 
 procedure List.6 (#Attr.2):
-    let List.701 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.701;
+    let List.709 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.709;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.699 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.699;
+    let List.707 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.707;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.289 : 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.694 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.694;
+    let List.702 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.702;
 
 procedure List.6 (#Attr.2):
-    let List.695 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.695;
+    let List.703 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.703;
 
 procedure Num.19 (#Attr.2, #Attr.3):
     let Num.289 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/list_map_closure_borrows.txt

@@ -1,66 +1,66 @@
-procedure List.103 (Bool.21, Bool.22, Bool.23, Bool.24, Bool.25):
-    joinpoint List.708 List.178 List.179 List.180 List.181 List.182:
-        let List.710 : Int1 = CallByName Num.22 List.181 List.182;
-        if List.710 then
-            let List.714 : Str = CallByName List.66 List.178 List.181;
-            inc List.714;
-            let List.183 : List Str = CallByName List.296 List.179 List.714 List.180;
-            dec List.714;
-            let List.713 : U64 = 1i64;
-            let List.712 : U64 = CallByName Num.51 List.181 List.713;
-            jump List.708 List.178 List.183 List.180 List.712 List.182;
+procedure List.104 (Bool.21, Bool.22, Bool.23, Bool.24, Bool.25):
+    joinpoint List.716 List.179 List.180 List.181 List.182 List.183:
+        let List.718 : Int1 = CallByName Num.22 List.182 List.183;
+        if List.718 then
+            let List.722 : Str = CallByName List.66 List.179 List.182;
+            inc List.722;
+            let List.184 : List Str = CallByName List.297 List.180 List.722 List.181;
+            dec List.722;
+            let List.721 : U64 = 1i64;
+            let List.720 : U64 = CallByName Num.51 List.182 List.721;
+            jump List.716 List.179 List.184 List.181 List.720 List.183;
         else
-            dec List.178;
-            ret List.179;
+            dec List.179;
+            ret List.180;
     in
     inc Bool.21;
-    jump List.708 Bool.21 Bool.22 Bool.23 Bool.24 Bool.25;
+    jump List.716 Bool.21 Bool.22 Bool.23 Bool.24 Bool.25;
 
-procedure List.18 (List.175, List.176, List.177):
-    let List.706 : U64 = 0i64;
-    let List.707 : U64 = CallByName List.6 List.175;
-    let List.705 : List Str = CallByName List.103 List.175 List.176 List.177 List.706 List.707;
-    ret List.705;
+procedure List.18 (List.176, List.177, List.178):
+    let List.714 : U64 = 0i64;
+    let List.715 : U64 = CallByName List.6 List.176;
+    let List.713 : List Str = CallByName List.104 List.176 List.177 List.178 List.714 List.715;
+    ret List.713;
 
-procedure List.2 (List.123, List.124):
-    let List.700 : U64 = CallByName List.6 List.123;
-    let List.696 : Int1 = CallByName Num.22 List.124 List.700;
-    if List.696 then
-        let List.698 : Str = CallByName List.66 List.123 List.124;
-        inc List.698;
-        let List.697 : [C {}, C Str] = TagId(1) List.698;
-        ret List.697;
+procedure List.2 (List.124, List.125):
+    let List.708 : U64 = CallByName List.6 List.124;
+    let List.704 : Int1 = CallByName Num.22 List.125 List.708;
+    if List.704 then
+        let List.706 : Str = CallByName List.66 List.124 List.125;
+        inc List.706;
+        let List.705 : [C {}, C Str] = TagId(1) List.706;
+        ret List.705;
     else
-        let List.695 : {} = Struct {};
-        let List.694 : [C {}, C Str] = TagId(0) List.695;
-        ret List.694;
+        let List.703 : {} = Struct {};
+        let List.702 : [C {}, C Str] = TagId(0) List.703;
+        ret List.702;
 
-procedure List.296 (List.297, List.298, List.294):
-    let List.717 : Str = CallByName Test.3 List.298;
-    let List.716 : List Str = CallByName List.71 List.297 List.717;
-    ret List.716;
+procedure List.297 (List.298, List.299, List.295):
+    let List.725 : Str = CallByName Test.3 List.299;
+    let List.724 : List Str = CallByName List.71 List.298 List.725;
+    ret List.724;
 
-procedure List.5 (List.293, List.294):
-    let List.295 : U64 = CallByName List.6 List.293;
-    let List.703 : List Str = CallByName List.68 List.295;
-    let List.702 : List Str = CallByName List.18 List.293 List.703 List.294;
-    ret List.702;
+procedure List.5 (List.294, List.295):
+    let List.296 : U64 = CallByName List.6 List.294;
+    let List.711 : List Str = CallByName List.68 List.296;
+    let List.710 : List Str = CallByName List.18 List.294 List.711 List.295;
+    ret List.710;
 
 procedure List.6 (#Attr.2):
-    let List.701 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.701;
+    let List.709 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.709;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.699 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.699;
+    let List.707 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.707;
 
 procedure List.68 (#Attr.2):
-    let List.719 : List Str = lowlevel ListWithCapacity #Attr.2;
-    ret List.719;
+    let List.727 : List Str = lowlevel ListWithCapacity #Attr.2;
+    ret List.727;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.718 : List Str = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.718;
+    let List.726 : List Str = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.726;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.290 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/list_map_closure_owns.txt

@@ -1,65 +1,65 @@
-procedure List.103 (Bool.21, Bool.22, Bool.23, Bool.24, Bool.25):
-    joinpoint List.708 List.178 List.179 List.180 List.181 List.182:
-        let List.710 : Int1 = CallByName Num.22 List.181 List.182;
-        if List.710 then
-            let List.714 : Str = CallByName List.66 List.178 List.181;
-            inc List.714;
-            let List.183 : List Str = CallByName List.296 List.179 List.714 List.180;
-            let List.713 : U64 = 1i64;
-            let List.712 : U64 = CallByName Num.51 List.181 List.713;
-            jump List.708 List.178 List.183 List.180 List.712 List.182;
+procedure List.104 (Bool.21, Bool.22, Bool.23, Bool.24, Bool.25):
+    joinpoint List.716 List.179 List.180 List.181 List.182 List.183:
+        let List.718 : Int1 = CallByName Num.22 List.182 List.183;
+        if List.718 then
+            let List.722 : Str = CallByName List.66 List.179 List.182;
+            inc List.722;
+            let List.184 : List Str = CallByName List.297 List.180 List.722 List.181;
+            let List.721 : U64 = 1i64;
+            let List.720 : U64 = CallByName Num.51 List.182 List.721;
+            jump List.716 List.179 List.184 List.181 List.720 List.183;
         else
-            dec List.178;
-            ret List.179;
+            dec List.179;
+            ret List.180;
     in
     inc Bool.21;
-    jump List.708 Bool.21 Bool.22 Bool.23 Bool.24 Bool.25;
+    jump List.716 Bool.21 Bool.22 Bool.23 Bool.24 Bool.25;
 
-procedure List.18 (List.175, List.176, List.177):
-    let List.706 : U64 = 0i64;
-    let List.707 : U64 = CallByName List.6 List.175;
-    let List.705 : List Str = CallByName List.103 List.175 List.176 List.177 List.706 List.707;
-    ret List.705;
+procedure List.18 (List.176, List.177, List.178):
+    let List.714 : U64 = 0i64;
+    let List.715 : U64 = CallByName List.6 List.176;
+    let List.713 : List Str = CallByName List.104 List.176 List.177 List.178 List.714 List.715;
+    ret List.713;
 
-procedure List.2 (List.123, List.124):
-    let List.700 : U64 = CallByName List.6 List.123;
-    let List.696 : Int1 = CallByName Num.22 List.124 List.700;
-    if List.696 then
-        let List.698 : Str = CallByName List.66 List.123 List.124;
-        inc List.698;
-        let List.697 : [C {}, C Str] = TagId(1) List.698;
-        ret List.697;
+procedure List.2 (List.124, List.125):
+    let List.708 : U64 = CallByName List.6 List.124;
+    let List.704 : Int1 = CallByName Num.22 List.125 List.708;
+    if List.704 then
+        let List.706 : Str = CallByName List.66 List.124 List.125;
+        inc List.706;
+        let List.705 : [C {}, C Str] = TagId(1) List.706;
+        ret List.705;
     else
-        let List.695 : {} = Struct {};
-        let List.694 : [C {}, C Str] = TagId(0) List.695;
-        ret List.694;
+        let List.703 : {} = Struct {};
+        let List.702 : [C {}, C Str] = TagId(0) List.703;
+        ret List.702;
 
-procedure List.296 (List.297, List.298, List.294):
-    let List.717 : Str = CallByName Test.3 List.298;
-    let List.716 : List Str = CallByName List.71 List.297 List.717;
-    ret List.716;
+procedure List.297 (List.298, List.299, List.295):
+    let List.725 : Str = CallByName Test.3 List.299;
+    let List.724 : List Str = CallByName List.71 List.298 List.725;
+    ret List.724;
 
-procedure List.5 (List.293, List.294):
-    let List.295 : U64 = CallByName List.6 List.293;
-    let List.703 : List Str = CallByName List.68 List.295;
-    let List.702 : List Str = CallByName List.18 List.293 List.703 List.294;
-    ret List.702;
+procedure List.5 (List.294, List.295):
+    let List.296 : U64 = CallByName List.6 List.294;
+    let List.711 : List Str = CallByName List.68 List.296;
+    let List.710 : List Str = CallByName List.18 List.294 List.711 List.295;
+    ret List.710;
 
 procedure List.6 (#Attr.2):
-    let List.701 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.701;
+    let List.709 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.709;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.699 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.699;
+    let List.707 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.707;
 
 procedure List.68 (#Attr.2):
-    let List.719 : List Str = lowlevel ListWithCapacity #Attr.2;
-    ret List.719;
+    let List.727 : List Str = lowlevel ListWithCapacity #Attr.2;
+    ret List.727;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.718 : List Str = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.718;
+    let List.726 : List Str = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.726;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.290 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/list_map_take_capturing_or_noncapturing.txt

@@ -1,66 +1,66 @@
-procedure List.103 (Bool.21, Bool.22, Bool.23, Bool.24, Bool.25):
-    joinpoint List.700 List.178 List.179 List.180 List.181 List.182:
-        let List.702 : Int1 = CallByName Num.22 List.181 List.182;
-        if List.702 then
-            let List.706 : U8 = CallByName List.66 List.178 List.181;
-            let List.183 : List U8 = CallByName List.296 List.179 List.706 List.180;
-            let List.705 : U64 = 1i64;
-            let List.704 : U64 = CallByName Num.51 List.181 List.705;
-            jump List.700 List.178 List.183 List.180 List.704 List.182;
+procedure List.104 (Bool.21, Bool.22, Bool.23, Bool.24, Bool.25):
+    joinpoint List.708 List.179 List.180 List.181 List.182 List.183:
+        let List.710 : Int1 = CallByName Num.22 List.182 List.183;
+        if List.710 then
+            let List.714 : U8 = CallByName List.66 List.179 List.182;
+            let List.184 : List U8 = CallByName List.297 List.180 List.714 List.181;
+            let List.713 : U64 = 1i64;
+            let List.712 : U64 = CallByName Num.51 List.182 List.713;
+            jump List.708 List.179 List.184 List.181 List.712 List.183;
         else
-            dec List.178;
-            ret List.179;
+            dec List.179;
+            ret List.180;
     in
     inc Bool.21;
-    jump List.700 Bool.21 Bool.22 Bool.23 Bool.24 Bool.25;
+    jump List.708 Bool.21 Bool.22 Bool.23 Bool.24 Bool.25;
 
-procedure List.18 (List.175, List.176, List.177):
-    let List.698 : U64 = 0i64;
-    let List.699 : U64 = CallByName List.6 List.175;
-    let List.697 : List U8 = CallByName List.103 List.175 List.176 List.177 List.698 List.699;
-    ret List.697;
+procedure List.18 (List.176, List.177, List.178):
+    let List.706 : U64 = 0i64;
+    let List.707 : U64 = CallByName List.6 List.176;
+    let List.705 : List U8 = CallByName List.104 List.176 List.177 List.178 List.706 List.707;
+    ret List.705;
 
-procedure List.296 (List.297, List.298, List.294):
-    let List.713 : U8 = GetTagId List.294;
-    joinpoint List.714 List.711:
-        let List.710 : List U8 = CallByName List.71 List.297 List.711;
-        ret List.710;
+procedure List.297 (List.298, List.299, List.295):
+    let List.721 : U8 = GetTagId List.295;
+    joinpoint List.722 List.719:
+        let List.718 : List U8 = CallByName List.71 List.298 List.719;
+        ret List.718;
     in
-    switch List.713:
+    switch List.721:
         case 0:
-            let List.715 : U8 = CallByName Test.4 List.298 List.294;
-            jump List.714 List.715;
+            let List.723 : U8 = CallByName Test.4 List.299 List.295;
+            jump List.722 List.723;
     
         case 1:
-            let List.715 : U8 = CallByName Test.6 List.298 List.294;
-            jump List.714 List.715;
+            let List.723 : U8 = CallByName Test.6 List.299 List.295;
+            jump List.722 List.723;
     
         default:
-            let List.715 : U8 = CallByName Test.8 List.298;
-            jump List.714 List.715;
+            let List.723 : U8 = CallByName Test.8 List.299;
+            jump List.722 List.723;
     
 
-procedure List.5 (List.293, List.294):
-    let List.295 : U64 = CallByName List.6 List.293;
-    let List.695 : List U8 = CallByName List.68 List.295;
-    let List.694 : List U8 = CallByName List.18 List.293 List.695 List.294;
-    ret List.694;
+procedure List.5 (List.294, List.295):
+    let List.296 : U64 = CallByName List.6 List.294;
+    let List.703 : List U8 = CallByName List.68 List.296;
+    let List.702 : List U8 = CallByName List.18 List.294 List.703 List.295;
+    ret List.702;
 
 procedure List.6 (#Attr.2):
-    let List.708 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.708;
-
-procedure List.66 (#Attr.2, #Attr.3):
-    let List.707 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.707;
-
-procedure List.68 (#Attr.2):
-    let List.716 : List U8 = lowlevel ListWithCapacity #Attr.2;
+    let List.716 : U64 = lowlevel ListLenU64 #Attr.2;
     ret List.716;
 
+procedure List.66 (#Attr.2, #Attr.3):
+    let List.715 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.715;
+
+procedure List.68 (#Attr.2):
+    let List.724 : List U8 = lowlevel ListWithCapacity #Attr.2;
+    ret List.724;
+
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.712 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.712;
+    let List.720 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.720;
 
 procedure Num.19 (#Attr.2, #Attr.3):
     let Num.291 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/list_pass_to_function.txt

@@ -1,25 +1,25 @@
-procedure List.3 (List.131, List.132, List.133):
-    let List.695 : {List I64, I64} = CallByName List.64 List.131 List.132 List.133;
-    let List.694 : List I64 = StructAtIndex 0 List.695;
-    ret List.694;
+procedure List.3 (List.132, List.133, List.134):
+    let List.703 : {List I64, I64} = CallByName List.64 List.132 List.133 List.134;
+    let List.702 : List I64 = StructAtIndex 0 List.703;
+    ret List.702;
 
 procedure List.6 (#Attr.2):
-    let List.701 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.701;
+    let List.709 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.709;
 
-procedure List.64 (List.128, List.129, List.130):
-    let List.700 : U64 = CallByName List.6 List.128;
-    let List.697 : Int1 = CallByName Num.22 List.129 List.700;
-    if List.697 then
-        let List.698 : {List I64, I64} = CallByName List.67 List.128 List.129 List.130;
-        ret List.698;
+procedure List.64 (List.129, List.130, List.131):
+    let List.708 : U64 = CallByName List.6 List.129;
+    let List.705 : Int1 = CallByName Num.22 List.130 List.708;
+    if List.705 then
+        let List.706 : {List I64, I64} = CallByName List.67 List.129 List.130 List.131;
+        ret List.706;
     else
-        let List.696 : {List I64, I64} = Struct {List.128, List.130};
-        ret List.696;
+        let List.704 : {List I64, I64} = Struct {List.129, List.131};
+        ret List.704;
 
 procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
-    let List.699 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
-    ret List.699;
+    let List.707 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
+    ret List.707;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.289 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/list_sort_asc.txt

@@ -1,11 +1,11 @@
 procedure List.28 (#Attr.2, #Attr.3):
-    let List.696 : List I64 = lowlevel ListSortWith { xs: `#Attr.#arg1` } #Attr.2 Num.46 #Attr.3;
-    ret List.696;
+    let List.704 : List I64 = lowlevel ListSortWith { xs: `#Attr.#arg1` } #Attr.2 Num.46 #Attr.3;
+    ret List.704;
 
-procedure List.59 (List.399):
-    let List.695 : {} = Struct {};
-    let List.694 : List I64 = CallByName List.28 List.399 List.695;
-    ret List.694;
+procedure List.59 (List.400):
+    let List.703 : {} = Struct {};
+    let List.702 : List I64 = CallByName List.28 List.400 List.703;
+    ret List.702;
 
 procedure Num.46 (#Attr.2, #Attr.3):
     let Num.289 : U8 = lowlevel NumCompare #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/quicksort_swap.txt

@@ -1,41 +1,41 @@
-procedure List.2 (List.123, List.124):
-    let List.716 : U64 = CallByName List.6 List.123;
-    let List.713 : Int1 = CallByName Num.22 List.124 List.716;
-    if List.713 then
-        let List.715 : I64 = CallByName List.66 List.123 List.124;
-        let List.714 : [C {}, C I64] = TagId(1) List.715;
-        ret List.714;
+procedure List.2 (List.124, List.125):
+    let List.724 : U64 = CallByName List.6 List.124;
+    let List.721 : Int1 = CallByName Num.22 List.125 List.724;
+    if List.721 then
+        let List.723 : I64 = CallByName List.66 List.124 List.125;
+        let List.722 : [C {}, C I64] = TagId(1) List.723;
+        ret List.722;
     else
-        let List.712 : {} = Struct {};
-        let List.711 : [C {}, C I64] = TagId(0) List.712;
-        ret List.711;
+        let List.720 : {} = Struct {};
+        let List.719 : [C {}, C I64] = TagId(0) List.720;
+        ret List.719;
 
-procedure List.3 (List.131, List.132, List.133):
-    let List.703 : {List I64, I64} = CallByName List.64 List.131 List.132 List.133;
-    let List.702 : List I64 = StructAtIndex 0 List.703;
-    ret List.702;
+procedure List.3 (List.132, List.133, List.134):
+    let List.711 : {List I64, I64} = CallByName List.64 List.132 List.133 List.134;
+    let List.710 : List I64 = StructAtIndex 0 List.711;
+    ret List.710;
 
 procedure List.6 (#Attr.2):
-    let List.701 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.701;
-
-procedure List.64 (List.128, List.129, List.130):
-    let List.700 : U64 = CallByName List.6 List.128;
-    let List.697 : Int1 = CallByName Num.22 List.129 List.700;
-    if List.697 then
-        let List.698 : {List I64, I64} = CallByName List.67 List.128 List.129 List.130;
-        ret List.698;
-    else
-        let List.696 : {List I64, I64} = Struct {List.128, List.130};
-        ret List.696;
-
-procedure List.66 (#Attr.2, #Attr.3):
-    let List.709 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.709 : U64 = lowlevel ListLenU64 #Attr.2;
     ret List.709;
 
+procedure List.64 (List.129, List.130, List.131):
+    let List.708 : U64 = CallByName List.6 List.129;
+    let List.705 : Int1 = CallByName Num.22 List.130 List.708;
+    if List.705 then
+        let List.706 : {List I64, I64} = CallByName List.67 List.129 List.130 List.131;
+        ret List.706;
+    else
+        let List.704 : {List I64, I64} = Struct {List.129, List.131};
+        ret List.704;
+
+procedure List.66 (#Attr.2, #Attr.3):
+    let List.717 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.717;
+
 procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
-    let List.699 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
-    ret List.699;
+    let List.707 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
+    ret List.707;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.291 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/record_update.txt

@@ -1,25 +1,25 @@
-procedure List.3 (List.131, List.132, List.133):
-    let List.703 : {List U64, U64} = CallByName List.64 List.131 List.132 List.133;
-    let List.702 : List U64 = StructAtIndex 0 List.703;
-    ret List.702;
+procedure List.3 (List.132, List.133, List.134):
+    let List.711 : {List U64, U64} = CallByName List.64 List.132 List.133 List.134;
+    let List.710 : List U64 = StructAtIndex 0 List.711;
+    ret List.710;
 
 procedure List.6 (#Attr.2):
-    let List.701 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.701;
+    let List.709 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.709;
 
-procedure List.64 (List.128, List.129, List.130):
-    let List.700 : U64 = CallByName List.6 List.128;
-    let List.697 : Int1 = CallByName Num.22 List.129 List.700;
-    if List.697 then
-        let List.698 : {List U64, U64} = CallByName List.67 List.128 List.129 List.130;
-        ret List.698;
+procedure List.64 (List.129, List.130, List.131):
+    let List.708 : U64 = CallByName List.6 List.129;
+    let List.705 : Int1 = CallByName Num.22 List.130 List.708;
+    if List.705 then
+        let List.706 : {List U64, U64} = CallByName List.67 List.129 List.130 List.131;
+        ret List.706;
     else
-        let List.696 : {List U64, U64} = Struct {List.128, List.130};
-        ret List.696;
+        let List.704 : {List U64, U64} = Struct {List.129, List.131};
+        ret List.704;
 
 procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
-    let List.699 : {List U64, U64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
-    ret List.699;
+    let List.707 : {List U64, U64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
+    ret List.707;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.289 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/recursive_function_and_union_with_inference_hole.txt

@@ -1,52 +1,52 @@
-procedure List.103 (Bool.22, Bool.23, Bool.24, Bool.25, Bool.26):
-    joinpoint List.700 List.178 List.179 List.180 List.181 List.182:
-        let List.702 : Int1 = CallByName Num.22 List.181 List.182;
-        if List.702 then
-            let List.706 : [<rnnu>C List *self] = CallByName List.66 List.178 List.181;
-            inc List.706;
-            let List.183 : List [<rnnu>C List *self] = CallByName List.296 List.179 List.706 List.180;
-            let List.705 : U64 = 1i64;
-            let List.704 : U64 = CallByName Num.51 List.181 List.705;
-            jump List.700 List.178 List.183 List.180 List.704 List.182;
+procedure List.104 (Bool.22, Bool.23, Bool.24, Bool.25, Bool.26):
+    joinpoint List.708 List.179 List.180 List.181 List.182 List.183:
+        let List.710 : Int1 = CallByName Num.22 List.182 List.183;
+        if List.710 then
+            let List.714 : [<rnnu>C List *self] = CallByName List.66 List.179 List.182;
+            inc List.714;
+            let List.184 : List [<rnnu>C List *self] = CallByName List.297 List.180 List.714 List.181;
+            let List.713 : U64 = 1i64;
+            let List.712 : U64 = CallByName Num.51 List.182 List.713;
+            jump List.708 List.179 List.184 List.181 List.712 List.183;
         else
-            dec List.178;
-            ret List.179;
+            dec List.179;
+            ret List.180;
     in
     inc Bool.22;
-    jump List.700 Bool.22 Bool.23 Bool.24 Bool.25 Bool.26;
+    jump List.708 Bool.22 Bool.23 Bool.24 Bool.25 Bool.26;
 
-procedure List.18 (List.175, List.176, List.177):
-    let List.698 : U64 = 0i64;
-    let List.699 : U64 = CallByName List.6 List.175;
-    let List.697 : List [<rnnu>C List *self] = CallByName List.103 List.175 List.176 List.177 List.698 List.699;
-    ret List.697;
+procedure List.18 (List.176, List.177, List.178):
+    let List.706 : U64 = 0i64;
+    let List.707 : U64 = CallByName List.6 List.176;
+    let List.705 : List [<rnnu>C List *self] = CallByName List.104 List.176 List.177 List.178 List.706 List.707;
+    ret List.705;
 
-procedure List.296 (List.297, List.298, List.294):
-    let List.711 : [<rnnu>C List *self] = CallByName Test.2 List.298;
-    let List.710 : List [<rnnu>C List *self] = CallByName List.71 List.297 List.711;
-    ret List.710;
+procedure List.297 (List.298, List.299, List.295):
+    let List.719 : [<rnnu>C List *self] = CallByName Test.2 List.299;
+    let List.718 : List [<rnnu>C List *self] = CallByName List.71 List.298 List.719;
+    ret List.718;
 
-procedure List.5 (List.293, List.294):
-    let List.295 : U64 = CallByName List.6 List.293;
-    let List.695 : List [<rnnu>C List *self] = CallByName List.68 List.295;
-    let List.694 : List [<rnnu>C List *self] = CallByName List.18 List.293 List.695 List.294;
-    ret List.694;
+procedure List.5 (List.294, List.295):
+    let List.296 : U64 = CallByName List.6 List.294;
+    let List.703 : List [<rnnu>C List *self] = CallByName List.68 List.296;
+    let List.702 : List [<rnnu>C List *self] = CallByName List.18 List.294 List.703 List.295;
+    ret List.702;
 
 procedure List.6 (#Attr.2):
-    let List.708 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.708;
+    let List.716 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.716;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.707 : [<rnnu>C List *self] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.707;
+    let List.715 : [<rnnu>C List *self] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.715;
 
 procedure List.68 (#Attr.2):
-    let List.713 : List [<rnnu>C List *self] = lowlevel ListWithCapacity #Attr.2;
-    ret List.713;
+    let List.721 : List [<rnnu>C List *self] = lowlevel ListWithCapacity #Attr.2;
+    ret List.721;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.712 : List [<rnnu>C List *self] = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.712;
+    let List.720 : List [<rnnu>C List *self] = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.720;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.290 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/rigids.txt

@@ -1,41 +1,41 @@
-procedure List.2 (List.123, List.124):
-    let List.716 : U64 = CallByName List.6 List.123;
-    let List.713 : Int1 = CallByName Num.22 List.124 List.716;
-    if List.713 then
-        let List.715 : I64 = CallByName List.66 List.123 List.124;
-        let List.714 : [C {}, C I64] = TagId(1) List.715;
-        ret List.714;
+procedure List.2 (List.124, List.125):
+    let List.724 : U64 = CallByName List.6 List.124;
+    let List.721 : Int1 = CallByName Num.22 List.125 List.724;
+    if List.721 then
+        let List.723 : I64 = CallByName List.66 List.124 List.125;
+        let List.722 : [C {}, C I64] = TagId(1) List.723;
+        ret List.722;
     else
-        let List.712 : {} = Struct {};
-        let List.711 : [C {}, C I64] = TagId(0) List.712;
-        ret List.711;
+        let List.720 : {} = Struct {};
+        let List.719 : [C {}, C I64] = TagId(0) List.720;
+        ret List.719;
 
-procedure List.3 (List.131, List.132, List.133):
-    let List.703 : {List I64, I64} = CallByName List.64 List.131 List.132 List.133;
-    let List.702 : List I64 = StructAtIndex 0 List.703;
-    ret List.702;
+procedure List.3 (List.132, List.133, List.134):
+    let List.711 : {List I64, I64} = CallByName List.64 List.132 List.133 List.134;
+    let List.710 : List I64 = StructAtIndex 0 List.711;
+    ret List.710;
 
 procedure List.6 (#Attr.2):
-    let List.701 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.701;
-
-procedure List.64 (List.128, List.129, List.130):
-    let List.700 : U64 = CallByName List.6 List.128;
-    let List.697 : Int1 = CallByName Num.22 List.129 List.700;
-    if List.697 then
-        let List.698 : {List I64, I64} = CallByName List.67 List.128 List.129 List.130;
-        ret List.698;
-    else
-        let List.696 : {List I64, I64} = Struct {List.128, List.130};
-        ret List.696;
-
-procedure List.66 (#Attr.2, #Attr.3):
-    let List.709 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.709 : U64 = lowlevel ListLenU64 #Attr.2;
     ret List.709;
 
+procedure List.64 (List.129, List.130, List.131):
+    let List.708 : U64 = CallByName List.6 List.129;
+    let List.705 : Int1 = CallByName Num.22 List.130 List.708;
+    if List.705 then
+        let List.706 : {List I64, I64} = CallByName List.67 List.129 List.130 List.131;
+        ret List.706;
+    else
+        let List.704 : {List I64, I64} = Struct {List.129, List.131};
+        ret List.704;
+
+procedure List.66 (#Attr.2, #Attr.3):
+    let List.717 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.717;
+
 procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
-    let List.699 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
-    ret List.699;
+    let List.707 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
+    ret List.707;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.291 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_does_not_duplicate_identical_concrete_types.txt

@@ -29,58 +29,58 @@ procedure Encode.26 (Encode.107, Encode.108):
     let Encode.110 : List U8 = CallByName Encode.24 Encode.111 Encode.112 Encode.108;
     ret Encode.110;
 
-procedure List.103 (#Derived_gen.9, #Derived_gen.10, #Derived_gen.11, #Derived_gen.12, #Derived_gen.13):
-    joinpoint List.697 List.178 List.179 List.180 List.181 List.182:
-        let List.699 : Int1 = CallByName Num.22 List.181 List.182;
-        if List.699 then
-            let List.703 : Str = CallByName List.66 List.178 List.181;
-            inc List.703;
-            let List.183 : List U8 = CallByName Test.66 List.179 List.703 List.180;
-            let List.702 : U64 = 1i64;
-            let List.701 : U64 = CallByName Num.51 List.181 List.702;
-            jump List.697 List.178 List.183 List.180 List.701 List.182;
+procedure List.104 (#Derived_gen.9, #Derived_gen.10, #Derived_gen.11, #Derived_gen.12, #Derived_gen.13):
+    joinpoint List.705 List.179 List.180 List.181 List.182 List.183:
+        let List.707 : Int1 = CallByName Num.22 List.182 List.183;
+        if List.707 then
+            let List.711 : Str = CallByName List.66 List.179 List.182;
+            inc List.711;
+            let List.184 : List U8 = CallByName Test.66 List.180 List.711 List.181;
+            let List.710 : U64 = 1i64;
+            let List.709 : U64 = CallByName Num.51 List.182 List.710;
+            jump List.705 List.179 List.184 List.181 List.709 List.183;
         else
-            dec List.178;
-            ret List.179;
+            dec List.179;
+            ret List.180;
     in
     inc #Derived_gen.9;
-    jump List.697 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13;
+    jump List.705 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13;
 
 procedure List.13 (#Attr.2, #Attr.3):
-    let List.720 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3;
-    ret List.720;
+    let List.728 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3;
+    ret List.728;
 
-procedure List.18 (List.175, List.176, List.177):
-    let List.695 : U64 = 0i64;
-    let List.696 : U64 = CallByName List.6 List.175;
-    let List.694 : List U8 = CallByName List.103 List.175 List.176 List.177 List.695 List.696;
-    ret List.694;
+procedure List.18 (List.176, List.177, List.178):
+    let List.703 : U64 = 0i64;
+    let List.704 : U64 = CallByName List.6 List.176;
+    let List.702 : List U8 = CallByName List.104 List.176 List.177 List.178 List.703 List.704;
+    ret List.702;
 
-procedure List.4 (List.139, List.140):
-    let List.716 : U64 = 1i64;
-    let List.715 : List U8 = CallByName List.70 List.139 List.716;
-    let List.714 : List U8 = CallByName List.71 List.715 List.140;
-    ret List.714;
+procedure List.4 (List.140, List.141):
+    let List.724 : U64 = 1i64;
+    let List.723 : List U8 = CallByName List.70 List.140 List.724;
+    let List.722 : List U8 = CallByName List.71 List.723 List.141;
+    ret List.722;
 
 procedure List.6 (#Attr.2):
-    let List.719 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.719;
+    let List.727 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.727;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.704 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.704;
+    let List.712 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.712;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.710 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.710;
+    let List.718 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    ret List.718;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.708 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.708;
+    let List.716 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.716;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.718 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.718;
+    let List.726 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    ret List.726;
 
 procedure Num.127 (#Attr.2):
     let Num.290 : U8 = lowlevel NumIntCast #Attr.2;

crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_keeps_all_concrete_types_without_unification_of_unifiable.txt

@@ -87,93 +87,93 @@ procedure Encode.26 (Encode.107, Encode.108):
     let Encode.110 : List U8 = CallByName Encode.24 Encode.111 Encode.112 Encode.108;
     ret Encode.110;
 
-procedure List.103 (#Derived_gen.44, #Derived_gen.45, #Derived_gen.46, #Derived_gen.47, #Derived_gen.48):
-    joinpoint List.724 List.178 List.179 List.180 List.181 List.182:
-        let List.726 : Int1 = CallByName Num.22 List.181 List.182;
-        if List.726 then
-            let List.730 : Str = CallByName List.66 List.178 List.181;
-            inc List.730;
-            let List.183 : List U8 = CallByName Test.66 List.179 List.730 List.180;
-            let List.729 : U64 = 1i64;
-            let List.728 : U64 = CallByName Num.51 List.181 List.729;
-            jump List.724 List.178 List.183 List.180 List.728 List.182;
+procedure List.104 (#Derived_gen.44, #Derived_gen.45, #Derived_gen.46, #Derived_gen.47, #Derived_gen.48):
+    joinpoint List.705 List.179 List.180 List.181 List.182 List.183:
+        let List.707 : Int1 = CallByName Num.22 List.182 List.183;
+        if List.707 then
+            let List.711 : [C {}, C {}, C Str] = CallByName List.66 List.179 List.182;
+            inc List.711;
+            let List.184 : List U8 = CallByName Test.66 List.180 List.711 List.181;
+            let List.710 : U64 = 1i64;
+            let List.709 : U64 = CallByName Num.51 List.182 List.710;
+            jump List.705 List.179 List.184 List.181 List.709 List.183;
         else
-            dec List.178;
-            ret List.179;
+            dec List.179;
+            ret List.180;
     in
     inc #Derived_gen.44;
-    jump List.724 #Derived_gen.44 #Derived_gen.45 #Derived_gen.46 #Derived_gen.47 #Derived_gen.48;
+    jump List.705 #Derived_gen.44 #Derived_gen.45 #Derived_gen.46 #Derived_gen.47 #Derived_gen.48;
 
-procedure List.103 (#Derived_gen.49, #Derived_gen.50, #Derived_gen.51, #Derived_gen.52, #Derived_gen.53):
-    joinpoint List.697 List.178 List.179 List.180 List.181 List.182:
-        let List.699 : Int1 = CallByName Num.22 List.181 List.182;
-        if List.699 then
-            let List.703 : [C {}, C {}, C Str] = CallByName List.66 List.178 List.181;
-            inc List.703;
-            let List.183 : List U8 = CallByName Test.66 List.179 List.703 List.180;
-            let List.702 : U64 = 1i64;
-            let List.701 : U64 = CallByName Num.51 List.181 List.702;
-            jump List.697 List.178 List.183 List.180 List.701 List.182;
+procedure List.104 (#Derived_gen.49, #Derived_gen.50, #Derived_gen.51, #Derived_gen.52, #Derived_gen.53):
+    joinpoint List.732 List.179 List.180 List.181 List.182 List.183:
+        let List.734 : Int1 = CallByName Num.22 List.182 List.183;
+        if List.734 then
+            let List.738 : Str = CallByName List.66 List.179 List.182;
+            inc List.738;
+            let List.184 : List U8 = CallByName Test.66 List.180 List.738 List.181;
+            let List.737 : U64 = 1i64;
+            let List.736 : U64 = CallByName Num.51 List.182 List.737;
+            jump List.732 List.179 List.184 List.181 List.736 List.183;
         else
-            dec List.178;
-            ret List.179;
+            dec List.179;
+            ret List.180;
     in
     inc #Derived_gen.49;
-    jump List.697 #Derived_gen.49 #Derived_gen.50 #Derived_gen.51 #Derived_gen.52 #Derived_gen.53;
+    jump List.732 #Derived_gen.49 #Derived_gen.50 #Derived_gen.51 #Derived_gen.52 #Derived_gen.53;
 
 procedure List.13 (#Attr.2, #Attr.3):
-    let List.720 : List [C {}, C {}, C Str] = lowlevel ListPrepend #Attr.2 #Attr.3;
-    ret List.720;
+    let List.728 : List [C {}, C {}, C Str] = lowlevel ListPrepend #Attr.2 #Attr.3;
+    ret List.728;
 
 procedure List.13 (#Attr.2, #Attr.3):
-    let List.748 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3;
-    ret List.748;
+    let List.756 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3;
+    ret List.756;
 
-procedure List.18 (List.175, List.176, List.177):
-    let List.695 : U64 = 0i64;
-    let List.696 : U64 = CallByName List.6 List.175;
-    let List.694 : List U8 = CallByName List.103 List.175 List.176 List.177 List.695 List.696;
-    ret List.694;
+procedure List.18 (List.176, List.177, List.178):
+    let List.703 : U64 = 0i64;
+    let List.704 : U64 = CallByName List.6 List.176;
+    let List.702 : List U8 = CallByName List.104 List.176 List.177 List.178 List.703 List.704;
+    ret List.702;
 
-procedure List.18 (List.175, List.176, List.177):
-    let List.722 : U64 = 0i64;
-    let List.723 : U64 = CallByName List.6 List.175;
-    let List.721 : List U8 = CallByName List.103 List.175 List.176 List.177 List.722 List.723;
-    ret List.721;
+procedure List.18 (List.176, List.177, List.178):
+    let List.730 : U64 = 0i64;
+    let List.731 : U64 = CallByName List.6 List.176;
+    let List.729 : List U8 = CallByName List.104 List.176 List.177 List.178 List.730 List.731;
+    ret List.729;
 
-procedure List.4 (List.139, List.140):
-    let List.743 : U64 = 1i64;
-    let List.742 : List U8 = CallByName List.70 List.139 List.743;
-    let List.741 : List U8 = CallByName List.71 List.742 List.140;
-    ret List.741;
+procedure List.4 (List.140, List.141):
+    let List.751 : U64 = 1i64;
+    let List.750 : List U8 = CallByName List.70 List.140 List.751;
+    let List.749 : List U8 = CallByName List.71 List.750 List.141;
+    ret List.749;
 
 procedure List.6 (#Attr.2):
-    let List.719 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.719;
+    let List.727 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.727;
 
 procedure List.6 (#Attr.2):
-    let List.746 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.746;
+    let List.754 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.754;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.704 : [C {}, C {}, C Str] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.704;
+    let List.712 : [C {}, C {}, C Str] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.712;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.731 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.731;
+    let List.739 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.739;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.737 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.737;
+    let List.745 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    ret List.745;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.735 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.735;
+    let List.743 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.743;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.745 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.745;
+    let List.753 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    ret List.753;
 
 procedure Num.127 (#Attr.2):
     let Num.294 : U8 = lowlevel NumIntCast #Attr.2;

crates/compiler/test_mono/generated/weakening_avoids_overspecialization.txt

@@ -2,81 +2,81 @@ procedure Bool.9 (#Attr.2, #Attr.3):
     let Bool.21 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
     ret Bool.21;
 
-procedure List.119 (List.582, List.583, List.584):
-    let List.712 : U64 = 0i64;
-    let List.713 : U64 = CallByName List.6 List.582;
-    let List.711 : [C U64, C U64] = CallByName List.80 List.582 List.583 List.584 List.712 List.713;
-    ret List.711;
+procedure List.120 (List.590, List.591, List.592):
+    let List.720 : U64 = 0i64;
+    let List.721 : U64 = CallByName List.6 List.590;
+    let List.719 : [C U64, C U64] = CallByName List.80 List.590 List.591 List.592 List.720 List.721;
+    ret List.719;
 
-procedure List.26 (List.216, List.217, List.218):
-    let List.705 : [C U64, C U64] = CallByName List.119 List.216 List.217 List.218;
-    let List.708 : U8 = 1i64;
-    let List.709 : U8 = GetTagId List.705;
-    let List.710 : Int1 = lowlevel Eq List.708 List.709;
-    if List.710 then
-        let List.219 : U64 = UnionAtIndex (Id 1) (Index 0) List.705;
-        ret List.219;
-    else
-        let List.220 : U64 = UnionAtIndex (Id 0) (Index 0) List.705;
+procedure List.26 (List.217, List.218, List.219):
+    let List.713 : [C U64, C U64] = CallByName List.120 List.217 List.218 List.219;
+    let List.716 : U8 = 1i64;
+    let List.717 : U8 = GetTagId List.713;
+    let List.718 : Int1 = lowlevel Eq List.716 List.717;
+    if List.718 then
+        let List.220 : U64 = UnionAtIndex (Id 1) (Index 0) List.713;
         ret List.220;
+    else
+        let List.221 : U64 = UnionAtIndex (Id 0) (Index 0) List.713;
+        ret List.221;
 
-procedure List.38 (List.413, List.414):
-    let List.704 : U64 = CallByName List.6 List.413;
-    let List.415 : U64 = CallByName Num.77 List.704 List.414;
-    let List.694 : List U8 = CallByName List.43 List.413 List.415;
-    ret List.694;
+procedure List.38 (List.414, List.415):
+    let List.712 : U64 = CallByName List.6 List.414;
+    let List.416 : U64 = CallByName Num.77 List.712 List.415;
+    let List.702 : List U8 = CallByName List.43 List.414 List.416;
+    ret List.702;
 
-procedure List.43 (List.411, List.412):
-    let List.702 : U64 = CallByName List.6 List.411;
-    let List.701 : U64 = CallByName Num.77 List.702 List.412;
-    let List.696 : {U64, U64} = Struct {List.412, List.701};
-    let List.695 : List U8 = CallByName List.49 List.411 List.696;
-    ret List.695;
-
-procedure List.49 (List.489, List.490):
-    let List.698 : U64 = StructAtIndex 1 List.490;
-    let List.699 : U64 = StructAtIndex 0 List.490;
-    let List.697 : List U8 = CallByName List.72 List.489 List.698 List.699;
-    ret List.697;
-
-procedure List.6 (#Attr.2):
-    let List.703 : U64 = lowlevel ListLenU64 #Attr.2;
+procedure List.43 (List.412, List.413):
+    let List.710 : U64 = CallByName List.6 List.412;
+    let List.709 : U64 = CallByName Num.77 List.710 List.413;
+    let List.704 : {U64, U64} = Struct {List.413, List.709};
+    let List.703 : List U8 = CallByName List.49 List.412 List.704;
     ret List.703;
 
+procedure List.49 (List.497, List.498):
+    let List.706 : U64 = StructAtIndex 1 List.498;
+    let List.707 : U64 = StructAtIndex 0 List.498;
+    let List.705 : List U8 = CallByName List.72 List.497 List.706 List.707;
+    ret List.705;
+
+procedure List.6 (#Attr.2):
+    let List.711 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.711;
+
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.726 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.726;
+    let List.734 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.734;
 
 procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
-    let List.700 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
-    ret List.700;
+    let List.708 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
+    ret List.708;
 
 procedure List.80 (Bool.22, Bool.23, Bool.24, Bool.25, Bool.26):
-    joinpoint List.714 List.585 List.586 List.587 List.588 List.589:
-        let List.716 : Int1 = CallByName Num.22 List.588 List.589;
-        if List.716 then
-            let List.725 : U8 = CallByName List.66 List.585 List.588;
-            let List.717 : [C U64, C U64] = CallByName Test.3 List.586 List.725;
-            let List.722 : U8 = 1i64;
-            let List.723 : U8 = GetTagId List.717;
-            let List.724 : Int1 = lowlevel Eq List.722 List.723;
-            if List.724 then
-                let List.590 : U64 = UnionAtIndex (Id 1) (Index 0) List.717;
-                let List.720 : U64 = 1i64;
-                let List.719 : U64 = CallByName Num.51 List.588 List.720;
-                jump List.714 List.585 List.590 List.587 List.719 List.589;
+    joinpoint List.722 List.593 List.594 List.595 List.596 List.597:
+        let List.724 : Int1 = CallByName Num.22 List.596 List.597;
+        if List.724 then
+            let List.733 : U8 = CallByName List.66 List.593 List.596;
+            let List.725 : [C U64, C U64] = CallByName Test.3 List.594 List.733;
+            let List.730 : U8 = 1i64;
+            let List.731 : U8 = GetTagId List.725;
+            let List.732 : Int1 = lowlevel Eq List.730 List.731;
+            if List.732 then
+                let List.598 : U64 = UnionAtIndex (Id 1) (Index 0) List.725;
+                let List.728 : U64 = 1i64;
+                let List.727 : U64 = CallByName Num.51 List.596 List.728;
+                jump List.722 List.593 List.598 List.595 List.727 List.597;
             else
-                dec List.585;
-                let List.591 : U64 = UnionAtIndex (Id 0) (Index 0) List.717;
-                let List.721 : [C U64, C U64] = TagId(0) List.591;
-                ret List.721;
+                dec List.593;
+                let List.599 : U64 = UnionAtIndex (Id 0) (Index 0) List.725;
+                let List.729 : [C U64, C U64] = TagId(0) List.599;
+                ret List.729;
         else
-            dec List.585;
-            let List.715 : [C U64, C U64] = TagId(1) List.586;
-            ret List.715;
+            dec List.593;
+            let List.723 : [C U64, C U64] = TagId(1) List.594;
+            ret List.723;
     in
     inc Bool.22;
-    jump List.714 Bool.22 Bool.23 Bool.24 Bool.25 Bool.26;
+    jump List.722 Bool.22 Bool.23 Bool.24 Bool.25 Bool.26;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.292 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/error_macros/src/lib.rs

@@ -111,7 +111,8 @@ pub fn error_and_exit(args: fmt::Arguments) -> ! {
 pub const INTERNAL_ERROR_MESSAGE: &str = concat!(
     "An internal compiler expectation was broken.\n",
     "This is definitely a compiler bug.\n",
-    "Please file an issue here: <https://github.com/roc-lang/roc/issues/new/choose>\n",
+    "Note: this compiler is deprecated, we are unlikely to prioritize an issue with it.\n",
+    "Our new compiler is coming along nicely, it will be announced at <https://roc.zulipchat.com/#narrow/channel/397893-announcements> when it is ready to completely replace this one.\n",
 );
 
 /// `internal_error!` should be used whenever a compiler invariant is broken.

langref/README.md

@@ -0,0 +1,102 @@
+**NOTE:** This is heavily WIP! This line will be removed when the langref is considered complete, and at that point, missing sections and outdated information will be considered bugs. If you'd like to contribute to this (other than minor corrections of obvious mistakes), **definitely** mention it in the [langref Zulip channel](https://roc.zulipchat.com/#narrow/channel/316715-contributing/topic/language.20reference/with/564909757) before getting started on anything!
+
+# Language Reference
+
+This is Roc's language reference (or _langref_ for short).
+
+If you're looking for a beginner tutoral, check out [roc-lang.org/tutorial](https://roc-lang.org/tutorial) instead; the langref is a detailed reference intended for experienced Roc programmers.
+
+## Outline
+
+- [Expressions](expressions)
+  - [Values](expressions#values)
+    - [Reference Counting](expressions#reference-counting)
+    - [Reference Cycles](expressions#reference-cycles)
+    - [Opportunistic Mutation](expressions#opportunistic-mutation)
+  - [Block Expressions](expressions#block-expressions)
+- [Statements](statements)
+  - [`=` (assignment)](statements#assignment)
+  - [`import`](statements#import)
+  - [`expect`](statements#expect)
+  - [`return`](statements#return)
+  - [`break`](statements#break)
+  - [`continue`](statements#continue)
+  - [Block Statements](statements#block-statements)
+- [Conditionals](conditionals)
+  - [`if`](conditionals#if)
+  - [`else`](conditionals#else)
+    - [`else if`](conditionals#else-if)
+  - [`and`](conditionals#and)
+  - [`or`](conditionals#or)
+  - [`match`](conditionals#match)
+- [Pattern Matching](pattern-matching)
+  - [`match`](pattern-matching#match)
+    - [Branch Alternatives](pattern-matching#alternatives)
+    - [`if` Guards on Branches](pattern-matching#if-guards-on-branches)
+  - [Exhaustiveness](pattern-matching#exhaustiveness)
+    - [Catch-all Patterns (`_`)](pattern-matching#catch-all-patterns-underscore)
+  - [Destructuring](pattern-matching#destructuring)
+    - [Destructuring Assignments (with `=`)](pattern-matching#destructuring-assignments)
+- [Functions](functions)
+  - [Pure Functions](functions#pure-functions)
+  - [Effectful Functions](functions#effectful-functions)
+    - [`!` suffix](functions#!-suffix)
+  - [Recursive Functions](functions#recursive-functions)
+    - [Self-recursive Functions](functions#self-recursive-functions)
+    - [Mutually Recursive Functions](functions#mutually-recursive-functions)
+  - [Tail Calls](functions#tail-calls)
+    - [Self-tail Calls](functions#self-tail-calls)
+    - [Tail Call Optimization](functions#tail-call-optimization)
+      - [Modulo Cons](functions#modulo-cons)
+- [Naming](naming)
+  - [Shadowing](naming#shadowing)
+  - [Constants](naming#constants)
+  - [Variables (with `var`)](naming#variables)
+    - [`var` keyword](naming#var-keyword)
+    - [`$` suffix](naming#$-suffix)
+  - [Type Variables](naming#type-variables)
+  - [Type Aliases](naming#type-aliases)
+    - [Parameterized Type Aliases](naming#parameterized-type-aliases)
+  - [Module Names](naming#module-names)
+  - [`as`](naming#as)
+- [Modules](modules)
+  - [Type Modules](modules#type-modules)
+  - [Imports](modules#imports)
+  - [Package Modules](modules#package-modules)
+  - [Platform Modules](modules#platform-modules)
+  - [Application Modules](modules#application-modules)
+- [Types](types)
+  - [Type Annotations](types#type-annotations)
+    - [Where Clauses](types#where-clauses)
+  - [Nominal Types](types#nominal-types)
+    - [Opaque Nominal Types](types#opaque-nominal-types)
+  - [Structural Types](types#structural-types)
+  - [Type Aliases](types#type-aliases)
+- [Static Dispatch](static-dispatch)
+  - [Methods](static-dispatch#methods)
+  - [Where Clauses](static-dispatch#where-clauses)
+  - [Aliases](static-dispatch#aliases)
+- [Operators](operators)
+  - [Desugaring](operators#desugaring)
+  - [Binary Infix Operations](operators#binary-infix-operations)
+    - [And](operators#and)
+    - [Or](operators#or)
+    - [Arithmetic Operators](operators#arithmetic-operators)
+    - [Comparison Operators](operators#comparison-operators)
+  - [Unary Prefix Operators](operators#unary-prefix-operators)
+    - [`-` (`.negate()`)](operators#-)
+    - [`!` (`.not()`)](operators#-1)
+  - [Unary Postfix Operators](operators#unary-postfix-operators)
+    - [`?` (unwrap if `Ok`; early `return` if `Err`)](operators#-2)
+    - [`[…]` (subscript operator)](operators#-subscript-operator)
+- [Collections](collections)
+  - [Structural Records](collections#structural-records)
+  - [Nominal Records](collections#nominal-records)
+  - [Tuples](collections#tuples)
+  - [Structural Tag Unions](collections#structural-tag-unions)
+  - [Nominal Tag Unions](collections#nominal-tag-unions)
+  - [Builtin Collections](collections#builtin-collections)
+- [Loops](loops)
+  - [`for` Loops](loops#for)
+  - [`while` Loop](loops#while)
+  - [Infinite Loops](loops#infinite-loops)

langref/collections.md

@@ -0,0 +1,13 @@
+# Collections
+
+## Structural Records
+
+## Nominal Records
+
+## Tuples
+
+## Structural Tag Unions
+
+## Nominal Tag Unions
+
+## Builtin Collections

langref/conditionals.md

@@ -0,0 +1,13 @@
+# Conditionals
+
+## `if`
+
+## `else`
+
+### `else if`
+
+## `and`
+
+## `or`
+
+## `match`

langref/expressions.md

@@ -0,0 +1,140 @@
+# Expressions
+
+An expression is something that evaluates to a [value](#values). 
+
+You can wrap expressions in parentheses without changing what they do. Non-expressions
+can't be wrapped in parentheses without causing an error. Some examples:
+
+- `x` is a valid expression. It evaluates to a value. `(x)` is valid.
+- `foo(1)` is a valid expression. It evaluates to a value. `(foo(1))` is valid.
+- `1` is a valid expression. It's already a value `(1)` is valid.
+- `import Foo` is a [statement](statements) not an expression. `(import Foo)` is invalid.
+- `# Something` is a [comment](comments), not an expression. `(# Something)` is invalid.
+- `package […]` is a [module heaader](modules#headers), not an expression. `(package […])` is invalid.
+
+Another way to think of an expression is that you can always assign it to a name—so, you
+can always put it after an `=` sign.
+
+## [Types of Expressions](#literal-expressions) {#literal-expression}
+
+Here are all the different types of expressions in Roc:
+
+- String literals, e.g. `"foo"` or `"Hello, ${name}!"`
+- Number literals, e.g. `1` or `2.34` or `0.123e4`
+- List literals, e.g. `[1, 2]` or `[]` or `["foo"]`
+- Record literals, e.g. `{ x: 1, y: 2 }` or `{}` or `{ x, y, ..other_record }`
+- Tag literals, e.g. `Foo` or `Foo(bar)`
+- Tuple literals, e.g. `(a, b, "foo")`
+- Function literals (aka "lambdas"), e.g. `|a, b| a + b` or `|| c + d`
+- Lookups, e.g. `blah` or `(blah)` or `$blah` or `($blah)` or `blah!` or `(blah!)`
+- Calls, e.g. `blah(arg)` or `foo.bar(baz)`
+- Operator applications, e.g. `a + b` or `!x`, which [desugar to calls](operators#desugaring)
+- [Block expressions](#block-expressions), e.g. `{ foo() }`
+
+There are no other types of expressions in the language.
+
+## [Values](#values) {#values}
+
+A Roc value is a semantically immutable piece of data. 
+
+### [Value Identity](#value-identity) {#value-identity}
+
+Since values take up memory at runtime, each value has a [memory address](https://en.wikipedia.org/wiki/Memory_address). 
+Roc treats memory addresses as behind-the-scenes implementation details that should not affect
+program behavior, and by design exposes no language-level way to access or compare addresses.
+
+This implies that Roc has no concept of [value identity](https://en.wikipedia.org/wiki/Identity_(object-oriented_programming)), reference equality (also known as [physical equality](https://ocaml.org/manual/5.4/api/Repr.html#VALphys_equal)), or [pointers](https://en.wikipedia.org/wiki/Pointer_(computer_programming)), all of which are semantic concepts based on memory addresses. 
+
+> Note that platform authors can choose to implement features based on memory addresses,
+> since platforms have access to lower-level languages which can naturally see the addresses
+> of any Roc value the platform receives. This means it's up to a platform author to decide 
+> whether it's a good idea for users of their platform to start needing to think about memory
+> addresses, when the rest of the language is designed to keep them behind the scenes.
+
+### [Reference Counting](#reference-counting) {#reference-counting}
+
+Heap-allocated Roc values are automatically [reference-counted](https://en.wikipedia.org/wiki/Reference_counting) ([atomically](https://en.wikipedia.org/wiki/Linearizability#Primitive_atomic_instructions), for thread-safety). 
+
+Heap-allocated values include as strings, lists, boxes, and recursive tag unions. Numbers,
+records, tuples, and non-recursive tag unions are stack-allocated, and so are not reference counted.
+
+### [Reference Cycles](#reference-cycles) {#reference-cycles}
+
+Other languages support [reference cycles](https://en.wikipedia.org/wiki/Reference_counting#Dealing_with_reference_cycles), which create problems for reference counting systems. Solutions to these problems include runtime tracing garbage collectors for cycles, or a concept of [weak references](https://en.wikipedia.org/wiki/Weak_reference). By design, Roc has no way to express reference cycles, so none of these solutions are necessary.
+
+### [Opportunistic Mutation](#opportunistic-mutation) {#opportunistic-mutation}
+
+Roc's compiler does _opportunistic mutation_ using the [Perceus](https://www.microsoft.com/en-us/research/wp-content/uploads/2020/11/perceus-tr-v4.pdf) "functional-but-in-place" reference counting system. The way this works is:
+
+- Builtin operations on reference-counted values will update them in place when their reference counts are 1
+- When their reference counts are greater than 1, they will be shallowly cloned first, and then the clone will be updated and returned.
+
+For example, when [`List.set`](../builtins/List#set) is passed a unique list (reference count is 1), then that list will have the given element replaced. When it's given a shared list (reference count is not 1), it will first shallowly clone the list, and then replace the given element in the clone. Either way, the modified list will be returned—regardless of whether the clone or the original was the one modified.
+
+## [Block Expressions](#block-expressions) {#block-expressions}
+
+A _block expression_ is an expression with some optional [statements](statements) 
+before the expression. It has its own scope, so anything assigned in it can't be accessed
+outsdie the block. The entire block evaluates to the expression at its end.
+
+The statements are optional, so `{ x }` is a valid block expression. This is useful 
+stylistically in situations like conditional branches:
+
+```roc
+x = if foo {
+    …
+} else {
+    x
+}
+```
+
+> Note that `{ x, y }` is a [record](records) with two fields (it's syntax sugar for `{ x: x, y: y }`),
+> but `{ x }` is always a block expression. That's because it's much more useful to have `{ x }` 
+> be a block expression, for situations like `else { x }`, than syntax sugar for a single-field 
+> record like `{ x: x }`. Single-field records are much less common than blocks in 
+> conditional branches.
+
+## [Evaluation](#evaluation) {#evaluation}
+
+Evaluation is the process of an expression becoming a value.
+
+Like most programming languages, Roc uses [strict evaluation](https://en.wikipedia.org/wiki/Strict_programming_language) and does not support [lazy evaluation](https://en.wikipedia.org/wiki/Strict_programming_language) like some non-strict languages do (such as [Haskell](https://www.haskell.org)).
+
+Expressions that are already values (such as `4`, `"foo"`, etc.) evaluate to themselves.
+
+More complex expressions, such as function calls or [block expressions](#block-expressions)
+may require multiple steps to evaluate to a value. 
+
+### [Side Effects during evaluation](#side-effects-during-evaluation) {#side-effects-during-evaluation}
+
+Normally, only evaluating [effectful functions](functions#effectful-functions) can 
+cause [side effects](functions#side-effects), but evaluating any other type of expression cannot. 
+
+One exception to this rule is [`dbg` statements](statements#dbg), which perform the side effect of 
+logging a value for debugging purposes. This is intended to be an interface for debugging, much 
+like a [step debugger](https://en.wikipedia.org/wiki/Debugger), not part of a program's semantics, 
+and so the side effect is allowed outside effectful functions (just like step debugging works on
+any expression, not just calling effectful functions).
+
+The only other exception to the rule is [`expect` statements](statements#expect), 
+
+> Note that platform authors are in charge of what happens when memory gets allocated and
+> deallocated, and can therefore decide to perform side effects during memory allocation
+> and deallocation. This can easily cause surprising behavior for Roc applicationa authors,
+> and should not be relied upon because Roc's optimizer assumes memory allocation and deallocation
+> has no observable effect on the program (unless allocation fails), which means these side
+> effects may be optimized away differently between patch releases of the compiler.
+
+### [Compile-Time Evaluation](#compile-time-evaluation) {#compile-time-evaluation}
+
+When possible, Roc's compiler will evaluate expressions at compile-time instead of at runtime.
+
+This is only possible for expressions that depend only on values known at compile-time. The
+following are not known at compile time:
+
+- Values returned from effectful function calls (which can vary based on runtime state)
+- Values provided by the platform
+
+If a [`crash`](statements#crash) is encountered during compile-time evaluation,
+it will be reported at compile time just like any other compilation errors (such as
+syntax errors, naming errors, and type mismatches).

langref/functions.md

@@ -0,0 +1,23 @@
+# Functions
+
+## Pure Functions
+
+### Side Effects
+
+## Effectful Functions
+
+### `!` suffix
+
+## Recursive Functions
+
+### Self-recursive Functions
+
+### Mutually Recursive Functions
+
+## Tail Calls
+
+### Self-tail Calls
+
+### Tail Call Optimization
+
+#### Modulo Cons

langref/loops.md

@@ -0,0 +1,7 @@
+# Loops
+
+## `for` Loops
+
+## `while` Loop
+
+## Infinite Loops

langref/modules.md

@@ -0,0 +1,15 @@
+# Modules
+
+## Type Modules
+
+## Imports
+
+## Module Headers
+
+## Package Modules
+
+## Platform Modules
+
+## Application Modules
+
+### Headerless Application Modules

langref/naming.md

@@ -0,0 +1,21 @@
+# Naming
+
+## Shadowing
+
+## Constants
+
+## Variables (with `var`)
+
+### `var` keyword
+
+### `$` suffix
+
+## Type Variables
+
+## Type Aliases
+
+### Parameterized Type Aliases
+
+## Module Names
+
+## `as`

langref/operators.md

@@ -0,0 +1,25 @@
+# Operators
+
+## Desugaring
+
+## Binary Infix Operations
+
+### And
+
+### Or
+
+### Arithmetic Operators
+
+### Comparison Operators
+
+## Unary Prefix Operators
+
+### `-` (`.negate()`)
+
+### `!` (`.not()`)
+
+## Unary Postfix Operators
+
+### `?` (unwrap if `Ok`; early `return` if `Err`)
+
+### `[…]` (subscript operator)

langref/pattern-matching.md

@@ -0,0 +1,15 @@
+# Pattern Matching
+
+## `match`
+
+### Branch Alternatives
+
+### `if` Guards on Branches
+
+## Exhaustiveness
+
+### Catch-all Patterns (`_`)
+
+## Destructuring
+
+### Destructuring Assignments (with `=`)

langref/statements.md

@@ -0,0 +1,149 @@
+# Statements
+
+Statements are run as soon as they are encountered at runtime.
+They do not [evaluate](expressions#evaluation) to a [value](expressions#value).
+
+## [`=` (assignment)](#assignment) {#assignment}
+
+An _assignment statement_ gives a name to a [value](expressions#value) inside the current scope.
+
+### [Assignment Order](#assignment-order) {#assignment-order}
+
+Assignments inside expressions can only reference names that were assigned earlier in scope. 
+For example, this would be an error:
+
+```roc
+foo({
+    y = z + 1
+    z = 5
+    
+    z + 1
+})
+```
+
+However, at the top level of a module, assignments can reference each other 
+regardless of declaration order:
+
+```roc
+x = y + 1
+y = 5
+```
+
+### [Assignment Cycles](#assignment-cycles) {#assignment-cycles}
+
+Top-level assignments can only mutually reference each other if they are all assigning to functions. 
+This gives an error at compile time:
+
+```roc
+x = y + 1
+y = x + 1
+```
+
+(If it did not give an error at compile time, it would either crash or loop infinitely at runtime.)
+
+In contrast, this gives no error because all the assignments in the cycle are assigning to functions:
+
+```roc
+x = |arg| if arg >= 1 { y(arg + 1) } else { 0 }
+y = |arg| if arg <= 9 { x(arg + 1) } else { 0 }
+```
+
+### [Reassignment](#reassignment) {#reassignment}
+
+Reassigning to an existing name is only allowed when the name was declared with 
+[`var`](pattern-matching#var). This is allowed:
+
+```roc
+var $foo = 0
+$foo = 1
+```
+
+However, this gives a [shadowing](naming#shadowing) error:
+
+```roc
+foo = 0
+foo = 1
+```
+
+## [`import`](#import) {#import}
+
+The `import` statement imports a [type](types) into scope from a [type module](modules#type-modules).
+
+### [`import` with `exposing`](#import-exposing) {#import-exposing}
+
+### [Renaming Imports with `as`](#renaming-imports) {#renaming-imports}
+
+### [Importing non-Roc files](#importing-non-roc-files) {#importing-non-roc-files}
+
+## [`dbg`](#dbg) {#dbg}
+
+## [`expect`](#expect) {#expect}
+
+## [`return`](#return) {#return}
+
+The `return` statement immediately exits a function, returning the given value.
+
+```roc
+my_func = |arg| {
+    if arg == 0 {
+        return 0
+        
+        # This line will never be reached.
+    }
+    
+    arg - 1
+}
+```
+
+## [`break`](#break) {#break}
+
+(This has not been implemented yet. It will exit a `for` or `while` loop.)
+
+## [`continue`](#continue) {#continue}
+
+(This has not been implemented yet. It will continue to the next iteration of a `for` or `while` loop.)
+
+## [`crash`](#crash) {#crash}
+
+A `crash` statement crashes the running application. All code following the `crash`
+becomes unreachable and will not be executed.
+
+```roc
+if some_condition {
+    crash "There is no way this program could possibly continue."
+}
+
+# This line will never be reached if `some_condition` was `True`
+```
+
+What happens after a `crash` is determined by the platform. Some may gracefully recover
+and have some way of continuing the process, but others may terminate the process immediately.
+
+## [Block Statements](#block-statements) {#block-statements}
+
+A _block statement_ is a group of statements which has its own scope, so 
+anything [assigned](#assignment) in it can't be accessed outsdie the block.
+
+It's different from a [block expression](expressions#block-expressions) in that
+a block statement does not have an expression at the end. A common block
+statement is one that does an early `return` in a conditional branch:
+
+```roc
+if foo {
+    …
+} else {
+    bar = …
+    
+    return bar
+}
+```
+
+Having a single statement in a block expression is allowed:
+
+```roc
+if foo {
+    …
+} else {
+    return bar
+}
+```

langref/static-dispatch.md

@@ -0,0 +1,7 @@
+# Static Dispatch
+
+## Methods
+
+## Where Clauses
+
+## Aliases

langref/types.md

@@ -0,0 +1,13 @@
+# Types
+
+## Type Annotations
+
+### Where Clauses
+
+## Nominal Types
+
+### Opaque Nominal Types
+
+## Structural Types
+
+## Type Aliases