diff --git a/.github/actions/flaky-retry/action.yml b/.github/actions/flaky-retry/action.yml index b72b3cf0a7..60174f38e2 100644 --- a/.github/actions/flaky-retry/action.yml +++ b/.github/actions/flaky-retry/action.yml @@ -28,8 +28,11 @@ runs: 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 @@ -95,4 +98,4 @@ runs: Write-Host "Not retrying" exit $exitCode } - } \ No newline at end of file + } diff --git a/.github/workflows/basic_cli_build_release.yml b/.github/workflows/basic_cli_build_release.yml index f69baf9891..ac749cc490 100644 --- a/.github/workflows/basic_cli_build_release.yml +++ b/.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 diff --git a/.github/workflows/basic_webserver_build_release.yml b/.github/workflows/basic_webserver_build_release.yml index 1aac671447..b57cf163e2 100644 --- a/.github/workflows/basic_webserver_build_release.yml +++ b/.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 diff --git a/.github/workflows/ci_cross_compile.yml b/.github/workflows/ci_cross_compile.yml index 729895274c..559edc0b6a 100644 --- a/.github/workflows/ci_cross_compile.yml +++ b/.github/workflows/ci_cross_compile.yml @@ -15,7 +15,7 @@ jobs: matrix: host: [ ubuntu-22.04, # Linux x64 host - macos-13, # macOS x64 host + macos-15-intel, # macOS x64 host macos-15, # macOS ARM64 host windows-2022, # Windows x64 host ] diff --git a/.github/workflows/ci_manager.yml b/.github/workflows/ci_manager.yml index 14c437252d..928aa12702 100644 --- a/.github/workflows/ci_manager.yml +++ b/.github/workflows/ci_manager.yml @@ -32,6 +32,7 @@ jobs: - 'build.zig.zon' - '.github/workflows/ci_zig.yml' - '.github/workflows/ci_cross_compile.yml' + - '.github/actions/flaky-retry/action.yml' - 'ci/zig_lints.sh' - uses: dorny/paths-filter@v3 id: other_filter @@ -48,6 +49,7 @@ jobs: - '!build.zig.zon' - '!.github/workflows/ci_zig.yml' - '!.github/workflows/ci_cross_compile.yml' + - '!.github/actions/flaky-retry/action.yml' - '!ci/zig_lints.sh' # Files that ci manager workflows should not run on. - '!.gitignore' diff --git a/.github/workflows/ci_zig.yml b/.github/workflows/ci_zig.yml index c4ec973df8..cc137091c9 100644 --- a/.github/workflows/ci_zig.yml +++ b/.github/workflows/ci_zig.yml @@ -62,7 +62,7 @@ jobs: - name: Run Playground Tests run: | - zig build playground-test -Doptimize=ReleaseSmall -- --verbose + zig build test-playground -Doptimize=ReleaseSmall -- --verbose zig-tests: needs: check-once @@ -71,14 +71,14 @@ jobs: fail-fast: false matrix: os: [ - macos-13, + macos-15-intel, macos-15, ubuntu-22.04, ubuntu-24.04-arm, windows-2022, windows-2025, windows-11-arm, - ] # macos-13 uses x64, macos-15 uses arm64 + ] # macos-15 uses arm64 steps: - name: Checkout uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # ratchet:actions/checkout@v4 @@ -97,7 +97,7 @@ jobs: run: | sudo rm /usr/lib/llvm-18/bin/llvm-config - - name: build roc + - name: build repro executables run: | zig build -Dfuzz -Dsystem-afl=false @@ -137,9 +137,12 @@ jobs: - name: zig snapshot tests run: zig build snapshot -- --debug - - name: zig tests - run: | - zig build test -Dfuzz -Dsystem-afl=false + - name: build repro executables + uses: ./.github/actions/flaky-retry + with: + command: 'zig build test -Dfuzz -Dsystem-afl=false' + error_string_contains: 'double roundtrip bundle' + retry_count: 3 - name: Check for snapshot changes run: | diff --git a/.github/workflows/nightly_linux_arm64.yml b/.github/workflows/nightly_linux_arm64.yml index 9d3734e0db..cb5279c496 100644 --- a/.github/workflows/nightly_linux_arm64.yml +++ b/.github/workflows/nightly_linux_arm64.yml @@ -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: diff --git a/.github/workflows/nightly_linux_x86_64.yml b/.github/workflows/nightly_linux_x86_64.yml index 548d71c970..247b962ab7 100644 --- a/.github/workflows/nightly_linux_x86_64.yml +++ b/.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: diff --git a/.github/workflows/nightly_macos_apple_silicon.yml b/.github/workflows/nightly_macos_apple_silicon.yml index c74f48f6c8..bc5e9aac05 100644 --- a/.github/workflows/nightly_macos_apple_silicon.yml +++ b/.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 diff --git a/.github/workflows/nightly_macos_x86_64.yml b/.github/workflows/nightly_macos_x86_64.yml index e710356122..622d67924e 100644 --- a/.github/workflows/nightly_macos_x86_64.yml +++ b/.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: diff --git a/.github/workflows/nix_macos_x86_64.yml b/.github/workflows/nix_macos_x86_64.yml index 60b12c39f5..ce97dd2a88 100644 --- a/.github/workflows/nix_macos_x86_64.yml +++ b/.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 diff --git a/.github/workflows/test_alpha_many_os.yml b/.github/workflows/test_alpha_many_os.yml index 410673cc31..5e5c00bacc 100644 --- a/.github/workflows/test_alpha_many_os.yml +++ b/.github/workflows/test_alpha_many_os.yml @@ -9,11 +9,11 @@ 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: @@ -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') diff --git a/.github/workflows/test_nightly_many_os.yml b/.github/workflows/test_nightly_many_os.yml index c38d1e9356..86627f1a7c 100644 --- a/.github/workflows/test_nightly_many_os.yml +++ b/.github/workflows/test_nightly_many_os.yml @@ -9,11 +9,11 @@ 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: @@ -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) diff --git a/.github/workflows/ubuntu_x86_64.yml b/.github/workflows/ubuntu_x86_64.yml index 3b9d5d618d..5b8d86519c 100644 --- a/.github/workflows/ubuntu_x86_64.yml +++ b/.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 diff --git a/build.zig b/build.zig index d8ded9d50a..6715b19757 100644 --- a/build.zig +++ b/build.zig @@ -19,12 +19,23 @@ pub fn build(b: *std.Build) void { const check_fmt_step = b.step("check-fmt", "Check formatting of all zig code"); const snapshot_step = b.step("snapshot", "Run the snapshot tool to update snapshot files"); const playground_step = b.step("playground", "Build the WASM playground"); - const playground_test_step = b.step("playground-test", "Build the integration test suite for the WASM playground"); + const playground_test_step = b.step("test-playground", "Build the integration test suite for the WASM playground"); + const serialization_size_step = b.step("test-serialization-sizes", "Verify Serialized types have platform-independent sizes"); // general configuration - const target = b.standardTargetOptions(.{ .default_target = .{ - .abi = if (builtin.target.os.tag == .linux) .musl else null, - } }); + const target = blk: { + var default_target_query: std.Target.Query = .{ + .abi = if (builtin.target.os.tag == .linux) .musl else null, + }; + + // Use baseline x86_64 CPU for Valgrind compatibility on CI (Valgrind 3.18.1 doesn't support AVX-512) + const is_ci = std.process.getEnvVarOwned(b.allocator, "CI") catch null; + if (is_ci != null and builtin.target.cpu.arch == .x86_64 and builtin.target.os.tag == .linux) { + default_target_query.cpu_model = .{ .explicit = &std.Target.x86.cpu.x86_64 }; + } + + break :blk b.standardTargetOptions(.{ .default_target = default_target_query }); + }; const optimize = b.standardOptimizeOption(.{}); const strip = b.option(bool, "strip", "Omit debug information"); const no_bin = b.option(bool, "no-bin", "Skip emitting binaries (important for fast incremental compilation)") orelse false; @@ -79,11 +90,168 @@ pub fn build(b: *std.Build) void { const roc_modules = modules.RocModules.create(b, build_options, zstd); - // add main roc exe const roc_exe = addMainExe(b, roc_modules, target, optimize, strip, enable_llvm, use_system_llvm, user_llvm_path, flag_enable_tracy, zstd) orelse return; roc_modules.addAll(roc_exe); install_and_run(b, no_bin, roc_exe, roc_step, run_step, run_args); + // Build-time compiler for builtin .roc modules with caching + // + // Changes to .roc files in src/build/roc/ are automatically detected and trigger recompilation. + // However, if you modify the compiler itself (e.g., parse, can, check modules) and want those + // changes reflected in the builtin .bin files, you need to run: zig build rebuild-builtins + // + // We cache the builtin compiler executable to avoid ~doubling normal build times. + // CI always rebuilds from scratch, so it's not affected by this caching. + + // Discover all .roc files in src/build/roc/ + const roc_files = discoverBuiltinRocFiles(b) catch |err| { + std.debug.print("Failed to discover builtin .roc files: {}\n", .{err}); + return; + }; + + // Check if we need to rebuild builtins by comparing .roc and .bin file timestamps + const should_rebuild_builtins = blk: { + for (roc_files) |roc_path| { + // Get the base name (e.g., "Dict" from "src/build/roc/Dict.roc") + const roc_basename = std.fs.path.basename(roc_path); + const name_without_ext = roc_basename[0 .. roc_basename.len - 4]; // Remove ".roc" + + // Check if corresponding .bin file exists and is up-to-date + const bin_path = b.fmt("zig-out/builtins/{s}.bin", .{name_without_ext}); + + const roc_stat = std.fs.cwd().statFile(roc_path) catch break :blk true; + const bin_stat = std.fs.cwd().statFile(bin_path) catch break :blk true; + + // If .roc file is newer than .bin file, rebuild + if (roc_stat.mtime > bin_stat.mtime) { + break :blk true; + } + } + + // All .bin files exist and are up-to-date + break :blk false; + }; + + const write_compiled_builtins = b.addWriteFiles(); + + if (should_rebuild_builtins) { + // Build and run the compiler + const builtin_compiler_exe = b.addExecutable(.{ + .name = "builtin_compiler", + .root_source_file = b.path("src/build/builtin_compiler/main.zig"), + .target = b.graph.host, // this runs at build time on the *host* machine! + .optimize = .Debug, // No need to optimize - only compiles builtin modules + // Note: libc linking is handled by add_tracy below (required when tracy is enabled) + }); + + // Add only the minimal modules needed for parsing/checking + builtin_compiler_exe.root_module.addImport("base", roc_modules.base); + builtin_compiler_exe.root_module.addImport("collections", roc_modules.collections); + builtin_compiler_exe.root_module.addImport("types", roc_modules.types); + builtin_compiler_exe.root_module.addImport("parse", roc_modules.parse); + builtin_compiler_exe.root_module.addImport("can", roc_modules.can); + builtin_compiler_exe.root_module.addImport("check", roc_modules.check); + builtin_compiler_exe.root_module.addImport("reporting", roc_modules.reporting); + builtin_compiler_exe.root_module.addImport("builtins", roc_modules.builtins); + + // Add tracy support (required by parse/can/check modules) + add_tracy(b, roc_modules.build_options, builtin_compiler_exe, b.graph.host, false, flag_enable_tracy); + + // Run the builtin compiler to generate .bin files in zig-out/builtins/ + const run_builtin_compiler = b.addRunArtifact(builtin_compiler_exe); + + // Add all .roc files as explicit file inputs so Zig's cache tracks them + for (roc_files) |roc_path| { + run_builtin_compiler.addFileArg(b.path(roc_path)); + } + + write_compiled_builtins.step.dependOn(&run_builtin_compiler.step); + + // Copy all generated .bin files from zig-out to build cache + for (roc_files) |roc_path| { + const roc_basename = std.fs.path.basename(roc_path); + const name_without_ext = roc_basename[0 .. roc_basename.len - 4]; + const bin_filename = b.fmt("{s}.bin", .{name_without_ext}); + + _ = write_compiled_builtins.addCopyFile( + .{ .cwd_relative = b.fmt("zig-out/builtins/{s}", .{bin_filename}) }, + bin_filename, + ); + } + } else { + // Use existing .bin files from zig-out/builtins/ + for (roc_files) |roc_path| { + const roc_basename = std.fs.path.basename(roc_path); + const name_without_ext = roc_basename[0 .. roc_basename.len - 4]; + const bin_filename = b.fmt("{s}.bin", .{name_without_ext}); + + _ = write_compiled_builtins.addCopyFile( + .{ .cwd_relative = b.fmt("zig-out/builtins/{s}", .{bin_filename}) }, + bin_filename, + ); + } + } + + // Generate compiled_builtins.zig dynamically based on discovered .roc files + const builtins_source_str = generateCompiledBuiltinsSource(b, roc_files) catch |err| { + std.debug.print("Failed to generate compiled_builtins.zig: {}\n", .{err}); + return; + }; + + const compiled_builtins_source = write_compiled_builtins.add( + "compiled_builtins.zig", + builtins_source_str, + ); + + const compiled_builtins_module = b.createModule(.{ + .root_source_file = compiled_builtins_source, + }); + + // Manual rebuild command: zig build rebuild-builtins + // Use this after making compiler changes to ensure those changes are reflected in builtins + const rebuild_builtins_step = b.step( + "rebuild-builtins", + "Force rebuild of all builtin modules (*.roc -> *.bin)", + ); + + // Discover .roc files again for the rebuild command + const roc_files_force = discoverBuiltinRocFiles(b) catch |err| { + std.debug.print("Failed to discover .roc files for rebuild: {}\n", .{err}); + return; + }; + + // Always build and run the compiler for this command + const builtin_compiler_exe_force = b.addExecutable(.{ + .name = "builtin_compiler", + .root_source_file = b.path("src/build/builtin_compiler/main.zig"), + .target = b.graph.host, + .optimize = .Debug, + }); + + builtin_compiler_exe_force.root_module.addImport("base", roc_modules.base); + builtin_compiler_exe_force.root_module.addImport("collections", roc_modules.collections); + builtin_compiler_exe_force.root_module.addImport("types", roc_modules.types); + builtin_compiler_exe_force.root_module.addImport("parse", roc_modules.parse); + builtin_compiler_exe_force.root_module.addImport("can", roc_modules.can); + builtin_compiler_exe_force.root_module.addImport("check", roc_modules.check); + builtin_compiler_exe_force.root_module.addImport("reporting", roc_modules.reporting); + builtin_compiler_exe_force.root_module.addImport("builtins", roc_modules.builtins); + + add_tracy(b, roc_modules.build_options, builtin_compiler_exe_force, b.graph.host, false, flag_enable_tracy); + + const run_builtin_compiler_force = b.addRunArtifact(builtin_compiler_exe_force); + + // Add all discovered .roc files as inputs + for (roc_files_force) |roc_path| { + run_builtin_compiler_force.addFileArg(b.path(roc_path)); + } + + rebuild_builtins_step.dependOn(&run_builtin_compiler_force.step); + + // Add the compiled builtins module to roc exe and make it depend on the builtins being ready + roc_exe.root_module.addImport("compiled_builtins", compiled_builtins_module); + roc_exe.step.dependOn(&write_compiled_builtins.step); + // Add snapshot tool const snapshot_exe = b.addExecutable(.{ .name = "snapshot", @@ -95,6 +263,8 @@ pub fn build(b: *std.Build) void { }), }); roc_modules.addAll(snapshot_exe); + snapshot_exe.root_module.addImport("compiled_builtins", compiled_builtins_module); + snapshot_exe.step.dependOn(&write_compiled_builtins.step); add_tracy(b, roc_modules.build_options, snapshot_exe, target, false, flag_enable_tracy); install_and_run(b, no_bin, snapshot_exe, snapshot_step, snapshot_step, run_args); @@ -155,84 +325,151 @@ pub fn build(b: *std.Build) void { break :blk install; }; + // Add serialization size check + // This verifies that Serialized types have the same size on 32-bit and 64-bit platforms + // using compile-time assertions + { + // Build for native - will fail at compile time if sizes don't match expected + const size_check_native = b.addExecutable(.{ + .name = "serialization_size_check_native", + .root_source_file = b.path("test/serialization_size_check.zig"), + .target = target, + .optimize = .Debug, + }); + roc_modules.addAll(size_check_native); + + // Build for wasm32 (32-bit) - will fail at compile time if sizes don't match expected + const size_check_wasm32 = b.addExecutable(.{ + .name = "serialization_size_check_wasm32", + .root_source_file = b.path("test/serialization_size_check.zig"), + .target = b.resolveTargetQuery(.{ + .cpu_arch = .wasm32, + .os_tag = .freestanding, + }), + .optimize = .Debug, + }); + size_check_wasm32.entry = .disabled; + size_check_wasm32.rdynamic = true; + roc_modules.addAll(size_check_wasm32); + + // Run the native version to confirm (wasm32 build is enough to verify 32-bit) + const run_native = b.addRunArtifact(size_check_native); + + // The test passes if both executables build successfully (compile-time checks pass) + // and the native one runs without error + serialization_size_step.dependOn(&size_check_native.step); + serialization_size_step.dependOn(&size_check_wasm32.step); + serialization_size_step.dependOn(&run_native.step); + } + // Create and add module tests const module_tests = roc_modules.createModuleTests(b, target, optimize, zstd, test_filters); for (module_tests) |module_test| { + // Add compiled builtins to check module tests + if (std.mem.eql(u8, module_test.test_step.name, "check")) { + module_test.test_step.root_module.addImport("compiled_builtins", compiled_builtins_module); + module_test.test_step.step.dependOn(&write_compiled_builtins.step); + } + if (run_args.len != 0) { module_test.run_step.addArgs(run_args); } + + // Create individual test step for this module + const test_exe_name = module_test.test_step.name; + const step_name = b.fmt("test-{s}", .{test_exe_name}); + const individual_test_step = b.step(step_name, b.fmt("Run {s} tests only", .{test_exe_name})); + + // Create run step that accepts command line args (including --test-filter) + const individual_run = b.addRunArtifact(module_test.test_step); + if (run_args.len != 0) { + individual_run.addArgs(run_args); + } + individual_test_step.dependOn(&individual_run.step); + b.default_step.dependOn(&module_test.test_step.step); test_step.dependOn(&module_test.run_step.step); } // Add snapshot tool test - const snapshot_test = b.addTest(.{ - .name = "snapshot_tool_test", - .root_module = b.createModule(.{ - .root_source_file = b.path("src/snapshot_tool/main.zig"), - .target = target, - .optimize = optimize, - .link_libc = true, - }), - .filters = test_filters, - }); - roc_modules.addAll(snapshot_test); - add_tracy(b, roc_modules.build_options, snapshot_test, target, false, flag_enable_tracy); + const enable_snapshot_tests = b.option(bool, "snapshot-tests", "Enable snapshot tests") orelse true; + if (enable_snapshot_tests) { + const snapshot_test = b.addTest(.{ + .name = "snapshot_tool_test", + .root_module = b.createModule(.{ + .root_source_file = b.path("src/snapshot_tool/main.zig"), + .target = target, + .optimize = optimize, + .link_libc = true, + }), + .filters = test_filters, + }); + roc_modules.addAll(snapshot_test); + snapshot_test.root_module.addImport("compiled_builtins", compiled_builtins_module); + snapshot_test.step.dependOn(&write_compiled_builtins.step); + add_tracy(b, roc_modules.build_options, snapshot_test, target, false, flag_enable_tracy); - const run_snapshot_test = b.addRunArtifact(snapshot_test); - if (run_args.len != 0) { - run_snapshot_test.addArgs(run_args); + const run_snapshot_test = b.addRunArtifact(snapshot_test); + if (run_args.len != 0) { + run_snapshot_test.addArgs(run_args); + } + test_step.dependOn(&run_snapshot_test.step); } - test_step.dependOn(&run_snapshot_test.step); // Add CLI test - const cli_test = b.addTest(.{ - .name = "cli_test", - .root_module = b.createModule(.{ - .root_source_file = b.path("src/cli/main.zig"), - .target = target, - .optimize = optimize, - .link_libc = true, - }), - .filters = test_filters, - }); - roc_modules.addAll(cli_test); - cli_test.linkLibrary(zstd.artifact("zstd")); - add_tracy(b, roc_modules.build_options, cli_test, target, false, flag_enable_tracy); + const enable_cli_tests = b.option(bool, "cli-tests", "Enable cli tests") orelse true; + if (enable_cli_tests) { + const cli_test = b.addTest(.{ + .name = "cli_test", + .root_module = b.createModule(.{ + .root_source_file = b.path("src/cli/main.zig"), + .target = target, + .optimize = optimize, + .link_libc = true, + }), + .filters = test_filters, + }); + roc_modules.addAll(cli_test); + cli_test.linkLibrary(zstd.artifact("zstd")); + add_tracy(b, roc_modules.build_options, cli_test, target, false, flag_enable_tracy); - const run_cli_test = b.addRunArtifact(cli_test); - if (run_args.len != 0) { - run_cli_test.addArgs(run_args); + const run_cli_test = b.addRunArtifact(cli_test); + if (run_args.len != 0) { + run_cli_test.addArgs(run_args); + } + test_step.dependOn(&run_cli_test.step); } - test_step.dependOn(&run_cli_test.step); // Add watch tests - const watch_test = b.addTest(.{ - .name = "watch_test", - .root_module = b.createModule(.{ - .root_source_file = b.path("src/watch/watch.zig"), - .target = target, - .optimize = optimize, - .link_libc = true, - }), - .filters = test_filters, - }); - roc_modules.addAll(watch_test); - add_tracy(b, roc_modules.build_options, watch_test, target, false, flag_enable_tracy); + const enable_watch_tests = b.option(bool, "watch-tests", "Enable watch tests") orelse true; + if (enable_watch_tests) { + const watch_test = b.addTest(.{ + .name = "watch_test", + .root_module = b.createModule(.{ + .root_source_file = b.path("src/watch/watch.zig"), + .target = target, + .optimize = optimize, + .link_libc = true, + }), + .filters = test_filters, + }); + roc_modules.addAll(watch_test); + add_tracy(b, roc_modules.build_options, watch_test, target, false, flag_enable_tracy); - // Link platform-specific libraries for file watching - if (target.result.os.tag == .macos) { - watch_test.linkFramework("CoreFoundation"); - watch_test.linkFramework("CoreServices"); - } else if (target.result.os.tag == .windows) { - watch_test.linkSystemLibrary("kernel32"); - } + // Link platform-specific libraries for file watching + if (target.result.os.tag == .macos) { + watch_test.linkFramework("CoreFoundation"); + watch_test.linkFramework("CoreServices"); + } else if (target.result.os.tag == .windows) { + watch_test.linkSystemLibrary("kernel32"); + } - const run_watch_test = b.addRunArtifact(watch_test); - if (run_args.len != 0) { - run_watch_test.addArgs(run_args); + const run_watch_test = b.addRunArtifact(watch_test); + if (run_args.len != 0) { + run_watch_test.addArgs(run_args); + } + test_step.dependOn(&run_watch_test.step); } - test_step.dependOn(&run_watch_test.step); b.default_step.dependOn(playground_step); { @@ -295,6 +532,44 @@ pub fn build(b: *std.Build) void { const ModuleTest = modules.ModuleTest; +fn discoverBuiltinRocFiles(b: *std.Build) ![]const []const u8 { + var builtin_roc_dir = try std.fs.cwd().openDir("src/build/roc", .{ .iterate = true }); + defer builtin_roc_dir.close(); + + var roc_files = std.array_list.Managed([]const u8).init(b.allocator); + errdefer roc_files.deinit(); + + var iter = builtin_roc_dir.iterate(); + while (try iter.next()) |entry| { + if (entry.kind == .file and std.mem.endsWith(u8, entry.name, ".roc")) { + const full_path = b.fmt("src/build/roc/{s}", .{entry.name}); + try roc_files.append(full_path); + } + } + + return roc_files.toOwnedSlice(); +} + +fn generateCompiledBuiltinsSource(b: *std.Build, roc_files: []const []const u8) ![]const u8 { + var builtins_source = std.array_list.Managed(u8).init(b.allocator); + errdefer builtins_source.deinit(); + const writer = builtins_source.writer(); + + for (roc_files) |roc_path| { + const roc_basename = std.fs.path.basename(roc_path); + const name_without_ext = roc_basename[0 .. roc_basename.len - 4]; + // Use lowercase with underscore for the identifier + const lower_name = try std.ascii.allocLowerString(b.allocator, name_without_ext); + + try writer.print("pub const {s}_bin = @embedFile(\"{s}.bin\");\n", .{ + lower_name, + name_without_ext, + }); + } + + return builtins_source.toOwnedSlice(); +} + fn add_fuzz_target( b: *std.Build, fuzz: bool, @@ -320,6 +595,10 @@ fn add_fuzz_target( .optimize = if (target.result.os.tag == .macos) .Debug else .ReleaseSafe, }), }); + // Required for fuzzing. + fuzz_obj.root_module.link_libc = true; + fuzz_obj.root_module.stack_check = false; + roc_modules.addAll(fuzz_obj); add_tracy(b, roc_modules.build_options, fuzz_obj, target, false, tracy); @@ -344,7 +623,7 @@ fn add_fuzz_target( b.default_step.dependOn(fuzz_step); const afl = b.lazyImport(@This(), "afl_kit") orelse return; - const fuzz_exe = afl.addInstrumentedExe(b, target, .ReleaseSafe, &.{}, use_system_afl, fuzz_obj) orelse return; + const fuzz_exe = afl.addInstrumentedExe(b, target, .ReleaseSafe, &.{}, use_system_afl, fuzz_obj, &.{"-lm"}) orelse return; const install_fuzz = b.addInstallBinFile(fuzz_exe, name_exe); fuzz_step.dependOn(&install_fuzz.step); b.getInstallStep().dependOn(&install_fuzz.step); diff --git a/build.zig.zon b/build.zig.zon index 626d8cbd24..d34225dfef 100644 --- a/build.zig.zon +++ b/build.zig.zon @@ -4,8 +4,8 @@ .minimum_zig_version = "0.15.1", .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 = .{ diff --git a/src/PROFILING/README.md b/src/PROFILING/README.md index b1bc133277..1f640379ee 100644 --- a/src/PROFILING/README.md +++ b/src/PROFILING/README.md @@ -34,7 +34,7 @@ They also lack interactivity and many low level details. Flamegraphs are essentially a still frame view into an apps performance. The tool is simple to run. -Using it with roc can be as simple as `flamegraph --root -- ./zig-out/bin/roc format /tmp/app.roc`. +Using it with roc can be as simple as `flamegraph --root -- ./zig-out/bin/roc fmt /tmp/app.roc`. > Note: `--root` is not always needed, but it generally gives better results. @@ -51,7 +51,7 @@ Samply is a sampling profiler that that uses the [Firefox profiler](https://prof I find it to be a richer and nicer default than simple flamegraphs, but it is also more complex. Not only do you get a flamegraph, but you get callstacks, can collapse recursive nodes, and are able to view source lines and assembly hit by the sampler. -Using samply is also super simply, just `samply record -- ./zig-out/bin/roc format /tmp/new.roc`. +Using samply is also super simply, just `samply record -- ./zig-out/bin/roc fmt /tmp/new.roc`. Here is an example output after searching for `memmove`. We can see in the top graph, all the specific times during execution that memmove was using the cpu. @@ -79,11 +79,11 @@ Often times, it is worth profiling once with `-Dtracy-callstack=false` to have m Now that I have the compiler built with tracy, I can launch the tracy server on my mac machine to record the result (you can also run it on the same machine if wanted). Run `tracy-profiler`, input the correct ip address, and press connect. -Then run the instrumented version of zig: `./zig-out/bin/roc format /tmp/new.roc`. +Then run the instrumented version of zig: `./zig-out/bin/roc fmt /tmp/new.roc`. Also, run with the root user to capture more information. In this case, I ran: ``` -sudo ./zig-out/bin/roc format /tmp/new.roc +sudo ./zig-out/bin/roc fmt /tmp/new.roc ``` After that, welcome to a wealth of information: diff --git a/src/base/CommonEnv.zig b/src/base/CommonEnv.zig index d1e4d8a6c8..a69d0fff15 100644 --- a/src/base/CommonEnv.zig +++ b/src/base/CommonEnv.zig @@ -96,7 +96,7 @@ pub const Serialized = struct { strings: StringLiteral.Store.Serialized, exposed_items: ExposedItems.Serialized, line_starts: SafeList(u32).Serialized, - source: []const u8, // Serialized as zeros, provided during deserialization + source: [2]u64, // Reserve space for slice (ptr + len), provided during deserialization /// Serialize a ModuleEnv into this Serialized struct, appending data to the writer pub fn serialize( @@ -105,13 +105,15 @@ pub const Serialized = struct { allocator: std.mem.Allocator, writer: *CompactWriter, ) !void { - self.source = ""; // Empty slice - // Serialize each component using its Serialized struct try self.idents.serialize(&env.idents, allocator, writer); try self.strings.serialize(&env.strings, allocator, writer); try self.exposed_items.serialize(&env.exposed_items, allocator, writer); try self.line_starts.serialize(&env.line_starts, allocator, writer); + + // Set source to all zeros; the space needs to be here, + // but the value will be set separately during deserialization. + self.source = .{ 0, 0 }; } /// Deserialize a CommonEnv from the buffer, updating the CommonEnv in place diff --git a/src/base/SExprTree.zig b/src/base/SExprTree.zig index 3e0bea6be3..34c44091dd 100644 --- a/src/base/SExprTree.zig +++ b/src/base/SExprTree.zig @@ -146,9 +146,9 @@ const Node = union(enum) { BytesRange: struct { begin: u32, end: u32, region: RegionInfo }, }; -children: std.ArrayList(Node), -data: std.ArrayList(u8), -stack: std.ArrayList(Node), +children: std.array_list.Managed(Node), +data: std.array_list.Managed(u8), +stack: std.array_list.Managed(Node), allocator: std.mem.Allocator, pub fn init(allocator: std.mem.Allocator) SExprTree { diff --git a/src/base/Scratch.zig b/src/base/Scratch.zig index 28df091a93..d7c9e8d136 100644 --- a/src/base/Scratch.zig +++ b/src/base/Scratch.zig @@ -7,10 +7,10 @@ const DataSpan = @import("DataSpan.zig"); /// A stack for easily adding and removing index types when doing recursive operations pub fn Scratch(comptime T: type) type { return struct { - items: std.ArrayList(T), + items: std.array_list.Managed(T), const Self = @This(); - const ArrayList = std.ArrayList(T); + const ArrayList = std.array_list.Managed(T); pub fn init(gpa: std.mem.Allocator) std.mem.Allocator.Error!Self { const items = try ArrayList.initCapacity(gpa, std.math.ceilPowerOfTwoAssert(usize, 64)); @@ -28,11 +28,16 @@ pub fn Scratch(comptime T: type) type { return @as(u32, @intCast(self.items.items.len)); } - /// Places a new index of type `T` in the scratch. Will panic on OOM. + /// Places a new index of type `T` in the scratch pub fn append(self: *Self, gpa: std.mem.Allocator, idx: T) std.mem.Allocator.Error!void { try self.items.append(gpa, idx); } + /// Pop an item of the scratch buffer + pub fn pop(self: *Self) ?T { + return self.items.pop(); + } + /// Creates slice from the provided indexes pub fn slice(self: *Self, start: u32, end: u32) []T { return self.items.items[@intCast(start)..@intCast(end)]; @@ -45,7 +50,7 @@ pub fn Scratch(comptime T: type) type { /// Creates a new span starting at start. Moves the items from scratch /// to extra_data as appropriate. - pub fn spanFromStart(self: *Self, start: u32, gpa: std.mem.Allocator, data: *std.ArrayList(u32)) std.mem.Allocator.Error!DataSpan { + pub fn spanFromStart(self: *Self, start: u32, gpa: std.mem.Allocator, data: *std.array_list.Managed(u32)) std.mem.Allocator.Error!DataSpan { const end = self.items.len; defer self.items.shrinkRetainingCapacity(start); var i = @as(usize, @intCast(start)); @@ -61,7 +66,9 @@ pub fn Scratch(comptime T: type) type { /// Should be used wherever the scratch items will not be used, /// as in when parsing fails. pub fn clearFrom(self: *Self, start: u32) void { - self.items.shrinkRetainingCapacity(start); + if (self.items.items.len > start) { + self.items.shrinkRetainingCapacity(start); + } } }; } diff --git a/src/build/builtin_compiler/main.zig b/src/build/builtin_compiler/main.zig new file mode 100644 index 0000000000..58d4205bc2 --- /dev/null +++ b/src/build/builtin_compiler/main.zig @@ -0,0 +1,267 @@ +//! Build-time compiler for Roc builtin modules (Bool.roc, Result.roc, Dict.roc, and Set.roc). +//! +//! This executable runs during `zig build` on the host machine to: +//! 1. Parse and type-check the builtin .roc modules +//! 2. Serialize the resulting ModuleEnvs to binary files +//! 3. Output .bin files to zig-out/builtins/ (which get embedded in the roc binary) + +const std = @import("std"); +const base = @import("base"); +const parse = @import("parse"); +const can = @import("can"); +const check = @import("check"); +const collections = @import("collections"); +const types = @import("types"); + +const ModuleEnv = can.ModuleEnv; +const Can = can.Can; +const Check = check.Check; +const Allocator = std.mem.Allocator; + +/// Build-time compiler that compiles builtin .roc sources into serialized ModuleEnvs. +/// This runs during `zig build` on the host machine to generate .bin files +/// that get embedded into the final roc executable. +/// +/// Note: Command-line arguments are ignored. The .roc files are read from fixed paths. +/// The build system may pass file paths as arguments for cache tracking, but we don't use them. +pub fn main() !void { + var gpa_impl = std.heap.GeneralPurposeAllocator(.{}){}; + defer { + const leaked = gpa_impl.deinit(); + if (leaked == .leak) { + std.debug.print("WARNING: Memory leaked!\n", .{}); + } + } + const gpa = gpa_impl.allocator(); + + // Ignore command-line arguments - they're only used by Zig's build system for cache tracking + + // Read the .roc source files at runtime + const bool_roc_source = try std.fs.cwd().readFileAlloc(gpa, "src/build/roc/Bool.roc", 1024 * 1024); + defer gpa.free(bool_roc_source); + + const result_roc_source = try std.fs.cwd().readFileAlloc(gpa, "src/build/roc/Result.roc", 1024 * 1024); + defer gpa.free(result_roc_source); + + const dict_roc_source = try std.fs.cwd().readFileAlloc(gpa, "src/build/roc/Dict.roc", 1024 * 1024); + defer gpa.free(dict_roc_source); + + const set_roc_source = try std.fs.cwd().readFileAlloc(gpa, "src/build/roc/Set.roc", 1024 * 1024); + defer gpa.free(set_roc_source); + + // Compile Bool.roc without injecting anything (it's completely self-contained) + const bool_env = try compileModule( + gpa, + "Bool", + bool_roc_source, + &.{}, // No module dependencies + .{ .inject_bool = false, .inject_result = false }, + ); + defer { + bool_env.deinit(); + gpa.destroy(bool_env); + } + + // Verify that Bool's type declaration is at the expected index (2) + // This is critical for the compiler's hardcoded BUILTIN_BOOL constant + const bool_type_idx = bool_env.all_statements.span.start; + if (bool_type_idx != 2) { + const stderr = std.io.getStdErr().writer(); + try stderr.print("WARNING: Expected Bool at index 2, but got {}!\n", .{bool_type_idx}); + return error.UnexpectedBoolIndex; + } + + // Compile Result.roc (injects Bool since Result might use if expressions) + const result_env = try compileModule( + gpa, + "Result", + result_roc_source, + &.{}, // No module dependencies + .{ .inject_bool = true, .inject_result = false }, + ); + defer { + result_env.deinit(); + gpa.destroy(result_env); + } + + // Compile Dict.roc (needs Bool injected for if expressions, and Result for error handling) + const dict_env = try compileModule( + gpa, + "Dict", + dict_roc_source, + &.{}, // No module dependencies + .{}, // Inject Bool and Result (defaults) + ); + defer { + dict_env.deinit(); + gpa.destroy(dict_env); + } + + // Compile Set.roc (imports Dict, needs Bool and Result injected) + const set_env = try compileModule( + gpa, + "Set", + set_roc_source, + &[_]ModuleDep{ + .{ .name = "Dict", .env = dict_env }, + }, + .{}, // Inject Bool and Result (defaults) + ); + defer { + set_env.deinit(); + gpa.destroy(set_env); + } + + // Create output directory + try std.fs.cwd().makePath("zig-out/builtins"); + + // Serialize modules + try serializeModuleEnv(gpa, bool_env, "zig-out/builtins/Bool.bin"); + try serializeModuleEnv(gpa, result_env, "zig-out/builtins/Result.bin"); + try serializeModuleEnv(gpa, dict_env, "zig-out/builtins/Dict.bin"); + try serializeModuleEnv(gpa, set_env, "zig-out/builtins/Set.bin"); +} + +const ModuleDep = struct { + name: []const u8, + env: *const ModuleEnv, +}; + +fn compileModule( + gpa: Allocator, + module_name: []const u8, + source: []const u8, + deps: []const ModuleDep, + can_options: Can.InitOptions, +) !*ModuleEnv { + // This follows the pattern from TestEnv.init() in src/check/test/TestEnv.zig + + // 1. Create ModuleEnv + var module_env = try gpa.create(ModuleEnv); + errdefer gpa.destroy(module_env); + + var arena = std.heap.ArenaAllocator.init(gpa); + defer arena.deinit(); + + module_env.* = try ModuleEnv.init(gpa, source); + errdefer module_env.deinit(); + + module_env.common.source = source; + module_env.module_name = module_name; + try module_env.common.calcLineStarts(gpa); + + // 2. Create common idents (needed for type checking) + const module_ident = try module_env.insertIdent(base.Ident.for_text(module_name)); + const list_ident = try module_env.insertIdent(base.Ident.for_text("List")); + const box_ident = try module_env.insertIdent(base.Ident.for_text("Box")); + + const common_idents: Check.CommonIdents = .{ + .module_name = module_ident, + .list = list_ident, + .box = box_ident, + }; + + // 3. Parse + var parse_ast = try gpa.create(parse.AST); + defer { + parse_ast.deinit(gpa); + gpa.destroy(parse_ast); + } + + parse_ast.* = try parse.parse(&module_env.common, gpa); + parse_ast.store.emptyScratch(); + + // Check for parse errors + if (parse_ast.hasErrors()) { + std.debug.print("Parse errors in {s}:\n", .{module_name}); + for (parse_ast.tokenize_diagnostics.items) |diag| { + std.debug.print(" Tokenize error: {any}\n", .{diag}); + } + for (parse_ast.parse_diagnostics.items) |diag| { + std.debug.print(" Parse error: {any}\n", .{diag}); + } + return error.ParseError; + } + + // 4. Create module imports map (for cross-module references) + var module_envs = std.StringHashMap(*const ModuleEnv).init(gpa); + defer module_envs.deinit(); + + // Add dependencies (e.g., Dict for Set) + for (deps) |dep| { + try module_envs.put(dep.name, dep.env); + } + + // 5. Canonicalize + try module_env.initCIRFields(gpa, module_name); + + var can_result = try gpa.create(Can); + defer { + can_result.deinit(); + gpa.destroy(can_result); + } + + can_result.* = try Can.init(module_env, parse_ast, &module_envs, can_options); + + try can_result.canonicalizeFile(); + try can_result.validateForChecking(); + + // 6. Type check + // Build the list of other modules for type checking + var other_modules = std.array_list.Managed(*const ModuleEnv).init(gpa); + defer other_modules.deinit(); + + // Add dependencies + for (deps) |dep| { + try other_modules.append(dep.env); + } + + var checker = try Check.init( + gpa, + &module_env.types, + module_env, + other_modules.items, + &module_env.store.regions, + common_idents, + ); + defer checker.deinit(); + + try checker.checkFile(); + + // Check for type errors + if (checker.problems.problems.items.len > 0) { + std.debug.print("Type errors found in {s}:\n", .{module_name}); + for (checker.problems.problems.items) |prob| { + std.debug.print(" - Problem: {any}\n", .{prob}); + } + return error.TypeCheckError; + } + + return module_env; +} + +fn serializeModuleEnv( + gpa: Allocator, + env: *const ModuleEnv, + output_path: []const u8, +) !void { + // This follows the pattern from module_env_test.zig + + var arena = std.heap.ArenaAllocator.init(gpa); + defer arena.deinit(); + const arena_alloc = arena.allocator(); + + // Create output file + const file = try std.fs.cwd().createFile(output_path, .{ .read = true }); + defer file.close(); + + // Serialize using CompactWriter + var writer = collections.CompactWriter.init(); + defer writer.deinit(arena_alloc); + + const serialized = try writer.appendAlloc(arena_alloc, ModuleEnv.Serialized); + try serialized.serialize(env, arena_alloc, &writer); + + // Write to file + try writer.writeGather(arena_alloc, file); +} diff --git a/src/build/modules.zig b/src/build/modules.zig index 899fd0d44f..0aa054c4f5 100644 --- a/src/build/modules.zig +++ b/src/build/modules.zig @@ -100,7 +100,7 @@ pub const ModuleType = enum { .can => &.{ .tracy, .builtins, .collections, .types, .base, .parse, .reporting }, .check => &.{ .tracy, .builtins, .collections, .base, .parse, .types, .can, .reporting }, .layout => &.{ .collections, .base, .types, .builtins, .can }, - .eval => &.{ .collections, .base, .types, .builtins, .parse, .can, .check, .layout, .build_options }, + .eval => &.{ .collections, .base, .types, .builtins, .parse, .can, .check, .layout, .build_options, .reporting }, .compile => &.{ .tracy, .build_options, .fs, .builtins, .collections, .base, .types, .parse, .can, .check, .reporting, .layout, .eval }, .ipc => &.{}, .repl => &.{ .base, .compile, .parse, .types, .can, .check, .builtins, .layout, .eval }, @@ -325,7 +325,7 @@ pub const RocModules = struct { const module = self.getModule(module_type); const module_filters = extendWithAggregatorFilters(b, test_filters, module_type); const test_step = b.addTest(.{ - .name = b.fmt("{s}_test", .{@tagName(module_type)}), + .name = b.fmt("{s}", .{@tagName(module_type)}), .root_module = b.createModule(.{ .root_source_file = module.root_source_file.?, .target = target, diff --git a/src/build/roc/Bool.roc b/src/build/roc/Bool.roc new file mode 100644 index 0000000000..fea74ce5fa --- /dev/null +++ b/src/build/roc/Bool.roc @@ -0,0 +1 @@ +Bool := [True, False].{} diff --git a/src/build/roc/Dict.roc b/src/build/roc/Dict.roc new file mode 100644 index 0000000000..b453b2027b --- /dev/null +++ b/src/build/roc/Dict.roc @@ -0,0 +1 @@ +Dict := [EmptyDict].{} diff --git a/src/build/roc/Result.roc b/src/build/roc/Result.roc new file mode 100644 index 0000000000..f2a788799f --- /dev/null +++ b/src/build/roc/Result.roc @@ -0,0 +1 @@ +Result(ok, err) := [Ok(ok), Err(err)].{} diff --git a/src/build/roc/Set.roc b/src/build/roc/Set.roc new file mode 100644 index 0000000000..662078af66 --- /dev/null +++ b/src/build/roc/Set.roc @@ -0,0 +1,3 @@ +import Dict + +Set := [EmptySet(Dict)].{} diff --git a/src/canonicalize/CIR.zig b/src/canonicalize/CIR.zig index 2daa535cc9..bb7605e228 100644 --- a/src/canonicalize/CIR.zig +++ b/src/canonicalize/CIR.zig @@ -274,19 +274,235 @@ pub const PatternRecordField = struct { pub const Span = struct { start: u32, len: u32 }; }; +/// Represents an arbitrary precision smallish decimal value +pub const SmallDecValue = struct { + numerator: i16, + denominator_power_of_ten: u8, + + /// Convert a small dec to f64 (use for size comparisons) + /// TODO: Review, claude generated + pub fn toF64(self: @This()) f64 { + const numerator_f64 = @as(f64, @floatFromInt(self.numerator)); + const divisor = std.math.pow(f64, 10, @as(f64, @floatFromInt(self.denominator_power_of_ten))); + return numerator_f64 / divisor; + } + + /// Calculate the int requirements of a SmallDecValue + pub fn toFracRequirements(self: SmallDecValue) types_mod.Num.FracRequirements { + const f64_val = self.toF64(); + return types_mod.Num.FracRequirements{ + .fits_in_f32 = fitsInF32(f64_val), + .fits_in_dec = fitsInDec(f64_val), + }; + } + + test "SmallDecValue.toF64 - basic cases" { + // Test integer values + { + const val = SmallDecValue{ .numerator = 42, .denominator_power_of_ten = 0 }; + try std.testing.expectEqual(@as(f64, 42.0), val.toF64()); + } + + // Test decimal values + { + const val = SmallDecValue{ .numerator = 314, .denominator_power_of_ten = 2 }; + try std.testing.expectApproxEqAbs(@as(f64, 3.14), val.toF64(), 0.0001); + } + + // Test negative values + { + const val = SmallDecValue{ .numerator = -500, .denominator_power_of_ten = 3 }; + try std.testing.expectApproxEqAbs(@as(f64, -0.5), val.toF64(), 0.0001); + } + + // Test very small values + { + const val = SmallDecValue{ .numerator = 1, .denominator_power_of_ten = 10 }; + try std.testing.expectApproxEqAbs(@as(f64, 1e-10), val.toF64(), 1e-15); + } + + // Test maximum numerator + { + const val = SmallDecValue{ .numerator = 32767, .denominator_power_of_ten = 0 }; + try std.testing.expectEqual(@as(f64, 32767.0), val.toF64()); + } + + // Test minimum numerator + { + const val = SmallDecValue{ .numerator = -32768, .denominator_power_of_ten = 0 }; + try std.testing.expectEqual(@as(f64, -32768.0), val.toF64()); + } + } + + test "SmallDecValue.toFracRequirements - fits in all types" { + // Small integer - fits in everything + { + const val = SmallDecValue{ .numerator = 100, .denominator_power_of_ten = 0 }; + const req = val.toFracRequirements(); + try std.testing.expect(req.fits_in_f32); + try std.testing.expect(req.fits_in_dec); + } + + // Pi approximation - fits in everything + { + const val = SmallDecValue{ .numerator = 31416, .denominator_power_of_ten = 4 }; + const req = val.toFracRequirements(); + try std.testing.expect(req.fits_in_f32); + try std.testing.expect(req.fits_in_dec); + } + } +}; + +/// Check if the given f64 fits in f32 range (ignoring precision loss) +pub fn fitsInF32(f64_val: f64) bool { + // Check if it's within the range that f32 can represent. + // This includes normal, subnormal, and zero values. + // (This is a magnitude check, so take the abs value to check + // positive and negative at the same time.) + const abs_val = @abs(f64_val); + return abs_val == 0.0 or (abs_val >= std.math.floatTrueMin(f32) and abs_val <= std.math.floatMax(f32)); +} + +/// Check if a float value can be represented accurately in RocDec +pub fn fitsInDec(value: f64) bool { + // RocDec uses i128 with 18 decimal places + const max_dec_value = 170141183460469231731.0; + const min_dec_value = -170141183460469231731.0; + + return value >= min_dec_value and value <= max_dec_value; +} + /// Represents an arbitrary precision integer value pub const IntValue = struct { bytes: [16]u8, - kind: enum { - i64, - u64, + kind: IntKind, + + pub const IntKind = enum { i128, u128, - }, + }; pub fn toI128(self: IntValue) i128 { return @bitCast(self.bytes); } + + pub fn bufPrint(self: IntValue, buf: []u8) ![]u8 { + switch (self.kind) { + .i128 => { + const val: i128 = @bitCast(self.bytes); + return std.fmt.bufPrint(buf, "{d}", .{val}); + }, + .u128 => { + const val: u128 = @bitCast(self.bytes); + return std.fmt.bufPrint(buf, "{d}", .{val}); + }, + } + } + + /// Calculate the int requirements of an IntValue + /// TODO: Review, claude generated + pub fn toIntRequirements(self: IntValue) types_mod.Num.IntRequirements { + var is_negated = false; + var u128_val: u128 = undefined; + + switch (self.kind) { + .i128 => { + const val: i128 = @bitCast(self.bytes); + is_negated = val < 0; + u128_val = if (val < 0) @abs(val) else @intCast(val); + }, + .u128 => { + const val: u128 = @bitCast(self.bytes); + is_negated = false; + u128_val = val; + }, + } + + // Special handling for minimum signed values + // These are the exact minimum values for each signed integer type. + // They need special handling because their absolute value is one more + // than the maximum positive value of the same signed type. + // For example: i8 range is -128 to 127, so abs(-128) = 128 doesn't fit in i8's positive range + const is_minimum_signed = is_negated and switch (u128_val) { + @as(u128, @intCast(std.math.maxInt(i8))) + 1 => true, + @as(u128, @intCast(std.math.maxInt(i16))) + 1 => true, + @as(u128, @intCast(std.math.maxInt(i32))) + 1 => true, + @as(u128, @intCast(std.math.maxInt(i64))) + 1 => true, + @as(u128, @intCast(std.math.maxInt(i128))) + 1 => true, + else => false, + }; + + // For minimum signed values, subtract 1 from the magnitude + // This makes the bit calculation work correctly with the "n-1 bits for magnitude" rule + const adjusted_val = if (is_minimum_signed) u128_val - 1 else u128_val; + const bits_needed = types_mod.Num.Int.BitsNeeded.fromValue(adjusted_val); + return types_mod.Num.IntRequirements{ + .sign_needed = is_negated and u128_val != 0, // -0 doesn't need a sign + .bits_needed = bits_needed.toBits(), + .is_minimum_signed = is_minimum_signed, + }; + } + + /// Calculate the frac requirements of an IntValue + /// TODO: Review, claude generated + /// Calculate the frac requirements of an IntValue + pub fn toFracRequirements(self: IntValue) types_mod.Num.FracRequirements { + // Convert to f64 for checking + const f64_val: f64 = switch (self.kind) { + .i128 => @floatFromInt(@as(i128, @bitCast(self.bytes))), + .u128 => blk: { + const val = @as(u128, @bitCast(self.bytes)); + if (val > @as(u128, 1) << 64) { + break :blk std.math.inf(f64); + } + break :blk @floatFromInt(val); + }, + }; + + // For integers, check both range AND exact representability in f32 + const fits_in_f32 = blk: { + // Check range + if (!fitsInF32(f64_val)) { + break :blk false; + } + + // Additionally check exact representability for integers + // F32 can exactly represent integers only up to 2^24 + const f32_max_exact_int = 16777216.0; // 2^24 + break :blk @abs(f64_val) <= f32_max_exact_int; + }; + + const fits_in_dec = fitsInDec(f64_val); + + return types_mod.Num.FracRequirements{ + .fits_in_f32 = fits_in_f32, + .fits_in_dec = fits_in_dec, + }; + } +}; + +/// Canonical information about a number +pub const NumKind = enum { + // If this number has no restrictions + num_unbound, + + // If this number is an int with no restrictions + int_unbound, + + // If the number has an explicit suffix + u8, + i8, + u16, + i16, + u32, + i32, + u64, + i64, + u128, + i128, + f32, + f64, + dec, }; // RocDec type definition (for missing export) @@ -375,7 +591,8 @@ pub const Import = struct { pub const Serialized = struct { // Placeholder to match Store size - not serialized - map: std.AutoHashMapUnmanaged(base.StringLiteral.Idx, Import.Idx) = .{}, + // Reserve space for hashmap (3 pointers for unmanaged hashmap internals) + map: [3]u64 = undefined, imports: collections.SafeList(base.StringLiteral.Idx).Serialized, /// Serialize a Store into this Serialized struct, appending data to the writer @@ -387,6 +604,10 @@ pub const Import = struct { ) std.mem.Allocator.Error!void { // Serialize the imports SafeList try self.imports.serialize(&store.imports, allocator, writer); + + // Set map to all zeros; the space needs to be here, + // but the map will be rebuilt during deserialization. + self.map = .{ 0, 0, 0 }; // Note: The map is not serialized as it's only used for deduplication during insertion } diff --git a/src/canonicalize/Can.zig b/src/canonicalize/Can.zig index 245c5b2781..8d99fa3e3c 100644 --- a/src/canonicalize/Can.zig +++ b/src/canonicalize/Can.zig @@ -59,7 +59,9 @@ const TypeVarProblem = struct { env: *ModuleEnv, parse_ir: *AST, -scopes: std.ArrayList(Scope) = .{}, +scopes: std.ArrayListUnmanaged(Scope) = .{}, +/// Special scope for rigid type variables in annotations +type_vars_scope: base.Scratch(TypeVarScope), /// Special scope for tracking exposed items from module header exposed_scope: Scope = undefined, /// Track exposed identifiers by text to handle changing indices @@ -69,7 +71,7 @@ exposed_type_texts: std.StringHashMapUnmanaged(Region) = .{}, /// Special scope for unqualified nominal tags (e.g., True, False) unqualified_nominal_tags: std.StringHashMapUnmanaged(Statement.Idx) = .{}, /// Stack of function regions for tracking var reassignment across function boundaries -function_regions: std.ArrayList(Region), +function_regions: std.array_list.Managed(Region), /// Maps var patterns to the function region they were declared in var_function_regions: std.AutoHashMapUnmanaged(Pattern.Idx, Region), /// Set of pattern indices that are vars @@ -77,7 +79,7 @@ var_patterns: std.AutoHashMapUnmanaged(Pattern.Idx, void), /// Tracks which pattern indices have been used/referenced used_patterns: std.AutoHashMapUnmanaged(Pattern.Idx, void), /// Map of module name strings to their ModuleEnv pointers for import validation -module_envs: ?*const std.StringHashMap(*ModuleEnv), +module_envs: ?*const std.StringHashMap(*const ModuleEnv), /// Map from module name string to Import.Idx for tracking unique imports import_indices: std.StringHashMapUnmanaged(Import.Idx), /// Scratch type variables @@ -105,6 +107,7 @@ const CalledVia = base.CalledVia; const TypeVar = types.Var; const Content = types.Content; +const Flex = types.Flex; const FlatType = types.FlatType; const Num = types.Num; @@ -130,32 +133,9 @@ const RecordField = CIR.RecordField; const SeenRecordField = struct { ident: base.Ident.Idx, region: base.Region }; /// The idx of the builtin Bool -/// The idx of the builtin Bool pattern (not used for type checking - use BUILTIN_BOOL_TYPE instead) -pub const BUILTIN_BOOL: Pattern.Idx = @enumFromInt(0); -/// The idx of the builtin Bool type declaration (use this for type checking) -pub var BUILTIN_BOOL_TYPE: Statement.Idx = undefined; -/// The idx of the builtin Box -pub const BUILTIN_BOX: Pattern.Idx = @enumFromInt(1); -/// The idx of the builtin Decode -pub const BUILTIN_DECODE: Pattern.Idx = @enumFromInt(2); -/// The idx of the builtin Dict -pub const BUILTIN_DICT: Pattern.Idx = @enumFromInt(3); -/// The idx of the builtin Encode -pub const BUILTIN_ENCODE: Pattern.Idx = @enumFromInt(4); -/// The idx of the builtin Hash -pub const BUILTIN_HASH: Pattern.Idx = @enumFromInt(5); -/// The idx of the builtin Inspect -pub const BUILTIN_INSPECT: Pattern.Idx = @enumFromInt(6); -/// The idx of the builtin List -pub const BUILTIN_LIST: Pattern.Idx = @enumFromInt(7); -/// The idx of the builtin Num -pub const BUILTIN_NUM: Pattern.Idx = @enumFromInt(8); +pub const BUILTIN_BOOL: Statement.Idx = @enumFromInt(2); /// The idx of the builtin Result -pub const BUILTIN_RESULT: Pattern.Idx = @enumFromInt(9); -/// The idx of the builtin Set -pub const BUILTIN_SET: Pattern.Idx = @enumFromInt(10); -/// The idx of the builtin Str -pub const BUILTIN_STR: Pattern.Idx = @enumFromInt(11); +pub const BUILTIN_RESULT: Statement.Idx = @enumFromInt(13); /// Deinitialize canonicalizer resources pub fn deinit( @@ -163,6 +143,7 @@ pub fn deinit( ) void { const gpa = self.env.gpa; + self.type_vars_scope.deinit(gpa); self.exposed_scope.deinit(gpa); self.exposed_ident_texts.deinit(gpa); self.exposed_type_texts.deinit(gpa); @@ -190,7 +171,23 @@ pub fn deinit( self.scratch_free_vars.deinit(gpa); } -pub fn init(env: *ModuleEnv, parse_ir: *AST, module_envs: ?*const std.StringHashMap(*ModuleEnv)) std.mem.Allocator.Error!Self { +/// Options for initializing the canonicalizer. +/// Controls which built-in types are injected into the module's scope. +pub const InitOptions = struct { + /// Whether to inject the Bool type declaration (`Bool := [True, False]`). + /// Set to false when compiling Bool.roc itself to avoid duplication. + inject_bool: bool = true, + /// Whether to inject the Result type declaration (`Result(ok, err) := [Ok(ok), Err(err)]`). + /// Set to false when compiling Result.roc itself (if it exists). + inject_result: bool = true, +}; + +pub fn init( + env: *ModuleEnv, + parse_ir: *AST, + module_envs: ?*const std.StringHashMap(*const ModuleEnv), + options: InitOptions, +) std.mem.Allocator.Error!Self { const gpa = env.gpa; // Create the canonicalizer with scopes @@ -198,7 +195,7 @@ pub fn init(env: *ModuleEnv, parse_ir: *AST, module_envs: ?*const std.StringHash .env = env, .parse_ir = parse_ir, .scopes = .{}, - .function_regions = std.ArrayList(Region){}, + .function_regions = std.array_list.Managed(Region){}, .var_function_regions = std.AutoHashMapUnmanaged(Pattern.Idx, Region){}, .var_patterns = std.AutoHashMapUnmanaged(Pattern.Idx, void){}, .used_patterns = std.AutoHashMapUnmanaged(Pattern.Idx, void){}, @@ -210,6 +207,7 @@ pub fn init(env: *ModuleEnv, parse_ir: *AST, module_envs: ?*const std.StringHash .scratch_type_var_problems = try base.Scratch(TypeVarProblem).init(gpa), .scratch_record_fields = try base.Scratch(types.RecordField).init(gpa), .scratch_seen_record_fields = try base.Scratch(SeenRecordField).init(gpa), + .type_vars_scope = try base.Scratch(TypeVarScope).init(gpa), .exposed_scope = Scope.init(false), .scratch_tags = try base.Scratch(types.Tag).init(gpa), .unqualified_nominal_tags = std.StringHashMapUnmanaged(Statement.Idx){}, @@ -219,318 +217,189 @@ pub fn init(env: *ModuleEnv, parse_ir: *AST, module_envs: ?*const std.StringHash // Top-level scope is not a function boundary try result.scopeEnter(gpa, false); - // Simulate the builtins by adding to both the NodeStore and Scopes - // Not sure if this is how we want to do it long term, but want something to - // make a start on canonicalization. + const scratch_statements_start = result.env.store.scratch.?.statements.top(); + + // Inject built-in type declarations that aren't defined in this module's source + // TODO: These should ultimately come from the platform/builtin files rather than being hardcoded + if (options.inject_bool) { + const bool_idx = try result.addBuiltinTypeBool(env); + try result.env.store.addScratchStatement(bool_idx); + } + if (options.inject_result) { + const result_idx = try result.addBuiltinTypeResult(env); + try result.env.store.addScratchStatement(result_idx); + } + + result.env.builtin_statements = try result.env.store.statementSpanFrom(scratch_statements_start); + + // Debug assertion: When Bool is injected, it must be the first builtin statement + if (std.debug.runtime_safety and options.inject_bool) { + const builtin_stmts = result.env.store.sliceStatements(result.env.builtin_statements); + std.debug.assert(builtin_stmts.len >= 1); // Must have at least Bool + // Verify first builtin is Bool by checking it's a nominal_decl + const first_stmt = result.env.store.getStatement(builtin_stmts[0]); + std.debug.assert(first_stmt == .s_nominal_decl); + } // Assert that the node store is completely empty env.debugAssertArraysInSync(); - // Add builtinss (eventually will be gotten from builtins roc files) - try result.addBuiltin(env, "Bool", BUILTIN_BOOL); - try result.addBuiltin(env, "Box", BUILTIN_BOX); - try result.addBuiltin(env, "Decode", BUILTIN_DECODE); - try result.addBuiltin(env, "Dict", BUILTIN_DICT); - try result.addBuiltin(env, "Encode", BUILTIN_ENCODE); - try result.addBuiltin(env, "Hash", BUILTIN_HASH); - try result.addBuiltin(env, "Inspect", BUILTIN_INSPECT); - try result.addBuiltin(env, "List", BUILTIN_LIST); - try result.addBuiltin(env, "Num", BUILTIN_NUM); - try result.addBuiltin(env, "Result", BUILTIN_RESULT); - try result.addBuiltin(env, "Set", BUILTIN_SET); - try result.addBuiltin(env, "Str", BUILTIN_STR); - - // Assert that the node store has the 12 builtin types - env.debugAssertArraysInSync(); - - // Add built-in types to the type scope - // TODO: These should ultimately come from the platform/builtin files rather than being hardcoded - try result.addBuiltinTypeBool(env); - try result.addBuiltinTypeList(env); - try result.addBuiltinTypeBox(env); - try result.addBuiltinTypeResult(env); - - _ = try result.addBuiltinType(env, "Str", .{ .structure = .str }); - _ = try result.addBuiltinType(env, "U8", .{ .structure = .{ .num = types.Num.int_u8 } }); - _ = try result.addBuiltinType(env, "U16", .{ .structure = .{ .num = types.Num.int_u16 } }); - _ = try result.addBuiltinType(env, "U32", .{ .structure = .{ .num = types.Num.int_u32 } }); - _ = try result.addBuiltinType(env, "U64", .{ .structure = .{ .num = types.Num.int_u64 } }); - _ = try result.addBuiltinType(env, "U128", .{ .structure = .{ .num = types.Num.int_u128 } }); - _ = try result.addBuiltinType(env, "I8", .{ .structure = .{ .num = types.Num.int_i8 } }); - _ = try result.addBuiltinType(env, "I16", .{ .structure = .{ .num = types.Num.int_i16 } }); - _ = try result.addBuiltinType(env, "I32", .{ .structure = .{ .num = types.Num.int_i32 } }); - _ = try result.addBuiltinType(env, "I64", .{ .structure = .{ .num = types.Num.int_i64 } }); - _ = try result.addBuiltinType(env, "I128", .{ .structure = .{ .num = types.Num.int_i128 } }); - _ = try result.addBuiltinType(env, "F32", .{ .structure = .{ .num = types.Num.frac_f32 } }); - _ = try result.addBuiltinType(env, "F64", .{ .structure = .{ .num = types.Num.frac_f64 } }); - _ = try result.addBuiltinType(env, "Dec", .{ .structure = .{ .num = types.Num.frac_dec } }); - _ = try result.addBuiltinType(env, "Dict", .{ .flex_var = null }); - _ = try result.addBuiltinType(env, "Set", .{ .flex_var = null }); - return result; } // builtins // -fn addBuiltin(self: *Self, ir: *ModuleEnv, ident_text: []const u8, idx: Pattern.Idx) std.mem.Allocator.Error!void { - const gpa = ir.gpa; - const ident_add = try ir.insertIdent(base.Ident.for_text(ident_text)); - const pattern_idx_add = try ir.addPatternAndTypeVar(Pattern{ .assign = .{ .ident = ident_add } }, Content{ .flex_var = null }, Region.zero()); - _ = try self.scopeIntroduceInternal(gpa, .ident, ident_add, pattern_idx_add, false, true); - std.debug.assert(idx == pattern_idx_add); -} - -/// Stub builtin types. Currently sets every type to be a nominal type -/// This should be replaced by real builtins eventually -fn addBuiltinType(self: *Self, ir: *ModuleEnv, type_name: []const u8, content: types.Content) std.mem.Allocator.Error!Statement.Idx { - const gpa = ir.gpa; - const type_ident = try ir.insertIdent(base.Ident.for_text(type_name)); - - // Create a type header for the built-in type - const header_idx = try ir.addTypeHeaderAndTypeVar(.{ - .name = type_ident, - .args = .{ .span = .{ .start = 0, .len = 0 } }, // No type parameters for built-ins - }, .{ .flex_var = null }, Region.zero()); - - // Create a type annotation that refers to itself (built-in types are primitive) - const anno_idx = try ir.addTypeAnnoAndTypeVar(.{ .ty = .{ - .symbol = type_ident, - } }, content, Region.zero()); - const anno_var = ModuleEnv.castIdx(TypeAnno.Idx, TypeVar, anno_idx); - - // Create the type declaration statement - const type_decl_stmt = Statement{ - .s_nominal_decl = .{ .header = header_idx, .anno = anno_idx }, - }; - - const type_decl_idx = try ir.addStatementAndTypeVar( - type_decl_stmt, - try ir.types.mkAlias(types.TypeIdent{ .ident_idx = type_ident }, anno_var, &.{}), - Region.zero(), - ); - - // Add to scope without any error checking (built-ins are always valid) - const current_scope = &self.scopes.items[self.scopes.items.len - 1]; - try current_scope.put(gpa, .type_decl, type_ident, type_decl_idx); - - return type_decl_idx; -} - -/// Creates `Result(ok, err) := [Ok(ok), Err(err)]` -fn addBuiltinTypeResult(self: *Self, ir: *ModuleEnv) std.mem.Allocator.Error!void { - const gpa = ir.gpa; - const type_ident = try ir.insertIdent(base.Ident.for_text("Result")); - const a_ident = try ir.insertIdent(base.Ident.for_text("ok")); - const b_ident = try ir.insertIdent(base.Ident.for_text("err")); - - // Create a type header for the built-in type - const header_idx = try ir.addTypeHeaderAndTypeVar(.{ - .name = type_ident, - .args = .{ .span = .{ .start = 0, .len = 0 } }, // No type parameters for built-ins - }, .{ .flex_var = null }, Region.zero()); - const header_node_idx = ModuleEnv.nodeIdxFrom(header_idx); - - // Create a type annotation that refers to itself (built-in types are primitive) - const ext_var = try ir.addTypeSlotAndTypeVar( - header_node_idx, - Content{ .structure = .empty_tag_union }, - Region.zero(), - TypeVar, - ); - const a_rigid = try ir.addTypeSlotAndTypeVar( - header_node_idx, - .{ .rigid_var = a_ident }, - Region.zero(), - TypeVar, - ); - const b_rigid = try ir.addTypeSlotAndTypeVar( - header_node_idx, - .{ .rigid_var = b_ident }, - Region.zero(), - TypeVar, - ); - const anno_idx = try ir.addTypeAnnoAndTypeVar( - .{ .ty = .{ .symbol = type_ident } }, - try ir.types.mkResult(gpa, ir.getIdentStore(), a_rigid, b_rigid, ext_var), - Region.zero(), - ); - const anno_var = ModuleEnv.castIdx(TypeAnno.Idx, TypeVar, anno_idx); - - // Create the type declaration statement - const type_decl_stmt = Statement{ - .s_nominal_decl = .{ .header = header_idx, .anno = anno_idx }, - }; - - const type_decl_idx = try ir.addStatementAndTypeVar( - type_decl_stmt, - try ir.types.mkNominal( - types.TypeIdent{ .ident_idx = type_ident }, - anno_var, - &.{ a_rigid, b_rigid }, - try ir.insertIdent(base.Ident.for_text(ir.module_name)), - ), - Region.zero(), - ); - - // Add to scope without any error checking (built-ins are always valid) - const current_scope = &self.scopes.items[self.scopes.items.len - 1]; - try current_scope.put(gpa, .type_decl, type_ident, type_decl_idx); - - try ir.redirectTypeTo(Pattern.Idx, BUILTIN_RESULT, ModuleEnv.varFrom(type_decl_idx)); - - // Add True and False to unqualified_nominal_tags - // TODO: in the future, we should have hardcoded constants for these. - try self.unqualified_nominal_tags.put(gpa, "Ok", type_decl_idx); - try self.unqualified_nominal_tags.put(gpa, "Err", type_decl_idx); -} - -/// Creates `List(a) : (a)` -fn addBuiltinTypeList(self: *Self, ir: *ModuleEnv) std.mem.Allocator.Error!void { - const gpa = ir.gpa; - const type_ident = try ir.insertIdent(base.Ident.for_text("List")); - const elem_ident = try ir.insertIdent(base.Ident.for_text("item")); - - // Create a type header for the built-in type - const header_idx = try ir.addTypeHeaderAndTypeVar(.{ - .name = type_ident, - .args = .{ .span = .{ .start = 0, .len = 0 } }, // No type parameters for built-ins - }, .{ .flex_var = null }, Region.zero()); - const header_node_idx = ModuleEnv.nodeIdxFrom(header_idx); - - // Create a type annotation that refers to itself (built-in types are primitive) - const elem_var = try ir.addTypeSlotAndTypeVar( - header_node_idx, - Content{ .rigid_var = elem_ident }, - Region.zero(), - TypeVar, - ); - const anno_idx = try ir.addTypeAnnoAndTypeVar(.{ .ty = .{ - .symbol = type_ident, - } }, .{ .structure = .{ .list = elem_var } }, Region.zero()); - const anno_var = ModuleEnv.castIdx(TypeAnno.Idx, TypeVar, anno_idx); - - // Create the type declaration statement - const type_decl_stmt = Statement{ - .s_alias_decl = .{ .header = header_idx, .anno = anno_idx }, - }; - - const type_decl_idx = try ir.addStatementAndTypeVar( - type_decl_stmt, - try ir.types.mkAlias( - types.TypeIdent{ .ident_idx = type_ident }, - anno_var, - &.{elem_var}, - ), - Region.zero(), - ); - - // Add to scope without any error checking (built-ins are always valid) - const current_scope = &self.scopes.items[self.scopes.items.len - 1]; - try current_scope.put(gpa, .type_decl, type_ident, type_decl_idx); - - try ir.redirectTypeTo(Pattern.Idx, BUILTIN_LIST, ModuleEnv.varFrom(type_decl_idx)); -} - -/// Creates `Box(a) : (a)` -fn addBuiltinTypeBox(self: *Self, ir: *ModuleEnv) std.mem.Allocator.Error!void { - const gpa = ir.gpa; - const type_ident = try ir.insertIdent(base.Ident.for_text("Box")); - const elem_ident = try ir.insertIdent(base.Ident.for_text("item")); - - // Create a type header for the built-in type - const header_idx = try ir.addTypeHeaderAndTypeVar(.{ - .name = type_ident, - .args = .{ .span = .{ .start = 0, .len = 0 } }, // No type parameters for built-ins - }, .{ .flex_var = null }, Region.zero()); - const header_node_idx = ModuleEnv.nodeIdxFrom(header_idx); - - // Create a type annotation that refers to itself (built-in types are primitive) - const elem_var = try ir.addTypeSlotAndTypeVar( - header_node_idx, - Content{ .rigid_var = elem_ident }, - Region.zero(), - TypeVar, - ); - const anno_idx = try ir.addTypeAnnoAndTypeVar(.{ .ty = .{ - .symbol = type_ident, - } }, .{ .structure = .{ .box = elem_var } }, Region.zero()); - const anno_var = ModuleEnv.castIdx(TypeAnno.Idx, TypeVar, anno_idx); - - // Create the type declaration statement - const type_decl_stmt = Statement{ - .s_alias_decl = .{ .header = header_idx, .anno = anno_idx }, - }; - - const type_decl_idx = try ir.addStatementAndTypeVar( - type_decl_stmt, - try ir.types.mkAlias( - types.TypeIdent{ .ident_idx = type_ident }, - anno_var, - &.{elem_var}, - ), - Region.zero(), - ); - - // Add to scope without any error checking (built-ins are always valid) - const current_scope = &self.scopes.items[self.scopes.items.len - 1]; - try current_scope.put(gpa, .type_decl, type_ident, type_decl_idx); - - try ir.redirectTypeTo(Pattern.Idx, BUILTIN_BOX, ModuleEnv.varFrom(type_decl_idx)); -} - /// Creates `Bool := [True, False]` -fn addBuiltinTypeBool(self: *Self, ir: *ModuleEnv) std.mem.Allocator.Error!void { +/// Returns the statement index where Bool was created +fn addBuiltinTypeBool(self: *Self, ir: *ModuleEnv) std.mem.Allocator.Error!Statement.Idx { const gpa = ir.gpa; const type_ident = try ir.insertIdent(base.Ident.for_text("Bool")); + const true_ident = try ir.insertIdent(base.Ident.for_text("True")); + const false_ident = try ir.insertIdent(base.Ident.for_text("False")); + + // Create a type header (lhs) => Bool // - // Create a type header for the built-in type const header_idx = try ir.addTypeHeaderAndTypeVar(.{ .name = type_ident, - .args = .{ .span = .{ .start = 0, .len = 0 } }, // No type parameters for built-ins - }, .{ .flex_var = null }, Region.zero()); - const header_node_idx = ModuleEnv.nodeIdxFrom(header_idx); + .args = .{ .span = DataSpan.empty() }, + }, .err, Region.zero()); - // Create a type annotation that refers to itself (built-in types are primitive) - const ext_var = try ir.addTypeSlotAndTypeVar( - header_node_idx, - Content{ .structure = .empty_tag_union }, - Region.zero(), - TypeVar, - ); - const anno_idx = try ir.addTypeAnnoAndTypeVar(.{ .ty = .{ - .symbol = type_ident, - } }, try ir.types.mkBool(gpa, ir.getIdentStore(), ext_var), Region.zero()); - const anno_var = ModuleEnv.castIdx(TypeAnno.Idx, TypeVar, anno_idx); + // Create the type body (rhs) => [True, False] // - // Create the type declaration statement - const type_decl_stmt = Statement{ - .s_nominal_decl = .{ .header = header_idx, .anno = anno_idx }, - }; + const scratch_top = self.env.store.scratchTypeAnnoTop(); - const type_decl_idx = try ir.addStatementAndTypeVar( - type_decl_stmt, - try ir.types.mkNominal( - types.TypeIdent{ .ident_idx = type_ident }, - anno_var, - &.{}, - try ir.insertIdent(base.Ident.for_text(ir.module_name)), - ), + const true_tag_anno_idx = try ir.addTypeAnnoAndTypeVar( + .{ .tag = .{ .name = true_ident, .args = .{ .span = DataSpan.empty() } } }, + .err, Region.zero(), ); + try self.env.store.addScratchTypeAnno(true_tag_anno_idx); - // Expose the bool type declaration idx for downstream consumers that rely on it. - BUILTIN_BOOL_TYPE = type_decl_idx; + const false_tag_anno_idx = try ir.addTypeAnnoAndTypeVar( + .{ .tag = .{ .name = false_ident, .args = .{ .span = DataSpan.empty() } } }, + .err, + Region.zero(), + ); + try self.env.store.addScratchTypeAnno(false_tag_anno_idx); - // Add to scope without any error checking (built-ins are always valid) + const tag_union_anno_idx = try ir.addTypeAnnoAndTypeVar(.{ .tag_union = .{ + .tags = try self.env.store.typeAnnoSpanFrom(scratch_top), + .ext = null, + } }, .err, Region.zero()); + + // Create the type declaration statement // + + const type_decl_idx = try ir.addStatementAndTypeVar(Statement{ + .s_nominal_decl = .{ .header = header_idx, .anno = tag_union_anno_idx }, + }, .err, Region.zero()); + + // Note: When Bool.roc is compiled without injecting builtins, Bool is at absolute index 2 (BUILTIN_BOOL). + // This is verified at build time by the builtin_compiler. + // When builtins are injected into other modules, Bool is always the FIRST builtin (builtin_statements[0]), + // though its absolute statement index may differ from BUILTIN_BOOL. + + // Introduce to scope const current_scope = &self.scopes.items[self.scopes.items.len - 1]; try current_scope.put(gpa, .type_decl, type_ident, type_decl_idx); - try ir.redirectTypeTo(Pattern.Idx, BUILTIN_BOOL, ModuleEnv.varFrom(type_decl_idx)); - // Add True and False to unqualified_nominal_tags // TODO: in the future, we should have hardcoded constants for these. try self.unqualified_nominal_tags.put(gpa, "True", type_decl_idx); try self.unqualified_nominal_tags.put(gpa, "False", type_decl_idx); + + return type_decl_idx; +} + +/// Creates `Result(ok, err) := [Ok(ok), Err(err)]` +/// Returns the statement index where Result was created +fn addBuiltinTypeResult(self: *Self, ir: *ModuleEnv) std.mem.Allocator.Error!Statement.Idx { + const gpa = ir.gpa; + const type_ident = try ir.insertIdent(base.Ident.for_text("Result")); + const ok_tag_ident = try ir.insertIdent(base.Ident.for_text("Ok")); + const err_tag_ident = try ir.insertIdent(base.Ident.for_text("Err")); + const ok_var_ident = try ir.insertIdent(base.Ident.for_text("ok")); + const err_var_ident = try ir.insertIdent(base.Ident.for_text("err")); + + // Create a type header (lhs) => Result(ok, err) // + + const header_scratch_top = self.env.store.scratchTypeAnnoTop(); + + const ok_rigid_var = try ir.addTypeAnnoAndTypeVar(.{ .rigid_var = .{ .name = ok_var_ident } }, .err, Region.zero()); + try self.env.store.addScratchTypeAnno(ok_rigid_var); + + const err_rigid_var = try ir.addTypeAnnoAndTypeVar(.{ .rigid_var = .{ .name = err_var_ident } }, .err, Region.zero()); + try self.env.store.addScratchTypeAnno(err_rigid_var); + + const header_idx = try ir.addTypeHeaderAndTypeVar(.{ + .name = type_ident, + .args = try self.env.store.typeAnnoSpanFrom(header_scratch_top), + }, .err, Region.zero()); + + // Create the type body (rhs) => [Ok(ok), Err(err)] // + + // Create Ok(ok) + const ok_tag_scratch_top = self.env.store.scratchTypeAnnoTop(); + + const ok_rigid_var_arg = try ir.addTypeAnnoAndTypeVar(.{ .rigid_var_lookup = .{ .ref = ok_rigid_var } }, .err, Region.zero()); + try self.env.store.addScratchTypeAnno(ok_rigid_var_arg); + + const ok_tag_anno_idx = try ir.addTypeAnnoAndTypeVar( + .{ .tag = .{ + .name = ok_tag_ident, + .args = try self.env.store.typeAnnoSpanFrom(ok_tag_scratch_top), + } }, + .err, + Region.zero(), + ); + + // Create Err(err) + const err_tag_scratch_top = self.env.store.scratchTypeAnnoTop(); + + const err_rigid_var_arg = try ir.addTypeAnnoAndTypeVar(.{ .rigid_var_lookup = .{ .ref = err_rigid_var } }, .err, Region.zero()); + try self.env.store.addScratchTypeAnno(err_rigid_var_arg); + + const err_tag_anno_idx = try ir.addTypeAnnoAndTypeVar( + .{ .tag = .{ + .name = err_tag_ident, + .args = try self.env.store.typeAnnoSpanFrom(err_tag_scratch_top), + } }, + .err, + Region.zero(), + ); + + // Create tag union + const tag_scratch_top = self.env.store.scratchTypeAnnoTop(); + try self.env.store.addScratchTypeAnno(ok_tag_anno_idx); + try self.env.store.addScratchTypeAnno(err_tag_anno_idx); + + const tag_union_anno_idx = try ir.addTypeAnnoAndTypeVar(.{ .tag_union = .{ + .tags = try self.env.store.typeAnnoSpanFrom(tag_scratch_top), + .ext = null, + } }, .err, Region.zero()); + + // Create the type declaration statement // + + const type_decl_idx = try ir.addStatementAndTypeVar( + Statement{ + .s_nominal_decl = .{ .header = header_idx, .anno = tag_union_anno_idx }, + }, + .err, + Region.zero(), + ); + + // Note: When Result.roc is compiled without injecting builtins, Result ends up at index 13 (BUILTIN_RESULT) + // This is verified during build time. + // When builtins are injected into other modules (Dict, Set), Result can be at any index. + + // Add to scope + const current_scope = &self.scopes.items[self.scopes.items.len - 1]; + try current_scope.put(gpa, .type_decl, type_ident, type_decl_idx); + + // Add Ok and Err to unqualified_nominal_tags + try self.unqualified_nominal_tags.put(gpa, "Ok", type_decl_idx); + try self.unqualified_nominal_tags.put(gpa, "Err", type_decl_idx); + + return type_decl_idx; } // canonicalize // @@ -553,6 +422,469 @@ const Self = @This(); /// - Eliminates syntax sugar (for example, renaming `+` to the function call `add`). /// /// The canonicalization occurs on a single module (file) in isolation. This allows for this work to be easily parallelized and also cached. So where the source code for a module has not changed, the CanIR can simply be loaded from disk and used immediately. +/// First pass helper: Process a type declaration and introduce it into scope +/// If parent_name is provided, creates a qualified name (e.g., "Foo.Bar") +fn processTypeDeclFirstPass( + self: *Self, + type_decl: anytype, + parent_name: ?Ident.Idx, +) std.mem.Allocator.Error!void { + // Canonicalize the type declaration header first + const header_idx = try self.canonicalizeTypeHeader(type_decl.header); + const region = self.parse_ir.tokenizedRegionToRegion(type_decl.region); + + // Extract the type name from the header + const type_header = self.env.store.getTypeHeader(header_idx); + + // Build qualified name and header if we have a parent + const qualified_name_idx = if (parent_name) |parent_idx| blk: { + const parent_text = self.env.getIdent(parent_idx); + const type_text = self.env.getIdent(type_header.name); + const qualified_name_str = try std.fmt.allocPrint( + self.env.gpa, + "{s}.{s}", + .{ parent_text, type_text }, + ); + defer self.env.gpa.free(qualified_name_str); + + const qualified_ident = base.Ident.for_text(qualified_name_str); + break :blk try self.env.insertIdent(qualified_ident); + } else type_header.name; + + // Create a new header with the qualified name if needed + const final_header_idx = if (parent_name != null and qualified_name_idx.idx != type_header.name.idx) blk: { + const qualified_header = CIR.TypeHeader{ + .name = qualified_name_idx, + .args = type_header.args, + }; + break :blk try self.env.addTypeHeaderAndTypeVar(qualified_header, Content{ .flex = Flex.init() }, region); + } else header_idx; + + // Create a placeholder type declaration statement to introduce the type name into scope + // This allows recursive type references to work during annotation canonicalization + const placeholder_cir_type_decl = switch (type_decl.kind) { + .alias => Statement{ + .s_alias_decl = .{ + .header = final_header_idx, + .anno = @enumFromInt(0), // placeholder - will be replaced + }, + }, + .nominal => Statement{ + .s_nominal_decl = .{ + .header = final_header_idx, + .anno = @enumFromInt(0), // placeholder - will be replaced + }, + }, + }; + + const type_decl_stmt_idx = try self.env.addStatementAndTypeVar(placeholder_cir_type_decl, .err, region); + + // Introduce the type name into scope early to support recursive references + try self.scopeIntroduceTypeDecl(qualified_name_idx, type_decl_stmt_idx, region); + + // Process type parameters and annotation in a separate scope + const anno_idx = blk: { + // Enter a new scope for type parameters + const type_var_scope = self.scopeEnterTypeVar(); + defer self.scopeExitTypeVar(type_var_scope); + + // Introduce type parameters from the header into the scope + try self.introduceTypeParametersFromHeader(final_header_idx); + + // Now canonicalize the type annotation with type parameters and type name in scope + break :blk try self.canonicalizeTypeAnno(type_decl.anno, .type_decl_anno); + }; + + // Canonicalize where clauses if present + if (type_decl.where) |_| { + try self.env.pushDiagnostic(Diagnostic{ .where_clause_not_allowed_in_type_decl = .{ + .region = region, + } }); + } + + // Create the real CIR type declaration statement with the canonicalized annotation + const type_decl_stmt = blk: { + switch (type_decl.kind) { + .alias => { + break :blk Statement{ + .s_alias_decl = .{ + .header = final_header_idx, + .anno = anno_idx, + }, + }; + }, + .nominal => { + break :blk Statement{ + .s_nominal_decl = .{ + .header = final_header_idx, + .anno = anno_idx, + }, + }; + }, + } + }; + + // Create the real statement and add it to scratch statements + try self.env.store.setStatementNode(type_decl_stmt_idx, type_decl_stmt); + try self.env.store.addScratchStatement(type_decl_stmt_idx); + + // Remove from exposed_type_texts since the type is now fully defined + const type_text = self.env.getIdent(type_header.name); + _ = self.exposed_type_texts.remove(type_text); + + // Process associated items recursively in the first pass to introduce names + // Aliases are introduced in the current scope (not a nested scope) during first pass + // They will be available when we process the associated block in the second pass + if (type_decl.associated) |assoc| { + try self.processAssociatedItemsFirstPass(qualified_name_idx, assoc.statements); + } +} + +/// Canonicalize an associated item declaration with a qualified name +fn canonicalizeAssociatedDecl( + self: *Self, + decl: AST.Statement.Decl, + qualified_ident: Ident.Idx, +) std.mem.Allocator.Error!CIR.Def.Idx { + const trace = tracy.trace(@src()); + defer trace.end(); + + const pattern_region = self.parse_ir.tokenizedRegionToRegion(self.parse_ir.store.getPattern(decl.pattern).to_tokenized_region()); + + // Look up the placeholder pattern that was created in the first pass + const pattern_idx = blk: { + const lookup_result = self.scopeLookup(.ident, qualified_ident); + switch (lookup_result) { + .found => |pattern| break :blk pattern, + .not_found => unreachable, // Pattern should have been created in first pass + } + }; + + // Canonicalize the body expression + const can_expr = try self.canonicalizeExprOrMalformed(decl.body); + + // Create the def with no annotation (type annotations are handled via canonicalizeAssociatedDeclWithAnno) + const def = CIR.Def{ + .pattern = pattern_idx, + .expr = can_expr.idx, + .annotation = null, + .kind = .{ .let = {} }, + }; + + const def_idx = try self.env.addDefAndTypeVar(def, Content{ .flex = Flex.init() }, pattern_region); + return def_idx; +} + +/// Canonicalize an associated item declaration with a type annotation +fn canonicalizeAssociatedDeclWithAnno( + self: *Self, + decl: AST.Statement.Decl, + qualified_ident: Ident.Idx, + type_anno_idx: CIR.TypeAnno.Idx, +) std.mem.Allocator.Error!CIR.Def.Idx { + const trace = tracy.trace(@src()); + defer trace.end(); + + const pattern_region = self.parse_ir.tokenizedRegionToRegion(self.parse_ir.store.getPattern(decl.pattern).to_tokenized_region()); + + // Look up the placeholder pattern that was created in the first pass + const pattern_idx = blk: { + const lookup_result = self.scopeLookup(.ident, qualified_ident); + switch (lookup_result) { + .found => |pattern| break :blk pattern, + .not_found => unreachable, // Pattern should have been created in first pass + } + }; + + // Canonicalize the body expression + const can_expr = try self.canonicalizeExprOrMalformed(decl.body); + + // Create the annotation structure + const annotation = CIR.Annotation{ + .type_anno = type_anno_idx, + .signature = try self.env.addTypeSlotAndTypeVar(@enumFromInt(0), .err, pattern_region, TypeVar), + }; + const annotation_idx = try self.env.addAnnotationAndTypeVarRedirect(annotation, ModuleEnv.varFrom(type_anno_idx), pattern_region); + + // Create the def with the type annotation + const def = CIR.Def{ + .pattern = pattern_idx, + .expr = can_expr.idx, + .annotation = annotation_idx, + .kind = .{ .let = {} }, + }; + + const def_idx = try self.env.addDefAndTypeVar(def, Content{ .flex = Flex.init() }, pattern_region); + return def_idx; +} + +/// Second pass helper: Canonicalize associated item definitions +fn processAssociatedItemsSecondPass( + self: *Self, + parent_name: Ident.Idx, + statements: AST.Statement.Span, +) std.mem.Allocator.Error!void { + const stmt_idxs = self.parse_ir.store.statementSlice(statements); + var i: usize = 0; + while (i < stmt_idxs.len) : (i += 1) { + const stmt_idx = stmt_idxs[i]; + const stmt = self.parse_ir.store.getStatement(stmt_idx); + switch (stmt) { + .type_decl => |type_decl| { + // Recursively process nested type declarations + if (type_decl.associated) |assoc| { + const type_header = self.parse_ir.store.getTypeHeader(type_decl.header) catch continue; + const type_ident = self.parse_ir.tokens.resolveIdentifier(type_header.name) orelse continue; + + // Build qualified name for nested type + const parent_text = self.env.getIdent(parent_name); + const type_text = self.env.getIdent(type_ident); + const qualified_name_str = try std.fmt.allocPrint( + self.env.gpa, + "{s}.{s}", + .{ parent_text, type_text }, + ); + defer self.env.gpa.free(qualified_name_str); + const qualified_ident = base.Ident.for_text(qualified_name_str); + const qualified_idx = try self.env.insertIdent(qualified_ident); + + try self.processAssociatedItemsSecondPass(qualified_idx, assoc.statements); + } + }, + .type_anno => |ta| { + const region = self.parse_ir.tokenizedRegionToRegion(ta.region); + const name_ident = self.parse_ir.tokens.resolveIdentifier(ta.name) orelse { + // Malformed identifier - skip this annotation + continue; + }; + + // First, make the top of our scratch list + const type_vars_top: u32 = @intCast(self.scratch_idents.top()); + + // Extract type variables from the AST annotation + try self.extractTypeVarIdentsFromASTAnno(ta.anno, type_vars_top); + + // Enter a new type var scope + const type_var_scope = self.scopeEnterTypeVar(); + defer self.scopeExitTypeVar(type_var_scope); + std.debug.assert(type_var_scope.idx == 0); + + // Now canonicalize the annotation with type variables in scope + const type_anno_idx = try self.canonicalizeTypeAnno(ta.anno, .inline_anno); + + // Canonicalize where clauses if present + const where_clauses = if (ta.where) |where_coll| blk: { + const where_slice = self.parse_ir.store.whereClauseSlice(.{ .span = self.parse_ir.store.getCollection(where_coll).span }); + const where_start = self.env.store.scratchWhereClauseTop(); + + for (where_slice) |where_idx| { + const canonicalized_where = try self.canonicalizeWhereClause(where_idx, .inline_anno); + try self.env.store.addScratchWhereClause(canonicalized_where); + } + + break :blk try self.env.store.whereClauseSpanFrom(where_start); + } else null; + + // If we have where clauses, create a separate s_type_anno statement + if (where_clauses != null) { + // Build qualified name for the annotation + const parent_text = self.env.getIdent(parent_name); + const name_text = self.env.getIdent(name_ident); + const qualified_name_str = try std.fmt.allocPrint( + self.env.gpa, + "{s}.{s}", + .{ parent_text, name_text }, + ); + defer self.env.gpa.free(qualified_name_str); + const qualified_ident = base.Ident.for_text(qualified_name_str); + const qualified_idx = try self.env.insertIdent(qualified_ident); + + const type_anno_stmt = Statement{ + .s_type_anno = .{ + .name = qualified_idx, + .anno = type_anno_idx, + .where = where_clauses, + }, + }; + const type_anno_stmt_idx = try self.env.addStatementAndTypeVar(type_anno_stmt, Content{ .flex = Flex.init() }, region); + try self.env.store.addScratchStatement(type_anno_stmt_idx); + } + + // Now, check the next stmt to see if it matches this anno + const next_i = i + 1; + if (next_i < stmt_idxs.len) { + const next_stmt_id = stmt_idxs[next_i]; + const next_stmt = self.parse_ir.store.getStatement(next_stmt_id); + + switch (next_stmt) { + .decl => |decl| { + // Check if the declaration pattern matches the annotation name + const pattern = self.parse_ir.store.getPattern(decl.pattern); + if (pattern == .ident) { + const pattern_ident_tok = pattern.ident.ident_tok; + if (self.parse_ir.tokens.resolveIdentifier(pattern_ident_tok)) |decl_ident| { + // Check if names match + if (name_ident.idx == decl_ident.idx) { + // Skip the next statement since we're processing it now + i = next_i; + + // Build qualified name (e.g., "Foo.bar") + const parent_text = self.env.getIdent(parent_name); + const decl_text = self.env.getIdent(decl_ident); + const qualified_name_str = try std.fmt.allocPrint( + self.env.gpa, + "{s}.{s}", + .{ parent_text, decl_text }, + ); + defer self.env.gpa.free(qualified_name_str); + const qualified_ident = base.Ident.for_text(qualified_name_str); + const qualified_idx = try self.env.insertIdent(qualified_ident); + + // Canonicalize with the qualified name and type annotation + const def_idx = try self.canonicalizeAssociatedDeclWithAnno(decl, qualified_idx, type_anno_idx); + try self.env.store.addScratchDef(def_idx); + } + } + } + }, + else => { + // Type annotation doesn't match a declaration - continue normally + }, + } + } + }, + .decl => |decl| { + // Canonicalize the declaration with qualified name + const pattern = self.parse_ir.store.getPattern(decl.pattern); + if (pattern == .ident) { + const pattern_ident_tok = pattern.ident.ident_tok; + if (self.parse_ir.tokens.resolveIdentifier(pattern_ident_tok)) |decl_ident| { + // Build qualified name (e.g., "Foo.bar") + const parent_text = self.env.getIdent(parent_name); + const decl_text = self.env.getIdent(decl_ident); + const qualified_name_str = try std.fmt.allocPrint( + self.env.gpa, + "{s}.{s}", + .{ parent_text, decl_text }, + ); + defer self.env.gpa.free(qualified_name_str); + const qualified_ident = base.Ident.for_text(qualified_name_str); + const qualified_idx = try self.env.insertIdent(qualified_ident); + + // Canonicalize with the qualified name + const def_idx = try self.canonicalizeAssociatedDecl(decl, qualified_idx); + try self.env.store.addScratchDef(def_idx); + } + } else { + // Non-identifier patterns are not supported in associated blocks + const region = self.parse_ir.tokenizedRegionToRegion(decl.region); + const feature = try self.env.insertString("non-identifier patterns in associated blocks"); + try self.env.pushDiagnostic(Diagnostic{ + .not_implemented = .{ + .feature = feature, + .region = region, + }, + }); + } + }, + .import => { + // Imports are not valid in associated blocks + const region = self.parse_ir.tokenizedRegionToRegion(stmt.import.region); + const feature = try self.env.insertString("import statements in associated blocks"); + try self.env.pushDiagnostic(Diagnostic{ + .not_implemented = .{ + .feature = feature, + .region = region, + }, + }); + }, + else => { + // Other statement types (var, expr, crash, dbg, expect, for, return, malformed) + // are not valid in associated blocks but are already caught by the parser, + // so we don't need to emit additional diagnostics here + }, + } + } +} + +/// First pass helper: Process associated items and introduce them into scope with qualified names +fn processAssociatedItemsFirstPass( + self: *Self, + parent_name: Ident.Idx, + statements: AST.Statement.Span, +) std.mem.Allocator.Error!void { + for (self.parse_ir.store.statementSlice(statements)) |stmt_idx| { + const stmt = self.parse_ir.store.getStatement(stmt_idx); + switch (stmt) { + .type_decl => |type_decl| { + // Recursively process nested type declarations (this introduces the qualified name) + try self.processTypeDeclFirstPass(type_decl, parent_name); + }, + .decl => |decl| { + // Introduce declarations with qualified names for recursive references + const pattern = self.parse_ir.store.getPattern(decl.pattern); + if (pattern == .ident) { + const pattern_ident_tok = pattern.ident.ident_tok; + if (self.parse_ir.tokens.resolveIdentifier(pattern_ident_tok)) |decl_ident| { + // Build qualified name (e.g., "Foo.Bar.baz") + const parent_text = self.env.getIdent(parent_name); + const decl_text = self.env.getIdent(decl_ident); + const qualified_name_str = try std.fmt.allocPrint( + self.env.gpa, + "{s}.{s}", + .{ parent_text, decl_text }, + ); + defer self.env.gpa.free(qualified_name_str); + + const qualified_ident = base.Ident.for_text(qualified_name_str); + const qualified_idx = try self.env.insertIdent(qualified_ident); + + // Create placeholder pattern with qualified name + const region = self.parse_ir.tokenizedRegionToRegion(decl.region); + const placeholder_pattern = Pattern{ + .assign = .{ + .ident = qualified_idx, + }, + }; + const placeholder_pattern_idx = try self.env.addPatternAndTypeVar(placeholder_pattern, .err, region); + + // Introduce the qualified name to scope + switch (try self.scopeIntroduceInternal(self.env.gpa, .ident, qualified_idx, placeholder_pattern_idx, false, true)) { + .success => {}, + .shadowing_warning => |shadowed_pattern_idx| { + const original_region = self.env.store.getPatternRegion(shadowed_pattern_idx); + try self.env.pushDiagnostic(Diagnostic{ .shadowing_warning = .{ + .ident = qualified_idx, + .region = region, + .original_region = original_region, + } }); + }, + .top_level_var_error => { + // This shouldn't happen for declarations in associated blocks + }, + .var_across_function_boundary => { + // This shouldn't happen for declarations in associated blocks + }, + } + } + } + }, + else => { + // Skip other statement types in first pass + }, + } + } +} + +/// Canonicalizes a full Roc source file, transforming the Abstract Syntax Tree (AST) +/// into Canonical Intermediate Representation (CIR). +/// +/// This is the main entry point for file-level canonicalization, handling: +/// - Module headers and exposed items +/// - Type declarations (including nested types in associated blocks) +/// - Value definitions +/// - Import statements +/// - Module validation (type modules, default-app modules, etc.) pub fn canonicalizeFile( self: *Self, ) std.mem.Allocator.Error!void { @@ -566,147 +898,66 @@ pub fn canonicalizeFile( // canonicalize_header_packages(); - // First, process the header to create exposed_scope + // First, process the header to create exposed_scope and set module_kind const header = self.parse_ir.store.getHeader(file.header); switch (header) { - .module => |h| try self.createExposedScope(h.exposes), - .package => |h| try self.createExposedScope(h.exposes), - .platform => |h| try self.createExposedScope(h.exposes), - .hosted => |h| try self.createExposedScope(h.exposes), + .module => |h| { + self.env.module_kind = .deprecated_module; + // Emit deprecation warning + const header_region = self.parse_ir.tokenizedRegionToRegion(h.region); + try self.env.pushDiagnostic(.{ + .module_header_deprecated = .{ + .region = header_region, + }, + }); + try self.createExposedScope(h.exposes); + }, + .package => |h| { + self.env.module_kind = .package; + try self.createExposedScope(h.exposes); + }, + .platform => |h| { + self.env.module_kind = .platform; + try self.createExposedScope(h.exposes); + }, + .hosted => |h| { + self.env.module_kind = .hosted; + try self.createExposedScope(h.exposes); + }, .app => |h| { + self.env.module_kind = .app; // App headers have 'provides' instead of 'exposes' // but we need to track the provided functions for export try self.createExposedScope(h.provides); }, + .type_module => { + // Set to undefined placeholder - will be properly set during validation + // when we find the matching type declaration + self.env.module_kind = .{ .type_module = undefined }; + // Type modules don't have an exposes list + // We'll validate the type name matches the module name after processing types + }, + .default_app => { + self.env.module_kind = .default_app; + // Default app modules don't have an exposes list + // They have a main! function that will be validated + }, .malformed => { + self.env.module_kind = .malformed; // Skip malformed headers }, } // Track the start of scratch defs and statements const scratch_defs_start = self.env.store.scratchDefTop(); - const scratch_statements_start = self.env.store.scratch_statements.top(); + const scratch_statements_start = self.env.store.scratch.?.statements.top(); // First pass: Process all type declarations to introduce them into scope for (self.parse_ir.store.statementSlice(file.statements)) |stmt_id| { const stmt = self.parse_ir.store.getStatement(stmt_id); switch (stmt) { .type_decl => |type_decl| { - // Canonicalize the type declaration header first - const header_idx = try self.canonicalizeTypeHeader(type_decl.header); - const region = self.parse_ir.tokenizedRegionToRegion(type_decl.region); - - // Extract the type name from the header to introduce it into scope early - const type_header = self.env.store.getTypeHeader(header_idx); - - // Create a placeholder type declaration statement to introduce the type name into scope - // This allows recursive type references to work during annotation canonicalization - const placeholder_cir_type_decl = switch (type_decl.kind) { - .alias => Statement{ - .s_alias_decl = .{ - .header = header_idx, - .anno = @enumFromInt(0), // placeholder - will be replaced - }, - }, - .nominal => Statement{ - .s_nominal_decl = .{ - .header = header_idx, - .anno = @enumFromInt(0), // placeholder - will be replaced - }, - }, - }; - - const placeholder_type_decl_idx = try self.env.addStatementAndTypeVar(placeholder_cir_type_decl, Content{ .flex_var = null }, region); - - // Introduce the type name into scope early to support recursive references - try self.scopeIntroduceTypeDecl(type_header.name, placeholder_type_decl_idx, region); - - // Process type parameters and annotation in a separate scope - const anno_idx = blk: { - // Enter a new scope for type parameters - try self.scopeEnter(self.env.gpa, false); - defer self.scopeExit(self.env.gpa) catch {}; - - // Introduce type parameters from the header into the scope - try self.introduceTypeParametersFromHeader(header_idx); - - // Now canonicalize the type annotation with type parameters and type name in scope - break :blk try self.canonicalizeTypeAnno(type_decl.anno, .type_decl_anno); - }; - - // Get type variables to args (lhs) - const header_arg_vars: []TypeVar = @ptrCast(self.env.store.sliceTypeAnnos(type_header.args)); - - // Get type variable to the backing type (rhs) - const anno_var = ModuleEnv.varFrom(anno_idx); - - // Check if the backing type is already an error type - const backing_resolved = self.env.types.resolveVar(anno_var); - const backing_is_error = backing_resolved.desc.content == .err; - - // The identified of the type - const type_ident = types.TypeIdent{ .ident_idx = type_header.name }; - - // Canonicalize where clauses if present - if (type_decl.where) |_| { - try self.env.pushDiagnostic(Diagnostic{ .where_clause_not_allowed_in_type_decl = .{ - .region = region, - } }); - } - - // Create the real CIR type declaration statement with the canonicalized annotation - const real_cir_type_decl, const type_decl_content = blk: { - switch (type_decl.kind) { - .alias => { - const alias_content = if (backing_is_error) - types.Content{ .err = {} } - else - try self.env.types.mkAlias(type_ident, anno_var, header_arg_vars); - - break :blk .{ - Statement{ - .s_alias_decl = .{ - .header = header_idx, - .anno = anno_idx, - }, - }, - alias_content, - }; - }, - .nominal => { - const nominal_content = if (backing_is_error) - types.Content{ .err = {} } - else - try self.env.types.mkNominal( - type_ident, - anno_var, - header_arg_vars, - try self.env.insertIdent(base.Ident.for_text(self.env.module_name)), - ); - - break :blk .{ - Statement{ - .s_nominal_decl = .{ - .header = header_idx, - .anno = anno_idx, - }, - }, - nominal_content, - }; - }, - } - }; - - // Create the real statement and add it to scratch statements - const type_decl_stmt_idx = try self.env.addStatementAndTypeVar(real_cir_type_decl, type_decl_content, region); - try self.env.store.addScratchStatement(type_decl_stmt_idx); - - // Update the scope to point to the real statement instead of the placeholder - try self.scopeUpdateTypeDecl(type_header.name, type_decl_stmt_idx); - - // Remove from exposed_type_texts since the type is now fully defined - const type_text = self.env.getIdent(type_header.name); - _ = self.exposed_type_texts.remove(type_text); + try self.processTypeDeclFirstPass(type_decl, null); }, else => { // Skip non-type-declaration statements in first pass @@ -714,62 +965,41 @@ pub fn canonicalizeFile( } } - // Second pass: Process all other statements - var last_type_anno: ?struct { - name: base.Ident.Idx, - anno_idx: TypeAnno.Idx, - type_vars: DataSpan, - where_clauses: ?WhereClause.Span, - } = null; + // For type modules, expose the main type and all associated items before the second pass + // This ensures unused variable checking in the third pass doesn't flag exposed items + if (self.env.module_kind == .type_module) { + const module_name_text = self.env.module_name; + for (self.parse_ir.store.statementSlice(file.statements)) |stmt_id| { + const stmt = self.parse_ir.store.getStatement(stmt_id); + if (stmt == .type_decl) { + const type_decl = stmt.type_decl; + const type_header = self.parse_ir.store.getTypeHeader(type_decl.header) catch continue; + const type_name_ident = self.parse_ir.tokens.resolveIdentifier(type_header.name) orelse continue; + const type_name_text = self.env.getIdent(type_name_ident); - for (self.parse_ir.store.statementSlice(file.statements)) |stmt_id| { + if (std.mem.eql(u8, type_name_text, module_name_text)) { + // Expose the main type + try self.env.addExposedById(type_name_ident); + // Expose all associated items recursively + try self.exposeAssociatedItems(type_name_ident, type_decl); + break; + } + } + } + } + + // Second pass: Process all other statements + const ast_stmt_idxs = self.parse_ir.store.statementSlice(file.statements); + var i: usize = 0; + while (i < ast_stmt_idxs.len) : (i += 1) { + const stmt_id = ast_stmt_idxs[i]; const stmt = self.parse_ir.store.getStatement(stmt_id); switch (stmt) { .import => |import_stmt| { _ = try self.canonicalizeImportStatement(import_stmt); - last_type_anno = null; // Clear on non-annotation statement }, .decl => |decl| { - // Check if this declaration matches the last type annotation - var annotation_idx: ?Annotation.Idx = null; - if (last_type_anno) |anno_info| { - if (self.parse_ir.store.getPattern(decl.pattern) == .ident) { - const pattern_ident = self.parse_ir.store.getPattern(decl.pattern).ident; - if (self.parse_ir.tokens.resolveIdentifier(pattern_ident.ident_tok)) |decl_ident| { - if (anno_info.name.idx == decl_ident.idx) { - // This declaration matches the type annotation - const pattern_region = self.parse_ir.tokenizedRegionToRegion(self.parse_ir.store.getPattern(decl.pattern).to_tokenized_region()); - annotation_idx = try self.createAnnotationFromTypeAnno(anno_info.anno_idx, pattern_region); - // Clear the annotation since we've used it - last_type_anno = null; - } - } - } - } - - const def_idx = try self.canonicalizeDeclWithAnnotation(decl, annotation_idx); - try self.env.store.addScratchDef(def_idx); - last_type_anno = null; // Clear after successful use - - // If this declaration successfully defined an exposed value, remove it from exposed_ident_texts - // and add the node index to exposed_items - const pattern = self.parse_ir.store.getPattern(decl.pattern); - if (pattern == .ident) { - const token_region = self.parse_ir.tokens.resolve(@intCast(pattern.ident.ident_tok)); - const ident_text = self.parse_ir.env.source[token_region.start.offset..token_region.end.offset]; - - // If this identifier is exposed, add it to exposed_items - if (self.exposed_ident_texts.contains(ident_text)) { - // Get the interned identifier - it should already exist from parsing - const ident = base.Ident.for_text(ident_text); - const idx = try self.env.insertIdent(ident); - // Store the def index as u16 in exposed_items - const def_idx_u16: u16 = @intCast(@intFromEnum(def_idx)); - try self.env.setExposedNodeIndexById(idx, def_idx_u16); - } - - _ = self.exposed_ident_texts.remove(ident_text); - } + _ = try self.canonicalizeStmtDecl(decl, null); }, .@"var" => |var_stmt| { // Not valid at top-level @@ -779,7 +1009,6 @@ pub fn canonicalizeFile( .stmt = string_idx, .region = region, } }); - last_type_anno = null; // Clear on non-annotation statement }, .expr => |expr_stmt| { // Not valid at top-level @@ -789,7 +1018,6 @@ pub fn canonicalizeFile( .stmt = string_idx, .region = region, } }); - last_type_anno = null; // Clear on non-annotation statement }, .crash => |crash_stmt| { // Not valid at top-level @@ -799,7 +1027,6 @@ pub fn canonicalizeFile( .stmt = string_idx, .region = region, } }); - last_type_anno = null; // Clear on non-annotation statement }, .dbg => |dbg_stmt| { // Not valid at top-level @@ -809,7 +1036,6 @@ pub fn canonicalizeFile( .stmt = string_idx, .region = region, } }); - last_type_anno = null; // Clear on non-annotation statement }, .expect => |e| { // Top-level expect statement @@ -824,9 +1050,8 @@ pub fn canonicalizeFile( const expect_stmt = Statement{ .s_expect = .{ .body = malformed, } }; - const expect_stmt_idx = try self.env.addStatementAndTypeVar(expect_stmt, Content{ .flex_var = null }, region); + const expect_stmt_idx = try self.env.addStatementAndTypeVar(expect_stmt, Content{ .flex = types.Flex.init() }, region); try self.env.store.addScratchStatement(expect_stmt_idx); - last_type_anno = null; // Clear on non-annotation statement continue; }; @@ -834,10 +1059,8 @@ pub fn canonicalizeFile( const expect_stmt = Statement{ .s_expect = .{ .body = can_expect.idx, } }; - const expect_stmt_idx = try self.env.addStatementAndTypeVar(expect_stmt, Content{ .flex_var = null }, region); + const expect_stmt_idx = try self.env.addStatementAndTypeVar(expect_stmt, Content{ .flex = types.Flex.init() }, region); try self.env.store.addScratchStatement(expect_stmt_idx); - - last_type_anno = null; // Clear on non-annotation statement }, .@"for" => |for_stmt| { // Not valid at top-level @@ -859,7 +1082,6 @@ pub fn canonicalizeFile( }, .type_decl => { // Already processed in first pass, skip - last_type_anno = null; // Clear on non-annotation statement }, .type_anno => |ta| { const region = self.parse_ir.tokenizedRegionToRegion(ta.region); @@ -874,6 +1096,7 @@ pub fn canonicalizeFile( .region = region, }, }); + continue; }; @@ -883,9 +1106,10 @@ pub fn canonicalizeFile( // Extract type variables from the AST annotation try self.extractTypeVarIdentsFromASTAnno(ta.anno, type_vars_top); - // Enter a new scope for type variables - try self.scopeEnter(self.env.gpa, false); - defer self.scopeExit(self.env.gpa) catch {}; + // Enter a new type var scope + const type_var_scope = self.scopeEnterTypeVar(); + defer self.scopeExitTypeVar(type_var_scope); + std.debug.assert(type_var_scope.idx == 0); // Now canonicalize the annotation with type variables in scope const type_anno_idx = try self.canonicalizeTypeAnno(ta.anno, .inline_anno); @@ -912,22 +1136,112 @@ pub fn canonicalizeFile( .where = where_clauses, }, }; - const type_anno_stmt_idx = try self.env.addStatementAndTypeVar(type_anno_stmt, Content{ .flex_var = null }, region); + const type_anno_stmt_idx = try self.env.addStatementAndTypeVar(type_anno_stmt, Content{ .flex = types.Flex.init() }, region); try self.env.store.addScratchStatement(type_anno_stmt_idx); } - // Store this annotation for the next declaration - last_type_anno = .{ - .name = name_ident, - .anno_idx = type_anno_idx, - .type_vars = DataSpan.empty(), - .where_clauses = where_clauses, - }; + // Now, check the next stmt to see if it matches this anno + const next_i = i + 1; + if (next_i < ast_stmt_idxs.len) { + const next_stmt_id = ast_stmt_idxs[next_i]; + const next_stmt = self.parse_ir.store.getStatement(next_stmt_id); + + switch (next_stmt) { + .decl => |decl| { + i = next_i; + _ = try self.canonicalizeStmtDecl(decl, TypeAnnoIdent{ + .name = name_ident, + .anno_idx = type_anno_idx, + }); + }, + else => { + // TODO: Issue diagnostic? + }, + } + } }, .malformed => |malformed| { // We won't touch this since it's already a parse error. _ = malformed; - last_type_anno = null; // Clear on non-annotation statement + }, + } + } + + // Third pass: Process associated items in type declarations + for (self.parse_ir.store.statementSlice(file.statements)) |stmt_id| { + const stmt = self.parse_ir.store.getStatement(stmt_id); + switch (stmt) { + .type_decl => |type_decl| { + if (type_decl.associated) |assoc| { + const type_header = self.parse_ir.store.getTypeHeader(type_decl.header) catch continue; + const type_ident = self.parse_ir.tokens.resolveIdentifier(type_header.name) orelse continue; + + // Enter a new scope for the associated block + try self.scopeEnter(self.env.gpa, false); // false = not a function boundary + defer self.scopeExit(self.env.gpa) catch unreachable; + + // Re-introduce the aliases from first pass + // (We need to rebuild them since we're in a new scope) + for (self.parse_ir.store.statementSlice(assoc.statements)) |assoc_stmt_idx| { + const assoc_stmt = self.parse_ir.store.getStatement(assoc_stmt_idx); + switch (assoc_stmt) { + .type_decl => |nested_type_decl| { + const nested_header = self.parse_ir.store.getTypeHeader(nested_type_decl.header) catch continue; + const unqualified_ident = self.parse_ir.tokens.resolveIdentifier(nested_header.name) orelse continue; + + // Build qualified name + const parent_text = self.env.getIdent(type_ident); + const type_text = self.env.getIdent(unqualified_ident); + const qualified_name_str = try std.fmt.allocPrint( + self.env.gpa, + "{s}.{s}", + .{ parent_text, type_text }, + ); + defer self.env.gpa.free(qualified_name_str); + const qualified_ident_idx = try self.env.insertIdent(base.Ident.for_text(qualified_name_str)); + + // Look up and alias + if (self.scopeLookupTypeDecl(qualified_ident_idx)) |qualified_type_decl_idx| { + const current_scope = &self.scopes.items[self.scopes.items.len - 1]; + try current_scope.introduceTypeAlias(self.env.gpa, unqualified_ident, qualified_type_decl_idx); + } + }, + .decl => |decl| { + const pattern = self.parse_ir.store.getPattern(decl.pattern); + if (pattern == .ident) { + const pattern_ident_tok = pattern.ident.ident_tok; + if (self.parse_ir.tokens.resolveIdentifier(pattern_ident_tok)) |decl_ident| { + // Build qualified name + const parent_text = self.env.getIdent(type_ident); + const decl_text = self.env.getIdent(decl_ident); + const qualified_name_str = try std.fmt.allocPrint( + self.env.gpa, + "{s}.{s}", + .{ parent_text, decl_text }, + ); + defer self.env.gpa.free(qualified_name_str); + const qualified_ident_idx = try self.env.insertIdent(base.Ident.for_text(qualified_name_str)); + + // Look up the qualified pattern + switch (self.scopeLookup(.ident, qualified_ident_idx)) { + .found => |pattern_idx| { + const current_scope = &self.scopes.items[self.scopes.items.len - 1]; + try current_scope.idents.put(self.env.gpa, decl_ident, pattern_idx); + }, + .not_found => {}, + } + } + } + }, + else => {}, + } + } + + try self.processAssociatedItemsSecondPass(type_ident, assoc.statements); + } + }, + else => { + // Skip non-type-declaration statements in third pass }, } } @@ -944,11 +1258,111 @@ pub fn canonicalizeFile( // Assert that everything is in-sync self.env.debugAssertArraysInSync(); - - // Freeze the interners after canonicalization is complete - self.env.freezeInterners(); } +/// Validate a type module for use in checking mode (roc check). +/// This accepts both type modules and default-app modules, providing helpful +/// error messages when neither is valid. +pub fn validateForChecking(self: *Self) std.mem.Allocator.Error!void { + const trace = tracy.trace(@src()); + defer trace.end(); + + switch (self.env.module_kind) { + .type_module => |*main_type_ident| { + const main_status = try self.checkMainFunction(); + const matching_type_ident = self.findMatchingTypeIdent(); + + // Store the matching type ident in module_kind if found + if (matching_type_ident) |type_ident| { + main_type_ident.* = type_ident; + // The main type and associated items are already exposed in canonicalize() + } + + // Valid if either we have a valid main! or a matching type declaration + const is_valid = (main_status == .valid) or (matching_type_ident != null); + + if (!is_valid and main_status == .not_found) { + // Neither valid main! nor matching type - report helpful error + try self.reportTypeModuleOrDefaultAppError(); + } + }, + .default_app, .app, .package, .platform, .hosted, .deprecated_module, .malformed => { + // No validation needed for these module kinds in checking mode + }, + } +} + +/// Validate a module for use in execution mode (e.g. `roc main.roc` or `roc build`). +/// Requires a valid main! function for type_module headers. +pub fn validateForExecution(self: *Self) std.mem.Allocator.Error!void { + switch (self.env.module_kind) { + .type_module => { + const main_status = try self.checkMainFunction(); + if (main_status == .not_found) { + try self.reportExecutionRequiresAppOrDefaultApp(); + } + }, + .default_app, .app, .package, .platform, .hosted, .deprecated_module, .malformed => { + // No validation needed for these module kinds in execution mode + }, + } +} + +fn canonicalizeStmtDecl(self: *Self, decl: AST.Statement.Decl, mb_last_anno: ?TypeAnnoIdent) std.mem.Allocator.Error!void { + // Check if this declaration matches the last type annotation + var mb_validated_anno: ?Annotation.Idx = null; + if (mb_last_anno) |anno_info| { + const ast_pattern = self.parse_ir.store.getPattern(decl.pattern); + if (ast_pattern == .ident) { + const pattern_ident = ast_pattern.ident; + if (self.parse_ir.tokens.resolveIdentifier(pattern_ident.ident_tok)) |decl_ident| { + if (anno_info.name.idx == decl_ident.idx) { + // This declaration matches the type annotation + const pattern_region = self.parse_ir.tokenizedRegionToRegion(ast_pattern.to_tokenized_region()); + mb_validated_anno = try self.createAnnotationFromTypeAnno(anno_info.anno_idx, pattern_region); + } + } else { + // TODO: Diagnostic + } + } + } + + // Canonicalize the decl (with the validated anno) + const def_idx = try self.canonicalizeDeclWithAnnotation(decl, mb_validated_anno); + try self.env.store.addScratchDef(def_idx); + + // If this declaration successfully defined an exposed value, remove it from exposed_ident_texts + // and add the node index to exposed_items + const pattern = self.parse_ir.store.getPattern(decl.pattern); + if (pattern == .ident) { + const token_region = self.parse_ir.tokens.resolve(@intCast(pattern.ident.ident_tok)); + const ident_text = self.parse_ir.env.source[token_region.start.offset..token_region.end.offset]; + + // If this identifier is exposed, add it to exposed_items + if (self.exposed_ident_texts.contains(ident_text)) { + // Get the interned identifier - it should already exist from parsing + const ident = base.Ident.for_text(ident_text); + const idx = try self.env.insertIdent(ident); + // Store the def index as u16 in exposed_items + const def_idx_u16: u16 = @intCast(@intFromEnum(def_idx)); + try self.env.setExposedNodeIndexById(idx, def_idx_u16); + } + + _ = self.exposed_ident_texts.remove(ident_text); + } +} + +/// An annotation and it's scope. This struct owns the Scope +const AnnotationAndScope = struct { + anno_idx: Annotation.Idx, + scope: *Scope, +}; + +const TypeAnnoIdent = struct { + name: base.Ident.Idx, + anno_idx: TypeAnno.Idx, +}; + fn collectBoundVars(self: *Self, pattern_idx: Pattern.Idx, bound_vars: *std.AutoHashMapUnmanaged(Pattern.Idx, void)) !void { const pattern = self.env.store.getPattern(pattern_idx); switch (pattern) { @@ -988,7 +1402,7 @@ fn collectBoundVars(self: *Self, pattern_idx: Pattern.Idx, bound_vars: *std.Auto } } }, - .int_literal, + .num_literal, .small_dec_literal, .dec_literal, .frac_f32_literal, @@ -1359,10 +1773,12 @@ fn canonicalizeImportStatement( // Process type imports from this module try self.processTypeImports(module_name, alias); - // 5. Convert exposed items and introduce them into scope - const cir_exposes = try self.convertASTExposesToCIR(import_stmt.exposes); + // 5. Convert exposed items to CIR + const scratch_start = self.env.store.scratchExposedItemTop(); + try self.convertASTExposesToCIR(import_stmt.exposes); + const cir_exposes = try self.env.store.exposedItemSpanFrom(scratch_start); const import_region = self.parse_ir.tokenizedRegionToRegion(import_stmt.region); - try self.introduceExposedItemsIntoScope(cir_exposes, module_name, import_region); + try self.introduceExposedItemsIntoScope(cir_exposes, module_name, alias, import_region); // 6. Store the mapping from module name to Import.Idx try self.import_indices.put(self.env.gpa, module_name_text, module_import_idx); @@ -1377,7 +1793,7 @@ fn canonicalizeImportStatement( }, }; - const import_idx = try self.env.addStatementAndTypeVar(cir_import, Content{ .flex_var = null }, self.parse_ir.tokenizedRegionToRegion(import_stmt.region)); + const import_idx = try self.env.addStatementAndTypeVar(cir_import, Content{ .flex = types.Flex.init() }, self.parse_ir.tokenizedRegionToRegion(import_stmt.region)); try self.env.store.addScratchStatement(import_idx); // 8. Add the module to the current scope so it can be used in qualified lookups @@ -1458,12 +1874,11 @@ fn createExternalDeclaration( } /// Convert AST exposed items to CIR exposed items +/// If main_type_name is provided, auto-inject it as an exposed item fn convertASTExposesToCIR( self: *Self, ast_exposes: AST.ExposedItem.Span, -) std.mem.Allocator.Error!CIR.ExposedItem.Span { - const scratch_start = self.env.store.scratchExposedItemTop(); - +) std.mem.Allocator.Error!void { const ast_exposed_slice = self.parse_ir.store.exposedItemSlice(ast_exposes); for (ast_exposed_slice) |ast_exposed_idx| { const ast_exposed = self.parse_ir.store.getExposedItem(ast_exposed_idx); @@ -1511,11 +1926,9 @@ fn convertASTExposesToCIR( inline else => |payload| payload.region, }; const region = self.parse_ir.tokenizedRegionToRegion(tokenized_region); - const cir_exposed_idx = try self.env.addExposedItemAndTypeVar(cir_exposed, .{ .flex_var = null }, region); + const cir_exposed_idx = try self.env.addExposedItemAndTypeVar(cir_exposed, .{ .flex = types.Flex.init() }, region); try self.env.store.addScratchExposedItem(cir_exposed_idx); } - - return try self.env.store.exposedItemSpanFrom(scratch_start); } /// Introduce converted exposed items into scope for identifier resolution @@ -1523,6 +1936,7 @@ fn introduceExposedItemsIntoScope( self: *Self, exposed_items_span: CIR.ExposedItem.Span, module_name: Ident.Idx, + module_alias: Ident.Idx, import_region: Region, ) std.mem.Allocator.Error!void { const exposed_items_slice = self.env.store.sliceExposedItems(exposed_items_span); @@ -1541,6 +1955,20 @@ fn introduceExposedItemsIntoScope( // Get the module's exposed_items const module_env = envs_map.get(module_name_text).?; + // For type modules, auto-introduce the main type with the alias name + switch (module_env.module_kind) { + .type_module => |main_type_ident| { + if (module_env.containsExposedById(main_type_ident)) { + const item_info = Scope.ExposedItemInfo{ + .module_name = module_name, + .original_name = main_type_ident, + }; + try self.scopeIntroduceExposedItem(module_alias, item_info); + } + }, + else => {}, + } + // Validate each exposed item for (exposed_items_slice) |exposed_item_idx| { const exposed_item = self.env.store.getExposedItem(exposed_item_idx); @@ -1598,16 +2026,16 @@ fn introduceExposedItemsIntoScope( } } +/// Canonicalize a decl with an annotation fn canonicalizeDeclWithAnnotation( self: *Self, decl: AST.Statement.Decl, - annotation: ?Annotation.Idx, + mb_anno_idx: ?Annotation.Idx, ) std.mem.Allocator.Error!CIR.Def.Idx { const trace = tracy.trace(@src()); defer trace.end(); const pattern_region = self.parse_ir.tokenizedRegionToRegion(self.parse_ir.store.getPattern(decl.pattern).to_tokenized_region()); - const expr_region = self.parse_ir.tokenizedRegionToRegion(self.parse_ir.store.getExpr(decl.body).to_tokenized_region()); const pattern_idx = blk: { if (try self.canonicalizePattern(decl.pattern)) |idx| { @@ -1620,17 +2048,7 @@ fn canonicalizeDeclWithAnnotation( } }; - const can_expr = blk: { - if (try self.canonicalizeExpr(decl.body)) |ce| { - break :blk ce; - } else { - const malformed_idx = try self.env.pushMalformed(Expr.Idx, Diagnostic{ .expr_not_canonicalized = .{ - .region = expr_region, - } }); - break :blk CanonicalizedExpr{ .idx = malformed_idx, .free_vars = null }; - } - }; - const expr_idx = can_expr.idx; + const can_expr = try self.canonicalizeExprOrMalformed(decl.body); // Create the def entry and set def type variable to a flex var // @@ -1649,10 +2067,10 @@ fn canonicalizeDeclWithAnnotation( const region = self.parse_ir.tokenizedRegionToRegion(decl.region); const def_idx = self.env.addDefAndTypeVar(.{ .pattern = pattern_idx, - .expr = expr_idx, - .annotation = annotation, + .expr = can_expr.idx, + .annotation = mb_anno_idx, .kind = .let, - }, Content{ .flex_var = null }, region); + }, Content{ .flex = types.Flex.init() }, region); return def_idx; } @@ -1752,27 +2170,23 @@ fn canonicalizeSingleQuote( const token_text = self.parse_ir.resolve(token); if (parseSingleQuoteCodepoint(token_text[1 .. token_text.len - 1])) |codepoint| { - const type_content = Content{ .structure = .{ .num = .{ .num_unbound = types.Num.IntRequirements{ - .sign_needed = false, - .bits_needed = @intCast(@sizeOf(u21)), - } } } }; const value_content = CIR.IntValue{ .bytes = @bitCast(@as(u128, @intCast(codepoint))), .kind = .u128, }; - if (Idx == Expr.Idx) { + if (comptime Idx == Expr.Idx) { const expr_idx = try self.env.addExprAndTypeVar(CIR.Expr{ - .e_int = .{ + .e_num = .{ .value = value_content, + .kind = .int_unbound, }, - }, type_content, region); + }, .err, region); return expr_idx; - } else if (Idx == Pattern.Idx) { - const pat_idx = try self.env.addPatternAndTypeVar(Pattern{ - .int_literal = .{ - .value = value_content, - }, - }, type_content, region); + } else if (comptime Idx == Pattern.Idx) { + const pat_idx = try self.env.addPatternAndTypeVar(Pattern{ .num_literal = .{ + .value = value_content, + .kind = .int_unbound, + } }, .err, region); return pat_idx; } else { @compileError("Unsupported Idx type"); @@ -1821,7 +2235,7 @@ fn canonicalizeRecordField( .value = can_value.idx, }; - return try self.env.addRecordFieldAndTypeVar(cir_field, Content{ .flex_var = null }, self.parse_ir.tokenizedRegionToRegion(field.region)); + return try self.env.addRecordFieldAndTypeVar(cir_field, Content{ .flex = types.Flex.init() }, self.parse_ir.tokenizedRegionToRegion(field.region)); } /// Parse an integer with underscores. @@ -1866,16 +2280,14 @@ pub fn canonicalizeExpr( // Not a tag application, proceed with normal function call // Mark the start of scratch expressions const free_vars_start = self.scratch_free_vars.top(); - const scratch_top = self.env.store.scratchExprTop(); // Canonicalize the function being called and add as first element const can_fn_expr = try self.canonicalizeExpr(e.@"fn") orelse { - self.env.store.clearScratchExprsFrom(scratch_top); return null; }; - try self.env.store.addScratchExpr(can_fn_expr.idx); // Canonicalize and add all arguments + const scratch_top = self.env.store.scratchExprTop(); const args_slice = self.parse_ir.store.exprSlice(e.args); for (args_slice) |arg| { if (try self.canonicalizeExpr(arg)) |can_arg| { @@ -1888,10 +2300,11 @@ pub fn canonicalizeExpr( const expr_idx = try self.env.addExprAndTypeVar(CIR.Expr{ .e_call = .{ + .func = can_fn_expr.idx, .args = args_span, .called_via = CalledVia.apply, }, - }, Content{ .flex_var = null }, region); + }, .err, region); const free_vars_slice = self.scratch_free_vars.slice(free_vars_start, self.scratch_free_vars.top()); return CanonicalizedExpr{ .idx = expr_idx, .free_vars = if (free_vars_slice.len > 0) free_vars_slice else null }; @@ -1902,6 +2315,36 @@ pub fn canonicalizeExpr( // Check if this is a module-qualified identifier const qualifier_tokens = self.parse_ir.store.tokenSlice(e.qualifiers); if (qualifier_tokens.len > 0) { + // First, try looking up the full qualified name as a local identifier (for associated items) + const strip_tokens = [_]tokenize.Token.Tag{.NoSpaceDotLowerIdent}; + const qualified_name_text = self.parse_ir.resolveQualifiedName( + e.qualifiers, + e.token, + &strip_tokens, + ); + const qualified_ident = try self.env.insertIdent(base.Ident.for_text(qualified_name_text)); + + // Try local lookup first + switch (self.scopeLookup(.ident, qualified_ident)) { + .found => |found_pattern_idx| { + // Mark this pattern as used for unused variable checking + try self.used_patterns.put(self.env.gpa, found_pattern_idx, {}); + + // We found the qualified ident in local scope + const expr_idx = try self.env.addExprAndTypeVar(CIR.Expr{ .e_lookup_local = .{ + .pattern_idx = found_pattern_idx, + } }, .err, region); + + const free_vars_start = self.scratch_free_vars.top(); + try self.scratch_free_vars.append(self.env.gpa, found_pattern_idx); + const free_vars_slice = self.scratch_free_vars.slice(free_vars_start, self.scratch_free_vars.top()); + return CanonicalizedExpr{ .idx = expr_idx, .free_vars = if (free_vars_slice.len > 0) free_vars_slice else null }; + }, + .not_found => { + // Not a local qualified identifier, try module-qualified lookup + }, + } + const qualifier_tok = @as(Token.Idx, @intCast(qualifier_tokens[0])); if (self.parse_ir.tokens.resolveIdentifier(qualifier_tok)) |module_alias| { // Check if this is a module alias @@ -1941,7 +2384,7 @@ pub fn canonicalizeExpr( .module_idx = import_idx, .target_node_idx = target_node_idx, .region = region, - } }, Content{ .flex_var = null }, region); + } }, Content{ .flex = types.Flex.init() }, region); return CanonicalizedExpr{ .idx = expr_idx, .free_vars = null, @@ -1952,20 +2395,21 @@ pub fn canonicalizeExpr( // Not a module-qualified lookup, or qualifier not found, proceed with normal lookup switch (self.scopeLookup(.ident, ident)) { - .found => |pattern_idx| { + .found => |found_pattern_idx| { // Mark this pattern as used for unused variable checking - try self.used_patterns.put(self.env.gpa, pattern_idx, {}); + try self.used_patterns.put(self.env.gpa, found_pattern_idx, {}); // Check if this is a used underscore variable try self.checkUsedUnderscoreVariable(ident, region); // We found the ident in scope, lookup to reference the pattern - const expr_idx = try self.env.addExprAndTypeVarRedirect(CIR.Expr{ .e_lookup_local = .{ - .pattern_idx = pattern_idx, - } }, ModuleEnv.varFrom(pattern_idx), region); + // TODO(RANK) + const expr_idx = try self.env.addExprAndTypeVar(CIR.Expr{ .e_lookup_local = .{ + .pattern_idx = found_pattern_idx, + } }, .err, region); const free_vars_start = self.scratch_free_vars.top(); - try self.scratch_free_vars.append(self.env.gpa, pattern_idx); + try self.scratch_free_vars.append(self.env.gpa, found_pattern_idx); const free_vars_slice = self.scratch_free_vars.slice(free_vars_start, self.scratch_free_vars.top()); return CanonicalizedExpr{ .idx = expr_idx, .free_vars = if (free_vars_slice.len > 0) free_vars_slice else null }; }, @@ -2005,7 +2449,7 @@ pub fn canonicalizeExpr( .module_idx = import_idx, .target_node_idx = target_node_idx, .region = region, - } }, Content{ .flex_var = null }, region); + } }, .err, region); return CanonicalizedExpr{ .idx = expr_idx, .free_vars = null }; } @@ -2082,109 +2526,111 @@ pub fn canonicalizeExpr( return CanonicalizedExpr{ .idx = expr_idx, .free_vars = null }; } - // Now we've confirmed that our int literal is one of these: - // * A signed integer that fits in i128 - // * An unsigned integer that fits in u128 - // - // We'll happily bitcast a u128 to i128 for storage (and bitcast it back later - // using its type information), but for negative numbers, we do need to actually - // negate them (branchlessly) if we skipped its minus sign earlier. - // - // This operation should never overflow i128, because we already would have errored out - // if the u128 portion was bigger than the lowest i128 without a minus sign. - // Special case: exactly i128 min already has the correct bit pattern when bitcast from u128, - // so if we try to negate it we'll get an overflow. We specifically *don't* negate that one. - const i128_val: i128 = if (is_negated) blk: { - if (u128_val == min_i128_negated) { - break :blk @as(i128, @bitCast(u128_val)); + // Determine the appropriate storage type + const int_value = blk: { + if (is_negated) { + // Negative: must be i128 (or smaller) + const i128_val = if (u128_val == min_i128_negated) + std.math.minInt(i128) // Special case for -2^127 + else + -@as(i128, @intCast(u128_val)); + break :blk CIR.IntValue{ + .bytes = @bitCast(i128_val), + .kind = .i128, + }; } else { - break :blk -@as(i128, @bitCast(u128_val)); - } - } else @as(i128, @bitCast(u128_val)); - - // Calculate requirements based on the value - // Special handling for minimum signed values (-128, -32768, etc.) - // These are special because they have a power-of-2 magnitude that fits exactly - // in their signed type. We report them as needing one less bit to make the - // standard "signed types have n-1 usable bits" logic work correctly. - if (parsed.suffix) |suffix| { - const type_content = blk: { - if (std.mem.eql(u8, suffix, "u8")) { - if (u128_val > std.math.maxInt(u8)) break :blk null; - break :blk Content{ .structure = FlatType{ .num = Num.int_u8 } }; - } else if (std.mem.eql(u8, suffix, "u16")) { - if (u128_val > std.math.maxInt(u16)) break :blk null; - break :blk Content{ .structure = FlatType{ .num = Num.int_u16 } }; - } else if (std.mem.eql(u8, suffix, "u32")) { - if (u128_val > std.math.maxInt(u32)) break :blk null; - break :blk Content{ .structure = FlatType{ .num = Num.int_u32 } }; - } else if (std.mem.eql(u8, suffix, "u64")) { - if (u128_val > std.math.maxInt(u64)) break :blk null; - break :blk Content{ .structure = FlatType{ .num = Num.int_u64 } }; - } else if (std.mem.eql(u8, suffix, "u128")) { - break :blk Content{ .structure = FlatType{ .num = Num.int_u128 } }; - } else if (std.mem.eql(u8, suffix, "i8")) { - if (i128_val < std.math.minInt(i8) or i128_val > std.math.maxInt(i8)) break :blk null; - break :blk Content{ .structure = FlatType{ .num = Num.int_i8 } }; - } else if (std.mem.eql(u8, suffix, "i16")) { - if (i128_val < std.math.minInt(i16) or i128_val > std.math.maxInt(i16)) break :blk null; - break :blk Content{ .structure = FlatType{ .num = Num.int_i16 } }; - } else if (std.mem.eql(u8, suffix, "i32")) { - if (i128_val < std.math.minInt(i32) or i128_val > std.math.maxInt(i32)) break :blk null; - break :blk Content{ .structure = FlatType{ .num = Num.int_i32 } }; - } else if (std.mem.eql(u8, suffix, "i64")) { - if (i128_val < std.math.minInt(i64) or i128_val > std.math.maxInt(i64)) break :blk null; - break :blk Content{ .structure = FlatType{ .num = Num.int_i64 } }; - } else if (std.mem.eql(u8, suffix, "i128")) { - break :blk Content{ .structure = FlatType{ .num = Num.int_i128 } }; + // Positive: could be i128 or u128 + if (u128_val > @as(u128, std.math.maxInt(i128))) { + // Too big for i128, keep as u128 + break :blk CIR.IntValue{ + .bytes = @bitCast(u128_val), + .kind = .u128, + }; } else { - break :blk null; + // Fits in i128 + break :blk CIR.IntValue{ + .bytes = @bitCast(@as(i128, @intCast(u128_val))), + .kind = .i128, + }; + } + } + }; + + // If a user provided a suffix, then we treat is as an type + // annotation to apply to the number + if (parsed.suffix) |suffix| { + // Capture the suffix, if provided + const num_suffix: CIR.NumKind = blk: { + if (std.mem.eql(u8, suffix, "u8")) { + break :blk .u8; + } else if (std.mem.eql(u8, suffix, "u16")) { + break :blk .u16; + } else if (std.mem.eql(u8, suffix, "u32")) { + break :blk .u32; + } else if (std.mem.eql(u8, suffix, "u64")) { + break :blk .u64; + } else if (std.mem.eql(u8, suffix, "u128")) { + break :blk .u128; + } else if (std.mem.eql(u8, suffix, "i8")) { + break :blk .i8; + } else if (std.mem.eql(u8, suffix, "i16")) { + break :blk .i16; + } else if (std.mem.eql(u8, suffix, "i32")) { + break :blk .i32; + } else if (std.mem.eql(u8, suffix, "i64")) { + break :blk .i64; + } else if (std.mem.eql(u8, suffix, "i128")) { + break :blk .i128; + } else if (std.mem.eql(u8, suffix, "f32")) { + break :blk .f32; + } else if (std.mem.eql(u8, suffix, "f64")) { + break :blk .f64; + } else if (std.mem.eql(u8, suffix, "dec")) { + break :blk .dec; + } else { + // TODO: Create a new error type + const expr_idx = try self.env.pushMalformed(Expr.Idx, Diagnostic{ .invalid_num_literal = .{ .region = region } }); + return CanonicalizedExpr{ .idx = expr_idx, .free_vars = null }; } }; - if (type_content) |content| { - const expr_idx = try self.env.addExprAndTypeVar( - .{ .e_int = .{ .value = .{ .bytes = @bitCast(i128_val), .kind = .i128 } } }, - content, - region, - ); - return CanonicalizedExpr{ .idx = expr_idx, .free_vars = null }; - } + // Note that type-checking will ensure that the actual int value + // fits into the provided type + + const expr_idx = try self.env.addExprAndTypeVar( + .{ .e_num = .{ .value = int_value, .kind = num_suffix } }, + .err, + region, + ); + return CanonicalizedExpr{ .idx = expr_idx, .free_vars = null }; } - const is_negative_u1 = @as(u1, @intFromBool(is_negated)); - const is_power_of_2 = @as(u1, @intFromBool(u128_val != 0 and (u128_val & (u128_val - 1)) == 0)); - const is_minimum_signed = is_negative_u1 & is_power_of_2; - const adjusted_val = u128_val - is_minimum_signed; - - const requirements = types.Num.Int.Requirements{ - .sign_needed = is_negated, - .bits_needed = types.Num.Int.BitsNeeded.fromValue(adjusted_val), + // Insert concrete expr + const expr_idx = blk: { + const is_not_base10 = int_base != DEFAULT_BASE; + if (is_not_base10) { + // For non-decimal integers (hex, binary, octal), set as an int + break :blk try self.env.addExprAndTypeVar( + CIR.Expr{ .e_num = .{ + .value = int_value, + .kind = .int_unbound, + } }, + .err, + region, + ); + } else { + // For decimal (base 10), use a num so it can be either Int or Frac + break :blk try self.env.addExprAndTypeVar( + CIR.Expr{ .e_num = .{ + .value = int_value, + .kind = .num_unbound, + } }, + .err, + region, + ); + } }; - const int_requirements = types.Num.IntRequirements{ - .sign_needed = requirements.sign_needed, - .bits_needed = @intCast(@intFromEnum(requirements.bits_needed)), - }; - - // For non-decimal integers (hex, binary, octal), use int_poly directly - // For decimal integers, use num_poly so they can be either Int or Frac - const is_non_decimal = int_base != DEFAULT_BASE; - - // Insert concrete type variable - const type_content = if (is_non_decimal) - Content{ .structure = .{ .num = .{ .int_unbound = int_requirements } } } - else - Content{ .structure = .{ .num = .{ .num_unbound = int_requirements } } }; - - const expr_idx = try self.env.addExprAndTypeVar( - CIR.Expr{ .e_int = .{ .value = CIR.IntValue{ - .bytes = @bitCast(i128_val), - .kind = .i128, - } } }, - type_content, - region, - ); return CanonicalizedExpr{ .idx = expr_idx, .free_vars = null }; }, .frac => |e| { @@ -2201,25 +2647,31 @@ pub fn canonicalizeExpr( }; if (std.mem.eql(u8, suffix, "f32")) { - if (!fitsInF32(f64_val)) { + if (!CIR.fitsInF32(f64_val)) { const expr_idx = try self.env.pushMalformed(Expr.Idx, Diagnostic{ .invalid_num_literal = .{ .region = region } }); return CanonicalizedExpr{ .idx = expr_idx, .free_vars = null }; } const expr_idx = try self.env.addExprAndTypeVar( - .{ .e_frac_f32 = .{ .value = @floatCast(f64_val) } }, - .{ .structure = FlatType{ .num = .{ .frac_precision = .f32 } } }, + .{ .e_frac_f32 = .{ + .value = @floatCast(f64_val), + .has_suffix = true, + } }, + .err, region, ); return CanonicalizedExpr{ .idx = expr_idx, .free_vars = null }; } else if (std.mem.eql(u8, suffix, "f64")) { const expr_idx = try self.env.addExprAndTypeVar( - .{ .e_frac_f64 = .{ .value = f64_val } }, - .{ .structure = FlatType{ .num = .{ .frac_precision = .f64 } } }, + .{ .e_frac_f64 = .{ + .value = f64_val, + .has_suffix = true, + } }, + .err, region, ); return CanonicalizedExpr{ .idx = expr_idx, .free_vars = null }; } else if (std.mem.eql(u8, suffix, "dec")) { - if (!fitsInDec(f64_val)) { + if (!CIR.fitsInDec(f64_val)) { const expr_idx = try self.env.pushMalformed(Expr.Idx, Diagnostic{ .invalid_num_literal = .{ .region = region } }); return CanonicalizedExpr{ .idx = expr_idx, .free_vars = null }; } @@ -2228,8 +2680,11 @@ pub fn canonicalizeExpr( return CanonicalizedExpr{ .idx = expr_idx, .free_vars = null }; }; const expr_idx = try self.env.addExprAndTypeVar( - .{ .e_frac_dec = .{ .value = dec_val } }, - .{ .structure = FlatType{ .num = .{ .frac_precision = .dec } } }, + .{ .e_dec = .{ + .value = dec_val, + .has_suffix = true, + } }, + .err, region, ); return CanonicalizedExpr{ .idx = expr_idx, .free_vars = null }; @@ -2248,38 +2703,31 @@ pub fn canonicalizeExpr( }, }; - // Parse the literal first to get requirements - const requirements = switch (parsed) { - .small => |small_info| small_info.requirements, - .dec => |dec_info| dec_info.requirements, - .f64 => |f64_info| f64_info.requirements, - }; - - const frac_requirements = types.Num.FracRequirements{ - .fits_in_f32 = requirements.fits_in_f32, - .fits_in_dec = requirements.fits_in_dec, - }; - const cir_expr = switch (parsed) { .small => |small_info| CIR.Expr{ .e_dec_small = .{ - .numerator = small_info.numerator, - .denominator_power_of_ten = small_info.denominator_power_of_ten, + .value = .{ + .numerator = small_info.numerator, + .denominator_power_of_ten = small_info.denominator_power_of_ten, + }, + .has_suffix = false, }, }, .dec => |dec_info| CIR.Expr{ - .e_frac_dec = .{ + .e_dec = .{ .value = dec_info.value, + .has_suffix = false, }, }, .f64 => |f64_info| CIR.Expr{ .e_frac_f64 = .{ .value = f64_info.value, + .has_suffix = false, }, }, }; - const expr_idx = try self.env.addExprAndTypeVar(cir_expr, Content{ .structure = .{ .num = .{ .frac_unbound = frac_requirements } } }, region); + const expr_idx = try self.env.addExprAndTypeVar(cir_expr, .err, region); return CanonicalizedExpr{ .idx = expr_idx, .free_vars = null }; }, @@ -2332,16 +2780,9 @@ pub fn canonicalizeExpr( return CanonicalizedExpr{ .idx = expr_idx, .free_vars = null }; } - // Initialize the list's type variable to its first element's CIR Index - // (later steps will unify that type with the other elems' types) - const first_elem_idx = self.env.store.sliceExpr(elems_span)[0]; - const elem_type_var = @as(TypeVar, @enumFromInt(@intFromEnum(first_elem_idx))); const expr_idx = try self.env.addExprAndTypeVar(CIR.Expr{ - .e_list = .{ - .elem_var = elem_type_var, - .elems = elems_span, - }, - }, Content{ .structure = .{ .list = elem_type_var } }, region); + .e_list = .{ .elems = elems_span }, + }, .err, region); const free_vars_slice = self.scratch_free_vars.slice(free_vars_start, self.scratch_free_vars.top()); return CanonicalizedExpr{ .idx = expr_idx, .free_vars = if (free_vars_slice.len > 0) free_vars_slice else null }; @@ -2409,7 +2850,7 @@ pub fn canonicalizeExpr( // of scratch expr idx and cast them to vars const elems_var_range = try self.env.types.appendVars( @ptrCast(@alignCast( - self.env.store.scratch_exprs.slice(scratch_top, self.env.store.scratchExprTop()), + self.env.store.scratch.?.exprs.slice(scratch_top, self.env.store.scratchExprTop()), )), ); @@ -2451,7 +2892,7 @@ pub fn canonicalizeExpr( } // Mark the start of scratch record fields for the record - const scratch_top = self.env.store.scratch_record_fields.top(); + const scratch_top = self.env.store.scratch.?.record_fields.top(); // Track field names to detect duplicates const seen_fields_top = self.scratch_seen_record_fields.top(); @@ -2492,7 +2933,7 @@ pub fn canonicalizeExpr( // Only canonicalize and include non-duplicate fields if (try self.canonicalizeRecordField(field)) |can_field_idx| { - try self.env.store.scratch_record_fields.append(self.env.gpa, can_field_idx); + try self.env.store.scratch.?.record_fields.append(self.env.gpa, can_field_idx); } } else { // TODO: Add diagnostic on duplicate record field @@ -2500,7 +2941,7 @@ pub fn canonicalizeExpr( } else { // Field name couldn't be resolved, still try to canonicalize if (try self.canonicalizeRecordField(field)) |can_field_idx| { - try self.env.store.scratch_record_fields.append(self.env.gpa, can_field_idx); + try self.env.store.scratch.?.record_fields.append(self.env.gpa, can_field_idx); } } } @@ -2556,17 +2997,17 @@ pub fn canonicalizeExpr( // args const gpa = self.env.gpa; - const args_start = self.env.store.scratch_patterns.top(); + const args_start = self.env.store.scratch.?.patterns.top(); for (self.parse_ir.store.patternSlice(e.args)) |arg_pattern_idx| { if (try self.canonicalizePattern(arg_pattern_idx)) |pattern_idx| { - try self.env.store.scratch_patterns.append(gpa, pattern_idx); + try self.env.store.scratch.?.patterns.append(gpa, pattern_idx); } else { const arg = self.parse_ir.store.getPattern(arg_pattern_idx); const arg_region = self.parse_ir.tokenizedRegionToRegion(arg.to_tokenized_region()); const malformed_idx = try self.env.pushMalformed(Pattern.Idx, Diagnostic{ .pattern_arg_invalid = .{ .region = arg_region, } }); - try self.env.store.scratch_patterns.append(gpa, malformed_idx); + try self.env.store.scratch.?.patterns.append(gpa, malformed_idx); } } const args_span = try self.env.store.patternSpanFrom(args_start); @@ -2625,7 +3066,7 @@ pub fn canonicalizeExpr( } const capture_info: Expr.Capture.Span = blk: { - const scratch_start = self.env.store.scratch_captures.top(); + const scratch_start = self.env.store.scratch.?.captures.top(); var cap_it = captures_set.iterator(); while (cap_it.next()) |entry| { const pattern_idx = entry.key_ptr.*; @@ -2639,7 +3080,7 @@ pub fn canonicalizeExpr( .pattern_idx = pattern_idx, .scope_depth = 0, // This is now unused, but kept for struct compatibility. }; - const capture_idx = try self.env.addCaptureAndTypeVar(capture, types.Content{ .flex_var = null }, region); + const capture_idx = try self.env.addCaptureAndTypeVar(capture, types.Content{ .flex = types.Flex.init() }, region); try self.env.store.addScratchCapture(capture_idx); } @@ -2737,7 +3178,7 @@ pub fn canonicalizeExpr( const expr_idx = try self.env.addExprAndTypeVar(Expr{ .e_binop = Expr.Binop.init(op, can_lhs.idx, can_rhs.idx), - }, Content{ .flex_var = null }, region); + }, Content{ .flex = types.Flex.init() }, region); const free_vars_slice = self.scratch_free_vars.slice(free_vars_start, self.scratch_free_vars.top()); return CanonicalizedExpr{ .idx = expr_idx, .free_vars = if (free_vars_slice.len > 0) free_vars_slice else null }; @@ -2762,7 +3203,7 @@ pub fn canonicalizeExpr( // Create unary minus CIR expression const expr_idx = try self.env.addExprAndTypeVar(Expr{ .e_unary_minus = Expr.UnaryMinus.init(can_operand.idx), - }, Content{ .flex_var = null }, region); + }, Content{ .flex = types.Flex.init() }, region); return CanonicalizedExpr{ .idx = expr_idx, .free_vars = can_operand.free_vars }; }, @@ -2773,7 +3214,7 @@ pub fn canonicalizeExpr( // Create unary not CIR expression const expr_idx = try self.env.addExprAndTypeVar(Expr{ .e_unary_not = Expr.UnaryNot.init(can_operand.idx), - }, Content{ .flex_var = null }, region); + }, Content{ .flex = types.Flex.init() }, region); return CanonicalizedExpr{ .idx = expr_idx, .free_vars = can_operand.free_vars }; }, @@ -2825,7 +3266,7 @@ pub fn canonicalizeExpr( .cond = can_cond.idx, .body = can_then.idx, }; - const if_branch_idx = try self.env.addIfBranchAndTypeVar(if_branch, Content{ .flex_var = null }, self.parse_ir.tokenizedRegionToRegion(current_if.region)); + const if_branch_idx = try self.env.addIfBranchAndTypeVar(if_branch, Content{ .flex = types.Flex.init() }, self.parse_ir.tokenizedRegionToRegion(current_if.region)); try self.env.store.addScratchIfBranch(if_branch_idx); // Check if the else clause is another if-then-else @@ -2858,7 +3299,7 @@ pub fn canonicalizeExpr( .branches = branches_span, .final_else = final_else, }, - }, Content{ .flex_var = null }, region); + }, Content{ .flex = types.Flex.init() }, region); // Immediately redirect the if expression's type variable to the first branch's body const first_branch = self.env.store.getIfBranch(branches[0]); @@ -2919,7 +3360,7 @@ pub fn canonicalizeExpr( const branch_pattern_idx = try self.env.addMatchBranchPatternAndTypeVar(Expr.Match.BranchPattern{ .pattern = pattern_idx, .degenerate = false, - }, Content{ .flex_var = null }, alt_pattern_region); + }, Content{ .flex = types.Flex.init() }, alt_pattern_region); try self.env.store.addScratchMatchBranchPattern(branch_pattern_idx); } }, @@ -2939,7 +3380,7 @@ pub fn canonicalizeExpr( const branch_pattern_idx = try self.env.addMatchBranchPatternAndTypeVar(Expr.Match.BranchPattern{ .pattern = pattern_idx, .degenerate = false, - }, Content{ .flex_var = null }, pattern_region); + }, Content{ .flex = types.Flex.init() }, pattern_region); try self.env.store.addScratchMatchBranchPattern(branch_pattern_idx); }, } @@ -2970,7 +3411,7 @@ pub fn canonicalizeExpr( .guard = null, .redundant = @enumFromInt(0), // TODO }, - Content{ .flex_var = null }, + Content{ .flex = types.Flex.init() }, body_region, ); @@ -2993,7 +3434,7 @@ pub fn canonicalizeExpr( }; // Create initial content for the match expression - const initial_content = if (mb_branch_var) |_| Content{ .flex_var = null } else Content{ .err = {} }; + const initial_content = if (mb_branch_var) |_| Content{ .flex = types.Flex.init() } else Content{ .err = {} }; const expr_idx = try self.env.addExprAndTypeVar(CIR.Expr{ .e_match = match_expr }, initial_content, region); // If there is at least 1 branch, then set the root expr to redirect @@ -3014,7 +3455,7 @@ pub fn canonicalizeExpr( // Create debug expression const dbg_expr = try self.env.addExprAndTypeVar(Expr{ .e_dbg = .{ .expr = can_inner.idx, - } }, Content{ .flex_var = null }, region); + } }, Content{ .flex = types.Flex.init() }, region); return CanonicalizedExpr{ .idx = dbg_expr, .free_vars = can_inner.free_vars }; }, @@ -3028,171 +3469,11 @@ pub fn canonicalizeExpr( }, .ellipsis => |e| { const region = self.parse_ir.tokenizedRegionToRegion(e.region); - const ellipsis_expr = try self.env.addExprAndTypeVar(Expr{ .e_ellipsis = .{} }, Content{ .flex_var = null }, region); + const ellipsis_expr = try self.env.addExprAndTypeVar(Expr{ .e_ellipsis = .{} }, Content{ .flex = types.Flex.init() }, region); return CanonicalizedExpr{ .idx = ellipsis_expr, .free_vars = null }; }, .block => |e| { - const region = self.parse_ir.tokenizedRegionToRegion(e.region); - - var last_type_anno: ?StmtTypeAnno = null; - - // Blocks don't introduce function boundaries, but may contain var statements - try self.scopeEnter(self.env.gpa, false); // false = not a function boundary - defer self.scopeExit(self.env.gpa) catch {}; - - // Keep track of the start position for statements - const stmt_start = self.env.store.scratch_statements.top(); - - // TODO Use a temporary scratch space for the block's free variables - // - // I apologize for leaving these AutoHashMapUnmanaged's here ... but it's a workaround - // to land a working closure capture implementation, and we can optimize this later. Forgive me. - var bound_vars = std.AutoHashMapUnmanaged(Pattern.Idx, void){}; - defer bound_vars.deinit(self.env.gpa); - - var captures = std.AutoHashMapUnmanaged(Pattern.Idx, void){}; - defer captures.deinit(self.env.gpa); - - // Canonicalize all statements in the block - const statements = self.parse_ir.store.statementSlice(e.statements); - var last_expr: ?CanonicalizedExpr = null; - - for (statements, 0..) |stmt_idx, i| { - // Check if this is the last statement and if it's an expression - const is_last = (i == statements.len - 1); - const stmt = self.parse_ir.store.getStatement(stmt_idx); - - if (is_last and (stmt == .expr or stmt == .dbg or stmt == .@"return" or stmt == .crash)) { - // For the last expression or debug statement, canonicalize it directly as the final expression - // without adding it as a statement - switch (stmt) { - .expr => |expr_stmt| last_expr = try self.canonicalizeExprOrMalformed(expr_stmt.expr), - .dbg => |dbg_stmt| { - // For final debug statements, canonicalize as debug expression - const debug_region = self.parse_ir.tokenizedRegionToRegion(dbg_stmt.region); - const inner_expr = try self.canonicalizeExprOrMalformed(dbg_stmt.expr); - - // Create debug expression - const dbg_expr = try self.env.addExprAndTypeVarRedirect(Expr{ .e_dbg = .{ - .expr = inner_expr.idx, - } }, ModuleEnv.varFrom(inner_expr.idx), debug_region); - last_expr = CanonicalizedExpr{ .idx = dbg_expr, .free_vars = inner_expr.free_vars }; - }, - .@"return" => |return_stmt| last_expr = try self.canonicalizeExprOrMalformed(return_stmt.expr), - .crash => |crash_stmt| { - // For final debug statements, canonicalize as debug expression - const crash_region = self.parse_ir.tokenizedRegionToRegion(crash_stmt.region); - - // Create crash expression - // Extract string content from the crash expression or create malformed if not string - const crash_expr = blk: { - const msg_expr = self.parse_ir.store.getExpr(crash_stmt.expr); - switch (msg_expr) { - .string => |s| { - // For string literals, we need to extract the actual string parts - const parts = self.parse_ir.store.exprSlice(s.parts); - if (parts.len > 0) { - const first_part = self.parse_ir.store.getExpr(parts[0]); - if (first_part == .string_part) { - const part_text = self.parse_ir.resolve(first_part.string_part.token); - break :blk try self.env.addExprAndTypeVar(Expr{ .e_crash = .{ - .msg = try self.env.insertString(part_text), - } }, .{ .flex_var = null }, crash_region); - } - } - // Fall back to default if we can't extract - break :blk try self.env.addExprAndTypeVar(Expr{ .e_crash = .{ - .msg = try self.env.insertString("crash"), - } }, .{ .flex_var = null }, crash_region); - }, - else => { - // For non-string expressions, create a malformed expression - break :blk try self.env.pushMalformed(Expr.Idx, Diagnostic{ .crash_expects_string = .{ - .region = region, - } }); - }, - } - }; - - last_expr = CanonicalizedExpr{ .idx = crash_expr, .free_vars = null }; - }, - else => unreachable, - } - } else { - // This is a regular statement within the block - const can_stmt_result = try self.canonicalizeStatement(stmt_idx, &last_type_anno); - switch (can_stmt_result) { - .import_stmt => { - // After we process import statements, there's no - // need to include then in the canonicalize IR - }, - .stmt => |can_stmt| { - try self.env.store.addScratchStatement(can_stmt.idx); - - const cir_stmt = self.env.store.getStatement(can_stmt.idx); - switch (cir_stmt) { - .s_decl => |decl| try self.collectBoundVars(decl.pattern, &bound_vars), - .s_var => |var_stmt| try self.collectBoundVars(var_stmt.pattern_idx, &bound_vars), - else => {}, - } - - // Collect free vars from the statement into the block's scratch space - if (can_stmt.free_vars) |fvs| { - for (fvs) |fv| { - if (!bound_vars.contains(fv)) { - try captures.put(self.env.gpa, fv, {}); - } - } - } - }, - } - } - } - - // Determine the final expression - const final_expr = if (last_expr) |can_expr| can_expr else blk: { - // Empty block - create empty record - const expr_idx = try self.env.addExprAndTypeVar(CIR.Expr{ - .e_empty_record = .{}, - }, Content{ .structure = .empty_record }, region); - break :blk CanonicalizedExpr{ .idx = expr_idx, .free_vars = null }; - }; - const final_expr_var = @as(TypeVar, @enumFromInt(@intFromEnum(final_expr.idx))); - - // Add free vars from the final expression to the block's scratch space - if (final_expr.free_vars) |fvs| { - for (fvs) |fv| { - if (!bound_vars.contains(fv)) { - try captures.put(self.env.gpa, fv, {}); - } - } - } - - // Add the actual free variables (captures) to the parent's scratch space - const captures_start = self.scratch_free_vars.top(); - var cap_it = captures.iterator(); - while (cap_it.next()) |entry| { - try self.scratch_free_vars.append(self.env.gpa, entry.key_ptr.*); - } - const captures_slice = self.scratch_free_vars.slice(captures_start, self.scratch_free_vars.top()); - - // Create statement span - const stmt_span = try self.env.store.statementSpanFrom(stmt_start); - - // Create and return block expression - const block_expr = CIR.Expr{ - .e_block = .{ - .stmts = stmt_span, - .final_expr = final_expr.idx, - }, - }; - const block_idx = try self.env.addExprAndTypeVar(block_expr, Content{ .flex_var = null }, region); - const block_var = @as(TypeVar, @enumFromInt(@intFromEnum(block_idx))); - - // Set the root block expr to redirect to the final expr var - try self.env.types.setVarRedirect(block_var, final_expr_var); - - return CanonicalizedExpr{ .idx = block_idx, .free_vars = if (captures_slice.len > 0) captures_slice else null }; + return try self.canonicalizeBlock(e); }, .malformed => |malformed| { // We won't touch this since it's already a parse error. @@ -3246,7 +3527,7 @@ fn canonicalizeTagExpr(self: *Self, e: AST.TagExpr, mb_args: ?AST.Expr.Span, reg // Create a single tag, open tag union for this variable // Use a placeholder ext_var that will be handled during type checking - const ext_var = try self.env.addTypeSlotAndTypeVar(@enumFromInt(0), .{ .flex_var = null }, region, TypeVar); + const ext_var = try self.env.addTypeSlotAndTypeVar(@enumFromInt(0), .{ .flex = types.Flex.init() }, region, TypeVar); const tag = try self.env.types.mkTag(tag_name, @ptrCast(self.env.store.sliceExpr(args_span))); const tag_union = try self.env.types.mkTagUnion(&[_]Tag{tag}, ext_var); @@ -3332,39 +3613,95 @@ fn canonicalizeTagExpr(self: *Self, e: AST.TagExpr, mb_args: ?AST.Expr.Span, reg }, } } else { - // If this is a tag with more than 1 qualifier, then it is an imported - // nominal type where the last qualifier is the type name, then the other - // are the module + // Multi-qualified tag (e.g., Foo.Bar.X or Foo.Bar.Baz.X) + // + // All qualifiers form the type name, with the final segment as the tag name. + // Example: Foo.Bar.Baz.X has type "Foo.Bar.Baz" and tag "X" + // + // To resolve the type, check if the first qualifier matches an imported module name. + // If it does, look up the type in that module; otherwise, look up locally. - // Get the last token of the qualifiers const qualifier_toks = self.parse_ir.store.tokenSlice(e.qualifiers); + const strip_tokens = [_]tokenize.Token.Tag{.NoSpaceDotUpperIdent}; - // Get the type from the last qualifier + // Check if the first qualifier is an imported name + const first_tok_idx = qualifier_toks[0]; + const first_tok_ident = self.parse_ir.tokens.resolveIdentifier(first_tok_idx) orelse unreachable; + const is_imported = self.scopeLookupModule(first_tok_ident) != null; + + // Build the full qualified type name from ALL qualifiers (the tag name is separate in e.token) + // For Foo.Bar.X: qualifiers=[Foo, Bar], token=X, type name="Foo.Bar" const type_tok_idx = qualifier_toks[qualifier_toks.len - 1]; const type_tok_ident = self.parse_ir.tokens.resolveIdentifier(type_tok_idx) orelse unreachable; const type_tok_region = self.parse_ir.tokens.resolve(type_tok_idx); const type_tok_text = self.env.getIdent(type_tok_ident); - // Get the fully resolved module name from all but the last qualifier - const strip_tokens = [_]tokenize.Token.Tag{.NoSpaceDotUpperIdent}; - const module_alias_text = self.parse_ir.resolveQualifiedName( - .{ .span = .{ .start = 0, .len = @intCast(qualifier_toks.len - 2) } }, - qualifier_toks[qualifier_toks.len - 2], + const full_type_name = self.parse_ir.resolveQualifiedName( + e.qualifiers, + qualifier_toks[qualifier_toks.len - 1], &strip_tokens, ); - const module_alias = try self.env.insertIdent(base.Ident.for_text(module_alias_text)); + const full_type_ident = try self.env.insertIdent(base.Ident.for_text(full_type_name)); - // Check if this is a module alias - const module_name = self.scopeLookupModule(module_alias) orelse { - // Module is not in current scope - return CanonicalizedExpr{ .idx = try self.env.pushMalformed(Expr.Idx, CIR.Diagnostic{ .module_not_imported = .{ - .module_name = module_alias, - .region = region, - } }), .free_vars = null }; - }; + if (!is_imported) { + // Local reference: look up the type locally + const nominal_type_decl_stmt_idx = self.scopeLookupTypeDecl(full_type_ident) orelse { + return CanonicalizedExpr{ + .idx = try self.env.pushMalformed(Expr.Idx, Diagnostic{ .undeclared_type = .{ + .name = full_type_ident, + .region = type_tok_region, + } }), + .free_vars = null, + }; + }; + + switch (self.env.store.getStatement(nominal_type_decl_stmt_idx)) { + .s_nominal_decl => { + const expr_idx = try self.env.addExprAndTypeVar(CIR.Expr{ + .e_nominal = .{ + .nominal_type_decl = nominal_type_decl_stmt_idx, + .backing_expr = tag_expr_idx, + .backing_type = .tag, + }, + }, .err, region); + + const free_vars_slice = self.scratch_free_vars.slice(free_vars_start, self.scratch_free_vars.top()); + return CanonicalizedExpr{ + .idx = expr_idx, + .free_vars = if (free_vars_slice.len > 0) free_vars_slice else null, + }; + }, + .s_alias_decl => { + return CanonicalizedExpr{ + .idx = try self.env.pushMalformed(Expr.Idx, Diagnostic{ .type_alias_but_needed_nominal = .{ + .name = full_type_ident, + .region = type_tok_region, + } }), + .free_vars = null, + }; + }, + else => { + const feature = try self.env.insertString("report an error resolved type decl in scope wasn't actually a type decl"); + const malformed_idx = try self.env.pushMalformed(Expr.Idx, Diagnostic{ .not_implemented = .{ + .feature = feature, + .region = Region.zero(), + } }); + return CanonicalizedExpr{ + .idx = malformed_idx, + .free_vars = null, + }; + }, + } + } + + // Import reference: look up the type in the imported file + // For Imported.Foo.Bar.X: module=Imported, type=Foo.Bar, tag=X + // qualifiers=[Imported, Foo, Bar], so type name is built from qualifiers[1..] + + const module_name = self.scopeLookupModule(first_tok_ident).?; // Already checked above const module_name_text = self.env.getIdent(module_name); - // Check if this module is imported in the current scope + // Check if this is imported in the current scope const import_idx = self.scopeLookupImportedModule(module_name_text) orelse { return CanonicalizedExpr{ .idx = try self.env.pushMalformed(Expr.Idx, Diagnostic{ .module_not_imported = .{ .module_name = module_name, @@ -3372,36 +3709,54 @@ fn canonicalizeTagExpr(self: *Self, e: AST.TagExpr, mb_args: ?AST.Expr.Span, reg } }), .free_vars = null }; }; - // Look up the target node index in the module's exposed_nodes - const target_node_idx, const type_content = blk: { + // Build the type name from all qualifiers except the first (module name) + // For Imported.Foo.Bar.X: qualifiers=[Imported, Foo, Bar], type="Foo.Bar" + const type_qualifiers_start = 1; + const type_name = if (qualifier_toks.len > type_qualifiers_start) + self.parse_ir.resolveQualifiedName( + Token.Span{ + .span = DataSpan.init( + e.qualifiers.span.start + type_qualifiers_start, + e.qualifiers.span.len - type_qualifiers_start, + ), + }, + qualifier_toks[qualifier_toks.len - 1], + &strip_tokens, + ) + else + type_tok_text; + const type_name_ident = try self.env.insertIdent(base.Ident.for_text(type_name)); + + // Look up the target node index in the imported file's exposed_nodes + const target_node_idx = blk: { const envs_map = self.module_envs orelse { - break :blk .{ 0, Content.err }; + break :blk 0; }; const module_env = envs_map.get(module_name_text) orelse { - break :blk .{ 0, Content.err }; + break :blk 0; }; - const target_ident = module_env.common.findIdent(type_tok_text) orelse { - // Type is not exposed by the module + const target_ident = module_env.common.findIdent(type_name) orelse { + // Type is not exposed by the imported file return CanonicalizedExpr{ .idx = try self.env.pushMalformed(Expr.Idx, CIR.Diagnostic{ .type_not_exposed = .{ .module_name = module_name, - .type_name = type_tok_ident, + .type_name = type_name_ident, .region = type_tok_region, } }), .free_vars = null }; }; const other_module_node_id = module_env.getExposedNodeIndexById(target_ident) orelse { - // Type is not exposed by the module + // Type is not exposed by the imported file return CanonicalizedExpr{ .idx = try self.env.pushMalformed(Expr.Idx, CIR.Diagnostic{ .type_not_exposed = .{ .module_name = module_name, - .type_name = type_tok_ident, + .type_name = type_name_ident, .region = type_tok_region, } }), .free_vars = null }; }; // Successfully found the target node - break :blk .{ other_module_node_id, Content{ .flex_var = null } }; + break :blk other_module_node_id; }; const expr_idx = try self.env.addExprAndTypeVar(CIR.Expr{ @@ -3411,7 +3766,7 @@ fn canonicalizeTagExpr(self: *Self, e: AST.TagExpr, mb_args: ?AST.Expr.Span, reg .backing_expr = tag_expr_idx, .backing_type = .tag, }, - }, type_content, region); + }, .err, region); const free_vars_slice = self.scratch_free_vars.slice(free_vars_start, self.scratch_free_vars.top()); return CanonicalizedExpr{ @@ -3509,7 +3864,6 @@ fn canonicalizePattern( const trace = tracy.trace(@src()); defer trace.end(); - const gpa = self.env.gpa; switch (self.parse_ir.store.getPattern(ast_pattern_idx)) { .ident => |e| { const region = self.parse_ir.tokenizedRegionToRegion(e.region); @@ -3517,7 +3871,7 @@ fn canonicalizePattern( // Create a Pattern node for our identifier const pattern_idx = try self.env.addPatternAndTypeVar(Pattern{ .assign = .{ .ident = ident_idx, - } }, .{ .flex_var = null }, region); + } }, .err, region); // Introduce the identifier into scope mapping to this pattern node switch (try self.scopeIntroduceInternal(self.env.gpa, .ident, ident_idx, pattern_idx, false, true)) { @@ -3562,7 +3916,7 @@ fn canonicalizePattern( .underscore = {}, }; - const pattern_idx = try self.env.addPatternAndTypeVar(underscore_pattern, Content{ .flex_var = null }, region); + const pattern_idx = try self.env.addPatternAndTypeVar(underscore_pattern, .err, region); return pattern_idx; }, @@ -3636,87 +3990,76 @@ fn canonicalizePattern( } } else @as(i128, @bitCast(u128_val)); + // const is_negative_u1 = @as(u1, @intFromBool(is_negated)); + // const is_power_of_2 = @as(u1, @intFromBool(u128_val != 0 and (u128_val & (u128_val - 1)) == 0)); + // const is_minimum_signed = is_negative_u1 & is_power_of_2; + // const adjusted_val = u128_val - is_minimum_signed; + + // const requirements = types.Num.Int.Requirements{ + // .sign_needed = is_negated, + // .bits_needed = types.Num.Int.BitsNeeded.fromValue(adjusted_val), + // }; + // const int_requirements = types.Num.IntRequirements{ + // .sign_needed = requirements.sign_needed, + // .bits_needed = @intCast(@intFromEnum(requirements.bits_needed)), + // }; + // Calculate requirements based on the value // Special handling for minimum signed values (-128, -32768, etc.) // These are special because they have a power-of-2 magnitude that fits exactly // in their signed type. We report them as needing one less bit to make the // standard "signed types have n-1 usable bits" logic work correctly. if (parsed.suffix) |suffix| { - const type_content = blk: { + // Capture the suffix, if provided + const num_suffix: CIR.NumKind = blk: { if (std.mem.eql(u8, suffix, "u8")) { - if (u128_val > std.math.maxInt(u8)) break :blk null; - break :blk Content{ .structure = FlatType{ .num = Num.int_u8 } }; + break :blk .u8; } else if (std.mem.eql(u8, suffix, "u16")) { - if (u128_val > std.math.maxInt(u16)) break :blk null; - break :blk Content{ .structure = FlatType{ .num = Num.int_u16 } }; + break :blk .u16; } else if (std.mem.eql(u8, suffix, "u32")) { - if (u128_val > std.math.maxInt(u32)) break :blk null; - break :blk Content{ .structure = FlatType{ .num = Num.int_u32 } }; + break :blk .u32; } else if (std.mem.eql(u8, suffix, "u64")) { - if (u128_val > std.math.maxInt(u64)) break :blk null; - break :blk Content{ .structure = FlatType{ .num = Num.int_u64 } }; + break :blk .u64; } else if (std.mem.eql(u8, suffix, "u128")) { - break :blk Content{ .structure = FlatType{ .num = Num.int_u128 } }; + break :blk .u128; } else if (std.mem.eql(u8, suffix, "i8")) { - if (i128_val < std.math.minInt(i8) or i128_val > std.math.maxInt(i8)) break :blk null; - break :blk Content{ .structure = FlatType{ .num = Num.int_i8 } }; + break :blk .i8; } else if (std.mem.eql(u8, suffix, "i16")) { - if (i128_val < std.math.minInt(i16) or i128_val > std.math.maxInt(i16)) break :blk null; - break :blk Content{ .structure = FlatType{ .num = Num.int_i16 } }; + break :blk .i16; } else if (std.mem.eql(u8, suffix, "i32")) { - if (i128_val < std.math.minInt(i32) or i128_val > std.math.maxInt(i32)) break :blk null; - break :blk Content{ .structure = FlatType{ .num = Num.int_i32 } }; + break :blk .i32; } else if (std.mem.eql(u8, suffix, "i64")) { - if (i128_val < std.math.minInt(i64) or i128_val > std.math.maxInt(i64)) break :blk null; - break :blk Content{ .structure = FlatType{ .num = Num.int_i64 } }; + break :blk .i64; } else if (std.mem.eql(u8, suffix, "i128")) { - break :blk Content{ .structure = FlatType{ .num = Num.int_i128 } }; + break :blk .i128; + } else if (std.mem.eql(u8, suffix, "f32")) { + break :blk .f32; + } else if (std.mem.eql(u8, suffix, "f64")) { + break :blk .f64; + } else if (std.mem.eql(u8, suffix, "dec")) { + break :blk .dec; } else { - break :blk null; + // TODO: Create a new error type + return try self.env.pushMalformed(Pattern.Idx, Diagnostic{ .invalid_num_literal = .{ .region = region } }); } }; - - if (type_content) |content| { - const pattern_idx = try self.env.addPatternAndTypeVar( - .{ .int_literal = .{ .value = .{ .bytes = @bitCast(i128_val), .kind = .i128 } } }, - content, - region, - ); - return pattern_idx; - } + const pattern_idx = try self.env.addPatternAndTypeVar( + .{ .num_literal = .{ + .value = .{ .bytes = @bitCast(i128_val), .kind = .i128 }, + .kind = num_suffix, + } }, + .err, + region, + ); + return pattern_idx; } - const is_negative_u1 = @as(u1, @intFromBool(is_negated)); - const is_power_of_2 = @as(u1, @intFromBool(u128_val != 0 and (u128_val & (u128_val - 1)) == 0)); - const is_minimum_signed = is_negative_u1 & is_power_of_2; - const adjusted_val = u128_val - is_minimum_signed; - - const requirements = types.Num.Int.Requirements{ - .sign_needed = is_negated, - .bits_needed = types.Num.Int.BitsNeeded.fromValue(adjusted_val), - }; - - const int_requirements = types.Num.IntRequirements{ - .sign_needed = requirements.sign_needed, - .bits_needed = @intCast(@intFromEnum(requirements.bits_needed)), - }; - - // For non-decimal integers (hex, binary, octal), use int_poly directly - // For decimal integers, use num_poly so they can be either Int or Frac - const is_non_decimal = int_base != DEFAULT_BASE; - - // Insert concrete type variable - const type_content = if (is_non_decimal) - Content{ .structure = .{ .num = .{ .int_unbound = int_requirements } } } - else - Content{ .structure = .{ .num = .{ .num_unbound = int_requirements } } }; - const pattern_idx = try self.env.addPatternAndTypeVar( - Pattern{ .int_literal = .{ .value = CIR.IntValue{ - .bytes = @bitCast(i128_val), - .kind = .i128, - } } }, - type_content, + Pattern{ .num_literal = .{ + .value = CIR.IntValue{ .bytes = @bitCast(i128_val), .kind = .i128 }, + .kind = .num_unbound, + } }, + .err, region, ); return pattern_idx; @@ -3735,25 +4078,25 @@ fn canonicalizePattern( }; if (std.mem.eql(u8, suffix, "f32")) { - if (!fitsInF32(f64_val)) { + if (!CIR.fitsInF32(f64_val)) { const malformed_idx = try self.env.pushMalformed(Pattern.Idx, Diagnostic{ .invalid_num_literal = .{ .region = region } }); return malformed_idx; } const pattern_idx = try self.env.addPatternAndTypeVar( .{ .frac_f32_literal = .{ .value = @floatCast(f64_val) } }, - .{ .structure = FlatType{ .num = .{ .frac_precision = .f32 } } }, + .err, region, ); return pattern_idx; } else if (std.mem.eql(u8, suffix, "f64")) { const pattern_idx = try self.env.addPatternAndTypeVar( .{ .frac_f64_literal = .{ .value = f64_val } }, - .{ .structure = FlatType{ .num = .{ .frac_precision = .f64 } } }, + .err, region, ); return pattern_idx; } else if (std.mem.eql(u8, suffix, "dec")) { - if (!fitsInDec(f64_val)) { + if (!CIR.fitsInDec(f64_val)) { const malformed_idx = try self.env.pushMalformed(Pattern.Idx, Diagnostic{ .invalid_num_literal = .{ .region = region } }); return malformed_idx; } @@ -3762,8 +4105,8 @@ fn canonicalizePattern( return malformed_idx; }; const pattern_idx = try self.env.addPatternAndTypeVar( - .{ .dec_literal = .{ .value = dec_val } }, - .{ .structure = FlatType{ .num = .{ .frac_precision = .dec } } }, + .{ .dec_literal = .{ .value = dec_val, .has_suffix = true } }, + .err, region, ); return pattern_idx; @@ -3779,18 +4122,6 @@ fn canonicalizePattern( }, }; - // Parse the literal first to get requirements - const requirements = switch (parsed) { - .small => |small_info| small_info.requirements, - .dec => |dec_info| dec_info.requirements, - .f64 => |f64_info| f64_info.requirements, - }; - - const frac_requirements = types.Num.FracRequirements{ - .fits_in_f32 = requirements.fits_in_f32, - .fits_in_dec = requirements.fits_in_dec, - }; - // Check for f64 literals which are not allowed in patterns if (parsed == .f64) { const malformed_idx = try self.env.pushMalformed(Pattern.Idx, Diagnostic{ .f64_pattern_literal = .{ @@ -3802,21 +4133,23 @@ fn canonicalizePattern( const cir_pattern = switch (parsed) { .small => |small_info| Pattern{ .small_dec_literal = .{ - .numerator = small_info.numerator, - .denominator_power_of_ten = small_info.denominator_power_of_ten, + .value = .{ + .numerator = small_info.numerator, + .denominator_power_of_ten = small_info.denominator_power_of_ten, + }, + .has_suffix = false, }, }, .dec => |dec_info| Pattern{ .dec_literal = .{ .value = dec_info.value, + .has_suffix = false, }, }, .f64 => unreachable, // Already handled above }; - const pattern_idx = try self.env.addPatternAndTypeVar(cir_pattern, Content{ - .structure = .{ .num = .{ .frac_unbound = frac_requirements } }, - }, region); + const pattern_idx = try self.env.addPatternAndTypeVar(cir_pattern, .err, region); return pattern_idx; }, @@ -3835,7 +4168,7 @@ fn canonicalizePattern( .literal = literal, }, }; - const pattern_idx = try self.env.addPatternAndTypeVar(str_pattern, Content{ .structure = .str }, region); + const pattern_idx = try self.env.addPatternAndTypeVar(str_pattern, .err, region); return pattern_idx; }, @@ -3843,23 +4176,24 @@ fn canonicalizePattern( return try self.canonicalizeSingleQuote(e.region, e.token, Pattern.Idx); }, .tag => |e| { + const gpa = self.env.gpa; const tag_name = self.parse_ir.tokens.resolveIdentifier(e.tag_tok) orelse return null; const tag_name_text = self.parse_ir.env.getIdent(tag_name); const region = self.parse_ir.tokenizedRegionToRegion(e.region); // Canonicalized the tags args - const patterns_start = self.env.store.scratch_patterns.top(); + const patterns_start = self.env.store.scratch.?.patterns.top(); for (self.parse_ir.store.patternSlice(e.args)) |sub_ast_pattern_idx| { if (try self.canonicalizePattern(sub_ast_pattern_idx)) |idx| { - try self.env.store.scratch_patterns.append(gpa, idx); + try self.env.store.scratch.?.patterns.append(gpa, idx); } else { const arg = self.parse_ir.store.getPattern(sub_ast_pattern_idx); const arg_region = self.parse_ir.tokenizedRegionToRegion(arg.to_tokenized_region()); const malformed_idx = try self.env.pushMalformed(Pattern.Idx, Diagnostic{ .pattern_arg_invalid = .{ .region = arg_region, } }); - try self.env.store.scratch_patterns.append(gpa, malformed_idx); + try self.env.store.scratch.?.patterns.append(gpa, malformed_idx); } } const args = try self.env.store.patternSpanFrom(patterns_start); @@ -3867,9 +4201,9 @@ fn canonicalizePattern( // Create the pattern type var first const arg_vars: []TypeVar = @ptrCast(self.env.store.slicePatterns(args)); // We need to create a temporary pattern idx to get the type var - const ext_var = try self.env.addTypeSlotAndTypeVar(@enumFromInt(0), .{ .flex_var = null }, region, TypeVar); + const ext_var = try self.env.addTypeSlotAndTypeVar(@enumFromInt(0), .{ .flex = types.Flex.init() }, region, TypeVar); const tag = try self.env.types.mkTag(tag_name, arg_vars); - const tag_union_type = try self.env.types.mkTagUnion(&[_]Tag{tag}, ext_var); + _ = try self.env.types.mkTagUnion(&[_]Tag{tag}, ext_var); // Create the pattern node with type var const tag_pattern_idx = try self.env.addPatternAndTypeVar(Pattern{ @@ -3877,7 +4211,7 @@ fn canonicalizePattern( .name = tag_name, .args = args, }, - }, tag_union_type, region); + }, .err, region); if (e.qualifiers.span.len == 0) { // Check if this is an unqualified nominal tag (e.g. True or False are in scope unqualified by default) @@ -3982,7 +4316,7 @@ fn canonicalizePattern( }; // Look up the target node index in the module's exposed_nodes - const target_node_idx, const type_content = blk: { + const target_node_idx, _ = blk: { const envs_map = self.module_envs orelse { break :blk .{ 0, Content.err }; }; @@ -4010,7 +4344,7 @@ fn canonicalizePattern( }; // Successfully found the target node - break :blk .{ other_module_node_id, Content{ .flex_var = null } }; + break :blk .{ other_module_node_id, Content{ .flex = types.Flex.init() } }; }; const nominal_pattern_idx = try self.env.addPatternAndTypeVar(CIR.Pattern{ @@ -4020,7 +4354,7 @@ fn canonicalizePattern( .backing_pattern = tag_pattern_idx, .backing_type = .tag, }, - }, type_content, region); + }, .err, region); return nominal_pattern_idx; } @@ -4041,12 +4375,14 @@ fn canonicalizePattern( // For simple destructuring like `{ name, age }`, both label and ident are the same if (field.value) |sub_pattern_idx| { // Handle patterns like `{ name: x }` or `{ address: { city } }` where there's a sub-pattern - const canonicalized_sub_pattern = try self.canonicalizePattern(sub_pattern_idx) orelse { - // If sub-pattern canonicalization fails, return malformed pattern - const malformed_idx = try self.env.pushMalformed(Pattern.Idx, Diagnostic{ .pattern_not_canonicalized = .{ - .region = field_region, - } }); - return malformed_idx; + const canonicalized_sub_pattern = blk: { + break :blk try self.canonicalizePattern(sub_pattern_idx) orelse { + // If sub-pattern canonicalization fails, return malformed pattern + const malformed_idx = try self.env.pushMalformed(Pattern.Idx, Diagnostic{ .pattern_not_canonicalized = .{ + .region = field_region, + } }); + break :blk malformed_idx; + }; }; // Create the RecordDestruct with sub-pattern @@ -4056,12 +4392,12 @@ fn canonicalizePattern( .kind = .{ .SubPattern = canonicalized_sub_pattern }, }; - const destruct_idx = try self.env.addRecordDestructAndTypeVar(record_destruct, .{ .flex_var = null }, field_region); + const destruct_idx = try self.env.addRecordDestructAndTypeVar(record_destruct, .err, field_region); try self.env.store.addScratchRecordDestruct(destruct_idx); } else { // Simple case: Create the RecordDestruct for this field const assign_pattern = Pattern{ .assign = .{ .ident = field_name_ident } }; - const assign_pattern_idx = try self.env.addPatternAndTypeVar(assign_pattern, .{ .flex_var = null }, field_region); + const assign_pattern_idx = try self.env.addPatternAndTypeVar(assign_pattern, .err, field_region); const record_destruct = CIR.Pattern.RecordDestruct{ .label = field_name_ident, @@ -4069,7 +4405,7 @@ fn canonicalizePattern( .kind = .{ .Required = assign_pattern_idx }, }; - const destruct_idx = try self.env.addRecordDestructAndTypeVar(record_destruct, .{ .flex_var = null }, field_region); + const destruct_idx = try self.env.addRecordDestructAndTypeVar(record_destruct, .err, field_region); try self.env.store.addScratchRecordDestruct(destruct_idx); // Introduce the identifier into scope @@ -4114,19 +4450,12 @@ fn canonicalizePattern( // Create span of the new scratch record destructs const destructs_span = try self.env.store.recordDestructSpanFrom(scratch_top); - // Create type variables for the record - // TODO: Remove `var`s from pattern node? - const whole_var = try self.env.addTypeSlotAndTypeVar(@enumFromInt(0), .{ .flex_var = null }, region, TypeVar); - const ext_var = try self.env.addTypeSlotAndTypeVar(@enumFromInt(0), .{ .flex_var = null }, region, TypeVar); - // Create the record destructure pattern const pattern_idx = try self.env.addPatternAndTypeVar(Pattern{ .record_destructure = .{ - .whole_var = whole_var, - .ext_var = ext_var, .destructs = destructs_span, }, - }, .{ .flex_var = null }, region); + }, .err, region); return pattern_idx; }, @@ -4149,24 +4478,17 @@ fn canonicalizePattern( // Create span of the new scratch patterns const patterns_span = try self.env.store.patternSpanFrom(scratch_top); - // Since pattern idx map 1-to-1 to variables, we can get cast the - // slice of and cast them to vars - const elems_var_range = try self.env.types.appendVars( - @ptrCast(@alignCast(self.env.store.slicePatterns(patterns_span))), - ); - const pattern_idx = try self.env.addPatternAndTypeVar(Pattern{ .tuple = .{ .patterns = patterns_span, }, - }, Content{ .structure = FlatType{ - .tuple = types.Tuple{ .elems = elems_var_range }, - } }, region); + }, .err, region); return pattern_idx; }, .list => |e| { const region = self.parse_ir.tokenizedRegionToRegion(e.region); + const gpa = self.env.gpa; // Mark the start of scratch patterns for non-rest patterns only const scratch_top = self.env.store.scratchPatternTop(); @@ -4199,11 +4521,9 @@ fn canonicalizePattern( // Create an assign pattern for the rest variable // Use the region of just the identifier token, not the full rest pattern const name_region = self.parse_ir.tokenizedRegionToRegion(.{ .start = name_tok, .end = name_tok }); - // Note: The rest variable's type will be set later when we know elem_var - // For now, just give it a flex var const assign_idx = try self.env.addPatternAndTypeVar(Pattern{ .assign = .{ .ident = ident_idx, - } }, Content{ .flex_var = null }, name_region); + } }, .err, name_region); // Introduce the identifier into scope switch (try self.scopeIntroduceInternal(self.env.gpa, .ident, ident_idx, assign_idx, false, true)) { @@ -4239,19 +4559,19 @@ fn canonicalizePattern( // Store rest information // The rest_index should be the number of patterns canonicalized so far - const patterns_so_far = self.env.store.scratch_patterns.top() - scratch_top; + const patterns_so_far = self.env.store.scratch.?.patterns.top() - scratch_top; rest_index = @intCast(patterns_so_far); rest_pattern = current_rest_pattern; } else { // Regular pattern - canonicalize it and add to scratch patterns if (try self.canonicalizePattern(pattern_idx)) |canonicalized| { - try self.env.store.scratch_patterns.append(gpa, canonicalized); + try self.env.store.scratch.?.patterns.append(gpa, canonicalized); } else { const pattern_region = self.parse_ir.tokenizedRegionToRegion(ast_pattern.to_tokenized_region()); const malformed_idx = try self.env.pushMalformed(Pattern.Idx, Diagnostic{ .pattern_not_canonicalized = .{ .region = pattern_region, } }); - try self.env.store.scratch_patterns.append(gpa, malformed_idx); + try self.env.store.scratch.?.patterns.append(gpa, malformed_idx); } } } @@ -4261,50 +4581,25 @@ fn canonicalizePattern( // Handle empty list patterns specially if (patterns_span.span.len == 0 and rest_index == null) { - // Empty list pattern - create a simple pattern without elem_var + // Empty list pattern const pattern_idx = try self.env.addPatternAndTypeVar(Pattern{ .list = .{ - .list_var = @enumFromInt(0), // Will be set by addPatternAndTypeVar - .elem_var = @enumFromInt(0), // Not used for empty lists .patterns = patterns_span, .rest_info = null, }, - }, Content{ .structure = .list_unbound }, region); + }, .err, region); return pattern_idx; } - // For non-empty list patterns, use the first pattern's type variable as elem_var - const elem_var: TypeVar = if (patterns_span.span.len > 0) blk: { - const first_pattern_idx = self.env.store.slicePatterns(patterns_span)[0]; - break :blk @enumFromInt(@intFromEnum(first_pattern_idx)); - } else blk: { - // Must be a rest-only pattern like [..] or [.. as rest] - // Create a placeholder pattern for the element type - const placeholder_idx = try self.env.addPatternAndTypeVar(Pattern{ - .underscore = {}, - }, Content{ .flex_var = null }, region); - break :blk @enumFromInt(@intFromEnum(placeholder_idx)); - }; - - // Update rest pattern's type if it exists - if (rest_pattern) |rest_pat| { - // Update the rest pattern's type to be a list of elem_var - const rest_list_type = Content{ .structure = .{ .list = elem_var } }; - _ = try self.env.types.setVarContent(@enumFromInt(@intFromEnum(rest_pat)), rest_list_type); - } - // Create the list pattern with rest info // Set type variable for the pattern - this should be the list type - const list_type = Content{ .structure = .{ .list = elem_var } }; const pattern_idx = try self.env.addPatternAndTypeVar(Pattern{ .list = .{ - .list_var = @enumFromInt(0), // Will be set by addPatternAndTypeVar - .elem_var = elem_var, .patterns = patterns_span, .rest_info = if (rest_index) |idx| .{ .index = idx, .pattern = rest_pattern } else null, }, - }, list_type, region); + }, .err, region); return pattern_idx; }, @@ -4350,7 +4645,7 @@ fn canonicalizePattern( }, }; - const pattern_idx = try self.env.addPatternAndTypeVar(as_pattern, .{ .flex_var = null }, region); + const pattern_idx = try self.env.addPatternAndTypeVar(as_pattern, .err, region); // Introduce the identifier into scope switch (try self.scopeIntroduceInternal(self.env.gpa, .ident, ident_idx, pattern_idx, false, true)) { @@ -4440,25 +4735,6 @@ fn isVarReassignmentAcrossFunctionBoundary(self: *const Self, pattern_idx: Patte return false; } -// Check if the given f64 fits in f32 range (ignoring precision loss) -fn fitsInF32(f64_val: f64) bool { - // Check if it's within the range that f32 can represent. - // This includes normal, subnormal, and zero values. - // (This is a magnitude check, so take the abs value to check - // positive and negative at the same time.) - const abs_val = @abs(f64_val); - return abs_val == 0.0 or (abs_val >= std.math.floatTrueMin(f32) and abs_val <= std.math.floatMax(f32)); -} - -// Check if a float value can be represented accurately in RocDec -fn fitsInDec(value: f64) bool { - // RocDec uses i128 with 18 decimal places - const max_dec_value = 170141183460469231731.0; - const min_dec_value = -170141183460469231731.0; - - return value >= min_dec_value and value <= max_dec_value; -} - // Result type for parsing fractional literals into small, Dec, or f64 const FracLiteralResult = union(enum) { small: struct { @@ -4563,7 +4839,7 @@ fn parseFracLiteral(token_text: []const u8) !FracLiteralResult { .numerator = small.numerator, .denominator_power_of_ten = small.denominator_power_of_ten, .requirements = types.Num.Frac.Requirements{ - .fits_in_f32 = fitsInF32(small_f64_val), + .fits_in_f32 = CIR.fitsInF32(small_f64_val), .fits_in_dec = true, }, }, @@ -4580,7 +4856,7 @@ fn parseFracLiteral(token_text: []const u8) !FracLiteralResult { .numerator = @as(i16, @intFromFloat(rounded)), .denominator_power_of_ten = 0, .requirements = types.Num.Frac.Requirements{ - .fits_in_f32 = fitsInF32(f64_val), + .fits_in_f32 = CIR.fitsInF32(f64_val), .fits_in_dec = true, }, }, @@ -4590,7 +4866,7 @@ fn parseFracLiteral(token_text: []const u8) !FracLiteralResult { // Check if the value can fit in RocDec (whether or not it uses scientific notation) // RocDec uses i128 with 18 decimal places // We need to check if the value is within RocDec's range - if (fitsInDec(f64_val)) { + if (CIR.fitsInDec(f64_val)) { // Convert f64 to RocDec by multiplying by 10^18 const dec_scale = std.math.pow(f64, 10, 18); const scaled_val = f64_val * dec_scale; @@ -4612,7 +4888,7 @@ fn parseFracLiteral(token_text: []const u8) !FracLiteralResult { .f64 = .{ .value = f64_val, .requirements = types.Num.Frac.Requirements{ - .fits_in_f32 = fitsInF32(f64_val), + .fits_in_f32 = CIR.fitsInF32(f64_val), .fits_in_dec = false, }, }, @@ -4630,7 +4906,7 @@ fn parseFracLiteral(token_text: []const u8) !FracLiteralResult { .f64 = .{ .value = f64_val, .requirements = types.Num.Frac.Requirements{ - .fits_in_f32 = fitsInF32(f64_val), + .fits_in_f32 = CIR.fitsInF32(f64_val), .fits_in_dec = false, }, }, @@ -4641,7 +4917,7 @@ fn parseFracLiteral(token_text: []const u8) !FracLiteralResult { .dec = .{ .value = RocDec{ .num = dec_num }, .requirements = types.Num.Frac.Requirements{ - .fits_in_f32 = fitsInF32(f64_val), + .fits_in_f32 = CIR.fitsInF32(f64_val), .fits_in_dec = true, }, }, @@ -4654,7 +4930,7 @@ fn parseFracLiteral(token_text: []const u8) !FracLiteralResult { .f64 = .{ .value = f64_val, .requirements = types.Num.Frac.Requirements{ - .fits_in_f32 = fitsInF32(f64_val), + .fits_in_f32 = CIR.fitsInF32(f64_val), .fits_in_dec = false, }, }, @@ -4914,14 +5190,13 @@ fn canonicalizeTypeAnnoHelp(self: *Self, anno_idx: AST.TypeAnno.Idx, type_anno_c } }); }; // Check if this type variable is in scope - const scope = self.currentScope(); - switch (scope.lookupTypeVar(name_ident)) { + switch (self.scopeLookupTypeVar(name_ident)) { .found => |found_anno_idx| { // Track this type variable for underscore validation try self.scratch_type_var_validation.append(self.env.gpa, name_ident); - return try self.env.addTypeAnnoAndTypeVarRedirect(.{ .ty_var = .{ - .name = name_ident, + return try self.env.addTypeAnnoAndTypeVarRedirect(.{ .rigid_var_lookup = .{ + .ref = found_anno_idx, } }, ModuleEnv.varFrom(found_anno_idx), region); }, .not_found => { @@ -4932,8 +5207,8 @@ fn canonicalizeTypeAnnoHelp(self: *Self, anno_idx: AST.TypeAnno.Idx, type_anno_c // Track this type variable for underscore validation try self.scratch_type_var_validation.append(self.env.gpa, name_ident); - const content = types.Content{ .rigid_var = name_ident }; - const new_anno_idx = try self.env.addTypeAnnoAndTypeVar(.{ .ty_var = .{ + const content = types.Content{ .rigid = types.Rigid.init(name_ident) }; + const new_anno_idx = try self.env.addTypeAnnoAndTypeVar(.{ .rigid_var = .{ .name = name_ident, } }, content, region); @@ -4973,14 +5248,13 @@ fn canonicalizeTypeAnnoHelp(self: *Self, anno_idx: AST.TypeAnno.Idx, type_anno_c }; // Check if this type variable is in scope - const scope = self.currentScope(); - switch (scope.lookupTypeVar(name_ident)) { + switch (self.scopeLookupTypeVar(name_ident)) { .found => |found_anno_idx| { // Track this type variable for underscore validation try self.scratch_type_var_validation.append(self.env.gpa, name_ident); - return try self.env.addTypeAnnoAndTypeVarRedirect(.{ .ty_var = .{ - .name = name_ident, + return try self.env.addTypeAnnoAndTypeVarRedirect(.{ .rigid_var_lookup = .{ + .ref = found_anno_idx, } }, ModuleEnv.varFrom(found_anno_idx), region); }, .not_found => { @@ -4991,8 +5265,8 @@ fn canonicalizeTypeAnnoHelp(self: *Self, anno_idx: AST.TypeAnno.Idx, type_anno_c // Track this type variable for underscore validation try self.scratch_type_var_validation.append(self.env.gpa, name_ident); - const content = types.Content{ .rigid_var = name_ident }; - const new_anno_idx = try self.env.addTypeAnnoAndTypeVar(.{ .ty_var = .{ + const content = types.Content{ .rigid = types.Rigid.init(name_ident) }; + const new_anno_idx = try self.env.addTypeAnnoAndTypeVar(.{ .rigid_var = .{ .name = name_ident, } }, content, region); @@ -5013,7 +5287,7 @@ fn canonicalizeTypeAnnoHelp(self: *Self, anno_idx: AST.TypeAnno.Idx, type_anno_c } }, .ty => |ty| { - return (try self.canonicalizeTypeAnnoBasicType(ty)).anno_idx; + return try self.canonicalizeTypeAnnoBasicType(ty); }, .underscore => |underscore| { type_anno_ctx.found_underscore = true; @@ -5033,7 +5307,7 @@ fn canonicalizeTypeAnnoHelp(self: *Self, anno_idx: AST.TypeAnno.Idx, type_anno_c if (type_anno_ctx.isTypeDeclAndHasUnderscore()) { break :blk types.Content{ .err = {} }; } else { - break :blk types.Content{ .flex_var = null }; + break :blk types.Content{ .flex = types.Flex.init() }; } }; @@ -5078,16 +5352,11 @@ fn canonicalizeTypeAnnoHelp(self: *Self, anno_idx: AST.TypeAnno.Idx, type_anno_c try self.processCollectedTypeVars(); } -const CanonicalizedTypeAnnoBasicType = struct { - anno_idx: TypeAnno.Idx, - mb_local_decl_idx: ?Statement.Idx, -}; - /// Handle basic type lookup (Bool, Str, Num, etc.) fn canonicalizeTypeAnnoBasicType( self: *Self, ty: @TypeOf(@as(AST.TypeAnno, undefined).ty), -) std.mem.Allocator.Error!CanonicalizedTypeAnnoBasicType { +) std.mem.Allocator.Error!TypeAnno.Idx { const trace = tracy.trace(@src()); defer trace.end(); @@ -5101,52 +5370,54 @@ fn canonicalizeTypeAnnoBasicType( const type_name_region = self.parse_ir.tokens.resolve(ty.token); if (qualifier_toks.len == 0) { - // Unqualified type - - // TODO: Check for List, Box, and Str here (since they are primitives) - - const type_decl_idx = self.scopeLookupTypeDecl(type_name_ident) orelse { - // Type not found in scope - issue diagnostic - try self.env.pushDiagnostic(Diagnostic{ .undeclared_type = .{ + // First, check if the type is a builtin type + // There are always automatically in-scope + if (TypeAnno.Builtin.fromBytes(self.env.getIdentText(type_name_ident))) |builtin_type| { + return try self.env.addTypeAnnoAndTypeVar(CIR.TypeAnno{ .lookup = .{ .name = type_name_ident, - .region = type_name_region, - } }); - return .{ .anno_idx = try self.env.addTypeAnnoAndTypeVar(.{ .ty = .{ - .symbol = type_name_ident, - } }, .err, region), .mb_local_decl_idx = null }; - }; - - const type_decl = self.env.store.getStatement(type_decl_idx); - switch (type_decl) { - .s_alias_decl => |_| { - return .{ - .anno_idx = try self.env.addTypeAnnoAndTypeVarRedirect(CIR.TypeAnno{ .ty = .{ - .symbol = type_name_ident, - } }, ModuleEnv.varFrom(type_decl_idx), region), - .mb_local_decl_idx = type_decl_idx, - }; - }, - .s_nominal_decl => |_| { - return .{ - .anno_idx = try self.env.addTypeAnnoAndTypeVarRedirect(CIR.TypeAnno{ .ty = .{ - .symbol = type_name_ident, - } }, ModuleEnv.varFrom(type_decl_idx), region), - .mb_local_decl_idx = type_decl_idx, - }; - }, - else => { - // Since we looked up this type decl from `scopeLookupTypeDecl` - // this state should be impossible - unreachable; - }, + .base = .{ .builtin = builtin_type }, + } }, .err, region); + } else { + // If it's not a builtin, look up in scope + const type_decl_idx = self.scopeLookupTypeDecl(type_name_ident) orelse { + return try self.env.pushMalformed(TypeAnno.Idx, Diagnostic{ .undeclared_type = .{ + .name = type_name_ident, + .region = type_name_region, + } }); + }; + return try self.env.addTypeAnnoAndTypeVar(CIR.TypeAnno{ .lookup = .{ + .name = type_name_ident, + .base = .{ .local = .{ .decl_idx = type_decl_idx } }, + } }, .err, region); } } else { - // This is an external type - - // Get the fully resolved module name + // First, check if this is a qualified name for an associated type (e.g., Foo.Bar) + // Build the full qualified name const strip_tokens = [_]tokenize.Token.Tag{.NoSpaceDotUpperIdent}; + const qualified_prefix = self.parse_ir.resolveQualifiedName( + ty.qualifiers, + ty.token, + &strip_tokens, + ); + const qualified_name_ident = try self.env.insertIdent(base.Ident.for_text(qualified_prefix)); + + // Try looking up the full qualified name in local scope (for associated types) + if (self.scopeLookupTypeDecl(qualified_name_ident)) |type_decl_idx| { + return try self.env.addTypeAnnoAndTypeVar(CIR.TypeAnno{ .lookup = .{ + .name = qualified_name_ident, + .base = .{ .local = .{ .decl_idx = type_decl_idx } }, + } }, .err, region); + } + + // Not a local qualified type, so treat as an external type from a module + // Get qualifiers excluding the last one for module alias + const module_qualifiers: AST.Token.Span = if (qualifier_toks.len > 1) + .{ .span = .{ .start = ty.qualifiers.span.start, .len = @intCast(qualifier_toks.len - 1) } } + else + .{ .span = .{ .start = 0, .len = 0 } }; + const module_alias_text = self.parse_ir.resolveQualifiedName( - .{ .span = .{ .start = 0, .len = @intCast(qualifier_toks.len - 1) } }, + module_qualifiers, qualifier_toks[qualifier_toks.len - 1], &strip_tokens, ); @@ -5155,64 +5426,61 @@ fn canonicalizeTypeAnnoBasicType( // Check if this is a module alias const module_name = self.scopeLookupModule(module_alias) orelse { // Module is not in current scope - return .{ .anno_idx = try self.env.pushMalformed(TypeAnno.Idx, CIR.Diagnostic{ .module_not_imported = .{ + return try self.env.pushMalformed(TypeAnno.Idx, CIR.Diagnostic{ .module_not_imported = .{ .module_name = module_alias, .region = region, - } }), .mb_local_decl_idx = null }; + } }); }; const module_name_text = self.env.getIdent(module_name); // Check if this module is imported in the current scope const import_idx = self.scopeLookupImportedModule(module_name_text) orelse { - return .{ .anno_idx = try self.env.pushMalformed(TypeAnno.Idx, Diagnostic{ .module_not_imported = .{ + return try self.env.pushMalformed(TypeAnno.Idx, Diagnostic{ .module_not_imported = .{ .module_name = module_name, .region = region, - } }), .mb_local_decl_idx = null }; + } }); }; // Look up the target node index in the module's exposed_nodes const type_name_text = self.env.getIdent(type_name_ident); - const target_node_idx, const type_content = blk: { + const target_node_idx = blk: { const envs_map = self.module_envs orelse { - break :blk .{ 0, Content.err }; + break :blk 0; }; const module_env = envs_map.get(module_name_text) orelse { - break :blk .{ 0, Content.err }; + break :blk 0; }; const target_ident = module_env.common.findIdent(type_name_text) orelse { // Type is not exposed by the module - return .{ .anno_idx = try self.env.pushMalformed(TypeAnno.Idx, CIR.Diagnostic{ .type_not_exposed = .{ + return try self.env.pushMalformed(TypeAnno.Idx, CIR.Diagnostic{ .type_not_exposed = .{ .module_name = module_name, .type_name = type_name_ident, .region = type_name_region, - } }), .mb_local_decl_idx = null }; + } }); }; const other_module_node_id = module_env.getExposedNodeIndexById(target_ident) orelse { // Type is not exposed by the module - return .{ .anno_idx = try self.env.pushMalformed(TypeAnno.Idx, CIR.Diagnostic{ .type_not_exposed = .{ + return try self.env.pushMalformed(TypeAnno.Idx, CIR.Diagnostic{ .type_not_exposed = .{ .module_name = module_name, .type_name = type_name_ident, .region = type_name_region, - } }), .mb_local_decl_idx = null }; + } }); }; // Successfully found the target node - break :blk .{ other_module_node_id, Content{ .flex_var = null } }; + break :blk other_module_node_id; }; // Create the ty_lookup_external expression with Import.Idx // Type solving will copy this types from the origin type store into the // this module's type store - return .{ - .anno_idx = try self.env.addTypeAnnoAndTypeVar(CIR.TypeAnno{ .ty_lookup_external = .{ - .module_idx = import_idx, - .target_node_idx = target_node_idx, - } }, type_content, region), - .mb_local_decl_idx = null, - }; + return try self.env.addTypeAnnoAndTypeVar(CIR.TypeAnno{ .lookup = .{ .name = type_name_ident, .base = .{ .external = .{ + .module_idx = import_idx, + .target_node_idx = target_node_idx, + } } } }, .err, region); } } @@ -5235,7 +5503,7 @@ fn canonicalizeTypeAnnoTypeApplication( // Canonicalize the base type first const based_anno_ast = self.parse_ir.store.getTypeAnno(args_slice[0]); - const base_canonicalized = blk: { + const base_anno_idx = blk: { switch (based_anno_ast) { .ty => |ty| { break :blk try self.canonicalizeTypeAnnoBasicType(ty); @@ -5245,7 +5513,7 @@ fn canonicalizeTypeAnnoTypeApplication( }, } }; - const base_anno = self.env.store.getTypeAnno(base_canonicalized.anno_idx); + const base_anno = self.env.store.getTypeAnno(base_anno_idx); // Canonicalize type arguments (skip first which is the type name) const scratch_top = self.env.store.scratchTypeAnnoTop(); @@ -5261,45 +5529,21 @@ fn canonicalizeTypeAnnoTypeApplication( // Then, we must instantiate the type from the base declaration *with* the // user-provided type arugmuments applied switch (base_anno) { - .ty => |ty| { + .lookup => |ty| { if (type_anno_ctx.isTypeDeclAndHasUnderscore()) { - return try self.env.addTypeAnnoAndTypeVar(.{ .apply = .{ - .symbol = ty.symbol, - .args = args_span, - } }, .err, region); + try self.env.pushDiagnostic(Diagnostic{ .underscore_in_type_declaration = .{ + .is_alias = true, + .region = self.env.store.getTypeAnnoRegion(base_anno_idx), + } }); } - const local_decl_idx = base_canonicalized.mb_local_decl_idx orelse { - return try self.env.addTypeAnnoAndTypeVar(.{ .apply = .{ - .symbol = ty.symbol, - .args = args_span, - } }, .err, region); - }; - - return try self.env.addTypeAnnoAndTypeVarRedirect(.{ .apply = .{ - .symbol = ty.symbol, + return try self.env.addTypeAnnoAndTypeVar(.{ .apply = .{ + .name = ty.name, + .base = ty.base, .args = args_span, - } }, ModuleEnv.varFrom(local_decl_idx), region); + } }, .err, region); }, - .ty_lookup_external => |tle| { - if (type_anno_ctx.isTypeDeclAndHasUnderscore()) { - return try self.env.addTypeAnnoAndTypeVar(.{ .apply_external = .{ - .module_idx = tle.module_idx, - .target_node_idx = tle.target_node_idx, - .args = args_span, - } }, .err, region); - } else { - // Set the type to be flex var for now. The type solving phase - // will copy the type from the original module's type store into - // this module's type store - return try self.env.addTypeAnnoAndTypeVar(.{ .apply_external = .{ - .module_idx = tle.module_idx, - .target_node_idx = tle.target_node_idx, - .args = args_span, - } }, .{ .flex_var = null }, region); - } - }, - else => return base_canonicalized.anno_idx, + else => return base_anno_idx, } } @@ -5476,12 +5720,9 @@ fn canonicalizeTypeAnnoTagUnion( const tag_cir_anno = self.env.store.getTypeAnno(canonicalized_tag_idx); const tag = blk: { switch (tag_cir_anno) { - .ty => |ty| { - break :blk try self.env.types.mkTag(ty.symbol, &.{}); - }, - .apply => |apply| { - const args_slice: []TypeVar = @ptrCast(self.env.store.sliceTypeAnnos(apply.args)); - break :blk try self.env.types.mkTag(apply.symbol, args_slice); + .tag => |tag| { + const args_slice: []TypeVar = @ptrCast(self.env.store.sliceTypeAnnos(tag.args)); + break :blk try self.env.types.mkTag(tag.name, args_slice); }, .malformed => { continue; @@ -5557,9 +5798,10 @@ fn canonicalizeTypeAnnoTag( // Create identifier from text if resolution fails try self.env.insertIdent(base.Ident.for_text(self.parse_ir.resolve(ty.token))); - return try self.env.addTypeAnnoAndTypeVar(.{ .ty = .{ - .symbol = ident_idx, - } }, Content{ .flex_var = null }, region); + return try self.env.addTypeAnnoAndTypeVar(.{ .tag = .{ + .name = ident_idx, + .args = .{ .span = DataSpan.empty() }, + } }, .err, region); }, .apply => |apply| { // For tags with arguments like `Some(Str)`, validate the arguments but not the tag name @@ -5591,10 +5833,10 @@ fn canonicalizeTypeAnnoTag( } const args = try self.env.store.typeAnnoSpanFrom(scratch_top); - return try self.env.addTypeAnnoAndTypeVar(.{ .apply = .{ - .symbol = type_name, + return try self.env.addTypeAnnoAndTypeVar(.{ .tag = .{ + .name = type_name, .args = args, - } }, Content{ .flex_var = null }, region); + } }, Content{ .flex = types.Flex.init() }, region); }, else => { return try self.env.pushMalformed(TypeAnno.Idx, Diagnostic{ @@ -5661,7 +5903,7 @@ fn canonicalizeTypeHeader(self: *Self, header_idx: AST.TypeHeader.Idx) std.mem.A return try self.env.addTypeHeaderAndTypeVar(.{ .name = base.Ident.Idx{ .attributes = .{ .effectful = false, .ignored = false, .reassignable = false }, .idx = 0 }, // Invalid identifier .args = .{ .span = .{ .start = 0, .len = 0 } }, - }, Content{ .flex_var = null }, node_region); + }, Content{ .flex = types.Flex.init() }, node_region); } const ast_header = self.parse_ir.store.getTypeHeader(header_idx) catch unreachable; // Malformed handled above @@ -5673,9 +5915,18 @@ fn canonicalizeTypeHeader(self: *Self, header_idx: AST.TypeHeader.Idx) std.mem.A return try self.env.addTypeHeaderAndTypeVar(.{ .name = base.Ident.Idx{ .attributes = .{ .effectful = false, .ignored = false, .reassignable = false }, .idx = 0 }, // Invalid identifier .args = .{ .span = .{ .start = 0, .len = 0 } }, - }, Content{ .flex_var = null }, region); + }, Content{ .flex = types.Flex.init() }, region); }; + // Check if this is a builtin type + // TODO: Can we compare idents or something here? The byte slice comparison is ineffecient + if (TypeAnno.Builtin.fromBytes(self.env.getIdentText(name_ident))) |_| { + return try self.env.pushMalformed(CIR.TypeHeader.Idx, Diagnostic{ .ident_already_in_scope = .{ + .ident = name_ident, + .region = region, + } }); + } + // Canonicalize type arguments - these are parameter declarations, not references const scratch_top = self.env.store.scratchTypeAnnoTop(); defer self.env.store.clearScratchTypeAnnosFrom(scratch_top); @@ -5704,9 +5955,9 @@ fn canonicalizeTypeHeader(self: *Self, header_idx: AST.TypeHeader.Idx) std.mem.A } }); } - const param_anno = try self.env.addTypeAnnoAndTypeVar(.{ .ty_var = .{ + const param_anno = try self.env.addTypeAnnoAndTypeVar(.{ .rigid_var = .{ .name = param_ident, - } }, Content{ .rigid_var = param_ident }, param_region); + } }, Content{ .rigid = types.Rigid.init(param_ident) }, param_region); try self.env.store.addScratchTypeAnno(param_anno); }, .underscore => |underscore_param| { @@ -5740,12 +5991,10 @@ fn canonicalizeTypeHeader(self: *Self, header_idx: AST.TypeHeader.Idx) std.mem.A try self.env.store.addScratchTypeAnno(malformed_anno); }, else => { - // Other types in parameter position - canonicalize normally but warn - try self.env.pushDiagnostic(Diagnostic{ .malformed_type_annotation = .{ + const malformed_anno = try self.env.pushMalformed(TypeAnno.Idx, Diagnostic{ .malformed_type_annotation = .{ .region = node_region, } }); - const canonicalized = try self.canonicalizeTypeAnno(arg_idx, .type_decl_anno); - try self.env.store.addScratchTypeAnno(canonicalized); + try self.env.store.addScratchTypeAnno(malformed_anno); }, } } @@ -5755,162 +6004,245 @@ fn canonicalizeTypeHeader(self: *Self, header_idx: AST.TypeHeader.Idx) std.mem.A return try self.env.addTypeHeaderAndTypeVar(.{ .name = name_ident, .args = args, - }, Content{ .flex_var = null }, region); + }, Content{ .flex = types.Flex.init() }, region); } // expr statements // -// A canonicalized statement -const CanonicalizedStatement = struct { - idx: Statement.Idx, - free_vars: ?[]Pattern.Idx, -}; +fn canonicalizeBlock(self: *Self, e: AST.Block) std.mem.Allocator.Error!CanonicalizedExpr { + const block_region = self.parse_ir.tokenizedRegionToRegion(e.region); -/// A statement type annotation -pub const StmtTypeAnno = struct { - anno_idx: Statement.Idx, - anno: @FieldType(Statement, "s_type_anno"), -}; + // Blocks don't introduce function boundaries, but may contain var statements + try self.scopeEnter(self.env.gpa, false); // false = not a function boundary + defer self.scopeExit(self.env.gpa) catch {}; -// The result of canonicalizing a statement -const CanonicalizedStatementResult = union(enum) { - import_stmt, - stmt: CanonicalizedStatement, -}; + // Keep track of the start position for statements + const stmt_start = self.env.store.scratch.?.statements.top(); -/// Canonicalize a statement in the canonical IR. -/// -/// This always succeed, but the Statement.Idx returned may be null only if the -/// statement was an imported. -pub fn canonicalizeStatement( - self: *Self, - ast_stmt_idx: AST.Statement.Idx, - last_type_anno: *?StmtTypeAnno, -) std.mem.Allocator.Error!CanonicalizedStatementResult { - const trace = tracy.trace(@src()); - defer trace.end(); - - // In many of these branches, we defer setting `last_anno_type` to ensure - // that in the case of early returns, the value is reset properly. + // TODO Use a temporary scratch space for the block's free variables // - // We can't have the `defer` outide the switch branches because not all - // branches should reset `last_type_anno` + // I apologize for leaving these AutoHashMapUnmanaged's here ... but it's a workaround + // to land a working closure capture implementation, and we can optimize this later. Forgive me. + var bound_vars = std.AutoHashMapUnmanaged(Pattern.Idx, void){}; + defer bound_vars.deinit(self.env.gpa); - const ast_stmt = self.parse_ir.store.getStatement(ast_stmt_idx); - switch (ast_stmt) { - .decl => |d| { - defer last_type_anno.* = null; // See above comment for why this is necessary - const region = self.parse_ir.tokenizedRegionToRegion(d.region); + var captures = std.AutoHashMapUnmanaged(Pattern.Idx, void){}; + defer captures.deinit(self.env.gpa); - // Check if this is a var reassignment - const ast_pattern = self.parse_ir.store.getPattern(d.pattern); - switch (ast_pattern) { - .ident => |pattern_ident| { - const ident_region = self.parse_ir.tokenizedRegionToRegion(pattern_ident.region); - const ident_tok = pattern_ident.ident_tok; + // Canonicalize all statements in the block + const ast_stmt_idxs = self.parse_ir.store.statementSlice(e.statements); + var last_expr: ?CanonicalizedExpr = null; - if (self.parse_ir.tokens.resolveIdentifier(ident_tok)) |ident_idx| { - // Check if this identifier exists and is a var - switch (self.scopeLookup(.ident, ident_idx)) { - .found => |existing_pattern_idx| { - // Check if this is a var reassignment across function boundaries - if (self.isVarReassignmentAcrossFunctionBoundary(existing_pattern_idx)) { - // Generate error for var reassignment across function boundary - const malformed_idx = try self.env.pushMalformed(Expr.Idx, Diagnostic{ .var_across_function_boundary = .{ - .region = ident_region, - } }); + var i: u32 = 0; + while (i < ast_stmt_idxs.len) : (i += 1) { + const ast_stmt_idx = ast_stmt_idxs[i]; + const ast_stmt = self.parse_ir.store.getStatement(ast_stmt_idx); - // Create a reassign statement with the error expression - const reassign_idx = try self.env.addStatementAndTypeVarRedirect(Statement{ .s_reassign = .{ - .pattern_idx = existing_pattern_idx, - .expr = malformed_idx, - } }, ModuleEnv.varFrom(malformed_idx), ident_region); + // Check if this is the last statement and if it's an expression + const is_last = (i == ast_stmt_idxs.len - 1); + if (is_last and (ast_stmt == .expr or ast_stmt == .dbg or ast_stmt == .@"return" or ast_stmt == .crash)) { + // If the last statement is expr, debg, return or crash, then we + // canonicalize the expr directly without adding it as a statement + switch (ast_stmt) { + .expr => |expr_stmt| { + // + last_expr = try self.canonicalizeExprOrMalformed(expr_stmt.expr); + }, + .dbg => |dbg_stmt| { + // For final debug statements, canonicalize as debug expression + const debug_region = self.parse_ir.tokenizedRegionToRegion(dbg_stmt.region); + const inner_expr = try self.canonicalizeExprOrMalformed(dbg_stmt.expr); - return .{ - .stmt = CanonicalizedStatement{ .idx = reassign_idx, .free_vars = null }, - }; - } - - // Check if this was declared as a var - if (self.isVarPattern(existing_pattern_idx)) { - // This is a var reassignment - canonicalize the expression and create reassign statement - const expr = try self.canonicalizeExprOrMalformed(d.body); - - // Create reassign statement - const reassign_idx = try self.env.addStatementAndTypeVarRedirect(Statement{ .s_reassign = .{ - .pattern_idx = existing_pattern_idx, - .expr = expr.idx, - } }, ModuleEnv.varFrom(expr.idx), ident_region); - - return .{ - .stmt = CanonicalizedStatement{ .idx = reassign_idx, .free_vars = expr.free_vars }, - }; + // Create debug expression + const dbg_expr = try self.env.addExprAndTypeVarRedirect(Expr{ .e_dbg = .{ + .expr = inner_expr.idx, + } }, ModuleEnv.varFrom(inner_expr.idx), debug_region); + last_expr = CanonicalizedExpr{ .idx = dbg_expr, .free_vars = inner_expr.free_vars }; + }, + .@"return" => |return_stmt| { + last_expr = try self.canonicalizeExprOrMalformed(return_stmt.expr); + }, + .crash => |crash_stmt| { + // For final debug statements, canonicalize as debug expression + const crash_region = self.parse_ir.tokenizedRegionToRegion(crash_stmt.region); + + // Create crash expression + // Extract string content from the crash expression or create malformed if not string + const crash_expr = blk: { + const msg_expr = self.parse_ir.store.getExpr(crash_stmt.expr); + switch (msg_expr) { + .string => |s| { + // For string literals, we need to extract the actual string parts + const parts = self.parse_ir.store.exprSlice(s.parts); + if (parts.len > 0) { + const first_part = self.parse_ir.store.getExpr(parts[0]); + if (first_part == .string_part) { + const part_text = self.parse_ir.resolve(first_part.string_part.token); + break :blk try self.env.addExprAndTypeVar(Expr{ .e_crash = .{ + .msg = try self.env.insertString(part_text), + } }, .{ .flex = types.Flex.init() }, crash_region); + } } + // Fall back to default if we can't extract + break :blk try self.env.addExprAndTypeVar(Expr{ .e_crash = .{ + .msg = try self.env.insertString("crash"), + } }, .{ .flex = types.Flex.init() }, crash_region); }, - .not_found => { - // Not found in scope, fall through to regular declaration + else => { + // For non-string expressions, create a malformed expression + break :blk try self.env.pushMalformed(Expr.Idx, Diagnostic{ .crash_expects_string = .{ + .region = block_region, + } }); }, } - } + }; + + last_expr = CanonicalizedExpr{ .idx = crash_expr, .free_vars = null }; }, - else => {}, + else => unreachable, + } + } else { + // Otherwise, this is a normal statement + // + // We process each stmt individually, saving the result in + // mb_canonicailzed_stmt for post-processing + + const stmt_result = try self.canonicalizeBlockStatement(ast_stmt, ast_stmt_idxs, i); + const mb_canonicailzed_stmt = stmt_result.canonicalized_stmt; + + // If we have a second statement (e.g., type annotation), process it too + if (stmt_result.second_canonicalized_stmt) |other_stmt| { + try self.env.store.addScratchStatement(other_stmt.idx); + + // Collect bound variables for the other statement + const cir_other_stmt = self.env.store.getStatement(other_stmt.idx); + switch (cir_other_stmt) { + .s_decl => |decl| try self.collectBoundVars(decl.pattern, &bound_vars), + .s_var => |var_stmt| try self.collectBoundVars(var_stmt.pattern_idx, &bound_vars), + else => {}, + } + + // Collect free vars from the other statement + if (other_stmt.free_vars) |fvs| { + for (fvs) |fv| { + if (!bound_vars.contains(fv)) { + try captures.put(self.env.gpa, fv, {}); + } + } + } + + // Skip the next statement since we processed it + i += 1; } - // check against last anno + // Post processing for the stmt + if (mb_canonicailzed_stmt) |canonicailzed_stmt| { + try self.env.store.addScratchStatement(canonicailzed_stmt.idx); - // Regular declaration - canonicalize as usual - const pattern_idx = try self.canonicalizePattern(d.pattern) orelse blk: { - const pattern = self.parse_ir.store.getPattern(d.pattern); - break :blk try self.env.pushMalformed(Pattern.Idx, Diagnostic{ .expr_not_canonicalized = .{ - .region = self.parse_ir.tokenizedRegionToRegion(pattern.to_tokenized_region()), - } }); - }; + // Collect bound variables for the + const cir_stmt = self.env.store.getStatement(canonicailzed_stmt.idx); + switch (cir_stmt) { + .s_decl => |decl| try self.collectBoundVars(decl.pattern, &bound_vars), + .s_var => |var_stmt| try self.collectBoundVars(var_stmt.pattern_idx, &bound_vars), + else => {}, + } - const expr = try self.canonicalizeExprOrMalformed(d.body); - - // Check if this declaration matches the last type annotation - var annotation_idx: ?Annotation.Idx = null; - if (last_type_anno.*) |anno_info| { - if (ast_pattern == .ident) { - const pattern_ident = ast_pattern.ident; - if (self.parse_ir.tokens.resolveIdentifier(pattern_ident.ident_tok)) |decl_ident| { - if (anno_info.anno.name.idx == decl_ident.idx) { - // This declaration matches the type annotation - const pattern_region = self.parse_ir.tokenizedRegionToRegion(ast_pattern.ident.region); - annotation_idx = try self.createAnnotationFromTypeAnno(anno_info.anno.anno, pattern_region); - - // Clear the annotation since we've used it - last_type_anno.* = null; + // Collect free vars from the statement into the block's scratch space + if (canonicailzed_stmt.free_vars) |fvs| { + for (fvs) |fv| { + if (!bound_vars.contains(fv)) { + try captures.put(self.env.gpa, fv, {}); } } } } + } + } - // Create a declaration statement - const stmt_idx = try self.env.addStatementAndTypeVarRedirect(Statement{ .s_decl = .{ - .pattern = pattern_idx, - .expr = expr.idx, - .anno = annotation_idx, - } }, ModuleEnv.varFrom(expr.idx), region); + // Determine the final expression + const final_expr = if (last_expr) |can_expr| can_expr else blk: { + // Empty block - create empty record + const expr_idx = try self.env.addExprAndTypeVar(CIR.Expr{ + .e_empty_record = .{}, + }, Content{ .structure = .empty_record }, block_region); + break :blk CanonicalizedExpr{ .idx = expr_idx, .free_vars = null }; + }; + const final_expr_var = @as(TypeVar, @enumFromInt(@intFromEnum(final_expr.idx))); - return .{ - .stmt = CanonicalizedStatement{ .idx = stmt_idx, .free_vars = expr.free_vars }, - }; + // Add free vars from the final expression to the block's scratch space + if (final_expr.free_vars) |fvs| { + for (fvs) |fv| { + if (!bound_vars.contains(fv)) { + try captures.put(self.env.gpa, fv, {}); + } + } + } + + // Add the actual free variables (captures) to the parent's scratch space + const captures_start = self.scratch_free_vars.top(); + var cap_it = captures.iterator(); + while (cap_it.next()) |entry| { + try self.scratch_free_vars.append(self.env.gpa, entry.key_ptr.*); + } + const captures_slice = self.scratch_free_vars.slice(captures_start, self.scratch_free_vars.top()); + + // Create statement span + const stmt_span = try self.env.store.statementSpanFrom(stmt_start); + + // Create and return block expression + const block_expr = CIR.Expr{ + .e_block = .{ + .stmts = stmt_span, + .final_expr = final_expr.idx, }, - .@"var" => |v| { - defer last_type_anno.* = null; // See above comment for why this is necessary + }; + const block_idx = try self.env.addExprAndTypeVar(block_expr, Content{ .flex = types.Flex.init() }, block_region); + const block_var = @as(TypeVar, @enumFromInt(@intFromEnum(block_idx))); + + // Set the root block expr to redirect to the final expr var + try self.env.types.setVarRedirect(block_var, final_expr_var); + + return CanonicalizedExpr{ .idx = block_idx, .free_vars = if (captures_slice.len > 0) captures_slice else null }; +} + +const StatementResult = struct { + canonicalized_stmt: ?CanonicalizedStatement, + second_canonicalized_stmt: ?CanonicalizedStatement, +}; + +/// Canonicalize a single statement within a block +/// +/// This function generally processes 1 stmt, but in the case of type +/// annotations, it may ties the following declaration. In this case, the first +/// stmt is the anno & the second is the following decl +/// +/// The stmt may be null if: +/// * the stmt is an import statement, in which case it is processed but not +/// added to CIR +/// * it's a type annotation without a where clause, in which case the anno is +/// simply attached to decl node +pub fn canonicalizeBlockStatement(self: *Self, ast_stmt: AST.Statement, ast_stmt_idxs: []const AST.Statement.Idx, current_index: u32) std.mem.Allocator.Error!StatementResult { + var mb_canonicailzed_stmt: ?CanonicalizedStatement = null; + var mb_second_canonicalized_stmt: ?CanonicalizedStatement = null; + + switch (ast_stmt) { + .decl => |d| { + mb_canonicailzed_stmt = try self.canonicalizeBlockDecl(d, null); + }, + .@"var" => |v| blk: { const region = self.parse_ir.tokenizedRegionToRegion(v.region); // Var declaration - handle specially with function boundary tracking const var_name = self.parse_ir.tokens.resolveIdentifier(v.name) orelse { const feature = try self.env.insertString("resolve var name"); - return .{ .stmt = CanonicalizedStatement{ + mb_canonicailzed_stmt = CanonicalizedStatement{ .idx = try self.env.pushMalformed(Statement.Idx, Diagnostic{ .not_implemented = .{ .feature = feature, .region = region, } }), .free_vars = null, - } }; + }; + break :blk; }; // Canonicalize the initial value @@ -5932,32 +6264,26 @@ pub fn canonicalizeStatement( .expr = expr.idx, } }, ModuleEnv.varFrom(expr.idx), region); - return .{ - .stmt = CanonicalizedStatement{ .idx = stmt_idx, .free_vars = expr.free_vars }, - }; + mb_canonicailzed_stmt = CanonicalizedStatement{ .idx = stmt_idx, .free_vars = expr.free_vars }; }, - .expr => |e| { - defer last_type_anno.* = null; // See above comment for why this is necessary - const region = self.parse_ir.tokenizedRegionToRegion(e.region); + .expr => |e_| { + const region = self.parse_ir.tokenizedRegionToRegion(e_.region); // Expression statement - const expr = try self.canonicalizeExprOrMalformed(e.expr); + const expr = try self.canonicalizeExprOrMalformed(e_.expr); // Create expression statement const stmt_idx = try self.env.addStatementAndTypeVarRedirect(Statement{ .s_expr = .{ .expr = expr.idx, } }, ModuleEnv.varFrom(expr.idx), region); - return .{ - .stmt = CanonicalizedStatement{ .idx = stmt_idx, .free_vars = expr.free_vars }, - }; + mb_canonicailzed_stmt = CanonicalizedStatement{ .idx = stmt_idx, .free_vars = expr.free_vars }; }, .crash => |c| { - defer last_type_anno.* = null; // See above comment for why this is necessary const region = self.parse_ir.tokenizedRegionToRegion(c.region); // Extract string content from the crash expression or create malformed if not string - const msg_literal = blk: { + const mb_msg_literal = blk: { const msg_expr = self.parse_ir.store.getExpr(c.expr); switch (msg_expr) { .string => |s| { @@ -5974,28 +6300,28 @@ pub fn canonicalizeStatement( break :blk try self.env.insertString("crash"); }, else => { - // For non-string expressions, create a malformed expression - const malformed_idx = try self.env.pushMalformed(Statement.Idx, Diagnostic{ .crash_expects_string = .{ - .region = region, - } }); - return .{ - .stmt = CanonicalizedStatement{ .idx = malformed_idx, .free_vars = null }, - }; + break :blk null; }, } }; - // Create crash statement - const stmt_idx = try self.env.addStatementAndTypeVar(Statement{ .s_crash = .{ - .msg = msg_literal, - } }, .err, region); - - return .{ - .stmt = CanonicalizedStatement{ .idx = stmt_idx, .free_vars = null }, + const stmt_idx = blk: { + if (mb_msg_literal) |msg_literal| { + // Create crash statement + break :blk try self.env.addStatementAndTypeVar(Statement{ .s_crash = .{ + .msg = msg_literal, + } }, .err, region); + } else { + // For non-string expressions, create a malformed expression + break :blk try self.env.pushMalformed(Statement.Idx, Diagnostic{ .crash_expects_string = .{ + .region = region, + } }); + } }; + + mb_canonicailzed_stmt = CanonicalizedStatement{ .idx = stmt_idx, .free_vars = null }; }, .dbg => |d| { - defer last_type_anno.* = null; // See above comment for why this is necessary const region = self.parse_ir.tokenizedRegionToRegion(d.region); // Canonicalize the debug expression @@ -6007,28 +6333,22 @@ pub fn canonicalizeStatement( .expr = expr.idx, } }, ModuleEnv.varFrom(expr.idx), region); - return .{ - .stmt = CanonicalizedStatement{ .idx = stmt_idx, .free_vars = expr.free_vars }, - }; + mb_canonicailzed_stmt = CanonicalizedStatement{ .idx = stmt_idx, .free_vars = expr.free_vars }; }, - .expect => |e| { - defer last_type_anno.* = null; // See above comment for why this is necessary - const region = self.parse_ir.tokenizedRegionToRegion(e.region); + .expect => |e_| { + const region = self.parse_ir.tokenizedRegionToRegion(e_.region); // Canonicalize the expect expression - const expr = try self.canonicalizeExprOrMalformed(e.body); + const expr = try self.canonicalizeExprOrMalformed(e_.body); // Create expect statement const stmt_idx = try self.env.addStatementAndTypeVar(Statement{ .s_expect = .{ .body = expr.idx, } }, Content{ .structure = .empty_record }, region); - return .{ - .stmt = CanonicalizedStatement{ .idx = stmt_idx, .free_vars = expr.free_vars }, - }; + mb_canonicailzed_stmt = CanonicalizedStatement{ .idx = stmt_idx, .free_vars = expr.free_vars }; }, .@"return" => |r| { - defer last_type_anno.* = null; // See above comment for why this is necessary const region = self.parse_ir.tokenizedRegionToRegion(r.region); // Canonicalize the return expression @@ -6039,26 +6359,18 @@ pub fn canonicalizeStatement( .expr = expr.idx, } }, ModuleEnv.varFrom(expr.idx), region); - return .{ - .stmt = CanonicalizedStatement{ .idx = stmt_idx, .free_vars = expr.free_vars }, - }; + mb_canonicailzed_stmt = CanonicalizedStatement{ .idx = stmt_idx, .free_vars = expr.free_vars }; }, .type_decl => |s| { - defer last_type_anno.* = null; // See above comment for why this is necessary - // TODO type declarations in statement context const feature = try self.env.insertString("type_decl in statement context"); const malformed_idx = try self.env.pushMalformed(Statement.Idx, Diagnostic{ .not_implemented = .{ .feature = feature, .region = self.parse_ir.tokenizedRegionToRegion(s.region), } }); - return .{ - .stmt = CanonicalizedStatement{ .idx = malformed_idx, .free_vars = null }, - }; + mb_canonicailzed_stmt = CanonicalizedStatement{ .idx = malformed_idx, .free_vars = null }; }, - .type_anno => |ta| { - // Note that we do _not_ defer resetting last_type_anno in this branch - + .type_anno => |ta| blk: { // Type annotation statement const region = self.parse_ir.tokenizedRegionToRegion(ta.region); @@ -6069,19 +6381,25 @@ pub fn canonicalizeStatement( .feature = feature, .region = region, } }); - return .{ - .stmt = CanonicalizedStatement{ .idx = malformed_idx, .free_vars = null }, - }; + mb_canonicailzed_stmt = CanonicalizedStatement{ .idx = malformed_idx, .free_vars = null }; + break :blk; }; // Introduce type variables into scope const type_vars_top: u32 = @intCast(self.scratch_idents.top()); - // Extract type variables from the AST annotation - try self.extractTypeVarIdentsFromASTAnno(ta.anno, type_vars_top); + + // Create new type var scope + const type_var_scope = self.scopeEnterTypeVar(); + defer self.scopeExitTypeVar(type_var_scope); + // Now canonicalize the annotation with type variables in scope const type_anno_idx = try self.canonicalizeTypeAnno(ta.anno, .inline_anno); + + // Extract type variables from the AST annotation + try self.extractTypeVarIdentsFromASTAnno(ta.anno, type_vars_top); + // Canonicalize where clauses if present - const where_clauses = if (ta.where) |where_coll| blk: { + const where_clauses = if (ta.where) |where_coll| inner_blk: { const where_slice = self.parse_ir.store.whereClauseSlice(.{ .span = self.parse_ir.store.getCollection(where_coll).span }); const where_start = self.env.store.scratchWhereClauseTop(); @@ -6093,50 +6411,220 @@ pub fn canonicalizeStatement( const canonicalized_where = try self.canonicalizeWhereClause(where_idx, .inline_anno); try self.env.store.addScratchWhereClause(canonicalized_where); } - break :blk try self.env.store.whereClauseSpanFrom(where_start); + break :inner_blk try self.env.store.whereClauseSpanFrom(where_start); } else null; - // Create a type annotation statement - const type_anno_stmt: @FieldType(Statement, "s_type_anno") = .{ - .name = name_ident, - .anno = type_anno_idx, - .where = where_clauses, - }; - const type_anno_stmt_idx = try self.env.addStatementAndTypeVarRedirect(Statement{ - .s_type_anno = type_anno_stmt, - }, ModuleEnv.varFrom(type_anno_idx), region); - - last_type_anno.* = StmtTypeAnno{ - .anno_idx = type_anno_stmt_idx, - .anno = type_anno_stmt, + // If we have where clauses, create a separate s_type_anno statement + const mb_type_anno_stmt_idx: ?Statement.Idx = inner_blk: { + if (where_clauses != null) { + break :inner_blk try self.env.addStatementAndTypeVarRedirect(Statement{ + .s_type_anno = .{ + .name = name_ident, + .anno = type_anno_idx, + .where = where_clauses, + }, + }, ModuleEnv.varFrom(type_anno_idx), region); + } else { + break :inner_blk null; + } }; - return .{ - .stmt = CanonicalizedStatement{ .idx = type_anno_stmt_idx, .free_vars = null }, - }; + // Set the type annotation stmt if it exists + if (mb_type_anno_stmt_idx) |type_anno_stmt_idx| { + mb_canonicailzed_stmt = CanonicalizedStatement{ .idx = type_anno_stmt_idx, .free_vars = null }; + } + + // Now, check the next stmt to see if it matches this anno + const next_i = current_index + 1; + if (next_i < ast_stmt_idxs.len) { + const next_stmt_id = ast_stmt_idxs[next_i]; + const next_stmt = self.parse_ir.store.getStatement(next_stmt_id); + + switch (next_stmt) { + .decl => |decl| { + // Immediately process the next decl, with the annotation + mb_second_canonicalized_stmt = try self.canonicalizeBlockDecl(decl, TypeAnnoIdent{ + .name = name_ident, + .anno_idx = type_anno_idx, + }); + }, + else => {}, + } + } }, .import => |import_stmt| { - defer last_type_anno.* = null; // See above comment for why this is necessary - // After we process import statements, there's no need to include // then in the canonicalize IR _ = try self.canonicalizeImportStatement(import_stmt); - return .import_stmt; }, else => { - defer last_type_anno.* = null; // See above comment for why this is necessary - // Other statement types not yet implemented const feature = try self.env.insertString("statement type in block"); const malformed_idx = try self.env.pushMalformed(Statement.Idx, Diagnostic{ .not_implemented = .{ .feature = feature, .region = Region.zero(), } }); - return .{ - .stmt = CanonicalizedStatement{ .idx = malformed_idx, .free_vars = null }, - }; + mb_canonicailzed_stmt = CanonicalizedStatement{ .idx = malformed_idx, .free_vars = null }; }, } + + return StatementResult{ .canonicalized_stmt = mb_canonicailzed_stmt, .second_canonicalized_stmt = mb_second_canonicalized_stmt }; +} + +/// Canonicalize a block declarataion +pub fn canonicalizeBlockDecl(self: *Self, d: AST.Statement.Decl, mb_last_anno: ?TypeAnnoIdent) std.mem.Allocator.Error!CanonicalizedStatement { + const region = self.parse_ir.tokenizedRegionToRegion(d.region); + + // Check if this is a var reassignment + const ast_pattern = self.parse_ir.store.getPattern(d.pattern); + switch (ast_pattern) { + .ident => |pattern_ident| { + const ident_region = self.parse_ir.tokenizedRegionToRegion(pattern_ident.region); + const ident_tok = pattern_ident.ident_tok; + + if (self.parse_ir.tokens.resolveIdentifier(ident_tok)) |ident_idx| { + // Check if this identifier exists and is a var + switch (self.scopeLookup(.ident, ident_idx)) { + .found => |existing_pattern_idx| { + // Check if this is a var reassignment across function boundaries + if (self.isVarReassignmentAcrossFunctionBoundary(existing_pattern_idx)) { + // Generate error for var reassignment across function boundary + const malformed_idx = try self.env.pushMalformed(Expr.Idx, Diagnostic{ .var_across_function_boundary = .{ + .region = ident_region, + } }); + + // Create a reassign statement with the error expression + const reassign_idx = try self.env.addStatementAndTypeVarRedirect(Statement{ .s_reassign = .{ + .pattern_idx = existing_pattern_idx, + .expr = malformed_idx, + } }, ModuleEnv.varFrom(malformed_idx), ident_region); + + return CanonicalizedStatement{ .idx = reassign_idx, .free_vars = null }; + } + + // Check if this was declared as a var + if (self.isVarPattern(existing_pattern_idx)) { + // This is a var reassignment - canonicalize the expression and create reassign statement + const expr = try self.canonicalizeExprOrMalformed(d.body); + + // Create reassign statement + const reassign_idx = try self.env.addStatementAndTypeVarRedirect(Statement{ .s_reassign = .{ + .pattern_idx = existing_pattern_idx, + .expr = expr.idx, + } }, ModuleEnv.varFrom(expr.idx), ident_region); + + return CanonicalizedStatement{ .idx = reassign_idx, .free_vars = expr.free_vars }; + } + }, + .not_found => { + // Not found in scope, fall through to regular declaration + }, + } + } + }, + else => {}, + } + + // check against last anno + + // Get the last annotation, if it exists + var mb_validated_anno: ?Annotation.Idx = null; + if (mb_last_anno) |anno_info| { + if (ast_pattern == .ident) { + const pattern_ident = ast_pattern.ident; + if (self.parse_ir.tokens.resolveIdentifier(pattern_ident.ident_tok)) |decl_ident| { + if (anno_info.name.idx == decl_ident.idx) { + // This declaration matches the type annotation + const pattern_region = self.parse_ir.tokenizedRegionToRegion(ast_pattern.to_tokenized_region()); + mb_validated_anno = try self.createAnnotationFromTypeAnno(anno_info.anno_idx, pattern_region); + } + } else { + // TODO: Diagnostic + } + } + } + + // Regular declaration - canonicalize as usual + const pattern_idx = try self.canonicalizePattern(d.pattern) orelse inner_blk: { + const pattern = self.parse_ir.store.getPattern(d.pattern); + break :inner_blk try self.env.pushMalformed(Pattern.Idx, Diagnostic{ .expr_not_canonicalized = .{ + .region = self.parse_ir.tokenizedRegionToRegion(pattern.to_tokenized_region()), + } }); + }; + + // Canonicalize the decl expr + const expr = try self.canonicalizeExprOrMalformed(d.body); + + // Create a declaration statement + const stmt_idx = try self.env.addStatementAndTypeVarRedirect(Statement{ .s_decl = .{ + .pattern = pattern_idx, + .expr = expr.idx, + .anno = mb_validated_anno, + } }, ModuleEnv.varFrom(expr.idx), region); + + return CanonicalizedStatement{ .idx = stmt_idx, .free_vars = expr.free_vars }; +} + +// A canonicalized statement +const CanonicalizedStatement = struct { + idx: Statement.Idx, + free_vars: ?[]Pattern.Idx, +}; + +// special type var scope // + +/// A type variable in scope +const TypeVarScope = struct { + ident: Ident.Idx, + anno_idx: CIR.TypeAnno.Idx, +}; + +/// Marker into the type var scope array, provided on scope enter, used on scope exit +const TypeVarScopeIdx = struct { idx: u32 }; + +/// Enter a type var scope +fn scopeEnterTypeVar(self: *Self) TypeVarScopeIdx { + return .{ .idx = self.type_vars_scope.top() }; +} + +/// Exit a type var scope +fn scopeExitTypeVar(self: *Self, scope_idx: TypeVarScopeIdx) void { + self.type_vars_scope.clearFrom(scope_idx.idx); +} + +/// Result of looking up a type variable +const TypeVarLookupResult = union(enum) { + found: CIR.TypeAnno.Idx, + not_found, +}; + +/// Lookup a type variable in the scope hierarchy +fn scopeLookupTypeVar(self: *const Self, name_ident: Ident.Idx) TypeVarLookupResult { + for (self.type_vars_scope.items.items) |entry| { + if (entry.ident.idx == name_ident.idx) { + return TypeVarLookupResult{ .found = entry.anno_idx }; + } + } + return .not_found; +} + +/// Result of introducing a type variable +const TypeVarIntroduceResult = union(enum) { + success, + already_in_scope: CIR.TypeAnno.Idx, +}; + +/// Introduce a type variable into the current scope +fn scopeIntroduceTypeVar(self: *Self, name_ident: Ident.Idx, type_var_anno: TypeAnno.Idx) std.mem.Allocator.Error!TypeVarIntroduceResult { + // Check if it's already in scope + for (self.type_vars_scope.items.items) |entry| { + if (entry.ident.idx == name_ident.idx) { + return .{ .already_in_scope = entry.anno_idx }; + } + } + + try self.type_vars_scope.append(self.env.gpa, TypeVarScope{ .ident = name_ident, .anno_idx = type_var_anno }); + return .success; } // scope // @@ -6144,11 +6632,24 @@ pub fn canonicalizeStatement( /// Enter a new scope level pub fn scopeEnter(self: *Self, gpa: std.mem.Allocator, is_function_boundary: bool) std.mem.Allocator.Error!void { const scope = Scope.init(is_function_boundary); - try self.scopes.append(gpa, scope); + return try self.scopeAppend(gpa, scope); } /// Exit the current scope level pub fn scopeExit(self: *Self, gpa: std.mem.Allocator) Scope.Error!void { + var popped_scope = try self.scopePop(); + popped_scope.deinit(gpa); +} + +/// Append an existing scope +pub fn scopeAppend(self: *Self, gpa: std.mem.Allocator, scope: Scope) std.mem.Allocator.Error!void { + try self.scopes.append(gpa, scope); +} + +/// Pop scope off the stack. +/// IMPORTANT: Caller owns the returned scope. +/// That is, this function does _not_ deinit the popped scope. +pub fn scopePop(self: *Self) Scope.Error!Scope { if (self.scopes.items.len <= 1) { return Scope.Error.ExitedTopScopeLevel; } @@ -6157,37 +6658,33 @@ pub fn scopeExit(self: *Self, gpa: std.mem.Allocator) Scope.Error!void { const scope = &self.scopes.items[self.scopes.items.len - 1]; try self.checkScopeForUnusedVariables(scope); - var popped_scope: Scope = self.scopes.pop().?; - popped_scope.deinit(gpa); + const popped_scope: Scope = self.scopes.pop().?; + return popped_scope; } /// Get the current scope fn currentScope(self: *Self) *Scope { std.debug.assert(self.scopes.items.len > 0); - return &self.scopes.items[self.scopes.items.len - 1]; + return &self.scopes.items[self.currentScopeIdx()]; +} + +/// Get the current scope +fn currentScopeIdx(self: *Self) usize { + std.debug.assert(self.scopes.items.len > 0); + return self.scopes.items.len - 1; } /// This will be used later for builtins like Num.nan, Num.infinity, etc. pub fn addNonFiniteFloat(self: *Self, value: f64, region: base.Region) !Expr.Idx { - // Dec doesn't have infinity, -infinity, or NaN - const requirements = types.Num.Frac.Requirements{ - .fits_in_f32 = true, - .fits_in_dec = false, - }; - - const frac_requirements = types.Num.FracRequirements{ - .fits_in_f32 = requirements.fits_in_f32, - .fits_in_dec = requirements.fits_in_dec, - }; - // then in the final slot the actual expr is inserted const expr_idx = try self.env.addExprAndTypeVar( CIR.Expr{ .e_frac_f64 = .{ .value = value, + .has_suffix = false, }, }, - Content{ .structure = .{ .num = .{ .frac_unbound = frac_requirements } } }, + .err, region, ); @@ -6222,62 +6719,20 @@ pub fn scopeLookup( comptime item_kind: Scope.ItemKind, name: base.Ident.Idx, ) Scope.LookupResult { - if (self.scopeContains(item_kind, name)) |pattern| { - return Scope.LookupResult{ .found = pattern }; + if (self.scopeContains(item_kind, name)) |found| { + return Scope.LookupResult{ .found = found }; } return Scope.LookupResult{ .not_found = {} }; } -/// Lookup a type variable in the scope hierarchy -fn scopeLookupTypeVar(self: *const Self, name_ident: Ident.Idx) ?TypeAnno.Idx { - // Search from innermost to outermost scope - var i = self.scopes.items.len; - while (i > 0) { - i -= 1; - const scope = &self.scopes.items[i]; - - switch (scope.lookupTypeVar(name_ident)) { - .found => |type_var_idx| return type_var_idx, - .not_found => continue, - } - } - return null; -} - -/// Introduce a type variable into the current scope -fn scopeIntroduceTypeVar(self: *Self, name: Ident.Idx, type_var_anno: TypeAnno.Idx) std.mem.Allocator.Error!void { - const gpa = self.env.gpa; - const current_scope = &self.scopes.items[self.scopes.items.len - 1]; - - // Don't use parent lookup function for now - just introduce directly - // Type variable shadowing is allowed in Roc - const result = try current_scope.introduceTypeVar(gpa, name, type_var_anno, null); - - switch (result) { - .success => {}, - .shadowing_warning => |shadowed_type_var_idx| { - // Type variable shadowing is allowed but should produce warning - const original_region = self.env.store.getTypeAnnoRegion(shadowed_type_var_idx); - try self.env.pushDiagnostic(Diagnostic{ .shadowing_warning = .{ - .ident = name, - .region = self.env.store.getTypeAnnoRegion(type_var_anno), - .original_region = original_region, - } }); - }, - .already_in_scope => |_| { - // Type variable already exists in this scope - this is fine for repeated references - }, - } -} - fn introduceTypeParametersFromHeader(self: *Self, header_idx: CIR.TypeHeader.Idx) std.mem.Allocator.Error!void { const header = self.env.store.getTypeHeader(header_idx); // Introduce each type parameter into the current scope for (self.env.store.sliceTypeAnnos(header.args)) |param_idx| { const param = self.env.store.getTypeAnno(param_idx); - if (param == .ty_var) { - try self.scopeIntroduceTypeVar(param.ty_var.name, param_idx); + if (param == .rigid_var) { + _ = try self.scopeIntroduceTypeVar(param.rigid_var.name, param_idx); } } } @@ -6430,7 +6885,7 @@ pub fn scopeIntroduceInternal( } // Check for existing identifier in any scope level for shadowing detection - if (self.scopeContains(item_kind, ident_idx)) |existing_pattern| { + if (self.scopeContains(item_kind, ident_idx)) |existing| { // If it's a var reassignment (not declaration), check function boundaries if (is_var and !is_declaration) { // Find the scope where the var was declared and check for function boundaries @@ -6470,7 +6925,7 @@ pub fn scopeIntroduceInternal( if (found_function_boundary) { // Different function, return error - return Scope.IntroduceResult{ .var_across_function_boundary = existing_pattern }; + return Scope.IntroduceResult{ .var_across_function_boundary = existing }; } else { // Same function, allow reassignment without warning try self.scopes.items[self.scopes.items.len - 1].put(gpa, item_kind, ident_idx, pattern_idx); @@ -6486,7 +6941,7 @@ pub fn scopeIntroduceInternal( // For non-var declarations, we should still report shadowing // Regular shadowing case - produce warning but still introduce try self.scopes.items[self.scopes.items.len - 1].put(gpa, item_kind, ident_idx, pattern_idx); - return Scope.IntroduceResult{ .shadowing_warning = existing_pattern }; + return Scope.IntroduceResult{ .shadowing_warning = existing }; } // Check the current level for duplicates @@ -6553,6 +7008,23 @@ fn checkScopeForUnusedVariables(self: *Self, scope: *const Scope) std.mem.Alloca continue; } + // Skip if this identifier is exposed (implicitly used in type modules) + if (self.env.common.exposed_items.containsById(self.env.gpa, @bitCast(ident_idx))) { + continue; + } + + // Get the pattern to check if it has a different ident than the scope key + // For pattern_identifier nodes, check if the qualified ident is exposed + const node_idx: Node.Idx = @enumFromInt(@intFromEnum(pattern_idx)); + const node = self.env.store.nodes.get(node_idx); + + if (node.tag == .pattern_identifier) { + const assign_ident: base.Ident.Idx = @bitCast(node.data_1); + if (self.env.common.exposed_items.containsById(self.env.gpa, @bitCast(assign_ident))) { + continue; + } + } + // Get the region for this pattern to provide good error location const region = self.env.store.getPatternRegion(pattern_idx); @@ -6708,6 +7180,12 @@ fn scopeLookupTypeDecl(self: *Self, ident_idx: Ident.Idx) ?Statement.Idx { i -= 1; const scope = &self.scopes.items[i]; + // Check for type aliases (unqualified names in associated blocks) + if (scope.lookupTypeAlias(ident_idx)) |aliased_decl| { + return aliased_decl; + } + + // Check regular type declarations switch (scope.lookupTypeDecl(ident_idx)) { .found => |type_decl_idx| return type_decl_idx, .not_found => continue, @@ -6958,7 +7436,7 @@ fn canonicalizeWhereClause(self: *Self, ast_where_idx: AST.WhereClause.Idx, type defer self.env.gpa.free(module_text); const module_name = try self.env.insertIdent(Ident.for_text(module_text)); - const external_type_var = try self.env.addTypeSlotAndTypeVar(@enumFromInt(0), .{ .flex_var = null }, region, TypeVar); + const external_type_var = try self.env.addTypeSlotAndTypeVar(@enumFromInt(0), .{ .flex = types.Flex.init() }, region, TypeVar); const external_decl = try self.createExternalDeclaration(qualified_name, module_name, method_ident, .value, external_type_var, region); return try self.env.addWhereClauseAndTypeVar(WhereClause{ .mod_method = .{ @@ -6967,7 +7445,7 @@ fn canonicalizeWhereClause(self: *Self, ast_where_idx: AST.WhereClause.Idx, type .args = args_span, .ret_anno = ret_anno, .external_decl = external_decl, - } }, .{ .flex_var = null }, region); + } }, .{ .flex = types.Flex.init() }, region); }, .mod_alias => |ma| { const region = self.parse_ir.tokenizedRegionToRegion(ma.region); @@ -7003,14 +7481,14 @@ fn canonicalizeWhereClause(self: *Self, ast_where_idx: AST.WhereClause.Idx, type defer self.env.gpa.free(module_text); const module_name = try self.env.insertIdent(Ident.for_text(module_text)); - const external_type_var = try self.env.addTypeSlotAndTypeVar(@enumFromInt(0), .{ .flex_var = null }, region, TypeVar); + const external_type_var = try self.env.addTypeSlotAndTypeVar(@enumFromInt(0), .{ .flex = types.Flex.init() }, region, TypeVar); const external_decl = try self.createExternalDeclaration(qualified_name, module_name, alias_ident, .type, external_type_var, region); return try self.env.addWhereClauseAndTypeVar(WhereClause{ .mod_alias = .{ .var_name = var_ident, .alias_name = alias_ident, .external_decl = external_decl, - } }, .{ .flex_var = null }, region); + } }, .{ .flex = types.Flex.init() }, region); }, .malformed => |m| { const region = self.parse_ir.tokenizedRegionToRegion(m.region); @@ -7019,19 +7497,20 @@ fn canonicalizeWhereClause(self: *Self, ast_where_idx: AST.WhereClause.Idx, type } }, .err); return try self.env.addWhereClauseAndTypeVar(WhereClause{ .malformed = .{ .diagnostic = diagnostic, - } }, .{ .flex_var = null }, region); + } }, .{ .flex = types.Flex.init() }, region); }, } } /// Handle module-qualified types like Json.Decoder /// Create an annotation from a type annotation -fn createAnnotationFromTypeAnno(self: *Self, type_anno_idx: TypeAnno.Idx, region: Region) std.mem.Allocator.Error!?Annotation.Idx { +fn createAnnotationFromTypeAnno(self: *Self, type_anno_idx: TypeAnno.Idx, region: Region) std.mem.Allocator.Error!Annotation.Idx { const trace = tracy.trace(@src()); defer trace.end(); // Create the annotation structure // TODO: Remove signature field from Annotation + // TODO: Capture where clauses const annotation = CIR.Annotation{ .type_anno = type_anno_idx, .signature = try self.env.addTypeSlotAndTypeVar(@enumFromInt(0), .err, region, TypeVar), @@ -7117,7 +7596,7 @@ fn tryModuleQualifiedLookup(self: *Self, field_access: AST.BinOp) std.mem.Alloca .module_idx = import_idx, .target_node_idx = target_node_idx, .region = region, - } }, Content{ .flex_var = null }, region); + } }, Content{ .flex = types.Flex.init() }, region); return expr_idx; } @@ -7145,7 +7624,7 @@ fn canonicalizeRegularFieldAccess(self: *Self, field_access: AST.BinOp) std.mem. }, }; - const expr_idx = try self.env.addExprAndTypeVar(dot_access_expr, Content{ .flex_var = null }, self.parse_ir.tokenizedRegionToRegion(field_access.region)); + const expr_idx = try self.env.addExprAndTypeVar(dot_access_expr, Content{ .flex = types.Flex.init() }, self.parse_ir.tokenizedRegionToRegion(field_access.region)); return expr_idx; } @@ -7238,6 +7717,186 @@ fn createUnknownIdent(self: *Self) std.mem.Allocator.Error!Ident.Idx { return try self.env.insertIdent(base.Ident.for_text("unknown")); } +const MainFunctionStatus = enum { valid, invalid, not_found }; + +/// Check if this module has a valid main! function (1 argument lambda). +/// Reports an error if main! exists but has the wrong arity. +fn checkMainFunction(self: *Self) std.mem.Allocator.Error!MainFunctionStatus { + const file = self.parse_ir.store.getFile(); + + for (self.parse_ir.store.statementSlice(file.statements)) |stmt_id| { + const stmt = self.parse_ir.store.getStatement(stmt_id); + if (stmt == .decl) { + const decl = stmt.decl; + const pattern = self.parse_ir.store.getPattern(decl.pattern); + if (pattern == .ident) { + const ident_token = pattern.ident.ident_tok; + const ident_idx = self.parse_ir.tokens.resolveIdentifier(ident_token) orelse continue; + const ident_text = self.env.getIdent(ident_idx); + + if (std.mem.eql(u8, ident_text, "main!")) { + const region = self.parse_ir.tokenizedRegionToRegion(decl.region); + const expr = self.parse_ir.store.getExpr(decl.body); + + if (expr == .lambda) { + const lambda = expr.lambda; + const params = self.parse_ir.store.patternSlice(lambda.args); + + if (params.len == 1) { + return .valid; + } else { + try self.env.pushDiagnostic(Diagnostic{ .default_app_wrong_arity = .{ + .arity = @intCast(params.len), + .region = region, + } }); + return .invalid; + } + } + } + } + } + } + + return .not_found; +} + +/// Check if there's a type declaration matching the module name +/// Find the type declaration matching the module name and return its ident +fn findMatchingTypeIdent(self: *Self) ?Ident.Idx { + const file = self.parse_ir.store.getFile(); + const module_name_text = self.env.module_name; + + // Look through all statements for a type declaration matching the module name + for (self.parse_ir.store.statementSlice(file.statements)) |stmt_id| { + const stmt = self.parse_ir.store.getStatement(stmt_id); + if (stmt == .type_decl) { + const type_decl = stmt.type_decl; + // Get the type name from the header + const header = self.parse_ir.store.getTypeHeader(type_decl.header) catch continue; + const type_name_ident = self.parse_ir.tokens.resolveIdentifier(header.name) orelse continue; + const type_name_text = self.env.getIdent(type_name_ident); + + if (std.mem.eql(u8, type_name_text, module_name_text)) { + return type_name_ident; + } + } + } + + return null; +} + +/// Expose all associated items of a type declaration (recursively for nested types) +/// This is used for type modules where all associated items are implicitly exposed +fn exposeAssociatedItems(self: *Self, parent_name: Ident.Idx, type_decl: anytype) std.mem.Allocator.Error!void { + if (type_decl.associated) |assoc| { + for (self.parse_ir.store.statementSlice(assoc.statements)) |assoc_stmt_idx| { + const assoc_stmt = self.parse_ir.store.getStatement(assoc_stmt_idx); + switch (assoc_stmt) { + .type_decl => |nested_type_decl| { + // Get the nested type name + const nested_header = self.parse_ir.store.getTypeHeader(nested_type_decl.header) catch continue; + const nested_ident = self.parse_ir.tokens.resolveIdentifier(nested_header.name) orelse continue; + + // Build qualified name (e.g., "Foo.Bar") + const parent_text = self.env.getIdent(parent_name); + const nested_text = self.env.getIdent(nested_ident); + const qualified_name_str = try std.fmt.allocPrint( + self.env.gpa, + "{s}.{s}", + .{ parent_text, nested_text }, + ); + defer self.env.gpa.free(qualified_name_str); + const qualified_ident = base.Ident.for_text(qualified_name_str); + const qualified_idx = try self.env.insertIdent(qualified_ident); + + // Expose the nested type + try self.env.addExposedById(qualified_idx); + + // Recursively expose its associated items + try self.exposeAssociatedItems(qualified_idx, nested_type_decl); + }, + .decl => |decl| { + // Get the declaration name + const pattern = self.parse_ir.store.getPattern(decl.pattern); + if (pattern == .ident) { + const pattern_ident_tok = pattern.ident.ident_tok; + if (self.parse_ir.tokens.resolveIdentifier(pattern_ident_tok)) |decl_ident| { + // Build qualified name (e.g., "Foo.stuff") + const parent_text = self.env.getIdent(parent_name); + const decl_text = self.env.getIdent(decl_ident); + const qualified_name_str = try std.fmt.allocPrint( + self.env.gpa, + "{s}.{s}", + .{ parent_text, decl_text }, + ); + defer self.env.gpa.free(qualified_name_str); + const qualified_ident = base.Ident.for_text(qualified_name_str); + const qualified_idx = try self.env.insertIdent(qualified_ident); + + // Expose the declaration + try self.env.addExposedById(qualified_idx); + } + } + }, + else => {}, + } + } + } +} + +/// Check if any type declarations exist in the file +fn hasAnyTypeDeclarations(self: *Self) bool { + const file = self.parse_ir.store.getFile(); + + for (self.parse_ir.store.statementSlice(file.statements)) |stmt_id| { + const stmt = self.parse_ir.store.getStatement(stmt_id); + if (stmt == .type_decl) { + return true; + } + } + + return false; +} + +/// Report smart error when neither type module nor default-app is valid (checking mode) +fn reportTypeModuleOrDefaultAppError(self: *Self) std.mem.Allocator.Error!void { + const file = self.parse_ir.store.getFile(); + const module_name_text = self.env.module_name; + const module_name_ident = try self.env.insertIdent(base.Ident.for_text(module_name_text)); + const file_region = self.parse_ir.tokenizedRegionToRegion(file.region); + + // Use heuristic: if there are types declared, assume type module, else assume default-app + if (self.hasAnyTypeDeclarations()) { + // Assume user wanted type module + try self.env.pushDiagnostic(.{ + .type_module_missing_matching_type = .{ + .module_name = module_name_ident, + .region = file_region, + }, + }); + } else { + // Assume user wanted default-app + try self.env.pushDiagnostic(.{ + .default_app_missing_main = .{ + .module_name = module_name_ident, + .region = file_region, + }, + }); + } +} + +/// Report error when trying to execute a plain type module +fn reportExecutionRequiresAppOrDefaultApp(self: *Self) std.mem.Allocator.Error!void { + const file = self.parse_ir.store.getFile(); + const file_region = self.parse_ir.tokenizedRegionToRegion(file.region); + + try self.env.pushDiagnostic(.{ + .execution_requires_app_or_default_app = .{ + .region = file_region, + }, + }); +} + // We write out this giant literal because it's actually annoying to try to // take std.math.minInt(i128), drop the minus sign, and convert it to u128 // all at comptime. Instead we just have a test that verifies its correctness. diff --git a/src/canonicalize/Diagnostic.zig b/src/canonicalize/Diagnostic.zig index e90b18d07f..0998dcd0ba 100644 --- a/src/canonicalize/Diagnostic.zig +++ b/src/canonicalize/Diagnostic.zig @@ -137,6 +137,43 @@ pub const Diagnostic = union(enum) { crash_expects_string: struct { region: Region, }, + type_module_missing_matching_type: struct { + module_name: Ident.Idx, + region: Region, + }, + default_app_missing_main: struct { + module_name: Ident.Idx, + region: Region, + }, + default_app_wrong_arity: struct { + arity: u32, + region: Region, + }, + cannot_import_default_app: struct { + module_name: Ident.Idx, + region: Region, + }, + execution_requires_app_or_default_app: struct { + region: Region, + }, + type_name_case_mismatch: struct { + module_name: Ident.Idx, + type_name: Ident.Idx, + region: Region, + }, + module_header_deprecated: struct { + region: Region, + }, + redundant_expose_main_type: struct { + type_name: Ident.Idx, + module_name: Ident.Idx, + region: Region, + }, + invalid_main_type_rename_in_exposing: struct { + type_name: Ident.Idx, + alias: Ident.Idx, + region: Region, + }, type_alias_redeclared: struct { name: Ident.Idx, original_region: Region, @@ -233,6 +270,15 @@ pub const Diagnostic = union(enum) { .undeclared_type_var => |d| d.region, .type_alias_but_needed_nominal => |d| d.region, .crash_expects_string => |d| d.region, + .type_module_missing_matching_type => |d| d.region, + .default_app_missing_main => |d| d.region, + .default_app_wrong_arity => |d| d.region, + .cannot_import_default_app => |d| d.region, + .execution_requires_app_or_default_app => |d| d.region, + .type_name_case_mismatch => |d| d.region, + .module_header_deprecated => |d| d.region, + .redundant_expose_main_type => |d| d.region, + .invalid_main_type_rename_in_exposing => |d| d.region, .type_alias_redeclared => |d| d.redeclared_region, .nominal_type_redeclared => |d| d.redeclared_region, .type_shadowed_warning => |d| d.region, diff --git a/src/canonicalize/Expression.zig b/src/canonicalize/Expression.zig index 383118a4db..565fc52c0a 100644 --- a/src/canonicalize/Expression.zig +++ b/src/canonicalize/Expression.zig @@ -43,21 +43,25 @@ const Self = Expr; /// An expression in the Roc language. pub const Expr = union(enum) { - /// An integer literal with a specific value. + /// An number literal with a specific value. /// Represents whole numbers in various bases (decimal, hex, octal, binary). /// /// ```roc - /// 42 # Decimal integer + /// 42 # Decimal number /// 0xFF # Hexadecimal integer /// 0o755 # Octal integer /// 0b1010 # Binary integer + /// 42u8 # Decimal number with type suffix + /// 42f32 # Decimal number with type suffix /// ``` - e_int: struct { + e_num: struct { value: CIR.IntValue, + kind: CIR.NumKind, }, /// A 32-bit floating-point literal. e_frac_f32: struct { value: f32, + has_suffix: bool, // If the value had a `f32` suffix }, /// A 64-bit floating-point literal. /// Used for approximate decimal representations when F64 type is explicitly required for increased performance. @@ -68,6 +72,7 @@ pub const Expr = union(enum) { /// ``` e_frac_f64: struct { value: f64, + has_suffix: bool, // If the value had a `f64` suffix }, /// A high-precision decimal literal. /// Used for exact decimal arithmetic without floating-point precision issues. @@ -77,8 +82,9 @@ pub const Expr = union(enum) { /// 3.14159265358979323846 # High precision decimal /// 0.1 + 0.2 # Equals exactly 0.3 (not 0.30000000000000004) /// ``` - e_frac_dec: struct { + e_dec: struct { value: RocDec, + has_suffix: bool, // If the value had a `dec` suffix }, /// A small decimal literal stored as a rational number (numerator/10^denominator). /// Memory-efficient representation for common decimal values. @@ -90,8 +96,8 @@ pub const Expr = union(enum) { /// 42.0 # Stored as numerator=420, denominator_power_of_ten=1 (420/10) /// ``` e_dec_small: struct { - numerator: i16, - denominator_power_of_ten: u8, + value: CIR.SmallDecValue, + has_suffix: bool, // If the value had a `dec` suffix }, // A single segment of a string literal // a single string may be made up of a span sequential segments @@ -127,7 +133,6 @@ pub const Expr = union(enum) { /// ["one", "two", "three"] /// ``` e_list: struct { - elem_var: TypeVar, elems: Expr.Span, }, /// Empty list constant `[]` @@ -162,6 +167,7 @@ pub const Expr = union(enum) { /// This is *only* for calling functions, not for tag application. /// The Tag variant contains any applied values inside it. e_call: struct { + func: Expr.Idx, args: Expr.Span, called_via: CalledVia, }, @@ -466,15 +472,14 @@ pub const Expr = union(enum) { pub fn pushToSExprTree(self: *const @This(), ir: *const ModuleEnv, tree: *SExprTree, expr_idx: Self.Idx) std.mem.Allocator.Error!void { switch (self.*) { - .e_int => |int_expr| { + .e_num => |int_expr| { const begin = tree.beginNode(); - try tree.pushStaticAtom("e-int"); + try tree.pushStaticAtom("e-num"); const region = ir.store.getExprRegion(expr_idx); try ir.appendRegionInfoToSExprTreeFromRegion(tree, region); - const value_i128: i128 = @bitCast(int_expr.value.bytes); var value_buf: [40]u8 = undefined; - const value_str = std.fmt.bufPrint(&value_buf, "{}", .{value_i128}) catch "fmt_error"; + const value_str = int_expr.value.bufPrint(&value_buf) catch unreachable; try tree.pushStringPair("value", value_str); const attrs = tree.beginNode(); @@ -516,7 +521,7 @@ pub const Expr = union(enum) { const attrs = tree.beginNode(); try tree.endNode(begin, attrs); }, - .e_frac_dec => |e| { + .e_dec => |e| { const begin = tree.beginNode(); try tree.pushStaticAtom("e-frac-dec"); const region = ir.store.getExprRegion(expr_idx); @@ -542,15 +547,15 @@ pub const Expr = union(enum) { try ir.appendRegionInfoToSExprTreeFromRegion(tree, region); var num_buf: [32]u8 = undefined; - const num_str = std.fmt.bufPrint(&num_buf, "{}", .{e.numerator}) catch "fmt_error"; + const num_str = std.fmt.bufPrint(&num_buf, "{}", .{e.value.numerator}) catch "fmt_error"; try tree.pushStringPair("numerator", num_str); var denom_buf: [32]u8 = undefined; - const denom_str = std.fmt.bufPrint(&denom_buf, "{}", .{e.denominator_power_of_ten}) catch "fmt_error"; + const denom_str = std.fmt.bufPrint(&denom_buf, "{}", .{e.value.denominator_power_of_ten}) catch "fmt_error"; try tree.pushStringPair("denominator-power-of-ten", denom_str); - const numerator_f64: f64 = @floatFromInt(e.numerator); - const denominator_f64: f64 = std.math.pow(f64, 10, @floatFromInt(e.denominator_power_of_ten)); + const numerator_f64: f64 = @floatFromInt(e.value.numerator); + const denominator_f64: f64 = std.math.pow(f64, 10, @floatFromInt(e.value.denominator_power_of_ten)); const value_f64 = numerator_f64 / denominator_f64; var value_buf: [512]u8 = undefined; @@ -714,12 +719,10 @@ pub const Expr = union(enum) { const all_exprs = ir.store.exprSlice(c.args); - if (all_exprs.len > 0) { - try ir.store.getExpr(all_exprs[0]).pushToSExprTree(ir, tree, all_exprs[0]); - } + try ir.store.getExpr(c.func).pushToSExprTree(ir, tree, c.func); - if (all_exprs.len > 1) { - for (all_exprs[1..]) |arg_idx| { + if (all_exprs.len > 0) { + for (all_exprs[0..]) |arg_idx| { try ir.store.getExpr(arg_idx).pushToSExprTree(ir, tree, arg_idx); } } diff --git a/src/canonicalize/ModuleEnv.zig b/src/canonicalize/ModuleEnv.zig index 1494816062..ca69755de4 100644 --- a/src/canonicalize/ModuleEnv.zig +++ b/src/canonicalize/ModuleEnv.zig @@ -29,6 +29,18 @@ const TypeStore = types_mod.Store; const Self = @This(); +/// The kind of module being canonicalized, set during header processing +pub const ModuleKind = union(enum) { + type_module: Ident.Idx, // Holds the main type identifier for type modules + default_app, + app, + package, + platform, + hosted, + deprecated_module, + malformed, +}; + gpa: std.mem.Allocator, common: CommonEnv, @@ -37,12 +49,16 @@ types: TypeStore, // ===== Module compilation fields ===== // NOTE: These fields are populated during canonicalization and preserved for later use +/// The kind of module (type_module, app, etc.) - set during canonicalization +module_kind: ModuleKind, /// All the definitions in the module (populated by canonicalization) all_defs: CIR.Def.Span, /// All the top-level statements in the module (populated by canonicalization) all_statements: CIR.Statement.Span, /// Definitions that are exported by this module (populated by canonicalization) exports: CIR.Def.Span, +/// All builtin stmts (temporary until module imports are working) +builtin_statements: CIR.Statement.Span, /// All external declarations referenced in this module external_decls: CIR.ExternalDecl.SafeList, /// Store for interned module imports @@ -56,12 +72,32 @@ diagnostics: CIR.Diagnostic.Span, /// Uses an efficient data structure, and provides helpers for storing and retrieving nodes. store: NodeStore, +/// Relocate all pointers in the ModuleEnv by the given offset. +/// This is used when loading a ModuleEnv from shared memory at a different address. +pub fn relocate(self: *Self, offset: isize) void { + // Relocate all sub-structures that contain pointers + self.common.relocate(offset); + self.types.relocate(offset); + self.external_decls.relocate(offset); + self.imports.relocate(offset); + // Note: NodeStore.Serialized.deserialize() handles relocation internally, no separate relocate method needed + + // Relocate the module_name pointer if it's not empty + if (self.module_name.len > 0) { + const old_ptr = @intFromPtr(self.module_name.ptr); + const new_ptr = @as(isize, @intCast(old_ptr)) + offset; + self.module_name.ptr = @ptrFromInt(@as(usize, @intCast(new_ptr))); + } +} + /// Initialize the compilation fields in an existing ModuleEnv pub fn initCIRFields(self: *Self, gpa: std.mem.Allocator, module_name: []const u8) !void { _ = gpa; // unused since we don't create new allocations + self.module_kind = undefined; // Set during canonicalization self.all_defs = .{ .span = .{ .start = 0, .len = 0 } }; self.all_statements = .{ .span = .{ .start = 0, .len = 0 } }; self.exports = .{ .span = .{ .start = 0, .len = 0 } }; + self.builtin_statements = .{ .span = .{ .start = 0, .len = 0 } }; // Note: external_decls already exists from ModuleEnv.init(), so we don't create a new one self.imports = CIR.Import.Store.init(); self.module_name = module_name; @@ -82,9 +118,11 @@ pub fn init(gpa: std.mem.Allocator, source: []const u8) std.mem.Allocator.Error! .gpa = gpa, .common = try CommonEnv.init(gpa, source), .types = try TypeStore.initCapacity(gpa, 2048, 512), + .module_kind = undefined, // Set during canonicalization .all_defs = .{ .span = .{ .start = 0, .len = 0 } }, .all_statements = .{ .span = .{ .start = 0, .len = 0 } }, .exports = .{ .span = .{ .start = 0, .len = 0 } }, + .builtin_statements = .{ .span = .{ .start = 0, .len = 0 } }, .external_decls = try CIR.ExternalDecl.SafeList.initCapacity(gpa, 16), .imports = CIR.Import.Store.init(), .module_name = "", // Will be set later during canonicalization @@ -956,6 +994,331 @@ pub fn diagnosticToReport(self: *Self, diagnostic: CIR.Diagnostic, allocator: st break :blk report; }, + .type_module_missing_matching_type => |data| blk: { + const region_info = self.calcRegionInfo(data.region); + + var report = Report.init(allocator, "TYPE MODULE MISSING MATCHING TYPE", .runtime_error); + + const module_name_bytes = self.getIdent(data.module_name); + const module_name = try report.addOwnedString(module_name_bytes); + + try report.document.addReflowingText("Type modules must have a type declaration matching the module name."); + try report.document.addLineBreak(); + try report.document.addLineBreak(); + + try report.document.addText("This file is named "); + try report.document.addInlineCode(module_name); + try report.document.addReflowingText(".roc, but no top-level type declaration named "); + try report.document.addInlineCode(module_name); + try report.document.addReflowingText(" was found."); + try report.document.addLineBreak(); + try report.document.addLineBreak(); + + try report.document.addReflowingText("Add either:"); + try report.document.addLineBreak(); + const nominal_msg = try std.fmt.allocPrint(allocator, "{s} := ...", .{module_name_bytes}); + defer allocator.free(nominal_msg); + const owned_nominal = try report.addOwnedString(nominal_msg); + try report.document.addInlineCode(owned_nominal); + try report.document.addReflowingText(" (nominal type)"); + try report.document.addLineBreak(); + try report.document.addReflowingText("or:"); + try report.document.addLineBreak(); + const alias_msg = try std.fmt.allocPrint(allocator, "{s} : ...", .{module_name_bytes}); + defer allocator.free(alias_msg); + const owned_alias = try report.addOwnedString(alias_msg); + try report.document.addInlineCode(owned_alias); + try report.document.addReflowingText(" (type alias)"); + try report.document.addLineBreak(); + + const owned_filename = try report.addOwnedString(filename); + try report.document.addSourceRegion( + region_info, + .error_highlight, + owned_filename, + self.getSourceAll(), + self.getLineStartsAll(), + ); + + break :blk report; + }, + .default_app_missing_main => |data| blk: { + const region_info = self.calcRegionInfo(data.region); + + var report = Report.init(allocator, "MISSING MAIN! FUNCTION", .runtime_error); + + try report.document.addReflowingText("Default app modules must have a "); + try report.document.addInlineCode("main!"); + try report.document.addReflowingText(" function."); + try report.document.addLineBreak(); + try report.document.addLineBreak(); + + try report.document.addText("No "); + try report.document.addInlineCode("main!"); + try report.document.addReflowingText(" function was found."); + try report.document.addLineBreak(); + try report.document.addLineBreak(); + + try report.document.addReflowingText("Add a main! function like:"); + try report.document.addLineBreak(); + try report.document.addInlineCode("main! = |arg| { ... }"); + try report.document.addLineBreak(); + + const owned_filename = try report.addOwnedString(filename); + try report.document.addSourceRegion( + region_info, + .error_highlight, + owned_filename, + self.getSourceAll(), + self.getLineStartsAll(), + ); + + break :blk report; + }, + .default_app_wrong_arity => |data| blk: { + const region_info = self.calcRegionInfo(data.region); + + var report = Report.init(allocator, "MAIN! SHOULD TAKE 1 ARGUMENT", .runtime_error); + + try report.document.addInlineCode("main!"); + try report.document.addReflowingText(" is defined but has the wrong number of arguments. "); + try report.document.addInlineCode("main!"); + try report.document.addReflowingText(" should take 1 argument."); + try report.document.addLineBreak(); + try report.document.addLineBreak(); + + const arity_msg = try std.fmt.allocPrint(allocator, "{d}", .{data.arity}); + defer allocator.free(arity_msg); + const owned_arity = try report.addOwnedString(arity_msg); + try report.document.addText("Found "); + try report.document.addInlineCode(owned_arity); + try report.document.addReflowingText(" arguments."); + try report.document.addLineBreak(); + try report.document.addLineBreak(); + + try report.document.addReflowingText("Change it to:"); + try report.document.addLineBreak(); + try report.document.addInlineCode("main! = |arg| { ... }"); + try report.document.addLineBreak(); + + const owned_filename = try report.addOwnedString(filename); + try report.document.addSourceRegion( + region_info, + .error_highlight, + owned_filename, + self.getSourceAll(), + self.getLineStartsAll(), + ); + + break :blk report; + }, + .cannot_import_default_app => |data| blk: { + const region_info = self.calcRegionInfo(data.region); + + var report = Report.init(allocator, "CANNOT IMPORT DEFAULT APP", .runtime_error); + + const module_name_bytes = self.getIdent(data.module_name); + const module_name = try report.addOwnedString(module_name_bytes); + + try report.document.addReflowingText("You cannot import a default app module."); + try report.document.addLineBreak(); + try report.document.addLineBreak(); + + try report.document.addText("The module "); + try report.document.addInlineCode(module_name); + try report.document.addReflowingText(" is a default app module and cannot be imported."); + try report.document.addLineBreak(); + + const owned_filename = try report.addOwnedString(filename); + try report.document.addSourceRegion( + region_info, + .error_highlight, + owned_filename, + self.getSourceAll(), + self.getLineStartsAll(), + ); + + break :blk report; + }, + .execution_requires_app_or_default_app => |data| blk: { + const region_info = self.calcRegionInfo(data.region); + + var report = Report.init(allocator, "EXECUTION REQUIRES APP OR DEFAULT APP", .runtime_error); + + try report.document.addReflowingText("This file cannot be executed because it is not an app or default-app module."); + try report.document.addLineBreak(); + try report.document.addLineBreak(); + + try report.document.addReflowingText("Add either:"); + try report.document.addLineBreak(); + try report.document.addInlineCode("app"); + try report.document.addReflowingText(" header at the top of the file"); + try report.document.addLineBreak(); + try report.document.addReflowingText("or:"); + try report.document.addLineBreak(); + try report.document.addReflowingText("a "); + try report.document.addInlineCode("main!"); + try report.document.addReflowingText(" function with 1 argument (for default-app)"); + try report.document.addLineBreak(); + + const owned_filename = try report.addOwnedString(filename); + try report.document.addSourceRegion( + region_info, + .error_highlight, + owned_filename, + self.getSourceAll(), + self.getLineStartsAll(), + ); + + break :blk report; + }, + .type_name_case_mismatch => |data| blk: { + const region_info = self.calcRegionInfo(data.region); + + var report = Report.init(allocator, "TYPE NAME CASE MISMATCH", .runtime_error); + + const module_name_bytes = self.getIdent(data.module_name); + const module_name = try report.addOwnedString(module_name_bytes); + const type_name_bytes = self.getIdent(data.type_name); + const type_name = try report.addOwnedString(type_name_bytes); + + try report.document.addReflowingText("Type module name must match the type declaration."); + try report.document.addLineBreak(); + try report.document.addLineBreak(); + + try report.document.addText("This file is named "); + try report.document.addInlineCode(module_name); + try report.document.addReflowingText(".roc, but the type is named "); + try report.document.addInlineCode(type_name); + try report.document.addReflowingText("."); + try report.document.addLineBreak(); + try report.document.addLineBreak(); + + try report.document.addReflowingText("Make sure the type name matches the filename exactly (case-sensitive)."); + try report.document.addLineBreak(); + + const owned_filename = try report.addOwnedString(filename); + try report.document.addSourceRegion( + region_info, + .error_highlight, + owned_filename, + self.getSourceAll(), + self.getLineStartsAll(), + ); + + break :blk report; + }, + .module_header_deprecated => |data| blk: { + const region_info = self.calcRegionInfo(data.region); + + var report = Report.init(allocator, "MODULE HEADER DEPRECATED", .warning); + + try report.document.addReflowingText("The "); + try report.document.addInlineCode("module"); + try report.document.addReflowingText(" header is deprecated."); + try report.document.addLineBreak(); + try report.document.addLineBreak(); + + try report.document.addReflowingText("Type modules (headerless files with a top-level type matching the filename) are now the preferred way to define modules."); + try report.document.addLineBreak(); + try report.document.addLineBreak(); + + try report.document.addReflowingText("Remove the "); + try report.document.addInlineCode("module"); + try report.document.addReflowingText(" header and ensure your file defines a type that matches the filename."); + try report.document.addLineBreak(); + + const owned_filename = try report.addOwnedString(filename); + try report.document.addSourceRegion( + region_info, + .warning_highlight, + owned_filename, + self.getSourceAll(), + self.getLineStartsAll(), + ); + + break :blk report; + }, + .redundant_expose_main_type => |data| blk: { + const region_info = self.calcRegionInfo(data.region); + + var report = Report.init(allocator, "REDUNDANT EXPOSE", .warning); + + const type_name_bytes = self.getIdent(data.type_name); + const type_name = try report.addOwnedString(type_name_bytes); + const module_name_bytes = self.getIdent(data.module_name); + const module_name = try report.addOwnedString(module_name_bytes); + + try report.document.addReflowingText("Redundantly exposing "); + try report.document.addInlineCode(type_name); + try report.document.addReflowingText(" when importing "); + try report.document.addInlineCode(module_name); + try report.document.addReflowingText("."); + try report.document.addLineBreak(); + try report.document.addLineBreak(); + + try report.document.addReflowingText("The type "); + try report.document.addInlineCode(type_name); + try report.document.addReflowingText(" is automatically exposed when importing a type module."); + try report.document.addLineBreak(); + try report.document.addLineBreak(); + + try report.document.addReflowingText("Remove "); + try report.document.addInlineCode(type_name); + try report.document.addReflowingText(" from the exposing clause."); + try report.document.addLineBreak(); + + const owned_filename = try report.addOwnedString(filename); + try report.document.addSourceRegion( + region_info, + .warning_highlight, + owned_filename, + self.getSourceAll(), + self.getLineStartsAll(), + ); + + break :blk report; + }, + .invalid_main_type_rename_in_exposing => |data| blk: { + const region_info = self.calcRegionInfo(data.region); + + var report = Report.init(allocator, "INVALID TYPE RENAME", .runtime_error); + + const type_name_bytes = self.getIdent(data.type_name); + const type_name = try report.addOwnedString(type_name_bytes); + const alias_bytes = self.getIdent(data.alias); + const alias = try report.addOwnedString(alias_bytes); + + try report.document.addReflowingText("Cannot rename "); + try report.document.addInlineCode(type_name); + try report.document.addReflowingText(" to "); + try report.document.addInlineCode(alias); + try report.document.addReflowingText(" in the exposing clause."); + try report.document.addLineBreak(); + try report.document.addLineBreak(); + + try report.document.addReflowingText("To rename both the module and its main type, use "); + try report.document.addInlineCode("as"); + try report.document.addReflowingText(" at the module level:"); + try report.document.addLineBreak(); + + const example_msg = try std.fmt.allocPrint(allocator, "import ModuleName as {s}", .{alias_bytes}); + defer allocator.free(example_msg); + const owned_example = try report.addOwnedString(example_msg); + try report.document.addInlineCode(owned_example); + try report.document.addLineBreak(); + + const owned_filename = try report.addOwnedString(filename); + try report.document.addSourceRegion( + region_info, + .error_highlight, + owned_filename, + self.getSourceAll(), + self.getLineStartsAll(), + ); + + break :blk report; + }, else => { // For unhandled diagnostics, create a generic report const diagnostic_name = @tagName(diagnostic); @@ -1001,73 +1364,21 @@ pub fn getSourceLine(self: *const Self, region: Region) ![]const u8 { return self.common.getSourceLine(region); } -/// Serialize this ModuleEnv to the given CompactWriter. -/// IMPORTANT: The returned pointer points to memory inside the writer! -/// Attempting to dereference this pointer or calling any methods on it -/// is illegal behavior! -pub fn serialize( - self: *const Self, - allocator: std.mem.Allocator, - writer: *CompactWriter, -) std.mem.Allocator.Error!*const Self { - // First, write the ModuleEnv struct itself - const offset_self = try writer.appendAlloc(allocator, Self); - - // Then serialize the sub-structures and update the struct - offset_self.* = .{ - .gpa = undefined, // Will be set when deserializing - .common = (try self.common.serialize(allocator, writer)).*, - .types = (try self.types.serialize(allocator, writer)).*, - .all_defs = self.all_defs, - .all_statements = self.all_statements, - .exports = self.exports, - .external_decls = (try self.external_decls.serialize(allocator, writer)).*, - .imports = (try self.imports.serialize(allocator, writer)).*, - .module_name = "", // Will be set when deserializing - .diagnostics = self.diagnostics, - .store = (try self.store.serialize(allocator, writer)).*, - }; - - // set gpa to all zeros, so that what we write to the file is deterministic - @memset(@as([*]u8, @ptrCast(&offset_self.gpa))[0..@sizeOf(@TypeOf(offset_self.gpa))], 0); - - return @constCast(offset_self); -} - -/// Add the given offset to the memory addresses of all pointers in `self`. -/// IMPORTANT: The gpa, source, and module_name fields must be manually set before calling this function. -pub fn relocate(self: *Self, offset: isize) void { - // IMPORTANT: gpa, and module_name are not relocated - they should be set manually before calling relocate - - // Relocate all sub-structures - self.common.relocate(offset); - self.types.relocate(offset); - - // Note: all_defs and all_statements are just spans with numeric values, no pointers to relocate - - self.external_decls.relocate(offset); - // self.imports is deserialized separately, so no need to relocate here - - // Note: module_name is not relocated - it should be set manually - - // Note: diagnostics is just a span with numeric values, no pointers to relocate - - self.store.relocate(offset); -} - /// Serialized representation of ModuleEnv pub const Serialized = struct { - gpa: std.mem.Allocator, // Serialized as zeros, provided during deserialization + gpa: [2]u64, // Reserve space for allocator (vtable ptr + context ptr), provided during deserialization common: CommonEnv.Serialized, types: TypeStore.Serialized, all_defs: CIR.Def.Span, all_statements: CIR.Statement.Span, exports: CIR.Def.Span, + builtin_statements: CIR.Statement.Span, external_decls: CIR.ExternalDecl.SafeList.Serialized, imports: CIR.Import.Store.Serialized, - module_name: []const u8, // Serialized as zeros, provided during deserialization + module_name: [2]u64, // Reserve space for slice (ptr + len), provided during deserialization diagnostics: CIR.Diagnostic.Span, store: NodeStore.Serialized, + module_kind: ModuleKind, /// Serialize a ModuleEnv into this Serialized struct, appending data to the writer pub fn serialize( @@ -1076,9 +1387,6 @@ pub const Serialized = struct { allocator: std.mem.Allocator, writer: *CompactWriter, ) !void { - // Set fields that will be provided during deserialization to zeros - self.gpa = undefined; // Will be set to zeros below - try self.common.serialize(&env.common, allocator, writer); try self.types.serialize(&env.types, allocator, writer); @@ -1086,6 +1394,7 @@ pub const Serialized = struct { self.all_defs = env.all_defs; self.all_statements = env.all_statements; self.exports = env.exports; + self.builtin_statements = env.builtin_statements; try self.external_decls.serialize(&env.external_decls, allocator, writer); try self.imports.serialize(&env.imports, allocator, writer); @@ -1095,9 +1404,10 @@ pub const Serialized = struct { // Serialize NodeStore try self.store.serialize(&env.store, allocator, writer); - // Set gpa to all zeros; the space needs to be here, - // but the value will be set separately during deserialization. - @memset(@as([*]u8, @ptrCast(&self.gpa))[0..@sizeOf(@TypeOf(self.gpa))], 0); + // Set gpa and module_name to all zeros; the space needs to be here, + // but the values will be set separately during deserialization. + self.gpa = .{ 0, 0 }; + self.module_name = .{ 0, 0 }; } /// Deserialize a ModuleEnv from the buffer, updating the ModuleEnv in place @@ -1117,10 +1427,12 @@ pub const Serialized = struct { env.* = Self{ .gpa = gpa, .common = self.common.deserialize(offset, source).*, - .types = self.types.deserialize(offset).*, + .types = self.types.deserialize(offset, gpa).*, + .module_kind = self.module_kind, .all_defs = self.all_defs, .all_statements = self.all_statements, .exports = self.exports, + .builtin_statements = self.builtin_statements, .external_decls = self.external_decls.deserialize(offset).*, .imports = self.imports.deserialize(offset, gpa).*, .module_name = module_name, @@ -1825,6 +2137,11 @@ pub fn getIdentStore(self: *Self) *Ident.Store { return &self.common.idents; } +/// Returns an immutable reference to the identifier store. +pub fn getIdentStoreConst(self: *const Self) *const Ident.Store { + return &self.common.idents; +} + /// Retrieves the text of an identifier by its index. pub fn getIdent(self: *const Self, idx: Ident.Idx) []const u8 { return self.common.getIdent(idx); diff --git a/src/canonicalize/Node.zig b/src/canonicalize/Node.zig index efedb6a2de..4a9c28f538 100644 --- a/src/canonicalize/Node.zig +++ b/src/canonicalize/Node.zig @@ -58,7 +58,7 @@ pub const Tag = enum { expr_int, expr_frac_f32, expr_frac_f64, - expr_frac_dec, + expr_dec, expr_dec_small, expr_tag, expr_nominal, @@ -87,10 +87,12 @@ pub const Tag = enum { // Type Annotation ty_apply, ty_apply_external, - ty_var, - ty_ident, + ty_rigid_var, + ty_rigid_var_lookup, + ty_lookup, ty_underscore, ty_tag_union, + ty_tag, ty_tuple, ty_record, ty_record_field, @@ -108,7 +110,6 @@ pub const Tag = enum { pattern_list, pattern_tuple, pattern_num_literal, - pattern_int_literal, pattern_dec_literal, pattern_f32_literal, pattern_f64_literal, @@ -163,6 +164,15 @@ pub const Tag = enum { diag_malformed_type_annotation, diag_malformed_where_clause, diag_where_clause_not_allowed_in_type_decl, + diag_type_module_missing_matching_type, + diag_default_app_missing_main, + diag_default_app_wrong_arity, + diag_cannot_import_default_app, + diag_execution_requires_app_or_default_app, + diag_type_name_case_mismatch, + diag_module_header_deprecated, + diag_redundant_expose_main_type, + diag_invalid_main_type_rename_in_exposing, diag_var_across_function_boundary, diag_shadowing_warning, diag_type_redeclared, diff --git a/src/canonicalize/NodeStore.zig b/src/canonicalize/NodeStore.zig index bc9859969d..cc4717efb1 100644 --- a/src/canonicalize/NodeStore.zig +++ b/src/canonicalize/NodeStore.zig @@ -13,6 +13,7 @@ const CIR = @import("CIR.zig"); const SERIALIZATION_ALIGNMENT = collections.SERIALIZATION_ALIGNMENT; +const Allocator = std.mem.Allocator; const CompactWriter = collections.CompactWriter; const SafeList = collections.SafeList; const RocDec = builtins.dec.RocDec; @@ -25,57 +26,91 @@ const FunctionArgs = base.FunctionArgs; const NodeStore = @This(); -gpa: std.mem.Allocator, +gpa: Allocator, nodes: Node.List, regions: Region.List, extra_data: collections.SafeList(u32), -scratch_statements: base.Scratch(CIR.Statement.Idx), -scratch_exprs: base.Scratch(CIR.Expr.Idx), -scratch_record_fields: base.Scratch(CIR.RecordField.Idx), -scratch_match_branches: base.Scratch(CIR.Expr.Match.Branch.Idx), -scratch_match_branch_patterns: base.Scratch(CIR.Expr.Match.BranchPattern.Idx), -scratch_if_branches: base.Scratch(CIR.Expr.IfBranch.Idx), -scratch_where_clauses: base.Scratch(CIR.WhereClause.Idx), -scratch_patterns: base.Scratch(CIR.Pattern.Idx), -scratch_pattern_record_fields: base.Scratch(CIR.PatternRecordField.Idx), -scratch_record_destructs: base.Scratch(CIR.Pattern.RecordDestruct.Idx), -scratch_type_annos: base.Scratch(CIR.TypeAnno.Idx), -scratch_anno_record_fields: base.Scratch(CIR.TypeAnno.RecordField.Idx), -scratch_exposed_items: base.Scratch(CIR.ExposedItem.Idx), -scratch_defs: base.Scratch(CIR.Def.Idx), -scratch_diagnostics: base.Scratch(CIR.Diagnostic.Idx), -scratch_captures: base.Scratch(CIR.Expr.Capture.Idx), +scratch: ?*Scratch, // Nullable because when we deserialize a NodeStore, we don't bother to reinitialize scratch. + +const Scratch = struct { + statements: base.Scratch(CIR.Statement.Idx), + exprs: base.Scratch(CIR.Expr.Idx), + record_fields: base.Scratch(CIR.RecordField.Idx), + match_branches: base.Scratch(CIR.Expr.Match.Branch.Idx), + match_branch_patterns: base.Scratch(CIR.Expr.Match.BranchPattern.Idx), + if_branches: base.Scratch(CIR.Expr.IfBranch.Idx), + where_clauses: base.Scratch(CIR.WhereClause.Idx), + patterns: base.Scratch(CIR.Pattern.Idx), + pattern_record_fields: base.Scratch(CIR.PatternRecordField.Idx), + record_destructs: base.Scratch(CIR.Pattern.RecordDestruct.Idx), + type_annos: base.Scratch(CIR.TypeAnno.Idx), + anno_record_fields: base.Scratch(CIR.TypeAnno.RecordField.Idx), + exposed_items: base.Scratch(CIR.ExposedItem.Idx), + defs: base.Scratch(CIR.Def.Idx), + diagnostics: base.Scratch(CIR.Diagnostic.Idx), + captures: base.Scratch(CIR.Expr.Capture.Idx), + + fn init(gpa: Allocator) Allocator.Error!*@This() { + const ptr = try gpa.create(Scratch); + + ptr.* = .{ + .statements = try base.Scratch(CIR.Statement.Idx).init(gpa), + .exprs = try base.Scratch(CIR.Expr.Idx).init(gpa), + .record_fields = try base.Scratch(CIR.RecordField.Idx).init(gpa), + .match_branches = try base.Scratch(CIR.Expr.Match.Branch.Idx).init(gpa), + .match_branch_patterns = try base.Scratch(CIR.Expr.Match.BranchPattern.Idx).init(gpa), + .if_branches = try base.Scratch(CIR.Expr.IfBranch.Idx).init(gpa), + .where_clauses = try base.Scratch(CIR.WhereClause.Idx).init(gpa), + .patterns = try base.Scratch(CIR.Pattern.Idx).init(gpa), + .pattern_record_fields = try base.Scratch(CIR.PatternRecordField.Idx).init(gpa), + .record_destructs = try base.Scratch(CIR.Pattern.RecordDestruct.Idx).init(gpa), + .type_annos = try base.Scratch(CIR.TypeAnno.Idx).init(gpa), + .anno_record_fields = try base.Scratch(CIR.TypeAnno.RecordField.Idx).init(gpa), + .exposed_items = try base.Scratch(CIR.ExposedItem.Idx).init(gpa), + .defs = try base.Scratch(CIR.Def.Idx).init(gpa), + .diagnostics = try base.Scratch(CIR.Diagnostic.Idx).init(gpa), + .captures = try base.Scratch(CIR.Expr.Capture.Idx).init(gpa), + }; + + return ptr; + } + + fn deinit(self: *@This(), gpa: Allocator) void { + self.statements.deinit(gpa); + self.exprs.deinit(gpa); + self.record_fields.deinit(gpa); + self.match_branches.deinit(gpa); + self.match_branch_patterns.deinit(gpa); + self.if_branches.deinit(gpa); + self.where_clauses.deinit(gpa); + self.patterns.deinit(gpa); + self.pattern_record_fields.deinit(gpa); + self.record_destructs.deinit(gpa); + self.type_annos.deinit(gpa); + self.anno_record_fields.deinit(gpa); + self.exposed_items.deinit(gpa); + self.defs.deinit(gpa); + self.diagnostics.deinit(gpa); + self.captures.deinit(gpa); + gpa.destroy(self); + } +}; /// Initializes the NodeStore -pub fn init(gpa: std.mem.Allocator) std.mem.Allocator.Error!NodeStore { +pub fn init(gpa: Allocator) Allocator.Error!NodeStore { // TODO determine what capacity to use // maybe these should be moved to build/compile flags? return try NodeStore.initCapacity(gpa, 128); } /// Initializes the NodeStore with a specified capacity. -pub fn initCapacity(gpa: std.mem.Allocator, capacity: usize) std.mem.Allocator.Error!NodeStore { +pub fn initCapacity(gpa: Allocator, capacity: usize) Allocator.Error!NodeStore { return .{ .gpa = gpa, .nodes = try Node.List.initCapacity(gpa, capacity), .regions = try Region.List.initCapacity(gpa, capacity), .extra_data = try collections.SafeList(u32).initCapacity(gpa, capacity / 2), - .scratch_statements = try base.Scratch(CIR.Statement.Idx).init(gpa), - .scratch_exprs = try base.Scratch(CIR.Expr.Idx).init(gpa), - .scratch_record_fields = try base.Scratch(CIR.RecordField.Idx).init(gpa), - .scratch_match_branches = try base.Scratch(CIR.Expr.Match.Branch.Idx).init(gpa), - .scratch_match_branch_patterns = try base.Scratch(CIR.Expr.Match.BranchPattern.Idx).init(gpa), - .scratch_if_branches = try base.Scratch(CIR.Expr.IfBranch.Idx).init(gpa), - .scratch_where_clauses = try base.Scratch(CIR.WhereClause.Idx).init(gpa), - .scratch_patterns = try base.Scratch(CIR.Pattern.Idx).init(gpa), - .scratch_pattern_record_fields = try base.Scratch(CIR.PatternRecordField.Idx).init(gpa), - .scratch_record_destructs = try base.Scratch(CIR.Pattern.RecordDestruct.Idx).init(gpa), - .scratch_type_annos = try base.Scratch(CIR.TypeAnno.Idx).init(gpa), - .scratch_anno_record_fields = try base.Scratch(CIR.TypeAnno.RecordField.Idx).init(gpa), - .scratch_exposed_items = try base.Scratch(CIR.ExposedItem.Idx).init(gpa), - .scratch_defs = try base.Scratch(CIR.Def.Idx).init(gpa), - .scratch_diagnostics = try base.Scratch(CIR.Diagnostic.Idx).init(gpa), - .scratch_captures = try base.Scratch(CIR.Expr.Capture.Idx).init(gpa), + .scratch = try Scratch.init(gpa), }; } @@ -84,29 +119,16 @@ pub fn deinit(store: *NodeStore) void { store.nodes.deinit(store.gpa); store.regions.deinit(store.gpa); store.extra_data.deinit(store.gpa); - store.scratch_statements.deinit(store.gpa); - store.scratch_exprs.deinit(store.gpa); - store.scratch_record_fields.deinit(store.gpa); - store.scratch_match_branches.deinit(store.gpa); - store.scratch_match_branch_patterns.deinit(store.gpa); - store.scratch_if_branches.deinit(store.gpa); - store.scratch_where_clauses.deinit(store.gpa); - store.scratch_patterns.deinit(store.gpa); - store.scratch_pattern_record_fields.deinit(store.gpa); - store.scratch_record_destructs.deinit(store.gpa); - store.scratch_type_annos.deinit(store.gpa); - store.scratch_anno_record_fields.deinit(store.gpa); - store.scratch_exposed_items.deinit(store.gpa); - store.scratch_defs.deinit(store.gpa); - store.scratch_diagnostics.deinit(store.gpa); - store.scratch_captures.deinit(store.gpa); + if (store.scratch) |scratch| { + scratch.deinit(store.gpa); + } } /// Compile-time constants for union variant counts to ensure we don't miss cases /// when adding/removing variants from ModuleEnv unions. Update these when modifying the unions. /// /// Count of the diagnostic nodes in the ModuleEnv -pub const MODULEENV_DIAGNOSTIC_NODE_COUNT = 46; +pub const MODULEENV_DIAGNOSTIC_NODE_COUNT = 55; /// Count of the expression nodes in the ModuleEnv pub const MODULEENV_EXPR_NODE_COUNT = 33; /// Count of the statement nodes in the ModuleEnv @@ -323,21 +345,25 @@ pub fn getExpr(store: *const NodeStore, expr: CIR.Expr.Idx) CIR.Expr { .region = store.getRegionAt(node_idx), } }; }, - .expr_int => { + .expr_num => { + // Get requirements + const kind: CIR.NumKind = @enumFromInt(node.data_1); + // Read i128 from extra_data (stored as 4 u32s in data_1) - const value_as_u32s = store.extra_data.items.items[node.data_1..][0..4]; + const val_kind: CIR.IntValue.IntKind = @enumFromInt(node.data_2); + const value_as_u32s = store.extra_data.items.items[node.data_3..][0..4]; // Retrieve type variable from data_2 and requirements from data_3 return CIR.Expr{ - .e_int = .{ - .value = .{ .bytes = @bitCast(value_as_u32s.*), .kind = .i128 }, + .e_num = .{ + .value = .{ .bytes = @bitCast(value_as_u32s.*), .kind = val_kind }, + .kind = kind, }, }; }, .expr_list => { return CIR.Expr{ .e_list = .{ - .elem_var = @enumFromInt(node.data_3), .elems = .{ .span = .{ .start = node.data_1, .len = node.data_2 } }, }, }; @@ -351,7 +377,7 @@ pub fn getExpr(store: *const NodeStore, expr: CIR.Expr.Idx) CIR.Expr { }, .expr_call => { // Retrieve args span from extra_data - const extra_start = node.data_1; + const extra_start = node.data_2; const extra_data = store.extra_data.items.items[extra_start..]; const args_start = extra_data[0]; @@ -359,26 +385,34 @@ pub fn getExpr(store: *const NodeStore, expr: CIR.Expr.Idx) CIR.Expr { return CIR.Expr{ .e_call = .{ + .func = @enumFromInt(node.data_1), .args = .{ .span = .{ .start = args_start, .len = args_len } }, - .called_via = @enumFromInt(node.data_2), + .called_via = @enumFromInt(node.data_3), }, }; }, - .expr_frac_f32 => return CIR.Expr{ .e_frac_f32 = .{ .value = @bitCast(node.data_1) } }, + .expr_frac_f32 => return CIR.Expr{ .e_frac_f32 = .{ + .value = @bitCast(node.data_1), + .has_suffix = node.data_2 != 0, + } }, .expr_frac_f64 => { const raw: [2]u32 = .{ node.data_1, node.data_2 }; - return CIR.Expr{ .e_frac_f64 = .{ .value = @bitCast(raw) } }; + return CIR.Expr{ .e_frac_f64 = .{ + .value = @bitCast(raw), + .has_suffix = node.data_3 != 0, + } }; }, - .expr_frac_dec => { + .expr_dec => { // Get value from extra_data const extra_data_idx = node.data_1; const value_as_u32s = store.extra_data.items.items[extra_data_idx..][0..4]; const value_as_i128: i128 = @bitCast(value_as_u32s.*); return CIR.Expr{ - .e_frac_dec = .{ + .e_dec = .{ .value = RocDec{ .num = value_as_i128 }, + .has_suffix = node.data_2 != 0, }, }; }, @@ -387,12 +421,15 @@ pub fn getExpr(store: *const NodeStore, expr: CIR.Expr.Idx) CIR.Expr { // data_1: numerator (i16) stored as u32 // data_3: denominator_power_of_ten (u8) in lower 8 bits const numerator = @as(i16, @intCast(@as(i32, @bitCast(node.data_1)))); - const denominator_power_of_ten = @as(u8, @truncate(node.data_3)); + const denominator_power_of_ten = @as(u8, @truncate(node.data_2)); return CIR.Expr{ .e_dec_small = .{ - .numerator = numerator, - .denominator_power_of_ten = denominator_power_of_ten, + .value = .{ + .numerator = numerator, + .denominator_power_of_ten = denominator_power_of_ten, + }, + .has_suffix = node.data_3 != 0, }, }; }, @@ -815,19 +852,12 @@ pub fn getPattern(store: *const NodeStore, pattern_idx: CIR.Pattern.Idx) CIR.Pat }; }, .pattern_record_destructure => { - const extra_start = node.data_1; - const extra_data = store.extra_data.items.items[extra_start..]; - - const destructs_start = extra_data[0]; - const destructs_len = extra_data[1]; - const ext_var = @as(types.Var, @enumFromInt(extra_data[2])); - const whole_var = @as(types.Var, @enumFromInt(extra_data[3])); + const destructs_start = node.data_1; + const destructs_len = node.data_2; return CIR.Pattern{ .record_destructure = .{ .destructs = DataSpan.init(destructs_start, destructs_len).as(CIR.Pattern.RecordDestruct.Span), - .ext_var = ext_var, - .whole_var = whole_var, }, }; }, @@ -837,16 +867,14 @@ pub fn getPattern(store: *const NodeStore, pattern_idx: CIR.Pattern.Idx) CIR.Pat const patterns_start = extra_data[0]; const patterns_len = extra_data[1]; - const elem_var = @as(types.Var, @enumFromInt(extra_data[2])); - const list_var = @as(types.Var, @enumFromInt(extra_data[3])); // Load rest_info - const has_rest_info = extra_data[4] != 0; + const has_rest_info = extra_data[2] != 0; const rest_info = if (has_rest_info) blk: { - const rest_index = extra_data[5]; - const has_pattern = extra_data[6] != 0; + const rest_index = extra_data[3]; + const has_pattern = extra_data[4] != 0; const rest_pattern = if (has_pattern) - @as(CIR.Pattern.Idx, @enumFromInt(extra_data[7])) + @as(CIR.Pattern.Idx, @enumFromInt(extra_data[5])) else null; break :blk @as(@TypeOf(@as(CIR.Pattern, undefined).list.rest_info), .{ @@ -858,8 +886,6 @@ pub fn getPattern(store: *const NodeStore, pattern_idx: CIR.Pattern.Idx) CIR.Pat return CIR.Pattern{ .list = .{ .patterns = DataSpan.init(patterns_start, patterns_len).as(CIR.Pattern.Span), - .elem_var = elem_var, - .list_var = list_var, .rest_info = rest_info, }, }; @@ -870,24 +896,18 @@ pub fn getPattern(store: *const NodeStore, pattern_idx: CIR.Pattern.Idx) CIR.Pat }, }, .pattern_num_literal => { - const extra_data_idx = node.data_1; + const kind: CIR.NumKind = @enumFromInt(node.data_1); + + const val_kind: CIR.IntValue.IntKind = @enumFromInt(node.data_2); + + const extra_data_idx = node.data_3; const value_as_u32s = store.extra_data.items.items[extra_data_idx..][0..4]; const value_as_i128: i128 = @bitCast(value_as_u32s.*); return CIR.Pattern{ - .int_literal = .{ - .value = .{ .bytes = @bitCast(value_as_i128), .kind = .i128 }, - }, - }; - }, - .pattern_int_literal => { - const extra_data_idx = node.data_1; - const value_as_u32s = store.extra_data.items.items[extra_data_idx..][0..4]; - const value_as_i128: i128 = @bitCast(value_as_u32s.*); - - return CIR.Pattern{ - .int_literal = .{ - .value = .{ .bytes = @bitCast(value_as_i128), .kind = .i128 }, + .num_literal = .{ + .value = .{ .bytes = @bitCast(value_as_i128), .kind = val_kind }, + .kind = kind, }, }; }, @@ -908,9 +928,12 @@ pub fn getPattern(store: *const NodeStore, pattern_idx: CIR.Pattern.Idx) CIR.Pat const value_as_u32s = store.extra_data.items.items[extra_data_idx..][0..4]; const value_as_i128: i128 = @bitCast(value_as_u32s.*); + const has_suffix = node.data_2 != 0; + return CIR.Pattern{ .dec_literal = .{ .value = RocDec{ .num = value_as_i128 }, + .has_suffix = has_suffix, }, }; }, @@ -919,12 +942,17 @@ pub fn getPattern(store: *const NodeStore, pattern_idx: CIR.Pattern.Idx) CIR.Pat // data_1: numerator (i16) stored as u32 // data_3: denominator_power_of_ten (u8) in lower 8 bits const numerator: i16 = @intCast(@as(i32, @bitCast(node.data_1))); - const denominator_power_of_ten: u8 = @intCast(node.data_3 & 0xFF); + const denominator_power_of_ten: u8 = @intCast(node.data_2 & 0xFF); + + const has_suffix = node.data_3 != 0; return CIR.Pattern{ .small_dec_literal = .{ - .numerator = numerator, - .denominator_power_of_ten = denominator_power_of_ten, + .value = .{ + .numerator = numerator, + .denominator_power_of_ten = denominator_power_of_ten, + }, + .has_suffix = has_suffix, }, }; }, @@ -939,7 +967,7 @@ pub fn getPattern(store: *const NodeStore, pattern_idx: CIR.Pattern.Idx) CIR.Pat } }; }, else => { - @panic("unreachable, node is not an pattern tag"); + std.debug.panic("unreachable, node is not an pattern tag {}", .{node.tag}); }, } } @@ -958,31 +986,78 @@ pub fn getTypeAnno(store: *const NodeStore, typeAnno: CIR.TypeAnno.Idx) CIR.Type const node = store.nodes.get(node_idx); switch (node.tag) { - .ty_apply => return CIR.TypeAnno{ .apply = .{ - .symbol = @bitCast(node.data_1), - .args = .{ .span = .{ .start = node.data_2, .len = node.data_3 } }, - } }, - .ty_apply_external => { - const extra_data_idx = node.data_3; - const args_start = store.extra_data.items.items[extra_data_idx]; - const args_len = store.extra_data.items.items[extra_data_idx + 1]; - return CIR.TypeAnno{ .apply_external = .{ - .module_idx = @enumFromInt(node.data_1), - .target_node_idx = @intCast(node.data_2), + .ty_apply => { + const name: Ident.Idx = @bitCast(node.data_1); + const args_start = node.data_2; + + const extra_data = store.extra_data.items.items[node.data_3..]; + const args_len = extra_data[0]; + const base_enum: CIR.TypeAnno.LocalOrExternal.Tag = @enumFromInt(extra_data[1]); + const type_base: CIR.TypeAnno.LocalOrExternal = blk: { + switch (base_enum) { + .builtin => { + break :blk .{ .builtin = @enumFromInt(extra_data[2]) }; + }, + .local => { + break :blk .{ .local = .{ .decl_idx = @enumFromInt(extra_data[2]) } }; + }, + .external => { + break :blk .{ .external = .{ + .module_idx = @enumFromInt(extra_data[2]), + .target_node_idx = @intCast(extra_data[3]), + } }; + }, + } + }; + + return CIR.TypeAnno{ .apply = .{ + .name = name, + .base = type_base, .args = .{ .span = .{ .start = args_start, .len = args_len } }, } }; }, - .ty_var => return CIR.TypeAnno{ .ty_var = .{ + .ty_rigid_var => return CIR.TypeAnno{ .rigid_var = .{ .name = @bitCast(node.data_1), } }, - .ty_underscore => return CIR.TypeAnno{ .underscore = {} }, - .ty_ident => return CIR.TypeAnno{ .ty = .{ - .symbol = @bitCast(node.data_1), + .ty_rigid_var_lookup => return CIR.TypeAnno{ .rigid_var_lookup = .{ + .ref = @enumFromInt(node.data_1), } }, + .ty_underscore => return CIR.TypeAnno{ .underscore = {} }, + .ty_lookup => { + const name: Ident.Idx = @bitCast(node.data_1); + const base_enum: CIR.TypeAnno.LocalOrExternal.Tag = @enumFromInt(node.data_2); + + const extra_data = store.extra_data.items.items[node.data_3..]; + const type_base: CIR.TypeAnno.LocalOrExternal = blk: { + switch (base_enum) { + .builtin => { + break :blk .{ .builtin = @enumFromInt(extra_data[0]) }; + }, + .local => { + break :blk .{ .local = .{ .decl_idx = @enumFromInt(extra_data[0]) } }; + }, + .external => { + break :blk .{ .external = .{ + .module_idx = @enumFromInt(extra_data[0]), + .target_node_idx = @intCast(extra_data[1]), + } }; + }, + } + }; + + return CIR.TypeAnno{ .lookup = .{ + .name = name, + .base = type_base, + } }; + }, .ty_tag_union => return CIR.TypeAnno{ .tag_union = .{ .tags = .{ .span = .{ .start = node.data_1, .len = node.data_2 } }, .ext = if (node.data_3 != 0) @enumFromInt(node.data_3) else null, } }, + .ty_tag => return CIR.TypeAnno{ .tag = .{ + .name = @bitCast(node.data_1), + .args = .{ .span = .{ .start = node.data_2, .len = node.data_3 } }, + } }, .ty_tuple => return CIR.TypeAnno{ .tuple = .{ .elems = .{ .span = .{ .start = node.data_1, .len = node.data_2 } }, } }, @@ -1002,12 +1077,6 @@ pub fn getTypeAnno(store: *const NodeStore, typeAnno: CIR.TypeAnno.Idx) CIR.Type .ty_parens => return CIR.TypeAnno{ .parens = .{ .anno = @enumFromInt(node.data_1), } }, - .ty_lookup_external => return CIR.TypeAnno{ - .ty_lookup_external = .{ - .module_idx = @enumFromInt(node.data_1), - .target_node_idx = @intCast(node.data_2), - }, - }, .ty_malformed => return CIR.TypeAnno{ .malformed = .{ .diagnostic = @enumFromInt(node.data_1), } }, @@ -1077,7 +1146,30 @@ pub fn getExposedItem(store: *const NodeStore, exposedItem: CIR.ExposedItem.Idx) /// /// IMPORTANT: You should not use this function directly! Instead, use it's /// corresponding function in `ModuleEnv`. -pub fn addStatement(store: *NodeStore, statement: CIR.Statement, region: base.Region) std.mem.Allocator.Error!CIR.Statement.Idx { +pub fn addStatement(store: *NodeStore, statement: CIR.Statement, region: base.Region) Allocator.Error!CIR.Statement.Idx { + const node = try store.makeStatementNode(statement); + const node_idx = try store.nodes.append(store.gpa, node); + _ = try store.regions.append(store.gpa, region); + return @enumFromInt(@intFromEnum(node_idx)); +} + +/// Set a statement idx to the provided statement +/// +/// This is used when defininig recursive type declarations: +/// 1. Make the placeholder node +/// 2. Introduce to scope +/// 3. Canonicalize the annotation +/// 4. Update the placeholder node with the actual annotation +pub fn setStatementNode(store: *NodeStore, stmt_idx: CIR.Statement.Idx, statement: CIR.Statement) Allocator.Error!void { + const node = try store.makeStatementNode(statement); + store.nodes.set(@enumFromInt(@intFromEnum(stmt_idx)), node); +} + +/// Creates a statement node, but does not append to the store. +/// IMPORTANT: It *does* append to extra_data though +/// +/// See `setStatementNode` to see why this exists +fn makeStatementNode(store: *NodeStore, statement: CIR.Statement) Allocator.Error!Node { var node = Node{ .data_1 = 0, .data_2 = 0, @@ -1208,16 +1300,14 @@ pub fn addStatement(store: *NodeStore, statement: CIR.Statement, region: base.Re }, } - const node_idx = try store.nodes.append(store.gpa, node); - _ = try store.regions.append(store.gpa, region); - return @enumFromInt(@intFromEnum(node_idx)); + return node; } /// Adds an expression node to the store. /// /// IMPORTANT: You should not use this function directly! Instead, use it's /// corresponding function in `ModuleEnv`. -pub fn addExpr(store: *NodeStore, expr: CIR.Expr, region: base.Region) std.mem.Allocator.Error!CIR.Expr.Idx { +pub fn addExpr(store: *NodeStore, expr: CIR.Expr, region: base.Region) Allocator.Error!CIR.Expr.Idx { var node = Node{ .data_1 = 0, .data_2 = 0, @@ -1236,8 +1326,11 @@ pub fn addExpr(store: *NodeStore, expr: CIR.Expr, region: base.Region) std.mem.A node.data_1 = @intFromEnum(e.module_idx); node.data_2 = e.target_node_idx; }, - .e_int => |e| { - node.tag = .expr_int; + .e_num => |e| { + node.tag = .expr_num; + + node.data_1 = @intFromEnum(e.kind); + node.data_2 = @intFromEnum(e.value.kind); // Store i128 value in extra_data const extra_data_start = store.extra_data.len(); @@ -1251,13 +1344,12 @@ pub fn addExpr(store: *NodeStore, expr: CIR.Expr, region: base.Region) std.mem.A } // Store the extra_data index in data_1 - node.data_1 = @intCast(extra_data_start); + node.data_3 = @intCast(extra_data_start); }, .e_list => |e| { node.tag = .expr_list; node.data_1 = e.elems.span.start; node.data_2 = e.elems.span.len; - node.data_3 = @intFromEnum(e.elem_var); }, .e_empty_list => |_| { node.tag = .expr_empty_list; @@ -1270,15 +1362,17 @@ pub fn addExpr(store: *NodeStore, expr: CIR.Expr, region: base.Region) std.mem.A .e_frac_f32 => |e| { node.tag = Node.Tag.expr_frac_f32; node.data_1 = @bitCast(e.value); + node.data_2 = @intFromBool(e.has_suffix); }, .e_frac_f64 => |e| { node.tag = .expr_frac_f64; const raw: [2]u32 = @bitCast(e.value); node.data_1 = raw[0]; node.data_2 = raw[1]; + node.data_3 = @intFromBool(e.has_suffix); }, - .e_frac_dec => |e| { - node.tag = .expr_frac_dec; + .e_dec => |e| { + node.tag = .expr_dec; // Store the RocDec value in extra_data const extra_data_start = store.extra_data.len(); @@ -1290,15 +1384,17 @@ pub fn addExpr(store: *NodeStore, expr: CIR.Expr, region: base.Region) std.mem.A // Store the extra_data index in data_1 node.data_1 = @intCast(extra_data_start); + node.data_2 = @intFromBool(e.has_suffix); }, .e_dec_small => |e| { node.tag = .expr_dec_small; // Pack small dec data into data_1 and data_3 // data_1: numerator (i16) - fits in lower 16 bits - // data_3: denominator_power_of_ten (u8) in lower 8 bits - node.data_1 = @as(u32, @bitCast(@as(i32, e.numerator))); - node.data_3 = @as(u32, e.denominator_power_of_ten); + // data_2: denominator_power_of_ten (u8) in lower 8 bits + node.data_1 = @as(u32, @bitCast(@as(i32, e.value.numerator))); + node.data_2 = @as(u32, e.value.denominator_power_of_ten); + node.data_3 = @intFromBool(e.has_suffix); }, .e_str_segment => |e| { node.tag = .expr_string_segment; @@ -1396,8 +1492,9 @@ pub fn addExpr(store: *NodeStore, expr: CIR.Expr, region: base.Region) std.mem.A // Store args span length _ = try store.extra_data.append(store.gpa, e.args.span.len); - node.data_1 = @intCast(extra_data_start); - node.data_2 = @intFromEnum(e.called_via); + node.data_1 = @intFromEnum(e.func); + node.data_2 = @intCast(extra_data_start); + node.data_3 = @intFromEnum(e.called_via); }, .e_record => |e| { node.tag = .expr_record; @@ -1495,7 +1592,7 @@ pub fn addExpr(store: *NodeStore, expr: CIR.Expr, region: base.Region) std.mem.A /// /// IMPORTANT: You should not use this function directly! Instead, use it's /// corresponding function in `ModuleEnv`. -pub fn addRecordField(store: *NodeStore, recordField: CIR.RecordField, region: base.Region) std.mem.Allocator.Error!CIR.RecordField.Idx { +pub fn addRecordField(store: *NodeStore, recordField: CIR.RecordField, region: base.Region) Allocator.Error!CIR.RecordField.Idx { const node = Node{ .data_1 = @bitCast(recordField.name), .data_2 = @intFromEnum(recordField.value), @@ -1512,7 +1609,7 @@ pub fn addRecordField(store: *NodeStore, recordField: CIR.RecordField, region: b /// /// IMPORTANT: You should not use this function directly! Instead, use it's /// corresponding function in `ModuleEnv`. -pub fn addRecordDestruct(store: *NodeStore, record_destruct: CIR.Pattern.RecordDestruct, region: base.Region) std.mem.Allocator.Error!CIR.Pattern.RecordDestruct.Idx { +pub fn addRecordDestruct(store: *NodeStore, record_destruct: CIR.Pattern.RecordDestruct, region: base.Region) Allocator.Error!CIR.Pattern.RecordDestruct.Idx { const extra_data_start = @as(u32, @intCast(store.extra_data.len())); const node = Node{ .data_1 = @bitCast(record_destruct.label), @@ -1529,11 +1626,11 @@ pub fn addRecordDestruct(store: *NodeStore, record_destruct: CIR.Pattern.RecordD // Store pattern index _ = try store.extra_data.append(store.gpa, @intFromEnum(pattern_idx)); }, - .SubPattern => |sub_pattern| { + .SubPattern => |pattern_idx| { // Store kind tag (1 for SubPattern) _ = try store.extra_data.append(store.gpa, 1); // Store sub-pattern index - _ = try store.extra_data.append(store.gpa, @intFromEnum(sub_pattern)); + _ = try store.extra_data.append(store.gpa, @intFromEnum(pattern_idx)); }, } @@ -1546,7 +1643,7 @@ pub fn addRecordDestruct(store: *NodeStore, record_destruct: CIR.Pattern.RecordD /// /// IMPORTANT: You should not use this function directly! Instead, use it's /// corresponding function in `ModuleEnv`. -pub fn addCapture(store: *NodeStore, capture: CIR.Expr.Capture, region: base.Region) std.mem.Allocator.Error!CIR.Expr.Capture.Idx { +pub fn addCapture(store: *NodeStore, capture: CIR.Expr.Capture, region: base.Region) Allocator.Error!CIR.Expr.Capture.Idx { const node = Node{ .tag = .lambda_capture, .data_1 = @bitCast(capture.name), @@ -1563,7 +1660,7 @@ pub fn addCapture(store: *NodeStore, capture: CIR.Expr.Capture, region: base.Reg /// /// IMPORTANT: You should not use this function directly! Instead, use it's /// corresponding function in `ModuleEnv`. -pub fn addMatchBranch(store: *NodeStore, branch: CIR.Expr.Match.Branch, region: base.Region) std.mem.Allocator.Error!CIR.Expr.Match.Branch.Idx { +pub fn addMatchBranch(store: *NodeStore, branch: CIR.Expr.Match.Branch, region: base.Region) Allocator.Error!CIR.Expr.Match.Branch.Idx { var node = Node{ .data_1 = 0, .data_2 = 0, @@ -1590,7 +1687,7 @@ pub fn addMatchBranch(store: *NodeStore, branch: CIR.Expr.Match.Branch, region: /// /// IMPORTANT: You should not use this function directly! Instead, use it's /// corresponding function in `ModuleEnv`. -pub fn addMatchBranchPattern(store: *NodeStore, branchPattern: CIR.Expr.Match.BranchPattern, region: base.Region) std.mem.Allocator.Error!CIR.Expr.Match.BranchPattern.Idx { +pub fn addMatchBranchPattern(store: *NodeStore, branchPattern: CIR.Expr.Match.BranchPattern, region: base.Region) Allocator.Error!CIR.Expr.Match.BranchPattern.Idx { const node = Node{ .data_1 = @intFromEnum(branchPattern.pattern), .data_2 = @as(u32, @intFromBool(branchPattern.degenerate)), @@ -1606,7 +1703,7 @@ pub fn addMatchBranchPattern(store: *NodeStore, branchPattern: CIR.Expr.Match.Br /// /// IMPORTANT: You should not use this function directly! Instead, use it's /// corresponding function in `ModuleEnv`. -pub fn addWhereClause(store: *NodeStore, whereClause: CIR.WhereClause, region: base.Region) std.mem.Allocator.Error!CIR.WhereClause.Idx { +pub fn addWhereClause(store: *NodeStore, whereClause: CIR.WhereClause, region: base.Region) Allocator.Error!CIR.WhereClause.Idx { var node = Node{ .data_1 = 0, .data_2 = 0, @@ -1653,7 +1750,7 @@ pub fn addWhereClause(store: *NodeStore, whereClause: CIR.WhereClause, region: b /// /// IMPORTANT: You should not use this function directly! Instead, use it's /// corresponding function in `ModuleEnv`. -pub fn addPattern(store: *NodeStore, pattern: CIR.Pattern, region: base.Region) std.mem.Allocator.Error!CIR.Pattern.Idx { +pub fn addPattern(store: *NodeStore, pattern: CIR.Pattern, region: base.Region) Allocator.Error!CIR.Pattern.Idx { var node = Node{ .data_1 = 0, .data_2 = 0, @@ -1694,13 +1791,8 @@ pub fn addPattern(store: *NodeStore, pattern: CIR.Pattern, region: base.Region) .record_destructure => |p| { node.tag = .pattern_record_destructure; - // Store record destructure data in extra_data - const extra_data_start = store.extra_data.len(); - _ = try store.extra_data.append(store.gpa, p.destructs.span.start); - _ = try store.extra_data.append(store.gpa, p.destructs.span.len); - _ = try store.extra_data.append(store.gpa, @intFromEnum(p.ext_var)); - _ = try store.extra_data.append(store.gpa, @intFromEnum(p.whole_var)); - node.data_1 = @intCast(extra_data_start); + node.data_1 = p.destructs.span.start; + node.data_2 = p.destructs.span.len; }, .list => |p| { node.tag = .pattern_list; @@ -1709,8 +1801,6 @@ pub fn addPattern(store: *NodeStore, pattern: CIR.Pattern, region: base.Region) const extra_data_start = store.extra_data.len(); _ = try store.extra_data.append(store.gpa, p.patterns.span.start); _ = try store.extra_data.append(store.gpa, p.patterns.span.len); - _ = try store.extra_data.append(store.gpa, @intFromEnum(p.elem_var)); - _ = try store.extra_data.append(store.gpa, @intFromEnum(p.list_var)); // Store rest_info if (p.rest_info) |rest| { @@ -1733,23 +1823,26 @@ pub fn addPattern(store: *NodeStore, pattern: CIR.Pattern, region: base.Region) node.data_1 = p.patterns.span.start; node.data_2 = p.patterns.span.len; }, - .int_literal => |p| { - node.tag = .pattern_int_literal; - // Store the value in extra_data - const extra_data_start = store.extra_data.len(); + .num_literal => |p| { + node.tag = .pattern_num_literal; + + node.data_1 = @intFromEnum(p.kind); + node.data_2 = @intFromEnum(p.value.kind); + node.data_3 = @intCast(store.extra_data.len()); + const value_as_u32s: [4]u32 = @bitCast(p.value.bytes); for (value_as_u32s) |word| { _ = try store.extra_data.append(store.gpa, word); } - node.data_1 = @intCast(extra_data_start); }, .small_dec_literal => |p| { node.tag = .pattern_small_dec_literal; // Pack small dec data into data_1 and data_3 // data_1: numerator (i16) - fits in lower 16 bits // data_3: denominator_power_of_ten (u8) in lower 8 bits - node.data_1 = @as(u32, @bitCast(@as(i32, p.numerator))); - node.data_3 = @as(u32, p.denominator_power_of_ten); + node.data_1 = @as(u32, @bitCast(@as(i32, p.value.numerator))); + node.data_2 = @as(u32, p.value.denominator_power_of_ten); + node.data_3 = @intFromBool(p.has_suffix); }, .dec_literal => |p| { node.tag = .pattern_dec_literal; @@ -1760,6 +1853,7 @@ pub fn addPattern(store: *NodeStore, pattern: CIR.Pattern, region: base.Region) _ = try store.extra_data.append(store.gpa, word); } node.data_1 = @intCast(extra_data_start); + node.data_2 = @intFromBool(p.has_suffix); }, .str_literal => |p| { node.tag = .pattern_str_literal; @@ -1792,7 +1886,7 @@ pub fn addPattern(store: *NodeStore, pattern: CIR.Pattern, region: base.Region) } /// Adds a pattern record field to the store. -pub fn addPatternRecordField(store: *NodeStore, patternRecordField: CIR.PatternRecordField) std.mem.Allocator.Error!CIR.PatternRecordField.Idx { +pub fn addPatternRecordField(store: *NodeStore, patternRecordField: CIR.PatternRecordField) Allocator.Error!CIR.PatternRecordField.Idx { _ = store; _ = patternRecordField; @@ -1803,7 +1897,7 @@ pub fn addPatternRecordField(store: *NodeStore, patternRecordField: CIR.PatternR /// /// IMPORTANT: You should not use this function directly! Instead, use it's /// corresponding function in `ModuleEnv`. -pub fn addTypeAnno(store: *NodeStore, typeAnno: CIR.TypeAnno, region: base.Region) std.mem.Allocator.Error!CIR.TypeAnno.Idx { +pub fn addTypeAnno(store: *NodeStore, typeAnno: CIR.TypeAnno, region: base.Region) Allocator.Error!CIR.TypeAnno.Idx { var node = Node{ .data_1 = 0, .data_2 = 0, @@ -1813,30 +1907,60 @@ pub fn addTypeAnno(store: *NodeStore, typeAnno: CIR.TypeAnno, region: base.Regio switch (typeAnno) { .apply => |a| { - node.data_1 = @bitCast(a.symbol); + node.data_1 = @bitCast(a.name); node.data_2 = a.args.span.start; - node.data_3 = a.args.span.len; + + const ed_start = store.extra_data.len(); + _ = try store.extra_data.append(store.gpa, a.args.span.len); + _ = try store.extra_data.append(store.gpa, @intFromEnum(@as(CIR.TypeAnno.LocalOrExternal.Tag, std.meta.activeTag(a.base)))); + switch (a.base) { + .builtin => |builtin_type| { + _ = try store.extra_data.append(store.gpa, @intFromEnum(builtin_type)); + }, + .local => |local| { + _ = try store.extra_data.append(store.gpa, @intFromEnum(local.decl_idx)); + }, + .external => |ext| { + _ = try store.extra_data.append(store.gpa, @intFromEnum(ext.module_idx)); + _ = try store.extra_data.append(store.gpa, @intCast(ext.target_node_idx)); + }, + } + + node.data_3 = @intCast(ed_start); + node.tag = .ty_apply; }, - .apply_external => |a| { - node.data_1 = @intFromEnum(a.module_idx); - node.data_2 = a.target_node_idx; - const ed_start = store.extra_data.len(); - _ = try store.extra_data.append(store.gpa, a.args.span.start); - _ = try store.extra_data.append(store.gpa, a.args.span.len); - node.data_3 = @intCast(ed_start); - node.tag = .ty_apply_external; - }, - .ty_var => |tv| { + .rigid_var => |tv| { node.data_1 = @bitCast(tv.name); - node.tag = .ty_var; + node.tag = .ty_rigid_var; + }, + .rigid_var_lookup => |tv| { + node.data_1 = @intFromEnum(tv.ref); + node.tag = .ty_rigid_var_lookup; }, .underscore => |_| { node.tag = .ty_underscore; }, - .ty => |t| { - node.data_1 = @bitCast(t.symbol); - node.tag = .ty_ident; + .lookup => |t| { + node.data_1 = @bitCast(t.name); + node.data_2 = @intFromEnum(@as(CIR.TypeAnno.LocalOrExternal.Tag, std.meta.activeTag(t.base))); + + const ed_start = store.extra_data.len(); + switch (t.base) { + .builtin => |builtin_type| { + _ = try store.extra_data.append(store.gpa, @intFromEnum(builtin_type)); + }, + .local => |local| { + _ = try store.extra_data.append(store.gpa, @intFromEnum(local.decl_idx)); + }, + .external => |ext| { + _ = try store.extra_data.append(store.gpa, @intFromEnum(ext.module_idx)); + _ = try store.extra_data.append(store.gpa, @intCast(ext.target_node_idx)); + }, + } + node.data_3 = @intCast(ed_start); + + node.tag = .ty_lookup; }, .tag_union => |tu| { node.data_1 = tu.tags.span.start; @@ -1844,6 +1968,12 @@ pub fn addTypeAnno(store: *NodeStore, typeAnno: CIR.TypeAnno, region: base.Regio node.data_3 = if (tu.ext) |ext| @intFromEnum(ext) else 0; node.tag = .ty_tag_union; }, + .tag => |t| { + node.data_1 = @bitCast(t.name); + node.data_2 = t.args.span.start; + node.data_3 = t.args.span.len; + node.tag = .ty_tag; + }, .tuple => |t| { node.data_1 = t.elems.span.start; node.data_2 = t.elems.span.len; @@ -1867,11 +1997,6 @@ pub fn addTypeAnno(store: *NodeStore, typeAnno: CIR.TypeAnno, region: base.Regio node.data_1 = @intFromEnum(p.anno); node.tag = .ty_parens; }, - .ty_lookup_external => |tle| { - node.tag = .ty_lookup_external; - node.data_1 = @intFromEnum(tle.module_idx); - node.data_2 = tle.target_node_idx; - }, .malformed => |m| { node.data_1 = @intFromEnum(m.diagnostic); node.tag = .ty_malformed; @@ -1887,7 +2012,7 @@ pub fn addTypeAnno(store: *NodeStore, typeAnno: CIR.TypeAnno, region: base.Regio /// /// IMPORTANT: You should not use this function directly! Instead, use it's /// corresponding function in `ModuleEnv`. -pub fn addTypeHeader(store: *NodeStore, typeHeader: CIR.TypeHeader, region: base.Region) std.mem.Allocator.Error!CIR.TypeHeader.Idx { +pub fn addTypeHeader(store: *NodeStore, typeHeader: CIR.TypeHeader, region: base.Region) Allocator.Error!CIR.TypeHeader.Idx { const node = Node{ .data_1 = @bitCast(typeHeader.name), .data_2 = typeHeader.args.span.start, @@ -1904,7 +2029,7 @@ pub fn addTypeHeader(store: *NodeStore, typeHeader: CIR.TypeHeader, region: base /// /// IMPORTANT: You should not use this function directly! Instead, use it's /// corresponding function in `ModuleEnv`. -pub fn addAnnoRecordField(store: *NodeStore, annoRecordField: CIR.TypeAnno.RecordField, region: base.Region) std.mem.Allocator.Error!CIR.TypeAnno.RecordField.Idx { +pub fn addAnnoRecordField(store: *NodeStore, annoRecordField: CIR.TypeAnno.RecordField, region: base.Region) Allocator.Error!CIR.TypeAnno.RecordField.Idx { const node = Node{ .data_1 = @bitCast(annoRecordField.name), .data_2 = @intFromEnum(annoRecordField.ty), @@ -1921,7 +2046,7 @@ pub fn addAnnoRecordField(store: *NodeStore, annoRecordField: CIR.TypeAnno.Recor /// /// IMPORTANT: You should not use this function directly! Instead, use it's /// corresponding function in `ModuleEnv`. -pub fn addAnnotation(store: *NodeStore, annotation: CIR.Annotation, region: base.Region) std.mem.Allocator.Error!CIR.Annotation.Idx { +pub fn addAnnotation(store: *NodeStore, annotation: CIR.Annotation, region: base.Region) Allocator.Error!CIR.Annotation.Idx { const node = Node{ .data_1 = @intFromEnum(annotation.signature), .data_2 = @intFromEnum(annotation.type_anno), @@ -1938,7 +2063,7 @@ pub fn addAnnotation(store: *NodeStore, annotation: CIR.Annotation, region: base /// /// IMPORTANT: You should not use this function directly! Instead, use it's /// corresponding function in `ModuleEnv`. -pub fn addExposedItem(store: *NodeStore, exposedItem: CIR.ExposedItem, region: base.Region) std.mem.Allocator.Error!CIR.ExposedItem.Idx { +pub fn addExposedItem(store: *NodeStore, exposedItem: CIR.ExposedItem, region: base.Region) Allocator.Error!CIR.ExposedItem.Idx { const node = Node{ .data_1 = @bitCast(exposedItem.name), .data_2 = if (exposedItem.alias) |alias| @bitCast(alias) else 0, @@ -1955,7 +2080,7 @@ pub fn addExposedItem(store: *NodeStore, exposedItem: CIR.ExposedItem, region: b /// /// IMPORTANT: You should not use this function directly! Instead, use it's /// corresponding function in `ModuleEnv`. -pub fn addDef(store: *NodeStore, def: CIR.Def, region: base.Region) std.mem.Allocator.Error!CIR.Def.Idx { +pub fn addDef(store: *NodeStore, def: CIR.Def, region: base.Region) Allocator.Error!CIR.Def.Idx { var node = Node{ .data_1 = 0, .data_2 = 0, @@ -2077,22 +2202,22 @@ pub fn getIfBranch(store: *const NodeStore, if_branch_idx: CIR.Expr.IfBranch.Idx /// Generic function to get the top of any scratch buffer pub fn scratchTop(store: *NodeStore, comptime field_name: []const u8) u32 { - return @field(store, field_name).top(); + return @field(store.scratch.?, field_name).top(); } /// Generic function to add an item to any scratch buffer -pub fn addScratch(store: *NodeStore, comptime field_name: []const u8, idx: anytype) std.mem.Allocator.Error!void { - try @field(store, field_name).append(store.gpa, idx); +pub fn addScratch(store: *NodeStore, comptime field_name: []const u8, idx: anytype) Allocator.Error!void { + try @field(store.scratch.?, field_name).append(store.gpa, idx); } /// Generic function to clear any scratch buffer from a given position pub fn clearScratchFrom(store: *NodeStore, comptime field_name: []const u8, start: u32) void { - @field(store, field_name).clearFrom(start); + @field(store.scratch.?, field_name).clearFrom(start); } /// Generic function to create a span from any scratch buffer -pub fn spanFrom(store: *NodeStore, comptime field_name: []const u8, comptime SpanType: type, start: u32) std.mem.Allocator.Error!SpanType { - const scratch_field = &@field(store, field_name); +pub fn spanFrom(store: *NodeStore, comptime field_name: []const u8, comptime SpanType: type, start: u32) Allocator.Error!SpanType { + const scratch_field = &@field(store.scratch.?, field_name); const end = scratch_field.top(); defer scratch_field.clearFrom(start); var i = @as(usize, @intCast(start)); @@ -2107,42 +2232,42 @@ pub fn spanFrom(store: *NodeStore, comptime field_name: []const u8, comptime Spa /// Returns the top of the scratch expressions buffer. pub fn scratchExprTop(store: *NodeStore) u32 { - return store.scratchTop("scratch_exprs"); + return store.scratchTop("exprs"); } /// Adds a scratch expression to temporary storage. -pub fn addScratchExpr(store: *NodeStore, idx: CIR.Expr.Idx) std.mem.Allocator.Error!void { - try store.addScratch("scratch_exprs", idx); +pub fn addScratchExpr(store: *NodeStore, idx: CIR.Expr.Idx) Allocator.Error!void { + try store.addScratch("exprs", idx); } /// Adds a capture index to the scratch captures list for building spans. -pub fn addScratchCapture(store: *NodeStore, idx: CIR.Expr.Capture.Idx) std.mem.Allocator.Error!void { - try store.addScratch("scratch_captures", idx); +pub fn addScratchCapture(store: *NodeStore, idx: CIR.Expr.Capture.Idx) Allocator.Error!void { + try store.addScratch("captures", idx); } /// Adds a statement index to the scratch statements list for building spans. -pub fn addScratchStatement(store: *NodeStore, idx: CIR.Statement.Idx) std.mem.Allocator.Error!void { - try store.addScratch("scratch_statements", idx); +pub fn addScratchStatement(store: *NodeStore, idx: CIR.Statement.Idx) Allocator.Error!void { + try store.addScratch("statements", idx); } /// Computes the span of an expression starting from a given index. -pub fn exprSpanFrom(store: *NodeStore, start: u32) std.mem.Allocator.Error!CIR.Expr.Span { - return try store.spanFrom("scratch_exprs", CIR.Expr.Span, start); +pub fn exprSpanFrom(store: *NodeStore, start: u32) Allocator.Error!CIR.Expr.Span { + return try store.spanFrom("exprs", CIR.Expr.Span, start); } /// Computes the span of captures starting from a given index. -pub fn capturesSpanFrom(store: *NodeStore, start: u32) std.mem.Allocator.Error!CIR.Expr.Capture.Span { - return try store.spanFrom("scratch_captures", CIR.Expr.Capture.Span, start); +pub fn capturesSpanFrom(store: *NodeStore, start: u32) Allocator.Error!CIR.Expr.Capture.Span { + return try store.spanFrom("captures", CIR.Expr.Capture.Span, start); } /// Creates a statement span from the given start position to the current top of scratch statements. -pub fn statementSpanFrom(store: *NodeStore, start: u32) std.mem.Allocator.Error!CIR.Statement.Span { - return try store.spanFrom("scratch_statements", CIR.Statement.Span, start); +pub fn statementSpanFrom(store: *NodeStore, start: u32) Allocator.Error!CIR.Statement.Span { + return try store.spanFrom("statements", CIR.Statement.Span, start); } /// Clears scratch expressions starting from a specified index. pub fn clearScratchExprsFrom(store: *NodeStore, start: u32) void { - store.clearScratchFrom("scratch_exprs", start); + store.clearScratchFrom("exprs", start); } /// Returns a slice of expressions from the scratch space. @@ -2152,97 +2277,97 @@ pub fn exprSlice(store: *const NodeStore, span: CIR.Expr.Span) []CIR.Expr.Idx { /// Returns the top index for scratch definitions. pub fn scratchDefTop(store: *NodeStore) u32 { - return store.scratchTop("scratch_defs"); + return store.scratchTop("defs"); } /// Adds a scratch definition to temporary storage. -pub fn addScratchDef(store: *NodeStore, idx: CIR.Def.Idx) std.mem.Allocator.Error!void { - try store.addScratch("scratch_defs", idx); +pub fn addScratchDef(store: *NodeStore, idx: CIR.Def.Idx) Allocator.Error!void { + try store.addScratch("defs", idx); } /// Adds a type annotation to the scratch buffer. -pub fn addScratchTypeAnno(store: *NodeStore, idx: CIR.TypeAnno.Idx) std.mem.Allocator.Error!void { - try store.addScratch("scratch_type_annos", idx); +pub fn addScratchTypeAnno(store: *NodeStore, idx: CIR.TypeAnno.Idx) Allocator.Error!void { + try store.addScratch("type_annos", idx); } /// Adds a where clause to the scratch buffer. -pub fn addScratchWhereClause(store: *NodeStore, idx: CIR.WhereClause.Idx) std.mem.Allocator.Error!void { - try store.addScratch("scratch_where_clauses", idx); +pub fn addScratchWhereClause(store: *NodeStore, idx: CIR.WhereClause.Idx) Allocator.Error!void { + try store.addScratch("where_clauses", idx); } /// Returns the current top of the scratch type annotations buffer. pub fn scratchTypeAnnoTop(store: *NodeStore) u32 { - return store.scratchTop("scratch_type_annos"); + return store.scratchTop("type_annos"); } /// Returns the current top of the scratch where clauses buffer. pub fn scratchWhereClauseTop(store: *NodeStore) u32 { - return store.scratchTop("scratch_where_clauses"); + return store.scratchTop("where_clauses"); } /// Clears scratch type annotations from the given index. pub fn clearScratchTypeAnnosFrom(store: *NodeStore, from: u32) void { - store.clearScratchFrom("scratch_type_annos", from); + store.clearScratchFrom("type_annos", from); } /// Clears scratch where clauses from the given index. pub fn clearScratchWhereClausesFrom(store: *NodeStore, from: u32) void { - store.clearScratchFrom("scratch_where_clauses", from); + store.clearScratchFrom("where_clauses", from); } /// Creates a span from the scratch type annotations starting at the given index. -pub fn typeAnnoSpanFrom(store: *NodeStore, start: u32) std.mem.Allocator.Error!CIR.TypeAnno.Span { - return try store.spanFrom("scratch_type_annos", CIR.TypeAnno.Span, start); +pub fn typeAnnoSpanFrom(store: *NodeStore, start: u32) Allocator.Error!CIR.TypeAnno.Span { + return try store.spanFrom("type_annos", CIR.TypeAnno.Span, start); } /// Returns a span from the scratch anno record fields starting at the given index. -pub fn annoRecordFieldSpanFrom(store: *NodeStore, start: u32) std.mem.Allocator.Error!CIR.TypeAnno.RecordField.Span { - return try store.spanFrom("scratch_anno_record_fields", CIR.TypeAnno.RecordField.Span, start); +pub fn annoRecordFieldSpanFrom(store: *NodeStore, start: u32) Allocator.Error!CIR.TypeAnno.RecordField.Span { + return try store.spanFrom("anno_record_fields", CIR.TypeAnno.RecordField.Span, start); } /// Returns a span from the scratch record fields starting at the given index. -pub fn recordFieldSpanFrom(store: *NodeStore, start: u32) std.mem.Allocator.Error!CIR.RecordField.Span { - return try store.spanFrom("scratch_record_fields", CIR.RecordField.Span, start); +pub fn recordFieldSpanFrom(store: *NodeStore, start: u32) Allocator.Error!CIR.RecordField.Span { + return try store.spanFrom("record_fields", CIR.RecordField.Span, start); } /// Returns a span from the scratch where clauses starting at the given index. -pub fn whereClauseSpanFrom(store: *NodeStore, start: u32) std.mem.Allocator.Error!CIR.WhereClause.Span { - return try store.spanFrom("scratch_where_clauses", CIR.WhereClause.Span, start); +pub fn whereClauseSpanFrom(store: *NodeStore, start: u32) Allocator.Error!CIR.WhereClause.Span { + return try store.spanFrom("where_clauses", CIR.WhereClause.Span, start); } /// Returns the current top of the scratch exposed items buffer. pub fn scratchExposedItemTop(store: *NodeStore) u32 { - return store.scratchTop("scratch_exposed_items"); + return store.scratchTop("exposed_items"); } /// Adds an exposed item to the scratch buffer. -pub fn addScratchExposedItem(store: *NodeStore, idx: CIR.ExposedItem.Idx) std.mem.Allocator.Error!void { - try store.addScratch("scratch_exposed_items", idx); +pub fn addScratchExposedItem(store: *NodeStore, idx: CIR.ExposedItem.Idx) Allocator.Error!void { + try store.addScratch("exposed_items", idx); } /// Creates a span from the scratch exposed items starting at the given index. -pub fn exposedItemSpanFrom(store: *NodeStore, start: u32) std.mem.Allocator.Error!CIR.ExposedItem.Span { - return try store.spanFrom("scratch_exposed_items", CIR.ExposedItem.Span, start); +pub fn exposedItemSpanFrom(store: *NodeStore, start: u32) Allocator.Error!CIR.ExposedItem.Span { + return try store.spanFrom("exposed_items", CIR.ExposedItem.Span, start); } /// Clears scratch exposed items from the given index. pub fn clearScratchExposedItemsFrom(store: *NodeStore, start: u32) void { - store.clearScratchFrom("scratch_exposed_items", start); + store.clearScratchFrom("exposed_items", start); } /// Returns the start position for a new Span of annoRecordFieldIdxs in scratch pub fn scratchAnnoRecordFieldTop(store: *NodeStore) u32 { - return store.scratchTop("scratch_anno_record_fields"); + return store.scratchTop("anno_record_fields"); } /// Places a new CIR.TypeAnno.RecordField.Idx in the scratch. Will panic on OOM. -pub fn addScratchAnnoRecordField(store: *NodeStore, idx: CIR.TypeAnno.RecordField.Idx) std.mem.Allocator.Error!void { - try store.addScratch("scratch_anno_record_fields", idx); +pub fn addScratchAnnoRecordField(store: *NodeStore, idx: CIR.TypeAnno.RecordField.Idx) Allocator.Error!void { + try store.addScratch("anno_record_fields", idx); } /// Clears any AnnoRecordFieldIds added to scratch from start until the end. pub fn clearScratchAnnoRecordFieldsFrom(store: *NodeStore, start: u32) void { - store.clearScratchFrom("scratch_anno_record_fields", start); + store.clearScratchFrom("anno_record_fields", start); } /// Returns a new AnnoRecordField slice so that the caller can iterate through @@ -2252,43 +2377,43 @@ pub fn annoRecordFieldSlice(store: *NodeStore, span: CIR.TypeAnno.RecordField.Sp } /// Computes the span of a definition starting from a given index. -pub fn defSpanFrom(store: *NodeStore, start: u32) std.mem.Allocator.Error!CIR.Def.Span { - return try store.spanFrom("scratch_defs", CIR.Def.Span, start); +pub fn defSpanFrom(store: *NodeStore, start: u32) Allocator.Error!CIR.Def.Span { + return try store.spanFrom("defs", CIR.Def.Span, start); } /// Retrieves a slice of record destructures from the store. -pub fn recordDestructSpanFrom(store: *NodeStore, start: u32) std.mem.Allocator.Error!CIR.Pattern.RecordDestruct.Span { - return try store.spanFrom("scratch_record_destructs", CIR.Pattern.RecordDestruct.Span, start); +pub fn recordDestructSpanFrom(store: *NodeStore, start: u32) Allocator.Error!CIR.Pattern.RecordDestruct.Span { + return try store.spanFrom("record_destructs", CIR.Pattern.RecordDestruct.Span, start); } /// Returns the current top of the scratch patterns buffer. pub fn scratchPatternTop(store: *NodeStore) u32 { - return store.scratchTop("scratch_patterns"); + return store.scratchTop("patterns"); } /// Adds a pattern to the scratch patterns list for building spans. -pub fn addScratchPattern(store: *NodeStore, idx: CIR.Pattern.Idx) std.mem.Allocator.Error!void { - try store.addScratch("scratch_patterns", idx); +pub fn addScratchPattern(store: *NodeStore, idx: CIR.Pattern.Idx) Allocator.Error!void { + try store.addScratch("patterns", idx); } /// Returns the current top of the scratch record destructures buffer. pub fn scratchRecordDestructTop(store: *NodeStore) u32 { - return store.scratchTop("scratch_record_destructs"); + return store.scratchTop("record_destructs"); } /// Adds a record destructure to the scratch record destructures list for building spans. -pub fn addScratchRecordDestruct(store: *NodeStore, idx: CIR.Pattern.RecordDestruct.Idx) std.mem.Allocator.Error!void { - try store.addScratch("scratch_record_destructs", idx); +pub fn addScratchRecordDestruct(store: *NodeStore, idx: CIR.Pattern.RecordDestruct.Idx) Allocator.Error!void { + try store.addScratch("record_destructs", idx); } /// Creates a pattern span from the given start position to the current top of scratch patterns. -pub fn patternSpanFrom(store: *NodeStore, start: u32) std.mem.Allocator.Error!CIR.Pattern.Span { - return try store.spanFrom("scratch_patterns", CIR.Pattern.Span, start); +pub fn patternSpanFrom(store: *NodeStore, start: u32) Allocator.Error!CIR.Pattern.Span { + return try store.spanFrom("patterns", CIR.Pattern.Span, start); } /// Clears scratch definitions starting from a specified index. pub fn clearScratchDefsFrom(store: *NodeStore, start: u32) void { - store.clearScratchFrom("scratch_defs", start); + store.clearScratchFrom("defs", start); } /// Creates a slice corresponding to a span. @@ -2363,24 +2488,24 @@ pub fn lastFromStatements(store: *const NodeStore, span: CIR.Statement.Span) CIR /// Returns a slice of if branches from the store. pub fn scratchIfBranchTop(store: *NodeStore) u32 { - return store.scratchTop("scratch_if_branches"); + return store.scratchTop("if_branches"); } /// Adds an if branch to the scratch if branches list for building spans. -pub fn addScratchIfBranch(store: *NodeStore, if_branch_idx: CIR.Expr.IfBranch.Idx) std.mem.Allocator.Error!void { - try store.addScratch("scratch_if_branches", if_branch_idx); +pub fn addScratchIfBranch(store: *NodeStore, if_branch_idx: CIR.Expr.IfBranch.Idx) Allocator.Error!void { + try store.addScratch("if_branches", if_branch_idx); } /// Creates an if branch span from the given start position to the current top of scratch if branches. -pub fn ifBranchSpanFrom(store: *NodeStore, start: u32) std.mem.Allocator.Error!CIR.Expr.IfBranch.Span { - return try store.spanFrom("scratch_if_branches", CIR.Expr.IfBranch.Span, start); +pub fn ifBranchSpanFrom(store: *NodeStore, start: u32) Allocator.Error!CIR.Expr.IfBranch.Span { + return try store.spanFrom("if_branches", CIR.Expr.IfBranch.Span, start); } /// Adds an if branch to the store and returns its index. /// /// IMPORTANT: You should not use this function directly! Instead, use it's /// corresponding function in `ModuleEnv`. -pub fn addIfBranch(store: *NodeStore, if_branch: CIR.Expr.IfBranch, region: base.Region) std.mem.Allocator.Error!CIR.Expr.IfBranch.Idx { +pub fn addIfBranch(store: *NodeStore, if_branch: CIR.Expr.IfBranch, region: base.Region) Allocator.Error!CIR.Expr.IfBranch.Idx { const node = Node{ .data_1 = @intFromEnum(if_branch.cond), .data_2 = @intFromEnum(if_branch.body), @@ -2434,7 +2559,7 @@ pub fn sliceRecordDestructs(store: *const NodeStore, span: CIR.Pattern.RecordDes /// /// IMPORTANT: You should not use this function directly! Instead, use it's /// corresponding function in `ModuleEnv`. -pub fn addDiagnostic(store: *NodeStore, reason: CIR.Diagnostic) std.mem.Allocator.Error!CIR.Diagnostic.Idx { +pub fn addDiagnostic(store: *NodeStore, reason: CIR.Diagnostic) Allocator.Error!CIR.Diagnostic.Idx { var node = Node{ .data_1 = 0, .data_2 = 0, @@ -2540,6 +2665,52 @@ pub fn addDiagnostic(store: *NodeStore, reason: CIR.Diagnostic) std.mem.Allocato node.tag = .diag_where_clause_not_allowed_in_type_decl; region = r.region; }, + .type_module_missing_matching_type => |r| { + node.tag = .diag_type_module_missing_matching_type; + region = r.region; + node.data_1 = @bitCast(r.module_name); + }, + .default_app_missing_main => |r| { + node.tag = .diag_default_app_missing_main; + region = r.region; + node.data_1 = @bitCast(r.module_name); + }, + .default_app_wrong_arity => |r| { + node.tag = .diag_default_app_wrong_arity; + region = r.region; + node.data_1 = r.arity; + }, + .cannot_import_default_app => |r| { + node.tag = .diag_cannot_import_default_app; + region = r.region; + node.data_1 = @bitCast(r.module_name); + }, + .execution_requires_app_or_default_app => |r| { + node.tag = .diag_execution_requires_app_or_default_app; + region = r.region; + }, + .type_name_case_mismatch => |r| { + node.tag = .diag_type_name_case_mismatch; + region = r.region; + node.data_1 = @bitCast(r.module_name); + node.data_2 = @bitCast(r.type_name); + }, + .module_header_deprecated => |r| { + node.tag = .diag_module_header_deprecated; + region = r.region; + }, + .redundant_expose_main_type => |r| { + node.tag = .diag_redundant_expose_main_type; + region = r.region; + node.data_1 = @bitCast(r.type_name); + node.data_2 = @bitCast(r.module_name); + }, + .invalid_main_type_rename_in_exposing => |r| { + node.tag = .diag_invalid_main_type_rename_in_exposing; + region = r.region; + node.data_1 = @bitCast(r.type_name); + node.data_2 = @bitCast(r.alias); + }, .var_across_function_boundary => |r| { node.tag = .diag_var_across_function_boundary; region = r.region; @@ -2694,7 +2865,7 @@ pub fn addDiagnostic(store: *NodeStore, reason: CIR.Diagnostic) std.mem.Allocato _ = try store.regions.append(store.gpa, region); // append to our scratch so we can get a span later of all our diagnostics - try store.addScratch("scratch_diagnostics", @as(CIR.Diagnostic.Idx, @enumFromInt(nid))); + try store.addScratch("diagnostics", @as(CIR.Diagnostic.Idx, @enumFromInt(nid))); return @enumFromInt(nid); } @@ -2715,7 +2886,7 @@ pub fn addDiagnostic(store: *NodeStore, reason: CIR.Diagnostic) std.mem.Allocato /// /// IMPORTANT: You should not use this function directly! Instead, use it's /// corresponding function in `ModuleEnv`. -pub fn addMalformed(store: *NodeStore, diagnostic_idx: CIR.Diagnostic.Idx, region: Region) std.mem.Allocator.Error!Node.Idx { +pub fn addMalformed(store: *NodeStore, diagnostic_idx: CIR.Diagnostic.Idx, region: Region) Allocator.Error!Node.Idx { const malformed_node = Node{ .data_1 = @intFromEnum(diagnostic_idx), .data_2 = 0, @@ -2870,6 +3041,43 @@ pub fn getDiagnostic(store: *const NodeStore, diagnostic: CIR.Diagnostic.Idx) CI .diag_where_clause_not_allowed_in_type_decl => return CIR.Diagnostic{ .where_clause_not_allowed_in_type_decl = .{ .region = store.getRegionAt(node_idx), } }, + .diag_type_module_missing_matching_type => return CIR.Diagnostic{ .type_module_missing_matching_type = .{ + .module_name = @bitCast(node.data_1), + .region = store.getRegionAt(node_idx), + } }, + .diag_default_app_missing_main => return CIR.Diagnostic{ .default_app_missing_main = .{ + .module_name = @bitCast(node.data_1), + .region = store.getRegionAt(node_idx), + } }, + .diag_default_app_wrong_arity => return CIR.Diagnostic{ .default_app_wrong_arity = .{ + .arity = node.data_1, + .region = store.getRegionAt(node_idx), + } }, + .diag_cannot_import_default_app => return CIR.Diagnostic{ .cannot_import_default_app = .{ + .module_name = @bitCast(node.data_1), + .region = store.getRegionAt(node_idx), + } }, + .diag_execution_requires_app_or_default_app => return CIR.Diagnostic{ .execution_requires_app_or_default_app = .{ + .region = store.getRegionAt(node_idx), + } }, + .diag_type_name_case_mismatch => return CIR.Diagnostic{ .type_name_case_mismatch = .{ + .module_name = @bitCast(node.data_1), + .type_name = @bitCast(node.data_2), + .region = store.getRegionAt(node_idx), + } }, + .diag_module_header_deprecated => return CIR.Diagnostic{ .module_header_deprecated = .{ + .region = store.getRegionAt(node_idx), + } }, + .diag_redundant_expose_main_type => return CIR.Diagnostic{ .redundant_expose_main_type = .{ + .type_name = @bitCast(node.data_1), + .module_name = @bitCast(node.data_2), + .region = store.getRegionAt(node_idx), + } }, + .diag_invalid_main_type_rename_in_exposing => return CIR.Diagnostic{ .invalid_main_type_rename_in_exposing = .{ + .type_name = @bitCast(node.data_1), + .alias = @bitCast(node.data_2), + .region = store.getRegionAt(node_idx), + } }, .diag_type_alias_redeclared => return CIR.Diagnostic{ .type_alias_redeclared = .{ .name = @bitCast(node.data_1), .redeclared_region = store.getRegionAt(node_idx), @@ -2962,13 +3170,13 @@ pub fn getDiagnostic(store: *const NodeStore, diagnostic: CIR.Diagnostic.Idx) CI } /// Computes the span of a diagnostic starting from a given index. -pub fn diagnosticSpanFrom(store: *NodeStore, start: u32) std.mem.Allocator.Error!CIR.Diagnostic.Span { - return try store.spanFrom("scratch_diagnostics", CIR.Diagnostic.Span, start); +pub fn diagnosticSpanFrom(store: *NodeStore, start: u32) Allocator.Error!CIR.Diagnostic.Span { + return try store.spanFrom("diagnostics", CIR.Diagnostic.Span, start); } /// Ensure the node store has capacity for at least the requested number of /// slots. Then return the *final* index. -pub fn predictNodeIndex(store: *NodeStore, count: u32) std.mem.Allocator.Error!Node.Idx { +pub fn predictNodeIndex(store: *NodeStore, count: u32) Allocator.Error!Node.Idx { const start_idx = store.nodes.len(); try store.nodes.ensureTotalCapacity(store.gpa, start_idx + count); // Return where the LAST node will actually be placed @@ -2979,7 +3187,7 @@ pub fn predictNodeIndex(store: *NodeStore, count: u32) std.mem.Allocator.Error!N /// /// IMPORTANT: You should not use this function directly! Instead, use it's /// corresponding function in `ModuleEnv`. -pub fn addTypeVarSlot(store: *NodeStore, parent_node_idx: Node.Idx, region: base.Region) std.mem.Allocator.Error!Node.Idx { +pub fn addTypeVarSlot(store: *NodeStore, parent_node_idx: Node.Idx, region: base.Region) Allocator.Error!Node.Idx { const nid = try store.nodes.append(store.gpa, .{ .tag = .type_var_slot, .data_1 = @intFromEnum(parent_node_idx), @@ -2994,7 +3202,7 @@ pub fn addTypeVarSlot(store: *NodeStore, parent_node_idx: Node.Idx, region: base /// If it is, do nothing /// If it's not, then fill in the store with type_var_slots for all missing /// intervening nodes, *up to and including* the provided node -pub fn fillInTypeVarSlotsThru(store: *NodeStore, target_idx: Node.Idx, parent_node_idx: Node.Idx, region: Region) std.mem.Allocator.Error!void { +pub fn fillInTypeVarSlotsThru(store: *NodeStore, target_idx: Node.Idx, parent_node_idx: Node.Idx, region: Region) Allocator.Error!void { const idx = @intFromEnum(target_idx); try store.nodes.items.ensureTotalCapacity(store.gpa, idx); while (store.nodes.items.len <= idx) { @@ -3010,116 +3218,49 @@ pub fn fillInTypeVarSlotsThru(store: *NodeStore, target_idx: Node.Idx, parent_no /// Return the current top index for scratch match branches. pub fn scratchMatchBranchTop(store: *NodeStore) u32 { - return store.scratchTop("scratch_match_branches"); + return store.scratchTop("match_branches"); } /// Add a match branch index to the scratch buffer. -pub fn addScratchMatchBranch(store: *NodeStore, branch_idx: CIR.Expr.Match.Branch.Idx) std.mem.Allocator.Error!void { - try store.addScratch("scratch_match_branches", branch_idx); +pub fn addScratchMatchBranch(store: *NodeStore, branch_idx: CIR.Expr.Match.Branch.Idx) Allocator.Error!void { + try store.addScratch("match_branches", branch_idx); } /// Create a span from the scratch match branches starting at the given index. -pub fn matchBranchSpanFrom(store: *NodeStore, start: u32) std.mem.Allocator.Error!CIR.Expr.Match.Branch.Span { - return try store.spanFrom("scratch_match_branches", CIR.Expr.Match.Branch.Span, start); +pub fn matchBranchSpanFrom(store: *NodeStore, start: u32) Allocator.Error!CIR.Expr.Match.Branch.Span { + return try store.spanFrom("match_branches", CIR.Expr.Match.Branch.Span, start); } /// Return the current top index for scratch match branch patterns. pub fn scratchMatchBranchPatternTop(store: *NodeStore) u32 { - return store.scratchTop("scratch_match_branch_patterns"); + return store.scratchTop("match_branch_patterns"); } /// Add a match branch pattern index to the scratch buffer. -pub fn addScratchMatchBranchPattern(store: *NodeStore, pattern_idx: CIR.Expr.Match.BranchPattern.Idx) std.mem.Allocator.Error!void { - try store.addScratch("scratch_match_branch_patterns", pattern_idx); +pub fn addScratchMatchBranchPattern(store: *NodeStore, pattern_idx: CIR.Expr.Match.BranchPattern.Idx) Allocator.Error!void { + try store.addScratch("match_branch_patterns", pattern_idx); } /// Create a span from the scratch match branch patterns starting at the given index. -pub fn matchBranchPatternSpanFrom(store: *NodeStore, start: u32) std.mem.Allocator.Error!CIR.Expr.Match.BranchPattern.Span { - return try store.spanFrom("scratch_match_branch_patterns", CIR.Expr.Match.BranchPattern.Span, start); -} - -/// Serialize this NodeStore to the given CompactWriter. The resulting NodeStore -/// in the writer's buffer will have offsets instead of pointers. Calling any -/// methods on it or dereferencing its internal "pointers" (which are now -/// offsets) is illegal behavior! -pub fn serialize( - self: *const NodeStore, - allocator: std.mem.Allocator, - writer: *CompactWriter, -) std.mem.Allocator.Error!*const NodeStore { - // First, write the NodeStore struct itself - const offset_self = try writer.appendAlloc(allocator, NodeStore); - - // Then serialize the sub-structures and update the struct - offset_self.* = .{ - .gpa = undefined, // Will be set when deserializing - .nodes = (try self.nodes.serialize(allocator, writer)).*, - .regions = (try self.regions.serialize(allocator, writer)).*, - .extra_data = (try self.extra_data.serialize(allocator, writer)).*, - // All scratch arrays are serialized as empty - // TODO: maybe we can put these all at the end of ModuleEnv and not bother serializing them, and just re-init on deserialization? - .scratch_statements = .{ .items = .{} }, - .scratch_exprs = .{ .items = .{} }, - .scratch_captures = .{ .items = .{} }, - .scratch_record_fields = .{ .items = .{} }, - .scratch_match_branches = .{ .items = .{} }, - .scratch_match_branch_patterns = .{ .items = .{} }, - .scratch_if_branches = .{ .items = .{} }, - .scratch_where_clauses = .{ .items = .{} }, - .scratch_patterns = .{ .items = .{} }, - .scratch_pattern_record_fields = .{ .items = .{} }, - .scratch_record_destructs = .{ .items = .{} }, - .scratch_type_annos = .{ .items = .{} }, - .scratch_anno_record_fields = .{ .items = .{} }, - .scratch_exposed_items = .{ .items = .{} }, - .scratch_defs = .{ .items = .{} }, - .scratch_diagnostics = .{ .items = .{} }, - }; - - return @constCast(offset_self); -} - -/// Add the given offset to the memory addresses of all pointers in `self`. -pub fn relocate(self: *NodeStore, offset: isize) void { - self.nodes.relocate(offset); - self.regions.relocate(offset); - self.extra_data.relocate(offset); - // Note: scratch arrays are empty after deserialization, so no need to relocate +pub fn matchBranchPatternSpanFrom(store: *NodeStore, start: u32) Allocator.Error!CIR.Expr.Match.BranchPattern.Span { + return try store.spanFrom("match_branch_patterns", CIR.Expr.Match.BranchPattern.Span, start); } /// Serialized representation of NodeStore pub const Serialized = struct { + gpa: [2]u64, // Reserve enough space for 2 64-bit pointers nodes: Node.List.Serialized, regions: Region.List.Serialized, extra_data: collections.SafeList(u32).Serialized, - // Scratch arrays - not serialized, just placeholders to match NodeStore size - // TODO move these out of NodeStore so that we don't need to serialize and - // deserialize a bunch of zeros for these; it's a waste of space. - scratch_statements: std.ArrayList(CIR.Statement.Idx) = .{}, - scratch_exprs: std.ArrayList(CIR.Expr.Idx) = .{}, - scratch_record_fields: std.ArrayList(CIR.RecordField.Idx) = .{}, - scratch_match_branches: std.ArrayList(CIR.Expr.Match.Branch.Idx) = .{}, - scratch_match_branch_patterns: std.ArrayList(CIR.Expr.Match.BranchPattern.Idx) = .{}, - scratch_if_branches: std.ArrayList(CIR.Expr.IfBranch.Idx) = .{}, - scratch_where_clauses: std.ArrayList(CIR.WhereClause.Idx) = .{}, - scratch_patterns: std.ArrayList(CIR.Pattern.Idx) = .{}, - scratch_pattern_record_fields: std.ArrayList(CIR.PatternRecordField.Idx) = .{}, - scratch_record_destructs: std.ArrayList(CIR.Pattern.RecordDestruct.Idx) = .{}, - scratch_type_annos: std.ArrayList(CIR.TypeAnno.Idx) = .{}, - scratch_anno_record_fields: std.ArrayList(CIR.TypeAnno.RecordField.Idx) = .{}, - scratch_exposed_items: std.ArrayList(CIR.ExposedItem.Idx) = .{}, - scratch_defs: std.ArrayList(CIR.Def.Idx) = .{}, - scratch_diagnostics: std.ArrayList(CIR.Diagnostic.Idx) = .{}, - scratch_captures: std.ArrayList(CIR.Expr.Capture.Idx) = .{}, - gpa: std.mem.Allocator = undefined, + scratch: u64, // Reserve enough space for a 64-bit pointer /// Serialize a NodeStore into this Serialized struct, appending data to the writer pub fn serialize( self: *Serialized, store: *const NodeStore, - allocator: std.mem.Allocator, + allocator: Allocator, writer: *CompactWriter, - ) std.mem.Allocator.Error!void { + ) Allocator.Error!void { // Serialize nodes try self.nodes.serialize(&store.nodes, allocator, writer); // Serialize regions @@ -3129,7 +3270,7 @@ pub const Serialized = struct { } /// Deserialize this Serialized struct into a NodeStore - pub fn deserialize(self: *Serialized, offset: i64, gpa: std.mem.Allocator) *NodeStore { + pub fn deserialize(self: *Serialized, offset: i64, gpa: Allocator) *NodeStore { // NodeStore.Serialized should be at least as big as NodeStore std.debug.assert(@sizeOf(Serialized) >= @sizeOf(NodeStore)); @@ -3141,23 +3282,7 @@ pub const Serialized = struct { .nodes = self.nodes.deserialize(offset).*, .regions = self.regions.deserialize(offset).*, .extra_data = self.extra_data.deserialize(offset).*, - // Initialize scratch arrays as proper Scratch instances - .scratch_statements = base.Scratch(CIR.Statement.Idx){ .items = .{} }, - .scratch_exprs = base.Scratch(CIR.Expr.Idx){ .items = .{} }, - .scratch_captures = base.Scratch(CIR.Expr.Capture.Idx){ .items = .{} }, - .scratch_patterns = base.Scratch(CIR.Pattern.Idx){ .items = .{} }, - .scratch_record_fields = base.Scratch(CIR.RecordField.Idx){ .items = .{} }, - .scratch_pattern_record_fields = base.Scratch(CIR.PatternRecordField.Idx){ .items = .{} }, - .scratch_record_destructs = base.Scratch(CIR.Pattern.RecordDestruct.Idx){ .items = .{} }, - .scratch_match_branches = base.Scratch(CIR.Expr.Match.Branch.Idx){ .items = .{} }, - .scratch_match_branch_patterns = base.Scratch(CIR.Expr.Match.BranchPattern.Idx){ .items = .{} }, - .scratch_if_branches = base.Scratch(CIR.Expr.IfBranch.Idx){ .items = .{} }, - .scratch_type_annos = base.Scratch(CIR.TypeAnno.Idx){ .items = .{} }, - .scratch_anno_record_fields = base.Scratch(CIR.TypeAnno.RecordField.Idx){ .items = .{} }, - .scratch_exposed_items = base.Scratch(CIR.ExposedItem.Idx){ .items = .{} }, - .scratch_defs = base.Scratch(CIR.Def.Idx){ .items = .{} }, - .scratch_where_clauses = base.Scratch(CIR.WhereClause.Idx){ .items = .{} }, - .scratch_diagnostics = base.Scratch(CIR.Diagnostic.Idx){ .items = .{} }, + .scratch = null, // A deserialized NodeStore is read-only, so it has no need for scratch memory! }; return store; @@ -3310,7 +3435,7 @@ test "NodeStore multiple nodes CompactWriter roundtrip" { .tag = .expr_list, .data_1 = 10, // elems start .data_2 = 3, // elems len - .data_3 = 2, // elem_var + .data_3 = 0, }; _ = try original.nodes.append(gpa, list_node); @@ -3383,7 +3508,6 @@ test "NodeStore multiple nodes CompactWriter roundtrip" { try testing.expectEqual(Node.Tag.expr_list, retrieved_list.tag); try testing.expectEqual(@as(u32, 10), retrieved_list.data_1); try testing.expectEqual(@as(u32, 3), retrieved_list.data_2); - try testing.expectEqual(@as(u32, 2), retrieved_list.data_3); // Verify float node and extra data const retrieved_float = deserialized.nodes.get(@enumFromInt(2)); @@ -3401,8 +3525,6 @@ test "NodeStore multiple nodes CompactWriter roundtrip" { try testing.expectEqual(expected_region.end.offset, retrieved_region.end.offset); } - // Verify all scratch arrays are empty - try testing.expectEqual(@as(usize, 0), deserialized.scratch_statements.items.items.len); - try testing.expectEqual(@as(usize, 0), deserialized.scratch_exprs.items.items.len); - try testing.expectEqual(@as(usize, 0), deserialized.scratch_patterns.items.items.len); + // Verify scratch is null (deserialized NodeStores don't allocate scratch) + try testing.expect(deserialized.scratch == null); } diff --git a/src/canonicalize/Pattern.zig b/src/canonicalize/Pattern.zig index 942505fa5b..92478d83b5 100644 --- a/src/canonicalize/Pattern.zig +++ b/src/canonicalize/Pattern.zig @@ -101,8 +101,6 @@ pub const Pattern = union(enum) { /// } /// ``` record_destructure: struct { - whole_var: TypeVar, - ext_var: TypeVar, destructs: RecordDestruct.Span, }, /// Pattern that destructures a list, with optional rest pattern. @@ -118,8 +116,6 @@ pub const Pattern = union(enum) { /// } /// ``` list: struct { - list_var: TypeVar, - elem_var: TypeVar, patterns: Pattern.Span, // All non-rest patterns rest_info: ?struct { index: u32, // Where the rest appears (split point) @@ -148,8 +144,9 @@ pub const Pattern = union(enum) { /// n => "many" /// } /// ``` - int_literal: struct { + num_literal: struct { value: CIR.IntValue, + kind: CIR.NumKind, }, /// Pattern that matches a small decimal literal (represented as rational number). /// This is Roc's preferred approach for exact decimal matching, avoiding @@ -163,8 +160,8 @@ pub const Pattern = union(enum) { /// } /// ``` small_dec_literal: struct { - numerator: i16, - denominator_power_of_ten: u8, + value: CIR.SmallDecValue, + has_suffix: bool, }, /// Pattern that matches a high-precision decimal literal. /// Used for exact decimal matching with arbitrary precision. @@ -177,6 +174,7 @@ pub const Pattern = union(enum) { /// ``` dec_literal: struct { value: RocDec, + has_suffix: bool, }, /// Pattern that matches a specific f32 literal value exactly. /// Used for exact matching in pattern expressions. @@ -435,14 +433,13 @@ pub const Pattern = union(enum) { try tree.endNode(begin, attrs); }, - .int_literal => |p| { + .num_literal => |p| { const begin = tree.beginNode(); - try tree.pushStaticAtom("p-int"); + try tree.pushStaticAtom("p-num"); try ir.appendRegionInfoToSExprTree(tree, pattern_idx); - const value_i128: i128 = @bitCast(p.value.bytes); var value_buf: [40]u8 = undefined; - const value_str = std.fmt.bufPrint(&value_buf, "{}", .{value_i128}) catch "fmt_error"; + const value_str = p.value.bufPrint(&value_buf) catch unreachable; try tree.pushStringPair("value", value_str); const attrs = tree.beginNode(); diff --git a/src/canonicalize/Scope.zig b/src/canonicalize/Scope.zig index d0ea372c71..831513aa8b 100644 --- a/src/canonicalize/Scope.zig +++ b/src/canonicalize/Scope.zig @@ -15,6 +15,9 @@ idents: std.AutoHashMapUnmanaged(Ident.Idx, CIR.Pattern.Idx), aliases: std.AutoHashMapUnmanaged(Ident.Idx, CIR.Pattern.Idx), /// Maps type names to their type declaration statements type_decls: std.AutoHashMapUnmanaged(Ident.Idx, CIR.Statement.Idx), +/// Maps unqualified type names to their fully qualified Statement.Idx (for associated types) +/// Example: within Foo's associated block, "Bar" -> statement for "Foo.Bar" +type_aliases: std.AutoHashMapUnmanaged(Ident.Idx, CIR.Statement.Idx), /// Maps type variables to their type annotation indices type_vars: std.AutoHashMapUnmanaged(Ident.Idx, CIR.TypeAnno.Idx), /// Maps module alias names to their full module names @@ -31,6 +34,7 @@ pub fn init(is_function_boundary: bool) Scope { .idents = std.AutoHashMapUnmanaged(Ident.Idx, CIR.Pattern.Idx){}, .aliases = std.AutoHashMapUnmanaged(Ident.Idx, CIR.Pattern.Idx){}, .type_decls = std.AutoHashMapUnmanaged(Ident.Idx, CIR.Statement.Idx){}, + .type_aliases = std.AutoHashMapUnmanaged(Ident.Idx, CIR.Statement.Idx){}, .type_vars = std.AutoHashMapUnmanaged(Ident.Idx, CIR.TypeAnno.Idx){}, .module_aliases = std.AutoHashMapUnmanaged(Ident.Idx, Ident.Idx){}, .exposed_items = std.AutoHashMapUnmanaged(Ident.Idx, ExposedItemInfo){}, @@ -44,6 +48,7 @@ pub fn deinit(self: *Scope, gpa: std.mem.Allocator) void { self.idents.deinit(gpa); self.aliases.deinit(gpa); self.type_decls.deinit(gpa); + self.type_aliases.deinit(gpa); self.type_vars.deinit(gpa); self.module_aliases.deinit(gpa); self.exposed_items.deinit(gpa); @@ -248,6 +253,22 @@ pub fn lookupTypeDecl(scope: *const Scope, name: Ident.Idx) TypeLookupResult { return TypeLookupResult{ .not_found = {} }; } +/// Look up an unqualified type alias (for associated types) +pub fn lookupTypeAlias(scope: *const Scope, name: Ident.Idx) ?CIR.Statement.Idx { + return scope.type_aliases.get(name); +} + +/// Introduce an unqualified type alias (for associated types) +/// Maps an unqualified name to a fully qualified type declaration +pub fn introduceTypeAlias( + scope: *Scope, + gpa: std.mem.Allocator, + unqualified_name: Ident.Idx, + qualified_type_decl: CIR.Statement.Idx, +) !void { + try scope.type_aliases.put(gpa, unqualified_name, qualified_type_decl); +} + /// Update an existing type declaration in the scope /// This is used for recursive type declarations where we need to update /// the statement index after canonicalizing the type annotation diff --git a/src/canonicalize/TypeAnnotation.zig b/src/canonicalize/TypeAnnotation.zig index ccc49325f2..f732b2e46e 100644 --- a/src/canonicalize/TypeAnnotation.zig +++ b/src/canonicalize/TypeAnnotation.zig @@ -19,6 +19,7 @@ const SExpr = base.SExpr; const SExprTree = base.SExprTree; const TypeVar = types.Var; const Expr = CIR.Expr; +const Statement = CIR.Statement; const IntValue = CIR.IntValue; const RocDec = builtins.RocDec; @@ -32,28 +33,44 @@ pub const TypeAnno = union(enum) { /// /// Examples: `List(Str)`, `Dict(String, Int)`, `Result(a, b)` apply: Apply, - /// Type application: applying a type constructor to arguments. - /// - /// Examples: `OtherModule.MyMap(String, Int)` - apply_external: ApplyExternal, /// Type variable: a placeholder type that can be unified with other types. /// /// Examples: `a`, `b`, `elem` in generic type signatures - ty_var: struct { + rigid_var: struct { name: Ident.Idx, // The variable name (e.g., "a", "b") }, + /// A rigid var that references another + /// + /// Examples: + /// + /// MyAlias(a) = List(a) + /// rigid_var ^ ^ rigid_var_lookup + /// + /// myFunction : a -> a + /// rigid_var ^ ^ rigid_var_lookup + rigid_var_lookup: struct { + ref: TypeAnno.Idx, // The variable name (e.g., "a", "b") + }, /// Inferred type `_` underscore: void, /// Basic type identifier: a concrete type name without arguments. /// /// Examples: `Str`, `U64`, `Bool` - ty: struct { - symbol: Ident.Idx, // The type name + lookup: struct { + name: Ident.Idx, // The type name + base: LocalOrExternal, }, /// Tag union type: a union of tags, possibly with payloads. /// /// Examples: `[Some(a), None]`, `[Red, Green, Blue]`, `[Cons(a, (List a)), Nil]` tag_union: TagUnion, + /// A tag in a gat union + /// + /// Examples: `Some(a)`, `None` + tag: struct { + name: Ident.Idx, // The tag name + args: TypeAnno.Span, // The tag arguments + }, /// Tuple type: a fixed-size collection of heterogeneous types. /// /// Examples: `(Str, U64)`, `(a, b, c)` @@ -72,13 +89,6 @@ pub const TypeAnno = union(enum) { parens: struct { anno: TypeAnno.Idx, // The type inside the parentheses }, - /// External type lookup: references a type from another module via external declaration. - /// - /// Examples: `Json.Value`, `Http.Request` - types that will be resolved when dependencies are available - ty_lookup_external: struct { - module_idx: CIR.Import.Idx, - target_node_idx: u16, - }, /// Malformed type annotation: represents a type that couldn't be parsed correctly. /// This follows the "Inform Don't Block" principle - compilation continues with /// an error marker that will be reported to the user. @@ -96,9 +106,41 @@ pub const TypeAnno = union(enum) { try tree.pushStaticAtom("ty-apply"); const region = ir.store.getTypeAnnoRegion(type_anno_idx); try ir.appendRegionInfoToSExprTreeFromRegion(tree, region); - try tree.pushStringPair("symbol", ir.getIdentText(a.symbol)); - const attrs = tree.beginNode(); + try tree.pushStringPair("name", ir.getIdentText(a.name)); + switch (a.base) { + .builtin => |_| { + const field_begin = tree.beginNode(); + try tree.pushStaticAtom("builtin"); + const field_attrs = tree.beginNode(); + try tree.endNode(field_begin, field_attrs); + }, + .local => |_| { + const field_begin = tree.beginNode(); + try tree.pushStaticAtom("local"); + const field_attrs = tree.beginNode(); + try tree.endNode(field_begin, field_attrs); + }, + .external => |external| { + const ext_begin = tree.beginNode(); + try tree.pushStaticAtom("external"); + + // Add module index + var buf: [32]u8 = undefined; + const module_idx_str = std.fmt.bufPrint(&buf, "{}", .{@intFromEnum(external.module_idx)}) catch unreachable; + try tree.pushStringPair("module-idx", module_idx_str); + + // Add target node index + var buf2: [32]u8 = undefined; + const target_idx_str = std.fmt.bufPrint(&buf2, "{}", .{external.target_node_idx}) catch unreachable; + try tree.pushStringPair("target-node-idx", target_idx_str); + + const field_attrs = tree.beginNode(); + try tree.endNode(ext_begin, field_attrs); + }, + } + + const attrs = tree.beginNode(); const args_slice = ir.store.sliceTypeAnnos(a.args); for (args_slice) |arg_idx| { try ir.store.getTypeAnno(arg_idx).pushToSExprTree(ir, tree, arg_idx); @@ -106,34 +148,22 @@ pub const TypeAnno = union(enum) { try tree.endNode(begin, attrs); }, - .apply_external => |a| { + .rigid_var => |tv| { const begin = tree.beginNode(); - try tree.pushStaticAtom("ty-apply-external"); - const region = ir.store.getTypeAnnoRegion(type_anno_idx); - try ir.appendRegionInfoToSExprTreeFromRegion(tree, region); - const attrs = tree.beginNode(); - - // Add module index - var buf: [32]u8 = undefined; - const module_idx_str = std.fmt.bufPrint(&buf, "{}", .{@intFromEnum(a.module_idx)}) catch unreachable; - try tree.pushStringPair("module-idx", module_idx_str); - - // Add target node index - var buf2: [32]u8 = undefined; - const target_idx_str = std.fmt.bufPrint(&buf2, "{}", .{a.target_node_idx}) catch unreachable; - try tree.pushStringPair("target-node-idx", target_idx_str); - - try tree.endNode(begin, attrs); - }, - .ty_var => |tv| { - const begin = tree.beginNode(); - try tree.pushStaticAtom("ty-var"); + try tree.pushStaticAtom("ty-rigid-var"); const region = ir.store.getTypeAnnoRegion(type_anno_idx); try ir.appendRegionInfoToSExprTreeFromRegion(tree, region); try tree.pushStringPair("name", ir.getIdentText(tv.name)); const attrs = tree.beginNode(); try tree.endNode(begin, attrs); }, + .rigid_var_lookup => |rv_lookup| { + const begin = tree.beginNode(); + try tree.pushStaticAtom("ty-rigid-var-lookup"); + try ir.store.getTypeAnno(rv_lookup.ref).pushToSExprTree(ir, tree, rv_lookup.ref); + const attrs = tree.beginNode(); + try tree.endNode(begin, attrs); + }, .underscore => |_| { const begin = tree.beginNode(); try tree.pushStaticAtom("ty-underscore"); @@ -142,12 +172,45 @@ pub const TypeAnno = union(enum) { const attrs = tree.beginNode(); try tree.endNode(begin, attrs); }, - .ty => |t| { + .lookup => |t| { const begin = tree.beginNode(); - try tree.pushStaticAtom("ty"); + try tree.pushStaticAtom("ty-lookup"); const region = ir.store.getTypeAnnoRegion(type_anno_idx); try ir.appendRegionInfoToSExprTreeFromRegion(tree, region); - try tree.pushStringPair("name", ir.getIdentText(t.symbol)); + try tree.pushStringPair("name", ir.getIdentText(t.name)); + + switch (t.base) { + .builtin => |_| { + const field_begin = tree.beginNode(); + try tree.pushStaticAtom("builtin"); + const field_attrs = tree.beginNode(); + try tree.endNode(field_begin, field_attrs); + }, + .local => |_| { + const field_begin = tree.beginNode(); + try tree.pushStaticAtom("local"); + const field_attrs = tree.beginNode(); + try tree.endNode(field_begin, field_attrs); + }, + .external => |external| { + const ext_begin = tree.beginNode(); + try tree.pushStaticAtom("external"); + + // Add module index + var buf: [32]u8 = undefined; + const module_idx_str = std.fmt.bufPrint(&buf, "{}", .{@intFromEnum(external.module_idx)}) catch unreachable; + try tree.pushStringPair("module-idx", module_idx_str); + + // Add target node index + var buf2: [32]u8 = undefined; + const target_idx_str = std.fmt.bufPrint(&buf2, "{}", .{external.target_node_idx}) catch unreachable; + try tree.pushStringPair("target-node-idx", target_idx_str); + + const field_attrs = tree.beginNode(); + try tree.endNode(ext_begin, field_attrs); + }, + } + const attrs = tree.beginNode(); try tree.endNode(begin, attrs); }, @@ -169,6 +232,21 @@ pub const TypeAnno = union(enum) { try tree.endNode(begin, attrs); }, + .tag => |t| { + const begin = tree.beginNode(); + try tree.pushStaticAtom("ty-tag-name"); + const region = ir.store.getTypeAnnoRegion(type_anno_idx); + + try ir.appendRegionInfoToSExprTreeFromRegion(tree, region); + try tree.pushStringPair("name", ir.getIdentText(t.name)); + + const attrs = tree.beginNode(); + const args_slice = ir.store.sliceTypeAnnos(t.args); + for (args_slice) |tag_idx| { + try ir.store.getTypeAnno(tag_idx).pushToSExprTree(ir, tree, tag_idx); + } + try tree.endNode(begin, attrs); + }, .tuple => |t| { const begin = tree.beginNode(); try tree.pushStaticAtom("ty-tuple"); @@ -234,25 +312,6 @@ pub const TypeAnno = union(enum) { try tree.endNode(begin, attrs); }, - .ty_lookup_external => |tle| { - const begin = tree.beginNode(); - try tree.pushStaticAtom("ty-lookup-external"); - const region = ir.store.getTypeAnnoRegion(type_anno_idx); - try ir.appendRegionInfoToSExprTreeFromRegion(tree, region); - const attrs = tree.beginNode(); - - // Add module index - var buf: [32]u8 = undefined; - const module_idx_str = std.fmt.bufPrint(&buf, "{}", .{@intFromEnum(tle.module_idx)}) catch unreachable; - try tree.pushStringPair("module-idx", module_idx_str); - - // Add target node index - var buf2: [32]u8 = undefined; - const target_idx_str = std.fmt.bufPrint(&buf2, "{}", .{tle.target_node_idx}) catch unreachable; - try tree.pushStringPair("target-node-idx", target_idx_str); - - try tree.endNode(begin, attrs); - }, .malformed => |_| { const begin = tree.beginNode(); try tree.pushStaticAtom("ty-malformed"); @@ -273,16 +332,25 @@ pub const TypeAnno = union(enum) { pub const Span = struct { span: DataSpan }; }; - /// A type application in a type annotation - pub const Apply = struct { - symbol: Ident.Idx, // The type constructor being applied (e.g., "List", "Dict") - args: TypeAnno.Span, // The type arguments (e.g., [Str], [String, Int]) + /// Either a locally declare type, or an external type + pub const LocalOrExternal = union(enum) { + builtin: Builtin, + local: struct { + decl_idx: Statement.Idx, + }, + external: struct { + module_idx: CIR.Import.Idx, + target_node_idx: u16, + }, + + // Just the tag of this union enum + pub const Tag = std.meta.Tag(@This()); }; - /// A type application of an external type in a type annotation - pub const ApplyExternal = struct { - module_idx: CIR.Import.Idx, - target_node_idx: u16, + /// A type application in a type annotation + pub const Apply = struct { + name: Ident.Idx, // The type name + base: LocalOrExternal, // Reference to the type args: TypeAnno.Span, // The type arguments (e.g., [Str], [String, Int]) }; @@ -308,4 +376,75 @@ pub const TypeAnno = union(enum) { pub const Tuple = struct { elems: TypeAnno.Span, // The types of each tuple element }; + + /// A builtin type + pub const Builtin = enum { + str, + list, + box, + num, + frac, + int, + u8, + u16, + u32, + u64, + u128, + i8, + i16, + i32, + i64, + i128, + f32, + f64, + dec, + + /// Convert a builtin type to it's name + pub fn toBytes(self: @This()) []const u8 { + switch (self) { + .str => return "Str", + .list => return "List", + .box => return "Box", + .num => return "Num", + .frac => return "Frac", + .int => return "Int", + .u8 => return "U8", + .u16 => return "U16", + .u32 => return "U32", + .u64 => return "U64", + .u128 => return "U128", + .i8 => return "I8", + .i16 => return "I16", + .i32 => return "I32", + .i64 => return "I64", + .i128 => return "I128", + .f32 => return "F32", + .f64 => return "F64", + .dec => return "Dec", + } + } + + /// Convert a type name string to the corresponding builtin type + pub fn fromBytes(bytes: []const u8) ?@This() { + if (std.mem.eql(u8, bytes, "Str")) return .str; + if (std.mem.eql(u8, bytes, "List")) return .list; + if (std.mem.eql(u8, bytes, "Num")) return .num; + if (std.mem.eql(u8, bytes, "Frac")) return .frac; + if (std.mem.eql(u8, bytes, "Int")) return .int; + if (std.mem.eql(u8, bytes, "U8")) return .u8; + if (std.mem.eql(u8, bytes, "U16")) return .u16; + if (std.mem.eql(u8, bytes, "U32")) return .u32; + if (std.mem.eql(u8, bytes, "U64")) return .u64; + if (std.mem.eql(u8, bytes, "U128")) return .u128; + if (std.mem.eql(u8, bytes, "I8")) return .i8; + if (std.mem.eql(u8, bytes, "I16")) return .i16; + if (std.mem.eql(u8, bytes, "I32")) return .i32; + if (std.mem.eql(u8, bytes, "I64")) return .i64; + if (std.mem.eql(u8, bytes, "I128")) return .i128; + if (std.mem.eql(u8, bytes, "F32")) return .f32; + if (std.mem.eql(u8, bytes, "F64")) return .f64; + if (std.mem.eql(u8, bytes, "Dec")) return .dec; + return null; + } + }; }; diff --git a/src/canonicalize/test/TestEnv.zig b/src/canonicalize/test/TestEnv.zig index 86c7a3c13a..d2a6d104b6 100644 --- a/src/canonicalize/test/TestEnv.zig +++ b/src/canonicalize/test/TestEnv.zig @@ -50,7 +50,7 @@ pub fn init(source: []const u8) !TestEnv { try module_env.initCIRFields(gpa, "test"); - can.* = try Can.init(module_env, parse_ast, null); + can.* = try Can.init(module_env, parse_ast, null, .{}); return TestEnv{ .gpa = gpa, diff --git a/src/canonicalize/test/exposed_shadowing_test.zig b/src/canonicalize/test/exposed_shadowing_test.zig index 35d7a70747..5981079f61 100644 --- a/src/canonicalize/test/exposed_shadowing_test.zig +++ b/src/canonicalize/test/exposed_shadowing_test.zig @@ -32,15 +32,15 @@ test "exposed but not implemented - values" { var ast = try parse.parse(&env.common, allocator); defer ast.deinit(allocator); - var czer = try Can.init(&env, &ast, null); + var czer = try Can.init(&env, &ast, null, .{}); defer czer.deinit(); try czer.canonicalizeFile(); // Check that we have an "exposed but not implemented" diagnostic for 'bar' var found_bar_error = false; - for (0..env.store.scratch_diagnostics.top()) |i| { - const diag_idx = env.store.scratch_diagnostics.items.items[i]; + for (0..env.store.scratch.?.diagnostics.top()) |i| { + const diag_idx = env.store.scratch.?.diagnostics.items.items[i]; const diag = env.store.getDiagnostic(diag_idx); switch (diag) { .exposed_but_not_implemented => |d| { @@ -71,15 +71,15 @@ test "exposed but not implemented - types" { var ast = try parse.parse(&env.common, allocator); defer ast.deinit(allocator); - var czer = try Can.init(&env, &ast, null); + var czer = try Can.init(&env, &ast, null, .{}); defer czer.deinit(); try czer.canonicalizeFile(); // Check that we have an "exposed but not implemented" diagnostic for 'OtherType' var found_other_type_error = false; - for (0..env.store.scratch_diagnostics.top()) |i| { - const diag_idx = env.store.scratch_diagnostics.items.items[i]; + for (0..env.store.scratch.?.diagnostics.top()) |i| { + const diag_idx = env.store.scratch.?.diagnostics.items.items[i]; const diag = env.store.getDiagnostic(diag_idx); switch (diag) { .exposed_but_not_implemented => |d| { @@ -108,7 +108,7 @@ test "redundant exposed entries" { try env.initCIRFields(allocator, "Test"); var ast = try parse.parse(&env.common, allocator); defer ast.deinit(allocator); - var czer = try Can.init(&env, &ast, null); + var czer = try Can.init(&env, &ast, null, .{}); defer czer .deinit(); try czer @@ -116,8 +116,8 @@ test "redundant exposed entries" { // Check that we have redundant exposed warnings var found_foo_redundant = false; var found_bar_redundant = false; - for (0..env.store.scratch_diagnostics.top()) |i| { - const diag_idx = env.store.scratch_diagnostics.items.items[i]; + for (0..env.store.scratch.?.diagnostics.top()) |i| { + const diag_idx = env.store.scratch.?.diagnostics.items.items[i]; const diag = env.store.getDiagnostic(diag_idx); switch (diag) { .redundant_exposed => |d| { @@ -151,15 +151,15 @@ test "shadowing with exposed items" { try env.initCIRFields(allocator, "Test"); var ast = try parse.parse(&env.common, allocator); defer ast.deinit(allocator); - var czer = try Can.init(&env, &ast, null); + var czer = try Can.init(&env, &ast, null, .{}); defer czer .deinit(); try czer .canonicalizeFile(); // Check that we have shadowing warnings var shadowing_count: usize = 0; - for (0..env.store.scratch_diagnostics.top()) |i| { - const diag_idx = env.store.scratch_diagnostics.items.items[i]; + for (0..env.store.scratch.?.diagnostics.top()) |i| { + const diag_idx = env.store.scratch.?.diagnostics.items.items[i]; const diag = env.store.getDiagnostic(diag_idx); switch (diag) { .shadowing_warning => shadowing_count += 1, @@ -184,15 +184,15 @@ test "shadowing non-exposed items" { try env.initCIRFields(allocator, "Test"); var ast = try parse.parse(&env.common, allocator); defer ast.deinit(allocator); - var czer = try Can.init(&env, &ast, null); + var czer = try Can.init(&env, &ast, null, .{}); defer czer .deinit(); try czer .canonicalizeFile(); // Check that we still get shadowing warnings for non-exposed items var found_shadowing = false; - for (0..env.store.scratch_diagnostics.top()) |i| { - const diag_idx = env.store.scratch_diagnostics.items.items[i]; + for (0..env.store.scratch.?.diagnostics.top()) |i| { + const diag_idx = env.store.scratch.?.diagnostics.items.items[i]; const diag = env.store.getDiagnostic(diag_idx); switch (diag) { .shadowing_warning => |d| { @@ -224,7 +224,7 @@ test "exposed items correctly tracked across shadowing" { try env.initCIRFields(allocator, "Test"); var ast = try parse.parse(&env.common, allocator); defer ast.deinit(allocator); - var czer = try Can.init(&env, &ast, null); + var czer = try Can.init(&env, &ast, null, .{}); defer czer .deinit(); try czer @@ -237,8 +237,8 @@ test "exposed items correctly tracked across shadowing" { var found_x_shadowing = false; var found_z_not_implemented = false; var found_unexpected_not_implemented = false; - for (0..env.store.scratch_diagnostics.top()) |i| { - const diag_idx = env.store.scratch_diagnostics.items.items[i]; + for (0..env.store.scratch.?.diagnostics.top()) |i| { + const diag_idx = env.store.scratch.?.diagnostics.items.items[i]; const diag = env.store.getDiagnostic(diag_idx); switch (diag) { .shadowing_warning => |d| { @@ -280,7 +280,7 @@ test "complex case with redundant, shadowing, and not implemented" { try env.initCIRFields(allocator, "Test"); var ast = try parse.parse(&env.common, allocator); defer ast.deinit(allocator); - var czer = try Can.init(&env, &ast, null); + var czer = try Can.init(&env, &ast, null, .{}); defer czer .deinit(); try czer @@ -288,8 +288,8 @@ test "complex case with redundant, shadowing, and not implemented" { var found_a_redundant = false; var found_a_shadowing = false; var found_not_implemented = false; - for (0..env.store.scratch_diagnostics.top()) |i| { - const diag_idx = env.store.scratch_diagnostics.items.items[i]; + for (0..env.store.scratch.?.diagnostics.top()) |i| { + const diag_idx = env.store.scratch.?.diagnostics.items.items[i]; const diag = env.store.getDiagnostic(diag_idx); switch (diag) { .redundant_exposed => |d| { @@ -332,7 +332,7 @@ test "exposed_items is populated correctly" { try env.initCIRFields(allocator, "Test"); var ast = try parse.parse(&env.common, allocator); defer ast.deinit(allocator); - var czer = try Can.init(&env, &ast, null); + var czer = try Can.init(&env, &ast, null, .{}); defer czer .deinit(); try czer @@ -364,7 +364,7 @@ test "exposed_items persists after canonicalization" { try env.initCIRFields(allocator, "Test"); var ast = try parse.parse(&env.common, allocator); defer ast.deinit(allocator); - var czer = try Can.init(&env, &ast, null); + var czer = try Can.init(&env, &ast, null, .{}); defer czer .deinit(); try czer @@ -394,7 +394,7 @@ test "exposed_items never has entries removed" { try env.initCIRFields(allocator, "Test"); var ast = try parse.parse(&env.common, allocator); defer ast.deinit(allocator); - var czer = try Can.init(&env, &ast, null); + var czer = try Can.init(&env, &ast, null, .{}); defer czer .deinit(); try czer @@ -427,7 +427,7 @@ test "exposed_items handles identifiers with different attributes" { try env.initCIRFields(allocator, "Test"); var ast = try parse.parse(&env.common, allocator); defer ast.deinit(allocator); - var czer = try Can.init(&env, &ast, null); + var czer = try Can.init(&env, &ast, null, .{}); defer czer .deinit(); try czer diff --git a/src/canonicalize/test/frac_test.zig b/src/canonicalize/test/frac_test.zig index bff445686d..3d2c03ca2c 100644 --- a/src/canonicalize/test/frac_test.zig +++ b/src/canonicalize/test/frac_test.zig @@ -8,7 +8,6 @@ const std = @import("std"); const base = @import("base"); const parse = @import("parse"); const compile = @import("compile"); -const types = @import("types"); const builtins = @import("builtins"); const Can = @import("../Can.zig"); @@ -28,60 +27,11 @@ test "fractional literal - basic decimal" { switch (expr) { .e_dec_small => |dec| { - try testing.expectEqual(dec.numerator, 314); - try testing.expectEqual(dec.denominator_power_of_ten, 2); - const expr_as_type_var: types.Var = @enumFromInt(@intFromEnum(canonical_expr.get_idx())); - const resolved = test_env.module_env.types.resolveVar(expr_as_type_var); - switch (resolved.desc.content) { - .structure => |structure| switch (structure) { - .num => |num| switch (num) { - .num_poly => return error.UnexpectedNumPolyType, - .frac_poly => |poly| { - try testing.expect(poly.requirements.fits_in_dec); - }, - .frac_unbound => |requirements| { - try testing.expect(requirements.fits_in_dec); - }, - else => return error.UnexpectedNumType, - }, - else => return error.UnexpectedStructureType, - }, - .flex_var => { - // It's an unbound type variable, which is also fine for literals - }, - else => { - std.debug.print("Unexpected content type: {}\n", .{resolved.desc.content}); - return error.UnexpectedContentType; - }, - } + try testing.expectEqual(dec.value.numerator, 314); + try testing.expectEqual(dec.value.denominator_power_of_ten, 2); }, - .e_frac_dec => |dec| { + .e_dec => |dec| { _ = dec; - // Also accept e_frac_dec for decimal literals - const expr_as_type_var: types.Var = @enumFromInt(@intFromEnum(canonical_expr.get_idx())); - const resolved = test_env.module_env.types.resolveVar(expr_as_type_var); - switch (resolved.desc.content) { - .structure => |structure| switch (structure) { - .num => |num| switch (num) { - .num_poly => return error.UnexpectedNumPolyType, - .frac_poly => |poly| { - try testing.expect(poly.requirements.fits_in_dec); - }, - .frac_unbound => |requirements| { - try testing.expect(requirements.fits_in_dec); - }, - else => return error.UnexpectedNumType, - }, - else => return error.UnexpectedStructureType, - }, - .flex_var => { - // It's an unbound type variable, which is also fine for literals - }, - else => { - std.debug.print("Unexpected content type: {}\n", .{resolved.desc.content}); - return error.UnexpectedContentType; - }, - } }, else => { std.debug.print("Unexpected expr type: {}\n", .{expr}); @@ -102,89 +52,13 @@ test "fractional literal - scientific notation small" { .e_dec_small => |dec| { // Very small numbers may round to zero when parsed as small decimal // This is expected behavior when the value is too small for i16 representation - try testing.expectEqual(dec.numerator, 0); - - // Still check type requirements - const expr_as_type_var: types.Var = @enumFromInt(@intFromEnum(canonical_expr.get_idx())); - const resolved = test_env.module_env.types.resolveVar(expr_as_type_var); - switch (resolved.desc.content) { - .structure => |structure| switch (structure) { - .num => |num| switch (num) { - .frac_poly => |poly| { - try testing.expect(poly.requirements.fits_in_f32); - try testing.expect(poly.requirements.fits_in_dec); - }, - .frac_unbound => |requirements| { - try testing.expect(requirements.fits_in_f32); - try testing.expect(requirements.fits_in_dec); - }, - else => return error.UnexpectedNumType, - }, - else => return error.UnexpectedStructureType, - }, - .flex_var => { - // It's an unbound type variable, which is also fine for literals - }, - else => return error.UnexpectedContentType, - } + try testing.expectEqual(dec.value.numerator, 0); }, - .e_frac_dec => |frac| { - // Scientific notation can also be parsed as RocDec for exact representation - const expr_as_type_var: types.Var = @enumFromInt(@intFromEnum(canonical_expr.get_idx())); - const resolved = test_env.module_env.types.resolveVar(expr_as_type_var); - switch (resolved.desc.content) { - .structure => |structure| switch (structure) { - .num => |num| switch (num) { - .num_poly => return error.UnexpectedNumPolyType, - .frac_poly => |poly| { - // 1.23e-10 is within f32 range, so it should fit (ignoring precision) - try testing.expect(poly.requirements.fits_in_f32); - try testing.expect(poly.requirements.fits_in_dec); - }, - .frac_unbound => |requirements| { - // 1.23e-10 is within f32 range, so it should fit (ignoring precision) - try testing.expect(requirements.fits_in_f32); - try testing.expect(requirements.fits_in_dec); - }, - else => return error.UnexpectedNumType, - }, - else => return error.UnexpectedStructureType, - }, - .flex_var => { - // It's an unbound type variable, which is also fine for literals - }, - else => return error.UnexpectedContentType, - } + .e_dec => |frac| { // RocDec stores the value in a special format _ = frac; }, .e_frac_f64 => |frac| { - // Or it might be parsed as f64 - const expr_as_type_var: types.Var = @enumFromInt(@intFromEnum(canonical_expr.get_idx())); - const resolved = test_env.module_env.types.resolveVar(expr_as_type_var); - switch (resolved.desc.content) { - .structure => |structure| switch (structure) { - .num => |num| switch (num) { - .num_poly => return error.UnexpectedNumPolyType, - .frac_poly => |poly| { - // 1.23e-10 is within f32 range, so it should fit (ignoring precision) - try testing.expect(poly.requirements.fits_in_f32); - try testing.expect(poly.requirements.fits_in_dec); - }, - .frac_unbound => |requirements| { - // 1.23e-10 is within f32 range, so it should fit (ignoring precision) - try testing.expect(requirements.fits_in_f32); - try testing.expect(requirements.fits_in_dec); - }, - else => return error.UnexpectedNumType, - }, - else => return error.UnexpectedStructureType, - }, - .flex_var => { - // It's an unbound type variable, which is also fine for literals - }, - else => return error.UnexpectedContentType, - } try testing.expectApproxEqAbs(frac.value, 1.23e-10, 1e-20); }, else => { @@ -204,27 +78,6 @@ test "fractional literal - scientific notation large (near f64 max)" { switch (expr) { .e_frac_f64 => |frac| { - const expr_as_type_var: types.Var = @enumFromInt(@intFromEnum(canonical_expr.get_idx())); - const resolved = test_env.module_env.types.resolveVar(expr_as_type_var); - switch (resolved.desc.content) { - .structure => |structure| switch (structure) { - .num => |num| switch (num) { - .num_poly => return error.UnexpectedNumPolyType, - .frac_poly => |poly| { - try testing.expect(!poly.requirements.fits_in_dec); // Way out of Dec range - }, - .frac_unbound => |requirements| { - try testing.expect(!requirements.fits_in_dec); // Way out of Dec range - }, - else => return error.UnexpectedNumType, - }, - else => return error.UnexpectedStructureType, - }, - .flex_var => { - // It's an unbound type variable, which is also fine for literals - }, - else => return error.UnexpectedContentType, - } try testing.expectEqual(frac.value, 1e308); }, else => { @@ -264,12 +117,12 @@ test "fractional literal - negative zero" { switch (expr) { .e_dec_small => |small| { // dec_small doesn't preserve sign for -0.0 - try testing.expectEqual(small.numerator, 0); - try testing.expectEqual(small.denominator_power_of_ten, 0); + try testing.expectEqual(small.value.numerator, 0); + try testing.expectEqual(small.value.denominator_power_of_ten, 0); try testing.expect(true); // -0.0 fits in Dec try testing.expect(true); // -0.0 fits in F32 }, - .e_frac_dec => |frac| { + .e_dec => |frac| { try testing.expect(true); // -0.0 fits in Dec and F32 const f64_val = frac.value.toF64(); // RocDec may not preserve the sign bit for -0.0, so just check it's zero @@ -296,8 +149,8 @@ test "fractional literal - positive zero" { switch (expr) { .e_dec_small => |small| { - try testing.expectEqual(small.numerator, 0); - try testing.expectEqual(small.denominator_power_of_ten, 1); + try testing.expectEqual(small.value.numerator, 0); + try testing.expectEqual(small.value.denominator_power_of_ten, 1); try testing.expect(true); // 0.5 fits in F32 try testing.expect(true); // 0.5 fits in Dec }, @@ -373,7 +226,7 @@ test "fractional literal - scientific notation with capital E" { const expr = test_env.getCanonicalExpr(canonical_expr.get_idx()); switch (expr) { - .e_frac_dec => |frac| { + .e_dec => |frac| { try testing.expect(true); // 1e7 fits in Dec try testing.expect(true); // 2.5e10 is within f32 range try testing.expectApproxEqAbs(@as(f64, @floatFromInt(frac.value.num)) / std.math.pow(f64, 10, 18), 2.5e10, 1e-5); @@ -393,7 +246,7 @@ test "fractional literal - negative scientific notation" { const expr = test_env.getCanonicalExpr(canonical_expr.get_idx()); switch (expr) { - .e_frac_dec => |frac| { + .e_dec => |frac| { try testing.expect(true); // 1e-7 fits in Dec // -1.5e-5 may not round-trip perfectly through f32 // Let's just check the value is correct @@ -439,8 +292,8 @@ test "negative zero forced to f64 parsing" { switch (expr) { .e_dec_small => |small| { - try testing.expectEqual(small.numerator, 0); - try testing.expectEqual(small.denominator_power_of_ten, 0); + try testing.expectEqual(small.value.numerator, 0); + try testing.expectEqual(small.value.denominator_power_of_ten, 0); }, else => { try testing.expect(false); // Should be dec_small @@ -476,8 +329,8 @@ test "small dec - basic positive decimal" { switch (expr) { .e_dec_small => |dec| { - try testing.expectEqual(dec.numerator, 314); - try testing.expectEqual(dec.denominator_power_of_ten, 2); + try testing.expectEqual(dec.value.numerator, 314); + try testing.expectEqual(dec.value.denominator_power_of_ten, 2); try testing.expect(true); // 1.1 fits in Dec }, else => { @@ -496,10 +349,10 @@ test "negative zero preservation - uses f64" { switch (expr) { .e_dec_small => |small| { - try testing.expectEqual(small.numerator, 0); + try testing.expectEqual(small.value.numerator, 0); // Sign is lost with dec_small }, - .e_frac_dec => |frac| { + .e_dec => |frac| { // If it went through Dec path, check if sign is preserved if (std.mem.eql(u8, "-0.0", "-0.0")) { const f64_val = @as(f64, @floatFromInt(frac.value.num)) / std.math.pow(f64, 10, 18); @@ -523,8 +376,8 @@ test "negative zero with scientific notation - preserves sign via f64" { switch (expr) { .e_dec_small => |small| { - try testing.expectEqual(small.numerator, 0); - try testing.expectEqual(small.denominator_power_of_ten, 0); + try testing.expectEqual(small.value.numerator, 0); + try testing.expectEqual(small.value.denominator_power_of_ten, 0); }, else => { try testing.expect(false); // Should be dec_small @@ -542,11 +395,11 @@ test "small dec - positive zero" { switch (expr) { .e_dec_small => |dec| { - try testing.expectEqual(dec.numerator, 0); - try testing.expectEqual(dec.denominator_power_of_ten, 1); + try testing.expectEqual(dec.value.numerator, 0); + try testing.expectEqual(dec.value.denominator_power_of_ten, 1); // Verify positive zero - try testing.expectEqual(dec.numerator, 0); + try testing.expectEqual(dec.value.numerator, 0); }, else => { try testing.expect(false); // Should be dec_small @@ -564,8 +417,8 @@ test "small dec - precision preservation for 0.1" { switch (expr) { .e_dec_small => |dec| { - try testing.expectEqual(dec.numerator, 1); - try testing.expectEqual(dec.denominator_power_of_ten, 1); + try testing.expectEqual(dec.value.numerator, 1); + try testing.expectEqual(dec.value.denominator_power_of_ten, 1); }, else => { try testing.expect(false); // Should be dec_small @@ -583,8 +436,8 @@ test "small dec - trailing zeros" { switch (expr) { .e_dec_small => |dec| { - try testing.expectEqual(dec.numerator, 1100); - try testing.expectEqual(dec.denominator_power_of_ten, 3); + try testing.expectEqual(dec.value.numerator, 1100); + try testing.expectEqual(dec.value.denominator_power_of_ten, 3); }, else => { try testing.expect(false); // Should be dec_small @@ -602,8 +455,8 @@ test "small dec - negative number" { switch (expr) { .e_dec_small => |dec| { - try testing.expectEqual(dec.numerator, -525); - try testing.expectEqual(dec.denominator_power_of_ten, 2); + try testing.expectEqual(dec.value.numerator, -525); + try testing.expectEqual(dec.value.denominator_power_of_ten, 2); }, else => { try testing.expect(false); // Should be dec_small @@ -621,8 +474,8 @@ test "small dec - max i8 value" { switch (expr) { .e_dec_small => |dec| { - try testing.expectEqual(dec.numerator, 12799); - try testing.expectEqual(dec.denominator_power_of_ten, 2); + try testing.expectEqual(dec.value.numerator, 12799); + try testing.expectEqual(dec.value.denominator_power_of_ten, 2); }, else => { try testing.expect(false); // Should be dec_small @@ -640,8 +493,8 @@ test "small dec - min i8 value" { switch (expr) { .e_dec_small => |dec| { - try testing.expectEqual(dec.numerator, -1280); - try testing.expectEqual(dec.denominator_power_of_ten, 1); + try testing.expectEqual(dec.value.numerator, -1280); + try testing.expectEqual(dec.value.denominator_power_of_ten, 1); }, else => { try testing.expect(false); // Should be dec_small @@ -660,8 +513,8 @@ test "small dec - 128.0 now fits with new representation" { switch (expr) { .e_dec_small => |dec| { // With numerator/power representation, 128.0 = 1280/10^1 fits in i16 - try testing.expectEqual(dec.numerator, 1280); - try testing.expectEqual(dec.denominator_power_of_ten, 1); + try testing.expectEqual(dec.value.numerator, 1280); + try testing.expectEqual(dec.value.denominator_power_of_ten, 1); }, else => { try testing.expect(false); // Should be dec_small @@ -678,7 +531,7 @@ test "small dec - exceeds i16 range falls back to Dec" { const expr = test_env.getCanonicalExpr(canonical_expr.get_idx()); switch (expr) { - .e_frac_dec => { + .e_dec => { // Should fall back to Dec because 327680 > 32767 (max i16) try testing.expect(true); // 3.141 fits in Dec }, @@ -701,8 +554,8 @@ test "small dec - too many fractional digits falls back to Dec" { switch (expr) { .e_dec_small => |dec| { - try testing.expectEqual(dec.numerator, 1234); - try testing.expectEqual(dec.denominator_power_of_ten, 3); + try testing.expectEqual(dec.value.numerator, 1234); + try testing.expectEqual(dec.value.denominator_power_of_ten, 3); }, else => { try testing.expect(false); // Should be dec_small @@ -720,8 +573,8 @@ test "small dec - complex example 0.001" { switch (expr) { .e_dec_small => |dec| { - try testing.expectEqual(dec.numerator, 1); - try testing.expectEqual(dec.denominator_power_of_ten, 3); + try testing.expectEqual(dec.value.numerator, 1); + try testing.expectEqual(dec.value.denominator_power_of_ten, 3); }, else => { try testing.expect(false); // Should be dec_small @@ -740,8 +593,8 @@ test "small dec - negative example -0.05" { switch (expr) { .e_dec_small => |dec| { // -0.05 = -5 / 10^2 - try testing.expectEqual(dec.numerator, -5); - try testing.expectEqual(dec.denominator_power_of_ten, 2); + try testing.expectEqual(dec.value.numerator, -5); + try testing.expectEqual(dec.value.denominator_power_of_ten, 2); }, else => { try testing.expect(false); // Should be dec_small @@ -760,8 +613,8 @@ test "negative zero with scientific notation preserves sign" { switch (expr) { .e_dec_small => |small| { // With scientific notation, now uses dec_small and loses sign - try testing.expectEqual(small.numerator, 0); - try testing.expectEqual(small.denominator_power_of_ten, 0); + try testing.expectEqual(small.value.numerator, 0); + try testing.expectEqual(small.value.denominator_power_of_ten, 0); }, else => { try testing.expect(false); // Should be dec_small @@ -779,8 +632,8 @@ test "fractional literal - simple 1.0 uses small dec" { switch (expr) { .e_dec_small => |dec| { - try testing.expectEqual(dec.numerator, 10); - try testing.expectEqual(dec.denominator_power_of_ten, 1); + try testing.expectEqual(dec.value.numerator, 10); + try testing.expectEqual(dec.value.denominator_power_of_ten, 1); }, else => { try testing.expect(false); // Should be dec_small diff --git a/src/canonicalize/test/import_store_test.zig b/src/canonicalize/test/import_store_test.zig index 7fe433db82..d330918da2 100644 --- a/src/canonicalize/test/import_store_test.zig +++ b/src/canonicalize/test/import_store_test.zig @@ -12,31 +12,30 @@ const CompactWriter = collections.CompactWriter; test "Import.Store deduplicates module names" { const testing = std.testing; const gpa = testing.allocator; - var arena = std.heap.ArenaAllocator.init(gpa); - defer arena.deinit(); - const arena_allocator = arena.allocator(); // Create a string store for interning module names - var string_store = try StringLiteral.Store.initCapacityBytes(arena_allocator, 1024); + var string_store = try StringLiteral.Store.initCapacityBytes(gpa, 1024); + defer string_store.deinit(gpa); // Create import store var store = Import.Store.init(); + defer store.deinit(gpa); // Add the same module name multiple times - should deduplicate - const idx1 = try store.getOrPut(arena_allocator, &string_store, "test.Module"); - const idx2 = try store.getOrPut(arena_allocator, &string_store, "test.Module"); + const idx1 = try store.getOrPut(gpa, &string_store, "test.Module"); + const idx2 = try store.getOrPut(gpa, &string_store, "test.Module"); // Should get the same index try testing.expectEqual(idx1, idx2); try testing.expectEqual(@as(usize, 1), store.imports.len()); // Add a different module - should create a new entry - const idx3 = try store.getOrPut(arena_allocator, &string_store, "other.Module"); + const idx3 = try store.getOrPut(gpa, &string_store, "other.Module"); try testing.expect(idx3 != idx1); try testing.expectEqual(@as(usize, 2), store.imports.len()); // Add the first module name again - should still return original index - const idx4 = try store.getOrPut(arena_allocator, &string_store, "test.Module"); + const idx4 = try store.getOrPut(gpa, &string_store, "test.Module"); try testing.expectEqual(idx1, idx4); try testing.expectEqual(@as(usize, 2), store.imports.len()); @@ -50,13 +49,9 @@ test "Import.Store deduplicates module names" { test "Import.Store empty CompactWriter roundtrip" { const testing = std.testing; const gpa = testing.allocator; - var arena = std.heap.ArenaAllocator.init(gpa); - defer arena.deinit(); - const arena_allocator = arena.allocator(); // Create an empty Store var original = Import.Store.init(); - // No deinit needed, arena will handle it. // Create a temp file var tmp_dir = testing.tmpDir(.{}); @@ -66,13 +61,13 @@ test "Import.Store empty CompactWriter roundtrip" { defer file.close(); var writer = CompactWriter.init(); - defer writer.deinit(arena_allocator); + defer writer.deinit(gpa); - const serialized = try writer.appendAlloc(arena_allocator, Import.Store.Serialized); - try serialized.serialize(&original, arena_allocator, &writer); + const serialized = try writer.appendAlloc(gpa, Import.Store.Serialized); + try serialized.serialize(&original, gpa, &writer); // Write to file - try writer.writeGather(arena_allocator, file); + try writer.writeGather(gpa, file); // Read back try file.seekTo(0); @@ -81,7 +76,7 @@ test "Import.Store empty CompactWriter roundtrip" { // Cast to Serialized and deserialize const serialized_ptr = @as(*Import.Store.Serialized, @ptrCast(@alignCast(buffer.ptr))); - const deserialized = serialized_ptr.deserialize(@as(i64, @intCast(@intFromPtr(buffer.ptr))), arena_allocator); + const deserialized = serialized_ptr.deserialize(@as(i64, @intCast(@intFromPtr(buffer.ptr))), gpa); // Verify empty try testing.expectEqual(@as(usize, 0), deserialized.imports.len()); @@ -91,22 +86,21 @@ test "Import.Store empty CompactWriter roundtrip" { test "Import.Store basic CompactWriter roundtrip" { const testing = std.testing; const gpa = testing.allocator; - var arena = std.heap.ArenaAllocator.init(gpa); - defer arena.deinit(); - const arena_allocator = arena.allocator(); // Create a mock module env with string store - var string_store = try StringLiteral.Store.initCapacityBytes(arena_allocator, 1024); + var string_store = try StringLiteral.Store.initCapacityBytes(gpa, 1024); + defer string_store.deinit(gpa); const MockEnv = struct { strings: *StringLiteral.Store }; const mock_env = MockEnv{ .strings = &string_store }; // Create original store and add some imports var original = Import.Store.init(); + defer original.deinit(gpa); - const idx1 = try original.getOrPut(arena_allocator, mock_env.strings, "json.Json"); - const idx2 = try original.getOrPut(arena_allocator, mock_env.strings, "core.List"); - const idx3 = try original.getOrPut(arena_allocator, mock_env.strings, "my.Module"); + const idx1 = try original.getOrPut(gpa, mock_env.strings, "json.Json"); + const idx2 = try original.getOrPut(gpa, mock_env.strings, "core.List"); + const idx3 = try original.getOrPut(gpa, mock_env.strings, "my.Module"); // Verify indices try testing.expectEqual(@as(u32, 0), @intFromEnum(idx1)); @@ -121,13 +115,13 @@ test "Import.Store basic CompactWriter roundtrip" { defer file.close(); var writer = CompactWriter.init(); - defer writer.deinit(arena_allocator); + defer writer.deinit(gpa); - const serialized = try writer.appendAlloc(arena_allocator, Import.Store.Serialized); - try serialized.serialize(&original, arena_allocator, &writer); + const serialized = try writer.appendAlloc(gpa, Import.Store.Serialized); + try serialized.serialize(&original, gpa, &writer); // Write to file - try writer.writeGather(arena_allocator, file); + try writer.writeGather(gpa, file); // Read back try file.seekTo(0); @@ -136,7 +130,8 @@ test "Import.Store basic CompactWriter roundtrip" { // Cast to Serialized and deserialize const serialized_ptr: *Import.Store.Serialized = @ptrCast(@alignCast(buffer.ptr)); - const deserialized = serialized_ptr.deserialize(@as(i64, @intCast(@intFromPtr(buffer.ptr))), arena_allocator); + var deserialized = serialized_ptr.deserialize(@as(i64, @intCast(@intFromPtr(buffer.ptr))), gpa); + defer deserialized.map.deinit(gpa); // Verify the imports are accessible try testing.expectEqual(@as(usize, 3), deserialized.imports.len()); @@ -157,22 +152,21 @@ test "Import.Store basic CompactWriter roundtrip" { test "Import.Store duplicate imports CompactWriter roundtrip" { const testing = std.testing; const gpa = testing.allocator; - var arena = std.heap.ArenaAllocator.init(gpa); - defer arena.deinit(); - const arena_allocator = arena.allocator(); // Create a mock module env with string store - var string_store = try StringLiteral.Store.initCapacityBytes(arena_allocator, 1024); + var string_store = try StringLiteral.Store.initCapacityBytes(gpa, 1024); + defer string_store.deinit(gpa); const MockEnv = struct { strings: *StringLiteral.Store }; const mock_env = MockEnv{ .strings = &string_store }; // Create store with duplicate imports var original = Import.Store.init(); + defer original.deinit(gpa); - const idx1 = try original.getOrPut(arena_allocator, mock_env.strings, "test.Module"); - const idx2 = try original.getOrPut(arena_allocator, mock_env.strings, "another.Module"); - const idx3 = try original.getOrPut(arena_allocator, mock_env.strings, "test.Module"); // duplicate + const idx1 = try original.getOrPut(gpa, mock_env.strings, "test.Module"); + const idx2 = try original.getOrPut(gpa, mock_env.strings, "another.Module"); + const idx3 = try original.getOrPut(gpa, mock_env.strings, "test.Module"); // duplicate // Verify deduplication worked try testing.expectEqual(idx1, idx3); @@ -186,13 +180,13 @@ test "Import.Store duplicate imports CompactWriter roundtrip" { defer file.close(); var writer = CompactWriter.init(); - defer writer.deinit(arena_allocator); + defer writer.deinit(gpa); - const serialized = try writer.appendAlloc(arena_allocator, Import.Store.Serialized); - try serialized.serialize(&original, arena_allocator, &writer); + const serialized = try writer.appendAlloc(gpa, Import.Store.Serialized); + try serialized.serialize(&original, gpa, &writer); // Write to file - try writer.writeGather(arena_allocator, file); + try writer.writeGather(gpa, file); // Read back try file.seekTo(0); @@ -201,7 +195,8 @@ test "Import.Store duplicate imports CompactWriter roundtrip" { // Cast to Serialized and deserialize const serialized_ptr: *Import.Store.Serialized = @ptrCast(@alignCast(buffer.ptr)); - const deserialized = serialized_ptr.deserialize(@as(i64, @intCast(@intFromPtr(buffer.ptr))), arena_allocator); + var deserialized = serialized_ptr.deserialize(@as(i64, @intCast(@intFromPtr(buffer.ptr))), gpa); + defer deserialized.map.deinit(gpa); // Verify correct number of imports try testing.expectEqual(@as(usize, 2), deserialized.imports.len()); diff --git a/src/canonicalize/test/import_validation_test.zig b/src/canonicalize/test/import_validation_test.zig index 521c41396d..028faff23e 100644 --- a/src/canonicalize/test/import_validation_test.zig +++ b/src/canonicalize/test/import_validation_test.zig @@ -18,12 +18,18 @@ const testing = std.testing; const expectEqual = testing.expectEqual; // Helper function to parse and canonicalize source code -fn parseAndCanonicalizeSource(allocator: std.mem.Allocator, source: []const u8, module_envs: ?*std.StringHashMap(*ModuleEnv)) !struct { +fn parseAndCanonicalizeSource( + allocator: std.mem.Allocator, + source: []const u8, + module_envs: ?*std.StringHashMap(*const ModuleEnv), +) !struct { parse_env: *ModuleEnv, ast: *parse.AST, can: *Can, } { const parse_env = try allocator.create(ModuleEnv); + // Note: We pass allocator for both gpa and arena since the ModuleEnv + // will be cleaned up by the caller parse_env.* = try ModuleEnv.init(allocator, source); const ast = try allocator.create(parse.AST); @@ -33,7 +39,7 @@ fn parseAndCanonicalizeSource(allocator: std.mem.Allocator, source: []const u8, try parse_env.initCIRFields(allocator, "Test"); const can = try allocator.create(Can); - can.* = try Can.init(parse_env, ast, module_envs); + can.* = try Can.init(parse_env, ast, module_envs, .{}); return .{ .parse_env = parse_env, @@ -46,8 +52,9 @@ test "import validation - mix of MODULE NOT FOUND, TYPE NOT EXPOSED, VALUE NOT E var gpa_state = std.heap.GeneralPurposeAllocator(.{ .safety = true }){}; defer std.debug.assert(gpa_state.deinit() == .ok); const allocator = gpa_state.allocator(); + // First, create some module environments with exposed items - var module_envs = std.StringHashMap(*ModuleEnv).init(allocator); + var module_envs = std.StringHashMap(*const ModuleEnv).init(allocator); defer module_envs.deinit(); // Create module environment for "Json" module const json_env = try allocator.create(ModuleEnv); @@ -112,7 +119,7 @@ test "import validation - mix of MODULE NOT FOUND, TYPE NOT EXPOSED, VALUE NOT E // Initialize CIR fields try parse_env.initCIRFields(allocator, "Test"); // Canonicalize with module validation - var can = try Can.init(parse_env, &ast, &module_envs); + var can = try Can.init(parse_env, &ast, &module_envs, .{}); defer can.deinit(); _ = try can.canonicalizeFile(); // Collect all diagnostics @@ -165,6 +172,7 @@ test "import validation - no module_envs provided" { var gpa_state = std.heap.GeneralPurposeAllocator(.{ .safety = true }){}; defer std.debug.assert(gpa_state.deinit() == .ok); const allocator = gpa_state.allocator(); + // Parse source code with import statements const source = \\module [main] @@ -186,7 +194,7 @@ test "import validation - no module_envs provided" { try parse_env.initCIRFields(allocator, "Test"); // Create czer // with null module_envs - var can = try Can.init(parse_env, &ast, null); + var can = try Can.init(parse_env, &ast, null, .{}); defer can.deinit(); _ = try can.canonicalizeFile(); const diagnostics = try parse_env.getDiagnostics(); @@ -196,6 +204,9 @@ test "import validation - no module_envs provided" { .module_not_found => { // expected this error message, ignore }, + .module_header_deprecated => { + // expected deprecation warning, ignore + }, else => { // these errors are not expected try testing.expect(false); @@ -457,8 +468,9 @@ test "exposed_items - tracking CIR node indices for exposed items" { var gpa_state = std.heap.GeneralPurposeAllocator(.{ .safety = true }){}; defer std.debug.assert(gpa_state.deinit() == .ok); const allocator = gpa_state.allocator(); + // Create module environments with exposed items - var module_envs = std.StringHashMap(*ModuleEnv).init(allocator); + var module_envs = std.StringHashMap(*const ModuleEnv).init(allocator); defer module_envs.deinit(); // Create a "MathUtils" module with some exposed definitions const math_env = try allocator.create(ModuleEnv); @@ -580,6 +592,7 @@ test "export count safety - ensures safe u16 casting" { var gpa_state = std.heap.GeneralPurposeAllocator(.{ .safety = true }){}; defer std.debug.assert(gpa_state.deinit() == .ok); const allocator = gpa_state.allocator(); + // This test verifies that we check export counts to ensure safe casting to u16 // The check triggers when exposed_items.len >= maxInt(u16) (65535) // This leaves 0 available as a potential sentinel value if needed diff --git a/src/canonicalize/test/int_test.zig b/src/canonicalize/test/int_test.zig index e8c4080b19..f79dc10e40 100644 --- a/src/canonicalize/test/int_test.zig +++ b/src/canonicalize/test/int_test.zig @@ -21,19 +21,13 @@ const Content = types.Content; fn getIntValue(module_env: *ModuleEnv, expr_idx: CIR.Expr.Idx) !i128 { const expr = module_env.store.getExpr(expr_idx); switch (expr) { - .e_int => |int_expr| { + .e_num => |int_expr| { return @bitCast(int_expr.value.bytes); }, else => return error.NotAnInteger, } } -fn calculateRequirements(value: i128) types.Num.Int.Requirements { - const bits_needed = types.Num.Int.BitsNeeded.fromValue(@bitCast(value)); - - return .{ .sign_needed = value < 0, .bits_needed = bits_needed }; -} - test "canonicalize simple positive integer" { const source = "42"; var test_env = try TestEnv.init(source); @@ -153,19 +147,17 @@ test "canonicalize integer with specific requirements" { const test_cases = [_]struct { source: []const u8, expected_value: i128, - expected_sign_needed: bool, - expected_bits_needed: types.Num.Int.BitsNeeded, }{ - .{ .source = "127", .expected_value = 127, .expected_sign_needed = false, .expected_bits_needed = .@"7" }, - .{ .source = "128", .expected_value = 128, .expected_sign_needed = false, .expected_bits_needed = .@"8" }, - .{ .source = "255", .expected_value = 255, .expected_sign_needed = false, .expected_bits_needed = .@"8" }, - .{ .source = "256", .expected_value = 256, .expected_sign_needed = false, .expected_bits_needed = .@"9_to_15" }, - .{ .source = "-128", .expected_value = -128, .expected_sign_needed = true, .expected_bits_needed = .@"7" }, - .{ .source = "-129", .expected_value = -129, .expected_sign_needed = true, .expected_bits_needed = .@"8" }, - .{ .source = "32767", .expected_value = 32767, .expected_sign_needed = false, .expected_bits_needed = .@"9_to_15" }, - .{ .source = "32768", .expected_value = 32768, .expected_sign_needed = false, .expected_bits_needed = .@"16" }, - .{ .source = "65535", .expected_value = 65535, .expected_sign_needed = false, .expected_bits_needed = .@"16" }, - .{ .source = "65536", .expected_value = 65536, .expected_sign_needed = false, .expected_bits_needed = .@"17_to_31" }, + .{ .source = "127", .expected_value = 127 }, + .{ .source = "128", .expected_value = 128 }, + .{ .source = "255", .expected_value = 255 }, + .{ .source = "256", .expected_value = 256 }, + .{ .source = "-128", .expected_value = -128 }, + .{ .source = "-129", .expected_value = -129 }, + .{ .source = "32767", .expected_value = 32767 }, + .{ .source = "32768", .expected_value = 32768 }, + .{ .source = "65535", .expected_value = 65535 }, + .{ .source = "65536", .expected_value = 65536 }, }; for (test_cases) |tc| { @@ -178,21 +170,6 @@ test "canonicalize integer with specific requirements" { } } -test "canonicalize integer literal creates correct type variables" { - const source = "42"; - var test_env = try TestEnv.init(source); - defer test_env.deinit(); - - const canonical_expr = try test_env.canonicalizeExpr() orelse unreachable; - const expr = test_env.getCanonicalExpr(canonical_expr.get_idx()); - switch (expr) { - .e_int => { - // Verify requirements were set - }, - else => return error.UnexpectedExprType, - } -} - test "canonicalize invalid integer literal" { // Test individual cases since some might fail during parsing vs canonicalization @@ -315,19 +292,17 @@ test "canonicalize integer requirements determination" { const test_cases = [_]struct { source: []const u8, expected_value: i128, - expected_sign_needed: bool, - expected_bits_needed: types.Num.Int.BitsNeeded, }{ // 255 needs 8 bits and no sign - .{ .source = "255", .expected_value = 255, .expected_sign_needed = false, .expected_bits_needed = .@"8" }, + .{ .source = "255", .expected_value = 255 }, // 256 needs 9-15 bits and no sign - .{ .source = "256", .expected_value = 256, .expected_sign_needed = false, .expected_bits_needed = .@"9_to_15" }, + .{ .source = "256", .expected_value = 256 }, // -1 needs sign and 7 bits - .{ .source = "-1", .expected_value = -1, .expected_sign_needed = true, .expected_bits_needed = .@"7" }, + .{ .source = "-1", .expected_value = -1 }, // 65535 needs 16 bits and no sign - .{ .source = "65535", .expected_value = 65535, .expected_sign_needed = false, .expected_bits_needed = .@"16" }, + .{ .source = "65535", .expected_value = 65535 }, // 65536 needs 17-31 bits and no sign - .{ .source = "65536", .expected_value = 65536, .expected_sign_needed = false, .expected_bits_needed = .@"17_to_31" }, + .{ .source = "65536", .expected_value = 65536 }, }; for (test_cases) |tc| { @@ -430,7 +405,7 @@ test "integer literal - negative zero" { const canonical_expr = try test_env.canonicalizeExpr() orelse unreachable; const expr = test_env.getCanonicalExpr(canonical_expr.get_idx()); switch (expr) { - .e_int => |int| { + .e_num => |int| { // -0 should be treated as 0 try testing.expectEqual(@as(i128, @bitCast(int.value.bytes)), 0); // But it should still be marked as needing a sign @@ -449,7 +424,7 @@ test "integer literal - positive zero" { const canonical_expr = try test_env.canonicalizeExpr() orelse unreachable; const expr = test_env.getCanonicalExpr(canonical_expr.get_idx()); switch (expr) { - .e_int => |int| { + .e_num => |int| { try testing.expectEqual(@as(i128, @bitCast(int.value.bytes)), 0); // Positive zero should not need a sign }, @@ -463,35 +438,33 @@ test "hexadecimal integer literals" { const test_cases = [_]struct { literal: []const u8, expected_value: i128, - expected_sign_needed: bool, - expected_bits_needed: u8, }{ // Basic hex literals - .{ .literal = "0x0", .expected_value = 0, .expected_sign_needed = false, .expected_bits_needed = 0 }, - .{ .literal = "0x1", .expected_value = 1, .expected_sign_needed = false, .expected_bits_needed = 0 }, - .{ .literal = "0xFF", .expected_value = 255, .expected_sign_needed = false, .expected_bits_needed = 1 }, - .{ .literal = "0x100", .expected_value = 256, .expected_sign_needed = false, .expected_bits_needed = 2 }, - .{ .literal = "0xFFFF", .expected_value = 65535, .expected_sign_needed = false, .expected_bits_needed = 3 }, - .{ .literal = "0x10000", .expected_value = 65536, .expected_sign_needed = false, .expected_bits_needed = 4 }, - .{ .literal = "0xFFFFFFFF", .expected_value = 4294967295, .expected_sign_needed = false, .expected_bits_needed = 5 }, - .{ .literal = "0x100000000", .expected_value = 4294967296, .expected_sign_needed = false, .expected_bits_needed = 6 }, - .{ .literal = "0xFFFFFFFFFFFFFFFF", .expected_value = @as(i128, @bitCast(@as(u128, 18446744073709551615))), .expected_sign_needed = false, .expected_bits_needed = 7 }, + .{ .literal = "0x0", .expected_value = 0 }, + .{ .literal = "0x1", .expected_value = 1 }, + .{ .literal = "0xFF", .expected_value = 255 }, + .{ .literal = "0x100", .expected_value = 256 }, + .{ .literal = "0xFFFF", .expected_value = 65535 }, + .{ .literal = "0x10000", .expected_value = 65536 }, + .{ .literal = "0xFFFFFFFF", .expected_value = 4294967295 }, + .{ .literal = "0x100000000", .expected_value = 4294967296 }, + .{ .literal = "0xFFFFFFFFFFFFFFFF", .expected_value = @as(i128, @bitCast(@as(u128, 18446744073709551615))) }, // Hex with underscores - .{ .literal = "0x1_000", .expected_value = 4096, .expected_sign_needed = false, .expected_bits_needed = 2 }, - .{ .literal = "0xFF_FF", .expected_value = 65535, .expected_sign_needed = false, .expected_bits_needed = 3 }, - .{ .literal = "0x1234_5678_9ABC_DEF0", .expected_value = @as(i128, @bitCast(@as(u128, 0x123456789ABCDEF0))), .expected_sign_needed = false, .expected_bits_needed = 6 }, + .{ .literal = "0x1_000", .expected_value = 4096 }, + .{ .literal = "0xFF_FF", .expected_value = 65535 }, + .{ .literal = "0x1234_5678_9ABC_DEF0", .expected_value = @as(i128, @bitCast(@as(u128, 0x123456789ABCDEF0))) }, // Negative hex literals - .{ .literal = "-0x1", .expected_value = -1, .expected_sign_needed = true, .expected_bits_needed = 0 }, - .{ .literal = "-0x80", .expected_value = -128, .expected_sign_needed = true, .expected_bits_needed = 0 }, - .{ .literal = "-0x81", .expected_value = -129, .expected_sign_needed = true, .expected_bits_needed = 1 }, - .{ .literal = "-0x8000", .expected_value = -32768, .expected_sign_needed = true, .expected_bits_needed = 2 }, - .{ .literal = "-0x8001", .expected_value = -32769, .expected_sign_needed = true, .expected_bits_needed = 3 }, - .{ .literal = "-0x80000000", .expected_value = -2147483648, .expected_sign_needed = true, .expected_bits_needed = 4 }, - .{ .literal = "-0x80000001", .expected_value = -2147483649, .expected_sign_needed = true, .expected_bits_needed = 5 }, - .{ .literal = "-0x8000000000000000", .expected_value = -9223372036854775808, .expected_sign_needed = true, .expected_bits_needed = 6 }, - .{ .literal = "-0x8000000000000001", .expected_value = @as(i128, -9223372036854775809), .expected_sign_needed = true, .expected_bits_needed = 7 }, + .{ .literal = "-0x1", .expected_value = -1 }, + .{ .literal = "-0x80", .expected_value = -128 }, + .{ .literal = "-0x81", .expected_value = -129 }, + .{ .literal = "-0x8000", .expected_value = -32768 }, + .{ .literal = "-0x8001", .expected_value = -32769 }, + .{ .literal = "-0x80000000", .expected_value = -2147483648 }, + .{ .literal = "-0x80000001", .expected_value = -2147483649 }, + .{ .literal = "-0x8000000000000000", .expected_value = -9223372036854775808 }, + .{ .literal = "-0x8000000000000001", .expected_value = @as(i128, -9223372036854775809) }, }; var gpa_state = std.heap.GeneralPurposeAllocator(.{ .safety = true }){}; @@ -507,7 +480,7 @@ test "hexadecimal integer literals" { var ast = try parse.parseExpr(&env.common, env.gpa); defer ast.deinit(gpa); - var czer = try Can.init(&env, &ast, null); + var czer = try Can.init(&env, &ast, null, .{}); defer czer.deinit(); const expr_idx: parse.AST.Expr.Idx = @enumFromInt(ast.root_node_idx); @@ -518,38 +491,10 @@ test "hexadecimal integer literals" { }; const expr = env.store.getExpr(canonical_expr_idx.get_idx()); - try std.testing.expect(expr == .e_int); + try std.testing.expect(expr == .e_num); // Check the value - try std.testing.expectEqual(tc.expected_value, @as(i128, @bitCast(expr.e_int.value.bytes))); - - const expr_as_type_var: types.Var = @enumFromInt(@intFromEnum(canonical_expr_idx.get_idx())); - const resolved = env.types.resolveVar(expr_as_type_var); - switch (resolved.desc.content) { - .structure => |structure| switch (structure) { - .num => |num| switch (num) { - .num_poly => |poly| { - try std.testing.expectEqual(tc.expected_sign_needed, poly.requirements.sign_needed); - try std.testing.expectEqual(tc.expected_bits_needed, poly.requirements.bits_needed); - }, - .int_poly => |poly| { - try std.testing.expectEqual(tc.expected_sign_needed, poly.requirements.sign_needed); - try std.testing.expectEqual(tc.expected_bits_needed, poly.requirements.bits_needed); - }, - .num_unbound => |requirements| { - try std.testing.expectEqual(tc.expected_sign_needed, requirements.sign_needed); - try std.testing.expectEqual(tc.expected_bits_needed, requirements.bits_needed); - }, - .int_unbound => |requirements| { - try std.testing.expectEqual(tc.expected_sign_needed, requirements.sign_needed); - try std.testing.expectEqual(tc.expected_bits_needed, requirements.bits_needed); - }, - else => return error.UnexpectedNumType, - }, - else => return error.UnexpectedStructureType, - }, - else => return error.UnexpectedContentType, - } + try std.testing.expectEqual(tc.expected_value, @as(i128, @bitCast(expr.e_num.value.bytes))); } } @@ -557,30 +502,28 @@ test "binary integer literals" { const test_cases = [_]struct { literal: []const u8, expected_value: i128, - expected_sign_needed: bool, - expected_bits_needed: u8, }{ // Basic binary literals - .{ .literal = "0b0", .expected_value = 0, .expected_sign_needed = false, .expected_bits_needed = 0 }, - .{ .literal = "0b1", .expected_value = 1, .expected_sign_needed = false, .expected_bits_needed = 0 }, - .{ .literal = "0b10", .expected_value = 2, .expected_sign_needed = false, .expected_bits_needed = 0 }, - .{ .literal = "0b11111111", .expected_value = 255, .expected_sign_needed = false, .expected_bits_needed = 1 }, - .{ .literal = "0b100000000", .expected_value = 256, .expected_sign_needed = false, .expected_bits_needed = 2 }, - .{ .literal = "0b1111111111111111", .expected_value = 65535, .expected_sign_needed = false, .expected_bits_needed = 3 }, - .{ .literal = "0b10000000000000000", .expected_value = 65536, .expected_sign_needed = false, .expected_bits_needed = 4 }, + .{ .literal = "0b0", .expected_value = 0 }, + .{ .literal = "0b1", .expected_value = 1 }, + .{ .literal = "0b10", .expected_value = 2 }, + .{ .literal = "0b11111111", .expected_value = 255 }, + .{ .literal = "0b100000000", .expected_value = 256 }, + .{ .literal = "0b1111111111111111", .expected_value = 65535 }, + .{ .literal = "0b10000000000000000", .expected_value = 65536 }, // Binary with underscores - .{ .literal = "0b11_11", .expected_value = 15, .expected_sign_needed = false, .expected_bits_needed = 0 }, - .{ .literal = "0b1111_1111", .expected_value = 255, .expected_sign_needed = false, .expected_bits_needed = 1 }, - .{ .literal = "0b1_0000_0000", .expected_value = 256, .expected_sign_needed = false, .expected_bits_needed = 2 }, - .{ .literal = "0b1010_1010_1010_1010", .expected_value = 43690, .expected_sign_needed = false, .expected_bits_needed = 3 }, + .{ .literal = "0b11_11", .expected_value = 15 }, + .{ .literal = "0b1111_1111", .expected_value = 255 }, + .{ .literal = "0b1_0000_0000", .expected_value = 256 }, + .{ .literal = "0b1010_1010_1010_1010", .expected_value = 43690 }, // Negative binary - .{ .literal = "-0b1", .expected_value = -1, .expected_sign_needed = true, .expected_bits_needed = 0 }, - .{ .literal = "-0b10000000", .expected_value = -128, .expected_sign_needed = true, .expected_bits_needed = 0 }, - .{ .literal = "-0b10000001", .expected_value = -129, .expected_sign_needed = true, .expected_bits_needed = 1 }, - .{ .literal = "-0b1000000000000000", .expected_value = -32768, .expected_sign_needed = true, .expected_bits_needed = 2 }, - .{ .literal = "-0b1000000000000001", .expected_value = -32769, .expected_sign_needed = true, .expected_bits_needed = 3 }, + .{ .literal = "-0b1", .expected_value = -1 }, + .{ .literal = "-0b10000000", .expected_value = -128 }, + .{ .literal = "-0b10000001", .expected_value = -129 }, + .{ .literal = "-0b1000000000000000", .expected_value = -32768 }, + .{ .literal = "-0b1000000000000001", .expected_value = -32769 }, }; var gpa_state = std.heap.GeneralPurposeAllocator(.{ .safety = true }){}; @@ -596,7 +539,7 @@ test "binary integer literals" { var ast = try parse.parseExpr(&env.common, env.gpa); defer ast.deinit(gpa); - var czer = try Can.init(&env, &ast, null); + var czer = try Can.init(&env, &ast, null, .{}); defer czer.deinit(); const expr_idx: parse.AST.Expr.Idx = @enumFromInt(ast.root_node_idx); @@ -607,38 +550,10 @@ test "binary integer literals" { }; const expr = env.store.getExpr(canonical_expr_idx.get_idx()); - try std.testing.expect(expr == .e_int); + try std.testing.expect(expr == .e_num); // Check the value - try std.testing.expectEqual(tc.expected_value, @as(i128, @bitCast(expr.e_int.value.bytes))); - - const expr_as_type_var: types.Var = @enumFromInt(@intFromEnum(canonical_expr_idx.get_idx())); - const resolved = env.types.resolveVar(expr_as_type_var); - switch (resolved.desc.content) { - .structure => |structure| switch (structure) { - .num => |num| switch (num) { - .num_poly => |poly| { - try std.testing.expectEqual(tc.expected_sign_needed, poly.requirements.sign_needed); - try std.testing.expectEqual(tc.expected_bits_needed, poly.requirements.bits_needed); - }, - .int_poly => |poly| { - try std.testing.expectEqual(tc.expected_sign_needed, poly.requirements.sign_needed); - try std.testing.expectEqual(tc.expected_bits_needed, poly.requirements.bits_needed); - }, - .num_unbound => |requirements| { - try std.testing.expectEqual(tc.expected_sign_needed, requirements.sign_needed); - try std.testing.expectEqual(tc.expected_bits_needed, requirements.bits_needed); - }, - .int_unbound => |requirements| { - try std.testing.expectEqual(tc.expected_sign_needed, requirements.sign_needed); - try std.testing.expectEqual(tc.expected_bits_needed, requirements.bits_needed); - }, - else => return error.UnexpectedNumType, - }, - else => return error.UnexpectedStructureType, - }, - else => return error.UnexpectedContentType, - } + try std.testing.expectEqual(tc.expected_value, @as(i128, @bitCast(expr.e_num.value.bytes))); } } @@ -646,30 +561,28 @@ test "octal integer literals" { const test_cases = [_]struct { literal: []const u8, expected_value: i128, - expected_sign_needed: bool, - expected_bits_needed: u8, }{ // Basic octal literals - .{ .literal = "0o0", .expected_value = 0, .expected_sign_needed = false, .expected_bits_needed = 0 }, - .{ .literal = "0o1", .expected_value = 1, .expected_sign_needed = false, .expected_bits_needed = 0 }, - .{ .literal = "0o7", .expected_value = 7, .expected_sign_needed = false, .expected_bits_needed = 0 }, - .{ .literal = "0o10", .expected_value = 8, .expected_sign_needed = false, .expected_bits_needed = 0 }, - .{ .literal = "0o377", .expected_value = 255, .expected_sign_needed = false, .expected_bits_needed = 1 }, - .{ .literal = "0o400", .expected_value = 256, .expected_sign_needed = false, .expected_bits_needed = 2 }, - .{ .literal = "0o177777", .expected_value = 65535, .expected_sign_needed = false, .expected_bits_needed = 3 }, - .{ .literal = "0o200000", .expected_value = 65536, .expected_sign_needed = false, .expected_bits_needed = 4 }, + .{ .literal = "0o0", .expected_value = 0 }, + .{ .literal = "0o1", .expected_value = 1 }, + .{ .literal = "0o7", .expected_value = 7 }, + .{ .literal = "0o10", .expected_value = 8 }, + .{ .literal = "0o377", .expected_value = 255 }, + .{ .literal = "0o400", .expected_value = 256 }, + .{ .literal = "0o177777", .expected_value = 65535 }, + .{ .literal = "0o200000", .expected_value = 65536 }, // Octal with underscores - .{ .literal = "0o377_377", .expected_value = 130815, .expected_sign_needed = false, .expected_bits_needed = 4 }, - .{ .literal = "0o1_234_567", .expected_value = 342391, .expected_sign_needed = false, .expected_bits_needed = 4 }, + .{ .literal = "0o377_377", .expected_value = 130815 }, + .{ .literal = "0o1_234_567", .expected_value = 342391 }, // Negative octal literals - .{ .literal = "-0o1", .expected_value = -1, .expected_sign_needed = true, .expected_bits_needed = 0 }, - .{ .literal = "-0o100", .expected_value = -64, .expected_sign_needed = true, .expected_bits_needed = 0 }, - .{ .literal = "-0o200", .expected_value = -128, .expected_sign_needed = true, .expected_bits_needed = 0 }, - .{ .literal = "-0o201", .expected_value = -129, .expected_sign_needed = true, .expected_bits_needed = 1 }, - .{ .literal = "-0o100000", .expected_value = -32768, .expected_sign_needed = true, .expected_bits_needed = 2 }, - .{ .literal = "-0o100001", .expected_value = -32769, .expected_sign_needed = true, .expected_bits_needed = 3 }, + .{ .literal = "-0o1", .expected_value = -1 }, + .{ .literal = "-0o100", .expected_value = -64 }, + .{ .literal = "-0o200", .expected_value = -128 }, + .{ .literal = "-0o201", .expected_value = -129 }, + .{ .literal = "-0o100000", .expected_value = -32768 }, + .{ .literal = "-0o100001", .expected_value = -32769 }, }; var gpa_state = std.heap.GeneralPurposeAllocator(.{ .safety = true }){}; @@ -685,7 +598,7 @@ test "octal integer literals" { var ast = try parse.parseExpr(&env.common, env.gpa); defer ast.deinit(gpa); - var czer = try Can.init(&env, &ast, null); + var czer = try Can.init(&env, &ast, null, .{}); defer czer.deinit(); const expr_idx: parse.AST.Expr.Idx = @enumFromInt(ast.root_node_idx); @@ -696,38 +609,10 @@ test "octal integer literals" { }; const expr = env.store.getExpr(canonical_expr_idx.get_idx()); - try std.testing.expect(expr == .e_int); + try std.testing.expect(expr == .e_num); // Check the value - try std.testing.expectEqual(tc.expected_value, @as(i128, @bitCast(expr.e_int.value.bytes))); - - const expr_as_type_var: types.Var = @enumFromInt(@intFromEnum(canonical_expr_idx.get_idx())); - const resolved = env.types.resolveVar(expr_as_type_var); - switch (resolved.desc.content) { - .structure => |structure| switch (structure) { - .num => |num| switch (num) { - .num_poly => |poly| { - try std.testing.expectEqual(tc.expected_sign_needed, poly.requirements.sign_needed); - try std.testing.expectEqual(tc.expected_bits_needed, poly.requirements.bits_needed); - }, - .int_poly => |poly| { - try std.testing.expectEqual(tc.expected_sign_needed, poly.requirements.sign_needed); - try std.testing.expectEqual(tc.expected_bits_needed, poly.requirements.bits_needed); - }, - .num_unbound => |requirements| { - try std.testing.expectEqual(tc.expected_sign_needed, requirements.sign_needed); - try std.testing.expectEqual(tc.expected_bits_needed, requirements.bits_needed); - }, - .int_unbound => |requirements| { - try std.testing.expectEqual(tc.expected_sign_needed, requirements.sign_needed); - try std.testing.expectEqual(tc.expected_bits_needed, requirements.bits_needed); - }, - else => return error.UnexpectedNumType, - }, - else => return error.UnexpectedStructureType, - }, - else => return error.UnexpectedContentType, - } + try std.testing.expectEqual(tc.expected_value, @as(i128, @bitCast(expr.e_num.value.bytes))); } } @@ -735,30 +620,28 @@ test "integer literals with uppercase base prefixes" { const test_cases = [_]struct { literal: []const u8, expected_value: i128, - expected_sign_needed: bool, - expected_bits_needed: u8, }{ // Uppercase hex prefix - .{ .literal = "0X0", .expected_value = 0, .expected_sign_needed = false, .expected_bits_needed = 0 }, - .{ .literal = "0X1", .expected_value = 1, .expected_sign_needed = false, .expected_bits_needed = 0 }, - .{ .literal = "0XFF", .expected_value = 255, .expected_sign_needed = false, .expected_bits_needed = 1 }, - .{ .literal = "0XABCD", .expected_value = 43981, .expected_sign_needed = false, .expected_bits_needed = 3 }, + .{ .literal = "0X0", .expected_value = 0 }, + .{ .literal = "0X1", .expected_value = 1 }, + .{ .literal = "0XFF", .expected_value = 255 }, + .{ .literal = "0XABCD", .expected_value = 43981 }, // Uppercase binary prefix - .{ .literal = "0B0", .expected_value = 0, .expected_sign_needed = false, .expected_bits_needed = 0 }, - .{ .literal = "0B1", .expected_value = 1, .expected_sign_needed = false, .expected_bits_needed = 0 }, - .{ .literal = "0B1111", .expected_value = 15, .expected_sign_needed = false, .expected_bits_needed = 0 }, - .{ .literal = "0B11111111", .expected_value = 255, .expected_sign_needed = false, .expected_bits_needed = 1 }, + .{ .literal = "0B0", .expected_value = 0 }, + .{ .literal = "0B1", .expected_value = 1 }, + .{ .literal = "0B1111", .expected_value = 15 }, + .{ .literal = "0B11111111", .expected_value = 255 }, // Uppercase octal prefix - .{ .literal = "0O0", .expected_value = 0, .expected_sign_needed = false, .expected_bits_needed = 0 }, - .{ .literal = "0O7", .expected_value = 7, .expected_sign_needed = false, .expected_bits_needed = 0 }, - .{ .literal = "0O377", .expected_value = 255, .expected_sign_needed = false, .expected_bits_needed = 1 }, - .{ .literal = "0O777", .expected_value = 511, .expected_sign_needed = false, .expected_bits_needed = 2 }, + .{ .literal = "0O0", .expected_value = 0 }, + .{ .literal = "0O7", .expected_value = 7 }, + .{ .literal = "0O377", .expected_value = 255 }, + .{ .literal = "0O777", .expected_value = 511 }, // Mixed case in value (should still work) - .{ .literal = "0xAbCd", .expected_value = 43981, .expected_sign_needed = false, .expected_bits_needed = 3 }, - .{ .literal = "0XaBcD", .expected_value = 43981, .expected_sign_needed = false, .expected_bits_needed = 3 }, + .{ .literal = "0xAbCd", .expected_value = 43981 }, + .{ .literal = "0XaBcD", .expected_value = 43981 }, }; var gpa_state = std.heap.GeneralPurposeAllocator(.{ .safety = true }){}; @@ -774,7 +657,7 @@ test "integer literals with uppercase base prefixes" { var ast = try parse.parseExpr(&env.common, gpa); defer ast.deinit(gpa); - var czer = try Can.init(&env, &ast, null); + var czer = try Can.init(&env, &ast, null, .{}); defer czer.deinit(); const expr_idx: parse.AST.Expr.Idx = @enumFromInt(ast.root_node_idx); @@ -785,38 +668,10 @@ test "integer literals with uppercase base prefixes" { }; const expr = env.store.getExpr(canonical_expr_idx.get_idx()); - try std.testing.expect(expr == .e_int); + try std.testing.expect(expr == .e_num); // Check the value - try std.testing.expectEqual(tc.expected_value, @as(i128, @bitCast(expr.e_int.value.bytes))); - - const expr_as_type_var: types.Var = @enumFromInt(@intFromEnum(canonical_expr_idx.get_idx())); - const resolved = env.types.resolveVar(expr_as_type_var); - switch (resolved.desc.content) { - .structure => |structure| switch (structure) { - .num => |num| switch (num) { - .num_poly => |poly| { - try std.testing.expectEqual(tc.expected_sign_needed, poly.requirements.sign_needed); - try std.testing.expectEqual(tc.expected_bits_needed, poly.requirements.bits_needed); - }, - .int_poly => |poly| { - try std.testing.expectEqual(tc.expected_sign_needed, poly.requirements.sign_needed); - try std.testing.expectEqual(tc.expected_bits_needed, poly.requirements.bits_needed); - }, - .num_unbound => |requirements| { - try std.testing.expectEqual(tc.expected_sign_needed, requirements.sign_needed); - try std.testing.expectEqual(tc.expected_bits_needed, requirements.bits_needed); - }, - .int_unbound => |requirements| { - try std.testing.expectEqual(tc.expected_sign_needed, requirements.sign_needed); - try std.testing.expectEqual(tc.expected_bits_needed, requirements.bits_needed); - }, - else => return error.UnexpectedNumType, - }, - else => return error.UnexpectedStructureType, - }, - else => return error.UnexpectedContentType, - } + try std.testing.expectEqual(tc.expected_value, @as(i128, @bitCast(expr.e_num.value.bytes))); } } @@ -834,39 +689,18 @@ test "numeric literal patterns use pattern idx as type var" { // Create an int literal pattern directly const int_pattern = CIR.Pattern{ - .int_literal = .{ + .num_literal = .{ .value = .{ .bytes = @bitCast(@as(i128, 42)), .kind = .i128 }, + .kind = .num_unbound, }, }; - const pattern_idx = try env.addPatternAndTypeVar(int_pattern, Content{ - .structure = .{ .num = .{ .num_unbound = .{ - .sign_needed = false, - .bits_needed = 0, - } } }, - }, base.Region.zero()); + const pattern_idx = try env.addPatternAndTypeVar(int_pattern, .err, base.Region.zero()); // Verify the stored pattern const stored_pattern = env.store.getPattern(pattern_idx); - try std.testing.expect(stored_pattern == .int_literal); - try std.testing.expectEqual(@as(i128, 42), @as(i128, @bitCast(stored_pattern.int_literal.value.bytes))); - - // Verify the pattern index can be used as a type variable - const pattern_as_type_var: types.Var = @enumFromInt(@intFromEnum(pattern_idx)); - const resolved = env.types.resolveVar(pattern_as_type_var); - switch (resolved.desc.content) { - .structure => |structure| switch (structure) { - .num => |num| switch (num) { - .num_unbound => |requirements| { - try std.testing.expectEqual(false, requirements.sign_needed); - try std.testing.expectEqual(@as(u8, 0), requirements.bits_needed); - }, - else => return error.UnexpectedNumType, - }, - else => return error.UnexpectedStructureType, - }, - else => return error.UnexpectedContentType, - } + try std.testing.expect(stored_pattern == .num_literal); + try std.testing.expectEqual(@as(i128, 42), @as(i128, @bitCast(stored_pattern.num_literal.value.bytes))); } // Test that f64 literal patterns work @@ -880,302 +714,17 @@ test "numeric literal patterns use pattern idx as type var" { const dec_pattern = CIR.Pattern{ .dec_literal = .{ .value = RocDec.fromF64(3.14) orelse unreachable, + .has_suffix = false, }, }; - const pattern_idx = try env.addPatternAndTypeVar(dec_pattern, Content{ - .structure = .{ .num = .{ .frac_unbound = .{ - .fits_in_f32 = true, - .fits_in_dec = true, - } } }, - }, base.Region.zero()); + const pattern_idx = try env.addPatternAndTypeVar(dec_pattern, .err, base.Region.zero()); // Verify the stored pattern const stored_pattern = env.store.getPattern(pattern_idx); try std.testing.expect(stored_pattern == .dec_literal); const expected_dec = RocDec.fromF64(3.14) orelse unreachable; try std.testing.expectEqual(expected_dec.num, stored_pattern.dec_literal.value.num); - - // Verify the pattern index can be used as a type variable - const pattern_as_type_var: types.Var = @enumFromInt(@intFromEnum(pattern_idx)); - const resolved = env.types.resolveVar(pattern_as_type_var); - switch (resolved.desc.content) { - .structure => |structure| switch (structure) { - .num => |num| switch (num) { - .frac_unbound => |requirements| { - try std.testing.expectEqual(true, requirements.fits_in_f32); - try std.testing.expectEqual(true, requirements.fits_in_dec); - }, - else => return error.UnexpectedNumType, - }, - else => return error.UnexpectedStructureType, - }, - else => return error.UnexpectedContentType, - } - } -} - -test "numeric pattern types: unbound vs polymorphic" { - var gpa_state = std.heap.GeneralPurposeAllocator(.{ .safety = true }){}; - defer std.debug.assert(gpa_state.deinit() == .ok); - const gpa = gpa_state.allocator(); - - // Test int_unbound pattern - { - var env = try ModuleEnv.init(gpa, ""); - defer env.deinit(); - - try env.initCIRFields(gpa, "test"); - - const pattern = CIR.Pattern{ - .int_literal = .{ - .value = .{ .bytes = @bitCast(@as(i128, -17)), .kind = .i128 }, - }, - }; - - const pattern_idx = try env.addPatternAndTypeVar(pattern, Content{ - .structure = .{ .num = .{ .int_unbound = .{ - .sign_needed = true, - .bits_needed = 0, - } } }, - }, base.Region.zero()); - - const pattern_var: types.Var = @enumFromInt(@intFromEnum(pattern_idx)); - const resolved = env.types.resolveVar(pattern_var); - switch (resolved.desc.content) { - .structure => |s| switch (s) { - .num => |n| switch (n) { - .int_unbound => |req| { - try std.testing.expectEqual(true, req.sign_needed); - try std.testing.expectEqual(@as(u8, 0), req.bits_needed); - }, - else => return error.ExpectedIntUnbound, - }, - else => {}, - }, - else => {}, - } - } - - // Test int_poly pattern (polymorphic integer that can be different int types) - { - var env = try ModuleEnv.init(gpa, ""); - defer env.deinit(); - - try env.initCIRFields(gpa, "test"); - - const pattern = CIR.Pattern{ - .int_literal = .{ - .value = .{ .bytes = @bitCast(@as(i128, 255)), .kind = .i128 }, - }, - }; - - // Create a fresh type variable for polymorphic int - const poly_var = try env.types.fresh(); - - const pattern_idx = try env.store.addPattern(pattern, base.Region.zero()); - _ = try env.types.freshFromContent(Content{ - .structure = .{ - .num = .{ - .int_poly = .{ - .var_ = poly_var, - .requirements = .{ - .sign_needed = false, - .bits_needed = 1, // Needs at least 8 bits for 255 - }, - }, - }, - }, - }); - - const pattern_var: types.Var = @enumFromInt(@intFromEnum(pattern_idx)); - const resolved = env.types.resolveVar(pattern_var); - switch (resolved.desc.content) { - .structure => |s| switch (s) { - .num => |n| switch (n) { - .int_poly => |poly| { - try std.testing.expectEqual(false, poly.requirements.sign_needed); - try std.testing.expectEqual(@as(u8, 1), poly.requirements.bits_needed); - try std.testing.expectEqual(poly_var, poly.var_); - }, - else => return error.ExpectedIntPoly, - }, - else => {}, - }, - else => {}, - } - } - - // Test num_unbound pattern (can be int or frac) - { - var env = try ModuleEnv.init(gpa, ""); - defer env.deinit(); - - try env.initCIRFields(gpa, "test"); - - const pattern = CIR.Pattern{ - .int_literal = .{ - .value = .{ .bytes = @bitCast(@as(i128, 10)), .kind = .i128 }, - }, - }; - - const pattern_idx = try env.addPatternAndTypeVar(pattern, Content{ - .structure = .{ .num = .{ .num_unbound = .{ - .sign_needed = false, - .bits_needed = 0, - } } }, - }, base.Region.zero()); - - const pattern_var: types.Var = @enumFromInt(@intFromEnum(pattern_idx)); - const resolved = env.types.resolveVar(pattern_var); - switch (resolved.desc.content) { - .structure => |s| switch (s) { - .num => |n| switch (n) { - .num_unbound => |req| { - try std.testing.expectEqual(false, req.sign_needed); - try std.testing.expectEqual(@as(u8, 0), req.bits_needed); - }, - else => return error.ExpectedNumUnbound, - }, - else => {}, - }, - else => {}, - } - } - - // Test num_poly pattern (polymorphic num that can be int or frac) - { - var env = try ModuleEnv.init(gpa, ""); - defer env.deinit(); - - try env.initCIRFields(gpa, "test"); - - const pattern = CIR.Pattern{ - .int_literal = .{ - .value = .{ .bytes = @bitCast(@as(i128, 5)), .kind = .i128 }, - }, - }; - - // Create a fresh type variable for polymorphic num - const poly_var = try env.types.fresh(); - - const pattern_idx = try env.store.addPattern(pattern, base.Region.zero()); - _ = try env.types.freshFromContent(Content{ - .structure = .{ .num = .{ .num_poly = .{ - .var_ = poly_var, - .requirements = .{ - .sign_needed = false, - .bits_needed = 0, - }, - } } }, - }); - - const pattern_var: types.Var = @enumFromInt(@intFromEnum(pattern_idx)); - const resolved = env.types.resolveVar(pattern_var); - switch (resolved.desc.content) { - .structure => |s| switch (s) { - .num => |n| switch (n) { - .num_poly => |poly| { - try std.testing.expectEqual(false, poly.requirements.sign_needed); - try std.testing.expectEqual(@as(u8, 0), poly.requirements.bits_needed); - try std.testing.expectEqual(poly_var, poly.var_); - }, - else => return error.ExpectedNumPoly, - }, - else => {}, - }, - else => {}, - } - } - - // Test frac_unbound pattern - { - var env = try ModuleEnv.init(gpa, ""); - defer env.deinit(); - - try env.initCIRFields(gpa, "test"); - - const pattern = CIR.Pattern{ - .dec_literal = .{ - .value = RocDec.fromF64(2.5) orelse unreachable, - }, - }; - - const pattern_idx = try env.addPatternAndTypeVar(pattern, Content{ - .structure = .{ .num = .{ .frac_unbound = .{ - .fits_in_f32 = true, - .fits_in_dec = true, - } } }, - }, base.Region.zero()); - - const pattern_var: types.Var = @enumFromInt(@intFromEnum(pattern_idx)); - const resolved = env.types.resolveVar(pattern_var); - switch (resolved.desc.content) { - .structure => |s| switch (s) { - .num => |n| switch (n) { - .frac_unbound => |req| { - try std.testing.expectEqual(true, req.fits_in_f32); - try std.testing.expectEqual(true, req.fits_in_dec); - }, - else => return error.ExpectedFracUnbound, - }, - else => {}, - }, - else => {}, - } - } -} - -test "numeric pattern types: unbound vs polymorphic - frac" { - const gpa = std.testing.allocator; - - // Test frac_poly pattern - { - var env = try ModuleEnv.init(gpa, ""); - defer env.deinit(); - - try env.initCIRFields(gpa, "test"); - - const pattern = CIR.Pattern{ - .dec_literal = .{ - .value = RocDec.fromF64(1000000.0) orelse unreachable, - }, - }; - - // Create a fresh type variable for polymorphic frac - const poly_var = try env.types.fresh(); - - const pattern_idx = try env.store.addPattern(pattern, base.Region.zero()); - _ = try env.types.freshFromContent(Content{ - .structure = .{ - .num = .{ - .frac_poly = .{ - .var_ = poly_var, - .requirements = .{ - .fits_in_f32 = true, - .fits_in_dec = false, // Infinity doesn't fit in Dec - }, - }, - }, - }, - }); - - const pattern_var: types.Var = @enumFromInt(@intFromEnum(pattern_idx)); - const resolved = env.types.resolveVar(pattern_var); - switch (resolved.desc.content) { - .structure => |s| switch (s) { - .num => |n| switch (n) { - .frac_poly => |poly| { - try std.testing.expectEqual(true, poly.requirements.fits_in_f32); - try std.testing.expectEqual(false, poly.requirements.fits_in_dec); - try std.testing.expectEqual(poly_var, poly.var_); - }, - else => return error.ExpectedFracPoly, - }, - else => {}, - }, - else => {}, - } } } @@ -1193,23 +742,25 @@ test "pattern numeric literal value edge cases" { // Test i128 max const max_pattern = CIR.Pattern{ - .int_literal = .{ + .num_literal = .{ .value = .{ .bytes = @bitCast(@as(i128, std.math.maxInt(i128))), .kind = .i128 }, + .kind = .num_unbound, }, }; const max_idx = try env.store.addPattern(max_pattern, base.Region.zero()); const stored_max = env.store.getPattern(max_idx); - try std.testing.expectEqual(std.math.maxInt(i128), @as(i128, @bitCast(stored_max.int_literal.value.bytes))); + try std.testing.expectEqual(std.math.maxInt(i128), @as(i128, @bitCast(stored_max.num_literal.value.bytes))); // Test i128 min const min_pattern = CIR.Pattern{ - .int_literal = .{ + .num_literal = .{ .value = .{ .bytes = @bitCast(@as(i128, std.math.minInt(i128))), .kind = .i128 }, + .kind = .num_unbound, }, }; const min_idx = try env.store.addPattern(min_pattern, base.Region.zero()); const stored_min = env.store.getPattern(min_idx); - try std.testing.expectEqual(std.math.minInt(i128), @as(i128, @bitCast(stored_min.int_literal.value.bytes))); + try std.testing.expectEqual(std.math.minInt(i128), @as(i128, @bitCast(stored_min.num_literal.value.bytes))); } // Test small decimal pattern @@ -1221,9 +772,11 @@ test "pattern numeric literal value edge cases" { const small_dec_pattern = CIR.Pattern{ .small_dec_literal = .{ - .numerator = 1234, - .denominator_power_of_ten = 2, // 12.34 - + .value = .{ + .numerator = 1234, + .denominator_power_of_ten = 2, // 12.34 + }, + .has_suffix = false, }, }; @@ -1231,8 +784,8 @@ test "pattern numeric literal value edge cases" { const stored = env.store.getPattern(pattern_idx); try std.testing.expect(stored == .small_dec_literal); - try std.testing.expectEqual(@as(i16, 1234), stored.small_dec_literal.numerator); - try std.testing.expectEqual(@as(u8, 2), stored.small_dec_literal.denominator_power_of_ten); + try std.testing.expectEqual(@as(i16, 1234), stored.small_dec_literal.value.numerator); + try std.testing.expectEqual(@as(u8, 2), stored.small_dec_literal.value.denominator_power_of_ten); } // Test dec literal pattern @@ -1245,7 +798,7 @@ test "pattern numeric literal value edge cases" { const dec_pattern = CIR.Pattern{ .dec_literal = .{ .value = RocDec{ .num = 314159265358979323 }, // π * 10^17 - + .has_suffix = false, }, }; @@ -1267,6 +820,7 @@ test "pattern numeric literal value edge cases" { const neg_zero_pattern = CIR.Pattern{ .dec_literal = .{ .value = RocDec.fromF64(-0.0) orelse unreachable, + .has_suffix = false, }, }; const neg_zero_idx = try env.store.addPattern(neg_zero_pattern, base.Region.zero()); @@ -1276,213 +830,6 @@ test "pattern numeric literal value edge cases" { } } -test "pattern literal type transitions" { - var gpa_state = std.heap.GeneralPurposeAllocator(.{ .safety = true }){}; - defer std.debug.assert(gpa_state.deinit() == .ok); - const gpa = gpa_state.allocator(); - - // Test transitioning from unbound to concrete type - { - var env = try ModuleEnv.init(gpa, ""); - defer env.deinit(); - - try env.initCIRFields(gpa, "test"); - - const pattern = CIR.Pattern{ - .int_literal = .{ - .value = .{ .bytes = @bitCast(@as(i128, 100)), .kind = .i128 }, - }, - }; - - const pattern_idx = try env.addPatternAndTypeVar(pattern, Content{ - .structure = .{ .num = .{ .num_unbound = .{ - .sign_needed = false, - .bits_needed = 1, - } } }, - }, base.Region.zero()); - - // Simulate type inference determining it's a U8 - const pattern_var: types.Var = @enumFromInt(@intFromEnum(pattern_idx)); - _ = try env.types.setVarContent(pattern_var, Content{ - .structure = .{ .num = types.Num.int_u8 }, - }); - - // Verify it resolved to U8 - const resolved = env.types.resolveVar(pattern_var); - switch (resolved.desc.content) { - .structure => |s| switch (s) { - .num => |n| switch (n) { - .num_compact => |compact| switch (compact) { - .int => |int| { - try std.testing.expect(int == .u8); - }, - else => return error.ExpectedInt, - }, - else => return error.ExpectedNumCompact, - }, - else => {}, - }, - else => {}, - } - } - - // Test hex/binary/octal patterns must be integers - { - var env = try ModuleEnv.init(gpa, ""); - defer env.deinit(); - - try env.initCIRFields(gpa, "test"); - - // Hex pattern (0xFF) - const hex_pattern = CIR.Pattern{ - .int_literal = .{ - .value = .{ .bytes = @bitCast(@as(i128, 0xFF)), .kind = .i128 }, - }, - }; - - const hex_idx = try env.addPatternAndTypeVar(hex_pattern, Content{ - .structure = .{ .num = .{ .int_unbound = .{ - .sign_needed = false, - .bits_needed = 1, - } } }, - }, base.Region.zero()); - - const hex_var: types.Var = @enumFromInt(@intFromEnum(hex_idx)); - const resolved = env.types.resolveVar(hex_var); - switch (resolved.desc.content) { - .structure => |s| switch (s) { - .num => |n| switch (n) { - .int_unbound => |req| { - // Verify it's constrained to integers only - try std.testing.expectEqual(false, req.sign_needed); - try std.testing.expectEqual(@as(u8, 1), req.bits_needed); - }, - else => return error.ExpectedIntUnbound, - }, - else => {}, - }, - else => {}, - } - } -} - -test "pattern type inference with numeric literals" { - var gpa_state = std.heap.GeneralPurposeAllocator(.{ .safety = true }){}; - defer std.debug.assert(gpa_state.deinit() == .ok); - const gpa = gpa_state.allocator(); - - // Test that pattern indices work correctly as type variables with type inference - { - var env = try ModuleEnv.init(gpa, ""); - defer env.deinit(); - - try env.initCIRFields(gpa, "test"); - - // Create patterns representing different numeric literals - const patterns = [_]struct { - pattern: CIR.Pattern, - expected_type: types.Content, - }{ - // Small positive int - could be any unsigned type - .{ - .pattern = CIR.Pattern{ - .int_literal = .{ - .value = .{ .bytes = @bitCast(@as(i128, 42)), .kind = .i128 }, - }, - }, - .expected_type = Content{ .structure = .{ .num = .{ .num_unbound = .{ - .sign_needed = false, - .bits_needed = 0, - } } } }, - }, - // Negative int - needs signed type - .{ - .pattern = CIR.Pattern{ - .int_literal = .{ - .value = .{ .bytes = @bitCast(@as(i128, -42)), .kind = .i128 }, - }, - }, - .expected_type = Content{ .structure = .{ .num = .{ .num_unbound = .{ - .sign_needed = true, - .bits_needed = 0, - } } } }, - }, - // Large int requiring more bits - .{ - .pattern = CIR.Pattern{ - .int_literal = .{ - .value = .{ .bytes = @bitCast(@as(i128, 65536)), .kind = .i128 }, - }, - }, - .expected_type = Content{ - .structure = .{ - .num = .{ - .num_unbound = .{ - .sign_needed = false, - .bits_needed = 4, // Needs at least 17 bits - }, - }, - }, - }, - }, - }; - - for (patterns) |test_case| { - const pattern_idx = try env.addPatternAndTypeVar(test_case.pattern, test_case.expected_type, base.Region.zero()); - - // Verify the pattern index works as a type variable - const pattern_var: types.Var = @enumFromInt(@intFromEnum(pattern_idx)); - const resolved = env.types.resolveVar(pattern_var); - - // Compare the resolved type with expected - try std.testing.expectEqual(test_case.expected_type, resolved.desc.content); - } - } - - // Test patterns with type constraints from context - { - var env = try ModuleEnv.init(gpa, ""); - defer env.deinit(); - - try env.initCIRFields(gpa, "test"); - - // Create a pattern that will be constrained by context - const pattern = CIR.Pattern{ - .int_literal = .{ - .value = .{ .bytes = @bitCast(@as(i128, 100)), .kind = .i128 }, - }, - }; - - const pattern_idx = try env.addPatternAndTypeVar(pattern, Content{ - .structure = .{ .num = .{ .num_unbound = .{ - .sign_needed = false, - .bits_needed = 1, - } } }, - }, base.Region.zero()); - - // Simulate type inference constraining it to U8 - const pattern_var: types.Var = @enumFromInt(@intFromEnum(pattern_idx)); - _ = try env.types.setVarContent(pattern_var, Content{ - .structure = .{ .num = types.Num.int_u8 }, - }); - - // Verify it was constrained correctly - const resolved = env.types.resolveVar(pattern_var); - switch (resolved.desc.content) { - .structure => |s| switch (s) { - .num => |n| switch (n) { - .num_compact => |compact| { - try std.testing.expect(compact.int == .u8); - }, - else => return error.ExpectedConcreteType, - }, - else => {}, - }, - else => {}, - } - } -} - test "parseIntWithUnderscores function" { // Test the parseIntWithUnderscores helper function directly const test_cases = [_]struct { @@ -1670,3 +1017,330 @@ test "hex literal parsing logic integration" { try std.testing.expectEqual(tc.expected_value, u128_val); } } + +// number req tests // +// TODO: Review, claude generated + +test "IntValue.toIntRequirements - boundary values for each type" { + // u8 boundary: 255/256 + { + var val = CIR.IntValue{ .bytes = [_]u8{0} ** 16, .kind = .u128 }; + const test_val: u128 = 255; + @memcpy(val.bytes[0..16], std.mem.asBytes(&test_val)); + const req = val.toIntRequirements(); + try testing.expect(!req.sign_needed); + try testing.expectEqual(req.bits_needed, types.Num.Int.BitsNeeded.@"8".toBits()); + } + { + var val = CIR.IntValue{ .bytes = [_]u8{0} ** 16, .kind = .u128 }; + const test_val: u128 = 256; + @memcpy(val.bytes[0..16], std.mem.asBytes(&test_val)); + const req = val.toIntRequirements(); + try testing.expect(!req.sign_needed); + try testing.expectEqual(req.bits_needed, types.Num.Int.BitsNeeded.@"9_to_15".toBits()); + } + + // i8 positive boundary: 127/128 + { + var val = CIR.IntValue{ .bytes = [_]u8{0} ** 16, .kind = .i128 }; + const test_val: i128 = 127; + @memcpy(val.bytes[0..16], std.mem.asBytes(&test_val)); + const req = val.toIntRequirements(); + try testing.expect(!req.sign_needed); // Positive doesn't need sign + try testing.expectEqual(req.bits_needed, types.Num.Int.BitsNeeded.@"7".toBits()); + } + { + var val = CIR.IntValue{ .bytes = [_]u8{0} ** 16, .kind = .i128 }; + const test_val: i128 = 128; + @memcpy(val.bytes[0..16], std.mem.asBytes(&test_val)); + const req = val.toIntRequirements(); + try testing.expect(!req.sign_needed); // Positive doesn't need sign + try testing.expectEqual(req.bits_needed, types.Num.Int.BitsNeeded.@"8".toBits()); + } + + // i8 negative boundary: -127/-128/-129 + { + var val = CIR.IntValue{ .bytes = [_]u8{0} ** 16, .kind = .i128 }; + const test_val: i128 = -127; + @memcpy(val.bytes[0..16], std.mem.asBytes(&test_val)); + const req = val.toIntRequirements(); + try testing.expect(req.sign_needed); + try testing.expectEqual(req.bits_needed, types.Num.Int.BitsNeeded.@"7".toBits()); + } + { + var val = CIR.IntValue{ .bytes = [_]u8{0} ** 16, .kind = .i128 }; + const test_val: i128 = -128; // Special case! + @memcpy(val.bytes[0..16], std.mem.asBytes(&test_val)); + const req = val.toIntRequirements(); + try testing.expect(req.sign_needed); + try testing.expectEqual(req.bits_needed, types.Num.Int.BitsNeeded.@"7".toBits()); // Due to special case + } + { + var val = CIR.IntValue{ .bytes = [_]u8{0} ** 16, .kind = .i128 }; + const test_val: i128 = -129; + @memcpy(val.bytes[0..16], std.mem.asBytes(&test_val)); + const req = val.toIntRequirements(); + try testing.expect(req.sign_needed); + try testing.expectEqual(req.bits_needed, types.Num.Int.BitsNeeded.@"8".toBits()); + } + + // u16 boundary: 65535/65536 + { + var val = CIR.IntValue{ .bytes = [_]u8{0} ** 16, .kind = .u128 }; + const test_val: u128 = 65535; + @memcpy(val.bytes[0..16], std.mem.asBytes(&test_val)); + const req = val.toIntRequirements(); + try testing.expect(!req.sign_needed); + try testing.expectEqual(req.bits_needed, types.Num.Int.BitsNeeded.@"16".toBits()); + } + { + var val = CIR.IntValue{ .bytes = [_]u8{0} ** 16, .kind = .u128 }; + const test_val: u128 = 65536; + @memcpy(val.bytes[0..16], std.mem.asBytes(&test_val)); + const req = val.toIntRequirements(); + try testing.expect(!req.sign_needed); + try testing.expectEqual(req.bits_needed, types.Num.Int.BitsNeeded.@"17_to_31".toBits()); + } + + // i16 boundaries: 32767/-32768/-32769 + { + var val = CIR.IntValue{ .bytes = [_]u8{0} ** 16, .kind = .i128 }; + const test_val: i128 = 32767; + @memcpy(val.bytes[0..16], std.mem.asBytes(&test_val)); + const req = val.toIntRequirements(); + try testing.expect(!req.sign_needed); + try testing.expectEqual(req.bits_needed, types.Num.Int.BitsNeeded.@"9_to_15".toBits()); + } + { + var val = CIR.IntValue{ .bytes = [_]u8{0} ** 16, .kind = .i128 }; + const test_val: i128 = -32768; // Special case! + @memcpy(val.bytes[0..16], std.mem.asBytes(&test_val)); + const req = val.toIntRequirements(); + try testing.expect(req.sign_needed); + try testing.expectEqual(req.bits_needed, types.Num.Int.BitsNeeded.@"9_to_15".toBits()); // Due to special case + } + { + var val = CIR.IntValue{ .bytes = [_]u8{0} ** 16, .kind = .i128 }; + const test_val: i128 = -32769; + @memcpy(val.bytes[0..16], std.mem.asBytes(&test_val)); + const req = val.toIntRequirements(); + try testing.expect(req.sign_needed); + try testing.expectEqual(req.bits_needed, types.Num.Int.BitsNeeded.@"16".toBits()); + } +} + +test "IntValue.toIntRequirements - zero and small values" { + // Zero (special case: doesn't need sign even if stored as signed) + { + var val = CIR.IntValue{ .bytes = [_]u8{0} ** 16, .kind = .i128 }; + const req = val.toIntRequirements(); + try testing.expect(!req.sign_needed); // Zero doesn't need sign + try testing.expectEqual(req.bits_needed, types.Num.Int.BitsNeeded.@"7".toBits()); + } + + // 1 and -1 + { + var val = CIR.IntValue{ .bytes = [_]u8{0} ** 16, .kind = .i128 }; + const test_val: i128 = 1; + @memcpy(val.bytes[0..16], std.mem.asBytes(&test_val)); + const req = val.toIntRequirements(); + try testing.expect(!req.sign_needed); + try testing.expectEqual(req.bits_needed, types.Num.Int.BitsNeeded.@"7".toBits()); + } + { + var val = CIR.IntValue{ .bytes = [_]u8{0} ** 16, .kind = .i128 }; + const test_val: i128 = -1; + @memcpy(val.bytes[0..16], std.mem.asBytes(&test_val)); + const req = val.toIntRequirements(); + try testing.expect(req.sign_needed); + try testing.expectEqual(req.bits_needed, types.Num.Int.BitsNeeded.@"7".toBits()); + } +} + +test "IntValue.toIntRequirements - powers of 2 edge cases" { + // Powers of 2 that are NOT minimum signed values + { + var val = CIR.IntValue{ .bytes = [_]u8{0} ** 16, .kind = .i128 }; + const test_val: i128 = -256; // Power of 2, but not a minimum signed value + @memcpy(val.bytes[0..16], std.mem.asBytes(&test_val)); + const req = val.toIntRequirements(); + try testing.expect(req.sign_needed); + try testing.expectEqual(req.bits_needed, types.Num.Int.BitsNeeded.@"9_to_15".toBits()); // Should NOT be special cased + } + { + var val = CIR.IntValue{ .bytes = [_]u8{0} ** 16, .kind = .i128 }; + const test_val: i128 = -512; // Power of 2, but not a minimum signed value + @memcpy(val.bytes[0..16], std.mem.asBytes(&test_val)); + const req = val.toIntRequirements(); + try testing.expect(req.sign_needed); + try testing.expectEqual(req.bits_needed, types.Num.Int.BitsNeeded.@"9_to_15".toBits()); // Should NOT be special cased + } +} + +test "IntValue.toIntRequirements - i32 boundaries" { + { + var val = CIR.IntValue{ .bytes = [_]u8{0} ** 16, .kind = .i128 }; + const test_val: i128 = 2147483647; // i32 max + @memcpy(val.bytes[0..16], std.mem.asBytes(&test_val)); + const req = val.toIntRequirements(); + try testing.expect(!req.sign_needed); + try testing.expectEqual(req.bits_needed, types.Num.Int.BitsNeeded.@"17_to_31".toBits()); + } + { + var val = CIR.IntValue{ .bytes = [_]u8{0} ** 16, .kind = .i128 }; + const test_val: i128 = -2147483648; // i32 min (special case!) + @memcpy(val.bytes[0..16], std.mem.asBytes(&test_val)); + const req = val.toIntRequirements(); + try testing.expect(req.sign_needed); + try testing.expectEqual(req.bits_needed, types.Num.Int.BitsNeeded.@"17_to_31".toBits()); // Due to special case + } + { + var val = CIR.IntValue{ .bytes = [_]u8{0} ** 16, .kind = .i128 }; + const test_val: i128 = -2147483649; + @memcpy(val.bytes[0..16], std.mem.asBytes(&test_val)); + const req = val.toIntRequirements(); + try testing.expect(req.sign_needed); + try testing.expectEqual(req.bits_needed, types.Num.Int.BitsNeeded.@"32".toBits()); + } +} + +test "IntValue.toIntRequirements - i64 boundaries" { + { + var val = CIR.IntValue{ .bytes = [_]u8{0} ** 16, .kind = .i128 }; + const test_val: i128 = std.math.maxInt(i64); // 9223372036854775807 + @memcpy(val.bytes[0..16], std.mem.asBytes(&test_val)); + const req = val.toIntRequirements(); + try testing.expect(!req.sign_needed); + try testing.expectEqual(req.bits_needed, types.Num.Int.BitsNeeded.@"33_to_63".toBits()); + } + { + var val = CIR.IntValue{ .bytes = [_]u8{0} ** 16, .kind = .i128 }; + const test_val: i128 = std.math.minInt(i64); // -9223372036854775808 (special case!) + @memcpy(val.bytes[0..16], std.mem.asBytes(&test_val)); + const req = val.toIntRequirements(); + try testing.expect(req.sign_needed); + try testing.expectEqual(req.bits_needed, types.Num.Int.BitsNeeded.@"33_to_63".toBits()); // Due to special case + } +} + +test "IntValue.toIntRequirements - u128 max" { + var val = CIR.IntValue{ .bytes = [_]u8{0} ** 16, .kind = .u128 }; + const test_val: u128 = std.math.maxInt(u128); + @memcpy(val.bytes[0..16], std.mem.asBytes(&test_val)); + const req = val.toIntRequirements(); + try testing.expect(!req.sign_needed); + try testing.expectEqual(req.bits_needed, types.Num.Int.BitsNeeded.@"128".toBits()); +} + +test "IntValue.toFracRequirements - f32 precision boundaries" { + // 2^24 - 1 (largest consecutive integer in f32) + { + var val = CIR.IntValue{ .bytes = [_]u8{0} ** 16, .kind = .u128 }; + const test_val: u128 = 16777215; + @memcpy(val.bytes[0..16], std.mem.asBytes(&test_val)); + const req = val.toFracRequirements(); + try testing.expect(req.fits_in_f32); + } + + // 2^24 (still representable exactly) + { + var val = CIR.IntValue{ .bytes = [_]u8{0} ** 16, .kind = .u128 }; + const test_val: u128 = 16777216; + @memcpy(val.bytes[0..16], std.mem.asBytes(&test_val)); + const req = val.toFracRequirements(); + try testing.expect(req.fits_in_f32); + } + + // 2^24 + 1 (first integer that can't be exactly represented) + { + var val = CIR.IntValue{ .bytes = [_]u8{0} ** 16, .kind = .u128 }; + const test_val: u128 = 16777217; + @memcpy(val.bytes[0..16], std.mem.asBytes(&test_val)); + const req = val.toFracRequirements(); + try testing.expect(!req.fits_in_f32); // Cannot be exactly represented + } +} + +test "IntValue.toFracRequirements - Dec boundaries" { + // Value near Dec's positive limit (~1.7e20) + { + var val = CIR.IntValue{ .bytes = [_]u8{0} ** 16, .kind = .i128 }; + const test_val: i128 = 170141183460469231731; // Just under Dec's limit + @memcpy(val.bytes[0..16], std.mem.asBytes(&test_val)); + const req = val.toFracRequirements(); + try testing.expect(req.fits_in_dec); + } + + // Value exceeding Dec's positive limit + { + var val = CIR.IntValue{ .bytes = [_]u8{0} ** 16, .kind = .i128 }; + const test_val: i128 = std.math.maxInt(i128); // Way over Dec's limit + @memcpy(val.bytes[0..16], std.mem.asBytes(&test_val)); + const req = val.toFracRequirements(); + try testing.expect(!req.fits_in_dec); + } + + // Value near Dec's negative limit + { + var val = CIR.IntValue{ .bytes = [_]u8{0} ** 16, .kind = .i128 }; + const test_val: i128 = -170141183460469231731; // Just within Dec's limit + @memcpy(val.bytes[0..16], std.mem.asBytes(&test_val)); + const req = val.toFracRequirements(); + try testing.expect(req.fits_in_dec); + } +} + +test "SmallDecValue edge cases" { + // Maximum denominator power (produces very small but non-zero value) + { + const val = CIR.SmallDecValue{ .numerator = 1, .denominator_power_of_ten = 255 }; + const f64_val = val.toF64(); + // This doesn't underflow to 0 - f64 can represent very small values + try testing.expect(f64_val > 0.0); + try testing.expect(f64_val < 1e-250); // Very small + const req = val.toFracRequirements(); + // Very small values don't fit in f32 (would underflow) + try testing.expect(!req.fits_in_f32); // Too small for f32 + try testing.expect(req.fits_in_dec); // But fits in Dec (as 0 or very small) + } + + // Large numerator with large denominator (should produce normal value) + { + const val = CIR.SmallDecValue{ .numerator = 32767, .denominator_power_of_ten = 4 }; + const f64_val = val.toF64(); + try testing.expectApproxEqAbs(@as(f64, 3.2767), f64_val, 0.0001); + const req = val.toFracRequirements(); + try testing.expect(req.fits_in_f32); + try testing.expect(req.fits_in_dec); + } + + // Negative max numerator + { + const val = CIR.SmallDecValue{ .numerator = -32768, .denominator_power_of_ten = 4 }; + const f64_val = val.toF64(); + try testing.expectApproxEqAbs(@as(f64, -3.2768), f64_val, 0.0001); + const req = val.toFracRequirements(); + try testing.expect(req.fits_in_f32); + try testing.expect(req.fits_in_dec); + } + + // Value that would be subnormal in f32 (but still representable) + { + const val = CIR.SmallDecValue{ .numerator = 1, .denominator_power_of_ten = 40 }; + const f64_val = val.toF64(); + try testing.expectEqual(@as(f64, 1e-40), f64_val); + const req = val.toFracRequirements(); + try testing.expect(req.fits_in_f32); // CAN be represented as subnormal in f32 + try testing.expect(req.fits_in_dec); + } + + // Value that's too small even for f32 subnormals + { + const val = CIR.SmallDecValue{ .numerator = 1, .denominator_power_of_ten = 46 }; + const f64_val = val.toF64(); + try testing.expectEqual(@as(f64, 1e-46), f64_val); + const req = val.toFracRequirements(); + try testing.expect(!req.fits_in_f32); // Below f32's true minimum (~1.4e-45) + try testing.expect(req.fits_in_dec); + } +} diff --git a/src/canonicalize/test/node_store_test.zig b/src/canonicalize/test/node_store_test.zig index 9ef94383a9..1de617d9d0 100644 --- a/src/canonicalize/test/node_store_test.zig +++ b/src/canonicalize/test/node_store_test.zig @@ -54,6 +54,7 @@ fn rand_region() base.Region { test "NodeStore round trip - Statements" { const gpa = testing.allocator; + var store = try NodeStore.init(gpa); defer store.deinit(); @@ -175,6 +176,7 @@ test "NodeStore round trip - Statements" { test "NodeStore round trip - Expressions" { const gpa = testing.allocator; + var store = try NodeStore.init(gpa); defer store.deinit(); @@ -182,25 +184,30 @@ test "NodeStore round trip - Expressions" { defer expressions.deinit(); try expressions.append(CIR.Expr{ - .e_int = .{ + .e_num = .{ .value = .{ .bytes = @bitCast(@as(i128, 42)), .kind = .i128 }, + .kind = .i128, }, }); try expressions.append(CIR.Expr{ - .e_frac_f32 = .{ .value = rand.random().float(f32) }, + .e_frac_f32 = .{ .value = rand.random().float(f32), .has_suffix = false }, }); try expressions.append(CIR.Expr{ - .e_frac_f64 = .{ .value = rand.random().float(f64) }, + .e_frac_f64 = .{ .value = rand.random().float(f64), .has_suffix = false }, }); try expressions.append(CIR.Expr{ - .e_frac_dec = .{ + .e_dec = .{ .value = RocDec{ .num = 314 }, + .has_suffix = false, }, }); try expressions.append(CIR.Expr{ .e_dec_small = .{ - .numerator = rand.random().int(i16), - .denominator_power_of_ten = rand.random().int(u8), + .value = .{ + .numerator = rand.random().int(i16), + .denominator_power_of_ten = rand.random().int(u8), + }, + .has_suffix = false, }, }); try expressions.append(CIR.Expr{ @@ -227,7 +234,6 @@ test "NodeStore round trip - Expressions" { }); try expressions.append(CIR.Expr{ .e_list = .{ - .elem_var = rand_idx(TypeVar), .elems = CIR.Expr.Span{ .span = rand_span() }, }, }); @@ -251,6 +257,7 @@ test "NodeStore round trip - Expressions" { }); try expressions.append(CIR.Expr{ .e_call = .{ + .func = rand_idx(CIR.Expr.Idx), .args = CIR.Expr.Span{ .span = rand_span() }, .called_via = CalledVia.apply, }, @@ -347,8 +354,9 @@ test "NodeStore round trip - Expressions" { }, }); try expressions.append(CIR.Expr{ - .e_frac_dec = .{ + .e_dec = .{ .value = RocDec{ .num = 123456789 }, + .has_suffix = false, }, }); try expressions.append(CIR.Expr{ @@ -385,6 +393,7 @@ test "NodeStore round trip - Expressions" { test "NodeStore round trip - Diagnostics" { const gpa = testing.allocator; + var store = try NodeStore.init(gpa); defer store.deinit(); @@ -547,6 +556,70 @@ test "NodeStore round trip - Diagnostics" { }, }); + try diagnostics.append(CIR.Diagnostic{ + .type_module_missing_matching_type = .{ + .module_name = rand_ident_idx(), + .region = rand_region(), + }, + }); + + try diagnostics.append(CIR.Diagnostic{ + .default_app_missing_main = .{ + .module_name = rand_ident_idx(), + .region = rand_region(), + }, + }); + + try diagnostics.append(CIR.Diagnostic{ + .default_app_wrong_arity = .{ + .arity = 2, + .region = rand_region(), + }, + }); + + try diagnostics.append(CIR.Diagnostic{ + .cannot_import_default_app = .{ + .module_name = rand_ident_idx(), + .region = rand_region(), + }, + }); + + try diagnostics.append(CIR.Diagnostic{ + .execution_requires_app_or_default_app = .{ + .region = rand_region(), + }, + }); + + try diagnostics.append(CIR.Diagnostic{ + .type_name_case_mismatch = .{ + .module_name = rand_ident_idx(), + .type_name = rand_ident_idx(), + .region = rand_region(), + }, + }); + + try diagnostics.append(CIR.Diagnostic{ + .module_header_deprecated = .{ + .region = rand_region(), + }, + }); + + try diagnostics.append(CIR.Diagnostic{ + .redundant_expose_main_type = .{ + .type_name = rand_ident_idx(), + .module_name = rand_ident_idx(), + .region = rand_region(), + }, + }); + + try diagnostics.append(CIR.Diagnostic{ + .invalid_main_type_rename_in_exposing = .{ + .type_name = rand_ident_idx(), + .alias = rand_ident_idx(), + .region = rand_region(), + }, + }); + try diagnostics.append(CIR.Diagnostic{ .unused_variable = .{ .ident = rand_ident_idx(), @@ -732,6 +805,7 @@ test "NodeStore round trip - Diagnostics" { test "NodeStore round trip - TypeAnno" { const gpa = testing.allocator; + var store = try NodeStore.init(gpa); defer store.deinit(); @@ -741,30 +815,63 @@ test "NodeStore round trip - TypeAnno" { // Test all TypeAnno variants to ensure complete coverage try type_annos.append(CIR.TypeAnno{ .apply = .{ - .symbol = rand_ident_idx(), + .name = rand_ident_idx(), + .base = .{ .builtin = .dec }, + .args = CIR.TypeAnno.Span{ .span = rand_span() }, + }, + }); + try type_annos.append(CIR.TypeAnno{ + .apply = .{ + .name = rand_ident_idx(), + .base = .{ .local = .{ .decl_idx = @enumFromInt(10) } }, + .args = CIR.TypeAnno.Span{ .span = rand_span() }, + }, + }); + try type_annos.append(CIR.TypeAnno{ + .apply = .{ + .name = rand_ident_idx(), + .base = .{ .external = .{ + .module_idx = rand_idx(CIR.Import.Idx), + .target_node_idx = rand.random().int(u16), + } }, .args = CIR.TypeAnno.Span{ .span = rand_span() }, }, }); try type_annos.append(CIR.TypeAnno{ - .ty_var = .{ + .rigid_var = .{ .name = rand_ident_idx(), }, }); + try type_annos.append(CIR.TypeAnno{ + .rigid_var_lookup = .{ + .ref = rand_idx(CIR.TypeAnno.Idx), + }, + }); try type_annos.append(CIR.TypeAnno{ .underscore = {}, }); try type_annos.append(CIR.TypeAnno{ - .ty = .{ - .symbol = rand_ident_idx(), + .lookup = .{ + .name = rand_ident_idx(), + .base = .{ .builtin = .dec }, }, }); - try type_annos.append(CIR.TypeAnno{ - .ty = .{ - .symbol = rand_ident_idx(), + .lookup = .{ + .name = rand_ident_idx(), + .base = .{ .local = .{ .decl_idx = @enumFromInt(10) } }, + }, + }); + try type_annos.append(CIR.TypeAnno{ + .lookup = .{ + .name = rand_ident_idx(), + .base = .{ .external = .{ + .module_idx = rand_idx(CIR.Import.Idx), + .target_node_idx = rand.random().int(u16), + } }, }, }); @@ -775,6 +882,13 @@ test "NodeStore round trip - TypeAnno" { }, }); + try type_annos.append(CIR.TypeAnno{ + .tag = .{ + .name = rand_ident_idx(), + .args = CIR.TypeAnno.Span{ .span = rand_span() }, + }, + }); + try type_annos.append(CIR.TypeAnno{ .tuple = .{ .elems = CIR.TypeAnno.Span{ .span = rand_span() }, @@ -801,19 +915,6 @@ test "NodeStore round trip - TypeAnno" { }, }); - try type_annos.append(CIR.TypeAnno{ - .ty = .{ - .symbol = rand_ident_idx(), - }, - }); - - try type_annos.append(CIR.TypeAnno{ - .ty_lookup_external = .{ - .module_idx = rand_idx(CIR.Import.Idx), - .target_node_idx = rand.random().int(u16), - }, - }); - try type_annos.append(CIR.TypeAnno{ .malformed = .{ .diagnostic = rand_idx(CIR.Diagnostic.Idx), @@ -833,8 +934,13 @@ test "NodeStore round trip - TypeAnno" { }; } + // We have extra tests for: + // * apply -> 2 + // * lookup -> 2 + const extra_test_count = 4; + const actual_test_count = type_annos.items.len; - if (actual_test_count < NodeStore.MODULEENV_TYPE_ANNO_NODE_COUNT) { + if (actual_test_count - extra_test_count < NodeStore.MODULEENV_TYPE_ANNO_NODE_COUNT) { std.debug.print("CIR.TypeAnno test coverage insufficient! Need at least {d} test cases but found {d}.\n", .{ NodeStore.MODULEENV_TYPE_ANNO_NODE_COUNT, actual_test_count }); std.debug.print("Please add test cases for missing type annotation variants.\n", .{}); return error.IncompleteTypeAnnoTestCoverage; @@ -843,6 +949,7 @@ test "NodeStore round trip - TypeAnno" { test "NodeStore round trip - Pattern" { const gpa = testing.allocator; + var store = try NodeStore.init(gpa); defer store.deinit(); @@ -884,15 +991,11 @@ test "NodeStore round trip - Pattern" { }); try patterns.append(CIR.Pattern{ .record_destructure = .{ - .whole_var = rand_idx(TypeVar), - .ext_var = rand_idx(TypeVar), .destructs = CIR.Pattern.RecordDestruct.Span{ .span = rand_span() }, }, }); try patterns.append(CIR.Pattern{ .list = .{ - .list_var = rand_idx(TypeVar), - .elem_var = rand_idx(TypeVar), .patterns = CIR.Pattern.Span{ .span = rand_span() }, .rest_info = .{ .index = rand.random().int(u32), .pattern = rand_idx(CIR.Pattern.Idx) }, }, @@ -903,22 +1006,27 @@ test "NodeStore round trip - Pattern" { }, }); try patterns.append(CIR.Pattern{ - .int_literal = .{ + .num_literal = .{ .value = CIR.IntValue{ .bytes = @bitCast(rand.random().int(i128)), .kind = .i128, }, + .kind = .int_unbound, }, }); try patterns.append(CIR.Pattern{ .small_dec_literal = .{ - .numerator = rand.random().int(i16), - .denominator_power_of_ten = rand.random().int(u8), + .value = .{ + .numerator = rand.random().int(i16), + .denominator_power_of_ten = rand.random().int(u8), + }, + .has_suffix = true, }, }); try patterns.append(CIR.Pattern{ .dec_literal = .{ .value = RocDec.fromU64(rand.random().int(u64)), + .has_suffix = false, }, }); try patterns.append(CIR.Pattern{ diff --git a/src/canonicalize/test/record_test.zig b/src/canonicalize/test/record_test.zig index 87ee4cd896..fffcc2337c 100644 --- a/src/canonicalize/test/record_test.zig +++ b/src/canonicalize/test/record_test.zig @@ -26,7 +26,7 @@ test "record literal uses record_unbound" { var ast = try parse.parseExpr(&env.common, gpa); defer ast.deinit(gpa); - var can = try Can.init(&env, &ast, null); + var can = try Can.init(&env, &ast, null, .{}); defer can.deinit(); const expr_idx: parse.AST.Expr.Idx = @enumFromInt(ast.root_node_idx); @@ -63,7 +63,7 @@ test "record literal uses record_unbound" { var ast = try parse.parseExpr(&env.common, gpa); defer ast.deinit(gpa); - var can = try Can.init(&env, &ast, null); + var can = try Can.init(&env, &ast, null, .{}); defer can.deinit(); const expr_idx: parse.AST.Expr.Idx = @enumFromInt(ast.root_node_idx); @@ -100,7 +100,7 @@ test "record literal uses record_unbound" { var ast = try parse.parseExpr(&env.common, gpa); defer ast.deinit(gpa); - var can = try Can.init(&env, &ast, null); + var can = try Can.init(&env, &ast, null, .{}); defer can.deinit(); const expr_idx: parse.AST.Expr.Idx = @enumFromInt(ast.root_node_idx); @@ -133,6 +133,7 @@ test "record literal uses record_unbound" { test "record_unbound basic functionality" { const gpa = std.testing.allocator; + const source = "{ x: 42, y: 99 }"; // Test that record literals create record_unbound types @@ -144,7 +145,7 @@ test "record_unbound basic functionality" { var ast = try parse.parseExpr(&env.common, gpa); defer ast.deinit(gpa); - var can = try Can.init(&env, &ast, null); + var can = try Can.init(&env, &ast, null, .{}); defer can.deinit(); const expr_idx: parse.AST.Expr.Idx = @enumFromInt(ast.root_node_idx); @@ -176,6 +177,7 @@ test "record_unbound basic functionality" { test "record_unbound with multiple fields" { const gpa = std.testing.allocator; + const source = "{ a: 123, b: 456, c: 789 }"; var env = try ModuleEnv.init(gpa, source); @@ -187,7 +189,7 @@ test "record_unbound with multiple fields" { var ast = try parse.parseExpr(&env.common, gpa); defer ast.deinit(gpa); - var can = try Can.init(&env, &ast, null); + var can = try Can.init(&env, &ast, null, .{}); defer can.deinit(); const expr_idx: parse.AST.Expr.Idx = @enumFromInt(ast.root_node_idx); @@ -248,7 +250,7 @@ test "record with extension variable" { // Check that extension is a flex var (open record) const ext_resolved = env.types.resolveVar(record.ext); switch (ext_resolved.desc.content) { - .flex_var => { + .flex => { // Success! The record has an open extension }, else => return error.ExpectedFlexVar, diff --git a/src/canonicalize/test/scope_test.zig b/src/canonicalize/test/scope_test.zig index 39b0cfc3e1..97aed925df 100644 --- a/src/canonicalize/test/scope_test.zig +++ b/src/canonicalize/test/scope_test.zig @@ -26,7 +26,7 @@ const ScopeTestContext = struct { try module_env.initCIRFields(gpa, "test"); return ScopeTestContext{ - .self = try Can.init(module_env, undefined, null), + .self = try Can.init(module_env, undefined, null, .{}), .module_env = module_env, .gpa = gpa, }; diff --git a/src/check/Check.zig b/src/check/Check.zig index 73b3dbc775..cb55e1d550 100644 --- a/src/check/Check.zig +++ b/src/check/Check.zig @@ -9,6 +9,7 @@ const tracy = @import("tracy"); const collections = @import("collections"); const types_mod = @import("types"); const can = @import("can"); +const builtins = @import("builtins"); const copy_import = @import("copy_import.zig"); const unifier = @import("unify.zig"); @@ -21,16 +22,146 @@ const ModuleEnv = can.ModuleEnv; const Allocator = std.mem.Allocator; const Ident = base.Ident; const Region = base.Region; -const Instantiate = types_mod.instantiate.Instantiate; const Func = types_mod.Func; const Var = types_mod.Var; +const Flex = types_mod.Flex; +const Rigid = types_mod.Rigid; const Content = types_mod.Content; +const Rank = types_mod.Rank; +const Num = types_mod.Num; const testing = std.testing; +const Instantiator = types_mod.instantiate.Instantiator; +const Generalizer = types_mod.generalize.Generalizer; +const VarPool = types_mod.generalize.VarPool; const SnapshotStore = @import("snapshot.zig").Store; const ProblemStore = @import("problem.zig").Store; const Self = @This(); +gpa: std.mem.Allocator, +// not owned +types: *types_mod.Store, +cir: *ModuleEnv, +regions: *Region.List, +other_modules: []const *const ModuleEnv, +common_idents: CommonIdents, + +/// type snapshots used in error messages +snapshots: SnapshotStore, +/// type problems +problems: ProblemStore, +/// reusable scratch arrays used in unification +unify_scratch: unifier.Scratch, +/// reusable scratch arrays used in occurs check +occurs_scratch: occurs.Scratch, +/// free vars collected when generation types from annotation +anno_free_vars: base.Scratch(FreeVar), +/// free vars collected when generation types from type decls +decl_free_vars: base.Scratch(FreeVar), +/// annos we've already seen when generation a type from an annotation +seen_annos: std.AutoHashMap(CIR.TypeAnno.Idx, Var), +/// pool of variables that need to be generalized, built up during checking +var_pool: VarPool, +/// wrapper around generalization, contains some internal state used to do it's work +generalizer: Generalizer, +/// A map from one var to another. Used in instantiation and var copying +var_map: std.AutoHashMap(Var, Var), +/// A map from one var to another. Used to apply type arguments in instantiation +rigid_var_substitutions: std.AutoHashMapUnmanaged(Ident.Idx, Var), +/// scratch vars used to build up intermediate lists, used for various things +scratch_vars: base.Scratch(Var), +/// scratch tags used to build up intermediate lists, used for various things +scratch_tags: base.Scratch(types_mod.Tag), +/// scratch record fields used to build up intermediate lists, used for various things +scratch_record_fields: base.Scratch(types_mod.RecordField), +// Cache for imported types. This cache lives for the entire type-checking session +/// of a module, so the same imported type can be reused across the entire module. +import_cache: ImportCache, +/// Maps variables to the expressions that constrained them (for better error regions) +constraint_origins: std.AutoHashMap(Var, Var), + +/// A map of rigid variables that we build up during a branch of type checking +const FreeVar = struct { ident: base.Ident.Idx, var_: Var }; + +/// A struct of common idents +pub const CommonIdents = struct { + module_name: base.Ident.Idx, + list: base.Ident.Idx, + box: base.Ident.Idx, +}; + +/// Init type solver +/// Does *not* own types_store or cir, but *does* own other fields +pub fn init( + gpa: std.mem.Allocator, + types: *types_mod.Store, + cir: *const ModuleEnv, + other_modules: []const *const ModuleEnv, + regions: *Region.List, + common_idents: CommonIdents, +) std.mem.Allocator.Error!Self { + return .{ + .gpa = gpa, + .types = types, + .cir = @constCast(cir), + .other_modules = other_modules, + .regions = regions, + .common_idents = common_idents, + .snapshots = try SnapshotStore.initCapacity(gpa, 512), + .problems = try ProblemStore.initCapacity(gpa, 64), + .unify_scratch = try unifier.Scratch.init(gpa), + .occurs_scratch = try occurs.Scratch.init(gpa), + .anno_free_vars = try base.Scratch(FreeVar).init(gpa), + .decl_free_vars = try base.Scratch(FreeVar).init(gpa), + .seen_annos = std.AutoHashMap(CIR.TypeAnno.Idx, Var).init(gpa), + .var_pool = try VarPool.init(gpa), + .generalizer = try Generalizer.init(gpa, types), + .var_map = std.AutoHashMap(Var, Var).init(gpa), + .rigid_var_substitutions = std.AutoHashMapUnmanaged(Ident.Idx, Var){}, + .scratch_vars = try base.Scratch(types_mod.Var).init(gpa), + .scratch_tags = try base.Scratch(types_mod.Tag).init(gpa), + .scratch_record_fields = try base.Scratch(types_mod.RecordField).init(gpa), + .import_cache = ImportCache{}, + .constraint_origins = std.AutoHashMap(Var, Var).init(gpa), + }; +} + +/// Deinit owned fields +pub fn deinit(self: *Self) void { + self.problems.deinit(self.gpa); + self.snapshots.deinit(); + self.unify_scratch.deinit(); + self.occurs_scratch.deinit(); + self.anno_free_vars.deinit(self.gpa); + self.decl_free_vars.deinit(self.gpa); + self.seen_annos.deinit(); + self.var_pool.deinit(); + self.generalizer.deinit(); + self.var_map.deinit(); + self.rigid_var_substitutions.deinit(self.gpa); + self.scratch_vars.deinit(self.gpa); + self.scratch_tags.deinit(self.gpa); + self.scratch_record_fields.deinit(self.gpa); + self.import_cache.deinit(self.gpa); + self.constraint_origins.deinit(); +} + +/// Assert that type vars and regions in sync +pub inline fn debugAssertArraysInSync(self: *const Self) void { + if (builtin.mode == .Debug) { + const region_nodes = self.regions.len(); + const type_nodes = self.types.len(); + if (!(region_nodes == type_nodes)) { + std.debug.panic( + "Arrays out of sync:\n type_nodes={}\n region_nodes={}\n ", + .{ type_nodes, region_nodes }, + ); + } + } +} + +// import caches // + /// Key for the import cache: module index + expression index in that module const ImportCacheKey = struct { module_idx: CIR.Import.Idx, @@ -66,84 +197,10 @@ const ImportCache = std.HashMapUnmanaged(ImportCacheKey, Var, struct { } }, 80); -gpa: std.mem.Allocator, -// not owned -types: *types_mod.Store, -cir: *ModuleEnv, -regions: *Region.List, -other_modules: []const *ModuleEnv, -// owned -snapshots: SnapshotStore, -problems: ProblemStore, -unify_scratch: unifier.Scratch, -occurs_scratch: occurs.Scratch, -var_map: std.AutoHashMap(Var, Var), -annotation_rigid_var_subs: Instantiate.RigidToFlexSubs, -anonymous_rigid_var_subs: Instantiate.RigidToFlexSubs, -/// Cache for imported types. This cache lives for the entire type-checking session -/// of a module, so the same imported type can be reused across the entire module. -import_cache: ImportCache, -/// Maps variables to the expressions that constrained them (for better error regions) -constraint_origins: std.AutoHashMap(Var, Var), - -/// Init type solver -/// Does *not* own types_store or cir, but *does* own other fields -pub fn init( - gpa: std.mem.Allocator, - types: *types_mod.Store, - cir: *const ModuleEnv, - other_modules: []const *ModuleEnv, - regions: *Region.List, -) std.mem.Allocator.Error!Self { - return .{ - .gpa = gpa, - .types = types, - .cir = @constCast(cir), - .other_modules = other_modules, - .regions = regions, - .snapshots = try SnapshotStore.initCapacity(gpa, 512), - .problems = try ProblemStore.initCapacity(gpa, 64), - .unify_scratch = try unifier.Scratch.init(gpa), - .occurs_scratch = try occurs.Scratch.init(gpa), - .var_map = std.AutoHashMap(Var, Var).init(gpa), - .annotation_rigid_var_subs = try Instantiate.RigidToFlexSubs.init(gpa), - .anonymous_rigid_var_subs = try Instantiate.RigidToFlexSubs.init(gpa), - .import_cache = ImportCache{}, - .constraint_origins = std.AutoHashMap(Var, Var).init(gpa), - }; -} - -/// Deinit owned fields -pub fn deinit(self: *Self) void { - self.problems.deinit(self.gpa); - self.snapshots.deinit(); - self.unify_scratch.deinit(); - self.occurs_scratch.deinit(); - self.var_map.deinit(); - self.annotation_rigid_var_subs.deinit(self.gpa); - self.anonymous_rigid_var_subs.deinit(self.gpa); - self.import_cache.deinit(self.gpa); - self.constraint_origins.deinit(); -} - -/// Assert that type vars and regions in sync -pub inline fn debugAssertArraysInSync(self: *const Self) void { - if (builtin.mode == .Debug) { - const region_nodes = self.regions.len(); - const type_nodes = self.types.len(); - if (!(region_nodes == type_nodes)) { - std.debug.panic( - "Arrays out of sync:\n type_nodes={}\n region_nodes={}\n ", - .{ type_nodes, region_nodes }, - ); - } - } -} - // unify // /// Unify two types -pub fn unify(self: *Self, a: Var, b: Var) std.mem.Allocator.Error!unifier.Result { +pub fn unify(self: *Self, a: Var, b: Var, rank: Rank) std.mem.Allocator.Error!unifier.Result { const trace = tracy.trace(@src()); defer trace.end(); @@ -175,6 +232,10 @@ pub fn unify(self: *Self, a: Var, b: Var) std.mem.Allocator.Error!unifier.Result } } + for (self.unify_scratch.fresh_vars.items.items) |fresh_var| { + try self.var_pool.addVarToRank(fresh_var, rank); + } + return result; } @@ -208,7 +269,7 @@ fn findConstraintOriginForVars(self: *Self, a: Var, b: Var) ?Var { /// Unify two variables where the second represents an annotation type. /// This sets from_annotation=true to ensure proper error region highlighting. -pub fn unifyWithAnnotation(self: *Self, a: Var, b: Var) std.mem.Allocator.Error!unifier.Result { +pub fn unifyFromAnno(self: *Self, a: Var, b: Var, rank: Rank) std.mem.Allocator.Error!unifier.Result { const trace = tracy.trace(@src()); defer trace.end(); @@ -235,6 +296,10 @@ pub fn unifyWithAnnotation(self: *Self, a: Var, b: Var) std.mem.Allocator.Error! try self.constraint_origins.put(a, origin); try self.constraint_origins.put(b, origin); } + + for (self.unify_scratch.fresh_vars.items.items) |fresh_var| { + try self.var_pool.addVarToRank(fresh_var, rank); + } } return result; @@ -260,7 +325,7 @@ pub fn unifyWithConstraintOrigin(self: *Self, a: Var, b: Var, constraint_origin_ ); } -// instantiate // +// instantiate // const InstantiateRegionBehavior = union(enum) { explicit: Region, @@ -268,36 +333,94 @@ const InstantiateRegionBehavior = union(enum) { use_last_var, }; -const RigidVarBehavior = union(enum) { - use_cached_rigid_vars, - rollback_rigid_vars, -}; - -/// Instantiate a variable +/// Instantiate a variable, substituting any encountered rigids with flex vars +/// +/// Note that the the rigid var structure will be preserved. +/// E.g. `a -> a`, `a` will reference the same new flex var fn instantiateVar( self: *Self, var_to_instantiate: Var, - rigid_to_flex_subs: *Instantiate.RigidToFlexSubs, + rank: types_mod.Rank, region_behavior: InstantiateRegionBehavior, ) std.mem.Allocator.Error!Var { - self.var_map.clearRetainingCapacity(); + var instantiate_ctx = Instantiator{ + .store = self.types, + .idents = self.cir.getIdentStoreConst(), + .var_map = &self.var_map, - var instantiate = Instantiate.init(self.types, self.cir.getIdentStore(), &self.var_map); - var instantiate_ctx = Instantiate.Ctx{ - .rigid_var_subs = rigid_to_flex_subs, + .current_rank = rank, + .rigid_behavior = .fresh_flex, }; - const instantiated_var = try instantiate.instantiateVar(var_to_instantiate, &instantiate_ctx); + return self.instantiateVarHelp(var_to_instantiate, &instantiate_ctx, region_behavior); +} + +/// Instantiate a variable, substituting any encountered rigids with *new* rigid vars +/// +/// Note that the the rigid var structure will be preserved. +/// E.g. `a -> a`, `a` will reference the same new rigid var +fn instantiateVarPreserveRigids( + self: *Self, + var_to_instantiate: Var, + rank: types_mod.Rank, + region_behavior: InstantiateRegionBehavior, +) std.mem.Allocator.Error!Var { + var instantiate_ctx = Instantiator{ + .store = self.types, + .idents = self.cir.getIdentStoreConst(), + .var_map = &self.var_map, + + .current_rank = rank, + .rigid_behavior = .fresh_flex, + }; + return self.instantiateVarHelp(var_to_instantiate, &instantiate_ctx, region_behavior); +} + +/// Instantiate a variable +fn instantiateVarWithSubs( + self: *Self, + var_to_instantiate: Var, + subs: *std.AutoHashMapUnmanaged(Ident.Idx, Var), + rank: types_mod.Rank, + region_behavior: InstantiateRegionBehavior, +) std.mem.Allocator.Error!Var { + var instantiate_ctx = Instantiator{ + .store = self.types, + .idents = self.cir.getIdentStoreConst(), + .var_map = &self.var_map, + + .current_rank = rank, + .rigid_behavior = .{ .substitute_rigids = subs }, + }; + return self.instantiateVarHelp(var_to_instantiate, &instantiate_ctx, region_behavior); +} + +/// Instantiate a variable +fn instantiateVarHelp( + self: *Self, + var_to_instantiate: Var, + instantiator: *Instantiator, + region_behavior: InstantiateRegionBehavior, +) std.mem.Allocator.Error!Var { + // First, reset state + instantiator.var_map.clearRetainingCapacity(); + + // Then, instantiate the variable with the provided context + const instantiated_var = try instantiator.instantiateVar(var_to_instantiate); // If we had to insert any new type variables, ensure that we have // corresponding regions for them. This is essential for error reporting. const root_instantiated_region = self.regions.get(@enumFromInt(@intFromEnum(var_to_instantiate))).*; - if (self.var_map.count() > 0) { - var iterator = self.var_map.iterator(); + if (instantiator.var_map.count() > 0) { + var iterator = instantiator.var_map.iterator(); while (iterator.next()) |x| { // Get the newly created var const fresh_var = x.value_ptr.*; - try self.fillInRegionsThrough(fresh_var); + // Add to pool + try self.var_pool.addVarToRank(fresh_var, instantiator.current_rank); + + // Set the region + try self.fillInRegionsThrough(fresh_var); switch (region_behavior) { .explicit => |region| { self.setRegionAt(fresh_var, region); @@ -317,58 +440,10 @@ fn instantiateVar( // Assert that we have regions for every type variable self.debugAssertArraysInSync(); + // Return the instantiated var return instantiated_var; } -/// Instantiate a variable -fn instantiateVarAnon( - self: *Self, - var_to_instantiate: Var, - region_behavior: InstantiateRegionBehavior, -) std.mem.Allocator.Error!Var { - self.anonymous_rigid_var_subs.items.clearRetainingCapacity(); - const var_ = self.instantiateVar(var_to_instantiate, &self.anonymous_rigid_var_subs, region_behavior); - return var_; -} - -// copy type from other module // - -/// Instantiate a variable, writing su -fn copyVar( - self: *Self, - other_module_var: Var, - other_module_env: *ModuleEnv, -) std.mem.Allocator.Error!Var { - self.var_map.clearRetainingCapacity(); - const copied_var = try copy_import.copyVar( - &other_module_env.*.types, - self.types, - other_module_var, - &self.var_map, - other_module_env.getIdentStore(), - self.cir.getIdentStore(), - self.gpa, - ); - - // If we had to insert any new type variables, ensure that we have - // corresponding regions for them. This is essential for error reporting. - if (self.var_map.count() > 0) { - var iterator = self.var_map.iterator(); - while (iterator.next()) |x| { - // Get the newly created var - const fresh_var = x.value_ptr.*; - try self.fillInRegionsThrough(fresh_var); - - self.setRegionAt(fresh_var, base.Region.zero()); - } - } - - // Assert that we have regions for every type variable - self.debugAssertArraysInSync(); - - return copied_var; -} - // regions // /// Fill slots in the regions array up to and including the target var @@ -385,897 +460,2157 @@ fn fillInRegionsThrough(self: *Self, target_var: Var) Allocator.Error!void { } } -/// The the region for a variable +/// Set the region for a var fn setRegionAt(self: *Self, target_var: Var, new_region: Region) void { self.regions.set(@enumFromInt(@intFromEnum(target_var)), new_region); } +/// Get the region for a var +fn getRegionAt(self: *Self, target_var: Var) Region { + self.regions.get(@enumFromInt(@intFromEnum(target_var))); +} + // fresh vars // /// The the region for a variable -fn fresh(self: *Self, new_region: Region) Allocator.Error!Var { - const var_ = try self.types.fresh(); +fn fresh(self: *Self, rank: Rank, new_region: Region) Allocator.Error!Var { + const var_ = try self.types.freshWithRank(rank); try self.fillInRegionsThrough(var_); self.setRegionAt(var_, new_region); return var_; } /// The the region for a variable -fn freshFromContent(self: *Self, content: Content, new_region: Region) Allocator.Error!Var { - const var_ = try self.types.freshFromContent(content); +fn freshRedirect(self: *Self, redirect_to: Var, new_region: Region) Allocator.Error!Var { + const var_ = try self.types.freshRedirect(redirect_to); try self.fillInRegionsThrough(var_); self.setRegionAt(var_, new_region); return var_; } -// external types // - -const ExternalType = struct { - local_var: Var, - other_cir_node_idx: CIR.Node.Idx, - other_cir: *ModuleEnv, -}; - -/// Copy a variable from a different module into this module's types store. -/// -/// IMPORTANT: The caller must instantiate this variable before unifing -/// against it. This avoid poisoning the copied variable in the types store if -/// unification fails. -fn resolveVarFromExternal( - self: *Self, - module_idx: CIR.Import.Idx, - node_idx: u16, -) std.mem.Allocator.Error!?ExternalType { - const module_idx_int = @intFromEnum(module_idx); - if (module_idx_int < self.other_modules.len) { - const other_module_cir = self.other_modules[module_idx_int]; - const other_module_env = other_module_cir; - - // The idx of the expression in the other module - const target_node_idx = @as(CIR.Node.Idx, @enumFromInt(node_idx)); - - // Check if we've already copied this import - const cache_key = ImportCacheKey{ - .module_idx = module_idx, - .node_idx = target_node_idx, - }; - - const copied_var = if (self.import_cache.get(cache_key)) |cached_var| - // Reuse the previously copied type. - cached_var - else blk: { - // First time importing this type - copy it and cache the result - const imported_var = @as(Var, @enumFromInt(@intFromEnum(target_node_idx))); - const new_copy = try self.copyVar(imported_var, other_module_env); - try self.import_cache.put(self.gpa, cache_key, new_copy); - break :blk new_copy; - }; - - return .{ - .local_var = copied_var, - .other_cir_node_idx = target_node_idx, - .other_cir = other_module_env, - }; - } else { - return null; - } +/// The the region for a variable +fn freshFromContent(self: *Self, content: Content, rank: types_mod.Rank, new_region: Region) Allocator.Error!Var { + const var_ = try self.types.freshFromContentWithRank(content, rank); + try self.fillInRegionsThrough(var_); + self.setRegionAt(var_, new_region); + return var_; } -// defs // +/// The the region for a variable +fn freshBool(self: *Self, rank: Rank, new_region: Region) Allocator.Error!Var { + // Look up Bool's actual index from builtin_statements (should be first) + const builtin_stmts_slice = self.cir.store.sliceStatements(self.cir.builtin_statements); + std.debug.assert(builtin_stmts_slice.len >= 1); // Must have at least Bool + const bool_stmt_idx = builtin_stmts_slice[0]; // Bool is always the first builtin + // Debug assertion: verify this is a nominal type declaration + if (std.debug.runtime_safety) { + const stmt = self.cir.store.getStatement(bool_stmt_idx); + std.debug.assert(stmt == .s_nominal_decl); + } + return try self.instantiateVar(ModuleEnv.varFrom(bool_stmt_idx), rank, .{ .explicit = new_region }); +} + +// fresh vars // + +fn updateVar(self: *Self, target_var: Var, content: types_mod.Content, rank: types_mod.Rank) std.mem.Allocator.Error!void { + try self.types.setVarDesc(target_var, .{ .content = content, .rank = rank, .mark = types_mod.Mark.none }); +} + +// file // /// Check the types for all defs -pub fn checkDefs(self: *Self) std.mem.Allocator.Error!void { +pub fn checkFile(self: *Self) std.mem.Allocator.Error!void { const trace = tracy.trace(@src()); defer trace.end(); + // First, iterate over the statements, generating types for each type declaration + const builtin_stmts_slice = self.cir.store.sliceStatements(self.cir.builtin_statements); + for (builtin_stmts_slice) |builtin_stmt_idx| { + // If the statement is a type declaration, then generate the it's type + // The resulting generalized type is saved at the type var slot at `stmt_idx` + try self.generateStmtTypeDeclType(builtin_stmt_idx); + } + + // First, iterate over the statements, generating types for each type declaration + const stmts_slice = self.cir.store.sliceStatements(self.cir.all_statements); + for (stmts_slice) |stmt_idx| { + // If the statement is a type declaration, then generate the it's type + // The resulting generalized type is saved at the type var slot at `stmt_idx` + try self.generateStmtTypeDeclType(stmt_idx); + } + const defs_slice = self.cir.store.sliceDefs(self.cir.all_defs); for (defs_slice) |def_idx| { try self.checkDef(def_idx); } + + // Freeze interners after type-checking is complete + self.cir.freezeInterners(); } +// repl // + +/// Check an expr for the repl +pub fn checkExprRepl(self: *Self, expr_idx: CIR.Expr.Idx) std.mem.Allocator.Error!void { + // First, iterate over the statements, generating types for each type declaration + const stms_slice = self.cir.store.sliceStatements(self.cir.builtin_statements); + for (stms_slice) |stmt_idx| { + // If the statement is a type declaration, then generate the it's type + // The resulting generalized type is saved at the type var slot at `stmt_idx` + try self.generateStmtTypeDeclType(stmt_idx); + } + + // Push the rank for this definition + try self.var_pool.pushRank(); + defer self.var_pool.popRank(); + + // Ensure that the current rank in the pool is top-level + const rank = types_mod.Rank.top_level; + std.debug.assert(rank == self.var_pool.current_rank); + + _ = try self.checkExpr(expr_idx, rank, .no_expectation); + + // Now that we are existing the scope, we must generalize then pop this rank + try self.generalizer.generalize(&self.var_pool, rank); +} + +// defs // + /// Check the types for a single definition fn checkDef(self: *Self, def_idx: CIR.Def.Idx) std.mem.Allocator.Error!void { const trace = tracy.trace(@src()); defer trace.end(); + // Push the rank for this definition + try self.var_pool.pushRank(); + defer self.var_pool.popRank(); + + // Ensure that the current rank in the pool is top-level + const rank = types_mod.Rank.top_level; + std.debug.assert(rank == self.var_pool.current_rank); + const def = self.cir.store.getDef(def_idx); - const expr_var: Var = ModuleEnv.varFrom(def.expr); - const expr_region = self.cir.store.getNodeRegion(ModuleEnv.nodeIdxFrom(def.expr)); + const def_var = ModuleEnv.varFrom(def_idx); + const ptrn_var = ModuleEnv.varFrom(def.pattern); + const expr_var = ModuleEnv.varFrom(def.expr); // Check the pattern - try self.checkPattern(def.pattern); - - // Get the defs var slot - const def_var = ModuleEnv.varFrom(def_idx); + try self.checkPattern(def.pattern, rank, .no_expectation); // Handle if there's an annotation associated with this def if (def.annotation) |anno_idx| { const annotation = self.cir.store.getAnnotation(anno_idx); - const expr = self.cir.store.getExpr(def.expr); + self.anno_free_vars.items.clearRetainingCapacity(); + try self.generateAnnoTypeInPlace(annotation.type_anno, .annotation); + + // TODO: Duplicate anno var so if the body results in type mismatch, the + // annotation isn't corrupted + // We can instantiate, but how do we deal with rigid vars? + // const anno_var = try self.instantiateVaPreserveRigids(ModuleEnv.varFrom(annotation.type_anno), Rank.generalized, .use_last_var); const anno_var = ModuleEnv.varFrom(annotation.type_anno); - self.annotation_rigid_var_subs.items.clearRetainingCapacity(); - try self.checkAnnotation(annotation.type_anno); - if (expr == .e_lambda) { - // Special handling for lambda expressions with annotations - _ = try self.checkLambdaWithAnno( - def.expr, - expr_region, - expr.e_lambda, - anno_var, - ); - } else if (expr == .e_closure) { - // For closures with annotations, we need special handling - const closure = expr.e_closure; - const lambda_expr = self.cir.store.getExpr(closure.lambda_idx); - - if (lambda_expr == .e_lambda) { - // Use special lambda handling to propagate constraints without changing error locations - _ = try self.checkLambdaForClosure( - closure.lambda_idx, - lambda_expr.e_lambda, - anno_var, - ); - // Unify closure with lambda - _ = try self.unify(expr_var, ModuleEnv.varFrom(closure.lambda_idx)); - // Now unify with annotation for final validation - _ = try self.unifyWithAnnotation(expr_var, anno_var); - } else { - // Shouldn't happen - closures should contain lambdas - _ = try self.checkExpr(def.expr); - _ = try self.unifyWithAnnotation(expr_var, anno_var); - } - } else { - // Check the expr - _ = try self.checkExpr(def.expr); - - // Unify the expression with its annotation - _ = try self.unifyWithAnnotation(expr_var, anno_var); - } + _ = try self.checkExpr(def.expr, rank, .{ + .expected = .{ .var_ = anno_var, .from_annotation = true }, + }); } else { - // Check the expr - _ = try self.checkExpr(def.expr); + _ = try self.checkExpr(def.expr, rank, .no_expectation); } - // Unify the def with its expression - _ = try self.unify(def_var, ModuleEnv.varFrom(def.expr)); + // Also unify the pattern with the expr - needed so lookups work correctly + _ = try self.unify(ptrn_var, expr_var, rank); - // Also unify the pattern with the def - needed so lookups work correctly - // TODO could we unify directly with the pattern elsewhere, to save a type var and unify() here? - _ = try self.unify(ModuleEnv.varFrom(def.pattern), def_var); + // Set the def var to redirect to the pattern + _ = try self.types.setVarRedirect(def_var, ptrn_var); + + // Now that we are existing the scope, we must generalize then pop this rank + try self.generalizer.generalize(&self.var_pool, rank); +} + +// create types for type decls // + +/// Generate a type variable from the provided type statement. +/// If the stmt is not an alias or nominal dec, then do nothing +/// +/// The created variable is put in-place at the var slot at `decl_idx` +/// The created variable will be generalized +fn generateStmtTypeDeclType( + self: *Self, + decl_idx: CIR.Statement.Idx, +) std.mem.Allocator.Error!void { + const decl_free_vars_top = self.decl_free_vars.top(); + defer self.decl_free_vars.clearFrom(decl_free_vars_top); + + const decl = self.cir.store.getStatement(decl_idx); + const decl_var = ModuleEnv.varFrom(decl_idx); + + switch (decl) { + .s_alias_decl => |alias| { + // Get the type header's args + const header = self.cir.store.getTypeHeader(alias.header); + const header_args = self.cir.store.sliceTypeAnnos(header.args); + + // Next, generate the provided arg types and build the map of rigid variables in the header + for (header_args) |header_arg_idx| { + const header_arg = self.cir.store.getTypeAnno(header_arg_idx); + const header_var = ModuleEnv.varFrom(header_arg_idx); + switch (header_arg) { + .rigid_var => |rigid| { + try self.updateVar(header_var, .{ .rigid = Rigid.init(rigid.name) }, Rank.generalized); + }, + .underscore, .malformed => { + try self.updateVar(header_var, .err, Rank.generalized); + }, + else => { + // This should never be possible + std.debug.assert(false); + try self.updateVar(header_var, .err, Rank.generalized); + }, + } + } + + const header_vars: []Var = @ptrCast(header_args); + + // Now we have a built of list of rigid variables for the decl lhs (header). + // With this in hand, we can now generate the type for the lhs (body). + self.seen_annos.clearRetainingCapacity(); + const backing_var: Var = ModuleEnv.varFrom(alias.anno); + try self.generateAnnoTypeInPlace(alias.anno, .{ .type_decl = .{ + .idx = decl_idx, + .name = header.name, + .type_ = .alias, + .backing_var = backing_var, + .num_args = @intCast(header_args.len), + } }); + + try self.updateVar( + decl_var, + try self.types.mkAlias( + .{ .ident_idx = header.name }, + backing_var, + header_vars, + ), + Rank.generalized, + ); + }, + .s_nominal_decl => |nominal| { + // Get the type header's args + const header = self.cir.store.getTypeHeader(nominal.header); + const header_args = self.cir.store.sliceTypeAnnos(header.args); + + // Next, generate the provided arg types and build the map of rigid variables in the header + for (header_args) |header_arg_idx| { + const header_arg = self.cir.store.getTypeAnno(header_arg_idx); + const header_var = ModuleEnv.varFrom(header_arg_idx); + switch (header_arg) { + .rigid_var => |rigid| { + try self.updateVar(header_var, .{ .rigid = Rigid.init(rigid.name) }, Rank.generalized); + }, + .underscore, .malformed => { + try self.updateVar(header_var, .err, Rank.generalized); + }, + else => { + // This should never be possible + std.debug.assert(false); + try self.updateVar(header_var, .err, Rank.generalized); + }, + } + } + + const header_vars: []Var = @ptrCast(header_args); + + // Now we have a built of list of rigid variables for the decl lhs (header). + // With this in hand, we can now generate the type for the lhs (body). + self.seen_annos.clearRetainingCapacity(); + const backing_var: Var = ModuleEnv.varFrom(nominal.anno); + try self.generateAnnoTypeInPlace(nominal.anno, .{ .type_decl = .{ + .idx = decl_idx, + .name = header.name, + .type_ = .nominal, + .backing_var = backing_var, + .num_args = @intCast(header_args.len), + } }); + + try self.updateVar( + decl_var, + try self.types.mkNominal( + .{ .ident_idx = header.name }, + backing_var, + header_vars, + self.common_idents.module_name, + ), + Rank.generalized, + ); + }, + .s_runtime_error => { + try self.updateVar(decl_var, .err, Rank.generalized); + }, + else => { + // Do nothing + }, + } } // annotations // -/// Check the types for the provided pattern -pub fn checkAnnotation(self: *Self, anno_idx: CIR.TypeAnno.Idx) std.mem.Allocator.Error!void { +/// The context use for free var generation +const GenTypeAnnoCtx = union(enum) { + annotation, + type_decl: struct { + idx: CIR.Statement.Idx, + name: Ident.Idx, + type_: enum { nominal, alias }, + backing_var: Var, + num_args: u32, + }, +}; + +/// Given an annotation, generate the corresponding type based on the CIR +/// +/// This function will write the type into the type var node at `anno_idx` +fn generateAnnoTypeInPlace(self: *Self, anno_idx: CIR.TypeAnno.Idx, ctx: GenTypeAnnoCtx) std.mem.Allocator.Error!void { const trace = tracy.trace(@src()); defer trace.end(); + // First, check if we've seen this anno before + // This guards against recursive types + if (self.seen_annos.get(anno_idx)) |_| { + return; + } + + // Get the annotation const anno = self.cir.store.getTypeAnno(anno_idx); - const anno_var = ModuleEnv.varFrom(anno_idx); const anno_region = self.cir.store.getNodeRegion(ModuleEnv.nodeIdxFrom(anno_idx)); + const anno_var = ModuleEnv.varFrom(anno_idx); + + // Put this anno in the "seen" map immediately, to support recursive references + try self.seen_annos.put(anno_idx, anno_var); switch (anno) { - .ty_lookup_external => |a| { - const resolved_external = try self.resolveVarFromExternal(a.module_idx, a.target_node_idx) orelse { - // If we could not copy the type, set error and continue - try self.types.setVarContent(ModuleEnv.varFrom(anno_idx), .err); - return; - }; + .rigid_var => |rigid| { + try self.updateVar(anno_var, .{ .rigid = Rigid.init(rigid.name) }, Rank.generalized); + }, + .rigid_var_lookup => |rigid_lookup| { + try self.types.setVarRedirect(anno_var, ModuleEnv.varFrom(rigid_lookup.ref)); + }, + .underscore => { + try self.updateVar(anno_var, .{ .flex = Flex.init() }, Rank.generalized); + }, + .lookup => |lookup| { + switch (lookup.base) { + .builtin => |builtin_type| { + // TODO: Don't generate a new type var here, reuse anno var + const builtin_var = try self.generateBuiltinTypeInstance(lookup.name, builtin_type, &.{}, anno_region); + try self.types.setVarRedirect(anno_var, builtin_var); + }, + .local => |local| { + // Check if we're in a declaration or an annotation + switch (ctx) { + .type_decl => |this_decl| { + // If so, check if this is a recursive reference + if (this_decl.idx == local.decl_idx) { - self.annotation_rigid_var_subs.items.clearRetainingCapacity(); - const instantatied_var = try self.instantiateVar( - resolved_external.local_var, - &self.annotation_rigid_var_subs, - .{ .explicit = anno_region }, - ); - try self.types.setVarRedirect(anno_var, instantatied_var); + // If it is a recursive ref, check that there are + // no arguments (since this is a lookup, not an apply) + if (this_decl.num_args != 0) { + _ = try self.problems.appendProblem(self.gpa, .{ .type_apply_mismatch_arities = .{ + .type_name = this_decl.name, + .region = anno_region, + .num_expected_args = 0, + .num_actual_args = this_decl.num_args, + } }); + try self.updateVar(anno_var, .err, Rank.generalized); + return; + } + + // If so, then update this annotation to be an instance + // of this type using the same backing variable + try self.updateVar(anno_var, blk: { + switch (this_decl.type_) { + .alias => { + break :blk try self.types.mkAlias( + .{ .ident_idx = this_decl.name }, + this_decl.backing_var, + &.{}, + ); + }, + .nominal => { + break :blk try self.types.mkNominal( + .{ .ident_idx = this_decl.name }, + this_decl.backing_var, + &.{}, + self.common_idents.module_name, + ); + }, + } + }, Rank.generalized); + + return; + } + }, + .annotation => { + // Otherwise, we're in an annotation and this cannot + // be recursive + }, + } + + const instantiated_var = try self.instantiateVar( + ModuleEnv.varFrom(local.decl_idx), + Rank.generalized, + .{ .explicit = anno_region }, + ); + try self.types.setVarRedirect(anno_var, instantiated_var); + }, + .external => |ext| { + if (try self.resolveVarFromExternal(ext.module_idx, ext.target_node_idx)) |ext_ref| { + const ext_instantiated_var = try self.instantiateVar( + ext_ref.local_var, + Rank.generalized, + .{ .explicit = anno_region }, + ); + try self.types.setVarRedirect(anno_var, ext_instantiated_var); + } else { + // If this external type is unresolved, can should've reported + // an error. So we set to error and continue + try self.updateVar(anno_var, .err, Rank.generalized); + } + }, + } }, .apply => |a| { - // For apply annotation, the root anno's var is intitally set to be - // a redirect to backing type declaration. - try self.checkApplyAnno(anno_var, anno_region, a.args); - }, - .apply_external => |a| { - const resolved_external = try self.resolveVarFromExternal(a.module_idx, a.target_node_idx) orelse { - // If we could not copy the type, set error and continue - try self.types.setVarContent(ModuleEnv.varFrom(anno_idx), .err); - return; - }; + // Generate the types for the arguments + const anno_args = self.cir.store.sliceTypeAnnos(a.args); + for (anno_args) |anno_arg| { + try self.generateAnnoTypeInPlace(anno_arg, ctx); + } + const anno_arg_vars: []Var = @ptrCast(anno_args); - try self.checkApplyAnno(resolved_external.local_var, anno_region, a.args); - }, - .tag_union => |tag_union| { - const args_anno_slice = self.cir.store.sliceTypeAnnos(tag_union.tags); - for (args_anno_slice) |arg_anno_idx| { - try self.checkAnnotation(arg_anno_idx); - } - }, - .tuple => |tuple| { - const args_anno_slice = self.cir.store.sliceTypeAnnos(tuple.elems); - for (args_anno_slice) |arg_anno_idx| { - try self.checkAnnotation(arg_anno_idx); - } - }, - .record => |rec| { - const recs_anno_slice = self.cir.store.sliceAnnoRecordFields(rec.fields); - for (recs_anno_slice) |rec_anno_idx| { - const rec_field = self.cir.store.getAnnoRecordField(rec_anno_idx); - try self.checkAnnotation(rec_field.ty); + switch (a.base) { + .builtin => |builtin_type| { + // TODO: Don't generate a new type var here, reuse anno var + const builtin_var = try self.generateBuiltinTypeInstance(a.name, builtin_type, anno_arg_vars, anno_region); + try self.types.setVarRedirect(anno_var, builtin_var); + }, + .local => |local| { + // Check if we're in a declaration or an annotation + switch (ctx) { + .type_decl => |this_decl| { + // If so, check if this is a recursive reference + if (this_decl.idx == local.decl_idx) { + + // If it is a recursive ref, check that the args being + // applied here match the number of args of the decl + if (anno_arg_vars.len != this_decl.num_args) { + _ = try self.problems.appendProblem(self.gpa, .{ .type_apply_mismatch_arities = .{ + .type_name = this_decl.name, + .region = anno_region, + .num_expected_args = this_decl.num_args, + .num_actual_args = @intCast(anno_args.len), + } }); + try self.updateVar(anno_var, .err, Rank.generalized); + return; + } + + // If so, then update this annotation to be an instance + // of this type using the same backing variable + try self.updateVar(anno_var, blk: { + switch (this_decl.type_) { + .alias => { + break :blk try self.types.mkAlias( + .{ .ident_idx = this_decl.name }, + this_decl.backing_var, + anno_arg_vars, + ); + }, + .nominal => { + break :blk try self.types.mkNominal( + .{ .ident_idx = this_decl.name }, + this_decl.backing_var, + anno_arg_vars, + self.common_idents.module_name, + ); + }, + } + }, Rank.generalized); + + return; + } + }, + .annotation => { + // Otherwise, we're in an annotation and this cannot + // be recursive + }, + } + + // Resolve the referenced type + const decl_var = ModuleEnv.varFrom(local.decl_idx); + const decl_resolved = self.types.resolveVar(decl_var).desc.content; + + // Get the arguments & name the referenced type + const decl_arg_vars, const decl_name = blk: { + if (decl_resolved == .alias) { + const decl_alias = decl_resolved.alias; + break :blk .{ self.types.sliceAliasArgs(decl_alias), decl_alias.ident.ident_idx }; + } else if (decl_resolved == .structure and decl_resolved.structure == .nominal_type) { + const decl_nominal = decl_resolved.structure.nominal_type; + break :blk .{ self.types.sliceNominalArgs(decl_nominal), decl_nominal.ident.ident_idx }; + } else if (decl_resolved == .err) { + try self.updateVar(anno_var, .err, Rank.generalized); + return; + } else { + std.debug.assert(false); + try self.updateVar(anno_var, .err, Rank.generalized); + return; + } + }; + + // Check for an arity mismatch + if (decl_arg_vars.len != anno_arg_vars.len) { + _ = try self.problems.appendProblem(self.gpa, .{ .type_apply_mismatch_arities = .{ + .type_name = decl_name, + .region = anno_region, + .num_expected_args = @intCast(decl_arg_vars.len), + .num_actual_args = @intCast(anno_args.len), + } }); + try self.updateVar(anno_var, .err, Rank.generalized); + return; + } + + // Then, built the map of applied variables + self.rigid_var_substitutions.clearRetainingCapacity(); + for (decl_arg_vars, anno_arg_vars) |decl_arg_var, anno_arg_var| { + const decl_arg_resolved = self.types.resolveVar(decl_arg_var).desc.content; + + std.debug.assert(decl_arg_resolved == .rigid); + const decl_arg_rigid = decl_arg_resolved.rigid; + + try self.rigid_var_substitutions.put(self.gpa, decl_arg_rigid.name, anno_arg_var); + } + + // Then instantiate the variable, substituting the rigid + // variables in the definition with the applied args from + // the annotation + const instantiated_var = try self.instantiateVarWithSubs( + decl_var, + &self.rigid_var_substitutions, + Rank.generalized, + .{ .explicit = anno_region }, + ); + try self.types.setVarRedirect(anno_var, instantiated_var); + }, + .external => |ext| { + if (try self.resolveVarFromExternal(ext.module_idx, ext.target_node_idx)) |ext_ref| { + // Resolve the referenced type + const ext_resolved = self.types.resolveVar(ext_ref.local_var).desc.content; + + // Get the arguments & name the referenced type + const ext_arg_vars, const ext_name = blk: { + if (ext_resolved == .alias) { + const decl_alias = ext_resolved.alias; + break :blk .{ self.types.sliceAliasArgs(decl_alias), decl_alias.ident.ident_idx }; + } else if (ext_resolved == .structure and ext_resolved.structure == .nominal_type) { + const decl_nominal = ext_resolved.structure.nominal_type; + break :blk .{ self.types.sliceNominalArgs(decl_nominal), decl_nominal.ident.ident_idx }; + } else if (ext_resolved == .err) { + try self.updateVar(anno_var, .err, Rank.generalized); + return; + } else { + std.debug.assert(false); + try self.updateVar(anno_var, .err, Rank.generalized); + return; + } + }; + + // Check for an arity mismatch + if (ext_arg_vars.len != anno_arg_vars.len) { + _ = try self.problems.appendProblem(self.gpa, .{ .type_apply_mismatch_arities = .{ + .type_name = ext_name, + .region = anno_region, + .num_expected_args = @intCast(ext_arg_vars.len), + .num_actual_args = @intCast(anno_args.len), + } }); + try self.updateVar(anno_var, .err, Rank.generalized); + return; + } + + // Then, built the map of applied variables + self.rigid_var_substitutions.clearRetainingCapacity(); + for (ext_arg_vars, anno_arg_vars) |decl_arg_var, anno_arg_var| { + const decl_arg_resolved = self.types.resolveVar(decl_arg_var).desc.content; + + std.debug.assert(decl_arg_resolved == .rigid); + const decl_arg_rigid = decl_arg_resolved.rigid; + + try self.rigid_var_substitutions.put(self.gpa, decl_arg_rigid.name, anno_arg_var); + } + + // Then instantiate the variable, substituting the rigid + // variables in the definition with the applied args from + // the annotation + const instantiated_var = try self.instantiateVarWithSubs( + ext_ref.local_var, + &self.rigid_var_substitutions, + Rank.generalized, + .{ .explicit = anno_region }, + ); + try self.types.setVarRedirect(anno_var, instantiated_var); + } else { + // If this external type is unresolved, can should've reported + // an error. So we set to error and continue + try self.updateVar(anno_var, .err, Rank.generalized); + } + }, } }, .@"fn" => |func| { const args_anno_slice = self.cir.store.sliceTypeAnnos(func.args); for (args_anno_slice) |arg_anno_idx| { - try self.checkAnnotation(arg_anno_idx); + try self.generateAnnoTypeInPlace(arg_anno_idx, ctx); } - try self.checkAnnotation(func.ret); + const args_var_slice: []Var = @ptrCast(args_anno_slice); + + try self.generateAnnoTypeInPlace(func.ret, ctx); + + const fn_type = inner_blk: { + if (func.effectful) { + break :inner_blk try self.types.mkFuncEffectful(args_var_slice, ModuleEnv.varFrom(func.ret)); + } else { + break :inner_blk try self.types.mkFuncPure(args_var_slice, ModuleEnv.varFrom(func.ret)); + } + }; + try self.updateVar(anno_var, fn_type, Rank.generalized); + }, + .tag_union => |tag_union| { + const scratch_tags_top = self.scratch_tags.top(); + defer self.scratch_tags.clearFrom(scratch_tags_top); + + const tag_anno_slices = self.cir.store.sliceTypeAnnos(tag_union.tags); + for (tag_anno_slices) |tag_anno_idx| { + // Get the tag anno + const tag_type_anno = self.cir.store.getTypeAnno(tag_anno_idx); + + // If the child of the tag union is not a tag, then set as error + // Canonicalization should have reported this error + if (tag_type_anno != .tag) { + try self.updateVar(anno_var, .err, Rank.generalized); + return; + } + const tag = tag_type_anno.tag; + + // Generate the types for each tag arg + const tag_anno_args_slice = self.cir.store.sliceTypeAnnos(tag.args); + for (tag_anno_args_slice) |tag_arg_idx| { + try self.generateAnnoTypeInPlace(tag_arg_idx, ctx); + } + const tag_vars_slice: []Var = @ptrCast(tag_anno_args_slice); + + // Add the processed tag to scratch + try self.scratch_tags.append(self.gpa, try self.types.mkTag( + tag.name, + tag_vars_slice, + )); + } + + // Get the slice of tags + const tags_slice = self.scratch_tags.sliceFromStart(scratch_tags_top); + std.mem.sort(types_mod.Tag, tags_slice, self.cir.common.getIdentStore(), comptime types_mod.Tag.sortByNameAsc); + + // Process the ext if it exists. Absence means it's a closed union + const ext_var = inner_blk: { + if (tag_union.ext) |ext_anno_idx| { + try self.generateAnnoTypeInPlace(ext_anno_idx, ctx); + break :inner_blk ModuleEnv.varFrom(ext_anno_idx); + } else { + break :inner_blk try self.freshFromContent(.{ .structure = .empty_tag_union }, Rank.generalized, anno_region); + } + }; + + // Set the anno's type + try self.updateVar(anno_var, try self.types.mkTagUnion(tags_slice, ext_var), Rank.generalized); + }, + .tag => { + // This indicates a malformed type annotation. Tags should only + // exist as direct children of tag_unions + std.debug.assert(false); + try self.updateVar(anno_var, .err, Rank.generalized); + }, + .record => |rec| { + const scratch_record_fields_top = self.scratch_record_fields.top(); + defer self.scratch_record_fields.clearFrom(scratch_record_fields_top); + + const recs_anno_slice = self.cir.store.sliceAnnoRecordFields(rec.fields); + + for (recs_anno_slice) |rec_anno_idx| { + const rec_field = self.cir.store.getAnnoRecordField(rec_anno_idx); + + try self.generateAnnoTypeInPlace(rec_field.ty, ctx); + const record_field_var = ModuleEnv.varFrom(rec_field.ty); + + // Add the processed tag to scratch + try self.scratch_record_fields.append(self.gpa, types_mod.RecordField{ + .name = rec_field.name, + .var_ = record_field_var, + }); + } + + // Get the slice of record_fields + const record_fields_slice = self.scratch_record_fields.sliceFromStart(scratch_record_fields_top); + std.mem.sort(types_mod.RecordField, record_fields_slice, self.cir.common.getIdentStore(), comptime types_mod.RecordField.sortByNameAsc); + const fields_type_range = try self.types.appendRecordFields(record_fields_slice); + + // Process the ext if it exists. Absence means it's a closed union + // TODO: Capture ext in record field CIR + // const ext_var = inner_blk: { + // if (rec.ext) |ext_anno_idx| { + // try self.generateAnnoType(rigid_vars_ctx, ext_anno_idx); + // break :inner_blk ModuleEnv.varFrom(ext_anno_idx); + // } else { + // break :inner_blk try self.freshFromContent(.{ .structure = .empty_record }, Rank.generalized, anno_region); + // } + // }; + const ext_var = try self.freshFromContent(.{ .structure = .empty_record }, Rank.generalized, anno_region); + + // Create the type for the anno in the store + try self.updateVar( + anno_var, + .{ .structure = types_mod.FlatType{ .record = .{ + .fields = fields_type_range, + .ext = ext_var, + } } }, + Rank.generalized, + ); + }, + .tuple => |tuple| { + const elems_anno_slice = self.cir.store.sliceTypeAnnos(tuple.elems); + for (elems_anno_slice) |arg_anno_idx| { + try self.generateAnnoTypeInPlace(arg_anno_idx, ctx); + } + const elems_range = try self.types.appendVars(@ptrCast(elems_anno_slice)); + try self.updateVar(anno_var, .{ .structure = .{ .tuple = .{ .elems = elems_range } } }, Rank.generalized); }, .parens => |parens| { - try self.checkAnnotation(parens.anno); + try self.generateAnnoTypeInPlace(parens.anno, ctx); + try self.types.setVarRedirect(anno_var, ModuleEnv.varFrom(parens.anno)); + }, + .malformed => { + try self.updateVar(anno_var, .err, Rank.generalized); }, - else => {}, } } -/// Check and process a type application annotation (e.g., Maybe(x), List(String)). +/// Generate a type variable from the builtin /// -/// This function handles annotations where a polymorphic type is applied with specific -/// type arguments. It creates a mapping from the type definition's rigid variables -/// to the annotation's rigid variables, preserving rigid constraints. -/// -/// Example: -/// Type definition: Maybe(a) := [Some(a), None] -/// Annotation: Maybe(x) -/// Result: Creates mapping a[rigid] → x[rigid], then applies it -/// to get [Some(x[rigid]), None] where x stays rigid -/// -/// Parameters: -/// * `anno_var` - Variable for the annotation (initially points to the type definition) -/// * `anno_region` - Source region for error reporting -/// * `anno_args_span` - The type arguments in the annotation (e.g., 'x' in Maybe(x)) -pub fn checkApplyAnno( +/// Writes the resulting type into the slot at `ret_var` +fn generateBuiltinTypeInstance( self: *Self, - anno_var: Var, + anno_builtin_name: Ident.Idx, + anno_builtin_type: CIR.TypeAnno.Builtin, + anno_args: []Var, anno_region: Region, - anno_args_span: CIR.TypeAnno.Span, -) std.mem.Allocator.Error!void { - // Clear any previous rigid variable mappings - self.annotation_rigid_var_subs.items.clearRetainingCapacity(); +) std.mem.Allocator.Error!Var { + switch (anno_builtin_type) { + .str => return try self.freshFromContent(.{ .structure = .str }, Rank.generalized, anno_region), + .u8 => return try self.freshFromContent(.{ .structure = .{ .num = types_mod.Num.int_u8 } }, Rank.generalized, anno_region), + .u16 => return try self.freshFromContent(.{ .structure = .{ .num = types_mod.Num.int_u16 } }, Rank.generalized, anno_region), + .u32 => return try self.freshFromContent(.{ .structure = .{ .num = types_mod.Num.int_u32 } }, Rank.generalized, anno_region), + .u64 => return try self.freshFromContent(.{ .structure = .{ .num = types_mod.Num.int_u64 } }, Rank.generalized, anno_region), + .u128 => return try self.freshFromContent(.{ .structure = .{ .num = types_mod.Num.int_u128 } }, Rank.generalized, anno_region), + .i8 => return try self.freshFromContent(.{ .structure = .{ .num = types_mod.Num.int_i8 } }, Rank.generalized, anno_region), + .i16 => return try self.freshFromContent(.{ .structure = .{ .num = types_mod.Num.int_i16 } }, Rank.generalized, anno_region), + .i32 => return try self.freshFromContent(.{ .structure = .{ .num = types_mod.Num.int_i32 } }, Rank.generalized, anno_region), + .i64 => return try self.freshFromContent(.{ .structure = .{ .num = types_mod.Num.int_i64 } }, Rank.generalized, anno_region), + .i128 => return try self.freshFromContent(.{ .structure = .{ .num = types_mod.Num.int_i128 } }, Rank.generalized, anno_region), + .f32 => return try self.freshFromContent(.{ .structure = .{ .num = types_mod.Num.frac_f32 } }, Rank.generalized, anno_region), + .f64 => return try self.freshFromContent(.{ .structure = .{ .num = types_mod.Num.frac_f64 } }, Rank.generalized, anno_region), + .dec => return try self.freshFromContent(.{ .structure = .{ .num = types_mod.Num.frac_dec } }, Rank.generalized, anno_region), + .list => { + // Then check arity + if (anno_args.len != 1) { + _ = try self.problems.appendProblem(self.gpa, .{ .type_apply_mismatch_arities = .{ + .type_name = anno_builtin_name, + .region = anno_region, + .num_expected_args = 1, + .num_actual_args = @intCast(anno_args.len), + } }); - // Get the base type definition that this annotation references - const type_base = self.types.resolveVar(anno_var).desc.content; + // Set error and return + return try self.freshFromContent(.err, Rank.generalized, anno_region); + } - const anno_args = self.cir.store.sliceTypeAnnos(anno_args_span); - - switch (type_base) { - .alias => |alias| { - const base_arg_vars = self.types.sliceAliasArgs(alias); - try self.buildRigidVarMapping(alias.ident.ident_idx, base_arg_vars, anno_args, anno_var); + // Create the type + return try self.freshFromContent(.{ .structure = .{ .list = anno_args[0] } }, Rank.generalized, anno_region); }, - .structure => |flat_type| switch (flat_type) { - .nominal_type => |nominal| { - const base_arg_vars = self.types.sliceNominalArgs(nominal); - try self.buildRigidVarMapping(nominal.ident.ident_idx, base_arg_vars, anno_args, anno_var); - }, - else => { - // Do we need to handle cases like `List` or `Box` here? They - // have args, but it depends how they're added to scope in - // canonicalize. If they're added as aliases, then we don't, but - // if when we lookup `List` in scope, for example, we use the - // primitive directly, then we do + .box => { + // Then check arity + if (anno_args.len != 1) { + _ = try self.problems.appendProblem(self.gpa, .{ .type_apply_mismatch_arities = .{ + .type_name = anno_builtin_name, + .region = anno_region, + .num_expected_args = 1, + .num_actual_args = @intCast(anno_args.len), + } }); - }, + // Set error and return + return try self.freshFromContent(.err, Rank.generalized, anno_region); + } + + // Create the type + return try self.freshFromContent(.{ .structure = .{ .box = anno_args[0] } }, Rank.generalized, anno_region); }, - else => { - // Non-parameterized types don't need rigid variable mapping + .num => { + // Then check arity + if (anno_args.len != 1) { + _ = try self.problems.appendProblem(self.gpa, .{ .type_apply_mismatch_arities = .{ + .type_name = anno_builtin_name, + .region = anno_region, + .num_expected_args = 1, + .num_actual_args = @intCast(anno_args.len), + } }); + + // Set error and return + return try self.freshFromContent(.err, Rank.generalized, anno_region); + } + + // Create the type + return try self.freshFromContent(.{ .structure = .{ + .num = .{ .num_poly = anno_args[0] }, + } }, Rank.generalized, anno_region); }, - } + .frac => { + // Then check arity + if (anno_args.len != 1) { + _ = try self.problems.appendProblem(self.gpa, .{ .type_apply_mismatch_arities = .{ + .type_name = anno_builtin_name, + .region = anno_region, + .num_expected_args = 1, + .num_actual_args = @intCast(anno_args.len), + } }); - // Apply the rigid variable substitution to the type definition - // This converts the base type (e.g., Maybe(a)) to use the annotation's - // rigid variables (e.g., Maybe(x)) while preserving rigidity - const instantiated_var = try self.instantiateVar( - anno_var, - &self.annotation_rigid_var_subs, - .{ .explicit = anno_region }, - ); + // Set error and return + return try self.freshFromContent(.err, Rank.generalized, anno_region); + } - // Redirect the annotation variable to point to the substituted type - try self.types.setVarRedirect(anno_var, instantiated_var); -} + // Create the type + const frac_var = try self.freshFromContent(.{ .structure = .{ .num = .{ + .frac_unbound = Num.FracRequirements.init(), + } } }, Rank.generalized, anno_region); + return try self.freshFromContent(.{ .structure = .{ .num = .{ + .num_poly = frac_var, + } } }, Rank.generalized, anno_region); + }, + .int => { + // Then check arity + if (anno_args.len != 1) { + _ = try self.problems.appendProblem(self.gpa, .{ .type_apply_mismatch_arities = .{ + .type_name = anno_builtin_name, + .region = anno_region, + .num_expected_args = 1, + .num_actual_args = @intCast(anno_args.len), + } }); -/// Build the mapping from base type rigid variables to annotation rigid variables -/// -/// For each parameter in the base type definition, if it's a rigid variable, -/// map it to the corresponding argument in the annotation. -/// -/// Example: Maybe(a) + annotation args [x] → mapping["a"] = x[rigid] -fn buildRigidVarMapping( - self: *Self, - base_name: Ident.Idx, - base_arg_vars: []const types_mod.Var, - anno_args: []const CIR.TypeAnno.Idx, - anno_var: types_mod.Var, -) std.mem.Allocator.Error!void { - // Ensure we have the same number of parameters and arguments - if (base_arg_vars.len != anno_args.len) { - _ = try self.problems.appendProblem(self.gpa, .{ .type_apply_mismatch_arities = .{ - .type_name = base_name, - .anno_var = anno_var, - .num_expected_args = @intCast(base_arg_vars.len), - .num_actual_args = @intCast(anno_args.len), - } }); - // Base type parameter is in error state - propagate error - try self.types.setVarContent(anno_var, .err); - return; - } + // Set error and return + return try self.freshFromContent(.err, Rank.generalized, anno_region); + } - for (base_arg_vars, anno_args) |base_arg_var, anno_arg_idx| { - const base_arg_resolved = self.types.resolveVar(base_arg_var).desc.content; - - switch (base_arg_resolved) { - .rigid_var => |ident| { - // Found a rigid variable in the base type - map it to the annotation argument - const ident_text = self.cir.getIdent(ident); - - const anno_arg_var = ModuleEnv.varFrom(anno_arg_idx); - const anno_arg_var_inst = try self.instantiateVar(anno_arg_var, &self.annotation_rigid_var_subs, .use_last_var); - - try self.annotation_rigid_var_subs.append(self.gpa, .{ - .ident = ident_text, - .var_ = anno_arg_var_inst, - }); - }, - .err => { - // Base type parameter is in error state - propagate error - try self.types.setVarContent(anno_var, .err); - return; - }, - else => { - // Base type parameter is not a rigid variable (unexpected) - // This should only happen for rigid variables in well-formed type definitions - std.debug.assert(base_arg_resolved != .flex_var); - }, - } + // Create the type + const int_var = try self.freshFromContent(.{ .structure = .{ .num = .{ + .int_unbound = Num.IntRequirements.init(), + } } }, Rank.generalized, anno_region); + return try self.freshFromContent(.{ .structure = .{ .num = .{ + .num_poly = int_var, + } } }, Rank.generalized, anno_region); + }, } } // pattern // /// Check the types for the provided pattern -pub fn checkPattern(self: *Self, pattern_idx: CIR.Pattern.Idx) std.mem.Allocator.Error!void { +fn checkPattern(self: *Self, pattern_idx: CIR.Pattern.Idx, rank: types_mod.Rank, expected: Expected) std.mem.Allocator.Error!void { const trace = tracy.trace(@src()); defer trace.end(); const pattern = self.cir.store.getPattern(pattern_idx); const pattern_region = self.cir.store.getNodeRegion(ModuleEnv.nodeIdxFrom(pattern_idx)); + const pattern_var = ModuleEnv.varFrom(pattern_idx); + switch (pattern) { - .nominal => |p| { - const real_nominal_var = ModuleEnv.varFrom(p.nominal_type_decl); - const pattern_backing_var = ModuleEnv.varFrom(p.backing_pattern); - try self.checkNominal( - ModuleEnv.varFrom(pattern_idx), - pattern_region, - pattern_backing_var, - p.backing_type, - real_nominal_var, - ); + .assign => |_| { + // In the case of an assigned variable, set it to be a flex var initially. + // This will be refined based on how it's used. + try self.updateVar(pattern_var, .{ .flex = Flex.init() }, rank); }, - .nominal_external => |p| { - const resolved_external = try self.resolveVarFromExternal(p.module_idx, p.target_node_idx) orelse { - // If we could not copy the type, set error and continue - try self.types.setVarContent(ModuleEnv.varFrom(pattern_idx), .err); - return; - }; - const pattern_backing_var = ModuleEnv.varFrom(p.backing_pattern); - try self.checkNominal( - ModuleEnv.varFrom(pattern_idx), - pattern_region, - pattern_backing_var, - p.backing_type, - resolved_external.local_var, - ); + .underscore => |_| { + // Underscore can be anything + try self.updateVar(pattern_var, .{ .flex = Flex.init() }, rank); }, - .int_literal => |_| { - // Integer literal patterns have their type constraints (bits_needed, sign_needed) - // created during canonicalization. The type variable for this pattern was already - // created with the appropriate num_unbound or int_unbound content. - // When this pattern is unified with the match scrutinee, the numeric constraints - // will be checked and produce NumberDoesNotFit or NegativeUnsignedInt errors - // if there's a mismatch. + // str // + .str_literal => { + try self.updateVar(pattern_var, .{ .structure = .str }, rank); }, + // as // .as => |p| { - try self.checkPattern(p.pattern); + try self.checkPattern(p.pattern, rank, expected); }, - .applied_tag => |p| { - const args_slice = self.cir.store.slicePatterns(p.args); - for (args_slice) |pat_idx| { - try self.checkPattern(pat_idx); + // tuple // + .tuple => |tuple| { + // Check tuple elements + const elems_slice = self.cir.store.slicePatterns(tuple.patterns); + for (elems_slice) |single_elem_ptrn_idx| { + try self.checkPattern(single_elem_ptrn_idx, rank, .no_expectation); + } + + // Cast the elems idxs to vars (this works because Anno Idx are 1-1 with type Vars) + const elem_vars_slice = try self.types.appendVars(@ptrCast(elems_slice)); + + // Set the type in the store + try self.updateVar(pattern_var, .{ .structure = .{ + .tuple = .{ .elems = elem_vars_slice }, + } }, rank); + }, + // list // + .list => |list| { + const elems = self.cir.store.slicePatterns(list.patterns); + if (elems.len == 0) { + // If we have no elems, then set the type and move on + try self.updateVar(pattern_var, .{ .structure = .list_unbound }, rank); + } else { + // Here, we use the list's 1st element as the element var to + // constrain the rest of the list + + // Check the first elem + try self.checkPattern(elems[0], rank, .no_expectation); + + // Iterate over the remaining elements + const elem_var = ModuleEnv.varFrom(elems[0]); + var last_elem_ptrn_idx = elems[0]; + for (elems[1..], 1..) |elem_ptrn_idx, i| { + try self.checkPattern(elem_ptrn_idx, rank, .no_expectation); + const cur_elem_var = ModuleEnv.varFrom(elem_ptrn_idx); + + // Unify each element's var with the list's elem var + const result = try self.unify(elem_var, cur_elem_var, rank); + self.setDetailIfTypeMismatch(result, problem.TypeMismatchDetail{ .incompatible_list_elements = .{ + .last_elem_idx = ModuleEnv.nodeIdxFrom(last_elem_ptrn_idx), + .incompatible_elem_index = @intCast(i), + .list_length = @intCast(elems.len), + } }); + + // If we errored, check the rest of the elements without comparing + // to the elem_var to catch their individual errors + if (!result.isOk()) { + for (elems[i + 1 ..]) |remaining_elem_expr_idx| { + try self.checkPattern(remaining_elem_expr_idx, rank, .no_expectation); + } + + // Break to avoid cascading errors + break; + } + + last_elem_ptrn_idx = elem_ptrn_idx; + } + + // Now, set the type of the root variable t + try self.updateVar(pattern_var, .{ .structure = .{ .list = elem_var } }, rank); + + // Then, check the "rest" pattern is bound to a variable + // This is if the pattern is like `.. as x` + if (list.rest_info) |rest_info| { + if (rest_info.pattern) |rest_pattern_idx| { + try self.checkPattern(rest_pattern_idx, rank, .no_expectation); + const rest_pattern_var = ModuleEnv.varFrom(rest_pattern_idx); + + _ = try self.unify(pattern_var, rest_pattern_var, rank); + } + } } }, - .tuple => |p| { - const args_slice = self.cir.store.slicePatterns(p.patterns); - for (args_slice) |pat_idx| { - try self.checkPattern(pat_idx); + // applied tag // + .applied_tag => |applied_tag| { + // Create a tag type in the type system and assign it the expr_var + + // Process each tag arg + const arg_ptrn_idx_slice = self.cir.store.slicePatterns(applied_tag.args); + for (arg_ptrn_idx_slice) |arg_expr_idx| { + try self.checkPattern(arg_expr_idx, rank, .no_expectation); + } + + // Create the type + const ext_var = try self.fresh(rank, pattern_region); + try self.var_pool.addVarToRank(ext_var, rank); + + const tag = try self.types.mkTag(applied_tag.name, @ptrCast(arg_ptrn_idx_slice)); + const tag_union_content = try self.types.mkTagUnion(&[_]types_mod.Tag{tag}, ext_var); + + // Update the expr to point to the new type + try self.updateVar(pattern_var, tag_union_content, rank); + }, + // nominal // + .nominal => |nominal| { + // TODO: Merge this with e_nominal_external + + // First, check the type inside the expr + try self.checkPattern(nominal.backing_pattern, rank, .no_expectation); + const actual_backing_var = ModuleEnv.varFrom(nominal.backing_pattern); + + // Then, we need an instance of the nominal type being referenced + // E.g. ConList.Cons(...) + // ^^^^^^^ + const nominal_var = try self.instantiateVar(ModuleEnv.varFrom(nominal.nominal_type_decl), rank, .{ .explicit = pattern_region }); + const nominal_resolved = self.types.resolveVar(nominal_var).desc.content; + + if (nominal_resolved == .structure and nominal_resolved.structure == .nominal_type) { + // Then, we extract the variable of the nominal type + // E.g. ConList(a) := [Cons(a, ConstList), Nil] + // ^^^^^^^^^^^^^^^^^^^^^^^^^ + const nominal_backing_var = self.types.getNominalBackingVar(nominal_resolved.structure.nominal_type); + + // Now we unify what the user wrote with the backing type of the nominal was + // E.g. ConList.Cons(...) <-> [Cons(a, ConsList(a)), Nil] + // ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ + const result = try self.unify(nominal_backing_var, actual_backing_var, rank); + + // Then, we handle the result of unification + switch (result) { + .ok => { + // If that unify call succeeded, then we this is a valid instance + // of this nominal type. So we set the expr's type to be the + // nominal type + try self.types.setVarRedirect(pattern_var, nominal_var); + }, + .problem => |problem_idx| { + // Unification failed - the constructor is incompatible with the nominal type + // Set a specific error message based on the backing type kind + switch (nominal.backing_type) { + .tag => { + // Constructor doesn't exist or has wrong arity/types + self.setProblemTypeMismatchDetail(problem_idx, .invalid_nominal_tag); + }, + else => { + // TODO: Add specific error messages for records, tuples, etc. + }, + } + + // Mark the entire expression as having a type error + try self.updateVar(pattern_var, .err, rank); + }, + } + } else { + // If the nominal type is actually something else, then set the + // whole expression to be an error. + // + // TODO: Report a nice problem here + try self.updateVar(pattern_var, .err, rank); } }, - .record_destructure => |p| { - const destructs_slice = self.cir.store.sliceRecordDestructs(p.destructs); - for (destructs_slice) |destruct_idx| { + .nominal_external => |nominal| { + // TODO: Merge this with e_nominal + + // First, check the type inside the expr + try self.checkPattern(nominal.backing_pattern, rank, .no_expectation); + const actual_backing_var = ModuleEnv.varFrom(nominal.backing_pattern); + + if (try self.resolveVarFromExternal(nominal.module_idx, nominal.target_node_idx)) |ext_ref| { + // Then, we need an instance of the nominal type being referenced + // E.g. ConList.Cons(...) + // ^^^^^^^ + const nominal_var = try self.instantiateVar(ext_ref.local_var, Rank.generalized, .{ .explicit = pattern_region }); + const nominal_resolved = self.types.resolveVar(nominal_var).desc.content; + + if (nominal_resolved == .structure and nominal_resolved.structure == .nominal_type) { + // Then, we extract the variable of the nominal type + // E.g. ConList(a) := [Cons(a, ConstList), Nil] + // ^^^^^^^^^^^^^^^^^^^^^^^^^ + const nominal_backing_var = self.types.getNominalBackingVar(nominal_resolved.structure.nominal_type); + + // Now we unify what the user wrote with the backing type of the nominal was + // E.g. ConList.Cons(...) <-> [Cons(a, ConsList(a)), Nil] + // ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ + const result = try self.unify(nominal_backing_var, actual_backing_var, rank); + + // Then, we handle the result of unification + switch (result) { + .ok => { + // If that unify call succeeded, then we this is a valid instance + // of this nominal type. So we set the expr's type to be the + // nominal type + try self.types.setVarRedirect(pattern_var, nominal_var); + }, + .problem => |problem_idx| { + // Unification failed - the constructor is incompatible with the nominal type + // Set a specific error message based on the backing type kind + switch (nominal.backing_type) { + .tag => { + // Constructor doesn't exist or has wrong arity/types + self.setProblemTypeMismatchDetail(problem_idx, .invalid_nominal_tag); + }, + else => { + // TODO: Add specific error messages for records, tuples, etc. + }, + } + + // Mark the entire expression as having a type error + try self.updateVar(pattern_var, .err, rank); + }, + } + } else { + // If the nominal type is actually something else, then set the + // whole expression to be an error. + // + // TODO: Report a nice problem here + try self.updateVar(pattern_var, .err, rank); + } + } else { + try self.updateVar(pattern_var, .err, rank); + } + }, + // record destructure // + .record_destructure => |destructure| { + const scratch_records_top = self.scratch_record_fields.top(); + defer self.scratch_record_fields.clearFrom(scratch_records_top); + + for (self.cir.store.sliceRecordDestructs(destructure.destructs)) |destruct_idx| { const destruct = self.cir.store.getRecordDestruct(destruct_idx); - try self.checkPattern(destruct.kind.toPatternIdx()); + const destruct_var = ModuleEnv.varFrom(destruct_idx); + + // Check the sub pattern + const field_pattern_idx = blk: { + switch (destruct.kind) { + .Required => |sub_pattern_idx| { + try self.checkPattern(sub_pattern_idx, rank, .no_expectation); + break :blk sub_pattern_idx; + }, + .SubPattern => |sub_pattern_idx| { + try self.checkPattern(sub_pattern_idx, rank, .no_expectation); + break :blk sub_pattern_idx; + }, + } + }; + const field_pattern_var = ModuleEnv.varFrom(field_pattern_idx); + + // Set the destruct var to redirect to the field pattern var + try self.types.setVarRedirect(destruct_var, field_pattern_var); + + // Append it to the scratch records array + try self.scratch_record_fields.append(self.gpa, types_mod.RecordField{ + .name = destruct.label, + .var_ = ModuleEnv.varFrom(destruct_var), + }); + } + + // Copy the scratch record fields into the types store + const record_fields_scratch = self.scratch_record_fields.sliceFromStart(scratch_records_top); + std.mem.sort(types_mod.RecordField, record_fields_scratch, self.cir.getIdentStore(), comptime types_mod.RecordField.sortByNameAsc); + const record_fields_range = try self.types.appendRecordFields(record_fields_scratch); + + // Update the pattern var + try self.updateVar(pattern_var, .{ .structure = .{ + .record_unbound = record_fields_range, + } }, rank); + }, + // nums // + .num_literal => |num| { + const num_type = blk: { + switch (num.kind) { + .num_unbound => { + const int_reqs = num.value.toIntRequirements(); + const frac_reqs = num.value.toFracRequirements(); + break :blk Num{ .num_unbound = .{ .int_requirements = int_reqs, .frac_requirements = frac_reqs } }; + }, + .int_unbound => { + const int_reqs = num.value.toIntRequirements(); + const int_var = try self.freshFromContent(.{ .structure = .{ .num = .{ .int_unbound = int_reqs } } }, rank, pattern_region); + try self.var_pool.addVarToRank(int_var, rank); + break :blk Num{ .num_poly = int_var }; + }, + .u8 => break :blk Num{ .num_compact = Num.Compact{ .int = .u8 } }, + .i8 => break :blk Num{ .num_compact = Num.Compact{ .int = .i8 } }, + .u16 => break :blk Num{ .num_compact = Num.Compact{ .int = .u16 } }, + .i16 => break :blk Num{ .num_compact = Num.Compact{ .int = .i16 } }, + .u32 => break :blk Num{ .num_compact = Num.Compact{ .int = .u32 } }, + .i32 => break :blk Num{ .num_compact = Num.Compact{ .int = .i32 } }, + .u64 => break :blk Num{ .num_compact = Num.Compact{ .int = .u64 } }, + .i64 => break :blk Num{ .num_compact = Num.Compact{ .int = .i64 } }, + .u128 => break :blk Num{ .num_compact = Num.Compact{ .int = .u128 } }, + .i128 => break :blk Num{ .num_compact = Num.Compact{ .int = .i128 } }, + .f32 => break :blk Num{ .num_compact = Num.Compact{ .frac = .f32 } }, + .f64 => break :blk Num{ .num_compact = Num.Compact{ .frac = .f64 } }, + .dec => break :blk Num{ .num_compact = Num.Compact{ .frac = .dec } }, + } + }; + + // Update the pattern var + try self.updateVar(pattern_var, .{ .structure = .{ .num = num_type } }, rank); + }, + .frac_f32_literal => |_| { + try self.updateVar(pattern_var, .{ .structure = .{ .num = .{ .num_compact = .{ .frac = .f32 } } } }, rank); + }, + .frac_f64_literal => |_| { + try self.updateVar(pattern_var, .{ .structure = .{ .num = .{ .num_compact = .{ .frac = .f64 } } } }, rank); + }, + .dec_literal => |dec| { + if (dec.has_suffix) { + try self.updateVar(pattern_var, .{ .structure = .{ .num = .{ .num_compact = .{ .frac = .dec } } } }, rank); + } else { + const f64_val = dec.value.toF64(); + const requirements = types_mod.Num.FracRequirements{ + .fits_in_f32 = can.CIR.fitsInF32(f64_val), + .fits_in_dec = can.CIR.fitsInDec(f64_val), + }; + const frac_var = try self.freshFromContent(.{ .structure = .{ .num = .{ + .frac_unbound = requirements, + } } }, rank, pattern_region); + try self.var_pool.addVarToRank(frac_var, rank); + + try self.updateVar(pattern_var, .{ .structure = .{ .num = .{ + .num_poly = frac_var, + } } }, rank); + } + }, + .small_dec_literal => |dec| { + if (dec.has_suffix) { + try self.updateVar(pattern_var, .{ .structure = .{ .num = .{ .num_compact = .{ .frac = .dec } } } }, rank); + } else { + const reqs = dec.value.toFracRequirements(); + const frac_var = try self.freshFromContent(.{ .structure = .{ .num = .{ + .frac_unbound = reqs, + } } }, rank, pattern_region); + try self.var_pool.addVarToRank(frac_var, rank); + + try self.updateVar(pattern_var, .{ .structure = .{ .num = .{ + .num_poly = frac_var, + } } }, rank); + } + }, + .runtime_error => { + try self.updateVar(pattern_var, .err, rank); + }, + } + + // If we were provided with an expected type, unify against it + switch (expected) { + .no_expectation => {}, + .expected => |expected_type| { + if (expected_type.from_annotation) { + _ = try self.unifyFromAnno(expected_type.var_, pattern_var, rank); + } else { + _ = try self.unify(expected_type.var_, pattern_var, rank); } }, - else => {}, } } // expr // -/// Check the types for an exprexpression. Returns whether evaluating the expr might perform side effects. -pub fn checkExpr(self: *Self, expr_idx: CIR.Expr.Idx) std.mem.Allocator.Error!bool { - return self.checkExprWithExpected(expr_idx, null); -} +const Expected = union(enum) { + no_expectation, + expected: struct { var_: Var, from_annotation: bool }, +}; -/// Check expression with an optional expected type for bidirectional type checking -pub fn checkExprWithExpected(self: *Self, expr_idx: CIR.Expr.Idx, expected_type: ?Var) std.mem.Allocator.Error!bool { - return self.checkExprWithExpectedAndAnnotation(expr_idx, expected_type, false); -} - -fn checkExprWithExpectedAndAnnotation(self: *Self, expr_idx: CIR.Expr.Idx, expected_type: ?Var, from_annotation: bool) std.mem.Allocator.Error!bool { - const does_fx = self.checkExprWithExpectedAndAnnotationHelp(expr_idx, expected_type, from_annotation); - if (expected_type) |expected| { - if (from_annotation) { - _ = try self.unifyWithAnnotation(ModuleEnv.varFrom(expr_idx), expected); - } else { - _ = try self.unify(ModuleEnv.varFrom(expr_idx), expected); - } - } - return does_fx; -} - -/// Do not use directly, use `checkExprWithExpectedAndAnnotation` -/// -/// Checks the types of an expression, optionally against -fn checkExprWithExpectedAndAnnotationHelp(self: *Self, expr_idx: CIR.Expr.Idx, expected_type: ?Var, from_annotation: bool) std.mem.Allocator.Error!bool { +fn checkExpr(self: *Self, expr_idx: CIR.Expr.Idx, rank: types_mod.Rank, expected: Expected) std.mem.Allocator.Error!bool { const trace = tracy.trace(@src()); defer trace.end(); + std.debug.assert(rank == self.var_pool.current_rank); + const expr = self.cir.store.getExpr(expr_idx); const expr_var = ModuleEnv.varFrom(expr_idx); const expr_region = self.cir.store.getNodeRegion(ModuleEnv.nodeIdxFrom(expr_idx)); var does_fx = false; // Does this expression potentially perform any side effects? + switch (expr) { - .e_int => |_| { - // Integer literals have their type constraints (bits_needed, sign_needed) - // created during canonicalization. Here we just need to ensure those - // constraints will be checked when unified with expected types. - // The type variable for this expression was already created with the - // appropriate num_unbound or int_unbound content during canonicalization. + // str // + .e_str_segment => |_| { + try self.updateVar(expr_var, .{ .structure = .str }, rank); + }, + .e_str => |str| { + // Iterate over the string segments, capturing if any error'd + const segment_expr_idx_slice = self.cir.store.sliceExpr(str.span); + var did_err = false; + for (segment_expr_idx_slice) |seg_expr_idx| { + // Check the segment + does_fx = try self.checkExpr(seg_expr_idx, rank, .no_expectation) or does_fx; - // If we have an expected type, unify immediately to constrain the literal - if (expected_type) |expected| { - const literal_var = @as(Var, @enumFromInt(@intFromEnum(expr_idx))); - if (from_annotation) { - _ = try self.unifyWithAnnotation(literal_var, expected); - } else { - _ = try self.unify(literal_var, expected); - } + // Check if it errored + const seg_var = ModuleEnv.varFrom(seg_expr_idx); + did_err = did_err or self.types.resolveVar(seg_var).desc.content == .err; } - }, - .e_frac_f32 => |_| { - // Fractional literals have their type constraints (fits_in_f32, fits_in_dec) - // created during canonicalization. No additional checking needed here. - }, - .e_frac_f64 => |_| { - // Fractional literals have their type constraints (fits_in_f32, fits_in_dec) - // created during canonicalization. No additional checking needed here. - }, - .e_frac_dec => |_| { - // Decimal literals are similar to frac_f64. - }, - .e_dec_small => |_| { - // Small decimal literals are similar to frac_f64. - }, - .e_str_segment => |_| {}, - .e_str => |_| {}, - .e_lookup_local => |local| { - // For lookups, we need to connect the lookup expression to the actual variable - // The lookup expression should have the same type as the pattern it refers to - const lookup_var = @as(Var, @enumFromInt(@intFromEnum(expr_idx))); - const pattern_var = @as(Var, @enumFromInt(@intFromEnum(local.pattern_idx))); - _ = try self.unify(lookup_var, pattern_var); - }, - .e_lookup_external => |e| { - const module_idx = @intFromEnum(e.module_idx); - if (module_idx < self.other_modules.len) { - const other_module_cir = self.other_modules[module_idx]; - const other_module_env = other_module_cir; - - // The idx of the expression in the other module - const target_node_idx = @as(CIR.Node.Idx, @enumFromInt(e.target_node_idx)); - - // Check if we've already copied this import - const cache_key = ImportCacheKey{ - .module_idx = e.module_idx, - .node_idx = target_node_idx, - }; - - const copied_var = if (self.import_cache.get(cache_key)) |cached_var| - // Reuse the previously copied type. - cached_var - else blk: { - // First time importing this type - copy it and cache the result - const imported_var = @as(Var, @enumFromInt(@intFromEnum(target_node_idx))); - const new_copy = try self.copyVar(imported_var, other_module_env); - try self.import_cache.put(self.gpa, cache_key, new_copy); - break :blk new_copy; - }; - const instantiated_copy = try self.instantiateVarAnon(copied_var, .use_last_var); - - // Unify our expression with the copied type - const result = try self.unify(expr_var, instantiated_copy); - if (result.isProblem()) { - self.setProblemTypeMismatchDetail(result.problem, .{ - .cross_module_import = .{ - .import_region = expr_idx, - .module_idx = e.module_idx, - }, - }); - - try self.types.setVarContent(expr_var, .err); - } + if (did_err) { + // If any segment errored, propgate that error to the root string + try self.updateVar(expr_var, .err, rank); } else { - // Import not found - try self.types.setVarContent(expr_var, .err); + // Otherwise, set the type of this expr to be string + try self.updateVar(expr_var, .{ .structure = .str }, rank); } }, + // nums // + .e_num => |num| { + const num_type = blk: { + switch (num.kind) { + .num_unbound => { + const int_reqs = num.value.toIntRequirements(); + const frac_reqs = num.value.toFracRequirements(); + break :blk Num{ .num_unbound = .{ .int_requirements = int_reqs, .frac_requirements = frac_reqs } }; + }, + .int_unbound => { + const int_reqs = num.value.toIntRequirements(); + const int_var = try self.freshFromContent(.{ .structure = .{ .num = .{ .int_unbound = int_reqs } } }, rank, expr_region); + try self.var_pool.addVarToRank(int_var, rank); + break :blk Num{ .num_poly = int_var }; + }, + .u8 => break :blk Num{ .num_compact = Num.Compact{ .int = .u8 } }, + .i8 => break :blk Num{ .num_compact = Num.Compact{ .int = .i8 } }, + .u16 => break :blk Num{ .num_compact = Num.Compact{ .int = .u16 } }, + .i16 => break :blk Num{ .num_compact = Num.Compact{ .int = .i16 } }, + .u32 => break :blk Num{ .num_compact = Num.Compact{ .int = .u32 } }, + .i32 => break :blk Num{ .num_compact = Num.Compact{ .int = .i32 } }, + .u64 => break :blk Num{ .num_compact = Num.Compact{ .int = .u64 } }, + .i64 => break :blk Num{ .num_compact = Num.Compact{ .int = .i64 } }, + .u128 => break :blk Num{ .num_compact = Num.Compact{ .int = .u128 } }, + .i128 => break :blk Num{ .num_compact = Num.Compact{ .int = .i128 } }, + .f32 => break :blk Num{ .num_compact = Num.Compact{ .frac = .f32 } }, + .f64 => break :blk Num{ .num_compact = Num.Compact{ .frac = .f64 } }, + .dec => break :blk Num{ .num_compact = Num.Compact{ .frac = .dec } }, + } + }; + + // Update the pattern var + try self.updateVar(expr_var, .{ .structure = .{ .num = num_type } }, rank); + }, + .e_frac_f32 => |frac| { + if (frac.has_suffix) { + try self.updateVar(expr_var, .{ .structure = .{ .num = .{ .num_compact = .{ .frac = .f32 } } } }, rank); + } else { + const requirements = types_mod.Num.FracRequirements{ + .fits_in_f32 = true, + .fits_in_dec = can.CIR.fitsInDec(@floatCast(frac.value)), + }; + const frac_var = try self.freshFromContent(.{ .structure = .{ .num = .{ + .frac_unbound = requirements, + } } }, rank, expr_region); + try self.var_pool.addVarToRank(frac_var, rank); + + try self.updateVar(expr_var, .{ .structure = .{ .num = .{ + .num_poly = frac_var, + } } }, rank); + } + }, + .e_frac_f64 => |frac| { + if (frac.has_suffix) { + try self.updateVar(expr_var, .{ .structure = .{ .num = .{ .num_compact = .{ .frac = .f64 } } } }, rank); + } else { + const requirements = types_mod.Num.FracRequirements{ + .fits_in_f32 = can.CIR.fitsInF32(@floatCast(frac.value)), + .fits_in_dec = can.CIR.fitsInDec(@floatCast(frac.value)), + }; + const frac_var = try self.freshFromContent(.{ .structure = .{ .num = .{ + .frac_unbound = requirements, + } } }, rank, expr_region); + try self.var_pool.addVarToRank(frac_var, rank); + + try self.updateVar(expr_var, .{ .structure = .{ .num = .{ + .num_poly = frac_var, + } } }, rank); + } + }, + .e_dec => |frac| { + if (frac.has_suffix) { + try self.updateVar(expr_var, .{ .structure = .{ .num = .{ .num_compact = .{ .frac = .dec } } } }, rank); + } else { + const f64_val = frac.value.toF64(); + const requirements = types_mod.Num.FracRequirements{ + .fits_in_f32 = can.CIR.fitsInF32(f64_val), + .fits_in_dec = can.CIR.fitsInDec(f64_val), + }; + const frac_var = try self.freshFromContent(.{ .structure = .{ .num = .{ + .frac_unbound = requirements, + } } }, rank, expr_region); + try self.var_pool.addVarToRank(frac_var, rank); + + try self.updateVar(expr_var, .{ .structure = .{ .num = .{ + .num_poly = frac_var, + } } }, rank); + } + }, + .e_dec_small => |frac| { + if (frac.has_suffix) { + try self.updateVar(expr_var, .{ .structure = .{ .num = .{ .num_compact = .{ .frac = .dec } } } }, rank); + } else { + const reqs = frac.value.toFracRequirements(); + const frac_var = try self.freshFromContent(.{ .structure = .{ .num = .{ + .frac_unbound = reqs, + } } }, rank, expr_region); + try self.var_pool.addVarToRank(frac_var, rank); + + try self.updateVar(expr_var, .{ .structure = .{ .num = .{ + .num_poly = frac_var, + } } }, rank); + } + }, + // list // + .e_empty_list => { + try self.updateVar(expr_var, .{ .structure = .list_unbound }, rank); + }, .e_list => |list| { - const elem_var = @as(Var, @enumFromInt(@intFromEnum(list.elem_var))); const elems = self.cir.store.exprSlice(list.elems); - std.debug.assert(elems.len > 0); // Should never be 0 here, because this is not an .empty_list + if (elems.len == 0) { + // If we have no elems, then set the type and move on + try self.updateVar(expr_var, .{ .structure = .list_unbound }, rank); + } else { + // Here, we use the list's 1st element as the element var to + // constrain the rest of the list - // We need to type-check the first element, but we don't need to unify it with - // anything because we already pre-unified the list's elem var with it. - const first_elem_idx = elems[0]; - var last_elem_idx: CIR.Expr.Idx = first_elem_idx; - does_fx = try self.checkExpr(first_elem_idx) or does_fx; + // Check the first elem + does_fx = try self.checkExpr(elems[0], rank, .no_expectation) or does_fx; - for (elems[1..], 1..) |elem_expr_id, i| { - does_fx = try self.checkExpr(elem_expr_id) or does_fx; + // Iterate over the remaining elements + const elem_var = ModuleEnv.varFrom(elems[0]); + var last_elem_expr_idx = elems[0]; + for (elems[1..], 1..) |elem_expr_idx, i| { + does_fx = try self.checkExpr(elem_expr_idx, rank, .no_expectation) or does_fx; + const cur_elem_var = ModuleEnv.varFrom(elem_expr_idx); - // Unify each element's var with the list's elem var - const result = try self.unify(elem_var, @enumFromInt(@intFromEnum(elem_expr_id))); - self.setDetailIfTypeMismatch(result, problem.TypeMismatchDetail{ .incompatible_list_elements = .{ - .last_elem_expr = last_elem_idx, - .incompatible_elem_index = @intCast(i), - .list_length = @intCast(elems.len), - } }); + // Unify each element's var with the list's elem var + const result = try self.unify(elem_var, cur_elem_var, rank); + self.setDetailIfTypeMismatch(result, problem.TypeMismatchDetail{ .incompatible_list_elements = .{ + .last_elem_idx = ModuleEnv.nodeIdxFrom(last_elem_expr_idx), + .incompatible_elem_index = @intCast(i), + .list_length = @intCast(elems.len), + } }); - if (!result.isOk()) { - // Check remaining elements to catch their individual errors - for (elems[i + 1 ..]) |remaining_elem_id| { - does_fx = try self.checkExpr(remaining_elem_id) or does_fx; + // If we errored, check the rest of the elements without comparing + // to the elem_var to catch their individual errors + if (!result.isOk()) { + for (elems[i + 1 ..]) |remaining_elem_expr_idx| { + does_fx = try self.checkExpr(remaining_elem_expr_idx, rank, .no_expectation) or does_fx; + } + + // Break to avoid cascading errors + break; } - // Break to avoid cascading errors - break; + last_elem_expr_idx = elem_expr_idx; } - last_elem_idx = elem_expr_id; + try self.updateVar(expr_var, .{ .structure = .{ .list = elem_var } }, rank); } }, - .e_empty_list => |_| {}, - .e_match => |match| { - does_fx = try self.checkMatchExpr(expr_idx, match); - }, - .e_if => |if_expr| { - does_fx = try self.checkIfElseExpr(expr_idx, expr_region, if_expr); - }, - .e_call => |call| { - // Get all expressions - first is function, rest are arguments - const all_exprs = self.cir.store.sliceExpr(call.args); - - if (all_exprs.len == 0) return false; // No function to call - - // First expression is the function being called; the rest are args. - const func_expr_idx = all_exprs[0]; - does_fx = try self.checkExpr(func_expr_idx) or does_fx; // func_expr could be effectful, e.g. `(mk_fn!())(arg)` - - // Then, check all the arguments - const call_args = all_exprs[1..]; - for (call_args) |arg_expr_idx| { - // Each arg could also be effectful, e.g. `fn(mk_arg!(), mk_arg!())` - does_fx = try self.checkExpr(arg_expr_idx) or does_fx; + // tuple // + .e_tuple => |tuple| { + // Check tuple elements + const elems_slice = self.cir.store.exprSlice(tuple.elems); + for (elems_slice) |single_elem_expr_idx| { + does_fx = try self.checkExpr(single_elem_expr_idx, rank, .no_expectation) or does_fx; } - // Don't try to unify with the function if the function is a runtime error. - const func_expr = self.cir.store.getExpr(func_expr_idx); - if (func_expr != .e_runtime_error) { - const func_expr_region = self.cir.store.getRegionAt(ModuleEnv.nodeIdxFrom(func_expr_idx)); + // Cast the elems idxs to vars (this works because Anno Idx are 1-1 with type Vars) + const elem_vars_slice = try self.types.appendVars(@ptrCast(elems_slice)); - const call_var = @as(Var, @enumFromInt(@intFromEnum(expr_idx))); - const call_func_var = @as(Var, @enumFromInt(@intFromEnum(func_expr_idx))); - const resolved_func = self.types.resolveVar(call_func_var); - - // Check if this is an annotated function that needs instantiation - // We only instantiate if the function actually contains type variables - var cur_call_func_var = call_func_var; - var current_content = resolved_func.desc.content; - - content_switch: switch (current_content) { - .structure => |flat_type| switch (flat_type) { - .fn_effectful => |_| { - does_fx = true; - if (self.types.needsInstantiation(cur_call_func_var)) { - const expected_func_var = try self.instantiateVarAnon(cur_call_func_var, .{ .explicit = expr_region }); - const resolved_expected_func = self.types.resolveVar(expected_func_var); - - std.debug.assert(resolved_expected_func.desc.content == .structure); - std.debug.assert(resolved_expected_func.desc.content.structure == .fn_effectful); - const expected_func = resolved_expected_func.desc.content.structure.fn_effectful; - - does_fx = try self.unifyFunctionCall(call_var, call_func_var, call_args, expected_func, expr_region, func_expr_idx) or does_fx; - - // Unify with expected type if provided - if (expected_type) |expected| { - if (from_annotation) { - _ = try self.unifyWithAnnotation(call_var, expected); - } else { - _ = try self.unify(call_var, expected); - } - } - - return does_fx; - } - }, - .fn_pure => |_| { - if (self.types.needsInstantiation(cur_call_func_var)) { - const expected_func_var = try self.instantiateVarAnon(cur_call_func_var, .{ .explicit = expr_region }); - const resolved_expected_func = self.types.resolveVar(expected_func_var); - - std.debug.assert(resolved_expected_func.desc.content == .structure); - std.debug.assert(resolved_expected_func.desc.content.structure == .fn_pure); - const expected_func = resolved_expected_func.desc.content.structure.fn_pure; - - does_fx = try self.unifyFunctionCall(call_var, call_func_var, call_args, expected_func, func_expr_region, func_expr_idx) or does_fx; - - // Unify with expected type if provided - if (expected_type) |expected| { - if (from_annotation) { - _ = try self.unifyWithAnnotation(call_var, expected); - } else { - _ = try self.unify(call_var, expected); - } - } - - return does_fx; - } - }, - .fn_unbound => |_| { - if (self.types.needsInstantiation(cur_call_func_var)) { - const expected_func_var = try self.instantiateVarAnon(cur_call_func_var, .{ .explicit = expr_region }); - const resolved_expected_func = self.types.resolveVar(expected_func_var); - - std.debug.assert(resolved_expected_func.desc.content == .structure); - std.debug.assert(resolved_expected_func.desc.content.structure == .fn_unbound); - const expected_func = resolved_expected_func.desc.content.structure.fn_unbound; - - does_fx = try self.unifyFunctionCall(call_var, call_func_var, call_args, expected_func, expr_region, func_expr_idx) or does_fx; - return does_fx; - } - }, - else => { - // Non-function structure - fall through - }, - }, - .alias => |alias| { - // Resolve the alias, then continue on to the appropriate branch. - // (It might be another alias, or we might be done and ready to proceed.) - const backing_var = self.types.getAliasBackingVar(alias); - cur_call_func_var = backing_var; - current_content = self.types.resolveVar(backing_var).desc.content; - continue :content_switch current_content; - }, - else => { - // Non-structure content - fall through - }, - } - - // We didn't handle the function call above (either because it wasn't a function - // or it didn't need instantiation), so fall back on this logic. - const arg_vars: []Var = @ptrCast(@alignCast(@constCast(call_args))); - - // Create an unbound function type with the call result as return type - // The unification will propagate the actual return type to the call - // - // TODO: Do we need to insert a CIR placeholder node here as well? - // What happens if later this type variable has a problem, and we - // try to look up its region in CIR? - const func_content = try self.types.mkFuncUnbound(arg_vars, call_var); - const expected_func_var = try self.freshFromContent(func_content, expr_region); - _ = try self.unify(expected_func_var, cur_call_func_var); - } + // Set the type in the store + try self.updateVar(expr_var, .{ .structure = .{ + .tuple = .{ .elems = elem_vars_slice }, + } }, rank); }, + // record // .e_record => |e| { - // Perform field-by-field unification between the record structure's - // field type variables and the actual field value expression types. - // - // 1. Resolve the expression var to get the record structure - // 2. Type check each field value expression (to get concrete types) - // 3. For each field, unify the field type var with the field value type var - // 4. Unification propagates concrete types through the type system + // Create a record type in the type system and assign it the expr_var - const record_var_resolved = self.types.resolveVar(expr_var); - const record_var_content = record_var_resolved.desc.content; + // Write down the top of the scratch records array + const record_fields_top = self.scratch_record_fields.top(); + defer self.scratch_record_fields.clearFrom(record_fields_top); // Process each field for (self.cir.store.sliceRecordFields(e.fields)) |field_idx| { const field = self.cir.store.getRecordField(field_idx); - // STEP 1: Check the field value expression first - // This ensures the field value has a concrete type to unify with - does_fx = try self.checkExpr(field.value) or does_fx; + // Check the field value expression + does_fx = try self.checkExpr(field.value, rank, .no_expectation) or does_fx; - // STEP 2: Find the corresponding field type in the record structure - // This only works if record_var_content is .structure.record - if (record_var_content == .structure and record_var_content.structure == .record) { - const record_fields = self.types.getRecordFieldsSlice(record_var_content.structure.record.fields); + // Append it to the scratch records array + try self.scratch_record_fields.append(self.gpa, types_mod.RecordField{ + .name = field.name, + .var_ = ModuleEnv.varFrom(field.value), + }); + } - // STEP 3: Find the field with matching name and unify types - const field_names = record_fields.items(.name); - const field_vars = record_fields.items(.var_); - for (field_names, field_vars) |type_field_name, type_field_var| { - if (type_field_name.idx == field.name.idx) { - // Extract the type variable from the field value expression - // Different expression types store their type variables in different places - const field_expr_type_var = @as(Var, @enumFromInt(@intFromEnum(field.value))); + // Copy the scratch fields into the types store + const record_fields_scratch = self.scratch_record_fields.sliceFromStart(record_fields_top); + std.mem.sort(types_mod.RecordField, record_fields_scratch, self.cir.getIdentStore(), comptime types_mod.RecordField.sortByNameAsc); + const record_fields_range = try self.types.appendRecordFields(record_fields_scratch); - // STEP 4: Unify field type variable with field value type variable - // This is where concrete types (like Str, Num) get propagated - // from field values to the record structure - _ = try self.unify(type_field_var, field_expr_type_var); - break; - } - } - } - // If record_var_content is NOT .structure.record, unification is skipped - // This typically happens when canonicalization didn't set the record structure properly + // Check if we have an ext + if (e.ext) |ext_expr| { + does_fx = try self.checkExpr(ext_expr, rank, .no_expectation) or does_fx; + try self.updateVar(expr_var, .{ .structure = .{ .record = .{ + .ext = ModuleEnv.varFrom(ext_expr), + .fields = record_fields_range, + } } }, rank); + } else { + try self.updateVar(expr_var, .{ .structure = .{ + .record_unbound = record_fields_range, + } }, rank); } }, - .e_empty_record => |_| {}, - .e_tag => |_| {}, - .e_nominal => |e| { - const real_nominal_var = ModuleEnv.varFrom(e.nominal_type_decl); - const expr_backing_var = ModuleEnv.varFrom(e.backing_expr); + .e_empty_record => { + try self.updateVar(expr_var, .{ .structure = .empty_record }, rank); + }, + // tags // + .e_zero_argument_tag => |e| { + const ext_var = try self.fresh(rank, expr_region); + try self.var_pool.addVarToRank(ext_var, rank); - try self.checkNominal( - ModuleEnv.varFrom(expr_idx), - expr_region, - expr_backing_var, - e.backing_type, - real_nominal_var, - ); + const tag = try self.types.mkTag(e.name, &.{}); + const tag_union_content = try self.types.mkTagUnion(&[_]types_mod.Tag{tag}, ext_var); + + // Update the expr to point to the new type + try self.updateVar(expr_var, tag_union_content, rank); }, - .e_nominal_external => |e| { - const resolved_external = try self.resolveVarFromExternal(e.module_idx, e.target_node_idx) orelse { - // If we could not copy the type, set error and continue - try self.types.setVarContent(ModuleEnv.varFrom(expr_idx), .err); - return false; - }; - const expr_backing_var = ModuleEnv.varFrom(e.backing_expr); - try self.checkNominal( - ModuleEnv.varFrom(expr_idx), - expr_region, - expr_backing_var, - e.backing_type, - resolved_external.local_var, - ); + .e_tag => |e| { + // Create a tag type in the type system and assign it the expr_var + + // Process each tag arg + const arg_expr_idx_slice = self.cir.store.sliceExpr(e.args); + for (arg_expr_idx_slice) |arg_expr_idx| { + does_fx = try self.checkExpr(arg_expr_idx, rank, .no_expectation) or does_fx; + } + + // Create the type + const ext_var = try self.fresh(rank, expr_region); + try self.var_pool.addVarToRank(ext_var, rank); + + const tag = try self.types.mkTag(e.name, @ptrCast(arg_expr_idx_slice)); + const tag_union_content = try self.types.mkTagUnion(&[_]types_mod.Tag{tag}, ext_var); + + // Update the expr to point to the new type + try self.updateVar(expr_var, tag_union_content, rank); }, - .e_zero_argument_tag => |_| {}, - .e_binop => |binop| { - does_fx = try self.checkBinopExpr(expr_idx, expr_region, binop, expected_type, from_annotation); + // nominal // + .e_nominal => |nominal| { + // TODO: Merge this with e_nominal_external + + // First, check the type inside the expr + does_fx = try self.checkExpr(nominal.backing_expr, rank, .no_expectation) or does_fx; + const actual_backing_var = ModuleEnv.varFrom(nominal.backing_expr); + + // Then, we need an instance of the nominal type being referenced + // E.g. ConList.Cons(...) + // ^^^^^^^ + const nominal_var = try self.instantiateVar(ModuleEnv.varFrom(nominal.nominal_type_decl), rank, .{ .explicit = expr_region }); + const nominal_resolved = self.types.resolveVar(nominal_var).desc.content; + + if (nominal_resolved == .structure and nominal_resolved.structure == .nominal_type) { + // Then, we extract the variable of the nominal type + // E.g. ConList(a) := [Cons(a, ConstList), Nil] + // ^^^^^^^^^^^^^^^^^^^^^^^^^ + const nominal_backing_var = self.types.getNominalBackingVar(nominal_resolved.structure.nominal_type); + + // Now we unify what the user wrote with the backing type of the nominal was + // E.g. ConList.Cons(...) <-> [Cons(a, ConsList(a)), Nil] + // ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ + const result = try self.unify(nominal_backing_var, actual_backing_var, rank); + + // Then, we handle the result of unification + switch (result) { + .ok => { + // If that unify call succeeded, then we this is a valid instance + // of this nominal type. So we set the expr's type to be the + // nominal type + try self.types.setVarRedirect(expr_var, nominal_var); + }, + .problem => |problem_idx| { + // Unification failed - the constructor is incompatible with the nominal type + // Set a specific error message based on the backing type kind + switch (nominal.backing_type) { + .tag => { + // Constructor doesn't exist or has wrong arity/types + self.setProblemTypeMismatchDetail(problem_idx, .invalid_nominal_tag); + }, + else => { + // TODO: Add specific error messages for records, tuples, etc. + }, + } + + // Mark the entire expression as having a type error + try self.updateVar(expr_var, .err, rank); + }, + } + } else { + // If the nominal type is actually something else, then set the + // whole expression to be an error. + // + // TODO: Report a nice problem here + try self.updateVar(expr_var, .err, rank); + } }, - .e_unary_minus => |unary| { - does_fx = try self.checkUnaryMinusExpr(expr_idx, expr_region, unary); + .e_nominal_external => |nominal| { + // TODO: Merge this with e_nominal + + // First, check the type inside the expr + does_fx = try self.checkExpr(nominal.backing_expr, rank, .no_expectation) or does_fx; + const actual_backing_var = ModuleEnv.varFrom(nominal.backing_expr); + + if (try self.resolveVarFromExternal(nominal.module_idx, nominal.target_node_idx)) |ext_ref| { + // Then, we need an instance of the nominal type being referenced + // E.g. ConList.Cons(...) + // ^^^^^^^ + const nominal_var = try self.instantiateVar(ext_ref.local_var, Rank.generalized, .{ .explicit = expr_region }); + const nominal_resolved = self.types.resolveVar(nominal_var).desc.content; + + if (nominal_resolved == .structure and nominal_resolved.structure == .nominal_type) { + // Then, we extract the variable of the nominal type + // E.g. ConList(a) := [Cons(a, ConstList), Nil] + // ^^^^^^^^^^^^^^^^^^^^^^^^^ + const nominal_backing_var = self.types.getNominalBackingVar(nominal_resolved.structure.nominal_type); + + // Now we unify what the user wrote with the backing type of the nominal was + // E.g. ConList.Cons(...) <-> [Cons(a, ConsList(a)), Nil] + // ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ + const result = try self.unify(nominal_backing_var, actual_backing_var, rank); + + // Then, we handle the result of unification + switch (result) { + .ok => { + // If that unify call succeeded, then we this is a valid instance + // of this nominal type. So we set the expr's type to be the + // nominal type + try self.types.setVarRedirect(expr_var, nominal_var); + }, + .problem => |problem_idx| { + // Unification failed - the constructor is incompatible with the nominal type + // Set a specific error message based on the backing type kind + switch (nominal.backing_type) { + .tag => { + // Constructor doesn't exist or has wrong arity/types + self.setProblemTypeMismatchDetail(problem_idx, .invalid_nominal_tag); + }, + else => { + // TODO: Add specific error messages for records, tuples, etc. + }, + } + + // Mark the entire expression as having a type error + try self.updateVar(expr_var, .err, rank); + }, + } + } else { + // If the nominal type is actually something else, then set the + // whole expression to be an error. + // + // TODO: Report a nice problem here + try self.updateVar(expr_var, .err, rank); + } + } else { + try self.updateVar(expr_var, .err, rank); + } }, - .e_unary_not => |unary| { - does_fx = try self.checkUnaryNotExpr(expr_idx, expr_region, unary); + // lookup // + .e_lookup_local => |lookup| { + const pat_var = ModuleEnv.varFrom(lookup.pattern_idx); + const resolved_pat = self.types.resolveVar(pat_var).desc; + + // We never instantiate rigid variables + if (resolved_pat.rank == Rank.generalized and resolved_pat.content != .rigid) { + const instantiated = try self.instantiateVar(pat_var, rank, .use_last_var); + _ = try self.types.setVarRedirect(expr_var, instantiated); + } else { + _ = try self.types.setVarRedirect(expr_var, pat_var); + } + + // Unify this expression with the referenced pattern }, + .e_lookup_external => |ext| { + if (try self.resolveVarFromExternal(ext.module_idx, ext.target_node_idx)) |ext_ref| { + const ext_instantiated_var = try self.instantiateVar( + ext_ref.local_var, + Rank.generalized, + .{ .explicit = expr_region }, + ); + try self.types.setVarRedirect(expr_var, ext_instantiated_var); + } else { + try self.updateVar(expr_var, .err, rank); + } + }, + // block // .e_block => |block| { + const anno_free_vars_top = self.anno_free_vars.top(); + defer self.anno_free_vars.clearFrom(anno_free_vars_top); + // Check all statements in the block const statements = self.cir.store.sliceStatements(block.stmts); for (statements) |stmt_idx| { const stmt = self.cir.store.getStatement(stmt_idx); switch (stmt) { .s_decl => |decl_stmt| { - // Check pattern and expression, then unify - try self.checkPattern(decl_stmt.pattern); - if (decl_stmt.anno) |anno_idx| { - // TODO: When instantiating, use the parent type variables - // map here to allow `forall` behavior - const annotation = self.cir.store.getAnnotation(anno_idx); - try self.checkAnnotation(annotation.type_anno); + // Check the pattern + try self.checkPattern(decl_stmt.pattern, rank, .no_expectation); + const decl_pattern_var: Var = ModuleEnv.varFrom(decl_stmt.pattern); - does_fx = try self.checkExprWithExpectedAndAnnotation(decl_stmt.expr, ModuleEnv.varFrom(annotation.type_anno), true) or does_fx; - } else { - does_fx = try self.checkExpr(decl_stmt.expr) or does_fx; + // Check the annotation, if it exists + const check_mode = blk: { + if (decl_stmt.anno) |anno_idx| { + const annotation = self.cir.store.getAnnotation(anno_idx); + try self.generateAnnoTypeInPlace(annotation.type_anno, .annotation); + const anno_var = ModuleEnv.varFrom(anno_idx); + break :blk Expected{ + .expected = .{ .var_ = anno_var, .from_annotation = true }, + }; + } else { + break :blk Expected.no_expectation; + } + }; + + { + // Enter a new rank + try self.var_pool.pushRank(); + defer self.var_pool.popRank(); + + const next_rank = rank.next(); + std.debug.assert(next_rank == self.var_pool.current_rank); + + does_fx = try self.checkExpr(decl_stmt.expr, next_rank, check_mode) or does_fx; + + // Now that we are existing the scope, we must generalize then pop this rank + try self.generalizer.generalize(&self.var_pool, next_rank); } // Unify the pattern with the expression - const decl_pattern_var: Var = @enumFromInt(@intFromEnum(decl_stmt.pattern)); - const decl_expr_var: Var = @enumFromInt(@intFromEnum(decl_stmt.expr)); - _ = try self.unify(decl_pattern_var, decl_expr_var); + const decl_expr_var: Var = ModuleEnv.varFrom(decl_stmt.expr); + _ = try self.unify(decl_pattern_var, decl_expr_var, rank); }, .s_reassign => |reassign| { - does_fx = try self.checkExpr(reassign.expr) or does_fx; + // Check the pattern + try self.checkPattern(reassign.pattern_idx, rank, .no_expectation); + const reassign_pattern_var: Var = ModuleEnv.varFrom(reassign.pattern_idx); + + { + // Enter a new rank + try self.var_pool.pushRank(); + defer self.var_pool.popRank(); + + const next_rank = rank.next(); + std.debug.assert(next_rank == self.var_pool.current_rank); + + does_fx = try self.checkExpr(reassign.expr, next_rank, .no_expectation) or does_fx; + + // Now that we are existing the scope, we must generalize then pop this rank + try self.generalizer.generalize(&self.var_pool, next_rank); + } + + // Unify the pattern with the expression + const reassign_expr_var: Var = ModuleEnv.varFrom(reassign.expr); + _ = try self.unify(reassign_pattern_var, reassign_expr_var, rank); }, .s_expr => |expr_stmt| { - does_fx = try self.checkExpr(expr_stmt.expr) or does_fx; + does_fx = try self.checkExpr(expr_stmt.expr, rank, .no_expectation) or does_fx; + }, + .s_expect => |expr_stmt| { + does_fx = try self.checkExpr(expr_stmt.body, rank, .no_expectation) or does_fx; + const stmt_expr: Var = ModuleEnv.varFrom(expr_stmt.body); + + const bool_var = try self.freshBool(rank, expr_region); + _ = try self.unify(bool_var, stmt_expr, rank); }, else => { - // Other statement types don't need expression checking + // TODO }, } } // Check the final expression - does_fx = try self.checkExpr(block.final_expr) or does_fx; + does_fx = try self.checkExpr(block.final_expr, rank, expected) or does_fx; // Link the root expr with the final expr - _ = try self.unify( - @enumFromInt(@intFromEnum(expr_idx)), - @enumFromInt(@intFromEnum(block.final_expr)), - ); - }, - .e_closure => |closure| { - // The type of a closure is the type of the lambda it wraps. - // The lambda's type is determined by its arguments and body. - // We need to check the lambda expression itself to get its type. - // If we have an expected type, pass it to the lambda to catch type errors early - if (expected_type) |expected| { - does_fx = try self.checkExprWithExpectedAndAnnotation(closure.lambda_idx, expected, from_annotation); - } else { - does_fx = try self.checkExpr(closure.lambda_idx); - } - const lambda_var = ModuleEnv.varFrom(closure.lambda_idx); - const closure_var = ModuleEnv.varFrom(expr_idx); - _ = try self.unify(closure_var, lambda_var); + try self.types.setVarRedirect(expr_var, ModuleEnv.varFrom(block.final_expr)); }, + // function // .e_lambda => |lambda| { - does_fx = try self.checkLambdaWithAnno(expr_idx, expr_region, lambda, expected_type); - }, - .e_tuple => |tuple| { - // Check tuple elements - const elems_slice = self.cir.store.exprSlice(tuple.elems); - for (elems_slice) |single_elem_expr_idx| { - does_fx = try self.checkExpr(single_elem_expr_idx) or does_fx; + // Annotation-aware lambda type checking produces much better error + // messages, so first we have to determine if we have an expected + // type to validate against + const mb_expected_var: ?Var, const is_expected_from_anno: bool = blk: { + switch (expected) { + .no_expectation => break :blk .{ null, false }, + .expected => |expected_type| { + break :blk .{ expected_type.var_, expected_type.from_annotation }; + }, + } + }; + + // Then, even if we have an expected type, it may not actually be a function + const mb_expected_func: ?types_mod.Func = blk: { + if (mb_expected_var) |expected_var| { + // Here, we unwrap the function, following aliases, to get + // the actual function we want to check against + var var_ = expected_var; + while (true) { + switch (self.types.resolveVar(var_).desc.content) { + .structure => |flat_type| { + switch (flat_type) { + .fn_pure => |func| break :blk func, + .fn_unbound => |func| break :blk func, + .fn_effectful => |func| break :blk func, + else => break :blk null, + } + }, + .alias => |alias| { + var_ = self.types.getAliasBackingVar(alias); + }, + else => break :blk null, + } + } + } else { + break :blk null; + } + }; + + // Enter the next rank + try self.var_pool.pushRank(); + defer self.var_pool.popRank(); + + const next_rank = rank.next(); + std.debug.assert(next_rank == self.var_pool.current_rank); + + // Check the argument patterns + // This must happen *before* checking against the expected type so + // all the pattern types are inferred + const arg_pattern_idxs = self.cir.store.slicePatterns(lambda.args); + for (arg_pattern_idxs) |pattern_idx| { + try self.checkPattern(pattern_idx, next_rank, .no_expectation); } - // The tuple type is created in the type store in canonicalize, so - // nothing more needs to be done here + // Now, check if we have an expected function to validate against + if (mb_expected_func) |expected_func| { + const expected_func_args = self.types.sliceVars(expected_func.args); + + // Next, check if the arguments arities match + if (expected_func_args.len == arg_pattern_idxs.len) { + // If so, check each argument, passing in the expected type + + // First, find all the rigid variables in a the function's type + // and unify the matching corresponding lambda arguments together. + for (expected_func_args, 0..) |expected_arg_1, i| { + const expected_resolved_1 = self.types.resolveVar(expected_arg_1); + + // The expected type is an annotation and as such, + // should never contain a flex var. If it did, that + // would indicate that the annotation is malformed + // std.debug.assert(expected_resolved_1.desc.content != .flex); + + // Skip any concrete arguments + if (expected_resolved_1.desc.content != .rigid) { + continue; + } + + // Look for other arguments with the same type variable + for (expected_func_args[i + 1 ..], i + 1..) |expected_arg_2, j| for_blk: { + const expected_resolved_2 = self.types.resolveVar(expected_arg_2); + if (expected_resolved_1.var_ == expected_resolved_2.var_) { + // These two argument indexes in the called *function's* + // type have the same rigid variable! So, we unify + // the corresponding *lambda args* + + const arg_1 = @as(Var, ModuleEnv.varFrom(arg_pattern_idxs[i])); + const arg_2 = @as(Var, ModuleEnv.varFrom(arg_pattern_idxs[j])); + + const unify_result = try self.unify(arg_1, arg_2, rank); + if (unify_result.isProblem()) { + // Use the new error detail for bound type variable incompatibility + self.setProblemTypeMismatchDetail(unify_result.problem, .{ + .incompatible_fn_args_bound_var = .{ + .fn_name = null, // TODO: Use function name? + .first_arg_var = arg_1, + .second_arg_var = arg_2, + .first_arg_index = @intCast(i), + .second_arg_index = @intCast(j), + .num_args = @intCast(arg_pattern_idxs.len), + }, + }); + + // Stop execution + _ = try self.updateVar(expr_var, .err, rank); + break :for_blk; + } + } + } + } + + // Then, lastly, we unify the annotation types against the + // actual type + for (expected_func_args, arg_pattern_idxs) |expected_arg_var, pattern_idx| { + if (is_expected_from_anno) { + _ = try self.unifyFromAnno(expected_arg_var, ModuleEnv.varFrom(pattern_idx), next_rank); + } else { + _ = try self.unify(expected_arg_var, ModuleEnv.varFrom(pattern_idx), next_rank); + } + } + } else { + // This means the expected type and the actual lambda have + // an arity mismatch. This will be caught by the regular + // expectation checking code at the bottom of this function + } + } + const arg_vars: []Var = @ptrCast(arg_pattern_idxs); + + // Check the the body of the expr + // If we have an expected function, use that as the expr's expected type + if (mb_expected_func) |expected_func| { + does_fx = try self.checkExpr(lambda.body, next_rank, .{ + .expected = .{ .var_ = expected_func.ret, .from_annotation = is_expected_from_anno }, + }) or does_fx; + } else { + does_fx = try self.checkExpr(lambda.body, next_rank, .no_expectation) or does_fx; + } + const body_var = ModuleEnv.varFrom(lambda.body); + + // Create the function type + if (does_fx) { + _ = try self.updateVar(expr_var, try self.types.mkFuncEffectful(arg_vars, body_var), next_rank); + } else { + _ = try self.updateVar(expr_var, try self.types.mkFuncUnbound(arg_vars, body_var), next_rank); + } + try self.var_pool.addVarToRank(expr_var, next_rank); + + // Note that so far, we have not yet unified against the + // annotation's effectfulness/pureness. This is intentional! + // Below this large switch statement, there's the regular expr + // <-> expected unification. This will catch any difference in + // effectfullness, and it'll link the root expected var with the + // expr_var + + // Now that we are existing the scope, we must generalize then pop this rank + try self.generalizer.generalize(&self.var_pool, next_rank); + }, + .e_closure => |closure| { + does_fx = try self.checkExpr(closure.lambda_idx, rank, expected) or does_fx; + _ = try self.types.setVarRedirect(expr_var, ModuleEnv.varFrom(closure.lambda_idx)); + }, + // function calling // + .e_call => |call| { + switch (call.called_via) { + .apply => blk: { + // First, check the function being called + // It could be effectful, e.g. `(mk_fn!())(arg)` + does_fx = try self.checkExpr(call.func, rank, .no_expectation) or does_fx; + const func_var = ModuleEnv.varFrom(call.func); + + // Second, check the arguments being called + // It could be effectful, e.g. `fn(mk_arg!())` + const call_arg_expr_idxs = self.cir.store.sliceExpr(call.args); + for (call_arg_expr_idxs) |call_arg_idx| { + does_fx = try self.checkExpr(call_arg_idx, rank, .no_expectation) or does_fx; + } + + // From the base function type, extract the actual function info + const mb_func: ?types_mod.Func = inner_blk: { + // Here, we unwrap the function, following aliases, to get + // the actual function we want to check against + var var_ = func_var; + while (true) { + switch (self.types.resolveVar(var_).desc.content) { + .structure => |flat_type| { + switch (flat_type) { + .fn_pure => |func| break :inner_blk func, + .fn_unbound => |func| break :inner_blk func, + .fn_effectful => |func| break :inner_blk func, + else => break :inner_blk null, + } + }, + .alias => |alias| { + var_ = self.types.getAliasBackingVar(alias); + }, + else => break :inner_blk null, + } + } + }; + + // Get the name of the function (for error messages) + const func_name: ?Ident.Idx = inner_blk: { + const func_expr = self.cir.store.getExpr(call.func); + switch (func_expr) { + .e_lookup_local => |lookup| { + // Get the pattern that defines this identifier + const pattern = self.cir.store.getPattern(lookup.pattern_idx); + switch (pattern) { + .assign => |assign| break :inner_blk assign.ident, + else => break :inner_blk null, + } + }, + else => break :inner_blk null, + } + }; + + // Now, check the call args against the type of function + if (mb_func) |func| { + const func_args = self.types.sliceVars(func.args); + + if (func_args.len == call_arg_expr_idxs.len) { + // First, find all the "rigid" variables in a the function's type + // and unify the matching corresponding call arguments together. + // + // Here, "rigid" is in quotes because at this point, the expected function + // has been instantiated such that the rigid variables should all resolve + // to the same exact flex variable. So we are actually checking for flex + // variables here. + for (func_args, 0..) |expected_arg_1, i| { + const expected_resolved_1 = self.types.resolveVar(expected_arg_1); + + // Ensure the above comment is true. That is, that all + // rigid vars for this function have been instantiated to + // flex vars by the time we get here. + std.debug.assert(expected_resolved_1.desc.content != .rigid); + + // Skip any concrete arguments + if (expected_resolved_1.desc.content != .flex) { + continue; + } + + // Look for other arguments with the same type variable + for (func_args[i + 1 ..], i + 1..) |expected_arg_2, j| { + const expected_resolved_2 = self.types.resolveVar(expected_arg_2); + if (expected_resolved_1.var_ == expected_resolved_2.var_) { + // These two argument indexes in the called *function's* + // type have the same rigid variable! So, we unify + // the corresponding *call args* + + const arg_1 = @as(Var, ModuleEnv.varFrom(call_arg_expr_idxs[i])); + const arg_2 = @as(Var, ModuleEnv.varFrom(call_arg_expr_idxs[j])); + + const unify_result = try self.unify(arg_1, arg_2, rank); + if (unify_result.isProblem()) { + // Use the new error detail for bound type variable incompatibility + self.setProblemTypeMismatchDetail(unify_result.problem, .{ + .incompatible_fn_args_bound_var = .{ + .fn_name = func_name, + .first_arg_var = arg_1, + .second_arg_var = arg_2, + .first_arg_index = @intCast(i), + .second_arg_index = @intCast(j), + .num_args = @intCast(call_arg_expr_idxs.len), + }, + }); + + // Stop execution + _ = try self.updateVar(expr_var, .err, rank); + break :blk; + } + } + } + } + + // Check the function's arguments against the actual + // called arguments, unifying each one + for (func_args, call_arg_expr_idxs, 0..) |expected_arg_var, call_expr_idx, arg_index| { + const unify_result = try self.unify(expected_arg_var, ModuleEnv.varFrom(call_expr_idx), rank); + if (unify_result.isProblem()) { + // Use the new error detail for bound type variable incompatibility + self.setProblemTypeMismatchDetail(unify_result.problem, .{ + .incompatible_fn_call_arg = .{ + .fn_name = func_name, + .arg_var = ModuleEnv.varFrom(call_expr_idx), + .incompatible_arg_index = @intCast(arg_index), + .num_args = @intCast(call_arg_expr_idxs.len), + }, + }); + + // Stop execution + _ = try self.updateVar(expr_var, .err, rank); + break :blk; + } + } + + // Redirect the expr to the function's return type + _ = try self.types.setVarRedirect(expr_var, func.ret); + } else { + // TODO(jared): Better arity difference error message + + // If the expected function's arity doesn't match + // the actual arguments provoided, unify the + // inferred function type with the expected function + // type to get the regulare error message + const call_arg_vars: []Var = @ptrCast(call_arg_expr_idxs); + const call_func_ret = try self.fresh(rank, expr_region); + const call_func_content = try self.types.mkFuncUnbound(call_arg_vars, call_func_ret); + const call_func_var = try self.freshFromContent(call_func_content, rank, expr_region); + + try self.var_pool.addVarToRank(call_func_ret, rank); + try self.var_pool.addVarToRank(call_func_var, rank); + + _ = try self.unify(func_var, call_func_var, rank); + _ = try self.types.setVarRedirect(expr_var, call_func_ret); + } + } else { + // We get here if the type of expr being called + // (`mk_fn` in `(mk_fn())(arg)`) is NOT already + // inferred to be a function type. + + // This can mean a regular type mismatch, but it can also + // mean that the thing being called yet has not yet been + // inferred (like if this is an anonymous function param) + + // Either way, we know what the type *should* be, based + // on how it's being used here. So we create that func + // type and unify the function being called against it + + const call_arg_vars: []Var = @ptrCast(call_arg_expr_idxs); + const call_func_ret = try self.fresh(rank, expr_region); + const call_func_content = try self.types.mkFuncUnbound(call_arg_vars, call_func_ret); + const call_func_var = try self.freshFromContent(call_func_content, rank, expr_region); + + try self.var_pool.addVarToRank(call_func_ret, rank); + try self.var_pool.addVarToRank(call_func_var, rank); + + _ = try self.unify(func_var, call_func_var, rank); + + // Then, we set the root expr to redirect to the return + // type of that function, since a call expr ultimate + // resolve to the returned type + _ = try self.types.setVarRedirect(expr_var, call_func_ret); + } + }, + else => { + // No other call types are currently supported in czer + std.debug.assert(false); + try self.updateVar(expr_var, .err, rank); + }, + } + }, + .e_if => |if_expr| { + does_fx = try self.checkIfElseExpr(expr_idx, expr_region, rank, if_expr) or does_fx; + }, + .e_match => |match| { + does_fx = try self.checkMatchExpr(expr_idx, rank, match) or does_fx; + }, + .e_binop => |binop| { + does_fx = try self.checkBinopExpr(expr_idx, expr_region, rank, binop, expected) or does_fx; + }, + .e_unary_minus => |unary| { + does_fx = try self.checkUnaryMinusExpr(expr_idx, expr_region, rank, unary) or does_fx; + }, + .e_unary_not => |unary| { + does_fx = try self.checkUnaryNotExpr(expr_idx, expr_region, rank, unary) or does_fx; }, .e_dot_access => |dot_access| { // Check the receiver expression - does_fx = try self.checkExpr(dot_access.receiver) or does_fx; + does_fx = try self.checkExpr(dot_access.receiver, rank, .no_expectation) or does_fx; - // Get the type of the receiver - const receiver_var = @as(Var, @enumFromInt(@intFromEnum(dot_access.receiver))); - const resolved_receiver = self.types.resolveVar(receiver_var); + const receiver_var = ModuleEnv.varFrom(dot_access.receiver); + + if (dot_access.args) |args_span| { + // If this dot access has args, then it's static dispatch + + const resolved_receiver = self.types.resolveVar(receiver_var); + switch (resolved_receiver.desc.content) { + .err => { + // If the receiver type is an error, then propgate it and break + try self.updateVar(expr_var, .err, rank); + }, + .structure => |structure| switch (structure) { + .nominal_type => |nominal| { + // This is a static dispatch on a nominal type - // Handle different receiver types - switch (resolved_receiver.desc.content) { - .structure => |structure| switch (structure) { - .nominal_type => |nominal| { - // This is a static dispatch on a nominal type - if (dot_access.args) |args_span| { // Method call with arguments // Get the origin module path const origin_module_path = self.cir.getIdent(nominal.origin_module); @@ -1323,46 +2658,35 @@ fn checkExprWithExpectedAndAnnotationHelp(self: *Self, expr_idx: CIR.Expr.Idx, e cached_var else blk: { // Copy the method's type from the origin module to our type store - const source_var = @as(Var, @enumFromInt(@intFromEnum(target_node_idx))); + const source_var = ModuleEnv.varFrom(target_node_idx); const new_copy = try self.copyVar(source_var, @constCast(module)); try self.import_cache.put(self.gpa, cache_key, new_copy); break :blk new_copy; }; - const method_instantiated = try self.instantiateVarAnon(method_var, .use_last_var); + const method_instantiated = try self.instantiateVar(method_var, rank, .use_last_var); // Check all arguments - var i: u32 = 0; - while (i < args_span.span.len) : (i += 1) { - const arg_expr_idx = @as(CIR.Expr.Idx, @enumFromInt(args_span.span.start + i)); - does_fx = try self.checkExpr(arg_expr_idx) or does_fx; - } - - // Create argument list for the function call - var args = std.array_list.Managed(Var).init(self.gpa); - defer args.deinit(); - - // Add the receiver (the nominal type) as the first argument - try args.append(receiver_var); - - // Add the remaining arguments - i = 0; - while (i < args_span.span.len) : (i += 1) { - const arg_expr_idx = @as(CIR.Expr.Idx, @enumFromInt(args_span.span.start + i)); - const arg_var = @as(Var, @enumFromInt(@intFromEnum(arg_expr_idx))); - try args.append(arg_var); + const arg_expr_idxs = self.cir.store.sliceExpr(args_span); + for (arg_expr_idxs) |arg_expr_idx| { + does_fx = try self.checkExpr(arg_expr_idx, rank, .no_expectation) or does_fx; } + const arg_expr_vars: []Var = @ptrCast(arg_expr_idxs); // Create a function type for the method call - const dot_access_var = @as(Var, @enumFromInt(@intFromEnum(expr_idx))); - const func_content = try self.types.mkFuncUnbound(args.items, dot_access_var); - const expected_func_var = try self.freshFromContent(func_content, expr_region); + const ret_var = try self.fresh(rank, expr_region); + const func_content = try self.types.mkFuncUnbound(arg_expr_vars, ret_var); + const expected_func_var = try self.freshFromContent(func_content, rank, expr_region); // Unify with the imported method type - _ = try self.unify(expected_func_var, method_instantiated); + const result = try self.unify(method_instantiated, expected_func_var, rank); - // Store the resolved method info for code generation - // This will be used by the code generator to emit the correct function call - // For now, the type information in the expression variable is sufficient + // If the inferred function type matches the referenced type + // then set the expr type to be the return type + if (result.isOk()) { + try self.types.setVarRedirect(expr_var, ret_var); + } else { + try self.updateVar(expr_var, .err, rank); + } } else { // Method not found in origin module // TODO: Add a proper error type for method not found on nominal type @@ -1373,683 +2697,69 @@ fn checkExprWithExpectedAndAnnotationHelp(self: *Self, expr_idx: CIR.Expr.Idx, e // TODO: Add a proper error type for origin module not found try self.types.setVarContent(@enumFromInt(@intFromEnum(expr_idx)), .err); } - } else { - // No arguments - this might be a field access on a nominal type's backing type - // TODO: Handle field access on nominal types - try self.types.setVarContent(@enumFromInt(@intFromEnum(expr_idx)), .err); - } - }, - .record => |record| { - // Receiver is already a record, find the field - const fields = self.types.getRecordFieldsSlice(record.fields); - - // Find the field with the matching name - for (fields.items(.name), fields.items(.var_)) |field_name, field_var| { - if (field_name == dot_access.field_name) { - // Unify the dot access expression with the field type - const dot_access_var = @as(Var, @enumFromInt(@intFromEnum(expr_idx))); - _ = try self.unify(dot_access_var, field_var); - break; - } - } - }, - .record_unbound => |record_unbound| { - // Receiver is an unbound record, find the field - const fields = self.types.getRecordFieldsSlice(record_unbound); - - // Find the field with the matching name - for (fields.items(.name), fields.items(.var_)) |field_name, field_var| { - if (field_name == dot_access.field_name) { - // Unify the dot access expression with the field type - const dot_access_var = @as(Var, @enumFromInt(@intFromEnum(expr_idx))); - _ = try self.unify(dot_access_var, field_var); - break; - } - } + }, + else => { + // Receiver is not a nominal var, this is a type error + // TODO: Add a proper error when receiver is not a nominal var + }, }, else => { - // Receiver is not a record, this is a type error - // For now, we'll let unification handle the error + // Receiver is not a nominal var, this is a type error + // TODO: Add a proper error when receiver is not a nominal var + }, - }, - .flex_var => { - // Receiver is unbound, we need to constrain it to be a record with the field - // Create a fresh variable for the field type - const field_var = try self.fresh(expr_region); - const dot_access_var = @as(Var, @enumFromInt(@intFromEnum(expr_idx))); - _ = try self.unify(dot_access_var, field_var); - - // Create a record type with this field - const field_idx = try self.types.appendRecordField(.{ - .name = dot_access.field_name, - .var_ = field_var, - }); - const fields_range = types_mod.RecordField.SafeMultiList.Range{ - .start = field_idx, - .count = 1, - }; - - // Create an extension variable for other possible fields - // Create the record content - const record_content = types_mod.Content{ - .structure = .{ - .record_unbound = fields_range, - }, - }; - - // Unify the receiver with this record type - // - // TODO: Do we need to insert a CIR placeholder node here as well? - // What happens if later this type variable has a problem, and we - // try to look up it's region in CIR? - const record_var = try self.freshFromContent(record_content, expr_region); - - // Use the dot access expression as the constraint origin for better error reporting - _ = try self.unifyWithConstraintOrigin(receiver_var, record_var, dot_access_var); - - // Record that this variable was constrained by this dot access expression - try self.constraint_origins.put(receiver_var, dot_access_var); - // Constraint origin recorded for better error reporting - }, - else => { - // Other cases (rigid_var, alias, etc.) - let unification handle errors - }, - } - }, - .e_runtime_error => {}, - .e_crash => {}, - .e_dbg => {}, - .e_ellipsis => {}, - .e_expect => {}, - } - - return does_fx; -} - -// func // - -/// Helper function to unify a call expression with a function type -fn unifyFunctionCall( - self: *Self, - call_var: Var, // var for the entire call expr - call_func_var: Var, // var for the fn itself - call_args: []const CIR.Expr.Idx, // var for the fn args - expected_func: types_mod.Func, // the expected type of the fn (must be instantiated) - region: Region, - func_expr_idx: CIR.Expr.Idx, // the function expression for name extraction -) std.mem.Allocator.Error!bool { - // Extract function name if possible - const func_name: ?Ident.Idx = blk: { - const func_expr = self.cir.store.getExpr(func_expr_idx); - switch (func_expr) { - .e_lookup_local => |lookup| { - // Get the pattern that defines this identifier - const pattern = self.cir.store.getPattern(lookup.pattern_idx); - switch (pattern) { - .assign => |assign| break :blk assign.ident, - else => break :blk null, - } - }, - else => break :blk null, - } - }; - - // Check arguments with expected types using bidirectional type checking - const expected_args = self.types.sliceVars(expected_func.args); - - // Only unify arguments if counts match - otherwise let the normal - // unification process handle the arity mismatch error - if (expected_args.len == call_args.len) { - // For function signatures with bound type variables, unify arguments with each other first - // This ensures proper error placement for cases like mk_pair("1", 2) where a, a -> Pair(a) - - // Find arguments that share the same type variable - for (expected_args, 0..) |expected_arg_1, i| { - const expected_resolved_1 = self.types.resolveVar(expected_arg_1); - - // Only check type variables, skip concrete types - if (expected_resolved_1.desc.content != .flex_var and expected_resolved_1.desc.content != .rigid_var) { - continue; - } - - // Look for other arguments with the same type variable - for (expected_args[i + 1 ..], i + 1..) |expected_arg_2, j| { - if (expected_arg_1 == expected_arg_2) { - // These two arguments are bound by the same type variable - unify them first - const arg_1 = @as(Var, @enumFromInt(@intFromEnum(call_args[i]))); - const arg_2 = @as(Var, @enumFromInt(@intFromEnum(call_args[j]))); - - const unify_result = try self.unify(arg_1, arg_2); - - if (unify_result.isProblem()) { - // Use the new error detail for bound type variable incompatibility - self.setProblemTypeMismatchDetail(unify_result.problem, .{ - .incompatible_fn_args_bound_var = .{ - .fn_name = func_name, - .first_arg_var = arg_1, - .second_arg_var = arg_2, - .first_arg_index = @intCast(i), - .second_arg_index = @intCast(j), - .num_args = @intCast(call_args.len), - }, - }); - return false; // Early return on error - } - } - } - } - - // Apply constraint propagation for numeric literals with concrete types - for (expected_args, call_args) |expected_arg, arg_expr_idx| { - const expected_resolved = self.types.resolveVar(expected_arg); - - // Only apply constraint propagation for concrete types, not type variables - if (expected_resolved.desc.content != .flex_var and expected_resolved.desc.content != .rigid_var) { - const arg_expr = self.cir.store.getExpr(arg_expr_idx); - - if (arg_expr == .e_int) { - const literal_var = @as(Var, @enumFromInt(@intFromEnum(arg_expr_idx))); - _ = try self.unify(literal_var, expected_arg); - } - } - } - - // Regular unification using the argument vars - var arg_index: u32 = 0; - for (expected_args, call_args) |expected_arg, arg_expr_idx| { - const actual_arg = @as(Var, @enumFromInt(@intFromEnum(arg_expr_idx))); - - // Instantiate polymorphic arguments before unification - var arg_to_unify = actual_arg; - if (self.types.needsInstantiation(actual_arg)) { - arg_to_unify = try self.instantiateVarAnon(actual_arg, .{ .explicit = region }); - } - - const arg_result = try self.unify(expected_arg, arg_to_unify); - self.setDetailIfTypeMismatch(arg_result, .{ - .incompatible_fn_call_arg = .{ - .fn_name = null, // Get function name for better error message - .arg_var = actual_arg, - .incompatible_arg_index = arg_index, - .num_args = @intCast(call_args.len), - }, - }); - arg_index += 1; - } - // The call's type is the instantiated return type - _ = try self.unify(call_var, expected_func.ret); - } else { - // Arity mismatch - arguments already checked - - // Fall back to normal unification to get proper error message - // Use the original func_var to avoid issues with instantiated variables in error reporting - const actual_arg_vars: []Var = @ptrCast(@alignCast(@constCast(call_args))); - const func_content = try self.types.mkFuncUnbound(actual_arg_vars, call_var); - const expected_func_var = try self.freshFromContent(func_content, region); - _ = try self.unify(call_func_var, expected_func_var); - } - - return false; -} - -/// Performs bidirectional type checking for lambda expressions with optional type annotations. -/// -/// ## Constraint Ordering -/// -/// Parameter constraints from annotations are applied BEFORE checking the lambda body. -/// This ensures rigid variables are properly constrained during body analysis, causing -/// type errors to surface at their actual source rather than during later unification. -/// -/// **Why this ordering matters:** -/// ``` -/// Pair(a) := [Pair(a, a)] -/// mk_pair_invalid : a, b -> Pair(a) -/// mk_pair_invalid = |x, y| Pair.Pair(x, y) -/// -/// // Step 1: Constrain parameters from annotation first -/// x := a[rigid], y := b[rigid] -/// -/// // Step 2: Check body - error detected immediately at constructor -/// Pair.Pair(x, y) // ERROR: Pair requires same type, but x=a[rigid], y=b[rigid] -/// ``` -/// -/// Without upfront constraints, the error would only surface during final annotation -/// validation, making it harder to locate the actual problem in the source code. -/// Similar to checkLambdaWithAnno but only validates return type, not the entire function. -/// This is used for lambdas to preserve error locations while still catching type errors. -fn checkLambdaForClosure( - self: *Self, - expr_idx: CIR.Expr.Idx, - lambda: @FieldType(CIR.Expr, "e_lambda"), - anno_type: ?Var, -) std.mem.Allocator.Error!bool { - const trace = tracy.trace(@src()); - defer trace.end(); - - // Get the actual lambda arguments - const arg_patterns = self.cir.store.slicePatterns(lambda.args); - const arg_vars: []Var = @ptrCast(@alignCast(arg_patterns)); - - var mb_expected_func: ?types_mod.Func = null; - - // STEP 1: Apply annotation constraints to parameters FIRST - if (anno_type) |anno_var| { - const expected_resolved = self.types.resolveVar(anno_var); - mb_expected_func = switch (expected_resolved.desc.content) { - .structure => |s| switch (s) { - .fn_pure, .fn_effectful, .fn_unbound => |func| func, - else => null, - }, - else => null, - }; - - if (mb_expected_func) |func| { - const expected_args = self.types.sliceVars(func.args); - if (expected_args.len == arg_patterns.len) { - // Constrain parameters with annotation types - for (arg_patterns, expected_args) |pattern_idx, expected_arg| { - // Check the pattern - try self.checkPattern(pattern_idx); - - // Unify against the annotation - const pattern_var = ModuleEnv.varFrom(pattern_idx); - _ = try self.unify(pattern_var, expected_arg); - } - } - } - } - - // STEP 2: Check the body with return type constraint propagation - const is_effectful = if (mb_expected_func) |func| - try self.checkExprWithExpectedAndAnnotation(lambda.body, func.ret, true) - else - try self.checkExpr(lambda.body); - - // STEP 3: Build the function type - const fn_var = ModuleEnv.varFrom(expr_idx); - const return_var = @as(Var, @enumFromInt(@intFromEnum(lambda.body))); - - // Ensure the return variable has the correct region for error reporting - const body_region = self.cir.store.getExprRegion(lambda.body); - try self.fillInRegionsThrough(return_var); - self.setRegionAt(return_var, body_region); - - if (is_effectful) { - _ = try self.types.setVarContent(fn_var, try self.types.mkFuncEffectful(arg_vars, return_var)); - } else { - _ = try self.types.setVarContent(fn_var, try self.types.mkFuncUnbound(arg_vars, return_var)); - } - - // STEP 4: Don't validate here - let checkDef do the final unification - // This preserves error locations correctly - - // NOTE: We don't do the final unification with the full annotation here - // The caller (checkDef) will handle that to preserve error locations - - return is_effectful; -} - -fn checkLambdaWithAnno( - self: *Self, - expr_idx: CIR.Expr.Idx, - _: Region, - lambda: @FieldType(CIR.Expr, "e_lambda"), - anno_type: ?Var, -) std.mem.Allocator.Error!bool { - const trace = tracy.trace(@src()); - defer trace.end(); - - // Get the actual lambda arguments - const arg_patterns = self.cir.store.slicePatterns(lambda.args); - const arg_vars: []Var = @ptrCast(@alignCast(arg_patterns)); - - var mb_expected_var: ?Var = null; - var mb_expected_func: ?types_mod.Func = null; - - // STEP 1: Apply annotation constraints to parameters FIRST - if (anno_type) |anno_var| { - mb_expected_var = anno_var; - - const expected_resolved = self.types.resolveVar(anno_var); - mb_expected_func = switch (expected_resolved.desc.content) { - .structure => |s| switch (s) { - .fn_pure, .fn_effectful, .fn_unbound => |func| func, - else => null, - }, - else => null, - }; - - if (mb_expected_func) |func| { - const expected_args = self.types.sliceVars(func.args); - if (expected_args.len == arg_patterns.len) { - // Constrain parameters with annotation types - for (arg_patterns, expected_args) |pattern_idx, expected_arg| { - // Check the pattern - try self.checkPattern(pattern_idx); - - // Unify against the annotation - const pattern_var = ModuleEnv.varFrom(pattern_idx); - _ = try self.unify(pattern_var, expected_arg); - } - } - } - } - - // STEP 2: Check the body with return type constraint propagation for literals - const is_effectful = if (mb_expected_func) |func| - try self.checkExprWithExpectedAndAnnotation(lambda.body, func.ret, true) - else - try self.checkExpr(lambda.body); - - // STEP 3: Build the function type - const fn_var = ModuleEnv.varFrom(expr_idx); - const return_var = @as(Var, @enumFromInt(@intFromEnum(lambda.body))); - - // Ensure the return variable has the correct region for error reporting - const body_region = self.cir.store.getExprRegion(lambda.body); - try self.fillInRegionsThrough(return_var); - self.setRegionAt(return_var, body_region); - - if (is_effectful) { - _ = try self.types.setVarContent(fn_var, try self.types.mkFuncEffectful(arg_vars, return_var)); - } else { - _ = try self.types.setVarContent(fn_var, try self.types.mkFuncUnbound(arg_vars, return_var)); - } - - // STEP 4: Validate the function body against the annotation return type - if (mb_expected_func) |func| { - _ = try self.unify(return_var, func.ret); - } - - // STEP 5: Validate the entire function against the annotation - if (mb_expected_var) |expected_var| { - _ = try self.unifyWithAnnotation(fn_var, expected_var); - } - - return is_effectful; -} - -// binop // - -/// Check the types for a binary operation expression -fn checkBinopExpr(self: *Self, expr_idx: CIR.Expr.Idx, expr_region: Region, binop: CIR.Expr.Binop, expected_type: ?Var, from_annotation: bool) Allocator.Error!bool { - const trace = tracy.trace(@src()); - defer trace.end(); - - switch (binop.op) { - .add, .sub, .mul, .div, .rem, .pow, .div_trunc => { - // Check operands first - var does_fx = try self.checkExpr(binop.lhs); - does_fx = try self.checkExpr(binop.rhs) or does_fx; - - // For now, we'll constrain both operands to be numbers - // In the future, this will use static dispatch based on the lhs type - const lhs_var = @as(Var, @enumFromInt(@intFromEnum(binop.lhs))); - const rhs_var = @as(Var, @enumFromInt(@intFromEnum(binop.rhs))); - const result_var = @as(Var, @enumFromInt(@intFromEnum(expr_idx))); - - // For bidirectional type checking: if we have an expected type, - // we need to unify all operands and result with it. - // This ensures literals like `2` in `|x| x + 2` get properly constrained - // when the lambda has a type annotation like `I64 -> I64`. - if (expected_type) |expected| { - // All three must be the same type for arithmetic operations - if (from_annotation) { - _ = try self.unifyWithAnnotation(lhs_var, expected); - _ = try self.unifyWithAnnotation(rhs_var, expected); - _ = try self.unifyWithAnnotation(result_var, expected); - } else { - _ = try self.unify(lhs_var, expected); - _ = try self.unify(rhs_var, expected); - _ = try self.unify(result_var, expected); } } else { - // No expected type - use fresh number variables to maintain polymorphism - const num_content = Content{ .structure = .{ .num = .{ .num_unbound = .{ .sign_needed = false, .bits_needed = 0 } } } }; - const num_var_lhs = try self.freshFromContent(num_content, expr_region); - const num_var_rhs = try self.freshFromContent(num_content, expr_region); - const num_var_result = try self.freshFromContent(num_content, expr_region); + // Otherwise, this is dot access on a record - // Unify lhs, rhs, and result with the number type - _ = try self.unify(num_var_lhs, lhs_var); - _ = try self.unify(num_var_rhs, rhs_var); - _ = try self.unify(result_var, num_var_result); + // Create a type for the inferred type of this record access + // E.g. foo.bar -> { bar: flex } a + const record_field_var = try self.fresh(rank, expr_region); + const record_field_range = try self.types.appendRecordFields(&.{types_mod.RecordField{ + .name = dot_access.field_name, + .var_ = record_field_var, + }}); + const record_being_accessed = try self.freshFromContent(.{ .structure = .{ + .record_unbound = record_field_range, + } }, rank, expr_region); + + // Then, unify the actual receiver type with the expected record + _ = try self.unify(record_being_accessed, receiver_var, rank); + try self.types.setVarRedirect(expr_var, record_field_var); } - - return does_fx; }, - .lt, .gt, .le, .ge, .eq, .ne => { - // Check operands first - var does_fx = try self.checkExpr(binop.lhs); - does_fx = try self.checkExpr(binop.rhs) or does_fx; - - // For equality/comparison, operands must be the same type - const lhs_var = @as(Var, @enumFromInt(@intFromEnum(binop.lhs))); - const rhs_var = @as(Var, @enumFromInt(@intFromEnum(binop.rhs))); - _ = try self.unify(lhs_var, rhs_var); - - // Comparison operators always return Bool - const expr_var = @as(Var, @enumFromInt(@intFromEnum(expr_idx))); - const fresh_bool = try self.instantiateVarAnon(ModuleEnv.varFrom(can.Can.BUILTIN_BOOL_TYPE), .{ .explicit = expr_region }); - _ = try self.unify(expr_var, fresh_bool); - - return does_fx; + .e_crash => { + try self.updateVar(expr_var, .{ .flex = Flex.init() }, rank); }, - .@"and" => { - var does_fx = try self.checkExpr(binop.lhs); - does_fx = try self.checkExpr(binop.rhs) or does_fx; - - const lhs_fresh_bool = try self.instantiateVarAnon(ModuleEnv.varFrom(can.Can.BUILTIN_BOOL_TYPE), .{ .explicit = expr_region }); - const lhs_result = try self.unify(lhs_fresh_bool, @enumFromInt(@intFromEnum(binop.lhs))); - self.setDetailIfTypeMismatch(lhs_result, .{ .invalid_bool_binop = .{ - .binop_expr = expr_idx, - .problem_side = .lhs, - .binop = .@"and", - } }); - - if (lhs_result.isOk()) { - const rhs_fresh_bool = try self.instantiateVarAnon(ModuleEnv.varFrom(can.Can.BUILTIN_BOOL_TYPE), .{ .explicit = expr_region }); - const rhs_result = try self.unify(rhs_fresh_bool, @enumFromInt(@intFromEnum(binop.rhs))); - self.setDetailIfTypeMismatch(rhs_result, .{ .invalid_bool_binop = .{ - .binop_expr = expr_idx, - .problem_side = .rhs, - .binop = .@"and", - } }); - } - - return does_fx; + .e_dbg => |dbg| { + does_fx = try self.checkExpr(dbg.expr, rank, expected) or does_fx; + _ = try self.types.setVarRedirect(expr_var, ModuleEnv.varFrom(dbg.expr)); }, - .@"or" => { - var does_fx = try self.checkExpr(binop.lhs); - does_fx = try self.checkExpr(binop.rhs) or does_fx; - - const lhs_fresh_bool = try self.instantiateVarAnon(ModuleEnv.varFrom(can.Can.BUILTIN_BOOL_TYPE), .{ .explicit = expr_region }); - const lhs_result = try self.unify(lhs_fresh_bool, @enumFromInt(@intFromEnum(binop.lhs))); - self.setDetailIfTypeMismatch(lhs_result, .{ .invalid_bool_binop = .{ - .binop_expr = expr_idx, - .problem_side = .lhs, - .binop = .@"or", - } }); - - if (lhs_result.isOk()) { - const rhs_fresh_bool = try self.instantiateVarAnon(ModuleEnv.varFrom(can.Can.BUILTIN_BOOL_TYPE), .{ .explicit = expr_region }); - const rhs_result = try self.unify(rhs_fresh_bool, @enumFromInt(@intFromEnum(binop.rhs))); - self.setDetailIfTypeMismatch(rhs_result, .{ .invalid_bool_binop = .{ - .binop_expr = expr_idx, - .problem_side = .rhs, - .binop = .@"or", - } }); - } - - return does_fx; + .e_expect => |expect| { + does_fx = try self.checkExpr(expect.body, rank, expected) or does_fx; + try self.updateVar(expr_var, .{ .structure = .empty_record }, rank); }, - .pipe_forward => { - var does_fx = try self.checkExpr(binop.lhs); - does_fx = try self.checkExpr(binop.rhs) or does_fx; - return does_fx; + .e_ellipsis => { + try self.updateVar(expr_var, .{ .flex = Flex.init() }, rank); }, - .null_coalesce => { - var does_fx = try self.checkExpr(binop.lhs); - does_fx = try self.checkExpr(binop.rhs) or does_fx; - return does_fx; + .e_runtime_error => { + try self.updateVar(expr_var, .err, rank); }, } -} -fn checkUnaryMinusExpr(self: *Self, expr_idx: CIR.Expr.Idx, expr_region: Region, unary: CIR.Expr.UnaryMinus) Allocator.Error!bool { - const trace = tracy.trace(@src()); - defer trace.end(); - - // Check the operand expression - const does_fx = try self.checkExpr(unary.expr); - - // For unary minus, we constrain the operand and result to be numbers - const operand_var = @as(Var, @enumFromInt(@intFromEnum(unary.expr))); - const result_var = @as(Var, @enumFromInt(@intFromEnum(expr_idx))); - - // Create a fresh number variable for the operation - const num_content = Content{ .structure = .{ .num = .{ .num_unbound = .{ .sign_needed = true, .bits_needed = 0 } } } }; - const num_var = try self.freshFromContent(num_content, expr_region); - - // Unify operand and result with the number type - _ = try self.unify(operand_var, num_var); - _ = try self.unify(result_var, num_var); - - return does_fx; -} - -fn checkUnaryNotExpr(self: *Self, expr_idx: CIR.Expr.Idx, expr_region: Region, unary: CIR.Expr.UnaryNot) Allocator.Error!bool { - const trace = tracy.trace(@src()); - defer trace.end(); - - // Check the operand expression - const does_fx = try self.checkExpr(unary.expr); - - // For unary not, we constrain the operand and result to be booleans - const operand_var = @as(Var, @enumFromInt(@intFromEnum(unary.expr))); - const result_var = @as(Var, @enumFromInt(@intFromEnum(expr_idx))); - - // Create a fresh boolean variable for the operation - const bool_var = try self.instantiateVarAnon(ModuleEnv.varFrom(can.Can.BUILTIN_BOOL_TYPE), .{ .explicit = expr_region }); - - // Unify operand and result with the boolean type - _ = try self.unify(operand_var, bool_var); - _ = try self.unify(result_var, bool_var); - - return does_fx; -} - -// nominal // - -// nominal // - -/// Check that a nominal type constructor usage is valid and perform type inference. -/// -/// This function validates that a user's constructor application (like `Maybe.Just(1)`) -/// is compatible with the nominal type's definition and infers the concrete types. -/// -/// Example: -/// Maybe a := [Just(a), None] -/// val = Maybe.Just(1) // This call validates Just(1) against Maybe's definition -/// -/// Parameters: -/// * `node_var` - Variable representing the entire expression (initially a placeholder). -/// This will be redirected to the final inferred type. -/// * `node_region` - Source region of the entire expression for error reporting -/// * `node_backing_var` - Variable for the constructor application's internal type (e.g., `Just(1)`) -/// * `node_backing_type` - Kind of nominal backing (tag, record, tuple, or val) -/// * `real_nominal_var` - Variable of the nominal type declaration (e.g., `Maybe a`) -fn checkNominal( - self: *Self, - node_var: Var, - node_region: Region, - node_backing_var: Var, - node_backing_type: CIR.Expr.NominalBackingType, - real_nominal_var: Var, -) Allocator.Error!void { - // Clear the rigid variable substitution map to ensure fresh instantiation - self.anonymous_rigid_var_subs.items.clearRetainingCapacity(); - - // Algorithm overview: - // 1. Validate that the nominal type exists and is well-formed - // 2. Instantiate the nominal type's backing type with fresh variables - // 3. Unify the instantiated backing type against the user's constructor - // 4. If unification succeeds, instantiate the nominal type and assign to node_var - // 5. If unification fails, report appropriate error and mark node_var as error - // - // The key insight is using a shared rigid variable map so that type parameters - // in the backing type and nominal type get the same substitutions. - - // Step 1: Extract and validate the nominal type - const nominal_content = self.types.resolveVar(real_nominal_var).desc.content; - const nominal_type = switch (nominal_content) { - .structure => |structure| switch (structure) { - .nominal_type => |nt| nt, - else => { - // The supposed nominal type is actually some other structure - try self.types.setVarContent(node_var, .err); - return; - }, - }, - else => { - // The nominal type is in an error state or unresolved - try self.types.setVarContent(node_var, .err); - return; - }, - }; - - // Step 2: Instantiate the nominal type's backing type - // This converts rigid type variables (like `a[r]`) to fresh flexible variables - // that can be unified. The backing type defines the structure (e.g., [Just(a), None]) - const nominal_backing_var = self.types.getNominalBackingVar(nominal_type); - const instantiated_backing_var = try self.instantiateVar( - nominal_backing_var, - &self.anonymous_rigid_var_subs, - .{ .explicit = node_region }, - ); - - // TODO: If we can, unify arguments directly to get better error messages - // Unifying by the whole thing works, but doesn't have great error messages - // always - - // Step 3: Unify the instantiated backing type with the user's constructor - // This checks if `Just(1)` is compatible with `[Just(a), None]` and if so, - // unifies `a` with the type of `1` (e.g., Num(_size)) - const result = try self.unify(instantiated_backing_var, node_backing_var); - - // Step 4: Handle the unification result - switch (result) { - .ok => { - // Unification succeeded - the constructor is valid for this nominal type - // Now instantiate the full nominal type using the same rigid variable map - // so it gets the same type substitutions as the backing type - const instantiated_qualified_var = try self.instantiateVar( - real_nominal_var, - &self.anonymous_rigid_var_subs, - .{ .explicit = node_region }, - ); - - // Assign the inferred concrete type to the expression variable - // After this, `node_var` will resolve to something like `Maybe(Num(_size))` - try self.types.setVarRedirect(node_var, instantiated_qualified_var); - }, - .problem => |problem_idx| { - // Unification failed - the constructor is incompatible with the nominal type - // Set a specific error message based on the backing type kind - switch (node_backing_type) { - .tag => { - // Constructor doesn't exist or has wrong arity/types - self.setProblemTypeMismatchDetail(problem_idx, .invalid_nominal_tag); - }, - else => { - // TODO: Add specific error messages for records, tuples, etc. - }, + // If we were provided with an expected type, unify against it + switch (expected) { + .no_expectation => {}, + .expected => |expected_type| { + if (expected_type.from_annotation) { + _ = try self.unifyFromAnno(expected_type.var_, expr_var, rank); + } else { + _ = try self.unify(expected_type.var_, expr_var, rank); } - - // Mark the entire expression as having a type error - try self.types.setVarContent(node_var, .err); }, } + + return does_fx; } // if-else // @@ -2059,7 +2769,8 @@ fn checkIfElseExpr( self: *Self, if_expr_idx: CIR.Expr.Idx, expr_region: Region, - if_: @FieldType(CIR.Expr, "e_if"), + rank: types_mod.Rank, + if_: std.meta.FieldType(CIR.Expr, .e_if), ) std.mem.Allocator.Error!bool { const trace = tracy.trace(@src()); defer trace.end(); @@ -2074,36 +2785,38 @@ fn checkIfElseExpr( const first_branch = self.cir.store.getIfBranch(first_branch_idx); // Check the condition of the 1st branch - var does_fx = try self.checkExpr(first_branch.cond); - const first_cond_var: Var = @enumFromInt(@intFromEnum(first_branch.cond)); - const bool_var = try self.instantiateVarAnon(ModuleEnv.varFrom(can.Can.BUILTIN_BOOL_TYPE), .{ .explicit = expr_region }); - const first_cond_result = try self.unify(bool_var, first_cond_var); + var does_fx = try self.checkExpr(first_branch.cond, rank, .no_expectation); + const first_cond_var: Var = ModuleEnv.varFrom(first_branch.cond); + const bool_var = try self.freshBool(rank, expr_region); + const first_cond_result = try self.unify(bool_var, first_cond_var, rank); self.setDetailIfTypeMismatch(first_cond_result, .incompatible_if_cond); // Then we check the 1st branch's body - does_fx = try self.checkExpr(first_branch.body) or does_fx; + does_fx = try self.checkExpr(first_branch.body, rank, .no_expectation) or does_fx; // The 1st branch's body is the type all other branches must match - const branch_var = @as(Var, @enumFromInt(@intFromEnum(first_branch.body))); + const branch_var = @as(Var, ModuleEnv.varFrom(first_branch.body)); // Total number of branches (including final else) const num_branches: u32 = @intCast(branches.len + 1); var last_if_branch = first_branch_idx; for (branches[1..], 1..) |branch_idx, cur_index| { + // TODO: Each branch body get it's own rank?? + const branch = self.cir.store.getIfBranch(branch_idx); // Check the branches condition - does_fx = try self.checkExpr(branch.cond) or does_fx; - const cond_var: Var = @enumFromInt(@intFromEnum(branch.cond)); - const branch_bool_var = try self.instantiateVarAnon(ModuleEnv.varFrom(can.Can.BUILTIN_BOOL_TYPE), .{ .explicit = expr_region }); - const cond_result = try self.unify(branch_bool_var, cond_var); + does_fx = try self.checkExpr(branch.cond, rank, .no_expectation) or does_fx; + const cond_var: Var = ModuleEnv.varFrom(branch.cond); + const branch_bool_var = try self.freshBool(rank, expr_region); + const cond_result = try self.unify(branch_bool_var, cond_var, rank); self.setDetailIfTypeMismatch(cond_result, .incompatible_if_cond); // Check the branch body - does_fx = try self.checkExpr(branch.body) or does_fx; - const body_var: Var = @enumFromInt(@intFromEnum(branch.body)); - const body_result = try self.unify(branch_var, body_var); + does_fx = try self.checkExpr(branch.body, rank, .no_expectation) or does_fx; + const body_var: Var = ModuleEnv.varFrom(branch.body); + const body_result = try self.unify(branch_var, body_var, rank); self.setDetailIfTypeMismatch(body_result, problem.TypeMismatchDetail{ .incompatible_if_branches = .{ .parent_if_expr = if_expr_idx, .last_if_branch = last_if_branch, @@ -2116,15 +2829,15 @@ fn checkIfElseExpr( for (branches[cur_index + 1 ..]) |remaining_branch_idx| { const remaining_branch = self.cir.store.getIfBranch(remaining_branch_idx); - does_fx = try self.checkExpr(remaining_branch.cond) or does_fx; - const remaining_cond_var: Var = @enumFromInt(@intFromEnum(remaining_branch.cond)); + does_fx = try self.checkExpr(remaining_branch.cond, rank, .no_expectation) or does_fx; + const remaining_cond_var: Var = ModuleEnv.varFrom(remaining_branch.cond); - const fresh_bool = try self.instantiateVarAnon(ModuleEnv.varFrom(can.Can.BUILTIN_BOOL_TYPE), .{ .explicit = expr_region }); - const remaining_cond_result = try self.unify(fresh_bool, remaining_cond_var); + const fresh_bool = try self.freshBool(rank, expr_region); + const remaining_cond_result = try self.unify(fresh_bool, remaining_cond_var, rank); self.setDetailIfTypeMismatch(remaining_cond_result, .incompatible_if_cond); - does_fx = try self.checkExpr(remaining_branch.body) or does_fx; - try self.types.setVarContent(@enumFromInt(@intFromEnum(remaining_branch.body)), .err); + does_fx = try self.checkExpr(remaining_branch.body, rank, .no_expectation) or does_fx; + try self.types.setVarContent(ModuleEnv.varFrom(remaining_branch.body), .err); } // Break to avoid cascading errors @@ -2135,9 +2848,9 @@ fn checkIfElseExpr( } // Check the final else - does_fx = try self.checkExpr(if_.final_else) or does_fx; - const final_else_var: Var = @enumFromInt(@intFromEnum(if_.final_else)); - const final_else_result = try self.unify(branch_var, final_else_var); + does_fx = try self.checkExpr(if_.final_else, rank, .no_expectation) or does_fx; + const final_else_var: Var = ModuleEnv.varFrom(if_.final_else); + const final_else_result = try self.unify(branch_var, final_else_var, rank); self.setDetailIfTypeMismatch(final_else_result, problem.TypeMismatchDetail{ .incompatible_if_branches = .{ .parent_if_expr = if_expr_idx, .last_if_branch = last_if_branch, @@ -2145,9 +2858,9 @@ fn checkIfElseExpr( .problem_branch_index = num_branches - 1, } }); - // Unify the if expression's type variable with the branch type - const if_expr_var: Var = @enumFromInt(@intFromEnum(if_expr_idx)); - _ = try self.unify(if_expr_var, branch_var); + // Set the entire expr's type to be the type of the branch + const if_expr_var: Var = ModuleEnv.varFrom(if_expr_idx); + try self.types.setVarRedirect(if_expr_var, branch_var); return does_fx; } @@ -2155,17 +2868,16 @@ fn checkIfElseExpr( // match // /// Check the types for an if-else expr -fn checkMatchExpr(self: *Self, expr_idx: CIR.Expr.Idx, match: CIR.Expr.Match) Allocator.Error!bool { +fn checkMatchExpr(self: *Self, expr_idx: CIR.Expr.Idx, rank: Rank, match: CIR.Expr.Match) Allocator.Error!bool { const trace = tracy.trace(@src()); defer trace.end(); // Check the match's condition - var does_fx = try self.checkExpr(match.cond); + var does_fx = try self.checkExpr(match.cond, rank, .no_expectation); const cond_var = ModuleEnv.varFrom(match.cond); - // Bail if we somehow have 0 branches - // TODO: Should this be an error? Here or in Can? - if (match.branches.span.len == 0) return does_fx; + // Assert we have at least 1 branch + std.debug.assert(match.branches.span.len > 0); // Get slice of branches const branch_idxs = self.cir.store.sliceMatchBranches(match.branches); @@ -2178,23 +2890,19 @@ fn checkMatchExpr(self: *Self, expr_idx: CIR.Expr.Idx, match: CIR.Expr.Match) Al const first_branch_ptrn_idxs = self.cir.store.sliceMatchBranchPatterns(first_branch.patterns); - for (first_branch_ptrn_idxs, 0..) |branch_ptrn_idx, cur_ptrn_index| { + for (first_branch_ptrn_idxs) |branch_ptrn_idx| { const branch_ptrn = self.cir.store.getMatchBranchPattern(branch_ptrn_idx); - try self.checkPattern(branch_ptrn.pattern); + try self.checkPattern(branch_ptrn.pattern, rank, .no_expectation); const branch_ptrn_var = ModuleEnv.varFrom(branch_ptrn.pattern); - const ptrn_result = try self.unify(cond_var, branch_ptrn_var); - self.setDetailIfTypeMismatch(ptrn_result, problem.TypeMismatchDetail{ .incompatible_match_patterns = .{ + const ptrn_result = try self.unify(cond_var, branch_ptrn_var, rank); + self.setDetailIfTypeMismatch(ptrn_result, problem.TypeMismatchDetail{ .incompatible_match_cond_pattern = .{ .match_expr = expr_idx, - .num_branches = @intCast(match.branches.span.len), - .problem_branch_index = 0, - .num_patterns = @intCast(first_branch_ptrn_idxs.len), - .problem_pattern_index = @intCast(cur_ptrn_index), } }); } // Check the first branch's value, then use that at the branch_var - does_fx = try self.checkExpr(first_branch.value) or does_fx; + does_fx = try self.checkExpr(first_branch.value, rank, .no_expectation) or does_fx; const branch_var = ModuleEnv.varFrom(first_branch.value); // Then iterate over the rest of the branches @@ -2206,11 +2914,11 @@ fn checkMatchExpr(self: *Self, expr_idx: CIR.Expr.Idx, match: CIR.Expr.Match) Al for (branch_ptrn_idxs, 0..) |branch_ptrn_idx, cur_ptrn_index| { // Check the pattern's sub types const branch_ptrn = self.cir.store.getMatchBranchPattern(branch_ptrn_idx); - try self.checkPattern(branch_ptrn.pattern); + try self.checkPattern(branch_ptrn.pattern, rank, .no_expectation); // Check the pattern against the cond const branch_ptrn_var = ModuleEnv.varFrom(branch_ptrn.pattern); - const ptrn_result = try self.unify(cond_var, branch_ptrn_var); + const ptrn_result = try self.unify(cond_var, branch_ptrn_var, rank); self.setDetailIfTypeMismatch(ptrn_result, problem.TypeMismatchDetail{ .incompatible_match_patterns = .{ .match_expr = expr_idx, .num_branches = @intCast(match.branches.span.len), @@ -2221,8 +2929,8 @@ fn checkMatchExpr(self: *Self, expr_idx: CIR.Expr.Idx, match: CIR.Expr.Match) Al } // Then, check the body - does_fx = try self.checkExpr(branch.value) or does_fx; - const branch_result = try self.unify(branch_var, ModuleEnv.varFrom(branch.value)); + does_fx = try self.checkExpr(branch.value, rank, .no_expectation) or does_fx; + const branch_result = try self.unify(branch_var, ModuleEnv.varFrom(branch.value), rank); self.setDetailIfTypeMismatch(branch_result, problem.TypeMismatchDetail{ .incompatible_match_branches = .{ .match_expr = expr_idx, .num_branches = @intCast(match.branches.span.len), @@ -2240,11 +2948,11 @@ fn checkMatchExpr(self: *Self, expr_idx: CIR.Expr.Idx, match: CIR.Expr.Match) Al for (other_branch_ptrn_idxs, 0..) |other_branch_ptrn_idx, other_cur_ptrn_index| { // Check the pattern's sub types const other_branch_ptrn = self.cir.store.getMatchBranchPattern(other_branch_ptrn_idx); - try self.checkPattern(other_branch_ptrn.pattern); + try self.checkPattern(other_branch_ptrn.pattern, rank, .no_expectation); // Check the pattern against the cond const other_branch_ptrn_var = ModuleEnv.varFrom(other_branch_ptrn.pattern); - const ptrn_result = try self.unify(cond_var, other_branch_ptrn_var); + const ptrn_result = try self.unify(cond_var, other_branch_ptrn_var, rank); self.setDetailIfTypeMismatch(ptrn_result, problem.TypeMismatchDetail{ .incompatible_match_patterns = .{ .match_expr = expr_idx, .num_branches = @intCast(match.branches.span.len), @@ -2255,7 +2963,7 @@ fn checkMatchExpr(self: *Self, expr_idx: CIR.Expr.Idx, match: CIR.Expr.Match) Al } // Then check the other branch's exprs - does_fx = try self.checkExpr(other_branch.value) or does_fx; + does_fx = try self.checkExpr(other_branch.value, rank, .no_expectation) or does_fx; try self.types.setVarContent(ModuleEnv.varFrom(other_branch.value), .err); } @@ -2267,6 +2975,196 @@ fn checkMatchExpr(self: *Self, expr_idx: CIR.Expr.Idx, match: CIR.Expr.Match) Al return does_fx; } +// unary minus // + +fn checkUnaryMinusExpr(self: *Self, expr_idx: CIR.Expr.Idx, expr_region: Region, rank: Rank, unary: CIR.Expr.UnaryMinus) Allocator.Error!bool { + const trace = tracy.trace(@src()); + defer trace.end(); + + // Check the operand expression + const does_fx = try self.checkExpr(unary.expr, rank, .no_expectation); + + // For unary minus, we constrain the operand and result to be numbers + const operand_var = @as(Var, ModuleEnv.varFrom(unary.expr)); + const result_var = @as(Var, ModuleEnv.varFrom(expr_idx)); + + // Create a fresh number variable for the operation + const num_content = Content{ .structure = .{ .num = .{ + .num_unbound = .{ + .int_requirements = Num.IntRequirements.init(), + .frac_requirements = Num.FracRequirements.init(), + }, + } } }; + const num_var = try self.freshFromContent(num_content, rank, expr_region); + + // Unify operand and result with the number type + _ = try self.unify(num_var, operand_var, rank); + _ = try self.unify(num_var, result_var, rank); + + return does_fx; +} + +// unary not // + +fn checkUnaryNotExpr(self: *Self, expr_idx: CIR.Expr.Idx, expr_region: Region, rank: Rank, unary: CIR.Expr.UnaryNot) Allocator.Error!bool { + const trace = tracy.trace(@src()); + defer trace.end(); + + // Check the operand expression + const does_fx = try self.checkExpr(unary.expr, rank, .no_expectation); + + // For unary not, we constrain the operand and result to be booleans + const operand_var = @as(Var, ModuleEnv.varFrom(unary.expr)); + const result_var = @as(Var, ModuleEnv.varFrom(expr_idx)); + + // Create a fresh boolean variable for the operation + const bool_var = try self.freshBool(rank, expr_region); + + // Unify operand and result with the boolean type + _ = try self.unify(bool_var, operand_var, rank); + _ = try self.unify(bool_var, result_var, rank); + + return does_fx; +} + +// binop // + +/// Check the types for a binary operation expression +fn checkBinopExpr( + self: *Self, + expr_idx: CIR.Expr.Idx, + expr_region: Region, + rank: Rank, + binop: CIR.Expr.Binop, + expected: Expected, +) Allocator.Error!bool { + const trace = tracy.trace(@src()); + defer trace.end(); + + const expr_var = ModuleEnv.varFrom(expr_idx); + const lhs_var = @as(Var, ModuleEnv.varFrom(binop.lhs)); + const rhs_var = @as(Var, ModuleEnv.varFrom(binop.rhs)); + + // Check operands first + var does_fx = false; + does_fx = try self.checkExpr(binop.lhs, rank, .no_expectation) or does_fx; + does_fx = try self.checkExpr(binop.rhs, rank, .no_expectation) or does_fx; + + switch (binop.op) { + .add, .sub, .mul, .div, .rem, .pow, .div_trunc => { + // For now, we'll constrain both operands to be numbers + // In the future, this will use static dispatch based on the lhs type + + // We check the lhs and the rhs independently, then unify them with + // each other. This ensures that all errors are surfaced and the + // operands are the same type + switch (expected) { + .expected => |expectation| { + const lhs_instantiated = try self.instantiateVar(expectation.var_, rank, .{ .explicit = expr_region }); + const rhs_instantiated = try self.instantiateVar(expectation.var_, rank, .{ .explicit = expr_region }); + + if (expectation.from_annotation) { + _ = try self.unifyFromAnno(lhs_instantiated, lhs_var, rank); + _ = try self.unifyFromAnno(rhs_instantiated, rhs_var, rank); + } else { + _ = try self.unify(lhs_instantiated, lhs_var, rank); + _ = try self.unify(rhs_instantiated, rhs_var, rank); + } + }, + .no_expectation => { + // Start with empty requirements that can be constrained by operands + const num_content = Content{ .structure = .{ .num = .{ + .num_unbound = .{ + .int_requirements = Num.IntRequirements.init(), + .frac_requirements = Num.FracRequirements.init(), + }, + } } }; + const lhs_num_var = try self.freshFromContent(num_content, rank, expr_region); + const rhs_num_var = try self.freshFromContent(num_content, rank, expr_region); + + // Unify left and right operands with num + _ = try self.unify(lhs_num_var, lhs_var, rank); + _ = try self.unify(rhs_num_var, rhs_var, rank); + }, + } + + // Unify left and right together + _ = try self.unify(lhs_var, rhs_var, rank); + + // Set root expr. If unifications succeeded this will the the + // num, otherwise the propgate error + try self.types.setVarRedirect(expr_var, lhs_var); + }, + .lt, .gt, .le, .ge, .eq, .ne => { + // Ensure the operands are the same type + const result = try self.unify(lhs_var, rhs_var, rank); + + if (result.isOk()) { + const fresh_bool = try self.freshBool(rank, expr_region); + try self.types.setVarRedirect(expr_var, fresh_bool); + } else { + try self.updateVar(expr_var, .err, rank); + } + }, + .@"and" => { + const lhs_fresh_bool = try self.freshBool(rank, expr_region); + const lhs_result = try self.unify(lhs_fresh_bool, lhs_var, rank); + self.setDetailIfTypeMismatch(lhs_result, .{ .invalid_bool_binop = .{ + .binop_expr = expr_idx, + .problem_side = .lhs, + .binop = .@"and", + } }); + + const rhs_fresh_bool = try self.freshBool(rank, expr_region); + const rhs_result = try self.unify(rhs_fresh_bool, rhs_var, rank); + self.setDetailIfTypeMismatch(rhs_result, .{ .invalid_bool_binop = .{ + .binop_expr = expr_idx, + .problem_side = .rhs, + .binop = .@"and", + } }); + + // Unify left and right together + _ = try self.unify(lhs_var, rhs_var, rank); + + // Set root expr. If unifications succeeded this will the the + // num, otherwise the propgate error + try self.types.setVarRedirect(expr_var, lhs_var); + }, + .@"or" => { + const lhs_fresh_bool = try self.freshBool(rank, expr_region); + const lhs_result = try self.unify(lhs_fresh_bool, lhs_var, rank); + self.setDetailIfTypeMismatch(lhs_result, .{ .invalid_bool_binop = .{ + .binop_expr = expr_idx, + .problem_side = .lhs, + .binop = .@"and", + } }); + + const rhs_fresh_bool = try self.freshBool(rank, expr_region); + const rhs_result = try self.unify(rhs_fresh_bool, rhs_var, rank); + self.setDetailIfTypeMismatch(rhs_result, .{ .invalid_bool_binop = .{ + .binop_expr = expr_idx, + .problem_side = .rhs, + .binop = .@"and", + } }); + + // Unify left and right together + _ = try self.unify(lhs_var, rhs_var, rank); + + // Set root expr. If unifications succeeded this will the the + // num, otherwise the propagate error + try self.types.setVarRedirect(expr_var, lhs_var); + }, + .pipe_forward => { + // TODO + }, + .null_coalesce => { + // TODO + }, + } + + return does_fx; +} + // problems // /// If the provided result is a type mismatch problem, append the detail to the @@ -2830,3 +3728,162 @@ fn setProblemTypeMismatchDetail(self: *Self, problem_idx: problem.Problem.Idx, m // } // } // } + +// instantiate - OLD // + +// const RigidVarBehavior = union(enum) { +// use_cached_rigid_vars, +// rollback_rigid_vars, +// }; + +// /// Instantiate a variable +// fn instantiateVar( +// self: *Self, +// var_to_instantiate: Var, +// rigid_to_flex_subs: *Instantiate.RigidSubstitutions, +// region_behavior: InstantiateRegionBehavior, +// ) std.mem.Allocator.Error!Var { +// self.var_map.clearRetainingCapacity(); + +// var instantiate = Instantiate.init(self.types, self.cir.getIdentStore(), &self.var_map); +// var instantiate_ctx = Instantiate.Ctx{ +// .rigid_var_subs = rigid_to_flex_subs, +// }; +// const instantiated_var = try instantiate.instantiateVar(var_to_instantiate, &instantiate_ctx); + +// // If we had to insert any new type variables, ensure that we have +// // corresponding regions for them. This is essential for error reporting. +// const root_instantiated_region = self.regions.get(@enumFromInt(@intFromEnum(var_to_instantiate))).*; +// if (self.var_map.count() > 0) { +// var iterator = self.var_map.iterator(); +// while (iterator.next()) |x| { +// // Get the newly created var +// const fresh_var = x.value_ptr.*; +// try self.fillInRegionsThrough(fresh_var); + +// switch (region_behavior) { +// .explicit => |region| { +// self.setRegionAt(fresh_var, region); +// }, +// .use_root_instantiated => { +// self.setRegionAt(fresh_var, root_instantiated_region); +// }, +// .use_last_var => { +// const old_var = x.key_ptr.*; +// const old_region = self.regions.get(@enumFromInt(@intFromEnum(old_var))).*; +// self.setRegionAt(fresh_var, old_region); +// }, +// } +// } +// } + +// // Assert that we have regions for every type variable +// self.debugAssertArraysInSync(); + +// return instantiated_var; +// } + +// /// Instantiate a variable +// fn instantiateVarAnon( +// self: *Self, +// var_to_instantiate: Var, +// region_behavior: InstantiateRegionBehavior, +// ) std.mem.Allocator.Error!Var { +// self.anonymous_rigid_var_subs.items.clearRetainingCapacity(); +// const var_ = self.instantiateVar(var_to_instantiate, &self.anonymous_rigid_var_subs, region_behavior); +// return var_; +// } + +// copy type from other module // + +// external type lookups // + +const ExternalType = struct { + local_var: Var, + other_cir_node_idx: CIR.Node.Idx, + other_cir: *const ModuleEnv, +}; + +/// Copy a variable from a different module into this module's types store. +/// +/// IMPORTANT: The caller must instantiate this variable before unifing +/// against it. This avoid poisoning the copied variable in the types store if +/// unification fails. +fn resolveVarFromExternal( + self: *Self, + module_idx: CIR.Import.Idx, + node_idx: u16, +) std.mem.Allocator.Error!?ExternalType { + const module_idx_int = @intFromEnum(module_idx); + if (module_idx_int < self.other_modules.len) { + const other_module_cir = self.other_modules[module_idx_int]; + const other_module_env = other_module_cir; + + // The idx of the expression in the other module + const target_node_idx = @as(CIR.Node.Idx, @enumFromInt(node_idx)); + + // Check if we've already copied this import + const cache_key = ImportCacheKey{ + .module_idx = module_idx, + .node_idx = target_node_idx, + }; + + const copied_var = if (self.import_cache.get(cache_key)) |cached_var| + // Reuse the previously copied type. + cached_var + else blk: { + // First time importing this type - copy it and cache the result + const imported_var = @as(Var, @enumFromInt(@intFromEnum(target_node_idx))); + const new_copy = try self.copyVar(imported_var, other_module_env); + try self.import_cache.put(self.gpa, cache_key, new_copy); + break :blk new_copy; + }; + + return .{ + .local_var = copied_var, + .other_cir_node_idx = target_node_idx, + .other_cir = other_module_env, + }; + } else { + return null; + } +} + +/// Instantiate a variable, writing su +fn copyVar( + self: *Self, + other_module_var: Var, + other_module_env: *const ModuleEnv, +) std.mem.Allocator.Error!Var { + // First, reset state + self.var_map.clearRetainingCapacity(); + + // Then, copy the var from the dest type store into this type store + const copied_var = try copy_import.copyVar( + &other_module_env.*.types, + self.types, + other_module_var, + &self.var_map, + other_module_env.getIdentStoreConst(), + self.cir.getIdentStore(), + self.gpa, + ); + + // If we had to insert any new type variables, ensure that we have + // corresponding regions for them. This is essential for error reporting. + if (self.var_map.count() > 0) { + var iterator = self.var_map.iterator(); + while (iterator.next()) |x| { + // Get the newly created var + const fresh_var = x.value_ptr.*; + try self.fillInRegionsThrough(fresh_var); + + self.setRegionAt(fresh_var, base.Region.zero()); + } + } + + // Assert that we have regions for every type variable + self.debugAssertArraysInSync(); + + return copied_var; +} diff --git a/src/check/copy_import.zig b/src/check/copy_import.zig index 65682752e7..4dbca7cbf2 100644 --- a/src/check/copy_import.zig +++ b/src/check/copy_import.zig @@ -55,7 +55,11 @@ pub fn copyVar( const dest_content = try copyContent(source_store, dest_store, resolved.desc.content, var_mapping, source_idents, dest_idents, allocator); // Update the placeholder with the actual content - try dest_store.setVarContent(placeholder_var, dest_content); + try dest_store.setVarDesc(placeholder_var, .{ + .content = dest_content, + .rank = types_mod.Rank.generalized, + .mark = types_mod.Mark.none, + }); return placeholder_var; } @@ -70,8 +74,8 @@ fn copyContent( allocator: std.mem.Allocator, ) std.mem.Allocator.Error!Content { return switch (content) { - .flex_var => |maybe_ident| Content{ .flex_var = maybe_ident }, - .rigid_var => |ident| Content{ .rigid_var = ident }, + .flex => |flex| Content{ .flex = flex }, + .rigid => |rigid| Content{ .rigid = rigid }, .alias => |alias| Content{ .alias = try copyAlias(source_store, dest_store, alias, var_mapping, source_idents, dest_idents, allocator) }, .structure => |flat_type| Content{ .structure = try copyFlatType(source_store, dest_store, flat_type, var_mapping, source_idents, dest_idents, allocator) }, .err => Content.err, @@ -136,11 +140,6 @@ fn copyFlatType( .record => |record| FlatType{ .record = try copyRecord(source_store, dest_store, record, var_mapping, source_idents, dest_idents, allocator) }, .tag_union => |tag_union| FlatType{ .tag_union = try copyTagUnion(source_store, dest_store, tag_union, var_mapping, source_idents, dest_idents, allocator) }, .record_unbound => |fields| FlatType{ .record_unbound = try copyRecordFields(source_store, dest_store, fields, var_mapping, source_idents, dest_idents, allocator) }, - .record_poly => |poly| blk: { - const dest_record = try copyRecord(source_store, dest_store, poly.record, var_mapping, source_idents, dest_idents, allocator); - const dest_var = try copyVar(source_store, dest_store, poly.var_, var_mapping, source_idents, dest_idents, allocator); - break :blk FlatType{ .record_poly = .{ .record = dest_record, .var_ = dest_var } }; - }, .empty_record => FlatType.empty_record, .empty_tag_union => FlatType.empty_tag_union, }; @@ -179,9 +178,9 @@ fn copyNum( allocator: std.mem.Allocator, ) std.mem.Allocator.Error!Num { return switch (num) { - .num_poly => |poly| Num{ .num_poly = .{ .var_ = try copyVar(source_store, dest_store, poly.var_, var_mapping, source_idents, dest_idents, allocator), .requirements = poly.requirements } }, - .int_poly => |poly| Num{ .int_poly = .{ .var_ = try copyVar(source_store, dest_store, poly.var_, var_mapping, source_idents, dest_idents, allocator), .requirements = poly.requirements } }, - .frac_poly => |poly| Num{ .frac_poly = .{ .var_ = try copyVar(source_store, dest_store, poly.var_, var_mapping, source_idents, dest_idents, allocator), .requirements = poly.requirements } }, + .num_poly => |poly_var| Num{ .num_poly = try copyVar(source_store, dest_store, poly_var, var_mapping, source_idents, dest_idents, allocator) }, + .int_poly => |poly_var| Num{ .int_poly = try copyVar(source_store, dest_store, poly_var, var_mapping, source_idents, dest_idents, allocator) }, + .frac_poly => |poly_var| Num{ .frac_poly = try copyVar(source_store, dest_store, poly_var, var_mapping, source_idents, dest_idents, allocator) }, .num_unbound => |unbound| Num{ .num_unbound = unbound }, .int_unbound => |unbound| Num{ .int_unbound = unbound }, .frac_unbound => |unbound| Num{ .frac_unbound = unbound }, diff --git a/src/check/mod.zig b/src/check/mod.zig index 6ed4d421b1..20e801eb5e 100644 --- a/src/check/mod.zig +++ b/src/check/mod.zig @@ -31,10 +31,14 @@ test "check tests" { std.testing.refAllDecls(@import("problem.zig")); std.testing.refAllDecls(@import("snapshot.zig")); std.testing.refAllDecls(@import("unify.zig")); + + std.testing.refAllDecls(@import("test/compiled_builtins_test.zig")); + std.testing.refAllDecls(@import("test/unify_test.zig")); std.testing.refAllDecls(@import("test/cross_module_test.zig")); - std.testing.refAllDecls(@import("test/let_polymorphism_integration_test.zig")); - std.testing.refAllDecls(@import("test/let_polymorphism_test.zig")); - std.testing.refAllDecls(@import("test/literal_size_test.zig")); + std.testing.refAllDecls(@import("test/type_checking_integration.zig")); std.testing.refAllDecls(@import("test/nominal_type_origin_test.zig")); std.testing.refAllDecls(@import("test/static_dispatch_test.zig")); + std.testing.refAllDecls(@import("test/let_polymorphism_integration_test.zig")); + std.testing.refAllDecls(@import("test/num_type_inference_test.zig")); + std.testing.refAllDecls(@import("test/num_type_requirements_test.zig")); } diff --git a/src/check/occurs.zig b/src/check/occurs.zig index 6e7e4d0165..3cfa3e17cd 100644 --- a/src/check/occurs.zig +++ b/src/check/occurs.zig @@ -209,12 +209,6 @@ const CheckOccurs = struct { const fields_slice = self.types_store.getRecordFieldsSlice(fields); try self.occursSubVars(root, fields_slice.items(.var_), ctx.allowRecursion()); }, - .record_poly => |poly| { - const fields = self.types_store.getRecordFieldsSlice(poly.record.fields); - try self.occursSubVars(root, fields.items(.var_), ctx.allowRecursion()); - try self.occursSubVar(root, poly.record.ext, ctx); - try self.occursSubVar(root, poly.var_, ctx); - }, .tag_union => |tag_union| { const tags = self.types_store.getTagsSlice(tag_union.tags); for (tags.items(.args)) |tag_args| { @@ -236,8 +230,8 @@ const CheckOccurs = struct { const backing_var = self.types_store.getAliasBackingVar(alias); try self.occursSubVar(root, backing_var, ctx); }, - .flex_var => {}, - .rigid_var => {}, + .flex => {}, + .rigid => {}, .err => {}, } self.scratch.popSeen(); diff --git a/src/check/problem.zig b/src/check/problem.zig index a4e7f38505..e3e1fad730 100644 --- a/src/check/problem.zig +++ b/src/check/problem.zig @@ -96,6 +96,7 @@ pub const TypeMismatchDetail = union(enum) { incompatible_list_elements: IncompatibleListElements, incompatible_if_cond, incompatible_if_branches: IncompatibleIfBranches, + incompatible_match_cond_pattern: IncompatibleMatchCondPattern, incompatible_match_patterns: IncompatibleMatchPatterns, incompatible_match_branches: IncompatibleMatchBranches, invalid_bool_binop: InvalidBoolBinop, @@ -107,7 +108,7 @@ pub const TypeMismatchDetail = union(enum) { /// Problem data for when list elements have incompatible types pub const IncompatibleListElements = struct { - last_elem_expr: CIR.Expr.Idx, + last_elem_idx: CIR.Node.Idx, incompatible_elem_index: u32, // 0-based index of the incompatible element list_length: u32, // Total number of elements in the list }; @@ -144,6 +145,11 @@ pub const IncompatibleIfBranches = struct { problem_branch_index: u32, }; +/// Problem data for when match expression type is incompatible from the patterns +pub const IncompatibleMatchCondPattern = struct { + match_expr: CIR.Expr.Idx, +}; + /// Problem data for when match patterns have have incompatible types pub const IncompatibleMatchPatterns = struct { match_expr: CIR.Expr.Idx, @@ -173,7 +179,7 @@ pub const InvalidBoolBinop = struct { /// an annotation pub const TypeApplyArityMismatch = struct { type_name: base.Ident.Idx, - anno_var: Var, + region: base.Region, num_expected_args: u32, num_actual_args: u32, }; @@ -195,7 +201,8 @@ pub const ReportBuilder = struct { const Self = @This(); gpa: Allocator, - buf: std.array_list.Managed(u8), + snapshot_writer: snapshot.SnapshotWriter, + bytes_buf: std.array_list.Managed(u8), module_env: *ModuleEnv, can_ir: *const ModuleEnv, snapshots: *const snapshot.Store, @@ -215,7 +222,8 @@ pub const ReportBuilder = struct { ) Self { return .{ .gpa = gpa, - .buf = std.array_list.Managed(u8).init(gpa), + .snapshot_writer = snapshot.SnapshotWriter.init(gpa, snapshots, module_env.getIdentStore()), + .bytes_buf = std.array_list.Managed(u8).init(gpa), .module_env = module_env, .can_ir = can_ir, .snapshots = snapshots, @@ -228,7 +236,8 @@ pub const ReportBuilder = struct { /// Deinit report builder /// Only owned field is `buf` pub fn deinit(self: *Self) void { - self.buf.deinit(); + self.snapshot_writer.deinit(); + self.bytes_buf.deinit(); } /// Build a report for a problem @@ -239,69 +248,63 @@ pub const ReportBuilder = struct { const trace = tracy.trace(@src()); defer trace.end(); - var snapshot_writer = snapshot.SnapshotWriter.initWithContext( - self.buf.writer(), - self.snapshots, - self.module_env.getIdentStore(), - self.can_ir.module_name, - self.can_ir, - self.other_modules, - ); - switch (problem) { .type_mismatch => |mismatch| { if (mismatch.detail) |detail| { switch (detail) { .incompatible_list_elements => |data| { - return self.buildIncompatibleListElementsReport(&snapshot_writer, mismatch.types, data); + return self.buildIncompatibleListElementsReport(mismatch.types, data); }, .incompatible_if_cond => { - return self.buildInvalidIfCondition(&snapshot_writer, mismatch.types); + return self.buildInvalidIfCondition(mismatch.types); }, .incompatible_if_branches => |data| { - return self.buildIncompatibleIfBranches(&snapshot_writer, mismatch.types, data); + return self.buildIncompatibleIfBranches(mismatch.types, data); + }, + .incompatible_match_cond_pattern => |data| { + return self.buildIncompatibleMatchCondPattern(mismatch.types, data); }, .incompatible_match_patterns => |data| { - return self.buildIncompatibleMatchPatterns(&snapshot_writer, mismatch.types, data); + return self.buildIncompatibleMatchPatterns(mismatch.types, data); }, .incompatible_match_branches => |data| { - return self.buildIncompatibleMatchBranches(&snapshot_writer, mismatch.types, data); + return self.buildIncompatibleMatchBranches(mismatch.types, data); }, .invalid_bool_binop => |data| { - return self.buildInvalidBoolBinop(&snapshot_writer, mismatch.types, data); + return self.buildInvalidBoolBinop(mismatch.types, data); }, .invalid_nominal_tag => { - return self.buildInvalidNominalTag(&snapshot_writer, mismatch.types); + return self.buildInvalidNominalTag(mismatch.types); }, .cross_module_import => |data| { - return self.buildCrossModuleImportError(&snapshot_writer, mismatch.types, data); + return self.buildCrossModuleImportError(mismatch.types, data); }, .incompatible_fn_call_arg => |data| { - return self.buildIncompatibleFnCallArg(&snapshot_writer, mismatch.types, data); + return self.buildIncompatibleFnCallArg(mismatch.types, data); }, .incompatible_fn_args_bound_var => |data| { - return self.buildIncompatibleFnArgsBoundVar(&snapshot_writer, mismatch.types, data); + return self.buildIncompatibleFnArgsBoundVar(mismatch.types, data); }, } } else { - return self.buildGenericTypeMismatchReport(&snapshot_writer, mismatch.types); + return self.buildGenericTypeMismatchReport(mismatch.types); } }, .type_apply_mismatch_arities => |data| { - return self.buildTypeApplyArityMismatchReport(&snapshot_writer, data); + return self.buildTypeApplyArityMismatchReport(data); }, .number_does_not_fit => |data| { - return self.buildNumberDoesNotFitReport(&snapshot_writer, data); + return self.buildNumberDoesNotFitReport(data); }, .negative_unsigned_int => |data| { - return self.buildNegativeUnsignedIntReport(&snapshot_writer, data); + return self.buildNegativeUnsignedIntReport(data); }, - .infinite_recursion => |_| return self.buildUnimplementedReport(), - .anonymous_recursion => |_| return self.buildUnimplementedReport(), - .invalid_number_type => |_| return self.buildUnimplementedReport(), - .invalid_record_ext => |_| return self.buildUnimplementedReport(), - .invalid_tag_union_ext => |_| return self.buildUnimplementedReport(), - .bug => |_| return self.buildUnimplementedReport(), + .infinite_recursion => |_| return self.buildUnimplementedReport("infinite_recursion"), + .anonymous_recursion => |_| return self.buildUnimplementedReport("anonymous_recursion"), + .invalid_number_type => |_| return self.buildUnimplementedReport("invalid_number_type"), + .invalid_record_ext => |_| return self.buildUnimplementedReport("invalid_record_ext"), + .invalid_tag_union_ext => |_| return self.buildUnimplementedReport("invalid_tag_union_ext"), + .bug => |_| return self.buildUnimplementedReport("bug"), } } @@ -310,19 +313,18 @@ pub const ReportBuilder = struct { /// Build a report for type mismatch diagnostic fn buildGenericTypeMismatchReport( self: *Self, - snapshot_writer: *snapshot.SnapshotWriter, types: TypePair, ) !Report { var report = Report.init(self.gpa, "TYPE MISMATCH", .runtime_error); errdefer report.deinit(); - self.buf.clearRetainingCapacity(); - try snapshot_writer.write(types.actual_snapshot); - const owned_actual = try report.addOwnedString(self.buf.items[0..]); + self.snapshot_writer.resetContext(); + try self.snapshot_writer.write(types.actual_snapshot); + const owned_actual = try report.addOwnedString(self.snapshot_writer.get()); - self.buf.clearRetainingCapacity(); - try snapshot_writer.write(types.expected_snapshot); - const owned_expected = try report.addOwnedString(self.buf.items[0..]); + self.snapshot_writer.resetContext(); + try self.snapshot_writer.write(types.expected_snapshot); + const owned_expected = try report.addOwnedString(self.snapshot_writer.get()); // For annotation mismatches, we want to highlight the expression that doesn't match, // not the annotation itself. When from_annotation is true and we're showing @@ -331,8 +333,6 @@ pub const ReportBuilder = struct { const region_var = if (types.constraint_origin_var) |origin_var| origin_var - else if (types.from_annotation) - types.expected_var // Use expected_var to highlight the expression causing the mismatch else types.actual_var; const region = self.can_ir.store.regions.get(@enumFromInt(@intFromEnum(region_var))); @@ -349,7 +349,7 @@ pub const ReportBuilder = struct { // In this case, show a specialized argument type mismatch error. if (types.constraint_origin_var) |origin_var| { report.deinit(); - return self.buildIncompatibleFnCallArg(snapshot_writer, types, .{ + return self.buildIncompatibleFnCallArg(types, .{ .fn_name = null, .arg_var = origin_var, .incompatible_arg_index = 0, // First argument @@ -374,18 +374,18 @@ pub const ReportBuilder = struct { ); try report.document.addLineBreak(); - if (types.from_annotation) { - try report.document.addText("The type annotation says it should have the type:"); - } else { - try report.document.addText("It has the type:"); - } + try report.document.addText("It has the type:"); try report.document.addLineBreak(); try report.document.addText(" "); try report.document.addAnnotated(owned_actual, .type_variable); try report.document.addLineBreak(); try report.document.addLineBreak(); - try report.document.addText("But here it's being used as:"); + if (types.from_annotation) { + try report.document.addText("But the type annotation says it should have the type:"); + } else { + try report.document.addText("But I expected it to be:"); + } try report.document.addLineBreak(); try report.document.addText(" "); try report.document.addAnnotated(owned_expected, .type_variable); @@ -419,7 +419,6 @@ pub const ReportBuilder = struct { /// Build a report for incompatible list elements fn buildIncompatibleListElementsReport( self: *Self, - snapshot_writer: *snapshot.SnapshotWriter, types: TypePair, data: IncompatibleListElements, ) !Report { @@ -427,21 +426,21 @@ pub const ReportBuilder = struct { errdefer report.deinit(); // Create owned strings - self.buf.clearRetainingCapacity(); - try snapshot_writer.write(types.expected_snapshot); - const expected_type = try report.addOwnedString(self.buf.items); + self.snapshot_writer.resetContext(); + try self.snapshot_writer.write(types.expected_snapshot); + const expected_type = try report.addOwnedString(self.snapshot_writer.get()); - self.buf.clearRetainingCapacity(); - try snapshot_writer.write(types.actual_snapshot); - const actual_type = try report.addOwnedString(self.buf.items); + self.snapshot_writer.resetContext(); + try self.snapshot_writer.write(types.actual_snapshot); + const actual_type = try report.addOwnedString(self.snapshot_writer.get()); - self.buf.clearRetainingCapacity(); - try appendOrdinal(&self.buf, data.incompatible_elem_index); - const expected_type_ordinal = try report.addOwnedString(self.buf.items); + self.bytes_buf.clearRetainingCapacity(); + try appendOrdinal(&self.bytes_buf, data.incompatible_elem_index); + const expected_type_ordinal = try report.addOwnedString(self.bytes_buf.items); - self.buf.clearRetainingCapacity(); - try appendOrdinal(&self.buf, data.incompatible_elem_index + 1); - const actual_type_ordinal = try report.addOwnedString(self.buf.items); + self.bytes_buf.clearRetainingCapacity(); + try appendOrdinal(&self.bytes_buf, data.incompatible_elem_index + 1); + const actual_type_ordinal = try report.addOwnedString(self.bytes_buf.items); // Add description if (data.list_length == 2) { @@ -461,7 +460,7 @@ pub const ReportBuilder = struct { // Determine the overall region that encompasses both elements const actual_region = self.can_ir.store.regions.get(@enumFromInt(@intFromEnum(types.actual_var))); - const expected_region = self.can_ir.store.regions.get(@enumFromInt(@intFromEnum(data.last_elem_expr))); + const expected_region = self.can_ir.store.regions.get(@enumFromInt(@intFromEnum(data.last_elem_idx))); const overall_start_offset = @min(actual_region.start.offset, expected_region.start.offset); const overall_end_offset = @max(actual_region.end.offset, expected_region.end.offset); @@ -555,16 +554,15 @@ pub const ReportBuilder = struct { /// Build a report for incompatible list elements fn buildInvalidIfCondition( self: *Self, - snapshot_writer: *snapshot.SnapshotWriter, types: TypePair, ) !Report { var report = Report.init(self.gpa, "INVALID IF CONDITION", .runtime_error); errdefer report.deinit(); // Create owned strings - self.buf.clearRetainingCapacity(); - try snapshot_writer.write(types.actual_snapshot); - const actual_type = try report.addOwnedString(self.buf.items); + self.snapshot_writer.resetContext(); + try self.snapshot_writer.write(types.actual_snapshot); + const actual_type = try report.addOwnedString(self.snapshot_writer.get()); // Add description try report.document.addText("This "); @@ -633,7 +631,6 @@ pub const ReportBuilder = struct { /// Build a report for incompatible list elements fn buildIncompatibleIfBranches( self: *Self, - snapshot_writer: *snapshot.SnapshotWriter, types: TypePair, data: IncompatibleIfBranches, ) !Report { @@ -648,17 +645,17 @@ pub const ReportBuilder = struct { errdefer report.deinit(); // Create owned strings - self.buf.clearRetainingCapacity(); - try snapshot_writer.write(types.actual_snapshot); - const actual_type = try report.addOwnedString(self.buf.items); + self.snapshot_writer.resetContext(); + try self.snapshot_writer.write(types.actual_snapshot); + const actual_type = try report.addOwnedString(self.snapshot_writer.get()); - self.buf.clearRetainingCapacity(); - try snapshot_writer.write(types.expected_snapshot); - const expected_type = try report.addOwnedString(self.buf.items); + self.snapshot_writer.resetContext(); + try self.snapshot_writer.write(types.expected_snapshot); + const expected_type = try report.addOwnedString(self.snapshot_writer.get()); - self.buf.clearRetainingCapacity(); - try appendOrdinal(&self.buf, data.problem_branch_index + 1); - const branch_ordinal = try report.addOwnedString(self.buf.items); + self.bytes_buf.clearRetainingCapacity(); + try appendOrdinal(&self.bytes_buf, data.problem_branch_index + 1); + const branch_ordinal = try report.addOwnedString(self.bytes_buf.items); // Add title if (is_only_if_else) { @@ -776,10 +773,103 @@ pub const ReportBuilder = struct { return report; } + /// Build a report for the pattern in a match is a different type than the + /// match condition expr. e.g. match True { "hello" => ... } + fn buildIncompatibleMatchCondPattern( + self: *Self, + types: TypePair, + data: IncompatibleMatchCondPattern, + ) !Report { + var report = Report.init(self.gpa, "INCOMPATIBLE MATCH PATTERNS", .runtime_error); + errdefer report.deinit(); + + // Create owned strings + self.snapshot_writer.resetContext(); + try self.snapshot_writer.write(types.actual_snapshot); + const actual_type = try report.addOwnedString(self.snapshot_writer.get()); + + self.snapshot_writer.resetContext(); + try self.snapshot_writer.write(types.expected_snapshot); + const expected_type = try report.addOwnedString(self.snapshot_writer.get()); + + self.snapshot_writer.resetContext(); + try report.document.addText("The first pattern in this "); + try report.document.addAnnotated("match", .keyword); + try report.document.addText(" is incompatible:"); + try report.document.addLineBreak(); + + // Determine the overall region that encompasses both elements + const match_expr_region = self.can_ir.store.regions.get(@enumFromInt(@intFromEnum(data.match_expr))); + const overall_region_info = base.RegionInfo.position( + self.source, + self.module_env.getLineStarts(), + match_expr_region.start.offset, + match_expr_region.end.offset, + ) catch return report; + + // Get region info for invalid branch + const invalid_var_region = self.can_ir.store.regions.get(@enumFromInt(@intFromEnum(types.actual_var))); + const invalid_var_region_info = base.RegionInfo.position( + self.source, + self.module_env.getLineStarts(), + invalid_var_region.start.offset, + invalid_var_region.end.offset, + ) catch return report; + + // Create the display region + const display_region = SourceCodeDisplayRegion{ + .line_text = self.gpa.dupe(u8, overall_region_info.calculateLineText(self.source, self.module_env.getLineStarts())) catch return report, + .start_line = overall_region_info.start_line_idx + 1, + .start_column = overall_region_info.start_col_idx + 1, + .end_line = overall_region_info.end_line_idx + 1, + .end_column = overall_region_info.end_col_idx + 1, + .region_annotation = .dimmed, + .filename = self.filename, + }; + + // Create underline regions + const underline_regions = [_]UnderlineRegion{ + .{ + .start_line = invalid_var_region_info.start_line_idx + 1, + .start_column = invalid_var_region_info.start_col_idx + 1, + .end_line = invalid_var_region_info.end_line_idx + 1, + .end_column = invalid_var_region_info.end_col_idx + 1, + .annotation = .error_highlight, + }, + }; + + try report.document.addSourceCodeWithUnderlines(display_region, &underline_regions); + try report.document.addLineBreak(); + + // Show the type of the invalid branch + self.snapshot_writer.resetContext(); + try report.document.addText("The first pattern has the type:"); + try report.document.addLineBreak(); + try report.document.addText(" "); + try report.document.addAnnotated(actual_type, .type_variable); + try report.document.addLineBreak(); + try report.document.addLineBreak(); + + // Show the type of the other branches + try report.document.addText("But the expression between the "); + try report.document.addAnnotated("match", .keyword); + try report.document.addText(" parenthesis has the type:"); + try report.document.addLineBreak(); + try report.document.addText(" "); + try report.document.addAnnotated(expected_type, .type_variable); + try report.document.addLineBreak(); + try report.document.addLineBreak(); + + try report.document.addText("These two types can't never match!"); + try report.document.addLineBreak(); + try report.document.addLineBreak(); + + return report; + } + /// Build a report for incompatible match branches fn buildIncompatibleMatchPatterns( self: *Self, - snapshot_writer: *snapshot.SnapshotWriter, types: TypePair, data: IncompatibleMatchPatterns, ) !Report { @@ -787,25 +877,25 @@ pub const ReportBuilder = struct { errdefer report.deinit(); // Create owned strings - self.buf.clearRetainingCapacity(); - try snapshot_writer.write(types.actual_snapshot); - const actual_type = try report.addOwnedString(self.buf.items); + self.snapshot_writer.resetContext(); + try self.snapshot_writer.write(types.actual_snapshot); + const actual_type = try report.addOwnedString(self.snapshot_writer.get()); - self.buf.clearRetainingCapacity(); - try snapshot_writer.write(types.expected_snapshot); - const expected_type = try report.addOwnedString(self.buf.items); + self.snapshot_writer.resetContext(); + try self.snapshot_writer.write(types.expected_snapshot); + const expected_type = try report.addOwnedString(self.snapshot_writer.get()); - self.buf.clearRetainingCapacity(); - try appendOrdinal(&self.buf, data.problem_branch_index + 1); - const branch_ord = try report.addOwnedString(self.buf.items); + self.bytes_buf.clearRetainingCapacity(); + try appendOrdinal(&self.bytes_buf, data.problem_branch_index + 1); + const branch_ord = try report.addOwnedString(self.bytes_buf.items); - self.buf.clearRetainingCapacity(); - try appendOrdinal(&self.buf, data.problem_pattern_index + 1); - const pattern_ord = try report.addOwnedString(self.buf.items); + self.bytes_buf.clearRetainingCapacity(); + try appendOrdinal(&self.bytes_buf, data.problem_pattern_index + 1); + const pattern_ord = try report.addOwnedString(self.bytes_buf.items); // Add description if (data.num_patterns > 1) { - self.buf.clearRetainingCapacity(); + self.snapshot_writer.resetContext(); try report.document.addText("The pattern "); try report.document.addText(pattern_ord); try report.document.addText(" pattern in this "); @@ -814,7 +904,7 @@ pub const ReportBuilder = struct { try report.document.addText(" differs from previous ones:"); try report.document.addLineBreak(); } else { - self.buf.clearRetainingCapacity(); + self.snapshot_writer.resetContext(); try report.document.addText("The pattern in the "); try report.document.addText(branch_ord); try report.document.addText(" branch of this "); @@ -867,7 +957,7 @@ pub const ReportBuilder = struct { try report.document.addLineBreak(); // Show the type of the invalid branch - self.buf.clearRetainingCapacity(); + self.snapshot_writer.resetContext(); try report.document.addText("The "); try report.document.addText(branch_ord); try report.document.addText(" pattern has this type:"); @@ -902,7 +992,6 @@ pub const ReportBuilder = struct { /// Build a report for incompatible match branches fn buildIncompatibleMatchBranches( self: *Self, - snapshot_writer: *snapshot.SnapshotWriter, types: TypePair, data: IncompatibleMatchBranches, ) !Report { @@ -913,26 +1002,26 @@ pub const ReportBuilder = struct { errdefer report.deinit(); // Create owned strings - self.buf.clearRetainingCapacity(); - try snapshot_writer.write(types.actual_snapshot); - const actual_type = try report.addOwnedString(self.buf.items); + self.snapshot_writer.resetContext(); + try self.snapshot_writer.write(types.actual_snapshot); + const actual_type = try report.addOwnedString(self.snapshot_writer.get()); - self.buf.clearRetainingCapacity(); - try snapshot_writer.write(types.expected_snapshot); - const expected_type = try report.addOwnedString(self.buf.items); + self.snapshot_writer.resetContext(); + try self.snapshot_writer.write(types.expected_snapshot); + const expected_type = try report.addOwnedString(self.snapshot_writer.get()); - self.buf.clearRetainingCapacity(); - try appendOrdinal(&self.buf, data.problem_branch_index + 1); - const branch_ord = try report.addOwnedString(self.buf.items); + self.bytes_buf.clearRetainingCapacity(); + try appendOrdinal(&self.bytes_buf, data.problem_branch_index + 1); + const branch_ord = try report.addOwnedString(self.bytes_buf.items); // Add description if (data.num_branches == 2) { - self.buf.clearRetainingCapacity(); + self.snapshot_writer.resetContext(); try report.document.addText("The second branch's type in this "); try report.document.addAnnotated("match", .keyword); try report.document.addText(" is different from the first branch:"); } else { - self.buf.clearRetainingCapacity(); + self.snapshot_writer.resetContext(); try report.document.addText("The "); try report.document.addText(branch_ord); try report.document.addText(" branch's type in this "); @@ -1028,7 +1117,6 @@ pub const ReportBuilder = struct { /// Build a report for incompatible match branches fn buildInvalidBoolBinop( self: *Self, - snapshot_writer: *snapshot.SnapshotWriter, types: TypePair, data: InvalidBoolBinop, ) !Report { @@ -1036,9 +1124,9 @@ pub const ReportBuilder = struct { errdefer report.deinit(); // Create owned strings - self.buf.clearRetainingCapacity(); - try snapshot_writer.write(types.actual_snapshot); - const actual_type = try report.addOwnedString(self.buf.items); + self.snapshot_writer.resetContext(); + try self.snapshot_writer.write(types.actual_snapshot); + const actual_type = try report.addOwnedString(self.snapshot_writer.get()); // Add description try report.document.addText("I'm having trouble with this bool operation:"); @@ -1120,7 +1208,6 @@ pub const ReportBuilder = struct { /// Build a report for incompatible match branches fn buildInvalidNominalTag( self: *Self, - snapshot_writer: *snapshot.SnapshotWriter, types: TypePair, ) !Report { var report = Report.init(self.gpa, "INVALID NOMINAL TAG", .runtime_error); @@ -1132,9 +1219,9 @@ pub const ReportBuilder = struct { std.debug.assert(actual_content.structure == .tag_union); std.debug.assert(actual_content.structure.tag_union.tags.len() == 1); const actual_tag = self.snapshots.tags.get(actual_content.structure.tag_union.tags.start); - self.buf.clearRetainingCapacity(); - try snapshot_writer.writeTag(actual_tag, types.actual_snapshot); - const actual_tag_str = try report.addOwnedString(self.buf.items); + self.snapshot_writer.resetContext(); + try self.snapshot_writer.writeTag(actual_tag, types.actual_snapshot); + const actual_tag_str = try report.addOwnedString(self.snapshot_writer.get()); // Create expected tag str const expected_content = self.snapshots.getContent(types.expected_snapshot); @@ -1168,20 +1255,20 @@ pub const ReportBuilder = struct { // Show the expected tags if (expected_num_tags_str == 1) { const expected_tag = self.snapshots.tags.get(expected_content.structure.tag_union.tags.start); - self.buf.clearRetainingCapacity(); - try snapshot_writer.writeTag(expected_tag, types.expected_snapshot); - const expected_tag_str = try report.addOwnedString(self.buf.items); + self.snapshot_writer.resetContext(); + try self.snapshot_writer.writeTag(expected_tag, types.expected_snapshot); + const expected_tag_str = try report.addOwnedString(self.snapshot_writer.get()); - try report.document.addText("But it should be:"); + try report.document.addText("But the nominal type needs it to be:"); try report.document.addLineBreak(); try report.document.addText(" "); try report.document.addAnnotated(expected_tag_str, .type_variable); } else { - self.buf.clearRetainingCapacity(); - try snapshot_writer.write(types.expected_snapshot); - const expected_type = try report.addOwnedString(self.buf.items); + self.snapshot_writer.resetContext(); + try self.snapshot_writer.write(types.expected_snapshot); + const expected_type = try report.addOwnedString(self.snapshot_writer.get()); - try report.document.addText("But it should be one of:"); + try report.document.addText("But the nominal type needs it to one of:"); try report.document.addLineBreak(); try report.document.addText(" "); try report.document.addAnnotated(expected_type, .type_variable); @@ -1195,11 +1282,9 @@ pub const ReportBuilder = struct { const expected_tag_name_str = self.can_ir.getIdent(cur_expected_tag.name); if (std.mem.eql(u8, actual_tag_name_str, expected_tag_name_str)) { - snapshot_writer.resetContext(); - - self.buf.clearRetainingCapacity(); - try snapshot_writer.writeTag(cur_expected_tag, types.expected_snapshot); - const cur_expected_tag_str = try report.addOwnedString(self.buf.items); + self.snapshot_writer.resetContext(); + try self.snapshot_writer.writeTag(cur_expected_tag, types.expected_snapshot); + const cur_expected_tag_str = try report.addOwnedString(self.snapshot_writer.get()); try report.document.addLineBreak(); try report.document.addLineBreak(); @@ -1221,28 +1306,27 @@ pub const ReportBuilder = struct { /// Build a report for function argument type mismatch fn buildIncompatibleFnCallArg( self: *Self, - snapshot_writer: *snapshot.SnapshotWriter, types: TypePair, data: IncompatibleFnCallArg, ) !Report { var report = Report.init(self.gpa, "TYPE MISMATCH", .runtime_error); errdefer report.deinit(); - self.buf.clearRetainingCapacity(); - try appendOrdinal(&self.buf, data.incompatible_arg_index + 1); - const arg_index = try report.addOwnedString(self.buf.items); + self.bytes_buf.clearRetainingCapacity(); + try appendOrdinal(&self.bytes_buf, data.incompatible_arg_index + 1); + const arg_index = try report.addOwnedString(self.bytes_buf.items); // Extract only the argument types from the function snapshots const actual_arg_type = self.extractFirstArgTypeFromFunctionSnapshot(types.actual_snapshot) orelse types.actual_snapshot; const expected_arg_type = self.extractFirstArgTypeFromFunctionSnapshot(types.expected_snapshot) orelse types.expected_snapshot; - self.buf.clearRetainingCapacity(); - try snapshot_writer.write(actual_arg_type); - const actual_type = try report.addOwnedString(self.buf.items); + self.snapshot_writer.resetContext(); + try self.snapshot_writer.write(actual_arg_type); + const actual_type = try report.addOwnedString(self.snapshot_writer.get()); - self.buf.clearRetainingCapacity(); - try snapshot_writer.write(expected_arg_type); - const expected_type = try report.addOwnedString(self.buf.items); + self.snapshot_writer.resetContext(); + try self.snapshot_writer.write(expected_arg_type); + const expected_type = try report.addOwnedString(self.snapshot_writer.get()); try report.document.addText("The "); try report.document.addText(arg_index); @@ -1269,7 +1353,7 @@ pub const ReportBuilder = struct { try report.document.addReflowingText("But "); if (data.fn_name) |fn_name_ident| { - self.buf.clearRetainingCapacity(); + self.snapshot_writer.resetContext(); const fn_name = try report.addOwnedString(self.can_ir.getIdent(fn_name_ident)); try report.document.addAnnotated(fn_name, .inline_code); } else { @@ -1287,30 +1371,29 @@ pub const ReportBuilder = struct { fn buildIncompatibleFnArgsBoundVar( self: *Self, - snapshot_writer: *snapshot.SnapshotWriter, types: TypePair, data: IncompatibleFnArgsBoundVar, ) !Report { var report = Report.init(self.gpa, "TYPE MISMATCH", .runtime_error); errdefer report.deinit(); - self.buf.clearRetainingCapacity(); - try appendOrdinal(&self.buf, data.first_arg_index + 1); - const first_arg_index = try report.addOwnedString(self.buf.items); + self.bytes_buf.clearRetainingCapacity(); + try appendOrdinal(&self.bytes_buf, data.first_arg_index + 1); + const first_arg_index = try report.addOwnedString(self.bytes_buf.items); - self.buf.clearRetainingCapacity(); - try appendOrdinal(&self.buf, data.second_arg_index + 1); - const second_arg_index = try report.addOwnedString(self.buf.items); + self.bytes_buf.clearRetainingCapacity(); + try appendOrdinal(&self.bytes_buf, data.second_arg_index + 1); + const second_arg_index = try report.addOwnedString(self.bytes_buf.items); // The types from unification already have the correct snapshots // expected = first argument, actual = second argument - self.buf.clearRetainingCapacity(); - try snapshot_writer.write(types.expected_snapshot); - const first_type = try report.addOwnedString(self.buf.items); + self.snapshot_writer.resetContext(); + try self.snapshot_writer.write(types.expected_snapshot); + const first_type = try report.addOwnedString(self.snapshot_writer.get()); - self.buf.clearRetainingCapacity(); - try snapshot_writer.write(types.actual_snapshot); - const second_type = try report.addOwnedString(self.buf.items); + self.snapshot_writer.resetContext(); + try self.snapshot_writer.write(types.actual_snapshot); + const second_type = try report.addOwnedString(self.snapshot_writer.get()); try report.document.addText("The "); try report.document.addText(first_arg_index); @@ -1397,7 +1480,7 @@ pub const ReportBuilder = struct { try report.document.addLineBreak(); if (data.fn_name) |fn_name_ident| { - self.buf.clearRetainingCapacity(); + self.snapshot_writer.resetContext(); const fn_name = try report.addOwnedString(self.can_ir.getIdent(fn_name_ident)); try report.document.addAnnotated(fn_name, .inline_code); } else { @@ -1413,7 +1496,6 @@ pub const ReportBuilder = struct { /// Build a report for "number does not fit in type" diagnostic fn buildTypeApplyArityMismatchReport( self: *Self, - _: *snapshot.SnapshotWriter, data: TypeApplyArityMismatch, ) !Report { const title = blk: { @@ -1430,18 +1512,16 @@ pub const ReportBuilder = struct { const type_name = try report.addOwnedString(self.can_ir.getIdent(data.type_name)); - self.buf.clearRetainingCapacity(); - try self.buf.writer().print("{d}", .{data.num_expected_args}); - const num_expected_args = try report.addOwnedString(self.buf.items); + self.bytes_buf.clearRetainingCapacity(); + try self.bytes_buf.writer().print("{d}", .{data.num_expected_args}); + const num_expected_args = try report.addOwnedString(self.snapshot_writer.get()); - self.buf.clearRetainingCapacity(); - try self.buf.writer().print("{d}", .{data.num_actual_args}); - const num_actual_args = try report.addOwnedString(self.buf.items); - - const region = self.can_ir.store.regions.get(@enumFromInt(@intFromEnum(data.anno_var))); + self.bytes_buf.clearRetainingCapacity(); + try self.bytes_buf.writer().print("{d}", .{data.num_actual_args}); + const num_actual_args = try report.addOwnedString(self.snapshot_writer.get()); // Add source region highlighting - const region_info = self.module_env.calcRegionInfo(region.*); + const region_info = self.module_env.calcRegionInfo(data.region); try report.document.addReflowingText("The type "); try report.document.addAnnotated(type_name, .type_variable); @@ -1469,15 +1549,14 @@ pub const ReportBuilder = struct { /// Build a report for "number does not fit in type" diagnostic fn buildNumberDoesNotFitReport( self: *Self, - snapshot_writer: *snapshot.SnapshotWriter, data: NumberDoesNotFit, ) !Report { var report = Report.init(self.gpa, "NUMBER DOES NOT FIT IN TYPE", .runtime_error); errdefer report.deinit(); - self.buf.clearRetainingCapacity(); - try snapshot_writer.write(data.expected_type); - const owned_expected = try report.addOwnedString(self.buf.items[0..]); + self.snapshot_writer.resetContext(); + try self.snapshot_writer.write(data.expected_type); + const owned_expected = try report.addOwnedString(self.snapshot_writer.get()); const region = self.can_ir.store.regions.get(@enumFromInt(@intFromEnum(data.literal_var))); @@ -1510,15 +1589,14 @@ pub const ReportBuilder = struct { /// Build a report for "negative unsigned integer" diagnostic fn buildNegativeUnsignedIntReport( self: *Self, - snapshot_writer: *snapshot.SnapshotWriter, data: NegativeUnsignedInt, ) !Report { var report = Report.init(self.gpa, "NEGATIVE UNSIGNED INTEGER", .runtime_error); errdefer report.deinit(); - self.buf.clearRetainingCapacity(); - try snapshot_writer.write(data.expected_type); - const owned_expected = try report.addOwnedString(self.buf.items[0..]); + self.snapshot_writer.resetContext(); + try self.snapshot_writer.write(data.expected_type); + const owned_expected = try report.addOwnedString(self.snapshot_writer.get()); const region = self.can_ir.store.regions.get(@enumFromInt(@intFromEnum(data.literal_var))); @@ -1557,7 +1635,6 @@ pub const ReportBuilder = struct { /// Build a report for cross-module import type mismatch fn buildCrossModuleImportError( self: *Self, - snapshot_writer: *snapshot.SnapshotWriter, types: TypePair, data: CrossModuleImport, ) !Report { @@ -1617,9 +1694,9 @@ pub const ReportBuilder = struct { try report.document.addText("It has the type:"); try report.document.addLineBreak(); - self.buf.clearRetainingCapacity(); - try snapshot_writer.write(types.expected_snapshot); - const expected_type = try report.addOwnedString(self.buf.items); + self.snapshot_writer.resetContext(); + try self.snapshot_writer.write(types.expected_snapshot); + const expected_type = try report.addOwnedString(self.snapshot_writer.get()); try report.document.addText(" "); try report.document.addAnnotated(expected_type, .type_variable); try report.document.addLineBreak(); @@ -1635,9 +1712,9 @@ pub const ReportBuilder = struct { } try report.document.addLineBreak(); - self.buf.clearRetainingCapacity(); - try snapshot_writer.write(types.actual_snapshot); - const actual_type = try report.addOwnedString(self.buf.items); + self.snapshot_writer.resetContext(); + try self.snapshot_writer.write(types.actual_snapshot); + const actual_type = try report.addOwnedString(self.snapshot_writer.get()); try report.document.addText(" "); try report.document.addAnnotated(actual_type, .type_variable); try report.document.addLineBreak(); @@ -1646,8 +1723,10 @@ pub const ReportBuilder = struct { } /// Build a report for "invalid number literal" diagnostic - fn buildUnimplementedReport(self: *Self) !Report { - const report = Report.init(self.gpa, "UNIMPLEMENTED", .runtime_error); + fn buildUnimplementedReport(self: *Self, bytes: []const u8) !Report { + var report = Report.init(self.gpa, "UNIMPLEMENTED: ", .runtime_error); + const owned_bytes = try report.addOwnedString(bytes); + try report.document.addText(owned_bytes); return report; } diff --git a/src/check/snapshot.zig b/src/check/snapshot.zig index dd17edf1fb..dee8aa2fe8 100644 --- a/src/check/snapshot.zig +++ b/src/check/snapshot.zig @@ -22,6 +22,8 @@ const MkSafeMultiList = collections.SafeMultiList; const Var = types.Var; const Content = types.Content; +const Flex = types.Flex; +const Rigid = types.Rigid; /// Self-contained snapshot store with fully resolved content (ie no Vars) /// @@ -39,6 +41,9 @@ pub const Store = struct { // Content storage contents: SnapshotContentList, + // Catch recursive references + seen_vars: base.Scratch(Var), + /// Storage for compound type parts content_indexes: SnapshotContentIdxSafeList, record_fields: SnapshotRecordFieldSafeList, @@ -53,6 +58,7 @@ pub const Store = struct { return .{ .gpa = gpa, .contents = try SnapshotContentList.initCapacity(gpa, capacity), + .seen_vars = try base.Scratch(Var).init(gpa), .content_indexes = try SnapshotContentIdxSafeList.initCapacity(gpa, capacity), .record_fields = try SnapshotRecordFieldSafeList.initCapacity(gpa, 256), .tags = try SnapshotTagSafeList.initCapacity(gpa, 256), @@ -64,6 +70,7 @@ pub const Store = struct { pub fn deinit(self: *Self) void { self.contents.deinit(self.gpa); + self.seen_vars.deinit(self.gpa); self.content_indexes.deinit(self.gpa); self.record_fields.deinit(self.gpa); self.tags.deinit(self.gpa); @@ -76,13 +83,34 @@ pub const Store = struct { /// Deep copy a type variable's content into self-contained snapshot storage pub fn deepCopyVar(self: *Self, store: *const TypesStore, var_: types.Var) std.mem.Allocator.Error!SnapshotContentIdx { const resolved = store.resolveVar(var_); - return try self.deepCopyContent(store, resolved.desc.content); + + // Check if we've seen this variable + var has_seen_var = false; + for (self.seen_vars.items.items) |seen_var| { + if (seen_var == resolved.var_) { + has_seen_var = true; + break; + } + } + + // If we've seen this variable, then return it as a recursive type + if (has_seen_var) { + return try self.contents.append(self.gpa, .recursive); + } + + // If not, add it to the seen list + try self.seen_vars.append(self.gpa, resolved.var_); + defer _ = self.seen_vars.pop(); + + return try self.deepCopyContent(store, resolved.var_, resolved.desc.content); } - fn deepCopyContent(self: *Self, store: *const TypesStore, content: Content) std.mem.Allocator.Error!SnapshotContentIdx { + fn deepCopyContent(self: *Self, store: *const TypesStore, var_: types.Var, content: Content) std.mem.Allocator.Error!SnapshotContentIdx { const deep_content = switch (content) { - .flex_var => |ident| SnapshotContent{ .flex_var = ident }, - .rigid_var => |ident| SnapshotContent{ .rigid_var = ident }, + .flex => |flex| SnapshotContent{ + .flex = .{ .ident = flex.name, .var_ = var_ }, + }, + .rigid => |rigid| SnapshotContent{ .rigid = rigid.name }, .alias => |alias| SnapshotContent{ .alias = try self.deepCopyAlias(store, alias) }, .structure => |flat_type| SnapshotContent{ .structure = try self.deepCopyFlatType(store, flat_type) }, .err => SnapshotContent.err, @@ -95,13 +123,11 @@ pub const Store = struct { return switch (flat_type) { .str => SnapshotFlatType.str, .box => |box_var| { - const resolved = store.resolveVar(box_var); - const deep_content = try self.deepCopyContent(store, resolved.desc.content); + const deep_content = try self.deepCopyVar(store, box_var); return SnapshotFlatType{ .box = deep_content }; }, .list => |list_var| { - const resolved = store.resolveVar(list_var); - const deep_content = try self.deepCopyContent(store, resolved.desc.content); + const deep_content = try self.deepCopyVar(store, list_var); return SnapshotFlatType{ .list = deep_content }; }, .list_unbound => { @@ -115,10 +141,6 @@ pub const Store = struct { .fn_unbound => |func| SnapshotFlatType{ .fn_unbound = try self.deepCopyFunc(store, func) }, .record => |record| SnapshotFlatType{ .record = try self.deepCopyRecord(store, record) }, .record_unbound => |fields| SnapshotFlatType{ .record_unbound = try self.deepCopyRecordFields(store, fields) }, - .record_poly => |poly| SnapshotFlatType{ .record_poly = .{ - .record = try self.deepCopyRecord(store, poly.record), - .var_ = try self.deepCopyContent(store, store.resolveVar(poly.var_).desc.content), - } }, .empty_record => SnapshotFlatType.empty_record, .tag_union => |tag_union| SnapshotFlatType{ .tag_union = try self.deepCopyTagUnion(store, tag_union) }, .empty_tag_union => SnapshotFlatType.empty_tag_union, @@ -126,19 +148,16 @@ pub const Store = struct { } fn deepCopyAlias(self: *Self, store: *const TypesStore, alias: types.Alias) std.mem.Allocator.Error!SnapshotAlias { + const backing_var = store.getAliasBackingVar(alias); + const deep_backing = try self.deepCopyVar(store, backing_var); + // Mark starting position in the scratch array const scratch_top = self.scratch_content.top(); - const backing_var = store.getAliasBackingVar(alias); - const backing_resolved = store.resolveVar(backing_var); - const deep_backing = try self.deepCopyContent(store, backing_resolved.desc.content); - _ = try self.scratch_content.append(self.gpa, deep_backing); - // Iterate and append to scratch array var arg_iter = store.iterAliasArgs(alias); while (arg_iter.next()) |arg_var| { - const arg_resolved = store.resolveVar(arg_var); - const deep_arg = try self.deepCopyContent(store, arg_resolved.desc.content); + const deep_arg = try self.deepCopyVar(store, arg_var); _ = try self.scratch_content.append(self.gpa, deep_arg); } @@ -148,7 +167,7 @@ pub const Store = struct { return SnapshotAlias{ .ident = alias.ident, - .backing = try self.deepCopyContent(store, backing_resolved.desc.content), + .backing = deep_backing, .vars = args_range, }; } @@ -161,8 +180,7 @@ pub const Store = struct { // Iterate and append to scratch array for (elems_slice) |elem_var| { - const elem_resolved = store.resolveVar(elem_var); - const deep_elem = try self.deepCopyContent(store, elem_resolved.desc.content); + const deep_elem = try self.deepCopyVar(store, elem_var); _ = try self.scratch_content.append(self.gpa, deep_elem); } @@ -177,19 +195,20 @@ pub const Store = struct { fn deepCopyNum(self: *Self, store: *const TypesStore, num: types.Num) std.mem.Allocator.Error!SnapshotNum { switch (num) { - .num_poly => |poly| { - const resolved_poly = store.resolveVar(poly.var_); - const deep_poly = try self.deepCopyContent(store, resolved_poly.desc.content); + .num_poly => |poly_var| { + const deep_poly = try self.deepCopyVar(store, poly_var); return SnapshotNum{ .num_poly = deep_poly }; }, - .int_poly => |poly| { - const resolved_poly = store.resolveVar(poly.var_); - const deep_poly = try self.deepCopyContent(store, resolved_poly.desc.content); + .int_poly => |poly_var| { + const deep_poly = try self.deepCopyVar(store, poly_var); return SnapshotNum{ .int_poly = deep_poly }; }, - .num_unbound => |requirements| { + .num_unbound => |unbound| { // For unbound types, we don't have a var to resolve, just return the requirements - return SnapshotNum{ .num_unbound = requirements }; + return SnapshotNum{ .num_unbound = .{ + .int_requirements = unbound.int_requirements, + .frac_requirements = unbound.frac_requirements, + } }; }, .int_unbound => |requirements| { // For unbound types, we don't have a var to resolve, just return the requirements @@ -199,9 +218,8 @@ pub const Store = struct { // For unbound types, we don't have a var to resolve, just return the requirements return SnapshotNum{ .frac_unbound = requirements }; }, - .frac_poly => |poly| { - const resolved_poly = store.resolveVar(poly.var_); - const deep_poly = try self.deepCopyContent(store, resolved_poly.desc.content); + .frac_poly => |poly_var| { + const deep_poly = try self.deepCopyVar(store, poly_var); return SnapshotNum{ .frac_poly = deep_poly }; }, .int_precision => |prec| { @@ -222,15 +240,13 @@ pub const Store = struct { // Add backing var (must be first) const backing_var = store.getNominalBackingVar(nominal_type); - const backing_resolved = store.resolveVar(backing_var); - const deep_var = try self.deepCopyContent(store, backing_resolved.desc.content); + const deep_var = try self.deepCopyVar(store, backing_var); _ = try self.scratch_content.append(self.gpa, deep_var); // Add args after var arg_iter = store.iterNominalArgs(nominal_type); while (arg_iter.next()) |arg_var| { - const arg_resolved = store.resolveVar(arg_var); - const deep_arg = try self.deepCopyContent(store, arg_resolved.desc.content); + const deep_arg = try self.deepCopyVar(store, arg_var); _ = try self.scratch_content.append(self.gpa, deep_arg); } @@ -253,8 +269,7 @@ pub const Store = struct { // Iterate and append directly for (args_slice) |arg_var| { - const arg_resolved = store.resolveVar(arg_var); - const deep_arg = try self.deepCopyContent(store, arg_resolved.desc.content); + const deep_arg = try self.deepCopyVar(store, arg_var); _ = try self.scratch_content.append(self.gpa, deep_arg); } @@ -263,8 +278,7 @@ pub const Store = struct { self.scratch_content.clearFrom(scratch_top); // Deep copy return type - const ret_resolved = store.resolveVar(func.ret); - const deep_ret = try self.deepCopyContent(store, ret_resolved.desc.content); + const deep_ret = try self.deepCopyVar(store, func.ret); return SnapshotFunc{ .args = args_range, @@ -279,8 +293,7 @@ pub const Store = struct { const fields_slice = store.getRecordFieldsSlice(fields); for (fields_slice.items(.name), fields_slice.items(.var_)) |name, var_| { - const field_resolved = store.resolveVar(var_); - const deep_field_content = try self.deepCopyContent(store, field_resolved.desc.content); + const deep_field_content = try self.deepCopyVar(store, var_); const snapshot_field = SnapshotRecordField{ .name = name, @@ -306,8 +319,7 @@ pub const Store = struct { while (fields_iter.next()) |field_idx| { const field = store.record_fields.get(field_idx); - const field_resolved = store.resolveVar(field.var_); - const deep_field_content = try self.deepCopyContent(store, field_resolved.desc.content); + const deep_field_content = try self.deepCopyVar(store, field.var_); const snapshot_field = SnapshotRecordField{ .name = field.name, @@ -322,8 +334,7 @@ pub const Store = struct { self.scratch_record_fields.clearFrom(scratch_top); // Deep copy extension type - const ext_resolved = store.resolveVar(record.ext); - const deep_ext = try self.deepCopyContent(store, ext_resolved.desc.content); + const deep_ext = try self.deepCopyVar(store, record.ext); return SnapshotRecord{ .fields = fields_range, @@ -347,8 +358,7 @@ pub const Store = struct { // Iterate over tag arguments and append to scratch array for (tag_args_slice) |tag_arg_var| { - const tag_arg_resolved = store.resolveVar(tag_arg_var); - const deep_tag_arg = try self.deepCopyContent(store, tag_arg_resolved.desc.content); + const deep_tag_arg = try self.deepCopyVar(store, tag_arg_var); _ = try self.scratch_content.append(self.gpa, deep_tag_arg); } @@ -370,8 +380,7 @@ pub const Store = struct { self.scratch_tags.clearFrom(tags_scratch_top); // Deep copy extension type - const ext_resolved = store.resolveVar(tag_union.ext); - const deep_ext = try self.deepCopyContent(store, ext_resolved.desc.content); + const deep_ext = try self.deepCopyVar(store, tag_union.ext); return SnapshotTagUnion{ .tags = tags_range, @@ -395,10 +404,11 @@ pub const Store = struct { /// Snapshot types (no Var references!) pub const SnapshotContent = union(enum) { - flex_var: ?Ident.Idx, - rigid_var: Ident.Idx, + flex: struct { ident: ?Ident.Idx, var_: Var }, + rigid: Ident.Idx, alias: SnapshotAlias, structure: SnapshotFlatType, + recursive, err, }; @@ -423,7 +433,6 @@ pub const SnapshotFlatType = union(enum) { fn_unbound: SnapshotFunc, record: SnapshotRecord, record_unbound: SnapshotRecordFieldSafeList.Range, - record_poly: struct { record: SnapshotRecord, var_: SnapshotContentIdx }, empty_record, tag_union: SnapshotTagUnion, empty_tag_union, @@ -439,7 +448,7 @@ pub const SnapshotNum = union(enum) { num_poly: SnapshotContentIdx, int_poly: SnapshotContentIdx, frac_poly: SnapshotContentIdx, - num_unbound: types.Num.IntRequirements, + num_unbound: struct { int_requirements: types.Num.IntRequirements, frac_requirements: types.Num.FracRequirements }, int_unbound: types.Num.IntRequirements, frac_unbound: types.Num.FracRequirements, int_precision: types.Num.Int.Precision, @@ -502,7 +511,7 @@ const TypeContext = enum { pub const SnapshotWriter = struct { const Self = @This(); - writer: std.array_list.Managed(u8).Writer, + buf: std.array_list.Managed(u8), snapshots: *const Store, idents: *const Ident.Store, current_module_name: ?[]const u8, @@ -510,10 +519,14 @@ pub const SnapshotWriter = struct { other_modules: ?[]const *const ModuleEnv, next_name_index: u32, name_counters: std.EnumMap(TypeContext, u32), + flex_var_names_map: std.AutoHashMap(Var, FlexVarNameRange), + flex_var_names: std.array_list.Managed(u8), - pub fn init(writer: std.array_list.Managed(u8).Writer, snapshots: *const Store, idents: *const Ident.Store) Self { + const FlexVarNameRange = struct { start: usize, end: usize }; + + pub fn init(gpa: std.mem.Allocator, snapshots: *const Store, idents: *const Ident.Store) Self { return .{ - .writer = writer, + .buf = std.array_list.Managed(u8).init(gpa), .snapshots = snapshots, .idents = idents, .current_module_name = null, @@ -521,11 +534,13 @@ pub const SnapshotWriter = struct { .other_modules = null, .next_name_index = 0, .name_counters = std.EnumMap(TypeContext, u32).init(.{}), + .flex_var_names_map = std.AutoHashMap(Var, FlexVarNameRange).init(gpa), + .flex_var_names = std.array_list.Managed(u8).init(gpa), }; } pub fn initWithContext( - writer: std.array_list.Managed(u8).Writer, + gpa: std.mem.Allocator, snapshots: *const Store, idents: *const Ident.Store, current_module_name: []const u8, @@ -533,7 +548,7 @@ pub const SnapshotWriter = struct { other_modules: []const *const ModuleEnv, ) Self { return .{ - .writer = writer, + .buf = std.array_list.Managed(u8).init(gpa), .snapshots = snapshots, .idents = idents, .current_module_name = current_module_name, @@ -541,14 +556,34 @@ pub const SnapshotWriter = struct { .other_modules = other_modules, .next_name_index = 0, .name_counters = std.EnumMap(TypeContext, u32).init(.{}), + .flex_var_names_map = std.AutoHashMap(Var, FlexVarNameRange).init(gpa), + .flex_var_names = std.array_list.Managed(u8).init(gpa), }; } + pub fn deinit(self: *Self) void { + self.buf.deinit(); + self.flex_var_names_map.deinit(); + self.flex_var_names.deinit(); + } + pub fn resetContext(self: *Self) void { self.next_name_index = 0; self.name_counters = std.EnumMap(TypeContext, u32).init(.{}); + self.buf.clearRetainingCapacity(); + self.flex_var_names_map.clearRetainingCapacity(); + self.flex_var_names.clearRetainingCapacity(); } + pub fn get(self: *const Self) []const u8 { + return self.buf.items; + } + + const GenerateNameMode = union(enum) { + print, + persist_flex_var: Var, + }; + fn generateNextName(self: *Self) !void { // Generate name: a, b, ..., z, aa, ab, ..., az, ba, ... // Skip any names that already exist in the identifier store @@ -581,9 +616,8 @@ pub const SnapshotWriter = struct { const exists = self.idents.interner.contains(candidate_name); if (!exists) { - // This name is available, write it to the writer for (candidate_name) |c| { - try self.writer.writeByte(c); + try self.buf.writer().writeByte(c); } break; } @@ -592,8 +626,8 @@ pub const SnapshotWriter = struct { // This should never happen in practice, but let's handle it gracefully if (attempts >= max_attempts) { - _ = try self.writer.write("var"); - try self.writer.print("{}", .{self.next_name_index}); + _ = try self.buf.writer().write("var"); + try self.buf.writer().print("{}", .{self.next_name_index}); } } @@ -640,7 +674,7 @@ pub const SnapshotWriter = struct { if (!exists) { // This name is available, write it to the writer for (candidate_name) |c| { - try self.writer.writeByte(c); + try self.buf.writer().writeByte(c); } found = true; } else { @@ -659,89 +693,6 @@ pub const SnapshotWriter = struct { } /// Count how many times a content appears in a type - fn countOccurrences(self: *const Self, search_idx: SnapshotContentIdx, root_idx: SnapshotContentIdx) usize { - var count: usize = 0; - self.countContent(search_idx, root_idx, &count); - return count; - } - - fn countContent(self: *const Self, search_idx: SnapshotContentIdx, current_idx: SnapshotContentIdx, count: *usize) void { - if (current_idx == search_idx) { - count.* += 1; - } - - const content = self.snapshots.contents.get(current_idx); - switch (content.*) { - .flex_var, .rigid_var, .err => {}, - .alias => |alias| { - const args = self.snapshots.sliceVars(alias.vars); - for (args) |arg_idx| { - self.countContent(search_idx, arg_idx, count); - } - }, - .structure => |flat_type| { - self.countInFlatType(search_idx, flat_type, count); - }, - } - } - - fn countInFlatType(self: *const Self, search_idx: SnapshotContentIdx, flat_type: SnapshotFlatType, count: *usize) void { - switch (flat_type) { - .str, .empty_record, .empty_tag_union => {}, - .box => |sub_idx| self.countContent(search_idx, sub_idx, count), - .list => |sub_idx| self.countContent(search_idx, sub_idx, count), - .list_unbound, .num => {}, - .tuple => |tuple| { - const elems = self.snapshots.sliceVars(tuple.elems); - for (elems) |elem| { - self.countContent(search_idx, elem, count); - } - }, - .nominal_type => |nominal_type| { - const args = self.snapshots.sliceVars(nominal_type.vars); - // Skip the first var which is the nominal type's backing var - for (args[1..]) |arg_idx| { - self.countContent(search_idx, arg_idx, count); - } - }, - .fn_pure, .fn_effectful, .fn_unbound => |func| { - const args = self.snapshots.sliceVars(func.args); - for (args) |arg| { - self.countContent(search_idx, arg, count); - } - self.countContent(search_idx, func.ret, count); - }, - .record => |record| { - const fields = self.snapshots.record_fields.sliceRange(record.fields); - for (fields.items(.content)) |field_content| { - self.countContent(search_idx, field_content, count); - } - self.countContent(search_idx, record.ext, count); - }, - .record_unbound => |fields| { - const fields_slice = self.snapshots.record_fields.sliceRange(fields); - for (fields_slice.items(.content)) |field_content| { - self.countContent(search_idx, field_content, count); - } - }, - .record_poly => |poly| { - self.countInFlatType(search_idx, SnapshotFlatType{ .record = poly.record }, count); - self.countContent(search_idx, poly.var_, count); - }, - .tag_union => |tag_union| { - var iter = tag_union.tags.iterIndices(); - while (iter.next()) |tag_idx| { - const tag = self.snapshots.tags.get(tag_idx); - const args = self.snapshots.sliceVars(tag.args); - for (args) |arg_idx| { - self.countContent(search_idx, arg_idx, count); - } - } - self.countContent(search_idx, tag_union.ext, count); - }, - } - } - /// Convert a content to a type string with context pub fn writeWithContext(self: *Self, idx: SnapshotContentIdx, context: TypeContext, root_idx: SnapshotContentIdx) Allocator.Error!void { const content = self.snapshots.contents.get(idx); @@ -749,22 +700,17 @@ pub const SnapshotWriter = struct { } /// Convert a content to a type string - pub fn writeContent(self: *Self, content: SnapshotContent, context: TypeContext, current_idx: SnapshotContentIdx, root_idx: SnapshotContentIdx) Allocator.Error!void { + pub fn writeContent(self: *Self, content: SnapshotContent, context: TypeContext, content_idx: SnapshotContentIdx, root_idx: SnapshotContentIdx) Allocator.Error!void { switch (content) { - .flex_var => |mb_ident_idx| { - if (mb_ident_idx) |ident_idx| { - _ = try self.writer.write(self.idents.getText(ident_idx)); + .flex => |flex| { + if (flex.ident) |ident_idx| { + _ = try self.buf.writer().write(self.idents.getText(ident_idx)); } else { - // Check if this variable appears multiple times - const occurrences = self.countOccurrences(current_idx, root_idx); - if (occurrences == 1) { - _ = try self.writer.write("_"); - } - try self.generateContextualName(context); + _ = try self.writeFlexVarName(flex.var_, content_idx, context, root_idx); } }, - .rigid_var => |ident_idx| { - _ = try self.writer.write(self.idents.getText(ident_idx)); + .rigid => |rigid_name| { + _ = try self.buf.writer().write(self.idents.getText(rigid_name)); }, .alias => |alias| { try self.writeAlias(alias, root_idx); @@ -772,28 +718,27 @@ pub const SnapshotWriter = struct { .structure => |flat_type| { try self.writeFlatType(flat_type, root_idx); }, + .recursive => { + _ = try self.buf.writer().write("RecursiveType"); + }, .err => { - _ = try self.writer.write("Error"); + _ = try self.buf.writer().write("Error"); }, } } /// Write an alias type pub fn writeAlias(self: *Self, alias: SnapshotAlias, root_idx: SnapshotContentIdx) Allocator.Error!void { - _ = try self.writer.write(self.idents.getText(alias.ident.ident_idx)); - - // The 1st var is the alias type's backing var, so we skip it - var vars = self.snapshots.sliceVars(alias.vars); - std.debug.assert(vars.len > 0); - vars = vars[1..]; + _ = try self.buf.writer().write(self.idents.getText(alias.ident.ident_idx)); + const vars = self.snapshots.sliceVars(alias.vars); if (vars.len > 0) { - _ = try self.writer.write("("); + _ = try self.buf.writer().write("("); for (vars, 0..) |arg, i| { - if (i > 0) _ = try self.writer.write(", "); + if (i > 0) _ = try self.buf.writer().write(", "); try self.writeWithContext(arg, .General, root_idx); } - _ = try self.writer.write(")"); + _ = try self.buf.writer().write(")"); } } @@ -801,22 +746,22 @@ pub const SnapshotWriter = struct { pub fn writeFlatType(self: *Self, flat_type: SnapshotFlatType, root_idx: SnapshotContentIdx) Allocator.Error!void { switch (flat_type) { .str => { - _ = try self.writer.write("Str"); + _ = try self.buf.writer().write("Str"); }, .box => |sub_var| { - _ = try self.writer.write("Box("); + _ = try self.buf.writer().write("Box("); try self.writeWithContext(sub_var, .General, root_idx); - _ = try self.writer.write(")"); + _ = try self.buf.writer().write(")"); }, .list => |sub_var| { - _ = try self.writer.write("List("); + _ = try self.buf.writer().write("List("); try self.writeWithContext(sub_var, .ListContent, root_idx); - _ = try self.writer.write(")"); + _ = try self.buf.writer().write(")"); }, .list_unbound => { - _ = try self.writer.write("List(_"); + _ = try self.buf.writer().write("List(_"); try self.generateContextualName(.ListContent); - _ = try self.writer.write(")"); + _ = try self.buf.writer().write(")"); }, .tuple => |tuple| { try self.writeTuple(tuple, root_idx); @@ -842,18 +787,14 @@ pub const SnapshotWriter = struct { .record_unbound => |fields| { try self.writeRecordFields(fields, root_idx); }, - .record_poly => |poly| { - try self.writeRecord(poly.record, root_idx); - try self.writeWithContext(poly.var_, .General, root_idx); - }, .empty_record => { - _ = try self.writer.write("{}"); + _ = try self.buf.writer().write("{}"); }, .tag_union => |tag_union| { try self.writeTagUnion(tag_union, root_idx); }, .empty_tag_union => { - _ = try self.writer.write("[]"); + _ = try self.buf.writer().write("[]"); }, } } @@ -861,17 +802,17 @@ pub const SnapshotWriter = struct { /// Write a tuple type pub fn writeTuple(self: *Self, tuple: SnapshotTuple, root_idx: SnapshotContentIdx) Allocator.Error!void { const elems = self.snapshots.sliceVars(tuple.elems); - _ = try self.writer.write("("); + _ = try self.buf.writer().write("("); for (elems, 0..) |elem, i| { - if (i > 0) _ = try self.writer.write(", "); + if (i > 0) _ = try self.buf.writer().write(", "); try self.writeWithContext(elem, .TupleFieldContent, root_idx); } - _ = try self.writer.write(")"); + _ = try self.buf.writer().write(")"); } /// Write a nominal type pub fn writeNominalType(self: *Self, nominal_type: SnapshotNominalType, root_idx: SnapshotContentIdx) Allocator.Error!void { - _ = try self.writer.write(self.idents.getText(nominal_type.ident.ident_idx)); + _ = try self.buf.writer().write(self.idents.getText(nominal_type.ident.ident_idx)); // The 1st var is the nominal type's backing var, so we skip it var vars = self.snapshots.sliceVars(nominal_type.vars); @@ -879,12 +820,12 @@ pub const SnapshotWriter = struct { vars = vars[1..]; if (vars.len > 0) { - _ = try self.writer.write("("); + _ = try self.buf.writer().write("("); for (vars, 0..) |arg, i| { - if (i > 0) _ = try self.writer.write(", "); + if (i > 0) _ = try self.buf.writer().write(", "); try self.writeWithContext(arg, .General, root_idx); } - _ = try self.writer.write(")"); + _ = try self.buf.writer().write(")"); } // Add origin information if it's from a different module @@ -893,9 +834,9 @@ pub const SnapshotWriter = struct { // Only show origin if it's different from the current module if (!std.mem.eql(u8, origin_module_name, current_module)) { - _ = try self.writer.write(" (from "); - _ = try self.writer.write(origin_module_name); - _ = try self.writer.write(")"); + _ = try self.buf.writer().write(" (from "); + _ = try self.buf.writer().write(origin_module_name); + _ = try self.buf.writer().write(")"); } } } @@ -911,38 +852,38 @@ pub const SnapshotWriter = struct { // Write arguments if (args.len == 0) { - _ = try self.writer.write("({})"); + _ = try self.buf.writer().write("({})"); } else if (args.len == 1) { try self.writeWithContext(args[0], .FunctionArgument, root_idx); } else { for (args, 0..) |arg, i| { - if (i > 0) _ = try self.writer.write(", "); + if (i > 0) _ = try self.buf.writer().write(", "); try self.writeWithContext(arg, .FunctionArgument, root_idx); } } - _ = try self.writer.write(arrow); + _ = try self.buf.writer().write(arrow); try self.writeWithContext(func.ret, .FunctionReturn, root_idx); } /// Write a record type pub fn writeRecord(self: *Self, record: SnapshotRecord, root_idx: SnapshotContentIdx) Allocator.Error!void { - _ = try self.writer.write("{ "); + _ = try self.buf.writer().write("{ "); const fields_slice = self.snapshots.record_fields.sliceRange(record.fields); if (fields_slice.len > 0) { // Write first field - _ = try self.writer.write(self.idents.getText(fields_slice.items(.name)[0])); - _ = try self.writer.write(": "); + _ = try self.buf.writer().write(self.idents.getText(fields_slice.items(.name)[0])); + _ = try self.buf.writer().write(": "); try self.writeWithContext(fields_slice.items(.content)[0], .RecordFieldContent, root_idx); // Write remaining fields for (fields_slice.items(.name)[1..], fields_slice.items(.content)[1..]) |name, content| { - _ = try self.writer.write(", "); - _ = try self.writer.write(self.idents.getText(name)); - _ = try self.writer.write(": "); + _ = try self.buf.writer().write(", "); + _ = try self.buf.writer().write(self.idents.getText(name)); + _ = try self.buf.writer().write(": "); try self.writeWithContext(content, .RecordFieldContent, root_idx); } } @@ -952,73 +893,68 @@ pub const SnapshotWriter = struct { .structure => |flat_type| switch (flat_type) { .empty_record => {}, // Don't show empty extension else => { - if (fields_slice.len > 0) _ = try self.writer.write(", "); + if (fields_slice.len > 0) _ = try self.buf.writer().write(", "); try self.writeWithContext(record.ext, .RecordExtension, root_idx); }, }, else => { - if (fields_slice.len > 0) _ = try self.writer.write(", "); + if (fields_slice.len > 0) _ = try self.buf.writer().write(", "); try self.writeWithContext(record.ext, .RecordExtension, root_idx); }, } - _ = try self.writer.write(" }"); + _ = try self.buf.writer().write(" }"); } /// Write record fields without extension pub fn writeRecordFields(self: *Self, fields: SnapshotRecordFieldSafeList.Range, root_idx: SnapshotContentIdx) Allocator.Error!void { if (fields.isEmpty()) { - _ = try self.writer.write("{}"); + _ = try self.buf.writer().write("{}"); return; } const fields_slice = self.snapshots.record_fields.sliceRange(fields); - _ = try self.writer.write("{ "); + _ = try self.buf.writer().write("{ "); // Write first field - we already verified that there is at least one field. - _ = try self.writer.write(self.idents.getText(fields_slice.items(.name)[0])); - _ = try self.writer.write(": "); + _ = try self.buf.writer().write(self.idents.getText(fields_slice.items(.name)[0])); + _ = try self.buf.writer().write(": "); try self.writeWithContext(fields_slice.items(.content)[0], .RecordFieldContent, root_idx); // Write remaining fields for (fields_slice.items(.name)[1..], fields_slice.items(.content)[1..]) |name, content| { - _ = try self.writer.write(", "); - _ = try self.writer.write(self.idents.getText(name)); - _ = try self.writer.write(": "); + _ = try self.buf.writer().write(", "); + _ = try self.buf.writer().write(self.idents.getText(name)); + _ = try self.buf.writer().write(": "); try self.writeWithContext(content, .RecordFieldContent, root_idx); } - _ = try self.writer.write(" }"); + _ = try self.buf.writer().write(" }"); } /// Write a tag union pub fn writeTagUnion(self: *Self, tag_union: SnapshotTagUnion, root_idx: SnapshotContentIdx) Allocator.Error!void { - _ = try self.writer.write("["); + _ = try self.buf.writer().write("["); var iter = tag_union.tags.iterIndices(); while (iter.next()) |tag_idx| { if (@intFromEnum(tag_idx) > @intFromEnum(tag_union.tags.start)) { - _ = try self.writer.write(", "); + _ = try self.buf.writer().write(", "); } const tag = self.snapshots.tags.get(tag_idx); try self.writeTag(tag, root_idx); } - _ = try self.writer.write("]"); + _ = try self.buf.writer().write("]"); // Show extension variable if it's not empty switch (self.snapshots.contents.get(tag_union.ext).*) { - .flex_var => |mb_ident| { - if (mb_ident) |ident_idx| { - _ = try self.writer.write(self.idents.getText(ident_idx)); + .flex => |flex| { + if (flex.ident) |ident_idx| { + _ = try self.buf.writer().write(self.idents.getText(ident_idx)); } else { - // Check if this variable appears multiple times - const occurrences = self.countOccurrences(tag_union.ext, root_idx); - if (occurrences == 1) { - _ = try self.writer.write("_"); - } - try self.generateContextualName(.TagUnionExtension); + _ = try self.writeFlexVarName(flex.var_, tag_union.ext, .TagUnionExtension, root_idx); } }, .structure => |flat_type| switch (flat_type) { @@ -1027,8 +963,8 @@ pub const SnapshotWriter = struct { try self.writeWithContext(tag_union.ext, .TagUnionExtension, root_idx); }, }, - .rigid_var => |ident_idx| { - _ = try self.writer.write(self.idents.getText(ident_idx)); + .rigid => |rigid_name| { + _ = try self.buf.writer().write(self.idents.getText(rigid_name)); }, else => { try self.writeWithContext(tag_union.ext, .TagUnionExtension, root_idx); @@ -1038,15 +974,15 @@ pub const SnapshotWriter = struct { /// Write a single tag pub fn writeTag(self: *Self, tag: SnapshotTag, root_idx: SnapshotContentIdx) Allocator.Error!void { - _ = try self.writer.write(self.idents.getText(tag.name)); + _ = try self.buf.writer().write(self.idents.getText(tag.name)); const args = self.snapshots.sliceVars(tag.args); if (args.len > 0) { - _ = try self.writer.write("("); + _ = try self.buf.writer().write("("); for (args, 0..) |arg, i| { - if (i > 0) _ = try self.writer.write(", "); + if (i > 0) _ = try self.buf.writer().write(", "); try self.writeWithContext(arg, .General, root_idx); } - _ = try self.writer.write(")"); + _ = try self.buf.writer().write(")"); } } @@ -1054,74 +990,222 @@ pub const SnapshotWriter = struct { pub fn writeNum(self: *Self, num: SnapshotNum, root_idx: SnapshotContentIdx) Allocator.Error!void { switch (num) { .num_poly => |sub_var| { - _ = try self.writer.write("Num("); + _ = try self.buf.writer().write("Num("); try self.writeWithContext(sub_var, .NumContent, root_idx); - _ = try self.writer.write(")"); + _ = try self.buf.writer().write(")"); }, .int_poly => |sub_var| { - _ = try self.writer.write("Int("); + _ = try self.buf.writer().write("Int("); try self.writeWithContext(sub_var, .NumContent, root_idx); - _ = try self.writer.write(")"); + _ = try self.buf.writer().write(")"); }, .frac_poly => |sub_var| { - _ = try self.writer.write("Frac("); + _ = try self.buf.writer().write("Frac("); try self.writeWithContext(sub_var, .NumContent, root_idx); - _ = try self.writer.write(")"); + _ = try self.buf.writer().write(")"); }, .num_unbound => |_| { - _ = try self.writer.write("Num(_"); + _ = try self.buf.writer().write("Num(_"); try self.generateContextualName(.NumContent); - _ = try self.writer.write(")"); + _ = try self.buf.writer().write(")"); }, .int_unbound => |_| { - _ = try self.writer.write("Int(_"); + _ = try self.buf.writer().write("Int(_"); try self.generateContextualName(.NumContent); - _ = try self.writer.write(")"); + _ = try self.buf.writer().write(")"); }, .frac_unbound => |_| { - _ = try self.writer.write("Frac(_"); + _ = try self.buf.writer().write("Frac(_"); try self.generateContextualName(.NumContent); - _ = try self.writer.write(")"); + _ = try self.buf.writer().write(")"); }, .int_precision => |prec| { - try self.writeIntType(prec); + try self.writeIntType(prec, .precision); }, .frac_precision => |prec| { - try self.writeFracType(prec); + try self.writeFracType(prec, .precision); }, .num_compact => |compact| { switch (compact) { .int => |prec| { - try self.writeIntType(prec); + try self.writeIntType(prec, .compacted); }, .frac => |prec| { - try self.writeFracType(prec); + try self.writeFracType(prec, .compacted); }, } }, } } - pub fn writeIntType(self: *Self, prec: types.Num.Int.Precision) Allocator.Error!void { - _ = switch (prec) { - .u8 => try self.writer.write("U8"), - .i8 => try self.writer.write("I8"), - .u16 => try self.writer.write("U16"), - .i16 => try self.writer.write("I16"), - .u32 => try self.writer.write("U32"), - .i32 => try self.writer.write("I32"), - .u64 => try self.writer.write("U64"), - .i64 => try self.writer.write("I64"), - .u128 => try self.writer.write("U128"), - .i128 => try self.writer.write("I128"), - }; + const NumPrecType = enum { precision, compacted }; + + fn writeIntType(self: *Self, prec: types.Num.Int.Precision, num_type: NumPrecType) std.mem.Allocator.Error!void { + switch (num_type) { + .compacted => { + _ = switch (prec) { + .u8 => try self.buf.writer().write("Num(Int(Unsigned8))"), + .i8 => try self.buf.writer().write("Num(Int(Signed8))"), + .u16 => try self.buf.writer().write("Num(Int(Unsigned16))"), + .i16 => try self.buf.writer().write("Num(Int(Signed16))"), + .u32 => try self.buf.writer().write("Num(Int(Unsigned32))"), + .i32 => try self.buf.writer().write("Num(Int(Signed32))"), + .u64 => try self.buf.writer().write("Num(Int(Unsigned64))"), + .i64 => try self.buf.writer().write("Num(Int(Signed64))"), + .u128 => try self.buf.writer().write("Num(Int(Unsigned128))"), + .i128 => try self.buf.writer().write("Num(Int(Signed128))"), + }; + }, + .precision => { + _ = switch (prec) { + .u8 => try self.buf.writer().write("Unsigned8"), + .i8 => try self.buf.writer().write("Signed8"), + .u16 => try self.buf.writer().write("Unsigned16"), + .i16 => try self.buf.writer().write("Signed16"), + .u32 => try self.buf.writer().write("Unsigned32"), + .i32 => try self.buf.writer().write("Signed32"), + .u64 => try self.buf.writer().write("Unsigned64"), + .i64 => try self.buf.writer().write("Signed64"), + .u128 => try self.buf.writer().write("Unsigned128"), + .i128 => try self.buf.writer().write("Signed128"), + }; + }, + } } - pub fn writeFracType(self: *Self, prec: types.Num.Frac.Precision) Allocator.Error!void { - _ = switch (prec) { - .f32 => try self.writer.write("F32"), - .f64 => try self.writer.write("F64"), - .dec => try self.writer.write("Dec"), - }; + fn writeFracType(self: *Self, prec: types.Num.Frac.Precision, num_type: NumPrecType) std.mem.Allocator.Error!void { + switch (num_type) { + .compacted => { + _ = switch (prec) { + .f32 => try self.buf.writer().write("Num(Frac(Float32))"), + .f64 => try self.buf.writer().write("Num(Frac(Float64))"), + .dec => try self.buf.writer().write("Num(Frac(Decimal))"), + }; + }, + .precision => { + _ = switch (prec) { + .f32 => try self.buf.writer().write("Float32"), + .f64 => try self.buf.writer().write("Float64"), + .dec => try self.buf.writer().write("Decimal"), + }; + }, + } + } + + /// Generate a name for a flex var that may appear multiple times in the type + pub fn writeFlexVarName(self: *Self, flex_var: Var, _: SnapshotContentIdx, context: TypeContext, root_idx: SnapshotContentIdx) std.mem.Allocator.Error!void { + // Check if we've seen this flex var before. + if (self.flex_var_names_map.get(flex_var)) |range| { + // If so, then use that name + _ = try self.buf.writer().write( + self.flex_var_names.items[range.start..range.end], + ); + } else { + + // Check if this variable appears multiple times + const occurrences = self.countOccurrences(flex_var, root_idx); + + if (occurrences == 1) { + // If it appears once, then generate the contextual name + _ = try self.buf.writer().write("_"); + try self.generateContextualName(context); + } else { + // If it appears more than once, then we have to track the name we + // assign it so it appears consistently across the type str + + // Generate a new general var name. We do not use the context here + // because that may be the current context the var appears in, but + // the var may later appear in a different context + const buf_start = self.buf.items.len; + try self.generateContextualName(.General); + const buf_end = self.buf.items.len; + + // Then write down the name we generated for later + const flex_start = self.flex_var_names.items.len; + try self.flex_var_names.appendSlice(self.buf.items[buf_start..buf_end]); + const flex_end = self.flex_var_names.items.len; + try self.flex_var_names_map.put(flex_var, .{ .start = flex_start, .end = flex_end }); + } + } + } + + fn countOccurrences(self: *const Self, search_flex_var: Var, root_idx: SnapshotContentIdx) usize { + var count: usize = 0; + self.countContent(search_flex_var, root_idx, &count); + return count; + } + + fn countContent(self: *const Self, search_flex_var: Var, current_idx: SnapshotContentIdx, count: *usize) void { + const content = self.snapshots.contents.get(current_idx); + switch (content.*) { + .flex => |cur_flex| { + if (search_flex_var == cur_flex.var_) { + count.* += 1; + } + }, + .rigid, .recursive, .err => {}, + .alias => |alias| { + const args = self.snapshots.sliceVars(alias.vars); + for (args) |arg_idx| { + self.countContent(search_flex_var, arg_idx, count); + } + }, + .structure => |flat_type| { + self.countInFlatType(search_flex_var, flat_type, count); + }, + } + } + + fn countInFlatType(self: *const Self, search_flex_var: Var, flat_type: SnapshotFlatType, count: *usize) void { + switch (flat_type) { + .str, .empty_record, .empty_tag_union => {}, + .box => |sub_idx| self.countContent(search_flex_var, sub_idx, count), + .list => |sub_idx| self.countContent(search_flex_var, sub_idx, count), + .list_unbound, .num => {}, + .tuple => |tuple| { + const elems = self.snapshots.sliceVars(tuple.elems); + for (elems) |elem| { + self.countContent(search_flex_var, elem, count); + } + }, + .nominal_type => |nominal_type| { + const args = self.snapshots.sliceVars(nominal_type.vars); + // Skip the first var which is the nominal type's backing var + for (args[1..]) |arg_idx| { + self.countContent(search_flex_var, arg_idx, count); + } + }, + .fn_pure, .fn_effectful, .fn_unbound => |func| { + const args = self.snapshots.sliceVars(func.args); + for (args) |arg| { + self.countContent(search_flex_var, arg, count); + } + self.countContent(search_flex_var, func.ret, count); + }, + .record => |record| { + const fields = self.snapshots.record_fields.sliceRange(record.fields); + for (fields.items(.content)) |field_content| { + self.countContent(search_flex_var, field_content, count); + } + self.countContent(search_flex_var, record.ext, count); + }, + .record_unbound => |fields| { + const fields_slice = self.snapshots.record_fields.sliceRange(fields); + for (fields_slice.items(.content)) |field_content| { + self.countContent(search_flex_var, field_content, count); + } + }, + .tag_union => |tag_union| { + var iter = tag_union.tags.iterIndices(); + while (iter.next()) |tag_idx| { + const tag = self.snapshots.tags.get(tag_idx); + const args = self.snapshots.sliceVars(tag.args); + for (args) |arg_idx| { + self.countContent(search_flex_var, arg_idx, count); + } + } + self.countContent(search_flex_var, tag_union.ext, count); + }, + } } }; diff --git a/src/check/test/TestEnv.zig b/src/check/test/TestEnv.zig new file mode 100644 index 0000000000..34abebabdc --- /dev/null +++ b/src/check/test/TestEnv.zig @@ -0,0 +1,334 @@ +//! Test environment for canonicalization testing, providing utilities to parse, canonicalize, and inspect Roc expressions. + +const std = @import("std"); +const base = @import("base"); +const types = @import("types"); +const parse = @import("parse"); +const CIR = @import("can").CIR; +const Can = @import("can").Can; +const ModuleEnv = @import("can").ModuleEnv; + +const Check = @import("../Check.zig"); +const problem_mod = @import("../problem.zig"); + +const CommonEnv = base.CommonEnv; +const testing = std.testing; + +gpa: std.mem.Allocator, +module_env: *ModuleEnv, +parse_ast: *parse.AST, +can: *Can, +checker: Check, +type_writer: types.TypeWriter, + +module_envs: std.StringHashMap(*const ModuleEnv), +other_envs: std.array_list.Managed(*const ModuleEnv), + +/// Test environment for canonicalization testing, providing a convenient wrapper around ModuleEnv, AST, and Can. +const TestEnv = @This(); + +/// Initialize where the provided source is an entire file +/// +/// Accepts another module that should already be can'd and type checked, and will +/// add that module as an import to this module +pub fn initWithImport(source: []const u8, other_module_name: []const u8, other_module_env: *const ModuleEnv) !TestEnv { + const gpa = std.testing.allocator; + + // Allocate our ModuleEnv, AST, and Can on the heap + // so we can keep them around for testing purposes... + // this is an unusual setup, but helps us with testing + const module_env: *ModuleEnv = try gpa.create(ModuleEnv); + errdefer gpa.destroy(module_env); + + const parse_ast = try gpa.create(parse.AST); + errdefer gpa.destroy(parse_ast); + + const can = try gpa.create(Can); + errdefer gpa.destroy(can); + + var module_envs = std.StringHashMap(*const ModuleEnv).init(gpa); + var other_envs = std.array_list.Managed(*const ModuleEnv).init(gpa); + + // Put the other module in the env map + try module_envs.put(other_module_name, other_module_env); + + const module_name = "Test"; + std.debug.assert(!std.mem.eql(u8, module_name, other_module_name)); + + // Initialize the ModuleEnv with the CommonEnv + module_env.* = try ModuleEnv.init(gpa, source); + errdefer module_env.deinit(); + + module_env.common.source = source; + module_env.module_name = module_name; + try module_env.common.calcLineStarts(gpa); + + const module_common_idents: Check.CommonIdents = .{ + .module_name = try module_env.insertIdent(base.Ident.for_text(module_name)), + .list = try module_env.insertIdent(base.Ident.for_text("List")), + .box = try module_env.insertIdent(base.Ident.for_text("Box")), + }; + + // Parse the AST + parse_ast.* = try parse.parse(&module_env.common, gpa); + errdefer parse_ast.deinit(gpa); + parse_ast.store.emptyScratch(); + + // Canonicalize + try module_env.initCIRFields(gpa, "test"); + can.* = try Can.init(module_env, parse_ast, &module_envs, .{}); + errdefer can.deinit(); + + try can.canonicalizeFile(); + try can.validateForChecking(); + + // Pull out the imported index + std.debug.assert(can.import_indices.size == 1); + const import_idx = can.import_indices.get(other_module_name).?; + std.debug.assert(@intFromEnum(import_idx) == 0); + try other_envs.append(other_module_env); + + // Type Check + var checker = try Check.init(gpa, &module_env.types, module_env, other_envs.items, &module_env.store.regions, module_common_idents); + errdefer checker.deinit(); + + try checker.checkFile(); + + var type_writer = try module_env.initTypeWriter(); + errdefer type_writer.deinit(); + + return TestEnv{ + .gpa = gpa, + .module_env = module_env, + .parse_ast = parse_ast, + .can = can, + .checker = checker, + .type_writer = type_writer, + .module_envs = module_envs, + .other_envs = other_envs, + }; +} + +/// Initialize where the provided source is an entire file +pub fn init(source: []const u8) !TestEnv { + const gpa = std.testing.allocator; + + // Allocate our ModuleEnv, AST, and Can on the heap + // so we can keep them around for testing purposes... + // this is an unusual setup, but helps us with testing + const module_env: *ModuleEnv = try gpa.create(ModuleEnv); + errdefer gpa.destroy(module_env); + + const parse_ast = try gpa.create(parse.AST); + errdefer gpa.destroy(parse_ast); + + const can = try gpa.create(Can); + errdefer gpa.destroy(can); + + const module_envs = std.StringHashMap(*const ModuleEnv).init(gpa); + const other_envs = std.array_list.Managed(*const ModuleEnv).init(gpa); + + const module_name = "Test"; + + // Initialize the ModuleEnv with the CommonEnv + module_env.* = try ModuleEnv.init(gpa, source); + errdefer module_env.deinit(); + + module_env.common.source = source; + module_env.module_name = module_name; + try module_env.common.calcLineStarts(gpa); + + const module_common_idents: Check.CommonIdents = .{ + .module_name = try module_env.insertIdent(base.Ident.for_text(module_name)), + .list = try module_env.insertIdent(base.Ident.for_text("List")), + .box = try module_env.insertIdent(base.Ident.for_text("Box")), + }; + + // Parse the AST + parse_ast.* = try parse.parse(&module_env.common, gpa); + errdefer parse_ast.deinit(gpa); + parse_ast.store.emptyScratch(); + + // Canonicalize + try module_env.initCIRFields(gpa, "test"); + can.* = try Can.init(module_env, parse_ast, null, .{}); + errdefer can.deinit(); + + try can.canonicalizeFile(); + try can.validateForChecking(); + + // Type Check + var checker = try Check.init(gpa, &module_env.types, module_env, &.{}, &module_env.store.regions, module_common_idents); + errdefer checker.deinit(); + + try checker.checkFile(); + + var type_writer = try module_env.initTypeWriter(); + errdefer type_writer.deinit(); + + return TestEnv{ + .gpa = gpa, + .module_env = module_env, + .parse_ast = parse_ast, + .can = can, + .checker = checker, + .type_writer = type_writer, + .module_envs = module_envs, + .other_envs = other_envs, + }; +} + +/// Initialize where the provided source a single expression +pub fn initExpr(comptime source_expr: []const u8) !TestEnv { + const source_wrapper = + \\module [] + \\ + \\main = + ; + + var source: [source_wrapper.len + 1 + source_expr.len]u8 = undefined; + std.mem.copyForwards(u8, source[0..], source_wrapper); + std.mem.copyForwards(u8, source[source_wrapper.len..], " "); + std.mem.copyForwards(u8, source[source_wrapper.len + 1 ..], source_expr); + + return TestEnv.init(&source); +} + +pub fn deinit(self: *TestEnv) void { + self.can.deinit(); + self.gpa.destroy(self.can); + self.parse_ast.deinit(self.gpa); + self.gpa.destroy(self.parse_ast); + + self.checker.deinit(); + self.type_writer.deinit(); + + // ModuleEnv.deinit calls self.common.deinit() to clean up CommonEnv's internals + // Since common is now a value field, we don't need to free it separately + self.module_env.deinit(); + self.gpa.destroy(self.module_env); + + self.module_envs.deinit(); + self.other_envs.deinit(); +} + +/// Get the inferred type of the last declaration and compare it to the provided +/// expected type string. +/// +/// Also assert that there were no problems processing the source code. +pub fn assertLastDefType(self: *TestEnv, expected: []const u8) !void { + try self.assertNoParseProblems(); + // try self.assertNoCanProblems(); + try self.assertNoTypeProblems(); + + try testing.expect(self.module_env.all_defs.span.len > 0); + const defs_slice = self.module_env.store.sliceDefs(self.module_env.all_defs); + const last_def_idx = defs_slice[defs_slice.len - 1]; + + try testing.expectEqualStrings(expected, try self.type_writer.writeGet(ModuleEnv.varFrom(last_def_idx))); +} + +/// Get the inferred type descriptor of the last declaration +/// +/// Also assert that there were no problems processing the source code. +pub fn getLastExprType(self: *TestEnv) !types.Descriptor { + try self.assertNoParseProblems(); + // try self.assertNoCanProblems(); + try self.assertNoTypeProblems(); + + try testing.expect(self.module_env.all_defs.span.len > 0); + const defs_slice = self.module_env.store.sliceDefs(self.module_env.all_defs); + const last_def_idx = defs_slice[defs_slice.len - 1]; + + return self.module_env.types.resolveVar(ModuleEnv.varFrom(last_def_idx)).desc; +} + +/// Assert that there was a single type error when checking the input. Assert +/// that the title of the type error matches the expected title. +pub fn assertOneTypeError(self: *TestEnv, expected: []const u8) !void { + try self.assertNoParseProblems(); + // try self.assertNoCanProblems(); + + // Assert 1 problem + try testing.expectEqual(1, self.checker.problems.problems.items.len); + const problem = self.checker.problems.problems.items[0]; + + // Assert the rendered problem matches the expected problem + var report_builder = problem_mod.ReportBuilder.init( + self.gpa, + self.module_env, + self.module_env, + &self.checker.snapshots, + "test", + &.{}, + ); + defer report_builder.deinit(); + + var report = try report_builder.build(problem); + defer report.deinit(); + + try testing.expectEqualStrings(expected, report.title); +} + +fn assertNoParseProblems(self: *TestEnv) !void { + if (self.parse_ast.hasErrors()) { + var report_buf = try std.array_list.Managed(u8).initCapacity(self.gpa, 256); + defer report_buf.deinit(); + + for (self.parse_ast.tokenize_diagnostics.items) |tok_diag| { + var report = try self.parse_ast.tokenizeDiagnosticToReport(tok_diag, self.gpa); + defer report.deinit(); + + report_buf.clearRetainingCapacity(); + try report.render(report_buf.writer(), .markdown); + + try testing.expectEqualStrings("EXPECTED NO ERROR", report_buf.items); + } + + for (self.parse_ast.parse_diagnostics.items) |diag| { + var report = try self.parse_ast.parseDiagnosticToReport(&self.module_env.common, diag, self.gpa, self.module_env.module_name); + defer report.deinit(); + + report_buf.clearRetainingCapacity(); + try report.render(report_buf.writer(), .markdown); + + try testing.expectEqualStrings("EXPECTED NO ERROR", report_buf.items); + } + } +} + +fn assertNoCanProblems(self: *TestEnv) !void { + var report_buf = try std.array_list.Managed(u8).initCapacity(self.gpa, 256); + defer report_buf.deinit(); + + const diagnostics = try self.module_env.getDiagnostics(); + for (diagnostics) |d| { + var report = try self.module_env.diagnosticToReport(d, self.gpa, self.module_env.module_name); + defer report.deinit(); + + report_buf.clearRetainingCapacity(); + try report.render(report_buf.writer(), .markdown); + + try testing.expectEqualStrings("EXPECTED NO ERROR", report_buf.items); + } +} + +fn assertNoTypeProblems(self: *TestEnv) !void { + var report_builder = problem_mod.ReportBuilder.init(self.gpa, self.module_env, self.module_env, &self.checker.snapshots, "test", &.{}); + defer report_builder.deinit(); + + var report_buf = try std.array_list.Managed(u8).initCapacity(self.gpa, 256); + defer report_buf.deinit(); + + for (self.checker.problems.problems.items) |problem| { + var report = try report_builder.build(problem); + defer report.deinit(); + + report_buf.clearRetainingCapacity(); + try report.render(report_buf.writer(), .markdown); + + try testing.expectEqualStrings("EXPECTED NO ERROR", report_buf.items); + } + + try testing.expectEqual(0, self.checker.problems.problems.items.len); +} diff --git a/src/check/test/compiled_builtins_test.zig b/src/check/test/compiled_builtins_test.zig new file mode 100644 index 0000000000..03240b503e --- /dev/null +++ b/src/check/test/compiled_builtins_test.zig @@ -0,0 +1,209 @@ +//! Tests for compiled builtin modules (Set and Dict). +//! +//! These tests verify that the build-time compiled Set and Dict modules +//! can be loaded from their serialized .bin files and used in type checking. + +const std = @import("std"); +const base = @import("base"); +const types_mod = @import("types"); +const can = @import("can"); +const collections = @import("collections"); +const Check = @import("../Check.zig"); +const TestEnv = @import("./TestEnv.zig"); + +const ModuleEnv = can.ModuleEnv; +const testing = std.testing; +const compiled_builtins = @import("compiled_builtins"); + +/// Wrapper for a loaded compiled module that tracks the buffer +const LoadedModule = struct { + env: *ModuleEnv, + buffer: []align(collections.CompactWriter.SERIALIZATION_ALIGNMENT) u8, + gpa: std.mem.Allocator, + + fn deinit(self: *LoadedModule) void { + // Only free the hashmap that was allocated during deserialization + // Most other data (like the SafeList contents) points into the buffer + self.env.imports.map.deinit(self.gpa); + + // Free the buffer (the env points into this buffer for most data) + self.gpa.free(self.buffer); + // Free the env struct itself + self.gpa.destroy(self.env); + } +}; + +/// Load a compiled ModuleEnv from embedded binary data +fn loadCompiledModule(gpa: std.mem.Allocator, bin_data: []const u8, module_name: []const u8, source: []const u8) !LoadedModule { + // Copy the embedded data to properly aligned memory + // CompactWriter requires specific alignment for serialization + const CompactWriter = collections.CompactWriter; + const buffer = try gpa.alignedAlloc(u8, CompactWriter.SERIALIZATION_ALIGNMENT, bin_data.len); + @memcpy(buffer, bin_data); + + // Cast to the serialized structure + const serialized_ptr = @as( + *ModuleEnv.Serialized, + @ptrCast(@alignCast(buffer.ptr)), + ); + + const env = try gpa.create(ModuleEnv); + errdefer gpa.destroy(env); + + // Deserialize + const base_ptr = @intFromPtr(buffer.ptr); + env.* = ModuleEnv{ + .gpa = gpa, + .common = serialized_ptr.common.deserialize(@as(i64, @intCast(base_ptr)), source).*, + .types = serialized_ptr.types.deserialize(@as(i64, @intCast(base_ptr)), gpa).*, + .module_kind = serialized_ptr.module_kind, + .all_defs = serialized_ptr.all_defs, + .all_statements = serialized_ptr.all_statements, + .exports = serialized_ptr.exports, + .builtin_statements = serialized_ptr.builtin_statements, + .external_decls = serialized_ptr.external_decls.deserialize(@as(i64, @intCast(base_ptr))).*, + .imports = serialized_ptr.imports.deserialize(@as(i64, @intCast(base_ptr)), gpa).*, + .module_name = module_name, + .diagnostics = serialized_ptr.diagnostics, + .store = serialized_ptr.store.deserialize(@as(i64, @intCast(base_ptr)), gpa).*, + }; + + return LoadedModule{ + .env = env, + .buffer = buffer, + .gpa = gpa, + }; +} + +test "compiled builtins - load Dict" { + const gpa = testing.allocator; + + const dict_source = "Dict := [EmptyDict].{}\n"; + var dict_loaded = try loadCompiledModule(gpa, compiled_builtins.dict_bin, "Dict", dict_source); + defer dict_loaded.deinit(); + + // Verify the module loaded + try testing.expectEqualStrings("Dict", dict_loaded.env.module_name); +} + +test "compiled builtins - load Set" { + const gpa = testing.allocator; + + const set_source = "import Dict\n\nSet := [EmptySet(Dict)].{}\n"; + var set_loaded = try loadCompiledModule(gpa, compiled_builtins.set_bin, "Set", set_source); + defer set_loaded.deinit(); + + // Verify the module loaded + try testing.expectEqualStrings("Set", set_loaded.env.module_name); +} + +test "compiled builtins - use Set and Dict together" { + const gpa = testing.allocator; + + // Load Dict first + const dict_source = "Dict := [EmptyDict].{}\n"; + var dict_loaded = try loadCompiledModule(gpa, compiled_builtins.dict_bin, "Dict", dict_source); + defer dict_loaded.deinit(); + + // Load Set (which imports Dict) + const set_source = "import Dict\n\nSet := [EmptySet(Dict)].{}\n"; + var set_loaded = try loadCompiledModule(gpa, compiled_builtins.set_bin, "Set", set_source); + defer set_loaded.deinit(); + + // Now create a test that uses both Set and Dict + const test_source = + \\module [] + \\ + \\import Set + \\import Dict + \\ + \\x : Set + \\x = Set.EmptySet(Dict.EmptyDict) + \\ + \\main = match x { + \\ Set.EmptySet(Dict.EmptyDict) => "empty" + \\} + ; + + // Create module environment with Set and Dict imported + var module_env: *ModuleEnv = try gpa.create(ModuleEnv); + errdefer gpa.destroy(module_env); + + module_env.* = try ModuleEnv.init(gpa, test_source); + errdefer module_env.deinit(); + + module_env.common.source = test_source; + module_env.module_name = "Test"; + try module_env.common.calcLineStarts(gpa); + + const module_common_idents: Check.CommonIdents = .{ + .module_name = try module_env.insertIdent(base.Ident.for_text("Test")), + .list = try module_env.insertIdent(base.Ident.for_text("List")), + .box = try module_env.insertIdent(base.Ident.for_text("Box")), + }; + + // Parse + const parse = @import("parse"); + var parse_ast = try gpa.create(parse.AST); + defer { + parse_ast.deinit(gpa); + gpa.destroy(parse_ast); + } + + parse_ast.* = try parse.parse(&module_env.common, gpa); + parse_ast.store.emptyScratch(); + + if (parse_ast.hasErrors()) { + std.debug.print("Parse errors:\n", .{}); + for (parse_ast.tokenize_diagnostics.items) |diag| { + std.debug.print(" Tokenize: {any}\n", .{diag}); + } + for (parse_ast.parse_diagnostics.items) |diag| { + std.debug.print(" Parse: {any}\n", .{diag}); + } + return error.ParseError; + } + + // Set up module imports + var module_envs = std.StringHashMap(*const ModuleEnv).init(gpa); + defer module_envs.deinit(); + try module_envs.put("Set", set_loaded.env); + try module_envs.put("Dict", dict_loaded.env); + + // Canonicalize + try module_env.initCIRFields(gpa, "test"); + var can_result = try gpa.create(can.Can); + defer { + can_result.deinit(); + gpa.destroy(can_result); + } + + can_result.* = try can.Can.init(module_env, parse_ast, &module_envs, .{}); + try can_result.canonicalizeFile(); + try can_result.validateForChecking(); + + // Type check + var other_envs = std.array_list.Managed(*const ModuleEnv).init(gpa); + defer other_envs.deinit(); + try other_envs.append(set_loaded.env); + try other_envs.append(dict_loaded.env); + + var checker = try Check.init( + gpa, + &module_env.types, + module_env, + other_envs.items, + &module_env.store.regions, + module_common_idents, + ); + defer checker.deinit(); + + try checker.checkFile(); + + // Verify no type errors + try testing.expectEqual(0, checker.problems.problems.items.len); + + // Clean up module_env + module_env.deinit(); + gpa.destroy(module_env); +} diff --git a/src/check/test/cross_module_test.zig b/src/check/test/cross_module_test.zig index 40c5f5c609..97110a2f1a 100644 --- a/src/check/test/cross_module_test.zig +++ b/src/check/test/cross_module_test.zig @@ -5,6 +5,7 @@ const base = @import("base"); const types_mod = @import("types"); const can = @import("can"); const Check = @import("../Check.zig"); +const TestEnv = @import("./TestEnv.zig"); const CIR = can.CIR; const Var = types_mod.Var; @@ -21,1415 +22,103 @@ const UnifierScratch = @import("../unify.zig").Scratch; const OccursScratch = occurs.Scratch; const unify = @import("../unify.zig").unify; -test "cross-module type checking - monomorphic function" { - const allocator = testing.allocator; +test "cross-module type checking - monomorphic function passes" { + const source_a = + \\module [id_str] + \\ + \\id_str : Str -> Str + \\id_str = |s| s + ; + var test_env_a = try TestEnv.init(source_a); + defer test_env_a.deinit(); + try test_env_a.assertLastDefType("Str -> Str"); - // Create module A that exports a simple function - var module_a_env = try ModuleEnv.init(allocator, ""); - defer module_a_env.deinit(); - - try module_a_env.initCIRFields(allocator, "ModuleA"); - const module_a_cir = &module_a_env; - - const i32_content = Content{ .structure = .{ .num = .{ .int_precision = .i32 } } }; - const arg1_var = try module_a_cir.addTypeSlotAndTypeVar(@enumFromInt(0), i32_content, base.Region.zero(), Var); - const arg2_var = try module_a_cir.addTypeSlotAndTypeVar(@enumFromInt(0), i32_content, base.Region.zero(), Var); - const ret_var = try module_a_cir.addTypeSlotAndTypeVar(@enumFromInt(0), i32_content, base.Region.zero(), Var); - - const func_content = try module_a_env.types.mkFuncPure(&[_]Var{ arg1_var, arg2_var }, ret_var); - const func_expr_idx = try module_a_cir.addExprAndTypeVar(.{ .e_int = .{ - .value = .{ .bytes = [_]u8{0} ** 16, .kind = .i128 }, - } }, func_content, base.Region.zero()); - - // Set the type of expression 0 (which maps to var 0) - // Type is already set by addExprAndTypeVar - - // Create array of module environments - var modules = std.array_list.Managed(*ModuleEnv).init(allocator); - defer modules.deinit(); - - try modules.append(module_a_cir); - - // Create module B that imports and uses the function from module A - var module_b_env = try ModuleEnv.init(allocator, ""); - defer module_b_env.deinit(); - - try module_b_env.initCIRFields(allocator, "ModuleB"); - const module_b_cir = &module_b_env; - - // Register the import of module A - _ = try module_b_cir.imports.getOrPut(allocator, &module_b_cir.common.strings, "ModuleA"); - - // Create an external lookup expression - const external_lookup_expr = try module_b_cir.addExprAndTypeVar(.{ - .e_lookup_external = .{ - .module_idx = @enumFromInt(0), // Direct index to module A in the array - .target_node_idx = @intCast(@intFromEnum(func_expr_idx)), - .region = base.Region.zero(), - }, - }, Content{ .flex_var = null }, base.Region.zero()); - - try modules.append(module_b_cir); - - // Type check module B - var checker = try Check.init(allocator, &module_b_env.types, module_b_cir, modules.items, &module_b_cir.store.regions); - defer checker.deinit(); - - _ = try checker.checkExpr(external_lookup_expr); - - // Verify that the external lookup has the correct type - const external_var = @as(Var, @enumFromInt(@intFromEnum(external_lookup_expr))); - const resolved = module_b_env.types.resolveVar(external_var); - - try testing.expect(resolved.desc.content == .structure); - try testing.expect(resolved.desc.content.structure == .fn_pure); - - const func = resolved.desc.content.structure.fn_pure; - const args = module_b_env.types.sliceVars(func.args); - try testing.expectEqual(@as(usize, 2), args.len); - - // Check that all arguments and return are I32 - for (args) |arg| { - const arg_resolved = module_b_env.types.resolveVar(arg); - try testing.expect(arg_resolved.desc.content == .structure); - try testing.expect(arg_resolved.desc.content.structure == .num); - try testing.expect(arg_resolved.desc.content.structure.num == .int_precision); - try testing.expectEqual(types_mod.Num.Int.Precision.i32, arg_resolved.desc.content.structure.num.int_precision); - } - - const ret_resolved = module_b_env.types.resolveVar(func.ret); - try testing.expect(ret_resolved.desc.content == .structure); - try testing.expect(ret_resolved.desc.content.structure == .num); - try testing.expect(ret_resolved.desc.content.structure.num == .int_precision); - try testing.expectEqual(types_mod.Num.Int.Precision.i32, ret_resolved.desc.content.structure.num.int_precision); + const source_b = + \\module [] + \\ + \\import A + \\ + \\main : Str + \\main = A.id_str("hello") + ; + var test_env_b = try TestEnv.initWithImport(source_b, "A", test_env_a.module_env); + defer test_env_b.deinit(); + try test_env_b.assertLastDefType("Str"); } -test "cross-module type checking - polymorphic function" { - const allocator = testing.allocator; +test "cross-module type checking - monomorphic function fails" { + const source_a = + \\module [id_str] + \\ + \\id_str : Str -> Str + \\id_str = |s| s + ; + var test_env_a = try TestEnv.init(source_a); + defer test_env_a.deinit(); + try test_env_a.assertLastDefType("Str -> Str"); - // Create module A that exports a polymorphic identity function - var module_a_env = try ModuleEnv.init(allocator, ""); - defer module_a_env.deinit(); - - try module_a_env.initCIRFields(allocator, "ModuleA"); - const module_a_cir = &module_a_env; - - // Create a function: identity : a -> a - const type_var_a = try module_a_cir.addTypeSlotAndTypeVar(@enumFromInt(0), Content{ .flex_var = null }, base.Region.zero(), Var); - const func_content = try module_a_env.types.mkFuncPure(&[_]Var{type_var_a}, type_var_a); - const func_expr_idx = try module_a_cir.addExprAndTypeVar(.{ .e_int = .{ - .value = .{ .bytes = [_]u8{0} ** 16, .kind = .i128 }, - } }, func_content, base.Region.zero()); - - // Create array of module environments - var modules = std.array_list.Managed(*ModuleEnv).init(allocator); - defer modules.deinit(); - - try modules.append(module_a_cir); - - // Create module B that imports and uses the polymorphic function - var module_b_env = try ModuleEnv.init(allocator, ""); - defer module_b_env.deinit(); - - try module_b_env.initCIRFields(allocator, "ModuleB"); - const module_b_cir = &module_b_env; - - // Register the import of module A - _ = try module_b_cir.imports.getOrPut(allocator, &module_b_cir.common.strings, "ModuleA"); - - // Create an external lookup expression - const external_lookup_expr = try module_b_cir.addExprAndTypeVar(.{ - .e_lookup_external = .{ - .module_idx = @enumFromInt(0), // Direct index to module A in the array - .target_node_idx = @intCast(@intFromEnum(func_expr_idx)), - .region = base.Region.zero(), - }, - }, Content{ .flex_var = null }, base.Region.zero()); - - try modules.append(module_b_cir); - - // Type check module B - var checker = try Check.init(allocator, &module_b_env.types, module_b_cir, modules.items, &module_b_cir.store.regions); - defer checker.deinit(); - - _ = try checker.checkExpr(external_lookup_expr); - - // Verify that the external lookup has a polymorphic type - const external_var = @as(Var, @enumFromInt(@intFromEnum(external_lookup_expr))); - const resolved = module_b_env.types.resolveVar(external_var); - - try testing.expect(resolved.desc.content == .structure); - try testing.expect(resolved.desc.content.structure == .fn_pure); - - const func = resolved.desc.content.structure.fn_pure; - const args = module_b_env.types.sliceVars(func.args); - try testing.expectEqual(@as(usize, 1), args.len); - - // The function should still be polymorphic (flex var) - const arg_resolved = module_b_env.types.resolveVar(args[0]); - const ret_resolved = module_b_env.types.resolveVar(func.ret); - - // Both should resolve to the same flex var - try testing.expectEqual(arg_resolved.var_, ret_resolved.var_); - try testing.expect(arg_resolved.desc.content == .flex_var); + const source_b = + \\module [] + \\ + \\import A + \\ + \\main : U8 + \\main = A.id_str(1) + ; + var test_env_b = try TestEnv.initWithImport(source_b, "A", test_env_a.module_env); + defer test_env_b.deinit(); + try test_env_b.assertOneTypeError("TYPE MISMATCH"); } -test "cross-module type checking - record type" { - const allocator = testing.allocator; +test "cross-module type checking - polymorphic function passes" { + const source_a = + \\module [id] + \\ + \\id : a -> a + \\id = |s| s + ; + var test_env_a = try TestEnv.init(source_a); + defer test_env_a.deinit(); + try test_env_a.assertLastDefType("a -> a"); - // Create module A that exports a record type - var module_a_env = try ModuleEnv.init(allocator, ""); - defer module_a_env.deinit(); - - try module_a_env.initCIRFields(allocator, "ModuleA"); - const module_a_cir = &module_a_env; - - // Create a record type { x: I32, y: Str } - var record_fields = std.array_list.Managed(types_mod.RecordField).init(allocator); - defer record_fields.deinit(); - - const x_ident = try module_a_env.insertIdent(base.Ident.for_text("x")); - const y_ident = try module_a_env.insertIdent(base.Ident.for_text("y")); - - const i32_var = try module_a_cir.addTypeSlotAndTypeVar(@enumFromInt(0), Content{ .structure = .{ .num = .{ .int_precision = .i32 } } }, base.Region.zero(), Var); - const str_var = try module_a_cir.addTypeSlotAndTypeVar(@enumFromInt(0), Content{ .structure = .str }, base.Region.zero(), Var); - - try record_fields.append(.{ .name = x_ident, .var_ = i32_var }); - try record_fields.append(.{ .name = y_ident, .var_ = str_var }); - - const fields_range = try module_a_env.types.appendRecordFields(record_fields.items); - const ext_var = try module_a_cir.addTypeSlotAndTypeVar(@enumFromInt(0), Content{ .structure = .empty_record }, base.Region.zero(), Var); - - const record_content = Content{ - .structure = .{ - .record = .{ - .fields = fields_range, - .ext = ext_var, - }, - }, - }; - - // Set the type of this expression to our record type - const record_expr_idx = try module_a_cir.addExprAndTypeVar(.{ .e_int = .{ - .value = .{ .bytes = [_]u8{0} ** 16, .kind = .i128 }, - } }, record_content, base.Region.zero()); - - // Create array of module environments - var modules = std.array_list.Managed(*ModuleEnv).init(allocator); - defer modules.deinit(); - - try modules.append(module_a_cir); - - // Create module B that imports and uses the record from module A - var module_b_env = try ModuleEnv.init(allocator, ""); - defer module_b_env.deinit(); - - try module_b_env.initCIRFields(allocator, "ModuleB"); - const module_b_cir = &module_b_env; - - // Register the import of module A - _ = try module_b_cir.imports.getOrPut(allocator, &module_b_cir.common.strings, "ModuleA"); - - // Create an external lookup expression - const external_lookup_expr = try module_b_cir.addExprAndTypeVar(.{ - .e_lookup_external = .{ - .module_idx = @enumFromInt(0), // Direct index to module A in the array - .target_node_idx = @intCast(@intFromEnum(record_expr_idx)), - .region = base.Region.zero(), - }, - }, Content{ .flex_var = null }, base.Region.zero()); - - try modules.append(module_b_cir); - - // Type check module B - var checker = try Check.init(allocator, &module_b_env.types, module_b_cir, modules.items, &module_b_cir.store.regions); - defer checker.deinit(); - - _ = try checker.checkExpr(external_lookup_expr); - - // Verify that the external lookup has the correct record type - // Verify the record type - const external_var = @as(Var, @enumFromInt(@intFromEnum(external_lookup_expr))); - const resolved = module_b_env.types.resolveVar(external_var); - - try testing.expect(resolved.desc.content == .structure); - try testing.expect(resolved.desc.content.structure == .record); - - const record = resolved.desc.content.structure.record; - const fields = module_b_env.types.getRecordFieldsSlice(record.fields); - try testing.expectEqual(@as(usize, 2), fields.len); - - // Check field names and types - try testing.expectEqual(x_ident, fields.items(.name)[0]); - try testing.expectEqual(y_ident, fields.items(.name)[1]); - - const x_resolved = module_b_env.types.resolveVar(fields.items(.var_)[0]); - try testing.expect(x_resolved.desc.content == .structure); - try testing.expect(x_resolved.desc.content.structure == .num); - try testing.expect(x_resolved.desc.content.structure.num == .int_precision); - try testing.expectEqual(types_mod.Num.Int.Precision.i32, x_resolved.desc.content.structure.num.int_precision); - - // Check field y is Str - const y_resolved = module_b_env.types.resolveVar(fields.items(.var_)[1]); - try testing.expect(y_resolved.desc.content == .structure); - try testing.expect(y_resolved.desc.content.structure == .str); + const source_b = + \\module [] + \\ + \\import A + \\ + \\main : Str + \\main = A.id("hello") + ; + var test_env_b = try TestEnv.initWithImport(source_b, "A", test_env_a.module_env); + defer test_env_b.deinit(); + try test_env_b.assertLastDefType("Str"); } -test "cross-module type checking - type mismatch error" { - const allocator = testing.allocator; +test "cross-module type checking - polymorphic function with multiple uses passes" { + const source_a = + \\module [id] + \\ + \\id : a -> a + \\id = |s| s + ; + var test_env_a = try TestEnv.init(source_a); + defer test_env_a.deinit(); + try test_env_a.assertLastDefType("a -> a"); - // Create module A that exports an I32 - var module_a_env = try ModuleEnv.init(allocator, ""); - defer module_a_env.deinit(); - - try module_a_env.initCIRFields(allocator, "ModuleA"); - const module_a_cir = &module_a_env; - - // Create an I32 type - const i32_content = Content{ .structure = .{ .num = .{ .int_precision = .i32 } } }; - - // Store this as an integer literal expression - const func_expr_idx = try module_a_cir.addExprAndTypeVar(.{ .e_int = .{ - .value = .{ .bytes = [_]u8{ 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, .kind = .i128 }, - } }, i32_content, base.Region.zero()); - - // Create module B that imports the I32 but tries to use it as a String - var module_b_env = try ModuleEnv.init(allocator, ""); - defer module_b_env.deinit(); - - try module_b_env.initCIRFields(allocator, "ModuleB"); - const module_b_cir = &module_b_env; - - // Register the import of module A - _ = try module_b_cir.imports.getOrPut(allocator, &module_b_cir.common.strings, "ModuleA"); - - // Create an external lookup expression - const external_lookup_expr = try module_b_cir.addExprAndTypeVar(.{ - .e_lookup_external = .{ - .module_idx = @enumFromInt(0), // Direct index to module A in the array - .target_node_idx = @intCast(@intFromEnum(func_expr_idx)), - .region = base.Region.zero(), - }, - }, Content{ .flex_var = null }, base.Region.zero()); - - // Create a string literal expression - const str_content = Content{ .structure = .str }; - const str_expr = try module_b_cir.addExprAndTypeVar(.{ - .e_str_segment = .{ - .literal = @enumFromInt(0), // placeholder string literal - }, - }, str_content, base.Region.zero()); - - // Create array of module environments - var modules = std.array_list.Managed(*ModuleEnv).init(allocator); - defer modules.deinit(); - - try modules.append(module_a_cir); - try modules.append(module_b_cir); - - // Type check module B - var checker = try Check.init(allocator, &module_b_env.types, module_b_cir, modules.items, &module_b_cir.store.regions); - defer checker.deinit(); - - _ = try checker.checkExpr(external_lookup_expr); - _ = try checker.checkExpr(str_expr); - - // Try to unify the imported I32 with a String - this should fail - const external_var = @as(Var, @enumFromInt(@intFromEnum(external_lookup_expr))); - const string_var = @as(Var, @enumFromInt(@intFromEnum(str_expr))); - - const result = try checker.unify(external_var, string_var); - try testing.expect(result.isProblem()); -} - -test "cross-module type checking - polymorphic instantiation" { - const allocator = testing.allocator; - - // Create module A that exports a polymorphic list function - var module_a_env = try ModuleEnv.init(allocator, ""); - defer module_a_env.deinit(); - - try module_a_env.initCIRFields(allocator, "ModuleA"); - const module_a_cir = &module_a_env; - - // Store this as an integer literal expression (placeholder) - const type_var_a = try module_a_cir.addTypeSlotAndTypeVar( - @enumFromInt(0), - Content{ .flex_var = null }, - base.Region.zero(), - types_mod.Var, - ); - const list_var = try module_a_cir.addTypeSlotAndTypeVar( - @enumFromInt(0), - Content{ .structure = .{ .list = type_var_a } }, - base.Region.zero(), - types_mod.Var, - ); - const i64_var = try module_a_cir.addTypeSlotAndTypeVar( - @enumFromInt(0), - Content{ .structure = .{ .num = .{ .int_precision = .i64 } } }, - base.Region.zero(), - types_mod.Var, - ); - const func_content = try module_a_env.types.mkFuncPure(&[_]Var{list_var}, i64_var); - const func_expr_idx = try module_a_cir.addExprAndTypeVar(.{ .e_int = .{ - .value = .{ .bytes = [_]u8{0} ** 16, .kind = .i128 }, - } }, func_content, base.Region.zero()); - - // Create module B that imports and uses the function with a specific type - var module_b_env = try ModuleEnv.init(allocator, ""); - defer module_b_env.deinit(); - - try module_b_env.initCIRFields(allocator, "ModuleB"); - const module_b_cir = &module_b_env; - - // Register the import of module A - _ = try module_b_cir.imports.getOrPut(allocator, &module_b_cir.common.strings, "ModuleA"); - - // Create an external lookup expression - const external_lookup_expr = try module_b_cir.addExprAndTypeVar(.{ - .e_lookup_external = .{ - .module_idx = @enumFromInt(0), // Direct index to module A in the array - .target_node_idx = @intCast(@intFromEnum(func_expr_idx)), - .region = base.Region.zero(), - }, - }, .{ .flex_var = null }, base.Region.zero()); - - // Create an empty list expression - const str_var = try module_b_cir.addTypeSlotAndTypeVar( - @enumFromInt(0), - Content{ .structure = .str }, - base.Region.zero(), - types_mod.Var, - ); - const list_expr = try module_b_cir.addExprAndTypeVar(.{ - .e_empty_list = .{}, - }, Content{ .structure = .{ .list = str_var } }, base.Region.zero()); - - // Create array of module environments - var modules = std.array_list.Managed(*ModuleEnv).init(allocator); - defer modules.deinit(); - - try modules.append(module_a_cir); - try modules.append(module_b_cir); - - // Type check module B - var checker = try Check.init(allocator, &module_b_env.types, module_b_cir, modules.items, &module_b_cir.store.regions); - defer checker.deinit(); - - _ = try checker.checkExpr(external_lookup_expr); - _ = try checker.checkExpr(list_expr); - - // The polymorphic function should be usable with List(Str) - const external_var = @as(Var, @enumFromInt(@intFromEnum(external_lookup_expr))); - const resolved = module_b_env.types.resolveVar(external_var); - - try testing.expect(resolved.desc.content == .structure); - try testing.expect(resolved.desc.content.structure == .fn_pure); - - // The function should accept any list type - const func = resolved.desc.content.structure.fn_pure; - const args = module_b_env.types.sliceVars(func.args); - try testing.expectEqual(@as(usize, 1), args.len); - - // The argument should be a list with a flex var - const arg_resolved = module_b_env.types.resolveVar(args[0]); - try testing.expect(arg_resolved.desc.content == .structure); - try testing.expect(arg_resolved.desc.content.structure == .list); -} - -test "cross-module type checking - preserves module A types" { - const allocator = testing.allocator; - - // Create module A - var module_a_env = try ModuleEnv.init(allocator, ""); - defer module_a_env.deinit(); - - try module_a_env.initCIRFields(allocator, "ModuleA"); - const module_a_cir = &module_a_env; - - // Create a flex var in module A - const flex_var_a = try module_a_cir.addTypeSlotAndTypeVar(@enumFromInt(0), Content{ .flex_var = null }, base.Region.zero(), Var); - - // Store this as an integer literal expression (placeholder) - const flex_expr_idx = try module_a_cir.addExprAndTypeVar(.{ .e_int = .{ - .value = .{ .bytes = [_]u8{0} ** 16, .kind = .i128 }, - } }, Content{ .flex_var = null }, base.Region.zero()); - - // Remember the original state - const original_content = module_a_env.types.resolveVar(flex_var_a).desc.content; - try testing.expect(original_content == .flex_var); - - // Create module B - var module_b_env = try ModuleEnv.init(allocator, ""); - defer module_b_env.deinit(); - - try module_b_env.initCIRFields(allocator, "ModuleB"); - const module_b_cir = &module_b_env; - - // Register the import of module A - _ = try module_b_cir.imports.getOrPut(allocator, &module_b_cir.common.strings, "ModuleA"); - - // Create an external lookup expression - const external_lookup_expr = try module_b_cir.addExprAndTypeVar(.{ - .e_lookup_external = .{ - .module_idx = @enumFromInt(0), // Direct index to module A in the array - .target_node_idx = @intCast(@intFromEnum(flex_expr_idx)), - .region = base.Region.zero(), - }, - }, Content{ .flex_var = null }, base.Region.zero()); - - // Create a concrete type in module B to unify with - const i32_var = try module_b_cir.addTypeSlotAndTypeVar(@enumFromInt(0), Content{ .structure = .{ .num = .{ .int_precision = .i32 } } }, base.Region.zero(), Var); - const i32_expr = try module_b_cir.addExprAndTypeVar(.{ .e_int = .{ - .value = .{ .bytes = [_]u8{ 123, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, .kind = .i128 }, - } }, Content{ .structure = .{ .num = .{ .int_precision = .i32 } } }, base.Region.zero()); - - // Create array of module environments - var modules = std.array_list.Managed(*ModuleEnv).init(allocator); - defer modules.deinit(); - - try modules.append(module_a_cir); - try modules.append(module_b_cir); - - // Type check module B - var checker = try Check.init(allocator, &module_b_env.types, module_b_cir, modules.items, &module_b_cir.store.regions); - defer checker.deinit(); - - _ = try checker.checkExpr(external_lookup_expr); - _ = try checker.checkExpr(i32_expr); - - // Unify the imported type with I32 - const external_var = @as(Var, @enumFromInt(@intFromEnum(external_lookup_expr))); - const result = try checker.unify(external_var, i32_var); - try testing.expect(result.isOk()); - - // Module A's type should remain unchanged (still a flex var) - const module_a_after = module_a_env.types.resolveVar(flex_var_a).desc.content; - try testing.expect(module_a_after == .flex_var); - try testing.expectEqual(original_content, module_a_after); - - // Module B's imported type should be I32 - const module_b_resolved = module_b_env.types.resolveVar(external_var); - try testing.expect(module_b_resolved.desc.content == .structure); - try testing.expect(module_b_resolved.desc.content.structure == .num); - try testing.expect(module_b_resolved.desc.content.structure.num == .int_precision); - try testing.expectEqual(types_mod.Num.Int.Precision.i32, module_b_resolved.desc.content.structure.num.int_precision); -} - -test "cross-module type checking - three module chain monomorphic" { - const allocator = testing.allocator; - - // Module A exports a simple function: add : I32, I32 -> I32 - var module_a_env = try ModuleEnv.init(allocator, ""); - defer module_a_env.deinit(); - - try module_a_env.initCIRFields(allocator, "ModuleA"); - const module_a_cir = &module_a_env; - - // Create a function: add : I32, I32 -> I32 - const i32_content = Content{ .structure = .{ .num = .{ .int_precision = .i32 } } }; - const arg1_var = try module_a_cir.addTypeSlotAndTypeVar(@enumFromInt(0), i32_content, base.Region.zero(), Var); - const arg2_var = try module_a_cir.addTypeSlotAndTypeVar(@enumFromInt(0), i32_content, base.Region.zero(), Var); - const ret_var = try module_a_cir.addTypeSlotAndTypeVar(@enumFromInt(0), i32_content, base.Region.zero(), Var); - - const func_content = try module_a_env.types.mkFuncPure(&[_]Var{ arg1_var, arg2_var }, ret_var); - const func_expr_idx = try module_a_cir.addExprAndTypeVar(.{ .e_int = .{ - .value = .{ .bytes = [_]u8{0} ** 16, .kind = .i128 }, - } }, func_content, base.Region.zero()); - - // Module B imports from A and re-exports it - var module_b_env = try ModuleEnv.init(allocator, ""); - defer module_b_env.deinit(); - - try module_b_env.initCIRFields(allocator, "ModuleB"); - const module_b_cir = &module_b_env; - - // Module B imports A's function - _ = try module_b_cir.imports.getOrPut(allocator, &module_b_cir.common.strings, "ModuleA"); - - const b_lookup_expr = try module_b_cir.addExprAndTypeVar(.{ - .e_lookup_external = .{ - .module_idx = @enumFromInt(0), // Direct index to module A in the array - .target_node_idx = @intCast(@intFromEnum(func_expr_idx)), - .region = base.Region.zero(), - }, - }, Content{ .flex_var = null }, base.Region.zero()); - - // Module C imports from B - var module_c_env = try ModuleEnv.init(allocator, ""); - defer module_c_env.deinit(); - - try module_c_env.initCIRFields(allocator, "ModuleC"); - const module_c_cir = &module_c_env; - - // Module C imports from B (not A) - _ = try module_c_cir.imports.getOrPut(allocator, &module_c_cir.common.strings, "ModuleB"); - const c_lookup_expr = try module_c_cir.addExprAndTypeVar(.{ - .e_lookup_external = .{ - .module_idx = @enumFromInt(1), // Direct index to module B in the array - .target_node_idx = @intCast(@intFromEnum(b_lookup_expr)), - .region = base.Region.zero(), - }, - }, Content{ .flex_var = null }, base.Region.zero()); - - // Create array of module environments - var modules = std.array_list.Managed(*ModuleEnv).init(allocator); - defer modules.deinit(); - - try modules.append(module_a_cir); - try modules.append(module_b_cir); - try modules.append(module_c_cir); - - // Type check module B - var checker_b = try Check.init(allocator, &module_b_env.types, module_b_cir, modules.items, &module_b_cir.store.regions); - defer checker_b.deinit(); - - _ = try checker_b.checkExpr(b_lookup_expr); - - // Type check module C - var checker_c = try Check.init(allocator, &module_c_env.types, module_c_cir, modules.items, &module_c_cir.store.regions); - defer checker_c.deinit(); - - _ = try checker_c.checkExpr(c_lookup_expr); - - // Verify that module C sees the correct type through the chain - const c_var = @as(Var, @enumFromInt(@intFromEnum(c_lookup_expr))); - const c_resolved = module_c_env.types.resolveVar(c_var); - - try testing.expect(c_resolved.desc.content == .structure); - try testing.expect(c_resolved.desc.content.structure == .fn_pure); - - const func = c_resolved.desc.content.structure.fn_pure; - const args = module_c_env.types.sliceVars(func.args); - try testing.expectEqual(@as(usize, 2), args.len); - - // Check that all arguments and return are I32 - for (args) |arg| { - const arg_resolved = module_c_env.types.resolveVar(arg); - try testing.expect(arg_resolved.desc.content == .structure); - try testing.expect(arg_resolved.desc.content.structure == .num); - try testing.expect(arg_resolved.desc.content.structure.num == .int_precision); - try testing.expectEqual(types_mod.Num.Int.Precision.i32, arg_resolved.desc.content.structure.num.int_precision); - } - - const ret_resolved = module_c_env.types.resolveVar(func.ret); - try testing.expect(ret_resolved.desc.content == .structure); - try testing.expect(ret_resolved.desc.content.structure == .num); - try testing.expect(ret_resolved.desc.content.structure.num == .int_precision); - try testing.expectEqual(types_mod.Num.Int.Precision.i32, ret_resolved.desc.content.structure.num.int_precision); -} - -test "cross-module type checking - three module chain polymorphic" { - const allocator = testing.allocator; - - // Module A exports a polymorphic function: identity : a -> a - var module_a_env = try ModuleEnv.init(allocator, ""); - defer module_a_env.deinit(); - - try module_a_env.initCIRFields(allocator, "ModuleA"); - const module_a_cir = &module_a_env; - - const type_var_a = try module_a_cir.addTypeSlotAndTypeVar(@enumFromInt(0), Content{ .flex_var = null }, base.Region.zero(), Var); - const func_content = try module_a_env.types.mkFuncPure(&[_]Var{type_var_a}, type_var_a); - const func_expr_idx = try module_a_cir.addExprAndTypeVar(.{ .e_int = .{ - .value = .{ .bytes = [_]u8{0} ** 16, .kind = .i128 }, - } }, func_content, base.Region.zero()); - - // Module B imports from A and re-exports it - var module_b_env = try ModuleEnv.init(allocator, ""); - defer module_b_env.deinit(); - - try module_b_env.initCIRFields(allocator, "ModuleB"); - const module_b_cir = &module_b_env; - - // Module B imports from A - _ = try module_b_cir.imports.getOrPut(allocator, &module_b_cir.common.strings, "ModuleA"); - const b_lookup_expr = try module_b_cir.addExprAndTypeVar(.{ - .e_lookup_external = .{ - .module_idx = @enumFromInt(0), // Direct index to module A in the array - .target_node_idx = @intCast(@intFromEnum(func_expr_idx)), - .region = base.Region.zero(), - }, - }, Content{ .flex_var = null }, base.Region.zero()); - - // Module C imports from B - var module_c_env = try ModuleEnv.init(allocator, ""); - defer module_c_env.deinit(); - - try module_c_env.initCIRFields(allocator, "ModuleC"); - const module_c_cir = &module_c_env; - - // Module C imports from B - _ = try module_c_cir.imports.getOrPut(allocator, &module_c_cir.common.strings, "ModuleB"); - const c_lookup_expr = try module_c_cir.addExprAndTypeVar(.{ - .e_lookup_external = .{ - .module_idx = @enumFromInt(1), // Direct index to module B in the array - .target_node_idx = @intCast(@intFromEnum(b_lookup_expr)), - .region = base.Region.zero(), - }, - }, Content{ .flex_var = null }, base.Region.zero()); - - // Create array of module environments - var modules = std.array_list.Managed(*ModuleEnv).init(allocator); - defer modules.deinit(); - - try modules.append(module_a_cir); - try modules.append(module_b_cir); - try modules.append(module_c_cir); - - // Type check module B - var checker_b = try Check.init(allocator, &module_b_env.types, module_b_cir, modules.items, &module_b_cir.store.regions); - defer checker_b.deinit(); - - _ = try checker_b.checkExpr(b_lookup_expr); - - // Type check module C - var checker_c = try Check.init(allocator, &module_c_env.types, module_c_cir, modules.items, &module_c_cir.store.regions); - defer checker_c.deinit(); - - _ = try checker_c.checkExpr(c_lookup_expr); - - // Verify that module C sees the polymorphic type through the chain - const c_var = @as(Var, @enumFromInt(@intFromEnum(c_lookup_expr))); - const c_resolved = module_c_env.types.resolveVar(c_var); - - try testing.expect(c_resolved.desc.content == .structure); - try testing.expect(c_resolved.desc.content.structure == .fn_pure); - - const func = c_resolved.desc.content.structure.fn_pure; - const args = module_c_env.types.sliceVars(func.args); - try testing.expectEqual(@as(usize, 1), args.len); - - // The function should still be polymorphic - const arg_resolved = module_c_env.types.resolveVar(args[0]); - const ret_resolved = module_c_env.types.resolveVar(func.ret); - - // Both should resolve to the same flex var - try testing.expectEqual(arg_resolved.var_, ret_resolved.var_); - try testing.expect(arg_resolved.desc.content == .flex_var); -} - -test "cross-module type checking - partial polymorphic instantiation chain" { - const allocator = testing.allocator; - - // Module A exports: map : (a -> b), List a -> List b - var module_a_env = try ModuleEnv.init(allocator, ""); - defer module_a_env.deinit(); - - try module_a_env.initCIRFields(allocator, "ModuleA"); - const module_a_cir = &module_a_env; - - // Module A exports: map : (a -> b), List a -> List b - - // Create (a -> b) - const type_var_a = try module_a_cir.addTypeSlotAndTypeVar(@enumFromInt(0), Content{ .flex_var = null }, base.Region.zero(), Var); - const type_var_b = try module_a_cir.addTypeSlotAndTypeVar(@enumFromInt(0), Content{ .flex_var = null }, base.Region.zero(), Var); - const mapper_func_content = try module_a_env.types.mkFuncPure(&[_]Var{type_var_a}, type_var_b); - const mapper_var = try module_a_cir.addTypeSlotAndTypeVar(@enumFromInt(0), mapper_func_content, base.Region.zero(), Var); - - // Create List a - const list_a_content = Content{ .structure = .{ .list = type_var_a } }; - const list_a_var = try module_a_cir.addTypeSlotAndTypeVar(@enumFromInt(0), list_a_content, base.Region.zero(), Var); - - // Create List b - const list_b_content = Content{ .structure = .{ .list = type_var_b } }; - const list_b_var = try module_a_cir.addTypeSlotAndTypeVar(@enumFromInt(0), list_b_content, base.Region.zero(), Var); - - // Create map : (a -> b), List a -> List b - const map_func_content = try module_a_env.types.mkFuncPure(&[_]Var{ mapper_var, list_a_var }, list_b_var); - - // Update the expression with the correct function type - const map_expr_idx = try module_a_cir.addExprAndTypeVar(.{ .e_int = .{ - .value = .{ .bytes = [_]u8{0} ** 16, .kind = .i128 }, - } }, map_func_content, base.Region.zero()); - - // Module B imports map and partially applies it with I32 - var module_b_env = try ModuleEnv.init(allocator, ""); - defer module_b_env.deinit(); - - try module_b_env.initCIRFields(allocator, "ModuleB"); - const module_b_cir = &module_b_env; - - // Module B imports from A - _ = try module_b_cir.imports.getOrPut(allocator, &module_b_cir.common.strings, "ModuleA"); - const b_lookup_expr = try module_b_cir.addExprAndTypeVar(.{ - .e_lookup_external = .{ - .module_idx = @enumFromInt(0), // Direct index to module A in the array - .target_node_idx = @intCast(@intFromEnum(map_expr_idx)), - .region = base.Region.zero(), - }, - }, Content{ .flex_var = null }, base.Region.zero()); - - // Create specialized version: mapI32 : (I32 -> b), List I32 -> List b - - const i32_content = Content{ .structure = .{ .num = .{ .int_precision = .i32 } } }; - const i32_var = try module_b_cir.addTypeSlotAndTypeVar(@enumFromInt(0), i32_content, base.Region.zero(), Var); - const b_type_var_b = try module_b_cir.addTypeSlotAndTypeVar(@enumFromInt(0), Content{ .flex_var = null }, base.Region.zero(), Var); - - const i32_to_b_content = try module_b_env.types.mkFuncPure(&[_]Var{i32_var}, b_type_var_b); - const i32_to_b_var = try module_b_cir.addTypeSlotAndTypeVar(@enumFromInt(0), i32_to_b_content, base.Region.zero(), Var); - - const list_i32_content = Content{ .structure = .{ .list = i32_var } }; - const list_i32_var = try module_b_cir.addTypeSlotAndTypeVar(@enumFromInt(0), list_i32_content, base.Region.zero(), Var); - - const list_b_content_2 = Content{ .structure = .{ .list = b_type_var_b } }; - const list_b_var_2 = try module_b_cir.addTypeSlotAndTypeVar(@enumFromInt(0), list_b_content_2, base.Region.zero(), Var); - - const map_i32_content = try module_b_env.types.mkFuncPure(&[_]Var{ i32_to_b_var, list_i32_var }, list_b_var_2); - - const map_i32_expr_idx = try module_b_cir.addExprAndTypeVar(.{ .e_int = .{ - .value = .{ .bytes = [_]u8{0} ** 16, .kind = .i128 }, - } }, map_i32_content, base.Region.zero()); - - // Module C imports the partially specialized version from B - var module_c_env = try ModuleEnv.init(allocator, ""); - defer module_c_env.deinit(); - - try module_c_env.initCIRFields(allocator, "ModuleC"); - const module_c_cir = &module_c_env; - - // Module C imports from B and uses the partially specialized function - _ = try module_c_cir.imports.getOrPut(allocator, &module_c_cir.common.strings, "ModuleB"); - const c_lookup_expr = try module_c_cir.addExprAndTypeVar(.{ - .e_lookup_external = .{ - .module_idx = @enumFromInt(1), // Direct index to module B in the array - .target_node_idx = @intCast(@intFromEnum(map_i32_expr_idx)), - .region = base.Region.zero(), - }, - }, Content{ .flex_var = null }, base.Region.zero()); - - // Create array of module environments - var modules = std.array_list.Managed(*ModuleEnv).init(allocator); - defer modules.deinit(); - - try modules.append(module_a_cir); - try modules.append(module_b_cir); - try modules.append(module_c_cir); - - // Type check module B - var checker_b = try Check.init(allocator, &module_b_env.types, module_b_cir, modules.items, &module_b_cir.store.regions); - defer checker_b.deinit(); - - _ = try checker_b.checkExpr(b_lookup_expr); - _ = try checker_b.checkExpr(map_i32_expr_idx); - - // Type check module C - var checker_c = try Check.init(allocator, &module_c_env.types, module_c_cir, modules.items, &module_c_cir.store.regions); - defer checker_c.deinit(); - - _ = try checker_c.checkExpr(c_lookup_expr); - - // Verify that module C sees the partially specialized type - const c_var = @as(Var, @enumFromInt(@intFromEnum(c_lookup_expr))); - const c_resolved = module_c_env.types.resolveVar(c_var); - - try testing.expect(c_resolved.desc.content == .structure); - try testing.expect(c_resolved.desc.content.structure == .fn_pure); - - const func = c_resolved.desc.content.structure.fn_pure; - const args = module_c_env.types.sliceVars(func.args); - try testing.expectEqual(@as(usize, 2), args.len); - - // First argument should be (I32 -> b) - const mapper_resolved = module_c_env.types.resolveVar(args[0]); - try testing.expect(mapper_resolved.desc.content == .structure); - try testing.expect(mapper_resolved.desc.content.structure == .fn_pure); - - const mapper_func = mapper_resolved.desc.content.structure.fn_pure; - const mapper_args = module_c_env.types.sliceVars(mapper_func.args); - try testing.expectEqual(@as(usize, 1), mapper_args.len); - - // The mapper input should be I32 - const mapper_input_resolved = module_c_env.types.resolveVar(mapper_args[0]); - try testing.expect(mapper_input_resolved.desc.content == .structure); - try testing.expect(mapper_input_resolved.desc.content.structure == .num); - try testing.expect(mapper_input_resolved.desc.content.structure.num == .int_precision); - try testing.expectEqual(types_mod.Num.Int.Precision.i32, mapper_input_resolved.desc.content.structure.num.int_precision); - - // The mapper output should still be polymorphic - const mapper_output_resolved = module_c_env.types.resolveVar(mapper_func.ret); - try testing.expect(mapper_output_resolved.desc.content == .flex_var); - - // Second argument should be List I32 - const list_arg_resolved = module_c_env.types.resolveVar(args[1]); - try testing.expect(list_arg_resolved.desc.content == .structure); - try testing.expect(list_arg_resolved.desc.content.structure == .list); - - const list_elem_var = list_arg_resolved.desc.content.structure.list; - const list_elem_resolved = module_c_env.types.resolveVar(list_elem_var); - try testing.expect(list_elem_resolved.desc.content == .structure); - try testing.expect(list_elem_resolved.desc.content.structure == .num); - try testing.expect(list_elem_resolved.desc.content.structure.num == .int_precision); - try testing.expectEqual(types_mod.Num.Int.Precision.i32, list_elem_resolved.desc.content.structure.num.int_precision); - - // Return type should be List b (still polymorphic) - const ret_resolved = module_c_env.types.resolveVar(func.ret); - try testing.expect(ret_resolved.desc.content == .structure); - try testing.expect(ret_resolved.desc.content.structure == .list); - - const ret_elem_var = ret_resolved.desc.content.structure.list; - const ret_elem_resolved = module_c_env.types.resolveVar(ret_elem_var); - try testing.expect(ret_elem_resolved.desc.content == .flex_var); - - // The output type variable should match the mapper's output - try testing.expectEqual(mapper_output_resolved.var_, ret_elem_resolved.var_); -} - -test "cross-module type checking - record type chain" { - const allocator = testing.allocator; - - // Module A exports a record type: { x: I32, y: Str } - var module_a_env = try ModuleEnv.init(allocator, ""); - defer module_a_env.deinit(); - - try module_a_env.initCIRFields(allocator, "ModuleA"); - const module_a_cir = &module_a_env; - - // Module A exports a record type: { x: I32, y: Str } - const i32_content = Content{ .structure = .{ .num = .{ .int_precision = .i32 } } }; - const i32_var = try module_a_cir.addTypeSlotAndTypeVar(@enumFromInt(0), i32_content, base.Region.zero(), Var); - - const str_content = Content{ .structure = .str }; - const str_var = try module_a_cir.addTypeSlotAndTypeVar(@enumFromInt(0), str_content, base.Region.zero(), Var); - - const x_ident = try module_a_env.insertIdent(base.Ident.for_text("x")); - const y_ident = try module_a_env.insertIdent(base.Ident.for_text("y")); - - var record_fields = std.array_list.Managed(types_mod.RecordField).init(allocator); - defer record_fields.deinit(); - - try record_fields.append(.{ .name = x_ident, .var_ = i32_var }); - try record_fields.append(.{ .name = y_ident, .var_ = str_var }); - - const fields_range = try module_a_env.types.appendRecordFields(record_fields.items); - const ext_var = try module_a_cir.addTypeSlotAndTypeVar(@enumFromInt(0), Content{ .flex_var = null }, base.Region.zero(), Var); - - const record_content = Content{ .structure = .{ .record = .{ .fields = fields_range, .ext = ext_var } } }; - - const record_expr_idx = try module_a_cir.addExprAndTypeVar(.{ .e_int = .{ - .value = .{ .bytes = [_]u8{0} ** 16, .kind = .i128 }, - } }, record_content, base.Region.zero()); - - // Module B imports and re-exports the record - var module_b_env = try ModuleEnv.init(allocator, ""); - defer module_b_env.deinit(); - - try module_b_env.initCIRFields(allocator, "ModuleB"); - const module_b_cir = &module_b_env; - - // Module B imports from A and partially specializes - _ = try module_b_cir.imports.getOrPut(allocator, &module_b_cir.common.strings, "ModuleA"); - const b_lookup_expr = try module_b_cir.addExprAndTypeVar(.{ - .e_lookup_external = .{ - .module_idx = @enumFromInt(0), // Direct index to module A in the array - .target_node_idx = @intCast(@intFromEnum(record_expr_idx)), - .region = base.Region.zero(), - }, - }, Content{ .flex_var = null }, base.Region.zero()); - - // Module C imports from B - var module_c_env = try ModuleEnv.init(allocator, ""); - defer module_c_env.deinit(); - - try module_c_env.initCIRFields(allocator, "ModuleC"); - const module_c_cir = &module_c_env; - - // Module C imports from B - _ = try module_c_cir.imports.getOrPut(allocator, &module_c_cir.common.strings, "ModuleB"); - const c_lookup_expr = try module_c_cir.addExprAndTypeVar(.{ - .e_lookup_external = .{ - .module_idx = @enumFromInt(1), // Direct index to module B in the array - .target_node_idx = @intCast(@intFromEnum(b_lookup_expr)), - .region = base.Region.zero(), - }, - }, Content{ .flex_var = null }, base.Region.zero()); - - // Create array of module environments - var modules = std.array_list.Managed(*ModuleEnv).init(allocator); - defer modules.deinit(); - - try modules.append(module_a_cir); - try modules.append(module_b_cir); - try modules.append(module_c_cir); - - // Type check module B - var checker_b = try Check.init(allocator, &module_b_env.types, module_b_cir, modules.items, &module_b_cir.store.regions); - defer checker_b.deinit(); - - _ = try checker_b.checkExpr(b_lookup_expr); - - // Type check module C - var checker_c = try Check.init(allocator, &module_c_env.types, module_c_cir, modules.items, &module_c_cir.store.regions); - defer checker_c.deinit(); - - _ = try checker_c.checkExpr(c_lookup_expr); - - // Verify the record type in module C - const c_var = @as(Var, @enumFromInt(@intFromEnum(c_lookup_expr))); - const c_resolved = module_c_env.types.resolveVar(c_var); - - try testing.expect(c_resolved.desc.content == .structure); - try testing.expect(c_resolved.desc.content.structure == .record); - - const record = c_resolved.desc.content.structure.record; - const fields = module_c_env.types.getRecordFieldsSlice(record.fields); - try testing.expectEqual(@as(usize, 2), fields.len); - - // Check field names and types - try testing.expectEqualSlices(u8, "x", module_c_env.getIdent(fields.items(.name)[0])); - try testing.expectEqualSlices(u8, "y", module_c_env.getIdent(fields.items(.name)[1])); - - // Check field x is I32 - const x_resolved = module_c_env.types.resolveVar(fields.items(.var_)[0]); - try testing.expect(x_resolved.desc.content == .structure); - try testing.expect(x_resolved.desc.content.structure == .num); - try testing.expect(x_resolved.desc.content.structure.num == .int_precision); - try testing.expectEqual(types_mod.Num.Int.Precision.i32, x_resolved.desc.content.structure.num.int_precision); - - // Check field y is Str - const y_resolved = module_c_env.types.resolveVar(fields.items(.var_)[1]); - try testing.expect(y_resolved.desc.content == .structure); - try testing.expect(y_resolved.desc.content.structure == .str); -} - -test "cross-module type checking - polymorphic record chain" { - const allocator = testing.allocator; - - // Module A exports a polymorphic record: { value: a, next: List a } - var module_a_env = try ModuleEnv.init(allocator, ""); - defer module_a_env.deinit(); - - try module_a_env.initCIRFields(allocator, "ModuleA"); - const module_a_cir = &module_a_env; - - // Module A exports a polymorphic record: { value: a, next: List a } - const type_var_a = try module_a_cir.addTypeSlotAndTypeVar(@enumFromInt(0), Content{ .flex_var = null }, base.Region.zero(), Var); - - const list_a_content = Content{ .structure = .{ .list = type_var_a } }; - const list_a_var = try module_a_cir.addTypeSlotAndTypeVar(@enumFromInt(0), list_a_content, base.Region.zero(), Var); - - const value_ident = try module_a_env.insertIdent(base.Ident.for_text("value")); - const next_ident = try module_a_env.insertIdent(base.Ident.for_text("next")); - - var record_fields = std.array_list.Managed(types_mod.RecordField).init(allocator); - defer record_fields.deinit(); - - try record_fields.append(.{ .name = value_ident, .var_ = type_var_a }); - try record_fields.append(.{ .name = next_ident, .var_ = list_a_var }); - - const fields_range = try module_a_env.types.appendRecordFields(record_fields.items); - const ext_var = try module_a_cir.addTypeSlotAndTypeVar(@enumFromInt(0), Content{ .flex_var = null }, base.Region.zero(), Var); - - const record_content = Content{ .structure = .{ .record = .{ .fields = fields_range, .ext = ext_var } } }; - - const record_expr_idx = try module_a_cir.addExprAndTypeVar(.{ .e_int = .{ - .value = .{ .bytes = [_]u8{0} ** 16, .kind = .i128 }, - } }, record_content, base.Region.zero()); - - // Module B imports and partially specializes to Str - var module_b_env = try ModuleEnv.init(allocator, ""); - defer module_b_env.deinit(); - - try module_b_env.initCIRFields(allocator, "ModuleB"); - const module_b_cir = &module_b_env; - - // Module B imports from A - _ = try module_b_cir.imports.getOrPut(allocator, &module_b_cir.common.strings, "ModuleA"); - const b_lookup_expr = try module_b_cir.addExprAndTypeVar(.{ - .e_lookup_external = .{ - .module_idx = @enumFromInt(0), // Direct index to module A in the array - .target_node_idx = @intCast(@intFromEnum(record_expr_idx)), - .region = base.Region.zero(), - }, - }, Content{ .flex_var = null }, base.Region.zero()); - - // Create specialized version: { value: Str, next: List Str } - const str_content = Content{ .structure = .str }; - const str_var = try module_b_cir.addTypeSlotAndTypeVar(@enumFromInt(0), str_content, base.Region.zero(), Var); - - const list_str_content = Content{ .structure = .{ .list = str_var } }; - const list_str_var = try module_b_cir.addTypeSlotAndTypeVar(@enumFromInt(0), list_str_content, base.Region.zero(), Var); - - const value_ident_b = try module_b_env.insertIdent(base.Ident.for_text("value")); - const next_ident_b = try module_b_env.insertIdent(base.Ident.for_text("next")); - - var str_record_fields = std.array_list.Managed(types_mod.RecordField).init(allocator); - defer str_record_fields.deinit(); - - try str_record_fields.append(.{ .name = value_ident_b, .var_ = str_var }); - try str_record_fields.append(.{ .name = next_ident_b, .var_ = list_str_var }); - - const str_fields_range = try module_b_env.types.appendRecordFields(str_record_fields.items); - const str_ext_var = try module_b_cir.addTypeSlotAndTypeVar(@enumFromInt(0), Content{ .structure = .empty_record }, base.Region.zero(), Var); - - const str_record_content = Content{ .structure = .{ .record = .{ .fields = str_fields_range, .ext = str_ext_var } } }; - - // Set the type on var 1 (for expr 1) - const str_record_expr_idx = try module_b_cir.addExprAndTypeVar(.{ .e_int = .{ - .value = .{ .bytes = [_]u8{0} ** 16, .kind = .i128 }, - } }, str_record_content, base.Region.zero()); - - // Module C imports the specialized version from B - var module_c_env = try ModuleEnv.init(allocator, ""); - defer module_c_env.deinit(); - - try module_c_env.initCIRFields(allocator, "ModuleC"); - const module_c_cir = &module_c_env; - - // Module C imports from B - _ = try module_c_cir.imports.getOrPut(allocator, &module_c_cir.common.strings, "ModuleB"); - const c_lookup_expr = try module_c_cir.addExprAndTypeVar(.{ - .e_lookup_external = .{ - .module_idx = @enumFromInt(1), // Direct index to module B in the array - .target_node_idx = @intCast(@intFromEnum(str_record_expr_idx)), - .region = base.Region.zero(), - }, - }, Content{ .flex_var = null }, base.Region.zero()); - - // Create array of module environments - var modules = std.array_list.Managed(*ModuleEnv).init(allocator); - defer modules.deinit(); - - try modules.append(module_a_cir); - try modules.append(module_b_cir); - try modules.append(module_c_cir); - - // Type check module B - var checker_b = try Check.init(allocator, &module_b_env.types, module_b_cir, modules.items, &module_b_cir.store.regions); - defer checker_b.deinit(); - - _ = try checker_b.checkExpr(b_lookup_expr); - _ = try checker_b.checkExpr(str_record_expr_idx); - - // Type check module C - var checker_c = try Check.init(allocator, &module_c_env.types, module_c_cir, modules.items, &module_c_cir.store.regions); - defer checker_c.deinit(); - - _ = try checker_c.checkExpr(c_lookup_expr); - - // Verify the specialized record type in module C - const c_var = @as(Var, @enumFromInt(@intFromEnum(c_lookup_expr))); - const c_resolved = module_c_env.types.resolveVar(c_var); - - try testing.expect(c_resolved.desc.content == .structure); - try testing.expect(c_resolved.desc.content.structure == .record); - - const record = c_resolved.desc.content.structure.record; - const fields = module_c_env.types.getRecordFieldsSlice(record.fields); - try testing.expectEqual(@as(usize, 2), fields.len); - - // Check field names and types - try testing.expectEqualSlices(u8, "value", module_c_env.getIdent(fields.items(.name)[0])); - try testing.expectEqualSlices(u8, "next", module_c_env.getIdent(fields.items(.name)[1])); - - // Check field value is Str - const value_resolved = module_c_env.types.resolveVar(fields.items(.var_)[0]); - try testing.expect(value_resolved.desc.content == .structure); - try testing.expect(value_resolved.desc.content.structure == .str); - - // Check field next is List Str - const next_resolved = module_c_env.types.resolveVar(fields.items(.var_)[1]); - try testing.expect(next_resolved.desc.content == .structure); - try testing.expect(next_resolved.desc.content.structure == .list); - - const list_elem_var = next_resolved.desc.content.structure.list; - const list_elem_resolved = module_c_env.types.resolveVar(list_elem_var); - try testing.expect(list_elem_resolved.desc.content == .structure); - try testing.expect(list_elem_resolved.desc.content.structure == .str); -} - -test "cross-module type checking - complex polymorphic chain with unification" { - const allocator = testing.allocator; - - // Module A exports: compose : (b -> c), (a -> b) -> (a -> c) - var module_a_env = try ModuleEnv.init(allocator, ""); - defer module_a_env.deinit(); - - try module_a_env.initCIRFields(allocator, "ModuleA"); - const module_a_cir = &module_a_env; - - // Module A exports: compose : (b -> c), (a -> b) -> (a -> c) - const type_var_a = try module_a_cir.addTypeSlotAndTypeVar(@enumFromInt(0), Content{ .flex_var = null }, base.Region.zero(), Var); - const type_var_b = try module_a_cir.addTypeSlotAndTypeVar(@enumFromInt(0), Content{ .flex_var = null }, base.Region.zero(), Var); - const type_var_c = try module_a_cir.addTypeSlotAndTypeVar(@enumFromInt(0), Content{ .flex_var = null }, base.Region.zero(), Var); - - // Create (b -> c) - const b_to_c_content = try module_a_env.types.mkFuncPure(&[_]Var{type_var_b}, type_var_c); - const b_to_c_var = try module_a_cir.addTypeSlotAndTypeVar(@enumFromInt(0), b_to_c_content, base.Region.zero(), Var); - - // Create (a -> b) - const a_to_b_content = try module_a_env.types.mkFuncPure(&[_]Var{type_var_a}, type_var_b); - const a_to_b_var = try module_a_cir.addTypeSlotAndTypeVar(@enumFromInt(0), a_to_b_content, base.Region.zero(), Var); - - // Create (a -> c) - const a_to_c_content = try module_a_env.types.mkFuncPure(&[_]Var{type_var_a}, type_var_c); - const a_to_c_var = try module_a_cir.addTypeSlotAndTypeVar(@enumFromInt(0), a_to_c_content, base.Region.zero(), Var); - - // Create compose : (b -> c), (a -> b) -> (a -> c) - const compose_content = try module_a_env.types.mkFuncPure(&[_]Var{ b_to_c_var, a_to_b_var }, a_to_c_var); - const compose_expr_idx = try module_a_cir.addExprAndTypeVar(.{ .e_int = .{ - .value = .{ .bytes = [_]u8{0} ** 16, .kind = .i128 }, - } }, compose_content, base.Region.zero()); - - // Module B imports compose and partially applies with b = Str - var module_b_env = try ModuleEnv.init(allocator, ""); - defer module_b_env.deinit(); - - try module_b_env.initCIRFields(allocator, "ModuleB"); - const module_b_cir = &module_b_env; - - // Module B imports from A and makes a new record type - // This is initially a flex var, but the type will be copied from module A - // during type checking - _ = try module_b_cir.imports.getOrPut(allocator, &module_b_cir.common.strings, "ModuleA"); - const b_lookup_expr = try module_b_cir.addExprAndTypeVar(.{ - .e_lookup_external = .{ - .module_idx = @enumFromInt(0), // Direct index to module A in the array - .target_node_idx = @intCast(@intFromEnum(compose_expr_idx)), - .region = base.Region.zero(), - }, - }, Content{ .flex_var = null }, base.Region.zero()); - - // Create partially specialized version with b = Str - const str_content = Content{ .structure = .str }; - const b_str_var = try module_b_cir.addTypeSlotAndTypeVar(@enumFromInt(0), str_content, base.Region.zero(), Var); - const b_type_var_a = try module_b_cir.addTypeSlotAndTypeVar(@enumFromInt(0), Content{ .flex_var = null }, base.Region.zero(), Var); - const b_type_var_c = try module_b_cir.addTypeSlotAndTypeVar(@enumFromInt(0), Content{ .flex_var = null }, base.Region.zero(), Var); - - // Create (Str -> c) - const str_to_c_content = try module_b_env.types.mkFuncPure(&[_]Var{b_str_var}, b_type_var_c); - const str_to_c_var = try module_b_cir.addTypeSlotAndTypeVar(@enumFromInt(0), str_to_c_content, base.Region.zero(), Var); - - // Create (a -> Str) - const a_to_str_content = try module_b_env.types.mkFuncPure(&[_]Var{b_type_var_a}, b_str_var); - const a_to_str_var = try module_b_cir.addTypeSlotAndTypeVar(@enumFromInt(0), a_to_str_content, base.Region.zero(), Var); - - // Create (a -> c) - const b_a_to_c_content = try module_b_env.types.mkFuncPure(&[_]Var{b_type_var_a}, b_type_var_c); - const b_a_to_c_var = try module_b_cir.addTypeSlotAndTypeVar(@enumFromInt(0), b_a_to_c_content, base.Region.zero(), Var); - - // Create composeStr : (Str -> c), (a -> Str) -> (a -> c) - const compose_str_content = try module_b_env.types.mkFuncPure(&[_]Var{ str_to_c_var, a_to_str_var }, b_a_to_c_var); - - // Create the expression - const compose_str_expr_idx = try module_b_cir.addExprAndTypeVar(.{ .e_int = .{ - .value = .{ .bytes = [_]u8{0} ** 16, .kind = .i128 }, - } }, compose_str_content, base.Region.zero()); - - // Module C imports the partially specialized version and further specializes c = I32 - var module_c_env = try ModuleEnv.init(allocator, ""); - defer module_c_env.deinit(); - - try module_c_env.initCIRFields(allocator, "ModuleC"); - const module_c_cir = &module_c_env; - - // Module C imports from B and uses the wrapper - // This is initially a flex var, but the type will be copied from module B - // during type checking - _ = try module_c_cir.imports.getOrPut(allocator, &module_c_cir.common.strings, "ModuleB"); - const c_lookup_expr = try module_c_cir.addExprAndTypeVar(.{ - .e_lookup_external = .{ - .module_idx = @enumFromInt(1), // Direct index to module B in the array - .target_node_idx = @intCast(@intFromEnum(compose_str_expr_idx)), - .region = base.Region.zero(), - }, - }, Content{ .flex_var = null }, base.Region.zero()); - - // Create array of module environments - var modules = std.array_list.Managed(*ModuleEnv).init(allocator); - defer modules.deinit(); - - try modules.append(module_a_cir); - try modules.append(module_b_cir); - try modules.append(module_c_cir); - - // Type check module B - var checker_b = try Check.init(allocator, &module_b_env.types, module_b_cir, modules.items, &module_b_cir.store.regions); - defer checker_b.deinit(); - - _ = try checker_b.checkExpr(b_lookup_expr); - _ = try checker_b.checkExpr(compose_str_expr_idx); - - // Type check module C - var checker_c = try Check.init(allocator, &module_c_env.types, module_c_cir, modules.items, &module_c_cir.store.regions); - defer checker_c.deinit(); - - _ = try checker_c.checkExpr(c_lookup_expr); - - // Important! Now that we've type-checked, we can add vars directly to the - // types store. - - // Now unify the imported function with a specific instantiation - const c_var = @as(Var, @enumFromInt(@intFromEnum(c_lookup_expr))); - - // Create a concrete instance where c = I32 - const i32_content = Content{ .structure = .{ .num = .{ .int_precision = .i32 } } }; - const c_str_var = try module_c_env.types.freshFromContent(str_content); - const c_i32_var = try module_c_env.types.freshFromContent(i32_content); - const c_type_var_a = try module_c_env.types.fresh(); - - // Create (Str -> I32) - const str_to_i32_content = try module_c_env.types.mkFuncPure(&[_]Var{c_str_var}, c_i32_var); - const str_to_i32_var = try module_c_env.types.freshFromContent(str_to_i32_content); - - // Create (a -> Str) - const c_a_to_str_content = try module_c_env.types.mkFuncPure(&[_]Var{c_type_var_a}, c_str_var); - const c_a_to_str_var = try module_c_env.types.freshFromContent(c_a_to_str_content); - - // Create (a -> I32) - const a_to_i32_content = try module_c_env.types.mkFuncPure(&[_]Var{c_type_var_a}, c_i32_var); - const a_to_i32_var = try module_c_env.types.freshFromContent(a_to_i32_content); - - // Create the expected type: (Str -> I32), (a -> Str) -> (a -> I32) - const expected_content = try module_c_env.types.mkFuncPure(&[_]Var{ str_to_i32_var, c_a_to_str_var }, a_to_i32_var); - const expected_var = try module_c_env.types.freshFromContent(expected_content); - - // Unify the imported type with the expected type - const result = try checker_c.unify(c_var, expected_var); - try testing.expect(result.isOk()); - - // Verify the unified type - const c_resolved = module_c_env.types.resolveVar(c_var); - try testing.expect(c_resolved.desc.content == .structure); - try testing.expect(c_resolved.desc.content.structure == .fn_pure); - - const func = c_resolved.desc.content.structure.fn_pure; - const args = module_c_env.types.sliceVars(func.args); - try testing.expectEqual(@as(usize, 2), args.len); - - // First argument should be (Str -> I32) - const first_arg_resolved = module_c_env.types.resolveVar(args[0]); - try testing.expect(first_arg_resolved.desc.content == .structure); - try testing.expect(first_arg_resolved.desc.content.structure == .fn_pure); - - const first_func = first_arg_resolved.desc.content.structure.fn_pure; - const first_func_args = module_c_env.types.sliceVars(first_func.args); - try testing.expectEqual(@as(usize, 1), first_func_args.len); - - const first_func_arg_resolved = module_c_env.types.resolveVar(first_func_args[0]); - try testing.expect(first_func_arg_resolved.desc.content == .structure); - try testing.expect(first_func_arg_resolved.desc.content.structure == .str); - - const first_func_ret_resolved = module_c_env.types.resolveVar(first_func.ret); - try testing.expect(first_func_ret_resolved.desc.content == .structure); - try testing.expect(first_func_ret_resolved.desc.content.structure == .num); - try testing.expect(first_func_ret_resolved.desc.content.structure.num == .int_precision); - try testing.expectEqual(types_mod.Num.Int.Precision.i32, first_func_ret_resolved.desc.content.structure.num.int_precision); - - // Second argument should be (a -> Str) where a is still polymorphic - const second_arg_resolved = module_c_env.types.resolveVar(args[1]); - try testing.expect(second_arg_resolved.desc.content == .structure); - try testing.expect(second_arg_resolved.desc.content.structure == .fn_pure); - - const second_func = second_arg_resolved.desc.content.structure.fn_pure; - const second_func_args = module_c_env.types.sliceVars(second_func.args); - try testing.expectEqual(@as(usize, 1), second_func_args.len); - - const second_func_arg_resolved = module_c_env.types.resolveVar(second_func_args[0]); - try testing.expect(second_func_arg_resolved.desc.content == .flex_var); - - const second_func_ret_resolved = module_c_env.types.resolveVar(second_func.ret); - try testing.expect(second_func_ret_resolved.desc.content == .structure); - try testing.expect(second_func_ret_resolved.desc.content.structure == .str); - - // Return type should be (a -> I32) - const ret_resolved = module_c_env.types.resolveVar(func.ret); - try testing.expect(ret_resolved.desc.content == .structure); - try testing.expect(ret_resolved.desc.content.structure == .fn_pure); - - const ret_func = ret_resolved.desc.content.structure.fn_pure; - const ret_func_args = module_c_env.types.sliceVars(ret_func.args); - try testing.expectEqual(@as(usize, 1), ret_func_args.len); - - const ret_func_arg_resolved = module_c_env.types.resolveVar(ret_func_args[0]); - try testing.expect(ret_func_arg_resolved.desc.content == .flex_var); - - const ret_func_ret_resolved = module_c_env.types.resolveVar(ret_func.ret); - try testing.expect(ret_func_ret_resolved.desc.content == .structure); - try testing.expect(ret_func_ret_resolved.desc.content.structure == .num); - try testing.expect(ret_func_ret_resolved.desc.content.structure.num == .int_precision); - try testing.expectEqual(types_mod.Num.Int.Precision.i32, ret_func_ret_resolved.desc.content.structure.num.int_precision); - - // The 'a' type variable should be consistent across both functions - try testing.expectEqual(second_func_arg_resolved.var_, ret_func_arg_resolved.var_); -} - -test "cross-module type checking - type mismatch with proper error message" { - const allocator = testing.allocator; - - // Module A: Exports a string value - var module_a_env = try ModuleEnv.init(allocator, ""); - defer module_a_env.deinit(); - - try module_a_env.initCIRFields(allocator, "ModuleA"); - const module_a_cir = &module_a_env; - - // Create a string value in module A - const str_expr_idx = try module_a_cir.addExprAndTypeVar(.{ .e_int = .{ - .value = .{ .bytes = [_]u8{0} ** 16, .kind = .i128 }, - } }, .{ .structure = .str }, base.Region.zero()); - - // Module B: Tries to use the string as a number - var module_b_env = try ModuleEnv.init(allocator, ""); - defer module_b_env.deinit(); - - try module_b_env.initCIRFields(allocator, "ModuleB"); - const module_b_cir = &module_b_env; - - // Create an import expression that references module A's string - // This is initially a flex var, but the type will be copied from module A - // during type checking - const import_expr = try module_b_cir.addExprAndTypeVar(.{ - .e_lookup_external = .{ - .module_idx = @enumFromInt(0), - .target_node_idx = @intCast(@intFromEnum(str_expr_idx)), - .region = .{ - .start = .{ .offset = 0 }, - .end = .{ .offset = 20 }, - }, - }, - }, Content{ .flex_var = null }, base.Region.zero()); - - // Set up modules array - var modules = std.array_list.Managed(*ModuleEnv).init(allocator); - defer modules.deinit(); - try modules.append(module_a_cir); - - // Type check module B - var checker = try Check.init(allocator, &module_b_env.types, module_b_cir, modules.items, &module_b_cir.store.regions); - defer checker.deinit(); - - // Check the import expression - this will copy the type from module A - _ = try checker.checkExpr(import_expr); - - // Important! Now that we've type-checked, we can add vars directly to the - // types store. - - // Now try to unify the import (which has Str type) with I32 - const import_var = @as(types_mod.Var, @enumFromInt(@intFromEnum(import_expr))); - const i32_content = Content{ .structure = .{ .num = .{ .int_precision = .i32 } } }; - const i32_var = try module_b_env.types.freshFromContent(i32_content); - - const result = try checker.unify(import_var, i32_var); - - // The unification should fail - try testing.expect(result.isProblem()); - - // Check that the problem has the cross-module import detail - const problem_idx = result.problem; - const prob = checker.problems.problems.items[@intFromEnum(problem_idx)]; - - try testing.expect(prob == .type_mismatch); - const mismatch = prob.type_mismatch; - - // The detail might be null if the unification happens outside the import handling - // But our code ensures it gets set when the import unification fails - if (mismatch.detail) |detail| { - if (detail == .cross_module_import) { - const cross_module_detail = detail.cross_module_import; - try testing.expectEqual(import_expr, cross_module_detail.import_region); - try testing.expectEqual(@as(CIR.Import.Idx, @enumFromInt(0)), cross_module_detail.module_idx); - } - } + const source_b = + \\module [] + \\ + \\import A + \\ + \\main : U64 + \\main = { + \\ a = A.id(10) + \\ b = A.id(15) + \\ _c = A.id("Hello") + \\ a + b + \\} + ; + var test_env_b = try TestEnv.initWithImport(source_b, "A", test_env_a.module_env); + defer test_env_b.deinit(); + try test_env_b.assertLastDefType("Num(Int(Unsigned64))"); } diff --git a/src/check/test/let_polymorphism_integration_test.zig b/src/check/test/let_polymorphism_integration_test.zig index 9b7d9a28ac..173a9a3942 100644 --- a/src/check/test/let_polymorphism_integration_test.zig +++ b/src/check/test/let_polymorphism_integration_test.zig @@ -6,6 +6,7 @@ const base = @import("base"); const parse = @import("parse"); const can = @import("can"); const Check = @import("../Check.zig"); +const TestEnv = @import("./TestEnv.zig"); const Can = can.Can; const ModuleEnv = can.ModuleEnv; @@ -13,33 +14,6 @@ const CanonicalizedExpr = can.Can.CanonicalizedExpr; const testing = std.testing; const test_allocator = testing.allocator; -/// A unified helper to run the full pipeline: parse, canonicalize, and type-check source code. -fn typeCheck(allocator: std.mem.Allocator, source: []const u8) !bool { - // Set up module environment - var module_env = try ModuleEnv.init(allocator, source); - defer module_env.deinit(); - - // Parse - var parse_ast = try parse.parseExpr(&module_env.common, allocator); - defer parse_ast.deinit(allocator); - if (parse_ast.hasErrors()) return false; - - // Canonicalize - var czer = try Can.init(&module_env, &parse_ast, null); - defer czer.deinit(); - - const expr_idx: parse.AST.Expr.Idx = @enumFromInt(parse_ast.root_node_idx); - const canon_expr = try czer.canonicalizeExpr(expr_idx) orelse return false; - - // Type check - var checker = try Check.init(allocator, &module_env.types, &module_env, &.{}, &module_env.store.regions); - defer checker.deinit(); - - _ = try checker.checkExpr(canon_expr.get_idx()); - - return checker.problems.problems.items.len == 0; -} - test "direct polymorphic identity usage" { const source = \\{ @@ -49,7 +23,7 @@ test "direct polymorphic identity usage" { \\ { a, b } \\} ; - try testing.expect(try typeCheck(test_allocator, source)); + try typeCheck(source, "{ a: Num(_size), b: Str }"); } test "higher-order function with polymorphic identity" { @@ -62,7 +36,7 @@ test "higher-order function with polymorphic identity" { \\ { a, b } \\} ; - try testing.expect(try typeCheck(test_allocator, source)); + try typeCheck(source, "{ a: Num(_size), b: Str }"); } test "let-polymorphism with function composition" { @@ -76,7 +50,7 @@ test "let-polymorphism with function composition" { \\ { result1 } \\} ; - try testing.expect(try typeCheck(test_allocator, source)); + try typeCheck(source, "Num(_size)"); } test "polymorphic empty list" { @@ -88,7 +62,7 @@ test "polymorphic empty list" { \\ { empty, nums, strs } \\} ; - try testing.expect(try typeCheck(test_allocator, source)); + try typeCheck(source, "{ empty: List(_elem), nums: List(Num(_size)), strs: List(Str) }"); } test "polymorphic cons function" { @@ -105,7 +79,7 @@ test "polymorphic cons function" { \\ { list1, list2 } \\} ; - try testing.expect(try typeCheck(test_allocator, source)); + try typeCheck(source, "TODO"); } test "polymorphic map function" { @@ -121,7 +95,7 @@ test "polymorphic map function" { const source = \\{ - \\ map = |f, xs| + \\ map = |f, xs| \\ if xs == [] then \\ [] \\ else @@ -131,7 +105,7 @@ test "polymorphic map function" { \\ { nums } \\} ; - try testing.expect(try typeCheck(test_allocator, source)); + try typeCheck(source, "TODO"); } test "polymorphic record constructor" { @@ -140,11 +114,11 @@ test "polymorphic record constructor" { \\ make_pair = |x, y| { first: x, second: y } \\ pair1 = make_pair(1, "a") \\ pair2 = make_pair("hello", 42) - \\ pair3 = make_pair(true, false) + \\ pair3 = make_pair(True, False) \\ { pair1, pair2, pair3 } \\} ; - try testing.expect(try typeCheck(test_allocator, source)); + try typeCheck(source, "{ pair1: { first: Num(_size), second: Str }, pair2: { first: Str, second: Num(_size2) }, pair3: { first: Bool, second: Bool } }"); } test "polymorphic identity with various numeric types" { @@ -157,7 +131,7 @@ test "polymorphic identity with various numeric types" { \\ { int_val, float_val, bool_val } \\} ; - try testing.expect(try typeCheck(test_allocator, source)); + try typeCheck(source, "{ bool_val: Error, float_val: Num(Frac(_size)), int_val: Num(_size2) }"); } test "nested polymorphic data structures" { @@ -170,7 +144,7 @@ test "nested polymorphic data structures" { \\ { box1, box2, nested } \\} ; - try testing.expect(try typeCheck(test_allocator, source)); + try typeCheck(source, "{ box1: { value: Num(_size) }, box2: { value: Str }, nested: { value: { value: Num(_size2) } } }"); } test "polymorphic function in let binding" { @@ -185,31 +159,21 @@ test "polymorphic function in let binding" { \\ result \\} ; - try testing.expect(try typeCheck(test_allocator, source)); + try typeCheck(source, "{ a: Num(_size), b: Str }"); } test "polymorphic swap function" { - // This test is skipped because these features are missing: - // - Type inference for field access on polymorphic record parameters - // [parses and canonicalizes successfully, fails at type-check stage] - // The syntax `pair.field` works for concrete types but fails when `pair` is - // a polymorphic parameter with fields that have different types across usages. - // The type checker cannot properly infer that `swap` should be polymorphic - // over records with `first` and `second` fields of arbitrary types. - // TODO: Enable when polymorphic record field access type inference is improved - if (true) return error.SkipZigTest; - const source = \\{ \\ swap = |pair| { first: pair.second, second: pair.first } \\ pair1 = { first: 1, second: "a" } - \\ pair2 = { first: true, second: 42 } + \\ pair2 = { first: True, second: 42 } \\ swapped1 = swap(pair1) \\ swapped2 = swap(pair2) \\ { swapped1, swapped2 } \\} ; - try testing.expect(try typeCheck(test_allocator, source)); + try typeCheck(source, "{ swapped1: { first: Str, second: Num(_size) }, swapped2: { first: Num(_size2), second: Bool } }"); } test "polymorphic fold function" { @@ -236,7 +200,7 @@ test "polymorphic fold function" { \\ { sum, concat } \\} ; - try testing.expect(try typeCheck(test_allocator, source)); + try typeCheck(source, "TODO"); } test "polymorphic option type simulation" { @@ -250,7 +214,7 @@ test "polymorphic option type simulation" { \\ { opt1, opt2, opt3 } \\} ; - try testing.expect(try typeCheck(test_allocator, source)); + try typeCheck(source, "{ opt1: { tag: Str, value: Num(_size) }, opt2: { tag: Str, value: Str }, opt3: { tag: Str } }"); } test "polymorphic const function" { @@ -264,7 +228,7 @@ test "polymorphic const function" { \\ { num, str } \\} ; - try testing.expect(try typeCheck(test_allocator, source)); + try typeCheck(source, "{ num: Num(_size), str: Str }"); } test "shadowing of polymorphic values" { @@ -292,7 +256,7 @@ test "shadowing of polymorphic values" { \\ { a, inner, c } \\} ; - try testing.expect(try typeCheck(test_allocator, source)); + try typeCheck(source, "TODO"); } test "polymorphic pipe function" { @@ -300,11 +264,18 @@ test "polymorphic pipe function" { \\{ \\ pipe = |x, f| f(x) \\ double = |n| n * 2 - \\ length = |s| 5 // simplified string length + \\ length = |s| 5 \\ num_result = pipe(21, double) \\ str_result = pipe("hello", length) \\ { num_result, str_result } \\} ; - try testing.expect(try typeCheck(test_allocator, source)); + try typeCheck(source, "{ num_result: Num(_size), str_result: Num(_size2) }"); +} + +/// A unified helper to run the full pipeline: parse, canonicalize, and type-check source code. +fn typeCheck(comptime source_expr: []const u8, expected_type: []const u8) !void { + var test_env = try TestEnv.initExpr(source_expr); + defer test_env.deinit(); + return test_env.assertLastDefType(expected_type); } diff --git a/src/check/test/let_polymorphism_test.zig b/src/check/test/let_polymorphism_test.zig deleted file mode 100644 index f84c8310d3..0000000000 --- a/src/check/test/let_polymorphism_test.zig +++ /dev/null @@ -1,178 +0,0 @@ -//! These tests verify the core type instantiation logic for polymorphic values. - -const std = @import("std"); -const base = @import("base"); -const types = @import("types"); -const can = @import("can"); - -const TypesStore = types.Store; -const ModuleEnv = can.ModuleEnv; -const testing = std.testing; -const test_allocator = testing.allocator; -const Instantiate = types.instantiate.Instantiate; - -// test env // - -const TestEnv = struct { - module_env: *ModuleEnv, - store: *TypesStore, - var_subs: *Instantiate.SeenVars, - rigid_var_subs: *Instantiate.RigidToFlexSubs, - - fn init(allocator: std.mem.Allocator) !TestEnv { - const module_env = try allocator.create(ModuleEnv); - module_env.* = try ModuleEnv.init(allocator, ""); - - const store = try allocator.create(TypesStore); - store.* = try TypesStore.init(allocator); - - const var_subs = try allocator.create(Instantiate.SeenVars); - var_subs.* = Instantiate.SeenVars.init(allocator); - - const rigid_var_subs = try allocator.create(Instantiate.RigidToFlexSubs); - rigid_var_subs.* = try Instantiate.RigidToFlexSubs.init(allocator); - - return .{ - .module_env = module_env, - .store = store, - .var_subs = var_subs, - .rigid_var_subs = rigid_var_subs, - }; - } - - fn deinit(self: *TestEnv, allocator: std.mem.Allocator) void { - self.store.deinit(); - allocator.destroy(self.store); - self.module_env.deinit(); - allocator.destroy(self.module_env); - self.var_subs.deinit(); - allocator.destroy(self.var_subs); - self.rigid_var_subs.deinit(allocator); - allocator.destroy(self.rigid_var_subs); - } - - fn instantiate(self: *TestEnv, var_to_inst: types.Var, rigid_subs: []const struct { ident: []const u8, var_: types.Var }) !types.Var { - self.var_subs.clearRetainingCapacity(); - self.rigid_var_subs.clearFrom(0); - - for (rigid_subs) |sub| { - _ = try self.module_env.insertIdent(base.Ident.for_text(sub.ident)); - try self.rigid_var_subs.append(self.module_env.gpa, .{ .ident = sub.ident, .var_ = sub.var_ }); - } - - var inst = Instantiate.init(self.store, self.module_env.getIdentStore(), self.var_subs); - var instantiate_ctx = Instantiate.Ctx{ - .rigid_var_subs = self.rigid_var_subs, - }; - return inst.instantiateVar(var_to_inst, &instantiate_ctx); - } -}; - -test "let-polymorphism with empty list" { - var env = try TestEnv.init(test_allocator); - defer env.deinit(test_allocator); - - // forall a. List a - const a_ident = try env.module_env.insertIdent(base.Ident.for_text("a")); - const list_elem_var = try env.store.freshFromContent(.{ .rigid_var = a_ident }); - const poly_list_var = try env.store.freshFromContent(.{ .structure = .{ .list = list_elem_var } }); - - try testing.expect(env.store.needsInstantiation(poly_list_var)); - - const int_var = try env.store.freshFromContent(.{ .structure = .{ .num = .{ .num_compact = .{ .int = .i32 } } } }); - const int_list = try env.instantiate(poly_list_var, &.{.{ .ident = "a", .var_ = int_var }}); - - const str_var = try env.store.freshFromContent(.{ .structure = .str }); - const str_list = try env.instantiate(poly_list_var, &.{.{ .ident = "a", .var_ = str_var }}); - - try testing.expect(int_list != str_list); - try testing.expect(int_list != poly_list_var); -} - -test "let-polymorphism with polymorphic function" { - var env = try TestEnv.init(test_allocator); - defer env.deinit(test_allocator); - - // forall a. a -> a - const a_ident = try env.module_env.insertIdent(base.Ident.for_text("a")); - const type_param = try env.store.freshFromContent(.{ .rigid_var = a_ident }); - const func_content = try env.store.mkFuncPure(&.{type_param}, type_param); - const func_var = try env.store.freshFromContent(func_content); - - try testing.expect(env.store.needsInstantiation(func_var)); - - const str_var = try env.store.freshFromContent(.{ .structure = .str }); - const str_func = try env.instantiate(func_var, &.{.{ .ident = "a", .var_ = str_var }}); - - const num_var = try env.store.freshFromContent(.{ .structure = .{ .num = .{ .num_compact = .{ .int = .u32 } } } }); - const num_func = try env.instantiate(func_var, &.{.{ .ident = "a", .var_ = num_var }}); - - try testing.expect(str_func != num_func); -} - -test "let-polymorphism with multiple type parameters" { - var env = try TestEnv.init(test_allocator); - defer env.deinit(test_allocator); - - // forall a b. (a, b) -> (b, a) - const a_ident = try env.module_env.insertIdent(base.Ident.for_text("a")); - const b_ident = try env.module_env.insertIdent(base.Ident.for_text("b")); - const type_a = try env.store.freshFromContent(.{ .rigid_var = a_ident }); - const type_b = try env.store.freshFromContent(.{ .rigid_var = b_ident }); - - const func_content = try env.store.mkFuncPure(&.{ type_a, type_b }, type_b); // Simplified for test - const func_var = try env.store.freshFromContent(func_content); - - const str_var = try env.store.freshFromContent(.{ .structure = .str }); - const int_var = try env.store.freshFromContent(.{ .structure = .{ .num = .{ .num_compact = .{ .int = .i32 } } } }); - - const inst1 = try env.instantiate(func_var, &.{ - .{ .ident = "a", .var_ = str_var }, - .{ .ident = "b", .var_ = int_var }, - }); - - const inst2 = try env.instantiate(func_var, &.{ - .{ .ident = "a", .var_ = int_var }, - .{ .ident = "b", .var_ = str_var }, - }); - - try testing.expect(inst1 != inst2); -} - -test "let-polymorphism preserves sharing within single instantiation" { - var env = try TestEnv.init(test_allocator); - defer env.deinit(test_allocator); - - // forall a. { first: a, second: a } - const a_ident = try env.module_env.insertIdent(base.Ident.for_text("a")); - const type_param = try env.store.freshFromContent(.{ .rigid_var = a_ident }); - - const fields_range = try env.store.record_fields.appendSlice(env.module_env.gpa, &[_]types.RecordField{ - .{ .name = try env.module_env.insertIdent(base.Ident.for_text("first")), .var_ = type_param }, - .{ .name = try env.module_env.insertIdent(base.Ident.for_text("second")), .var_ = type_param }, - }); - const empty_ext = try env.store.freshFromContent(.{ .structure = .empty_record }); - const record_var = try env.store.freshFromContent(.{ .structure = .{ .record = .{ .fields = fields_range, .ext = empty_ext } } }); - - const int_var = try env.store.freshFromContent(.{ .structure = .{ .num = .{ .num_compact = .{ .int = .i32 } } } }); - const instantiated_rec = try env.instantiate(record_var, &.{.{ .ident = "a", .var_ = int_var }}); - - // Verify that both fields now point to the same, new concrete type. - const content = env.store.resolveVar(instantiated_rec).desc.content; - const rec = content.structure.record; - const fields = env.store.record_fields.sliceRange(rec.fields); - - try testing.expectEqual(fields.get(0).var_, fields.get(1).var_); - try testing.expect(env.store.resolveVar(fields.get(0).var_).desc.content.structure.num.num_compact.int == .i32); -} - -test "let-polymorphism prevents over-generalization of concrete types" { - var env = try TestEnv.init(test_allocator); - defer env.deinit(test_allocator); - - const i32_var = try env.store.freshFromContent(.{ .structure = .{ .num = .{ .num_compact = .{ .int = .i32 } } } }); - const list_i32_var = try env.store.freshFromContent(.{ .structure = .{ .list = i32_var } }); - - // This should NOT need instantiation because it's already concrete. - try testing.expect(!env.store.needsInstantiation(list_i32_var)); -} diff --git a/src/check/test/literal_size_test.zig b/src/check/test/literal_size_test.zig deleted file mode 100644 index 03eabd8469..0000000000 --- a/src/check/test/literal_size_test.zig +++ /dev/null @@ -1,592 +0,0 @@ -//! Tests for numeric literal size and type unification logic. - -const std = @import("std"); -const base = @import("base"); -const types = @import("types"); -const can = @import("can"); -const Check = @import("../Check.zig"); - -const TypesStore = types.TypesStore; -const Content = types.Content; -const ModuleEnv = can.ModuleEnv; -const Var = types.Var; -const Num = types.Num; -const problem = @import("../problem.zig"); -const snapshot = @import("../snapshot.zig"); -const occurs = @import("../occurs.zig"); -const FlatType = types.FlatType; -const ProblemStore = problem.Store; -const SnapshotStore = snapshot.Store; -const UnifierScratch = @import("../unify.zig").Scratch; -const OccursScratch = occurs.Scratch; -const unify = @import("../unify.zig").unify; - -test "integer literal 255 fits in U8" { - const gpa = std.testing.allocator; - - var module_env = try ModuleEnv.init(gpa, try gpa.dupe(u8, "")); - defer module_env.deinit(); - - var problems = try ProblemStore.initCapacity(gpa, 16); - defer problems.deinit(gpa); - - var snapshots = try SnapshotStore.initCapacity(gpa, 16); - defer snapshots.deinit(); - - var scratch = try UnifierScratch.init(gpa); - defer scratch.deinit(); - - var occurs_scratch = try OccursScratch.init(gpa); - defer occurs_scratch.deinit(); - - // Create a literal with value 255 - const literal_var = try module_env.types.freshFromContent(Content{ - .structure = .{ - .num = .{ - .num_poly = .{ - .requirements = Num.IntRequirements{ - .sign_needed = false, - .bits_needed = @intFromEnum(Num.Int.BitsNeeded.@"8"), - }, - .var_ = try module_env.types.fresh(), - }, - }, - }, - }); - - // Create U8 type - const u8_var = try module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_compact = .{ .int = .u8 } } } }); - - // They should unify successfully - const result = try unify( - &module_env, - &module_env.types, - &problems, - &snapshots, - &scratch, - &occurs_scratch, - literal_var, - u8_var, - ); - - try std.testing.expect(result == .ok); -} - -test "integer literal 256 does not fit in U8" { - const gpa = std.testing.allocator; - - var module_env = try ModuleEnv.init(gpa, try gpa.dupe(u8, "")); - defer module_env.deinit(); - - var problems = try ProblemStore.initCapacity(gpa, 16); - defer problems.deinit(gpa); - - var snapshots = try SnapshotStore.initCapacity(gpa, 16); - defer snapshots.deinit(); - - var scratch = try UnifierScratch.init(gpa); - defer scratch.deinit(); - - var occurs_scratch = try OccursScratch.init(gpa); - defer occurs_scratch.deinit(); - - // Create a literal with value 256 - const literal_var = try module_env.types.freshFromContent(Content{ - .structure = .{ - .num = .{ - .num_poly = .{ - .requirements = Num.IntRequirements{ - .sign_needed = false, - .bits_needed = @intFromEnum(Num.Int.BitsNeeded.@"9_to_15"), - }, - .var_ = try module_env.types.fresh(), - }, - }, - }, - }); - - // Create U8 type - const u8_var = try module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_compact = .{ .int = .u8 } } } }); - - // They should NOT unify - type mismatch expected - const result = try unify( - &module_env, - &module_env.types, - &problems, - &snapshots, - &scratch, - &occurs_scratch, - literal_var, - u8_var, - ); - - try std.testing.expect(result == .problem); -} - -test "integer literal -128 fits in I8" { - const gpa = std.testing.allocator; - - var module_env = try ModuleEnv.init(gpa, try gpa.dupe(u8, "")); - defer module_env.deinit(); - - var problems = try ProblemStore.initCapacity(gpa, 16); - defer problems.deinit(gpa); - - var snapshots = try SnapshotStore.initCapacity(gpa, 16); - defer snapshots.deinit(); - - var scratch = try UnifierScratch.init(gpa); - defer scratch.deinit(); - - var occurs_scratch = try OccursScratch.init(gpa); - defer occurs_scratch.deinit(); - - // Create a literal with value -128 - const literal_var = try module_env.types.freshFromContent(Content{ - .structure = .{ - .num = .{ - .num_poly = .{ - .requirements = Num.IntRequirements{ - .sign_needed = true, - .bits_needed = @intFromEnum(Num.Int.BitsNeeded.@"7"), - }, - .var_ = try module_env.types.fresh(), - }, - }, - }, - }); - - // Create I8 type - const i8_var = try module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_compact = .{ .int = .i8 } } } }); - - // They should unify successfully - const result = try unify( - &module_env, - &module_env.types, - &problems, - &snapshots, - &scratch, - &occurs_scratch, - literal_var, - i8_var, - ); - - try std.testing.expect(result == .ok); -} - -test "integer literal -129 does not fit in I8" { - const gpa = std.testing.allocator; - - var module_env = try ModuleEnv.init(gpa, try gpa.dupe(u8, "")); - defer module_env.deinit(); - - var problems = try ProblemStore.initCapacity(gpa, 16); - defer problems.deinit(gpa); - - var snapshots = try SnapshotStore.initCapacity(gpa, 16); - defer snapshots.deinit(); - - var scratch = try UnifierScratch.init(gpa); - defer scratch.deinit(); - - var occurs_scratch = try OccursScratch.init(gpa); - defer occurs_scratch.deinit(); - - // Create a literal with value -129 - const literal_var = try module_env.types.freshFromContent(Content{ - .structure = .{ - .num = .{ - .num_poly = .{ - .requirements = Num.IntRequirements{ - .sign_needed = true, - .bits_needed = @intFromEnum(Num.Int.BitsNeeded.@"8"), - }, - .var_ = try module_env.types.fresh(), - }, - }, - }, - }); - - // Create I8 type - const i8_var = try module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_compact = .{ .int = .i8 } } } }); - - // They should NOT unify - type mismatch expected - const result = try unify( - &module_env, - &module_env.types, - &problems, - &snapshots, - &scratch, - &occurs_scratch, - literal_var, - i8_var, - ); - - try std.testing.expect(result == .problem); -} - -test "negative literal cannot unify with unsigned type" { - const gpa = std.testing.allocator; - - var module_env = try ModuleEnv.init(gpa, try gpa.dupe(u8, "")); - defer module_env.deinit(); - - var problems = try ProblemStore.initCapacity(gpa, 16); - defer problems.deinit(gpa); - - var snapshots = try SnapshotStore.initCapacity(gpa, 16); - defer snapshots.deinit(); - - var scratch = try UnifierScratch.init(gpa); - defer scratch.deinit(); - - var occurs_scratch = try OccursScratch.init(gpa); - defer occurs_scratch.deinit(); - - // Create a literal with value -1 - const literal_var = try module_env.types.freshFromContent(Content{ - .structure = .{ - .num = .{ - .num_poly = .{ - .var_ = try module_env.types.fresh(), - .requirements = Num.IntRequirements{ - .sign_needed = true, - .bits_needed = @intFromEnum(Num.Int.BitsNeeded.@"7"), - }, - }, - }, - }, - }); - - // Create U8 type - const u8_var = try module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_compact = .{ .int = .u8 } } } }); - - // They should NOT unify - type mismatch expected - const result = try unify( - &module_env, - &module_env.types, - &problems, - &snapshots, - &scratch, - &occurs_scratch, - literal_var, - u8_var, - ); - - try std.testing.expect(result == .problem); -} - -test "float literal that fits in F32" { - const gpa = std.testing.allocator; - - var module_env = try ModuleEnv.init(gpa, try gpa.dupe(u8, "")); - defer module_env.deinit(); - - var problems = try ProblemStore.initCapacity(gpa, 16); - defer problems.deinit(gpa); - - var snapshots = try SnapshotStore.initCapacity(gpa, 16); - defer snapshots.deinit(); - - var scratch = try UnifierScratch.init(gpa); - defer scratch.deinit(); - - var occurs_scratch = try OccursScratch.init(gpa); - defer occurs_scratch.deinit(); - - // Create a literal that fits in F32 - const literal_var = try module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .frac_poly = .{ - .requirements = Num.FracRequirements{ - .fits_in_f32 = true, - .fits_in_dec = true, - }, - .var_ = try module_env.types.fresh(), - } } } }); - - // Create F32 type - const f32_var = try module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_compact = .{ .frac = .f32 } } } }); - - // They should unify successfully - const result = try unify( - &module_env, - &module_env.types, - &problems, - &snapshots, - &scratch, - &occurs_scratch, - literal_var, - f32_var, - ); - - try std.testing.expect(result == .ok); -} - -test "float literal that doesn't fit in F32" { - const gpa = std.testing.allocator; - - var module_env = try ModuleEnv.init(gpa, try gpa.dupe(u8, "")); - defer module_env.deinit(); - - var problems = try ProblemStore.initCapacity(gpa, 16); - defer problems.deinit(gpa); - - var snapshots = try SnapshotStore.initCapacity(gpa, 16); - defer snapshots.deinit(); - - var scratch = try UnifierScratch.init(gpa); - defer scratch.deinit(); - - var occurs_scratch = try OccursScratch.init(gpa); - defer occurs_scratch.deinit(); - - // Create a literal that doesn't fit in F32 (e.g., requires F64 precision) - const literal_var = try module_env.types.freshFromContent(Content{ - .structure = .{ - .num = .{ - .frac_poly = .{ - .requirements = Num.FracRequirements{ - .fits_in_f32 = false, - .fits_in_dec = true, - }, - .var_ = try module_env.types.fresh(), - }, - }, - }, - }); - - // Create F32 type - const f32_var = try module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_compact = .{ .frac = .f32 } } } }); - - // They should NOT unify - type mismatch expected - const result = try unify( - &module_env, - &module_env.types, - &problems, - &snapshots, - &scratch, - &occurs_scratch, - literal_var, - f32_var, - ); - - try std.testing.expect(result == .problem); -} - -test "float literal NaN doesn't fit in Dec" { - const gpa = std.testing.allocator; - - var module_env = try ModuleEnv.init(gpa, try gpa.dupe(u8, "")); - defer module_env.deinit(); - - var problems = try ProblemStore.initCapacity(gpa, 16); - defer problems.deinit(gpa); - - var snapshots = try SnapshotStore.initCapacity(gpa, 16); - defer snapshots.deinit(); - - var scratch = try UnifierScratch.init(gpa); - defer scratch.deinit(); - - var occurs_scratch = try OccursScratch.init(gpa); - defer occurs_scratch.deinit(); - - // Create a literal like NaN that doesn't fit in Dec - const literal_var = try module_env.types.freshFromContent(Content{ - .structure = .{ - .num = .{ - .frac_poly = .{ - .var_ = try module_env.types.fresh(), - .requirements = Num.FracRequirements{ - .fits_in_f32 = true, - .fits_in_dec = false, - }, - }, - }, - }, - }); - - // Create Dec type - const dec_var = try module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_compact = .{ .frac = .dec } } } }); - - // They should NOT unify - type mismatch expected - const result = try unify( - &module_env, - &module_env.types, - &problems, - &snapshots, - &scratch, - &occurs_scratch, - literal_var, - dec_var, - ); - - try std.testing.expect(result == .problem); -} - -test "two integer literals with different requirements unify to most restrictive" { - const gpa = std.testing.allocator; - - var module_env = try ModuleEnv.init(gpa, try gpa.dupe(u8, "")); - defer module_env.deinit(); - - var problems = try ProblemStore.initCapacity(gpa, 16); - defer problems.deinit(gpa); - - var snapshots = try SnapshotStore.initCapacity(gpa, 16); - defer snapshots.deinit(); - - var scratch = try UnifierScratch.init(gpa); - defer scratch.deinit(); - - var occurs_scratch = try OccursScratch.init(gpa); - defer occurs_scratch.deinit(); - - // Create a literal with value 100 (7 bits, no sign) - const literal1_var = try module_env.types.freshFromContent(Content{ - .structure = .{ - .num = .{ - .num_poly = .{ - .var_ = try module_env.types.fresh(), - .requirements = Num.IntRequirements{ - .sign_needed = false, - .bits_needed = @intFromEnum(Num.Int.BitsNeeded.@"7"), - }, - }, - }, - }, - }); - - // Create a literal with value 200 (8 bits, no sign) - const literal2_var = try module_env.types.freshFromContent(Content{ - .structure = .{ - .num = .{ - .num_poly = .{ - .var_ = try module_env.types.fresh(), - .requirements = Num.IntRequirements{ - .sign_needed = false, - .bits_needed = @intFromEnum(Num.Int.BitsNeeded.@"8"), - }, - }, - }, - }, - }); - - // They should unify successfully - const result = try unify( - &module_env, - &module_env.types, - &problems, - &snapshots, - &scratch, - &occurs_scratch, - literal1_var, - literal2_var, - ); - - try std.testing.expect(result == .ok); - - // Verify that the result has bits_needed = 8 - // After unification, both variables should have the most restrictive requirements - const resolved1 = module_env.types.resolveVar(literal1_var); - switch (resolved1.desc.content) { - .structure => |structure| switch (structure) { - .num => |num| switch (num) { - .num_poly => |requirements| { - try std.testing.expectEqual(@as(u8, @intFromEnum(Num.Int.BitsNeeded.@"8")), requirements.requirements.bits_needed); - try std.testing.expectEqual(false, requirements.requirements.sign_needed); - }, - .int_poly => |requirements| { - try std.testing.expectEqual(@as(u8, @intFromEnum(Num.Int.BitsNeeded.@"8")), requirements.requirements.bits_needed); - try std.testing.expectEqual(false, requirements.requirements.sign_needed); - }, - else => return error.UnexpectedNumType, - }, - else => return error.UnexpectedStructureType, - }, - else => return error.UnexpectedContentType, - } -} - -test "positive and negative literals unify with sign requirement" { - const gpa = std.testing.allocator; - - var module_env = try ModuleEnv.init(gpa, try gpa.dupe(u8, "")); - defer module_env.deinit(); - - var problems = try ProblemStore.initCapacity(gpa, 16); - defer problems.deinit(gpa); - - var snapshots = try SnapshotStore.initCapacity(gpa, 16); - defer snapshots.deinit(); - - var scratch = try UnifierScratch.init(gpa); - defer scratch.deinit(); - - var occurs_scratch = try OccursScratch.init(gpa); - defer occurs_scratch.deinit(); - - // Create a literal with value 100 (no sign needed) - const literal1_var = try module_env.types.freshFromContent(Content{ - .structure = FlatType{ - .num = Num{ - .num_poly = .{ - .var_ = try module_env.types.fresh(), - .requirements = Num.IntRequirements{ - .sign_needed = false, - .bits_needed = @intFromEnum(Num.Int.BitsNeeded.@"7"), - }, - }, - }, - }, - }); - - // Create a literal with value -100 (sign needed) - const literal2_var = try module_env.types.freshFromContent(Content{ - .structure = .{ - .num = .{ - .num_poly = .{ - .var_ = try module_env.types.fresh(), - .requirements = Num.IntRequirements{ - .sign_needed = true, - .bits_needed = @intFromEnum(Num.Int.BitsNeeded.@"7"), - }, - }, - }, - }, - }); - - // They should unify successfully - const result = try unify( - &module_env, - &module_env.types, - &problems, - &snapshots, - &scratch, - &occurs_scratch, - literal1_var, - literal2_var, - ); - - try std.testing.expect(result == .ok); - - // Verify that the result has sign_needed = true - // After unification, both variables should have the most restrictive requirements - const resolved1 = module_env.types.resolveVar(literal1_var); - switch (resolved1.desc.content) { - .structure => |structure| switch (structure) { - .num => |num| switch (num) { - .num_poly => |requirements| { - try std.testing.expectEqual(true, requirements.requirements.sign_needed); - try std.testing.expectEqual(@as(u8, @intFromEnum(Num.Int.BitsNeeded.@"7")), requirements.requirements.bits_needed); - }, - .int_poly => |requirements| { - try std.testing.expectEqual(true, requirements.requirements.sign_needed); - try std.testing.expectEqual(@as(u8, @intFromEnum(Num.Int.BitsNeeded.@"7")), requirements.requirements.bits_needed); - }, - else => return error.UnexpectedNumType, - }, - else => return error.UnexpectedStructureType, - }, - else => return error.UnexpectedContentType, - } -} diff --git a/src/check/test/nominal_type_origin_test.zig b/src/check/test/nominal_type_origin_test.zig index 0a108e471b..615a9149ff 100644 --- a/src/check/test/nominal_type_origin_test.zig +++ b/src/check/test/nominal_type_origin_test.zig @@ -3,11 +3,13 @@ const std = @import("std"); const base = @import("base"); const types_mod = @import("types"); +const can = @import("can"); const Check = @import("../Check.zig"); const snapshot = @import("../snapshot.zig"); const Ident = base.Ident; +const ModuleEnv = can.ModuleEnv; const testing = std.testing; const test_allocator = testing.allocator; @@ -38,19 +40,17 @@ test "nominal type origin - displays origin in snapshot writer" { // Test 1: Origin shown when type is from different module { - var buf = std.array_list.Managed(u8).init(test_allocator); - defer buf.deinit(); - var writer = snapshot.SnapshotWriter.init( - buf.writer(), + test_allocator, &snapshots, &idents, ); + defer writer.deinit(); writer.current_module_name = "CurrentModule"; try writer.writeNominalType(nominal_type, nominal_type_backing_idx); - const result = buf.items; + const result = writer.get(); // Should show "Person (from Data.Types)" try testing.expect(std.mem.indexOf(u8, result, "Person") != null); try testing.expect(std.mem.indexOf(u8, result, "(from Data.Types)") != null); @@ -58,9 +58,6 @@ test "nominal type origin - displays origin in snapshot writer" { // Test 2: Origin NOT shown when type is from same module { - var buf = std.array_list.Managed(u8).init(test_allocator); - defer buf.deinit(); - // Create a nominal type from the current module const same_module_nominal = snapshot.SnapshotNominalType{ .ident = types_mod.TypeIdent{ .ident_idx = type_name_ident }, @@ -69,15 +66,16 @@ test "nominal type origin - displays origin in snapshot writer" { }; var writer = snapshot.SnapshotWriter.init( - buf.writer(), + test_allocator, &snapshots, &idents, ); + defer writer.deinit(); writer.current_module_name = "CurrentModule"; try writer.writeNominalType(same_module_nominal, nominal_type_backing_idx); - const result = buf.items; + const result = writer.get(); // Should show just "Person" without origin try testing.expect(std.mem.indexOf(u8, result, "Person") != null); try testing.expect(std.mem.indexOf(u8, result, "(from CurrentModule)") == null); @@ -101,15 +99,16 @@ test "nominal type origin - displays origin in snapshot writer" { }; var writer = snapshot.SnapshotWriter.init( - buf.writer(), + test_allocator, &snapshots, &idents, ); + defer writer.deinit(); writer.current_module_name = "CurrentModule"; try writer.writeNominalType(generic_nominal, nominal_type_backing_idx); - const result = buf.items; + const result = writer.get(); // Should show "Person(Str) (from Data.Types)" try testing.expect(std.mem.indexOf(u8, result, "Person(Str)") != null); try testing.expect(std.mem.indexOf(u8, result, "(from Data.Types)") != null); @@ -137,19 +136,17 @@ test "nominal type origin - works with no context" { .origin_module = module_ident, }; - var buf = std.array_list.Managed(u8).init(test_allocator); - defer buf.deinit(); - // Use the basic init without context var writer = snapshot.SnapshotWriter.init( - buf.writer(), + test_allocator, &snapshots, &idents, ); + defer writer.deinit(); try writer.writeNominalType(nominal_type, nominal_type_backing_idx); - const result = buf.items; + const result = writer.get(); // Should show just "MyType" without origin info try testing.expect(std.mem.indexOf(u8, result, "MyType") != null); try testing.expect(std.mem.indexOf(u8, result, "(from") == null); diff --git a/src/check/test/num_type_inference_test.zig b/src/check/test/num_type_inference_test.zig new file mode 100644 index 0000000000..c188f9b677 --- /dev/null +++ b/src/check/test/num_type_inference_test.zig @@ -0,0 +1,349 @@ +//! Tests for integer literal type inference +//! +//! This module contains unit tests that verify the correct type inferenece +//! of integer literals and integer expressions from CIR into the types store + +const std = @import("std"); +const testing = std.testing; +const base = @import("base"); +const types = @import("types"); +const parse = @import("parse"); +const builtins = @import("builtins"); +const Can = @import("can").Can; +const CIR = @import("can").CIR; +const ModuleEnv = @import("can").ModuleEnv; +const RocDec = builtins.dec.RocDec; +const TestEnv = @import("TestEnv.zig"); +const parseIntWithUnderscores = Can.parseIntWithUnderscores; +const Content = types.Content; + +test "infers type for small nums" { + const test_cases = [_]struct { source: []const u8, expected: []const u8 }{ + .{ .source = "1", .expected = "Num(_size)" }, + .{ .source = "-1", .expected = "Num(_size)" }, + .{ .source = "10", .expected = "Num(_size)" }, + .{ .source = "-10", .expected = "Num(_size)" }, + .{ .source = "255", .expected = "Num(_size)" }, + .{ .source = "-128", .expected = "Num(_size)" }, + .{ .source = "256", .expected = "Num(_size)" }, + .{ .source = "-129", .expected = "Num(_size)" }, + .{ .source = "32767", .expected = "Num(_size)" }, + .{ .source = "-32768", .expected = "Num(_size)" }, + .{ .source = "65535", .expected = "Num(_size)" }, + .{ .source = "-32769", .expected = "Num(_size)" }, + }; + + inline for (test_cases) |tc| { + var test_env = try TestEnv.initExpr(tc.source); + defer test_env.deinit(); + + try test_env.assertLastDefType(tc.expected); + } +} + +test "infers type for nums with specific requirements" { + const test_cases = [_]struct { + source: []const u8, + expected_sign_needed: bool, + expected_bits_needed: types.Num.Int.BitsNeeded, + }{ + .{ .source = "127", .expected_sign_needed = false, .expected_bits_needed = .@"7" }, + .{ .source = "128", .expected_sign_needed = false, .expected_bits_needed = .@"8" }, + .{ .source = "255", .expected_sign_needed = false, .expected_bits_needed = .@"8" }, + .{ .source = "256", .expected_sign_needed = false, .expected_bits_needed = .@"9_to_15" }, + .{ .source = "-128", .expected_sign_needed = true, .expected_bits_needed = .@"7" }, + .{ .source = "-129", .expected_sign_needed = true, .expected_bits_needed = .@"8" }, + .{ .source = "32767", .expected_sign_needed = false, .expected_bits_needed = .@"9_to_15" }, + .{ .source = "32768", .expected_sign_needed = false, .expected_bits_needed = .@"16" }, + .{ .source = "65535", .expected_sign_needed = false, .expected_bits_needed = .@"16" }, + .{ .source = "65536", .expected_sign_needed = false, .expected_bits_needed = .@"17_to_31" }, + }; + + inline for (test_cases) |tc| { + var test_env = try TestEnv.initExpr(tc.source); + defer test_env.deinit(); + + const typ = (try test_env.getLastExprType()).content; + + try testing.expect(typ == .structure); + try testing.expect(typ.structure == .num); + try testing.expect(typ.structure.num == .num_unbound); + + const reqs = typ.structure.num.num_unbound; + + try testing.expectEqual(tc.expected_sign_needed, reqs.int_requirements.sign_needed); + try testing.expectEqual( + tc.expected_bits_needed.toBits(), + reqs.int_requirements.bits_needed, + ); + + try testing.expectEqual(true, reqs.frac_requirements.fits_in_f32); + try testing.expectEqual(true, reqs.frac_requirements.fits_in_dec); + } +} + +test "infers num requirements correctly" { + const test_cases = [_]struct { + source: []const u8, + expected_sign_needed: bool, + expected_bits_needed: types.Num.Int.BitsNeeded, + }{ + // 255 needs 8 bits and no sign + .{ .source = "255", .expected_sign_needed = false, .expected_bits_needed = .@"8" }, + // 256 needs 9-15 bits and no sign + .{ .source = "256", .expected_sign_needed = false, .expected_bits_needed = .@"9_to_15" }, + // -1 needs sign and 7 bits + .{ .source = "-1", .expected_sign_needed = true, .expected_bits_needed = .@"7" }, + // 65535 needs 16 bits and no sign + .{ .source = "65535", .expected_sign_needed = false, .expected_bits_needed = .@"16" }, + // 65536 needs 17-31 bits and no sign + .{ .source = "65536", .expected_sign_needed = false, .expected_bits_needed = .@"17_to_31" }, + }; + + inline for (test_cases) |tc| { + var test_env = try TestEnv.initExpr(tc.source); + defer test_env.deinit(); + + const typ = (try test_env.getLastExprType()).content; + + try testing.expect(typ == .structure); + try testing.expect(typ.structure == .num); + try testing.expect(typ.structure.num == .num_unbound); + + const reqs = typ.structure.num.num_unbound; + + try testing.expectEqual(tc.expected_sign_needed, reqs.int_requirements.sign_needed); + try testing.expectEqual( + tc.expected_bits_needed.toBits(), + reqs.int_requirements.bits_needed, + ); + + try testing.expectEqual(true, reqs.frac_requirements.fits_in_f32); + try testing.expectEqual(true, reqs.frac_requirements.fits_in_dec); + } +} + +test "fail to infer num literals outside supported range" { + // Test integer literals that are too big to be represented + const test_cases = [_][]const u8{ + // Negative number slightly lower than i128 min + "-170141183460469231731687303715884105729", + // Number too big for u128 max (340282366920938463463374607431768211455) + "340282366920938463463374607431768211456", + // Way too big + "999999999999999999999999999999999999999999999999999", + // Way, way too big + "999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999", + // Way, way too big + "-999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999", + }; + + inline for (test_cases) |source| { + var test_env = try TestEnv.initExpr(source); + defer test_env.deinit(); + + const typ = (try test_env.getLastExprType()).content; + try testing.expect(typ == .err); + } +} + +test "edge case: negative 0" { + const source = "-0"; + var test_env = try TestEnv.initExpr(source); + defer test_env.deinit(); + + const typ = (try test_env.getLastExprType()).content; + + try testing.expect(typ == .structure); + try testing.expect(typ.structure == .num); + try testing.expect(typ.structure.num == .num_unbound); + + const reqs = typ.structure.num.num_unbound; + + try testing.expectEqual(false, reqs.int_requirements.sign_needed); + try testing.expectEqual(7, reqs.int_requirements.bits_needed); + + try testing.expectEqual(true, reqs.frac_requirements.fits_in_f32); + try testing.expectEqual(true, reqs.frac_requirements.fits_in_dec); +} + +test "edge case: positive 0" { + const source = "0"; + var test_env = try TestEnv.initExpr(source); + defer test_env.deinit(); + + const typ = (try test_env.getLastExprType()).content; + + try testing.expect(typ == .structure); + try testing.expect(typ.structure == .num); + try testing.expect(typ.structure.num == .num_unbound); + + const reqs = typ.structure.num.num_unbound; + + try testing.expectEqual(false, reqs.int_requirements.sign_needed); + try testing.expectEqual(7, reqs.int_requirements.bits_needed); + + try testing.expectEqual(true, reqs.frac_requirements.fits_in_f32); + try testing.expectEqual(true, reqs.frac_requirements.fits_in_dec); +} + +test "infer hexadecimal literals as unbound integer" { + const test_cases = [_]struct { + source: []const u8, + expected_sign_needed: bool, + expected_bits_needed: types.Num.Int.BitsNeeded, + }{ + // Basic hex literals + .{ .source = "0x0", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(0) }, + .{ .source = "0x1", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(0) }, + .{ .source = "0xFF", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(1) }, + .{ .source = "0x100", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(2) }, + .{ .source = "0xFFFF", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(3) }, + .{ .source = "0x10000", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(4) }, + .{ .source = "0xFFFFFFFF", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(5) }, + .{ .source = "0x100000000", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(6) }, + .{ .source = "0xFFFFFFFFFFFFFFFF", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(7) }, + + // Hex with underscores + .{ .source = "0x1_000", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(2) }, + .{ .source = "0xFF_FF", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(3) }, + .{ .source = "0x1234_5678_9ABC_DEF0", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(6) }, + + // Negative hex literals + .{ .source = "-0x1", .expected_sign_needed = true, .expected_bits_needed = @enumFromInt(0) }, + .{ .source = "-0x80", .expected_sign_needed = true, .expected_bits_needed = @enumFromInt(0) }, + .{ .source = "-0x81", .expected_sign_needed = true, .expected_bits_needed = @enumFromInt(1) }, + .{ .source = "-0x8000", .expected_sign_needed = true, .expected_bits_needed = @enumFromInt(2) }, + .{ .source = "-0x8001", .expected_sign_needed = true, .expected_bits_needed = @enumFromInt(3) }, + .{ .source = "-0x80000000", .expected_sign_needed = true, .expected_bits_needed = @enumFromInt(4) }, + .{ .source = "-0x80000001", .expected_sign_needed = true, .expected_bits_needed = @enumFromInt(5) }, + .{ .source = "-0x8000000000000000", .expected_sign_needed = true, .expected_bits_needed = @enumFromInt(6) }, + .{ .source = "-0x8000000000000001", .expected_sign_needed = true, .expected_bits_needed = @enumFromInt(7) }, + }; + + inline for (test_cases) |tc| { + var test_env = try TestEnv.initExpr(tc.source); + defer test_env.deinit(); + + const typ = (try test_env.getLastExprType()).content; + + try testing.expect(typ == .structure); + try testing.expect(typ.structure == .num); + try testing.expect(typ.structure.num == .num_poly); + + const int_typ = test_env.module_env.types.resolveVar(typ.structure.num.num_poly).desc.content; + + try testing.expect(int_typ == .structure); + try testing.expect(int_typ.structure == .num); + try testing.expect(int_typ.structure.num == .int_unbound); + + const reqs = int_typ.structure.num.int_unbound; + + try testing.expectEqual(tc.expected_sign_needed, reqs.sign_needed); + try testing.expectEqual(tc.expected_bits_needed.toBits(), reqs.bits_needed); + } +} + +test "infer binary literals as unbound integer" { + const test_cases = [_]struct { + source: []const u8, + expected_sign_needed: bool, + expected_bits_needed: types.Num.Int.BitsNeeded, + }{ + // Basic binary literals + .{ .source = "0b0", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(0) }, + .{ .source = "0b1", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(0) }, + .{ .source = "0b10", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(0) }, + .{ .source = "0b11111111", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(1) }, + .{ .source = "0b100000000", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(2) }, + .{ .source = "0b1111111111111111", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(3) }, + .{ .source = "0b10000000000000000", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(4) }, + + // Binary with underscores + .{ .source = "0b11_11", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(0) }, + .{ .source = "0b1111_1111", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(1) }, + .{ .source = "0b1_0000_0000", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(2) }, + .{ .source = "0b1010_1010_1010_1010", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(3) }, + + // Negative binary + .{ .source = "-0b1", .expected_sign_needed = true, .expected_bits_needed = @enumFromInt(0) }, + .{ .source = "-0b10000000", .expected_sign_needed = true, .expected_bits_needed = @enumFromInt(0) }, + .{ .source = "-0b10000001", .expected_sign_needed = true, .expected_bits_needed = @enumFromInt(1) }, + .{ .source = "-0b1000000000000000", .expected_sign_needed = true, .expected_bits_needed = @enumFromInt(2) }, + .{ .source = "-0b1000000000000001", .expected_sign_needed = true, .expected_bits_needed = @enumFromInt(3) }, + }; + + inline for (test_cases) |tc| { + var test_env = try TestEnv.initExpr(tc.source); + defer test_env.deinit(); + + const typ = (try test_env.getLastExprType()).content; + + try testing.expect(typ == .structure); + try testing.expect(typ.structure == .num); + try testing.expect(typ.structure.num == .num_poly); + + const int_typ = test_env.module_env.types.resolveVar(typ.structure.num.num_poly).desc.content; + + try testing.expect(int_typ == .structure); + try testing.expect(int_typ.structure == .num); + try testing.expect(int_typ.structure.num == .int_unbound); + + const reqs = int_typ.structure.num.int_unbound; + + try testing.expectEqual(tc.expected_sign_needed, reqs.sign_needed); + try testing.expectEqual(tc.expected_bits_needed.toBits(), reqs.bits_needed); + } +} + +test "infer octal literals as unbound integer" { + const test_cases = [_]struct { + source: []const u8, + expected_sign_needed: bool, + expected_bits_needed: types.Num.Int.BitsNeeded, + }{ + // Basic octal literals + .{ .source = "0o0", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(0) }, + .{ .source = "0o1", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(0) }, + .{ .source = "0o7", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(0) }, + .{ .source = "0o10", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(0) }, + .{ .source = "0o377", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(1) }, + .{ .source = "0o400", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(2) }, + .{ .source = "0o177777", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(3) }, + .{ .source = "0o200000", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(4) }, + + // Octal with underscores + .{ .source = "0o377_377", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(4) }, + .{ .source = "0o1_234_567", .expected_sign_needed = false, .expected_bits_needed = @enumFromInt(4) }, + + // Negative octal literals + .{ .source = "-0o1", .expected_sign_needed = true, .expected_bits_needed = @enumFromInt(0) }, + .{ .source = "-0o100", .expected_sign_needed = true, .expected_bits_needed = @enumFromInt(0) }, + .{ .source = "-0o200", .expected_sign_needed = true, .expected_bits_needed = @enumFromInt(0) }, + .{ .source = "-0o201", .expected_sign_needed = true, .expected_bits_needed = @enumFromInt(1) }, + .{ .source = "-0o100000", .expected_sign_needed = true, .expected_bits_needed = @enumFromInt(2) }, + .{ .source = "-0o100001", .expected_sign_needed = true, .expected_bits_needed = @enumFromInt(3) }, + }; + + inline for (test_cases) |tc| { + var test_env = try TestEnv.initExpr(tc.source); + defer test_env.deinit(); + + const typ = (try test_env.getLastExprType()).content; + + try testing.expect(typ == .structure); + try testing.expect(typ.structure == .num); + try testing.expect(typ.structure.num == .num_poly); + + const int_typ = test_env.module_env.types.resolveVar(typ.structure.num.num_poly).desc.content; + + try testing.expect(int_typ == .structure); + try testing.expect(int_typ.structure == .num); + try testing.expect(int_typ.structure.num == .int_unbound); + + const reqs = int_typ.structure.num.int_unbound; + + try testing.expectEqual(tc.expected_sign_needed, reqs.sign_needed); + try testing.expectEqual(tc.expected_bits_needed.toBits(), reqs.bits_needed); + } +} diff --git a/src/check/test/num_type_requirements_test.zig b/src/check/test/num_type_requirements_test.zig new file mode 100644 index 0000000000..701751d25e --- /dev/null +++ b/src/check/test/num_type_requirements_test.zig @@ -0,0 +1,283 @@ +//! Tests for numeric literal size and type unification logic. + +const std = @import("std"); +const base = @import("base"); +const types = @import("types"); +const can = @import("can"); +const Check = @import("../Check.zig"); +const TestEnv = @import("./TestEnv.zig"); + +const TypesStore = types.TypesStore; +const Content = types.Content; +const ModuleEnv = can.ModuleEnv; +const Var = types.Var; +const Num = types.Num; +const problem = @import("../problem.zig"); +const snapshot = @import("../snapshot.zig"); +const occurs = @import("../occurs.zig"); +const FlatType = types.FlatType; +const ProblemStore = problem.Store; +const SnapshotStore = snapshot.Store; +const UnifierScratch = @import("../unify.zig").Scratch; +const OccursScratch = occurs.Scratch; +const unify = @import("../unify.zig").unify; + +test "U8: 255 fits" { + const source = + \\{ + \\ x : U8 + \\ x = 50 + \\ + \\ x + 255 + \\} + ; + + var test_env = try TestEnv.initExpr(source); + defer test_env.deinit(); + try test_env.assertLastDefType("Num(Int(Unsigned8))"); +} + +test "U8: 256 does not fit" { + const source = + \\{ + \\ x : U8 + \\ x = 50 + \\ + \\ x + 256 + \\} + ; + + var test_env = try TestEnv.initExpr(source); + defer test_env.deinit(); + try test_env.assertOneTypeError("NUMBER DOES NOT FIT IN TYPE"); +} + +test "U8: negative does not fit" { + const source = + \\{ + \\ x : U8 + \\ x = 50 + \\ + \\ x + -1 + \\} + ; + + var test_env = try TestEnv.initExpr(source); + defer test_env.deinit(); + try test_env.assertOneTypeError("NEGATIVE UNSIGNED INTEGER"); +} + +test "I8: -128 fits" { + const source = + \\{ + \\ x : I8 + \\ x = 1 + \\ + \\ x + -128 + \\} + ; + + var test_env = try TestEnv.initExpr(source); + defer test_env.deinit(); + try test_env.assertLastDefType("Num(Int(Signed8))"); +} + +test "I8: -129 does not fit" { + const source = + \\{ + \\ x : I8 + \\ x = 1 + \\ + \\ x + -129 + \\} + ; + + var test_env = try TestEnv.initExpr(source); + defer test_env.deinit(); + try test_env.assertOneTypeError("NUMBER DOES NOT FIT IN TYPE"); +} + +test "F32: fits" { + const source = + \\{ + \\ x : F32 + \\ x = 1 + \\ + \\ x + 10.1 + \\} + ; + + var test_env = try TestEnv.initExpr(source); + defer test_env.deinit(); + try test_env.assertLastDefType("Num(Frac(Float32))"); +} + +// TODO: Move these to unify + +// test "two integer literals with different requirements unify to most restrictive" { +// const gpa = std.testing.allocator; + +// var module_env = try ModuleEnv.init(gpa, try gpa.dupe(u8, "")); +// defer module_env.deinit(); + +// var problems = try ProblemStore.initCapacity(gpa, 16); +// defer problems.deinit(gpa); + +// var snapshots = try SnapshotStore.initCapacity(gpa, 16); +// defer snapshots.deinit(); + +// var scratch = try UnifierScratch.init(gpa); +// defer scratch.deinit(); + +// var occurs_scratch = try OccursScratch.init(gpa); +// defer occurs_scratch.deinit(); + +// // Create a literal with value 100 (7 bits, no sign) +// const literal1_var = try module_env.types.freshFromContent(Content{ +// .structure = .{ +// .num = .{ +// .num_poly = .{ +// .var_ = try module_env.types.fresh(), +// .requirements = Num.IntRequirements{ +// .sign_needed = false, +// .bits_needed = @intFromEnum(Num.Int.BitsNeeded.@"7"), +// }, +// }, +// }, +// }, +// }); + +// // Create a literal with value 200 (8 bits, no sign) +// const literal2_var = try module_env.types.freshFromContent(Content{ +// .structure = .{ +// .num = .{ +// .num_poly = .{ +// .var_ = try module_env.types.fresh(), +// .requirements = Num.IntRequirements{ +// .sign_needed = false, +// .bits_needed = @intFromEnum(Num.Int.BitsNeeded.@"8"), +// }, +// }, +// }, +// }, +// }); + +// // They should unify successfully +// const result = try unify( +// &module_env, +// &module_env.types, +// &problems, +// &snapshots, +// &scratch, +// &occurs_scratch, +// literal1_var, +// literal2_var, +// ); + +// try std.testing.expect(result == .ok); + +// // Verify that the result has bits_needed = 8 +// // After unification, both variables should have the most restrictive requirements +// const resolved1 = module_env.types.resolveVar(literal1_var); +// switch (resolved1.desc.content) { +// .structure => |structure| switch (structure) { +// .num => |num| switch (num) { +// .num_poly => |requirements| { +// try std.testing.expectEqual(@as(u8, @intFromEnum(Num.Int.BitsNeeded.@"8")), requirements.requirements.bits_needed); +// try std.testing.expectEqual(false, requirements.requirements.sign_needed); +// }, +// .int_poly => |requirements| { +// try std.testing.expectEqual(@as(u8, @intFromEnum(Num.Int.BitsNeeded.@"8")), requirements.requirements.bits_needed); +// try std.testing.expectEqual(false, requirements.requirements.sign_needed); +// }, +// else => return error.UnexpectedNumType, +// }, +// else => return error.UnexpectedStructureType, +// }, +// else => return error.UnexpectedContentType, +// } +// } + +// test "positive and negative literals unify with sign requirement" { +// const gpa = std.testing.allocator; + +// var module_env = try ModuleEnv.init(gpa, try gpa.dupe(u8, "")); +// defer module_env.deinit(); + +// var problems = try ProblemStore.initCapacity(gpa, 16); +// defer problems.deinit(gpa); + +// var snapshots = try SnapshotStore.initCapacity(gpa, 16); +// defer snapshots.deinit(); + +// var scratch = try UnifierScratch.init(gpa); +// defer scratch.deinit(); + +// var occurs_scratch = try OccursScratch.init(gpa); +// defer occurs_scratch.deinit(); + +// // Create a literal with value 100 (no sign needed) +// const literal1_var = try module_env.types.freshFromContent(Content{ +// .structure = FlatType{ +// .num = Num{ +// .num_poly = .{ +// .var_ = try module_env.types.fresh(), +// .requirements = Num.IntRequirements{ +// .sign_needed = false, +// .bits_needed = @intFromEnum(Num.Int.BitsNeeded.@"7"), +// }, +// }, +// }, +// }, +// }); + +// // Create a literal with value -100 (sign needed) +// const literal2_var = try module_env.types.freshFromContent(Content{ +// .structure = .{ +// .num = .{ +// .num_poly = .{ +// .var_ = try module_env.types.fresh(), +// .requirements = Num.IntRequirements{ +// .sign_needed = true, +// .bits_needed = @intFromEnum(Num.Int.BitsNeeded.@"7"), +// }, +// }, +// }, +// }, +// }); + +// // They should unify successfully +// const result = try unify( +// &module_env, +// &module_env.types, +// &problems, +// &snapshots, +// &scratch, +// &occurs_scratch, +// literal1_var, +// literal2_var, +// ); + +// try std.testing.expect(result == .ok); + +// // Verify that the result has sign_needed = true +// // After unification, both variables should have the most restrictive requirements +// const resolved1 = module_env.types.resolveVar(literal1_var); +// switch (resolved1.desc.content) { +// .structure => |structure| switch (structure) { +// .num => |num| switch (num) { +// .num_poly => |requirements| { +// try std.testing.expectEqual(true, requirements.requirements.sign_needed); +// try std.testing.expectEqual(@as(u8, @intFromEnum(Num.Int.BitsNeeded.@"7")), requirements.requirements.bits_needed); +// }, +// .int_poly => |requirements| { +// try std.testing.expectEqual(true, requirements.requirements.sign_needed); +// try std.testing.expectEqual(@as(u8, @intFromEnum(Num.Int.BitsNeeded.@"7")), requirements.requirements.bits_needed); +// }, +// else => return error.UnexpectedNumType, +// }, +// else => return error.UnexpectedStructureType, +// }, +// else => return error.UnexpectedContentType, +// } +// } diff --git a/src/check/test/type_checking_integration.zig b/src/check/test/type_checking_integration.zig new file mode 100644 index 0000000000..bcaec62b9c --- /dev/null +++ b/src/check/test/type_checking_integration.zig @@ -0,0 +1,1117 @@ +//! Integration tests for let-polymorphism that parse, canonicalize, and type-check +//! actual code to ensure polymorphic values work correctly in practice. + +const std = @import("std"); +const base = @import("base"); +const parse = @import("parse"); +const can = @import("can"); +const types_mod = @import("types"); +const problem_mod = @import("../problem.zig"); +const Check = @import("../Check.zig"); +const TestEnv = @import("./TestEnv.zig"); + +const Can = can.Can; +const ModuleEnv = can.ModuleEnv; +const CanonicalizedExpr = can.Can.CanonicalizedExpr; +const testing = std.testing; +const test_allocator = testing.allocator; + +// primitives - nums // + +test "check type - num - unbound" { + const source = + \\50 + ; + try assertExprTypeCheckPass(source, "Num(_size)"); +} + +test "check type - num - int suffix 1" { + const source = + \\10u8 + ; + try assertExprTypeCheckPass(source, "Num(Int(Unsigned8))"); +} + +test "check type - num - int suffix 2" { + const source = + \\10i128 + ; + try assertExprTypeCheckPass(source, "Num(Int(Signed128))"); +} + +test "check type - num - int big" { + const source = + \\{ + \\ e : U128 + \\ e = 340282366920938463463374607431768211455 + \\ + \\ e + \\} + ; + try assertExprTypeCheckPass(source, "Num(Int(Unsigned128))"); +} + +test "check type - num - float" { + const source = + \\10.1 + ; + try assertExprTypeCheckPass(source, "Num(Frac(_size))"); +} + +test "check type - num - float suffix 1" { + const source = + \\10.1f32 + ; + try assertExprTypeCheckPass(source, "Num(Frac(Float32))"); +} + +test "check type - num - float suffix 2" { + const source = + \\10.1f64 + ; + try assertExprTypeCheckPass(source, "Num(Frac(Float64))"); +} + +test "check type - num - float suffix 3" { + const source = + \\10.1dec + ; + try assertExprTypeCheckPass(source, "Num(Frac(Decimal))"); +} + +// primitives - strs // + +test "check type - str" { + const source = + \\"hello" + ; + try assertExprTypeCheckPass(source, "Str"); +} + +// primitives - lists // + +test "check type - list empty" { + const source = + \\[] + ; + try assertExprTypeCheckPass(source, "List(_elem)"); +} + +test "check type - list - same elems 1" { + const source = + \\["hello", "world"] + ; + try assertExprTypeCheckPass(source, "List(Str)"); +} + +test "check type - list - same elems 2" { + const source = + \\[100, 200] + ; + try assertExprTypeCheckPass(source, "List(Num(_size))"); +} + +test "check type - list - 1st elem more specific coreces 2nd elem" { + const source = + \\[100u64, 200] + ; + try assertExprTypeCheckPass(source, "List(Num(Int(Unsigned64)))"); +} + +test "check type - list - 2nd elem more specific coreces 1st elem" { + const source = + \\[100, 200u32] + ; + try assertExprTypeCheckPass(source, "List(Num(Int(Unsigned32)))"); +} + +test "check type - list - diff elems 1" { + const source = + \\["hello", 10] + ; + try assertExprTypeCheckFail(source, "INCOMPATIBLE LIST ELEMENTS"); +} + +// number requirements // + +test "check type - num - cannot coerce 500 to u8" { + const source = + \\[500, 200u8] + ; + try assertExprTypeCheckFail(source, "NUMBER DOES NOT FIT IN TYPE"); +} + +// records // + +test "check type - record" { + const source = + \\{ + \\ hello: "Hello", + \\ world: 10, + \\} + ; + try assertExprTypeCheckPass(source, "{ hello: Str, world: Num(_size) }"); +} + +// tags // + +test "check type - tag" { + const source = + \\MyTag + ; + try assertExprTypeCheckPass(source, "[MyTag]_others"); +} + +test "check type - tag - args" { + const source = + \\MyTag("hello", 1) + ; + try assertExprTypeCheckPass(source, "[MyTag(Str, Num(_size))]_others"); +} + +// blocks // + +test "check type - block - return expr" { + const source = + \\{ + \\ "Hello" + \\} + ; + try assertExprTypeCheckPass(source, "Str"); +} + +test "check type - block - implicit empty record" { + const source = + \\{ + \\ _test = "hello" + \\} + ; + try assertExprTypeCheckPass(source, "{}"); +} + +test "check type - block - local value decl" { + const source = + \\{ + \\ test = "hello" + \\ + \\ test + \\} + ; + try assertExprTypeCheckPass(source, "Str"); +} + +// function // + +test "check type - def - value" { + const source = + \\module [] + \\ + \\pairU64 = "hello" + ; + try assertFileTypeCheckPass(source, "Str"); +} + +test "check type - def - func" { + const source = + \\module [] + \\ + \\id = |_| 20 + ; + try assertFileTypeCheckPass(source, "_arg -> Num(_size)"); +} + +test "check type - def - id without annotation" { + const source = + \\module [] + \\ + \\id = |x| x + ; + try assertFileTypeCheckPass(source, "a -> a"); +} + +test "check type - def - id with annotation" { + const source = + \\module [] + \\ + \\id : a -> a + \\id = |x| x + ; + try assertFileTypeCheckPass(source, "a -> a"); +} + +test "check type - def - func with annotation 1" { + const source = + \\module [] + \\ + \\id : x -> Str + \\id = |_| "test" + ; + try assertFileTypeCheckPass(source, "x -> Str"); +} + +test "check type - def - func with annotation 2" { + const source = + \\module [] + \\ + \\id : x -> Num(_size) + \\id = |_| 15 + ; + try assertFileTypeCheckPass(source, "x -> Num(_size)"); +} + +test "check type - def - nested lambda" { + const source = + \\module [] + \\ + \\id = (((|a| |b| |c| a + b + c)(100))(20))(3) + ; + try assertFileTypeCheckPass(source, "Num(_size)"); +} + +// calling functions + +test "check type - def - monomorphic id" { + const source = + \\module [] + \\ + \\idStr : Str -> Str + \\idStr = |x| x + \\ + \\test = idStr("hello") + ; + try assertFileTypeCheckPass(source, "Str"); +} + +test "check type - def - polymorphic id 1" { + const source = + \\module [] + \\ + \\id : x -> x + \\id = |x| x + \\ + \\test = id(5) + ; + try assertFileTypeCheckPass(source, "Num(_size)"); +} + +test "check type - def - polymorphic id 2" { + const source = + \\module [] + \\ + \\id : x -> x + \\id = |x| x + \\ + \\test = (id(5), id("hello")) + ; + try assertFileTypeCheckPass(source, "(Num(_size), Str)"); +} + +test "check type - def - polymorphic higher order 1" { + const source = + \\module [] + \\ + \\f = |g, v| g(v) + ; + try assertFileTypeCheckPass(source, "a -> b, a -> b"); +} + +test "check type - top level polymorphic function is generalized" { + const source = + \\module [] + \\ + \\id = |x| x + \\ + \\main = { + \\ a = id(42) + \\ _b = id("hello") + \\ a + \\} + ; + try assertFileTypeCheckPass(source, "Num(_size)"); +} + +test "check type - let-def polymorphic function is generalized" { + const source = + \\module [] + \\ + \\main = { + \\ id = |x| x + \\ a = id(42) + \\ b = id("hello") + \\ a + \\} + ; + try assertFileTypeCheckPass(source, "Num(_size)"); +} + +test "check type - polymorphic function function param should be constrained" { + const source = + \\module [] + \\ + \\id = |x| x + \\ + \\use_twice = |f| { + \\ a = f(42) + \\ b = f("hello") + \\ a + \\} + \\result = use_twice(id) + ; + try assertFileTypeCheckFail(source, "TYPE MISMATCH"); +} + +// type aliases // + +test "check type - basic alias" { + const source = + \\module [] + \\ + \\MyAlias : Str + \\ + \\x : MyAlias + \\x = "hello" + ; + try assertFileTypeCheckPass(source, "MyAlias"); +} + +test "check type - alias with arg" { + const source = + \\module [] + \\ + \\MyListAlias(a) : List(a) + \\ + \\x : MyListAlias(Num(size)) + \\x = [15] + ; + try assertFileTypeCheckPass(source, "MyListAlias(Num(size))"); +} + +test "check type - alias with mismatch arg" { + const source = + \\module [] + \\ + \\MyListAlias(a) : List(a) + \\ + \\x : MyListAlias(Str) + \\x = [15] + ; + try assertFileTypeCheckFail(source, "TYPE MISMATCH"); +} + +// nominal types // + +test "check type - basic nominal" { + const source = + \\module [] + \\ + \\MyNominal := [MyNominal] + \\ + \\x : MyNominal + \\x = MyNominal.MyNominal + ; + try assertFileTypeCheckPass(source, "MyNominal"); +} + +test "check type - nominal with tag arg" { + const source = + \\module [] + \\ + \\MyNominal := [MyNominal(Str)] + \\ + \\x : MyNominal + \\x = MyNominal.MyNominal("hello") + ; + try assertFileTypeCheckPass(source, "MyNominal"); +} + +test "check type - nominal with type and tag arg" { + const source = + \\module [] + \\ + \\MyNominal(a) := [MyNominal(a)] + \\ + \\x : MyNominal(U8) + \\x = MyNominal.MyNominal(10) + ; + try assertFileTypeCheckPass(source, "MyNominal(Num(Int(Unsigned8)))"); +} + +test "check type - nominal with with rigid vars" { + const source = + \\module [] + \\ + \\Pair(a) := [Pair(a, a)] + \\ + \\pairU64 : Pair(U64) + \\pairU64 = Pair.Pair(1, 2) + ; + try assertFileTypeCheckPass(source, "Pair(Num(Int(Unsigned64)))"); +} + +test "check type - nominal with with rigid vars mismatch" { + const source = + \\module [] + \\ + \\Pair(a) := [Pair(a, a)] + \\ + \\pairU64 : Pair(U64) + \\pairU64 = Pair.Pair(1, "Str") + ; + try assertFileTypeCheckFail(source, "INVALID NOMINAL TAG"); +} + +test "check type - nominal recursive type" { + const source = + \\module [] + \\ + \\ConsList(a) := [Nil, Cons(a, ConsList(a))] + \\ + \\x : ConsList(Str) + \\x = ConsList.Cons("hello", ConsList.Nil) + ; + try assertFileTypeCheckPass(source, "ConsList(Str)"); +} + +test "check type - nominal recursive type anno mismatch" { + const source = + \\module [] + \\ + \\ConsList(a) := [Nil, Cons(a, ConsList(a))] + \\ + \\x : ConsList(Num(size)) + \\x = ConsList.Cons("hello", ConsList.Nil) + ; + try assertFileTypeCheckFail(source, "TYPE MISMATCH"); +} + +test "check type - two nominal types" { + const source = + \\module [] + \\ + \\Elem(a) := [Elem(a)] + \\ + \\ConsList(a) := [Nil, Cons(a, ConsList(a))] + \\ + \\x = ConsList.Cons(Elem.Elem("hello"), ConsList.Nil) + ; + try assertFileTypeCheckPass(source, "ConsList(Elem(Str))"); +} + +test "check type - nominal recursive type no args" { + const source = + \\module [] + \\ + \\StrConsList := [Nil, Cons(Str, StrConsList)] + \\ + \\x : StrConsList + \\x = StrConsList.Cons("hello", StrConsList.Nil) + ; + try assertFileTypeCheckPass(source, "StrConsList"); +} + +test "check type - nominal recursive type wrong type" { + const source = + \\module [] + \\ + \\StrConsList := [Nil, Cons(Str, StrConsList)] + \\ + \\x : StrConsList + \\x = StrConsList.Cons(10, StrConsList.Nil) + ; + try assertFileTypeCheckFail(source, "INVALID NOMINAL TAG"); +} + +test "check type - nominal w/ polymorphic function with bad args" { + const source = + \\module [] + \\ + \\Pair(a) := [Pair(a, a)] + \\ + \\mkPairInvalid : a, b -> Pair(a) + \\mkPairInvalid = |x, y| Pair.Pair(x, y) + ; + try assertFileTypeCheckFail(source, "INVALID NOMINAL TAG"); +} + +test "check type - nominal w/ polymorphic function" { + const source = + \\module [] + \\ + \\Pair(a, b) : (a, b) + \\ + \\swapPair : Pair(a, b) -> Pair(b, a) + \\swapPair = |(x, y)| (y, x) + \\ + \\test = |_| swapPair((1, "test")) + ; + try assertFileTypeCheckPass(source, "_arg -> Pair(Str, Num(_size))"); +} + +// bool + +test "check type - bool unqualified" { + const source = + \\module [] + \\ + \\x = True + ; + try assertFileTypeCheckPass(source, "Bool"); +} + +test "check type - bool qualified" { + const source = + \\module [] + \\ + \\x = Bool.True + ; + try assertFileTypeCheckPass(source, "Bool"); +} + +test "check type - bool lambda" { + const source = + \\module [] + \\ + \\x = (|x| !x)(Bool.True) + ; + try assertFileTypeCheckPass(source, "Bool"); +} + +// if-else + +test "check type - if else" { + const source = + \\module [] + \\ + \\x : Str + \\x = if True "true" else "false" + ; + try assertFileTypeCheckPass(source, "Str"); +} + +test "check type - if else - qualified bool" { + const source = + \\module [] + \\ + \\x : Str + \\x = if Bool.True "true" else "false" + ; + try assertFileTypeCheckPass(source, "Str"); +} + +test "check type - if else - invalid condition 1" { + const source = + \\module [] + \\ + \\x : Str + \\x = if Truee "true" else "false" + ; + try assertFileTypeCheckFail(source, "INVALID IF CONDITION"); +} + +test "check type - if else - invalid condition 2" { + const source = + \\module [] + \\ + \\x : Str + \\x = if Bool.Falsee "true" else "false" + ; + try assertFileTypeCheckFail(source, "INVALID NOMINAL TAG"); +} + +test "check type - if else - invalid condition 3" { + const source = + \\module [] + \\ + \\x : Str + \\x = if "True" "true" else "false" + ; + try assertFileTypeCheckFail(source, "INVALID IF CONDITION"); +} + +test "check type - if else - different branch types 1" { + const source = + \\module [] + \\ + \\x = if True "true" else 10 + ; + try assertFileTypeCheckFail(source, "INCOMPATIBLE IF BRANCHES"); +} + +test "check type - if else - different branch types 2" { + const source = + \\module [] + \\ + \\x = if True "true" else if False "false" else 10 + ; + try assertFileTypeCheckFail(source, "INCOMPATIBLE IF BRANCHES"); +} + +test "check type - if else - different branch types 3" { + const source = + \\module [] + \\ + \\x = if True "true" else if False 10 else "last" + ; + try assertFileTypeCheckFail(source, "INCOMPATIBLE IF BRANCHES"); +} + +// match + +test "check type - match" { + const source = + \\module [] + \\ + \\x = + \\ match True { + \\ True => "true" + \\ False => "false" + \\ } + ; + try assertFileTypeCheckPass(source, "Str"); +} + +test "check type - match - diff cond types 1" { + const source = + \\module [] + \\ + \\x = + \\ match "hello" { + \\ True => "true" + \\ False => "false" + \\ } + ; + try assertFileTypeCheckFail(source, "INCOMPATIBLE MATCH PATTERNS"); +} + +test "check type - match - diff branch types" { + const source = + \\module [] + \\ + \\x = + \\ match True { + \\ True => "true" + \\ False => 100 + \\ } + ; + try assertFileTypeCheckFail(source, "INCOMPATIBLE MATCH BRANCHES"); +} + +// unary not + +test "check type - unary not" { + const source = + \\module [] + \\ + \\x = !True + ; + try assertFileTypeCheckPass(source, "Bool"); +} + +test "check type - unary not mismatch" { + const source = + \\module [] + \\ + \\x = !"Hello" + ; + try assertFileTypeCheckFail(source, "TYPE MISMATCH"); +} + +// unary not + +test "check type - unary minus" { + const source = + \\module [] + \\ + \\x = -10 + ; + try assertFileTypeCheckPass(source, "Num(_size)"); +} + +test "check type - unary minus mismatch" { + const source = + \\module [] + \\ + \\x = "hello" + \\ + \\y = -x + ; + try assertFileTypeCheckFail(source, "TYPE MISMATCH"); +} + +// binops + +test "check type - binops math plus" { + const source = + \\module [] + \\ + \\x = 10 + 10u32 + ; + try assertFileTypeCheckPass(source, "Num(Int(Unsigned32))"); +} + +test "check type - binops math sub" { + const source = + \\module [] + \\ + \\x = 1 - 0.2 + ; + try assertFileTypeCheckPass(source, "Num(Frac(_size))"); +} + +test "check type - binops ord" { + const source = + \\module [] + \\ + \\x = 10.0f32 > 15 + ; + try assertFileTypeCheckPass(source, "Bool"); +} + +test "check type - binops and" { + const source = + \\module [] + \\ + \\x = True and False + ; + try assertFileTypeCheckPass(source, "Bool"); +} + +test "check type - binops and mismatch" { + const source = + \\module [] + \\ + \\x = "Hello" and False + ; + try assertFileTypeCheckFail(source, "INVALID BOOL OPERATION"); +} + +test "check type - binops or" { + const source = + \\module [] + \\ + \\x = True or False + ; + try assertFileTypeCheckPass(source, "Bool"); +} + +test "check type - binops or mismatch" { + const source = + \\module [] + \\ + \\x = "Hello" or False + ; + try assertFileTypeCheckFail(source, "INVALID BOOL OPERATION"); +} + +// record access + +test "check type - record access" { + const source = + \\module [] + \\ + \\r = + \\ { + \\ hello: "Hello", + \\ world: 10, + \\ } + \\ + \\x = r.hello + ; + try assertFileTypeCheckPass(source, "Str"); +} + +test "check type - record access func polymorphic" { + const source = + \\module [] + \\ + \\x = |r| r.my_field + ; + try assertFileTypeCheckPass(source, "{ my_field: a } -> a"); +} + +test "check type - record access - not a record" { + const source = + \\module [] + \\ + \\r = "hello" + \\ + \\x = r.my_field + ; + try assertFileTypeCheckFail(source, "TYPE MISMATCH"); +} + +// tags // + +test "check type - patterns - wrong type" { + const source = + \\{ + \\ x = True + \\ + \\ match(x) { + \\ "hello" => "world", + \\ } + \\} + ; + try assertExprTypeCheckFail(source, "INCOMPATIBLE MATCH PATTERNS"); +} + +test "check type - patterns tag without payload" { + const source = + \\{ + \\ x = True + \\ + \\ match(x) { + \\ True => "true", + \\ False => "false", + \\ } + \\} + ; + try assertExprTypeCheckPass(source, "Str"); +} + +test "check type - patterns tag with payload" { + const source = + \\{ + \\ x = Ok("ok") + \\ + \\ match(x) { + \\ Ok(val) => val, + \\ Err(_) => "err", + \\ } + \\} + ; + try assertExprTypeCheckPass(source, "Str"); +} + +test "check type - patterns tag with payload mismatch" { + const source = + \\{ + \\ x = Ok("ok") + \\ + \\ match(x) { + \\ Ok(True) => 10 * 10, + \\ Err(_) => 0, + \\ } + \\} + ; + try assertExprTypeCheckFail(source, "INCOMPATIBLE MATCH PATTERNS"); +} + +test "check type - patterns str" { + const source = + \\{ + \\ x = "hello" + \\ + \\ match(x) { + \\ "world" => "true", + \\ _ => "false", + \\ } + \\} + ; + try assertExprTypeCheckPass(source, "Str"); +} + +test "check type - patterns num" { + const source = + \\{ + \\ x = 10 + \\ + \\ match(x) { + \\ 10 => "true", + \\ _ => "false", + \\ } + \\} + ; + try assertExprTypeCheckPass(source, "Str"); +} + +test "check type - patterns int mismatch" { + const source = + \\{ + \\ x = 10u8 + \\ + \\ match(x) { + \\ 10u32 => "true", + \\ _ => "false", + \\ } + \\} + ; + try assertExprTypeCheckFail(source, "INCOMPATIBLE MATCH PATTERNS"); +} + +test "check type - patterns frac 1" { + const source = + \\{ + \\ x = 10.0dec + \\ + \\ match(x) { + \\ 10 => x, + \\ _ => 15, + \\ } + \\} + ; + try assertExprTypeCheckPass(source, "Num(Frac(Decimal))"); +} + +test "check type - patterns frac 2" { + const source = + \\{ + \\ x = 10.0 + \\ + \\ match(x) { + \\ 10f32 => x, + \\ _ => 15, + \\ } + \\} + ; + try assertExprTypeCheckPass(source, "Num(Frac(Float32))"); +} + +test "check type - patterns frac 3" { + const source = + \\{ + \\ x = 10.0 + \\ + \\ match(x) { + \\ 10 => x, + \\ 15f64 => x, + \\ _ => 20, + \\ } + \\} + ; + try assertExprTypeCheckPass(source, "Num(Frac(Float64))"); +} + +test "check type - patterns list" { + const source = + \\{ + \\ x = ["a", "b", "c"] + \\ + \\ match(x) { + \\ [.. as b, a] => b, + \\ [a, .. as b] => b, + \\ [] => [], + \\ } + \\} + ; + try assertExprTypeCheckPass(source, "List(Str)"); +} + +test "check type - patterns record" { + const source = + \\{ + \\ val = { x: "hello", y: True } + \\ + \\ match(val) { + \\ { y: False } => "False", + \\ { x } => x, + \\ } + \\} + ; + try assertExprTypeCheckPass(source, "Str"); +} + +test "check type - patterns record 2" { + const source = + \\{ + \\ val = { x: "hello", y: True } + \\ + \\ match(val) { + \\ { y: False, x: "world" } => 10 + \\ _ => 20, + \\ } + \\} + ; + try assertExprTypeCheckPass(source, "Num(_size)"); +} + +test "check type - patterns record field mismatch" { + const source = + \\{ + \\ val = { x: "hello" } + \\ + \\ match(val) { + \\ { x: False } => 10 + \\ _ => 20 + \\ } + \\} + ; + try assertExprTypeCheckFail(source, "INCOMPATIBLE MATCH PATTERNS"); +} + +// vars + +test "check type - var ressignment" { + const source = + \\module [] + \\ + \\main = { + \\ var x = 1 + \\ x = x + 1 + \\ x + \\} + ; + try assertFileTypeCheckPass(source, "Num(_size)"); +} + +// expect + +test "check type - expect" { + const source = + \\module [] + \\ + \\main = { + \\ x = 1 + \\ expect x == 1 + \\ x + \\} + ; + try assertFileTypeCheckPass(source, "Num(_size)"); +} + +test "check type - expect not bool" { + const source = + \\module [] + \\ + \\main = { + \\ x = 1 + \\ expect x + \\ x + \\} + ; + try assertFileTypeCheckFail(source, "TYPE MISMATCH"); +} + +// helpers // + +/// A unified helper to run the full pipeline: parse, canonicalize, and type-check source code. +/// Asserts that type checking the expr passes +fn assertExprTypeCheckPass(comptime source_expr: []const u8, expected_type: []const u8) !void { + var test_env = try TestEnv.initExpr(source_expr); + defer test_env.deinit(); + return test_env.assertLastDefType(expected_type); +} + +/// A unified helper to run the full pipeline: parse, canonicalize, and type-check source code. +/// Asserts that type checking the expr fails with exactly one problem, and the title of the problem matches the provided one. +fn assertExprTypeCheckFail(comptime source_expr: []const u8, expected_problem_title: []const u8) !void { + var test_env = try TestEnv.initExpr(source_expr); + defer test_env.deinit(); + return test_env.assertOneTypeError(expected_problem_title); +} + +/// A unified helper to run the full pipeline: parse, canonicalize, and type-check source code. +/// Asserts that the type of the final definition in the source matches the one provided +fn assertFileTypeCheckPass(source: []const u8, expected_type: []const u8) !void { + var test_env = try TestEnv.init(source); + defer test_env.deinit(); + return test_env.assertLastDefType(expected_type); +} + +/// A unified helper to run the full pipeline: parse, canonicalize, and type-check source code. +/// Asserts that the type of the final definition in the source matches the one provided +fn assertFileTypeCheckFail(source: []const u8, expected_problem_title: []const u8) !void { + var test_env = try TestEnv.init(source); + defer test_env.deinit(); + return test_env.assertOneTypeError(expected_problem_title); +} diff --git a/src/check/test/unify_test.zig b/src/check/test/unify_test.zig new file mode 100644 index 0000000000..34f9687169 --- /dev/null +++ b/src/check/test/unify_test.zig @@ -0,0 +1,3474 @@ +//! TODO +const std = @import("std"); +const base = @import("base"); +const can = @import("can"); +const types_mod = @import("types"); + +const unify_mod = @import("../unify.zig"); +const problem_mod = @import("../problem.zig"); +const occurs = @import("../occurs.zig"); +const snapshot_mod = @import("../snapshot.zig"); + +const Region = base.Region; +const Ident = base.Ident; + +const ModuleEnv = can.ModuleEnv; + +const Scratch = unify_mod.Scratch; +const Result = unify_mod.Result; + +const Slot = types_mod.Slot; +const ResolvedVarDesc = types_mod.ResolvedVarDesc; +const ResolvedVarDescs = types_mod.ResolvedVarDescs; + +const TypeIdent = types_mod.TypeIdent; +const Var = types_mod.Var; +const Desc = types_mod.Descriptor; +const Rank = types_mod.Rank; +const Mark = types_mod.Mark; +const Flex = types_mod.Flex; +const Rigid = types_mod.Rigid; +const Content = types_mod.Content; +const Alias = types_mod.Alias; +const NominalType = types_mod.NominalType; +const FlatType = types_mod.FlatType; +const Builtin = types_mod.Builtin; +const Tuple = types_mod.Tuple; +const Num = types_mod.Num; +const NumCompact = types_mod.Num.Compact; +const Func = types_mod.Func; +const Record = types_mod.Record; +const RecordField = types_mod.RecordField; +const TwoRecordFields = types_mod.TwoRecordFields; +const TagUnion = types_mod.TagUnion; +const Tag = types_mod.Tag; +const TwoTags = types_mod.TwoTags; + +const VarSafeList = Var.SafeList; +const RecordFieldSafeMultiList = RecordField.SafeMultiList; +const RecordFieldSafeList = RecordField.SafeList; +const TwoRecordFieldsSafeMultiList = TwoRecordFields.SafeMultiList; +const TwoRecordFieldsSafeList = TwoRecordFields.SafeList; +const TagSafeList = Tag.SafeList; +const TagSafeMultiList = Tag.SafeMultiList; +const TwoTagsSafeList = TwoTags.SafeList; + +const Problem = problem_mod.Problem; + +/// A lightweight test harness used in unification and type inference tests. +/// +/// `TestEnv` bundles together the following components: +/// * a module env for holding things like idents +/// * a type store for registering and resolving types +/// * a reusable `Scratch` buffer for managing field partitions and temporary variables +/// +/// This is intended to simplify unit test setup, particularly for unifying records, +/// functions, aliases, and other structured types. +const TestEnv = struct { + const Self = @This(); + + module_env: *ModuleEnv, + snapshots: snapshot_mod.Store, + problems: problem_mod.Store, + scratch: Scratch, + occurs_scratch: occurs.Scratch, + + /// Init everything needed to test unify + /// This includes allocating module_env on the heap + /// + /// TODO: Is heap allocation unideal here? If we want to optimize tests, we + /// could pull module_env's initialization out of here, but this results in + /// slight more verbose setup for each test + fn init(gpa: std.mem.Allocator) std.mem.Allocator.Error!Self { + const module_env = try gpa.create(ModuleEnv); + module_env.* = try ModuleEnv.init(gpa, try gpa.dupe(u8, "")); + try module_env.initCIRFields(gpa, "Test"); + return .{ + .module_env = module_env, + .snapshots = try snapshot_mod.Store.initCapacity(gpa, 16), + .problems = try problem_mod.Store.initCapacity(gpa, 16), + .scratch = try Scratch.init(module_env.gpa), + .occurs_scratch = try occurs.Scratch.init(module_env.gpa), + }; + } + + /// Deinit the test env, including deallocing the module_env from the heap + fn deinit(self: *Self) void { + self.module_env.deinit(); + self.module_env.gpa.destroy(self.module_env); + self.snapshots.deinit(); + self.problems.deinit(self.module_env.gpa); + self.scratch.deinit(); + self.occurs_scratch.deinit(); + } + + /// Helper function to call unify with args from TestEnv + fn unify(self: *Self, a: Var, b: Var) std.mem.Allocator.Error!Result { + return try unify_mod.unify( + self.module_env, + &self.module_env.types, + &self.problems, + &self.snapshots, + &self.scratch, + &self.occurs_scratch, + a, + b, + ); + } + + const Error = error{ VarIsNotRoot, IsNotRecord, IsNotTagUnion }; + + /// Get a desc from a root var + fn getDescForRootVar(self: *Self, var_: Var) error{VarIsNotRoot}!Desc { + switch (self.module_env.types.getSlot(var_)) { + .root => |desc_idx| return self.module_env.types.getDesc(desc_idx), + .redirect => return error.VarIsNotRoot, + } + } + + /// Unwrap a record or throw + fn getRecordOrErr(desc: Desc) error{IsNotRecord}!Record { + return desc.content.unwrapRecord() orelse error.IsNotRecord; + } + + /// Unwrap a record or throw + fn getTagUnionOrErr(desc: Desc) error{IsNotTagUnion}!TagUnion { + return desc.content.unwrapTagUnion() orelse error.IsNotTagUnion; + } + + fn mkTypeIdent(self: *Self, name: []const u8) std.mem.Allocator.Error!TypeIdent { + const ident_idx = try self.module_env.getIdentStore().insert(self.module_env.gpa, Ident.for_text(name)); + return TypeIdent{ .ident_idx = ident_idx }; + } + + // helpers - rigid var // + + fn mkRigidVar(self: *Self, name: []const u8) std.mem.Allocator.Error!Content { + const ident_idx = try self.module_env.getIdentStore().insert(self.module_env.gpa, Ident.for_text(name)); + return Self.mkRigidVarFromIdent(ident_idx); + } + + fn mkRigidVarFromIdent(ident_idx: Ident.Idx) Content { + return .{ .rigid = Rigid.init(ident_idx) }; + } + + // helpers - alias // + + fn mkAlias(self: *Self, name: []const u8, backing_var: Var, args: []const Var) std.mem.Allocator.Error!Content { + return try self.module_env.types.mkAlias(try self.mkTypeIdent(name), backing_var, args); + } + + // helpers - nums // + + fn mkNumPoly(self: *Self, var_: Var) std.mem.Allocator.Error!Var { + return try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_poly = var_ } } }); + } + + fn mkNumPolyFlex(self: *Self) std.mem.Allocator.Error!Var { + const flex_var = try self.module_env.types.freshFromContent(.{ .flex = Flex.init() }); + return try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_poly = flex_var } } }); + } + + fn mkNumPolyRigid(self: *Self, name: []const u8) std.mem.Allocator.Error!Var { + const rigid_var = try self.module_env.types.freshFromContent(try self.mkRigidVar(name)); + return try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_poly = rigid_var } } }); + } + + // helpers - nums - ints // + + fn mkIntConcrete(self: *Self, var_: Var) std.mem.Allocator.Error!Var { + const int_var = try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .int_poly = var_ } } }); + return try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_poly = int_var } } }); + } + + fn mkIntPolyFlex(self: *Self) std.mem.Allocator.Error!Var { + const flex_var = try self.module_env.types.freshFromContent(.{ .flex = Flex.init() }); + const int_var = try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .int_poly = flex_var } } }); + return try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_poly = int_var } } }); + } + + fn mkIntPolyRigid(self: *Self, name: []const u8) std.mem.Allocator.Error!Var { + const rigid_var = try self.module_env.types.freshFromContent(try self.mkRigidVar(name)); + const int_var = try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .int_poly = rigid_var } } }); + return try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_poly = int_var } } }); + } + + fn mkIntPoly(self: *Self, prec: Num.Int.Precision) std.mem.Allocator.Error!Var { + const prec_var = try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .int_precision = prec } } }); + const int_var = try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .int_poly = prec_var } } }); + return try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_poly = int_var } } }); + } + + // helpers - nums - fracs // + + fn mkFracConcrete(self: *Self, var_: Var) std.mem.Allocator.Error!Var { + const int_var = try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .frac_poly = var_ } } }); + return try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_poly = int_var } } }); + } + + fn mkFracPolyFlex(self: *Self) std.mem.Allocator.Error!Var { + const flex_var = try self.module_env.types.freshFromContent(.{ .flex = Flex.init() }); + const frac_var = try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .frac_poly = flex_var } } }); + return try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_poly = frac_var } } }); + } + + fn mkFracPolyRigid(self: *Self, name: []const u8) std.mem.Allocator.Error!Var { + const rigid_var = try self.module_env.types.freshFromContent(try self.mkRigidVar(name)); + const frac_var = try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .frac_poly = rigid_var } } }); + return try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_poly = frac_var } } }); + } + + fn mkFracPoly(self: *Self, prec: Num.Frac.Precision) std.mem.Allocator.Error!Var { + const prec_var = try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .frac_precision = prec } } }); + const frac_var = try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .frac_poly = prec_var } } }); + return try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_poly = frac_var } } }); + } + + // helpers - structure - tuple // + + fn mkTuple(self: *Self, slice: []const Var) std.mem.Allocator.Error!Content { + const elems_range = try self.module_env.types.appendVars(slice); + return Content{ .structure = .{ .tuple = .{ .elems = elems_range } } }; + } + + // helpers - nominal type // + + fn mkNominalType(self: *Self, name: []const u8, backing_var: Var, args: []const Var) std.mem.Allocator.Error!Content { + return try self.module_env.types.mkNominal( + try self.mkTypeIdent(name), + backing_var, + args, + Ident.Idx{ .attributes = .{ .effectful = false, .ignored = false, .reassignable = false }, .idx = 0 }, + ); + } + + // helpers - structure - func // + + fn mkFuncPure(self: *Self, args: []const Var, ret: Var) std.mem.Allocator.Error!Content { + return try self.module_env.types.mkFuncPure(args, ret); + } + + fn mkFuncEffectful(self: *Self, args: []const Var, ret: Var) std.mem.Allocator.Error!Content { + return try self.module_env.types.mkFuncEffectful(args, ret); + } + + fn mkFuncUnbound(self: *Self, args: []const Var, ret: Var) std.mem.Allocator.Error!Content { + return try self.module_env.types.mkFuncUnbound(args, ret); + } + + fn mkFuncFlex(self: *Self, args: []const Var, ret: Var) std.mem.Allocator.Error!Content { + // For flex functions, we use unbound since we don't know the effectfulness yet + return try self.module_env.types.mkFuncUnbound(args, ret); + } + + // helpers - structure - records // + + fn mkRecordField(self: *Self, name: []const u8, var_: Var) std.mem.Allocator.Error!RecordField { + const ident_idx = try self.module_env.getIdentStore().insert(self.module_env.gpa, Ident.for_text(name)); + return Self.mkRecordFieldFromIdent(ident_idx, var_); + } + + fn mkRecordFieldFromIdent(ident_idx: Ident.Idx, var_: Var) RecordField { + return RecordField{ .name = ident_idx, .var_ = var_ }; + } + + const RecordInfo = struct { record: Record, content: Content }; + + fn mkRecord(self: *Self, fields: []const RecordField, ext_var: Var) std.mem.Allocator.Error!RecordInfo { + const fields_range = try self.module_env.types.appendRecordFields(fields); + const record = Record{ .fields = fields_range, .ext = ext_var }; + return .{ .content = Content{ .structure = .{ .record = record } }, .record = record }; + } + + fn mkRecordOpen(self: *Self, fields: []const RecordField) std.mem.Allocator.Error!RecordInfo { + const ext_var = try self.module_env.types.freshFromContent(.{ .flex = Flex.init() }); + return self.mkRecord(fields, ext_var); + } + + fn mkRecordClosed(self: *Self, fields: []const RecordField) std.mem.Allocator.Error!RecordInfo { + const ext_var = try self.module_env.types.freshFromContent(.{ .structure = .empty_record }); + return self.mkRecord(fields, ext_var); + } + + // helpers - structure - tag union // + + const TagUnionInfo = struct { tag_union: TagUnion, content: Content }; + + fn mkTagArgs(self: *Self, args: []const Var) std.mem.Allocator.Error!VarSafeList.Range { + return try self.module_env.types.appendVars(args); + } + + fn mkTag(self: *Self, name: []const u8, args: []const Var) std.mem.Allocator.Error!Tag { + const ident_idx = try self.module_env.getIdentStore().insert(self.module_env.gpa, Ident.for_text(name)); + return Tag{ .name = ident_idx, .args = try self.module_env.types.appendVars(args) }; + } + + fn mkTagUnion(self: *Self, tags: []const Tag, ext_var: Var) std.mem.Allocator.Error!TagUnionInfo { + const tags_range = try self.module_env.types.appendTags(tags); + const tag_union = TagUnion{ .tags = tags_range, .ext = ext_var }; + return .{ .content = Content{ .structure = .{ .tag_union = tag_union } }, .tag_union = tag_union }; + } + + fn mkTagUnionOpen(self: *Self, tags: []const Tag) std.mem.Allocator.Error!TagUnionInfo { + const ext_var = try self.module_env.types.freshFromContent(.{ .flex = Flex.init() }); + return self.mkTagUnion(tags, ext_var); + } + + fn mkTagUnionClosed(self: *Self, tags: []const Tag) std.mem.Allocator.Error!TagUnionInfo { + const ext_var = try self.module_env.types.freshFromContent(.{ .structure = .empty_tag_union }); + return self.mkTagUnion(tags, ext_var); + } +}; + +// unification - flex_vars // + +test "unify - identical" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const a = try env.module_env.types.fresh(); + const desc = try env.getDescForRootVar(a); + + const result = try env.unify(a, a); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(desc, try env.getDescForRootVar(a)); +} + +test "unify - both flex vars" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const a = try env.module_env.types.fresh(); + const b = try env.module_env.types.fresh(); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); +} + +test "unify - a is flex_var and b is not" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const a = try env.module_env.types.fresh(); + const b = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i8 } }); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); +} + +// unification - rigid // + +test "rigid_var - unifies with flex_var" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const rigid = try env.mkRigidVar("a"); + const a = try env.module_env.types.freshFromContent(.{ .flex = Flex.init() }); + const b = try env.module_env.types.freshFromContent(rigid); + + const result = try env.unify(a, b); + try std.testing.expectEqual(true, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(rigid, (try env.getDescForRootVar(b)).content); +} + +test "rigid_var - unifies with flex_var (other way)" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const rigid = try env.mkRigidVar("a"); + const a = try env.module_env.types.freshFromContent(rigid); + const b = try env.module_env.types.freshFromContent(.{ .flex = Flex.init() }); + + const result = try env.unify(a, b); + try std.testing.expectEqual(true, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(rigid, (try env.getDescForRootVar(b)).content); +} + +test "rigid_var - cannot unify with alias (fail)" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const alias = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const rigid = try env.module_env.types.freshFromContent(try env.mkRigidVar("a")); + + const result = try env.unify(alias, rigid); + try std.testing.expectEqual(false, result.isOk()); +} + +test "rigid_var - cannot unify with identical ident str (fail)" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const rigid1 = try env.module_env.types.freshFromContent(try env.mkRigidVar("a")); + const rigid2 = try env.module_env.types.freshFromContent(try env.mkRigidVar("a")); + + const result = try env.unify(rigid1, rigid2); + try std.testing.expectEqual(false, result.isOk()); +} + +// unification - aliases // + +test "unify - alias with same args" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const bool_ = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i8 } }); + + // Create alias `a` with its backing var and args in sequence + const a_backing_var = try env.module_env.types.freshFromContent(try env.mkTuple(&[_]Var{ str, bool_ })); + const a_alias = try env.mkAlias("AliasName", a_backing_var, &[_]Var{ str, bool_ }); + const a = try env.module_env.types.freshFromContent(a_alias); + + // Create alias `b` with its backing var and args in sequence + const b_backing_var = try env.module_env.types.freshFromContent(try env.mkTuple(&[_]Var{ str, bool_ })); + const b_alias = try env.mkAlias("AliasName", b_backing_var, &[_]Var{ str, bool_ }); + const b = try env.module_env.types.freshFromContent(b_alias); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(b_alias, (try env.getDescForRootVar(b)).content); +} + +test "unify - aliases with different names but same backing" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + + // Create alias `a` with its backing var and arg + const a_backing_var = try env.module_env.types.freshFromContent(try env.mkTuple(&[_]Var{str})); + const a_alias = try env.mkAlias("AliasA", a_backing_var, &[_]Var{str}); + const a = try env.module_env.types.freshFromContent(a_alias); + + // Create alias `b` with its backing var and arg + const b_backing_var = try env.module_env.types.freshFromContent(try env.mkTuple(&[_]Var{str})); + const b_alias = try env.mkAlias("AliasB", b_backing_var, &[_]Var{str}); + const b = try env.module_env.types.freshFromContent(b_alias); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(a_alias, (try env.getDescForRootVar(a)).content); + try std.testing.expectEqual(b_alias, (try env.getDescForRootVar(b)).content); +} + +test "unify - alias with different args (fail)" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const bool_ = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i8 } }); + + // Create alias `a` with its backing var and arg + const a_backing_var = try env.module_env.types.freshFromContent(try env.mkTuple(&[_]Var{ str, bool_ })); + const a_alias = try env.mkAlias("Alias", a_backing_var, &[_]Var{str}); + const a = try env.module_env.types.freshFromContent(a_alias); + + // Create alias `b` with its backing var and arg + const b_backing_var = try env.module_env.types.freshFromContent(try env.mkTuple(&[_]Var{ str, bool_ })); + const b_alias = try env.mkAlias("Alias", b_backing_var, &[_]Var{bool_}); + const b = try env.module_env.types.freshFromContent(b_alias); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); +} + +test "unify - alias with flex" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const bool_ = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i8 } }); + + const a_backing_var = try env.module_env.types.freshFromContent(try env.mkTuple(&[_]Var{ str, bool_ })); // backing var + const a_alias = try env.mkAlias("Alias", a_backing_var, &[_]Var{bool_}); + + const a = try env.module_env.types.freshFromContent(a_alias); + const b = try env.module_env.types.fresh(); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(a_alias, (try env.getDescForRootVar(b)).content); +} + +test "unify - alias with concrete" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const a_backing_var = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const a_alias = try env.mkAlias("Alias", a_backing_var, &[_]Var{}); + + const a = try env.module_env.types.freshFromContent(a_alias); + const b = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + + // Assert that the alias was preserved + const resolved = env.module_env.types.resolveVar(a); + try std.testing.expect(resolved.desc.content == .alias); + + // Assert that the alias backing var was preserved + const resolved_backing = env.module_env.types.resolveVar( + env.module_env.types.getAliasBackingVar(resolved.desc.content.alias), + ); + try std.testing.expectEqual(Content{ .structure = .str }, resolved_backing.desc.content); + + // Assert that a & b redirect to the alias + try std.testing.expectEqual(Slot{ .redirect = resolved.var_ }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(Slot{ .redirect = resolved.var_ }, env.module_env.types.getSlot(b)); +} + +test "unify - alias with concrete other way" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const b_backing_var = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const b_alias = try env.mkAlias("Alias", b_backing_var, &[_]Var{}); + + const a = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const b = try env.module_env.types.freshFromContent(b_alias); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + + // Assert that the alias was preserved + const resolved = env.module_env.types.resolveVar(a); + try std.testing.expect(resolved.desc.content == .alias); + + // Assert that the alias backing var was preserved + const resolved_backing = env.module_env.types.resolveVar( + env.module_env.types.getAliasBackingVar(resolved.desc.content.alias), + ); + try std.testing.expectEqual(Content{ .structure = .str }, resolved_backing.desc.content); + + // Assert that a & b redirect to the alias + try std.testing.expectEqual(Slot{ .redirect = resolved.var_ }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(Slot{ .redirect = resolved.var_ }, env.module_env.types.getSlot(b)); +} + +// unification - structure/flex_vars // + +test "unify - a is builtin and b is flex_var" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = Content{ .structure = .str }; + + const a = try env.module_env.types.freshFromContent(str); + const b = try env.module_env.types.fresh(); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(str, (try env.getDescForRootVar(b)).content); +} + +test "unify - a is flex_var and b is builtin" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = Content{ .structure = .str }; + + const a = try env.module_env.types.fresh(); + const b = try env.module_env.types.freshFromContent(str); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(str, (try env.getDescForRootVar(b)).content); +} + +// unification - structure/structure - builtin // + +test "unify - a & b are both str" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = Content{ .structure = .str }; + + const a = try env.module_env.types.freshFromContent(str); + const b = try env.module_env.types.freshFromContent(str); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(str, (try env.getDescForRootVar(b)).content); +} + +test "unify - a & b are diff (fail)" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = Content{ .structure = .str }; + const int = Content{ .structure = .{ .num = Num.int_i8 } }; + + const a = try env.module_env.types.freshFromContent(int); + const b = try env.module_env.types.freshFromContent(str); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); +} + +test "unify - a & b box with same arg unify" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = Content{ .structure = .str }; + const str_var = try env.module_env.types.freshFromContent(str); + + const box_str = Content{ .structure = .{ .box = str_var } }; + + const a = try env.module_env.types.freshFromContent(box_str); + const b = try env.module_env.types.freshFromContent(box_str); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(box_str, (try env.getDescForRootVar(b)).content); +} + +test "unify - a & b box with diff args (fail)" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = Content{ .structure = .str }; + const str_var = try env.module_env.types.freshFromContent(str); + + const i64_ = Content{ .structure = .{ .num = Num.int_i64 } }; + const i64_var = try env.module_env.types.freshFromContent(i64_); + + const box_str = Content{ .structure = .{ .box = str_var } }; + const box_i64 = Content{ .structure = .{ .box = i64_var } }; + + const a = try env.module_env.types.freshFromContent(box_str); + const b = try env.module_env.types.freshFromContent(box_i64); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); +} + +test "unify - a & b list with same arg unify" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = Content{ .structure = .str }; + const str_var = try env.module_env.types.freshFromContent(str); + + const list_str = Content{ .structure = .{ .list = str_var } }; + + const a = try env.module_env.types.freshFromContent(list_str); + const b = try env.module_env.types.freshFromContent(list_str); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(list_str, (try env.getDescForRootVar(b)).content); +} + +test "unify - a & b list with diff args (fail)" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = Content{ .structure = .str }; + const str_var = try env.module_env.types.freshFromContent(str); + + const u8_ = Content{ .structure = .{ .num = Num.int_u8 } }; + const u8_var = try env.module_env.types.freshFromContent(u8_); + + const list_str = Content{ .structure = .{ .list = str_var } }; + const list_u8 = Content{ .structure = .{ .list = u8_var } }; + + const a = try env.module_env.types.freshFromContent(list_str); + const b = try env.module_env.types.freshFromContent(list_u8); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); +} + +// unification - structure/structure - tuple // + +test "unify - a & b are same tuple" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = Content{ .structure = .str }; + const str_var = try env.module_env.types.freshFromContent(str); + + const bool_ = Content{ .structure = .{ .num = Num.int_i8 } }; + const bool_var = try env.module_env.types.freshFromContent(bool_); + + const tuple_str_bool = try env.mkTuple(&[_]Var{ str_var, bool_var }); + + const a = try env.module_env.types.freshFromContent(tuple_str_bool); + const b = try env.module_env.types.freshFromContent(tuple_str_bool); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(tuple_str_bool, (try env.getDescForRootVar(b)).content); +} + +test "unify - a & b are tuples with args flipped (fail)" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = Content{ .structure = .str }; + const str_var = try env.module_env.types.freshFromContent(str); + + const bool_ = Content{ .structure = .{ .num = Num.int_i8 } }; + const bool_var = try env.module_env.types.freshFromContent(bool_); + + const tuple_str_bool = try env.mkTuple(&[_]Var{ str_var, bool_var }); + const tuple_bool_str = try env.mkTuple(&[_]Var{ bool_var, str_var }); + + const a = try env.module_env.types.freshFromContent(tuple_str_bool); + const b = try env.module_env.types.freshFromContent(tuple_bool_str); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); +} + +// unification - structure/structure - compact/compact // + +test "unify - two compact ints" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const int_i32 = Content{ .structure = .{ .num = Num.int_i32 } }; + const a = try env.module_env.types.freshFromContent(int_i32); + const b = try env.module_env.types.freshFromContent(int_i32); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(int_i32, (try env.getDescForRootVar(b)).content); +} + +test "unify - two compact ints (fail)" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const a = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i32 } }); + const b = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u8 } }); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); +} + +test "unify - two compact fracs" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const frac_f32 = Content{ .structure = .{ .num = Num.frac_f32 } }; + const a = try env.module_env.types.freshFromContent(frac_f32); + const b = try env.module_env.types.freshFromContent(frac_f32); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(frac_f32, (try env.getDescForRootVar(b)).content); +} + +test "unify - two compact fracs (fail)" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const a = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.frac_f32 } }); + const b = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.frac_dec } }); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); +} + +// unification - structure/structure - poly/poly // + +test "unify - two poly ints" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const a = try env.mkIntPoly(Num.Int.Precision.u8); + const b = try env.mkIntPoly(Num.Int.Precision.u8); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); +} + +test "unify - two poly ints (fail)" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const a = try env.mkIntPoly(Num.Int.Precision.u8); + const b = try env.mkIntPoly(Num.Int.Precision.i128); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); +} + +test "unify - two poly fracs" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const a = try env.mkFracPoly(Num.Frac.Precision.f64); + const b = try env.mkFracPoly(Num.Frac.Precision.f64); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); +} + +test "unify - two poly fracs (fail)" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const a = try env.mkFracPoly(Num.Frac.Precision.f32); + const b = try env.mkFracPoly(Num.Frac.Precision.f64); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); +} + +// unification - structure/structure - poly/compact_int // + +test "unify - Num(flex) and compact int" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const int_i32 = Content{ .structure = .{ .num = Num.int_i32 } }; + const a = try env.mkNumPolyFlex(); + const b = try env.module_env.types.freshFromContent(int_i32); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(int_i32, (try env.getDescForRootVar(b)).content); +} + +test "unify - Num(Int(flex)) and compact int" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const int_i32 = Content{ .structure = .{ .num = Num.int_i32 } }; + const a = try env.mkIntPolyFlex(); + const b = try env.module_env.types.freshFromContent(int_i32); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(int_i32, (try env.getDescForRootVar(b)).content); +} + +test "unify - Num(Int(U8)) and compact int U8" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const int_u8 = Content{ .structure = .{ .num = Num.int_u8 } }; + const a = try env.mkIntPoly(Num.Int.Precision.u8); + const b = try env.module_env.types.freshFromContent(int_u8); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(int_u8, (try env.getDescForRootVar(b)).content); +} + +test "unify - Num(Int(U8)) and compact int I32 (fails)" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const int_i32 = Content{ .structure = .{ .num = Num.int_i32 } }; + const a = try env.mkIntPoly(Num.Int.Precision.u8); + const b = try env.module_env.types.freshFromContent(int_i32); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); +} + +// unification - structure/structure - poly/compact_frac // + +test "unify - Num(flex) and compact frac" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const frac_f32 = Content{ .structure = .{ .num = Num.frac_f32 } }; + const a = try env.mkNumPolyFlex(); + const b = try env.module_env.types.freshFromContent(frac_f32); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(frac_f32, (try env.getDescForRootVar(b)).content); +} + +test "unify - Num(Frac(flex)) and compact frac" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const frac_f32 = Content{ .structure = .{ .num = Num.frac_f32 } }; + const a = try env.mkFracPolyFlex(); + const b = try env.module_env.types.freshFromContent(frac_f32); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(frac_f32, (try env.getDescForRootVar(b)).content); +} + +test "unify - Num(Frac(Dec)) and compact frac Dec" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const frac_dec = Content{ .structure = .{ .num = Num.frac_dec } }; + const a = try env.mkFracPoly(Num.Frac.Precision.dec); + const b = try env.module_env.types.freshFromContent(frac_dec); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(frac_dec, (try env.getDescForRootVar(b)).content); +} + +test "unify - Num(Frac(F32)) and compact frac Dec (fails)" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const frac_f32 = Content{ .structure = .{ .num = Num.frac_f32 } }; + const a = try env.mkFracPoly(Num.Frac.Precision.dec); + const b = try env.module_env.types.freshFromContent(frac_f32); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); +} + +// unification - structure/structure - compact_int/poly // + +test "unify - compact int and Num(flex)" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const int_i32 = Content{ .structure = .{ .num = Num.int_i32 } }; + const a = try env.module_env.types.freshFromContent(int_i32); + const b = try env.mkNumPolyFlex(); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(int_i32, (try env.getDescForRootVar(b)).content); +} + +test "unify - compact int and Num(Int(flex))" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const int_i32 = Content{ .structure = .{ .num = Num.int_i32 } }; + const a = try env.module_env.types.freshFromContent(int_i32); + const b = try env.mkIntPolyFlex(); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(int_i32, (try env.getDescForRootVar(b)).content); +} + +test "unify - compact int and U8 Num(Int(U8))" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const int_u8 = Content{ .structure = .{ .num = Num.int_u8 } }; + const a = try env.module_env.types.freshFromContent(int_u8); + const b = try env.mkIntPoly(Num.Int.Precision.u8); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(int_u8, (try env.getDescForRootVar(b)).content); +} + +test "unify - compact int U8 and Num(Int(I32)) (fails)" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const int_i32 = Content{ .structure = .{ .num = Num.int_i32 } }; + const a = try env.module_env.types.freshFromContent(int_i32); + const b = try env.mkIntPoly(Num.Int.Precision.u8); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); +} + +// unification - structure/structure - compact_frac/poly // + +test "unify - compact frac and Num(flex)" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const frac_f32 = Content{ .structure = .{ .num = Num.frac_f32 } }; + const a = try env.module_env.types.freshFromContent(frac_f32); + const b = try env.mkNumPolyFlex(); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(frac_f32, (try env.getDescForRootVar(b)).content); +} + +test "unify - compact frac and Num(Frac(flex))" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const frac_f32 = Content{ .structure = .{ .num = Num.frac_f32 } }; + const a = try env.module_env.types.freshFromContent(frac_f32); + const b = try env.mkFracPolyFlex(); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(frac_f32, (try env.getDescForRootVar(b)).content); +} + +test "unify - compact frac and Dec Num(Frac(Dec))" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const frac_dec = Content{ .structure = .{ .num = Num.frac_dec } }; + const a = try env.module_env.types.freshFromContent(frac_dec); + const b = try env.mkFracPoly(Num.Frac.Precision.dec); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(frac_dec, (try env.getDescForRootVar(b)).content); +} + +test "unify - compact frac Dec and Num(Frac(F32)) (fails)" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const frac_f32 = Content{ .structure = .{ .num = Num.frac_f32 } }; + const a = try env.module_env.types.freshFromContent(frac_f32); + const b = try env.mkFracPoly(Num.Frac.Precision.dec); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); +} + +// unification - structure/structure - poly/poly rigid // + +test "unify - Num(rigid) and Num(rigid)" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const rigid = try env.module_env.types.freshFromContent(try env.mkRigidVar("b")); + const num = Content{ .structure = .{ .num = .{ .num_poly = rigid } } }; + const a = try env.module_env.types.freshFromContent(num); + const b = try env.module_env.types.freshFromContent(num); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(true, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(num, (try env.getDescForRootVar(b)).content); +} + +test "unify - Num(rigid_a) and Num(rigid_b)" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const a = try env.mkNumPolyRigid("a"); + const b = try env.mkNumPolyRigid("b"); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); +} + +test "unify - Num(Int(rigid)) and Num(Int(rigid))" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const num = try env.mkIntPolyRigid("a"); + const a = num; + const b = num; + + const result = try env.unify(a, b); + + try std.testing.expectEqual(true, result.isOk()); + try std.testing.expectEqual((try env.getDescForRootVar(num)).content, (try env.getDescForRootVar(a)).content); + try std.testing.expectEqual((try env.getDescForRootVar(num)).content, (try env.getDescForRootVar(b)).content); +} + +test "unify - Num(Int(rigid_a)) and Num(Int(rigid_b))" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const a = try env.mkIntPolyRigid("a"); + const b = try env.mkIntPolyRigid("b"); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); +} + +test "unify - Num(Frac(rigid)) and Num(Frac(rigid))" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const num = try env.mkFracPolyRigid("b"); + const a = num; + const b = num; + + const result = try env.unify(a, b); + + try std.testing.expectEqual(true, result.isOk()); + try std.testing.expectEqual((try env.getDescForRootVar(num)).content, (try env.getDescForRootVar(a)).content); + try std.testing.expectEqual((try env.getDescForRootVar(num)).content, (try env.getDescForRootVar(b)).content); +} + +test "unify - Num(Frac(rigid_a)) and Num(Frac(rigid_b))" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const a = try env.mkFracPolyRigid("a"); + const b = try env.mkFracPolyRigid("b"); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); +} + +// unification - structure/structure - compact/poly rigid // + +test "unify - compact int U8 and Num(Int(rigid)) (fails)" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const int_u8 = Content{ .structure = .{ .num = Num.int_u8 } }; + const a = try env.module_env.types.freshFromContent(int_u8); + const b = try env.mkFracPolyRigid("a"); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); +} + +test "unify - compact frac Dec and Num(Frac(rigid)) (fails)" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const frac_f32 = Content{ .structure = .{ .num = Num.frac_f32 } }; + const a = try env.module_env.types.freshFromContent(frac_f32); + const b = try env.mkFracPolyRigid("a"); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); +} + +// unification - structure/structure - poly/compact rigid // + +test "unify - Num(Int(rigid)) and compact int U8 (fails)" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const int_u8 = Content{ .structure = .{ .num = Num.int_u8 } }; + const a = try env.mkFracPolyRigid("a"); + const b = try env.module_env.types.freshFromContent(int_u8); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); +} + +test "unify - Num(Frac(rigid)) and compact frac Dec (fails)" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const frac_f32 = Content{ .structure = .{ .num = Num.frac_f32 } }; + const a = try env.mkFracPolyRigid("a"); + const b = try env.module_env.types.freshFromContent(frac_f32); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); +} + +// unification - structure/structure - func // + +test "unify - func are same" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const int_i32 = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i32 } }); + const num = try env.mkNumPolyFlex(); + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const func = try env.mkFuncFlex(&[_]Var{ str, num }, int_i32); + + const a = try env.module_env.types.freshFromContent(func); + const b = try env.module_env.types.freshFromContent(func); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(func, (try env.getDescForRootVar(b)).content); +} + +test "unify - funcs have diff return args (fail)" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const int_i32 = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i32 } }); + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + + const a = try env.module_env.types.freshFromContent(try env.mkFuncFlex(&[_]Var{int_i32}, str)); + const b = try env.module_env.types.freshFromContent(try env.mkFuncFlex(&[_]Var{str}, str)); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); +} + +test "unify - funcs have diff return types (fail)" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const int_i32 = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i32 } }); + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + + const a = try env.module_env.types.freshFromContent(try env.mkFuncFlex(&[_]Var{str}, int_i32)); + const b = try env.module_env.types.freshFromContent(try env.mkFuncFlex(&[_]Var{str}, str)); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); +} + +test "unify - same funcs pure" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const int_i32 = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i32 } }); + const int_poly = try env.mkIntPolyFlex(); + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const func = try env.mkFuncPure(&[_]Var{ str, int_poly }, int_i32); + + const a = try env.module_env.types.freshFromContent(func); + const b = try env.module_env.types.freshFromContent(func); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(func, (try env.getDescForRootVar(b)).content); +} + +test "unify - same funcs effectful" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const int_i32 = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i32 } }); + const int_poly = try env.mkIntPolyFlex(); + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const func = try env.mkFuncEffectful(&[_]Var{ str, int_poly }, int_i32); + + const a = try env.module_env.types.freshFromContent(func); + const b = try env.module_env.types.freshFromContent(func); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(func, (try env.getDescForRootVar(b)).content); +} + +test "unify - same funcs first eff, second pure (fail)" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const int_i32 = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i32 } }); + const int_poly = try env.mkIntPolyFlex(); + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const pure_func = try env.mkFuncPure(&[_]Var{ str, int_poly }, int_i32); + const eff_func = try env.mkFuncEffectful(&[_]Var{ str, int_poly }, int_i32); + + const a = try env.module_env.types.freshFromContent(eff_func); + const b = try env.module_env.types.freshFromContent(pure_func); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); +} + +test "unify - same funcs first pure, second eff (fail)" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const int_i32 = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i32 } }); + const int_poly = try env.mkIntPolyFlex(); + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const pure_func = try env.mkFuncPure(&[_]Var{ str, int_poly }, int_i32); + const eff_func = try env.mkFuncEffectful(&[_]Var{ str, int_poly }, int_i32); + + const a = try env.module_env.types.freshFromContent(pure_func); + const b = try env.module_env.types.freshFromContent(eff_func); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); +} + +test "unify - same funcs first pure, second unbound" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const int_i32 = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i32 } }); + const int_poly = try env.mkIntPolyFlex(); + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const pure_func = try env.mkFuncPure(&[_]Var{ str, int_poly }, int_i32); + const unbound_func = try env.mkFuncUnbound(&[_]Var{ str, int_poly }, int_i32); + + const a = try env.module_env.types.freshFromContent(pure_func); + const b = try env.module_env.types.freshFromContent(unbound_func); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(true, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(pure_func, (try env.getDescForRootVar(b)).content); +} + +test "unify - same funcs first unbound, second pure" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const int_i32 = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i32 } }); + const int_poly = try env.mkIntPolyFlex(); + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const pure_func = try env.mkFuncPure(&[_]Var{ str, int_poly }, int_i32); + const unbound_func = try env.mkFuncUnbound(&[_]Var{ str, int_poly }, int_i32); + + const a = try env.module_env.types.freshFromContent(unbound_func); + const b = try env.module_env.types.freshFromContent(pure_func); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(true, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(pure_func, (try env.getDescForRootVar(b)).content); +} + +test "unify - same funcs first effectful, second unbound" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const int_i32 = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i32 } }); + const int_poly = try env.mkIntPolyFlex(); + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const eff_func = try env.mkFuncEffectful(&[_]Var{ str, int_poly }, int_i32); + const unbound_func = try env.mkFuncUnbound(&[_]Var{ str, int_poly }, int_i32); + + const a = try env.module_env.types.freshFromContent(eff_func); + const b = try env.module_env.types.freshFromContent(unbound_func); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(true, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(eff_func, (try env.getDescForRootVar(b)).content); +} + +test "unify - same funcs first unbound, second effectful" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const int_i32 = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i32 } }); + const int_poly = try env.mkIntPolyFlex(); + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const eff_func = try env.mkFuncEffectful(&[_]Var{ str, int_poly }, int_i32); + const unbound_func = try env.mkFuncUnbound(&[_]Var{ str, int_poly }, int_i32); + + const a = try env.module_env.types.freshFromContent(unbound_func); + const b = try env.module_env.types.freshFromContent(eff_func); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(true, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(eff_func, (try env.getDescForRootVar(b)).content); +} + +test "unify - first is flex, second is func" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const tag_payload = try env.module_env.types.fresh(); + const tag = try env.mkTag("Some", &[_]Var{tag_payload}); + const backing_var = try env.module_env.types.freshFromContent((try env.mkTagUnionOpen(&[_]Tag{tag})).content); + const nominal_type = try env.module_env.types.freshFromContent(try env.mkNominalType("List", backing_var, &[_]Var{})); + const arg = try env.module_env.types.fresh(); + const func = try env.mkFuncUnbound(&[_]Var{arg}, nominal_type); + + const a = try env.module_env.types.fresh(); + const b = try env.module_env.types.freshFromContent(func); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(true, result.isOk()); +} + +// unification - structure/structure - nominal type // + +test "unify - a & b are both the same nominal type" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const arg = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u8 } }); + + const a_backing_var = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const a = try env.module_env.types.freshFromContent(try env.mkNominalType("MyType", a_backing_var, &[_]Var{arg})); + + const b_backing_var = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const b_nominal = try env.mkNominalType("MyType", b_backing_var, &[_]Var{arg}); + const b = try env.module_env.types.freshFromContent(b_nominal); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(b_nominal, (try env.getDescForRootVar(b)).content); +} + +test "unify - a & b are diff nominal types (fail)" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const arg = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u8 } }); + + const a_backing_var = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const a = try env.module_env.types.freshFromContent(try env.mkNominalType("MyType", a_backing_var, &[_]Var{arg})); + + const b_backing_var = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const b = try env.module_env.types.freshFromContent(try env.mkNominalType("AnotherType", b_backing_var, &[_]Var{arg})); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); +} + +test "unify - a & b are both the same nominal type with diff args (fail)" { + const gpa = std.testing.allocator; + + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const arg_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u8 } }); + const str_var = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + + const a_backing = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const a = try env.module_env.types.freshFromContent(try env.mkNominalType("MyType", a_backing, &[_]Var{arg_var})); + + const b_backing = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const b = try env.module_env.types.freshFromContent(try env.mkNominalType("MyType", b_backing, &[_]Var{str_var})); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); +} + +// unification - records - partition fields // + +test "partitionFields - same record" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const field_x = try env.mkRecordField("field_x", @enumFromInt(0)); + const field_y = try env.mkRecordField("field_y", @enumFromInt(1)); + + const range = try env.scratch.appendSliceGatheredFields(&[_]RecordField{ field_x, field_y }); + + const result = try unify_mod.partitionFields(env.module_env.getIdentStore(), &env.scratch, range, range); + + try std.testing.expectEqual(0, result.only_in_a.len()); + try std.testing.expectEqual(0, result.only_in_b.len()); + try std.testing.expectEqual(2, result.in_both.len()); + + const both_slice = env.scratch.in_both_fields.sliceRange(result.in_both); + try std.testing.expectEqual(field_x, both_slice[0].a); + try std.testing.expectEqual(field_x, both_slice[0].b); + try std.testing.expectEqual(field_y, both_slice[1].a); + try std.testing.expectEqual(field_y, both_slice[1].b); +} + +test "partitionFields - disjoint fields" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const a1 = try env.mkRecordField("a1", @enumFromInt(0)); + const a2 = try env.mkRecordField("a2", @enumFromInt(1)); + const b1 = try env.mkRecordField("b1", @enumFromInt(2)); + + const a_range = try env.scratch.appendSliceGatheredFields(&[_]RecordField{ a1, a2 }); + const b_range = try env.scratch.appendSliceGatheredFields(&[_]RecordField{b1}); + + const result = try unify_mod.partitionFields(env.module_env.getIdentStore(), &env.scratch, a_range, b_range); + + try std.testing.expectEqual(2, result.only_in_a.len()); + try std.testing.expectEqual(1, result.only_in_b.len()); + try std.testing.expectEqual(0, result.in_both.len()); + + const only_in_a_slice = env.scratch.only_in_a_fields.sliceRange(result.only_in_a); + try std.testing.expectEqual(a1, only_in_a_slice[0]); + try std.testing.expectEqual(a2, only_in_a_slice[1]); + + const only_in_b_slice = env.scratch.only_in_b_fields.sliceRange(result.only_in_b); + try std.testing.expectEqual(b1, only_in_b_slice[0]); +} + +test "partitionFields - overlapping fields" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const a1 = try env.mkRecordField("a1", @enumFromInt(0)); + const both = try env.mkRecordField("both", @enumFromInt(1)); + const b1 = try env.mkRecordField("b1", @enumFromInt(2)); + + const a_range = try env.scratch.appendSliceGatheredFields(&[_]RecordField{ a1, both }); + const b_range = try env.scratch.appendSliceGatheredFields(&[_]RecordField{ b1, both }); + + const result = try unify_mod.partitionFields(env.module_env.getIdentStore(), &env.scratch, a_range, b_range); + + try std.testing.expectEqual(1, result.only_in_a.len()); + try std.testing.expectEqual(1, result.only_in_b.len()); + try std.testing.expectEqual(1, result.in_both.len()); + + const both_slice = env.scratch.in_both_fields.sliceRange(result.in_both); + try std.testing.expectEqual(both, both_slice[0].a); + try std.testing.expectEqual(both, both_slice[0].b); + + const only_in_a_slice = env.scratch.only_in_a_fields.sliceRange(result.only_in_a); + try std.testing.expectEqual(a1, only_in_a_slice[0]); + + const only_in_b_slice = env.scratch.only_in_b_fields.sliceRange(result.only_in_b); + try std.testing.expectEqual(b1, only_in_b_slice[0]); +} + +test "partitionFields - reordering is normalized" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const f1 = try env.mkRecordField("f1", @enumFromInt(0)); + const f2 = try env.mkRecordField("f2", @enumFromInt(1)); + const f3 = try env.mkRecordField("f3", @enumFromInt(2)); + + const a_range = try env.scratch.appendSliceGatheredFields(&[_]RecordField{ f3, f1, f2 }); + const b_range = try env.scratch.appendSliceGatheredFields(&[_]RecordField{ f1, f2, f3 }); + + const result = try unify_mod.partitionFields(env.module_env.getIdentStore(), &env.scratch, a_range, b_range); + + try std.testing.expectEqual(0, result.only_in_a.len()); + try std.testing.expectEqual(0, result.only_in_b.len()); + try std.testing.expectEqual(3, result.in_both.len()); + + const both = env.scratch.in_both_fields.sliceRange(result.in_both); + try std.testing.expectEqual(f1, both[0].a); + try std.testing.expectEqual(f1, both[0].b); + try std.testing.expectEqual(f2, both[1].a); + try std.testing.expectEqual(f2, both[1].b); + try std.testing.expectEqual(f3, both[2].a); + try std.testing.expectEqual(f3, both[2].b); +} + +// unification - structure/structure - records closed // + +test "unify - identical closed records" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + + const fields = [_]RecordField{try env.mkRecordField("a", str)}; + const record_data = try env.mkRecordClosed(&fields); + const record_data_fields = env.module_env.types.record_fields.sliceRange(record_data.record.fields); + + const a = try env.module_env.types.freshFromContent(record_data.content); + const b = try env.module_env.types.freshFromContent(record_data.content); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + + const b_record = try TestEnv.getRecordOrErr(try env.getDescForRootVar(b)); + const b_record_fields = env.module_env.types.record_fields.sliceRange(b_record.fields); + try std.testing.expectEqualSlices(Ident.Idx, record_data_fields.items(.name), b_record_fields.items(.name)); + try std.testing.expectEqualSlices(Var, record_data_fields.items(.var_), b_record_fields.items(.var_)); +} + +test "unify - closed record mismatch on diff fields (fail)" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + + const field1 = try env.mkRecordField("field1", str); + const field2 = try env.mkRecordField("field2", str); + + const a_record_data = try env.mkRecordClosed(&[_]RecordField{ field1, field2 }); + const a = try env.module_env.types.freshFromContent(a_record_data.content); + + const b_record_data = try env.mkRecordClosed(&[_]RecordField{field1}); + const b = try env.module_env.types.freshFromContent(b_record_data.content); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + + const desc_b = try env.getDescForRootVar(b); + try std.testing.expectEqual(Content.err, desc_b.content); +} + +// unification - structure/structure - records open // + +test "unify - identical open records" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + + const field_shared = try env.mkRecordField("x", str); + + const a_rec_data = try env.mkRecordOpen(&[_]RecordField{field_shared}); + const a = try env.module_env.types.freshFromContent(a_rec_data.content); + const b_rec_data = try env.mkRecordOpen(&[_]RecordField{field_shared}); + const b = try env.module_env.types.freshFromContent(b_rec_data.content); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + + // check that the update var at b is correct + + const b_record = try TestEnv.getRecordOrErr(try env.getDescForRootVar(b)); + try std.testing.expectEqual(1, b_record.fields.len()); + const b_record_fields = env.module_env.types.getRecordFieldsSlice(b_record.fields); + try std.testing.expectEqual(field_shared.name, b_record_fields.items(.name)[0]); + try std.testing.expectEqual(field_shared.var_, b_record_fields.items(.var_)[0]); + + const b_ext = env.module_env.types.resolveVar(b_record.ext).desc.content; + try std.testing.expectEqual(Content{ .flex = Flex.init() }, b_ext); + + // check that fresh vars are correct + + try std.testing.expectEqual(0, env.scratch.fresh_vars.len()); +} + +test "unify - open record a extends b" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const int = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u8 } }); + + const field_shared = try env.mkRecordField("x", str); + const field_a_only = try env.mkRecordField("y", int); + + const a_rec_data = try env.mkRecordOpen(&[_]RecordField{ field_shared, field_a_only }); + const a = try env.module_env.types.freshFromContent(a_rec_data.content); + const b_rec_data = try env.mkRecordOpen(&[_]RecordField{field_shared}); + const b = try env.module_env.types.freshFromContent(b_rec_data.content); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + + // check that the update var at b is correct + + const b_record = try TestEnv.getRecordOrErr(try env.getDescForRootVar(b)); + try std.testing.expectEqual(1, b_record.fields.len()); + const b_record_fields = env.module_env.types.getRecordFieldsSlice(b_record.fields); + try std.testing.expectEqual(field_shared.name, b_record_fields.items(.name)[0]); + try std.testing.expectEqual(field_shared.var_, b_record_fields.items(.var_)[0]); + + try std.testing.expectEqual(1, env.scratch.fresh_vars.len()); + try std.testing.expectEqual(env.scratch.fresh_vars.get(@enumFromInt(0)).*, b_record.ext); + + const b_ext_record = try TestEnv.getRecordOrErr(env.module_env.types.resolveVar(b_record.ext).desc); + try std.testing.expectEqual(1, b_ext_record.fields.len()); + const b_ext_record_fields = env.module_env.types.getRecordFieldsSlice(b_ext_record.fields); + try std.testing.expectEqual(field_a_only.name, b_ext_record_fields.items(.name)[0]); + try std.testing.expectEqual(field_a_only.var_, b_ext_record_fields.items(.var_)[0]); + + const b_ext_ext = env.module_env.types.resolveVar(b_ext_record.ext).desc.content; + try std.testing.expectEqual(Content{ .flex = Flex.init() }, b_ext_ext); + + // check that fresh vars are correct + + try std.testing.expectEqual(1, env.scratch.fresh_vars.len()); + try std.testing.expectEqual(b_record.ext, env.scratch.fresh_vars.items.items[0]); +} + +test "unify - open record b extends a" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const int = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u8 } }); + + const field_shared = try env.mkRecordField("field_shared", str); + const field_b_only = try env.mkRecordField("field_b_only", int); + + const a_rec_data = try env.mkRecordOpen(&[_]RecordField{field_shared}); + const a = try env.module_env.types.freshFromContent(a_rec_data.content); + const b_rec_data = try env.mkRecordOpen(&[_]RecordField{ field_shared, field_b_only }); + const b = try env.module_env.types.freshFromContent(b_rec_data.content); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + + // check that the update var at b is correct + + const b_record = try TestEnv.getRecordOrErr(try env.getDescForRootVar(b)); + try std.testing.expectEqual(1, b_record.fields.len()); + const b_record_fields = env.module_env.types.getRecordFieldsSlice(b_record.fields); + try std.testing.expectEqual(field_shared.name, b_record_fields.items(.name)[0]); + try std.testing.expectEqual(field_shared.var_, b_record_fields.items(.var_)[0]); + + const b_ext_record = try TestEnv.getRecordOrErr(env.module_env.types.resolveVar(b_record.ext).desc); + try std.testing.expectEqual(1, b_ext_record.fields.len()); + const b_ext_record_fields = env.module_env.types.getRecordFieldsSlice(b_ext_record.fields); + try std.testing.expectEqual(field_b_only.name, b_ext_record_fields.items(.name)[0]); + try std.testing.expectEqual(field_b_only.var_, b_ext_record_fields.items(.var_)[0]); + + const b_ext_ext = env.module_env.types.resolveVar(b_ext_record.ext).desc.content; + try std.testing.expectEqual(Content{ .flex = Flex.init() }, b_ext_ext); + + // check that fresh vars are correct + + try std.testing.expectEqual(1, env.scratch.fresh_vars.len()); + try std.testing.expectEqual(b_record.ext, env.scratch.fresh_vars.items.items[0]); +} + +test "unify - both extend open record" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const int = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u8 } }); + const bool_ = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i8 } }); + + const field_shared = try env.mkRecordField("x", str); + const field_a_only = try env.mkRecordField("y", int); + const field_b_only = try env.mkRecordField("z", bool_); + + const a_rec_data = try env.mkRecordOpen(&[_]RecordField{ field_shared, field_a_only }); + const a = try env.module_env.types.freshFromContent(a_rec_data.content); + const b_rec_data = try env.mkRecordOpen(&[_]RecordField{ field_shared, field_b_only }); + const b = try env.module_env.types.freshFromContent(b_rec_data.content); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + + // check that the update var at b is correct + + const b_record = try TestEnv.getRecordOrErr(try env.getDescForRootVar(b)); + try std.testing.expectEqual(3, b_record.fields.len()); + const b_record_fields = env.module_env.types.getRecordFieldsSlice(b_record.fields); + try std.testing.expectEqual(field_shared, b_record_fields.get(0)); + try std.testing.expectEqual(field_a_only, b_record_fields.get(1)); + try std.testing.expectEqual(field_b_only, b_record_fields.get(2)); + + const b_ext = env.module_env.types.resolveVar(b_record.ext).desc.content; + try std.testing.expectEqual(Content{ .flex = Flex.init() }, b_ext); + + // check that fresh vars are correct + + try std.testing.expectEqual(3, env.scratch.fresh_vars.len()); + + const only_a_var = env.scratch.fresh_vars.get(@enumFromInt(0)).*; + const only_a_record = try TestEnv.getRecordOrErr(env.module_env.types.resolveVar(only_a_var).desc); + try std.testing.expectEqual(1, only_a_record.fields.len()); + const only_a_record_fields = env.module_env.types.getRecordFieldsSlice(only_a_record.fields); + try std.testing.expectEqual(field_a_only, only_a_record_fields.get(0)); + + const only_b_var = env.scratch.fresh_vars.get(@enumFromInt(1)).*; + const only_b_record = try TestEnv.getRecordOrErr(env.module_env.types.resolveVar(only_b_var).desc); + try std.testing.expectEqual(1, only_b_record.fields.len()); + const only_b_record_fields = env.module_env.types.getRecordFieldsSlice(only_b_record.fields); + try std.testing.expectEqual(field_b_only, only_b_record_fields.get(0)); + + const ext_var = env.scratch.fresh_vars.get(@enumFromInt(2)).*; + const ext_content = env.module_env.types.resolveVar(ext_var).desc.content; + try std.testing.expectEqual(Content{ .flex = Flex.init() }, ext_content); +} + +test "unify - record mismatch on shared field (fail)" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const int = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u8 } }); + + const field_a = try env.mkRecordField("x", str); + const field_b = try env.mkRecordField("x", int); + + const a_rec_data = try env.mkRecordOpen(&[_]RecordField{field_a}); + const a = try env.module_env.types.freshFromContent(a_rec_data.content); + + const b_rec_data = try env.mkRecordOpen(&[_]RecordField{field_b}); + const b = try env.module_env.types.freshFromContent(b_rec_data.content); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + + const desc_b = try env.getDescForRootVar(b); + try std.testing.expectEqual(Content.err, desc_b.content); +} + +// unification - structure/structure - records open+closed // + +test "unify - open record extends closed (fail)" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + + const field_x = try env.mkRecordField("field_x", str); + const field_y = try env.mkRecordField("field_y", str); + + const open = try env.module_env.types.freshFromContent((try env.mkRecordOpen(&[_]RecordField{ field_x, field_y })).content); + const closed = try env.module_env.types.freshFromContent((try env.mkRecordClosed(&[_]RecordField{field_x})).content); + + const result = try env.unify(open, closed); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = closed }, env.module_env.types.getSlot(open)); + try std.testing.expectEqual(Content.err, (try env.getDescForRootVar(closed)).content); +} + +test "unify - closed record extends open" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + + const field_x = try env.mkRecordField("field_x", str); + const field_y = try env.mkRecordField("field_y", str); + + const open = try env.module_env.types.freshFromContent((try env.mkRecordOpen(&[_]RecordField{field_x})).content); + const closed = try env.module_env.types.freshFromContent((try env.mkRecordClosed(&[_]RecordField{ field_x, field_y })).content); + + const result = try env.unify(open, closed); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = closed }, env.module_env.types.getSlot(open)); +} + +test "unify - open vs closed records with type mismatch (fail)" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const int = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u8 } }); + + const field_x_str = try env.mkRecordField("field_x_str", str); + const field_x_int = try env.mkRecordField("field_x_int", int); + + const open = try env.module_env.types.freshFromContent((try env.mkRecordOpen(&[_]RecordField{field_x_str})).content); + const closed = try env.module_env.types.freshFromContent((try env.mkRecordClosed(&[_]RecordField{field_x_int})).content); + + const result = try env.unify(open, closed); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = closed }, env.module_env.types.getSlot(open)); + + const desc = try env.getDescForRootVar(closed); + try std.testing.expectEqual(Content.err, desc.content); +} + +test "unify - closed vs open records with type mismatch (fail)" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const int = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u8 } }); + + const field_x_str = try env.mkRecordField("field_x_str", str); + const field_x_int = try env.mkRecordField("field_x_int", int); + + const closed = try env.module_env.types.freshFromContent((try env.mkRecordClosed(&[_]RecordField{field_x_int})).content); + const open = try env.module_env.types.freshFromContent((try env.mkRecordOpen(&[_]RecordField{field_x_str})).content); + + const result = try env.unify(closed, open); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = open }, env.module_env.types.getSlot(closed)); + + const desc = try env.getDescForRootVar(open); + try std.testing.expectEqual(Content.err, desc.content); +} + +// unification - tag unions - partition tags // + +test "partitionTags - same tags" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const tag_x = try env.mkTag("X", &[_]Var{@enumFromInt(0)}); + const tag_y = try env.mkTag("Y", &[_]Var{@enumFromInt(1)}); + + const range = try env.scratch.appendSliceGatheredTags(&[_]Tag{ tag_x, tag_y }); + + const result = try unify_mod.partitionTags(env.module_env.getIdentStore(), &env.scratch, range, range); + + try std.testing.expectEqual(0, result.only_in_a.len()); + try std.testing.expectEqual(0, result.only_in_b.len()); + try std.testing.expectEqual(2, result.in_both.len()); + + const both_slice = env.scratch.in_both_tags.sliceRange(result.in_both); + try std.testing.expectEqual(tag_x, both_slice[0].a); + try std.testing.expectEqual(tag_x, both_slice[0].b); + try std.testing.expectEqual(tag_y, both_slice[1].a); + try std.testing.expectEqual(tag_y, both_slice[1].b); +} + +test "partitionTags - disjoint fields" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const a1 = try env.mkTag("A1", &[_]Var{@enumFromInt(0)}); + const a2 = try env.mkTag("A2", &[_]Var{@enumFromInt(1)}); + const b1 = try env.mkTag("B1", &[_]Var{@enumFromInt(2)}); + + const a_range = try env.scratch.appendSliceGatheredTags(&[_]Tag{ a1, a2 }); + const b_range = try env.scratch.appendSliceGatheredTags(&[_]Tag{b1}); + + const result = try unify_mod.partitionTags(env.module_env.getIdentStore(), &env.scratch, a_range, b_range); + + try std.testing.expectEqual(2, result.only_in_a.len()); + try std.testing.expectEqual(1, result.only_in_b.len()); + try std.testing.expectEqual(0, result.in_both.len()); + + const only_in_a_slice = env.scratch.only_in_a_tags.sliceRange(result.only_in_a); + try std.testing.expectEqual(a1, only_in_a_slice[0]); + try std.testing.expectEqual(a2, only_in_a_slice[1]); + + const only_in_b_slice = env.scratch.only_in_b_tags.sliceRange(result.only_in_b); + try std.testing.expectEqual(b1, only_in_b_slice[0]); +} + +test "partitionTags - overlapping tags" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const a1 = try env.mkTag("A", &[_]Var{@enumFromInt(0)}); + const both = try env.mkTag("Both", &[_]Var{@enumFromInt(1)}); + const b1 = try env.mkTag("B", &[_]Var{@enumFromInt(2)}); + + const a_range = try env.scratch.appendSliceGatheredTags(&[_]Tag{ a1, both }); + const b_range = try env.scratch.appendSliceGatheredTags(&[_]Tag{ b1, both }); + + const result = try unify_mod.partitionTags(env.module_env.getIdentStore(), &env.scratch, a_range, b_range); + + try std.testing.expectEqual(1, result.only_in_a.len()); + try std.testing.expectEqual(1, result.only_in_b.len()); + try std.testing.expectEqual(1, result.in_both.len()); + + const both_slice = env.scratch.in_both_tags.sliceRange(result.in_both); + try std.testing.expectEqual(both, both_slice[0].a); + try std.testing.expectEqual(both, both_slice[0].b); + + const only_in_a_slice = env.scratch.only_in_a_tags.sliceRange(result.only_in_a); + try std.testing.expectEqual(a1, only_in_a_slice[0]); + + const only_in_b_slice = env.scratch.only_in_b_tags.sliceRange(result.only_in_b); + try std.testing.expectEqual(b1, only_in_b_slice[0]); +} + +test "partitionTags - reordering is normalized" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const f1 = try env.mkTag("F1", &[_]Var{@enumFromInt(0)}); + const f2 = try env.mkTag("F2", &[_]Var{@enumFromInt(1)}); + const f3 = try env.mkTag("F3", &[_]Var{@enumFromInt(2)}); + + const a_range = try env.scratch.appendSliceGatheredTags(&[_]Tag{ f3, f1, f2 }); + const b_range = try env.scratch.appendSliceGatheredTags(&[_]Tag{ f1, f2, f3 }); + + const result = try unify_mod.partitionTags(env.module_env.getIdentStore(), &env.scratch, a_range, b_range); + + try std.testing.expectEqual(0, result.only_in_a.len()); + try std.testing.expectEqual(0, result.only_in_b.len()); + try std.testing.expectEqual(3, result.in_both.len()); + + const both_slice = env.scratch.in_both_tags.sliceRange(result.in_both); + try std.testing.expectEqual(f1, both_slice[0].a); + try std.testing.expectEqual(f1, both_slice[0].b); + try std.testing.expectEqual(f2, both_slice[1].a); + try std.testing.expectEqual(f2, both_slice[1].b); + try std.testing.expectEqual(f3, both_slice[2].a); + try std.testing.expectEqual(f3, both_slice[2].b); +} + +// unification - structure/structure - tag unions closed // + +test "unify - identical closed tag_unions" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + + const tag = try env.mkTag("A", &[_]Var{str}); + const tags = [_]Tag{tag}; + const tag_union_data = try env.mkTagUnionClosed(&tags); + + const a = try env.module_env.types.freshFromContent(tag_union_data.content); + const b = try env.module_env.types.freshFromContent(tag_union_data.content); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + + const b_tag_union = try TestEnv.getTagUnionOrErr(try env.getDescForRootVar(b)); + const b_tags = env.module_env.types.tags.sliceRange(b_tag_union.tags); + const b_tags_names = b_tags.items(.name); + const b_tags_args = b_tags.items(.args); + try std.testing.expectEqual(1, b_tags.len); + try std.testing.expectEqual(tag.name, b_tags_names[0]); + try std.testing.expectEqual(tag.args, b_tags_args[0]); + + try std.testing.expectEqual(1, b_tags.len); + + const b_tag_args = env.module_env.types.vars.sliceRange(b_tags_args[0]); + try std.testing.expectEqual(1, b_tag_args.len); + try std.testing.expectEqual(str, b_tag_args[0]); +} + +test "unify - closed tag_unions with diff args (fail)" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const int = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u8 } }); + + const a_tag = try env.mkTag("A", &[_]Var{str}); + const a_tags = [_]Tag{a_tag}; + const a_tag_union_data = try env.mkTagUnionClosed(&a_tags); + const a = try env.module_env.types.freshFromContent(a_tag_union_data.content); + + const b_tag = try env.mkTag("A", &[_]Var{int}); + const b_tags = [_]Tag{b_tag}; + const b_tag_union_data = try env.mkTagUnionClosed(&b_tags); + const b = try env.module_env.types.freshFromContent(b_tag_union_data.content); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + + const desc = try env.getDescForRootVar(b); + try std.testing.expectEqual(Content.err, desc.content); +} + +// unification - structure/structure - tag unions open // + +test "unify - identical open tag unions" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + + const tag_shared = try env.mkTag("Shared", &[_]Var{ str, str }); + + const tag_union_a = try env.mkTagUnionOpen(&[_]Tag{tag_shared}); + const a = try env.module_env.types.freshFromContent(tag_union_a.content); + + const tag_union_b = try env.mkTagUnionOpen(&[_]Tag{tag_shared}); + const b = try env.module_env.types.freshFromContent(tag_union_b.content); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + + // check that the update var at b is correct + + const b_tag_union = try TestEnv.getTagUnionOrErr(try env.getDescForRootVar(b)); + try std.testing.expectEqual(1, b_tag_union.tags.len()); + + const b_tags = env.module_env.types.tags.sliceRange(b_tag_union.tags); + const b_tags_names = b_tags.items(.name); + const b_tags_args = b_tags.items(.args); + try std.testing.expectEqual(1, b_tags.len); + try std.testing.expectEqual(tag_shared.name, b_tags_names[0]); + try std.testing.expectEqual(tag_shared.args, b_tags_args[0]); + + const b_ext = env.module_env.types.resolveVar(b_tag_union.ext).desc.content; + try std.testing.expectEqual(Content{ .flex = Flex.init() }, b_ext); + + // check that fresh vars are correct + + try std.testing.expectEqual(0, env.scratch.fresh_vars.len()); +} + +test "unify - open tag union a extends b" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const int = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u8 } }); + + const tag_a_only = try env.mkTag("A", &[_]Var{str}); + const tag_shared = try env.mkTag("Shared", &[_]Var{ int, int }); + + const tag_union_a = try env.mkTagUnionOpen(&[_]Tag{ tag_a_only, tag_shared }); + const a = try env.module_env.types.freshFromContent(tag_union_a.content); + + const tag_union_b = try env.mkTagUnionOpen(&[_]Tag{tag_shared}); + const b = try env.module_env.types.freshFromContent(tag_union_b.content); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + + // check that the update var at b is correct + + const b_tag_union = try TestEnv.getTagUnionOrErr(try env.getDescForRootVar(b)); + try std.testing.expectEqual(1, b_tag_union.tags.len()); + + const b_tags = env.module_env.types.tags.sliceRange(b_tag_union.tags); + const b_tags_names = b_tags.items(.name); + const b_tags_args = b_tags.items(.args); + try std.testing.expectEqual(1, b_tags.len); + try std.testing.expectEqual(tag_shared.name, b_tags_names[0]); + try std.testing.expectEqual(tag_shared.args, b_tags_args[0]); + + const b_ext_tag_union = try TestEnv.getTagUnionOrErr(env.module_env.types.resolveVar(b_tag_union.ext).desc); + try std.testing.expectEqual(1, b_ext_tag_union.tags.len()); + + const b_ext_tags = env.module_env.types.tags.sliceRange(b_ext_tag_union.tags); + const b_ext_tags_names = b_ext_tags.items(.name); + const b_ext_tags_args = b_ext_tags.items(.args); + try std.testing.expectEqual(1, b_ext_tags.len); + try std.testing.expectEqual(tag_a_only.name, b_ext_tags_names[0]); + try std.testing.expectEqual(tag_a_only.args, b_ext_tags_args[0]); + + const b_ext_ext = env.module_env.types.resolveVar(b_ext_tag_union.ext).desc.content; + try std.testing.expectEqual(Content{ .flex = Flex.init() }, b_ext_ext); + + // check that fresh vars are correct + + try std.testing.expectEqual(1, env.scratch.fresh_vars.len()); + try std.testing.expectEqual(b_tag_union.ext, env.scratch.fresh_vars.items.items[0]); +} + +test "unify - open tag union b extends a" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const int = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u8 } }); + + const tag_b_only = try env.mkTag("A", &[_]Var{ str, int }); + const tag_shared = try env.mkTag("Shared", &[_]Var{int}); + + const tag_union_a = try env.mkTagUnionOpen(&[_]Tag{tag_shared}); + const a = try env.module_env.types.freshFromContent(tag_union_a.content); + + const tag_union_b = try env.mkTagUnionOpen(&[_]Tag{ tag_b_only, tag_shared }); + const b = try env.module_env.types.freshFromContent(tag_union_b.content); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + + // check that the update var at b is correct + + const b_tag_union = try TestEnv.getTagUnionOrErr(try env.getDescForRootVar(b)); + try std.testing.expectEqual(1, b_tag_union.tags.len()); + + const b_tags = env.module_env.types.tags.sliceRange(b_tag_union.tags); + const b_tags_names = b_tags.items(.name); + const b_tags_args = b_tags.items(.args); + try std.testing.expectEqual(1, b_tags.len); + try std.testing.expectEqual(tag_shared.name, b_tags_names[0]); + try std.testing.expectEqual(tag_shared.args, b_tags_args[0]); + + const b_ext_tag_union = try TestEnv.getTagUnionOrErr(env.module_env.types.resolveVar(b_tag_union.ext).desc); + try std.testing.expectEqual(1, b_ext_tag_union.tags.len()); + + const b_ext_tags = env.module_env.types.tags.sliceRange(b_ext_tag_union.tags); + const b_ext_tags_names = b_ext_tags.items(.name); + const b_ext_tags_args = b_ext_tags.items(.args); + try std.testing.expectEqual(1, b_ext_tags.len); + try std.testing.expectEqual(tag_b_only.name, b_ext_tags_names[0]); + try std.testing.expectEqual(tag_b_only.args, b_ext_tags_args[0]); + + const b_ext_ext = env.module_env.types.resolveVar(b_ext_tag_union.ext).desc.content; + try std.testing.expectEqual(Content{ .flex = Flex.init() }, b_ext_ext); + + // check that fresh vars are correct + + try std.testing.expectEqual(1, env.scratch.fresh_vars.len()); + try std.testing.expectEqual(b_tag_union.ext, env.scratch.fresh_vars.items.items[0]); +} + +test "unify - both extend open tag union" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const int = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u8 } }); + const bool_ = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i8 } }); + + const tag_a_only = try env.mkTag("A", &[_]Var{bool_}); + const tag_b_only = try env.mkTag("B", &[_]Var{ str, int }); + const tag_shared = try env.mkTag("Shared", &[_]Var{int}); + + const tag_union_a = try env.mkTagUnionOpen(&[_]Tag{ tag_a_only, tag_shared }); + const a = try env.module_env.types.freshFromContent(tag_union_a.content); + + const tag_union_b = try env.mkTagUnionOpen(&[_]Tag{ tag_b_only, tag_shared }); + const b = try env.module_env.types.freshFromContent(tag_union_b.content); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + + // check that the update var at b is correct + + const b_tag_union = try TestEnv.getTagUnionOrErr(try env.getDescForRootVar(b)); + try std.testing.expectEqual(3, b_tag_union.tags.len()); + + const b_tags = env.module_env.types.tags.sliceRange(b_tag_union.tags); + try std.testing.expectEqual(3, b_tags.len); + try std.testing.expectEqual(tag_shared, b_tags.get(0)); + try std.testing.expectEqual(tag_a_only, b_tags.get(1)); + try std.testing.expectEqual(tag_b_only, b_tags.get(2)); + + const b_ext = env.module_env.types.resolveVar(b_tag_union.ext).desc.content; + try std.testing.expectEqual(Content{ .flex = Flex.init() }, b_ext); + + // check that fresh vars are correct + + try std.testing.expectEqual(3, env.scratch.fresh_vars.len()); + + const only_a_var = env.scratch.fresh_vars.get(@enumFromInt(0)).*; + const only_a_tag_union = try TestEnv.getTagUnionOrErr(env.module_env.types.resolveVar(only_a_var).desc); + try std.testing.expectEqual(1, only_a_tag_union.tags.len()); + const only_a_tags = env.module_env.types.getTagsSlice(only_a_tag_union.tags); + try std.testing.expectEqual(tag_a_only, only_a_tags.get(0)); + + const only_b_var = env.scratch.fresh_vars.get(@enumFromInt(1)).*; + const only_b_tag_union = try TestEnv.getTagUnionOrErr(env.module_env.types.resolveVar(only_b_var).desc); + try std.testing.expectEqual(1, only_b_tag_union.tags.len()); + const only_b_tags = env.module_env.types.getTagsSlice(only_b_tag_union.tags); + try std.testing.expectEqual(tag_b_only, only_b_tags.get(0)); + + const ext_var = env.scratch.fresh_vars.get(@enumFromInt(2)).*; + const ext_content = env.module_env.types.resolveVar(ext_var).desc.content; + try std.testing.expectEqual(Content{ .flex = Flex.init() }, ext_content); +} + +test "unify - open tag unions a & b have same tag name with diff args (fail)" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const int = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u8 } }); + + const tag_a_only = try env.mkTag("A", &[_]Var{str}); + const tag_shared = try env.mkTag("A", &[_]Var{ int, int }); + + const tag_union_a = try env.mkTagUnionOpen(&[_]Tag{ tag_a_only, tag_shared }); + const a = try env.module_env.types.freshFromContent(tag_union_a.content); + + const tag_union_b = try env.mkTagUnionOpen(&[_]Tag{tag_shared}); + const b = try env.module_env.types.freshFromContent(tag_union_b.content); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + + const desc = try env.getDescForRootVar(b); + try std.testing.expectEqual(Content.err, desc.content); +} + +// unification - structure/structure - records open+closed // + +test "unify - open tag extends closed (fail)" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + + const tag_shared = try env.mkTag("Shared", &[_]Var{str}); + const tag_a_only = try env.mkTag("A", &[_]Var{str}); + + const a = try env.module_env.types.freshFromContent((try env.mkTagUnionOpen(&[_]Tag{ tag_shared, tag_a_only })).content); + const b = try env.module_env.types.freshFromContent((try env.mkTagUnionClosed(&[_]Tag{tag_shared})).content); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + try std.testing.expectEqual(Content.err, (try env.getDescForRootVar(b)).content); +} + +test "unify - closed tag union extends open" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + + const tag_shared = try env.mkTag("Shared", &[_]Var{str}); + const tag_b_only = try env.mkTag("B", &[_]Var{str}); + + const a = try env.module_env.types.freshFromContent((try env.mkTagUnionOpen(&[_]Tag{tag_shared})).content); + const b = try env.module_env.types.freshFromContent((try env.mkTagUnionClosed(&[_]Tag{ tag_shared, tag_b_only })).content); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(.ok, result); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + + // check that the update var at b is correct + + const b_tag_union = try TestEnv.getTagUnionOrErr(try env.getDescForRootVar(b)); + try std.testing.expectEqual(1, b_tag_union.tags.len()); + + const b_tags = env.module_env.types.tags.sliceRange(b_tag_union.tags); + const b_tags_names = b_tags.items(.name); + const b_tags_args = b_tags.items(.args); + try std.testing.expectEqual(1, b_tags.len); + try std.testing.expectEqual(tag_shared.name, b_tags_names[0]); + try std.testing.expectEqual(tag_shared.args, b_tags_args[0]); + + const b_ext_tag_union = try TestEnv.getTagUnionOrErr(env.module_env.types.resolveVar(b_tag_union.ext).desc); + try std.testing.expectEqual(1, b_ext_tag_union.tags.len()); + + const b_ext_tags = env.module_env.types.tags.sliceRange(b_ext_tag_union.tags); + const b_ext_tags_names = b_ext_tags.items(.name); + const b_ext_tags_args = b_ext_tags.items(.args); + try std.testing.expectEqual(1, b_ext_tags.len); + try std.testing.expectEqual(tag_b_only.name, b_ext_tags_names[0]); + try std.testing.expectEqual(tag_b_only.args, b_ext_tags_args[0]); + + const b_ext_ext = env.module_env.types.resolveVar(b_ext_tag_union.ext).desc.content; + try std.testing.expectEqual(Content{ .structure = .empty_tag_union }, b_ext_ext); + + // check that fresh vars are correct + + try std.testing.expectEqual(1, env.scratch.fresh_vars.len()); + try std.testing.expectEqual(b_tag_union.ext, env.scratch.fresh_vars.items.items[0]); +} + +test "unify - open vs closed tag union with type mismatch (fail)" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const bool_ = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i8 } }); + + const tag_a = try env.mkTag("A", &[_]Var{str}); + const tag_b = try env.mkTag("A", &[_]Var{bool_}); + + const a = try env.module_env.types.freshFromContent((try env.mkTagUnionOpen(&[_]Tag{tag_a})).content); + const b = try env.module_env.types.freshFromContent((try env.mkTagUnionClosed(&[_]Tag{tag_b})).content); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + + const desc = try env.getDescForRootVar(b); + try std.testing.expectEqual(Content.err, desc.content); +} + +test "unify - closed vs open tag union with type mismatch (fail)" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + const bool_ = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i8 } }); + + const tag_a = try env.mkTag("A", &[_]Var{str}); + const tag_b = try env.mkTag("B", &[_]Var{bool_}); + + const a = try env.module_env.types.freshFromContent((try env.mkTagUnionClosed(&[_]Tag{tag_a})).content); + const b = try env.module_env.types.freshFromContent((try env.mkTagUnionOpen(&[_]Tag{tag_b})).content); + + const result = try env.unify(a, b); + + try std.testing.expectEqual(false, result.isOk()); + try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); + + const desc = try env.getDescForRootVar(b); + try std.testing.expectEqual(Content.err, desc.content); +} + +// unification - recursion // + +test "unify - fails on infinite type" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const str_var = try env.module_env.types.freshFromContent(Content{ .structure = .str }); + + const a = try env.module_env.types.fresh(); + const a_elems_range = try env.module_env.types.appendVars(&[_]Var{ a, str_var }); + const a_tuple = types_mod.Tuple{ .elems = a_elems_range }; + try env.module_env.types.setRootVarContent(a, Content{ .structure = .{ .tuple = a_tuple } }); + + const b = try env.module_env.types.fresh(); + const b_elems_range = try env.module_env.types.appendVars(&[_]Var{ b, str_var }); + const b_tuple = types_mod.Tuple{ .elems = b_elems_range }; + try env.module_env.types.setRootVarContent(b, Content{ .structure = .{ .tuple = b_tuple } }); + + const result = try env.unify(a, b); + + switch (result) { + .ok => try std.testing.expect(false), + .problem => |problem_idx| { + const problem = env.problems.get(problem_idx); + try std.testing.expectEqual(.infinite_recursion, @as(Problem.Tag, problem)); + }, + } +} + +test "unify - fails on anonymous recursion" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const list_var_a = try env.module_env.types.fresh(); + const list_content_a = Content{ + .structure = .{ .list = list_var_a }, + }; + try env.module_env.types.setRootVarContent(list_var_a, list_content_a); + + const list_var_b = try env.module_env.types.fresh(); + const list_content_b = Content{ + .structure = .{ .list = list_var_b }, + }; + try env.module_env.types.setRootVarContent(list_var_b, list_content_b); + + const result = try env.unify(list_var_a, list_var_b); + + switch (result) { + .ok => try std.testing.expect(false), + .problem => |problem_idx| { + const problem = env.problems.get(problem_idx); + try std.testing.expectEqual(.anonymous_recursion, @as(Problem.Tag, problem)); + }, + } +} + +test "unify - succeeds on nominal, tag union recursion" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + var types_store = &env.module_env.types; + + // Create vars in the required order for adjacency to work out + const a = try types_store.fresh(); + const b = try types_store.fresh(); + const elem = try types_store.fresh(); + const ext = try types_store.fresh(); + + // Create the tag union content that references type_a_nominal + const a_cons_tag = try env.mkTag("Cons", &[_]Var{ elem, a }); + const a_nil_tag = try env.mkTag("Nil", &[_]Var{}); + const a_backing = try types_store.freshFromContent(try types_store.mkTagUnion(&.{ a_cons_tag, a_nil_tag }, ext)); + try types_store.setVarContent(a, try env.mkNominalType("TypeA", a_backing, &.{})); + + const b_cons_tag = try env.mkTag("Cons", &[_]Var{ elem, b }); + const b_nil_tag = try env.mkTag("Nil", &[_]Var{}); + const b_backing = try types_store.freshFromContent(try types_store.mkTagUnion(&.{ b_cons_tag, b_nil_tag }, ext)); + try types_store.setVarContent(b, try env.mkNominalType("TypeA", b_backing, &.{})); + + const result_nominal_type = try env.unify(a, b); + try std.testing.expectEqual(.ok, result_nominal_type); + + const result_tag_union = try env.unify(a_backing, b_backing); + try std.testing.expectEqual(.ok, result_tag_union); +} + +// numbers // +// +// Numbers are fairly complicated in roc. We have: +// * Polymorphic nums +// * Compacted nums +// * Unbounded nums +// +// Most type systems only have polymorphic numbers, but we have concepts of +// * Comapcted nums, which are fully concrete numbers +// * Unbound nums, which are polymorphic flex var numbers +// +// To the user though, they just see regular numbers like U8 or I64. +// +// Each of these have to be able to unify with each other. So we have +// sophisticated test infra to test various combinations of these. + +/// Specification for an unbound number type (literal) +const NumTypeUnbound = union(enum) { + /// Just int requirements (will be wrapped in Num(Int(_))) + int: Num.IntRequirements, + /// Just frac requirements (will be wrapped in Num(Frac(_))) + frac: Num.FracRequirements, + /// Both int and frac requirements (Num(_)) + num: Num.NumRequirements, + + /// Helper constructors + pub fn intLiteral(value: u128, is_negative: bool) NumTypeUnbound { + return .{ + .int = Num.IntRequirements.fromIntLiteral(value, is_negative), + }; + } + + pub fn fracLiteral(fits_f32: bool, fits_dec: bool) NumTypeUnbound { + return .{ .frac = .{ .fits_in_f32 = fits_f32, .fits_in_dec = fits_dec } }; + } + + pub fn numLiteral(int_value: u128, is_negative: bool, fits_f32: bool, fits_dec: bool) NumTypeUnbound { + return .{ .num = .{ + .int_requirements = Num.IntRequirements.fromIntLiteral(int_value, is_negative), + .frac_requirements = .{ .fits_in_f32 = fits_f32, .fits_in_dec = fits_dec }, + } }; + } +}; + +/// Specification for a concrete/polymorphic number type +const NumTypeBound = enum { + // Concrete integer types (these are Num(Int(U8)), etc.) + u8, + i8, + u16, + i16, + u32, + i32, + u64, + i64, + u128, + i128, + + // Concrete float types (these are Num(Frac(Dec)), etc.) + f32, + f64, + dec, + + // Polymorphic types + num_poly_flex, // Num(flex_var) + int_poly_flex, // Num(Int(flex_var)) + frac_poly_flex, // Num(Frac(flex_var)) +}; + +const NumTestCase = struct { + env: *TestEnv, + a_spec: NumSpec, + b_spec: NumSpec, + + const Self = @This(); + + const NumSpec = union(enum) { + unbound: NumTypeUnbound, + bound: NumTypeBound, + }; + + /// Initialize with an unbound literal and a bound type + fn init(env: *TestEnv, unbound: NumTypeUnbound, bound: NumTypeBound) !Self { + return .{ + .env = env, + .a_spec = .{ .unbound = unbound }, + .b_spec = .{ .bound = bound }, + }; + } + + /// Initialize with two bound types (for polymorphic × polymorphic tests) + fn initBothBound(env: *TestEnv, a: NumTypeBound, b: NumTypeBound) !Self { + return .{ + .env = env, + .a_spec = .{ .bound = a }, + .b_spec = .{ .bound = b }, + }; + } + + /// Initialize with two unbound types (for requirement merging tests) + fn initBothUnbound(env: *TestEnv, a: NumTypeUnbound, b: NumTypeUnbound) !Self { + return .{ + .env = env, + .a_spec = .{ .unbound = a }, + .b_spec = .{ .unbound = b }, + }; + } + + /// Create fresh variables from the specs + fn makeVars(self: Self) !struct { a: Var, b: Var } { + const a = switch (self.a_spec) { + .unbound => |spec| try makeUnboundVar(self.env, spec), + .bound => |spec| try makeBoundVar(self.env, spec), + }; + const b = switch (self.b_spec) { + .unbound => |spec| try makeUnboundVar(self.env, spec), + .bound => |spec| try makeBoundVar(self.env, spec), + }; + return .{ .a = a, .b = b }; + } + + fn expectOk(self: Self) !void { + const vars = try self.makeVars(); + const result = try self.env.unify(vars.a, vars.b); + try std.testing.expect(result == .ok); + } + + fn expectProblem(self: Self) !void { + const vars = try self.makeVars(); + const result = try self.env.unify(vars.a, vars.b); + try std.testing.expect(result == .problem); + } + + fn expectBothOrders(self: Self, comptime expectFn: fn (Self) anyerror!void) !void { + // Test a → b + try expectFn(self); + + // Test b → a (swap the specs, not the vars) + const swapped = Self{ + .env = self.env, + .a_spec = self.b_spec, + .b_spec = self.a_spec, + }; + try expectFn(swapped); + } + + /// For tests that need to inspect the unified result + fn unifyAndGetResult(self: Self) !struct { result: unify_mod.Result, a: Var, b: Var } { + const vars = try self.makeVars(); + const result = try self.env.unify(vars.a, vars.b); + return .{ .result = result, .a = vars.a, .b = vars.b }; + } + + fn makeUnboundVar(env: *TestEnv, spec: NumTypeUnbound) !Var { + return switch (spec) { + // int_unbound needs to be wrapped: Num(Int(unbound)) + .int => |reqs| blk: { + const int_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .int_unbound = reqs } } }); + break :blk try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_poly = int_var } } }); + }, + // frac_unbound needs to be wrapped: Num(Frac(unbound)) + .frac => |reqs| blk: { + const frac_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .frac_unbound = reqs } } }); + break :blk try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_poly = frac_var } } }); + }, + // num_unbound is already at the top level: Num(unbound) + .num => |reqs| try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_unbound = reqs } } }), + }; + } + + fn makeBoundVar(env: *TestEnv, spec: NumTypeBound) !Var { + return switch (spec) { + // These are already num_compact which is the full Num(Int(U8)) structure + .u8 => try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u8 } }), + .i8 => try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i8 } }), + .u16 => try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u16 } }), + .i16 => try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i16 } }), + .u32 => try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u32 } }), + .i32 => try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i32 } }), + .u64 => try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u64 } }), + .i64 => try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i64 } }), + .u128 => try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u128 } }), + .i128 => try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i128 } }), + + // These use mkFracPoly which builds: Num(Frac(precision)) + .f32 => try env.mkFracPoly(Num.Frac.Precision.f32), + .f64 => try env.mkFracPoly(Num.Frac.Precision.f64), + .dec => try env.mkFracPoly(Num.Frac.Precision.dec), + + // These are already properly wrapped by the mk functions + .num_poly_flex => try env.mkNumPolyFlex(), // Num(flex_var) + .int_poly_flex => try env.mkIntPolyFlex(), // Num(Int(flex_var)) + .frac_poly_flex => try env.mkFracPolyFlex(), // Num(Frac(flex_var)) + }; + } +}; + +// num basic test cases // + +test "unify - 255 fits in U8" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const case = try NumTestCase.init(&env, NumTypeUnbound.intLiteral(255, false), .u8); + try case.expectBothOrders(NumTestCase.expectOk); +} + +test "unify - 256 does not fit in U8" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const case = try NumTestCase.init(&env, NumTypeUnbound.intLiteral(256, false), .u8); + try case.expectBothOrders(NumTestCase.expectProblem); +} + +test "unify - 127 fits in I8" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const case = try NumTestCase.init(&env, NumTypeUnbound.intLiteral(127, false), .i8); + try case.expectBothOrders(NumTestCase.expectOk); +} + +test "unify - 128 does not fit in I8" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const case = try NumTestCase.init(&env, NumTypeUnbound.intLiteral(128, false), .i8); + try case.expectBothOrders(NumTestCase.expectProblem); +} + +test "unify - -128 fits in I8" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const case = try NumTestCase.init(&env, NumTypeUnbound.intLiteral(128, true), .i8); + try case.expectBothOrders(NumTestCase.expectOk); +} + +test "unify - -129 does not fit in I8" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const case = try NumTestCase.init(&env, NumTypeUnbound.intLiteral(129, true), .i8); + try case.expectBothOrders(NumTestCase.expectProblem); +} + +test "unify - two unbound nums merge requirements" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const case = try NumTestCase.initBothUnbound( + &env, + NumTypeUnbound.numLiteral(256, false, true, false), + NumTypeUnbound.numLiteral(100, true, false, true), + ); + + const unified = try case.unifyAndGetResult(); + try std.testing.expect(unified.result == .ok); + + // Verify merged requirements on the unified type + const resolved = env.module_env.types.resolveVar(unified.a).desc.content.structure.num.num_unbound; + try std.testing.expectEqual(true, resolved.int_requirements.sign_needed); + try std.testing.expectEqual((Num.Int.BitsNeeded.@"9_to_15").toBits(), resolved.int_requirements.bits_needed); + try std.testing.expectEqual(false, resolved.frac_requirements.fits_in_f32); + try std.testing.expectEqual(false, resolved.frac_requirements.fits_in_dec); +} + +test "unify - int_poly_flex unifies with num_unbound" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const case = try NumTestCase.initBothBound(&env, .int_poly_flex, .num_poly_flex); + try case.expectBothOrders(NumTestCase.expectOk); +} + +test "unify - literal vs concrete - exhaustive boundary tests" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const TestCase = struct { + value: u128, + is_negative: bool, + target: NumTypeBound, + should_succeed: bool, + }; + + const cases = [_]TestCase{ + // U8 boundaries (0-255) + .{ .value = 0, .is_negative = false, .target = .u8, .should_succeed = true }, + .{ .value = 127, .is_negative = false, .target = .u8, .should_succeed = true }, + .{ .value = 255, .is_negative = false, .target = .u8, .should_succeed = true }, + .{ .value = 256, .is_negative = false, .target = .u8, .should_succeed = false }, + .{ .value = 1, .is_negative = true, .target = .u8, .should_succeed = false }, + + // I8 boundaries (-128 to 127) + .{ .value = 0, .is_negative = false, .target = .i8, .should_succeed = true }, + .{ .value = 127, .is_negative = false, .target = .i8, .should_succeed = true }, + .{ .value = 128, .is_negative = false, .target = .i8, .should_succeed = false }, + .{ .value = 1, .is_negative = true, .target = .i8, .should_succeed = true }, + .{ .value = 128, .is_negative = true, .target = .i8, .should_succeed = true }, // -128 + .{ .value = 129, .is_negative = true, .target = .i8, .should_succeed = false }, + + // U16 boundaries (0-65535) + .{ .value = 255, .is_negative = false, .target = .u16, .should_succeed = true }, + .{ .value = 256, .is_negative = false, .target = .u16, .should_succeed = true }, + .{ .value = 65535, .is_negative = false, .target = .u16, .should_succeed = true }, + .{ .value = 65536, .is_negative = false, .target = .u16, .should_succeed = false }, + .{ .value = 1, .is_negative = true, .target = .u16, .should_succeed = false }, + + // I16 boundaries (-32768 to 32767) + .{ .value = 32767, .is_negative = false, .target = .i16, .should_succeed = true }, + .{ .value = 32768, .is_negative = false, .target = .i16, .should_succeed = false }, + .{ .value = 32768, .is_negative = true, .target = .i16, .should_succeed = true }, // -32768 + .{ .value = 32769, .is_negative = true, .target = .i16, .should_succeed = false }, + + // U32 boundaries + .{ .value = 65535, .is_negative = false, .target = .u32, .should_succeed = true }, + .{ .value = 65536, .is_negative = false, .target = .u32, .should_succeed = true }, + .{ .value = 4294967295, .is_negative = false, .target = .u32, .should_succeed = true }, + .{ .value = 4294967296, .is_negative = false, .target = .u32, .should_succeed = false }, + + // I32 boundaries (-2147483648 to 2147483647) + .{ .value = 2147483647, .is_negative = false, .target = .i32, .should_succeed = true }, + .{ .value = 2147483648, .is_negative = false, .target = .i32, .should_succeed = false }, + .{ .value = 2147483648, .is_negative = true, .target = .i32, .should_succeed = true }, + .{ .value = 2147483649, .is_negative = true, .target = .i32, .should_succeed = false }, + + // U64 boundaries + .{ .value = 4294967295, .is_negative = false, .target = .u64, .should_succeed = true }, + .{ .value = 18446744073709551615, .is_negative = false, .target = .u64, .should_succeed = true }, + + // I64 boundaries + .{ .value = 9223372036854775807, .is_negative = false, .target = .i64, .should_succeed = true }, + .{ .value = 9223372036854775808, .is_negative = false, .target = .i64, .should_succeed = false }, + .{ .value = 9223372036854775808, .is_negative = true, .target = .i64, .should_succeed = true }, + + // U128 - always succeeds for positive + .{ .value = 18446744073709551615, .is_negative = false, .target = .u128, .should_succeed = true }, + .{ .value = 1, .is_negative = true, .target = .u128, .should_succeed = false }, + + // I128 - succeeds for all values we can represent + .{ .value = 18446744073709551615, .is_negative = false, .target = .i128, .should_succeed = true }, + .{ .value = 18446744073709551615, .is_negative = true, .target = .i128, .should_succeed = true }, + }; + + for (cases) |tc| { + const case = try NumTestCase.init(&env, NumTypeUnbound.intLiteral(tc.value, tc.is_negative), tc.target); + + if (tc.should_succeed) { + try case.expectBothOrders(NumTestCase.expectOk); + } else { + try case.expectBothOrders(NumTestCase.expectProblem); + } + } +} + +test "unify - frac literal vs concrete - boundary tests" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const TestCase = struct { + fits_f32: bool, + fits_dec: bool, + target: NumTypeBound, + should_succeed: bool, + }; + + const cases = [_]TestCase{ + // Fits in both + .{ .fits_f32 = true, .fits_dec = true, .target = .f32, .should_succeed = true }, + .{ .fits_f32 = true, .fits_dec = true, .target = .f64, .should_succeed = true }, + .{ .fits_f32 = true, .fits_dec = true, .target = .dec, .should_succeed = true }, + + // Only fits in f32 (and therefore f64) + .{ .fits_f32 = true, .fits_dec = false, .target = .f32, .should_succeed = true }, + .{ .fits_f32 = true, .fits_dec = false, .target = .f64, .should_succeed = true }, + .{ .fits_f32 = true, .fits_dec = false, .target = .dec, .should_succeed = false }, + + // Only fits in dec + .{ .fits_f32 = false, .fits_dec = true, .target = .f32, .should_succeed = false }, + .{ .fits_f32 = false, .fits_dec = true, .target = .f64, .should_succeed = true }, + .{ .fits_f32 = false, .fits_dec = true, .target = .dec, .should_succeed = true }, + + // Only fits in f64 + .{ .fits_f32 = false, .fits_dec = false, .target = .f32, .should_succeed = false }, + .{ .fits_f32 = false, .fits_dec = false, .target = .f64, .should_succeed = true }, + .{ .fits_f32 = false, .fits_dec = false, .target = .dec, .should_succeed = false }, + }; + + for (cases) |tc| { + const case = try NumTestCase.init(&env, NumTypeUnbound.fracLiteral(tc.fits_f32, tc.fits_dec), tc.target); + + if (tc.should_succeed) { + try case.expectBothOrders(NumTestCase.expectOk); + } else { + try case.expectBothOrders(NumTestCase.expectProblem); + } + } +} + +test "unify - unbound vs polymorphic - full matrix" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const UnboundKind = enum { int, frac, num }; + const PolyKind = enum { int_poly_flex, frac_poly_flex, num_poly_flex }; + + // Matrix: should unbound × poly unify? + const ShouldUnify = enum { yes, no }; + const should_unify = std.EnumArray(UnboundKind, std.EnumArray(PolyKind, ShouldUnify)).init(.{ + .int = std.EnumArray(PolyKind, ShouldUnify).init(.{ + .int_poly_flex = .yes, // Num(Int(a)) × Num(Int(b)) → yes + .frac_poly_flex = .no, // Num(Int(a)) × Num(Frac(b)) → NO! + .num_poly_flex = .yes, // Num(Int(a)) × Num(b) → yes + }), + .frac = std.EnumArray(PolyKind, ShouldUnify).init(.{ + .int_poly_flex = .no, // Num(Frac(a)) × Num(Int(b)) → NO! + .frac_poly_flex = .yes, // Num(Frac(a)) × Num(Frac(b)) → yes + .num_poly_flex = .yes, // Num(Frac(a)) × Num(b) → yes + }), + .num = std.EnumArray(PolyKind, ShouldUnify).init(.{ + .int_poly_flex = .yes, // Num(a) × Num(Int(b)) → yes + .frac_poly_flex = .yes, // Num(a) × Num(Frac(b)) → yes + .num_poly_flex = .yes, // Num(a) × Num(b) → yes + }), + }); + + const unbound_specs = std.EnumArray(UnboundKind, NumTypeUnbound).init(.{ + .int = NumTypeUnbound.intLiteral(100, false), + .frac = NumTypeUnbound.fracLiteral(true, true), + .num = NumTypeUnbound.numLiteral(100, false, true, true), + }); + + const poly_specs = std.EnumArray(PolyKind, NumTypeBound).init(.{ + .int_poly_flex = .int_poly_flex, + .frac_poly_flex = .frac_poly_flex, + .num_poly_flex = .num_poly_flex, + }); + + inline for (std.meta.fields(UnboundKind)) |unbound_field| { + inline for (std.meta.fields(PolyKind)) |poly_field| { + const unbound_kind = @field(UnboundKind, unbound_field.name); + const poly_kind = @field(PolyKind, poly_field.name); + + const case = try NumTestCase.init(&env, unbound_specs.get(unbound_kind), poly_specs.get(poly_kind)); + + const expected = should_unify.get(unbound_kind).get(poly_kind); + + // Add context on failure + if (expected == .yes) { + case.expectBothOrders(NumTestCase.expectOk) catch |err| { + std.debug.print("FAILED: {s} × {s} (expected to unify)\n", .{ @tagName(unbound_kind), @tagName(poly_kind) }); + return err; + }; + } else { + case.expectBothOrders(NumTestCase.expectProblem) catch |err| { + std.debug.print("FAILED: {s} × {s} (expected NOT to unify)\n", .{ @tagName(unbound_kind), @tagName(poly_kind) }); + return err; + }; + } + } + } +} + +test "unify - polymorphic vs polymorphic - full matrix" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const PolyKind = enum { num_poly_flex, int_poly_flex, frac_poly_flex }; + + // Matrix: should poly × poly unify? + const ShouldUnify = enum { yes, no }; + const should_unify = std.EnumArray(PolyKind, std.EnumArray(PolyKind, ShouldUnify)).init(.{ + .num_poly_flex = std.EnumArray(PolyKind, ShouldUnify).init(.{ + .num_poly_flex = .yes, // Num(a) × Num(b) → yes + .int_poly_flex = .yes, // Num(a) × Num(Int(b)) → yes + .frac_poly_flex = .yes, // Num(a) × Num(Frac(b)) → yes + }), + .int_poly_flex = std.EnumArray(PolyKind, ShouldUnify).init(.{ + .num_poly_flex = .yes, // Num(Int(a)) × Num(b) → yes + .int_poly_flex = .yes, // Num(Int(a)) × Num(Int(b)) → yes + .frac_poly_flex = .no, // Num(Int(a)) × Num(Frac(b)) → NO! + }), + .frac_poly_flex = std.EnumArray(PolyKind, ShouldUnify).init(.{ + .num_poly_flex = .yes, // Num(Frac(a)) × Num(b) → yes + .int_poly_flex = .no, // Num(Frac(a)) × Num(Int(b)) → NO! + .frac_poly_flex = .yes, // Num(Frac(a)) × Num(Frac(b)) → yes + }), + }); + + const poly_specs = std.EnumArray(PolyKind, NumTypeBound).init(.{ + .num_poly_flex = .num_poly_flex, + .int_poly_flex = .int_poly_flex, + .frac_poly_flex = .frac_poly_flex, + }); + + inline for (std.meta.fields(PolyKind)) |a_field| { + inline for (std.meta.fields(PolyKind)) |b_field| { + const a_kind = @field(PolyKind, a_field.name); + const b_kind = @field(PolyKind, b_field.name); + + const case = try NumTestCase.initBothBound(&env, poly_specs.get(a_kind), poly_specs.get(b_kind)); + + const expected = should_unify.get(a_kind).get(b_kind); + + if (expected == .yes) { + case.expectBothOrders(NumTestCase.expectOk) catch |err| { + std.debug.print("FAILED: {s} × {s} (expected to unify)\n", .{ @tagName(a_kind), @tagName(b_kind) }); + return err; + }; + } else { + case.expectBothOrders(NumTestCase.expectProblem) catch |err| { + std.debug.print("FAILED: {s} × {s} (expected NOT to unify)\n", .{ @tagName(a_kind), @tagName(b_kind) }); + return err; + }; + } + } + } +} + +test "unify - unbound vs unbound - requirement merging" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + // Test that int requirements are merged correctly + { + const case = try NumTestCase.initBothUnbound(&env, NumTypeUnbound.intLiteral(256, false), // needs 9 bits, unsigned + NumTypeUnbound.intLiteral(100, true) // needs 7 bits, signed + ); + + const unified = try case.unifyAndGetResult(); + try std.testing.expect(unified.result == .ok); + + // Should take max bits (9) and OR the sign (true) + const resolved = env.module_env.types.resolveVar(unified.a).desc.content; + const int_poly = resolved.structure.num.num_poly; + const int_unbound = env.module_env.types.resolveVar(int_poly).desc.content.structure.num.int_unbound; + + try std.testing.expectEqual(true, int_unbound.sign_needed); + try std.testing.expectEqual(Num.Int.BitsNeeded.@"9_to_15".toBits(), int_unbound.bits_needed); + } + + // Test that frac requirements are merged correctly + { + const case = try NumTestCase.initBothUnbound(&env, NumTypeUnbound.fracLiteral(true, false), // fits f32 only + NumTypeUnbound.fracLiteral(false, true) // fits dec only + ); + + const unified = try case.unifyAndGetResult(); + try std.testing.expect(unified.result == .ok); + + // Should take AND of capabilities (both false) + const resolved = env.module_env.types.resolveVar(unified.a).desc.content; + const frac_poly = resolved.structure.num.num_poly; + const frac_unbound = env.module_env.types.resolveVar(frac_poly).desc.content.structure.num.frac_unbound; + + try std.testing.expectEqual(false, frac_unbound.fits_in_f32); + try std.testing.expectEqual(false, frac_unbound.fits_in_dec); + } + + // Test that num requirements merge both int and frac (Num(num_unbound)) + { + const case = try NumTestCase.initBothUnbound(&env, NumTypeUnbound.numLiteral(256, false, true, false), NumTypeUnbound.numLiteral(100, true, false, true)); + + const unified = try case.unifyAndGetResult(); + try std.testing.expect(unified.result == .ok); + + const resolved = env.module_env.types.resolveVar(unified.a).desc.content.structure.num.num_unbound; + + try std.testing.expectEqual(true, resolved.int_requirements.sign_needed); + try std.testing.expectEqual(Num.Int.BitsNeeded.@"9_to_15".toBits(), resolved.int_requirements.bits_needed); + try std.testing.expectEqual(false, resolved.frac_requirements.fits_in_f32); + try std.testing.expectEqual(false, resolved.frac_requirements.fits_in_dec); + } + + // Test that Num(int_unbound) × Num(frac_unbound) doesn't unify + { + const case = try NumTestCase.initBothUnbound(&env, NumTypeUnbound.intLiteral(100, false), NumTypeUnbound.fracLiteral(true, true)); + + try case.expectProblem(); + } + + // Test that Num(num_unbound) × Num(Int(int_unbound)) unifies and merges int requirements + { + const case = try NumTestCase.initBothUnbound(&env, NumTypeUnbound.numLiteral(256, false, true, false), // Num(num_unbound) + NumTypeUnbound.intLiteral(100, true) // Num(Int(int_unbound)) + ); + + const unified = try case.unifyAndGetResult(); + try std.testing.expect(unified.result == .ok); + + // Result should be Num(Int(int_unbound)) with merged requirements + const resolved = env.module_env.types.resolveVar(unified.a).desc.content; + const int_poly = resolved.structure.num.num_poly; + const int_unbound = env.module_env.types.resolveVar(int_poly).desc.content.structure.num.int_unbound; + + try std.testing.expectEqual(true, int_unbound.sign_needed); + try std.testing.expectEqual(Num.Int.BitsNeeded.@"9_to_15".toBits(), int_unbound.bits_needed); + } + + // Test that Num(num_unbound) × Num(Frac(frac_unbound)) unifies and merges frac requirements + { + const case = try NumTestCase.initBothUnbound(&env, NumTypeUnbound.numLiteral(100, false, true, false), // Num(num_unbound) + NumTypeUnbound.fracLiteral(false, true) // Num(Frac(frac_unbound)) + ); + + const unified = try case.unifyAndGetResult(); + try std.testing.expect(unified.result == .ok); + + // Result should be Num(Frac(frac_unbound)) with merged requirements + const resolved = env.module_env.types.resolveVar(unified.a).desc.content; + const frac_poly = resolved.structure.num.num_poly; + const frac_unbound = env.module_env.types.resolveVar(frac_poly).desc.content.structure.num.frac_unbound; + + try std.testing.expectEqual(false, frac_unbound.fits_in_f32); + try std.testing.expectEqual(false, frac_unbound.fits_in_dec); + } +} + +test "unify - compact vs unbound - both orders" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + // Compact should win after checking requirements + const case = try NumTestCase.init(&env, NumTypeUnbound.intLiteral(100, false), .u8); + + // Test both orders and verify compact wins + { + const unified = try case.unifyAndGetResult(); + try std.testing.expect(unified.result == .ok); + + const resolved = env.module_env.types.resolveVar(unified.a).desc.content.structure.num; + try std.testing.expect(resolved == .num_compact); + try std.testing.expectEqual(Num.Int.Precision.u8, resolved.num_compact.int); + } + + // Swapped order should also have compact win + { + const swapped_case = NumTestCase{ + .env = case.env, + .a_spec = case.b_spec, + .b_spec = case.a_spec, + }; + const unified = try swapped_case.unifyAndGetResult(); + try std.testing.expect(unified.result == .ok); + + const resolved = env.module_env.types.resolveVar(unified.a).desc.content.structure.num; + try std.testing.expect(resolved == .num_compact); + try std.testing.expectEqual(Num.Int.Precision.u8, resolved.num_compact.int); + } +} + +test "unify - compact vs compact - same type succeeds" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const int_types = [_]NumTypeBound{ .u8, .i8, .u16, .i16, .u32, .i32, .u64, .i64, .u128, .i128 }; + const frac_types = [_]NumTypeBound{ .f32, .f64, .dec }; + + // Same int types should unify + for (int_types) |t| { + const case = try NumTestCase.initBothBound(&env, t, t); + try case.expectBothOrders(NumTestCase.expectOk); + } + + // Same frac types should unify + for (frac_types) |t| { + const case = try NumTestCase.initBothBound(&env, t, t); + try case.expectBothOrders(NumTestCase.expectOk); + } + + // Different int types should NOT unify + const case_u8_i8 = try NumTestCase.initBothBound(&env, .u8, .i8); + try case_u8_i8.expectBothOrders(NumTestCase.expectProblem); + + const case_u8_u16 = try NumTestCase.initBothBound(&env, .u8, .u16); + try case_u8_u16.expectBothOrders(NumTestCase.expectProblem); + + // Int vs frac should NOT unify + const case_u8_f32 = try NumTestCase.initBothBound(&env, .u8, .f32); + try case_u8_f32.expectBothOrders(NumTestCase.expectProblem); +} diff --git a/src/check/unify.zig b/src/check/unify.zig index 3f5cc4a60a..5c10d86856 100644 --- a/src/check/unify.zig +++ b/src/check/unify.zig @@ -67,6 +67,8 @@ const Var = types_mod.Var; const Desc = types_mod.Descriptor; const Rank = types_mod.Rank; const Mark = types_mod.Mark; +const Flex = types_mod.Flex; +const Rigid = types_mod.Rigid; const Content = types_mod.Content; const Alias = types_mod.Alias; const NominalType = types_mod.NominalType; @@ -459,20 +461,13 @@ fn Unifier(comptime StoreTypeB: type) type { defer trace.end(); switch (vars.a.desc.content) { - .flex_var => |mb_a_ident| { - self.unifyFlex(vars, mb_a_ident, vars.b.desc.content); + .flex => |flex| { + self.unifyFlex(vars, flex, vars.b.desc.content); }, - .rigid_var => |_| { + .rigid => |_| { try self.unifyRigid(vars, vars.b.desc.content); }, .alias => |a_alias| { - const backing_var = self.types_store.getAliasBackingVar(a_alias); - const backing_resolved = self.types_store.resolveVar(backing_var); - if (backing_resolved.desc.content == .err) { - // Invalid alias - treat as transparent - self.merge(vars, vars.b.desc.content); - return; - } try self.unifyAlias(vars, a_alias, vars.b.desc.content); }, .structure => |a_flat_type| { @@ -516,19 +511,26 @@ fn Unifier(comptime StoreTypeB: type) type { // Unify flex // /// Unify when `a` was a flex - fn unifyFlex(self: *Self, vars: *const ResolvedVarDescs, mb_a_ident: ?Ident.Idx, b_content: Content) void { + fn unifyFlex(self: *Self, vars: *const ResolvedVarDescs, a_flex: Flex, b_content: Content) void { const trace = tracy.trace(@src()); defer trace.end(); switch (b_content) { - .flex_var => |mb_b_ident| { - if (mb_a_ident) |a_ident| { - self.merge(vars, Content{ .flex_var = a_ident }); - } else { - self.merge(vars, Content{ .flex_var = mb_b_ident }); - } + .flex => |b_flex| { + const mb_ident = blk: { + if (a_flex.name) |a_ident| { + break :blk a_ident; + } else { + break :blk b_flex.name; + } + }; + // TODO: Merge static dispatch constraints + self.merge(vars, Content{ .flex = Flex.init().withName(mb_ident) }); + }, + .rigid => { + // TODO: Merge static dispatch constraints + self.merge(vars, b_content); }, - .rigid_var => self.merge(vars, b_content), .alias => |_| self.merge(vars, b_content), .structure => self.merge(vars, b_content), .err => self.merge(vars, .err), @@ -543,8 +545,11 @@ fn Unifier(comptime StoreTypeB: type) type { defer trace.end(); switch (b_content) { - .flex_var => self.merge(vars, vars.a.desc.content), - .rigid_var => return error.TypeMismatch, + .flex => { + // TODO: Merge static dispatch constraints + self.merge(vars, vars.a.desc.content); + }, + .rigid => return error.TypeMismatch, .alias => return error.TypeMismatch, .structure => return error.TypeMismatch, .err => self.merge(vars, .err), @@ -561,10 +566,12 @@ fn Unifier(comptime StoreTypeB: type) type { const backing_var = self.types_store.getAliasBackingVar(a_alias); switch (b_content) { - .flex_var => |_| { + .flex => |_| { + // TODO: Unwrap alias? + // TODO: Merge static dispatch constraints self.merge(vars, Content{ .alias = a_alias }); }, - .rigid_var => |_| { + .rigid => |_| { try self.unifyGuarded(backing_var, vars.b.var_); }, .alias => |b_alias| { @@ -583,7 +590,21 @@ fn Unifier(comptime StoreTypeB: type) type { } }, .structure => { - try self.unifyGuarded(backing_var, vars.b.var_); + // When unifying an alias with a concrete structure, we + // want to preserve the alias for display while ensuring the + // types are compatible. + + // First, we unify the concrete var with the alias backing var + // IMPORTANT: The arg order here is important! Unifying + // updates the second var to hold the type, and the first + // var to redirect to the second + try self.unifyGuarded(vars.b.var_, backing_var); + + // Next, we create a fresh alias (which internally points to `backing_var`), + // then we redirect both a & b to the new alias. + const fresh_alias_var = self.fresh(vars, .{ .alias = a_alias }) catch return Error.AllocatorError; + self.types_store.setVarRedirect(vars.a.var_, fresh_alias_var) catch return Error.AllocatorError; + self.types_store.setVarRedirect(vars.b.var_, fresh_alias_var) catch return Error.AllocatorError; }, .err => self.merge(vars, .err), } @@ -637,12 +658,29 @@ fn Unifier(comptime StoreTypeB: type) type { defer trace.end(); switch (b_content) { - .flex_var => |_| { + .flex => |_| { + // TODO: Check static dispatch constraints self.merge(vars, Content{ .structure = a_flat_type }); }, - .rigid_var => return error.TypeMismatch, + .rigid => return error.TypeMismatch, .alias => |b_alias| { - try self.unifyGuarded(vars.a.var_, self.types_store.getAliasBackingVar(b_alias)); + // When unifying an alias with a concrete structure, we + // want to preserve the alias for display while ensuring the + // types are compatible. + + const backing_var = self.types_store.getAliasBackingVar(b_alias); + + // First, we unify the concrete var with the alias backing var + // IMPORTANT: The arg order here is important! Unifying + // updates the second var to hold the type, and the first + // var to redirect to the second + try self.unifyGuarded(vars.a.var_, backing_var); + + // Next, we create a fresh alias (which internally points to `backing_var`), + // then we redirect both a & b to the new alias. + const fresh_alias_var = self.fresh(vars, .{ .alias = b_alias }) catch return Error.AllocatorError; + self.types_store.setVarRedirect(vars.a.var_, fresh_alias_var) catch return Error.AllocatorError; + self.types_store.setVarRedirect(vars.b.var_, fresh_alias_var) catch return Error.AllocatorError; }, .structure => |b_flat_type| { try self.unifyFlatType(vars, a_flat_type, b_flat_type); @@ -819,49 +857,22 @@ fn Unifier(comptime StoreTypeB: type) type { } }, .record => |b_record| { - try self.unifyTwoRecords(vars, a_record, b_record); + try self.unifyTwoRecords( + vars, + a_record.fields, + .{ .ext = a_record.ext }, + b_record.fields, + .{ .ext = b_record.ext }, + ); }, .record_unbound => |b_fields| { - // When unifying record with record_unbound, record wins - // First gather the fields from the record - const a_gathered_fields = try self.gatherRecordFields(a_record); - - // For record_unbound, we just have the fields directly (no extension) - const b_gathered_range = self.scratch.copyGatherFieldsFromMultiList( - &self.types_store.record_fields, - b_fields, - ) catch return Error.AllocatorError; - - // Partition the fields - const partitioned = Self.partitionFields( - self.module_env.getIdentStore(), - self.scratch, - a_gathered_fields.range, - b_gathered_range, - ) catch return Error.AllocatorError; - - // record_unbound requires at least its fields to be present in the record - // The record can have additional fields (that's what makes it extensible) - if (partitioned.only_in_b.len() > 0) { - // The record_unbound has fields that the record doesn't have - return error.TypeMismatch; - } - - // Unify shared fields - try self.unifySharedFields( + try self.unifyTwoRecords( vars, - self.scratch.in_both_fields.sliceRange(partitioned.in_both), - null, - null, - a_gathered_fields.ext, + a_record.fields, + .{ .ext = a_record.ext }, + b_fields, + .unbound, ); - - // Record wins (keeps its extension and any extra fields) - self.merge(vars, vars.a.desc.content); - }, - .record_poly => |b_poly| { - // When unifying record with record_poly, unify the records - try self.unifyTwoRecords(vars, a_record, b_poly.record); }, else => return error.TypeMismatch, } @@ -877,173 +888,22 @@ fn Unifier(comptime StoreTypeB: type) type { } }, .record => |b_record| { - // When unifying record_unbound with record, record wins - // Copy unbound fields into scratch - const a_gathered_range = self.scratch.copyGatherFieldsFromMultiList( - &self.types_store.record_fields, - a_fields, - ) catch return Error.AllocatorError; - - // Gather fields from the record - const b_gathered_fields = try self.gatherRecordFields(b_record); - - // Partition the fields - const partitioned = Self.partitionFields( - self.module_env.getIdentStore(), - self.scratch, - a_gathered_range, - b_gathered_fields.range, - ) catch return Error.AllocatorError; - - // record_unbound requires at least its fields to be present in the record - // The record can have additional fields (that's what makes it extensible) - if (partitioned.only_in_a.len() > 0) { - // The record_unbound has fields that the record doesn't have - return error.TypeMismatch; - } - - // Unify shared fields - try self.unifySharedFields( + try self.unifyTwoRecords( vars, - self.scratch.in_both_fields.sliceRange(partitioned.in_both), - null, - null, - b_gathered_fields.ext, + a_fields, + .unbound, + b_record.fields, + .{ .ext = b_record.ext }, ); - - // Record wins - self.merge(vars, vars.b.desc.content); }, .record_unbound => |b_fields| { - // Both are record_unbound - unify fields and stay unbound - // Copy both field sets into scratch - const a_gathered_range = self.scratch.copyGatherFieldsFromMultiList( - &self.types_store.record_fields, + try self.unifyTwoRecords( + vars, a_fields, - ) catch return Error.AllocatorError; - const b_gathered_range = self.scratch.copyGatherFieldsFromMultiList( - &self.types_store.record_fields, + .unbound, b_fields, - ) catch return Error.AllocatorError; - - // Partition the fields - const partitioned = Self.partitionFields( - self.module_env.getIdentStore(), - self.scratch, - a_gathered_range, - b_gathered_range, - ) catch return Error.AllocatorError; - - // Check that they have the same fields - if (partitioned.only_in_a.len() > 0 or partitioned.only_in_b.len() > 0) { - return error.TypeMismatch; - } - - // Unify shared fields (no extension since both are unbound) - const dummy_ext = self.fresh(vars, .{ .structure = .empty_record }) catch return Error.AllocatorError; - try self.unifySharedFields( - vars, - self.scratch.in_both_fields.sliceRange(partitioned.in_both), - null, - null, - dummy_ext, + .unbound, ); - - // Stay unbound (use the first one's fields since they're unified now) - self.merge(vars, vars.a.desc.content); - }, - .record_poly => |b_poly| { - // When unifying record_unbound with record_poly, poly wins - // Copy unbound fields into scratch - const a_gathered_range = self.scratch.copyGatherFieldsFromMultiList( - &self.types_store.record_fields, - a_fields, - ) catch return Error.AllocatorError; - - // Gather fields from the poly record - const b_gathered_fields = try self.gatherRecordFields(b_poly.record); - - // Partition the fields - const partitioned = Self.partitionFields( - self.module_env.getIdentStore(), - self.scratch, - a_gathered_range, - b_gathered_fields.range, - ) catch return Error.AllocatorError; - - // Check that they have the same fields - if (partitioned.only_in_a.len() > 0 or partitioned.only_in_b.len() > 0) { - return error.TypeMismatch; - } - - // Unify shared fields - try self.unifySharedFields( - vars, - self.scratch.in_both_fields.sliceRange(partitioned.in_both), - null, - null, - b_gathered_fields.ext, - ); - - // Poly wins - self.merge(vars, vars.b.desc.content); - }, - else => return error.TypeMismatch, - } - }, - .record_poly => |a_poly| { - switch (b_flat_type) { - .empty_record => { - if (a_poly.record.fields.len() == 0) { - try self.unifyGuarded(a_poly.record.ext, vars.b.var_); - } else { - return error.TypeMismatch; - } - }, - .record => |b_record| { - // When unifying record_poly with record, unify the records - try self.unifyTwoRecords(vars, a_poly.record, b_record); - }, - .record_unbound => |b_fields| { - // When unifying record_poly with record_unbound, poly wins - // Gather fields from the poly record - const a_gathered_fields = try self.gatherRecordFields(a_poly.record); - - // Copy unbound fields into scratch - const b_gathered_range = self.scratch.copyGatherFieldsFromMultiList( - &self.types_store.record_fields, - b_fields, - ) catch return Error.AllocatorError; - - // Partition the fields - const partitioned = Self.partitionFields( - self.module_env.getIdentStore(), - self.scratch, - a_gathered_fields.range, - b_gathered_range, - ) catch return Error.AllocatorError; - - // Check that they have the same fields - if (partitioned.only_in_a.len() > 0 or partitioned.only_in_b.len() > 0) { - return error.TypeMismatch; - } - - // Unify shared fields - try self.unifySharedFields( - vars, - self.scratch.in_both_fields.sliceRange(partitioned.in_both), - null, - null, - a_gathered_fields.ext, - ); - - // Poly wins - self.merge(vars, vars.a.desc.content); - }, - .record_poly => |b_poly| { - // Both are record_poly - unify the records and vars - try self.unifyTwoRecords(vars, a_poly.record, b_poly.record); - try self.unifyGuarded(a_poly.var_, b_poly.var_); }, else => return error.TypeMismatch, } @@ -1068,13 +928,6 @@ fn Unifier(comptime StoreTypeB: type) type { return error.TypeMismatch; } }, - .record_poly => |b_poly| { - if (b_poly.record.fields.len() == 0) { - try self.unifyGuarded(vars.a.var_, b_poly.record.ext); - } else { - return error.TypeMismatch; - } - }, else => return error.TypeMismatch, } }, @@ -1144,335 +997,163 @@ fn Unifier(comptime StoreTypeB: type) type { a_num: Num, b_num: Num, ) Error!void { - const trace = tracy.trace(@src()); - defer trace.end(); - switch (a_num) { + // Nums // + // Num(a) + // ^^^ .num_poly => |a_poly| { switch (b_num) { .num_poly => |b_poly| { - // Unify the variables - try self.unifyGuarded(a_poly.var_, b_poly.var_); - - // num_poly always contains IntRequirements - self.merge(vars, Content{ .structure = .{ .num = .{ .num_poly = .{ - .var_ = a_poly.var_, - .requirements = a_poly.requirements.unify(b_poly.requirements), - } } } }); + try self.unifyGuarded(a_poly, b_poly); + self.merge(vars, .{ .structure = .{ .num = .{ .num_poly = b_poly } } }); }, - .num_unbound => |b_requirements| { - // When unifying num_poly with num_unbound, the unbound picks up the poly's var - self.merge(vars, Content{ .structure = .{ .num = .{ .num_poly = .{ - .var_ = a_poly.var_, - .requirements = a_poly.requirements.unify(b_requirements), - } } } }); + .num_unbound => |b_reqs| { + try self.unifyPolyAndUnboundNums(vars, a_poly, b_reqs); }, .num_compact => |b_num_compact| { - // num_poly always contains IntRequirements - switch (b_num_compact) { - .int => |prec| { - const result = self.checkIntPrecisionRequirements(prec, a_poly.requirements); + try self.unifyPolyAndCompactNums(vars, a_poly, b_num_compact); + }, + else => return error.TypeMismatch, + } + }, + .num_unbound => |a_reqs| { + switch (b_num) { + .num_poly => |b_poly| { + try self.unifyUnboundAndPolyNums(vars, a_reqs, b_poly); + }, + .num_unbound => |b_requirements| { + self.merge(vars, .{ .structure = .{ .num = .{ + .num_unbound = .{ + .int_requirements = a_reqs.int_requirements.unify(b_requirements.int_requirements), + .frac_requirements = a_reqs.frac_requirements.unify(b_requirements.frac_requirements), + }, + } } }); + }, + .num_compact => |b_num_compact| { + try self.unifyUnboundAndCompactNums( + vars, + a_reqs, + b_num_compact, + ); + }, + else => return error.TypeMismatch, + } + }, + // Ints + // Num(Int(a)) + // ^^^^^^ + .int_poly => |a_poly_var| { + switch (b_num) { + .int_poly => |b_poly_var| { + try self.unifyGuarded(a_poly_var, b_poly_var); + self.merge(vars, vars.a.desc.content); + }, + .int_unbound => |b_reqs| { + const a_num_resolved = self.resolvePolyNum(a_poly_var, .inside_int); + switch (a_num_resolved) { + .int_resolved => |a_prec| { + const result = self.checkIntPrecisionRequirements(a_prec, b_reqs); switch (result) { .ok => {}, .negative_unsigned => return error.NegativeUnsignedInt, .too_large => return error.NumberDoesNotFit, } + self.merge(vars, vars.a.desc.content); }, - .frac => return error.TypeMismatch, + .int_flex => { + self.merge(vars, vars.b.desc.content); + }, + else => return error.TypeMismatch, } - self.merge(vars, vars.b.desc.content); }, - .int_poly => |b_poly| { - // Both are int requirements - unify and merge - try self.unifyGuarded(a_poly.var_, b_poly.var_); - self.merge(vars, Content{ .structure = .{ .num = .{ .int_poly = .{ - .var_ = a_poly.var_, - .requirements = a_poly.requirements.unify(b_poly.requirements), - } } } }); - }, - .int_unbound => |b_requirements| { - // When unifying int_poly with int_unbound, keep as int_poly - self.merge(vars, Content{ .structure = .{ .num = .{ .int_poly = .{ - .var_ = a_poly.var_, - .requirements = a_poly.requirements.unify(b_requirements), - } } } }); - }, - .frac_poly => { - // num_poly has IntRequirements, frac_poly has FracRequirements - incompatible - return error.TypeMismatch; - }, - .frac_unbound => { - // num_poly has IntRequirements, frac_unbound has FracRequirements - incompatible - return error.TypeMismatch; - }, - .int_precision => |prec| { - // num_poly always contains IntRequirements - const result = self.checkIntPrecisionRequirements(prec, a_poly.requirements); - switch (result) { - .ok => {}, - .negative_unsigned => return error.NegativeUnsignedInt, - .too_large => return error.NumberDoesNotFit, - } - self.merge(vars, vars.b.desc.content); - }, - .frac_precision => { - // num_poly has IntRequirements, frac_precision is for fractions - incompatible - return error.TypeMismatch; - }, - } - }, - .int_poly => |a_poly| { - switch (b_num) { - .num_poly => |b_poly| { - // Both are int requirements - unify and merge - try self.unifyGuarded(a_poly.var_, b_poly.var_); - self.merge(vars, Content{ .structure = .{ .num = .{ .int_poly = .{ - .var_ = a_poly.var_, - .requirements = a_poly.requirements.unify(b_poly.requirements), - } } } }); - }, - .num_unbound => |b_requirements| { - // When unifying int_poly with num_unbound, keep as int_poly - self.merge(vars, Content{ .structure = .{ .num = .{ .int_poly = .{ - .var_ = a_poly.var_, - .requirements = a_poly.requirements.unify(b_requirements), - } } } }); - }, - .int_poly => |b_poly| { - try self.unifyGuarded(a_poly.var_, b_poly.var_); - self.merge(vars, Content{ .structure = .{ .num = .{ .int_poly = .{ - .var_ = a_poly.var_, - .requirements = a_poly.requirements.unify(b_poly.requirements), - } } } }); - }, - .int_unbound => |b_requirements| { - // When unifying int_poly with int_unbound, keep as int_poly - self.merge(vars, Content{ .structure = .{ .num = .{ .int_poly = .{ - .var_ = a_poly.var_, - .requirements = a_poly.requirements.unify(b_requirements), - } } } }); - }, - .int_precision => |prec| { - // Check if the requirements variable is rigid - const req_var_desc = self.module_env.types.resolveVar(a_poly.var_).desc; - if (req_var_desc.content == .rigid_var) { - return error.TypeMismatch; - } - // Check if the precision satisfies the requirements - const result = self.checkIntPrecisionRequirements(prec, a_poly.requirements); - switch (result) { - .ok => {}, - .negative_unsigned => return error.NegativeUnsignedInt, - .too_large => return error.NumberDoesNotFit, - } - self.merge(vars, vars.b.desc.content); - }, - else => return error.TypeMismatch, } }, - .frac_poly => |a_poly| { + .int_unbound => |a_reqs| { switch (b_num) { - .frac_poly => |b_poly| { - try self.unifyGuarded(a_poly.var_, b_poly.var_); - self.merge(vars, Content{ .structure = .{ .num = .{ .frac_poly = .{ - .var_ = a_poly.var_, - .requirements = a_poly.requirements.unify(b_poly.requirements), - } } } }); - }, - .frac_unbound => |b_requirements| { - // When unifying frac_poly with frac_unbound, keep as frac_poly - self.merge(vars, Content{ .structure = .{ .num = .{ .frac_poly = .{ - .var_ = a_poly.var_, - .requirements = a_poly.requirements.unify(b_requirements), - } } } }); - }, - .frac_precision => |prec| { - // Check if the precision satisfies the requirements - if (!self.fracPrecisionSatisfiesRequirements(prec, a_poly.requirements)) { - return error.TypeMismatch; - } - self.merge(vars, vars.b.desc.content); - }, - .num_poly => { - // num_poly has IntRequirements, frac_poly has FracRequirements - incompatible - return error.TypeMismatch; - }, - .num_compact => |b_compact| { - // Check if the requirements variable is rigid - const req_var_desc = self.module_env.types.resolveVar(a_poly.var_).desc; - if (req_var_desc.content == .rigid_var) { - return error.TypeMismatch; - } - // Check if the compact frac type satisfies the requirements - switch (b_compact) { - .frac => |prec| { - if (!self.fracPrecisionSatisfiesRequirements(prec, a_poly.requirements)) { - return error.TypeMismatch; + .int_poly => |b_poly_var| { + const b_num_resolved = self.resolvePolyNum(b_poly_var, .inside_int); + switch (b_num_resolved) { + .int_resolved => |b_prec| { + const result = self.checkIntPrecisionRequirements(b_prec, a_reqs); + switch (result) { + .ok => {}, + .negative_unsigned => return error.NegativeUnsignedInt, + .too_large => return error.NumberDoesNotFit, } self.merge(vars, vars.b.desc.content); }, - .int => return error.TypeMismatch, - } - }, - else => return error.TypeMismatch, - } - }, - .num_unbound => |a_requirements| { - switch (b_num) { - .num_poly => |b_poly| { - // When unifying num_unbound with num_poly, the unbound picks up the poly's var - self.merge(vars, Content{ .structure = .{ .num = .{ .num_poly = .{ - .var_ = b_poly.var_, - .requirements = a_requirements.unify(b_poly.requirements), - } } } }); - }, - .num_unbound => |b_requirements| { - // Both unbound - merge requirements, stay unbound - self.merge(vars, Content{ .structure = .{ .num = .{ .num_unbound = a_requirements.unify(b_requirements) } } }); - }, - .int_poly => |b_poly| { - // When unifying num_unbound with int_poly, keep as int_poly - self.merge(vars, Content{ .structure = .{ .num = .{ .int_poly = .{ - .var_ = b_poly.var_, - .requirements = a_requirements.unify(b_poly.requirements), - } } } }); - }, - .int_unbound => |b_requirements| { - // When unifying num_unbound with int_unbound, keep as int_unbound - self.merge(vars, Content{ .structure = .{ .num = .{ .int_unbound = a_requirements.unify(b_requirements) } } }); - }, - .num_compact => |b_num_compact| { - // Check if the compact type satisfies the requirements - switch (b_num_compact) { - .int => |int_prec| { - const result = self.checkIntPrecisionRequirements(int_prec, a_requirements); - switch (result) { - .ok => {}, - .negative_unsigned => return error.NegativeUnsignedInt, - .too_large => return error.NumberDoesNotFit, - } + .int_flex => { + self.merge(vars, vars.a.desc.content); }, - .frac => return error.TypeMismatch, + else => return error.TypeMismatch, } - self.merge(vars, vars.b.desc.content); }, - .int_precision => |prec| { - // Check if the precision satisfies the requirements - const result = self.checkIntPrecisionRequirements(prec, a_requirements); - switch (result) { - .ok => {}, - .negative_unsigned => return error.NegativeUnsignedInt, - .too_large => return error.NumberDoesNotFit, - } - self.merge(vars, vars.b.desc.content); - }, - .frac_precision => |prec| { - // Promote decimal integers to the concrete fractional precision. - // Any fractional precision can represent integer literals, so no - // additional requirement checks are needed here. - self.merge(vars, Content{ .structure = .{ .num = .{ .frac_precision = prec } } }); - }, - .frac_unbound => |b_requirements| { - // When unifying num_unbound with frac_unbound, frac wins - self.merge(vars, Content{ .structure = .{ .num = .{ .frac_unbound = b_requirements } } }); + .int_unbound => |b_reqs| { + self.merge(vars, .{ .structure = .{ .num = .{ + .int_unbound = a_reqs.unify(b_reqs), + } } }); }, else => return error.TypeMismatch, } }, - .int_unbound => |a_requirements| { + // Fracs // + // Num(Frac(a)) + // ^^^^^^^ + .frac_poly => |a_poly_var| { switch (b_num) { - .num_poly => |b_poly| { - // When unifying int_unbound with num_poly, keep as int_poly - self.merge(vars, Content{ .structure = .{ .num = .{ .int_poly = .{ - .var_ = b_poly.var_, - .requirements = a_requirements.unify(b_poly.requirements), - } } } }); + .frac_poly => |b_poly_var| { + try self.unifyGuarded(a_poly_var, b_poly_var); + self.merge(vars, vars.a.desc.content); }, - .num_unbound => |b_requirements| { - // When unifying int_unbound with num_unbound, keep as int_unbound - self.merge(vars, Content{ .structure = .{ .num = .{ .int_unbound = a_requirements.unify(b_requirements) } } }); - }, - .int_poly => |b_poly| { - // When unifying int_unbound with int_poly, keep as int_poly - self.merge(vars, Content{ .structure = .{ .num = .{ .int_poly = .{ - .var_ = b_poly.var_, - .requirements = a_requirements.unify(b_poly.requirements), - } } } }); - }, - .int_unbound => |b_requirements| { - // Both int_unbound - merge requirements - self.merge(vars, Content{ .structure = .{ .num = .{ .int_unbound = a_requirements.unify(b_requirements) } } }); - }, - .num_compact => |b_num_compact| { - // Check if it's an int - switch (b_num_compact) { - .int => |int_prec| { - const result = self.checkIntPrecisionRequirements(int_prec, a_requirements); - switch (result) { - .ok => {}, - .negative_unsigned => return error.NegativeUnsignedInt, - .too_large => return error.NumberDoesNotFit, + .frac_unbound => |b_reqs| { + const a_num_resolved = self.resolvePolyNum(a_poly_var, .inside_frac); + switch (a_num_resolved) { + .frac_resolved => |a_prec| { + const does_fit = self.checkFracPrecisionRequirements(a_prec, b_reqs); + if (!does_fit) { + return error.NumberDoesNotFit; } + self.merge(vars, vars.a.desc.content); }, - .frac => return error.TypeMismatch, + .frac_flex => { + self.merge(vars, vars.b.desc.content); + }, + else => return error.TypeMismatch, } - self.merge(vars, vars.b.desc.content); - }, - .int_precision => |prec| { - // Check if the precision satisfies the requirements - const result = self.checkIntPrecisionRequirements(prec, a_requirements); - switch (result) { - .ok => {}, - .negative_unsigned => return error.NegativeUnsignedInt, - .too_large => return error.NumberDoesNotFit, - } - self.merge(vars, vars.b.desc.content); }, else => return error.TypeMismatch, } }, - .frac_unbound => |a_requirements| { + .frac_unbound => |a_reqs| { switch (b_num) { - .frac_poly => |b_poly| { - // When unifying frac_unbound with frac_poly, keep as frac_poly - self.merge(vars, Content{ .structure = .{ .num = .{ .frac_poly = .{ - .var_ = b_poly.var_, - .requirements = a_requirements.unify(b_poly.requirements), - } } } }); - }, - .frac_unbound => |b_requirements| { - // Both frac_unbound - merge requirements - self.merge(vars, Content{ .structure = .{ .num = .{ .frac_unbound = a_requirements.unify(b_requirements) } } }); - }, - .num_compact => |b_num_compact| { - // Check if it's a frac - switch (b_num_compact) { - .frac => |frac_prec| { - if (!self.fracPrecisionSatisfiesRequirements(frac_prec, a_requirements)) { - return error.TypeMismatch; + .frac_poly => |b_poly_var| { + const b_num_resolved = self.resolvePolyNum(b_poly_var, .inside_frac); + switch (b_num_resolved) { + .frac_resolved => |b_prec| { + const does_fit = self.checkFracPrecisionRequirements(b_prec, a_reqs); + if (!does_fit) { + return error.NumberDoesNotFit; } + self.merge(vars, vars.b.desc.content); }, - .int => return error.TypeMismatch, + .frac_flex => { + self.merge(vars, vars.a.desc.content); + }, + else => return error.TypeMismatch, } - self.merge(vars, vars.b.desc.content); }, - .frac_precision => |prec| { - // Check if the precision satisfies the requirements - if (!self.fracPrecisionSatisfiesRequirements(prec, a_requirements)) { - return error.TypeMismatch; - } - self.merge(vars, vars.b.desc.content); - }, - .num_unbound => |b_requirements| { - // When unifying frac_unbound with num_unbound, frac wins - // Note: b_requirements are IntRequirements, we just keep our FracRequirements - _ = b_requirements; - self.merge(vars, Content{ .structure = .{ .num = .{ .frac_unbound = a_requirements } } }); + .frac_unbound => |b_reqs| { + self.merge(vars, .{ .structure = .{ .num = .{ + .frac_unbound = a_reqs.unify(b_reqs), + } } }); }, else => return error.TypeMismatch, } }, + // Precisions // + // This Num(Int(a)), Num(Int(Signed8)), Num(Frac(...)) + // ^ ^^^^^^^ ^^^ .int_precision => |a_prec| { switch (b_num) { .int_precision => |b_prec| { @@ -1482,18 +1163,6 @@ fn Unifier(comptime StoreTypeB: type) type { return error.TypeMismatch; } }, - .num_compact => |b_compact| { - switch (b_compact) { - .int => |b_prec| { - if (a_prec == b_prec) { - self.merge(vars, vars.b.desc.content); - } else { - return error.TypeMismatch; - } - }, - .frac => return error.TypeMismatch, - } - }, else => return error.TypeMismatch, } }, @@ -1506,100 +1175,30 @@ fn Unifier(comptime StoreTypeB: type) type { return error.TypeMismatch; } }, - .num_unbound => { - // Fractional precision wins when unified with decimal integer literals. - self.merge(vars, vars.a.desc.content); - }, - .num_compact => |b_compact| { - switch (b_compact) { - .frac => |b_prec| { - if (a_prec == b_prec) { - self.merge(vars, vars.b.desc.content); - } else { - return error.TypeMismatch; - } - }, - .int => return error.TypeMismatch, - } - }, else => return error.TypeMismatch, } }, + // Compacted nums // + // The whole Num(Int(Signed8)), compacted into a single variable + // ^^^^^^^^^^^^^^^^ .num_compact => |a_num_compact| { switch (b_num) { .num_compact => |b_num_compact| { try self.unifyTwoCompactNums(vars, a_num_compact, b_num_compact); }, .num_poly => |b_poly| { - // num_poly always contains IntRequirements - switch (a_num_compact) { - .int => |prec| { - const result = self.checkIntPrecisionRequirements(prec, b_poly.requirements); - switch (result) { - .ok => {}, - .negative_unsigned => return error.NegativeUnsignedInt, - .too_large => return error.NumberDoesNotFit, - } - }, - .frac => return error.TypeMismatch, - } - self.merge(vars, vars.a.desc.content); + try self.unifyCompactAndPolyNums( + vars, + a_num_compact, + b_poly, + ); }, - .int_precision => |b_prec| { - switch (a_num_compact) { - .int => |a_prec| { - if (a_prec == b_prec) { - self.merge(vars, vars.a.desc.content); - } else { - return error.TypeMismatch; - } - }, - .frac => return error.TypeMismatch, - } - }, - .frac_precision => |b_prec| { - switch (a_num_compact) { - .frac => |a_prec| { - if (a_prec == b_prec) { - self.merge(vars, vars.a.desc.content); - } else { - return error.TypeMismatch; - } - }, - .int => return error.TypeMismatch, - } - }, - .frac_poly => |b_poly| { - // Check if the requirements variable is rigid - const req_var_desc = self.module_env.types.resolveVar(b_poly.var_).desc; - if (req_var_desc.content == .rigid_var) { - return error.TypeMismatch; - } - // Check if the compact frac type satisfies the requirements - switch (a_num_compact) { - .frac => |prec| { - if (!self.fracPrecisionSatisfiesRequirements(prec, b_poly.requirements)) { - return error.TypeMismatch; - } - self.merge(vars, vars.a.desc.content); - }, - .int => return error.TypeMismatch, - } - }, - .num_unbound => |b_num_unbound| { - // Check if the compact type satisfies the requirements - switch (a_num_compact) { - .int => |int_prec| { - const result = self.checkIntPrecisionRequirements(int_prec, b_num_unbound); - switch (result) { - .ok => {}, - .negative_unsigned => return error.NegativeUnsignedInt, - .too_large => return error.NumberDoesNotFit, - } - }, - .frac => return error.TypeMismatch, - } - self.merge(vars, vars.a.desc.content); + .num_unbound => |b_reqs| { + try self.unifyCompactAndUnboundNums( + vars, + a_num_compact, + b_reqs, + ); }, else => return error.TypeMismatch, } @@ -1607,71 +1206,411 @@ fn Unifier(comptime StoreTypeB: type) type { } } - const IntPrecisionCheckResult = enum { - ok, - negative_unsigned, - too_large, - }; + // number unification helpers // - fn checkIntPrecisionRequirements(self: *Self, prec: Num.Int.Precision, requirements: Num.IntRequirements) IntPrecisionCheckResult { - _ = self; + // Unify when a is polymorphic and b is unbound with requirements + /// Preserves rigid variables from a, or merges requirements appropriately + fn unifyPolyAndUnboundNums( + self: *Self, + vars: *const ResolvedVarDescs, + a_num_var: Var, + b_reqs: Num.NumRequirements, + ) Error!void { + const a_num_resolved = self.resolvePolyNum(a_num_var, .inside_num); + switch (a_num_resolved) { + // If the variable inside a was flex, then b wins + .num_flex => self.merge(vars, vars.b.desc.content), - // Check sign requirement - const is_signed = switch (prec) { - .i8, .i16, .i32, .i64, .i128 => true, - .u8, .u16, .u32, .u64, .u128 => false, - }; + // If the variable inside a was flex, then have it become unbound with requirements + .int_flex => { + const int_unbound = self.fresh(vars, .{ .structure = .{ + .num = .{ .int_unbound = b_reqs.int_requirements }, + } }) catch return Error.AllocatorError; + self.merge(vars, .{ .structure = .{ .num = .{ .num_poly = int_unbound } } }); + }, + .frac_flex => { + const frac_unbound = self.fresh(vars, .{ .structure = .{ + .num = .{ .frac_unbound = b_reqs.frac_requirements }, + } }) catch return Error.AllocatorError; + self.merge(vars, .{ .structure = .{ .num = .{ .num_poly = frac_unbound } } }); + }, - // If we need signed values but have unsigned type, it's a negative literal error - if (requirements.sign_needed and !is_signed) { - return .negative_unsigned; + // If the variable was rigid, then the rigid wins + .num_rigid => self.merge(vars, vars.a.desc.content), + .int_rigid => self.merge(vars, vars.a.desc.content), + .frac_rigid => self.merge(vars, vars.a.desc.content), + + // If the variable inside a was unbound with recs, unify the reqs + .num_unbound => |a_reqs| self.merge(vars, .{ .structure = .{ .num = .{ .num_unbound = .{ + .int_requirements = b_reqs.int_requirements.unify(a_reqs.int_requirements), + .frac_requirements = b_reqs.frac_requirements.unify(a_reqs.frac_requirements), + } } } }), + .int_unbound => |a_reqs| { + const poly_unbound = self.fresh(vars, .{ .structure = .{ + .num = .{ .int_unbound = b_reqs.int_requirements.unify(a_reqs) }, + } }) catch return Error.AllocatorError; + self.merge(vars, .{ .structure = .{ .num = .{ .num_poly = poly_unbound } } }); + }, + .frac_unbound => |a_reqs| { + const poly_unbound = self.fresh(vars, .{ .structure = .{ + .num = .{ .frac_unbound = b_reqs.frac_requirements.unify(a_reqs) }, + } }) catch return Error.AllocatorError; + self.merge(vars, .{ .structure = .{ .num = .{ .num_poly = poly_unbound } } }); + }, + + // If the variable inside an int with a precision + .int_resolved => |a_int| { + const result = self.checkIntPrecisionRequirements(a_int, b_reqs.int_requirements); + switch (result) { + .ok => {}, + .negative_unsigned => return error.NegativeUnsignedInt, + .too_large => return error.NumberDoesNotFit, + } + self.merge(vars, vars.b.desc.content); + }, + + // If the variable inside an frac with a precision or requirements + .frac_resolved => |a_frac| { + const does_fit = self.checkFracPrecisionRequirements(a_frac, b_reqs.frac_requirements); + if (!does_fit) { + return error.NumberDoesNotFit; + } + self.merge(vars, vars.b.desc.content); + }, + + // If the variable inside a wasn't a num, then this in an error + .err => |var_| { + return self.setUnifyErrAndThrow(.{ .invalid_number_type = var_ }); + }, } - - // Check bits requirement - const available_bits: u8 = switch (prec) { - .i8, .u8 => 8, - .i16, .u16 => 16, - .i32, .u32 => 32, - .i64, .u64 => 64, - .i128, .u128 => 128, - }; - - // Map requirements.bits_needed to actual bit count - const required_bits: u8 = switch (@as(Num.Int.BitsNeeded, @enumFromInt(requirements.bits_needed))) { - .@"7" => 7, - .@"8" => 8, - .@"9_to_15" => 15, - .@"16" => 16, - .@"17_to_31" => 31, - .@"32" => 32, - .@"33_to_63" => 63, - .@"64" => 64, - .@"65_to_127" => 127, - .@"128" => 128, - }; - - // For unsigned types, we need exactly the required bits - if (!is_signed) { - return if (available_bits >= required_bits) .ok else .too_large; - } - - // For signed types, we lose one bit to the sign - const usable_bits = if (is_signed) available_bits - 1 else available_bits; - - return if (usable_bits >= required_bits) .ok else .too_large; } - fn intPrecisionSatisfiesRequirements(self: *Self, prec: Num.Int.Precision, requirements: Num.IntRequirements) bool { - return self.checkIntPrecisionRequirements(prec, requirements) == .ok; + /// Unify when a is unbound with requirements and b is polymorphic + /// Preserves rigid variables from b, or merges requirements appropriately + fn unifyUnboundAndPolyNums( + self: *Self, + vars: *const ResolvedVarDescs, + a_reqs: Num.NumRequirements, + b_num_var: Var, + ) Error!void { + const b_num_resolved = self.resolvePolyNum(b_num_var, .inside_num); + switch (b_num_resolved) { + // If the variable inside a was flex, then b wins + .num_flex => self.merge(vars, vars.a.desc.content), + + // If the variable inside a was flex, then have it become unbound with requirements + .int_flex => { + const int_unbound = self.fresh(vars, .{ .structure = .{ + .num = .{ .int_unbound = a_reqs.int_requirements }, + } }) catch return Error.AllocatorError; + self.merge(vars, .{ .structure = .{ .num = .{ .num_poly = int_unbound } } }); + }, + .frac_flex => { + const frac_unbound = self.fresh(vars, .{ .structure = .{ + .num = .{ .frac_unbound = a_reqs.frac_requirements }, + } }) catch return Error.AllocatorError; + self.merge(vars, .{ .structure = .{ .num = .{ .num_poly = frac_unbound } } }); + }, + + // If the variable was rigid, then the rigid wins + .num_rigid => self.merge(vars, vars.b.desc.content), + .int_rigid => self.merge(vars, vars.b.desc.content), + .frac_rigid => self.merge(vars, vars.b.desc.content), + + // If the variable inside a was unbound with recs, unify the reqs + .num_unbound => |b_reqs| self.merge(vars, .{ .structure = .{ .num = .{ .num_unbound = .{ + .int_requirements = a_reqs.int_requirements.unify(b_reqs.int_requirements), + .frac_requirements = a_reqs.frac_requirements.unify(b_reqs.frac_requirements), + } } } }), + .int_unbound => |b_reqs| { + const poly_unbound = self.fresh(vars, .{ .structure = .{ + .num = .{ .int_unbound = a_reqs.int_requirements.unify(b_reqs) }, + } }) catch return Error.AllocatorError; + self.merge(vars, .{ .structure = .{ .num = .{ .num_poly = poly_unbound } } }); + }, + .frac_unbound => |b_reqs| { + const poly_unbound = self.fresh(vars, .{ .structure = .{ + .num = .{ .frac_unbound = a_reqs.frac_requirements.unify(b_reqs) }, + } }) catch return Error.AllocatorError; + self.merge(vars, .{ .structure = .{ .num = .{ .num_poly = poly_unbound } } }); + }, + + // If the variable inside an int with a precision + .int_resolved => |b_int| { + const result = self.checkIntPrecisionRequirements(b_int, a_reqs.int_requirements); + switch (result) { + .ok => {}, + .negative_unsigned => return error.NegativeUnsignedInt, + .too_large => return error.NumberDoesNotFit, + } + self.merge(vars, vars.a.desc.content); + }, + + // If the variable inside an frac with a precision or requirements + .frac_resolved => |b_frac| { + const does_fit = self.checkFracPrecisionRequirements(b_frac, a_reqs.frac_requirements); + if (!does_fit) { + return error.NumberDoesNotFit; + } + self.merge(vars, vars.a.desc.content); + }, + + // If the variable inside a wasn't a num, then this in an error + .err => |var_| { + return self.setUnifyErrAndThrow(.{ .invalid_number_type = var_ }); + }, + } } - fn fracPrecisionSatisfiesRequirements(self: *Self, prec: Num.Frac.Precision, requirements: Num.FracRequirements) bool { - _ = self; + /// Unify when a is compact and b is polymorphic + /// Since a is compact, we must merge with it (unless b is rigid, which errors) + fn unifyCompactAndPolyNums( + self: *Self, + vars: *const ResolvedVarDescs, + a_num: NumCompact, + b_num_var: Var, + ) Error!void { + const b_num_resolved = self.resolvePolyNum(b_num_var, .inside_num); + switch (a_num) { + .int => |a_int| { + switch (b_num_resolved) { + // If the variable inside a was flex, then b wins + .num_flex => self.merge(vars, vars.a.desc.content), + .int_flex => self.merge(vars, vars.a.desc.content), - switch (prec) { - .f32 => return requirements.fits_in_f32, - .f64 => return true, // F64 can always hold values - .dec => return requirements.fits_in_dec, + // If the var inside was a num with requirements + .num_unbound => |b_reqs| { + const result = self.checkIntPrecisionRequirements(a_int, b_reqs.int_requirements); + switch (result) { + .ok => {}, + .negative_unsigned => return error.NegativeUnsignedInt, + .too_large => return error.NumberDoesNotFit, + } + self.merge(vars, vars.a.desc.content); + }, + + // If the variable inside an int with a precision or requirements + .int_resolved => |b_int| if (@intFromEnum(a_int) == @intFromEnum(b_int)) { + self.merge(vars, vars.a.desc.content); + } else { + return error.TypeMismatch; + }, + .int_unbound => |b_reqs| { + const result = self.checkIntPrecisionRequirements(a_int, b_reqs); + switch (result) { + .ok => {}, + .negative_unsigned => return error.NegativeUnsignedInt, + .too_large => return error.NumberDoesNotFit, + } + self.merge(vars, vars.a.desc.content); + }, + + // If the variable inside b was a frac, error + .frac_flex => return error.TypeMismatch, + .frac_resolved => return error.TypeMismatch, + .frac_unbound => return error.TypeMismatch, + + // If the variable was rigid, then error + .num_rigid => return error.TypeMismatch, + .int_rigid => return error.TypeMismatch, + .frac_rigid => return error.TypeMismatch, + + // If the variable inside a wasn't a num, then this in an error + .err => |var_| { + return self.setUnifyErrAndThrow(.{ .invalid_number_type = var_ }); + }, + } + }, + .frac => |a_frac| { + switch (b_num_resolved) { + // If the variable inside a was flex, then b wins + .num_flex => self.merge(vars, vars.a.desc.content), + .frac_flex => self.merge(vars, vars.a.desc.content), + + // If the var inside was a num with requirements + .num_unbound => |b_reqs| { + const does_fit = self.checkFracPrecisionRequirements(a_frac, b_reqs.frac_requirements); + if (!does_fit) { + return error.NumberDoesNotFit; + } + self.merge(vars, vars.a.desc.content); + }, + + // If the variable inside an int with a precision or requirements + .frac_resolved => |b_frac| if (@intFromEnum(a_frac) == @intFromEnum(b_frac)) { + self.merge(vars, vars.a.desc.content); + } else { + return error.TypeMismatch; + }, + .frac_unbound => |b_reqs| { + const does_fit = self.checkFracPrecisionRequirements(a_frac, b_reqs); + if (!does_fit) { + return error.NumberDoesNotFit; + } + self.merge(vars, vars.a.desc.content); + }, + + // If the variable inside b was an int, error + .int_flex => return error.TypeMismatch, + .int_resolved => return error.TypeMismatch, + .int_unbound => return error.TypeMismatch, + + // If the variable was rigid, then error + .num_rigid => return error.TypeMismatch, + .int_rigid => return error.TypeMismatch, + .frac_rigid => return error.TypeMismatch, + + // If the variable inside a wasn't a num, then this in an error + .err => |var_| { + return self.setUnifyErrAndThrow(.{ .invalid_number_type = var_ }); + }, + } + }, + } + } + + /// Unify when a is polymorphic and b is compact + /// Since b is compact, we must merge with it (unless a is rigid, which errors) + fn unifyPolyAndCompactNums( + self: *Self, + vars: *const ResolvedVarDescs, + a_num_var: Var, + b_num: NumCompact, + ) Error!void { + const a_num_resolved = self.resolvePolyNum(a_num_var, .inside_num); + switch (a_num_resolved) { + // If the variable inside a was flex, then b wins + .num_flex => self.merge(vars, vars.b.desc.content), + .int_flex => self.merge(vars, vars.b.desc.content), + .frac_flex => self.merge(vars, vars.b.desc.content), + + // If the variable was rigid, then error + .num_rigid => return error.TypeMismatch, + .int_rigid => return error.TypeMismatch, + .frac_rigid => return error.TypeMismatch, + + // If the var inside was a num with requirements + .num_unbound => |a_reqs| switch (b_num) { + .int => |b_int| { + const result = self.checkIntPrecisionRequirements(b_int, a_reqs.int_requirements); + switch (result) { + .ok => {}, + .negative_unsigned => return error.NegativeUnsignedInt, + .too_large => return error.NumberDoesNotFit, + } + self.merge(vars, vars.b.desc.content); + }, + .frac => |b_frac| { + const does_fit = self.checkFracPrecisionRequirements(b_frac, a_reqs.frac_requirements); + if (!does_fit) { + return error.NumberDoesNotFit; + } + self.merge(vars, vars.b.desc.content); + }, + }, + + // If the variable inside an int with a precision or requirements + .int_resolved => |a_int| switch (b_num) { + .int => |b_int| if (@intFromEnum(a_int) == @intFromEnum(b_int)) { + self.merge(vars, vars.b.desc.content); + } else { + return error.TypeMismatch; + }, + .frac => return error.TypeMismatch, + }, + .int_unbound => |a_reqs| switch (b_num) { + .int => |b_int| { + const result = self.checkIntPrecisionRequirements(b_int, a_reqs); + switch (result) { + .ok => {}, + .negative_unsigned => return error.NegativeUnsignedInt, + .too_large => return error.NumberDoesNotFit, + } + self.merge(vars, vars.b.desc.content); + }, + .frac => return error.TypeMismatch, + }, + + // If the variable inside an frac with a precision or requirements + .frac_resolved => |a_frac| switch (b_num) { + .frac => |b_frac| if (@intFromEnum(a_frac) == @intFromEnum(b_frac)) { + self.merge(vars, vars.b.desc.content); + } else { + return error.TypeMismatch; + }, + .int => return error.TypeMismatch, + }, + .frac_unbound => |a_reqs| switch (b_num) { + .frac => |b_frac| { + const does_fit = self.checkFracPrecisionRequirements(b_frac, a_reqs); + if (!does_fit) { + return error.NumberDoesNotFit; + } + self.merge(vars, vars.b.desc.content); + }, + .int => return error.TypeMismatch, + }, + + // If the variable inside a wasn't a num, then this in an error + .err => |var_| { + return self.setUnifyErrAndThrow(.{ .invalid_number_type = var_ }); + }, + } + } + + /// Unify when a is compact and b is unbound with requirements + /// Since a is compact, we must merge with it after checking requirements + fn unifyCompactAndUnboundNums( + self: *Self, + vars: *const ResolvedVarDescs, + a_num: NumCompact, + b_reqs: Num.NumRequirements, + ) Error!void { + switch (a_num) { + .int => |a_int| { + const result = self.checkIntPrecisionRequirements(a_int, b_reqs.int_requirements); + switch (result) { + .ok => {}, + .negative_unsigned => return error.NegativeUnsignedInt, + .too_large => return error.NumberDoesNotFit, + } + self.merge(vars, vars.a.desc.content); + }, + .frac => |a_frac| { + const does_fit = self.checkFracPrecisionRequirements(a_frac, b_reqs.frac_requirements); + if (!does_fit) { + return error.NumberDoesNotFit; + } + self.merge(vars, vars.a.desc.content); + }, + } + } + + /// Unify when a is unbound with requirements and b is compact + /// Since b is compact, we must merge with it after checking requirements + fn unifyUnboundAndCompactNums( + self: *Self, + vars: *const ResolvedVarDescs, + a_reqs: Num.NumRequirements, + b_num: NumCompact, + ) Error!void { + switch (b_num) { + .int => |b_int| { + const result = self.checkIntPrecisionRequirements(b_int, a_reqs.int_requirements); + switch (result) { + .ok => {}, + .negative_unsigned => return error.NegativeUnsignedInt, + .too_large => return error.NumberDoesNotFit, + } + self.merge(vars, vars.b.desc.content); + }, + .frac => |b_frac| { + const does_fit = self.checkFracPrecisionRequirements(b_frac, a_reqs.frac_requirements); + if (!does_fit) { + return error.NumberDoesNotFit; + } + self.merge(vars, vars.b.desc.content); + }, } } @@ -1708,14 +1647,97 @@ fn Unifier(comptime StoreTypeB: type) type { } } + // number requirement helpers // + + /// The result of checking if an imprecision is compatible with a set of requirements. + const IntPrecisionCheckResult = enum { + ok, + negative_unsigned, + too_large, + }; + + /// Checks whether a chosen integer precision can satisfy unified IntRequirements + /// under two’s-complement semantics, using only sign_needed, bits_needed, and is_minimum_signed. + /// + /// Rules: + /// - Unsigned N-bit: accept if bits_needed ≤ N. + /// - Signed N-bit: + /// * Positive: accept if bits_needed ≤ N−1. + /// * Negative: accept if (bits_needed ≤ N−1) + /// OR (bits_needed == N AND is_minimum_signed), + /// where the latter covers the single boundary value −2^(N−1). + /// + /// TODO: Review, claude generated + fn checkIntPrecisionRequirements(self: *Self, prec: Num.Int.Precision, reqs: Num.IntRequirements) IntPrecisionCheckResult { + _ = self; + + const is_signed = switch (prec) { + .i8, .i16, .i32, .i64, .i128 => true, + .u8, .u16, .u32, .u64, .u128 => false, + }; + + if (reqs.sign_needed and !is_signed) { + return .negative_unsigned; + } + + const n: u8 = switch (prec) { + .i8, .u8 => 8, + .i16, .u16 => 16, + .i32, .u32 => 32, + .i64, .u64 => 64, + .i128, .u128 => 128, + }; + + const k: u8 = reqs.bits_needed; + + if (!is_signed) { + return if (k <= n) .ok else .too_large; + } + + if (reqs.sign_needed) { + const fits_regular_neg = (k <= n - 1); + const fits_boundary_neg = (k == n) and reqs.is_minimum_signed; // only allow −2^(N−1) + return if (fits_regular_neg or fits_boundary_neg) .ok else .too_large; + } else { + return if (k <= n - 1) .ok else .too_large; + } + } + + /// Checks if the frac precision satisfies the requirements + fn checkFracPrecisionRequirements(self: *Self, prec: Num.Frac.Precision, requirements: Num.FracRequirements) bool { + _ = self; + + switch (prec) { + .f32 => return requirements.fits_in_f32, + .f64 => return true, // F64 can always hold values + .dec => return requirements.fits_in_dec, + } + } + + // polymorphic num helpers // + /// The result of attempting to resolve a polymorphic number const ResolvedNum = union(enum) { - flex_resolved, + num_flex, + num_rigid: Var, + num_unbound: Num.NumRequirements, + int_flex, + int_rigid: Var, + int_unbound: Num.IntRequirements, int_resolved: Num.Int.Precision, + frac_flex, + frac_rigid: Var, + frac_unbound: Num.FracRequirements, frac_resolved: Num.Frac.Precision, err: Var, }; + const ResolvePolyNumCtx = enum { + inside_num, + inside_int, + inside_frac, + }; + /// Attempts to resolve a polymorphic number variable to a concrete precision. /// /// This function recursively follows the structure of a number type, @@ -1726,7 +1748,7 @@ fn Unifier(comptime StoreTypeB: type) type { /// For example: /// Given a type like `Num(Int(U8))`, this function returns `.int_resolved(.u8)`. /// - /// If resolution reaches a `.flex_var`, it returns `.flex_resolved`, + /// If resolution reaches a `.flex`, it returns `.flex_resolved`, /// indicating the number is still unspecialized. /// /// If the chain ends in an invalid structure (e.g. `Num(Str)`), @@ -1736,26 +1758,60 @@ fn Unifier(comptime StoreTypeB: type) type { /// Note that this function will work on the "tail" of a polymorphic number. /// That is, if you pass in `Frac(Dec)` (without the outer `Num`), this /// function will still resolve successfully. - fn resolvePolyNum( - self: *Self, - initial_num_var: Var, - ) ResolvedNum { + fn resolvePolyNum(self: *Self, initial_num_var: Var, initial_ctx: ResolvePolyNumCtx) ResolvedNum { var num_var = initial_num_var; + var seen_int = initial_ctx == .inside_int; + var seen_frac = initial_ctx == .inside_frac; while (true) { const resolved = self.types_store.resolveVar(num_var); switch (resolved.desc.content) { - .flex_var => return .flex_resolved, + .flex => { + if (seen_int and seen_frac) { + return .{ .err = num_var }; + } else if (seen_int) { + return .int_flex; + } else if (seen_frac) { + return .frac_flex; + } else { + return .num_flex; + } + }, + .rigid => { + if (seen_int and seen_frac) { + return .{ .err = num_var }; + } else if (seen_int) { + return .{ .int_rigid = num_var }; + } else if (seen_frac) { + return .{ .frac_rigid = num_var }; + } else { + return .{ .num_rigid = num_var }; + } + }, + .alias => |alias| { + num_var = self.types_store.getAliasBackingVar(alias); + }, .structure => |flat_type| { switch (flat_type) { .num => |num| switch (num) { - .num_poly => |requirements| { - num_var = requirements.var_; + .num_poly => |var_| { + num_var = var_; }, - .int_poly => |requirements| { - num_var = requirements.var_; + .num_unbound => |reqs| { + return .{ .num_unbound = reqs }; }, - .frac_poly => |requirements| { - num_var = requirements.var_; + .int_poly => |var_| { + seen_int = true; + num_var = var_; + }, + .int_unbound => |reqs| { + return .{ .int_unbound = reqs }; + }, + .frac_poly => |var_| { + seen_frac = true; + num_var = var_; + }, + .frac_unbound => |reqs| { + return .{ .frac_unbound = reqs }; }, .int_precision => |prec| { return .{ .int_resolved = prec }; @@ -1925,16 +1981,18 @@ fn Unifier(comptime StoreTypeB: type) type { fn unifyTwoRecords( self: *Self, vars: *const ResolvedVarDescs, - a_record: Record, - b_record: Record, + a_fields: RecordField.SafeMultiList.Range, + a_ext: RecordExt, + b_fields: RecordField.SafeMultiList.Range, + b_ext: RecordExt, ) Error!void { const trace = tracy.trace(@src()); defer trace.end(); // First, unwrap all fields for record, erroring if we encounter an // invalid record ext var - const a_gathered_fields = try self.gatherRecordFields(a_record); - const b_gathered_fields = try self.gatherRecordFields(b_record); + const a_gathered_fields = try self.gatherRecordFields(a_fields, a_ext); + const b_gathered_fields = try self.gatherRecordFields(b_fields, b_ext); // Then partition the fields const partitioned = Self.partitionFields( @@ -1957,11 +2015,24 @@ fn Unifier(comptime StoreTypeB: type) type { fields_ext = .b_extends_a; } + const a_gathered_ext = blk: { + switch (a_gathered_fields.ext) { + .unbound => break :blk self.fresh(vars, .{ .flex = Flex.init() }) catch return Error.AllocatorError, + .ext => |ext_var| break :blk ext_var, + } + }; + const b_gathered_ext = blk: { + switch (b_gathered_fields.ext) { + .unbound => break :blk self.fresh(vars, .{ .flex = Flex.init() }) catch return Error.AllocatorError, + .ext => |ext_var| break :blk ext_var, + } + }; + // Unify fields switch (fields_ext) { .exactly_the_same => { // Unify exts - try self.unifyGuarded(a_gathered_fields.ext, b_gathered_fields.ext); + try self.unifyGuarded(a_gathered_ext, b_gathered_ext); // Unify shared fields // This copies fields from scratch into type_store @@ -1970,7 +2041,7 @@ fn Unifier(comptime StoreTypeB: type) type { self.scratch.in_both_fields.sliceRange(partitioned.in_both), null, null, - a_gathered_fields.ext, + a_gathered_ext, ); }, .a_extends_b => { @@ -1981,11 +2052,11 @@ fn Unifier(comptime StoreTypeB: type) type { ) catch return Error.AllocatorError; const only_in_a_var = self.fresh(vars, Content{ .structure = FlatType{ .record = .{ .fields = only_in_a_fields_range, - .ext = a_gathered_fields.ext, + .ext = a_gathered_ext, } } }) catch return Error.AllocatorError; // Unify the sub record with b's ext - try self.unifyGuarded(only_in_a_var, b_gathered_fields.ext); + try self.unifyGuarded(only_in_a_var, b_gathered_ext); // Unify shared fields // This copies fields from scratch into type_store @@ -2005,11 +2076,11 @@ fn Unifier(comptime StoreTypeB: type) type { ) catch return Error.AllocatorError; const only_in_b_var = self.fresh(vars, Content{ .structure = FlatType{ .record = .{ .fields = only_in_b_fields_range, - .ext = b_gathered_fields.ext, + .ext = b_gathered_ext, } } }) catch return Error.AllocatorError; // Unify the sub record with a's ext - try self.unifyGuarded(a_gathered_fields.ext, only_in_b_var); + try self.unifyGuarded(a_gathered_ext, only_in_b_var); // Unify shared fields // This copies fields from scratch into type_store @@ -2029,7 +2100,7 @@ fn Unifier(comptime StoreTypeB: type) type { ) catch return Error.AllocatorError; const only_in_a_var = self.fresh(vars, Content{ .structure = FlatType{ .record = .{ .fields = only_in_a_fields_range, - .ext = a_gathered_fields.ext, + .ext = a_gathered_ext, } } }) catch return Error.AllocatorError; // Create a new variable of a record with only b's uniq fields @@ -2039,15 +2110,15 @@ fn Unifier(comptime StoreTypeB: type) type { ) catch return Error.AllocatorError; const only_in_b_var = self.fresh(vars, Content{ .structure = FlatType{ .record = .{ .fields = only_in_b_fields_range, - .ext = b_gathered_fields.ext, + .ext = b_gathered_ext, } } }) catch return Error.AllocatorError; // Create a new ext var - const new_ext_var = self.fresh(vars, .{ .flex_var = null }) catch return Error.AllocatorError; + const new_ext_var = self.fresh(vars, .{ .flex = Flex.init() }) catch return Error.AllocatorError; // Unify the sub records with exts - try self.unifyGuarded(a_gathered_fields.ext, only_in_b_var); - try self.unifyGuarded(only_in_a_var, b_gathered_fields.ext); + try self.unifyGuarded(a_gathered_ext, only_in_b_var); + try self.unifyGuarded(only_in_a_var, b_gathered_ext); // Unify shared fields // This copies fields from scratch into type_store @@ -2064,7 +2135,9 @@ fn Unifier(comptime StoreTypeB: type) type { const FieldsExtension = enum { exactly_the_same, a_extends_b, b_extends_a, both_extend }; - const GatheredFields = struct { ext: Var, range: RecordFieldSafeList.Range }; + const RecordExt = union(enum) { ext: Var, unbound }; + + const GatheredFields = struct { ext: RecordExt, range: RecordFieldSafeList.Range }; /// Recursively unwraps the fields of an extensible record, flattening all visible fields /// into `scratch.gathered_fields` and following through: @@ -2076,61 +2149,60 @@ fn Unifier(comptime StoreTypeB: type) type { /// * the final tail extension variable, which is either a flex var or an empty record /// /// Errors if it encounters a malformed or invalid extension (e.g. a non-record type). - fn gatherRecordFields(self: *Self, record: Record) Error!GatheredFields { + fn gatherRecordFields(self: *Self, record_fields: RecordField.SafeMultiList.Range, record_ext: RecordExt) Error!GatheredFields { // first, copy from the store's MultiList record fields array into scratch's // regular list, capturing the insertion range var range = self.scratch.copyGatherFieldsFromMultiList( &self.types_store.record_fields, - record.fields, + record_fields, ) catch return Error.AllocatorError; // then recursiv - var ext_var = record.ext; + var ext = record_ext; while (true) { - switch (self.types_store.resolveVar(ext_var).desc.content) { - .flex_var => { - return .{ .ext = ext_var, .range = range }; + switch (ext) { + .unbound => { + return .{ .ext = ext, .range = range }; }, - .rigid_var => { - return .{ .ext = ext_var, .range = range }; - }, - .alias => |alias| { - ext_var = self.types_store.getAliasBackingVar(alias); - }, - .structure => |flat_type| { - switch (flat_type) { - .record => |ext_record| { - const next_range = self.scratch.copyGatherFieldsFromMultiList( - &self.types_store.record_fields, - ext_record.fields, - ) catch return Error.AllocatorError; - range.count += next_range.count; - ext_var = ext_record.ext; + .ext => |ext_var| { + switch (self.types_store.resolveVar(ext_var).desc.content) { + .flex => { + return .{ .ext = .{ .ext = ext_var }, .range = range }; }, - .record_unbound => |fields| { - const next_range = self.scratch.copyGatherFieldsFromMultiList( - &self.types_store.record_fields, - fields, - ) catch return Error.AllocatorError; - range.count += next_range.count; - // record_unbound has no extension, so we're done - return .{ .ext = ext_var, .range = range }; + .rigid => { + return .{ .ext = .{ .ext = ext_var }, .range = range }; }, - .record_poly => |poly| { - const next_range = self.scratch.copyGatherFieldsFromMultiList( - &self.types_store.record_fields, - poly.record.fields, - ) catch return Error.AllocatorError; - range.count += next_range.count; - ext_var = poly.record.ext; + .alias => |alias| { + ext = .{ .ext = self.types_store.getAliasBackingVar(alias) }; }, - .empty_record => { - return .{ .ext = ext_var, .range = range }; + .structure => |flat_type| { + switch (flat_type) { + .record => |ext_record| { + const next_range = self.scratch.copyGatherFieldsFromMultiList( + &self.types_store.record_fields, + ext_record.fields, + ) catch return Error.AllocatorError; + range.count += next_range.count; + ext = .{ .ext = ext_record.ext }; + }, + .record_unbound => |fields| { + const next_range = self.scratch.copyGatherFieldsFromMultiList( + &self.types_store.record_fields, + fields, + ) catch return Error.AllocatorError; + range.count += next_range.count; + // record_unbound has no extension, so we're done + return .{ .ext = ext, .range = range }; + }, + .empty_record => { + return .{ .ext = ext, .range = range }; + }, + else => try self.setUnifyErrAndThrow(.{ .invalid_record_ext = ext_var }), + } }, else => try self.setUnifyErrAndThrow(.{ .invalid_record_ext = ext_var }), } }, - else => try self.setUnifyErrAndThrow(.{ .invalid_record_ext = ext_var }), } } } @@ -2460,7 +2532,7 @@ fn Unifier(comptime StoreTypeB: type) type { } } }) catch return Error.AllocatorError; // Create a new ext var - const new_ext_var = self.fresh(vars, .{ .flex_var = null }) catch return Error.AllocatorError; + const new_ext_var = self.fresh(vars, .{ .flex = Flex.init() }) catch return Error.AllocatorError; // Unify the sub tag_unions with exts try self.unifyGuarded(a_gathered_tags.ext, only_in_b_var); @@ -2505,10 +2577,10 @@ fn Unifier(comptime StoreTypeB: type) type { var ext_var = tag_union.ext; while (true) { switch (self.types_store.resolveVar(ext_var).desc.content) { - .flex_var => { + .flex => { return .{ .ext = ext_var, .range = range }; }, - .rigid_var => { + .rigid => { return .{ .ext = ext_var, .range = range }; }, .alias => |alias| { @@ -2666,7 +2738,7 @@ fn Unifier(comptime StoreTypeB: type) type { } /// Set error data in scratch & throw - fn setUnifyErrAndThrow(self: *Self, err: UnifyErrCtx) Error!void { + inline fn setUnifyErrAndThrow(self: *Self, err: UnifyErrCtx) Error!void { self.scratch.setUnifyErr(err); return error.UnifyErr; } @@ -2846,11 +2918,13 @@ pub const Scratch = struct { return self.gathered_tags.rangeToEnd(@intCast(start_int)); } - fn appendSliceGatheredFields(self: *Self, fields: []const RecordField) std.mem.Allocator.Error!RecordFieldSafeList.Range { + /// Exposed for tests + pub fn appendSliceGatheredFields(self: *Self, fields: []const RecordField) std.mem.Allocator.Error!RecordFieldSafeList.Range { return try self.gathered_fields.appendSlice(self.gpa, fields); } - fn appendSliceGatheredTags(self: *Self, fields: []const Tag) std.mem.Allocator.Error!TagSafeList.Range { + /// Exposed for tests + pub fn appendSliceGatheredTags(self: *Self, fields: []const Tag) std.mem.Allocator.Error!TagSafeList.Range { return try self.gathered_tags.appendSlice(self.gpa, fields); } @@ -2858,3047 +2932,3 @@ pub const Scratch = struct { self.err = err; } }; - -// tests // - -const RootModule = @This(); - -/// A lightweight test harness used in unification and type inference tests. -/// -/// `TestEnv` bundles together the following components: -/// * a module env for holding things like idents -/// * a type store for registering and resolving types -/// * a reusable `Scratch` buffer for managing field partitions and temporary variables -/// -/// This is intended to simplify unit test setup, particularly for unifying records, -/// functions, aliases, and other structured types. -const TestEnv = struct { - const Self = @This(); - - module_env: *ModuleEnv, - snapshots: snapshot_mod.Store, - problems: problem_mod.Store, - scratch: Scratch, - occurs_scratch: occurs.Scratch, - - /// Init everything needed to test unify - /// This includes allocating module_env on the heap - /// - /// TODO: Is heap allocation unideal here? If we want to optimize tests, we - /// could pull module_env's initialization out of here, but this results in - /// slight more verbose setup for each test - fn init(gpa: std.mem.Allocator) std.mem.Allocator.Error!Self { - const module_env = try gpa.create(ModuleEnv); - module_env.* = try ModuleEnv.init(gpa, try gpa.dupe(u8, "")); - try module_env.initCIRFields(gpa, "Test"); - return .{ - .module_env = module_env, - .snapshots = try snapshot_mod.Store.initCapacity(gpa, 16), - .problems = try problem_mod.Store.initCapacity(gpa, 16), - .scratch = try Scratch.init(module_env.gpa), - .occurs_scratch = try occurs.Scratch.init(module_env.gpa), - }; - } - - /// Deinit the test env, including deallocing the module_env from the heap - fn deinit(self: *Self) void { - self.module_env.deinit(); - self.module_env.gpa.destroy(self.module_env); - self.snapshots.deinit(); - self.problems.deinit(self.module_env.gpa); - self.scratch.deinit(); - self.occurs_scratch.deinit(); - } - - /// Helper function to call unify with args from TestEnv - fn unify(self: *Self, a: Var, b: Var) std.mem.Allocator.Error!Result { - return try RootModule.unify( - self.module_env, - &self.module_env.types, - &self.problems, - &self.snapshots, - &self.scratch, - &self.occurs_scratch, - a, - b, - ); - } - - const Error = error{ VarIsNotRoot, IsNotRecord, IsNotTagUnion }; - - /// Get a desc from a root var - fn getDescForRootVar(self: *Self, var_: Var) error{VarIsNotRoot}!Desc { - switch (self.module_env.types.getSlot(var_)) { - .root => |desc_idx| return self.module_env.types.getDesc(desc_idx), - .redirect => return error.VarIsNotRoot, - } - } - - /// Unwrap a record or throw - fn getRecordOrErr(desc: Desc) error{IsNotRecord}!Record { - return desc.content.unwrapRecord() orelse error.IsNotRecord; - } - - /// Unwrap a record or throw - fn getTagUnionOrErr(desc: Desc) error{IsNotTagUnion}!TagUnion { - return desc.content.unwrapTagUnion() orelse error.IsNotTagUnion; - } - - fn mkTypeIdent(self: *Self, name: []const u8) std.mem.Allocator.Error!TypeIdent { - const ident_idx = try self.module_env.getIdentStore().insert(self.module_env.gpa, Ident.for_text(name)); - return TypeIdent{ .ident_idx = ident_idx }; - } - - // helpers - rigid var - - fn mkRigidVar(self: *Self, name: []const u8) std.mem.Allocator.Error!Content { - const ident_idx = try self.module_env.getIdentStore().insert(self.module_env.gpa, Ident.for_text(name)); - return Self.mkRigidVarFromIdent(ident_idx); - } - - fn mkRigidVarFromIdent(ident_idx: Ident.Idx) Content { - return .{ .rigid_var = ident_idx }; - } - - // helpers - alias - - fn mkAlias(self: *Self, name: []const u8, backing_var: Var, args: []const Var) std.mem.Allocator.Error!Content { - return try self.module_env.types.mkAlias(try self.mkTypeIdent(name), backing_var, args); - } - - // helpers - nums - - fn mkNum(self: *Self, var_: Var) std.mem.Allocator.Error!Var { - const requirements = Num.IntRequirements{ - .sign_needed = false, - .bits_needed = 0, - }; - return try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_poly = .{ .var_ = var_, .requirements = requirements } } } }); - } - - fn mkNumFlex(self: *Self) std.mem.Allocator.Error!Var { - // Create a true flex var that can unify with any numeric type - return try self.module_env.types.fresh(); - } - - fn mkFrac(self: *Self, var_: Var) std.mem.Allocator.Error!Var { - const frac_requirements = Num.FracRequirements{ - .var_ = var_, - .fits_in_f32 = true, - .fits_in_dec = true, - }; - return try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .frac_poly = frac_requirements } } }); - } - - fn mkFracFlex(self: *Self) std.mem.Allocator.Error!Var { - const prec_var = try self.module_env.types.fresh(); - const frac_requirements = Num.FracRequirements{ - .fits_in_f32 = true, - .fits_in_dec = true, - }; - return try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .frac_poly = .{ .var_ = prec_var, .requirements = frac_requirements } } } }); - } - - fn mkFracRigid(self: *Self, name: []const u8) std.mem.Allocator.Error!Var { - const rigid = try self.module_env.types.freshFromContent(try self.mkRigidVar(name)); - const frac_requirements = Num.FracRequirements{ - .fits_in_f32 = true, - .fits_in_dec = true, - }; - return try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .frac_poly = .{ .var_ = rigid, .requirements = frac_requirements } } } }); - } - - fn mkFracPoly(self: *Self, prec: Num.Frac.Precision) std.mem.Allocator.Error!Var { - const prec_var = try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .frac_precision = prec } } }); - const frac_requirements = Num.FracRequirements{ - .fits_in_f32 = true, - .fits_in_dec = true, - }; - return try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .frac_poly = .{ .var_ = prec_var, .requirements = frac_requirements } } } }); - } - - fn mkFracExact(self: *Self, prec: Num.Frac.Precision) std.mem.Allocator.Error!Var { - // Create an exact fraction type that only unifies with the same precision - return try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .frac_precision = prec } } }); - } - - fn mkInt(self: *Self, var_: Var) std.mem.Allocator.Error!Var { - const int_requirements = Num.IntRequirements{ - .sign_needed = false, - .bits_needed = 0, // 7 bits, the minimum - }; - return try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_poly = .{ .var_ = var_, .requirements = int_requirements } } } }); - } - - fn mkIntFlex(self: *Self) std.mem.Allocator.Error!Var { - const prec_var = try self.module_env.types.fresh(); - const int_requirements = Num.IntRequirements{ - .sign_needed = false, - .bits_needed = 0, // 7 bits, the minimum - }; - return try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_poly = .{ .var_ = prec_var, .requirements = int_requirements } } } }); - } - - fn mkIntRigid(self: *Self, name: []const u8) std.mem.Allocator.Error!Var { - const rigid = try self.module_env.types.freshFromContent(try self.mkRigidVar(name)); - const int_requirements = Num.IntRequirements{ - .sign_needed = false, - .bits_needed = 0, // 7 bits, the minimum - }; - return try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_poly = .{ .var_ = rigid, .requirements = int_requirements } } } }); - } - - fn mkIntPoly(self: *Self, prec: Num.Int.Precision) std.mem.Allocator.Error!Var { - const prec_var = try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .int_precision = prec } } }); - const int_requirements = Num.IntRequirements{ - .sign_needed = false, - .bits_needed = 0, // 7 bits, the minimum - }; - return try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .int_poly = .{ .var_ = prec_var, .requirements = int_requirements } } } }); - } - - fn mkIntExact(self: *Self, prec: Num.Int.Precision) std.mem.Allocator.Error!Var { - // Create an exact integer type that only unifies with the same precision - return try self.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .int_precision = prec } } }); - } - - // helpers - structure - tuple - - fn mkTuple(self: *Self, slice: []const Var) std.mem.Allocator.Error!Content { - const elems_range = try self.module_env.types.appendVars(slice); - return Content{ .structure = .{ .tuple = .{ .elems = elems_range } } }; - } - - // helpers - nominal type - - fn mkNominalType(self: *Self, name: []const u8, backing_var: Var, args: []const Var) std.mem.Allocator.Error!Content { - return try self.module_env.types.mkNominal( - try self.mkTypeIdent(name), - backing_var, - args, - Ident.Idx{ .attributes = .{ .effectful = false, .ignored = false, .reassignable = false }, .idx = 0 }, - ); - } - - // helpers - structure - func - - fn mkFuncPure(self: *Self, args: []const Var, ret: Var) std.mem.Allocator.Error!Content { - return try self.module_env.types.mkFuncPure(args, ret); - } - - fn mkFuncEffectful(self: *Self, args: []const Var, ret: Var) std.mem.Allocator.Error!Content { - return try self.module_env.types.mkFuncEffectful(args, ret); - } - - fn mkFuncUnbound(self: *Self, args: []const Var, ret: Var) std.mem.Allocator.Error!Content { - return try self.module_env.types.mkFuncUnbound(args, ret); - } - - fn mkFuncFlex(self: *Self, args: []const Var, ret: Var) std.mem.Allocator.Error!Content { - // For flex functions, we use unbound since we don't know the effectfulness yet - return try self.module_env.types.mkFuncUnbound(args, ret); - } - - // helpers - structure - records - - fn mkRecordField(self: *Self, name: []const u8, var_: Var) std.mem.Allocator.Error!RecordField { - const ident_idx = try self.module_env.getIdentStore().insert(self.module_env.gpa, Ident.for_text(name)); - return Self.mkRecordFieldFromIdent(ident_idx, var_); - } - - fn mkRecordFieldFromIdent(ident_idx: Ident.Idx, var_: Var) RecordField { - return RecordField{ .name = ident_idx, .var_ = var_ }; - } - - const RecordInfo = struct { record: Record, content: Content }; - - fn mkRecord(self: *Self, fields: []const RecordField, ext_var: Var) std.mem.Allocator.Error!RecordInfo { - const fields_range = try self.module_env.types.appendRecordFields(fields); - const record = Record{ .fields = fields_range, .ext = ext_var }; - return .{ .content = Content{ .structure = .{ .record = record } }, .record = record }; - } - - fn mkRecordOpen(self: *Self, fields: []const RecordField) std.mem.Allocator.Error!RecordInfo { - const ext_var = try self.module_env.types.freshFromContent(.{ .flex_var = null }); - return self.mkRecord(fields, ext_var); - } - - fn mkRecordClosed(self: *Self, fields: []const RecordField) std.mem.Allocator.Error!RecordInfo { - const ext_var = try self.module_env.types.freshFromContent(.{ .structure = .empty_record }); - return self.mkRecord(fields, ext_var); - } - - // helpers - structure - tag union - - const TagUnionInfo = struct { tag_union: TagUnion, content: Content }; - - fn mkTagArgs(self: *Self, args: []const Var) std.mem.Allocator.Error!VarSafeList.Range { - return try self.module_env.types.appendVars(args); - } - - fn mkTag(self: *Self, name: []const u8, args: []const Var) std.mem.Allocator.Error!Tag { - const ident_idx = try self.module_env.getIdentStore().insert(self.module_env.gpa, Ident.for_text(name)); - return Tag{ .name = ident_idx, .args = try self.module_env.types.appendVars(args) }; - } - - fn mkTagUnion(self: *Self, tags: []const Tag, ext_var: Var) std.mem.Allocator.Error!TagUnionInfo { - const tags_range = try self.module_env.types.appendTags(tags); - const tag_union = TagUnion{ .tags = tags_range, .ext = ext_var }; - return .{ .content = Content{ .structure = .{ .tag_union = tag_union } }, .tag_union = tag_union }; - } - - fn mkTagUnionOpen(self: *Self, tags: []const Tag) std.mem.Allocator.Error!TagUnionInfo { - const ext_var = try self.module_env.types.freshFromContent(.{ .flex_var = null }); - return self.mkTagUnion(tags, ext_var); - } - - fn mkTagUnionClosed(self: *Self, tags: []const Tag) std.mem.Allocator.Error!TagUnionInfo { - const ext_var = try self.module_env.types.freshFromContent(.{ .structure = .empty_tag_union }); - return self.mkTagUnion(tags, ext_var); - } -}; - -// unification - flex_vars - -// test "unify - identical" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const a = try env.module_env.types.fresh(); -// const desc = try env.getDescForRootVar(a); - -// const result = try env.unify(a, a); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(desc, try env.getDescForRootVar(a)); -// } - -// test "unify - both flex vars" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const a = try env.module_env.types.fresh(); -// const b = try env.module_env.types.fresh(); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// } - -// test "unify - a is flex_var and b is not" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const a = try env.module_env.types.fresh(); -// const b = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i8 } }); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// } - -// // unification - rigid - -// test "rigid_var - unifies with flex_var" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const rigid = try env.mkRigidVar("a"); -// const a = try env.module_env.types.freshFromContent(.{ .flex_var = null }); -// const b = try env.module_env.types.freshFromContent(rigid); - -// const result = try env.unify(a, b); -// try std.testing.expectEqual(true, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(rigid, (try env.getDescForRootVar(b)).content); -// } - -// test "rigid_var - unifies with flex_var (other way)" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const rigid = try env.mkRigidVar("a"); -// const a = try env.module_env.types.freshFromContent(rigid); -// const b = try env.module_env.types.freshFromContent(.{ .flex_var = null }); - -// const result = try env.unify(a, b); -// try std.testing.expectEqual(true, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(rigid, (try env.getDescForRootVar(b)).content); -// } - -// test "rigid_var - cannot unify with alias (fail)" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const alias = try env.module_env.types.freshFromContent(Content{ .structure = .str }); -// const rigid = try env.module_env.types.freshFromContent(try env.mkRigidVar("a")); - -// const result = try env.unify(alias, rigid); -// try std.testing.expectEqual(false, result.isOk()); -// } - -// test "rigid_var - cannot unify with identical ident str (fail)" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const rigid1 = try env.module_env.types.freshFromContent(try env.mkRigidVar("a")); -// const rigid2 = try env.module_env.types.freshFromContent(try env.mkRigidVar("a")); - -// const result = try env.unify(rigid1, rigid2); -// try std.testing.expectEqual(false, result.isOk()); -// } - -// // unification - aliases - -// test "unify - alias with same args" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); -// const bool_ = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i8 } }); - -// // Create alias `a` with its backing var and args in sequence -// const a_backing_var = try env.module_env.types.freshFromContent(try env.mkTuple(&[_]Var{ str, bool_ })); -// const a_alias = try env.mkAlias("AliasName", a_backing_var, &[_]Var{ str, bool_ }); -// const a = try env.module_env.types.freshFromContent(a_alias); - -// // Create alias `b` with its backing var and args in sequence -// const b_backing_var = try env.module_env.types.freshFromContent(try env.mkTuple(&[_]Var{ str, bool_ })); -// const b_alias = try env.mkAlias("AliasName", b_backing_var, &[_]Var{ str, bool_ }); -// const b = try env.module_env.types.freshFromContent(b_alias); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(b_alias, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - aliases with different names but same backing" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); - -// // Create alias `a` with its backing var and arg -// const a_backing_var = try env.module_env.types.freshFromContent(try env.mkTuple(&[_]Var{str})); -// const a_alias = try env.mkAlias("AliasA", a_backing_var, &[_]Var{str}); -// const a = try env.module_env.types.freshFromContent(a_alias); - -// // Create alias `b` with its backing var and arg -// const b_backing_var = try env.module_env.types.freshFromContent(try env.mkTuple(&[_]Var{str})); -// const b_alias = try env.mkAlias("AliasB", b_backing_var, &[_]Var{str}); -// const b = try env.module_env.types.freshFromContent(b_alias); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(a_alias, (try env.getDescForRootVar(a)).content); -// try std.testing.expectEqual(b_alias, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - alias with different args (fail)" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); -// const bool_ = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i8 } }); - -// // Create alias `a` with its backing var and arg -// const a_backing_var = try env.module_env.types.freshFromContent(try env.mkTuple(&[_]Var{ str, bool_ })); -// const a_alias = try env.mkAlias("Alias", a_backing_var, &[_]Var{str}); -// const a = try env.module_env.types.freshFromContent(a_alias); - -// // Create alias `b` with its backing var and arg -// const b_backing_var = try env.module_env.types.freshFromContent(try env.mkTuple(&[_]Var{ str, bool_ })); -// const b_alias = try env.mkAlias("Alias", b_backing_var, &[_]Var{bool_}); -// const b = try env.module_env.types.freshFromContent(b_alias); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - alias with flex" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); -// const bool_ = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i8 } }); - -// const a_backing_var = try env.module_env.types.freshFromContent(try env.mkTuple(&[_]Var{ str, bool_ })); // backing var -// const a_alias = try env.mkAlias("Alias", a_backing_var, &[_]Var{bool_}); - -// const a = try env.module_env.types.freshFromContent(a_alias); -// const b = try env.module_env.types.fresh(); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(a_alias, (try env.getDescForRootVar(b)).content); -// } - -// // unification - structure/flex_vars - -// test "unify - a is builtin and b is flex_var" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = Content{ .structure = .str }; - -// const a = try env.module_env.types.freshFromContent(str); -// const b = try env.module_env.types.fresh(); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(str, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - a is flex_var and b is builtin" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = Content{ .structure = .str }; - -// const a = try env.module_env.types.fresh(); -// const b = try env.module_env.types.freshFromContent(str); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(str, (try env.getDescForRootVar(b)).content); -// } - -// // unification - structure/structure - builtin - -// test "unify - a & b are both str" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = Content{ .structure = .str }; - -// const a = try env.module_env.types.freshFromContent(str); -// const b = try env.module_env.types.freshFromContent(str); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(str, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - a & b are diff (fail)" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = Content{ .structure = .str }; -// const int = Content{ .structure = .{ .num = Num.int_i8 } }; - -// const a = try env.module_env.types.freshFromContent(int); -// const b = try env.module_env.types.freshFromContent(str); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - a & b box with same arg unify" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = Content{ .structure = .str }; -// const str_var = try env.module_env.types.freshFromContent(str); - -// const box_str = Content{ .structure = .{ .box = str_var } }; - -// const a = try env.module_env.types.freshFromContent(box_str); -// const b = try env.module_env.types.freshFromContent(box_str); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(box_str, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - a & b box with diff args (fail)" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = Content{ .structure = .str }; -// const str_var = try env.module_env.types.freshFromContent(str); - -// const i64_ = Content{ .structure = .{ .num = Num.int_i64 } }; -// const i64_var = try env.module_env.types.freshFromContent(i64_); - -// const box_str = Content{ .structure = .{ .box = str_var } }; -// const box_i64 = Content{ .structure = .{ .box = i64_var } }; - -// const a = try env.module_env.types.freshFromContent(box_str); -// const b = try env.module_env.types.freshFromContent(box_i64); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - a & b list with same arg unify" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = Content{ .structure = .str }; -// const str_var = try env.module_env.types.freshFromContent(str); - -// const list_str = Content{ .structure = .{ .list = str_var } }; - -// const a = try env.module_env.types.freshFromContent(list_str); -// const b = try env.module_env.types.freshFromContent(list_str); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(list_str, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - a & b list with diff args (fail)" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = Content{ .structure = .str }; -// const str_var = try env.module_env.types.freshFromContent(str); - -// const u8_ = Content{ .structure = .{ .num = Num.int_u8 } }; -// const u8_var = try env.module_env.types.freshFromContent(u8_); - -// const list_str = Content{ .structure = .{ .list = str_var } }; -// const list_u8 = Content{ .structure = .{ .list = u8_var } }; - -// const a = try env.module_env.types.freshFromContent(list_str); -// const b = try env.module_env.types.freshFromContent(list_u8); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); -// } - -// // unification - structure/structure - tuple - -// test "unify - a & b are same tuple" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = Content{ .structure = .str }; -// const str_var = try env.module_env.types.freshFromContent(str); - -// const bool_ = Content{ .structure = .{ .num = Num.int_i8 } }; -// const bool_var = try env.module_env.types.freshFromContent(bool_); - -// const tuple_str_bool = try env.mkTuple(&[_]Var{ str_var, bool_var }); - -// const a = try env.module_env.types.freshFromContent(tuple_str_bool); -// const b = try env.module_env.types.freshFromContent(tuple_str_bool); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(tuple_str_bool, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - a & b are tuples with args flipped (fail)" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = Content{ .structure = .str }; -// const str_var = try env.module_env.types.freshFromContent(str); - -// const bool_ = Content{ .structure = .{ .num = Num.int_i8 } }; -// const bool_var = try env.module_env.types.freshFromContent(bool_); - -// const tuple_str_bool = try env.mkTuple(&[_]Var{ str_var, bool_var }); -// const tuple_bool_str = try env.mkTuple(&[_]Var{ bool_var, str_var }); - -// const a = try env.module_env.types.freshFromContent(tuple_str_bool); -// const b = try env.module_env.types.freshFromContent(tuple_bool_str); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); -// } - -// // unification - structure/structure - compact/compact - -// test "unify - two compact ints" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const int_i32 = Content{ .structure = .{ .num = Num.int_i32 } }; -// const a = try env.module_env.types.freshFromContent(int_i32); -// const b = try env.module_env.types.freshFromContent(int_i32); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(int_i32, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - two compact ints (fail)" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const a = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i32 } }); -// const b = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u8 } }); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - two compact fracs" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const frac_f32 = Content{ .structure = .{ .num = Num.frac_f32 } }; -// const a = try env.module_env.types.freshFromContent(frac_f32); -// const b = try env.module_env.types.freshFromContent(frac_f32); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(frac_f32, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - two compact fracs (fail)" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const a = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.frac_f32 } }); -// const b = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.frac_dec } }); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); -// } - -// // unification - structure/structure - poly/poly - -// test "unify - two poly ints" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const a = try env.mkIntPoly(Num.Int.Precision.u8); -// const b = try env.mkIntPoly(Num.Int.Precision.u8); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// } - -// test "unify - two poly ints (fail)" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const a = try env.mkIntPoly(Num.Int.Precision.u8); -// const b = try env.mkIntPoly(Num.Int.Precision.i128); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - two poly fracs" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const a = try env.mkFracPoly(Num.Frac.Precision.f64); -// const b = try env.mkFracPoly(Num.Frac.Precision.f64); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// } - -// test "unify - two poly fracs (fail)" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const a = try env.mkFracPoly(Num.Frac.Precision.f32); -// const b = try env.mkFracPoly(Num.Frac.Precision.f64); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); -// } - -// // unification - structure/structure - poly/compact_int - -// test "unify - Num(flex) and compact int" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const int_i32 = Content{ .structure = .{ .num = Num.int_i32 } }; -// const a = try env.mkNumFlex(); -// const b = try env.module_env.types.freshFromContent(int_i32); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(int_i32, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - Num(Int(flex)) and compact int" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const int_i32 = Content{ .structure = .{ .num = Num.int_i32 } }; -// const a = try env.mkIntFlex(); -// const b = try env.module_env.types.freshFromContent(int_i32); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(int_i32, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - Num(Int(U8)) and compact int U8" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const int_u8 = Content{ .structure = .{ .num = Num.int_u8 } }; -// const a = try env.mkIntExact(Num.Int.Precision.u8); -// const b = try env.module_env.types.freshFromContent(int_u8); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(int_u8, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - Num(Int(U8)) and compact int I32 (fails)" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const int_i32 = Content{ .structure = .{ .num = Num.int_i32 } }; -// const a = try env.mkIntExact(Num.Int.Precision.u8); -// const b = try env.module_env.types.freshFromContent(int_i32); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); -// } - -// // unification - structure/structure - poly/compact_frac - -// test "unify - Num(flex) and compact frac" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const frac_f32 = Content{ .structure = .{ .num = Num.frac_f32 } }; -// const a = try env.mkNumFlex(); -// const b = try env.module_env.types.freshFromContent(frac_f32); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(frac_f32, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - Num(Frac(flex)) and compact frac" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const frac_f32 = Content{ .structure = .{ .num = Num.frac_f32 } }; -// const a = try env.mkFracFlex(); -// const b = try env.module_env.types.freshFromContent(frac_f32); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(frac_f32, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - Num(Frac(Dec)) and compact frac Dec" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const frac_dec = Content{ .structure = .{ .num = Num.frac_dec } }; -// const a = try env.mkFracExact(Num.Frac.Precision.dec); -// const b = try env.module_env.types.freshFromContent(frac_dec); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(frac_dec, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - Num(Frac(F32)) and compact frac Dec (fails)" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const frac_f32 = Content{ .structure = .{ .num = Num.frac_f32 } }; -// const a = try env.mkFracExact(Num.Frac.Precision.dec); -// const b = try env.module_env.types.freshFromContent(frac_f32); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); -// } - -// // unification - structure/structure - compact_int/poly - -// test "unify - compact int and Num(flex)" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const int_i32 = Content{ .structure = .{ .num = Num.int_i32 } }; -// const a = try env.module_env.types.freshFromContent(int_i32); -// const b = try env.mkNumFlex(); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(int_i32, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - compact int and Num(Int(flex))" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const int_i32 = Content{ .structure = .{ .num = Num.int_i32 } }; -// const a = try env.module_env.types.freshFromContent(int_i32); -// const b = try env.mkIntFlex(); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(int_i32, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - compact int and U8 Num(Int(U8))" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const int_u8 = Content{ .structure = .{ .num = Num.int_u8 } }; -// const a = try env.module_env.types.freshFromContent(int_u8); -// const b = try env.mkIntExact(Num.Int.Precision.u8); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(int_u8, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - compact int U8 and Num(Int(I32)) (fails)" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const int_i32 = Content{ .structure = .{ .num = Num.int_i32 } }; -// const a = try env.module_env.types.freshFromContent(int_i32); -// const b = try env.mkIntExact(Num.Int.Precision.u8); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); -// } - -// // unification - structure/structure - compact_frac/poly - -// test "unify - compact frac and Num(flex)" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const frac_f32 = Content{ .structure = .{ .num = Num.frac_f32 } }; -// const a = try env.module_env.types.freshFromContent(frac_f32); -// const b = try env.mkNumFlex(); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(frac_f32, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - compact frac and Num(Frac(flex))" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const frac_f32 = Content{ .structure = .{ .num = Num.frac_f32 } }; -// const a = try env.module_env.types.freshFromContent(frac_f32); -// const b = try env.mkFracFlex(); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(frac_f32, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - compact frac and Dec Num(Frac(Dec))" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const frac_dec = Content{ .structure = .{ .num = Num.frac_dec } }; -// const a = try env.module_env.types.freshFromContent(frac_dec); -// const b = try env.mkFracExact(Num.Frac.Precision.dec); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(frac_dec, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - compact frac Dec and Num(Frac(F32)) (fails)" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const frac_f32 = Content{ .structure = .{ .num = Num.frac_f32 } }; -// const a = try env.module_env.types.freshFromContent(frac_f32); -// const b = try env.mkFracExact(Num.Frac.Precision.dec); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); -// } - -// // unification - structure/structure - poly/poly rigid - -// test "unify - Num(rigid) and Num(rigid)" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const rigid = try env.module_env.types.freshFromContent(try env.mkRigidVar("b")); -// const requirements = Num.IntRequirements{ -// .sign_needed = false, -// .bits_needed = 0, -// }; -// const num = Content{ .structure = .{ .num = .{ .num_poly = .{ .var_ = rigid, .requirements = requirements } } } }; -// const a = try env.module_env.types.freshFromContent(num); -// const b = try env.module_env.types.freshFromContent(num); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(true, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(num, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - Num(rigid_a) and Num(rigid_b)" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const rigid_a = try env.module_env.types.freshFromContent(try env.mkRigidVar("a")); -// const rigid_b = try env.module_env.types.freshFromContent(try env.mkRigidVar("b")); - -// const int_requirements = Num.IntRequirements{ -// .sign_needed = false, -// .bits_needed = 0, -// }; -// const a = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_poly = .{ .var_ = rigid_a, .requirements = int_requirements } } } }); -// const b = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_poly = .{ .var_ = rigid_b, .requirements = int_requirements } } } }); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - Num(Int(rigid)) and Num(Int(rigid))" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const rigid = try env.module_env.types.freshFromContent(try env.mkRigidVar("b")); -// const int_requirements = Num.IntRequirements{ -// .sign_needed = false, -// .bits_needed = 0, -// }; -// _ = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .int_poly = .{ .var_ = rigid, .requirements = int_requirements } } } }); -// const num = Content{ .structure = .{ .num = .{ .num_poly = .{ .var_ = rigid, .requirements = int_requirements } } } }; -// const a = try env.module_env.types.freshFromContent(num); -// const b = try env.module_env.types.freshFromContent(num); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(true, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(num, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - Num(Frac(rigid)) and Num(Frac(rigid))" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const rigid = try env.module_env.types.freshFromContent(try env.mkRigidVar("b")); -// const frac_requirements = Num.FracRequirements{ -// .fits_in_f32 = true, -// .fits_in_dec = true, -// }; -// const frac_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .frac_poly = .{ .var_ = rigid, .requirements = frac_requirements } } } }); -// const int_requirements = Num.IntRequirements{ -// .sign_needed = false, -// .bits_needed = 0, -// }; -// const num = Content{ .structure = .{ .num = .{ .num_poly = .{ .var_ = frac_var, .requirements = int_requirements } } } }; -// const a = try env.module_env.types.freshFromContent(num); -// const b = try env.module_env.types.freshFromContent(num); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(true, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(num, (try env.getDescForRootVar(b)).content); -// } - -// // unification - structure/structure - compact/poly rigid - -// test "unify - compact int U8 and Num(Int(rigid)) (fails)" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const int_u8 = Content{ .structure = .{ .num = Num.int_u8 } }; -// const a = try env.module_env.types.freshFromContent(int_u8); -// const b = try env.mkFracRigid("a"); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - compact frac Dec and Num(Frac(rigid)) (fails)" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const frac_f32 = Content{ .structure = .{ .num = Num.frac_f32 } }; -// const a = try env.module_env.types.freshFromContent(frac_f32); -// const b = try env.mkFracRigid("a"); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); -// } - -// // unification - structure/structure - poly/compact rigid - -// test "unify - Num(Int(rigid)) and compact int U8 (fails)" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const int_u8 = Content{ .structure = .{ .num = Num.int_u8 } }; -// const a = try env.mkFracRigid("a"); -// const b = try env.module_env.types.freshFromContent(int_u8); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - Num(Frac(rigid)) and compact frac Dec (fails)" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const frac_f32 = Content{ .structure = .{ .num = Num.frac_f32 } }; -// const a = try env.mkFracRigid("a"); -// const b = try env.module_env.types.freshFromContent(frac_f32); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); -// } - -// // unification - structure/structure - func - -// test "unify - func are same" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const int_i32 = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i32 } }); -// const num_flex = try env.module_env.types.fresh(); -// const requirements = Num.IntRequirements{ -// .sign_needed = false, -// .bits_needed = 0, -// }; -// const num = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_poly = .{ .var_ = num_flex, .requirements = requirements } } } }); -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); -// const func = try env.mkFuncFlex(&[_]Var{ str, num }, int_i32); - -// const a = try env.module_env.types.freshFromContent(func); -// const b = try env.module_env.types.freshFromContent(func); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(func, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - funcs have diff return args (fail)" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const int_i32 = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i32 } }); -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); - -// const a = try env.module_env.types.freshFromContent(try env.mkFuncFlex(&[_]Var{int_i32}, str)); -// const b = try env.module_env.types.freshFromContent(try env.mkFuncFlex(&[_]Var{str}, str)); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - funcs have diff return types (fail)" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const int_i32 = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i32 } }); -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); - -// const a = try env.module_env.types.freshFromContent(try env.mkFuncFlex(&[_]Var{str}, int_i32)); -// const b = try env.module_env.types.freshFromContent(try env.mkFuncFlex(&[_]Var{str}, str)); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - same funcs pure" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const int_i32 = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i32 } }); -// const int_poly_var = try env.module_env.types.fresh(); -// const int_requirements = Num.IntRequirements{ -// .sign_needed = false, -// .bits_needed = 0, -// }; -// const int_poly = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .int_poly = .{ .var_ = int_poly_var, .requirements = int_requirements } } } }); -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); -// const func = try env.mkFuncPure(&[_]Var{ str, int_poly }, int_i32); - -// const a = try env.module_env.types.freshFromContent(func); -// const b = try env.module_env.types.freshFromContent(func); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(func, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - same funcs effectful" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const int_i32 = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i32 } }); -// const int_poly_var = try env.module_env.types.fresh(); -// const int_requirements = Num.IntRequirements{ -// .sign_needed = false, -// .bits_needed = 0, -// }; -// const int_poly = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .int_poly = .{ .var_ = int_poly_var, .requirements = int_requirements } } } }); -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); -// const func = try env.mkFuncEffectful(&[_]Var{ str, int_poly }, int_i32); - -// const a = try env.module_env.types.freshFromContent(func); -// const b = try env.module_env.types.freshFromContent(func); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(func, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - same funcs first eff, second pure (fail)" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const int_i32 = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i32 } }); -// const int_poly_var = try env.module_env.types.fresh(); -// const int_requirements = Num.IntRequirements{ -// .sign_needed = false, -// .bits_needed = 0, -// }; -// const int_poly = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .int_poly = .{ .var_ = int_poly_var, .requirements = int_requirements } } } }); -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); -// const pure_func = try env.mkFuncPure(&[_]Var{ str, int_poly }, int_i32); -// const eff_func = try env.mkFuncEffectful(&[_]Var{ str, int_poly }, int_i32); - -// const a = try env.module_env.types.freshFromContent(eff_func); -// const b = try env.module_env.types.freshFromContent(pure_func); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - same funcs first pure, second eff" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const int_i32 = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i32 } }); -// const int_poly_var = try env.module_env.types.fresh(); -// const int_requirements = Num.IntRequirements{ -// .sign_needed = false, -// .bits_needed = 0, -// }; -// const int_poly = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .int_poly = .{ .var_ = int_poly_var, .requirements = int_requirements } } } }); -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); -// const pure_func = try env.mkFuncPure(&[_]Var{ str, int_poly }, int_i32); -// const eff_func = try env.mkFuncEffectful(&[_]Var{ str, int_poly }, int_i32); - -// const a = try env.module_env.types.freshFromContent(pure_func); -// const b = try env.module_env.types.freshFromContent(eff_func); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(false, result.isOk()); -// } - -// test "unify - first is flex, second is func" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const tag_payload = try env.module_env.types.fresh(); -// const tag = try env.mkTag("Some", &[_]Var{tag_payload}); -// const backing_var = try env.module_env.types.freshFromContent((try env.mkTagUnionOpen(&[_]Tag{tag})).content); -// const nominal_type = try env.module_env.types.freshFromContent(try env.mkNominalType("List", backing_var, &[_]Var{})); -// const arg = try env.module_env.types.fresh(); -// const func = try env.mkFuncUnbound(&[_]Var{arg}, nominal_type); - -// const a = try env.module_env.types.fresh(); -// const b = try env.module_env.types.freshFromContent(func); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(true, result.isOk()); -// } - -// // unification - structure/structure - nominal type - -// test "unify - a & b are both the same nominal type" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const arg = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u8 } }); - -// const a_backing_var = try env.module_env.types.freshFromContent(Content{ .structure = .str }); -// const a = try env.module_env.types.freshFromContent(try env.mkNominalType("MyType", a_backing_var, &[_]Var{arg})); - -// const b_backing_var = try env.module_env.types.freshFromContent(Content{ .structure = .str }); -// const b_nominal = try env.mkNominalType("MyType", b_backing_var, &[_]Var{arg}); -// const b = try env.module_env.types.freshFromContent(b_nominal); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(b_nominal, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - a & b are diff nominal types (fail)" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const arg = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u8 } }); - -// const a_backing_var = try env.module_env.types.freshFromContent(Content{ .structure = .str }); -// const a = try env.module_env.types.freshFromContent(try env.mkNominalType("MyType", a_backing_var, &[_]Var{arg})); - -// const b_backing_var = try env.module_env.types.freshFromContent(Content{ .structure = .str }); -// const b = try env.module_env.types.freshFromContent(try env.mkNominalType("AnotherType", b_backing_var, &[_]Var{arg})); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - a & b are both the same nominal type with diff args (fail)" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const arg_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u8 } }); -// const str_var = try env.module_env.types.freshFromContent(Content{ .structure = .str }); - -// const a_backing = try env.module_env.types.freshFromContent(Content{ .structure = .str }); -// const a = try env.module_env.types.freshFromContent(try env.mkNominalType("MyType", a_backing, &[_]Var{arg_var})); - -// const b_backing = try env.module_env.types.freshFromContent(Content{ .structure = .str }); -// const b = try env.module_env.types.freshFromContent(try env.mkNominalType("MyType", b_backing, &[_]Var{str_var})); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(.err, (try env.getDescForRootVar(b)).content); -// } - -// // unification - records - partition fields - -// test "partitionFields - same record" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const field_x = try env.mkRecordField("field_x", @enumFromInt(0)); -// const field_y = try env.mkRecordField("field_y", @enumFromInt(1)); - -// const range = try env.scratch.appendSliceGatheredFields(&[_]RecordField{ field_x, field_y }); - -// const result = try partitionFields(&env.module_env.getIdentStore(), &env.scratch, range, range); - -// try std.testing.expectEqual(0, result.only_in_a.len()); -// try std.testing.expectEqual(0, result.only_in_b.len()); -// try std.testing.expectEqual(2, result.in_both.len()); - -// const both_slice = env.scratch.in_both_fields.sliceRange(result.in_both); -// try std.testing.expectEqual(field_x, both_slice[0].a); -// try std.testing.expectEqual(field_x, both_slice[0].b); -// try std.testing.expectEqual(field_y, both_slice[1].a); -// try std.testing.expectEqual(field_y, both_slice[1].b); -// } - -// test "partitionFields - disjoint fields" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const a1 = try env.mkRecordField("a1", @enumFromInt(0)); -// const a2 = try env.mkRecordField("a2", @enumFromInt(1)); -// const b1 = try env.mkRecordField("b1", @enumFromInt(2)); - -// const a_range = try env.scratch.appendSliceGatheredFields(&[_]RecordField{ a1, a2 }); -// const b_range = try env.scratch.appendSliceGatheredFields(&[_]RecordField{b1}); - -// const result = try partitionFields(&env.module_env.getIdentStore(), &env.scratch, a_range, b_range); - -// try std.testing.expectEqual(2, result.only_in_a.len()); -// try std.testing.expectEqual(1, result.only_in_b.len()); -// try std.testing.expectEqual(0, result.in_both.len()); - -// const only_in_a_slice = env.scratch.only_in_a_fields.sliceRange(result.only_in_a); -// try std.testing.expectEqual(a1, only_in_a_slice[0]); -// try std.testing.expectEqual(a2, only_in_a_slice[1]); - -// const only_in_b_slice = env.scratch.only_in_b_fields.sliceRange(result.only_in_b); -// try std.testing.expectEqual(b1, only_in_b_slice[0]); -// } - -// test "partitionFields - overlapping fields" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const a1 = try env.mkRecordField("a1", @enumFromInt(0)); -// const both = try env.mkRecordField("both", @enumFromInt(1)); -// const b1 = try env.mkRecordField("b1", @enumFromInt(2)); - -// const a_range = try env.scratch.appendSliceGatheredFields(&[_]RecordField{ a1, both }); -// const b_range = try env.scratch.appendSliceGatheredFields(&[_]RecordField{ b1, both }); - -// const result = try partitionFields(&env.module_env.getIdentStore(), &env.scratch, a_range, b_range); - -// try std.testing.expectEqual(1, result.only_in_a.len()); -// try std.testing.expectEqual(1, result.only_in_b.len()); -// try std.testing.expectEqual(1, result.in_both.len()); - -// const both_slice = env.scratch.in_both_fields.sliceRange(result.in_both); -// try std.testing.expectEqual(both, both_slice[0].a); -// try std.testing.expectEqual(both, both_slice[0].b); - -// const only_in_a_slice = env.scratch.only_in_a_fields.sliceRange(result.only_in_a); -// try std.testing.expectEqual(a1, only_in_a_slice[0]); - -// const only_in_b_slice = env.scratch.only_in_b_fields.sliceRange(result.only_in_b); -// try std.testing.expectEqual(b1, only_in_b_slice[0]); -// } - -// test "partitionFields - reordering is normalized" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const f1 = try env.mkRecordField("f1", @enumFromInt(0)); -// const f2 = try env.mkRecordField("f2", @enumFromInt(1)); -// const f3 = try env.mkRecordField("f3", @enumFromInt(2)); - -// const a_range = try env.scratch.appendSliceGatheredFields(&[_]RecordField{ f3, f1, f2 }); -// const b_range = try env.scratch.appendSliceGatheredFields(&[_]RecordField{ f1, f2, f3 }); - -// const result = try partitionFields(&env.module_env.getIdentStore(), &env.scratch, a_range, b_range); - -// try std.testing.expectEqual(0, result.only_in_a.len()); -// try std.testing.expectEqual(0, result.only_in_b.len()); -// try std.testing.expectEqual(3, result.in_both.len()); - -// const both = env.scratch.in_both_fields.sliceRange(result.in_both); -// try std.testing.expectEqual(f1, both[0].a); -// try std.testing.expectEqual(f1, both[0].b); -// try std.testing.expectEqual(f2, both[1].a); -// try std.testing.expectEqual(f2, both[1].b); -// try std.testing.expectEqual(f3, both[2].a); -// try std.testing.expectEqual(f3, both[2].b); -// } - -// // unification - structure/structure - records closed - -// test "unify - identical closed records" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); - -// const fields = [_]RecordField{try env.mkRecordField("a", str)}; -// const record_data = try env.mkRecordClosed(&fields); -// const record_data_fields = env.module_env.types.record_fields.sliceRange(record_data.record.fields); - -// const a = try env.module_env.types.freshFromContent(record_data.content); -// const b = try env.module_env.types.freshFromContent(record_data.content); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); - -// const b_record = try TestEnv.getRecordOrErr(try env.getDescForRootVar(b)); -// const b_record_fields = env.module_env.types.record_fields.sliceRange(b_record.fields); -// try std.testing.expectEqualSlices(Ident.Idx, record_data_fields.items(.name), b_record_fields.items(.name)); -// try std.testing.expectEqualSlices(Var, record_data_fields.items(.var_), b_record_fields.items(.var_)); -// } - -// test "unify - closed record mismatch on diff fields (fail)" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); - -// const field1 = try env.mkRecordField("field1", str); -// const field2 = try env.mkRecordField("field2", str); - -// const a_record_data = try env.mkRecordClosed(&[_]RecordField{ field1, field2 }); -// const a = try env.module_env.types.freshFromContent(a_record_data.content); - -// const b_record_data = try env.mkRecordClosed(&[_]RecordField{field1}); -// const b = try env.module_env.types.freshFromContent(b_record_data.content); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); - -// const desc_b = try env.getDescForRootVar(b); -// try std.testing.expectEqual(Content.err, desc_b.content); -// } - -// // unification - structure/structure - records open - -// test "unify - identical open records" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); - -// const field_shared = try env.mkRecordField("x", str); - -// const a_rec_data = try env.mkRecordOpen(&[_]RecordField{field_shared}); -// const a = try env.module_env.types.freshFromContent(a_rec_data.content); -// const b_rec_data = try env.mkRecordOpen(&[_]RecordField{field_shared}); -// const b = try env.module_env.types.freshFromContent(b_rec_data.content); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); - -// // check that the update var at b is correct - -// const b_record = try TestEnv.getRecordOrErr(try env.getDescForRootVar(b)); -// try std.testing.expectEqual(1, b_record.fields.len()); -// const b_record_fields = env.module_env.types.getRecordFieldsSlice(b_record.fields); -// try std.testing.expectEqual(field_shared.name, b_record_fields.items(.name)[0]); -// try std.testing.expectEqual(field_shared.var_, b_record_fields.items(.var_)[0]); - -// const b_ext = env.module_env.types.resolveVar(b_record.ext).desc.content; -// try std.testing.expectEqual(Content{ .flex_var = null }, b_ext); - -// // check that fresh vars are correct - -// try std.testing.expectEqual(0, env.scratch.fresh_vars.len()); -// } - -// test "unify - open record a extends b" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); -// const int = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u8 } }); - -// const field_shared = try env.mkRecordField("x", str); -// const field_a_only = try env.mkRecordField("y", int); - -// const a_rec_data = try env.mkRecordOpen(&[_]RecordField{ field_shared, field_a_only }); -// const a = try env.module_env.types.freshFromContent(a_rec_data.content); -// const b_rec_data = try env.mkRecordOpen(&[_]RecordField{field_shared}); -// const b = try env.module_env.types.freshFromContent(b_rec_data.content); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); - -// // check that the update var at b is correct - -// const b_record = try TestEnv.getRecordOrErr(try env.getDescForRootVar(b)); -// try std.testing.expectEqual(1, b_record.fields.len()); -// const b_record_fields = env.module_env.types.getRecordFieldsSlice(b_record.fields); -// try std.testing.expectEqual(field_shared.name, b_record_fields.items(.name)[0]); -// try std.testing.expectEqual(field_shared.var_, b_record_fields.items(.var_)[0]); - -// try std.testing.expectEqual(1, env.scratch.fresh_vars.len()); -// try std.testing.expectEqual(env.scratch.fresh_vars.get(@enumFromInt(0)).*, b_record.ext); - -// const b_ext_record = try TestEnv.getRecordOrErr(env.module_env.types.resolveVar(b_record.ext).desc); -// try std.testing.expectEqual(1, b_ext_record.fields.len()); -// const b_ext_record_fields = env.module_env.types.getRecordFieldsSlice(b_ext_record.fields); -// try std.testing.expectEqual(field_a_only.name, b_ext_record_fields.items(.name)[0]); -// try std.testing.expectEqual(field_a_only.var_, b_ext_record_fields.items(.var_)[0]); - -// const b_ext_ext = env.module_env.types.resolveVar(b_ext_record.ext).desc.content; -// try std.testing.expectEqual(Content{ .flex_var = null }, b_ext_ext); - -// // check that fresh vars are correct - -// try std.testing.expectEqual(1, env.scratch.fresh_vars.len()); -// try std.testing.expectEqual(b_record.ext, env.scratch.fresh_vars.items.items[0]); -// } - -// test "unify - open record b extends a" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); -// const int = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u8 } }); - -// const field_shared = try env.mkRecordField("field_shared", str); -// const field_b_only = try env.mkRecordField("field_b_only", int); - -// const a_rec_data = try env.mkRecordOpen(&[_]RecordField{field_shared}); -// const a = try env.module_env.types.freshFromContent(a_rec_data.content); -// const b_rec_data = try env.mkRecordOpen(&[_]RecordField{ field_shared, field_b_only }); -// const b = try env.module_env.types.freshFromContent(b_rec_data.content); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); - -// // check that the update var at b is correct - -// const b_record = try TestEnv.getRecordOrErr(try env.getDescForRootVar(b)); -// try std.testing.expectEqual(1, b_record.fields.len()); -// const b_record_fields = env.module_env.types.getRecordFieldsSlice(b_record.fields); -// try std.testing.expectEqual(field_shared.name, b_record_fields.items(.name)[0]); -// try std.testing.expectEqual(field_shared.var_, b_record_fields.items(.var_)[0]); - -// const b_ext_record = try TestEnv.getRecordOrErr(env.module_env.types.resolveVar(b_record.ext).desc); -// try std.testing.expectEqual(1, b_ext_record.fields.len()); -// const b_ext_record_fields = env.module_env.types.getRecordFieldsSlice(b_ext_record.fields); -// try std.testing.expectEqual(field_b_only.name, b_ext_record_fields.items(.name)[0]); -// try std.testing.expectEqual(field_b_only.var_, b_ext_record_fields.items(.var_)[0]); - -// const b_ext_ext = env.module_env.types.resolveVar(b_ext_record.ext).desc.content; -// try std.testing.expectEqual(Content{ .flex_var = null }, b_ext_ext); - -// // check that fresh vars are correct - -// try std.testing.expectEqual(1, env.scratch.fresh_vars.len()); -// try std.testing.expectEqual(b_record.ext, env.scratch.fresh_vars.items.items[0]); -// } - -// test "unify - both extend open record" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); -// const int = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u8 } }); -// const bool_ = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i8 } }); - -// const field_shared = try env.mkRecordField("x", str); -// const field_a_only = try env.mkRecordField("y", int); -// const field_b_only = try env.mkRecordField("z", bool_); - -// const a_rec_data = try env.mkRecordOpen(&[_]RecordField{ field_shared, field_a_only }); -// const a = try env.module_env.types.freshFromContent(a_rec_data.content); -// const b_rec_data = try env.mkRecordOpen(&[_]RecordField{ field_shared, field_b_only }); -// const b = try env.module_env.types.freshFromContent(b_rec_data.content); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); - -// // check that the update var at b is correct - -// const b_record = try TestEnv.getRecordOrErr(try env.getDescForRootVar(b)); -// try std.testing.expectEqual(3, b_record.fields.len()); -// const b_record_fields = env.module_env.types.getRecordFieldsSlice(b_record.fields); -// try std.testing.expectEqual(field_shared, b_record_fields.get(0)); -// try std.testing.expectEqual(field_a_only, b_record_fields.get(1)); -// try std.testing.expectEqual(field_b_only, b_record_fields.get(2)); - -// const b_ext = env.module_env.types.resolveVar(b_record.ext).desc.content; -// try std.testing.expectEqual(Content{ .flex_var = null }, b_ext); - -// // check that fresh vars are correct - -// try std.testing.expectEqual(3, env.scratch.fresh_vars.len()); - -// const only_a_var = env.scratch.fresh_vars.get(@enumFromInt(0)).*; -// const only_a_record = try TestEnv.getRecordOrErr(env.module_env.types.resolveVar(only_a_var).desc); -// try std.testing.expectEqual(1, only_a_record.fields.len()); -// const only_a_record_fields = env.module_env.types.getRecordFieldsSlice(only_a_record.fields); -// try std.testing.expectEqual(field_a_only, only_a_record_fields.get(0)); - -// const only_b_var = env.scratch.fresh_vars.get(@enumFromInt(1)).*; -// const only_b_record = try TestEnv.getRecordOrErr(env.module_env.types.resolveVar(only_b_var).desc); -// try std.testing.expectEqual(1, only_b_record.fields.len()); -// const only_b_record_fields = env.module_env.types.getRecordFieldsSlice(only_b_record.fields); -// try std.testing.expectEqual(field_b_only, only_b_record_fields.get(0)); - -// const ext_var = env.scratch.fresh_vars.get(@enumFromInt(2)).*; -// const ext_content = env.module_env.types.resolveVar(ext_var).desc.content; -// try std.testing.expectEqual(Content{ .flex_var = null }, ext_content); -// } - -// test "unify - record mismatch on shared field (fail)" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); -// const int = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u8 } }); - -// const field_a = try env.mkRecordField("x", str); -// const field_b = try env.mkRecordField("x", int); - -// const a_rec_data = try env.mkRecordOpen(&[_]RecordField{field_a}); -// const a = try env.module_env.types.freshFromContent(a_rec_data.content); - -// const b_rec_data = try env.mkRecordOpen(&[_]RecordField{field_b}); -// const b = try env.module_env.types.freshFromContent(b_rec_data.content); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); - -// const desc_b = try env.getDescForRootVar(b); -// try std.testing.expectEqual(Content.err, desc_b.content); -// } - -// // unification - structure/structure - records open+closed - -// test "unify - open record extends closed (fail)" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); - -// const field_x = try env.mkRecordField("field_x", str); -// const field_y = try env.mkRecordField("field_y", str); - -// const open = try env.module_env.types.freshFromContent((try env.mkRecordOpen(&[_]RecordField{ field_x, field_y })).content); -// const closed = try env.module_env.types.freshFromContent((try env.mkRecordClosed(&[_]RecordField{field_x})).content); - -// const result = try env.unify(open, closed); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = closed }, env.module_env.types.getSlot(open)); -// try std.testing.expectEqual(Content.err, (try env.getDescForRootVar(closed)).content); -// } - -// test "unify - closed record extends open" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); - -// const field_x = try env.mkRecordField("field_x", str); -// const field_y = try env.mkRecordField("field_y", str); - -// const open = try env.module_env.types.freshFromContent((try env.mkRecordOpen(&[_]RecordField{field_x})).content); -// const closed = try env.module_env.types.freshFromContent((try env.mkRecordClosed(&[_]RecordField{ field_x, field_y })).content); - -// const result = try env.unify(open, closed); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = closed }, env.module_env.types.getSlot(open)); -// } - -// test "unify - open vs closed records with type mismatch (fail)" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); -// const int = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u8 } }); - -// const field_x_str = try env.mkRecordField("field_x_str", str); -// const field_x_int = try env.mkRecordField("field_x_int", int); - -// const open = try env.module_env.types.freshFromContent((try env.mkRecordOpen(&[_]RecordField{field_x_str})).content); -// const closed = try env.module_env.types.freshFromContent((try env.mkRecordClosed(&[_]RecordField{field_x_int})).content); - -// const result = try env.unify(open, closed); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = closed }, env.module_env.types.getSlot(open)); - -// const desc = try env.getDescForRootVar(closed); -// try std.testing.expectEqual(Content.err, desc.content); -// } - -// test "unify - closed vs open records with type mismatch (fail)" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); -// const int = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u8 } }); - -// const field_x_str = try env.mkRecordField("field_x_str", str); -// const field_x_int = try env.mkRecordField("field_x_int", int); - -// const closed = try env.module_env.types.freshFromContent((try env.mkRecordClosed(&[_]RecordField{field_x_int})).content); -// const open = try env.module_env.types.freshFromContent((try env.mkRecordOpen(&[_]RecordField{field_x_str})).content); - -// const result = try env.unify(closed, open); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = open }, env.module_env.types.getSlot(closed)); - -// const desc = try env.getDescForRootVar(open); -// try std.testing.expectEqual(Content.err, desc.content); -// } - -// // unification - tag unions - partition tags - -// test "partitionTags - same tags" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const tag_x = try env.mkTag("X", &[_]Var{@enumFromInt(0)}); -// const tag_y = try env.mkTag("Y", &[_]Var{@enumFromInt(1)}); - -// const range = try env.scratch.appendSliceGatheredTags(&[_]Tag{ tag_x, tag_y }); - -// const result = try partitionTags(&env.module_env.getIdentStore(), &env.scratch, range, range); - -// try std.testing.expectEqual(0, result.only_in_a.len()); -// try std.testing.expectEqual(0, result.only_in_b.len()); -// try std.testing.expectEqual(2, result.in_both.len()); - -// const both_slice = env.scratch.in_both_tags.sliceRange(result.in_both); -// try std.testing.expectEqual(tag_x, both_slice[0].a); -// try std.testing.expectEqual(tag_x, both_slice[0].b); -// try std.testing.expectEqual(tag_y, both_slice[1].a); -// try std.testing.expectEqual(tag_y, both_slice[1].b); -// } - -// test "partitionTags - disjoint fields" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const a1 = try env.mkTag("A1", &[_]Var{@enumFromInt(0)}); -// const a2 = try env.mkTag("A2", &[_]Var{@enumFromInt(1)}); -// const b1 = try env.mkTag("B1", &[_]Var{@enumFromInt(2)}); - -// const a_range = try env.scratch.appendSliceGatheredTags(&[_]Tag{ a1, a2 }); -// const b_range = try env.scratch.appendSliceGatheredTags(&[_]Tag{b1}); - -// const result = try partitionTags(&env.module_env.getIdentStore(), &env.scratch, a_range, b_range); - -// try std.testing.expectEqual(2, result.only_in_a.len()); -// try std.testing.expectEqual(1, result.only_in_b.len()); -// try std.testing.expectEqual(0, result.in_both.len()); - -// const only_in_a_slice = env.scratch.only_in_a_tags.sliceRange(result.only_in_a); -// try std.testing.expectEqual(a1, only_in_a_slice[0]); -// try std.testing.expectEqual(a2, only_in_a_slice[1]); - -// const only_in_b_slice = env.scratch.only_in_b_tags.sliceRange(result.only_in_b); -// try std.testing.expectEqual(b1, only_in_b_slice[0]); -// } - -// test "partitionTags - overlapping tags" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const a1 = try env.mkTag("A", &[_]Var{@enumFromInt(0)}); -// const both = try env.mkTag("Both", &[_]Var{@enumFromInt(1)}); -// const b1 = try env.mkTag("B", &[_]Var{@enumFromInt(2)}); - -// const a_range = try env.scratch.appendSliceGatheredTags(&[_]Tag{ a1, both }); -// const b_range = try env.scratch.appendSliceGatheredTags(&[_]Tag{ b1, both }); - -// const result = try partitionTags(&env.module_env.getIdentStore(), &env.scratch, a_range, b_range); - -// try std.testing.expectEqual(1, result.only_in_a.len()); -// try std.testing.expectEqual(1, result.only_in_b.len()); -// try std.testing.expectEqual(1, result.in_both.len()); - -// const both_slice = env.scratch.in_both_tags.sliceRange(result.in_both); -// try std.testing.expectEqual(both, both_slice[0].a); -// try std.testing.expectEqual(both, both_slice[0].b); - -// const only_in_a_slice = env.scratch.only_in_a_tags.sliceRange(result.only_in_a); -// try std.testing.expectEqual(a1, only_in_a_slice[0]); - -// const only_in_b_slice = env.scratch.only_in_b_tags.sliceRange(result.only_in_b); -// try std.testing.expectEqual(b1, only_in_b_slice[0]); -// } - -// test "partitionTags - reordering is normalized" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const f1 = try env.mkTag("F1", &[_]Var{@enumFromInt(0)}); -// const f2 = try env.mkTag("F2", &[_]Var{@enumFromInt(1)}); -// const f3 = try env.mkTag("F3", &[_]Var{@enumFromInt(2)}); - -// const a_range = try env.scratch.appendSliceGatheredTags(&[_]Tag{ f3, f1, f2 }); -// const b_range = try env.scratch.appendSliceGatheredTags(&[_]Tag{ f1, f2, f3 }); - -// const result = try partitionTags(&env.module_env.getIdentStore(), &env.scratch, a_range, b_range); - -// try std.testing.expectEqual(0, result.only_in_a.len()); -// try std.testing.expectEqual(0, result.only_in_b.len()); -// try std.testing.expectEqual(3, result.in_both.len()); - -// const both_slice = env.scratch.in_both_tags.sliceRange(result.in_both); -// try std.testing.expectEqual(f1, both_slice[0].a); -// try std.testing.expectEqual(f1, both_slice[0].b); -// try std.testing.expectEqual(f2, both_slice[1].a); -// try std.testing.expectEqual(f2, both_slice[1].b); -// try std.testing.expectEqual(f3, both_slice[2].a); -// try std.testing.expectEqual(f3, both_slice[2].b); -// } - -// // unification - structure/structure - tag unions closed - -// test "unify - identical closed tag_unions" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); - -// const tag = try env.mkTag("A", &[_]Var{str}); -// const tags = [_]Tag{tag}; -// const tag_union_data = try env.mkTagUnionClosed(&tags); - -// const a = try env.module_env.types.freshFromContent(tag_union_data.content); -// const b = try env.module_env.types.freshFromContent(tag_union_data.content); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); - -// const b_tag_union = try TestEnv.getTagUnionOrErr(try env.getDescForRootVar(b)); -// const b_tags = env.module_env.types.tags.sliceRange(b_tag_union.tags); -// const b_tags_names = b_tags.items(.name); -// const b_tags_args = b_tags.items(.args); -// try std.testing.expectEqual(1, b_tags.len); -// try std.testing.expectEqual(tag.name, b_tags_names[0]); -// try std.testing.expectEqual(tag.args, b_tags_args[0]); - -// try std.testing.expectEqual(1, b_tags.len); - -// const b_tag_args = env.module_env.types.vars.sliceRange(b_tags_args[0]); -// try std.testing.expectEqual(1, b_tag_args.len); -// try std.testing.expectEqual(str, b_tag_args[0]); -// } - -// test "unify - closed tag_unions with diff args (fail)" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); -// const int = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u8 } }); - -// const a_tag = try env.mkTag("A", &[_]Var{str}); -// const a_tags = [_]Tag{a_tag}; -// const a_tag_union_data = try env.mkTagUnionClosed(&a_tags); -// const a = try env.module_env.types.freshFromContent(a_tag_union_data.content); - -// const b_tag = try env.mkTag("A", &[_]Var{int}); -// const b_tags = [_]Tag{b_tag}; -// const b_tag_union_data = try env.mkTagUnionClosed(&b_tags); -// const b = try env.module_env.types.freshFromContent(b_tag_union_data.content); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); - -// const desc = try env.getDescForRootVar(b); -// try std.testing.expectEqual(Content.err, desc.content); -// } - -// // unification - structure/structure - tag unions open - -// test "unify - identical open tag unions" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); - -// const tag_shared = try env.mkTag("Shared", &[_]Var{ str, str }); - -// const tag_union_a = try env.mkTagUnionOpen(&[_]Tag{tag_shared}); -// const a = try env.module_env.types.freshFromContent(tag_union_a.content); - -// const tag_union_b = try env.mkTagUnionOpen(&[_]Tag{tag_shared}); -// const b = try env.module_env.types.freshFromContent(tag_union_b.content); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); - -// // check that the update var at b is correct - -// const b_tag_union = try TestEnv.getTagUnionOrErr(try env.getDescForRootVar(b)); -// try std.testing.expectEqual(1, b_tag_union.tags.len()); - -// const b_tags = env.module_env.types.tags.sliceRange(b_tag_union.tags); -// const b_tags_names = b_tags.items(.name); -// const b_tags_args = b_tags.items(.args); -// try std.testing.expectEqual(1, b_tags.len); -// try std.testing.expectEqual(tag_shared.name, b_tags_names[0]); -// try std.testing.expectEqual(tag_shared.args, b_tags_args[0]); - -// const b_ext = env.module_env.types.resolveVar(b_tag_union.ext).desc.content; -// try std.testing.expectEqual(Content{ .flex_var = null }, b_ext); - -// // check that fresh vars are correct - -// try std.testing.expectEqual(0, env.scratch.fresh_vars.len()); -// } - -// test "unify - open tag union a extends b" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); -// const int = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u8 } }); - -// const tag_a_only = try env.mkTag("A", &[_]Var{str}); -// const tag_shared = try env.mkTag("Shared", &[_]Var{ int, int }); - -// const tag_union_a = try env.mkTagUnionOpen(&[_]Tag{ tag_a_only, tag_shared }); -// const a = try env.module_env.types.freshFromContent(tag_union_a.content); - -// const tag_union_b = try env.mkTagUnionOpen(&[_]Tag{tag_shared}); -// const b = try env.module_env.types.freshFromContent(tag_union_b.content); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); - -// // check that the update var at b is correct - -// const b_tag_union = try TestEnv.getTagUnionOrErr(try env.getDescForRootVar(b)); -// try std.testing.expectEqual(1, b_tag_union.tags.len()); - -// const b_tags = env.module_env.types.tags.sliceRange(b_tag_union.tags); -// const b_tags_names = b_tags.items(.name); -// const b_tags_args = b_tags.items(.args); -// try std.testing.expectEqual(1, b_tags.len); -// try std.testing.expectEqual(tag_shared.name, b_tags_names[0]); -// try std.testing.expectEqual(tag_shared.args, b_tags_args[0]); - -// const b_ext_tag_union = try TestEnv.getTagUnionOrErr(env.module_env.types.resolveVar(b_tag_union.ext).desc); -// try std.testing.expectEqual(1, b_ext_tag_union.tags.len()); - -// const b_ext_tags = env.module_env.types.tags.sliceRange(b_ext_tag_union.tags); -// const b_ext_tags_names = b_ext_tags.items(.name); -// const b_ext_tags_args = b_ext_tags.items(.args); -// try std.testing.expectEqual(1, b_ext_tags.len); -// try std.testing.expectEqual(tag_a_only.name, b_ext_tags_names[0]); -// try std.testing.expectEqual(tag_a_only.args, b_ext_tags_args[0]); - -// const b_ext_ext = env.module_env.types.resolveVar(b_ext_tag_union.ext).desc.content; -// try std.testing.expectEqual(Content{ .flex_var = null }, b_ext_ext); - -// // check that fresh vars are correct - -// try std.testing.expectEqual(1, env.scratch.fresh_vars.len()); -// try std.testing.expectEqual(b_tag_union.ext, env.scratch.fresh_vars.items.items[0]); -// } - -// test "unify - open tag union b extends a" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); -// const int = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u8 } }); - -// const tag_b_only = try env.mkTag("A", &[_]Var{ str, int }); -// const tag_shared = try env.mkTag("Shared", &[_]Var{int}); - -// const tag_union_a = try env.mkTagUnionOpen(&[_]Tag{tag_shared}); -// const a = try env.module_env.types.freshFromContent(tag_union_a.content); - -// const tag_union_b = try env.mkTagUnionOpen(&[_]Tag{ tag_b_only, tag_shared }); -// const b = try env.module_env.types.freshFromContent(tag_union_b.content); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); - -// // check that the update var at b is correct - -// const b_tag_union = try TestEnv.getTagUnionOrErr(try env.getDescForRootVar(b)); -// try std.testing.expectEqual(1, b_tag_union.tags.len()); - -// const b_tags = env.module_env.types.tags.sliceRange(b_tag_union.tags); -// const b_tags_names = b_tags.items(.name); -// const b_tags_args = b_tags.items(.args); -// try std.testing.expectEqual(1, b_tags.len); -// try std.testing.expectEqual(tag_shared.name, b_tags_names[0]); -// try std.testing.expectEqual(tag_shared.args, b_tags_args[0]); - -// const b_ext_tag_union = try TestEnv.getTagUnionOrErr(env.module_env.types.resolveVar(b_tag_union.ext).desc); -// try std.testing.expectEqual(1, b_ext_tag_union.tags.len()); - -// const b_ext_tags = env.module_env.types.tags.sliceRange(b_ext_tag_union.tags); -// const b_ext_tags_names = b_ext_tags.items(.name); -// const b_ext_tags_args = b_ext_tags.items(.args); -// try std.testing.expectEqual(1, b_ext_tags.len); -// try std.testing.expectEqual(tag_b_only.name, b_ext_tags_names[0]); -// try std.testing.expectEqual(tag_b_only.args, b_ext_tags_args[0]); - -// const b_ext_ext = env.module_env.types.resolveVar(b_ext_tag_union.ext).desc.content; -// try std.testing.expectEqual(Content{ .flex_var = null }, b_ext_ext); - -// // check that fresh vars are correct - -// try std.testing.expectEqual(1, env.scratch.fresh_vars.len()); -// try std.testing.expectEqual(b_tag_union.ext, env.scratch.fresh_vars.items.items[0]); -// } - -// test "unify - both extend open tag union" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); -// const int = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u8 } }); -// const bool_ = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i8 } }); - -// const tag_a_only = try env.mkTag("A", &[_]Var{bool_}); -// const tag_b_only = try env.mkTag("B", &[_]Var{ str, int }); -// const tag_shared = try env.mkTag("Shared", &[_]Var{int}); - -// const tag_union_a = try env.mkTagUnionOpen(&[_]Tag{ tag_a_only, tag_shared }); -// const a = try env.module_env.types.freshFromContent(tag_union_a.content); - -// const tag_union_b = try env.mkTagUnionOpen(&[_]Tag{ tag_b_only, tag_shared }); -// const b = try env.module_env.types.freshFromContent(tag_union_b.content); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); - -// // check that the update var at b is correct - -// const b_tag_union = try TestEnv.getTagUnionOrErr(try env.getDescForRootVar(b)); -// try std.testing.expectEqual(3, b_tag_union.tags.len()); - -// const b_tags = env.module_env.types.tags.sliceRange(b_tag_union.tags); -// try std.testing.expectEqual(3, b_tags.len); -// try std.testing.expectEqual(tag_shared, b_tags.get(0)); -// try std.testing.expectEqual(tag_a_only, b_tags.get(1)); -// try std.testing.expectEqual(tag_b_only, b_tags.get(2)); - -// const b_ext = env.module_env.types.resolveVar(b_tag_union.ext).desc.content; -// try std.testing.expectEqual(Content{ .flex_var = null }, b_ext); - -// // check that fresh vars are correct - -// try std.testing.expectEqual(3, env.scratch.fresh_vars.len()); - -// const only_a_var = env.scratch.fresh_vars.get(@enumFromInt(0)).*; -// const only_a_tag_union = try TestEnv.getTagUnionOrErr(env.module_env.types.resolveVar(only_a_var).desc); -// try std.testing.expectEqual(1, only_a_tag_union.tags.len()); -// const only_a_tags = env.module_env.types.getTagsSlice(only_a_tag_union.tags); -// try std.testing.expectEqual(tag_a_only, only_a_tags.get(0)); - -// const only_b_var = env.scratch.fresh_vars.get(@enumFromInt(1)).*; -// const only_b_tag_union = try TestEnv.getTagUnionOrErr(env.module_env.types.resolveVar(only_b_var).desc); -// try std.testing.expectEqual(1, only_b_tag_union.tags.len()); -// const only_b_tags = env.module_env.types.getTagsSlice(only_b_tag_union.tags); -// try std.testing.expectEqual(tag_b_only, only_b_tags.get(0)); - -// const ext_var = env.scratch.fresh_vars.get(@enumFromInt(2)).*; -// const ext_content = env.module_env.types.resolveVar(ext_var).desc.content; -// try std.testing.expectEqual(Content{ .flex_var = null }, ext_content); -// } - -// test "unify - open tag unions a & b have same tag name with diff args (fail)" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); -// const int = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_u8 } }); - -// const tag_a_only = try env.mkTag("A", &[_]Var{str}); -// const tag_shared = try env.mkTag("A", &[_]Var{ int, int }); - -// const tag_union_a = try env.mkTagUnionOpen(&[_]Tag{ tag_a_only, tag_shared }); -// const a = try env.module_env.types.freshFromContent(tag_union_a.content); - -// const tag_union_b = try env.mkTagUnionOpen(&[_]Tag{tag_shared}); -// const b = try env.module_env.types.freshFromContent(tag_union_b.content); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); - -// const desc = try env.getDescForRootVar(b); -// try std.testing.expectEqual(Content.err, desc.content); -// } - -// // unification - structure/structure - records open+closed - -// test "unify - open tag extends closed (fail)" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); - -// const tag_shared = try env.mkTag("Shared", &[_]Var{str}); -// const tag_a_only = try env.mkTag("A", &[_]Var{str}); - -// const a = try env.module_env.types.freshFromContent((try env.mkTagUnionOpen(&[_]Tag{ tag_shared, tag_a_only })).content); -// const b = try env.module_env.types.freshFromContent((try env.mkTagUnionClosed(&[_]Tag{tag_shared})).content); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); -// try std.testing.expectEqual(Content.err, (try env.getDescForRootVar(b)).content); -// } - -// test "unify - closed tag union extends open" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); - -// const tag_shared = try env.mkTag("Shared", &[_]Var{str}); -// const tag_b_only = try env.mkTag("B", &[_]Var{str}); - -// const a = try env.module_env.types.freshFromContent((try env.mkTagUnionOpen(&[_]Tag{tag_shared})).content); -// const b = try env.module_env.types.freshFromContent((try env.mkTagUnionClosed(&[_]Tag{ tag_shared, tag_b_only })).content); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(.ok, result); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); - -// // check that the update var at b is correct - -// const b_tag_union = try TestEnv.getTagUnionOrErr(try env.getDescForRootVar(b)); -// try std.testing.expectEqual(1, b_tag_union.tags.len()); - -// const b_tags = env.module_env.types.tags.sliceRange(b_tag_union.tags); -// const b_tags_names = b_tags.items(.name); -// const b_tags_args = b_tags.items(.args); -// try std.testing.expectEqual(1, b_tags.len); -// try std.testing.expectEqual(tag_shared.name, b_tags_names[0]); -// try std.testing.expectEqual(tag_shared.args, b_tags_args[0]); - -// const b_ext_tag_union = try TestEnv.getTagUnionOrErr(env.module_env.types.resolveVar(b_tag_union.ext).desc); -// try std.testing.expectEqual(1, b_ext_tag_union.tags.len()); - -// const b_ext_tags = env.module_env.types.tags.sliceRange(b_ext_tag_union.tags); -// const b_ext_tags_names = b_ext_tags.items(.name); -// const b_ext_tags_args = b_ext_tags.items(.args); -// try std.testing.expectEqual(1, b_ext_tags.len); -// try std.testing.expectEqual(tag_b_only.name, b_ext_tags_names[0]); -// try std.testing.expectEqual(tag_b_only.args, b_ext_tags_args[0]); - -// const b_ext_ext = env.module_env.types.resolveVar(b_ext_tag_union.ext).desc.content; -// try std.testing.expectEqual(Content{ .structure = .empty_tag_union }, b_ext_ext); - -// // check that fresh vars are correct - -// try std.testing.expectEqual(1, env.scratch.fresh_vars.len()); -// try std.testing.expectEqual(b_tag_union.ext, env.scratch.fresh_vars.items.items[0]); -// } - -// test "unify - open vs closed tag union with type mismatch (fail)" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); -// const bool_ = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i8 } }); - -// const tag_a = try env.mkTag("A", &[_]Var{str}); -// const tag_b = try env.mkTag("A", &[_]Var{bool_}); - -// const a = try env.module_env.types.freshFromContent((try env.mkTagUnionOpen(&[_]Tag{tag_a})).content); -// const b = try env.module_env.types.freshFromContent((try env.mkTagUnionClosed(&[_]Tag{tag_b})).content); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); - -// const desc = try env.getDescForRootVar(b); -// try std.testing.expectEqual(Content.err, desc.content); -// } - -// test "unify - closed vs open tag union with type mismatch (fail)" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str = try env.module_env.types.freshFromContent(Content{ .structure = .str }); -// const bool_ = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = Num.int_i8 } }); - -// const tag_a = try env.mkTag("A", &[_]Var{str}); -// const tag_b = try env.mkTag("B", &[_]Var{bool_}); - -// const a = try env.module_env.types.freshFromContent((try env.mkTagUnionClosed(&[_]Tag{tag_a})).content); -// const b = try env.module_env.types.freshFromContent((try env.mkTagUnionOpen(&[_]Tag{tag_b})).content); - -// const result = try env.unify(a, b); - -// try std.testing.expectEqual(false, result.isOk()); -// try std.testing.expectEqual(Slot{ .redirect = b }, env.module_env.types.getSlot(a)); - -// const desc = try env.getDescForRootVar(b); -// try std.testing.expectEqual(Content.err, desc.content); -// } - -// // unification - recursion - -// test "unify - fails on infinite type" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const str_var = try env.module_env.types.freshFromContent(Content{ .structure = .str }); - -// const a = try env.module_env.types.fresh(); -// const a_elems_range = try env.module_env.types.appendVars(&[_]Var{ a, str_var }); -// const a_tuple = types_mod.Tuple{ .elems = a_elems_range }; -// try env.module_env.types.setRootVarContent(a, Content{ .structure = .{ .tuple = a_tuple } }); - -// const b = try env.module_env.types.fresh(); -// const b_elems_range = try env.module_env.types.appendVars(&[_]Var{ b, str_var }); -// const b_tuple = types_mod.Tuple{ .elems = b_elems_range }; -// try env.module_env.types.setRootVarContent(b, Content{ .structure = .{ .tuple = b_tuple } }); - -// const result = try env.unify(a, b); - -// switch (result) { -// .ok => try std.testing.expect(false), -// .problem => |problem_idx| { -// const problem = env.problems.problems.get(problem_idx); -// try std.testing.expectEqual(.infinite_recursion, @as(Problem.Tag, problem)); -// }, -// } -// } - -// test "unify - fails on anonymous recursion" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// const list_var_a = try env.module_env.types.fresh(); -// const list_content_a = Content{ -// .structure = .{ .list = list_var_a }, -// }; -// try env.module_env.types.setRootVarContent(list_var_a, list_content_a); - -// const list_var_b = try env.module_env.types.fresh(); -// const list_content_b = Content{ -// .structure = .{ .list = list_var_b }, -// }; -// try env.module_env.types.setRootVarContent(list_var_b, list_content_b); - -// const result = try env.unify(list_var_a, list_var_b); - -// switch (result) { -// .ok => try std.testing.expect(false), -// .problem => |problem_idx| { -// const problem = env.problems.problems.get(problem_idx); -// try std.testing.expectEqual(.anonymous_recursion, @as(Problem.Tag, problem)); -// }, -// } -// } - -// test "unify - succeeds on nominal, tag union recursion" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// var types_store = &env.module_env.types; - -// // Create vars in the required order for adjacency to work out -// const a = try types_store.fresh(); -// const b = try types_store.fresh(); -// const elem = try types_store.fresh(); -// const ext = try types_store.fresh(); - -// // Create the tag union content that references type_a_nominal -// const a_cons_tag = try env.mkTag("Cons", &[_]Var{ elem, a }); -// const a_nil_tag = try env.mkTag("Nil", &[_]Var{}); -// const a_backing = try types_store.freshFromContent(try types_store.mkTagUnion(&.{ a_cons_tag, a_nil_tag }, ext)); -// try types_store.setVarContent(a, try env.mkNominalType("TypeA", a_backing, &.{})); - -// const b_cons_tag = try env.mkTag("Cons", &[_]Var{ elem, b }); -// const b_nil_tag = try env.mkTag("Nil", &[_]Var{}); -// const b_backing = try types_store.freshFromContent(try types_store.mkTagUnion(&.{ b_cons_tag, b_nil_tag }, ext)); -// try types_store.setVarContent(b, try env.mkNominalType("TypeA", b_backing, &.{})); - -// const result_nominal_type = try env.unify(a, b); -// try std.testing.expectEqual(.ok, result_nominal_type); - -// const result_tag_union = try env.unify(a_backing, b_backing); -// try std.testing.expectEqual(.ok, result_tag_union); -// } - -// test "integer literal 255 fits in U8" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// // Create a literal with value 255 (8 bits unsigned) -// const literal_requirements = Num.IntRequirements{ -// .sign_needed = false, -// .bits_needed = @intFromEnum(Num.Int.BitsNeeded.@"8"), -// }; -// const literal_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_unbound = literal_requirements } } }); - -// // Create U8 type -// const u8_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_compact = .{ .int = .u8 } } } }); - -// // They should unify successfully -// const result = try env.unify(literal_var, u8_var); -// try std.testing.expect(result == .ok); -// } - -// test "integer literal 256 does not fit in U8" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// // Create a literal with value 256 (9 bits, no sign) -// const literal_requirements = Num.IntRequirements{ -// .sign_needed = false, -// .bits_needed = @intFromEnum(Num.Int.BitsNeeded.@"9_to_15"), -// }; -// const literal_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_unbound = literal_requirements } } }); - -// // Create U8 type -// const u8_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_compact = .{ .int = .u8 } } } }); - -// // They should NOT unify - type mismatch expected -// const result = try env.unify(literal_var, u8_var); -// try std.testing.expect(result == .problem); -// } - -// test "integer literal -128 fits in I8" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// // Create a literal with value -128 (needs sign, 7 bits after adjustment) -// const literal_requirements = Num.IntRequirements{ -// .sign_needed = true, -// .bits_needed = @intFromEnum(Num.Int.BitsNeeded.@"7"), -// }; -// const literal_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_unbound = literal_requirements } } }); - -// // Create I8 type -// const i8_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_compact = .{ .int = .i8 } } } }); - -// // They should unify successfully -// const result = try env.unify(literal_var, i8_var); -// try std.testing.expect(result == .ok); -// } - -// test "integer literal -129 does not fit in I8" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// // Create a literal with value -129 (needs sign, 8 bits) -// const literal_requirements = Num.IntRequirements{ -// .sign_needed = true, -// .bits_needed = @intFromEnum(Num.Int.BitsNeeded.@"8"), -// }; -// const literal_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_unbound = literal_requirements } } }); - -// // Create I8 type -// const i8_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_compact = .{ .int = .i8 } } } }); - -// // They should NOT unify - type mismatch expected -// const result = try env.unify(literal_var, i8_var); -// try std.testing.expect(result == .problem); -// } - -// test "negative literal cannot unify with unsigned type" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// // Create a literal with negative value (sign needed) -// const literal_requirements = Num.IntRequirements{ -// .sign_needed = true, -// .bits_needed = @intFromEnum(Num.Int.BitsNeeded.@"7"), -// }; -// const literal_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_unbound = literal_requirements } } }); - -// // Create U8 type -// const u8_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_compact = .{ .int = .u8 } } } }); - -// // They should NOT unify - type mismatch expected -// const result = try env.unify(literal_var, u8_var); -// try std.testing.expect(result == .problem); -// } - -// test "float literal that fits in F32" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// // Create a literal that fits in F32 -// const literal_requirements = Num.FracRequirements{ -// .fits_in_f32 = true, -// .fits_in_dec = true, -// }; -// const literal_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .frac_unbound = literal_requirements } } }); - -// // Create F32 type -// const f32_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_compact = .{ .frac = .f32 } } } }); - -// // They should unify successfully -// const result = try env.unify(literal_var, f32_var); -// try std.testing.expect(result == .ok); -// } - -// test "float literal that doesn't fit in F32" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// // Create a literal that doesn't fit in F32 -// const literal_requirements = Num.FracRequirements{ -// .fits_in_f32 = false, -// .fits_in_dec = true, -// }; -// const literal_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .frac_unbound = literal_requirements } } }); - -// // Create F32 type -// const f32_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_compact = .{ .frac = .f32 } } } }); - -// // They should NOT unify - type mismatch expected -// const result = try env.unify(literal_var, f32_var); -// try std.testing.expect(result == .problem); -// } - -// test "float literal NaN doesn't fit in Dec" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// // Create a literal like NaN that doesn't fit in Dec -// const literal_requirements = Num.FracRequirements{ -// .fits_in_f32 = true, -// .fits_in_dec = false, -// }; -// const literal_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .frac_unbound = literal_requirements } } }); - -// // Create Dec type -// const dec_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_compact = .{ .frac = .dec } } } }); - -// // They should NOT unify - type mismatch expected -// const result = try env.unify(literal_var, dec_var); -// try std.testing.expect(result == .problem); -// } - -// test "two integer literals with different requirements unify to most restrictive" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// // Create a literal with value 100 (7 bits, no sign) -// const literal1_requirements = Num.IntRequirements{ -// .sign_needed = false, -// .bits_needed = @intFromEnum(Num.Int.BitsNeeded.@"7"), -// }; -// const literal1_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_unbound = literal1_requirements } } }); - -// // Create a literal with value 200 (8 bits, no sign) -// const literal2_requirements = Num.IntRequirements{ -// .sign_needed = false, -// .bits_needed = @intFromEnum(Num.Int.BitsNeeded.@"8"), -// }; -// const literal2_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_unbound = literal2_requirements } } }); - -// // They should unify successfully -// const result = try env.unify(literal1_var, literal2_var); -// try std.testing.expect(result == .ok); -// } - -// test "positive and negative literals unify with sign requirement" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// // Create an unsigned literal -// const literal1_requirements = Num.IntRequirements{ -// .sign_needed = false, -// .bits_needed = @intFromEnum(Num.Int.BitsNeeded.@"7"), -// }; -// const literal1_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_unbound = literal1_requirements } } }); - -// // Create a signed literal -// const literal2_requirements = Num.IntRequirements{ -// .sign_needed = true, -// .bits_needed = @intFromEnum(Num.Int.BitsNeeded.@"7"), -// }; -// const literal2_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_unbound = literal2_requirements } } }); - -// // They should unify successfully (creating a signed type that can hold both) -// const result = try env.unify(literal1_var, literal2_var); -// try std.testing.expect(result == .ok); -// } - -// test "unify - num_unbound with frac_unbound" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// // Create a num_unbound (like literal 1) -// const num_requirements = Num.IntRequirements{ -// .sign_needed = false, -// .bits_needed = @intFromEnum(Num.Int.BitsNeeded.@"7"), -// }; -// const num_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_unbound = num_requirements } } }); - -// // Create a frac_unbound (like literal 2.5) -// const frac_requirements = Num.FracRequirements{ -// .fits_in_f32 = true, -// .fits_in_dec = true, -// }; -// const frac_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .frac_unbound = frac_requirements } } }); - -// // They should unify successfully with frac_unbound winning -// const result = try env.unify(num_var, frac_var); -// try std.testing.expect(result == .ok); - -// // Check that the result is frac_unbound -// const resolved = env.module_env.types.resolveVar(num_var); -// switch (resolved.desc.content) { -// .structure => |structure| { -// switch (structure) { -// .num => |num| { -// switch (num) { -// .frac_unbound => {}, // Expected -// else => return error.ExpectedFracUnbound, -// } -// }, -// else => return error.ExpectedNum, -// } -// }, -// else => return error.ExpectedStructure, -// } -// } - -// test "unify - frac_unbound with num_unbound (reverse order)" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// // Create a frac_unbound (like literal 2.5) -// const frac_requirements = Num.FracRequirements{ -// .fits_in_f32 = true, -// .fits_in_dec = true, -// }; -// const frac_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .frac_unbound = frac_requirements } } }); - -// // Create a num_unbound (like literal 1) -// const num_requirements = Num.IntRequirements{ -// .sign_needed = false, -// .bits_needed = @intFromEnum(Num.Int.BitsNeeded.@"7"), -// }; -// const num_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_unbound = num_requirements } } }); - -// // They should unify successfully with frac_unbound winning -// const result = try env.unify(frac_var, num_var); -// try std.testing.expect(result == .ok); - -// // Check that the result is frac_unbound -// const resolved = env.module_env.types.resolveVar(frac_var); -// switch (resolved.desc.content) { -// .structure => |structure| { -// switch (structure) { -// .num => |num| { -// switch (num) { -// .frac_unbound => {}, // Expected -// else => return error.ExpectedFracUnbound, -// } -// }, -// else => return error.ExpectedNum, -// } -// }, -// else => return error.ExpectedStructure, -// } -// } - -// test "unify - int_unbound with num_unbound" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// // Create an int_unbound (like literal -5) -// const int_requirements = Num.IntRequirements{ -// .sign_needed = true, -// .bits_needed = @intFromEnum(Num.Int.BitsNeeded.@"7"), -// }; -// const int_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .int_unbound = int_requirements } } }); - -// // Create a num_unbound (like literal 1) -// const num_requirements = Num.IntRequirements{ -// .sign_needed = false, -// .bits_needed = @intFromEnum(Num.Int.BitsNeeded.@"7"), -// }; -// const num_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_unbound = num_requirements } } }); - -// // They should unify successfully with int_unbound winning -// const result = try env.unify(int_var, num_var); -// try std.testing.expect(result == .ok); - -// // Check that the result is int_unbound -// const resolved = env.module_env.types.resolveVar(int_var); -// switch (resolved.desc.content) { -// .structure => |structure| { -// switch (structure) { -// .num => |num| { -// switch (num) { -// .int_unbound => |requirements| { -// // Should have merged the requirements - sign_needed should be true -// try std.testing.expect(requirements.sign_needed == true); -// }, -// else => return error.ExpectedIntUnbound, -// } -// }, -// else => return error.ExpectedNum, -// } -// }, -// else => return error.ExpectedStructure, -// } -// } - -// test "unify - num_unbound with int_unbound (reverse order)" { -// const gpa = std.testing.allocator; - -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// // Create a num_unbound (like literal 1) -// const num_requirements = Num.IntRequirements{ -// .sign_needed = false, -// .bits_needed = @intFromEnum(Num.Int.BitsNeeded.@"7"), -// }; -// const num_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .num_unbound = num_requirements } } }); - -// // Create an int_unbound (like literal -5) -// const int_requirements = Num.IntRequirements{ -// .sign_needed = true, -// .bits_needed = @intFromEnum(Num.Int.BitsNeeded.@"7"), -// }; -// const int_var = try env.module_env.types.freshFromContent(Content{ .structure = .{ .num = .{ .int_unbound = int_requirements } } }); - -// // They should unify successfully with int_unbound winning -// const result = try env.unify(num_var, int_var); -// try std.testing.expect(result == .ok); - -// // Check that the result is int_unbound -// const resolved = env.module_env.types.resolveVar(num_var); -// switch (resolved.desc.content) { -// .structure => |structure| { -// switch (structure) { -// .num => |num| { -// switch (num) { -// .int_unbound => |requirements| { -// // Should have merged the requirements - sign_needed should be true -// try std.testing.expect(requirements.sign_needed == true); -// }, -// else => return error.ExpectedIntUnbound, -// } -// }, -// else => return error.ExpectedNum, -// } -// }, -// else => return error.ExpectedStructure, -// } -// } - -// test "heterogeneous list reports only first incompatibility" { -// const gpa = std.testing.allocator; -// var env = try TestEnv.init(gpa); -// defer env.deinit(); - -// // Create a list type with three different elements -// const num_var = try env.module_env.types.freshFromContent(.{ .structure = .{ .num = .{ .int_unbound = .{ .sign_needed = false, .bits_needed = 7 } } } }); -// const str_var = try env.module_env.types.freshFromContent(.{ .structure = .str }); -// const frac_var = try env.module_env.types.freshFromContent(.{ .structure = .{ .num = .{ .frac_unbound = .{ .fits_in_f32 = true, .fits_in_dec = true } } } }); - -// // Create a list element type variable -// const elem_var = try env.module_env.types.fresh(); - -// // Unify first element (number) with elem_var - should succeed -// const result1 = try env.unify(elem_var, num_var); -// try std.testing.expectEqual(.ok, result1); - -// // Unify second element (string) with elem_var - should fail -// const result2 = try env.unify(elem_var, str_var); -// try std.testing.expectEqual(false, result2.isOk()); - -// // Unify third element (fraction) with elem_var - should succeed (int can be promoted to frac) -// const result3 = try env.unify(elem_var, frac_var); -// try std.testing.expectEqual(.ok, result3); - -// // Check that we have exactly one problem recorded (from the string unification) -// try std.testing.expect(env.problems.problems.len() == 1); -// } diff --git a/src/cli/bench.zig b/src/cli/bench.zig index 3a9d84360d..a439d7e4be 100644 --- a/src/cli/bench.zig +++ b/src/cli/bench.zig @@ -78,6 +78,9 @@ fn benchParseOrTokenize(comptime is_parse: bool, gpa: Allocator, path: []const u std.debug.print("Total: {} bytes, {} lines\n", .{ metrics.total_bytes, metrics.total_lines }); // Create a module environment for tokenization (reused for tokenizer, created per-iteration for parser) + var arena = std.heap.ArenaAllocator.init(gpa); + defer arena.deinit(); + var env: ?ModuleEnv = if (!is_parse) try ModuleEnv.init(gpa, "") else null; defer if (env) |*e| e.deinit(); @@ -102,12 +105,15 @@ fn benchParseOrTokenize(comptime is_parse: bool, gpa: Allocator, path: []const u // ModuleEnv takes ownership of the source code, so we need to dupe it each iteration const source_copy = try gpa.dupe(u8, roc_file.content); + var parse_arena = std.heap.ArenaAllocator.init(gpa); + var parse_env = try ModuleEnv.init(gpa, source_copy); var ir = try parse.parse(&parse_env.common, gpa); iteration_tokens += ir.tokens.tokens.len; ir.deinit(gpa); parse_env.deinit(); + parse_arena.deinit(); } else { // Tokenize mode var messages: [128]tokenize.Diagnostic = undefined; diff --git a/src/cli/cli_args.zig b/src/cli/cli_args.zig index 69db6b015f..9922850331 100644 --- a/src/cli/cli_args.zig +++ b/src/cli/cli_args.zig @@ -11,7 +11,7 @@ pub const CliArgs = union(enum) { run: RunArgs, check: CheckArgs, build: BuildArgs, - format: FormatArgs, + fmt: FormatArgs, test_cmd: TestArgs, bundle: BundleArgs, unbundle: UnbundleArgs, @@ -24,7 +24,7 @@ pub const CliArgs = union(enum) { pub fn deinit(self: CliArgs, gpa: mem.Allocator) void { switch (self) { - .format => |fmt| gpa.free(fmt.paths), + .fmt => |fmt| gpa.free(fmt.paths), .run => |run| gpa.free(run.app_args), .bundle => |bundle| gpa.free(bundle.paths), .unbundle => |unbundle| gpa.free(unbundle.paths), @@ -117,9 +117,13 @@ pub const UnbundleArgs = struct { /// Arguments for `roc docs` pub const DocsArgs = struct { - path: []const u8, // the main.roc file to base the generation on - output: []const u8, // the path to the output directory for the generated docs - root_dir: ?[]const u8 = null, // the prefix to be used in generated links in the docs + path: []const u8, // the path of the roc file to generate docs for + main: ?[]const u8 = null, // the path to a roc file with an app header to be used to resolved dependencies + output: []const u8 = "generated-docs", // the output directory for generated documentation + time: bool = false, // whether to print timing information + no_cache: bool = false, // disable cache + verbose: bool = false, // enable verbose output + serve: bool = false, // start an HTTP server after generating docs }; /// Parse a list of arguments. @@ -130,7 +134,7 @@ pub fn parse(gpa: mem.Allocator, args: []const []const u8) !CliArgs { if (mem.eql(u8, args[0], "build")) return parseBuild(args[1..]); if (mem.eql(u8, args[0], "bundle")) return try parseBundle(gpa, args[1..]); if (mem.eql(u8, args[0], "unbundle")) return try parseUnbundle(gpa, args[1..]); - if (mem.eql(u8, args[0], "format")) return try parseFormat(gpa, args[1..]); + if (mem.eql(u8, args[0], "fmt")) return try parseFormat(gpa, args[1..]); if (mem.eql(u8, args[0], "test")) return parseTest(args[1..]); if (mem.eql(u8, args[0], "repl")) return parseRepl(args[1..]); if (mem.eql(u8, args[0], "version")) return parseVersion(args[1..]); @@ -154,7 +158,7 @@ const main_help = \\ unbundle Extract files from compressed .tar.zst archives \\ test Run all top-level `expect`s in a main module and any modules it imports \\ repl Launch the interactive Read Eval Print Loop (REPL) - \\ format Format a .roc file or the .roc files contained in a directory using standard Roc formatting + \\ fmt Format a .roc file or the .roc files contained in a directory using standard Roc formatting \\ version Print the Roc compiler's version \\ check Check the code for problems, but don't build or run it \\ docs Generate documentation for a Roc package or platform @@ -429,7 +433,7 @@ fn parseFormat(gpa: mem.Allocator, args: []const []const u8) std.mem.Allocator.E return CliArgs{ .help = \\Format a .roc file or the .roc files contained in a directory using standard Roc formatting \\ - \\Usage: roc format [OPTIONS] [DIRECTORY_OR_FILES] + \\Usage: roc fmt [OPTIONS] [DIRECTORY_OR_FILES] \\ \\Arguments: \\ [DIRECTORY_OR_FILES] @@ -454,7 +458,7 @@ fn parseFormat(gpa: mem.Allocator, args: []const []const u8) std.mem.Allocator.E if (paths.items.len == 0) { try paths.append("main.roc"); } - return CliArgs{ .format = FormatArgs{ .paths = try paths.toOwnedSlice(), .stdin = stdin, .check = check } }; + return CliArgs{ .fmt = FormatArgs{ .paths = try paths.toOwnedSlice(), .stdin = stdin, .check = check } }; } fn parseTest(args: []const []const u8) CliArgs { @@ -565,9 +569,14 @@ fn parseLicenses(args: []const []const u8) CliArgs { } fn parseDocs(args: []const []const u8) CliArgs { - var output: ?[]const u8 = null; - var root_dir: ?[]const u8 = null; var path: ?[]const u8 = null; + var main: ?[]const u8 = null; + var output: ?[]const u8 = null; + var time: bool = false; + var no_cache: bool = false; + var verbose: bool = false; + var serve: bool = false; + for (args) |arg| { if (isHelpFlag(arg)) { return CliArgs{ .help = @@ -576,26 +585,38 @@ fn parseDocs(args: []const []const u8) CliArgs { \\Usage: roc docs [OPTIONS] [ROC_FILE] \\ \\Arguments: - \\ [ROC_FILE] The package's main .roc file [default: main.roc] + \\ [ROC_FILE] The .roc file to generate docs for [default: main.roc] \\ \\Options: - \\ --output= Output directory for the generated documentation files. [default: generated-docs] - \\ --root-dir= Set a root directory path to be used as a prefix for URL links in the generated documentation files. - \\ -h, --help Print help + \\ --main=
The .roc file of the main app/package module to resolve dependencies from + \\ --output= Output directory for generated documentation [default: generated-docs] + \\ --serve Start an HTTP server to view the documentation + \\ --time Print timing information for each compilation phase. Will not print anything if everything is cached. + \\ --no-cache Disable caching + \\ --verbose Enable verbose output including cache statistics + \\ -h, --help Print help \\ }; + } else if (mem.startsWith(u8, arg, "--main")) { + if (getFlagValue(arg)) |value| { + main = value; + } else { + return CliArgs{ .problem = CliProblem{ .missing_flag_value = .{ .flag = "--main" } } }; + } } else if (mem.startsWith(u8, arg, "--output")) { if (getFlagValue(arg)) |value| { output = value; } else { return CliArgs{ .problem = CliProblem{ .missing_flag_value = .{ .flag = "--output" } } }; } - } else if (mem.startsWith(u8, arg, "--root-dir")) { - if (getFlagValue(arg)) |value| { - root_dir = value; - } else { - return CliArgs{ .problem = CliProblem{ .missing_flag_value = .{ .flag = "--root-dir" } } }; - } + } else if (mem.eql(u8, arg, "--serve")) { + serve = true; + } else if (mem.eql(u8, arg, "--time")) { + time = true; + } else if (mem.eql(u8, arg, "--no-cache")) { + no_cache = true; + } else if (mem.eql(u8, arg, "--verbose")) { + verbose = true; } else { if (path != null) { return CliArgs{ .problem = CliProblem{ .unexpected_argument = .{ .cmd = "docs", .arg = arg } } }; @@ -604,7 +625,7 @@ fn parseDocs(args: []const []const u8) CliArgs { } } - return CliArgs{ .docs = DocsArgs{ .path = path orelse "main.roc", .output = output orelse "generated-docs", .root_dir = root_dir } }; + return CliArgs{ .docs = DocsArgs{ .path = path orelse "main.roc", .main = main, .output = output orelse "generated-docs", .time = time, .no_cache = no_cache, .verbose = verbose, .serve = serve } }; } fn parseRun(gpa: mem.Allocator, args: []const []const u8) std.mem.Allocator.Error!CliArgs { @@ -800,61 +821,61 @@ test "roc build" { } } -test "roc format" { +test "roc fmt" { const gpa = testing.allocator; { - const result = try parse(gpa, &[_][]const u8{"format"}); + const result = try parse(gpa, &[_][]const u8{"fmt"}); defer result.deinit(gpa); - try testing.expectEqualStrings("main.roc", result.format.paths[0]); - try testing.expect(!result.format.stdin); - try testing.expect(!result.format.check); + try testing.expectEqualStrings("main.roc", result.fmt.paths[0]); + try testing.expect(!result.fmt.stdin); + try testing.expect(!result.fmt.check); } { - const result = try parse(gpa, &[_][]const u8{ "format", "--check" }); + const result = try parse(gpa, &[_][]const u8{ "fmt", "--check" }); defer result.deinit(gpa); - try testing.expectEqualStrings("main.roc", result.format.paths[0]); - try testing.expect(!result.format.stdin); - try testing.expect(result.format.check); + try testing.expectEqualStrings("main.roc", result.fmt.paths[0]); + try testing.expect(!result.fmt.stdin); + try testing.expect(result.fmt.check); } { - const result = try parse(gpa, &[_][]const u8{ "format", "--stdin" }); + const result = try parse(gpa, &[_][]const u8{ "fmt", "--stdin" }); defer result.deinit(gpa); - try testing.expectEqualStrings("main.roc", result.format.paths[0]); - try testing.expect(result.format.stdin); - try testing.expect(!result.format.check); + try testing.expectEqualStrings("main.roc", result.fmt.paths[0]); + try testing.expect(result.fmt.stdin); + try testing.expect(!result.fmt.check); } { - const result = try parse(gpa, &[_][]const u8{ "format", "--stdin", "--check", "foo.roc" }); + const result = try parse(gpa, &[_][]const u8{ "fmt", "--stdin", "--check", "foo.roc" }); defer result.deinit(gpa); - try testing.expectEqualStrings("foo.roc", result.format.paths[0]); - try testing.expect(result.format.stdin); - try testing.expect(result.format.check); + try testing.expectEqualStrings("foo.roc", result.fmt.paths[0]); + try testing.expect(result.fmt.stdin); + try testing.expect(result.fmt.check); } { - const result = try parse(gpa, &[_][]const u8{ "format", "foo.roc", "bar.roc" }); + const result = try parse(gpa, &[_][]const u8{ "fmt", "foo.roc", "bar.roc" }); defer result.deinit(gpa); - try testing.expectEqualStrings("foo.roc", result.format.paths[0]); - try testing.expectEqualStrings("bar.roc", result.format.paths[1]); + try testing.expectEqualStrings("foo.roc", result.fmt.paths[0]); + try testing.expectEqualStrings("bar.roc", result.fmt.paths[1]); } { - const result = try parse(gpa, &[_][]const u8{ "format", "-h" }); + const result = try parse(gpa, &[_][]const u8{ "fmt", "-h" }); defer result.deinit(gpa); try testing.expectEqual(.help, std.meta.activeTag(result)); } { - const result = try parse(gpa, &[_][]const u8{ "format", "--help" }); + const result = try parse(gpa, &[_][]const u8{ "fmt", "--help" }); defer result.deinit(gpa); try testing.expectEqual(.help, std.meta.activeTag(result)); } { - const result = try parse(gpa, &[_][]const u8{ "format", "foo.roc", "--help" }); + const result = try parse(gpa, &[_][]const u8{ "fmt", "foo.roc", "--help" }); defer result.deinit(gpa); try testing.expectEqual(.help, std.meta.activeTag(result)); } { - const result = try parse(gpa, &[_][]const u8{ "format", "--thisisactuallyafile" }); + const result = try parse(gpa, &[_][]const u8{ "fmt", "--thisisactuallyafile" }); defer result.deinit(gpa); - try testing.expectEqualStrings("--thisisactuallyafile", result.format.paths[0]); + try testing.expectEqualStrings("--thisisactuallyafile", result.fmt.paths[0]); } } @@ -1018,20 +1039,34 @@ test "roc docs" { const result = try parse(gpa, &[_][]const u8{"docs"}); defer result.deinit(gpa); try testing.expectEqualStrings("main.roc", result.docs.path); + try testing.expectEqual(null, result.docs.main); try testing.expectEqualStrings("generated-docs", result.docs.output); - try testing.expectEqual(null, result.docs.root_dir); + try testing.expectEqual(false, result.docs.time); + try testing.expectEqual(false, result.docs.no_cache); + try testing.expectEqual(false, result.docs.verbose); } { - const result = try parse(gpa, &[_][]const u8{ "docs", "foo/bar.roc", "--root-dir=/root/dir", "--output=my_output_dir" }); + const result = try parse(gpa, &[_][]const u8{ "docs", "foo.roc" }); defer result.deinit(gpa); - try testing.expectEqualStrings("foo/bar.roc", result.docs.path); - try testing.expectEqualStrings("my_output_dir", result.docs.output); - try testing.expectEqualStrings("/root/dir", result.docs.root_dir.?); + try testing.expectEqualStrings("foo.roc", result.docs.path); + try testing.expectEqualStrings("generated-docs", result.docs.output); } { - const result = try parse(gpa, &[_][]const u8{ "docs", "foo.roc", "--madeup" }); + const result = try parse(gpa, &[_][]const u8{ "docs", "--main=mymain.roc", "foo.roc" }); defer result.deinit(gpa); - try testing.expectEqualStrings("--madeup", result.problem.unexpected_argument.arg); + try testing.expectEqualStrings("foo.roc", result.docs.path); + try testing.expectEqualStrings("mymain.roc", result.docs.main.?); + } + { + const result = try parse(gpa, &[_][]const u8{ "docs", "--output=my-docs", "foo.roc" }); + defer result.deinit(gpa); + try testing.expectEqualStrings("foo.roc", result.docs.path); + try testing.expectEqualStrings("my-docs", result.docs.output); + } + { + const result = try parse(gpa, &[_][]const u8{ "docs", "foo.roc", "bar.roc" }); + defer result.deinit(gpa); + try testing.expectEqualStrings("bar.roc", result.problem.unexpected_argument.arg); } { const result = try parse(gpa, &[_][]const u8{ "docs", "-h" }); @@ -1048,6 +1083,29 @@ test "roc docs" { defer result.deinit(gpa); try testing.expectEqual(.help, std.meta.activeTag(result)); } + { + const result = try parse(gpa, &[_][]const u8{ "docs", "--time" }); + defer result.deinit(gpa); + try testing.expectEqualStrings("main.roc", result.docs.path); + try testing.expectEqual(true, result.docs.time); + } + { + const result = try parse(gpa, &[_][]const u8{ "docs", "foo.roc", "--time", "--main=bar.roc" }); + defer result.deinit(gpa); + try testing.expectEqualStrings("foo.roc", result.docs.path); + try testing.expectEqualStrings("bar.roc", result.docs.main.?); + try testing.expectEqual(true, result.docs.time); + } + { + const result = try parse(gpa, &[_][]const u8{ "docs", "--no-cache" }); + defer result.deinit(gpa); + try testing.expectEqual(true, result.docs.no_cache); + } + { + const result = try parse(gpa, &[_][]const u8{ "docs", "--verbose" }); + defer result.deinit(gpa); + try testing.expectEqual(true, result.docs.verbose); + } } test "roc help" { diff --git a/src/cli/main.zig b/src/cli/main.zig index c1de2a2198..0bb89cd754 100644 --- a/src/cli/main.zig +++ b/src/cli/main.zig @@ -449,7 +449,7 @@ fn mainArgs(gpa: Allocator, arena: Allocator, args: []const []const u8) !void { .build => |build_args| rocBuild(gpa, build_args), .bundle => |bundle_args| rocBundle(gpa, bundle_args), .unbundle => |unbundle_args| rocUnbundle(gpa, unbundle_args), - .format => |format_args| rocFormat(gpa, arena, format_args), + .fmt => |format_args| rocFormat(gpa, arena, format_args), .test_cmd => |test_args| rocTest(gpa, test_args), .repl => rocRepl(gpa), .version => stdout.print("Roc compiler version {s}", .{build_options.compiler_version}), @@ -1368,6 +1368,10 @@ pub fn setupSharedMemoryWithModuleEnv(gpa: std.mem.Allocator, roc_file_path: []c const basename = std.fs.path.basename(roc_file_path); const module_name = try shm_allocator.dupe(u8, basename); + // Create arena allocator for scratch memory + var arena = std.heap.ArenaAllocator.init(shm_allocator); + defer arena.deinit(); + var env = try ModuleEnv.init(shm_allocator, source); env.common.source = source; env.module_name = module_name; @@ -1381,12 +1385,18 @@ pub fn setupSharedMemoryWithModuleEnv(gpa: std.mem.Allocator, roc_file_path: []c // Initialize CIR fields in ModuleEnv try env.initCIRFields(shm_allocator, module_name); + const common_idents: Check.CommonIdents = .{ + .module_name = try env.insertIdent(base.Ident.for_text("test")), + .list = try env.insertIdent(base.Ident.for_text("List")), + .box = try env.insertIdent(base.Ident.for_text("Box")), + }; // Create canonicalizer - var canonicalizer = try Can.init(&env, &parse_ast, null); + var canonicalizer = try Can.init(&env, &parse_ast, null, .{}); // Canonicalize the entire module try canonicalizer.canonicalizeFile(); + try canonicalizer.validateForExecution(); // Validation check - ensure exports were populated during canonicalization if (env.exports.span.len == 0) { @@ -1413,8 +1423,8 @@ pub fn setupSharedMemoryWithModuleEnv(gpa: std.mem.Allocator, roc_file_path: []c } // Type check the module - var checker = try Check.init(shm_allocator, &env.types, &env, &.{}, &env.store.regions); - try checker.checkDefs(); + var checker = try Check.init(shm_allocator, &env.types, &env, &.{}, &env.store.regions, common_idents); + try checker.checkFile(); // Copy the ModuleEnv to the allocated space env_ptr.* = env; @@ -1754,6 +1764,10 @@ fn extractEntrypointsFromPlatform(gpa: std.mem.Allocator, roc_file_path: []const const module_name = try gpa.dupe(u8, basename); defer gpa.free(module_name); + // Create arena allocator for scratch memory + var arena = std.heap.ArenaAllocator.init(gpa); + defer arena.deinit(); + // Create ModuleEnv var env = ModuleEnv.init(gpa, source) catch return error.ParseFailed; defer env.deinit(); @@ -2418,6 +2432,10 @@ fn rocTest(gpa: Allocator, args: cli_args.TestArgs) !void { const module_name = try gpa.dupe(u8, basename); defer gpa.free(module_name); + // Create arena allocator for scratch memory + var arena = std.heap.ArenaAllocator.init(gpa); + defer arena.deinit(); + // Create ModuleEnv var env = ModuleEnv.init(gpa, source) catch |err| { try stderr.print("Failed to initialize module environment: {}", .{err}); @@ -2429,6 +2447,12 @@ fn rocTest(gpa: Allocator, args: cli_args.TestArgs) !void { env.module_name = module_name; try env.common.calcLineStarts(gpa); + const module_common_idents: Check.CommonIdents = .{ + .module_name = try env.insertIdent(base.Ident.for_text(module_name)), + .list = try env.insertIdent(base.Ident.for_text("List")), + .box = try env.insertIdent(base.Ident.for_text("Box")), + }; + // Parse the source code as a full module var parse_ast = parse.parse(&env.common, gpa) catch |err| { try stderr.print("Failed to parse file: {}", .{err}); @@ -2443,7 +2467,7 @@ fn rocTest(gpa: Allocator, args: cli_args.TestArgs) !void { try env.initCIRFields(gpa, module_name); // Create canonicalizer - var canonicalizer = Can.init(&env, &parse_ast, null) catch |err| { + var canonicalizer = Can.init(&env, &parse_ast, null, .{}) catch |err| { try stderr.print("Failed to initialize canonicalizer: {}", .{err}); std.process.exit(1); }; @@ -2455,14 +2479,20 @@ fn rocTest(gpa: Allocator, args: cli_args.TestArgs) !void { std.process.exit(1); }; + // Validate for checking mode + canonicalizer.validateForChecking() catch |err| { + try stderr.print("Failed to validate module: {}", .{err}); + std.process.exit(1); + }; + // Type check the module - var checker = Check.init(gpa, &env.types, &env, &.{}, &env.store.regions) catch |err| { + var checker = Check.init(gpa, &env.types, &env, &.{}, &env.store.regions, module_common_idents) catch |err| { try stderr.print("Failed to initialize type checker: {}", .{err}); std.process.exit(1); }; defer checker.deinit(); - checker.checkDefs() catch |err| { + checker.checkFile() catch |err| { try stderr.print("Type checking failed: {}", .{err}); std.process.exit(1); }; @@ -2508,11 +2538,30 @@ fn rocTest(gpa: Allocator, args: cli_args.TestArgs) !void { if (test_result.passed) { try stdout.print("\x1b[32mPASS\x1b[0m: {s}:{}\n", .{ args.path, region_info.start_line_idx + 1 }); } else { - if (test_result.error_msg) |msg| { - try stdout.print("\x1b[31mFAIL\x1b[0m: {s}:{} - {s}\n", .{ args.path, region_info.start_line_idx + 1, msg }); - } else { - try stdout.print("\x1b[31mFAIL\x1b[0m: {s}:{}\n", .{ args.path, region_info.start_line_idx + 1 }); - } + // Generate and render a detailed report for this failure + var report = test_runner.createReport(test_result, args.path) catch |err| { + // Fallback to simple message if report generation fails + try stderr.print("\x1b[31mFAIL\x1b[0m: {s}:{}", .{ args.path, region_info.start_line_idx + 1 }); + if (test_result.error_msg) |msg| { + try stderr.print(" - {s}", .{msg}); + } + try stderr.print(" (report generation failed: {})\n", .{err}); + continue; + }; + defer report.deinit(); + + // Render the report to terminal + const palette = reporting.ColorUtils.getPaletteForConfig(reporting.ReportingConfig.initColorTerminal()); + const config = reporting.ReportingConfig.initColorTerminal(); + try reporting.renderReportToTerminal(&report, stderr.any(), palette, config); + } + } + } else { + // Non-verbose mode: just show simple FAIL messages with line numbers + for (test_runner.test_results.items) |test_result| { + if (!test_result.passed) { + const region_info = env.calcRegionInfo(test_result.region); + try stderr.print("\x1b[31mFAIL\x1b[0m: {s}:{}\n", .{ args.path, region_info.start_line_idx + 1 }); } } } @@ -2677,6 +2726,118 @@ const BuildAppError = std.mem.Allocator.Error || std.fs.File.OpenError || std.fs CurrentWorkingDirectoryUnlinked, }; +/// Result from checking a file that preserves the BuildEnv for further processing (e.g., docs generation) +const CheckResultWithBuildEnv = struct { + check_result: CheckResult, + build_env: BuildEnv, + + /// Free allocated memory including the BuildEnv + pub fn deinit(self: *CheckResultWithBuildEnv, gpa: Allocator) void { + self.check_result.deinit(gpa); + self.build_env.deinit(); + } +}; + +/// Check a Roc file using BuildEnv and preserve the BuildEnv for further processing +fn checkFileWithBuildEnvPreserved( + gpa: Allocator, + filepath: []const u8, + collect_timing: bool, + cache_config: CacheConfig, +) BuildAppError!CheckResultWithBuildEnv { + _ = collect_timing; // Timing is always collected by BuildEnv + const trace = tracy.trace(@src()); + defer trace.end(); + + // Initialize BuildEnv in single-threaded mode for checking + var build_env = BuildEnv.init(gpa, .single_threaded, 1); + build_env.compiler_version = build_options.compiler_version; + // Note: We do NOT defer build_env.deinit() here because we're returning it + + // Set up cache manager if caching is enabled + if (cache_config.enabled) { + const cache_manager = try gpa.create(CacheManager); + cache_manager.* = CacheManager.init(gpa, cache_config, Filesystem.default()); + build_env.setCacheManager(cache_manager); + // Note: BuildEnv.deinit() will clean up the cache manager when caller calls deinit + } + + // Build the file (works for both app and module files) + build_env.build(filepath) catch |err| { + return err; + }; + + // Force processing to ensure canonicalization happens + var sched_iter = build_env.schedulers.iterator(); + if (sched_iter.next()) |sched_entry| { + const package_env = sched_entry.value_ptr.*; + if (package_env.modules.items.len > 0) { + const module_name = package_env.modules.items[0].name; + + // Keep processing until the module is done + var max_iterations: u32 = 20; + while (max_iterations > 0) : (max_iterations -= 1) { + const phase = package_env.modules.items[0].phase; + if (phase == .Done) break; + + package_env.processModuleByName(module_name) catch |err| { + std.debug.print("Error processing module: {}\n", .{err}); + break; + }; + } + } + } + + // Drain all reports + const drained = try build_env.drainReports(); + + // Count errors and warnings + var error_count: u32 = 0; + var warning_count: u32 = 0; + + for (drained) |mod| { + for (mod.reports) |report| { + switch (report.severity) { + .info => {}, + .runtime_error, .fatal => error_count += 1, + .warning => warning_count += 1, + } + } + } + + // Convert BuildEnv drained reports to our format + var reports = try gpa.alloc(DrainedReport, drained.len); + for (drained, 0..) |mod, i| { + reports[i] = .{ + .file_path = try gpa.dupe(u8, mod.abs_path), + .reports = try gpa.dupe(reporting.Report, mod.reports), + }; + } + + // Free the original drained reports + // Note: abs_path is owned by BuildEnv, reports are moved to our array + gpa.free(drained); + + // Get timing information from BuildEnv + const timing = if (builtin.target.cpu.arch == .wasm32) + CheckTimingInfo{} + else + build_env.getTimingInfo(); + + const check_result = CheckResult{ + .reports = reports, + .timing = timing, + .was_cached = false, // BuildEnv doesn't currently expose cache info + .error_count = error_count, + .warning_count = warning_count, + }; + + return CheckResultWithBuildEnv{ + .check_result = check_result, + .build_env = build_env, + }; +} + /// Check a Roc file using the BuildEnv system fn checkFileWithBuildEnv( gpa: Allocator, @@ -2862,10 +3023,760 @@ fn printTimingBreakdown(writer: anytype, timing: ?CheckTimingInfo) void { } } +/// Start an HTTP server to serve the generated documentation +fn serveDocumentation(gpa: Allocator, docs_dir: []const u8) !void { + const stdout = std.io.getStdOut().writer(); + + const address = try std.net.Address.parseIp("127.0.0.1", 8080); + var server = try address.listen(.{ + .reuse_address = true, + }); + defer server.deinit(); + + stdout.print("Visit http://localhost:8080 to view the docs at ./{s}/\n", .{docs_dir}) catch {}; + stdout.print("Press Ctrl+C to stop the server\n", .{}) catch {}; + + while (true) { + const connection = try server.accept(); + handleConnection(gpa, connection, docs_dir) catch |err| { + std.debug.print("Error handling connection: {}\n", .{err}); + }; + } +} + +/// Handle a single HTTP connection +fn handleConnection(gpa: Allocator, connection: std.net.Server.Connection, docs_dir: []const u8) !void { + defer connection.stream.close(); + + var buffer: [4096]u8 = undefined; + const bytes_read = try connection.stream.read(&buffer); + + if (bytes_read == 0) return; + + const request = buffer[0..bytes_read]; + + // Parse the request line (e.g., "GET /path HTTP/1.1") + var lines = std.mem.splitSequence(u8, request, "\r\n"); + const request_line = lines.next() orelse return; + + var parts = std.mem.splitSequence(u8, request_line, " "); + const method = parts.next() orelse return; + const path = parts.next() orelse return; + + if (!std.mem.eql(u8, method, "GET")) { + try sendResponse(connection.stream, "405 Method Not Allowed", "text/plain", "Method Not Allowed"); + return; + } + + // Determine the file path to serve + const file_path = try resolveFilePath(gpa, docs_dir, path); + defer gpa.free(file_path); + + // Try to open and serve the file + const file = std.fs.cwd().openFile(file_path, .{}) catch |err| { + if (err == error.FileNotFound) { + try sendResponse(connection.stream, "404 Not Found", "text/plain", "File Not Found"); + } else { + try sendResponse(connection.stream, "500 Internal Server Error", "text/plain", "Internal Server Error"); + } + return; + }; + defer file.close(); + + // Read file contents + const file_content = try file.readToEndAlloc(gpa, 10 * 1024 * 1024); // 10MB max + defer gpa.free(file_content); + + // Determine content type + const content_type = getContentType(file_path); + + // Send response + try sendResponse(connection.stream, "200 OK", content_type, file_content); +} + +/// Resolve the file path based on the URL path +fn resolveFilePath(gpa: Allocator, docs_dir: []const u8, url_path: []const u8) ![]const u8 { + // Remove leading slash + const clean_path = if (url_path.len > 0 and url_path[0] == '/') + url_path[1..] + else + url_path; + + // If path is empty or ends with /, serve index.html + if (clean_path.len == 0 or clean_path[clean_path.len - 1] == '/') { + return try std.fmt.allocPrint(gpa, "{s}/{s}index.html", .{ docs_dir, clean_path }); + } + + // Check if the path has a file extension (contains a dot in the last component) + const last_slash = std.mem.lastIndexOfScalar(u8, clean_path, '/') orelse 0; + const last_component = clean_path[last_slash..]; + const has_extension = std.mem.indexOfScalar(u8, last_component, '.') != null; + + if (has_extension) { + // Path has extension, serve the file directly + return try std.fmt.allocPrint(gpa, "{s}/{s}", .{ docs_dir, clean_path }); + } else { + // No extension, serve index.html from that directory + return try std.fmt.allocPrint(gpa, "{s}/{s}/index.html", .{ docs_dir, clean_path }); + } +} + +/// Get content type based on file extension +fn getContentType(file_path: []const u8) []const u8 { + if (std.mem.endsWith(u8, file_path, ".html")) { + return "text/html; charset=utf-8"; + } else if (std.mem.endsWith(u8, file_path, ".css")) { + return "text/css"; + } else if (std.mem.endsWith(u8, file_path, ".js")) { + return "application/javascript"; + } else if (std.mem.endsWith(u8, file_path, ".json")) { + return "application/json"; + } else if (std.mem.endsWith(u8, file_path, ".png")) { + return "image/png"; + } else if (std.mem.endsWith(u8, file_path, ".jpg") or std.mem.endsWith(u8, file_path, ".jpeg")) { + return "image/jpeg"; + } else if (std.mem.endsWith(u8, file_path, ".svg")) { + return "image/svg+xml"; + } else { + return "text/plain"; + } +} + +/// Send an HTTP response +fn sendResponse(stream: std.net.Stream, status: []const u8, content_type: []const u8, body: []const u8) !void { + var response_buffer: [8192]u8 = undefined; + const response = try std.fmt.bufPrint( + &response_buffer, + "HTTP/1.1 {s}\r\n" ++ + "Content-Type: {s}\r\n" ++ + "Content-Length: {d}\r\n" ++ + "Connection: close\r\n" ++ + "\r\n", + .{ status, content_type, body.len }, + ); + + try stream.writeAll(response); + try stream.writeAll(body); +} + fn rocDocs(gpa: Allocator, args: cli_args.DocsArgs) !void { - _ = gpa; - _ = args; - fatal("docs not implemented", .{}); + const trace = tracy.trace(@src()); + defer trace.end(); + + const stdout = std.io.getStdOut().writer(); + const stderr = std.io.getStdErr().writer(); + const stderr_writer = stderr.any(); + + var timer = try std.time.Timer.start(); + + // Set up cache configuration based on command line args + const cache_config = CacheConfig{ + .enabled = !args.no_cache, + .verbose = args.verbose, + }; + + // Use BuildEnv to check the file, preserving the BuildEnv for docs generation + var result_with_env = checkFileWithBuildEnvPreserved( + gpa, + args.path, + args.time, + cache_config, + ) catch |err| { + handleProcessFileError(err, stderr, args.path); + }; + + // Clean up when we're done - this includes the BuildEnv and all module envs + defer result_with_env.deinit(gpa); + + const check_result = &result_with_env.check_result; + const elapsed = timer.read(); + + // Handle cached results vs fresh compilation results differently + if (check_result.was_cached) { + // For cached results, use the stored diagnostic counts + const total_errors = check_result.error_count; + const total_warnings = check_result.warning_count; + + if (total_errors > 0 or total_warnings > 0) { + stderr.print("Found {} error(s) and {} warning(s) in ", .{ + total_errors, + total_warnings, + }) catch {}; + formatElapsedTime(stderr, elapsed) catch {}; + stderr.print(" for {s} (note module loaded from cache, use --no-cache to display Errors and Warnings.).", .{args.path}) catch {}; + std.process.exit(1); + } + } else { + // For fresh compilation, process and display reports normally + var has_errors = false; + + // Render reports grouped by module + for (check_result.reports) |module| { + for (module.reports) |*report| { + + // Render the diagnostic report to stderr + reporting.renderReportToTerminal(report, stderr_writer, ColorPalette.ANSI, reporting.ReportingConfig.initColorTerminal()) catch |render_err| { + stderr.print("Error rendering diagnostic report: {}", .{render_err}) catch {}; + // Fallback to just printing the title + stderr.print(" {s}", .{report.title}) catch {}; + }; + + if (report.severity == .fatal or report.severity == .runtime_error) { + has_errors = true; + } + } + } + + if (check_result.error_count > 0 or check_result.warning_count > 0) { + stderr.writeAll("\n") catch {}; + stderr.print("Found {} error(s) and {} warning(s) in ", .{ + check_result.error_count, + check_result.warning_count, + }) catch {}; + formatElapsedTime(stderr, elapsed) catch {}; + stderr.print(" for {s}.", .{args.path}) catch {}; + + if (check_result.error_count > 0) { + std.process.exit(1); + } + } + } + + // Print timing breakdown if requested + if (args.time) { + printTimingBreakdown(stdout, if (builtin.target.cpu.arch == .wasm32) null else check_result.timing); + } + + // Generate documentation for all packages and modules + try generateDocs(gpa, &result_with_env.build_env, args.path, args.output); + + stdout.print("\nDocumentation generation complete for {s}\n", .{args.path}) catch {}; + + // Start HTTP server if --serve flag is enabled + if (args.serve) { + try serveDocumentation(gpa, args.output); + } +} + +/// Associated item (type or value) within a module or type +pub const AssociatedItem = struct { + name: []const u8, + children: []AssociatedItem, // Nested associated items (for types with associated items) + + fn deinit(self: AssociatedItem, gpa: Allocator) void { + gpa.free(self.name); + for (self.children) |child| { + child.deinit(gpa); + } + gpa.free(self.children); + } +}; + +/// Information about an imported module +pub const ModuleInfo = struct { + name: []const u8, // e.g., "Foo" or "foo.Bar" + link_path: []const u8, // e.g., "Foo" or "foo/Bar" + associated_items: []AssociatedItem, // Types and values defined in this module + + fn deinit(self: ModuleInfo, gpa: Allocator) void { + gpa.free(self.name); + gpa.free(self.link_path); + for (self.associated_items) |item| { + item.deinit(gpa); + } + gpa.free(self.associated_items); + } +}; + +/// Recursively write associated items as nested
    elements +fn writeAssociatedItems(writer: anytype, items: []const AssociatedItem, indent_level: usize) !void { + // Write opening
      + try writer.writeByteNTimes(' ', indent_level * 2); + try writer.writeAll("
        \n"); + + for (items) |item| { + // Write
      • with item name + try writer.writeByteNTimes(' ', (indent_level + 1) * 2); + try writer.print("
      • {s}\n", .{item.name}); + + // Recursively write children if any + if (item.children.len > 0) { + try writeAssociatedItems(writer, item.children, indent_level + 2); + } + + // Close
      • + try writer.writeByteNTimes(' ', (indent_level + 1) * 2); + try writer.writeAll("
        • \n"); + } + + // Write closing
      + try writer.writeByteNTimes(' ', indent_level * 2); + try writer.writeAll("
    \n"); +} + +/// Generate HTML index file for a package or app +pub fn generatePackageIndex( + gpa: Allocator, + output_path: []const u8, + module_path: []const u8, + package_shorthands: []const []const u8, + imported_modules: []const ModuleInfo, +) !void { + // Create output directory if it doesn't exist + std.fs.cwd().makePath(output_path) catch |err| switch (err) { + error.PathAlreadyExists => {}, + else => return err, + }; + + // Create index.html file + const index_path = try std.fs.path.join(gpa, &[_][]const u8{ output_path, "index.html" }); + defer gpa.free(index_path); + + const file = try std.fs.cwd().createFile(index_path, .{}); + defer file.close(); + + const writer = file.writer(); + + // Write HTML header + try writer.writeAll("\n\n\n"); + try writer.writeAll(" \n"); + try writer.writeAll(" Documentation\n"); + try writer.writeAll("\n\n"); + + // Write module path as h1 + try writer.print("

    {s}

    \n", .{module_path}); + + // Write sidebar with imported modules if any + if (imported_modules.len > 0) { + try writer.writeAll("
      \n"); + for (imported_modules) |mod_info| { + try writer.print("
    • \n {s}\n", .{ mod_info.link_path, mod_info.name }); + + // Write nested associated items if any + if (mod_info.associated_items.len > 0) { + try writeAssociatedItems(writer, mod_info.associated_items, 3); + } + + try writer.writeAll("
      • \n"); + } + try writer.writeAll("
    \n"); + } + + // Write links to package dependencies if any exist + if (package_shorthands.len > 0) { + try writer.writeAll("
      \n"); + for (package_shorthands) |shorthand| { + try writer.print("
    • {s}
      • \n", .{ shorthand, shorthand }); + } + try writer.writeAll("
    \n"); + } + + try writer.writeAll("\n\n"); +} + +/// Generate HTML index file for a module +pub fn generateModuleIndex( + gpa: Allocator, + output_path: []const u8, + module_name: []const u8, +) !void { + // Create output directory if it doesn't exist + std.fs.cwd().makePath(output_path) catch |err| switch (err) { + error.PathAlreadyExists => {}, + else => return err, + }; + + // Create index.html file + const index_path = try std.fs.path.join(gpa, &[_][]const u8{ output_path, "index.html" }); + defer gpa.free(index_path); + + const file = try std.fs.cwd().createFile(index_path, .{}); + defer file.close(); + + const writer = file.writer(); + + // Write HTML header + try writer.writeAll("\n\n\n"); + try writer.writeAll(" \n"); + try writer.print(" {s}\n", .{module_name}); + try writer.writeAll("\n\n"); + + // Write module name as h1 + try writer.print("

    {s}

    \n", .{module_name}); + + try writer.writeAll("\n\n"); +} + +/// Extract associated items from a record expression (recursively) +fn extractRecordAssociatedItems( + gpa: Allocator, + module_env: *const ModuleEnv, + record_fields: can.CIR.RecordField.Span, +) ![]AssociatedItem { + var items = std.array_list.Managed(AssociatedItem).init(gpa); + errdefer { + for (items.items) |item| { + item.deinit(gpa); + } + items.deinit(); + } + + const fields_slice = module_env.store.sliceRecordFields(record_fields); + for (fields_slice) |field_idx| { + const field = module_env.store.getRecordField(field_idx); + const field_name = try gpa.dupe(u8, module_env.getIdentText(field.name)); + errdefer gpa.free(field_name); + + // Check if the field value is a nominal type (has nested associated items) + const field_expr = module_env.store.getExpr(field.value); + const children = switch (field_expr) { + .e_nominal => |nom| blk: { + // Get the nominal type's backing expression + const backing_expr = module_env.store.getExpr(nom.backing_expr); + break :blk switch (backing_expr) { + .e_record => |rec| try extractRecordAssociatedItems(gpa, module_env, rec.fields), + else => try gpa.alloc(AssociatedItem, 0), + }; + }, + else => try gpa.alloc(AssociatedItem, 0), + }; + + try items.append(.{ + .name = field_name, + .children = children, + }); + } + + return try items.toOwnedSlice(); +} + +/// Extract associated items from a module's exports +fn extractAssociatedItems( + gpa: Allocator, + module_env: *const ModuleEnv, +) ![]AssociatedItem { + var items = std.array_list.Managed(AssociatedItem).init(gpa); + errdefer { + for (items.items) |item| { + item.deinit(gpa); + } + items.deinit(); + } + + // Get all exported definitions + const exports_slice = module_env.store.sliceDefs(module_env.exports); + + // If no exports, try all_defs (for modules that are still being processed) + const defs_slice = if (exports_slice.len == 0) + module_env.store.sliceDefs(module_env.all_defs) + else + exports_slice; + + for (defs_slice) |def_idx| { + const def = module_env.store.getDef(def_idx); + + // Get the pattern to find the name + const pattern = module_env.store.getPattern(def.pattern); + + // Extract name from pattern (could be assign, nominal, etc.) + const name_ident_opt = switch (pattern) { + .assign => |a| a.ident, + .nominal => |n| blk: { + // For nominal types, we need to get the statement and extract the header + const stmt = module_env.store.getStatement(n.nominal_type_decl); + break :blk switch (stmt) { + .s_nominal_decl => |decl| module_env.store.getTypeHeader(decl.header).name, + else => continue, + }; + }, + else => continue, + }; + + const name = try gpa.dupe(u8, module_env.getIdentText(name_ident_opt)); + errdefer gpa.free(name); + + // Extract nested associated items if this is a nominal type with a record + const children = switch (pattern) { + .nominal => blk: { + // For nominal types, look at the expression to find associated items + const expr = module_env.store.getExpr(def.expr); + break :blk switch (expr) { + .e_nominal => |nom_expr| blk2: { + const backing = module_env.store.getExpr(nom_expr.backing_expr); + break :blk2 switch (backing) { + .e_record => |record| try extractRecordAssociatedItems(gpa, module_env, record.fields), + else => try gpa.alloc(AssociatedItem, 0), + }; + }, + else => try gpa.alloc(AssociatedItem, 0), + }; + }, + else => try gpa.alloc(AssociatedItem, 0), + }; + + try items.append(.{ + .name = name, + .children = children, + }); + } + + return try items.toOwnedSlice(); +} + +/// Generate documentation for the root and all its dependencies and imported modules +fn generateDocs( + gpa: Allocator, + build_env: *compile.BuildEnv, + module_path: []const u8, + base_output_dir: []const u8, +) !void { + // First, determine if this is an app or other kind + var pkg_iter = build_env.packages.iterator(); + const first_pkg = if (pkg_iter.next()) |entry| entry.value_ptr.* else return; + + const is_app = first_pkg.kind == .app; + + if (is_app) { + // For apps, collect all imported modules and generate sidebar + try generateAppDocs(gpa, build_env, module_path, base_output_dir); + } else { + // For packages, just generate package dependency docs + try generatePackageDocs(gpa, build_env, module_path, base_output_dir, ""); + } +} + +/// Generate docs for an app module +fn generateAppDocs( + gpa: Allocator, + build_env: *compile.BuildEnv, + module_path: []const u8, + base_output_dir: []const u8, +) !void { + // Collect all imported modules (both local and from packages) + var modules_map = std.StringHashMap(ModuleInfo).init(gpa); + defer { + var it = modules_map.iterator(); + while (it.next()) |entry| { + entry.value_ptr.deinit(gpa); + } + modules_map.deinit(); + } + + // Get the root package + var pkg_iter = build_env.packages.iterator(); + const first_pkg = if (pkg_iter.next()) |entry| entry.value_ptr.* else return; + + // Iterate through schedulers to get modules + var sched_iter = build_env.schedulers.iterator(); + while (sched_iter.next()) |sched_entry| { + const package_name = sched_entry.key_ptr.*; + const package_env = sched_entry.value_ptr.*; + + // Iterate through modules in this package + for (package_env.modules.items) |module_state| { + // Process external imports (e.g., "cli.Stdout") + for (module_state.external_imports.items) |ext_import| { + // Parse the import (e.g., "cli.Stdout" -> package="cli", module="Stdout") + if (std.mem.indexOfScalar(u8, ext_import, '.')) |dot_index| { + const pkg_shorthand = ext_import[0..dot_index]; + const module_name = ext_import[dot_index + 1 ..]; + + // Create full name and link path + const full_name = try gpa.dupe(u8, ext_import); + const link_path = try std.fmt.allocPrint(gpa, "{s}/{s}", .{ pkg_shorthand, module_name }); + + const empty_items = [_]AssociatedItem{}; + const mod_info = ModuleInfo{ + .name = full_name, + .link_path = link_path, + .associated_items = &empty_items, + }; + + // Add to map (deduplicates automatically) + const gop = try modules_map.getOrPut(full_name); + if (!gop.found_existing) { + gop.value_ptr.* = mod_info; + } else { + // Free the duplicates + gpa.free(full_name); + gpa.free(link_path); + } + + // Generate index.html for this module + const module_output_dir = try std.fs.path.join(gpa, &[_][]const u8{ base_output_dir, pkg_shorthand, module_name }); + defer gpa.free(module_output_dir); + generateModuleIndex(gpa, module_output_dir, ext_import) catch |err| { + std.debug.print("Warning: failed to generate module index for {s}: {}\n", .{ ext_import, err }); + }; + } + } + + // Process local imports (non-external modules in the same package) + for (module_state.imports.items) |import_id| { + if (import_id < package_env.modules.items.len) { + const imported_module = package_env.modules.items[import_id]; + const module_name = imported_module.name; + + // Skip if this is the root module itself + if (std.mem.eql(u8, module_name, "main")) continue; + + // Only include if it's a local module (not from a package) + if (std.mem.eql(u8, package_name, first_pkg.name)) { + const full_name = try gpa.dupe(u8, module_name); + const link_path = try gpa.dupe(u8, module_name); + + // Extract associated items from the module if it has an env + const associated_items = if (imported_module.env) |*mod_env| + try extractAssociatedItems(gpa, mod_env) + else + try gpa.alloc(AssociatedItem, 0); + + const mod_info = ModuleInfo{ + .name = full_name, + .link_path = link_path, + .associated_items = associated_items, + }; + + const gop = try modules_map.getOrPut(full_name); + if (!gop.found_existing) { + gop.value_ptr.* = mod_info; + } else { + // Free the duplicates + gpa.free(full_name); + gpa.free(link_path); + for (associated_items) |item| { + item.deinit(gpa); + } + gpa.free(associated_items); + } + + // Generate index.html for this local module + const module_output_dir = try std.fs.path.join(gpa, &[_][]const u8{ base_output_dir, module_name }); + defer gpa.free(module_output_dir); + generateModuleIndex(gpa, module_output_dir, module_name) catch |err| { + std.debug.print("Warning: failed to generate module index for {s}: {}\n", .{ module_name, err }); + }; + } + } + } + } + } + + // Convert map to sorted list + var modules_list = std.array_list.Managed(ModuleInfo).init(gpa); + defer modules_list.deinit(); + var map_iter = modules_map.iterator(); + while (map_iter.next()) |entry| { + try modules_list.append(entry.value_ptr.*); + } + + // Collect package shorthands + var shorthands_list = std.array_list.Managed([]const u8).init(gpa); + defer { + for (shorthands_list.items) |item| gpa.free(item); + shorthands_list.deinit(); + } + + var shorthand_iter = first_pkg.shorthands.iterator(); + while (shorthand_iter.next()) |sh_entry| { + const shorthand = try gpa.dupe(u8, sh_entry.key_ptr.*); + try shorthands_list.append(shorthand); + } + + // Generate root index.html + try generatePackageIndex(gpa, base_output_dir, module_path, shorthands_list.items, modules_list.items); + + // Generate package dependency docs recursively + shorthand_iter = first_pkg.shorthands.iterator(); + while (shorthand_iter.next()) |sh_entry| { + const shorthand = sh_entry.key_ptr.*; + const dep_ref = sh_entry.value_ptr.*; + + generatePackageDocs(gpa, build_env, dep_ref.root_file, base_output_dir, shorthand) catch |err| { + std.debug.print("Warning: failed to generate docs for package {s}: {}\n", .{ shorthand, err }); + }; + } +} + +/// Recursively generate documentation for a package and its dependencies +fn generatePackageDocs( + gpa: Allocator, + build_env: *compile.BuildEnv, + module_path: []const u8, + base_output_dir: []const u8, + relative_path: []const u8, +) error{OutOfMemory}!void { + const output_dir = if (relative_path.len == 0) + try gpa.dupe(u8, base_output_dir) + else + try std.fs.path.join(gpa, &[_][]const u8{ base_output_dir, relative_path }); + defer gpa.free(output_dir); + + var shorthands_list = std.array_list.Managed([]const u8).init(gpa); + defer { + for (shorthands_list.items) |item| gpa.free(item); + shorthands_list.deinit(); + } + + var pkg_iter = build_env.packages.iterator(); + while (pkg_iter.next()) |entry| { + const pkg = entry.value_ptr; + + var shorthand_iter = pkg.shorthands.iterator(); + while (shorthand_iter.next()) |sh_entry| { + const shorthand = try gpa.dupe(u8, sh_entry.key_ptr.*); + try shorthands_list.append(shorthand); + } + + shorthand_iter = pkg.shorthands.iterator(); + while (shorthand_iter.next()) |sh_entry| { + const shorthand = sh_entry.key_ptr.*; + + const dep_relative_path = if (relative_path.len == 0) + try gpa.dupe(u8, shorthand) + else + try std.fs.path.join(gpa, &[_][]const u8{ relative_path, shorthand }); + defer gpa.free(dep_relative_path); + + const dep_ref = sh_entry.value_ptr.*; + generatePackageDocs(gpa, build_env, dep_ref.root_file, base_output_dir, dep_relative_path) catch |err| { + std.debug.print("Warning: failed to generate docs for {s}: {}\n", .{ shorthand, err }); + }; + } + + break; + } + + // For standalone modules, extract and display their exports + var module_infos = std.array_list.Managed(ModuleInfo).init(gpa); + defer { + for (module_infos.items) |mod| mod.deinit(gpa); + module_infos.deinit(); + } + + // Get the module's exports if it's a standalone module + var sched_iter = build_env.schedulers.iterator(); + while (sched_iter.next()) |sched_entry| { + const package_env = sched_entry.value_ptr.*; + + // Check ALL modules in this package + for (package_env.modules.items) |module_state| { + if (module_state.env) |*mod_env| { + const associated_items = try extractAssociatedItems(gpa, mod_env); + const mod_name = try gpa.dupe(u8, module_state.name); + + try module_infos.append(.{ + .name = mod_name, + .link_path = try gpa.dupe(u8, ""), + .associated_items = associated_items, + }); + } + } + } + + generatePackageIndex(gpa, output_dir, module_path, shorthands_list.items, module_infos.items) catch |err| { + std.debug.print("Warning: failed to generate index for {s}: {}\n", .{ module_path, err }); + }; } /// Log a fatal error and exit the process with a non-zero code. diff --git a/src/cli/test_docs.zig b/src/cli/test_docs.zig new file mode 100644 index 0000000000..8492031131 --- /dev/null +++ b/src/cli/test_docs.zig @@ -0,0 +1,351 @@ +//! TODO +const std = @import("std"); +const testing = std.testing; +const main = @import("main.zig"); +const cli_args = @import("cli_args.zig"); + +test "roc docs generates nested package documentation" { + const gpa = testing.allocator; + + // Create a temporary directory for our test + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + + const tmp_path = try tmp.dir.realpathAlloc(gpa, "."); + defer gpa.free(tmp_path); + + // Create nested package structure: + // root (app) -> depends on foo, bar + // foo (package) -> depends on baz + // baz (package) -> depends on qux + // qux (package) -> no deps + // bar (package) -> depends on baz (shared dependency) + + // Create qux package (leaf dependency) + try tmp.dir.makeDir("qux"); + const qux_file = try tmp.dir.createFile("qux/main.roc", .{}); + defer qux_file.close(); + try qux_file.writeAll( + \\package [add] {} + \\ + \\add : I64, I64 -> I64 + \\add = \a, b -> a + b + \\ + ); + + // Create baz package (depends on qux) + try tmp.dir.makeDir("baz"); + const baz_file = try tmp.dir.createFile("baz/main.roc", .{}); + defer baz_file.close(); + try baz_file.writeAll( + \\package [multiply] { qux: "../qux/main.roc" } + \\ + \\multiply : I64, I64 -> I64 + \\multiply = \a, b -> a * b + \\ + ); + + // Create foo package (depends on baz) + try tmp.dir.makeDir("foo"); + const foo_file = try tmp.dir.createFile("foo/main.roc", .{}); + defer foo_file.close(); + try foo_file.writeAll( + \\package [increment] { baz: "../baz/main.roc" } + \\ + \\increment : I64 -> I64 + \\increment = \n -> n + 1 + \\ + ); + + // Create bar package (also depends on baz - shared dependency) + try tmp.dir.makeDir("bar"); + const bar_file = try tmp.dir.createFile("bar/main.roc", .{}); + defer bar_file.close(); + try bar_file.writeAll( + \\package [decrement] { baz: "../baz/main.roc" } + \\ + \\decrement : I64 -> I64 + \\decrement = \n -> n - 1 + \\ + ); + + // Create root app (depends on foo and bar) + const root_file = try tmp.dir.createFile("root.roc", .{}); + defer root_file.close(); + try root_file.writeAll( + \\app [main] { + \\ pf: platform "https://github.com/roc-lang/basic-cli/releases/download/0.19.0/Hj-J_zxz-8W4-Or3AUfyRJHhxUlgwBXNHkJcUqZPnPg.tar.br", + \\ foo: "foo/main.roc", + \\ bar: "bar/main.roc", + \\} + \\ + \\import pf.Stdout + \\ + \\main = + \\ Stdout.line! "Hello" + \\ + ); + + // Create output directory path + const output_dir = try std.fs.path.join(gpa, &[_][]const u8{ tmp_path, "generated-docs" }); + defer gpa.free(output_dir); + + const root_path = try std.fs.path.join(gpa, &[_][]const u8{ tmp_path, "root.roc" }); + defer gpa.free(root_path); + + // Note: We would call main.rocDocs(gpa, args) here, but it requires + // a full build environment setup. Instead, we test the individual + // helper functions in separate tests below. + + // For now, just verify the test structure was created correctly + tmp.dir.access("root.roc", .{}) catch unreachable; + tmp.dir.access("foo/main.roc", .{}) catch unreachable; + tmp.dir.access("bar/main.roc", .{}) catch unreachable; + tmp.dir.access("baz/main.roc", .{}) catch unreachable; + tmp.dir.access("qux/main.roc", .{}) catch unreachable; + + _ = root_path; + _ = output_dir; +} + +test "generatePackageIndex creates valid HTML" { + const gpa = testing.allocator; + + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + + const tmp_path = try tmp.dir.realpathAlloc(gpa, "."); + defer gpa.free(tmp_path); + + // Test with no dependencies or modules + { + const shorthands = [_][]const u8{}; + const modules = [_]main.ModuleInfo{}; + try main.generatePackageIndex(gpa, tmp_path, "test/module.roc", &shorthands, &modules); + + const content = try tmp.dir.readFileAlloc(gpa, "index.html", 10000); + defer gpa.free(content); + + try testing.expect(std.mem.indexOf(u8, content, "

    test/module.roc

    ") != null); + try testing.expect(std.mem.indexOf(u8, content, "") != null); + try testing.expect(std.mem.indexOf(u8, content, "") != null); + } + + // Delete the file for next test + try tmp.dir.deleteFile("index.html"); + + // Test with package dependencies + { + const shorthands = [_][]const u8{ "foo", "bar", "baz" }; + const modules = [_]main.ModuleInfo{}; + try main.generatePackageIndex(gpa, tmp_path, "root.roc", &shorthands, &modules); + + const content = try tmp.dir.readFileAlloc(gpa, "index.html", 10000); + defer gpa.free(content); + + try testing.expect(std.mem.indexOf(u8, content, "

    root.roc

    ") != null); + try testing.expect(std.mem.indexOf(u8, content, "
      ") != null); + try testing.expect(std.mem.indexOf(u8, content, "foo") != null); + try testing.expect(std.mem.indexOf(u8, content, "bar") != null); + try testing.expect(std.mem.indexOf(u8, content, "baz") != null); + } +} + +test "generatePackageIndex with imported modules" { + const gpa = testing.allocator; + + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + + const tmp_path = try tmp.dir.realpathAlloc(gpa, "."); + defer gpa.free(tmp_path); + + // Test with local and package modules + { + const shorthands = [_][]const u8{"pf"}; + + const empty_items = [_]main.AssociatedItem{}; + var modules = [_]main.ModuleInfo{ + .{ .name = try gpa.dupe(u8, "Foo"), .link_path = try gpa.dupe(u8, "Foo"), .associated_items = &empty_items }, + .{ .name = try gpa.dupe(u8, "Bar"), .link_path = try gpa.dupe(u8, "Bar"), .associated_items = &empty_items }, + .{ .name = try gpa.dupe(u8, "pf.Stdout"), .link_path = try gpa.dupe(u8, "pf/Stdout"), .associated_items = &empty_items }, + }; + defer for (modules) |mod| mod.deinit(gpa); + + try main.generatePackageIndex(gpa, tmp_path, "root.roc", &shorthands, &modules); + + const content = try tmp.dir.readFileAlloc(gpa, "index.html", 10000); + defer gpa.free(content); + + // Check for sidebar + try testing.expect(std.mem.indexOf(u8, content, "
        ") != null); + + // Check local modules + try testing.expect(std.mem.indexOf(u8, content, "Foo") != null); + try testing.expect(std.mem.indexOf(u8, content, "Bar") != null); + + // Check package module + try testing.expect(std.mem.indexOf(u8, content, "pf.Stdout") != null); + } +} + +test "generateModuleIndex creates valid HTML" { + const gpa = testing.allocator; + + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + + const tmp_path = try tmp.dir.realpathAlloc(gpa, "."); + defer gpa.free(tmp_path); + + try main.generateModuleIndex(gpa, tmp_path, "Foo"); + + const content = try tmp.dir.readFileAlloc(gpa, "index.html", 10000); + defer gpa.free(content); + + try testing.expect(std.mem.indexOf(u8, content, "

        Foo

        ") != null); + try testing.expect(std.mem.indexOf(u8, content, "Foo") != null); +} + +test "generatePackageIndex handles nested paths" { + const gpa = testing.allocator; + + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + + const tmp_path = try tmp.dir.realpathAlloc(gpa, "."); + defer gpa.free(tmp_path); + + // Create nested directory + try tmp.dir.makeDir("foo"); + try tmp.dir.makeDir("foo/bar"); + + const nested_path = try std.fs.path.join(gpa, &[_][]const u8{ tmp_path, "foo", "bar" }); + defer gpa.free(nested_path); + + const shorthands = [_][]const u8{"baz"}; + const modules = [_]main.ModuleInfo{}; + try main.generatePackageIndex(gpa, nested_path, "foo/bar/module.roc", &shorthands, &modules); + + // Verify the file was created in the nested directory + const content = try tmp.dir.readFileAlloc(gpa, "foo/bar/index.html", 10000); + defer gpa.free(content); + + try testing.expect(std.mem.indexOf(u8, content, "

        foo/bar/module.roc

        ") != null); + try testing.expect(std.mem.indexOf(u8, content, "baz") != null); +} + +test "module deduplication" { + const gpa = testing.allocator; + + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + + const tmp_path = try tmp.dir.realpathAlloc(gpa, "."); + defer gpa.free(tmp_path); + + // Test that duplicate modules are handled correctly (only appear once) + { + const shorthands = [_][]const u8{}; + + const empty_items = [_]main.AssociatedItem{}; + // Create same module twice - simulating what would happen if multiple files import it + var modules = [_]main.ModuleInfo{ + .{ .name = try gpa.dupe(u8, "Foo"), .link_path = try gpa.dupe(u8, "Foo"), .associated_items = &empty_items }, + .{ .name = try gpa.dupe(u8, "pf.Stdout"), .link_path = try gpa.dupe(u8, "pf/Stdout"), .associated_items = &empty_items }, + // Foo appears again - but should only show up once in output + }; + defer for (modules) |mod| mod.deinit(gpa); + + try main.generatePackageIndex(gpa, tmp_path, "root.roc", &shorthands, &modules); + + const content = try tmp.dir.readFileAlloc(gpa, "index.html", 10000); + defer gpa.free(content); + + // Count occurrences of "Foo" link - should appear exactly once + const foo_link = "Foo"; + var count: usize = 0; + var search_start: usize = 0; + while (std.mem.indexOfPos(u8, content, search_start, foo_link)) |pos| { + count += 1; + search_start = pos + foo_link.len; + } + + // Each module should only appear once in the sidebar + try testing.expectEqual(@as(usize, 1), count); + } +} + +test "nested associated items in sidebar" { + const gpa = testing.allocator; + + var tmp = testing.tmpDir(.{}); + defer tmp.cleanup(); + + const tmp_path = try tmp.dir.realpathAlloc(gpa, "."); + defer gpa.free(tmp_path); + + // Create a module with nested associated items like: + // Foo := [Bar, Baz].{ OtherThing := [Etc].{ stuff = "" } thing = {} } + { + const shorthands = [_][]const u8{}; + + // Build the nested structure: stuff is child of OtherThing + const stuff_item = main.AssociatedItem{ + .name = try gpa.dupe(u8, "stuff"), + .children = &[_]main.AssociatedItem{}, + }; + const stuff_items = try gpa.dupe(main.AssociatedItem, &[_]main.AssociatedItem{stuff_item}); + + // OtherThing has stuff as a child + const other_thing = main.AssociatedItem{ + .name = try gpa.dupe(u8, "OtherThing"), + .children = stuff_items, + }; + + // thing has no children + const thing_item = main.AssociatedItem{ + .name = try gpa.dupe(u8, "thing"), + .children = &[_]main.AssociatedItem{}, + }; + + // Foo has both OtherThing and thing as children + const foo_items = try gpa.dupe(main.AssociatedItem, &[_]main.AssociatedItem{ other_thing, thing_item }); + + var modules = [_]main.ModuleInfo{ + .{ + .name = try gpa.dupe(u8, "Foo"), + .link_path = try gpa.dupe(u8, "Foo"), + .associated_items = foo_items, + }, + }; + defer for (modules) |mod| mod.deinit(gpa); + + try main.generatePackageIndex(gpa, tmp_path, "root.roc", &shorthands, &modules); + + const content = try tmp.dir.readFileAlloc(gpa, "index.html", 10000); + defer gpa.free(content); + + // Verify the nested structure exists + try testing.expect(std.mem.indexOf(u8, content, "Foo") != null); + try testing.expect(std.mem.indexOf(u8, content, "
      • OtherThing") != null); + try testing.expect(std.mem.indexOf(u8, content, "
      • thing") != null); + try testing.expect(std.mem.indexOf(u8, content, "
      • stuff") != null); + + // Verify nested
          structure - OtherThing should have a nested
            for stuff + // The structure should be:
          • OtherThing ...
              ...
            • stuff + const other_thing_pos = std.mem.indexOf(u8, content, "
            • OtherThing").?; + const stuff_pos = std.mem.indexOf(u8, content, "
            • stuff").?; + try testing.expect(stuff_pos > other_thing_pos); + + // Verify that there are nested
                tags (multiple levels) + var ul_count: usize = 0; + var search_start: usize = 0; + while (std.mem.indexOfPos(u8, content, search_start, "
                  ")) |pos| { + ul_count += 1; + search_start = pos + 4; + } + // Should have at least 2
                    tags: one for the sidebar, and one for nested items + try testing.expect(ul_count >= 2); + } +} diff --git a/src/collections/CompactWriter.zig b/src/collections/CompactWriter.zig index f93edc6230..d311e065a3 100644 --- a/src/collections/CompactWriter.zig +++ b/src/collections/CompactWriter.zig @@ -16,10 +16,10 @@ pub const SERIALIZATION_ALIGNMENT = std.mem.Alignment.@"16"; const ZEROS: [16]u8 = [_]u8{0} ** 16; -iovecs: std.ArrayList(Iovec), +iovecs: std.array_list.Managed(Iovec), total_bytes: usize, // Track all allocated memory so we can free it in deinit -allocated_memory: std.ArrayList(AllocatedMemory), +allocated_memory: std.array_list.Managed(AllocatedMemory), pub fn init() CompactWriter { return CompactWriter{ diff --git a/src/collections/SortedArrayBuilder.zig b/src/collections/SortedArrayBuilder.zig index 1131b44dff..1d7076b32b 100644 --- a/src/collections/SortedArrayBuilder.zig +++ b/src/collections/SortedArrayBuilder.zig @@ -20,7 +20,7 @@ const CompactWriter = @import("CompactWriter.zig"); /// This is more efficient when we know we won't have duplicates pub fn SortedArrayBuilder(comptime K: type, comptime V: type) type { return struct { - entries: std.ArrayList(Entry) = .{}, + entries: std.array_list.Managed(Entry) = .{}, sorted: bool = true, const Self = @This(); diff --git a/src/collections/safe_list.zig b/src/collections/safe_list.zig index dfbd661cf0..e8ea53ac4b 100644 --- a/src/collections/safe_list.zig +++ b/src/collections/safe_list.zig @@ -95,13 +95,13 @@ pub fn SafeRange(comptime Idx: type) type { /// less likely since indices are only created for valid list entries. pub fn SafeList(comptime T: type) type { return struct { - items: std.ArrayList(T) = .{}, + items: std.array_list.Managed(T) = .{}, /// An index for an item in the list. pub const Idx = enum(u32) { _ }; /// A non-type-safe slice of the list. - pub const Slice = std.ArrayList(T).Slice; + pub const Slice = std.array_list.Managed(T).Slice; /// A type-safe range of the list. pub const Range = SafeRange(Idx); @@ -178,7 +178,7 @@ pub fn SafeList(comptime T: type) type { /// Initialize the `SafeList` with the specified capacity. pub fn initCapacity(gpa: Allocator, capacity: usize) std.mem.Allocator.Error!SafeList(T) { return .{ - .items = try std.ArrayList(T).initCapacity(gpa, capacity), + .items = try std.array_list.Managed(T).initCapacity(gpa, capacity), }; } diff --git a/src/compile/compile_build.zig b/src/compile/compile_build.zig index 2bd3169405..3461467cf9 100644 --- a/src/compile/compile_build.zig +++ b/src/compile/compile_build.zig @@ -470,13 +470,15 @@ pub const BuildEnv = struct { var header_info = try self.parseHeaderDeps(root_abs); defer header_info.deinit(self.gpa); - // Allow both app and module files - if (header_info.kind != .app and header_info.kind != .module) { + // Allow app, module, type_module, and default_app files + const is_executable = header_info.kind == .app or header_info.kind == .default_app; + + if (!is_executable and header_info.kind != .module and header_info.kind != .type_module) { return error.UnsupportedHeader; } - // Create package entry (for both app and module) - const pkg_name = if (header_info.kind == .module) "module" else "app"; + // Create package entry + const pkg_name = if (is_executable) "app" else "module"; const key_pkg = try self.gpa.dupe(u8, pkg_name); const pkg_root_file = try self.gpa.dupe(u8, root_abs); const pkg_root_dir = try self.gpa.dupe(u8, root_dir); @@ -643,7 +645,7 @@ pub const BuildEnv = struct { // Package graph construction // ------------------------ - const PackageKind = enum { app, package, platform, module, hosted }; + const PackageKind = enum { app, package, platform, module, hosted, type_module, default_app }; const PackageRef = struct { name: []const u8, // Package name (alias in workspace) @@ -865,6 +867,15 @@ pub const BuildEnv = struct { info.kind = .hosted; // Hosted headers are like modules but for platform-specific code }, + .type_module => { + info.kind = .type_module; + // Type modules are headerless files with a top-level type matching the filename + // They don't have package dependencies + }, + .default_app => { + info.kind = .default_app; + // Default app headers are for REPL-style execution + }, else => return error.UnsupportedHeader, } diff --git a/src/compile/compile_package.zig b/src/compile/compile_package.zig index 4aa57eaf57..c2b2fcbc34 100644 --- a/src/compile/compile_package.zig +++ b/src/compile/compile_package.zig @@ -94,11 +94,11 @@ const ModuleState = struct { path: []const u8, env: ?ModuleEnv = null, phase: Phase = .Parse, - imports: std.ArrayList(ModuleId) = .{}, + imports: std.array_list.Managed(ModuleId) = .{}, /// External imports qualified via package shorthand (e.g. "cli.Stdout") - still strings as they reference other packages - external_imports: std.ArrayList([]const u8) = .{}, - dependents: std.ArrayList(ModuleId) = .{}, - reports: std.ArrayList(Report) = .{}, + external_imports: std.array_list.Managed([]const u8) = .{}, + dependents: std.array_list.Managed(ModuleId) = .{}, + reports: std.array_list.Managed(Report) = .{}, depth: u32 = std.math.maxInt(u32), // min depth from root /// DFS visitation color for cycle detection: 0=white (unvisited), 1=gray (visiting), 2=black (finished) visit_color: u8 = 0, @@ -137,10 +137,10 @@ pub const PackageEnv = struct { cond: Condition = .{}, // Work queue - injector: std.ArrayList(Task) = .{}, + injector: std.array_list.Managed(Task) = .{}, // Module storage - modules: std.ArrayList(ModuleState) = .{}, + modules: std.array_list.Managed(ModuleState) = .{}, // String intern table: module name -> module ID module_names: std.StringHashMapUnmanaged(ModuleId) = .{}, @@ -148,7 +148,7 @@ pub const PackageEnv = struct { remaining_modules: usize = 0, // Track module discovery order and which modules have had their reports emitted - discovered: std.ArrayList(ModuleId) = .{}, + discovered: std.array_list.Managed(ModuleId) = .{}, emitted: std.bit_set.DynamicBitSetUnmanaged = .{}, // Timing collection (accumulated across all modules) @@ -497,7 +497,7 @@ pub const PackageEnv = struct { fn doCanonicalize(self: *PackageEnv, module_id: ModuleId) !void { var st = &self.modules.items[module_id]; - var env = st.env.?; + var env = &st.env.?; // Parse and canonicalize in one step to avoid double parsing const parse_start = if (@import("builtin").target.cpu.arch != .wasm32) std.time.nanoTimestamp() else 0; @@ -511,7 +511,7 @@ pub const PackageEnv = struct { // canonicalize using the AST const canon_start = if (@import("builtin").target.cpu.arch != .wasm32) std.time.nanoTimestamp() else 0; - var czer = try Can.init(&env, &parse_ast, null); + var czer = try Can.init(env, &parse_ast, null, .{}); try czer.canonicalizeFile(); czer.deinit(); const canon_end = if (@import("builtin").target.cpu.arch != .wasm32) std.time.nanoTimestamp() else 0; @@ -541,7 +541,7 @@ pub const PackageEnv = struct { const mod_name = env.getString(str_idx); // Use CIR qualifier metadata instead of heuristic; this allocates nothing and scans only once - const qualified = hadQualifiedImport(&env, mod_name); + const qualified = hadQualifiedImport(env, mod_name); if (qualified) { // Qualified imports refer to external packages; track and schedule externally @@ -680,6 +680,12 @@ pub const PackageEnv = struct { var st = &self.modules.items[module_id]; var env = st.env.?; + const module_common_idents: Check.CommonIdents = .{ + .module_name = try env.insertIdent(base.Ident.for_text("test")), + .list = try env.insertIdent(base.Ident.for_text("List")), + .box = try env.insertIdent(base.Ident.for_text("Box")), + }; + // Build other_modules array according to env.imports order const import_count = env.imports.imports.items.items.len; var others = try std.array_list.Managed(*ModuleEnv).initCapacity(self.gpa, import_count); @@ -710,11 +716,11 @@ pub const PackageEnv = struct { } } - var checker = try Check.init(self.gpa, &env.types, &env, others.items, &env.store.regions); + var checker = try Check.init(self.gpa, &env.types, &env, others.items, &env.store.regions, module_common_idents); defer checker.deinit(); // Note: checkDefs runs type checking for module const check_start = if (@import("builtin").target.cpu.arch != .wasm32) std.time.nanoTimestamp() else 0; - try checker.checkDefs(); + try checker.checkFile(); const check_end = if (@import("builtin").target.cpu.arch != .wasm32) std.time.nanoTimestamp() else 0; if (@import("builtin").target.cpu.arch != .wasm32) { self.total_type_checking_ns += @intCast(check_end - check_start); diff --git a/src/compile/test/module_env_test.zig b/src/compile/test/module_env_test.zig index b2841a7df2..1ec89a2b6c 100644 --- a/src/compile/test/module_env_test.zig +++ b/src/compile/test/module_env_test.zig @@ -84,10 +84,12 @@ test "ModuleEnv.Serialized roundtrip" { env.* = ModuleEnv{ .gpa = gpa, .common = deserialized_ptr.common.deserialize(@as(i64, @intCast(@intFromPtr(buffer.ptr))), source).*, - .types = deserialized_ptr.types.deserialize(@as(i64, @intCast(@intFromPtr(buffer.ptr)))).*, + .types = deserialized_ptr.types.deserialize(@as(i64, @intCast(@intFromPtr(buffer.ptr))), gpa).*, + .module_kind = deserialized_ptr.module_kind, .all_defs = deserialized_ptr.all_defs, .all_statements = deserialized_ptr.all_statements, .exports = deserialized_ptr.exports, + .builtin_statements = deserialized_ptr.builtin_statements, .external_decls = deserialized_ptr.external_decls.deserialize(@as(i64, @intCast(@intFromPtr(buffer.ptr)))).*, .imports = deserialized_ptr.imports.deserialize(@as(i64, @intCast(@intFromPtr(buffer.ptr))), deser_alloc).*, .module_name = "TestModule", diff --git a/src/eval/interpreter.zig b/src/eval/interpreter.zig index 8fdf554a18..eea78ca937 100644 --- a/src/eval/interpreter.zig +++ b/src/eval/interpreter.zig @@ -33,6 +33,8 @@ pub const Interpreter = struct { NotNumeric, NullStackPointer, RecordIndexOutOfBounds, + InvalidNumExt, + InvalidTagExt, StringOrderingNotSupported, StackOverflow, TupleIndexOutOfBounds, @@ -113,6 +115,8 @@ pub const Interpreter = struct { bool_false_index: u8, bool_true_index: u8, canonical_bool_rt_var: ?types.Var, + // Used to unwrap extensible tags + scratch_tags: std.array_list.Managed(types.Tag), pub fn init(allocator: std.mem.Allocator, env: *can.ModuleEnv) !Interpreter { const rt_types_ptr = try allocator.create(types.store.Store); @@ -138,6 +142,7 @@ pub const Interpreter = struct { .bool_false_index = 0, .bool_true_index = 1, .canonical_bool_rt_var = null, + .scratch_tags = try std.array_list.Managed(types.Tag).initCapacity(allocator, 8), }; result.runtime_layout_store = try layout.Store.init(env, result.runtime_types); return result; @@ -406,7 +411,7 @@ pub const Interpreter = struct { return try self.evalExprMinimal(blk.final_expr, roc_ops, null); }, - .e_int => |int_lit| { + .e_num => |num_lit| { // Use runtime type to choose layout const rt_var = expected_rt_var orelse blk: { const ct_var = can.ModuleEnv.varFrom(expr_idx); @@ -418,19 +423,19 @@ pub const Interpreter = struct { value.is_initialized = false; switch (layout_val.tag) { .scalar => switch (layout_val.data.scalar.tag) { - .int => value.setInt(int_lit.value.toI128()), + .int => value.setInt(num_lit.value.toI128()), .frac => switch (layout_val.data.scalar.data.frac) { .f32 => { const ptr = @as(*f32, @ptrCast(@alignCast(value.ptr.?))); - ptr.* = @floatFromInt(int_lit.value.toI128()); + ptr.* = @floatFromInt(num_lit.value.toI128()); }, .f64 => { const ptr = @as(*f64, @ptrCast(@alignCast(value.ptr.?))); - ptr.* = @floatFromInt(int_lit.value.toI128()); + ptr.* = @floatFromInt(num_lit.value.toI128()); }, .dec => { const ptr = @as(*RocDec, @ptrCast(@alignCast(value.ptr.?))); - ptr.* = .{ .num = int_lit.value.toI128() * RocDec.one_point_zero_i128 }; + ptr.* = .{ .num = num_lit.value.toI128() * RocDec.one_point_zero_i128 }; }, }, else => return error.TypeMismatch, @@ -676,7 +681,7 @@ pub const Interpreter = struct { } return value; }, - .e_frac_dec => |dec_lit| { + .e_dec => |dec_lit| { const rt_var = expected_rt_var orelse blk: { const ct_var = can.ModuleEnv.varFrom(expr_idx); break :blk try self.translateTypeVar(self.env, ct_var); @@ -698,8 +703,8 @@ pub const Interpreter = struct { const value = try self.pushRaw(layout_val, 0); if (value.ptr) |ptr| { const typed_ptr: *RocDec = @ptrCast(@alignCast(ptr)); - const scale_factor = std.math.pow(i128, 10, RocDec.decimal_places - small.denominator_power_of_ten); - const scaled = @as(i128, small.numerator) * scale_factor; + const scale_factor = std.math.pow(i128, 10, RocDec.decimal_places - small.value.denominator_power_of_ten); + const scaled = @as(i128, small.value.numerator) * scale_factor; typed_ptr.* = RocDec{ .num = scaled }; } return value; @@ -738,7 +743,12 @@ pub const Interpreter = struct { break :blk try self.translateTypeVar(self.env, ct_var); }; - const elem_rt_var = try self.translateTypeVar(self.env, list_expr.elem_var); + // Get the first element's variables, which is representative of all the element vars + const elems = self.env.store.sliceExpr(list_expr.elems); + std.debug.assert(elems.len > 0); + const first_elem_var: types.Var = @enumFromInt(@intFromEnum(elems[0])); + + const elem_rt_var = try self.translateTypeVar(self.env, first_elem_var); const elem_layout = try self.getRuntimeLayout(elem_rt_var); var values = try std.array_list.AlignedManaged(StackValue, null).initCapacity(self.allocator, elem_indices.len); @@ -928,7 +938,17 @@ pub const Interpreter = struct { const ct_var = can.ModuleEnv.varFrom(expr_idx); const nominal_rt_var = try self.translateTypeVar(self.env, ct_var); const nominal_resolved = self.runtime_types.resolveVar(nominal_rt_var); - const backing_rt_var = if (nom.nominal_type_decl == can.Can.BUILTIN_BOOL_TYPE) + // Check if this is Bool by comparing against the first builtin statement + const builtin_stmts_slice = self.env.store.sliceStatements(self.env.builtin_statements); + const bool_decl_idx = if (builtin_stmts_slice.len > 0) blk: { + // Debug assertion: when we have builtins, first must be Bool (a nominal type) + if (std.debug.runtime_safety) { + const stmt = self.env.store.getStatement(builtin_stmts_slice[0]); + std.debug.assert(stmt == .s_nominal_decl); + } + break :blk builtin_stmts_slice[0]; + } else can.Can.BUILTIN_BOOL; + const backing_rt_var = if (nom.nominal_type_decl == bool_decl_idx) try self.getCanonicalBoolRuntimeVar() else switch (nominal_resolved.desc.content) { .structure => |st| switch (st) { @@ -1336,8 +1356,8 @@ pub const Interpreter = struct { .e_call => |call| { const all = self.env.store.sliceExpr(call.args); if (all.len == 0) return error.TypeMismatch; - const func_idx = all[0]; - const arg_indices = all[1..]; + const func_idx = call.func; + const arg_indices = all[0..]; // Runtime unification for call: constrain return type from arg types const func_ct_var = can.ModuleEnv.varFrom(func_idx); const func_rt_var = try self.translateTypeVar(self.env, func_ct_var); @@ -1791,7 +1811,7 @@ pub const Interpreter = struct { fn boolValueIsTrue(self: *Interpreter, value: StackValue, rt_var: types.Var) !bool { if (!self.isBoolLayout(value.layout)) return error.TypeMismatch; try self.prepareBoolIndices(rt_var); - if (!self.runtimeVarIsBool(rt_var)) return error.TypeMismatch; + if (!try self.runtimeVarIsBool(rt_var)) return error.TypeMismatch; const idx = try self.extractBoolTagIndex(value, rt_var); return idx == self.bool_true_index; } @@ -2243,7 +2263,7 @@ pub const Interpreter = struct { return try self.structuralEqualList(lhs, rhs, elem_var); }, .empty_record => true, - .list_unbound, .record_unbound, .record_poly, .fn_pure, .fn_effectful, .fn_unbound, .nominal_type, .empty_tag_union, .box => error.NotImplemented, + .list_unbound, .record_unbound, .fn_pure, .fn_effectful, .fn_unbound, .nominal_type, .empty_tag_union, .box => error.NotImplemented, .str => error.NotImplemented, .num => error.NotImplemented, }; @@ -2429,8 +2449,9 @@ pub const Interpreter = struct { return true; } - fn runtimeVarIsBool(self: *Interpreter, rt_var: types.Var) bool { + fn runtimeVarIsBool(self: *Interpreter, rt_var: types.Var) !bool { var resolved = self.runtime_types.resolveVar(rt_var); + unwrap: while (true) { switch (resolved.desc.content) { .alias => |al| { @@ -2452,13 +2473,48 @@ pub const Interpreter = struct { const structure = resolved.desc.content.structure; if (structure != .tag_union) return false; const tu = structure.tag_union; - const tags = self.runtime_types.getTagsSlice(tu.tags); + + const scratch_tags_top = self.scratch_tags.items.len; + defer self.scratch_tags.shrinkRetainingCapacity(scratch_tags_top); + + const tag_slice = self.runtime_types.getTagsSlice(tu.tags); + for (tag_slice.items(.name), tag_slice.items(.args)) |name, args| { + _ = try self.scratch_tags.append(.{ .name = name, .args = args }); + } + + var current_ext = tu.ext; + while (true) { + const resolved_ext = self.runtime_types.resolveVar(current_ext); + switch (resolved_ext.desc.content) { + .structure => |ext_flat_type| switch (ext_flat_type) { + .empty_tag_union => break, + .tag_union => |ext_tag_union| { + if (ext_tag_union.tags.len() > 0) { + const ext_tag_slice = self.runtime_types.getTagsSlice(ext_tag_union.tags); + for (ext_tag_slice.items(.name), ext_tag_slice.items(.args)) |name, args| { + _ = try self.scratch_tags.append(.{ .name = name, .args = args }); + } + current_ext = ext_tag_union.ext; + } else { + break; + } + }, + else => return Error.InvalidTagExt, + }, + .alias => |alias| { + current_ext = self.runtime_types.getAliasBackingVar(alias); + }, + else => return Error.InvalidTagExt, + } + } + + const tags = self.scratch_tags.items[scratch_tags_top..]; if (tags.len == 0 or tags.len > 2) return false; var false_idx: ?usize = null; var true_idx: ?usize = null; - for (tags.items(.name), 0..) |ident_idx, i| { - const name_text = self.env.getIdent(ident_idx); + for (tags, 0..) |tag, i| { + const name_text = self.env.getIdent(tag.name); if (std.mem.eql(u8, name_text, "False")) { false_idx = i; } else if (std.mem.eql(u8, name_text, "True")) { @@ -2476,7 +2532,15 @@ pub const Interpreter = struct { fn getCanonicalBoolRuntimeVar(self: *Interpreter) !types.Var { if (self.canonical_bool_rt_var) |cached| return cached; - const bool_decl_idx = can.Can.BUILTIN_BOOL_TYPE; + // Look up Bool's actual index from builtin_statements (should be first) + const builtin_stmts_slice = self.env.store.sliceStatements(self.env.builtin_statements); + std.debug.assert(builtin_stmts_slice.len >= 1); // Must have at least Bool + const bool_decl_idx = builtin_stmts_slice[0]; // Bool is always the first builtin + // Debug assertion: verify this is a nominal type declaration + if (std.debug.runtime_safety) { + const stmt = self.env.store.getStatement(bool_decl_idx); + std.debug.assert(stmt == .s_nominal_decl); + } const ct_var = can.ModuleEnv.varFrom(bool_decl_idx); const nominal_rt_var = try self.translateTypeVar(self.env, ct_var); const nominal_resolved = self.runtime_types.resolveVar(nominal_rt_var); @@ -2492,13 +2556,13 @@ pub const Interpreter = struct { } fn prepareBoolIndices(self: *Interpreter, rt_var: types.Var) !void { - if (self.runtimeVarIsBool(rt_var)) return; + if (try self.runtimeVarIsBool(rt_var)) return; const canonical = try self.getCanonicalBoolRuntimeVar(); - _ = self.runtimeVarIsBool(canonical); + _ = try self.runtimeVarIsBool(canonical); } fn ensureBoolRuntimeVar(self: *Interpreter, module: *can.ModuleEnv, compile_var: types.Var, runtime_var: types.Var) !types.Var { - if (self.runtimeVarIsBool(runtime_var)) return runtime_var; + if (try self.runtimeVarIsBool(runtime_var)) return runtime_var; const canonical = try self.getCanonicalBoolRuntimeVar(); const key: u64 = (@as(u64, @intFromPtr(module)) << 32) | @as(u64, @intFromEnum(compile_var)); @@ -2879,7 +2943,7 @@ pub const Interpreter = struct { return true; }, .underscore => return true, - .int_literal => |il| { + .num_literal => |il| { if (!(value.layout.tag == .scalar and value.layout.data.scalar.tag == .int)) return false; const lit = il.value.toI128(); return value.asI128() == lit; @@ -2928,7 +2992,13 @@ pub const Interpreter = struct { if (value.layout.tag != .list and value.layout.tag != .list_of_zst) return false; const list_layout = try self.getRuntimeLayout(value_rt_var); - const elem_rt_var = try self.translateTypeVar(self.env, list_pat.elem_var); + + const list_rt_var = try self.translateTypeVar(self.env, can.ModuleEnv.varFrom(pattern_idx)); + const list_rt_content = self.runtime_types.resolveVar(list_rt_var).desc.content; + std.debug.assert(list_rt_content == .structure); + std.debug.assert(list_rt_content.structure == .list); + + const elem_rt_var = list_rt_content.structure.list; const elem_layout = try self.getRuntimeLayout(elem_rt_var); var accessor = try value.asList(&self.runtime_layout_store, elem_layout); @@ -3032,7 +3102,7 @@ pub const Interpreter = struct { if (tag_data.index >= tag_list.items.len) return false; const expected_name = self.env.getIdent(tag_pat.name); - if (self.runtimeVarIsBool(value_rt_var)) { + if (try self.runtimeVarIsBool(value_rt_var)) { const actual_name = if (tag_data.index == self.bool_true_index) "True" else "False"; if (!std.mem.eql(u8, expected_name, actual_name)) return false; } else { @@ -3095,6 +3165,7 @@ pub const Interpreter = struct { else => return false, } } + pub fn deinit(self: *Interpreter) void { self.empty_scope.deinit(); self.translate_cache.deinit(); @@ -3115,6 +3186,7 @@ pub const Interpreter = struct { self.stack_memory.deinit(); self.bindings.deinit(); self.active_closures.deinit(); + self.scratch_tags.deinit(); } /// Ensure the slot array can index at least `min_len` entries; zero-fill new entries. @@ -3207,15 +3279,6 @@ pub const Interpreter = struct { try acc.put(f.name, f.var_); } }, - .record_poly => |poly| { - const ct_fields = module.types.getRecordFieldsSlice(poly.record.fields); - var i: usize = 0; - while (i < ct_fields.len) : (i += 1) { - const f = ct_fields.get(i); - try acc.put(f.name, f.var_); - } - try self.collectRecordFieldsFromVar(module, poly.var_, acc, visited); - }, .nominal_type => |nom| { const backing = module.types.getNominalBackingVar(nom); try self.collectRecordFieldsFromVar(module, backing, acc, visited); @@ -3233,217 +3296,303 @@ pub const Interpreter = struct { /// Minimal translate implementation (scaffolding): handles .str only for now pub fn translateTypeVar(self: *Interpreter, module: *can.ModuleEnv, compile_var: types.Var) Error!types.Var { - const key: u64 = (@as(u64, @intFromPtr(module)) << 32) | @as(u64, @intFromEnum(compile_var)); + const resolved = module.types.resolveVar(compile_var); + + const key: u64 = (@as(u64, @intFromPtr(module)) << 32) | @as(u64, @intFromEnum(resolved.var_)); if (self.translate_cache.get(key)) |found| return found; - const resolved = module.types.resolveVar(compile_var); - const out_var = switch (resolved.desc.content) { - .structure => |flat| switch (flat) { - .str => try self.runtime_types.freshFromContent(.{ .structure = .str }), - .num => |n| switch (n) { - .num_compact => |c| switch (c) { - .int => |p| try self.runtime_types.freshFromContent(.{ .structure = .{ .num = .{ .num_compact = .{ .int = p } } } }), - .frac => |p| try self.runtime_types.freshFromContent(.{ .structure = .{ .num = .{ .num_compact = .{ .frac = p } } } }), - }, - .int_precision => |p| try self.runtime_types.freshFromContent(.{ .structure = .{ .num = .{ .num_compact = .{ .int = p } } } }), - .frac_precision => |p| try self.runtime_types.freshFromContent(.{ .structure = .{ .num = .{ .num_compact = .{ .frac = p } } } }), - .num_unbound, .int_unbound => try self.runtime_types.freshFromContent(.{ .structure = .{ .num = .{ .num_compact = .{ .int = types.Num.Int.Precision.default } } } }), - .frac_unbound => try self.runtime_types.freshFromContent(.{ .structure = .{ .num = .{ .num_compact = .{ .frac = types.Num.Frac.Precision.default } } } }), - .num_poly, .int_poly => try self.runtime_types.freshFromContent(.{ .structure = .{ .num = .{ .num_compact = .{ .int = types.Num.Int.Precision.default } } } }), - .frac_poly => try self.runtime_types.freshFromContent(.{ .structure = .{ .num = .{ .num_compact = .{ .frac = types.Num.Frac.Precision.default } } } }), - }, - .tag_union => |tu| { - const ct_tags = module.types.getTagsSlice(tu.tags); - var rt_tags = try self.allocator.alloc(@import("types").Tag, ct_tags.len); - defer self.allocator.free(rt_tags); - for (ct_tags.items(.name), ct_tags.items(.args), 0..) |name, args_range, i| { - const ct_args = module.types.sliceVars(args_range); - var arg_buf = try self.allocator.alloc(types.Var, ct_args.len); - defer self.allocator.free(arg_buf); - for (ct_args, 0..) |ct_arg, j| { - arg_buf[j] = try self.translateTypeVar(module, ct_arg); - } - const rt_args_range = try self.runtime_types.appendVars(arg_buf); - rt_tags[i] = .{ .name = name, .args = rt_args_range }; - } - const rt_ext = try self.translateTypeVar(module, tu.ext); - const content = try self.runtime_types.mkTagUnion(rt_tags, rt_ext); - return try self.runtime_types.register(.{ .content = content, .rank = types.Rank.top_level, .mark = types.Mark.none }); - }, - .empty_tag_union => { - return try self.runtime_types.freshFromContent(.{ .structure = .empty_tag_union }); - }, - .tuple => |t| { - const ct_elems = module.types.sliceVars(t.elems); - var buf = try self.allocator.alloc(types.Var, ct_elems.len); - defer self.allocator.free(buf); - for (ct_elems, 0..) |ct_elem, i| { - buf[i] = try self.translateTypeVar(module, ct_elem); - } - const range = try self.runtime_types.appendVars(buf); - return try self.runtime_types.freshFromContent(.{ .structure = .{ .tuple = .{ .elems = range } } }); - }, - .box => |elem_var| { - const rt_elem = try self.translateTypeVar(module, elem_var); - return try self.runtime_types.freshFromContent(.{ .structure = .{ .box = rt_elem } }); - }, - .list => |elem_var| { - const rt_elem = try self.translateTypeVar(module, elem_var); - return try self.runtime_types.freshFromContent(.{ .structure = .{ .list = rt_elem } }); - }, - .list_unbound => { - return try self.runtime_types.freshFromContent(.{ .structure = .list_unbound }); - }, - .record => |rec| { - var acc = try FieldAccumulator.init(self.allocator); - defer acc.deinit(); - var visited = std.AutoHashMap(types.Var, void).init(self.allocator); - defer visited.deinit(); + const out_var = blk: { + switch (resolved.desc.content) { + .structure => |flat| { + switch (flat) { + .str => { + break :blk try self.runtime_types.freshFromContent(.{ .structure = .str }); + }, + .num => |initial_num| { + const compact_num: types.Num.Compact = prec: { + var num = initial_num; + while (true) { + switch (num) { + .num_compact => |compact| break :prec compact, + .int_precision => |precision| break :prec .{ .int = precision }, + .frac_precision => |precision| break :prec .{ .frac = precision }, + // For polymorphic types, use default precision + .num_unbound => |_| { + // TODO: Should we consider requirements here? + break :prec .{ .int = types.Num.Int.Precision.default }; + }, + .int_unbound => { + // TODO: Should we consider requirements here? + break :prec .{ .int = types.Num.Int.Precision.default }; + }, + .frac_unbound => { + // TODO: Should we consider requirements here? + break :prec .{ .frac = types.Num.Frac.Precision.default }; + }, + .num_poly => |var_| { + const next_type = module.types.resolveVar(var_).desc.content; + if (next_type == .structure and next_type.structure == .num) { + num = next_type.structure.num; + } else if (next_type == .flex) { + break :prec .{ .int = types.Num.Int.Precision.default }; + } else { + return Error.InvalidNumExt; + } + }, + .int_poly => |var_| { + const next_type = module.types.resolveVar(var_).desc.content; + if (next_type == .structure and next_type.structure == .num) { + num = next_type.structure.num; + } else if (next_type == .flex) { + break :prec .{ .int = types.Num.Int.Precision.default }; + } else { + return Error.InvalidNumExt; + } + }, + .frac_poly => |var_| { + const next_type = module.types.resolveVar(var_).desc.content; + if (next_type == .structure and next_type.structure == .num) { + num = next_type.structure.num; + } else if (next_type == .flex) { + break :prec .{ .frac = types.Num.Frac.Precision.default }; + } else { + return Error.InvalidNumExt; + } + }, + } + } + }; + break :blk try self.runtime_types.freshFromContent(.{ .structure = .{ .num = .{ .num_compact = compact_num } } }); + }, + .tag_union => |tu| { + var rt_tag_args = try std.ArrayListUnmanaged(types.Var).initCapacity(self.allocator, 8); + defer rt_tag_args.deinit(self.allocator); - try self.collectRecordFieldsFromVar(module, rec.ext, &acc, &visited); + var rt_tags = try self.gatherTags(module, tu); + defer rt_tags.deinit(self.allocator); - const ct_fields = module.types.getRecordFieldsSlice(rec.fields); - var i: usize = 0; - while (i < ct_fields.len) : (i += 1) { - const f = ct_fields.get(i); - try acc.put(f.name, f.var_); - } + for (rt_tags.items) |*tag| { + rt_tag_args.clearRetainingCapacity(); + const ct_args = module.types.sliceVars(tag.args); + for (ct_args) |ct_arg_var| { + try rt_tag_args.append(self.allocator, try self.translateTypeVar(module, ct_arg_var)); + } + const rt_args_range = try self.runtime_types.appendVars(rt_tag_args.items); + tag.* = .{ + .name = tag.name, + .args = rt_args_range, + }; + } - const rt_ext = try self.translateTypeVar(module, rec.ext); - var runtime_fields = try self.allocator.alloc(types.RecordField, acc.fields.items.len); - defer self.allocator.free(runtime_fields); - var j: usize = 0; - while (j < acc.fields.items.len) : (j += 1) { - const ct_field = acc.fields.items[j]; - runtime_fields[j] = .{ - .name = ct_field.name, - .var_ = try self.translateTypeVar(module, ct_field.var_), - }; - } - const rt_fields = try self.runtime_types.appendRecordFields(runtime_fields); - return try self.runtime_types.freshFromContent(.{ .structure = .{ .record = .{ .fields = rt_fields, .ext = rt_ext } } }); - }, - .record_unbound => |fields_range| { - const ct_fields = module.types.getRecordFieldsSlice(fields_range); - var runtime_fields = try self.allocator.alloc(types.RecordField, ct_fields.len); - defer self.allocator.free(runtime_fields); - var i: usize = 0; - while (i < ct_fields.len) : (i += 1) { - const f = ct_fields.get(i); - runtime_fields[i] = .{ - .name = f.name, - .var_ = try self.translateTypeVar(module, f.var_), - }; - } - const rt_fields = try self.runtime_types.appendRecordFields(runtime_fields); - const ext_empty = try self.runtime_types.freshFromContent(.{ .structure = .empty_record }); - return try self.runtime_types.freshFromContent(.{ .structure = .{ .record = .{ .fields = rt_fields, .ext = ext_empty } } }); - }, - .record_poly => |poly| { - var acc = try FieldAccumulator.init(self.allocator); - defer acc.deinit(); - var visited = std.AutoHashMap(types.Var, void).init(self.allocator); - defer visited.deinit(); + const rt_ext = try self.runtime_types.register(.{ .content = .{ .structure = .empty_tag_union }, .rank = types.Rank.top_level, .mark = types.Mark.none }); + const content = try self.runtime_types.mkTagUnion(rt_tags.items, rt_ext); + break :blk try self.runtime_types.register(.{ .content = content, .rank = types.Rank.top_level, .mark = types.Mark.none }); + }, + .empty_tag_union => { + break :blk try self.runtime_types.freshFromContent(.{ .structure = .empty_tag_union }); + }, + .tuple => |t| { + const ct_elems = module.types.sliceVars(t.elems); + var buf = try self.allocator.alloc(types.Var, ct_elems.len); + defer self.allocator.free(buf); + for (ct_elems, 0..) |ct_elem, i| { + buf[i] = try self.translateTypeVar(module, ct_elem); + } + const range = try self.runtime_types.appendVars(buf); + break :blk try self.runtime_types.freshFromContent(.{ .structure = .{ .tuple = .{ .elems = range } } }); + }, + .box => |elem_var| { + const rt_elem = try self.translateTypeVar(module, elem_var); + break :blk try self.runtime_types.freshFromContent(.{ .structure = .{ .box = rt_elem } }); + }, + .list => |elem_var| { + const rt_elem = try self.translateTypeVar(module, elem_var); + break :blk try self.runtime_types.freshFromContent(.{ .structure = .{ .list = rt_elem } }); + }, + .list_unbound => { + const elem_var = try self.runtime_types.freshFromContent(.{ .flex = types.Flex.init() }); + break :blk try self.runtime_types.freshFromContent(.{ .structure = .{ .list = elem_var } }); + }, + .record => |rec| { + var acc = try FieldAccumulator.init(self.allocator); + defer acc.deinit(); + var visited = std.AutoHashMap(types.Var, void).init(self.allocator); + defer visited.deinit(); - try self.collectRecordFieldsFromVar(module, poly.record.ext, &acc, &visited); + try self.collectRecordFieldsFromVar(module, rec.ext, &acc, &visited); - const ct_fields = module.types.getRecordFieldsSlice(poly.record.fields); - var i: usize = 0; - while (i < ct_fields.len) : (i += 1) { - const f = ct_fields.get(i); - try acc.put(f.name, f.var_); - } + const ct_fields = module.types.getRecordFieldsSlice(rec.fields); + var i: usize = 0; + while (i < ct_fields.len) : (i += 1) { + const f = ct_fields.get(i); + try acc.put(f.name, f.var_); + } - const rt_ext = try self.translateTypeVar(module, poly.var_); - var runtime_fields = try self.allocator.alloc(types.RecordField, acc.fields.items.len); - defer self.allocator.free(runtime_fields); - var j: usize = 0; - while (j < acc.fields.items.len) : (j += 1) { - const ct_field = acc.fields.items[j]; - runtime_fields[j] = .{ - .name = ct_field.name, - .var_ = try self.translateTypeVar(module, ct_field.var_), - }; + const rt_ext = try self.translateTypeVar(module, rec.ext); + var runtime_fields = try self.allocator.alloc(types.RecordField, acc.fields.items.len); + defer self.allocator.free(runtime_fields); + var j: usize = 0; + while (j < acc.fields.items.len) : (j += 1) { + const ct_field = acc.fields.items[j]; + runtime_fields[j] = .{ + .name = ct_field.name, + .var_ = try self.translateTypeVar(module, ct_field.var_), + }; + } + const rt_fields = try self.runtime_types.appendRecordFields(runtime_fields); + break :blk try self.runtime_types.freshFromContent(.{ .structure = .{ .record = .{ .fields = rt_fields, .ext = rt_ext } } }); + }, + .record_unbound => |fields_range| { + // TODO: Recursively unwrap record fields via ext, like tag unions + const ct_fields = module.types.getRecordFieldsSlice(fields_range); + var runtime_fields = try self.allocator.alloc(types.RecordField, ct_fields.len); + defer self.allocator.free(runtime_fields); + var i: usize = 0; + while (i < ct_fields.len) : (i += 1) { + const f = ct_fields.get(i); + runtime_fields[i] = .{ + .name = f.name, + .var_ = try self.translateTypeVar(module, f.var_), + }; + } + const rt_fields = try self.runtime_types.appendRecordFields(runtime_fields); + const ext_empty = try self.runtime_types.freshFromContent(.{ .structure = .empty_record }); + break :blk try self.runtime_types.freshFromContent(.{ .structure = .{ .record = .{ .fields = rt_fields, .ext = ext_empty } } }); + }, + .empty_record => { + break :blk try self.runtime_types.freshFromContent(.{ .structure = .empty_record }); + }, + .fn_pure => |f| { + const ct_args = module.types.sliceVars(f.args); + var buf = try self.allocator.alloc(types.Var, ct_args.len); + defer self.allocator.free(buf); + for (ct_args, 0..) |ct_arg, i| { + buf[i] = try self.translateTypeVar(module, ct_arg); + } + const rt_ret = try self.translateTypeVar(module, f.ret); + const content = try self.runtime_types.mkFuncPure(buf, rt_ret); + break :blk try self.runtime_types.register(.{ .content = content, .rank = types.Rank.top_level, .mark = types.Mark.none }); + }, + .fn_effectful => |f| { + const ct_args = module.types.sliceVars(f.args); + var buf = try self.allocator.alloc(types.Var, ct_args.len); + defer self.allocator.free(buf); + for (ct_args, 0..) |ct_arg, i| { + buf[i] = try self.translateTypeVar(module, ct_arg); + } + const rt_ret = try self.translateTypeVar(module, f.ret); + const content = try self.runtime_types.mkFuncEffectful(buf, rt_ret); + break :blk try self.runtime_types.register(.{ .content = content, .rank = types.Rank.top_level, .mark = types.Mark.none }); + }, + .fn_unbound => |f| { + const ct_args = module.types.sliceVars(f.args); + var buf = try self.allocator.alloc(types.Var, ct_args.len); + defer self.allocator.free(buf); + for (ct_args, 0..) |ct_arg, i| { + buf[i] = try self.translateTypeVar(module, ct_arg); + } + const rt_ret = try self.translateTypeVar(module, f.ret); + const content = try self.runtime_types.mkFuncUnbound(buf, rt_ret); + break :blk try self.runtime_types.register(.{ .content = content, .rank = types.Rank.top_level, .mark = types.Mark.none }); + }, + .nominal_type => |nom| { + const ct_backing = module.types.getNominalBackingVar(nom); + const rt_backing = try self.translateTypeVar(module, ct_backing); + const ct_args = module.types.sliceNominalArgs(nom); + var buf = try self.allocator.alloc(types.Var, ct_args.len); + defer self.allocator.free(buf); + for (ct_args, 0..) |ct_arg, i| { + buf[i] = try self.translateTypeVar(module, ct_arg); + } + const content = try self.runtime_types.mkNominal(nom.ident, rt_backing, buf, nom.origin_module); + break :blk try self.runtime_types.register(.{ .content = content, .rank = types.Rank.top_level, .mark = types.Mark.none }); + }, } - const rt_fields = try self.runtime_types.appendRecordFields(runtime_fields); - return try self.runtime_types.freshFromContent(.{ .structure = .{ .record = .{ .fields = rt_fields, .ext = rt_ext } } }); }, - .empty_record => try self.runtime_types.freshFromContent(.{ .structure = .empty_record }), - .fn_pure => |f| { - const ct_args = module.types.sliceVars(f.args); - var buf = try self.allocator.alloc(types.Var, ct_args.len); - defer self.allocator.free(buf); - for (ct_args, 0..) |ct_arg, i| { - buf[i] = try self.translateTypeVar(module, ct_arg); - } - const rt_ret = try self.translateTypeVar(module, f.ret); - const content = try self.runtime_types.mkFuncPure(buf, rt_ret); - return try self.runtime_types.register(.{ .content = content, .rank = types.Rank.top_level, .mark = types.Mark.none }); - }, - .fn_effectful => |f| { - const ct_args = module.types.sliceVars(f.args); - var buf = try self.allocator.alloc(types.Var, ct_args.len); - defer self.allocator.free(buf); - for (ct_args, 0..) |ct_arg, i| { - buf[i] = try self.translateTypeVar(module, ct_arg); - } - const rt_ret = try self.translateTypeVar(module, f.ret); - const content = try self.runtime_types.mkFuncEffectful(buf, rt_ret); - return try self.runtime_types.register(.{ .content = content, .rank = types.Rank.top_level, .mark = types.Mark.none }); - }, - .fn_unbound => |f| { - const ct_args = module.types.sliceVars(f.args); - var buf = try self.allocator.alloc(types.Var, ct_args.len); - defer self.allocator.free(buf); - for (ct_args, 0..) |ct_arg, i| { - buf[i] = try self.translateTypeVar(module, ct_arg); - } - const rt_ret = try self.translateTypeVar(module, f.ret); - const content = try self.runtime_types.mkFuncUnbound(buf, rt_ret); - return try self.runtime_types.register(.{ .content = content, .rank = types.Rank.top_level, .mark = types.Mark.none }); - }, - .nominal_type => |nom| { - const ct_backing = module.types.getNominalBackingVar(nom); + .alias => |alias| { + const ct_backing = module.types.getAliasBackingVar(alias); const rt_backing = try self.translateTypeVar(module, ct_backing); - const ct_args = module.types.sliceNominalArgs(nom); + const ct_args = module.types.sliceAliasArgs(alias); var buf = try self.allocator.alloc(types.Var, ct_args.len); defer self.allocator.free(buf); for (ct_args, 0..) |ct_arg, i| { buf[i] = try self.translateTypeVar(module, ct_arg); } - const content = try self.runtime_types.mkNominal(nom.ident, rt_backing, buf, nom.origin_module); - return try self.runtime_types.register(.{ .content = content, .rank = types.Rank.top_level, .mark = types.Mark.none }); + const content = try self.runtime_types.mkAlias(alias.ident, rt_backing, buf); + break :blk try self.runtime_types.register(.{ .content = content, .rank = types.Rank.top_level, .mark = types.Mark.none }); }, - }, - .alias => |alias| { - const ct_backing = module.types.getAliasBackingVar(alias); - const rt_backing = try self.translateTypeVar(module, ct_backing); - const ct_args = module.types.sliceAliasArgs(alias); - var buf = try self.allocator.alloc(types.Var, ct_args.len); - defer self.allocator.free(buf); - for (ct_args, 0..) |ct_arg, i| { - buf[i] = try self.translateTypeVar(module, ct_arg); - } - const content = try self.runtime_types.mkAlias(alias.ident, rt_backing, buf); - return try self.runtime_types.register(.{ .content = content, .rank = types.Rank.top_level, .mark = types.Mark.none }); - }, - .flex_var => |id_opt| { - const content: types.Content = .{ .flex_var = id_opt }; - return try self.runtime_types.freshFromContent(content); - }, - .rigid_var => |ident| { - const content: types.Content = .{ .rigid_var = ident }; - return try self.runtime_types.freshFromContent(content); - }, - .err => { - return error.TypeMismatch; - }, + .flex => |flex| { + const content: types.Content = .{ .flex = flex }; + break :blk try self.runtime_types.freshFromContent(content); + }, + .rigid => |rigid| { + const content: types.Content = .{ .rigid = rigid }; + break :blk try self.runtime_types.freshFromContent(content); + }, + .err => { + return error.TypeMismatch; + }, + } }; try self.translate_cache.put(key, out_var); return out_var; } + /// Recursively expand a tag union's tags, returning an array list + /// Caller owns the returned memory + fn gatherTags( + ctx: *const Interpreter, + module: *can.ModuleEnv, + tag_union: types.TagUnion, + ) std.mem.Allocator.Error!std.ArrayListUnmanaged(types.Tag) { + var scratch_tags = try std.ArrayListUnmanaged(types.Tag).initCapacity(ctx.allocator, 8); + + const tag_slice = module.types.getTagsSlice(tag_union.tags); + for (tag_slice.items(.name), tag_slice.items(.args)) |name, args| { + _ = try scratch_tags.append(ctx.allocator, .{ .name = name, .args = args }); + } + + var current_ext = tag_union.ext; + while (true) { + const resolved_ext = module.types.resolveVar(current_ext); + switch (resolved_ext.desc.content) { + .structure => |ext_flat_type| switch (ext_flat_type) { + .empty_tag_union => break, + .tag_union => |ext_tag_union| { + if (ext_tag_union.tags.len() > 0) { + const ext_tag_slice = module.types.getTagsSlice(ext_tag_union.tags); + for (ext_tag_slice.items(.name), ext_tag_slice.items(.args)) |name, args| { + _ = try scratch_tags.append(ctx.allocator, .{ .name = name, .args = args }); + } + current_ext = ext_tag_union.ext; + } else { + break; + } + }, + else => { + // TODO: Don't use unreachable here + unreachable; + }, + }, + .alias => |alias| { + current_ext = module.types.getAliasBackingVar(alias); + }, + .flex => break, + .rigid => break, + else => { + // TODO: Don't use unreachable here + unreachable; + }, + } + } + + // Sort the tags alphabetically + std.mem.sort(types.Tag, scratch_tags.items, module.common.getIdentStore(), comptime types.Tag.sortByNameAsc); + + return scratch_tags; + } + pub fn makePolyKey(self: *Interpreter, func_id: u32, args: []const types.Var) PolyKey { _ = self; return PolyKey.init(func_id, args); @@ -3536,6 +3685,11 @@ pub const Interpreter = struct { try self.polyInsert(func_id, entry); return entry; } + + /// Initial a TypeWriter from an interpreter. Useful when debugging + fn initTypeWriter(self: *const Interpreter) std.mem.Allocator.Error!types.TypeWriter { + return try types.TypeWriter.initFromParts(self.allocator, self.runtime_types, self.env.common.getIdentStore()); + } }; fn add(a: i32, b: i32) i32 { @@ -3550,6 +3704,7 @@ test "interpreter: wiring works" { // RED: expect Var->Layout slot to work (will fail until implemented) test "interpreter: Var->Layout slot caches computed layout" { const gpa = std.testing.allocator; + var env = try can.ModuleEnv.init(gpa, ""); defer env.deinit(); @@ -3574,6 +3729,7 @@ test "interpreter: Var->Layout slot caches computed layout" { // RED: translating a compile-time str var should produce a runtime str var test "interpreter: translateTypeVar for str" { const gpa = std.testing.allocator; + var env = try can.ModuleEnv.init(gpa, ""); defer env.deinit(); @@ -3591,6 +3747,7 @@ test "interpreter: translateTypeVar for str" { // RED: translating a compile-time concrete int64 should produce a runtime int64 test "interpreter: translateTypeVar for int64" { const gpa = std.testing.allocator; + var env = try can.ModuleEnv.init(gpa, ""); defer env.deinit(); @@ -3616,6 +3773,7 @@ test "interpreter: translateTypeVar for int64" { // RED: translating a compile-time concrete f64 should produce a runtime f64 test "interpreter: translateTypeVar for f64" { const gpa = std.testing.allocator; + var env = try can.ModuleEnv.init(gpa, ""); defer env.deinit(); @@ -3641,6 +3799,7 @@ test "interpreter: translateTypeVar for f64" { // RED: translating a compile-time tuple (Str, I64) should produce a runtime tuple with same element shapes test "interpreter: translateTypeVar for tuple(Str, I64)" { const gpa = std.testing.allocator; + var env = try can.ModuleEnv.init(gpa, ""); defer env.deinit(); @@ -3684,6 +3843,7 @@ test "interpreter: translateTypeVar for tuple(Str, I64)" { // RED: translating a compile-time record { first: Str, second: I64 } should produce equivalent runtime record test "interpreter: translateTypeVar for record {first: Str, second: I64}" { const gpa = std.testing.allocator; + var env = try can.ModuleEnv.init(gpa, ""); defer env.deinit(); @@ -3741,6 +3901,7 @@ test "interpreter: translateTypeVar for record {first: Str, second: I64}" { // RED: translating a compile-time alias should produce equivalent runtime alias test "interpreter: translateTypeVar for alias of Str" { const gpa = std.testing.allocator; + var env = try can.ModuleEnv.init(gpa, ""); defer env.deinit(); @@ -3767,6 +3928,7 @@ test "interpreter: translateTypeVar for alias of Str" { // RED: translating a compile-time nominal type should produce equivalent runtime nominal test "interpreter: translateTypeVar for nominal Point(Str)" { const gpa = std.testing.allocator; + var env = try can.ModuleEnv.init(gpa, ""); defer env.deinit(); @@ -3798,21 +3960,23 @@ test "interpreter: translateTypeVar for nominal Point(Str)" { // RED: translating a compile-time flex var should produce a runtime flex var test "interpreter: translateTypeVar for flex var" { const gpa = std.testing.allocator; + var env = try can.ModuleEnv.init(gpa, ""); defer env.deinit(); var interp = try Interpreter.init(gpa, &env); defer interp.deinit(); - const ct_flex = try env.types.freshFromContent(.{ .flex_var = null }); + const ct_flex = try env.types.freshFromContent(.{ .flex = types.Flex.init() }); const rt_var = try interp.translateTypeVar(&env, ct_flex); const resolved = interp.runtime_types.resolveVar(rt_var); - try std.testing.expect(resolved.desc.content == .flex_var); + try std.testing.expect(resolved.desc.content == .flex); } // RED: translating a compile-time rigid var should produce a runtime rigid var with same ident test "interpreter: translateTypeVar for rigid var" { const gpa = std.testing.allocator; + var env = try can.ModuleEnv.init(gpa, ""); defer env.deinit(); @@ -3820,16 +3984,17 @@ test "interpreter: translateTypeVar for rigid var" { defer interp.deinit(); const name_a = try env.common.idents.insert(gpa, @import("base").Ident.for_text("A")); - const ct_rigid = try env.types.freshFromContent(.{ .rigid_var = name_a }); + const ct_rigid = try env.types.freshFromContent(.{ .rigid = types.Rigid.init(name_a) }); const rt_var = try interp.translateTypeVar(&env, ct_rigid); const resolved = interp.runtime_types.resolveVar(rt_var); - try std.testing.expect(resolved.desc.content == .rigid_var); - try std.testing.expectEqual(name_a, resolved.desc.content.rigid_var); + try std.testing.expect(resolved.desc.content == .rigid); + try std.testing.expectEqual(name_a, resolved.desc.content.rigid.name); } // RED: poly cache miss then hit test "interpreter: poly cache insert and lookup" { const gpa = std.testing.allocator; + var env = try can.ModuleEnv.init(gpa, ""); defer env.deinit(); @@ -3865,6 +4030,7 @@ test "interpreter: poly cache insert and lookup" { // RED: prepareCall should miss without hint, then hit after inserting with hint test "interpreter: prepareCall miss then hit" { const gpa = std.testing.allocator; + var env = try can.ModuleEnv.init(gpa, ""); defer env.deinit(); @@ -3894,6 +4060,7 @@ test "interpreter: prepareCall miss then hit" { // RED: prepareCallWithFuncVar populates cache based on function type test "interpreter: prepareCallWithFuncVar populates cache" { const gpa = std.testing.allocator; + var env = try can.ModuleEnv.init(gpa, ""); defer env.deinit(); @@ -3923,6 +4090,7 @@ test "interpreter: prepareCallWithFuncVar populates cache" { // RED: unification constrains return type for polymorphic (a -> a), when called with Str test "interpreter: unification constrains (a->a) with Str" { const gpa = std.testing.allocator; + var env = try can.ModuleEnv.init(gpa, ""); defer env.deinit(); @@ -3931,7 +4099,7 @@ test "interpreter: unification constrains (a->a) with Str" { const func_id: u32 = 42; // runtime flex var 'a' - const a = try interp.runtime_types.freshFromContent(.{ .flex_var = null }); + const a = try interp.runtime_types.freshFromContent(.{ .flex = types.Flex.init() }); const func_content = try interp.runtime_types.mkFuncPure(&.{a}, a); const func_var = try interp.runtime_types.register(.{ .content = func_content, .rank = types.Rank.top_level, .mark = types.Mark.none }); diff --git a/src/eval/test/eval_test.zig b/src/eval/test/eval_test.zig index b04a9b744e..b471267341 100644 --- a/src/eval/test/eval_test.zig +++ b/src/eval/test/eval_test.zig @@ -709,9 +709,14 @@ test "ModuleEnv serialization and interpreter evaluation" { // Initialize CIR fields in ModuleEnv try original_env.initCIRFields(gpa, "test"); + const common_idents: Check.CommonIdents = .{ + .module_name = try original_env.insertIdent(base.Ident.for_text("test")), + .list = try original_env.insertIdent(base.Ident.for_text("List")), + .box = try original_env.insertIdent(base.Ident.for_text("Box")), + }; // Create canonicalizer - var czer = try Can.init(&original_env, &parse_ast, null); + var czer = try Can.init(&original_env, &parse_ast, null, .{}); defer czer.deinit(); // Canonicalize the expression @@ -721,10 +726,10 @@ test "ModuleEnv serialization and interpreter evaluation" { }; // Type check the expression - var checker = try Check.init(gpa, &original_env.types, &original_env, &.{}, &original_env.store.regions); + var checker = try Check.init(gpa, &original_env.types, &original_env, &.{}, &original_env.store.regions, common_idents); defer checker.deinit(); - _ = try checker.checkExpr(canonicalized_expr_idx.get_idx()); + _ = try checker.checkExprRepl(canonicalized_expr_idx.get_idx()); // Test 1: Evaluate with the original ModuleEnv { @@ -741,9 +746,9 @@ test "ModuleEnv serialization and interpreter evaluation" { // Test 2: Full serialization and deserialization with interpreter evaluation { - var arena = std.heap.ArenaAllocator.init(gpa); - defer arena.deinit(); - const arena_alloc = arena.allocator(); + var serialization_arena = std.heap.ArenaAllocator.init(gpa); + defer serialization_arena.deinit(); + const arena_alloc = serialization_arena.allocator(); var tmp_dir = testing.tmpDir(.{}); defer tmp_dir.cleanup(); diff --git a/src/eval/test/helpers.zig b/src/eval/test/helpers.zig index c5dbb28f89..b7ba29ca1a 100644 --- a/src/eval/test/helpers.zig +++ b/src/eval/test/helpers.zig @@ -306,11 +306,16 @@ pub fn parseAndCanonicalizeExpr(allocator: std.mem.Allocator, source: []const u8 // Initialize CIR fields in ModuleEnv try module_env.initCIRFields(allocator, "test"); + const common_idents: Check.CommonIdents = .{ + .module_name = try module_env.insertIdent(base.Ident.for_text("test")), + .list = try module_env.insertIdent(base.Ident.for_text("List")), + .box = try module_env.insertIdent(base.Ident.for_text("Box")), + }; // Create czer // const czer = try allocator.create(Can); - czer.* = try Can.init(module_env, parse_ast, null); + czer.* = try Can.init(module_env, parse_ast, null, .{}); // Canonicalize the expression const expr_idx: parse.AST.Expr.Idx = @enumFromInt(parse_ast.root_node_idx); @@ -321,7 +326,7 @@ pub fn parseAndCanonicalizeExpr(allocator: std.mem.Allocator, source: []const u8 .region = base.Region.zero(), } }); const checker = try allocator.create(Check); - checker.* = try Check.init(allocator, &module_env.types, module_env, &.{}, &module_env.store.regions); + checker.* = try Check.init(allocator, &module_env.types, module_env, &.{}, &module_env.store.regions, common_idents); return .{ .module_env = module_env, .parse_ast = parse_ast, @@ -335,33 +340,10 @@ pub fn parseAndCanonicalizeExpr(allocator: std.mem.Allocator, source: []const u8 // Create type checker const checker = try allocator.create(Check); - checker.* = try Check.init(allocator, &module_env.types, module_env, &.{}, &module_env.store.regions); + checker.* = try Check.init(allocator, &module_env.types, module_env, &.{}, &module_env.store.regions, common_idents); // Type check the expression - _ = try checker.checkExpr(canonical_expr_idx.get_idx()); - - // WORKAROUND: The type checker doesn't set types for binop expressions yet. - // For numeric binops, manually set the type to match the operands. - const expr = module_env.store.getExpr(canonical_expr_idx.get_idx()); - if (expr == .e_binop) { - const binop = expr.e_binop; - // For arithmetic ops, use the type of the left operand - switch (binop.op) { - .add, .sub, .mul, .div, .rem, .pow, .div_trunc => { - const left_var = @as(types.Var, @enumFromInt(@intFromEnum(binop.lhs))); - const left_resolved = module_env.types.resolveVar(left_var); - const result_var = @as(types.Var, @enumFromInt(@intFromEnum(canonical_expr_idx.get_idx()))); - try module_env.types.setVarContent(result_var, left_resolved.desc.content); - }, - .lt, .gt, .le, .ge, .eq, .ne => { - // Comparison ops return Bool - const result_var = @as(types.Var, @enumFromInt(@intFromEnum(canonical_expr_idx.get_idx()))); - const bool_content = try module_env.types.mkBool(allocator, &module_env.common.idents, @enumFromInt(0)); - try module_env.types.setVarContent(result_var, bool_content); - }, - else => {}, - } - } + _ = try checker.checkExprRepl(canonical_expr_idx.get_idx()); return .{ .module_env = module_env, diff --git a/src/eval/test/interpreter_polymorphism_test.zig b/src/eval/test/interpreter_polymorphism_test.zig index de074efe91..afbee0765c 100644 --- a/src/eval/test/interpreter_polymorphism_test.zig +++ b/src/eval/test/interpreter_polymorphism_test.zig @@ -212,28 +212,6 @@ test "interpreter captures (polymorphic): capture id and apply to string" { try std.testing.expectEqualStrings(expected, rendered); } -test "interpreter captures (polymorphic): same captured id used at two types" { - const roc_src = - \\(((|f| (|a| (|b| (f(a), f(b)))))(|x| x))(1))("hi") - ; - - const resources = try helpers.parseAndCanonicalizeExpr(std.testing.allocator, roc_src); - defer helpers.cleanupParseAndCanonical(std.testing.allocator, resources); - - var interp2 = try Interpreter.init(std.testing.allocator, resources.module_env); - defer interp2.deinit(); - - var host = TestHost{ .allocator = std.testing.allocator }; - var ops = makeOps(&host); - const result = try interp2.evalMinimal(resources.expr_idx, &ops); - const rendered = try interp2.renderValueRoc(result); - defer std.testing.allocator.free(rendered); - const expected = - \\(1, "hi") - ; - try std.testing.expectEqualStrings(expected, rendered); -} - // Higher-order: pass a function and apply inside another function test "interpreter higher-order: apply f then call with 41" { const roc_src = diff --git a/src/eval/test/interpreter_style_test.zig b/src/eval/test/interpreter_style_test.zig index e86ad24bf4..c4d564a1cb 100644 --- a/src/eval/test/interpreter_style_test.zig +++ b/src/eval/test/interpreter_style_test.zig @@ -106,56 +106,21 @@ fn recordCrashCallback(args: *const builtins.host_abi.RocCrashed, env: *anyopaqu } test "interpreter: (|x| x)(\"Hello\") yields \"Hello\"" { - // Roc input (begin with Roc syntax): const roc_src = "(|x| x)(\"Hello\")"; - // Expected Roc output (end with Roc syntax): - const expected_out_roc = "\"Hello\""; - - // Parse + canonicalize (+ typecheck) with fast failure & proper diagnostics const resources = try helpers.parseAndCanonicalizeExpr(std.testing.allocator, roc_src); defer helpers.cleanupParseAndCanonical(std.testing.allocator, resources); - // Evaluate with current interpreter (value result must be the string Hello) - try helpers.runExpectStr(roc_src, "Hello", .no_trace); - - // Now exercise Interpreter on the same ModuleEnv to verify runtime typing and minimal evaluation var interp2 = try Interpreter.init(std.testing.allocator, resources.module_env); defer interp2.deinit(); - const CIR = can.CIR; - const root_expr = resources.module_env.store.getExpr(resources.expr_idx); - try std.testing.expect(root_expr == .e_call); - const call = root_expr.e_call; - const all_exprs = resources.module_env.store.sliceExpr(call.args); - try std.testing.expect(all_exprs.len == 2); - const func_expr_idx: CIR.Expr.Idx = all_exprs[0]; - const arg_expr_idx: CIR.Expr.Idx = all_exprs[1]; - - // Translate function type and arg type to runtime types - const func_ct_var: types.Var = can.ModuleEnv.varFrom(func_expr_idx); - _ = try interp2.translateTypeVar(resources.module_env, func_ct_var); - const arg_ct_var: types.Var = can.ModuleEnv.varFrom(arg_expr_idx); - const arg_rt_var = try interp2.translateTypeVar(resources.module_env, arg_ct_var); - - // Prepare call using runtime function type; should constrain return to Str - // Prepare call using a hint (until full eval is fully wired) and minimally evaluate - const entry = (try interp2.prepareCall(1234, &.{arg_rt_var}, arg_rt_var)) orelse return error.TestUnexpectedResult; - try std.testing.expect(entry.return_layout_slot != 0); - - // Minimal eval: evaluate the call directly via Interpreter - // Minimal eval using fresh RocOps var host = TestHost.init(std.testing.allocator); defer host.deinit(); var ops = host.makeOps(); + const result = try interp2.evalMinimal(resources.expr_idx, &ops); const rendered = try interp2.renderValueRoc(result); defer std.testing.allocator.free(rendered); - // End with Roc-output literal for readability try std.testing.expectEqualStrings("\"Hello\"", rendered); - - // For clarity, re-assert the expected Roc output literal - const got_out_roc = expected_out_roc; // In a future step, render REPL-style from result - try std.testing.expectEqualStrings(expected_out_roc, got_out_roc); } test "interpreter: (|n| n + 1)(41) yields 42" { diff --git a/src/eval/test_runner.zig b/src/eval/test_runner.zig index f05c30d0f7..015ad82512 100644 --- a/src/eval/test_runner.zig +++ b/src/eval/test_runner.zig @@ -6,6 +6,7 @@ const std = @import("std"); const base = @import("base"); const builtins = @import("builtins"); const can = @import("can"); +const reporting = @import("reporting"); const Interpreter = @import("interpreter.zig").Interpreter; const eval_mod = @import("mod.zig"); @@ -92,10 +93,32 @@ const Evaluation = enum { not_a_bool, }; +/// Categorizes the type of test failure +const FailureType = enum { + /// expect evaluated to false + simple_failure, + /// interpreter error during evaluation + eval_error, + /// expression didn't return a bool + not_bool, +}; + +/// Detailed information about a test failure +const FailureInfo = union(FailureType) { + /// No additional info needed + simple_failure, + /// The specific interpreter error + eval_error: EvalError, + /// No additional info needed + not_bool, +}; + // Track test results const TestResult = struct { passed: bool, region: base.Region, + failure_info: ?FailureInfo = null, + // Legacy error message for HTML report compatibility error_msg: ?[]const u8 = null, }; @@ -185,18 +208,32 @@ pub const TestRunner = struct { const result = self.eval(stmt.s_expect.body) catch |err| { failed += 1; const error_msg = try std.fmt.allocPrint(self.allocator, "Test evaluation failed: {}", .{err}); - try self.test_results.append(.{ .region = region, .passed = false, .error_msg = error_msg }); + try self.test_results.append(.{ + .region = region, + .passed = false, + .failure_info = .{ .eval_error = err }, + .error_msg = error_msg, + }); continue; }; switch (result) { .not_a_bool => { failed += 1; const error_msg = try std.fmt.allocPrint(self.allocator, "Test did not evaluate to a boolean", .{}); - try self.test_results.append(.{ .region = region, .passed = false, .error_msg = error_msg }); + try self.test_results.append(.{ + .region = region, + .passed = false, + .failure_info = .not_bool, + .error_msg = error_msg, + }); }, .failed => { failed += 1; - try self.test_results.append(.{ .region = region, .passed = false }); + try self.test_results.append(.{ + .region = region, + .passed = false, + .failure_info = .simple_failure, + }); }, .passed => { passed += 1; @@ -212,6 +249,125 @@ pub const TestRunner = struct { }; } + /// Create a Report for a failed test. + /// Caller is responsible for calling report.deinit(). + pub fn createReport(self: *const TestRunner, test_result: TestResult, filename: []const u8) !reporting.Report { + std.debug.assert(!test_result.passed); // Only call for failed tests + + const failure_info = test_result.failure_info orelse { + // Fallback for legacy tests without failure_info + var report = reporting.Report.init(self.allocator, "TEST FAILURE", .runtime_error); + errdefer report.deinit(); + try report.document.addText("This expect failed but no failure information is available."); + return report; + }; + + switch (failure_info) { + .simple_failure => { + var report = reporting.Report.init(self.allocator, "TEST FAILURE", .runtime_error); + errdefer report.deinit(); + + try report.document.addText("This "); + try report.document.addAnnotated("expect", .keyword); + try report.document.addText(" failed:"); + try report.document.addLineBreak(); + + // Show the source code with highlighting + const region_info = self.env.calcRegionInfo(test_result.region); + try report.document.addSourceRegion( + region_info, + .error_highlight, + filename, + self.env.common.source, + self.env.getLineStarts(), + ); + try report.document.addLineBreak(); + + try report.document.addText("The expression evaluated to "); + try report.document.addAnnotated("False", .emphasized); + try report.document.addText("."); + + return report; + }, + .eval_error => |err| { + var report = reporting.Report.init(self.allocator, "TEST EVALUATION ERROR", .runtime_error); + errdefer report.deinit(); + + try report.document.addText("This "); + try report.document.addAnnotated("expect", .keyword); + try report.document.addText(" could not be evaluated:"); + try report.document.addLineBreak(); + + // Show the source code with highlighting + const region_info = self.env.calcRegionInfo(test_result.region); + try report.document.addSourceRegion( + region_info, + .error_highlight, + filename, + self.env.common.source, + self.env.getLineStarts(), + ); + try report.document.addLineBreak(); + + // Show the error type + const error_name = @errorName(err); + try report.document.addText("Error: "); + try report.document.addAnnotated(error_name, .error_highlight); + try report.document.addLineBreak(); + try report.document.addLineBreak(); + + // Add helpful explanation based on error type + const explanation = switch (err) { + error.TypeMismatch => "The test expression has incompatible types and cannot be evaluated.", + error.DivisionByZero => "The test expression attempts to divide by zero.", + error.NotImplemented => "The test uses a feature that is not yet implemented in the interpreter.", + error.ZeroSizedType => "The test expression results in a zero-sized type.", + else => "This usually indicates a bug in the test itself.", + }; + try report.document.addText(explanation); + + return report; + }, + .not_bool => { + var report = reporting.Report.init(self.allocator, "EXPECT TYPE ERROR", .runtime_error); + errdefer report.deinit(); + + try report.document.addText("This "); + try report.document.addAnnotated("expect", .keyword); + try report.document.addText(" expression must evaluate to a "); + try report.document.addAnnotated("Bool", .type_variable); + try report.document.addText(":"); + try report.document.addLineBreak(); + + // Show the source code with highlighting + const region_info = self.env.calcRegionInfo(test_result.region); + try report.document.addSourceRegion( + region_info, + .error_highlight, + filename, + self.env.common.source, + self.env.getLineStarts(), + ); + try report.document.addLineBreak(); + + try report.document.addText("The expression did not evaluate to a "); + try report.document.addAnnotated("Bool", .type_variable); + try report.document.addText(" value."); + try report.document.addLineBreak(); + try report.document.addLineBreak(); + try report.document.addText("Every "); + try report.document.addAnnotated("expect", .keyword); + try report.document.addText(" must have a boolean expression\u{2014}either "); + try report.document.addAnnotated("True", .tag_name); + try report.document.addText(" or "); + try report.document.addAnnotated("False", .tag_name); + try report.document.addText("."); + + return report; + }, + } + } + /// Write a html report of the test results to the given writer. pub fn write_html_report(self: *const TestRunner, writer: *std.Io.Writer) !void { if (self.test_results.items.len > 0) { diff --git a/src/fmt/fmt.zig b/src/fmt/fmt.zig index 521c5830f5..40cfad3611 100644 --- a/src/fmt/fmt.zig +++ b/src/fmt/fmt.zig @@ -177,6 +177,9 @@ pub fn formatFilePath(gpa: std.mem.Allocator, base_dir: std.fs.Dir, path: []cons } }; + var arena = std.heap.ArenaAllocator.init(gpa); + defer arena.deinit(); + var module_env = try ModuleEnv.init(gpa, contents); defer module_env.deinit(); @@ -212,6 +215,9 @@ pub fn formatStdin(gpa: std.mem.Allocator) !void { const contents = try std.fs.File.stdin().readToEndAlloc(gpa, Filesystem.max_file_size); // ModuleEnv takes ownership of contents + var arena = std.heap.ArenaAllocator.init(gpa); + defer arena.deinit(); + var module_env = try ModuleEnv.init(gpa, contents); defer module_env.deinit(); @@ -512,6 +518,23 @@ const Formatter = struct { } try fmt.formatWhereConstraint(w, multiline); } + if (d.associated) |assoc| { + try fmt.pushAll("."); + try fmt.push('{'); + if (assoc.statements.span.len > 0) { + try fmt.ensureNewline(); + fmt.curr_indent += 1; + const statements = fmt.ast.store.statementSlice(assoc.statements); + for (statements) |stmt_idx| { + try fmt.pushIndent(); + _ = try fmt.formatStatement(stmt_idx); + try fmt.ensureNewline(); + } + fmt.curr_indent -= 1; + try fmt.pushIndent(); + } + try fmt.push('}'); + } }, .type_anno => |t| { try fmt.pushTokenText(t.name); @@ -837,7 +860,7 @@ const Formatter = struct { fmt.curr_indent += 1; } var add_newline = false; - try fmt.pushAll("\"\"\""); + try fmt.pushAll("\\\\"); for (fmt.ast.store.exprSlice(s.parts)) |idx| { const e = fmt.ast.store.getExpr(idx); switch (e) { @@ -847,7 +870,7 @@ const Formatter = struct { _ = try fmt.flushCommentsBefore(str.region.start - 1); try fmt.ensureNewline(); try fmt.pushIndent(); - try fmt.pushAll("\"\"\""); + try fmt.pushAll("\\\\"); } add_newline = true; @@ -1411,7 +1434,7 @@ const Formatter = struct { } var platform_field: ?AST.RecordField.Idx = null; - var package_fields_list = try std.ArrayList(AST.RecordField.Idx).initCapacity(fmt.ast.store.gpa, 10); + var package_fields_list = try std.array_list.Managed(AST.RecordField.Idx).initCapacity(fmt.ast.store.gpa, 10); const packages_slice = fmt.ast.store.recordFieldSlice(.{ .span = packages.span }); for (packages_slice) |package_idx| { if (package_idx == a.platform_idx) { @@ -1643,6 +1666,8 @@ const Formatter = struct { Formatter.formatRecordField, ); }, + .type_module => {}, + .default_app => {}, .malformed => {}, } } @@ -2322,6 +2347,9 @@ pub fn moduleFmtsStable(gpa: std.mem.Allocator, input: []const u8, debug: bool) } fn parseAndFmt(gpa: std.mem.Allocator, input: []const u8, debug: bool) ![]const u8 { + var arena = std.heap.ArenaAllocator.init(gpa); + defer arena.deinit(); + var module_env = try ModuleEnv.init(gpa, input); defer module_env.deinit(); diff --git a/src/fs/Filesystem.zig b/src/fs/Filesystem.zig index 6e24457151..79e0b2eb91 100644 --- a/src/fs/Filesystem.zig +++ b/src/fs/Filesystem.zig @@ -161,8 +161,8 @@ pub const Dir = struct { dir: *Dir, gpa: std.mem.Allocator, string_arena: *std.heap.ArenaAllocator, - ) !std.ArrayList([]const u8) { - var files = std.ArrayList([]const u8){}; + ) !std.array_list.Managed([]const u8) { + var files = std.array_list.Managed([]const u8){}; errdefer files.deinit(gpa); var walker = try dir.dir.walk(gpa); diff --git a/src/interpreter_shim/main.zig b/src/interpreter_shim/main.zig index d4ca8c861c..834fc9d746 100644 --- a/src/interpreter_shim/main.zig +++ b/src/interpreter_shim/main.zig @@ -196,19 +196,13 @@ fn setupModuleEnv(shm: *SharedMemoryAllocator, roc_ops: *RocOps) ShimError!*Modu return error.ModuleEnvSetupFailed; } - // Get ModuleEnv pointer from the offset stored in the header + // Get ModuleEnv.Serialized pointer from the offset stored in the header const env_addr = @intFromPtr(base_ptr) + @as(usize, @intCast(header_ptr.module_env_offset)); - const env_ptr: *ModuleEnv = @ptrFromInt(env_addr); + const serialized_ptr: *ModuleEnv.Serialized = @ptrFromInt(env_addr); - // Set up the environment - env_ptr.gpa = std.heap.page_allocator; - env_ptr.relocate(offset); - - if (env_ptr.module_name.len > 0) { - const old_module_ptr = @intFromPtr(env_ptr.module_name.ptr); - const new_module_ptr = @as(isize, @intCast(old_module_ptr)) + offset; - env_ptr.module_name.ptr = @ptrFromInt(@as(usize, @intCast(new_module_ptr))); - } + // Deserialize the ModuleEnv, which properly reconstructs runtime fields + // Empty strings are used for source and module_name since they're not needed in the interpreter + const env_ptr = serialized_ptr.deserialize(offset, std.heap.page_allocator, "", ""); return env_ptr; } diff --git a/src/layout/store.zig b/src/layout/store.zig index caa30f6c2f..aebfa26da1 100644 --- a/src/layout/store.zig +++ b/src/layout/store.zig @@ -36,6 +36,7 @@ pub const LayoutError = error{ ZeroSizedType, TypeContainedMismatch, InvalidRecordExtension, + InvalidNumberExtension, // Compiler bugs. Hopefully these never come up, but if they do, the caller should gracefully recover. BugUnboxedFlexVar, BugUnboxedRigidVar, @@ -473,6 +474,56 @@ pub const Store = struct { }; } + /// Add the tag union's tags to self.pending_tags, + /// then add the tag union's extension fields too (recursively). + fn gatherTags( + self: *Self, + tag_union: types.TagUnion, + ) (LayoutError || std.mem.Allocator.Error)!usize { + var num_tags = tag_union.tags.len(); + + const tag_slice = self.types_store.getTagsSlice(tag_union.tags); + for (tag_slice.items(.name), tag_slice.items(.args)) |name, args| { + // TODO is it possible that here we're encountering record fields with names + // already in the list? Would type-checking have already deduped them? + // We would certainly rather not spend time doing hashmap things if we can avoid it here. + try self.work.pending_tags.append(self.env.gpa, .{ .name = name, .args = args }); + } + + var current_ext = tag_union.ext; + while (true) { + const resolved_ext = self.types_store.resolveVar(current_ext); + switch (resolved_ext.desc.content) { + .structure => |ext_flat_type| switch (ext_flat_type) { + .empty_tag_union => break, + .tag_union => |ext_tag_union| { + if (ext_tag_union.tags.len() > 0) { + num_tags += ext_tag_union.tags.len(); + const ext_tag_slice = self.types_store.getTagsSlice(ext_tag_union.tags); + for (ext_tag_slice.items(.name), ext_tag_slice.items(.args)) |name, args| { + // TODO is it possible that here we're adding fields with names + // already in the list? Would type-checking have already collapsed these? + // We would certainly rather not spend time doing hashmap things + // if we can avoid it here. + try self.work.pending_tags.append(self.env.gpa, .{ .name = name, .args = args }); + } + current_ext = ext_tag_union.ext; + } else { + break; + } + }, + else => return LayoutError.InvalidRecordExtension, + }, + .alias => |alias| { + current_ext = self.types_store.getAliasBackingVar(alias); + }, + else => return LayoutError.InvalidRecordExtension, + } + } + + return num_tags; + } + /// Add the record's fields to self.pending_record_fields, /// then add the record's extension fields too (recursively). fn gatherRecordFields( @@ -526,25 +577,13 @@ pub const Store = struct { // record_unbound has no extension, so stop here break; }, - .record_poly => |poly| { - if (poly.record.fields.len() > 0) { - num_fields += poly.record.fields.len(); - const poly_field_slice = self.types_store.getRecordFieldsSlice(poly.record.fields); - for (poly_field_slice.items(.name), poly_field_slice.items(.var_)) |name, var_| { - // TODO is it possible that here we're adding fields with names - // already in the list? Would type-checking have already collapsed these? - // We would certainly rather not spend time doing hashmap things - // if we can avoid it here. - try self.work.pending_record_fields.append(self.env.gpa, .{ .name = name, .var_ = var_ }); - } - } - current_ext = poly.record.ext; - }, else => return LayoutError.InvalidRecordExtension, }, .alias => |alias| { current_ext = self.types_store.getAliasBackingVar(alias); }, + .flex => |_| break, + .rigid => |_| break, else => return LayoutError.InvalidRecordExtension, } } @@ -820,13 +859,24 @@ pub const Store = struct { continue; }, .list => |elem_var| { - try self.work.pending_containers.append(self.env.gpa, .{ - .var_ = current.var_, - .container = .list, - }); - // Push a pending List container and "recurse" on the elem type - current = self.types_store.resolveVar(elem_var); - continue; + const elem_content = self.types_store.resolveVar(elem_var).desc.content; + if (elem_content == .flex or elem_content == .rigid) { + // For unbound lists (empty lists), use list of zero-sized type + const layout = Layout.listOfZst(); + const idx = try self.insertLayout(layout); + try self.layouts_by_var.put(self.env.gpa, current.var_, idx); + return idx; + } else { + // Otherwise, add this to the stack of pending work + try self.work.pending_containers.append(self.env.gpa, .{ + .var_ = current.var_, + .container = .list, + }); + + // Push a pending List container and "recurse" on the elem type + current = self.types_store.resolveVar(elem_var); + continue; + } }, .list_unbound => { // For unbound lists (empty lists), use list of zero-sized type @@ -848,20 +898,63 @@ pub const Store = struct { current = resolved; continue; }, - .num => |num| switch (num) { - .num_compact => |compact| switch (compact) { - .int => |precision| Layout.int(precision), - .frac => |precision| Layout.frac(precision), - }, - .int_precision => |precision| Layout.int(precision), - .frac_precision => |precision| Layout.frac(precision), - // For polymorphic types, use default precision - .num_unbound => Layout.int(types.Num.Int.Precision.default), - .int_unbound => Layout.int(types.Num.Int.Precision.default), - .frac_unbound => Layout.frac(types.Num.Frac.Precision.default), - .num_poly => Layout.int(types.Num.Int.Precision.default), - .int_poly => Layout.int(types.Num.Int.Precision.default), - .frac_poly => Layout.frac(types.Num.Frac.Precision.default), + .num => |initial_num| { + var num = initial_num; + + while (true) { + switch (num) { + // TODO: Unwrap number to get the root precision or requiremnets + .num_compact => |compact| switch (compact) { + .int => |precision| break :flat_type Layout.int(precision), + .frac => |precision| break :flat_type Layout.frac(precision), + }, + .int_precision => |precision| break :flat_type Layout.int(precision), + .frac_precision => |precision| break :flat_type Layout.frac(precision), + // For polymorphic types, use default precision + .num_unbound => |_| { + // TODO: Should we consider requirements here? + break :flat_type Layout.int(types.Num.Int.Precision.default); + }, + .int_unbound => { + // TODO: Should we consider requirements here? + break :flat_type Layout.int(types.Num.Int.Precision.default); + }, + .frac_unbound => { + // TODO: Should we consider requirements here? + break :flat_type Layout.frac(types.Num.Frac.Precision.default); + }, + .num_poly => |var_| { + const next_type = self.types_store.resolveVar(var_).desc.content; + if (next_type == .structure and next_type.structure == .num) { + num = next_type.structure.num; + } else if (next_type == .flex) { + break :flat_type Layout.int(types.Num.Int.Precision.default); + } else { + return LayoutError.InvalidRecordExtension; + } + }, + .int_poly => |var_| { + const next_type = self.types_store.resolveVar(var_).desc.content; + if (next_type == .structure and next_type.structure == .num) { + num = next_type.structure.num; + } else if (next_type == .flex) { + break :flat_type Layout.int(types.Num.Int.Precision.default); + } else { + return LayoutError.InvalidRecordExtension; + } + }, + .frac_poly => |var_| { + const next_type = self.types_store.resolveVar(var_).desc.content; + if (next_type == .structure and next_type.structure == .num) { + num = next_type.structure.num; + } else if (next_type == .flex) { + break :flat_type Layout.frac(types.Num.Frac.Precision.default); + } else { + return LayoutError.InvalidRecordExtension; + } + }, + } + } }, .tuple => |tuple_type| { const num_fields = try self.gatherTupleFields(tuple_type); @@ -933,13 +1026,23 @@ pub const Store = struct { // Handle tag unions by computing the layout based on: // 1. Discriminant size (based on number of tags) // 2. Maximum payload size and alignment - const tags = self.types_store.getTagsSlice(tag_union.tags); + + const pending_tags_top = self.work.pending_tags.len; + defer self.work.pending_tags.shrinkRetainingCapacity(pending_tags_top); + + // Recursively get all tags by checking the tag extension + const num_tags = try self.gatherTags(tag_union); + const tags_slice = self.work.pending_tags.slice(); + + // Get the slices of tags + const tags_args = tags_slice.items(.args)[pending_tags_top..]; // Check if this is a Bool (2 tags with no payload) as a special case // This is a legitimate layout optimization for boolean tag unions - if (tags.len == 2) { + // TODO: Is this necessary? + if (num_tags == 2) { var is_bool = true; - for (tags.items(.args)) |tag_args| { + for (tags_args) |tag_args| { const args_slice = self.types_store.sliceVars(tag_args); if (args_slice.len != 0) { is_bool = false; @@ -958,19 +1061,19 @@ pub const Store = struct { // For general tag unions, we need to compute the layout // First, determine discriminant size based on number of tags - const discriminant_layout = if (tags.len == 0) + const discriminant_layout = if (num_tags == 0) // Empty tag union - should not happen in practice return LayoutError.ZeroSizedType - else if (tags.len <= 256) + else if (num_tags <= 256) Layout.int(.u8) - else if (tags.len <= 65536) + else if (num_tags <= 65536) Layout.int(.u16) else Layout.int(.u32); // If all tags have no payload, we just need the discriminant var has_payload = false; - for (tags.items(.args)) |tag_args| { + for (tags_args) |tag_args| { const args_slice = self.types_store.sliceVars(tag_args); if (args_slice.len > 0) { has_payload = true; @@ -1018,7 +1121,8 @@ pub const Store = struct { // For each tag, compute its payload layout: () => ZST, 1 arg => layout, >1 => tuple of arg layouts var temp_scope = TypeScope.init(self.env.gpa); defer temp_scope.deinit(); - for (tags.items(.args)) |tag_args| { + + for (tags_slice.items(.args)) |tag_args| { const args_slice = self.types_store.sliceVars(tag_args); if (args_slice.len == 0) { // zero-sized payload; nothing to update @@ -1105,30 +1209,6 @@ pub const Store = struct { current = self.types_store.resolveVar(field.var_); continue; }, - .record_poly => |poly| { - const num_fields = try self.gatherRecordFields(poly.record); - - if (num_fields == 0) { - continue :flat_type .empty_record; - } - - try self.work.pending_containers.append(self.env.gpa, .{ - .var_ = current.var_, - .container = .{ - .record = .{ - .num_fields = @intCast(num_fields), - .resolved_fields_start = @intCast(self.work.resolved_record_fields.len), - .pending_fields = @intCast(num_fields), - }, - }, - }); - - // Start working on the last pending field (we want to pop them). - const field = self.work.pending_record_fields.get(self.work.pending_record_fields.len - 1); - - current = self.types_store.resolveVar(field.var_); - continue; - }, .empty_record, .empty_tag_union => blk: { // Empty records and tag unions are zero-sized, so we need to do something different // depending on the container we're working on (if any). For example, if we're @@ -1217,7 +1297,7 @@ pub const Store = struct { return LayoutError.ZeroSizedType; }, }, - .flex_var => |_| blk: { + .flex => |_| blk: { // First, check if this flex var is mapped in the TypeScope if (type_scope.lookup(current.var_)) |mapped_var| { // Found a mapping, resolve the mapped variable and continue @@ -1238,8 +1318,7 @@ pub const Store = struct { // For now, default to I64 for numeric flex vars. break :blk Layout.int(.i64); }, - .rigid_var => |ident| blk: { - _ = ident; + .rigid => |_| blk: { // First, check if this rigid var is mapped in the TypeScope if (type_scope.lookup(current.var_)) |mapped_var| { // Found a mapping, resolve the mapped variable and continue diff --git a/src/layout/store_test.zig b/src/layout/store_test.zig index 8131af8358..b6904bcdf9 100644 --- a/src/layout/store_test.zig +++ b/src/layout/store_test.zig @@ -85,7 +85,7 @@ test "addTypeVar - default layouts for polymorphic types" { // Flex number var (Num a) defaults to i128 const num_var = try lt.type_store.fresh(); - const flex_num_var = try lt.type_store.freshFromContent(.{ .structure = .{ .num = .{ .num_poly = .{ .var_ = num_var, .requirements = .{ .sign_needed = false, .bits_needed = 0 } } } } }); + const flex_num_var = try lt.type_store.freshFromContent(.{ .structure = .{ .num = .{ .num_poly = num_var } } }); const num_layout_idx = try lt.layout_store.addTypeVar(flex_num_var, <.type_scope); const num_layout = lt.layout_store.getLayout(num_layout_idx); try testing.expect(num_layout.tag == .scalar); @@ -93,7 +93,7 @@ test "addTypeVar - default layouts for polymorphic types" { // Flex int var (Int a) defaults to i128 const int_var = try lt.type_store.fresh(); - const flex_int_var = try lt.type_store.freshFromContent(.{ .structure = .{ .num = .{ .int_poly = .{ .var_ = int_var, .requirements = .{ .sign_needed = false, .bits_needed = 0 } } } } }); + const flex_int_var = try lt.type_store.freshFromContent(.{ .structure = .{ .num = .{ .int_poly = int_var } } }); const int_layout_idx = try lt.layout_store.addTypeVar(flex_int_var, <.type_scope); const int_layout = lt.layout_store.getLayout(int_layout_idx); try testing.expect(int_layout.tag == .scalar); @@ -101,7 +101,7 @@ test "addTypeVar - default layouts for polymorphic types" { // Flex frac var (Frac a) defaults to dec const frac_var = try lt.type_store.fresh(); - const flex_frac_var = try lt.type_store.freshFromContent(.{ .structure = .{ .num = .{ .frac_poly = .{ .var_ = frac_var, .requirements = .{ .fits_in_f32 = false, .fits_in_dec = true } } } } }); + const flex_frac_var = try lt.type_store.freshFromContent(.{ .structure = .{ .num = .{ .frac_poly = frac_var } } }); const frac_layout_idx = try lt.layout_store.addTypeVar(flex_frac_var, <.type_scope); const frac_layout = lt.layout_store.getLayout(frac_layout_idx); try testing.expect(frac_layout.tag == .scalar); @@ -118,7 +118,7 @@ test "addTypeVar - host opaque types compile to opaque_ptr" { defer lt.deinit(); // Box of flex_var - const flex_var = try lt.type_store.freshFromContent(.{ .flex_var = null }); + const flex_var = try lt.type_store.freshFromContent(.{ .flex = types.Flex.init() }); const box_flex_var = try lt.type_store.freshFromContent(.{ .structure = .{ .box = flex_var } }); const box_flex_idx = try lt.layout_store.addTypeVar(box_flex_var, <.type_scope); const box_flex_layout = lt.layout_store.getLayout(box_flex_idx); @@ -127,7 +127,7 @@ test "addTypeVar - host opaque types compile to opaque_ptr" { // Box of rigid_var const ident_idx = try lt.module_env.insertIdent(base.Ident.for_text("a")); - const rigid_var = try lt.type_store.freshFromContent(.{ .rigid_var = ident_idx }); + const rigid_var = try lt.type_store.freshFromContent(.{ .rigid = types.Rigid.init(ident_idx) }); const box_rigid_var = try lt.type_store.freshFromContent(.{ .structure = .{ .box = rigid_var } }); const box_rigid_idx = try lt.layout_store.addTypeVar(box_rigid_var, <.type_scope); const box_rigid_layout = lt.layout_store.getLayout(box_rigid_idx); diff --git a/src/layout/work.zig b/src/layout/work.zig index d093d60023..0fc509205d 100644 --- a/src/layout/work.zig +++ b/src/layout/work.zig @@ -11,6 +11,8 @@ pub const Work = struct { pending_containers: std.MultiArrayList(PendingContainerItem), pending_record_fields: std.MultiArrayList(types.RecordField), resolved_record_fields: std.MultiArrayList(ResolvedRecordField), + pending_tags: std.MultiArrayList(types.Tag), + resolved_tags: std.MultiArrayList(ResolvedTag), pending_tuple_fields: std.MultiArrayList(TupleField), resolved_tuple_fields: std.MultiArrayList(ResolvedTupleField), @@ -24,6 +26,11 @@ pub const Work = struct { var_: types.Var, }; + pub const ResolvedTag = struct { + field_name: Ident.Idx, + field_idx: layout.Idx, + }; + pub const ResolvedRecordField = struct { field_name: Ident.Idx, field_idx: layout.Idx, @@ -63,6 +70,12 @@ pub const Work = struct { var resolved_record_fields = std.MultiArrayList(ResolvedRecordField){}; try resolved_record_fields.ensureTotalCapacity(allocator, capacity); + var pending_tags = std.MultiArrayList(types.Tag){}; + try pending_tags.ensureTotalCapacity(allocator, capacity); + + var resolved_tags = std.MultiArrayList(ResolvedTag){}; + try resolved_tags.ensureTotalCapacity(allocator, capacity); + var pending_tuple_fields = std.MultiArrayList(TupleField){}; try pending_tuple_fields.ensureTotalCapacity(allocator, capacity); @@ -73,6 +86,8 @@ pub const Work = struct { .pending_containers = pending_containers, .pending_record_fields = pending_record_fields, .resolved_record_fields = resolved_record_fields, + .pending_tags = pending_tags, + .resolved_tags = resolved_tags, .pending_tuple_fields = pending_tuple_fields, .resolved_tuple_fields = resolved_tuple_fields, }; @@ -82,6 +97,8 @@ pub const Work = struct { self.pending_containers.deinit(allocator); self.pending_record_fields.deinit(allocator); self.resolved_record_fields.deinit(allocator); + self.pending_tags.deinit(allocator); + self.resolved_tags.deinit(allocator); self.pending_tuple_fields.deinit(allocator); self.resolved_tuple_fields.deinit(allocator); } @@ -90,6 +107,8 @@ pub const Work = struct { self.pending_containers.clearRetainingCapacity(); self.pending_record_fields.clearRetainingCapacity(); self.resolved_record_fields.clearRetainingCapacity(); + self.pending_tags.clearRetainingCapacity(); + self.resolved_tags.clearRetainingCapacity(); self.pending_tuple_fields.clearRetainingCapacity(); self.resolved_tuple_fields.clearRetainingCapacity(); } diff --git a/src/parse/AST.zig b/src/parse/AST.zig index 348114c96c..032836fd29 100644 --- a/src/parse/AST.zig +++ b/src/parse/AST.zig @@ -35,8 +35,8 @@ env: *CommonEnv, tokens: TokenizedBuffer, store: NodeStore, root_node_idx: u32 = 0, -tokenize_diagnostics: std.ArrayList(tokenize.Diagnostic), -parse_diagnostics: std.ArrayList(AST.Diagnostic), +tokenize_diagnostics: std.array_list.Managed(tokenize.Diagnostic), +parse_diagnostics: std.array_list.Managed(AST.Diagnostic), /// Calculate whether this region is - or will be - multiline pub fn regionIsMultiline(self: *AST, region: TokenizedRegion) bool { @@ -201,7 +201,9 @@ pub fn tokenizedRegionToRegion(self: *AST, tokenized_region: TokenizedRegion) ba safe_end_idx; const start_region = self.tokens.resolve(safe_start_idx); - const end_region = self.tokens.resolve(final_end_idx - 1); + // Protect against underflow when final_end_idx is 0 + const end_idx = if (final_end_idx > 0) final_end_idx - 1 else 0; + const end_region = self.tokens.resolve(end_idx); return .{ .start = start_region.start, .end = end_region.end, @@ -252,6 +254,9 @@ pub fn parseDiagnosticToReport(self: *AST, env: *const CommonEnv, diagnostic: Di .where_expected_colon => "WHERE CLAUSE ERROR", .where_expected_constraints => "WHERE CLAUSE ERROR", .no_else => "IF WITHOUT ELSE", + .type_alias_cannot_have_associated => "TYPE ALIAS WITH ASSOCIATED ITEMS", + .nominal_associated_cannot_have_final_expression => "EXPRESSION IN ASSOCIATED ITEMS", + .where_clause_not_allowed_in_type_declaration => "WHERE CLAUSE IN TYPE DECLARATION", else => "PARSE ERROR", }; @@ -548,6 +553,30 @@ pub fn parseDiagnosticToReport(self: *AST, env: *const CommonEnv, diagnostic: Di try report.document.addKeyword("False"); try report.document.addReflowingText("."); }, + .type_alias_cannot_have_associated => { + try report.document.addText("Type aliases cannot have associated items (such as types or methods)."); + try report.document.addLineBreak(); + try report.document.addLineBreak(); + try report.document.addReflowingText("Only nominal types (defined with "); + try report.document.addAnnotated(":=", .emphasized); + try report.document.addReflowingText(") can have associated items. Type aliases (defined with "); + try report.document.addAnnotated(":", .emphasized); + try report.document.addReflowingText(") only define names for other types."); + }, + .nominal_associated_cannot_have_final_expression => { + try report.document.addText("Associated items (such as types or methods) can only have associated types and values, not plain expressions."); + try report.document.addLineBreak(); + try report.document.addLineBreak(); + try report.document.addText("To fix this, remove the expression at the very end."); + }, + .where_clause_not_allowed_in_type_declaration => { + try report.document.addText("Type declarations cannot include "); + try report.document.addKeyword("where"); + try report.document.addText(" clauses."); + try report.document.addLineBreak(); + try report.document.addLineBreak(); + try report.document.addReflowingText("Only type annotations (such as annottions for a function or other value) can have them."); + }, else => { const tag_name = @tagName(diagnostic.tag); const owned_tag = try report.addOwnedString(tag_name); @@ -676,6 +705,9 @@ pub const Diagnostic = struct { expected_expr_close_curly, expr_dot_suffix_not_allowed, incomplete_import, + nominal_associated_cannot_have_final_expression, + type_alias_cannot_have_associated, + where_clause_not_allowed_in_type_declaration, }; }; @@ -834,8 +866,12 @@ pub const Statement = union(enum) { type_decl: struct { header: TypeHeader.Idx, anno: TypeAnno.Idx, - where: ?Collection.Idx, kind: TypeDeclKind, + /// Where clause (invalid in type declarations, but preserved for error recovery/formatting) + where: ?Collection.Idx, + /// Associated items block for .nominal types + /// (e.g. the curly braces in `Foo := [A, B].{ x = 5 }`) + associated: ?Associated, region: TokenizedRegion, }, type_anno: struct { @@ -978,15 +1014,19 @@ pub const Statement = union(enum) { try ast.store.getTypeAnno(a.anno).pushToSExprTree(gpa, env, ast, tree); - if (a.where) |where_coll| { - const where_node = tree.beginNode(); - try tree.pushStaticAtom("where"); - const attrs2 = tree.beginNode(); - for (ast.store.whereClauseSlice(.{ .span = ast.store.getCollection(where_coll).span })) |clause_idx| { - const clause_child = ast.store.getWhereClause(clause_idx); - try clause_child.pushToSExprTree(gpa, env, ast, tree); + // Add associated block if present + if (a.associated) |assoc| { + const assoc_begin = tree.beginNode(); + try tree.pushStaticAtom("associated"); + try ast.appendRegionInfoToSexprTree(env, tree, assoc.region); + const assoc_attrs = tree.beginNode(); + + for (ast.store.statementSlice(assoc.statements)) |stmt_idx| { + const stmt = ast.store.getStatement(stmt_idx); + try stmt.pushToSExprTree(gpa, env, ast, tree); } - try tree.endNode(where_node, attrs2); + + try tree.endNode(assoc_begin, assoc_attrs); } try tree.endNode(begin, attrs); @@ -1126,6 +1166,15 @@ pub const Block = struct { } }; +/// Represents associated items for nominal type declarations. +/// Associated items are the statements in the `.{ }` block after a nominal type, +/// e.g., `Foo := [A, B].{ x = 5 }` +pub const Associated = struct { + /// The statements in the associated items block + statements: Statement.Span, + region: TokenizedRegion, +}; + /// Represents a Pattern used in pattern matching. pub const Pattern = union(enum) { ident: struct { @@ -1496,6 +1545,15 @@ pub const Header = union(enum) { exposes: Collection.Idx, region: TokenizedRegion, }, + type_module: struct { + region: TokenizedRegion, + }, + default_app: struct { + // Stores reference to the main! function + // This will be filled in during canonicalization when main! is found + main_fn_idx: u32, // Will store CIR Def.Idx + region: TokenizedRegion, + }, malformed: struct { reason: Diagnostic.Tag, region: TokenizedRegion, @@ -1681,6 +1739,23 @@ pub const Header = union(enum) { try tree.endNode(begin, attrs); }, + .type_module => |a| { + const begin = tree.beginNode(); + try tree.pushStaticAtom("type-module"); + try ast.appendRegionInfoToSexprTree(env, tree, a.region); + const attrs = tree.beginNode(); + try tree.endNode(begin, attrs); + }, + .default_app => |a| { + const begin = tree.beginNode(); + try tree.pushStaticAtom("default-app"); + try ast.appendRegionInfoToSexprTree(env, tree, a.region); + const attrs = tree.beginNode(); + var buf: [32]u8 = undefined; + const idx_str = std.fmt.bufPrint(&buf, "{d}", .{a.main_fn_idx}) catch "(error)"; + try tree.pushStringPair("main-fn-idx", idx_str); + try tree.endNode(begin, attrs); + }, .malformed => |a| { const begin = tree.beginNode(); try tree.pushStaticAtom("malformed-header"); @@ -1700,6 +1775,8 @@ pub const Header = union(enum) { .package => |p| p.region, .platform => |p| p.region, .hosted => |h| h.region, + .type_module => |t| t.region, + .default_app => |d| d.region, .malformed => |m| m.region, }; } diff --git a/src/parse/Node.zig b/src/parse/Node.zig index 7f49817601..2a54796ef6 100644 --- a/src/parse/Node.zig +++ b/src/parse/Node.zig @@ -48,6 +48,8 @@ pub const Tag = enum { hosted_header, package_header, platform_header, + type_module_header, + default_app_header, // Statements diff --git a/src/parse/NodeStore.zig b/src/parse/NodeStore.zig index 4ce6335ec3..7de5c0e1ed 100644 --- a/src/parse/NodeStore.zig +++ b/src/parse/NodeStore.zig @@ -20,7 +20,7 @@ const NodeStore = @This(); gpa: std.mem.Allocator, nodes: Node.List, -extra_data: std.ArrayList(u32), +extra_data: std.array_list.Managed(u32), scratch_statements: base.Scratch(AST.Statement.Idx), scratch_tokens: base.Scratch(Token.Idx), scratch_exprs: base.Scratch(AST.Expr.Idx), @@ -54,7 +54,7 @@ pub fn initCapacity(gpa: std.mem.Allocator, capacity: usize) std.mem.Allocator.E var store: NodeStore = .{ .gpa = gpa, .nodes = try Node.List.initCapacity(gpa, capacity), - .extra_data = try std.ArrayList(u32).initCapacity(gpa, capacity / 2), + .extra_data = try std.array_list.Managed(u32).initCapacity(gpa, capacity / 2), .scratch_statements = try base.Scratch(AST.Statement.Idx).init(gpa), .scratch_tokens = try base.Scratch(Token.Idx).init(gpa), .scratch_exprs = try base.Scratch(AST.Expr.Idx).init(gpa), @@ -239,6 +239,15 @@ pub fn addHeader(store: *NodeStore, header: AST.Header) std.mem.Allocator.Error! node.region = platform.region; }, + .type_module => |type_module| { + node.tag = .type_module_header; + node.region = type_module.region; + }, + .default_app => |default_app| { + node.tag = .default_app_header; + node.main_token = default_app.main_fn_idx; + node.region = default_app.region; + }, .malformed => { @panic("Use addMalformed instead"); }, @@ -390,8 +399,33 @@ pub fn addStatement(store: *NodeStore, statement: AST.Statement) std.mem.Allocat node.region = d.region; node.data.lhs = @intFromEnum(d.header); node.data.rhs = @intFromEnum(d.anno); - if (d.where) |w| { - node.main_token = @intFromEnum(w); + + // Store optional where and associated in extra_data if either is present + if (d.where != null or d.associated != null) { + // Format: [where_idx, has_associated, associated_data...] + // where_idx is 0 if null, otherwise the Collection.Idx value + // has_associated is 0 or 1 + // associated_data is [statements_start, statements_len, region_start, region_end] if has_associated == 1 + const extra_start = @as(u32, @intCast(store.extra_data.items.len)); + + // Store where clause index (0 if null) + const where_idx = if (d.where) |w| @intFromEnum(w) else 0; + try store.extra_data.append(store.gpa, where_idx); + + // Store associated data if present + if (d.associated) |assoc| { + try store.extra_data.append(store.gpa, 1); // has_associated = 1 + try store.extra_data.append(store.gpa, assoc.statements.span.start); + try store.extra_data.append(store.gpa, assoc.statements.span.len); + try store.extra_data.append(store.gpa, assoc.region.start); + try store.extra_data.append(store.gpa, assoc.region.end); + } else { + try store.extra_data.append(store.gpa, 0); // has_associated = 0 + } + + node.main_token = extra_start; + } else { + node.main_token = 0; } }, .type_anno => |a| { @@ -1013,6 +1047,17 @@ pub fn getHeader(store: *const NodeStore, header_idx: AST.Header.Idx) AST.Header .region = node.region, } }; }, + .type_module_header => { + return .{ .type_module = .{ + .region = node.region, + } }; + }, + .default_app_header => { + return .{ .default_app = .{ + .main_fn_idx = node.main_token, + .region = node.region, + } }; + }, .malformed => { return .{ .malformed = .{ .reason = @enumFromInt(node.data.lhs), @@ -1163,21 +1208,71 @@ pub fn getStatement(store: *const NodeStore, statement_idx: AST.Statement.Idx) A } }; }, .type_decl => { + // Read where and associated from extra_data if present (main_token != 0) + var where_clause: ?AST.Collection.Idx = null; + var associated: ?AST.Associated = null; + if (node.main_token != 0) { + const extra_start = node.main_token; + // Format: [where_idx, has_associated, associated_data...] + const where_idx = store.extra_data.items[extra_start]; + if (where_idx != 0) { + where_clause = @enumFromInt(where_idx); + } + + const has_associated = store.extra_data.items[extra_start + 1]; + if (has_associated == 1) { + const stmt_start = store.extra_data.items[extra_start + 2]; + const stmt_len = store.extra_data.items[extra_start + 3]; + const reg_start = store.extra_data.items[extra_start + 4]; + const reg_end = store.extra_data.items[extra_start + 5]; + associated = AST.Associated{ + .statements = AST.Statement.Span{ .span = .{ .start = stmt_start, .len = stmt_len } }, + .region = .{ .start = reg_start, .end = reg_end }, + }; + } + } + return .{ .type_decl = .{ .region = node.region, .header = @enumFromInt(node.data.lhs), .anno = @enumFromInt(node.data.rhs), .kind = .alias, - .where = if (node.main_token != 0) @enumFromInt(node.main_token) else null, + .where = where_clause, + .associated = associated, } }; }, .type_decl_nominal => { + // Read where and associated from extra_data if present (main_token != 0) + var where_clause: ?AST.Collection.Idx = null; + var associated: ?AST.Associated = null; + if (node.main_token != 0) { + const extra_start = node.main_token; + // Format: [where_idx, has_associated, associated_data...] + const where_idx = store.extra_data.items[extra_start]; + if (where_idx != 0) { + where_clause = @enumFromInt(where_idx); + } + + const has_associated = store.extra_data.items[extra_start + 1]; + if (has_associated == 1) { + const stmt_start = store.extra_data.items[extra_start + 2]; + const stmt_len = store.extra_data.items[extra_start + 3]; + const reg_start = store.extra_data.items[extra_start + 4]; + const reg_end = store.extra_data.items[extra_start + 5]; + associated = AST.Associated{ + .statements = AST.Statement.Span{ .span = .{ .start = stmt_start, .len = stmt_len } }, + .region = .{ .start = reg_start, .end = reg_end }, + }; + } + } + return .{ .type_decl = .{ .region = node.region, .header = @enumFromInt(node.data.lhs), .anno = @enumFromInt(node.data.rhs), .kind = .nominal, - .where = if (node.main_token != 0) @enumFromInt(node.main_token) else null, + .where = where_clause, + .associated = associated, } }; }, .type_anno => { diff --git a/src/parse/Parser.zig b/src/parse/Parser.zig index fa5808177d..f165bdfe85 100644 --- a/src/parse/Parser.zig +++ b/src/parse/Parser.zig @@ -29,8 +29,8 @@ gpa: std.mem.Allocator, pos: TokenIdx, tok_buf: TokenizedBuffer, store: NodeStore, -scratch_nodes: std.ArrayList(Node.Idx), -diagnostics: std.ArrayList(AST.Diagnostic), +scratch_nodes: std.array_list.Managed(Node.Idx), +diagnostics: std.array_list.Managed(AST.Diagnostic), cached_malformed_node: ?Node.Idx, nesting_counter: u8, @@ -282,7 +282,10 @@ pub fn parseHeader(self: *Parser) Error!AST.Header.Idx { return self.parsePlatformHeader(); }, else => { - return try self.pushMalformed(AST.Header.Idx, .missing_header, self.pos); + // No header keyword found - this is a type module + return try self.store.addHeader(.{ .type_module = .{ + .region = .{ .start = 0, .end = 0 }, + } }); }, } } @@ -927,7 +930,7 @@ pub fn parseExposedItem(self: *Parser) Error!AST.ExposedItem.Idx { } } -const StatementType = enum { top_level, in_body }; +const StatementType = enum { top_level, in_body, in_associated_block }; /// Parse a top level roc statement /// @@ -1167,7 +1170,7 @@ fn parseStmtByType(self: *Parser, statementType: StatementType) Error!AST.Statem // Type Annotation (e.g. `Foo a : (a,a)`) .UpperIdent => { const start = self.pos; - if (statementType == .top_level) { + if (statementType == .top_level or statementType == .in_associated_block) { const header = try self.parseTypeHeader(); if (self.peek() != .OpColon and self.peek() != .OpColonEqual) { // Point to the unexpected token (e.g., "U8" in "List U8") @@ -1177,13 +1180,32 @@ fn parseStmtByType(self: *Parser, statementType: StatementType) Error!AST.Statem self.advance(); const anno = try self.parseTypeAnno(.not_looking_for_args); const where_clause = try self.parseWhereConstraint(); - // Use the type annotation's end position if there's no where clause, - // otherwise use the current position (after parsing where clause) + + // Check if there's a .{ associated } after the type annotation + var associated: ?AST.Associated = null; + if (self.peek() == .Dot and self.peekN(1) == .OpenCurly) { + const dot_pos = self.pos; + // Parse the associated items block + self.advance(); // consume . + self.advance(); // consume { + const associated_start = self.pos - 1; + associated = try self.parseStatementOnlyBlock(associated_start); + + // Report error if this is a type alias + if (kind == .alias) { + try self.pushDiagnostic(.type_alias_cannot_have_associated, .{ + .start = dot_pos, + .end = dot_pos + 1, + }); + } + } + const statement_idx = try self.store.addStatement(.{ .type_decl = .{ .header = header, .anno = anno, - .where = where_clause, .kind = kind, + .where = where_clause, + .associated = associated, .region = .{ .start = start, .end = self.pos }, } }); return statement_idx; @@ -2935,6 +2957,50 @@ pub fn parseBlock(self: *Parser, start: u32) Error!AST.Expr.Idx { } }); } +/// Parse a block that contains only statements, no ending expression. +/// This is used for nominal type associated items like `Foo := [A, B].{ x = 5 }` +/// { +/// +/// ... +/// +/// } +pub fn parseStatementOnlyBlock(self: *Parser, start: u32) Error!AST.Associated { + const scratch_top = self.store.scratchStatementTop(); + + while (self.peek() != .EndOfFile and self.peek() != .CloseCurly) { + const statement_pos = self.pos; + const statement = try self.parseStmtByType(.in_associated_block); + + // Check if this is an expression statement (the last statement must not be an expression) + const stmt = self.store.getStatement(statement); + if (stmt == .expr) { + // Check if we're at the closing brace (this would be a final expression) + if (self.peek() == .CloseCurly) { + try self.pushDiagnostic(.nominal_associated_cannot_have_final_expression, .{ + .start = statement_pos, + .end = self.pos, + }); + // Still add it to maintain AST structure + } + } + + try self.store.addScratchStatement(statement); + } + + self.expect(.CloseCurly) catch { + try self.pushDiagnostic(.expected_expr_close_curly, .{ + .start = self.pos, + .end = self.pos, + }); + }; + + const statements = try self.store.statementSpanFrom(scratch_top); + return AST.Associated{ + .statements = statements, + .region = .{ .start = start, .end = self.pos }, + }; +} + /// Parse a record. /// Check parseRecordField to see how record fields are parsed. /// { diff --git a/src/parse/mod.zig b/src/parse/mod.zig index c78a9a4e17..0300229981 100644 --- a/src/parse/mod.zig +++ b/src/parse/mod.zig @@ -52,7 +52,7 @@ fn runParse(env: *CommonEnv, gpa: std.mem.Allocator, parserCall: *const fn (*Par const idx = try parserCall(&parser); const tokenize_diagnostics_slice = try gpa.dupe(tokenize.Diagnostic, result.messages); - const tokenize_diagnostics = std.ArrayList(tokenize.Diagnostic).fromOwnedSlice(tokenize_diagnostics_slice); + const tokenize_diagnostics = std.array_list.Managed(tokenize.Diagnostic).fromOwnedSlice(tokenize_diagnostics_slice); return .{ .env = env, diff --git a/src/parse/test/ast_node_store_test.zig b/src/parse/test/ast_node_store_test.zig index 3c7c69f486..a8e15cdb22 100644 --- a/src/parse/test/ast_node_store_test.zig +++ b/src/parse/test/ast_node_store_test.zig @@ -228,6 +228,7 @@ test "NodeStore round trip - Statement" { .kind = AST.TypeDeclKind.nominal, .region = rand_region(), .where = rand_idx(AST.Collection.Idx), + .associated = null, }, }); try statements.append(AST.Statement{ diff --git a/src/parse/tokenize.zig b/src/parse/tokenize.zig index feb8aec8d6..b764093d57 100644 --- a/src/parse/tokenize.zig +++ b/src/parse/tokenize.zig @@ -46,7 +46,7 @@ pub const Token = struct { Float, StringStart, // the " that starts a string StringEnd, // the " that ends a string - MultilineStringStart, // the """ that starts a multiline string + MultilineStringStart, // the """ or \\ that starts a multiline string StringPart, MalformedStringPart, // malformed, but should be treated similar to a StringPart in the parser SingleQuote, @@ -1058,7 +1058,7 @@ const StringKind = enum { pub const Tokenizer = struct { cursor: Cursor, output: TokenizedBuffer, - string_interpolation_stack: std.ArrayList(StringKind), + string_interpolation_stack: std.array_list.Managed(StringKind), env: *CommonEnv, /// Creates a new Tokenizer. @@ -1304,8 +1304,12 @@ pub const Tokenizer = struct { // Backslash (\) '\\' => { - self.cursor.pos += 1; - try self.pushTokenNormalHere(gpa, .OpBackslash, start); + if (self.cursor.peekAt(1) == '\\') { + try self.tokenizeMultilineStringLiteral(gpa); + } else { + self.cursor.pos += 1; + try self.pushTokenNormalHere(gpa, .OpBackslash, start); + } }, // Percent (%) @@ -1532,6 +1536,14 @@ pub const Tokenizer = struct { try self.tokenizeStringLikeLiteralBody(gpa, kind, start); } + pub fn tokenizeMultilineStringLiteral(self: *Tokenizer, gpa: std.mem.Allocator) std.mem.Allocator.Error!void { + const start = self.cursor.pos; + std.debug.assert(self.cursor.peek() == '\\' and self.cursor.peekAt(1) == '\\'); + self.cursor.pos += 2; + try self.pushTokenNormalHere(gpa, .MultilineStringStart, start); + try self.tokenizeStringLikeLiteralBody(gpa, .multi_line, start); + } + // Moving curly chars to constants because some editors hate them inline. const open_curly = '{'; const close_curly = '}'; @@ -1715,9 +1727,9 @@ pub fn checkTokenizerInvariants(gpa: std.mem.Allocator, input: []const u8, debug } } -fn rebuildBufferForTesting(buf: []const u8, tokens: *TokenizedBuffer, alloc: std.mem.Allocator) !std.ArrayList(u8) { +fn rebuildBufferForTesting(buf: []const u8, tokens: *TokenizedBuffer, alloc: std.mem.Allocator) !std.array_list.Managed(u8) { // Create an arraylist to store the new buffer. - var buf2 = try std.ArrayList(u8).initCapacity(alloc, buf.len); + var buf2 = try std.array_list.Managed(u8).initCapacity(alloc, buf.len); errdefer buf2.deinit(alloc); // Dump back to buffer. @@ -1818,9 +1830,14 @@ fn rebuildBufferForTesting(buf: []const u8, tokens: *TokenizedBuffer, alloc: std try buf2.append(alloc, '"'); }, .MultilineStringStart => { - try buf2.append(alloc, '"'); - try buf2.append(alloc, '"'); - try buf2.append(alloc, '"'); + if (length == 3 and buf[region.start.offset] == '"') { + try buf2.append(alloc, '"'); + try buf2.append(alloc, '"'); + try buf2.append(alloc, '"'); + } else { + try buf2.append(alloc, '\\'); + try buf2.append(alloc, '\\'); + } }, .StringPart => { for (0..length) |_| { @@ -2298,6 +2315,30 @@ test "tokenizer" { .StringPart, }, ); + + // Test new \\ multiline string syntax + try testTokenization( + gpa, + "\\\\hello", + &[_]Token.Tag{ .MultilineStringStart, .StringPart }, + ); + try testTokenization( + gpa, + "\\\\hello\n\\\\world", + &[_]Token.Tag{ .MultilineStringStart, .StringPart, .MultilineStringStart, .StringPart }, + ); + try testTokenization( + gpa, + "\\\\a${b}c", + &[_]Token.Tag{ + .MultilineStringStart, + .StringPart, + .OpenStringInterpolation, + .LowerIdent, + .CloseStringInterpolation, + .StringPart, + }, + ); } test "tokenizer with invalid UTF-8" { diff --git a/src/playground_wasm/main.zig b/src/playground_wasm/main.zig index 331954a612..b86696a96a 100644 --- a/src/playground_wasm/main.zig +++ b/src/playground_wasm/main.zig @@ -788,6 +788,7 @@ fn compileSource(source: []const u8) !CompilerStageData { if (source.len == 0) { // Return empty compiler stage data for completely empty input var module_env = try allocator.create(ModuleEnv); + module_env.* = try ModuleEnv.init(allocator, source); try module_env.common.calcLineStarts(module_env.gpa); return CompilerStageData.init(allocator, module_env); @@ -797,6 +798,7 @@ fn compileSource(source: []const u8) !CompilerStageData { if (trimmed_source.len == 0) { // Return empty compiler stage data for whitespace-only input var module_env = try allocator.create(ModuleEnv); + module_env.* = try ModuleEnv.init(allocator, source); try module_env.common.calcLineStarts(module_env.gpa); return CompilerStageData.init(allocator, module_env); @@ -807,6 +809,7 @@ fn compileSource(source: []const u8) !CompilerStageData { // Initialize the ModuleEnv var module_env = try allocator.create(ModuleEnv); + module_env.* = try ModuleEnv.init(allocator, source); try module_env.common.calcLineStarts(module_env.gpa); @@ -884,7 +887,13 @@ fn compileSource(source: []const u8) !CompilerStageData { const env = result.module_env; try env.initCIRFields(allocator, "main"); - var czer = try Can.init(env, &result.parse_ast.?, null); + const module_common_idents: Check.CommonIdents = .{ + .module_name = try module_env.insertIdent(base.Ident.for_text("main")), + .list = try module_env.insertIdent(base.Ident.for_text("List")), + .box = try module_env.insertIdent(base.Ident.for_text("Box")), + }; + + var czer = try Can.init(env, &result.parse_ast.?, null, .{}); defer czer.deinit(); czer.canonicalizeFile() catch |err| { @@ -896,6 +905,13 @@ fn compileSource(source: []const u8) !CompilerStageData { } }; + czer.validateForChecking() catch |err| { + logDebug("compileSource: validateForChecking failed: {}\n", .{err}); + if (err == error.OutOfMemory) { + return err; + } + }; + // Copy the modified AST back into the main result to ensure state consistency result.parse_ast = parse_ast; @@ -918,11 +934,11 @@ fn compileSource(source: []const u8) !CompilerStageData { const type_can_ir = result.module_env; const empty_modules: []const *ModuleEnv = &.{}; // Use pointer to the stored CIR to ensure solver references valid memory - var solver = try Check.init(allocator, &type_can_ir.types, type_can_ir, empty_modules, &type_can_ir.store.regions); + var solver = try Check.init(allocator, &type_can_ir.types, type_can_ir, empty_modules, &type_can_ir.store.regions, module_common_idents); result.solver = solver; - solver.checkDefs() catch |check_err| { - logDebug("compileSource: checkDefs failed: {}\n", .{check_err}); + solver.checkFile() catch |check_err| { + logDebug("compileSource: checkFile failed: {}\n", .{check_err}); if (check_err == error.OutOfMemory) { // OOM during type checking is critical. // Deinit solver and propagate error. diff --git a/src/repl/Repl.zig b/src/repl/Repl.zig index 928ea6fda8..14ab1e698d 100644 --- a/src/repl/Repl.zig +++ b/src/repl/Repl.zig @@ -23,12 +23,22 @@ const RocOps = builtins.host_abi.RocOps; const Repl = @This(); +/// Information about a type declaration +const TypeDeclInfo = struct { + /// Name of the type (e.g., "Foo") + type_name: []const u8, + /// Whether it has associated items + has_associated_items: bool, +}; + /// Type of definition stored in the REPL history const DefKind = union(enum) { /// An assignment with an identifier assignment: []const u8, /// An import statement import, + /// A type declaration + type_decl: TypeDeclInfo, }; /// Represents a past definition in the REPL session @@ -43,6 +53,7 @@ const PastDef = struct { switch (self.kind) { .assignment => |ident| allocator.free(ident), .import => {}, + .type_decl => |info| allocator.free(info.type_name), } } }; @@ -119,31 +130,21 @@ fn processInput(self: *Repl, input: []const u8) ![]const u8 { switch (parse_result) { .assignment => |info| { + // Make a copy of the identifier to keep (will be stored in past_defs) + const ident_for_past_defs = try self.allocator.dupe(u8, info.ident); + errdefer self.allocator.free(ident_for_past_defs); defer self.allocator.free(info.ident); - // Add to past definitions (allows redefinition) + // Evaluate the assignment and return the value of the identifier + const result = try self.evaluateDefinition(input, ident_for_past_defs); + + // Add to past definitions after successful evaluation (allows redefinition) try self.past_defs.append(.{ .source = try self.allocator.dupe(u8, input), - .kind = .{ .assignment = try self.allocator.dupe(u8, info.ident) }, + .kind = .{ .assignment = ident_for_past_defs }, }); - // For assignments, evaluate the RHS directly - // Extract the RHS from the assignment - if (std.mem.indexOf(u8, input, "=")) |eq_pos| { - const rhs = std.mem.trim(u8, input[eq_pos + 1 ..], " \t\n"); - - // If the RHS is a simple literal, evaluate it directly - if (std.fmt.parseInt(i64, rhs, 10)) |num| { - return try std.fmt.allocPrint(self.allocator, "{d}", .{num}); - } else |_| {} - - // Otherwise, evaluate with context - const full_source = try self.buildFullSource(rhs); - defer self.allocator.free(full_source); - return try self.evaluateSource(full_source); - } - - return try self.allocator.dupe(u8, ""); + return result; }, .import => { // Add import to past definitions @@ -156,14 +157,23 @@ fn processInput(self: *Repl, input: []const u8) ![]const u8 { }, .expression => { // Evaluate expression with all past definitions - const full_source = try self.buildFullSource(input); - defer self.allocator.free(full_source); - - return try self.evaluateSource(full_source); + return try self.evaluateSource(input); }, - .type_decl => { - // Type declarations can't be evaluated - return try self.allocator.dupe(u8, ""); + .type_decl => |info| { + defer self.allocator.free(info.type_name); + + // Store the type declaration - associated items will be canonicalized and evaluated + // automatically when we build the full source for the next expression/definition + try self.past_defs.append(.{ + .source = try self.allocator.dupe(u8, input), + .kind = .{ .type_decl = .{ + .type_name = try self.allocator.dupe(u8, info.type_name), + .has_associated_items = info.has_associated_items, + } }, + }); + + // Output the type name to indicate it was defined + return try std.fmt.allocPrint(self.allocator, "{s}", .{info.type_name}); }, .parse_error => |msg| { defer self.allocator.free(msg); @@ -176,15 +186,63 @@ const ParseResult = union(enum) { assignment: struct { ident: []const u8 }, // This ident must be allocator.dupe'd import, expression, - type_decl, + type_decl: struct { + type_name: []const u8, // This must be allocator.dupe'd + has_associated_items: bool, + }, parse_error: []const u8, // This must be allocator.dupe'd }; /// Try to parse input as a statement fn tryParseStatement(self: *Repl, input: []const u8) !ParseResult { + var arena = std.heap.ArenaAllocator.init(self.allocator); + defer arena.deinit(); + var module_env = try ModuleEnv.init(self.allocator, input); defer module_env.deinit(); + // Try parsing as a full file first (for type declarations with associated items) + if (parse.parse(&module_env.common, self.allocator)) |ast_const| { + var ast = ast_const; + defer ast.deinit(self.allocator); + + // Get the file (type modules have root_node_idx = 0) + const file = ast.store.getFile(); + const statements = ast.store.statementSlice(file.statements); + + if (statements.len == 1) { + const stmt = ast.store.getStatement(statements[0]); + switch (stmt) { + .decl => |decl| { + const pattern = ast.store.getPattern(decl.pattern); + if (pattern == .ident) { + const ident_tok = pattern.ident.ident_tok; + const token_region = ast.tokens.resolve(@intCast(ident_tok)); + const ident = ast.env.source[token_region.start.offset..token_region.end.offset]; + const ident_copy = try self.allocator.dupe(u8, ident); + return ParseResult{ .assignment = .{ .ident = ident_copy } }; + } + return ParseResult.expression; + }, + .import => return ParseResult.import, + .type_decl => |decl| { + const header = ast.store.getTypeHeader(decl.header) catch { + return ParseResult.expression; + }; + const type_name_tok = header.name; + const token_region = ast.tokens.resolve(type_name_tok); + const type_name = ast.env.source[token_region.start.offset..token_region.end.offset]; + + return ParseResult{ .type_decl = .{ + .type_name = try self.allocator.dupe(u8, type_name), + .has_associated_items = decl.associated != null, + } }; + }, + else => return ParseResult.expression, + } + } + } else |_| {} + // Try statement parsing if (parse.parseStatement(&module_env.common, self.allocator)) |ast_const| { var ast = ast_const; @@ -208,7 +266,20 @@ fn tryParseStatement(self: *Repl, input: []const u8) !ParseResult { return ParseResult.expression; }, .import => return ParseResult.import, - .type_decl => return ParseResult.type_decl, + .type_decl => |decl| { + const header = ast.store.getTypeHeader(decl.header) catch { + // If we can't get the type header, treat it as an expression + return ParseResult.expression; + }; + const type_name_tok = header.name; + const token_region = ast.tokens.resolve(type_name_tok); + const type_name = ast.env.source[token_region.start.offset..token_region.end.offset]; + + return ParseResult{ .type_decl = .{ + .type_name = try self.allocator.dupe(u8, type_name), + .has_associated_items = decl.associated != null, + } }; + }, else => return ParseResult.expression, } } @@ -227,8 +298,9 @@ fn tryParseStatement(self: *Repl, input: []const u8) !ParseResult { } /// Build full source including all past definitions -fn buildFullSource(self: *Repl, current_expr: []const u8) ![]const u8 { - var buffer = std.array_list.AlignedManaged(u8, null).init(self.allocator); +/// If `def_ident` is provided, the current_expr is a definition and we add an expression to evaluate def_ident +fn buildFullSource(self: *Repl, current_expr: []const u8, def_ident: ?[]const u8) ![]const u8 { + var buffer = std.array_list.Managed(u8).init(self.allocator); defer buffer.deinit(); // Add all past definitions in order (later ones shadow earlier ones) @@ -237,39 +309,71 @@ fn buildFullSource(self: *Repl, current_expr: []const u8) ![]const u8 { try buffer.append('\n'); } - // Add current expression - try buffer.appendSlice(current_expr); + // If we have past_defs OR a def_ident, we need to wrap/structure the source + if (self.past_defs.items.len > 0 or def_ident != null) { + // Don't add a header - we'll parse as a headerless file (type module or default-app) + // The REPL validation_context will skip module validation + + if (def_ident) |ident| { + // Current input is a definition - add it as-is, then add an expression to evaluate the identifier + try buffer.appendSlice(current_expr); + try buffer.append('\n'); + try buffer.appendSlice("main! = |_| "); + try buffer.appendSlice(ident); + } else { + // Current input is an expression - wrap it in main! + try buffer.appendSlice("main! = |_| "); + try buffer.appendSlice(current_expr); + } + } else { + try buffer.appendSlice(current_expr); + } return try buffer.toOwnedSlice(); } /// Evaluate source code fn evaluateSource(self: *Repl, source: []const u8) ![]const u8 { - return try self.evaluatePureExpression(source); + return try self.evaluatePureExpression(source, null); +} + +/// Evaluate source code for a definition and return the value of the assigned identifier +fn evaluateDefinition(self: *Repl, source: []const u8, ident: []const u8) ![]const u8 { + return try self.evaluatePureExpression(source, ident); } /// Evaluate a pure expression -fn evaluatePureExpression(self: *Repl, expr_source: []const u8) ![]const u8 { - // If we have past definitions and the expression might reference them, - // we need context-aware evaluation (not yet implemented) - if (self.past_defs.items.len > 0) { - // Check if it's a simple literal that doesn't need context - if (std.fmt.parseInt(i64, std.mem.trim(u8, expr_source, " \t\n"), 10)) |num| { - return try std.fmt.allocPrint(self.allocator, "{d}", .{num}); - } else |_| {} - - // Context-aware evaluation not yet implemented - return try std.fmt.allocPrint(self.allocator, "", .{}); - } +/// If `def_ident` is provided, the expr_source is treated as a definition and we return the value of def_ident +fn evaluatePureExpression(self: *Repl, expr_source: []const u8, def_ident: ?[]const u8) ![]const u8 { + // Build the full source including past definitions + // We need to build full source if we have past_defs OR if this is a definition (def_ident != null) + const need_full_source = self.past_defs.items.len > 0 or def_ident != null; + const full_source = if (need_full_source) + try self.buildFullSource(expr_source, def_ident) + else + expr_source; + defer if (need_full_source) self.allocator.free(full_source); // Create module environment for the expression - var module_env = try ModuleEnv.init(self.allocator, expr_source); + var arena = std.heap.ArenaAllocator.init(self.allocator); + defer arena.deinit(); + + var module_env = try ModuleEnv.init(self.allocator, full_source); defer module_env.deinit(); - // Parse as expression - var parse_ast = parse.parseExpr(&module_env.common, self.allocator) catch |err| { - return try std.fmt.allocPrint(self.allocator, "Parse error: {}", .{err}); - }; + // Parse as a file if buildFullSource wrapped the input in a synthetic `main! = |_| `. + // This happens when we have past definitions to include, or when evaluating a definition (def_ident != null). + // Otherwise, parse the input directly as an expression. + const need_file_parse = self.past_defs.items.len > 0 or def_ident != null; + + var parse_ast = if (need_file_parse) + parse.parse(&module_env.common, self.allocator) catch |err| { + return try std.fmt.allocPrint(self.allocator, "Parse error: {}", .{err}); + } + else + parse.parseExpr(&module_env.common, self.allocator) catch |err| { + return try std.fmt.allocPrint(self.allocator, "Parse error: {}", .{err}); + }; defer parse_ast.deinit(self.allocator); // Empty scratch space @@ -277,32 +381,98 @@ fn evaluatePureExpression(self: *Repl, expr_source: []const u8) ![]const u8 { // Create CIR const cir = &module_env; // CIR is now just ModuleEnv - try cir.initCIRFields(self.allocator, "repl"); + const module_name = "repl"; + try cir.initCIRFields(self.allocator, module_name); + + const common_idents: Check.CommonIdents = .{ + .module_name = try cir.insertIdent(base.Ident.for_text(module_name)), + .list = try cir.insertIdent(base.Ident.for_text("List")), + .box = try cir.insertIdent(base.Ident.for_text("Box")), + }; // Create czer // - var czer = Can.init(cir, &parse_ast, null) catch |err| { + var czer = Can.init(cir, &parse_ast, null, .{}) catch |err| { return try std.fmt.allocPrint(self.allocator, "Canonicalize init error: {}", .{err}); }; defer czer.deinit(); - // Canonicalize the expression - const expr_idx: parse.AST.Expr.Idx = @enumFromInt(parse_ast.root_node_idx); - const canonical_expr_idx = czer.canonicalizeExpr(expr_idx) catch |err| { - return try std.fmt.allocPrint(self.allocator, "Canonicalize expr error: {}", .{err}); - } orelse { - return try self.allocator.dupe(u8, "Failed to canonicalize expression"); + // Canonicalize based on whether we have past definitions or a def_ident + const canonical_expr_idx: can.CIR.Expr.Idx = if (self.past_defs.items.len > 0 or def_ident != null) blk: { + // When there are past definitions, buildFullSource wraps the expression in a synthetic + // `main! = |_| ` so it can be evaluated along with those definitions. + czer.canonicalizeFile() catch |err| { + return try std.fmt.allocPrint(self.allocator, "Canonicalize file error: {}", .{err}); + }; + + const defs_slice = cir.store.sliceDefs(czer.env.all_defs); + + if (defs_slice.len == 0) { + return try self.allocator.dupe(u8, "No definitions created during canonicalization"); + } + + // Find the synthetic "main!" definition that wraps the expression + var main_def_idx: ?can.CIR.Def.Idx = null; + for (defs_slice) |def_idx| { + const def = cir.store.getDef(def_idx); + const pattern = cir.store.getPattern(def.pattern); + if (pattern == .assign) { + const ident_idx = pattern.assign.ident; + const ident_text = cir.getIdent(ident_idx); + if (std.mem.eql(u8, ident_text, "main!")) { + main_def_idx = def_idx; + break; + } + } + } + + if (main_def_idx) |def_idx| { + const def = cir.store.getDef(def_idx); + const expr = cir.store.getExpr(def.expr); + // Extract the body from main! = |_| + if (expr == .e_lambda) { + break :blk expr.e_lambda.body; + } else if (expr == .e_closure) { + const lambda_expr = cir.store.getExpr(expr.e_closure.lambda_idx); + if (lambda_expr == .e_lambda) { + break :blk lambda_expr.e_lambda.body; + } else { + return try self.allocator.dupe(u8, "main! closure does not contain a lambda"); + } + } else { + return try std.fmt.allocPrint(self.allocator, "main! is not a lambda as expected, got: {s}", .{@tagName(expr)}); + } + } else { + return try self.allocator.dupe(u8, "Could not find main! definition"); + } + } else blk: { + // Canonicalize just the expression (no past definitions) + const expr_idx: parse.AST.Expr.Idx = @enumFromInt(parse_ast.root_node_idx); + const result = czer.canonicalizeExpr(expr_idx) catch |err| { + return try std.fmt.allocPrint(self.allocator, "Canonicalize expr error: {}", .{err}); + } orelse { + return try self.allocator.dupe(u8, "Failed to canonicalize expression"); + }; + break :blk result.get_idx(); }; // Type check - var checker = Check.init(self.allocator, &module_env.types, cir, &.{}, &cir.store.regions) catch |err| { + var checker = Check.init(self.allocator, &module_env.types, cir, &.{}, &cir.store.regions, common_idents) catch |err| { return try std.fmt.allocPrint(self.allocator, "Type check init error: {}", .{err}); }; defer checker.deinit(); - _ = checker.checkExpr(canonical_expr_idx.get_idx()) catch |err| { - return try std.fmt.allocPrint(self.allocator, "Type check error: {}", .{err}); - }; + // If we have file-level defs, use checkFile to type-check everything + // Otherwise, just check the single expression + if (self.past_defs.items.len > 0 or def_ident != null) { + checker.checkFile() catch |err| { + return try std.fmt.allocPrint(self.allocator, "Type check error: {}", .{err}); + }; + } else { + _ = checker.checkExprRepl(canonical_expr_idx) catch |err| { + return try std.fmt.allocPrint(self.allocator, "Type check error: {}", .{err}); + }; + } // Create interpreter var interpreter = eval.Interpreter.init(self.allocator, cir) catch |err| { @@ -310,16 +480,70 @@ fn evaluatePureExpression(self: *Repl, expr_source: []const u8) ![]const u8 { }; defer interpreter.deinit(); + // If we have past definitions or a def_ident, we need to evaluate all the defs (except main!) + // to populate bindings for associated items + if (self.past_defs.items.len > 0 or def_ident != null) { + const defs_slice = cir.store.sliceDefs(czer.env.all_defs); + + // Evaluate all defs except main! and the current def (if there are past defs) + for (defs_slice) |def_idx| { + const def = cir.store.getDef(def_idx); + const pattern = cir.store.getPattern(def.pattern); + + // Skip main! since we extract its body separately + // Skip the current def ONLY if it's a NEW definition (not a redefinition) + if (pattern == .assign) { + const ident_idx = pattern.assign.ident; + const ident_text = cir.getIdent(ident_idx); + if (std.mem.eql(u8, ident_text, "main!")) { + continue; + } + // Skip the current def only if it's a NEW definition + if (self.past_defs.items.len > 0 and def_ident != null) { + if (std.mem.eql(u8, ident_text, def_ident.?)) { + // Check if this is a redefinition + var is_redefinition = false; + for (self.past_defs.items) |past_def| { + if (past_def.kind == .assignment) { + if (std.mem.eql(u8, past_def.kind.assignment, ident_text)) { + is_redefinition = true; + break; + } + } + } + // Only skip if it's a NEW definition + if (!is_redefinition) { + continue; + } + } + } + } + + // Evaluate the def's expression + const value = interpreter.evalMinimal(def.expr, self.roc_ops) catch |err| { + return try std.fmt.allocPrint(self.allocator, "Error evaluating definition: {}", .{err}); + }; + // Don't defer value.decref here because we're storing it in bindings + + // Create a binding for this pattern + try interpreter.bindings.append(.{ + .pattern_idx = def.pattern, + .value = value, + }); + } + } + // Evaluate the expression + // The full source has been built and canonicalized with all past_defs included // if (self.trace_writer) |trace_writer| { - // interpreter.startTrace(); + // interpreter.startTrace(trace_writer); // } if (self.crash_ctx) |ctx| { ctx.reset(); } - const result = interpreter.evalMinimal(canonical_expr_idx.get_idx(), self.roc_ops) catch |err| { + const result = interpreter.evalMinimal(canonical_expr_idx, self.roc_ops) catch |err| { // if (self.trace_writer) |_| { // interpreter.endTrace(); // } @@ -340,7 +564,7 @@ fn evaluatePureExpression(self: *Repl, expr_source: []const u8) ![]const u8 { // interpreter.endTrace(); // } - const expr_ct_var = can.ModuleEnv.varFrom(canonical_expr_idx.get_idx()); + const expr_ct_var = can.ModuleEnv.varFrom(canonical_expr_idx); const output = blk: { const expr_rt_var = interpreter.translateTypeVar(cir, expr_ct_var) catch { break :blk try interpreter.renderValueRoc(result); @@ -425,25 +649,25 @@ test "Repl - redefinition with evaluation" { defer std.testing.allocator.free(result1); try testing.expectEqualStrings("5", result1); - // Define y in terms of x (returns as context-aware evaluation is not yet implemented) + // Define y in terms of x (may hit NotImplemented in context-aware evaluation) const result2 = try repl.step("y = x + 1"); defer std.testing.allocator.free(result2); - try testing.expectEqualStrings("", result2); + try testing.expect(std.mem.indexOf(u8, result2, "error.NotImplemented") != null or std.mem.indexOf(u8, result2, "6") != null); // Redefine x const result3 = try repl.step("x = 6"); defer std.testing.allocator.free(result3); try testing.expectEqualStrings("6", result3); - // Evaluate x (returns as context-aware evaluation is not yet implemented) + // Evaluate x (may hit NotImplemented in context-aware evaluation) const result4 = try repl.step("x"); defer std.testing.allocator.free(result4); - try testing.expectEqualStrings("", result4); + try testing.expect(std.mem.indexOf(u8, result4, "error.NotImplemented") != null or std.mem.indexOf(u8, result4, "6") != null); - // Evaluate y (returns as context-aware evaluation is not yet implemented) + // Evaluate y (may hit NotImplemented in context-aware evaluation) const result5 = try repl.step("y"); defer std.testing.allocator.free(result5); - try testing.expectEqualStrings("", result5); + try testing.expect(std.mem.indexOf(u8, result5, "error.NotImplemented") != null or std.mem.indexOf(u8, result5, "6") != null); } test "Repl - build full source with redefinitions" { @@ -470,14 +694,14 @@ test "Repl - build full source with redefinitions" { }); // Build full source for evaluating y - const full_source = try repl.buildFullSource("y"); + const full_source = try repl.buildFullSource("y", null); defer std.testing.allocator.free(full_source); const expected = \\x = 5 \\y = x + 1 \\x = 6 - \\y + \\main! = |_| y ; try testing.expectEqualStrings(expected, full_source); } @@ -512,14 +736,14 @@ test "Repl - past def ordering" { try testing.expectEqualStrings("x = 3", repl.past_defs.items[2].source); // Build source shows all definitions - const full_source = try repl.buildFullSource("x"); + const full_source = try repl.buildFullSource("x", null); defer std.testing.allocator.free(full_source); const expected = \\x = 1 \\x = 2 \\x = 3 - \\x + \\main! = |_| x ; try testing.expectEqualStrings(expected, full_source); } @@ -532,6 +756,9 @@ test "Repl - minimal interpreter integration" { // Step 1: Create module environment const source = "42"; + var arena = std.heap.ArenaAllocator.init(gpa); + defer arena.deinit(); + var module_env = try ModuleEnv.init(gpa, source); defer module_env.deinit(); @@ -546,8 +773,14 @@ test "Repl - minimal interpreter integration" { const cir = &module_env; // CIR is now just ModuleEnv try cir.initCIRFields(gpa, "test"); + const module_common_idents: Check.CommonIdents = .{ + .module_name = try module_env.insertIdent(base.Ident.for_text("test")), + .list = try module_env.insertIdent(base.Ident.for_text("List")), + .box = try module_env.insertIdent(base.Ident.for_text("Box")), + }; + // Step 4: Canonicalize - var czer = try Can.init(cir, &parse_ast, null); + var czer = try Can.init(cir, &parse_ast, null, .{}); defer czer.deinit(); const expr_idx: parse.AST.Expr.Idx = @enumFromInt(parse_ast.root_node_idx); @@ -556,10 +789,10 @@ test "Repl - minimal interpreter integration" { }; // Step 5: Type check - var checker = try Check.init(gpa, &module_env.types, cir, &.{}, &cir.store.regions); + var checker = try Check.init(gpa, &module_env.types, cir, &.{}, &cir.store.regions, module_common_idents); defer checker.deinit(); - _ = try checker.checkExpr(canonical_expr_idx.get_idx()); + _ = try checker.checkExprRepl(canonical_expr_idx.get_idx()); // Step 6: Create interpreter var interpreter = try eval.Interpreter.init(gpa, cir); @@ -579,3 +812,75 @@ test "Repl - minimal interpreter integration" { try testing.expectEqual(@as(i128, 42), value); } + +test "Repl - type with associated value" { + var test_env = TestEnv.init(std.testing.allocator); + defer test_env.deinit(); + + var repl = try Repl.init(std.testing.allocator, test_env.get_ops(), test_env.crashContextPtr()); + defer repl.deinit(); + + // Define a type with an associated value + const result1 = try repl.step("Foo := [A, B].{ x = 5 }"); + defer std.testing.allocator.free(result1); + try testing.expectEqualStrings("Foo", result1); + + // Use the associated value + const result2 = try repl.step("Foo.x"); + defer std.testing.allocator.free(result2); +} + +test "Repl - nested type declaration" { + var test_env = TestEnv.init(std.testing.allocator); + defer test_env.deinit(); + + var repl = try Repl.init(std.testing.allocator, test_env.get_ops(), test_env.crashContextPtr()); + defer repl.deinit(); + + // Define a type with a nested type + const result1 = try repl.step("Foo := [Whatever].{ Bar := [X, Y, Z] }"); + defer std.testing.allocator.free(result1); + try testing.expectEqualStrings("Foo", result1); + + // Use a tag from the nested type + const result2 = try repl.step("Foo.Bar.X"); + defer std.testing.allocator.free(result2); +} + +test "Repl - associated value with type annotation" { + var test_env = TestEnv.init(std.testing.allocator); + defer test_env.deinit(); + + var repl = try Repl.init(std.testing.allocator, test_env.get_ops(), test_env.crashContextPtr()); + defer repl.deinit(); + + // Define a type with an associated value + const result1 = try repl.step("Foo := [A, B].{ defaultNum = 42 }"); + defer std.testing.allocator.free(result1); + try testing.expectEqualStrings("Foo", result1); + + // Define a value using the associated item + const result2 = try repl.step("x = Foo.defaultNum"); + defer std.testing.allocator.free(result2); +} + +test "Repl - nested type with tag constructor" { + var test_env = TestEnv.init(std.testing.allocator); + defer test_env.deinit(); + + var repl = try Repl.init(std.testing.allocator, test_env.get_ops(), test_env.crashContextPtr()); + defer repl.deinit(); + + // Define nested types + const result1 = try repl.step("Foo := [Whatever].{ Bar := [X, Y, Z] }"); + defer std.testing.allocator.free(result1); + try testing.expectEqualStrings("Foo", result1); + + // Create a value with type annotation + const result2 = try repl.step("x : Foo.Bar"); + defer std.testing.allocator.free(result2); + + // Assign the value + const result3 = try repl.step("x = Foo.Bar.X"); + defer std.testing.allocator.free(result3); +} diff --git a/src/repl/eval.zig b/src/repl/eval.zig index 7cb73d556a..f8dedc8478 100644 --- a/src/repl/eval.zig +++ b/src/repl/eval.zig @@ -86,6 +86,9 @@ pub const Repl = struct { // Allocate new ModuleEnv on heap const new_env = try self.allocator.create(ModuleEnv); + var arena = std.heap.ArenaAllocator.init(self.allocator); + defer arena.deinit(); + new_env.* = try ModuleEnv.init(self.allocator, source); self.last_module_env = new_env; return new_env; @@ -247,6 +250,9 @@ pub const Repl = struct { /// Try to parse input as a statement fn tryParseStatement(self: *Repl, input: []const u8) !ParseResult { + var arena = std.heap.ArenaAllocator.init(self.allocator); + defer arena.deinit(); + var module_env = try ModuleEnv.init(self.allocator, input); defer module_env.deinit(); @@ -362,9 +368,14 @@ pub const Repl = struct { // Create CIR const cir = module_env; // CIR is now just ModuleEnv try cir.initCIRFields(self.allocator, "repl"); + const module_common_idents: Check.CommonIdents = .{ + .module_name = try module_env.insertIdent(base.Ident.for_text("repl")), + .list = try module_env.insertIdent(base.Ident.for_text("List")), + .box = try module_env.insertIdent(base.Ident.for_text("Box")), + }; // Create canonicalizer - var czer = Can.init(cir, &parse_ast, null) catch |err| { + var czer = Can.init(cir, &parse_ast, null, .{}) catch |err| { return try std.fmt.allocPrint(self.allocator, "Canonicalize init error: {}", .{err}); }; defer czer.deinit(); @@ -378,13 +389,13 @@ pub const Repl = struct { const final_expr_idx = canonical_expr.get_idx(); // Type check - var checker = Check.init(self.allocator, &module_env.types, cir, &.{}, &cir.store.regions) catch |err| { + var checker = Check.init(self.allocator, &module_env.types, cir, &.{}, &cir.store.regions, module_common_idents) catch |err| { return try std.fmt.allocPrint(self.allocator, "Type check init error: {}", .{err}); }; defer checker.deinit(); // Check the expression (no need to check defs since we're parsing as expressions) - _ = checker.checkExpr(final_expr_idx) catch |err| { + _ = checker.checkExprRepl(final_expr_idx) catch |err| { return try std.fmt.allocPrint(self.allocator, "Type check expr error: {}", .{err}); }; diff --git a/src/repl/repl_test.zig b/src/repl/repl_test.zig index c2dd386b00..64fcc5db8c 100644 --- a/src/repl/repl_test.zig +++ b/src/repl/repl_test.zig @@ -2,6 +2,9 @@ const std = @import("std"); const can_mod = @import("can"); const check_mod = @import("check"); +const eval = @import("eval"); +const base = @import("base"); +const check = @import("check"); const parse = @import("parse"); const ModuleEnv = can_mod.ModuleEnv; const Canon = can_mod.Can; @@ -180,6 +183,9 @@ test "Repl - minimal interpreter integration" { // Step 1: Create module environment const source = "42"; + var arena = std.heap.ArenaAllocator.init(gpa); + defer arena.deinit(); + var module_env = try ModuleEnv.init(gpa, source); defer module_env.deinit(); @@ -193,9 +199,14 @@ test "Repl - minimal interpreter integration" { // Step 3: Create CIR const cir = &module_env; // CIR is now just ModuleEnv try cir.initCIRFields(gpa, "test"); + const common_idents: Check.CommonIdents = .{ + .module_name = try cir.insertIdent(base.Ident.for_text("test")), + .list = try cir.insertIdent(base.Ident.for_text("List")), + .box = try cir.insertIdent(base.Ident.for_text("Box")), + }; // Step 4: Canonicalize - var can = try Canon.init(cir, &parse_ast, null); + var can = try Canon.init(cir, &parse_ast, null, .{}); defer can.deinit(); const expr_idx: parse.AST.Expr.Idx = @enumFromInt(parse_ast.root_node_idx); @@ -204,10 +215,10 @@ test "Repl - minimal interpreter integration" { }; // Step 5: Type check - var checker = try Check.init(gpa, &module_env.types, cir, &.{}, &cir.store.regions); + var checker = try Check.init(gpa, &module_env.types, cir, &.{}, &cir.store.regions, common_idents); defer checker.deinit(); - _ = try checker.checkExpr(canonical_expr_idx.get_idx()); + _ = try checker.checkExprRepl(canonical_expr_idx.get_idx()); // Step 6: Create interpreter var interpreter = try Interpreter.init(gpa, &module_env); diff --git a/src/snapshot_tool/main.zig b/src/snapshot_tool/main.zig index a2188c5a7c..36fb48a572 100644 --- a/src/snapshot_tool/main.zig +++ b/src/snapshot_tool/main.zig @@ -19,6 +19,8 @@ const compile = @import("compile"); const fmt = @import("fmt"); const repl = @import("repl"); const eval_mod = @import("eval"); +const collections = @import("collections"); +const compiled_builtins = @import("compiled_builtins"); const Repl = repl.Repl; const CrashContext = eval_mod.CrashContext; @@ -644,6 +646,66 @@ fn extractSectionInfo(content: []const u8, section_name: []const u8) ?struct { s return .{ .start = start_idx, .end = next_section_idx }; } +/// Wrapper for a loaded compiled builtin module that tracks the buffer +const LoadedModule = struct { + env: *ModuleEnv, + buffer: []align(collections.CompactWriter.SERIALIZATION_ALIGNMENT) u8, + gpa: std.mem.Allocator, + + fn deinit(self: *LoadedModule) void { + // Only free the hashmap that was allocated during deserialization + // Most other data (like the SafeList contents) points into the buffer + self.env.imports.map.deinit(self.gpa); + + // Free the buffer (the env points into this buffer for most data) + self.gpa.free(self.buffer); + // Free the env struct itself + self.gpa.destroy(self.env); + } +}; + +/// Load a compiled ModuleEnv from embedded binary data +fn loadCompiledModule(gpa: std.mem.Allocator, bin_data: []const u8, module_name: []const u8, source: []const u8) !LoadedModule { + // Copy the embedded data to properly aligned memory + // CompactWriter requires specific alignment for serialization + const CompactWriter = collections.CompactWriter; + const buffer = try gpa.alignedAlloc(u8, CompactWriter.SERIALIZATION_ALIGNMENT, bin_data.len); + @memcpy(buffer, bin_data); + + // Cast to the serialized structure + const serialized_ptr = @as( + *ModuleEnv.Serialized, + @ptrCast(@alignCast(buffer.ptr)), + ); + + const env = try gpa.create(ModuleEnv); + errdefer gpa.destroy(env); + + // Deserialize + const base_ptr = @intFromPtr(buffer.ptr); + env.* = ModuleEnv{ + .gpa = gpa, + .common = serialized_ptr.common.deserialize(@as(i64, @intCast(base_ptr)), source).*, + .types = serialized_ptr.types.deserialize(@as(i64, @intCast(base_ptr)), gpa).*, + .module_kind = serialized_ptr.module_kind, + .all_defs = serialized_ptr.all_defs, + .all_statements = serialized_ptr.all_statements, + .exports = serialized_ptr.exports, + .builtin_statements = serialized_ptr.builtin_statements, + .external_decls = serialized_ptr.external_decls.deserialize(@as(i64, @intCast(base_ptr))).*, + .imports = serialized_ptr.imports.deserialize(@as(i64, @intCast(base_ptr)), gpa).*, + .module_name = module_name, + .diagnostics = serialized_ptr.diagnostics, + .store = serialized_ptr.store.deserialize(@as(i64, @intCast(base_ptr)), gpa).*, + }; + + return LoadedModule{ + .env = env, + .buffer = buffer, + .gpa = gpa, + }; +} + /// cli entrypoint for snapshot tool pub fn main() !void { // Use GeneralPurposeAllocator for command-line parsing and general work @@ -773,12 +835,23 @@ pub fn main() !void { } } + // Load compiled builtin modules (Set and Dict) + const dict_source = "Dict := [EmptyDict].{}\n"; + var dict_loaded = try loadCompiledModule(gpa, compiled_builtins.dict_bin, "Dict", dict_source); + defer dict_loaded.deinit(); + + const set_source = "import Dict\n\nSet := [EmptySet(Dict)].{}\n"; + var set_loaded = try loadCompiledModule(gpa, compiled_builtins.set_bin, "Set", set_source); + defer set_loaded.deinit(); + const config = Config{ .maybe_fuzz_corpus_path = maybe_fuzz_corpus_path, .generate_html = generate_html, .expected_section_command = expected_section_command, .output_section_command = output_section_command, .trace_eval = trace_eval, + .dict_module = dict_loaded.env, + .set_module = set_loaded.env, }; if (config.maybe_fuzz_corpus_path != null) { @@ -786,7 +859,6 @@ pub fn main() !void { try std.fs.cwd().makePath(config.maybe_fuzz_corpus_path.?); } const snapshots_dir = "test/snapshots"; - var timer = std.time.Timer.start() catch unreachable; // Stage 1: Collect work items var work_list = WorkList.init(gpa); @@ -807,19 +879,9 @@ pub fn main() !void { try collectWorkItems(gpa, snapshots_dir, &work_list); } - const collect_duration_ms = timer.read() / std.time.ns_per_ms; - log("collected {d} work items in {d} ms", .{ work_list.items.len, collect_duration_ms }); - // Stage 2: Process work items (in parallel or single-threaded) const result = try processWorkItems(gpa, work_list, max_threads, debug_mode, &config); - const duration_ms = timer.read() / std.time.ns_per_ms; - - std.log.debug( - "collected {d} items in {d} ms, processed {d} snapshots in {d} ms.", - .{ work_list.items.len, collect_duration_ms, result.success, duration_ms }, - ); - if (result.failed > 0) { std.log.err("Failed to process {d} snapshots.", .{result.failed}); std.process.exit(1); @@ -827,12 +889,23 @@ pub fn main() !void { } fn checkSnapshotExpectations(gpa: Allocator) !bool { + // Load compiled builtin modules (Set and Dict) + const dict_source = "Dict := [EmptyDict].{}\n"; + var dict_loaded = try loadCompiledModule(gpa, compiled_builtins.dict_bin, "Dict", dict_source); + defer dict_loaded.deinit(); + + const set_source = "import Dict\n\nSet := [EmptySet(Dict)].{}\n"; + var set_loaded = try loadCompiledModule(gpa, compiled_builtins.set_bin, "Set", set_source); + defer set_loaded.deinit(); + const config = Config{ .maybe_fuzz_corpus_path = null, .generate_html = false, .expected_section_command = .check, .output_section_command = .check, .disable_updates = true, + .dict_module = dict_loaded.env, + .set_module = set_loaded.env, }; const snapshots_dir = "test/snapshots"; var work_list = WorkList.init(gpa); @@ -1067,6 +1140,9 @@ fn processSnapshotContent( } // Process the content through the compilation pipeline + var arena = std.heap.ArenaAllocator.init(allocator); + defer arena.deinit(); + var module_env = try ModuleEnv.init(allocator, content.source); defer module_env.deinit(); @@ -1083,27 +1159,70 @@ fn processSnapshotContent( .platform => try parse.parse(&module_env.common, allocator), .app => try parse.parse(&module_env.common, allocator), .repl => unreachable, // Handled above + .snippet => try parse.parse(&module_env.common, allocator), }; defer parse_ast.deinit(allocator); parse_ast.store.emptyScratch(); - // Extract module name from output path - const basename = std.fs.path.basename(output_path); - const module_name = if (std.mem.lastIndexOfScalar(u8, basename, '.')) |dot_idx| - basename[0..dot_idx] - else - basename; + // Extract module name from custom filename if provided, otherwise from output path + const module_name = if (content.meta.filename) |custom_filename| + // Strip .roc extension if present + if (std.mem.lastIndexOfScalar(u8, custom_filename, '.')) |dot_idx| + custom_filename[0..dot_idx] + else + custom_filename + else blk: { + const basename = std.fs.path.basename(output_path); + break :blk if (std.mem.lastIndexOfScalar(u8, basename, '.')) |dot_idx| + basename[0..dot_idx] + else + basename; + }; var can_ir = &module_env; // ModuleEnv contains the canonical IR try can_ir.initCIRFields(allocator, module_name); - var czer = try Can.init(can_ir, &parse_ast, null); + const common_idents: Check.CommonIdents = .{ + .module_name = try can_ir.insertIdent(base.Ident.for_text(module_name)), + .list = try can_ir.insertIdent(base.Ident.for_text("List")), + .box = try can_ir.insertIdent(base.Ident.for_text("Box")), + }; + + // Auto-inject Set and Dict as available imports (if they're loaded) + // This makes them available without needing explicit `import` statements in tests + var module_envs = std.StringHashMap(*const ModuleEnv).init(allocator); + defer module_envs.deinit(); + + var dict_import_idx: ?CIR.Import.Idx = null; + var set_import_idx: ?CIR.Import.Idx = null; + + if (config.dict_module) |dict_env| { + dict_import_idx = try can_ir.imports.getOrPut(allocator, &can_ir.common.strings, "Dict"); + try module_envs.put("Dict", dict_env); + } + if (config.set_module) |set_env| { + set_import_idx = try can_ir.imports.getOrPut(allocator, &can_ir.common.strings, "Set"); + try module_envs.put("Set", set_env); + } + + var czer = try Can.init(can_ir, &parse_ast, &module_envs, .{}); defer czer.deinit(); + // Register auto-injected imports with the canonicalizer so it knows they're already imported + if (dict_import_idx) |idx| { + try czer.import_indices.put(allocator, "Dict", idx); + } + if (set_import_idx) |idx| { + try czer.import_indices.put(allocator, "Set", idx); + } + var maybe_expr_idx: ?Can.CanonicalizedExpr = null; switch (content.meta.node_type) { - .file => try czer.canonicalizeFile(), + .file => { + try czer.canonicalizeFile(); + try czer.validateForChecking(); + }, .header => { // TODO: implement canonicalize_header when available }, @@ -1113,39 +1232,45 @@ fn processSnapshotContent( }, .statement => { const ast_stmt_idx: AST.Statement.Idx = @enumFromInt(parse_ast.root_node_idx); - - var last_anno: ?Can.StmtTypeAnno = null; - const can_stmt_result = try czer.canonicalizeStatement(ast_stmt_idx, &last_anno); - switch (can_stmt_result) { - .import_stmt => { - // After we process import statements, there's no - // need to include then in the canonicalize IR - }, - .stmt => |can_stmt| { - // Manually track scratch statements because we aren't using the file entrypoint - const scratch_statements_start = can_ir.store.scratch_statements.top(); - try can_ir.store.addScratchStatement(can_stmt.idx); - can_ir.all_statements = try can_ir.store.statementSpanFrom(scratch_statements_start); - }, + const can_stmt_result = try czer.canonicalizeBlockStatement(czer.parse_ir.store.getStatement(ast_stmt_idx), &.{}, 0); + if (can_stmt_result.canonicalized_stmt) |can_stmt| { + // Manually track scratch statements because we aren't using the file entrypoint + const scratch_statements_start = can_ir.store.scratch.?.statements.top(); + try can_ir.store.addScratchStatement(can_stmt.idx); + can_ir.all_statements = try can_ir.store.statementSpanFrom(scratch_statements_start); } }, .package => try czer.canonicalizeFile(), .platform => try czer.canonicalizeFile(), .app => try czer.canonicalizeFile(), .repl => unreachable, // Handled above + .snippet => { + // Snippet - just canonicalize without validation + try czer.canonicalizeFile(); + }, } // Assert that everything is in-sync can_ir.debugAssertArraysInSync(); - // Types - const empty_modules: []const *ModuleEnv = &.{}; + // Types - include Set and Dict modules if loaded + var builtin_modules = std.array_list.Managed(*const ModuleEnv).init(allocator); + defer builtin_modules.deinit(); + + if (config.dict_module) |dict_env| { + try builtin_modules.append(dict_env); + } + if (config.set_module) |set_env| { + try builtin_modules.append(set_env); + } + var solver = try Check.init( allocator, &can_ir.types, can_ir, - empty_modules, + builtin_modules.items, &can_ir.store.regions, + common_idents, ); defer solver.deinit(); @@ -1153,9 +1278,9 @@ fn processSnapshotContent( solver.debugAssertArraysInSync(); if (maybe_expr_idx) |expr_idx| { - _ = try solver.checkExpr(expr_idx.idx); + _ = try solver.checkExprRepl(expr_idx.idx); } else { - try solver.checkDefs(); + try solver.checkFile(); } // Cache round-trip validation - ensure ModuleCache serialization/deserialization works @@ -1305,6 +1430,9 @@ const Config = struct { output_section_command: UpdateCommand, disable_updates: bool = false, // Disable updates for check mode trace_eval: bool = false, + // Compiled builtin modules (Set and Dict) loaded at startup + dict_module: ?*const ModuleEnv = null, + set_module: ?*const ModuleEnv = null, }; const ProcessResult = struct { @@ -1525,6 +1653,7 @@ pub const NodeType = enum { platform, app, repl, + snippet, pub const HEADER = "header"; pub const EXPR = "expr"; @@ -1534,6 +1663,7 @@ pub const NodeType = enum { pub const PLATFORM = "platform"; pub const APP = "app"; pub const REPL = "repl"; + pub const SNIPPET = "snippet"; fn fromString(str: []const u8) !NodeType { if (std.mem.eql(u8, str, HEADER)) return .header; @@ -1544,6 +1674,7 @@ pub const NodeType = enum { if (std.mem.eql(u8, str, PLATFORM)) return .platform; if (std.mem.eql(u8, str, APP)) return .app; if (std.mem.eql(u8, str, REPL)) return .repl; + if (std.mem.eql(u8, str, SNIPPET)) return .snippet; return Error.InvalidNodeType; } @@ -1557,6 +1688,7 @@ pub const NodeType = enum { .platform => "platform", .app => "app", .repl => "repl", + .snippet => "snippet", }; } }; @@ -1564,6 +1696,7 @@ pub const NodeType = enum { const Meta = struct { description: []const u8, node_type: NodeType, + filename: ?[]const u8 = null, const DESC_START: []const u8 = "description="; const TYPE_START: []const u8 = "type="; @@ -1572,19 +1705,27 @@ const Meta = struct { var lines = std.mem.splitScalar(u8, text, '\n'); var desc: []const u8 = ""; var node_type: NodeType = .file; + var filename: ?[]const u8 = null; while (true) { var line = lines.next() orelse break; if (std.mem.startsWith(u8, line, DESC_START)) { desc = line[(DESC_START.len)..]; } else if (std.mem.startsWith(u8, line, TYPE_START)) { const ty = line[(TYPE_START.len)..]; - node_type = try NodeType.fromString(ty); + // Check if there's a colon indicating a custom filename + if (std.mem.indexOfScalar(u8, ty, ':')) |colon_idx| { + node_type = try NodeType.fromString(ty[0..colon_idx]); + filename = ty[colon_idx + 1 ..]; + } else { + node_type = try NodeType.fromString(ty); + } } } return .{ .description = desc, .node_type = node_type, + .filename = filename, }; } @@ -1594,6 +1735,10 @@ const Meta = struct { try writer.writeAll("\n"); try writer.writeAll(TYPE_START); try writer.writeAll(self.node_type.toString()); + if (self.filename) |fname| { + try writer.writeAll(":"); + try writer.writeAll(fname); + } } test "Meta.fromString - only description" { @@ -2044,6 +2189,10 @@ fn generateParseSection(output: *DualOutput, content: *const Content, parse_ast: // REPL doesn't use parse trees return; }, + .snippet => { + const file = parse_ast.store.getFile(); + try file.pushToSExprTree(output.gpa, env, parse_ast, &tree); + }, } // Only generate section if we have content on the stack @@ -2107,6 +2256,9 @@ fn generateFormattedSection(output: *DualOutput, content: *const Content, parse_ // REPL doesn't use formatting return; }, + .snippet => { + try fmt.formatAst(parse_ast.*, formatted.writer().any()); + }, } const is_changed = !std.mem.eql(u8, formatted.written(), content.source); diff --git a/src/types/TypeWriter.zig b/src/types/TypeWriter.zig index ed7ad11200..5e5b282d99 100644 --- a/src/types/TypeWriter.zig +++ b/src/types/TypeWriter.zig @@ -57,6 +57,10 @@ buf: std.array_list.Managed(u8), seen: std.array_list.Managed(Var), next_name_index: u32, name_counters: std.EnumMap(TypeContext, u32), +flex_var_names_map: std.AutoHashMap(Var, FlexVarNameRange), +flex_var_names: std.array_list.Managed(u8), + +const FlexVarNameRange = struct { start: usize, end: usize }; /// Initialize a TypeWriter with immutable types and idents references. pub fn initFromParts(gpa: std.mem.Allocator, types_store: *const TypesStore, idents: *const Ident.Store) std.mem.Allocator.Error!TypeWriter { @@ -67,18 +71,28 @@ pub fn initFromParts(gpa: std.mem.Allocator, types_store: *const TypesStore, ide .seen = try std.array_list.Managed(Var).initCapacity(gpa, 16), .next_name_index = 0, .name_counters = std.EnumMap(TypeContext, u32).init(.{}), + .flex_var_names_map = std.AutoHashMap(Var, FlexVarNameRange).init(gpa), + .flex_var_names = try std.array_list.Managed(u8).initCapacity(gpa, 32), }; } pub fn deinit(self: *TypeWriter) void { self.buf.deinit(); self.seen.deinit(); + self.flex_var_names_map.deinit(); + self.flex_var_names.deinit(); +} + +/// Writes the current var into the the writers buffer and returns a bytes slice +pub fn writeGet(self: *TypeWriter, var_: Var) std.mem.Allocator.Error![]const u8 { + try self.write(var_); + return self.get(); } /// Returns the current contents of the type writer's buffer as a slice. /// This contains the formatted type representation built up by write operations. -pub fn get(self: *const TypeWriter) []u8 { - return self.buf.items[0..]; +pub fn get(self: *const TypeWriter) []const u8 { + return self.buf.items; } /// Writes a type variable to the buffer, formatting it as a human-readable string. @@ -120,9 +134,9 @@ fn generateNextName(self: *TypeWriter) !void { const exists = self.idents.interner.contains(candidate_name); if (!exists) { - // This name is available, write it to the buffer + // This name is available, use it for (candidate_name) |c| { - try self.buf.append(c); + try self.buf.writer().writeByte(c); } break; } @@ -231,92 +245,6 @@ fn hasSeenVar(self: *const TypeWriter, var_: Var) bool { return false; } -/// Count how many times a variable appears in a type -fn countVarOccurrences(self: *const TypeWriter, search_var: Var, root_var: Var) usize { - var count: usize = 0; - self.countVar(search_var, root_var, &count); - return count; -} - -fn countVar(self: *const TypeWriter, search_var: Var, current_var: Var, count: *usize) void { - if (current_var == search_var) { - count.* += 1; - } - - if (@intFromEnum(current_var) >= self.types.slots.backing.len()) return; - - const resolved = self.types.resolveVar(current_var); - switch (resolved.desc.content) { - .flex_var, .rigid_var, .err => {}, - .alias => |alias| { - // For aliases, we only count occurrences in the type arguments - var args_iter = self.types.iterAliasArgs(alias); - while (args_iter.next()) |arg_var| { - self.countVar(search_var, arg_var, count); - } - }, - .structure => |flat_type| { - self.countVarInFlatType(search_var, flat_type, count); - }, - } -} - -fn countVarInFlatType(self: *const TypeWriter, search_var: Var, flat_type: FlatType, count: *usize) void { - switch (flat_type) { - .str, .empty_record, .empty_tag_union => {}, - .box => |sub_var| self.countVar(search_var, sub_var, count), - .list => |sub_var| self.countVar(search_var, sub_var, count), - .list_unbound, .num => {}, - .tuple => |tuple| { - const elems = self.types.sliceVars(tuple.elems); - for (elems) |elem| { - self.countVar(search_var, elem, count); - } - }, - .nominal_type => |nominal_type| { - var args_iter = self.types.iterNominalArgs(nominal_type); - while (args_iter.next()) |arg_var| { - self.countVar(search_var, arg_var, count); - } - }, - .fn_pure, .fn_effectful, .fn_unbound => |func| { - const args = self.types.sliceVars(func.args); - for (args) |arg| { - self.countVar(search_var, arg, count); - } - self.countVar(search_var, func.ret, count); - }, - .record => |record| { - const fields = self.types.getRecordFieldsSlice(record.fields); - for (fields.items(.var_)) |field_var| { - self.countVar(search_var, field_var, count); - } - self.countVar(search_var, record.ext, count); - }, - .record_unbound => |fields| { - const fields_slice = self.types.getRecordFieldsSlice(fields); - for (fields_slice.items(.var_)) |field_var| { - self.countVar(search_var, field_var, count); - } - }, - .record_poly => |poly| { - self.countVarInFlatType(search_var, FlatType{ .record = poly.record }, count); - self.countVar(search_var, poly.var_, count); - }, - .tag_union => |tag_union| { - var iter = tag_union.tags.iterIndices(); - while (iter.next()) |tag_idx| { - const tag = self.types.tags.get(tag_idx); - const args = self.types.sliceVars(tag.args); - for (args) |arg_var| { - self.countVar(search_var, arg_var, count); - } - } - self.countVar(search_var, tag_union.ext, count); - }, - } -} - /// Convert a var to a type string fn writeVarWithContext(self: *TypeWriter, var_: Var, context: TypeContext, root_var: Var) std.mem.Allocator.Error!void { if (@intFromEnum(var_) >= self.types.slots.backing.len()) { @@ -324,27 +252,23 @@ fn writeVarWithContext(self: *TypeWriter, var_: Var, context: TypeContext, root_ _ = try self.buf.writer().write("invalid_type"); } else { const resolved = self.types.resolveVar(var_); - if (self.hasSeenVar(var_)) { + if (self.hasSeenVar(resolved.var_)) { _ = try self.buf.writer().write("..."); } else { try self.seen.append(var_); defer _ = self.seen.pop(); switch (resolved.desc.content) { - .flex_var => |mb_ident_idx| { - if (mb_ident_idx) |ident_idx| { + .flex => |flex| { + if (flex.name) |ident_idx| { _ = try self.buf.writer().write(self.getIdent(ident_idx)); } else { - // Check if this variable appears multiple times - const occurrences = self.countVarOccurrences(var_, root_var); - if (occurrences == 1) { - _ = try self.buf.writer().write("_"); - } - try self.generateContextualName(context); + try self.writeFlexVarName(var_, context, root_var); } }, - .rigid_var => |ident_idx| { - _ = try self.buf.writer().write(self.getIdent(ident_idx)); + .rigid => |rigid| { + _ = try self.buf.writer().write(self.getIdent(rigid.name)); + // Useful in debugging to see if a var is rigid or not // _ = try self.buf.writer().write("[r]"); }, .alias => |alias| { @@ -431,10 +355,6 @@ fn writeFlatType(self: *TypeWriter, flat_type: FlatType, root_var: Var) std.mem. .record_unbound => |fields| { try self.writeRecordFields(fields, root_var); }, - .record_poly => |poly| { - try self.writeRecord(poly.record, root_var); - try self.writeVar(poly.var_, root_var); - }, .empty_record => { _ = try self.buf.writer().write("{}"); }, @@ -561,19 +481,19 @@ fn writeRecord(self: *TypeWriter, record: Record, root_var: Var) std.mem.Allocat try self.writeVarWithContext(record.ext, .RecordExtension, root_var); }, }, - .flex_var => |mb_ident| { + .flex => |flex| { // Only show flex vars if they have a name - if (mb_ident) |_| { + if (flex.name) |_| { if (fields.len > 0) _ = try self.buf.writer().write(", "); try self.writeVarWithContext(record.ext, .RecordExtension, root_var); } // Otherwise hide unnamed flex vars, so they render as no extension. }, - .rigid_var => |ident_idx| { + .rigid => |rigid| { // Show rigid vars with .. syntax if (fields.len > 0) _ = try self.buf.writer().write(", "); _ = try self.buf.writer().write(".."); - _ = try self.buf.writer().write(self.getIdent(ident_idx)); + _ = try self.buf.writer().write(self.getIdent(rigid.name)); }, else => { if (fields.len > 0) _ = try self.buf.writer().write(", "); @@ -607,19 +527,19 @@ fn writeRecordExtension(self: *TypeWriter, ext_var: Var, num_fields: usize, root try self.writeVarWithContext(ext_var, .RecordExtension, root_var); }, }, - .flex_var => |mb_ident| { + .flex => |flex| { // Only show flex vars if they have a name - if (mb_ident) |_| { + if (flex.name) |_| { if (num_fields > 0) _ = try self.buf.writer().write(", "); try self.writeVarWithContext(ext_var, .RecordExtension, root_var); } // Otherwise hide unnamed flex vars, so they render as no extension. }, - .rigid_var => |ident_idx| { + .rigid => |rigid| { // Show rigid vars with .. syntax if (num_fields > 0) _ = try self.buf.writer().write(", "); _ = try self.buf.writer().write(".."); - _ = try self.buf.writer().write(self.getIdent(ident_idx)); + _ = try self.buf.writer().write(self.getIdent(rigid.name)); }, else => { // Show other types (aliases, errors, etc) @@ -647,16 +567,11 @@ fn writeTagUnion(self: *TypeWriter, tag_union: TagUnion, root_var: Var) std.mem. // Show extension variable if it's not empty const ext_resolved = self.types.resolveVar(tag_union.ext); switch (ext_resolved.desc.content) { - .flex_var => |mb_ident_idx| { - if (mb_ident_idx) |ident_idx| { + .flex => |flex| { + if (flex.name) |ident_idx| { _ = try self.buf.writer().write(self.getIdent(ident_idx)); } else { - // Check if this variable appears multiple times - const occurrences = self.countVarOccurrences(tag_union.ext, root_var); - if (occurrences == 1) { - _ = try self.buf.writer().write("_"); - } - try self.generateContextualName(.TagUnionExtension); + try self.writeFlexVarName(tag_union.ext, .TagUnionExtension, root_var); } }, .structure => |flat_type| switch (flat_type) { @@ -665,8 +580,9 @@ fn writeTagUnion(self: *TypeWriter, tag_union: TagUnion, root_var: Var) std.mem. try self.writeVarWithContext(tag_union.ext, .TagUnionExtension, root_var); }, }, - .rigid_var => |ident_idx| { - _ = try self.buf.writer().write(self.getIdent(ident_idx)); + .rigid => |rigid| { + _ = try self.buf.writer().write(self.getIdent(rigid.name)); + // _ = try self.buf.writer().write("[r]"); }, else => { try self.writeVarWithContext(tag_union.ext, .TagUnionExtension, root_var); @@ -691,19 +607,19 @@ fn writeTag(self: *TypeWriter, tag: Tag, root_var: Var) std.mem.Allocator.Error! /// Convert a num type to a type string fn writeNum(self: *TypeWriter, num: Num, root_var: Var) std.mem.Allocator.Error!void { switch (num) { - .num_poly => |poly| { + .num_poly => |poly_var| { _ = try self.buf.writer().write("Num("); - try self.writeVarWithContext(poly.var_, .NumContent, root_var); + try self.writeVarWithContext(poly_var, .NumContent, root_var); _ = try self.buf.writer().write(")"); }, .int_poly => |poly| { _ = try self.buf.writer().write("Int("); - try self.writeVarWithContext(poly.var_, .NumContent, root_var); + try self.writeVarWithContext(poly, .NumContent, root_var); _ = try self.buf.writer().write(")"); }, .frac_poly => |poly| { _ = try self.buf.writer().write("Frac("); - try self.writeVarWithContext(poly.var_, .NumContent, root_var); + try self.writeVarWithContext(poly, .NumContent, root_var); _ = try self.buf.writer().write(")"); }, .num_unbound => |_| { @@ -722,45 +638,195 @@ fn writeNum(self: *TypeWriter, num: Num, root_var: Var) std.mem.Allocator.Error! _ = try self.buf.writer().write(")"); }, .int_precision => |prec| { - try self.writeIntType(prec); + try self.writeIntType(prec, .precision); }, .frac_precision => |prec| { - try self.writeFracType(prec); + try self.writeFracType(prec, .precision); }, .num_compact => |compact| { switch (compact) { .int => |prec| { - try self.writeIntType(prec); + try self.writeIntType(prec, .compacted); }, .frac => |prec| { - try self.writeFracType(prec); + try self.writeFracType(prec, .compacted); }, } }, } } -fn writeIntType(self: *TypeWriter, prec: Num.Int.Precision) std.mem.Allocator.Error!void { - _ = switch (prec) { - .u8 => try self.buf.writer().write("U8"), - .i8 => try self.buf.writer().write("I8"), - .u16 => try self.buf.writer().write("U16"), - .i16 => try self.buf.writer().write("I16"), - .u32 => try self.buf.writer().write("U32"), - .i32 => try self.buf.writer().write("I32"), - .u64 => try self.buf.writer().write("U64"), - .i64 => try self.buf.writer().write("I64"), - .u128 => try self.buf.writer().write("U128"), - .i128 => try self.buf.writer().write("I128"), - }; +const NumPrecType = enum { precision, compacted }; + +fn writeIntType(self: *TypeWriter, prec: Num.Int.Precision, num_type: NumPrecType) std.mem.Allocator.Error!void { + switch (num_type) { + .compacted => { + _ = switch (prec) { + .u8 => try self.buf.writer().write("Num(Int(Unsigned8))"), + .i8 => try self.buf.writer().write("Num(Int(Signed8))"), + .u16 => try self.buf.writer().write("Num(Int(Unsigned16))"), + .i16 => try self.buf.writer().write("Num(Int(Signed16))"), + .u32 => try self.buf.writer().write("Num(Int(Unsigned32))"), + .i32 => try self.buf.writer().write("Num(Int(Signed32))"), + .u64 => try self.buf.writer().write("Num(Int(Unsigned64))"), + .i64 => try self.buf.writer().write("Num(Int(Signed64))"), + .u128 => try self.buf.writer().write("Num(Int(Unsigned128))"), + .i128 => try self.buf.writer().write("Num(Int(Signed128))"), + }; + }, + .precision => { + _ = switch (prec) { + .u8 => try self.buf.writer().write("Unsigned8"), + .i8 => try self.buf.writer().write("Signed8"), + .u16 => try self.buf.writer().write("Unsigned16"), + .i16 => try self.buf.writer().write("Signed16"), + .u32 => try self.buf.writer().write("Unsigned32"), + .i32 => try self.buf.writer().write("Signed32"), + .u64 => try self.buf.writer().write("Unsigned64"), + .i64 => try self.buf.writer().write("Signed64"), + .u128 => try self.buf.writer().write("Unsigned128"), + .i128 => try self.buf.writer().write("Signed128"), + }; + }, + } } -fn writeFracType(self: *TypeWriter, prec: Num.Frac.Precision) std.mem.Allocator.Error!void { - _ = switch (prec) { - .f32 => try self.buf.writer().write("F32"), - .f64 => try self.buf.writer().write("F64"), - .dec => try self.buf.writer().write("Dec"), - }; +fn writeFracType(self: *TypeWriter, prec: Num.Frac.Precision, num_type: NumPrecType) std.mem.Allocator.Error!void { + switch (num_type) { + .compacted => { + _ = switch (prec) { + .f32 => try self.buf.writer().write("Num(Frac(Float32))"), + .f64 => try self.buf.writer().write("Num(Frac(Float64))"), + .dec => try self.buf.writer().write("Num(Frac(Decimal))"), + }; + }, + .precision => { + _ = switch (prec) { + .f32 => try self.buf.writer().write("Float32"), + .f64 => try self.buf.writer().write("Float64"), + .dec => try self.buf.writer().write("Decimal"), + }; + }, + } +} + +/// Generate a name for a flex var that may appear multiple times in the type +pub fn writeFlexVarName(self: *TypeWriter, var_: Var, context: TypeContext, root_var: Var) std.mem.Allocator.Error!void { + const resolved_var = self.types.resolveVar(var_).var_; + + // Check if we've seen this flex var before. + if (self.flex_var_names_map.get(resolved_var)) |range| { + // If so, then use that name + _ = try self.buf.writer().write( + self.flex_var_names.items[range.start..range.end], + ); + } else { + // Check if this variable appears multiple times + const occurrences = self.countVarOccurrences(resolved_var, root_var); + if (occurrences == 1) { + // If it appears once, then generate and write the name + _ = try self.buf.writer().write("_"); + try self.generateContextualName(context); + } else { + // If it appears more than once, then we have to track the name we + // assign it so it appears consistently across the type str + + // Generate a new general var name. We do not use the context here + // because that may be the current context the var appears in, but + // the var may later appear in a different context + const buf_start = self.buf.items.len; + try self.generateContextualName(.General); + const buf_end = self.buf.items.len; + + // Then write down the name we generated for later + const flex_start = self.flex_var_names.items.len; + try self.flex_var_names.appendSlice(self.buf.items[buf_start..buf_end]); + const flex_end = self.flex_var_names.items.len; + try self.flex_var_names_map.put(resolved_var, .{ .start = flex_start, .end = flex_end }); + } + } +} + +/// Count how many times a variable appears in a type +fn countVarOccurrences(self: *const TypeWriter, search_var: Var, root_var: Var) usize { + var count: usize = 0; + self.countVar(search_var, root_var, &count); + return count; +} + +fn countVar(self: *const TypeWriter, search_var: Var, current_var: Var, count: *usize) void { + if (@intFromEnum(current_var) >= self.types.slots.backing.len()) return; + + const resolved = self.types.resolveVar(current_var); + if (resolved.var_ == search_var) { + count.* += 1; + } + + switch (resolved.desc.content) { + .flex, .rigid, .err => {}, + .alias => |alias| { + // For aliases, we only count occurrences in the type arguments + var args_iter = self.types.iterAliasArgs(alias); + while (args_iter.next()) |arg_var| { + self.countVar(search_var, arg_var, count); + } + }, + .structure => |flat_type| { + self.countVarInFlatType(search_var, flat_type, count); + }, + } +} + +fn countVarInFlatType(self: *const TypeWriter, search_var: Var, flat_type: FlatType, count: *usize) void { + switch (flat_type) { + .str, .empty_record, .empty_tag_union => {}, + .box => |sub_var| self.countVar(search_var, sub_var, count), + .list => |sub_var| self.countVar(search_var, sub_var, count), + .list_unbound, .num => {}, + .tuple => |tuple| { + const elems = self.types.sliceVars(tuple.elems); + for (elems) |elem| { + self.countVar(search_var, elem, count); + } + }, + .nominal_type => |nominal_type| { + var args_iter = self.types.iterNominalArgs(nominal_type); + while (args_iter.next()) |arg_var| { + self.countVar(search_var, arg_var, count); + } + }, + .fn_pure, .fn_effectful, .fn_unbound => |func| { + const args = self.types.sliceVars(func.args); + for (args) |arg| { + self.countVar(search_var, arg, count); + } + self.countVar(search_var, func.ret, count); + }, + .record => |record| { + const fields = self.types.getRecordFieldsSlice(record.fields); + for (fields.items(.var_)) |field_var| { + self.countVar(search_var, field_var, count); + } + self.countVar(search_var, record.ext, count); + }, + .record_unbound => |fields| { + const fields_slice = self.types.getRecordFieldsSlice(fields); + for (fields_slice.items(.var_)) |field_var| { + self.countVar(search_var, field_var, count); + } + }, + .tag_union => |tag_union| { + var iter = tag_union.tags.iterIndices(); + while (iter.next()) |tag_idx| { + const tag = self.types.tags.get(tag_idx); + const args = self.types.sliceVars(tag.args); + for (args) |arg_var| { + self.countVar(search_var, arg_var, count); + } + } + self.countVar(search_var, tag_union.ext, count); + }, + } } /// Retrieves the text representation of an identifier by its index. diff --git a/src/types/generalize.zig b/src/types/generalize.zig new file mode 100644 index 0000000000..f4a8a0c2c4 --- /dev/null +++ b/src/types/generalize.zig @@ -0,0 +1,267 @@ +//! Type instantiation for Hindley-Milner type inference. +//! +//! This module provides functionality to instantiate polymorphic types with fresh +//! type variables while preserving type aliases and structure. This is a critical +//! component for proper handling of annotated functions in the type system. + +const std = @import("std"); +const base = @import("base"); +const collections = @import("collections"); + +const TypesStore = @import("store.zig").Store; +const Var = @import("types.zig").Var; +const Content = @import("types.zig").Content; +const FlatType = @import("types.zig").FlatType; +const Alias = @import("types.zig").Alias; +const Func = @import("types.zig").Func; +const Record = @import("types.zig").Record; +const TagUnion = @import("types.zig").TagUnion; +const RecordField = @import("types.zig").RecordField; +const Tag = @import("types.zig").Tag; +const Num = @import("types.zig").Num; +const NominalType = @import("types.zig").NominalType; +const Tuple = @import("types.zig").Tuple; +const Rank = @import("types.zig").Rank; +const Ident = base.Ident; + +/// Type to manage instantiation. +/// +/// Entry point is `instantiateVar` +/// +/// This type does not own any of it's fields – it's a convenience wrapper to +/// making threading it's field through all the recursive functions easier +pub const Generalizer = struct { + // not owned + store: *TypesStore, + rank_adjusted_vars: std.AutoHashMap(Var, void), + + const Self = @This(); + + // general // + + pub fn init(gpa: std.mem.Allocator, store: *TypesStore) std.mem.Allocator.Error!Self { + return .{ + .store = store, + .rank_adjusted_vars = std.AutoHashMap(Var, void).init(gpa), + }; + } + + /// Reset the state of the generalizer + pub fn reset(self: *Self) void { + self.rank_adjusted_vars.clearRetainingCapacity(); + } + + pub fn deinit(self: *Self) void { + self.rank_adjusted_vars.deinit(); + } + + // generalize // + + /// Adjust the rank of a type such that the rank never increase as you move deeper + /// This way, the outermost rank is representative of of the entire structure + pub fn generalize(self: *Self, var_pool: *VarPool, rank_to_generalize: Rank) std.mem.Allocator.Error!void { + // std.debug.assert(var_pool.current_rank == rank_to_generalize); + + // First, reset internal state + self.reset(); + + // Get vars at the current rank to generalize + const vars_to_generalize = var_pool.getVarsForRank(rank_to_generalize); + + // First, adjust the rank_var's rank is representative of it's entire structure + // + // Note that this has to be done it it's own pass so all ranks are + // adjusted _before_ we generalize + for (vars_to_generalize) |rank_var| { + _ = try self.adjustRank(rank_var, rank_to_generalize); + } + + // Iterate over all the variables at the rank we're trying to generalize + for (vars_to_generalize) |rank_var| { + // Only process non-redundant vars + if (!self.store.isRedirect(rank_var)) { + const resolved = self.store.resolveVar(rank_var); + if (@intFromEnum(resolved.desc.rank) < @intFromEnum(rank_to_generalize)) { + // If this var is less than the current rank (meaning it + // escaped it's scope), move it to the correct pool + try var_pool.addVarToRank(resolved.var_, resolved.desc.rank); + } else { + // Otherwise, generalize it + self.store.setDescRank(resolved.desc_idx, Rank.generalized); + } + } + } + } + + // adjust rank // + + /// Adjust the rank of a type such that the rank never increase as you move deeper + /// This way, the outermost rank is representative of of the entire structure + fn adjustRank(self: *Self, var_: Var, group_rank: Rank) std.mem.Allocator.Error!Rank { + // Resolve the var + const resolved = self.store.resolveVar(var_); + + if (self.rank_adjusted_vars.contains(resolved.var_)) { + return group_rank; + } else { + + // Add the resolved var to the list of seen vars immediately, in case + // this is a recursive type + _ = try self.rank_adjusted_vars.put(resolved.var_, {}); + + // Get the max rank of this vars + const max_rank = try self.adjustRankContent(resolved.desc.content, group_rank); + + // Set the rank + self.store.setDescRank(resolved.desc_idx, max_rank); + + return max_rank; + } + } + + fn adjustRankContent(self: *Self, content: Content, group_rank: Rank) std.mem.Allocator.Error!Rank { + return switch (content) { + .flex, .rigid, .err => return group_rank, + .alias => |alias| { + var next_rank = group_rank; + var args_iter = self.store.iterAliasArgs(alias); + while (args_iter.next()) |arg_var| { + next_rank = next_rank.max(try self.adjustRank(arg_var, next_rank)); + } + next_rank = next_rank.max(try self.adjustRank(self.store.getAliasBackingVar(alias), next_rank)); + return next_rank; + }, + .structure => |flat_type| { + switch (flat_type) { + .str, .empty_record, .empty_tag_union, .list_unbound => return group_rank, + .box => |inner_var| { + return group_rank.max(try self.adjustRank(inner_var, group_rank)); + }, + .list => |inner_var| { + return group_rank.max(try self.adjustRank(inner_var, group_rank)); + }, + .tuple => |tuple| { + var next_rank = group_rank; + for (self.store.sliceVars(tuple.elems)) |arg_var| { + next_rank = next_rank.max(try self.adjustRank(arg_var, next_rank)); + } + return next_rank; + }, + .num => return group_rank, + .nominal_type => |nominal| { + var next_rank = group_rank; + var args_iter = self.store.iterNominalArgs(nominal); + while (args_iter.next()) |arg_var| { + next_rank = next_rank.max(try self.adjustRank(arg_var, next_rank)); + } + next_rank = next_rank.max(try self.adjustRank(self.store.getNominalBackingVar(nominal), next_rank)); + return next_rank; + }, + .fn_pure => |func| { + var next_rank = group_rank; + for (self.store.sliceVars(func.args)) |arg_var| { + next_rank = next_rank.max(try self.adjustRank(arg_var, next_rank)); + } + next_rank = next_rank.max(try self.adjustRank(func.ret, next_rank)); + return next_rank; + }, + .fn_effectful => |func| { + var next_rank = group_rank; + for (self.store.sliceVars(func.args)) |arg_var| { + next_rank = next_rank.max(try self.adjustRank(arg_var, next_rank)); + } + next_rank = next_rank.max(try self.adjustRank(func.ret, next_rank)); + return next_rank; + }, + .fn_unbound => |func| { + var next_rank = group_rank; + for (self.store.sliceVars(func.args)) |arg_var| { + next_rank = next_rank.max(try self.adjustRank(arg_var, next_rank)); + } + next_rank = next_rank.max(try self.adjustRank(func.ret, next_rank)); + return next_rank; + }, + .record => |record| { + var next_rank = group_rank; + for (self.store.getRecordFieldsSlice(record.fields).items(.var_)) |rec_var| { + next_rank = next_rank.max(try self.adjustRank(rec_var, next_rank)); + } + next_rank = next_rank.max(try self.adjustRank(record.ext, next_rank)); + return next_rank; + }, + .record_unbound => |record_fields| { + var next_rank = group_rank; + for (self.store.getRecordFieldsSlice(record_fields).items(.var_)) |rec_var| { + next_rank = next_rank.max(try self.adjustRank(rec_var, next_rank)); + } + return next_rank; + }, + .tag_union => |tag_union| { + var next_rank = group_rank; + for (self.store.getTagsSlice(tag_union.tags).items(.args)) |arg_range| { + for (self.store.sliceVars(arg_range)) |tag_arg_var| { + next_rank = next_rank.max(try self.adjustRank(tag_arg_var, next_rank)); + } + } + return next_rank; + }, + } + }, + }; + } +}; + +const VarArrayList = std.array_list.Managed(Var); + +/// A pool of variables grouped by rank, use to manage & generalize variables +/// introduced during unification +pub const VarPool = struct { + const Self = @This(); + + ranks: std.array_list.Managed(VarArrayList), + current_rank: Rank, + allocator: std.mem.Allocator, + + pub fn init(allocator: std.mem.Allocator) std.mem.Allocator.Error!Self { + var ranks = try std.array_list.Managed(VarArrayList).initCapacity(allocator, 16); + for (0..16) |_| { + ranks.appendAssumeCapacity(try VarArrayList.initCapacity(allocator, 16)); + } + return Self{ + .ranks = ranks, + .current_rank = Rank.generalized, + .allocator = allocator, + }; + } + + pub fn deinit(self: *Self) void { + for (self.ranks.items) |*rank| { + rank.deinit(); + } + self.ranks.deinit(); + } + + pub fn pushRank(self: *Self) std.mem.Allocator.Error!void { + self.current_rank = self.current_rank.next(); + if (@intFromEnum(self.current_rank) >= self.ranks.items.len) { + try self.ranks.append(try VarArrayList.initCapacity(self.allocator, 16)); + } + } + + pub fn popRank(self: *Self) void { + if (@intFromEnum(self.current_rank) > 0) { + self.ranks.items[@intFromEnum(self.current_rank)].clearRetainingCapacity(); + self.current_rank = self.current_rank.prev(); + } + } + + pub fn addVarToRank(self: *Self, variable: Var, rank: Rank) !void { + std.debug.assert(@intFromEnum(rank) <= @intFromEnum(self.current_rank)); + try self.ranks.items[@intFromEnum(rank)].append(variable); + } + + pub fn getVarsForRank(self: *Self, rank: Rank) []Var { + std.debug.assert(@intFromEnum(rank) <= @intFromEnum(self.current_rank)); + return self.ranks.items[@intFromEnum(rank)].items; + } +}; diff --git a/src/types/instantiate.zig b/src/types/instantiate.zig index 958a9c64ed..d28e5e1807 100644 --- a/src/types/instantiate.zig +++ b/src/types/instantiate.zig @@ -10,6 +10,7 @@ const collections = @import("collections"); const TypesStore = @import("store.zig").Store; const Var = @import("types.zig").Var; +const Flex = @import("types.zig").Flex; const Content = @import("types.zig").Content; const FlatType = @import("types.zig").FlatType; const Alias = @import("types.zig").Alias; @@ -22,6 +23,7 @@ const Num = @import("types.zig").Num; const NominalType = @import("types.zig").NominalType; const Tuple = @import("types.zig").Tuple; const Rank = @import("types.zig").Rank; +const Mark = @import("types.zig").Mark; const Ident = base.Ident; /// Type to manage instantiation. @@ -30,194 +32,188 @@ const Ident = base.Ident; /// /// This type does not own any of it's fields – it's a convenience wrapper to /// making threading it's field through all the recursive functions easier -pub const Instantiate = struct { +pub const Instantiator = struct { // not owned store: *TypesStore, idents: *const base.Ident.Store, - seen_vars_subs: *SeenVars, + var_map: *std.AutoHashMap(Var, Var), + + current_rank: Rank = Rank.top_level, + rigid_behavior: RigidBehavior, + + /// The mode to use when instantiating + pub const RigidBehavior = union(enum) { + /// In this mode, all rigids are instantiated as new flex vars + /// Note that the the rigid var structure will be preserved. + /// E.g. `a -> a`, `a` will reference the same new rigid var + fresh_flex, + + /// In this mode, all rigids are instantiated as new rigid variables + /// Note that the the rigid var structure will be preserved. + /// E.g. `a -> a`, `a` will reference the same new flex var + fresh_rigid, + + /// In this mode, all rigids we be substituted with values in the provided map. + /// If a rigid var is not in the map, then that variable will be set to + /// `.err` & in debug mode it will error + substitute_rigids: *std.AutoHashMapUnmanaged(Ident.Idx, Var), + }; const Self = @This(); - pub const IdentVar = struct { ident: []const u8, var_: Var }; - pub const RigidToFlexSubs = base.Scratch(IdentVar); - - pub const SeenVars = std.AutoHashMap(Var, Var); - - // general // - - pub fn init( - store: *TypesStore, - idents: *const base.Ident.Store, - seen_vars_subs: *SeenVars, - ) Self { - return .{ - .store = store, - .idents = idents, - .seen_vars_subs = seen_vars_subs, - }; - } - // rigid vars // - - /// Check if, for the provided rigid var ident, we have a variable to substitute - fn getRigidVarSub(rigid_vars_subs: *RigidToFlexSubs, ident: []const u8) ?Var { - for (rigid_vars_subs.items.items) |elem| { - if (std.mem.eql(u8, ident, elem.ident)) { - return elem.var_; - } - } - return null; - } - - // instantiation // - - pub const Ctx = struct { - rigid_var_subs: *RigidToFlexSubs, - current_rank: Rank = Rank.top_level, - }; - // instantiation // /// Instantiate a variable - /// - /// The caller provides a map that's used to substitute rigid variables, - /// as depending on the context this map should contain vars from an - /// annotation, or not - pub fn instantiateVar(self: *Self, initial_var: Var, ctx: *Ctx) std.mem.Allocator.Error!Var { + pub fn instantiateVar( + self: *Self, + initial_var: Var, + ) std.mem.Allocator.Error!Var { const resolved = self.store.resolveVar(initial_var); const resolved_var = resolved.var_; // Check if we've already instantiated this variable - if (self.seen_vars_subs.get(resolved_var)) |fresh_var| { + if (self.var_map.get(resolved_var)) |fresh_var| { return fresh_var; } switch (resolved.desc.content) { - .rigid_var => |ident| { - // Get the ident of the rigid var - const ident_bytes = self.getIdent(ident); - - if (Self.getRigidVarSub(ctx.rigid_var_subs, ident_bytes)) |existing_flex_var| { - try self.seen_vars_subs.put(resolved_var, existing_flex_var); - return existing_flex_var; - } else { - // Create a new flex variable for this rigid variable name - const fresh_var = try self.store.freshFromContentWithRank(Content{ .flex_var = ident }, ctx.current_rank); - try ctx.rigid_var_subs.append(self.store.gpa, .{ .ident = ident_bytes, .var_ = fresh_var }); - - // Remember this substitution for recursive references - try self.seen_vars_subs.put(resolved_var, fresh_var); - - return fresh_var; - } - }, - else => { - const fresh_content = try self.instantiateContent(resolved.desc.content, ctx); - - // Create a fresh variable with the instantiated content - const fresh_var = try self.store.freshFromContentWithRank(fresh_content, ctx.current_rank); + .rigid => |rigid| { + // If this var is rigid, then create a new var depending on the + // provided behavior + const fresh_var = blk: { + switch (self.rigid_behavior) { + .fresh_rigid => { + break :blk try self.store.freshFromContentWithRank( + Content{ .rigid = rigid }, + self.current_rank, + ); + }, + .fresh_flex => { + break :blk try self.store.freshFromContentWithRank( + Content{ .flex = Flex.init().withName(rigid.name) }, + self.current_rank, + ); + }, + .substitute_rigids => |rigid_subs| { + if (rigid_subs.get(rigid.name)) |existing_flex| { + break :blk existing_flex; + } else { + std.debug.assert(false); + break :blk try self.store.freshFromContentWithRank( + .err, + self.current_rank, + ); + } + }, + } + }; // Remember this substitution for recursive references - try self.seen_vars_subs.put(resolved_var, fresh_var); + try self.var_map.put(resolved_var, fresh_var); + + return fresh_var; + }, + else => { + // Remember this substitution for recursive references + // IMPORTANT: This has to be inserted _before_ we recurse into `instantiateContent` + const fresh_var = try self.store.fresh(); + try self.var_map.put(resolved_var, fresh_var); + + // Generate the content + const fresh_content = try self.instantiateContent(resolved.desc.content); + + // Update the placeholder fresh var with the real content + try self.store.setVarDesc( + fresh_var, + .{ + .content = fresh_content, + .rank = self.current_rank, + .mark = Mark.none, + }, + ); return fresh_var; }, } } - fn instantiateContent(self: *Self, content: Content, ctx: *Ctx) std.mem.Allocator.Error!Content { + fn instantiateContent(self: *Self, content: Content) std.mem.Allocator.Error!Content { return switch (content) { - .flex_var => |maybe_ident| Content{ .flex_var = maybe_ident }, - // .rigid_var => |maybe_ident| Content{ .rigid_var = maybe_ident }, - .rigid_var => unreachable, + .flex => |maybe_ident| Content{ .flex = maybe_ident }, + // .rigid => |maybe_ident| Content{ .rigid = maybe_ident }, + .rigid => unreachable, .alias => |alias| { // Instantiate the structure recursively - const fresh_alias = try self.instantiateAlias(alias, ctx); - return Content{ .alias = fresh_alias }; + return try self.instantiateAlias(alias); }, .structure => |flat_type| blk: { // Instantiate the structure recursively - const fresh_flat_type = try self.instantiateFlatType(flat_type, ctx); + const fresh_flat_type = try self.instantiateFlatType(flat_type); break :blk Content{ .structure = fresh_flat_type }; }, .err => Content.err, }; } - fn instantiateAlias(self: *Self, alias: Alias, ctx: *Ctx) std.mem.Allocator.Error!Alias { + fn instantiateAlias(self: *Self, alias: Alias) std.mem.Allocator.Error!Content { var fresh_vars = std.array_list.Managed(Var).init(self.store.gpa); defer fresh_vars.deinit(); - const backing_var = self.store.getAliasBackingVar(alias); - const fresh_backing_var = try self.instantiateVar(backing_var, ctx); - try fresh_vars.append(fresh_backing_var); - var iter = self.store.iterAliasArgs(alias); while (iter.next()) |arg_var| { - const fresh_elem = try self.instantiateVar(arg_var, ctx); + const fresh_elem = try self.instantiateVar(arg_var); try fresh_vars.append(fresh_elem); } - const fresh_vars_range = try self.store.appendVars(fresh_vars.items); - return Alias{ - .ident = alias.ident, - .vars = .{ .nonempty = fresh_vars_range }, - }; + const backing_var = self.store.getAliasBackingVar(alias); + const fresh_backing_var = try self.instantiateVar(backing_var); + + return self.store.mkAlias(alias.ident, fresh_backing_var, fresh_vars.items); } - fn instantiateFlatType(self: *Self, flat_type: FlatType, ctx: *Ctx) std.mem.Allocator.Error!FlatType { + fn instantiateFlatType(self: *Self, flat_type: FlatType) std.mem.Allocator.Error!FlatType { return switch (flat_type) { .str => FlatType.str, - .box => |box_var| FlatType{ .box = try self.instantiateVar(box_var, ctx) }, - .list => |list_var| FlatType{ .list = try self.instantiateVar(list_var, ctx) }, + .box => |box_var| FlatType{ .box = try self.instantiateVar(box_var) }, + .list => |list_var| FlatType{ .list = try self.instantiateVar(list_var) }, .list_unbound => FlatType.list_unbound, - .tuple => |tuple| FlatType{ .tuple = try self.instantiateTuple(tuple, ctx) }, - .num => |num| FlatType{ .num = try self.instantiateNum(num, ctx) }, - .nominal_type => |nominal| FlatType{ .nominal_type = try self.instantiateNominalType(nominal, ctx) }, - .fn_pure => |func| FlatType{ .fn_pure = try self.instantiateFunc(func, ctx) }, - .fn_effectful => |func| FlatType{ .fn_effectful = try self.instantiateFunc(func, ctx) }, - .fn_unbound => |func| FlatType{ .fn_unbound = try self.instantiateFunc(func, ctx) }, - .record => |record| FlatType{ .record = try self.instantiateRecord(record, ctx) }, - .record_unbound => |fields| FlatType{ .record_unbound = try self.instantiateRecordFields(fields, ctx) }, - .record_poly => |poly| blk: { - const fresh_record = try self.instantiateRecord(poly.record, ctx); - const fresh_ext = try self.instantiateVar(poly.var_, ctx); - break :blk FlatType{ .record_poly = .{ .record = fresh_record, .var_ = fresh_ext } }; - }, + .tuple => |tuple| FlatType{ .tuple = try self.instantiateTuple(tuple) }, + .num => |num| FlatType{ .num = try self.instantiateNum(num) }, + .nominal_type => |nominal| FlatType{ .nominal_type = try self.instantiateNominalType(nominal) }, + .fn_pure => |func| FlatType{ .fn_pure = try self.instantiateFunc(func) }, + .fn_effectful => |func| FlatType{ .fn_effectful = try self.instantiateFunc(func) }, + .fn_unbound => |func| FlatType{ .fn_unbound = try self.instantiateFunc(func) }, + .record => |record| FlatType{ .record = try self.instantiateRecord(record) }, + .record_unbound => |fields| FlatType{ .record_unbound = try self.instantiateRecordFields(fields) }, .empty_record => FlatType.empty_record, - .tag_union => |tag_union| FlatType{ .tag_union = try self.instantiateTagUnion(tag_union, ctx) }, + .tag_union => |tag_union| FlatType{ .tag_union = try self.instantiateTagUnion(tag_union) }, .empty_tag_union => FlatType.empty_tag_union, }; } - fn instantiateNominalType(self: *Self, nominal: NominalType, ctx: *Ctx) std.mem.Allocator.Error!NominalType { + fn instantiateNominalType(self: *Self, nominal: NominalType) std.mem.Allocator.Error!NominalType { + const backing_var = self.store.getNominalBackingVar(nominal); + const fresh_backing_var = try self.instantiateVar(backing_var); + var fresh_vars = std.array_list.Managed(Var).init(self.store.gpa); defer fresh_vars.deinit(); - const backing_var = self.store.getNominalBackingVar(nominal); - const fresh_backing_var = try self.instantiateVar(backing_var, ctx); - try fresh_vars.append(fresh_backing_var); - var iter = self.store.iterNominalArgs(nominal); while (iter.next()) |arg_var| { - const fresh_elem = try self.instantiateVar(arg_var, ctx); + const fresh_elem = try self.instantiateVar(arg_var); try fresh_vars.append(fresh_elem); } - const fresh_vars_range = try self.store.appendVars(fresh_vars.items); - return NominalType{ - .ident = nominal.ident, - .vars = .{ .nonempty = fresh_vars_range }, - .origin_module = nominal.origin_module, - }; + return (try self.store.mkNominal(nominal.ident, fresh_backing_var, fresh_vars.items, nominal.origin_module)).structure.nominal_type; } - fn instantiateTuple(self: *Self, tuple: Tuple, ctx: *Ctx) std.mem.Allocator.Error!Tuple { + fn instantiateTuple(self: *Self, tuple: Tuple) std.mem.Allocator.Error!Tuple { const elems_slice = self.store.sliceVars(tuple.elems); var fresh_elems = std.array_list.Managed(Var).init(self.store.gpa); defer fresh_elems.deinit(); for (elems_slice) |elem_var| { - const fresh_elem = try self.instantiateVar(elem_var, ctx); + const fresh_elem = try self.instantiateVar(elem_var); try fresh_elems.append(fresh_elem); } @@ -225,11 +221,11 @@ pub const Instantiate = struct { return Tuple{ .elems = fresh_elems_range }; } - fn instantiateNum(self: *Self, num: Num, ctx: *Ctx) std.mem.Allocator.Error!Num { + fn instantiateNum(self: *Self, num: Num) std.mem.Allocator.Error!Num { return switch (num) { - .num_poly => |poly| Num{ .num_poly = .{ .var_ = try self.instantiateVar(poly.var_, ctx), .requirements = poly.requirements } }, - .int_poly => |poly| Num{ .int_poly = .{ .var_ = try self.instantiateVar(poly.var_, ctx), .requirements = poly.requirements } }, - .frac_poly => |poly| Num{ .frac_poly = .{ .var_ = try self.instantiateVar(poly.var_, ctx), .requirements = poly.requirements } }, + .num_poly => |poly_var| Num{ .num_poly = try self.instantiateVar(poly_var) }, + .int_poly => |poly_var| Num{ .int_poly = try self.instantiateVar(poly_var) }, + .frac_poly => |poly_var| Num{ .frac_poly = try self.instantiateVar(poly_var) }, // Concrete types remain unchanged .int_precision => |precision| Num{ .int_precision = precision }, .frac_precision => |precision| Num{ .frac_precision = precision }, @@ -240,17 +236,17 @@ pub const Instantiate = struct { }; } - fn instantiateFunc(self: *Self, func: Func, ctx: *Ctx) std.mem.Allocator.Error!Func { + fn instantiateFunc(self: *Self, func: Func) std.mem.Allocator.Error!Func { const args_slice = self.store.sliceVars(func.args); var fresh_args = std.array_list.Managed(Var).init(self.store.gpa); defer fresh_args.deinit(); for (args_slice) |arg_var| { - const fresh_arg = try self.instantiateVar(arg_var, ctx); + const fresh_arg = try self.instantiateVar(arg_var); try fresh_args.append(fresh_arg); } - const fresh_ret = try self.instantiateVar(func.ret, ctx); + const fresh_ret = try self.instantiateVar(func.ret); const fresh_args_range = try self.store.appendVars(fresh_args.items); return Func{ .args = fresh_args_range, @@ -259,14 +255,14 @@ pub const Instantiate = struct { }; } - fn instantiateRecordFields(self: *Self, fields: RecordField.SafeMultiList.Range, ctx: *Ctx) std.mem.Allocator.Error!RecordField.SafeMultiList.Range { + fn instantiateRecordFields(self: *Self, fields: RecordField.SafeMultiList.Range) std.mem.Allocator.Error!RecordField.SafeMultiList.Range { const fields_slice = self.store.getRecordFieldsSlice(fields); var fresh_fields = std.array_list.Managed(RecordField).init(self.store.gpa); defer fresh_fields.deinit(); for (fields_slice.items(.name), fields_slice.items(.var_)) |name, type_var| { - const fresh_type = try self.instantiateVar(type_var, ctx); + const fresh_type = try self.instantiateVar(type_var); _ = try fresh_fields.append(RecordField{ .name = name, .var_ = fresh_type, @@ -276,14 +272,14 @@ pub const Instantiate = struct { return try self.store.appendRecordFields(fresh_fields.items); } - fn instantiateRecord(self: *Self, record: Record, ctx: *Ctx) std.mem.Allocator.Error!Record { + fn instantiateRecord(self: *Self, record: Record) std.mem.Allocator.Error!Record { const fields_slice = self.store.getRecordFieldsSlice(record.fields); var fresh_fields = std.array_list.Managed(RecordField).init(self.store.gpa); defer fresh_fields.deinit(); for (fields_slice.items(.name), fields_slice.items(.var_)) |name, type_var| { - const fresh_type = try self.instantiateVar(type_var, ctx); + const fresh_type = try self.instantiateVar(type_var); _ = try fresh_fields.append(RecordField{ .name = name, .var_ = fresh_type, @@ -293,11 +289,11 @@ pub const Instantiate = struct { const fields_range = try self.store.appendRecordFields(fresh_fields.items); return Record{ .fields = fields_range, - .ext = try self.instantiateVar(record.ext, ctx), + .ext = try self.instantiateVar(record.ext), }; } - fn instantiateTagUnion(self: *Self, tag_union: TagUnion, ctx: *Ctx) std.mem.Allocator.Error!TagUnion { + fn instantiateTagUnion(self: *Self, tag_union: TagUnion) std.mem.Allocator.Error!TagUnion { const tags_slice = self.store.getTagsSlice(tag_union.tags); var fresh_tags = std.array_list.Managed(Tag).init(self.store.gpa); @@ -309,7 +305,7 @@ pub const Instantiate = struct { const args_slice = self.store.sliceVars(tag_args); for (args_slice) |arg_var| { - const fresh_arg = try self.instantiateVar(arg_var, ctx); + const fresh_arg = try self.instantiateVar(arg_var); try fresh_args.append(fresh_arg); } @@ -324,7 +320,7 @@ pub const Instantiate = struct { const tags_range = try self.store.appendTags(fresh_tags.items); return TagUnion{ .tags = tags_range, - .ext = try self.instantiateVar(tag_union.ext, ctx), + .ext = try self.instantiateVar(tag_union.ext), }; } diff --git a/src/types/mod.zig b/src/types/mod.zig index f32fc6d701..c4706ed736 100644 --- a/src/types/mod.zig +++ b/src/types/mod.zig @@ -10,10 +10,13 @@ const std = @import("std"); pub const types = @import("types.zig"); pub const store = @import("store.zig"); pub const instantiate = @import("instantiate.zig"); +pub const generalize = @import("generalize.zig"); pub const TypeWriter = @import("TypeWriter.zig"); pub const Alias = types.Alias; +pub const Flex = types.Flex; +pub const Rigid = types.Rigid; pub const Content = types.Content; pub const FlatType = types.FlatType; pub const Func = types.Func; @@ -41,5 +44,5 @@ pub const Store = store.Store; pub const DescStoreIdx = store.DescStoreIdx; test { - std.testing.refAllDecls(@import("test_rigid_instantiation.zig")); + std.testing.refAllDecls(@import("test/test_rigid_instantiation.zig")); } diff --git a/src/types/store.zig b/src/types/store.zig index dd01809917..3eac8d853f 100644 --- a/src/types/store.zig +++ b/src/types/store.zig @@ -14,6 +14,8 @@ const Var = types.Var; const Content = types.Content; const Rank = types.Rank; const Mark = types.Mark; +const Flex = types.Flex; +const Rigid = types.Rigid; const RecordField = types.RecordField; const TagUnion = types.TagUnion; const Tag = types.Tag; @@ -27,6 +29,7 @@ const FlatType = types.FlatType; const NominalType = types.NominalType; const Record = types.Record; const Num = types.Num; +const StaticDispatchConstraint = types.StaticDispatchConstraint; const SERIALIZATION_ALIGNMENT = collections.SERIALIZATION_ALIGNMENT; @@ -78,10 +81,10 @@ pub const Store = struct { descs: DescStore, /// Storage for compound type parts - /// TODO: Consolidate all var lists into 1 vars: VarSafeList, record_fields: RecordFieldSafeMultiList, tags: TagSafeMultiList, + static_dispatch_constraints: StaticDispatchConstraint.SafeMultiList, /// Init the unification table pub fn init(gpa: Allocator) std.mem.Allocator.Error!Self { @@ -102,6 +105,7 @@ pub const Store = struct { .vars = try VarSafeList.initCapacity(gpa, child_capacity), .record_fields = try RecordFieldSafeMultiList.initCapacity(gpa, child_capacity), .tags = try TagSafeMultiList.initCapacity(gpa, child_capacity), + .static_dispatch_constraints = try StaticDispatchConstraint.SafeMultiList.initCapacity(gpa, child_capacity), }; } @@ -121,6 +125,7 @@ pub const Store = struct { self.vars.deinit(self.gpa); self.record_fields.deinit(self.gpa); self.tags.deinit(self.gpa); + self.static_dispatch_constraints.deinit(self.gpa); } /// Return the number of type variables in the store. @@ -133,7 +138,13 @@ pub const Store = struct { /// Create a new unbound, flexible type variable without a name /// Used in canonicalization when creating type slots pub fn fresh(self: *Self) std.mem.Allocator.Error!Var { - return try self.freshFromContent(Content{ .flex_var = null }); + return try self.freshFromContent(Content{ .flex = Flex.init() }); + } + + /// Create a new unbound, flexible type variable without a name + /// Used in canonicalization when creating type slots + pub fn freshWithRank(self: *Self, rank: Rank) std.mem.Allocator.Error!Var { + return try self.freshFromContentWithRank(Content{ .flex = Flex.init() }, rank); } /// Create a new variable with the provided desc @@ -165,8 +176,23 @@ pub const Store = struct { return Self.slotIdxToVar(slot_idx); } + /// Check if a variable is a rediret + pub fn isRedirect(self: *const Self, var_: Var) bool { + switch (self.slots.get(Self.varToSlotIdx(var_))) { + .redirect => return true, + .root => return false, + } + } + // setting variables // + /// Set a type variable to the provided content + pub fn setVarDesc(self: *Self, target_var: Var, desc: Desc) Allocator.Error!void { + std.debug.assert(@intFromEnum(target_var) < self.len()); + const resolved = self.resolveVar(target_var); + self.descs.set(resolved.desc_idx, desc); + } + /// Set a type variable to the provided content pub fn setVarContent(self: *Self, target_var: Var, content: Content) Allocator.Error!void { std.debug.assert(@intFromEnum(target_var) < self.len()); @@ -357,8 +383,8 @@ pub const Store = struct { pub fn needsInstantiationContent(self: *const Self, content: Content) bool { return switch (content) { - .flex_var => true, // Flexible variables need instantiation - .rigid_var => true, // Rigid variables need instantiation when used outside their defining scope + .flex => true, // Flexible variables need instantiation + .rigid => true, // Rigid variables need instantiation when used outside their defining scope .alias => true, // Aliases may contain type variables, so assume they need instantiation .structure => |flat_type| self.needsInstantiationFlatType(flat_type), .err => false, @@ -370,7 +396,7 @@ pub const Store = struct { .str => false, .box => |box_var| self.needsInstantiation(box_var), .list => |list_var| self.needsInstantiation(list_var), - .list_unbound => false, + .list_unbound => true, .tuple => |tuple| blk: { const elems_slice = self.sliceVars(tuple.elems); for (elems_slice) |elem_var| { @@ -379,9 +405,12 @@ pub const Store = struct { break :blk false; }, .num => |num| switch (num) { - .num_poly => |poly| self.needsInstantiation(poly.var_), - .int_poly => |poly| self.needsInstantiation(poly.var_), - .frac_poly => |poly| self.needsInstantiation(poly.var_), + .num_poly => |poly_var| self.needsInstantiation(poly_var), + .num_unbound => true, + .int_poly => |poly_var| self.needsInstantiation(poly_var), + .int_unbound => true, + .frac_poly => |poly_var| self.needsInstantiation(poly_var), + .frac_unbound => true, else => false, // Concrete numeric types don't need instantiation }, .nominal_type => false, // Nominal types are concrete @@ -390,7 +419,6 @@ pub const Store = struct { .fn_unbound => |func| func.needs_instantiation, .record => |record| self.needsInstantiationRecord(record), .record_unbound => |fields| self.needsInstantiationRecordFields(fields), - .record_poly => |poly| self.needsInstantiation(poly.var_) or self.needsInstantiationRecord(poly.record), .empty_record => false, .tag_union => |tag_union| self.needsInstantiationTagUnion(tag_union), .empty_tag_union => false, @@ -634,6 +662,11 @@ pub const Store = struct { /// * update b to to the new desc value /// * redirect a -> b /// + /// CRITICAL: The merge direction (a -> b) is load-bearing and must not be changed! + /// Multiple parts of the unification algorithm depend on this specific order: + /// - When unifying aliases with structures, we rely on this order to ensure + /// that we don't loose alias context + /// // NOTE: The elm & the roc compiler this step differently // * The elm compiler sets b to redirect to a // * The roc compiler sets a to redirect to b @@ -695,12 +728,13 @@ pub const Store = struct { /// Serialized representation of types store pub const Serialized = struct { - gpa: Allocator, + gpa: [2]u64, // Reserve space for allocator (vtable ptr + context ptr), provided during deserialization slots: SlotStore.Serialized, descs: DescStore.Serialized, vars: VarSafeList.Serialized, record_fields: RecordFieldSafeMultiList.Serialized, tags: TagSafeMultiList.Serialized, + static_dispatch_constraints: StaticDispatchConstraint.SafeMultiList.Serialized, /// Serialize a Store into this Serialized struct, appending data to the writer pub fn serialize( @@ -715,13 +749,15 @@ pub const Store = struct { try self.vars.serialize(&store.vars, allocator, writer); try self.record_fields.serialize(&store.record_fields, allocator, writer); try self.tags.serialize(&store.tags, allocator, writer); + try self.static_dispatch_constraints.serialize(&store.static_dispatch_constraints, allocator, writer); - // Store the allocator - self.gpa = allocator; + // Set gpa to all zeros; the space needs to be here, + // but the value will be set separately during deserialization. + self.gpa = .{ 0, 0 }; } /// Deserialize this Serialized struct into a Store - pub fn deserialize(self: *Serialized, offset: i64) *Store { + pub fn deserialize(self: *Serialized, offset: i64, gpa: Allocator) *Store { // types.Store.Serialized should be at least as big as types.Store std.debug.assert(@sizeOf(Serialized) >= @sizeOf(Store)); @@ -729,12 +765,13 @@ pub const Store = struct { const store = @as(*Store, @ptrFromInt(@intFromPtr(self))); store.* = Store{ - .gpa = self.gpa, + .gpa = gpa, .slots = self.slots.deserialize(offset).*, .descs = self.descs.deserialize(offset).*, .vars = self.vars.deserialize(offset).*, .record_fields = self.record_fields.deserialize(offset).*, .tags = self.tags.deserialize(offset).*, + .static_dispatch_constraints = self.static_dispatch_constraints.deserialize(offset).*, }; return store; @@ -758,6 +795,7 @@ pub const Store = struct { .vars = (try self.vars.serialize(allocator, writer)).*, .record_fields = (try self.record_fields.serialize(allocator, writer)).*, .tags = (try self.tags.serialize(allocator, writer)).*, + .static_dispatch_constraints = (try self.static_dispatch_constraints.serialize(allocator, writer)).*, }; return @constCast(offset_self); @@ -770,6 +808,7 @@ pub const Store = struct { self.vars.relocate(offset); self.record_fields.relocate(offset); self.tags.relocate(offset); + self.static_dispatch_constraints.relocate(offset); } /// Calculate the size needed to serialize this Store @@ -779,10 +818,11 @@ pub const Store = struct { const record_fields_size = self.record_fields.serializedSize(); const tags_size = self.tags.serializedSize(); const vars_size = self.vars.serializedSize(); + const static_dispatch_constraints_size = self.static_dispatch_constraints.serializedSize(); // Add alignment padding for each component - var total_size: usize = @sizeOf(u32) * 5; // size headers - total_size = std.mem.alignForward(usize, total_size, SERIALIZATION_ALIGNMENT.toByteUnits()); + var total_size: usize = @sizeOf(u32) * 6; // size headers + total_size = std.mem.alignForward(usize, total_size, SERIALIZATION_ALIGNMENT); total_size += slots_size; total_size = std.mem.alignForward(usize, total_size, SERIALIZATION_ALIGNMENT.toByteUnits()); @@ -799,13 +839,16 @@ pub const Store = struct { total_size += vars_size; total_size = std.mem.alignForward(usize, total_size, SERIALIZATION_ALIGNMENT.toByteUnits()); + total_size += static_dispatch_constraints_size; + total_size = std.mem.alignForward(usize, total_size, SERIALIZATION_ALIGNMENT); + // Align to SERIALIZATION_ALIGNMENT to maintain alignment for subsequent data return std.mem.alignForward(usize, total_size, SERIALIZATION_ALIGNMENT.toByteUnits()); } /// Deserialize a Store from the provided buffer pub fn deserializeFrom(buffer: []const u8, allocator: Allocator) !Self { - if (buffer.len < @sizeOf(u32) * 5) return error.BufferTooSmall; + if (buffer.len < @sizeOf(u32) * 6) return error.BufferTooSmall; var offset: usize = 0; @@ -825,6 +868,9 @@ pub const Store = struct { const vars_size = @as(*const u32, @ptrCast(@alignCast(buffer.ptr + offset))).*; offset += @sizeOf(u32); + const static_dispatch_constraints_size = @as(*const u32, @ptrCast(@alignCast(buffer.ptr + offset))).*; + offset += @sizeOf(u32); + // Deserialize data offset = std.mem.alignForward(usize, offset, SERIALIZATION_ALIGNMENT.toByteUnits()); const slots_buffer = @as([]align(SERIALIZATION_ALIGNMENT.toByteUnits()) const u8, @alignCast(buffer[offset .. offset + slots_size])); @@ -851,6 +897,11 @@ pub const Store = struct { const vars = try VarSafeList.deserializeFrom(vars_buffer, allocator); offset += vars_size; + offset = std.mem.alignForward(usize, offset, SERIALIZATION_ALIGNMENT); + const static_dispatch_constraints_buffer = @as([]align(SERIALIZATION_ALIGNMENT) const u8, @alignCast(buffer[offset .. offset + static_dispatch_constraints_size])); + const static_dispatch_constraints = try StaticDispatchConstraint.SafeMultiList.deserializeFrom(static_dispatch_constraints_buffer, allocator); + offset += static_dispatch_constraints_size; + return Self{ .gpa = allocator, .slots = slots, @@ -858,6 +909,7 @@ pub const Store = struct { .record_fields = record_fields, .tags = tags, .vars = vars, + .static_dispatch_constraints = static_dispatch_constraints, }; } }; @@ -1064,7 +1116,7 @@ pub const DescStoreIdx = DescStore.Idx; // path compression -test "resolveVarAndCompressPath - flattens redirect chain to flex_var" { +test "resolveVarAndCompressPath - flattens redirect chain to flex" { const gpa = std.testing.allocator; var store = try Store.init(gpa); @@ -1075,7 +1127,7 @@ test "resolveVarAndCompressPath - flattens redirect chain to flex_var" { const a = try store.freshRedirect(b); const result = store.resolveVarAndCompressPath(a); - try std.testing.expectEqual(Content{ .flex_var = null }, result.desc.content); + try std.testing.expectEqual(Content{ .flex = Flex.init() }, result.desc.content); try std.testing.expectEqual(c, result.var_); try std.testing.expectEqual(Slot{ .redirect = c }, store.getSlot(a)); try std.testing.expectEqual(Slot{ .redirect = c }, store.getSlot(b)); @@ -1088,11 +1140,7 @@ test "resolveVarAndCompressPath - no-op on already root" { defer store.deinit(); const num_flex = try store.fresh(); - const requirements = Num.IntRequirements{ - .sign_needed = false, - .bits_needed = 0, - }; - const num = Content{ .structure = .{ .num = .{ .num_poly = .{ .var_ = num_flex, .requirements = requirements } } } }; + const num = Content{ .structure = .{ .num = .{ .num_poly = num_flex } } }; const num_var = try store.freshFromContent(num); const result = store.resolveVarAndCompressPath(num_var); @@ -1109,11 +1157,7 @@ test "resolveVarAndCompressPath - flattens redirect chain to structure" { defer store.deinit(); const num_flex = try store.fresh(); - const requirements = Num.IntRequirements{ - .sign_needed = false, - .bits_needed = 0, - }; - const num = Content{ .structure = .{ .num = .{ .num_poly = .{ .var_ = num_flex, .requirements = requirements } } } }; + const num = Content{ .structure = .{ .num = .{ .num_poly = num_flex } } }; const c = try store.freshFromContent(num); const b = try store.freshRedirect(c); const a = try store.freshRedirect(b); @@ -1174,18 +1218,18 @@ test "Store basic CompactWriter roundtrip" { defer original.deinit(); // Create some type variables - const flex_var = try original.fresh(); - const rigid_var = try original.freshFromContent(Content{ .rigid_var = @bitCast(@as(u32, 42)) }); + const flex = try original.fresh(); + const rigid = try original.freshFromContent(Content{ .rigid = Rigid.init(@bitCast(@as(u32, 42))) }); // Create a redirect - const redirect_var = try original.freshRedirect(flex_var); + const redirect_var = try original.freshRedirect(flex); // Verify original values - const flex_resolved = original.resolveVar(flex_var); - try std.testing.expectEqual(Content{ .flex_var = null }, flex_resolved.desc.content); + const flex_resolved = original.resolveVar(flex); + try std.testing.expectEqual(Content{ .flex = Flex.init() }, flex_resolved.desc.content); - const rigid_resolved = original.resolveVar(rigid_var); - try std.testing.expectEqual(Content{ .rigid_var = @bitCast(@as(u32, 42)) }, rigid_resolved.desc.content); + const rigid_resolved = original.resolveVar(rigid); + try std.testing.expectEqual(Content{ .rigid = Rigid.init(@bitCast(@as(u32, 42))) }, rigid_resolved.desc.content); const redirect_resolved = original.resolveVar(redirect_var); try std.testing.expectEqual(flex_resolved.desc_idx, redirect_resolved.desc_idx); @@ -1221,11 +1265,11 @@ test "Store basic CompactWriter roundtrip" { // Verify the types are accessible try std.testing.expectEqual(@as(usize, 3), deserialized.len()); - const deser_flex_resolved = deserialized.resolveVar(flex_var); - try std.testing.expectEqual(Content{ .flex_var = null }, deser_flex_resolved.desc.content); + const deser_flex_resolved = deserialized.resolveVar(flex); + try std.testing.expectEqual(Content{ .flex = Flex.init() }, deser_flex_resolved.desc.content); - const deser_rigid_resolved = deserialized.resolveVar(rigid_var); - try std.testing.expectEqual(Content{ .rigid_var = @bitCast(@as(u32, 42)) }, deser_rigid_resolved.desc.content); + const deser_rigid_resolved = deserialized.resolveVar(rigid); + try std.testing.expectEqual(Content{ .rigid = Rigid.init(@bitCast(@as(u32, 42))) }, deser_rigid_resolved.desc.content); const deser_redirect_resolved = deserialized.resolveVar(redirect_var); try std.testing.expectEqual(deser_flex_resolved.desc_idx, deser_redirect_resolved.desc_idx); @@ -1241,7 +1285,7 @@ test "Store comprehensive CompactWriter roundtrip" { defer original.deinit(); // Create various types - const flex_var = try original.fresh(); + const flex = try original.fresh(); const str_var = try original.freshFromContent(Content{ .structure = .{ .str = {} } }); const list_elem = try original.fresh(); const list_var = try original.freshFromContent(Content{ .structure = .{ .list = list_elem } }); @@ -1265,7 +1309,7 @@ test "Store comprehensive CompactWriter roundtrip" { const record_var = try original.freshFromContent(record_content); // Create a tag union - const tag1 = try original.mkTag(base.Ident.Idx{ .attributes = .{ .effectful = false, .ignored = false, .reassignable = false }, .idx = 300 }, &[_]Var{flex_var}); + const tag1 = try original.mkTag(base.Ident.Idx{ .attributes = .{ .effectful = false, .ignored = false, .reassignable = false }, .idx = 300 }, &[_]Var{flex}); const tag2 = try original.mkTag(base.Ident.Idx{ .attributes = .{ .effectful = false, .ignored = false, .reassignable = false }, .idx = 400 }, &[_]Var{ arg1, arg2 }); const tag_union_ext = try original.fresh(); const tag_union_content = try original.mkTagUnion(&[_]Tag{ tag1, tag2 }, tag_union_ext); @@ -1346,7 +1390,7 @@ test "Store comprehensive CompactWriter roundtrip" { const tag1_args = deserialized.sliceVars(tags_slice.items(.args)[0]); try std.testing.expectEqual(@as(usize, 1), tag1_args.len); - try std.testing.expectEqual(flex_var, tag1_args[0]); + try std.testing.expectEqual(flex, tag1_args[0]); const tag2_args = deserialized.sliceVars(tags_slice.items(.args)[1]); try std.testing.expectEqual(@as(usize, 2), tag2_args.len); @@ -1418,7 +1462,7 @@ test "DescStore.Serialized roundtrip" { // Add some descriptors const desc1 = Descriptor{ - .content = Content{ .flex_var = null }, + .content = Content{ .flex = Flex.init() }, .rank = Rank.generalized, .mark = Mark.none, }; @@ -1481,9 +1525,9 @@ test "Store.Serialized roundtrip" { defer store.deinit(); // Create some type variables - const flex_var = try store.fresh(); + const flex = try store.fresh(); const str_var = try store.freshFromContent(Content{ .structure = .{ .str = {} } }); - const redirect_var = try store.freshRedirect(flex_var); + const redirect_var = try store.freshRedirect(flex); // Create temp file var tmp_dir = std.testing.tmpDir(.{}); @@ -1514,13 +1558,13 @@ test "Store.Serialized roundtrip" { // Deserialize - Store.Serialized is at the beginning of the buffer const deser_ptr = @as(*Store.Serialized, @ptrCast(@alignCast(buffer.ptr))); - const deserialized = deser_ptr.deserialize(@as(i64, @intCast(@intFromPtr(buffer.ptr)))); + const deserialized = deser_ptr.deserialize(@as(i64, @intCast(@intFromPtr(buffer.ptr))), gpa); // Verify the store was deserialized correctly try std.testing.expectEqual(@as(usize, 3), deserialized.len()); - const flex_resolved = deserialized.resolveVar(flex_var); - try std.testing.expectEqual(Content{ .flex_var = null }, flex_resolved.desc.content); + const flex_resolved = deserialized.resolveVar(flex); + try std.testing.expectEqual(Content{ .flex = Flex.init() }, flex_resolved.desc.content); const str_resolved = deserialized.resolveVar(str_var); try std.testing.expectEqual(Content{ .structure = .{ .str = {} } }, str_resolved.desc.content); @@ -1620,9 +1664,9 @@ test "SlotStore and DescStore serialization and deserialization" { defer original.deinit(); // Create several variables to populate SlotStore with roots - const var1 = try original.freshFromContent(Content{ .flex_var = null }); + const var1 = try original.freshFromContent(Content{ .flex = Flex.init() }); const var2 = try original.freshFromContent(Content{ .structure = .{ .str = {} } }); - const var3 = try original.freshFromContent(Content{ .rigid_var = @bitCast(@as(u32, 123)) }); + const var3 = try original.freshFromContent(Content{ .rigid = Rigid.init(@bitCast(@as(u32, 123))) }); // Create redirects to populate SlotStore with redirects const redirect1 = try original.freshRedirect(var1); @@ -1675,13 +1719,13 @@ test "SlotStore and DescStore serialization and deserialization" { // Verify we can resolve variables correctly const resolved1 = deserialized.resolveVar(var1); - try std.testing.expectEqual(Content{ .flex_var = null }, resolved1.desc.content); + try std.testing.expectEqual(Content{ .flex = Flex.init() }, resolved1.desc.content); const resolved2 = deserialized.resolveVar(var2); try std.testing.expectEqual(Content{ .structure = .{ .str = {} } }, resolved2.desc.content); const resolved3 = deserialized.resolveVar(var3); - try std.testing.expectEqual(Content{ .rigid_var = @bitCast(@as(u32, 123)) }, resolved3.desc.content); + try std.testing.expectEqual(Content{ .rigid = Rigid.init(@bitCast(@as(u32, 123))) }, resolved3.desc.content); // Verify redirects work const resolved_redirect1 = deserialized.resolveVar(redirect1); diff --git a/src/types/test/test_rigid_instantiation.zig b/src/types/test/test_rigid_instantiation.zig new file mode 100644 index 0000000000..a4888f333a --- /dev/null +++ b/src/types/test/test_rigid_instantiation.zig @@ -0,0 +1,597 @@ +//! Tests for rigid variable instantiation in the type system. +//! +//! This module contains tests that verify the correct behavior of rigid type +//! variables during instantiation, particularly for polymorphic functions +//! where type variables need to be properly instantiated with concrete types. + +const std = @import("std"); +const base = @import("base"); + +const types_mod = @import("../types.zig"); +const Store = @import("../store.zig").Store; +const Instantiator = @import("../instantiate.zig").Instantiator; + +const Ident = base.Ident; + +const TypeIdent = types_mod.TypeIdent; +const Var = types_mod.Var; +const Desc = types_mod.Descriptor; +const Rank = types_mod.Rank; +const Mark = types_mod.Mark; +const Flex = types_mod.Flex; +const Rigid = types_mod.Rigid; +const Content = types_mod.Content; +const Alias = types_mod.Alias; +const NominalType = types_mod.NominalType; +const FlatType = types_mod.FlatType; +const Builtin = types_mod.Builtin; +const Tuple = types_mod.Tuple; +const Num = types_mod.Num; +const NumCompact = types_mod.Num.Compact; +const Func = types_mod.Func; +const Record = types_mod.Record; +const RecordField = types_mod.RecordField; +const TwoRecordFields = types_mod.TwoRecordFields; +const TagUnion = types_mod.TagUnion; +const Tag = types_mod.Tag; +const TwoTags = types_mod.TwoTags; + +const VarSafeList = Var.SafeList; +const RecordFieldSafeMultiList = RecordField.SafeMultiList; +const RecordFieldSafeList = RecordField.SafeList; +const TwoRecordFieldsSafeMultiList = TwoRecordFields.SafeMultiList; +const TwoRecordFieldsSafeList = TwoRecordFields.SafeList; +const TagSafeList = Tag.SafeList; +const TagSafeMultiList = Tag.SafeMultiList; +const TwoTagsSafeList = TwoTags.SafeList; + +test "instantiate - flex var creates new flex var" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const original = try env.types.freshFromContent(.{ .flex = Flex.init() }); + + var instantiator = Instantiator{ + .store = &env.types, + .idents = &env.idents, + .var_map = &env.var_map, + .rigid_behavior = .fresh_flex, + }; + + const instantiated = try instantiator.instantiateVar(original); + + // Should be a different variable + try std.testing.expect(instantiated != original); + + // Should still be flex + const resolved = env.types.resolveVar(instantiated); + try std.testing.expect(resolved.desc.content == .flex); +} + +test "instantiate - rigid var with fresh_flex creates flex var" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const original = try env.types.freshFromContent(try env.mkRigidVar("a")); + + var instantiator = Instantiator{ + .store = &env.types, + .idents = &env.idents, + .var_map = &env.var_map, + .rigid_behavior = .fresh_flex, + }; + + const instantiated = try instantiator.instantiateVar(original); + + // Should be a different variable + try std.testing.expect(instantiated != original); + + // Should now be flex + const resolved = env.types.resolveVar(instantiated); + try std.testing.expect(resolved.desc.content == .flex); +} + +test "instantiate - rigid var with fresh_rigid creates new rigid var" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const original = try env.types.freshFromContent(try env.mkRigidVar("a")); + + var instantiator = Instantiator{ + .store = &env.types, + .idents = &env.idents, + .var_map = &env.var_map, + .rigid_behavior = .fresh_rigid, + }; + + const instantiated = try instantiator.instantiateVar(original); + + // Should be a different variable + try std.testing.expect(instantiated != original); + + // Should still be rigid + const resolved = env.types.resolveVar(instantiated); + try std.testing.expect(resolved.desc.content == .rigid); +} + +test "instantiate - rigid var with substitute_rigids substitutes correctly" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const ident_idx = try env.idents.insert(gpa, Ident.for_text("a")); + const original = try env.types.freshFromContent(.{ .rigid = Rigid.init(ident_idx) }); + + const substitute_var = try env.types.freshFromContent(.{ .structure = .{ .num = Num.int_u8 } }); + + var rigid_subs = std.AutoHashMapUnmanaged(Ident.Idx, Var){}; + defer rigid_subs.deinit(gpa); + try rigid_subs.put(gpa, ident_idx, substitute_var); + + var instantiator = Instantiator{ + .store = &env.types, + .idents = &env.idents, + .var_map = &env.var_map, + .rigid_behavior = .{ .substitute_rigids = &rigid_subs }, + }; + + const instantiated = try instantiator.instantiateVar(original); + + // Should be substituted with our provided var + try std.testing.expectEqual(substitute_var, instantiated); +} + +test "instantiate - preserves rigid var structure in function" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + // Create a -> a function + const rigid_a = try env.types.freshFromContent(try env.mkRigidVar("a")); + const func_content = try env.mkFuncPure(&[_]Var{rigid_a}, rigid_a); + const original = try env.types.freshFromContent(func_content); + + var instantiator = Instantiator{ + .store = &env.types, + .idents = &env.idents, + .var_map = &env.var_map, + .rigid_behavior = .fresh_flex, + }; + + const instantiated = try instantiator.instantiateVar(original); + + // Should be a different function + try std.testing.expect(instantiated != original); + + // Get the function structure + const resolved = env.types.resolveVar(instantiated); + const func = resolved.desc.content.structure.fn_pure; + + const args = env.types.sliceVars(func.args); + try std.testing.expectEqual(1, args.len); + + // The arg and return should be the SAME new flex var + try std.testing.expectEqual(args[0], func.ret); +} + +test "instantiate - tuple with multiple vars" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const rigid_a = try env.types.freshFromContent(try env.mkRigidVar("a")); + const rigid_b = try env.types.freshFromContent(try env.mkRigidVar("b")); + const tuple_content = try env.mkTuple(&[_]Var{ rigid_a, rigid_b, rigid_a }); + const original = try env.types.freshFromContent(tuple_content); + + var instantiator = Instantiator{ + .store = &env.types, + .idents = &env.idents, + .var_map = &env.var_map, + .rigid_behavior = .fresh_flex, + }; + + const instantiated = try instantiator.instantiateVar(original); + + const resolved = env.types.resolveVar(instantiated); + const tuple = resolved.desc.content.structure.tuple; + const elems = env.types.sliceVars(tuple.elems); + + try std.testing.expectEqual(3, elems.len); + // First and third should be the same (both were rigid_a) + try std.testing.expectEqual(elems[0], elems[2]); + // Second should be different (was rigid_b) + try std.testing.expect(elems[0] != elems[1]); +} + +test "instantiate - record with multiple fields" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const rigid_a = try env.types.freshFromContent(try env.mkRigidVar("a")); + const rigid_b = try env.types.freshFromContent(try env.mkRigidVar("b")); + + const record_info = try env.mkRecordClosed(&[_]RecordField{ + try env.mkRecordField("x", rigid_a), + try env.mkRecordField("y", rigid_b), + try env.mkRecordField("z", rigid_a), + }); + const original = try env.types.freshFromContent(record_info.content); + + var instantiator = Instantiator{ + .store = &env.types, + .idents = &env.idents, + .var_map = &env.var_map, + .rigid_behavior = .fresh_flex, + }; + + const instantiated = try instantiator.instantiateVar(original); + + const resolved = env.types.resolveVar(instantiated); + const record = resolved.desc.content.structure.record; + const fields = env.types.getRecordFieldsSlice(record.fields); + + try std.testing.expectEqual(3, fields.len); + + const x_var = fields.items(.var_)[0]; + const y_var = fields.items(.var_)[1]; + const z_var = fields.items(.var_)[2]; + + // x and z should be the same (both were rigid_a) + try std.testing.expectEqual(x_var, z_var); + // y should be different (was rigid_b) + try std.testing.expect(x_var != y_var); +} + +test "instantiate - tag union preserves structure" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const rigid_a = try env.types.freshFromContent(try env.mkRigidVar("a")); + + const tag_union_info = try env.mkTagUnionClosed(&[_]Tag{ + try env.mkTag("Some", &[_]Var{rigid_a}), + try env.mkTag("None", &[_]Var{}), + }); + const original = try env.types.freshFromContent(tag_union_info.content); + + var instantiator = Instantiator{ + .store = &env.types, + .idents = &env.idents, + .var_map = &env.var_map, + .rigid_behavior = .fresh_flex, + }; + + const instantiated = try instantiator.instantiateVar(original); + + const resolved = env.types.resolveVar(instantiated); + const tag_union = resolved.desc.content.structure.tag_union; + const tags = env.types.getTagsSlice(tag_union.tags); + + try std.testing.expectEqual(2, tags.len); + + // Check Some tag has one arg that's different from original + const some_args = env.types.sliceVars(tags.items(.args)[0]); + try std.testing.expectEqual(1, some_args.len); + try std.testing.expect(some_args[0] != rigid_a); + + // Check None tag has no args + const none_args = env.types.sliceVars(tags.items(.args)[1]); + try std.testing.expectEqual(0, none_args.len); +} + +test "instantiate - alias preserves structure" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const rigid_a = try env.types.freshFromContent(try env.mkRigidVar("a")); + const backing = try env.types.freshFromContent(.{ .structure = .{ .list = rigid_a } }); + const alias_content = try env.mkAlias("MyList", backing, &[_]Var{rigid_a}); + const original = try env.types.freshFromContent(alias_content); + + var instantiator = Instantiator{ + .store = &env.types, + .idents = &env.idents, + .var_map = &env.var_map, + .rigid_behavior = .fresh_flex, + }; + + const instantiated = try instantiator.instantiateVar(original); + + const resolved = env.types.resolveVar(instantiated); + const alias = resolved.desc.content.alias; + + // Get the args + const args = env.types.sliceAliasArgs(alias); + try std.testing.expectEqual(1, args.len); + + // Get the backing var + const backing_var = env.types.getAliasBackingVar(alias); + const backing_resolved = env.types.resolveVar(backing_var); + const backing_list_elem = backing_resolved.desc.content.structure.list; + + // The alias arg and the list element should be the same fresh var + try std.testing.expectEqual(args[0], backing_list_elem); +} + +test "instantiate - num types" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const rigid_a = try env.types.freshFromContent(try env.mkRigidVar("a")); + + // Test num_poly + { + const num_poly = try env.types.freshFromContent(.{ .structure = .{ .num = .{ .num_poly = rigid_a } } }); + + var instantiator = Instantiator{ + .store = &env.types, + .idents = &env.idents, + .var_map = &env.var_map, + .rigid_behavior = .fresh_flex, + }; + + const instantiated = try instantiator.instantiateVar(num_poly); + const resolved = env.types.resolveVar(instantiated); + + try std.testing.expect(resolved.desc.content.structure.num == .num_poly); + try std.testing.expect(resolved.desc.content.structure.num.num_poly != rigid_a); + } + + // Test int_poly + { + const int_poly = try env.types.freshFromContent(.{ .structure = .{ .num = .{ .int_poly = rigid_a } } }); + + var instantiator = Instantiator{ + .store = &env.types, + .idents = &env.idents, + .var_map = &env.var_map, + .rigid_behavior = .fresh_flex, + }; + + const instantiated = try instantiator.instantiateVar(int_poly); + const resolved = env.types.resolveVar(instantiated); + + try std.testing.expect(resolved.desc.content.structure.num == .int_poly); + try std.testing.expect(resolved.desc.content.structure.num.int_poly != rigid_a); + } + + // Test that concrete types remain unchanged + { + const u8_var = try env.types.freshFromContent(.{ .structure = .{ .num = Num.int_u8 } }); + + var instantiator = Instantiator{ + .store = &env.types, + .idents = &env.idents, + .var_map = &env.var_map, + .rigid_behavior = .fresh_flex, + }; + + const instantiated = try instantiator.instantiateVar(u8_var); + const resolved = env.types.resolveVar(instantiated); + + try std.testing.expect(resolved.desc.content.structure.num == .num_compact); + try std.testing.expectEqual(Num.Int.Precision.u8, resolved.desc.content.structure.num.num_compact.int); + } +} + +test "instantiate - box and list" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const rigid_a = try env.types.freshFromContent(try env.mkRigidVar("a")); + + // Test Box a + { + const box_var = try env.types.freshFromContent(.{ .structure = .{ .box = rigid_a } }); + + var instantiator = Instantiator{ + .store = &env.types, + .idents = &env.idents, + .var_map = &env.var_map, + .rigid_behavior = .fresh_flex, + }; + + const instantiated = try instantiator.instantiateVar(box_var); + const resolved = env.types.resolveVar(instantiated); + + try std.testing.expect(resolved.desc.content.structure == .box); + try std.testing.expect(resolved.desc.content.structure.box != rigid_a); + } + + // Test List a + { + const list_var = try env.types.freshFromContent(.{ .structure = .{ .list = rigid_a } }); + + var instantiator = Instantiator{ + .store = &env.types, + .idents = &env.idents, + .var_map = &env.var_map, + .rigid_behavior = .fresh_flex, + }; + + const instantiated = try instantiator.instantiateVar(list_var); + const resolved = env.types.resolveVar(instantiated); + + try std.testing.expect(resolved.desc.content.structure == .list); + try std.testing.expect(resolved.desc.content.structure.list != rigid_a); + } +} + +test "instantiate - multiple instantiations are independent" { + const gpa = std.testing.allocator; + var env = try TestEnv.init(gpa); + defer env.deinit(); + + const rigid_a = try env.types.freshFromContent(try env.mkRigidVar("a")); + const func_content = try env.mkFuncPure(&[_]Var{rigid_a}, rigid_a); + const original = try env.types.freshFromContent(func_content); + + // First instantiation + var var_map1 = std.AutoHashMap(Var, Var).init(gpa); + defer var_map1.deinit(); + + var instantiator1 = Instantiator{ + .store = &env.types, + .idents = &env.idents, + .var_map = &var_map1, + .rigid_behavior = .fresh_flex, + }; + + const inst1 = try instantiator1.instantiateVar(original); + + // Second instantiation + var var_map2 = std.AutoHashMap(Var, Var).init(gpa); + defer var_map2.deinit(); + + var instantiator2 = Instantiator{ + .store = &env.types, + .idents = &env.idents, + .var_map = &var_map2, + .rigid_behavior = .fresh_flex, + }; + + const inst2 = try instantiator2.instantiateVar(original); + + // The two instantiations should be completely independent + try std.testing.expect(inst1 != inst2); + + const resolved1 = env.types.resolveVar(inst1); + const func1 = resolved1.desc.content.structure.fn_pure; + const args1 = env.types.sliceVars(func1.args); + + const resolved2 = env.types.resolveVar(inst2); + const func2 = resolved2.desc.content.structure.fn_pure; + const args2 = env.types.sliceVars(func2.args); + + // Even the inner vars should be different + try std.testing.expect(args1[0] != args2[0]); + try std.testing.expect(func1.ret != func2.ret); +} + +/// Env to make test setup/teardown easier +const TestEnv = struct { + const Self = @This(); + + gpa: std.mem.Allocator, + types: Store, + idents: Ident.Store, + var_map: std.AutoHashMap(Var, Var), + + fn init(gpa: std.mem.Allocator) std.mem.Allocator.Error!Self { + return .{ + .gpa = gpa, + .types = try Store.initCapacity(gpa, 16, 8), + .idents = try Ident.Store.initCapacity(gpa, 16), + .var_map = std.AutoHashMap(Var, Var).init(gpa), + }; + } + + /// Deinit the test env, including deallocing the module_env from the heap + fn deinit(self: *Self) void { + self.types.deinit(); + self.idents.deinit(self.gpa); + self.var_map.deinit(); + } + + fn mkTypeIdent(self: *Self, name: []const u8) std.mem.Allocator.Error!TypeIdent { + const ident_idx = try self.idents.insert(self.gpa, Ident.for_text(name)); + return TypeIdent{ .ident_idx = ident_idx }; + } + + // helpers - alias // + + fn mkAlias(self: *Self, name: []const u8, backing_var: Var, args: []const Var) std.mem.Allocator.Error!Content { + return try self.types.mkAlias(try self.mkTypeIdent(name), backing_var, args); + } + + // helpers - rigid var // + + fn mkRigidVar(self: *Self, name: []const u8) std.mem.Allocator.Error!Content { + const ident_idx = try self.idents.insert(self.gpa, Ident.for_text(name)); + return Self.mkRigidVarFromIdent(ident_idx); + } + + fn mkRigidVarFromIdent(ident_idx: Ident.Idx) Content { + return .{ .rigid = Rigid.init(ident_idx) }; + } + + // helpers - tuple // + + fn mkTuple(self: *Self, slice: []const Var) std.mem.Allocator.Error!Content { + const elems_range = try self.types.appendVars(slice); + return Content{ .structure = .{ .tuple = .{ .elems = elems_range } } }; + } + + // helpers - records // + + fn mkRecordField(self: *Self, name: []const u8, var_: Var) std.mem.Allocator.Error!RecordField { + const ident_idx = try self.idents.insert(self.gpa, Ident.for_text(name)); + return Self.mkRecordFieldFromIdent(ident_idx, var_); + } + + fn mkRecordFieldFromIdent(ident_idx: Ident.Idx, var_: Var) RecordField { + return RecordField{ .name = ident_idx, .var_ = var_ }; + } + + const RecordInfo = struct { record: Record, content: Content }; + + fn mkRecord(self: *Self, fields: []const RecordField, ext_var: Var) std.mem.Allocator.Error!RecordInfo { + const fields_range = try self.types.appendRecordFields(fields); + const record = Record{ .fields = fields_range, .ext = ext_var }; + return .{ .content = Content{ .structure = .{ .record = record } }, .record = record }; + } + + fn mkRecordOpen(self: *Self, fields: []const RecordField) std.mem.Allocator.Error!RecordInfo { + const ext_var = try self.types.freshFromContent(.{ .flex = Flex.init() }); + return self.mkRecord(fields, ext_var); + } + + fn mkRecordClosed(self: *Self, fields: []const RecordField) std.mem.Allocator.Error!RecordInfo { + const ext_var = try self.types.freshFromContent(.{ .structure = .empty_record }); + return self.mkRecord(fields, ext_var); + } + + // helpers - func // + + fn mkFuncPure(self: *Self, args: []const Var, ret: Var) std.mem.Allocator.Error!Content { + return try self.types.mkFuncPure(args, ret); + } + + // helpers - tag union // + + const TagUnionInfo = struct { tag_union: TagUnion, content: Content }; + + fn mkTagArgs(self: *Self, args: []const Var) std.mem.Allocator.Error!VarSafeList.Range { + return try self.types.appendVars(args); + } + + fn mkTag(self: *Self, name: []const u8, args: []const Var) std.mem.Allocator.Error!Tag { + const ident_idx = try self.idents.insert(self.gpa, Ident.for_text(name)); + return Tag{ .name = ident_idx, .args = try self.types.appendVars(args) }; + } + + fn mkTagUnion(self: *Self, tags: []const Tag, ext_var: Var) std.mem.Allocator.Error!TagUnionInfo { + const tags_range = try self.types.appendTags(tags); + const tag_union = TagUnion{ .tags = tags_range, .ext = ext_var }; + return .{ .content = Content{ .structure = .{ .tag_union = tag_union } }, .tag_union = tag_union }; + } + + fn mkTagUnionOpen(self: *Self, tags: []const Tag) std.mem.Allocator.Error!TagUnionInfo { + const ext_var = try self.types.freshFromContent(.{ .flex = Flex.init() }); + return self.mkTagUnion(tags, ext_var); + } + + fn mkTagUnionClosed(self: *Self, tags: []const Tag) std.mem.Allocator.Error!TagUnionInfo { + const ext_var = try self.types.freshFromContent(.{ .structure = .empty_tag_union }); + return self.mkTagUnion(tags, ext_var); + } +}; diff --git a/src/types/test_rigid_instantiation.zig b/src/types/test_rigid_instantiation.zig deleted file mode 100644 index 59bc9ea079..0000000000 --- a/src/types/test_rigid_instantiation.zig +++ /dev/null @@ -1,106 +0,0 @@ -//! Tests for rigid variable instantiation in the type system. -//! -//! This module contains tests that verify the correct behavior of rigid type -//! variables during instantiation, particularly for polymorphic functions -//! where type variables need to be properly instantiated with concrete types. - -const std = @import("std"); -const base = @import("base"); - -const Store = @import("store.zig").Store; -const Instantiate = @import("instantiate.zig").Instantiate; -const Content = @import("types.zig").Content; - -test "rigid variables need instantiation - multiple type parameters" { - const gpa = std.testing.allocator; - - var store = try Store.init(gpa); - defer store.deinit(); - - var idents = try base.Ident.Store.initCapacity(gpa, 256); - defer idents.deinit(gpa); - - var var_subs = Instantiate.SeenVars.init(gpa); - defer var_subs.deinit(); - - var rigid_var_subs = try Instantiate.RigidToFlexSubs.init(gpa); - defer rigid_var_subs.deinit(gpa); - - var instantiate = Instantiate.init(&store, &idents, &var_subs); - var instantiate_ctx = Instantiate.Ctx{ .rigid_var_subs = &rigid_var_subs }; - - const a_ident = try idents.insert(gpa, base.Ident.for_text("a")); - const b_ident = try idents.insert(gpa, base.Ident.for_text("a")); - - // Create rigid type variables 'a' and 'b' (like in `swap : (a, b) -> (b, a)`) - const rigid_a = try store.freshFromContent(.{ .rigid_var = a_ident }); - const rigid_b = try store.freshFromContent(.{ .rigid_var = b_ident }); - - // Create tuple types for the argument and return - const arg_elems_range = try store.appendVars(&.{ rigid_a, rigid_b }); - const arg_tuple_var = try store.freshFromContent(Content{ - .structure = .{ .tuple = .{ .elems = arg_elems_range } }, - }); - - const ret_elems_range = try store.appendVars(&.{ rigid_b, rigid_a }); - const ret_tuple_var = try store.freshFromContent(Content{ - .structure = .{ .tuple = .{ .elems = ret_elems_range } }, - }); - - // Create the polymorphic function type: (a, b) -> (b, a) - const func_content = try store.mkFuncPure(&.{arg_tuple_var}, ret_tuple_var); - const func_var = try store.freshFromContent(func_content); - - // Verify the function needs instantiation - try std.testing.expect(store.needsInstantiation(func_var)); - - var empty_store = try base.Ident.Store.initCapacity(gpa, 10); - defer empty_store.deinit(gpa); - - // Instantiate for first use - const inst1_var = try instantiate.instantiateVar(func_var, &instantiate_ctx); - try std.testing.expect(inst1_var != func_var); - - // Clear maps between instantiation runs - var_subs.clearRetainingCapacity(); - rigid_var_subs.items.clearRetainingCapacity(); - - // Instantiate for second use - const inst2_var = try instantiate.instantiateVar(func_var, &instantiate_ctx); - try std.testing.expect(inst2_var != func_var); - try std.testing.expect(inst2_var != inst1_var); - - // TODO: Test different rigid instantiation behavior -} - -test "needsInstantiation" { - const gpa = std.testing.allocator; - - var store = try Store.init(gpa); - defer store.deinit(); - - var idents = try base.Ident.Store.initCapacity(gpa, 256); - defer idents.deinit(gpa); - - var var_subs = Instantiate.SeenVars.init(gpa); - defer var_subs.deinit(); - - var rigid_var_subs = try Instantiate.RigidToFlexSubs.init(gpa); - defer rigid_var_subs.deinit(gpa); - - const a_ident = try idents.insert(gpa, base.Ident.for_text("a")); - - // Test that both rigid and flex variables need instantiation - const rigid_var = try store.freshFromContent(.{ .rigid_var = a_ident }); - try std.testing.expect(store.needsInstantiation(rigid_var)); - - const flex_var = try store.fresh(); - try std.testing.expect(store.needsInstantiation(flex_var)); - - // Test that concrete types don't need instantiation - const str_var = try store.freshFromContent(Content{ .structure = .str }); - try std.testing.expect(!store.needsInstantiation(str_var)); - - const int_var = try store.freshFromContent(Content{ .structure = .{ .num = .{ .int_precision = .u32 } } }); - try std.testing.expect(!store.needsInstantiation(int_var)); -} diff --git a/src/types/types.zig b/src/types/types.zig index bd2acb0edb..421b80dc1a 100644 --- a/src/types/types.zig +++ b/src/types/types.zig @@ -102,7 +102,6 @@ pub const Descriptor = struct { content: Content, rank: Rank, mark: Mark }; pub const Rank = enum(u4) { /// When the corresponding type is generic, like in `List.len`. generalized = 0, - top_level = 1, _, @@ -110,6 +109,21 @@ pub const Rank = enum(u4) { pub fn min(a: Rank, b: Rank) Rank { return @enumFromInt(@min(@intFromEnum(a), @intFromEnum(b))); } + + /// Get the lowest rank + pub fn max(a: Rank, b: Rank) Rank { + return @enumFromInt(@max(@intFromEnum(a), @intFromEnum(b))); + } + + /// Get the next rank + pub fn next(a: Rank) Rank { + return @enumFromInt(@intFromEnum(a) + 1); + } + + /// Get the prev rank + pub fn prev(a: Rank) Rank { + return @enumFromInt(@intFromEnum(a) - 1); + } }; /// A type variable mark @@ -139,8 +153,8 @@ pub const Mark = enum(u32) { pub const Content = union(enum) { const Self = @This(); - flex_var: ?Ident.Idx, - rigid_var: Ident.Idx, + flex: Flex, + rigid: Rigid, alias: Alias, structure: FlatType, err, @@ -193,6 +207,57 @@ pub const Content = union(enum) { } }; +// flex // + +/// A flex var, with optional static dispatch constraints +pub const Flex = struct { + name: ?Ident.Idx, + constraints: StaticDispatchConstraint.SafeMultiList.Range, + + pub fn init() Flex { + return .{ + .name = null, + .constraints = StaticDispatchConstraint.SafeMultiList.Range.empty(), + }; + } + + pub fn withName(self: Flex, name: ?Ident.Idx) Flex { + return .{ + .name = name, + .constraints = self.constraints, + }; + } + + pub fn withConstraints(self: Flex, constraints: StaticDispatchConstraint.SafeMultiList.Range) Flex { + return .{ + .name = self.name, + .constraints = constraints, + }; + } +}; + +// rigid // + +/// A rigid var, with optional static dispatch constraints +pub const Rigid = struct { + name: Ident.Idx, + constraints: StaticDispatchConstraint.SafeMultiList.Range, + + pub fn init(name: Ident.Idx) Rigid { + return .{ + .name = name, + .constraints = StaticDispatchConstraint.SafeMultiList.Range.empty(), + }; + } + + pub fn withConstraints(self: Rigid, constraints: StaticDispatchConstraint.SafeMultiList.Range) Rigid { + return .{ + .name = self.name, + .constraints = constraints, + }; + } +}; + // alias // /// A named alias to a different type @@ -230,15 +295,14 @@ pub const FlatType = union(enum) { box: Var, list: Var, list_unbound, + record: Record, record_unbound: RecordField.SafeMultiList.Range, - record_poly: struct { record: Record, var_: Var }, tuple: Tuple, num: Num, nominal_type: NominalType, fn_pure: Func, fn_effectful: Func, fn_unbound: Func, - record: Record, empty_record, tag_union: TagUnion, empty_tag_union, @@ -272,16 +336,30 @@ pub const Tuple = struct { /// form always wins: we discard the polymorphic wrapper and store the /// concrete, memory-efficient version instead. pub const Num = union(enum) { - num_unbound: IntRequirements, + // These are Num(a) + // ^^^ + num_poly: Var, + num_unbound: NumRequirements, + + // These are Num(int) or Num(frac) + // ^^^ ^^^^ + int_poly: Var, int_unbound: IntRequirements, + frac_poly: Var, frac_unbound: FracRequirements, - num_poly: struct { var_: Var, requirements: IntRequirements }, - int_poly: struct { var_: Var, requirements: IntRequirements }, - frac_poly: struct { var_: Var, requirements: FracRequirements }, - int_precision: Int.Precision, // TODO instead of storing this, can we just always store a num_compact instead? - frac_precision: Frac.Precision, // TODO instead of storing this, can we just always store a num_compact instead? + + // These are Num(Int(Signed8)) or Num(Frac(Decimal)) + // ^^^^^^^ ^^^^^^^ + int_precision: Int.Precision, + frac_precision: Frac.Precision, + + // This is the whole Num(Int(Signed8)), compacted into a single variable + // ^^^^^^^^^^^^^^^^ num_compact: Compact, + /// Represents requirements for number + pub const NumRequirements = struct { int_requirements: IntRequirements, frac_requirements: FracRequirements }; + /// Represents a compact number pub const Compact = union(enum) { const Self = @This(); @@ -325,11 +403,48 @@ pub const Num = union(enum) { // The lowest number of bits that can represent the decimal value of the Int literal *excluding* its sign. bits_needed: u8, + // True if the literal is an exact power of two (e.g., 1, 2, 4, ..., 2^k) on a boundary of a signed int. + // This is crucial to allow the single negative boundary value −2^(N−1) when bits_needed == N. + // When unifying multiple literals, we AND this flag to remain conservative. + is_minimum_signed: bool, + + pub fn init() @This() { + return .{ + .sign_needed = false, + .bits_needed = 0, + .is_minimum_signed = false, + }; + } + /// Unifies two IntRequirements, returning the most restrictive combination pub fn unify(self: IntRequirements, other: IntRequirements) IntRequirements { return IntRequirements{ .sign_needed = self.sign_needed or other.sign_needed, .bits_needed = @max(self.bits_needed, other.bits_needed), + .is_minimum_signed = self.is_minimum_signed and other.is_minimum_signed, + }; + } + + /// Create Requirements from a u128 value and whether it's negated + pub fn fromIntLiteral(val: u128, is_negated: bool) IntRequirements { + const bits_need = Int.BitsNeeded.fromValue(val); + return IntRequirements{ + .sign_needed = is_negated, + .bits_needed = bits_need.toBits(), + .is_minimum_signed = is_negated and IntRequirements.isMinimumSigned(val), + }; + } + + /// Check if a value is a minimum signed value. + /// These need special consideration + pub fn isMinimumSigned(val: u128) bool { + return switch (val) { + @as(u128, @intCast(std.math.maxInt(i8))) + 1 => true, + @as(u128, @intCast(std.math.maxInt(i16))) + 1 => true, + @as(u128, @intCast(std.math.maxInt(i32))) + 1 => true, + @as(u128, @intCast(std.math.maxInt(i64))) + 1 => true, + @as(u128, @intCast(std.math.maxInt(i128))) + 1 => true, + else => false, }; } }; @@ -353,6 +468,10 @@ pub const Num = union(enum) { fits_in_f32: bool, fits_in_dec: bool, + pub fn init() @This() { + return .{ .fits_in_f32 = true, .fits_in_dec = true }; + } + /// Unifies two FracRequirements, returning the intersection of capabilities pub fn unify(self: FracRequirements, other: FracRequirements) FracRequirements { return FracRequirements{ @@ -812,3 +931,24 @@ test "BitsNeeded.fromValue calculates correct bits for various values" { try std.testing.expectEqual(@as(u8, 65), BitsNeeded.@"65_to_127".toBits()); try std.testing.expectEqual(@as(u8, 128), BitsNeeded.@"128".toBits()); } + +// content // + +/// Represents a static dispatch constraints on a variable +/// +/// sort : List(a) -> List(a) where [a.ord : a -> Ord] +/// +/// TODO: This is WIP, likely to change during real implementation +pub const StaticDispatchConstraint = struct { + const Self = @This(); + + /// the dispatch fn name + fn_name: Ident.Idx, + /// the dispatch fn args + fn_args: Var.SafeList.NonEmptyRange, + /// the dispatch fn ret + fn_ret: Var, + + /// A safe multi list of static dispatch constraints + pub const SafeMultiList = MkSafeMultiList(Self); +}; diff --git a/test/playground-integration/main.zig b/test/playground-integration/main.zig index fb11bd4df0..e78ed26e49 100644 --- a/test/playground-integration/main.zig +++ b/test/playground-integration/main.zig @@ -903,7 +903,7 @@ pub fn main() !void { if (std.mem.eql(u8, arg, "--verbose")) { verbose_mode = true; } else if (std.mem.eql(u8, arg, "--help")) { - try stdout.print("Usage: playground-test [options] [wasm-path]\n", .{}); + try stdout.print("Usage: test-playground [options] [wasm-path]\n", .{}); try stdout.print("Options:\n", .{}); try stdout.print(" --verbose Enable verbose mode\n", .{}); try stdout.print(" --wasm-path PATH Path to the playground WASM file\n", .{}); @@ -1087,7 +1087,7 @@ pub fn main() !void { get_hover_info_steps[2] = .{ .message = .{ .type = "GET_HOVER_INFO", .identifier = "num", .line = 7, .ch = 1 }, .expected_status = "SUCCESS", - .expected_hover_info_contains = "I32", + .expected_hover_info_contains = "Num(Int(Signed32))", }; try test_cases.append(.{ .name = "GET_HOVER_INFO - Specific Type Query", diff --git a/test/serialization_size_check.zig b/test/serialization_size_check.zig new file mode 100644 index 0000000000..1d2a7950f2 --- /dev/null +++ b/test/serialization_size_check.zig @@ -0,0 +1,99 @@ +//! Checks that all Serialized types have the same size on 32-bit and 64-bit platforms. +//! +//! This is critical because we serialize these types and expect them to be portable +//! across architectures. If a Serialized type contains pointers/slices, it will have +//! different sizes on different platforms, which breaks our serialization. +//! +//! This test uses compile-time assertions to verify that all Serialized types match +//! their expected platform-independent sizes. The build will fail if any type has +//! the wrong size, preventing accidental introduction of pointers/slices. +//! +//! Run with: zig build test-serialization-sizes + +const std = @import("std"); +const builtin = @import("builtin"); +const collections = @import("collections"); +const can = @import("can"); + +const ModuleEnv = can.ModuleEnv; +const NodeStore = can.CIR.NodeStore; +const SafeList = collections.SafeList; +const SafeMultiList = collections.SafeMultiList; + +const TestStruct = struct { a: u32, b: u8 }; +const Node = can.CIR.Node; + +// Expected sizes for Serialized types (platform-independent, matching 32-bit wasm32) +// NOTE: These constants must be updated if the Serialized type definitions change. +// When you modify a Serialized type, rebuild with `zig build test-serialization-sizes` +// and update these constants based on the compile error messages. +const expected_safelist_u8_size = 24; +const expected_safelist_u32_size = 24; +const expected_safemultilist_teststruct_size = 24; +const expected_safemultilist_node_size = 24; +const expected_moduleenv_size = 600; // Platform-independent size +const expected_nodestore_size = 96; // Platform-independent size + +// Compile-time assertions - build will fail if sizes don't match expected values +comptime { + const actual_safelist_u8 = @sizeOf(SafeList(u8).Serialized); + if (actual_safelist_u8 != expected_safelist_u8_size) { + @compileError(std.fmt.comptimePrint( + "SafeList(u8).Serialized size mismatch: expected {d}, got {d}. " ++ + "This indicates the type contains pointers/slices. Update the type definition or the expected size constant.", + .{ expected_safelist_u8_size, actual_safelist_u8 }, + )); + } + + const actual_safelist_u32 = @sizeOf(SafeList(u32).Serialized); + if (actual_safelist_u32 != expected_safelist_u32_size) { + @compileError(std.fmt.comptimePrint( + "SafeList(u32).Serialized size mismatch: expected {d}, got {d}. " ++ + "This indicates the type contains pointers/slices. Update the type definition or the expected size constant.", + .{ expected_safelist_u32_size, actual_safelist_u32 }, + )); + } + + const actual_safemultilist_teststruct = @sizeOf(SafeMultiList(TestStruct).Serialized); + if (actual_safemultilist_teststruct != expected_safemultilist_teststruct_size) { + @compileError(std.fmt.comptimePrint( + "SafeMultiList(TestStruct).Serialized size mismatch: expected {d}, got {d}. " ++ + "This indicates the type contains pointers/slices. Update the type definition or the expected size constant.", + .{ expected_safemultilist_teststruct_size, actual_safemultilist_teststruct }, + )); + } + + const actual_safemultilist_node = @sizeOf(SafeMultiList(Node).Serialized); + if (actual_safemultilist_node != expected_safemultilist_node_size) { + @compileError(std.fmt.comptimePrint( + "SafeMultiList(Node).Serialized size mismatch: expected {d}, got {d}. " ++ + "This indicates the type contains pointers/slices. Update the type definition or the expected size constant.", + .{ expected_safemultilist_node_size, actual_safemultilist_node }, + )); + } + + const actual_moduleenv = @sizeOf(ModuleEnv.Serialized); + if (actual_moduleenv != expected_moduleenv_size) { + @compileError(std.fmt.comptimePrint( + "ModuleEnv.Serialized size mismatch: expected {d}, got {d}. " ++ + "This indicates the type contains pointers/slices. Update the type definition or the expected size constant.", + .{ expected_moduleenv_size, actual_moduleenv }, + )); + } + + const actual_nodestore = @sizeOf(NodeStore.Serialized); + if (actual_nodestore != expected_nodestore_size) { + @compileError(std.fmt.comptimePrint( + "NodeStore.Serialized size mismatch: expected {d}, got {d}. " ++ + "This indicates the type contains pointers/slices. Update the type definition or the expected size constant.", + .{ expected_nodestore_size, actual_nodestore }, + )); + } +} + +pub fn main() void { + // If we compile successfully on both platforms, print success + if (builtin.os.tag != .freestanding) { + std.debug.print("✓ Serialization size check passed - all types have correct platform-independent sizes\n", .{}); + } +} diff --git a/test/snapshots/001.md b/test/snapshots/001.md index da221fd98b..ac9759f235 100644 --- a/test/snapshots/001.md +++ b/test/snapshots/001.md @@ -1,15 +1,10 @@ # META ~~~ini description=Example to develop the snapshot methodology, includes FORMATTED section -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [ -# some crazy formatting - foo, - ] - foo = "one" @@ -20,33 +15,22 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:12-1:13), -LowerIdent(3:2-3:5),Comma(3:5-3:6), -CloseSquare(4:6-4:7), -LowerIdent(6:1-6:4),OpAssign(6:5-6:6), -StringStart(8:5-8:6),StringPart(8:6-8:9),StringEnd(8:9-8:10), -EndOfFile(9:1-9:1), +LowerIdent(1:1-1:4),OpAssign(1:5-1:6), +StringStart(3:5-3:6),StringPart(3:6-3:9),StringEnd(3:9-3:10), +EndOfFile(4:1-4:1), ~~~ # PARSE ~~~clojure -(file @1.1-8.10 - (module @1.1-4.7 - (exposes @1.12-4.7 - (exposed-lower-ident @3.2-3.5 - (text "foo")))) +(file @1.1-3.10 + (type-module @1.1-1.4) (statements - (s-decl @6.1-8.10 - (p-ident @6.1-6.4 (raw "foo")) - (e-string @8.5-8.10 - (e-string-part @8.6-8.9 (raw "one")))))) + (s-decl @1.1-3.10 + (p-ident @1.1-1.4 (raw "foo")) + (e-string @3.5-3.10 + (e-string-part @3.6-3.9 (raw "one")))))) ~~~ # FORMATTED ~~~roc -module [ - # some crazy formatting - foo, -] - foo = "one" @@ -55,15 +39,15 @@ foo = ~~~clojure (can-ir (d-let - (p-assign @6.1-6.4 (ident "foo")) - (e-string @8.5-8.10 - (e-literal @8.6-8.9 (string "one"))))) + (p-assign @1.1-1.4 (ident "foo")) + (e-string @3.5-3.10 + (e-literal @3.6-3.9 (string "one"))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @6.1-6.4 (type "Str"))) + (patt @1.1-1.4 (type "Str"))) (expressions - (expr @8.5-8.10 (type "Str")))) + (expr @3.5-3.10 (type "Str")))) ~~~ diff --git a/test/snapshots/add_var_with_spaces.md b/test/snapshots/add_var_with_spaces.md index f3ef4ec106..ca93ca2ab3 100644 --- a/test/snapshots/add_var_with_spaces.md +++ b/test/snapshots/add_var_with_spaces.md @@ -1,22 +1,20 @@ # META ~~~ini description=Add a variable with spaces -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [add2] - add2 = x + 2 ~~~ # EXPECTED -UNDEFINED VARIABLE - add_var_with_spaces.md:3:8:3:9 +UNDEFINED VARIABLE - add_var_with_spaces.md:1:8:1:9 # PROBLEMS **UNDEFINED VARIABLE** Nothing is named `x` in this scope. Is there an `import` or `exposing` missing up-top? -**add_var_with_spaces.md:3:8:3:9:** +**add_var_with_spaces.md:1:8:1:9:** ```roc add2 = x + 2 ``` @@ -25,44 +23,38 @@ add2 = x + 2 # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:13),CloseSquare(1:13-1:14), -LowerIdent(3:1-3:5),OpAssign(3:6-3:7),LowerIdent(3:8-3:9),OpPlus(3:10-3:11),Int(3:17-3:18), -EndOfFile(4:1-4:1), +LowerIdent(1:1-1:5),OpAssign(1:6-1:7),LowerIdent(1:8-1:9),OpPlus(1:10-1:11),Int(1:17-1:18), +EndOfFile(2:1-2:1), ~~~ # PARSE ~~~clojure -(file @1.1-3.18 - (module @1.1-1.14 - (exposes @1.8-1.14 - (exposed-lower-ident @1.9-1.13 - (text "add2")))) +(file @1.1-1.18 + (type-module @1.1-1.5) (statements - (s-decl @3.1-3.18 - (p-ident @3.1-3.5 (raw "add2")) - (e-binop @3.8-3.18 (op "+") - (e-ident @3.8-3.9 (raw "x")) - (e-int @3.17-3.18 (raw "2")))))) + (s-decl @1.1-1.18 + (p-ident @1.1-1.5 (raw "add2")) + (e-binop @1.8-1.18 (op "+") + (e-ident @1.8-1.9 (raw "x")) + (e-int @1.17-1.18 (raw "2")))))) ~~~ # FORMATTED ~~~roc -module [add2] - add2 = x + 2 ~~~ # CANONICALIZE ~~~clojure (can-ir (d-let - (p-assign @3.1-3.5 (ident "add2")) - (e-binop @3.8-3.18 (op "add") + (p-assign @1.1-1.5 (ident "add2")) + (e-binop @1.8-1.18 (op "add") (e-runtime-error (tag "ident_not_in_scope")) - (e-int @3.17-3.18 (value "2"))))) + (e-num @1.17-1.18 (value "2"))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @3.1-3.5 (type "Num(_size)"))) + (patt @1.1-1.5 (type "Error"))) (expressions - (expr @3.8-3.18 (type "Num(_size)")))) + (expr @1.8-1.18 (type "Error")))) ~~~ diff --git a/test/snapshots/annotations.md b/test/snapshots/annotations.md index 7696cd8da9..589e455074 100644 --- a/test/snapshots/annotations.md +++ b/test/snapshots/annotations.md @@ -1,12 +1,10 @@ # META ~~~ini description=Example of a nominal tag union with a payload -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - Pair(a) := [Pair(a, a)] pairU64 : Pair(U64) @@ -29,20 +27,15 @@ failPairDiffTypes2 = Pair.Pair(1, "str") mkPairInvalid : a, b -> Pair(a) mkPairInvalid = |x, y| Pair.Pair(x, y) - -mkPairInferred = |x, y| Pair.Pair(x, y) - -failWithImplicit = mkPairInferred("str", 2) ~~~ # EXPECTED -TYPE MISMATCH - annotations.md:18:28:18:28 -INVALID NOMINAL TAG - annotations.md:21:22:21:41 -INVALID NOMINAL TAG - annotations.md:24:24:24:39 -TYPE MISMATCH - annotations.md:28:35:28:35 +TYPE MISMATCH - annotations.md:16:28:16:28 +INVALID NOMINAL TAG - annotations.md:19:22:19:41 +INVALID NOMINAL TAG - annotations.md:22:24:22:39 # PROBLEMS **TYPE MISMATCH** The first and second arguments to `mkPair` must have compatible types, but they are incompatible in this call: -**annotations.md:18:28:** +**annotations.md:16:28:** ```roc failPairDiffTypes = mkPair("1", 2) ``` @@ -58,7 +51,7 @@ But the second argument has the type: **INVALID NOMINAL TAG** I'm having trouble with this nominal tag: -**annotations.md:21:22:21:41:** +**annotations.md:19:22:19:41:** ```roc failPairDiffTypes2 = Pair.Pair(1, "str") ``` @@ -67,12 +60,12 @@ failPairDiffTypes2 = Pair.Pair(1, "str") The tag is: _Pair(Num(_size), Str)_ -But it should be: - _Pair(Num(_size2), Num(_size3))_ +But the nominal type needs it to be: + _Pair(Num(_size), Num(_size2))_ **INVALID NOMINAL TAG** I'm having trouble with this nominal tag: -**annotations.md:24:24:24:39:** +**annotations.md:22:24:22:39:** ```roc mkPairInvalid = |x, y| Pair.Pair(x, y) ``` @@ -81,168 +74,131 @@ mkPairInvalid = |x, y| Pair.Pair(x, y) The tag is: _Pair(a, b)_ -But it should be: +But the nominal type needs it to be: _Pair(a, a)_ -**TYPE MISMATCH** -The first and second arguments to `mkPairInferred` must have compatible types, but they are incompatible in this call: -**annotations.md:28:35:** -```roc -failWithImplicit = mkPairInferred("str", 2) -``` - ^^^^^ ^ - -The first argument has the type: - _Str_ - -But the second argument has the type: - _Num(_size)_ - -`mkPairInferred` needs these arguments to have compatible types. - # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -UpperIdent(3:1-3:5),NoSpaceOpenRound(3:5-3:6),LowerIdent(3:6-3:7),CloseRound(3:7-3:8),OpColonEqual(3:9-3:11),OpenSquare(3:12-3:13),UpperIdent(3:13-3:17),NoSpaceOpenRound(3:17-3:18),LowerIdent(3:18-3:19),Comma(3:19-3:20),LowerIdent(3:21-3:22),CloseRound(3:22-3:23),CloseSquare(3:23-3:24), -LowerIdent(5:1-5:8),OpColon(5:9-5:10),UpperIdent(5:11-5:15),NoSpaceOpenRound(5:15-5:16),UpperIdent(5:16-5:19),CloseRound(5:19-5:20), -LowerIdent(6:1-6:8),OpAssign(6:9-6:10),UpperIdent(6:11-6:15),NoSpaceDotUpperIdent(6:15-6:20),NoSpaceOpenRound(6:20-6:21),Int(6:21-6:22),Comma(6:22-6:23),Int(6:24-6:25),CloseRound(6:25-6:26), -LowerIdent(8:1-8:8),OpColon(8:9-8:10),UpperIdent(8:11-8:15),NoSpaceOpenRound(8:15-8:16),UpperIdent(8:16-8:19),CloseRound(8:19-8:20), -LowerIdent(9:1-9:8),OpAssign(9:9-9:10),UpperIdent(9:11-9:15),NoSpaceDotUpperIdent(9:15-9:20),NoSpaceOpenRound(9:20-9:21),StringStart(9:21-9:22),StringPart(9:22-9:27),StringEnd(9:27-9:28),Comma(9:28-9:29),StringStart(9:30-9:31),StringPart(9:31-9:36),StringEnd(9:36-9:37),CloseRound(9:37-9:38), -LowerIdent(11:1-11:7),OpColon(11:8-11:9),LowerIdent(11:10-11:11),Comma(11:11-11:12),LowerIdent(11:13-11:14),OpArrow(11:15-11:17),UpperIdent(11:18-11:22),NoSpaceOpenRound(11:22-11:23),LowerIdent(11:23-11:24),CloseRound(11:24-11:25), -LowerIdent(12:1-12:7),OpAssign(12:8-12:9),OpBar(12:10-12:11),LowerIdent(12:11-12:12),Comma(12:12-12:13),LowerIdent(12:14-12:15),OpBar(12:15-12:16),UpperIdent(12:17-12:21),NoSpaceDotUpperIdent(12:21-12:26),NoSpaceOpenRound(12:26-12:27),LowerIdent(12:27-12:28),Comma(12:28-12:29),LowerIdent(12:30-12:31),CloseRound(12:31-12:32), -LowerIdent(14:1-14:20),OpColon(14:21-14:22),UpperIdent(14:23-14:27),NoSpaceOpenRound(14:27-14:28),UpperIdent(14:28-14:30),CloseRound(14:30-14:31), -LowerIdent(15:1-15:20),OpAssign(15:21-15:22),LowerIdent(15:23-15:29),NoSpaceOpenRound(15:29-15:30),Int(15:30-15:31),Comma(15:31-15:32),Int(15:33-15:34),CloseRound(15:34-15:35), -LowerIdent(17:1-17:18),OpColon(17:19-17:20),UpperIdent(17:21-17:25),NoSpaceOpenRound(17:25-17:26),UpperIdent(17:26-17:28),CloseRound(17:28-17:29), -LowerIdent(18:1-18:18),OpAssign(18:19-18:20),LowerIdent(18:21-18:27),NoSpaceOpenRound(18:27-18:28),StringStart(18:28-18:29),StringPart(18:29-18:30),StringEnd(18:30-18:31),Comma(18:31-18:32),Int(18:33-18:34),CloseRound(18:34-18:35), -LowerIdent(20:1-20:19),OpColon(20:20-20:21),UpperIdent(20:22-20:26),NoSpaceOpenRound(20:26-20:27),UpperIdent(20:27-20:30),CloseRound(20:30-20:31), -LowerIdent(21:1-21:19),OpAssign(21:20-21:21),UpperIdent(21:22-21:26),NoSpaceDotUpperIdent(21:26-21:31),NoSpaceOpenRound(21:31-21:32),Int(21:32-21:33),Comma(21:33-21:34),StringStart(21:35-21:36),StringPart(21:36-21:39),StringEnd(21:39-21:40),CloseRound(21:40-21:41), -LowerIdent(23:1-23:14),OpColon(23:15-23:16),LowerIdent(23:17-23:18),Comma(23:18-23:19),LowerIdent(23:20-23:21),OpArrow(23:22-23:24),UpperIdent(23:25-23:29),NoSpaceOpenRound(23:29-23:30),LowerIdent(23:30-23:31),CloseRound(23:31-23:32), -LowerIdent(24:1-24:14),OpAssign(24:15-24:16),OpBar(24:17-24:18),LowerIdent(24:18-24:19),Comma(24:19-24:20),LowerIdent(24:21-24:22),OpBar(24:22-24:23),UpperIdent(24:24-24:28),NoSpaceDotUpperIdent(24:28-24:33),NoSpaceOpenRound(24:33-24:34),LowerIdent(24:34-24:35),Comma(24:35-24:36),LowerIdent(24:37-24:38),CloseRound(24:38-24:39), -LowerIdent(26:1-26:15),OpAssign(26:16-26:17),OpBar(26:18-26:19),LowerIdent(26:19-26:20),Comma(26:20-26:21),LowerIdent(26:22-26:23),OpBar(26:23-26:24),UpperIdent(26:25-26:29),NoSpaceDotUpperIdent(26:29-26:34),NoSpaceOpenRound(26:34-26:35),LowerIdent(26:35-26:36),Comma(26:36-26:37),LowerIdent(26:38-26:39),CloseRound(26:39-26:40), -LowerIdent(28:1-28:17),OpAssign(28:18-28:19),LowerIdent(28:20-28:34),NoSpaceOpenRound(28:34-28:35),StringStart(28:35-28:36),StringPart(28:36-28:39),StringEnd(28:39-28:40),Comma(28:40-28:41),Int(28:42-28:43),CloseRound(28:43-28:44), -EndOfFile(29:1-29:1), +UpperIdent(1:1-1:5),NoSpaceOpenRound(1:5-1:6),LowerIdent(1:6-1:7),CloseRound(1:7-1:8),OpColonEqual(1:9-1:11),OpenSquare(1:12-1:13),UpperIdent(1:13-1:17),NoSpaceOpenRound(1:17-1:18),LowerIdent(1:18-1:19),Comma(1:19-1:20),LowerIdent(1:21-1:22),CloseRound(1:22-1:23),CloseSquare(1:23-1:24), +LowerIdent(3:1-3:8),OpColon(3:9-3:10),UpperIdent(3:11-3:15),NoSpaceOpenRound(3:15-3:16),UpperIdent(3:16-3:19),CloseRound(3:19-3:20), +LowerIdent(4:1-4:8),OpAssign(4:9-4:10),UpperIdent(4:11-4:15),NoSpaceDotUpperIdent(4:15-4:20),NoSpaceOpenRound(4:20-4:21),Int(4:21-4:22),Comma(4:22-4:23),Int(4:24-4:25),CloseRound(4:25-4:26), +LowerIdent(6:1-6:8),OpColon(6:9-6:10),UpperIdent(6:11-6:15),NoSpaceOpenRound(6:15-6:16),UpperIdent(6:16-6:19),CloseRound(6:19-6:20), +LowerIdent(7:1-7:8),OpAssign(7:9-7:10),UpperIdent(7:11-7:15),NoSpaceDotUpperIdent(7:15-7:20),NoSpaceOpenRound(7:20-7:21),StringStart(7:21-7:22),StringPart(7:22-7:27),StringEnd(7:27-7:28),Comma(7:28-7:29),StringStart(7:30-7:31),StringPart(7:31-7:36),StringEnd(7:36-7:37),CloseRound(7:37-7:38), +LowerIdent(9:1-9:7),OpColon(9:8-9:9),LowerIdent(9:10-9:11),Comma(9:11-9:12),LowerIdent(9:13-9:14),OpArrow(9:15-9:17),UpperIdent(9:18-9:22),NoSpaceOpenRound(9:22-9:23),LowerIdent(9:23-9:24),CloseRound(9:24-9:25), +LowerIdent(10:1-10:7),OpAssign(10:8-10:9),OpBar(10:10-10:11),LowerIdent(10:11-10:12),Comma(10:12-10:13),LowerIdent(10:14-10:15),OpBar(10:15-10:16),UpperIdent(10:17-10:21),NoSpaceDotUpperIdent(10:21-10:26),NoSpaceOpenRound(10:26-10:27),LowerIdent(10:27-10:28),Comma(10:28-10:29),LowerIdent(10:30-10:31),CloseRound(10:31-10:32), +LowerIdent(12:1-12:20),OpColon(12:21-12:22),UpperIdent(12:23-12:27),NoSpaceOpenRound(12:27-12:28),UpperIdent(12:28-12:30),CloseRound(12:30-12:31), +LowerIdent(13:1-13:20),OpAssign(13:21-13:22),LowerIdent(13:23-13:29),NoSpaceOpenRound(13:29-13:30),Int(13:30-13:31),Comma(13:31-13:32),Int(13:33-13:34),CloseRound(13:34-13:35), +LowerIdent(15:1-15:18),OpColon(15:19-15:20),UpperIdent(15:21-15:25),NoSpaceOpenRound(15:25-15:26),UpperIdent(15:26-15:28),CloseRound(15:28-15:29), +LowerIdent(16:1-16:18),OpAssign(16:19-16:20),LowerIdent(16:21-16:27),NoSpaceOpenRound(16:27-16:28),StringStart(16:28-16:29),StringPart(16:29-16:30),StringEnd(16:30-16:31),Comma(16:31-16:32),Int(16:33-16:34),CloseRound(16:34-16:35), +LowerIdent(18:1-18:19),OpColon(18:20-18:21),UpperIdent(18:22-18:26),NoSpaceOpenRound(18:26-18:27),UpperIdent(18:27-18:30),CloseRound(18:30-18:31), +LowerIdent(19:1-19:19),OpAssign(19:20-19:21),UpperIdent(19:22-19:26),NoSpaceDotUpperIdent(19:26-19:31),NoSpaceOpenRound(19:31-19:32),Int(19:32-19:33),Comma(19:33-19:34),StringStart(19:35-19:36),StringPart(19:36-19:39),StringEnd(19:39-19:40),CloseRound(19:40-19:41), +LowerIdent(21:1-21:14),OpColon(21:15-21:16),LowerIdent(21:17-21:18),Comma(21:18-21:19),LowerIdent(21:20-21:21),OpArrow(21:22-21:24),UpperIdent(21:25-21:29),NoSpaceOpenRound(21:29-21:30),LowerIdent(21:30-21:31),CloseRound(21:31-21:32), +LowerIdent(22:1-22:14),OpAssign(22:15-22:16),OpBar(22:17-22:18),LowerIdent(22:18-22:19),Comma(22:19-22:20),LowerIdent(22:21-22:22),OpBar(22:22-22:23),UpperIdent(22:24-22:28),NoSpaceDotUpperIdent(22:28-22:33),NoSpaceOpenRound(22:33-22:34),LowerIdent(22:34-22:35),Comma(22:35-22:36),LowerIdent(22:37-22:38),CloseRound(22:38-22:39), +EndOfFile(23:1-23:1), ~~~ # PARSE ~~~clojure -(file @1.1-28.44 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-22.39 + (type-module @1.1-1.5) (statements - (s-type-decl @3.1-3.24 - (header @3.1-3.8 (name "Pair") + (s-type-decl @1.1-1.24 + (header @1.1-1.8 (name "Pair") (args - (ty-var @3.6-3.7 (raw "a")))) - (ty-tag-union @3.12-3.24 + (ty-var @1.6-1.7 (raw "a")))) + (ty-tag-union @1.12-1.24 (tags - (ty-apply @3.13-3.23 - (ty @3.13-3.17 (name "Pair")) - (ty-var @3.18-3.19 (raw "a")) - (ty-var @3.21-3.22 (raw "a")))))) - (s-type-anno @5.1-5.20 (name "pairU64") - (ty-apply @5.11-5.20 - (ty @5.11-5.15 (name "Pair")) - (ty @5.16-5.19 (name "U64")))) - (s-decl @6.1-6.26 - (p-ident @6.1-6.8 (raw "pairU64")) - (e-apply @6.11-6.26 - (e-tag @6.11-6.20 (raw "Pair.Pair")) - (e-int @6.21-6.22 (raw "1")) - (e-int @6.24-6.25 (raw "2")))) - (s-type-anno @8.1-8.20 (name "pairStr") - (ty-apply @8.11-8.20 - (ty @8.11-8.15 (name "Pair")) - (ty @8.16-8.19 (name "Str")))) - (s-decl @9.1-9.38 - (p-ident @9.1-9.8 (raw "pairStr")) - (e-apply @9.11-9.38 - (e-tag @9.11-9.20 (raw "Pair.Pair")) - (e-string @9.21-9.28 - (e-string-part @9.22-9.27 (raw "hello"))) - (e-string @9.30-9.37 - (e-string-part @9.31-9.36 (raw "world"))))) - (s-type-anno @11.1-11.25 (name "mkPair") - (ty-fn @11.10-11.25 - (ty-var @11.10-11.11 (raw "a")) - (ty-var @11.13-11.14 (raw "a")) - (ty-apply @11.18-11.25 - (ty @11.18-11.22 (name "Pair")) - (ty-var @11.23-11.24 (raw "a"))))) - (s-decl @12.1-12.32 - (p-ident @12.1-12.7 (raw "mkPair")) - (e-lambda @12.10-12.32 + (ty-apply @1.13-1.23 + (ty @1.13-1.17 (name "Pair")) + (ty-var @1.18-1.19 (raw "a")) + (ty-var @1.21-1.22 (raw "a")))))) + (s-type-anno @3.1-3.20 (name "pairU64") + (ty-apply @3.11-3.20 + (ty @3.11-3.15 (name "Pair")) + (ty @3.16-3.19 (name "U64")))) + (s-decl @4.1-4.26 + (p-ident @4.1-4.8 (raw "pairU64")) + (e-apply @4.11-4.26 + (e-tag @4.11-4.20 (raw "Pair.Pair")) + (e-int @4.21-4.22 (raw "1")) + (e-int @4.24-4.25 (raw "2")))) + (s-type-anno @6.1-6.20 (name "pairStr") + (ty-apply @6.11-6.20 + (ty @6.11-6.15 (name "Pair")) + (ty @6.16-6.19 (name "Str")))) + (s-decl @7.1-7.38 + (p-ident @7.1-7.8 (raw "pairStr")) + (e-apply @7.11-7.38 + (e-tag @7.11-7.20 (raw "Pair.Pair")) + (e-string @7.21-7.28 + (e-string-part @7.22-7.27 (raw "hello"))) + (e-string @7.30-7.37 + (e-string-part @7.31-7.36 (raw "world"))))) + (s-type-anno @9.1-9.25 (name "mkPair") + (ty-fn @9.10-9.25 + (ty-var @9.10-9.11 (raw "a")) + (ty-var @9.13-9.14 (raw "a")) + (ty-apply @9.18-9.25 + (ty @9.18-9.22 (name "Pair")) + (ty-var @9.23-9.24 (raw "a"))))) + (s-decl @10.1-10.32 + (p-ident @10.1-10.7 (raw "mkPair")) + (e-lambda @10.10-10.32 (args - (p-ident @12.11-12.12 (raw "x")) - (p-ident @12.14-12.15 (raw "y"))) - (e-apply @12.17-12.32 - (e-tag @12.17-12.26 (raw "Pair.Pair")) - (e-ident @12.27-12.28 (raw "x")) - (e-ident @12.30-12.31 (raw "y"))))) - (s-type-anno @14.1-14.31 (name "succeedPairSameType") - (ty-apply @14.23-14.31 - (ty @14.23-14.27 (name "Pair")) - (ty @14.28-14.30 (name "U8")))) - (s-decl @15.1-15.35 - (p-ident @15.1-15.20 (raw "succeedPairSameType")) - (e-apply @15.23-15.35 - (e-ident @15.23-15.29 (raw "mkPair")) - (e-int @15.30-15.31 (raw "1")) - (e-int @15.33-15.34 (raw "2")))) - (s-type-anno @17.1-17.29 (name "failPairDiffTypes") - (ty-apply @17.21-17.29 - (ty @17.21-17.25 (name "Pair")) - (ty @17.26-17.28 (name "U8")))) - (s-decl @18.1-18.35 - (p-ident @18.1-18.18 (raw "failPairDiffTypes")) - (e-apply @18.21-18.35 - (e-ident @18.21-18.27 (raw "mkPair")) - (e-string @18.28-18.31 - (e-string-part @18.29-18.30 (raw "1"))) - (e-int @18.33-18.34 (raw "2")))) - (s-type-anno @20.1-20.31 (name "failPairDiffTypes2") - (ty-apply @20.22-20.31 - (ty @20.22-20.26 (name "Pair")) - (ty @20.27-20.30 (name "U64")))) - (s-decl @21.1-21.41 - (p-ident @21.1-21.19 (raw "failPairDiffTypes2")) - (e-apply @21.22-21.41 - (e-tag @21.22-21.31 (raw "Pair.Pair")) - (e-int @21.32-21.33 (raw "1")) - (e-string @21.35-21.40 - (e-string-part @21.36-21.39 (raw "str"))))) - (s-type-anno @23.1-23.32 (name "mkPairInvalid") - (ty-fn @23.17-23.32 - (ty-var @23.17-23.18 (raw "a")) - (ty-var @23.20-23.21 (raw "b")) - (ty-apply @23.25-23.32 - (ty @23.25-23.29 (name "Pair")) - (ty-var @23.30-23.31 (raw "a"))))) - (s-decl @24.1-24.39 - (p-ident @24.1-24.14 (raw "mkPairInvalid")) - (e-lambda @24.17-24.39 + (p-ident @10.11-10.12 (raw "x")) + (p-ident @10.14-10.15 (raw "y"))) + (e-apply @10.17-10.32 + (e-tag @10.17-10.26 (raw "Pair.Pair")) + (e-ident @10.27-10.28 (raw "x")) + (e-ident @10.30-10.31 (raw "y"))))) + (s-type-anno @12.1-12.31 (name "succeedPairSameType") + (ty-apply @12.23-12.31 + (ty @12.23-12.27 (name "Pair")) + (ty @12.28-12.30 (name "U8")))) + (s-decl @13.1-13.35 + (p-ident @13.1-13.20 (raw "succeedPairSameType")) + (e-apply @13.23-13.35 + (e-ident @13.23-13.29 (raw "mkPair")) + (e-int @13.30-13.31 (raw "1")) + (e-int @13.33-13.34 (raw "2")))) + (s-type-anno @15.1-15.29 (name "failPairDiffTypes") + (ty-apply @15.21-15.29 + (ty @15.21-15.25 (name "Pair")) + (ty @15.26-15.28 (name "U8")))) + (s-decl @16.1-16.35 + (p-ident @16.1-16.18 (raw "failPairDiffTypes")) + (e-apply @16.21-16.35 + (e-ident @16.21-16.27 (raw "mkPair")) + (e-string @16.28-16.31 + (e-string-part @16.29-16.30 (raw "1"))) + (e-int @16.33-16.34 (raw "2")))) + (s-type-anno @18.1-18.31 (name "failPairDiffTypes2") + (ty-apply @18.22-18.31 + (ty @18.22-18.26 (name "Pair")) + (ty @18.27-18.30 (name "U64")))) + (s-decl @19.1-19.41 + (p-ident @19.1-19.19 (raw "failPairDiffTypes2")) + (e-apply @19.22-19.41 + (e-tag @19.22-19.31 (raw "Pair.Pair")) + (e-int @19.32-19.33 (raw "1")) + (e-string @19.35-19.40 + (e-string-part @19.36-19.39 (raw "str"))))) + (s-type-anno @21.1-21.32 (name "mkPairInvalid") + (ty-fn @21.17-21.32 + (ty-var @21.17-21.18 (raw "a")) + (ty-var @21.20-21.21 (raw "b")) + (ty-apply @21.25-21.32 + (ty @21.25-21.29 (name "Pair")) + (ty-var @21.30-21.31 (raw "a"))))) + (s-decl @22.1-22.39 + (p-ident @22.1-22.14 (raw "mkPairInvalid")) + (e-lambda @22.17-22.39 (args - (p-ident @24.18-24.19 (raw "x")) - (p-ident @24.21-24.22 (raw "y"))) - (e-apply @24.24-24.39 - (e-tag @24.24-24.33 (raw "Pair.Pair")) - (e-ident @24.34-24.35 (raw "x")) - (e-ident @24.37-24.38 (raw "y"))))) - (s-decl @26.1-26.40 - (p-ident @26.1-26.15 (raw "mkPairInferred")) - (e-lambda @26.18-26.40 - (args - (p-ident @26.19-26.20 (raw "x")) - (p-ident @26.22-26.23 (raw "y"))) - (e-apply @26.25-26.40 - (e-tag @26.25-26.34 (raw "Pair.Pair")) - (e-ident @26.35-26.36 (raw "x")) - (e-ident @26.38-26.39 (raw "y"))))) - (s-decl @28.1-28.44 - (p-ident @28.1-28.17 (raw "failWithImplicit")) - (e-apply @28.20-28.44 - (e-ident @28.20-28.34 (raw "mkPairInferred")) - (e-string @28.35-28.40 - (e-string-part @28.36-28.39 (raw "str"))) - (e-int @28.42-28.43 (raw "2")))))) + (p-ident @22.18-22.19 (raw "x")) + (p-ident @22.21-22.22 (raw "y"))) + (e-apply @22.24-22.39 + (e-tag @22.24-22.33 (raw "Pair.Pair")) + (e-ident @22.34-22.35 (raw "x")) + (e-ident @22.37-22.38 (raw "y"))))))) ~~~ # FORMATTED ~~~roc @@ -252,160 +208,135 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @6.1-6.8 (ident "pairU64")) - (e-nominal @6.11-6.26 (nominal "Pair") - (e-tag @6.11-6.26 (name "Pair") + (p-assign @4.1-4.8 (ident "pairU64")) + (e-nominal @4.11-4.26 (nominal "Pair") + (e-tag @4.11-4.26 (name "Pair") (args - (e-int @6.21-6.22 (value "1")) - (e-int @6.24-6.25 (value "2"))))) - (annotation @6.1-6.8 + (e-num @4.21-4.22 (value "1")) + (e-num @4.24-4.25 (value "2"))))) + (annotation @4.1-4.8 (declared-type - (ty-apply @5.11-5.20 (symbol "Pair") - (ty @5.16-5.19 (name "U64")))))) + (ty-apply @3.11-3.20 (name "Pair") (local) + (ty-lookup @3.11-3.20 (name "U64") (builtin)))))) (d-let - (p-assign @9.1-9.8 (ident "pairStr")) - (e-nominal @9.11-9.38 (nominal "Pair") - (e-tag @9.11-9.38 (name "Pair") + (p-assign @7.1-7.8 (ident "pairStr")) + (e-nominal @7.11-7.38 (nominal "Pair") + (e-tag @7.11-7.38 (name "Pair") (args - (e-string @9.21-9.28 - (e-literal @9.22-9.27 (string "hello"))) - (e-string @9.30-9.37 - (e-literal @9.31-9.36 (string "world")))))) - (annotation @9.1-9.8 + (e-string @7.21-7.28 + (e-literal @7.22-7.27 (string "hello"))) + (e-string @7.30-7.37 + (e-literal @7.31-7.36 (string "world")))))) + (annotation @7.1-7.8 (declared-type - (ty-apply @8.11-8.20 (symbol "Pair") - (ty @8.16-8.19 (name "Str")))))) + (ty-apply @6.11-6.20 (name "Pair") (local) + (ty-lookup @6.11-6.20 (name "Str") (builtin)))))) (d-let - (p-assign @12.1-12.7 (ident "mkPair")) - (e-lambda @12.10-12.32 + (p-assign @10.1-10.7 (ident "mkPair")) + (e-lambda @10.10-10.32 (args - (p-assign @12.11-12.12 (ident "x")) - (p-assign @12.14-12.15 (ident "y"))) - (e-nominal @12.17-12.32 (nominal "Pair") - (e-tag @12.17-12.32 (name "Pair") + (p-assign @10.11-10.12 (ident "x")) + (p-assign @10.14-10.15 (ident "y"))) + (e-nominal @10.17-10.32 (nominal "Pair") + (e-tag @10.17-10.32 (name "Pair") (args - (e-lookup-local @12.27-12.28 - (p-assign @12.11-12.12 (ident "x"))) - (e-lookup-local @12.30-12.31 - (p-assign @12.14-12.15 (ident "y"))))))) - (annotation @12.1-12.7 + (e-lookup-local @10.27-10.28 + (p-assign @10.11-10.12 (ident "x"))) + (e-lookup-local @10.30-10.31 + (p-assign @10.14-10.15 (ident "y"))))))) + (annotation @10.1-10.7 (declared-type - (ty-fn @11.10-11.25 (effectful false) - (ty-var @11.10-11.11 (name "a")) - (ty-var @11.13-11.14 (name "a")) - (ty-apply @11.18-11.25 (symbol "Pair") - (ty-var @11.23-11.24 (name "a"))))))) + (ty-fn @9.10-9.25 (effectful false) + (ty-rigid-var @9.10-9.11 (name "a")) + (ty-rigid-var-lookup (ty-rigid-var @9.10-9.11 (name "a"))) + (ty-apply @9.18-9.25 (name "Pair") (local) + (ty-rigid-var-lookup (ty-rigid-var @9.10-9.11 (name "a")))))))) (d-let - (p-assign @15.1-15.20 (ident "succeedPairSameType")) - (e-call @15.23-15.35 - (e-lookup-local @15.23-15.29 - (p-assign @12.1-12.7 (ident "mkPair"))) - (e-int @15.30-15.31 (value "1")) - (e-int @15.33-15.34 (value "2"))) - (annotation @15.1-15.20 + (p-assign @13.1-13.20 (ident "succeedPairSameType")) + (e-call @13.23-13.35 + (e-lookup-local @13.23-13.29 + (p-assign @10.1-10.7 (ident "mkPair"))) + (e-num @13.30-13.31 (value "1")) + (e-num @13.33-13.34 (value "2"))) + (annotation @13.1-13.20 (declared-type - (ty-apply @14.23-14.31 (symbol "Pair") - (ty @14.28-14.30 (name "U8")))))) + (ty-apply @12.23-12.31 (name "Pair") (local) + (ty-lookup @12.23-12.31 (name "U8") (builtin)))))) (d-let - (p-assign @18.1-18.18 (ident "failPairDiffTypes")) - (e-call @18.21-18.35 - (e-lookup-local @18.21-18.27 - (p-assign @12.1-12.7 (ident "mkPair"))) - (e-string @18.28-18.31 - (e-literal @18.29-18.30 (string "1"))) - (e-int @18.33-18.34 (value "2"))) - (annotation @18.1-18.18 + (p-assign @16.1-16.18 (ident "failPairDiffTypes")) + (e-call @16.21-16.35 + (e-lookup-local @16.21-16.27 + (p-assign @10.1-10.7 (ident "mkPair"))) + (e-string @16.28-16.31 + (e-literal @16.29-16.30 (string "1"))) + (e-num @16.33-16.34 (value "2"))) + (annotation @16.1-16.18 (declared-type - (ty-apply @17.21-17.29 (symbol "Pair") - (ty @17.26-17.28 (name "U8")))))) + (ty-apply @15.21-15.29 (name "Pair") (local) + (ty-lookup @15.21-15.29 (name "U8") (builtin)))))) (d-let - (p-assign @21.1-21.19 (ident "failPairDiffTypes2")) - (e-nominal @21.22-21.41 (nominal "Pair") - (e-tag @21.22-21.41 (name "Pair") + (p-assign @19.1-19.19 (ident "failPairDiffTypes2")) + (e-nominal @19.22-19.41 (nominal "Pair") + (e-tag @19.22-19.41 (name "Pair") (args - (e-int @21.32-21.33 (value "1")) - (e-string @21.35-21.40 - (e-literal @21.36-21.39 (string "str")))))) - (annotation @21.1-21.19 + (e-num @19.32-19.33 (value "1")) + (e-string @19.35-19.40 + (e-literal @19.36-19.39 (string "str")))))) + (annotation @19.1-19.19 (declared-type - (ty-apply @20.22-20.31 (symbol "Pair") - (ty @20.27-20.30 (name "U64")))))) + (ty-apply @18.22-18.31 (name "Pair") (local) + (ty-lookup @18.22-18.31 (name "U64") (builtin)))))) (d-let - (p-assign @24.1-24.14 (ident "mkPairInvalid")) - (e-lambda @24.17-24.39 + (p-assign @22.1-22.14 (ident "mkPairInvalid")) + (e-lambda @22.17-22.39 (args - (p-assign @24.18-24.19 (ident "x")) - (p-assign @24.21-24.22 (ident "y"))) - (e-nominal @24.24-24.39 (nominal "Pair") - (e-tag @24.24-24.39 (name "Pair") + (p-assign @22.18-22.19 (ident "x")) + (p-assign @22.21-22.22 (ident "y"))) + (e-nominal @22.24-22.39 (nominal "Pair") + (e-tag @22.24-22.39 (name "Pair") (args - (e-lookup-local @24.34-24.35 - (p-assign @24.18-24.19 (ident "x"))) - (e-lookup-local @24.37-24.38 - (p-assign @24.21-24.22 (ident "y"))))))) - (annotation @24.1-24.14 + (e-lookup-local @22.34-22.35 + (p-assign @22.18-22.19 (ident "x"))) + (e-lookup-local @22.37-22.38 + (p-assign @22.21-22.22 (ident "y"))))))) + (annotation @22.1-22.14 (declared-type - (ty-fn @23.17-23.32 (effectful false) - (ty-var @23.17-23.18 (name "a")) - (ty-var @23.20-23.21 (name "b")) - (ty-apply @23.25-23.32 (symbol "Pair") - (ty-var @23.30-23.31 (name "a"))))))) - (d-let - (p-assign @26.1-26.15 (ident "mkPairInferred")) - (e-lambda @26.18-26.40 - (args - (p-assign @26.19-26.20 (ident "x")) - (p-assign @26.22-26.23 (ident "y"))) - (e-nominal @26.25-26.40 (nominal "Pair") - (e-tag @26.25-26.40 (name "Pair") - (args - (e-lookup-local @26.35-26.36 - (p-assign @26.19-26.20 (ident "x"))) - (e-lookup-local @26.38-26.39 - (p-assign @26.22-26.23 (ident "y")))))))) - (d-let - (p-assign @28.1-28.17 (ident "failWithImplicit")) - (e-call @28.20-28.44 - (e-lookup-local @28.20-28.34 - (p-assign @26.1-26.15 (ident "mkPairInferred"))) - (e-string @28.35-28.40 - (e-literal @28.36-28.39 (string "str"))) - (e-int @28.42-28.43 (value "2")))) - (s-nominal-decl @3.1-3.24 - (ty-header @3.1-3.8 (name "Pair") + (ty-fn @21.17-21.32 (effectful false) + (ty-rigid-var @21.17-21.18 (name "a")) + (ty-rigid-var @21.20-21.21 (name "b")) + (ty-apply @21.25-21.32 (name "Pair") (local) + (ty-rigid-var-lookup (ty-rigid-var @21.17-21.18 (name "a")))))))) + (s-nominal-decl @1.1-1.24 + (ty-header @1.1-1.8 (name "Pair") (ty-args - (ty-var @3.6-3.7 (name "a")))) - (ty-tag-union @3.12-3.24 - (ty-apply @3.13-3.23 (symbol "Pair") - (ty-var @3.18-3.19 (name "a")) - (ty-var @3.21-3.22 (name "a")))))) + (ty-rigid-var @1.6-1.7 (name "a")))) + (ty-tag-union @1.12-1.24 + (ty-tag-name @1.13-1.23 (name "Pair") + (ty-rigid-var-lookup (ty-rigid-var @1.6-1.7 (name "a"))) + (ty-rigid-var-lookup (ty-rigid-var @1.6-1.7 (name "a"))))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @6.1-6.8 (type "Pair(U64)")) - (patt @9.1-9.8 (type "Pair(Str)")) - (patt @12.1-12.7 (type "a, a -> Pair(a)")) - (patt @15.1-15.20 (type "Pair(U8)")) - (patt @18.1-18.18 (type "Pair(U8)")) - (patt @21.1-21.19 (type "Error")) - (patt @24.1-24.14 (type "a, b -> Error")) - (patt @26.1-26.15 (type "a, a -> Pair(a)")) - (patt @28.1-28.17 (type "_c"))) + (patt @4.1-4.8 (type "Pair(Num(Int(Unsigned64)))")) + (patt @7.1-7.8 (type "Pair(Str)")) + (patt @10.1-10.7 (type "a, a -> Pair(a)")) + (patt @13.1-13.20 (type "Pair(Num(Int(Unsigned8)))")) + (patt @16.1-16.18 (type "Error")) + (patt @19.1-19.19 (type "Error")) + (patt @22.1-22.14 (type "a, b -> Error"))) (type_decls - (nominal @3.1-3.24 (type "Pair(a)") - (ty-header @3.1-3.8 (name "Pair") + (nominal @1.1-1.24 (type "Pair(a)") + (ty-header @1.1-1.8 (name "Pair") (ty-args - (ty-var @3.6-3.7 (name "a")))))) + (ty-rigid-var @1.6-1.7 (name "a")))))) (expressions - (expr @6.11-6.26 (type "Pair(U64)")) - (expr @9.11-9.38 (type "Pair(Str)")) - (expr @12.10-12.32 (type "a, a -> Pair(a)")) - (expr @15.23-15.35 (type "Pair(U8)")) - (expr @18.21-18.35 (type "Pair(U8)")) - (expr @21.22-21.41 (type "Error")) - (expr @24.17-24.39 (type "a, b -> Error")) - (expr @26.18-26.40 (type "a, a -> Pair(a)")) - (expr @28.20-28.44 (type "_c")))) + (expr @4.11-4.26 (type "Pair(Num(Int(Unsigned64)))")) + (expr @7.11-7.38 (type "Pair(Str)")) + (expr @10.10-10.32 (type "a, a -> Pair(a)")) + (expr @13.23-13.35 (type "Pair(Num(Int(Unsigned8)))")) + (expr @16.21-16.35 (type "Error")) + (expr @19.22-19.41 (type "Error")) + (expr @22.17-22.39 (type "a, b -> Error")))) ~~~ diff --git a/test/snapshots/binop_omnibus__single__no_spaces.md b/test/snapshots/binop_omnibus__single__no_spaces.md index d0e8be237a..d794a54d97 100644 --- a/test/snapshots/binop_omnibus__single__no_spaces.md +++ b/test/snapshots/binop_omnibus__single__no_spaces.md @@ -73,19 +73,19 @@ Err(foo) ?? 12 > 5 * 5 or 13 + 2 < 5 and 10 (e-tag @1.1-1.9 (name "Err") (args (e-runtime-error (tag "ident_not_in_scope"))))) - (e-int @1.11-1.13 (value "12"))) + (e-num @1.11-1.13 (value "12"))) (e-binop @1.14-1.17 (op "mul") - (e-int @1.14-1.15 (value "5")) - (e-int @1.16-1.17 (value "5")))) + (e-num @1.14-1.15 (value "5")) + (e-num @1.16-1.17 (value "5")))) (e-binop @1.21-1.34 (op "and") (e-binop @1.21-1.27 (op "lt") (e-binop @1.21-1.25 (op "add") - (e-int @1.21-1.23 (value "13")) - (e-int @1.24-1.25 (value "2"))) - (e-int @1.26-1.27 (value "5"))) - (e-int @1.32-1.34 (value "10")))) + (e-num @1.21-1.23 (value "13")) + (e-num @1.24-1.25 (value "2"))) + (e-num @1.26-1.27 (value "5"))) + (e-num @1.32-1.34 (value "10")))) ~~~ # TYPES ~~~clojure -(expr @1.1-1.34 (type "_a")) +(expr @1.1-1.34 (type "Error")) ~~~ diff --git a/test/snapshots/binop_omnibus__singleline.md b/test/snapshots/binop_omnibus__singleline.md index 47d9f78c26..a1f63f5ede 100644 --- a/test/snapshots/binop_omnibus__singleline.md +++ b/test/snapshots/binop_omnibus__singleline.md @@ -69,29 +69,29 @@ NO CHANGE (e-tag @1.1-1.9 (name "Err") (args (e-runtime-error (tag "ident_not_in_scope"))))) - (e-int @1.13-1.15 (value "12"))) + (e-num @1.13-1.15 (value "12"))) (e-binop @1.18-1.23 (op "mul") - (e-int @1.18-1.19 (value "5")) - (e-int @1.22-1.23 (value "5")))) + (e-num @1.18-1.19 (value "5")) + (e-num @1.22-1.23 (value "5")))) (e-binop @1.27-1.69 (op "or") (e-binop @1.27-1.54 (op "and") (e-binop @1.27-1.37 (op "lt") (e-binop @1.27-1.33 (op "add") - (e-int @1.27-1.29 (value "13")) - (e-int @1.32-1.33 (value "2"))) - (e-int @1.36-1.37 (value "5"))) + (e-num @1.27-1.29 (value "13")) + (e-num @1.32-1.33 (value "2"))) + (e-num @1.36-1.37 (value "5"))) (e-binop @1.42-1.54 (op "ge") (e-binop @1.42-1.48 (op "sub") - (e-int @1.42-1.44 (value "10")) - (e-int @1.47-1.48 (value "1"))) - (e-int @1.52-1.54 (value "16")))) + (e-num @1.42-1.44 (value "10")) + (e-num @1.47-1.48 (value "1"))) + (e-num @1.52-1.54 (value "16")))) (e-binop @1.58-1.69 (op "le") - (e-int @1.58-1.60 (value "12")) + (e-num @1.58-1.60 (value "12")) (e-binop @1.64-1.69 (op "div") - (e-int @1.64-1.65 (value "3")) - (e-int @1.68-1.69 (value "5")))))) + (e-num @1.64-1.65 (value "3")) + (e-num @1.68-1.69 (value "5")))))) ~~~ # TYPES ~~~clojure -(expr @1.1-1.69 (type "_a")) +(expr @1.1-1.69 (type "Bool")) ~~~ diff --git a/test/snapshots/binops.md b/test/snapshots/binops.md index 12dc4c7c77..7cd77793fa 100644 --- a/test/snapshots/binops.md +++ b/test/snapshots/binops.md @@ -122,41 +122,41 @@ EndOfFile(18:1-18:1), (e-tuple @1.1-17.2 (elems (e-binop @2.5-2.10 (op "add") - (e-int @2.5-2.6 (value "4")) - (e-int @2.9-2.10 (value "2"))) + (e-num @2.5-2.6 (value "4")) + (e-num @2.9-2.10 (value "2"))) (e-binop @3.5-3.10 (op "sub") - (e-int @3.5-3.6 (value "4")) - (e-int @3.9-3.10 (value "2"))) + (e-num @3.5-3.6 (value "4")) + (e-num @3.9-3.10 (value "2"))) (e-binop @4.5-4.10 (op "mul") - (e-int @4.5-4.6 (value "4")) - (e-int @4.9-4.10 (value "2"))) + (e-num @4.5-4.6 (value "4")) + (e-num @4.9-4.10 (value "2"))) (e-binop @5.5-5.10 (op "div") - (e-int @5.5-5.6 (value "4")) - (e-int @5.9-5.10 (value "2"))) + (e-num @5.5-5.6 (value "4")) + (e-num @5.9-5.10 (value "2"))) (e-binop @6.5-6.10 (op "rem") - (e-int @6.5-6.6 (value "4")) - (e-int @6.9-6.10 (value "2"))) + (e-num @6.5-6.6 (value "4")) + (e-num @6.9-6.10 (value "2"))) (e-binop @7.5-7.10 (op "lt") - (e-int @7.5-7.6 (value "4")) - (e-int @7.9-7.10 (value "2"))) + (e-num @7.5-7.6 (value "4")) + (e-num @7.9-7.10 (value "2"))) (e-binop @8.5-8.10 (op "gt") - (e-int @8.5-8.6 (value "4")) - (e-int @8.9-8.10 (value "2"))) + (e-num @8.5-8.6 (value "4")) + (e-num @8.9-8.10 (value "2"))) (e-binop @9.5-9.11 (op "le") - (e-int @9.5-9.6 (value "4")) - (e-int @9.10-9.11 (value "2"))) + (e-num @9.5-9.6 (value "4")) + (e-num @9.10-9.11 (value "2"))) (e-binop @10.5-10.11 (op "ge") - (e-int @10.5-10.6 (value "4")) - (e-int @10.10-10.11 (value "2"))) + (e-num @10.5-10.6 (value "4")) + (e-num @10.10-10.11 (value "2"))) (e-binop @11.5-11.11 (op "eq") - (e-int @11.5-11.6 (value "4")) - (e-int @11.10-11.11 (value "2"))) + (e-num @11.5-11.6 (value "4")) + (e-num @11.10-11.11 (value "2"))) (e-binop @12.5-12.11 (op "ne") - (e-int @12.5-12.6 (value "4")) - (e-int @12.10-12.11 (value "2"))) + (e-num @12.5-12.6 (value "4")) + (e-num @12.10-12.11 (value "2"))) (e-binop @13.5-13.11 (op "div_trunc") - (e-int @13.5-13.6 (value "4")) - (e-int @13.10-13.11 (value "2"))) + (e-num @13.5-13.6 (value "4")) + (e-num @13.10-13.11 (value "2"))) (e-binop @14.5-14.29 (op "and") (e-nominal @14.5-14.14 (nominal "Bool") (e-tag @14.5-14.14 (name "True"))) @@ -169,9 +169,9 @@ EndOfFile(18:1-18:1), (e-tag @15.19-15.28 (name "True")))) (e-binop @16.5-16.14 (op "null_coalesce") (e-tag @16.5-16.9 (name "None")) - (e-int @16.13-16.14 (value "0"))))) + (e-num @16.13-16.14 (value "0"))))) ~~~ # TYPES ~~~clojure -(expr @1.1-17.2 (type "(Num(_size), Num(_size2), Num(_size3), Num(_size4), Num(_size5), Bool, Bool, Bool, Bool, Bool, Bool, Num(_size6), _field, _field2, _field3)")) +(expr @1.1-17.2 (type "(Num(_size), Num(_size2), Num(_size3), Num(_size4), Num(_size5), Bool, Bool, Bool, Bool, Bool, Bool, Num(_size6), Bool, Bool, _field)")) ~~~ diff --git a/test/snapshots/bound_type_var_no_annotation.md b/test/snapshots/bound_type_var_no_annotation.md index 50df3f0a50..229193c93f 100644 --- a/test/snapshots/bound_type_var_no_annotation.md +++ b/test/snapshots/bound_type_var_no_annotation.md @@ -196,11 +196,11 @@ main! = |_| { (annotation @7.1-7.8 (declared-type (ty-fn @6.11-6.25 (effectful false) - (ty-var @6.11-6.12 (name "a")) - (ty-var @6.14-6.15 (name "b")) + (ty-rigid-var @6.11-6.12 (name "a")) + (ty-rigid-var @6.14-6.15 (name "b")) (ty-tuple @6.19-6.25 - (ty-var @6.20-6.21 (name "a")) - (ty-var @6.23-6.24 (name "b"))))))) + (ty-rigid-var-lookup (ty-rigid-var @6.11-6.12 (name "a"))) + (ty-rigid-var-lookup (ty-rigid-var @6.14-6.15 (name "b")))))))) (d-let (p-assign @11.1-11.7 (ident "addOne")) (e-lambda @11.10-11.19 @@ -209,19 +209,19 @@ main! = |_| { (e-binop @11.14-11.19 (op "add") (e-lookup-local @11.14-11.15 (p-assign @11.11-11.12 (ident "n"))) - (e-int @11.18-11.19 (value "1")))) + (e-num @11.18-11.19 (value "1")))) (annotation @11.1-11.7 (declared-type (ty-fn @10.10-10.20 (effectful false) - (ty @10.10-10.13 (name "U64")) - (ty @10.17-10.20 (name "U64")))))) + (ty-lookup @10.10-10.13 (name "U64") (builtin)) + (ty-lookup @10.17-10.20 (name "U64") (builtin)))))) (d-let (p-assign @13.1-13.6 (ident "main!")) (e-closure @13.9-25.2 (captures - (capture @11.1-11.7 (ident "addOne")) + (capture @7.1-7.8 (ident "combine")) (capture @3.1-3.9 (ident "identity")) - (capture @7.1-7.8 (ident "combine"))) + (capture @11.1-11.7 (ident "addOne"))) (e-lambda @13.9-25.2 (args (p-underscore @13.10-13.11)) @@ -231,7 +231,7 @@ main! = |_| { (e-call @15.11-15.23 (e-lookup-local @15.11-15.19 (p-assign @3.1-3.9 (ident "identity"))) - (e-int @15.20-15.22 (value "42")))) + (e-num @15.20-15.22 (value "42")))) (s-let @16.5-16.29 (p-assign @16.5-16.9 (ident "text")) (e-call @16.12-16.29 @@ -253,7 +253,7 @@ main! = |_| { (e-call @22.14-22.23 (e-lookup-local @22.14-22.20 (p-assign @11.1-11.7 (ident "addOne"))) - (e-int @22.21-22.22 (value "5")))) + (e-num @22.21-22.22 (value "5")))) (e-lookup-local @24.5-24.11 (p-assign @22.5-22.11 (ident "result")))))))) ~~~ @@ -261,13 +261,13 @@ main! = |_| { ~~~clojure (inferred-types (defs - (patt @3.1-3.9 (type "_arg -> _ret")) + (patt @3.1-3.9 (type "c -> c")) (patt @7.1-7.8 (type "a, b -> (a, b)")) - (patt @11.1-11.7 (type "U64 -> U64")) - (patt @13.1-13.6 (type "_arg -> U64"))) + (patt @11.1-11.7 (type "Num(Int(Unsigned64)) -> Num(Int(Unsigned64))")) + (patt @13.1-13.6 (type "_arg -> Num(Int(Unsigned64))"))) (expressions - (expr @3.12-3.17 (type "_arg -> _ret")) + (expr @3.12-3.17 (type "c -> c")) (expr @7.11-7.42 (type "a, b -> (a, b)")) - (expr @11.10-11.19 (type "U64 -> U64")) - (expr @13.9-25.2 (type "_arg -> U64")))) + (expr @11.10-11.19 (type "Num(Int(Unsigned64)) -> Num(Int(Unsigned64))")) + (expr @13.9-25.2 (type "_arg -> Num(Int(Unsigned64))")))) ~~~ diff --git a/test/snapshots/can_basic_scoping.md b/test/snapshots/can_basic_scoping.md index 9b9ecedbe1..f4bf1d4cb8 100644 --- a/test/snapshots/can_basic_scoping.md +++ b/test/snapshots/can_basic_scoping.md @@ -1,12 +1,10 @@ # META ~~~ini description=Basic variable scoping behavior -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - # Top-level variables x = 5 y = 10 @@ -23,20 +21,20 @@ outerFunc = |_| { } ~~~ # EXPECTED -DUPLICATE DEFINITION - can_basic_scoping.md:9:5:9:6 +DUPLICATE DEFINITION - can_basic_scoping.md:7:5:7:6 # PROBLEMS **DUPLICATE DEFINITION** The name `x` is being redeclared in this scope. The redeclaration is here: -**can_basic_scoping.md:9:5:9:6:** +**can_basic_scoping.md:7:5:7:6:** ```roc x = 20 # Should shadow top-level x ``` ^ But `x` was already defined here: -**can_basic_scoping.md:4:1:4:2:** +**can_basic_scoping.md:2:1:2:2:** ```roc x = 5 ``` @@ -45,59 +43,56 @@ x = 5 # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -LowerIdent(4:1-4:2),OpAssign(4:3-4:4),Int(4:5-4:6), -LowerIdent(5:1-5:2),OpAssign(5:3-5:4),Int(5:5-5:7), -LowerIdent(8:1-8:10),OpAssign(8:11-8:12),OpBar(8:13-8:14),Underscore(8:14-8:15),OpBar(8:15-8:16),OpenCurly(8:17-8:18), -LowerIdent(9:5-9:6),OpAssign(9:7-9:8),Int(9:9-9:11), -LowerIdent(10:5-10:16),OpAssign(10:17-10:18),OpenCurly(10:19-10:20), -LowerIdent(12:9-12:10),OpAssign(12:11-12:12),LowerIdent(12:13-12:14),OpPlus(12:15-12:16),LowerIdent(12:17-12:18), -LowerIdent(13:9-13:10),OpPlus(13:11-13:12),Int(13:13-13:14), -CloseCurly(14:5-14:6), -LowerIdent(15:5-15:16), -CloseCurly(16:1-16:2), -EndOfFile(17:1-17:1), +LowerIdent(2:1-2:2),OpAssign(2:3-2:4),Int(2:5-2:6), +LowerIdent(3:1-3:2),OpAssign(3:3-3:4),Int(3:5-3:7), +LowerIdent(6:1-6:10),OpAssign(6:11-6:12),OpBar(6:13-6:14),Underscore(6:14-6:15),OpBar(6:15-6:16),OpenCurly(6:17-6:18), +LowerIdent(7:5-7:6),OpAssign(7:7-7:8),Int(7:9-7:11), +LowerIdent(8:5-8:16),OpAssign(8:17-8:18),OpenCurly(8:19-8:20), +LowerIdent(10:9-10:10),OpAssign(10:11-10:12),LowerIdent(10:13-10:14),OpPlus(10:15-10:16),LowerIdent(10:17-10:18), +LowerIdent(11:9-11:10),OpPlus(11:11-11:12),Int(11:13-11:14), +CloseCurly(12:5-12:6), +LowerIdent(13:5-13:16), +CloseCurly(14:1-14:2), +EndOfFile(15:1-15:1), ~~~ # PARSE ~~~clojure -(file @1.1-16.2 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @2.1-14.2 + (type-module @2.1-2.2) (statements - (s-decl @4.1-4.6 - (p-ident @4.1-4.2 (raw "x")) - (e-int @4.5-4.6 (raw "5"))) - (s-decl @5.1-5.7 - (p-ident @5.1-5.2 (raw "y")) - (e-int @5.5-5.7 (raw "10"))) - (s-decl @8.1-16.2 - (p-ident @8.1-8.10 (raw "outerFunc")) - (e-lambda @8.13-16.2 + (s-decl @2.1-2.6 + (p-ident @2.1-2.2 (raw "x")) + (e-int @2.5-2.6 (raw "5"))) + (s-decl @3.1-3.7 + (p-ident @3.1-3.2 (raw "y")) + (e-int @3.5-3.7 (raw "10"))) + (s-decl @6.1-14.2 + (p-ident @6.1-6.10 (raw "outerFunc")) + (e-lambda @6.13-14.2 (args (p-underscore)) - (e-block @8.17-16.2 + (e-block @6.17-14.2 (statements - (s-decl @9.5-9.11 - (p-ident @9.5-9.6 (raw "x")) - (e-int @9.9-9.11 (raw "20"))) - (s-decl @10.5-14.6 - (p-ident @10.5-10.16 (raw "innerResult")) - (e-block @10.19-14.6 + (s-decl @7.5-7.11 + (p-ident @7.5-7.6 (raw "x")) + (e-int @7.9-7.11 (raw "20"))) + (s-decl @8.5-12.6 + (p-ident @8.5-8.16 (raw "innerResult")) + (e-block @8.19-12.6 (statements - (s-decl @12.9-12.18 - (p-ident @12.9-12.10 (raw "z")) - (e-binop @12.13-12.18 (op "+") - (e-ident @12.13-12.14 (raw "x")) - (e-ident @12.17-12.18 (raw "y")))) - (e-binop @13.9-13.14 (op "+") - (e-ident @13.9-13.10 (raw "z")) - (e-int @13.13-13.14 (raw "1")))))) - (e-ident @15.5-15.16 (raw "innerResult")))))))) + (s-decl @10.9-10.18 + (p-ident @10.9-10.10 (raw "z")) + (e-binop @10.13-10.18 (op "+") + (e-ident @10.13-10.14 (raw "x")) + (e-ident @10.17-10.18 (raw "y")))) + (e-binop @11.9-11.14 (op "+") + (e-ident @11.9-11.10 (raw "z")) + (e-int @11.13-11.14 (raw "1")))))) + (e-ident @13.5-13.16 (raw "innerResult")))))))) ~~~ # FORMATTED ~~~roc -module [] - +# Top-level variables # Top-level variables x = 5 y = 10 @@ -117,49 +112,49 @@ outerFunc = |_| { ~~~clojure (can-ir (d-let - (p-assign @4.1-4.2 (ident "x")) - (e-int @4.5-4.6 (value "5"))) + (p-assign @2.1-2.2 (ident "x")) + (e-num @2.5-2.6 (value "5"))) (d-let - (p-assign @5.1-5.2 (ident "y")) - (e-int @5.5-5.7 (value "10"))) + (p-assign @3.1-3.2 (ident "y")) + (e-num @3.5-3.7 (value "10"))) (d-let - (p-assign @8.1-8.10 (ident "outerFunc")) - (e-closure @8.13-16.2 + (p-assign @6.1-6.10 (ident "outerFunc")) + (e-closure @6.13-14.2 (captures - (capture @5.1-5.2 (ident "y"))) - (e-lambda @8.13-16.2 + (capture @3.1-3.2 (ident "y"))) + (e-lambda @6.13-14.2 (args - (p-underscore @8.14-8.15)) - (e-block @8.17-16.2 - (s-let @9.5-9.11 - (p-assign @9.5-9.6 (ident "x")) - (e-int @9.9-9.11 (value "20"))) - (s-let @10.5-14.6 - (p-assign @10.5-10.16 (ident "innerResult")) - (e-block @10.19-14.6 - (s-let @12.9-12.18 - (p-assign @12.9-12.10 (ident "z")) - (e-binop @12.13-12.18 (op "add") - (e-lookup-local @12.13-12.14 - (p-assign @9.5-9.6 (ident "x"))) - (e-lookup-local @12.17-12.18 - (p-assign @5.1-5.2 (ident "y"))))) - (e-binop @13.9-13.14 (op "add") - (e-lookup-local @13.9-13.10 - (p-assign @12.9-12.10 (ident "z"))) - (e-int @13.13-13.14 (value "1"))))) - (e-lookup-local @15.5-15.16 - (p-assign @10.5-10.16 (ident "innerResult")))))))) + (p-underscore @6.14-6.15)) + (e-block @6.17-14.2 + (s-let @7.5-7.11 + (p-assign @7.5-7.6 (ident "x")) + (e-num @7.9-7.11 (value "20"))) + (s-let @8.5-12.6 + (p-assign @8.5-8.16 (ident "innerResult")) + (e-block @8.19-12.6 + (s-let @10.9-10.18 + (p-assign @10.9-10.10 (ident "z")) + (e-binop @10.13-10.18 (op "add") + (e-lookup-local @10.13-10.14 + (p-assign @7.5-7.6 (ident "x"))) + (e-lookup-local @10.17-10.18 + (p-assign @3.1-3.2 (ident "y"))))) + (e-binop @11.9-11.14 (op "add") + (e-lookup-local @11.9-11.10 + (p-assign @10.9-10.10 (ident "z"))) + (e-num @11.13-11.14 (value "1"))))) + (e-lookup-local @13.5-13.16 + (p-assign @8.5-8.16 (ident "innerResult")))))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @4.1-4.2 (type "Num(_size)")) - (patt @5.1-5.2 (type "Num(_size)")) - (patt @8.1-8.10 (type "_arg -> Num(_size)"))) + (patt @2.1-2.2 (type "Num(_size)")) + (patt @3.1-3.2 (type "Num(_size)")) + (patt @6.1-6.10 (type "_arg -> Num(_size)"))) (expressions - (expr @4.5-4.6 (type "Num(_size)")) - (expr @5.5-5.7 (type "Num(_size)")) - (expr @8.13-16.2 (type "_arg -> Num(_size)")))) + (expr @2.5-2.6 (type "Num(_size)")) + (expr @3.5-3.7 (type "Num(_size)")) + (expr @6.13-14.2 (type "_arg -> Num(_size)")))) ~~~ diff --git a/test/snapshots/can_dot_access.md b/test/snapshots/can_dot_access.md index d799ebce32..3116012a34 100644 --- a/test/snapshots/can_dot_access.md +++ b/test/snapshots/can_dot_access.md @@ -60,5 +60,5 @@ NO CHANGE ~~~ # TYPES ~~~clojure -(expr @1.1-1.13 (type "_a")) +(expr @1.1-1.13 (type "Error")) ~~~ diff --git a/test/snapshots/can_dot_access_with_vars.md b/test/snapshots/can_dot_access_with_vars.md index e10278a9c4..7dc09e8d05 100644 --- a/test/snapshots/can_dot_access_with_vars.md +++ b/test/snapshots/can_dot_access_with_vars.md @@ -63,9 +63,9 @@ EndOfFile(6:1-6:1), (p-assign @2.5-2.9 (ident "list")) (e-list @2.12-2.21 (elems - (e-int @2.13-2.14 (value "1")) - (e-int @2.16-2.17 (value "2")) - (e-int @2.19-2.20 (value "3"))))) + (e-num @2.13-2.14 (value "1")) + (e-num @2.16-2.17 (value "2")) + (e-num @2.19-2.20 (value "3"))))) (s-let @3.5-3.19 (p-assign @3.5-3.7 (ident "fn")) (e-lambda @3.10-3.19 @@ -74,7 +74,7 @@ EndOfFile(6:1-6:1), (e-binop @3.14-3.19 (op "add") (e-lookup-local @3.14-3.15 (p-assign @3.11-3.12 (ident "x"))) - (e-int @3.18-3.19 (value "1"))))) + (e-num @3.18-3.19 (value "1"))))) (e-dot-access @4.5-4.17 (field "map") (receiver (e-lookup-local @4.5-4.9 diff --git a/test/snapshots/can_frac_literal.md b/test/snapshots/can_frac_literal.md index 2e40f9ffc5..15d6a381d2 100644 --- a/test/snapshots/can_frac_literal.md +++ b/test/snapshots/can_frac_literal.md @@ -1,12 +1,10 @@ # META ~~~ini description=Float literal type inference -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - x = 3.14 y = 1.23e45 z = 0.5 @@ -17,27 +15,25 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -LowerIdent(3:1-3:2),OpAssign(3:3-3:4),Float(3:5-3:9), -LowerIdent(4:1-4:2),OpAssign(4:3-4:4),Float(4:5-4:12), -LowerIdent(5:1-5:2),OpAssign(5:3-5:4),Float(5:5-5:8), -EndOfFile(6:1-6:1), +LowerIdent(1:1-1:2),OpAssign(1:3-1:4),Float(1:5-1:9), +LowerIdent(2:1-2:2),OpAssign(2:3-2:4),Float(2:5-2:12), +LowerIdent(3:1-3:2),OpAssign(3:3-3:4),Float(3:5-3:8), +EndOfFile(4:1-4:1), ~~~ # PARSE ~~~clojure -(file @1.1-5.8 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-3.8 + (type-module @1.1-1.2) (statements - (s-decl @3.1-3.9 - (p-ident @3.1-3.2 (raw "x")) - (e-frac @3.5-3.9 (raw "3.14"))) - (s-decl @4.1-4.12 - (p-ident @4.1-4.2 (raw "y")) - (e-frac @4.5-4.12 (raw "1.23e45"))) - (s-decl @5.1-5.8 - (p-ident @5.1-5.2 (raw "z")) - (e-frac @5.5-5.8 (raw "0.5"))))) + (s-decl @1.1-1.9 + (p-ident @1.1-1.2 (raw "x")) + (e-frac @1.5-1.9 (raw "3.14"))) + (s-decl @2.1-2.12 + (p-ident @2.1-2.2 (raw "y")) + (e-frac @2.5-2.12 (raw "1.23e45"))) + (s-decl @3.1-3.8 + (p-ident @3.1-3.2 (raw "z")) + (e-frac @3.5-3.8 (raw "0.5"))))) ~~~ # FORMATTED ~~~roc @@ -47,24 +43,24 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @3.1-3.2 (ident "x")) - (e-dec-small @3.5-3.9 (numerator "314") (denominator-power-of-ten "2") (value "3.14"))) + (p-assign @1.1-1.2 (ident "x")) + (e-dec-small @1.5-1.9 (numerator "314") (denominator-power-of-ten "2") (value "3.14"))) (d-let - (p-assign @4.1-4.2 (ident "y")) - (e-frac-f64 @4.5-4.12 (value "1.23e45"))) + (p-assign @2.1-2.2 (ident "y")) + (e-frac-f64 @2.5-2.12 (value "1.23e45"))) (d-let - (p-assign @5.1-5.2 (ident "z")) - (e-dec-small @5.5-5.8 (numerator "5") (denominator-power-of-ten "1") (value "0.5")))) + (p-assign @3.1-3.2 (ident "z")) + (e-dec-small @3.5-3.8 (numerator "5") (denominator-power-of-ten "1") (value "0.5")))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @3.1-3.2 (type "Frac(_size)")) - (patt @4.1-4.2 (type "Frac(_size)")) - (patt @5.1-5.2 (type "Frac(_size)"))) + (patt @1.1-1.2 (type "Num(Frac(_size))")) + (patt @2.1-2.2 (type "Num(Frac(_size))")) + (patt @3.1-3.2 (type "Num(Frac(_size))"))) (expressions - (expr @3.5-3.9 (type "Frac(_size)")) - (expr @4.5-4.12 (type "Frac(_size)")) - (expr @5.5-5.8 (type "Frac(_size)")))) + (expr @1.5-1.9 (type "Num(Frac(_size))")) + (expr @2.5-2.12 (type "Num(Frac(_size))")) + (expr @3.5-3.8 (type "Num(Frac(_size))")))) ~~~ diff --git a/test/snapshots/can_hex_integer.md b/test/snapshots/can_hex_integer.md index 3cb0c1d5ba..e42af654a2 100644 --- a/test/snapshots/can_hex_integer.md +++ b/test/snapshots/can_hex_integer.md @@ -1,12 +1,10 @@ # META ~~~ini description=Hexadecimal integer literal type inference -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - x = 0xFF ~~~ # EXPECTED @@ -15,19 +13,17 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -LowerIdent(3:1-3:2),OpAssign(3:3-3:4),Int(3:5-3:9), -EndOfFile(4:1-4:1), +LowerIdent(1:1-1:2),OpAssign(1:3-1:4),Int(1:5-1:9), +EndOfFile(2:1-2:1), ~~~ # PARSE ~~~clojure -(file @1.1-3.9 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-1.9 + (type-module @1.1-1.2) (statements - (s-decl @3.1-3.9 - (p-ident @3.1-3.2 (raw "x")) - (e-int @3.5-3.9 (raw "0xFF"))))) + (s-decl @1.1-1.9 + (p-ident @1.1-1.2 (raw "x")) + (e-int @1.5-1.9 (raw "0xFF"))))) ~~~ # FORMATTED ~~~roc @@ -37,14 +33,14 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @3.1-3.2 (ident "x")) - (e-int @3.5-3.9 (value "255")))) + (p-assign @1.1-1.2 (ident "x")) + (e-num @1.5-1.9 (value "255")))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @3.1-3.2 (type "Int(_size)"))) + (patt @1.1-1.2 (type "Num(Int(_size))"))) (expressions - (expr @3.5-3.9 (type "Int(_size)")))) + (expr @1.5-1.9 (type "Num(Int(_size))")))) ~~~ diff --git a/test/snapshots/can_import_comprehensive.md b/test/snapshots/can_import_comprehensive.md index d2d6cba598..e8717f54f2 100644 --- a/test/snapshots/can_import_comprehensive.md +++ b/test/snapshots/can_import_comprehensive.md @@ -1,12 +1,10 @@ # META ~~~ini description=Comprehensive import test with various module access patterns -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - import json.Json import http.Client as Http exposing [get, post] import utils.String as Str @@ -42,15 +40,17 @@ main = { } ~~~ # EXPECTED -MODULE NOT FOUND - can_import_comprehensive.md:3:1:3:17 -MODULE NOT FOUND - can_import_comprehensive.md:4:1:4:48 -MODULE NOT FOUND - can_import_comprehensive.md:5:1:5:27 +MODULE NOT FOUND - can_import_comprehensive.md:1:1:1:17 +MODULE NOT FOUND - can_import_comprehensive.md:2:1:2:48 +MODULE NOT FOUND - can_import_comprehensive.md:3:1:3:27 +UNDEFINED VARIABLE - can_import_comprehensive.md:17:15:17:18 +UNDEFINED VARIABLE - can_import_comprehensive.md:18:15:18:19 # PROBLEMS **MODULE NOT FOUND** The module `json.Json` was not found in this Roc project. You're attempting to use this module here: -**can_import_comprehensive.md:3:1:3:17:** +**can_import_comprehensive.md:1:1:1:17:** ```roc import json.Json ``` @@ -61,7 +61,7 @@ import json.Json The module `http.Client` was not found in this Roc project. You're attempting to use this module here: -**can_import_comprehensive.md:4:1:4:48:** +**can_import_comprehensive.md:2:1:2:48:** ```roc import http.Client as Http exposing [get, post] ``` @@ -72,97 +72,115 @@ import http.Client as Http exposing [get, post] The module `utils.String` was not found in this Roc project. You're attempting to use this module here: -**can_import_comprehensive.md:5:1:5:27:** +**can_import_comprehensive.md:3:1:3:27:** ```roc import utils.String as Str ``` ^^^^^^^^^^^^^^^^^^^^^^^^^^ +**UNDEFINED VARIABLE** +Nothing is named `get` in this scope. +Is there an `import` or `exposing` missing up-top? + +**can_import_comprehensive.md:17:15:17:18:** +```roc + result3 = get +``` + ^^^ + + +**UNDEFINED VARIABLE** +Nothing is named `post` in this scope. +Is there an `import` or `exposing` missing up-top? + +**can_import_comprehensive.md:18:15:18:19:** +```roc + result4 = post +``` + ^^^^ + + # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -KwImport(3:1-3:7),LowerIdent(3:8-3:12),NoSpaceDotUpperIdent(3:12-3:17), -KwImport(4:1-4:7),LowerIdent(4:8-4:12),NoSpaceDotUpperIdent(4:12-4:19),KwAs(4:20-4:22),UpperIdent(4:23-4:27),KwExposing(4:28-4:36),OpenSquare(4:37-4:38),LowerIdent(4:38-4:41),Comma(4:41-4:42),LowerIdent(4:43-4:47),CloseSquare(4:47-4:48), -KwImport(5:1-5:7),LowerIdent(5:8-5:13),NoSpaceDotUpperIdent(5:13-5:20),KwAs(5:21-5:23),UpperIdent(5:24-5:27), -LowerIdent(7:1-7:5),OpAssign(7:6-7:7),OpenCurly(7:8-7:9), -LowerIdent(8:5-8:11),OpAssign(8:12-8:13),UpperIdent(8:14-8:18),NoSpaceDotLowerIdent(8:18-8:22), -LowerIdent(9:5-9:11),OpAssign(9:12-9:13),UpperIdent(9:14-9:18),NoSpaceDotLowerIdent(9:18-9:23), -LowerIdent(10:5-10:11),OpAssign(10:12-10:13),UpperIdent(10:14-10:17),NoSpaceDotLowerIdent(10:17-10:22), -LowerIdent(13:5-13:12),OpAssign(13:13-13:14),UpperIdent(13:15-13:19),NoSpaceDotLowerIdent(13:19-13:25), -LowerIdent(16:5-16:12),OpAssign(16:13-16:14),UpperIdent(16:15-16:19),NoSpaceDotLowerIdent(16:19-16:24), -LowerIdent(19:5-19:12),OpAssign(19:13-19:14),LowerIdent(19:15-19:18), -LowerIdent(20:5-20:12),OpAssign(20:13-20:14),LowerIdent(20:15-20:19), -LowerIdent(23:5-23:13),OpAssign(23:14-23:15),UpperIdent(23:16-23:19),NoSpaceDotLowerIdent(23:19-23:26), -OpenRound(25:5-25:6), +KwImport(1:1-1:7),LowerIdent(1:8-1:12),NoSpaceDotUpperIdent(1:12-1:17), +KwImport(2:1-2:7),LowerIdent(2:8-2:12),NoSpaceDotUpperIdent(2:12-2:19),KwAs(2:20-2:22),UpperIdent(2:23-2:27),KwExposing(2:28-2:36),OpenSquare(2:37-2:38),LowerIdent(2:38-2:41),Comma(2:41-2:42),LowerIdent(2:43-2:47),CloseSquare(2:47-2:48), +KwImport(3:1-3:7),LowerIdent(3:8-3:13),NoSpaceDotUpperIdent(3:13-3:20),KwAs(3:21-3:23),UpperIdent(3:24-3:27), +LowerIdent(5:1-5:5),OpAssign(5:6-5:7),OpenCurly(5:8-5:9), +LowerIdent(6:5-6:11),OpAssign(6:12-6:13),UpperIdent(6:14-6:18),NoSpaceDotLowerIdent(6:18-6:22), +LowerIdent(7:5-7:11),OpAssign(7:12-7:13),UpperIdent(7:14-7:18),NoSpaceDotLowerIdent(7:18-7:23), +LowerIdent(8:5-8:11),OpAssign(8:12-8:13),UpperIdent(8:14-8:17),NoSpaceDotLowerIdent(8:17-8:22), +LowerIdent(11:5-11:12),OpAssign(11:13-11:14),UpperIdent(11:15-11:19),NoSpaceDotLowerIdent(11:19-11:25), +LowerIdent(14:5-14:12),OpAssign(14:13-14:14),UpperIdent(14:15-14:19),NoSpaceDotLowerIdent(14:19-14:24), +LowerIdent(17:5-17:12),OpAssign(17:13-17:14),LowerIdent(17:15-17:18), +LowerIdent(18:5-18:12),OpAssign(18:13-18:14),LowerIdent(18:15-18:19), +LowerIdent(21:5-21:13),OpAssign(21:14-21:15),UpperIdent(21:16-21:19),NoSpaceDotLowerIdent(21:19-21:26), +OpenRound(23:5-23:6), +LowerIdent(24:9-24:15),Comma(24:15-24:16), +LowerIdent(25:9-25:15),Comma(25:15-25:16), LowerIdent(26:9-26:15),Comma(26:15-26:16), -LowerIdent(27:9-27:15),Comma(27:15-27:16), -LowerIdent(28:9-28:15),Comma(28:15-28:16), +LowerIdent(27:9-27:16),Comma(27:16-27:17), +LowerIdent(28:9-28:16),Comma(28:16-28:17), LowerIdent(29:9-29:16),Comma(29:16-29:17), LowerIdent(30:9-30:16),Comma(30:16-30:17), -LowerIdent(31:9-31:16),Comma(31:16-31:17), -LowerIdent(32:9-32:16),Comma(32:16-32:17), -LowerIdent(33:9-33:17),Comma(33:17-33:18), -CloseRound(34:5-34:6), -CloseCurly(35:1-35:2), -EndOfFile(36:1-36:1), +LowerIdent(31:9-31:17),Comma(31:17-31:18), +CloseRound(32:5-32:6), +CloseCurly(33:1-33:2), +EndOfFile(34:1-34:1), ~~~ # PARSE ~~~clojure -(file @1.1-35.2 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-33.2 + (type-module @1.1-1.7) (statements - (s-import @3.1-3.17 (raw "json.Json")) - (s-import @4.1-4.48 (raw "http.Client") (alias "Http") + (s-import @1.1-1.17 (raw "json.Json")) + (s-import @2.1-2.48 (raw "http.Client") (alias "Http") (exposing - (exposed-lower-ident @4.38-4.41 + (exposed-lower-ident @2.38-2.41 (text "get")) - (exposed-lower-ident @4.43-4.47 + (exposed-lower-ident @2.43-2.47 (text "post")))) - (s-import @5.1-5.27 (raw "utils.String") (alias "Str")) - (s-decl @7.1-35.2 - (p-ident @7.1-7.5 (raw "main")) - (e-block @7.8-35.2 + (s-import @3.1-3.27 (raw "utils.String") (alias "Str")) + (s-decl @5.1-33.2 + (p-ident @5.1-5.5 (raw "main")) + (e-block @5.8-33.2 (statements + (s-decl @6.5-6.22 + (p-ident @6.5-6.11 (raw "client")) + (e-ident @6.14-6.22 (raw "Http.get"))) + (s-decl @7.5-7.23 + (p-ident @7.5-7.11 (raw "parser")) + (e-ident @7.14-7.23 (raw "Json.utf8"))) (s-decl @8.5-8.22 - (p-ident @8.5-8.11 (raw "client")) - (e-ident @8.14-8.22 (raw "Http.get"))) - (s-decl @9.5-9.23 - (p-ident @9.5-9.11 (raw "parser")) - (e-ident @9.14-9.23 (raw "Json.utf8"))) - (s-decl @10.5-10.22 - (p-ident @10.5-10.11 (raw "helper")) - (e-ident @10.14-10.22 (raw "Str.trim"))) - (s-decl @13.5-13.25 - (p-ident @13.5-13.12 (raw "result1")) - (e-ident @13.15-13.25 (raw "Json.parse"))) - (s-decl @16.5-16.24 - (p-ident @16.5-16.12 (raw "result2")) - (e-ident @16.15-16.24 (raw "Http.post"))) - (s-decl @19.5-19.18 - (p-ident @19.5-19.12 (raw "result3")) - (e-ident @19.15-19.18 (raw "get"))) - (s-decl @20.5-20.19 - (p-ident @20.5-20.12 (raw "result4")) - (e-ident @20.15-20.19 (raw "post"))) - (s-decl @23.5-23.26 - (p-ident @23.5-23.13 (raw "combined")) - (e-ident @23.16-23.26 (raw "Str.concat"))) - (e-tuple @25.5-34.6 - (e-ident @26.9-26.15 (raw "client")) - (e-ident @27.9-27.15 (raw "parser")) - (e-ident @28.9-28.15 (raw "helper")) - (e-ident @29.9-29.16 (raw "result1")) - (e-ident @30.9-30.16 (raw "result2")) - (e-ident @31.9-31.16 (raw "result3")) - (e-ident @32.9-32.16 (raw "result4")) - (e-ident @33.9-33.17 (raw "combined")))))))) + (p-ident @8.5-8.11 (raw "helper")) + (e-ident @8.14-8.22 (raw "Str.trim"))) + (s-decl @11.5-11.25 + (p-ident @11.5-11.12 (raw "result1")) + (e-ident @11.15-11.25 (raw "Json.parse"))) + (s-decl @14.5-14.24 + (p-ident @14.5-14.12 (raw "result2")) + (e-ident @14.15-14.24 (raw "Http.post"))) + (s-decl @17.5-17.18 + (p-ident @17.5-17.12 (raw "result3")) + (e-ident @17.15-17.18 (raw "get"))) + (s-decl @18.5-18.19 + (p-ident @18.5-18.12 (raw "result4")) + (e-ident @18.15-18.19 (raw "post"))) + (s-decl @21.5-21.26 + (p-ident @21.5-21.13 (raw "combined")) + (e-ident @21.16-21.26 (raw "Str.concat"))) + (e-tuple @23.5-32.6 + (e-ident @24.9-24.15 (raw "client")) + (e-ident @25.9-25.15 (raw "parser")) + (e-ident @26.9-26.15 (raw "helper")) + (e-ident @27.9-27.16 (raw "result1")) + (e-ident @28.9-28.16 (raw "result2")) + (e-ident @29.9-29.16 (raw "result3")) + (e-ident @30.9-30.16 (raw "result4")) + (e-ident @31.9-31.17 (raw "combined")))))))) ~~~ # FORMATTED ~~~roc -module [] - import json.Json import http.Client as Http exposing [get, post] import utils.String as Str @@ -201,80 +219,76 @@ main = { ~~~clojure (can-ir (d-let - (p-assign @7.1-7.5 (ident "main")) - (e-block @7.8-35.2 + (p-assign @5.1-5.5 (ident "main")) + (e-block @5.8-33.2 + (s-let @6.5-6.22 + (p-assign @6.5-6.11 (ident "client")) + (e-lookup-external @6.14-6.22 + (module-idx "3") + (target-node-idx "0"))) + (s-let @7.5-7.23 + (p-assign @7.5-7.11 (ident "parser")) + (e-lookup-external @7.14-7.23 + (module-idx "2") + (target-node-idx "0"))) (s-let @8.5-8.22 - (p-assign @8.5-8.11 (ident "client")) + (p-assign @8.5-8.11 (ident "helper")) (e-lookup-external @8.14-8.22 - (module-idx "1") + (module-idx "4") (target-node-idx "0"))) - (s-let @9.5-9.23 - (p-assign @9.5-9.11 (ident "parser")) - (e-lookup-external @9.14-9.23 - (module-idx "0") - (target-node-idx "0"))) - (s-let @10.5-10.22 - (p-assign @10.5-10.11 (ident "helper")) - (e-lookup-external @10.14-10.22 + (s-let @11.5-11.25 + (p-assign @11.5-11.12 (ident "result1")) + (e-lookup-external @11.15-11.25 (module-idx "2") (target-node-idx "0"))) - (s-let @13.5-13.25 - (p-assign @13.5-13.12 (ident "result1")) - (e-lookup-external @13.15-13.25 - (module-idx "0") + (s-let @14.5-14.24 + (p-assign @14.5-14.12 (ident "result2")) + (e-lookup-external @14.15-14.24 + (module-idx "3") (target-node-idx "0"))) - (s-let @16.5-16.24 - (p-assign @16.5-16.12 (ident "result2")) - (e-lookup-external @16.15-16.24 - (module-idx "1") + (s-let @17.5-17.18 + (p-assign @17.5-17.12 (ident "result3")) + (e-runtime-error (tag "ident_not_in_scope"))) + (s-let @18.5-18.19 + (p-assign @18.5-18.12 (ident "result4")) + (e-runtime-error (tag "ident_not_in_scope"))) + (s-let @21.5-21.26 + (p-assign @21.5-21.13 (ident "combined")) + (e-lookup-external @21.16-21.26 + (module-idx "4") (target-node-idx "0"))) - (s-let @19.5-19.18 - (p-assign @19.5-19.12 (ident "result3")) - (e-lookup-external @19.15-19.18 - (module-idx "1") - (target-node-idx "0"))) - (s-let @20.5-20.19 - (p-assign @20.5-20.12 (ident "result4")) - (e-lookup-external @20.15-20.19 - (module-idx "1") - (target-node-idx "0"))) - (s-let @23.5-23.26 - (p-assign @23.5-23.13 (ident "combined")) - (e-lookup-external @23.16-23.26 - (module-idx "2") - (target-node-idx "0"))) - (e-tuple @25.5-34.6 + (e-tuple @23.5-32.6 (elems + (e-lookup-local @24.9-24.15 + (p-assign @6.5-6.11 (ident "client"))) + (e-lookup-local @25.9-25.15 + (p-assign @7.5-7.11 (ident "parser"))) (e-lookup-local @26.9-26.15 - (p-assign @8.5-8.11 (ident "client"))) - (e-lookup-local @27.9-27.15 - (p-assign @9.5-9.11 (ident "parser"))) - (e-lookup-local @28.9-28.15 - (p-assign @10.5-10.11 (ident "helper"))) + (p-assign @8.5-8.11 (ident "helper"))) + (e-lookup-local @27.9-27.16 + (p-assign @11.5-11.12 (ident "result1"))) + (e-lookup-local @28.9-28.16 + (p-assign @14.5-14.12 (ident "result2"))) (e-lookup-local @29.9-29.16 - (p-assign @13.5-13.12 (ident "result1"))) + (p-assign @17.5-17.12 (ident "result3"))) (e-lookup-local @30.9-30.16 - (p-assign @16.5-16.12 (ident "result2"))) - (e-lookup-local @31.9-31.16 - (p-assign @19.5-19.12 (ident "result3"))) - (e-lookup-local @32.9-32.16 - (p-assign @20.5-20.12 (ident "result4"))) - (e-lookup-local @33.9-33.17 - (p-assign @23.5-23.13 (ident "combined"))))))) - (s-import @3.1-3.17 (module "json.Json") (qualifier "json") + (p-assign @18.5-18.12 (ident "result4"))) + (e-lookup-local @31.9-31.17 + (p-assign @21.5-21.13 (ident "combined"))))))) + (s-import @1.1-1.17 (module "json.Json") (qualifier "json") (exposes)) - (s-import @4.1-4.48 (module "http.Client") (qualifier "http") (alias "Http") + (s-import @2.1-2.48 (module "http.Client") (qualifier "http") (alias "Http") (exposes (exposed (name "get") (wildcard false)) (exposed (name "post") (wildcard false)))) - (s-import @5.1-5.27 (module "utils.String") (qualifier "utils") (alias "Str") + (s-import @3.1-3.27 (module "utils.String") (qualifier "utils") (alias "Str") (exposes))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @7.1-7.5 (type "(Error, Error, Error, Error, Error, Error, Error, Error)"))) + (patt @5.1-5.5 (type "(Error, Error, Error, Error, Error, Error, Error, Error)"))) (expressions - (expr @7.8-35.2 (type "(Error, Error, Error, Error, Error, Error, Error, Error)")))) + (expr @5.8-33.2 (type "(Error, Error, Error, Error, Error, Error, Error, Error)")))) ~~~ diff --git a/test/snapshots/can_import_exposing_types.md b/test/snapshots/can_import_exposing_types.md index 76984c2d73..3c4fa354c2 100644 --- a/test/snapshots/can_import_exposing_types.md +++ b/test/snapshots/can_import_exposing_types.md @@ -1,12 +1,10 @@ # META ~~~ini description=Import types using exposing syntax -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - import json.Json exposing [Value, Error, Config] import http.Client as Http exposing [Request, Response, Status] import utils.Result exposing [Result] @@ -61,35 +59,35 @@ combineResults = |jsonResult, httpStatus| } ~~~ # EXPECTED -UNDECLARED TYPE - can_import_exposing_types.md:31:18:31:24 -UNDECLARED TYPE - can_import_exposing_types.md:32:18:32:24 -UNDECLARED TYPE - can_import_exposing_types.md:33:23:33:31 -MODULE NOT FOUND - can_import_exposing_types.md:3:1:3:49 -MODULE NOT FOUND - can_import_exposing_types.md:4:1:4:64 -MODULE NOT FOUND - can_import_exposing_types.md:5:1:5:38 -UNDECLARED TYPE - can_import_exposing_types.md:8:27:8:32 -UNDECLARED TYPE - can_import_exposing_types.md:8:34:8:39 -UNDECLARED TYPE - can_import_exposing_types.md:12:17:12:24 -UNDECLARED TYPE - can_import_exposing_types.md:12:28:12:36 -UNDECLARED TYPE - can_import_exposing_types.md:22:15:22:21 -UNDECLARED TYPE - can_import_exposing_types.md:22:28:22:33 -UNDECLARED TYPE - can_import_exposing_types.md:22:50:22:55 -UNDECLARED TYPE - can_import_exposing_types.md:22:58:22:63 -UNDEFINED VARIABLE - can_import_exposing_types.md:24:5:24:16 -UNDECLARED TYPE - can_import_exposing_types.md:37:16:37:22 -UNDECLARED TYPE - can_import_exposing_types.md:41:18:41:26 -UNDEFINED VARIABLE - can_import_exposing_types.md:45:23:45:37 -UNDECLARED TYPE - can_import_exposing_types.md:49:25:49:30 -UNDECLARED TYPE - can_import_exposing_types.md:49:32:49:37 -UNDECLARED TYPE - can_import_exposing_types.md:49:40:49:46 -UNDECLARED TYPE - can_import_exposing_types.md:49:57:49:65 -UNDECLARED TYPE - can_import_exposing_types.md:49:67:49:72 +UNDECLARED TYPE - can_import_exposing_types.md:29:18:29:24 +UNDECLARED TYPE - can_import_exposing_types.md:30:18:30:24 +UNDECLARED TYPE - can_import_exposing_types.md:31:23:31:31 +MODULE NOT FOUND - can_import_exposing_types.md:1:1:1:49 +MODULE NOT FOUND - can_import_exposing_types.md:2:1:2:64 +MODULE NOT FOUND - can_import_exposing_types.md:3:1:3:38 +UNDECLARED TYPE - can_import_exposing_types.md:6:27:6:32 +UNDECLARED TYPE - can_import_exposing_types.md:6:34:6:39 +UNDECLARED TYPE - can_import_exposing_types.md:10:17:10:24 +UNDECLARED TYPE - can_import_exposing_types.md:10:28:10:36 +UNDECLARED TYPE - can_import_exposing_types.md:20:15:20:21 +UNDECLARED TYPE - can_import_exposing_types.md:20:28:20:33 +UNDECLARED TYPE - can_import_exposing_types.md:20:50:20:55 +UNDECLARED TYPE - can_import_exposing_types.md:20:58:20:63 +UNDEFINED VARIABLE - can_import_exposing_types.md:22:5:22:16 +UNDECLARED TYPE - can_import_exposing_types.md:35:16:35:22 +UNDECLARED TYPE - can_import_exposing_types.md:39:18:39:26 +UNDEFINED VARIABLE - can_import_exposing_types.md:43:23:43:37 +UNDECLARED TYPE - can_import_exposing_types.md:47:25:47:30 +UNDECLARED TYPE - can_import_exposing_types.md:47:32:47:37 +UNDECLARED TYPE - can_import_exposing_types.md:47:40:47:46 +UNDECLARED TYPE - can_import_exposing_types.md:47:57:47:65 +UNDECLARED TYPE - can_import_exposing_types.md:47:67:47:72 # PROBLEMS **UNDECLARED TYPE** The type _Config_ is not declared in this scope. This type is referenced here: -**can_import_exposing_types.md:31:18:31:24:** +**can_import_exposing_types.md:29:18:29:24:** ```roc jsonConfig : Config, ``` @@ -100,7 +98,7 @@ This type is referenced here: The type _Status_ is not declared in this scope. This type is referenced here: -**can_import_exposing_types.md:32:18:32:24:** +**can_import_exposing_types.md:30:18:30:24:** ```roc httpStatus : Status, ``` @@ -111,7 +109,7 @@ This type is referenced here: The type _Response_ is not declared in this scope. This type is referenced here: -**can_import_exposing_types.md:33:23:33:31:** +**can_import_exposing_types.md:31:23:31:31:** ```roc defaultResponse : Response, ``` @@ -122,7 +120,7 @@ This type is referenced here: The module `json.Json` was not found in this Roc project. You're attempting to use this module here: -**can_import_exposing_types.md:3:1:3:49:** +**can_import_exposing_types.md:1:1:1:49:** ```roc import json.Json exposing [Value, Error, Config] ``` @@ -133,7 +131,7 @@ import json.Json exposing [Value, Error, Config] The module `http.Client` was not found in this Roc project. You're attempting to use this module here: -**can_import_exposing_types.md:4:1:4:64:** +**can_import_exposing_types.md:2:1:2:64:** ```roc import http.Client as Http exposing [Request, Response, Status] ``` @@ -144,7 +142,7 @@ import http.Client as Http exposing [Request, Response, Status] The module `utils.Result` was not found in this Roc project. You're attempting to use this module here: -**can_import_exposing_types.md:5:1:5:38:** +**can_import_exposing_types.md:3:1:3:38:** ```roc import utils.Result exposing [Result] ``` @@ -155,7 +153,7 @@ import utils.Result exposing [Result] The type _Value_ is not declared in this scope. This type is referenced here: -**can_import_exposing_types.md:8:27:8:32:** +**can_import_exposing_types.md:6:27:6:32:** ```roc parseJson : Str -> Result(Value, Error) ``` @@ -166,7 +164,7 @@ parseJson : Str -> Result(Value, Error) The type _Error_ is not declared in this scope. This type is referenced here: -**can_import_exposing_types.md:8:34:8:39:** +**can_import_exposing_types.md:6:34:6:39:** ```roc parseJson : Str -> Result(Value, Error) ``` @@ -177,7 +175,7 @@ parseJson : Str -> Result(Value, Error) The type _Request_ is not declared in this scope. This type is referenced here: -**can_import_exposing_types.md:12:17:12:24:** +**can_import_exposing_types.md:10:17:10:24:** ```roc handleRequest : Request -> Response ``` @@ -188,7 +186,7 @@ handleRequest : Request -> Response The type _Response_ is not declared in this scope. This type is referenced here: -**can_import_exposing_types.md:12:28:12:36:** +**can_import_exposing_types.md:10:28:10:36:** ```roc handleRequest : Request -> Response ``` @@ -199,7 +197,7 @@ handleRequest : Request -> Response The type _Config_ is not declared in this scope. This type is referenced here: -**can_import_exposing_types.md:22:15:22:21:** +**can_import_exposing_types.md:20:15:20:21:** ```roc processData : Config, List(Value) -> Result(List(Value), Error) ``` @@ -210,7 +208,7 @@ processData : Config, List(Value) -> Result(List(Value), Error) The type _Value_ is not declared in this scope. This type is referenced here: -**can_import_exposing_types.md:22:28:22:33:** +**can_import_exposing_types.md:20:28:20:33:** ```roc processData : Config, List(Value) -> Result(List(Value), Error) ``` @@ -221,7 +219,7 @@ processData : Config, List(Value) -> Result(List(Value), Error) The type _Value_ is not declared in this scope. This type is referenced here: -**can_import_exposing_types.md:22:50:22:55:** +**can_import_exposing_types.md:20:50:20:55:** ```roc processData : Config, List(Value) -> Result(List(Value), Error) ``` @@ -232,7 +230,7 @@ processData : Config, List(Value) -> Result(List(Value), Error) The type _Error_ is not declared in this scope. This type is referenced here: -**can_import_exposing_types.md:22:58:22:63:** +**can_import_exposing_types.md:20:58:20:63:** ```roc processData : Config, List(Value) -> Result(List(Value), Error) ``` @@ -243,7 +241,7 @@ processData : Config, List(Value) -> Result(List(Value), Error) Nothing is named `mapTry` in this scope. Is there an `import` or `exposing` missing up-top? -**can_import_exposing_types.md:24:5:24:16:** +**can_import_exposing_types.md:22:5:22:16:** ```roc List.mapTry( ``` @@ -254,7 +252,7 @@ Is there an `import` or `exposing` missing up-top? The type _Config_ is not declared in this scope. This type is referenced here: -**can_import_exposing_types.md:37:16:37:22:** +**can_import_exposing_types.md:35:16:35:22:** ```roc createClient : Config -> Http.Client ``` @@ -265,7 +263,7 @@ createClient : Config -> Http.Client The type _Response_ is not declared in this scope. This type is referenced here: -**can_import_exposing_types.md:41:18:41:26:** +**can_import_exposing_types.md:39:18:39:26:** ```roc handleResponse : Response -> Str ``` @@ -276,7 +274,7 @@ handleResponse : Response -> Str Nothing is named `toString` in this scope. Is there an `import` or `exposing` missing up-top? -**can_import_exposing_types.md:45:23:45:37:** +**can_import_exposing_types.md:43:23:43:37:** ```roc Err(error) => Error.toString(error) ``` @@ -287,7 +285,7 @@ Is there an `import` or `exposing` missing up-top? The type _Value_ is not declared in this scope. This type is referenced here: -**can_import_exposing_types.md:49:25:49:30:** +**can_import_exposing_types.md:47:25:47:30:** ```roc combineResults : Result(Value, Error), Status -> Result(Response, Error) ``` @@ -298,7 +296,7 @@ combineResults : Result(Value, Error), Status -> Result(Response, Error) The type _Error_ is not declared in this scope. This type is referenced here: -**can_import_exposing_types.md:49:32:49:37:** +**can_import_exposing_types.md:47:32:47:37:** ```roc combineResults : Result(Value, Error), Status -> Result(Response, Error) ``` @@ -309,7 +307,7 @@ combineResults : Result(Value, Error), Status -> Result(Response, Error) The type _Status_ is not declared in this scope. This type is referenced here: -**can_import_exposing_types.md:49:40:49:46:** +**can_import_exposing_types.md:47:40:47:46:** ```roc combineResults : Result(Value, Error), Status -> Result(Response, Error) ``` @@ -320,7 +318,7 @@ combineResults : Result(Value, Error), Status -> Result(Response, Error) The type _Response_ is not declared in this scope. This type is referenced here: -**can_import_exposing_types.md:49:57:49:65:** +**can_import_exposing_types.md:47:57:47:65:** ```roc combineResults : Result(Value, Error), Status -> Result(Response, Error) ``` @@ -331,7 +329,7 @@ combineResults : Result(Value, Error), Status -> Result(Response, Error) The type _Error_ is not declared in this scope. This type is referenced here: -**can_import_exposing_types.md:49:67:49:72:** +**can_import_exposing_types.md:47:67:47:72:** ```roc combineResults : Result(Value, Error), Status -> Result(Response, Error) ``` @@ -340,233 +338,229 @@ combineResults : Result(Value, Error), Status -> Result(Response, Error) # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -KwImport(3:1-3:7),LowerIdent(3:8-3:12),NoSpaceDotUpperIdent(3:12-3:17),KwExposing(3:18-3:26),OpenSquare(3:27-3:28),UpperIdent(3:28-3:33),Comma(3:33-3:34),UpperIdent(3:35-3:40),Comma(3:40-3:41),UpperIdent(3:42-3:48),CloseSquare(3:48-3:49), -KwImport(4:1-4:7),LowerIdent(4:8-4:12),NoSpaceDotUpperIdent(4:12-4:19),KwAs(4:20-4:22),UpperIdent(4:23-4:27),KwExposing(4:28-4:36),OpenSquare(4:37-4:38),UpperIdent(4:38-4:45),Comma(4:45-4:46),UpperIdent(4:47-4:55),Comma(4:55-4:56),UpperIdent(4:57-4:63),CloseSquare(4:63-4:64), -KwImport(5:1-5:7),LowerIdent(5:8-5:13),NoSpaceDotUpperIdent(5:13-5:20),KwExposing(5:21-5:29),OpenSquare(5:30-5:31),UpperIdent(5:31-5:37),CloseSquare(5:37-5:38), -LowerIdent(8:1-8:10),OpColon(8:11-8:12),UpperIdent(8:13-8:16),OpArrow(8:17-8:19),UpperIdent(8:20-8:26),NoSpaceOpenRound(8:26-8:27),UpperIdent(8:27-8:32),Comma(8:32-8:33),UpperIdent(8:34-8:39),CloseRound(8:39-8:40), -LowerIdent(9:1-9:10),OpAssign(9:11-9:12),OpBar(9:13-9:14),LowerIdent(9:14-9:19),OpBar(9:19-9:20),UpperIdent(9:21-9:25),NoSpaceDotLowerIdent(9:25-9:31),NoSpaceOpenRound(9:31-9:32),LowerIdent(9:32-9:37),CloseRound(9:37-9:38), -LowerIdent(12:1-12:14),OpColon(12:15-12:16),UpperIdent(12:17-12:24),OpArrow(12:25-12:27),UpperIdent(12:28-12:36), -LowerIdent(13:1-13:14),OpAssign(13:15-13:16),OpBar(13:17-13:18),LowerIdent(13:18-13:21),OpBar(13:21-13:22),OpenCurly(13:23-13:24), -LowerIdent(14:5-14:11),OpAssign(14:12-14:13),UpperIdent(14:14-14:18),NoSpaceDotLowerIdent(14:18-14:25),NoSpaceOpenRound(14:25-14:26),LowerIdent(14:26-14:29),NoSpaceDotLowerIdent(14:29-14:34),CloseRound(14:34-14:35), -KwMatch(15:5-15:10),LowerIdent(15:11-15:17),OpenCurly(15:18-15:19), -UpperIdent(16:9-16:11),NoSpaceOpenRound(16:11-16:12),LowerIdent(16:12-16:17),CloseRound(16:17-16:18),OpFatArrow(16:19-16:21),UpperIdent(16:22-16:26),NoSpaceDotLowerIdent(16:26-16:29),NoSpaceOpenRound(16:29-16:30),LowerIdent(16:30-16:35),CloseRound(16:35-16:36), -UpperIdent(17:9-17:12),NoSpaceOpenRound(17:12-17:13),LowerIdent(17:13-17:18),CloseRound(17:18-17:19),OpFatArrow(17:20-17:22),UpperIdent(17:23-17:27),NoSpaceDotLowerIdent(17:27-17:38),NoSpaceOpenRound(17:38-17:39),LowerIdent(17:39-17:44),CloseRound(17:44-17:45), -CloseCurly(18:5-18:6), -CloseCurly(19:1-19:2), -LowerIdent(22:1-22:12),OpColon(22:13-22:14),UpperIdent(22:15-22:21),Comma(22:21-22:22),UpperIdent(22:23-22:27),NoSpaceOpenRound(22:27-22:28),UpperIdent(22:28-22:33),CloseRound(22:33-22:34),OpArrow(22:35-22:37),UpperIdent(22:38-22:44),NoSpaceOpenRound(22:44-22:45),UpperIdent(22:45-22:49),NoSpaceOpenRound(22:49-22:50),UpperIdent(22:50-22:55),CloseRound(22:55-22:56),Comma(22:56-22:57),UpperIdent(22:58-22:63),CloseRound(22:63-22:64), -LowerIdent(23:1-23:12),OpAssign(23:13-23:14),OpBar(23:15-23:16),LowerIdent(23:16-23:22),Comma(23:22-23:23),LowerIdent(23:24-23:30),OpBar(23:30-23:31), -UpperIdent(24:5-24:9),NoSpaceDotLowerIdent(24:9-24:16),NoSpaceOpenRound(24:16-24:17), -LowerIdent(25:9-25:15),Comma(25:15-25:16), -OpBar(26:9-26:10),LowerIdent(26:10-26:11),OpBar(26:11-26:12),UpperIdent(26:13-26:17),NoSpaceDotLowerIdent(26:17-26:30),NoSpaceOpenRound(26:30-26:31),LowerIdent(26:31-26:37),Comma(26:37-26:38),LowerIdent(26:39-26:40),CloseRound(26:40-26:41),Comma(26:41-26:42), -CloseRound(27:5-27:6), -UpperIdent(30:1-30:13),OpColon(30:14-30:15),OpenCurly(30:16-30:17), -LowerIdent(31:5-31:15),OpColon(31:16-31:17),UpperIdent(31:18-31:24),Comma(31:24-31:25), -LowerIdent(32:5-32:15),OpColon(32:16-32:17),UpperIdent(32:18-32:24),Comma(32:24-32:25), -LowerIdent(33:5-33:20),OpColon(33:21-33:22),UpperIdent(33:23-33:31),Comma(33:31-33:32), -CloseCurly(34:1-34:2), -LowerIdent(37:1-37:13),OpColon(37:14-37:15),UpperIdent(37:16-37:22),OpArrow(37:23-37:25),UpperIdent(37:26-37:30),NoSpaceDotUpperIdent(37:30-37:37), -LowerIdent(38:1-38:13),OpAssign(38:14-38:15),OpBar(38:16-38:17),LowerIdent(38:17-38:23),OpBar(38:23-38:24),UpperIdent(38:25-38:29),NoSpaceDotLowerIdent(38:29-38:40),NoSpaceOpenRound(38:40-38:41),LowerIdent(38:41-38:47),CloseRound(38:47-38:48), -LowerIdent(41:1-41:15),OpColon(41:16-41:17),UpperIdent(41:18-41:26),OpArrow(41:27-41:29),UpperIdent(41:30-41:33), -LowerIdent(42:1-42:15),OpAssign(42:16-42:17),OpBar(42:18-42:19),LowerIdent(42:19-42:27),OpBar(42:27-42:28), -KwMatch(43:5-43:10),LowerIdent(43:11-43:19),NoSpaceDotLowerIdent(43:19-43:26),OpenCurly(43:27-43:28), -UpperIdent(44:9-44:11),NoSpaceOpenRound(44:11-44:12),LowerIdent(44:12-44:18),CloseRound(44:18-44:19),OpFatArrow(44:20-44:22),UpperIdent(44:23-44:27),NoSpaceDotLowerIdent(44:27-44:42),NoSpaceOpenRound(44:42-44:43),LowerIdent(44:43-44:49),CloseRound(44:49-44:50), -UpperIdent(45:9-45:12),NoSpaceOpenRound(45:12-45:13),LowerIdent(45:13-45:18),CloseRound(45:18-45:19),OpFatArrow(45:20-45:22),UpperIdent(45:23-45:28),NoSpaceDotLowerIdent(45:28-45:37),NoSpaceOpenRound(45:37-45:38),LowerIdent(45:38-45:43),CloseRound(45:43-45:44), -CloseCurly(46:5-46:6), -LowerIdent(49:1-49:15),OpColon(49:16-49:17),UpperIdent(49:18-49:24),NoSpaceOpenRound(49:24-49:25),UpperIdent(49:25-49:30),Comma(49:30-49:31),UpperIdent(49:32-49:37),CloseRound(49:37-49:38),Comma(49:38-49:39),UpperIdent(49:40-49:46),OpArrow(49:47-49:49),UpperIdent(49:50-49:56),NoSpaceOpenRound(49:56-49:57),UpperIdent(49:57-49:65),Comma(49:65-49:66),UpperIdent(49:67-49:72),CloseRound(49:72-49:73), -LowerIdent(50:1-50:15),OpAssign(50:16-50:17),OpBar(50:18-50:19),LowerIdent(50:19-50:29),Comma(50:29-50:30),LowerIdent(50:31-50:41),OpBar(50:41-50:42), -KwMatch(51:5-51:10),LowerIdent(51:11-51:21),OpenCurly(51:22-51:23), -UpperIdent(52:9-52:11),NoSpaceOpenRound(52:11-52:12),LowerIdent(52:12-52:17),CloseRound(52:17-52:18),OpFatArrow(52:19-52:21),UpperIdent(52:22-52:24),NoSpaceOpenRound(52:24-52:25),OpenCurly(52:25-52:26),LowerIdent(52:27-52:31),OpColon(52:31-52:32),UpperIdent(52:33-52:37),NoSpaceDotLowerIdent(52:37-52:44),NoSpaceOpenRound(52:44-52:45),LowerIdent(52:45-52:50),CloseRound(52:50-52:51),Comma(52:51-52:52),LowerIdent(52:53-52:59),OpColon(52:59-52:60),LowerIdent(52:61-52:71),CloseCurly(52:72-52:73),CloseRound(52:73-52:74), -UpperIdent(53:9-53:12),NoSpaceOpenRound(53:12-53:13),LowerIdent(53:13-53:18),CloseRound(53:18-53:19),OpFatArrow(53:20-53:22),UpperIdent(53:23-53:26),NoSpaceOpenRound(53:26-53:27),LowerIdent(53:27-53:32),CloseRound(53:32-53:33), -CloseCurly(54:5-54:6), -EndOfFile(55:1-55:1), +KwImport(1:1-1:7),LowerIdent(1:8-1:12),NoSpaceDotUpperIdent(1:12-1:17),KwExposing(1:18-1:26),OpenSquare(1:27-1:28),UpperIdent(1:28-1:33),Comma(1:33-1:34),UpperIdent(1:35-1:40),Comma(1:40-1:41),UpperIdent(1:42-1:48),CloseSquare(1:48-1:49), +KwImport(2:1-2:7),LowerIdent(2:8-2:12),NoSpaceDotUpperIdent(2:12-2:19),KwAs(2:20-2:22),UpperIdent(2:23-2:27),KwExposing(2:28-2:36),OpenSquare(2:37-2:38),UpperIdent(2:38-2:45),Comma(2:45-2:46),UpperIdent(2:47-2:55),Comma(2:55-2:56),UpperIdent(2:57-2:63),CloseSquare(2:63-2:64), +KwImport(3:1-3:7),LowerIdent(3:8-3:13),NoSpaceDotUpperIdent(3:13-3:20),KwExposing(3:21-3:29),OpenSquare(3:30-3:31),UpperIdent(3:31-3:37),CloseSquare(3:37-3:38), +LowerIdent(6:1-6:10),OpColon(6:11-6:12),UpperIdent(6:13-6:16),OpArrow(6:17-6:19),UpperIdent(6:20-6:26),NoSpaceOpenRound(6:26-6:27),UpperIdent(6:27-6:32),Comma(6:32-6:33),UpperIdent(6:34-6:39),CloseRound(6:39-6:40), +LowerIdent(7:1-7:10),OpAssign(7:11-7:12),OpBar(7:13-7:14),LowerIdent(7:14-7:19),OpBar(7:19-7:20),UpperIdent(7:21-7:25),NoSpaceDotLowerIdent(7:25-7:31),NoSpaceOpenRound(7:31-7:32),LowerIdent(7:32-7:37),CloseRound(7:37-7:38), +LowerIdent(10:1-10:14),OpColon(10:15-10:16),UpperIdent(10:17-10:24),OpArrow(10:25-10:27),UpperIdent(10:28-10:36), +LowerIdent(11:1-11:14),OpAssign(11:15-11:16),OpBar(11:17-11:18),LowerIdent(11:18-11:21),OpBar(11:21-11:22),OpenCurly(11:23-11:24), +LowerIdent(12:5-12:11),OpAssign(12:12-12:13),UpperIdent(12:14-12:18),NoSpaceDotLowerIdent(12:18-12:25),NoSpaceOpenRound(12:25-12:26),LowerIdent(12:26-12:29),NoSpaceDotLowerIdent(12:29-12:34),CloseRound(12:34-12:35), +KwMatch(13:5-13:10),LowerIdent(13:11-13:17),OpenCurly(13:18-13:19), +UpperIdent(14:9-14:11),NoSpaceOpenRound(14:11-14:12),LowerIdent(14:12-14:17),CloseRound(14:17-14:18),OpFatArrow(14:19-14:21),UpperIdent(14:22-14:26),NoSpaceDotLowerIdent(14:26-14:29),NoSpaceOpenRound(14:29-14:30),LowerIdent(14:30-14:35),CloseRound(14:35-14:36), +UpperIdent(15:9-15:12),NoSpaceOpenRound(15:12-15:13),LowerIdent(15:13-15:18),CloseRound(15:18-15:19),OpFatArrow(15:20-15:22),UpperIdent(15:23-15:27),NoSpaceDotLowerIdent(15:27-15:38),NoSpaceOpenRound(15:38-15:39),LowerIdent(15:39-15:44),CloseRound(15:44-15:45), +CloseCurly(16:5-16:6), +CloseCurly(17:1-17:2), +LowerIdent(20:1-20:12),OpColon(20:13-20:14),UpperIdent(20:15-20:21),Comma(20:21-20:22),UpperIdent(20:23-20:27),NoSpaceOpenRound(20:27-20:28),UpperIdent(20:28-20:33),CloseRound(20:33-20:34),OpArrow(20:35-20:37),UpperIdent(20:38-20:44),NoSpaceOpenRound(20:44-20:45),UpperIdent(20:45-20:49),NoSpaceOpenRound(20:49-20:50),UpperIdent(20:50-20:55),CloseRound(20:55-20:56),Comma(20:56-20:57),UpperIdent(20:58-20:63),CloseRound(20:63-20:64), +LowerIdent(21:1-21:12),OpAssign(21:13-21:14),OpBar(21:15-21:16),LowerIdent(21:16-21:22),Comma(21:22-21:23),LowerIdent(21:24-21:30),OpBar(21:30-21:31), +UpperIdent(22:5-22:9),NoSpaceDotLowerIdent(22:9-22:16),NoSpaceOpenRound(22:16-22:17), +LowerIdent(23:9-23:15),Comma(23:15-23:16), +OpBar(24:9-24:10),LowerIdent(24:10-24:11),OpBar(24:11-24:12),UpperIdent(24:13-24:17),NoSpaceDotLowerIdent(24:17-24:30),NoSpaceOpenRound(24:30-24:31),LowerIdent(24:31-24:37),Comma(24:37-24:38),LowerIdent(24:39-24:40),CloseRound(24:40-24:41),Comma(24:41-24:42), +CloseRound(25:5-25:6), +UpperIdent(28:1-28:13),OpColon(28:14-28:15),OpenCurly(28:16-28:17), +LowerIdent(29:5-29:15),OpColon(29:16-29:17),UpperIdent(29:18-29:24),Comma(29:24-29:25), +LowerIdent(30:5-30:15),OpColon(30:16-30:17),UpperIdent(30:18-30:24),Comma(30:24-30:25), +LowerIdent(31:5-31:20),OpColon(31:21-31:22),UpperIdent(31:23-31:31),Comma(31:31-31:32), +CloseCurly(32:1-32:2), +LowerIdent(35:1-35:13),OpColon(35:14-35:15),UpperIdent(35:16-35:22),OpArrow(35:23-35:25),UpperIdent(35:26-35:30),NoSpaceDotUpperIdent(35:30-35:37), +LowerIdent(36:1-36:13),OpAssign(36:14-36:15),OpBar(36:16-36:17),LowerIdent(36:17-36:23),OpBar(36:23-36:24),UpperIdent(36:25-36:29),NoSpaceDotLowerIdent(36:29-36:40),NoSpaceOpenRound(36:40-36:41),LowerIdent(36:41-36:47),CloseRound(36:47-36:48), +LowerIdent(39:1-39:15),OpColon(39:16-39:17),UpperIdent(39:18-39:26),OpArrow(39:27-39:29),UpperIdent(39:30-39:33), +LowerIdent(40:1-40:15),OpAssign(40:16-40:17),OpBar(40:18-40:19),LowerIdent(40:19-40:27),OpBar(40:27-40:28), +KwMatch(41:5-41:10),LowerIdent(41:11-41:19),NoSpaceDotLowerIdent(41:19-41:26),OpenCurly(41:27-41:28), +UpperIdent(42:9-42:11),NoSpaceOpenRound(42:11-42:12),LowerIdent(42:12-42:18),CloseRound(42:18-42:19),OpFatArrow(42:20-42:22),UpperIdent(42:23-42:27),NoSpaceDotLowerIdent(42:27-42:42),NoSpaceOpenRound(42:42-42:43),LowerIdent(42:43-42:49),CloseRound(42:49-42:50), +UpperIdent(43:9-43:12),NoSpaceOpenRound(43:12-43:13),LowerIdent(43:13-43:18),CloseRound(43:18-43:19),OpFatArrow(43:20-43:22),UpperIdent(43:23-43:28),NoSpaceDotLowerIdent(43:28-43:37),NoSpaceOpenRound(43:37-43:38),LowerIdent(43:38-43:43),CloseRound(43:43-43:44), +CloseCurly(44:5-44:6), +LowerIdent(47:1-47:15),OpColon(47:16-47:17),UpperIdent(47:18-47:24),NoSpaceOpenRound(47:24-47:25),UpperIdent(47:25-47:30),Comma(47:30-47:31),UpperIdent(47:32-47:37),CloseRound(47:37-47:38),Comma(47:38-47:39),UpperIdent(47:40-47:46),OpArrow(47:47-47:49),UpperIdent(47:50-47:56),NoSpaceOpenRound(47:56-47:57),UpperIdent(47:57-47:65),Comma(47:65-47:66),UpperIdent(47:67-47:72),CloseRound(47:72-47:73), +LowerIdent(48:1-48:15),OpAssign(48:16-48:17),OpBar(48:18-48:19),LowerIdent(48:19-48:29),Comma(48:29-48:30),LowerIdent(48:31-48:41),OpBar(48:41-48:42), +KwMatch(49:5-49:10),LowerIdent(49:11-49:21),OpenCurly(49:22-49:23), +UpperIdent(50:9-50:11),NoSpaceOpenRound(50:11-50:12),LowerIdent(50:12-50:17),CloseRound(50:17-50:18),OpFatArrow(50:19-50:21),UpperIdent(50:22-50:24),NoSpaceOpenRound(50:24-50:25),OpenCurly(50:25-50:26),LowerIdent(50:27-50:31),OpColon(50:31-50:32),UpperIdent(50:33-50:37),NoSpaceDotLowerIdent(50:37-50:44),NoSpaceOpenRound(50:44-50:45),LowerIdent(50:45-50:50),CloseRound(50:50-50:51),Comma(50:51-50:52),LowerIdent(50:53-50:59),OpColon(50:59-50:60),LowerIdent(50:61-50:71),CloseCurly(50:72-50:73),CloseRound(50:73-50:74), +UpperIdent(51:9-51:12),NoSpaceOpenRound(51:12-51:13),LowerIdent(51:13-51:18),CloseRound(51:18-51:19),OpFatArrow(51:20-51:22),UpperIdent(51:23-51:26),NoSpaceOpenRound(51:26-51:27),LowerIdent(51:27-51:32),CloseRound(51:32-51:33), +CloseCurly(52:5-52:6), +EndOfFile(53:1-53:1), ~~~ # PARSE ~~~clojure -(file @1.1-54.6 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-52.6 + (type-module @1.1-1.7) (statements - (s-import @3.1-3.49 (raw "json.Json") + (s-import @1.1-1.49 (raw "json.Json") (exposing - (exposed-upper-ident @3.28-3.33 (text "Value")) - (exposed-upper-ident @3.35-3.40 (text "Error")) - (exposed-upper-ident @3.42-3.48 (text "Config")))) - (s-import @4.1-4.64 (raw "http.Client") (alias "Http") + (exposed-upper-ident @1.28-1.33 (text "Value")) + (exposed-upper-ident @1.35-1.40 (text "Error")) + (exposed-upper-ident @1.42-1.48 (text "Config")))) + (s-import @2.1-2.64 (raw "http.Client") (alias "Http") (exposing - (exposed-upper-ident @4.38-4.45 (text "Request")) - (exposed-upper-ident @4.47-4.55 (text "Response")) - (exposed-upper-ident @4.57-4.63 (text "Status")))) - (s-import @5.1-5.38 (raw "utils.Result") + (exposed-upper-ident @2.38-2.45 (text "Request")) + (exposed-upper-ident @2.47-2.55 (text "Response")) + (exposed-upper-ident @2.57-2.63 (text "Status")))) + (s-import @3.1-3.38 (raw "utils.Result") (exposing - (exposed-upper-ident @5.31-5.37 (text "Result")))) - (s-type-anno @8.1-8.40 (name "parseJson") - (ty-fn @8.13-8.40 - (ty @8.13-8.16 (name "Str")) - (ty-apply @8.20-8.40 - (ty @8.20-8.26 (name "Result")) - (ty @8.27-8.32 (name "Value")) - (ty @8.34-8.39 (name "Error"))))) - (s-decl @9.1-9.38 - (p-ident @9.1-9.10 (raw "parseJson")) - (e-lambda @9.13-9.38 + (exposed-upper-ident @3.31-3.37 (text "Result")))) + (s-type-anno @6.1-6.40 (name "parseJson") + (ty-fn @6.13-6.40 + (ty @6.13-6.16 (name "Str")) + (ty-apply @6.20-6.40 + (ty @6.20-6.26 (name "Result")) + (ty @6.27-6.32 (name "Value")) + (ty @6.34-6.39 (name "Error"))))) + (s-decl @7.1-7.38 + (p-ident @7.1-7.10 (raw "parseJson")) + (e-lambda @7.13-7.38 (args - (p-ident @9.14-9.19 (raw "input"))) - (e-apply @9.21-9.38 - (e-ident @9.21-9.31 (raw "Json.parse")) - (e-ident @9.32-9.37 (raw "input"))))) - (s-type-anno @12.1-12.36 (name "handleRequest") - (ty-fn @12.17-12.36 - (ty @12.17-12.24 (name "Request")) - (ty @12.28-12.36 (name "Response")))) - (s-decl @13.1-19.2 - (p-ident @13.1-13.14 (raw "handleRequest")) - (e-lambda @13.17-19.2 + (p-ident @7.14-7.19 (raw "input"))) + (e-apply @7.21-7.38 + (e-ident @7.21-7.31 (raw "Json.parse")) + (e-ident @7.32-7.37 (raw "input"))))) + (s-type-anno @10.1-10.36 (name "handleRequest") + (ty-fn @10.17-10.36 + (ty @10.17-10.24 (name "Request")) + (ty @10.28-10.36 (name "Response")))) + (s-decl @11.1-17.2 + (p-ident @11.1-11.14 (raw "handleRequest")) + (e-lambda @11.17-17.2 (args - (p-ident @13.18-13.21 (raw "req"))) - (e-block @13.23-19.2 + (p-ident @11.18-11.21 (raw "req"))) + (e-block @11.23-17.2 (statements - (s-decl @14.5-14.35 - (p-ident @14.5-14.11 (raw "result")) - (e-apply @14.14-14.35 - (e-ident @14.14-14.25 (raw "Json.decode")) - (e-field-access @14.26-14.34 - (e-ident @14.26-14.29 (raw "req")) - (e-ident @14.29-14.34 (raw "body"))))) + (s-decl @12.5-12.35 + (p-ident @12.5-12.11 (raw "result")) + (e-apply @12.14-12.35 + (e-ident @12.14-12.25 (raw "Json.decode")) + (e-field-access @12.26-12.34 + (e-ident @12.26-12.29 (raw "req")) + (e-ident @12.29-12.34 (raw "body"))))) (e-match - (e-ident @15.11-15.17 (raw "result")) + (e-ident @13.11-13.17 (raw "result")) (branches - (branch @16.9-16.36 - (p-tag @16.9-16.18 (raw "Ok") - (p-ident @16.12-16.17 (raw "value"))) - (e-apply @16.22-16.36 - (e-ident @16.22-16.29 (raw "Http.ok")) - (e-ident @16.30-16.35 (raw "value")))) - (branch @17.9-17.45 - (p-tag @17.9-17.19 (raw "Err") - (p-ident @17.13-17.18 (raw "error"))) - (e-apply @17.23-17.45 - (e-ident @17.23-17.38 (raw "Http.badRequest")) - (e-ident @17.39-17.44 (raw "error")))))))))) - (s-type-anno @22.1-22.64 (name "processData") - (ty-fn @22.15-22.64 - (ty @22.15-22.21 (name "Config")) - (ty-apply @22.23-22.34 - (ty @22.23-22.27 (name "List")) - (ty @22.28-22.33 (name "Value"))) - (ty-apply @22.38-22.64 - (ty @22.38-22.44 (name "Result")) - (ty-apply @22.45-22.56 - (ty @22.45-22.49 (name "List")) - (ty @22.50-22.55 (name "Value"))) - (ty @22.58-22.63 (name "Error"))))) - (s-decl @23.1-27.6 - (p-ident @23.1-23.12 (raw "processData")) - (e-lambda @23.15-27.6 + (branch @14.9-14.36 + (p-tag @14.9-14.18 (raw "Ok") + (p-ident @14.12-14.17 (raw "value"))) + (e-apply @14.22-14.36 + (e-ident @14.22-14.29 (raw "Http.ok")) + (e-ident @14.30-14.35 (raw "value")))) + (branch @15.9-15.45 + (p-tag @15.9-15.19 (raw "Err") + (p-ident @15.13-15.18 (raw "error"))) + (e-apply @15.23-15.45 + (e-ident @15.23-15.38 (raw "Http.badRequest")) + (e-ident @15.39-15.44 (raw "error")))))))))) + (s-type-anno @20.1-20.64 (name "processData") + (ty-fn @20.15-20.64 + (ty @20.15-20.21 (name "Config")) + (ty-apply @20.23-20.34 + (ty @20.23-20.27 (name "List")) + (ty @20.28-20.33 (name "Value"))) + (ty-apply @20.38-20.64 + (ty @20.38-20.44 (name "Result")) + (ty-apply @20.45-20.56 + (ty @20.45-20.49 (name "List")) + (ty @20.50-20.55 (name "Value"))) + (ty @20.58-20.63 (name "Error"))))) + (s-decl @21.1-25.6 + (p-ident @21.1-21.12 (raw "processData")) + (e-lambda @21.15-25.6 (args - (p-ident @23.16-23.22 (raw "config")) - (p-ident @23.24-23.30 (raw "values"))) - (e-apply @24.5-27.6 - (e-ident @24.5-24.16 (raw "List.mapTry")) - (e-ident @25.9-25.15 (raw "values")) - (e-lambda @26.9-26.41 + (p-ident @21.16-21.22 (raw "config")) + (p-ident @21.24-21.30 (raw "values"))) + (e-apply @22.5-25.6 + (e-ident @22.5-22.16 (raw "List.mapTry")) + (e-ident @23.9-23.15 (raw "values")) + (e-lambda @24.9-24.41 (args - (p-ident @26.10-26.11 (raw "v"))) - (e-apply @26.13-26.41 - (e-ident @26.13-26.30 (raw "Json.validateWith")) - (e-ident @26.31-26.37 (raw "config")) - (e-ident @26.39-26.40 (raw "v"))))))) - (s-type-decl @30.1-34.2 - (header @30.1-30.13 (name "ServerConfig") + (p-ident @24.10-24.11 (raw "v"))) + (e-apply @24.13-24.41 + (e-ident @24.13-24.30 (raw "Json.validateWith")) + (e-ident @24.31-24.37 (raw "config")) + (e-ident @24.39-24.40 (raw "v"))))))) + (s-type-decl @28.1-32.2 + (header @28.1-28.13 (name "ServerConfig") (args)) - (ty-record @30.16-34.2 - (anno-record-field @31.5-31.24 (name "jsonConfig") - (ty @31.18-31.24 (name "Config"))) - (anno-record-field @32.5-32.24 (name "httpStatus") - (ty @32.18-32.24 (name "Status"))) - (anno-record-field @33.5-33.31 (name "defaultResponse") - (ty @33.23-33.31 (name "Response"))))) - (s-type-anno @37.1-37.37 (name "createClient") - (ty-fn @37.16-37.37 - (ty @37.16-37.22 (name "Config")) - (ty @37.26-37.37 (name "Http.Client")))) - (s-decl @38.1-38.48 - (p-ident @38.1-38.13 (raw "createClient")) - (e-lambda @38.16-38.48 + (ty-record @28.16-32.2 + (anno-record-field @29.5-29.24 (name "jsonConfig") + (ty @29.18-29.24 (name "Config"))) + (anno-record-field @30.5-30.24 (name "httpStatus") + (ty @30.18-30.24 (name "Status"))) + (anno-record-field @31.5-31.31 (name "defaultResponse") + (ty @31.23-31.31 (name "Response"))))) + (s-type-anno @35.1-35.37 (name "createClient") + (ty-fn @35.16-35.37 + (ty @35.16-35.22 (name "Config")) + (ty @35.26-35.37 (name "Http.Client")))) + (s-decl @36.1-36.48 + (p-ident @36.1-36.13 (raw "createClient")) + (e-lambda @36.16-36.48 (args - (p-ident @38.17-38.23 (raw "config"))) - (e-apply @38.25-38.48 - (e-ident @38.25-38.40 (raw "Http.clientWith")) - (e-ident @38.41-38.47 (raw "config"))))) - (s-type-anno @41.1-41.33 (name "handleResponse") - (ty-fn @41.18-41.33 - (ty @41.18-41.26 (name "Response")) - (ty @41.30-41.33 (name "Str")))) - (s-decl @42.1-46.6 - (p-ident @42.1-42.15 (raw "handleResponse")) - (e-lambda @42.18-46.6 + (p-ident @36.17-36.23 (raw "config"))) + (e-apply @36.25-36.48 + (e-ident @36.25-36.40 (raw "Http.clientWith")) + (e-ident @36.41-36.47 (raw "config"))))) + (s-type-anno @39.1-39.33 (name "handleResponse") + (ty-fn @39.18-39.33 + (ty @39.18-39.26 (name "Response")) + (ty @39.30-39.33 (name "Str")))) + (s-decl @40.1-44.6 + (p-ident @40.1-40.15 (raw "handleResponse")) + (e-lambda @40.18-44.6 (args - (p-ident @42.19-42.27 (raw "response"))) + (p-ident @40.19-40.27 (raw "response"))) (e-match - (e-field-access @43.11-43.26 - (e-ident @43.11-43.19 (raw "response")) - (e-ident @43.19-43.26 (raw "status"))) + (e-field-access @41.11-41.26 + (e-ident @41.11-41.19 (raw "response")) + (e-ident @41.19-41.26 (raw "status"))) (branches - (branch @44.9-44.50 - (p-tag @44.9-44.19 (raw "Ok") - (p-ident @44.12-44.18 (raw "status"))) - (e-apply @44.23-44.50 - (e-ident @44.23-44.42 (raw "Http.statusToString")) - (e-ident @44.43-44.49 (raw "status")))) - (branch @45.9-45.44 - (p-tag @45.9-45.19 (raw "Err") - (p-ident @45.13-45.18 (raw "error"))) - (e-apply @45.23-45.44 - (e-ident @45.23-45.37 (raw "Error.toString")) - (e-ident @45.38-45.43 (raw "error")))))))) - (s-type-anno @49.1-49.73 (name "combineResults") - (ty-fn @49.18-49.73 - (ty-apply @49.18-49.38 - (ty @49.18-49.24 (name "Result")) - (ty @49.25-49.30 (name "Value")) - (ty @49.32-49.37 (name "Error"))) - (ty @49.40-49.46 (name "Status")) - (ty-apply @49.50-49.73 - (ty @49.50-49.56 (name "Result")) - (ty @49.57-49.65 (name "Response")) - (ty @49.67-49.72 (name "Error"))))) - (s-decl @50.1-54.6 - (p-ident @50.1-50.15 (raw "combineResults")) - (e-lambda @50.18-54.6 + (branch @42.9-42.50 + (p-tag @42.9-42.19 (raw "Ok") + (p-ident @42.12-42.18 (raw "status"))) + (e-apply @42.23-42.50 + (e-ident @42.23-42.42 (raw "Http.statusToString")) + (e-ident @42.43-42.49 (raw "status")))) + (branch @43.9-43.44 + (p-tag @43.9-43.19 (raw "Err") + (p-ident @43.13-43.18 (raw "error"))) + (e-apply @43.23-43.44 + (e-ident @43.23-43.37 (raw "Error.toString")) + (e-ident @43.38-43.43 (raw "error")))))))) + (s-type-anno @47.1-47.73 (name "combineResults") + (ty-fn @47.18-47.73 + (ty-apply @47.18-47.38 + (ty @47.18-47.24 (name "Result")) + (ty @47.25-47.30 (name "Value")) + (ty @47.32-47.37 (name "Error"))) + (ty @47.40-47.46 (name "Status")) + (ty-apply @47.50-47.73 + (ty @47.50-47.56 (name "Result")) + (ty @47.57-47.65 (name "Response")) + (ty @47.67-47.72 (name "Error"))))) + (s-decl @48.1-52.6 + (p-ident @48.1-48.15 (raw "combineResults")) + (e-lambda @48.18-52.6 (args - (p-ident @50.19-50.29 (raw "jsonResult")) - (p-ident @50.31-50.41 (raw "httpStatus"))) + (p-ident @48.19-48.29 (raw "jsonResult")) + (p-ident @48.31-48.41 (raw "httpStatus"))) (e-match - (e-ident @51.11-51.21 (raw "jsonResult")) + (e-ident @49.11-49.21 (raw "jsonResult")) (branches - (branch @52.9-52.74 - (p-tag @52.9-52.18 (raw "Ok") - (p-ident @52.12-52.17 (raw "value"))) - (e-apply @52.22-52.74 - (e-tag @52.22-52.24 (raw "Ok")) - (e-record @52.25-52.73 + (branch @50.9-50.74 + (p-tag @50.9-50.18 (raw "Ok") + (p-ident @50.12-50.17 (raw "value"))) + (e-apply @50.22-50.74 + (e-tag @50.22-50.24 (raw "Ok")) + (e-record @50.25-50.73 (field (field "body") - (e-apply @52.33-52.51 - (e-ident @52.33-52.44 (raw "Json.encode")) - (e-ident @52.45-52.50 (raw "value")))) + (e-apply @50.33-50.51 + (e-ident @50.33-50.44 (raw "Json.encode")) + (e-ident @50.45-50.50 (raw "value")))) (field (field "status") - (e-ident @52.61-52.71 (raw "httpStatus")))))) - (branch @53.9-53.33 - (p-tag @53.9-53.19 (raw "Err") - (p-ident @53.13-53.18 (raw "error"))) - (e-apply @53.23-53.33 - (e-tag @53.23-53.26 (raw "Err")) - (e-ident @53.27-53.32 (raw "error")))))))))) + (e-ident @50.61-50.71 (raw "httpStatus")))))) + (branch @51.9-51.33 + (p-tag @51.9-51.19 (raw "Err") + (p-ident @51.13-51.18 (raw "error"))) + (e-apply @51.23-51.33 + (e-tag @51.23-51.26 (raw "Err")) + (e-ident @51.27-51.32 (raw "error")))))))))) ~~~ # FORMATTED ~~~roc -module [] - import json.Json exposing [Value, Error, Config] import http.Client as Http exposing [Request, Response, Status] import utils.Result exposing [Result] @@ -624,252 +618,250 @@ combineResults = |jsonResult, httpStatus| ~~~clojure (can-ir (d-let - (p-assign @9.1-9.10 (ident "parseJson")) - (e-lambda @9.13-9.38 + (p-assign @7.1-7.10 (ident "parseJson")) + (e-lambda @7.13-7.38 (args - (p-assign @9.14-9.19 (ident "input"))) - (e-call @9.21-9.38 - (e-lookup-external @9.21-9.31 - (module-idx "0") + (p-assign @7.14-7.19 (ident "input"))) + (e-call @7.21-7.38 + (e-lookup-external @7.21-7.31 + (module-idx "2") (target-node-idx "0")) - (e-lookup-local @9.32-9.37 - (p-assign @9.14-9.19 (ident "input"))))) - (annotation @9.1-9.10 + (e-lookup-local @7.32-7.37 + (p-assign @7.14-7.19 (ident "input"))))) + (annotation @7.1-7.10 (declared-type - (ty-fn @8.13-8.40 (effectful false) - (ty @8.13-8.16 (name "Str")) - (ty-apply @8.20-8.40 (symbol "Result") - (ty @8.27-8.32 (name "Value")) - (ty @8.34-8.39 (name "Error"))))))) + (ty-fn @6.13-6.40 (effectful false) + (ty-lookup @6.13-6.16 (name "Str") (builtin)) + (ty-apply @6.20-6.40 (name "Result") (local) + (ty-malformed @6.20-6.40) + (ty-malformed @6.20-6.40)))))) (d-let - (p-assign @13.1-13.14 (ident "handleRequest")) - (e-closure @13.17-19.2 + (p-assign @11.1-11.14 (ident "handleRequest")) + (e-closure @11.17-17.2 (captures - (capture @16.12-16.17 (ident "value")) - (capture @17.13-17.18 (ident "error"))) - (e-lambda @13.17-19.2 + (capture @14.12-14.17 (ident "value")) + (capture @15.13-15.18 (ident "error"))) + (e-lambda @11.17-17.2 (args - (p-assign @13.18-13.21 (ident "req"))) - (e-block @13.23-19.2 - (s-let @14.5-14.35 - (p-assign @14.5-14.11 (ident "result")) - (e-call @14.14-14.35 - (e-lookup-external @14.14-14.25 - (module-idx "0") + (p-assign @11.18-11.21 (ident "req"))) + (e-block @11.23-17.2 + (s-let @12.5-12.35 + (p-assign @12.5-12.11 (ident "result")) + (e-call @12.14-12.35 + (e-lookup-external @12.14-12.25 + (module-idx "2") (target-node-idx "0")) - (e-dot-access @14.26-14.34 (field "body") + (e-dot-access @12.26-12.34 (field "body") (receiver - (e-lookup-local @14.26-14.29 - (p-assign @13.18-13.21 (ident "req"))))))) - (e-match @15.5-18.6 - (match @15.5-18.6 + (e-lookup-local @12.26-12.29 + (p-assign @11.18-11.21 (ident "req"))))))) + (e-match @13.5-16.6 + (match @13.5-16.6 (cond - (e-lookup-local @15.11-15.17 - (p-assign @14.5-14.11 (ident "result")))) + (e-lookup-local @13.11-13.17 + (p-assign @12.5-12.11 (ident "result")))) (branches (branch (patterns (pattern (degenerate false) - (p-nominal @16.9-16.18 - (p-applied-tag @16.9-16.18)))) + (p-nominal @14.9-14.18 + (p-applied-tag @14.9-14.18)))) (value - (e-call @16.22-16.36 - (e-lookup-external @16.22-16.29 - (module-idx "1") + (e-call @14.22-14.36 + (e-lookup-external @14.22-14.29 + (module-idx "3") (target-node-idx "0")) - (e-lookup-local @16.30-16.35 - (p-assign @16.12-16.17 (ident "value")))))) + (e-lookup-local @14.30-14.35 + (p-assign @14.12-14.17 (ident "value")))))) (branch (patterns (pattern (degenerate false) - (p-nominal @17.9-17.19 - (p-applied-tag @17.9-17.19)))) + (p-nominal @15.9-15.19 + (p-applied-tag @15.9-15.19)))) (value - (e-call @17.23-17.45 - (e-lookup-external @17.23-17.38 - (module-idx "1") + (e-call @15.23-15.45 + (e-lookup-external @15.23-15.38 + (module-idx "3") (target-node-idx "0")) - (e-lookup-local @17.39-17.44 - (p-assign @17.13-17.18 (ident "error")))))))))))) - (annotation @13.1-13.14 + (e-lookup-local @15.39-15.44 + (p-assign @15.13-15.18 (ident "error")))))))))))) + (annotation @11.1-11.14 (declared-type - (ty-fn @12.17-12.36 (effectful false) - (ty @12.17-12.24 (name "Request")) - (ty @12.28-12.36 (name "Response")))))) + (ty-fn @10.17-10.36 (effectful false) + (ty-malformed @10.17-10.24) + (ty-malformed @10.28-10.36))))) (d-let - (p-assign @23.1-23.12 (ident "processData")) - (e-lambda @23.15-27.6 + (p-assign @21.1-21.12 (ident "processData")) + (e-lambda @21.15-25.6 (args - (p-assign @23.16-23.22 (ident "config")) - (p-assign @23.24-23.30 (ident "values"))) - (e-call @24.5-27.6 + (p-assign @21.16-21.22 (ident "config")) + (p-assign @21.24-21.30 (ident "values"))) + (e-call @22.5-25.6 (e-runtime-error (tag "ident_not_in_scope")) - (e-lookup-local @25.9-25.15 - (p-assign @23.24-23.30 (ident "values"))) - (e-closure @26.9-26.41 + (e-lookup-local @23.9-23.15 + (p-assign @21.24-21.30 (ident "values"))) + (e-closure @24.9-24.41 (captures - (capture @23.16-23.22 (ident "config"))) - (e-lambda @26.9-26.41 + (capture @21.16-21.22 (ident "config"))) + (e-lambda @24.9-24.41 (args - (p-assign @26.10-26.11 (ident "v"))) - (e-call @26.13-26.41 - (e-lookup-external @26.13-26.30 - (module-idx "0") + (p-assign @24.10-24.11 (ident "v"))) + (e-call @24.13-24.41 + (e-lookup-external @24.13-24.30 + (module-idx "2") (target-node-idx "0")) - (e-lookup-local @26.31-26.37 - (p-assign @23.16-23.22 (ident "config"))) - (e-lookup-local @26.39-26.40 - (p-assign @26.10-26.11 (ident "v")))))))) - (annotation @23.1-23.12 + (e-lookup-local @24.31-24.37 + (p-assign @21.16-21.22 (ident "config"))) + (e-lookup-local @24.39-24.40 + (p-assign @24.10-24.11 (ident "v")))))))) + (annotation @21.1-21.12 (declared-type - (ty-fn @22.15-22.64 (effectful false) - (ty @22.15-22.21 (name "Config")) - (ty-apply @22.23-22.34 (symbol "List") - (ty @22.28-22.33 (name "Value"))) - (ty-apply @22.38-22.64 (symbol "Result") - (ty-apply @22.45-22.56 (symbol "List") - (ty @22.50-22.55 (name "Value"))) - (ty @22.58-22.63 (name "Error"))))))) + (ty-fn @20.15-20.64 (effectful false) + (ty-malformed @20.15-20.21) + (ty-apply @20.23-20.34 (name "List") (builtin) + (ty-malformed @20.28-20.33)) + (ty-apply @20.38-20.64 (name "Result") (local) + (ty-apply @20.38-20.64 (name "List") (builtin) + (ty-malformed @20.50-20.55)) + (ty-malformed @20.38-20.64)))))) (d-let - (p-assign @38.1-38.13 (ident "createClient")) - (e-lambda @38.16-38.48 + (p-assign @36.1-36.13 (ident "createClient")) + (e-lambda @36.16-36.48 (args - (p-assign @38.17-38.23 (ident "config"))) - (e-call @38.25-38.48 - (e-lookup-external @38.25-38.40 - (module-idx "1") + (p-assign @36.17-36.23 (ident "config"))) + (e-call @36.25-36.48 + (e-lookup-external @36.25-36.40 + (module-idx "3") (target-node-idx "0")) - (e-lookup-local @38.41-38.47 - (p-assign @38.17-38.23 (ident "config"))))) - (annotation @38.1-38.13 + (e-lookup-local @36.41-36.47 + (p-assign @36.17-36.23 (ident "config"))))) + (annotation @36.1-36.13 (declared-type - (ty-fn @37.16-37.37 (effectful false) - (ty @37.16-37.22 (name "Config")) - (ty-lookup-external @37.26-37.37 - (module-idx "1") - (target-node-idx "0")))))) + (ty-fn @35.16-35.37 (effectful false) + (ty-malformed @35.16-35.22) + (ty-lookup @35.26-35.37 (name "Client") (external (module-idx "3") (target-node-idx "0"))))))) (d-let - (p-assign @42.1-42.15 (ident "handleResponse")) - (e-closure @42.18-46.6 + (p-assign @40.1-40.15 (ident "handleResponse")) + (e-closure @40.18-44.6 (captures - (capture @44.12-44.18 (ident "status")) - (capture @45.13-45.18 (ident "error"))) - (e-lambda @42.18-46.6 + (capture @43.13-43.18 (ident "error")) + (capture @42.12-42.18 (ident "status"))) + (e-lambda @40.18-44.6 (args - (p-assign @42.19-42.27 (ident "response"))) - (e-match @43.5-46.6 - (match @43.5-46.6 + (p-assign @40.19-40.27 (ident "response"))) + (e-match @41.5-44.6 + (match @41.5-44.6 (cond - (e-dot-access @43.11-43.26 (field "status") + (e-dot-access @41.11-41.26 (field "status") (receiver - (e-lookup-local @43.11-43.19 - (p-assign @42.19-42.27 (ident "response")))))) + (e-lookup-local @41.11-41.19 + (p-assign @40.19-40.27 (ident "response")))))) (branches (branch (patterns (pattern (degenerate false) - (p-nominal @44.9-44.19 - (p-applied-tag @44.9-44.19)))) + (p-nominal @42.9-42.19 + (p-applied-tag @42.9-42.19)))) (value - (e-call @44.23-44.50 - (e-lookup-external @44.23-44.42 - (module-idx "1") + (e-call @42.23-42.50 + (e-lookup-external @42.23-42.42 + (module-idx "3") (target-node-idx "0")) - (e-lookup-local @44.43-44.49 - (p-assign @44.12-44.18 (ident "status")))))) + (e-lookup-local @42.43-42.49 + (p-assign @42.12-42.18 (ident "status")))))) (branch (patterns (pattern (degenerate false) - (p-nominal @45.9-45.19 - (p-applied-tag @45.9-45.19)))) + (p-nominal @43.9-43.19 + (p-applied-tag @43.9-43.19)))) (value - (e-call @45.23-45.44 + (e-call @43.23-43.44 (e-runtime-error (tag "ident_not_in_scope")) - (e-lookup-local @45.38-45.43 - (p-assign @45.13-45.18 (ident "error"))))))))))) - (annotation @42.1-42.15 + (e-lookup-local @43.38-43.43 + (p-assign @43.13-43.18 (ident "error"))))))))))) + (annotation @40.1-40.15 (declared-type - (ty-fn @41.18-41.33 (effectful false) - (ty @41.18-41.26 (name "Response")) - (ty @41.30-41.33 (name "Str")))))) + (ty-fn @39.18-39.33 (effectful false) + (ty-malformed @39.18-39.26) + (ty-lookup @39.30-39.33 (name "Str") (builtin)))))) (d-let - (p-assign @50.1-50.15 (ident "combineResults")) - (e-closure @50.18-54.6 + (p-assign @48.1-48.15 (ident "combineResults")) + (e-closure @48.18-52.6 (captures - (capture @52.12-52.17 (ident "value")) - (capture @53.13-53.18 (ident "error"))) - (e-lambda @50.18-54.6 + (capture @51.13-51.18 (ident "error")) + (capture @50.12-50.17 (ident "value"))) + (e-lambda @48.18-52.6 (args - (p-assign @50.19-50.29 (ident "jsonResult")) - (p-assign @50.31-50.41 (ident "httpStatus"))) - (e-match @51.5-54.6 - (match @51.5-54.6 + (p-assign @48.19-48.29 (ident "jsonResult")) + (p-assign @48.31-48.41 (ident "httpStatus"))) + (e-match @49.5-52.6 + (match @49.5-52.6 (cond - (e-lookup-local @51.11-51.21 - (p-assign @50.19-50.29 (ident "jsonResult")))) + (e-lookup-local @49.11-49.21 + (p-assign @48.19-48.29 (ident "jsonResult")))) (branches (branch (patterns (pattern (degenerate false) - (p-nominal @52.9-52.18 - (p-applied-tag @52.9-52.18)))) + (p-nominal @50.9-50.18 + (p-applied-tag @50.9-50.18)))) (value - (e-nominal @52.22-52.74 (nominal "Result") - (e-tag @52.22-52.74 (name "Ok") + (e-nominal @50.22-50.74 (nominal "Result") + (e-tag @50.22-50.74 (name "Ok") (args - (e-record @52.25-52.73 + (e-record @50.25-50.73 (fields (field (name "body") - (e-call @52.33-52.51 - (e-lookup-external @52.33-52.44 - (module-idx "0") + (e-call @50.33-50.51 + (e-lookup-external @50.33-50.44 + (module-idx "2") (target-node-idx "0")) - (e-lookup-local @52.45-52.50 - (p-assign @52.12-52.17 (ident "value"))))) + (e-lookup-local @50.45-50.50 + (p-assign @50.12-50.17 (ident "value"))))) (field (name "status") - (e-lookup-local @52.61-52.71 - (p-assign @50.31-50.41 (ident "httpStatus"))))))))))) + (e-lookup-local @50.61-50.71 + (p-assign @48.31-48.41 (ident "httpStatus"))))))))))) (branch (patterns (pattern (degenerate false) - (p-nominal @53.9-53.19 - (p-applied-tag @53.9-53.19)))) + (p-nominal @51.9-51.19 + (p-applied-tag @51.9-51.19)))) (value - (e-nominal @53.23-53.33 (nominal "Result") - (e-tag @53.23-53.33 (name "Err") + (e-nominal @51.23-51.33 (nominal "Result") + (e-tag @51.23-51.33 (name "Err") (args - (e-lookup-local @53.27-53.32 - (p-assign @53.13-53.18 (ident "error"))))))))))))) - (annotation @50.1-50.15 + (e-lookup-local @51.27-51.32 + (p-assign @51.13-51.18 (ident "error"))))))))))))) + (annotation @48.1-48.15 (declared-type - (ty-fn @49.18-49.73 (effectful false) - (ty-apply @49.18-49.38 (symbol "Result") - (ty @49.25-49.30 (name "Value")) - (ty @49.32-49.37 (name "Error"))) - (ty @49.40-49.46 (name "Status")) - (ty-apply @49.50-49.73 (symbol "Result") - (ty @49.57-49.65 (name "Response")) - (ty @49.67-49.72 (name "Error"))))))) - (s-alias-decl @30.1-34.2 - (ty-header @30.1-30.13 (name "ServerConfig")) - (ty-record @30.16-34.2 + (ty-fn @47.18-47.73 (effectful false) + (ty-apply @47.18-47.38 (name "Result") (local) + (ty-malformed @47.18-47.38) + (ty-malformed @47.18-47.38)) + (ty-malformed @47.40-47.46) + (ty-apply @47.50-47.73 (name "Result") (local) + (ty-malformed @47.50-47.73) + (ty-malformed @47.50-47.73)))))) + (s-alias-decl @28.1-32.2 + (ty-header @28.1-28.13 (name "ServerConfig")) + (ty-record @28.16-32.2 (field (field "jsonConfig") - (ty @31.18-31.24 (name "Config"))) + (ty-malformed @29.18-29.24)) (field (field "httpStatus") - (ty @32.18-32.24 (name "Status"))) + (ty-malformed @30.18-30.24)) (field (field "defaultResponse") - (ty @33.23-33.31 (name "Response"))))) - (s-import @3.1-3.49 (module "json.Json") (qualifier "json") + (ty-malformed @31.23-31.31)))) + (s-import @1.1-1.49 (module "json.Json") (qualifier "json") (exposes (exposed (name "Value") (wildcard false)) (exposed (name "Error") (wildcard false)) (exposed (name "Config") (wildcard false)))) - (s-import @4.1-4.64 (module "http.Client") (qualifier "http") (alias "Http") + (s-import @2.1-2.64 (module "http.Client") (qualifier "http") (alias "Http") (exposes (exposed (name "Request") (wildcard false)) (exposed (name "Response") (wildcard false)) (exposed (name "Status") (wildcard false)))) - (s-import @5.1-5.38 (module "utils.Result") (qualifier "utils") + (s-import @3.1-3.38 (module "utils.Result") (qualifier "utils") (exposes (exposed (name "Result") (wildcard false))))) ~~~ @@ -877,20 +869,20 @@ combineResults = |jsonResult, httpStatus| ~~~clojure (inferred-types (defs - (patt @9.1-9.10 (type "Str -> Result(Error, Error)")) - (patt @13.1-13.14 (type "Error -> Error")) - (patt @23.1-23.12 (type "Error, List(Error) -> Result(List(item), Error)")) - (patt @38.1-38.13 (type "Error -> Error")) - (patt @42.1-42.15 (type "Error -> Str")) - (patt @50.1-50.15 (type "Result(Error, Error), Error -> Result(Error, Error)"))) + (patt @7.1-7.10 (type "Str -> Result(Error, Error)")) + (patt @11.1-11.14 (type "Error -> Error")) + (patt @21.1-21.12 (type "Error, List(Error) -> Result(List(Error), Error)")) + (patt @36.1-36.13 (type "Error -> Error")) + (patt @40.1-40.15 (type "Error -> Str")) + (patt @48.1-48.15 (type "Result(Error, Error), Error -> Result(Error, Error)"))) (type_decls - (alias @30.1-34.2 (type "ServerConfig") - (ty-header @30.1-30.13 (name "ServerConfig")))) + (alias @28.1-32.2 (type "ServerConfig") + (ty-header @28.1-28.13 (name "ServerConfig")))) (expressions - (expr @9.13-9.38 (type "Str -> Result(Error, Error)")) - (expr @13.17-19.2 (type "Error -> Error")) - (expr @23.15-27.6 (type "Error, List(Error) -> Result(List(item), Error)")) - (expr @38.16-38.48 (type "Error -> Error")) - (expr @42.18-46.6 (type "Error -> Str")) - (expr @50.18-54.6 (type "Result(Error, Error), Error -> Result(Error, Error)")))) + (expr @7.13-7.38 (type "Str -> Result(Error, Error)")) + (expr @11.17-17.2 (type "Error -> Error")) + (expr @21.15-25.6 (type "Error, List(Error) -> Result(List(Error), Error)")) + (expr @36.16-36.48 (type "Error -> Error")) + (expr @40.18-44.6 (type "Error -> Str")) + (expr @48.18-52.6 (type "Result(Error, Error), Error -> Result(Error, Error)")))) ~~~ diff --git a/test/snapshots/can_import_json.md b/test/snapshots/can_import_json.md index 41c704728e..cf03ac7857 100644 --- a/test/snapshots/can_import_json.md +++ b/test/snapshots/can_import_json.md @@ -1,24 +1,22 @@ # META ~~~ini description=Import with module-qualified usage -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - import json.Json main = Json.utf8 ~~~ # EXPECTED -MODULE NOT FOUND - can_import_json.md:3:1:3:17 +MODULE NOT FOUND - can_import_json.md:1:1:1:17 # PROBLEMS **MODULE NOT FOUND** The module `json.Json` was not found in this Roc project. You're attempting to use this module here: -**can_import_json.md:3:1:3:17:** +**can_import_json.md:1:1:1:17:** ```roc import json.Json ``` @@ -27,21 +25,19 @@ import json.Json # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -KwImport(3:1-3:7),LowerIdent(3:8-3:12),NoSpaceDotUpperIdent(3:12-3:17), -LowerIdent(5:1-5:5),OpAssign(5:6-5:7),UpperIdent(5:8-5:12),NoSpaceDotLowerIdent(5:12-5:17), -EndOfFile(6:1-6:1), +KwImport(1:1-1:7),LowerIdent(1:8-1:12),NoSpaceDotUpperIdent(1:12-1:17), +LowerIdent(3:1-3:5),OpAssign(3:6-3:7),UpperIdent(3:8-3:12),NoSpaceDotLowerIdent(3:12-3:17), +EndOfFile(4:1-4:1), ~~~ # PARSE ~~~clojure -(file @1.1-5.17 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-3.17 + (type-module @1.1-1.7) (statements - (s-import @3.1-3.17 (raw "json.Json")) - (s-decl @5.1-5.17 - (p-ident @5.1-5.5 (raw "main")) - (e-ident @5.8-5.17 (raw "Json.utf8"))))) + (s-import @1.1-1.17 (raw "json.Json")) + (s-decl @3.1-3.17 + (p-ident @3.1-3.5 (raw "main")) + (e-ident @3.8-3.17 (raw "Json.utf8"))))) ~~~ # FORMATTED ~~~roc @@ -51,18 +47,18 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @5.1-5.5 (ident "main")) - (e-lookup-external @5.8-5.17 - (module-idx "0") + (p-assign @3.1-3.5 (ident "main")) + (e-lookup-external @3.8-3.17 + (module-idx "2") (target-node-idx "0"))) - (s-import @3.1-3.17 (module "json.Json") (qualifier "json") + (s-import @1.1-1.17 (module "json.Json") (qualifier "json") (exposes))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @5.1-5.5 (type "Error"))) + (patt @3.1-3.5 (type "Error"))) (expressions - (expr @5.8-5.17 (type "Error")))) + (expr @3.8-3.17 (type "Error")))) ~~~ diff --git a/test/snapshots/can_import_nested_modules.md b/test/snapshots/can_import_nested_modules.md index 12cf9b65bc..c4d5f597cc 100644 --- a/test/snapshots/can_import_nested_modules.md +++ b/test/snapshots/can_import_nested_modules.md @@ -1,12 +1,10 @@ # META ~~~ini description=Nested module qualification -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - import json.Parser.Config import http.Client.Auth as HttpAuth import utils.String.Format exposing [padLeft] @@ -33,38 +31,38 @@ validateAuth : HttpAuth.Credentials -> Result(HttpAuth.Token, HttpAuth.Error) validateAuth = |creds| HttpAuth.validate(creds) ~~~ # EXPECTED -PARSE ERROR - can_import_nested_modules.md:3:19:3:26 -PARSE ERROR - can_import_nested_modules.md:4:19:4:24 -PARSE ERROR - can_import_nested_modules.md:4:25:4:27 -PARSE ERROR - can_import_nested_modules.md:5:1:5:7 -PARSE ERROR - can_import_nested_modules.md:5:8:5:13 -PARSE ERROR - can_import_nested_modules.md:5:13:5:20 -PARSE ERROR - can_import_nested_modules.md:5:20:5:27 -PARSE ERROR - can_import_nested_modules.md:5:28:5:36 -PARSE ERROR - can_import_nested_modules.md:5:37:5:38 -PARSE ERROR - can_import_nested_modules.md:5:38:5:45 -PARSE ERROR - can_import_nested_modules.md:5:45:5:46 -MODULE NOT FOUND - can_import_nested_modules.md:3:1:3:19 -MODULE NOT FOUND - can_import_nested_modules.md:4:1:4:19 -MODULE NOT IMPORTED - can_import_nested_modules.md:8:15:8:30 -UNDEFINED VARIABLE - can_import_nested_modules.md:9:26:9:41 -MODULE NOT IMPORTED - can_import_nested_modules.md:12:28:12:42 -UNDEFINED VARIABLE - can_import_nested_modules.md:13:29:13:43 -MODULE NOT IMPORTED - can_import_nested_modules.md:16:15:16:37 -MODULE NOT IMPORTED - can_import_nested_modules.md:16:58:16:77 -UNDEFINED VARIABLE - can_import_nested_modules.md:18:5:18:37 -UNDEFINED VARIABLE - can_import_nested_modules.md:22:23:22:30 -UNDEFINED VARIABLE - can_import_nested_modules.md:22:37:22:58 -MODULE NOT IMPORTED - can_import_nested_modules.md:25:16:25:36 -MODULE NOT IMPORTED - can_import_nested_modules.md:25:47:25:61 -MODULE NOT IMPORTED - can_import_nested_modules.md:25:63:25:77 -UNDEFINED VARIABLE - can_import_nested_modules.md:26:24:26:41 +PARSE ERROR - can_import_nested_modules.md:1:19:1:26 +PARSE ERROR - can_import_nested_modules.md:2:19:2:24 +PARSE ERROR - can_import_nested_modules.md:2:25:2:27 +PARSE ERROR - can_import_nested_modules.md:3:1:3:7 +PARSE ERROR - can_import_nested_modules.md:3:8:3:13 +PARSE ERROR - can_import_nested_modules.md:3:13:3:20 +PARSE ERROR - can_import_nested_modules.md:3:20:3:27 +PARSE ERROR - can_import_nested_modules.md:3:28:3:36 +PARSE ERROR - can_import_nested_modules.md:3:37:3:38 +PARSE ERROR - can_import_nested_modules.md:3:38:3:45 +PARSE ERROR - can_import_nested_modules.md:3:45:3:46 +MODULE NOT FOUND - can_import_nested_modules.md:1:1:1:19 +MODULE NOT FOUND - can_import_nested_modules.md:2:1:2:19 +MODULE NOT IMPORTED - can_import_nested_modules.md:6:15:6:30 +UNDEFINED VARIABLE - can_import_nested_modules.md:7:26:7:41 +MODULE NOT IMPORTED - can_import_nested_modules.md:10:28:10:42 +UNDEFINED VARIABLE - can_import_nested_modules.md:11:29:11:43 +MODULE NOT IMPORTED - can_import_nested_modules.md:14:15:14:37 +MODULE NOT IMPORTED - can_import_nested_modules.md:14:58:14:77 +UNDEFINED VARIABLE - can_import_nested_modules.md:16:5:16:37 +UNDEFINED VARIABLE - can_import_nested_modules.md:20:23:20:30 +UNDEFINED VARIABLE - can_import_nested_modules.md:20:37:20:58 +MODULE NOT IMPORTED - can_import_nested_modules.md:23:16:23:36 +MODULE NOT IMPORTED - can_import_nested_modules.md:23:47:23:61 +MODULE NOT IMPORTED - can_import_nested_modules.md:23:63:23:77 +UNDEFINED VARIABLE - can_import_nested_modules.md:24:24:24:41 # PROBLEMS **PARSE ERROR** A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**can_import_nested_modules.md:3:19:3:26:** +**can_import_nested_modules.md:1:19:1:26:** ```roc import json.Parser.Config ``` @@ -75,7 +73,7 @@ import json.Parser.Config A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**can_import_nested_modules.md:4:19:4:24:** +**can_import_nested_modules.md:2:19:2:24:** ```roc import http.Client.Auth as HttpAuth ``` @@ -86,7 +84,7 @@ import http.Client.Auth as HttpAuth A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**can_import_nested_modules.md:4:25:4:27:** +**can_import_nested_modules.md:2:25:2:27:** ```roc import http.Client.Auth as HttpAuth ``` @@ -109,7 +107,7 @@ Other valid examples: `Result(a, Str)` `Maybe(List(U64))` -**can_import_nested_modules.md:5:1:5:7:** +**can_import_nested_modules.md:3:1:3:7:** ```roc import utils.String.Format exposing [padLeft] ``` @@ -120,7 +118,7 @@ import utils.String.Format exposing [padLeft] A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**can_import_nested_modules.md:5:8:5:13:** +**can_import_nested_modules.md:3:8:3:13:** ```roc import utils.String.Format exposing [padLeft] ``` @@ -131,7 +129,7 @@ import utils.String.Format exposing [padLeft] A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**can_import_nested_modules.md:5:13:5:20:** +**can_import_nested_modules.md:3:13:3:20:** ```roc import utils.String.Format exposing [padLeft] ``` @@ -142,7 +140,7 @@ import utils.String.Format exposing [padLeft] A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**can_import_nested_modules.md:5:20:5:27:** +**can_import_nested_modules.md:3:20:3:27:** ```roc import utils.String.Format exposing [padLeft] ``` @@ -153,7 +151,7 @@ import utils.String.Format exposing [padLeft] A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**can_import_nested_modules.md:5:28:5:36:** +**can_import_nested_modules.md:3:28:3:36:** ```roc import utils.String.Format exposing [padLeft] ``` @@ -164,7 +162,7 @@ import utils.String.Format exposing [padLeft] A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**can_import_nested_modules.md:5:37:5:38:** +**can_import_nested_modules.md:3:37:3:38:** ```roc import utils.String.Format exposing [padLeft] ``` @@ -175,7 +173,7 @@ import utils.String.Format exposing [padLeft] A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**can_import_nested_modules.md:5:38:5:45:** +**can_import_nested_modules.md:3:38:3:45:** ```roc import utils.String.Format exposing [padLeft] ``` @@ -186,7 +184,7 @@ import utils.String.Format exposing [padLeft] A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**can_import_nested_modules.md:5:45:5:46:** +**can_import_nested_modules.md:3:45:3:46:** ```roc import utils.String.Format exposing [padLeft] ``` @@ -197,7 +195,7 @@ import utils.String.Format exposing [padLeft] The module `json.Parser` was not found in this Roc project. You're attempting to use this module here: -**can_import_nested_modules.md:3:1:3:19:** +**can_import_nested_modules.md:1:1:1:19:** ```roc import json.Parser.Config ``` @@ -208,7 +206,7 @@ import json.Parser.Config The module `http.Client` was not found in this Roc project. You're attempting to use this module here: -**can_import_nested_modules.md:4:1:4:19:** +**can_import_nested_modules.md:2:1:2:19:** ```roc import http.Client.Auth as HttpAuth ``` @@ -219,7 +217,7 @@ import http.Client.Auth as HttpAuth There is no module with the name `Config` imported into this Roc file. You're attempting to use this module here: -**can_import_nested_modules.md:8:15:8:30:** +**can_import_nested_modules.md:6:15:6:30:** ```roc parseConfig : Config.Settings -> Str ``` @@ -230,7 +228,7 @@ parseConfig : Config.Settings -> Str Nothing is named `toString` in this scope. Is there an `import` or `exposing` missing up-top? -**can_import_nested_modules.md:9:26:9:41:** +**can_import_nested_modules.md:7:26:7:41:** ```roc parseConfig = |settings| Config.toString(settings) ``` @@ -241,7 +239,7 @@ parseConfig = |settings| Config.toString(settings) There is no module with the name `HttpAuth` imported into this Roc file. You're attempting to use this module here: -**can_import_nested_modules.md:12:28:12:42:** +**can_import_nested_modules.md:10:28:10:42:** ```roc authenticate : Str, Str -> HttpAuth.Token ``` @@ -252,7 +250,7 @@ authenticate : Str, Str -> HttpAuth.Token Nothing is named `login` in this scope. Is there an `import` or `exposing` missing up-top? -**can_import_nested_modules.md:13:29:13:43:** +**can_import_nested_modules.md:11:29:11:43:** ```roc authenticate = |user, pass| HttpAuth.login(user, pass) ``` @@ -260,25 +258,10 @@ authenticate = |user, pass| HttpAuth.login(user, pass) **MODULE NOT IMPORTED** -There is no module with the name `module [] - -import json.Parser.Config -import http.Client.Auth as HttpAuth -import utils.String.Format exposing [padLeft] - -# Test multi-level type qualification -parseConfig : Config.Settings -> Str -parseConfig = |settings| Config.toString(settings) - -# Test multi-level value qualification -authenticate : Str, Str -> HttpAuth.Token -authenticate = |user, pass| HttpAuth.login(user, pass) - -# Test deeply nested qualification -processData : Config.Parser` imported into this Roc file. +There is no module with the name `Config.Parser` imported into this Roc file. You're attempting to use this module here: -**can_import_nested_modules.md:16:15:16:37:** +**can_import_nested_modules.md:14:15:14:37:** ```roc processData : Config.Parser.Advanced, Str -> Result(Str, Config.Parser.Error) ``` @@ -286,25 +269,10 @@ processData : Config.Parser.Advanced, Str -> Result(Str, Config.Parser.Error) **MODULE NOT IMPORTED** -There is no module with the name `module [] - -import json.Parser.Config -import http.Client.Auth as HttpAuth -import utils.String.Format exposing [padLeft] - -# Test multi-level type qualification -parseConfig : Config.Settings -> Str -parseConfig = |settings| Config.toString(settings) - -# Test multi-level value qualification -authenticate : Str, Str -> HttpAuth.Token -authenticate = |user, pass| HttpAuth.login(user, pass) - -# Test deeply nested qualification -processData : Config.Parser.Advanced, Str -> Result(Str, Config.Parser` imported into this Roc file. +There is no module with the name `Config.Parser` imported into this Roc file. You're attempting to use this module here: -**can_import_nested_modules.md:16:58:16:77:** +**can_import_nested_modules.md:14:58:14:77:** ```roc processData : Config.Parser.Advanced, Str -> Result(Str, Config.Parser.Error) ``` @@ -315,7 +283,7 @@ processData : Config.Parser.Advanced, Str -> Result(Str, Config.Parser.Error) Nothing is named `parseWith` in this scope. Is there an `import` or `exposing` missing up-top? -**can_import_nested_modules.md:18:5:18:37:** +**can_import_nested_modules.md:16:5:16:37:** ```roc Config.Parser.Advanced.parseWith(advancedConfig, input) ``` @@ -326,7 +294,7 @@ Is there an `import` or `exposing` missing up-top? Nothing is named `padLeft` in this scope. Is there an `import` or `exposing` missing up-top? -**can_import_nested_modules.md:22:23:22:30:** +**can_import_nested_modules.md:20:23:20:30:** ```roc formatOutput = |text| padLeft(text, Config.defaultPadding) ``` @@ -337,7 +305,7 @@ formatOutput = |text| padLeft(text, Config.defaultPadding) Nothing is named `defaultPadding` in this scope. Is there an `import` or `exposing` missing up-top? -**can_import_nested_modules.md:22:37:22:58:** +**can_import_nested_modules.md:20:37:20:58:** ```roc formatOutput = |text| padLeft(text, Config.defaultPadding) ``` @@ -348,7 +316,7 @@ formatOutput = |text| padLeft(text, Config.defaultPadding) There is no module with the name `HttpAuth` imported into this Roc file. You're attempting to use this module here: -**can_import_nested_modules.md:25:16:25:36:** +**can_import_nested_modules.md:23:16:23:36:** ```roc validateAuth : HttpAuth.Credentials -> Result(HttpAuth.Token, HttpAuth.Error) ``` @@ -359,7 +327,7 @@ validateAuth : HttpAuth.Credentials -> Result(HttpAuth.Token, HttpAuth.Error) There is no module with the name `HttpAuth` imported into this Roc file. You're attempting to use this module here: -**can_import_nested_modules.md:25:47:25:61:** +**can_import_nested_modules.md:23:47:23:61:** ```roc validateAuth : HttpAuth.Credentials -> Result(HttpAuth.Token, HttpAuth.Error) ``` @@ -370,7 +338,7 @@ validateAuth : HttpAuth.Credentials -> Result(HttpAuth.Token, HttpAuth.Error) There is no module with the name `HttpAuth` imported into this Roc file. You're attempting to use this module here: -**can_import_nested_modules.md:25:63:25:77:** +**can_import_nested_modules.md:23:63:23:77:** ```roc validateAuth : HttpAuth.Credentials -> Result(HttpAuth.Token, HttpAuth.Error) ``` @@ -381,7 +349,7 @@ validateAuth : HttpAuth.Credentials -> Result(HttpAuth.Token, HttpAuth.Error) Nothing is named `validate` in this scope. Is there an `import` or `exposing` missing up-top? -**can_import_nested_modules.md:26:24:26:41:** +**can_import_nested_modules.md:24:24:24:41:** ```roc validateAuth = |creds| HttpAuth.validate(creds) ``` @@ -390,120 +358,116 @@ validateAuth = |creds| HttpAuth.validate(creds) # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -KwImport(3:1-3:7),LowerIdent(3:8-3:12),NoSpaceDotUpperIdent(3:12-3:19),NoSpaceDotUpperIdent(3:19-3:26), -KwImport(4:1-4:7),LowerIdent(4:8-4:12),NoSpaceDotUpperIdent(4:12-4:19),NoSpaceDotUpperIdent(4:19-4:24),KwAs(4:25-4:27),UpperIdent(4:28-4:36), -KwImport(5:1-5:7),LowerIdent(5:8-5:13),NoSpaceDotUpperIdent(5:13-5:20),NoSpaceDotUpperIdent(5:20-5:27),KwExposing(5:28-5:36),OpenSquare(5:37-5:38),LowerIdent(5:38-5:45),CloseSquare(5:45-5:46), -LowerIdent(8:1-8:12),OpColon(8:13-8:14),UpperIdent(8:15-8:21),NoSpaceDotUpperIdent(8:21-8:30),OpArrow(8:31-8:33),UpperIdent(8:34-8:37), -LowerIdent(9:1-9:12),OpAssign(9:13-9:14),OpBar(9:15-9:16),LowerIdent(9:16-9:24),OpBar(9:24-9:25),UpperIdent(9:26-9:32),NoSpaceDotLowerIdent(9:32-9:41),NoSpaceOpenRound(9:41-9:42),LowerIdent(9:42-9:50),CloseRound(9:50-9:51), -LowerIdent(12:1-12:13),OpColon(12:14-12:15),UpperIdent(12:16-12:19),Comma(12:19-12:20),UpperIdent(12:21-12:24),OpArrow(12:25-12:27),UpperIdent(12:28-12:36),NoSpaceDotUpperIdent(12:36-12:42), -LowerIdent(13:1-13:13),OpAssign(13:14-13:15),OpBar(13:16-13:17),LowerIdent(13:17-13:21),Comma(13:21-13:22),LowerIdent(13:23-13:27),OpBar(13:27-13:28),UpperIdent(13:29-13:37),NoSpaceDotLowerIdent(13:37-13:43),NoSpaceOpenRound(13:43-13:44),LowerIdent(13:44-13:48),Comma(13:48-13:49),LowerIdent(13:50-13:54),CloseRound(13:54-13:55), -LowerIdent(16:1-16:12),OpColon(16:13-16:14),UpperIdent(16:15-16:21),NoSpaceDotUpperIdent(16:21-16:28),NoSpaceDotUpperIdent(16:28-16:37),Comma(16:37-16:38),UpperIdent(16:39-16:42),OpArrow(16:43-16:45),UpperIdent(16:46-16:52),NoSpaceOpenRound(16:52-16:53),UpperIdent(16:53-16:56),Comma(16:56-16:57),UpperIdent(16:58-16:64),NoSpaceDotUpperIdent(16:64-16:71),NoSpaceDotUpperIdent(16:71-16:77),CloseRound(16:77-16:78), -LowerIdent(17:1-17:12),OpAssign(17:13-17:14),OpBar(17:15-17:16),LowerIdent(17:16-17:30),Comma(17:30-17:31),LowerIdent(17:32-17:37),OpBar(17:37-17:38), -UpperIdent(18:5-18:11),NoSpaceDotUpperIdent(18:11-18:18),NoSpaceDotUpperIdent(18:18-18:27),NoSpaceDotLowerIdent(18:27-18:37),NoSpaceOpenRound(18:37-18:38),LowerIdent(18:38-18:52),Comma(18:52-18:53),LowerIdent(18:54-18:59),CloseRound(18:59-18:60), -LowerIdent(21:1-21:13),OpColon(21:14-21:15),UpperIdent(21:16-21:19),OpArrow(21:20-21:22),UpperIdent(21:23-21:26), -LowerIdent(22:1-22:13),OpAssign(22:14-22:15),OpBar(22:16-22:17),LowerIdent(22:17-22:21),OpBar(22:21-22:22),LowerIdent(22:23-22:30),NoSpaceOpenRound(22:30-22:31),LowerIdent(22:31-22:35),Comma(22:35-22:36),UpperIdent(22:37-22:43),NoSpaceDotLowerIdent(22:43-22:58),CloseRound(22:58-22:59), -LowerIdent(25:1-25:13),OpColon(25:14-25:15),UpperIdent(25:16-25:24),NoSpaceDotUpperIdent(25:24-25:36),OpArrow(25:37-25:39),UpperIdent(25:40-25:46),NoSpaceOpenRound(25:46-25:47),UpperIdent(25:47-25:55),NoSpaceDotUpperIdent(25:55-25:61),Comma(25:61-25:62),UpperIdent(25:63-25:71),NoSpaceDotUpperIdent(25:71-25:77),CloseRound(25:77-25:78), -LowerIdent(26:1-26:13),OpAssign(26:14-26:15),OpBar(26:16-26:17),LowerIdent(26:17-26:22),OpBar(26:22-26:23),UpperIdent(26:24-26:32),NoSpaceDotLowerIdent(26:32-26:41),NoSpaceOpenRound(26:41-26:42),LowerIdent(26:42-26:47),CloseRound(26:47-26:48), -EndOfFile(27:1-27:1), +KwImport(1:1-1:7),LowerIdent(1:8-1:12),NoSpaceDotUpperIdent(1:12-1:19),NoSpaceDotUpperIdent(1:19-1:26), +KwImport(2:1-2:7),LowerIdent(2:8-2:12),NoSpaceDotUpperIdent(2:12-2:19),NoSpaceDotUpperIdent(2:19-2:24),KwAs(2:25-2:27),UpperIdent(2:28-2:36), +KwImport(3:1-3:7),LowerIdent(3:8-3:13),NoSpaceDotUpperIdent(3:13-3:20),NoSpaceDotUpperIdent(3:20-3:27),KwExposing(3:28-3:36),OpenSquare(3:37-3:38),LowerIdent(3:38-3:45),CloseSquare(3:45-3:46), +LowerIdent(6:1-6:12),OpColon(6:13-6:14),UpperIdent(6:15-6:21),NoSpaceDotUpperIdent(6:21-6:30),OpArrow(6:31-6:33),UpperIdent(6:34-6:37), +LowerIdent(7:1-7:12),OpAssign(7:13-7:14),OpBar(7:15-7:16),LowerIdent(7:16-7:24),OpBar(7:24-7:25),UpperIdent(7:26-7:32),NoSpaceDotLowerIdent(7:32-7:41),NoSpaceOpenRound(7:41-7:42),LowerIdent(7:42-7:50),CloseRound(7:50-7:51), +LowerIdent(10:1-10:13),OpColon(10:14-10:15),UpperIdent(10:16-10:19),Comma(10:19-10:20),UpperIdent(10:21-10:24),OpArrow(10:25-10:27),UpperIdent(10:28-10:36),NoSpaceDotUpperIdent(10:36-10:42), +LowerIdent(11:1-11:13),OpAssign(11:14-11:15),OpBar(11:16-11:17),LowerIdent(11:17-11:21),Comma(11:21-11:22),LowerIdent(11:23-11:27),OpBar(11:27-11:28),UpperIdent(11:29-11:37),NoSpaceDotLowerIdent(11:37-11:43),NoSpaceOpenRound(11:43-11:44),LowerIdent(11:44-11:48),Comma(11:48-11:49),LowerIdent(11:50-11:54),CloseRound(11:54-11:55), +LowerIdent(14:1-14:12),OpColon(14:13-14:14),UpperIdent(14:15-14:21),NoSpaceDotUpperIdent(14:21-14:28),NoSpaceDotUpperIdent(14:28-14:37),Comma(14:37-14:38),UpperIdent(14:39-14:42),OpArrow(14:43-14:45),UpperIdent(14:46-14:52),NoSpaceOpenRound(14:52-14:53),UpperIdent(14:53-14:56),Comma(14:56-14:57),UpperIdent(14:58-14:64),NoSpaceDotUpperIdent(14:64-14:71),NoSpaceDotUpperIdent(14:71-14:77),CloseRound(14:77-14:78), +LowerIdent(15:1-15:12),OpAssign(15:13-15:14),OpBar(15:15-15:16),LowerIdent(15:16-15:30),Comma(15:30-15:31),LowerIdent(15:32-15:37),OpBar(15:37-15:38), +UpperIdent(16:5-16:11),NoSpaceDotUpperIdent(16:11-16:18),NoSpaceDotUpperIdent(16:18-16:27),NoSpaceDotLowerIdent(16:27-16:37),NoSpaceOpenRound(16:37-16:38),LowerIdent(16:38-16:52),Comma(16:52-16:53),LowerIdent(16:54-16:59),CloseRound(16:59-16:60), +LowerIdent(19:1-19:13),OpColon(19:14-19:15),UpperIdent(19:16-19:19),OpArrow(19:20-19:22),UpperIdent(19:23-19:26), +LowerIdent(20:1-20:13),OpAssign(20:14-20:15),OpBar(20:16-20:17),LowerIdent(20:17-20:21),OpBar(20:21-20:22),LowerIdent(20:23-20:30),NoSpaceOpenRound(20:30-20:31),LowerIdent(20:31-20:35),Comma(20:35-20:36),UpperIdent(20:37-20:43),NoSpaceDotLowerIdent(20:43-20:58),CloseRound(20:58-20:59), +LowerIdent(23:1-23:13),OpColon(23:14-23:15),UpperIdent(23:16-23:24),NoSpaceDotUpperIdent(23:24-23:36),OpArrow(23:37-23:39),UpperIdent(23:40-23:46),NoSpaceOpenRound(23:46-23:47),UpperIdent(23:47-23:55),NoSpaceDotUpperIdent(23:55-23:61),Comma(23:61-23:62),UpperIdent(23:63-23:71),NoSpaceDotUpperIdent(23:71-23:77),CloseRound(23:77-23:78), +LowerIdent(24:1-24:13),OpAssign(24:14-24:15),OpBar(24:16-24:17),LowerIdent(24:17-24:22),OpBar(24:22-24:23),UpperIdent(24:24-24:32),NoSpaceDotLowerIdent(24:32-24:41),NoSpaceOpenRound(24:41-24:42),LowerIdent(24:42-24:47),CloseRound(24:47-24:48), +EndOfFile(25:1-25:1), ~~~ # PARSE ~~~clojure -(file @1.1-26.48 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-24.48 + (type-module @1.1-1.7) (statements - (s-import @3.1-3.19 (raw "json.Parser")) - (s-malformed @3.19-3.26 (tag "statement_unexpected_token")) - (s-import @4.1-4.19 (raw "http.Client")) - (s-malformed @4.19-4.24 (tag "statement_unexpected_token")) - (s-malformed @4.25-4.27 (tag "statement_unexpected_token")) - (s-malformed @5.1-5.7 (tag "expected_colon_after_type_annotation")) - (s-malformed @5.8-5.13 (tag "statement_unexpected_token")) - (s-malformed @5.13-5.20 (tag "statement_unexpected_token")) - (s-malformed @5.20-5.27 (tag "statement_unexpected_token")) - (s-malformed @5.28-5.36 (tag "statement_unexpected_token")) - (s-malformed @5.37-5.38 (tag "statement_unexpected_token")) - (s-malformed @5.38-5.45 (tag "statement_unexpected_token")) - (s-malformed @5.45-5.46 (tag "statement_unexpected_token")) - (s-type-anno @8.1-8.37 (name "parseConfig") - (ty-fn @8.15-8.37 - (ty @8.15-8.30 (name "Config.Settings")) - (ty @8.34-8.37 (name "Str")))) - (s-decl @9.1-9.51 - (p-ident @9.1-9.12 (raw "parseConfig")) - (e-lambda @9.15-9.51 + (s-import @1.1-1.19 (raw "json.Parser")) + (s-malformed @1.19-1.26 (tag "statement_unexpected_token")) + (s-import @2.1-2.19 (raw "http.Client")) + (s-malformed @2.19-2.24 (tag "statement_unexpected_token")) + (s-malformed @2.25-2.27 (tag "statement_unexpected_token")) + (s-malformed @3.1-3.7 (tag "expected_colon_after_type_annotation")) + (s-malformed @3.8-3.13 (tag "statement_unexpected_token")) + (s-malformed @3.13-3.20 (tag "statement_unexpected_token")) + (s-malformed @3.20-3.27 (tag "statement_unexpected_token")) + (s-malformed @3.28-3.36 (tag "statement_unexpected_token")) + (s-malformed @3.37-3.38 (tag "statement_unexpected_token")) + (s-malformed @3.38-3.45 (tag "statement_unexpected_token")) + (s-malformed @3.45-3.46 (tag "statement_unexpected_token")) + (s-type-anno @6.1-6.37 (name "parseConfig") + (ty-fn @6.15-6.37 + (ty @6.15-6.30 (name "Config.Settings")) + (ty @6.34-6.37 (name "Str")))) + (s-decl @7.1-7.51 + (p-ident @7.1-7.12 (raw "parseConfig")) + (e-lambda @7.15-7.51 (args - (p-ident @9.16-9.24 (raw "settings"))) - (e-apply @9.26-9.51 - (e-ident @9.26-9.41 (raw "Config.toString")) - (e-ident @9.42-9.50 (raw "settings"))))) - (s-type-anno @12.1-12.42 (name "authenticate") - (ty-fn @12.16-12.42 - (ty @12.16-12.19 (name "Str")) - (ty @12.21-12.24 (name "Str")) - (ty @12.28-12.42 (name "HttpAuth.Token")))) - (s-decl @13.1-13.55 - (p-ident @13.1-13.13 (raw "authenticate")) - (e-lambda @13.16-13.55 + (p-ident @7.16-7.24 (raw "settings"))) + (e-apply @7.26-7.51 + (e-ident @7.26-7.41 (raw "Config.toString")) + (e-ident @7.42-7.50 (raw "settings"))))) + (s-type-anno @10.1-10.42 (name "authenticate") + (ty-fn @10.16-10.42 + (ty @10.16-10.19 (name "Str")) + (ty @10.21-10.24 (name "Str")) + (ty @10.28-10.42 (name "HttpAuth.Token")))) + (s-decl @11.1-11.55 + (p-ident @11.1-11.13 (raw "authenticate")) + (e-lambda @11.16-11.55 (args - (p-ident @13.17-13.21 (raw "user")) - (p-ident @13.23-13.27 (raw "pass"))) - (e-apply @13.29-13.55 - (e-ident @13.29-13.43 (raw "HttpAuth.login")) - (e-ident @13.44-13.48 (raw "user")) - (e-ident @13.50-13.54 (raw "pass"))))) - (s-type-anno @16.1-16.78 (name "processData") - (ty-fn @16.15-16.78 - (ty @16.15-16.37 (name "Config.Parser.Advanced")) - (ty @16.39-16.42 (name "Str")) - (ty-apply @16.46-16.78 - (ty @16.46-16.52 (name "Result")) - (ty @16.53-16.56 (name "Str")) - (ty @16.58-16.77 (name "Config.Parser.Error"))))) - (s-decl @17.1-18.60 - (p-ident @17.1-17.12 (raw "processData")) - (e-lambda @17.15-18.60 + (p-ident @11.17-11.21 (raw "user")) + (p-ident @11.23-11.27 (raw "pass"))) + (e-apply @11.29-11.55 + (e-ident @11.29-11.43 (raw "HttpAuth.login")) + (e-ident @11.44-11.48 (raw "user")) + (e-ident @11.50-11.54 (raw "pass"))))) + (s-type-anno @14.1-14.78 (name "processData") + (ty-fn @14.15-14.78 + (ty @14.15-14.37 (name "Config.Parser.Advanced")) + (ty @14.39-14.42 (name "Str")) + (ty-apply @14.46-14.78 + (ty @14.46-14.52 (name "Result")) + (ty @14.53-14.56 (name "Str")) + (ty @14.58-14.77 (name "Config.Parser.Error"))))) + (s-decl @15.1-16.60 + (p-ident @15.1-15.12 (raw "processData")) + (e-lambda @15.15-16.60 (args - (p-ident @17.16-17.30 (raw "advancedConfig")) - (p-ident @17.32-17.37 (raw "input"))) - (e-apply @18.5-18.60 - (e-ident @18.5-18.37 (raw "Config.Parser.Advanced.parseWith")) - (e-ident @18.38-18.52 (raw "advancedConfig")) - (e-ident @18.54-18.59 (raw "input"))))) - (s-type-anno @21.1-21.26 (name "formatOutput") - (ty-fn @21.16-21.26 - (ty @21.16-21.19 (name "Str")) - (ty @21.23-21.26 (name "Str")))) - (s-decl @22.1-22.59 - (p-ident @22.1-22.13 (raw "formatOutput")) - (e-lambda @22.16-22.59 + (p-ident @15.16-15.30 (raw "advancedConfig")) + (p-ident @15.32-15.37 (raw "input"))) + (e-apply @16.5-16.60 + (e-ident @16.5-16.37 (raw "Config.Parser.Advanced.parseWith")) + (e-ident @16.38-16.52 (raw "advancedConfig")) + (e-ident @16.54-16.59 (raw "input"))))) + (s-type-anno @19.1-19.26 (name "formatOutput") + (ty-fn @19.16-19.26 + (ty @19.16-19.19 (name "Str")) + (ty @19.23-19.26 (name "Str")))) + (s-decl @20.1-20.59 + (p-ident @20.1-20.13 (raw "formatOutput")) + (e-lambda @20.16-20.59 (args - (p-ident @22.17-22.21 (raw "text"))) - (e-apply @22.23-22.59 - (e-ident @22.23-22.30 (raw "padLeft")) - (e-ident @22.31-22.35 (raw "text")) - (e-ident @22.37-22.58 (raw "Config.defaultPadding"))))) - (s-type-anno @25.1-25.78 (name "validateAuth") - (ty-fn @25.16-25.78 - (ty @25.16-25.36 (name "HttpAuth.Credentials")) - (ty-apply @25.40-25.78 - (ty @25.40-25.46 (name "Result")) - (ty @25.47-25.61 (name "HttpAuth.Token")) - (ty @25.63-25.77 (name "HttpAuth.Error"))))) - (s-decl @26.1-26.48 - (p-ident @26.1-26.13 (raw "validateAuth")) - (e-lambda @26.16-26.48 + (p-ident @20.17-20.21 (raw "text"))) + (e-apply @20.23-20.59 + (e-ident @20.23-20.30 (raw "padLeft")) + (e-ident @20.31-20.35 (raw "text")) + (e-ident @20.37-20.58 (raw "Config.defaultPadding"))))) + (s-type-anno @23.1-23.78 (name "validateAuth") + (ty-fn @23.16-23.78 + (ty @23.16-23.36 (name "HttpAuth.Credentials")) + (ty-apply @23.40-23.78 + (ty @23.40-23.46 (name "Result")) + (ty @23.47-23.61 (name "HttpAuth.Token")) + (ty @23.63-23.77 (name "HttpAuth.Error"))))) + (s-decl @24.1-24.48 + (p-ident @24.1-24.13 (raw "validateAuth")) + (e-lambda @24.16-24.48 (args - (p-ident @26.17-26.22 (raw "creds"))) - (e-apply @26.24-26.48 - (e-ident @26.24-26.41 (raw "HttpAuth.validate")) - (e-ident @26.42-26.47 (raw "creds"))))))) + (p-ident @24.17-24.22 (raw "creds"))) + (e-apply @24.24-24.48 + (e-ident @24.24-24.41 (raw "HttpAuth.validate")) + (e-ident @24.42-24.47 (raw "creds"))))))) ~~~ # FORMATTED ~~~roc -module [] - import json.Parser import http.Client @@ -535,106 +499,106 @@ validateAuth = |creds| HttpAuth.validate(creds) ~~~clojure (can-ir (d-let - (p-assign @9.1-9.12 (ident "parseConfig")) - (e-lambda @9.15-9.51 + (p-assign @7.1-7.12 (ident "parseConfig")) + (e-lambda @7.15-7.51 (args - (p-assign @9.16-9.24 (ident "settings"))) - (e-call @9.26-9.51 + (p-assign @7.16-7.24 (ident "settings"))) + (e-call @7.26-7.51 (e-runtime-error (tag "ident_not_in_scope")) - (e-lookup-local @9.42-9.50 - (p-assign @9.16-9.24 (ident "settings"))))) - (annotation @9.1-9.12 + (e-lookup-local @7.42-7.50 + (p-assign @7.16-7.24 (ident "settings"))))) + (annotation @7.1-7.12 (declared-type - (ty-fn @8.15-8.37 (effectful false) - (ty-malformed @8.15-8.30) - (ty @8.34-8.37 (name "Str")))))) + (ty-fn @6.15-6.37 (effectful false) + (ty-malformed @6.15-6.30) + (ty-lookup @6.34-6.37 (name "Str") (builtin)))))) (d-let - (p-assign @13.1-13.13 (ident "authenticate")) - (e-lambda @13.16-13.55 + (p-assign @11.1-11.13 (ident "authenticate")) + (e-lambda @11.16-11.55 (args - (p-assign @13.17-13.21 (ident "user")) - (p-assign @13.23-13.27 (ident "pass"))) - (e-call @13.29-13.55 + (p-assign @11.17-11.21 (ident "user")) + (p-assign @11.23-11.27 (ident "pass"))) + (e-call @11.29-11.55 (e-runtime-error (tag "ident_not_in_scope")) - (e-lookup-local @13.44-13.48 - (p-assign @13.17-13.21 (ident "user"))) - (e-lookup-local @13.50-13.54 - (p-assign @13.23-13.27 (ident "pass"))))) - (annotation @13.1-13.13 + (e-lookup-local @11.44-11.48 + (p-assign @11.17-11.21 (ident "user"))) + (e-lookup-local @11.50-11.54 + (p-assign @11.23-11.27 (ident "pass"))))) + (annotation @11.1-11.13 (declared-type - (ty-fn @12.16-12.42 (effectful false) - (ty @12.16-12.19 (name "Str")) - (ty @12.21-12.24 (name "Str")) - (ty-malformed @12.28-12.42))))) + (ty-fn @10.16-10.42 (effectful false) + (ty-lookup @10.16-10.19 (name "Str") (builtin)) + (ty-lookup @10.21-10.24 (name "Str") (builtin)) + (ty-malformed @10.28-10.42))))) (d-let - (p-assign @17.1-17.12 (ident "processData")) - (e-lambda @17.15-18.60 + (p-assign @15.1-15.12 (ident "processData")) + (e-lambda @15.15-16.60 (args - (p-assign @17.16-17.30 (ident "advancedConfig")) - (p-assign @17.32-17.37 (ident "input"))) - (e-call @18.5-18.60 + (p-assign @15.16-15.30 (ident "advancedConfig")) + (p-assign @15.32-15.37 (ident "input"))) + (e-call @16.5-16.60 (e-runtime-error (tag "ident_not_in_scope")) - (e-lookup-local @18.38-18.52 - (p-assign @17.16-17.30 (ident "advancedConfig"))) - (e-lookup-local @18.54-18.59 - (p-assign @17.32-17.37 (ident "input"))))) - (annotation @17.1-17.12 + (e-lookup-local @16.38-16.52 + (p-assign @15.16-15.30 (ident "advancedConfig"))) + (e-lookup-local @16.54-16.59 + (p-assign @15.32-15.37 (ident "input"))))) + (annotation @15.1-15.12 (declared-type - (ty-fn @16.15-16.78 (effectful false) - (ty-malformed @16.15-16.37) - (ty @16.39-16.42 (name "Str")) - (ty-apply @16.46-16.78 (symbol "Result") - (ty @16.53-16.56 (name "Str")) - (ty-malformed @16.58-16.77)))))) + (ty-fn @14.15-14.78 (effectful false) + (ty-malformed @14.15-14.37) + (ty-lookup @14.39-14.42 (name "Str") (builtin)) + (ty-apply @14.46-14.78 (name "Result") (local) + (ty-lookup @14.46-14.78 (name "Str") (builtin)) + (ty-malformed @14.46-14.78)))))) (d-let - (p-assign @22.1-22.13 (ident "formatOutput")) - (e-lambda @22.16-22.59 + (p-assign @20.1-20.13 (ident "formatOutput")) + (e-lambda @20.16-20.59 (args - (p-assign @22.17-22.21 (ident "text"))) - (e-call @22.23-22.59 + (p-assign @20.17-20.21 (ident "text"))) + (e-call @20.23-20.59 (e-runtime-error (tag "ident_not_in_scope")) - (e-lookup-local @22.31-22.35 - (p-assign @22.17-22.21 (ident "text"))) + (e-lookup-local @20.31-20.35 + (p-assign @20.17-20.21 (ident "text"))) (e-runtime-error (tag "ident_not_in_scope")))) - (annotation @22.1-22.13 + (annotation @20.1-20.13 (declared-type - (ty-fn @21.16-21.26 (effectful false) - (ty @21.16-21.19 (name "Str")) - (ty @21.23-21.26 (name "Str")))))) + (ty-fn @19.16-19.26 (effectful false) + (ty-lookup @19.16-19.19 (name "Str") (builtin)) + (ty-lookup @19.23-19.26 (name "Str") (builtin)))))) (d-let - (p-assign @26.1-26.13 (ident "validateAuth")) - (e-lambda @26.16-26.48 + (p-assign @24.1-24.13 (ident "validateAuth")) + (e-lambda @24.16-24.48 (args - (p-assign @26.17-26.22 (ident "creds"))) - (e-call @26.24-26.48 + (p-assign @24.17-24.22 (ident "creds"))) + (e-call @24.24-24.48 (e-runtime-error (tag "ident_not_in_scope")) - (e-lookup-local @26.42-26.47 - (p-assign @26.17-26.22 (ident "creds"))))) - (annotation @26.1-26.13 + (e-lookup-local @24.42-24.47 + (p-assign @24.17-24.22 (ident "creds"))))) + (annotation @24.1-24.13 (declared-type - (ty-fn @25.16-25.78 (effectful false) - (ty-malformed @25.16-25.36) - (ty-apply @25.40-25.78 (symbol "Result") - (ty-malformed @25.47-25.61) - (ty-malformed @25.63-25.77)))))) - (s-import @3.1-3.19 (module "json.Parser") (qualifier "json") + (ty-fn @23.16-23.78 (effectful false) + (ty-malformed @23.16-23.36) + (ty-apply @23.40-23.78 (name "Result") (local) + (ty-malformed @23.40-23.78) + (ty-malformed @23.40-23.78)))))) + (s-import @1.1-1.19 (module "json.Parser") (qualifier "json") (exposes)) - (s-import @4.1-4.19 (module "http.Client") (qualifier "http") + (s-import @2.1-2.19 (module "http.Client") (qualifier "http") (exposes))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @9.1-9.12 (type "Error -> Str")) - (patt @13.1-13.13 (type "Str, Str -> Error")) - (patt @17.1-17.12 (type "Error, Str -> Result(Str, Error)")) - (patt @22.1-22.13 (type "Str -> Str")) - (patt @26.1-26.13 (type "Error -> Result(Error, Error)"))) + (patt @7.1-7.12 (type "Error -> Str")) + (patt @11.1-11.13 (type "Str, Str -> Error")) + (patt @15.1-15.12 (type "Error, Str -> Result(Str, Error)")) + (patt @20.1-20.13 (type "Str -> Str")) + (patt @24.1-24.13 (type "Error -> Result(Error, Error)"))) (expressions - (expr @9.15-9.51 (type "Error -> Str")) - (expr @13.16-13.55 (type "Str, Str -> Error")) - (expr @17.15-18.60 (type "Error, Str -> Result(Str, Error)")) - (expr @22.16-22.59 (type "Str -> Str")) - (expr @26.16-26.48 (type "Error -> Result(Error, Error)")))) + (expr @7.15-7.51 (type "Error -> Str")) + (expr @11.16-11.55 (type "Str, Str -> Error")) + (expr @15.15-16.60 (type "Error, Str -> Result(Str, Error)")) + (expr @20.16-20.59 (type "Str -> Str")) + (expr @24.16-24.48 (type "Error -> Result(Error, Error)")))) ~~~ diff --git a/test/snapshots/can_import_type_annotations.md b/test/snapshots/can_import_type_annotations.md index 27c050a1e0..7f2f58a43e 100644 --- a/test/snapshots/can_import_type_annotations.md +++ b/test/snapshots/can_import_type_annotations.md @@ -1,12 +1,10 @@ # META ~~~ini description=Import types and use in type annotations -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - import http.Client as Http exposing [Request, Response] import json.Json import utils.Result exposing [Result] @@ -46,20 +44,20 @@ combineResults = |result1, result2| } ~~~ # EXPECTED -MODULE NOT FOUND - can_import_type_annotations.md:3:1:3:56 -MODULE NOT FOUND - can_import_type_annotations.md:4:1:4:17 -MODULE NOT FOUND - can_import_type_annotations.md:5:1:5:38 -UNDECLARED TYPE - can_import_type_annotations.md:7:18:7:25 -UNDECLARED TYPE - can_import_type_annotations.md:7:29:7:37 -UNUSED VARIABLE - can_import_type_annotations.md:8:19:8:22 -MODULE NOT IMPORTED - can_import_type_annotations.md:26:18:26:36 -MODULE NOT IMPORTED - can_import_type_annotations.md:26:64:26:81 +MODULE NOT FOUND - can_import_type_annotations.md:1:1:1:56 +MODULE NOT FOUND - can_import_type_annotations.md:2:1:2:17 +MODULE NOT FOUND - can_import_type_annotations.md:3:1:3:38 +UNDECLARED TYPE - can_import_type_annotations.md:5:18:5:25 +UNDECLARED TYPE - can_import_type_annotations.md:5:29:5:37 +UNUSED VARIABLE - can_import_type_annotations.md:6:19:6:22 +MODULE NOT IMPORTED - can_import_type_annotations.md:24:18:24:36 +MODULE NOT IMPORTED - can_import_type_annotations.md:24:64:24:81 # PROBLEMS **MODULE NOT FOUND** The module `http.Client` was not found in this Roc project. You're attempting to use this module here: -**can_import_type_annotations.md:3:1:3:56:** +**can_import_type_annotations.md:1:1:1:56:** ```roc import http.Client as Http exposing [Request, Response] ``` @@ -70,7 +68,7 @@ import http.Client as Http exposing [Request, Response] The module `json.Json` was not found in this Roc project. You're attempting to use this module here: -**can_import_type_annotations.md:4:1:4:17:** +**can_import_type_annotations.md:2:1:2:17:** ```roc import json.Json ``` @@ -81,7 +79,7 @@ import json.Json The module `utils.Result` was not found in this Roc project. You're attempting to use this module here: -**can_import_type_annotations.md:5:1:5:38:** +**can_import_type_annotations.md:3:1:3:38:** ```roc import utils.Result exposing [Result] ``` @@ -92,7 +90,7 @@ import utils.Result exposing [Result] The type _Request_ is not declared in this scope. This type is referenced here: -**can_import_type_annotations.md:7:18:7:25:** +**can_import_type_annotations.md:5:18:5:25:** ```roc processRequest : Request -> Response ``` @@ -103,7 +101,7 @@ processRequest : Request -> Response The type _Response_ is not declared in this scope. This type is referenced here: -**can_import_type_annotations.md:7:29:7:37:** +**can_import_type_annotations.md:5:29:5:37:** ```roc processRequest : Request -> Response ``` @@ -115,7 +113,7 @@ Variable `req` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_req` to suppress this warning. The unused variable is declared here: -**can_import_type_annotations.md:8:19:8:22:** +**can_import_type_annotations.md:6:19:6:22:** ```roc processRequest = |req| Http.defaultResponse ``` @@ -123,35 +121,10 @@ processRequest = |req| Http.defaultResponse **MODULE NOT IMPORTED** -There is no module with the name `module [] - -import http.Client as Http exposing [Request, Response] -import json.Json -import utils.Result exposing [Result] - -processRequest : Request -> Response -processRequest = |req| Http.defaultResponse - -parseJson : Str -> Json.Value -parseJson = |input| Json.parse(input) - -handleApi : Http.Request -> Result(Http.Response, Json.Error) -handleApi = |request| { - result = Json.decode(request.body) - match result { - Ok(data) => Ok(Http.success(data)) - Err(err) => Err(err) - } -} - -config : Json.Config -config = Json.defaultConfig - -# Test nested type qualification -advancedParser : Json.Parser` imported into this Roc file. +There is no module with the name `Json.Parser` imported into this Roc file. You're attempting to use this module here: -**can_import_type_annotations.md:26:18:26:36:** +**can_import_type_annotations.md:24:18:24:36:** ```roc advancedParser : Json.Parser.Config, Str -> Result(Json.Value, Json.Parser.Error) ``` @@ -159,35 +132,10 @@ advancedParser : Json.Parser.Config, Str -> Result(Json.Value, Json.Parser.Error **MODULE NOT IMPORTED** -There is no module with the name `module [] - -import http.Client as Http exposing [Request, Response] -import json.Json -import utils.Result exposing [Result] - -processRequest : Request -> Response -processRequest = |req| Http.defaultResponse - -parseJson : Str -> Json.Value -parseJson = |input| Json.parse(input) - -handleApi : Http.Request -> Result(Http.Response, Json.Error) -handleApi = |request| { - result = Json.decode(request.body) - match result { - Ok(data) => Ok(Http.success(data)) - Err(err) => Err(err) - } -} - -config : Json.Config -config = Json.defaultConfig - -# Test nested type qualification -advancedParser : Json.Parser.Config, Str -> Result(Json.Value, Json.Parser` imported into this Roc file. +There is no module with the name `Json.Parser` imported into this Roc file. You're attempting to use this module here: -**can_import_type_annotations.md:26:64:26:81:** +**can_import_type_annotations.md:24:64:24:81:** ```roc advancedParser : Json.Parser.Config, Str -> Result(Json.Value, Json.Parser.Error) ``` @@ -196,192 +144,188 @@ advancedParser : Json.Parser.Config, Str -> Result(Json.Value, Json.Parser.Error # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -KwImport(3:1-3:7),LowerIdent(3:8-3:12),NoSpaceDotUpperIdent(3:12-3:19),KwAs(3:20-3:22),UpperIdent(3:23-3:27),KwExposing(3:28-3:36),OpenSquare(3:37-3:38),UpperIdent(3:38-3:45),Comma(3:45-3:46),UpperIdent(3:47-3:55),CloseSquare(3:55-3:56), -KwImport(4:1-4:7),LowerIdent(4:8-4:12),NoSpaceDotUpperIdent(4:12-4:17), -KwImport(5:1-5:7),LowerIdent(5:8-5:13),NoSpaceDotUpperIdent(5:13-5:20),KwExposing(5:21-5:29),OpenSquare(5:30-5:31),UpperIdent(5:31-5:37),CloseSquare(5:37-5:38), -LowerIdent(7:1-7:15),OpColon(7:16-7:17),UpperIdent(7:18-7:25),OpArrow(7:26-7:28),UpperIdent(7:29-7:37), -LowerIdent(8:1-8:15),OpAssign(8:16-8:17),OpBar(8:18-8:19),LowerIdent(8:19-8:22),OpBar(8:22-8:23),UpperIdent(8:24-8:28),NoSpaceDotLowerIdent(8:28-8:44), -LowerIdent(10:1-10:10),OpColon(10:11-10:12),UpperIdent(10:13-10:16),OpArrow(10:17-10:19),UpperIdent(10:20-10:24),NoSpaceDotUpperIdent(10:24-10:30), -LowerIdent(11:1-11:10),OpAssign(11:11-11:12),OpBar(11:13-11:14),LowerIdent(11:14-11:19),OpBar(11:19-11:20),UpperIdent(11:21-11:25),NoSpaceDotLowerIdent(11:25-11:31),NoSpaceOpenRound(11:31-11:32),LowerIdent(11:32-11:37),CloseRound(11:37-11:38), -LowerIdent(13:1-13:10),OpColon(13:11-13:12),UpperIdent(13:13-13:17),NoSpaceDotUpperIdent(13:17-13:25),OpArrow(13:26-13:28),UpperIdent(13:29-13:35),NoSpaceOpenRound(13:35-13:36),UpperIdent(13:36-13:40),NoSpaceDotUpperIdent(13:40-13:49),Comma(13:49-13:50),UpperIdent(13:51-13:55),NoSpaceDotUpperIdent(13:55-13:61),CloseRound(13:61-13:62), -LowerIdent(14:1-14:10),OpAssign(14:11-14:12),OpBar(14:13-14:14),LowerIdent(14:14-14:21),OpBar(14:21-14:22),OpenCurly(14:23-14:24), -LowerIdent(15:5-15:11),OpAssign(15:12-15:13),UpperIdent(15:14-15:18),NoSpaceDotLowerIdent(15:18-15:25),NoSpaceOpenRound(15:25-15:26),LowerIdent(15:26-15:33),NoSpaceDotLowerIdent(15:33-15:38),CloseRound(15:38-15:39), -KwMatch(16:5-16:10),LowerIdent(16:11-16:17),OpenCurly(16:18-16:19), -UpperIdent(17:9-17:11),NoSpaceOpenRound(17:11-17:12),LowerIdent(17:12-17:16),CloseRound(17:16-17:17),OpFatArrow(17:18-17:20),UpperIdent(17:21-17:23),NoSpaceOpenRound(17:23-17:24),UpperIdent(17:24-17:28),NoSpaceDotLowerIdent(17:28-17:36),NoSpaceOpenRound(17:36-17:37),LowerIdent(17:37-17:41),CloseRound(17:41-17:42),CloseRound(17:42-17:43), -UpperIdent(18:9-18:12),NoSpaceOpenRound(18:12-18:13),LowerIdent(18:13-18:16),CloseRound(18:16-18:17),OpFatArrow(18:18-18:20),UpperIdent(18:21-18:24),NoSpaceOpenRound(18:24-18:25),LowerIdent(18:25-18:28),CloseRound(18:28-18:29), -CloseCurly(19:5-19:6), -CloseCurly(20:1-20:2), -LowerIdent(22:1-22:7),OpColon(22:8-22:9),UpperIdent(22:10-22:14),NoSpaceDotUpperIdent(22:14-22:21), -LowerIdent(23:1-23:7),OpAssign(23:8-23:9),UpperIdent(23:10-23:14),NoSpaceDotLowerIdent(23:14-23:28), -LowerIdent(26:1-26:15),OpColon(26:16-26:17),UpperIdent(26:18-26:22),NoSpaceDotUpperIdent(26:22-26:29),NoSpaceDotUpperIdent(26:29-26:36),Comma(26:36-26:37),UpperIdent(26:38-26:41),OpArrow(26:42-26:44),UpperIdent(26:45-26:51),NoSpaceOpenRound(26:51-26:52),UpperIdent(26:52-26:56),NoSpaceDotUpperIdent(26:56-26:62),Comma(26:62-26:63),UpperIdent(26:64-26:68),NoSpaceDotUpperIdent(26:68-26:75),NoSpaceDotUpperIdent(26:75-26:81),CloseRound(26:81-26:82), -LowerIdent(27:1-27:15),OpAssign(27:16-27:17),OpBar(27:18-27:19),LowerIdent(27:19-27:31),Comma(27:31-27:32),LowerIdent(27:33-27:38),OpBar(27:38-27:39),UpperIdent(27:40-27:44),NoSpaceDotUpperIdent(27:44-27:51),NoSpaceDotLowerIdent(27:51-27:61),NoSpaceOpenRound(27:61-27:62),LowerIdent(27:62-27:74),Comma(27:74-27:75),LowerIdent(27:76-27:81),CloseRound(27:81-27:82), -LowerIdent(30:1-30:15),OpColon(30:16-30:17),UpperIdent(30:18-30:24),NoSpaceOpenRound(30:24-30:25),LowerIdent(30:25-30:26),Comma(30:26-30:27),LowerIdent(30:28-30:31),CloseRound(30:31-30:32),Comma(30:32-30:33),UpperIdent(30:34-30:40),NoSpaceOpenRound(30:40-30:41),LowerIdent(30:41-30:42),Comma(30:42-30:43),LowerIdent(30:44-30:47),CloseRound(30:47-30:48),OpArrow(30:49-30:51),UpperIdent(30:52-30:58),NoSpaceOpenRound(30:58-30:59),NoSpaceOpenRound(30:59-30:60),LowerIdent(30:60-30:61),Comma(30:61-30:62),LowerIdent(30:63-30:64),CloseRound(30:64-30:65),Comma(30:65-30:66),LowerIdent(30:67-30:70),CloseRound(30:70-30:71), -LowerIdent(31:1-31:15),OpAssign(31:16-31:17),OpBar(31:18-31:19),LowerIdent(31:19-31:26),Comma(31:26-31:27),LowerIdent(31:28-31:35),OpBar(31:35-31:36), -KwMatch(32:5-32:10),LowerIdent(32:11-32:18),OpenCurly(32:19-32:20), -UpperIdent(33:9-33:11),NoSpaceOpenRound(33:11-33:12),LowerIdent(33:12-33:18),CloseRound(33:18-33:19),OpFatArrow(33:20-33:22), -KwMatch(34:13-34:18),NoSpaceOpenRound(34:18-34:19),LowerIdent(34:19-34:26),CloseRound(34:26-34:27),OpenCurly(34:28-34:29), -UpperIdent(35:17-35:19),NoSpaceOpenRound(35:19-35:20),LowerIdent(35:20-35:26),CloseRound(35:26-35:27),OpFatArrow(35:28-35:30),UpperIdent(35:31-35:33),NoSpaceOpenRound(35:33-35:34),NoSpaceOpenRound(35:34-35:35),LowerIdent(35:35-35:41),Comma(35:41-35:42),LowerIdent(35:43-35:49),CloseRound(35:49-35:50),CloseRound(35:50-35:51), -UpperIdent(36:17-36:20),NoSpaceOpenRound(36:20-36:21),LowerIdent(36:21-36:24),CloseRound(36:24-36:25),OpFatArrow(36:26-36:28),UpperIdent(36:29-36:32),NoSpaceOpenRound(36:32-36:33),LowerIdent(36:33-36:36),CloseRound(36:36-36:37), -CloseCurly(37:13-37:14), -UpperIdent(38:9-38:12),NoSpaceOpenRound(38:12-38:13),LowerIdent(38:13-38:16),CloseRound(38:16-38:17),OpFatArrow(38:18-38:20),UpperIdent(38:21-38:24),NoSpaceOpenRound(38:24-38:25),LowerIdent(38:25-38:28),CloseRound(38:28-38:29), -CloseCurly(39:5-39:6), -EndOfFile(40:1-40:1), +KwImport(1:1-1:7),LowerIdent(1:8-1:12),NoSpaceDotUpperIdent(1:12-1:19),KwAs(1:20-1:22),UpperIdent(1:23-1:27),KwExposing(1:28-1:36),OpenSquare(1:37-1:38),UpperIdent(1:38-1:45),Comma(1:45-1:46),UpperIdent(1:47-1:55),CloseSquare(1:55-1:56), +KwImport(2:1-2:7),LowerIdent(2:8-2:12),NoSpaceDotUpperIdent(2:12-2:17), +KwImport(3:1-3:7),LowerIdent(3:8-3:13),NoSpaceDotUpperIdent(3:13-3:20),KwExposing(3:21-3:29),OpenSquare(3:30-3:31),UpperIdent(3:31-3:37),CloseSquare(3:37-3:38), +LowerIdent(5:1-5:15),OpColon(5:16-5:17),UpperIdent(5:18-5:25),OpArrow(5:26-5:28),UpperIdent(5:29-5:37), +LowerIdent(6:1-6:15),OpAssign(6:16-6:17),OpBar(6:18-6:19),LowerIdent(6:19-6:22),OpBar(6:22-6:23),UpperIdent(6:24-6:28),NoSpaceDotLowerIdent(6:28-6:44), +LowerIdent(8:1-8:10),OpColon(8:11-8:12),UpperIdent(8:13-8:16),OpArrow(8:17-8:19),UpperIdent(8:20-8:24),NoSpaceDotUpperIdent(8:24-8:30), +LowerIdent(9:1-9:10),OpAssign(9:11-9:12),OpBar(9:13-9:14),LowerIdent(9:14-9:19),OpBar(9:19-9:20),UpperIdent(9:21-9:25),NoSpaceDotLowerIdent(9:25-9:31),NoSpaceOpenRound(9:31-9:32),LowerIdent(9:32-9:37),CloseRound(9:37-9:38), +LowerIdent(11:1-11:10),OpColon(11:11-11:12),UpperIdent(11:13-11:17),NoSpaceDotUpperIdent(11:17-11:25),OpArrow(11:26-11:28),UpperIdent(11:29-11:35),NoSpaceOpenRound(11:35-11:36),UpperIdent(11:36-11:40),NoSpaceDotUpperIdent(11:40-11:49),Comma(11:49-11:50),UpperIdent(11:51-11:55),NoSpaceDotUpperIdent(11:55-11:61),CloseRound(11:61-11:62), +LowerIdent(12:1-12:10),OpAssign(12:11-12:12),OpBar(12:13-12:14),LowerIdent(12:14-12:21),OpBar(12:21-12:22),OpenCurly(12:23-12:24), +LowerIdent(13:5-13:11),OpAssign(13:12-13:13),UpperIdent(13:14-13:18),NoSpaceDotLowerIdent(13:18-13:25),NoSpaceOpenRound(13:25-13:26),LowerIdent(13:26-13:33),NoSpaceDotLowerIdent(13:33-13:38),CloseRound(13:38-13:39), +KwMatch(14:5-14:10),LowerIdent(14:11-14:17),OpenCurly(14:18-14:19), +UpperIdent(15:9-15:11),NoSpaceOpenRound(15:11-15:12),LowerIdent(15:12-15:16),CloseRound(15:16-15:17),OpFatArrow(15:18-15:20),UpperIdent(15:21-15:23),NoSpaceOpenRound(15:23-15:24),UpperIdent(15:24-15:28),NoSpaceDotLowerIdent(15:28-15:36),NoSpaceOpenRound(15:36-15:37),LowerIdent(15:37-15:41),CloseRound(15:41-15:42),CloseRound(15:42-15:43), +UpperIdent(16:9-16:12),NoSpaceOpenRound(16:12-16:13),LowerIdent(16:13-16:16),CloseRound(16:16-16:17),OpFatArrow(16:18-16:20),UpperIdent(16:21-16:24),NoSpaceOpenRound(16:24-16:25),LowerIdent(16:25-16:28),CloseRound(16:28-16:29), +CloseCurly(17:5-17:6), +CloseCurly(18:1-18:2), +LowerIdent(20:1-20:7),OpColon(20:8-20:9),UpperIdent(20:10-20:14),NoSpaceDotUpperIdent(20:14-20:21), +LowerIdent(21:1-21:7),OpAssign(21:8-21:9),UpperIdent(21:10-21:14),NoSpaceDotLowerIdent(21:14-21:28), +LowerIdent(24:1-24:15),OpColon(24:16-24:17),UpperIdent(24:18-24:22),NoSpaceDotUpperIdent(24:22-24:29),NoSpaceDotUpperIdent(24:29-24:36),Comma(24:36-24:37),UpperIdent(24:38-24:41),OpArrow(24:42-24:44),UpperIdent(24:45-24:51),NoSpaceOpenRound(24:51-24:52),UpperIdent(24:52-24:56),NoSpaceDotUpperIdent(24:56-24:62),Comma(24:62-24:63),UpperIdent(24:64-24:68),NoSpaceDotUpperIdent(24:68-24:75),NoSpaceDotUpperIdent(24:75-24:81),CloseRound(24:81-24:82), +LowerIdent(25:1-25:15),OpAssign(25:16-25:17),OpBar(25:18-25:19),LowerIdent(25:19-25:31),Comma(25:31-25:32),LowerIdent(25:33-25:38),OpBar(25:38-25:39),UpperIdent(25:40-25:44),NoSpaceDotUpperIdent(25:44-25:51),NoSpaceDotLowerIdent(25:51-25:61),NoSpaceOpenRound(25:61-25:62),LowerIdent(25:62-25:74),Comma(25:74-25:75),LowerIdent(25:76-25:81),CloseRound(25:81-25:82), +LowerIdent(28:1-28:15),OpColon(28:16-28:17),UpperIdent(28:18-28:24),NoSpaceOpenRound(28:24-28:25),LowerIdent(28:25-28:26),Comma(28:26-28:27),LowerIdent(28:28-28:31),CloseRound(28:31-28:32),Comma(28:32-28:33),UpperIdent(28:34-28:40),NoSpaceOpenRound(28:40-28:41),LowerIdent(28:41-28:42),Comma(28:42-28:43),LowerIdent(28:44-28:47),CloseRound(28:47-28:48),OpArrow(28:49-28:51),UpperIdent(28:52-28:58),NoSpaceOpenRound(28:58-28:59),NoSpaceOpenRound(28:59-28:60),LowerIdent(28:60-28:61),Comma(28:61-28:62),LowerIdent(28:63-28:64),CloseRound(28:64-28:65),Comma(28:65-28:66),LowerIdent(28:67-28:70),CloseRound(28:70-28:71), +LowerIdent(29:1-29:15),OpAssign(29:16-29:17),OpBar(29:18-29:19),LowerIdent(29:19-29:26),Comma(29:26-29:27),LowerIdent(29:28-29:35),OpBar(29:35-29:36), +KwMatch(30:5-30:10),LowerIdent(30:11-30:18),OpenCurly(30:19-30:20), +UpperIdent(31:9-31:11),NoSpaceOpenRound(31:11-31:12),LowerIdent(31:12-31:18),CloseRound(31:18-31:19),OpFatArrow(31:20-31:22), +KwMatch(32:13-32:18),NoSpaceOpenRound(32:18-32:19),LowerIdent(32:19-32:26),CloseRound(32:26-32:27),OpenCurly(32:28-32:29), +UpperIdent(33:17-33:19),NoSpaceOpenRound(33:19-33:20),LowerIdent(33:20-33:26),CloseRound(33:26-33:27),OpFatArrow(33:28-33:30),UpperIdent(33:31-33:33),NoSpaceOpenRound(33:33-33:34),NoSpaceOpenRound(33:34-33:35),LowerIdent(33:35-33:41),Comma(33:41-33:42),LowerIdent(33:43-33:49),CloseRound(33:49-33:50),CloseRound(33:50-33:51), +UpperIdent(34:17-34:20),NoSpaceOpenRound(34:20-34:21),LowerIdent(34:21-34:24),CloseRound(34:24-34:25),OpFatArrow(34:26-34:28),UpperIdent(34:29-34:32),NoSpaceOpenRound(34:32-34:33),LowerIdent(34:33-34:36),CloseRound(34:36-34:37), +CloseCurly(35:13-35:14), +UpperIdent(36:9-36:12),NoSpaceOpenRound(36:12-36:13),LowerIdent(36:13-36:16),CloseRound(36:16-36:17),OpFatArrow(36:18-36:20),UpperIdent(36:21-36:24),NoSpaceOpenRound(36:24-36:25),LowerIdent(36:25-36:28),CloseRound(36:28-36:29), +CloseCurly(37:5-37:6), +EndOfFile(38:1-38:1), ~~~ # PARSE ~~~clojure -(file @1.1-39.6 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-37.6 + (type-module @1.1-1.7) (statements - (s-import @3.1-3.56 (raw "http.Client") (alias "Http") + (s-import @1.1-1.56 (raw "http.Client") (alias "Http") (exposing - (exposed-upper-ident @3.38-3.45 (text "Request")) - (exposed-upper-ident @3.47-3.55 (text "Response")))) - (s-import @4.1-4.17 (raw "json.Json")) - (s-import @5.1-5.38 (raw "utils.Result") + (exposed-upper-ident @1.38-1.45 (text "Request")) + (exposed-upper-ident @1.47-1.55 (text "Response")))) + (s-import @2.1-2.17 (raw "json.Json")) + (s-import @3.1-3.38 (raw "utils.Result") (exposing - (exposed-upper-ident @5.31-5.37 (text "Result")))) - (s-type-anno @7.1-7.37 (name "processRequest") - (ty-fn @7.18-7.37 - (ty @7.18-7.25 (name "Request")) - (ty @7.29-7.37 (name "Response")))) - (s-decl @8.1-8.44 - (p-ident @8.1-8.15 (raw "processRequest")) - (e-lambda @8.18-8.44 + (exposed-upper-ident @3.31-3.37 (text "Result")))) + (s-type-anno @5.1-5.37 (name "processRequest") + (ty-fn @5.18-5.37 + (ty @5.18-5.25 (name "Request")) + (ty @5.29-5.37 (name "Response")))) + (s-decl @6.1-6.44 + (p-ident @6.1-6.15 (raw "processRequest")) + (e-lambda @6.18-6.44 (args - (p-ident @8.19-8.22 (raw "req"))) - (e-ident @8.24-8.44 (raw "Http.defaultResponse")))) - (s-type-anno @10.1-10.30 (name "parseJson") - (ty-fn @10.13-10.30 - (ty @10.13-10.16 (name "Str")) - (ty @10.20-10.30 (name "Json.Value")))) - (s-decl @11.1-11.38 - (p-ident @11.1-11.10 (raw "parseJson")) - (e-lambda @11.13-11.38 + (p-ident @6.19-6.22 (raw "req"))) + (e-ident @6.24-6.44 (raw "Http.defaultResponse")))) + (s-type-anno @8.1-8.30 (name "parseJson") + (ty-fn @8.13-8.30 + (ty @8.13-8.16 (name "Str")) + (ty @8.20-8.30 (name "Json.Value")))) + (s-decl @9.1-9.38 + (p-ident @9.1-9.10 (raw "parseJson")) + (e-lambda @9.13-9.38 (args - (p-ident @11.14-11.19 (raw "input"))) - (e-apply @11.21-11.38 - (e-ident @11.21-11.31 (raw "Json.parse")) - (e-ident @11.32-11.37 (raw "input"))))) - (s-type-anno @13.1-13.62 (name "handleApi") - (ty-fn @13.13-13.62 - (ty @13.13-13.25 (name "Http.Request")) - (ty-apply @13.29-13.62 - (ty @13.29-13.35 (name "Result")) - (ty @13.36-13.49 (name "Http.Response")) - (ty @13.51-13.61 (name "Json.Error"))))) - (s-decl @14.1-20.2 - (p-ident @14.1-14.10 (raw "handleApi")) - (e-lambda @14.13-20.2 + (p-ident @9.14-9.19 (raw "input"))) + (e-apply @9.21-9.38 + (e-ident @9.21-9.31 (raw "Json.parse")) + (e-ident @9.32-9.37 (raw "input"))))) + (s-type-anno @11.1-11.62 (name "handleApi") + (ty-fn @11.13-11.62 + (ty @11.13-11.25 (name "Http.Request")) + (ty-apply @11.29-11.62 + (ty @11.29-11.35 (name "Result")) + (ty @11.36-11.49 (name "Http.Response")) + (ty @11.51-11.61 (name "Json.Error"))))) + (s-decl @12.1-18.2 + (p-ident @12.1-12.10 (raw "handleApi")) + (e-lambda @12.13-18.2 (args - (p-ident @14.14-14.21 (raw "request"))) - (e-block @14.23-20.2 + (p-ident @12.14-12.21 (raw "request"))) + (e-block @12.23-18.2 (statements - (s-decl @15.5-15.39 - (p-ident @15.5-15.11 (raw "result")) - (e-apply @15.14-15.39 - (e-ident @15.14-15.25 (raw "Json.decode")) - (e-field-access @15.26-15.38 - (e-ident @15.26-15.33 (raw "request")) - (e-ident @15.33-15.38 (raw "body"))))) + (s-decl @13.5-13.39 + (p-ident @13.5-13.11 (raw "result")) + (e-apply @13.14-13.39 + (e-ident @13.14-13.25 (raw "Json.decode")) + (e-field-access @13.26-13.38 + (e-ident @13.26-13.33 (raw "request")) + (e-ident @13.33-13.38 (raw "body"))))) (e-match - (e-ident @16.11-16.17 (raw "result")) + (e-ident @14.11-14.17 (raw "result")) (branches - (branch @17.9-17.43 - (p-tag @17.9-17.17 (raw "Ok") - (p-ident @17.12-17.16 (raw "data"))) - (e-apply @17.21-17.43 - (e-tag @17.21-17.23 (raw "Ok")) - (e-apply @17.24-17.42 - (e-ident @17.24-17.36 (raw "Http.success")) - (e-ident @17.37-17.41 (raw "data"))))) - (branch @18.9-18.29 - (p-tag @18.9-18.17 (raw "Err") - (p-ident @18.13-18.16 (raw "err"))) - (e-apply @18.21-18.29 - (e-tag @18.21-18.24 (raw "Err")) - (e-ident @18.25-18.28 (raw "err")))))))))) - (s-type-anno @22.1-22.21 (name "config") - (ty @22.10-22.21 (name "Json.Config"))) - (s-decl @23.1-23.28 - (p-ident @23.1-23.7 (raw "config")) - (e-ident @23.10-23.28 (raw "Json.defaultConfig"))) - (s-type-anno @26.1-26.82 (name "advancedParser") - (ty-fn @26.18-26.82 - (ty @26.18-26.36 (name "Json.Parser.Config")) - (ty @26.38-26.41 (name "Str")) - (ty-apply @26.45-26.82 - (ty @26.45-26.51 (name "Result")) - (ty @26.52-26.62 (name "Json.Value")) - (ty @26.64-26.81 (name "Json.Parser.Error"))))) - (s-decl @27.1-27.82 - (p-ident @27.1-27.15 (raw "advancedParser")) - (e-lambda @27.18-27.82 + (branch @15.9-15.43 + (p-tag @15.9-15.17 (raw "Ok") + (p-ident @15.12-15.16 (raw "data"))) + (e-apply @15.21-15.43 + (e-tag @15.21-15.23 (raw "Ok")) + (e-apply @15.24-15.42 + (e-ident @15.24-15.36 (raw "Http.success")) + (e-ident @15.37-15.41 (raw "data"))))) + (branch @16.9-16.29 + (p-tag @16.9-16.17 (raw "Err") + (p-ident @16.13-16.16 (raw "err"))) + (e-apply @16.21-16.29 + (e-tag @16.21-16.24 (raw "Err")) + (e-ident @16.25-16.28 (raw "err")))))))))) + (s-type-anno @20.1-20.21 (name "config") + (ty @20.10-20.21 (name "Json.Config"))) + (s-decl @21.1-21.28 + (p-ident @21.1-21.7 (raw "config")) + (e-ident @21.10-21.28 (raw "Json.defaultConfig"))) + (s-type-anno @24.1-24.82 (name "advancedParser") + (ty-fn @24.18-24.82 + (ty @24.18-24.36 (name "Json.Parser.Config")) + (ty @24.38-24.41 (name "Str")) + (ty-apply @24.45-24.82 + (ty @24.45-24.51 (name "Result")) + (ty @24.52-24.62 (name "Json.Value")) + (ty @24.64-24.81 (name "Json.Parser.Error"))))) + (s-decl @25.1-25.82 + (p-ident @25.1-25.15 (raw "advancedParser")) + (e-lambda @25.18-25.82 (args - (p-ident @27.19-27.31 (raw "parserConfig")) - (p-ident @27.33-27.38 (raw "input"))) - (e-apply @27.40-27.82 - (e-ident @27.40-27.61 (raw "Json.Parser.parseWith")) - (e-ident @27.62-27.74 (raw "parserConfig")) - (e-ident @27.76-27.81 (raw "input"))))) - (s-type-anno @30.1-30.71 (name "combineResults") - (ty-fn @30.18-30.71 - (ty-apply @30.18-30.32 - (ty @30.18-30.24 (name "Result")) - (ty-var @30.25-30.26 (raw "a")) - (ty-var @30.28-30.31 (raw "err"))) - (ty-apply @30.34-30.48 - (ty @30.34-30.40 (name "Result")) - (ty-var @30.41-30.42 (raw "b")) - (ty-var @30.44-30.47 (raw "err"))) - (ty-apply @30.52-30.71 - (ty @30.52-30.58 (name "Result")) - (ty-tuple @30.59-30.65 - (ty-var @30.60-30.61 (raw "a")) - (ty-var @30.63-30.64 (raw "b"))) - (ty-var @30.67-30.70 (raw "err"))))) - (s-decl @31.1-39.6 - (p-ident @31.1-31.15 (raw "combineResults")) - (e-lambda @31.18-39.6 + (p-ident @25.19-25.31 (raw "parserConfig")) + (p-ident @25.33-25.38 (raw "input"))) + (e-apply @25.40-25.82 + (e-ident @25.40-25.61 (raw "Json.Parser.parseWith")) + (e-ident @25.62-25.74 (raw "parserConfig")) + (e-ident @25.76-25.81 (raw "input"))))) + (s-type-anno @28.1-28.71 (name "combineResults") + (ty-fn @28.18-28.71 + (ty-apply @28.18-28.32 + (ty @28.18-28.24 (name "Result")) + (ty-var @28.25-28.26 (raw "a")) + (ty-var @28.28-28.31 (raw "err"))) + (ty-apply @28.34-28.48 + (ty @28.34-28.40 (name "Result")) + (ty-var @28.41-28.42 (raw "b")) + (ty-var @28.44-28.47 (raw "err"))) + (ty-apply @28.52-28.71 + (ty @28.52-28.58 (name "Result")) + (ty-tuple @28.59-28.65 + (ty-var @28.60-28.61 (raw "a")) + (ty-var @28.63-28.64 (raw "b"))) + (ty-var @28.67-28.70 (raw "err"))))) + (s-decl @29.1-37.6 + (p-ident @29.1-29.15 (raw "combineResults")) + (e-lambda @29.18-37.6 (args - (p-ident @31.19-31.26 (raw "result1")) - (p-ident @31.28-31.35 (raw "result2"))) + (p-ident @29.19-29.26 (raw "result1")) + (p-ident @29.28-29.35 (raw "result2"))) (e-match - (e-ident @32.11-32.18 (raw "result1")) + (e-ident @30.11-30.18 (raw "result1")) (branches - (branch @33.9-37.14 - (p-tag @33.9-33.19 (raw "Ok") - (p-ident @33.12-33.18 (raw "value1"))) + (branch @31.9-35.14 + (p-tag @31.9-31.19 (raw "Ok") + (p-ident @31.12-31.18 (raw "value1"))) (e-match - (e-tuple @34.18-34.27 - (e-ident @34.19-34.26 (raw "result2"))) + (e-tuple @32.18-32.27 + (e-ident @32.19-32.26 (raw "result2"))) (branches - (branch @35.17-35.51 - (p-tag @35.17-35.27 (raw "Ok") - (p-ident @35.20-35.26 (raw "value2"))) - (e-apply @35.31-35.51 - (e-tag @35.31-35.33 (raw "Ok")) - (e-tuple @35.34-35.50 - (e-ident @35.35-35.41 (raw "value1")) - (e-ident @35.43-35.49 (raw "value2"))))) - (branch @36.17-36.37 - (p-tag @36.17-36.25 (raw "Err") - (p-ident @36.21-36.24 (raw "err"))) - (e-apply @36.29-36.37 - (e-tag @36.29-36.32 (raw "Err")) - (e-ident @36.33-36.36 (raw "err"))))))) - (branch @38.9-38.29 - (p-tag @38.9-38.17 (raw "Err") - (p-ident @38.13-38.16 (raw "err"))) - (e-apply @38.21-38.29 - (e-tag @38.21-38.24 (raw "Err")) - (e-ident @38.25-38.28 (raw "err")))))))))) + (branch @33.17-33.51 + (p-tag @33.17-33.27 (raw "Ok") + (p-ident @33.20-33.26 (raw "value2"))) + (e-apply @33.31-33.51 + (e-tag @33.31-33.33 (raw "Ok")) + (e-tuple @33.34-33.50 + (e-ident @33.35-33.41 (raw "value1")) + (e-ident @33.43-33.49 (raw "value2"))))) + (branch @34.17-34.37 + (p-tag @34.17-34.25 (raw "Err") + (p-ident @34.21-34.24 (raw "err"))) + (e-apply @34.29-34.37 + (e-tag @34.29-34.32 (raw "Err")) + (e-ident @34.33-34.36 (raw "err"))))))) + (branch @36.9-36.29 + (p-tag @36.9-36.17 (raw "Err") + (p-ident @36.13-36.16 (raw "err"))) + (e-apply @36.21-36.29 + (e-tag @36.21-36.24 (raw "Err")) + (e-ident @36.25-36.28 (raw "err")))))))))) ~~~ # FORMATTED ~~~roc -module [] - import http.Client as Http exposing [Request, Response] import json.Json import utils.Result exposing [Result] @@ -424,223 +368,211 @@ combineResults = |result1, result2| ~~~clojure (can-ir (d-let - (p-assign @8.1-8.15 (ident "processRequest")) - (e-lambda @8.18-8.44 + (p-assign @6.1-6.15 (ident "processRequest")) + (e-lambda @6.18-6.44 (args - (p-assign @8.19-8.22 (ident "req"))) - (e-lookup-external @8.24-8.44 - (module-idx "0") + (p-assign @6.19-6.22 (ident "req"))) + (e-lookup-external @6.24-6.44 + (module-idx "2") (target-node-idx "0"))) - (annotation @8.1-8.15 + (annotation @6.1-6.15 (declared-type - (ty-fn @7.18-7.37 (effectful false) - (ty @7.18-7.25 (name "Request")) - (ty @7.29-7.37 (name "Response")))))) + (ty-fn @5.18-5.37 (effectful false) + (ty-malformed @5.18-5.25) + (ty-malformed @5.29-5.37))))) (d-let - (p-assign @11.1-11.10 (ident "parseJson")) - (e-lambda @11.13-11.38 + (p-assign @9.1-9.10 (ident "parseJson")) + (e-lambda @9.13-9.38 (args - (p-assign @11.14-11.19 (ident "input"))) - (e-call @11.21-11.38 - (e-lookup-external @11.21-11.31 - (module-idx "1") + (p-assign @9.14-9.19 (ident "input"))) + (e-call @9.21-9.38 + (e-lookup-external @9.21-9.31 + (module-idx "3") (target-node-idx "0")) - (e-lookup-local @11.32-11.37 - (p-assign @11.14-11.19 (ident "input"))))) - (annotation @11.1-11.10 + (e-lookup-local @9.32-9.37 + (p-assign @9.14-9.19 (ident "input"))))) + (annotation @9.1-9.10 (declared-type - (ty-fn @10.13-10.30 (effectful false) - (ty @10.13-10.16 (name "Str")) - (ty-lookup-external @10.20-10.30 - (module-idx "1") - (target-node-idx "0")))))) + (ty-fn @8.13-8.30 (effectful false) + (ty-lookup @8.13-8.16 (name "Str") (builtin)) + (ty-lookup @8.20-8.30 (name "Value") (external (module-idx "3") (target-node-idx "0"))))))) (d-let - (p-assign @14.1-14.10 (ident "handleApi")) - (e-closure @14.13-20.2 + (p-assign @12.1-12.10 (ident "handleApi")) + (e-closure @12.13-18.2 (captures - (capture @17.12-17.16 (ident "data")) - (capture @18.13-18.16 (ident "err"))) - (e-lambda @14.13-20.2 + (capture @15.12-15.16 (ident "data")) + (capture @16.13-16.16 (ident "err"))) + (e-lambda @12.13-18.2 (args - (p-assign @14.14-14.21 (ident "request"))) - (e-block @14.23-20.2 - (s-let @15.5-15.39 - (p-assign @15.5-15.11 (ident "result")) - (e-call @15.14-15.39 - (e-lookup-external @15.14-15.25 - (module-idx "1") + (p-assign @12.14-12.21 (ident "request"))) + (e-block @12.23-18.2 + (s-let @13.5-13.39 + (p-assign @13.5-13.11 (ident "result")) + (e-call @13.14-13.39 + (e-lookup-external @13.14-13.25 + (module-idx "3") (target-node-idx "0")) - (e-dot-access @15.26-15.38 (field "body") + (e-dot-access @13.26-13.38 (field "body") (receiver - (e-lookup-local @15.26-15.33 - (p-assign @14.14-14.21 (ident "request"))))))) - (e-match @16.5-19.6 - (match @16.5-19.6 + (e-lookup-local @13.26-13.33 + (p-assign @12.14-12.21 (ident "request"))))))) + (e-match @14.5-17.6 + (match @14.5-17.6 (cond - (e-lookup-local @16.11-16.17 - (p-assign @15.5-15.11 (ident "result")))) + (e-lookup-local @14.11-14.17 + (p-assign @13.5-13.11 (ident "result")))) (branches (branch (patterns (pattern (degenerate false) - (p-nominal @17.9-17.17 - (p-applied-tag @17.9-17.17)))) + (p-nominal @15.9-15.17 + (p-applied-tag @15.9-15.17)))) (value - (e-nominal @17.21-17.43 (nominal "Result") - (e-tag @17.21-17.43 (name "Ok") + (e-nominal @15.21-15.43 (nominal "Result") + (e-tag @15.21-15.43 (name "Ok") (args - (e-call @17.24-17.42 - (e-lookup-external @17.24-17.36 - (module-idx "0") + (e-call @15.24-15.42 + (e-lookup-external @15.24-15.36 + (module-idx "2") (target-node-idx "0")) - (e-lookup-local @17.37-17.41 - (p-assign @17.12-17.16 (ident "data"))))))))) + (e-lookup-local @15.37-15.41 + (p-assign @15.12-15.16 (ident "data"))))))))) (branch (patterns (pattern (degenerate false) - (p-nominal @18.9-18.17 - (p-applied-tag @18.9-18.17)))) + (p-nominal @16.9-16.17 + (p-applied-tag @16.9-16.17)))) (value - (e-nominal @18.21-18.29 (nominal "Result") - (e-tag @18.21-18.29 (name "Err") + (e-nominal @16.21-16.29 (nominal "Result") + (e-tag @16.21-16.29 (name "Err") (args - (e-lookup-local @18.25-18.28 - (p-assign @18.13-18.16 (ident "err")))))))))))))) - (annotation @14.1-14.10 + (e-lookup-local @16.25-16.28 + (p-assign @16.13-16.16 (ident "err")))))))))))))) + (annotation @12.1-12.10 (declared-type - (ty-fn @13.13-13.62 (effectful false) - (ty-lookup-external @13.13-13.25 - (module-idx "0") - (target-node-idx "0")) - (ty-apply @13.29-13.62 (symbol "Result") - (ty-lookup-external @13.36-13.49 - (module-idx "0") - (target-node-idx "0")) - (ty-lookup-external @13.51-13.61 - (module-idx "1") - (target-node-idx "0"))))))) + (ty-fn @11.13-11.62 (effectful false) + (ty-lookup @11.13-11.25 (name "Request") (external (module-idx "2") (target-node-idx "0"))) + (ty-apply @11.29-11.62 (name "Result") (local) + (ty-lookup @11.29-11.62 (name "Response") (external (module-idx "2") (target-node-idx "0"))) + (ty-lookup @11.29-11.62 (name "Error") (external (module-idx "3") (target-node-idx "0")))))))) (d-let - (p-assign @23.1-23.7 (ident "config")) - (e-lookup-external @23.10-23.28 - (module-idx "1") + (p-assign @21.1-21.7 (ident "config")) + (e-lookup-external @21.10-21.28 + (module-idx "3") (target-node-idx "0")) - (annotation @23.1-23.7 + (annotation @21.1-21.7 (declared-type - (ty-lookup-external @22.10-22.21 - (module-idx "1") - (target-node-idx "0"))))) + (ty-lookup @20.10-20.21 (name "Config") (external (module-idx "3") (target-node-idx "0")))))) (d-let - (p-assign @27.1-27.15 (ident "advancedParser")) - (e-lambda @27.18-27.82 + (p-assign @25.1-25.15 (ident "advancedParser")) + (e-lambda @25.18-25.82 (args - (p-assign @27.19-27.31 (ident "parserConfig")) - (p-assign @27.33-27.38 (ident "input"))) - (e-call @27.40-27.82 - (e-lookup-external @27.40-27.61 - (module-idx "1") + (p-assign @25.19-25.31 (ident "parserConfig")) + (p-assign @25.33-25.38 (ident "input"))) + (e-call @25.40-25.82 + (e-lookup-external @25.40-25.61 + (module-idx "3") (target-node-idx "0")) - (e-lookup-local @27.62-27.74 - (p-assign @27.19-27.31 (ident "parserConfig"))) - (e-lookup-local @27.76-27.81 - (p-assign @27.33-27.38 (ident "input"))))) - (annotation @27.1-27.15 + (e-lookup-local @25.62-25.74 + (p-assign @25.19-25.31 (ident "parserConfig"))) + (e-lookup-local @25.76-25.81 + (p-assign @25.33-25.38 (ident "input"))))) + (annotation @25.1-25.15 (declared-type - (ty-fn @26.18-26.82 (effectful false) - (ty-malformed @26.18-26.36) - (ty @26.38-26.41 (name "Str")) - (ty-apply @26.45-26.82 (symbol "Result") - (ty-lookup-external @26.52-26.62 - (module-idx "1") - (target-node-idx "0")) - (ty-malformed @26.64-26.81)))))) + (ty-fn @24.18-24.82 (effectful false) + (ty-malformed @24.18-24.36) + (ty-lookup @24.38-24.41 (name "Str") (builtin)) + (ty-apply @24.45-24.82 (name "Result") (local) + (ty-lookup @24.45-24.82 (name "Value") (external (module-idx "3") (target-node-idx "0"))) + (ty-malformed @24.45-24.82)))))) (d-let - (p-assign @31.1-31.15 (ident "combineResults")) - (e-closure @31.18-39.6 + (p-assign @29.1-29.15 (ident "combineResults")) + (e-closure @29.18-37.6 (captures - (capture @38.13-38.16 (ident "err")) - (capture @36.21-36.24 (ident "err")) - (capture @33.12-33.18 (ident "value1")) - (capture @35.20-35.26 (ident "value2"))) - (e-lambda @31.18-39.6 + (capture @34.21-34.24 (ident "err")) + (capture @33.20-33.26 (ident "value2")) + (capture @36.13-36.16 (ident "err")) + (capture @31.12-31.18 (ident "value1"))) + (e-lambda @29.18-37.6 (args - (p-assign @31.19-31.26 (ident "result1")) - (p-assign @31.28-31.35 (ident "result2"))) - (e-match @32.5-39.6 - (match @32.5-39.6 + (p-assign @29.19-29.26 (ident "result1")) + (p-assign @29.28-29.35 (ident "result2"))) + (e-match @30.5-37.6 + (match @30.5-37.6 (cond - (e-lookup-local @32.11-32.18 - (p-assign @31.19-31.26 (ident "result1")))) + (e-lookup-local @30.11-30.18 + (p-assign @29.19-29.26 (ident "result1")))) (branches (branch (patterns (pattern (degenerate false) - (p-nominal @33.9-33.19 - (p-applied-tag @33.9-33.19)))) + (p-nominal @31.9-31.19 + (p-applied-tag @31.9-31.19)))) (value - (e-match @34.13-37.14 - (match @34.13-37.14 + (e-match @32.13-35.14 + (match @32.13-35.14 (cond - (e-lookup-local @34.19-34.26 - (p-assign @31.28-31.35 (ident "result2")))) + (e-lookup-local @32.19-32.26 + (p-assign @29.28-29.35 (ident "result2")))) (branches (branch (patterns (pattern (degenerate false) - (p-nominal @35.17-35.27 - (p-applied-tag @35.17-35.27)))) + (p-nominal @33.17-33.27 + (p-applied-tag @33.17-33.27)))) (value - (e-nominal @35.31-35.51 (nominal "Result") - (e-tag @35.31-35.51 (name "Ok") + (e-nominal @33.31-33.51 (nominal "Result") + (e-tag @33.31-33.51 (name "Ok") (args - (e-tuple @35.34-35.50 + (e-tuple @33.34-33.50 (elems - (e-lookup-local @35.35-35.41 - (p-assign @33.12-33.18 (ident "value1"))) - (e-lookup-local @35.43-35.49 - (p-assign @35.20-35.26 (ident "value2")))))))))) + (e-lookup-local @33.35-33.41 + (p-assign @31.12-31.18 (ident "value1"))) + (e-lookup-local @33.43-33.49 + (p-assign @33.20-33.26 (ident "value2")))))))))) (branch (patterns (pattern (degenerate false) - (p-nominal @36.17-36.25 - (p-applied-tag @36.17-36.25)))) + (p-nominal @34.17-34.25 + (p-applied-tag @34.17-34.25)))) (value - (e-nominal @36.29-36.37 (nominal "Result") - (e-tag @36.29-36.37 (name "Err") + (e-nominal @34.29-34.37 (nominal "Result") + (e-tag @34.29-34.37 (name "Err") (args - (e-lookup-local @36.33-36.36 - (p-assign @36.21-36.24 (ident "err"))))))))))))) + (e-lookup-local @34.33-34.36 + (p-assign @34.21-34.24 (ident "err"))))))))))))) (branch (patterns (pattern (degenerate false) - (p-nominal @38.9-38.17 - (p-applied-tag @38.9-38.17)))) + (p-nominal @36.9-36.17 + (p-applied-tag @36.9-36.17)))) (value - (e-nominal @38.21-38.29 (nominal "Result") - (e-tag @38.21-38.29 (name "Err") + (e-nominal @36.21-36.29 (nominal "Result") + (e-tag @36.21-36.29 (name "Err") (args - (e-lookup-local @38.25-38.28 - (p-assign @38.13-38.16 (ident "err"))))))))))))) - (annotation @31.1-31.15 + (e-lookup-local @36.25-36.28 + (p-assign @36.13-36.16 (ident "err"))))))))))))) + (annotation @29.1-29.15 (declared-type - (ty-fn @30.18-30.71 (effectful false) - (ty-apply @30.18-30.32 (symbol "Result") - (ty-var @30.25-30.26 (name "a")) - (ty-var @30.28-30.31 (name "err"))) - (ty-apply @30.34-30.48 (symbol "Result") - (ty-var @30.41-30.42 (name "b")) - (ty-var @30.44-30.47 (name "err"))) - (ty-apply @30.52-30.71 (symbol "Result") - (ty-tuple @30.59-30.65 - (ty-var @30.60-30.61 (name "a")) - (ty-var @30.63-30.64 (name "b"))) - (ty-var @30.67-30.70 (name "err"))))))) - (s-import @3.1-3.56 (module "http.Client") (qualifier "http") (alias "Http") + (ty-fn @28.18-28.71 (effectful false) + (ty-apply @28.18-28.32 (name "Result") (local) + (ty-rigid-var @28.18-28.32 (name "a")) + (ty-rigid-var @28.18-28.32 (name "err"))) + (ty-apply @28.34-28.48 (name "Result") (local) + (ty-rigid-var @28.34-28.48 (name "b")) + (ty-rigid-var-lookup (ty-rigid-var @28.18-28.32 (name "err")))) + (ty-apply @28.52-28.71 (name "Result") (local) + (ty-tuple @28.52-28.71 + (ty-rigid-var-lookup (ty-rigid-var @28.18-28.32 (name "a"))) + (ty-rigid-var-lookup (ty-rigid-var @28.34-28.48 (name "b")))) + (ty-rigid-var-lookup (ty-rigid-var @28.18-28.32 (name "err")))))))) + (s-import @1.1-1.56 (module "http.Client") (qualifier "http") (alias "Http") (exposes (exposed (name "Request") (wildcard false)) (exposed (name "Response") (wildcard false)))) - (s-import @4.1-4.17 (module "json.Json") (qualifier "json") + (s-import @2.1-2.17 (module "json.Json") (qualifier "json") (exposes)) - (s-import @5.1-5.38 (module "utils.Result") (qualifier "utils") + (s-import @3.1-3.38 (module "utils.Result") (qualifier "utils") (exposes (exposed (name "Result") (wildcard false))))) ~~~ @@ -648,17 +580,17 @@ combineResults = |result1, result2| ~~~clojure (inferred-types (defs - (patt @8.1-8.15 (type "Error -> Error")) - (patt @11.1-11.10 (type "Str -> Error")) - (patt @14.1-14.10 (type "Error -> Result(Error, Error)")) - (patt @23.1-23.7 (type "Error")) - (patt @27.1-27.15 (type "Error, Str -> Result(Error, Error)")) - (patt @31.1-31.15 (type "Result(a, err), Result(b, err) -> Result((a, b), err)"))) + (patt @6.1-6.15 (type "Error -> Error")) + (patt @9.1-9.10 (type "Str -> Error")) + (patt @12.1-12.10 (type "Error -> Result(Error, Error)")) + (patt @21.1-21.7 (type "Error")) + (patt @25.1-25.15 (type "Error, Str -> Result(Error, Error)")) + (patt @29.1-29.15 (type "Result(a, err), Result(b, err) -> Result((a, b), err)"))) (expressions - (expr @8.18-8.44 (type "Error -> Error")) - (expr @11.13-11.38 (type "Str -> Error")) - (expr @14.13-20.2 (type "Error -> Result(Error, Error)")) - (expr @23.10-23.28 (type "Error")) - (expr @27.18-27.82 (type "Error, Str -> Result(Error, Error)")) - (expr @31.18-39.6 (type "Result(a, err), Result(b, err) -> Result((a, b), err)")))) + (expr @6.18-6.44 (type "Error -> Error")) + (expr @9.13-9.38 (type "Str -> Error")) + (expr @12.13-18.2 (type "Error -> Result(Error, Error)")) + (expr @21.10-21.28 (type "Error")) + (expr @25.18-25.82 (type "Error, Str -> Result(Error, Error)")) + (expr @29.18-37.6 (type "Result(a, err), Result(b, err) -> Result((a, b), err)")))) ~~~ diff --git a/test/snapshots/can_import_unresolved_qualified.md b/test/snapshots/can_import_unresolved_qualified.md index a98fe52534..ba139acdc2 100644 --- a/test/snapshots/can_import_unresolved_qualified.md +++ b/test/snapshots/can_import_unresolved_qualified.md @@ -1,12 +1,10 @@ # META ~~~ini description=Error handling for unresolved qualified names -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - import json.Json import http.Client as Http @@ -34,17 +32,17 @@ client = Http.invalidMethod parser = Json.Parser.Advanced.NonExistent.create ~~~ # EXPECTED -MODULE NOT FOUND - can_import_unresolved_qualified.md:3:1:3:17 -MODULE NOT FOUND - can_import_unresolved_qualified.md:4:1:4:27 -MODULE NOT IMPORTED - can_import_unresolved_qualified.md:14:18:14:37 -MODULE NOT IMPORTED - can_import_unresolved_qualified.md:14:41:14:61 -UNUSED VARIABLE - can_import_unresolved_qualified.md:15:19:15:22 +MODULE NOT FOUND - can_import_unresolved_qualified.md:1:1:1:17 +MODULE NOT FOUND - can_import_unresolved_qualified.md:2:1:2:27 +MODULE NOT IMPORTED - can_import_unresolved_qualified.md:12:18:12:37 +MODULE NOT IMPORTED - can_import_unresolved_qualified.md:12:41:12:61 +UNUSED VARIABLE - can_import_unresolved_qualified.md:13:19:13:22 # PROBLEMS **MODULE NOT FOUND** The module `json.Json` was not found in this Roc project. You're attempting to use this module here: -**can_import_unresolved_qualified.md:3:1:3:17:** +**can_import_unresolved_qualified.md:1:1:1:17:** ```roc import json.Json ``` @@ -55,7 +53,7 @@ import json.Json The module `http.Client` was not found in this Roc project. You're attempting to use this module here: -**can_import_unresolved_qualified.md:4:1:4:27:** +**can_import_unresolved_qualified.md:2:1:2:27:** ```roc import http.Client as Http ``` @@ -63,23 +61,10 @@ import http.Client as Http **MODULE NOT IMPORTED** -There is no module with the name `module [] - -import json.Json -import http.Client as Http - -# Test unresolved qualified value -main = Json.NonExistent.method - -# Test unresolved qualified type in annotation -parseData : Json.InvalidType -> Str -parseData = |data| Json.stringify(data) - -# Test unresolved nested qualification -processRequest : Http.Server` imported into this Roc file. +There is no module with the name `Http.Server` imported into this Roc file. You're attempting to use this module here: -**can_import_unresolved_qualified.md:14:18:14:37:** +**can_import_unresolved_qualified.md:12:18:12:37:** ```roc processRequest : Http.Server.Request -> Http.Server.Response ``` @@ -87,23 +72,10 @@ processRequest : Http.Server.Request -> Http.Server.Response **MODULE NOT IMPORTED** -There is no module with the name `module [] - -import json.Json -import http.Client as Http - -# Test unresolved qualified value -main = Json.NonExistent.method - -# Test unresolved qualified type in annotation -parseData : Json.InvalidType -> Str -parseData = |data| Json.stringify(data) - -# Test unresolved nested qualification -processRequest : Http.Server.Request -> Http.Server` imported into this Roc file. +There is no module with the name `Http.Server` imported into this Roc file. You're attempting to use this module here: -**can_import_unresolved_qualified.md:14:41:14:61:** +**can_import_unresolved_qualified.md:12:41:12:61:** ```roc processRequest : Http.Server.Request -> Http.Server.Response ``` @@ -115,7 +87,7 @@ Variable `req` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_req` to suppress this warning. The unused variable is declared here: -**can_import_unresolved_qualified.md:15:19:15:22:** +**can_import_unresolved_qualified.md:13:19:13:22:** ```roc processRequest = |req| Http.Server.defaultResponse ``` @@ -124,68 +96,66 @@ processRequest = |req| Http.Server.defaultResponse # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -KwImport(3:1-3:7),LowerIdent(3:8-3:12),NoSpaceDotUpperIdent(3:12-3:17), -KwImport(4:1-4:7),LowerIdent(4:8-4:12),NoSpaceDotUpperIdent(4:12-4:19),KwAs(4:20-4:22),UpperIdent(4:23-4:27), -LowerIdent(7:1-7:5),OpAssign(7:6-7:7),UpperIdent(7:8-7:12),NoSpaceDotUpperIdent(7:12-7:24),NoSpaceDotLowerIdent(7:24-7:31), -LowerIdent(10:1-10:10),OpColon(10:11-10:12),UpperIdent(10:13-10:17),NoSpaceDotUpperIdent(10:17-10:29),OpArrow(10:30-10:32),UpperIdent(10:33-10:36), -LowerIdent(11:1-11:10),OpAssign(11:11-11:12),OpBar(11:13-11:14),LowerIdent(11:14-11:18),OpBar(11:18-11:19),UpperIdent(11:20-11:24),NoSpaceDotLowerIdent(11:24-11:34),NoSpaceOpenRound(11:34-11:35),LowerIdent(11:35-11:39),CloseRound(11:39-11:40), -LowerIdent(14:1-14:15),OpColon(14:16-14:17),UpperIdent(14:18-14:22),NoSpaceDotUpperIdent(14:22-14:29),NoSpaceDotUpperIdent(14:29-14:37),OpArrow(14:38-14:40),UpperIdent(14:41-14:45),NoSpaceDotUpperIdent(14:45-14:52),NoSpaceDotUpperIdent(14:52-14:61), -LowerIdent(15:1-15:15),OpAssign(15:16-15:17),OpBar(15:18-15:19),LowerIdent(15:19-15:22),OpBar(15:22-15:23),UpperIdent(15:24-15:28),NoSpaceDotUpperIdent(15:28-15:35),NoSpaceDotLowerIdent(15:35-15:51), -LowerIdent(18:1-18:7),OpAssign(18:8-18:9),UpperIdent(18:10-18:14),NoSpaceDotLowerIdent(18:14-18:20),NoSpaceOpenRound(18:20-18:21),StringStart(18:21-18:22),StringPart(18:22-18:26),StringEnd(18:26-18:27),CloseRound(18:27-18:28), -LowerIdent(21:1-21:7),OpAssign(21:8-21:9),UpperIdent(21:10-21:17),NoSpaceDotUpperIdent(21:17-21:24),NoSpaceDotLowerIdent(21:24-21:31), -LowerIdent(24:1-24:7),OpAssign(24:8-24:9),UpperIdent(24:10-24:14),NoSpaceDotLowerIdent(24:14-24:28), -LowerIdent(27:1-27:7),OpAssign(27:8-27:9),UpperIdent(27:10-27:14),NoSpaceDotUpperIdent(27:14-27:21),NoSpaceDotUpperIdent(27:21-27:30),NoSpaceDotUpperIdent(27:30-27:42),NoSpaceDotLowerIdent(27:42-27:49), -EndOfFile(28:1-28:1), +KwImport(1:1-1:7),LowerIdent(1:8-1:12),NoSpaceDotUpperIdent(1:12-1:17), +KwImport(2:1-2:7),LowerIdent(2:8-2:12),NoSpaceDotUpperIdent(2:12-2:19),KwAs(2:20-2:22),UpperIdent(2:23-2:27), +LowerIdent(5:1-5:5),OpAssign(5:6-5:7),UpperIdent(5:8-5:12),NoSpaceDotUpperIdent(5:12-5:24),NoSpaceDotLowerIdent(5:24-5:31), +LowerIdent(8:1-8:10),OpColon(8:11-8:12),UpperIdent(8:13-8:17),NoSpaceDotUpperIdent(8:17-8:29),OpArrow(8:30-8:32),UpperIdent(8:33-8:36), +LowerIdent(9:1-9:10),OpAssign(9:11-9:12),OpBar(9:13-9:14),LowerIdent(9:14-9:18),OpBar(9:18-9:19),UpperIdent(9:20-9:24),NoSpaceDotLowerIdent(9:24-9:34),NoSpaceOpenRound(9:34-9:35),LowerIdent(9:35-9:39),CloseRound(9:39-9:40), +LowerIdent(12:1-12:15),OpColon(12:16-12:17),UpperIdent(12:18-12:22),NoSpaceDotUpperIdent(12:22-12:29),NoSpaceDotUpperIdent(12:29-12:37),OpArrow(12:38-12:40),UpperIdent(12:41-12:45),NoSpaceDotUpperIdent(12:45-12:52),NoSpaceDotUpperIdent(12:52-12:61), +LowerIdent(13:1-13:15),OpAssign(13:16-13:17),OpBar(13:18-13:19),LowerIdent(13:19-13:22),OpBar(13:22-13:23),UpperIdent(13:24-13:28),NoSpaceDotUpperIdent(13:28-13:35),NoSpaceDotLowerIdent(13:35-13:51), +LowerIdent(16:1-16:7),OpAssign(16:8-16:9),UpperIdent(16:10-16:14),NoSpaceDotLowerIdent(16:14-16:20),NoSpaceOpenRound(16:20-16:21),StringStart(16:21-16:22),StringPart(16:22-16:26),StringEnd(16:26-16:27),CloseRound(16:27-16:28), +LowerIdent(19:1-19:7),OpAssign(19:8-19:9),UpperIdent(19:10-19:17),NoSpaceDotUpperIdent(19:17-19:24),NoSpaceDotLowerIdent(19:24-19:31), +LowerIdent(22:1-22:7),OpAssign(22:8-22:9),UpperIdent(22:10-22:14),NoSpaceDotLowerIdent(22:14-22:28), +LowerIdent(25:1-25:7),OpAssign(25:8-25:9),UpperIdent(25:10-25:14),NoSpaceDotUpperIdent(25:14-25:21),NoSpaceDotUpperIdent(25:21-25:30),NoSpaceDotUpperIdent(25:30-25:42),NoSpaceDotLowerIdent(25:42-25:49), +EndOfFile(26:1-26:1), ~~~ # PARSE ~~~clojure -(file @1.1-27.49 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-25.49 + (type-module @1.1-1.7) (statements - (s-import @3.1-3.17 (raw "json.Json")) - (s-import @4.1-4.27 (raw "http.Client") (alias "Http")) - (s-decl @7.1-7.31 - (p-ident @7.1-7.5 (raw "main")) - (e-ident @7.8-7.31 (raw "Json.NonExistent.method"))) - (s-type-anno @10.1-10.36 (name "parseData") - (ty-fn @10.13-10.36 - (ty @10.13-10.29 (name "Json.InvalidType")) - (ty @10.33-10.36 (name "Str")))) - (s-decl @11.1-11.40 - (p-ident @11.1-11.10 (raw "parseData")) - (e-lambda @11.13-11.40 + (s-import @1.1-1.17 (raw "json.Json")) + (s-import @2.1-2.27 (raw "http.Client") (alias "Http")) + (s-decl @5.1-5.31 + (p-ident @5.1-5.5 (raw "main")) + (e-ident @5.8-5.31 (raw "Json.NonExistent.method"))) + (s-type-anno @8.1-8.36 (name "parseData") + (ty-fn @8.13-8.36 + (ty @8.13-8.29 (name "Json.InvalidType")) + (ty @8.33-8.36 (name "Str")))) + (s-decl @9.1-9.40 + (p-ident @9.1-9.10 (raw "parseData")) + (e-lambda @9.13-9.40 (args - (p-ident @11.14-11.18 (raw "data"))) - (e-apply @11.20-11.40 - (e-ident @11.20-11.34 (raw "Json.stringify")) - (e-ident @11.35-11.39 (raw "data"))))) - (s-type-anno @14.1-14.61 (name "processRequest") - (ty-fn @14.18-14.61 - (ty @14.18-14.37 (name "Http.Server.Request")) - (ty @14.41-14.61 (name "Http.Server.Response")))) - (s-decl @15.1-15.51 - (p-ident @15.1-15.15 (raw "processRequest")) - (e-lambda @15.18-15.51 + (p-ident @9.14-9.18 (raw "data"))) + (e-apply @9.20-9.40 + (e-ident @9.20-9.34 (raw "Json.stringify")) + (e-ident @9.35-9.39 (raw "data"))))) + (s-type-anno @12.1-12.61 (name "processRequest") + (ty-fn @12.18-12.61 + (ty @12.18-12.37 (name "Http.Server.Request")) + (ty @12.41-12.61 (name "Http.Server.Response")))) + (s-decl @13.1-13.51 + (p-ident @13.1-13.15 (raw "processRequest")) + (e-lambda @13.18-13.51 (args - (p-ident @15.19-15.22 (raw "req"))) - (e-ident @15.24-15.51 (raw "Http.Server.defaultResponse")))) - (s-decl @18.1-18.28 - (p-ident @18.1-18.7 (raw "result")) - (e-apply @18.10-18.28 - (e-ident @18.10-18.20 (raw "Json.prase")) - (e-string @18.21-18.27 - (e-string-part @18.22-18.26 (raw "test"))))) - (s-decl @21.1-21.31 - (p-ident @21.1-21.7 (raw "config")) - (e-ident @21.10-21.31 (raw "Unknown.Module.config"))) - (s-decl @24.1-24.28 - (p-ident @24.1-24.7 (raw "client")) - (e-ident @24.10-24.28 (raw "Http.invalidMethod"))) - (s-decl @27.1-27.49 - (p-ident @27.1-27.7 (raw "parser")) - (e-ident @27.10-27.49 (raw "Json.Parser.Advanced.NonExistent.create"))))) + (p-ident @13.19-13.22 (raw "req"))) + (e-ident @13.24-13.51 (raw "Http.Server.defaultResponse")))) + (s-decl @16.1-16.28 + (p-ident @16.1-16.7 (raw "result")) + (e-apply @16.10-16.28 + (e-ident @16.10-16.20 (raw "Json.prase")) + (e-string @16.21-16.27 + (e-string-part @16.22-16.26 (raw "test"))))) + (s-decl @19.1-19.31 + (p-ident @19.1-19.7 (raw "config")) + (e-ident @19.10-19.31 (raw "Unknown.Module.config"))) + (s-decl @22.1-22.28 + (p-ident @22.1-22.7 (raw "client")) + (e-ident @22.10-22.28 (raw "Http.invalidMethod"))) + (s-decl @25.1-25.49 + (p-ident @25.1-25.7 (raw "parser")) + (e-ident @25.10-25.49 (raw "Json.Parser.Advanced.NonExistent.create"))))) ~~~ # FORMATTED ~~~roc @@ -195,85 +165,83 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @7.1-7.5 (ident "main")) - (e-lookup-external @7.8-7.31 - (module-idx "0") + (p-assign @5.1-5.5 (ident "main")) + (e-lookup-external @5.8-5.31 + (module-idx "2") (target-node-idx "0"))) (d-let - (p-assign @11.1-11.10 (ident "parseData")) - (e-lambda @11.13-11.40 + (p-assign @9.1-9.10 (ident "parseData")) + (e-lambda @9.13-9.40 (args - (p-assign @11.14-11.18 (ident "data"))) - (e-call @11.20-11.40 - (e-lookup-external @11.20-11.34 - (module-idx "0") + (p-assign @9.14-9.18 (ident "data"))) + (e-call @9.20-9.40 + (e-lookup-external @9.20-9.34 + (module-idx "2") (target-node-idx "0")) - (e-lookup-local @11.35-11.39 - (p-assign @11.14-11.18 (ident "data"))))) - (annotation @11.1-11.10 + (e-lookup-local @9.35-9.39 + (p-assign @9.14-9.18 (ident "data"))))) + (annotation @9.1-9.10 (declared-type - (ty-fn @10.13-10.36 (effectful false) - (ty-lookup-external @10.13-10.29 - (module-idx "0") - (target-node-idx "0")) - (ty @10.33-10.36 (name "Str")))))) + (ty-fn @8.13-8.36 (effectful false) + (ty-lookup @8.13-8.29 (name "InvalidType") (external (module-idx "2") (target-node-idx "0"))) + (ty-lookup @8.33-8.36 (name "Str") (builtin)))))) (d-let - (p-assign @15.1-15.15 (ident "processRequest")) - (e-lambda @15.18-15.51 + (p-assign @13.1-13.15 (ident "processRequest")) + (e-lambda @13.18-13.51 (args - (p-assign @15.19-15.22 (ident "req"))) - (e-lookup-external @15.24-15.51 - (module-idx "1") + (p-assign @13.19-13.22 (ident "req"))) + (e-lookup-external @13.24-13.51 + (module-idx "3") (target-node-idx "0"))) - (annotation @15.1-15.15 + (annotation @13.1-13.15 (declared-type - (ty-fn @14.18-14.61 (effectful false) - (ty-malformed @14.18-14.37) - (ty-malformed @14.41-14.61))))) + (ty-fn @12.18-12.61 (effectful false) + (ty-malformed @12.18-12.37) + (ty-malformed @12.41-12.61))))) (d-let - (p-assign @18.1-18.7 (ident "result")) - (e-call @18.10-18.28 - (e-lookup-external @18.10-18.20 - (module-idx "0") + (p-assign @16.1-16.7 (ident "result")) + (e-call @16.10-16.28 + (e-lookup-external @16.10-16.20 + (module-idx "2") (target-node-idx "0")) - (e-string @18.21-18.27 - (e-literal @18.22-18.26 (string "test"))))) + (e-string @16.21-16.27 + (e-literal @16.22-16.26 (string "test"))))) (d-let - (p-assign @21.1-21.7 (ident "config")) - (e-lookup-local @21.10-21.31 - (p-assign @21.1-21.7 (ident "config")))) + (p-assign @19.1-19.7 (ident "config")) + (e-lookup-local @19.10-19.31 + (p-assign @19.1-19.7 (ident "config")))) (d-let - (p-assign @24.1-24.7 (ident "client")) - (e-lookup-external @24.10-24.28 - (module-idx "1") + (p-assign @22.1-22.7 (ident "client")) + (e-lookup-external @22.10-22.28 + (module-idx "3") (target-node-idx "0"))) (d-let - (p-assign @27.1-27.7 (ident "parser")) - (e-lookup-external @27.10-27.49 - (module-idx "0") + (p-assign @25.1-25.7 (ident "parser")) + (e-lookup-external @25.10-25.49 + (module-idx "2") (target-node-idx "0"))) - (s-import @3.1-3.17 (module "json.Json") (qualifier "json") + (s-import @1.1-1.17 (module "json.Json") (qualifier "json") (exposes)) - (s-import @4.1-4.27 (module "http.Client") (qualifier "http") (alias "Http") + (s-import @2.1-2.27 (module "http.Client") (qualifier "http") (alias "Http") (exposes))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @7.1-7.5 (type "Error")) - (patt @11.1-11.10 (type "Error -> Str")) - (patt @15.1-15.15 (type "Error -> Error")) - (patt @18.1-18.7 (type "_a")) - (patt @21.1-21.7 (type "_a")) - (patt @24.1-24.7 (type "Error")) - (patt @27.1-27.7 (type "Error"))) + (patt @5.1-5.5 (type "Error")) + (patt @9.1-9.10 (type "Error -> Str")) + (patt @13.1-13.15 (type "Error -> Error")) + (patt @16.1-16.7 (type "_a")) + (patt @19.1-19.7 (type "_a")) + (patt @22.1-22.7 (type "Error")) + (patt @25.1-25.7 (type "Error"))) (expressions - (expr @7.8-7.31 (type "Error")) - (expr @11.13-11.40 (type "Error -> Str")) - (expr @15.18-15.51 (type "Error -> Error")) - (expr @18.10-18.28 (type "_a")) - (expr @21.10-21.31 (type "_a")) - (expr @24.10-24.28 (type "Error")) - (expr @27.10-27.49 (type "Error")))) + (expr @5.8-5.31 (type "Error")) + (expr @9.13-9.40 (type "Error -> Str")) + (expr @13.18-13.51 (type "Error -> Error")) + (expr @16.10-16.28 (type "_a")) + (expr @19.10-19.31 (type "_a")) + (expr @22.10-22.28 (type "Error")) + (expr @25.10-25.49 (type "Error")))) ~~~ diff --git a/test/snapshots/can_import_with_alias.md b/test/snapshots/can_import_with_alias.md index 028a793b17..0b69a700a2 100644 --- a/test/snapshots/can_import_with_alias.md +++ b/test/snapshots/can_import_with_alias.md @@ -1,24 +1,22 @@ # META ~~~ini description=Import with explicit alias -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - import json.Json as MyJson main = MyJson.decode ~~~ # EXPECTED -MODULE NOT FOUND - can_import_with_alias.md:3:1:3:27 +MODULE NOT FOUND - can_import_with_alias.md:1:1:1:27 # PROBLEMS **MODULE NOT FOUND** The module `json.Json` was not found in this Roc project. You're attempting to use this module here: -**can_import_with_alias.md:3:1:3:27:** +**can_import_with_alias.md:1:1:1:27:** ```roc import json.Json as MyJson ``` @@ -27,21 +25,19 @@ import json.Json as MyJson # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -KwImport(3:1-3:7),LowerIdent(3:8-3:12),NoSpaceDotUpperIdent(3:12-3:17),KwAs(3:18-3:20),UpperIdent(3:21-3:27), -LowerIdent(5:1-5:5),OpAssign(5:6-5:7),UpperIdent(5:8-5:14),NoSpaceDotLowerIdent(5:14-5:21), -EndOfFile(6:1-6:1), +KwImport(1:1-1:7),LowerIdent(1:8-1:12),NoSpaceDotUpperIdent(1:12-1:17),KwAs(1:18-1:20),UpperIdent(1:21-1:27), +LowerIdent(3:1-3:5),OpAssign(3:6-3:7),UpperIdent(3:8-3:14),NoSpaceDotLowerIdent(3:14-3:21), +EndOfFile(4:1-4:1), ~~~ # PARSE ~~~clojure -(file @1.1-5.21 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-3.21 + (type-module @1.1-1.7) (statements - (s-import @3.1-3.27 (raw "json.Json") (alias "MyJson")) - (s-decl @5.1-5.21 - (p-ident @5.1-5.5 (raw "main")) - (e-ident @5.8-5.21 (raw "MyJson.decode"))))) + (s-import @1.1-1.27 (raw "json.Json") (alias "MyJson")) + (s-decl @3.1-3.21 + (p-ident @3.1-3.5 (raw "main")) + (e-ident @3.8-3.21 (raw "MyJson.decode"))))) ~~~ # FORMATTED ~~~roc @@ -51,18 +47,18 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @5.1-5.5 (ident "main")) - (e-lookup-external @5.8-5.21 - (module-idx "0") + (p-assign @3.1-3.5 (ident "main")) + (e-lookup-external @3.8-3.21 + (module-idx "2") (target-node-idx "0"))) - (s-import @3.1-3.27 (module "json.Json") (qualifier "json") (alias "MyJson") + (s-import @1.1-1.27 (module "json.Json") (qualifier "json") (alias "MyJson") (exposes))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @5.1-5.5 (type "Error"))) + (patt @3.1-3.5 (type "Error"))) (expressions - (expr @5.8-5.21 (type "Error")))) + (expr @3.8-3.21 (type "Error")))) ~~~ diff --git a/test/snapshots/can_list_first_concrete.md b/test/snapshots/can_list_first_concrete.md index 9b80eba04b..cbe9c66708 100644 --- a/test/snapshots/can_list_first_concrete.md +++ b/test/snapshots/can_list_first_concrete.md @@ -50,7 +50,7 @@ NO CHANGE ~~~clojure (e-list @1.1-1.20 (elems - (e-int @1.2-1.4 (value "42")) + (e-num @1.2-1.4 (value "42")) (e-string @1.6-1.13 (e-literal @1.7-1.12 (string "world"))) (e-dec-small @1.15-1.19 (numerator "314") (denominator-power-of-ten "2") (value "3.14")))) diff --git a/test/snapshots/can_list_heterogeneous.md b/test/snapshots/can_list_heterogeneous.md index a15a5e78a3..348e461da1 100644 --- a/test/snapshots/can_list_heterogeneous.md +++ b/test/snapshots/can_list_heterogeneous.md @@ -50,7 +50,7 @@ NO CHANGE ~~~clojure (e-list @1.1-1.19 (elems - (e-int @1.2-1.3 (value "1")) + (e-num @1.2-1.3 (value "1")) (e-string @1.5-1.12 (e-literal @1.6-1.11 (string "hello"))) (e-dec-small @1.14-1.18 (numerator "314") (denominator-power-of-ten "2") (value "3.14")))) diff --git a/test/snapshots/can_list_mismatch_then_nested_error.md b/test/snapshots/can_list_mismatch_then_nested_error.md index ac3505ca67..6ad1d7a6dc 100644 --- a/test/snapshots/can_list_mismatch_then_nested_error.md +++ b/test/snapshots/can_list_mismatch_then_nested_error.md @@ -73,12 +73,12 @@ NO CHANGE ~~~clojure (e-list @1.1-1.27 (elems - (e-int @1.2-1.3 (value "1")) + (e-num @1.2-1.3 (value "1")) (e-string @1.5-1.12 (e-literal @1.6-1.11 (string "hello"))) (e-list @1.14-1.26 (elems - (e-int @1.15-1.16 (value "3")) + (e-num @1.15-1.16 (value "3")) (e-string @1.18-1.25 (e-literal @1.19-1.24 (string "world"))))))) ~~~ diff --git a/test/snapshots/can_list_multiline_mismatch.md b/test/snapshots/can_list_multiline_mismatch.md index b0d2319799..32b862a597 100644 --- a/test/snapshots/can_list_multiline_mismatch.md +++ b/test/snapshots/can_list_multiline_mismatch.md @@ -64,10 +64,10 @@ EndOfFile(6:1-6:1), ~~~clojure (e-list @1.1-5.2 (elems - (e-int @2.5-2.7 (value "42")) + (e-num @2.5-2.7 (value "42")) (e-string @3.5-3.18 (e-literal @3.6-3.17 (string "hello world"))) - (e-int @4.5-4.8 (value "100")))) + (e-num @4.5-4.8 (value "100")))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/can_list_nested_heterogeneous.md b/test/snapshots/can_list_nested_heterogeneous.md index 4240f1fcc5..f6083a2fee 100644 --- a/test/snapshots/can_list_nested_heterogeneous.md +++ b/test/snapshots/can_list_nested_heterogeneous.md @@ -55,7 +55,7 @@ NO CHANGE (e-empty_list @1.2-1.4) (e-list @1.6-1.9 (elems - (e-int @1.7-1.8 (value "1")))) + (e-num @1.7-1.8 (value "1")))) (e-list @1.11-1.20 (elems (e-string @1.12-1.19 diff --git a/test/snapshots/can_list_number_doesnt_fit.md b/test/snapshots/can_list_number_doesnt_fit.md index ba59464dc4..a723816d6d 100644 --- a/test/snapshots/can_list_number_doesnt_fit.md +++ b/test/snapshots/can_list_number_doesnt_fit.md @@ -19,7 +19,7 @@ The number **300** does not fit in its inferred type: ^^^ Its inferred type is: - _U8_ + _Num(Int(Unsigned8))_ # TOKENS ~~~zig @@ -41,9 +41,9 @@ NO CHANGE ~~~clojure (e-list @1.1-1.16 (elems - (e-int @1.2-1.5 (value "1")) - (e-int @1.7-1.10 (value "2")) - (e-int @1.12-1.15 (value "300")))) + (e-num @1.2-1.5 (value "1")) + (e-num @1.7-1.10 (value "2")) + (e-num @1.12-1.15 (value "300")))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/can_list_rest_types.md b/test/snapshots/can_list_rest_types.md index 6a7946b67f..1e0bc30fe9 100644 --- a/test/snapshots/can_list_rest_types.md +++ b/test/snapshots/can_list_rest_types.md @@ -94,5 +94,5 @@ match numbers { ~~~ # TYPES ~~~clojure -(expr @1.1-4.2 (type "List(_elem)")) +(expr @1.1-4.2 (type "Error")) ~~~ diff --git a/test/snapshots/can_list_triple_nested_heterogeneous.md b/test/snapshots/can_list_triple_nested_heterogeneous.md index 895d72fb59..de5e2121f9 100644 --- a/test/snapshots/can_list_triple_nested_heterogeneous.md +++ b/test/snapshots/can_list_triple_nested_heterogeneous.md @@ -62,7 +62,7 @@ NO CHANGE (e-empty_list @1.7-1.9) (e-list @1.11-1.14 (elems - (e-int @1.12-1.13 (value "1")))))) + (e-num @1.12-1.13 (value "1")))))) (e-list @1.17-1.32 (elems (e-empty_list @1.18-1.20) diff --git a/test/snapshots/can_list_two_elements.md b/test/snapshots/can_list_two_elements.md index baad52566f..f9555ec618 100644 --- a/test/snapshots/can_list_two_elements.md +++ b/test/snapshots/can_list_two_elements.md @@ -49,7 +49,7 @@ NO CHANGE ~~~clojure (e-list @1.1-1.13 (elems - (e-int @1.2-1.3 (value "1")) + (e-num @1.2-1.3 (value "1")) (e-string @1.5-1.12 (e-literal @1.6-1.11 (string "hello"))))) ~~~ diff --git a/test/snapshots/can_nested_heterogeneous_lists.md b/test/snapshots/can_nested_heterogeneous_lists.md index 45b411b7f0..426feafe6b 100644 --- a/test/snapshots/can_nested_heterogeneous_lists.md +++ b/test/snapshots/can_nested_heterogeneous_lists.md @@ -55,13 +55,13 @@ NO CHANGE (elems (e-list @1.2-1.14 (elems - (e-int @1.3-1.4 (value "1")) + (e-num @1.3-1.4 (value "1")) (e-string @1.6-1.13 (e-literal @1.7-1.12 (string "hello"))))) (e-list @1.16-1.22 (elems - (e-int @1.17-1.18 (value "2")) - (e-int @1.20-1.21 (value "3")))))) + (e-num @1.17-1.18 (value "2")) + (e-num @1.20-1.21 (value "3")))))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/can_two_decls.md b/test/snapshots/can_two_decls.md index cc3d0f0ced..a87acb8734 100644 --- a/test/snapshots/can_two_decls.md +++ b/test/snapshots/can_two_decls.md @@ -52,13 +52,13 @@ NO CHANGE (can-ir (d-let (p-assign @3.1-3.2 (ident "a")) - (e-int @3.5-3.6 (value "5"))) + (e-num @3.5-3.6 (value "5"))) (d-let (p-assign @4.1-4.2 (ident "b")) (e-binop @4.5-4.10 (op "add") (e-lookup-local @4.5-4.6 (p-assign @3.1-3.2 (ident "a"))) - (e-int @4.9-4.10 (value "1"))))) + (e-num @4.9-4.10 (value "1"))))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/can_var_scoping_invalid_top_level.md b/test/snapshots/can_var_scoping_invalid_top_level.md index 7794bc050d..4531013b5d 100644 --- a/test/snapshots/can_var_scoping_invalid_top_level.md +++ b/test/snapshots/can_var_scoping_invalid_top_level.md @@ -1,23 +1,21 @@ # META ~~~ini description=Variable scoping with var keyword -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - # This should cause an error - var not allowed at top level var topLevelVar_ = 0 ~~~ # EXPECTED -PARSE ERROR - can_var_scoping_invalid_top_level.md:4:1:4:4 +PARSE ERROR - can_var_scoping_invalid_top_level.md:2:1:2:4 # PROBLEMS **PARSE ERROR** A parsing error occurred: `var_only_allowed_in_a_body` This is an unexpected parsing error. Please check your syntax. -**can_var_scoping_invalid_top_level.md:4:1:4:4:** +**can_var_scoping_invalid_top_level.md:2:1:2:4:** ```roc var topLevelVar_ = 0 ``` @@ -26,25 +24,22 @@ var topLevelVar_ = 0 # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -KwVar(4:1-4:4),LowerIdent(4:5-4:17),OpAssign(4:18-4:19),Int(4:20-4:21), -EndOfFile(5:1-5:1), +KwVar(2:1-2:4),LowerIdent(2:5-2:17),OpAssign(2:18-2:19),Int(2:20-2:21), +EndOfFile(3:1-3:1), ~~~ # PARSE ~~~clojure -(file @1.1-4.21 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @2.1-2.21 + (type-module @2.1-2.4) (statements - (s-malformed @4.1-4.4 (tag "var_only_allowed_in_a_body")) - (s-decl @4.5-4.21 - (p-ident @4.5-4.17 (raw "topLevelVar_")) - (e-int @4.20-4.21 (raw "0"))))) + (s-malformed @2.1-2.4 (tag "var_only_allowed_in_a_body")) + (s-decl @2.5-2.21 + (p-ident @2.5-2.17 (raw "topLevelVar_")) + (e-int @2.20-2.21 (raw "0"))))) ~~~ # FORMATTED ~~~roc -module [] - +# This should cause an error - var not allowed at top level # This should cause an error - var not allowed at top level topLevelVar_ = 0 ~~~ @@ -52,14 +47,14 @@ topLevelVar_ = 0 ~~~clojure (can-ir (d-let - (p-assign @4.5-4.17 (ident "topLevelVar_")) - (e-int @4.20-4.21 (value "0")))) + (p-assign @2.5-2.17 (ident "topLevelVar_")) + (e-num @2.20-2.21 (value "0")))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @4.5-4.17 (type "Num(_size)"))) + (patt @2.5-2.17 (type "Num(_size)"))) (expressions - (expr @4.20-4.21 (type "Num(_size)")))) + (expr @2.20-2.21 (type "Num(_size)")))) ~~~ diff --git a/test/snapshots/can_var_scoping_regular_var.md b/test/snapshots/can_var_scoping_regular_var.md index c75632d776..4515760efb 100644 --- a/test/snapshots/can_var_scoping_regular_var.md +++ b/test/snapshots/can_var_scoping_regular_var.md @@ -1,12 +1,10 @@ # META ~~~ini description=Variable scoping with var keyword -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - # Regular function with var usage processItems = |items| { var count_ = 0 @@ -30,7 +28,7 @@ processItems = |items| { # EXPECTED VAR REASSIGNMENT ERROR - :0:0:0:0 VAR REASSIGNMENT ERROR - :0:0:0:0 -UNUSED VARIABLE - can_var_scoping_regular_var.md:4:17:4:22 +UNUSED VARIABLE - can_var_scoping_regular_var.md:2:17:2:22 # PROBLEMS **VAR REASSIGNMENT ERROR** Cannot reassign a `var` from outside the function where it was declared. @@ -45,7 +43,7 @@ Variable `items` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_items` to suppress this warning. The unused variable is declared here: -**can_var_scoping_regular_var.md:4:17:4:22:** +**can_var_scoping_regular_var.md:2:17:2:22:** ```roc processItems = |items| { ``` @@ -54,141 +52,158 @@ processItems = |items| { # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -LowerIdent(4:1-4:13),OpAssign(4:14-4:15),OpBar(4:16-4:17),LowerIdent(4:17-4:22),OpBar(4:22-4:23),OpenCurly(4:24-4:25), -KwVar(5:2-5:5),LowerIdent(5:6-5:12),OpAssign(5:13-5:14),Int(5:15-5:16), -KwVar(6:2-6:5),LowerIdent(6:6-6:12),OpAssign(6:13-6:14),Int(6:15-6:16), -LowerIdent(9:2-9:8),OpAssign(9:9-9:10),LowerIdent(9:11-9:17),OpPlus(9:18-9:19),Int(9:20-9:21), -LowerIdent(10:2-10:8),OpAssign(10:9-10:10),LowerIdent(10:11-10:17),OpPlus(10:18-10:19),Int(10:20-10:22), -LowerIdent(13:2-13:12),OpAssign(13:13-13:14),OpBar(13:15-13:16),Underscore(13:16-13:17),OpBar(13:17-13:18),OpenCurly(13:19-13:20), -LowerIdent(14:3-14:9),OpAssign(14:10-14:11),LowerIdent(14:12-14:18),OpPlus(14:19-14:20),Int(14:21-14:22), -LowerIdent(15:3-15:9),OpAssign(15:10-15:11),LowerIdent(15:12-15:18),OpStar(15:19-15:20),Int(15:21-15:22), -LowerIdent(16:3-16:9), -CloseCurly(17:2-17:3), -LowerIdent(19:2-19:8),OpAssign(19:9-19:10),LowerIdent(19:11-19:21),NoSpaceOpenRound(19:21-19:22),OpenCurly(19:22-19:23),CloseCurly(19:23-19:24),CloseRound(19:24-19:25), -LowerIdent(20:2-20:8),OpPlus(20:9-20:10),LowerIdent(20:11-20:17), -CloseCurly(21:1-21:2), -EndOfFile(22:1-22:1), +LowerIdent(2:1-2:13),OpAssign(2:14-2:15),OpBar(2:16-2:17),LowerIdent(2:17-2:22),OpBar(2:22-2:23),OpenCurly(2:24-2:25), +KwVar(3:2-3:5),LowerIdent(3:6-3:12),OpAssign(3:13-3:14),Int(3:15-3:16), +KwVar(4:2-4:5),LowerIdent(4:6-4:12),OpAssign(4:13-4:14),Int(4:15-4:16), +LowerIdent(7:2-7:8),OpAssign(7:9-7:10),LowerIdent(7:11-7:17),OpPlus(7:18-7:19),Int(7:20-7:21), +LowerIdent(8:2-8:8),OpAssign(8:9-8:10),LowerIdent(8:11-8:17),OpPlus(8:18-8:19),Int(8:20-8:22), +LowerIdent(11:2-11:12),OpAssign(11:13-11:14),OpBar(11:15-11:16),Underscore(11:16-11:17),OpBar(11:17-11:18),OpenCurly(11:19-11:20), +LowerIdent(12:3-12:9),OpAssign(12:10-12:11),LowerIdent(12:12-12:18),OpPlus(12:19-12:20),Int(12:21-12:22), +LowerIdent(13:3-13:9),OpAssign(13:10-13:11),LowerIdent(13:12-13:18),OpStar(13:19-13:20),Int(13:21-13:22), +LowerIdent(14:3-14:9), +CloseCurly(15:2-15:3), +LowerIdent(17:2-17:8),OpAssign(17:9-17:10),LowerIdent(17:11-17:21),NoSpaceOpenRound(17:21-17:22),OpenCurly(17:22-17:23),CloseCurly(17:23-17:24),CloseRound(17:24-17:25), +LowerIdent(18:2-18:8),OpPlus(18:9-18:10),LowerIdent(18:11-18:17), +CloseCurly(19:1-19:2), +EndOfFile(20:1-20:1), ~~~ # PARSE ~~~clojure -(file @1.1-21.2 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @2.1-19.2 + (type-module @2.1-2.13) (statements - (s-decl @4.1-21.2 - (p-ident @4.1-4.13 (raw "processItems")) - (e-lambda @4.16-21.2 + (s-decl @2.1-19.2 + (p-ident @2.1-2.13 (raw "processItems")) + (e-lambda @2.16-19.2 (args - (p-ident @4.17-4.22 (raw "items"))) - (e-block @4.24-21.2 + (p-ident @2.17-2.22 (raw "items"))) + (e-block @2.24-19.2 (statements - (s-var @5.2-5.16 (name "count_") - (e-int @5.15-5.16 (raw "0"))) - (s-var @6.2-6.16 (name "total_") - (e-int @6.15-6.16 (raw "0"))) - (s-decl @9.2-9.21 - (p-ident @9.2-9.8 (raw "count_")) - (e-binop @9.11-9.21 (op "+") - (e-ident @9.11-9.17 (raw "count_")) - (e-int @9.20-9.21 (raw "1")))) - (s-decl @10.2-10.22 - (p-ident @10.2-10.8 (raw "total_")) - (e-binop @10.11-10.22 (op "+") - (e-ident @10.11-10.17 (raw "total_")) - (e-int @10.20-10.22 (raw "10")))) - (s-decl @13.2-17.3 - (p-ident @13.2-13.12 (raw "nestedFunc")) - (e-lambda @13.15-17.3 + (s-var @3.2-3.16 (name "count_") + (e-int @3.15-3.16 (raw "0"))) + (s-var @4.2-4.16 (name "total_") + (e-int @4.15-4.16 (raw "0"))) + (s-decl @7.2-7.21 + (p-ident @7.2-7.8 (raw "count_")) + (e-binop @7.11-7.21 (op "+") + (e-ident @7.11-7.17 (raw "count_")) + (e-int @7.20-7.21 (raw "1")))) + (s-decl @8.2-8.22 + (p-ident @8.2-8.8 (raw "total_")) + (e-binop @8.11-8.22 (op "+") + (e-ident @8.11-8.17 (raw "total_")) + (e-int @8.20-8.22 (raw "10")))) + (s-decl @11.2-15.3 + (p-ident @11.2-11.12 (raw "nestedFunc")) + (e-lambda @11.15-15.3 (args (p-underscore)) - (e-block @13.19-17.3 + (e-block @11.19-15.3 (statements - (s-decl @14.3-14.22 - (p-ident @14.3-14.9 (raw "count_")) - (e-binop @14.12-14.22 (op "+") - (e-ident @14.12-14.18 (raw "count_")) - (e-int @14.21-14.22 (raw "5")))) - (s-decl @15.3-15.22 - (p-ident @15.3-15.9 (raw "total_")) - (e-binop @15.12-15.22 (op "*") - (e-ident @15.12-15.18 (raw "total_")) - (e-int @15.21-15.22 (raw "2")))) - (e-ident @16.3-16.9 (raw "count_")))))) - (s-decl @19.2-19.25 - (p-ident @19.2-19.8 (raw "result")) - (e-apply @19.11-19.25 - (e-ident @19.11-19.21 (raw "nestedFunc")) - (e-record @19.22-19.24))) - (e-binop @20.2-20.17 (op "+") - (e-ident @20.2-20.8 (raw "total_")) - (e-ident @20.11-20.17 (raw "result"))))))))) + (s-decl @12.3-12.22 + (p-ident @12.3-12.9 (raw "count_")) + (e-binop @12.12-12.22 (op "+") + (e-ident @12.12-12.18 (raw "count_")) + (e-int @12.21-12.22 (raw "5")))) + (s-decl @13.3-13.22 + (p-ident @13.3-13.9 (raw "total_")) + (e-binop @13.12-13.22 (op "*") + (e-ident @13.12-13.18 (raw "total_")) + (e-int @13.21-13.22 (raw "2")))) + (e-ident @14.3-14.9 (raw "count_")))))) + (s-decl @17.2-17.25 + (p-ident @17.2-17.8 (raw "result")) + (e-apply @17.11-17.25 + (e-ident @17.11-17.21 (raw "nestedFunc")) + (e-record @17.22-17.24))) + (e-binop @18.2-18.17 (op "+") + (e-ident @18.2-18.8 (raw "total_")) + (e-ident @18.11-18.17 (raw "result"))))))))) ~~~ # FORMATTED ~~~roc -NO CHANGE +# Regular function with var usage +# Regular function with var usage +processItems = |items| { + var count_ = 0 + var total_ = 0 + + # Reassign vars within same function - should work + count_ = count_ + 1 + total_ = total_ + 10 + + # Nested function - var reassignment should fail across function boundary + nestedFunc = |_| { + count_ = count_ + 5 # Should cause error - different function + total_ = total_ * 2 # Should cause error - different function + count_ + } + + result = nestedFunc({}) + total_ + result +} ~~~ # CANONICALIZE ~~~clojure (can-ir (d-let - (p-assign @4.1-4.13 (ident "processItems")) - (e-lambda @4.16-21.2 + (p-assign @2.1-2.13 (ident "processItems")) + (e-lambda @2.16-19.2 (args - (p-assign @4.17-4.22 (ident "items"))) - (e-block @4.24-21.2 - (s-var @5.2-5.16 - (p-assign @5.2-5.16 (ident "count_")) - (e-int @5.15-5.16 (value "0"))) - (s-var @6.2-6.16 - (p-assign @6.2-6.16 (ident "total_")) - (e-int @6.15-6.16 (value "0"))) - (s-reassign @9.2-9.8 - (p-assign @5.2-5.16 (ident "count_")) - (e-binop @9.11-9.21 (op "add") - (e-lookup-local @9.11-9.17 - (p-assign @5.2-5.16 (ident "count_"))) - (e-int @9.20-9.21 (value "1")))) - (s-reassign @10.2-10.8 - (p-assign @6.2-6.16 (ident "total_")) - (e-binop @10.11-10.22 (op "add") - (e-lookup-local @10.11-10.17 - (p-assign @6.2-6.16 (ident "total_"))) - (e-int @10.20-10.22 (value "10")))) - (s-let @13.2-17.3 - (p-assign @13.2-13.12 (ident "nestedFunc")) - (e-closure @13.15-17.3 + (p-assign @2.17-2.22 (ident "items"))) + (e-block @2.24-19.2 + (s-var @3.2-3.16 + (p-assign @3.2-3.16 (ident "count_")) + (e-num @3.15-3.16 (value "0"))) + (s-var @4.2-4.16 + (p-assign @4.2-4.16 (ident "total_")) + (e-num @4.15-4.16 (value "0"))) + (s-reassign @7.2-7.8 + (p-assign @3.2-3.16 (ident "count_")) + (e-binop @7.11-7.21 (op "add") + (e-lookup-local @7.11-7.17 + (p-assign @3.2-3.16 (ident "count_"))) + (e-num @7.20-7.21 (value "1")))) + (s-reassign @8.2-8.8 + (p-assign @4.2-4.16 (ident "total_")) + (e-binop @8.11-8.22 (op "add") + (e-lookup-local @8.11-8.17 + (p-assign @4.2-4.16 (ident "total_"))) + (e-num @8.20-8.22 (value "10")))) + (s-let @11.2-15.3 + (p-assign @11.2-11.12 (ident "nestedFunc")) + (e-closure @11.15-15.3 (captures - (capture @5.2-5.16 (ident "count_"))) - (e-lambda @13.15-17.3 + (capture @3.2-3.16 (ident "count_"))) + (e-lambda @11.15-15.3 (args - (p-underscore @13.16-13.17)) - (e-block @13.19-17.3 - (s-reassign @14.3-14.9 - (p-assign @5.2-5.16 (ident "count_")) + (p-underscore @11.16-11.17)) + (e-block @11.19-15.3 + (s-reassign @12.3-12.9 + (p-assign @3.2-3.16 (ident "count_")) (e-runtime-error (tag "var_across_function_boundary"))) - (s-reassign @15.3-15.9 - (p-assign @6.2-6.16 (ident "total_")) + (s-reassign @13.3-13.9 + (p-assign @4.2-4.16 (ident "total_")) (e-runtime-error (tag "var_across_function_boundary"))) - (e-lookup-local @16.3-16.9 - (p-assign @5.2-5.16 (ident "count_"))))))) - (s-let @19.2-19.25 - (p-assign @19.2-19.8 (ident "result")) - (e-call @19.11-19.25 - (e-lookup-local @19.11-19.21 - (p-assign @13.2-13.12 (ident "nestedFunc"))) - (e-empty_record @19.22-19.24))) - (e-binop @20.2-20.17 (op "add") - (e-lookup-local @20.2-20.8 - (p-assign @6.2-6.16 (ident "total_"))) - (e-lookup-local @20.11-20.17 - (p-assign @19.2-19.8 (ident "result")))))))) + (e-lookup-local @14.3-14.9 + (p-assign @3.2-3.16 (ident "count_"))))))) + (s-let @17.2-17.25 + (p-assign @17.2-17.8 (ident "result")) + (e-call @17.11-17.25 + (e-lookup-local @17.11-17.21 + (p-assign @11.2-11.12 (ident "nestedFunc"))) + (e-empty_record @17.22-17.24))) + (e-binop @18.2-18.17 (op "add") + (e-lookup-local @18.2-18.8 + (p-assign @4.2-4.16 (ident "total_"))) + (e-lookup-local @18.11-18.17 + (p-assign @17.2-17.8 (ident "result")))))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @4.1-4.13 (type "_arg -> Num(_size)"))) + (patt @2.1-2.13 (type "_arg -> Error"))) (expressions - (expr @4.16-21.2 (type "_arg -> Num(_size)")))) + (expr @2.16-19.2 (type "_arg -> Error")))) ~~~ diff --git a/test/snapshots/can_var_scoping_var_idents.md b/test/snapshots/can_var_scoping_var_idents.md index ff265cd087..d46d519d62 100644 --- a/test/snapshots/can_var_scoping_var_idents.md +++ b/test/snapshots/can_var_scoping_var_idents.md @@ -1,12 +1,10 @@ # META ~~~ini description=Variable scoping with var keyword -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - # Function showing var vs regular identifier independence testFunc = |input| { sum = input # Regular identifier @@ -22,85 +20,91 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -LowerIdent(4:1-4:9),OpAssign(4:10-4:11),OpBar(4:12-4:13),LowerIdent(4:13-4:18),OpBar(4:18-4:19),OpenCurly(4:20-4:21), -LowerIdent(5:2-5:5),OpAssign(5:6-5:7),LowerIdent(5:8-5:13), -KwVar(6:2-6:5),LowerIdent(6:6-6:10),OpAssign(6:11-6:12),LowerIdent(6:13-6:18),OpStar(6:19-6:20),Int(6:21-6:22), -LowerIdent(8:2-8:6),OpAssign(8:7-8:8),LowerIdent(8:9-8:13),OpPlus(8:14-8:15),LowerIdent(8:16-8:19), -LowerIdent(9:2-9:5),OpPlus(9:6-9:7),LowerIdent(9:8-9:12), -CloseCurly(10:1-10:2), -EndOfFile(11:1-11:1), +LowerIdent(2:1-2:9),OpAssign(2:10-2:11),OpBar(2:12-2:13),LowerIdent(2:13-2:18),OpBar(2:18-2:19),OpenCurly(2:20-2:21), +LowerIdent(3:2-3:5),OpAssign(3:6-3:7),LowerIdent(3:8-3:13), +KwVar(4:2-4:5),LowerIdent(4:6-4:10),OpAssign(4:11-4:12),LowerIdent(4:13-4:18),OpStar(4:19-4:20),Int(4:21-4:22), +LowerIdent(6:2-6:6),OpAssign(6:7-6:8),LowerIdent(6:9-6:13),OpPlus(6:14-6:15),LowerIdent(6:16-6:19), +LowerIdent(7:2-7:5),OpPlus(7:6-7:7),LowerIdent(7:8-7:12), +CloseCurly(8:1-8:2), +EndOfFile(9:1-9:1), ~~~ # PARSE ~~~clojure -(file @1.1-10.2 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @2.1-8.2 + (type-module @2.1-2.9) (statements - (s-decl @4.1-10.2 - (p-ident @4.1-4.9 (raw "testFunc")) - (e-lambda @4.12-10.2 + (s-decl @2.1-8.2 + (p-ident @2.1-2.9 (raw "testFunc")) + (e-lambda @2.12-8.2 (args - (p-ident @4.13-4.18 (raw "input"))) - (e-block @4.20-10.2 + (p-ident @2.13-2.18 (raw "input"))) + (e-block @2.20-8.2 (statements - (s-decl @5.2-5.13 - (p-ident @5.2-5.5 (raw "sum")) - (e-ident @5.8-5.13 (raw "input"))) - (s-var @6.2-6.22 (name "sum_") - (e-binop @6.13-6.22 (op "*") - (e-ident @6.13-6.18 (raw "input")) - (e-int @6.21-6.22 (raw "2")))) - (s-decl @8.2-8.19 - (p-ident @8.2-8.6 (raw "sum_")) - (e-binop @8.9-8.19 (op "+") - (e-ident @8.9-8.13 (raw "sum_")) - (e-ident @8.16-8.19 (raw "sum")))) - (e-binop @9.2-9.12 (op "+") - (e-ident @9.2-9.5 (raw "sum")) - (e-ident @9.8-9.12 (raw "sum_"))))))))) + (s-decl @3.2-3.13 + (p-ident @3.2-3.5 (raw "sum")) + (e-ident @3.8-3.13 (raw "input"))) + (s-var @4.2-4.22 (name "sum_") + (e-binop @4.13-4.22 (op "*") + (e-ident @4.13-4.18 (raw "input")) + (e-int @4.21-4.22 (raw "2")))) + (s-decl @6.2-6.19 + (p-ident @6.2-6.6 (raw "sum_")) + (e-binop @6.9-6.19 (op "+") + (e-ident @6.9-6.13 (raw "sum_")) + (e-ident @6.16-6.19 (raw "sum")))) + (e-binop @7.2-7.12 (op "+") + (e-ident @7.2-7.5 (raw "sum")) + (e-ident @7.8-7.12 (raw "sum_"))))))))) ~~~ # FORMATTED ~~~roc -NO CHANGE +# Function showing var vs regular identifier independence +# Function showing var vs regular identifier independence +testFunc = |input| { + sum = input # Regular identifier + var sum_ = input * 2 # Var with underscore - should not conflict + + sum_ = sum_ + sum # Reassign var - should work + sum + sum_ # Both should be accessible +} ~~~ # CANONICALIZE ~~~clojure (can-ir (d-let - (p-assign @4.1-4.9 (ident "testFunc")) - (e-lambda @4.12-10.2 + (p-assign @2.1-2.9 (ident "testFunc")) + (e-lambda @2.12-8.2 (args - (p-assign @4.13-4.18 (ident "input"))) - (e-block @4.20-10.2 - (s-let @5.2-5.13 - (p-assign @5.2-5.5 (ident "sum")) - (e-lookup-local @5.8-5.13 - (p-assign @4.13-4.18 (ident "input")))) - (s-var @6.2-6.22 - (p-assign @6.2-6.22 (ident "sum_")) - (e-binop @6.13-6.22 (op "mul") - (e-lookup-local @6.13-6.18 - (p-assign @4.13-4.18 (ident "input"))) - (e-int @6.21-6.22 (value "2")))) - (s-reassign @8.2-8.6 - (p-assign @6.2-6.22 (ident "sum_")) - (e-binop @8.9-8.19 (op "add") - (e-lookup-local @8.9-8.13 - (p-assign @6.2-6.22 (ident "sum_"))) - (e-lookup-local @8.16-8.19 - (p-assign @5.2-5.5 (ident "sum"))))) - (e-binop @9.2-9.12 (op "add") - (e-lookup-local @9.2-9.5 - (p-assign @5.2-5.5 (ident "sum"))) - (e-lookup-local @9.8-9.12 - (p-assign @6.2-6.22 (ident "sum_")))))))) + (p-assign @2.13-2.18 (ident "input"))) + (e-block @2.20-8.2 + (s-let @3.2-3.13 + (p-assign @3.2-3.5 (ident "sum")) + (e-lookup-local @3.8-3.13 + (p-assign @2.13-2.18 (ident "input")))) + (s-var @4.2-4.22 + (p-assign @4.2-4.22 (ident "sum_")) + (e-binop @4.13-4.22 (op "mul") + (e-lookup-local @4.13-4.18 + (p-assign @2.13-2.18 (ident "input"))) + (e-num @4.21-4.22 (value "2")))) + (s-reassign @6.2-6.6 + (p-assign @4.2-4.22 (ident "sum_")) + (e-binop @6.9-6.19 (op "add") + (e-lookup-local @6.9-6.13 + (p-assign @4.2-4.22 (ident "sum_"))) + (e-lookup-local @6.16-6.19 + (p-assign @3.2-3.5 (ident "sum"))))) + (e-binop @7.2-7.12 (op "add") + (e-lookup-local @7.2-7.5 + (p-assign @3.2-3.5 (ident "sum"))) + (e-lookup-local @7.8-7.12 + (p-assign @4.2-4.22 (ident "sum_")))))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @4.1-4.9 (type "Num(_size) -> Num(_size2)"))) + (patt @2.1-2.9 (type "Num(_size) -> Num(_size2)"))) (expressions - (expr @4.12-10.2 (type "Num(_size) -> Num(_size2)")))) + (expr @2.12-8.2 (type "Num(_size) -> Num(_size2)")))) ~~~ diff --git a/test/snapshots/can_var_scoping_var_redeclaration.md b/test/snapshots/can_var_scoping_var_redeclaration.md index aced20f924..a2d65b4363 100644 --- a/test/snapshots/can_var_scoping_var_redeclaration.md +++ b/test/snapshots/can_var_scoping_var_redeclaration.md @@ -1,12 +1,10 @@ # META ~~~ini description=Variable scoping with var keyword -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - # Test var redeclaration (should produce shadowing warning) redeclareTest = |_| { var x_ = 5 @@ -18,20 +16,20 @@ redeclareTest = |_| { result = redeclareTest({}) ~~~ # EXPECTED -DUPLICATE DEFINITION - can_var_scoping_var_redeclaration.md:6:2:6:13 +DUPLICATE DEFINITION - can_var_scoping_var_redeclaration.md:4:2:4:13 # PROBLEMS **DUPLICATE DEFINITION** The name `x_` is being redeclared in this scope. The redeclaration is here: -**can_var_scoping_var_redeclaration.md:6:2:6:13:** +**can_var_scoping_var_redeclaration.md:4:2:4:13:** ```roc var x_ = 10 # Redeclare var - should warn but proceed ``` ^^^^^^^^^^^ But `x_` was already defined here: -**can_var_scoping_var_redeclaration.md:5:2:5:12:** +**can_var_scoping_var_redeclaration.md:3:2:3:12:** ```roc var x_ = 5 ``` @@ -40,81 +38,88 @@ But `x_` was already defined here: # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -LowerIdent(4:1-4:14),OpAssign(4:15-4:16),OpBar(4:17-4:18),Underscore(4:18-4:19),OpBar(4:19-4:20),OpenCurly(4:21-4:22), -KwVar(5:2-5:5),LowerIdent(5:6-5:8),OpAssign(5:9-5:10),Int(5:11-5:12), -KwVar(6:2-6:5),LowerIdent(6:6-6:8),OpAssign(6:9-6:10),Int(6:11-6:13), -LowerIdent(7:2-7:4),OpAssign(7:5-7:6),Int(7:7-7:9), -LowerIdent(8:2-8:4), -CloseCurly(9:1-9:2), -LowerIdent(11:1-11:7),OpAssign(11:8-11:9),LowerIdent(11:10-11:23),NoSpaceOpenRound(11:23-11:24),OpenCurly(11:24-11:25),CloseCurly(11:25-11:26),CloseRound(11:26-11:27), -EndOfFile(12:1-12:1), +LowerIdent(2:1-2:14),OpAssign(2:15-2:16),OpBar(2:17-2:18),Underscore(2:18-2:19),OpBar(2:19-2:20),OpenCurly(2:21-2:22), +KwVar(3:2-3:5),LowerIdent(3:6-3:8),OpAssign(3:9-3:10),Int(3:11-3:12), +KwVar(4:2-4:5),LowerIdent(4:6-4:8),OpAssign(4:9-4:10),Int(4:11-4:13), +LowerIdent(5:2-5:4),OpAssign(5:5-5:6),Int(5:7-5:9), +LowerIdent(6:2-6:4), +CloseCurly(7:1-7:2), +LowerIdent(9:1-9:7),OpAssign(9:8-9:9),LowerIdent(9:10-9:23),NoSpaceOpenRound(9:23-9:24),OpenCurly(9:24-9:25),CloseCurly(9:25-9:26),CloseRound(9:26-9:27), +EndOfFile(10:1-10:1), ~~~ # PARSE ~~~clojure -(file @1.1-11.27 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @2.1-9.27 + (type-module @2.1-2.14) (statements - (s-decl @4.1-9.2 - (p-ident @4.1-4.14 (raw "redeclareTest")) - (e-lambda @4.17-9.2 + (s-decl @2.1-7.2 + (p-ident @2.1-2.14 (raw "redeclareTest")) + (e-lambda @2.17-7.2 (args (p-underscore)) - (e-block @4.21-9.2 + (e-block @2.21-7.2 (statements - (s-var @5.2-5.12 (name "x_") - (e-int @5.11-5.12 (raw "5"))) - (s-var @6.2-6.13 (name "x_") - (e-int @6.11-6.13 (raw "10"))) - (s-decl @7.2-7.9 - (p-ident @7.2-7.4 (raw "x_")) - (e-int @7.7-7.9 (raw "15"))) - (e-ident @8.2-8.4 (raw "x_")))))) - (s-decl @11.1-11.27 - (p-ident @11.1-11.7 (raw "result")) - (e-apply @11.10-11.27 - (e-ident @11.10-11.23 (raw "redeclareTest")) - (e-record @11.24-11.26))))) + (s-var @3.2-3.12 (name "x_") + (e-int @3.11-3.12 (raw "5"))) + (s-var @4.2-4.13 (name "x_") + (e-int @4.11-4.13 (raw "10"))) + (s-decl @5.2-5.9 + (p-ident @5.2-5.4 (raw "x_")) + (e-int @5.7-5.9 (raw "15"))) + (e-ident @6.2-6.4 (raw "x_")))))) + (s-decl @9.1-9.27 + (p-ident @9.1-9.7 (raw "result")) + (e-apply @9.10-9.27 + (e-ident @9.10-9.23 (raw "redeclareTest")) + (e-record @9.24-9.26))))) ~~~ # FORMATTED ~~~roc -NO CHANGE +# Test var redeclaration (should produce shadowing warning) +# Test var redeclaration (should produce shadowing warning) +redeclareTest = |_| { + var x_ = 5 + var x_ = 10 # Redeclare var - should warn but proceed + x_ = 15 # Reassign - should work without warning + x_ +} + +result = redeclareTest({}) ~~~ # CANONICALIZE ~~~clojure (can-ir (d-let - (p-assign @4.1-4.14 (ident "redeclareTest")) - (e-lambda @4.17-9.2 + (p-assign @2.1-2.14 (ident "redeclareTest")) + (e-lambda @2.17-7.2 (args - (p-underscore @4.18-4.19)) - (e-block @4.21-9.2 - (s-var @5.2-5.12 - (p-assign @5.2-5.12 (ident "x_")) - (e-int @5.11-5.12 (value "5"))) - (s-var @6.2-6.13 - (p-assign @6.2-6.13 (ident "x_")) - (e-int @6.11-6.13 (value "10"))) - (s-reassign @7.2-7.4 - (p-assign @6.2-6.13 (ident "x_")) - (e-int @7.7-7.9 (value "15"))) - (e-lookup-local @8.2-8.4 - (p-assign @6.2-6.13 (ident "x_")))))) + (p-underscore @2.18-2.19)) + (e-block @2.21-7.2 + (s-var @3.2-3.12 + (p-assign @3.2-3.12 (ident "x_")) + (e-num @3.11-3.12 (value "5"))) + (s-var @4.2-4.13 + (p-assign @4.2-4.13 (ident "x_")) + (e-num @4.11-4.13 (value "10"))) + (s-reassign @5.2-5.4 + (p-assign @4.2-4.13 (ident "x_")) + (e-num @5.7-5.9 (value "15"))) + (e-lookup-local @6.2-6.4 + (p-assign @4.2-4.13 (ident "x_")))))) (d-let - (p-assign @11.1-11.7 (ident "result")) - (e-call @11.10-11.27 - (e-lookup-local @11.10-11.23 - (p-assign @4.1-4.14 (ident "redeclareTest"))) - (e-empty_record @11.24-11.26)))) + (p-assign @9.1-9.7 (ident "result")) + (e-call @9.10-9.27 + (e-lookup-local @9.10-9.23 + (p-assign @2.1-2.14 (ident "redeclareTest"))) + (e-empty_record @9.24-9.26)))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @4.1-4.14 (type "_arg -> Num(_size)")) - (patt @11.1-11.7 (type "Num(_size)"))) + (patt @2.1-2.14 (type "_arg -> Num(_size)")) + (patt @9.1-9.7 (type "Num(_size)"))) (expressions - (expr @4.17-9.2 (type "_arg -> Num(_size)")) - (expr @11.10-11.27 (type "Num(_size)")))) + (expr @2.17-7.2 (type "_arg -> Num(_size)")) + (expr @9.10-9.27 (type "Num(_size)")))) ~~~ diff --git a/test/snapshots/crash_and_ellipsis_test.md b/test/snapshots/crash_and_ellipsis_test.md index 30bf3ba1e0..5ab4b5c5db 100644 --- a/test/snapshots/crash_and_ellipsis_test.md +++ b/test/snapshots/crash_and_ellipsis_test.md @@ -208,8 +208,8 @@ main! = |_| { (annotation @5.1-5.13 (declared-type (ty-fn @4.16-4.26 (effectful false) - (ty @4.16-4.19 (name "U64")) - (ty @4.23-4.26 (name "U64")))))) + (ty-lookup @4.16-4.19 (name "U64") (builtin)) + (ty-lookup @4.23-4.26 (name "U64") (builtin)))))) (d-let (p-assign @9.1-9.10 (ident "testCrash")) (e-lambda @9.13-11.2 @@ -220,8 +220,8 @@ main! = |_| { (annotation @9.1-9.10 (declared-type (ty-fn @8.13-8.23 (effectful false) - (ty @8.13-8.16 (name "U64")) - (ty @8.20-8.23 (name "U64")))))) + (ty-lookup @8.13-8.16 (name "U64") (builtin)) + (ty-lookup @8.20-8.23 (name "U64") (builtin)))))) (d-let (p-assign @15.1-15.16 (ident "testCrashSimple")) (e-lambda @15.19-17.2 @@ -232,15 +232,15 @@ main! = |_| { (annotation @15.1-15.16 (declared-type (ty-fn @14.19-14.29 (effectful false) - (ty @14.19-14.22 (name "U64")) - (ty @14.26-14.29 (name "U64")))))) + (ty-lookup @14.19-14.22 (name "U64") (builtin)) + (ty-lookup @14.26-14.29 (name "U64") (builtin)))))) (d-let (p-assign @19.1-19.6 (ident "main!")) (e-closure @19.9-24.2 (captures + (capture @5.1-5.13 (ident "testEllipsis")) (capture @9.1-9.10 (ident "testCrash")) - (capture @15.1-15.16 (ident "testCrashSimple")) - (capture @5.1-5.13 (ident "testEllipsis"))) + (capture @15.1-15.16 (ident "testCrashSimple"))) (e-lambda @19.9-24.2 (args (p-underscore @19.10-19.11)) @@ -250,32 +250,32 @@ main! = |_| { (e-call @20.15-20.31 (e-lookup-local @20.15-20.27 (p-assign @5.1-5.13 (ident "testEllipsis"))) - (e-int @20.28-20.30 (value "42")))) + (e-num @20.28-20.30 (value "42")))) (s-let @21.5-21.28 (p-assign @21.5-21.12 (ident "result2")) (e-call @21.15-21.28 (e-lookup-local @21.15-21.24 (p-assign @9.1-9.10 (ident "testCrash"))) - (e-int @21.25-21.27 (value "42")))) + (e-num @21.25-21.27 (value "42")))) (s-let @22.5-22.34 (p-assign @22.5-22.12 (ident "result3")) (e-call @22.15-22.34 (e-lookup-local @22.15-22.30 (p-assign @15.1-15.16 (ident "testCrashSimple"))) - (e-int @22.31-22.33 (value "42")))) + (e-num @22.31-22.33 (value "42")))) (e-empty_list @23.5-23.7)))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @5.1-5.13 (type "U64 -> U64")) - (patt @9.1-9.10 (type "U64 -> U64")) - (patt @15.1-15.16 (type "U64 -> U64")) + (patt @5.1-5.13 (type "Num(Int(Unsigned64)) -> Num(Int(Unsigned64))")) + (patt @9.1-9.10 (type "Num(Int(Unsigned64)) -> Num(Int(Unsigned64))")) + (patt @15.1-15.16 (type "Num(Int(Unsigned64)) -> Num(Int(Unsigned64))")) (patt @19.1-19.6 (type "_arg -> List(_elem)"))) (expressions - (expr @5.16-5.23 (type "U64 -> U64")) - (expr @9.13-11.2 (type "U64 -> U64")) - (expr @15.19-17.2 (type "U64 -> U64")) + (expr @5.16-5.23 (type "Num(Int(Unsigned64)) -> Num(Int(Unsigned64))")) + (expr @9.13-11.2 (type "Num(Int(Unsigned64)) -> Num(Int(Unsigned64))")) + (expr @15.19-17.2 (type "Num(Int(Unsigned64)) -> Num(Int(Unsigned64))")) (expr @19.9-24.2 (type "_arg -> List(_elem)")))) ~~~ diff --git a/test/snapshots/def_simple_with_annotation.md b/test/snapshots/def_simple_with_annotation.md index 4c644c06fb..0cb47ee41f 100644 --- a/test/snapshots/def_simple_with_annotation.md +++ b/test/snapshots/def_simple_with_annotation.md @@ -1,12 +1,10 @@ # META ~~~ini description=Simple definition with type annotation -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [foo] - foo : Str foo = "one" ~~~ @@ -16,25 +14,21 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:12),CloseSquare(1:12-1:13), -LowerIdent(3:1-3:4),OpColon(3:5-3:6),UpperIdent(3:7-3:10), -LowerIdent(4:1-4:4),OpAssign(4:5-4:6),StringStart(4:7-4:8),StringPart(4:8-4:11),StringEnd(4:11-4:12), -EndOfFile(5:1-5:1), +LowerIdent(1:1-1:4),OpColon(1:5-1:6),UpperIdent(1:7-1:10), +LowerIdent(2:1-2:4),OpAssign(2:5-2:6),StringStart(2:7-2:8),StringPart(2:8-2:11),StringEnd(2:11-2:12), +EndOfFile(3:1-3:1), ~~~ # PARSE ~~~clojure -(file @1.1-4.12 - (module @1.1-1.13 - (exposes @1.8-1.13 - (exposed-lower-ident @1.9-1.12 - (text "foo")))) +(file @1.1-2.12 + (type-module @1.1-1.4) (statements - (s-type-anno @3.1-3.10 (name "foo") - (ty @3.7-3.10 (name "Str"))) - (s-decl @4.1-4.12 - (p-ident @4.1-4.4 (raw "foo")) - (e-string @4.7-4.12 - (e-string-part @4.8-4.11 (raw "one")))))) + (s-type-anno @1.1-1.10 (name "foo") + (ty @1.7-1.10 (name "Str"))) + (s-decl @2.1-2.12 + (p-ident @2.1-2.4 (raw "foo")) + (e-string @2.7-2.12 + (e-string-part @2.8-2.11 (raw "one")))))) ~~~ # FORMATTED ~~~roc @@ -44,18 +38,18 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @4.1-4.4 (ident "foo")) - (e-string @4.7-4.12 - (e-literal @4.8-4.11 (string "one"))) - (annotation @4.1-4.4 + (p-assign @2.1-2.4 (ident "foo")) + (e-string @2.7-2.12 + (e-literal @2.8-2.11 (string "one"))) + (annotation @2.1-2.4 (declared-type - (ty @3.7-3.10 (name "Str")))))) + (ty-lookup @1.7-1.10 (name "Str") (builtin)))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @4.1-4.4 (type "Str"))) + (patt @2.1-2.4 (type "Str"))) (expressions - (expr @4.7-4.12 (type "Str")))) + (expr @2.7-2.12 (type "Str")))) ~~~ diff --git a/test/snapshots/default_app_no_main.md b/test/snapshots/default_app_no_main.md new file mode 100644 index 0000000000..ad82d3f2ab --- /dev/null +++ b/test/snapshots/default_app_no_main.md @@ -0,0 +1,70 @@ +# META +~~~ini +description=Error - type module with no main! or matching type +type=file +~~~ +# SOURCE +~~~roc +helper = |x| x + 1 +~~~ +# EXPECTED +MISSING MAIN! FUNCTION - default_app_no_main.md:1:1:1:19 +# PROBLEMS +**MISSING MAIN! FUNCTION** +Default app modules must have a `main!` function. + +No `main!` function was found. + +Add a main! function like: +`main! = |arg| { ... }` +**default_app_no_main.md:1:1:1:19:** +```roc +helper = |x| x + 1 +``` +^^^^^^^^^^^^^^^^^^ + + +# TOKENS +~~~zig +LowerIdent(1:1-1:7),OpAssign(1:8-1:9),OpBar(1:10-1:11),LowerIdent(1:11-1:12),OpBar(1:12-1:13),LowerIdent(1:14-1:15),OpPlus(1:16-1:17),Int(1:18-1:19), +EndOfFile(2:1-2:1), +~~~ +# PARSE +~~~clojure +(file @1.1-1.19 + (type-module @1.1-1.7) + (statements + (s-decl @1.1-1.19 + (p-ident @1.1-1.7 (raw "helper")) + (e-lambda @1.10-1.19 + (args + (p-ident @1.11-1.12 (raw "x"))) + (e-binop @1.14-1.19 (op "+") + (e-ident @1.14-1.15 (raw "x")) + (e-int @1.18-1.19 (raw "1"))))))) +~~~ +# FORMATTED +~~~roc +NO CHANGE +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @1.1-1.7 (ident "helper")) + (e-lambda @1.10-1.19 + (args + (p-assign @1.11-1.12 (ident "x"))) + (e-binop @1.14-1.19 (op "add") + (e-lookup-local @1.14-1.15 + (p-assign @1.11-1.12 (ident "x"))) + (e-num @1.18-1.19 (value "1")))))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @1.1-1.7 (type "Num(_size) -> Num(_size2)"))) + (expressions + (expr @1.10-1.19 (type "Num(_size) -> Num(_size2)")))) +~~~ diff --git a/test/snapshots/default_app_wrong_arity.md b/test/snapshots/default_app_wrong_arity.md new file mode 100644 index 0000000000..df27864393 --- /dev/null +++ b/test/snapshots/default_app_wrong_arity.md @@ -0,0 +1,91 @@ +# META +~~~ini +description=Error - main! with wrong number of parameters +type=file +~~~ +# SOURCE +~~~roc +main! = |arg1, arg2| { + arg1 +} +~~~ +# EXPECTED +UNUSED VARIABLE - default_app_wrong_arity.md:1:16:1:20 +MAIN! SHOULD TAKE 1 ARGUMENT - default_app_wrong_arity.md:1:1:3:2 +# PROBLEMS +**UNUSED VARIABLE** +Variable `arg2` is not used anywhere in your code. + +If you don't need this variable, prefix it with an underscore like `_arg2` to suppress this warning. +The unused variable is declared here: +**default_app_wrong_arity.md:1:16:1:20:** +```roc +main! = |arg1, arg2| { +``` + ^^^^ + + +**MAIN! SHOULD TAKE 1 ARGUMENT** +`main!` is defined but has the wrong number of arguments. `main!` should take 1 argument. + +Found `2` arguments. + +Change it to: +`main! = |arg| { ... }` +**default_app_wrong_arity.md:1:1:3:2:** +```roc +main! = |arg1, arg2| { + arg1 +} +``` + + +# TOKENS +~~~zig +LowerIdent(1:1-1:6),OpAssign(1:7-1:8),OpBar(1:9-1:10),LowerIdent(1:10-1:14),Comma(1:14-1:15),LowerIdent(1:16-1:20),OpBar(1:20-1:21),OpenCurly(1:22-1:23), +LowerIdent(2:5-2:9), +CloseCurly(3:1-3:2), +EndOfFile(4:1-4:1), +~~~ +# PARSE +~~~clojure +(file @1.1-3.2 + (type-module @1.1-1.6) + (statements + (s-decl @1.1-3.2 + (p-ident @1.1-1.6 (raw "main!")) + (e-lambda @1.9-3.2 + (args + (p-ident @1.10-1.14 (raw "arg1")) + (p-ident @1.16-1.20 (raw "arg2"))) + (e-block @1.22-3.2 + (statements + (e-ident @2.5-2.9 (raw "arg1")))))))) +~~~ +# FORMATTED +~~~roc +main! = |arg1, arg2| { + arg1 +} +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @1.1-1.6 (ident "main!")) + (e-lambda @1.9-3.2 + (args + (p-assign @1.10-1.14 (ident "arg1")) + (p-assign @1.16-1.20 (ident "arg2"))) + (e-block @1.22-3.2 + (e-lookup-local @2.5-2.9 + (p-assign @1.10-1.14 (ident "arg1"))))))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @1.1-1.6 (type "a, _arg -> a"))) + (expressions + (expr @1.9-3.2 (type "a, _arg -> a")))) +~~~ diff --git a/test/snapshots/effectful_with_effectful_annotation.md b/test/snapshots/effectful_with_effectful_annotation.md index 4375ab359a..9605e2ac75 100644 --- a/test/snapshots/effectful_with_effectful_annotation.md +++ b/test/snapshots/effectful_with_effectful_annotation.md @@ -87,14 +87,14 @@ NO CHANGE (p-assign @7.15-7.18 (ident "msg"))) (e-call @7.20-7.37 (e-lookup-external @7.20-7.32 - (module-idx "0") + (module-idx "2") (target-node-idx "0")) (e-lookup-local @7.33-7.36 (p-assign @7.15-7.18 (ident "msg"))))) (annotation @7.1-7.11 (declared-type (ty-fn @6.14-6.23 (effectful true) - (ty @6.14-6.17 (name "Str")) + (ty-lookup @6.14-6.17 (name "Str") (builtin)) (ty-record @6.21-6.23))))) (d-let (p-assign @9.1-9.6 (ident "main!")) diff --git a/test/snapshots/eval/lambda_simple_application.md b/test/snapshots/eval/lambda_simple_application.md index e58c93fc60..0a2e700b3a 100644 --- a/test/snapshots/eval/lambda_simple_application.md +++ b/test/snapshots/eval/lambda_simple_application.md @@ -41,8 +41,8 @@ NO CHANGE (e-binop @1.6-1.11 (op "add") (e-lookup-local @1.6-1.7 (p-assign @1.3-1.4 (ident "x"))) - (e-int @1.10-1.11 (value "1")))) - (e-int @1.13-1.14 (value "5"))) + (e-num @1.10-1.11 (value "1")))) + (e-num @1.13-1.14 (value "5"))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/eval/mixed_destructure_closure.md b/test/snapshots/eval/mixed_destructure_closure.md index 25b5c9608c..a8c6539c33 100644 --- a/test/snapshots/eval/mixed_destructure_closure.md +++ b/test/snapshots/eval/mixed_destructure_closure.md @@ -102,19 +102,19 @@ EndOfFile(2:1-2:1), (e-record @1.53-1.88 (fields (field (name "a") - (e-int @1.58-1.59 (value "1"))) + (e-num @1.58-1.59 (value "1"))) (field (name "x") (e-tuple @1.64-1.70 (elems - (e-int @1.65-1.66 (value "2")) - (e-int @1.68-1.69 (value "3"))))) + (e-num @1.65-1.66 (value "2")) + (e-num @1.68-1.69 (value "3"))))) (field (name "y") (e-record @1.75-1.87 (fields (field (name "d") - (e-int @1.79-1.80 (value "4"))) + (e-num @1.79-1.80 (value "4"))) (field (name "e") - (e-int @1.85-1.86 (value "5"))))))))) + (e-num @1.85-1.86 (value "5"))))))))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/eval/record_argument_closure.md b/test/snapshots/eval/record_argument_closure.md index 23dd743e45..cbda54a9e8 100644 --- a/test/snapshots/eval/record_argument_closure.md +++ b/test/snapshots/eval/record_argument_closure.md @@ -59,9 +59,9 @@ NO CHANGE (e-record @1.20-1.36 (fields (field (name "x") - (e-int @1.25-1.27 (value "10"))) + (e-num @1.25-1.27 (value "10"))) (field (name "y") - (e-int @1.32-1.34 (value "20")))))) + (e-num @1.32-1.34 (value "20")))))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/eval/record_argument_closure_single.md b/test/snapshots/eval/record_argument_closure_single.md index ff8d650c92..ff44d35f9f 100644 --- a/test/snapshots/eval/record_argument_closure_single.md +++ b/test/snapshots/eval/record_argument_closure_single.md @@ -48,9 +48,9 @@ EndOfFile(2:1-2:1), (e-record @1.14-1.24 (fields (field (name "x") - (e-int @1.19-1.22 (value "-10")))))) + (e-num @1.19-1.22 (value "-10")))))) ~~~ # TYPES ~~~clojure -(expr @1.1-1.25 (type "_a")) +(expr @1.1-1.25 (type "Num(_size)")) ~~~ diff --git a/test/snapshots/eval/simple_add.md b/test/snapshots/eval/simple_add.md index 83cc93c16a..d6d3fb7a93 100644 --- a/test/snapshots/eval/simple_add.md +++ b/test/snapshots/eval/simple_add.md @@ -1,12 +1,10 @@ # META ~~~ini description=Simple addition function with expect statement -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [addU8] - addU8 : U8, U8 -> U8 addU8 = |a, b| a + b @@ -19,49 +17,45 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:14),CloseSquare(1:14-1:15), -LowerIdent(3:1-3:6),OpColon(3:7-3:8),UpperIdent(3:9-3:11),Comma(3:11-3:12),UpperIdent(3:13-3:15),OpArrow(3:16-3:18),UpperIdent(3:19-3:21), -LowerIdent(4:1-4:6),OpAssign(4:7-4:8),OpBar(4:9-4:10),LowerIdent(4:10-4:11),Comma(4:11-4:12),LowerIdent(4:13-4:14),OpBar(4:14-4:15),LowerIdent(4:16-4:17),OpPlus(4:18-4:19),LowerIdent(4:20-4:21), -KwExpect(6:1-6:7),LowerIdent(6:8-6:13),NoSpaceOpenRound(6:13-6:14),Int(6:14-6:15),Comma(6:15-6:16),Int(6:17-6:18),CloseRound(6:18-6:19),OpEquals(6:20-6:22),Int(6:23-6:24), -KwExpect(7:1-7:7),LowerIdent(7:8-7:13),NoSpaceOpenRound(7:13-7:14),Int(7:14-7:15),Comma(7:15-7:16),Int(7:17-7:19),CloseRound(7:19-7:20),OpEquals(7:21-7:23),Int(7:24-7:26), -EndOfFile(8:1-8:1), +LowerIdent(1:1-1:6),OpColon(1:7-1:8),UpperIdent(1:9-1:11),Comma(1:11-1:12),UpperIdent(1:13-1:15),OpArrow(1:16-1:18),UpperIdent(1:19-1:21), +LowerIdent(2:1-2:6),OpAssign(2:7-2:8),OpBar(2:9-2:10),LowerIdent(2:10-2:11),Comma(2:11-2:12),LowerIdent(2:13-2:14),OpBar(2:14-2:15),LowerIdent(2:16-2:17),OpPlus(2:18-2:19),LowerIdent(2:20-2:21), +KwExpect(4:1-4:7),LowerIdent(4:8-4:13),NoSpaceOpenRound(4:13-4:14),Int(4:14-4:15),Comma(4:15-4:16),Int(4:17-4:18),CloseRound(4:18-4:19),OpEquals(4:20-4:22),Int(4:23-4:24), +KwExpect(5:1-5:7),LowerIdent(5:8-5:13),NoSpaceOpenRound(5:13-5:14),Int(5:14-5:15),Comma(5:15-5:16),Int(5:17-5:19),CloseRound(5:19-5:20),OpEquals(5:21-5:23),Int(5:24-5:26), +EndOfFile(6:1-6:1), ~~~ # PARSE ~~~clojure -(file @1.1-7.26 - (module @1.1-1.15 - (exposes @1.8-1.15 - (exposed-lower-ident @1.9-1.14 - (text "addU8")))) +(file @1.1-5.26 + (type-module @1.1-1.6) (statements - (s-type-anno @3.1-3.21 (name "addU8") - (ty-fn @3.9-3.21 - (ty @3.9-3.11 (name "U8")) - (ty @3.13-3.15 (name "U8")) - (ty @3.19-3.21 (name "U8")))) - (s-decl @4.1-4.21 - (p-ident @4.1-4.6 (raw "addU8")) - (e-lambda @4.9-4.21 + (s-type-anno @1.1-1.21 (name "addU8") + (ty-fn @1.9-1.21 + (ty @1.9-1.11 (name "U8")) + (ty @1.13-1.15 (name "U8")) + (ty @1.19-1.21 (name "U8")))) + (s-decl @2.1-2.21 + (p-ident @2.1-2.6 (raw "addU8")) + (e-lambda @2.9-2.21 (args - (p-ident @4.10-4.11 (raw "a")) - (p-ident @4.13-4.14 (raw "b"))) - (e-binop @4.16-4.21 (op "+") - (e-ident @4.16-4.17 (raw "a")) - (e-ident @4.20-4.21 (raw "b"))))) - (s-expect @6.1-6.24 - (e-binop @6.8-6.24 (op "==") - (e-apply @6.8-6.19 - (e-ident @6.8-6.13 (raw "addU8")) - (e-int @6.14-6.15 (raw "1")) - (e-int @6.17-6.18 (raw "2"))) - (e-int @6.23-6.24 (raw "3")))) - (s-expect @7.1-7.26 - (e-binop @7.8-7.26 (op "==") - (e-apply @7.8-7.20 - (e-ident @7.8-7.13 (raw "addU8")) - (e-int @7.14-7.15 (raw "0")) - (e-int @7.17-7.19 (raw "10"))) - (e-int @7.24-7.26 (raw "10")))))) + (p-ident @2.10-2.11 (raw "a")) + (p-ident @2.13-2.14 (raw "b"))) + (e-binop @2.16-2.21 (op "+") + (e-ident @2.16-2.17 (raw "a")) + (e-ident @2.20-2.21 (raw "b"))))) + (s-expect @4.1-4.24 + (e-binop @4.8-4.24 (op "==") + (e-apply @4.8-4.19 + (e-ident @4.8-4.13 (raw "addU8")) + (e-int @4.14-4.15 (raw "1")) + (e-int @4.17-4.18 (raw "2"))) + (e-int @4.23-4.24 (raw "3")))) + (s-expect @5.1-5.26 + (e-binop @5.8-5.26 (op "==") + (e-apply @5.8-5.20 + (e-ident @5.8-5.13 (raw "addU8")) + (e-int @5.14-5.15 (raw "0")) + (e-int @5.17-5.19 (raw "10"))) + (e-int @5.24-5.26 (raw "10")))))) ~~~ # FORMATTED ~~~roc @@ -71,44 +65,44 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @4.1-4.6 (ident "addU8")) - (e-lambda @4.9-4.21 + (p-assign @2.1-2.6 (ident "addU8")) + (e-lambda @2.9-2.21 (args - (p-assign @4.10-4.11 (ident "a")) - (p-assign @4.13-4.14 (ident "b"))) - (e-binop @4.16-4.21 (op "add") - (e-lookup-local @4.16-4.17 - (p-assign @4.10-4.11 (ident "a"))) - (e-lookup-local @4.20-4.21 - (p-assign @4.13-4.14 (ident "b"))))) - (annotation @4.1-4.6 + (p-assign @2.10-2.11 (ident "a")) + (p-assign @2.13-2.14 (ident "b"))) + (e-binop @2.16-2.21 (op "add") + (e-lookup-local @2.16-2.17 + (p-assign @2.10-2.11 (ident "a"))) + (e-lookup-local @2.20-2.21 + (p-assign @2.13-2.14 (ident "b"))))) + (annotation @2.1-2.6 (declared-type - (ty-fn @3.9-3.21 (effectful false) - (ty @3.9-3.11 (name "U8")) - (ty @3.13-3.15 (name "U8")) - (ty @3.19-3.21 (name "U8")))))) - (s-expect @6.1-6.24 - (e-binop @6.8-6.24 (op "eq") - (e-call @6.8-6.19 - (e-lookup-local @6.8-6.13 - (p-assign @4.1-4.6 (ident "addU8"))) - (e-int @6.14-6.15 (value "1")) - (e-int @6.17-6.18 (value "2"))) - (e-int @6.23-6.24 (value "3")))) - (s-expect @7.1-7.26 - (e-binop @7.8-7.26 (op "eq") - (e-call @7.8-7.20 - (e-lookup-local @7.8-7.13 - (p-assign @4.1-4.6 (ident "addU8"))) - (e-int @7.14-7.15 (value "0")) - (e-int @7.17-7.19 (value "10"))) - (e-int @7.24-7.26 (value "10"))))) + (ty-fn @1.9-1.21 (effectful false) + (ty-lookup @1.9-1.11 (name "U8") (builtin)) + (ty-lookup @1.13-1.15 (name "U8") (builtin)) + (ty-lookup @1.19-1.21 (name "U8") (builtin)))))) + (s-expect @4.1-4.24 + (e-binop @4.8-4.24 (op "eq") + (e-call @4.8-4.19 + (e-lookup-local @4.8-4.13 + (p-assign @2.1-2.6 (ident "addU8"))) + (e-num @4.14-4.15 (value "1")) + (e-num @4.17-4.18 (value "2"))) + (e-num @4.23-4.24 (value "3")))) + (s-expect @5.1-5.26 + (e-binop @5.8-5.26 (op "eq") + (e-call @5.8-5.20 + (e-lookup-local @5.8-5.13 + (p-assign @2.1-2.6 (ident "addU8"))) + (e-num @5.14-5.15 (value "0")) + (e-num @5.17-5.19 (value "10"))) + (e-num @5.24-5.26 (value "10"))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @4.1-4.6 (type "U8, U8 -> U8"))) + (patt @2.1-2.6 (type "Num(Int(Unsigned8)), Num(Int(Unsigned8)) -> Num(Int(Unsigned8))"))) (expressions - (expr @4.9-4.21 (type "U8, U8 -> U8")))) + (expr @2.9-2.21 (type "Num(Int(Unsigned8)), Num(Int(Unsigned8)) -> Num(Int(Unsigned8))")))) ~~~ diff --git a/test/snapshots/eval/tuple_argument_closure.md b/test/snapshots/eval/tuple_argument_closure.md index 31ba9086f7..459d9d0115 100644 --- a/test/snapshots/eval/tuple_argument_closure.md +++ b/test/snapshots/eval/tuple_argument_closure.md @@ -52,8 +52,8 @@ EndOfFile(2:1-2:1), (p-assign @1.6-1.7 (ident "y"))))) (e-tuple @1.18-1.23 (elems - (e-int @1.19-1.20 (value "1")) - (e-int @1.21-1.22 (value "2"))))) + (e-num @1.19-1.20 (value "1")) + (e-num @1.21-1.22 (value "2"))))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/eval/tuple_bool.md b/test/snapshots/eval/tuple_bool.md index 702daa348e..629de77153 100644 --- a/test/snapshots/eval/tuple_bool.md +++ b/test/snapshots/eval/tuple_bool.md @@ -73,5 +73,5 @@ NO CHANGE ~~~ # TYPES ~~~clojure -(expr @1.1-1.84 (type "(Bool, Bool, Bool, Bool, Bool, Bool, _field, _field2)")) +(expr @1.1-1.84 (type "(Bool, Bool, Bool, Bool, Bool, Bool, Bool, Bool)")) ~~~ diff --git a/test/snapshots/eval/tuple_numbers.md b/test/snapshots/eval/tuple_numbers.md index e80744f8f4..7958f3c4bf 100644 --- a/test/snapshots/eval/tuple_numbers.md +++ b/test/snapshots/eval/tuple_numbers.md @@ -55,28 +55,28 @@ NO CHANGE ~~~clojure (e-tuple @1.1-1.184 (elems - (e-int @1.2-1.5 (value "1")) - (e-int @1.7-1.10 (value "2")) - (e-int @1.12-1.16 (value "3")) - (e-int @1.18-1.22 (value "4")) - (e-int @1.24-1.28 (value "5")) - (e-int @1.30-1.34 (value "6")) - (e-int @1.36-1.40 (value "7")) - (e-int @1.42-1.46 (value "8")) - (e-int @1.48-1.53 (value "9")) - (e-int @1.55-1.61 (value "10")) + (e-num @1.2-1.5 (value "1")) + (e-num @1.7-1.10 (value "2")) + (e-num @1.12-1.16 (value "3")) + (e-num @1.18-1.22 (value "4")) + (e-num @1.24-1.28 (value "5")) + (e-num @1.30-1.34 (value "6")) + (e-num @1.36-1.40 (value "7")) + (e-num @1.42-1.46 (value "8")) + (e-num @1.48-1.53 (value "9")) + (e-num @1.55-1.61 (value "10")) (e-frac-f32 @1.63-1.70 (value "11")) (e-frac-f64 @1.72-1.79 (value "12")) (e-frac-dec @1.81-1.88 (value "13")) - (e-int @1.90-1.93 (value "14")) - (e-int @1.95-1.98 (value "15")) - (e-int @1.100-1.104 (value "32")) - (e-int @1.106-1.113 (value "17")) - (e-int @1.115-1.123 (value "18")) - (e-int @1.125-1.127 (value "19")) + (e-num @1.90-1.93 (value "14")) + (e-num @1.95-1.98 (value "15")) + (e-num @1.100-1.104 (value "32")) + (e-num @1.106-1.113 (value "17")) + (e-num @1.115-1.123 (value "18")) + (e-num @1.125-1.127 (value "19")) (e-dec-small @1.129-1.133 (numerator "200") (denominator-power-of-ten "1") (value "20")) - (e-int @1.135-1.141 (value "21000")) - (e-int @1.143-1.153 (value "22000000")) + (e-num @1.135-1.141 (value "21000")) + (e-num @1.143-1.153 (value "22000000")) (e-dec-small @1.155-1.158 (numerator "0") (denominator-power-of-ten "1") (value "0.0")) (e-dec-small @1.160-1.164 (numerator "-1") (denominator-power-of-ten "1") (value "-0.1")) (e-dec-small @1.166-1.169 (numerator "20000") (denominator-power-of-ten "0") (value "20000")) @@ -85,5 +85,5 @@ NO CHANGE ~~~ # TYPES ~~~clojure -(expr @1.1-1.184 (type "(U8, I8, U16, I16, U32, I32, U64, I64, U128, I128, F32, F64, Dec, Int(_size), Int(_size2), Int(_size3), Int(_size4), Int(_size5), Num(_size6), Frac(_size7), Num(_size8), Num(_size9), Frac(_size10), Frac(_size11), Frac(_size12), Frac(_size13), Frac(_size14))")) +(expr @1.1-1.184 (type "(Num(Int(Unsigned8)), Num(Int(Signed8)), Num(Int(Unsigned16)), Num(Int(Signed16)), Num(Int(Unsigned32)), Num(Int(Signed32)), Num(Int(Unsigned64)), Num(Int(Signed64)), Num(Int(Unsigned128)), Num(Int(Signed128)), Num(Frac(Float32)), Num(Frac(Float64)), Num(Frac(Decimal)), Num(Int(_size)), Num(Int(_size2)), Num(Int(_size3)), Num(Int(_size4)), Num(Int(_size5)), Num(_size6), Num(Frac(_size7)), Num(_size8), Num(_size9), Num(Frac(_size10)), Num(Frac(_size11)), Num(Frac(_size12)), Num(Frac(_size13)), Num(Frac(_size14)))")) ~~~ diff --git a/test/snapshots/exposed_items_test.md b/test/snapshots/exposed_items_test.md index b34c8b51e8..36cad01c60 100644 --- a/test/snapshots/exposed_items_test.md +++ b/test/snapshots/exposed_items_test.md @@ -1,24 +1,22 @@ # META ~~~ini description=Import with exposing syntax test -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [main] - import pf.Stdout exposing [line!, write!] main = 42 ~~~ # EXPECTED -MODULE NOT FOUND - exposed_items_test.md:3:1:3:42 +MODULE NOT FOUND - exposed_items_test.md:1:1:1:42 # PROBLEMS **MODULE NOT FOUND** The module `pf.Stdout` was not found in this Roc project. You're attempting to use this module here: -**exposed_items_test.md:3:1:3:42:** +**exposed_items_test.md:1:1:1:42:** ```roc import pf.Stdout exposing [line!, write!] ``` @@ -27,28 +25,24 @@ import pf.Stdout exposing [line!, write!] # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:13),CloseSquare(1:13-1:14), -KwImport(3:1-3:7),LowerIdent(3:8-3:10),NoSpaceDotUpperIdent(3:10-3:17),KwExposing(3:18-3:26),OpenSquare(3:27-3:28),LowerIdent(3:28-3:33),Comma(3:33-3:34),LowerIdent(3:35-3:41),CloseSquare(3:41-3:42), -LowerIdent(5:1-5:5),OpAssign(5:6-5:7),Int(5:8-5:10), -EndOfFile(6:1-6:1), +KwImport(1:1-1:7),LowerIdent(1:8-1:10),NoSpaceDotUpperIdent(1:10-1:17),KwExposing(1:18-1:26),OpenSquare(1:27-1:28),LowerIdent(1:28-1:33),Comma(1:33-1:34),LowerIdent(1:35-1:41),CloseSquare(1:41-1:42), +LowerIdent(3:1-3:5),OpAssign(3:6-3:7),Int(3:8-3:10), +EndOfFile(4:1-4:1), ~~~ # PARSE ~~~clojure -(file @1.1-5.10 - (module @1.1-1.14 - (exposes @1.8-1.14 - (exposed-lower-ident @1.9-1.13 - (text "main")))) +(file @1.1-3.10 + (type-module @1.1-1.7) (statements - (s-import @3.1-3.42 (raw "pf.Stdout") + (s-import @1.1-1.42 (raw "pf.Stdout") (exposing - (exposed-lower-ident @3.28-3.33 + (exposed-lower-ident @1.28-1.33 (text "line!")) - (exposed-lower-ident @3.35-3.41 + (exposed-lower-ident @1.35-1.41 (text "write!")))) - (s-decl @5.1-5.10 - (p-ident @5.1-5.5 (raw "main")) - (e-int @5.8-5.10 (raw "42"))))) + (s-decl @3.1-3.10 + (p-ident @3.1-3.5 (raw "main")) + (e-int @3.8-3.10 (raw "42"))))) ~~~ # FORMATTED ~~~roc @@ -58,9 +52,9 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @5.1-5.5 (ident "main")) - (e-int @5.8-5.10 (value "42"))) - (s-import @3.1-3.42 (module "pf.Stdout") (qualifier "pf") + (p-assign @3.1-3.5 (ident "main")) + (e-num @3.8-3.10 (value "42"))) + (s-import @1.1-1.42 (module "pf.Stdout") (qualifier "pf") (exposes (exposed (name "line!") (wildcard false)) (exposed (name "write!") (wildcard false))))) @@ -69,7 +63,7 @@ NO CHANGE ~~~clojure (inferred-types (defs - (patt @5.1-5.5 (type "Num(_size)"))) + (patt @3.1-3.5 (type "Num(_size)"))) (expressions - (expr @5.8-5.10 (type "Num(_size)")))) + (expr @3.8-3.10 (type "Num(_size)")))) ~~~ diff --git a/test/snapshots/expr/ann_closed_union.md b/test/snapshots/expr/ann_closed_union.md index ed2456cf46..b999e933e5 100644 --- a/test/snapshots/expr/ann_closed_union.md +++ b/test/snapshots/expr/ann_closed_union.md @@ -48,11 +48,6 @@ NO CHANGE # CANONICALIZE ~~~clojure (e-block @1.1-6.2 - (s-type-anno @2.2-2.32 (name "apple") - (ty-tag-union @2.10-2.32 - (ty @2.11-2.16 (name "Apple")) - (ty-apply @2.18-2.31 (symbol "IsFruit") - (ty @2.26-2.30 (name "Bool"))))) (s-let @3.2-3.15 (p-assign @3.2-3.7 (ident "apple")) (e-tag @3.10-3.15 (name "Apple"))) diff --git a/test/snapshots/expr/ann_effectful_fn.md b/test/snapshots/expr/ann_effectful_fn.md index 76d265aeb8..8b2ea01e88 100644 --- a/test/snapshots/expr/ann_effectful_fn.md +++ b/test/snapshots/expr/ann_effectful_fn.md @@ -59,10 +59,6 @@ EndOfFile(7:1-7:1), # CANONICALIZE ~~~clojure (e-block @1.1-6.2 - (s-type-anno @2.5-2.34 (name "launchTheNukes") - (ty-fn @2.22-2.34 (effectful true) - (ty-record @2.22-2.24) - (ty @2.28-2.34 (name "Result")))) (s-expr @2.35-2.39 (e-tag @2.35-2.39 (name "Bool"))) (s-expr @2.40-2.53 diff --git a/test/snapshots/expr/apply_function.md b/test/snapshots/expr/apply_function.md index efdd0a75a3..51f879f485 100644 --- a/test/snapshots/expr/apply_function.md +++ b/test/snapshots/expr/apply_function.md @@ -42,7 +42,7 @@ NO CHANGE ~~~clojure (e-call @1.1-1.17 (e-runtime-error (tag "ident_not_in_scope")) - (e-int @1.5-1.7 (value "42")) + (e-num @1.5-1.7 (value "42")) (e-string @1.9-1.16 (e-literal @1.10-1.15 (string "hello")))) ~~~ diff --git a/test/snapshots/expr/binop_simple_add.md b/test/snapshots/expr/binop_simple_add.md index 99f273b7e3..9eab101212 100644 --- a/test/snapshots/expr/binop_simple_add.md +++ b/test/snapshots/expr/binop_simple_add.md @@ -29,8 +29,8 @@ NO CHANGE # CANONICALIZE ~~~clojure (e-binop @1.1-1.6 (op "add") - (e-int @1.1-1.2 (value "1")) - (e-int @1.5-1.6 (value "2"))) + (e-num @1.1-1.2 (value "1")) + (e-num @1.5-1.6 (value "2"))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/expr/block_defs_simple.md b/test/snapshots/expr/block_defs_simple.md index 6b412e42eb..6ee6344f16 100644 --- a/test/snapshots/expr/block_defs_simple.md +++ b/test/snapshots/expr/block_defs_simple.md @@ -53,17 +53,17 @@ EndOfFile(6:1-6:1), (e-block @1.1-5.2 (s-let @2.5-2.11 (p-assign @2.5-2.6 (ident "x")) - (e-int @2.9-2.11 (value "42"))) + (e-num @2.9-2.11 (value "42"))) (s-let @3.5-3.14 (p-assign @3.5-3.6 (ident "y")) (e-binop @3.9-3.14 (op "add") (e-lookup-local @3.9-3.10 (p-assign @2.5-2.6 (ident "x"))) - (e-int @3.13-3.14 (value "1")))) + (e-num @3.13-3.14 (value "1")))) (e-binop @4.5-4.10 (op "mul") (e-lookup-local @4.5-4.6 (p-assign @3.5-3.6 (ident "y"))) - (e-int @4.9-4.10 (value "2")))) + (e-num @4.9-4.10 (value "2")))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/expr/block_pattern_unify.md b/test/snapshots/expr/block_pattern_unify.md index 845a628727..c53ea4a821 100644 --- a/test/snapshots/expr/block_pattern_unify.md +++ b/test/snapshots/expr/block_pattern_unify.md @@ -69,7 +69,7 @@ EndOfFile(7:1-7:1), (e-block @1.1-6.2 (s-let @2.5-2.11 (p-assign @2.5-2.6 (ident "x")) - (e-int @2.9-2.11 (value "42"))) + (e-num @2.9-2.11 (value "42"))) (s-let @3.5-3.18 (p-assign @3.5-3.8 (ident "str")) (e-string @3.11-3.18 @@ -79,7 +79,7 @@ EndOfFile(7:1-7:1), (e-binop @4.14-4.19 (op "add") (e-lookup-local @4.14-4.15 (p-assign @2.5-2.6 (ident "x"))) - (e-int @4.18-4.19 (value "5")))) + (e-num @4.18-4.19 (value "5")))) (e-lookup-local @5.5-5.11 (p-assign @4.5-4.11 (ident "result")))) ~~~ diff --git a/test/snapshots/expr/float_negative.md b/test/snapshots/expr/float_negative.md index d3c770bf12..46fe886c59 100644 --- a/test/snapshots/expr/float_negative.md +++ b/test/snapshots/expr/float_negative.md @@ -30,5 +30,5 @@ NO CHANGE ~~~ # TYPES ~~~clojure -(expr @1.1-1.5 (type "Frac(_size)")) +(expr @1.1-1.5 (type "Num(Frac(_size))")) ~~~ diff --git a/test/snapshots/expr/float_scientific.md b/test/snapshots/expr/float_scientific.md index 4d79be6e98..72f35bfa2b 100644 --- a/test/snapshots/expr/float_scientific.md +++ b/test/snapshots/expr/float_scientific.md @@ -30,5 +30,5 @@ NO CHANGE ~~~ # TYPES ~~~clojure -(expr @1.1-1.8 (type "Frac(_size)")) +(expr @1.1-1.8 (type "Num(Frac(_size))")) ~~~ diff --git a/test/snapshots/expr/float_simple.md b/test/snapshots/expr/float_simple.md index a7d3a18edf..7794c027ab 100644 --- a/test/snapshots/expr/float_simple.md +++ b/test/snapshots/expr/float_simple.md @@ -30,5 +30,5 @@ NO CHANGE ~~~ # TYPES ~~~clojure -(expr @1.1-1.5 (type "Frac(_size)")) +(expr @1.1-1.5 (type "Num(Frac(_size))")) ~~~ diff --git a/test/snapshots/expr/function_call.md b/test/snapshots/expr/function_call.md index 9274b45518..3cf6e5d083 100644 --- a/test/snapshots/expr/function_call.md +++ b/test/snapshots/expr/function_call.md @@ -41,8 +41,8 @@ NO CHANGE ~~~clojure (e-call @1.1-1.10 (e-runtime-error (tag "ident_not_in_scope")) - (e-int @1.5-1.6 (value "5")) - (e-int @1.8-1.9 (value "3"))) + (e-num @1.5-1.6 (value "5")) + (e-num @1.8-1.9 (value "3"))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/expr/if_expression.md b/test/snapshots/expr/if_expression.md index ce3e482c1c..dea4d03484 100644 --- a/test/snapshots/expr/if_expression.md +++ b/test/snapshots/expr/if_expression.md @@ -48,7 +48,7 @@ NO CHANGE (if-branch (e-binop @1.4-1.9 (op "gt") (e-runtime-error (tag "ident_not_in_scope")) - (e-int @1.8-1.9 (value "5"))) + (e-num @1.8-1.9 (value "5"))) (e-string @1.10-1.15 (e-literal @1.11-1.14 (string "big"))))) (if-else diff --git a/test/snapshots/expr/if_numeric_comparison.md b/test/snapshots/expr/if_numeric_comparison.md index 510f022fd1..bcede04bab 100644 --- a/test/snapshots/expr/if_numeric_comparison.md +++ b/test/snapshots/expr/if_numeric_comparison.md @@ -35,11 +35,11 @@ NO CHANGE (if-branches (if-branch (e-binop @1.4-1.9 (op "gt") - (e-int @1.4-1.5 (value "5")) - (e-int @1.8-1.9 (value "3"))) - (e-int @1.10-1.11 (value "1")))) + (e-num @1.4-1.5 (value "5")) + (e-num @1.8-1.9 (value "3"))) + (e-num @1.10-1.11 (value "1")))) (if-else - (e-int @1.17-1.18 (value "2")))) + (e-num @1.17-1.18 (value "2")))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/expr/if_true_literal.md b/test/snapshots/expr/if_true_literal.md index e2aec3873c..2247763a64 100644 --- a/test/snapshots/expr/if_true_literal.md +++ b/test/snapshots/expr/if_true_literal.md @@ -34,9 +34,9 @@ NO CHANGE (if-branch (e-nominal @1.4-1.8 (nominal "Bool") (e-tag @1.4-1.8 (name "True"))) - (e-int @1.9-1.10 (value "1")))) + (e-num @1.9-1.10 (value "1")))) (if-else - (e-int @1.16-1.17 (value "2")))) + (e-num @1.16-1.17 (value "2")))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/expr/int_hex.md b/test/snapshots/expr/int_hex.md index bbb7d79c60..89d18907e2 100644 --- a/test/snapshots/expr/int_hex.md +++ b/test/snapshots/expr/int_hex.md @@ -26,9 +26,9 @@ NO CHANGE ~~~ # CANONICALIZE ~~~clojure -(e-int @1.1-1.5 (value "255")) +(e-num @1.1-1.5 (value "255")) ~~~ # TYPES ~~~clojure -(expr @1.1-1.5 (type "Int(_size)")) +(expr @1.1-1.5 (type "Num(Int(_size))")) ~~~ diff --git a/test/snapshots/expr/int_large.md b/test/snapshots/expr/int_large.md index bd955b67ea..c6038a2943 100644 --- a/test/snapshots/expr/int_large.md +++ b/test/snapshots/expr/int_large.md @@ -26,7 +26,7 @@ NO CHANGE ~~~ # CANONICALIZE ~~~clojure -(e-int @1.1-1.31 (value "999999999999999999999999999999")) +(e-num @1.1-1.31 (value "999999999999999999999999999999")) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/expr/int_with_underscores.md b/test/snapshots/expr/int_with_underscores.md index 22fa517610..83b5a463fb 100644 --- a/test/snapshots/expr/int_with_underscores.md +++ b/test/snapshots/expr/int_with_underscores.md @@ -26,7 +26,7 @@ NO CHANGE ~~~ # CANONICALIZE ~~~clojure -(e-int @1.1-1.10 (value "1000000")) +(e-num @1.1-1.10 (value "1000000")) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/expr/lambda_simple.md b/test/snapshots/expr/lambda_simple.md index 6cfa94ce5b..273bf59f0b 100644 --- a/test/snapshots/expr/lambda_simple.md +++ b/test/snapshots/expr/lambda_simple.md @@ -37,7 +37,7 @@ NO CHANGE (e-binop @1.5-1.10 (op "add") (e-lookup-local @1.5-1.6 (p-assign @1.2-1.3 (ident "x"))) - (e-int @1.9-1.10 (value "1")))) + (e-num @1.9-1.10 (value "1")))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/expr/list_integers.md b/test/snapshots/expr/list_integers.md index 2efdfa390c..c31417eeab 100644 --- a/test/snapshots/expr/list_integers.md +++ b/test/snapshots/expr/list_integers.md @@ -31,9 +31,9 @@ NO CHANGE ~~~clojure (e-list @1.1-1.10 (elems - (e-int @1.2-1.3 (value "1")) - (e-int @1.5-1.6 (value "2")) - (e-int @1.8-1.9 (value "3")))) + (e-num @1.2-1.3 (value "1")) + (e-num @1.5-1.6 (value "2")) + (e-num @1.8-1.9 (value "3")))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/expr/list_nested.md b/test/snapshots/expr/list_nested.md index 7b89609f75..e5f005b6cb 100644 --- a/test/snapshots/expr/list_nested.md +++ b/test/snapshots/expr/list_nested.md @@ -38,15 +38,15 @@ NO CHANGE (elems (e-list @1.2-1.8 (elems - (e-int @1.3-1.4 (value "1")) - (e-int @1.6-1.7 (value "2")))) + (e-num @1.3-1.4 (value "1")) + (e-num @1.6-1.7 (value "2")))) (e-list @1.10-1.16 (elems - (e-int @1.11-1.12 (value "3")) - (e-int @1.14-1.15 (value "4")))) + (e-num @1.11-1.12 (value "3")) + (e-num @1.14-1.15 (value "4")))) (e-list @1.18-1.21 (elems - (e-int @1.19-1.20 (value "5")))))) + (e-num @1.19-1.20 (value "5")))))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/expr/list_type_err.md b/test/snapshots/expr/list_type_err.md index ade06b7558..f769a06322 100644 --- a/test/snapshots/expr/list_type_err.md +++ b/test/snapshots/expr/list_type_err.md @@ -50,8 +50,8 @@ NO CHANGE ~~~clojure (e-list @1.1-1.16 (elems - (e-int @1.2-1.3 (value "1")) - (e-int @1.5-1.6 (value "2")) + (e-num @1.2-1.3 (value "1")) + (e-num @1.5-1.6 (value "2")) (e-string @1.8-1.15 (e-literal @1.9-1.14 (string "hello"))))) ~~~ diff --git a/test/snapshots/expr/min_parens_number.md b/test/snapshots/expr/min_parens_number.md index 16aea0a6c7..9c8b684db4 100644 --- a/test/snapshots/expr/min_parens_number.md +++ b/test/snapshots/expr/min_parens_number.md @@ -29,7 +29,7 @@ NO CHANGE # CANONICALIZE ~~~clojure (e-unary-minus @1.1-1.5 - (e-int @1.3-1.4 (value "8"))) + (e-num @1.3-1.4 (value "8"))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/expr/not_tag.md b/test/snapshots/expr/not_tag.md index b44cb41081..1540490671 100644 --- a/test/snapshots/expr/not_tag.md +++ b/test/snapshots/expr/not_tag.md @@ -8,22 +8,22 @@ type=expr !(C(2)) ~~~ # EXPECTED -TYPE MISMATCH - not_tag.md:1:1:1:8 +TYPE MISMATCH - not_tag.md:1:3:1:7 # PROBLEMS **TYPE MISMATCH** This expression is used in an unexpected way: -**not_tag.md:1:1:1:8:** +**not_tag.md:1:3:1:7:** ```roc !(C(2)) ``` -^^^^^^^ + ^^^^ It has the type: - _Bool_ - -But here it's being used as: _[C(Num(_size))]_others_ +But I expected it to be: + _Bool_ + # TOKENS ~~~zig OpBang(1:1-1:2),NoSpaceOpenRound(1:2-1:3),UpperIdent(1:3-1:4),NoSpaceOpenRound(1:4-1:5),Int(1:5-1:6),CloseRound(1:6-1:7),CloseRound(1:7-1:8), @@ -46,7 +46,7 @@ NO CHANGE (e-unary-not @1.1-1.8 (e-tag @1.3-1.7 (name "C") (args - (e-int @1.5-1.6 (value "2"))))) + (e-num @1.5-1.6 (value "2"))))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/expr/num_bang_amp_z_dot_t.md b/test/snapshots/expr/num_bang_amp_z_dot_t.md index 30f0e43732..7592948548 100644 --- a/test/snapshots/expr/num_bang_amp_z_dot_t.md +++ b/test/snapshots/expr/num_bang_amp_z_dot_t.md @@ -30,7 +30,7 @@ EndOfFile(4:1-4:1), ~~~ # CANONICALIZE ~~~clojure -(e-int @1.1-1.2 (value "4")) +(e-num @1.1-1.2 (value "4")) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/expr/number_literal_suffixes.md b/test/snapshots/expr/number_literal_suffixes.md index 100acae9eb..b4491dff4d 100644 --- a/test/snapshots/expr/number_literal_suffixes.md +++ b/test/snapshots/expr/number_literal_suffixes.md @@ -192,71 +192,71 @@ EndOfFile(35:1-35:1), (e-record @1.1-34.2 (fields (field (name "u8") - (e-int @2.9-2.14 (value "123"))) + (e-num @2.9-2.14 (value "123"))) (field (name "u16") - (e-int @3.9-3.15 (value "123"))) + (e-num @3.9-3.15 (value "123"))) (field (name "u32") - (e-int @4.9-4.15 (value "123"))) + (e-num @4.9-4.15 (value "123"))) (field (name "u64") - (e-int @5.9-5.15 (value "123"))) + (e-num @5.9-5.15 (value "123"))) (field (name "u128") - (e-int @6.9-6.16 (value "123"))) + (e-num @6.9-6.16 (value "123"))) (field (name "i8") - (e-int @7.9-7.14 (value "123"))) + (e-num @7.9-7.14 (value "123"))) (field (name "i16") - (e-int @8.9-8.15 (value "123"))) + (e-num @8.9-8.15 (value "123"))) (field (name "i32") - (e-int @9.9-9.15 (value "123"))) + (e-num @9.9-9.15 (value "123"))) (field (name "i64") - (e-int @10.9-10.15 (value "123"))) + (e-num @10.9-10.15 (value "123"))) (field (name "i128") - (e-int @11.9-11.16 (value "123"))) + (e-num @11.9-11.16 (value "123"))) (field (name "dec") - (e-int @12.9-12.15 (value "123"))) + (e-num @12.9-12.15 (value "123"))) (field (name "u8Neg") - (e-int @13.12-13.18 (value "-123"))) + (e-num @13.12-13.18 (value "-123"))) (field (name "u16Neg") - (e-int @14.12-14.19 (value "-123"))) + (e-num @14.12-14.19 (value "-123"))) (field (name "u32Neg") - (e-int @15.12-15.19 (value "-123"))) + (e-num @15.12-15.19 (value "-123"))) (field (name "u64Neg") - (e-int @16.12-16.19 (value "-123"))) + (e-num @16.12-16.19 (value "-123"))) (field (name "u128Neg") - (e-int @17.12-17.20 (value "-123"))) + (e-num @17.12-17.20 (value "-123"))) (field (name "i8Neg") - (e-int @18.12-18.18 (value "-123"))) + (e-num @18.12-18.18 (value "-123"))) (field (name "i16Neg") - (e-int @19.12-19.19 (value "-123"))) + (e-num @19.12-19.19 (value "-123"))) (field (name "i32Neg") - (e-int @20.12-20.19 (value "-123"))) + (e-num @20.12-20.19 (value "-123"))) (field (name "i64Neg") - (e-int @21.12-21.19 (value "-123"))) + (e-num @21.12-21.19 (value "-123"))) (field (name "i128Neg") - (e-int @22.12-22.20 (value "-123"))) + (e-num @22.12-22.20 (value "-123"))) (field (name "decNeg") - (e-int @23.12-23.19 (value "-123"))) + (e-num @23.12-23.19 (value "-123"))) (field (name "u8Bin") - (e-int @24.12-24.19 (value "5"))) + (e-num @24.12-24.19 (value "5"))) (field (name "u16Bin") - (e-int @25.12-25.20 (value "5"))) + (e-num @25.12-25.20 (value "5"))) (field (name "u32Bin") - (e-int @26.12-26.20 (value "5"))) + (e-num @26.12-26.20 (value "5"))) (field (name "u64Bin") - (e-int @27.12-27.20 (value "5"))) + (e-num @27.12-27.20 (value "5"))) (field (name "u128Bin") - (e-int @28.12-28.21 (value "5"))) + (e-num @28.12-28.21 (value "5"))) (field (name "i8Bin") - (e-int @29.12-29.19 (value "5"))) + (e-num @29.12-29.19 (value "5"))) (field (name "i16Bin") - (e-int @30.12-30.20 (value "5"))) + (e-num @30.12-30.20 (value "5"))) (field (name "i32Bin") - (e-int @31.12-31.20 (value "5"))) + (e-num @31.12-31.20 (value "5"))) (field (name "i64Bin") - (e-int @32.12-32.20 (value "5"))) + (e-num @32.12-32.20 (value "5"))) (field (name "i128Bin") - (e-int @33.12-33.21 (value "5"))))) + (e-num @33.12-33.21 (value "5"))))) ~~~ # TYPES ~~~clojure -(expr @1.1-34.2 (type "{ u8: U8, u16: U16, u32: U32, u64: U64, u128: U128, i8: I8, i16: I16, i32: I32, i64: I64, i128: I128, dec: Num(_size), u8Neg: U8, u16Neg: U16, u32Neg: U32, u64Neg: U64, u128Neg: U128, i8Neg: I8, i16Neg: I16, i32Neg: I32, i64Neg: I64, i128Neg: I128, decNeg: Num(_size2), u8Bin: U8, u16Bin: U16, u32Bin: U32, u64Bin: U64, u128Bin: U128, i8Bin: I8, i16Bin: I16, i32Bin: I32, i64Bin: I64, i128Bin: I128 }")) +(expr @1.1-34.2 (type "{ dec: Num(Frac(Decimal)), decNeg: Num(Frac(Decimal)), i128: Num(Int(Signed128)), i128Bin: Num(Int(Signed128)), i128Neg: Num(Int(Signed128)), i16: Num(Int(Signed16)), i16Bin: Num(Int(Signed16)), i16Neg: Num(Int(Signed16)), i32: Num(Int(Signed32)), i32Bin: Num(Int(Signed32)), i32Neg: Num(Int(Signed32)), i64: Num(Int(Signed64)), i64Bin: Num(Int(Signed64)), i64Neg: Num(Int(Signed64)), i8: Num(Int(Signed8)), i8Bin: Num(Int(Signed8)), i8Neg: Num(Int(Signed8)), u128: Num(Int(Unsigned128)), u128Bin: Num(Int(Unsigned128)), u128Neg: Num(Int(Unsigned128)), u16: Num(Int(Unsigned16)), u16Bin: Num(Int(Unsigned16)), u16Neg: Num(Int(Unsigned16)), u32: Num(Int(Unsigned32)), u32Bin: Num(Int(Unsigned32)), u32Neg: Num(Int(Unsigned32)), u64: Num(Int(Unsigned64)), u64Bin: Num(Int(Unsigned64)), u64Neg: Num(Int(Unsigned64)), u8: Num(Int(Unsigned8)), u8Bin: Num(Int(Unsigned8)), u8Neg: Num(Int(Unsigned8)) }")) ~~~ diff --git a/test/snapshots/expr/record_builder.md b/test/snapshots/expr/record_builder.md index 71296a684b..eac5eb0dbb 100644 --- a/test/snapshots/expr/record_builder.md +++ b/test/snapshots/expr/record_builder.md @@ -181,12 +181,8 @@ EndOfFile(5:1-5:1), (e-runtime-error (tag "ident_not_in_scope"))) (s-expr @1.15-1.17 (e-runtime-error (tag "expr_not_canonicalized"))) - (s-type-anno @2.5-2.9 (name "x") - (ty-malformed @2.8-2.9)) (s-expr @2.9-2.10 (e-runtime-error (tag "expr_not_canonicalized"))) - (s-type-anno @3.5-3.9 (name "y") - (ty-malformed @3.8-3.9)) (e-runtime-error (tag "expr_not_canonicalized"))) ~~~ # TYPES diff --git a/test/snapshots/expr/record_field_update.md b/test/snapshots/expr/record_field_update.md index aed73c53bd..1c7472014d 100644 --- a/test/snapshots/expr/record_field_update.md +++ b/test/snapshots/expr/record_field_update.md @@ -45,9 +45,9 @@ NO CHANGE (e-runtime-error (tag "ident_not_in_scope"))) (fields (field (name "age") - (e-int @1.18-1.20 (value "31"))))) + (e-num @1.18-1.20 (value "31"))))) ~~~ # TYPES ~~~clojure -(expr @1.1-1.22 (type "{ age: Num(_size) }")) +(expr @1.1-1.22 (type "{ age: Num(_size), Error }")) ~~~ diff --git a/test/snapshots/expr/record_field_update_error.md b/test/snapshots/expr/record_field_update_error.md index 755844209c..9f38062516 100644 --- a/test/snapshots/expr/record_field_update_error.md +++ b/test/snapshots/expr/record_field_update_error.md @@ -96,8 +96,6 @@ EndOfFile(2:1-2:1), (e-runtime-error (tag "ident_not_in_scope"))) (s-expr @1.10-1.11 (e-runtime-error (tag "expr_not_canonicalized"))) - (s-type-anno @1.12-1.19 (name "age") - (ty-malformed @1.17-1.19)) (e-empty_record @1.1-1.21)) ~~~ # TYPES diff --git a/test/snapshots/expr/record_literal_field_bang.md b/test/snapshots/expr/record_literal_field_bang.md index 20b4ff4a30..39b632720f 100644 --- a/test/snapshots/expr/record_literal_field_bang.md +++ b/test/snapshots/expr/record_literal_field_bang.md @@ -45,7 +45,7 @@ EndOfFile(5:1-5:1), (e-record @1.1-4.2 (fields (field (name "answer") - (e-int @2.13-2.15 (value "42"))) + (e-num @2.13-2.15 (value "42"))) (field (name "launchTheNukes!") (e-lambda @3.22-3.30 (args @@ -55,5 +55,5 @@ EndOfFile(5:1-5:1), ~~~ # TYPES ~~~clojure -(expr @1.1-4.2 (type "{ answer: Num(_size), launchTheNukes!: _arg -> _ret }")) +(expr @1.1-4.2 (type "{ answer: Num(_size), launchTheNukes!: {} -> _ret }")) ~~~ diff --git a/test/snapshots/expr/record_simple.md b/test/snapshots/expr/record_simple.md index 2a425e6c51..a814fa29aa 100644 --- a/test/snapshots/expr/record_simple.md +++ b/test/snapshots/expr/record_simple.md @@ -37,9 +37,9 @@ NO CHANGE (e-string @1.9-1.16 (e-literal @1.10-1.15 (string "Alice")))) (field (name "age") - (e-int @1.23-1.25 (value "30"))))) + (e-num @1.23-1.25 (value "30"))))) ~~~ # TYPES ~~~clojure -(expr @1.1-1.27 (type "{ name: Str, age: Num(_size) }")) +(expr @1.1-1.27 (type "{ age: Num(_size), name: Str }")) ~~~ diff --git a/test/snapshots/expr/record_updater_basic.md b/test/snapshots/expr/record_updater_basic.md index 5495cde6fd..39f14f88fd 100644 --- a/test/snapshots/expr/record_updater_basic.md +++ b/test/snapshots/expr/record_updater_basic.md @@ -1,12 +1,10 @@ # META ~~~ini description=Basic record updater with field override -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [person, updated] - person = { name: "Alice", age: 30 } updated = { ..person, age: 31 } ~~~ @@ -16,36 +14,30 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:15),Comma(1:15-1:16),LowerIdent(1:17-1:24),CloseSquare(1:24-1:25), -LowerIdent(3:1-3:7),OpAssign(3:8-3:9),OpenCurly(3:10-3:11),LowerIdent(3:12-3:16),OpColon(3:16-3:17),StringStart(3:18-3:19),StringPart(3:19-3:24),StringEnd(3:24-3:25),Comma(3:25-3:26),LowerIdent(3:27-3:30),OpColon(3:30-3:31),Int(3:32-3:34),CloseCurly(3:35-3:36), -LowerIdent(4:1-4:8),OpAssign(4:9-4:10),OpenCurly(4:11-4:12),DoubleDot(4:13-4:15),LowerIdent(4:15-4:21),Comma(4:21-4:22),LowerIdent(4:23-4:26),OpColon(4:26-4:27),Int(4:28-4:30),CloseCurly(4:31-4:32), -EndOfFile(5:1-5:1), +LowerIdent(1:1-1:7),OpAssign(1:8-1:9),OpenCurly(1:10-1:11),LowerIdent(1:12-1:16),OpColon(1:16-1:17),StringStart(1:18-1:19),StringPart(1:19-1:24),StringEnd(1:24-1:25),Comma(1:25-1:26),LowerIdent(1:27-1:30),OpColon(1:30-1:31),Int(1:32-1:34),CloseCurly(1:35-1:36), +LowerIdent(2:1-2:8),OpAssign(2:9-2:10),OpenCurly(2:11-2:12),DoubleDot(2:13-2:15),LowerIdent(2:15-2:21),Comma(2:21-2:22),LowerIdent(2:23-2:26),OpColon(2:26-2:27),Int(2:28-2:30),CloseCurly(2:31-2:32), +EndOfFile(3:1-3:1), ~~~ # PARSE ~~~clojure -(file @1.1-4.32 - (module @1.1-1.25 - (exposes @1.8-1.25 - (exposed-lower-ident @1.9-1.15 - (text "person")) - (exposed-lower-ident @1.17-1.24 - (text "updated")))) +(file @1.1-2.32 + (type-module @1.1-1.7) (statements - (s-decl @3.1-3.36 - (p-ident @3.1-3.7 (raw "person")) - (e-record @3.10-3.36 + (s-decl @1.1-1.36 + (p-ident @1.1-1.7 (raw "person")) + (e-record @1.10-1.36 (field (field "name") - (e-string @3.18-3.25 - (e-string-part @3.19-3.24 (raw "Alice")))) + (e-string @1.18-1.25 + (e-string-part @1.19-1.24 (raw "Alice")))) (field (field "age") - (e-int @3.32-3.34 (raw "30"))))) - (s-decl @4.1-4.32 - (p-ident @4.1-4.8 (raw "updated")) - (e-record @4.11-4.32 + (e-int @1.32-1.34 (raw "30"))))) + (s-decl @2.1-2.32 + (p-ident @2.1-2.8 (raw "updated")) + (e-record @2.11-2.32 (ext - (e-ident @4.15-4.21 (raw "person"))) + (e-ident @2.15-2.21 (raw "person"))) (field (field "age") - (e-int @4.28-4.30 (raw "31"))))))) + (e-int @2.28-2.30 (raw "31"))))))) ~~~ # FORMATTED ~~~roc @@ -55,31 +47,31 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @3.1-3.7 (ident "person")) - (e-record @3.10-3.36 + (p-assign @1.1-1.7 (ident "person")) + (e-record @1.10-1.36 (fields (field (name "name") - (e-string @3.18-3.25 - (e-literal @3.19-3.24 (string "Alice")))) + (e-string @1.18-1.25 + (e-literal @1.19-1.24 (string "Alice")))) (field (name "age") - (e-int @3.32-3.34 (value "30")))))) + (e-num @1.32-1.34 (value "30")))))) (d-let - (p-assign @4.1-4.8 (ident "updated")) - (e-record @4.11-4.32 + (p-assign @2.1-2.8 (ident "updated")) + (e-record @2.11-2.32 (ext - (e-lookup-local @4.15-4.21 - (p-assign @3.1-3.7 (ident "person")))) + (e-lookup-local @2.15-2.21 + (p-assign @1.1-1.7 (ident "person")))) (fields (field (name "age") - (e-int @4.28-4.30 (value "31"))))))) + (e-num @2.28-2.30 (value "31"))))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @3.1-3.7 (type "{ name: Str, age: Num(_size) }")) - (patt @4.1-4.8 (type "{ age: Num(_size) }"))) + (patt @1.1-1.7 (type "{ age: Num(_size), name: Str }")) + (patt @2.1-2.8 (type "{ age: Num(_size), { age: Num(_size2), name: Str } }"))) (expressions - (expr @3.10-3.36 (type "{ name: Str, age: Num(_size) }")) - (expr @4.11-4.32 (type "{ age: Num(_size) }")))) + (expr @1.10-1.36 (type "{ age: Num(_size), name: Str }")) + (expr @2.11-2.32 (type "{ age: Num(_size), { age: Num(_size2), name: Str } }")))) ~~~ diff --git a/test/snapshots/expr/record_updater_chained.md b/test/snapshots/expr/record_updater_chained.md index ad64aa7c62..da48f103bf 100644 --- a/test/snapshots/expr/record_updater_chained.md +++ b/test/snapshots/expr/record_updater_chained.md @@ -1,12 +1,10 @@ # META ~~~ini description=Chained record updater expressions -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [person, final] - person = { name: "Alice", age: 30, city: "Boston" } updated_one = { ..person, age: 31 } updated2 = { ..updated_one, city: "New York" } @@ -18,59 +16,53 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:15),Comma(1:15-1:16),LowerIdent(1:17-1:22),CloseSquare(1:22-1:23), -LowerIdent(3:1-3:7),OpAssign(3:8-3:9),OpenCurly(3:10-3:11),LowerIdent(3:12-3:16),OpColon(3:16-3:17),StringStart(3:18-3:19),StringPart(3:19-3:24),StringEnd(3:24-3:25),Comma(3:25-3:26),LowerIdent(3:27-3:30),OpColon(3:30-3:31),Int(3:32-3:34),Comma(3:34-3:35),LowerIdent(3:36-3:40),OpColon(3:40-3:41),StringStart(3:42-3:43),StringPart(3:43-3:49),StringEnd(3:49-3:50),CloseCurly(3:51-3:52), -LowerIdent(4:1-4:12),OpAssign(4:13-4:14),OpenCurly(4:15-4:16),DoubleDot(4:17-4:19),LowerIdent(4:19-4:25),Comma(4:25-4:26),LowerIdent(4:27-4:30),OpColon(4:30-4:31),Int(4:32-4:34),CloseCurly(4:35-4:36), -LowerIdent(5:1-5:9),OpAssign(5:10-5:11),OpenCurly(5:12-5:13),DoubleDot(5:14-5:16),LowerIdent(5:16-5:27),Comma(5:27-5:28),LowerIdent(5:29-5:33),OpColon(5:33-5:34),StringStart(5:35-5:36),StringPart(5:36-5:44),StringEnd(5:44-5:45),CloseCurly(5:46-5:47), -LowerIdent(6:1-6:6),OpAssign(6:7-6:8),OpenCurly(6:9-6:10),DoubleDot(6:11-6:13),LowerIdent(6:13-6:21),Comma(6:21-6:22),LowerIdent(6:23-6:27),OpColon(6:27-6:28),StringStart(6:29-6:30),StringPart(6:30-6:41),StringEnd(6:41-6:42),Comma(6:42-6:43),LowerIdent(6:44-6:47),OpColon(6:47-6:48),Int(6:49-6:51),CloseCurly(6:52-6:53), -EndOfFile(7:1-7:1), +LowerIdent(1:1-1:7),OpAssign(1:8-1:9),OpenCurly(1:10-1:11),LowerIdent(1:12-1:16),OpColon(1:16-1:17),StringStart(1:18-1:19),StringPart(1:19-1:24),StringEnd(1:24-1:25),Comma(1:25-1:26),LowerIdent(1:27-1:30),OpColon(1:30-1:31),Int(1:32-1:34),Comma(1:34-1:35),LowerIdent(1:36-1:40),OpColon(1:40-1:41),StringStart(1:42-1:43),StringPart(1:43-1:49),StringEnd(1:49-1:50),CloseCurly(1:51-1:52), +LowerIdent(2:1-2:12),OpAssign(2:13-2:14),OpenCurly(2:15-2:16),DoubleDot(2:17-2:19),LowerIdent(2:19-2:25),Comma(2:25-2:26),LowerIdent(2:27-2:30),OpColon(2:30-2:31),Int(2:32-2:34),CloseCurly(2:35-2:36), +LowerIdent(3:1-3:9),OpAssign(3:10-3:11),OpenCurly(3:12-3:13),DoubleDot(3:14-3:16),LowerIdent(3:16-3:27),Comma(3:27-3:28),LowerIdent(3:29-3:33),OpColon(3:33-3:34),StringStart(3:35-3:36),StringPart(3:36-3:44),StringEnd(3:44-3:45),CloseCurly(3:46-3:47), +LowerIdent(4:1-4:6),OpAssign(4:7-4:8),OpenCurly(4:9-4:10),DoubleDot(4:11-4:13),LowerIdent(4:13-4:21),Comma(4:21-4:22),LowerIdent(4:23-4:27),OpColon(4:27-4:28),StringStart(4:29-4:30),StringPart(4:30-4:41),StringEnd(4:41-4:42),Comma(4:42-4:43),LowerIdent(4:44-4:47),OpColon(4:47-4:48),Int(4:49-4:51),CloseCurly(4:52-4:53), +EndOfFile(5:1-5:1), ~~~ # PARSE ~~~clojure -(file @1.1-6.53 - (module @1.1-1.23 - (exposes @1.8-1.23 - (exposed-lower-ident @1.9-1.15 - (text "person")) - (exposed-lower-ident @1.17-1.22 - (text "final")))) +(file @1.1-4.53 + (type-module @1.1-1.7) (statements - (s-decl @3.1-3.52 - (p-ident @3.1-3.7 (raw "person")) - (e-record @3.10-3.52 + (s-decl @1.1-1.52 + (p-ident @1.1-1.7 (raw "person")) + (e-record @1.10-1.52 (field (field "name") - (e-string @3.18-3.25 - (e-string-part @3.19-3.24 (raw "Alice")))) + (e-string @1.18-1.25 + (e-string-part @1.19-1.24 (raw "Alice")))) (field (field "age") - (e-int @3.32-3.34 (raw "30"))) + (e-int @1.32-1.34 (raw "30"))) (field (field "city") - (e-string @3.42-3.50 - (e-string-part @3.43-3.49 (raw "Boston")))))) - (s-decl @4.1-4.36 - (p-ident @4.1-4.12 (raw "updated_one")) - (e-record @4.15-4.36 + (e-string @1.42-1.50 + (e-string-part @1.43-1.49 (raw "Boston")))))) + (s-decl @2.1-2.36 + (p-ident @2.1-2.12 (raw "updated_one")) + (e-record @2.15-2.36 (ext - (e-ident @4.19-4.25 (raw "person"))) + (e-ident @2.19-2.25 (raw "person"))) (field (field "age") - (e-int @4.32-4.34 (raw "31"))))) - (s-decl @5.1-5.47 - (p-ident @5.1-5.9 (raw "updated2")) - (e-record @5.12-5.47 + (e-int @2.32-2.34 (raw "31"))))) + (s-decl @3.1-3.47 + (p-ident @3.1-3.9 (raw "updated2")) + (e-record @3.12-3.47 (ext - (e-ident @5.16-5.27 (raw "updated_one"))) + (e-ident @3.16-3.27 (raw "updated_one"))) (field (field "city") - (e-string @5.35-5.45 - (e-string-part @5.36-5.44 (raw "New York")))))) - (s-decl @6.1-6.53 - (p-ident @6.1-6.6 (raw "final")) - (e-record @6.9-6.53 + (e-string @3.35-3.45 + (e-string-part @3.36-3.44 (raw "New York")))))) + (s-decl @4.1-4.53 + (p-ident @4.1-4.6 (raw "final")) + (e-record @4.9-4.53 (ext - (e-ident @6.13-6.21 (raw "updated2"))) + (e-ident @4.13-4.21 (raw "updated2"))) (field (field "name") - (e-string @6.29-6.42 - (e-string-part @6.30-6.41 (raw "Alice Smith")))) + (e-string @4.29-4.42 + (e-string-part @4.30-4.41 (raw "Alice Smith")))) (field (field "age") - (e-int @6.49-6.51 (raw "32"))))))) + (e-int @4.49-4.51 (raw "32"))))))) ~~~ # FORMATTED ~~~roc @@ -80,60 +72,60 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @3.1-3.7 (ident "person")) - (e-record @3.10-3.52 + (p-assign @1.1-1.7 (ident "person")) + (e-record @1.10-1.52 (fields (field (name "name") - (e-string @3.18-3.25 - (e-literal @3.19-3.24 (string "Alice")))) + (e-string @1.18-1.25 + (e-literal @1.19-1.24 (string "Alice")))) (field (name "age") - (e-int @3.32-3.34 (value "30"))) + (e-num @1.32-1.34 (value "30"))) (field (name "city") - (e-string @3.42-3.50 - (e-literal @3.43-3.49 (string "Boston"))))))) + (e-string @1.42-1.50 + (e-literal @1.43-1.49 (string "Boston"))))))) (d-let - (p-assign @4.1-4.12 (ident "updated_one")) - (e-record @4.15-4.36 + (p-assign @2.1-2.12 (ident "updated_one")) + (e-record @2.15-2.36 (ext - (e-lookup-local @4.19-4.25 - (p-assign @3.1-3.7 (ident "person")))) + (e-lookup-local @2.19-2.25 + (p-assign @1.1-1.7 (ident "person")))) (fields (field (name "age") - (e-int @4.32-4.34 (value "31")))))) + (e-num @2.32-2.34 (value "31")))))) (d-let - (p-assign @5.1-5.9 (ident "updated2")) - (e-record @5.12-5.47 + (p-assign @3.1-3.9 (ident "updated2")) + (e-record @3.12-3.47 (ext - (e-lookup-local @5.16-5.27 - (p-assign @4.1-4.12 (ident "updated_one")))) + (e-lookup-local @3.16-3.27 + (p-assign @2.1-2.12 (ident "updated_one")))) (fields (field (name "city") - (e-string @5.35-5.45 - (e-literal @5.36-5.44 (string "New York"))))))) + (e-string @3.35-3.45 + (e-literal @3.36-3.44 (string "New York"))))))) (d-let - (p-assign @6.1-6.6 (ident "final")) - (e-record @6.9-6.53 + (p-assign @4.1-4.6 (ident "final")) + (e-record @4.9-4.53 (ext - (e-lookup-local @6.13-6.21 - (p-assign @5.1-5.9 (ident "updated2")))) + (e-lookup-local @4.13-4.21 + (p-assign @3.1-3.9 (ident "updated2")))) (fields (field (name "name") - (e-string @6.29-6.42 - (e-literal @6.30-6.41 (string "Alice Smith")))) + (e-string @4.29-4.42 + (e-literal @4.30-4.41 (string "Alice Smith")))) (field (name "age") - (e-int @6.49-6.51 (value "32"))))))) + (e-num @4.49-4.51 (value "32"))))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @3.1-3.7 (type "{ name: Str, age: Num(_size), city: Str }")) - (patt @4.1-4.12 (type "{ age: Num(_size) }")) - (patt @5.1-5.9 (type "{ city: Str }")) - (patt @6.1-6.6 (type "{ name: Str, age: Num(_size) }"))) + (patt @1.1-1.7 (type "{ age: Num(_size), city: Str, name: Str }")) + (patt @2.1-2.12 (type "{ age: Num(_size), { age: Num(_size2), city: Str, name: Str } }")) + (patt @3.1-3.9 (type "{ city: Str, age: Num(_size), { age: Num(_size2), city: Str, name: Str } }")) + (patt @4.1-4.6 (type "{ age: Num(_size), name: Str, city: Str, age: Num(_size2), { age: Num(_size3), city: Str, name: Str } }"))) (expressions - (expr @3.10-3.52 (type "{ name: Str, age: Num(_size), city: Str }")) - (expr @4.15-4.36 (type "{ age: Num(_size) }")) - (expr @5.12-5.47 (type "{ city: Str }")) - (expr @6.9-6.53 (type "{ name: Str, age: Num(_size) }")))) + (expr @1.10-1.52 (type "{ age: Num(_size), city: Str, name: Str }")) + (expr @2.15-2.36 (type "{ age: Num(_size), { age: Num(_size2), city: Str, name: Str } }")) + (expr @3.12-3.47 (type "{ city: Str, age: Num(_size), { age: Num(_size2), city: Str, name: Str } }")) + (expr @4.9-4.53 (type "{ age: Num(_size), name: Str, city: Str, age: Num(_size2), { age: Num(_size3), city: Str, name: Str } }")))) ~~~ diff --git a/test/snapshots/expr/s_quote_pattern.md b/test/snapshots/expr/s_quote_pattern.md index 7026fa8ed1..b8032d2971 100644 --- a/test/snapshots/expr/s_quote_pattern.md +++ b/test/snapshots/expr/s_quote_pattern.md @@ -58,7 +58,7 @@ NO CHANGE (pattern (degenerate false) (p-list @2.2-2.7 (patterns - (p-int @2.3-2.6 (value "35")))))) + (p-num @2.3-2.6 (value "35")))))) (value (e-not-implemented @1.1-1.1))) (branch @@ -66,8 +66,8 @@ NO CHANGE (pattern (degenerate false) (p-list @3.2-3.12 (patterns - (p-int @3.3-3.6 (value "97")) - (p-int @3.8-3.11 (value "98")))))) + (p-num @3.3-3.6 (value "97")) + (p-num @3.8-3.11 (value "98")))))) (value (e-not-implemented @1.1-1.1))) (branch diff --git a/test/snapshots/expr/string_interpolation_simple.md b/test/snapshots/expr/string_interpolation_simple.md index 6d62d1425d..2a4c081634 100644 --- a/test/snapshots/expr/string_interpolation_simple.md +++ b/test/snapshots/expr/string_interpolation_simple.md @@ -46,5 +46,5 @@ NO CHANGE ~~~ # TYPES ~~~clojure -(expr @1.1-1.17 (type "Str")) +(expr @1.1-1.17 (type "Error")) ~~~ diff --git a/test/snapshots/expr/tag_applications_simple.md b/test/snapshots/expr/tag_applications_simple.md index 872d555fdb..a447dad44a 100644 --- a/test/snapshots/expr/tag_applications_simple.md +++ b/test/snapshots/expr/tag_applications_simple.md @@ -119,7 +119,7 @@ EndOfFile(13:1-13:1), (elems (e-tag @2.5-2.13 (name "Some") (args - (e-int @2.10-2.12 (value "42")))) + (e-num @2.10-2.12 (value "42")))) (e-tag @3.5-3.9 (name "None")) (e-nominal @4.5-4.16 (nominal "Result") (e-tag @4.5-4.16 (name "Ok") @@ -133,14 +133,14 @@ EndOfFile(13:1-13:1), (e-literal @5.10-5.14 (string "oops")))))) (e-tag @6.5-6.14 (name "Just") (args - (e-int @6.10-6.13 (value "100")))) + (e-num @6.10-6.13 (value "100")))) (e-tag @7.5-7.12 (name "Nothing")) (e-tag @8.5-8.12 (name "Left") (args - (e-int @8.10-8.11 (value "1")))) + (e-num @8.10-8.11 (value "1")))) (e-tag @9.5-9.13 (name "Right") (args - (e-int @9.11-9.12 (value "2")))) + (e-num @9.11-9.12 (value "2")))) (e-tag @10.5-10.23 (name "Some") (args (e-nominal @10.10-10.22 (nominal "Result") @@ -148,7 +148,7 @@ EndOfFile(13:1-13:1), (args (e-tag @10.13-10.21 (name "Just") (args - (e-int @10.18-10.20 (value "42"))))))))) + (e-num @10.18-10.20 (value "42"))))))))) (e-tag @11.5-11.27 (name "Result") (args (e-nominal @11.12-11.26 (nominal "Result") diff --git a/test/snapshots/expr/tag_vs_function_calls.md b/test/snapshots/expr/tag_vs_function_calls.md index cd4c26eeb1..a33b758e48 100644 --- a/test/snapshots/expr/tag_vs_function_calls.md +++ b/test/snapshots/expr/tag_vs_function_calls.md @@ -115,7 +115,7 @@ EndOfFile(11:1-11:1), (field (name "someTag") (e-tag @2.14-2.22 (name "Some") (args - (e-int @2.19-2.21 (value "42"))))) + (e-num @2.19-2.21 (value "42"))))) (field (name "noneTag") (e-tag @3.14-3.18 (name "None"))) (field (name "okTag") @@ -137,11 +137,11 @@ EndOfFile(11:1-11:1), (e-binop @6.17-6.22 (op "add") (e-lookup-local @6.17-6.18 (p-assign @6.14-6.15 (ident "x"))) - (e-int @6.21-6.22 (value "1"))))) + (e-num @6.21-6.22 (value "1"))))) (field (name "result") (e-call @7.13-7.22 (e-runtime-error (tag "ident_not_in_scope")) - (e-int @7.20-7.21 (value "5")))) + (e-num @7.20-7.21 (value "5")))) (field (name "nested") (e-tag @8.13-8.31 (name "Some") (args @@ -150,22 +150,22 @@ EndOfFile(11:1-11:1), (args (e-tag @8.21-8.29 (name "Just") (args - (e-int @8.26-8.28 (value "42")))))))))) + (e-num @8.26-8.28 (value "42")))))))))) (field (name "tagList") (e-list @9.14-9.47 (elems (e-tag @9.15-9.22 (name "Some") (args - (e-int @9.20-9.21 (value "1")))) + (e-num @9.20-9.21 (value "1")))) (e-tag @9.24-9.31 (name "Some") (args - (e-int @9.29-9.30 (value "2")))) + (e-num @9.29-9.30 (value "2")))) (e-tag @9.33-9.37 (name "None")) (e-tag @9.39-9.46 (name "Some") (args - (e-int @9.44-9.45 (value "3"))))))))) + (e-num @9.44-9.45 (value "3"))))))))) ~~~ # TYPES ~~~clojure -(expr @1.1-10.2 (type "{ someTag: [Some(Num(_size))]_others, noneTag: [None]_others2, okTag: Result(Str, err), errTag: Result(ok, Str), addOne: Num(_size2) -> Num(_size3), result: _field, nested: [Some(Error)]_others3, tagList: List([Some(Num(_size4))][None]_others4) }")) +(expr @1.1-10.2 (type "{ addOne: Num(_size) -> Num(_size2), errTag: Result(ok, Str), nested: [Some(Result([Just(Num(_size3))]_others, err))]_others2, noneTag: [None]_others3, okTag: Result(Str, err), result: _field, someTag: [Some(Num(_size4))]_others4, tagList: List([Some(Num(_size5))][None]_others5) }")) ~~~ diff --git a/test/snapshots/expr/tag_with_payload.md b/test/snapshots/expr/tag_with_payload.md index 8d73514f0b..aaba2c2c74 100644 --- a/test/snapshots/expr/tag_with_payload.md +++ b/test/snapshots/expr/tag_with_payload.md @@ -30,7 +30,7 @@ NO CHANGE ~~~clojure (e-tag @1.1-1.9 (name "Some") (args - (e-int @1.6-1.8 (value "42")))) + (e-num @1.6-1.8 (value "42")))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/expr/tuple.md b/test/snapshots/expr/tuple.md index 852f2a1f46..4fa197d92f 100644 --- a/test/snapshots/expr/tuple.md +++ b/test/snapshots/expr/tuple.md @@ -32,7 +32,7 @@ NO CHANGE ~~~clojure (e-tuple @1.1-1.19 (elems - (e-int @1.2-1.3 (value "1")) + (e-num @1.2-1.3 (value "1")) (e-string @1.5-1.12 (e-literal @1.6-1.11 (string "hello"))) (e-nominal @1.14-1.18 (nominal "Bool") diff --git a/test/snapshots/expr/tuple_comprehensive.md b/test/snapshots/expr/tuple_comprehensive.md index 7b8bed436d..65099de645 100644 --- a/test/snapshots/expr/tuple_comprehensive.md +++ b/test/snapshots/expr/tuple_comprehensive.md @@ -258,30 +258,30 @@ EndOfFile(20:1-20:1), (e-empty_record @3.19-3.21))) (s-let @4.5-4.11 (p-assign @4.5-4.6 (ident "x")) - (e-int @4.9-4.11 (value "10"))) + (e-num @4.9-4.11 (value "10"))) (s-let @5.5-5.11 (p-assign @5.5-5.6 (ident "y")) - (e-int @5.9-5.11 (value "20"))) + (e-num @5.9-5.11 (value "20"))) (s-let @6.5-6.11 (p-assign @6.5-6.6 (ident "z")) - (e-int @6.9-6.11 (value "30"))) + (e-num @6.9-6.11 (value "30"))) (s-let @9.2-9.12 (p-assign @9.2-9.7 (ident "empty")) (e-runtime-error (tag "empty_tuple"))) (s-let @10.2-10.15 (p-assign @10.2-10.8 (ident "single")) - (e-int @10.12-10.14 (value "42"))) + (e-num @10.12-10.14 (value "42"))) (s-let @11.2-11.15 (p-assign @11.2-11.6 (ident "pair")) (e-tuple @11.9-11.15 (elems - (e-int @11.10-11.11 (value "1")) - (e-int @11.13-11.14 (value "2"))))) + (e-num @11.10-11.11 (value "1")) + (e-num @11.13-11.14 (value "2"))))) (s-let @12.2-12.29 (p-assign @12.2-12.8 (ident "triple")) (e-tuple @12.11-12.29 (elems - (e-int @12.12-12.13 (value "1")) + (e-num @12.12-12.13 (value "1")) (e-string @12.15-12.22 (e-literal @12.16-12.21 (string "hello"))) (e-nominal @12.24-12.28 (nominal "Bool") @@ -292,12 +292,12 @@ EndOfFile(20:1-20:1), (elems (e-tuple @13.12-13.18 (elems - (e-int @13.13-13.14 (value "1")) - (e-int @13.16-13.17 (value "2")))) + (e-num @13.13-13.14 (value "1")) + (e-num @13.16-13.17 (value "2")))) (e-tuple @13.20-13.26 (elems - (e-int @13.21-13.22 (value "3")) - (e-int @13.24-13.25 (value "4"))))))) + (e-num @13.21-13.22 (value "3")) + (e-num @13.24-13.25 (value "4"))))))) (s-let @14.2-14.42 (p-assign @14.2-14.7 (ident "mixed")) (e-tuple @14.10-14.42 @@ -305,14 +305,14 @@ EndOfFile(20:1-20:1), (e-call @14.11-14.21 (e-lookup-local @14.11-14.18 (p-assign @3.5-3.12 (ident "add_one"))) - (e-int @14.19-14.20 (value "5"))) + (e-num @14.19-14.20 (value "5"))) (e-string @14.23-14.30 (e-literal @14.24-14.29 (string "world"))) (e-list @14.32-14.41 (elems - (e-int @14.33-14.34 (value "1")) - (e-int @14.36-14.37 (value "2")) - (e-int @14.39-14.40 (value "3"))))))) + (e-num @14.33-14.34 (value "1")) + (e-num @14.36-14.37 (value "2")) + (e-num @14.39-14.40 (value "3"))))))) (s-let @15.2-15.23 (p-assign @15.2-15.11 (ident "with_vars")) (e-tuple @15.14-15.23 @@ -333,8 +333,8 @@ EndOfFile(20:1-20:1), (e-binop @16.21-16.26 (op "add") (e-lookup-local @16.21-16.22 (p-assign @16.18-16.19 (ident "n"))) - (e-int @16.25-16.26 (value "1")))) - (e-int @16.28-16.30 (value "42"))))) + (e-num @16.25-16.26 (value "1")))) + (e-num @16.28-16.30 (value "42"))))) (e-lookup-local @18.2-18.7 (p-assign @9.2-9.7 (ident "empty")))) ~~~ diff --git a/test/snapshots/expr/tuple_patterns.md b/test/snapshots/expr/tuple_patterns.md index e07b59d389..62ad7a2e4a 100644 --- a/test/snapshots/expr/tuple_patterns.md +++ b/test/snapshots/expr/tuple_patterns.md @@ -312,8 +312,8 @@ EndOfFile(20:1-20:1), (p-assign @4.9-4.10 (ident "y")))) (e-tuple @4.14-4.20 (elems - (e-int @4.15-4.16 (value "1")) - (e-int @4.18-4.19 (value "2"))))) + (e-num @4.15-4.16 (value "1")) + (e-num @4.18-4.19 (value "2"))))) (s-let @7.5-7.44 (p-tuple @7.5-7.21 (patterns @@ -329,12 +329,12 @@ EndOfFile(20:1-20:1), (elems (e-tuple @7.25-7.33 (elems - (e-int @7.26-7.28 (value "10")) - (e-int @7.30-7.32 (value "20")))) + (e-num @7.26-7.28 (value "10")) + (e-num @7.30-7.32 (value "20")))) (e-tuple @7.35-7.43 (elems - (e-int @7.36-7.38 (value "30")) - (e-int @7.40-7.42 (value "40"))))))) + (e-num @7.36-7.38 (value "30")) + (e-num @7.40-7.42 (value "40"))))))) (s-let @10.5-10.44 (p-tuple @10.5-10.27 (patterns @@ -343,9 +343,9 @@ EndOfFile(20:1-20:1), (p-assign @10.21-10.26 (ident "third")))) (e-tuple @10.30-10.44 (elems - (e-int @10.31-10.34 (value "100")) - (e-int @10.36-10.38 (value "42")) - (e-int @10.40-10.43 (value "200"))))) + (e-num @10.31-10.34 (value "100")) + (e-num @10.36-10.38 (value "42")) + (e-num @10.40-10.43 (value "200"))))) (s-let @13.5-13.55 (p-tuple @13.5-13.28 (patterns @@ -369,9 +369,9 @@ EndOfFile(20:1-20:1), (elems (e-list @16.22-16.31 (elems - (e-int @16.23-16.24 (value "1")) - (e-int @16.26-16.27 (value "2")) - (e-int @16.29-16.30 (value "3")))) + (e-num @16.23-16.24 (value "1")) + (e-num @16.26-16.27 (value "2")) + (e-num @16.29-16.30 (value "3")))) (e-string @16.33-16.40 (e-literal @16.34-16.39 (string "hello")))))) (e-empty_record @18.5-18.7)) diff --git a/test/snapshots/expr/tuple_simple_unbound.md b/test/snapshots/expr/tuple_simple_unbound.md index 595fecd238..142c8ac7b5 100644 --- a/test/snapshots/expr/tuple_simple_unbound.md +++ b/test/snapshots/expr/tuple_simple_unbound.md @@ -32,7 +32,7 @@ NO CHANGE ~~~clojure (e-tuple @1.1-1.19 (elems - (e-int @1.2-1.3 (value "1")) + (e-num @1.2-1.3 (value "1")) (e-string @1.5-1.12 (e-literal @1.6-1.11 (string "hello"))) (e-nominal @1.14-1.18 (nominal "Bool") diff --git a/test/snapshots/expr/tuple_type.md b/test/snapshots/expr/tuple_type.md index e7fce08fcc..7fee4c0d23 100644 --- a/test/snapshots/expr/tuple_type.md +++ b/test/snapshots/expr/tuple_type.md @@ -26,7 +26,7 @@ The first argument being passed to this function has the wrong type: This argument has the type: _(Num(_size), Num(_size2))_ -But the function needs the first argument to be: +But `f` needs the first argument to be: _(Str, Str)_ # TOKENS @@ -74,14 +74,6 @@ EndOfFile(7:1-7:1), # CANONICALIZE ~~~clojure (e-block @1.1-6.2 - (s-type-anno @2.5-2.33 (name "f") - (ty-fn @2.9-2.33 (effectful false) - (ty-tuple @2.9-2.19 - (ty @2.10-2.13 (name "Str")) - (ty @2.15-2.18 (name "Str"))) - (ty-tuple @2.23-2.33 - (ty @2.24-2.27 (name "Str")) - (ty @2.29-2.32 (name "Str"))))) (s-let @3.5-3.14 (p-assign @3.5-3.6 (ident "f")) (e-lambda @3.9-3.14 @@ -94,8 +86,8 @@ EndOfFile(7:1-7:1), (p-assign @3.5-3.6 (ident "f"))) (e-tuple @5.7-5.13 (elems - (e-int @5.8-5.9 (value "1")) - (e-int @5.11-5.12 (value "2")))))) + (e-num @5.8-5.9 (value "1")) + (e-num @5.11-5.12 (value "2")))))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/expr/tuple_unification_test.md b/test/snapshots/expr/tuple_unification_test.md index 968970e53c..ced9e9f7ba 100644 --- a/test/snapshots/expr/tuple_unification_test.md +++ b/test/snapshots/expr/tuple_unification_test.md @@ -38,7 +38,7 @@ NO CHANGE (elems (e-tuple @1.2-1.10 (elems - (e-int @1.3-1.4 (value "1")) + (e-num @1.3-1.4 (value "1")) (e-string @1.6-1.9 (e-literal @1.7-1.8 (string "a"))))) (e-tuple @1.12-1.22 @@ -49,5 +49,5 @@ NO CHANGE ~~~ # TYPES ~~~clojure -(expr @1.1-1.23 (type "List((Frac(_size), Str))")) +(expr @1.1-1.23 (type "List((Num(Frac(_size)), Str))")) ~~~ diff --git a/test/snapshots/expr/two_arg_closure.md b/test/snapshots/expr/two_arg_closure.md index 6d467b2b08..b0918d6736 100644 --- a/test/snapshots/expr/two_arg_closure.md +++ b/test/snapshots/expr/two_arg_closure.md @@ -34,7 +34,7 @@ NO CHANGE (args (p-underscore @1.2-1.3) (p-underscore @1.5-1.6)) - (e-int @1.8-1.10 (value "42"))) + (e-num @1.8-1.10 (value "42"))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/expr_if_missing_else.md b/test/snapshots/expr_if_missing_else.md index 9c0fdc9996..ace2d25a58 100644 --- a/test/snapshots/expr_if_missing_else.md +++ b/test/snapshots/expr_if_missing_else.md @@ -1,24 +1,22 @@ # META ~~~ini description= -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - foo = if tru 0 ~~~ # EXPECTED -IF WITHOUT ELSE - expr_if_missing_else.md:3:7:3:9 -UNRECOGNIZED SYNTAX - expr_if_missing_else.md:3:7:3:15 +IF WITHOUT ELSE - expr_if_missing_else.md:1:7:1:9 +UNRECOGNIZED SYNTAX - expr_if_missing_else.md:1:7:1:15 # PROBLEMS **IF WITHOUT ELSE** This `if` is being used as an expression, but it doesn't have an `else`. When `if` is used as an expression (to evaluate to a value), it must have an `else` branch to specify what value to use when the condition is `False`. -**expr_if_missing_else.md:3:7:3:9:** +**expr_if_missing_else.md:1:7:1:9:** ```roc foo = if tru 0 ``` @@ -28,7 +26,7 @@ foo = if tru 0 **UNRECOGNIZED SYNTAX** I don't recognize this syntax. -**expr_if_missing_else.md:3:7:3:15:** +**expr_if_missing_else.md:1:7:1:15:** ```roc foo = if tru 0 ``` @@ -38,38 +36,34 @@ This might be a syntax error, an unsupported language feature, or a typo. # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -LowerIdent(3:1-3:4),OpAssign(3:5-3:6),KwIf(3:7-3:9),LowerIdent(3:10-3:13),Int(3:14-3:15), -EndOfFile(4:1-4:1), +LowerIdent(1:1-1:4),OpAssign(1:5-1:6),KwIf(1:7-1:9),LowerIdent(1:10-1:13),Int(1:14-1:15), +EndOfFile(2:1-2:1), ~~~ # PARSE ~~~clojure -(file @1.1-3.15 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-1.15 + (type-module @1.1-1.4) (statements - (s-decl @3.1-3.15 - (p-ident @3.1-3.4 (raw "foo")) - (e-malformed @3.7-3.15 (reason "no_else"))))) + (s-decl @1.1-1.15 + (p-ident @1.1-1.4 (raw "foo")) + (e-malformed @1.7-1.15 (reason "no_else"))))) ~~~ # FORMATTED ~~~roc -module [] - foo = ~~~ # CANONICALIZE ~~~clojure (can-ir (d-let - (p-assign @3.1-3.4 (ident "foo")) + (p-assign @1.1-1.4 (ident "foo")) (e-runtime-error (tag "expr_not_canonicalized")))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @3.1-3.4 (type "Error"))) + (patt @1.1-1.4 (type "Error"))) (expressions - (expr @3.7-3.15 (type "Error")))) + (expr @1.7-1.15 (type "Error")))) ~~~ diff --git a/test/snapshots/expr_int_negative.md b/test/snapshots/expr_int_negative.md index a8c3b1eca8..74f104d032 100644 --- a/test/snapshots/expr_int_negative.md +++ b/test/snapshots/expr_int_negative.md @@ -26,7 +26,7 @@ NO CHANGE ~~~ # CANONICALIZE ~~~clojure -(e-int @1.1-1.5 (value "-123")) +(e-num @1.1-1.5 (value "-123")) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/expr_int_simple.md b/test/snapshots/expr_int_simple.md index c8710b02f5..f86b50ac47 100644 --- a/test/snapshots/expr_int_simple.md +++ b/test/snapshots/expr_int_simple.md @@ -26,7 +26,7 @@ NO CHANGE ~~~ # CANONICALIZE ~~~clojure -(e-int @1.1-1.3 (value "42")) +(e-num @1.1-1.3 (value "42")) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/expr_no_space_dot_int.md b/test/snapshots/expr_no_space_dot_int.md index f668a30f0f..738439609a 100644 --- a/test/snapshots/expr_no_space_dot_int.md +++ b/test/snapshots/expr_no_space_dot_int.md @@ -1,23 +1,21 @@ # META ~~~ini description= -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - foo = asd.0 ~~~ # EXPECTED -PARSE ERROR - expr_no_space_dot_int.md:3:10:3:12 -UNRECOGNIZED SYNTAX - expr_no_space_dot_int.md:3:10:3:12 +PARSE ERROR - expr_no_space_dot_int.md:1:10:1:12 +UNRECOGNIZED SYNTAX - expr_no_space_dot_int.md:1:10:1:12 # PROBLEMS **PARSE ERROR** A parsing error occurred: `expr_no_space_dot_int` This is an unexpected parsing error. Please check your syntax. -**expr_no_space_dot_int.md:3:10:3:12:** +**expr_no_space_dot_int.md:1:10:1:12:** ```roc foo = asd.0 ``` @@ -27,7 +25,7 @@ foo = asd.0 **UNRECOGNIZED SYNTAX** I don't recognize this syntax. -**expr_no_space_dot_int.md:3:10:3:12:** +**expr_no_space_dot_int.md:1:10:1:12:** ```roc foo = asd.0 ``` @@ -37,38 +35,34 @@ This might be a syntax error, an unsupported language feature, or a typo. # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -LowerIdent(3:1-3:4),OpAssign(3:5-3:6),LowerIdent(3:7-3:10),NoSpaceDotInt(3:10-3:12), -EndOfFile(4:1-4:1), +LowerIdent(1:1-1:4),OpAssign(1:5-1:6),LowerIdent(1:7-1:10),NoSpaceDotInt(1:10-1:12), +EndOfFile(2:1-2:1), ~~~ # PARSE ~~~clojure -(file @1.1-3.12 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-1.12 + (type-module @1.1-1.4) (statements - (s-decl @3.1-3.12 - (p-ident @3.1-3.4 (raw "foo")) - (e-malformed @3.10-3.12 (reason "expr_no_space_dot_int"))))) + (s-decl @1.1-1.12 + (p-ident @1.1-1.4 (raw "foo")) + (e-malformed @1.10-1.12 (reason "expr_no_space_dot_int"))))) ~~~ # FORMATTED ~~~roc -module [] - foo = ~~~ # CANONICALIZE ~~~clojure (can-ir (d-let - (p-assign @3.1-3.4 (ident "foo")) + (p-assign @1.1-1.4 (ident "foo")) (e-runtime-error (tag "expr_not_canonicalized")))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @3.1-3.4 (type "Error"))) + (patt @1.1-1.4 (type "Error"))) (expressions - (expr @3.10-3.12 (type "Error")))) + (expr @1.10-1.12 (type "Error")))) ~~~ diff --git a/test/snapshots/external_decl_lookup.md b/test/snapshots/external_decl_lookup.md index 6d4d28290c..72c2e5dad0 100644 --- a/test/snapshots/external_decl_lookup.md +++ b/test/snapshots/external_decl_lookup.md @@ -113,13 +113,13 @@ main! = |_| { (p-assign @8.5-8.11 (ident "result")) (e-call @8.14-8.54 (e-lookup-external @8.14-8.23 - (module-idx "1") + (module-idx "3") (target-node-idx "0")) (e-string @8.24-8.53 (e-literal @8.25-8.52 (string "Hello from external module!"))))) (e-call @9.5-9.25 (e-lookup-external @9.5-9.17 - (module-idx "0") + (module-idx "2") (target-node-idx "0")) (e-lookup-local @9.18-9.24 (p-assign @8.5-8.11 (ident "result"))))))) diff --git a/test/snapshots/fib_module.md b/test/snapshots/fib_module.md index 7268220086..c736fe8a52 100644 --- a/test/snapshots/fib_module.md +++ b/test/snapshots/fib_module.md @@ -1,12 +1,10 @@ # META ~~~ini description=Fibonacci fn -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [fib] - fib = |n| if n <= 1 n else fib(n - 1) + fib(n - 2) ~~~ # EXPECTED @@ -15,39 +13,35 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:12),CloseSquare(1:12-1:13), -LowerIdent(3:1-3:4),OpAssign(3:5-3:6),OpBar(3:7-3:8),LowerIdent(3:8-3:9),OpBar(3:9-3:10),KwIf(3:11-3:13),LowerIdent(3:14-3:15),OpLessThanOrEq(3:16-3:18),Int(3:19-3:20),LowerIdent(3:21-3:22),KwElse(3:23-3:27),LowerIdent(3:28-3:31),NoSpaceOpenRound(3:31-3:32),LowerIdent(3:32-3:33),OpBinaryMinus(3:34-3:35),Int(3:36-3:37),CloseRound(3:37-3:38),OpPlus(3:39-3:40),LowerIdent(3:41-3:44),NoSpaceOpenRound(3:44-3:45),LowerIdent(3:45-3:46),OpBinaryMinus(3:47-3:48),Int(3:49-3:50),CloseRound(3:50-3:51), -EndOfFile(4:1-4:1), +LowerIdent(1:1-1:4),OpAssign(1:5-1:6),OpBar(1:7-1:8),LowerIdent(1:8-1:9),OpBar(1:9-1:10),KwIf(1:11-1:13),LowerIdent(1:14-1:15),OpLessThanOrEq(1:16-1:18),Int(1:19-1:20),LowerIdent(1:21-1:22),KwElse(1:23-1:27),LowerIdent(1:28-1:31),NoSpaceOpenRound(1:31-1:32),LowerIdent(1:32-1:33),OpBinaryMinus(1:34-1:35),Int(1:36-1:37),CloseRound(1:37-1:38),OpPlus(1:39-1:40),LowerIdent(1:41-1:44),NoSpaceOpenRound(1:44-1:45),LowerIdent(1:45-1:46),OpBinaryMinus(1:47-1:48),Int(1:49-1:50),CloseRound(1:50-1:51), +EndOfFile(2:1-2:1), ~~~ # PARSE ~~~clojure -(file @1.1-3.51 - (module @1.1-1.13 - (exposes @1.8-1.13 - (exposed-lower-ident @1.9-1.12 - (text "fib")))) +(file @1.1-1.51 + (type-module @1.1-1.4) (statements - (s-decl @3.1-3.51 - (p-ident @3.1-3.4 (raw "fib")) - (e-lambda @3.7-3.51 + (s-decl @1.1-1.51 + (p-ident @1.1-1.4 (raw "fib")) + (e-lambda @1.7-1.51 (args - (p-ident @3.8-3.9 (raw "n"))) - (e-if-then-else @3.11-3.51 - (e-binop @3.14-3.20 (op "<=") - (e-ident @3.14-3.15 (raw "n")) - (e-int @3.19-3.20 (raw "1"))) - (e-ident @3.21-3.22 (raw "n")) - (e-binop @3.28-3.51 (op "+") - (e-apply @3.28-3.38 - (e-ident @3.28-3.31 (raw "fib")) - (e-binop @3.32-3.37 (op "-") - (e-ident @3.32-3.33 (raw "n")) - (e-int @3.36-3.37 (raw "1")))) - (e-apply @3.41-3.51 - (e-ident @3.41-3.44 (raw "fib")) - (e-binop @3.45-3.50 (op "-") - (e-ident @3.45-3.46 (raw "n")) - (e-int @3.49-3.50 (raw "2")))))))))) + (p-ident @1.8-1.9 (raw "n"))) + (e-if-then-else @1.11-1.51 + (e-binop @1.14-1.20 (op "<=") + (e-ident @1.14-1.15 (raw "n")) + (e-int @1.19-1.20 (raw "1"))) + (e-ident @1.21-1.22 (raw "n")) + (e-binop @1.28-1.51 (op "+") + (e-apply @1.28-1.38 + (e-ident @1.28-1.31 (raw "fib")) + (e-binop @1.32-1.37 (op "-") + (e-ident @1.32-1.33 (raw "n")) + (e-int @1.36-1.37 (raw "1")))) + (e-apply @1.41-1.51 + (e-ident @1.41-1.44 (raw "fib")) + (e-binop @1.45-1.50 (op "-") + (e-ident @1.45-1.46 (raw "n")) + (e-int @1.49-1.50 (raw "2")))))))))) ~~~ # FORMATTED ~~~roc @@ -57,44 +51,44 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @3.1-3.4 (ident "fib")) - (e-closure @3.7-3.51 + (p-assign @1.1-1.4 (ident "fib")) + (e-closure @1.7-1.51 (captures - (capture @3.1-3.4 (ident "fib"))) - (e-lambda @3.7-3.51 + (capture @1.1-1.4 (ident "fib"))) + (e-lambda @1.7-1.51 (args - (p-assign @3.8-3.9 (ident "n"))) - (e-if @3.11-3.51 + (p-assign @1.8-1.9 (ident "n"))) + (e-if @1.11-1.51 (if-branches (if-branch - (e-binop @3.14-3.20 (op "le") - (e-lookup-local @3.14-3.15 - (p-assign @3.8-3.9 (ident "n"))) - (e-int @3.19-3.20 (value "1"))) - (e-lookup-local @3.21-3.22 - (p-assign @3.8-3.9 (ident "n"))))) + (e-binop @1.14-1.20 (op "le") + (e-lookup-local @1.14-1.15 + (p-assign @1.8-1.9 (ident "n"))) + (e-num @1.19-1.20 (value "1"))) + (e-lookup-local @1.21-1.22 + (p-assign @1.8-1.9 (ident "n"))))) (if-else - (e-binop @3.28-3.51 (op "add") - (e-call @3.28-3.38 - (e-lookup-local @3.28-3.31 - (p-assign @3.1-3.4 (ident "fib"))) - (e-binop @3.32-3.37 (op "sub") - (e-lookup-local @3.32-3.33 - (p-assign @3.8-3.9 (ident "n"))) - (e-int @3.36-3.37 (value "1")))) - (e-call @3.41-3.51 - (e-lookup-local @3.41-3.44 - (p-assign @3.1-3.4 (ident "fib"))) - (e-binop @3.45-3.50 (op "sub") - (e-lookup-local @3.45-3.46 - (p-assign @3.8-3.9 (ident "n"))) - (e-int @3.49-3.50 (value "2"))))))))))) + (e-binop @1.28-1.51 (op "add") + (e-call @1.28-1.38 + (e-lookup-local @1.28-1.31 + (p-assign @1.1-1.4 (ident "fib"))) + (e-binop @1.32-1.37 (op "sub") + (e-lookup-local @1.32-1.33 + (p-assign @1.8-1.9 (ident "n"))) + (e-num @1.36-1.37 (value "1")))) + (e-call @1.41-1.51 + (e-lookup-local @1.41-1.44 + (p-assign @1.1-1.4 (ident "fib"))) + (e-binop @1.45-1.50 (op "sub") + (e-lookup-local @1.45-1.46 + (p-assign @1.8-1.9 (ident "n"))) + (e-num @1.49-1.50 (value "2"))))))))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @3.1-3.4 (type "Num(_size) -> Num(_size2)"))) + (patt @1.1-1.4 (type "Num(_size) -> Num(_size2)"))) (expressions - (expr @3.7-3.51 (type "Num(_size) -> Num(_size2)")))) + (expr @1.7-1.51 (type "Num(_size) -> Num(_size2)")))) ~~~ diff --git a/test/snapshots/file/inline_ingested_file.md b/test/snapshots/file/inline_ingested_file.md index bd1e93013c..a208020061 100644 --- a/test/snapshots/file/inline_ingested_file.md +++ b/test/snapshots/file/inline_ingested_file.md @@ -1,30 +1,28 @@ # META ~~~ini description=inline_ingested_file -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [foo] - import "users.json" as data : Str import Json foo = Json.parse(data) ~~~ # EXPECTED -PARSE ERROR - inline_ingested_file.md:3:8:3:9 -PARSE ERROR - inline_ingested_file.md:3:9:3:19 -PARSE ERROR - inline_ingested_file.md:3:19:3:20 -PARSE ERROR - inline_ingested_file.md:3:21:3:23 -MODULE NOT FOUND - inline_ingested_file.md:4:1:4:12 -UNDEFINED VARIABLE - inline_ingested_file.md:6:18:6:22 +PARSE ERROR - inline_ingested_file.md:1:8:1:9 +PARSE ERROR - inline_ingested_file.md:1:9:1:19 +PARSE ERROR - inline_ingested_file.md:1:19:1:20 +PARSE ERROR - inline_ingested_file.md:1:21:1:23 +MODULE NOT FOUND - inline_ingested_file.md:2:1:2:12 +UNDEFINED VARIABLE - inline_ingested_file.md:4:18:4:22 # PROBLEMS **PARSE ERROR** A parsing error occurred: `incomplete_import` This is an unexpected parsing error. Please check your syntax. -**inline_ingested_file.md:3:8:3:9:** +**inline_ingested_file.md:1:8:1:9:** ```roc import "users.json" as data : Str ``` @@ -35,7 +33,7 @@ import "users.json" as data : Str A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**inline_ingested_file.md:3:9:3:19:** +**inline_ingested_file.md:1:9:1:19:** ```roc import "users.json" as data : Str ``` @@ -46,7 +44,7 @@ import "users.json" as data : Str A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**inline_ingested_file.md:3:19:3:20:** +**inline_ingested_file.md:1:19:1:20:** ```roc import "users.json" as data : Str ``` @@ -57,7 +55,7 @@ import "users.json" as data : Str A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**inline_ingested_file.md:3:21:3:23:** +**inline_ingested_file.md:1:21:1:23:** ```roc import "users.json" as data : Str ``` @@ -68,7 +66,7 @@ import "users.json" as data : Str The module `Json` was not found in this Roc project. You're attempting to use this module here: -**inline_ingested_file.md:4:1:4:12:** +**inline_ingested_file.md:2:1:2:12:** ```roc import Json ``` @@ -79,7 +77,7 @@ import Json Nothing is named `data` in this scope. Is there an `import` or `exposing` missing up-top? -**inline_ingested_file.md:6:18:6:22:** +**inline_ingested_file.md:4:18:4:22:** ```roc foo = Json.parse(data) ``` @@ -88,37 +86,31 @@ foo = Json.parse(data) # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:12),CloseSquare(1:12-1:13), -KwImport(3:1-3:7),StringStart(3:8-3:9),StringPart(3:9-3:19),StringEnd(3:19-3:20),KwAs(3:21-3:23),LowerIdent(3:24-3:28),OpColon(3:29-3:30),UpperIdent(3:31-3:34), -KwImport(4:1-4:7),UpperIdent(4:8-4:12), -LowerIdent(6:1-6:4),OpAssign(6:5-6:6),UpperIdent(6:7-6:11),NoSpaceDotLowerIdent(6:11-6:17),NoSpaceOpenRound(6:17-6:18),LowerIdent(6:18-6:22),CloseRound(6:22-6:23), -EndOfFile(7:1-7:1), +KwImport(1:1-1:7),StringStart(1:8-1:9),StringPart(1:9-1:19),StringEnd(1:19-1:20),KwAs(1:21-1:23),LowerIdent(1:24-1:28),OpColon(1:29-1:30),UpperIdent(1:31-1:34), +KwImport(2:1-2:7),UpperIdent(2:8-2:12), +LowerIdent(4:1-4:4),OpAssign(4:5-4:6),UpperIdent(4:7-4:11),NoSpaceDotLowerIdent(4:11-4:17),NoSpaceOpenRound(4:17-4:18),LowerIdent(4:18-4:22),CloseRound(4:22-4:23), +EndOfFile(5:1-5:1), ~~~ # PARSE ~~~clojure -(file @1.1-6.23 - (module @1.1-1.13 - (exposes @1.8-1.13 - (exposed-lower-ident @1.9-1.12 - (text "foo")))) +(file @1.1-4.23 + (type-module @1.1-1.7) (statements - (s-malformed @3.1-3.9 (tag "incomplete_import")) - (s-malformed @3.9-3.19 (tag "statement_unexpected_token")) - (s-malformed @3.19-3.20 (tag "statement_unexpected_token")) - (s-malformed @3.21-3.23 (tag "statement_unexpected_token")) - (s-type-anno @3.24-3.34 (name "data") - (ty @3.31-3.34 (name "Str"))) - (s-import @4.1-4.12 (raw "Json")) - (s-decl @6.1-6.23 - (p-ident @6.1-6.4 (raw "foo")) - (e-apply @6.7-6.23 - (e-ident @6.7-6.17 (raw "Json.parse")) - (e-ident @6.18-6.22 (raw "data")))))) + (s-malformed @1.1-1.9 (tag "incomplete_import")) + (s-malformed @1.9-1.19 (tag "statement_unexpected_token")) + (s-malformed @1.19-1.20 (tag "statement_unexpected_token")) + (s-malformed @1.21-1.23 (tag "statement_unexpected_token")) + (s-type-anno @1.24-1.34 (name "data") + (ty @1.31-1.34 (name "Str"))) + (s-import @2.1-2.12 (raw "Json")) + (s-decl @4.1-4.23 + (p-ident @4.1-4.4 (raw "foo")) + (e-apply @4.7-4.23 + (e-ident @4.7-4.17 (raw "Json.parse")) + (e-ident @4.18-4.22 (raw "data")))))) ~~~ # FORMATTED ~~~roc -module [foo] - data : Str import Json @@ -128,20 +120,20 @@ foo = Json.parse(data) ~~~clojure (can-ir (d-let - (p-assign @6.1-6.4 (ident "foo")) - (e-call @6.7-6.23 - (e-lookup-external @6.7-6.17 - (module-idx "0") + (p-assign @4.1-4.4 (ident "foo")) + (e-call @4.7-4.23 + (e-lookup-external @4.7-4.17 + (module-idx "2") (target-node-idx "0")) (e-runtime-error (tag "ident_not_in_scope")))) - (s-import @4.1-4.12 (module "Json") + (s-import @2.1-2.12 (module "Json") (exposes))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @6.1-6.4 (type "_a"))) + (patt @4.1-4.4 (type "_a"))) (expressions - (expr @6.7-6.23 (type "_a")))) + (expr @4.7-4.23 (type "_a")))) ~~~ diff --git a/test/snapshots/file/underscore_type_decl.md b/test/snapshots/file/underscore_type_decl.md index 564dd1b7b6..86447f7e45 100644 --- a/test/snapshots/file/underscore_type_decl.md +++ b/test/snapshots/file/underscore_type_decl.md @@ -1,12 +1,10 @@ # META ~~~ini description=underscore_in_assignment_pattern -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - import Module exposing [Pair] Pair1(x, _) = Pair(0, 1) @@ -14,29 +12,29 @@ Pair2(_, y) = Pair(0, 1) Pair3(_, _) = Pair(0, 1) ~~~ # EXPECTED +PARSE ERROR - underscore_type_decl.md:3:13:3:14 +PARSE ERROR - underscore_type_decl.md:3:20:3:21 +PARSE ERROR - underscore_type_decl.md:3:23:3:24 +PARSE ERROR - underscore_type_decl.md:4:1:4:6 +PARSE ERROR - underscore_type_decl.md:4:6:4:7 +PARSE ERROR - underscore_type_decl.md:4:7:4:8 +PARSE ERROR - underscore_type_decl.md:4:8:4:9 +PARSE ERROR - underscore_type_decl.md:4:10:4:11 +PARSE ERROR - underscore_type_decl.md:4:11:4:12 +PARSE ERROR - underscore_type_decl.md:4:13:4:14 +PARSE ERROR - underscore_type_decl.md:4:20:4:21 +PARSE ERROR - underscore_type_decl.md:4:23:4:24 +PARSE ERROR - underscore_type_decl.md:5:1:5:6 +PARSE ERROR - underscore_type_decl.md:5:6:5:7 +PARSE ERROR - underscore_type_decl.md:5:7:5:8 +PARSE ERROR - underscore_type_decl.md:5:8:5:9 +PARSE ERROR - underscore_type_decl.md:5:10:5:11 +PARSE ERROR - underscore_type_decl.md:5:11:5:12 PARSE ERROR - underscore_type_decl.md:5:13:5:14 PARSE ERROR - underscore_type_decl.md:5:20:5:21 PARSE ERROR - underscore_type_decl.md:5:23:5:24 -PARSE ERROR - underscore_type_decl.md:6:1:6:6 -PARSE ERROR - underscore_type_decl.md:6:6:6:7 -PARSE ERROR - underscore_type_decl.md:6:7:6:8 -PARSE ERROR - underscore_type_decl.md:6:8:6:9 -PARSE ERROR - underscore_type_decl.md:6:10:6:11 -PARSE ERROR - underscore_type_decl.md:6:11:6:12 -PARSE ERROR - underscore_type_decl.md:6:13:6:14 -PARSE ERROR - underscore_type_decl.md:6:20:6:21 -PARSE ERROR - underscore_type_decl.md:6:23:6:24 -PARSE ERROR - underscore_type_decl.md:7:1:7:6 -PARSE ERROR - underscore_type_decl.md:7:6:7:7 -PARSE ERROR - underscore_type_decl.md:7:7:7:8 -PARSE ERROR - underscore_type_decl.md:7:8:7:9 -PARSE ERROR - underscore_type_decl.md:7:10:7:11 -PARSE ERROR - underscore_type_decl.md:7:11:7:12 -PARSE ERROR - underscore_type_decl.md:7:13:7:14 -PARSE ERROR - underscore_type_decl.md:7:20:7:21 -PARSE ERROR - underscore_type_decl.md:7:23:7:24 -PARSE ERROR - underscore_type_decl.md:8:1:8:1 -MODULE NOT FOUND - underscore_type_decl.md:3:1:3:30 +PARSE ERROR - underscore_type_decl.md:6:1:6:1 +MODULE NOT FOUND - underscore_type_decl.md:1:1:1:30 # PROBLEMS **PARSE ERROR** Type applications require parentheses around their type arguments. @@ -54,20 +52,242 @@ Other valid examples: `Result(a, Str)` `Maybe(List(U64))` -**underscore_type_decl.md:5:13:5:14:** +**underscore_type_decl.md:3:13:3:14:** ```roc Pair1(x, _) = Pair(0, 1) ``` ^ +**PARSE ERROR** +A parsing error occurred: `invalid_type_arg` +This is an unexpected parsing error. Please check your syntax. + +**underscore_type_decl.md:3:20:3:21:** +```roc +Pair1(x, _) = Pair(0, 1) +``` + ^ + + +**PARSE ERROR** +A parsing error occurred: `invalid_type_arg` +This is an unexpected parsing error. Please check your syntax. + +**underscore_type_decl.md:3:23:3:24:** +```roc +Pair1(x, _) = Pair(0, 1) +``` + ^ + + +**PARSE ERROR** +Type applications require parentheses around their type arguments. + +I found a type followed by what looks like a type argument, but they need to be connected with parentheses. + +Instead of: + **List U8** + +Use: + **List(U8)** + +Other valid examples: + `Dict(Str, Num)` + `Result(a, Str)` + `Maybe(List(U64))` + +**underscore_type_decl.md:4:1:4:6:** +```roc +Pair2(_, y) = Pair(0, 1) +``` +^^^^^ + + +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**underscore_type_decl.md:4:6:4:7:** +```roc +Pair2(_, y) = Pair(0, 1) +``` + ^ + + +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**underscore_type_decl.md:4:7:4:8:** +```roc +Pair2(_, y) = Pair(0, 1) +``` + ^ + + +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**underscore_type_decl.md:4:8:4:9:** +```roc +Pair2(_, y) = Pair(0, 1) +``` + ^ + + +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**underscore_type_decl.md:4:10:4:11:** +```roc +Pair2(_, y) = Pair(0, 1) +``` + ^ + + +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**underscore_type_decl.md:4:11:4:12:** +```roc +Pair2(_, y) = Pair(0, 1) +``` + ^ + + +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**underscore_type_decl.md:4:13:4:14:** +```roc +Pair2(_, y) = Pair(0, 1) +``` + ^ + + +**PARSE ERROR** +A parsing error occurred: `invalid_type_arg` +This is an unexpected parsing error. Please check your syntax. + +**underscore_type_decl.md:4:20:4:21:** +```roc +Pair2(_, y) = Pair(0, 1) +``` + ^ + + +**PARSE ERROR** +A parsing error occurred: `invalid_type_arg` +This is an unexpected parsing error. Please check your syntax. + +**underscore_type_decl.md:4:23:4:24:** +```roc +Pair2(_, y) = Pair(0, 1) +``` + ^ + + +**PARSE ERROR** +Type applications require parentheses around their type arguments. + +I found a type followed by what looks like a type argument, but they need to be connected with parentheses. + +Instead of: + **List U8** + +Use: + **List(U8)** + +Other valid examples: + `Dict(Str, Num)` + `Result(a, Str)` + `Maybe(List(U64))` + +**underscore_type_decl.md:5:1:5:6:** +```roc +Pair3(_, _) = Pair(0, 1) +``` +^^^^^ + + +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**underscore_type_decl.md:5:6:5:7:** +```roc +Pair3(_, _) = Pair(0, 1) +``` + ^ + + +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**underscore_type_decl.md:5:7:5:8:** +```roc +Pair3(_, _) = Pair(0, 1) +``` + ^ + + +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**underscore_type_decl.md:5:8:5:9:** +```roc +Pair3(_, _) = Pair(0, 1) +``` + ^ + + +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**underscore_type_decl.md:5:10:5:11:** +```roc +Pair3(_, _) = Pair(0, 1) +``` + ^ + + +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**underscore_type_decl.md:5:11:5:12:** +```roc +Pair3(_, _) = Pair(0, 1) +``` + ^ + + +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**underscore_type_decl.md:5:13:5:14:** +```roc +Pair3(_, _) = Pair(0, 1) +``` + ^ + + **PARSE ERROR** A parsing error occurred: `invalid_type_arg` This is an unexpected parsing error. Please check your syntax. **underscore_type_decl.md:5:20:5:21:** ```roc -Pair1(x, _) = Pair(0, 1) +Pair3(_, _) = Pair(0, 1) ``` ^ @@ -78,228 +298,6 @@ This is an unexpected parsing error. Please check your syntax. **underscore_type_decl.md:5:23:5:24:** ```roc -Pair1(x, _) = Pair(0, 1) -``` - ^ - - -**PARSE ERROR** -Type applications require parentheses around their type arguments. - -I found a type followed by what looks like a type argument, but they need to be connected with parentheses. - -Instead of: - **List U8** - -Use: - **List(U8)** - -Other valid examples: - `Dict(Str, Num)` - `Result(a, Str)` - `Maybe(List(U64))` - -**underscore_type_decl.md:6:1:6:6:** -```roc -Pair2(_, y) = Pair(0, 1) -``` -^^^^^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**underscore_type_decl.md:6:6:6:7:** -```roc -Pair2(_, y) = Pair(0, 1) -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**underscore_type_decl.md:6:7:6:8:** -```roc -Pair2(_, y) = Pair(0, 1) -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**underscore_type_decl.md:6:8:6:9:** -```roc -Pair2(_, y) = Pair(0, 1) -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**underscore_type_decl.md:6:10:6:11:** -```roc -Pair2(_, y) = Pair(0, 1) -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**underscore_type_decl.md:6:11:6:12:** -```roc -Pair2(_, y) = Pair(0, 1) -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**underscore_type_decl.md:6:13:6:14:** -```roc -Pair2(_, y) = Pair(0, 1) -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `invalid_type_arg` -This is an unexpected parsing error. Please check your syntax. - -**underscore_type_decl.md:6:20:6:21:** -```roc -Pair2(_, y) = Pair(0, 1) -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `invalid_type_arg` -This is an unexpected parsing error. Please check your syntax. - -**underscore_type_decl.md:6:23:6:24:** -```roc -Pair2(_, y) = Pair(0, 1) -``` - ^ - - -**PARSE ERROR** -Type applications require parentheses around their type arguments. - -I found a type followed by what looks like a type argument, but they need to be connected with parentheses. - -Instead of: - **List U8** - -Use: - **List(U8)** - -Other valid examples: - `Dict(Str, Num)` - `Result(a, Str)` - `Maybe(List(U64))` - -**underscore_type_decl.md:7:1:7:6:** -```roc -Pair3(_, _) = Pair(0, 1) -``` -^^^^^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**underscore_type_decl.md:7:6:7:7:** -```roc -Pair3(_, _) = Pair(0, 1) -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**underscore_type_decl.md:7:7:7:8:** -```roc -Pair3(_, _) = Pair(0, 1) -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**underscore_type_decl.md:7:8:7:9:** -```roc -Pair3(_, _) = Pair(0, 1) -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**underscore_type_decl.md:7:10:7:11:** -```roc -Pair3(_, _) = Pair(0, 1) -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**underscore_type_decl.md:7:11:7:12:** -```roc -Pair3(_, _) = Pair(0, 1) -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**underscore_type_decl.md:7:13:7:14:** -```roc -Pair3(_, _) = Pair(0, 1) -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `invalid_type_arg` -This is an unexpected parsing error. Please check your syntax. - -**underscore_type_decl.md:7:20:7:21:** -```roc -Pair3(_, _) = Pair(0, 1) -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `invalid_type_arg` -This is an unexpected parsing error. Please check your syntax. - -**underscore_type_decl.md:7:23:7:24:** -```roc Pair3(_, _) = Pair(0, 1) ``` ^ @@ -321,7 +319,7 @@ Other valid examples: `Result(a, Str)` `Maybe(List(U64))` -**underscore_type_decl.md:8:1:8:1:** +**underscore_type_decl.md:6:1:6:1:** ```roc ``` @@ -332,7 +330,7 @@ Other valid examples: The module `Module` was not found in this Roc project. You're attempting to use this module here: -**underscore_type_decl.md:3:1:3:30:** +**underscore_type_decl.md:1:1:1:30:** ```roc import Module exposing [Pair] ``` @@ -341,43 +339,39 @@ import Module exposing [Pair] # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -KwImport(3:1-3:7),UpperIdent(3:8-3:14),KwExposing(3:15-3:23),OpenSquare(3:24-3:25),UpperIdent(3:25-3:29),CloseSquare(3:29-3:30), -UpperIdent(5:1-5:6),NoSpaceOpenRound(5:6-5:7),LowerIdent(5:7-5:8),Comma(5:8-5:9),Underscore(5:10-5:11),CloseRound(5:11-5:12),OpAssign(5:13-5:14),UpperIdent(5:15-5:19),NoSpaceOpenRound(5:19-5:20),Int(5:20-5:21),Comma(5:21-5:22),Int(5:23-5:24),CloseRound(5:24-5:25), -UpperIdent(6:1-6:6),NoSpaceOpenRound(6:6-6:7),Underscore(6:7-6:8),Comma(6:8-6:9),LowerIdent(6:10-6:11),CloseRound(6:11-6:12),OpAssign(6:13-6:14),UpperIdent(6:15-6:19),NoSpaceOpenRound(6:19-6:20),Int(6:20-6:21),Comma(6:21-6:22),Int(6:23-6:24),CloseRound(6:24-6:25), -UpperIdent(7:1-7:6),NoSpaceOpenRound(7:6-7:7),Underscore(7:7-7:8),Comma(7:8-7:9),Underscore(7:10-7:11),CloseRound(7:11-7:12),OpAssign(7:13-7:14),UpperIdent(7:15-7:19),NoSpaceOpenRound(7:19-7:20),Int(7:20-7:21),Comma(7:21-7:22),Int(7:23-7:24),CloseRound(7:24-7:25), -EndOfFile(8:1-8:1), +KwImport(1:1-1:7),UpperIdent(1:8-1:14),KwExposing(1:15-1:23),OpenSquare(1:24-1:25),UpperIdent(1:25-1:29),CloseSquare(1:29-1:30), +UpperIdent(3:1-3:6),NoSpaceOpenRound(3:6-3:7),LowerIdent(3:7-3:8),Comma(3:8-3:9),Underscore(3:10-3:11),CloseRound(3:11-3:12),OpAssign(3:13-3:14),UpperIdent(3:15-3:19),NoSpaceOpenRound(3:19-3:20),Int(3:20-3:21),Comma(3:21-3:22),Int(3:23-3:24),CloseRound(3:24-3:25), +UpperIdent(4:1-4:6),NoSpaceOpenRound(4:6-4:7),Underscore(4:7-4:8),Comma(4:8-4:9),LowerIdent(4:10-4:11),CloseRound(4:11-4:12),OpAssign(4:13-4:14),UpperIdent(4:15-4:19),NoSpaceOpenRound(4:19-4:20),Int(4:20-4:21),Comma(4:21-4:22),Int(4:23-4:24),CloseRound(4:24-4:25), +UpperIdent(5:1-5:6),NoSpaceOpenRound(5:6-5:7),Underscore(5:7-5:8),Comma(5:8-5:9),Underscore(5:10-5:11),CloseRound(5:11-5:12),OpAssign(5:13-5:14),UpperIdent(5:15-5:19),NoSpaceOpenRound(5:19-5:20),Int(5:20-5:21),Comma(5:21-5:22),Int(5:23-5:24),CloseRound(5:24-5:25), +EndOfFile(6:1-6:1), ~~~ # PARSE ~~~clojure -(file @1.1-7.25 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-5.25 + (type-module @1.1-1.7) (statements - (s-import @3.1-3.30 (raw "Module") + (s-import @1.1-1.30 (raw "Module") (exposing - (exposed-upper-ident @3.25-3.29 (text "Pair")))) - (s-malformed @5.13-5.14 (tag "expected_colon_after_type_annotation")) - (s-malformed @6.1-6.6 (tag "expected_colon_after_type_annotation")) - (s-malformed @6.6-6.7 (tag "statement_unexpected_token")) - (s-malformed @6.7-6.8 (tag "statement_unexpected_token")) - (s-malformed @6.8-6.9 (tag "statement_unexpected_token")) - (s-malformed @6.10-6.11 (tag "statement_unexpected_token")) - (s-malformed @6.11-6.12 (tag "statement_unexpected_token")) - (s-malformed @6.13-6.14 (tag "statement_unexpected_token")) - (s-malformed @7.1-7.6 (tag "expected_colon_after_type_annotation")) - (s-malformed @7.6-7.7 (tag "statement_unexpected_token")) - (s-malformed @7.7-7.8 (tag "statement_unexpected_token")) - (s-malformed @7.8-7.9 (tag "statement_unexpected_token")) - (s-malformed @7.10-7.11 (tag "statement_unexpected_token")) - (s-malformed @7.11-7.12 (tag "statement_unexpected_token")) - (s-malformed @7.13-7.14 (tag "statement_unexpected_token")) + (exposed-upper-ident @1.25-1.29 (text "Pair")))) + (s-malformed @3.13-3.14 (tag "expected_colon_after_type_annotation")) + (s-malformed @4.1-4.6 (tag "expected_colon_after_type_annotation")) + (s-malformed @4.6-4.7 (tag "statement_unexpected_token")) + (s-malformed @4.7-4.8 (tag "statement_unexpected_token")) + (s-malformed @4.8-4.9 (tag "statement_unexpected_token")) + (s-malformed @4.10-4.11 (tag "statement_unexpected_token")) + (s-malformed @4.11-4.12 (tag "statement_unexpected_token")) + (s-malformed @4.13-4.14 (tag "statement_unexpected_token")) + (s-malformed @5.1-5.6 (tag "expected_colon_after_type_annotation")) + (s-malformed @5.6-5.7 (tag "statement_unexpected_token")) + (s-malformed @5.7-5.8 (tag "statement_unexpected_token")) + (s-malformed @5.8-5.9 (tag "statement_unexpected_token")) + (s-malformed @5.10-5.11 (tag "statement_unexpected_token")) + (s-malformed @5.11-5.12 (tag "statement_unexpected_token")) + (s-malformed @5.13-5.14 (tag "statement_unexpected_token")) (s-malformed @1.1-1.1 (tag "expected_colon_after_type_annotation")))) ~~~ # FORMATTED ~~~roc -module [] - import Module exposing [Pair] @@ -386,7 +380,7 @@ import Module exposing [Pair] # CANONICALIZE ~~~clojure (can-ir - (s-import @3.1-3.30 (module "Module") + (s-import @1.1-1.30 (module "Module") (exposes (exposed (name "Pair") (wildcard false))))) ~~~ diff --git a/test/snapshots/file_multiple_type_decls.md b/test/snapshots/file_multiple_type_decls.md index b469badebb..c2e7d60d6f 100644 --- a/test/snapshots/file_multiple_type_decls.md +++ b/test/snapshots/file_multiple_type_decls.md @@ -1,12 +1,10 @@ # META ~~~ini description=Multiple unqualified type declarations -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - FirstType : U64 SecondType : Str ThirdType : List(U8) @@ -17,32 +15,30 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -UpperIdent(3:1-3:10),OpColon(3:11-3:12),UpperIdent(3:13-3:16), -UpperIdent(4:1-4:11),OpColon(4:12-4:13),UpperIdent(4:14-4:17), -UpperIdent(5:1-5:10),OpColon(5:11-5:12),UpperIdent(5:13-5:17),NoSpaceOpenRound(5:17-5:18),UpperIdent(5:18-5:20),CloseRound(5:20-5:21), -EndOfFile(6:1-6:1), +UpperIdent(1:1-1:10),OpColon(1:11-1:12),UpperIdent(1:13-1:16), +UpperIdent(2:1-2:11),OpColon(2:12-2:13),UpperIdent(2:14-2:17), +UpperIdent(3:1-3:10),OpColon(3:11-3:12),UpperIdent(3:13-3:17),NoSpaceOpenRound(3:17-3:18),UpperIdent(3:18-3:20),CloseRound(3:20-3:21), +EndOfFile(4:1-4:1), ~~~ # PARSE ~~~clojure -(file @1.1-5.21 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-3.21 + (type-module @1.1-1.10) (statements - (s-type-decl @3.1-3.16 - (header @3.1-3.10 (name "FirstType") + (s-type-decl @1.1-1.16 + (header @1.1-1.10 (name "FirstType") (args)) - (ty @3.13-3.16 (name "U64"))) - (s-type-decl @4.1-4.17 - (header @4.1-4.11 (name "SecondType") + (ty @1.13-1.16 (name "U64"))) + (s-type-decl @2.1-2.17 + (header @2.1-2.11 (name "SecondType") (args)) - (ty @4.14-4.17 (name "Str"))) - (s-type-decl @5.1-5.21 - (header @5.1-5.10 (name "ThirdType") + (ty @2.14-2.17 (name "Str"))) + (s-type-decl @3.1-3.21 + (header @3.1-3.10 (name "ThirdType") (args)) - (ty-apply @5.13-5.21 - (ty @5.13-5.17 (name "List")) - (ty @5.18-5.20 (name "U8")))))) + (ty-apply @3.13-3.21 + (ty @3.13-3.17 (name "List")) + (ty @3.18-3.20 (name "U8")))))) ~~~ # FORMATTED ~~~roc @@ -51,27 +47,27 @@ NO CHANGE # CANONICALIZE ~~~clojure (can-ir - (s-alias-decl @3.1-3.16 - (ty-header @3.1-3.10 (name "FirstType")) - (ty @3.13-3.16 (name "U64"))) - (s-alias-decl @4.1-4.17 - (ty-header @4.1-4.11 (name "SecondType")) - (ty @4.14-4.17 (name "Str"))) - (s-alias-decl @5.1-5.21 - (ty-header @5.1-5.10 (name "ThirdType")) - (ty-apply @5.13-5.21 (symbol "List") - (ty @5.18-5.20 (name "U8"))))) + (s-alias-decl @1.1-1.16 + (ty-header @1.1-1.10 (name "FirstType")) + (ty-lookup @1.13-1.16 (name "U64") (builtin))) + (s-alias-decl @2.1-2.17 + (ty-header @2.1-2.11 (name "SecondType")) + (ty-lookup @2.14-2.17 (name "Str") (builtin))) + (s-alias-decl @3.1-3.21 + (ty-header @3.1-3.10 (name "ThirdType")) + (ty-apply @3.13-3.21 (name "List") (builtin) + (ty-lookup @3.18-3.20 (name "U8") (builtin))))) ~~~ # TYPES ~~~clojure (inferred-types (defs) (type_decls - (alias @3.1-3.16 (type "FirstType") - (ty-header @3.1-3.10 (name "FirstType"))) - (alias @4.1-4.17 (type "SecondType") - (ty-header @4.1-4.11 (name "SecondType"))) - (alias @5.1-5.21 (type "ThirdType") - (ty-header @5.1-5.10 (name "ThirdType")))) + (alias @1.1-1.16 (type "FirstType") + (ty-header @1.1-1.10 (name "FirstType"))) + (alias @2.1-2.17 (type "SecondType") + (ty-header @2.1-2.11 (name "SecondType"))) + (alias @3.1-3.21 (type "ThirdType") + (ty-header @3.1-3.10 (name "ThirdType")))) (expressions)) ~~~ diff --git a/test/snapshots/formatting/multiline/everything.md b/test/snapshots/formatting/multiline/everything.md index 4699a604d7..75c5a8fe27 100644 --- a/test/snapshots/formatting/multiline/everything.md +++ b/test/snapshots/formatting/multiline/everything.md @@ -1,12 +1,10 @@ # META ~~~ini description=Multiline formatting everything -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - # Import exposing import I1 exposing [ I11, @@ -117,25 +115,25 @@ h = |x, y| { } ~~~ # EXPECTED -WHERE CLAUSE NOT ALLOWED IN TYPE DECLARATION - everything.md:14:1:23:11 -WHERE CLAUSE NOT ALLOWED IN TYPE DECLARATION - everything.md:24:1:33:11 -MODULE NOT FOUND - everything.md:4:1:7:2 -MODULE NOT FOUND - everything.md:8:1:11:2 -UNUSED VARIABLE - everything.md:90:5:90:6 -UNUSED VARIABLE - everything.md:95:4:95:5 -UNUSED VARIABLE - everything.md:100:5:100:6 -UNUSED VARIABLE - everything.md:106:5:106:6 -UNUSED VARIABLE - everything.md:61:2:61:4 -UNUSED VARIABLE - everything.md:69:2:69:4 -UNUSED VARIABLE - everything.md:73:2:73:4 -UNUSED VARIABLE - everything.md:77:2:77:4 -UNUSED VARIABLE - everything.md:81:2:81:4 +WHERE CLAUSE NOT ALLOWED IN TYPE DECLARATION - everything.md:12:1:21:11 +WHERE CLAUSE NOT ALLOWED IN TYPE DECLARATION - everything.md:22:1:31:11 +MODULE NOT FOUND - everything.md:2:1:5:2 +MODULE NOT FOUND - everything.md:6:1:9:2 +UNUSED VARIABLE - everything.md:88:5:88:6 +UNUSED VARIABLE - everything.md:93:4:93:5 +UNUSED VARIABLE - everything.md:98:5:98:6 +UNUSED VARIABLE - everything.md:104:5:104:6 +UNUSED VARIABLE - everything.md:59:2:59:4 +UNUSED VARIABLE - everything.md:67:2:67:4 +UNUSED VARIABLE - everything.md:71:2:71:4 +UNUSED VARIABLE - everything.md:75:2:75:4 +UNUSED VARIABLE - everything.md:79:2:79:4 # PROBLEMS **WHERE CLAUSE NOT ALLOWED IN TYPE DECLARATION** You cannot define a `where` clause inside a type declaration. You're attempting do this here: -**everything.md:14:1:23:11:** +**everything.md:12:1:21:11:** ```roc A(a) : a where @@ -154,7 +152,7 @@ A(a) : a You cannot define a `where` clause inside a type declaration. You're attempting do this here: -**everything.md:24:1:33:11:** +**everything.md:22:1:31:11:** ```roc B(b) : b where @@ -173,7 +171,7 @@ B(b) : b The module `I1` was not found in this Roc project. You're attempting to use this module here: -**everything.md:4:1:7:2:** +**everything.md:2:1:5:2:** ```roc import I1 exposing [ I11, @@ -186,7 +184,7 @@ import I1 exposing [ The module `I2` was not found in this Roc project. You're attempting to use this module here: -**everything.md:8:1:11:2:** +**everything.md:6:1:9:2:** ```roc import I2 exposing [ I21 as Ias1, @@ -200,7 +198,7 @@ Variable `b` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_b` to suppress this warning. The unused variable is declared here: -**everything.md:90:5:90:6:** +**everything.md:88:5:88:6:** ```roc b, ``` @@ -212,7 +210,7 @@ Variable `b` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_b` to suppress this warning. The unused variable is declared here: -**everything.md:95:4:95:5:** +**everything.md:93:4:93:5:** ```roc b, ``` @@ -224,7 +222,7 @@ Variable `b` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_b` to suppress this warning. The unused variable is declared here: -**everything.md:100:5:100:6:** +**everything.md:98:5:98:6:** ```roc b, ``` @@ -236,7 +234,7 @@ Variable `b` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_b` to suppress this warning. The unused variable is declared here: -**everything.md:106:5:106:6:** +**everything.md:104:5:104:6:** ```roc b, ``` @@ -248,7 +246,7 @@ Variable `h1` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_h1` to suppress this warning. The unused variable is declared here: -**everything.md:61:2:61:4:** +**everything.md:59:2:59:4:** ```roc h1 = { ``` @@ -260,7 +258,7 @@ Variable `h2` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_h2` to suppress this warning. The unused variable is declared here: -**everything.md:69:2:69:4:** +**everything.md:67:2:67:4:** ```roc h2 = h( ``` @@ -272,7 +270,7 @@ Variable `h3` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_h3` to suppress this warning. The unused variable is declared here: -**everything.md:73:2:73:4:** +**everything.md:71:2:71:4:** ```roc h3 = A( ``` @@ -284,7 +282,7 @@ Variable `h4` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_h4` to suppress this warning. The unused variable is declared here: -**everything.md:77:2:77:4:** +**everything.md:75:2:75:4:** ```roc h4 = [ ``` @@ -296,7 +294,7 @@ Variable `h5` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_h5` to suppress this warning. The unused variable is declared here: -**everything.md:81:2:81:4:** +**everything.md:79:2:79:4:** ```roc h5 = ( ``` @@ -305,460 +303,540 @@ The unused variable is declared here: # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -KwImport(4:1-4:7),UpperIdent(4:8-4:10),KwExposing(4:11-4:19),OpenSquare(4:20-4:21), -UpperIdent(5:2-5:5),Comma(5:5-5:6), -UpperIdent(6:2-6:5),Comma(6:5-6:6), -CloseSquare(7:1-7:2), -KwImport(8:1-8:7),UpperIdent(8:8-8:10),KwExposing(8:11-8:19),OpenSquare(8:20-8:21), -UpperIdent(9:2-9:5),KwAs(9:6-9:8),UpperIdent(9:9-9:13),Comma(9:13-9:14), -UpperIdent(10:2-10:5),KwAs(10:6-10:8),UpperIdent(10:9-10:13),Comma(10:13-10:14), -CloseSquare(11:1-11:2), -UpperIdent(14:1-14:2),NoSpaceOpenRound(14:2-14:3),LowerIdent(14:3-14:4),CloseRound(14:4-14:5),OpColon(14:6-14:7),LowerIdent(14:8-14:9), -KwWhere(15:2-15:7), -KwModule(16:3-16:9),NoSpaceOpenRound(16:9-16:10),LowerIdent(16:10-16:11),CloseRound(16:11-16:12),NoSpaceDotLowerIdent(16:12-16:15),OpColon(16:16-16:17),OpenRound(16:18-16:19), -LowerIdent(17:4-17:5),Comma(17:5-17:6), -LowerIdent(18:4-18:5),Comma(18:5-18:6), -CloseRound(19:3-19:4),OpArrow(19:5-19:7),UpperIdent(19:8-19:11),Comma(19:11-19:12), -KwModule(20:3-20:9),NoSpaceOpenRound(20:9-20:10),LowerIdent(20:10-20:11),CloseRound(20:11-20:12),NoSpaceDotLowerIdent(20:12-20:15),OpColon(20:16-20:17),OpenRound(20:18-20:19), -LowerIdent(21:4-21:5),Comma(21:5-21:6), -LowerIdent(22:4-22:5),Comma(22:5-22:6), -CloseRound(23:3-23:4),OpArrow(23:5-23:7),UpperIdent(23:8-23:11), -UpperIdent(24:1-24:2),NoSpaceOpenRound(24:2-24:3),LowerIdent(24:3-24:4),CloseRound(24:4-24:5),OpColon(24:6-24:7),LowerIdent(24:8-24:9), -KwWhere(25:2-25:7), -KwModule(26:3-26:9),NoSpaceOpenRound(26:9-26:10),LowerIdent(26:10-26:11),CloseRound(26:11-26:12),NoSpaceDotLowerIdent(26:12-26:15),OpColon(26:16-26:17),OpenRound(26:18-26:19), -LowerIdent(27:4-27:5),Comma(27:5-27:6), -LowerIdent(28:4-28:5),Comma(28:5-28:6), -CloseRound(29:3-29:4),OpArrow(29:5-29:7),UpperIdent(29:8-29:11),Comma(29:11-29:12), -KwModule(30:3-30:9),NoSpaceOpenRound(30:9-30:10),LowerIdent(30:10-30:11),CloseRound(30:11-30:12),NoSpaceDotLowerIdent(30:12-30:15),OpColon(30:16-30:17),OpenRound(30:18-30:19), -LowerIdent(31:4-31:5),Comma(31:5-31:6), -LowerIdent(32:4-32:5),Comma(32:5-32:6), -CloseRound(33:3-33:4),OpArrow(33:5-33:7),UpperIdent(33:8-33:11), -UpperIdent(35:1-35:2),NoSpaceOpenRound(35:2-35:3), -LowerIdent(36:2-36:3),Comma(36:3-36:4), +KwImport(2:1-2:7),UpperIdent(2:8-2:10),KwExposing(2:11-2:19),OpenSquare(2:20-2:21), +UpperIdent(3:2-3:5),Comma(3:5-3:6), +UpperIdent(4:2-4:5),Comma(4:5-4:6), +CloseSquare(5:1-5:2), +KwImport(6:1-6:7),UpperIdent(6:8-6:10),KwExposing(6:11-6:19),OpenSquare(6:20-6:21), +UpperIdent(7:2-7:5),KwAs(7:6-7:8),UpperIdent(7:9-7:13),Comma(7:13-7:14), +UpperIdent(8:2-8:5),KwAs(8:6-8:8),UpperIdent(8:9-8:13),Comma(8:13-8:14), +CloseSquare(9:1-9:2), +UpperIdent(12:1-12:2),NoSpaceOpenRound(12:2-12:3),LowerIdent(12:3-12:4),CloseRound(12:4-12:5),OpColon(12:6-12:7),LowerIdent(12:8-12:9), +KwWhere(13:2-13:7), +KwModule(14:3-14:9),NoSpaceOpenRound(14:9-14:10),LowerIdent(14:10-14:11),CloseRound(14:11-14:12),NoSpaceDotLowerIdent(14:12-14:15),OpColon(14:16-14:17),OpenRound(14:18-14:19), +LowerIdent(15:4-15:5),Comma(15:5-15:6), +LowerIdent(16:4-16:5),Comma(16:5-16:6), +CloseRound(17:3-17:4),OpArrow(17:5-17:7),UpperIdent(17:8-17:11),Comma(17:11-17:12), +KwModule(18:3-18:9),NoSpaceOpenRound(18:9-18:10),LowerIdent(18:10-18:11),CloseRound(18:11-18:12),NoSpaceDotLowerIdent(18:12-18:15),OpColon(18:16-18:17),OpenRound(18:18-18:19), +LowerIdent(19:4-19:5),Comma(19:5-19:6), +LowerIdent(20:4-20:5),Comma(20:5-20:6), +CloseRound(21:3-21:4),OpArrow(21:5-21:7),UpperIdent(21:8-21:11), +UpperIdent(22:1-22:2),NoSpaceOpenRound(22:2-22:3),LowerIdent(22:3-22:4),CloseRound(22:4-22:5),OpColon(22:6-22:7),LowerIdent(22:8-22:9), +KwWhere(23:2-23:7), +KwModule(24:3-24:9),NoSpaceOpenRound(24:9-24:10),LowerIdent(24:10-24:11),CloseRound(24:11-24:12),NoSpaceDotLowerIdent(24:12-24:15),OpColon(24:16-24:17),OpenRound(24:18-24:19), +LowerIdent(25:4-25:5),Comma(25:5-25:6), +LowerIdent(26:4-26:5),Comma(26:5-26:6), +CloseRound(27:3-27:4),OpArrow(27:5-27:7),UpperIdent(27:8-27:11),Comma(27:11-27:12), +KwModule(28:3-28:9),NoSpaceOpenRound(28:9-28:10),LowerIdent(28:10-28:11),CloseRound(28:11-28:12),NoSpaceDotLowerIdent(28:12-28:15),OpColon(28:16-28:17),OpenRound(28:18-28:19), +LowerIdent(29:4-29:5),Comma(29:5-29:6), +LowerIdent(30:4-30:5),Comma(30:5-30:6), +CloseRound(31:3-31:4),OpArrow(31:5-31:7),UpperIdent(31:8-31:11), +UpperIdent(33:1-33:2),NoSpaceOpenRound(33:2-33:3), +LowerIdent(34:2-34:3),Comma(34:3-34:4), +LowerIdent(35:2-35:3),Comma(35:3-35:4), +CloseRound(36:1-36:2),OpColon(36:3-36:4),OpenRound(36:5-36:6), LowerIdent(37:2-37:3),Comma(37:3-37:4), -CloseRound(38:1-38:2),OpColon(38:3-38:4),OpenRound(38:5-38:6), -LowerIdent(39:2-39:3),Comma(39:3-39:4), -LowerIdent(40:2-40:3),Comma(40:3-40:4), -CloseRound(41:1-41:2), -UpperIdent(42:1-42:2),NoSpaceOpenRound(42:2-42:3), -LowerIdent(43:2-43:3),Comma(43:3-43:4), +LowerIdent(38:2-38:3),Comma(38:3-38:4), +CloseRound(39:1-39:2), +UpperIdent(40:1-40:2),NoSpaceOpenRound(40:2-40:3), +LowerIdent(41:2-41:3),Comma(41:3-41:4), +LowerIdent(42:2-42:3),Comma(42:3-42:4), +CloseRound(43:1-43:2),OpColon(43:3-43:4),UpperIdent(43:5-43:6),NoSpaceOpenRound(43:6-43:7), LowerIdent(44:2-44:3),Comma(44:3-44:4), -CloseRound(45:1-45:2),OpColon(45:3-45:4),UpperIdent(45:5-45:6),NoSpaceOpenRound(45:6-45:7), -LowerIdent(46:2-46:3),Comma(46:3-46:4), -LowerIdent(47:2-47:3),Comma(47:3-47:4), -CloseRound(48:1-48:2), -UpperIdent(49:1-49:2),OpColon(49:3-49:4),OpenCurly(49:5-49:6), -LowerIdent(50:2-50:3),OpColon(50:4-50:5),UpperIdent(50:6-50:9),Comma(50:9-50:10), -LowerIdent(51:2-51:3),OpColon(51:4-51:5),UpperIdent(51:6-51:9),Comma(51:9-51:10), -CloseCurly(52:1-52:2), -UpperIdent(53:1-53:2),OpColon(53:3-53:4),OpenSquare(53:5-53:6), -UpperIdent(54:2-54:3),Comma(54:3-54:4), -UpperIdent(55:2-55:3),Comma(55:3-55:4), -CloseSquare(56:1-56:2), -LowerIdent(58:1-58:2),OpColon(58:3-58:4),LowerIdent(58:5-58:6),OpArrow(58:7-58:9),LowerIdent(58:10-58:11),KwWhere(58:12-58:17),KwModule(58:18-58:24),NoSpaceOpenRound(58:24-58:25),LowerIdent(58:25-58:26),CloseRound(58:26-58:27),NoSpaceDotUpperIdent(58:27-58:29),Comma(58:29-58:30),KwModule(58:31-58:37),NoSpaceOpenRound(58:37-58:38),LowerIdent(58:38-58:39),CloseRound(58:39-58:40),NoSpaceDotUpperIdent(58:40-58:42), -LowerIdent(60:1-60:2),OpAssign(60:3-60:4),OpBar(60:5-60:6),LowerIdent(60:6-60:7),Comma(60:7-60:8),LowerIdent(60:9-60:10),OpBar(60:10-60:11),OpenCurly(60:12-60:13), -LowerIdent(61:2-61:4),OpAssign(61:5-61:6),OpenCurly(61:7-61:8), -LowerIdent(62:3-62:6),OpColon(62:6-62:7),LowerIdent(62:8-62:9),Comma(62:9-62:10), -LowerIdent(63:3-63:6),OpColon(63:6-63:7),LowerIdent(63:8-63:9),Comma(63:9-63:10), -LowerIdent(64:3-64:6),OpColon(64:6-64:7),OpenCurly(64:8-64:9), -LowerIdent(65:4-65:8),OpColon(65:8-65:9),LowerIdent(65:10-65:11),Comma(65:11-65:12), -LowerIdent(66:4-66:8),OpColon(66:8-66:9),LowerIdent(66:10-66:11),Comma(66:11-66:12), -CloseCurly(67:3-67:4),Comma(67:4-67:5), -CloseCurly(68:2-68:3), -LowerIdent(69:2-69:4),OpAssign(69:5-69:6),LowerIdent(69:7-69:8),NoSpaceOpenRound(69:8-69:9), -LowerIdent(70:3-70:4),Comma(70:4-70:5), -LowerIdent(71:3-71:4),Comma(71:4-71:5), -CloseRound(72:2-72:3), -LowerIdent(73:2-73:4),OpAssign(73:5-73:6),UpperIdent(73:7-73:8),NoSpaceOpenRound(73:8-73:9), -LowerIdent(74:3-74:4),Comma(74:4-74:5), -LowerIdent(75:3-75:4),Comma(75:4-75:5), -CloseRound(76:2-76:3), -LowerIdent(77:2-77:4),OpAssign(77:5-77:6),OpenSquare(77:7-77:8), -LowerIdent(78:3-78:4),Comma(78:4-78:5), -LowerIdent(79:3-79:4),Comma(79:4-79:5), -CloseSquare(80:2-80:3), -LowerIdent(81:2-81:4),OpAssign(81:5-81:6),OpenRound(81:7-81:8), -LowerIdent(82:3-82:4),Comma(82:4-82:5), -LowerIdent(83:3-83:4),Comma(83:4-83:5), -CloseRound(84:2-84:3), -KwMatch(86:2-86:7),LowerIdent(86:8-86:9),OpenCurly(86:10-86:11), -UpperIdent(87:3-87:5),NoSpaceOpenRound(87:5-87:6), -OpenRound(88:4-88:5), -LowerIdent(89:5-89:6),Comma(89:6-89:7), -LowerIdent(90:5-90:6),Comma(90:6-90:7), -CloseRound(91:4-91:5),Comma(91:5-91:6), -CloseRound(92:3-92:4),OpFatArrow(92:5-92:7),LowerIdent(92:8-92:9), -UpperIdent(93:3-93:5),NoSpaceOpenRound(93:5-93:6), -LowerIdent(94:4-94:5),Comma(94:5-94:6), -LowerIdent(95:4-95:5),Comma(95:5-95:6), -CloseRound(96:3-96:4),OpFatArrow(96:5-96:7),LowerIdent(96:8-96:9), -UpperIdent(97:3-97:5),NoSpaceOpenRound(97:5-97:6), -OpenCurly(98:4-98:5), -LowerIdent(99:5-99:6),Comma(99:6-99:7), -LowerIdent(100:5-100:6),Comma(100:6-100:7), -CloseCurly(101:4-101:5),Comma(101:5-101:6), -CloseRound(102:3-102:4),OpFatArrow(102:5-102:7),LowerIdent(102:8-102:9), -UpperIdent(103:3-103:5),NoSpaceOpenRound(103:5-103:6), -OpenSquare(104:4-104:5), -LowerIdent(105:5-105:6),Comma(105:6-105:7), -LowerIdent(106:5-106:6),Comma(106:6-106:7), -CloseSquare(107:4-107:5),Comma(107:5-107:6), -CloseRound(108:3-108:4),OpFatArrow(108:5-108:7),LowerIdent(108:8-108:9), -CloseCurly(109:2-109:3), -CloseCurly(110:1-110:2), -EndOfFile(111:1-111:1), +LowerIdent(45:2-45:3),Comma(45:3-45:4), +CloseRound(46:1-46:2), +UpperIdent(47:1-47:2),OpColon(47:3-47:4),OpenCurly(47:5-47:6), +LowerIdent(48:2-48:3),OpColon(48:4-48:5),UpperIdent(48:6-48:9),Comma(48:9-48:10), +LowerIdent(49:2-49:3),OpColon(49:4-49:5),UpperIdent(49:6-49:9),Comma(49:9-49:10), +CloseCurly(50:1-50:2), +UpperIdent(51:1-51:2),OpColon(51:3-51:4),OpenSquare(51:5-51:6), +UpperIdent(52:2-52:3),Comma(52:3-52:4), +UpperIdent(53:2-53:3),Comma(53:3-53:4), +CloseSquare(54:1-54:2), +LowerIdent(56:1-56:2),OpColon(56:3-56:4),LowerIdent(56:5-56:6),OpArrow(56:7-56:9),LowerIdent(56:10-56:11),KwWhere(56:12-56:17),KwModule(56:18-56:24),NoSpaceOpenRound(56:24-56:25),LowerIdent(56:25-56:26),CloseRound(56:26-56:27),NoSpaceDotUpperIdent(56:27-56:29),Comma(56:29-56:30),KwModule(56:31-56:37),NoSpaceOpenRound(56:37-56:38),LowerIdent(56:38-56:39),CloseRound(56:39-56:40),NoSpaceDotUpperIdent(56:40-56:42), +LowerIdent(58:1-58:2),OpAssign(58:3-58:4),OpBar(58:5-58:6),LowerIdent(58:6-58:7),Comma(58:7-58:8),LowerIdent(58:9-58:10),OpBar(58:10-58:11),OpenCurly(58:12-58:13), +LowerIdent(59:2-59:4),OpAssign(59:5-59:6),OpenCurly(59:7-59:8), +LowerIdent(60:3-60:6),OpColon(60:6-60:7),LowerIdent(60:8-60:9),Comma(60:9-60:10), +LowerIdent(61:3-61:6),OpColon(61:6-61:7),LowerIdent(61:8-61:9),Comma(61:9-61:10), +LowerIdent(62:3-62:6),OpColon(62:6-62:7),OpenCurly(62:8-62:9), +LowerIdent(63:4-63:8),OpColon(63:8-63:9),LowerIdent(63:10-63:11),Comma(63:11-63:12), +LowerIdent(64:4-64:8),OpColon(64:8-64:9),LowerIdent(64:10-64:11),Comma(64:11-64:12), +CloseCurly(65:3-65:4),Comma(65:4-65:5), +CloseCurly(66:2-66:3), +LowerIdent(67:2-67:4),OpAssign(67:5-67:6),LowerIdent(67:7-67:8),NoSpaceOpenRound(67:8-67:9), +LowerIdent(68:3-68:4),Comma(68:4-68:5), +LowerIdent(69:3-69:4),Comma(69:4-69:5), +CloseRound(70:2-70:3), +LowerIdent(71:2-71:4),OpAssign(71:5-71:6),UpperIdent(71:7-71:8),NoSpaceOpenRound(71:8-71:9), +LowerIdent(72:3-72:4),Comma(72:4-72:5), +LowerIdent(73:3-73:4),Comma(73:4-73:5), +CloseRound(74:2-74:3), +LowerIdent(75:2-75:4),OpAssign(75:5-75:6),OpenSquare(75:7-75:8), +LowerIdent(76:3-76:4),Comma(76:4-76:5), +LowerIdent(77:3-77:4),Comma(77:4-77:5), +CloseSquare(78:2-78:3), +LowerIdent(79:2-79:4),OpAssign(79:5-79:6),OpenRound(79:7-79:8), +LowerIdent(80:3-80:4),Comma(80:4-80:5), +LowerIdent(81:3-81:4),Comma(81:4-81:5), +CloseRound(82:2-82:3), +KwMatch(84:2-84:7),LowerIdent(84:8-84:9),OpenCurly(84:10-84:11), +UpperIdent(85:3-85:5),NoSpaceOpenRound(85:5-85:6), +OpenRound(86:4-86:5), +LowerIdent(87:5-87:6),Comma(87:6-87:7), +LowerIdent(88:5-88:6),Comma(88:6-88:7), +CloseRound(89:4-89:5),Comma(89:5-89:6), +CloseRound(90:3-90:4),OpFatArrow(90:5-90:7),LowerIdent(90:8-90:9), +UpperIdent(91:3-91:5),NoSpaceOpenRound(91:5-91:6), +LowerIdent(92:4-92:5),Comma(92:5-92:6), +LowerIdent(93:4-93:5),Comma(93:5-93:6), +CloseRound(94:3-94:4),OpFatArrow(94:5-94:7),LowerIdent(94:8-94:9), +UpperIdent(95:3-95:5),NoSpaceOpenRound(95:5-95:6), +OpenCurly(96:4-96:5), +LowerIdent(97:5-97:6),Comma(97:6-97:7), +LowerIdent(98:5-98:6),Comma(98:6-98:7), +CloseCurly(99:4-99:5),Comma(99:5-99:6), +CloseRound(100:3-100:4),OpFatArrow(100:5-100:7),LowerIdent(100:8-100:9), +UpperIdent(101:3-101:5),NoSpaceOpenRound(101:5-101:6), +OpenSquare(102:4-102:5), +LowerIdent(103:5-103:6),Comma(103:6-103:7), +LowerIdent(104:5-104:6),Comma(104:6-104:7), +CloseSquare(105:4-105:5),Comma(105:5-105:6), +CloseRound(106:3-106:4),OpFatArrow(106:5-106:7),LowerIdent(106:8-106:9), +CloseCurly(107:2-107:3), +CloseCurly(108:1-108:2), +EndOfFile(109:1-109:1), ~~~ # PARSE ~~~clojure -(file @1.1-110.2 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @2.1-108.2 + (type-module @2.1-2.7) (statements - (s-import @4.1-7.2 (raw "I1") + (s-import @2.1-5.2 (raw "I1") (exposing - (exposed-upper-ident @5.2-5.5 (text "I11")) - (exposed-upper-ident @6.2-6.5 (text "I12")))) - (s-import @8.1-11.2 (raw "I2") + (exposed-upper-ident @3.2-3.5 (text "I11")) + (exposed-upper-ident @4.2-4.5 (text "I12")))) + (s-import @6.1-9.2 (raw "I2") (exposing - (exposed-upper-ident @9.2-9.13 (text "I21") (as "Ias1")) - (exposed-upper-ident @10.2-10.13 (text "I22") (as "Ias2")))) - (s-type-decl @14.1-23.11 - (header @14.1-14.5 (name "A") + (exposed-upper-ident @7.2-7.13 (text "I21") (as "Ias1")) + (exposed-upper-ident @8.2-8.13 (text "I22") (as "Ias2")))) + (s-type-decl @12.1-21.11 + (header @12.1-12.5 (name "A") (args - (ty-var @14.3-14.4 (raw "a")))) - (ty-var @14.8-14.9 (raw "a")) - (where - (method @16.3-19.11 (module-of "a") (name "a1") - (args - (ty-tuple @16.18-19.4 - (ty-var @17.4-17.5 (raw "a")) - (ty-var @18.4-18.5 (raw "a")))) - (ty @19.8-19.11 (name "Str"))) - (method @20.3-23.11 (module-of "a") (name "a2") - (args - (ty-tuple @20.18-23.4 - (ty-var @21.4-21.5 (raw "a")) - (ty-var @22.4-22.5 (raw "a")))) - (ty @23.8-23.11 (name "Str"))))) - (s-type-decl @24.1-33.11 - (header @24.1-24.5 (name "B") + (ty-var @12.3-12.4 (raw "a")))) + (ty-var @12.8-12.9 (raw "a"))) + (s-type-decl @22.1-31.11 + (header @22.1-22.5 (name "B") (args - (ty-var @24.3-24.4 (raw "b")))) - (ty-var @24.8-24.9 (raw "b")) - (where - (method @26.3-29.11 (module-of "b") (name "b1") - (args - (ty-tuple @26.18-29.4 - (ty-var @27.4-27.5 (raw "b")) - (ty-var @28.4-28.5 (raw "b")))) - (ty @29.8-29.11 (name "Str"))) - (method @30.3-33.11 (module-of "b") (name "b2") - (args - (ty-tuple @30.18-33.4 - (ty-var @31.4-31.5 (raw "b")) - (ty-var @32.4-32.5 (raw "b")))) - (ty @33.8-33.11 (name "Str"))))) - (s-type-decl @35.1-41.2 - (header @35.1-38.2 (name "C") + (ty-var @22.3-22.4 (raw "b")))) + (ty-var @22.8-22.9 (raw "b"))) + (s-type-decl @33.1-39.2 + (header @33.1-36.2 (name "C") (args - (ty-var @36.2-36.3 (raw "a")) - (ty-var @37.2-37.3 (raw "b")))) - (ty-tuple @38.5-41.2 - (ty-var @39.2-39.3 (raw "a")) - (ty-var @40.2-40.3 (raw "b")))) - (s-type-decl @42.1-48.2 - (header @42.1-45.2 (name "D") + (ty-var @34.2-34.3 (raw "a")) + (ty-var @35.2-35.3 (raw "b")))) + (ty-tuple @36.5-39.2 + (ty-var @37.2-37.3 (raw "a")) + (ty-var @38.2-38.3 (raw "b")))) + (s-type-decl @40.1-46.2 + (header @40.1-43.2 (name "D") (args - (ty-var @43.2-43.3 (raw "a")) - (ty-var @44.2-44.3 (raw "b")))) - (ty-apply @45.5-48.2 - (ty @45.5-45.6 (name "C")) - (ty-var @46.2-46.3 (raw "a")) - (ty-var @47.2-47.3 (raw "b")))) - (s-type-decl @49.1-52.2 - (header @49.1-49.2 (name "E") + (ty-var @41.2-41.3 (raw "a")) + (ty-var @42.2-42.3 (raw "b")))) + (ty-apply @43.5-46.2 + (ty @43.5-43.6 (name "C")) + (ty-var @44.2-44.3 (raw "a")) + (ty-var @45.2-45.3 (raw "b")))) + (s-type-decl @47.1-50.2 + (header @47.1-47.2 (name "E") (args)) - (ty-record @49.5-52.2 - (anno-record-field @50.2-50.9 (name "a") - (ty @50.6-50.9 (name "Str"))) - (anno-record-field @51.2-51.9 (name "b") - (ty @51.6-51.9 (name "Str"))))) - (s-type-decl @53.1-56.2 - (header @53.1-53.2 (name "F") + (ty-record @47.5-50.2 + (anno-record-field @48.2-48.9 (name "a") + (ty @48.6-48.9 (name "Str"))) + (anno-record-field @49.2-49.9 (name "b") + (ty @49.6-49.9 (name "Str"))))) + (s-type-decl @51.1-54.2 + (header @51.1-51.2 (name "F") (args)) - (ty-tag-union @53.5-56.2 + (ty-tag-union @51.5-54.2 (tags - (ty @54.2-54.3 (name "A")) - (ty @55.2-55.3 (name "B"))))) - (s-type-anno @58.1-58.42 (name "g") - (ty-fn @58.5-58.11 - (ty-var @58.5-58.6 (raw "e")) - (ty-var @58.10-58.11 (raw "e"))) + (ty @52.2-52.3 (name "A")) + (ty @53.2-53.3 (name "B"))))) + (s-type-anno @56.1-56.42 (name "g") + (ty-fn @56.5-56.11 + (ty-var @56.5-56.6 (raw "e")) + (ty-var @56.10-56.11 (raw "e"))) (where - (alias @58.18-58.29 (module-of "e") (name "A")) - (alias @58.31-58.42 (module-of "e") (name "B")))) - (s-decl @60.1-110.2 - (p-ident @60.1-60.2 (raw "h")) - (e-lambda @60.5-110.2 + (alias @56.18-56.29 (module-of "e") (name "A")) + (alias @56.31-56.42 (module-of "e") (name "B")))) + (s-decl @58.1-108.2 + (p-ident @58.1-58.2 (raw "h")) + (e-lambda @58.5-108.2 (args - (p-ident @60.6-60.7 (raw "x")) - (p-ident @60.9-60.10 (raw "y"))) - (e-block @60.12-110.2 + (p-ident @58.6-58.7 (raw "x")) + (p-ident @58.9-58.10 (raw "y"))) + (e-block @58.12-108.2 (statements - (s-decl @61.2-68.3 - (p-ident @61.2-61.4 (raw "h1")) - (e-record @61.7-68.3 + (s-decl @59.2-66.3 + (p-ident @59.2-59.4 (raw "h1")) + (e-record @59.7-66.3 (field (field "h11") - (e-ident @62.8-62.9 (raw "x"))) + (e-ident @60.8-60.9 (raw "x"))) (field (field "h12") - (e-ident @63.8-63.9 (raw "x"))) + (e-ident @61.8-61.9 (raw "x"))) (field (field "h13") - (e-record @64.8-67.4 + (e-record @62.8-65.4 (field (field "h131") - (e-ident @65.10-65.11 (raw "x"))) + (e-ident @63.10-63.11 (raw "x"))) (field (field "h132") - (e-ident @66.10-66.11 (raw "y"))))))) - (s-decl @69.2-72.3 - (p-ident @69.2-69.4 (raw "h2")) - (e-apply @69.7-72.3 - (e-ident @69.7-69.8 (raw "h")) - (e-ident @70.3-70.4 (raw "x")) - (e-ident @71.3-71.4 (raw "y")))) - (s-decl @73.2-76.3 - (p-ident @73.2-73.4 (raw "h3")) - (e-apply @73.7-76.3 - (e-tag @73.7-73.8 (raw "A")) - (e-ident @74.3-74.4 (raw "x")) - (e-ident @75.3-75.4 (raw "y")))) - (s-decl @77.2-80.3 - (p-ident @77.2-77.4 (raw "h4")) - (e-list @77.7-80.3 - (e-ident @78.3-78.4 (raw "x")) - (e-ident @79.3-79.4 (raw "y")))) - (s-decl @81.2-84.3 - (p-ident @81.2-81.4 (raw "h5")) - (e-tuple @81.7-84.3 - (e-ident @82.3-82.4 (raw "x")) - (e-ident @83.3-83.4 (raw "y")))) + (e-ident @64.10-64.11 (raw "y"))))))) + (s-decl @67.2-70.3 + (p-ident @67.2-67.4 (raw "h2")) + (e-apply @67.7-70.3 + (e-ident @67.7-67.8 (raw "h")) + (e-ident @68.3-68.4 (raw "x")) + (e-ident @69.3-69.4 (raw "y")))) + (s-decl @71.2-74.3 + (p-ident @71.2-71.4 (raw "h3")) + (e-apply @71.7-74.3 + (e-tag @71.7-71.8 (raw "A")) + (e-ident @72.3-72.4 (raw "x")) + (e-ident @73.3-73.4 (raw "y")))) + (s-decl @75.2-78.3 + (p-ident @75.2-75.4 (raw "h4")) + (e-list @75.7-78.3 + (e-ident @76.3-76.4 (raw "x")) + (e-ident @77.3-77.4 (raw "y")))) + (s-decl @79.2-82.3 + (p-ident @79.2-79.4 (raw "h5")) + (e-tuple @79.7-82.3 + (e-ident @80.3-80.4 (raw "x")) + (e-ident @81.3-81.4 (raw "y")))) (e-match - (e-ident @86.8-86.9 (raw "x")) + (e-ident @84.8-84.9 (raw "x")) (branches - (branch @87.3-92.9 - (p-tag @87.3-92.4 (raw "Z1") - (p-tuple @88.4-91.5 - (p-ident @89.5-89.6 (raw "a")) - (p-ident @90.5-90.6 (raw "b")))) - (e-ident @92.8-92.9 (raw "a"))) - (branch @93.3-96.9 - (p-tag @93.3-96.4 (raw "Z2") - (p-ident @94.4-94.5 (raw "a")) - (p-ident @95.4-95.5 (raw "b"))) - (e-ident @96.8-96.9 (raw "a"))) - (branch @97.3-102.9 - (p-tag @97.3-102.4 (raw "Z3") - (p-record @98.4-101.5 - (field @99.5-99.6 (name "a") (rest false)) - (field @100.5-100.6 (name "b") (rest false)))) - (e-ident @102.8-102.9 (raw "a"))) - (branch @103.3-108.9 - (p-tag @103.3-108.4 (raw "Z4") - (p-list @104.4-107.5 - (p-ident @105.5-105.6 (raw "a")) - (p-ident @106.5-106.6 (raw "b")))) - (e-ident @108.8-108.9 (raw "a"))))))))))) + (branch @85.3-90.9 + (p-tag @85.3-90.4 (raw "Z1") + (p-tuple @86.4-89.5 + (p-ident @87.5-87.6 (raw "a")) + (p-ident @88.5-88.6 (raw "b")))) + (e-ident @90.8-90.9 (raw "a"))) + (branch @91.3-94.9 + (p-tag @91.3-94.4 (raw "Z2") + (p-ident @92.4-92.5 (raw "a")) + (p-ident @93.4-93.5 (raw "b"))) + (e-ident @94.8-94.9 (raw "a"))) + (branch @95.3-100.9 + (p-tag @95.3-100.4 (raw "Z3") + (p-record @96.4-99.5 + (field @97.5-97.6 (name "a") (rest false)) + (field @98.5-98.6 (name "b") (rest false)))) + (e-ident @100.8-100.9 (raw "a"))) + (branch @101.3-106.9 + (p-tag @101.3-106.4 (raw "Z4") + (p-list @102.4-105.5 + (p-ident @103.5-103.6 (raw "a")) + (p-ident @104.5-104.6 (raw "b")))) + (e-ident @106.8-106.9 (raw "a"))))))))))) ~~~ # FORMATTED ~~~roc -NO CHANGE +# Import exposing +# Import exposing +import I1 exposing [ + I11, + I12, +] +import I2 exposing [ + I21 as Ias1, + I22 as Ias2, +] + +# Where constraint +A(a) : a + where + module(a).a1 : ( + a, + a, + ) -> Str, + module(a).a2 : ( + a, + a, + ) -> Str +B(b) : b + where + module(b).b1 : ( + b, + b, + ) -> Str, + module(b).b2 : ( + b, + b, + ) -> Str + +C( + a, + b, +) : ( + a, + b, +) +D( + a, + b, +) : C( + a, + b, +) +E : { + a : Str, + b : Str, +} +F : [ + A, + B, +] + +g : e -> e where module(e).A, module(e).B + +h = |x, y| { + h1 = { + h11: x, + h12: x, + h13: { + h131: x, + h132: y, + }, + } + h2 = h( + x, + y, + ) + h3 = A( + x, + y, + ) + h4 = [ + x, + y, + ] + h5 = ( + x, + y, + ) + + match x { + Z1( + ( + a, + b, + ), + ) => a + Z2( + a, + b, + ) => a + Z3( + { + a, + b, + }, + ) => a + Z4( + [ + a, + b, + ], + ) => a + } +} ~~~ # CANONICALIZE ~~~clojure (can-ir (d-let - (p-assign @60.1-60.2 (ident "h")) - (e-closure @60.5-110.2 + (p-assign @58.1-58.2 (ident "h")) + (e-closure @58.5-108.2 (captures - (capture @60.1-60.2 (ident "h")) - (capture @89.5-89.6 (ident "a")) - (capture @99.5-99.6 (ident "a")) - (capture @94.4-94.5 (ident "a")) - (capture @105.5-105.6 (ident "a"))) - (e-lambda @60.5-110.2 + (capture @103.5-103.6 (ident "a")) + (capture @97.5-97.6 (ident "a")) + (capture @87.5-87.6 (ident "a")) + (capture @58.1-58.2 (ident "h")) + (capture @92.4-92.5 (ident "a"))) + (e-lambda @58.5-108.2 (args - (p-assign @60.6-60.7 (ident "x")) - (p-assign @60.9-60.10 (ident "y"))) - (e-block @60.12-110.2 - (s-let @61.2-68.3 - (p-assign @61.2-61.4 (ident "h1")) - (e-record @61.7-68.3 + (p-assign @58.6-58.7 (ident "x")) + (p-assign @58.9-58.10 (ident "y"))) + (e-block @58.12-108.2 + (s-let @59.2-66.3 + (p-assign @59.2-59.4 (ident "h1")) + (e-record @59.7-66.3 (fields (field (name "h11") - (e-lookup-local @62.8-62.9 - (p-assign @60.6-60.7 (ident "x")))) + (e-lookup-local @60.8-60.9 + (p-assign @58.6-58.7 (ident "x")))) (field (name "h12") - (e-lookup-local @63.8-63.9 - (p-assign @60.6-60.7 (ident "x")))) + (e-lookup-local @61.8-61.9 + (p-assign @58.6-58.7 (ident "x")))) (field (name "h13") - (e-record @64.8-67.4 + (e-record @62.8-65.4 (fields (field (name "h131") - (e-lookup-local @65.10-65.11 - (p-assign @60.6-60.7 (ident "x")))) + (e-lookup-local @63.10-63.11 + (p-assign @58.6-58.7 (ident "x")))) (field (name "h132") - (e-lookup-local @66.10-66.11 - (p-assign @60.9-60.10 (ident "y")))))))))) - (s-let @69.2-72.3 - (p-assign @69.2-69.4 (ident "h2")) - (e-call @69.7-72.3 - (e-lookup-local @69.7-69.8 - (p-assign @60.1-60.2 (ident "h"))) - (e-lookup-local @70.3-70.4 - (p-assign @60.6-60.7 (ident "x"))) - (e-lookup-local @71.3-71.4 - (p-assign @60.9-60.10 (ident "y"))))) - (s-let @73.2-76.3 - (p-assign @73.2-73.4 (ident "h3")) - (e-tag @73.7-76.3 (name "A") + (e-lookup-local @64.10-64.11 + (p-assign @58.9-58.10 (ident "y")))))))))) + (s-let @67.2-70.3 + (p-assign @67.2-67.4 (ident "h2")) + (e-call @67.7-70.3 + (e-lookup-local @67.7-67.8 + (p-assign @58.1-58.2 (ident "h"))) + (e-lookup-local @68.3-68.4 + (p-assign @58.6-58.7 (ident "x"))) + (e-lookup-local @69.3-69.4 + (p-assign @58.9-58.10 (ident "y"))))) + (s-let @71.2-74.3 + (p-assign @71.2-71.4 (ident "h3")) + (e-tag @71.7-74.3 (name "A") (args - (e-lookup-local @74.3-74.4 - (p-assign @60.6-60.7 (ident "x"))) - (e-lookup-local @75.3-75.4 - (p-assign @60.9-60.10 (ident "y")))))) - (s-let @77.2-80.3 - (p-assign @77.2-77.4 (ident "h4")) - (e-list @77.7-80.3 + (e-lookup-local @72.3-72.4 + (p-assign @58.6-58.7 (ident "x"))) + (e-lookup-local @73.3-73.4 + (p-assign @58.9-58.10 (ident "y")))))) + (s-let @75.2-78.3 + (p-assign @75.2-75.4 (ident "h4")) + (e-list @75.7-78.3 (elems - (e-lookup-local @78.3-78.4 - (p-assign @60.6-60.7 (ident "x"))) - (e-lookup-local @79.3-79.4 - (p-assign @60.9-60.10 (ident "y")))))) - (s-let @81.2-84.3 - (p-assign @81.2-81.4 (ident "h5")) - (e-tuple @81.7-84.3 + (e-lookup-local @76.3-76.4 + (p-assign @58.6-58.7 (ident "x"))) + (e-lookup-local @77.3-77.4 + (p-assign @58.9-58.10 (ident "y")))))) + (s-let @79.2-82.3 + (p-assign @79.2-79.4 (ident "h5")) + (e-tuple @79.7-82.3 (elems - (e-lookup-local @82.3-82.4 - (p-assign @60.6-60.7 (ident "x"))) - (e-lookup-local @83.3-83.4 - (p-assign @60.9-60.10 (ident "y")))))) - (e-match @86.2-109.3 - (match @86.2-109.3 + (e-lookup-local @80.3-80.4 + (p-assign @58.6-58.7 (ident "x"))) + (e-lookup-local @81.3-81.4 + (p-assign @58.9-58.10 (ident "y")))))) + (e-match @84.2-107.3 + (match @84.2-107.3 (cond - (e-lookup-local @86.8-86.9 - (p-assign @60.6-60.7 (ident "x")))) + (e-lookup-local @84.8-84.9 + (p-assign @58.6-58.7 (ident "x")))) (branches (branch (patterns (pattern (degenerate false) - (p-applied-tag @87.3-92.4))) + (p-applied-tag @85.3-90.4))) (value - (e-lookup-local @92.8-92.9 - (p-assign @89.5-89.6 (ident "a"))))) + (e-lookup-local @90.8-90.9 + (p-assign @87.5-87.6 (ident "a"))))) (branch (patterns (pattern (degenerate false) - (p-applied-tag @93.3-96.4))) + (p-applied-tag @91.3-94.4))) (value - (e-lookup-local @96.8-96.9 - (p-assign @94.4-94.5 (ident "a"))))) + (e-lookup-local @94.8-94.9 + (p-assign @92.4-92.5 (ident "a"))))) (branch (patterns (pattern (degenerate false) - (p-applied-tag @97.3-102.4))) + (p-applied-tag @95.3-100.4))) (value - (e-lookup-local @102.8-102.9 - (p-assign @99.5-99.6 (ident "a"))))) + (e-lookup-local @100.8-100.9 + (p-assign @97.5-97.6 (ident "a"))))) (branch (patterns (pattern (degenerate false) - (p-applied-tag @103.3-108.4))) + (p-applied-tag @101.3-106.4))) (value - (e-lookup-local @108.8-108.9 - (p-assign @105.5-105.6 (ident "a")))))))))))) - (s-alias-decl @14.1-23.11 - (ty-header @14.1-14.5 (name "A") + (e-lookup-local @106.8-106.9 + (p-assign @103.5-103.6 (ident "a")))))))))))) + (s-alias-decl @12.1-21.11 + (ty-header @12.1-12.5 (name "A") (ty-args - (ty-var @14.3-14.4 (name "a")))) - (ty-var @14.8-14.9 (name "a"))) - (s-alias-decl @24.1-33.11 - (ty-header @24.1-24.5 (name "B") + (ty-rigid-var @12.3-12.4 (name "a")))) + (ty-rigid-var-lookup (ty-rigid-var @12.3-12.4 (name "a")))) + (s-alias-decl @22.1-31.11 + (ty-header @22.1-22.5 (name "B") (ty-args - (ty-var @24.3-24.4 (name "b")))) - (ty-var @24.8-24.9 (name "b"))) - (s-alias-decl @35.1-41.2 - (ty-header @35.1-38.2 (name "C") + (ty-rigid-var @22.3-22.4 (name "b")))) + (ty-rigid-var-lookup (ty-rigid-var @22.3-22.4 (name "b")))) + (s-alias-decl @33.1-39.2 + (ty-header @33.1-36.2 (name "C") (ty-args - (ty-var @36.2-36.3 (name "a")) - (ty-var @37.2-37.3 (name "b")))) - (ty-tuple @38.5-41.2 - (ty-var @39.2-39.3 (name "a")) - (ty-var @40.2-40.3 (name "b")))) - (s-alias-decl @42.1-48.2 - (ty-header @42.1-45.2 (name "D") + (ty-rigid-var @34.2-34.3 (name "a")) + (ty-rigid-var @35.2-35.3 (name "b")))) + (ty-tuple @36.5-39.2 + (ty-rigid-var-lookup (ty-rigid-var @34.2-34.3 (name "a"))) + (ty-rigid-var-lookup (ty-rigid-var @35.2-35.3 (name "b"))))) + (s-alias-decl @40.1-46.2 + (ty-header @40.1-43.2 (name "D") (ty-args - (ty-var @43.2-43.3 (name "a")) - (ty-var @44.2-44.3 (name "b")))) - (ty-apply @45.5-48.2 (symbol "C") - (ty-var @46.2-46.3 (name "a")) - (ty-var @47.2-47.3 (name "b")))) - (s-alias-decl @49.1-52.2 - (ty-header @49.1-49.2 (name "E")) - (ty-record @49.5-52.2 + (ty-rigid-var @41.2-41.3 (name "a")) + (ty-rigid-var @42.2-42.3 (name "b")))) + (ty-apply @43.5-46.2 (name "C") (local) + (ty-rigid-var-lookup (ty-rigid-var @41.2-41.3 (name "a"))) + (ty-rigid-var-lookup (ty-rigid-var @42.2-42.3 (name "b"))))) + (s-alias-decl @47.1-50.2 + (ty-header @47.1-47.2 (name "E")) + (ty-record @47.5-50.2 (field (field "a") - (ty @50.6-50.9 (name "Str"))) + (ty-lookup @48.6-48.9 (name "Str") (builtin))) (field (field "b") - (ty @51.6-51.9 (name "Str"))))) - (s-alias-decl @53.1-56.2 - (ty-header @53.1-53.2 (name "F")) - (ty-tag-union @53.5-56.2 - (ty @54.2-54.3 (name "A")) - (ty @55.2-55.3 (name "B")))) - (s-import @4.1-7.2 (module "I1") + (ty-lookup @49.6-49.9 (name "Str") (builtin))))) + (s-alias-decl @51.1-54.2 + (ty-header @51.1-51.2 (name "F")) + (ty-tag-union @51.5-54.2 + (ty-tag-name @52.2-52.3 (name "A")) + (ty-tag-name @53.2-53.3 (name "B")))) + (s-import @2.1-5.2 (module "I1") (exposes (exposed (name "I11") (wildcard false)) (exposed (name "I12") (wildcard false)))) - (s-import @8.1-11.2 (module "I2") + (s-import @6.1-9.2 (module "I2") (exposes (exposed (name "I21") (alias "Ias1") (wildcard false)) (exposed (name "I22") (alias "Ias2") (wildcard false)))) - (s-type-anno @58.1-58.42 (name "g") - (ty-fn @58.5-58.11 (effectful false) - (ty-var @58.5-58.6 (name "e")) - (ty-var @58.10-58.11 (name "e"))) + (s-type-anno @56.1-56.42 (name "g") + (ty-fn @56.5-56.11 (effectful false) + (ty-rigid-var @56.5-56.6 (name "e")) + (ty-rigid-var-lookup (ty-rigid-var @56.5-56.6 (name "e")))) (where - (alias @58.18-58.29 (module-of "e") (ident "A")) - (alias @58.31-58.42 (module-of "e") (ident "B")))) - (ext-decl @58.18-58.29 (ident "module(e).A") (kind "type")) - (ext-decl @58.31-58.42 (ident "module(e).B") (kind "type"))) + (alias @56.18-56.29 (module-of "e") (ident "A")) + (alias @56.31-56.42 (module-of "e") (ident "B")))) + (ext-decl @56.18-56.29 (ident "module(e).A") (kind "type")) + (ext-decl @56.31-56.42 (ident "module(e).B") (kind "type"))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @60.1-60.2 (type "[Z1((field, field2)), Z2(c, d), Z3(f), Z4(List(elem))]others, [Z1((field3, field4)), Z2(i, j), Z3(k), Z4(List(elem2))]others2 -> _ret"))) + (patt @58.1-58.2 (type "[Z1((c, d)), Z2(c, f), Z3({ a: c, b: i }), Z4(List(c))]j, [Z1((c, d)), Z2(c, f), Z3({ a: c, b: i }), Z4(List(c))]j -> c"))) (type_decls - (alias @14.1-23.11 (type "A(a)") - (ty-header @14.1-14.5 (name "A") + (alias @12.1-21.11 (type "A(a)") + (ty-header @12.1-12.5 (name "A") (ty-args - (ty-var @14.3-14.4 (name "a"))))) - (alias @24.1-33.11 (type "B(b)") - (ty-header @24.1-24.5 (name "B") + (ty-rigid-var @12.3-12.4 (name "a"))))) + (alias @22.1-31.11 (type "B(b)") + (ty-header @22.1-22.5 (name "B") (ty-args - (ty-var @24.3-24.4 (name "b"))))) - (alias @35.1-41.2 (type "C(a, b)") - (ty-header @35.1-38.2 (name "C") + (ty-rigid-var @22.3-22.4 (name "b"))))) + (alias @33.1-39.2 (type "C(a, b)") + (ty-header @33.1-36.2 (name "C") (ty-args - (ty-var @36.2-36.3 (name "a")) - (ty-var @37.2-37.3 (name "b"))))) - (alias @42.1-48.2 (type "D(a, b)") - (ty-header @42.1-45.2 (name "D") + (ty-rigid-var @34.2-34.3 (name "a")) + (ty-rigid-var @35.2-35.3 (name "b"))))) + (alias @40.1-46.2 (type "D(a, b)") + (ty-header @40.1-43.2 (name "D") (ty-args - (ty-var @43.2-43.3 (name "a")) - (ty-var @44.2-44.3 (name "b"))))) - (alias @49.1-52.2 (type "E") - (ty-header @49.1-49.2 (name "E"))) - (alias @53.1-56.2 (type "F") - (ty-header @53.1-53.2 (name "F")))) + (ty-rigid-var @41.2-41.3 (name "a")) + (ty-rigid-var @42.2-42.3 (name "b"))))) + (alias @47.1-50.2 (type "E") + (ty-header @47.1-47.2 (name "E"))) + (alias @51.1-54.2 (type "F") + (ty-header @51.1-51.2 (name "F")))) (expressions - (expr @60.5-110.2 (type "[Z1((field, field2)), Z2(c, d), Z3(f), Z4(List(elem))]others, [Z1((field3, field4)), Z2(i, j), Z3(k), Z4(List(elem2))]others2 -> _ret")))) + (expr @58.5-108.2 (type "[Z1((c, d)), Z2(c, f), Z3({ a: c, b: i }), Z4(List(c))]j, [Z1((c, d)), Z2(c, f), Z3({ a: c, b: i }), Z4(List(c))]j -> c")))) ~~~ diff --git a/test/snapshots/formatting/multiline/module.md b/test/snapshots/formatting/multiline/module.md index 1c83587087..4cda8284b4 100644 --- a/test/snapshots/formatting/multiline/module.md +++ b/test/snapshots/formatting/multiline/module.md @@ -1,11 +1,10 @@ # META ~~~ini description=Multiline formatting module -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [ a, b, ] @@ -14,57 +13,119 @@ a = 'a' b = 'a' ~~~ # EXPECTED -NIL +PARSE ERROR - module.md:1:2:1:3 +PARSE ERROR - module.md:1:3:1:4 +PARSE ERROR - module.md:2:2:2:3 +PARSE ERROR - module.md:2:3:2:4 +PARSE ERROR - module.md:3:1:3:2 # PROBLEMS -NIL +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**module.md:1:2:1:3:** +```roc + a, +``` + ^ + + +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**module.md:1:3:1:4:** +```roc + a, +``` + ^ + + +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**module.md:2:2:2:3:** +```roc + b, +``` + ^ + + +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**module.md:2:3:2:4:** +```roc + b, +``` + ^ + + +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**module.md:3:1:3:2:** +```roc +] +``` +^ + + # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9), +LowerIdent(1:2-1:3),Comma(1:3-1:4), LowerIdent(2:2-2:3),Comma(2:3-2:4), -LowerIdent(3:2-3:3),Comma(3:3-3:4), -CloseSquare(4:1-4:2), +CloseSquare(3:1-3:2), +LowerIdent(5:1-5:2),OpAssign(5:3-5:4),SingleQuote(5:5-5:8), LowerIdent(6:1-6:2),OpAssign(6:3-6:4),SingleQuote(6:5-6:8), -LowerIdent(7:1-7:2),OpAssign(7:3-7:4),SingleQuote(7:5-7:8), -EndOfFile(8:1-8:1), +EndOfFile(7:1-7:1), ~~~ # PARSE ~~~clojure -(file @1.1-7.8 - (module @1.1-4.2 - (exposes @1.8-4.2 - (exposed-lower-ident @2.2-2.3 - (text "a")) - (exposed-lower-ident @3.2-3.3 - (text "b")))) +(file @1.2-6.8 + (type-module @1.2-1.3) (statements + (s-malformed @1.2-1.3 (tag "statement_unexpected_token")) + (s-malformed @1.3-1.4 (tag "statement_unexpected_token")) + (s-malformed @2.2-2.3 (tag "statement_unexpected_token")) + (s-malformed @2.3-2.4 (tag "statement_unexpected_token")) + (s-malformed @3.1-3.2 (tag "statement_unexpected_token")) + (s-decl @5.1-5.8 + (p-ident @5.1-5.2 (raw "a")) + (e-single-quote @5.5-5.8 (raw "'a'"))) (s-decl @6.1-6.8 - (p-ident @6.1-6.2 (raw "a")) - (e-single-quote @6.5-6.8 (raw "'a'"))) - (s-decl @7.1-7.8 - (p-ident @7.1-7.2 (raw "b")) - (e-single-quote @7.5-7.8 (raw "'a'"))))) + (p-ident @6.1-6.2 (raw "b")) + (e-single-quote @6.5-6.8 (raw "'a'"))))) ~~~ # FORMATTED ~~~roc -NO CHANGE + + + + +a = 'a' +b = 'a' ~~~ # CANONICALIZE ~~~clojure (can-ir (d-let - (p-assign @6.1-6.2 (ident "a")) - (e-int @6.5-6.8 (value "97"))) + (p-assign @5.1-5.2 (ident "a")) + (e-num @5.5-5.8 (value "97"))) (d-let - (p-assign @7.1-7.2 (ident "b")) - (e-int @7.5-7.8 (value "97")))) + (p-assign @6.1-6.2 (ident "b")) + (e-num @6.5-6.8 (value "97")))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @6.1-6.2 (type "Num(_size)")) - (patt @7.1-7.2 (type "Num(_size)"))) + (patt @5.1-5.2 (type "Num(Int(_size))")) + (patt @6.1-6.2 (type "Num(Int(_size))"))) (expressions - (expr @6.5-6.8 (type "Num(_size)")) - (expr @7.5-7.8 (type "Num(_size)")))) + (expr @5.5-5.8 (type "Num(Int(_size))")) + (expr @6.5-6.8 (type "Num(Int(_size))")))) ~~~ diff --git a/test/snapshots/formatting/multiline_without_comma/everything.md b/test/snapshots/formatting/multiline_without_comma/everything.md index 6e426f39ca..88aa49f301 100644 --- a/test/snapshots/formatting/multiline_without_comma/everything.md +++ b/test/snapshots/formatting/multiline_without_comma/everything.md @@ -1,12 +1,10 @@ # META ~~~ini description=Multiline without comma formatting everything -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - # Import exposing import I1 exposing [ I11, @@ -117,25 +115,25 @@ h = |x, y| { } ~~~ # EXPECTED -WHERE CLAUSE NOT ALLOWED IN TYPE DECLARATION - everything.md:14:1:23:11 -WHERE CLAUSE NOT ALLOWED IN TYPE DECLARATION - everything.md:24:1:33:11 -MODULE NOT FOUND - everything.md:4:1:7:2 -MODULE NOT FOUND - everything.md:8:1:11:2 -UNUSED VARIABLE - everything.md:90:5:90:6 -UNUSED VARIABLE - everything.md:95:4:95:5 -UNUSED VARIABLE - everything.md:100:5:100:6 -UNUSED VARIABLE - everything.md:106:5:106:6 -UNUSED VARIABLE - everything.md:61:2:61:4 -UNUSED VARIABLE - everything.md:69:2:69:4 -UNUSED VARIABLE - everything.md:73:2:73:4 -UNUSED VARIABLE - everything.md:77:2:77:4 -UNUSED VARIABLE - everything.md:81:2:81:4 +WHERE CLAUSE NOT ALLOWED IN TYPE DECLARATION - everything.md:12:1:21:11 +WHERE CLAUSE NOT ALLOWED IN TYPE DECLARATION - everything.md:22:1:31:11 +MODULE NOT FOUND - everything.md:2:1:5:2 +MODULE NOT FOUND - everything.md:6:1:9:2 +UNUSED VARIABLE - everything.md:88:5:88:6 +UNUSED VARIABLE - everything.md:93:4:93:5 +UNUSED VARIABLE - everything.md:98:5:98:6 +UNUSED VARIABLE - everything.md:104:5:104:6 +UNUSED VARIABLE - everything.md:59:2:59:4 +UNUSED VARIABLE - everything.md:67:2:67:4 +UNUSED VARIABLE - everything.md:71:2:71:4 +UNUSED VARIABLE - everything.md:75:2:75:4 +UNUSED VARIABLE - everything.md:79:2:79:4 # PROBLEMS **WHERE CLAUSE NOT ALLOWED IN TYPE DECLARATION** You cannot define a `where` clause inside a type declaration. You're attempting do this here: -**everything.md:14:1:23:11:** +**everything.md:12:1:21:11:** ```roc A(a) : a where @@ -154,7 +152,7 @@ A(a) : a You cannot define a `where` clause inside a type declaration. You're attempting do this here: -**everything.md:24:1:33:11:** +**everything.md:22:1:31:11:** ```roc B(b) : b where @@ -173,7 +171,7 @@ B(b) : b The module `I1` was not found in this Roc project. You're attempting to use this module here: -**everything.md:4:1:7:2:** +**everything.md:2:1:5:2:** ```roc import I1 exposing [ I11, @@ -186,7 +184,7 @@ import I1 exposing [ The module `I2` was not found in this Roc project. You're attempting to use this module here: -**everything.md:8:1:11:2:** +**everything.md:6:1:9:2:** ```roc import I2 exposing [ I21 as Ias1, @@ -200,7 +198,7 @@ Variable `b` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_b` to suppress this warning. The unused variable is declared here: -**everything.md:90:5:90:6:** +**everything.md:88:5:88:6:** ```roc b ``` @@ -212,7 +210,7 @@ Variable `b` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_b` to suppress this warning. The unused variable is declared here: -**everything.md:95:4:95:5:** +**everything.md:93:4:93:5:** ```roc b ``` @@ -224,7 +222,7 @@ Variable `b` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_b` to suppress this warning. The unused variable is declared here: -**everything.md:100:5:100:6:** +**everything.md:98:5:98:6:** ```roc b ``` @@ -236,7 +234,7 @@ Variable `b` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_b` to suppress this warning. The unused variable is declared here: -**everything.md:106:5:106:6:** +**everything.md:104:5:104:6:** ```roc b ``` @@ -248,7 +246,7 @@ Variable `h1` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_h1` to suppress this warning. The unused variable is declared here: -**everything.md:61:2:61:4:** +**everything.md:59:2:59:4:** ```roc h1 = { ``` @@ -260,7 +258,7 @@ Variable `h2` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_h2` to suppress this warning. The unused variable is declared here: -**everything.md:69:2:69:4:** +**everything.md:67:2:67:4:** ```roc h2 = h( ``` @@ -272,7 +270,7 @@ Variable `h3` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_h3` to suppress this warning. The unused variable is declared here: -**everything.md:73:2:73:4:** +**everything.md:71:2:71:4:** ```roc h3 = A( ``` @@ -284,7 +282,7 @@ Variable `h4` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_h4` to suppress this warning. The unused variable is declared here: -**everything.md:77:2:77:4:** +**everything.md:75:2:75:4:** ```roc h4 = [ ``` @@ -296,7 +294,7 @@ Variable `h5` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_h5` to suppress this warning. The unused variable is declared here: -**everything.md:81:2:81:4:** +**everything.md:79:2:79:4:** ```roc h5 = ( ``` @@ -305,273 +303,244 @@ The unused variable is declared here: # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -KwImport(4:1-4:7),UpperIdent(4:8-4:10),KwExposing(4:11-4:19),OpenSquare(4:20-4:21), -UpperIdent(5:2-5:5),Comma(5:5-5:6), -UpperIdent(6:2-6:5), -CloseSquare(7:1-7:2), -KwImport(8:1-8:7),UpperIdent(8:8-8:10),KwExposing(8:11-8:19),OpenSquare(8:20-8:21), -UpperIdent(9:2-9:5),KwAs(9:6-9:8),UpperIdent(9:9-9:13),Comma(9:13-9:14), -UpperIdent(10:2-10:5),KwAs(10:6-10:8),UpperIdent(10:9-10:13), -CloseSquare(11:1-11:2), -UpperIdent(14:1-14:2),NoSpaceOpenRound(14:2-14:3),LowerIdent(14:3-14:4),CloseRound(14:4-14:5),OpColon(14:6-14:7),LowerIdent(14:8-14:9), -KwWhere(15:2-15:7), -KwModule(16:3-16:9),NoSpaceOpenRound(16:9-16:10),LowerIdent(16:10-16:11),CloseRound(16:11-16:12),NoSpaceDotLowerIdent(16:12-16:15),OpColon(16:16-16:17),OpenRound(16:18-16:19), -LowerIdent(17:4-17:5),Comma(17:5-17:6), -LowerIdent(18:4-18:5), -CloseRound(19:3-19:4),OpArrow(19:5-19:7),UpperIdent(19:8-19:11),Comma(19:11-19:12), -KwModule(20:3-20:9),NoSpaceOpenRound(20:9-20:10),LowerIdent(20:10-20:11),CloseRound(20:11-20:12),NoSpaceDotLowerIdent(20:12-20:15),OpColon(20:16-20:17),OpenRound(20:18-20:19), -LowerIdent(21:4-21:5),Comma(21:5-21:6), -LowerIdent(22:4-22:5), -CloseRound(23:3-23:4),OpArrow(23:5-23:7),UpperIdent(23:8-23:11), -UpperIdent(24:1-24:2),NoSpaceOpenRound(24:2-24:3),LowerIdent(24:3-24:4),CloseRound(24:4-24:5),OpColon(24:6-24:7),LowerIdent(24:8-24:9), -KwWhere(25:2-25:7), -KwModule(26:3-26:9),NoSpaceOpenRound(26:9-26:10),LowerIdent(26:10-26:11),CloseRound(26:11-26:12),NoSpaceDotLowerIdent(26:12-26:15),OpColon(26:16-26:17),OpenRound(26:18-26:19), -LowerIdent(27:4-27:5),Comma(27:5-27:6), -LowerIdent(28:4-28:5), -CloseRound(29:3-29:4),OpArrow(29:5-29:7),UpperIdent(29:8-29:11),Comma(29:11-29:12), -KwModule(30:3-30:9),NoSpaceOpenRound(30:9-30:10),LowerIdent(30:10-30:11),CloseRound(30:11-30:12),NoSpaceDotLowerIdent(30:12-30:15),OpColon(30:16-30:17),OpenRound(30:18-30:19), -LowerIdent(31:4-31:5),Comma(31:5-31:6), -LowerIdent(32:4-32:5), -CloseRound(33:3-33:4),OpArrow(33:5-33:7),UpperIdent(33:8-33:11), -UpperIdent(35:1-35:2),NoSpaceOpenRound(35:2-35:3), -LowerIdent(36:2-36:3),Comma(36:3-36:4), -LowerIdent(37:2-37:3), -CloseRound(38:1-38:2),OpColon(38:3-38:4),OpenRound(38:5-38:6), -LowerIdent(39:2-39:3),Comma(39:3-39:4), -LowerIdent(40:2-40:3), -CloseRound(41:1-41:2), -UpperIdent(42:1-42:2),NoSpaceOpenRound(42:2-42:3), -LowerIdent(43:2-43:3),Comma(43:3-43:4), -LowerIdent(44:2-44:3), -CloseRound(45:1-45:2),OpColon(45:3-45:4),UpperIdent(45:5-45:6),NoSpaceOpenRound(45:6-45:7), -LowerIdent(46:2-46:3),Comma(46:3-46:4), -LowerIdent(47:2-47:3), -CloseRound(48:1-48:2), -UpperIdent(49:1-49:2),OpColon(49:3-49:4),OpenCurly(49:5-49:6), -LowerIdent(50:2-50:3),OpColon(50:4-50:5),UpperIdent(50:6-50:9),Comma(50:9-50:10), -LowerIdent(51:2-51:3),OpColon(51:4-51:5),UpperIdent(51:6-51:9), -CloseCurly(52:1-52:2), -UpperIdent(53:1-53:2),OpColon(53:3-53:4),OpenSquare(53:5-53:6), -UpperIdent(54:2-54:3),Comma(54:3-54:4), -UpperIdent(55:2-55:3), -CloseSquare(56:1-56:2), -LowerIdent(58:1-58:2),OpColon(58:3-58:4),LowerIdent(58:5-58:6),OpArrow(58:7-58:9),LowerIdent(58:10-58:11),KwWhere(58:12-58:17),KwModule(58:18-58:24),NoSpaceOpenRound(58:24-58:25),LowerIdent(58:25-58:26),CloseRound(58:26-58:27),NoSpaceDotUpperIdent(58:27-58:29),Comma(58:29-58:30),KwModule(58:31-58:37),NoSpaceOpenRound(58:37-58:38),LowerIdent(58:38-58:39),CloseRound(58:39-58:40),NoSpaceDotUpperIdent(58:40-58:42), -LowerIdent(60:1-60:2),OpAssign(60:3-60:4),OpBar(60:5-60:6),LowerIdent(60:6-60:7),Comma(60:7-60:8),LowerIdent(60:9-60:10),OpBar(60:10-60:11),OpenCurly(60:12-60:13), -LowerIdent(61:2-61:4),OpAssign(61:5-61:6),OpenCurly(61:7-61:8), -LowerIdent(62:3-62:6),OpColon(62:6-62:7),LowerIdent(62:8-62:9),Comma(62:9-62:10), -LowerIdent(63:3-63:6),OpColon(63:6-63:7),LowerIdent(63:8-63:9),Comma(63:9-63:10), -LowerIdent(64:3-64:6),OpColon(64:6-64:7),OpenCurly(64:8-64:9), -LowerIdent(65:4-65:8),OpColon(65:8-65:9),LowerIdent(65:10-65:11),Comma(65:11-65:12), -LowerIdent(66:4-66:8),OpColon(66:8-66:9),LowerIdent(66:10-66:11), -CloseCurly(67:3-67:4), -CloseCurly(68:2-68:3), -LowerIdent(69:2-69:4),OpAssign(69:5-69:6),LowerIdent(69:7-69:8),NoSpaceOpenRound(69:8-69:9), -LowerIdent(70:3-70:4),Comma(70:4-70:5), -LowerIdent(71:3-71:4), -CloseRound(72:2-72:3), -LowerIdent(73:2-73:4),OpAssign(73:5-73:6),UpperIdent(73:7-73:8),NoSpaceOpenRound(73:8-73:9), -LowerIdent(74:3-74:4),Comma(74:4-74:5), -LowerIdent(75:3-75:4), -CloseRound(76:2-76:3), -LowerIdent(77:2-77:4),OpAssign(77:5-77:6),OpenSquare(77:7-77:8), -LowerIdent(78:3-78:4),Comma(78:4-78:5), -LowerIdent(79:3-79:4), -CloseSquare(80:2-80:3), -LowerIdent(81:2-81:4),OpAssign(81:5-81:6),OpenRound(81:7-81:8), -LowerIdent(82:3-82:4),Comma(82:4-82:5), -LowerIdent(83:3-83:4), -CloseRound(84:2-84:3), -KwMatch(86:2-86:7),LowerIdent(86:8-86:9),OpenCurly(86:10-86:11), -UpperIdent(87:3-87:5),NoSpaceOpenRound(87:5-87:6), -OpenRound(88:4-88:5), -LowerIdent(89:5-89:6),Comma(89:6-89:7), -LowerIdent(90:5-90:6), -CloseRound(91:4-91:5), -CloseRound(92:3-92:4),OpFatArrow(92:5-92:7),LowerIdent(92:8-92:9), -UpperIdent(93:3-93:5),NoSpaceOpenRound(93:5-93:6), -LowerIdent(94:4-94:5),Comma(94:5-94:6), -LowerIdent(95:4-95:5), -CloseRound(96:3-96:4),OpFatArrow(96:5-96:7),LowerIdent(96:8-96:9), -UpperIdent(97:3-97:5),NoSpaceOpenRound(97:5-97:6), -OpenCurly(98:4-98:5), -LowerIdent(99:5-99:6),Comma(99:6-99:7), -LowerIdent(100:5-100:6), -CloseCurly(101:4-101:5), -CloseRound(102:3-102:4),OpFatArrow(102:5-102:7),LowerIdent(102:8-102:9), -UpperIdent(103:3-103:5),NoSpaceOpenRound(103:5-103:6), -OpenSquare(104:4-104:5), -LowerIdent(105:5-105:6),Comma(105:6-105:7), -LowerIdent(106:5-106:6), -CloseSquare(107:4-107:5), -CloseRound(108:3-108:4),OpFatArrow(108:5-108:7),LowerIdent(108:8-108:9), -CloseCurly(109:2-109:3), -CloseCurly(110:1-110:2), -EndOfFile(111:1-111:1), +KwImport(2:1-2:7),UpperIdent(2:8-2:10),KwExposing(2:11-2:19),OpenSquare(2:20-2:21), +UpperIdent(3:2-3:5),Comma(3:5-3:6), +UpperIdent(4:2-4:5), +CloseSquare(5:1-5:2), +KwImport(6:1-6:7),UpperIdent(6:8-6:10),KwExposing(6:11-6:19),OpenSquare(6:20-6:21), +UpperIdent(7:2-7:5),KwAs(7:6-7:8),UpperIdent(7:9-7:13),Comma(7:13-7:14), +UpperIdent(8:2-8:5),KwAs(8:6-8:8),UpperIdent(8:9-8:13), +CloseSquare(9:1-9:2), +UpperIdent(12:1-12:2),NoSpaceOpenRound(12:2-12:3),LowerIdent(12:3-12:4),CloseRound(12:4-12:5),OpColon(12:6-12:7),LowerIdent(12:8-12:9), +KwWhere(13:2-13:7), +KwModule(14:3-14:9),NoSpaceOpenRound(14:9-14:10),LowerIdent(14:10-14:11),CloseRound(14:11-14:12),NoSpaceDotLowerIdent(14:12-14:15),OpColon(14:16-14:17),OpenRound(14:18-14:19), +LowerIdent(15:4-15:5),Comma(15:5-15:6), +LowerIdent(16:4-16:5), +CloseRound(17:3-17:4),OpArrow(17:5-17:7),UpperIdent(17:8-17:11),Comma(17:11-17:12), +KwModule(18:3-18:9),NoSpaceOpenRound(18:9-18:10),LowerIdent(18:10-18:11),CloseRound(18:11-18:12),NoSpaceDotLowerIdent(18:12-18:15),OpColon(18:16-18:17),OpenRound(18:18-18:19), +LowerIdent(19:4-19:5),Comma(19:5-19:6), +LowerIdent(20:4-20:5), +CloseRound(21:3-21:4),OpArrow(21:5-21:7),UpperIdent(21:8-21:11), +UpperIdent(22:1-22:2),NoSpaceOpenRound(22:2-22:3),LowerIdent(22:3-22:4),CloseRound(22:4-22:5),OpColon(22:6-22:7),LowerIdent(22:8-22:9), +KwWhere(23:2-23:7), +KwModule(24:3-24:9),NoSpaceOpenRound(24:9-24:10),LowerIdent(24:10-24:11),CloseRound(24:11-24:12),NoSpaceDotLowerIdent(24:12-24:15),OpColon(24:16-24:17),OpenRound(24:18-24:19), +LowerIdent(25:4-25:5),Comma(25:5-25:6), +LowerIdent(26:4-26:5), +CloseRound(27:3-27:4),OpArrow(27:5-27:7),UpperIdent(27:8-27:11),Comma(27:11-27:12), +KwModule(28:3-28:9),NoSpaceOpenRound(28:9-28:10),LowerIdent(28:10-28:11),CloseRound(28:11-28:12),NoSpaceDotLowerIdent(28:12-28:15),OpColon(28:16-28:17),OpenRound(28:18-28:19), +LowerIdent(29:4-29:5),Comma(29:5-29:6), +LowerIdent(30:4-30:5), +CloseRound(31:3-31:4),OpArrow(31:5-31:7),UpperIdent(31:8-31:11), +UpperIdent(33:1-33:2),NoSpaceOpenRound(33:2-33:3), +LowerIdent(34:2-34:3),Comma(34:3-34:4), +LowerIdent(35:2-35:3), +CloseRound(36:1-36:2),OpColon(36:3-36:4),OpenRound(36:5-36:6), +LowerIdent(37:2-37:3),Comma(37:3-37:4), +LowerIdent(38:2-38:3), +CloseRound(39:1-39:2), +UpperIdent(40:1-40:2),NoSpaceOpenRound(40:2-40:3), +LowerIdent(41:2-41:3),Comma(41:3-41:4), +LowerIdent(42:2-42:3), +CloseRound(43:1-43:2),OpColon(43:3-43:4),UpperIdent(43:5-43:6),NoSpaceOpenRound(43:6-43:7), +LowerIdent(44:2-44:3),Comma(44:3-44:4), +LowerIdent(45:2-45:3), +CloseRound(46:1-46:2), +UpperIdent(47:1-47:2),OpColon(47:3-47:4),OpenCurly(47:5-47:6), +LowerIdent(48:2-48:3),OpColon(48:4-48:5),UpperIdent(48:6-48:9),Comma(48:9-48:10), +LowerIdent(49:2-49:3),OpColon(49:4-49:5),UpperIdent(49:6-49:9), +CloseCurly(50:1-50:2), +UpperIdent(51:1-51:2),OpColon(51:3-51:4),OpenSquare(51:5-51:6), +UpperIdent(52:2-52:3),Comma(52:3-52:4), +UpperIdent(53:2-53:3), +CloseSquare(54:1-54:2), +LowerIdent(56:1-56:2),OpColon(56:3-56:4),LowerIdent(56:5-56:6),OpArrow(56:7-56:9),LowerIdent(56:10-56:11),KwWhere(56:12-56:17),KwModule(56:18-56:24),NoSpaceOpenRound(56:24-56:25),LowerIdent(56:25-56:26),CloseRound(56:26-56:27),NoSpaceDotUpperIdent(56:27-56:29),Comma(56:29-56:30),KwModule(56:31-56:37),NoSpaceOpenRound(56:37-56:38),LowerIdent(56:38-56:39),CloseRound(56:39-56:40),NoSpaceDotUpperIdent(56:40-56:42), +LowerIdent(58:1-58:2),OpAssign(58:3-58:4),OpBar(58:5-58:6),LowerIdent(58:6-58:7),Comma(58:7-58:8),LowerIdent(58:9-58:10),OpBar(58:10-58:11),OpenCurly(58:12-58:13), +LowerIdent(59:2-59:4),OpAssign(59:5-59:6),OpenCurly(59:7-59:8), +LowerIdent(60:3-60:6),OpColon(60:6-60:7),LowerIdent(60:8-60:9),Comma(60:9-60:10), +LowerIdent(61:3-61:6),OpColon(61:6-61:7),LowerIdent(61:8-61:9),Comma(61:9-61:10), +LowerIdent(62:3-62:6),OpColon(62:6-62:7),OpenCurly(62:8-62:9), +LowerIdent(63:4-63:8),OpColon(63:8-63:9),LowerIdent(63:10-63:11),Comma(63:11-63:12), +LowerIdent(64:4-64:8),OpColon(64:8-64:9),LowerIdent(64:10-64:11), +CloseCurly(65:3-65:4), +CloseCurly(66:2-66:3), +LowerIdent(67:2-67:4),OpAssign(67:5-67:6),LowerIdent(67:7-67:8),NoSpaceOpenRound(67:8-67:9), +LowerIdent(68:3-68:4),Comma(68:4-68:5), +LowerIdent(69:3-69:4), +CloseRound(70:2-70:3), +LowerIdent(71:2-71:4),OpAssign(71:5-71:6),UpperIdent(71:7-71:8),NoSpaceOpenRound(71:8-71:9), +LowerIdent(72:3-72:4),Comma(72:4-72:5), +LowerIdent(73:3-73:4), +CloseRound(74:2-74:3), +LowerIdent(75:2-75:4),OpAssign(75:5-75:6),OpenSquare(75:7-75:8), +LowerIdent(76:3-76:4),Comma(76:4-76:5), +LowerIdent(77:3-77:4), +CloseSquare(78:2-78:3), +LowerIdent(79:2-79:4),OpAssign(79:5-79:6),OpenRound(79:7-79:8), +LowerIdent(80:3-80:4),Comma(80:4-80:5), +LowerIdent(81:3-81:4), +CloseRound(82:2-82:3), +KwMatch(84:2-84:7),LowerIdent(84:8-84:9),OpenCurly(84:10-84:11), +UpperIdent(85:3-85:5),NoSpaceOpenRound(85:5-85:6), +OpenRound(86:4-86:5), +LowerIdent(87:5-87:6),Comma(87:6-87:7), +LowerIdent(88:5-88:6), +CloseRound(89:4-89:5), +CloseRound(90:3-90:4),OpFatArrow(90:5-90:7),LowerIdent(90:8-90:9), +UpperIdent(91:3-91:5),NoSpaceOpenRound(91:5-91:6), +LowerIdent(92:4-92:5),Comma(92:5-92:6), +LowerIdent(93:4-93:5), +CloseRound(94:3-94:4),OpFatArrow(94:5-94:7),LowerIdent(94:8-94:9), +UpperIdent(95:3-95:5),NoSpaceOpenRound(95:5-95:6), +OpenCurly(96:4-96:5), +LowerIdent(97:5-97:6),Comma(97:6-97:7), +LowerIdent(98:5-98:6), +CloseCurly(99:4-99:5), +CloseRound(100:3-100:4),OpFatArrow(100:5-100:7),LowerIdent(100:8-100:9), +UpperIdent(101:3-101:5),NoSpaceOpenRound(101:5-101:6), +OpenSquare(102:4-102:5), +LowerIdent(103:5-103:6),Comma(103:6-103:7), +LowerIdent(104:5-104:6), +CloseSquare(105:4-105:5), +CloseRound(106:3-106:4),OpFatArrow(106:5-106:7),LowerIdent(106:8-106:9), +CloseCurly(107:2-107:3), +CloseCurly(108:1-108:2), +EndOfFile(109:1-109:1), ~~~ # PARSE ~~~clojure -(file @1.1-110.2 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @2.1-108.2 + (type-module @2.1-2.7) (statements - (s-import @4.1-7.2 (raw "I1") + (s-import @2.1-5.2 (raw "I1") (exposing - (exposed-upper-ident @5.2-5.5 (text "I11")) - (exposed-upper-ident @6.2-6.5 (text "I12")))) - (s-import @8.1-11.2 (raw "I2") + (exposed-upper-ident @3.2-3.5 (text "I11")) + (exposed-upper-ident @4.2-4.5 (text "I12")))) + (s-import @6.1-9.2 (raw "I2") (exposing - (exposed-upper-ident @9.2-9.13 (text "I21") (as "Ias1")) - (exposed-upper-ident @10.2-10.13 (text "I22") (as "Ias2")))) - (s-type-decl @14.1-23.11 - (header @14.1-14.5 (name "A") + (exposed-upper-ident @7.2-7.13 (text "I21") (as "Ias1")) + (exposed-upper-ident @8.2-8.13 (text "I22") (as "Ias2")))) + (s-type-decl @12.1-21.11 + (header @12.1-12.5 (name "A") (args - (ty-var @14.3-14.4 (raw "a")))) - (ty-var @14.8-14.9 (raw "a")) - (where - (method @16.3-19.11 (module-of "a") (name "a1") - (args - (ty-tuple @16.18-19.4 - (ty-var @17.4-17.5 (raw "a")) - (ty-var @18.4-18.5 (raw "a")))) - (ty @19.8-19.11 (name "Str"))) - (method @20.3-23.11 (module-of "a") (name "a2") - (args - (ty-tuple @20.18-23.4 - (ty-var @21.4-21.5 (raw "a")) - (ty-var @22.4-22.5 (raw "a")))) - (ty @23.8-23.11 (name "Str"))))) - (s-type-decl @24.1-33.11 - (header @24.1-24.5 (name "B") + (ty-var @12.3-12.4 (raw "a")))) + (ty-var @12.8-12.9 (raw "a"))) + (s-type-decl @22.1-31.11 + (header @22.1-22.5 (name "B") (args - (ty-var @24.3-24.4 (raw "b")))) - (ty-var @24.8-24.9 (raw "b")) - (where - (method @26.3-29.11 (module-of "b") (name "b1") - (args - (ty-tuple @26.18-29.4 - (ty-var @27.4-27.5 (raw "b")) - (ty-var @28.4-28.5 (raw "b")))) - (ty @29.8-29.11 (name "Str"))) - (method @30.3-33.11 (module-of "b") (name "b2") - (args - (ty-tuple @30.18-33.4 - (ty-var @31.4-31.5 (raw "b")) - (ty-var @32.4-32.5 (raw "b")))) - (ty @33.8-33.11 (name "Str"))))) - (s-type-decl @35.1-41.2 - (header @35.1-38.2 (name "C") + (ty-var @22.3-22.4 (raw "b")))) + (ty-var @22.8-22.9 (raw "b"))) + (s-type-decl @33.1-39.2 + (header @33.1-36.2 (name "C") (args - (ty-var @36.2-36.3 (raw "a")) - (ty-var @37.2-37.3 (raw "b")))) - (ty-tuple @38.5-41.2 - (ty-var @39.2-39.3 (raw "a")) - (ty-var @40.2-40.3 (raw "b")))) - (s-type-decl @42.1-48.2 - (header @42.1-45.2 (name "D") + (ty-var @34.2-34.3 (raw "a")) + (ty-var @35.2-35.3 (raw "b")))) + (ty-tuple @36.5-39.2 + (ty-var @37.2-37.3 (raw "a")) + (ty-var @38.2-38.3 (raw "b")))) + (s-type-decl @40.1-46.2 + (header @40.1-43.2 (name "D") (args - (ty-var @43.2-43.3 (raw "a")) - (ty-var @44.2-44.3 (raw "b")))) - (ty-apply @45.5-48.2 - (ty @45.5-45.6 (name "C")) - (ty-var @46.2-46.3 (raw "a")) - (ty-var @47.2-47.3 (raw "b")))) - (s-type-decl @49.1-52.2 - (header @49.1-49.2 (name "E") + (ty-var @41.2-41.3 (raw "a")) + (ty-var @42.2-42.3 (raw "b")))) + (ty-apply @43.5-46.2 + (ty @43.5-43.6 (name "C")) + (ty-var @44.2-44.3 (raw "a")) + (ty-var @45.2-45.3 (raw "b")))) + (s-type-decl @47.1-50.2 + (header @47.1-47.2 (name "E") (args)) - (ty-record @49.5-52.2 - (anno-record-field @50.2-50.9 (name "a") - (ty @50.6-50.9 (name "Str"))) - (anno-record-field @51.2-51.9 (name "b") - (ty @51.6-51.9 (name "Str"))))) - (s-type-decl @53.1-56.2 - (header @53.1-53.2 (name "F") + (ty-record @47.5-50.2 + (anno-record-field @48.2-48.9 (name "a") + (ty @48.6-48.9 (name "Str"))) + (anno-record-field @49.2-49.9 (name "b") + (ty @49.6-49.9 (name "Str"))))) + (s-type-decl @51.1-54.2 + (header @51.1-51.2 (name "F") (args)) - (ty-tag-union @53.5-56.2 + (ty-tag-union @51.5-54.2 (tags - (ty @54.2-54.3 (name "A")) - (ty @55.2-55.3 (name "B"))))) - (s-type-anno @58.1-58.42 (name "g") - (ty-fn @58.5-58.11 - (ty-var @58.5-58.6 (raw "e")) - (ty-var @58.10-58.11 (raw "e"))) + (ty @52.2-52.3 (name "A")) + (ty @53.2-53.3 (name "B"))))) + (s-type-anno @56.1-56.42 (name "g") + (ty-fn @56.5-56.11 + (ty-var @56.5-56.6 (raw "e")) + (ty-var @56.10-56.11 (raw "e"))) (where - (alias @58.18-58.29 (module-of "e") (name "A")) - (alias @58.31-58.42 (module-of "e") (name "B")))) - (s-decl @60.1-110.2 - (p-ident @60.1-60.2 (raw "h")) - (e-lambda @60.5-110.2 + (alias @56.18-56.29 (module-of "e") (name "A")) + (alias @56.31-56.42 (module-of "e") (name "B")))) + (s-decl @58.1-108.2 + (p-ident @58.1-58.2 (raw "h")) + (e-lambda @58.5-108.2 (args - (p-ident @60.6-60.7 (raw "x")) - (p-ident @60.9-60.10 (raw "y"))) - (e-block @60.12-110.2 + (p-ident @58.6-58.7 (raw "x")) + (p-ident @58.9-58.10 (raw "y"))) + (e-block @58.12-108.2 (statements - (s-decl @61.2-68.3 - (p-ident @61.2-61.4 (raw "h1")) - (e-record @61.7-68.3 + (s-decl @59.2-66.3 + (p-ident @59.2-59.4 (raw "h1")) + (e-record @59.7-66.3 (field (field "h11") - (e-ident @62.8-62.9 (raw "x"))) + (e-ident @60.8-60.9 (raw "x"))) (field (field "h12") - (e-ident @63.8-63.9 (raw "x"))) + (e-ident @61.8-61.9 (raw "x"))) (field (field "h13") - (e-record @64.8-67.4 + (e-record @62.8-65.4 (field (field "h131") - (e-ident @65.10-65.11 (raw "x"))) + (e-ident @63.10-63.11 (raw "x"))) (field (field "h132") - (e-ident @66.10-66.11 (raw "y"))))))) - (s-decl @69.2-72.3 - (p-ident @69.2-69.4 (raw "h2")) - (e-apply @69.7-72.3 - (e-ident @69.7-69.8 (raw "h")) - (e-ident @70.3-70.4 (raw "x")) - (e-ident @71.3-71.4 (raw "y")))) - (s-decl @73.2-76.3 - (p-ident @73.2-73.4 (raw "h3")) - (e-apply @73.7-76.3 - (e-tag @73.7-73.8 (raw "A")) - (e-ident @74.3-74.4 (raw "x")) - (e-ident @75.3-75.4 (raw "y")))) - (s-decl @77.2-80.3 - (p-ident @77.2-77.4 (raw "h4")) - (e-list @77.7-80.3 - (e-ident @78.3-78.4 (raw "x")) - (e-ident @79.3-79.4 (raw "y")))) - (s-decl @81.2-84.3 - (p-ident @81.2-81.4 (raw "h5")) - (e-tuple @81.7-84.3 - (e-ident @82.3-82.4 (raw "x")) - (e-ident @83.3-83.4 (raw "y")))) + (e-ident @64.10-64.11 (raw "y"))))))) + (s-decl @67.2-70.3 + (p-ident @67.2-67.4 (raw "h2")) + (e-apply @67.7-70.3 + (e-ident @67.7-67.8 (raw "h")) + (e-ident @68.3-68.4 (raw "x")) + (e-ident @69.3-69.4 (raw "y")))) + (s-decl @71.2-74.3 + (p-ident @71.2-71.4 (raw "h3")) + (e-apply @71.7-74.3 + (e-tag @71.7-71.8 (raw "A")) + (e-ident @72.3-72.4 (raw "x")) + (e-ident @73.3-73.4 (raw "y")))) + (s-decl @75.2-78.3 + (p-ident @75.2-75.4 (raw "h4")) + (e-list @75.7-78.3 + (e-ident @76.3-76.4 (raw "x")) + (e-ident @77.3-77.4 (raw "y")))) + (s-decl @79.2-82.3 + (p-ident @79.2-79.4 (raw "h5")) + (e-tuple @79.7-82.3 + (e-ident @80.3-80.4 (raw "x")) + (e-ident @81.3-81.4 (raw "y")))) (e-match - (e-ident @86.8-86.9 (raw "x")) + (e-ident @84.8-84.9 (raw "x")) (branches - (branch @87.3-92.9 - (p-tag @87.3-92.4 (raw "Z1") - (p-tuple @88.4-91.5 - (p-ident @89.5-89.6 (raw "a")) - (p-ident @90.5-90.6 (raw "b")))) - (e-ident @92.8-92.9 (raw "a"))) - (branch @93.3-96.9 - (p-tag @93.3-96.4 (raw "Z2") - (p-ident @94.4-94.5 (raw "a")) - (p-ident @95.4-95.5 (raw "b"))) - (e-ident @96.8-96.9 (raw "a"))) - (branch @97.3-102.9 - (p-tag @97.3-102.4 (raw "Z3") - (p-record @98.4-101.5 - (field @99.5-99.6 (name "a") (rest false)) - (field @100.5-100.6 (name "b") (rest false)))) - (e-ident @102.8-102.9 (raw "a"))) - (branch @103.3-108.9 - (p-tag @103.3-108.4 (raw "Z4") - (p-list @104.4-107.5 - (p-ident @105.5-105.6 (raw "a")) - (p-ident @106.5-106.6 (raw "b")))) - (e-ident @108.8-108.9 (raw "a"))))))))))) + (branch @85.3-90.9 + (p-tag @85.3-90.4 (raw "Z1") + (p-tuple @86.4-89.5 + (p-ident @87.5-87.6 (raw "a")) + (p-ident @88.5-88.6 (raw "b")))) + (e-ident @90.8-90.9 (raw "a"))) + (branch @91.3-94.9 + (p-tag @91.3-94.4 (raw "Z2") + (p-ident @92.4-92.5 (raw "a")) + (p-ident @93.4-93.5 (raw "b"))) + (e-ident @94.8-94.9 (raw "a"))) + (branch @95.3-100.9 + (p-tag @95.3-100.4 (raw "Z3") + (p-record @96.4-99.5 + (field @97.5-97.6 (name "a") (rest false)) + (field @98.5-98.6 (name "b") (rest false)))) + (e-ident @100.8-100.9 (raw "a"))) + (branch @101.3-106.9 + (p-tag @101.3-106.4 (raw "Z4") + (p-list @102.4-105.5 + (p-ident @103.5-103.6 (raw "a")) + (p-ident @104.5-104.6 (raw "b")))) + (e-ident @106.8-106.9 (raw "a"))))))))))) ~~~ # FORMATTED ~~~roc -module [] - +# Import exposing # Import exposing import I1 exposing [ I11, @@ -685,189 +654,189 @@ h = |x, y| { ~~~clojure (can-ir (d-let - (p-assign @60.1-60.2 (ident "h")) - (e-closure @60.5-110.2 + (p-assign @58.1-58.2 (ident "h")) + (e-closure @58.5-108.2 (captures - (capture @60.1-60.2 (ident "h")) - (capture @89.5-89.6 (ident "a")) - (capture @99.5-99.6 (ident "a")) - (capture @94.4-94.5 (ident "a")) - (capture @105.5-105.6 (ident "a"))) - (e-lambda @60.5-110.2 + (capture @103.5-103.6 (ident "a")) + (capture @97.5-97.6 (ident "a")) + (capture @87.5-87.6 (ident "a")) + (capture @58.1-58.2 (ident "h")) + (capture @92.4-92.5 (ident "a"))) + (e-lambda @58.5-108.2 (args - (p-assign @60.6-60.7 (ident "x")) - (p-assign @60.9-60.10 (ident "y"))) - (e-block @60.12-110.2 - (s-let @61.2-68.3 - (p-assign @61.2-61.4 (ident "h1")) - (e-record @61.7-68.3 + (p-assign @58.6-58.7 (ident "x")) + (p-assign @58.9-58.10 (ident "y"))) + (e-block @58.12-108.2 + (s-let @59.2-66.3 + (p-assign @59.2-59.4 (ident "h1")) + (e-record @59.7-66.3 (fields (field (name "h11") - (e-lookup-local @62.8-62.9 - (p-assign @60.6-60.7 (ident "x")))) + (e-lookup-local @60.8-60.9 + (p-assign @58.6-58.7 (ident "x")))) (field (name "h12") - (e-lookup-local @63.8-63.9 - (p-assign @60.6-60.7 (ident "x")))) + (e-lookup-local @61.8-61.9 + (p-assign @58.6-58.7 (ident "x")))) (field (name "h13") - (e-record @64.8-67.4 + (e-record @62.8-65.4 (fields (field (name "h131") - (e-lookup-local @65.10-65.11 - (p-assign @60.6-60.7 (ident "x")))) + (e-lookup-local @63.10-63.11 + (p-assign @58.6-58.7 (ident "x")))) (field (name "h132") - (e-lookup-local @66.10-66.11 - (p-assign @60.9-60.10 (ident "y")))))))))) - (s-let @69.2-72.3 - (p-assign @69.2-69.4 (ident "h2")) - (e-call @69.7-72.3 - (e-lookup-local @69.7-69.8 - (p-assign @60.1-60.2 (ident "h"))) - (e-lookup-local @70.3-70.4 - (p-assign @60.6-60.7 (ident "x"))) - (e-lookup-local @71.3-71.4 - (p-assign @60.9-60.10 (ident "y"))))) - (s-let @73.2-76.3 - (p-assign @73.2-73.4 (ident "h3")) - (e-tag @73.7-76.3 (name "A") + (e-lookup-local @64.10-64.11 + (p-assign @58.9-58.10 (ident "y")))))))))) + (s-let @67.2-70.3 + (p-assign @67.2-67.4 (ident "h2")) + (e-call @67.7-70.3 + (e-lookup-local @67.7-67.8 + (p-assign @58.1-58.2 (ident "h"))) + (e-lookup-local @68.3-68.4 + (p-assign @58.6-58.7 (ident "x"))) + (e-lookup-local @69.3-69.4 + (p-assign @58.9-58.10 (ident "y"))))) + (s-let @71.2-74.3 + (p-assign @71.2-71.4 (ident "h3")) + (e-tag @71.7-74.3 (name "A") (args - (e-lookup-local @74.3-74.4 - (p-assign @60.6-60.7 (ident "x"))) - (e-lookup-local @75.3-75.4 - (p-assign @60.9-60.10 (ident "y")))))) - (s-let @77.2-80.3 - (p-assign @77.2-77.4 (ident "h4")) - (e-list @77.7-80.3 + (e-lookup-local @72.3-72.4 + (p-assign @58.6-58.7 (ident "x"))) + (e-lookup-local @73.3-73.4 + (p-assign @58.9-58.10 (ident "y")))))) + (s-let @75.2-78.3 + (p-assign @75.2-75.4 (ident "h4")) + (e-list @75.7-78.3 (elems - (e-lookup-local @78.3-78.4 - (p-assign @60.6-60.7 (ident "x"))) - (e-lookup-local @79.3-79.4 - (p-assign @60.9-60.10 (ident "y")))))) - (s-let @81.2-84.3 - (p-assign @81.2-81.4 (ident "h5")) - (e-tuple @81.7-84.3 + (e-lookup-local @76.3-76.4 + (p-assign @58.6-58.7 (ident "x"))) + (e-lookup-local @77.3-77.4 + (p-assign @58.9-58.10 (ident "y")))))) + (s-let @79.2-82.3 + (p-assign @79.2-79.4 (ident "h5")) + (e-tuple @79.7-82.3 (elems - (e-lookup-local @82.3-82.4 - (p-assign @60.6-60.7 (ident "x"))) - (e-lookup-local @83.3-83.4 - (p-assign @60.9-60.10 (ident "y")))))) - (e-match @86.2-109.3 - (match @86.2-109.3 + (e-lookup-local @80.3-80.4 + (p-assign @58.6-58.7 (ident "x"))) + (e-lookup-local @81.3-81.4 + (p-assign @58.9-58.10 (ident "y")))))) + (e-match @84.2-107.3 + (match @84.2-107.3 (cond - (e-lookup-local @86.8-86.9 - (p-assign @60.6-60.7 (ident "x")))) + (e-lookup-local @84.8-84.9 + (p-assign @58.6-58.7 (ident "x")))) (branches (branch (patterns (pattern (degenerate false) - (p-applied-tag @87.3-92.4))) + (p-applied-tag @85.3-90.4))) (value - (e-lookup-local @92.8-92.9 - (p-assign @89.5-89.6 (ident "a"))))) + (e-lookup-local @90.8-90.9 + (p-assign @87.5-87.6 (ident "a"))))) (branch (patterns (pattern (degenerate false) - (p-applied-tag @93.3-96.4))) + (p-applied-tag @91.3-94.4))) (value - (e-lookup-local @96.8-96.9 - (p-assign @94.4-94.5 (ident "a"))))) + (e-lookup-local @94.8-94.9 + (p-assign @92.4-92.5 (ident "a"))))) (branch (patterns (pattern (degenerate false) - (p-applied-tag @97.3-102.4))) + (p-applied-tag @95.3-100.4))) (value - (e-lookup-local @102.8-102.9 - (p-assign @99.5-99.6 (ident "a"))))) + (e-lookup-local @100.8-100.9 + (p-assign @97.5-97.6 (ident "a"))))) (branch (patterns (pattern (degenerate false) - (p-applied-tag @103.3-108.4))) + (p-applied-tag @101.3-106.4))) (value - (e-lookup-local @108.8-108.9 - (p-assign @105.5-105.6 (ident "a")))))))))))) - (s-alias-decl @14.1-23.11 - (ty-header @14.1-14.5 (name "A") + (e-lookup-local @106.8-106.9 + (p-assign @103.5-103.6 (ident "a")))))))))))) + (s-alias-decl @12.1-21.11 + (ty-header @12.1-12.5 (name "A") (ty-args - (ty-var @14.3-14.4 (name "a")))) - (ty-var @14.8-14.9 (name "a"))) - (s-alias-decl @24.1-33.11 - (ty-header @24.1-24.5 (name "B") + (ty-rigid-var @12.3-12.4 (name "a")))) + (ty-rigid-var-lookup (ty-rigid-var @12.3-12.4 (name "a")))) + (s-alias-decl @22.1-31.11 + (ty-header @22.1-22.5 (name "B") (ty-args - (ty-var @24.3-24.4 (name "b")))) - (ty-var @24.8-24.9 (name "b"))) - (s-alias-decl @35.1-41.2 - (ty-header @35.1-38.2 (name "C") + (ty-rigid-var @22.3-22.4 (name "b")))) + (ty-rigid-var-lookup (ty-rigid-var @22.3-22.4 (name "b")))) + (s-alias-decl @33.1-39.2 + (ty-header @33.1-36.2 (name "C") (ty-args - (ty-var @36.2-36.3 (name "a")) - (ty-var @37.2-37.3 (name "b")))) - (ty-tuple @38.5-41.2 - (ty-var @39.2-39.3 (name "a")) - (ty-var @40.2-40.3 (name "b")))) - (s-alias-decl @42.1-48.2 - (ty-header @42.1-45.2 (name "D") + (ty-rigid-var @34.2-34.3 (name "a")) + (ty-rigid-var @35.2-35.3 (name "b")))) + (ty-tuple @36.5-39.2 + (ty-rigid-var-lookup (ty-rigid-var @34.2-34.3 (name "a"))) + (ty-rigid-var-lookup (ty-rigid-var @35.2-35.3 (name "b"))))) + (s-alias-decl @40.1-46.2 + (ty-header @40.1-43.2 (name "D") (ty-args - (ty-var @43.2-43.3 (name "a")) - (ty-var @44.2-44.3 (name "b")))) - (ty-apply @45.5-48.2 (symbol "C") - (ty-var @46.2-46.3 (name "a")) - (ty-var @47.2-47.3 (name "b")))) - (s-alias-decl @49.1-52.2 - (ty-header @49.1-49.2 (name "E")) - (ty-record @49.5-52.2 + (ty-rigid-var @41.2-41.3 (name "a")) + (ty-rigid-var @42.2-42.3 (name "b")))) + (ty-apply @43.5-46.2 (name "C") (local) + (ty-rigid-var-lookup (ty-rigid-var @41.2-41.3 (name "a"))) + (ty-rigid-var-lookup (ty-rigid-var @42.2-42.3 (name "b"))))) + (s-alias-decl @47.1-50.2 + (ty-header @47.1-47.2 (name "E")) + (ty-record @47.5-50.2 (field (field "a") - (ty @50.6-50.9 (name "Str"))) + (ty-lookup @48.6-48.9 (name "Str") (builtin))) (field (field "b") - (ty @51.6-51.9 (name "Str"))))) - (s-alias-decl @53.1-56.2 - (ty-header @53.1-53.2 (name "F")) - (ty-tag-union @53.5-56.2 - (ty @54.2-54.3 (name "A")) - (ty @55.2-55.3 (name "B")))) - (s-import @4.1-7.2 (module "I1") + (ty-lookup @49.6-49.9 (name "Str") (builtin))))) + (s-alias-decl @51.1-54.2 + (ty-header @51.1-51.2 (name "F")) + (ty-tag-union @51.5-54.2 + (ty-tag-name @52.2-52.3 (name "A")) + (ty-tag-name @53.2-53.3 (name "B")))) + (s-import @2.1-5.2 (module "I1") (exposes (exposed (name "I11") (wildcard false)) (exposed (name "I12") (wildcard false)))) - (s-import @8.1-11.2 (module "I2") + (s-import @6.1-9.2 (module "I2") (exposes (exposed (name "I21") (alias "Ias1") (wildcard false)) (exposed (name "I22") (alias "Ias2") (wildcard false)))) - (s-type-anno @58.1-58.42 (name "g") - (ty-fn @58.5-58.11 (effectful false) - (ty-var @58.5-58.6 (name "e")) - (ty-var @58.10-58.11 (name "e"))) + (s-type-anno @56.1-56.42 (name "g") + (ty-fn @56.5-56.11 (effectful false) + (ty-rigid-var @56.5-56.6 (name "e")) + (ty-rigid-var-lookup (ty-rigid-var @56.5-56.6 (name "e")))) (where - (alias @58.18-58.29 (module-of "e") (ident "A")) - (alias @58.31-58.42 (module-of "e") (ident "B")))) - (ext-decl @58.18-58.29 (ident "module(e).A") (kind "type")) - (ext-decl @58.31-58.42 (ident "module(e).B") (kind "type"))) + (alias @56.18-56.29 (module-of "e") (ident "A")) + (alias @56.31-56.42 (module-of "e") (ident "B")))) + (ext-decl @56.18-56.29 (ident "module(e).A") (kind "type")) + (ext-decl @56.31-56.42 (ident "module(e).B") (kind "type"))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @60.1-60.2 (type "[Z1((field, field2)), Z2(c, d), Z3(f), Z4(List(elem))]others, [Z1((field3, field4)), Z2(i, j), Z3(k), Z4(List(elem2))]others2 -> _ret"))) + (patt @58.1-58.2 (type "[Z1((c, d)), Z2(c, f), Z3({ a: c, b: i }), Z4(List(c))]j, [Z1((c, d)), Z2(c, f), Z3({ a: c, b: i }), Z4(List(c))]j -> c"))) (type_decls - (alias @14.1-23.11 (type "A(a)") - (ty-header @14.1-14.5 (name "A") + (alias @12.1-21.11 (type "A(a)") + (ty-header @12.1-12.5 (name "A") (ty-args - (ty-var @14.3-14.4 (name "a"))))) - (alias @24.1-33.11 (type "B(b)") - (ty-header @24.1-24.5 (name "B") + (ty-rigid-var @12.3-12.4 (name "a"))))) + (alias @22.1-31.11 (type "B(b)") + (ty-header @22.1-22.5 (name "B") (ty-args - (ty-var @24.3-24.4 (name "b"))))) - (alias @35.1-41.2 (type "C(a, b)") - (ty-header @35.1-38.2 (name "C") + (ty-rigid-var @22.3-22.4 (name "b"))))) + (alias @33.1-39.2 (type "C(a, b)") + (ty-header @33.1-36.2 (name "C") (ty-args - (ty-var @36.2-36.3 (name "a")) - (ty-var @37.2-37.3 (name "b"))))) - (alias @42.1-48.2 (type "D(a, b)") - (ty-header @42.1-45.2 (name "D") + (ty-rigid-var @34.2-34.3 (name "a")) + (ty-rigid-var @35.2-35.3 (name "b"))))) + (alias @40.1-46.2 (type "D(a, b)") + (ty-header @40.1-43.2 (name "D") (ty-args - (ty-var @43.2-43.3 (name "a")) - (ty-var @44.2-44.3 (name "b"))))) - (alias @49.1-52.2 (type "E") - (ty-header @49.1-49.2 (name "E"))) - (alias @53.1-56.2 (type "F") - (ty-header @53.1-53.2 (name "F")))) + (ty-rigid-var @41.2-41.3 (name "a")) + (ty-rigid-var @42.2-42.3 (name "b"))))) + (alias @47.1-50.2 (type "E") + (ty-header @47.1-47.2 (name "E"))) + (alias @51.1-54.2 (type "F") + (ty-header @51.1-51.2 (name "F")))) (expressions - (expr @60.5-110.2 (type "[Z1((field, field2)), Z2(c, d), Z3(f), Z4(List(elem))]others, [Z1((field3, field4)), Z2(i, j), Z3(k), Z4(List(elem2))]others2 -> _ret")))) + (expr @58.5-108.2 (type "[Z1((c, d)), Z2(c, f), Z3({ a: c, b: i }), Z4(List(c))]j, [Z1((c, d)), Z2(c, f), Z3({ a: c, b: i }), Z4(List(c))]j -> c")))) ~~~ diff --git a/test/snapshots/formatting/multiline_without_comma/module.md b/test/snapshots/formatting/multiline_without_comma/module.md index 6673f9da91..c45110fb83 100644 --- a/test/snapshots/formatting/multiline_without_comma/module.md +++ b/test/snapshots/formatting/multiline_without_comma/module.md @@ -1,11 +1,10 @@ # META ~~~ini description=Multiline without comma formatting module -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [ a, b ] @@ -14,42 +13,85 @@ a = 'a' b = 'a' ~~~ # EXPECTED -NIL +PARSE ERROR - module.md:1:2:1:3 +PARSE ERROR - module.md:1:3:1:4 +PARSE ERROR - module.md:2:2:2:3 +PARSE ERROR - module.md:3:1:3:2 # PROBLEMS -NIL +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**module.md:1:2:1:3:** +```roc + a, +``` + ^ + + +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**module.md:1:3:1:4:** +```roc + a, +``` + ^ + + +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**module.md:2:2:2:3:** +```roc + b +``` + ^ + + +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**module.md:3:1:3:2:** +```roc +] +``` +^ + + # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9), -LowerIdent(2:2-2:3),Comma(2:3-2:4), -LowerIdent(3:2-3:3), -CloseSquare(4:1-4:2), +LowerIdent(1:2-1:3),Comma(1:3-1:4), +LowerIdent(2:2-2:3), +CloseSquare(3:1-3:2), +LowerIdent(5:1-5:2),OpAssign(5:3-5:4),SingleQuote(5:5-5:8), LowerIdent(6:1-6:2),OpAssign(6:3-6:4),SingleQuote(6:5-6:8), -LowerIdent(7:1-7:2),OpAssign(7:3-7:4),SingleQuote(7:5-7:8), -EndOfFile(8:1-8:1), +EndOfFile(7:1-7:1), ~~~ # PARSE ~~~clojure -(file @1.1-7.8 - (module @1.1-4.2 - (exposes @1.8-4.2 - (exposed-lower-ident @2.2-2.3 - (text "a")) - (exposed-lower-ident @3.2-3.3 - (text "b")))) +(file @1.2-6.8 + (type-module @1.2-1.3) (statements + (s-malformed @1.2-1.3 (tag "statement_unexpected_token")) + (s-malformed @1.3-1.4 (tag "statement_unexpected_token")) + (s-malformed @2.2-2.3 (tag "statement_unexpected_token")) + (s-malformed @3.1-3.2 (tag "statement_unexpected_token")) + (s-decl @5.1-5.8 + (p-ident @5.1-5.2 (raw "a")) + (e-single-quote @5.5-5.8 (raw "'a'"))) (s-decl @6.1-6.8 - (p-ident @6.1-6.2 (raw "a")) - (e-single-quote @6.5-6.8 (raw "'a'"))) - (s-decl @7.1-7.8 - (p-ident @7.1-7.2 (raw "b")) - (e-single-quote @7.5-7.8 (raw "'a'"))))) + (p-ident @6.1-6.2 (raw "b")) + (e-single-quote @6.5-6.8 (raw "'a'"))))) ~~~ # FORMATTED ~~~roc -module [ - a, - b, -] + + + a = 'a' b = 'a' @@ -58,19 +100,19 @@ b = 'a' ~~~clojure (can-ir (d-let - (p-assign @6.1-6.2 (ident "a")) - (e-int @6.5-6.8 (value "97"))) + (p-assign @5.1-5.2 (ident "a")) + (e-num @5.5-5.8 (value "97"))) (d-let - (p-assign @7.1-7.2 (ident "b")) - (e-int @7.5-7.8 (value "97")))) + (p-assign @6.1-6.2 (ident "b")) + (e-num @6.5-6.8 (value "97")))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @6.1-6.2 (type "Num(_size)")) - (patt @7.1-7.2 (type "Num(_size)"))) + (patt @5.1-5.2 (type "Num(Int(_size))")) + (patt @6.1-6.2 (type "Num(Int(_size))"))) (expressions - (expr @6.5-6.8 (type "Num(_size)")) - (expr @7.5-7.8 (type "Num(_size)")))) + (expr @5.5-5.8 (type "Num(Int(_size))")) + (expr @6.5-6.8 (type "Num(Int(_size))")))) ~~~ diff --git a/test/snapshots/formatting/singleline/everything.md b/test/snapshots/formatting/singleline/everything.md index 43bcb3551c..0d9933a2da 100644 --- a/test/snapshots/formatting/singleline/everything.md +++ b/test/snapshots/formatting/singleline/everything.md @@ -1,12 +1,10 @@ # META ~~~ini description=Singleline formatting everything -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - # Import exposing import I1 exposing [I11, I12] import I2 exposing [I21 as Ias1, I22 as Ias2] @@ -38,25 +36,25 @@ h = |x, y| { } ~~~ # EXPECTED -WHERE CLAUSE NOT ALLOWED IN TYPE DECLARATION - everything.md:8:1:8:74 -WHERE CLAUSE NOT ALLOWED IN TYPE DECLARATION - everything.md:9:1:9:74 -MODULE NOT FOUND - everything.md:4:1:4:30 -MODULE NOT FOUND - everything.md:5:1:5:46 -UNUSED VARIABLE - everything.md:26:10:26:11 -UNUSED VARIABLE - everything.md:27:9:27:10 -UNUSED VARIABLE - everything.md:28:11:28:12 -UNUSED VARIABLE - everything.md:29:10:29:11 +WHERE CLAUSE NOT ALLOWED IN TYPE DECLARATION - everything.md:6:1:6:74 +WHERE CLAUSE NOT ALLOWED IN TYPE DECLARATION - everything.md:7:1:7:74 +MODULE NOT FOUND - everything.md:2:1:2:30 +MODULE NOT FOUND - everything.md:3:1:3:46 +UNUSED VARIABLE - everything.md:24:10:24:11 +UNUSED VARIABLE - everything.md:25:9:25:10 +UNUSED VARIABLE - everything.md:26:11:26:12 +UNUSED VARIABLE - everything.md:27:10:27:11 +UNUSED VARIABLE - everything.md:17:2:17:4 +UNUSED VARIABLE - everything.md:18:2:18:4 UNUSED VARIABLE - everything.md:19:2:19:4 UNUSED VARIABLE - everything.md:20:2:20:4 UNUSED VARIABLE - everything.md:21:2:21:4 -UNUSED VARIABLE - everything.md:22:2:22:4 -UNUSED VARIABLE - everything.md:23:2:23:4 # PROBLEMS **WHERE CLAUSE NOT ALLOWED IN TYPE DECLARATION** You cannot define a `where` clause inside a type declaration. You're attempting do this here: -**everything.md:8:1:8:74:** +**everything.md:6:1:6:74:** ```roc A(a) : a where module(a).a1 : (a, a) -> Str, module(a).a2 : (a, a) -> Str ``` @@ -67,7 +65,7 @@ A(a) : a where module(a).a1 : (a, a) -> Str, module(a).a2 : (a, a) -> Str You cannot define a `where` clause inside a type declaration. You're attempting do this here: -**everything.md:9:1:9:74:** +**everything.md:7:1:7:74:** ```roc B(b) : b where module(b).b1 : (b, b) -> Str, module(b).b2 : (b, b) -> Str ``` @@ -78,7 +76,7 @@ B(b) : b where module(b).b1 : (b, b) -> Str, module(b).b2 : (b, b) -> Str The module `I1` was not found in this Roc project. You're attempting to use this module here: -**everything.md:4:1:4:30:** +**everything.md:2:1:2:30:** ```roc import I1 exposing [I11, I12] ``` @@ -89,7 +87,7 @@ import I1 exposing [I11, I12] The module `I2` was not found in this Roc project. You're attempting to use this module here: -**everything.md:5:1:5:46:** +**everything.md:3:1:3:46:** ```roc import I2 exposing [I21 as Ias1, I22 as Ias2] ``` @@ -101,7 +99,7 @@ Variable `b` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_b` to suppress this warning. The unused variable is declared here: -**everything.md:26:10:26:11:** +**everything.md:24:10:24:11:** ```roc Z1((a, b)) => a ``` @@ -113,7 +111,7 @@ Variable `b` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_b` to suppress this warning. The unused variable is declared here: -**everything.md:27:9:27:10:** +**everything.md:25:9:25:10:** ```roc Z2(a, b) => a ``` @@ -125,7 +123,7 @@ Variable `b` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_b` to suppress this warning. The unused variable is declared here: -**everything.md:28:11:28:12:** +**everything.md:26:11:26:12:** ```roc Z3({ a, b }) => a ``` @@ -137,7 +135,7 @@ Variable `b` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_b` to suppress this warning. The unused variable is declared here: -**everything.md:29:10:29:11:** +**everything.md:27:10:27:11:** ```roc Z4([a, b]) => a ``` @@ -149,7 +147,7 @@ Variable `h1` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_h1` to suppress this warning. The unused variable is declared here: -**everything.md:19:2:19:4:** +**everything.md:17:2:17:4:** ```roc h1 = { h11: x, h12: x, h13: { h131: x, h132: y } } ``` @@ -161,7 +159,7 @@ Variable `h2` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_h2` to suppress this warning. The unused variable is declared here: -**everything.md:20:2:20:4:** +**everything.md:18:2:18:4:** ```roc h2 = h(x, y) ``` @@ -173,7 +171,7 @@ Variable `h3` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_h3` to suppress this warning. The unused variable is declared here: -**everything.md:21:2:21:4:** +**everything.md:19:2:19:4:** ```roc h3 = A(x, y) ``` @@ -185,7 +183,7 @@ Variable `h4` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_h4` to suppress this warning. The unused variable is declared here: -**everything.md:22:2:22:4:** +**everything.md:20:2:20:4:** ```roc h4 = [x, y] ``` @@ -197,7 +195,7 @@ Variable `h5` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_h5` to suppress this warning. The unused variable is declared here: -**everything.md:23:2:23:4:** +**everything.md:21:2:21:4:** ```roc h5 = (x, y) ``` @@ -206,381 +204,382 @@ The unused variable is declared here: # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -KwImport(4:1-4:7),UpperIdent(4:8-4:10),KwExposing(4:11-4:19),OpenSquare(4:20-4:21),UpperIdent(4:21-4:24),Comma(4:24-4:25),UpperIdent(4:26-4:29),CloseSquare(4:29-4:30), -KwImport(5:1-5:7),UpperIdent(5:8-5:10),KwExposing(5:11-5:19),OpenSquare(5:20-5:21),UpperIdent(5:21-5:24),KwAs(5:25-5:27),UpperIdent(5:28-5:32),Comma(5:32-5:33),UpperIdent(5:34-5:37),KwAs(5:38-5:40),UpperIdent(5:41-5:45),CloseSquare(5:45-5:46), -UpperIdent(8:1-8:2),NoSpaceOpenRound(8:2-8:3),LowerIdent(8:3-8:4),CloseRound(8:4-8:5),OpColon(8:6-8:7),LowerIdent(8:8-8:9),KwWhere(8:10-8:15),KwModule(8:16-8:22),NoSpaceOpenRound(8:22-8:23),LowerIdent(8:23-8:24),CloseRound(8:24-8:25),NoSpaceDotLowerIdent(8:25-8:28),OpColon(8:29-8:30),OpenRound(8:31-8:32),LowerIdent(8:32-8:33),Comma(8:33-8:34),LowerIdent(8:35-8:36),CloseRound(8:36-8:37),OpArrow(8:38-8:40),UpperIdent(8:41-8:44),Comma(8:44-8:45),KwModule(8:46-8:52),NoSpaceOpenRound(8:52-8:53),LowerIdent(8:53-8:54),CloseRound(8:54-8:55),NoSpaceDotLowerIdent(8:55-8:58),OpColon(8:59-8:60),OpenRound(8:61-8:62),LowerIdent(8:62-8:63),Comma(8:63-8:64),LowerIdent(8:65-8:66),CloseRound(8:66-8:67),OpArrow(8:68-8:70),UpperIdent(8:71-8:74), -UpperIdent(9:1-9:2),NoSpaceOpenRound(9:2-9:3),LowerIdent(9:3-9:4),CloseRound(9:4-9:5),OpColon(9:6-9:7),LowerIdent(9:8-9:9),KwWhere(9:10-9:15),KwModule(9:16-9:22),NoSpaceOpenRound(9:22-9:23),LowerIdent(9:23-9:24),CloseRound(9:24-9:25),NoSpaceDotLowerIdent(9:25-9:28),OpColon(9:29-9:30),OpenRound(9:31-9:32),LowerIdent(9:32-9:33),Comma(9:33-9:34),LowerIdent(9:35-9:36),CloseRound(9:36-9:37),OpArrow(9:38-9:40),UpperIdent(9:41-9:44),Comma(9:44-9:45),KwModule(9:46-9:52),NoSpaceOpenRound(9:52-9:53),LowerIdent(9:53-9:54),CloseRound(9:54-9:55),NoSpaceDotLowerIdent(9:55-9:58),OpColon(9:59-9:60),OpenRound(9:61-9:62),LowerIdent(9:62-9:63),Comma(9:63-9:64),LowerIdent(9:65-9:66),CloseRound(9:66-9:67),OpArrow(9:68-9:70),UpperIdent(9:71-9:74), -UpperIdent(11:1-11:2),NoSpaceOpenRound(11:2-11:3),LowerIdent(11:3-11:4),Comma(11:4-11:5),LowerIdent(11:6-11:7),CloseRound(11:7-11:8),OpColon(11:9-11:10),OpenRound(11:11-11:12),LowerIdent(11:12-11:13),Comma(11:13-11:14),LowerIdent(11:15-11:16),CloseRound(11:16-11:17), -UpperIdent(12:1-12:2),NoSpaceOpenRound(12:2-12:3),LowerIdent(12:3-12:4),Comma(12:4-12:5),LowerIdent(12:6-12:7),CloseRound(12:7-12:8),OpColon(12:9-12:10),UpperIdent(12:11-12:12),NoSpaceOpenRound(12:12-12:13),LowerIdent(12:13-12:14),Comma(12:14-12:15),LowerIdent(12:16-12:17),CloseRound(12:17-12:18), -UpperIdent(13:1-13:2),OpColon(13:3-13:4),OpenCurly(13:5-13:6),LowerIdent(13:7-13:8),OpColon(13:9-13:10),UpperIdent(13:11-13:14),Comma(13:14-13:15),LowerIdent(13:16-13:17),OpColon(13:18-13:19),UpperIdent(13:20-13:23),CloseCurly(13:24-13:25), -UpperIdent(14:1-14:2),OpColon(14:3-14:4),OpenSquare(14:5-14:6),UpperIdent(14:6-14:7),Comma(14:7-14:8),UpperIdent(14:9-14:10),CloseSquare(14:10-14:11), -LowerIdent(16:1-16:2),OpColon(16:3-16:4),LowerIdent(16:5-16:6),OpArrow(16:7-16:9),LowerIdent(16:10-16:11),KwWhere(16:12-16:17),KwModule(16:18-16:24),NoSpaceOpenRound(16:24-16:25),LowerIdent(16:25-16:26),CloseRound(16:26-16:27),NoSpaceDotUpperIdent(16:27-16:29),Comma(16:29-16:30),KwModule(16:31-16:37),NoSpaceOpenRound(16:37-16:38),LowerIdent(16:38-16:39),CloseRound(16:39-16:40),NoSpaceDotUpperIdent(16:40-16:42), -LowerIdent(18:1-18:2),OpAssign(18:3-18:4),OpBar(18:5-18:6),LowerIdent(18:6-18:7),Comma(18:7-18:8),LowerIdent(18:9-18:10),OpBar(18:10-18:11),OpenCurly(18:12-18:13), -LowerIdent(19:2-19:4),OpAssign(19:5-19:6),OpenCurly(19:7-19:8),LowerIdent(19:9-19:12),OpColon(19:12-19:13),LowerIdent(19:14-19:15),Comma(19:15-19:16),LowerIdent(19:17-19:20),OpColon(19:20-19:21),LowerIdent(19:22-19:23),Comma(19:23-19:24),LowerIdent(19:25-19:28),OpColon(19:28-19:29),OpenCurly(19:30-19:31),LowerIdent(19:32-19:36),OpColon(19:36-19:37),LowerIdent(19:38-19:39),Comma(19:39-19:40),LowerIdent(19:41-19:45),OpColon(19:45-19:46),LowerIdent(19:47-19:48),CloseCurly(19:49-19:50),CloseCurly(19:51-19:52), -LowerIdent(20:2-20:4),OpAssign(20:5-20:6),LowerIdent(20:7-20:8),NoSpaceOpenRound(20:8-20:9),LowerIdent(20:9-20:10),Comma(20:10-20:11),LowerIdent(20:12-20:13),CloseRound(20:13-20:14), -LowerIdent(21:2-21:4),OpAssign(21:5-21:6),UpperIdent(21:7-21:8),NoSpaceOpenRound(21:8-21:9),LowerIdent(21:9-21:10),Comma(21:10-21:11),LowerIdent(21:12-21:13),CloseRound(21:13-21:14), -LowerIdent(22:2-22:4),OpAssign(22:5-22:6),OpenSquare(22:7-22:8),LowerIdent(22:8-22:9),Comma(22:9-22:10),LowerIdent(22:11-22:12),CloseSquare(22:12-22:13), -LowerIdent(23:2-23:4),OpAssign(23:5-23:6),OpenRound(23:7-23:8),LowerIdent(23:8-23:9),Comma(23:9-23:10),LowerIdent(23:11-23:12),CloseRound(23:12-23:13), -KwMatch(25:2-25:7),LowerIdent(25:8-25:9),OpenCurly(25:10-25:11), -UpperIdent(26:3-26:5),NoSpaceOpenRound(26:5-26:6),NoSpaceOpenRound(26:6-26:7),LowerIdent(26:7-26:8),Comma(26:8-26:9),LowerIdent(26:10-26:11),CloseRound(26:11-26:12),CloseRound(26:12-26:13),OpFatArrow(26:14-26:16),LowerIdent(26:17-26:18), -UpperIdent(27:3-27:5),NoSpaceOpenRound(27:5-27:6),LowerIdent(27:6-27:7),Comma(27:7-27:8),LowerIdent(27:9-27:10),CloseRound(27:10-27:11),OpFatArrow(27:12-27:14),LowerIdent(27:15-27:16), -UpperIdent(28:3-28:5),NoSpaceOpenRound(28:5-28:6),OpenCurly(28:6-28:7),LowerIdent(28:8-28:9),Comma(28:9-28:10),LowerIdent(28:11-28:12),CloseCurly(28:13-28:14),CloseRound(28:14-28:15),OpFatArrow(28:16-28:18),LowerIdent(28:19-28:20), -UpperIdent(29:3-29:5),NoSpaceOpenRound(29:5-29:6),OpenSquare(29:6-29:7),LowerIdent(29:7-29:8),Comma(29:8-29:9),LowerIdent(29:10-29:11),CloseSquare(29:11-29:12),CloseRound(29:12-29:13),OpFatArrow(29:14-29:16),LowerIdent(29:17-29:18), -CloseCurly(30:2-30:3), -CloseCurly(31:1-31:2), -EndOfFile(32:1-32:1), +KwImport(2:1-2:7),UpperIdent(2:8-2:10),KwExposing(2:11-2:19),OpenSquare(2:20-2:21),UpperIdent(2:21-2:24),Comma(2:24-2:25),UpperIdent(2:26-2:29),CloseSquare(2:29-2:30), +KwImport(3:1-3:7),UpperIdent(3:8-3:10),KwExposing(3:11-3:19),OpenSquare(3:20-3:21),UpperIdent(3:21-3:24),KwAs(3:25-3:27),UpperIdent(3:28-3:32),Comma(3:32-3:33),UpperIdent(3:34-3:37),KwAs(3:38-3:40),UpperIdent(3:41-3:45),CloseSquare(3:45-3:46), +UpperIdent(6:1-6:2),NoSpaceOpenRound(6:2-6:3),LowerIdent(6:3-6:4),CloseRound(6:4-6:5),OpColon(6:6-6:7),LowerIdent(6:8-6:9),KwWhere(6:10-6:15),KwModule(6:16-6:22),NoSpaceOpenRound(6:22-6:23),LowerIdent(6:23-6:24),CloseRound(6:24-6:25),NoSpaceDotLowerIdent(6:25-6:28),OpColon(6:29-6:30),OpenRound(6:31-6:32),LowerIdent(6:32-6:33),Comma(6:33-6:34),LowerIdent(6:35-6:36),CloseRound(6:36-6:37),OpArrow(6:38-6:40),UpperIdent(6:41-6:44),Comma(6:44-6:45),KwModule(6:46-6:52),NoSpaceOpenRound(6:52-6:53),LowerIdent(6:53-6:54),CloseRound(6:54-6:55),NoSpaceDotLowerIdent(6:55-6:58),OpColon(6:59-6:60),OpenRound(6:61-6:62),LowerIdent(6:62-6:63),Comma(6:63-6:64),LowerIdent(6:65-6:66),CloseRound(6:66-6:67),OpArrow(6:68-6:70),UpperIdent(6:71-6:74), +UpperIdent(7:1-7:2),NoSpaceOpenRound(7:2-7:3),LowerIdent(7:3-7:4),CloseRound(7:4-7:5),OpColon(7:6-7:7),LowerIdent(7:8-7:9),KwWhere(7:10-7:15),KwModule(7:16-7:22),NoSpaceOpenRound(7:22-7:23),LowerIdent(7:23-7:24),CloseRound(7:24-7:25),NoSpaceDotLowerIdent(7:25-7:28),OpColon(7:29-7:30),OpenRound(7:31-7:32),LowerIdent(7:32-7:33),Comma(7:33-7:34),LowerIdent(7:35-7:36),CloseRound(7:36-7:37),OpArrow(7:38-7:40),UpperIdent(7:41-7:44),Comma(7:44-7:45),KwModule(7:46-7:52),NoSpaceOpenRound(7:52-7:53),LowerIdent(7:53-7:54),CloseRound(7:54-7:55),NoSpaceDotLowerIdent(7:55-7:58),OpColon(7:59-7:60),OpenRound(7:61-7:62),LowerIdent(7:62-7:63),Comma(7:63-7:64),LowerIdent(7:65-7:66),CloseRound(7:66-7:67),OpArrow(7:68-7:70),UpperIdent(7:71-7:74), +UpperIdent(9:1-9:2),NoSpaceOpenRound(9:2-9:3),LowerIdent(9:3-9:4),Comma(9:4-9:5),LowerIdent(9:6-9:7),CloseRound(9:7-9:8),OpColon(9:9-9:10),OpenRound(9:11-9:12),LowerIdent(9:12-9:13),Comma(9:13-9:14),LowerIdent(9:15-9:16),CloseRound(9:16-9:17), +UpperIdent(10:1-10:2),NoSpaceOpenRound(10:2-10:3),LowerIdent(10:3-10:4),Comma(10:4-10:5),LowerIdent(10:6-10:7),CloseRound(10:7-10:8),OpColon(10:9-10:10),UpperIdent(10:11-10:12),NoSpaceOpenRound(10:12-10:13),LowerIdent(10:13-10:14),Comma(10:14-10:15),LowerIdent(10:16-10:17),CloseRound(10:17-10:18), +UpperIdent(11:1-11:2),OpColon(11:3-11:4),OpenCurly(11:5-11:6),LowerIdent(11:7-11:8),OpColon(11:9-11:10),UpperIdent(11:11-11:14),Comma(11:14-11:15),LowerIdent(11:16-11:17),OpColon(11:18-11:19),UpperIdent(11:20-11:23),CloseCurly(11:24-11:25), +UpperIdent(12:1-12:2),OpColon(12:3-12:4),OpenSquare(12:5-12:6),UpperIdent(12:6-12:7),Comma(12:7-12:8),UpperIdent(12:9-12:10),CloseSquare(12:10-12:11), +LowerIdent(14:1-14:2),OpColon(14:3-14:4),LowerIdent(14:5-14:6),OpArrow(14:7-14:9),LowerIdent(14:10-14:11),KwWhere(14:12-14:17),KwModule(14:18-14:24),NoSpaceOpenRound(14:24-14:25),LowerIdent(14:25-14:26),CloseRound(14:26-14:27),NoSpaceDotUpperIdent(14:27-14:29),Comma(14:29-14:30),KwModule(14:31-14:37),NoSpaceOpenRound(14:37-14:38),LowerIdent(14:38-14:39),CloseRound(14:39-14:40),NoSpaceDotUpperIdent(14:40-14:42), +LowerIdent(16:1-16:2),OpAssign(16:3-16:4),OpBar(16:5-16:6),LowerIdent(16:6-16:7),Comma(16:7-16:8),LowerIdent(16:9-16:10),OpBar(16:10-16:11),OpenCurly(16:12-16:13), +LowerIdent(17:2-17:4),OpAssign(17:5-17:6),OpenCurly(17:7-17:8),LowerIdent(17:9-17:12),OpColon(17:12-17:13),LowerIdent(17:14-17:15),Comma(17:15-17:16),LowerIdent(17:17-17:20),OpColon(17:20-17:21),LowerIdent(17:22-17:23),Comma(17:23-17:24),LowerIdent(17:25-17:28),OpColon(17:28-17:29),OpenCurly(17:30-17:31),LowerIdent(17:32-17:36),OpColon(17:36-17:37),LowerIdent(17:38-17:39),Comma(17:39-17:40),LowerIdent(17:41-17:45),OpColon(17:45-17:46),LowerIdent(17:47-17:48),CloseCurly(17:49-17:50),CloseCurly(17:51-17:52), +LowerIdent(18:2-18:4),OpAssign(18:5-18:6),LowerIdent(18:7-18:8),NoSpaceOpenRound(18:8-18:9),LowerIdent(18:9-18:10),Comma(18:10-18:11),LowerIdent(18:12-18:13),CloseRound(18:13-18:14), +LowerIdent(19:2-19:4),OpAssign(19:5-19:6),UpperIdent(19:7-19:8),NoSpaceOpenRound(19:8-19:9),LowerIdent(19:9-19:10),Comma(19:10-19:11),LowerIdent(19:12-19:13),CloseRound(19:13-19:14), +LowerIdent(20:2-20:4),OpAssign(20:5-20:6),OpenSquare(20:7-20:8),LowerIdent(20:8-20:9),Comma(20:9-20:10),LowerIdent(20:11-20:12),CloseSquare(20:12-20:13), +LowerIdent(21:2-21:4),OpAssign(21:5-21:6),OpenRound(21:7-21:8),LowerIdent(21:8-21:9),Comma(21:9-21:10),LowerIdent(21:11-21:12),CloseRound(21:12-21:13), +KwMatch(23:2-23:7),LowerIdent(23:8-23:9),OpenCurly(23:10-23:11), +UpperIdent(24:3-24:5),NoSpaceOpenRound(24:5-24:6),NoSpaceOpenRound(24:6-24:7),LowerIdent(24:7-24:8),Comma(24:8-24:9),LowerIdent(24:10-24:11),CloseRound(24:11-24:12),CloseRound(24:12-24:13),OpFatArrow(24:14-24:16),LowerIdent(24:17-24:18), +UpperIdent(25:3-25:5),NoSpaceOpenRound(25:5-25:6),LowerIdent(25:6-25:7),Comma(25:7-25:8),LowerIdent(25:9-25:10),CloseRound(25:10-25:11),OpFatArrow(25:12-25:14),LowerIdent(25:15-25:16), +UpperIdent(26:3-26:5),NoSpaceOpenRound(26:5-26:6),OpenCurly(26:6-26:7),LowerIdent(26:8-26:9),Comma(26:9-26:10),LowerIdent(26:11-26:12),CloseCurly(26:13-26:14),CloseRound(26:14-26:15),OpFatArrow(26:16-26:18),LowerIdent(26:19-26:20), +UpperIdent(27:3-27:5),NoSpaceOpenRound(27:5-27:6),OpenSquare(27:6-27:7),LowerIdent(27:7-27:8),Comma(27:8-27:9),LowerIdent(27:10-27:11),CloseSquare(27:11-27:12),CloseRound(27:12-27:13),OpFatArrow(27:14-27:16),LowerIdent(27:17-27:18), +CloseCurly(28:2-28:3), +CloseCurly(29:1-29:2), +EndOfFile(30:1-30:1), ~~~ # PARSE ~~~clojure -(file @1.1-31.2 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @2.1-29.2 + (type-module @2.1-2.7) (statements - (s-import @4.1-4.30 (raw "I1") + (s-import @2.1-2.30 (raw "I1") (exposing - (exposed-upper-ident @4.21-4.24 (text "I11")) - (exposed-upper-ident @4.26-4.29 (text "I12")))) - (s-import @5.1-5.46 (raw "I2") + (exposed-upper-ident @2.21-2.24 (text "I11")) + (exposed-upper-ident @2.26-2.29 (text "I12")))) + (s-import @3.1-3.46 (raw "I2") (exposing - (exposed-upper-ident @5.21-5.32 (text "I21") (as "Ias1")) - (exposed-upper-ident @5.34-5.45 (text "I22") (as "Ias2")))) - (s-type-decl @8.1-8.74 - (header @8.1-8.5 (name "A") + (exposed-upper-ident @3.21-3.32 (text "I21") (as "Ias1")) + (exposed-upper-ident @3.34-3.45 (text "I22") (as "Ias2")))) + (s-type-decl @6.1-6.74 + (header @6.1-6.5 (name "A") (args - (ty-var @8.3-8.4 (raw "a")))) - (ty-var @8.8-8.9 (raw "a")) - (where - (method @8.16-8.44 (module-of "a") (name "a1") - (args - (ty-tuple @8.31-8.37 - (ty-var @8.32-8.33 (raw "a")) - (ty-var @8.35-8.36 (raw "a")))) - (ty @8.41-8.44 (name "Str"))) - (method @8.46-8.74 (module-of "a") (name "a2") - (args - (ty-tuple @8.61-8.67 - (ty-var @8.62-8.63 (raw "a")) - (ty-var @8.65-8.66 (raw "a")))) - (ty @8.71-8.74 (name "Str"))))) - (s-type-decl @9.1-9.74 - (header @9.1-9.5 (name "B") + (ty-var @6.3-6.4 (raw "a")))) + (ty-var @6.8-6.9 (raw "a"))) + (s-type-decl @7.1-7.74 + (header @7.1-7.5 (name "B") (args - (ty-var @9.3-9.4 (raw "b")))) - (ty-var @9.8-9.9 (raw "b")) - (where - (method @9.16-9.44 (module-of "b") (name "b1") - (args - (ty-tuple @9.31-9.37 - (ty-var @9.32-9.33 (raw "b")) - (ty-var @9.35-9.36 (raw "b")))) - (ty @9.41-9.44 (name "Str"))) - (method @9.46-9.74 (module-of "b") (name "b2") - (args - (ty-tuple @9.61-9.67 - (ty-var @9.62-9.63 (raw "b")) - (ty-var @9.65-9.66 (raw "b")))) - (ty @9.71-9.74 (name "Str"))))) - (s-type-decl @11.1-11.17 - (header @11.1-11.8 (name "C") + (ty-var @7.3-7.4 (raw "b")))) + (ty-var @7.8-7.9 (raw "b"))) + (s-type-decl @9.1-9.17 + (header @9.1-9.8 (name "C") (args - (ty-var @11.3-11.4 (raw "a")) - (ty-var @11.6-11.7 (raw "b")))) - (ty-tuple @11.11-11.17 - (ty-var @11.12-11.13 (raw "a")) - (ty-var @11.15-11.16 (raw "b")))) - (s-type-decl @12.1-12.18 - (header @12.1-12.8 (name "D") + (ty-var @9.3-9.4 (raw "a")) + (ty-var @9.6-9.7 (raw "b")))) + (ty-tuple @9.11-9.17 + (ty-var @9.12-9.13 (raw "a")) + (ty-var @9.15-9.16 (raw "b")))) + (s-type-decl @10.1-10.18 + (header @10.1-10.8 (name "D") (args - (ty-var @12.3-12.4 (raw "a")) - (ty-var @12.6-12.7 (raw "b")))) - (ty-apply @12.11-12.18 - (ty @12.11-12.12 (name "C")) - (ty-var @12.13-12.14 (raw "a")) - (ty-var @12.16-12.17 (raw "b")))) - (s-type-decl @13.1-13.25 - (header @13.1-13.2 (name "E") + (ty-var @10.3-10.4 (raw "a")) + (ty-var @10.6-10.7 (raw "b")))) + (ty-apply @10.11-10.18 + (ty @10.11-10.12 (name "C")) + (ty-var @10.13-10.14 (raw "a")) + (ty-var @10.16-10.17 (raw "b")))) + (s-type-decl @11.1-11.25 + (header @11.1-11.2 (name "E") (args)) - (ty-record @13.5-13.25 - (anno-record-field @13.7-13.14 (name "a") - (ty @13.11-13.14 (name "Str"))) - (anno-record-field @13.16-13.23 (name "b") - (ty @13.20-13.23 (name "Str"))))) - (s-type-decl @14.1-14.11 - (header @14.1-14.2 (name "F") + (ty-record @11.5-11.25 + (anno-record-field @11.7-11.14 (name "a") + (ty @11.11-11.14 (name "Str"))) + (anno-record-field @11.16-11.23 (name "b") + (ty @11.20-11.23 (name "Str"))))) + (s-type-decl @12.1-12.11 + (header @12.1-12.2 (name "F") (args)) - (ty-tag-union @14.5-14.11 + (ty-tag-union @12.5-12.11 (tags - (ty @14.6-14.7 (name "A")) - (ty @14.9-14.10 (name "B"))))) - (s-type-anno @16.1-16.42 (name "g") - (ty-fn @16.5-16.11 - (ty-var @16.5-16.6 (raw "e")) - (ty-var @16.10-16.11 (raw "e"))) + (ty @12.6-12.7 (name "A")) + (ty @12.9-12.10 (name "B"))))) + (s-type-anno @14.1-14.42 (name "g") + (ty-fn @14.5-14.11 + (ty-var @14.5-14.6 (raw "e")) + (ty-var @14.10-14.11 (raw "e"))) (where - (alias @16.18-16.29 (module-of "e") (name "A")) - (alias @16.31-16.42 (module-of "e") (name "B")))) - (s-decl @18.1-31.2 - (p-ident @18.1-18.2 (raw "h")) - (e-lambda @18.5-31.2 + (alias @14.18-14.29 (module-of "e") (name "A")) + (alias @14.31-14.42 (module-of "e") (name "B")))) + (s-decl @16.1-29.2 + (p-ident @16.1-16.2 (raw "h")) + (e-lambda @16.5-29.2 (args - (p-ident @18.6-18.7 (raw "x")) - (p-ident @18.9-18.10 (raw "y"))) - (e-block @18.12-31.2 + (p-ident @16.6-16.7 (raw "x")) + (p-ident @16.9-16.10 (raw "y"))) + (e-block @16.12-29.2 (statements - (s-decl @19.2-19.52 - (p-ident @19.2-19.4 (raw "h1")) - (e-record @19.7-19.52 + (s-decl @17.2-17.52 + (p-ident @17.2-17.4 (raw "h1")) + (e-record @17.7-17.52 (field (field "h11") - (e-ident @19.14-19.15 (raw "x"))) + (e-ident @17.14-17.15 (raw "x"))) (field (field "h12") - (e-ident @19.22-19.23 (raw "x"))) + (e-ident @17.22-17.23 (raw "x"))) (field (field "h13") - (e-record @19.30-19.50 + (e-record @17.30-17.50 (field (field "h131") - (e-ident @19.38-19.39 (raw "x"))) + (e-ident @17.38-17.39 (raw "x"))) (field (field "h132") - (e-ident @19.47-19.48 (raw "y"))))))) - (s-decl @20.2-20.14 - (p-ident @20.2-20.4 (raw "h2")) - (e-apply @20.7-20.14 - (e-ident @20.7-20.8 (raw "h")) - (e-ident @20.9-20.10 (raw "x")) - (e-ident @20.12-20.13 (raw "y")))) - (s-decl @21.2-21.14 - (p-ident @21.2-21.4 (raw "h3")) - (e-apply @21.7-21.14 - (e-tag @21.7-21.8 (raw "A")) - (e-ident @21.9-21.10 (raw "x")) - (e-ident @21.12-21.13 (raw "y")))) - (s-decl @22.2-22.13 - (p-ident @22.2-22.4 (raw "h4")) - (e-list @22.7-22.13 - (e-ident @22.8-22.9 (raw "x")) - (e-ident @22.11-22.12 (raw "y")))) - (s-decl @23.2-23.13 - (p-ident @23.2-23.4 (raw "h5")) - (e-tuple @23.7-23.13 - (e-ident @23.8-23.9 (raw "x")) - (e-ident @23.11-23.12 (raw "y")))) + (e-ident @17.47-17.48 (raw "y"))))))) + (s-decl @18.2-18.14 + (p-ident @18.2-18.4 (raw "h2")) + (e-apply @18.7-18.14 + (e-ident @18.7-18.8 (raw "h")) + (e-ident @18.9-18.10 (raw "x")) + (e-ident @18.12-18.13 (raw "y")))) + (s-decl @19.2-19.14 + (p-ident @19.2-19.4 (raw "h3")) + (e-apply @19.7-19.14 + (e-tag @19.7-19.8 (raw "A")) + (e-ident @19.9-19.10 (raw "x")) + (e-ident @19.12-19.13 (raw "y")))) + (s-decl @20.2-20.13 + (p-ident @20.2-20.4 (raw "h4")) + (e-list @20.7-20.13 + (e-ident @20.8-20.9 (raw "x")) + (e-ident @20.11-20.12 (raw "y")))) + (s-decl @21.2-21.13 + (p-ident @21.2-21.4 (raw "h5")) + (e-tuple @21.7-21.13 + (e-ident @21.8-21.9 (raw "x")) + (e-ident @21.11-21.12 (raw "y")))) (e-match - (e-ident @25.8-25.9 (raw "x")) + (e-ident @23.8-23.9 (raw "x")) (branches - (branch @26.3-26.18 - (p-tag @26.3-26.13 (raw "Z1") - (p-tuple @26.6-26.12 - (p-ident @26.7-26.8 (raw "a")) - (p-ident @26.10-26.11 (raw "b")))) - (e-ident @26.17-26.18 (raw "a"))) - (branch @27.3-27.16 - (p-tag @27.3-27.11 (raw "Z2") - (p-ident @27.6-27.7 (raw "a")) - (p-ident @27.9-27.10 (raw "b"))) - (e-ident @27.15-27.16 (raw "a"))) - (branch @28.3-28.20 - (p-tag @28.3-28.15 (raw "Z3") - (p-record @28.6-28.14 - (field @28.8-28.9 (name "a") (rest false)) - (field @28.11-28.12 (name "b") (rest false)))) - (e-ident @28.19-28.20 (raw "a"))) - (branch @29.3-29.18 - (p-tag @29.3-29.13 (raw "Z4") - (p-list @29.6-29.12 - (p-ident @29.7-29.8 (raw "a")) - (p-ident @29.10-29.11 (raw "b")))) - (e-ident @29.17-29.18 (raw "a"))))))))))) + (branch @24.3-24.18 + (p-tag @24.3-24.13 (raw "Z1") + (p-tuple @24.6-24.12 + (p-ident @24.7-24.8 (raw "a")) + (p-ident @24.10-24.11 (raw "b")))) + (e-ident @24.17-24.18 (raw "a"))) + (branch @25.3-25.16 + (p-tag @25.3-25.11 (raw "Z2") + (p-ident @25.6-25.7 (raw "a")) + (p-ident @25.9-25.10 (raw "b"))) + (e-ident @25.15-25.16 (raw "a"))) + (branch @26.3-26.20 + (p-tag @26.3-26.15 (raw "Z3") + (p-record @26.6-26.14 + (field @26.8-26.9 (name "a") (rest false)) + (field @26.11-26.12 (name "b") (rest false)))) + (e-ident @26.19-26.20 (raw "a"))) + (branch @27.3-27.18 + (p-tag @27.3-27.13 (raw "Z4") + (p-list @27.6-27.12 + (p-ident @27.7-27.8 (raw "a")) + (p-ident @27.10-27.11 (raw "b")))) + (e-ident @27.17-27.18 (raw "a"))))))))))) ~~~ # FORMATTED ~~~roc -NO CHANGE +# Import exposing +# Import exposing +import I1 exposing [I11, I12] +import I2 exposing [I21 as Ias1, I22 as Ias2] + +# Where constraint +A(a) : a where module(a).a1 : (a, a) -> Str, module(a).a2 : (a, a) -> Str +B(b) : b where module(b).b1 : (b, b) -> Str, module(b).b2 : (b, b) -> Str + +C(a, b) : (a, b) +D(a, b) : C(a, b) +E : { a : Str, b : Str } +F : [A, B] + +g : e -> e where module(e).A, module(e).B + +h = |x, y| { + h1 = { h11: x, h12: x, h13: { h131: x, h132: y } } + h2 = h(x, y) + h3 = A(x, y) + h4 = [x, y] + h5 = (x, y) + + match x { + Z1((a, b)) => a + Z2(a, b) => a + Z3({ a, b }) => a + Z4([a, b]) => a + } +} ~~~ # CANONICALIZE ~~~clojure (can-ir (d-let - (p-assign @18.1-18.2 (ident "h")) - (e-closure @18.5-31.2 + (p-assign @16.1-16.2 (ident "h")) + (e-closure @16.5-29.2 (captures - (capture @18.1-18.2 (ident "h")) - (capture @26.7-26.8 (ident "a")) - (capture @28.8-28.9 (ident "a")) - (capture @27.6-27.7 (ident "a")) - (capture @29.7-29.8 (ident "a"))) - (e-lambda @18.5-31.2 + (capture @27.7-27.8 (ident "a")) + (capture @26.8-26.9 (ident "a")) + (capture @24.7-24.8 (ident "a")) + (capture @16.1-16.2 (ident "h")) + (capture @25.6-25.7 (ident "a"))) + (e-lambda @16.5-29.2 (args - (p-assign @18.6-18.7 (ident "x")) - (p-assign @18.9-18.10 (ident "y"))) - (e-block @18.12-31.2 - (s-let @19.2-19.52 - (p-assign @19.2-19.4 (ident "h1")) - (e-record @19.7-19.52 + (p-assign @16.6-16.7 (ident "x")) + (p-assign @16.9-16.10 (ident "y"))) + (e-block @16.12-29.2 + (s-let @17.2-17.52 + (p-assign @17.2-17.4 (ident "h1")) + (e-record @17.7-17.52 (fields (field (name "h11") - (e-lookup-local @19.14-19.15 - (p-assign @18.6-18.7 (ident "x")))) + (e-lookup-local @17.14-17.15 + (p-assign @16.6-16.7 (ident "x")))) (field (name "h12") - (e-lookup-local @19.22-19.23 - (p-assign @18.6-18.7 (ident "x")))) + (e-lookup-local @17.22-17.23 + (p-assign @16.6-16.7 (ident "x")))) (field (name "h13") - (e-record @19.30-19.50 + (e-record @17.30-17.50 (fields (field (name "h131") - (e-lookup-local @19.38-19.39 - (p-assign @18.6-18.7 (ident "x")))) + (e-lookup-local @17.38-17.39 + (p-assign @16.6-16.7 (ident "x")))) (field (name "h132") - (e-lookup-local @19.47-19.48 - (p-assign @18.9-18.10 (ident "y")))))))))) - (s-let @20.2-20.14 - (p-assign @20.2-20.4 (ident "h2")) - (e-call @20.7-20.14 - (e-lookup-local @20.7-20.8 - (p-assign @18.1-18.2 (ident "h"))) - (e-lookup-local @20.9-20.10 - (p-assign @18.6-18.7 (ident "x"))) - (e-lookup-local @20.12-20.13 - (p-assign @18.9-18.10 (ident "y"))))) - (s-let @21.2-21.14 - (p-assign @21.2-21.4 (ident "h3")) - (e-tag @21.7-21.14 (name "A") + (e-lookup-local @17.47-17.48 + (p-assign @16.9-16.10 (ident "y")))))))))) + (s-let @18.2-18.14 + (p-assign @18.2-18.4 (ident "h2")) + (e-call @18.7-18.14 + (e-lookup-local @18.7-18.8 + (p-assign @16.1-16.2 (ident "h"))) + (e-lookup-local @18.9-18.10 + (p-assign @16.6-16.7 (ident "x"))) + (e-lookup-local @18.12-18.13 + (p-assign @16.9-16.10 (ident "y"))))) + (s-let @19.2-19.14 + (p-assign @19.2-19.4 (ident "h3")) + (e-tag @19.7-19.14 (name "A") (args - (e-lookup-local @21.9-21.10 - (p-assign @18.6-18.7 (ident "x"))) - (e-lookup-local @21.12-21.13 - (p-assign @18.9-18.10 (ident "y")))))) - (s-let @22.2-22.13 - (p-assign @22.2-22.4 (ident "h4")) - (e-list @22.7-22.13 + (e-lookup-local @19.9-19.10 + (p-assign @16.6-16.7 (ident "x"))) + (e-lookup-local @19.12-19.13 + (p-assign @16.9-16.10 (ident "y")))))) + (s-let @20.2-20.13 + (p-assign @20.2-20.4 (ident "h4")) + (e-list @20.7-20.13 (elems - (e-lookup-local @22.8-22.9 - (p-assign @18.6-18.7 (ident "x"))) - (e-lookup-local @22.11-22.12 - (p-assign @18.9-18.10 (ident "y")))))) - (s-let @23.2-23.13 - (p-assign @23.2-23.4 (ident "h5")) - (e-tuple @23.7-23.13 + (e-lookup-local @20.8-20.9 + (p-assign @16.6-16.7 (ident "x"))) + (e-lookup-local @20.11-20.12 + (p-assign @16.9-16.10 (ident "y")))))) + (s-let @21.2-21.13 + (p-assign @21.2-21.4 (ident "h5")) + (e-tuple @21.7-21.13 (elems - (e-lookup-local @23.8-23.9 - (p-assign @18.6-18.7 (ident "x"))) - (e-lookup-local @23.11-23.12 - (p-assign @18.9-18.10 (ident "y")))))) - (e-match @25.2-30.3 - (match @25.2-30.3 + (e-lookup-local @21.8-21.9 + (p-assign @16.6-16.7 (ident "x"))) + (e-lookup-local @21.11-21.12 + (p-assign @16.9-16.10 (ident "y")))))) + (e-match @23.2-28.3 + (match @23.2-28.3 (cond - (e-lookup-local @25.8-25.9 - (p-assign @18.6-18.7 (ident "x")))) + (e-lookup-local @23.8-23.9 + (p-assign @16.6-16.7 (ident "x")))) (branches (branch (patterns (pattern (degenerate false) - (p-applied-tag @26.3-26.13))) + (p-applied-tag @24.3-24.13))) (value - (e-lookup-local @26.17-26.18 - (p-assign @26.7-26.8 (ident "a"))))) + (e-lookup-local @24.17-24.18 + (p-assign @24.7-24.8 (ident "a"))))) (branch (patterns (pattern (degenerate false) - (p-applied-tag @27.3-27.11))) + (p-applied-tag @25.3-25.11))) (value - (e-lookup-local @27.15-27.16 - (p-assign @27.6-27.7 (ident "a"))))) + (e-lookup-local @25.15-25.16 + (p-assign @25.6-25.7 (ident "a"))))) (branch (patterns (pattern (degenerate false) - (p-applied-tag @28.3-28.15))) + (p-applied-tag @26.3-26.15))) (value - (e-lookup-local @28.19-28.20 - (p-assign @28.8-28.9 (ident "a"))))) + (e-lookup-local @26.19-26.20 + (p-assign @26.8-26.9 (ident "a"))))) (branch (patterns (pattern (degenerate false) - (p-applied-tag @29.3-29.13))) + (p-applied-tag @27.3-27.13))) (value - (e-lookup-local @29.17-29.18 - (p-assign @29.7-29.8 (ident "a")))))))))))) - (s-alias-decl @8.1-8.74 - (ty-header @8.1-8.5 (name "A") + (e-lookup-local @27.17-27.18 + (p-assign @27.7-27.8 (ident "a")))))))))))) + (s-alias-decl @6.1-6.74 + (ty-header @6.1-6.5 (name "A") (ty-args - (ty-var @8.3-8.4 (name "a")))) - (ty-var @8.8-8.9 (name "a"))) - (s-alias-decl @9.1-9.74 - (ty-header @9.1-9.5 (name "B") + (ty-rigid-var @6.3-6.4 (name "a")))) + (ty-rigid-var-lookup (ty-rigid-var @6.3-6.4 (name "a")))) + (s-alias-decl @7.1-7.74 + (ty-header @7.1-7.5 (name "B") (ty-args - (ty-var @9.3-9.4 (name "b")))) - (ty-var @9.8-9.9 (name "b"))) - (s-alias-decl @11.1-11.17 - (ty-header @11.1-11.8 (name "C") + (ty-rigid-var @7.3-7.4 (name "b")))) + (ty-rigid-var-lookup (ty-rigid-var @7.3-7.4 (name "b")))) + (s-alias-decl @9.1-9.17 + (ty-header @9.1-9.8 (name "C") (ty-args - (ty-var @11.3-11.4 (name "a")) - (ty-var @11.6-11.7 (name "b")))) - (ty-tuple @11.11-11.17 - (ty-var @11.12-11.13 (name "a")) - (ty-var @11.15-11.16 (name "b")))) - (s-alias-decl @12.1-12.18 - (ty-header @12.1-12.8 (name "D") + (ty-rigid-var @9.3-9.4 (name "a")) + (ty-rigid-var @9.6-9.7 (name "b")))) + (ty-tuple @9.11-9.17 + (ty-rigid-var-lookup (ty-rigid-var @9.3-9.4 (name "a"))) + (ty-rigid-var-lookup (ty-rigid-var @9.6-9.7 (name "b"))))) + (s-alias-decl @10.1-10.18 + (ty-header @10.1-10.8 (name "D") (ty-args - (ty-var @12.3-12.4 (name "a")) - (ty-var @12.6-12.7 (name "b")))) - (ty-apply @12.11-12.18 (symbol "C") - (ty-var @12.13-12.14 (name "a")) - (ty-var @12.16-12.17 (name "b")))) - (s-alias-decl @13.1-13.25 - (ty-header @13.1-13.2 (name "E")) - (ty-record @13.5-13.25 + (ty-rigid-var @10.3-10.4 (name "a")) + (ty-rigid-var @10.6-10.7 (name "b")))) + (ty-apply @10.11-10.18 (name "C") (local) + (ty-rigid-var-lookup (ty-rigid-var @10.3-10.4 (name "a"))) + (ty-rigid-var-lookup (ty-rigid-var @10.6-10.7 (name "b"))))) + (s-alias-decl @11.1-11.25 + (ty-header @11.1-11.2 (name "E")) + (ty-record @11.5-11.25 (field (field "a") - (ty @13.11-13.14 (name "Str"))) + (ty-lookup @11.11-11.14 (name "Str") (builtin))) (field (field "b") - (ty @13.20-13.23 (name "Str"))))) - (s-alias-decl @14.1-14.11 - (ty-header @14.1-14.2 (name "F")) - (ty-tag-union @14.5-14.11 - (ty @14.6-14.7 (name "A")) - (ty @14.9-14.10 (name "B")))) - (s-import @4.1-4.30 (module "I1") + (ty-lookup @11.20-11.23 (name "Str") (builtin))))) + (s-alias-decl @12.1-12.11 + (ty-header @12.1-12.2 (name "F")) + (ty-tag-union @12.5-12.11 + (ty-tag-name @12.6-12.7 (name "A")) + (ty-tag-name @12.9-12.10 (name "B")))) + (s-import @2.1-2.30 (module "I1") (exposes (exposed (name "I11") (wildcard false)) (exposed (name "I12") (wildcard false)))) - (s-import @5.1-5.46 (module "I2") + (s-import @3.1-3.46 (module "I2") (exposes (exposed (name "I21") (alias "Ias1") (wildcard false)) (exposed (name "I22") (alias "Ias2") (wildcard false)))) - (s-type-anno @16.1-16.42 (name "g") - (ty-fn @16.5-16.11 (effectful false) - (ty-var @16.5-16.6 (name "e")) - (ty-var @16.10-16.11 (name "e"))) + (s-type-anno @14.1-14.42 (name "g") + (ty-fn @14.5-14.11 (effectful false) + (ty-rigid-var @14.5-14.6 (name "e")) + (ty-rigid-var-lookup (ty-rigid-var @14.5-14.6 (name "e")))) (where - (alias @16.18-16.29 (module-of "e") (ident "A")) - (alias @16.31-16.42 (module-of "e") (ident "B")))) - (ext-decl @16.18-16.29 (ident "module(e).A") (kind "type")) - (ext-decl @16.31-16.42 (ident "module(e).B") (kind "type"))) + (alias @14.18-14.29 (module-of "e") (ident "A")) + (alias @14.31-14.42 (module-of "e") (ident "B")))) + (ext-decl @14.18-14.29 (ident "module(e).A") (kind "type")) + (ext-decl @14.31-14.42 (ident "module(e).B") (kind "type"))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @18.1-18.2 (type "[Z1((field, field2)), Z2(c, d), Z3(f), Z4(List(elem))]others, [Z1((field3, field4)), Z2(i, j), Z3(k), Z4(List(elem2))]others2 -> _ret"))) + (patt @16.1-16.2 (type "[Z1((c, d)), Z2(c, f), Z3({ a: c, b: i }), Z4(List(c))]j, [Z1((c, d)), Z2(c, f), Z3({ a: c, b: i }), Z4(List(c))]j -> c"))) (type_decls - (alias @8.1-8.74 (type "A(a)") - (ty-header @8.1-8.5 (name "A") + (alias @6.1-6.74 (type "A(a)") + (ty-header @6.1-6.5 (name "A") (ty-args - (ty-var @8.3-8.4 (name "a"))))) - (alias @9.1-9.74 (type "B(b)") - (ty-header @9.1-9.5 (name "B") + (ty-rigid-var @6.3-6.4 (name "a"))))) + (alias @7.1-7.74 (type "B(b)") + (ty-header @7.1-7.5 (name "B") (ty-args - (ty-var @9.3-9.4 (name "b"))))) - (alias @11.1-11.17 (type "C(a, b)") - (ty-header @11.1-11.8 (name "C") + (ty-rigid-var @7.3-7.4 (name "b"))))) + (alias @9.1-9.17 (type "C(a, b)") + (ty-header @9.1-9.8 (name "C") (ty-args - (ty-var @11.3-11.4 (name "a")) - (ty-var @11.6-11.7 (name "b"))))) - (alias @12.1-12.18 (type "D(a, b)") - (ty-header @12.1-12.8 (name "D") + (ty-rigid-var @9.3-9.4 (name "a")) + (ty-rigid-var @9.6-9.7 (name "b"))))) + (alias @10.1-10.18 (type "D(a, b)") + (ty-header @10.1-10.8 (name "D") (ty-args - (ty-var @12.3-12.4 (name "a")) - (ty-var @12.6-12.7 (name "b"))))) - (alias @13.1-13.25 (type "E") - (ty-header @13.1-13.2 (name "E"))) - (alias @14.1-14.11 (type "F") - (ty-header @14.1-14.2 (name "F")))) + (ty-rigid-var @10.3-10.4 (name "a")) + (ty-rigid-var @10.6-10.7 (name "b"))))) + (alias @11.1-11.25 (type "E") + (ty-header @11.1-11.2 (name "E"))) + (alias @12.1-12.11 (type "F") + (ty-header @12.1-12.2 (name "F")))) (expressions - (expr @18.5-31.2 (type "[Z1((field, field2)), Z2(c, d), Z3(f), Z4(List(elem))]others, [Z1((field3, field4)), Z2(i, j), Z3(k), Z4(List(elem2))]others2 -> _ret")))) + (expr @16.5-29.2 (type "[Z1((c, d)), Z2(c, f), Z3({ a: c, b: i }), Z4(List(c))]j, [Z1((c, d)), Z2(c, f), Z3({ a: c, b: i }), Z4(List(c))]j -> c")))) ~~~ diff --git a/test/snapshots/formatting/singleline/module.md b/test/snapshots/formatting/singleline/module.md index 9b4129bad8..4d65f65553 100644 --- a/test/snapshots/formatting/singleline/module.md +++ b/test/snapshots/formatting/singleline/module.md @@ -1,12 +1,10 @@ # META ~~~ini description=Singleline formatting module -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [a, b] - a = 'a' b = 'a' ~~~ @@ -16,27 +14,21 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:10),Comma(1:10-1:11),LowerIdent(1:12-1:13),CloseSquare(1:13-1:14), -LowerIdent(3:1-3:2),OpAssign(3:3-3:4),SingleQuote(3:5-3:8), -LowerIdent(4:1-4:2),OpAssign(4:3-4:4),SingleQuote(4:5-4:8), -EndOfFile(5:1-5:1), +LowerIdent(1:1-1:2),OpAssign(1:3-1:4),SingleQuote(1:5-1:8), +LowerIdent(2:1-2:2),OpAssign(2:3-2:4),SingleQuote(2:5-2:8), +EndOfFile(3:1-3:1), ~~~ # PARSE ~~~clojure -(file @1.1-4.8 - (module @1.1-1.14 - (exposes @1.8-1.14 - (exposed-lower-ident @1.9-1.10 - (text "a")) - (exposed-lower-ident @1.12-1.13 - (text "b")))) +(file @1.1-2.8 + (type-module @1.1-1.2) (statements - (s-decl @3.1-3.8 - (p-ident @3.1-3.2 (raw "a")) - (e-single-quote @3.5-3.8 (raw "'a'"))) - (s-decl @4.1-4.8 - (p-ident @4.1-4.2 (raw "b")) - (e-single-quote @4.5-4.8 (raw "'a'"))))) + (s-decl @1.1-1.8 + (p-ident @1.1-1.2 (raw "a")) + (e-single-quote @1.5-1.8 (raw "'a'"))) + (s-decl @2.1-2.8 + (p-ident @2.1-2.2 (raw "b")) + (e-single-quote @2.5-2.8 (raw "'a'"))))) ~~~ # FORMATTED ~~~roc @@ -46,19 +38,19 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @3.1-3.2 (ident "a")) - (e-int @3.5-3.8 (value "97"))) + (p-assign @1.1-1.2 (ident "a")) + (e-num @1.5-1.8 (value "97"))) (d-let - (p-assign @4.1-4.2 (ident "b")) - (e-int @4.5-4.8 (value "97")))) + (p-assign @2.1-2.2 (ident "b")) + (e-num @2.5-2.8 (value "97")))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @3.1-3.2 (type "Num(_size)")) - (patt @4.1-4.2 (type "Num(_size)"))) + (patt @1.1-1.2 (type "Num(Int(_size))")) + (patt @2.1-2.2 (type "Num(Int(_size))"))) (expressions - (expr @3.5-3.8 (type "Num(_size)")) - (expr @4.5-4.8 (type "Num(_size)")))) + (expr @1.5-1.8 (type "Num(Int(_size))")) + (expr @2.5-2.8 (type "Num(Int(_size))")))) ~~~ diff --git a/test/snapshots/formatting/singleline_with_comma/everything.md b/test/snapshots/formatting/singleline_with_comma/everything.md index ada7a3b04f..bda600c575 100644 --- a/test/snapshots/formatting/singleline_with_comma/everything.md +++ b/test/snapshots/formatting/singleline_with_comma/everything.md @@ -1,12 +1,10 @@ # META ~~~ini description=Singleline with comma formatting everything -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - # Import exposing import I1 exposing [I11, I12,] import I2 exposing [I21 as Ias1, I22 as Ias2,] @@ -38,25 +36,25 @@ h = |x, y,| { } ~~~ # EXPECTED -WHERE CLAUSE NOT ALLOWED IN TYPE DECLARATION - everything.md:8:1:8:77 -WHERE CLAUSE NOT ALLOWED IN TYPE DECLARATION - everything.md:9:1:9:77 -MODULE NOT FOUND - everything.md:4:1:4:31 -MODULE NOT FOUND - everything.md:5:1:5:47 -UNUSED VARIABLE - everything.md:26:10:26:11 -UNUSED VARIABLE - everything.md:27:9:27:10 -UNUSED VARIABLE - everything.md:28:11:28:12 -UNUSED VARIABLE - everything.md:29:10:29:11 +WHERE CLAUSE NOT ALLOWED IN TYPE DECLARATION - everything.md:6:1:6:77 +WHERE CLAUSE NOT ALLOWED IN TYPE DECLARATION - everything.md:7:1:7:77 +MODULE NOT FOUND - everything.md:2:1:2:31 +MODULE NOT FOUND - everything.md:3:1:3:47 +UNUSED VARIABLE - everything.md:24:10:24:11 +UNUSED VARIABLE - everything.md:25:9:25:10 +UNUSED VARIABLE - everything.md:26:11:26:12 +UNUSED VARIABLE - everything.md:27:10:27:11 +UNUSED VARIABLE - everything.md:17:2:17:4 +UNUSED VARIABLE - everything.md:18:2:18:4 UNUSED VARIABLE - everything.md:19:2:19:4 UNUSED VARIABLE - everything.md:20:2:20:4 UNUSED VARIABLE - everything.md:21:2:21:4 -UNUSED VARIABLE - everything.md:22:2:22:4 -UNUSED VARIABLE - everything.md:23:2:23:4 # PROBLEMS **WHERE CLAUSE NOT ALLOWED IN TYPE DECLARATION** You cannot define a `where` clause inside a type declaration. You're attempting do this here: -**everything.md:8:1:8:77:** +**everything.md:6:1:6:77:** ```roc A(a) : a where module(a).a1 : (a, a,) -> Str, module(a).a2 : (a, a,) -> Str, ``` @@ -67,7 +65,7 @@ A(a) : a where module(a).a1 : (a, a,) -> Str, module(a).a2 : (a, a,) -> Str, You cannot define a `where` clause inside a type declaration. You're attempting do this here: -**everything.md:9:1:9:77:** +**everything.md:7:1:7:77:** ```roc B(b) : b where module(b).b1 : (b, b,) -> Str, module(b).b2 : (b, b,) -> Str, ``` @@ -78,7 +76,7 @@ B(b) : b where module(b).b1 : (b, b,) -> Str, module(b).b2 : (b, b,) -> Str, The module `I1` was not found in this Roc project. You're attempting to use this module here: -**everything.md:4:1:4:31:** +**everything.md:2:1:2:31:** ```roc import I1 exposing [I11, I12,] ``` @@ -89,7 +87,7 @@ import I1 exposing [I11, I12,] The module `I2` was not found in this Roc project. You're attempting to use this module here: -**everything.md:5:1:5:47:** +**everything.md:3:1:3:47:** ```roc import I2 exposing [I21 as Ias1, I22 as Ias2,] ``` @@ -101,7 +99,7 @@ Variable `b` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_b` to suppress this warning. The unused variable is declared here: -**everything.md:26:10:26:11:** +**everything.md:24:10:24:11:** ```roc Z1((a, b,)) => a ``` @@ -113,7 +111,7 @@ Variable `b` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_b` to suppress this warning. The unused variable is declared here: -**everything.md:27:9:27:10:** +**everything.md:25:9:25:10:** ```roc Z2(a, b,) => a ``` @@ -125,7 +123,7 @@ Variable `b` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_b` to suppress this warning. The unused variable is declared here: -**everything.md:28:11:28:12:** +**everything.md:26:11:26:12:** ```roc Z3({ a, b, }) => a ``` @@ -137,7 +135,7 @@ Variable `b` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_b` to suppress this warning. The unused variable is declared here: -**everything.md:29:10:29:11:** +**everything.md:27:10:27:11:** ```roc Z4([a, b,]) => a ``` @@ -149,7 +147,7 @@ Variable `h1` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_h1` to suppress this warning. The unused variable is declared here: -**everything.md:19:2:19:4:** +**everything.md:17:2:17:4:** ```roc h1 = { h11: x, h12: x, h13: { h131: x, h132: y, }, } ``` @@ -161,7 +159,7 @@ Variable `h2` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_h2` to suppress this warning. The unused variable is declared here: -**everything.md:20:2:20:4:** +**everything.md:18:2:18:4:** ```roc h2 = h(x, y,) ``` @@ -173,7 +171,7 @@ Variable `h3` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_h3` to suppress this warning. The unused variable is declared here: -**everything.md:21:2:21:4:** +**everything.md:19:2:19:4:** ```roc h3 = A(x, y,) ``` @@ -185,7 +183,7 @@ Variable `h4` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_h4` to suppress this warning. The unused variable is declared here: -**everything.md:22:2:22:4:** +**everything.md:20:2:20:4:** ```roc h4 = [x, y,] ``` @@ -197,7 +195,7 @@ Variable `h5` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_h5` to suppress this warning. The unused variable is declared here: -**everything.md:23:2:23:4:** +**everything.md:21:2:21:4:** ```roc h5 = (x, y,) ``` @@ -206,194 +204,165 @@ The unused variable is declared here: # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -KwImport(4:1-4:7),UpperIdent(4:8-4:10),KwExposing(4:11-4:19),OpenSquare(4:20-4:21),UpperIdent(4:21-4:24),Comma(4:24-4:25),UpperIdent(4:26-4:29),Comma(4:29-4:30),CloseSquare(4:30-4:31), -KwImport(5:1-5:7),UpperIdent(5:8-5:10),KwExposing(5:11-5:19),OpenSquare(5:20-5:21),UpperIdent(5:21-5:24),KwAs(5:25-5:27),UpperIdent(5:28-5:32),Comma(5:32-5:33),UpperIdent(5:34-5:37),KwAs(5:38-5:40),UpperIdent(5:41-5:45),Comma(5:45-5:46),CloseSquare(5:46-5:47), -UpperIdent(8:1-8:2),NoSpaceOpenRound(8:2-8:3),LowerIdent(8:3-8:4),CloseRound(8:4-8:5),OpColon(8:6-8:7),LowerIdent(8:8-8:9),KwWhere(8:10-8:15),KwModule(8:16-8:22),NoSpaceOpenRound(8:22-8:23),LowerIdent(8:23-8:24),CloseRound(8:24-8:25),NoSpaceDotLowerIdent(8:25-8:28),OpColon(8:29-8:30),OpenRound(8:31-8:32),LowerIdent(8:32-8:33),Comma(8:33-8:34),LowerIdent(8:35-8:36),Comma(8:36-8:37),CloseRound(8:37-8:38),OpArrow(8:39-8:41),UpperIdent(8:42-8:45),Comma(8:45-8:46),KwModule(8:47-8:53),NoSpaceOpenRound(8:53-8:54),LowerIdent(8:54-8:55),CloseRound(8:55-8:56),NoSpaceDotLowerIdent(8:56-8:59),OpColon(8:60-8:61),OpenRound(8:62-8:63),LowerIdent(8:63-8:64),Comma(8:64-8:65),LowerIdent(8:66-8:67),Comma(8:67-8:68),CloseRound(8:68-8:69),OpArrow(8:70-8:72),UpperIdent(8:73-8:76),Comma(8:76-8:77), -UpperIdent(9:1-9:2),NoSpaceOpenRound(9:2-9:3),LowerIdent(9:3-9:4),CloseRound(9:4-9:5),OpColon(9:6-9:7),LowerIdent(9:8-9:9),KwWhere(9:10-9:15),KwModule(9:16-9:22),NoSpaceOpenRound(9:22-9:23),LowerIdent(9:23-9:24),CloseRound(9:24-9:25),NoSpaceDotLowerIdent(9:25-9:28),OpColon(9:29-9:30),OpenRound(9:31-9:32),LowerIdent(9:32-9:33),Comma(9:33-9:34),LowerIdent(9:35-9:36),Comma(9:36-9:37),CloseRound(9:37-9:38),OpArrow(9:39-9:41),UpperIdent(9:42-9:45),Comma(9:45-9:46),KwModule(9:47-9:53),NoSpaceOpenRound(9:53-9:54),LowerIdent(9:54-9:55),CloseRound(9:55-9:56),NoSpaceDotLowerIdent(9:56-9:59),OpColon(9:60-9:61),OpenRound(9:62-9:63),LowerIdent(9:63-9:64),Comma(9:64-9:65),LowerIdent(9:66-9:67),Comma(9:67-9:68),CloseRound(9:68-9:69),OpArrow(9:70-9:72),UpperIdent(9:73-9:76),Comma(9:76-9:77), -UpperIdent(11:1-11:2),NoSpaceOpenRound(11:2-11:3),LowerIdent(11:3-11:4),Comma(11:4-11:5),LowerIdent(11:6-11:7),Comma(11:7-11:8),CloseRound(11:8-11:9),OpColon(11:10-11:11),OpenRound(11:12-11:13),LowerIdent(11:13-11:14),Comma(11:14-11:15),LowerIdent(11:16-11:17),Comma(11:17-11:18),CloseRound(11:18-11:19), -UpperIdent(12:1-12:2),NoSpaceOpenRound(12:2-12:3),LowerIdent(12:3-12:4),Comma(12:4-12:5),LowerIdent(12:6-12:7),Comma(12:7-12:8),CloseRound(12:8-12:9),OpColon(12:10-12:11),UpperIdent(12:12-12:13),NoSpaceOpenRound(12:13-12:14),LowerIdent(12:14-12:15),Comma(12:15-12:16),LowerIdent(12:17-12:18),Comma(12:18-12:19),CloseRound(12:19-12:20), -UpperIdent(13:1-13:2),OpColon(13:3-13:4),OpenCurly(13:5-13:6),LowerIdent(13:7-13:8),OpColon(13:9-13:10),UpperIdent(13:11-13:14),Comma(13:14-13:15),LowerIdent(13:16-13:17),OpColon(13:18-13:19),UpperIdent(13:20-13:23),Comma(13:23-13:24),CloseCurly(13:25-13:26), -UpperIdent(14:1-14:2),OpColon(14:3-14:4),OpenSquare(14:5-14:6),UpperIdent(14:6-14:7),Comma(14:7-14:8),UpperIdent(14:9-14:10),Comma(14:10-14:11),CloseSquare(14:11-14:12), -LowerIdent(16:1-16:2),OpColon(16:3-16:4),LowerIdent(16:5-16:6),OpArrow(16:7-16:9),LowerIdent(16:10-16:11),KwWhere(16:12-16:17),KwModule(16:18-16:24),NoSpaceOpenRound(16:24-16:25),LowerIdent(16:25-16:26),CloseRound(16:26-16:27),NoSpaceDotUpperIdent(16:27-16:29),Comma(16:29-16:30),KwModule(16:31-16:37),NoSpaceOpenRound(16:37-16:38),LowerIdent(16:38-16:39),CloseRound(16:39-16:40),NoSpaceDotUpperIdent(16:40-16:42),Comma(16:42-16:43), -LowerIdent(18:1-18:2),OpAssign(18:3-18:4),OpBar(18:5-18:6),LowerIdent(18:6-18:7),Comma(18:7-18:8),LowerIdent(18:9-18:10),Comma(18:10-18:11),OpBar(18:11-18:12),OpenCurly(18:13-18:14), -LowerIdent(19:2-19:4),OpAssign(19:5-19:6),OpenCurly(19:7-19:8),LowerIdent(19:9-19:12),OpColon(19:12-19:13),LowerIdent(19:14-19:15),Comma(19:15-19:16),LowerIdent(19:17-19:20),OpColon(19:20-19:21),LowerIdent(19:22-19:23),Comma(19:23-19:24),LowerIdent(19:25-19:28),OpColon(19:28-19:29),OpenCurly(19:30-19:31),LowerIdent(19:32-19:36),OpColon(19:36-19:37),LowerIdent(19:38-19:39),Comma(19:39-19:40),LowerIdent(19:41-19:45),OpColon(19:45-19:46),LowerIdent(19:47-19:48),Comma(19:48-19:49),CloseCurly(19:50-19:51),Comma(19:51-19:52),CloseCurly(19:53-19:54), -LowerIdent(20:2-20:4),OpAssign(20:5-20:6),LowerIdent(20:7-20:8),NoSpaceOpenRound(20:8-20:9),LowerIdent(20:9-20:10),Comma(20:10-20:11),LowerIdent(20:12-20:13),Comma(20:13-20:14),CloseRound(20:14-20:15), -LowerIdent(21:2-21:4),OpAssign(21:5-21:6),UpperIdent(21:7-21:8),NoSpaceOpenRound(21:8-21:9),LowerIdent(21:9-21:10),Comma(21:10-21:11),LowerIdent(21:12-21:13),Comma(21:13-21:14),CloseRound(21:14-21:15), -LowerIdent(22:2-22:4),OpAssign(22:5-22:6),OpenSquare(22:7-22:8),LowerIdent(22:8-22:9),Comma(22:9-22:10),LowerIdent(22:11-22:12),Comma(22:12-22:13),CloseSquare(22:13-22:14), -LowerIdent(23:2-23:4),OpAssign(23:5-23:6),OpenRound(23:7-23:8),LowerIdent(23:8-23:9),Comma(23:9-23:10),LowerIdent(23:11-23:12),Comma(23:12-23:13),CloseRound(23:13-23:14), -KwMatch(25:2-25:7),LowerIdent(25:8-25:9),OpenCurly(25:10-25:11), -UpperIdent(26:3-26:5),NoSpaceOpenRound(26:5-26:6),NoSpaceOpenRound(26:6-26:7),LowerIdent(26:7-26:8),Comma(26:8-26:9),LowerIdent(26:10-26:11),Comma(26:11-26:12),CloseRound(26:12-26:13),CloseRound(26:13-26:14),OpFatArrow(26:15-26:17),LowerIdent(26:18-26:19), -UpperIdent(27:3-27:5),NoSpaceOpenRound(27:5-27:6),LowerIdent(27:6-27:7),Comma(27:7-27:8),LowerIdent(27:9-27:10),Comma(27:10-27:11),CloseRound(27:11-27:12),OpFatArrow(27:13-27:15),LowerIdent(27:16-27:17), -UpperIdent(28:3-28:5),NoSpaceOpenRound(28:5-28:6),OpenCurly(28:6-28:7),LowerIdent(28:8-28:9),Comma(28:9-28:10),LowerIdent(28:11-28:12),Comma(28:12-28:13),CloseCurly(28:14-28:15),CloseRound(28:15-28:16),OpFatArrow(28:17-28:19),LowerIdent(28:20-28:21), -UpperIdent(29:3-29:5),NoSpaceOpenRound(29:5-29:6),OpenSquare(29:6-29:7),LowerIdent(29:7-29:8),Comma(29:8-29:9),LowerIdent(29:10-29:11),Comma(29:11-29:12),CloseSquare(29:12-29:13),CloseRound(29:13-29:14),OpFatArrow(29:15-29:17),LowerIdent(29:18-29:19), -CloseCurly(30:2-30:3), -CloseCurly(31:1-31:2), -EndOfFile(32:1-32:1), +KwImport(2:1-2:7),UpperIdent(2:8-2:10),KwExposing(2:11-2:19),OpenSquare(2:20-2:21),UpperIdent(2:21-2:24),Comma(2:24-2:25),UpperIdent(2:26-2:29),Comma(2:29-2:30),CloseSquare(2:30-2:31), +KwImport(3:1-3:7),UpperIdent(3:8-3:10),KwExposing(3:11-3:19),OpenSquare(3:20-3:21),UpperIdent(3:21-3:24),KwAs(3:25-3:27),UpperIdent(3:28-3:32),Comma(3:32-3:33),UpperIdent(3:34-3:37),KwAs(3:38-3:40),UpperIdent(3:41-3:45),Comma(3:45-3:46),CloseSquare(3:46-3:47), +UpperIdent(6:1-6:2),NoSpaceOpenRound(6:2-6:3),LowerIdent(6:3-6:4),CloseRound(6:4-6:5),OpColon(6:6-6:7),LowerIdent(6:8-6:9),KwWhere(6:10-6:15),KwModule(6:16-6:22),NoSpaceOpenRound(6:22-6:23),LowerIdent(6:23-6:24),CloseRound(6:24-6:25),NoSpaceDotLowerIdent(6:25-6:28),OpColon(6:29-6:30),OpenRound(6:31-6:32),LowerIdent(6:32-6:33),Comma(6:33-6:34),LowerIdent(6:35-6:36),Comma(6:36-6:37),CloseRound(6:37-6:38),OpArrow(6:39-6:41),UpperIdent(6:42-6:45),Comma(6:45-6:46),KwModule(6:47-6:53),NoSpaceOpenRound(6:53-6:54),LowerIdent(6:54-6:55),CloseRound(6:55-6:56),NoSpaceDotLowerIdent(6:56-6:59),OpColon(6:60-6:61),OpenRound(6:62-6:63),LowerIdent(6:63-6:64),Comma(6:64-6:65),LowerIdent(6:66-6:67),Comma(6:67-6:68),CloseRound(6:68-6:69),OpArrow(6:70-6:72),UpperIdent(6:73-6:76),Comma(6:76-6:77), +UpperIdent(7:1-7:2),NoSpaceOpenRound(7:2-7:3),LowerIdent(7:3-7:4),CloseRound(7:4-7:5),OpColon(7:6-7:7),LowerIdent(7:8-7:9),KwWhere(7:10-7:15),KwModule(7:16-7:22),NoSpaceOpenRound(7:22-7:23),LowerIdent(7:23-7:24),CloseRound(7:24-7:25),NoSpaceDotLowerIdent(7:25-7:28),OpColon(7:29-7:30),OpenRound(7:31-7:32),LowerIdent(7:32-7:33),Comma(7:33-7:34),LowerIdent(7:35-7:36),Comma(7:36-7:37),CloseRound(7:37-7:38),OpArrow(7:39-7:41),UpperIdent(7:42-7:45),Comma(7:45-7:46),KwModule(7:47-7:53),NoSpaceOpenRound(7:53-7:54),LowerIdent(7:54-7:55),CloseRound(7:55-7:56),NoSpaceDotLowerIdent(7:56-7:59),OpColon(7:60-7:61),OpenRound(7:62-7:63),LowerIdent(7:63-7:64),Comma(7:64-7:65),LowerIdent(7:66-7:67),Comma(7:67-7:68),CloseRound(7:68-7:69),OpArrow(7:70-7:72),UpperIdent(7:73-7:76),Comma(7:76-7:77), +UpperIdent(9:1-9:2),NoSpaceOpenRound(9:2-9:3),LowerIdent(9:3-9:4),Comma(9:4-9:5),LowerIdent(9:6-9:7),Comma(9:7-9:8),CloseRound(9:8-9:9),OpColon(9:10-9:11),OpenRound(9:12-9:13),LowerIdent(9:13-9:14),Comma(9:14-9:15),LowerIdent(9:16-9:17),Comma(9:17-9:18),CloseRound(9:18-9:19), +UpperIdent(10:1-10:2),NoSpaceOpenRound(10:2-10:3),LowerIdent(10:3-10:4),Comma(10:4-10:5),LowerIdent(10:6-10:7),Comma(10:7-10:8),CloseRound(10:8-10:9),OpColon(10:10-10:11),UpperIdent(10:12-10:13),NoSpaceOpenRound(10:13-10:14),LowerIdent(10:14-10:15),Comma(10:15-10:16),LowerIdent(10:17-10:18),Comma(10:18-10:19),CloseRound(10:19-10:20), +UpperIdent(11:1-11:2),OpColon(11:3-11:4),OpenCurly(11:5-11:6),LowerIdent(11:7-11:8),OpColon(11:9-11:10),UpperIdent(11:11-11:14),Comma(11:14-11:15),LowerIdent(11:16-11:17),OpColon(11:18-11:19),UpperIdent(11:20-11:23),Comma(11:23-11:24),CloseCurly(11:25-11:26), +UpperIdent(12:1-12:2),OpColon(12:3-12:4),OpenSquare(12:5-12:6),UpperIdent(12:6-12:7),Comma(12:7-12:8),UpperIdent(12:9-12:10),Comma(12:10-12:11),CloseSquare(12:11-12:12), +LowerIdent(14:1-14:2),OpColon(14:3-14:4),LowerIdent(14:5-14:6),OpArrow(14:7-14:9),LowerIdent(14:10-14:11),KwWhere(14:12-14:17),KwModule(14:18-14:24),NoSpaceOpenRound(14:24-14:25),LowerIdent(14:25-14:26),CloseRound(14:26-14:27),NoSpaceDotUpperIdent(14:27-14:29),Comma(14:29-14:30),KwModule(14:31-14:37),NoSpaceOpenRound(14:37-14:38),LowerIdent(14:38-14:39),CloseRound(14:39-14:40),NoSpaceDotUpperIdent(14:40-14:42),Comma(14:42-14:43), +LowerIdent(16:1-16:2),OpAssign(16:3-16:4),OpBar(16:5-16:6),LowerIdent(16:6-16:7),Comma(16:7-16:8),LowerIdent(16:9-16:10),Comma(16:10-16:11),OpBar(16:11-16:12),OpenCurly(16:13-16:14), +LowerIdent(17:2-17:4),OpAssign(17:5-17:6),OpenCurly(17:7-17:8),LowerIdent(17:9-17:12),OpColon(17:12-17:13),LowerIdent(17:14-17:15),Comma(17:15-17:16),LowerIdent(17:17-17:20),OpColon(17:20-17:21),LowerIdent(17:22-17:23),Comma(17:23-17:24),LowerIdent(17:25-17:28),OpColon(17:28-17:29),OpenCurly(17:30-17:31),LowerIdent(17:32-17:36),OpColon(17:36-17:37),LowerIdent(17:38-17:39),Comma(17:39-17:40),LowerIdent(17:41-17:45),OpColon(17:45-17:46),LowerIdent(17:47-17:48),Comma(17:48-17:49),CloseCurly(17:50-17:51),Comma(17:51-17:52),CloseCurly(17:53-17:54), +LowerIdent(18:2-18:4),OpAssign(18:5-18:6),LowerIdent(18:7-18:8),NoSpaceOpenRound(18:8-18:9),LowerIdent(18:9-18:10),Comma(18:10-18:11),LowerIdent(18:12-18:13),Comma(18:13-18:14),CloseRound(18:14-18:15), +LowerIdent(19:2-19:4),OpAssign(19:5-19:6),UpperIdent(19:7-19:8),NoSpaceOpenRound(19:8-19:9),LowerIdent(19:9-19:10),Comma(19:10-19:11),LowerIdent(19:12-19:13),Comma(19:13-19:14),CloseRound(19:14-19:15), +LowerIdent(20:2-20:4),OpAssign(20:5-20:6),OpenSquare(20:7-20:8),LowerIdent(20:8-20:9),Comma(20:9-20:10),LowerIdent(20:11-20:12),Comma(20:12-20:13),CloseSquare(20:13-20:14), +LowerIdent(21:2-21:4),OpAssign(21:5-21:6),OpenRound(21:7-21:8),LowerIdent(21:8-21:9),Comma(21:9-21:10),LowerIdent(21:11-21:12),Comma(21:12-21:13),CloseRound(21:13-21:14), +KwMatch(23:2-23:7),LowerIdent(23:8-23:9),OpenCurly(23:10-23:11), +UpperIdent(24:3-24:5),NoSpaceOpenRound(24:5-24:6),NoSpaceOpenRound(24:6-24:7),LowerIdent(24:7-24:8),Comma(24:8-24:9),LowerIdent(24:10-24:11),Comma(24:11-24:12),CloseRound(24:12-24:13),CloseRound(24:13-24:14),OpFatArrow(24:15-24:17),LowerIdent(24:18-24:19), +UpperIdent(25:3-25:5),NoSpaceOpenRound(25:5-25:6),LowerIdent(25:6-25:7),Comma(25:7-25:8),LowerIdent(25:9-25:10),Comma(25:10-25:11),CloseRound(25:11-25:12),OpFatArrow(25:13-25:15),LowerIdent(25:16-25:17), +UpperIdent(26:3-26:5),NoSpaceOpenRound(26:5-26:6),OpenCurly(26:6-26:7),LowerIdent(26:8-26:9),Comma(26:9-26:10),LowerIdent(26:11-26:12),Comma(26:12-26:13),CloseCurly(26:14-26:15),CloseRound(26:15-26:16),OpFatArrow(26:17-26:19),LowerIdent(26:20-26:21), +UpperIdent(27:3-27:5),NoSpaceOpenRound(27:5-27:6),OpenSquare(27:6-27:7),LowerIdent(27:7-27:8),Comma(27:8-27:9),LowerIdent(27:10-27:11),Comma(27:11-27:12),CloseSquare(27:12-27:13),CloseRound(27:13-27:14),OpFatArrow(27:15-27:17),LowerIdent(27:18-27:19), +CloseCurly(28:2-28:3), +CloseCurly(29:1-29:2), +EndOfFile(30:1-30:1), ~~~ # PARSE ~~~clojure -(file @1.1-31.2 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @2.1-29.2 + (type-module @2.1-2.7) (statements - (s-import @4.1-4.31 (raw "I1") + (s-import @2.1-2.31 (raw "I1") (exposing - (exposed-upper-ident @4.21-4.24 (text "I11")) - (exposed-upper-ident @4.26-4.29 (text "I12")))) - (s-import @5.1-5.47 (raw "I2") + (exposed-upper-ident @2.21-2.24 (text "I11")) + (exposed-upper-ident @2.26-2.29 (text "I12")))) + (s-import @3.1-3.47 (raw "I2") (exposing - (exposed-upper-ident @5.21-5.32 (text "I21") (as "Ias1")) - (exposed-upper-ident @5.34-5.45 (text "I22") (as "Ias2")))) - (s-type-decl @8.1-8.77 - (header @8.1-8.5 (name "A") + (exposed-upper-ident @3.21-3.32 (text "I21") (as "Ias1")) + (exposed-upper-ident @3.34-3.45 (text "I22") (as "Ias2")))) + (s-type-decl @6.1-6.77 + (header @6.1-6.5 (name "A") (args - (ty-var @8.3-8.4 (raw "a")))) - (ty-var @8.8-8.9 (raw "a")) - (where - (method @8.16-8.45 (module-of "a") (name "a1") - (args - (ty-tuple @8.31-8.38 - (ty-var @8.32-8.33 (raw "a")) - (ty-var @8.35-8.36 (raw "a")))) - (ty @8.42-8.45 (name "Str"))) - (method @8.47-8.76 (module-of "a") (name "a2") - (args - (ty-tuple @8.62-8.69 - (ty-var @8.63-8.64 (raw "a")) - (ty-var @8.66-8.67 (raw "a")))) - (ty @8.73-8.76 (name "Str"))))) - (s-type-decl @9.1-9.77 - (header @9.1-9.5 (name "B") + (ty-var @6.3-6.4 (raw "a")))) + (ty-var @6.8-6.9 (raw "a"))) + (s-type-decl @7.1-7.77 + (header @7.1-7.5 (name "B") (args - (ty-var @9.3-9.4 (raw "b")))) - (ty-var @9.8-9.9 (raw "b")) - (where - (method @9.16-9.45 (module-of "b") (name "b1") - (args - (ty-tuple @9.31-9.38 - (ty-var @9.32-9.33 (raw "b")) - (ty-var @9.35-9.36 (raw "b")))) - (ty @9.42-9.45 (name "Str"))) - (method @9.47-9.76 (module-of "b") (name "b2") - (args - (ty-tuple @9.62-9.69 - (ty-var @9.63-9.64 (raw "b")) - (ty-var @9.66-9.67 (raw "b")))) - (ty @9.73-9.76 (name "Str"))))) - (s-type-decl @11.1-11.19 - (header @11.1-11.9 (name "C") + (ty-var @7.3-7.4 (raw "b")))) + (ty-var @7.8-7.9 (raw "b"))) + (s-type-decl @9.1-9.19 + (header @9.1-9.9 (name "C") (args - (ty-var @11.3-11.4 (raw "a")) - (ty-var @11.6-11.7 (raw "b")))) - (ty-tuple @11.12-11.19 - (ty-var @11.13-11.14 (raw "a")) - (ty-var @11.16-11.17 (raw "b")))) - (s-type-decl @12.1-12.20 - (header @12.1-12.9 (name "D") + (ty-var @9.3-9.4 (raw "a")) + (ty-var @9.6-9.7 (raw "b")))) + (ty-tuple @9.12-9.19 + (ty-var @9.13-9.14 (raw "a")) + (ty-var @9.16-9.17 (raw "b")))) + (s-type-decl @10.1-10.20 + (header @10.1-10.9 (name "D") (args - (ty-var @12.3-12.4 (raw "a")) - (ty-var @12.6-12.7 (raw "b")))) - (ty-apply @12.12-12.20 - (ty @12.12-12.13 (name "C")) - (ty-var @12.14-12.15 (raw "a")) - (ty-var @12.17-12.18 (raw "b")))) - (s-type-decl @13.1-13.26 - (header @13.1-13.2 (name "E") + (ty-var @10.3-10.4 (raw "a")) + (ty-var @10.6-10.7 (raw "b")))) + (ty-apply @10.12-10.20 + (ty @10.12-10.13 (name "C")) + (ty-var @10.14-10.15 (raw "a")) + (ty-var @10.17-10.18 (raw "b")))) + (s-type-decl @11.1-11.26 + (header @11.1-11.2 (name "E") (args)) - (ty-record @13.5-13.26 - (anno-record-field @13.7-13.14 (name "a") - (ty @13.11-13.14 (name "Str"))) - (anno-record-field @13.16-13.23 (name "b") - (ty @13.20-13.23 (name "Str"))))) - (s-type-decl @14.1-14.12 - (header @14.1-14.2 (name "F") + (ty-record @11.5-11.26 + (anno-record-field @11.7-11.14 (name "a") + (ty @11.11-11.14 (name "Str"))) + (anno-record-field @11.16-11.23 (name "b") + (ty @11.20-11.23 (name "Str"))))) + (s-type-decl @12.1-12.12 + (header @12.1-12.2 (name "F") (args)) - (ty-tag-union @14.5-14.12 + (ty-tag-union @12.5-12.12 (tags - (ty @14.6-14.7 (name "A")) - (ty @14.9-14.10 (name "B"))))) - (s-type-anno @16.1-16.43 (name "g") - (ty-fn @16.5-16.11 - (ty-var @16.5-16.6 (raw "e")) - (ty-var @16.10-16.11 (raw "e"))) + (ty @12.6-12.7 (name "A")) + (ty @12.9-12.10 (name "B"))))) + (s-type-anno @14.1-14.43 (name "g") + (ty-fn @14.5-14.11 + (ty-var @14.5-14.6 (raw "e")) + (ty-var @14.10-14.11 (raw "e"))) (where - (alias @16.18-16.29 (module-of "e") (name "A")) - (alias @16.31-16.42 (module-of "e") (name "B")))) - (s-decl @18.1-31.2 - (p-ident @18.1-18.2 (raw "h")) - (e-lambda @18.5-31.2 + (alias @14.18-14.29 (module-of "e") (name "A")) + (alias @14.31-14.42 (module-of "e") (name "B")))) + (s-decl @16.1-29.2 + (p-ident @16.1-16.2 (raw "h")) + (e-lambda @16.5-29.2 (args - (p-ident @18.6-18.7 (raw "x")) - (p-ident @18.9-18.10 (raw "y"))) - (e-block @18.13-31.2 + (p-ident @16.6-16.7 (raw "x")) + (p-ident @16.9-16.10 (raw "y"))) + (e-block @16.13-29.2 (statements - (s-decl @19.2-19.54 - (p-ident @19.2-19.4 (raw "h1")) - (e-record @19.7-19.54 + (s-decl @17.2-17.54 + (p-ident @17.2-17.4 (raw "h1")) + (e-record @17.7-17.54 (field (field "h11") - (e-ident @19.14-19.15 (raw "x"))) + (e-ident @17.14-17.15 (raw "x"))) (field (field "h12") - (e-ident @19.22-19.23 (raw "x"))) + (e-ident @17.22-17.23 (raw "x"))) (field (field "h13") - (e-record @19.30-19.51 + (e-record @17.30-17.51 (field (field "h131") - (e-ident @19.38-19.39 (raw "x"))) + (e-ident @17.38-17.39 (raw "x"))) (field (field "h132") - (e-ident @19.47-19.48 (raw "y"))))))) - (s-decl @20.2-20.15 - (p-ident @20.2-20.4 (raw "h2")) - (e-apply @20.7-20.15 - (e-ident @20.7-20.8 (raw "h")) - (e-ident @20.9-20.10 (raw "x")) - (e-ident @20.12-20.13 (raw "y")))) - (s-decl @21.2-21.15 - (p-ident @21.2-21.4 (raw "h3")) - (e-apply @21.7-21.15 - (e-tag @21.7-21.8 (raw "A")) - (e-ident @21.9-21.10 (raw "x")) - (e-ident @21.12-21.13 (raw "y")))) - (s-decl @22.2-22.14 - (p-ident @22.2-22.4 (raw "h4")) - (e-list @22.7-22.14 - (e-ident @22.8-22.9 (raw "x")) - (e-ident @22.11-22.12 (raw "y")))) - (s-decl @23.2-23.14 - (p-ident @23.2-23.4 (raw "h5")) - (e-tuple @23.7-23.14 - (e-ident @23.8-23.9 (raw "x")) - (e-ident @23.11-23.12 (raw "y")))) + (e-ident @17.47-17.48 (raw "y"))))))) + (s-decl @18.2-18.15 + (p-ident @18.2-18.4 (raw "h2")) + (e-apply @18.7-18.15 + (e-ident @18.7-18.8 (raw "h")) + (e-ident @18.9-18.10 (raw "x")) + (e-ident @18.12-18.13 (raw "y")))) + (s-decl @19.2-19.15 + (p-ident @19.2-19.4 (raw "h3")) + (e-apply @19.7-19.15 + (e-tag @19.7-19.8 (raw "A")) + (e-ident @19.9-19.10 (raw "x")) + (e-ident @19.12-19.13 (raw "y")))) + (s-decl @20.2-20.14 + (p-ident @20.2-20.4 (raw "h4")) + (e-list @20.7-20.14 + (e-ident @20.8-20.9 (raw "x")) + (e-ident @20.11-20.12 (raw "y")))) + (s-decl @21.2-21.14 + (p-ident @21.2-21.4 (raw "h5")) + (e-tuple @21.7-21.14 + (e-ident @21.8-21.9 (raw "x")) + (e-ident @21.11-21.12 (raw "y")))) (e-match - (e-ident @25.8-25.9 (raw "x")) + (e-ident @23.8-23.9 (raw "x")) (branches - (branch @26.3-26.19 - (p-tag @26.3-26.14 (raw "Z1") - (p-tuple @26.6-26.13 - (p-ident @26.7-26.8 (raw "a")) - (p-ident @26.10-26.11 (raw "b")))) - (e-ident @26.18-26.19 (raw "a"))) - (branch @27.3-27.17 - (p-tag @27.3-27.12 (raw "Z2") - (p-ident @27.6-27.7 (raw "a")) - (p-ident @27.9-27.10 (raw "b"))) - (e-ident @27.16-27.17 (raw "a"))) - (branch @28.3-28.21 - (p-tag @28.3-28.16 (raw "Z3") - (p-record @28.6-28.15 - (field @28.8-28.9 (name "a") (rest false)) - (field @28.11-28.12 (name "b") (rest false)))) - (e-ident @28.20-28.21 (raw "a"))) - (branch @29.3-29.19 - (p-tag @29.3-29.14 (raw "Z4") - (p-list @29.6-29.13 - (p-ident @29.7-29.8 (raw "a")) - (p-ident @29.10-29.11 (raw "b")))) - (e-ident @29.18-29.19 (raw "a"))))))))))) + (branch @24.3-24.19 + (p-tag @24.3-24.14 (raw "Z1") + (p-tuple @24.6-24.13 + (p-ident @24.7-24.8 (raw "a")) + (p-ident @24.10-24.11 (raw "b")))) + (e-ident @24.18-24.19 (raw "a"))) + (branch @25.3-25.17 + (p-tag @25.3-25.12 (raw "Z2") + (p-ident @25.6-25.7 (raw "a")) + (p-ident @25.9-25.10 (raw "b"))) + (e-ident @25.16-25.17 (raw "a"))) + (branch @26.3-26.21 + (p-tag @26.3-26.16 (raw "Z3") + (p-record @26.6-26.15 + (field @26.8-26.9 (name "a") (rest false)) + (field @26.11-26.12 (name "b") (rest false)))) + (e-ident @26.20-26.21 (raw "a"))) + (branch @27.3-27.19 + (p-tag @27.3-27.14 (raw "Z4") + (p-list @27.6-27.13 + (p-ident @27.7-27.8 (raw "a")) + (p-ident @27.10-27.11 (raw "b")))) + (e-ident @27.18-27.19 (raw "a"))))))))))) ~~~ # FORMATTED ~~~roc -module [] - +# Import exposing # Import exposing import I1 exposing [ I11, @@ -510,189 +479,189 @@ h = | ~~~clojure (can-ir (d-let - (p-assign @18.1-18.2 (ident "h")) - (e-closure @18.5-31.2 + (p-assign @16.1-16.2 (ident "h")) + (e-closure @16.5-29.2 (captures - (capture @18.1-18.2 (ident "h")) - (capture @26.7-26.8 (ident "a")) - (capture @28.8-28.9 (ident "a")) - (capture @27.6-27.7 (ident "a")) - (capture @29.7-29.8 (ident "a"))) - (e-lambda @18.5-31.2 + (capture @27.7-27.8 (ident "a")) + (capture @26.8-26.9 (ident "a")) + (capture @24.7-24.8 (ident "a")) + (capture @16.1-16.2 (ident "h")) + (capture @25.6-25.7 (ident "a"))) + (e-lambda @16.5-29.2 (args - (p-assign @18.6-18.7 (ident "x")) - (p-assign @18.9-18.10 (ident "y"))) - (e-block @18.13-31.2 - (s-let @19.2-19.54 - (p-assign @19.2-19.4 (ident "h1")) - (e-record @19.7-19.54 + (p-assign @16.6-16.7 (ident "x")) + (p-assign @16.9-16.10 (ident "y"))) + (e-block @16.13-29.2 + (s-let @17.2-17.54 + (p-assign @17.2-17.4 (ident "h1")) + (e-record @17.7-17.54 (fields (field (name "h11") - (e-lookup-local @19.14-19.15 - (p-assign @18.6-18.7 (ident "x")))) + (e-lookup-local @17.14-17.15 + (p-assign @16.6-16.7 (ident "x")))) (field (name "h12") - (e-lookup-local @19.22-19.23 - (p-assign @18.6-18.7 (ident "x")))) + (e-lookup-local @17.22-17.23 + (p-assign @16.6-16.7 (ident "x")))) (field (name "h13") - (e-record @19.30-19.51 + (e-record @17.30-17.51 (fields (field (name "h131") - (e-lookup-local @19.38-19.39 - (p-assign @18.6-18.7 (ident "x")))) + (e-lookup-local @17.38-17.39 + (p-assign @16.6-16.7 (ident "x")))) (field (name "h132") - (e-lookup-local @19.47-19.48 - (p-assign @18.9-18.10 (ident "y")))))))))) - (s-let @20.2-20.15 - (p-assign @20.2-20.4 (ident "h2")) - (e-call @20.7-20.15 - (e-lookup-local @20.7-20.8 - (p-assign @18.1-18.2 (ident "h"))) - (e-lookup-local @20.9-20.10 - (p-assign @18.6-18.7 (ident "x"))) - (e-lookup-local @20.12-20.13 - (p-assign @18.9-18.10 (ident "y"))))) - (s-let @21.2-21.15 - (p-assign @21.2-21.4 (ident "h3")) - (e-tag @21.7-21.15 (name "A") + (e-lookup-local @17.47-17.48 + (p-assign @16.9-16.10 (ident "y")))))))))) + (s-let @18.2-18.15 + (p-assign @18.2-18.4 (ident "h2")) + (e-call @18.7-18.15 + (e-lookup-local @18.7-18.8 + (p-assign @16.1-16.2 (ident "h"))) + (e-lookup-local @18.9-18.10 + (p-assign @16.6-16.7 (ident "x"))) + (e-lookup-local @18.12-18.13 + (p-assign @16.9-16.10 (ident "y"))))) + (s-let @19.2-19.15 + (p-assign @19.2-19.4 (ident "h3")) + (e-tag @19.7-19.15 (name "A") (args - (e-lookup-local @21.9-21.10 - (p-assign @18.6-18.7 (ident "x"))) - (e-lookup-local @21.12-21.13 - (p-assign @18.9-18.10 (ident "y")))))) - (s-let @22.2-22.14 - (p-assign @22.2-22.4 (ident "h4")) - (e-list @22.7-22.14 + (e-lookup-local @19.9-19.10 + (p-assign @16.6-16.7 (ident "x"))) + (e-lookup-local @19.12-19.13 + (p-assign @16.9-16.10 (ident "y")))))) + (s-let @20.2-20.14 + (p-assign @20.2-20.4 (ident "h4")) + (e-list @20.7-20.14 (elems - (e-lookup-local @22.8-22.9 - (p-assign @18.6-18.7 (ident "x"))) - (e-lookup-local @22.11-22.12 - (p-assign @18.9-18.10 (ident "y")))))) - (s-let @23.2-23.14 - (p-assign @23.2-23.4 (ident "h5")) - (e-tuple @23.7-23.14 + (e-lookup-local @20.8-20.9 + (p-assign @16.6-16.7 (ident "x"))) + (e-lookup-local @20.11-20.12 + (p-assign @16.9-16.10 (ident "y")))))) + (s-let @21.2-21.14 + (p-assign @21.2-21.4 (ident "h5")) + (e-tuple @21.7-21.14 (elems - (e-lookup-local @23.8-23.9 - (p-assign @18.6-18.7 (ident "x"))) - (e-lookup-local @23.11-23.12 - (p-assign @18.9-18.10 (ident "y")))))) - (e-match @25.2-30.3 - (match @25.2-30.3 + (e-lookup-local @21.8-21.9 + (p-assign @16.6-16.7 (ident "x"))) + (e-lookup-local @21.11-21.12 + (p-assign @16.9-16.10 (ident "y")))))) + (e-match @23.2-28.3 + (match @23.2-28.3 (cond - (e-lookup-local @25.8-25.9 - (p-assign @18.6-18.7 (ident "x")))) + (e-lookup-local @23.8-23.9 + (p-assign @16.6-16.7 (ident "x")))) (branches (branch (patterns (pattern (degenerate false) - (p-applied-tag @26.3-26.14))) + (p-applied-tag @24.3-24.14))) (value - (e-lookup-local @26.18-26.19 - (p-assign @26.7-26.8 (ident "a"))))) + (e-lookup-local @24.18-24.19 + (p-assign @24.7-24.8 (ident "a"))))) (branch (patterns (pattern (degenerate false) - (p-applied-tag @27.3-27.12))) + (p-applied-tag @25.3-25.12))) (value - (e-lookup-local @27.16-27.17 - (p-assign @27.6-27.7 (ident "a"))))) + (e-lookup-local @25.16-25.17 + (p-assign @25.6-25.7 (ident "a"))))) (branch (patterns (pattern (degenerate false) - (p-applied-tag @28.3-28.16))) + (p-applied-tag @26.3-26.16))) (value - (e-lookup-local @28.20-28.21 - (p-assign @28.8-28.9 (ident "a"))))) + (e-lookup-local @26.20-26.21 + (p-assign @26.8-26.9 (ident "a"))))) (branch (patterns (pattern (degenerate false) - (p-applied-tag @29.3-29.14))) + (p-applied-tag @27.3-27.14))) (value - (e-lookup-local @29.18-29.19 - (p-assign @29.7-29.8 (ident "a")))))))))))) - (s-alias-decl @8.1-8.77 - (ty-header @8.1-8.5 (name "A") + (e-lookup-local @27.18-27.19 + (p-assign @27.7-27.8 (ident "a")))))))))))) + (s-alias-decl @6.1-6.77 + (ty-header @6.1-6.5 (name "A") (ty-args - (ty-var @8.3-8.4 (name "a")))) - (ty-var @8.8-8.9 (name "a"))) - (s-alias-decl @9.1-9.77 - (ty-header @9.1-9.5 (name "B") + (ty-rigid-var @6.3-6.4 (name "a")))) + (ty-rigid-var-lookup (ty-rigid-var @6.3-6.4 (name "a")))) + (s-alias-decl @7.1-7.77 + (ty-header @7.1-7.5 (name "B") (ty-args - (ty-var @9.3-9.4 (name "b")))) - (ty-var @9.8-9.9 (name "b"))) - (s-alias-decl @11.1-11.19 - (ty-header @11.1-11.9 (name "C") + (ty-rigid-var @7.3-7.4 (name "b")))) + (ty-rigid-var-lookup (ty-rigid-var @7.3-7.4 (name "b")))) + (s-alias-decl @9.1-9.19 + (ty-header @9.1-9.9 (name "C") (ty-args - (ty-var @11.3-11.4 (name "a")) - (ty-var @11.6-11.7 (name "b")))) - (ty-tuple @11.12-11.19 - (ty-var @11.13-11.14 (name "a")) - (ty-var @11.16-11.17 (name "b")))) - (s-alias-decl @12.1-12.20 - (ty-header @12.1-12.9 (name "D") + (ty-rigid-var @9.3-9.4 (name "a")) + (ty-rigid-var @9.6-9.7 (name "b")))) + (ty-tuple @9.12-9.19 + (ty-rigid-var-lookup (ty-rigid-var @9.3-9.4 (name "a"))) + (ty-rigid-var-lookup (ty-rigid-var @9.6-9.7 (name "b"))))) + (s-alias-decl @10.1-10.20 + (ty-header @10.1-10.9 (name "D") (ty-args - (ty-var @12.3-12.4 (name "a")) - (ty-var @12.6-12.7 (name "b")))) - (ty-apply @12.12-12.20 (symbol "C") - (ty-var @12.14-12.15 (name "a")) - (ty-var @12.17-12.18 (name "b")))) - (s-alias-decl @13.1-13.26 - (ty-header @13.1-13.2 (name "E")) - (ty-record @13.5-13.26 + (ty-rigid-var @10.3-10.4 (name "a")) + (ty-rigid-var @10.6-10.7 (name "b")))) + (ty-apply @10.12-10.20 (name "C") (local) + (ty-rigid-var-lookup (ty-rigid-var @10.3-10.4 (name "a"))) + (ty-rigid-var-lookup (ty-rigid-var @10.6-10.7 (name "b"))))) + (s-alias-decl @11.1-11.26 + (ty-header @11.1-11.2 (name "E")) + (ty-record @11.5-11.26 (field (field "a") - (ty @13.11-13.14 (name "Str"))) + (ty-lookup @11.11-11.14 (name "Str") (builtin))) (field (field "b") - (ty @13.20-13.23 (name "Str"))))) - (s-alias-decl @14.1-14.12 - (ty-header @14.1-14.2 (name "F")) - (ty-tag-union @14.5-14.12 - (ty @14.6-14.7 (name "A")) - (ty @14.9-14.10 (name "B")))) - (s-import @4.1-4.31 (module "I1") + (ty-lookup @11.20-11.23 (name "Str") (builtin))))) + (s-alias-decl @12.1-12.12 + (ty-header @12.1-12.2 (name "F")) + (ty-tag-union @12.5-12.12 + (ty-tag-name @12.6-12.7 (name "A")) + (ty-tag-name @12.9-12.10 (name "B")))) + (s-import @2.1-2.31 (module "I1") (exposes (exposed (name "I11") (wildcard false)) (exposed (name "I12") (wildcard false)))) - (s-import @5.1-5.47 (module "I2") + (s-import @3.1-3.47 (module "I2") (exposes (exposed (name "I21") (alias "Ias1") (wildcard false)) (exposed (name "I22") (alias "Ias2") (wildcard false)))) - (s-type-anno @16.1-16.43 (name "g") - (ty-fn @16.5-16.11 (effectful false) - (ty-var @16.5-16.6 (name "e")) - (ty-var @16.10-16.11 (name "e"))) + (s-type-anno @14.1-14.43 (name "g") + (ty-fn @14.5-14.11 (effectful false) + (ty-rigid-var @14.5-14.6 (name "e")) + (ty-rigid-var-lookup (ty-rigid-var @14.5-14.6 (name "e")))) (where - (alias @16.18-16.29 (module-of "e") (ident "A")) - (alias @16.31-16.42 (module-of "e") (ident "B")))) - (ext-decl @16.18-16.29 (ident "module(e).A") (kind "type")) - (ext-decl @16.31-16.42 (ident "module(e).B") (kind "type"))) + (alias @14.18-14.29 (module-of "e") (ident "A")) + (alias @14.31-14.42 (module-of "e") (ident "B")))) + (ext-decl @14.18-14.29 (ident "module(e).A") (kind "type")) + (ext-decl @14.31-14.42 (ident "module(e).B") (kind "type"))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @18.1-18.2 (type "[Z1((field, field2)), Z2(c, d), Z3(f), Z4(List(elem))]others, [Z1((field3, field4)), Z2(i, j), Z3(k), Z4(List(elem2))]others2 -> _ret"))) + (patt @16.1-16.2 (type "[Z1((c, d)), Z2(c, f), Z3({ a: c, b: i }), Z4(List(c))]j, [Z1((c, d)), Z2(c, f), Z3({ a: c, b: i }), Z4(List(c))]j -> c"))) (type_decls - (alias @8.1-8.77 (type "A(a)") - (ty-header @8.1-8.5 (name "A") + (alias @6.1-6.77 (type "A(a)") + (ty-header @6.1-6.5 (name "A") (ty-args - (ty-var @8.3-8.4 (name "a"))))) - (alias @9.1-9.77 (type "B(b)") - (ty-header @9.1-9.5 (name "B") + (ty-rigid-var @6.3-6.4 (name "a"))))) + (alias @7.1-7.77 (type "B(b)") + (ty-header @7.1-7.5 (name "B") (ty-args - (ty-var @9.3-9.4 (name "b"))))) - (alias @11.1-11.19 (type "C(a, b)") - (ty-header @11.1-11.9 (name "C") + (ty-rigid-var @7.3-7.4 (name "b"))))) + (alias @9.1-9.19 (type "C(a, b)") + (ty-header @9.1-9.9 (name "C") (ty-args - (ty-var @11.3-11.4 (name "a")) - (ty-var @11.6-11.7 (name "b"))))) - (alias @12.1-12.20 (type "D(a, b)") - (ty-header @12.1-12.9 (name "D") + (ty-rigid-var @9.3-9.4 (name "a")) + (ty-rigid-var @9.6-9.7 (name "b"))))) + (alias @10.1-10.20 (type "D(a, b)") + (ty-header @10.1-10.9 (name "D") (ty-args - (ty-var @12.3-12.4 (name "a")) - (ty-var @12.6-12.7 (name "b"))))) - (alias @13.1-13.26 (type "E") - (ty-header @13.1-13.2 (name "E"))) - (alias @14.1-14.12 (type "F") - (ty-header @14.1-14.2 (name "F")))) + (ty-rigid-var @10.3-10.4 (name "a")) + (ty-rigid-var @10.6-10.7 (name "b"))))) + (alias @11.1-11.26 (type "E") + (ty-header @11.1-11.2 (name "E"))) + (alias @12.1-12.12 (type "F") + (ty-header @12.1-12.2 (name "F")))) (expressions - (expr @18.5-31.2 (type "[Z1((field, field2)), Z2(c, d), Z3(f), Z4(List(elem))]others, [Z1((field3, field4)), Z2(i, j), Z3(k), Z4(List(elem2))]others2 -> _ret")))) + (expr @16.5-29.2 (type "[Z1((c, d)), Z2(c, f), Z3({ a: c, b: i }), Z4(List(c))]j, [Z1((c, d)), Z2(c, f), Z3({ a: c, b: i }), Z4(List(c))]j -> c")))) ~~~ diff --git a/test/snapshots/formatting/singleline_with_comma/module.md b/test/snapshots/formatting/singleline_with_comma/module.md index 5da4c3ac6c..c443464ab5 100644 --- a/test/snapshots/formatting/singleline_with_comma/module.md +++ b/test/snapshots/formatting/singleline_with_comma/module.md @@ -1,12 +1,10 @@ # META ~~~ini description=Singleline with comma formatting module -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [a, b,] - a = 'a' b = 'a' ~~~ @@ -16,55 +14,43 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:10),Comma(1:10-1:11),LowerIdent(1:12-1:13),Comma(1:13-1:14),CloseSquare(1:14-1:15), -LowerIdent(3:1-3:2),OpAssign(3:3-3:4),SingleQuote(3:5-3:8), -LowerIdent(4:1-4:2),OpAssign(4:3-4:4),SingleQuote(4:5-4:8), -EndOfFile(5:1-5:1), +LowerIdent(1:1-1:2),OpAssign(1:3-1:4),SingleQuote(1:5-1:8), +LowerIdent(2:1-2:2),OpAssign(2:3-2:4),SingleQuote(2:5-2:8), +EndOfFile(3:1-3:1), ~~~ # PARSE ~~~clojure -(file @1.1-4.8 - (module @1.1-1.15 - (exposes @1.8-1.15 - (exposed-lower-ident @1.9-1.10 - (text "a")) - (exposed-lower-ident @1.12-1.13 - (text "b")))) +(file @1.1-2.8 + (type-module @1.1-1.2) (statements - (s-decl @3.1-3.8 - (p-ident @3.1-3.2 (raw "a")) - (e-single-quote @3.5-3.8 (raw "'a'"))) - (s-decl @4.1-4.8 - (p-ident @4.1-4.2 (raw "b")) - (e-single-quote @4.5-4.8 (raw "'a'"))))) + (s-decl @1.1-1.8 + (p-ident @1.1-1.2 (raw "a")) + (e-single-quote @1.5-1.8 (raw "'a'"))) + (s-decl @2.1-2.8 + (p-ident @2.1-2.2 (raw "b")) + (e-single-quote @2.5-2.8 (raw "'a'"))))) ~~~ # FORMATTED ~~~roc -module [ - a, - b, -] - -a = 'a' -b = 'a' +NO CHANGE ~~~ # CANONICALIZE ~~~clojure (can-ir (d-let - (p-assign @3.1-3.2 (ident "a")) - (e-int @3.5-3.8 (value "97"))) + (p-assign @1.1-1.2 (ident "a")) + (e-num @1.5-1.8 (value "97"))) (d-let - (p-assign @4.1-4.2 (ident "b")) - (e-int @4.5-4.8 (value "97")))) + (p-assign @2.1-2.2 (ident "b")) + (e-num @2.5-2.8 (value "97")))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @3.1-3.2 (type "Num(_size)")) - (patt @4.1-4.2 (type "Num(_size)"))) + (patt @1.1-1.2 (type "Num(Int(_size))")) + (patt @2.1-2.2 (type "Num(Int(_size))"))) (expressions - (expr @3.5-3.8 (type "Num(_size)")) - (expr @4.5-4.8 (type "Num(_size)")))) + (expr @1.5-1.8 (type "Num(Int(_size))")) + (expr @2.5-2.8 (type "Num(Int(_size))")))) ~~~ diff --git a/test/snapshots/function_no_annotation.md b/test/snapshots/function_no_annotation.md index 1a45102bcc..01cb11980d 100644 --- a/test/snapshots/function_no_annotation.md +++ b/test/snapshots/function_no_annotation.md @@ -119,7 +119,7 @@ NO CHANGE (p-assign @9.18-9.19 (ident "n"))) (e-call @9.21-9.36 (e-lookup-external @9.21-9.33 - (module-idx "0") + (module-idx "2") (target-node-idx "0")) (e-lookup-local @9.34-9.35 (p-assign @9.18-9.19 (ident "n")))))) @@ -140,13 +140,13 @@ NO CHANGE (p-assign @6.1-6.9 (ident "multiply"))) (e-lookup-local @12.39-12.40 (p-assign @12.13-12.14 (ident "x"))) - (e-int @12.42-12.43 (value "2"))))))) + (e-num @12.42-12.43 (value "2"))))))) (d-let (p-assign @14.1-14.6 (ident "main!")) (e-call @14.9-14.21 (e-lookup-local @14.9-14.17 (p-assign @12.1-12.9 (ident "process!"))) - (e-int @14.18-14.20 (value "42")))) + (e-num @14.18-14.20 (value "42")))) (s-import @3.1-3.17 (module "pf.Stdout") (qualifier "pf") (exposes))) ~~~ diff --git a/test/snapshots/fuzz_crash/fuzz_crash_001.md b/test/snapshots/fuzz_crash/fuzz_crash_001.md index b1d92d1951..8be1381000 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_001.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_001.md @@ -8,17 +8,14 @@ type=file mo|% ~~~ # EXPECTED -MISSING HEADER - fuzz_crash_001.md:1:1:1:3 +PARSE ERROR - fuzz_crash_001.md:1:1:1:3 PARSE ERROR - fuzz_crash_001.md:1:3:1:4 PARSE ERROR - fuzz_crash_001.md:1:4:1:5 +MISSING MAIN! FUNCTION - fuzz_crash_001.md:1:1:1:5 # PROBLEMS -**MISSING HEADER** -Roc files must start with a module header. - -For example: - module [main] -or for an app: - app [main!] { pf: platform "../basic-cli/platform.roc" } +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. **fuzz_crash_001.md:1:1:1:3:** ```roc @@ -49,6 +46,20 @@ mo|% ^ +**MISSING MAIN! FUNCTION** +Default app modules must have a `main!` function. + +No `main!` function was found. + +Add a main! function like: +`main! = |arg| { ... }` +**fuzz_crash_001.md:1:1:1:5:** +```roc +mo|% +``` +^^^^ + + # TOKENS ~~~zig LowerIdent(1:1-1:3),OpBar(1:3-1:4),OpPercent(1:4-1:5), @@ -57,8 +68,9 @@ EndOfFile(2:1-2:1), # PARSE ~~~clojure (file @1.1-1.5 - (malformed-header @1.1-1.3 (tag "missing_header")) + (type-module @1.1-1.3) (statements + (s-malformed @1.1-1.3 (tag "statement_unexpected_token")) (s-malformed @1.3-1.4 (tag "statement_unexpected_token")) (s-malformed @1.4-1.5 (tag "statement_unexpected_token")))) ~~~ diff --git a/test/snapshots/fuzz_crash/fuzz_crash_002.md b/test/snapshots/fuzz_crash/fuzz_crash_002.md index 1b8e5a9d1e..ed9e8586d7 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_002.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_002.md @@ -8,9 +8,7 @@ type=file modu:;::::::::::::::le[% ~~~ # EXPECTED -MISSING HEADER - fuzz_crash_002.md:1:1:1:5 -PARSE ERROR - fuzz_crash_002.md:1:5:1:6 -PARSE ERROR - fuzz_crash_002.md:1:6:1:7 +UNEXPECTED TOKEN IN TYPE ANNOTATION - fuzz_crash_002.md:1:6:1:7 PARSE ERROR - fuzz_crash_002.md:1:7:1:8 PARSE ERROR - fuzz_crash_002.md:1:8:1:9 PARSE ERROR - fuzz_crash_002.md:1:9:1:10 @@ -28,36 +26,12 @@ PARSE ERROR - fuzz_crash_002.md:1:20:1:21 PARSE ERROR - fuzz_crash_002.md:1:21:1:23 PARSE ERROR - fuzz_crash_002.md:1:23:1:24 PARSE ERROR - fuzz_crash_002.md:1:24:1:25 +MALFORMED TYPE - fuzz_crash_002.md:1:6:1:7 +MISSING MAIN! FUNCTION - fuzz_crash_002.md:1:1:1:25 # PROBLEMS -**MISSING HEADER** -Roc files must start with a module header. - -For example: - module [main] -or for an app: - app [main!] { pf: platform "../basic-cli/platform.roc" } - -**fuzz_crash_002.md:1:1:1:5:** -```roc -modu:;::::::::::::::le[% -``` -^^^^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_002.md:1:5:1:6:** -```roc -modu:;::::::::::::::le[% -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. +**UNEXPECTED TOKEN IN TYPE ANNOTATION** +The token **;** is not expected in a type annotation. +Type annotations should contain types like _Str_, _Num a_, or _List U64_. **fuzz_crash_002.md:1:6:1:7:** ```roc @@ -253,6 +227,30 @@ modu:;::::::::::::::le[% ^ +**MALFORMED TYPE** +This type annotation is malformed or contains invalid syntax. + +**fuzz_crash_002.md:1:6:1:7:** +```roc +modu:;::::::::::::::le[% +``` + ^ + + +**MISSING MAIN! FUNCTION** +Default app modules must have a `main!` function. + +No `main!` function was found. + +Add a main! function like: +`main! = |arg| { ... }` +**fuzz_crash_002.md:1:1:1:25:** +```roc +modu:;::::::::::::::le[% +``` +^^^^^^^^^^^^^^^^^^^^^^^^ + + # TOKENS ~~~zig LowerIdent(1:1-1:5),OpColon(1:5-1:6),MalformedUnknownToken(1:6-1:7),OpColon(1:7-1:8),OpColon(1:8-1:9),OpColon(1:9-1:10),OpColon(1:10-1:11),OpColon(1:11-1:12),OpColon(1:12-1:13),OpColon(1:13-1:14),OpColon(1:14-1:15),OpColon(1:15-1:16),OpColon(1:16-1:17),OpColon(1:17-1:18),OpColon(1:18-1:19),OpColon(1:19-1:20),OpColon(1:20-1:21),LowerIdent(1:21-1:23),OpenSquare(1:23-1:24),OpPercent(1:24-1:25), @@ -261,10 +259,10 @@ EndOfFile(2:1-2:1), # PARSE ~~~clojure (file @1.1-1.25 - (malformed-header @1.1-1.5 (tag "missing_header")) + (type-module @1.1-1.5) (statements - (s-malformed @1.5-1.6 (tag "statement_unexpected_token")) - (s-malformed @1.6-1.7 (tag "statement_unexpected_token")) + (s-type-anno @1.1-1.7 (name "modu") + (ty-malformed @1.6-1.7 (tag "ty_anno_unexpected_token"))) (s-malformed @1.7-1.8 (tag "statement_unexpected_token")) (s-malformed @1.8-1.9 (tag "statement_unexpected_token")) (s-malformed @1.9-1.10 (tag "statement_unexpected_token")) @@ -285,6 +283,7 @@ EndOfFile(2:1-2:1), ~~~ # FORMATTED ~~~roc +modu : ~~~ # CANONICALIZE ~~~clojure diff --git a/test/snapshots/fuzz_crash/fuzz_crash_003.md b/test/snapshots/fuzz_crash/fuzz_crash_003.md index 4bc2b8645a..268f53fcba 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_003.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_003.md @@ -9,10 +9,11 @@ type=file ~~~ # EXPECTED UNCLOSED STRING - :0:0:0:0 -MISSING HEADER - fuzz_crash_003.md:1:1:1:2 +PARSE ERROR - fuzz_crash_003.md:1:1:1:2 PARSE ERROR - fuzz_crash_003.md:1:3:1:4 PARSE ERROR - fuzz_crash_003.md:1:4:1:6 PARSE ERROR - fuzz_crash_003.md:1:6:1:6 +MISSING MAIN! FUNCTION - fuzz_crash_003.md:1:1:1:6 # PROBLEMS **UNCLOSED STRING** This string is missing a closing quote. @@ -23,13 +24,9 @@ This string is missing a closing quote. ^^^ -**MISSING HEADER** -Roc files must start with a module header. - -For example: - module [main] -or for an app: - app [main!] { pf: platform "../basic-cli/platform.roc" } +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. **fuzz_crash_003.md:1:1:1:2:** ```roc @@ -71,6 +68,20 @@ This is an unexpected parsing error. Please check your syntax. ^ +**MISSING MAIN! FUNCTION** +Default app modules must have a `main!` function. + +No `main!` function was found. + +Add a main! function like: +`main! = |arg| { ... }` +**fuzz_crash_003.md:1:1:1:6:** +```roc += "te +``` +^^^^^ + + # TOKENS ~~~zig OpAssign(1:1-1:2),StringStart(1:3-1:4),StringPart(1:4-1:6),StringEnd(1:6-1:6), @@ -79,8 +90,9 @@ EndOfFile(2:1-2:1), # PARSE ~~~clojure (file @1.1-1.6 - (malformed-header @1.1-1.2 (tag "missing_header")) + (type-module @1.1-1.2) (statements + (s-malformed @1.1-1.2 (tag "statement_unexpected_token")) (s-malformed @1.3-1.4 (tag "statement_unexpected_token")) (s-malformed @1.4-1.6 (tag "statement_unexpected_token")) (s-malformed @1.6-1.6 (tag "statement_unexpected_token")))) diff --git a/test/snapshots/fuzz_crash/fuzz_crash_004.md b/test/snapshots/fuzz_crash/fuzz_crash_004.md index f5b5dd7169..d2bffd8e90 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_004.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_004.md @@ -8,16 +8,39 @@ type=file F ~~~ # EXPECTED -MISSING HEADER - fuzz_crash_004.md:1:1:1:2 +PARSE ERROR - fuzz_crash_004.md:2:1:2:1 +MISSING MAIN! FUNCTION - fuzz_crash_004.md:1:1:1:2 # PROBLEMS -**MISSING HEADER** -Roc files must start with a module header. +**PARSE ERROR** +Type applications require parentheses around their type arguments. -For example: - module [main] -or for an app: - app [main!] { pf: platform "../basic-cli/platform.roc" } +I found a type followed by what looks like a type argument, but they need to be connected with parentheses. +Instead of: + **List U8** + +Use: + **List(U8)** + +Other valid examples: + `Dict(Str, Num)` + `Result(a, Str)` + `Maybe(List(U64))` + +**fuzz_crash_004.md:2:1:2:1:** +```roc + +``` +^ + + +**MISSING MAIN! FUNCTION** +Default app modules must have a `main!` function. + +No `main!` function was found. + +Add a main! function like: +`main! = |arg| { ... }` **fuzz_crash_004.md:1:1:1:2:** ```roc F @@ -33,11 +56,13 @@ EndOfFile(2:1-2:1), # PARSE ~~~clojure (file @1.1-1.2 - (malformed-header @1.1-1.2 (tag "missing_header")) - (statements)) + (type-module @1.1-1.2) + (statements + (s-malformed @1.1-1.1 (tag "expected_colon_after_type_annotation")))) ~~~ # FORMATTED ~~~roc + ~~~ # CANONICALIZE ~~~clojure diff --git a/test/snapshots/fuzz_crash/fuzz_crash_005.md b/test/snapshots/fuzz_crash/fuzz_crash_005.md index 2e27555299..039cfd567e 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_005.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_005.md @@ -8,16 +8,27 @@ type=file modu ~~~ # EXPECTED -MISSING HEADER - fuzz_crash_005.md:1:1:1:5 +PARSE ERROR - fuzz_crash_005.md:1:1:1:5 +MISSING MAIN! FUNCTION - fuzz_crash_005.md:1:1:1:5 # PROBLEMS -**MISSING HEADER** -Roc files must start with a module header. +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. -For example: - module [main] -or for an app: - app [main!] { pf: platform "../basic-cli/platform.roc" } +**fuzz_crash_005.md:1:1:1:5:** +```roc +modu +``` +^^^^ + +**MISSING MAIN! FUNCTION** +Default app modules must have a `main!` function. + +No `main!` function was found. + +Add a main! function like: +`main! = |arg| { ... }` **fuzz_crash_005.md:1:1:1:5:** ```roc modu @@ -33,8 +44,9 @@ EndOfFile(2:1-2:1), # PARSE ~~~clojure (file @1.1-1.5 - (malformed-header @1.1-1.5 (tag "missing_header")) - (statements)) + (type-module @1.1-1.5) + (statements + (s-malformed @1.1-1.5 (tag "statement_unexpected_token")))) ~~~ # FORMATTED ~~~roc diff --git a/test/snapshots/fuzz_crash/fuzz_crash_006.md b/test/snapshots/fuzz_crash/fuzz_crash_006.md index 168ec62e67..6d9c22a8f1 100644 Binary files a/test/snapshots/fuzz_crash/fuzz_crash_006.md and b/test/snapshots/fuzz_crash/fuzz_crash_006.md differ diff --git a/test/snapshots/fuzz_crash/fuzz_crash_007.md b/test/snapshots/fuzz_crash/fuzz_crash_007.md index 5393d4b382..51c75e21dc 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_007.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_007.md @@ -8,17 +8,14 @@ type=file ff8.8.d ~~~ # EXPECTED -MISSING HEADER - fuzz_crash_007.md:1:1:1:4 +PARSE ERROR - fuzz_crash_007.md:1:1:1:4 PARSE ERROR - fuzz_crash_007.md:1:4:1:6 PARSE ERROR - fuzz_crash_007.md:1:6:1:8 +MISSING MAIN! FUNCTION - fuzz_crash_007.md:1:1:1:8 # PROBLEMS -**MISSING HEADER** -Roc files must start with a module header. - -For example: - module [main] -or for an app: - app [main!] { pf: platform "../basic-cli/platform.roc" } +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. **fuzz_crash_007.md:1:1:1:4:** ```roc @@ -49,6 +46,20 @@ ff8.8.d ^^ +**MISSING MAIN! FUNCTION** +Default app modules must have a `main!` function. + +No `main!` function was found. + +Add a main! function like: +`main! = |arg| { ... }` +**fuzz_crash_007.md:1:1:1:8:** +```roc +ff8.8.d +``` +^^^^^^^ + + # TOKENS ~~~zig LowerIdent(1:1-1:4),NoSpaceDotInt(1:4-1:6),NoSpaceDotLowerIdent(1:6-1:8), @@ -57,8 +68,9 @@ EndOfFile(2:1-2:1), # PARSE ~~~clojure (file @1.1-1.8 - (malformed-header @1.1-1.4 (tag "missing_header")) + (type-module @1.1-1.4) (statements + (s-malformed @1.1-1.4 (tag "statement_unexpected_token")) (s-malformed @1.4-1.6 (tag "statement_unexpected_token")) (s-malformed @1.6-1.8 (tag "statement_unexpected_token")))) ~~~ diff --git a/test/snapshots/fuzz_crash/fuzz_crash_008.md b/test/snapshots/fuzz_crash/fuzz_crash_008.md index cac7c936df..30658320cc 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_008.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_008.md @@ -9,22 +9,19 @@ type=file ~~~ # EXPECTED ASCII CONTROL CHARACTER - :0:0:0:0 -MISSING HEADER - fuzz_crash_008.md:1:1:1:2 +PARSE ERROR - fuzz_crash_008.md:1:1:1:2 PARSE ERROR - fuzz_crash_008.md:1:3:1:4 PARSE ERROR - fuzz_crash_008.md:1:4:1:5 +MISSING MAIN! FUNCTION - fuzz_crash_008.md:1:1:1:5 # PROBLEMS **ASCII CONTROL CHARACTER** ASCII control characters are not allowed in Roc source code. -**MISSING HEADER** -Roc files must start with a module header. - -For example: - module [main] -or for an app: - app [main!] { pf: platform "../basic-cli/platform.roc" } +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. **fuzz_crash_008.md:1:1:1:2:** ```roc @@ -55,6 +52,20 @@ This is an unexpected parsing error. Please check your syntax. ^ +**MISSING MAIN! FUNCTION** +Default app modules must have a `main!` function. + +No `main!` function was found. + +Add a main! function like: +`main! = |arg| { ... }` +**fuzz_crash_008.md:1:1:1:5:** +```roc +||1 +``` +^^^^ + + # TOKENS ~~~zig OpBar(1:1-1:2),OpBar(1:3-1:4),Int(1:4-1:5), @@ -63,8 +74,9 @@ EndOfFile(2:1-2:1), # PARSE ~~~clojure (file @1.1-1.5 - (malformed-header @1.1-1.2 (tag "missing_header")) + (type-module @1.1-1.2) (statements + (s-malformed @1.1-1.2 (tag "statement_unexpected_token")) (s-malformed @1.3-1.4 (tag "statement_unexpected_token")) (s-malformed @1.4-1.5 (tag "statement_unexpected_token")))) ~~~ diff --git a/test/snapshots/fuzz_crash/fuzz_crash_009.md b/test/snapshots/fuzz_crash/fuzz_crash_009.md index c658ddb5df..da9df93bf6 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_009.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_009.md @@ -14,11 +14,12 @@ foo = ~~~ # EXPECTED UNCLOSED STRING - :0:0:0:0 -MISSING HEADER - fuzz_crash_009.md:1:2:1:3 +PARSE ERROR - fuzz_crash_009.md:1:2:1:3 PARSE ERROR - fuzz_crash_009.md:1:3:1:4 PARSE ERROR - fuzz_crash_009.md:1:4:1:5 PARSE ERROR - fuzz_crash_009.md:1:5:1:6 PARSE ERROR - fuzz_crash_009.md:2:6:2:7 +MISSING MAIN! FUNCTION - fuzz_crash_009.md:1:2:6:12 # PROBLEMS **UNCLOSED STRING** This string is missing a closing quote. @@ -29,13 +30,9 @@ This string is missing a closing quote. ^^^^^^^ -**MISSING HEADER** -Roc files must start with a module header. - -For example: - module [main] -or for an app: - app [main!] { pf: platform "../basic-cli/platform.roc" } +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. **fuzz_crash_009.md:1:2:1:3:** ```roc @@ -88,6 +85,24 @@ This is an unexpected parsing error. Please check your syntax. ^ +**MISSING MAIN! FUNCTION** +Default app modules must have a `main!` function. + +No `main!` function was found. + +Add a main! function like: +`main! = |arg| { ... }` +**fuzz_crash_009.md:1:2:6:12:** +```roc + f{o, + ] + +foo = + + "onmo % +``` + + # TOKENS ~~~zig LowerIdent(1:2-1:3),OpenCurly(1:3-1:4),LowerIdent(1:4-1:5),Comma(1:5-1:6), @@ -99,8 +114,9 @@ EndOfFile(7:1-7:1), # PARSE ~~~clojure (file @1.2-6.12 - (malformed-header @1.2-1.3 (tag "missing_header")) + (type-module @1.2-1.3) (statements + (s-malformed @1.2-1.3 (tag "statement_unexpected_token")) (s-malformed @1.3-1.4 (tag "statement_unexpected_token")) (s-malformed @1.4-1.5 (tag "statement_unexpected_token")) (s-malformed @1.5-1.6 (tag "statement_unexpected_token")) diff --git a/test/snapshots/fuzz_crash/fuzz_crash_010.md b/test/snapshots/fuzz_crash/fuzz_crash_010.md index 42a40d45c9..f5a63d9259 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_010.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_010.md @@ -14,11 +14,11 @@ foo = # EXPECTED ASCII CONTROL CHARACTER - :0:0:0:0 UNCLOSED STRING - :0:0:0:0 -MISSING HEADER - fuzz_crash_010.md:1:1:1:2 PARSE ERROR - fuzz_crash_010.md:1:2:1:3 PARSE ERROR - fuzz_crash_010.md:1:3:1:4 PARSE ERROR - fuzz_crash_010.md:1:4:1:5 PARSE ERROR - fuzz_crash_010.md:2:6:2:7 +MISSING MAIN! FUNCTION - fuzz_crash_010.md:1:1:5:35 # PROBLEMS **ASCII CONTROL CHARACTER** ASCII control characters are not allowed in Roc source code. @@ -34,24 +34,21 @@ This string is missing a closing quote. ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -**MISSING HEADER** -Roc files must start with a module header. - -For example: - module [main] -or for an app: - app [main!] { pf: platform "../basic-cli/platform.roc" } - -**fuzz_crash_010.md:1:1:1:2:** -```roc -H{o, -``` -^ - - **PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. +Type applications require parentheses around their type arguments. + +I found a type followed by what looks like a type argument, but they need to be connected with parentheses. + +Instead of: + **List U8** + +Use: + **List(U8)** + +Other valid examples: + `Dict(Str, Num)` + `Result(a, Str)` + `Maybe(List(U64))` **fuzz_crash_010.md:1:2:1:3:** ```roc @@ -93,6 +90,23 @@ This is an unexpected parsing error. Please check your syntax. ^ +**MISSING MAIN! FUNCTION** +Default app modules must have a `main!` function. + +No `main!` function was found. + +Add a main! function like: +`main! = |arg| { ... }` +**fuzz_crash_010.md:1:1:5:35:** +```roc +H{o, +  ] +foo = + + "on (string 'onmo %'))) +``` + + # TOKENS ~~~zig UpperIdent(1:1-1:2),OpenCurly(1:2-1:3),LowerIdent(1:3-1:4),Comma(1:4-1:5), @@ -104,9 +118,9 @@ EndOfFile(6:1-6:1), # PARSE ~~~clojure (file @1.1-5.35 - (malformed-header @1.1-1.2 (tag "missing_header")) + (type-module @1.1-1.2) (statements - (s-malformed @1.2-1.3 (tag "statement_unexpected_token")) + (s-malformed @1.2-1.3 (tag "expected_colon_after_type_annotation")) (s-malformed @1.3-1.4 (tag "statement_unexpected_token")) (s-malformed @1.4-1.5 (tag "statement_unexpected_token")) (s-malformed @2.6-2.7 (tag "statement_unexpected_token")) diff --git a/test/snapshots/fuzz_crash/fuzz_crash_012.md b/test/snapshots/fuzz_crash/fuzz_crash_012.md index d74e2605a6..84e0d0e2e3 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_012.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_012.md @@ -8,21 +8,18 @@ type=file ||(|(l888888888| ~~~ # EXPECTED -MISSING HEADER - fuzz_crash_012.md:1:1:1:2 +PARSE ERROR - fuzz_crash_012.md:1:1:1:2 PARSE ERROR - fuzz_crash_012.md:1:2:1:3 PARSE ERROR - fuzz_crash_012.md:1:3:1:4 PARSE ERROR - fuzz_crash_012.md:1:4:1:5 PARSE ERROR - fuzz_crash_012.md:1:5:1:6 PARSE ERROR - fuzz_crash_012.md:1:6:1:16 PARSE ERROR - fuzz_crash_012.md:1:16:1:17 +MISSING MAIN! FUNCTION - fuzz_crash_012.md:1:1:1:17 # PROBLEMS -**MISSING HEADER** -Roc files must start with a module header. - -For example: - module [main] -or for an app: - app [main!] { pf: platform "../basic-cli/platform.roc" } +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. **fuzz_crash_012.md:1:1:1:2:** ```roc @@ -97,6 +94,20 @@ This is an unexpected parsing error. Please check your syntax. ^ +**MISSING MAIN! FUNCTION** +Default app modules must have a `main!` function. + +No `main!` function was found. + +Add a main! function like: +`main! = |arg| { ... }` +**fuzz_crash_012.md:1:1:1:17:** +```roc +||(|(l888888888| +``` +^^^^^^^^^^^^^^^^ + + # TOKENS ~~~zig OpBar(1:1-1:2),OpBar(1:2-1:3),NoSpaceOpenRound(1:3-1:4),OpBar(1:4-1:5),NoSpaceOpenRound(1:5-1:6),LowerIdent(1:6-1:16),OpBar(1:16-1:17), @@ -105,8 +116,9 @@ EndOfFile(2:1-2:1), # PARSE ~~~clojure (file @1.1-1.17 - (malformed-header @1.1-1.2 (tag "missing_header")) + (type-module @1.1-1.2) (statements + (s-malformed @1.1-1.2 (tag "statement_unexpected_token")) (s-malformed @1.2-1.3 (tag "statement_unexpected_token")) (s-malformed @1.3-1.4 (tag "statement_unexpected_token")) (s-malformed @1.4-1.5 (tag "statement_unexpected_token")) diff --git a/test/snapshots/fuzz_crash/fuzz_crash_013.md b/test/snapshots/fuzz_crash/fuzz_crash_013.md index 2d6ce9a6f3..a4f930cdef 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_013.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_013.md @@ -8,16 +8,13 @@ type=file 0{ ~~~ # EXPECTED -MISSING HEADER - fuzz_crash_013.md:1:1:1:2 +PARSE ERROR - fuzz_crash_013.md:1:1:1:2 PARSE ERROR - fuzz_crash_013.md:1:2:1:3 +MISSING MAIN! FUNCTION - fuzz_crash_013.md:1:1:1:3 # PROBLEMS -**MISSING HEADER** -Roc files must start with a module header. - -For example: - module [main] -or for an app: - app [main!] { pf: platform "../basic-cli/platform.roc" } +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. **fuzz_crash_013.md:1:1:1:2:** ```roc @@ -37,6 +34,20 @@ This is an unexpected parsing error. Please check your syntax. ^ +**MISSING MAIN! FUNCTION** +Default app modules must have a `main!` function. + +No `main!` function was found. + +Add a main! function like: +`main! = |arg| { ... }` +**fuzz_crash_013.md:1:1:1:3:** +```roc +0{ +``` +^^ + + # TOKENS ~~~zig Int(1:1-1:2),OpenCurly(1:2-1:3), @@ -45,8 +56,9 @@ EndOfFile(2:1-2:1), # PARSE ~~~clojure (file @1.1-1.3 - (malformed-header @1.1-1.2 (tag "missing_header")) + (type-module @1.1-1.2) (statements + (s-malformed @1.1-1.2 (tag "statement_unexpected_token")) (s-malformed @1.2-1.3 (tag "statement_unexpected_token")))) ~~~ # FORMATTED diff --git a/test/snapshots/fuzz_crash/fuzz_crash_014.md b/test/snapshots/fuzz_crash/fuzz_crash_014.md index 35f7441cb6..8c8078a067 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_014.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_014.md @@ -10,18 +10,15 @@ type=file 0u22 ~~~ # EXPECTED -MISSING HEADER - fuzz_crash_014.md:1:1:1:3 +PARSE ERROR - fuzz_crash_014.md:1:1:1:3 PARSE ERROR - fuzz_crash_014.md:1:3:1:5 PARSE ERROR - fuzz_crash_014.md:2:1:2:6 PARSE ERROR - fuzz_crash_014.md:3:1:3:5 +MISSING MAIN! FUNCTION - fuzz_crash_014.md:1:1:3:5 # PROBLEMS -**MISSING HEADER** -Roc files must start with a module header. - -For example: - module [main] -or for an app: - app [main!] { pf: platform "../basic-cli/platform.roc" } +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. **fuzz_crash_014.md:1:1:1:3:** ```roc @@ -63,6 +60,21 @@ This is an unexpected parsing error. Please check your syntax. ^^^^ +**MISSING MAIN! FUNCTION** +Default app modules must have a `main!` function. + +No `main!` function was found. + +Add a main! function like: +`main! = |arg| { ... }` +**fuzz_crash_014.md:1:1:3:5:** +```roc +0b.0 +0bu22 +0u22 +``` + + # TOKENS ~~~zig MalformedNumberNoDigits(1:1-1:3),NoSpaceDotInt(1:3-1:5), @@ -73,8 +85,9 @@ EndOfFile(4:1-4:1), # PARSE ~~~clojure (file @1.1-3.5 - (malformed-header @1.1-1.3 (tag "missing_header")) + (type-module @1.1-1.3) (statements + (s-malformed @1.1-1.3 (tag "statement_unexpected_token")) (s-malformed @1.3-1.5 (tag "statement_unexpected_token")) (s-malformed @2.1-2.6 (tag "statement_unexpected_token")) (s-malformed @3.1-3.5 (tag "statement_unexpected_token")))) diff --git a/test/snapshots/fuzz_crash/fuzz_crash_015.md b/test/snapshots/fuzz_crash/fuzz_crash_015.md index a6d861eebe..a662b9f81f 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_015.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_015.md @@ -12,25 +12,22 @@ type=file ~~~ # EXPECTED LEADING ZERO - :0:0:0:0 -MISSING HEADER - fuzz_crash_015.md:1:1:1:4 +PARSE ERROR - fuzz_crash_015.md:1:1:1:4 PARSE ERROR - fuzz_crash_015.md:1:4:1:6 PARSE ERROR - fuzz_crash_015.md:2:1:2:4 PARSE ERROR - fuzz_crash_015.md:3:1:3:4 PARSE ERROR - fuzz_crash_015.md:3:4:3:6 PARSE ERROR - fuzz_crash_015.md:4:1:4:3 +MISSING MAIN! FUNCTION - fuzz_crash_015.md:1:1:4:3 # PROBLEMS **LEADING ZERO** Numbers cannot have leading zeros. -**MISSING HEADER** -Roc files must start with a module header. - -For example: - module [main] -or for an app: - app [main!] { pf: platform "../basic-cli/platform.roc" } +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. **fuzz_crash_015.md:1:1:1:4:** ```roc @@ -94,6 +91,22 @@ This is an unexpected parsing error. Please check your syntax. ^^ +**MISSING MAIN! FUNCTION** +Default app modules must have a `main!` function. + +No `main!` function was found. + +Add a main! function like: +`main! = |arg| { ... }` +**fuzz_crash_015.md:1:1:4:3:** +```roc +0o0.0 +0_0 +0u8.0 +0_ +``` + + # TOKENS ~~~zig Int(1:1-1:4),NoSpaceDotInt(1:4-1:6), @@ -105,8 +118,9 @@ EndOfFile(5:1-5:1), # PARSE ~~~clojure (file @1.1-4.3 - (malformed-header @1.1-1.4 (tag "missing_header")) + (type-module @1.1-1.4) (statements + (s-malformed @1.1-1.4 (tag "statement_unexpected_token")) (s-malformed @1.4-1.6 (tag "statement_unexpected_token")) (s-malformed @2.1-2.4 (tag "statement_unexpected_token")) (s-malformed @3.1-3.4 (tag "statement_unexpected_token")) diff --git a/test/snapshots/fuzz_crash/fuzz_crash_016.md b/test/snapshots/fuzz_crash/fuzz_crash_016.md index fcf26ac6c0..2a24c1e5d2 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_016.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_016.md @@ -8,16 +8,13 @@ type=file 0| ~~~ # EXPECTED -MISSING HEADER - fuzz_crash_016.md:1:1:1:2 +PARSE ERROR - fuzz_crash_016.md:1:1:1:2 PARSE ERROR - fuzz_crash_016.md:1:2:1:3 +MISSING MAIN! FUNCTION - fuzz_crash_016.md:1:1:1:3 # PROBLEMS -**MISSING HEADER** -Roc files must start with a module header. - -For example: - module [main] -or for an app: - app [main!] { pf: platform "../basic-cli/platform.roc" } +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. **fuzz_crash_016.md:1:1:1:2:** ```roc @@ -37,6 +34,20 @@ This is an unexpected parsing error. Please check your syntax. ^ +**MISSING MAIN! FUNCTION** +Default app modules must have a `main!` function. + +No `main!` function was found. + +Add a main! function like: +`main! = |arg| { ... }` +**fuzz_crash_016.md:1:1:1:3:** +```roc +0| +``` +^^ + + # TOKENS ~~~zig Int(1:1-1:2),OpBar(1:2-1:3), @@ -45,8 +56,9 @@ EndOfFile(2:1-2:1), # PARSE ~~~clojure (file @1.1-1.3 - (malformed-header @1.1-1.2 (tag "missing_header")) + (type-module @1.1-1.2) (statements + (s-malformed @1.1-1.2 (tag "statement_unexpected_token")) (s-malformed @1.2-1.3 (tag "statement_unexpected_token")))) ~~~ # FORMATTED diff --git a/test/snapshots/fuzz_crash/fuzz_crash_017.md b/test/snapshots/fuzz_crash/fuzz_crash_017.md index 3a6f13ca4f..1269bc3c4c 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_017.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_017.md @@ -9,73 +9,10 @@ me = "luc" foo = "hello ${namF ~~~ # EXPECTED -MISSING HEADER - fuzz_crash_017.md:1:1:1:3 -PARSE ERROR - fuzz_crash_017.md:1:4:1:5 -PARSE ERROR - fuzz_crash_017.md:1:6:1:7 -PARSE ERROR - fuzz_crash_017.md:1:7:1:10 -PARSE ERROR - fuzz_crash_017.md:1:10:1:11 PARSE ERROR - fuzz_crash_017.md:2:7:2:8 UNRECOGNIZED SYNTAX - fuzz_crash_017.md:2:7:2:20 +MISSING MAIN! FUNCTION - fuzz_crash_017.md:1:1:2:20 # PROBLEMS -**MISSING HEADER** -Roc files must start with a module header. - -For example: - module [main] -or for an app: - app [main!] { pf: platform "../basic-cli/platform.roc" } - -**fuzz_crash_017.md:1:1:1:3:** -```roc -me = "luc" -``` -^^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_017.md:1:4:1:5:** -```roc -me = "luc" -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_017.md:1:6:1:7:** -```roc -me = "luc" -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_017.md:1:7:1:10:** -```roc -me = "luc" -``` - ^^^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_017.md:1:10:1:11:** -```roc -me = "luc" -``` - ^ - - **PARSE ERROR** A parsing error occurred: `string_expected_close_interpolation` This is an unexpected parsing error. Please check your syntax. @@ -98,6 +35,20 @@ foo = "hello ${namF This might be a syntax error, an unsupported language feature, or a typo. +**MISSING MAIN! FUNCTION** +Default app modules must have a `main!` function. + +No `main!` function was found. + +Add a main! function like: +`main! = |arg| { ... }` +**fuzz_crash_017.md:1:1:2:20:** +```roc +me = "luc" +foo = "hello ${namF +``` + + # TOKENS ~~~zig LowerIdent(1:1-1:3),OpAssign(1:4-1:5),StringStart(1:6-1:7),StringPart(1:7-1:10),StringEnd(1:10-1:11), @@ -107,24 +58,28 @@ EndOfFile(3:1-3:1), # PARSE ~~~clojure (file @1.1-2.20 - (malformed-header @1.1-1.3 (tag "missing_header")) + (type-module @1.1-1.3) (statements - (s-malformed @1.4-1.5 (tag "statement_unexpected_token")) - (s-malformed @1.6-1.7 (tag "statement_unexpected_token")) - (s-malformed @1.7-1.10 (tag "statement_unexpected_token")) - (s-malformed @1.10-1.11 (tag "statement_unexpected_token")) + (s-decl @1.1-1.11 + (p-ident @1.1-1.3 (raw "me")) + (e-string @1.6-1.11 + (e-string-part @1.7-1.10 (raw "luc")))) (s-decl @2.1-2.20 (p-ident @2.1-2.4 (raw "foo")) (e-malformed @2.7-2.20 (reason "string_expected_close_interpolation"))))) ~~~ # FORMATTED ~~~roc - +me = "luc" foo = ~~~ # CANONICALIZE ~~~clojure (can-ir + (d-let + (p-assign @1.1-1.3 (ident "me")) + (e-string @1.6-1.11 + (e-literal @1.7-1.10 (string "luc")))) (d-let (p-assign @2.1-2.4 (ident "foo")) (e-runtime-error (tag "expr_not_canonicalized")))) @@ -133,7 +88,9 @@ foo = ~~~clojure (inferred-types (defs + (patt @1.1-1.3 (type "Str")) (patt @2.1-2.4 (type "Error"))) (expressions + (expr @1.6-1.11 (type "Str")) (expr @2.7-2.20 (type "Error")))) ~~~ diff --git a/test/snapshots/fuzz_crash/fuzz_crash_018.md b/test/snapshots/fuzz_crash/fuzz_crash_018.md index 085ec65af3..a4d7d2f0bd 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_018.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_018.md @@ -9,17 +9,14 @@ type=file .R ~~~ # EXPECTED -MISSING HEADER - fuzz_crash_018.md:1:1:1:2 +PARSE ERROR - fuzz_crash_018.md:1:1:1:2 PARSE ERROR - fuzz_crash_018.md:2:1:2:3 UNDECLARED TYPE - fuzz_crash_018.md:1:5:1:6 +MISSING MAIN! FUNCTION - fuzz_crash_018.md:1:1:2:3 # PROBLEMS -**MISSING HEADER** -Roc files must start with a module header. - -For example: - module [main] -or for an app: - app [main!] { pf: platform "../basic-cli/platform.roc" } +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. **fuzz_crash_018.md:1:1:1:2:** ```roc @@ -50,6 +47,20 @@ This type is referenced here: ^ +**MISSING MAIN! FUNCTION** +Default app modules must have a `main!` function. + +No `main!` function was found. + +Add a main! function like: +`main! = |arg| { ... }` +**fuzz_crash_018.md:1:1:2:3:** +```roc +0 b:S +.R +``` + + # TOKENS ~~~zig Int(1:1-1:2),LowerIdent(1:3-1:4),OpColon(1:4-1:5),UpperIdent(1:5-1:6), @@ -59,8 +70,9 @@ EndOfFile(3:1-3:1), # PARSE ~~~clojure (file @1.1-2.3 - (malformed-header @1.1-1.2 (tag "missing_header")) + (type-module @1.1-1.2) (statements + (s-malformed @1.1-1.2 (tag "statement_unexpected_token")) (s-type-anno @1.3-1.6 (name "b") (ty @1.5-1.6 (name "S"))) (s-malformed @2.1-2.3 (tag "statement_unexpected_token")))) diff --git a/test/snapshots/fuzz_crash/fuzz_crash_019.md b/test/snapshots/fuzz_crash/fuzz_crash_019.md index 39371187cf..62568bdc23 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_019.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_019.md @@ -186,6 +186,7 @@ UNDEFINED VARIABLE - fuzz_crash_019.md:119:2:119:5 UNDEFINED VARIABLE - fuzz_crash_019.md:120:1:120:2 UNDEFINED VARIABLE - fuzz_crash_019.md:120:6:120:9 EXPOSED BUT NOT DEFINED - fuzz_crash_019.md:2:6:2:11 +TOO FEW ARGS - fuzz_crash_019.md:17:3:18:4 INCOMPATIBLE MATCH PATTERNS - fuzz_crash_019.md:52:2:52:2 TYPE MISMATCH - fuzz_crash_019.md:84:2:86:3 # PROBLEMS @@ -835,6 +836,16 @@ app [main!] { pf: platform "c" } ^^^^^ You can fix this by either defining `main!` in this module, or by removing it from the list of exposed values. +**TOO FEW ARGS** +The type _List_ expects argument, but got instead. +**fuzz_crash_019.md:17:3:18:4:** +```roc + List( #rg + ), +``` + + + **INCOMPATIBLE MATCH PATTERNS** The pattern in the fourth branch of this `match` differs from previous ones: **fuzz_crash_019.md:52:2:** @@ -882,7 +893,7 @@ This expression is used in an unexpected way: It has the type: __arg -> _ret_ -But here it's being used as: +But I expected it to be: _[Blue]_others, [Tb]_others2 -> Error_ # TOKENS @@ -1492,9 +1503,9 @@ expect { (if-branch (e-lookup-local @35.16-35.19 (p-assign @35.8-35.11 (ident "num"))) - (e-int @35.20-35.21 (value "2")))) + (e-num @35.20-35.21 (value "2")))) (if-else - (e-int @35.27-35.28 (value "5")))))) + (e-num @35.27-35.28 (value "5")))))) (d-let (p-assign @38.1-38.4 (ident "add")) (e-lambda @38.7-47.2 @@ -1502,7 +1513,7 @@ expect { (p-assign @38.8-38.11 (ident "num"))) (e-block @38.13-47.2 (s-expr @39.2-39.3 - (e-int @39.2-39.3 (value "1"))) + (e-num @39.2-39.3 (value "1"))) (e-if @40.2-46.3 (if-branches (if-branch @@ -1515,7 +1526,7 @@ expect { (if-else (e-block @43.9-46.3 (s-dbg @44.3-44.10 - (e-int @44.7-44.10 (value "123"))) + (e-num @44.7-44.10 (value "123"))) (e-runtime-error (tag "ident_not_in_scope")))))))) (d-let (p-assign @49.1-49.3 (ident "me")) @@ -1548,19 +1559,19 @@ expect { (pattern (degenerate false) (p-assign @57.2-57.4 (ident "er")))) (value - (e-int @58.4-58.5 (value "1")))) + (e-num @58.4-58.5 (value "1")))) (branch (patterns (pattern (degenerate false) (p-str @58.6-58.11 (text """)))) (value - (e-int @58.15-58.17 (value "20")))) + (e-num @58.15-58.17 (value "20")))) (branch (patterns (pattern (degenerate false) (p-list @58.17-58.22 (patterns - (p-int @58.18-58.19 (value "1")))))) + (p-num @58.18-58.19 (value "1")))))) (value (e-runtime-error (tag "ident_not_in_scope")))) (branch @@ -1568,25 +1579,25 @@ expect { (pattern (degenerate false) (p-list @60.3-60.16 (patterns - (p-int @60.4-60.5 (value "1")) - (p-int @60.7-60.8 (value "2")) - (p-int @60.10-60.11 (value "3")) + (p-num @60.4-60.5 (value "1")) + (p-num @60.7-60.8 (value "2")) + (p-num @60.10-60.11 (value "3")) (p-assign @60.12-60.15 (ident "est")))))) (value - (e-int @60.16-60.19 (value "123")))) + (e-num @60.16-60.19 (value "123")))) (branch (patterns (pattern (degenerate false) (p-list @61.3-62.4 (patterns)))) (value - (e-int @62.5-62.7 (value "23")))) + (e-num @62.5-62.7 (value "23")))) (branch (patterns (pattern (degenerate false) (p-small-dec @63.3-63.6))) (value - (e-int @63.7-63.10 (value "314")))) + (e-num @63.7-63.10 (value "314")))) (branch (patterns (pattern (degenerate false) @@ -1594,39 +1605,39 @@ expect { (pattern (degenerate false) (p-small-dec @64.10-64.14))) (value - (e-int @64.18-64.21 (value "314")))) + (e-num @64.18-64.21 (value "314")))) (branch (patterns (pattern (degenerate false) (p-tuple @65.3-65.8 (patterns - (p-int @65.4-65.5 (value "1")))))) + (p-num @65.4-65.5 (value "1")))))) (value - (e-int @65.12-65.15 (value "123")))) + (e-num @65.12-65.15 (value "123")))) (branch (patterns (pattern (degenerate false) (p-tuple @66.3-66.12 (patterns - (p-int @66.4-66.5 (value "1")) - (p-int @66.7-66.8 (value "2")) - (p-int @66.10-66.11 (value "3")))))) + (p-num @66.4-66.5 (value "1")) + (p-num @66.7-66.8 (value "2")) + (p-num @66.10-66.11 (value "3")))))) (value - (e-int @66.12-66.15 (value "123")))) + (e-num @66.12-66.15 (value "123")))) (branch (patterns (pattern (degenerate false) (p-record-destructure @67.3-67.7 (destructs)))) (value - (e-int @67.11-67.13 (value "12")))) + (e-num @67.11-67.13 (value "12")))) (branch (patterns (pattern (degenerate false) (p-nominal @68.3-68.10 (p-applied-tag @68.3-68.10)))) (value - (e-int @68.14-68.16 (value "12"))))))))) + (e-num @68.14-68.16 (value "12"))))))))) (d-let (p-assign @75.1-75.3 (ident "ma")) (e-closure @75.5-111.2 @@ -1644,7 +1655,7 @@ expect { (e-literal @76.7-76.8 (string "d")))) (s-var @77.2-77.14 (p-assign @77.2-77.14 (ident "er")) - (e-int @77.11-77.14 (value "123"))) + (e-num @77.11-77.14 (value "123"))) (s-expect @78.2-78.14 (e-runtime-error (tag "ident_not_in_scope"))) (s-return @79.2-80.6 @@ -1674,15 +1685,15 @@ expect { (e-runtime-error (tag "ident_not_in_scope")) (e-lookup-local @89.7-89.9 (p-assign @77.2-77.14 (ident "er")))) - (e-int @89.16-89.19 (value "456")) - (e-int @90.1-90.2 (value "9"))))) + (e-num @89.16-89.19 (value "456")) + (e-num @90.1-90.2 (value "9"))))) (s-runtime-error (tag "not_implemented")) (s-let @96.2-96.59 (p-assign @96.2-96.4 (ident "rd")) (e-record @96.7-96.59 (fields (field (name "foo") - (e-int @96.14-96.17 (value "123"))) + (e-num @96.14-96.17 (value "123"))) (field (name "bar") (e-string @96.24-96.27 (e-literal @96.25-96.26 (string "H")))) @@ -1699,7 +1710,7 @@ expect { (p-assign @97.2-97.3 (ident "t")) (e-tuple @97.6-97.48 (elems - (e-int @97.7-97.10 (value "123")) + (e-num @97.7-97.10 (value "123")) (e-string @97.12-97.19 (e-literal @97.13-97.18 (string "World"))) (e-runtime-error (tag "ident_not_in_scope")) @@ -1711,15 +1722,15 @@ expect { (p-assign @97.2-97.3 (ident "t"))))) (e-list @97.38-97.47 (elems - (e-int @97.39-97.40 (value "1")) - (e-int @97.42-97.43 (value "2")) - (e-int @97.45-97.46 (value "3"))))))) + (e-num @97.39-97.40 (value "1")) + (e-num @97.42-97.43 (value "2")) + (e-num @97.45-97.46 (value "3"))))))) (s-expr @98.2-98.3 (e-runtime-error (tag "ident_not_in_scope"))) (s-expr @98.4-104.3 (e-tuple @98.4-104.3 (elems - (e-int @99.3-99.6 (value "123")) + (e-num @99.3-99.6 (value "123")) (e-string @100.3-100.10 (e-literal @100.4-100.9 (string "World"))) (e-runtime-error (tag "ident_not_in_scope")) @@ -1730,31 +1741,31 @@ expect { (e-runtime-error (tag "ident_not_in_scope")))) (e-list @103.3-103.12 (elems - (e-int @103.4-103.5 (value "1")) - (e-int @103.7-103.8 (value "2")) - (e-int @103.10-103.11 (value "3"))))))) + (e-num @103.4-103.5 (value "1")) + (e-num @103.7-103.8 (value "2")) + (e-num @103.10-103.11 (value "3"))))))) (s-expr @105.2-105.54 (e-binop @105.2-105.54 (op "or") (e-binop @105.2-105.12 (op "gt") (e-binop @105.2-105.8 (op "null_coalesce") (e-runtime-error (tag "ident_not_in_scope")) - (e-int @105.6-105.8 (value "12"))) - (e-int @105.11-105.12 (value "5"))) + (e-num @105.6-105.8 (value "12"))) + (e-num @105.11-105.12 (value "5"))) (e-binop @105.16-105.54 (op "or") (e-binop @105.16-105.43 (op "and") (e-binop @105.16-105.26 (op "lt") (e-binop @105.16-105.22 (op "add") - (e-int @105.16-105.18 (value "13")) - (e-int @105.21-105.22 (value "2"))) - (e-int @105.25-105.26 (value "5"))) + (e-num @105.16-105.18 (value "13")) + (e-num @105.21-105.22 (value "2"))) + (e-num @105.25-105.26 (value "5"))) (e-binop @105.31-105.43 (op "ge") (e-binop @105.31-105.37 (op "sub") - (e-int @105.31-105.33 (value "10")) - (e-int @105.36-105.37 (value "1"))) - (e-int @105.41-105.43 (value "16")))) + (e-num @105.31-105.33 (value "10")) + (e-num @105.36-105.37 (value "1"))) + (e-num @105.41-105.43 (value "16")))) (e-binop @105.47-105.54 (op "le") - (e-int @105.47-105.49 (value "12")) - (e-int @105.53-105.54 (value "3")))))) + (e-num @105.47-105.49 (value "12")) + (e-num @105.53-105.54 (value "3")))))) (s-expr @105.55-105.85 (e-dot-access @105.55-105.85 (field "unknown") (receiver @@ -1777,47 +1788,47 @@ expect { (s-alias-decl @13.1-13.33 (ty-header @13.1-13.10 (name "Map") (ty-args - (ty-var @13.5-13.6 (name "a")) - (ty-var @13.8-13.9 (name "b")))) + (ty-rigid-var @13.5-13.6 (name "a")) + (ty-rigid-var @13.8-13.9 (name "b")))) (ty-fn @13.13-13.33 (effectful false) - (ty @13.13-13.16 (name "Lis")) + (ty-malformed @13.13-13.16) (ty-malformed @13.19-13.21) - (ty-apply @13.26-13.33 (symbol "List") - (ty-var @13.31-13.32 (name "b"))))) + (ty-apply @13.26-13.33 (name "List") (builtin) + (ty-rigid-var-lookup (ty-rigid-var @13.8-13.9 (name "b")))))) (s-alias-decl @14.1-20.15 (ty-header @14.1-15.2 (name "MapML")) (ty-fn @17.3-20.15 (effectful false) - (ty-apply @17.3-18.4 (symbol "List")) + (ty-apply @17.3-18.4 (name "List") (builtin)) (ty-malformed @19.4-19.6) - (ty-apply @20.4-20.15 (symbol "List") + (ty-apply @20.4-20.15 (name "List") (builtin) (ty-malformed @20.12-20.13)))) (s-alias-decl @24.1-24.27 (ty-header @24.1-24.4 (name "Som")) (ty-record @24.7-24.27 (field (field "foo") - (ty @24.15-24.16 (name "O"))) + (ty-malformed @24.15-24.16)) (field (field "bar") (ty-malformed @24.24-24.25)))) (s-alias-decl @25.1-26.2 (ty-header @25.1-25.6 (name "Ml") (ty-args - (ty-var @25.4-25.5 (name "a")))) + (ty-rigid-var @25.4-25.5 (name "a")))) (ty-record @25.9-26.2)) (s-alias-decl @28.1-29.2 (ty-header @28.1-28.9 (name "Soine") (ty-args - (ty-var @28.7-28.8 (name "a")))) + (ty-rigid-var @28.7-28.8 (name "a")))) (ty-record @28.12-29.2)) (s-alias-decl @30.1-30.19 (ty-header @30.1-30.9 (name "Maybe") (ty-args - (ty-var @30.7-30.8 (name "a")))) + (ty-rigid-var @30.7-30.8 (name "a")))) (ty-tag-union @30.12-30.19 - (ty @30.13-30.18 (name "Somne")))) + (ty-tag-name @30.13-30.18 (name "Somne")))) (s-alias-decl @32.1-33.2 (ty-header @32.1-32.10 (name "Mayine") (ty-args - (ty-var @32.8-32.9 (name "a")))) + (ty-rigid-var @32.8-32.9 (name "a")))) (ty-tag-union @32.13-33.2)) (s-import @4.1-4.34 (module "pf.Stdout") (qualifier "pf") (exposes @@ -1836,7 +1847,7 @@ expect { (s-expr @119.2-119.10 (e-binop @119.2-119.10 (op "eq") (e-runtime-error (tag "ident_not_in_scope")) - (e-int @119.9-119.10 (value "1")))) + (e-num @119.9-119.10 (value "1")))) (e-binop @120.1-120.9 (op "eq") (e-runtime-error (tag "ident_not_in_scope")) (e-runtime-error (tag "ident_not_in_scope")))))) @@ -1854,8 +1865,8 @@ expect { (alias @13.1-13.33 (type "Map(a, b)") (ty-header @13.1-13.10 (name "Map") (ty-args - (ty-var @13.5-13.6 (name "a")) - (ty-var @13.8-13.9 (name "b"))))) + (ty-rigid-var @13.5-13.6 (name "a")) + (ty-rigid-var @13.8-13.9 (name "b"))))) (alias @14.1-20.15 (type "MapML") (ty-header @14.1-15.2 (name "MapML"))) (alias @24.1-24.27 (type "Som") @@ -1863,19 +1874,19 @@ expect { (alias @25.1-26.2 (type "Ml(a)") (ty-header @25.1-25.6 (name "Ml") (ty-args - (ty-var @25.4-25.5 (name "a"))))) + (ty-rigid-var @25.4-25.5 (name "a"))))) (alias @28.1-29.2 (type "Soine(a)") (ty-header @28.1-28.9 (name "Soine") (ty-args - (ty-var @28.7-28.8 (name "a"))))) + (ty-rigid-var @28.7-28.8 (name "a"))))) (alias @30.1-30.19 (type "Maybe(a)") (ty-header @30.1-30.9 (name "Maybe") (ty-args - (ty-var @30.7-30.8 (name "a"))))) + (ty-rigid-var @30.7-30.8 (name "a"))))) (alias @32.1-33.2 (type "Mayine(a)") (ty-header @32.1-32.10 (name "Mayine") (ty-args - (ty-var @32.8-32.9 (name "a")))))) + (ty-rigid-var @32.8-32.9 (name "a")))))) (expressions (expr @35.7-35.28 (type "Bool -> Num(_size)")) (expr @38.7-47.2 (type "Bool -> Error")) diff --git a/test/snapshots/fuzz_crash/fuzz_crash_020.md b/test/snapshots/fuzz_crash/fuzz_crash_020.md index 75e66fdc2b..fbcb91150a 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_020.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_020.md @@ -187,6 +187,7 @@ UNDEFINED VARIABLE - fuzz_crash_020.md:119:2:119:5 UNDEFINED VARIABLE - fuzz_crash_020.md:120:1:120:2 UNDEFINED VARIABLE - fuzz_crash_020.md:120:6:120:9 EXPOSED BUT NOT DEFINED - fuzz_crash_020.md:2:6:2:11 +TOO FEW ARGS - fuzz_crash_020.md:17:3:18:4 INCOMPATIBLE MATCH PATTERNS - fuzz_crash_020.md:52:2:52:2 # PROBLEMS **PARSE ERROR** @@ -846,6 +847,16 @@ app [main!] { pf: platform "c" } ^^^^^ You can fix this by either defining `main!` in this module, or by removing it from the list of exposed values. +**TOO FEW ARGS** +The type _List_ expects argument, but got instead. +**fuzz_crash_020.md:17:3:18:4:** +```roc + List( #rg + ), +``` + + + **INCOMPATIBLE MATCH PATTERNS** The pattern in the fourth branch of this `match` differs from previous ones: **fuzz_crash_020.md:52:2:** @@ -1486,9 +1497,9 @@ expect { (if-branch (e-lookup-local @35.16-35.19 (p-assign @35.8-35.11 (ident "num"))) - (e-int @35.20-35.21 (value "2")))) + (e-num @35.20-35.21 (value "2")))) (if-else - (e-int @35.27-35.28 (value "5")))))) + (e-num @35.27-35.28 (value "5")))))) (d-let (p-assign @38.1-38.4 (ident "add")) (e-lambda @38.7-47.2 @@ -1496,7 +1507,7 @@ expect { (p-applied-tag @38.8-38.11)) (e-block @38.13-47.2 (s-expr @39.2-39.3 - (e-int @39.2-39.3 (value "1"))) + (e-num @39.2-39.3 (value "1"))) (e-if @40.2-46.3 (if-branches (if-branch @@ -1508,7 +1519,7 @@ expect { (if-else (e-block @43.9-46.3 (s-dbg @44.3-44.10 - (e-int @44.7-44.10 (value "123"))) + (e-num @44.7-44.10 (value "123"))) (e-runtime-error (tag "ident_not_in_scope")))))))) (d-let (p-assign @49.1-49.3 (ident "me")) @@ -1540,19 +1551,19 @@ expect { (pattern (degenerate false) (p-assign @57.2-57.4 (ident "er")))) (value - (e-int @58.4-58.5 (value "1")))) + (e-num @58.4-58.5 (value "1")))) (branch (patterns (pattern (degenerate false) (p-str @58.6-58.11 (text """)))) (value - (e-int @58.15-58.17 (value "20")))) + (e-num @58.15-58.17 (value "20")))) (branch (patterns (pattern (degenerate false) (p-list @58.17-58.22 (patterns - (p-int @58.18-58.19 (value "1")))))) + (p-num @58.18-58.19 (value "1")))))) (value (e-runtime-error (tag "ident_not_in_scope")))) (branch @@ -1560,25 +1571,25 @@ expect { (pattern (degenerate false) (p-list @60.3-60.16 (patterns - (p-int @60.4-60.5 (value "1")) - (p-int @60.7-60.8 (value "2")) - (p-int @60.10-60.11 (value "3")) + (p-num @60.4-60.5 (value "1")) + (p-num @60.7-60.8 (value "2")) + (p-num @60.10-60.11 (value "3")) (p-assign @60.12-60.15 (ident "est")))))) (value - (e-int @60.16-60.19 (value "123")))) + (e-num @60.16-60.19 (value "123")))) (branch (patterns (pattern (degenerate false) (p-list @61.3-62.4 (patterns)))) (value - (e-int @62.5-62.7 (value "23")))) + (e-num @62.5-62.7 (value "23")))) (branch (patterns (pattern (degenerate false) (p-small-dec @63.3-63.6))) (value - (e-int @63.7-63.10 (value "314")))) + (e-num @63.7-63.10 (value "314")))) (branch (patterns (pattern (degenerate false) @@ -1586,39 +1597,39 @@ expect { (pattern (degenerate false) (p-small-dec @64.10-64.14))) (value - (e-int @64.18-64.21 (value "314")))) + (e-num @64.18-64.21 (value "314")))) (branch (patterns (pattern (degenerate false) (p-tuple @65.3-65.8 (patterns - (p-int @65.4-65.5 (value "1")))))) + (p-num @65.4-65.5 (value "1")))))) (value - (e-int @65.12-65.15 (value "123")))) + (e-num @65.12-65.15 (value "123")))) (branch (patterns (pattern (degenerate false) (p-tuple @66.3-66.12 (patterns - (p-int @66.4-66.5 (value "1")) - (p-int @66.7-66.8 (value "2")) - (p-int @66.10-66.11 (value "3")))))) + (p-num @66.4-66.5 (value "1")) + (p-num @66.7-66.8 (value "2")) + (p-num @66.10-66.11 (value "3")))))) (value - (e-int @66.12-66.15 (value "123")))) + (e-num @66.12-66.15 (value "123")))) (branch (patterns (pattern (degenerate false) (p-record-destructure @67.3-67.7 (destructs)))) (value - (e-int @67.11-67.13 (value "12")))) + (e-num @67.11-67.13 (value "12")))) (branch (patterns (pattern (degenerate false) (p-nominal @68.3-68.10 (p-applied-tag @68.3-68.10)))) (value - (e-int @68.14-68.16 (value "12"))))))))) + (e-num @68.14-68.16 (value "12"))))))))) (d-let (p-assign @75.1-75.3 (ident "ma")) (e-closure @75.5-111.2 @@ -1636,7 +1647,7 @@ expect { (e-literal @76.7-76.8 (string "d")))) (s-var @77.2-77.14 (p-assign @77.2-77.14 (ident "er")) - (e-int @77.11-77.14 (value "123"))) + (e-num @77.11-77.14 (value "123"))) (s-expect @78.2-78.14 (e-runtime-error (tag "ident_not_in_scope"))) (s-return @79.2-80.6 @@ -1666,15 +1677,15 @@ expect { (e-runtime-error (tag "ident_not_in_scope")) (e-lookup-local @89.7-89.9 (p-assign @77.2-77.14 (ident "er")))) - (e-int @89.16-89.19 (value "456")) - (e-int @90.1-90.2 (value "9"))))) + (e-num @89.16-89.19 (value "456")) + (e-num @90.1-90.2 (value "9"))))) (s-runtime-error (tag "not_implemented")) (s-let @96.2-96.59 (p-assign @96.2-96.4 (ident "rd")) (e-record @96.7-96.59 (fields (field (name "foo") - (e-int @96.14-96.17 (value "123"))) + (e-num @96.14-96.17 (value "123"))) (field (name "bar") (e-string @96.24-96.27 (e-literal @96.25-96.26 (string "H")))) @@ -1691,7 +1702,7 @@ expect { (p-assign @97.2-97.3 (ident "t")) (e-tuple @97.6-97.48 (elems - (e-int @97.7-97.10 (value "123")) + (e-num @97.7-97.10 (value "123")) (e-string @97.12-97.19 (e-literal @97.13-97.18 (string "World"))) (e-runtime-error (tag "ident_not_in_scope")) @@ -1703,15 +1714,15 @@ expect { (p-assign @97.2-97.3 (ident "t"))))) (e-list @97.38-97.47 (elems - (e-int @97.39-97.40 (value "1")) - (e-int @97.42-97.43 (value "2")) - (e-int @97.45-97.46 (value "3"))))))) + (e-num @97.39-97.40 (value "1")) + (e-num @97.42-97.43 (value "2")) + (e-num @97.45-97.46 (value "3"))))))) (s-expr @98.2-98.3 (e-runtime-error (tag "ident_not_in_scope"))) (s-expr @98.4-104.3 (e-tuple @98.4-104.3 (elems - (e-int @99.3-99.6 (value "123")) + (e-num @99.3-99.6 (value "123")) (e-string @100.3-100.10 (e-literal @100.4-100.9 (string "World"))) (e-runtime-error (tag "ident_not_in_scope")) @@ -1722,31 +1733,31 @@ expect { (e-runtime-error (tag "ident_not_in_scope")))) (e-list @103.3-103.12 (elems - (e-int @103.4-103.5 (value "1")) - (e-int @103.7-103.8 (value "2")) - (e-int @103.10-103.11 (value "3"))))))) + (e-num @103.4-103.5 (value "1")) + (e-num @103.7-103.8 (value "2")) + (e-num @103.10-103.11 (value "3"))))))) (s-expr @105.2-105.54 (e-binop @105.2-105.54 (op "or") (e-binop @105.2-105.12 (op "gt") (e-binop @105.2-105.8 (op "null_coalesce") (e-runtime-error (tag "ident_not_in_scope")) - (e-int @105.6-105.8 (value "12"))) - (e-int @105.11-105.12 (value "5"))) + (e-num @105.6-105.8 (value "12"))) + (e-num @105.11-105.12 (value "5"))) (e-binop @105.16-105.54 (op "or") (e-binop @105.16-105.43 (op "and") (e-binop @105.16-105.26 (op "lt") (e-binop @105.16-105.22 (op "add") - (e-int @105.16-105.18 (value "13")) - (e-int @105.21-105.22 (value "2"))) - (e-int @105.25-105.26 (value "5"))) + (e-num @105.16-105.18 (value "13")) + (e-num @105.21-105.22 (value "2"))) + (e-num @105.25-105.26 (value "5"))) (e-binop @105.31-105.43 (op "ge") (e-binop @105.31-105.37 (op "sub") - (e-int @105.31-105.33 (value "10")) - (e-int @105.36-105.37 (value "1"))) - (e-int @105.41-105.43 (value "16")))) + (e-num @105.31-105.33 (value "10")) + (e-num @105.36-105.37 (value "1"))) + (e-num @105.41-105.43 (value "16")))) (e-binop @105.47-105.54 (op "le") - (e-int @105.47-105.49 (value "12")) - (e-int @105.53-105.54 (value "3")))))) + (e-num @105.47-105.49 (value "12")) + (e-num @105.53-105.54 (value "3")))))) (s-expr @105.55-105.85 (e-dot-access @105.55-105.85 (field "unknown") (receiver @@ -1769,47 +1780,47 @@ expect { (s-alias-decl @13.1-13.33 (ty-header @13.1-13.10 (name "Map") (ty-args - (ty-var @13.5-13.6 (name "a")) - (ty-var @13.8-13.9 (name "b")))) + (ty-rigid-var @13.5-13.6 (name "a")) + (ty-rigid-var @13.8-13.9 (name "b")))) (ty-fn @13.13-13.33 (effectful false) - (ty @13.13-13.16 (name "Lis")) + (ty-malformed @13.13-13.16) (ty-malformed @13.19-13.21) - (ty-apply @13.26-13.33 (symbol "List") - (ty-var @13.31-13.32 (name "b"))))) + (ty-apply @13.26-13.33 (name "List") (builtin) + (ty-rigid-var-lookup (ty-rigid-var @13.8-13.9 (name "b")))))) (s-alias-decl @14.1-20.15 (ty-header @14.1-15.2 (name "MapML")) (ty-fn @17.3-20.15 (effectful false) - (ty-apply @17.3-18.4 (symbol "List")) + (ty-apply @17.3-18.4 (name "List") (builtin)) (ty-malformed @19.4-19.6) - (ty-apply @20.4-20.15 (symbol "List") + (ty-apply @20.4-20.15 (name "List") (builtin) (ty-malformed @20.12-20.13)))) (s-alias-decl @24.1-24.27 (ty-header @24.1-24.4 (name "Som")) (ty-record @24.7-24.27 (field (field "foo") - (ty @24.15-24.16 (name "O"))) + (ty-malformed @24.15-24.16)) (field (field "bar") (ty-malformed @24.24-24.25)))) (s-alias-decl @25.1-26.2 (ty-header @25.1-25.6 (name "Ml") (ty-args - (ty-var @25.4-25.5 (name "a")))) + (ty-rigid-var @25.4-25.5 (name "a")))) (ty-record @25.9-26.2)) (s-alias-decl @28.1-29.2 (ty-header @28.1-28.9 (name "Soine") (ty-args - (ty-var @28.7-28.8 (name "a")))) + (ty-rigid-var @28.7-28.8 (name "a")))) (ty-record @28.12-29.2)) (s-alias-decl @30.1-30.19 (ty-header @30.1-30.9 (name "Maybe") (ty-args - (ty-var @30.7-30.8 (name "a")))) + (ty-rigid-var @30.7-30.8 (name "a")))) (ty-tag-union @30.12-30.19 - (ty @30.13-30.18 (name "Somne")))) + (ty-tag-name @30.13-30.18 (name "Somne")))) (s-alias-decl @32.1-33.2 (ty-header @32.1-32.10 (name "Mayine") (ty-args - (ty-var @32.8-32.9 (name "a")))) + (ty-rigid-var @32.8-32.9 (name "a")))) (ty-tag-union @32.13-33.2)) (s-import @4.1-4.34 (module "pf.Stdout") (qualifier "pf") (exposes @@ -1828,7 +1839,7 @@ expect { (s-expr @119.2-119.10 (e-binop @119.2-119.10 (op "eq") (e-runtime-error (tag "ident_not_in_scope")) - (e-int @119.9-119.10 (value "1")))) + (e-num @119.9-119.10 (value "1")))) (e-binop @120.1-120.9 (op "eq") (e-runtime-error (tag "ident_not_in_scope")) (e-runtime-error (tag "ident_not_in_scope")))))) @@ -1846,8 +1857,8 @@ expect { (alias @13.1-13.33 (type "Map(a, b)") (ty-header @13.1-13.10 (name "Map") (ty-args - (ty-var @13.5-13.6 (name "a")) - (ty-var @13.8-13.9 (name "b"))))) + (ty-rigid-var @13.5-13.6 (name "a")) + (ty-rigid-var @13.8-13.9 (name "b"))))) (alias @14.1-20.15 (type "MapML") (ty-header @14.1-15.2 (name "MapML"))) (alias @24.1-24.27 (type "Som") @@ -1855,19 +1866,19 @@ expect { (alias @25.1-26.2 (type "Ml(a)") (ty-header @25.1-25.6 (name "Ml") (ty-args - (ty-var @25.4-25.5 (name "a"))))) + (ty-rigid-var @25.4-25.5 (name "a"))))) (alias @28.1-29.2 (type "Soine(a)") (ty-header @28.1-28.9 (name "Soine") (ty-args - (ty-var @28.7-28.8 (name "a"))))) + (ty-rigid-var @28.7-28.8 (name "a"))))) (alias @30.1-30.19 (type "Maybe(a)") (ty-header @30.1-30.9 (name "Maybe") (ty-args - (ty-var @30.7-30.8 (name "a"))))) + (ty-rigid-var @30.7-30.8 (name "a"))))) (alias @32.1-33.2 (type "Mayine(a)") (ty-header @32.1-32.10 (name "Mayine") (ty-args - (ty-var @32.8-32.9 (name "a")))))) + (ty-rigid-var @32.8-32.9 (name "a")))))) (expressions (expr @35.7-35.28 (type "Bool -> Num(_size)")) (expr @38.7-47.2 (type "[Rum]_others -> Error")) diff --git a/test/snapshots/fuzz_crash/fuzz_crash_021.md b/test/snapshots/fuzz_crash/fuzz_crash_021.md index 2e3bb28968..04d25ba39e 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_021.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_021.md @@ -11,7 +11,6 @@ Pair(a, b+ : ( ~~~ # EXPECTED UNCLOSED STRING - :0:0:0:0 -MISSING HEADER - fuzz_crash_021.md:1:1:1:4 PARSE ERROR - fuzz_crash_021.md:1:4:1:5 PARSE ERROR - fuzz_crash_021.md:1:5:1:9 PARSE ERROR - fuzz_crash_021.md:1:9:1:13 @@ -21,6 +20,7 @@ PARSE ERROR - fuzz_crash_021.md:1:16:1:16 PARSE ERROR - fuzz_crash_021.md:3:1:3:5 PARSE ERROR - fuzz_crash_021.md:4:1:4:1 MALFORMED TYPE - fuzz_crash_021.md:3:14:3:15 +TYPE MODULE MISSING MATCHING TYPE - fuzz_crash_021.md:1:1:3:15 # PROBLEMS **UNCLOSED STRING** This string is missing a closing quote. @@ -31,24 +31,21 @@ Fli/main.roc" } ^^^ -**MISSING HEADER** -Roc files must start with a module header. - -For example: - module [main] -or for an app: - app [main!] { pf: platform "../basic-cli/platform.roc" } - -**fuzz_crash_021.md:1:1:1:4:** -```roc -Fli/main.roc" } -``` -^^^ - - **PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. +Type applications require parentheses around their type arguments. + +I found a type followed by what looks like a type argument, but they need to be connected with parentheses. + +Instead of: + **List U8** + +Use: + **List(U8)** + +Other valid examples: + `Dict(Str, Num)` + `Result(a, Str)` + `Maybe(List(U64))` **fuzz_crash_021.md:1:4:1:5:** ```roc @@ -144,6 +141,23 @@ Pair(a, b+ : ( ^ +**TYPE MODULE MISSING MATCHING TYPE** +Type modules must have a type declaration matching the module name. + +This file is named `fuzz_crash_021`.roc, but no top-level type declaration named `fuzz_crash_021` was found. + +Add either: +`fuzz_crash_021 := ...` (nominal type) +or: +`fuzz_crash_021 : ...` (type alias) +**fuzz_crash_021.md:1:1:3:15:** +```roc +Fli/main.roc" } + +Pair(a, b+ : ( +``` + + # TOKENS ~~~zig UpperIdent(1:1-1:4),OpSlash(1:4-1:5),LowerIdent(1:5-1:9),NoSpaceDotLowerIdent(1:9-1:13),StringStart(1:13-1:14),StringPart(1:14-1:16),StringEnd(1:16-1:16), @@ -153,9 +167,9 @@ EndOfFile(4:1-4:1), # PARSE ~~~clojure (file @1.1-3.15 - (malformed-header @1.1-1.4 (tag "missing_header")) + (type-module @1.1-1.4) (statements - (s-malformed @1.4-1.5 (tag "statement_unexpected_token")) + (s-malformed @1.4-1.5 (tag "expected_colon_after_type_annotation")) (s-malformed @1.5-1.9 (tag "statement_unexpected_token")) (s-malformed @1.9-1.13 (tag "statement_unexpected_token")) (s-malformed @1.13-1.14 (tag "statement_unexpected_token")) @@ -184,7 +198,7 @@ EndOfFile(4:1-4:1), (inferred-types (defs) (type_decls - (alias @3.1-3.15 (type "Error") + (alias @3.1-3.15 (type "") (ty-header @3.1-3.11 (name "")))) (expressions)) ~~~ diff --git a/test/snapshots/fuzz_crash/fuzz_crash_022.md b/test/snapshots/fuzz_crash/fuzz_crash_022.md index 793dc8987c..dc96740d18 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_022.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_022.md @@ -223,10 +223,10 @@ ain! = |_| getUser(900) (e-call @8.13-8.25 (e-lookup-local @8.13-8.20 (p-assign @6.1-6.8 (ident "getUser"))) - (e-int @8.21-8.24 (value "900")))))) + (e-num @8.21-8.24 (value "900")))))) (s-alias-decl @3.1-3.13 (ty-header @3.1-3.7 (name "UserId")) - (ty @3.10-3.13 (name "U64")))) + (ty-lookup @3.10-3.13 (name "U64") (builtin)))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/fuzz_crash/fuzz_crash_023.md b/test/snapshots/fuzz_crash/fuzz_crash_023.md index c86859cdf0..94e07c286f 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_023.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_023.md @@ -231,8 +231,6 @@ UNDECLARED TYPE - fuzz_crash_023.md:52:4:52:6 UNDECLARED TYPE - fuzz_crash_023.md:53:8:53:17 MODULE NOT FOUND - fuzz_crash_023.md:4:1:4:42 NOT IMPLEMENTED - :0:0:0:0 -NOT IMPLEMENTED - :0:0:0:0 -NOT IMPLEMENTED - :0:0:0:0 MODULE NOT FOUND - fuzz_crash_023.md:6:1:12:4 MODULE NOT FOUND - fuzz_crash_023.md:14:1:14:82 MODULE NOT FOUND - fuzz_crash_023.md:16:1:16:27 @@ -460,16 +458,6 @@ This feature is not yet implemented: malformed import module name contains inval This error doesn't have a proper diagnostic report yet. Let us know if you want to help improve Roc's error messages! -**NOT IMPLEMENTED** -This feature is not yet implemented: Exposed item 'line!' already imported from module 'pf.Stdout', cannot import again from module 'MALFORMED_IMPORT' - -This error doesn't have a proper diagnostic report yet. Let us know if you want to help improve Roc's error messages! - -**NOT IMPLEMENTED** -This feature is not yet implemented: Exposed item 'write!' already imported from module 'pf.Stdout', cannot import again from module 'MALFORMED_IMPORT' - -This error doesn't have a proper diagnostic report yet. Let us know if you want to help improve Roc's error messages! - **MODULE NOT FOUND** The module `MALFORMED_IMPORT` was not found in this Roc project. @@ -907,7 +895,7 @@ This `if` condition needs to be a _Bool_: ^^^ Right now, it has the type: - _U64_ + _Num(Int(Unsigned64))_ Every `if` condition must evaluate to a _Bool_–either `True` or `False`. @@ -995,8 +983,8 @@ This expression is used in an unexpected way: It has the type: __arg -> _ret_ -But here it's being used as: - _[Red][Blue, Green]_others, _arg2 -> Error_ +But I expected it to be: + _[Red][Blue, Green]_others, _arg -> Error_ # TOKENS ~~~zig @@ -1936,9 +1924,9 @@ expect { (if-branch (e-lookup-local @65.28-65.31 (p-assign @65.20-65.23 (ident "num"))) - (e-int @65.32-65.33 (value "2")))) + (e-num @65.32-65.33 (value "2")))) (if-else - (e-int @65.39-65.40 (value "5")))))) + (e-num @65.39-65.40 (value "5")))))) (d-let (p-assign @68.1-68.8 (ident "add_one")) (e-lambda @68.11-78.2 @@ -1947,7 +1935,7 @@ expect { (e-block @68.17-78.2 (s-let @69.2-69.11 (p-assign @69.2-69.7 (ident "other")) - (e-int @69.10-69.11 (value "1"))) + (e-num @69.10-69.11 (value "1"))) (e-if @70.2-77.3 (if-branches (if-branch @@ -1957,18 +1945,18 @@ expect { (s-dbg @71.3-72.15 (e-call @72.4-72.15 (e-runtime-error (tag "ident_not_in_scope")))) - (e-int @73.3-73.4 (value "0"))))) + (e-num @73.3-73.4 (value "0"))))) (if-else (e-block @74.9-77.3 (s-dbg @75.3-75.10 - (e-int @75.7-75.10 (value "123"))) + (e-num @75.7-75.10 (value "123"))) (e-lookup-local @76.3-76.8 (p-assign @69.2-69.7 (ident "other")))))))) (annotation @68.1-68.8 (declared-type (ty-fn @67.11-67.21 (effectful false) - (ty @67.11-67.14 (name "U64")) - (ty @67.18-67.21 (name "U64")))))) + (ty-lookup @67.11-67.14 (name "U64") (builtin)) + (ty-lookup @67.18-67.21 (name "U64") (builtin)))))) (d-let (p-assign @80.1-80.11 (ident "match_time")) (e-closure @80.14-138.3 @@ -1998,7 +1986,7 @@ expect { (e-block @85.25-88.4 (s-let @86.4-86.10 (p-assign @86.4-86.5 (ident "x")) - (e-int @86.8-86.10 (value "12"))) + (e-num @86.8-86.10 (value "12"))) (e-lookup-local @87.4-87.5 (p-assign @86.4-86.5 (ident "x")))))) (branch @@ -2013,7 +2001,7 @@ expect { (e-block @93.7-96.5 (s-let @94.5-94.11 (p-assign @94.5-94.6 (ident "x")) - (e-int @94.9-94.11 (value "12"))) + (e-num @94.9-94.11 (value "12"))) (e-lookup-local @95.5-95.6 (p-assign @94.5-94.6 (ident "x")))))) (branch @@ -2021,13 +2009,13 @@ expect { (pattern (degenerate false) (p-assign @97.3-97.8 (ident "lower")))) (value - (e-int @98.7-98.8 (value "1")))) + (e-num @98.7-98.8 (value "1")))) (branch (patterns (pattern (degenerate false) (p-str @99.3-99.8 (text """)))) (value - (e-int @100.4-100.7 (value "100")))) + (e-num @100.4-100.7 (value "100")))) (branch (patterns (pattern (degenerate false) @@ -2035,49 +2023,49 @@ expect { (pattern (degenerate false) (p-str @101.11-101.16 (text """)))) (value - (e-int @101.20-101.23 (value "200")))) + (e-num @101.20-101.23 (value "200")))) (branch (patterns (pattern (degenerate false) (p-list @102.3-102.24 (patterns - (p-int @102.4-102.5 (value "1")) - (p-int @102.7-102.8 (value "2")) - (p-int @102.10-102.11 (value "3"))) + (p-num @102.4-102.5 (value "1")) + (p-num @102.7-102.8 (value "2")) + (p-num @102.10-102.11 (value "3"))) (rest-at (index 3) (p-assign @1.1-1.1 (ident "rest")))))) (value - (e-int @104.5-104.8 (value "123")))) + (e-num @104.5-104.8 (value "123")))) (branch (patterns (pattern (degenerate false) (p-list @108.3-108.28 (patterns - (p-int @108.4-108.5 (value "1")) + (p-num @108.4-108.5 (value "1")) (p-runtime-error @1.1-1.1 (tag "not_implemented")) - (p-int @108.14-108.15 (value "3"))) + (p-num @108.14-108.15 (value "3"))) (rest-at (index 3) (p-assign @1.1-1.1 (ident "rest")))))) (value - (e-int @108.32-108.35 (value "123")))) + (e-num @108.32-108.35 (value "123")))) (branch (patterns (pattern (degenerate false) (p-list @109.3-116.4 (patterns - (p-int @110.4-110.5 (value "1")) + (p-num @110.4-110.5 (value "1")) (p-runtime-error @1.1-1.1 (tag "not_implemented")) - (p-int @112.4-112.5 (value "3"))) + (p-num @112.4-112.5 (value "3"))) (rest-at (index 3) (p-assign @1.1-1.1 (ident "rest")))))) (value - (e-int @116.8-116.11 (value "123")))) + (e-num @116.8-116.11 (value "123")))) (branch (patterns (pattern (degenerate false) (p-small-dec @117.3-117.7))) (value - (e-int @117.11-117.14 (value "314")))) + (e-num @117.11-117.14 (value "314")))) (branch (patterns (pattern (degenerate false) @@ -2085,27 +2073,27 @@ expect { (pattern (degenerate false) (p-small-dec @118.10-118.14))) (value - (e-int @118.18-118.21 (value "314")))) + (e-num @118.18-118.21 (value "314")))) (branch (patterns (pattern (degenerate false) (p-tuple @119.3-119.12 (patterns - (p-int @119.4-119.5 (value "1")) - (p-int @119.7-119.8 (value "2")) - (p-int @119.10-119.11 (value "3")))))) + (p-num @119.4-119.5 (value "1")) + (p-num @119.7-119.8 (value "2")) + (p-num @119.10-119.11 (value "3")))))) (value - (e-int @119.16-119.19 (value "123")))) + (e-num @119.16-119.19 (value "123")))) (branch (patterns (pattern (degenerate false) (p-tuple @120.3-120.16 (patterns - (p-int @120.4-120.5 (value "1")) + (p-num @120.4-120.5 (value "1")) (p-runtime-error @1.1-1.1 (tag "not_implemented")) - (p-int @120.14-120.15 (value "3")))))) + (p-num @120.14-120.15 (value "3")))))) (value - (e-int @120.20-120.23 (value "123")))) + (e-num @120.20-120.23 (value "123")))) (branch (patterns (pattern (degenerate false) @@ -2113,10 +2101,10 @@ expect { (destructs (record-destruct @121.5-121.11 (label "foo") (ident "foo") (sub-pattern - (p-int @121.10-121.11 (value "1")))) + (p-num @121.10-121.11 (value "1")))) (record-destruct @121.13-121.19 (label "bar") (ident "bar") (sub-pattern - (p-int @121.18-121.19 (value "2")))) + (p-num @121.18-121.19 (value "2")))) (record-destruct @121.21-121.27 (label "rest") (ident "rest") (required (p-assign @121.21-121.27 (ident "rest")))))))) @@ -2129,15 +2117,15 @@ expect { (destructs (record-destruct @123.4-125.7 (label "foo") (ident "foo") (sub-pattern - (p-int @125.6-125.7 (value "1")))) + (p-num @125.6-125.7 (value "1")))) (record-destruct @126.4-126.10 (label "bar") (ident "bar") (sub-pattern - (p-int @126.9-126.10 (value "2")))) + (p-num @126.9-126.10 (value "2")))) (record-destruct @127.4-128.9 (label "rest") (ident "rest") (required (p-assign @127.4-128.9 (ident "rest")))))))) (value - (e-int @129.8-129.10 (value "12")))) + (e-num @129.8-129.10 (value "12")))) (branch (patterns (pattern (degenerate false) @@ -2145,12 +2133,12 @@ expect { (destructs (record-destruct @130.5-130.11 (label "foo") (ident "foo") (sub-pattern - (p-int @130.10-130.11 (value "1")))) + (p-num @130.10-130.11 (value "1")))) (record-destruct @130.13-130.23 (label "bar") (ident "bar") (sub-pattern (p-runtime-error @1.1-1.1 (tag "not_implemented")))))))) (value - (e-int @130.29-130.31 (value "12")))) + (e-num @130.29-130.31 (value "12")))) (branch (patterns (pattern (degenerate false) @@ -2158,19 +2146,19 @@ expect { (destructs (record-destruct @132.4-132.10 (label "foo") (ident "foo") (sub-pattern - (p-int @132.9-132.10 (value "1")))) + (p-num @132.9-132.10 (value "1")))) (record-destruct @133.4-133.14 (label "bar") (ident "bar") (sub-pattern (p-runtime-error @1.1-1.1 (tag "not_implemented")))))))) (value - (e-int @134.8-134.10 (value "12")))) + (e-num @134.8-134.10 (value "12")))) (branch (patterns (pattern (degenerate false) (p-nominal @135.3-135.10 (p-applied-tag @135.3-135.10)))) (value - (e-int @135.14-135.17 (value "123")))) + (e-num @135.14-135.17 (value "123")))) (branch (patterns (pattern (degenerate false) @@ -2184,13 +2172,13 @@ expect { (pattern (degenerate false) (p-applied-tag @137.3-137.34))) (value - (e-int @137.38-137.42 (value "1000")))))))))) + (e-num @137.38-137.42 (value "1000")))))))))) (d-let (p-assign @144.1-144.6 (ident "main!")) (e-closure @144.9-196.2 (captures - (capture @68.1-68.8 (ident "add_one")) - (capture @80.1-80.11 (ident "match_time"))) + (capture @80.1-80.11 (ident "match_time")) + (capture @68.1-68.8 (ident "add_one"))) (e-lambda @144.9-196.2 (args (p-underscore @144.10-144.11)) @@ -2201,11 +2189,11 @@ expect { (e-literal @145.11-145.16 (string "World")))) (s-var @146.2-146.18 (p-assign @146.2-146.18 (ident "number")) - (e-int @146.15-146.18 (value "123"))) + (e-num @146.15-146.18 (value "123"))) (s-expect @147.2-147.18 (e-binop @147.9-147.18 (op "eq") (e-runtime-error (tag "ident_not_in_scope")) - (e-int @147.17-147.18 (value "1")))) + (e-num @147.17-147.18 (value "1")))) (s-let @148.2-148.12 (p-assign @148.2-148.5 (ident "tag")) (e-tag @148.8-148.12 (name "Blue"))) @@ -2223,7 +2211,7 @@ expect { (e-call @158.2-161.3 (e-runtime-error (tag "ident_not_in_scope")) (e-dbg @159.3-160.6 - (e-int @160.4-160.6 (value "42"))))) + (e-num @160.4-160.6 (value "42"))))) (s-crash @162.2-163.17 (msg "Unreachable!")) (s-let @164.2-164.31 (p-assign @164.2-164.18 (ident "tag_with_payload")) @@ -2249,8 +2237,8 @@ expect { (e-dbg @168.4-169.11 (e-lookup-local @169.5-169.11 (p-assign @146.2-146.18 (ident "number"))))) - (e-int @171.3-171.6 (value "456")) - (e-int @172.3-172.6 (value "789"))))) + (e-num @171.3-171.6 (value "456")) + (e-num @172.3-172.6 (value "789"))))) (s-runtime-error (tag "not_implemented")) (s-let @178.2-178.40 (p-assign @178.2-178.8 (ident "record")) @@ -2262,13 +2250,11 @@ expect { (p-assign @148.2-148.5 (ident "tag")))) (s-expr @178.45-178.46 (e-runtime-error (tag "expr_not_canonicalized"))) - (s-type-anno @178.47-178.71 (name "qux") - (ty-malformed @178.52-178.71)) (s-let @179.2-179.68 (p-assign @179.2-179.7 (ident "tuple")) (e-tuple @179.10-179.68 (elems - (e-int @179.11-179.14 (value "123")) + (e-num @179.11-179.14 (value "123")) (e-string @179.16-179.23 (e-literal @179.17-179.22 (string "World"))) (e-lookup-local @179.25-179.28 @@ -2285,14 +2271,14 @@ expect { (p-assign @179.2-179.7 (ident "tuple"))))) (e-list @179.58-179.67 (elems - (e-int @179.59-179.60 (value "1")) - (e-int @179.62-179.63 (value "2")) - (e-int @179.65-179.66 (value "3"))))))) + (e-num @179.59-179.60 (value "1")) + (e-num @179.62-179.63 (value "2")) + (e-num @179.65-179.66 (value "3"))))))) (s-let @180.2-187.3 (p-assign @180.2-180.17 (ident "multiline_tuple")) (e-tuple @180.20-187.3 (elems - (e-int @181.3-181.6 (value "123")) + (e-num @181.3-181.6 (value "123")) (e-string @182.3-182.10 (e-literal @182.4-182.9 (string "World"))) (e-runtime-error (tag "ident_not_in_scope")) @@ -2308,9 +2294,9 @@ expect { (p-assign @179.2-179.7 (ident "tuple"))))) (e-list @186.3-186.12 (elems - (e-int @186.4-186.5 (value "1")) - (e-int @186.7-186.8 (value "2")) - (e-int @186.10-186.11 (value "3"))))))) + (e-num @186.4-186.5 (value "1")) + (e-num @186.7-186.8 (value "2")) + (e-num @186.10-186.11 (value "3"))))))) (s-let @188.2-188.86 (p-assign @188.2-188.15 (ident "bin_op_result")) (e-binop @188.18-188.86 (op "or") @@ -2320,27 +2306,27 @@ expect { (e-tag @188.18-188.26 (name "Err") (args (e-runtime-error (tag "ident_not_in_scope"))))) - (e-int @188.30-188.32 (value "12"))) + (e-num @188.30-188.32 (value "12"))) (e-binop @188.35-188.40 (op "mul") - (e-int @188.35-188.36 (value "5")) - (e-int @188.39-188.40 (value "5")))) + (e-num @188.35-188.36 (value "5")) + (e-num @188.39-188.40 (value "5")))) (e-binop @188.44-188.86 (op "or") (e-binop @188.44-188.71 (op "and") (e-binop @188.44-188.54 (op "lt") (e-binop @188.44-188.50 (op "add") - (e-int @188.44-188.46 (value "13")) - (e-int @188.49-188.50 (value "2"))) - (e-int @188.53-188.54 (value "5"))) + (e-num @188.44-188.46 (value "13")) + (e-num @188.49-188.50 (value "2"))) + (e-num @188.53-188.54 (value "5"))) (e-binop @188.59-188.71 (op "ge") (e-binop @188.59-188.65 (op "sub") - (e-int @188.59-188.61 (value "10")) - (e-int @188.64-188.65 (value "1"))) - (e-int @188.69-188.71 (value "16")))) + (e-num @188.59-188.61 (value "10")) + (e-num @188.64-188.65 (value "1"))) + (e-num @188.69-188.71 (value "16")))) (e-binop @188.75-188.86 (op "le") - (e-int @188.75-188.77 (value "12")) + (e-num @188.75-188.77 (value "12")) (e-binop @188.81-188.86 (op "div") - (e-int @188.81-188.82 (value "3")) - (e-int @188.85-188.86 (value "5"))))))) + (e-num @188.81-188.82 (value "3")) + (e-num @188.85-188.86 (value "5"))))))) (s-let @189.2-189.111 (p-assign @189.2-189.23 (ident "static_dispatch_style")) (e-dot-access @189.26-189.111 (field "unknown") @@ -2354,7 +2340,7 @@ expect { (e-runtime-error (tag "not_implemented"))) (e-call @191.2-195.3 (e-lookup-external @191.2-191.14 - (module-idx "0") + (module-idx "2") (target-node-idx "0")) (e-string @192.3-194.18 (e-literal @192.4-192.14 (string "How about ")) @@ -2366,11 +2352,11 @@ expect { (annotation @144.1-144.6 (declared-type (ty-fn @143.9-143.38 (effectful false) - (ty-apply @143.9-143.21 (symbol "List") - (ty @143.14-143.20 (name "String"))) - (ty-apply @143.25-143.38 (symbol "Result") - (ty-record @143.32-143.34) - (ty-underscore @1.1-1.1)))))) + (ty-apply @143.9-143.21 (name "List") (builtin) + (ty-malformed @143.14-143.20)) + (ty-apply @143.25-143.38 (name "Result") (local) + (ty-record @143.25-143.38) + (ty-underscore @143.25-143.38)))))) (d-let (p-assign @199.1-199.6 (ident "empty")) (e-empty_record @199.9-199.11) @@ -2380,97 +2366,94 @@ expect { (s-alias-decl @22.1-22.41 (ty-header @22.1-22.10 (name "Map") (ty-args - (ty-var @22.5-22.6 (name "a")) - (ty-var @22.8-22.9 (name "b")))) + (ty-rigid-var @22.5-22.6 (name "a")) + (ty-rigid-var @22.8-22.9 (name "b")))) (ty-fn @22.13-22.41 (effectful false) - (ty-apply @22.13-22.20 (symbol "List") - (ty-var @22.18-22.19 (name "a"))) + (ty-apply @22.13-22.20 (name "List") (builtin) + (ty-rigid-var-lookup (ty-rigid-var @22.5-22.6 (name "a")))) (ty-parens @22.22-22.30 (ty-fn @22.23-22.29 (effectful false) - (ty-var @22.23-22.24 (name "a")) - (ty-var @22.28-22.29 (name "b")))) - (ty-apply @22.34-22.41 (symbol "List") - (ty-var @22.39-22.40 (name "b"))))) + (ty-rigid-var-lookup (ty-rigid-var @22.5-22.6 (name "a"))) + (ty-rigid-var-lookup (ty-rigid-var @22.8-22.9 (name "b"))))) + (ty-apply @22.34-22.41 (name "List") (builtin) + (ty-rigid-var-lookup (ty-rigid-var @22.8-22.9 (name "b")))))) (s-alias-decl @23.1-34.5 (ty-header @23.1-26.2 (name "MapML") (ty-args - (ty-var @24.2-24.3 (name "a")) - (ty-var @25.2-25.3 (name "b")))) + (ty-rigid-var @24.2-24.3 (name "a")) + (ty-rigid-var @25.2-25.3 (name "b")))) (ty-fn @28.3-34.5 (effectful false) - (ty-apply @28.3-30.4 (symbol "List") - (ty-var @29.4-29.5 (name "a"))) + (ty-apply @28.3-30.4 (name "List") (builtin) + (ty-rigid-var-lookup (ty-rigid-var @24.2-24.3 (name "a")))) (ty-parens @31.3-31.11 (ty-fn @31.4-31.10 (effectful false) - (ty-var @31.4-31.5 (name "a")) - (ty-var @31.9-31.10 (name "b")))) - (ty-apply @32.4-34.5 (symbol "List") - (ty-var @33.5-33.6 (name "b"))))) + (ty-rigid-var-lookup (ty-rigid-var @24.2-24.3 (name "a"))) + (ty-rigid-var-lookup (ty-rigid-var @25.2-25.3 (name "b"))))) + (ty-apply @32.4-34.5 (name "List") (builtin) + (ty-rigid-var-lookup (ty-rigid-var @25.2-25.3 (name "b")))))) (s-alias-decl @36.1-36.17 (ty-header @36.1-36.4 (name "Foo")) (ty-tuple @36.7-36.17 - (ty @36.8-36.11 (name "Bar")) - (ty @36.13-36.16 (name "Baz")))) + (ty-malformed @36.8-36.11) + (ty-malformed @36.13-36.16))) (s-alias-decl @38.1-41.2 (ty-header @38.1-38.13 (name "FooMultiline")) (ty-tuple @38.16-41.2 - (ty @39.2-39.5 (name "Bar")) - (ty @40.2-40.5 (name "Baz")))) + (ty-malformed @39.2-39.5) + (ty-malformed @40.2-40.5))) (s-alias-decl @43.1-43.43 (ty-header @43.1-43.8 (name "Some") (ty-args - (ty-var @43.6-43.7 (name "a")))) + (ty-rigid-var @43.6-43.7 (name "a")))) (ty-record @43.11-43.43 (field (field "foo") - (ty-apply @43.19-43.24 (symbol "Ok") - (ty-var @43.22-43.23 (name "a")))) + (ty-malformed @43.19-43.21)) (field (field "bar") - (ty @43.32-43.41 (name "Something"))))) + (ty-malformed @43.32-43.41)))) (s-alias-decl @44.1-47.2 (ty-header @44.1-44.10 (name "SomeMl") (ty-args - (ty-var @44.8-44.9 (name "a")))) + (ty-rigid-var @44.8-44.9 (name "a")))) (ty-record @44.13-47.2 (field (field "foo") - (ty-apply @45.8-45.13 (symbol "Ok") - (ty-var @45.11-45.12 (name "a")))) + (ty-malformed @45.8-45.10)) (field (field "bar") - (ty @46.8-46.17 (name "Something"))))) + (ty-malformed @46.8-46.17)))) (s-alias-decl @49.1-54.2 (ty-header @49.1-49.17 (name "SomeMultiline") (ty-args - (ty-var @49.15-49.16 (name "a")))) + (ty-rigid-var @49.15-49.16 (name "a")))) (ty-record @49.20-54.2 (field (field "foo") - (ty-apply @52.4-52.9 (symbol "Ok") - (ty-var @52.7-52.8 (name "a")))) + (ty-malformed @52.4-52.6)) (field (field "bar") - (ty @53.8-53.17 (name "Something"))))) + (ty-malformed @53.8-53.17)))) (s-alias-decl @56.1-56.27 (ty-header @56.1-56.9 (name "Maybe") (ty-args - (ty-var @56.7-56.8 (name "a")))) + (ty-rigid-var @56.7-56.8 (name "a")))) (ty-tag-union @56.12-56.27 - (ty-apply @56.13-56.20 (symbol "Some") - (ty-var @56.18-56.19 (name "a"))) - (ty @56.22-56.26 (name "None")))) + (ty-tag-name @56.13-56.20 (name "Some") + (ty-rigid-var-lookup (ty-rigid-var @56.7-56.8 (name "a")))) + (ty-tag-name @56.22-56.26 (name "None")))) (s-alias-decl @58.1-61.2 (ty-header @58.1-58.18 (name "MaybeMultiline") (ty-args - (ty-var @58.16-58.17 (name "a")))) + (ty-rigid-var @58.16-58.17 (name "a")))) (ty-tag-union @58.21-61.2 - (ty-apply @59.2-59.9 (symbol "Some") - (ty-var @59.7-59.8 (name "a"))) - (ty @60.2-60.6 (name "None")))) + (ty-tag-name @59.2-59.9 (name "Some") + (ty-rigid-var-lookup (ty-rigid-var @58.16-58.17 (name "a")))) + (ty-tag-name @60.2-60.6 (name "None")))) (s-alias-decl @63.1-63.38 (ty-header @63.1-63.12 (name "SomeFunc") (ty-args - (ty-var @63.10-63.11 (name "a")))) + (ty-rigid-var @63.10-63.11 (name "a")))) (ty-fn @63.15-63.38 (effectful false) - (ty-apply @63.15-63.23 (symbol "Maybe") - (ty-var @63.21-63.22 (name "a"))) - (ty-var @63.25-63.26 (name "a")) - (ty-apply @63.30-63.38 (symbol "Maybe") - (ty-var @63.36-63.37 (name "a"))))) + (ty-apply @63.15-63.23 (name "Maybe") (local) + (ty-rigid-var-lookup (ty-rigid-var @63.10-63.11 (name "a")))) + (ty-rigid-var-lookup (ty-rigid-var @63.10-63.11 (name "a"))) + (ty-apply @63.30-63.38 (name "Maybe") (local) + (ty-rigid-var-lookup (ty-rigid-var @63.10-63.11 (name "a")))))) (s-import @4.1-4.42 (module "pf.Stdout") (qualifier "pf") (exposes (exposed (name "line!") (wildcard false)) @@ -2491,15 +2474,15 @@ expect { (s-expect @140.1-141.11 (e-binop @141.2-141.11 (op "eq") (e-runtime-error (tag "ident_not_in_scope")) - (e-int @141.10-141.11 (value "1")))) + (e-num @141.10-141.11 (value "1")))) (s-expect @203.1-207.2 (e-block @203.8-207.2 (s-let @204.2-204.9 (p-assign @204.2-204.5 (ident "foo")) - (e-int @204.8-204.9 (value "1"))) + (e-num @204.8-204.9 (value "1"))) (s-let @205.2-205.10 (p-assign @205.2-205.6 (ident "blah")) - (e-int @205.9-205.10 (value "1"))) + (e-num @205.9-205.10 (value "1"))) (e-binop @206.2-206.13 (op "eq") (e-lookup-local @206.2-206.6 (p-assign @205.2-205.6 (ident "blah"))) @@ -2511,7 +2494,7 @@ expect { (inferred-types (defs (patt @65.1-65.16 (type "Bool -> Num(_size)")) - (patt @68.1-68.8 (type "Error -> Error")) + (patt @68.1-68.8 (type "Num(Int(Unsigned64)) -> Num(Int(Unsigned64))")) (patt @80.1-80.11 (type "[Red][Blue, Green]_others, _arg -> Error")) (patt @144.1-144.6 (type "List(Error) -> Result({ }, _d)")) (patt @199.1-199.6 (type "{}"))) @@ -2519,13 +2502,13 @@ expect { (alias @22.1-22.41 (type "Map(a, b)") (ty-header @22.1-22.10 (name "Map") (ty-args - (ty-var @22.5-22.6 (name "a")) - (ty-var @22.8-22.9 (name "b"))))) + (ty-rigid-var @22.5-22.6 (name "a")) + (ty-rigid-var @22.8-22.9 (name "b"))))) (alias @23.1-34.5 (type "MapML(a, b)") (ty-header @23.1-26.2 (name "MapML") (ty-args - (ty-var @24.2-24.3 (name "a")) - (ty-var @25.2-25.3 (name "b"))))) + (ty-rigid-var @24.2-24.3 (name "a")) + (ty-rigid-var @25.2-25.3 (name "b"))))) (alias @36.1-36.17 (type "Foo") (ty-header @36.1-36.4 (name "Foo"))) (alias @38.1-41.2 (type "FooMultiline") @@ -2533,30 +2516,30 @@ expect { (alias @43.1-43.43 (type "Some(a)") (ty-header @43.1-43.8 (name "Some") (ty-args - (ty-var @43.6-43.7 (name "a"))))) + (ty-rigid-var @43.6-43.7 (name "a"))))) (alias @44.1-47.2 (type "SomeMl(a)") (ty-header @44.1-44.10 (name "SomeMl") (ty-args - (ty-var @44.8-44.9 (name "a"))))) + (ty-rigid-var @44.8-44.9 (name "a"))))) (alias @49.1-54.2 (type "SomeMultiline(a)") (ty-header @49.1-49.17 (name "SomeMultiline") (ty-args - (ty-var @49.15-49.16 (name "a"))))) + (ty-rigid-var @49.15-49.16 (name "a"))))) (alias @56.1-56.27 (type "Maybe(a)") (ty-header @56.1-56.9 (name "Maybe") (ty-args - (ty-var @56.7-56.8 (name "a"))))) + (ty-rigid-var @56.7-56.8 (name "a"))))) (alias @58.1-61.2 (type "MaybeMultiline(a)") (ty-header @58.1-58.18 (name "MaybeMultiline") (ty-args - (ty-var @58.16-58.17 (name "a"))))) + (ty-rigid-var @58.16-58.17 (name "a"))))) (alias @63.1-63.38 (type "SomeFunc(a)") (ty-header @63.1-63.12 (name "SomeFunc") (ty-args - (ty-var @63.10-63.11 (name "a")))))) + (ty-rigid-var @63.10-63.11 (name "a")))))) (expressions (expr @65.19-65.40 (type "Bool -> Num(_size)")) - (expr @68.11-78.2 (type "Error -> Error")) + (expr @68.11-78.2 (type "Num(Int(Unsigned64)) -> Num(Int(Unsigned64))")) (expr @80.14-138.3 (type "[Red][Blue, Green]_others, _arg -> Error")) (expr @144.9-196.2 (type "List(Error) -> Result({ }, _d)")) (expr @199.9-199.11 (type "{}")))) diff --git a/test/snapshots/fuzz_crash/fuzz_crash_024.md b/test/snapshots/fuzz_crash/fuzz_crash_024.md index 4a9c51331c..2b87493654 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_024.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_024.md @@ -1,12 +1,10 @@ # META ~~~ini description=fuzz crash -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [module ] { pf: platform ".-/main._]where # A - #el var t= ] @@ -14,100 +12,17 @@ var t= ] var t= 0 ~~~ # EXPECTED -UNCLOSED STRING - :0:0:0:0 -PARSE ERROR - fuzz_crash_024.md:1:9:1:15 -PARSE ERROR - fuzz_crash_024.md:1:18:1:19 -UNEXPECTED TOKEN IN TYPE ANNOTATION - fuzz_crash_024.md:1:24:1:32 -PARSE ERROR - fuzz_crash_024.md:1:33:1:34 -PARSE ERROR - fuzz_crash_024.md:1:34:1:53 -PARSE ERROR - fuzz_crash_024.md:1:53:1:53 -PARSE ERROR - fuzz_crash_024.md:4:1:4:4 -UNEXPECTED TOKEN IN EXPRESSION - fuzz_crash_024.md:4:8:4:9 -PARSE ERROR - fuzz_crash_024.md:7:1:7:4 -MALFORMED TYPE - fuzz_crash_024.md:1:24:1:32 -UNRECOGNIZED SYNTAX - fuzz_crash_024.md:4:8:4:9 -DUPLICATE DEFINITION - fuzz_crash_024.md:7:5:7:6 +PARSE ERROR - fuzz_crash_024.md:2:1:2:4 +UNEXPECTED TOKEN IN EXPRESSION - fuzz_crash_024.md:2:8:2:9 +PARSE ERROR - fuzz_crash_024.md:5:1:5:4 +UNRECOGNIZED SYNTAX - fuzz_crash_024.md:2:8:2:9 +DUPLICATE DEFINITION - fuzz_crash_024.md:5:5:5:6 # PROBLEMS -**UNCLOSED STRING** -This string is missing a closing quote. - -```roc -module [module ] { pf: platform ".-/main._]where # A -``` - ^^^^^^^^^^^^^^^^^^^^ - - -**PARSE ERROR** -A parsing error occurred: `exposed_item_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_024.md:1:9:1:15:** -```roc -module [module ] { pf: platform ".-/main._]where # A -``` - ^^^^^^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_024.md:1:18:1:19:** -```roc -module [module ] { pf: platform ".-/main._]where # A -``` - ^ - - -**UNEXPECTED TOKEN IN TYPE ANNOTATION** -The token **platform** is not expected in a type annotation. -Type annotations should contain types like _Str_, _Num a_, or _List U64_. - -**fuzz_crash_024.md:1:24:1:32:** -```roc -module [module ] { pf: platform ".-/main._]where # A -``` - ^^^^^^^^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_024.md:1:33:1:34:** -```roc -module [module ] { pf: platform ".-/main._]where # A -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_024.md:1:34:1:53:** -```roc -module [module ] { pf: platform ".-/main._]where # A -``` - ^^^^^^^^^^^^^^^^^^^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_024.md:1:53:1:53:** -```roc -module [module ] { pf: platform ".-/main._]where # A -``` - ^ - - **PARSE ERROR** A parsing error occurred: `var_only_allowed_in_a_body` This is an unexpected parsing error. Please check your syntax. -**fuzz_crash_024.md:4:1:4:4:** +**fuzz_crash_024.md:2:1:2:4:** ```roc var t= ] ``` @@ -118,7 +33,7 @@ var t= ] The token **]** is not expected in an expression. Expressions can be identifiers, literals, function calls, or operators. -**fuzz_crash_024.md:4:8:4:9:** +**fuzz_crash_024.md:2:8:2:9:** ```roc var t= ] ``` @@ -129,27 +44,17 @@ var t= ] A parsing error occurred: `var_only_allowed_in_a_body` This is an unexpected parsing error. Please check your syntax. -**fuzz_crash_024.md:7:1:7:4:** +**fuzz_crash_024.md:5:1:5:4:** ```roc var t= 0 ``` ^^^ -**MALFORMED TYPE** -This type annotation is malformed or contains invalid syntax. - -**fuzz_crash_024.md:1:24:1:32:** -```roc -module [module ] { pf: platform ".-/main._]where # A -``` - ^^^^^^^^ - - **UNRECOGNIZED SYNTAX** I don't recognize this syntax. -**fuzz_crash_024.md:4:8:4:9:** +**fuzz_crash_024.md:2:8:2:9:** ```roc var t= ] ``` @@ -161,14 +66,14 @@ This might be a syntax error, an unsupported language feature, or a typo. The name `t` is being redeclared in this scope. The redeclaration is here: -**fuzz_crash_024.md:7:5:7:6:** +**fuzz_crash_024.md:5:5:5:6:** ```roc var t= 0 ``` ^ But `t` was already defined here: -**fuzz_crash_024.md:4:5:4:6:** +**fuzz_crash_024.md:2:5:2:6:** ```roc var t= ] ``` @@ -177,39 +82,27 @@ var t= ] # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),KwModule(1:9-1:15),CloseSquare(1:16-1:17),OpenCurly(1:18-1:19),LowerIdent(1:20-1:22),OpColon(1:22-1:23),KwPlatform(1:24-1:32),StringStart(1:33-1:34),StringPart(1:34-1:53),StringEnd(1:53-1:53), -KwVar(4:1-4:4),LowerIdent(4:5-4:6),OpAssign(4:6-4:7),CloseSquare(4:8-4:9), -KwVar(7:1-7:4),LowerIdent(7:5-7:6),OpAssign(7:6-7:7),Int(7:8-7:9), -EndOfFile(8:1-8:1), +KwVar(2:1-2:4),LowerIdent(2:5-2:6),OpAssign(2:6-2:7),CloseSquare(2:8-2:9), +KwVar(5:1-5:4),LowerIdent(5:5-5:6),OpAssign(5:6-5:7),Int(5:8-5:9), +EndOfFile(6:1-6:1), ~~~ # PARSE ~~~clojure -(file @1.1-7.9 - (module @1.1-1.17 - (exposes @1.8-1.17 - (exposed-malformed @1.9-1.15 (reason "exposed_item_unexpected_token") @1.9-1.15))) +(file @2.1-5.9 + (type-module @2.1-2.4) (statements - (s-malformed @1.18-1.19 (tag "statement_unexpected_token")) - (s-type-anno @1.20-1.32 (name "pf") - (ty-malformed @1.24-1.32 (tag "ty_anno_unexpected_token"))) - (s-malformed @1.33-1.34 (tag "statement_unexpected_token")) - (s-malformed @1.34-1.53 (tag "statement_unexpected_token")) - (s-malformed @1.53-1.53 (tag "statement_unexpected_token")) - (s-malformed @4.1-4.4 (tag "var_only_allowed_in_a_body")) - (s-decl @4.5-4.9 - (p-ident @4.5-4.6 (raw "t")) - (e-malformed @4.8-4.9 (reason "expr_unexpected_token"))) - (s-malformed @7.1-7.4 (tag "var_only_allowed_in_a_body")) - (s-decl @7.5-7.9 - (p-ident @7.5-7.6 (raw "t")) - (e-int @7.8-7.9 (raw "0"))))) + (s-malformed @2.1-2.4 (tag "var_only_allowed_in_a_body")) + (s-decl @2.5-2.9 + (p-ident @2.5-2.6 (raw "t")) + (e-malformed @2.8-2.9 (reason "expr_unexpected_token"))) + (s-malformed @5.1-5.4 (tag "var_only_allowed_in_a_body")) + (s-decl @5.5-5.9 + (p-ident @5.5-5.6 (raw "t")) + (e-int @5.8-5.9 (raw "0"))))) ~~~ # FORMATTED ~~~roc -module [] -pf : - - +# el # el t = @@ -220,19 +113,19 @@ t = 0 ~~~clojure (can-ir (d-let - (p-assign @4.5-4.6 (ident "t")) + (p-assign @2.5-2.6 (ident "t")) (e-runtime-error (tag "expr_not_canonicalized"))) (d-let - (p-assign @7.5-7.6 (ident "t")) - (e-int @7.8-7.9 (value "0")))) + (p-assign @5.5-5.6 (ident "t")) + (e-num @5.8-5.9 (value "0")))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @4.5-4.6 (type "Error")) - (patt @7.5-7.6 (type "Num(_size)"))) + (patt @2.5-2.6 (type "Error")) + (patt @5.5-5.6 (type "Num(_size)"))) (expressions - (expr @4.8-4.9 (type "Error")) - (expr @7.8-7.9 (type "Num(_size)")))) + (expr @2.8-2.9 (type "Error")) + (expr @5.8-5.9 (type "Num(_size)")))) ~~~ diff --git a/test/snapshots/fuzz_crash/fuzz_crash_025.md b/test/snapshots/fuzz_crash/fuzz_crash_025.md index fc3b1d3e92..ee372ab0b6 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_025.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_025.md @@ -1,12 +1,10 @@ # META ~~~ini description=fuzz crash -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - a : U8 a = 255 @@ -34,14 +32,14 @@ j : I128 j = -17011687303715884105728 ~~~ # EXPECTED -PARSE ERROR - fuzz_crash_025.md:11:1:11:2 -PARSE ERROR - fuzz_crash_025.md:11:3:11:4 -PARSE ERROR - fuzz_crash_025.md:11:5:11:25 -PARSE ERROR - fuzz_crash_025.md:14:48:14:49 -PARSE ERROR - fuzz_crash_025.md:15:1:15:2 -PARSE ERROR - fuzz_crash_025.md:15:3:15:4 -PARSE ERROR - fuzz_crash_025.md:15:4:15:5 -TYPE MISMATCH - fuzz_crash_025.md:14:5:14:48 +PARSE ERROR - fuzz_crash_025.md:9:1:9:2 +PARSE ERROR - fuzz_crash_025.md:9:3:9:4 +PARSE ERROR - fuzz_crash_025.md:9:5:9:25 +PARSE ERROR - fuzz_crash_025.md:12:48:12:49 +PARSE ERROR - fuzz_crash_025.md:13:1:13:2 +PARSE ERROR - fuzz_crash_025.md:13:3:13:4 +PARSE ERROR - fuzz_crash_025.md:13:4:13:5 +TYPE MISMATCH - fuzz_crash_025.md:12:5:12:48 # PROBLEMS **PARSE ERROR** Type applications require parentheses around their type arguments. @@ -59,7 +57,7 @@ Other valid examples: `Result(a, Str)` `Maybe(List(U64))` -**fuzz_crash_025.md:11:1:11:2:** +**fuzz_crash_025.md:9:1:9:2:** ```roc d = 18446744073709551615 ``` @@ -70,7 +68,7 @@ d = 18446744073709551615 A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**fuzz_crash_025.md:11:3:11:4:** +**fuzz_crash_025.md:9:3:9:4:** ```roc d = 18446744073709551615 ``` @@ -81,7 +79,7 @@ d = 18446744073709551615 A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**fuzz_crash_025.md:11:5:11:25:** +**fuzz_crash_025.md:9:5:9:25:** ```roc d = 18446744073709551615 ``` @@ -92,7 +90,7 @@ d = 18446744073709551615 A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**fuzz_crash_025.md:14:48:14:49:** +**fuzz_crash_025.md:12:48:12:49:** ```roc e = 3402823669209384634633746074317682114553.14: I8 ``` @@ -115,7 +113,7 @@ Other valid examples: `Result(a, Str)` `Maybe(List(U64))` -**fuzz_crash_025.md:15:1:15:2:** +**fuzz_crash_025.md:13:1:13:2:** ```roc f =8 ``` @@ -126,7 +124,7 @@ f =8 A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**fuzz_crash_025.md:15:3:15:4:** +**fuzz_crash_025.md:13:3:13:4:** ```roc f =8 ``` @@ -137,7 +135,7 @@ f =8 A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**fuzz_crash_025.md:15:4:15:5:** +**fuzz_crash_025.md:13:4:13:5:** ```roc f =8 ``` @@ -146,99 +144,97 @@ f =8 **TYPE MISMATCH** This expression is used in an unexpected way: -**fuzz_crash_025.md:14:5:14:48:** +**fuzz_crash_025.md:12:5:12:48:** ```roc e = 3402823669209384634633746074317682114553.14: I8 ``` ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -The type annotation says it should have the type: - _U128_ +It has the type: + _Num(Frac(_size))_ -But here it's being used as: - _Frac(_size)_ +But the type annotation says it should have the type: + _Num(Int(Unsigned128))_ + +**Hint:** This might be because the numeric literal is either negative or too large to fit in the unsigned type. # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -LowerIdent(3:1-3:2),OpColon(3:3-3:4),UpperIdent(3:5-3:7), -LowerIdent(4:1-4:2),OpAssign(4:3-4:4),Int(4:5-4:8), -LowerIdent(6:1-6:2),OpColon(6:3-6:4),UpperIdent(6:5-6:8), -LowerIdent(7:1-7:2),OpAssign(7:3-7:4),Int(7:5-7:10), -LowerIdent(9:1-9:2),OpColon(9:3-9:4),UpperIdent(9:5-9:8), -LowerIdent(10:1-10:2),OpAssign(10:3-10:4),Int(10:5-10:14),UpperIdent(10:15-10:18), -LowerIdent(11:1-11:2),OpAssign(11:3-11:4),Int(11:5-11:25), -LowerIdent(13:1-13:2),OpColon(13:3-13:4),UpperIdent(13:5-13:9), -LowerIdent(14:1-14:2),OpAssign(14:3-14:4),Float(14:5-14:48),OpColon(14:48-14:49),UpperIdent(14:50-14:52), -LowerIdent(15:1-15:2),OpAssign(15:3-15:4),Int(15:4-15:5), -LowerIdent(17:1-17:2),OpColon(17:3-17:4),UpperIdent(17:5-17:8), -LowerIdent(18:1-18:2),OpAssign(18:3-18:4),Int(18:5-18:11), -LowerIdent(20:1-20:2),OpColon(20:3-20:4),UpperIdent(20:5-20:8), -LowerIdent(21:1-21:2),OpAssign(21:3-21:4),Int(21:5-21:12), -LowerIdent(23:1-23:2),OpColon(23:3-23:4),UpperIdent(23:5-23:8), -LowerIdent(24:1-24:2),OpAssign(24:3-24:4),Int(24:5-24:17), -LowerIdent(26:1-26:2),OpColon(26:3-26:4),UpperIdent(26:5-26:9), -LowerIdent(27:1-27:2),OpAssign(27:3-27:4),Int(27:5-27:29), -EndOfFile(28:1-28:1), +LowerIdent(1:1-1:2),OpColon(1:3-1:4),UpperIdent(1:5-1:7), +LowerIdent(2:1-2:2),OpAssign(2:3-2:4),Int(2:5-2:8), +LowerIdent(4:1-4:2),OpColon(4:3-4:4),UpperIdent(4:5-4:8), +LowerIdent(5:1-5:2),OpAssign(5:3-5:4),Int(5:5-5:10), +LowerIdent(7:1-7:2),OpColon(7:3-7:4),UpperIdent(7:5-7:8), +LowerIdent(8:1-8:2),OpAssign(8:3-8:4),Int(8:5-8:14),UpperIdent(8:15-8:18), +LowerIdent(9:1-9:2),OpAssign(9:3-9:4),Int(9:5-9:25), +LowerIdent(11:1-11:2),OpColon(11:3-11:4),UpperIdent(11:5-11:9), +LowerIdent(12:1-12:2),OpAssign(12:3-12:4),Float(12:5-12:48),OpColon(12:48-12:49),UpperIdent(12:50-12:52), +LowerIdent(13:1-13:2),OpAssign(13:3-13:4),Int(13:4-13:5), +LowerIdent(15:1-15:2),OpColon(15:3-15:4),UpperIdent(15:5-15:8), +LowerIdent(16:1-16:2),OpAssign(16:3-16:4),Int(16:5-16:11), +LowerIdent(18:1-18:2),OpColon(18:3-18:4),UpperIdent(18:5-18:8), +LowerIdent(19:1-19:2),OpAssign(19:3-19:4),Int(19:5-19:12), +LowerIdent(21:1-21:2),OpColon(21:3-21:4),UpperIdent(21:5-21:8), +LowerIdent(22:1-22:2),OpAssign(22:3-22:4),Int(22:5-22:17), +LowerIdent(24:1-24:2),OpColon(24:3-24:4),UpperIdent(24:5-24:9), +LowerIdent(25:1-25:2),OpAssign(25:3-25:4),Int(25:5-25:29), +EndOfFile(26:1-26:1), ~~~ # PARSE ~~~clojure -(file @1.1-27.29 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-25.29 + (type-module @1.1-1.2) (statements - (s-type-anno @3.1-3.7 (name "a") - (ty @3.5-3.7 (name "U8"))) - (s-decl @4.1-4.8 - (p-ident @4.1-4.2 (raw "a")) - (e-int @4.5-4.8 (raw "255"))) - (s-type-anno @6.1-6.8 (name "b") - (ty @6.5-6.8 (name "U16"))) - (s-decl @7.1-7.10 - (p-ident @7.1-7.2 (raw "b")) - (e-int @7.5-7.10 (raw "65535"))) - (s-type-anno @9.1-9.8 (name "c") - (ty @9.5-9.8 (name "U32"))) - (s-decl @10.1-10.14 - (p-ident @10.1-10.2 (raw "c")) - (e-int @10.5-10.14 (raw "429496729"))) - (s-malformed @11.1-11.2 (tag "expected_colon_after_type_annotation")) - (s-malformed @11.3-11.4 (tag "statement_unexpected_token")) - (s-malformed @11.5-11.25 (tag "statement_unexpected_token")) - (s-type-anno @13.1-13.9 (name "e") - (ty @13.5-13.9 (name "U128"))) - (s-decl @14.1-14.48 - (p-ident @14.1-14.2 (raw "e")) - (e-frac @14.5-14.48 (raw "3402823669209384634633746074317682114553.14"))) - (s-malformed @14.48-14.49 (tag "statement_unexpected_token")) - (s-malformed @15.1-15.2 (tag "expected_colon_after_type_annotation")) - (s-malformed @15.3-15.4 (tag "statement_unexpected_token")) - (s-malformed @15.4-15.5 (tag "statement_unexpected_token")) - (s-type-anno @17.1-17.8 (name "g") - (ty @17.5-17.8 (name "I16"))) - (s-decl @18.1-18.11 - (p-ident @18.1-18.2 (raw "g")) - (e-int @18.5-18.11 (raw "-32768"))) - (s-type-anno @20.1-20.8 (name "h") - (ty @20.5-20.8 (name "I32"))) - (s-decl @21.1-21.12 - (p-ident @21.1-21.2 (raw "h")) - (e-int @21.5-21.12 (raw "-483648"))) - (s-type-anno @23.1-23.8 (name "i") - (ty @23.5-23.8 (name "I64"))) - (s-decl @24.1-24.17 - (p-ident @24.1-24.2 (raw "i")) - (e-int @24.5-24.17 (raw "-92233725808"))) - (s-type-anno @26.1-26.9 (name "j") - (ty @26.5-26.9 (name "I128"))) - (s-decl @27.1-27.29 - (p-ident @27.1-27.2 (raw "j")) - (e-int @27.5-27.29 (raw "-17011687303715884105728"))))) + (s-type-anno @1.1-1.7 (name "a") + (ty @1.5-1.7 (name "U8"))) + (s-decl @2.1-2.8 + (p-ident @2.1-2.2 (raw "a")) + (e-int @2.5-2.8 (raw "255"))) + (s-type-anno @4.1-4.8 (name "b") + (ty @4.5-4.8 (name "U16"))) + (s-decl @5.1-5.10 + (p-ident @5.1-5.2 (raw "b")) + (e-int @5.5-5.10 (raw "65535"))) + (s-type-anno @7.1-7.8 (name "c") + (ty @7.5-7.8 (name "U32"))) + (s-decl @8.1-8.14 + (p-ident @8.1-8.2 (raw "c")) + (e-int @8.5-8.14 (raw "429496729"))) + (s-malformed @9.1-9.2 (tag "expected_colon_after_type_annotation")) + (s-malformed @9.3-9.4 (tag "statement_unexpected_token")) + (s-malformed @9.5-9.25 (tag "statement_unexpected_token")) + (s-type-anno @11.1-11.9 (name "e") + (ty @11.5-11.9 (name "U128"))) + (s-decl @12.1-12.48 + (p-ident @12.1-12.2 (raw "e")) + (e-frac @12.5-12.48 (raw "3402823669209384634633746074317682114553.14"))) + (s-malformed @12.48-12.49 (tag "statement_unexpected_token")) + (s-malformed @13.1-13.2 (tag "expected_colon_after_type_annotation")) + (s-malformed @13.3-13.4 (tag "statement_unexpected_token")) + (s-malformed @13.4-13.5 (tag "statement_unexpected_token")) + (s-type-anno @15.1-15.8 (name "g") + (ty @15.5-15.8 (name "I16"))) + (s-decl @16.1-16.11 + (p-ident @16.1-16.2 (raw "g")) + (e-int @16.5-16.11 (raw "-32768"))) + (s-type-anno @18.1-18.8 (name "h") + (ty @18.5-18.8 (name "I32"))) + (s-decl @19.1-19.12 + (p-ident @19.1-19.2 (raw "h")) + (e-int @19.5-19.12 (raw "-483648"))) + (s-type-anno @21.1-21.8 (name "i") + (ty @21.5-21.8 (name "I64"))) + (s-decl @22.1-22.17 + (p-ident @22.1-22.2 (raw "i")) + (e-int @22.5-22.17 (raw "-92233725808"))) + (s-type-anno @24.1-24.9 (name "j") + (ty @24.5-24.9 (name "I128"))) + (s-decl @25.1-25.29 + (p-ident @25.1-25.2 (raw "j")) + (e-int @25.5-25.29 (raw "-17011687303715884105728"))))) ~~~ # FORMATTED ~~~roc -module [] - a : U8 a = 255 @@ -270,73 +266,73 @@ j = -17011687303715884105728 ~~~clojure (can-ir (d-let - (p-assign @4.1-4.2 (ident "a")) - (e-int @4.5-4.8 (value "255")) - (annotation @4.1-4.2 + (p-assign @2.1-2.2 (ident "a")) + (e-num @2.5-2.8 (value "255")) + (annotation @2.1-2.2 (declared-type - (ty @3.5-3.7 (name "U8"))))) + (ty-lookup @1.5-1.7 (name "U8") (builtin))))) (d-let - (p-assign @7.1-7.2 (ident "b")) - (e-int @7.5-7.10 (value "65535")) - (annotation @7.1-7.2 + (p-assign @5.1-5.2 (ident "b")) + (e-num @5.5-5.10 (value "65535")) + (annotation @5.1-5.2 (declared-type - (ty @6.5-6.8 (name "U16"))))) + (ty-lookup @4.5-4.8 (name "U16") (builtin))))) (d-let - (p-assign @10.1-10.2 (ident "c")) - (e-int @10.5-10.14 (value "429496729")) - (annotation @10.1-10.2 + (p-assign @8.1-8.2 (ident "c")) + (e-num @8.5-8.14 (value "429496729")) + (annotation @8.1-8.2 (declared-type - (ty @9.5-9.8 (name "U32"))))) + (ty-lookup @7.5-7.8 (name "U32") (builtin))))) (d-let - (p-assign @14.1-14.2 (ident "e")) - (e-frac-f64 @14.5-14.48 (value "3.4028236692093846e39")) - (annotation @14.1-14.2 + (p-assign @12.1-12.2 (ident "e")) + (e-frac-f64 @12.5-12.48 (value "3.4028236692093846e39")) + (annotation @12.1-12.2 (declared-type - (ty @13.5-13.9 (name "U128"))))) + (ty-lookup @11.5-11.9 (name "U128") (builtin))))) (d-let - (p-assign @18.1-18.2 (ident "g")) - (e-int @18.5-18.11 (value "-32768")) - (annotation @18.1-18.2 + (p-assign @16.1-16.2 (ident "g")) + (e-num @16.5-16.11 (value "-32768")) + (annotation @16.1-16.2 (declared-type - (ty @17.5-17.8 (name "I16"))))) + (ty-lookup @15.5-15.8 (name "I16") (builtin))))) (d-let - (p-assign @21.1-21.2 (ident "h")) - (e-int @21.5-21.12 (value "-483648")) - (annotation @21.1-21.2 + (p-assign @19.1-19.2 (ident "h")) + (e-num @19.5-19.12 (value "-483648")) + (annotation @19.1-19.2 (declared-type - (ty @20.5-20.8 (name "I32"))))) + (ty-lookup @18.5-18.8 (name "I32") (builtin))))) (d-let - (p-assign @24.1-24.2 (ident "i")) - (e-int @24.5-24.17 (value "-92233725808")) - (annotation @24.1-24.2 + (p-assign @22.1-22.2 (ident "i")) + (e-num @22.5-22.17 (value "-92233725808")) + (annotation @22.1-22.2 (declared-type - (ty @23.5-23.8 (name "I64"))))) + (ty-lookup @21.5-21.8 (name "I64") (builtin))))) (d-let - (p-assign @27.1-27.2 (ident "j")) - (e-int @27.5-27.29 (value "-17011687303715884105728")) - (annotation @27.1-27.2 + (p-assign @25.1-25.2 (ident "j")) + (e-num @25.5-25.29 (value "-17011687303715884105728")) + (annotation @25.1-25.2 (declared-type - (ty @26.5-26.9 (name "I128")))))) + (ty-lookup @24.5-24.9 (name "I128") (builtin)))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @4.1-4.2 (type "U8")) - (patt @7.1-7.2 (type "U16")) - (patt @10.1-10.2 (type "U32")) - (patt @14.1-14.2 (type "Error")) - (patt @18.1-18.2 (type "I16")) - (patt @21.1-21.2 (type "I32")) - (patt @24.1-24.2 (type "I64")) - (patt @27.1-27.2 (type "I128"))) + (patt @2.1-2.2 (type "Num(Int(Unsigned8))")) + (patt @5.1-5.2 (type "Num(Int(Unsigned16))")) + (patt @8.1-8.2 (type "Num(Int(Unsigned32))")) + (patt @12.1-12.2 (type "Error")) + (patt @16.1-16.2 (type "Num(Int(Signed16))")) + (patt @19.1-19.2 (type "Num(Int(Signed32))")) + (patt @22.1-22.2 (type "Num(Int(Signed64))")) + (patt @25.1-25.2 (type "Num(Int(Signed128))"))) (expressions - (expr @4.5-4.8 (type "U8")) - (expr @7.5-7.10 (type "U16")) - (expr @10.5-10.14 (type "U32")) - (expr @14.5-14.48 (type "Error")) - (expr @18.5-18.11 (type "I16")) - (expr @21.5-21.12 (type "I32")) - (expr @24.5-24.17 (type "I64")) - (expr @27.5-27.29 (type "I128")))) + (expr @2.5-2.8 (type "Num(Int(Unsigned8))")) + (expr @5.5-5.10 (type "Num(Int(Unsigned16))")) + (expr @8.5-8.14 (type "Num(Int(Unsigned32))")) + (expr @12.5-12.48 (type "Error")) + (expr @16.5-16.11 (type "Num(Int(Signed16))")) + (expr @19.5-19.12 (type "Num(Int(Signed32))")) + (expr @22.5-22.17 (type "Num(Int(Signed64))")) + (expr @25.5-25.29 (type "Num(Int(Signed128))")))) ~~~ diff --git a/test/snapshots/fuzz_crash/fuzz_crash_026.md b/test/snapshots/fuzz_crash/fuzz_crash_026.md index b3bb2fa38c..1dd9704d1b 100644 Binary files a/test/snapshots/fuzz_crash/fuzz_crash_026.md and b/test/snapshots/fuzz_crash/fuzz_crash_026.md differ diff --git a/test/snapshots/fuzz_crash/fuzz_crash_027.md b/test/snapshots/fuzz_crash/fuzz_crash_027.md index 568f6e2142..6ffbe920a4 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_027.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_027.md @@ -224,10 +224,11 @@ UNUSED VARIABLE - fuzz_crash_027.md:133:2:133:9 UNUSED VARIABLE - fuzz_crash_027.md:141:2:141:7 UNUSED VARIABLE - fuzz_crash_027.md:142:2:142:7 UNDECLARED TYPE - fuzz_crash_027.md:153:9:153:14 +TOO FEW ARGS - fuzz_crash_027.md:21:3:22:4 INVALID IF CONDITION - fuzz_crash_027.md:50:5:50:5 INCOMPATIBLE MATCH PATTERNS - fuzz_crash_027.md:64:2:64:2 TYPE MISMATCH - fuzz_crash_027.md:111:2:113:3 -TYPE MISMATCH - fuzz_crash_027.md:142:10:142:47 +TYPE MISMATCH - fuzz_crash_027.md:143:2:147:3 # PROBLEMS **LEADING ZERO** Numbers cannot have leading zeros. @@ -844,6 +845,16 @@ tuple : Value((a, b, c)) ^^^^^ +**TOO FEW ARGS** +The type _List_ expects argument, but got instead. +**fuzz_crash_027.md:21:3:22:4:** +```roc + List( #rg + ), +``` + + + **INVALID IF CONDITION** This `if` condition needs to be a _Bool_: **fuzz_crash_027.md:50:5:** @@ -853,7 +864,7 @@ This `if` condition needs to be a _Bool_: ^^^ Right now, it has the type: - _U64_ + _Num(Int(Unsigned64))_ Every `if` condition must evaluate to a _Bool_–either `True` or `False`. @@ -917,23 +928,26 @@ This expression is used in an unexpected way: It has the type: __arg -> _ret_ -But here it's being used as: - _[Red, Blue]_others, _arg2 -> Error_ +But I expected it to be: + _[Red, Blue]_others, _arg -> Error_ **TYPE MISMATCH** This expression is used in an unexpected way: -**fuzz_crash_027.md:142:10:142:47:** +**fuzz_crash_027.md:143:2:147:3:** ```roc - stale = some_fn(arg1)?.statod()?.ned()?.recd? + Stdoline!( + "How about ${ # + Num.toStr(number) # on expr + } as a", + ) ``` - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -The type annotation says it should have the type: - _Result({ }, _d)_ - -But here it's being used as: +It has the type: _[Stdoline!(Str)]_others_ +But the type annotation says it should have the type: + _Result({ }, _d)_ + # TOKENS ~~~zig KwApp(2:1-2:4),OpenSquare(2:5-2:6),LowerIdent(2:6-2:11),CloseSquare(2:11-2:12),OpenCurly(2:13-2:14),LowerIdent(2:15-2:17),OpColon(2:17-2:18),KwPlatform(2:19-2:27),StringStart(2:28-2:29),StringPart(2:29-2:30),StringEnd(2:30-2:31),CloseCurly(2:32-2:33), @@ -1711,9 +1725,9 @@ expect { (if-branch (e-lookup-local @45.16-45.19 (p-assign @45.8-45.11 (ident "num"))) - (e-int @45.20-45.21 (value "2")))) + (e-num @45.20-45.21 (value "2")))) (if-else - (e-int @45.27-45.28 (value "5")))))) + (e-num @45.27-45.28 (value "5")))))) (d-let (p-assign @48.1-48.8 (ident "add_one")) (e-lambda @48.11-58.2 @@ -1722,7 +1736,7 @@ expect { (e-block @48.17-58.2 (s-let @49.2-49.11 (p-assign @49.2-49.7 (ident "other")) - (e-int @49.10-49.11 (value "1"))) + (e-num @49.10-49.11 (value "1"))) (e-if @50.2-57.3 (if-branches (if-branch @@ -1731,18 +1745,18 @@ expect { (e-block @50.9-54.3 (s-dbg @51.3-52.3 (e-runtime-error (tag "empty_tuple"))) - (e-int @53.3-53.4 (value "0"))))) + (e-num @53.3-53.4 (value "0"))))) (if-else (e-block @54.9-57.3 (s-dbg @55.3-55.10 - (e-int @55.7-55.10 (value "123"))) + (e-num @55.7-55.10 (value "123"))) (e-lookup-local @56.3-56.8 (p-assign @49.2-49.7 (ident "other")))))))) (annotation @48.1-48.8 (declared-type (ty-fn @47.11-47.21 (effectful false) - (ty @47.11-47.14 (name "U64")) - (ty @47.18-47.21 (name "U64")))))) + (ty-lookup @47.11-47.14 (name "U64") (builtin)) + (ty-lookup @47.18-47.21 (name "U64") (builtin)))))) (d-let (p-assign @60.1-60.11 (ident "match_time")) (e-lambda @60.14-94.3 @@ -1771,13 +1785,13 @@ expect { (pattern (degenerate false) (p-applied-tag @67.3-67.7))) (value - (e-int @67.12-67.13 (value "1")))) + (e-num @67.12-67.13 (value "1")))) (branch (patterns (pattern (degenerate false) (p-str @68.3-68.8 (text """)))) (value - (e-int @69.1-69.3 (value "0")))) + (e-num @69.1-69.3 (value "0")))) (branch (patterns (pattern (degenerate false) @@ -1785,15 +1799,15 @@ expect { (pattern (degenerate false) (p-str @70.11-70.16 (text """)))) (value - (e-int @70.20-70.22 (value "20")))) + (e-num @70.20-70.22 (value "20")))) (branch (patterns (pattern (degenerate false) (p-list @70.22-70.43 (patterns - (p-int @70.23-70.24 (value "1")) - (p-int @70.26-70.27 (value "2")) - (p-int @70.29-70.30 (value "3"))) + (p-num @70.23-70.24 (value "1")) + (p-num @70.26-70.27 (value "2")) + (p-num @70.29-70.30 (value "3"))) (rest-at (index 3) (p-assign @1.1-1.1 (ident "rest")))))) (value @@ -1803,13 +1817,13 @@ expect { (pattern (degenerate false) (p-list @74.3-74.28 (patterns - (p-int @74.4-74.5 (value "1")) + (p-num @74.4-74.5 (value "1")) (p-runtime-error @1.1-1.1 (tag "not_implemented")) - (p-int @74.14-74.15 (value "3"))) + (p-num @74.14-74.15 (value "3"))) (rest-at (index 3) (p-assign @1.1-1.1 (ident "rest")))))) (value - (e-int @74.32-74.35 (value "123")))) + (e-num @74.32-74.35 (value "123")))) (branch (patterns (pattern (degenerate false) @@ -1817,13 +1831,13 @@ expect { (patterns (p-assign @76.1-76.4 (ident "ist")))))) (value - (e-int @77.8-77.11 (value "123")))) + (e-num @77.8-77.11 (value "123")))) (branch (patterns (pattern (degenerate false) (p-small-dec @78.3-78.7))) (value - (e-int @78.11-78.14 (value "314")))) + (e-num @78.11-78.14 (value "314")))) (branch (patterns (pattern (degenerate false) @@ -1831,27 +1845,27 @@ expect { (pattern (degenerate false) (p-small-dec @79.10-79.14))) (value - (e-int @79.18-79.21 (value "314")))) + (e-num @79.18-79.21 (value "314")))) (branch (patterns (pattern (degenerate false) (p-tuple @80.3-80.12 (patterns - (p-int @80.4-80.5 (value "1")) - (p-int @80.7-80.8 (value "2")) - (p-int @80.10-80.11 (value "3")))))) + (p-num @80.4-80.5 (value "1")) + (p-num @80.7-80.8 (value "2")) + (p-num @80.10-80.11 (value "3")))))) (value - (e-int @80.16-80.19 (value "123")))) + (e-num @80.16-80.19 (value "123")))) (branch (patterns (pattern (degenerate false) (p-tuple @81.3-81.16 (patterns - (p-int @81.4-81.5 (value "1")) + (p-num @81.4-81.5 (value "1")) (p-runtime-error @1.1-1.1 (tag "not_implemented")) - (p-int @81.14-81.15 (value "3")))))) + (p-num @81.14-81.15 (value "3")))))) (value - (e-int @81.20-81.23 (value "123")))) + (e-num @81.20-81.23 (value "123")))) (branch (patterns (pattern (degenerate false) @@ -1859,10 +1873,10 @@ expect { (destructs (record-destruct @82.5-82.11 (label "foo") (ident "foo") (sub-pattern - (p-int @82.10-82.11 (value "1")))) + (p-num @82.10-82.11 (value "1")))) (record-destruct @82.13-82.19 (label "bar") (ident "bar") (sub-pattern - (p-int @82.18-82.19 (value "2")))) + (p-num @82.18-82.19 (value "2")))) (record-destruct @82.21-82.27 (label "rest") (ident "rest") (required (p-assign @82.21-82.27 (ident "rest")))))))) @@ -1873,7 +1887,7 @@ expect { (pattern (degenerate false) (p-runtime-error @88.4-88.6 (tag "not_implemented")))) (value - (e-int @88.11-88.13 (value "12")))) + (e-num @88.11-88.13 (value "12")))) (branch (patterns (pattern (degenerate false) @@ -1881,12 +1895,12 @@ expect { (destructs (record-destruct @89.5-89.11 (label "foo") (ident "foo") (sub-pattern - (p-int @89.10-89.11 (value "1")))) + (p-num @89.10-89.11 (value "1")))) (record-destruct @89.13-89.23 (label "bar") (ident "bar") (sub-pattern (p-runtime-error @1.1-1.1 (tag "not_implemented")))))))) (value - (e-int @89.29-89.31 (value "12")))) + (e-num @89.29-89.31 (value "12")))) (branch (patterns (pattern (degenerate false) @@ -1894,16 +1908,16 @@ expect { (destructs (record-destruct @91.4-91.10 (label "foo") (ident "foo") (sub-pattern - (p-int @91.9-91.10 (value "1")))))))) + (p-num @91.9-91.10 (value "1")))))))) (value - (e-int @92.9-92.11 (value "12")))) + (e-num @92.9-92.11 (value "12")))) (branch (patterns (pattern (degenerate false) (p-nominal @93.3-93.10 (p-applied-tag @93.3-93.10)))) (value - (e-int @93.14-93.20 (value "121000"))))))))) + (e-num @93.14-93.20 (value "121000"))))))))) (d-let (p-assign @100.1-100.6 (ident "main!")) (e-closure @100.9-148.2 @@ -1919,11 +1933,11 @@ expect { (e-literal @101.11-101.16 (string "World")))) (s-var @102.2-102.18 (p-assign @102.2-102.18 (ident "number")) - (e-int @102.15-102.18 (value "123"))) + (e-num @102.15-102.18 (value "123"))) (s-expect @103.2-103.18 (e-binop @103.9-103.18 (op "eq") (e-runtime-error (tag "ident_not_in_scope")) - (e-int @103.17-103.18 (value "1")))) + (e-num @103.17-103.18 (value "1")))) (s-let @104.2-104.12 (p-assign @104.2-104.5 (ident "tag")) (e-tag @104.8-104.12 (name "Blue"))) @@ -1941,7 +1955,7 @@ expect { (e-call @114.2-117.3 (e-runtime-error (tag "ident_not_in_scope")) (e-dbg @115.3-116.6 - (e-int @116.4-116.6 (value "42"))))) + (e-num @116.4-116.6 (value "42"))))) (s-crash @118.2-118.22 (msg "Unreachtement")) (s-let @119.2-119.23 (p-assign @119.2-119.10 (ident "tag_with")) @@ -1961,14 +1975,14 @@ expect { (p-assign @121.2-121.6 (ident "list")) (e-list @121.9-126.3 (elems - (e-int @125.6-125.9 (value "456"))))) + (e-num @125.6-125.9 (value "456"))))) (s-runtime-error (tag "not_implemented")) (s-let @131.2-131.71 (p-assign @131.2-131.8 (ident "record")) (e-record @131.11-131.71 (fields (field (name "foo") - (e-int @131.18-131.21 (value "123"))) + (e-num @131.18-131.21 (value "123"))) (field (name "bar") (e-string @131.28-131.35 (e-literal @131.29-131.34 (string "Hello")))) @@ -1987,7 +2001,7 @@ expect { (p-assign @132.2-132.7 (ident "tuple")) (e-tuple @132.10-132.68 (elems - (e-int @132.11-132.14 (value "123")) + (e-num @132.11-132.14 (value "123")) (e-string @132.16-132.23 (e-literal @132.17-132.22 (string "World"))) (e-lookup-local @132.25-132.28 @@ -2004,14 +2018,14 @@ expect { (p-assign @132.2-132.7 (ident "tuple"))))) (e-list @132.58-132.67 (elems - (e-int @132.59-132.60 (value "1")) - (e-int @132.62-132.63 (value "2")) - (e-int @132.65-132.66 (value "3"))))))) + (e-num @132.59-132.60 (value "1")) + (e-num @132.62-132.63 (value "2")) + (e-num @132.65-132.66 (value "3"))))))) (s-let @133.2-140.3 (p-assign @133.2-133.9 (ident "m_tuple")) (e-tuple @133.12-140.3 (elems - (e-int @134.3-134.6 (value "123")) + (e-num @134.3-134.6 (value "123")) (e-string @135.3-135.10 (e-literal @135.4-135.9 (string "World"))) (e-runtime-error (tag "ident_not_in_scope")) @@ -2027,9 +2041,9 @@ expect { (p-assign @132.2-132.7 (ident "tuple"))))) (e-list @139.3-139.12 (elems - (e-int @139.4-139.5 (value "1")) - (e-int @139.7-139.8 (value "2")) - (e-int @139.10-139.11 (value "3"))))))) + (e-num @139.4-139.5 (value "1")) + (e-num @139.7-139.8 (value "2")) + (e-num @139.10-139.11 (value "3"))))))) (s-let @141.2-141.78 (p-assign @141.2-141.7 (ident "bsult")) (e-binop @141.10-141.78 (op "or") @@ -2039,27 +2053,27 @@ expect { (e-tag @141.10-141.18 (name "Err") (args (e-runtime-error (tag "ident_not_in_scope"))))) - (e-int @141.22-141.24 (value "12"))) + (e-num @141.22-141.24 (value "12"))) (e-binop @141.27-141.32 (op "mul") - (e-int @141.27-141.28 (value "5")) - (e-int @141.31-141.32 (value "5")))) + (e-num @141.27-141.28 (value "5")) + (e-num @141.31-141.32 (value "5")))) (e-binop @141.36-141.78 (op "or") (e-binop @141.36-141.63 (op "and") (e-binop @141.36-141.46 (op "lt") (e-binop @141.36-141.42 (op "add") - (e-int @141.36-141.38 (value "13")) - (e-int @141.41-141.42 (value "2"))) - (e-int @141.45-141.46 (value "5"))) + (e-num @141.36-141.38 (value "13")) + (e-num @141.41-141.42 (value "2"))) + (e-num @141.45-141.46 (value "5"))) (e-binop @141.51-141.63 (op "ge") (e-binop @141.51-141.57 (op "sub") - (e-int @141.51-141.53 (value "10")) - (e-int @141.56-141.57 (value "1"))) - (e-int @141.61-141.63 (value "16")))) + (e-num @141.51-141.53 (value "10")) + (e-num @141.56-141.57 (value "1"))) + (e-num @141.61-141.63 (value "16")))) (e-binop @141.67-141.78 (op "le") - (e-int @141.67-141.69 (value "12")) + (e-num @141.67-141.69 (value "12")) (e-binop @141.73-141.78 (op "div") - (e-int @141.73-141.74 (value "3")) - (e-int @141.77-141.78 (value "5"))))))) + (e-num @141.73-141.74 (value "3")) + (e-num @141.77-141.78 (value "5"))))))) (s-let @142.2-142.47 (p-assign @142.2-142.7 (ident "stale")) (e-dot-access @142.10-142.47 (field "unknown") @@ -2081,11 +2095,11 @@ expect { (annotation @100.1-100.6 (declared-type (ty-fn @99.9-99.38 (effectful false) - (ty-apply @99.9-99.21 (symbol "List") - (ty @99.14-99.20 (name "String"))) - (ty-apply @99.25-99.38 (symbol "Result") - (ty-record @99.32-99.34) - (ty-underscore @1.1-1.1)))))) + (ty-apply @99.9-99.21 (name "List") (builtin) + (ty-malformed @99.14-99.20)) + (ty-apply @99.25-99.38 (name "Result") (local) + (ty-record @99.25-99.38) + (ty-underscore @99.25-99.38)))))) (d-let (p-assign @151.1-151.6 (ident "empty")) (e-empty_record @151.9-151.11) @@ -2095,69 +2109,66 @@ expect { (s-alias-decl @15.1-15.41 (ty-header @15.1-15.10 (name "Map") (ty-args - (ty-var @15.5-15.6 (name "a")) - (ty-var @15.8-15.9 (name "b")))) + (ty-rigid-var @15.5-15.6 (name "a")) + (ty-rigid-var @15.8-15.9 (name "b")))) (ty-fn @15.13-15.41 (effectful false) - (ty-apply @15.13-15.20 (symbol "List") - (ty-var @15.18-15.19 (name "a"))) + (ty-apply @15.13-15.20 (name "List") (builtin) + (ty-rigid-var-lookup (ty-rigid-var @15.5-15.6 (name "a")))) (ty-parens @15.22-15.30 (ty-fn @15.23-15.29 (effectful false) - (ty-var @15.23-15.24 (name "a")) - (ty-var @15.28-15.29 (name "b")))) - (ty-apply @15.34-15.41 (symbol "List") - (ty-var @15.39-15.40 (name "b"))))) + (ty-rigid-var-lookup (ty-rigid-var @15.5-15.6 (name "a"))) + (ty-rigid-var-lookup (ty-rigid-var @15.8-15.9 (name "b"))))) + (ty-apply @15.34-15.41 (name "List") (builtin) + (ty-rigid-var-lookup (ty-rigid-var @15.8-15.9 (name "b")))))) (s-alias-decl @16.1-24.15 (ty-header @16.1-19.2 (name "MapML") (ty-args - (ty-var @17.2-17.3 (name "a")) - (ty-var @18.2-18.3 (name "b")))) + (ty-rigid-var @17.2-17.3 (name "a")) + (ty-rigid-var @18.2-18.3 (name "b")))) (ty-fn @21.3-24.15 (effectful false) - (ty-apply @21.3-22.4 (symbol "List")) + (ty-apply @21.3-22.4 (name "List") (builtin)) (ty-parens @23.3-23.11 (ty-fn @23.4-23.10 (effectful false) - (ty-var @23.4-23.5 (name "a")) - (ty-var @23.9-23.10 (name "b")))) - (ty-apply @24.4-24.15 (symbol "List") - (ty-var @24.12-24.13 (name "b"))))) + (ty-rigid-var-lookup (ty-rigid-var @17.2-17.3 (name "a"))) + (ty-rigid-var-lookup (ty-rigid-var @18.2-18.3 (name "b"))))) + (ty-apply @24.4-24.15 (name "List") (builtin) + (ty-rigid-var-lookup (ty-rigid-var @18.2-18.3 (name "b")))))) (s-alias-decl @26.1-26.17 (ty-header @26.1-26.4 (name "Foo")) (ty-tuple @26.7-26.17 - (ty @26.8-26.11 (name "Bar")) - (ty @26.13-26.16 (name "Baz")))) + (ty-malformed @26.8-26.11) + (ty-malformed @26.13-26.16))) (s-alias-decl @32.1-32.35 (ty-header @32.1-32.8 (name "Some") (ty-args - (ty-var @32.6-32.7 (name "a")))) + (ty-rigid-var @32.6-32.7 (name "a")))) (ty-record @32.11-32.35 (field (field "foo") - (ty-apply @32.19-32.24 (symbol "Ok") - (ty-var @32.22-32.23 (name "a")))) + (ty-malformed @32.19-32.21)) (field (field "bar") (ty-malformed @32.32-32.33)))) (s-alias-decl @33.1-35.2 (ty-header @33.1-33.6 (name "Ml") (ty-args - (ty-var @33.4-33.5 (name "a")))) + (ty-rigid-var @33.4-33.5 (name "a")))) (ty-record @33.9-35.2 (field (field "bar") - (ty @34.8-34.11 (name "Som"))))) + (ty-malformed @34.8-34.11)))) (s-alias-decl @37.1-39.2 (ty-header @37.1-37.9 (name "Soine") (ty-args - (ty-var @37.7-37.8 (name "a")))) + (ty-rigid-var @37.7-37.8 (name "a")))) (ty-record @37.12-39.2 (field (field "bar") - (ty @38.8-38.11 (name "Som"))))) + (ty-malformed @38.8-38.11)))) (s-alias-decl @43.1-43.34 (ty-header @43.1-43.8 (name "Func") (ty-args - (ty-var @43.6-43.7 (name "a")))) + (ty-rigid-var @43.6-43.7 (name "a")))) (ty-fn @43.11-43.34 (effectful false) - (ty-apply @43.11-43.19 (symbol "Maybe") - (ty-var @43.17-43.18 (name "a"))) - (ty-var @43.21-43.22 (name "a")) - (ty-apply @43.26-43.34 (symbol "Maybe") - (ty-var @43.32-43.33 (name "a"))))) + (ty-malformed @43.11-43.16) + (ty-rigid-var-lookup (ty-rigid-var @43.6-43.7 (name "a"))) + (ty-malformed @43.26-43.31))) (s-import @4.1-4.38 (module "pf.Stdout") (qualifier "pf") (exposes (exposed (name "line!") (wildcard false)) @@ -2175,15 +2186,15 @@ expect { (s-expect @96.1-97.11 (e-binop @97.2-97.11 (op "eq") (e-runtime-error (tag "ident_not_in_scope")) - (e-int @97.10-97.11 (value "1")))) + (e-num @97.10-97.11 (value "1")))) (s-expect @155.1-159.2 (e-block @155.8-159.2 (s-let @156.2-156.9 (p-assign @156.2-156.5 (ident "foo")) - (e-int @156.8-156.9 (value "1"))) + (e-num @156.8-156.9 (value "1"))) (s-let @157.2-157.10 (p-assign @157.2-157.6 (ident "blah")) - (e-int @157.9-157.10 (value "1"))) + (e-num @157.9-157.10 (value "1"))) (e-binop @158.2-158.13 (op "eq") (e-lookup-local @158.2-158.6 (p-assign @157.2-157.6 (ident "blah"))) @@ -2195,7 +2206,7 @@ expect { (inferred-types (defs (patt @45.1-45.4 (type "Bool -> Num(_size)")) - (patt @48.1-48.8 (type "Error -> Error")) + (patt @48.1-48.8 (type "Num(Int(Unsigned64)) -> Num(Int(Unsigned64))")) (patt @60.1-60.11 (type "[Red, Blue]_others, _arg -> Error")) (patt @100.1-100.6 (type "List(Error) -> Error")) (patt @151.1-151.6 (type "{}"))) @@ -2203,34 +2214,34 @@ expect { (alias @15.1-15.41 (type "Map(a, b)") (ty-header @15.1-15.10 (name "Map") (ty-args - (ty-var @15.5-15.6 (name "a")) - (ty-var @15.8-15.9 (name "b"))))) + (ty-rigid-var @15.5-15.6 (name "a")) + (ty-rigid-var @15.8-15.9 (name "b"))))) (alias @16.1-24.15 (type "MapML(a, b)") (ty-header @16.1-19.2 (name "MapML") (ty-args - (ty-var @17.2-17.3 (name "a")) - (ty-var @18.2-18.3 (name "b"))))) + (ty-rigid-var @17.2-17.3 (name "a")) + (ty-rigid-var @18.2-18.3 (name "b"))))) (alias @26.1-26.17 (type "Foo") (ty-header @26.1-26.4 (name "Foo"))) (alias @32.1-32.35 (type "Some(a)") (ty-header @32.1-32.8 (name "Some") (ty-args - (ty-var @32.6-32.7 (name "a"))))) + (ty-rigid-var @32.6-32.7 (name "a"))))) (alias @33.1-35.2 (type "Ml(a)") (ty-header @33.1-33.6 (name "Ml") (ty-args - (ty-var @33.4-33.5 (name "a"))))) + (ty-rigid-var @33.4-33.5 (name "a"))))) (alias @37.1-39.2 (type "Soine(a)") (ty-header @37.1-37.9 (name "Soine") (ty-args - (ty-var @37.7-37.8 (name "a"))))) + (ty-rigid-var @37.7-37.8 (name "a"))))) (alias @43.1-43.34 (type "Func(a)") (ty-header @43.1-43.8 (name "Func") (ty-args - (ty-var @43.6-43.7 (name "a")))))) + (ty-rigid-var @43.6-43.7 (name "a")))))) (expressions (expr @45.7-45.28 (type "Bool -> Num(_size)")) - (expr @48.11-58.2 (type "Error -> Error")) + (expr @48.11-58.2 (type "Num(Int(Unsigned64)) -> Num(Int(Unsigned64))")) (expr @60.14-94.3 (type "[Red, Blue]_others, _arg -> Error")) (expr @100.9-148.2 (type "List(Error) -> Error")) (expr @151.9-151.11 (type "{}")))) diff --git a/test/snapshots/fuzz_crash/fuzz_crash_028.md b/test/snapshots/fuzz_crash/fuzz_crash_028.md index ed839f3116..e037f9b7c8 100644 Binary files a/test/snapshots/fuzz_crash/fuzz_crash_028.md and b/test/snapshots/fuzz_crash/fuzz_crash_028.md differ diff --git a/test/snapshots/fuzz_crash/fuzz_crash_031.md b/test/snapshots/fuzz_crash/fuzz_crash_031.md index 5839967f8b..503184da9d 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_031.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_031.md @@ -11,20 +11,17 @@ mule [] vavar t= ' ~~~ # EXPECTED -MISSING HEADER - fuzz_crash_031.md:1:1:1:5 +PARSE ERROR - fuzz_crash_031.md:1:1:1:5 PARSE ERROR - fuzz_crash_031.md:1:6:1:7 PARSE ERROR - fuzz_crash_031.md:1:7:1:8 PARSE ERROR - fuzz_crash_031.md:4:1:4:6 UNEXPECTED TOKEN IN EXPRESSION - fuzz_crash_031.md:4:10:4:11 UNRECOGNIZED SYNTAX - fuzz_crash_031.md:4:10:4:11 +MISSING MAIN! FUNCTION - fuzz_crash_031.md:1:1:4:11 # PROBLEMS -**MISSING HEADER** -Roc files must start with a module header. - -For example: - module [main] -or for an app: - app [main!] { pf: platform "../basic-cli/platform.roc" } +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. **fuzz_crash_031.md:1:1:1:5:** ```roc @@ -88,6 +85,22 @@ vavar t= ' This might be a syntax error, an unsupported language feature, or a typo. +**MISSING MAIN! FUNCTION** +Default app modules must have a `main!` function. + +No `main!` function was found. + +Add a main! function like: +`main! = |arg| { ... }` +**fuzz_crash_031.md:1:1:4:11:** +```roc +mule [] + +#el +vavar t= ' +``` + + # TOKENS ~~~zig LowerIdent(1:1-1:5),OpenSquare(1:6-1:7),CloseSquare(1:7-1:8), @@ -97,8 +110,9 @@ EndOfFile(5:1-5:1), # PARSE ~~~clojure (file @1.1-4.11 - (malformed-header @1.1-1.5 (tag "missing_header")) + (type-module @1.1-1.5) (statements + (s-malformed @1.1-1.5 (tag "statement_unexpected_token")) (s-malformed @1.6-1.7 (tag "statement_unexpected_token")) (s-malformed @1.7-1.8 (tag "statement_unexpected_token")) (s-malformed @4.1-4.6 (tag "statement_unexpected_token")) diff --git a/test/snapshots/fuzz_crash/fuzz_crash_032.md b/test/snapshots/fuzz_crash/fuzz_crash_032.md index 4c7dad55c6..0e81c65407 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_032.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_032.md @@ -1,12 +1,10 @@ # META ~~~ini description=fuzz crash, unterminated single quote -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [tus,r] - LocalStatus :lue => Loc= [Pending, Complete] olor : _ -> tus @@ -19,29 +17,27 @@ Green => LocalStatus-Complete } ~~~ # EXPECTED -PARSE ERROR - fuzz_crash_032.md:3:24:3:25 -PARSE ERROR - fuzz_crash_032.md:3:26:3:27 -PARSE ERROR - fuzz_crash_032.md:3:34:3:35 -PARSE ERROR - fuzz_crash_032.md:3:44:3:45 -IMPORT MUST BE TOP LEVEL - fuzz_crash_032.md:6:18:6:24 -UNEXPECTED TOKEN IN PATTERN - fuzz_crash_032.md:9:21:9:22 -PARSE ERROR - fuzz_crash_032.md:9:22:9:22 -UNDECLARED TYPE VARIABLE - fuzz_crash_032.md:3:14:3:17 -UNDECLARED TYPE - fuzz_crash_032.md:3:21:3:24 +PARSE ERROR - fuzz_crash_032.md:1:24:1:25 +PARSE ERROR - fuzz_crash_032.md:1:26:1:27 +PARSE ERROR - fuzz_crash_032.md:1:34:1:35 +PARSE ERROR - fuzz_crash_032.md:1:44:1:45 +IMPORT MUST BE TOP LEVEL - fuzz_crash_032.md:4:18:4:24 +UNEXPECTED TOKEN IN PATTERN - fuzz_crash_032.md:7:21:7:22 +PARSE ERROR - fuzz_crash_032.md:7:22:7:22 +UNDECLARED TYPE VARIABLE - fuzz_crash_032.md:1:14:1:17 +UNDECLARED TYPE - fuzz_crash_032.md:1:21:1:24 NOT IMPLEMENTED - :0:0:0:0 -UNDECLARED TYPE - fuzz_crash_032.md:6:25:6:30 -EXPECTED NOMINAL TYPE - fuzz_crash_032.md:8:26:8:37 +UNDECLARED TYPE - fuzz_crash_032.md:4:25:4:30 +EXPECTED NOMINAL TYPE - fuzz_crash_032.md:6:26:6:37 INVALID PATTERN - :0:0:0:0 -UNDECLARED TYPE - fuzz_crash_032.md:10:3:10:4 -EXPECTED NOMINAL TYPE - fuzz_crash_032.md:10:13:10:24 -EXPOSED BUT NOT DEFINED - fuzz_crash_032.md:1:13:1:14 -EXPOSED BUT NOT DEFINED - fuzz_crash_032.md:1:9:1:12 +UNDECLARED TYPE - fuzz_crash_032.md:8:3:8:4 +EXPECTED NOMINAL TYPE - fuzz_crash_032.md:8:13:8:24 # PROBLEMS **PARSE ERROR** A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**fuzz_crash_032.md:3:24:3:25:** +**fuzz_crash_032.md:1:24:1:25:** ```roc LocalStatus :lue => Loc= [Pending, Complete] ``` @@ -52,7 +48,7 @@ LocalStatus :lue => Loc= [Pending, Complete] A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**fuzz_crash_032.md:3:26:3:27:** +**fuzz_crash_032.md:1:26:1:27:** ```roc LocalStatus :lue => Loc= [Pending, Complete] ``` @@ -75,7 +71,7 @@ Other valid examples: `Result(a, Str)` `Maybe(List(U64))` -**fuzz_crash_032.md:3:34:3:35:** +**fuzz_crash_032.md:1:34:1:35:** ```roc LocalStatus :lue => Loc= [Pending, Complete] ``` @@ -98,7 +94,7 @@ Other valid examples: `Result(a, Str)` `Maybe(List(U64))` -**fuzz_crash_032.md:3:44:3:45:** +**fuzz_crash_032.md:1:44:1:45:** ```roc LocalStatus :lue => Loc= [Pending, Complete] ``` @@ -109,7 +105,7 @@ LocalStatus :lue => Loc= [Pending, Complete] Import statements must appear at the top level of a module. Move this import to the top of the file, after the module header but before any definitions. -**fuzz_crash_032.md:6:18:6:24:** +**fuzz_crash_032.md:4:18:4:24:** ```roc olor = |color| { import Color.RGB ``` @@ -120,7 +116,7 @@ olor = |color| { import Color.RGB The token **-** is not expected in a pattern. Patterns can contain identifiers, literals, lists, records, or tags. -**fuzz_crash_032.md:9:21:9:22:** +**fuzz_crash_032.md:7:21:7:22:** ```roc Green => LocalStatus-Complete ``` @@ -131,7 +127,7 @@ Green => LocalStatus-Complete A parsing error occurred: `match_branch_missing_arrow` This is an unexpected parsing error. Please check your syntax. -**fuzz_crash_032.md:9:22:9:22:** +**fuzz_crash_032.md:7:22:7:22:** ```roc Green => LocalStatus-Complete ``` @@ -144,7 +140,7 @@ The type variable _lue_ is not declared in this scope. Type variables must be introduced in a type annotation before they can be used. This type variable is referenced here: -**fuzz_crash_032.md:3:14:3:17:** +**fuzz_crash_032.md:1:14:1:17:** ```roc LocalStatus :lue => Loc= [Pending, Complete] ``` @@ -155,7 +151,7 @@ LocalStatus :lue => Loc= [Pending, Complete] The type _Loc_ is not declared in this scope. This type is referenced here: -**fuzz_crash_032.md:3:21:3:24:** +**fuzz_crash_032.md:1:21:1:24:** ```roc LocalStatus :lue => Loc= [Pending, Complete] ``` @@ -171,7 +167,7 @@ This error doesn't have a proper diagnostic report yet. Let us know if you want The type _Color_ is not declared in this scope. This type is referenced here: -**fuzz_crash_032.md:6:25:6:30:** +**fuzz_crash_032.md:4:25:4:30:** ```roc olor = |color| { import Color.RGB ``` @@ -182,7 +178,7 @@ olor = |color| { import Color.RGB You are using the type _LocalStatus_ like a nominal type, but it is an alias. This type is referenced here: -**fuzz_crash_032.md:8:26:8:37:** +**fuzz_crash_032.md:6:26:6:37:** ```roc match color { RGB => LocalStatus.Pending ``` @@ -198,7 +194,7 @@ This pattern contains invalid syntax or uses unsupported features. The type _B_ is not declared in this scope. This type is referenced here: -**fuzz_crash_032.md:10:3:10:4:** +**fuzz_crash_032.md:8:3:8:4:** ```roc B.Blue => LocalStatus.Pending ``` @@ -209,7 +205,7 @@ This type is referenced here: You are using the type _LocalStatus_ like a nominal type, but it is an alias. This type is referenced here: -**fuzz_crash_032.md:10:13:10:24:** +**fuzz_crash_032.md:8:13:8:24:** ```roc B.Blue => LocalStatus.Pending ``` @@ -218,92 +214,64 @@ This type is referenced here: **Hint:** You can declare this type with `:=` to make it nominal. -**EXPOSED BUT NOT DEFINED** -The module header says that `r` is exposed, but it is not defined anywhere in this module. - -**fuzz_crash_032.md:1:13:1:14:** -```roc -module [tus,r] -``` - ^ -You can fix this by either defining `r` in this module, or by removing it from the list of exposed values. - -**EXPOSED BUT NOT DEFINED** -The module header says that `tus` is exposed, but it is not defined anywhere in this module. - -**fuzz_crash_032.md:1:9:1:12:** -```roc -module [tus,r] -``` - ^^^ -You can fix this by either defining `tus` in this module, or by removing it from the list of exposed values. - # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:12),Comma(1:12-1:13),LowerIdent(1:13-1:14),CloseSquare(1:14-1:15), -UpperIdent(3:1-3:12),OpColon(3:13-3:14),LowerIdent(3:14-3:17),OpFatArrow(3:18-3:20),UpperIdent(3:21-3:24),OpAssign(3:24-3:25),OpenSquare(3:26-3:27),UpperIdent(3:27-3:34),Comma(3:34-3:35),UpperIdent(3:36-3:44),CloseSquare(3:44-3:45), -LowerIdent(5:1-5:5),OpColon(5:6-5:7),Underscore(5:8-5:9),OpArrow(5:10-5:12),LowerIdent(5:13-5:16), -LowerIdent(6:1-6:5),OpAssign(6:6-6:7),OpBar(6:8-6:9),LowerIdent(6:9-6:14),OpBar(6:14-6:15),OpenCurly(6:16-6:17),KwImport(6:18-6:24),UpperIdent(6:25-6:30),NoSpaceDotUpperIdent(6:30-6:34), -KwMatch(8:5-8:10),LowerIdent(8:11-8:16),OpenCurly(8:17-8:18),UpperIdent(8:19-8:22),OpFatArrow(8:23-8:25),UpperIdent(8:26-8:37),NoSpaceDotUpperIdent(8:37-8:45), -UpperIdent(9:1-9:6),OpFatArrow(9:7-9:9),UpperIdent(9:10-9:21),OpUnaryMinus(9:21-9:22),UpperIdent(9:22-9:30), -UpperIdent(10:3-10:4),NoSpaceDotUpperIdent(10:4-10:9),OpFatArrow(10:10-10:12),UpperIdent(10:13-10:24),NoSpaceDotUpperIdent(10:24-10:32), -CloseCurly(11:5-11:6), -CloseCurly(12:1-12:2), -EndOfFile(13:1-13:1), +UpperIdent(1:1-1:12),OpColon(1:13-1:14),LowerIdent(1:14-1:17),OpFatArrow(1:18-1:20),UpperIdent(1:21-1:24),OpAssign(1:24-1:25),OpenSquare(1:26-1:27),UpperIdent(1:27-1:34),Comma(1:34-1:35),UpperIdent(1:36-1:44),CloseSquare(1:44-1:45), +LowerIdent(3:1-3:5),OpColon(3:6-3:7),Underscore(3:8-3:9),OpArrow(3:10-3:12),LowerIdent(3:13-3:16), +LowerIdent(4:1-4:5),OpAssign(4:6-4:7),OpBar(4:8-4:9),LowerIdent(4:9-4:14),OpBar(4:14-4:15),OpenCurly(4:16-4:17),KwImport(4:18-4:24),UpperIdent(4:25-4:30),NoSpaceDotUpperIdent(4:30-4:34), +KwMatch(6:5-6:10),LowerIdent(6:11-6:16),OpenCurly(6:17-6:18),UpperIdent(6:19-6:22),OpFatArrow(6:23-6:25),UpperIdent(6:26-6:37),NoSpaceDotUpperIdent(6:37-6:45), +UpperIdent(7:1-7:6),OpFatArrow(7:7-7:9),UpperIdent(7:10-7:21),OpUnaryMinus(7:21-7:22),UpperIdent(7:22-7:30), +UpperIdent(8:3-8:4),NoSpaceDotUpperIdent(8:4-8:9),OpFatArrow(8:10-8:12),UpperIdent(8:13-8:24),NoSpaceDotUpperIdent(8:24-8:32), +CloseCurly(9:5-9:6), +CloseCurly(10:1-10:2), +EndOfFile(11:1-11:1), ~~~ # PARSE ~~~clojure -(file @1.1-12.2 - (module @1.1-1.15 - (exposes @1.8-1.15 - (exposed-lower-ident @1.9-1.12 - (text "tus")) - (exposed-lower-ident @1.13-1.14 - (text "r")))) +(file @1.1-10.2 + (type-module @1.1-1.12) (statements - (s-type-decl @3.1-3.24 - (header @3.1-3.12 (name "LocalStatus") + (s-type-decl @1.1-1.24 + (header @1.1-1.12 (name "LocalStatus") (args)) - (ty-fn @3.14-3.24 - (ty-var @3.14-3.17 (raw "lue")) - (ty @3.21-3.24 (name "Loc")))) - (s-malformed @3.24-3.25 (tag "statement_unexpected_token")) - (s-malformed @3.26-3.27 (tag "statement_unexpected_token")) - (s-malformed @3.34-3.35 (tag "expected_colon_after_type_annotation")) - (s-malformed @3.44-3.45 (tag "expected_colon_after_type_annotation")) - (s-type-anno @5.1-5.16 (name "olor") - (ty-fn @5.8-5.16 + (ty-fn @1.14-1.24 + (ty-var @1.14-1.17 (raw "lue")) + (ty @1.21-1.24 (name "Loc")))) + (s-malformed @1.24-1.25 (tag "statement_unexpected_token")) + (s-malformed @1.26-1.27 (tag "statement_unexpected_token")) + (s-malformed @1.34-1.35 (tag "expected_colon_after_type_annotation")) + (s-malformed @1.44-1.45 (tag "expected_colon_after_type_annotation")) + (s-type-anno @3.1-3.16 (name "olor") + (ty-fn @3.8-3.16 (_) - (ty-var @5.13-5.16 (raw "tus")))) - (s-decl @6.1-12.2 - (p-ident @6.1-6.5 (raw "olor")) - (e-lambda @6.8-12.2 + (ty-var @3.13-3.16 (raw "tus")))) + (s-decl @4.1-10.2 + (p-ident @4.1-4.5 (raw "olor")) + (e-lambda @4.8-10.2 (args - (p-ident @6.9-6.14 (raw "color"))) - (e-block @6.16-12.2 + (p-ident @4.9-4.14 (raw "color"))) + (e-block @4.16-10.2 (statements - (s-malformed @6.18-6.24 (tag "import_must_be_top_level")) - (e-tag @6.25-6.34 (raw "Color.RGB")) + (s-malformed @4.18-4.24 (tag "import_must_be_top_level")) + (e-tag @4.25-4.34 (raw "Color.RGB")) (e-match - (e-ident @8.11-8.16 (raw "color")) + (e-ident @6.11-6.16 (raw "color")) (branches - (branch @8.19-8.45 - (p-tag @8.19-8.22 (raw "RGB")) - (e-tag @8.26-8.45 (raw "LocalStatus.Pending"))) - (branch @9.1-9.21 - (p-tag @9.1-9.6 (raw "Green")) - (e-tag @9.10-9.21 (raw "LocalStatus"))) - (branch @9.21-9.30 - (p-malformed @9.21-9.22 (tag "pattern_unexpected_token")) - (e-tag @9.22-9.30 (raw "Complete"))) - (branch @10.3-10.32 - (p-tag @10.3-10.9 (raw ".Blue")) - (e-tag @10.13-10.32 (raw "LocalStatus.Pending"))))))))))) + (branch @6.19-6.45 + (p-tag @6.19-6.22 (raw "RGB")) + (e-tag @6.26-6.45 (raw "LocalStatus.Pending"))) + (branch @7.1-7.21 + (p-tag @7.1-7.6 (raw "Green")) + (e-tag @7.10-7.21 (raw "LocalStatus"))) + (branch @7.21-7.30 + (p-malformed @7.21-7.22 (tag "pattern_unexpected_token")) + (e-tag @7.22-7.30 (raw "Complete"))) + (branch @8.3-8.32 + (p-tag @8.3-8.9 (raw ".Blue")) + (e-tag @8.13-8.32 (raw "LocalStatus.Pending"))))))))))) ~~~ # FORMATTED ~~~roc -module [tus, r] - LocalStatus : lue => Loc @@ -323,63 +291,63 @@ olor = |color| { ~~~clojure (can-ir (d-let - (p-assign @6.1-6.5 (ident "olor")) - (e-lambda @6.8-12.2 + (p-assign @4.1-4.5 (ident "olor")) + (e-lambda @4.8-10.2 (args - (p-assign @6.9-6.14 (ident "color"))) - (e-block @6.16-12.2 + (p-assign @4.9-4.14 (ident "color"))) + (e-block @4.16-10.2 (s-runtime-error (tag "not_implemented")) - (s-expr @6.25-6.34 + (s-expr @4.25-4.34 (e-runtime-error (tag "undeclared_type"))) - (e-match @8.5-11.6 - (match @8.5-11.6 + (e-match @6.5-9.6 + (match @6.5-9.6 (cond - (e-lookup-local @8.11-8.16 - (p-assign @6.9-6.14 (ident "color")))) + (e-lookup-local @6.11-6.16 + (p-assign @4.9-4.14 (ident "color")))) (branches (branch (patterns (pattern (degenerate false) - (p-applied-tag @8.19-8.22))) + (p-applied-tag @6.19-6.22))) (value (e-runtime-error (tag "type_alias_but_needed_nominal")))) (branch (patterns (pattern (degenerate false) - (p-applied-tag @9.1-9.6))) + (p-applied-tag @7.1-7.6))) (value - (e-tag @9.10-9.21 (name "LocalStatus")))) + (e-tag @7.10-7.21 (name "LocalStatus")))) (branch (patterns (pattern (degenerate false) - (p-runtime-error @9.21-9.22 (tag "pattern_not_canonicalized")))) + (p-runtime-error @7.21-7.22 (tag "pattern_not_canonicalized")))) (value - (e-tag @9.22-9.30 (name "Complete")))) + (e-tag @7.22-7.30 (name "Complete")))) (branch (patterns (pattern (degenerate false) - (p-runtime-error @10.3-10.4 (tag "undeclared_type")))) + (p-runtime-error @8.3-8.4 (tag "undeclared_type")))) (value (e-runtime-error (tag "type_alias_but_needed_nominal"))))))))) - (annotation @6.1-6.5 + (annotation @4.1-4.5 (declared-type - (ty-fn @5.8-5.16 (effectful false) + (ty-fn @3.8-3.16 (effectful false) (ty-underscore @1.1-1.1) - (ty-var @5.13-5.16 (name "tus")))))) - (s-alias-decl @3.1-3.24 - (ty-header @3.1-3.12 (name "LocalStatus")) - (ty-fn @3.14-3.24 (effectful true) - (ty-malformed @3.14-3.17) - (ty @3.21-3.24 (name "Loc"))))) + (ty-rigid-var @3.13-3.16 (name "tus")))))) + (s-alias-decl @1.1-1.24 + (ty-header @1.1-1.12 (name "LocalStatus")) + (ty-fn @1.14-1.24 (effectful true) + (ty-malformed @1.14-1.17) + (ty-malformed @1.21-1.24)))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @6.1-6.5 (type "Error -> Error"))) + (patt @4.1-4.5 (type "_arg -> Error"))) (type_decls - (alias @3.1-3.24 (type "LocalStatus") - (ty-header @3.1-3.12 (name "LocalStatus")))) + (alias @1.1-1.24 (type "LocalStatus") + (ty-header @1.1-1.12 (name "LocalStatus")))) (expressions - (expr @6.8-12.2 (type "Error -> Error")))) + (expr @4.8-10.2 (type "_arg -> Error")))) ~~~ diff --git a/test/snapshots/fuzz_crash/fuzz_crash_034.md b/test/snapshots/fuzz_crash/fuzz_crash_034.md index 1a42fa006b..df80a78d6a 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_034.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_034.md @@ -1,55 +1,29 @@ # META ~~~ini description=fuzz crash -type=file +type=snippet ~~~ # SOURCE ~~~roc -module[]0 f + ~~~ # EXPECTED -PARSE ERROR - fuzz_crash_034.md:1:9:1:10 -PARSE ERROR - fuzz_crash_034.md:1:11:1:12 +NIL # PROBLEMS -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_034.md:1:9:1:10:** -```roc -module[]0 f -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_034.md:1:11:1:12:** -```roc -module[]0 f -``` - ^ - - +NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:7-1:8),CloseSquare(1:8-1:9),Int(1:9-1:10),LowerIdent(1:11-1:12), EndOfFile(2:1-2:1), ~~~ # PARSE ~~~clojure -(file @1.1-1.12 - (module @1.1-1.9 - (exposes @1.7-1.9)) - (statements - (s-malformed @1.9-1.10 (tag "statement_unexpected_token")) - (s-malformed @1.11-1.12 (tag "statement_unexpected_token")))) +(file @2.1-2.1 + (type-module @2.1-2.1) + (statements)) ~~~ # FORMATTED ~~~roc -module [] +NO CHANGE ~~~ # CANONICALIZE ~~~clojure diff --git a/test/snapshots/fuzz_crash/fuzz_crash_035.md b/test/snapshots/fuzz_crash/fuzz_crash_035.md index 6e7bc042f9..8150c05e3f 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_035.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_035.md @@ -1,43 +1,29 @@ # META ~~~ini description=fuzz crash -type=file +type=snippet ~~~ # SOURCE ~~~roc -module[]{ ~~~ # EXPECTED -PARSE ERROR - fuzz_crash_035.md:1:9:1:10 +NIL # PROBLEMS -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_035.md:1:9:1:10:** -```roc -module[]{ -``` - ^ - - +NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:7-1:8),CloseSquare(1:8-1:9),OpenCurly(1:9-1:10), -EndOfFile(3:1-3:1), +EndOfFile(2:1-2:1), ~~~ # PARSE ~~~clojure -(file @1.1-1.10 - (module @1.1-1.9 - (exposes @1.7-1.9)) - (statements - (s-malformed @1.9-1.10 (tag "statement_unexpected_token")))) +(file @2.1-2.1 + (type-module @2.1-2.1) + (statements)) ~~~ # FORMATTED ~~~roc -module [] + ~~~ # CANONICALIZE ~~~clojure diff --git a/test/snapshots/fuzz_crash/fuzz_crash_036.md b/test/snapshots/fuzz_crash/fuzz_crash_036.md index 4ed6f53f67..df80a78d6a 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_036.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_036.md @@ -1,68 +1,29 @@ # META ~~~ini description=fuzz crash -type=file +type=snippet ~~~ # SOURCE ~~~roc -module[]{B + ~~~ # EXPECTED -PARSE ERROR - fuzz_crash_036.md:1:9:1:10 -PARSE ERROR - fuzz_crash_036.md:2:1:2:1 +NIL # PROBLEMS -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_036.md:1:9:1:10:** -```roc -module[]{B -``` - ^ - - -**PARSE ERROR** -Type applications require parentheses around their type arguments. - -I found a type followed by what looks like a type argument, but they need to be connected with parentheses. - -Instead of: - **List U8** - -Use: - **List(U8)** - -Other valid examples: - `Dict(Str, Num)` - `Result(a, Str)` - `Maybe(List(U64))` - -**fuzz_crash_036.md:2:1:2:1:** -```roc - -``` -^ - - +NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:7-1:8),CloseSquare(1:8-1:9),OpenCurly(1:9-1:10),UpperIdent(1:10-1:11), EndOfFile(2:1-2:1), ~~~ # PARSE ~~~clojure -(file @1.1-1.11 - (module @1.1-1.9 - (exposes @1.7-1.9)) - (statements - (s-malformed @1.9-1.10 (tag "statement_unexpected_token")) - (s-malformed @1.1-1.1 (tag "expected_colon_after_type_annotation")))) +(file @2.1-2.1 + (type-module @2.1-2.1) + (statements)) ~~~ # FORMATTED ~~~roc -module [] - +NO CHANGE ~~~ # CANONICALIZE ~~~clojure diff --git a/test/snapshots/fuzz_crash/fuzz_crash_037.md b/test/snapshots/fuzz_crash/fuzz_crash_037.md index 8d23a72d50..df80a78d6a 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_037.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_037.md @@ -1,88 +1,29 @@ # META ~~~ini description=fuzz crash -type=file +type=snippet ~~~ # SOURCE ~~~roc -module[]"\ + ~~~ # EXPECTED -INVALID ESCAPE SEQUENCE - :0:0:0:0 -UNCLOSED STRING - :0:0:0:0 -PARSE ERROR - fuzz_crash_037.md:1:9:1:10 -PARSE ERROR - fuzz_crash_037.md:1:10:1:11 -PARSE ERROR - fuzz_crash_037.md:1:11:1:11 +NIL # PROBLEMS -**INVALID ESCAPE SEQUENCE** -This escape sequence is not recognized. - -```roc -module[]"\ - -``` - - -**UNCLOSED STRING** -This string is missing a closing quote. - -```roc -module[]"\ -``` - ^^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_037.md:1:9:1:10:** -```roc -module[]"\ -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_037.md:1:10:1:11:** -```roc -module[]"\ -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_037.md:1:11:1:11:** -```roc -module[]"\ -``` - ^ - - +NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:7-1:8),CloseSquare(1:8-1:9),StringStart(1:9-1:10),MalformedStringPart(1:10-1:11),StringEnd(1:11-1:11), EndOfFile(2:1-2:1), ~~~ # PARSE ~~~clojure -(file @1.1-1.11 - (module @1.1-1.9 - (exposes @1.7-1.9)) - (statements - (s-malformed @1.9-1.10 (tag "statement_unexpected_token")) - (s-malformed @1.10-1.11 (tag "statement_unexpected_token")) - (s-malformed @1.11-1.11 (tag "statement_unexpected_token")))) +(file @2.1-2.1 + (type-module @2.1-2.1) + (statements)) ~~~ # FORMATTED ~~~roc -module [] +NO CHANGE ~~~ # CANONICALIZE ~~~clojure diff --git a/test/snapshots/fuzz_crash/fuzz_crash_038.md b/test/snapshots/fuzz_crash/fuzz_crash_038.md index 7709218b7d..4ad8ce0825 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_038.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_038.md @@ -8,16 +8,13 @@ type=file *import B as ~~~ # EXPECTED -MISSING HEADER - fuzz_crash_038.md:1:1:1:2 +PARSE ERROR - fuzz_crash_038.md:1:1:1:2 PARSE ERROR - fuzz_crash_038.md:1:2:1:8 +MISSING MAIN! FUNCTION - fuzz_crash_038.md:1:1:1:13 # PROBLEMS -**MISSING HEADER** -Roc files must start with a module header. - -For example: - module [main] -or for an app: - app [main!] { pf: platform "../basic-cli/platform.roc" } +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. **fuzz_crash_038.md:1:1:1:2:** ```roc @@ -37,6 +34,20 @@ This is an unexpected parsing error. Please check your syntax. ^^^^^^ +**MISSING MAIN! FUNCTION** +Default app modules must have a `main!` function. + +No `main!` function was found. + +Add a main! function like: +`main! = |arg| { ... }` +**fuzz_crash_038.md:1:1:1:13:** +```roc +*import B as +``` +^^^^^^^^^^^^ + + # TOKENS ~~~zig OpStar(1:1-1:2),KwImport(1:2-1:8),UpperIdent(1:9-1:10),KwAs(1:11-1:13), @@ -45,8 +56,9 @@ EndOfFile(2:1-2:1), # PARSE ~~~clojure (file @1.1-1.13 - (malformed-header @1.1-1.2 (tag "missing_header")) + (type-module @1.1-1.2) (statements + (s-malformed @1.1-1.2 (tag "statement_unexpected_token")) (s-malformed @1.2-1.13 (tag "expected_upper_name_after_import_as")))) ~~~ # FORMATTED diff --git a/test/snapshots/fuzz_crash/fuzz_crash_042.md b/test/snapshots/fuzz_crash/fuzz_crash_042.md index c66aeab519..637e7b9736 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_042.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_042.md @@ -1,78 +1,76 @@ # META ~~~ini description=fuzz crash -type=file +type=snippet ~~~ # SOURCE ~~~roc -module[]import u.R}g:r->R.a.E +import u.R}g:r->R.a.E ~~~ # EXPECTED -PARSE ERROR - fuzz_crash_042.md:1:19:1:20 -MODULE NOT FOUND - fuzz_crash_042.md:1:9:1:19 -MODULE NOT IMPORTED - fuzz_crash_042.md:1:25:1:30 +PARSE ERROR - fuzz_crash_042.md:1:11:1:12 +MODULE NOT FOUND - fuzz_crash_042.md:1:1:1:11 +MODULE NOT IMPORTED - fuzz_crash_042.md:1:17:1:22 # PROBLEMS **PARSE ERROR** A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**fuzz_crash_042.md:1:19:1:20:** +**fuzz_crash_042.md:1:11:1:12:** ```roc -module[]import u.R}g:r->R.a.E +import u.R}g:r->R.a.E ``` - ^ + ^ **MODULE NOT FOUND** The module `u.R` was not found in this Roc project. You're attempting to use this module here: -**fuzz_crash_042.md:1:9:1:19:** +**fuzz_crash_042.md:1:1:1:11:** ```roc -module[]import u.R}g:r->R.a.E +import u.R}g:r->R.a.E ``` - ^^^^^^^^^^ +^^^^^^^^^^ **MODULE NOT IMPORTED** -There is no module with the name `module[]import u.R}g:r->R.a` imported into this Roc file. +There is no module with the name `R.a` imported into this Roc file. You're attempting to use this module here: -**fuzz_crash_042.md:1:25:1:30:** +**fuzz_crash_042.md:1:17:1:22:** ```roc -module[]import u.R}g:r->R.a.E +import u.R}g:r->R.a.E ``` - ^^^^^ + ^^^^^ # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:7-1:8),CloseSquare(1:8-1:9),KwImport(1:9-1:15),LowerIdent(1:16-1:17),NoSpaceDotUpperIdent(1:17-1:19),CloseCurly(1:19-1:20),LowerIdent(1:20-1:21),OpColon(1:21-1:22),LowerIdent(1:22-1:23),OpArrow(1:23-1:25),UpperIdent(1:25-1:26),NoSpaceDotLowerIdent(1:26-1:28),NoSpaceDotUpperIdent(1:28-1:30), +KwImport(1:1-1:7),LowerIdent(1:8-1:9),NoSpaceDotUpperIdent(1:9-1:11),CloseCurly(1:11-1:12),LowerIdent(1:12-1:13),OpColon(1:13-1:14),LowerIdent(1:14-1:15),OpArrow(1:15-1:17),UpperIdent(1:17-1:18),NoSpaceDotLowerIdent(1:18-1:20),NoSpaceDotUpperIdent(1:20-1:22), EndOfFile(2:1-2:1), ~~~ # PARSE ~~~clojure -(file @1.1-1.30 - (module @1.1-1.9 - (exposes @1.7-1.9)) +(file @1.1-1.22 + (type-module @1.1-1.7) (statements - (s-import @1.9-1.19 (raw "u.R")) - (s-malformed @1.19-1.20 (tag "statement_unexpected_token")) - (s-type-anno @1.20-1.30 (name "g") - (ty-fn @1.22-1.30 - (ty-var @1.22-1.23 (raw "r")) - (ty @1.25-1.30 (name "R.a.E")))))) + (s-import @1.1-1.11 (raw "u.R")) + (s-malformed @1.11-1.12 (tag "statement_unexpected_token")) + (s-type-anno @1.12-1.22 (name "g") + (ty-fn @1.14-1.22 + (ty-var @1.14-1.15 (raw "r")) + (ty @1.17-1.22 (name "R.a.E")))))) ~~~ # FORMATTED ~~~roc -module [] import u.R g : r -> R.a.E ~~~ # CANONICALIZE ~~~clojure (can-ir - (s-import @1.9-1.19 (module "u.R") (qualifier "u") + (s-import @1.1-1.11 (module "u.R") (qualifier "u") (exposes))) ~~~ # TYPES diff --git a/test/snapshots/fuzz_crash/fuzz_crash_047.md b/test/snapshots/fuzz_crash/fuzz_crash_047.md index 3fefbc058c..9c76fc643c 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_047.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_047.md @@ -1,12 +1,10 @@ # META ~~~ini description=fuzz crash -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [person, updated] - person = { name: "Alice", age: 30 } updated = { ..person, age: 31 } @@ -17,42 +15,34 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:15),Comma(1:15-1:16),LowerIdent(1:17-1:24),CloseSquare(1:24-1:25), -LowerIdent(3:1-3:7),OpAssign(3:8-3:9),OpenCurly(3:10-3:11),LowerIdent(3:12-3:16),OpColon(3:16-3:17),StringStart(3:18-3:19),StringPart(3:19-3:24),StringEnd(3:24-3:25),Comma(3:25-3:26),LowerIdent(3:27-3:30),OpColon(3:30-3:31),Int(3:32-3:34),CloseCurly(3:35-3:36), -LowerIdent(4:1-4:8),OpAssign(4:9-4:10),OpenCurly(4:11-4:12),DoubleDot(4:13-4:15),LowerIdent(4:15-4:21),Comma(4:21-4:22), -LowerIdent(5:2-5:5),OpColon(5:5-5:6),Int(5:7-5:9),CloseCurly(5:10-5:11), -EndOfFile(6:1-6:1), +LowerIdent(1:1-1:7),OpAssign(1:8-1:9),OpenCurly(1:10-1:11),LowerIdent(1:12-1:16),OpColon(1:16-1:17),StringStart(1:18-1:19),StringPart(1:19-1:24),StringEnd(1:24-1:25),Comma(1:25-1:26),LowerIdent(1:27-1:30),OpColon(1:30-1:31),Int(1:32-1:34),CloseCurly(1:35-1:36), +LowerIdent(2:1-2:8),OpAssign(2:9-2:10),OpenCurly(2:11-2:12),DoubleDot(2:13-2:15),LowerIdent(2:15-2:21),Comma(2:21-2:22), +LowerIdent(3:2-3:5),OpColon(3:5-3:6),Int(3:7-3:9),CloseCurly(3:10-3:11), +EndOfFile(4:1-4:1), ~~~ # PARSE ~~~clojure -(file @1.1-5.11 - (module @1.1-1.25 - (exposes @1.8-1.25 - (exposed-lower-ident @1.9-1.15 - (text "person")) - (exposed-lower-ident @1.17-1.24 - (text "updated")))) +(file @1.1-3.11 + (type-module @1.1-1.7) (statements - (s-decl @3.1-3.36 - (p-ident @3.1-3.7 (raw "person")) - (e-record @3.10-3.36 + (s-decl @1.1-1.36 + (p-ident @1.1-1.7 (raw "person")) + (e-record @1.10-1.36 (field (field "name") - (e-string @3.18-3.25 - (e-string-part @3.19-3.24 (raw "Alice")))) + (e-string @1.18-1.25 + (e-string-part @1.19-1.24 (raw "Alice")))) (field (field "age") - (e-int @3.32-3.34 (raw "30"))))) - (s-decl @4.1-5.11 - (p-ident @4.1-4.8 (raw "updated")) - (e-record @4.11-5.11 + (e-int @1.32-1.34 (raw "30"))))) + (s-decl @2.1-3.11 + (p-ident @2.1-2.8 (raw "updated")) + (e-record @2.11-3.11 (ext - (e-ident @4.15-4.21 (raw "person"))) + (e-ident @2.15-2.21 (raw "person"))) (field (field "age") - (e-int @5.7-5.9 (raw "31"))))))) + (e-int @3.7-3.9 (raw "31"))))))) ~~~ # FORMATTED ~~~roc -module [person, updated] - person = { name: "Alice", age: 30 } updated = { ..person, @@ -63,31 +53,31 @@ updated = { ~~~clojure (can-ir (d-let - (p-assign @3.1-3.7 (ident "person")) - (e-record @3.10-3.36 + (p-assign @1.1-1.7 (ident "person")) + (e-record @1.10-1.36 (fields (field (name "name") - (e-string @3.18-3.25 - (e-literal @3.19-3.24 (string "Alice")))) + (e-string @1.18-1.25 + (e-literal @1.19-1.24 (string "Alice")))) (field (name "age") - (e-int @3.32-3.34 (value "30")))))) + (e-num @1.32-1.34 (value "30")))))) (d-let - (p-assign @4.1-4.8 (ident "updated")) - (e-record @4.11-5.11 + (p-assign @2.1-2.8 (ident "updated")) + (e-record @2.11-3.11 (ext - (e-lookup-local @4.15-4.21 - (p-assign @3.1-3.7 (ident "person")))) + (e-lookup-local @2.15-2.21 + (p-assign @1.1-1.7 (ident "person")))) (fields (field (name "age") - (e-int @5.7-5.9 (value "31"))))))) + (e-num @3.7-3.9 (value "31"))))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @3.1-3.7 (type "{ name: Str, age: Num(_size) }")) - (patt @4.1-4.8 (type "{ age: Num(_size) }"))) + (patt @1.1-1.7 (type "{ age: Num(_size), name: Str }")) + (patt @2.1-2.8 (type "{ age: Num(_size), { age: Num(_size2), name: Str } }"))) (expressions - (expr @3.10-3.36 (type "{ name: Str, age: Num(_size) }")) - (expr @4.11-5.11 (type "{ age: Num(_size) }")))) + (expr @1.10-1.36 (type "{ age: Num(_size), name: Str }")) + (expr @2.11-3.11 (type "{ age: Num(_size), { age: Num(_size2), name: Str } }")))) ~~~ diff --git a/test/snapshots/fuzz_crash/fuzz_crash_048.md b/test/snapshots/fuzz_crash/fuzz_crash_048.md index 92fd10912a..f44911ce2d 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_048.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_048.md @@ -1,12 +1,10 @@ # META ~~~ini description=fuzz crash -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - foo : U64 bar : Thing(a, b, _) biz : (a, b, c) @@ -17,9 +15,9 @@ tag_tuple : Value((a, b, c)) ~~~ # EXPECTED ASCII CONTROL CHARACTER - :0:0:0:0 -UNDECLARED TYPE - fuzz_crash_048.md:4:7:4:12 -UNDECLARED TYPE - fuzz_crash_048.md:8:14:8:20 -UNDECLARED TYPE - fuzz_crash_048.md:9:13:9:18 +UNDECLARED TYPE - fuzz_crash_048.md:2:7:2:12 +UNDECLARED TYPE - fuzz_crash_048.md:6:14:6:20 +UNDECLARED TYPE - fuzz_crash_048.md:7:13:7:18 # PROBLEMS **ASCII CONTROL CHARACTER** ASCII control characters are not allowed in Roc source code. @@ -30,7 +28,7 @@ ASCII control characters are not allowed in Roc source code. The type _Thing_ is not declared in this scope. This type is referenced here: -**fuzz_crash_048.md:4:7:4:12:** +**fuzz_crash_048.md:2:7:2:12:** ```roc bar : Thing(a, b, _) ``` @@ -41,7 +39,7 @@ bar : Thing(a, b, _) The type _String_ is not declared in this scope. This type is referenced here: -**fuzz_crash_048.md:8:14:8:20:** +**fuzz_crash_048.md:6:14:6:20:** ```roc main! : List(String) -> Result({}, _) ``` @@ -52,7 +50,7 @@ main! : List(String) -> Result({}, _) The type _Value_ is not declared in this scope. This type is referenced here: -**fuzz_crash_048.md:9:13:9:18:** +**fuzz_crash_048.md:7:13:7:18:** ```roc tag_tuple : Value((a, b, c)) ``` @@ -61,61 +59,57 @@ tag_tuple : Value((a, b, c)) # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -LowerIdent(3:1-3:4),OpColon(3:5-3:6),UpperIdent(3:7-3:10), -LowerIdent(4:1-4:4),OpColon(4:5-4:6),UpperIdent(4:7-4:12),NoSpaceOpenRound(4:12-4:13),LowerIdent(4:13-4:14),Comma(4:14-4:15),LowerIdent(4:16-4:17),Comma(4:17-4:18),Underscore(4:19-4:20),CloseRound(4:20-4:21), -LowerIdent(5:1-5:4),OpColon(5:5-5:6),OpenRound(5:7-5:8),LowerIdent(5:8-5:9),Comma(5:9-5:10),LowerIdent(5:11-5:12),Comma(5:12-5:13),LowerIdent(5:14-5:15),CloseRound(5:15-5:16), -LowerIdent(6:1-6:8),OpColon(6:9-6:10),OpenRound(6:11-6:12), -UpperIdent(7:1-7:3),Comma(7:3-7:4),UpperIdent(7:5-7:8),OpArrow(7:9-7:11),UpperIdent(7:12-7:15),CloseRound(7:15-7:16), -LowerIdent(8:1-8:6),OpColon(8:7-8:8),UpperIdent(8:9-8:13),NoSpaceOpenRound(8:13-8:14),UpperIdent(8:14-8:20),CloseRound(8:20-8:21),OpArrow(8:22-8:24),UpperIdent(8:25-8:31),NoSpaceOpenRound(8:31-8:32),OpenCurly(8:32-8:33),CloseCurly(8:33-8:34),Comma(8:34-8:35),Underscore(8:36-8:37),CloseRound(8:37-8:38), -LowerIdent(9:1-9:10),OpColon(9:11-9:12),UpperIdent(9:13-9:18),NoSpaceOpenRound(9:18-9:19),NoSpaceOpenRound(9:19-9:20),LowerIdent(9:20-9:21),Comma(9:21-9:22),LowerIdent(9:23-9:24),Comma(9:24-9:25),LowerIdent(9:26-9:27),CloseRound(9:27-9:28),CloseRound(9:28-9:29), -EndOfFile(10:1-10:1), +LowerIdent(1:1-1:4),OpColon(1:5-1:6),UpperIdent(1:7-1:10), +LowerIdent(2:1-2:4),OpColon(2:5-2:6),UpperIdent(2:7-2:12),NoSpaceOpenRound(2:12-2:13),LowerIdent(2:13-2:14),Comma(2:14-2:15),LowerIdent(2:16-2:17),Comma(2:17-2:18),Underscore(2:19-2:20),CloseRound(2:20-2:21), +LowerIdent(3:1-3:4),OpColon(3:5-3:6),OpenRound(3:7-3:8),LowerIdent(3:8-3:9),Comma(3:9-3:10),LowerIdent(3:11-3:12),Comma(3:12-3:13),LowerIdent(3:14-3:15),CloseRound(3:15-3:16), +LowerIdent(4:1-4:8),OpColon(4:9-4:10),OpenRound(4:11-4:12), +UpperIdent(5:1-5:3),Comma(5:3-5:4),UpperIdent(5:5-5:8),OpArrow(5:9-5:11),UpperIdent(5:12-5:15),CloseRound(5:15-5:16), +LowerIdent(6:1-6:6),OpColon(6:7-6:8),UpperIdent(6:9-6:13),NoSpaceOpenRound(6:13-6:14),UpperIdent(6:14-6:20),CloseRound(6:20-6:21),OpArrow(6:22-6:24),UpperIdent(6:25-6:31),NoSpaceOpenRound(6:31-6:32),OpenCurly(6:32-6:33),CloseCurly(6:33-6:34),Comma(6:34-6:35),Underscore(6:36-6:37),CloseRound(6:37-6:38), +LowerIdent(7:1-7:10),OpColon(7:11-7:12),UpperIdent(7:13-7:18),NoSpaceOpenRound(7:18-7:19),NoSpaceOpenRound(7:19-7:20),LowerIdent(7:20-7:21),Comma(7:21-7:22),LowerIdent(7:23-7:24),Comma(7:24-7:25),LowerIdent(7:26-7:27),CloseRound(7:27-7:28),CloseRound(7:28-7:29), +EndOfFile(8:1-8:1), ~~~ # PARSE ~~~clojure -(file @1.1-9.29 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-7.29 + (type-module @1.1-1.4) (statements - (s-type-anno @3.1-3.10 (name "foo") - (ty @3.7-3.10 (name "U64"))) - (s-type-anno @4.1-4.21 (name "bar") - (ty-apply @4.7-4.21 - (ty @4.7-4.12 (name "Thing")) - (ty-var @4.13-4.14 (raw "a")) - (ty-var @4.16-4.17 (raw "b")) + (s-type-anno @1.1-1.10 (name "foo") + (ty @1.7-1.10 (name "U64"))) + (s-type-anno @2.1-2.21 (name "bar") + (ty-apply @2.7-2.21 + (ty @2.7-2.12 (name "Thing")) + (ty-var @2.13-2.14 (raw "a")) + (ty-var @2.16-2.17 (raw "b")) (_))) - (s-type-anno @5.1-5.16 (name "biz") - (ty-tuple @5.7-5.16 - (ty-var @5.8-5.9 (raw "a")) - (ty-var @5.11-5.12 (raw "b")) - (ty-var @5.14-5.15 (raw "c")))) - (s-type-anno @6.1-7.16 (name "add_one") - (ty-fn @7.1-7.15 - (ty @7.1-7.3 (name "U8")) - (ty @7.5-7.8 (name "U16")) - (ty @7.12-7.15 (name "U32")))) - (s-type-anno @8.1-8.38 (name "main!") - (ty-fn @8.9-8.38 - (ty-apply @8.9-8.21 - (ty @8.9-8.13 (name "List")) - (ty @8.14-8.20 (name "String"))) - (ty-apply @8.25-8.38 - (ty @8.25-8.31 (name "Result")) - (ty-record @8.32-8.34) + (s-type-anno @3.1-3.16 (name "biz") + (ty-tuple @3.7-3.16 + (ty-var @3.8-3.9 (raw "a")) + (ty-var @3.11-3.12 (raw "b")) + (ty-var @3.14-3.15 (raw "c")))) + (s-type-anno @4.1-5.16 (name "add_one") + (ty-fn @5.1-5.15 + (ty @5.1-5.3 (name "U8")) + (ty @5.5-5.8 (name "U16")) + (ty @5.12-5.15 (name "U32")))) + (s-type-anno @6.1-6.38 (name "main!") + (ty-fn @6.9-6.38 + (ty-apply @6.9-6.21 + (ty @6.9-6.13 (name "List")) + (ty @6.14-6.20 (name "String"))) + (ty-apply @6.25-6.38 + (ty @6.25-6.31 (name "Result")) + (ty-record @6.32-6.34) (_)))) - (s-type-anno @9.1-9.29 (name "tag_tuple") - (ty-apply @9.13-9.29 - (ty @9.13-9.18 (name "Value")) - (ty-tuple @9.19-9.28 - (ty-var @9.20-9.21 (raw "a")) - (ty-var @9.23-9.24 (raw "b")) - (ty-var @9.26-9.27 (raw "c"))))))) + (s-type-anno @7.1-7.29 (name "tag_tuple") + (ty-apply @7.13-7.29 + (ty @7.13-7.18 (name "Value")) + (ty-tuple @7.19-7.28 + (ty-var @7.20-7.21 (raw "a")) + (ty-var @7.23-7.24 (raw "b")) + (ty-var @7.26-7.27 (raw "c"))))))) ~~~ # FORMATTED ~~~roc -module [] - foo : U64 bar : Thing(a, b, _) biz : (a, b, c) diff --git a/test/snapshots/fuzz_crash/fuzz_crash_049.md b/test/snapshots/fuzz_crash/fuzz_crash_049.md index bd2e6b6f28..3e9512d9bd 100644 Binary files a/test/snapshots/fuzz_crash/fuzz_crash_049.md and b/test/snapshots/fuzz_crash/fuzz_crash_049.md differ diff --git a/test/snapshots/fuzz_crash/fuzz_crash_050.md b/test/snapshots/fuzz_crash/fuzz_crash_050.md index e38e420f90..5f7246fbb9 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_050.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_050.md @@ -1,91 +1,49 @@ # META ~~~ini description=fuzz crash -type=file +type=snippet ~~~ # SOURCE ~~~roc -module[]_0={ ) ~~~ # EXPECTED -UNEXPECTED TOKEN IN EXPRESSION - fuzz_crash_050.md:2:1:2:2 -PARSE ERROR - fuzz_crash_050.md:4:1:4:1 -UNRECOGNIZED SYNTAX - fuzz_crash_050.md:2:1:2:2 +PARSE ERROR - fuzz_crash_050.md:1:1:1:2 # PROBLEMS -**UNEXPECTED TOKEN IN EXPRESSION** -The token **)** is not expected in an expression. -Expressions can be identifiers, literals, function calls, or operators. - -**fuzz_crash_050.md:2:1:2:2:** -```roc -) -``` -^ - - **PARSE ERROR** -A parsing error occurred: `expected_expr_close_curly` +A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**fuzz_crash_050.md:4:1:4:1:** -```roc - -``` -^ - - -**UNRECOGNIZED SYNTAX** -I don't recognize this syntax. - -**fuzz_crash_050.md:2:1:2:2:** +**fuzz_crash_050.md:1:1:1:2:** ```roc ) ``` ^ -This might be a syntax error, an unsupported language feature, or a typo. # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:7-1:8),CloseSquare(1:8-1:9),NamedUnderscore(1:9-1:11),OpAssign(1:11-1:12),OpenCurly(1:12-1:13), -CloseRound(2:1-2:2), -EndOfFile(4:1-4:1), +CloseRound(1:1-1:2), +EndOfFile(3:1-3:1), ~~~ # PARSE ~~~clojure -(file @1.1-2.2 - (module @1.1-1.9 - (exposes @1.7-1.9)) +(file @1.1-1.2 + (type-module @1.1-1.2) (statements - (s-decl @1.9-2.2 - (p-ident @1.9-1.11 (raw "_0")) - (e-block @1.12-2.2 - (statements - (e-malformed @2.1-2.2 (reason "expr_unexpected_token"))))))) + (s-malformed @1.1-1.2 (tag "statement_unexpected_token")))) ~~~ # FORMATTED ~~~roc -module [] -_0 = { - - -} ~~~ # CANONICALIZE ~~~clojure -(can-ir - (d-let - (p-assign @1.9-1.11 (ident "_0")) - (e-block @1.12-2.2 - (e-runtime-error (tag "expr_not_canonicalized"))))) +(can-ir (empty true)) ~~~ # TYPES ~~~clojure (inferred-types - (defs - (patt @1.9-1.11 (type "Error"))) - (expressions - (expr @1.12-2.2 (type "Error")))) + (defs) + (expressions)) ~~~ diff --git a/test/snapshots/fuzz_crash/fuzz_crash_052.md b/test/snapshots/fuzz_crash/fuzz_crash_052.md index 390abd8988..320b7bc5fb 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_052.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_052.md @@ -1,67 +1,59 @@ # META ~~~ini description=fuzz crash -type=file +type=snippet ~~~ # SOURCE ~~~roc -module[]import S 0 ~~~ # EXPECTED -PARSE ERROR - fuzz_crash_052.md:3:1:3:2 -MODULE NOT FOUND - fuzz_crash_052.md:1:9:2:2 +PARSE ERROR - fuzz_crash_052.md:2:1:2:2 # PROBLEMS **PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. +Type applications require parentheses around their type arguments. -**fuzz_crash_052.md:3:1:3:2:** +I found a type followed by what looks like a type argument, but they need to be connected with parentheses. + +Instead of: + **List U8** + +Use: + **List(U8)** + +Other valid examples: + `Dict(Str, Num)` + `Result(a, Str)` + `Maybe(List(U64))` + +**fuzz_crash_052.md:2:1:2:2:** ```roc 0 ``` ^ -**MODULE NOT FOUND** -The module `S` was not found in this Roc project. - -You're attempting to use this module here: -**fuzz_crash_052.md:1:9:2:2:** -```roc -module[]import -S -``` - - # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:7-1:8),CloseSquare(1:8-1:9),KwImport(1:9-1:15), -UpperIdent(2:1-2:2), -Int(3:1-3:2), -EndOfFile(4:1-4:1), +UpperIdent(1:1-1:2), +Int(2:1-2:2), +EndOfFile(3:1-3:1), ~~~ # PARSE ~~~clojure -(file @1.1-3.2 - (module @1.1-1.9 - (exposes @1.7-1.9)) +(file @1.1-2.2 + (type-module @1.1-1.2) (statements - (s-import @1.9-2.2 (raw "S")) - (s-malformed @3.1-3.2 (tag "statement_unexpected_token")))) + (s-malformed @2.1-2.2 (tag "expected_colon_after_type_annotation")))) ~~~ # FORMATTED ~~~roc -module [] -import - S + ~~~ # CANONICALIZE ~~~clojure -(can-ir - (s-import @1.9-2.2 (module "S") - (exposes))) +(can-ir (empty true)) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/fuzz_crash/fuzz_crash_055.md b/test/snapshots/fuzz_crash/fuzz_crash_055.md index f1c6ed3c51..39b9b094f5 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_055.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_055.md @@ -1,53 +1,108 @@ # META ~~~ini description=fuzz crash -type=file +type=snippet ~~~ # SOURCE ~~~roc -module[]r:a where module(a).h:s ~~~ # EXPECTED -NIL +PARSE ERROR - fuzz_crash_055.md:1:7:1:8 +PARSE ERROR - fuzz_crash_055.md:1:8:1:9 +PARSE ERROR - fuzz_crash_055.md:1:9:1:10 +PARSE ERROR - fuzz_crash_055.md:1:10:1:12 +PARSE ERROR - fuzz_crash_055.md:1:12:1:13 +PARSE ERROR - fuzz_crash_055.md:1:13:1:14 # PROBLEMS -NIL +**PARSE ERROR** +A parsing error occurred: `header_expected_open_square` +This is an unexpected parsing error. Please check your syntax. + +**fuzz_crash_055.md:1:7:1:8:** +```roc +module(a).h:s +``` + ^ + + +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**fuzz_crash_055.md:1:8:1:9:** +```roc +module(a).h:s +``` + ^ + + +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**fuzz_crash_055.md:1:9:1:10:** +```roc +module(a).h:s +``` + ^ + + +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**fuzz_crash_055.md:1:10:1:12:** +```roc +module(a).h:s +``` + ^^ + + +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**fuzz_crash_055.md:1:12:1:13:** +```roc +module(a).h:s +``` + ^ + + +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**fuzz_crash_055.md:1:13:1:14:** +```roc +module(a).h:s +``` + ^ + + # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:7-1:8),CloseSquare(1:8-1:9),LowerIdent(1:9-1:10),OpColon(1:10-1:11),LowerIdent(1:11-1:12),KwWhere(1:13-1:18), -KwModule(2:1-2:7),NoSpaceOpenRound(2:7-2:8),LowerIdent(2:8-2:9),CloseRound(2:9-2:10),NoSpaceDotLowerIdent(2:10-2:12),OpColon(2:12-2:13),LowerIdent(2:13-2:14), -EndOfFile(3:1-3:1), +KwModule(1:1-1:7),NoSpaceOpenRound(1:7-1:8),LowerIdent(1:8-1:9),CloseRound(1:9-1:10),NoSpaceDotLowerIdent(1:10-1:12),OpColon(1:12-1:13),LowerIdent(1:13-1:14), +EndOfFile(2:1-2:1), ~~~ # PARSE ~~~clojure -(file @1.1-2.14 - (module @1.1-1.9 - (exposes @1.7-1.9)) +(file @1.1-1.14 + (malformed-header @1.7-1.8 (tag "header_expected_open_square")) (statements - (s-type-anno @1.9-2.14 (name "r") - (ty-var @1.11-1.12 (raw "a")) - (where - (method @2.1-2.14 (module-of "a") (name "h") - (args) - (ty-var @2.13-2.14 (raw "s"))))))) + (s-malformed @1.8-1.9 (tag "statement_unexpected_token")) + (s-malformed @1.9-1.10 (tag "statement_unexpected_token")) + (s-malformed @1.10-1.12 (tag "statement_unexpected_token")) + (s-malformed @1.12-1.13 (tag "statement_unexpected_token")) + (s-malformed @1.13-1.14 (tag "statement_unexpected_token")))) ~~~ # FORMATTED ~~~roc -module [] -r : a - where - module(a).h : s ~~~ # CANONICALIZE ~~~clojure -(can-ir - (s-type-anno @1.9-2.14 (name "r") - (ty-var @1.11-1.12 (name "a")) - (where - (method @2.1-2.14 (module-of "a") (ident "h") - (args) - (ty-var @2.13-2.14 (name "s"))))) - (ext-decl @2.1-2.14 (ident "module(a).h") (kind "value"))) +(can-ir (empty true)) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/fuzz_crash/fuzz_crash_057.md b/test/snapshots/fuzz_crash/fuzz_crash_057.md index 47399b33a4..df80a78d6a 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_057.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_057.md @@ -1,67 +1,33 @@ # META ~~~ini description=fuzz crash -type=file +type=snippet ~~~ # SOURCE ~~~roc -module[]s:b->c where module(a).t:c,u:o... + ~~~ # EXPECTED -PARSE ERROR - fuzz_crash_057.md:1:39:1:42 +NIL # PROBLEMS -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_057.md:1:39:1:42:** -```roc -module[]s:b->c where module(a).t:c,u:o... -``` - ^^^ - - +NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:7-1:8),CloseSquare(1:8-1:9),LowerIdent(1:9-1:10),OpColon(1:10-1:11),LowerIdent(1:11-1:12),OpArrow(1:12-1:14),LowerIdent(1:14-1:15),KwWhere(1:16-1:21),KwModule(1:22-1:28),NoSpaceOpenRound(1:28-1:29),LowerIdent(1:29-1:30),CloseRound(1:30-1:31),NoSpaceDotLowerIdent(1:31-1:33),OpColon(1:33-1:34),LowerIdent(1:34-1:35),Comma(1:35-1:36),LowerIdent(1:36-1:37),OpColon(1:37-1:38),LowerIdent(1:38-1:39),TripleDot(1:39-1:42), EndOfFile(2:1-2:1), ~~~ # PARSE ~~~clojure -(file @1.1-1.42 - (module @1.1-1.9 - (exposes @1.7-1.9)) - (statements - (s-type-anno @1.9-1.36 (name "s") - (ty-fn @1.11-1.15 - (ty-var @1.11-1.12 (raw "b")) - (ty-var @1.14-1.15 (raw "c"))) - (where - (method @1.22-1.35 (module-of "a") (name "t") - (args) - (ty-var @1.34-1.35 (raw "c"))))) - (s-type-anno @1.36-1.39 (name "u") - (ty-var @1.38-1.39 (raw "o"))) - (s-malformed @1.39-1.42 (tag "statement_unexpected_token")))) +(file @2.1-2.1 + (type-module @2.1-2.1) + (statements)) ~~~ # FORMATTED ~~~roc -module [] -s : b -> c where module(a).t : c -u : o +NO CHANGE ~~~ # CANONICALIZE ~~~clojure -(can-ir - (s-type-anno @1.9-1.36 (name "s") - (ty-fn @1.11-1.15 (effectful false) - (ty-var @1.11-1.12 (name "b")) - (ty-var @1.14-1.15 (name "c"))) - (where - (method @1.22-1.35 (module-of "a") (ident "t") - (args) - (ty-var @1.34-1.35 (name "c"))))) - (ext-decl @1.22-1.35 (ident "module(a).t") (kind "value"))) +(can-ir (empty true)) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/fuzz_crash/fuzz_crash_060.md b/test/snapshots/fuzz_crash/fuzz_crash_060.md index 4657e1d88d..f20892057b 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_060.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_060.md @@ -1,29 +1,20 @@ # META ~~~ini description=fuzz crash -type=file +type=snippet ~~~ # SOURCE ~~~roc -module[]C:k||match 0{0|# 0" } ~~~ # EXPECTED UNCLOSED STRING - :0:0:0:0 -PARSE ERROR - fuzz_crash_060.md:1:12:1:13 -PARSE ERROR - fuzz_crash_060.md:1:13:1:14 -PARSE ERROR - fuzz_crash_060.md:1:14:1:19 -PARSE ERROR - fuzz_crash_060.md:1:20:1:21 -PARSE ERROR - fuzz_crash_060.md:1:21:1:22 -PARSE ERROR - fuzz_crash_060.md:1:22:1:23 -PARSE ERROR - fuzz_crash_060.md:1:23:1:24 +PARSE ERROR - fuzz_crash_060.md:1:1:1:2 +PARSE ERROR - fuzz_crash_060.md:1:2:1:3 +PARSE ERROR - fuzz_crash_060.md:1:3:1:3 +PARSE ERROR - fuzz_crash_060.md:1:3:1:3 PARSE ERROR - fuzz_crash_060.md:2:1:2:2 -PARSE ERROR - fuzz_crash_060.md:2:2:2:3 -PARSE ERROR - fuzz_crash_060.md:2:3:2:3 -PARSE ERROR - fuzz_crash_060.md:2:3:2:3 -PARSE ERROR - fuzz_crash_060.md:3:1:3:2 -UNDECLARED TYPE VARIABLE - fuzz_crash_060.md:1:11:1:12 # PROBLEMS **UNCLOSED STRING** This string is missing a closing quote. @@ -38,84 +29,7 @@ This string is missing a closing quote. A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**fuzz_crash_060.md:1:12:1:13:** -```roc -module[]C:k||match 0{0|# -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_060.md:1:13:1:14:** -```roc -module[]C:k||match 0{0|# -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_060.md:1:14:1:19:** -```roc -module[]C:k||match 0{0|# -``` - ^^^^^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_060.md:1:20:1:21:** -```roc -module[]C:k||match 0{0|# -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_060.md:1:21:1:22:** -```roc -module[]C:k||match 0{0|# -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_060.md:1:22:1:23:** -```roc -module[]C:k||match 0{0|# -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_060.md:1:23:1:24:** -```roc -module[]C:k||match 0{0|# -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_060.md:2:1:2:2:** +**fuzz_crash_060.md:1:1:1:2:** ```roc 0" ``` @@ -126,7 +40,7 @@ This is an unexpected parsing error. Please check your syntax. A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**fuzz_crash_060.md:2:2:2:3:** +**fuzz_crash_060.md:1:2:1:3:** ```roc 0" ``` @@ -137,7 +51,7 @@ This is an unexpected parsing error. Please check your syntax. A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**fuzz_crash_060.md:2:3:2:3:** +**fuzz_crash_060.md:1:3:1:3:** ```roc 0" ``` @@ -148,7 +62,7 @@ This is an unexpected parsing error. Please check your syntax. A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**fuzz_crash_060.md:2:3:2:3:** +**fuzz_crash_060.md:1:3:1:3:** ```roc 0" ``` @@ -159,76 +73,41 @@ This is an unexpected parsing error. Please check your syntax. A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**fuzz_crash_060.md:3:1:3:2:** +**fuzz_crash_060.md:2:1:2:2:** ```roc } ``` ^ -**UNDECLARED TYPE VARIABLE** -The type variable _k_ is not declared in this scope. - -Type variables must be introduced in a type annotation before they can be used. - -This type variable is referenced here: -**fuzz_crash_060.md:1:11:1:12:** -```roc -module[]C:k||match 0{0|# -``` - ^ - - # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:7-1:8),CloseSquare(1:8-1:9),UpperIdent(1:9-1:10),OpColon(1:10-1:11),LowerIdent(1:11-1:12),OpBar(1:12-1:13),OpBar(1:13-1:14),KwMatch(1:14-1:19),Int(1:20-1:21),OpenCurly(1:21-1:22),Int(1:22-1:23),OpBar(1:23-1:24), -Int(2:1-2:2),StringStart(2:2-2:3),StringPart(2:3-2:3),StringEnd(2:3-2:3), -CloseCurly(3:1-3:2), -EndOfFile(4:1-4:1), +Int(1:1-1:2),StringStart(1:2-1:3),StringPart(1:3-1:3),StringEnd(1:3-1:3), +CloseCurly(2:1-2:2), +EndOfFile(3:1-3:1), ~~~ # PARSE ~~~clojure -(file @1.1-3.2 - (module @1.1-1.9 - (exposes @1.7-1.9)) +(file @1.1-2.2 + (type-module @1.1-1.2) (statements - (s-type-decl @1.9-1.12 - (header @1.9-1.10 (name "C") - (args)) - (ty-var @1.11-1.12 (raw "k"))) - (s-malformed @1.12-1.13 (tag "statement_unexpected_token")) - (s-malformed @1.13-1.14 (tag "statement_unexpected_token")) - (s-malformed @1.14-1.19 (tag "statement_unexpected_token")) - (s-malformed @1.20-1.21 (tag "statement_unexpected_token")) - (s-malformed @1.21-1.22 (tag "statement_unexpected_token")) - (s-malformed @1.22-1.23 (tag "statement_unexpected_token")) - (s-malformed @1.23-1.24 (tag "statement_unexpected_token")) - (s-malformed @2.1-2.2 (tag "statement_unexpected_token")) - (s-malformed @2.2-2.3 (tag "statement_unexpected_token")) - (s-malformed @2.3-2.3 (tag "statement_unexpected_token")) - (s-malformed @2.3-2.3 (tag "statement_unexpected_token")) - (s-malformed @3.1-3.2 (tag "statement_unexpected_token")))) + (s-malformed @1.1-1.2 (tag "statement_unexpected_token")) + (s-malformed @1.2-1.3 (tag "statement_unexpected_token")) + (s-malformed @1.3-1.3 (tag "statement_unexpected_token")) + (s-malformed @1.3-1.3 (tag "statement_unexpected_token")) + (s-malformed @2.1-2.2 (tag "statement_unexpected_token")))) ~~~ # FORMATTED ~~~roc -module [] -C : k -# ~~~ # CANONICALIZE ~~~clojure -(can-ir - (s-alias-decl @1.9-1.12 - (ty-header @1.9-1.10 (name "C")) - (ty-malformed @1.11-1.12))) +(can-ir (empty true)) ~~~ # TYPES ~~~clojure (inferred-types (defs) - (type_decls - (alias @1.9-1.12 (type "Error") - (ty-header @1.9-1.10 (name "C")))) (expressions)) ~~~ diff --git a/test/snapshots/fuzz_crash/fuzz_crash_064.md b/test/snapshots/fuzz_crash/fuzz_crash_064.md index af2b603647..4b1e0e2b6d 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_064.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_064.md @@ -8,16 +8,15 @@ type=file ~~~ # EXPECTED -MISSING HEADER - fuzz_crash_064.md:2:1:2:1 +MISSING MAIN! FUNCTION - fuzz_crash_064.md:2:1:2:1 # PROBLEMS -**MISSING HEADER** -Roc files must start with a module header. +**MISSING MAIN! FUNCTION** +Default app modules must have a `main!` function. -For example: - module [main] -or for an app: - app [main!] { pf: platform "../basic-cli/platform.roc" } +No `main!` function was found. +Add a main! function like: +`main! = |arg| { ... }` **fuzz_crash_064.md:2:1:2:1:** ```roc @@ -32,7 +31,7 @@ EndOfFile(2:1-2:1), # PARSE ~~~clojure (file @2.1-2.1 - (malformed-header @2.1-2.1 (tag "missing_header")) + (type-module @2.1-2.1) (statements)) ~~~ # FORMATTED diff --git a/test/snapshots/fuzz_crash/fuzz_crash_065.md b/test/snapshots/fuzz_crash/fuzz_crash_065.md index 3e50fe1109..df80a78d6a 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_065.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_065.md @@ -1,67 +1,29 @@ # META ~~~ini description=fuzz crash -type=file +type=snippet ~~~ # SOURCE ~~~roc -module[]{R} + ~~~ # EXPECTED -PARSE ERROR - fuzz_crash_065.md:1:9:1:10 -PARSE ERROR - fuzz_crash_065.md:1:11:1:12 +NIL # PROBLEMS -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_065.md:1:9:1:10:** -```roc -module[]{R} -``` - ^ - - -**PARSE ERROR** -Type applications require parentheses around their type arguments. - -I found a type followed by what looks like a type argument, but they need to be connected with parentheses. - -Instead of: - **List U8** - -Use: - **List(U8)** - -Other valid examples: - `Dict(Str, Num)` - `Result(a, Str)` - `Maybe(List(U64))` - -**fuzz_crash_065.md:1:11:1:12:** -```roc -module[]{R} -``` - ^ - - +NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:7-1:8),CloseSquare(1:8-1:9),OpenCurly(1:9-1:10),UpperIdent(1:10-1:11),CloseCurly(1:11-1:12), EndOfFile(2:1-2:1), ~~~ # PARSE ~~~clojure -(file @1.1-1.12 - (module @1.1-1.9 - (exposes @1.7-1.9)) - (statements - (s-malformed @1.9-1.10 (tag "statement_unexpected_token")) - (s-malformed @1.11-1.12 (tag "expected_colon_after_type_annotation")))) +(file @2.1-2.1 + (type-module @2.1-2.1) + (statements)) ~~~ # FORMATTED ~~~roc -module [] +NO CHANGE ~~~ # CANONICALIZE ~~~clojure diff --git a/test/snapshots/fuzz_crash/fuzz_crash_066.md b/test/snapshots/fuzz_crash/fuzz_crash_066.md index 9c183febb8..eb8b0c6d6f 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_066.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_066.md @@ -1,23 +1,21 @@ # META ~~~ini description=fuzz crash -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - C:[0] ~~~ # EXPECTED -UNEXPECTED TOKEN IN TYPE ANNOTATION - fuzz_crash_066.md:3:4:3:5 -MALFORMED TYPE - fuzz_crash_066.md:3:4:3:5 +UNEXPECTED TOKEN IN TYPE ANNOTATION - fuzz_crash_066.md:1:4:1:5 +MALFORMED TYPE - fuzz_crash_066.md:1:4:1:5 # PROBLEMS **UNEXPECTED TOKEN IN TYPE ANNOTATION** The token **0** is not expected in a type annotation. Type annotations should contain types like _Str_, _Num a_, or _List U64_. -**fuzz_crash_066.md:3:4:3:5:** +**fuzz_crash_066.md:1:4:1:5:** ```roc C:[0] ``` @@ -27,7 +25,7 @@ C:[0] **MALFORMED TYPE** This type annotation is malformed or contains invalid syntax. -**fuzz_crash_066.md:3:4:3:5:** +**fuzz_crash_066.md:1:4:1:5:** ```roc C:[0] ``` @@ -36,43 +34,39 @@ C:[0] # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -UpperIdent(3:1-3:2),OpColon(3:2-3:3),OpenSquare(3:3-3:4),Int(3:4-3:5),CloseSquare(3:5-3:6), -EndOfFile(4:1-4:1), +UpperIdent(1:1-1:2),OpColon(1:2-1:3),OpenSquare(1:3-1:4),Int(1:4-1:5),CloseSquare(1:5-1:6), +EndOfFile(2:1-2:1), ~~~ # PARSE ~~~clojure -(file @1.1-3.6 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-1.6 + (type-module @1.1-1.2) (statements - (s-type-decl @3.1-3.6 - (header @3.1-3.2 (name "C") + (s-type-decl @1.1-1.6 + (header @1.1-1.2 (name "C") (args)) - (ty-tag-union @3.3-3.6 + (ty-tag-union @1.3-1.6 (tags - (ty-malformed @3.4-3.5 (tag "ty_anno_unexpected_token"))))))) + (ty-malformed @1.4-1.5 (tag "ty_anno_unexpected_token"))))))) ~~~ # FORMATTED ~~~roc -module [] - C : [] ~~~ # CANONICALIZE ~~~clojure (can-ir - (s-alias-decl @3.1-3.6 - (ty-header @3.1-3.2 (name "C")) - (ty-tag-union @3.3-3.6 - (ty-malformed @3.4-3.5)))) + (s-alias-decl @1.1-1.6 + (ty-header @1.1-1.2 (name "C")) + (ty-tag-union @1.3-1.6 + (ty-malformed @1.4-1.5)))) ~~~ # TYPES ~~~clojure (inferred-types (defs) (type_decls - (alias @3.1-3.6 (type "C") - (ty-header @3.1-3.2 (name "C")))) + (alias @1.1-1.6 (type "C") + (ty-header @1.1-1.2 (name "C")))) (expressions)) ~~~ diff --git a/test/snapshots/fuzz_crash/fuzz_crash_067.md b/test/snapshots/fuzz_crash/fuzz_crash_067.md index f1c35b9204..80a9c7bd7b 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_067.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_067.md @@ -1,23 +1,21 @@ # META ~~~ini description=fuzz crash -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - f = || { crash 1 } ~~~ # EXPECTED -CRASH EXPECTS STRING - fuzz_crash_067.md:3:8:5:2 +CRASH EXPECTS STRING - fuzz_crash_067.md:1:8:3:2 # PROBLEMS **CRASH EXPECTS STRING** The `crash` keyword expects a string literal as its argument. For example: `crash "Something went wrong"` -**fuzz_crash_067.md:3:8:5:2:** +**fuzz_crash_067.md:1:8:3:2:** ```roc f = || { crash 1 @@ -27,31 +25,27 @@ f = || { # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -LowerIdent(3:1-3:2),OpAssign(3:3-3:4),OpBar(3:5-3:6),OpBar(3:6-3:7),OpenCurly(3:8-3:9), -KwCrash(4:5-4:10),Int(4:11-4:12), -CloseCurly(5:1-5:2), -EndOfFile(6:1-6:1), +LowerIdent(1:1-1:2),OpAssign(1:3-1:4),OpBar(1:5-1:6),OpBar(1:6-1:7),OpenCurly(1:8-1:9), +KwCrash(2:5-2:10),Int(2:11-2:12), +CloseCurly(3:1-3:2), +EndOfFile(4:1-4:1), ~~~ # PARSE ~~~clojure -(file @1.1-5.2 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-3.2 + (type-module @1.1-1.2) (statements - (s-decl @3.1-5.2 - (p-ident @3.1-3.2 (raw "f")) - (e-lambda @3.5-5.2 + (s-decl @1.1-3.2 + (p-ident @1.1-1.2 (raw "f")) + (e-lambda @1.5-3.2 (args) - (e-block @3.8-5.2 + (e-block @1.8-3.2 (statements - (s-crash @4.5-4.12 - (e-int @4.11-4.12 (raw "1"))))))))) + (s-crash @2.5-2.12 + (e-int @2.11-2.12 (raw "1"))))))))) ~~~ # FORMATTED ~~~roc -module [] - f = || { crash 1 } @@ -60,17 +54,17 @@ f = || { ~~~clojure (can-ir (d-let - (p-assign @3.1-3.2 (ident "f")) - (e-lambda @3.5-5.2 + (p-assign @1.1-1.2 (ident "f")) + (e-lambda @1.5-3.2 (args) - (e-block @3.8-5.2 + (e-block @1.8-3.2 (e-runtime-error (tag "crash_expects_string")))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @3.1-3.2 (type "({}) -> Error"))) + (patt @1.1-1.2 (type "({}) -> Error"))) (expressions - (expr @3.5-5.2 (type "({}) -> Error")))) + (expr @1.5-3.2 (type "({}) -> Error")))) ~~~ diff --git a/test/snapshots/fuzz_crash/fuzz_crash_068.md b/test/snapshots/fuzz_crash/fuzz_crash_068.md index 417832e8c3..df80a78d6a 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_068.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_068.md @@ -1,94 +1,29 @@ # META ~~~ini description=fuzz crash -type=file +type=snippet ~~~ # SOURCE ~~~roc -module[]({0}) + ~~~ # EXPECTED -PARSE ERROR - fuzz_crash_068.md:1:9:1:10 -PARSE ERROR - fuzz_crash_068.md:1:10:1:11 -PARSE ERROR - fuzz_crash_068.md:1:11:1:12 -PARSE ERROR - fuzz_crash_068.md:1:12:1:13 -PARSE ERROR - fuzz_crash_068.md:1:13:1:14 +NIL # PROBLEMS -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_068.md:1:9:1:10:** -```roc -module[]({0}) -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_068.md:1:10:1:11:** -```roc -module[]({0}) -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_068.md:1:11:1:12:** -```roc -module[]({0}) -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_068.md:1:12:1:13:** -```roc -module[]({0}) -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_068.md:1:13:1:14:** -```roc -module[]({0}) -``` - ^ - - +NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:7-1:8),CloseSquare(1:8-1:9),NoSpaceOpenRound(1:9-1:10),OpenCurly(1:10-1:11),Int(1:11-1:12),CloseCurly(1:12-1:13),CloseRound(1:13-1:14), EndOfFile(2:1-2:1), ~~~ # PARSE ~~~clojure -(file @1.1-1.14 - (module @1.1-1.9 - (exposes @1.7-1.9)) - (statements - (s-malformed @1.9-1.10 (tag "statement_unexpected_token")) - (s-malformed @1.10-1.11 (tag "statement_unexpected_token")) - (s-malformed @1.11-1.12 (tag "statement_unexpected_token")) - (s-malformed @1.12-1.13 (tag "statement_unexpected_token")) - (s-malformed @1.13-1.14 (tag "statement_unexpected_token")))) +(file @2.1-2.1 + (type-module @2.1-2.1) + (statements)) ~~~ # FORMATTED ~~~roc -module [] +NO CHANGE ~~~ # CANONICALIZE ~~~clojure diff --git a/test/snapshots/fuzz_crash/fuzz_crash_070.md b/test/snapshots/fuzz_crash/fuzz_crash_070.md index bf98f6dabf..df80a78d6a 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_070.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_070.md @@ -1,81 +1,29 @@ # META ~~~ini description=fuzz crash -type=file +type=snippet ~~~ # SOURCE ~~~roc -module[]()0 .t + ~~~ # EXPECTED -PARSE ERROR - fuzz_crash_070.md:1:9:1:10 -PARSE ERROR - fuzz_crash_070.md:1:10:1:11 -PARSE ERROR - fuzz_crash_070.md:1:11:1:12 -PARSE ERROR - fuzz_crash_070.md:1:17:1:19 +NIL # PROBLEMS -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_070.md:1:9:1:10:** -```roc -module[]()0 .t -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_070.md:1:10:1:11:** -```roc -module[]()0 .t -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_070.md:1:11:1:12:** -```roc -module[]()0 .t -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_070.md:1:17:1:19:** -```roc -module[]()0 .t -``` - ^^ - - +NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:7-1:8),CloseSquare(1:8-1:9),NoSpaceOpenRound(1:9-1:10),CloseRound(1:10-1:11),Int(1:11-1:12),DotLowerIdent(1:17-1:19), EndOfFile(2:1-2:1), ~~~ # PARSE ~~~clojure -(file @1.1-1.19 - (module @1.1-1.9 - (exposes @1.7-1.9)) - (statements - (s-malformed @1.9-1.10 (tag "statement_unexpected_token")) - (s-malformed @1.10-1.11 (tag "statement_unexpected_token")) - (s-malformed @1.11-1.12 (tag "statement_unexpected_token")) - (s-malformed @1.17-1.19 (tag "statement_unexpected_token")))) +(file @2.1-2.1 + (type-module @2.1-2.1) + (statements)) ~~~ # FORMATTED ~~~roc -module [] +NO CHANGE ~~~ # CANONICALIZE ~~~clojure diff --git a/test/snapshots/fuzz_crash/fuzz_crash_072.md b/test/snapshots/fuzz_crash/fuzz_crash_072.md index 7eec31229e..df80a78d6a 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_072.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_072.md @@ -1,159 +1,29 @@ # META ~~~ini description=fuzz crash -type=file +type=snippet ~~~ # SOURCE ~~~roc -module[]({})(!{0}) + ~~~ # EXPECTED -PARSE ERROR - fuzz_crash_072.md:1:9:1:10 -PARSE ERROR - fuzz_crash_072.md:1:10:1:11 -PARSE ERROR - fuzz_crash_072.md:1:11:1:12 -PARSE ERROR - fuzz_crash_072.md:1:12:1:13 -PARSE ERROR - fuzz_crash_072.md:1:13:1:14 -PARSE ERROR - fuzz_crash_072.md:1:14:1:15 -PARSE ERROR - fuzz_crash_072.md:1:15:1:16 -PARSE ERROR - fuzz_crash_072.md:1:16:1:17 -PARSE ERROR - fuzz_crash_072.md:1:17:1:18 -PARSE ERROR - fuzz_crash_072.md:1:18:1:19 +NIL # PROBLEMS -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_072.md:1:9:1:10:** -```roc -module[]({})(!{0}) -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_072.md:1:10:1:11:** -```roc -module[]({})(!{0}) -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_072.md:1:11:1:12:** -```roc -module[]({})(!{0}) -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_072.md:1:12:1:13:** -```roc -module[]({})(!{0}) -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_072.md:1:13:1:14:** -```roc -module[]({})(!{0}) -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_072.md:1:14:1:15:** -```roc -module[]({})(!{0}) -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_072.md:1:15:1:16:** -```roc -module[]({})(!{0}) -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_072.md:1:16:1:17:** -```roc -module[]({})(!{0}) -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_072.md:1:17:1:18:** -```roc -module[]({})(!{0}) -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_072.md:1:18:1:19:** -```roc -module[]({})(!{0}) -``` - ^ - - +NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:7-1:8),CloseSquare(1:8-1:9),NoSpaceOpenRound(1:9-1:10),OpenCurly(1:10-1:11),CloseCurly(1:11-1:12),CloseRound(1:12-1:13),NoSpaceOpenRound(1:13-1:14),OpBang(1:14-1:15),OpenCurly(1:15-1:16),Int(1:16-1:17),CloseCurly(1:17-1:18),CloseRound(1:18-1:19), EndOfFile(2:1-2:1), ~~~ # PARSE ~~~clojure -(file @1.1-1.19 - (module @1.1-1.9 - (exposes @1.7-1.9)) - (statements - (s-malformed @1.9-1.10 (tag "statement_unexpected_token")) - (s-malformed @1.10-1.11 (tag "statement_unexpected_token")) - (s-malformed @1.11-1.12 (tag "statement_unexpected_token")) - (s-malformed @1.12-1.13 (tag "statement_unexpected_token")) - (s-malformed @1.13-1.14 (tag "statement_unexpected_token")) - (s-malformed @1.14-1.15 (tag "statement_unexpected_token")) - (s-malformed @1.15-1.16 (tag "statement_unexpected_token")) - (s-malformed @1.16-1.17 (tag "statement_unexpected_token")) - (s-malformed @1.17-1.18 (tag "statement_unexpected_token")) - (s-malformed @1.18-1.19 (tag "statement_unexpected_token")))) +(file @2.1-2.1 + (type-module @2.1-2.1) + (statements)) ~~~ # FORMATTED ~~~roc -module [] +NO CHANGE ~~~ # CANONICALIZE ~~~clojure diff --git a/test/snapshots/fuzz_crash/fuzz_crash_073.md b/test/snapshots/fuzz_crash/fuzz_crash_073.md index a88f2af216..df80a78d6a 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_073.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_073.md @@ -1,74 +1,29 @@ # META ~~~ini description=fuzz crash -type=file +type=snippet ~~~ # SOURCE ~~~roc -module[]!0.t + ~~~ # EXPECTED -ASCII CONTROL CHARACTER - :0:0:0:0 -PARSE ERROR - fuzz_crash_073.md:1:9:1:10 -PARSE ERROR - fuzz_crash_073.md:1:10:1:11 -PARSE ERROR - fuzz_crash_073.md:1:12:1:14 +NIL # PROBLEMS -**ASCII CONTROL CHARACTER** -ASCII control characters are not allowed in Roc source code. - - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_073.md:1:9:1:10:** -```roc -module[]!0.t -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_073.md:1:10:1:11:** -```roc -module[]!0.t -``` - ^ - - -**PARSE ERROR** -A parsing error occurred: `statement_unexpected_token` -This is an unexpected parsing error. Please check your syntax. - -**fuzz_crash_073.md:1:12:1:14:** -```roc -module[]!0.t -``` - ^^ - - +NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:7-1:8),CloseSquare(1:8-1:9),OpBang(1:9-1:10),Int(1:10-1:11),DotLowerIdent(1:12-1:14), EndOfFile(2:1-2:1), ~~~ # PARSE ~~~clojure -(file @1.1-1.14 - (module @1.1-1.9 - (exposes @1.7-1.9)) - (statements - (s-malformed @1.9-1.10 (tag "statement_unexpected_token")) - (s-malformed @1.10-1.11 (tag "statement_unexpected_token")) - (s-malformed @1.12-1.14 (tag "statement_unexpected_token")))) +(file @2.1-2.1 + (type-module @2.1-2.1) + (statements)) ~~~ # FORMATTED ~~~roc -module [] +NO CHANGE ~~~ # CANONICALIZE ~~~clojure diff --git a/test/snapshots/fuzz_crash/fuzz_crash_078.md b/test/snapshots/fuzz_crash/fuzz_crash_078.md index 2918436e58..20034f18b9 100644 --- a/test/snapshots/fuzz_crash/fuzz_crash_078.md +++ b/test/snapshots/fuzz_crash/fuzz_crash_078.md @@ -1,21 +1,20 @@ # META ~~~ini description=fuzz crash -type=file +type=snippet ~~~ # SOURCE ~~~roc -module[]e=""" import#\ ~~~ # EXPECTED -PARSE ERROR - fuzz_crash_078.md:3:1:3:1 +PARSE ERROR - fuzz_crash_078.md:2:1:2:1 # PROBLEMS **PARSE ERROR** A parsing error occurred: `incomplete_import` This is an unexpected parsing error. Please check your syntax. -**fuzz_crash_078.md:3:1:3:1:** +**fuzz_crash_078.md:2:1:2:1:** ```roc ``` @@ -24,40 +23,27 @@ This is an unexpected parsing error. Please check your syntax. # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:7-1:8),CloseSquare(1:8-1:9),LowerIdent(1:9-1:10),OpAssign(1:10-1:11),MultilineStringStart(1:11-1:14),StringPart(1:14-1:14), -KwImport(2:1-2:7), -EndOfFile(3:1-3:1), +KwImport(1:1-1:7), +EndOfFile(2:1-2:1), ~~~ # PARSE ~~~clojure -(file @1.1-2.7 - (module @1.1-1.9 - (exposes @1.7-1.9)) +(file @1.1-1.7 + (type-module @1.1-1.7) (statements - (s-decl @1.9-1.14 - (p-ident @1.9-1.10 (raw "e")) - (e-multiline-string @1.11-1.14 - (e-string-part @1.14-1.14 (raw "")))) - (s-malformed @2.1-2.7 (tag "incomplete_import")))) + (s-malformed @1.1-1.7 (tag "incomplete_import")))) ~~~ # FORMATTED ~~~roc -module [] -e = """ # \ ~~~ # CANONICALIZE ~~~clojure -(can-ir - (d-let - (p-assign @1.9-1.10 (ident "e")) - (e-string @1.11-1.14))) +(can-ir (empty true)) ~~~ # TYPES ~~~clojure (inferred-types - (defs - (patt @1.9-1.10 (type "Str"))) - (expressions - (expr @1.11-1.14 (type "Str")))) + (defs) + (expressions)) ~~~ diff --git a/test/snapshots/fuzz_crash/fuzz_hang_001.md b/test/snapshots/fuzz_crash/fuzz_hang_001.md index 0a69178837..fe8dafaa90 100644 --- a/test/snapshots/fuzz_crash/fuzz_hang_001.md +++ b/test/snapshots/fuzz_crash/fuzz_hang_001.md @@ -8,16 +8,13 @@ type=file 0 ( ~~~ # EXPECTED -MISSING HEADER - fuzz_hang_001.md:1:1:1:2 +PARSE ERROR - fuzz_hang_001.md:1:1:1:2 PARSE ERROR - fuzz_hang_001.md:1:3:1:4 +MISSING MAIN! FUNCTION - fuzz_hang_001.md:1:1:1:4 # PROBLEMS -**MISSING HEADER** -Roc files must start with a module header. - -For example: - module [main] -or for an app: - app [main!] { pf: platform "../basic-cli/platform.roc" } +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. **fuzz_hang_001.md:1:1:1:2:** ```roc @@ -37,6 +34,20 @@ This is an unexpected parsing error. Please check your syntax. ^ +**MISSING MAIN! FUNCTION** +Default app modules must have a `main!` function. + +No `main!` function was found. + +Add a main! function like: +`main! = |arg| { ... }` +**fuzz_hang_001.md:1:1:1:4:** +```roc +0 ( +``` +^^^ + + # TOKENS ~~~zig Int(1:1-1:2),OpenRound(1:3-1:4), @@ -45,8 +56,9 @@ EndOfFile(2:1-2:1), # PARSE ~~~clojure (file @1.1-1.4 - (malformed-header @1.1-1.2 (tag "missing_header")) + (type-module @1.1-1.2) (statements + (s-malformed @1.1-1.2 (tag "statement_unexpected_token")) (s-malformed @1.3-1.4 (tag "statement_unexpected_token")))) ~~~ # FORMATTED diff --git a/test/snapshots/hello_world.md b/test/snapshots/hello_world.md index f2422ca0a4..095911cb4e 100644 --- a/test/snapshots/hello_world.md +++ b/test/snapshots/hello_world.md @@ -72,7 +72,7 @@ NO CHANGE (p-underscore @5.10-5.11)) (e-call @5.13-5.42 (e-lookup-external @5.13-5.25 - (module-idx "0") + (module-idx "2") (target-node-idx "0")) (e-string @5.26-5.41 (e-literal @5.27-5.40 (string "Hello, world!")))))) diff --git a/test/snapshots/hello_world_with_block.md b/test/snapshots/hello_world_with_block.md index bd743b5d85..1c0f437810 100644 --- a/test/snapshots/hello_world_with_block.md +++ b/test/snapshots/hello_world_with_block.md @@ -106,7 +106,7 @@ NO CHANGE (e-literal @9.11-9.16 (string "World")))) (e-call @11.2-11.31 (e-lookup-external @11.2-11.14 - (module-idx "0") + (module-idx "2") (target-node-idx "0")) (e-string @11.15-11.30 (e-literal @11.16-11.29 (string "Hello, world!"))))))) diff --git a/test/snapshots/if_then_else/if_then_else_7.md b/test/snapshots/if_then_else/if_then_else_7.md index a1fcd9b8d0..9e33b37823 100644 --- a/test/snapshots/if_then_else/if_then_else_7.md +++ b/test/snapshots/if_then_else/if_then_else_7.md @@ -56,10 +56,10 @@ NO CHANGE (if-branch (e-runtime-error (tag "ident_not_in_scope")) (e-block @1.9-3.2 - (e-int @2.2-2.3 (value "1"))))) + (e-num @2.2-2.3 (value "1"))))) (if-else (e-block @3.8-5.2 - (e-int @4.2-4.3 (value "2"))))) + (e-num @4.2-4.3 (value "2"))))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/if_then_else/if_then_else_9.md b/test/snapshots/if_then_else/if_then_else_9.md index f662b4c62b..e7f2b38bd6 100644 --- a/test/snapshots/if_then_else/if_then_else_9.md +++ b/test/snapshots/if_then_else/if_then_else_9.md @@ -105,14 +105,14 @@ NO CHANGE (if-branch (e-runtime-error (tag "ident_not_in_scope")) (e-block @1.9-3.2 - (e-int @2.2-2.3 (value "1")))) + (e-num @2.2-2.3 (value "1")))) (if-branch - (e-int @3.11-3.13 (value "10")) + (e-num @3.11-3.13 (value "10")) (e-block @3.14-5.2 (e-tag @4.2-4.3 (name "A"))))) (if-else (e-block @5.8-7.2 - (e-int @6.2-6.3 (value "3"))))) + (e-num @6.2-6.3 (value "3"))))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/if_then_else/if_then_else_comments_block.md b/test/snapshots/if_then_else/if_then_else_comments_block.md index 7bc6e2b92e..53db2733ac 100644 --- a/test/snapshots/if_then_else/if_then_else_comments_block.md +++ b/test/snapshots/if_then_else/if_then_else_comments_block.md @@ -60,10 +60,10 @@ NO CHANGE (if-branch (e-runtime-error (tag "ident_not_in_scope")) (e-block @3.3-5.4 - (e-int @4.4-4.5 (value "1"))))) + (e-num @4.4-4.5 (value "1"))))) (if-else (e-block @5.10-7.4 - (e-int @6.4-6.5 (value "2"))))) + (e-num @6.4-6.5 (value "2"))))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/if_then_else/if_then_else_comments_complex.md b/test/snapshots/if_then_else/if_then_else_comments_complex.md index dae22c77d3..b3134fd661 100644 --- a/test/snapshots/if_then_else/if_then_else_comments_complex.md +++ b/test/snapshots/if_then_else/if_then_else_comments_complex.md @@ -64,10 +64,10 @@ NO CHANGE (if-branch (e-runtime-error (tag "ident_not_in_scope")) (e-block @3.3-5.4 - (e-int @4.4-4.5 (value "1"))))) + (e-num @4.4-4.5 (value "1"))))) (if-else (e-block @7.5-9.6 - (e-int @8.6-8.7 (value "2"))))) + (e-num @8.6-8.7 (value "2"))))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/if_then_else/if_then_else_multi_comments.md b/test/snapshots/if_then_else/if_then_else_multi_comments.md index 35b0fe37dd..dbcd429482 100644 --- a/test/snapshots/if_then_else/if_then_else_multi_comments.md +++ b/test/snapshots/if_then_else/if_then_else_multi_comments.md @@ -60,10 +60,10 @@ NO CHANGE (if-branch (e-runtime-error (tag "ident_not_in_scope")) (e-block @3.3-5.4 - (e-int @4.4-4.5 (value "1"))))) + (e-num @4.4-4.5 (value "1"))))) (if-else (e-block @5.10-7.4 - (e-int @6.4-6.5 (value "2"))))) + (e-num @6.4-6.5 (value "2"))))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/if_then_else/if_then_else_nested_chain.md b/test/snapshots/if_then_else/if_then_else_nested_chain.md index 74d38747fb..202194cd4e 100644 --- a/test/snapshots/if_then_else/if_then_else_nested_chain.md +++ b/test/snapshots/if_then_else/if_then_else_nested_chain.md @@ -1,12 +1,10 @@ # META ~~~ini description=Nested if-then-else chain demonstrating flattening -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [checkNumber] - checkNumber = |num| { if num < 0 { "negative" @@ -25,63 +23,59 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:20),CloseSquare(1:20-1:21), -LowerIdent(3:1-3:12),OpAssign(3:13-3:14),OpBar(3:15-3:16),LowerIdent(3:16-3:19),OpBar(3:19-3:20),OpenCurly(3:21-3:22), -KwIf(4:2-4:4),LowerIdent(4:5-4:8),OpLessThan(4:9-4:10),Int(4:11-4:12),OpenCurly(4:13-4:14), -StringStart(5:3-5:4),StringPart(5:4-5:12),StringEnd(5:12-5:13), -CloseCurly(6:2-6:3),KwElse(6:4-6:8),KwIf(6:9-6:11),LowerIdent(6:12-6:15),OpEquals(6:16-6:18),Int(6:19-6:20),OpenCurly(6:21-6:22), -StringStart(7:3-7:4),StringPart(7:4-7:8),StringEnd(7:8-7:9), -CloseCurly(8:2-8:3),KwElse(8:4-8:8),KwIf(8:9-8:11),LowerIdent(8:12-8:15),OpGreaterThan(8:16-8:17),Int(8:18-8:21),OpenCurly(8:22-8:23), -StringStart(9:3-9:4),StringPart(9:4-9:9),StringEnd(9:9-9:10), -CloseCurly(10:2-10:3),KwElse(10:4-10:8),OpenCurly(10:9-10:10), -StringStart(11:3-11:4),StringPart(11:4-11:12),StringEnd(11:12-11:13), -CloseCurly(12:2-12:3), -CloseCurly(13:1-13:2), -EndOfFile(14:1-14:1), +LowerIdent(1:1-1:12),OpAssign(1:13-1:14),OpBar(1:15-1:16),LowerIdent(1:16-1:19),OpBar(1:19-1:20),OpenCurly(1:21-1:22), +KwIf(2:2-2:4),LowerIdent(2:5-2:8),OpLessThan(2:9-2:10),Int(2:11-2:12),OpenCurly(2:13-2:14), +StringStart(3:3-3:4),StringPart(3:4-3:12),StringEnd(3:12-3:13), +CloseCurly(4:2-4:3),KwElse(4:4-4:8),KwIf(4:9-4:11),LowerIdent(4:12-4:15),OpEquals(4:16-4:18),Int(4:19-4:20),OpenCurly(4:21-4:22), +StringStart(5:3-5:4),StringPart(5:4-5:8),StringEnd(5:8-5:9), +CloseCurly(6:2-6:3),KwElse(6:4-6:8),KwIf(6:9-6:11),LowerIdent(6:12-6:15),OpGreaterThan(6:16-6:17),Int(6:18-6:21),OpenCurly(6:22-6:23), +StringStart(7:3-7:4),StringPart(7:4-7:9),StringEnd(7:9-7:10), +CloseCurly(8:2-8:3),KwElse(8:4-8:8),OpenCurly(8:9-8:10), +StringStart(9:3-9:4),StringPart(9:4-9:12),StringEnd(9:12-9:13), +CloseCurly(10:2-10:3), +CloseCurly(11:1-11:2), +EndOfFile(12:1-12:1), ~~~ # PARSE ~~~clojure -(file @1.1-13.2 - (module @1.1-1.21 - (exposes @1.8-1.21 - (exposed-lower-ident @1.9-1.20 - (text "checkNumber")))) +(file @1.1-11.2 + (type-module @1.1-1.12) (statements - (s-decl @3.1-13.2 - (p-ident @3.1-3.12 (raw "checkNumber")) - (e-lambda @3.15-13.2 + (s-decl @1.1-11.2 + (p-ident @1.1-1.12 (raw "checkNumber")) + (e-lambda @1.15-11.2 (args - (p-ident @3.16-3.19 (raw "num"))) - (e-block @3.21-13.2 + (p-ident @1.16-1.19 (raw "num"))) + (e-block @1.21-11.2 (statements - (e-if-then-else @4.2-12.3 - (e-binop @4.5-4.12 (op "<") - (e-ident @4.5-4.8 (raw "num")) - (e-int @4.11-4.12 (raw "0"))) - (e-block @4.13-6.3 + (e-if-then-else @2.2-10.3 + (e-binop @2.5-2.12 (op "<") + (e-ident @2.5-2.8 (raw "num")) + (e-int @2.11-2.12 (raw "0"))) + (e-block @2.13-4.3 (statements - (e-string @5.3-5.13 - (e-string-part @5.4-5.12 (raw "negative"))))) - (e-if-then-else @6.9-12.3 - (e-binop @6.12-6.20 (op "==") - (e-ident @6.12-6.15 (raw "num")) - (e-int @6.19-6.20 (raw "0"))) - (e-block @6.21-8.3 + (e-string @3.3-3.13 + (e-string-part @3.4-3.12 (raw "negative"))))) + (e-if-then-else @4.9-10.3 + (e-binop @4.12-4.20 (op "==") + (e-ident @4.12-4.15 (raw "num")) + (e-int @4.19-4.20 (raw "0"))) + (e-block @4.21-6.3 (statements - (e-string @7.3-7.9 - (e-string-part @7.4-7.8 (raw "zero"))))) - (e-if-then-else @8.9-12.3 - (e-binop @8.12-8.21 (op ">") - (e-ident @8.12-8.15 (raw "num")) - (e-int @8.18-8.21 (raw "100"))) - (e-block @8.22-10.3 + (e-string @5.3-5.9 + (e-string-part @5.4-5.8 (raw "zero"))))) + (e-if-then-else @6.9-10.3 + (e-binop @6.12-6.21 (op ">") + (e-ident @6.12-6.15 (raw "num")) + (e-int @6.18-6.21 (raw "100"))) + (e-block @6.22-8.3 (statements - (e-string @9.3-9.10 - (e-string-part @9.4-9.9 (raw "large"))))) - (e-block @10.9-12.3 + (e-string @7.3-7.10 + (e-string-part @7.4-7.9 (raw "large"))))) + (e-block @8.9-10.3 (statements - (e-string @11.3-11.13 - (e-string-part @11.4-11.12 (raw "positive")))))))))))))) + (e-string @9.3-9.13 + (e-string-part @9.4-9.12 (raw "positive")))))))))))))) ~~~ # FORMATTED ~~~roc @@ -91,47 +85,47 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @3.1-3.12 (ident "checkNumber")) - (e-lambda @3.15-13.2 + (p-assign @1.1-1.12 (ident "checkNumber")) + (e-lambda @1.15-11.2 (args - (p-assign @3.16-3.19 (ident "num"))) - (e-block @3.21-13.2 - (e-if @4.2-12.3 + (p-assign @1.16-1.19 (ident "num"))) + (e-block @1.21-11.2 + (e-if @2.2-10.3 (if-branches (if-branch - (e-binop @4.5-4.12 (op "lt") - (e-lookup-local @4.5-4.8 - (p-assign @3.16-3.19 (ident "num"))) - (e-int @4.11-4.12 (value "0"))) - (e-block @4.13-6.3 - (e-string @5.3-5.13 - (e-literal @5.4-5.12 (string "negative"))))) + (e-binop @2.5-2.12 (op "lt") + (e-lookup-local @2.5-2.8 + (p-assign @1.16-1.19 (ident "num"))) + (e-num @2.11-2.12 (value "0"))) + (e-block @2.13-4.3 + (e-string @3.3-3.13 + (e-literal @3.4-3.12 (string "negative"))))) (if-branch - (e-binop @6.12-6.20 (op "eq") + (e-binop @4.12-4.20 (op "eq") + (e-lookup-local @4.12-4.15 + (p-assign @1.16-1.19 (ident "num"))) + (e-num @4.19-4.20 (value "0"))) + (e-block @4.21-6.3 + (e-string @5.3-5.9 + (e-literal @5.4-5.8 (string "zero"))))) + (if-branch + (e-binop @6.12-6.21 (op "gt") (e-lookup-local @6.12-6.15 - (p-assign @3.16-3.19 (ident "num"))) - (e-int @6.19-6.20 (value "0"))) - (e-block @6.21-8.3 - (e-string @7.3-7.9 - (e-literal @7.4-7.8 (string "zero"))))) - (if-branch - (e-binop @8.12-8.21 (op "gt") - (e-lookup-local @8.12-8.15 - (p-assign @3.16-3.19 (ident "num"))) - (e-int @8.18-8.21 (value "100"))) - (e-block @8.22-10.3 - (e-string @9.3-9.10 - (e-literal @9.4-9.9 (string "large")))))) + (p-assign @1.16-1.19 (ident "num"))) + (e-num @6.18-6.21 (value "100"))) + (e-block @6.22-8.3 + (e-string @7.3-7.10 + (e-literal @7.4-7.9 (string "large")))))) (if-else - (e-block @10.9-12.3 - (e-string @11.3-11.13 - (e-literal @11.4-11.12 (string "positive")))))))))) + (e-block @8.9-10.3 + (e-string @9.3-9.13 + (e-literal @9.4-9.12 (string "positive")))))))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @3.1-3.12 (type "Num(_size) -> Str"))) + (patt @1.1-1.12 (type "Num(_size) -> Str"))) (expressions - (expr @3.15-13.2 (type "Num(_size) -> Str")))) + (expr @1.15-11.2 (type "Num(_size) -> Str")))) ~~~ diff --git a/test/snapshots/if_then_else/if_then_else_simple_block_formatting.md b/test/snapshots/if_then_else/if_then_else_simple_block_formatting.md index 7fcca124c2..fa38a06578 100644 --- a/test/snapshots/if_then_else/if_then_else_simple_block_formatting.md +++ b/test/snapshots/if_then_else/if_then_else_simple_block_formatting.md @@ -74,7 +74,7 @@ NO CHANGE (e-block @1.9-3.2 (e-tag @2.2-2.3 (name "A"))))) (if-else - (e-int @3.8-3.9 (value "2")))) + (e-num @3.8-3.9 (value "2")))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/if_then_else/if_then_else_simple_file.md b/test/snapshots/if_then_else/if_then_else_simple_file.md index 9d94c8bb87..2e789af122 100644 --- a/test/snapshots/if_then_else/if_then_else_simple_file.md +++ b/test/snapshots/if_then_else/if_then_else_simple_file.md @@ -1,12 +1,10 @@ # META ~~~ini description=Example if-then-else statement -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [foo] - foo = if 1 A else { @@ -14,12 +12,12 @@ foo = if 1 A } ~~~ # EXPECTED -INVALID IF CONDITION - if_then_else_simple_file.md:3:10:3:10 -INCOMPATIBLE IF BRANCHES - if_then_else_simple_file.md:3:7:3:7 +INVALID IF CONDITION - if_then_else_simple_file.md:1:10:1:10 +INCOMPATIBLE IF BRANCHES - if_then_else_simple_file.md:1:7:1:7 # PROBLEMS **INVALID IF CONDITION** This `if` condition needs to be a _Bool_: -**if_then_else_simple_file.md:3:10:** +**if_then_else_simple_file.md:1:10:** ```roc foo = if 1 A ``` @@ -32,7 +30,7 @@ Every `if` condition must evaluate to a _Bool_–either `True` or `False`. **INCOMPATIBLE IF BRANCHES** This `if` has an `else` branch with a different type from it's `then` branch: -**if_then_else_simple_file.md:3:7:** +**if_then_else_simple_file.md:1:7:** ```roc foo = if 1 A @@ -55,35 +53,29 @@ To learn about tags, see # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:12),CloseSquare(1:12-1:13), -LowerIdent(3:1-3:4),OpAssign(3:5-3:6),KwIf(3:7-3:9),Int(3:10-3:11),UpperIdent(3:12-3:13), -KwElse(5:5-5:9),OpenCurly(5:10-5:11), -StringStart(6:2-6:3),StringPart(6:3-6:8),StringEnd(6:8-6:9), -CloseCurly(7:5-7:6), -EndOfFile(8:1-8:1), +LowerIdent(1:1-1:4),OpAssign(1:5-1:6),KwIf(1:7-1:9),Int(1:10-1:11),UpperIdent(1:12-1:13), +KwElse(3:5-3:9),OpenCurly(3:10-3:11), +StringStart(4:2-4:3),StringPart(4:3-4:8),StringEnd(4:8-4:9), +CloseCurly(5:5-5:6), +EndOfFile(6:1-6:1), ~~~ # PARSE ~~~clojure -(file @1.1-7.6 - (module @1.1-1.13 - (exposes @1.8-1.13 - (exposed-lower-ident @1.9-1.12 - (text "foo")))) +(file @1.1-5.6 + (type-module @1.1-1.4) (statements - (s-decl @3.1-7.6 - (p-ident @3.1-3.4 (raw "foo")) - (e-if-then-else @3.7-7.6 - (e-int @3.10-3.11 (raw "1")) - (e-tag @3.12-3.13 (raw "A")) - (e-block @5.10-7.6 + (s-decl @1.1-5.6 + (p-ident @1.1-1.4 (raw "foo")) + (e-if-then-else @1.7-5.6 + (e-int @1.10-1.11 (raw "1")) + (e-tag @1.12-1.13 (raw "A")) + (e-block @3.10-5.6 (statements - (e-string @6.2-6.9 - (e-string-part @6.3-6.8 (raw "hello"))))))))) + (e-string @4.2-4.9 + (e-string-part @4.3-4.8 (raw "hello"))))))))) ~~~ # FORMATTED ~~~roc -module [foo] - foo = if 1 A else { @@ -94,22 +86,22 @@ foo = if 1 A ~~~clojure (can-ir (d-let - (p-assign @3.1-3.4 (ident "foo")) - (e-if @3.7-7.6 + (p-assign @1.1-1.4 (ident "foo")) + (e-if @1.7-5.6 (if-branches (if-branch - (e-int @3.10-3.11 (value "1")) - (e-tag @3.12-3.13 (name "A")))) + (e-num @1.10-1.11 (value "1")) + (e-tag @1.12-1.13 (name "A")))) (if-else - (e-block @5.10-7.6 - (e-string @6.2-6.9 - (e-literal @6.3-6.8 (string "hello")))))))) + (e-block @3.10-5.6 + (e-string @4.2-4.9 + (e-literal @4.3-4.8 (string "hello")))))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @3.1-3.4 (type "Error"))) + (patt @1.1-1.4 (type "Error"))) (expressions - (expr @3.7-7.6 (type "Error")))) + (expr @1.7-5.6 (type "Error")))) ~~~ diff --git a/test/snapshots/if_then_else/if_then_else_simple_minimal.md b/test/snapshots/if_then_else/if_then_else_simple_minimal.md index 29d6684456..668d8953db 100644 --- a/test/snapshots/if_then_else/if_then_else_simple_minimal.md +++ b/test/snapshots/if_then_else/if_then_else_simple_minimal.md @@ -43,9 +43,9 @@ NO CHANGE (if-branches (if-branch (e-runtime-error (tag "ident_not_in_scope")) - (e-int @1.9-1.10 (value "1")))) + (e-num @1.9-1.10 (value "1")))) (if-else - (e-int @1.16-1.17 (value "2")))) + (e-num @1.16-1.17 (value "2")))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/if_then_else/if_then_else_simple_tag.md b/test/snapshots/if_then_else/if_then_else_simple_tag.md index 5483d4de76..6c88315aba 100644 --- a/test/snapshots/if_then_else/if_then_else_simple_tag.md +++ b/test/snapshots/if_then_else/if_then_else_simple_tag.md @@ -41,12 +41,12 @@ NO CHANGE (e-nominal @1.14-1.19 (nominal "Result") (e-tag @1.14-1.19 (name "Ok") (args - (e-int @1.17-1.18 (value "0"))))))) + (e-num @1.17-1.18 (value "0"))))))) (if-else (e-nominal @1.25-1.31 (nominal "Result") (e-tag @1.25-1.31 (name "Err") (args - (e-int @1.29-1.30 (value "1"))))))) + (e-num @1.29-1.30 (value "1"))))))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/import_exposing_alias.md b/test/snapshots/import_exposing_alias.md index ef8efda210..658252ccc6 100644 --- a/test/snapshots/import_exposing_alias.md +++ b/test/snapshots/import_exposing_alias.md @@ -1,12 +1,10 @@ # META ~~~ini description=Import with exposing clause using aliases -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [main] - import json.Json exposing [decode as fromJson, encode as toJson] main = { @@ -17,70 +15,90 @@ main = { } ~~~ # EXPECTED -MODULE NOT FOUND - import_exposing_alias.md:3:1:3:65 +MODULE NOT FOUND - import_exposing_alias.md:1:1:1:65 +UNDEFINED VARIABLE - import_exposing_alias.md:5:12:5:18 +UNDEFINED VARIABLE - import_exposing_alias.md:6:12:6:20 # PROBLEMS **MODULE NOT FOUND** The module `json.Json` was not found in this Roc project. You're attempting to use this module here: -**import_exposing_alias.md:3:1:3:65:** +**import_exposing_alias.md:1:1:1:65:** ```roc import json.Json exposing [decode as fromJson, encode as toJson] ``` ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +**UNDEFINED VARIABLE** +Nothing is named `toJson` in this scope. +Is there an `import` or `exposing` missing up-top? + +**import_exposing_alias.md:5:12:5:18:** +```roc + encoded = toJson(data) +``` + ^^^^^^ + + +**UNDEFINED VARIABLE** +Nothing is named `fromJson` in this scope. +Is there an `import` or `exposing` missing up-top? + +**import_exposing_alias.md:6:12:6:20:** +```roc + decoded = fromJson(encoded) +``` + ^^^^^^^^ + + # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:13),CloseSquare(1:13-1:14), -KwImport(3:1-3:7),LowerIdent(3:8-3:12),NoSpaceDotUpperIdent(3:12-3:17),KwExposing(3:18-3:26),OpenSquare(3:27-3:28),LowerIdent(3:28-3:34),KwAs(3:35-3:37),LowerIdent(3:38-3:46),Comma(3:46-3:47),LowerIdent(3:48-3:54),KwAs(3:55-3:57),LowerIdent(3:58-3:64),CloseSquare(3:64-3:65), -LowerIdent(5:1-5:5),OpAssign(5:6-5:7),OpenCurly(5:8-5:9), -LowerIdent(6:2-6:6),OpAssign(6:7-6:8),OpenCurly(6:9-6:10),LowerIdent(6:11-6:15),OpColon(6:15-6:16),StringStart(6:17-6:18),StringPart(6:18-6:21),StringEnd(6:21-6:22),Comma(6:22-6:23),LowerIdent(6:24-6:27),OpColon(6:27-6:28),Int(6:29-6:31),CloseCurly(6:32-6:33), -LowerIdent(7:2-7:9),OpAssign(7:10-7:11),LowerIdent(7:12-7:18),NoSpaceOpenRound(7:18-7:19),LowerIdent(7:19-7:23),CloseRound(7:23-7:24), -LowerIdent(8:2-8:9),OpAssign(8:10-8:11),LowerIdent(8:12-8:20),NoSpaceOpenRound(8:20-8:21),LowerIdent(8:21-8:28),CloseRound(8:28-8:29), -LowerIdent(9:2-9:9), -CloseCurly(10:1-10:2), -EndOfFile(11:1-11:1), +KwImport(1:1-1:7),LowerIdent(1:8-1:12),NoSpaceDotUpperIdent(1:12-1:17),KwExposing(1:18-1:26),OpenSquare(1:27-1:28),LowerIdent(1:28-1:34),KwAs(1:35-1:37),LowerIdent(1:38-1:46),Comma(1:46-1:47),LowerIdent(1:48-1:54),KwAs(1:55-1:57),LowerIdent(1:58-1:64),CloseSquare(1:64-1:65), +LowerIdent(3:1-3:5),OpAssign(3:6-3:7),OpenCurly(3:8-3:9), +LowerIdent(4:2-4:6),OpAssign(4:7-4:8),OpenCurly(4:9-4:10),LowerIdent(4:11-4:15),OpColon(4:15-4:16),StringStart(4:17-4:18),StringPart(4:18-4:21),StringEnd(4:21-4:22),Comma(4:22-4:23),LowerIdent(4:24-4:27),OpColon(4:27-4:28),Int(4:29-4:31),CloseCurly(4:32-4:33), +LowerIdent(5:2-5:9),OpAssign(5:10-5:11),LowerIdent(5:12-5:18),NoSpaceOpenRound(5:18-5:19),LowerIdent(5:19-5:23),CloseRound(5:23-5:24), +LowerIdent(6:2-6:9),OpAssign(6:10-6:11),LowerIdent(6:12-6:20),NoSpaceOpenRound(6:20-6:21),LowerIdent(6:21-6:28),CloseRound(6:28-6:29), +LowerIdent(7:2-7:9), +CloseCurly(8:1-8:2), +EndOfFile(9:1-9:1), ~~~ # PARSE ~~~clojure -(file @1.1-10.2 - (module @1.1-1.14 - (exposes @1.8-1.14 - (exposed-lower-ident @1.9-1.13 - (text "main")))) +(file @1.1-8.2 + (type-module @1.1-1.7) (statements - (s-import @3.1-3.65 (raw "json.Json") + (s-import @1.1-1.65 (raw "json.Json") (exposing - (exposed-lower-ident @3.28-3.46 + (exposed-lower-ident @1.28-1.46 (text "decode") (as "fromJson")) - (exposed-lower-ident @3.48-3.64 + (exposed-lower-ident @1.48-1.64 (text "encode") (as "toJson")))) - (s-decl @5.1-10.2 - (p-ident @5.1-5.5 (raw "main")) - (e-block @5.8-10.2 + (s-decl @3.1-8.2 + (p-ident @3.1-3.5 (raw "main")) + (e-block @3.8-8.2 (statements - (s-decl @6.2-6.33 - (p-ident @6.2-6.6 (raw "data")) - (e-record @6.9-6.33 + (s-decl @4.2-4.33 + (p-ident @4.2-4.6 (raw "data")) + (e-record @4.9-4.33 (field (field "name") - (e-string @6.17-6.22 - (e-string-part @6.18-6.21 (raw "Bob")))) + (e-string @4.17-4.22 + (e-string-part @4.18-4.21 (raw "Bob")))) (field (field "age") - (e-int @6.29-6.31 (raw "25"))))) - (s-decl @7.2-7.24 - (p-ident @7.2-7.9 (raw "encoded")) - (e-apply @7.12-7.24 - (e-ident @7.12-7.18 (raw "toJson")) - (e-ident @7.19-7.23 (raw "data")))) - (s-decl @8.2-8.29 - (p-ident @8.2-8.9 (raw "decoded")) - (e-apply @8.12-8.29 - (e-ident @8.12-8.20 (raw "fromJson")) - (e-ident @8.21-8.28 (raw "encoded")))) - (e-ident @9.2-9.9 (raw "decoded"))))))) + (e-int @4.29-4.31 (raw "25"))))) + (s-decl @5.2-5.24 + (p-ident @5.2-5.9 (raw "encoded")) + (e-apply @5.12-5.24 + (e-ident @5.12-5.18 (raw "toJson")) + (e-ident @5.19-5.23 (raw "data")))) + (s-decl @6.2-6.29 + (p-ident @6.2-6.9 (raw "decoded")) + (e-apply @6.12-6.29 + (e-ident @6.12-6.20 (raw "fromJson")) + (e-ident @6.21-6.28 (raw "encoded")))) + (e-ident @7.2-7.9 (raw "decoded"))))))) ~~~ # FORMATTED ~~~roc @@ -90,36 +108,32 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @5.1-5.5 (ident "main")) - (e-block @5.8-10.2 - (s-let @6.2-6.33 - (p-assign @6.2-6.6 (ident "data")) - (e-record @6.9-6.33 + (p-assign @3.1-3.5 (ident "main")) + (e-block @3.8-8.2 + (s-let @4.2-4.33 + (p-assign @4.2-4.6 (ident "data")) + (e-record @4.9-4.33 (fields (field (name "name") - (e-string @6.17-6.22 - (e-literal @6.18-6.21 (string "Bob")))) + (e-string @4.17-4.22 + (e-literal @4.18-4.21 (string "Bob")))) (field (name "age") - (e-int @6.29-6.31 (value "25")))))) - (s-let @7.2-7.24 - (p-assign @7.2-7.9 (ident "encoded")) - (e-call @7.12-7.24 - (e-lookup-external @7.12-7.18 - (module-idx "0") - (target-node-idx "0")) - (e-lookup-local @7.19-7.23 - (p-assign @6.2-6.6 (ident "data"))))) - (s-let @8.2-8.29 - (p-assign @8.2-8.9 (ident "decoded")) - (e-call @8.12-8.29 - (e-lookup-external @8.12-8.20 - (module-idx "0") - (target-node-idx "0")) - (e-lookup-local @8.21-8.28 - (p-assign @7.2-7.9 (ident "encoded"))))) - (e-lookup-local @9.2-9.9 - (p-assign @8.2-8.9 (ident "decoded"))))) - (s-import @3.1-3.65 (module "json.Json") (qualifier "json") + (e-num @4.29-4.31 (value "25")))))) + (s-let @5.2-5.24 + (p-assign @5.2-5.9 (ident "encoded")) + (e-call @5.12-5.24 + (e-runtime-error (tag "ident_not_in_scope")) + (e-lookup-local @5.19-5.23 + (p-assign @4.2-4.6 (ident "data"))))) + (s-let @6.2-6.29 + (p-assign @6.2-6.9 (ident "decoded")) + (e-call @6.12-6.29 + (e-runtime-error (tag "ident_not_in_scope")) + (e-lookup-local @6.21-6.28 + (p-assign @5.2-5.9 (ident "encoded"))))) + (e-lookup-local @7.2-7.9 + (p-assign @6.2-6.9 (ident "decoded"))))) + (s-import @1.1-1.65 (module "json.Json") (qualifier "json") (exposes (exposed (name "decode") (alias "fromJson") (wildcard false)) (exposed (name "encode") (alias "toJson") (wildcard false))))) @@ -128,7 +142,7 @@ NO CHANGE ~~~clojure (inferred-types (defs - (patt @5.1-5.5 (type "_a"))) + (patt @3.1-3.5 (type "_a"))) (expressions - (expr @5.8-10.2 (type "_a")))) + (expr @3.8-8.2 (type "_a")))) ~~~ diff --git a/test/snapshots/import_exposing_basic.md b/test/snapshots/import_exposing_basic.md index baad922add..f432c71e9c 100644 --- a/test/snapshots/import_exposing_basic.md +++ b/test/snapshots/import_exposing_basic.md @@ -1,12 +1,10 @@ # META ~~~ini description=Import with exposing clause and usage of exposed items -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [main] - import json.Json exposing [decode, encode] main = { @@ -17,73 +15,91 @@ main = { } ~~~ # EXPECTED -MODULE NOT FOUND - import_exposing_basic.md:3:1:3:43 +MODULE NOT FOUND - import_exposing_basic.md:1:1:1:43 +UNDEFINED VARIABLE - import_exposing_basic.md:5:15:5:21 +UNDEFINED VARIABLE - import_exposing_basic.md:6:15:6:21 # PROBLEMS **MODULE NOT FOUND** The module `json.Json` was not found in this Roc project. You're attempting to use this module here: -**import_exposing_basic.md:3:1:3:43:** +**import_exposing_basic.md:1:1:1:43:** ```roc import json.Json exposing [decode, encode] ``` ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +**UNDEFINED VARIABLE** +Nothing is named `encode` in this scope. +Is there an `import` or `exposing` missing up-top? + +**import_exposing_basic.md:5:15:5:21:** +```roc + encoded = encode(data) +``` + ^^^^^^ + + +**UNDEFINED VARIABLE** +Nothing is named `decode` in this scope. +Is there an `import` or `exposing` missing up-top? + +**import_exposing_basic.md:6:15:6:21:** +```roc + decoded = decode(encoded) +``` + ^^^^^^ + + # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:13),CloseSquare(1:13-1:14), -KwImport(3:1-3:7),LowerIdent(3:8-3:12),NoSpaceDotUpperIdent(3:12-3:17),KwExposing(3:18-3:26),OpenSquare(3:27-3:28),LowerIdent(3:28-3:34),Comma(3:34-3:35),LowerIdent(3:36-3:42),CloseSquare(3:42-3:43), -LowerIdent(5:1-5:5),OpAssign(5:6-5:7),OpenCurly(5:8-5:9), -LowerIdent(6:5-6:9),OpAssign(6:10-6:11),OpenCurly(6:12-6:13),LowerIdent(6:14-6:18),OpColon(6:18-6:19),StringStart(6:20-6:21),StringPart(6:21-6:26),StringEnd(6:26-6:27),Comma(6:27-6:28),LowerIdent(6:29-6:32),OpColon(6:32-6:33),Int(6:34-6:36),CloseCurly(6:37-6:38), -LowerIdent(7:5-7:12),OpAssign(7:13-7:14),LowerIdent(7:15-7:21),NoSpaceOpenRound(7:21-7:22),LowerIdent(7:22-7:26),CloseRound(7:26-7:27), -LowerIdent(8:5-8:12),OpAssign(8:13-8:14),LowerIdent(8:15-8:21),NoSpaceOpenRound(8:21-8:22),LowerIdent(8:22-8:29),CloseRound(8:29-8:30), -LowerIdent(9:5-9:12), -CloseCurly(10:1-10:2), -EndOfFile(11:1-11:1), +KwImport(1:1-1:7),LowerIdent(1:8-1:12),NoSpaceDotUpperIdent(1:12-1:17),KwExposing(1:18-1:26),OpenSquare(1:27-1:28),LowerIdent(1:28-1:34),Comma(1:34-1:35),LowerIdent(1:36-1:42),CloseSquare(1:42-1:43), +LowerIdent(3:1-3:5),OpAssign(3:6-3:7),OpenCurly(3:8-3:9), +LowerIdent(4:5-4:9),OpAssign(4:10-4:11),OpenCurly(4:12-4:13),LowerIdent(4:14-4:18),OpColon(4:18-4:19),StringStart(4:20-4:21),StringPart(4:21-4:26),StringEnd(4:26-4:27),Comma(4:27-4:28),LowerIdent(4:29-4:32),OpColon(4:32-4:33),Int(4:34-4:36),CloseCurly(4:37-4:38), +LowerIdent(5:5-5:12),OpAssign(5:13-5:14),LowerIdent(5:15-5:21),NoSpaceOpenRound(5:21-5:22),LowerIdent(5:22-5:26),CloseRound(5:26-5:27), +LowerIdent(6:5-6:12),OpAssign(6:13-6:14),LowerIdent(6:15-6:21),NoSpaceOpenRound(6:21-6:22),LowerIdent(6:22-6:29),CloseRound(6:29-6:30), +LowerIdent(7:5-7:12), +CloseCurly(8:1-8:2), +EndOfFile(9:1-9:1), ~~~ # PARSE ~~~clojure -(file @1.1-10.2 - (module @1.1-1.14 - (exposes @1.8-1.14 - (exposed-lower-ident @1.9-1.13 - (text "main")))) +(file @1.1-8.2 + (type-module @1.1-1.7) (statements - (s-import @3.1-3.43 (raw "json.Json") + (s-import @1.1-1.43 (raw "json.Json") (exposing - (exposed-lower-ident @3.28-3.34 + (exposed-lower-ident @1.28-1.34 (text "decode")) - (exposed-lower-ident @3.36-3.42 + (exposed-lower-ident @1.36-1.42 (text "encode")))) - (s-decl @5.1-10.2 - (p-ident @5.1-5.5 (raw "main")) - (e-block @5.8-10.2 + (s-decl @3.1-8.2 + (p-ident @3.1-3.5 (raw "main")) + (e-block @3.8-8.2 (statements - (s-decl @6.5-6.38 - (p-ident @6.5-6.9 (raw "data")) - (e-record @6.12-6.38 + (s-decl @4.5-4.38 + (p-ident @4.5-4.9 (raw "data")) + (e-record @4.12-4.38 (field (field "name") - (e-string @6.20-6.27 - (e-string-part @6.21-6.26 (raw "Alice")))) + (e-string @4.20-4.27 + (e-string-part @4.21-4.26 (raw "Alice")))) (field (field "age") - (e-int @6.34-6.36 (raw "30"))))) - (s-decl @7.5-7.27 - (p-ident @7.5-7.12 (raw "encoded")) - (e-apply @7.15-7.27 - (e-ident @7.15-7.21 (raw "encode")) - (e-ident @7.22-7.26 (raw "data")))) - (s-decl @8.5-8.30 - (p-ident @8.5-8.12 (raw "decoded")) - (e-apply @8.15-8.30 - (e-ident @8.15-8.21 (raw "decode")) - (e-ident @8.22-8.29 (raw "encoded")))) - (e-ident @9.5-9.12 (raw "decoded"))))))) + (e-int @4.34-4.36 (raw "30"))))) + (s-decl @5.5-5.27 + (p-ident @5.5-5.12 (raw "encoded")) + (e-apply @5.15-5.27 + (e-ident @5.15-5.21 (raw "encode")) + (e-ident @5.22-5.26 (raw "data")))) + (s-decl @6.5-6.30 + (p-ident @6.5-6.12 (raw "decoded")) + (e-apply @6.15-6.30 + (e-ident @6.15-6.21 (raw "decode")) + (e-ident @6.22-6.29 (raw "encoded")))) + (e-ident @7.5-7.12 (raw "decoded"))))))) ~~~ # FORMATTED ~~~roc -module [main] - import json.Json exposing [decode, encode] main = { @@ -97,36 +113,32 @@ main = { ~~~clojure (can-ir (d-let - (p-assign @5.1-5.5 (ident "main")) - (e-block @5.8-10.2 - (s-let @6.5-6.38 - (p-assign @6.5-6.9 (ident "data")) - (e-record @6.12-6.38 + (p-assign @3.1-3.5 (ident "main")) + (e-block @3.8-8.2 + (s-let @4.5-4.38 + (p-assign @4.5-4.9 (ident "data")) + (e-record @4.12-4.38 (fields (field (name "name") - (e-string @6.20-6.27 - (e-literal @6.21-6.26 (string "Alice")))) + (e-string @4.20-4.27 + (e-literal @4.21-4.26 (string "Alice")))) (field (name "age") - (e-int @6.34-6.36 (value "30")))))) - (s-let @7.5-7.27 - (p-assign @7.5-7.12 (ident "encoded")) - (e-call @7.15-7.27 - (e-lookup-external @7.15-7.21 - (module-idx "0") - (target-node-idx "0")) - (e-lookup-local @7.22-7.26 - (p-assign @6.5-6.9 (ident "data"))))) - (s-let @8.5-8.30 - (p-assign @8.5-8.12 (ident "decoded")) - (e-call @8.15-8.30 - (e-lookup-external @8.15-8.21 - (module-idx "0") - (target-node-idx "0")) - (e-lookup-local @8.22-8.29 - (p-assign @7.5-7.12 (ident "encoded"))))) - (e-lookup-local @9.5-9.12 - (p-assign @8.5-8.12 (ident "decoded"))))) - (s-import @3.1-3.43 (module "json.Json") (qualifier "json") + (e-num @4.34-4.36 (value "30")))))) + (s-let @5.5-5.27 + (p-assign @5.5-5.12 (ident "encoded")) + (e-call @5.15-5.27 + (e-runtime-error (tag "ident_not_in_scope")) + (e-lookup-local @5.22-5.26 + (p-assign @4.5-4.9 (ident "data"))))) + (s-let @6.5-6.30 + (p-assign @6.5-6.12 (ident "decoded")) + (e-call @6.15-6.30 + (e-runtime-error (tag "ident_not_in_scope")) + (e-lookup-local @6.22-6.29 + (p-assign @5.5-5.12 (ident "encoded"))))) + (e-lookup-local @7.5-7.12 + (p-assign @6.5-6.12 (ident "decoded"))))) + (s-import @1.1-1.43 (module "json.Json") (qualifier "json") (exposes (exposed (name "decode") (wildcard false)) (exposed (name "encode") (wildcard false))))) @@ -135,7 +147,7 @@ main = { ~~~clojure (inferred-types (defs - (patt @5.1-5.5 (type "_a"))) + (patt @3.1-3.5 (type "_a"))) (expressions - (expr @5.8-10.2 (type "_a")))) + (expr @3.8-8.2 (type "_a")))) ~~~ diff --git a/test/snapshots/issue/minimal_underscore.md b/test/snapshots/issue/minimal_underscore.md index 72e1058127..db9889cca4 100644 --- a/test/snapshots/issue/minimal_underscore.md +++ b/test/snapshots/issue/minimal_underscore.md @@ -1,12 +1,10 @@ # META ~~~ini description=Minimal test - underscore type should become error type -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - BadType := _ ~~~ # EXPECTED @@ -17,7 +15,7 @@ Underscores are not allowed in type alias declarations. **minimal_underscore.md:1:1:1:1:** ```roc -module [] +BadType := _ ``` ^ @@ -25,18 +23,16 @@ Underscores in type annotations mean "I don't care about this type", which doesn # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -UpperIdent(3:1-3:8),OpColonEqual(3:9-3:11),Underscore(3:12-3:13), -EndOfFile(4:1-4:1), +UpperIdent(1:1-1:8),OpColonEqual(1:9-1:11),Underscore(1:12-1:13), +EndOfFile(2:1-2:1), ~~~ # PARSE ~~~clojure -(file @1.1-3.13 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-1.13 + (type-module @1.1-1.8) (statements - (s-type-decl @3.1-3.13 - (header @3.1-3.8 (name "BadType") + (s-type-decl @1.1-1.13 + (header @1.1-1.8 (name "BadType") (args)) (_)))) ~~~ @@ -47,8 +43,8 @@ NO CHANGE # CANONICALIZE ~~~clojure (can-ir - (s-nominal-decl @3.1-3.13 - (ty-header @3.1-3.8 (name "BadType")) + (s-nominal-decl @1.1-1.13 + (ty-header @1.1-1.8 (name "BadType")) (ty-underscore @1.1-1.1))) ~~~ # TYPES @@ -56,7 +52,7 @@ NO CHANGE (inferred-types (defs) (type_decls - (nominal @3.1-3.13 (type "Error") - (ty-header @3.1-3.8 (name "BadType")))) + (nominal @1.1-1.13 (type "BadType") + (ty-header @1.1-1.8 (name "BadType")))) (expressions)) ~~~ diff --git a/test/snapshots/issue/simple_underscore_error.md b/test/snapshots/issue/simple_underscore_error.md index 1b8ced23b5..4c63c4aa3f 100644 --- a/test/snapshots/issue/simple_underscore_error.md +++ b/test/snapshots/issue/simple_underscore_error.md @@ -1,12 +1,10 @@ # META ~~~ini description=Simple test for single underscore type becoming error type -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - BadType := _ foo : BadType @@ -14,41 +12,54 @@ foo = 42 ~~~ # EXPECTED UNDERSCORE IN TYPE ALIAS - simple_underscore_error.md:1:1:1:1 +TYPE MISMATCH - simple_underscore_error.md:4:7:4:9 # PROBLEMS **UNDERSCORE IN TYPE ALIAS** Underscores are not allowed in type alias declarations. **simple_underscore_error.md:1:1:1:1:** ```roc -module [] +BadType := _ ``` ^ Underscores in type annotations mean "I don't care about this type", which doesn't make sense when declaring a type. If you need a placeholder type variable, use a named type variable like `a` instead. +**TYPE MISMATCH** +This expression is used in an unexpected way: +**simple_underscore_error.md:4:7:4:9:** +```roc +foo = 42 +``` + ^^ + +It has the type: + _Num(_size)_ + +But the type annotation says it should have the type: + _BadType_ + # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -UpperIdent(3:1-3:8),OpColonEqual(3:9-3:11),Underscore(3:12-3:13), -LowerIdent(5:1-5:4),OpColon(5:5-5:6),UpperIdent(5:7-5:14), -LowerIdent(6:1-6:4),OpAssign(6:5-6:6),Int(6:7-6:9), -EndOfFile(7:1-7:1), +UpperIdent(1:1-1:8),OpColonEqual(1:9-1:11),Underscore(1:12-1:13), +LowerIdent(3:1-3:4),OpColon(3:5-3:6),UpperIdent(3:7-3:14), +LowerIdent(4:1-4:4),OpAssign(4:5-4:6),Int(4:7-4:9), +EndOfFile(5:1-5:1), ~~~ # PARSE ~~~clojure -(file @1.1-6.9 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-4.9 + (type-module @1.1-1.8) (statements - (s-type-decl @3.1-3.13 - (header @3.1-3.8 (name "BadType") + (s-type-decl @1.1-1.13 + (header @1.1-1.8 (name "BadType") (args)) (_)) - (s-type-anno @5.1-5.14 (name "foo") - (ty @5.7-5.14 (name "BadType"))) - (s-decl @6.1-6.9 - (p-ident @6.1-6.4 (raw "foo")) - (e-int @6.7-6.9 (raw "42"))))) + (s-type-anno @3.1-3.14 (name "foo") + (ty @3.7-3.14 (name "BadType"))) + (s-decl @4.1-4.9 + (p-ident @4.1-4.4 (raw "foo")) + (e-int @4.7-4.9 (raw "42"))))) ~~~ # FORMATTED ~~~roc @@ -58,23 +69,23 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @6.1-6.4 (ident "foo")) - (e-int @6.7-6.9 (value "42")) - (annotation @6.1-6.4 + (p-assign @4.1-4.4 (ident "foo")) + (e-num @4.7-4.9 (value "42")) + (annotation @4.1-4.4 (declared-type - (ty @5.7-5.14 (name "BadType"))))) - (s-nominal-decl @3.1-3.13 - (ty-header @3.1-3.8 (name "BadType")) + (ty-lookup @3.7-3.14 (name "BadType") (local))))) + (s-nominal-decl @1.1-1.13 + (ty-header @1.1-1.8 (name "BadType")) (ty-underscore @1.1-1.1))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @6.1-6.4 (type "Error"))) + (patt @4.1-4.4 (type "Error"))) (type_decls - (nominal @3.1-3.13 (type "Error") - (ty-header @3.1-3.8 (name "BadType")))) + (nominal @1.1-1.13 (type "BadType") + (ty-header @1.1-1.8 (name "BadType")))) (expressions - (expr @6.7-6.9 (type "Error")))) + (expr @4.7-4.9 (type "Error")))) ~~~ diff --git a/test/snapshots/issue/test_error_propagation.md b/test/snapshots/issue/test_error_propagation.md index 7db377af18..b159a46def 100644 --- a/test/snapshots/issue/test_error_propagation.md +++ b/test/snapshots/issue/test_error_propagation.md @@ -1,12 +1,10 @@ # META ~~~ini description=Test error propagation - aliases that reference error types should not propagate errors -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - BadBase := _ GoodAlias := BadBase @@ -16,47 +14,60 @@ value = "test" ~~~ # EXPECTED UNDERSCORE IN TYPE ALIAS - test_error_propagation.md:1:1:1:1 +TYPE MISMATCH - test_error_propagation.md:6:9:6:15 # PROBLEMS **UNDERSCORE IN TYPE ALIAS** Underscores are not allowed in type alias declarations. **test_error_propagation.md:1:1:1:1:** ```roc -module [] +BadBase := _ ``` ^ Underscores in type annotations mean "I don't care about this type", which doesn't make sense when declaring a type. If you need a placeholder type variable, use a named type variable like `a` instead. +**TYPE MISMATCH** +This expression is used in an unexpected way: +**test_error_propagation.md:6:9:6:15:** +```roc +value = "test" +``` + ^^^^^^ + +It has the type: + _Str_ + +But the type annotation says it should have the type: + _GoodAlias_ + # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -UpperIdent(3:1-3:8),OpColonEqual(3:9-3:11),Underscore(3:12-3:13), -UpperIdent(5:1-5:10),OpColonEqual(5:11-5:13),UpperIdent(5:14-5:21), -LowerIdent(7:1-7:6),OpColon(7:7-7:8),UpperIdent(7:9-7:18), -LowerIdent(8:1-8:6),OpAssign(8:7-8:8),StringStart(8:9-8:10),StringPart(8:10-8:14),StringEnd(8:14-8:15), -EndOfFile(9:1-9:1), +UpperIdent(1:1-1:8),OpColonEqual(1:9-1:11),Underscore(1:12-1:13), +UpperIdent(3:1-3:10),OpColonEqual(3:11-3:13),UpperIdent(3:14-3:21), +LowerIdent(5:1-5:6),OpColon(5:7-5:8),UpperIdent(5:9-5:18), +LowerIdent(6:1-6:6),OpAssign(6:7-6:8),StringStart(6:9-6:10),StringPart(6:10-6:14),StringEnd(6:14-6:15), +EndOfFile(7:1-7:1), ~~~ # PARSE ~~~clojure -(file @1.1-8.15 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-6.15 + (type-module @1.1-1.8) (statements - (s-type-decl @3.1-3.13 - (header @3.1-3.8 (name "BadBase") + (s-type-decl @1.1-1.13 + (header @1.1-1.8 (name "BadBase") (args)) (_)) - (s-type-decl @5.1-5.21 - (header @5.1-5.10 (name "GoodAlias") + (s-type-decl @3.1-3.21 + (header @3.1-3.10 (name "GoodAlias") (args)) - (ty @5.14-5.21 (name "BadBase"))) - (s-type-anno @7.1-7.18 (name "value") - (ty @7.9-7.18 (name "GoodAlias"))) - (s-decl @8.1-8.15 - (p-ident @8.1-8.6 (raw "value")) - (e-string @8.9-8.15 - (e-string-part @8.10-8.14 (raw "test")))))) + (ty @3.14-3.21 (name "BadBase"))) + (s-type-anno @5.1-5.18 (name "value") + (ty @5.9-5.18 (name "GoodAlias"))) + (s-decl @6.1-6.15 + (p-ident @6.1-6.6 (raw "value")) + (e-string @6.9-6.15 + (e-string-part @6.10-6.14 (raw "test")))))) ~~~ # FORMATTED ~~~roc @@ -66,29 +77,29 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @8.1-8.6 (ident "value")) - (e-string @8.9-8.15 - (e-literal @8.10-8.14 (string "test"))) - (annotation @8.1-8.6 + (p-assign @6.1-6.6 (ident "value")) + (e-string @6.9-6.15 + (e-literal @6.10-6.14 (string "test"))) + (annotation @6.1-6.6 (declared-type - (ty @7.9-7.18 (name "GoodAlias"))))) - (s-nominal-decl @3.1-3.13 - (ty-header @3.1-3.8 (name "BadBase")) + (ty-lookup @5.9-5.18 (name "GoodAlias") (local))))) + (s-nominal-decl @1.1-1.13 + (ty-header @1.1-1.8 (name "BadBase")) (ty-underscore @1.1-1.1)) - (s-nominal-decl @5.1-5.21 - (ty-header @5.1-5.10 (name "GoodAlias")) - (ty @5.14-5.21 (name "BadBase")))) + (s-nominal-decl @3.1-3.21 + (ty-header @3.1-3.10 (name "GoodAlias")) + (ty-lookup @3.14-3.21 (name "BadBase") (local)))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @8.1-8.6 (type "Error"))) + (patt @6.1-6.6 (type "Error"))) (type_decls - (nominal @3.1-3.13 (type "Error") - (ty-header @3.1-3.8 (name "BadBase"))) - (nominal @5.1-5.21 (type "Error") - (ty-header @5.1-5.10 (name "GoodAlias")))) + (nominal @1.1-1.13 (type "BadBase") + (ty-header @1.1-1.8 (name "BadBase"))) + (nominal @3.1-3.21 (type "GoodAlias") + (ty-header @3.1-3.10 (name "GoodAlias")))) (expressions - (expr @8.9-8.15 (type "Error")))) + (expr @6.9-6.15 (type "Error")))) ~~~ diff --git a/test/snapshots/issue/underscore_error_propagation.md b/test/snapshots/issue/underscore_error_propagation.md index 5f19da7dc7..ebc68b2c8b 100644 --- a/test/snapshots/issue/underscore_error_propagation.md +++ b/test/snapshots/issue/underscore_error_propagation.md @@ -1,12 +1,10 @@ # META ~~~ini description=Error types should propagate through aliases when underscores are used -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - BadBase := _ BadDerived := BadBase @@ -23,14 +21,15 @@ goodValue = "test" ~~~ # EXPECTED UNDERSCORE IN TYPE ALIAS - underscore_error_propagation.md:1:1:1:1 -TYPE MISMATCH - underscore_error_propagation.md:15:13:15:19 +TYPE MISMATCH - underscore_error_propagation.md:6:9:6:15 +TYPE MISMATCH - underscore_error_propagation.md:13:13:13:19 # PROBLEMS **UNDERSCORE IN TYPE ALIAS** Underscores are not allowed in type alias declarations. **underscore_error_propagation.md:1:1:1:1:** ```roc -module [] +BadBase := _ ``` ^ @@ -38,65 +37,77 @@ Underscores in type annotations mean "I don't care about this type", which doesn **TYPE MISMATCH** This expression is used in an unexpected way: -**underscore_error_propagation.md:15:13:15:19:** +**underscore_error_propagation.md:6:9:6:15:** +```roc +value = "test" +``` + ^^^^^^ + +It has the type: + _Str_ + +But the type annotation says it should have the type: + _BadDerived_ + +**TYPE MISMATCH** +This expression is used in an unexpected way: +**underscore_error_propagation.md:13:13:13:19:** ```roc goodValue = "test" ``` ^^^^^^ -The type annotation says it should have the type: - _GoodDerived_ - -But here it's being used as: +It has the type: _Str_ +But the type annotation says it should have the type: + _GoodDerived_ + # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -UpperIdent(3:1-3:8),OpColonEqual(3:9-3:11),Underscore(3:12-3:13), -UpperIdent(5:1-5:11),OpColonEqual(5:12-5:14),UpperIdent(5:15-5:22), -LowerIdent(7:1-7:6),OpColon(7:7-7:8),UpperIdent(7:9-7:19), -LowerIdent(8:1-8:6),OpAssign(8:7-8:8),StringStart(8:9-8:10),StringPart(8:10-8:14),StringEnd(8:14-8:15), -UpperIdent(10:1-10:9),OpColonEqual(10:10-10:12),UpperIdent(10:13-10:16), -UpperIdent(12:1-12:12),OpColonEqual(12:13-12:15),UpperIdent(12:16-12:24), -LowerIdent(14:1-14:10),OpColon(14:11-14:12),UpperIdent(14:13-14:24), -LowerIdent(15:1-15:10),OpAssign(15:11-15:12),StringStart(15:13-15:14),StringPart(15:14-15:18),StringEnd(15:18-15:19), -EndOfFile(16:1-16:1), +UpperIdent(1:1-1:8),OpColonEqual(1:9-1:11),Underscore(1:12-1:13), +UpperIdent(3:1-3:11),OpColonEqual(3:12-3:14),UpperIdent(3:15-3:22), +LowerIdent(5:1-5:6),OpColon(5:7-5:8),UpperIdent(5:9-5:19), +LowerIdent(6:1-6:6),OpAssign(6:7-6:8),StringStart(6:9-6:10),StringPart(6:10-6:14),StringEnd(6:14-6:15), +UpperIdent(8:1-8:9),OpColonEqual(8:10-8:12),UpperIdent(8:13-8:16), +UpperIdent(10:1-10:12),OpColonEqual(10:13-10:15),UpperIdent(10:16-10:24), +LowerIdent(12:1-12:10),OpColon(12:11-12:12),UpperIdent(12:13-12:24), +LowerIdent(13:1-13:10),OpAssign(13:11-13:12),StringStart(13:13-13:14),StringPart(13:14-13:18),StringEnd(13:18-13:19), +EndOfFile(14:1-14:1), ~~~ # PARSE ~~~clojure -(file @1.1-15.19 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-13.19 + (type-module @1.1-1.8) (statements - (s-type-decl @3.1-3.13 - (header @3.1-3.8 (name "BadBase") + (s-type-decl @1.1-1.13 + (header @1.1-1.8 (name "BadBase") (args)) (_)) - (s-type-decl @5.1-5.22 - (header @5.1-5.11 (name "BadDerived") + (s-type-decl @3.1-3.22 + (header @3.1-3.11 (name "BadDerived") (args)) - (ty @5.15-5.22 (name "BadBase"))) - (s-type-anno @7.1-7.19 (name "value") - (ty @7.9-7.19 (name "BadDerived"))) - (s-decl @8.1-8.15 - (p-ident @8.1-8.6 (raw "value")) - (e-string @8.9-8.15 - (e-string-part @8.10-8.14 (raw "test")))) - (s-type-decl @10.1-10.16 - (header @10.1-10.9 (name "GoodBase") + (ty @3.15-3.22 (name "BadBase"))) + (s-type-anno @5.1-5.19 (name "value") + (ty @5.9-5.19 (name "BadDerived"))) + (s-decl @6.1-6.15 + (p-ident @6.1-6.6 (raw "value")) + (e-string @6.9-6.15 + (e-string-part @6.10-6.14 (raw "test")))) + (s-type-decl @8.1-8.16 + (header @8.1-8.9 (name "GoodBase") (args)) - (ty @10.13-10.16 (name "Str"))) - (s-type-decl @12.1-12.24 - (header @12.1-12.12 (name "GoodDerived") + (ty @8.13-8.16 (name "Str"))) + (s-type-decl @10.1-10.24 + (header @10.1-10.12 (name "GoodDerived") (args)) - (ty @12.16-12.24 (name "GoodBase"))) - (s-type-anno @14.1-14.24 (name "goodValue") - (ty @14.13-14.24 (name "GoodDerived"))) - (s-decl @15.1-15.19 - (p-ident @15.1-15.10 (raw "goodValue")) - (e-string @15.13-15.19 - (e-string-part @15.14-15.18 (raw "test")))))) + (ty @10.16-10.24 (name "GoodBase"))) + (s-type-anno @12.1-12.24 (name "goodValue") + (ty @12.13-12.24 (name "GoodDerived"))) + (s-decl @13.1-13.19 + (p-ident @13.1-13.10 (raw "goodValue")) + (e-string @13.13-13.19 + (e-string-part @13.14-13.18 (raw "test")))))) ~~~ # FORMATTED ~~~roc @@ -106,48 +117,48 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @8.1-8.6 (ident "value")) - (e-string @8.9-8.15 - (e-literal @8.10-8.14 (string "test"))) - (annotation @8.1-8.6 + (p-assign @6.1-6.6 (ident "value")) + (e-string @6.9-6.15 + (e-literal @6.10-6.14 (string "test"))) + (annotation @6.1-6.6 (declared-type - (ty @7.9-7.19 (name "BadDerived"))))) + (ty-lookup @5.9-5.19 (name "BadDerived") (local))))) (d-let - (p-assign @15.1-15.10 (ident "goodValue")) - (e-string @15.13-15.19 - (e-literal @15.14-15.18 (string "test"))) - (annotation @15.1-15.10 + (p-assign @13.1-13.10 (ident "goodValue")) + (e-string @13.13-13.19 + (e-literal @13.14-13.18 (string "test"))) + (annotation @13.1-13.10 (declared-type - (ty @14.13-14.24 (name "GoodDerived"))))) - (s-nominal-decl @3.1-3.13 - (ty-header @3.1-3.8 (name "BadBase")) + (ty-lookup @12.13-12.24 (name "GoodDerived") (local))))) + (s-nominal-decl @1.1-1.13 + (ty-header @1.1-1.8 (name "BadBase")) (ty-underscore @1.1-1.1)) - (s-nominal-decl @5.1-5.22 - (ty-header @5.1-5.11 (name "BadDerived")) - (ty @5.15-5.22 (name "BadBase"))) - (s-nominal-decl @10.1-10.16 - (ty-header @10.1-10.9 (name "GoodBase")) - (ty @10.13-10.16 (name "Str"))) - (s-nominal-decl @12.1-12.24 - (ty-header @12.1-12.12 (name "GoodDerived")) - (ty @12.16-12.24 (name "GoodBase")))) + (s-nominal-decl @3.1-3.22 + (ty-header @3.1-3.11 (name "BadDerived")) + (ty-lookup @3.15-3.22 (name "BadBase") (local))) + (s-nominal-decl @8.1-8.16 + (ty-header @8.1-8.9 (name "GoodBase")) + (ty-lookup @8.13-8.16 (name "Str") (builtin))) + (s-nominal-decl @10.1-10.24 + (ty-header @10.1-10.12 (name "GoodDerived")) + (ty-lookup @10.16-10.24 (name "GoodBase") (local)))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @8.1-8.6 (type "Error")) - (patt @15.1-15.10 (type "Error"))) + (patt @6.1-6.6 (type "Error")) + (patt @13.1-13.10 (type "Error"))) (type_decls - (nominal @3.1-3.13 (type "Error") - (ty-header @3.1-3.8 (name "BadBase"))) - (nominal @5.1-5.22 (type "Error") - (ty-header @5.1-5.11 (name "BadDerived"))) - (nominal @10.1-10.16 (type "GoodBase") - (ty-header @10.1-10.9 (name "GoodBase"))) - (nominal @12.1-12.24 (type "Error") - (ty-header @12.1-12.12 (name "GoodDerived")))) + (nominal @1.1-1.13 (type "BadBase") + (ty-header @1.1-1.8 (name "BadBase"))) + (nominal @3.1-3.22 (type "BadDerived") + (ty-header @3.1-3.11 (name "BadDerived"))) + (nominal @8.1-8.16 (type "GoodBase") + (ty-header @8.1-8.9 (name "GoodBase"))) + (nominal @10.1-10.24 (type "GoodDerived") + (ty-header @10.1-10.12 (name "GoodDerived")))) (expressions - (expr @8.9-8.15 (type "Error")) - (expr @15.13-15.19 (type "Error")))) + (expr @6.9-6.15 (type "Error")) + (expr @13.13-13.19 (type "Error")))) ~~~ diff --git a/test/snapshots/issue/underscore_error_type.md b/test/snapshots/issue/underscore_error_type.md index 7595b89cff..aa94c3467e 100644 --- a/test/snapshots/issue/underscore_error_type.md +++ b/test/snapshots/issue/underscore_error_type.md @@ -1,12 +1,10 @@ # META ~~~ini description=Type declarations with underscores should become error types that fail unification -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - BadType := _ foo : BadType @@ -34,18 +32,24 @@ quux = ("hello", 42) ~~~ # EXPECTED UNDERSCORE IN TYPE ALIAS - underscore_error_type.md:1:1:1:1 -UNDERSCORE IN TYPE ALIAS - underscore_error_type.md:8:17:8:17 +UNDERSCORE IN TYPE ALIAS - underscore_error_type.md:6:17:6:17 +UNDERSCORE IN TYPE ALIAS - underscore_error_type.md:6:12:6:16 UNDERSCORE IN TYPE ALIAS - underscore_error_type.md:1:1:1:1 UNDERSCORE IN TYPE ALIAS - underscore_error_type.md:1:1:1:1 UNDERSCORE IN TYPE ALIAS - underscore_error_type.md:1:1:1:1 -UNDERSCORE IN TYPE ALIAS - underscore_error_type.md:23:14:23:14 +UNDERSCORE IN TYPE ALIAS - underscore_error_type.md:21:14:21:14 +TYPE MISMATCH - underscore_error_type.md:4:7:4:9 +TYPE MISMATCH - underscore_error_type.md:9:7:9:16 +TYPE MISMATCH - underscore_error_type.md:14:7:14:32 +TYPE MISMATCH - underscore_error_type.md:19:7:19:12 +TYPE MISMATCH - underscore_error_type.md:24:8:24:21 # PROBLEMS **UNDERSCORE IN TYPE ALIAS** Underscores are not allowed in type alias declarations. **underscore_error_type.md:1:1:1:1:** ```roc -module [] +BadType := _ ``` ^ @@ -54,7 +58,7 @@ Underscores in type annotations mean "I don't care about this type", which doesn **UNDERSCORE IN TYPE ALIAS** Underscores are not allowed in type alias declarations. -**underscore_error_type.md:8:17:8:17:** +**underscore_error_type.md:6:17:6:17:** ```roc BadList := List(_) ``` @@ -65,9 +69,20 @@ Underscores in type annotations mean "I don't care about this type", which doesn **UNDERSCORE IN TYPE ALIAS** Underscores are not allowed in type alias declarations. +**underscore_error_type.md:6:12:6:16:** +```roc +BadList := List(_) +``` + ^^^^ + +Underscores in type annotations mean "I don't care about this type", which doesn't make sense when declaring a type. If you need a placeholder type variable, use a named type variable like `a` instead. + +**UNDERSCORE IN TYPE ALIAS** +Underscores are not allowed in type alias declarations. + **underscore_error_type.md:1:1:1:1:** ```roc -module [] +BadType := _ ``` ^ @@ -78,7 +93,7 @@ Underscores are not allowed in type alias declarations. **underscore_error_type.md:1:1:1:1:** ```roc -module [] +BadType := _ ``` ^ @@ -89,7 +104,7 @@ Underscores are not allowed in type alias declarations. **underscore_error_type.md:1:1:1:1:** ```roc -module [] +BadType := _ ``` ^ @@ -98,7 +113,7 @@ Underscores in type annotations mean "I don't care about this type", which doesn **UNDERSCORE IN TYPE ALIAS** Underscores are not allowed in type alias declarations. -**underscore_error_type.md:23:14:23:14:** +**underscore_error_type.md:21:14:21:14:** ```roc BadTuple := (_, U32) ``` @@ -106,106 +121,172 @@ BadTuple := (_, U32) Underscores in type annotations mean "I don't care about this type", which doesn't make sense when declaring a type. If you need a placeholder type variable, use a named type variable like `a` instead. +**TYPE MISMATCH** +This expression is used in an unexpected way: +**underscore_error_type.md:4:7:4:9:** +```roc +foo = 42 +``` + ^^ + +It has the type: + _Num(_size)_ + +But the type annotation says it should have the type: + _BadType_ + +**TYPE MISMATCH** +This expression is used in an unexpected way: +**underscore_error_type.md:9:7:9:16:** +```roc +bar = [1, 2, 3] +``` + ^^^^^^^^^ + +It has the type: + _List(Num(_size))_ + +But the type annotation says it should have the type: + _BadList_ + +**TYPE MISMATCH** +This expression is used in an unexpected way: +**underscore_error_type.md:14:7:14:32:** +```roc +baz = { field: "hi", other: 5 } +``` + ^^^^^^^^^^^^^^^^^^^^^^^^^ + +It has the type: + _{ field: Str, other: Num(_size) }_ + +But the type annotation says it should have the type: + _BadRecord_ + +**TYPE MISMATCH** +This expression is used in an unexpected way: +**underscore_error_type.md:19:7:19:12:** +```roc +qux = |x| x +``` + ^^^^^ + +It has the type: + _a -> a_ + +But the type annotation says it should have the type: + _BadFunction_ + +**TYPE MISMATCH** +This expression is used in an unexpected way: +**underscore_error_type.md:24:8:24:21:** +```roc +quux = ("hello", 42) +``` + ^^^^^^^^^^^^^ + +It has the type: + _(Str, Num(_size))_ + +But the type annotation says it should have the type: + _BadTuple_ + # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -UpperIdent(3:1-3:8),OpColonEqual(3:9-3:11),Underscore(3:12-3:13), -LowerIdent(5:1-5:4),OpColon(5:5-5:6),UpperIdent(5:7-5:14), -LowerIdent(6:1-6:4),OpAssign(6:5-6:6),Int(6:7-6:9), -UpperIdent(8:1-8:8),OpColonEqual(8:9-8:11),UpperIdent(8:12-8:16),NoSpaceOpenRound(8:16-8:17),Underscore(8:17-8:18),CloseRound(8:18-8:19), -LowerIdent(10:1-10:4),OpColon(10:5-10:6),UpperIdent(10:7-10:14), -LowerIdent(11:1-11:4),OpAssign(11:5-11:6),OpenSquare(11:7-11:8),Int(11:8-11:9),Comma(11:9-11:10),Int(11:11-11:12),Comma(11:12-11:13),Int(11:14-11:15),CloseSquare(11:15-11:16), -UpperIdent(13:1-13:10),OpColonEqual(13:11-13:13),OpenCurly(13:14-13:15),LowerIdent(13:16-13:21),OpColon(13:21-13:22),Underscore(13:23-13:24),Comma(13:24-13:25),LowerIdent(13:26-13:31),OpColon(13:31-13:32),UpperIdent(13:33-13:36),CloseCurly(13:37-13:38), -LowerIdent(15:1-15:4),OpColon(15:5-15:6),UpperIdent(15:7-15:16), -LowerIdent(16:1-16:4),OpAssign(16:5-16:6),OpenCurly(16:7-16:8),LowerIdent(16:9-16:14),OpColon(16:14-16:15),StringStart(16:16-16:17),StringPart(16:17-16:19),StringEnd(16:19-16:20),Comma(16:20-16:21),LowerIdent(16:22-16:27),OpColon(16:27-16:28),Int(16:29-16:30),CloseCurly(16:31-16:32), -UpperIdent(18:1-18:12),OpColonEqual(18:13-18:15),Underscore(18:16-18:17),OpArrow(18:18-18:20),Underscore(18:21-18:22), -LowerIdent(20:1-20:4),OpColon(20:5-20:6),UpperIdent(20:7-20:18), -LowerIdent(21:1-21:4),OpAssign(21:5-21:6),OpBar(21:7-21:8),LowerIdent(21:8-21:9),OpBar(21:9-21:10),LowerIdent(21:11-21:12), -UpperIdent(23:1-23:9),OpColonEqual(23:10-23:12),OpenRound(23:13-23:14),Underscore(23:14-23:15),Comma(23:15-23:16),UpperIdent(23:17-23:20),CloseRound(23:20-23:21), -LowerIdent(25:1-25:5),OpColon(25:6-25:7),UpperIdent(25:8-25:16), -LowerIdent(26:1-26:5),OpAssign(26:6-26:7),OpenRound(26:8-26:9),StringStart(26:9-26:10),StringPart(26:10-26:15),StringEnd(26:15-26:16),Comma(26:16-26:17),Int(26:18-26:20),CloseRound(26:20-26:21), -EndOfFile(27:1-27:1), +UpperIdent(1:1-1:8),OpColonEqual(1:9-1:11),Underscore(1:12-1:13), +LowerIdent(3:1-3:4),OpColon(3:5-3:6),UpperIdent(3:7-3:14), +LowerIdent(4:1-4:4),OpAssign(4:5-4:6),Int(4:7-4:9), +UpperIdent(6:1-6:8),OpColonEqual(6:9-6:11),UpperIdent(6:12-6:16),NoSpaceOpenRound(6:16-6:17),Underscore(6:17-6:18),CloseRound(6:18-6:19), +LowerIdent(8:1-8:4),OpColon(8:5-8:6),UpperIdent(8:7-8:14), +LowerIdent(9:1-9:4),OpAssign(9:5-9:6),OpenSquare(9:7-9:8),Int(9:8-9:9),Comma(9:9-9:10),Int(9:11-9:12),Comma(9:12-9:13),Int(9:14-9:15),CloseSquare(9:15-9:16), +UpperIdent(11:1-11:10),OpColonEqual(11:11-11:13),OpenCurly(11:14-11:15),LowerIdent(11:16-11:21),OpColon(11:21-11:22),Underscore(11:23-11:24),Comma(11:24-11:25),LowerIdent(11:26-11:31),OpColon(11:31-11:32),UpperIdent(11:33-11:36),CloseCurly(11:37-11:38), +LowerIdent(13:1-13:4),OpColon(13:5-13:6),UpperIdent(13:7-13:16), +LowerIdent(14:1-14:4),OpAssign(14:5-14:6),OpenCurly(14:7-14:8),LowerIdent(14:9-14:14),OpColon(14:14-14:15),StringStart(14:16-14:17),StringPart(14:17-14:19),StringEnd(14:19-14:20),Comma(14:20-14:21),LowerIdent(14:22-14:27),OpColon(14:27-14:28),Int(14:29-14:30),CloseCurly(14:31-14:32), +UpperIdent(16:1-16:12),OpColonEqual(16:13-16:15),Underscore(16:16-16:17),OpArrow(16:18-16:20),Underscore(16:21-16:22), +LowerIdent(18:1-18:4),OpColon(18:5-18:6),UpperIdent(18:7-18:18), +LowerIdent(19:1-19:4),OpAssign(19:5-19:6),OpBar(19:7-19:8),LowerIdent(19:8-19:9),OpBar(19:9-19:10),LowerIdent(19:11-19:12), +UpperIdent(21:1-21:9),OpColonEqual(21:10-21:12),OpenRound(21:13-21:14),Underscore(21:14-21:15),Comma(21:15-21:16),UpperIdent(21:17-21:20),CloseRound(21:20-21:21), +LowerIdent(23:1-23:5),OpColon(23:6-23:7),UpperIdent(23:8-23:16), +LowerIdent(24:1-24:5),OpAssign(24:6-24:7),OpenRound(24:8-24:9),StringStart(24:9-24:10),StringPart(24:10-24:15),StringEnd(24:15-24:16),Comma(24:16-24:17),Int(24:18-24:20),CloseRound(24:20-24:21), +EndOfFile(25:1-25:1), ~~~ # PARSE ~~~clojure -(file @1.1-26.21 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-24.21 + (type-module @1.1-1.8) (statements - (s-type-decl @3.1-3.13 - (header @3.1-3.8 (name "BadType") + (s-type-decl @1.1-1.13 + (header @1.1-1.8 (name "BadType") (args)) (_)) - (s-type-anno @5.1-5.14 (name "foo") - (ty @5.7-5.14 (name "BadType"))) - (s-decl @6.1-6.9 - (p-ident @6.1-6.4 (raw "foo")) - (e-int @6.7-6.9 (raw "42"))) - (s-type-decl @8.1-8.19 - (header @8.1-8.8 (name "BadList") + (s-type-anno @3.1-3.14 (name "foo") + (ty @3.7-3.14 (name "BadType"))) + (s-decl @4.1-4.9 + (p-ident @4.1-4.4 (raw "foo")) + (e-int @4.7-4.9 (raw "42"))) + (s-type-decl @6.1-6.19 + (header @6.1-6.8 (name "BadList") (args)) - (ty-apply @8.12-8.19 - (ty @8.12-8.16 (name "List")) + (ty-apply @6.12-6.19 + (ty @6.12-6.16 (name "List")) (_))) - (s-type-anno @10.1-10.14 (name "bar") - (ty @10.7-10.14 (name "BadList"))) - (s-decl @11.1-11.16 - (p-ident @11.1-11.4 (raw "bar")) - (e-list @11.7-11.16 - (e-int @11.8-11.9 (raw "1")) - (e-int @11.11-11.12 (raw "2")) - (e-int @11.14-11.15 (raw "3")))) - (s-type-decl @13.1-13.38 - (header @13.1-13.10 (name "BadRecord") + (s-type-anno @8.1-8.14 (name "bar") + (ty @8.7-8.14 (name "BadList"))) + (s-decl @9.1-9.16 + (p-ident @9.1-9.4 (raw "bar")) + (e-list @9.7-9.16 + (e-int @9.8-9.9 (raw "1")) + (e-int @9.11-9.12 (raw "2")) + (e-int @9.14-9.15 (raw "3")))) + (s-type-decl @11.1-11.38 + (header @11.1-11.10 (name "BadRecord") (args)) - (ty-record @13.14-13.38 - (anno-record-field @13.16-13.24 (name "field") + (ty-record @11.14-11.38 + (anno-record-field @11.16-11.24 (name "field") (_)) - (anno-record-field @13.26-13.36 (name "other") - (ty @13.33-13.36 (name "U32"))))) - (s-type-anno @15.1-15.16 (name "baz") - (ty @15.7-15.16 (name "BadRecord"))) - (s-decl @16.1-16.32 - (p-ident @16.1-16.4 (raw "baz")) - (e-record @16.7-16.32 + (anno-record-field @11.26-11.36 (name "other") + (ty @11.33-11.36 (name "U32"))))) + (s-type-anno @13.1-13.16 (name "baz") + (ty @13.7-13.16 (name "BadRecord"))) + (s-decl @14.1-14.32 + (p-ident @14.1-14.4 (raw "baz")) + (e-record @14.7-14.32 (field (field "field") - (e-string @16.16-16.20 - (e-string-part @16.17-16.19 (raw "hi")))) + (e-string @14.16-14.20 + (e-string-part @14.17-14.19 (raw "hi")))) (field (field "other") - (e-int @16.29-16.30 (raw "5"))))) - (s-type-decl @18.1-18.22 - (header @18.1-18.12 (name "BadFunction") + (e-int @14.29-14.30 (raw "5"))))) + (s-type-decl @16.1-16.22 + (header @16.1-16.12 (name "BadFunction") (args)) - (ty-fn @18.16-18.22 + (ty-fn @16.16-16.22 (_) (_))) - (s-type-anno @20.1-20.18 (name "qux") - (ty @20.7-20.18 (name "BadFunction"))) - (s-decl @21.1-21.12 - (p-ident @21.1-21.4 (raw "qux")) - (e-lambda @21.7-21.12 + (s-type-anno @18.1-18.18 (name "qux") + (ty @18.7-18.18 (name "BadFunction"))) + (s-decl @19.1-19.12 + (p-ident @19.1-19.4 (raw "qux")) + (e-lambda @19.7-19.12 (args - (p-ident @21.8-21.9 (raw "x"))) - (e-ident @21.11-21.12 (raw "x")))) - (s-type-decl @23.1-23.21 - (header @23.1-23.9 (name "BadTuple") + (p-ident @19.8-19.9 (raw "x"))) + (e-ident @19.11-19.12 (raw "x")))) + (s-type-decl @21.1-21.21 + (header @21.1-21.9 (name "BadTuple") (args)) - (ty-tuple @23.13-23.21 + (ty-tuple @21.13-21.21 (_) - (ty @23.17-23.20 (name "U32")))) - (s-type-anno @25.1-25.16 (name "quux") - (ty @25.8-25.16 (name "BadTuple"))) - (s-decl @26.1-26.21 - (p-ident @26.1-26.5 (raw "quux")) - (e-tuple @26.8-26.21 - (e-string @26.9-26.16 - (e-string-part @26.10-26.15 (raw "hello"))) - (e-int @26.18-26.20 (raw "42")))))) + (ty @21.17-21.20 (name "U32")))) + (s-type-anno @23.1-23.16 (name "quux") + (ty @23.8-23.16 (name "BadTuple"))) + (s-decl @24.1-24.21 + (p-ident @24.1-24.5 (raw "quux")) + (e-tuple @24.8-24.21 + (e-string @24.9-24.16 + (e-string-part @24.10-24.15 (raw "hello"))) + (e-int @24.18-24.20 (raw "42")))))) ~~~ # FORMATTED ~~~roc -module [] - BadType := _ foo : BadType @@ -235,102 +316,102 @@ quux = ("hello", 42) ~~~clojure (can-ir (d-let - (p-assign @6.1-6.4 (ident "foo")) - (e-int @6.7-6.9 (value "42")) - (annotation @6.1-6.4 + (p-assign @4.1-4.4 (ident "foo")) + (e-num @4.7-4.9 (value "42")) + (annotation @4.1-4.4 (declared-type - (ty @5.7-5.14 (name "BadType"))))) + (ty-lookup @3.7-3.14 (name "BadType") (local))))) (d-let - (p-assign @11.1-11.4 (ident "bar")) - (e-list @11.7-11.16 + (p-assign @9.1-9.4 (ident "bar")) + (e-list @9.7-9.16 (elems - (e-int @11.8-11.9 (value "1")) - (e-int @11.11-11.12 (value "2")) - (e-int @11.14-11.15 (value "3")))) - (annotation @11.1-11.4 + (e-num @9.8-9.9 (value "1")) + (e-num @9.11-9.12 (value "2")) + (e-num @9.14-9.15 (value "3")))) + (annotation @9.1-9.4 (declared-type - (ty @10.7-10.14 (name "BadList"))))) + (ty-lookup @8.7-8.14 (name "BadList") (local))))) (d-let - (p-assign @16.1-16.4 (ident "baz")) - (e-record @16.7-16.32 + (p-assign @14.1-14.4 (ident "baz")) + (e-record @14.7-14.32 (fields (field (name "field") - (e-string @16.16-16.20 - (e-literal @16.17-16.19 (string "hi")))) + (e-string @14.16-14.20 + (e-literal @14.17-14.19 (string "hi")))) (field (name "other") - (e-int @16.29-16.30 (value "5"))))) - (annotation @16.1-16.4 + (e-num @14.29-14.30 (value "5"))))) + (annotation @14.1-14.4 (declared-type - (ty @15.7-15.16 (name "BadRecord"))))) + (ty-lookup @13.7-13.16 (name "BadRecord") (local))))) (d-let - (p-assign @21.1-21.4 (ident "qux")) - (e-lambda @21.7-21.12 + (p-assign @19.1-19.4 (ident "qux")) + (e-lambda @19.7-19.12 (args - (p-assign @21.8-21.9 (ident "x"))) - (e-lookup-local @21.11-21.12 - (p-assign @21.8-21.9 (ident "x")))) - (annotation @21.1-21.4 + (p-assign @19.8-19.9 (ident "x"))) + (e-lookup-local @19.11-19.12 + (p-assign @19.8-19.9 (ident "x")))) + (annotation @19.1-19.4 (declared-type - (ty @20.7-20.18 (name "BadFunction"))))) + (ty-lookup @18.7-18.18 (name "BadFunction") (local))))) (d-let - (p-assign @26.1-26.5 (ident "quux")) - (e-tuple @26.8-26.21 + (p-assign @24.1-24.5 (ident "quux")) + (e-tuple @24.8-24.21 (elems - (e-string @26.9-26.16 - (e-literal @26.10-26.15 (string "hello"))) - (e-int @26.18-26.20 (value "42")))) - (annotation @26.1-26.5 + (e-string @24.9-24.16 + (e-literal @24.10-24.15 (string "hello"))) + (e-num @24.18-24.20 (value "42")))) + (annotation @24.1-24.5 (declared-type - (ty @25.8-25.16 (name "BadTuple"))))) - (s-nominal-decl @3.1-3.13 - (ty-header @3.1-3.8 (name "BadType")) + (ty-lookup @23.8-23.16 (name "BadTuple") (local))))) + (s-nominal-decl @1.1-1.13 + (ty-header @1.1-1.8 (name "BadType")) (ty-underscore @1.1-1.1)) - (s-nominal-decl @8.1-8.19 - (ty-header @8.1-8.8 (name "BadList")) - (ty-apply @8.12-8.19 (symbol "List") - (ty-underscore @8.17-8.17))) - (s-nominal-decl @13.1-13.38 - (ty-header @13.1-13.10 (name "BadRecord")) - (ty-record @13.14-13.38 + (s-nominal-decl @6.1-6.19 + (ty-header @6.1-6.8 (name "BadList")) + (ty-apply @6.12-6.19 (name "List") (builtin) + (ty-underscore @6.17-6.17))) + (s-nominal-decl @11.1-11.38 + (ty-header @11.1-11.10 (name "BadRecord")) + (ty-record @11.14-11.38 (field (field "field") (ty-underscore @1.1-1.1)) (field (field "other") - (ty @13.33-13.36 (name "U32"))))) - (s-nominal-decl @18.1-18.22 - (ty-header @18.1-18.12 (name "BadFunction")) - (ty-fn @18.16-18.22 (effectful false) + (ty-lookup @11.33-11.36 (name "U32") (builtin))))) + (s-nominal-decl @16.1-16.22 + (ty-header @16.1-16.12 (name "BadFunction")) + (ty-fn @16.16-16.22 (effectful false) (ty-underscore @1.1-1.1) (ty-underscore @1.1-1.1))) - (s-nominal-decl @23.1-23.21 - (ty-header @23.1-23.9 (name "BadTuple")) - (ty-tuple @23.13-23.21 - (ty-underscore @23.14-23.14) - (ty @23.17-23.20 (name "U32"))))) + (s-nominal-decl @21.1-21.21 + (ty-header @21.1-21.9 (name "BadTuple")) + (ty-tuple @21.13-21.21 + (ty-underscore @21.14-21.14) + (ty-lookup @21.17-21.20 (name "U32") (builtin))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @6.1-6.4 (type "Error")) - (patt @11.1-11.4 (type "Error")) - (patt @16.1-16.4 (type "Error")) - (patt @21.1-21.4 (type "Error")) - (patt @26.1-26.5 (type "Error"))) + (patt @4.1-4.4 (type "Error")) + (patt @9.1-9.4 (type "Error")) + (patt @14.1-14.4 (type "Error")) + (patt @19.1-19.4 (type "Error")) + (patt @24.1-24.5 (type "Error"))) (type_decls - (nominal @3.1-3.13 (type "Error") - (ty-header @3.1-3.8 (name "BadType"))) - (nominal @8.1-8.19 (type "Error") - (ty-header @8.1-8.8 (name "BadList"))) - (nominal @13.1-13.38 (type "Error") - (ty-header @13.1-13.10 (name "BadRecord"))) - (nominal @18.1-18.22 (type "Error") - (ty-header @18.1-18.12 (name "BadFunction"))) - (nominal @23.1-23.21 (type "Error") - (ty-header @23.1-23.9 (name "BadTuple")))) + (nominal @1.1-1.13 (type "BadType") + (ty-header @1.1-1.8 (name "BadType"))) + (nominal @6.1-6.19 (type "BadList") + (ty-header @6.1-6.8 (name "BadList"))) + (nominal @11.1-11.38 (type "BadRecord") + (ty-header @11.1-11.10 (name "BadRecord"))) + (nominal @16.1-16.22 (type "BadFunction") + (ty-header @16.1-16.12 (name "BadFunction"))) + (nominal @21.1-21.21 (type "BadTuple") + (ty-header @21.1-21.9 (name "BadTuple")))) (expressions - (expr @6.7-6.9 (type "Error")) - (expr @11.7-11.16 (type "Error")) - (expr @16.7-16.32 (type "Error")) - (expr @21.7-21.12 (type "Error")) - (expr @26.8-26.21 (type "Error")))) + (expr @4.7-4.9 (type "Error")) + (expr @9.7-9.16 (type "Error")) + (expr @14.7-14.32 (type "Error")) + (expr @19.7-19.12 (type "Error")) + (expr @24.8-24.21 (type "Error")))) ~~~ diff --git a/test/snapshots/issue/usage_test.md b/test/snapshots/issue/usage_test.md index ca23cee248..6296f8860c 100644 --- a/test/snapshots/issue/usage_test.md +++ b/test/snapshots/issue/usage_test.md @@ -1,12 +1,10 @@ # META ~~~ini description=Test if usage affects error type conversion -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - UnusedType := _ UsedType := _ @@ -17,13 +15,14 @@ value = 42 # EXPECTED UNDERSCORE IN TYPE ALIAS - usage_test.md:1:1:1:1 UNDERSCORE IN TYPE ALIAS - usage_test.md:1:1:1:1 +TYPE MISMATCH - usage_test.md:6:9:6:11 # PROBLEMS **UNDERSCORE IN TYPE ALIAS** Underscores are not allowed in type alias declarations. **usage_test.md:1:1:1:1:** ```roc -module [] +UnusedType := _ ``` ^ @@ -34,40 +33,52 @@ Underscores are not allowed in type alias declarations. **usage_test.md:1:1:1:1:** ```roc -module [] +UnusedType := _ ``` ^ Underscores in type annotations mean "I don't care about this type", which doesn't make sense when declaring a type. If you need a placeholder type variable, use a named type variable like `a` instead. +**TYPE MISMATCH** +This expression is used in an unexpected way: +**usage_test.md:6:9:6:11:** +```roc +value = 42 +``` + ^^ + +It has the type: + _Num(_size)_ + +But the type annotation says it should have the type: + _UsedType_ + # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -UpperIdent(3:1-3:11),OpColonEqual(3:12-3:14),Underscore(3:15-3:16), -UpperIdent(5:1-5:9),OpColonEqual(5:10-5:12),Underscore(5:13-5:14), -LowerIdent(7:1-7:6),OpColon(7:7-7:8),UpperIdent(7:9-7:17), -LowerIdent(8:1-8:6),OpAssign(8:7-8:8),Int(8:9-8:11), -EndOfFile(9:1-9:1), +UpperIdent(1:1-1:11),OpColonEqual(1:12-1:14),Underscore(1:15-1:16), +UpperIdent(3:1-3:9),OpColonEqual(3:10-3:12),Underscore(3:13-3:14), +LowerIdent(5:1-5:6),OpColon(5:7-5:8),UpperIdent(5:9-5:17), +LowerIdent(6:1-6:6),OpAssign(6:7-6:8),Int(6:9-6:11), +EndOfFile(7:1-7:1), ~~~ # PARSE ~~~clojure -(file @1.1-8.11 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-6.11 + (type-module @1.1-1.11) (statements - (s-type-decl @3.1-3.16 - (header @3.1-3.11 (name "UnusedType") + (s-type-decl @1.1-1.16 + (header @1.1-1.11 (name "UnusedType") (args)) (_)) - (s-type-decl @5.1-5.14 - (header @5.1-5.9 (name "UsedType") + (s-type-decl @3.1-3.14 + (header @3.1-3.9 (name "UsedType") (args)) (_)) - (s-type-anno @7.1-7.17 (name "value") - (ty @7.9-7.17 (name "UsedType"))) - (s-decl @8.1-8.11 - (p-ident @8.1-8.6 (raw "value")) - (e-int @8.9-8.11 (raw "42"))))) + (s-type-anno @5.1-5.17 (name "value") + (ty @5.9-5.17 (name "UsedType"))) + (s-decl @6.1-6.11 + (p-ident @6.1-6.6 (raw "value")) + (e-int @6.9-6.11 (raw "42"))))) ~~~ # FORMATTED ~~~roc @@ -77,28 +88,28 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @8.1-8.6 (ident "value")) - (e-int @8.9-8.11 (value "42")) - (annotation @8.1-8.6 + (p-assign @6.1-6.6 (ident "value")) + (e-num @6.9-6.11 (value "42")) + (annotation @6.1-6.6 (declared-type - (ty @7.9-7.17 (name "UsedType"))))) - (s-nominal-decl @3.1-3.16 - (ty-header @3.1-3.11 (name "UnusedType")) + (ty-lookup @5.9-5.17 (name "UsedType") (local))))) + (s-nominal-decl @1.1-1.16 + (ty-header @1.1-1.11 (name "UnusedType")) (ty-underscore @1.1-1.1)) - (s-nominal-decl @5.1-5.14 - (ty-header @5.1-5.9 (name "UsedType")) + (s-nominal-decl @3.1-3.14 + (ty-header @3.1-3.9 (name "UsedType")) (ty-underscore @1.1-1.1))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @8.1-8.6 (type "Error"))) + (patt @6.1-6.6 (type "Error"))) (type_decls - (nominal @3.1-3.16 (type "Error") - (ty-header @3.1-3.11 (name "UnusedType"))) - (nominal @5.1-5.14 (type "Error") - (ty-header @5.1-5.9 (name "UsedType")))) + (nominal @1.1-1.16 (type "UnusedType") + (ty-header @1.1-1.11 (name "UnusedType"))) + (nominal @3.1-3.14 (type "UsedType") + (ty-header @3.1-3.9 (name "UsedType")))) (expressions - (expr @8.9-8.11 (type "Error")))) + (expr @6.9-6.11 (type "Error")))) ~~~ diff --git a/test/snapshots/lambda_annotation_mismatch_error.md b/test/snapshots/lambda_annotation_mismatch_error.md index 99b42cc422..25b16ba46c 100644 --- a/test/snapshots/lambda_annotation_mismatch_error.md +++ b/test/snapshots/lambda_annotation_mismatch_error.md @@ -1,12 +1,10 @@ # META ~~~ini description=Lambda annotation mismatch error message test - verifies error messages assume annotation is correct and implementation is wrong -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [string_function, wrong_type_function] - # Annotation says it takes and returns strings, but implementation uses number addition string_function : Str -> Str string_function = |x| x + 42 @@ -16,124 +14,127 @@ wrong_type_function : I64 -> I64 wrong_type_function = |x| x * 3.14 ~~~ # EXPECTED -TYPE MISMATCH - lambda_annotation_mismatch_error.md:5:27:5:29 -TYPE MISMATCH - lambda_annotation_mismatch_error.md:9:31:9:35 +TYPE MISMATCH - lambda_annotation_mismatch_error.md:3:27:3:29 +TYPE MISMATCH - lambda_annotation_mismatch_error.md:7:31:7:35 # PROBLEMS **TYPE MISMATCH** This expression is used in an unexpected way: -**lambda_annotation_mismatch_error.md:5:27:5:29:** +**lambda_annotation_mismatch_error.md:3:27:3:29:** ```roc string_function = |x| x + 42 ``` ^^ -The type annotation says it should have the type: - _Str_ - -But here it's being used as: +It has the type: _Num(_size)_ +But the type annotation says it should have the type: + _Str_ + **TYPE MISMATCH** This expression is used in an unexpected way: -**lambda_annotation_mismatch_error.md:9:31:9:35:** +**lambda_annotation_mismatch_error.md:7:31:7:35:** ```roc wrong_type_function = |x| x * 3.14 ``` ^^^^ -The type annotation says it should have the type: - _I64_ +It has the type: + _Num(Frac(_size))_ -But here it's being used as: - _Frac(_size)_ +But the type annotation says it should have the type: + _Num(Int(Signed64))_ + +**Hint:** This might be because the numeric literal is too large to fit in the target type. # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:24),Comma(1:24-1:25),LowerIdent(1:26-1:45),CloseSquare(1:45-1:46), -LowerIdent(4:1-4:16),OpColon(4:17-4:18),UpperIdent(4:19-4:22),OpArrow(4:23-4:25),UpperIdent(4:26-4:29), -LowerIdent(5:1-5:16),OpAssign(5:17-5:18),OpBar(5:19-5:20),LowerIdent(5:20-5:21),OpBar(5:21-5:22),LowerIdent(5:23-5:24),OpPlus(5:25-5:26),Int(5:27-5:29), -LowerIdent(8:1-8:20),OpColon(8:21-8:22),UpperIdent(8:23-8:26),OpArrow(8:27-8:29),UpperIdent(8:30-8:33), -LowerIdent(9:1-9:20),OpAssign(9:21-9:22),OpBar(9:23-9:24),LowerIdent(9:24-9:25),OpBar(9:25-9:26),LowerIdent(9:27-9:28),OpStar(9:29-9:30),Float(9:31-9:35), -EndOfFile(10:1-10:1), +LowerIdent(2:1-2:16),OpColon(2:17-2:18),UpperIdent(2:19-2:22),OpArrow(2:23-2:25),UpperIdent(2:26-2:29), +LowerIdent(3:1-3:16),OpAssign(3:17-3:18),OpBar(3:19-3:20),LowerIdent(3:20-3:21),OpBar(3:21-3:22),LowerIdent(3:23-3:24),OpPlus(3:25-3:26),Int(3:27-3:29), +LowerIdent(6:1-6:20),OpColon(6:21-6:22),UpperIdent(6:23-6:26),OpArrow(6:27-6:29),UpperIdent(6:30-6:33), +LowerIdent(7:1-7:20),OpAssign(7:21-7:22),OpBar(7:23-7:24),LowerIdent(7:24-7:25),OpBar(7:25-7:26),LowerIdent(7:27-7:28),OpStar(7:29-7:30),Float(7:31-7:35), +EndOfFile(8:1-8:1), ~~~ # PARSE ~~~clojure -(file @1.1-9.35 - (module @1.1-1.46 - (exposes @1.8-1.46 - (exposed-lower-ident @1.9-1.24 - (text "string_function")) - (exposed-lower-ident @1.26-1.45 - (text "wrong_type_function")))) +(file @2.1-7.35 + (type-module @2.1-2.16) (statements - (s-type-anno @4.1-4.29 (name "string_function") - (ty-fn @4.19-4.29 - (ty @4.19-4.22 (name "Str")) - (ty @4.26-4.29 (name "Str")))) - (s-decl @5.1-5.29 - (p-ident @5.1-5.16 (raw "string_function")) - (e-lambda @5.19-5.29 + (s-type-anno @2.1-2.29 (name "string_function") + (ty-fn @2.19-2.29 + (ty @2.19-2.22 (name "Str")) + (ty @2.26-2.29 (name "Str")))) + (s-decl @3.1-3.29 + (p-ident @3.1-3.16 (raw "string_function")) + (e-lambda @3.19-3.29 (args - (p-ident @5.20-5.21 (raw "x"))) - (e-binop @5.23-5.29 (op "+") - (e-ident @5.23-5.24 (raw "x")) - (e-int @5.27-5.29 (raw "42"))))) - (s-type-anno @8.1-8.33 (name "wrong_type_function") - (ty-fn @8.23-8.33 - (ty @8.23-8.26 (name "I64")) - (ty @8.30-8.33 (name "I64")))) - (s-decl @9.1-9.35 - (p-ident @9.1-9.20 (raw "wrong_type_function")) - (e-lambda @9.23-9.35 + (p-ident @3.20-3.21 (raw "x"))) + (e-binop @3.23-3.29 (op "+") + (e-ident @3.23-3.24 (raw "x")) + (e-int @3.27-3.29 (raw "42"))))) + (s-type-anno @6.1-6.33 (name "wrong_type_function") + (ty-fn @6.23-6.33 + (ty @6.23-6.26 (name "I64")) + (ty @6.30-6.33 (name "I64")))) + (s-decl @7.1-7.35 + (p-ident @7.1-7.20 (raw "wrong_type_function")) + (e-lambda @7.23-7.35 (args - (p-ident @9.24-9.25 (raw "x"))) - (e-binop @9.27-9.35 (op "*") - (e-ident @9.27-9.28 (raw "x")) - (e-frac @9.31-9.35 (raw "3.14"))))))) + (p-ident @7.24-7.25 (raw "x"))) + (e-binop @7.27-7.35 (op "*") + (e-ident @7.27-7.28 (raw "x")) + (e-frac @7.31-7.35 (raw "3.14"))))))) ~~~ # FORMATTED ~~~roc -NO CHANGE +# Annotation says it takes and returns strings, but implementation uses number addition +# Annotation says it takes and returns strings, but implementation uses number addition +string_function : Str -> Str +string_function = |x| x + 42 + +# Annotation says function returns I64, but implementation returns Frac(_prec) +wrong_type_function : I64 -> I64 +wrong_type_function = |x| x * 3.14 ~~~ # CANONICALIZE ~~~clojure (can-ir (d-let - (p-assign @5.1-5.16 (ident "string_function")) - (e-lambda @5.19-5.29 + (p-assign @3.1-3.16 (ident "string_function")) + (e-lambda @3.19-3.29 (args - (p-assign @5.20-5.21 (ident "x"))) - (e-binop @5.23-5.29 (op "add") - (e-lookup-local @5.23-5.24 - (p-assign @5.20-5.21 (ident "x"))) - (e-int @5.27-5.29 (value "42")))) - (annotation @5.1-5.16 + (p-assign @3.20-3.21 (ident "x"))) + (e-binop @3.23-3.29 (op "add") + (e-lookup-local @3.23-3.24 + (p-assign @3.20-3.21 (ident "x"))) + (e-num @3.27-3.29 (value "42")))) + (annotation @3.1-3.16 (declared-type - (ty-fn @4.19-4.29 (effectful false) - (ty @4.19-4.22 (name "Str")) - (ty @4.26-4.29 (name "Str")))))) + (ty-fn @2.19-2.29 (effectful false) + (ty-lookup @2.19-2.22 (name "Str") (builtin)) + (ty-lookup @2.26-2.29 (name "Str") (builtin)))))) (d-let - (p-assign @9.1-9.20 (ident "wrong_type_function")) - (e-lambda @9.23-9.35 + (p-assign @7.1-7.20 (ident "wrong_type_function")) + (e-lambda @7.23-7.35 (args - (p-assign @9.24-9.25 (ident "x"))) - (e-binop @9.27-9.35 (op "mul") - (e-lookup-local @9.27-9.28 - (p-assign @9.24-9.25 (ident "x"))) - (e-dec-small @9.31-9.35 (numerator "314") (denominator-power-of-ten "2") (value "3.14")))) - (annotation @9.1-9.20 + (p-assign @7.24-7.25 (ident "x"))) + (e-binop @7.27-7.35 (op "mul") + (e-lookup-local @7.27-7.28 + (p-assign @7.24-7.25 (ident "x"))) + (e-dec-small @7.31-7.35 (numerator "314") (denominator-power-of-ten "2") (value "3.14")))) + (annotation @7.1-7.20 (declared-type - (ty-fn @8.23-8.33 (effectful false) - (ty @8.23-8.26 (name "I64")) - (ty @8.30-8.33 (name "I64"))))))) + (ty-fn @6.23-6.33 (effectful false) + (ty-lookup @6.23-6.26 (name "I64") (builtin)) + (ty-lookup @6.30-6.33 (name "I64") (builtin))))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @5.1-5.16 (type "Error -> Error")) - (patt @9.1-9.20 (type "Error -> Error"))) + (patt @3.1-3.16 (type "Str -> Error")) + (patt @7.1-7.20 (type "Num(Int(Signed64)) -> Error"))) (expressions - (expr @5.19-5.29 (type "Error -> Error")) - (expr @9.23-9.35 (type "Error -> Error")))) + (expr @3.19-3.29 (type "Str -> Error")) + (expr @7.23-7.35 (type "Num(Int(Signed64)) -> Error")))) ~~~ diff --git a/test/snapshots/lambda_capture/argument_shadows_capture.md b/test/snapshots/lambda_capture/argument_shadows_capture.md index c08b00762a..dc1036ea3e 100644 --- a/test/snapshots/lambda_capture/argument_shadows_capture.md +++ b/test/snapshots/lambda_capture/argument_shadows_capture.md @@ -79,14 +79,14 @@ EndOfFile(5:1-5:1), (e-block @1.1-4.2 (s-let @2.5-2.10 (p-assign @2.5-2.6 (ident "x")) - (e-int @2.9-2.10 (value "5"))) + (e-num @2.9-2.10 (value "5"))) (e-call @3.5-3.16 (e-lambda @3.6-3.11 (args (p-assign @3.7-3.8 (ident "x"))) (e-lookup-local @3.10-3.11 (p-assign @3.7-3.8 (ident "x")))) - (e-int @3.13-3.15 (value "10")))) + (e-num @3.13-3.15 (value "10")))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/lambda_capture/capture_from_block.md b/test/snapshots/lambda_capture/capture_from_block.md index d35cfb2b1b..1c9b053615 100644 --- a/test/snapshots/lambda_capture/capture_from_block.md +++ b/test/snapshots/lambda_capture/capture_from_block.md @@ -57,7 +57,7 @@ EndOfFile(6:1-6:1), (e-block @1.1-5.2 (s-let @2.5-2.11 (p-assign @2.5-2.6 (ident "a")) - (e-int @2.9-2.11 (value "10"))) + (e-num @2.9-2.11 (value "10"))) (s-let @3.5-3.23 (p-assign @3.5-3.6 (ident "b")) (e-call @3.9-3.23 @@ -70,8 +70,8 @@ EndOfFile(6:1-6:1), (e-binop @3.14-3.19 (op "mul") (e-lookup-local @3.14-3.15 (p-assign @2.5-2.6 (ident "a"))) - (e-int @3.18-3.19 (value "2"))))) - (e-int @3.21-3.22 (value "5")))) + (e-num @3.18-3.19 (value "2"))))) + (e-num @3.21-3.22 (value "5")))) (e-lookup-local @4.5-4.6 (p-assign @3.5-3.6 (ident "b")))) ~~~ diff --git a/test/snapshots/lambda_capture/deeply_nested_capture.md b/test/snapshots/lambda_capture/deeply_nested_capture.md index ff0bf4b634..ab0d5eb8eb 100644 --- a/test/snapshots/lambda_capture/deeply_nested_capture.md +++ b/test/snapshots/lambda_capture/deeply_nested_capture.md @@ -96,7 +96,7 @@ EndOfFile(8:1-8:1), (e-binop @2.13-2.18 (op "mul") (e-lookup-local @2.13-2.14 (p-assign @1.5-1.6 (ident "a"))) - (e-int @2.17-2.18 (value "2")))) + (e-num @2.17-2.18 (value "2")))) (e-closure @3.5-6.6 (captures (capture @2.5-2.10 (ident "a_loc"))) @@ -122,9 +122,9 @@ EndOfFile(8:1-8:1), (p-assign @4.9-4.14 (ident "b_loc"))) (e-lookup-local @5.21-5.22 (p-assign @5.10-5.11 (ident "c"))))))))))) - (e-int @7.4-7.7 (value "100"))) - (e-int @7.10-7.12 (value "20"))) - (e-int @7.15-7.16 (value "3"))) + (e-num @7.4-7.7 (value "100"))) + (e-num @7.10-7.12 (value "20"))) + (e-num @7.15-7.16 (value "3"))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/lambda_capture/lambda_capture_advanced.md b/test/snapshots/lambda_capture/lambda_capture_advanced.md index 6f2f5a77e6..b8407b71f5 100644 --- a/test/snapshots/lambda_capture/lambda_capture_advanced.md +++ b/test/snapshots/lambda_capture/lambda_capture_advanced.md @@ -57,8 +57,8 @@ NO CHANGE (e-closure @1.12-1.29 (captures (capture @1.9-1.10 (ident "c")) - (capture @1.3-1.4 (ident "a")) - (capture @1.6-1.7 (ident "b"))) + (capture @1.6-1.7 (ident "b")) + (capture @1.3-1.4 (ident "a"))) (e-lambda @1.12-1.29 (args (p-assign @1.13-1.14 (ident "x"))) @@ -73,10 +73,10 @@ NO CHANGE (p-assign @1.9-1.10 (ident "c")))) (e-lookup-local @1.28-1.29 (p-assign @1.13-1.14 (ident "x"))))))) - (e-int @1.31-1.33 (value "10")) - (e-int @1.35-1.37 (value "20")) - (e-int @1.39-1.40 (value "5"))) - (e-int @1.42-1.43 (value "7"))) + (e-num @1.31-1.33 (value "10")) + (e-num @1.35-1.37 (value "20")) + (e-num @1.39-1.40 (value "5"))) + (e-num @1.42-1.43 (value "7"))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/lambda_capture/lambda_capture_basic.md b/test/snapshots/lambda_capture/lambda_capture_basic.md index f311cf9cb2..e40b267713 100644 --- a/test/snapshots/lambda_capture/lambda_capture_basic.md +++ b/test/snapshots/lambda_capture/lambda_capture_basic.md @@ -55,8 +55,8 @@ NO CHANGE (p-assign @1.3-1.4 (ident "x"))) (e-lookup-local @1.14-1.15 (p-assign @1.7-1.8 (ident "y"))))))) - (e-int @1.17-1.18 (value "1"))) - (e-int @1.20-1.21 (value "2"))) + (e-num @1.17-1.18 (value "1"))) + (e-num @1.20-1.21 (value "2"))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/lambda_capture/lambda_capture_block_capture.md b/test/snapshots/lambda_capture/lambda_capture_block_capture.md index b082a54ec6..18332bc4b6 100644 --- a/test/snapshots/lambda_capture/lambda_capture_block_capture.md +++ b/test/snapshots/lambda_capture/lambda_capture_block_capture.md @@ -56,7 +56,7 @@ EndOfFile(6:1-6:1), (e-block @1.1-5.2 (s-let @2.5-2.11 (p-assign @2.5-2.6 (ident "x")) - (e-int @2.9-2.11 (value "42"))) + (e-num @2.9-2.11 (value "42"))) (s-let @3.5-3.18 (p-assign @3.5-3.6 (ident "f")) (e-closure @3.9-3.18 @@ -73,7 +73,7 @@ EndOfFile(6:1-6:1), (e-call @4.5-4.10 (e-lookup-local @4.5-4.6 (p-assign @3.5-3.6 (ident "f"))) - (e-int @4.7-4.9 (value "10")))) + (e-num @4.7-4.9 (value "10")))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/lambda_capture/lambda_capture_complex_expressions.md b/test/snapshots/lambda_capture/lambda_capture_complex_expressions.md index 9225cc0544..315dbacea7 100644 --- a/test/snapshots/lambda_capture/lambda_capture_complex_expressions.md +++ b/test/snapshots/lambda_capture/lambda_capture_complex_expressions.md @@ -62,7 +62,7 @@ NO CHANGE (e-binop @1.21-1.30 (op "gt") (e-lookup-local @1.21-1.26 (p-assign @1.3-1.8 (ident "outer"))) - (e-int @1.29-1.30 (value "0"))) + (e-num @1.29-1.30 (value "0"))) (e-binop @1.32-1.45 (op "add") (e-lookup-local @1.32-1.37 (p-assign @1.3-1.8 (ident "outer"))) @@ -71,8 +71,8 @@ NO CHANGE (if-else (e-lookup-local @1.52-1.57 (p-assign @1.11-1.16 (ident "inner")))))))) - (e-int @1.59-1.60 (value "1"))) - (e-int @1.62-1.64 (value "-2"))) + (e-num @1.59-1.60 (value "1"))) + (e-num @1.62-1.64 (value "-2"))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/lambda_capture/lambda_capture_deep_nesting.md b/test/snapshots/lambda_capture/lambda_capture_deep_nesting.md index ba2adf96b3..15a902a132 100644 --- a/test/snapshots/lambda_capture/lambda_capture_deep_nesting.md +++ b/test/snapshots/lambda_capture/lambda_capture_deep_nesting.md @@ -76,25 +76,25 @@ NO CHANGE (p-assign @1.7-1.8 (ident "b"))) (e-closure @1.10-1.39 (captures - (capture @1.3-1.4 (ident "a")) - (capture @1.7-1.8 (ident "b"))) + (capture @1.7-1.8 (ident "b")) + (capture @1.3-1.4 (ident "a"))) (e-lambda @1.10-1.39 (args (p-assign @1.11-1.12 (ident "c"))) (e-closure @1.14-1.39 (captures (capture @1.11-1.12 (ident "c")) - (capture @1.3-1.4 (ident "a")) - (capture @1.7-1.8 (ident "b"))) + (capture @1.7-1.8 (ident "b")) + (capture @1.3-1.4 (ident "a"))) (e-lambda @1.14-1.39 (args (p-assign @1.15-1.16 (ident "d"))) (e-closure @1.18-1.39 (captures - (capture @1.11-1.12 (ident "c")) (capture @1.15-1.16 (ident "d")) - (capture @1.3-1.4 (ident "a")) - (capture @1.7-1.8 (ident "b"))) + (capture @1.11-1.12 (ident "c")) + (capture @1.7-1.8 (ident "b")) + (capture @1.3-1.4 (ident "a"))) (e-lambda @1.18-1.39 (args (p-assign @1.19-1.20 (ident "e"))) @@ -112,11 +112,11 @@ NO CHANGE (p-assign @1.15-1.16 (ident "d")))) (e-lookup-local @1.38-1.39 (p-assign @1.19-1.20 (ident "e"))))))))))))) - (e-int @1.41-1.42 (value "1"))) - (e-int @1.44-1.45 (value "2"))) - (e-int @1.47-1.48 (value "3"))) - (e-int @1.50-1.51 (value "4"))) - (e-int @1.53-1.54 (value "5"))) + (e-num @1.41-1.42 (value "1"))) + (e-num @1.44-1.45 (value "2"))) + (e-num @1.47-1.48 (value "3"))) + (e-num @1.50-1.51 (value "4"))) + (e-num @1.53-1.54 (value "5"))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/lambda_capture/lambda_capture_mixed_patterns.md b/test/snapshots/lambda_capture/lambda_capture_mixed_patterns.md index feca357360..80c5ba2141 100644 --- a/test/snapshots/lambda_capture/lambda_capture_mixed_patterns.md +++ b/test/snapshots/lambda_capture/lambda_capture_mixed_patterns.md @@ -76,12 +76,12 @@ EndOfFile(5:1-5:1), (p-assign @1.3-1.7 (ident "base"))) (e-lookup-local @2.23-2.24 (p-assign @2.13-2.14 (ident "x")))) - (e-int @2.27-2.28 (value "1")))))) + (e-num @2.27-2.28 (value "1")))))) (e-call @3.3-3.12 (e-lookup-local @3.3-3.9 (p-assign @2.3-2.9 (ident "simple"))) - (e-int @3.10-3.11 (value "1"))))) - (e-int @4.4-4.5 (value "1"))) + (e-num @3.10-3.11 (value "1"))))) + (e-num @4.4-4.5 (value "1"))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/lambda_capture/lambda_capture_simple.md b/test/snapshots/lambda_capture/lambda_capture_simple.md index 0983c31a0f..7936224e0f 100644 --- a/test/snapshots/lambda_capture/lambda_capture_simple.md +++ b/test/snapshots/lambda_capture/lambda_capture_simple.md @@ -41,8 +41,8 @@ NO CHANGE (e-binop @1.6-1.11 (op "add") (e-lookup-local @1.6-1.7 (p-assign @1.3-1.4 (ident "x"))) - (e-int @1.10-1.11 (value "1")))) - (e-int @1.13-1.14 (value "5"))) + (e-num @1.10-1.11 (value "1")))) + (e-num @1.13-1.14 (value "5"))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/lambda_capture/lambda_capture_three_levels.md b/test/snapshots/lambda_capture/lambda_capture_three_levels.md index 4d4dec26fd..37f8317f45 100644 --- a/test/snapshots/lambda_capture/lambda_capture_three_levels.md +++ b/test/snapshots/lambda_capture/lambda_capture_three_levels.md @@ -60,8 +60,8 @@ NO CHANGE (p-assign @1.11-1.17 (ident "middle"))) (e-closure @1.19-1.49 (captures - (capture @1.3-1.8 (ident "outer")) - (capture @1.11-1.17 (ident "middle"))) + (capture @1.11-1.17 (ident "middle")) + (capture @1.3-1.8 (ident "outer"))) (e-lambda @1.19-1.49 (args (p-assign @1.20-1.25 (ident "inner"))) @@ -73,9 +73,9 @@ NO CHANGE (p-assign @1.11-1.17 (ident "middle")))) (e-lookup-local @1.44-1.49 (p-assign @1.20-1.25 (ident "inner"))))))))) - (e-int @1.51-1.52 (value "1"))) - (e-int @1.54-1.55 (value "2"))) - (e-int @1.57-1.58 (value "3"))) + (e-num @1.51-1.52 (value "1"))) + (e-num @1.54-1.55 (value "2"))) + (e-num @1.57-1.58 (value "3"))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/lambda_capture/lambda_invalid_references.md b/test/snapshots/lambda_capture/lambda_invalid_references.md index 8e209ae063..68d9770161 100644 --- a/test/snapshots/lambda_capture/lambda_invalid_references.md +++ b/test/snapshots/lambda_capture/lambda_invalid_references.md @@ -73,5 +73,5 @@ NO CHANGE ~~~ # TYPES ~~~clojure -(expr @1.1-1.14 (type "Num(_size) -> _arg -> Num(_size2)")) +(expr @1.1-1.14 (type "Error -> _arg -> Error")) ~~~ diff --git a/test/snapshots/lambda_capture/lambda_no_captures.md b/test/snapshots/lambda_capture/lambda_no_captures.md index ad70953972..2f086b2664 100644 --- a/test/snapshots/lambda_capture/lambda_no_captures.md +++ b/test/snapshots/lambda_capture/lambda_no_captures.md @@ -41,8 +41,8 @@ NO CHANGE (e-binop @1.6-1.11 (op "add") (e-lookup-local @1.6-1.7 (p-assign @1.3-1.4 (ident "x"))) - (e-int @1.10-1.11 (value "1")))) - (e-int @1.13-1.14 (value "2"))) + (e-num @1.10-1.11 (value "1")))) + (e-num @1.13-1.14 (value "2"))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/lambda_capture/lambda_with_negative_argument.md b/test/snapshots/lambda_capture/lambda_with_negative_argument.md index e0ef253438..5f23fa133d 100644 --- a/test/snapshots/lambda_capture/lambda_with_negative_argument.md +++ b/test/snapshots/lambda_capture/lambda_with_negative_argument.md @@ -41,8 +41,8 @@ NO CHANGE (e-binop @1.6-1.11 (op "add") (e-lookup-local @1.6-1.7 (p-assign @1.3-1.4 (ident "x"))) - (e-int @1.10-1.11 (value "1")))) - (e-int @1.13-1.15 (value "-5"))) + (e-num @1.10-1.11 (value "1")))) + (e-num @1.13-1.15 (value "-5"))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/lambda_capture/let_shadows_capture.md b/test/snapshots/lambda_capture/let_shadows_capture.md index 58f4417941..7ba0f20a11 100644 --- a/test/snapshots/lambda_capture/let_shadows_capture.md +++ b/test/snapshots/lambda_capture/let_shadows_capture.md @@ -101,7 +101,7 @@ EndOfFile(9:1-9:1), (e-block @1.1-8.2 (s-let @2.5-2.10 (p-assign @2.5-2.6 (ident "x")) - (e-int @2.9-2.10 (value "5"))) + (e-num @2.9-2.10 (value "5"))) (s-let @3.5-6.11 (p-assign @3.5-3.6 (ident "y")) (e-call @3.9-6.11 @@ -111,7 +111,7 @@ EndOfFile(9:1-9:1), (e-block @3.14-6.6 (s-let @4.9-4.15 (p-assign @4.9-4.10 (ident "x")) - (e-int @4.13-4.15 (value "10"))) + (e-num @4.13-4.15 (value "10"))) (e-lookup-local @5.9-5.10 (p-assign @4.9-4.10 (ident "x"))))) (e-empty_record @6.8-6.10))) diff --git a/test/snapshots/lambda_capture/nested_capture.md b/test/snapshots/lambda_capture/nested_capture.md index 24a19387ed..e5293ab1fc 100644 --- a/test/snapshots/lambda_capture/nested_capture.md +++ b/test/snapshots/lambda_capture/nested_capture.md @@ -81,11 +81,11 @@ EndOfFile(6:1-6:1), (e-call @3.9-3.14 (e-lookup-local @3.9-3.10 (p-assign @2.5-2.6 (ident "f"))) - (e-int @3.11-3.13 (value "10")))) + (e-num @3.11-3.13 (value "10")))) (e-call @4.5-4.9 (e-lookup-local @4.5-4.6 (p-assign @3.5-3.6 (ident "g"))) - (e-int @4.7-4.8 (value "5")))) + (e-num @4.7-4.8 (value "5")))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/lambda_capture/no_capture.md b/test/snapshots/lambda_capture/no_capture.md index bf9bd7439a..b7f4015e47 100644 --- a/test/snapshots/lambda_capture/no_capture.md +++ b/test/snapshots/lambda_capture/no_capture.md @@ -41,8 +41,8 @@ NO CHANGE (e-binop @1.6-1.11 (op "add") (e-lookup-local @1.6-1.7 (p-assign @1.3-1.4 (ident "x"))) - (e-int @1.10-1.11 (value "1")))) - (e-int @1.13-1.15 (value "10"))) + (e-num @1.10-1.11 (value "1")))) + (e-num @1.13-1.15 (value "10"))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/lambda_capture/simple_capture.md b/test/snapshots/lambda_capture/simple_capture.md index 9cc71a819b..84a3d7d66b 100644 --- a/test/snapshots/lambda_capture/simple_capture.md +++ b/test/snapshots/lambda_capture/simple_capture.md @@ -55,7 +55,7 @@ EndOfFile(6:1-6:1), (e-block @1.1-5.2 (s-let @2.5-2.10 (p-assign @2.5-2.6 (ident "x")) - (e-int @2.9-2.10 (value "5"))) + (e-num @2.9-2.10 (value "5"))) (s-let @3.5-3.19 (p-assign @3.5-3.6 (ident "y")) (e-call @3.9-3.19 @@ -67,7 +67,7 @@ EndOfFile(6:1-6:1), (p-underscore @3.11-3.12)) (e-lookup-local @3.14-3.15 (p-assign @2.5-2.6 (ident "x"))))) - (e-int @3.17-3.18 (value "1")))) + (e-num @3.17-3.18 (value "1")))) (e-lookup-local @4.5-4.6 (p-assign @3.5-3.6 (ident "y")))) ~~~ diff --git a/test/snapshots/lambda_currying_constraint.md b/test/snapshots/lambda_currying_constraint.md index 5147b3f193..6a8ec84153 100644 --- a/test/snapshots/lambda_currying_constraint.md +++ b/test/snapshots/lambda_currying_constraint.md @@ -1,12 +1,10 @@ # META ~~~ini description=Lambda currying with polymorphic function constraints - tests if numeric literals in curried functions get properly constrained -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [makeAdder, curriedAdd, applyTwice] - # Function that returns a function with polymorphic type makeAdder : a -> (a -> a) makeAdder = |x| |y| x + y @@ -29,194 +27,201 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:18),Comma(1:18-1:19),LowerIdent(1:20-1:30),Comma(1:30-1:31),LowerIdent(1:32-1:42),CloseSquare(1:42-1:43), -LowerIdent(4:1-4:10),OpColon(4:11-4:12),LowerIdent(4:13-4:14),OpArrow(4:15-4:17),OpenRound(4:18-4:19),LowerIdent(4:19-4:20),OpArrow(4:21-4:23),LowerIdent(4:24-4:25),CloseRound(4:25-4:26), -LowerIdent(5:1-5:10),OpAssign(5:11-5:12),OpBar(5:13-5:14),LowerIdent(5:14-5:15),OpBar(5:15-5:16),OpBar(5:17-5:18),LowerIdent(5:18-5:19),OpBar(5:19-5:20),LowerIdent(5:21-5:22),OpPlus(5:23-5:24),LowerIdent(5:25-5:26), -LowerIdent(8:1-8:11),OpColon(8:12-8:13),UpperIdent(8:14-8:17),OpArrow(8:18-8:20),UpperIdent(8:21-8:24), -LowerIdent(9:1-9:11),OpAssign(9:12-9:13),LowerIdent(9:14-9:23),NoSpaceOpenRound(9:23-9:24),Int(9:24-9:25),CloseRound(9:25-9:26), -LowerIdent(12:1-12:11),OpColon(12:12-12:13),OpenRound(12:14-12:15),LowerIdent(12:15-12:16),OpArrow(12:17-12:19),LowerIdent(12:20-12:21),CloseRound(12:21-12:22),Comma(12:22-12:23),LowerIdent(12:24-12:25),OpArrow(12:26-12:28),LowerIdent(12:29-12:30), -LowerIdent(13:1-13:11),OpAssign(13:12-13:13),OpBar(13:14-13:15),LowerIdent(13:15-13:16),Comma(13:16-13:17),LowerIdent(13:18-13:19),OpBar(13:19-13:20),LowerIdent(13:21-13:22),NoSpaceOpenRound(13:22-13:23),LowerIdent(13:23-13:24),NoSpaceOpenRound(13:24-13:25),LowerIdent(13:25-13:26),CloseRound(13:26-13:27),CloseRound(13:27-13:28), -LowerIdent(16:1-16:14),OpColon(16:15-16:16),UpperIdent(16:17-16:20),OpArrow(16:21-16:23),UpperIdent(16:24-16:27), -LowerIdent(17:1-17:14),OpAssign(17:15-17:16),OpBar(17:17-17:18),LowerIdent(17:18-17:19),OpBar(17:19-17:20),LowerIdent(17:21-17:31),NoSpaceOpenRound(17:31-17:32),OpBar(17:32-17:33),LowerIdent(17:33-17:34),OpBar(17:34-17:35),LowerIdent(17:36-17:37),OpPlus(17:38-17:39),Int(17:40-17:41),Comma(17:41-17:42),LowerIdent(17:43-17:44),CloseRound(17:44-17:45), -EndOfFile(18:1-18:1), +LowerIdent(2:1-2:10),OpColon(2:11-2:12),LowerIdent(2:13-2:14),OpArrow(2:15-2:17),OpenRound(2:18-2:19),LowerIdent(2:19-2:20),OpArrow(2:21-2:23),LowerIdent(2:24-2:25),CloseRound(2:25-2:26), +LowerIdent(3:1-3:10),OpAssign(3:11-3:12),OpBar(3:13-3:14),LowerIdent(3:14-3:15),OpBar(3:15-3:16),OpBar(3:17-3:18),LowerIdent(3:18-3:19),OpBar(3:19-3:20),LowerIdent(3:21-3:22),OpPlus(3:23-3:24),LowerIdent(3:25-3:26), +LowerIdent(6:1-6:11),OpColon(6:12-6:13),UpperIdent(6:14-6:17),OpArrow(6:18-6:20),UpperIdent(6:21-6:24), +LowerIdent(7:1-7:11),OpAssign(7:12-7:13),LowerIdent(7:14-7:23),NoSpaceOpenRound(7:23-7:24),Int(7:24-7:25),CloseRound(7:25-7:26), +LowerIdent(10:1-10:11),OpColon(10:12-10:13),OpenRound(10:14-10:15),LowerIdent(10:15-10:16),OpArrow(10:17-10:19),LowerIdent(10:20-10:21),CloseRound(10:21-10:22),Comma(10:22-10:23),LowerIdent(10:24-10:25),OpArrow(10:26-10:28),LowerIdent(10:29-10:30), +LowerIdent(11:1-11:11),OpAssign(11:12-11:13),OpBar(11:14-11:15),LowerIdent(11:15-11:16),Comma(11:16-11:17),LowerIdent(11:18-11:19),OpBar(11:19-11:20),LowerIdent(11:21-11:22),NoSpaceOpenRound(11:22-11:23),LowerIdent(11:23-11:24),NoSpaceOpenRound(11:24-11:25),LowerIdent(11:25-11:26),CloseRound(11:26-11:27),CloseRound(11:27-11:28), +LowerIdent(14:1-14:14),OpColon(14:15-14:16),UpperIdent(14:17-14:20),OpArrow(14:21-14:23),UpperIdent(14:24-14:27), +LowerIdent(15:1-15:14),OpAssign(15:15-15:16),OpBar(15:17-15:18),LowerIdent(15:18-15:19),OpBar(15:19-15:20),LowerIdent(15:21-15:31),NoSpaceOpenRound(15:31-15:32),OpBar(15:32-15:33),LowerIdent(15:33-15:34),OpBar(15:34-15:35),LowerIdent(15:36-15:37),OpPlus(15:38-15:39),Int(15:40-15:41),Comma(15:41-15:42),LowerIdent(15:43-15:44),CloseRound(15:44-15:45), +EndOfFile(16:1-16:1), ~~~ # PARSE ~~~clojure -(file @1.1-17.45 - (module @1.1-1.43 - (exposes @1.8-1.43 - (exposed-lower-ident @1.9-1.18 - (text "makeAdder")) - (exposed-lower-ident @1.20-1.30 - (text "curriedAdd")) - (exposed-lower-ident @1.32-1.42 - (text "applyTwice")))) +(file @2.1-15.45 + (type-module @2.1-2.10) (statements - (s-type-anno @4.1-4.26 (name "makeAdder") - (ty-fn @4.13-4.26 - (ty-var @4.13-4.14 (raw "a")) - (ty-fn @4.19-4.25 - (ty-var @4.19-4.20 (raw "a")) - (ty-var @4.24-4.25 (raw "a"))))) - (s-decl @5.1-5.26 - (p-ident @5.1-5.10 (raw "makeAdder")) - (e-lambda @5.13-5.26 + (s-type-anno @2.1-2.26 (name "makeAdder") + (ty-fn @2.13-2.26 + (ty-var @2.13-2.14 (raw "a")) + (ty-fn @2.19-2.25 + (ty-var @2.19-2.20 (raw "a")) + (ty-var @2.24-2.25 (raw "a"))))) + (s-decl @3.1-3.26 + (p-ident @3.1-3.10 (raw "makeAdder")) + (e-lambda @3.13-3.26 (args - (p-ident @5.14-5.15 (raw "x"))) - (e-lambda @5.17-5.26 + (p-ident @3.14-3.15 (raw "x"))) + (e-lambda @3.17-3.26 (args - (p-ident @5.18-5.19 (raw "y"))) - (e-binop @5.21-5.26 (op "+") - (e-ident @5.21-5.22 (raw "x")) - (e-ident @5.25-5.26 (raw "y")))))) - (s-type-anno @8.1-8.24 (name "curriedAdd") - (ty-fn @8.14-8.24 - (ty @8.14-8.17 (name "I64")) - (ty @8.21-8.24 (name "I64")))) - (s-decl @9.1-9.26 - (p-ident @9.1-9.11 (raw "curriedAdd")) - (e-apply @9.14-9.26 - (e-ident @9.14-9.23 (raw "makeAdder")) - (e-int @9.24-9.25 (raw "5")))) - (s-type-anno @12.1-12.30 (name "applyTwice") - (ty-fn @12.14-12.30 - (ty-fn @12.15-12.21 - (ty-var @12.15-12.16 (raw "a")) - (ty-var @12.20-12.21 (raw "a"))) - (ty-var @12.24-12.25 (raw "a")) - (ty-var @12.29-12.30 (raw "a")))) - (s-decl @13.1-13.28 - (p-ident @13.1-13.11 (raw "applyTwice")) - (e-lambda @13.14-13.28 + (p-ident @3.18-3.19 (raw "y"))) + (e-binop @3.21-3.26 (op "+") + (e-ident @3.21-3.22 (raw "x")) + (e-ident @3.25-3.26 (raw "y")))))) + (s-type-anno @6.1-6.24 (name "curriedAdd") + (ty-fn @6.14-6.24 + (ty @6.14-6.17 (name "I64")) + (ty @6.21-6.24 (name "I64")))) + (s-decl @7.1-7.26 + (p-ident @7.1-7.11 (raw "curriedAdd")) + (e-apply @7.14-7.26 + (e-ident @7.14-7.23 (raw "makeAdder")) + (e-int @7.24-7.25 (raw "5")))) + (s-type-anno @10.1-10.30 (name "applyTwice") + (ty-fn @10.14-10.30 + (ty-fn @10.15-10.21 + (ty-var @10.15-10.16 (raw "a")) + (ty-var @10.20-10.21 (raw "a"))) + (ty-var @10.24-10.25 (raw "a")) + (ty-var @10.29-10.30 (raw "a")))) + (s-decl @11.1-11.28 + (p-ident @11.1-11.11 (raw "applyTwice")) + (e-lambda @11.14-11.28 (args - (p-ident @13.15-13.16 (raw "f")) - (p-ident @13.18-13.19 (raw "x"))) - (e-apply @13.21-13.28 - (e-ident @13.21-13.22 (raw "f")) - (e-apply @13.23-13.27 - (e-ident @13.23-13.24 (raw "f")) - (e-ident @13.25-13.26 (raw "x")))))) - (s-type-anno @16.1-16.27 (name "addThreeTwice") - (ty-fn @16.17-16.27 - (ty @16.17-16.20 (name "I64")) - (ty @16.24-16.27 (name "I64")))) - (s-decl @17.1-17.45 - (p-ident @17.1-17.14 (raw "addThreeTwice")) - (e-lambda @17.17-17.45 + (p-ident @11.15-11.16 (raw "f")) + (p-ident @11.18-11.19 (raw "x"))) + (e-apply @11.21-11.28 + (e-ident @11.21-11.22 (raw "f")) + (e-apply @11.23-11.27 + (e-ident @11.23-11.24 (raw "f")) + (e-ident @11.25-11.26 (raw "x")))))) + (s-type-anno @14.1-14.27 (name "addThreeTwice") + (ty-fn @14.17-14.27 + (ty @14.17-14.20 (name "I64")) + (ty @14.24-14.27 (name "I64")))) + (s-decl @15.1-15.45 + (p-ident @15.1-15.14 (raw "addThreeTwice")) + (e-lambda @15.17-15.45 (args - (p-ident @17.18-17.19 (raw "n"))) - (e-apply @17.21-17.45 - (e-ident @17.21-17.31 (raw "applyTwice")) - (e-lambda @17.32-17.41 + (p-ident @15.18-15.19 (raw "n"))) + (e-apply @15.21-15.45 + (e-ident @15.21-15.31 (raw "applyTwice")) + (e-lambda @15.32-15.41 (args - (p-ident @17.33-17.34 (raw "x"))) - (e-binop @17.36-17.41 (op "+") - (e-ident @17.36-17.37 (raw "x")) - (e-int @17.40-17.41 (raw "3")))) - (e-ident @17.43-17.44 (raw "n"))))))) + (p-ident @15.33-15.34 (raw "x"))) + (e-binop @15.36-15.41 (op "+") + (e-ident @15.36-15.37 (raw "x")) + (e-int @15.40-15.41 (raw "3")))) + (e-ident @15.43-15.44 (raw "n"))))))) ~~~ # FORMATTED ~~~roc -NO CHANGE +# Function that returns a function with polymorphic type +# Function that returns a function with polymorphic type +makeAdder : a -> (a -> a) +makeAdder = |x| |y| x + y + +# Should constrain the literal 5 to I64 +curriedAdd : I64 -> I64 +curriedAdd = makeAdder(5) + +# Higher-order function that applies a function twice +applyTwice : (a -> a), a -> a +applyTwice = |f, x| f(f(x)) + +# Should constrain the literal 3 to I64 +addThreeTwice : I64 -> I64 +addThreeTwice = |n| applyTwice(|x| x + 3, n) ~~~ # CANONICALIZE ~~~clojure (can-ir (d-let - (p-assign @5.1-5.10 (ident "makeAdder")) - (e-lambda @5.13-5.26 + (p-assign @3.1-3.10 (ident "makeAdder")) + (e-lambda @3.13-3.26 (args - (p-assign @5.14-5.15 (ident "x"))) - (e-closure @5.17-5.26 + (p-assign @3.14-3.15 (ident "x"))) + (e-closure @3.17-3.26 (captures - (capture @5.14-5.15 (ident "x"))) - (e-lambda @5.17-5.26 + (capture @3.14-3.15 (ident "x"))) + (e-lambda @3.17-3.26 (args - (p-assign @5.18-5.19 (ident "y"))) - (e-binop @5.21-5.26 (op "add") - (e-lookup-local @5.21-5.22 - (p-assign @5.14-5.15 (ident "x"))) - (e-lookup-local @5.25-5.26 - (p-assign @5.18-5.19 (ident "y"))))))) - (annotation @5.1-5.10 + (p-assign @3.18-3.19 (ident "y"))) + (e-binop @3.21-3.26 (op "add") + (e-lookup-local @3.21-3.22 + (p-assign @3.14-3.15 (ident "x"))) + (e-lookup-local @3.25-3.26 + (p-assign @3.18-3.19 (ident "y"))))))) + (annotation @3.1-3.10 (declared-type - (ty-fn @4.13-4.26 (effectful false) - (ty-var @4.13-4.14 (name "a")) - (ty-parens @4.18-4.26 - (ty-fn @4.19-4.25 (effectful false) - (ty-var @4.19-4.20 (name "a")) - (ty-var @4.24-4.25 (name "a")))))))) + (ty-fn @2.13-2.26 (effectful false) + (ty-rigid-var @2.13-2.14 (name "a")) + (ty-parens @2.18-2.26 + (ty-fn @2.19-2.25 (effectful false) + (ty-rigid-var-lookup (ty-rigid-var @2.13-2.14 (name "a"))) + (ty-rigid-var-lookup (ty-rigid-var @2.13-2.14 (name "a"))))))))) (d-let - (p-assign @9.1-9.11 (ident "curriedAdd")) - (e-call @9.14-9.26 - (e-lookup-local @9.14-9.23 - (p-assign @5.1-5.10 (ident "makeAdder"))) - (e-int @9.24-9.25 (value "5"))) - (annotation @9.1-9.11 + (p-assign @7.1-7.11 (ident "curriedAdd")) + (e-call @7.14-7.26 + (e-lookup-local @7.14-7.23 + (p-assign @3.1-3.10 (ident "makeAdder"))) + (e-num @7.24-7.25 (value "5"))) + (annotation @7.1-7.11 (declared-type - (ty-fn @8.14-8.24 (effectful false) - (ty @8.14-8.17 (name "I64")) - (ty @8.21-8.24 (name "I64")))))) + (ty-fn @6.14-6.24 (effectful false) + (ty-lookup @6.14-6.17 (name "I64") (builtin)) + (ty-lookup @6.21-6.24 (name "I64") (builtin)))))) (d-let - (p-assign @13.1-13.11 (ident "applyTwice")) - (e-lambda @13.14-13.28 + (p-assign @11.1-11.11 (ident "applyTwice")) + (e-lambda @11.14-11.28 (args - (p-assign @13.15-13.16 (ident "f")) - (p-assign @13.18-13.19 (ident "x"))) - (e-call @13.21-13.28 - (e-lookup-local @13.21-13.22 - (p-assign @13.15-13.16 (ident "f"))) - (e-call @13.23-13.27 - (e-lookup-local @13.23-13.24 - (p-assign @13.15-13.16 (ident "f"))) - (e-lookup-local @13.25-13.26 - (p-assign @13.18-13.19 (ident "x")))))) - (annotation @13.1-13.11 + (p-assign @11.15-11.16 (ident "f")) + (p-assign @11.18-11.19 (ident "x"))) + (e-call @11.21-11.28 + (e-lookup-local @11.21-11.22 + (p-assign @11.15-11.16 (ident "f"))) + (e-call @11.23-11.27 + (e-lookup-local @11.23-11.24 + (p-assign @11.15-11.16 (ident "f"))) + (e-lookup-local @11.25-11.26 + (p-assign @11.18-11.19 (ident "x")))))) + (annotation @11.1-11.11 (declared-type - (ty-fn @12.14-12.30 (effectful false) - (ty-parens @12.14-12.22 - (ty-fn @12.15-12.21 (effectful false) - (ty-var @12.15-12.16 (name "a")) - (ty-var @12.20-12.21 (name "a")))) - (ty-var @12.24-12.25 (name "a")) - (ty-var @12.29-12.30 (name "a")))))) + (ty-fn @10.14-10.30 (effectful false) + (ty-parens @10.14-10.22 + (ty-fn @10.15-10.21 (effectful false) + (ty-rigid-var @10.15-10.16 (name "a")) + (ty-rigid-var-lookup (ty-rigid-var @10.15-10.16 (name "a"))))) + (ty-rigid-var-lookup (ty-rigid-var @10.15-10.16 (name "a"))) + (ty-rigid-var-lookup (ty-rigid-var @10.15-10.16 (name "a"))))))) (d-let - (p-assign @17.1-17.14 (ident "addThreeTwice")) - (e-closure @17.17-17.45 + (p-assign @15.1-15.14 (ident "addThreeTwice")) + (e-closure @15.17-15.45 (captures - (capture @13.1-13.11 (ident "applyTwice"))) - (e-lambda @17.17-17.45 + (capture @11.1-11.11 (ident "applyTwice"))) + (e-lambda @15.17-15.45 (args - (p-assign @17.18-17.19 (ident "n"))) - (e-call @17.21-17.45 - (e-lookup-local @17.21-17.31 - (p-assign @13.1-13.11 (ident "applyTwice"))) - (e-lambda @17.32-17.41 + (p-assign @15.18-15.19 (ident "n"))) + (e-call @15.21-15.45 + (e-lookup-local @15.21-15.31 + (p-assign @11.1-11.11 (ident "applyTwice"))) + (e-lambda @15.32-15.41 (args - (p-assign @17.33-17.34 (ident "x"))) - (e-binop @17.36-17.41 (op "add") - (e-lookup-local @17.36-17.37 - (p-assign @17.33-17.34 (ident "x"))) - (e-int @17.40-17.41 (value "3")))) - (e-lookup-local @17.43-17.44 - (p-assign @17.18-17.19 (ident "n")))))) - (annotation @17.1-17.14 + (p-assign @15.33-15.34 (ident "x"))) + (e-binop @15.36-15.41 (op "add") + (e-lookup-local @15.36-15.37 + (p-assign @15.33-15.34 (ident "x"))) + (e-num @15.40-15.41 (value "3")))) + (e-lookup-local @15.43-15.44 + (p-assign @15.18-15.19 (ident "n")))))) + (annotation @15.1-15.14 (declared-type - (ty-fn @16.17-16.27 (effectful false) - (ty @16.17-16.20 (name "I64")) - (ty @16.24-16.27 (name "I64"))))))) + (ty-fn @14.17-14.27 (effectful false) + (ty-lookup @14.17-14.20 (name "I64") (builtin)) + (ty-lookup @14.24-14.27 (name "I64") (builtin))))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @5.1-5.10 (type "a -> a -> a")) - (patt @9.1-9.11 (type "I64 -> I64")) - (patt @13.1-13.11 (type "a -> a, a -> a")) - (patt @17.1-17.14 (type "I64 -> I64"))) + (patt @3.1-3.10 (type "a -> a -> a")) + (patt @7.1-7.11 (type "Num(Int(Signed64)) -> Num(Int(Signed64))")) + (patt @11.1-11.11 (type "a -> a, a -> a")) + (patt @15.1-15.14 (type "Num(Int(Signed64)) -> Num(Int(Signed64))"))) (expressions - (expr @5.13-5.26 (type "a -> a -> a")) - (expr @9.14-9.26 (type "I64 -> I64")) - (expr @13.14-13.28 (type "a -> a, a -> a")) - (expr @17.17-17.45 (type "I64 -> I64")))) + (expr @3.13-3.26 (type "a -> a -> a")) + (expr @7.14-7.26 (type "Num(Int(Signed64)) -> Num(Int(Signed64))")) + (expr @11.14-11.28 (type "a -> a, a -> a")) + (expr @15.17-15.45 (type "Num(Int(Signed64)) -> Num(Int(Signed64))")))) ~~~ diff --git a/test/snapshots/lambda_multi_arg_mismatch.md b/test/snapshots/lambda_multi_arg_mismatch.md index 22c4c7e5ab..6057ebcf1a 100644 --- a/test/snapshots/lambda_multi_arg_mismatch.md +++ b/test/snapshots/lambda_multi_arg_mismatch.md @@ -1,12 +1,10 @@ # META ~~~ini description=Lambda with multiple non-consecutive argument type mismatches -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - # Function with 8 arguments where several types must match (a appears in positions 1, 3, 5, 7) multi_arg_fn : a, b, a, c, a, d, a, e -> (a, b, c, d, e) multi_arg_fn = |x1, x2, x3, x4, x5, x6, x7, x8| @@ -26,17 +24,17 @@ result = multi_arg_fn( ) ~~~ # EXPECTED -UNUSED VARIABLE - lambda_multi_arg_mismatch.md:5:25:5:27 -UNUSED VARIABLE - lambda_multi_arg_mismatch.md:5:33:5:35 -UNUSED VARIABLE - lambda_multi_arg_mismatch.md:5:41:5:43 -TYPE MISMATCH - lambda_multi_arg_mismatch.md:11:5:11:5 +UNUSED VARIABLE - lambda_multi_arg_mismatch.md:3:25:3:27 +UNUSED VARIABLE - lambda_multi_arg_mismatch.md:3:33:3:35 +UNUSED VARIABLE - lambda_multi_arg_mismatch.md:3:41:3:43 +TYPE MISMATCH - lambda_multi_arg_mismatch.md:9:5:9:5 # PROBLEMS **UNUSED VARIABLE** Variable `x3` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_x3` to suppress this warning. The unused variable is declared here: -**lambda_multi_arg_mismatch.md:5:25:5:27:** +**lambda_multi_arg_mismatch.md:3:25:3:27:** ```roc multi_arg_fn = |x1, x2, x3, x4, x5, x6, x7, x8| ``` @@ -48,7 +46,7 @@ Variable `x5` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_x5` to suppress this warning. The unused variable is declared here: -**lambda_multi_arg_mismatch.md:5:33:5:35:** +**lambda_multi_arg_mismatch.md:3:33:3:35:** ```roc multi_arg_fn = |x1, x2, x3, x4, x5, x6, x7, x8| ``` @@ -60,7 +58,7 @@ Variable `x7` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_x7` to suppress this warning. The unused variable is declared here: -**lambda_multi_arg_mismatch.md:5:41:5:43:** +**lambda_multi_arg_mismatch.md:3:41:3:43:** ```roc multi_arg_fn = |x1, x2, x3, x4, x5, x6, x7, x8| ``` @@ -69,7 +67,7 @@ multi_arg_fn = |x1, x2, x3, x4, x5, x6, x7, x8| **TYPE MISMATCH** The first and third arguments to `multi_arg_fn` must have compatible types, but they are incompatible in this call: -**lambda_multi_arg_mismatch.md:11:5:** +**lambda_multi_arg_mismatch.md:9:5:** ```roc 42, # x1: U64 (type 'a') "hello", # x2: Str (type 'b') - correct @@ -88,84 +86,81 @@ But the third argument has the type: # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -LowerIdent(4:1-4:13),OpColon(4:14-4:15),LowerIdent(4:16-4:17),Comma(4:17-4:18),LowerIdent(4:19-4:20),Comma(4:20-4:21),LowerIdent(4:22-4:23),Comma(4:23-4:24),LowerIdent(4:25-4:26),Comma(4:26-4:27),LowerIdent(4:28-4:29),Comma(4:29-4:30),LowerIdent(4:31-4:32),Comma(4:32-4:33),LowerIdent(4:34-4:35),Comma(4:35-4:36),LowerIdent(4:37-4:38),OpArrow(4:39-4:41),OpenRound(4:42-4:43),LowerIdent(4:43-4:44),Comma(4:44-4:45),LowerIdent(4:46-4:47),Comma(4:47-4:48),LowerIdent(4:49-4:50),Comma(4:50-4:51),LowerIdent(4:52-4:53),Comma(4:53-4:54),LowerIdent(4:55-4:56),CloseRound(4:56-4:57), -LowerIdent(5:1-5:13),OpAssign(5:14-5:15),OpBar(5:16-5:17),LowerIdent(5:17-5:19),Comma(5:19-5:20),LowerIdent(5:21-5:23),Comma(5:23-5:24),LowerIdent(5:25-5:27),Comma(5:27-5:28),LowerIdent(5:29-5:31),Comma(5:31-5:32),LowerIdent(5:33-5:35),Comma(5:35-5:36),LowerIdent(5:37-5:39),Comma(5:39-5:40),LowerIdent(5:41-5:43),Comma(5:43-5:44),LowerIdent(5:45-5:47),OpBar(5:47-5:48), -OpenRound(6:5-6:6),LowerIdent(6:6-6:8),Comma(6:8-6:9),LowerIdent(6:10-6:12),Comma(6:12-6:13),LowerIdent(6:14-6:16),Comma(6:16-6:17),LowerIdent(6:18-6:20),Comma(6:20-6:21),LowerIdent(6:22-6:24),CloseRound(6:24-6:25), -LowerIdent(10:1-10:7),OpAssign(10:8-10:9),LowerIdent(10:10-10:22),NoSpaceOpenRound(10:22-10:23), -Int(11:5-11:7),Comma(11:7-11:8), -StringStart(12:5-12:6),StringPart(12:6-12:11),StringEnd(12:11-12:12),Comma(12:12-12:13), -StringStart(13:5-13:6),StringPart(13:6-13:11),StringEnd(13:11-13:12),Comma(13:12-13:13), -Float(14:5-14:8),Comma(14:8-14:9), -Float(15:5-15:9),Comma(15:9-15:10), -OpenSquare(16:5-16:6),Int(16:6-16:7),Comma(16:7-16:8),Int(16:9-16:10),CloseSquare(16:10-16:11),Comma(16:11-16:12), -UpperIdent(17:5-17:9),Comma(17:9-17:10), -StringStart(18:5-18:6),StringPart(18:6-18:10),StringEnd(18:10-18:11),Comma(18:11-18:12), -CloseRound(19:1-19:2), -EndOfFile(20:1-20:1), +LowerIdent(2:1-2:13),OpColon(2:14-2:15),LowerIdent(2:16-2:17),Comma(2:17-2:18),LowerIdent(2:19-2:20),Comma(2:20-2:21),LowerIdent(2:22-2:23),Comma(2:23-2:24),LowerIdent(2:25-2:26),Comma(2:26-2:27),LowerIdent(2:28-2:29),Comma(2:29-2:30),LowerIdent(2:31-2:32),Comma(2:32-2:33),LowerIdent(2:34-2:35),Comma(2:35-2:36),LowerIdent(2:37-2:38),OpArrow(2:39-2:41),OpenRound(2:42-2:43),LowerIdent(2:43-2:44),Comma(2:44-2:45),LowerIdent(2:46-2:47),Comma(2:47-2:48),LowerIdent(2:49-2:50),Comma(2:50-2:51),LowerIdent(2:52-2:53),Comma(2:53-2:54),LowerIdent(2:55-2:56),CloseRound(2:56-2:57), +LowerIdent(3:1-3:13),OpAssign(3:14-3:15),OpBar(3:16-3:17),LowerIdent(3:17-3:19),Comma(3:19-3:20),LowerIdent(3:21-3:23),Comma(3:23-3:24),LowerIdent(3:25-3:27),Comma(3:27-3:28),LowerIdent(3:29-3:31),Comma(3:31-3:32),LowerIdent(3:33-3:35),Comma(3:35-3:36),LowerIdent(3:37-3:39),Comma(3:39-3:40),LowerIdent(3:41-3:43),Comma(3:43-3:44),LowerIdent(3:45-3:47),OpBar(3:47-3:48), +OpenRound(4:5-4:6),LowerIdent(4:6-4:8),Comma(4:8-4:9),LowerIdent(4:10-4:12),Comma(4:12-4:13),LowerIdent(4:14-4:16),Comma(4:16-4:17),LowerIdent(4:18-4:20),Comma(4:20-4:21),LowerIdent(4:22-4:24),CloseRound(4:24-4:25), +LowerIdent(8:1-8:7),OpAssign(8:8-8:9),LowerIdent(8:10-8:22),NoSpaceOpenRound(8:22-8:23), +Int(9:5-9:7),Comma(9:7-9:8), +StringStart(10:5-10:6),StringPart(10:6-10:11),StringEnd(10:11-10:12),Comma(10:12-10:13), +StringStart(11:5-11:6),StringPart(11:6-11:11),StringEnd(11:11-11:12),Comma(11:12-11:13), +Float(12:5-12:8),Comma(12:8-12:9), +Float(13:5-13:9),Comma(13:9-13:10), +OpenSquare(14:5-14:6),Int(14:6-14:7),Comma(14:7-14:8),Int(14:9-14:10),CloseSquare(14:10-14:11),Comma(14:11-14:12), +UpperIdent(15:5-15:9),Comma(15:9-15:10), +StringStart(16:5-16:6),StringPart(16:6-16:10),StringEnd(16:10-16:11),Comma(16:11-16:12), +CloseRound(17:1-17:2), +EndOfFile(18:1-18:1), ~~~ # PARSE ~~~clojure -(file @1.1-19.2 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @2.1-17.2 + (type-module @2.1-2.13) (statements - (s-type-anno @4.1-4.57 (name "multi_arg_fn") - (ty-fn @4.16-4.57 - (ty-var @4.16-4.17 (raw "a")) - (ty-var @4.19-4.20 (raw "b")) - (ty-var @4.22-4.23 (raw "a")) - (ty-var @4.25-4.26 (raw "c")) - (ty-var @4.28-4.29 (raw "a")) - (ty-var @4.31-4.32 (raw "d")) - (ty-var @4.34-4.35 (raw "a")) - (ty-var @4.37-4.38 (raw "e")) - (ty-tuple @4.42-4.57 - (ty-var @4.43-4.44 (raw "a")) - (ty-var @4.46-4.47 (raw "b")) - (ty-var @4.49-4.50 (raw "c")) - (ty-var @4.52-4.53 (raw "d")) - (ty-var @4.55-4.56 (raw "e"))))) - (s-decl @5.1-6.25 - (p-ident @5.1-5.13 (raw "multi_arg_fn")) - (e-lambda @5.16-6.25 + (s-type-anno @2.1-2.57 (name "multi_arg_fn") + (ty-fn @2.16-2.57 + (ty-var @2.16-2.17 (raw "a")) + (ty-var @2.19-2.20 (raw "b")) + (ty-var @2.22-2.23 (raw "a")) + (ty-var @2.25-2.26 (raw "c")) + (ty-var @2.28-2.29 (raw "a")) + (ty-var @2.31-2.32 (raw "d")) + (ty-var @2.34-2.35 (raw "a")) + (ty-var @2.37-2.38 (raw "e")) + (ty-tuple @2.42-2.57 + (ty-var @2.43-2.44 (raw "a")) + (ty-var @2.46-2.47 (raw "b")) + (ty-var @2.49-2.50 (raw "c")) + (ty-var @2.52-2.53 (raw "d")) + (ty-var @2.55-2.56 (raw "e"))))) + (s-decl @3.1-4.25 + (p-ident @3.1-3.13 (raw "multi_arg_fn")) + (e-lambda @3.16-4.25 (args - (p-ident @5.17-5.19 (raw "x1")) - (p-ident @5.21-5.23 (raw "x2")) - (p-ident @5.25-5.27 (raw "x3")) - (p-ident @5.29-5.31 (raw "x4")) - (p-ident @5.33-5.35 (raw "x5")) - (p-ident @5.37-5.39 (raw "x6")) - (p-ident @5.41-5.43 (raw "x7")) - (p-ident @5.45-5.47 (raw "x8"))) - (e-tuple @6.5-6.25 - (e-ident @6.6-6.8 (raw "x1")) - (e-ident @6.10-6.12 (raw "x2")) - (e-ident @6.14-6.16 (raw "x4")) - (e-ident @6.18-6.20 (raw "x6")) - (e-ident @6.22-6.24 (raw "x8"))))) - (s-decl @10.1-19.2 - (p-ident @10.1-10.7 (raw "result")) - (e-apply @10.10-19.2 - (e-ident @10.10-10.22 (raw "multi_arg_fn")) - (e-int @11.5-11.7 (raw "42")) - (e-string @12.5-12.12 - (e-string-part @12.6-12.11 (raw "hello"))) - (e-string @13.5-13.12 - (e-string-part @13.6-13.11 (raw "world"))) - (e-frac @14.5-14.8 (raw "1.5")) - (e-frac @15.5-15.9 (raw "3.14")) - (e-list @16.5-16.11 - (e-int @16.6-16.7 (raw "1")) - (e-int @16.9-16.10 (raw "2"))) - (e-tag @17.5-17.9 (raw "True")) - (e-string @18.5-18.11 - (e-string-part @18.6-18.10 (raw "done"))))))) + (p-ident @3.17-3.19 (raw "x1")) + (p-ident @3.21-3.23 (raw "x2")) + (p-ident @3.25-3.27 (raw "x3")) + (p-ident @3.29-3.31 (raw "x4")) + (p-ident @3.33-3.35 (raw "x5")) + (p-ident @3.37-3.39 (raw "x6")) + (p-ident @3.41-3.43 (raw "x7")) + (p-ident @3.45-3.47 (raw "x8"))) + (e-tuple @4.5-4.25 + (e-ident @4.6-4.8 (raw "x1")) + (e-ident @4.10-4.12 (raw "x2")) + (e-ident @4.14-4.16 (raw "x4")) + (e-ident @4.18-4.20 (raw "x6")) + (e-ident @4.22-4.24 (raw "x8"))))) + (s-decl @8.1-17.2 + (p-ident @8.1-8.7 (raw "result")) + (e-apply @8.10-17.2 + (e-ident @8.10-8.22 (raw "multi_arg_fn")) + (e-int @9.5-9.7 (raw "42")) + (e-string @10.5-10.12 + (e-string-part @10.6-10.11 (raw "hello"))) + (e-string @11.5-11.12 + (e-string-part @11.6-11.11 (raw "world"))) + (e-frac @12.5-12.8 (raw "1.5")) + (e-frac @13.5-13.9 (raw "3.14")) + (e-list @14.5-14.11 + (e-int @14.6-14.7 (raw "1")) + (e-int @14.9-14.10 (raw "2"))) + (e-tag @15.5-15.9 (raw "True")) + (e-string @16.5-16.11 + (e-string-part @16.6-16.10 (raw "done"))))))) ~~~ # FORMATTED ~~~roc -module [] - +# Function with 8 arguments where several types must match (a appears in positions 1, 3, 5, 7) # Function with 8 arguments where several types must match (a appears in positions 1, 3, 5, 7) multi_arg_fn : a, b, a, c, a, d, a, e -> (a, b, c, d, e) multi_arg_fn = |x1, x2, x3, x4, x5, x6, x7, x8| @@ -188,74 +183,74 @@ result = multi_arg_fn( ~~~clojure (can-ir (d-let - (p-assign @5.1-5.13 (ident "multi_arg_fn")) - (e-lambda @5.16-6.25 + (p-assign @3.1-3.13 (ident "multi_arg_fn")) + (e-lambda @3.16-4.25 (args - (p-assign @5.17-5.19 (ident "x1")) - (p-assign @5.21-5.23 (ident "x2")) - (p-assign @5.25-5.27 (ident "x3")) - (p-assign @5.29-5.31 (ident "x4")) - (p-assign @5.33-5.35 (ident "x5")) - (p-assign @5.37-5.39 (ident "x6")) - (p-assign @5.41-5.43 (ident "x7")) - (p-assign @5.45-5.47 (ident "x8"))) - (e-tuple @6.5-6.25 + (p-assign @3.17-3.19 (ident "x1")) + (p-assign @3.21-3.23 (ident "x2")) + (p-assign @3.25-3.27 (ident "x3")) + (p-assign @3.29-3.31 (ident "x4")) + (p-assign @3.33-3.35 (ident "x5")) + (p-assign @3.37-3.39 (ident "x6")) + (p-assign @3.41-3.43 (ident "x7")) + (p-assign @3.45-3.47 (ident "x8"))) + (e-tuple @4.5-4.25 (elems - (e-lookup-local @6.6-6.8 - (p-assign @5.17-5.19 (ident "x1"))) - (e-lookup-local @6.10-6.12 - (p-assign @5.21-5.23 (ident "x2"))) - (e-lookup-local @6.14-6.16 - (p-assign @5.29-5.31 (ident "x4"))) - (e-lookup-local @6.18-6.20 - (p-assign @5.37-5.39 (ident "x6"))) - (e-lookup-local @6.22-6.24 - (p-assign @5.45-5.47 (ident "x8")))))) - (annotation @5.1-5.13 + (e-lookup-local @4.6-4.8 + (p-assign @3.17-3.19 (ident "x1"))) + (e-lookup-local @4.10-4.12 + (p-assign @3.21-3.23 (ident "x2"))) + (e-lookup-local @4.14-4.16 + (p-assign @3.29-3.31 (ident "x4"))) + (e-lookup-local @4.18-4.20 + (p-assign @3.37-3.39 (ident "x6"))) + (e-lookup-local @4.22-4.24 + (p-assign @3.45-3.47 (ident "x8")))))) + (annotation @3.1-3.13 (declared-type - (ty-fn @4.16-4.57 (effectful false) - (ty-var @4.16-4.17 (name "a")) - (ty-var @4.19-4.20 (name "b")) - (ty-var @4.22-4.23 (name "a")) - (ty-var @4.25-4.26 (name "c")) - (ty-var @4.28-4.29 (name "a")) - (ty-var @4.31-4.32 (name "d")) - (ty-var @4.34-4.35 (name "a")) - (ty-var @4.37-4.38 (name "e")) - (ty-tuple @4.42-4.57 - (ty-var @4.43-4.44 (name "a")) - (ty-var @4.46-4.47 (name "b")) - (ty-var @4.49-4.50 (name "c")) - (ty-var @4.52-4.53 (name "d")) - (ty-var @4.55-4.56 (name "e"))))))) + (ty-fn @2.16-2.57 (effectful false) + (ty-rigid-var @2.16-2.17 (name "a")) + (ty-rigid-var @2.19-2.20 (name "b")) + (ty-rigid-var-lookup (ty-rigid-var @2.16-2.17 (name "a"))) + (ty-rigid-var @2.25-2.26 (name "c")) + (ty-rigid-var-lookup (ty-rigid-var @2.16-2.17 (name "a"))) + (ty-rigid-var @2.31-2.32 (name "d")) + (ty-rigid-var-lookup (ty-rigid-var @2.16-2.17 (name "a"))) + (ty-rigid-var @2.37-2.38 (name "e")) + (ty-tuple @2.42-2.57 + (ty-rigid-var-lookup (ty-rigid-var @2.16-2.17 (name "a"))) + (ty-rigid-var-lookup (ty-rigid-var @2.19-2.20 (name "b"))) + (ty-rigid-var-lookup (ty-rigid-var @2.25-2.26 (name "c"))) + (ty-rigid-var-lookup (ty-rigid-var @2.31-2.32 (name "d"))) + (ty-rigid-var-lookup (ty-rigid-var @2.37-2.38 (name "e")))))))) (d-let - (p-assign @10.1-10.7 (ident "result")) - (e-call @10.10-19.2 - (e-lookup-local @10.10-10.22 - (p-assign @5.1-5.13 (ident "multi_arg_fn"))) - (e-int @11.5-11.7 (value "42")) - (e-string @12.5-12.12 - (e-literal @12.6-12.11 (string "hello"))) - (e-string @13.5-13.12 - (e-literal @13.6-13.11 (string "world"))) - (e-dec-small @14.5-14.8 (numerator "15") (denominator-power-of-ten "1") (value "1.5")) - (e-dec-small @15.5-15.9 (numerator "314") (denominator-power-of-ten "2") (value "3.14")) - (e-list @16.5-16.11 + (p-assign @8.1-8.7 (ident "result")) + (e-call @8.10-17.2 + (e-lookup-local @8.10-8.22 + (p-assign @3.1-3.13 (ident "multi_arg_fn"))) + (e-num @9.5-9.7 (value "42")) + (e-string @10.5-10.12 + (e-literal @10.6-10.11 (string "hello"))) + (e-string @11.5-11.12 + (e-literal @11.6-11.11 (string "world"))) + (e-dec-small @12.5-12.8 (numerator "15") (denominator-power-of-ten "1") (value "1.5")) + (e-dec-small @13.5-13.9 (numerator "314") (denominator-power-of-ten "2") (value "3.14")) + (e-list @14.5-14.11 (elems - (e-int @16.6-16.7 (value "1")) - (e-int @16.9-16.10 (value "2")))) - (e-nominal @17.5-17.9 (nominal "Bool") - (e-tag @17.5-17.9 (name "True"))) - (e-string @18.5-18.11 - (e-literal @18.6-18.10 (string "done")))))) + (e-num @14.6-14.7 (value "1")) + (e-num @14.9-14.10 (value "2")))) + (e-nominal @15.5-15.9 (nominal "Bool") + (e-tag @15.5-15.9 (name "True"))) + (e-string @16.5-16.11 + (e-literal @16.6-16.10 (string "done")))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @5.1-5.13 (type "a, b, a, c, a, d, a, e -> (a, b, c, d, e)")) - (patt @10.1-10.7 (type "_f"))) + (patt @3.1-3.13 (type "a, b, a, c, a, d, a, e -> (a, b, c, d, e)")) + (patt @8.1-8.7 (type "Error"))) (expressions - (expr @5.16-6.25 (type "a, b, a, c, a, d, a, e -> (a, b, c, d, e)")) - (expr @10.10-19.2 (type "_f")))) + (expr @3.16-4.25 (type "a, b, a, c, a, d, a, e -> (a, b, c, d, e)")) + (expr @8.10-17.2 (type "Error")))) ~~~ diff --git a/test/snapshots/lambda_parameter_unused.md b/test/snapshots/lambda_parameter_unused.md index 9622235f93..c61a33efc3 100644 --- a/test/snapshots/lambda_parameter_unused.md +++ b/test/snapshots/lambda_parameter_unused.md @@ -209,12 +209,12 @@ main! = |_| { (e-lambda @5.7-5.18 (args (p-assign @5.8-5.14 (ident "unused"))) - (e-int @5.16-5.18 (value "42"))) + (e-num @5.16-5.18 (value "42"))) (annotation @5.1-5.4 (declared-type (ty-fn @4.7-4.17 (effectful false) - (ty @4.7-4.10 (name "U64")) - (ty @4.14-4.17 (name "U64")))))) + (ty-lookup @4.7-4.10 (name "U64") (builtin)) + (ty-lookup @4.14-4.17 (name "U64") (builtin)))))) (d-let (p-assign @9.1-9.9 (ident "multiply")) (e-lambda @9.12-9.33 @@ -223,23 +223,23 @@ main! = |_| { (e-binop @9.22-9.33 (op "mul") (e-lookup-local @9.22-9.29 (p-assign @9.13-9.20 (ident "_factor"))) - (e-int @9.32-9.33 (value "2")))) + (e-num @9.32-9.33 (value "2")))) (annotation @9.1-9.9 (declared-type (ty-fn @8.12-8.22 (effectful false) - (ty @8.12-8.15 (name "U64")) - (ty @8.19-8.22 (name "U64")))))) + (ty-lookup @8.12-8.15 (name "U64") (builtin)) + (ty-lookup @8.19-8.22 (name "U64") (builtin)))))) (d-let (p-assign @13.1-13.8 (ident "process")) (e-lambda @13.11-13.23 (args (p-assign @13.12-13.18 (ident "_input"))) - (e-int @13.20-13.23 (value "100"))) + (e-num @13.20-13.23 (value "100"))) (annotation @13.1-13.8 (declared-type (ty-fn @12.11-12.21 (effectful false) - (ty @12.11-12.14 (name "U64")) - (ty @12.18-12.21 (name "U64")))))) + (ty-lookup @12.11-12.14 (name "U64") (builtin)) + (ty-lookup @12.18-12.21 (name "U64") (builtin)))))) (d-let (p-assign @17.1-17.7 (ident "double")) (e-lambda @17.10-17.27 @@ -248,20 +248,20 @@ main! = |_| { (e-binop @17.18-17.27 (op "mul") (e-lookup-local @17.18-17.23 (p-assign @17.11-17.16 (ident "value"))) - (e-int @17.26-17.27 (value "2")))) + (e-num @17.26-17.27 (value "2")))) (annotation @17.1-17.7 (declared-type (ty-fn @16.10-16.20 (effectful false) - (ty @16.10-16.13 (name "U64")) - (ty @16.17-16.20 (name "U64")))))) + (ty-lookup @16.10-16.13 (name "U64") (builtin)) + (ty-lookup @16.17-16.20 (name "U64") (builtin)))))) (d-let (p-assign @19.1-19.6 (ident "main!")) (e-closure @19.9-25.2 (captures - (capture @5.1-5.4 (ident "add")) - (capture @13.1-13.8 (ident "process")) (capture @9.1-9.9 (ident "multiply")) - (capture @17.1-17.7 (ident "double"))) + (capture @5.1-5.4 (ident "add")) + (capture @17.1-17.7 (ident "double")) + (capture @13.1-13.8 (ident "process"))) (e-lambda @19.9-25.2 (args (p-underscore @19.10-19.11)) @@ -271,25 +271,25 @@ main! = |_| { (e-call @20.15-20.21 (e-lookup-local @20.15-20.18 (p-assign @5.1-5.4 (ident "add"))) - (e-int @20.19-20.20 (value "5")))) + (e-num @20.19-20.20 (value "5")))) (s-let @21.5-21.26 (p-assign @21.5-21.12 (ident "result2")) (e-call @21.15-21.26 (e-lookup-local @21.15-21.23 (p-assign @9.1-9.9 (ident "multiply"))) - (e-int @21.24-21.25 (value "3")))) + (e-num @21.24-21.25 (value "3")))) (s-let @22.5-22.25 (p-assign @22.5-22.12 (ident "result3")) (e-call @22.15-22.25 (e-lookup-local @22.15-22.22 (p-assign @13.1-13.8 (ident "process"))) - (e-int @22.23-22.24 (value "7")))) + (e-num @22.23-22.24 (value "7")))) (s-let @23.5-23.24 (p-assign @23.5-23.12 (ident "result4")) (e-call @23.15-23.24 (e-lookup-local @23.15-23.21 (p-assign @17.1-17.7 (ident "double"))) - (e-int @23.22-23.23 (value "4")))) + (e-num @23.22-23.23 (value "4")))) (e-binop @24.5-24.42 (op "add") (e-binop @24.5-24.32 (op "add") (e-binop @24.5-24.22 (op "add") @@ -306,15 +306,15 @@ main! = |_| { ~~~clojure (inferred-types (defs - (patt @5.1-5.4 (type "U64 -> U64")) - (patt @9.1-9.9 (type "U64 -> U64")) - (patt @13.1-13.8 (type "U64 -> U64")) - (patt @17.1-17.7 (type "U64 -> U64")) - (patt @19.1-19.6 (type "_arg -> Num(_size)"))) + (patt @5.1-5.4 (type "Num(Int(Unsigned64)) -> Num(Int(Unsigned64))")) + (patt @9.1-9.9 (type "Num(Int(Unsigned64)) -> Num(Int(Unsigned64))")) + (patt @13.1-13.8 (type "Num(Int(Unsigned64)) -> Num(Int(Unsigned64))")) + (patt @17.1-17.7 (type "Num(Int(Unsigned64)) -> Num(Int(Unsigned64))")) + (patt @19.1-19.6 (type "_arg -> Num(Int(Unsigned64))"))) (expressions - (expr @5.7-5.18 (type "U64 -> U64")) - (expr @9.12-9.33 (type "U64 -> U64")) - (expr @13.11-13.23 (type "U64 -> U64")) - (expr @17.10-17.27 (type "U64 -> U64")) - (expr @19.9-25.2 (type "_arg -> Num(_size)")))) + (expr @5.7-5.18 (type "Num(Int(Unsigned64)) -> Num(Int(Unsigned64))")) + (expr @9.12-9.33 (type "Num(Int(Unsigned64)) -> Num(Int(Unsigned64))")) + (expr @13.11-13.23 (type "Num(Int(Unsigned64)) -> Num(Int(Unsigned64))")) + (expr @17.10-17.27 (type "Num(Int(Unsigned64)) -> Num(Int(Unsigned64))")) + (expr @19.9-25.2 (type "_arg -> Num(Int(Unsigned64))")))) ~~~ diff --git a/test/snapshots/lambda_ret_constraint_bug.md b/test/snapshots/lambda_ret_constraint_bug.md index 5b86cac7d9..4a98df615d 100644 --- a/test/snapshots/lambda_ret_constraint_bug.md +++ b/test/snapshots/lambda_ret_constraint_bug.md @@ -83,12 +83,12 @@ NO CHANGE (e-binop @4.14-4.19 (op "mul") (e-lookup-local @4.14-4.15 (p-assign @4.11-4.12 (ident "n"))) - (e-int @4.18-4.19 (value "2")))) + (e-num @4.18-4.19 (value "2")))) (annotation @4.1-4.7 (declared-type (ty-fn @3.10-3.20 (effectful false) - (ty @3.10-3.13 (name "I64")) - (ty @3.17-3.20 (name "I64")))))) + (ty-lookup @3.10-3.13 (name "I64") (builtin)) + (ty-lookup @3.17-3.20 (name "I64") (builtin)))))) (d-let (p-assign @7.1-7.5 (ident "main")) (e-closure @7.8-7.24 @@ -101,21 +101,21 @@ NO CHANGE (e-call @7.15-7.24 (e-lookup-local @7.15-7.21 (p-assign @4.1-4.7 (ident "helper"))) - (e-int @7.22-7.23 (value "5"))))) + (e-num @7.22-7.23 (value "5"))))) (annotation @7.1-7.5 (declared-type (ty-fn @6.8-6.23 (effectful false) - (ty @6.8-6.11 (name "I64")) - (ty @6.13-6.16 (name "I64")) - (ty @6.20-6.23 (name "I64"))))))) + (ty-lookup @6.8-6.11 (name "I64") (builtin)) + (ty-lookup @6.13-6.16 (name "I64") (builtin)) + (ty-lookup @6.20-6.23 (name "I64") (builtin))))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @4.1-4.7 (type "I64 -> I64")) - (patt @7.1-7.5 (type "I64, I64 -> I64"))) + (patt @4.1-4.7 (type "Num(Int(Signed64)) -> Num(Int(Signed64))")) + (patt @7.1-7.5 (type "Num(Int(Signed64)), Num(Int(Signed64)) -> Num(Int(Signed64))"))) (expressions - (expr @4.10-4.19 (type "I64 -> I64")) - (expr @7.8-7.24 (type "I64, I64 -> I64")))) + (expr @4.10-4.19 (type "Num(Int(Signed64)) -> Num(Int(Signed64))")) + (expr @7.8-7.24 (type "Num(Int(Signed64)), Num(Int(Signed64)) -> Num(Int(Signed64))")))) ~~~ diff --git a/test/snapshots/let_polymorphism_complex.md b/test/snapshots/let_polymorphism_complex.md index ab6a5d8a5b..30d9a2213b 100644 --- a/test/snapshots/let_polymorphism_complex.md +++ b/test/snapshots/let_polymorphism_complex.md @@ -643,7 +643,7 @@ main = |_| { (can-ir (d-let (p-assign @4.1-4.4 (ident "num")) - (e-int @4.7-4.9 (value "42"))) + (e-num @4.7-4.9 (value "42"))) (d-let (p-assign @5.1-5.5 (ident "frac")) (e-dec-small @5.8-5.11 (numerator "42") (denominator-power-of-ten "1") (value "4.2"))) @@ -665,9 +665,9 @@ main = |_| { (p-assign @14.1-14.9 (ident "int_list")) (e-list @14.12-14.21 (elems - (e-int @14.13-14.14 (value "1")) - (e-int @14.16-14.17 (value "2")) - (e-int @14.19-14.20 (value "3"))))) + (e-num @14.13-14.14 (value "1")) + (e-num @14.16-14.17 (value "2")) + (e-num @14.19-14.20 (value "3"))))) (d-let (p-assign @15.1-15.9 (ident "str_list")) (e-list @15.12-15.27 @@ -704,14 +704,14 @@ main = |_| { (p-assign @10.1-10.11 (ident "empty_list"))) (e-list @20.29-20.35 (elems - (e-int @20.30-20.31 (value "1")) - (e-int @20.33-20.34 (value "2")))) + (e-num @20.30-20.31 (value "1")) + (e-num @20.33-20.34 (value "2")))) (e-lookup-local @20.37-20.47 (p-assign @10.1-10.11 (ident "empty_list"))) (e-list @20.49-20.55 (elems - (e-int @20.50-20.51 (value "3")) - (e-int @20.53-20.54 (value "4"))))))) + (e-num @20.50-20.51 (value "3")) + (e-num @20.53-20.54 (value "4"))))))) (d-let (p-assign @23.1-23.12 (ident "poly_record")) (e-record @23.15-23.46 @@ -720,7 +720,7 @@ main = |_| { (e-lookup-local @23.24-23.34 (p-assign @10.1-10.11 (ident "empty_list")))) (field (name "count") - (e-int @23.43-23.44 (value "0")))))) + (e-num @23.43-23.44 (value "0")))))) (d-let (p-assign @24.1-24.17 (ident "use_poly_record1")) (e-record @24.20-24.50 @@ -728,11 +728,11 @@ main = |_| { (field (name "items") (e-list @24.29-24.38 (elems - (e-int @24.30-24.31 (value "1")) - (e-int @24.33-24.34 (value "2")) - (e-int @24.36-24.37 (value "3"))))) + (e-num @24.30-24.31 (value "1")) + (e-num @24.33-24.34 (value "2")) + (e-num @24.36-24.37 (value "3"))))) (field (name "count") - (e-int @24.47-24.48 (value "0")))))) + (e-num @24.47-24.48 (value "0")))))) (d-let (p-assign @25.1-25.17 (ident "use_poly_record2")) (e-record @25.20-25.56 @@ -747,7 +747,7 @@ main = |_| { (e-string @25.40-25.43 (e-literal @25.41-25.42 (string "z")))))) (field (name "count") - (e-int @25.53-25.54 (value "0")))))) + (e-num @25.53-25.54 (value "0")))))) (d-let (p-assign @28.1-28.12 (ident "base_config")) (e-record @28.15-35.2 @@ -774,11 +774,11 @@ main = |_| { (field (name "data") (e-list @39.11-39.26 (elems - (e-int @39.12-39.13 (value "1")) - (e-int @39.15-39.16 (value "2")) - (e-int @39.18-39.19 (value "3")) - (e-int @39.21-39.22 (value "4")) - (e-int @39.24-39.25 (value "5"))))) + (e-num @39.12-39.13 (value "1")) + (e-num @39.15-39.16 (value "2")) + (e-num @39.18-39.19 (value "3")) + (e-num @39.21-39.22 (value "4")) + (e-num @39.24-39.25 (value "5"))))) (field (name "metadata") (e-record @40.15-44.6 (fields @@ -885,11 +885,11 @@ main = |_| { (e-binop @72.26-72.33 (op "mul") (e-lookup-local @72.26-72.29 (p-assign @4.1-4.4 (ident "num"))) - (e-int @72.32-72.33 (value "2"))) + (e-num @72.32-72.33 (value "2"))) (e-binop @72.35-72.42 (op "mul") (e-lookup-local @72.35-72.38 (p-assign @4.1-4.4 (ident "num"))) - (e-int @72.41-72.42 (value "3"))))))))) + (e-num @72.41-72.42 (value "3"))))))))) (field (name "collection") (e-lookup-local @74.21-74.31 (p-assign @10.1-10.11 (ident "empty_list"))))))) @@ -901,7 +901,7 @@ main = |_| { (field (name "data") (e-list @77.17-77.20 (elems - (e-int @77.18-77.19 (value "1"))))) + (e-num @77.18-77.19 (value "1"))))) (field (name "tag") (e-string @77.27-77.35 (e-literal @77.28-77.34 (string "single")))))) @@ -910,8 +910,8 @@ main = |_| { (field (name "data") (e-list @78.17-78.23 (elems - (e-int @78.18-78.19 (value "1")) - (e-int @78.21-78.22 (value "2"))))) + (e-num @78.18-78.19 (value "1")) + (e-num @78.21-78.22 (value "2"))))) (field (name "tag") (e-string @78.30-78.36 (e-literal @78.31-78.35 (string "ints")))))) @@ -920,9 +920,9 @@ main = |_| { (field (name "data") (e-list @79.17-79.26 (elems - (e-int @79.18-79.19 (value "1")) - (e-int @79.21-79.22 (value "2")) - (e-int @79.24-79.25 (value "3"))))) + (e-num @79.18-79.19 (value "1")) + (e-num @79.21-79.22 (value "2")) + (e-num @79.24-79.25 (value "3"))))) (field (name "tag") (e-string @79.33-79.39 (e-literal @79.34-79.38 (string "more")))))))))))) @@ -931,13 +931,13 @@ main = |_| { (e-binop @84.12-84.20 (op "add") (e-lookup-local @84.12-84.15 (p-assign @4.1-4.4 (ident "num"))) - (e-int @84.18-84.20 (value "10")))) + (e-num @84.18-84.20 (value "10")))) (d-let (p-assign @85.1-85.9 (ident "compute2")) (e-binop @85.12-85.19 (op "mul") (e-lookup-local @85.12-85.15 (p-assign @4.1-4.4 (ident "num"))) - (e-int @85.18-85.19 (value "2")))) + (e-num @85.18-85.19 (value "2")))) (d-let (p-assign @86.1-86.9 (ident "compute3")) (e-list @86.12-86.22 @@ -961,11 +961,11 @@ main = |_| { (e-binop @87.40-87.47 (op "add") (e-lookup-local @87.40-87.43 (p-assign @4.1-4.4 (ident "num"))) - (e-int @87.46-87.47 (value "1"))) + (e-num @87.46-87.47 (value "1"))) (e-binop @87.49-87.56 (op "add") (e-lookup-local @87.49-87.52 (p-assign @4.1-4.4 (ident "num"))) - (e-int @87.55-87.56 (value "2"))))))))) + (e-num @87.55-87.56 (value "2"))))))))) (d-let (p-assign @90.1-90.6 (ident "mixed")) (e-record @90.9-103.2 @@ -1023,7 +1023,7 @@ main = |_| { (e-binop @99.19-99.28 (op "mul") (e-lookup-local @99.19-99.22 (p-assign @4.1-4.4 (ident "num"))) - (e-int @99.25-99.28 (value "100")))) + (e-num @99.25-99.28 (value "100")))) (field (name "from_frac") (e-binop @100.20-100.31 (op "mul") (e-lookup-local @100.20-100.24 @@ -1052,14 +1052,14 @@ main = |_| { (receiver (e-lookup-local @107.5-107.15 (p-assign @60.1-60.11 (ident "container1"))))) - (e-int @107.24-107.26 (value "10")))))))) + (e-num @107.24-107.26 (value "10")))))))) ~~~ # TYPES ~~~clojure (inferred-types (defs (patt @4.1-4.4 (type "Num(_size)")) - (patt @5.1-5.5 (type "Frac(_size)")) + (patt @5.1-5.5 (type "Num(Frac(_size))")) (patt @6.1-6.4 (type "Str")) (patt @7.1-7.5 (type "Bool")) (patt @10.1-10.11 (type "List(Num(_size))")) @@ -1069,26 +1069,26 @@ main = |_| { (patt @16.1-16.10 (type "List(Bool)")) (patt @19.1-19.13 (type "List(List(Num(_size)))")) (patt @20.1-20.13 (type "List(List(Num(_size)))")) - (patt @23.1-23.12 (type "{ items: List(Num(_size)), count: Num(_size2) }")) - (patt @24.1-24.17 (type "{ items: List(Num(_size)), count: Num(_size2) }")) - (patt @25.1-25.17 (type "{ items: List(Str), count: Num(_size) }")) - (patt @28.1-28.12 (type "{ data: List(Num(_size)), metadata: { version: Num(_size2), ratio: Frac(_size3), description: Str } }")) - (patt @38.1-38.8 (type "{ data: List(Num(_size)), metadata: { version: Num(_size2), ratio: Frac(_size3), description: Str }, name: Str }")) - (patt @48.1-48.8 (type "{ data: List(Str), metadata: { version: Num(_size), ratio: Frac(_size2), description: Str }, name: Str }")) - (patt @59.1-59.15 (type "_arg -> { value: _field, wrapper: List(_elem) }")) + (patt @23.1-23.12 (type "{ count: Num(_size), items: List(Num(_size2)) }")) + (patt @24.1-24.17 (type "{ count: Num(_size), items: List(Num(_size2)) }")) + (patt @25.1-25.17 (type "{ count: Num(_size), items: List(Str) }")) + (patt @28.1-28.12 (type "{ data: List(Num(_size)), metadata: { description: Str, ratio: Num(Frac(_size2)), version: Num(_size3) } }")) + (patt @38.1-38.8 (type "{ data: List(Num(_size)), metadata: { description: Str, ratio: Num(Frac(_size2)), version: Num(_size3) }, name: Str }")) + (patt @48.1-48.8 (type "{ data: List(Str), metadata: { description: Str, ratio: Num(Frac(_size)), version: Num(_size2) }, name: Str }")) + (patt @59.1-59.15 (type "a -> { value: a, wrapper: List(a) }")) (patt @60.1-60.11 (type "{ value: Num(_size), wrapper: List(Num(_size2)) }")) (patt @61.1-61.11 (type "{ value: Str, wrapper: List(Str) }")) - (patt @62.1-62.11 (type "{ value: Frac(_size), wrapper: List(Frac(_size2)) }")) - (patt @65.1-65.5 (type "{ level1: { level2: { level3: { data: List(Num(_size)), value: Num(_size2) }, items: List(Num(_size3)) }, collection: List(Num(_size4)) }, results: List({ data: List(Num(_size5)), tag: Str }) }")) + (patt @62.1-62.11 (type "{ value: Num(Frac(_size)), wrapper: List(Num(Frac(_size2))) }")) + (patt @65.1-65.5 (type "{ level1: { collection: List(Num(_size)), level2: { items: List(Num(_size2)), level3: { data: List(Num(_size3)), value: Num(_size4) } } }, results: List({ data: List(Num(_size5)), tag: Str }) }")) (patt @84.1-84.9 (type "Num(_size)")) (patt @85.1-85.9 (type "Num(_size)")) (patt @86.1-86.9 (type "List(Num(_size))")) (patt @87.1-87.9 (type "{ base: Num(_size), derived: List(Num(_size2)) }")) - (patt @90.1-90.6 (type "{ numbers: { value: Num(_size), list: List(Num(_size2)), float: Frac(_size3) }, strings: { value: Str, list: List(Str) }, empty_lists: { raw: List(Num(_size4)), in_list: List(List(Num(_size5))), in_record: { data: List(Num(_size6)) } }, computations: { from_num: Num(_size7), from_frac: Num(_size8), list_from_num: List(Num(_size9)) } }")) + (patt @90.1-90.6 (type "{ computations: { from_frac: Num(Frac(_size)), from_num: Num(_size2), list_from_num: List(Num(_size3)) }, empty_lists: { in_list: List(List(Num(_size4))), in_record: { data: List(Num(_size5)) }, raw: List(Num(_size6)) }, numbers: { float: Num(Frac(_size7)), list: List(Num(_size8)), value: Num(_size9) }, strings: { list: List(Str), value: Str } }")) (patt @105.1-105.5 (type "_arg -> Num(_size)"))) (expressions (expr @4.7-4.9 (type "Num(_size)")) - (expr @5.8-5.11 (type "Frac(_size)")) + (expr @5.8-5.11 (type "Num(Frac(_size))")) (expr @6.7-6.14 (type "Str")) (expr @7.8-7.12 (type "Bool")) (expr @10.14-10.16 (type "List(Num(_size))")) @@ -1098,21 +1098,21 @@ main = |_| { (expr @16.13-16.26 (type "List(Bool)")) (expr @19.16-19.52 (type "List(List(Num(_size)))")) (expr @20.16-20.56 (type "List(List(Num(_size)))")) - (expr @23.15-23.46 (type "{ items: List(Num(_size)), count: Num(_size2) }")) - (expr @24.20-24.50 (type "{ items: List(Num(_size)), count: Num(_size2) }")) - (expr @25.20-25.56 (type "{ items: List(Str), count: Num(_size) }")) - (expr @28.15-35.2 (type "{ data: List(Num(_size)), metadata: { version: Num(_size2), ratio: Frac(_size3), description: Str } }")) - (expr @38.11-46.2 (type "{ data: List(Num(_size)), metadata: { version: Num(_size2), ratio: Frac(_size3), description: Str }, name: Str }")) - (expr @48.11-56.2 (type "{ data: List(Str), metadata: { version: Num(_size), ratio: Frac(_size2), description: Str }, name: Str }")) - (expr @59.18-59.54 (type "_arg -> { value: _field, wrapper: List(_elem) }")) + (expr @23.15-23.46 (type "{ count: Num(_size), items: List(Num(_size2)) }")) + (expr @24.20-24.50 (type "{ count: Num(_size), items: List(Num(_size2)) }")) + (expr @25.20-25.56 (type "{ count: Num(_size), items: List(Str) }")) + (expr @28.15-35.2 (type "{ data: List(Num(_size)), metadata: { description: Str, ratio: Num(Frac(_size2)), version: Num(_size3) } }")) + (expr @38.11-46.2 (type "{ data: List(Num(_size)), metadata: { description: Str, ratio: Num(Frac(_size2)), version: Num(_size3) }, name: Str }")) + (expr @48.11-56.2 (type "{ data: List(Str), metadata: { description: Str, ratio: Num(Frac(_size)), version: Num(_size2) }, name: Str }")) + (expr @59.18-59.54 (type "a -> { value: a, wrapper: List(a) }")) (expr @60.14-60.33 (type "{ value: Num(_size), wrapper: List(Num(_size2)) }")) (expr @61.14-61.33 (type "{ value: Str, wrapper: List(Str) }")) - (expr @62.14-62.34 (type "{ value: Frac(_size), wrapper: List(Frac(_size2)) }")) - (expr @65.8-81.2 (type "{ level1: { level2: { level3: { data: List(Num(_size)), value: Num(_size2) }, items: List(Num(_size3)) }, collection: List(Num(_size4)) }, results: List({ data: List(Num(_size5)), tag: Str }) }")) + (expr @62.14-62.34 (type "{ value: Num(Frac(_size)), wrapper: List(Num(Frac(_size2))) }")) + (expr @65.8-81.2 (type "{ level1: { collection: List(Num(_size)), level2: { items: List(Num(_size2)), level3: { data: List(Num(_size3)), value: Num(_size4) } } }, results: List({ data: List(Num(_size5)), tag: Str }) }")) (expr @84.12-84.20 (type "Num(_size)")) (expr @85.12-85.19 (type "Num(_size)")) (expr @86.12-86.22 (type "List(Num(_size))")) (expr @87.12-87.59 (type "{ base: Num(_size), derived: List(Num(_size2)) }")) - (expr @90.9-103.2 (type "{ numbers: { value: Num(_size), list: List(Num(_size2)), float: Frac(_size3) }, strings: { value: Str, list: List(Str) }, empty_lists: { raw: List(Num(_size4)), in_list: List(List(Num(_size5))), in_record: { data: List(Num(_size6)) } }, computations: { from_num: Num(_size7), from_frac: Num(_size8), list_from_num: List(Num(_size9)) } }")) + (expr @90.9-103.2 (type "{ computations: { from_frac: Num(Frac(_size)), from_num: Num(_size2), list_from_num: List(Num(_size3)) }, empty_lists: { in_list: List(List(Num(_size4))), in_record: { data: List(Num(_size5)) }, raw: List(Num(_size6)) }, numbers: { float: Num(Frac(_size7)), list: List(Num(_size8)), value: Num(_size9) }, strings: { list: List(Str), value: Str } }")) (expr @105.8-108.2 (type "_arg -> Num(_size)")))) ~~~ diff --git a/test/snapshots/let_polymorphism_error.md b/test/snapshots/let_polymorphism_error.md index 2ecee11877..63e6a0f743 100644 --- a/test/snapshots/let_polymorphism_error.md +++ b/test/snapshots/let_polymorphism_error.md @@ -19,7 +19,7 @@ The second and third elements in this list have incompatible types: ^^^ ^^^^^^^ The second element has this type: - _Frac(_size)_ + _Num(Frac(_size))_ However, the third element has this type: _Str_ @@ -50,7 +50,7 @@ NO CHANGE ~~~clojure (e-list @1.1-1.19 (elems - (e-int @1.2-1.4 (value "42")) + (e-num @1.2-1.4 (value "42")) (e-dec-small @1.6-1.9 (numerator "42") (denominator-power-of-ten "1") (value "4.2")) (e-string @1.11-1.18 (e-literal @1.12-1.17 (string "hello"))))) diff --git a/test/snapshots/let_polymorphism_expr.md b/test/snapshots/let_polymorphism_expr.md index 51c834607f..b84fabcf22 100644 --- a/test/snapshots/let_polymorphism_expr.md +++ b/test/snapshots/let_polymorphism_expr.md @@ -67,9 +67,9 @@ match [] { (field (name "ints") (e-list @2.22-2.31 (elems - (e-int @2.23-2.24 (value "1")) - (e-int @2.26-2.27 (value "2")) - (e-int @2.29-2.30 (value "3"))))) + (e-num @2.23-2.24 (value "1")) + (e-num @2.26-2.27 (value "2")) + (e-num @2.29-2.30 (value "3"))))) (field (name "strs") (e-list @2.39-2.54 (elems @@ -85,5 +85,5 @@ match [] { ~~~ # TYPES ~~~clojure -(expr @1.1-3.2 (type "{ ints: List(Num(_size)), strs: List(Str), empty: List(_elem) }")) +(expr @1.1-3.2 (type "{ empty: List(_elem), ints: List(Num(_size)), strs: List(Str) }")) ~~~ diff --git a/test/snapshots/let_polymorphism_lists.md b/test/snapshots/let_polymorphism_lists.md index d227510750..9d4026aed6 100644 --- a/test/snapshots/let_polymorphism_lists.md +++ b/test/snapshots/let_polymorphism_lists.md @@ -347,9 +347,9 @@ main = |_| { (p-assign @7.1-7.9 (ident "int_list")) (e-list @7.12-7.21 (elems - (e-int @7.13-7.14 (value "1")) - (e-int @7.16-7.17 (value "2")) - (e-int @7.19-7.20 (value "3"))))) + (e-num @7.13-7.14 (value "1")) + (e-num @7.16-7.17 (value "2")) + (e-num @7.19-7.20 (value "3"))))) (d-let (p-assign @8.1-8.9 (ident "str_list")) (e-list @8.12-8.30 @@ -385,7 +385,7 @@ main = |_| { (e-call @20.18-20.31 (e-lookup-local @20.18-20.27 (p-assign @17.1-17.10 (ident "get_empty"))) - (e-int @20.28-20.30 (value "42")))) + (e-num @20.28-20.30 (value "42")))) (d-let (p-assign @21.1-21.15 (ident "empty_str_list")) (e-call @21.18-21.35 @@ -397,9 +397,9 @@ main = |_| { (p-assign @23.1-23.5 (ident "main")) (e-closure @23.8-29.2 (captures - (capture @13.1-13.13 (ident "all_str_list")) (capture @14.1-14.15 (ident "all_float_list")) - (capture @12.1-12.13 (ident "all_int_list"))) + (capture @12.1-12.13 (ident "all_int_list")) + (capture @13.1-13.13 (ident "all_str_list"))) (e-lambda @23.8-29.2 (args (p-underscore @23.9-23.10)) @@ -438,7 +438,7 @@ main = |_| { (patt @4.1-4.14 (type "List(_elem)")) (patt @7.1-7.9 (type "List(Num(_size))")) (patt @8.1-8.9 (type "List(Str)")) - (patt @9.1-9.11 (type "List(Frac(_size))")) + (patt @9.1-9.11 (type "List(Num(Frac(_size)))")) (patt @12.1-12.13 (type "Error")) (patt @13.1-13.13 (type "Error")) (patt @14.1-14.15 (type "Error")) @@ -450,7 +450,7 @@ main = |_| { (expr @4.17-4.19 (type "List(_elem)")) (expr @7.12-7.21 (type "List(Num(_size))")) (expr @8.12-8.30 (type "List(Str)")) - (expr @9.14-9.29 (type "List(Frac(_size))")) + (expr @9.14-9.29 (type "List(Num(Frac(_size)))")) (expr @12.16-12.27 (type "Error")) (expr @13.16-13.27 (type "Error")) (expr @14.18-14.31 (type "Error")) diff --git a/test/snapshots/let_polymorphism_numbers.md b/test/snapshots/let_polymorphism_numbers.md index 8aa37c91ba..16da6ab7a9 100644 --- a/test/snapshots/let_polymorphism_numbers.md +++ b/test/snapshots/let_polymorphism_numbers.md @@ -171,7 +171,7 @@ main = |_| { (can-ir (d-let (p-assign @4.1-4.4 (ident "num")) - (e-int @4.7-4.9 (value "42"))) + (e-num @4.7-4.9 (value "42"))) (d-let (p-assign @5.1-5.5 (ident "frac")) (e-dec-small @5.8-5.11 (numerator "42") (denominator-power-of-ten "1") (value "4.2"))) @@ -188,13 +188,13 @@ main = |_| { (e-binop @12.11-12.19 (op "add") (e-lookup-local @12.11-12.14 (p-assign @4.1-4.4 (ident "num"))) - (e-int @12.17-12.19 (value "10")))) + (e-num @12.17-12.19 (value "10")))) (d-let (p-assign @13.1-13.13 (ident "int_multiply")) (e-binop @13.16-13.23 (op "mul") (e-lookup-local @13.16-13.19 (p-assign @4.1-4.4 (ident "num"))) - (e-int @13.22-13.23 (value "2")))) + (e-num @13.22-13.23 (value "2")))) (d-let (p-assign @16.1-16.10 (ident "float_add")) (e-binop @16.13-16.23 (op "add") @@ -215,13 +215,13 @@ main = |_| { (e-binop @20.14-20.19 (op "mul") (e-lookup-local @20.14-20.15 (p-assign @20.11-20.12 (ident "x"))) - (e-int @20.18-20.19 (value "2"))))) + (e-num @20.18-20.19 (value "2"))))) (d-let (p-assign @23.1-23.12 (ident "int_doubled")) (e-call @23.15-23.24 (e-lookup-local @23.15-23.21 (p-assign @20.1-20.7 (ident "double"))) - (e-int @23.22-23.23 (value "5")))) + (e-num @23.22-23.23 (value "5")))) (d-let (p-assign @24.1-24.14 (ident "float_doubled")) (e-call @24.17-24.28 @@ -248,29 +248,29 @@ main = |_| { ~~~clojure (inferred-types (defs - (patt @4.1-4.4 (type "Num(_size)")) - (patt @5.1-5.5 (type "Frac(_size)")) - (patt @8.1-8.8 (type "Num(_size)")) - (patt @9.1-9.10 (type "Frac(_size)")) - (patt @12.1-12.8 (type "Num(_size)")) - (patt @13.1-13.13 (type "Num(_size)")) - (patt @16.1-16.10 (type "Num(_size)")) - (patt @17.1-17.15 (type "Num(_size)")) + (patt @4.1-4.4 (type "Num(Frac(_size))")) + (patt @5.1-5.5 (type "Num(Frac(_size))")) + (patt @8.1-8.8 (type "Num(Frac(_size))")) + (patt @9.1-9.10 (type "Num(Frac(_size))")) + (patt @12.1-12.8 (type "Num(Frac(_size))")) + (patt @13.1-13.13 (type "Num(Frac(_size))")) + (patt @16.1-16.10 (type "Num(Frac(_size))")) + (patt @17.1-17.15 (type "Num(Frac(_size))")) (patt @20.1-20.7 (type "Num(_size) -> Num(_size2)")) (patt @23.1-23.12 (type "Num(_size)")) - (patt @24.1-24.14 (type "Num(_size)")) - (patt @26.1-26.5 (type "_arg -> Num(_size)"))) + (patt @24.1-24.14 (type "Num(Frac(_size))")) + (patt @26.1-26.5 (type "_arg -> Num(Frac(_size))"))) (expressions - (expr @4.7-4.9 (type "Num(_size)")) - (expr @5.8-5.11 (type "Frac(_size)")) - (expr @8.11-8.14 (type "Num(_size)")) - (expr @9.13-9.17 (type "Frac(_size)")) - (expr @12.11-12.19 (type "Num(_size)")) - (expr @13.16-13.23 (type "Num(_size)")) - (expr @16.13-16.23 (type "Num(_size)")) - (expr @17.18-17.27 (type "Num(_size)")) + (expr @4.7-4.9 (type "Num(Frac(_size))")) + (expr @5.8-5.11 (type "Num(Frac(_size))")) + (expr @8.11-8.14 (type "Num(Frac(_size))")) + (expr @9.13-9.17 (type "Num(Frac(_size))")) + (expr @12.11-12.19 (type "Num(Frac(_size))")) + (expr @13.16-13.23 (type "Num(Frac(_size))")) + (expr @16.13-16.23 (type "Num(Frac(_size))")) + (expr @17.18-17.27 (type "Num(Frac(_size))")) (expr @20.10-20.19 (type "Num(_size) -> Num(_size2)")) (expr @23.15-23.24 (type "Num(_size)")) - (expr @24.17-24.28 (type "Num(_size)")) - (expr @26.8-29.2 (type "_arg -> Num(_size)")))) + (expr @24.17-24.28 (type "Num(Frac(_size))")) + (expr @26.8-29.2 (type "_arg -> Num(Frac(_size))")))) ~~~ diff --git a/test/snapshots/let_polymorphism_records.md b/test/snapshots/let_polymorphism_records.md index b830e60465..d7621f9d61 100644 --- a/test/snapshots/let_polymorphism_records.md +++ b/test/snapshots/let_polymorphism_records.md @@ -277,7 +277,7 @@ main = |_| { (can-ir (d-let (p-assign @4.1-4.4 (ident "num")) - (e-int @4.7-4.9 (value "42"))) + (e-num @4.7-4.9 (value "42"))) (d-let (p-assign @5.1-5.5 (ident "frac")) (e-dec-small @5.8-5.11 (numerator "42") (denominator-power-of-ten "1") (value "4.2"))) @@ -307,7 +307,7 @@ main = |_| { (e-lookup-local @11.34-11.39 (p-assign @11.19-11.24 (ident "value")))) (field (name "count") - (e-int @11.48-11.49 (value "1"))))))) + (e-num @11.48-11.49 (value "1"))))))) (d-let (p-assign @14.1-14.14 (ident "int_container")) (e-call @14.17-14.36 @@ -341,8 +341,6 @@ main = |_| { (p-assign @19.16-19.25 (ident "container")))) (s-expr @19.50-19.51 (e-runtime-error (tag "expr_not_canonicalized"))) - (s-type-anno @19.52-19.67 (name "data") - (ty-var @19.58-19.67 (name "new_value"))) (e-empty_record @19.38-19.69)))) (d-let (p-assign @22.1-22.12 (ident "updated_int")) @@ -351,7 +349,7 @@ main = |_| { (p-assign @19.1-19.12 (ident "update_data"))) (e-lookup-local @22.27-22.40 (p-assign @14.1-14.14 (ident "int_container"))) - (e-int @22.42-22.45 (value "100")))) + (e-num @22.42-22.45 (value "100")))) (d-let (p-assign @23.1-23.12 (ident "updated_str")) (e-call @23.15-23.50 @@ -376,7 +374,7 @@ main = |_| { (e-call @29.14-29.33 (e-lookup-local @29.14-29.29 (p-assign @26.1-26.16 (ident "identity_record"))) - (e-int @29.30-29.32 (value "42")))) + (e-num @29.30-29.32 (value "42")))) (d-let (p-assign @30.1-30.11 (ident "str_record")) (e-call @30.14-30.37 @@ -391,15 +389,15 @@ main = |_| { (p-assign @26.1-26.16 (ident "identity_record"))) (e-list @31.31-31.40 (elems - (e-int @31.32-31.33 (value "1")) - (e-int @31.35-31.36 (value "2")) - (e-int @31.38-31.39 (value "3")))))) + (e-num @31.32-31.33 (value "1")) + (e-num @31.35-31.36 (value "2")) + (e-num @31.38-31.39 (value "3")))))) (d-let (p-assign @33.1-33.5 (ident "main")) (e-closure @33.8-36.2 (captures - (capture @14.1-14.14 (ident "int_container")) - (capture @15.1-15.14 (ident "str_container"))) + (capture @15.1-15.14 (ident "str_container")) + (capture @14.1-14.14 (ident "int_container"))) (e-lambda @33.8-36.2 (args (p-underscore @33.9-33.10)) @@ -418,37 +416,37 @@ main = |_| { ~~~clojure (inferred-types (defs - (patt @4.1-4.4 (type "Frac(_size)")) - (patt @5.1-5.5 (type "Frac(_size)")) + (patt @4.1-4.4 (type "Num(Frac(_size))")) + (patt @5.1-5.5 (type "Num(Frac(_size))")) (patt @6.1-6.4 (type "Str")) (patt @7.1-7.14 (type "List(_elem)")) - (patt @8.1-8.17 (type "List(Frac(_size))")) - (patt @11.1-11.15 (type "_arg -> { data: _field, count: Num(_size) }")) - (patt @14.1-14.14 (type "{ data: Frac(_size), count: Num(_size2) }")) - (patt @15.1-15.14 (type "{ data: Str, count: Num(_size) }")) - (patt @16.1-16.15 (type "{ data: List(_elem), count: Num(_size) }")) + (patt @8.1-8.17 (type "List(Num(Frac(_size)))")) + (patt @11.1-11.15 (type "a -> { count: Num(_size), data: a }")) + (patt @14.1-14.14 (type "{ count: Num(_size), data: Num(Frac(_size2)) }")) + (patt @15.1-15.14 (type "{ count: Num(_size), data: Str }")) + (patt @16.1-16.15 (type "{ count: Num(_size), data: List(_elem) }")) (patt @19.1-19.12 (type "_arg, _arg2 -> {}")) (patt @22.1-22.12 (type "{}")) (patt @23.1-23.12 (type "{}")) - (patt @26.1-26.16 (type "_arg -> { value: _field }")) + (patt @26.1-26.16 (type "a -> { value: a }")) (patt @29.1-29.11 (type "{ value: Num(_size) }")) (patt @30.1-30.11 (type "{ value: Str }")) (patt @31.1-31.12 (type "{ value: List(Num(_size)) }")) (patt @33.1-33.5 (type "_arg -> Num(_size)"))) (expressions - (expr @4.7-4.9 (type "Frac(_size)")) - (expr @5.8-5.11 (type "Frac(_size)")) + (expr @4.7-4.9 (type "Num(Frac(_size))")) + (expr @5.8-5.11 (type "Num(Frac(_size))")) (expr @6.7-6.14 (type "Str")) (expr @7.17-7.19 (type "List(_elem)")) - (expr @8.20-8.31 (type "List(Frac(_size))")) - (expr @11.18-11.51 (type "_arg -> { data: _field, count: Num(_size) }")) - (expr @14.17-14.36 (type "{ data: Frac(_size), count: Num(_size2) }")) - (expr @15.17-15.36 (type "{ data: Str, count: Num(_size) }")) - (expr @16.18-16.47 (type "{ data: List(_elem), count: Num(_size) }")) + (expr @8.20-8.31 (type "List(Num(Frac(_size)))")) + (expr @11.18-11.51 (type "a -> { count: Num(_size), data: a }")) + (expr @14.17-14.36 (type "{ count: Num(_size), data: Num(Frac(_size2)) }")) + (expr @15.17-15.36 (type "{ count: Num(_size), data: Str }")) + (expr @16.18-16.47 (type "{ count: Num(_size), data: List(_elem) }")) (expr @19.15-19.69 (type "_arg, _arg2 -> {}")) (expr @22.15-22.46 (type "{}")) (expr @23.15-23.50 (type "{}")) - (expr @26.19-26.35 (type "_arg -> { value: _field }")) + (expr @26.19-26.35 (type "a -> { value: a }")) (expr @29.14-29.33 (type "{ value: Num(_size) }")) (expr @30.14-30.37 (type "{ value: Str }")) (expr @31.15-31.41 (type "{ value: List(Num(_size)) }")) diff --git a/test/snapshots/match_expr/basic_tag_union.md b/test/snapshots/match_expr/basic_tag_union.md index d70a2b5a9d..59b2539ac1 100644 --- a/test/snapshots/match_expr/basic_tag_union.md +++ b/test/snapshots/match_expr/basic_tag_union.md @@ -89,13 +89,13 @@ NO CHANGE (pattern (degenerate false) (p-applied-tag @2.2-2.5))) (value - (e-int @2.9-2.10 (value "1")))) + (e-num @2.9-2.10 (value "1")))) (branch (patterns (pattern (degenerate false) (p-applied-tag @3.2-3.6))) (value - (e-int @3.10-3.11 (value "2")))) + (e-num @3.10-3.11 (value "2")))) (branch (patterns (pattern (degenerate false) diff --git a/test/snapshots/match_expr/branch_scoping.md b/test/snapshots/match_expr/branch_scoping.md index f6af3a9c69..47dac23280 100644 --- a/test/snapshots/match_expr/branch_scoping.md +++ b/test/snapshots/match_expr/branch_scoping.md @@ -91,7 +91,7 @@ match result { (e-binop @2.18-2.27 (op "add") (e-lookup-local @2.18-2.23 (p-assign @2.8-2.13 (ident "value"))) - (e-int @2.26-2.27 (value "1"))))) + (e-num @2.26-2.27 (value "1"))))) (branch (patterns (pattern (degenerate false) @@ -101,7 +101,7 @@ match result { (e-binop @3.19-3.28 (op "sub") (e-lookup-local @3.19-3.24 (p-assign @3.9-3.14 (ident "value"))) - (e-int @3.27-3.28 (value "1"))))) + (e-num @3.27-3.28 (value "1"))))) (branch (patterns (pattern (degenerate false) @@ -111,7 +111,7 @@ match result { (e-binop @4.22-4.35 (op "mul") (e-lookup-local @4.22-4.31 (p-assign @4.8-4.17 (ident "different"))) - (e-int @4.34-4.35 (value "2"))))) + (e-num @4.34-4.35 (value "2"))))) (branch (patterns (pattern (degenerate false) @@ -121,7 +121,7 @@ match result { (e-binop @5.23-5.36 (op "div") (e-lookup-local @5.23-5.32 (p-assign @5.9-5.18 (ident "different"))) - (e-int @5.35-5.36 (value "2")))))))) + (e-num @5.35-5.36 (value "2")))))))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/match_expr/list_destructure_variations.md b/test/snapshots/match_expr/list_destructure_variations.md index 0b7a52a897..06519f75ad 100644 --- a/test/snapshots/match_expr/list_destructure_variations.md +++ b/test/snapshots/match_expr/list_destructure_variations.md @@ -145,7 +145,7 @@ match list { (p-list @2.5-2.7 (patterns)))) (value - (e-int @2.11-2.12 (value "0")))) + (e-num @2.11-2.12 (value "0")))) (branch (patterns (pattern (degenerate false) @@ -189,7 +189,7 @@ match list { (rest-at (index 2) (p-assign @1.1-1.1 (ident "rest")))))) (value - (e-int @6.31-6.32 (value "3")))) + (e-num @6.31-6.32 (value "3")))) (branch (patterns (pattern (degenerate false) diff --git a/test/snapshots/match_expr/list_mixed_literals.md b/test/snapshots/match_expr/list_mixed_literals.md index fcf05c9223..08bb0b47c8 100644 --- a/test/snapshots/match_expr/list_mixed_literals.md +++ b/test/snapshots/match_expr/list_mixed_literals.md @@ -90,7 +90,7 @@ match sequence { (pattern (degenerate false) (p-list @2.5-2.15 (patterns - (p-int @2.6-2.7 (value "0")) + (p-num @2.6-2.7 (value "0")) (p-assign @2.9-2.14 (ident "count")))))) (value (e-lookup-local @2.19-2.24 @@ -100,9 +100,9 @@ match sequence { (pattern (degenerate false) (p-list @3.5-3.14 (patterns - (p-int @3.6-3.7 (value "1")) + (p-num @3.6-3.7 (value "1")) (p-assign @3.9-3.10 (ident "x")) - (p-int @3.12-3.13 (value "3")))))) + (p-num @3.12-3.13 (value "3")))))) (value (e-lookup-local @3.18-3.19 (p-assign @3.9-3.10 (ident "x"))))) @@ -111,7 +111,7 @@ match sequence { (pattern (degenerate false) (p-list @4.5-4.16 (patterns - (p-int @4.6-4.8 (value "42")) + (p-num @4.6-4.8 (value "42")) (p-assign @4.10-4.15 (ident "value")))))) (value (e-lookup-local @4.20-4.25 @@ -122,7 +122,7 @@ match sequence { (p-list @5.5-5.16 (patterns (p-assign @5.6-5.11 (ident "first")) - (p-int @5.13-5.15 (value "99")))))) + (p-num @5.13-5.15 (value "99")))))) (value (e-lookup-local @5.20-5.25 (p-assign @5.6-5.11 (ident "first"))))) @@ -132,7 +132,7 @@ match sequence { (p-list @6.5-6.7 (patterns)))) (value - (e-int @6.11-6.12 (value "0"))))))) + (e-num @6.11-6.12 (value "0"))))))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/match_expr/list_patterns.md b/test/snapshots/match_expr/list_patterns.md index 74e7f3e38e..450c7fa1fb 100644 --- a/test/snapshots/match_expr/list_patterns.md +++ b/test/snapshots/match_expr/list_patterns.md @@ -126,7 +126,7 @@ match numbers { (rest-at (index 1) (p-assign @3.15-3.15 (ident "rest")))))) (value - (e-int @3.24-3.25 (value "0"))))))) + (e-num @3.24-3.25 (value "0"))))))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/match_expr/list_rest_invalid.md b/test/snapshots/match_expr/list_rest_invalid.md index 2563906dc4..3ea9d9f7d6 100644 --- a/test/snapshots/match_expr/list_rest_invalid.md +++ b/test/snapshots/match_expr/list_rest_invalid.md @@ -207,7 +207,7 @@ match items { (rest-at (index 1) (p-assign @2.15-2.15 (ident "rest")))))) (value - (e-int @2.24-2.25 (value "0")))) + (e-num @2.24-2.25 (value "0")))) (branch (patterns (pattern (degenerate false) @@ -217,7 +217,7 @@ match items { (rest-at (index 0) (p-assign @3.8-3.8 (ident "rest")))))) (value - (e-int @3.23-3.24 (value "1")))) + (e-num @3.23-3.24 (value "1")))) (branch (patterns (pattern (degenerate false) @@ -228,7 +228,7 @@ match items { (rest-at (index 1) (p-assign @4.11-4.11 (ident "rest")))))) (value - (e-int @4.23-4.24 (value "2"))))))) + (e-num @4.23-4.24 (value "2"))))))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/match_expr/list_rest_scoping.md b/test/snapshots/match_expr/list_rest_scoping.md index b4ceaa2310..424f8f2e49 100644 --- a/test/snapshots/match_expr/list_rest_scoping.md +++ b/test/snapshots/match_expr/list_rest_scoping.md @@ -164,7 +164,7 @@ match items { (e-binop @2.24-2.33 (op "add") (e-lookup-local @2.24-2.29 (p-assign @2.6-2.11 (ident "first"))) - (e-int @2.32-2.33 (value "1"))))) + (e-num @2.32-2.33 (value "1"))))) (branch (patterns (pattern (degenerate false) @@ -177,7 +177,7 @@ match items { (e-binop @3.23-3.31 (op "add") (e-lookup-local @3.23-3.27 (p-assign @3.14-3.18 (ident "last"))) - (e-int @3.30-3.31 (value "2"))))) + (e-num @3.30-3.31 (value "2"))))) (branch (patterns (pattern (degenerate false) diff --git a/test/snapshots/match_expr/list_rest_scoping_variables.md b/test/snapshots/match_expr/list_rest_scoping_variables.md index 154f28a583..72abf5e5ed 100644 --- a/test/snapshots/match_expr/list_rest_scoping_variables.md +++ b/test/snapshots/match_expr/list_rest_scoping_variables.md @@ -188,7 +188,7 @@ match data { (rest-at (index 0) (p-assign @2.8-2.8 (ident "items")))))) (value - (e-int @2.18-2.19 (value "1")))) + (e-num @2.18-2.19 (value "1")))) (branch (patterns (pattern (degenerate false) diff --git a/test/snapshots/match_expr/list_underscore_patterns.md b/test/snapshots/match_expr/list_underscore_patterns.md index 5723d31627..ebead652fd 100644 --- a/test/snapshots/match_expr/list_underscore_patterns.md +++ b/test/snapshots/match_expr/list_underscore_patterns.md @@ -103,7 +103,7 @@ match items { (patterns (p-underscore @2.6-2.7))))) (value - (e-int @2.12-2.13 (value "1")))) + (e-num @2.12-2.13 (value "1")))) (branch (patterns (pattern (degenerate false) @@ -156,7 +156,7 @@ match items { (p-list @7.5-7.7 (patterns)))) (value - (e-int @7.11-7.12 (value "0"))))))) + (e-num @7.11-7.12 (value "0"))))))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/match_expr/literal_patterns.md b/test/snapshots/match_expr/literal_patterns.md index 44d2e0d414..ef76716535 100644 --- a/test/snapshots/match_expr/literal_patterns.md +++ b/test/snapshots/match_expr/literal_patterns.md @@ -110,7 +110,7 @@ match Answer { (pattern (degenerate false) (p-applied-tag @2.5-2.11))) (value - (e-int @2.15-2.16 (value "1")))) + (e-num @2.15-2.16 (value "1")))) (branch (patterns (pattern (degenerate false) @@ -123,13 +123,13 @@ match Answer { (pattern (degenerate false) (p-applied-tag @4.5-4.13))) (value - (e-int @4.17-4.18 (value "3")))) + (e-num @4.17-4.18 (value "3")))) (branch (patterns (pattern (degenerate false) - (p-int @5.5-5.7 (value "10")))) + (p-num @5.5-5.7 (value "10")))) (value - (e-int @5.11-5.12 (value "4"))))))) + (e-num @5.11-5.12 (value "4"))))))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/match_expr/middle_rest.md b/test/snapshots/match_expr/middle_rest.md index 5afc154da1..bec91f1c30 100644 --- a/test/snapshots/match_expr/middle_rest.md +++ b/test/snapshots/match_expr/middle_rest.md @@ -152,7 +152,7 @@ match items { (p-list @5.5-5.7 (patterns)))) (value - (e-int @5.11-5.12 (value "0"))))))) + (e-num @5.11-5.12 (value "0"))))))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/match_expr/mixed_pattern_scoping.md b/test/snapshots/match_expr/mixed_pattern_scoping.md index 14854bd337..c45709fb68 100644 --- a/test/snapshots/match_expr/mixed_pattern_scoping.md +++ b/test/snapshots/match_expr/mixed_pattern_scoping.md @@ -105,7 +105,7 @@ match data { (e-binop @3.15-3.20 (op "sub") (e-lookup-local @3.15-3.16 (p-assign @3.9-3.10 (ident "x"))) - (e-int @3.19-3.20 (value "1"))))) + (e-num @3.19-3.20 (value "1"))))) (branch (patterns (pattern (degenerate false) @@ -115,7 +115,7 @@ match data { (e-binop @4.16-4.21 (op "mul") (e-lookup-local @4.16-4.17 (p-assign @4.9-4.10 (ident "x"))) - (e-int @4.20-4.21 (value "2"))))) + (e-num @4.20-4.21 (value "2"))))) (branch (patterns (pattern (degenerate false) @@ -125,7 +125,7 @@ match data { (e-binop @5.15-5.20 (op "div") (e-lookup-local @5.15-5.16 (p-assign @5.9-5.10 (ident "y"))) - (e-int @5.19-5.20 (value "2")))))))) + (e-num @5.19-5.20 (value "2")))))))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/match_expr/multi_pattern_branch.md b/test/snapshots/match_expr/multi_pattern_branch.md index ff104f7143..156ba63796 100644 --- a/test/snapshots/match_expr/multi_pattern_branch.md +++ b/test/snapshots/match_expr/multi_pattern_branch.md @@ -76,19 +76,19 @@ match color { (pattern (degenerate false) (p-applied-tag @2.20-2.23))) (value - (e-int @2.27-2.28 (value "1")))) + (e-num @2.27-2.28 (value "1")))) (branch (patterns (pattern (degenerate false) (p-applied-tag @3.5-3.10))) (value - (e-int @3.14-3.15 (value "2")))) + (e-num @3.14-3.15 (value "2")))) (branch (patterns (pattern (degenerate false) (p-applied-tag @4.5-4.10))) (value - (e-int @4.14-4.15 (value "3"))))))) + (e-num @4.14-4.15 (value "3"))))))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/match_expr/nested_list_scoping.md b/test/snapshots/match_expr/nested_list_scoping.md index bba741e459..4b572c72a4 100644 --- a/test/snapshots/match_expr/nested_list_scoping.md +++ b/test/snapshots/match_expr/nested_list_scoping.md @@ -13,6 +13,7 @@ match nestedList { ~~~ # EXPECTED UNDEFINED VARIABLE - nested_list_scoping.md:1:7:1:17 +TYPE MISMATCH - nested_list_scoping.md:4:17:4:18 # PROBLEMS **UNDEFINED VARIABLE** Nothing is named `nestedList` in this scope. @@ -25,6 +26,20 @@ match nestedList { ^^^^^^^^^^ +**TYPE MISMATCH** +This expression is used in an unexpected way: +**nested_list_scoping.md:4:17:4:18:** +```roc + [x, [y]] => x * y +``` + ^ + +It has the type: + _List(_elem)_ + +But I expected it to be: + _Num(_size)_ + # TOKENS ~~~zig KwMatch(1:1-1:6),LowerIdent(1:7-1:17),OpenCurly(1:18-1:19), @@ -130,5 +145,5 @@ match nestedList { ~~~ # TYPES ~~~clojure -(expr @1.1-5.2 (type "Num(_size)")) +(expr @1.1-5.2 (type "Error")) ~~~ diff --git a/test/snapshots/match_expr/nested_patterns.md b/test/snapshots/match_expr/nested_patterns.md index 4cda0f3422..6369039e30 100644 --- a/test/snapshots/match_expr/nested_patterns.md +++ b/test/snapshots/match_expr/nested_patterns.md @@ -120,7 +120,7 @@ match data { (pattern (degenerate false) (p-applied-tag @3.5-3.29))) (value - (e-int @3.33-3.34 (value "0")))) + (e-num @3.33-3.34 (value "0")))) (branch (patterns (pattern (degenerate false) diff --git a/test/snapshots/match_expr/pattern_alternatives_basic.md b/test/snapshots/match_expr/pattern_alternatives_basic.md index ca4a6c36dc..3834c16799 100644 --- a/test/snapshots/match_expr/pattern_alternatives_basic.md +++ b/test/snapshots/match_expr/pattern_alternatives_basic.md @@ -1,12 +1,10 @@ # META ~~~ini description=Basic pattern alternatives with multiple tag patterns -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [kind] - Color : [Red, Green, Blue, Yellow, Orange, Purple] kind : Color -> Str @@ -21,65 +19,59 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:13),CloseSquare(1:13-1:14), -UpperIdent(3:1-3:6),OpColon(3:7-3:8),OpenSquare(3:9-3:10),UpperIdent(3:10-3:13),Comma(3:13-3:14),UpperIdent(3:15-3:20),Comma(3:20-3:21),UpperIdent(3:22-3:26),Comma(3:26-3:27),UpperIdent(3:28-3:34),Comma(3:34-3:35),UpperIdent(3:36-3:42),Comma(3:42-3:43),UpperIdent(3:44-3:50),CloseSquare(3:50-3:51), -LowerIdent(5:1-5:5),OpColon(5:6-5:7),UpperIdent(5:8-5:13),OpArrow(5:14-5:16),UpperIdent(5:17-5:20), -LowerIdent(6:1-6:5),OpAssign(6:6-6:7),OpBar(6:8-6:9),LowerIdent(6:9-6:14),OpBar(6:14-6:15),KwMatch(6:16-6:21),LowerIdent(6:22-6:27),OpenCurly(6:28-6:29), -UpperIdent(7:5-7:8),OpBar(7:9-7:10),UpperIdent(7:11-7:16),OpBar(7:17-7:18),UpperIdent(7:19-7:23),OpFatArrow(7:24-7:26),StringStart(7:27-7:28),StringPart(7:28-7:35),StringEnd(7:35-7:36), -UpperIdent(8:5-8:11),OpBar(8:12-8:13),UpperIdent(8:14-8:20),OpBar(8:21-8:22),UpperIdent(8:23-8:29),OpFatArrow(8:30-8:32),StringStart(8:33-8:34),StringPart(8:34-8:43),StringEnd(8:43-8:44), -CloseCurly(9:1-9:2), -EndOfFile(10:1-10:1), +UpperIdent(1:1-1:6),OpColon(1:7-1:8),OpenSquare(1:9-1:10),UpperIdent(1:10-1:13),Comma(1:13-1:14),UpperIdent(1:15-1:20),Comma(1:20-1:21),UpperIdent(1:22-1:26),Comma(1:26-1:27),UpperIdent(1:28-1:34),Comma(1:34-1:35),UpperIdent(1:36-1:42),Comma(1:42-1:43),UpperIdent(1:44-1:50),CloseSquare(1:50-1:51), +LowerIdent(3:1-3:5),OpColon(3:6-3:7),UpperIdent(3:8-3:13),OpArrow(3:14-3:16),UpperIdent(3:17-3:20), +LowerIdent(4:1-4:5),OpAssign(4:6-4:7),OpBar(4:8-4:9),LowerIdent(4:9-4:14),OpBar(4:14-4:15),KwMatch(4:16-4:21),LowerIdent(4:22-4:27),OpenCurly(4:28-4:29), +UpperIdent(5:5-5:8),OpBar(5:9-5:10),UpperIdent(5:11-5:16),OpBar(5:17-5:18),UpperIdent(5:19-5:23),OpFatArrow(5:24-5:26),StringStart(5:27-5:28),StringPart(5:28-5:35),StringEnd(5:35-5:36), +UpperIdent(6:5-6:11),OpBar(6:12-6:13),UpperIdent(6:14-6:20),OpBar(6:21-6:22),UpperIdent(6:23-6:29),OpFatArrow(6:30-6:32),StringStart(6:33-6:34),StringPart(6:34-6:43),StringEnd(6:43-6:44), +CloseCurly(7:1-7:2), +EndOfFile(8:1-8:1), ~~~ # PARSE ~~~clojure -(file @1.1-9.2 - (module @1.1-1.14 - (exposes @1.8-1.14 - (exposed-lower-ident @1.9-1.13 - (text "kind")))) +(file @1.1-7.2 + (type-module @1.1-1.6) (statements - (s-type-decl @3.1-3.51 - (header @3.1-3.6 (name "Color") + (s-type-decl @1.1-1.51 + (header @1.1-1.6 (name "Color") (args)) - (ty-tag-union @3.9-3.51 + (ty-tag-union @1.9-1.51 (tags - (ty @3.10-3.13 (name "Red")) - (ty @3.15-3.20 (name "Green")) - (ty @3.22-3.26 (name "Blue")) - (ty @3.28-3.34 (name "Yellow")) - (ty @3.36-3.42 (name "Orange")) - (ty @3.44-3.50 (name "Purple"))))) - (s-type-anno @5.1-5.20 (name "kind") - (ty-fn @5.8-5.20 - (ty @5.8-5.13 (name "Color")) - (ty @5.17-5.20 (name "Str")))) - (s-decl @6.1-9.2 - (p-ident @6.1-6.5 (raw "kind")) - (e-lambda @6.8-9.2 + (ty @1.10-1.13 (name "Red")) + (ty @1.15-1.20 (name "Green")) + (ty @1.22-1.26 (name "Blue")) + (ty @1.28-1.34 (name "Yellow")) + (ty @1.36-1.42 (name "Orange")) + (ty @1.44-1.50 (name "Purple"))))) + (s-type-anno @3.1-3.20 (name "kind") + (ty-fn @3.8-3.20 + (ty @3.8-3.13 (name "Color")) + (ty @3.17-3.20 (name "Str")))) + (s-decl @4.1-7.2 + (p-ident @4.1-4.5 (raw "kind")) + (e-lambda @4.8-7.2 (args - (p-ident @6.9-6.14 (raw "color"))) + (p-ident @4.9-4.14 (raw "color"))) (e-match - (e-ident @6.22-6.27 (raw "color")) + (e-ident @4.22-4.27 (raw "color")) (branches - (branch @7.5-7.36 + (branch @5.5-5.36 (p-alternatives - (p-tag @7.5-7.8 (raw "Red")) - (p-tag @7.11-7.16 (raw "Green")) - (p-tag @7.19-7.23 (raw "Blue"))) - (e-string @7.27-7.36 - (e-string-part @7.28-7.35 (raw "primary")))) - (branch @8.5-8.44 + (p-tag @5.5-5.8 (raw "Red")) + (p-tag @5.11-5.16 (raw "Green")) + (p-tag @5.19-5.23 (raw "Blue"))) + (e-string @5.27-5.36 + (e-string-part @5.28-5.35 (raw "primary")))) + (branch @6.5-6.44 (p-alternatives - (p-tag @8.5-8.11 (raw "Yellow")) - (p-tag @8.14-8.20 (raw "Orange")) - (p-tag @8.23-8.29 (raw "Purple"))) - (e-string @8.33-8.44 - (e-string-part @8.34-8.43 (raw "secondary")))))))))) + (p-tag @6.5-6.11 (raw "Yellow")) + (p-tag @6.14-6.20 (raw "Orange")) + (p-tag @6.23-6.29 (raw "Purple"))) + (e-string @6.33-6.44 + (e-string-part @6.34-6.43 (raw "secondary")))))))))) ~~~ # FORMATTED ~~~roc -module [kind] - Color : [Red, Green, Blue, Yellow, Orange, Purple] kind : Color -> Str @@ -92,61 +84,61 @@ kind = |color| match color { ~~~clojure (can-ir (d-let - (p-assign @6.1-6.5 (ident "kind")) - (e-lambda @6.8-9.2 + (p-assign @4.1-4.5 (ident "kind")) + (e-lambda @4.8-7.2 (args - (p-assign @6.9-6.14 (ident "color"))) - (e-match @6.16-9.2 - (match @6.16-9.2 + (p-assign @4.9-4.14 (ident "color"))) + (e-match @4.16-7.2 + (match @4.16-7.2 (cond - (e-lookup-local @6.22-6.27 - (p-assign @6.9-6.14 (ident "color")))) + (e-lookup-local @4.22-4.27 + (p-assign @4.9-4.14 (ident "color")))) (branches (branch (patterns (pattern (degenerate false) - (p-applied-tag @7.5-7.8)) + (p-applied-tag @5.5-5.8)) (pattern (degenerate false) - (p-applied-tag @7.11-7.16)) + (p-applied-tag @5.11-5.16)) (pattern (degenerate false) - (p-applied-tag @7.19-7.23))) + (p-applied-tag @5.19-5.23))) (value - (e-string @7.27-7.36 - (e-literal @7.28-7.35 (string "primary"))))) + (e-string @5.27-5.36 + (e-literal @5.28-5.35 (string "primary"))))) (branch (patterns (pattern (degenerate false) - (p-applied-tag @8.5-8.11)) + (p-applied-tag @6.5-6.11)) (pattern (degenerate false) - (p-applied-tag @8.14-8.20)) + (p-applied-tag @6.14-6.20)) (pattern (degenerate false) - (p-applied-tag @8.23-8.29))) + (p-applied-tag @6.23-6.29))) (value - (e-string @8.33-8.44 - (e-literal @8.34-8.43 (string "secondary"))))))))) - (annotation @6.1-6.5 + (e-string @6.33-6.44 + (e-literal @6.34-6.43 (string "secondary"))))))))) + (annotation @4.1-4.5 (declared-type - (ty-fn @5.8-5.20 (effectful false) - (ty @5.8-5.13 (name "Color")) - (ty @5.17-5.20 (name "Str")))))) - (s-alias-decl @3.1-3.51 - (ty-header @3.1-3.6 (name "Color")) - (ty-tag-union @3.9-3.51 - (ty @3.10-3.13 (name "Red")) - (ty @3.15-3.20 (name "Green")) - (ty @3.22-3.26 (name "Blue")) - (ty @3.28-3.34 (name "Yellow")) - (ty @3.36-3.42 (name "Orange")) - (ty @3.44-3.50 (name "Purple"))))) + (ty-fn @3.8-3.20 (effectful false) + (ty-lookup @3.8-3.13 (name "Color") (local)) + (ty-lookup @3.17-3.20 (name "Str") (builtin)))))) + (s-alias-decl @1.1-1.51 + (ty-header @1.1-1.6 (name "Color")) + (ty-tag-union @1.9-1.51 + (ty-tag-name @1.10-1.13 (name "Red")) + (ty-tag-name @1.15-1.20 (name "Green")) + (ty-tag-name @1.22-1.26 (name "Blue")) + (ty-tag-name @1.28-1.34 (name "Yellow")) + (ty-tag-name @1.36-1.42 (name "Orange")) + (ty-tag-name @1.44-1.50 (name "Purple"))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @6.1-6.5 (type "Color -> Str"))) + (patt @4.1-4.5 (type "Color -> Str"))) (type_decls - (alias @3.1-3.51 (type "Color") - (ty-header @3.1-3.6 (name "Color")))) + (alias @1.1-1.51 (type "Color") + (ty-header @1.1-1.6 (name "Color")))) (expressions - (expr @6.8-9.2 (type "Color -> Str")))) + (expr @4.8-7.2 (type "Color -> Str")))) ~~~ diff --git a/test/snapshots/match_expr/pattern_alternatives_mixed.md b/test/snapshots/match_expr/pattern_alternatives_mixed.md index 2349b1e1c5..cdc275efae 100644 --- a/test/snapshots/match_expr/pattern_alternatives_mixed.md +++ b/test/snapshots/match_expr/pattern_alternatives_mixed.md @@ -116,11 +116,11 @@ NO CHANGE (branch (patterns (pattern (degenerate false) - (p-int @2.2-2.3 (value "1"))) + (p-num @2.2-2.3 (value "1"))) (pattern (degenerate false) - (p-int @2.6-2.7 (value "2"))) + (p-num @2.6-2.7 (value "2"))) (pattern (degenerate false) - (p-int @2.10-2.11 (value "3")))) + (p-num @2.10-2.11 (value "3")))) (value (e-string @2.15-2.30 (e-literal @2.16-2.29 (string "small numbers"))))) @@ -160,13 +160,13 @@ NO CHANGE (pattern (degenerate false) (p-tuple @6.2-6.8 (patterns - (p-int @6.3-6.4 (value "0")) + (p-num @6.3-6.4 (value "0")) (p-underscore @6.6-6.7)))) (pattern (degenerate false) (p-tuple @6.11-6.17 (patterns (p-underscore @6.12-6.13) - (p-int @6.15-6.16 (value "0")))))) + (p-num @6.15-6.16 (value "0")))))) (value (e-string @6.21-6.31 (e-literal @6.22-6.30 (string "has zero"))))) diff --git a/test/snapshots/match_expr/pattern_as_basic.md b/test/snapshots/match_expr/pattern_as_basic.md index 9ddf2878d7..2b79a2c532 100644 --- a/test/snapshots/match_expr/pattern_as_basic.md +++ b/test/snapshots/match_expr/pattern_as_basic.md @@ -71,8 +71,8 @@ match (1, 2) { (cond (e-tuple @1.7-1.13 (elems - (e-int @1.8-1.9 (value "1")) - (e-int @1.11-1.12 (value "2"))))) + (e-num @1.8-1.9 (value "1")) + (e-num @1.11-1.12 (value "2"))))) (branches (branch (patterns @@ -92,5 +92,5 @@ match (1, 2) { ~~~ # TYPES ~~~clojure -(expr @1.1-3.2 (type "(Num(_size), Num(_size2))")) +(expr @1.1-3.2 (type "Error")) ~~~ diff --git a/test/snapshots/match_expr/pattern_as_nested.md b/test/snapshots/match_expr/pattern_as_nested.md index b2310c8ca0..52dec166af 100644 --- a/test/snapshots/match_expr/pattern_as_nested.md +++ b/test/snapshots/match_expr/pattern_as_nested.md @@ -156,5 +156,5 @@ match person { ~~~ # TYPES ~~~clojure -(expr @1.1-4.2 (type "(Error, _field, Str)")) +(expr @1.1-4.2 (type "(Error, Error, Str)")) ~~~ diff --git a/test/snapshots/match_expr/single_branch.md b/test/snapshots/match_expr/single_branch.md index 953ad603b1..ea8a235eb0 100644 --- a/test/snapshots/match_expr/single_branch.md +++ b/test/snapshots/match_expr/single_branch.md @@ -62,9 +62,9 @@ match value { (e-binop @2.10-2.15 (op "add") (e-lookup-local @2.10-2.11 (p-assign @2.5-2.6 (ident "x"))) - (e-int @2.14-2.15 (value "1")))))))) + (e-num @2.14-2.15 (value "1")))))))) ~~~ # TYPES ~~~clojure -(expr @1.1-3.2 (type "Num(_size)")) +(expr @1.1-3.2 (type "Error")) ~~~ diff --git a/test/snapshots/match_expr/tag_with_payload.md b/test/snapshots/match_expr/tag_with_payload.md index d53f8c53ff..a63d2be555 100644 --- a/test/snapshots/match_expr/tag_with_payload.md +++ b/test/snapshots/match_expr/tag_with_payload.md @@ -116,5 +116,5 @@ match shape { ~~~ # TYPES ~~~clojure -(expr @1.1-5.2 (type "Num(_size)")) +(expr @1.1-5.2 (type "Num(Frac(_size))")) ~~~ diff --git a/test/snapshots/match_expr/variable_shadowing.md b/test/snapshots/match_expr/variable_shadowing.md index ac0f8ca03f..b43f4166d5 100644 --- a/test/snapshots/match_expr/variable_shadowing.md +++ b/test/snapshots/match_expr/variable_shadowing.md @@ -108,9 +108,9 @@ match (value, other) { (e-binop @3.18-3.23 (op "mul") (e-lookup-local @3.18-3.19 (p-assign @3.12-3.13 (ident "x"))) - (e-int @3.22-3.23 (value "2")))))))) + (e-num @3.22-3.23 (value "2")))))))) ~~~ # TYPES ~~~clojure -(expr @1.1-4.2 (type "Num(_size)")) +(expr @1.1-4.2 (type "Error")) ~~~ diff --git a/test/snapshots/module_empty.md b/test/snapshots/module_empty.md index 4ba631ead2..7999ea91c0 100644 --- a/test/snapshots/module_empty.md +++ b/test/snapshots/module_empty.md @@ -1,11 +1,11 @@ # META ~~~ini description=An empty module with no exposes -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] + ~~~ # EXPECTED NIL @@ -13,14 +13,12 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), EndOfFile(2:1-2:1), ~~~ # PARSE ~~~clojure -(file @1.1-1.10 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @2.1-2.1 + (type-module @2.1-2.1) (statements)) ~~~ # FORMATTED diff --git a/test/snapshots/module_multiline_with_comments.md b/test/snapshots/module_multiline_with_comments.md index 847d10d4ea..6173d79c33 100644 --- a/test/snapshots/module_multiline_with_comments.md +++ b/test/snapshots/module_multiline_with_comments.md @@ -1,62 +1,112 @@ # META ~~~ini description=An empty module with multiline exposes and comments -type=file +type=snippet ~~~ # SOURCE ~~~roc -module # Comment after module keyword [ # Comment After exposes open something, # Comment after exposed item SomeType, # Comment after final exposed item ] ~~~ # EXPECTED -EXPOSED BUT NOT DEFINED - module_multiline_with_comments.md:3:3:3:12 -EXPOSED BUT NOT DEFINED - module_multiline_with_comments.md:4:3:4:11 +PARSE ERROR - module_multiline_with_comments.md:1:2:1:3 +PARSE ERROR - module_multiline_with_comments.md:2:3:2:12 +PARSE ERROR - module_multiline_with_comments.md:2:12:2:13 +PARSE ERROR - module_multiline_with_comments.md:3:11:3:12 +PARSE ERROR - module_multiline_with_comments.md:4:2:4:3 # PROBLEMS -**EXPOSED BUT NOT DEFINED** -The module header says that `something` is exposed, but it is not defined anywhere in this module. +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. -**module_multiline_with_comments.md:3:3:3:12:** +**module_multiline_with_comments.md:1:2:1:3:** +```roc + [ # Comment After exposes open +``` + ^ + + +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**module_multiline_with_comments.md:2:3:2:12:** ```roc something, # Comment after exposed item ``` ^^^^^^^^^ -You can fix this by either defining `something` in this module, or by removing it from the list of exposed values. -**EXPOSED BUT NOT DEFINED** -The module header says that `SomeType` is exposed, but it is not defined anywhere in this module. -**module_multiline_with_comments.md:4:3:4:11:** +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**module_multiline_with_comments.md:2:12:2:13:** +```roc + something, # Comment after exposed item +``` + ^ + + +**PARSE ERROR** +Type applications require parentheses around their type arguments. + +I found a type followed by what looks like a type argument, but they need to be connected with parentheses. + +Instead of: + **List U8** + +Use: + **List(U8)** + +Other valid examples: + `Dict(Str, Num)` + `Result(a, Str)` + `Maybe(List(U64))` + +**module_multiline_with_comments.md:3:11:3:12:** ```roc SomeType, # Comment after final exposed item ``` - ^^^^^^^^ -You can fix this by either defining `SomeType` in this module, or by removing it from the list of exposed values. + ^ + + +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**module_multiline_with_comments.md:4:2:4:3:** +```roc + ] +``` + ^ + # TOKENS ~~~zig -KwModule(1:1-1:7), -OpenSquare(2:2-2:3), -LowerIdent(3:3-3:12),Comma(3:12-3:13), -UpperIdent(4:3-4:11),Comma(4:11-4:12), -CloseSquare(5:2-5:3), -EndOfFile(6:1-6:1), +OpenSquare(1:2-1:3), +LowerIdent(2:3-2:12),Comma(2:12-2:13), +UpperIdent(3:3-3:11),Comma(3:11-3:12), +CloseSquare(4:2-4:3), +EndOfFile(5:1-5:1), ~~~ # PARSE ~~~clojure -(file @1.1-5.3 - (module @1.1-5.3 - (exposes @2.2-5.3 - (exposed-lower-ident @3.3-3.12 - (text "something")) - (exposed-upper-ident @4.3-4.11 (text "SomeType")))) - (statements)) +(file @1.2-4.3 + (type-module @1.2-1.3) + (statements + (s-malformed @1.2-1.3 (tag "statement_unexpected_token")) + (s-malformed @2.3-2.12 (tag "statement_unexpected_token")) + (s-malformed @2.12-2.13 (tag "statement_unexpected_token")) + (s-malformed @3.11-3.12 (tag "expected_colon_after_type_annotation")) + (s-malformed @4.2-4.3 (tag "statement_unexpected_token")))) ~~~ # FORMATTED ~~~roc -NO CHANGE +# Comment After exposes open +# Comment after final exposed item ~~~ # CANONICALIZE ~~~clojure diff --git a/test/snapshots/module_nonempty_single.md b/test/snapshots/module_nonempty_single.md index 553d874506..ec7c7bf6d0 100644 --- a/test/snapshots/module_nonempty_single.md +++ b/test/snapshots/module_nonempty_single.md @@ -1,49 +1,24 @@ # META ~~~ini description=An empty module with singleline exposes -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [something, SomeType] + ~~~ # EXPECTED -EXPOSED BUT NOT DEFINED - module_nonempty_single.md:1:9:1:18 -EXPOSED BUT NOT DEFINED - module_nonempty_single.md:1:20:1:28 +NIL # PROBLEMS -**EXPOSED BUT NOT DEFINED** -The module header says that `something` is exposed, but it is not defined anywhere in this module. - -**module_nonempty_single.md:1:9:1:18:** -```roc -module [something, SomeType] -``` - ^^^^^^^^^ -You can fix this by either defining `something` in this module, or by removing it from the list of exposed values. - -**EXPOSED BUT NOT DEFINED** -The module header says that `SomeType` is exposed, but it is not defined anywhere in this module. - -**module_nonempty_single.md:1:20:1:28:** -```roc -module [something, SomeType] -``` - ^^^^^^^^ -You can fix this by either defining `SomeType` in this module, or by removing it from the list of exposed values. - +NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:18),Comma(1:18-1:19),UpperIdent(1:20-1:28),CloseSquare(1:28-1:29), EndOfFile(2:1-2:1), ~~~ # PARSE ~~~clojure -(file @1.1-1.29 - (module @1.1-1.29 - (exposes @1.8-1.29 - (exposed-lower-ident @1.9-1.18 - (text "something")) - (exposed-upper-ident @1.20-1.28 (text "SomeType")))) +(file @2.1-2.1 + (type-module @2.1-2.1) (statements)) ~~~ # FORMATTED diff --git a/test/snapshots/module_singleline_fmts_to_multiline.md b/test/snapshots/module_singleline_fmts_to_multiline.md index b578e5ba22..42b4b0a08c 100644 --- a/test/snapshots/module_singleline_fmts_to_multiline.md +++ b/test/snapshots/module_singleline_fmts_to_multiline.md @@ -1,57 +1,29 @@ # META ~~~ini description=An empty module with a singleline exposes with trailing comma -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [something, SomeType,] + ~~~ # EXPECTED -EXPOSED BUT NOT DEFINED - module_singleline_fmts_to_multiline.md:1:9:1:18 -EXPOSED BUT NOT DEFINED - module_singleline_fmts_to_multiline.md:1:20:1:28 +NIL # PROBLEMS -**EXPOSED BUT NOT DEFINED** -The module header says that `something` is exposed, but it is not defined anywhere in this module. - -**module_singleline_fmts_to_multiline.md:1:9:1:18:** -```roc -module [something, SomeType,] -``` - ^^^^^^^^^ -You can fix this by either defining `something` in this module, or by removing it from the list of exposed values. - -**EXPOSED BUT NOT DEFINED** -The module header says that `SomeType` is exposed, but it is not defined anywhere in this module. - -**module_singleline_fmts_to_multiline.md:1:20:1:28:** -```roc -module [something, SomeType,] -``` - ^^^^^^^^ -You can fix this by either defining `SomeType` in this module, or by removing it from the list of exposed values. - +NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:18),Comma(1:18-1:19),UpperIdent(1:20-1:28),Comma(1:28-1:29),CloseSquare(1:29-1:30), EndOfFile(2:1-2:1), ~~~ # PARSE ~~~clojure -(file @1.1-1.30 - (module @1.1-1.30 - (exposes @1.8-1.30 - (exposed-lower-ident @1.9-1.18 - (text "something")) - (exposed-upper-ident @1.20-1.28 (text "SomeType")))) +(file @2.1-2.1 + (type-module @2.1-2.1) (statements)) ~~~ # FORMATTED ~~~roc -module [ - something, - SomeType, -] +NO CHANGE ~~~ # CANONICALIZE ~~~clojure diff --git a/test/snapshots/multi_qualified_import.md b/test/snapshots/multi_qualified_import.md index 9ba6b25001..1e3cceff5e 100644 --- a/test/snapshots/multi_qualified_import.md +++ b/test/snapshots/multi_qualified_import.md @@ -1,12 +1,10 @@ # META ~~~ini description=Test multi-level qualified imports and type annotations -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [json_encoder] - import json.Core.Utf8 exposing [Encoder] json_encoder : Encoder @@ -21,31 +19,31 @@ data : json.Core.Utf8.EncodedData data = json.Core.Utf8.encode("hello") ~~~ # EXPECTED -PARSE ERROR - multi_qualified_import.md:3:17:3:22 -PARSE ERROR - multi_qualified_import.md:3:23:3:31 -PARSE ERROR - multi_qualified_import.md:3:32:3:33 -PARSE ERROR - multi_qualified_import.md:3:40:3:41 -PARSE ERROR - multi_qualified_import.md:14:12:14:17 -PARSE ERROR - multi_qualified_import.md:14:17:14:22 -PARSE ERROR - multi_qualified_import.md:14:22:14:29 -PARSE ERROR - multi_qualified_import.md:14:29:14:30 -PARSE ERROR - multi_qualified_import.md:14:30:14:31 -PARSE ERROR - multi_qualified_import.md:14:31:14:36 -PARSE ERROR - multi_qualified_import.md:14:36:14:37 -PARSE ERROR - multi_qualified_import.md:14:37:14:38 -MODULE NOT FOUND - multi_qualified_import.md:3:1:3:17 -UNDECLARED TYPE - multi_qualified_import.md:5:16:5:23 -UNDEFINED VARIABLE - multi_qualified_import.md:6:16:6:45 -MODULE NOT IMPORTED - multi_qualified_import.md:9:11:9:33 -UNUSED VARIABLE - multi_qualified_import.md:10:12:10:19 -MODULE NOT IMPORTED - multi_qualified_import.md:13:8:13:34 -UNDEFINED VARIABLE - multi_qualified_import.md:14:8:14:12 +PARSE ERROR - multi_qualified_import.md:1:17:1:22 +PARSE ERROR - multi_qualified_import.md:1:23:1:31 +PARSE ERROR - multi_qualified_import.md:1:32:1:33 +PARSE ERROR - multi_qualified_import.md:1:40:1:41 +PARSE ERROR - multi_qualified_import.md:12:12:12:17 +PARSE ERROR - multi_qualified_import.md:12:17:12:22 +PARSE ERROR - multi_qualified_import.md:12:22:12:29 +PARSE ERROR - multi_qualified_import.md:12:29:12:30 +PARSE ERROR - multi_qualified_import.md:12:30:12:31 +PARSE ERROR - multi_qualified_import.md:12:31:12:36 +PARSE ERROR - multi_qualified_import.md:12:36:12:37 +PARSE ERROR - multi_qualified_import.md:12:37:12:38 +MODULE NOT FOUND - multi_qualified_import.md:1:1:1:17 +UNDECLARED TYPE - multi_qualified_import.md:3:16:3:23 +UNDEFINED VARIABLE - multi_qualified_import.md:4:16:4:45 +MODULE NOT IMPORTED - multi_qualified_import.md:7:11:7:33 +UNUSED VARIABLE - multi_qualified_import.md:8:12:8:19 +MODULE NOT IMPORTED - multi_qualified_import.md:11:8:11:34 +UNDEFINED VARIABLE - multi_qualified_import.md:12:8:12:12 # PROBLEMS **PARSE ERROR** A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**multi_qualified_import.md:3:17:3:22:** +**multi_qualified_import.md:1:17:1:22:** ```roc import json.Core.Utf8 exposing [Encoder] ``` @@ -56,7 +54,7 @@ import json.Core.Utf8 exposing [Encoder] A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**multi_qualified_import.md:3:23:3:31:** +**multi_qualified_import.md:1:23:1:31:** ```roc import json.Core.Utf8 exposing [Encoder] ``` @@ -67,7 +65,7 @@ import json.Core.Utf8 exposing [Encoder] A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**multi_qualified_import.md:3:32:3:33:** +**multi_qualified_import.md:1:32:1:33:** ```roc import json.Core.Utf8 exposing [Encoder] ``` @@ -90,7 +88,7 @@ Other valid examples: `Result(a, Str)` `Maybe(List(U64))` -**multi_qualified_import.md:3:40:3:41:** +**multi_qualified_import.md:1:40:1:41:** ```roc import json.Core.Utf8 exposing [Encoder] ``` @@ -101,7 +99,7 @@ import json.Core.Utf8 exposing [Encoder] A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**multi_qualified_import.md:14:12:14:17:** +**multi_qualified_import.md:12:12:12:17:** ```roc data = json.Core.Utf8.encode("hello") ``` @@ -112,7 +110,7 @@ data = json.Core.Utf8.encode("hello") A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**multi_qualified_import.md:14:17:14:22:** +**multi_qualified_import.md:12:17:12:22:** ```roc data = json.Core.Utf8.encode("hello") ``` @@ -123,7 +121,7 @@ data = json.Core.Utf8.encode("hello") A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**multi_qualified_import.md:14:22:14:29:** +**multi_qualified_import.md:12:22:12:29:** ```roc data = json.Core.Utf8.encode("hello") ``` @@ -134,7 +132,7 @@ data = json.Core.Utf8.encode("hello") A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**multi_qualified_import.md:14:29:14:30:** +**multi_qualified_import.md:12:29:12:30:** ```roc data = json.Core.Utf8.encode("hello") ``` @@ -145,7 +143,7 @@ data = json.Core.Utf8.encode("hello") A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**multi_qualified_import.md:14:30:14:31:** +**multi_qualified_import.md:12:30:12:31:** ```roc data = json.Core.Utf8.encode("hello") ``` @@ -156,7 +154,7 @@ data = json.Core.Utf8.encode("hello") A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**multi_qualified_import.md:14:31:14:36:** +**multi_qualified_import.md:12:31:12:36:** ```roc data = json.Core.Utf8.encode("hello") ``` @@ -167,7 +165,7 @@ data = json.Core.Utf8.encode("hello") A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**multi_qualified_import.md:14:36:14:37:** +**multi_qualified_import.md:12:36:12:37:** ```roc data = json.Core.Utf8.encode("hello") ``` @@ -178,7 +176,7 @@ data = json.Core.Utf8.encode("hello") A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**multi_qualified_import.md:14:37:14:38:** +**multi_qualified_import.md:12:37:12:38:** ```roc data = json.Core.Utf8.encode("hello") ``` @@ -189,7 +187,7 @@ data = json.Core.Utf8.encode("hello") The module `json.Core` was not found in this Roc project. You're attempting to use this module here: -**multi_qualified_import.md:3:1:3:17:** +**multi_qualified_import.md:1:1:1:17:** ```roc import json.Core.Utf8 exposing [Encoder] ``` @@ -200,7 +198,7 @@ import json.Core.Utf8 exposing [Encoder] The type _Encoder_ is not declared in this scope. This type is referenced here: -**multi_qualified_import.md:5:16:5:23:** +**multi_qualified_import.md:3:16:3:23:** ```roc json_encoder : Encoder ``` @@ -211,7 +209,7 @@ json_encoder : Encoder Nothing is named `defaultEncoder` in this scope. Is there an `import` or `exposing` missing up-top? -**multi_qualified_import.md:6:16:6:45:** +**multi_qualified_import.md:4:16:4:45:** ```roc json_encoder = Json.Core.Utf8.defaultEncoder ``` @@ -219,18 +217,10 @@ json_encoder = Json.Core.Utf8.defaultEncoder **MODULE NOT IMPORTED** -There is no module with the name `module [json_encoder] - -import json.Core.Utf8 exposing [Encoder] - -json_encoder : Encoder -json_encoder = Json.Core.Utf8.defaultEncoder - -# Test with qualified type in annotation -process : json.Core.Utf8` imported into this Roc file. +There is no module with the name `json.Core.Utf8` imported into this Roc file. You're attempting to use this module here: -**multi_qualified_import.md:9:11:9:33:** +**multi_qualified_import.md:7:11:7:33:** ```roc process : json.Core.Utf8.Encoder -> Str ``` @@ -242,7 +232,7 @@ Variable `encoder` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_encoder` to suppress this warning. The unused variable is declared here: -**multi_qualified_import.md:10:12:10:19:** +**multi_qualified_import.md:8:12:8:19:** ```roc process = |encoder| "processing" ``` @@ -250,22 +240,10 @@ process = |encoder| "processing" **MODULE NOT IMPORTED** -There is no module with the name `module [json_encoder] - -import json.Core.Utf8 exposing [Encoder] - -json_encoder : Encoder -json_encoder = Json.Core.Utf8.defaultEncoder - -# Test with qualified type in annotation -process : json.Core.Utf8.Encoder -> Str -process = |encoder| "processing" - -# Test with multiple qualifiers -data : json.Core.Utf8` imported into this Roc file. +There is no module with the name `json.Core.Utf8` imported into this Roc file. You're attempting to use this module here: -**multi_qualified_import.md:13:8:13:34:** +**multi_qualified_import.md:11:8:11:34:** ```roc data : json.Core.Utf8.EncodedData ``` @@ -276,7 +254,7 @@ data : json.Core.Utf8.EncodedData Nothing is named `json` in this scope. Is there an `import` or `exposing` missing up-top? -**multi_qualified_import.md:14:8:14:12:** +**multi_qualified_import.md:12:8:12:12:** ```roc data = json.Core.Utf8.encode("hello") ``` @@ -285,63 +263,57 @@ data = json.Core.Utf8.encode("hello") # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:21),CloseSquare(1:21-1:22), -KwImport(3:1-3:7),LowerIdent(3:8-3:12),NoSpaceDotUpperIdent(3:12-3:17),NoSpaceDotUpperIdent(3:17-3:22),KwExposing(3:23-3:31),OpenSquare(3:32-3:33),UpperIdent(3:33-3:40),CloseSquare(3:40-3:41), -LowerIdent(5:1-5:13),OpColon(5:14-5:15),UpperIdent(5:16-5:23), -LowerIdent(6:1-6:13),OpAssign(6:14-6:15),UpperIdent(6:16-6:20),NoSpaceDotUpperIdent(6:20-6:25),NoSpaceDotUpperIdent(6:25-6:30),NoSpaceDotLowerIdent(6:30-6:45), -LowerIdent(9:1-9:8),OpColon(9:9-9:10),LowerIdent(9:11-9:15),NoSpaceDotUpperIdent(9:15-9:20),NoSpaceDotUpperIdent(9:20-9:25),NoSpaceDotUpperIdent(9:25-9:33),OpArrow(9:34-9:36),UpperIdent(9:37-9:40), -LowerIdent(10:1-10:8),OpAssign(10:9-10:10),OpBar(10:11-10:12),LowerIdent(10:12-10:19),OpBar(10:19-10:20),StringStart(10:21-10:22),StringPart(10:22-10:32),StringEnd(10:32-10:33), -LowerIdent(13:1-13:5),OpColon(13:6-13:7),LowerIdent(13:8-13:12),NoSpaceDotUpperIdent(13:12-13:17),NoSpaceDotUpperIdent(13:17-13:22),NoSpaceDotUpperIdent(13:22-13:34), -LowerIdent(14:1-14:5),OpAssign(14:6-14:7),LowerIdent(14:8-14:12),NoSpaceDotUpperIdent(14:12-14:17),NoSpaceDotUpperIdent(14:17-14:22),NoSpaceDotLowerIdent(14:22-14:29),NoSpaceOpenRound(14:29-14:30),StringStart(14:30-14:31),StringPart(14:31-14:36),StringEnd(14:36-14:37),CloseRound(14:37-14:38), -EndOfFile(15:1-15:1), +KwImport(1:1-1:7),LowerIdent(1:8-1:12),NoSpaceDotUpperIdent(1:12-1:17),NoSpaceDotUpperIdent(1:17-1:22),KwExposing(1:23-1:31),OpenSquare(1:32-1:33),UpperIdent(1:33-1:40),CloseSquare(1:40-1:41), +LowerIdent(3:1-3:13),OpColon(3:14-3:15),UpperIdent(3:16-3:23), +LowerIdent(4:1-4:13),OpAssign(4:14-4:15),UpperIdent(4:16-4:20),NoSpaceDotUpperIdent(4:20-4:25),NoSpaceDotUpperIdent(4:25-4:30),NoSpaceDotLowerIdent(4:30-4:45), +LowerIdent(7:1-7:8),OpColon(7:9-7:10),LowerIdent(7:11-7:15),NoSpaceDotUpperIdent(7:15-7:20),NoSpaceDotUpperIdent(7:20-7:25),NoSpaceDotUpperIdent(7:25-7:33),OpArrow(7:34-7:36),UpperIdent(7:37-7:40), +LowerIdent(8:1-8:8),OpAssign(8:9-8:10),OpBar(8:11-8:12),LowerIdent(8:12-8:19),OpBar(8:19-8:20),StringStart(8:21-8:22),StringPart(8:22-8:32),StringEnd(8:32-8:33), +LowerIdent(11:1-11:5),OpColon(11:6-11:7),LowerIdent(11:8-11:12),NoSpaceDotUpperIdent(11:12-11:17),NoSpaceDotUpperIdent(11:17-11:22),NoSpaceDotUpperIdent(11:22-11:34), +LowerIdent(12:1-12:5),OpAssign(12:6-12:7),LowerIdent(12:8-12:12),NoSpaceDotUpperIdent(12:12-12:17),NoSpaceDotUpperIdent(12:17-12:22),NoSpaceDotLowerIdent(12:22-12:29),NoSpaceOpenRound(12:29-12:30),StringStart(12:30-12:31),StringPart(12:31-12:36),StringEnd(12:36-12:37),CloseRound(12:37-12:38), +EndOfFile(13:1-13:1), ~~~ # PARSE ~~~clojure -(file @1.1-14.38 - (module @1.1-1.22 - (exposes @1.8-1.22 - (exposed-lower-ident @1.9-1.21 - (text "json_encoder")))) +(file @1.1-12.38 + (type-module @1.1-1.7) (statements - (s-import @3.1-3.17 (raw "json.Core")) - (s-malformed @3.17-3.22 (tag "statement_unexpected_token")) - (s-malformed @3.23-3.31 (tag "statement_unexpected_token")) - (s-malformed @3.32-3.33 (tag "statement_unexpected_token")) - (s-malformed @3.40-3.41 (tag "expected_colon_after_type_annotation")) - (s-type-anno @5.1-5.23 (name "json_encoder") - (ty @5.16-5.23 (name "Encoder"))) - (s-decl @6.1-6.45 - (p-ident @6.1-6.13 (raw "json_encoder")) - (e-ident @6.16-6.45 (raw "Json.Core.Utf8.defaultEncoder"))) - (s-type-anno @9.1-9.40 (name "process") - (ty-fn @9.11-9.40 - (ty @9.11-9.33 (name "json.Core.Utf8.Encoder")) - (ty @9.37-9.40 (name "Str")))) - (s-decl @10.1-10.33 - (p-ident @10.1-10.8 (raw "process")) - (e-lambda @10.11-10.33 + (s-import @1.1-1.17 (raw "json.Core")) + (s-malformed @1.17-1.22 (tag "statement_unexpected_token")) + (s-malformed @1.23-1.31 (tag "statement_unexpected_token")) + (s-malformed @1.32-1.33 (tag "statement_unexpected_token")) + (s-malformed @1.40-1.41 (tag "expected_colon_after_type_annotation")) + (s-type-anno @3.1-3.23 (name "json_encoder") + (ty @3.16-3.23 (name "Encoder"))) + (s-decl @4.1-4.45 + (p-ident @4.1-4.13 (raw "json_encoder")) + (e-ident @4.16-4.45 (raw "Json.Core.Utf8.defaultEncoder"))) + (s-type-anno @7.1-7.40 (name "process") + (ty-fn @7.11-7.40 + (ty @7.11-7.33 (name "json.Core.Utf8.Encoder")) + (ty @7.37-7.40 (name "Str")))) + (s-decl @8.1-8.33 + (p-ident @8.1-8.8 (raw "process")) + (e-lambda @8.11-8.33 (args - (p-ident @10.12-10.19 (raw "encoder"))) - (e-string @10.21-10.33 - (e-string-part @10.22-10.32 (raw "processing"))))) - (s-type-anno @13.1-13.34 (name "data") - (ty @13.8-13.34 (name "json.Core.Utf8.EncodedData"))) - (s-decl @14.1-14.12 - (p-ident @14.1-14.5 (raw "data")) - (e-ident @14.8-14.12 (raw "json"))) - (s-malformed @14.12-14.17 (tag "statement_unexpected_token")) - (s-malformed @14.17-14.22 (tag "statement_unexpected_token")) - (s-malformed @14.22-14.29 (tag "statement_unexpected_token")) - (s-malformed @14.29-14.30 (tag "statement_unexpected_token")) - (s-malformed @14.30-14.31 (tag "statement_unexpected_token")) - (s-malformed @14.31-14.36 (tag "statement_unexpected_token")) - (s-malformed @14.36-14.37 (tag "statement_unexpected_token")) - (s-malformed @14.37-14.38 (tag "statement_unexpected_token")))) + (p-ident @8.12-8.19 (raw "encoder"))) + (e-string @8.21-8.33 + (e-string-part @8.22-8.32 (raw "processing"))))) + (s-type-anno @11.1-11.34 (name "data") + (ty @11.8-11.34 (name "json.Core.Utf8.EncodedData"))) + (s-decl @12.1-12.12 + (p-ident @12.1-12.5 (raw "data")) + (e-ident @12.8-12.12 (raw "json"))) + (s-malformed @12.12-12.17 (tag "statement_unexpected_token")) + (s-malformed @12.17-12.22 (tag "statement_unexpected_token")) + (s-malformed @12.22-12.29 (tag "statement_unexpected_token")) + (s-malformed @12.29-12.30 (tag "statement_unexpected_token")) + (s-malformed @12.30-12.31 (tag "statement_unexpected_token")) + (s-malformed @12.31-12.36 (tag "statement_unexpected_token")) + (s-malformed @12.36-12.37 (tag "statement_unexpected_token")) + (s-malformed @12.37-12.38 (tag "statement_unexpected_token")))) ~~~ # FORMATTED ~~~roc -module [json_encoder] - import json.Core @@ -360,41 +332,41 @@ data = json ~~~clojure (can-ir (d-let - (p-assign @6.1-6.13 (ident "json_encoder")) + (p-assign @4.1-4.13 (ident "json_encoder")) (e-runtime-error (tag "ident_not_in_scope")) - (annotation @6.1-6.13 + (annotation @4.1-4.13 (declared-type - (ty @5.16-5.23 (name "Encoder"))))) + (ty-malformed @3.16-3.23)))) (d-let - (p-assign @10.1-10.8 (ident "process")) - (e-lambda @10.11-10.33 + (p-assign @8.1-8.8 (ident "process")) + (e-lambda @8.11-8.33 (args - (p-assign @10.12-10.19 (ident "encoder"))) - (e-string @10.21-10.33 - (e-literal @10.22-10.32 (string "processing")))) - (annotation @10.1-10.8 + (p-assign @8.12-8.19 (ident "encoder"))) + (e-string @8.21-8.33 + (e-literal @8.22-8.32 (string "processing")))) + (annotation @8.1-8.8 (declared-type - (ty-fn @9.11-9.40 (effectful false) - (ty-malformed @9.11-9.33) - (ty @9.37-9.40 (name "Str")))))) + (ty-fn @7.11-7.40 (effectful false) + (ty-malformed @7.11-7.33) + (ty-lookup @7.37-7.40 (name "Str") (builtin)))))) (d-let - (p-assign @14.1-14.5 (ident "data")) + (p-assign @12.1-12.5 (ident "data")) (e-runtime-error (tag "ident_not_in_scope")) - (annotation @14.1-14.5 + (annotation @12.1-12.5 (declared-type - (ty-malformed @13.8-13.34)))) - (s-import @3.1-3.17 (module "json.Core") (qualifier "json") + (ty-malformed @11.8-11.34)))) + (s-import @1.1-1.17 (module "json.Core") (qualifier "json") (exposes))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @6.1-6.13 (type "Error")) - (patt @10.1-10.8 (type "Error -> Str")) - (patt @14.1-14.5 (type "Error"))) + (patt @4.1-4.13 (type "Error")) + (patt @8.1-8.8 (type "Error -> Str")) + (patt @12.1-12.5 (type "Error"))) (expressions - (expr @6.16-6.45 (type "Error")) - (expr @10.11-10.33 (type "Error -> Str")) - (expr @14.8-14.12 (type "Error")))) + (expr @4.16-4.45 (type "Error")) + (expr @8.11-8.33 (type "Error -> Str")) + (expr @12.8-12.12 (type "Error")))) ~~~ diff --git a/test/snapshots/multiline_binop_1.md b/test/snapshots/multiline_binop_1.md index 3dd1913b04..38bbbf1684 100644 --- a/test/snapshots/multiline_binop_1.md +++ b/test/snapshots/multiline_binop_1.md @@ -42,10 +42,10 @@ NO CHANGE # CANONICALIZE ~~~clojure (e-binop @1.1-8.4 (op "add") - (e-int @1.1-1.2 (value "1")) + (e-num @1.1-1.2 (value "1")) (e-binop @6.2-8.4 (op "mul") - (e-int @6.2-6.3 (value "2")) - (e-int @8.3-8.4 (value "3")))) + (e-num @6.2-6.3 (value "2")) + (e-num @8.3-8.4 (value "3")))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/multiline_list_formatting_11.md b/test/snapshots/multiline_list_formatting_11.md index dc2a3f906d..42f7fb24d0 100644 --- a/test/snapshots/multiline_list_formatting_11.md +++ b/test/snapshots/multiline_list_formatting_11.md @@ -55,17 +55,17 @@ NO CHANGE (elems (e-list @2.2-2.5 (elems - (e-int @2.3-2.4 (value "1")))) + (e-num @2.3-2.4 (value "1")))) (e-list @3.2-3.5 (elems - (e-int @3.3-3.4 (value "2")))) + (e-num @3.3-3.4 (value "2")))) (e-list @4.2-7.3 (elems - (e-int @5.3-5.4 (value "3")) - (e-int @6.3-6.4 (value "4")))) + (e-num @5.3-5.4 (value "3")) + (e-num @6.3-6.4 (value "4")))) (e-list @8.2-8.5 (elems - (e-int @8.3-8.4 (value "5")))))) + (e-num @8.3-8.4 (value "5")))))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/multiline_list_formatting_14.md b/test/snapshots/multiline_list_formatting_14.md index 65cf7f4790..db163e3083 100644 --- a/test/snapshots/multiline_list_formatting_14.md +++ b/test/snapshots/multiline_list_formatting_14.md @@ -43,9 +43,9 @@ NO CHANGE ~~~clojure (e-list @1.1-9.2 (elems - (e-int @2.2-2.3 (value "1")) - (e-int @6.2-6.3 (value "2")) - (e-int @8.2-8.3 (value "3")))) + (e-num @2.2-2.3 (value "1")) + (e-num @6.2-6.3 (value "2")) + (e-num @8.2-8.3 (value "3")))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/multiline_list_formatting_5.md b/test/snapshots/multiline_list_formatting_5.md index 8c8fad0610..76131c6544 100644 --- a/test/snapshots/multiline_list_formatting_5.md +++ b/test/snapshots/multiline_list_formatting_5.md @@ -37,9 +37,9 @@ EndOfFile(3:1-3:1), ~~~clojure (e-list @1.1-2.5 (elems - (e-int @1.2-1.3 (value "1")) - (e-int @1.5-1.6 (value "2")) - (e-int @2.3-2.4 (value "3")))) + (e-num @1.2-1.3 (value "1")) + (e-num @1.5-1.6 (value "2")) + (e-num @2.3-2.4 (value "3")))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/multiline_list_formatting_7.md b/test/snapshots/multiline_list_formatting_7.md index 48b8637c57..c998e8340d 100644 --- a/test/snapshots/multiline_list_formatting_7.md +++ b/test/snapshots/multiline_list_formatting_7.md @@ -39,9 +39,9 @@ NO CHANGE ~~~clojure (e-list @1.1-5.2 (elems - (e-int @2.2-2.3 (value "1")) - (e-int @3.2-3.3 (value "2")) - (e-int @4.2-4.3 (value "3")))) + (e-num @2.2-2.3 (value "1")) + (e-num @3.2-3.3 (value "2")) + (e-num @4.2-4.3 (value "3")))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/multiline_string_complex.md b/test/snapshots/multiline_string_complex.md index 829f86c33f..6a00f69892 100644 --- a/test/snapshots/multiline_string_complex.md +++ b/test/snapshots/multiline_string_complex.md @@ -8,124 +8,124 @@ type=file package [] { - x: """Multiline + x: \\Multiline , } -value1 = """This is a "string" with just one line +value1 = \\This is a "string" with just one line value2 = - """This is a "string" with just one line + \\This is a "string" with just one line -value3 = """This is a string - """With multiple lines - """${value1} +value3 = \\This is a string + \\With multiple lines + \\${value1} value4 = - """This is a string + \\This is a string # A comment in between - """With multiple lines - """${value2} + \\With multiple lines + \\${value2} value5 = { - a: """Multiline + a: \\Multiline , b: ( - """Multiline + \\Multiline , - """Multiline + \\Multiline , ), c: [ - """multiline + \\multiline , ], d: ( - 0 - """ + 0 - \\ , ), - e: !""" + e: !\\ , } x = { - """ - """ + \\ + \\ } ~~~ # EXPECTED -TYPE MISMATCH - multiline_string_complex.md:37:7:37:10 -TYPE MISMATCH - multiline_string_complex.md:40:5:40:9 +TYPE MISMATCH - multiline_string_complex.md:37:7:37:9 +TYPE MISMATCH - multiline_string_complex.md:40:6:40:8 # PROBLEMS **TYPE MISMATCH** This expression is used in an unexpected way: -**multiline_string_complex.md:37:7:37:10:** +**multiline_string_complex.md:37:7:37:9:** ```roc - 0 - """ + 0 - \\ ``` - ^^^ + ^^ It has the type: _Str_ -But here it's being used as: +But I expected it to be: _Num(_size)_ **TYPE MISMATCH** This expression is used in an unexpected way: -**multiline_string_complex.md:40:5:40:9:** +**multiline_string_complex.md:40:6:40:8:** ```roc - e: !""" + e: !\\ ``` - ^^^^ + ^^ It has the type: - _Bool_ - -But here it's being used as: _Str_ +But I expected it to be: + _Bool_ + # TOKENS ~~~zig KwPackage(1:1-1:8), OpenSquare(2:2-2:3),CloseSquare(2:3-2:4), OpenCurly(3:2-3:3), -LowerIdent(4:3-4:4),OpColon(4:4-4:5),MultilineStringStart(4:6-4:9),StringPart(4:9-4:18), +LowerIdent(4:3-4:4),OpColon(4:4-4:5),MultilineStringStart(4:6-4:8),StringPart(4:8-4:17), Comma(5:3-5:4), CloseCurly(6:2-6:3), -LowerIdent(8:1-8:7),OpAssign(8:8-8:9),MultilineStringStart(8:10-8:13),StringPart(8:13-8:50), +LowerIdent(8:1-8:7),OpAssign(8:8-8:9),MultilineStringStart(8:10-8:12),StringPart(8:12-8:49), LowerIdent(10:1-10:7),OpAssign(10:8-10:9), -MultilineStringStart(11:2-11:5),StringPart(11:5-11:42), -LowerIdent(13:1-13:7),OpAssign(13:8-13:9),MultilineStringStart(13:10-13:13),StringPart(13:13-13:29), -MultilineStringStart(14:2-14:5),StringPart(14:5-14:24), -MultilineStringStart(15:2-15:5),StringPart(15:5-15:5),OpenStringInterpolation(15:5-15:7),LowerIdent(15:7-15:13),CloseStringInterpolation(15:13-15:14),StringPart(15:14-15:14), +MultilineStringStart(11:2-11:4),StringPart(11:4-11:41), +LowerIdent(13:1-13:7),OpAssign(13:8-13:9),MultilineStringStart(13:10-13:12),StringPart(13:12-13:28), +MultilineStringStart(14:2-14:4),StringPart(14:4-14:23), +MultilineStringStart(15:2-15:4),StringPart(15:4-15:4),OpenStringInterpolation(15:4-15:6),LowerIdent(15:6-15:12),CloseStringInterpolation(15:12-15:13),StringPart(15:13-15:13), LowerIdent(17:1-17:7),OpAssign(17:8-17:9), -MultilineStringStart(18:2-18:5),StringPart(18:5-18:21), -MultilineStringStart(20:2-20:5),StringPart(20:5-20:24), -MultilineStringStart(21:2-21:5),StringPart(21:5-21:5),OpenStringInterpolation(21:5-21:7),LowerIdent(21:7-21:13),CloseStringInterpolation(21:13-21:14),StringPart(21:14-21:14), +MultilineStringStart(18:2-18:4),StringPart(18:4-18:20), +MultilineStringStart(20:2-20:4),StringPart(20:4-20:23), +MultilineStringStart(21:2-21:4),StringPart(21:4-21:4),OpenStringInterpolation(21:4-21:6),LowerIdent(21:6-21:12),CloseStringInterpolation(21:12-21:13),StringPart(21:13-21:13), LowerIdent(23:1-23:7),OpAssign(23:8-23:9),OpenCurly(23:10-23:11), -LowerIdent(24:2-24:3),OpColon(24:3-24:4),MultilineStringStart(24:5-24:8),StringPart(24:8-24:17), +LowerIdent(24:2-24:3),OpColon(24:3-24:4),MultilineStringStart(24:5-24:7),StringPart(24:7-24:16), Comma(25:2-25:3), LowerIdent(26:2-26:3),OpColon(26:3-26:4),OpenRound(26:5-26:6), -MultilineStringStart(27:3-27:6),StringPart(27:6-27:15), +MultilineStringStart(27:3-27:5),StringPart(27:5-27:14), Comma(28:3-28:4), -MultilineStringStart(29:3-29:6),StringPart(29:6-29:15), +MultilineStringStart(29:3-29:5),StringPart(29:5-29:14), Comma(30:3-30:4), CloseRound(31:2-31:3),Comma(31:3-31:4), LowerIdent(32:2-32:3),OpColon(32:3-32:4),OpenSquare(32:5-32:6), -MultilineStringStart(33:3-33:6),StringPart(33:6-33:15), +MultilineStringStart(33:3-33:5),StringPart(33:5-33:14), Comma(34:3-34:4), CloseSquare(35:2-35:3),Comma(35:3-35:4), LowerIdent(36:2-36:3),OpColon(36:3-36:4),OpenRound(36:5-36:6), -Int(37:3-37:4),OpBinaryMinus(37:5-37:6),MultilineStringStart(37:7-37:10),StringPart(37:10-37:10), +Int(37:3-37:4),OpBinaryMinus(37:5-37:6),MultilineStringStart(37:7-37:9),StringPart(37:9-37:9), Comma(38:3-38:4), CloseRound(39:2-39:3),Comma(39:3-39:4), -LowerIdent(40:2-40:3),OpColon(40:3-40:4),OpBang(40:5-40:6),MultilineStringStart(40:6-40:9),StringPart(40:9-40:9), +LowerIdent(40:2-40:3),OpColon(40:3-40:4),OpBang(40:5-40:6),MultilineStringStart(40:6-40:8),StringPart(40:8-40:8), Comma(41:2-41:3), CloseCurly(42:1-42:2), LowerIdent(44:1-44:2),OpAssign(44:3-44:4),OpenCurly(44:5-44:6), -MultilineStringStart(45:2-45:5),StringPart(45:5-45:5), -MultilineStringStart(46:2-46:5),StringPart(46:5-46:5), +MultilineStringStart(45:2-45:4),StringPart(45:4-45:4), +MultilineStringStart(46:2-46:4),StringPart(46:4-46:4), CloseCurly(47:1-47:2), EndOfFile(48:1-48:1), ~~~ @@ -135,67 +135,67 @@ EndOfFile(48:1-48:1), (package @1.1-6.3 (exposes @2.2-2.4) (packages @3.2-6.3 - (record-field @4.3-4.18 (name "x") - (e-multiline-string @4.6-4.18 - (e-string-part @4.9-4.18 (raw "Multiline")))))) + (record-field @4.3-4.17 (name "x") + (e-multiline-string @4.6-4.17 + (e-string-part @4.8-4.17 (raw "Multiline")))))) (statements - (s-decl @8.1-8.50 + (s-decl @8.1-8.49 (p-ident @8.1-8.7 (raw "value1")) - (e-multiline-string @8.10-8.50 - (e-string-part @8.13-8.50 (raw "This is a "string" with just one line")))) - (s-decl @10.1-11.42 + (e-multiline-string @8.10-8.49 + (e-string-part @8.12-8.49 (raw "This is a "string" with just one line")))) + (s-decl @10.1-11.41 (p-ident @10.1-10.7 (raw "value2")) - (e-multiline-string @11.2-11.42 - (e-string-part @11.5-11.42 (raw "This is a "string" with just one line")))) - (s-decl @13.1-15.14 + (e-multiline-string @11.2-11.41 + (e-string-part @11.4-11.41 (raw "This is a "string" with just one line")))) + (s-decl @13.1-15.13 (p-ident @13.1-13.7 (raw "value3")) - (e-multiline-string @13.10-15.14 - (e-string-part @13.13-13.29 (raw "This is a string")) - (e-string-part @14.5-14.24 (raw "With multiple lines")) - (e-string-part @15.5-15.5 (raw "")) - (e-ident @15.7-15.13 (raw "value1")) - (e-string-part @15.14-15.14 (raw "")))) - (s-decl @17.1-21.14 + (e-multiline-string @13.10-15.13 + (e-string-part @13.12-13.28 (raw "This is a string")) + (e-string-part @14.4-14.23 (raw "With multiple lines")) + (e-string-part @15.4-15.4 (raw "")) + (e-ident @15.6-15.12 (raw "value1")) + (e-string-part @15.13-15.13 (raw "")))) + (s-decl @17.1-21.13 (p-ident @17.1-17.7 (raw "value4")) - (e-multiline-string @18.2-21.14 - (e-string-part @18.5-18.21 (raw "This is a string")) - (e-string-part @20.5-20.24 (raw "With multiple lines")) - (e-string-part @21.5-21.5 (raw "")) - (e-ident @21.7-21.13 (raw "value2")) - (e-string-part @21.14-21.14 (raw "")))) + (e-multiline-string @18.2-21.13 + (e-string-part @18.4-18.20 (raw "This is a string")) + (e-string-part @20.4-20.23 (raw "With multiple lines")) + (e-string-part @21.4-21.4 (raw "")) + (e-ident @21.6-21.12 (raw "value2")) + (e-string-part @21.13-21.13 (raw "")))) (s-decl @23.1-42.2 (p-ident @23.1-23.7 (raw "value5")) (e-record @23.10-42.2 (field (field "a") - (e-multiline-string @24.5-24.17 - (e-string-part @24.8-24.17 (raw "Multiline")))) + (e-multiline-string @24.5-24.16 + (e-string-part @24.7-24.16 (raw "Multiline")))) (field (field "b") (e-tuple @26.5-31.3 - (e-multiline-string @27.3-27.15 - (e-string-part @27.6-27.15 (raw "Multiline"))) - (e-multiline-string @29.3-29.15 - (e-string-part @29.6-29.15 (raw "Multiline"))))) + (e-multiline-string @27.3-27.14 + (e-string-part @27.5-27.14 (raw "Multiline"))) + (e-multiline-string @29.3-29.14 + (e-string-part @29.5-29.14 (raw "Multiline"))))) (field (field "c") (e-list @32.5-35.3 - (e-multiline-string @33.3-33.15 - (e-string-part @33.6-33.15 (raw "multiline"))))) + (e-multiline-string @33.3-33.14 + (e-string-part @33.5-33.14 (raw "multiline"))))) (field (field "d") (e-tuple @36.5-39.3 - (e-binop @37.3-37.10 (op "-") + (e-binop @37.3-37.9 (op "-") (e-int @37.3-37.4 (raw "0")) - (e-multiline-string @37.7-37.10 - (e-string-part @37.10-37.10 (raw "")))))) + (e-multiline-string @37.7-37.9 + (e-string-part @37.9-37.9 (raw "")))))) (field (field "e") (unary "!" - (e-multiline-string @40.6-40.9 - (e-string-part @40.9-40.9 (raw ""))))))) + (e-multiline-string @40.6-40.8 + (e-string-part @40.8-40.8 (raw ""))))))) (s-decl @44.1-47.2 (p-ident @44.1-44.2 (raw "x")) (e-block @44.5-47.2 (statements - (e-multiline-string @45.2-46.5 - (e-string-part @45.5-45.5 (raw "")) - (e-string-part @46.5-46.5 (raw "")))))))) + (e-multiline-string @45.2-46.4 + (e-string-part @45.4-45.4 (raw "")) + (e-string-part @46.4-46.4 (raw "")))))))) ~~~ # FORMATTED ~~~roc @@ -206,61 +206,61 @@ NO CHANGE (can-ir (d-let (p-assign @8.1-8.7 (ident "value1")) - (e-string @8.10-8.50 - (e-literal @8.13-8.50 (string "This is a "string" with just one line")))) + (e-string @8.10-8.49 + (e-literal @8.12-8.49 (string "This is a "string" with just one line")))) (d-let (p-assign @10.1-10.7 (ident "value2")) - (e-string @11.2-11.42 - (e-literal @11.5-11.42 (string "This is a "string" with just one line")))) + (e-string @11.2-11.41 + (e-literal @11.4-11.41 (string "This is a "string" with just one line")))) (d-let (p-assign @13.1-13.7 (ident "value3")) - (e-string @13.10-15.14 - (e-literal @13.13-13.29 (string "This is a string")) - (e-literal @14.2-14.5 (string "\n")) - (e-literal @14.5-14.24 (string "With multiple lines")) - (e-literal @15.2-15.5 (string "\n")) - (e-lookup-local @15.7-15.13 + (e-string @13.10-15.13 + (e-literal @13.12-13.28 (string "This is a string")) + (e-literal @14.2-14.4 (string "\n")) + (e-literal @14.4-14.23 (string "With multiple lines")) + (e-literal @15.2-15.4 (string "\n")) + (e-lookup-local @15.6-15.12 (p-assign @8.1-8.7 (ident "value1"))))) (d-let (p-assign @17.1-17.7 (ident "value4")) - (e-string @18.2-21.14 - (e-literal @18.5-18.21 (string "This is a string")) - (e-literal @20.2-20.5 (string "\n")) - (e-literal @20.5-20.24 (string "With multiple lines")) - (e-literal @21.2-21.5 (string "\n")) - (e-lookup-local @21.7-21.13 + (e-string @18.2-21.13 + (e-literal @18.4-18.20 (string "This is a string")) + (e-literal @20.2-20.4 (string "\n")) + (e-literal @20.4-20.23 (string "With multiple lines")) + (e-literal @21.2-21.4 (string "\n")) + (e-lookup-local @21.6-21.12 (p-assign @10.1-10.7 (ident "value2"))))) (d-let (p-assign @23.1-23.7 (ident "value5")) (e-record @23.10-42.2 (fields (field (name "a") - (e-string @24.5-24.17 - (e-literal @24.8-24.17 (string "Multiline")))) + (e-string @24.5-24.16 + (e-literal @24.7-24.16 (string "Multiline")))) (field (name "b") (e-tuple @26.5-31.3 (elems - (e-string @27.3-27.15 - (e-literal @27.6-27.15 (string "Multiline"))) - (e-string @29.3-29.15 - (e-literal @29.6-29.15 (string "Multiline")))))) + (e-string @27.3-27.14 + (e-literal @27.5-27.14 (string "Multiline"))) + (e-string @29.3-29.14 + (e-literal @29.5-29.14 (string "Multiline")))))) (field (name "c") (e-list @32.5-35.3 (elems - (e-string @33.3-33.15 - (e-literal @33.6-33.15 (string "multiline")))))) + (e-string @33.3-33.14 + (e-literal @33.5-33.14 (string "multiline")))))) (field (name "d") - (e-binop @37.3-37.10 (op "sub") - (e-int @37.3-37.4 (value "0")) - (e-string @37.7-37.10))) + (e-binop @37.3-37.9 (op "sub") + (e-num @37.3-37.4 (value "0")) + (e-string @37.7-37.9))) (field (name "e") - (e-unary-not @40.5-40.9 - (e-string @40.6-40.9)))))) + (e-unary-not @40.5-40.8 + (e-string @40.6-40.8)))))) (d-let (p-assign @44.1-44.2 (ident "x")) (e-block @44.5-47.2 - (e-string @45.2-46.5 - (e-literal @46.2-46.5 (string "\n")))))) + (e-string @45.2-46.4 + (e-literal @46.2-46.4 (string "\n")))))) ~~~ # TYPES ~~~clojure @@ -270,13 +270,13 @@ NO CHANGE (patt @10.1-10.7 (type "Str")) (patt @13.1-13.7 (type "Str")) (patt @17.1-17.7 (type "Str")) - (patt @23.1-23.7 (type "{ a: Str, b: (Str, Str), c: List(Str), d: Num(_size), e: Error }")) + (patt @23.1-23.7 (type "{ a: Str, b: (Str, Str), c: List(Str), d: Error, e: Error }")) (patt @44.1-44.2 (type "Str"))) (expressions - (expr @8.10-8.50 (type "Str")) - (expr @11.2-11.42 (type "Str")) - (expr @13.10-15.14 (type "Str")) - (expr @18.2-21.14 (type "Str")) - (expr @23.10-42.2 (type "{ a: Str, b: (Str, Str), c: List(Str), d: Num(_size), e: Error }")) + (expr @8.10-8.49 (type "Str")) + (expr @11.2-11.41 (type "Str")) + (expr @13.10-15.13 (type "Str")) + (expr @18.2-21.13 (type "Str")) + (expr @23.10-42.2 (type "{ a: Str, b: (Str, Str), c: List(Str), d: Error, e: Error }")) (expr @44.5-47.2 (type "Str")))) ~~~ diff --git a/test/snapshots/multiline_string_expr.md b/test/snapshots/multiline_string_expr.md index 80b823e044..c975fadc41 100644 --- a/test/snapshots/multiline_string_expr.md +++ b/test/snapshots/multiline_string_expr.md @@ -5,8 +5,8 @@ type=expr ~~~ # SOURCE ~~~roc -"""This is a string -"""With multiple lines +\\This is a string +\\With multiple lines ~~~ # EXPECTED NIL @@ -14,15 +14,15 @@ NIL NIL # TOKENS ~~~zig -MultilineStringStart(1:1-1:4),StringPart(1:4-1:20), -MultilineStringStart(2:1-2:4),StringPart(2:4-2:23), +MultilineStringStart(1:1-1:3),StringPart(1:3-1:19), +MultilineStringStart(2:1-2:3),StringPart(2:3-2:22), EndOfFile(3:1-3:1), ~~~ # PARSE ~~~clojure -(e-multiline-string @1.1-2.23 - (e-string-part @1.4-1.20 (raw "This is a string")) - (e-string-part @2.4-2.23 (raw "With multiple lines"))) +(e-multiline-string @1.1-2.22 + (e-string-part @1.3-1.19 (raw "This is a string")) + (e-string-part @2.3-2.22 (raw "With multiple lines"))) ~~~ # FORMATTED ~~~roc @@ -30,12 +30,12 @@ NO CHANGE ~~~ # CANONICALIZE ~~~clojure -(e-string @1.1-2.23 - (e-literal @1.4-1.20 (string "This is a string")) - (e-literal @2.1-2.4 (string "\n")) - (e-literal @2.4-2.23 (string "With multiple lines"))) +(e-string @1.1-2.22 + (e-literal @1.3-1.19 (string "This is a string")) + (e-literal @2.1-2.3 (string "\n")) + (e-literal @2.3-2.22 (string "With multiple lines"))) ~~~ # TYPES ~~~clojure -(expr @1.1-2.23 (type "Str")) +(expr @1.1-2.22 (type "Str")) ~~~ diff --git a/test/snapshots/nominal/nominal_associated_alias_within_block.md b/test/snapshots/nominal/nominal_associated_alias_within_block.md new file mode 100644 index 0000000000..2fe77aa147 --- /dev/null +++ b/test/snapshots/nominal/nominal_associated_alias_within_block.md @@ -0,0 +1,131 @@ +# META +~~~ini +description=Type alias within associated block referencing another nested type +type=snippet +~~~ +# SOURCE +~~~roc +Foo := [Whatever].{ + Bar := [X, Y, Z] + + # Alias within the associated block + Baz : Foo.Bar + + defaultBaz : Foo.Baz + defaultBaz = Foo.Bar.X +} + +external : Foo.Baz +external = Foo.defaultBaz +~~~ +# EXPECTED +NIL +# PROBLEMS +NIL +# TOKENS +~~~zig +UpperIdent(1:1-1:4),OpColonEqual(1:5-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:17),CloseSquare(1:17-1:18),Dot(1:18-1:19),OpenCurly(1:19-1:20), +UpperIdent(2:5-2:8),OpColonEqual(2:9-2:11),OpenSquare(2:12-2:13),UpperIdent(2:13-2:14),Comma(2:14-2:15),UpperIdent(2:16-2:17),Comma(2:17-2:18),UpperIdent(2:19-2:20),CloseSquare(2:20-2:21), +UpperIdent(5:5-5:8),OpColon(5:9-5:10),UpperIdent(5:11-5:14),NoSpaceDotUpperIdent(5:14-5:18), +LowerIdent(7:5-7:15),OpColon(7:16-7:17),UpperIdent(7:18-7:21),NoSpaceDotUpperIdent(7:21-7:25), +LowerIdent(8:5-8:15),OpAssign(8:16-8:17),UpperIdent(8:18-8:21),NoSpaceDotUpperIdent(8:21-8:25),NoSpaceDotUpperIdent(8:25-8:27), +CloseCurly(9:1-9:2), +LowerIdent(11:1-11:9),OpColon(11:10-11:11),UpperIdent(11:12-11:15),NoSpaceDotUpperIdent(11:15-11:19), +LowerIdent(12:1-12:9),OpAssign(12:10-12:11),UpperIdent(12:12-12:15),NoSpaceDotLowerIdent(12:15-12:26), +EndOfFile(13:1-13:1), +~~~ +# PARSE +~~~clojure +(file @1.1-12.26 + (type-module @1.1-1.4) + (statements + (s-type-decl @1.1-9.2 + (header @1.1-1.4 (name "Foo") + (args)) + (ty-tag-union @1.8-1.18 + (tags + (ty @1.9-1.17 (name "Whatever")))) + (associated @1.19-9.2 + (s-type-decl @2.5-2.21 + (header @2.5-2.8 (name "Bar") + (args)) + (ty-tag-union @2.12-2.21 + (tags + (ty @2.13-2.14 (name "X")) + (ty @2.16-2.17 (name "Y")) + (ty @2.19-2.20 (name "Z"))))) + (s-type-decl @5.5-5.18 + (header @5.5-5.8 (name "Baz") + (args)) + (ty @5.11-5.18 (name "Foo.Bar"))) + (s-type-anno @7.5-7.25 (name "defaultBaz") + (ty @7.18-7.25 (name "Foo.Baz"))) + (s-decl @8.5-8.27 + (p-ident @8.5-8.15 (raw "defaultBaz")) + (e-tag @8.18-8.27 (raw "Foo.Bar.X"))))) + (s-type-anno @11.1-11.19 (name "external") + (ty @11.12-11.19 (name "Foo.Baz"))) + (s-decl @12.1-12.26 + (p-ident @12.1-12.9 (raw "external")) + (e-ident @12.12-12.26 (raw "Foo.defaultBaz"))))) +~~~ +# FORMATTED +~~~roc +Foo := [Whatever].{ + Bar := [X, Y, Z] + Baz : Foo.Bar + defaultBaz : Foo.Baz + defaultBaz = Foo.Bar.X +} + +external : Foo.Baz +external = Foo.defaultBaz +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @12.1-12.9 (ident "external")) + (e-lookup-local @12.12-12.26 + (p-assign @8.5-8.27 (ident "Foo.defaultBaz"))) + (annotation @12.1-12.9 + (declared-type + (ty-lookup @11.12-11.19 (name "Foo.Baz") (local))))) + (d-let + (p-assign @8.5-8.27 (ident "Foo.defaultBaz")) + (e-nominal @8.18-8.27 (nominal "Foo.Bar") + (e-tag @8.18-8.27 (name "X"))) + (annotation @8.5-8.15 + (declared-type + (ty-lookup @7.18-7.25 (name "Foo.Baz") (local))))) + (s-nominal-decl @1.1-9.2 + (ty-header @1.1-1.4 (name "Foo")) + (ty-tag-union @1.8-1.18 + (ty-tag-name @1.9-1.17 (name "Whatever")))) + (s-nominal-decl @2.5-2.21 + (ty-header @2.5-2.21 (name "Foo.Bar")) + (ty-tag-union @2.12-2.21 + (ty-tag-name @2.13-2.14 (name "X")) + (ty-tag-name @2.16-2.17 (name "Y")) + (ty-tag-name @2.19-2.20 (name "Z")))) + (s-alias-decl @5.5-5.18 + (ty-header @5.5-5.18 (name "Foo.Baz")) + (ty-lookup @5.11-5.18 (name "Foo.Bar") (local)))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @12.1-12.9 (type "Foo.Baz")) + (patt @8.5-8.27 (type "Foo.Baz"))) + (type_decls + (nominal @1.1-9.2 (type "Foo") + (ty-header @1.1-1.4 (name "Foo"))) + (nominal @2.5-2.21 (type "Foo.Bar") + (ty-header @2.5-2.21 (name "Foo.Bar"))) + (alias @5.5-5.18 (type "Foo.Baz") + (ty-header @5.5-5.18 (name "Foo.Baz")))) + (expressions + (expr @12.12-12.26 (type "Foo.Baz")) + (expr @8.18-8.27 (type "Foo.Baz")))) +~~~ diff --git a/test/snapshots/nominal/nominal_associated_decls.md b/test/snapshots/nominal/nominal_associated_decls.md new file mode 100644 index 0000000000..a5f2c38731 --- /dev/null +++ b/test/snapshots/nominal/nominal_associated_decls.md @@ -0,0 +1,96 @@ +# META +~~~ini +description=Nominal type with declarations in associated blocks +type=file:Foo.roc +~~~ +# SOURCE +~~~roc +Foo := [Whatever].{ + Bar := [Something].{ + baz = 5 + } + blah = 6 +} +~~~ +# EXPECTED +NIL +# PROBLEMS +NIL +# TOKENS +~~~zig +UpperIdent(1:1-1:4),OpColonEqual(1:5-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:17),CloseSquare(1:17-1:18),Dot(1:18-1:19),OpenCurly(1:19-1:20), +UpperIdent(2:5-2:8),OpColonEqual(2:9-2:11),OpenSquare(2:12-2:13),UpperIdent(2:13-2:22),CloseSquare(2:22-2:23),Dot(2:23-2:24),OpenCurly(2:24-2:25), +LowerIdent(3:9-3:12),OpAssign(3:13-3:14),Int(3:15-3:16), +CloseCurly(4:5-4:6), +LowerIdent(5:5-5:9),OpAssign(5:10-5:11),Int(5:12-5:13), +CloseCurly(6:1-6:2), +EndOfFile(7:1-7:1), +~~~ +# PARSE +~~~clojure +(file @1.1-6.2 + (type-module @1.1-1.4) + (statements + (s-type-decl @1.1-6.2 + (header @1.1-1.4 (name "Foo") + (args)) + (ty-tag-union @1.8-1.18 + (tags + (ty @1.9-1.17 (name "Whatever")))) + (associated @1.19-6.2 + (s-type-decl @2.5-4.6 + (header @2.5-2.8 (name "Bar") + (args)) + (ty-tag-union @2.12-2.23 + (tags + (ty @2.13-2.22 (name "Something")))) + (associated @2.24-4.6 + (s-decl @3.9-3.16 + (p-ident @3.9-3.12 (raw "baz")) + (e-int @3.15-3.16 (raw "5"))))) + (s-decl @5.5-5.13 + (p-ident @5.5-5.9 (raw "blah")) + (e-int @5.12-5.13 (raw "6"))))))) +~~~ +# FORMATTED +~~~roc +Foo := [Whatever].{ + Bar := [Something].{ + baz = 5 + } + blah = 6 +} +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @3.9-3.16 (ident "Foo.Bar.baz")) + (e-num @3.15-3.16 (value "5"))) + (d-let + (p-assign @5.5-5.13 (ident "Foo.blah")) + (e-num @5.12-5.13 (value "6"))) + (s-nominal-decl @1.1-6.2 + (ty-header @1.1-1.4 (name "Foo")) + (ty-tag-union @1.8-1.18 + (ty-tag-name @1.9-1.17 (name "Whatever")))) + (s-nominal-decl @2.5-4.6 + (ty-header @2.5-4.6 (name "Foo.Bar")) + (ty-tag-union @2.12-2.23 + (ty-tag-name @2.13-2.22 (name "Something"))))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @3.9-3.16 (type "Num(_size)")) + (patt @5.5-5.13 (type "Num(_size)"))) + (type_decls + (nominal @1.1-6.2 (type "Foo") + (ty-header @1.1-1.4 (name "Foo"))) + (nominal @2.5-4.6 (type "Foo.Bar") + (ty-header @2.5-4.6 (name "Foo.Bar")))) + (expressions + (expr @3.15-3.16 (type "Num(_size)")) + (expr @5.12-5.13 (type "Num(_size)")))) +~~~ diff --git a/test/snapshots/nominal/nominal_associated_deep_nesting.md b/test/snapshots/nominal/nominal_associated_deep_nesting.md new file mode 100644 index 0000000000..35a4ddea94 --- /dev/null +++ b/test/snapshots/nominal/nominal_associated_deep_nesting.md @@ -0,0 +1,179 @@ +# META +~~~ini +description=Very deep nesting of associated items (4 levels) +type=file:Foo.roc +~~~ +# SOURCE +~~~roc +Foo := [Whatever].{ + Level1 := [A].{ + Level2 := [B].{ + Level3 := [C].{ + value = 42 + } + } + } +} + +deepValue : U64 +deepValue = Foo.Level1.Level2.Level3.value + +deepType : Foo.Level1.Level2.Level3 +deepType = C +~~~ +# EXPECTED +TYPE MISMATCH - nominal_associated_deep_nesting.md:15:12:15:13 +# PROBLEMS +**TYPE MISMATCH** +This expression is used in an unexpected way: +**nominal_associated_deep_nesting.md:15:12:15:13:** +```roc +deepType = C +``` + ^ + +It has the type: + _[C]_others_ + +But the type annotation says it should have the type: + _Foo.Level1.Level2.Level3_ + +# TOKENS +~~~zig +UpperIdent(1:1-1:4),OpColonEqual(1:5-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:17),CloseSquare(1:17-1:18),Dot(1:18-1:19),OpenCurly(1:19-1:20), +UpperIdent(2:5-2:11),OpColonEqual(2:12-2:14),OpenSquare(2:15-2:16),UpperIdent(2:16-2:17),CloseSquare(2:17-2:18),Dot(2:18-2:19),OpenCurly(2:19-2:20), +UpperIdent(3:9-3:15),OpColonEqual(3:16-3:18),OpenSquare(3:19-3:20),UpperIdent(3:20-3:21),CloseSquare(3:21-3:22),Dot(3:22-3:23),OpenCurly(3:23-3:24), +UpperIdent(4:13-4:19),OpColonEqual(4:20-4:22),OpenSquare(4:23-4:24),UpperIdent(4:24-4:25),CloseSquare(4:25-4:26),Dot(4:26-4:27),OpenCurly(4:27-4:28), +LowerIdent(5:17-5:22),OpAssign(5:23-5:24),Int(5:25-5:27), +CloseCurly(6:13-6:14), +CloseCurly(7:9-7:10), +CloseCurly(8:5-8:6), +CloseCurly(9:1-9:2), +LowerIdent(11:1-11:10),OpColon(11:11-11:12),UpperIdent(11:13-11:16), +LowerIdent(12:1-12:10),OpAssign(12:11-12:12),UpperIdent(12:13-12:16),NoSpaceDotUpperIdent(12:16-12:23),NoSpaceDotUpperIdent(12:23-12:30),NoSpaceDotUpperIdent(12:30-12:37),NoSpaceDotLowerIdent(12:37-12:43), +LowerIdent(14:1-14:9),OpColon(14:10-14:11),UpperIdent(14:12-14:15),NoSpaceDotUpperIdent(14:15-14:22),NoSpaceDotUpperIdent(14:22-14:29),NoSpaceDotUpperIdent(14:29-14:36), +LowerIdent(15:1-15:9),OpAssign(15:10-15:11),UpperIdent(15:12-15:13), +EndOfFile(16:1-16:1), +~~~ +# PARSE +~~~clojure +(file @1.1-15.13 + (type-module @1.1-1.4) + (statements + (s-type-decl @1.1-9.2 + (header @1.1-1.4 (name "Foo") + (args)) + (ty-tag-union @1.8-1.18 + (tags + (ty @1.9-1.17 (name "Whatever")))) + (associated @1.19-9.2 + (s-type-decl @2.5-8.6 + (header @2.5-2.11 (name "Level1") + (args)) + (ty-tag-union @2.15-2.18 + (tags + (ty @2.16-2.17 (name "A")))) + (associated @2.19-8.6 + (s-type-decl @3.9-7.10 + (header @3.9-3.15 (name "Level2") + (args)) + (ty-tag-union @3.19-3.22 + (tags + (ty @3.20-3.21 (name "B")))) + (associated @3.23-7.10 + (s-type-decl @4.13-6.14 + (header @4.13-4.19 (name "Level3") + (args)) + (ty-tag-union @4.23-4.26 + (tags + (ty @4.24-4.25 (name "C")))) + (associated @4.27-6.14 + (s-decl @5.17-5.27 + (p-ident @5.17-5.22 (raw "value")) + (e-int @5.25-5.27 (raw "42"))))))))))) + (s-type-anno @11.1-11.16 (name "deepValue") + (ty @11.13-11.16 (name "U64"))) + (s-decl @12.1-12.43 + (p-ident @12.1-12.10 (raw "deepValue")) + (e-ident @12.13-12.43 (raw "Foo.Level1.Level2.Level3.value"))) + (s-type-anno @14.1-14.36 (name "deepType") + (ty @14.12-14.36 (name "Foo.Level1.Level2.Level3"))) + (s-decl @15.1-15.13 + (p-ident @15.1-15.9 (raw "deepType")) + (e-tag @15.12-15.13 (raw "C"))))) +~~~ +# FORMATTED +~~~roc +Foo := [Whatever].{ + Level1 := [A].{ + Level2 := [B].{ + Level3 := [C].{ + value = 42 + } + } + } +} + +deepValue : U64 +deepValue = Foo.Level1.Level2.Level3.value + +deepType : Foo.Level1.Level2.Level3 +deepType = C +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @12.1-12.10 (ident "deepValue")) + (e-lookup-local @12.13-12.43 + (p-assign @5.17-5.27 (ident "Foo.Level1.Level2.Level3.value"))) + (annotation @12.1-12.10 + (declared-type + (ty-lookup @11.13-11.16 (name "U64") (builtin))))) + (d-let + (p-assign @15.1-15.9 (ident "deepType")) + (e-tag @15.12-15.13 (name "C")) + (annotation @15.1-15.9 + (declared-type + (ty-lookup @14.12-14.36 (name "Foo.Level1.Level2.Level3") (local))))) + (d-let + (p-assign @5.17-5.27 (ident "Foo.Level1.Level2.Level3.value")) + (e-num @5.25-5.27 (value "42"))) + (s-nominal-decl @1.1-9.2 + (ty-header @1.1-1.4 (name "Foo")) + (ty-tag-union @1.8-1.18 + (ty-tag-name @1.9-1.17 (name "Whatever")))) + (s-nominal-decl @2.5-8.6 + (ty-header @2.5-8.6 (name "Foo.Level1")) + (ty-tag-union @2.15-2.18 + (ty-tag-name @2.16-2.17 (name "A")))) + (s-nominal-decl @3.9-7.10 + (ty-header @3.9-7.10 (name "Foo.Level1.Level2")) + (ty-tag-union @3.19-3.22 + (ty-tag-name @3.20-3.21 (name "B")))) + (s-nominal-decl @4.13-6.14 + (ty-header @4.13-6.14 (name "Foo.Level1.Level2.Level3")) + (ty-tag-union @4.23-4.26 + (ty-tag-name @4.24-4.25 (name "C"))))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @12.1-12.10 (type "Num(_size)")) + (patt @15.1-15.9 (type "Error")) + (patt @5.17-5.27 (type "Num(_size)"))) + (type_decls + (nominal @1.1-9.2 (type "Foo") + (ty-header @1.1-1.4 (name "Foo"))) + (nominal @2.5-8.6 (type "Foo.Level1") + (ty-header @2.5-8.6 (name "Foo.Level1"))) + (nominal @3.9-7.10 (type "Foo.Level1.Level2") + (ty-header @3.9-7.10 (name "Foo.Level1.Level2"))) + (nominal @4.13-6.14 (type "Foo.Level1.Level2.Level3") + (ty-header @4.13-6.14 (name "Foo.Level1.Level2.Level3")))) + (expressions + (expr @12.13-12.43 (type "Num(_size)")) + (expr @15.12-15.13 (type "Error")) + (expr @5.25-5.27 (type "Num(_size)")))) +~~~ diff --git a/test/snapshots/nominal/nominal_associated_doc_comments.md b/test/snapshots/nominal/nominal_associated_doc_comments.md new file mode 100644 index 0000000000..b1c3db8ab2 --- /dev/null +++ b/test/snapshots/nominal/nominal_associated_doc_comments.md @@ -0,0 +1,92 @@ +# META +~~~ini +description=Doc comments on nested types and associated items +type=file:Foo.roc +~~~ +# SOURCE +~~~roc +## Top-level type documentation +Foo := [Whatever].{ + ## Nested type documentation + Bar := [X, Y, Z] + + ## Associated value documentation + defaultBar = Foo.Bar.X +} +~~~ +# EXPECTED +NIL +# PROBLEMS +NIL +# TOKENS +~~~zig +UpperIdent(2:1-2:4),OpColonEqual(2:5-2:7),OpenSquare(2:8-2:9),UpperIdent(2:9-2:17),CloseSquare(2:17-2:18),Dot(2:18-2:19),OpenCurly(2:19-2:20), +UpperIdent(4:5-4:8),OpColonEqual(4:9-4:11),OpenSquare(4:12-4:13),UpperIdent(4:13-4:14),Comma(4:14-4:15),UpperIdent(4:16-4:17),Comma(4:17-4:18),UpperIdent(4:19-4:20),CloseSquare(4:20-4:21), +LowerIdent(7:5-7:15),OpAssign(7:16-7:17),UpperIdent(7:18-7:21),NoSpaceDotUpperIdent(7:21-7:25),NoSpaceDotUpperIdent(7:25-7:27), +CloseCurly(8:1-8:2), +EndOfFile(9:1-9:1), +~~~ +# PARSE +~~~clojure +(file @2.1-8.2 + (type-module @2.1-2.4) + (statements + (s-type-decl @2.1-8.2 + (header @2.1-2.4 (name "Foo") + (args)) + (ty-tag-union @2.8-2.18 + (tags + (ty @2.9-2.17 (name "Whatever")))) + (associated @2.19-8.2 + (s-type-decl @4.5-4.21 + (header @4.5-4.8 (name "Bar") + (args)) + (ty-tag-union @4.12-4.21 + (tags + (ty @4.13-4.14 (name "X")) + (ty @4.16-4.17 (name "Y")) + (ty @4.19-4.20 (name "Z"))))) + (s-decl @7.5-7.27 + (p-ident @7.5-7.15 (raw "defaultBar")) + (e-tag @7.18-7.27 (raw "Foo.Bar.X"))))))) +~~~ +# FORMATTED +~~~roc +# # Top-level type documentation +# # Top-level type documentation +Foo := [Whatever].{ + Bar := [X, Y, Z] + defaultBar = Foo.Bar.X +} +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @7.5-7.27 (ident "Foo.defaultBar")) + (e-nominal @7.18-7.27 (nominal "Foo.Bar") + (e-tag @7.18-7.27 (name "X")))) + (s-nominal-decl @2.1-8.2 + (ty-header @2.1-2.4 (name "Foo")) + (ty-tag-union @2.8-2.18 + (ty-tag-name @2.9-2.17 (name "Whatever")))) + (s-nominal-decl @4.5-4.21 + (ty-header @4.5-4.21 (name "Foo.Bar")) + (ty-tag-union @4.12-4.21 + (ty-tag-name @4.13-4.14 (name "X")) + (ty-tag-name @4.16-4.17 (name "Y")) + (ty-tag-name @4.19-4.20 (name "Z"))))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @7.5-7.27 (type "Foo.Bar"))) + (type_decls + (nominal @2.1-8.2 (type "Foo") + (ty-header @2.1-2.4 (name "Foo"))) + (nominal @4.5-4.21 (type "Foo.Bar") + (ty-header @4.5-4.21 (name "Foo.Bar")))) + (expressions + (expr @7.18-7.27 (type "Foo.Bar")))) +~~~ diff --git a/test/snapshots/nominal/nominal_associated_in_patterns.md b/test/snapshots/nominal/nominal_associated_in_patterns.md new file mode 100644 index 0000000000..6b64e1deae --- /dev/null +++ b/test/snapshots/nominal/nominal_associated_in_patterns.md @@ -0,0 +1,122 @@ +# META +~~~ini +description=Using qualified types in pattern matching and function parameters +type=file:Foo.roc +~~~ +# SOURCE +~~~roc +Foo := [Whatever].{ + Result := [Success(U64), Failure(Str)] +} + +handleSuccess : Foo.Result -> Str +handleSuccess = |res| "success" +~~~ +# EXPECTED +UNUSED VARIABLE - nominal_associated_in_patterns.md:6:18:6:21 +# PROBLEMS +**UNUSED VARIABLE** +Variable `res` is not used anywhere in your code. + +If you don't need this variable, prefix it with an underscore like `_res` to suppress this warning. +The unused variable is declared here: +**nominal_associated_in_patterns.md:6:18:6:21:** +```roc +handleSuccess = |res| "success" +``` + ^^^ + + +# TOKENS +~~~zig +UpperIdent(1:1-1:4),OpColonEqual(1:5-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:17),CloseSquare(1:17-1:18),Dot(1:18-1:19),OpenCurly(1:19-1:20), +UpperIdent(2:5-2:11),OpColonEqual(2:12-2:14),OpenSquare(2:15-2:16),UpperIdent(2:16-2:23),NoSpaceOpenRound(2:23-2:24),UpperIdent(2:24-2:27),CloseRound(2:27-2:28),Comma(2:28-2:29),UpperIdent(2:30-2:37),NoSpaceOpenRound(2:37-2:38),UpperIdent(2:38-2:41),CloseRound(2:41-2:42),CloseSquare(2:42-2:43), +CloseCurly(3:1-3:2), +LowerIdent(5:1-5:14),OpColon(5:15-5:16),UpperIdent(5:17-5:20),NoSpaceDotUpperIdent(5:20-5:27),OpArrow(5:28-5:30),UpperIdent(5:31-5:34), +LowerIdent(6:1-6:14),OpAssign(6:15-6:16),OpBar(6:17-6:18),LowerIdent(6:18-6:21),OpBar(6:21-6:22),StringStart(6:23-6:24),StringPart(6:24-6:31),StringEnd(6:31-6:32), +EndOfFile(7:1-7:1), +~~~ +# PARSE +~~~clojure +(file @1.1-6.32 + (type-module @1.1-1.4) + (statements + (s-type-decl @1.1-3.2 + (header @1.1-1.4 (name "Foo") + (args)) + (ty-tag-union @1.8-1.18 + (tags + (ty @1.9-1.17 (name "Whatever")))) + (associated @1.19-3.2 + (s-type-decl @2.5-2.43 + (header @2.5-2.11 (name "Result") + (args)) + (ty-tag-union @2.15-2.43 + (tags + (ty-apply @2.16-2.28 + (ty @2.16-2.23 (name "Success")) + (ty @2.24-2.27 (name "U64"))) + (ty-apply @2.30-2.42 + (ty @2.30-2.37 (name "Failure")) + (ty @2.38-2.41 (name "Str")))))))) + (s-type-anno @5.1-5.34 (name "handleSuccess") + (ty-fn @5.17-5.34 + (ty @5.17-5.27 (name "Foo.Result")) + (ty @5.31-5.34 (name "Str")))) + (s-decl @6.1-6.32 + (p-ident @6.1-6.14 (raw "handleSuccess")) + (e-lambda @6.17-6.32 + (args + (p-ident @6.18-6.21 (raw "res"))) + (e-string @6.23-6.32 + (e-string-part @6.24-6.31 (raw "success"))))))) +~~~ +# FORMATTED +~~~roc +Foo := [Whatever].{ + Result := [Success(U64), Failure(Str)] +} + +handleSuccess : Foo.Result -> Str +handleSuccess = |res| "success" +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @6.1-6.14 (ident "handleSuccess")) + (e-lambda @6.17-6.32 + (args + (p-assign @6.18-6.21 (ident "res"))) + (e-string @6.23-6.32 + (e-literal @6.24-6.31 (string "success")))) + (annotation @6.1-6.14 + (declared-type + (ty-fn @5.17-5.34 (effectful false) + (ty-lookup @5.17-5.27 (name "Foo.Result") (local)) + (ty-lookup @5.31-5.34 (name "Str") (builtin)))))) + (s-nominal-decl @1.1-3.2 + (ty-header @1.1-1.4 (name "Foo")) + (ty-tag-union @1.8-1.18 + (ty-tag-name @1.9-1.17 (name "Whatever")))) + (s-nominal-decl @2.5-2.43 + (ty-header @2.5-2.43 (name "Foo.Result")) + (ty-tag-union @2.15-2.43 + (ty-tag-name @2.16-2.28 (name "Success") + (ty-lookup @2.24-2.27 (name "U64") (builtin))) + (ty-tag-name @2.30-2.42 (name "Failure") + (ty-lookup @2.38-2.41 (name "Str") (builtin)))))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @6.1-6.14 (type "Foo.Result -> Str"))) + (type_decls + (nominal @1.1-3.2 (type "Foo") + (ty-header @1.1-1.4 (name "Foo"))) + (nominal @2.5-2.43 (type "Foo.Result") + (ty-header @2.5-2.43 (name "Foo.Result")))) + (expressions + (expr @6.17-6.32 (type "Foo.Result -> Str")))) +~~~ diff --git a/test/snapshots/nominal/nominal_associated_in_tuples.md b/test/snapshots/nominal/nominal_associated_in_tuples.md new file mode 100644 index 0000000000..d0161fcfc5 --- /dev/null +++ b/test/snapshots/nominal/nominal_associated_in_tuples.md @@ -0,0 +1,221 @@ +# META +~~~ini +description=Qualified types in tuples and as type arguments +type=file:Foo.roc +~~~ +# SOURCE +~~~roc +Foo := [Whatever].{ + Bar := [X, Y] + Baz := [Z] +} + +pair : (Foo.Bar, Foo.Baz) +pair = (X, Z) + +Box : a -> [Box(a)] + +boxed : Box(Foo.Bar) +boxed = Box(X) +~~~ +# EXPECTED +UNDECLARED TYPE VARIABLE - nominal_associated_in_tuples.md:9:7:9:8 +UNDECLARED TYPE VARIABLE - nominal_associated_in_tuples.md:9:17:9:18 +TYPE MISMATCH - nominal_associated_in_tuples.md:7:8:7:14 +TOO MANY ARGS - nominal_associated_in_tuples.md:11:9:11:21 +# PROBLEMS +**UNDECLARED TYPE VARIABLE** +The type variable _a_ is not declared in this scope. + +Type variables must be introduced in a type annotation before they can be used. + +This type variable is referenced here: +**nominal_associated_in_tuples.md:9:7:9:8:** +```roc +Box : a -> [Box(a)] +``` + ^ + + +**UNDECLARED TYPE VARIABLE** +The type variable _a_ is not declared in this scope. + +Type variables must be introduced in a type annotation before they can be used. + +This type variable is referenced here: +**nominal_associated_in_tuples.md:9:17:9:18:** +```roc +Box : a -> [Box(a)] +``` + ^ + + +**TYPE MISMATCH** +This expression is used in an unexpected way: +**nominal_associated_in_tuples.md:7:8:7:14:** +```roc +pair = (X, Z) +``` + ^^^^^^ + +It has the type: + _([X]_others, [Z]_others2)_ + +But the type annotation says it should have the type: + _(Foo.Bar, Foo.Baz)_ + +**TOO MANY ARGS** +The type _Box_ expects argument, but got instead. +**nominal_associated_in_tuples.md:11:9:11:21:** +```roc +boxed : Box(Foo.Bar) +``` + ^^^^^^^^^^^^ + + + +# TOKENS +~~~zig +UpperIdent(1:1-1:4),OpColonEqual(1:5-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:17),CloseSquare(1:17-1:18),Dot(1:18-1:19),OpenCurly(1:19-1:20), +UpperIdent(2:5-2:8),OpColonEqual(2:9-2:11),OpenSquare(2:12-2:13),UpperIdent(2:13-2:14),Comma(2:14-2:15),UpperIdent(2:16-2:17),CloseSquare(2:17-2:18), +UpperIdent(3:5-3:8),OpColonEqual(3:9-3:11),OpenSquare(3:12-3:13),UpperIdent(3:13-3:14),CloseSquare(3:14-3:15), +CloseCurly(4:1-4:2), +LowerIdent(6:1-6:5),OpColon(6:6-6:7),OpenRound(6:8-6:9),UpperIdent(6:9-6:12),NoSpaceDotUpperIdent(6:12-6:16),Comma(6:16-6:17),UpperIdent(6:18-6:21),NoSpaceDotUpperIdent(6:21-6:25),CloseRound(6:25-6:26), +LowerIdent(7:1-7:5),OpAssign(7:6-7:7),OpenRound(7:8-7:9),UpperIdent(7:9-7:10),Comma(7:10-7:11),UpperIdent(7:12-7:13),CloseRound(7:13-7:14), +UpperIdent(9:1-9:4),OpColon(9:5-9:6),LowerIdent(9:7-9:8),OpArrow(9:9-9:11),OpenSquare(9:12-9:13),UpperIdent(9:13-9:16),NoSpaceOpenRound(9:16-9:17),LowerIdent(9:17-9:18),CloseRound(9:18-9:19),CloseSquare(9:19-9:20), +LowerIdent(11:1-11:6),OpColon(11:7-11:8),UpperIdent(11:9-11:12),NoSpaceOpenRound(11:12-11:13),UpperIdent(11:13-11:16),NoSpaceDotUpperIdent(11:16-11:20),CloseRound(11:20-11:21), +LowerIdent(12:1-12:6),OpAssign(12:7-12:8),UpperIdent(12:9-12:12),NoSpaceOpenRound(12:12-12:13),UpperIdent(12:13-12:14),CloseRound(12:14-12:15), +EndOfFile(13:1-13:1), +~~~ +# PARSE +~~~clojure +(file @1.1-12.15 + (type-module @1.1-1.4) + (statements + (s-type-decl @1.1-4.2 + (header @1.1-1.4 (name "Foo") + (args)) + (ty-tag-union @1.8-1.18 + (tags + (ty @1.9-1.17 (name "Whatever")))) + (associated @1.19-4.2 + (s-type-decl @2.5-2.18 + (header @2.5-2.8 (name "Bar") + (args)) + (ty-tag-union @2.12-2.18 + (tags + (ty @2.13-2.14 (name "X")) + (ty @2.16-2.17 (name "Y"))))) + (s-type-decl @3.5-3.15 + (header @3.5-3.8 (name "Baz") + (args)) + (ty-tag-union @3.12-3.15 + (tags + (ty @3.13-3.14 (name "Z"))))))) + (s-type-anno @6.1-6.26 (name "pair") + (ty-tuple @6.8-6.26 + (ty @6.9-6.16 (name "Foo.Bar")) + (ty @6.18-6.25 (name "Foo.Baz")))) + (s-decl @7.1-7.14 + (p-ident @7.1-7.5 (raw "pair")) + (e-tuple @7.8-7.14 + (e-tag @7.9-7.10 (raw "X")) + (e-tag @7.12-7.13 (raw "Z")))) + (s-type-decl @9.1-9.20 + (header @9.1-9.4 (name "Box") + (args)) + (ty-fn @9.7-9.20 + (ty-var @9.7-9.8 (raw "a")) + (ty-tag-union @9.12-9.20 + (tags + (ty-apply @9.13-9.19 + (ty @9.13-9.16 (name "Box")) + (ty-var @9.17-9.18 (raw "a"))))))) + (s-type-anno @11.1-11.21 (name "boxed") + (ty-apply @11.9-11.21 + (ty @11.9-11.12 (name "Box")) + (ty @11.13-11.20 (name "Foo.Bar")))) + (s-decl @12.1-12.15 + (p-ident @12.1-12.6 (raw "boxed")) + (e-apply @12.9-12.15 + (e-tag @12.9-12.12 (raw "Box")) + (e-tag @12.13-12.14 (raw "X")))))) +~~~ +# FORMATTED +~~~roc +Foo := [Whatever].{ + Bar := [X, Y] + Baz := [Z] +} + +pair : (Foo.Bar, Foo.Baz) +pair = (X, Z) + +Box : a -> [Box(a)] + +boxed : Box(Foo.Bar) +boxed = Box(X) +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @7.1-7.5 (ident "pair")) + (e-tuple @7.8-7.14 + (elems + (e-tag @7.9-7.10 (name "X")) + (e-tag @7.12-7.13 (name "Z")))) + (annotation @7.1-7.5 + (declared-type + (ty-tuple @6.8-6.26 + (ty-lookup @6.9-6.16 (name "Foo.Bar") (local)) + (ty-lookup @6.18-6.25 (name "Foo.Baz") (local)))))) + (d-let + (p-assign @12.1-12.6 (ident "boxed")) + (e-tag @12.9-12.15 (name "Box") + (args + (e-tag @12.13-12.14 (name "X")))) + (annotation @12.1-12.6 + (declared-type + (ty-apply @11.9-11.21 (name "Box") (local) + (ty-lookup @11.13-11.20 (name "Foo.Bar") (local)))))) + (s-nominal-decl @1.1-4.2 + (ty-header @1.1-1.4 (name "Foo")) + (ty-tag-union @1.8-1.18 + (ty-tag-name @1.9-1.17 (name "Whatever")))) + (s-nominal-decl @2.5-2.18 + (ty-header @2.5-2.18 (name "Foo.Bar")) + (ty-tag-union @2.12-2.18 + (ty-tag-name @2.13-2.14 (name "X")) + (ty-tag-name @2.16-2.17 (name "Y")))) + (s-nominal-decl @3.5-3.15 + (ty-header @3.5-3.15 (name "Foo.Baz")) + (ty-tag-union @3.12-3.15 + (ty-tag-name @3.13-3.14 (name "Z")))) + (s-alias-decl @9.1-9.20 + (ty-header @9.1-9.4 (name "Box")) + (ty-fn @9.7-9.20 (effectful false) + (ty-malformed @9.7-9.8) + (ty-tag-union @9.12-9.20 + (ty-tag-name @9.13-9.19 (name "Box") + (ty-malformed @9.17-9.18)))))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @7.1-7.5 (type "Error")) + (patt @12.1-12.6 (type "Error"))) + (type_decls + (nominal @1.1-4.2 (type "Foo") + (ty-header @1.1-1.4 (name "Foo"))) + (nominal @2.5-2.18 (type "Foo.Bar") + (ty-header @2.5-2.18 (name "Foo.Bar"))) + (nominal @3.5-3.15 (type "Foo.Baz") + (ty-header @3.5-3.15 (name "Foo.Baz"))) + (alias @9.1-9.20 (type "Box") + (ty-header @9.1-9.4 (name "Box")))) + (expressions + (expr @7.8-7.14 (type "Error")) + (expr @12.9-12.15 (type "Error")))) +~~~ diff --git a/test/snapshots/nominal/nominal_associated_lookup_decl.md b/test/snapshots/nominal/nominal_associated_lookup_decl.md new file mode 100644 index 0000000000..805c9dd273 --- /dev/null +++ b/test/snapshots/nominal/nominal_associated_lookup_decl.md @@ -0,0 +1,88 @@ +# META +~~~ini +description=Referencing declaration from associated block +type=file:Foo.roc +~~~ +# SOURCE +~~~roc +Foo := [Whatever].{ + bar = 42 +} + +useBar : U64 +useBar = Foo.bar +~~~ +# EXPECTED +NIL +# PROBLEMS +NIL +# TOKENS +~~~zig +UpperIdent(1:1-1:4),OpColonEqual(1:5-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:17),CloseSquare(1:17-1:18),Dot(1:18-1:19),OpenCurly(1:19-1:20), +LowerIdent(2:5-2:8),OpAssign(2:9-2:10),Int(2:11-2:13), +CloseCurly(3:1-3:2), +LowerIdent(5:1-5:7),OpColon(5:8-5:9),UpperIdent(5:10-5:13), +LowerIdent(6:1-6:7),OpAssign(6:8-6:9),UpperIdent(6:10-6:13),NoSpaceDotLowerIdent(6:13-6:17), +EndOfFile(7:1-7:1), +~~~ +# PARSE +~~~clojure +(file @1.1-6.17 + (type-module @1.1-1.4) + (statements + (s-type-decl @1.1-3.2 + (header @1.1-1.4 (name "Foo") + (args)) + (ty-tag-union @1.8-1.18 + (tags + (ty @1.9-1.17 (name "Whatever")))) + (associated @1.19-3.2 + (s-decl @2.5-2.13 + (p-ident @2.5-2.8 (raw "bar")) + (e-int @2.11-2.13 (raw "42"))))) + (s-type-anno @5.1-5.13 (name "useBar") + (ty @5.10-5.13 (name "U64"))) + (s-decl @6.1-6.17 + (p-ident @6.1-6.7 (raw "useBar")) + (e-ident @6.10-6.17 (raw "Foo.bar"))))) +~~~ +# FORMATTED +~~~roc +Foo := [Whatever].{ + bar = 42 +} + +useBar : U64 +useBar = Foo.bar +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @6.1-6.7 (ident "useBar")) + (e-lookup-local @6.10-6.17 + (p-assign @2.5-2.13 (ident "Foo.bar"))) + (annotation @6.1-6.7 + (declared-type + (ty-lookup @5.10-5.13 (name "U64") (builtin))))) + (d-let + (p-assign @2.5-2.13 (ident "Foo.bar")) + (e-num @2.11-2.13 (value "42"))) + (s-nominal-decl @1.1-3.2 + (ty-header @1.1-1.4 (name "Foo")) + (ty-tag-union @1.8-1.18 + (ty-tag-name @1.9-1.17 (name "Whatever"))))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @6.1-6.7 (type "Num(_size)")) + (patt @2.5-2.13 (type "Num(_size)"))) + (type_decls + (nominal @1.1-3.2 (type "Foo") + (ty-header @1.1-1.4 (name "Foo")))) + (expressions + (expr @6.10-6.17 (type "Num(_size)")) + (expr @2.11-2.13 (type "Num(_size)")))) +~~~ diff --git a/test/snapshots/nominal/nominal_associated_lookup_in_containers.md b/test/snapshots/nominal/nominal_associated_lookup_in_containers.md new file mode 100644 index 0000000000..3e0dd06506 --- /dev/null +++ b/test/snapshots/nominal/nominal_associated_lookup_in_containers.md @@ -0,0 +1,236 @@ +# META +~~~ini +description=Qualified types in type applications (List, Result, etc.) +type=file:Foo.roc +~~~ +# SOURCE +~~~roc +Foo := [Whatever].{ + Bar := [A, B, C] + Error := [Oops, Yikes] +} + +items : List(Foo.Bar) +items = [A, B, C] + +result : Result(Foo.Bar, Foo.Error) +result = Ok(A) + +nested : { bar : Foo.Bar, count : U64 } +nested = { bar: A, count: 1 } +~~~ +# EXPECTED +TYPE MISMATCH - nominal_associated_lookup_in_containers.md:7:9:7:18 +TYPE MISMATCH - nominal_associated_lookup_in_containers.md:10:10:10:15 +TYPE MISMATCH - nominal_associated_lookup_in_containers.md:13:10:13:30 +# PROBLEMS +**TYPE MISMATCH** +This expression is used in an unexpected way: +**nominal_associated_lookup_in_containers.md:7:9:7:18:** +```roc +items = [A, B, C] +``` + ^^^^^^^^^ + +It has the type: + _List([A, B, C]_others)_ + +But the type annotation says it should have the type: + _List(Foo.Bar)_ + +**TYPE MISMATCH** +This expression is used in an unexpected way: +**nominal_associated_lookup_in_containers.md:10:10:10:15:** +```roc +result = Ok(A) +``` + ^^^^^ + +It has the type: + _Result([A]_others, err)_ + +But the type annotation says it should have the type: + _Result(Foo.Bar, Foo.Error)_ + +**TYPE MISMATCH** +This expression is used in an unexpected way: +**nominal_associated_lookup_in_containers.md:13:10:13:30:** +```roc +nested = { bar: A, count: 1 } +``` + ^^^^^^^^^^^^^^^^^^^^ + +It has the type: + _{ bar: [A]_others, count: Num(_size) }_ + +But the type annotation says it should have the type: + _{ bar: Foo.Bar, count: Num(Int(Unsigned64)) }_ + +**Hint:** This might be because the numeric literal is either negative or too large to fit in the unsigned type. + +# TOKENS +~~~zig +UpperIdent(1:1-1:4),OpColonEqual(1:5-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:17),CloseSquare(1:17-1:18),Dot(1:18-1:19),OpenCurly(1:19-1:20), +UpperIdent(2:5-2:8),OpColonEqual(2:9-2:11),OpenSquare(2:12-2:13),UpperIdent(2:13-2:14),Comma(2:14-2:15),UpperIdent(2:16-2:17),Comma(2:17-2:18),UpperIdent(2:19-2:20),CloseSquare(2:20-2:21), +UpperIdent(3:5-3:10),OpColonEqual(3:11-3:13),OpenSquare(3:14-3:15),UpperIdent(3:15-3:19),Comma(3:19-3:20),UpperIdent(3:21-3:26),CloseSquare(3:26-3:27), +CloseCurly(4:1-4:2), +LowerIdent(6:1-6:6),OpColon(6:7-6:8),UpperIdent(6:9-6:13),NoSpaceOpenRound(6:13-6:14),UpperIdent(6:14-6:17),NoSpaceDotUpperIdent(6:17-6:21),CloseRound(6:21-6:22), +LowerIdent(7:1-7:6),OpAssign(7:7-7:8),OpenSquare(7:9-7:10),UpperIdent(7:10-7:11),Comma(7:11-7:12),UpperIdent(7:13-7:14),Comma(7:14-7:15),UpperIdent(7:16-7:17),CloseSquare(7:17-7:18), +LowerIdent(9:1-9:7),OpColon(9:8-9:9),UpperIdent(9:10-9:16),NoSpaceOpenRound(9:16-9:17),UpperIdent(9:17-9:20),NoSpaceDotUpperIdent(9:20-9:24),Comma(9:24-9:25),UpperIdent(9:26-9:29),NoSpaceDotUpperIdent(9:29-9:35),CloseRound(9:35-9:36), +LowerIdent(10:1-10:7),OpAssign(10:8-10:9),UpperIdent(10:10-10:12),NoSpaceOpenRound(10:12-10:13),UpperIdent(10:13-10:14),CloseRound(10:14-10:15), +LowerIdent(12:1-12:7),OpColon(12:8-12:9),OpenCurly(12:10-12:11),LowerIdent(12:12-12:15),OpColon(12:16-12:17),UpperIdent(12:18-12:21),NoSpaceDotUpperIdent(12:21-12:25),Comma(12:25-12:26),LowerIdent(12:27-12:32),OpColon(12:33-12:34),UpperIdent(12:35-12:38),CloseCurly(12:39-12:40), +LowerIdent(13:1-13:7),OpAssign(13:8-13:9),OpenCurly(13:10-13:11),LowerIdent(13:12-13:15),OpColon(13:15-13:16),UpperIdent(13:17-13:18),Comma(13:18-13:19),LowerIdent(13:20-13:25),OpColon(13:25-13:26),Int(13:27-13:28),CloseCurly(13:29-13:30), +EndOfFile(14:1-14:1), +~~~ +# PARSE +~~~clojure +(file @1.1-13.30 + (type-module @1.1-1.4) + (statements + (s-type-decl @1.1-4.2 + (header @1.1-1.4 (name "Foo") + (args)) + (ty-tag-union @1.8-1.18 + (tags + (ty @1.9-1.17 (name "Whatever")))) + (associated @1.19-4.2 + (s-type-decl @2.5-2.21 + (header @2.5-2.8 (name "Bar") + (args)) + (ty-tag-union @2.12-2.21 + (tags + (ty @2.13-2.14 (name "A")) + (ty @2.16-2.17 (name "B")) + (ty @2.19-2.20 (name "C"))))) + (s-type-decl @3.5-3.27 + (header @3.5-3.10 (name "Error") + (args)) + (ty-tag-union @3.14-3.27 + (tags + (ty @3.15-3.19 (name "Oops")) + (ty @3.21-3.26 (name "Yikes"))))))) + (s-type-anno @6.1-6.22 (name "items") + (ty-apply @6.9-6.22 + (ty @6.9-6.13 (name "List")) + (ty @6.14-6.21 (name "Foo.Bar")))) + (s-decl @7.1-7.18 + (p-ident @7.1-7.6 (raw "items")) + (e-list @7.9-7.18 + (e-tag @7.10-7.11 (raw "A")) + (e-tag @7.13-7.14 (raw "B")) + (e-tag @7.16-7.17 (raw "C")))) + (s-type-anno @9.1-9.36 (name "result") + (ty-apply @9.10-9.36 + (ty @9.10-9.16 (name "Result")) + (ty @9.17-9.24 (name "Foo.Bar")) + (ty @9.26-9.35 (name "Foo.Error")))) + (s-decl @10.1-10.15 + (p-ident @10.1-10.7 (raw "result")) + (e-apply @10.10-10.15 + (e-tag @10.10-10.12 (raw "Ok")) + (e-tag @10.13-10.14 (raw "A")))) + (s-type-anno @12.1-12.40 (name "nested") + (ty-record @12.10-12.40 + (anno-record-field @12.12-12.25 (name "bar") + (ty @12.18-12.25 (name "Foo.Bar"))) + (anno-record-field @12.27-12.38 (name "count") + (ty @12.35-12.38 (name "U64"))))) + (s-decl @13.1-13.30 + (p-ident @13.1-13.7 (raw "nested")) + (e-record @13.10-13.30 + (field (field "bar") + (e-tag @13.17-13.18 (raw "A"))) + (field (field "count") + (e-int @13.27-13.28 (raw "1"))))))) +~~~ +# FORMATTED +~~~roc +Foo := [Whatever].{ + Bar := [A, B, C] + Error := [Oops, Yikes] +} + +items : List(Foo.Bar) +items = [A, B, C] + +result : Result(Foo.Bar, Foo.Error) +result = Ok(A) + +nested : { bar : Foo.Bar, count : U64 } +nested = { bar: A, count: 1 } +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @7.1-7.6 (ident "items")) + (e-list @7.9-7.18 + (elems + (e-tag @7.10-7.11 (name "A")) + (e-tag @7.13-7.14 (name "B")) + (e-tag @7.16-7.17 (name "C")))) + (annotation @7.1-7.6 + (declared-type + (ty-apply @6.9-6.22 (name "List") (builtin) + (ty-lookup @6.14-6.21 (name "Foo.Bar") (local)))))) + (d-let + (p-assign @10.1-10.7 (ident "result")) + (e-nominal @10.10-10.15 (nominal "Result") + (e-tag @10.10-10.15 (name "Ok") + (args + (e-tag @10.13-10.14 (name "A"))))) + (annotation @10.1-10.7 + (declared-type + (ty-apply @9.10-9.36 (name "Result") (local) + (ty-lookup @9.10-9.36 (name "Foo.Bar") (local)) + (ty-lookup @9.10-9.36 (name "Foo.Error") (local)))))) + (d-let + (p-assign @13.1-13.7 (ident "nested")) + (e-record @13.10-13.30 + (fields + (field (name "bar") + (e-tag @13.17-13.18 (name "A"))) + (field (name "count") + (e-num @13.27-13.28 (value "1"))))) + (annotation @13.1-13.7 + (declared-type + (ty-record @12.10-12.40 + (field (field "bar") + (ty-lookup @12.18-12.25 (name "Foo.Bar") (local))) + (field (field "count") + (ty-lookup @12.35-12.38 (name "U64") (builtin))))))) + (s-nominal-decl @1.1-4.2 + (ty-header @1.1-1.4 (name "Foo")) + (ty-tag-union @1.8-1.18 + (ty-tag-name @1.9-1.17 (name "Whatever")))) + (s-nominal-decl @2.5-2.21 + (ty-header @2.5-2.21 (name "Foo.Bar")) + (ty-tag-union @2.12-2.21 + (ty-tag-name @2.13-2.14 (name "A")) + (ty-tag-name @2.16-2.17 (name "B")) + (ty-tag-name @2.19-2.20 (name "C")))) + (s-nominal-decl @3.5-3.27 + (ty-header @3.5-3.27 (name "Foo.Error")) + (ty-tag-union @3.14-3.27 + (ty-tag-name @3.15-3.19 (name "Oops")) + (ty-tag-name @3.21-3.26 (name "Yikes"))))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @7.1-7.6 (type "Error")) + (patt @10.1-10.7 (type "Error")) + (patt @13.1-13.7 (type "Error"))) + (type_decls + (nominal @1.1-4.2 (type "Foo") + (ty-header @1.1-1.4 (name "Foo"))) + (nominal @2.5-2.21 (type "Foo.Bar") + (ty-header @2.5-2.21 (name "Foo.Bar"))) + (nominal @3.5-3.27 (type "Foo.Error") + (ty-header @3.5-3.27 (name "Foo.Error")))) + (expressions + (expr @7.9-7.18 (type "Error")) + (expr @10.10-10.15 (type "Error")) + (expr @13.10-13.30 (type "Error")))) +~~~ diff --git a/test/snapshots/nominal/nominal_associated_lookup_mixed.md b/test/snapshots/nominal/nominal_associated_lookup_mixed.md new file mode 100644 index 0000000000..a60df11f7a --- /dev/null +++ b/test/snapshots/nominal/nominal_associated_lookup_mixed.md @@ -0,0 +1,145 @@ +# META +~~~ini +description=Mixed usage of types and declarations from associated blocks +type=file:Foo.roc +~~~ +# SOURCE +~~~roc +Foo := [Whatever].{ + Bar := [A, B, C] + + defaultBar = Bar.A + + transform : Foo.Bar -> Foo.Bar + transform = |x| x +} + +result : Foo.Bar +result = Foo.transform(Foo.defaultBar) +~~~ +# EXPECTED +NIL +# PROBLEMS +NIL +# TOKENS +~~~zig +UpperIdent(1:1-1:4),OpColonEqual(1:5-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:17),CloseSquare(1:17-1:18),Dot(1:18-1:19),OpenCurly(1:19-1:20), +UpperIdent(2:5-2:8),OpColonEqual(2:9-2:11),OpenSquare(2:12-2:13),UpperIdent(2:13-2:14),Comma(2:14-2:15),UpperIdent(2:16-2:17),Comma(2:17-2:18),UpperIdent(2:19-2:20),CloseSquare(2:20-2:21), +LowerIdent(4:5-4:15),OpAssign(4:16-4:17),UpperIdent(4:18-4:21),NoSpaceDotUpperIdent(4:21-4:23), +LowerIdent(6:5-6:14),OpColon(6:15-6:16),UpperIdent(6:17-6:20),NoSpaceDotUpperIdent(6:20-6:24),OpArrow(6:25-6:27),UpperIdent(6:28-6:31),NoSpaceDotUpperIdent(6:31-6:35), +LowerIdent(7:5-7:14),OpAssign(7:15-7:16),OpBar(7:17-7:18),LowerIdent(7:18-7:19),OpBar(7:19-7:20),LowerIdent(7:21-7:22), +CloseCurly(8:1-8:2), +LowerIdent(10:1-10:7),OpColon(10:8-10:9),UpperIdent(10:10-10:13),NoSpaceDotUpperIdent(10:13-10:17), +LowerIdent(11:1-11:7),OpAssign(11:8-11:9),UpperIdent(11:10-11:13),NoSpaceDotLowerIdent(11:13-11:23),NoSpaceOpenRound(11:23-11:24),UpperIdent(11:24-11:27),NoSpaceDotLowerIdent(11:27-11:38),CloseRound(11:38-11:39), +EndOfFile(12:1-12:1), +~~~ +# PARSE +~~~clojure +(file @1.1-11.39 + (type-module @1.1-1.4) + (statements + (s-type-decl @1.1-8.2 + (header @1.1-1.4 (name "Foo") + (args)) + (ty-tag-union @1.8-1.18 + (tags + (ty @1.9-1.17 (name "Whatever")))) + (associated @1.19-8.2 + (s-type-decl @2.5-2.21 + (header @2.5-2.8 (name "Bar") + (args)) + (ty-tag-union @2.12-2.21 + (tags + (ty @2.13-2.14 (name "A")) + (ty @2.16-2.17 (name "B")) + (ty @2.19-2.20 (name "C"))))) + (s-decl @4.5-4.23 + (p-ident @4.5-4.15 (raw "defaultBar")) + (e-tag @4.18-4.23 (raw "Bar.A"))) + (s-type-anno @6.5-6.35 (name "transform") + (ty-fn @6.17-6.35 + (ty @6.17-6.24 (name "Foo.Bar")) + (ty @6.28-6.35 (name "Foo.Bar")))) + (s-decl @7.5-7.22 + (p-ident @7.5-7.14 (raw "transform")) + (e-lambda @7.17-7.22 + (args + (p-ident @7.18-7.19 (raw "x"))) + (e-ident @7.21-7.22 (raw "x")))))) + (s-type-anno @10.1-10.17 (name "result") + (ty @10.10-10.17 (name "Foo.Bar"))) + (s-decl @11.1-11.39 + (p-ident @11.1-11.7 (raw "result")) + (e-apply @11.10-11.39 + (e-ident @11.10-11.23 (raw "Foo.transform")) + (e-ident @11.24-11.38 (raw "Foo.defaultBar")))))) +~~~ +# FORMATTED +~~~roc +Foo := [Whatever].{ + Bar := [A, B, C] + defaultBar = Bar.A + transform : Foo.Bar -> Foo.Bar + transform = |x| x +} + +result : Foo.Bar +result = Foo.transform(Foo.defaultBar) +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @11.1-11.7 (ident "result")) + (e-call @11.10-11.39 + (e-lookup-local @11.10-11.23 + (p-assign @7.5-7.22 (ident "Foo.transform"))) + (e-lookup-local @11.24-11.38 + (p-assign @4.5-4.23 (ident "Foo.defaultBar")))) + (annotation @11.1-11.7 + (declared-type + (ty-lookup @10.10-10.17 (name "Foo.Bar") (local))))) + (d-let + (p-assign @4.5-4.23 (ident "Foo.defaultBar")) + (e-nominal @4.18-4.23 (nominal "Foo.Bar") + (e-tag @4.18-4.23 (name "A")))) + (d-let + (p-assign @7.5-7.22 (ident "Foo.transform")) + (e-lambda @7.17-7.22 + (args + (p-assign @7.18-7.19 (ident "x"))) + (e-lookup-local @7.21-7.22 + (p-assign @7.18-7.19 (ident "x")))) + (annotation @7.5-7.14 + (declared-type + (ty-fn @6.17-6.35 (effectful false) + (ty-lookup @6.17-6.24 (name "Foo.Bar") (local)) + (ty-lookup @6.28-6.35 (name "Foo.Bar") (local)))))) + (s-nominal-decl @1.1-8.2 + (ty-header @1.1-1.4 (name "Foo")) + (ty-tag-union @1.8-1.18 + (ty-tag-name @1.9-1.17 (name "Whatever")))) + (s-nominal-decl @2.5-2.21 + (ty-header @2.5-2.21 (name "Foo.Bar")) + (ty-tag-union @2.12-2.21 + (ty-tag-name @2.13-2.14 (name "A")) + (ty-tag-name @2.16-2.17 (name "B")) + (ty-tag-name @2.19-2.20 (name "C"))))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @11.1-11.7 (type "Foo.Bar")) + (patt @4.5-4.23 (type "Foo.Bar")) + (patt @7.5-7.22 (type "Foo.Bar -> Foo.Bar"))) + (type_decls + (nominal @1.1-8.2 (type "Foo") + (ty-header @1.1-1.4 (name "Foo"))) + (nominal @2.5-2.21 (type "Foo.Bar") + (ty-header @2.5-2.21 (name "Foo.Bar")))) + (expressions + (expr @11.10-11.39 (type "Foo.Bar")) + (expr @4.18-4.23 (type "Foo.Bar")) + (expr @7.17-7.22 (type "Foo.Bar -> Foo.Bar")))) +~~~ diff --git a/test/snapshots/nominal/nominal_associated_lookup_nested.md b/test/snapshots/nominal/nominal_associated_lookup_nested.md new file mode 100644 index 0000000000..ce130338bd --- /dev/null +++ b/test/snapshots/nominal/nominal_associated_lookup_nested.md @@ -0,0 +1,141 @@ +# META +~~~ini +description=Referencing deeply nested items from associated blocks +type=file:Foo.roc +~~~ +# SOURCE +~~~roc +Foo := [Whatever].{ + Bar := [Something].{ + baz = 5 + } +} + +myType : Foo.Bar +myType = Something + +myNum : U64 +myNum = Foo.Bar.baz +~~~ +# EXPECTED +TYPE MISMATCH - nominal_associated_lookup_nested.md:8:10:8:19 +# PROBLEMS +**TYPE MISMATCH** +This expression is used in an unexpected way: +**nominal_associated_lookup_nested.md:8:10:8:19:** +```roc +myType = Something +``` + ^^^^^^^^^ + +It has the type: + _[Something]_others_ + +But the type annotation says it should have the type: + _Foo.Bar_ + +# TOKENS +~~~zig +UpperIdent(1:1-1:4),OpColonEqual(1:5-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:17),CloseSquare(1:17-1:18),Dot(1:18-1:19),OpenCurly(1:19-1:20), +UpperIdent(2:5-2:8),OpColonEqual(2:9-2:11),OpenSquare(2:12-2:13),UpperIdent(2:13-2:22),CloseSquare(2:22-2:23),Dot(2:23-2:24),OpenCurly(2:24-2:25), +LowerIdent(3:9-3:12),OpAssign(3:13-3:14),Int(3:15-3:16), +CloseCurly(4:5-4:6), +CloseCurly(5:1-5:2), +LowerIdent(7:1-7:7),OpColon(7:8-7:9),UpperIdent(7:10-7:13),NoSpaceDotUpperIdent(7:13-7:17), +LowerIdent(8:1-8:7),OpAssign(8:8-8:9),UpperIdent(8:10-8:19), +LowerIdent(10:1-10:6),OpColon(10:7-10:8),UpperIdent(10:9-10:12), +LowerIdent(11:1-11:6),OpAssign(11:7-11:8),UpperIdent(11:9-11:12),NoSpaceDotUpperIdent(11:12-11:16),NoSpaceDotLowerIdent(11:16-11:20), +EndOfFile(12:1-12:1), +~~~ +# PARSE +~~~clojure +(file @1.1-11.20 + (type-module @1.1-1.4) + (statements + (s-type-decl @1.1-5.2 + (header @1.1-1.4 (name "Foo") + (args)) + (ty-tag-union @1.8-1.18 + (tags + (ty @1.9-1.17 (name "Whatever")))) + (associated @1.19-5.2 + (s-type-decl @2.5-4.6 + (header @2.5-2.8 (name "Bar") + (args)) + (ty-tag-union @2.12-2.23 + (tags + (ty @2.13-2.22 (name "Something")))) + (associated @2.24-4.6 + (s-decl @3.9-3.16 + (p-ident @3.9-3.12 (raw "baz")) + (e-int @3.15-3.16 (raw "5"))))))) + (s-type-anno @7.1-7.17 (name "myType") + (ty @7.10-7.17 (name "Foo.Bar"))) + (s-decl @8.1-8.19 + (p-ident @8.1-8.7 (raw "myType")) + (e-tag @8.10-8.19 (raw "Something"))) + (s-type-anno @10.1-10.12 (name "myNum") + (ty @10.9-10.12 (name "U64"))) + (s-decl @11.1-11.20 + (p-ident @11.1-11.6 (raw "myNum")) + (e-ident @11.9-11.20 (raw "Foo.Bar.baz"))))) +~~~ +# FORMATTED +~~~roc +Foo := [Whatever].{ + Bar := [Something].{ + baz = 5 + } +} + +myType : Foo.Bar +myType = Something + +myNum : U64 +myNum = Foo.Bar.baz +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @8.1-8.7 (ident "myType")) + (e-tag @8.10-8.19 (name "Something")) + (annotation @8.1-8.7 + (declared-type + (ty-lookup @7.10-7.17 (name "Foo.Bar") (local))))) + (d-let + (p-assign @11.1-11.6 (ident "myNum")) + (e-lookup-local @11.9-11.20 + (p-assign @3.9-3.16 (ident "Foo.Bar.baz"))) + (annotation @11.1-11.6 + (declared-type + (ty-lookup @10.9-10.12 (name "U64") (builtin))))) + (d-let + (p-assign @3.9-3.16 (ident "Foo.Bar.baz")) + (e-num @3.15-3.16 (value "5"))) + (s-nominal-decl @1.1-5.2 + (ty-header @1.1-1.4 (name "Foo")) + (ty-tag-union @1.8-1.18 + (ty-tag-name @1.9-1.17 (name "Whatever")))) + (s-nominal-decl @2.5-4.6 + (ty-header @2.5-4.6 (name "Foo.Bar")) + (ty-tag-union @2.12-2.23 + (ty-tag-name @2.13-2.22 (name "Something"))))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @8.1-8.7 (type "Error")) + (patt @11.1-11.6 (type "Num(_size)")) + (patt @3.9-3.16 (type "Num(_size)"))) + (type_decls + (nominal @1.1-5.2 (type "Foo") + (ty-header @1.1-1.4 (name "Foo"))) + (nominal @2.5-4.6 (type "Foo.Bar") + (ty-header @2.5-4.6 (name "Foo.Bar")))) + (expressions + (expr @8.10-8.19 (type "Error")) + (expr @11.9-11.20 (type "Num(_size)")) + (expr @3.15-3.16 (type "Num(_size)")))) +~~~ diff --git a/test/snapshots/nominal/nominal_associated_lookup_type.md b/test/snapshots/nominal/nominal_associated_lookup_type.md new file mode 100644 index 0000000000..fdfb98bd3d --- /dev/null +++ b/test/snapshots/nominal/nominal_associated_lookup_type.md @@ -0,0 +1,104 @@ +# META +~~~ini +description=Type annotation referencing nested type in associated block +type=file:Foo.roc +~~~ +# SOURCE +~~~roc +Foo := [Whatever].{ + Bar := [Something] +} + +myBar : Foo.Bar +myBar = Something +~~~ +# EXPECTED +TYPE MISMATCH - nominal_associated_lookup_type.md:6:9:6:18 +# PROBLEMS +**TYPE MISMATCH** +This expression is used in an unexpected way: +**nominal_associated_lookup_type.md:6:9:6:18:** +```roc +myBar = Something +``` + ^^^^^^^^^ + +It has the type: + _[Something]_others_ + +But the type annotation says it should have the type: + _Foo.Bar_ + +# TOKENS +~~~zig +UpperIdent(1:1-1:4),OpColonEqual(1:5-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:17),CloseSquare(1:17-1:18),Dot(1:18-1:19),OpenCurly(1:19-1:20), +UpperIdent(2:5-2:8),OpColonEqual(2:9-2:11),OpenSquare(2:12-2:13),UpperIdent(2:13-2:22),CloseSquare(2:22-2:23), +CloseCurly(3:1-3:2), +LowerIdent(5:1-5:6),OpColon(5:7-5:8),UpperIdent(5:9-5:12),NoSpaceDotUpperIdent(5:12-5:16), +LowerIdent(6:1-6:6),OpAssign(6:7-6:8),UpperIdent(6:9-6:18), +EndOfFile(7:1-7:1), +~~~ +# PARSE +~~~clojure +(file @1.1-6.18 + (type-module @1.1-1.4) + (statements + (s-type-decl @1.1-3.2 + (header @1.1-1.4 (name "Foo") + (args)) + (ty-tag-union @1.8-1.18 + (tags + (ty @1.9-1.17 (name "Whatever")))) + (associated @1.19-3.2 + (s-type-decl @2.5-2.23 + (header @2.5-2.8 (name "Bar") + (args)) + (ty-tag-union @2.12-2.23 + (tags + (ty @2.13-2.22 (name "Something"))))))) + (s-type-anno @5.1-5.16 (name "myBar") + (ty @5.9-5.16 (name "Foo.Bar"))) + (s-decl @6.1-6.18 + (p-ident @6.1-6.6 (raw "myBar")) + (e-tag @6.9-6.18 (raw "Something"))))) +~~~ +# FORMATTED +~~~roc +Foo := [Whatever].{ + Bar := [Something] +} + +myBar : Foo.Bar +myBar = Something +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @6.1-6.6 (ident "myBar")) + (e-tag @6.9-6.18 (name "Something")) + (annotation @6.1-6.6 + (declared-type + (ty-lookup @5.9-5.16 (name "Foo.Bar") (local))))) + (s-nominal-decl @1.1-3.2 + (ty-header @1.1-1.4 (name "Foo")) + (ty-tag-union @1.8-1.18 + (ty-tag-name @1.9-1.17 (name "Whatever")))) + (s-nominal-decl @2.5-2.23 + (ty-header @2.5-2.23 (name "Foo.Bar")) + (ty-tag-union @2.12-2.23 + (ty-tag-name @2.13-2.22 (name "Something"))))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @6.1-6.6 (type "Error"))) + (type_decls + (nominal @1.1-3.2 (type "Foo") + (ty-header @1.1-1.4 (name "Foo"))) + (nominal @2.5-2.23 (type "Foo.Bar") + (ty-header @2.5-2.23 (name "Foo.Bar")))) + (expressions + (expr @6.9-6.18 (type "Error")))) +~~~ diff --git a/test/snapshots/nominal/nominal_associated_multiline_doc.md b/test/snapshots/nominal/nominal_associated_multiline_doc.md new file mode 100644 index 0000000000..2442ad6e5f --- /dev/null +++ b/test/snapshots/nominal/nominal_associated_multiline_doc.md @@ -0,0 +1,93 @@ +# META +~~~ini +description=Multi-line doc comments on associated items +type=file:Foo.roc +~~~ +# SOURCE +~~~roc +Foo := [A, B].{ + ## This is a multi-line doc comment + ## for a nested type declaration + ## that spans multiple lines + Bar := [X, Y, Z] + + ## Multi-line documentation + ## for an associated value + defaultValue = 42 +} +~~~ +# EXPECTED +NIL +# PROBLEMS +NIL +# TOKENS +~~~zig +UpperIdent(1:1-1:4),OpColonEqual(1:5-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:10),Comma(1:10-1:11),UpperIdent(1:12-1:13),CloseSquare(1:13-1:14),Dot(1:14-1:15),OpenCurly(1:15-1:16), +UpperIdent(5:5-5:8),OpColonEqual(5:9-5:11),OpenSquare(5:12-5:13),UpperIdent(5:13-5:14),Comma(5:14-5:15),UpperIdent(5:16-5:17),Comma(5:17-5:18),UpperIdent(5:19-5:20),CloseSquare(5:20-5:21), +LowerIdent(9:5-9:17),OpAssign(9:18-9:19),Int(9:20-9:22), +CloseCurly(10:1-10:2), +EndOfFile(11:1-11:1), +~~~ +# PARSE +~~~clojure +(file @1.1-10.2 + (type-module @1.1-1.4) + (statements + (s-type-decl @1.1-10.2 + (header @1.1-1.4 (name "Foo") + (args)) + (ty-tag-union @1.8-1.14 + (tags + (ty @1.9-1.10 (name "A")) + (ty @1.12-1.13 (name "B")))) + (associated @1.15-10.2 + (s-type-decl @5.5-5.21 + (header @5.5-5.8 (name "Bar") + (args)) + (ty-tag-union @5.12-5.21 + (tags + (ty @5.13-5.14 (name "X")) + (ty @5.16-5.17 (name "Y")) + (ty @5.19-5.20 (name "Z"))))) + (s-decl @9.5-9.22 + (p-ident @9.5-9.17 (raw "defaultValue")) + (e-int @9.20-9.22 (raw "42"))))))) +~~~ +# FORMATTED +~~~roc +Foo := [A, B].{ + Bar := [X, Y, Z] + defaultValue = 42 +} +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @9.5-9.22 (ident "Foo.defaultValue")) + (e-num @9.20-9.22 (value "42"))) + (s-nominal-decl @1.1-10.2 + (ty-header @1.1-1.4 (name "Foo")) + (ty-tag-union @1.8-1.14 + (ty-tag-name @1.9-1.10 (name "A")) + (ty-tag-name @1.12-1.13 (name "B")))) + (s-nominal-decl @5.5-5.21 + (ty-header @5.5-5.21 (name "Foo.Bar")) + (ty-tag-union @5.12-5.21 + (ty-tag-name @5.13-5.14 (name "X")) + (ty-tag-name @5.16-5.17 (name "Y")) + (ty-tag-name @5.19-5.20 (name "Z"))))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @9.5-9.22 (type "Num(_size)"))) + (type_decls + (nominal @1.1-10.2 (type "Foo") + (ty-header @1.1-1.4 (name "Foo"))) + (nominal @5.5-5.21 (type "Foo.Bar") + (ty-header @5.5-5.21 (name "Foo.Bar")))) + (expressions + (expr @9.20-9.22 (type "Num(_size)")))) +~~~ diff --git a/test/snapshots/nominal/nominal_associated_self_reference.md b/test/snapshots/nominal/nominal_associated_self_reference.md new file mode 100644 index 0000000000..5be36355e2 --- /dev/null +++ b/test/snapshots/nominal/nominal_associated_self_reference.md @@ -0,0 +1,178 @@ +# META +~~~ini +description=Self-references within associated blocks using unqualified names +type=file:Foo.roc +~~~ +# SOURCE +~~~roc +Foo := [Whatever].{ + Bar := [X, Y, Z] + + defaultBar : Bar + defaultBar = X + + transform : Bar -> Bar + transform = |x| x + + useDefault = transform(defaultBar) +} + +external : Foo.Bar +external = Foo.defaultBar +~~~ +# EXPECTED +TYPE MISMATCH - nominal_associated_self_reference.md:5:18:5:19 +# PROBLEMS +**TYPE MISMATCH** +This expression is used in an unexpected way: +**nominal_associated_self_reference.md:5:18:5:19:** +```roc + defaultBar = X +``` + ^ + +It has the type: + _[X]_others_ + +But the type annotation says it should have the type: + _Foo.Bar_ + +# TOKENS +~~~zig +UpperIdent(1:1-1:4),OpColonEqual(1:5-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:17),CloseSquare(1:17-1:18),Dot(1:18-1:19),OpenCurly(1:19-1:20), +UpperIdent(2:5-2:8),OpColonEqual(2:9-2:11),OpenSquare(2:12-2:13),UpperIdent(2:13-2:14),Comma(2:14-2:15),UpperIdent(2:16-2:17),Comma(2:17-2:18),UpperIdent(2:19-2:20),CloseSquare(2:20-2:21), +LowerIdent(4:5-4:15),OpColon(4:16-4:17),UpperIdent(4:18-4:21), +LowerIdent(5:5-5:15),OpAssign(5:16-5:17),UpperIdent(5:18-5:19), +LowerIdent(7:5-7:14),OpColon(7:15-7:16),UpperIdent(7:17-7:20),OpArrow(7:21-7:23),UpperIdent(7:24-7:27), +LowerIdent(8:5-8:14),OpAssign(8:15-8:16),OpBar(8:17-8:18),LowerIdent(8:18-8:19),OpBar(8:19-8:20),LowerIdent(8:21-8:22), +LowerIdent(10:5-10:15),OpAssign(10:16-10:17),LowerIdent(10:18-10:27),NoSpaceOpenRound(10:27-10:28),LowerIdent(10:28-10:38),CloseRound(10:38-10:39), +CloseCurly(11:1-11:2), +LowerIdent(13:1-13:9),OpColon(13:10-13:11),UpperIdent(13:12-13:15),NoSpaceDotUpperIdent(13:15-13:19), +LowerIdent(14:1-14:9),OpAssign(14:10-14:11),UpperIdent(14:12-14:15),NoSpaceDotLowerIdent(14:15-14:26), +EndOfFile(15:1-15:1), +~~~ +# PARSE +~~~clojure +(file @1.1-14.26 + (type-module @1.1-1.4) + (statements + (s-type-decl @1.1-11.2 + (header @1.1-1.4 (name "Foo") + (args)) + (ty-tag-union @1.8-1.18 + (tags + (ty @1.9-1.17 (name "Whatever")))) + (associated @1.19-11.2 + (s-type-decl @2.5-2.21 + (header @2.5-2.8 (name "Bar") + (args)) + (ty-tag-union @2.12-2.21 + (tags + (ty @2.13-2.14 (name "X")) + (ty @2.16-2.17 (name "Y")) + (ty @2.19-2.20 (name "Z"))))) + (s-type-anno @4.5-4.21 (name "defaultBar") + (ty @4.18-4.21 (name "Bar"))) + (s-decl @5.5-5.19 + (p-ident @5.5-5.15 (raw "defaultBar")) + (e-tag @5.18-5.19 (raw "X"))) + (s-type-anno @7.5-7.27 (name "transform") + (ty-fn @7.17-7.27 + (ty @7.17-7.20 (name "Bar")) + (ty @7.24-7.27 (name "Bar")))) + (s-decl @8.5-8.22 + (p-ident @8.5-8.14 (raw "transform")) + (e-lambda @8.17-8.22 + (args + (p-ident @8.18-8.19 (raw "x"))) + (e-ident @8.21-8.22 (raw "x")))) + (s-decl @10.5-10.39 + (p-ident @10.5-10.15 (raw "useDefault")) + (e-apply @10.18-10.39 + (e-ident @10.18-10.27 (raw "transform")) + (e-ident @10.28-10.38 (raw "defaultBar")))))) + (s-type-anno @13.1-13.19 (name "external") + (ty @13.12-13.19 (name "Foo.Bar"))) + (s-decl @14.1-14.26 + (p-ident @14.1-14.9 (raw "external")) + (e-ident @14.12-14.26 (raw "Foo.defaultBar"))))) +~~~ +# FORMATTED +~~~roc +Foo := [Whatever].{ + Bar := [X, Y, Z] + defaultBar : Bar + defaultBar = X + transform : Bar -> Bar + transform = |x| x + useDefault = transform(defaultBar) +} + +external : Foo.Bar +external = Foo.defaultBar +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @14.1-14.9 (ident "external")) + (e-lookup-local @14.12-14.26 + (p-assign @5.5-5.19 (ident "Foo.defaultBar"))) + (annotation @14.1-14.9 + (declared-type + (ty-lookup @13.12-13.19 (name "Foo.Bar") (local))))) + (d-let + (p-assign @5.5-5.19 (ident "Foo.defaultBar")) + (e-tag @5.18-5.19 (name "X")) + (annotation @5.5-5.15 + (declared-type + (ty-lookup @4.18-4.21 (name "Bar") (local))))) + (d-let + (p-assign @8.5-8.22 (ident "Foo.transform")) + (e-lambda @8.17-8.22 + (args + (p-assign @8.18-8.19 (ident "x"))) + (e-lookup-local @8.21-8.22 + (p-assign @8.18-8.19 (ident "x")))) + (annotation @8.5-8.14 + (declared-type + (ty-fn @7.17-7.27 (effectful false) + (ty-lookup @7.17-7.20 (name "Bar") (local)) + (ty-lookup @7.24-7.27 (name "Bar") (local)))))) + (d-let + (p-assign @10.5-10.39 (ident "Foo.useDefault")) + (e-call @10.18-10.39 + (e-lookup-local @10.18-10.27 + (p-assign @8.5-8.22 (ident "Foo.transform"))) + (e-lookup-local @10.28-10.38 + (p-assign @5.5-5.19 (ident "Foo.defaultBar"))))) + (s-nominal-decl @1.1-11.2 + (ty-header @1.1-1.4 (name "Foo")) + (ty-tag-union @1.8-1.18 + (ty-tag-name @1.9-1.17 (name "Whatever")))) + (s-nominal-decl @2.5-2.21 + (ty-header @2.5-2.21 (name "Foo.Bar")) + (ty-tag-union @2.12-2.21 + (ty-tag-name @2.13-2.14 (name "X")) + (ty-tag-name @2.16-2.17 (name "Y")) + (ty-tag-name @2.19-2.20 (name "Z"))))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @14.1-14.9 (type "Error")) + (patt @5.5-5.19 (type "Error")) + (patt @8.5-8.22 (type "Foo.Bar -> Foo.Bar")) + (patt @10.5-10.39 (type "Foo.Bar"))) + (type_decls + (nominal @1.1-11.2 (type "Foo") + (ty-header @1.1-1.4 (name "Foo"))) + (nominal @2.5-2.21 (type "Foo.Bar") + (ty-header @2.5-2.21 (name "Foo.Bar")))) + (expressions + (expr @14.12-14.26 (type "Error")) + (expr @5.18-5.19 (type "Error")) + (expr @8.17-8.22 (type "Foo.Bar -> Foo.Bar")) + (expr @10.18-10.39 (type "Foo.Bar")))) +~~~ diff --git a/test/snapshots/nominal/nominal_associated_type_alias.md b/test/snapshots/nominal/nominal_associated_type_alias.md new file mode 100644 index 0000000000..bc0da0b854 --- /dev/null +++ b/test/snapshots/nominal/nominal_associated_type_alias.md @@ -0,0 +1,112 @@ +# META +~~~ini +description=Type alias referencing associated nested type +type=snippet +~~~ +# SOURCE +~~~roc +Foo := [Whatever].{ + Bar := [X, Y, Z] +} + +# Type alias to the nested type +MyBar : Foo.Bar + +useMyBar : MyBar +useMyBar = Foo.Bar.X +~~~ +# EXPECTED +NIL +# PROBLEMS +NIL +# TOKENS +~~~zig +UpperIdent(1:1-1:4),OpColonEqual(1:5-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:17),CloseSquare(1:17-1:18),Dot(1:18-1:19),OpenCurly(1:19-1:20), +UpperIdent(2:5-2:8),OpColonEqual(2:9-2:11),OpenSquare(2:12-2:13),UpperIdent(2:13-2:14),Comma(2:14-2:15),UpperIdent(2:16-2:17),Comma(2:17-2:18),UpperIdent(2:19-2:20),CloseSquare(2:20-2:21), +CloseCurly(3:1-3:2), +UpperIdent(6:1-6:6),OpColon(6:7-6:8),UpperIdent(6:9-6:12),NoSpaceDotUpperIdent(6:12-6:16), +LowerIdent(8:1-8:9),OpColon(8:10-8:11),UpperIdent(8:12-8:17), +LowerIdent(9:1-9:9),OpAssign(9:10-9:11),UpperIdent(9:12-9:15),NoSpaceDotUpperIdent(9:15-9:19),NoSpaceDotUpperIdent(9:19-9:21), +EndOfFile(10:1-10:1), +~~~ +# PARSE +~~~clojure +(file @1.1-9.21 + (type-module @1.1-1.4) + (statements + (s-type-decl @1.1-3.2 + (header @1.1-1.4 (name "Foo") + (args)) + (ty-tag-union @1.8-1.18 + (tags + (ty @1.9-1.17 (name "Whatever")))) + (associated @1.19-3.2 + (s-type-decl @2.5-2.21 + (header @2.5-2.8 (name "Bar") + (args)) + (ty-tag-union @2.12-2.21 + (tags + (ty @2.13-2.14 (name "X")) + (ty @2.16-2.17 (name "Y")) + (ty @2.19-2.20 (name "Z"))))))) + (s-type-decl @6.1-6.16 + (header @6.1-6.6 (name "MyBar") + (args)) + (ty @6.9-6.16 (name "Foo.Bar"))) + (s-type-anno @8.1-8.17 (name "useMyBar") + (ty @8.12-8.17 (name "MyBar"))) + (s-decl @9.1-9.21 + (p-ident @9.1-9.9 (raw "useMyBar")) + (e-tag @9.12-9.21 (raw "Foo.Bar.X"))))) +~~~ +# FORMATTED +~~~roc +Foo := [Whatever].{ + Bar := [X, Y, Z] +} + +# Type alias to the nested type +MyBar : Foo.Bar + +useMyBar : MyBar +useMyBar = Foo.Bar.X +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @9.1-9.9 (ident "useMyBar")) + (e-nominal @9.12-9.21 (nominal "Foo.Bar") + (e-tag @9.12-9.21 (name "X"))) + (annotation @9.1-9.9 + (declared-type + (ty-lookup @8.12-8.17 (name "MyBar") (local))))) + (s-nominal-decl @1.1-3.2 + (ty-header @1.1-1.4 (name "Foo")) + (ty-tag-union @1.8-1.18 + (ty-tag-name @1.9-1.17 (name "Whatever")))) + (s-nominal-decl @2.5-2.21 + (ty-header @2.5-2.21 (name "Foo.Bar")) + (ty-tag-union @2.12-2.21 + (ty-tag-name @2.13-2.14 (name "X")) + (ty-tag-name @2.16-2.17 (name "Y")) + (ty-tag-name @2.19-2.20 (name "Z")))) + (s-alias-decl @6.1-6.16 + (ty-header @6.1-6.6 (name "MyBar")) + (ty-lookup @6.9-6.16 (name "Foo.Bar") (local)))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @9.1-9.9 (type "MyBar"))) + (type_decls + (nominal @1.1-3.2 (type "Foo") + (ty-header @1.1-1.4 (name "Foo"))) + (nominal @2.5-2.21 (type "Foo.Bar") + (ty-header @2.5-2.21 (name "Foo.Bar"))) + (alias @6.1-6.16 (type "MyBar") + (ty-header @6.1-6.6 (name "MyBar")))) + (expressions + (expr @9.12-9.21 (type "MyBar")))) +~~~ diff --git a/test/snapshots/nominal/nominal_associated_value_alias.md b/test/snapshots/nominal/nominal_associated_value_alias.md new file mode 100644 index 0000000000..527b7511f0 --- /dev/null +++ b/test/snapshots/nominal/nominal_associated_value_alias.md @@ -0,0 +1,112 @@ +# META +~~~ini +description=Value alias referencing associated item +type=snippet +~~~ +# SOURCE +~~~roc +Foo := [Whatever].{ + bar = 42 +} + +# Value alias to the associated item +myBar : U64 +myBar = Foo.bar + +result : U64 +result = myBar +~~~ +# EXPECTED +NIL +# PROBLEMS +NIL +# TOKENS +~~~zig +UpperIdent(1:1-1:4),OpColonEqual(1:5-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:17),CloseSquare(1:17-1:18),Dot(1:18-1:19),OpenCurly(1:19-1:20), +LowerIdent(2:5-2:8),OpAssign(2:9-2:10),Int(2:11-2:13), +CloseCurly(3:1-3:2), +LowerIdent(6:1-6:6),OpColon(6:7-6:8),UpperIdent(6:9-6:12), +LowerIdent(7:1-7:6),OpAssign(7:7-7:8),UpperIdent(7:9-7:12),NoSpaceDotLowerIdent(7:12-7:16), +LowerIdent(9:1-9:7),OpColon(9:8-9:9),UpperIdent(9:10-9:13), +LowerIdent(10:1-10:7),OpAssign(10:8-10:9),LowerIdent(10:10-10:15), +EndOfFile(11:1-11:1), +~~~ +# PARSE +~~~clojure +(file @1.1-10.15 + (type-module @1.1-1.4) + (statements + (s-type-decl @1.1-3.2 + (header @1.1-1.4 (name "Foo") + (args)) + (ty-tag-union @1.8-1.18 + (tags + (ty @1.9-1.17 (name "Whatever")))) + (associated @1.19-3.2 + (s-decl @2.5-2.13 + (p-ident @2.5-2.8 (raw "bar")) + (e-int @2.11-2.13 (raw "42"))))) + (s-type-anno @6.1-6.12 (name "myBar") + (ty @6.9-6.12 (name "U64"))) + (s-decl @7.1-7.16 + (p-ident @7.1-7.6 (raw "myBar")) + (e-ident @7.9-7.16 (raw "Foo.bar"))) + (s-type-anno @9.1-9.13 (name "result") + (ty @9.10-9.13 (name "U64"))) + (s-decl @10.1-10.15 + (p-ident @10.1-10.7 (raw "result")) + (e-ident @10.10-10.15 (raw "myBar"))))) +~~~ +# FORMATTED +~~~roc +Foo := [Whatever].{ + bar = 42 +} + +# Value alias to the associated item +myBar : U64 +myBar = Foo.bar + +result : U64 +result = myBar +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @7.1-7.6 (ident "myBar")) + (e-lookup-local @7.9-7.16 + (p-assign @2.5-2.13 (ident "Foo.bar"))) + (annotation @7.1-7.6 + (declared-type + (ty-lookup @6.9-6.12 (name "U64") (builtin))))) + (d-let + (p-assign @10.1-10.7 (ident "result")) + (e-lookup-local @10.10-10.15 + (p-assign @7.1-7.6 (ident "myBar"))) + (annotation @10.1-10.7 + (declared-type + (ty-lookup @9.10-9.13 (name "U64") (builtin))))) + (d-let + (p-assign @2.5-2.13 (ident "Foo.bar")) + (e-num @2.11-2.13 (value "42"))) + (s-nominal-decl @1.1-3.2 + (ty-header @1.1-1.4 (name "Foo")) + (ty-tag-union @1.8-1.18 + (ty-tag-name @1.9-1.17 (name "Whatever"))))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @7.1-7.6 (type "Num(_size)")) + (patt @10.1-10.7 (type "Error")) + (patt @2.5-2.13 (type "Num(_size)"))) + (type_decls + (nominal @1.1-3.2 (type "Foo") + (ty-header @1.1-1.4 (name "Foo")))) + (expressions + (expr @7.9-7.16 (type "Num(_size)")) + (expr @10.10-10.15 (type "Error")) + (expr @2.11-2.13 (type "Num(_size)")))) +~~~ diff --git a/test/snapshots/nominal/nominal_associated_vs_module.md b/test/snapshots/nominal/nominal_associated_vs_module.md new file mode 100644 index 0000000000..e9888ddc2d --- /dev/null +++ b/test/snapshots/nominal/nominal_associated_vs_module.md @@ -0,0 +1,128 @@ +# META +~~~ini +description=Qualified names should be checked locally before treating as module references +type=file +~~~ +# SOURCE +~~~roc +Foo := [Whatever].{ + Bar := [Something] +} + +# This should resolve to the local Foo.Bar, not try to import from a Foo module +useBar : Foo.Bar +useBar = Something +~~~ +# EXPECTED +TYPE MODULE MISSING MATCHING TYPE - nominal_associated_vs_module.md:1:1:7:19 +TYPE MISMATCH - nominal_associated_vs_module.md:7:10:7:19 +# PROBLEMS +**TYPE MODULE MISSING MATCHING TYPE** +Type modules must have a type declaration matching the module name. + +This file is named `nominal_associated_vs_module`.roc, but no top-level type declaration named `nominal_associated_vs_module` was found. + +Add either: +`nominal_associated_vs_module := ...` (nominal type) +or: +`nominal_associated_vs_module : ...` (type alias) +**nominal_associated_vs_module.md:1:1:7:19:** +```roc +Foo := [Whatever].{ + Bar := [Something] +} + +# This should resolve to the local Foo.Bar, not try to import from a Foo module +useBar : Foo.Bar +useBar = Something +``` + + +**TYPE MISMATCH** +This expression is used in an unexpected way: +**nominal_associated_vs_module.md:7:10:7:19:** +```roc +useBar = Something +``` + ^^^^^^^^^ + +It has the type: + _[Something]_others_ + +But the type annotation says it should have the type: + _Foo.Bar_ + +# TOKENS +~~~zig +UpperIdent(1:1-1:4),OpColonEqual(1:5-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:17),CloseSquare(1:17-1:18),Dot(1:18-1:19),OpenCurly(1:19-1:20), +UpperIdent(2:5-2:8),OpColonEqual(2:9-2:11),OpenSquare(2:12-2:13),UpperIdent(2:13-2:22),CloseSquare(2:22-2:23), +CloseCurly(3:1-3:2), +LowerIdent(6:1-6:7),OpColon(6:8-6:9),UpperIdent(6:10-6:13),NoSpaceDotUpperIdent(6:13-6:17), +LowerIdent(7:1-7:7),OpAssign(7:8-7:9),UpperIdent(7:10-7:19), +EndOfFile(8:1-8:1), +~~~ +# PARSE +~~~clojure +(file @1.1-7.19 + (type-module @1.1-1.4) + (statements + (s-type-decl @1.1-3.2 + (header @1.1-1.4 (name "Foo") + (args)) + (ty-tag-union @1.8-1.18 + (tags + (ty @1.9-1.17 (name "Whatever")))) + (associated @1.19-3.2 + (s-type-decl @2.5-2.23 + (header @2.5-2.8 (name "Bar") + (args)) + (ty-tag-union @2.12-2.23 + (tags + (ty @2.13-2.22 (name "Something"))))))) + (s-type-anno @6.1-6.17 (name "useBar") + (ty @6.10-6.17 (name "Foo.Bar"))) + (s-decl @7.1-7.19 + (p-ident @7.1-7.7 (raw "useBar")) + (e-tag @7.10-7.19 (raw "Something"))))) +~~~ +# FORMATTED +~~~roc +Foo := [Whatever].{ + Bar := [Something] +} + +# This should resolve to the local Foo.Bar, not try to import from a Foo module +useBar : Foo.Bar +useBar = Something +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @7.1-7.7 (ident "useBar")) + (e-tag @7.10-7.19 (name "Something")) + (annotation @7.1-7.7 + (declared-type + (ty-lookup @6.10-6.17 (name "Foo.Bar") (local))))) + (s-nominal-decl @1.1-3.2 + (ty-header @1.1-1.4 (name "Foo")) + (ty-tag-union @1.8-1.18 + (ty-tag-name @1.9-1.17 (name "Whatever")))) + (s-nominal-decl @2.5-2.23 + (ty-header @2.5-2.23 (name "Foo.Bar")) + (ty-tag-union @2.12-2.23 + (ty-tag-name @2.13-2.22 (name "Something"))))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @7.1-7.7 (type "Error"))) + (type_decls + (nominal @1.1-3.2 (type "Foo") + (ty-header @1.1-1.4 (name "Foo"))) + (nominal @2.5-2.23 (type "Foo.Bar") + (ty-header @2.5-2.23 (name "Foo.Bar")))) + (expressions + (expr @7.10-7.19 (type "Error")))) +~~~ diff --git a/test/snapshots/nominal/nominal_associated_with_final_expression.md b/test/snapshots/nominal/nominal_associated_with_final_expression.md new file mode 100644 index 0000000000..9f86372fbc --- /dev/null +++ b/test/snapshots/nominal/nominal_associated_with_final_expression.md @@ -0,0 +1,94 @@ +# META +~~~ini +description=Nominal type associated items with final expression produces error +type=snippet +~~~ +# SOURCE +~~~roc +Foo := [A, B, C].{ x = 5 +x } +~~~ +# EXPECTED +EXPRESSION IN ASSOCIATED ITEMS - nominal_associated_with_final_expression.md:2:1:2:2 +UNUSED VARIABLE - nominal_associated_with_final_expression.md:1:20:1:25 +# PROBLEMS +**EXPRESSION IN ASSOCIATED ITEMS** +Associated items (such as types or methods) can only have associated types and values, not plain expressions. + +To fix this, remove the expression at the very end. + +**nominal_associated_with_final_expression.md:2:1:2:2:** +```roc +x } +``` +^ + + +**UNUSED VARIABLE** +Variable `x` is not used anywhere in your code. + +If you don't need this variable, prefix it with an underscore like `_x` to suppress this warning. +The unused variable is declared here: +**nominal_associated_with_final_expression.md:1:20:1:25:** +```roc +Foo := [A, B, C].{ x = 5 +``` + ^^^^^ + + +# TOKENS +~~~zig +UpperIdent(1:1-1:4),OpColonEqual(1:5-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:10),Comma(1:10-1:11),UpperIdent(1:12-1:13),Comma(1:13-1:14),UpperIdent(1:15-1:16),CloseSquare(1:16-1:17),Dot(1:17-1:18),OpenCurly(1:18-1:19),LowerIdent(1:20-1:21),OpAssign(1:22-1:23),Int(1:24-1:25), +LowerIdent(2:1-2:2),CloseCurly(2:3-2:4), +EndOfFile(3:1-3:1), +~~~ +# PARSE +~~~clojure +(file @1.1-2.4 + (type-module @1.1-1.4) + (statements + (s-type-decl @1.1-2.4 + (header @1.1-1.4 (name "Foo") + (args)) + (ty-tag-union @1.8-1.17 + (tags + (ty @1.9-1.10 (name "A")) + (ty @1.12-1.13 (name "B")) + (ty @1.15-1.16 (name "C")))) + (associated @1.18-2.4 + (s-decl @1.20-1.25 + (p-ident @1.20-1.21 (raw "x")) + (e-int @1.24-1.25 (raw "5"))) + (e-ident @2.1-2.2 (raw "x")))))) +~~~ +# FORMATTED +~~~roc +Foo := [A, B, C].{ + x = 5 + x +} +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @1.20-1.25 (ident "Foo.x")) + (e-num @1.24-1.25 (value "5"))) + (s-nominal-decl @1.1-2.4 + (ty-header @1.1-1.4 (name "Foo")) + (ty-tag-union @1.8-1.17 + (ty-tag-name @1.9-1.10 (name "A")) + (ty-tag-name @1.12-1.13 (name "B")) + (ty-tag-name @1.15-1.16 (name "C"))))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @1.20-1.25 (type "Num(_size)"))) + (type_decls + (nominal @1.1-2.4 (type "Foo") + (ty-header @1.1-1.4 (name "Foo")))) + (expressions + (expr @1.24-1.25 (type "Num(_size)")))) +~~~ diff --git a/test/snapshots/nominal/nominal_deeply_nested_tag.md b/test/snapshots/nominal/nominal_deeply_nested_tag.md new file mode 100644 index 0000000000..c5e37fe610 --- /dev/null +++ b/test/snapshots/nominal/nominal_deeply_nested_tag.md @@ -0,0 +1,115 @@ +# META +~~~ini +description=Deeply nested tag constructor (three levels deep) +type=snippet +~~~ +# SOURCE +~~~roc +Foo := [Whatever].{ + Bar := [Something].{ + Baz := [X, Y, Z] + } +} + +x : Foo.Bar.Baz +x = Foo.Bar.Baz.X +~~~ +# EXPECTED +NIL +# PROBLEMS +NIL +# TOKENS +~~~zig +UpperIdent(1:1-1:4),OpColonEqual(1:5-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:17),CloseSquare(1:17-1:18),Dot(1:18-1:19),OpenCurly(1:19-1:20), +UpperIdent(2:5-2:8),OpColonEqual(2:9-2:11),OpenSquare(2:12-2:13),UpperIdent(2:13-2:22),CloseSquare(2:22-2:23),Dot(2:23-2:24),OpenCurly(2:24-2:25), +UpperIdent(3:9-3:12),OpColonEqual(3:13-3:15),OpenSquare(3:16-3:17),UpperIdent(3:17-3:18),Comma(3:18-3:19),UpperIdent(3:20-3:21),Comma(3:21-3:22),UpperIdent(3:23-3:24),CloseSquare(3:24-3:25), +CloseCurly(4:5-4:6), +CloseCurly(5:1-5:2), +LowerIdent(7:1-7:2),OpColon(7:3-7:4),UpperIdent(7:5-7:8),NoSpaceDotUpperIdent(7:8-7:12),NoSpaceDotUpperIdent(7:12-7:16), +LowerIdent(8:1-8:2),OpAssign(8:3-8:4),UpperIdent(8:5-8:8),NoSpaceDotUpperIdent(8:8-8:12),NoSpaceDotUpperIdent(8:12-8:16),NoSpaceDotUpperIdent(8:16-8:18), +EndOfFile(9:1-9:1), +~~~ +# PARSE +~~~clojure +(file @1.1-8.18 + (type-module @1.1-1.4) + (statements + (s-type-decl @1.1-5.2 + (header @1.1-1.4 (name "Foo") + (args)) + (ty-tag-union @1.8-1.18 + (tags + (ty @1.9-1.17 (name "Whatever")))) + (associated @1.19-5.2 + (s-type-decl @2.5-4.6 + (header @2.5-2.8 (name "Bar") + (args)) + (ty-tag-union @2.12-2.23 + (tags + (ty @2.13-2.22 (name "Something")))) + (associated @2.24-4.6 + (s-type-decl @3.9-3.25 + (header @3.9-3.12 (name "Baz") + (args)) + (ty-tag-union @3.16-3.25 + (tags + (ty @3.17-3.18 (name "X")) + (ty @3.20-3.21 (name "Y")) + (ty @3.23-3.24 (name "Z"))))))))) + (s-type-anno @7.1-7.16 (name "x") + (ty @7.5-7.16 (name "Foo.Bar.Baz"))) + (s-decl @8.1-8.18 + (p-ident @8.1-8.2 (raw "x")) + (e-tag @8.5-8.18 (raw "Foo.Bar.Baz.X"))))) +~~~ +# FORMATTED +~~~roc +Foo := [Whatever].{ + Bar := [Something].{ + Baz := [X, Y, Z] + } +} + +x : Foo.Bar.Baz +x = Foo.Bar.Baz.X +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @8.1-8.2 (ident "x")) + (e-nominal @8.5-8.18 (nominal "Foo.Bar.Baz") + (e-tag @8.5-8.18 (name "X"))) + (annotation @8.1-8.2 + (declared-type + (ty-lookup @7.5-7.16 (name "Foo.Bar.Baz") (local))))) + (s-nominal-decl @1.1-5.2 + (ty-header @1.1-1.4 (name "Foo")) + (ty-tag-union @1.8-1.18 + (ty-tag-name @1.9-1.17 (name "Whatever")))) + (s-nominal-decl @2.5-4.6 + (ty-header @2.5-4.6 (name "Foo.Bar")) + (ty-tag-union @2.12-2.23 + (ty-tag-name @2.13-2.22 (name "Something")))) + (s-nominal-decl @3.9-3.25 + (ty-header @3.9-3.25 (name "Foo.Bar.Baz")) + (ty-tag-union @3.16-3.25 + (ty-tag-name @3.17-3.18 (name "X")) + (ty-tag-name @3.20-3.21 (name "Y")) + (ty-tag-name @3.23-3.24 (name "Z"))))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @8.1-8.2 (type "Foo.Bar.Baz"))) + (type_decls + (nominal @1.1-5.2 (type "Foo") + (ty-header @1.1-1.4 (name "Foo"))) + (nominal @2.5-4.6 (type "Foo.Bar") + (ty-header @2.5-4.6 (name "Foo.Bar"))) + (nominal @3.9-3.25 (type "Foo.Bar.Baz") + (ty-header @3.9-3.25 (name "Foo.Bar.Baz")))) + (expressions + (expr @8.5-8.18 (type "Foo.Bar.Baz")))) +~~~ diff --git a/test/snapshots/nominal/nominal_deeply_nested_types.md b/test/snapshots/nominal/nominal_deeply_nested_types.md new file mode 100644 index 0000000000..f5f58757c9 --- /dev/null +++ b/test/snapshots/nominal/nominal_deeply_nested_types.md @@ -0,0 +1,156 @@ +# META +~~~ini +description=Deeply nested types (3+ levels) in associated blocks +type=file:Foo.roc +~~~ +# SOURCE +~~~roc +Foo := [Whatever].{ + Bar := [Something].{ + Baz := [Else].{ + Qux := [Deep].{ + w = 1 + } + z = 2 + } + y = 3 + } + x = 4 +} +~~~ +# EXPECTED +NIL +# PROBLEMS +NIL +# TOKENS +~~~zig +UpperIdent(1:1-1:4),OpColonEqual(1:5-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:17),CloseSquare(1:17-1:18),Dot(1:18-1:19),OpenCurly(1:19-1:20), +UpperIdent(2:5-2:8),OpColonEqual(2:9-2:11),OpenSquare(2:12-2:13),UpperIdent(2:13-2:22),CloseSquare(2:22-2:23),Dot(2:23-2:24),OpenCurly(2:24-2:25), +UpperIdent(3:9-3:12),OpColonEqual(3:13-3:15),OpenSquare(3:16-3:17),UpperIdent(3:17-3:21),CloseSquare(3:21-3:22),Dot(3:22-3:23),OpenCurly(3:23-3:24), +UpperIdent(4:13-4:16),OpColonEqual(4:17-4:19),OpenSquare(4:20-4:21),UpperIdent(4:21-4:25),CloseSquare(4:25-4:26),Dot(4:26-4:27),OpenCurly(4:27-4:28), +LowerIdent(5:17-5:18),OpAssign(5:19-5:20),Int(5:21-5:22), +CloseCurly(6:13-6:14), +LowerIdent(7:13-7:14),OpAssign(7:15-7:16),Int(7:17-7:18), +CloseCurly(8:9-8:10), +LowerIdent(9:9-9:10),OpAssign(9:11-9:12),Int(9:13-9:14), +CloseCurly(10:5-10:6), +LowerIdent(11:5-11:6),OpAssign(11:7-11:8),Int(11:9-11:10), +CloseCurly(12:1-12:2), +EndOfFile(13:1-13:1), +~~~ +# PARSE +~~~clojure +(file @1.1-12.2 + (type-module @1.1-1.4) + (statements + (s-type-decl @1.1-12.2 + (header @1.1-1.4 (name "Foo") + (args)) + (ty-tag-union @1.8-1.18 + (tags + (ty @1.9-1.17 (name "Whatever")))) + (associated @1.19-12.2 + (s-type-decl @2.5-10.6 + (header @2.5-2.8 (name "Bar") + (args)) + (ty-tag-union @2.12-2.23 + (tags + (ty @2.13-2.22 (name "Something")))) + (associated @2.24-10.6 + (s-type-decl @3.9-8.10 + (header @3.9-3.12 (name "Baz") + (args)) + (ty-tag-union @3.16-3.22 + (tags + (ty @3.17-3.21 (name "Else")))) + (associated @3.23-8.10 + (s-type-decl @4.13-6.14 + (header @4.13-4.16 (name "Qux") + (args)) + (ty-tag-union @4.20-4.26 + (tags + (ty @4.21-4.25 (name "Deep")))) + (associated @4.27-6.14 + (s-decl @5.17-5.22 + (p-ident @5.17-5.18 (raw "w")) + (e-int @5.21-5.22 (raw "1"))))) + (s-decl @7.13-7.18 + (p-ident @7.13-7.14 (raw "z")) + (e-int @7.17-7.18 (raw "2"))))) + (s-decl @9.9-9.14 + (p-ident @9.9-9.10 (raw "y")) + (e-int @9.13-9.14 (raw "3"))))) + (s-decl @11.5-11.10 + (p-ident @11.5-11.6 (raw "x")) + (e-int @11.9-11.10 (raw "4"))))))) +~~~ +# FORMATTED +~~~roc +Foo := [Whatever].{ + Bar := [Something].{ + Baz := [Else].{ + Qux := [Deep].{ + w = 1 + } + z = 2 + } + y = 3 + } + x = 4 +} +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @5.17-5.22 (ident "Foo.Bar.Baz.Qux.w")) + (e-num @5.21-5.22 (value "1"))) + (d-let + (p-assign @7.13-7.18 (ident "Foo.Bar.Baz.z")) + (e-num @7.17-7.18 (value "2"))) + (d-let + (p-assign @9.9-9.14 (ident "Foo.Bar.y")) + (e-num @9.13-9.14 (value "3"))) + (d-let + (p-assign @11.5-11.10 (ident "Foo.x")) + (e-num @11.9-11.10 (value "4"))) + (s-nominal-decl @1.1-12.2 + (ty-header @1.1-1.4 (name "Foo")) + (ty-tag-union @1.8-1.18 + (ty-tag-name @1.9-1.17 (name "Whatever")))) + (s-nominal-decl @2.5-10.6 + (ty-header @2.5-10.6 (name "Foo.Bar")) + (ty-tag-union @2.12-2.23 + (ty-tag-name @2.13-2.22 (name "Something")))) + (s-nominal-decl @3.9-8.10 + (ty-header @3.9-8.10 (name "Foo.Bar.Baz")) + (ty-tag-union @3.16-3.22 + (ty-tag-name @3.17-3.21 (name "Else")))) + (s-nominal-decl @4.13-6.14 + (ty-header @4.13-6.14 (name "Foo.Bar.Baz.Qux")) + (ty-tag-union @4.20-4.26 + (ty-tag-name @4.21-4.25 (name "Deep"))))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @5.17-5.22 (type "Num(_size)")) + (patt @7.13-7.18 (type "Num(_size)")) + (patt @9.9-9.14 (type "Num(_size)")) + (patt @11.5-11.10 (type "Num(_size)"))) + (type_decls + (nominal @1.1-12.2 (type "Foo") + (ty-header @1.1-1.4 (name "Foo"))) + (nominal @2.5-10.6 (type "Foo.Bar") + (ty-header @2.5-10.6 (name "Foo.Bar"))) + (nominal @3.9-8.10 (type "Foo.Bar.Baz") + (ty-header @3.9-8.10 (name "Foo.Bar.Baz"))) + (nominal @4.13-6.14 (type "Foo.Bar.Baz.Qux") + (ty-header @4.13-6.14 (name "Foo.Bar.Baz.Qux")))) + (expressions + (expr @5.21-5.22 (type "Num(_size)")) + (expr @7.17-7.18 (type "Num(_size)")) + (expr @9.13-9.14 (type "Num(_size)")) + (expr @11.9-11.10 (type "Num(_size)")))) +~~~ diff --git a/test/snapshots/nominal/nominal_external_fully_qualified.md b/test/snapshots/nominal/nominal_external_fully_qualified.md index f6b10c843f..5a68c4c671 100644 --- a/test/snapshots/nominal/nominal_external_fully_qualified.md +++ b/test/snapshots/nominal/nominal_external_fully_qualified.md @@ -1,12 +1,10 @@ # META ~~~ini description=Example of external nominal tag union fully qualified name -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [handleResult] - import MyResultModule handleResult : MyResultModule.MyResultType(Str, I32) -> Str @@ -18,14 +16,14 @@ handleResult = |result| { } ~~~ # EXPECTED -MODULE NOT FOUND - nominal_external_fully_qualified.md:3:1:3:22 -UNUSED VARIABLE - nominal_external_fully_qualified.md:9:41:9:45 +MODULE NOT FOUND - nominal_external_fully_qualified.md:1:1:1:22 +UNUSED VARIABLE - nominal_external_fully_qualified.md:7:41:7:45 # PROBLEMS **MODULE NOT FOUND** The module `MyResultModule` was not found in this Roc project. You're attempting to use this module here: -**nominal_external_fully_qualified.md:3:1:3:22:** +**nominal_external_fully_qualified.md:1:1:1:22:** ```roc import MyResultModule ``` @@ -37,7 +35,7 @@ Variable `code` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_code` to suppress this warning. The unused variable is declared here: -**nominal_external_fully_qualified.md:9:41:9:45:** +**nominal_external_fully_qualified.md:7:41:7:45:** ```roc MyResultModule.MyResultType.Err(code) => "Error: $(code.toStr())" ``` @@ -46,57 +44,51 @@ The unused variable is declared here: # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:21),CloseSquare(1:21-1:22), -KwImport(3:1-3:7),UpperIdent(3:8-3:22), -LowerIdent(5:1-5:13),OpColon(5:14-5:15),UpperIdent(5:16-5:30),NoSpaceDotUpperIdent(5:30-5:43),NoSpaceOpenRound(5:43-5:44),UpperIdent(5:44-5:47),Comma(5:47-5:48),UpperIdent(5:49-5:52),CloseRound(5:52-5:53),OpArrow(5:54-5:56),UpperIdent(5:57-5:60), -LowerIdent(6:1-6:13),OpAssign(6:14-6:15),OpBar(6:16-6:17),LowerIdent(6:17-6:23),OpBar(6:23-6:24),OpenCurly(6:25-6:26), -KwMatch(7:5-7:10),LowerIdent(7:11-7:17),OpenCurly(7:18-7:19), -UpperIdent(8:9-8:23),NoSpaceDotUpperIdent(8:23-8:36),NoSpaceDotUpperIdent(8:36-8:39),NoSpaceOpenRound(8:39-8:40),LowerIdent(8:40-8:45),CloseRound(8:45-8:46),OpFatArrow(8:47-8:49),LowerIdent(8:50-8:55), -UpperIdent(9:9-9:23),NoSpaceDotUpperIdent(9:23-9:36),NoSpaceDotUpperIdent(9:36-9:40),NoSpaceOpenRound(9:40-9:41),LowerIdent(9:41-9:45),CloseRound(9:45-9:46),OpFatArrow(9:47-9:49),StringStart(9:50-9:51),StringPart(9:51-9:73),StringEnd(9:73-9:74), -CloseCurly(10:5-10:6), -CloseCurly(11:1-11:2), -EndOfFile(12:1-12:1), +KwImport(1:1-1:7),UpperIdent(1:8-1:22), +LowerIdent(3:1-3:13),OpColon(3:14-3:15),UpperIdent(3:16-3:30),NoSpaceDotUpperIdent(3:30-3:43),NoSpaceOpenRound(3:43-3:44),UpperIdent(3:44-3:47),Comma(3:47-3:48),UpperIdent(3:49-3:52),CloseRound(3:52-3:53),OpArrow(3:54-3:56),UpperIdent(3:57-3:60), +LowerIdent(4:1-4:13),OpAssign(4:14-4:15),OpBar(4:16-4:17),LowerIdent(4:17-4:23),OpBar(4:23-4:24),OpenCurly(4:25-4:26), +KwMatch(5:5-5:10),LowerIdent(5:11-5:17),OpenCurly(5:18-5:19), +UpperIdent(6:9-6:23),NoSpaceDotUpperIdent(6:23-6:36),NoSpaceDotUpperIdent(6:36-6:39),NoSpaceOpenRound(6:39-6:40),LowerIdent(6:40-6:45),CloseRound(6:45-6:46),OpFatArrow(6:47-6:49),LowerIdent(6:50-6:55), +UpperIdent(7:9-7:23),NoSpaceDotUpperIdent(7:23-7:36),NoSpaceDotUpperIdent(7:36-7:40),NoSpaceOpenRound(7:40-7:41),LowerIdent(7:41-7:45),CloseRound(7:45-7:46),OpFatArrow(7:47-7:49),StringStart(7:50-7:51),StringPart(7:51-7:73),StringEnd(7:73-7:74), +CloseCurly(8:5-8:6), +CloseCurly(9:1-9:2), +EndOfFile(10:1-10:1), ~~~ # PARSE ~~~clojure -(file @1.1-11.2 - (module @1.1-1.22 - (exposes @1.8-1.22 - (exposed-lower-ident @1.9-1.21 - (text "handleResult")))) +(file @1.1-9.2 + (type-module @1.1-1.7) (statements - (s-import @3.1-3.22 (raw "MyResultModule")) - (s-type-anno @5.1-5.60 (name "handleResult") - (ty-fn @5.16-5.60 - (ty-apply @5.16-5.53 - (ty @5.16-5.43 (name "MyResultModule.MyResultType")) - (ty @5.44-5.47 (name "Str")) - (ty @5.49-5.52 (name "I32"))) - (ty @5.57-5.60 (name "Str")))) - (s-decl @6.1-11.2 - (p-ident @6.1-6.13 (raw "handleResult")) - (e-lambda @6.16-11.2 + (s-import @1.1-1.22 (raw "MyResultModule")) + (s-type-anno @3.1-3.60 (name "handleResult") + (ty-fn @3.16-3.60 + (ty-apply @3.16-3.53 + (ty @3.16-3.43 (name "MyResultModule.MyResultType")) + (ty @3.44-3.47 (name "Str")) + (ty @3.49-3.52 (name "I32"))) + (ty @3.57-3.60 (name "Str")))) + (s-decl @4.1-9.2 + (p-ident @4.1-4.13 (raw "handleResult")) + (e-lambda @4.16-9.2 (args - (p-ident @6.17-6.23 (raw "result"))) - (e-block @6.25-11.2 + (p-ident @4.17-4.23 (raw "result"))) + (e-block @4.25-9.2 (statements (e-match - (e-ident @7.11-7.17 (raw "result")) + (e-ident @5.11-5.17 (raw "result")) (branches - (branch @8.9-8.55 - (p-tag @8.9-8.46 (raw ".Ok") - (p-ident @8.40-8.45 (raw "value"))) - (e-ident @8.50-8.55 (raw "value"))) - (branch @9.9-9.74 - (p-tag @9.9-9.46 (raw ".Err") - (p-ident @9.41-9.45 (raw "code"))) - (e-string @9.50-9.74 - (e-string-part @9.51-9.73 (raw "Error: $(code.toStr())")))))))))))) + (branch @6.9-6.55 + (p-tag @6.9-6.46 (raw ".Ok") + (p-ident @6.40-6.45 (raw "value"))) + (e-ident @6.50-6.55 (raw "value"))) + (branch @7.9-7.74 + (p-tag @7.9-7.46 (raw ".Err") + (p-ident @7.41-7.45 (raw "code"))) + (e-string @7.50-7.74 + (e-string-part @7.51-7.73 (raw "Error: $(code.toStr())")))))))))))) ~~~ # FORMATTED ~~~roc -module [handleResult] - import MyResultModule handleResult : MyResultModule.MyResultType(Str, I32) -> Str @@ -111,51 +103,51 @@ handleResult = |result| { ~~~clojure (can-ir (d-let - (p-assign @6.1-6.13 (ident "handleResult")) - (e-closure @6.16-11.2 + (p-assign @4.1-4.13 (ident "handleResult")) + (e-closure @4.16-9.2 (captures - (capture @8.40-8.45 (ident "value"))) - (e-lambda @6.16-11.2 + (capture @6.40-6.45 (ident "value"))) + (e-lambda @4.16-9.2 (args - (p-assign @6.17-6.23 (ident "result"))) - (e-block @6.25-11.2 - (e-match @7.5-10.6 - (match @7.5-10.6 + (p-assign @4.17-4.23 (ident "result"))) + (e-block @4.25-9.2 + (e-match @5.5-8.6 + (match @5.5-8.6 (cond - (e-lookup-local @7.11-7.17 - (p-assign @6.17-6.23 (ident "result")))) + (e-lookup-local @5.11-5.17 + (p-assign @4.17-4.23 (ident "result")))) (branches (branch (patterns (pattern (degenerate false) - (p-nominal-external @8.9-8.46 (module-idx "0") (target-node-idx "0") - (p-applied-tag @8.9-8.46)))) + (p-nominal-external @6.9-6.46 (module-idx "2") (target-node-idx "0") + (p-applied-tag @6.9-6.46)))) (value - (e-lookup-local @8.50-8.55 - (p-assign @8.40-8.45 (ident "value"))))) + (e-lookup-local @6.50-6.55 + (p-assign @6.40-6.45 (ident "value"))))) (branch (patterns (pattern (degenerate false) - (p-nominal-external @9.9-9.46 (module-idx "0") (target-node-idx "0") - (p-applied-tag @9.9-9.46)))) + (p-nominal-external @7.9-7.46 (module-idx "2") (target-node-idx "0") + (p-applied-tag @7.9-7.46)))) (value - (e-string @9.50-9.74 - (e-literal @9.51-9.73 (string "Error: $(code.toStr())"))))))))))) - (annotation @6.1-6.13 + (e-string @7.50-7.74 + (e-literal @7.51-7.73 (string "Error: $(code.toStr())"))))))))))) + (annotation @4.1-4.13 (declared-type - (ty-fn @5.16-5.60 (effectful false) - (ty-apply-external @5.16-5.53 - (module-idx "0") - (target-node-idx "0")) - (ty @5.57-5.60 (name "Str")))))) - (s-import @3.1-3.22 (module "MyResultModule") + (ty-fn @3.16-3.60 (effectful false) + (ty-apply @3.16-3.53 (name "MyResultType") (external (module-idx "2") (target-node-idx "0")) + (ty-lookup @3.44-3.47 (name "Str") (builtin)) + (ty-lookup @3.49-3.52 (name "I32") (builtin))) + (ty-lookup @3.57-3.60 (name "Str") (builtin)))))) + (s-import @1.1-1.22 (module "MyResultModule") (exposes))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @6.1-6.13 (type "Error -> Str"))) + (patt @4.1-4.13 (type "Error -> Str"))) (expressions - (expr @6.16-11.2 (type "Error -> Str")))) + (expr @4.16-9.2 (type "Error -> Str")))) ~~~ diff --git a/test/snapshots/nominal/nominal_four_level_nested_tag.md b/test/snapshots/nominal/nominal_four_level_nested_tag.md new file mode 100644 index 0000000000..703ba3fc1b --- /dev/null +++ b/test/snapshots/nominal/nominal_four_level_nested_tag.md @@ -0,0 +1,134 @@ +# META +~~~ini +description=Four-level nested tag constructor (Foo.Bar.Baz.Qux.Tag) +type=snippet +~~~ +# SOURCE +~~~roc +Foo := [A].{ + Bar := [B].{ + Baz := [C].{ + Qux := [X, Y, Z] + } + } +} + +value : Foo.Bar.Baz.Qux +value = Foo.Bar.Baz.Qux.Y +~~~ +# EXPECTED +NIL +# PROBLEMS +NIL +# TOKENS +~~~zig +UpperIdent(1:1-1:4),OpColonEqual(1:5-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:10),CloseSquare(1:10-1:11),Dot(1:11-1:12),OpenCurly(1:12-1:13), +UpperIdent(2:5-2:8),OpColonEqual(2:9-2:11),OpenSquare(2:12-2:13),UpperIdent(2:13-2:14),CloseSquare(2:14-2:15),Dot(2:15-2:16),OpenCurly(2:16-2:17), +UpperIdent(3:9-3:12),OpColonEqual(3:13-3:15),OpenSquare(3:16-3:17),UpperIdent(3:17-3:18),CloseSquare(3:18-3:19),Dot(3:19-3:20),OpenCurly(3:20-3:21), +UpperIdent(4:13-4:16),OpColonEqual(4:17-4:19),OpenSquare(4:20-4:21),UpperIdent(4:21-4:22),Comma(4:22-4:23),UpperIdent(4:24-4:25),Comma(4:25-4:26),UpperIdent(4:27-4:28),CloseSquare(4:28-4:29), +CloseCurly(5:9-5:10), +CloseCurly(6:5-6:6), +CloseCurly(7:1-7:2), +LowerIdent(9:1-9:6),OpColon(9:7-9:8),UpperIdent(9:9-9:12),NoSpaceDotUpperIdent(9:12-9:16),NoSpaceDotUpperIdent(9:16-9:20),NoSpaceDotUpperIdent(9:20-9:24), +LowerIdent(10:1-10:6),OpAssign(10:7-10:8),UpperIdent(10:9-10:12),NoSpaceDotUpperIdent(10:12-10:16),NoSpaceDotUpperIdent(10:16-10:20),NoSpaceDotUpperIdent(10:20-10:24),NoSpaceDotUpperIdent(10:24-10:26), +EndOfFile(11:1-11:1), +~~~ +# PARSE +~~~clojure +(file @1.1-10.26 + (type-module @1.1-1.4) + (statements + (s-type-decl @1.1-7.2 + (header @1.1-1.4 (name "Foo") + (args)) + (ty-tag-union @1.8-1.11 + (tags + (ty @1.9-1.10 (name "A")))) + (associated @1.12-7.2 + (s-type-decl @2.5-6.6 + (header @2.5-2.8 (name "Bar") + (args)) + (ty-tag-union @2.12-2.15 + (tags + (ty @2.13-2.14 (name "B")))) + (associated @2.16-6.6 + (s-type-decl @3.9-5.10 + (header @3.9-3.12 (name "Baz") + (args)) + (ty-tag-union @3.16-3.19 + (tags + (ty @3.17-3.18 (name "C")))) + (associated @3.20-5.10 + (s-type-decl @4.13-4.29 + (header @4.13-4.16 (name "Qux") + (args)) + (ty-tag-union @4.20-4.29 + (tags + (ty @4.21-4.22 (name "X")) + (ty @4.24-4.25 (name "Y")) + (ty @4.27-4.28 (name "Z"))))))))))) + (s-type-anno @9.1-9.24 (name "value") + (ty @9.9-9.24 (name "Foo.Bar.Baz.Qux"))) + (s-decl @10.1-10.26 + (p-ident @10.1-10.6 (raw "value")) + (e-tag @10.9-10.26 (raw "Foo.Bar.Baz.Qux.Y"))))) +~~~ +# FORMATTED +~~~roc +Foo := [A].{ + Bar := [B].{ + Baz := [C].{ + Qux := [X, Y, Z] + } + } +} + +value : Foo.Bar.Baz.Qux +value = Foo.Bar.Baz.Qux.Y +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @10.1-10.6 (ident "value")) + (e-nominal @10.9-10.26 (nominal "Foo.Bar.Baz.Qux") + (e-tag @10.9-10.26 (name "Y"))) + (annotation @10.1-10.6 + (declared-type + (ty-lookup @9.9-9.24 (name "Foo.Bar.Baz.Qux") (local))))) + (s-nominal-decl @1.1-7.2 + (ty-header @1.1-1.4 (name "Foo")) + (ty-tag-union @1.8-1.11 + (ty-tag-name @1.9-1.10 (name "A")))) + (s-nominal-decl @2.5-6.6 + (ty-header @2.5-6.6 (name "Foo.Bar")) + (ty-tag-union @2.12-2.15 + (ty-tag-name @2.13-2.14 (name "B")))) + (s-nominal-decl @3.9-5.10 + (ty-header @3.9-5.10 (name "Foo.Bar.Baz")) + (ty-tag-union @3.16-3.19 + (ty-tag-name @3.17-3.18 (name "C")))) + (s-nominal-decl @4.13-4.29 + (ty-header @4.13-4.29 (name "Foo.Bar.Baz.Qux")) + (ty-tag-union @4.20-4.29 + (ty-tag-name @4.21-4.22 (name "X")) + (ty-tag-name @4.24-4.25 (name "Y")) + (ty-tag-name @4.27-4.28 (name "Z"))))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @10.1-10.6 (type "Foo.Bar.Baz.Qux"))) + (type_decls + (nominal @1.1-7.2 (type "Foo") + (ty-header @1.1-1.4 (name "Foo"))) + (nominal @2.5-6.6 (type "Foo.Bar") + (ty-header @2.5-6.6 (name "Foo.Bar"))) + (nominal @3.9-5.10 (type "Foo.Bar.Baz") + (ty-header @3.9-5.10 (name "Foo.Bar.Baz"))) + (nominal @4.13-4.29 (type "Foo.Bar.Baz.Qux") + (ty-header @4.13-4.29 (name "Foo.Bar.Baz.Qux")))) + (expressions + (expr @10.9-10.26 (type "Foo.Bar.Baz.Qux")))) +~~~ diff --git a/test/snapshots/nominal/nominal_import_long_package.md b/test/snapshots/nominal/nominal_import_long_package.md index 117abf920e..2ae8f64678 100644 --- a/test/snapshots/nominal/nominal_import_long_package.md +++ b/test/snapshots/nominal/nominal_import_long_package.md @@ -1,31 +1,29 @@ # META ~~~ini description=Example of importing a nominal tag union from a module within a package, and renaming it using `as` -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [red] - import design.Styles.Color exposing [Encoder as CE] red : CE red = ... # not implemented ~~~ # EXPECTED -PARSE ERROR - nominal_import_long_package.md:3:21:3:27 -PARSE ERROR - nominal_import_long_package.md:3:28:3:36 -PARSE ERROR - nominal_import_long_package.md:3:37:3:38 -PARSE ERROR - nominal_import_long_package.md:3:46:3:48 -PARSE ERROR - nominal_import_long_package.md:3:51:3:52 -MODULE NOT FOUND - nominal_import_long_package.md:3:1:3:21 -UNDECLARED TYPE - nominal_import_long_package.md:5:7:5:9 +PARSE ERROR - nominal_import_long_package.md:1:21:1:27 +PARSE ERROR - nominal_import_long_package.md:1:28:1:36 +PARSE ERROR - nominal_import_long_package.md:1:37:1:38 +PARSE ERROR - nominal_import_long_package.md:1:46:1:48 +PARSE ERROR - nominal_import_long_package.md:1:51:1:52 +MODULE NOT FOUND - nominal_import_long_package.md:1:1:1:21 +UNDECLARED TYPE - nominal_import_long_package.md:3:7:3:9 # PROBLEMS **PARSE ERROR** A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**nominal_import_long_package.md:3:21:3:27:** +**nominal_import_long_package.md:1:21:1:27:** ```roc import design.Styles.Color exposing [Encoder as CE] ``` @@ -36,7 +34,7 @@ import design.Styles.Color exposing [Encoder as CE] A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**nominal_import_long_package.md:3:28:3:36:** +**nominal_import_long_package.md:1:28:1:36:** ```roc import design.Styles.Color exposing [Encoder as CE] ``` @@ -47,7 +45,7 @@ import design.Styles.Color exposing [Encoder as CE] A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**nominal_import_long_package.md:3:37:3:38:** +**nominal_import_long_package.md:1:37:1:38:** ```roc import design.Styles.Color exposing [Encoder as CE] ``` @@ -70,7 +68,7 @@ Other valid examples: `Result(a, Str)` `Maybe(List(U64))` -**nominal_import_long_package.md:3:46:3:48:** +**nominal_import_long_package.md:1:46:1:48:** ```roc import design.Styles.Color exposing [Encoder as CE] ``` @@ -93,7 +91,7 @@ Other valid examples: `Result(a, Str)` `Maybe(List(U64))` -**nominal_import_long_package.md:3:51:3:52:** +**nominal_import_long_package.md:1:51:1:52:** ```roc import design.Styles.Color exposing [Encoder as CE] ``` @@ -104,7 +102,7 @@ import design.Styles.Color exposing [Encoder as CE] The module `design.Styles` was not found in this Roc project. You're attempting to use this module here: -**nominal_import_long_package.md:3:1:3:21:** +**nominal_import_long_package.md:1:1:1:21:** ```roc import design.Styles.Color exposing [Encoder as CE] ``` @@ -115,7 +113,7 @@ import design.Styles.Color exposing [Encoder as CE] The type _CE_ is not declared in this scope. This type is referenced here: -**nominal_import_long_package.md:5:7:5:9:** +**nominal_import_long_package.md:3:7:3:9:** ```roc red : CE ``` @@ -124,36 +122,30 @@ red : CE # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:12),CloseSquare(1:12-1:13), -KwImport(3:1-3:7),LowerIdent(3:8-3:14),NoSpaceDotUpperIdent(3:14-3:21),NoSpaceDotUpperIdent(3:21-3:27),KwExposing(3:28-3:36),OpenSquare(3:37-3:38),UpperIdent(3:38-3:45),KwAs(3:46-3:48),UpperIdent(3:49-3:51),CloseSquare(3:51-3:52), -LowerIdent(5:1-5:4),OpColon(5:5-5:6),UpperIdent(5:7-5:9), -LowerIdent(6:1-6:4),OpAssign(6:5-6:6),TripleDot(6:7-6:10), -EndOfFile(7:1-7:1), +KwImport(1:1-1:7),LowerIdent(1:8-1:14),NoSpaceDotUpperIdent(1:14-1:21),NoSpaceDotUpperIdent(1:21-1:27),KwExposing(1:28-1:36),OpenSquare(1:37-1:38),UpperIdent(1:38-1:45),KwAs(1:46-1:48),UpperIdent(1:49-1:51),CloseSquare(1:51-1:52), +LowerIdent(3:1-3:4),OpColon(3:5-3:6),UpperIdent(3:7-3:9), +LowerIdent(4:1-4:4),OpAssign(4:5-4:6),TripleDot(4:7-4:10), +EndOfFile(5:1-5:1), ~~~ # PARSE ~~~clojure -(file @1.1-6.10 - (module @1.1-1.13 - (exposes @1.8-1.13 - (exposed-lower-ident @1.9-1.12 - (text "red")))) +(file @1.1-4.10 + (type-module @1.1-1.7) (statements - (s-import @3.1-3.21 (raw "design.Styles")) - (s-malformed @3.21-3.27 (tag "statement_unexpected_token")) - (s-malformed @3.28-3.36 (tag "statement_unexpected_token")) - (s-malformed @3.37-3.38 (tag "statement_unexpected_token")) - (s-malformed @3.46-3.48 (tag "expected_colon_after_type_annotation")) - (s-malformed @3.51-3.52 (tag "expected_colon_after_type_annotation")) - (s-type-anno @5.1-5.9 (name "red") - (ty @5.7-5.9 (name "CE"))) - (s-decl @6.1-6.10 - (p-ident @6.1-6.4 (raw "red")) + (s-import @1.1-1.21 (raw "design.Styles")) + (s-malformed @1.21-1.27 (tag "statement_unexpected_token")) + (s-malformed @1.28-1.36 (tag "statement_unexpected_token")) + (s-malformed @1.37-1.38 (tag "statement_unexpected_token")) + (s-malformed @1.46-1.48 (tag "expected_colon_after_type_annotation")) + (s-malformed @1.51-1.52 (tag "expected_colon_after_type_annotation")) + (s-type-anno @3.1-3.9 (name "red") + (ty @3.7-3.9 (name "CE"))) + (s-decl @4.1-4.10 + (p-ident @4.1-4.4 (raw "red")) (e-ellipsis)))) ~~~ # FORMATTED ~~~roc -module [red] - import design.Styles @@ -164,19 +156,19 @@ red = ... # not implemented ~~~clojure (can-ir (d-let - (p-assign @6.1-6.4 (ident "red")) + (p-assign @4.1-4.4 (ident "red")) (e-not-implemented @1.1-1.1) - (annotation @6.1-6.4 + (annotation @4.1-4.4 (declared-type - (ty @5.7-5.9 (name "CE"))))) - (s-import @3.1-3.21 (module "design.Styles") (qualifier "design") + (ty-malformed @3.7-3.9)))) + (s-import @1.1-1.21 (module "design.Styles") (qualifier "design") (exposes))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @6.1-6.4 (type "Error"))) + (patt @4.1-4.4 (type "Error"))) (expressions (expr @1.1-1.1 (type "Error")))) ~~~ diff --git a/test/snapshots/nominal/nominal_import_type.md b/test/snapshots/nominal/nominal_import_type.md index c4972e83fa..db32c40117 100644 --- a/test/snapshots/nominal/nominal_import_type.md +++ b/test/snapshots/nominal/nominal_import_type.md @@ -1,25 +1,23 @@ # META ~~~ini description=Example of importing a nominal tag union from another module -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [red] - import Color red : Color.RGB red = Color.RGB.Red ~~~ # EXPECTED -MODULE NOT FOUND - nominal_import_type.md:3:1:3:13 +MODULE NOT FOUND - nominal_import_type.md:1:1:1:13 # PROBLEMS **MODULE NOT FOUND** The module `Color` was not found in this Roc project. You're attempting to use this module here: -**nominal_import_type.md:3:1:3:13:** +**nominal_import_type.md:1:1:1:13:** ```roc import Color ``` @@ -28,26 +26,22 @@ import Color # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:12),CloseSquare(1:12-1:13), -KwImport(3:1-3:7),UpperIdent(3:8-3:13), -LowerIdent(5:1-5:4),OpColon(5:5-5:6),UpperIdent(5:7-5:12),NoSpaceDotUpperIdent(5:12-5:16), -LowerIdent(6:1-6:4),OpAssign(6:5-6:6),UpperIdent(6:7-6:12),NoSpaceDotUpperIdent(6:12-6:16),NoSpaceDotUpperIdent(6:16-6:20), -EndOfFile(7:1-7:1), +KwImport(1:1-1:7),UpperIdent(1:8-1:13), +LowerIdent(3:1-3:4),OpColon(3:5-3:6),UpperIdent(3:7-3:12),NoSpaceDotUpperIdent(3:12-3:16), +LowerIdent(4:1-4:4),OpAssign(4:5-4:6),UpperIdent(4:7-4:12),NoSpaceDotUpperIdent(4:12-4:16),NoSpaceDotUpperIdent(4:16-4:20), +EndOfFile(5:1-5:1), ~~~ # PARSE ~~~clojure -(file @1.1-6.20 - (module @1.1-1.13 - (exposes @1.8-1.13 - (exposed-lower-ident @1.9-1.12 - (text "red")))) +(file @1.1-4.20 + (type-module @1.1-1.7) (statements - (s-import @3.1-3.13 (raw "Color")) - (s-type-anno @5.1-5.16 (name "red") - (ty @5.7-5.16 (name "Color.RGB"))) - (s-decl @6.1-6.20 - (p-ident @6.1-6.4 (raw "red")) - (e-tag @6.7-6.20 (raw "Color.RGB.Red"))))) + (s-import @1.1-1.13 (raw "Color")) + (s-type-anno @3.1-3.16 (name "red") + (ty @3.7-3.16 (name "Color.RGB"))) + (s-decl @4.1-4.20 + (p-ident @4.1-4.4 (raw "red")) + (e-tag @4.7-4.20 (raw "Color.RGB.Red"))))) ~~~ # FORMATTED ~~~roc @@ -57,24 +51,22 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @6.1-6.4 (ident "red")) - (e-nominal-external @6.7-6.20 - (module-idx "0") + (p-assign @4.1-4.4 (ident "red")) + (e-nominal-external @4.7-4.20 + (module-idx "2") (target-node-idx "0") - (e-tag @6.7-6.20 (name "Red"))) - (annotation @6.1-6.4 + (e-tag @4.7-4.20 (name "Red"))) + (annotation @4.1-4.4 (declared-type - (ty-lookup-external @5.7-5.16 - (module-idx "0") - (target-node-idx "0"))))) - (s-import @3.1-3.13 (module "Color") + (ty-lookup @3.7-3.16 (name "RGB") (external (module-idx "2") (target-node-idx "0")))))) + (s-import @1.1-1.13 (module "Color") (exposes))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @6.1-6.4 (type "Error"))) + (patt @4.1-4.4 (type "Error"))) (expressions - (expr @6.7-6.20 (type "Error")))) + (expr @4.7-4.20 (type "Error")))) ~~~ diff --git a/test/snapshots/nominal/nominal_import_wildcard.md b/test/snapshots/nominal/nominal_import_wildcard.md index cf2eea49a7..5e737ffec6 100644 --- a/test/snapshots/nominal/nominal_import_wildcard.md +++ b/test/snapshots/nominal/nominal_import_wildcard.md @@ -1,12 +1,10 @@ # META ~~~ini description=Example of importing constructors with wildcard from a nominal tag union -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [red, green, blue] - import Color.* red : Color @@ -19,17 +17,17 @@ green : Color green = Green ~~~ # EXPECTED -PARSE ERROR - nominal_import_wildcard.md:3:13:3:15 -MODULE NOT FOUND - nominal_import_wildcard.md:3:1:3:13 -UNDECLARED TYPE - nominal_import_wildcard.md:5:7:5:12 -UNDECLARED TYPE - nominal_import_wildcard.md:8:8:8:13 -UNDECLARED TYPE - nominal_import_wildcard.md:11:9:11:14 +PARSE ERROR - nominal_import_wildcard.md:1:13:1:15 +MODULE NOT FOUND - nominal_import_wildcard.md:1:1:1:13 +UNDECLARED TYPE - nominal_import_wildcard.md:3:7:3:12 +UNDECLARED TYPE - nominal_import_wildcard.md:6:8:6:13 +UNDECLARED TYPE - nominal_import_wildcard.md:9:9:9:14 # PROBLEMS **PARSE ERROR** A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**nominal_import_wildcard.md:3:13:3:15:** +**nominal_import_wildcard.md:1:13:1:15:** ```roc import Color.* ``` @@ -40,7 +38,7 @@ import Color.* The module `Color` was not found in this Roc project. You're attempting to use this module here: -**nominal_import_wildcard.md:3:1:3:13:** +**nominal_import_wildcard.md:1:1:1:13:** ```roc import Color.* ``` @@ -51,7 +49,7 @@ import Color.* The type _Color_ is not declared in this scope. This type is referenced here: -**nominal_import_wildcard.md:5:7:5:12:** +**nominal_import_wildcard.md:3:7:3:12:** ```roc red : Color ``` @@ -62,7 +60,7 @@ red : Color The type _Color_ is not declared in this scope. This type is referenced here: -**nominal_import_wildcard.md:8:8:8:13:** +**nominal_import_wildcard.md:6:8:6:13:** ```roc blue : Color ``` @@ -73,7 +71,7 @@ blue : Color The type _Color_ is not declared in this scope. This type is referenced here: -**nominal_import_wildcard.md:11:9:11:14:** +**nominal_import_wildcard.md:9:9:9:14:** ```roc green : Color ``` @@ -82,50 +80,40 @@ green : Color # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:12),Comma(1:12-1:13),LowerIdent(1:14-1:19),Comma(1:19-1:20),LowerIdent(1:21-1:25),CloseSquare(1:25-1:26), -KwImport(3:1-3:7),UpperIdent(3:8-3:13),DotStar(3:13-3:15), -LowerIdent(5:1-5:4),OpColon(5:5-5:6),UpperIdent(5:7-5:12), -LowerIdent(6:1-6:4),OpAssign(6:5-6:6),UpperIdent(6:7-6:10), -LowerIdent(8:1-8:5),OpColon(8:6-8:7),UpperIdent(8:8-8:13), -LowerIdent(9:1-9:5),OpAssign(9:6-9:7),UpperIdent(9:8-9:12), -LowerIdent(11:1-11:6),OpColon(11:7-11:8),UpperIdent(11:9-11:14), -LowerIdent(12:1-12:6),OpAssign(12:7-12:8),UpperIdent(12:9-12:14), -EndOfFile(13:1-13:1), +KwImport(1:1-1:7),UpperIdent(1:8-1:13),DotStar(1:13-1:15), +LowerIdent(3:1-3:4),OpColon(3:5-3:6),UpperIdent(3:7-3:12), +LowerIdent(4:1-4:4),OpAssign(4:5-4:6),UpperIdent(4:7-4:10), +LowerIdent(6:1-6:5),OpColon(6:6-6:7),UpperIdent(6:8-6:13), +LowerIdent(7:1-7:5),OpAssign(7:6-7:7),UpperIdent(7:8-7:12), +LowerIdent(9:1-9:6),OpColon(9:7-9:8),UpperIdent(9:9-9:14), +LowerIdent(10:1-10:6),OpAssign(10:7-10:8),UpperIdent(10:9-10:14), +EndOfFile(11:1-11:1), ~~~ # PARSE ~~~clojure -(file @1.1-12.14 - (module @1.1-1.26 - (exposes @1.8-1.26 - (exposed-lower-ident @1.9-1.12 - (text "red")) - (exposed-lower-ident @1.14-1.19 - (text "green")) - (exposed-lower-ident @1.21-1.25 - (text "blue")))) +(file @1.1-10.14 + (type-module @1.1-1.7) (statements - (s-import @3.1-3.13 (raw "Color")) - (s-malformed @3.13-3.15 (tag "statement_unexpected_token")) - (s-type-anno @5.1-5.12 (name "red") - (ty @5.7-5.12 (name "Color"))) - (s-decl @6.1-6.10 - (p-ident @6.1-6.4 (raw "red")) - (e-tag @6.7-6.10 (raw "Red"))) - (s-type-anno @8.1-8.13 (name "blue") - (ty @8.8-8.13 (name "Color"))) - (s-decl @9.1-9.12 - (p-ident @9.1-9.5 (raw "blue")) - (e-tag @9.8-9.12 (raw "Blue"))) - (s-type-anno @11.1-11.14 (name "green") - (ty @11.9-11.14 (name "Color"))) - (s-decl @12.1-12.14 - (p-ident @12.1-12.6 (raw "green")) - (e-tag @12.9-12.14 (raw "Green"))))) + (s-import @1.1-1.13 (raw "Color")) + (s-malformed @1.13-1.15 (tag "statement_unexpected_token")) + (s-type-anno @3.1-3.12 (name "red") + (ty @3.7-3.12 (name "Color"))) + (s-decl @4.1-4.10 + (p-ident @4.1-4.4 (raw "red")) + (e-tag @4.7-4.10 (raw "Red"))) + (s-type-anno @6.1-6.13 (name "blue") + (ty @6.8-6.13 (name "Color"))) + (s-decl @7.1-7.12 + (p-ident @7.1-7.5 (raw "blue")) + (e-tag @7.8-7.12 (raw "Blue"))) + (s-type-anno @9.1-9.14 (name "green") + (ty @9.9-9.14 (name "Color"))) + (s-decl @10.1-10.14 + (p-ident @10.1-10.6 (raw "green")) + (e-tag @10.9-10.14 (raw "Green"))))) ~~~ # FORMATTED ~~~roc -module [red, green, blue] - import Color @@ -142,35 +130,35 @@ green = Green ~~~clojure (can-ir (d-let - (p-assign @6.1-6.4 (ident "red")) - (e-tag @6.7-6.10 (name "Red")) - (annotation @6.1-6.4 + (p-assign @4.1-4.4 (ident "red")) + (e-tag @4.7-4.10 (name "Red")) + (annotation @4.1-4.4 (declared-type - (ty @5.7-5.12 (name "Color"))))) + (ty-malformed @3.7-3.12)))) (d-let - (p-assign @9.1-9.5 (ident "blue")) - (e-tag @9.8-9.12 (name "Blue")) - (annotation @9.1-9.5 + (p-assign @7.1-7.5 (ident "blue")) + (e-tag @7.8-7.12 (name "Blue")) + (annotation @7.1-7.5 (declared-type - (ty @8.8-8.13 (name "Color"))))) + (ty-malformed @6.8-6.13)))) (d-let - (p-assign @12.1-12.6 (ident "green")) - (e-tag @12.9-12.14 (name "Green")) - (annotation @12.1-12.6 + (p-assign @10.1-10.6 (ident "green")) + (e-tag @10.9-10.14 (name "Green")) + (annotation @10.1-10.6 (declared-type - (ty @11.9-11.14 (name "Color"))))) - (s-import @3.1-3.13 (module "Color") + (ty-malformed @9.9-9.14)))) + (s-import @1.1-1.13 (module "Color") (exposes))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @6.1-6.4 (type "Error")) - (patt @9.1-9.5 (type "Error")) - (patt @12.1-12.6 (type "Error"))) + (patt @4.1-4.4 (type "Error")) + (patt @7.1-7.5 (type "Error")) + (patt @10.1-10.6 (type "Error"))) (expressions - (expr @6.7-6.10 (type "Error")) - (expr @9.8-9.12 (type "Error")) - (expr @12.9-12.14 (type "Error")))) + (expr @4.7-4.10 (type "Error")) + (expr @7.8-7.12 (type "Error")) + (expr @10.9-10.14 (type "Error")))) ~~~ diff --git a/test/snapshots/nominal/nominal_mixed_scope.md b/test/snapshots/nominal/nominal_mixed_scope.md index 7211ee9108..b7c695eda1 100644 --- a/test/snapshots/nominal/nominal_mixed_scope.md +++ b/test/snapshots/nominal/nominal_mixed_scope.md @@ -1,12 +1,10 @@ # META ~~~ini description=Example of mixed local and external nominal types in same scope -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [LocalStatus, processColor] - LocalStatus := [Pending, Complete] processColor : _ -> LocalStatus @@ -23,18 +21,18 @@ processColor = |color| { } ~~~ # EXPECTED -IMPORT MUST BE TOP LEVEL - nominal_mixed_scope.md:9:5:9:11 +IMPORT MUST BE TOP LEVEL - nominal_mixed_scope.md:7:5:7:11 NOT IMPLEMENTED - :0:0:0:0 -UNDECLARED TYPE - nominal_mixed_scope.md:9:12:9:17 +UNDECLARED TYPE - nominal_mixed_scope.md:7:12:7:17 +UNDECLARED TYPE - nominal_mixed_scope.md:10:9:10:12 +UNDECLARED TYPE - nominal_mixed_scope.md:11:9:11:12 UNDECLARED TYPE - nominal_mixed_scope.md:12:9:12:12 -UNDECLARED TYPE - nominal_mixed_scope.md:13:9:13:12 -UNDECLARED TYPE - nominal_mixed_scope.md:14:9:14:12 # PROBLEMS **IMPORT MUST BE TOP LEVEL** Import statements must appear at the top level of a module. Move this import to the top of the file, after the module header but before any definitions. -**nominal_mixed_scope.md:9:5:9:11:** +**nominal_mixed_scope.md:7:5:7:11:** ```roc import Color.RGB ``` @@ -50,7 +48,7 @@ This error doesn't have a proper diagnostic report yet. Let us know if you want The type _Color_ is not declared in this scope. This type is referenced here: -**nominal_mixed_scope.md:9:12:9:17:** +**nominal_mixed_scope.md:7:12:7:17:** ```roc import Color.RGB ``` @@ -61,7 +59,7 @@ This type is referenced here: The type _RGB_ is not declared in this scope. This type is referenced here: -**nominal_mixed_scope.md:12:9:12:12:** +**nominal_mixed_scope.md:10:9:10:12:** ```roc RGB.Red => LocalStatus.Pending ``` @@ -72,7 +70,7 @@ This type is referenced here: The type _RGB_ is not declared in this scope. This type is referenced here: -**nominal_mixed_scope.md:13:9:13:12:** +**nominal_mixed_scope.md:11:9:11:12:** ```roc RGB.Green => LocalStatus.Complete ``` @@ -83,7 +81,7 @@ This type is referenced here: The type _RGB_ is not declared in this scope. This type is referenced here: -**nominal_mixed_scope.md:14:9:14:12:** +**nominal_mixed_scope.md:12:9:12:12:** ```roc RGB.Blue => LocalStatus.Pending ``` @@ -92,65 +90,58 @@ This type is referenced here: # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:20),Comma(1:20-1:21),LowerIdent(1:22-1:34),CloseSquare(1:34-1:35), -UpperIdent(3:1-3:12),OpColonEqual(3:13-3:15),OpenSquare(3:16-3:17),UpperIdent(3:17-3:24),Comma(3:24-3:25),UpperIdent(3:26-3:34),CloseSquare(3:34-3:35), -LowerIdent(5:1-5:13),OpColon(5:14-5:15),Underscore(5:16-5:17),OpArrow(5:18-5:20),UpperIdent(5:21-5:32), -LowerIdent(6:1-6:13),OpAssign(6:14-6:15),OpBar(6:16-6:17),LowerIdent(6:17-6:22),OpBar(6:22-6:23),OpenCurly(6:24-6:25), -KwImport(9:5-9:11),UpperIdent(9:12-9:17),NoSpaceDotUpperIdent(9:17-9:21), -KwMatch(11:5-11:10),LowerIdent(11:11-11:16),OpenCurly(11:17-11:18), -UpperIdent(12:9-12:12),NoSpaceDotUpperIdent(12:12-12:16),OpFatArrow(12:17-12:19),UpperIdent(12:20-12:31),NoSpaceDotUpperIdent(12:31-12:39), -UpperIdent(13:9-13:12),NoSpaceDotUpperIdent(13:12-13:18),OpFatArrow(13:19-13:21),UpperIdent(13:22-13:33),NoSpaceDotUpperIdent(13:33-13:42), -UpperIdent(14:9-14:12),NoSpaceDotUpperIdent(14:12-14:17),OpFatArrow(14:18-14:20),UpperIdent(14:21-14:32),NoSpaceDotUpperIdent(14:32-14:40), -CloseCurly(15:5-15:6), -CloseCurly(16:1-16:2), -EndOfFile(17:1-17:1), +UpperIdent(1:1-1:12),OpColonEqual(1:13-1:15),OpenSquare(1:16-1:17),UpperIdent(1:17-1:24),Comma(1:24-1:25),UpperIdent(1:26-1:34),CloseSquare(1:34-1:35), +LowerIdent(3:1-3:13),OpColon(3:14-3:15),Underscore(3:16-3:17),OpArrow(3:18-3:20),UpperIdent(3:21-3:32), +LowerIdent(4:1-4:13),OpAssign(4:14-4:15),OpBar(4:16-4:17),LowerIdent(4:17-4:22),OpBar(4:22-4:23),OpenCurly(4:24-4:25), +KwImport(7:5-7:11),UpperIdent(7:12-7:17),NoSpaceDotUpperIdent(7:17-7:21), +KwMatch(9:5-9:10),LowerIdent(9:11-9:16),OpenCurly(9:17-9:18), +UpperIdent(10:9-10:12),NoSpaceDotUpperIdent(10:12-10:16),OpFatArrow(10:17-10:19),UpperIdent(10:20-10:31),NoSpaceDotUpperIdent(10:31-10:39), +UpperIdent(11:9-11:12),NoSpaceDotUpperIdent(11:12-11:18),OpFatArrow(11:19-11:21),UpperIdent(11:22-11:33),NoSpaceDotUpperIdent(11:33-11:42), +UpperIdent(12:9-12:12),NoSpaceDotUpperIdent(12:12-12:17),OpFatArrow(12:18-12:20),UpperIdent(12:21-12:32),NoSpaceDotUpperIdent(12:32-12:40), +CloseCurly(13:5-13:6), +CloseCurly(14:1-14:2), +EndOfFile(15:1-15:1), ~~~ # PARSE ~~~clojure -(file @1.1-16.2 - (module @1.1-1.35 - (exposes @1.8-1.35 - (exposed-upper-ident @1.9-1.20 (text "LocalStatus")) - (exposed-lower-ident @1.22-1.34 - (text "processColor")))) +(file @1.1-14.2 + (type-module @1.1-1.12) (statements - (s-type-decl @3.1-3.35 - (header @3.1-3.12 (name "LocalStatus") + (s-type-decl @1.1-1.35 + (header @1.1-1.12 (name "LocalStatus") (args)) - (ty-tag-union @3.16-3.35 + (ty-tag-union @1.16-1.35 (tags - (ty @3.17-3.24 (name "Pending")) - (ty @3.26-3.34 (name "Complete"))))) - (s-type-anno @5.1-5.32 (name "processColor") - (ty-fn @5.16-5.32 + (ty @1.17-1.24 (name "Pending")) + (ty @1.26-1.34 (name "Complete"))))) + (s-type-anno @3.1-3.32 (name "processColor") + (ty-fn @3.16-3.32 (_) - (ty @5.21-5.32 (name "LocalStatus")))) - (s-decl @6.1-16.2 - (p-ident @6.1-6.13 (raw "processColor")) - (e-lambda @6.16-16.2 + (ty @3.21-3.32 (name "LocalStatus")))) + (s-decl @4.1-14.2 + (p-ident @4.1-4.13 (raw "processColor")) + (e-lambda @4.16-14.2 (args - (p-ident @6.17-6.22 (raw "color"))) - (e-block @6.24-16.2 + (p-ident @4.17-4.22 (raw "color"))) + (e-block @4.24-14.2 (statements - (s-malformed @9.5-9.11 (tag "import_must_be_top_level")) - (e-tag @9.12-9.21 (raw "Color.RGB")) + (s-malformed @7.5-7.11 (tag "import_must_be_top_level")) + (e-tag @7.12-7.21 (raw "Color.RGB")) (e-match - (e-ident @11.11-11.16 (raw "color")) + (e-ident @9.11-9.16 (raw "color")) (branches - (branch @12.9-12.39 - (p-tag @12.9-12.16 (raw ".Red")) - (e-tag @12.20-12.39 (raw "LocalStatus.Pending"))) - (branch @13.9-13.42 - (p-tag @13.9-13.18 (raw ".Green")) - (e-tag @13.22-13.42 (raw "LocalStatus.Complete"))) - (branch @14.9-14.40 - (p-tag @14.9-14.17 (raw ".Blue")) - (e-tag @14.21-14.40 (raw "LocalStatus.Pending"))))))))))) + (branch @10.9-10.39 + (p-tag @10.9-10.16 (raw ".Red")) + (e-tag @10.20-10.39 (raw "LocalStatus.Pending"))) + (branch @11.9-11.42 + (p-tag @11.9-11.18 (raw ".Green")) + (e-tag @11.22-11.42 (raw "LocalStatus.Complete"))) + (branch @12.9-12.40 + (p-tag @12.9-12.17 (raw ".Blue")) + (e-tag @12.21-12.40 (raw "LocalStatus.Pending"))))))))))) ~~~ # FORMATTED ~~~roc -module [LocalStatus, processColor] - LocalStatus := [Pending, Complete] processColor : _ -> LocalStatus @@ -170,60 +161,60 @@ processColor = |color| { ~~~clojure (can-ir (d-let - (p-assign @6.1-6.13 (ident "processColor")) - (e-lambda @6.16-16.2 + (p-assign @4.1-4.13 (ident "processColor")) + (e-lambda @4.16-14.2 (args - (p-assign @6.17-6.22 (ident "color"))) - (e-block @6.24-16.2 + (p-assign @4.17-4.22 (ident "color"))) + (e-block @4.24-14.2 (s-runtime-error (tag "not_implemented")) - (s-expr @9.12-9.21 + (s-expr @7.12-7.21 (e-runtime-error (tag "undeclared_type"))) - (e-match @11.5-15.6 - (match @11.5-15.6 + (e-match @9.5-13.6 + (match @9.5-13.6 (cond - (e-lookup-local @11.11-11.16 - (p-assign @6.17-6.22 (ident "color")))) + (e-lookup-local @9.11-9.16 + (p-assign @4.17-4.22 (ident "color")))) (branches + (branch + (patterns + (pattern (degenerate false) + (p-runtime-error @10.9-10.12 (tag "undeclared_type")))) + (value + (e-nominal @10.20-10.39 (nominal "LocalStatus") + (e-tag @10.20-10.39 (name "Pending"))))) + (branch + (patterns + (pattern (degenerate false) + (p-runtime-error @11.9-11.12 (tag "undeclared_type")))) + (value + (e-nominal @11.22-11.42 (nominal "LocalStatus") + (e-tag @11.22-11.42 (name "Complete"))))) (branch (patterns (pattern (degenerate false) (p-runtime-error @12.9-12.12 (tag "undeclared_type")))) (value - (e-nominal @12.20-12.39 (nominal "LocalStatus") - (e-tag @12.20-12.39 (name "Pending"))))) - (branch - (patterns - (pattern (degenerate false) - (p-runtime-error @13.9-13.12 (tag "undeclared_type")))) - (value - (e-nominal @13.22-13.42 (nominal "LocalStatus") - (e-tag @13.22-13.42 (name "Complete"))))) - (branch - (patterns - (pattern (degenerate false) - (p-runtime-error @14.9-14.12 (tag "undeclared_type")))) - (value - (e-nominal @14.21-14.40 (nominal "LocalStatus") - (e-tag @14.21-14.40 (name "Pending")))))))))) - (annotation @6.1-6.13 + (e-nominal @12.21-12.40 (nominal "LocalStatus") + (e-tag @12.21-12.40 (name "Pending")))))))))) + (annotation @4.1-4.13 (declared-type - (ty-fn @5.16-5.32 (effectful false) + (ty-fn @3.16-3.32 (effectful false) (ty-underscore @1.1-1.1) - (ty @5.21-5.32 (name "LocalStatus")))))) - (s-nominal-decl @3.1-3.35 - (ty-header @3.1-3.12 (name "LocalStatus")) - (ty-tag-union @3.16-3.35 - (ty @3.17-3.24 (name "Pending")) - (ty @3.26-3.34 (name "Complete"))))) + (ty-lookup @3.21-3.32 (name "LocalStatus") (local)))))) + (s-nominal-decl @1.1-1.35 + (ty-header @1.1-1.12 (name "LocalStatus")) + (ty-tag-union @1.16-1.35 + (ty-tag-name @1.17-1.24 (name "Pending")) + (ty-tag-name @1.26-1.34 (name "Complete"))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @6.1-6.13 (type "Error -> LocalStatus"))) + (patt @4.1-4.13 (type "_arg -> LocalStatus"))) (type_decls - (nominal @3.1-3.35 (type "LocalStatus") - (ty-header @3.1-3.12 (name "LocalStatus")))) + (nominal @1.1-1.35 (type "LocalStatus") + (ty-header @1.1-1.12 (name "LocalStatus")))) (expressions - (expr @6.16-16.2 (type "Error -> LocalStatus")))) + (expr @4.16-14.2 (type "_arg -> LocalStatus")))) ~~~ diff --git a/test/snapshots/nominal/nominal_nested_type_ref.md b/test/snapshots/nominal/nominal_nested_type_ref.md new file mode 100644 index 0000000000..3d65de2bd4 --- /dev/null +++ b/test/snapshots/nominal/nominal_nested_type_ref.md @@ -0,0 +1,96 @@ +# META +~~~ini +description=Type annotation referencing nested type directly +type=snippet +~~~ +# SOURCE +~~~roc +Foo := [Whatever].{ + Bar := [X, Y, Z] +} + +x : Foo.Bar +x = Foo.Bar.X +~~~ +# EXPECTED +NIL +# PROBLEMS +NIL +# TOKENS +~~~zig +UpperIdent(1:1-1:4),OpColonEqual(1:5-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:17),CloseSquare(1:17-1:18),Dot(1:18-1:19),OpenCurly(1:19-1:20), +UpperIdent(2:5-2:8),OpColonEqual(2:9-2:11),OpenSquare(2:12-2:13),UpperIdent(2:13-2:14),Comma(2:14-2:15),UpperIdent(2:16-2:17),Comma(2:17-2:18),UpperIdent(2:19-2:20),CloseSquare(2:20-2:21), +CloseCurly(3:1-3:2), +LowerIdent(5:1-5:2),OpColon(5:3-5:4),UpperIdent(5:5-5:8),NoSpaceDotUpperIdent(5:8-5:12), +LowerIdent(6:1-6:2),OpAssign(6:3-6:4),UpperIdent(6:5-6:8),NoSpaceDotUpperIdent(6:8-6:12),NoSpaceDotUpperIdent(6:12-6:14), +EndOfFile(7:1-7:1), +~~~ +# PARSE +~~~clojure +(file @1.1-6.14 + (type-module @1.1-1.4) + (statements + (s-type-decl @1.1-3.2 + (header @1.1-1.4 (name "Foo") + (args)) + (ty-tag-union @1.8-1.18 + (tags + (ty @1.9-1.17 (name "Whatever")))) + (associated @1.19-3.2 + (s-type-decl @2.5-2.21 + (header @2.5-2.8 (name "Bar") + (args)) + (ty-tag-union @2.12-2.21 + (tags + (ty @2.13-2.14 (name "X")) + (ty @2.16-2.17 (name "Y")) + (ty @2.19-2.20 (name "Z"))))))) + (s-type-anno @5.1-5.12 (name "x") + (ty @5.5-5.12 (name "Foo.Bar"))) + (s-decl @6.1-6.14 + (p-ident @6.1-6.2 (raw "x")) + (e-tag @6.5-6.14 (raw "Foo.Bar.X"))))) +~~~ +# FORMATTED +~~~roc +Foo := [Whatever].{ + Bar := [X, Y, Z] +} + +x : Foo.Bar +x = Foo.Bar.X +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @6.1-6.2 (ident "x")) + (e-nominal @6.5-6.14 (nominal "Foo.Bar") + (e-tag @6.5-6.14 (name "X"))) + (annotation @6.1-6.2 + (declared-type + (ty-lookup @5.5-5.12 (name "Foo.Bar") (local))))) + (s-nominal-decl @1.1-3.2 + (ty-header @1.1-1.4 (name "Foo")) + (ty-tag-union @1.8-1.18 + (ty-tag-name @1.9-1.17 (name "Whatever")))) + (s-nominal-decl @2.5-2.21 + (ty-header @2.5-2.21 (name "Foo.Bar")) + (ty-tag-union @2.12-2.21 + (ty-tag-name @2.13-2.14 (name "X")) + (ty-tag-name @2.16-2.17 (name "Y")) + (ty-tag-name @2.19-2.20 (name "Z"))))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @6.1-6.2 (type "Foo.Bar"))) + (type_decls + (nominal @1.1-3.2 (type "Foo") + (ty-header @1.1-1.4 (name "Foo"))) + (nominal @2.5-2.21 (type "Foo.Bar") + (ty-header @2.5-2.21 (name "Foo.Bar")))) + (expressions + (expr @6.5-6.14 (type "Foo.Bar")))) +~~~ diff --git a/test/snapshots/nominal/nominal_nested_types.md b/test/snapshots/nominal/nominal_nested_types.md new file mode 100644 index 0000000000..1a4b4a3fd9 --- /dev/null +++ b/test/snapshots/nominal/nominal_nested_types.md @@ -0,0 +1,96 @@ +# META +~~~ini +description=Nested types in associated blocks +type=file:Foo.roc +~~~ +# SOURCE +~~~roc +Foo := [Whatever].{ + Bar := [Something].{ + y = 6 + } + x = 5 +} +~~~ +# EXPECTED +NIL +# PROBLEMS +NIL +# TOKENS +~~~zig +UpperIdent(1:1-1:4),OpColonEqual(1:5-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:17),CloseSquare(1:17-1:18),Dot(1:18-1:19),OpenCurly(1:19-1:20), +UpperIdent(2:5-2:8),OpColonEqual(2:9-2:11),OpenSquare(2:12-2:13),UpperIdent(2:13-2:22),CloseSquare(2:22-2:23),Dot(2:23-2:24),OpenCurly(2:24-2:25), +LowerIdent(3:9-3:10),OpAssign(3:11-3:12),Int(3:13-3:14), +CloseCurly(4:5-4:6), +LowerIdent(5:5-5:6),OpAssign(5:7-5:8),Int(5:9-5:10), +CloseCurly(6:1-6:2), +EndOfFile(7:1-7:1), +~~~ +# PARSE +~~~clojure +(file @1.1-6.2 + (type-module @1.1-1.4) + (statements + (s-type-decl @1.1-6.2 + (header @1.1-1.4 (name "Foo") + (args)) + (ty-tag-union @1.8-1.18 + (tags + (ty @1.9-1.17 (name "Whatever")))) + (associated @1.19-6.2 + (s-type-decl @2.5-4.6 + (header @2.5-2.8 (name "Bar") + (args)) + (ty-tag-union @2.12-2.23 + (tags + (ty @2.13-2.22 (name "Something")))) + (associated @2.24-4.6 + (s-decl @3.9-3.14 + (p-ident @3.9-3.10 (raw "y")) + (e-int @3.13-3.14 (raw "6"))))) + (s-decl @5.5-5.10 + (p-ident @5.5-5.6 (raw "x")) + (e-int @5.9-5.10 (raw "5"))))))) +~~~ +# FORMATTED +~~~roc +Foo := [Whatever].{ + Bar := [Something].{ + y = 6 + } + x = 5 +} +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @3.9-3.14 (ident "Foo.Bar.y")) + (e-num @3.13-3.14 (value "6"))) + (d-let + (p-assign @5.5-5.10 (ident "Foo.x")) + (e-num @5.9-5.10 (value "5"))) + (s-nominal-decl @1.1-6.2 + (ty-header @1.1-1.4 (name "Foo")) + (ty-tag-union @1.8-1.18 + (ty-tag-name @1.9-1.17 (name "Whatever")))) + (s-nominal-decl @2.5-4.6 + (ty-header @2.5-4.6 (name "Foo.Bar")) + (ty-tag-union @2.12-2.23 + (ty-tag-name @2.13-2.22 (name "Something"))))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @3.9-3.14 (type "Num(_size)")) + (patt @5.5-5.10 (type "Num(_size)"))) + (type_decls + (nominal @1.1-6.2 (type "Foo") + (ty-header @1.1-1.4 (name "Foo"))) + (nominal @2.5-4.6 (type "Foo.Bar") + (ty-header @2.5-4.6 (name "Foo.Bar")))) + (expressions + (expr @3.13-3.14 (type "Num(_size)")) + (expr @5.9-5.10 (type "Num(_size)")))) +~~~ diff --git a/test/snapshots/nominal/nominal_simple_nested_tag.md b/test/snapshots/nominal/nominal_simple_nested_tag.md new file mode 100644 index 0000000000..9c1be30554 --- /dev/null +++ b/test/snapshots/nominal/nominal_simple_nested_tag.md @@ -0,0 +1,88 @@ +# META +~~~ini +description=Simple nested type tag constructor +type=snippet +~~~ +# SOURCE +~~~roc +Foo := [Whatever].{ + Bar := [X, Y, Z] +} + +x = Foo.Bar.X +~~~ +# EXPECTED +NIL +# PROBLEMS +NIL +# TOKENS +~~~zig +UpperIdent(1:1-1:4),OpColonEqual(1:5-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:17),CloseSquare(1:17-1:18),Dot(1:18-1:19),OpenCurly(1:19-1:20), +UpperIdent(2:5-2:8),OpColonEqual(2:9-2:11),OpenSquare(2:12-2:13),UpperIdent(2:13-2:14),Comma(2:14-2:15),UpperIdent(2:16-2:17),Comma(2:17-2:18),UpperIdent(2:19-2:20),CloseSquare(2:20-2:21), +CloseCurly(3:1-3:2), +LowerIdent(5:1-5:2),OpAssign(5:3-5:4),UpperIdent(5:5-5:8),NoSpaceDotUpperIdent(5:8-5:12),NoSpaceDotUpperIdent(5:12-5:14), +EndOfFile(6:1-6:1), +~~~ +# PARSE +~~~clojure +(file @1.1-5.14 + (type-module @1.1-1.4) + (statements + (s-type-decl @1.1-3.2 + (header @1.1-1.4 (name "Foo") + (args)) + (ty-tag-union @1.8-1.18 + (tags + (ty @1.9-1.17 (name "Whatever")))) + (associated @1.19-3.2 + (s-type-decl @2.5-2.21 + (header @2.5-2.8 (name "Bar") + (args)) + (ty-tag-union @2.12-2.21 + (tags + (ty @2.13-2.14 (name "X")) + (ty @2.16-2.17 (name "Y")) + (ty @2.19-2.20 (name "Z"))))))) + (s-decl @5.1-5.14 + (p-ident @5.1-5.2 (raw "x")) + (e-tag @5.5-5.14 (raw "Foo.Bar.X"))))) +~~~ +# FORMATTED +~~~roc +Foo := [Whatever].{ + Bar := [X, Y, Z] +} + +x = Foo.Bar.X +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @5.1-5.2 (ident "x")) + (e-nominal @5.5-5.14 (nominal "Foo.Bar") + (e-tag @5.5-5.14 (name "X")))) + (s-nominal-decl @1.1-3.2 + (ty-header @1.1-1.4 (name "Foo")) + (ty-tag-union @1.8-1.18 + (ty-tag-name @1.9-1.17 (name "Whatever")))) + (s-nominal-decl @2.5-2.21 + (ty-header @2.5-2.21 (name "Foo.Bar")) + (ty-tag-union @2.12-2.21 + (ty-tag-name @2.13-2.14 (name "X")) + (ty-tag-name @2.16-2.17 (name "Y")) + (ty-tag-name @2.19-2.20 (name "Z"))))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @5.1-5.2 (type "Foo.Bar"))) + (type_decls + (nominal @1.1-3.2 (type "Foo") + (ty-header @1.1-1.4 (name "Foo"))) + (nominal @2.5-2.21 (type "Foo.Bar") + (ty-header @2.5-2.21 (name "Foo.Bar")))) + (expressions + (expr @5.5-5.14 (type "Foo.Bar")))) +~~~ diff --git a/test/snapshots/nominal/nominal_single_qualifier_tag.md b/test/snapshots/nominal/nominal_single_qualifier_tag.md new file mode 100644 index 0000000000..4307633efd --- /dev/null +++ b/test/snapshots/nominal/nominal_single_qualifier_tag.md @@ -0,0 +1,67 @@ +# META +~~~ini +description=Tag with single qualifier +type=snippet +~~~ +# SOURCE +~~~roc +Foo := [X, Y, Z] + +x = Foo.X +~~~ +# EXPECTED +NIL +# PROBLEMS +NIL +# TOKENS +~~~zig +UpperIdent(1:1-1:4),OpColonEqual(1:5-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:10),Comma(1:10-1:11),UpperIdent(1:12-1:13),Comma(1:13-1:14),UpperIdent(1:15-1:16),CloseSquare(1:16-1:17), +LowerIdent(3:1-3:2),OpAssign(3:3-3:4),UpperIdent(3:5-3:8),NoSpaceDotUpperIdent(3:8-3:10), +EndOfFile(4:1-4:1), +~~~ +# PARSE +~~~clojure +(file @1.1-3.10 + (type-module @1.1-1.4) + (statements + (s-type-decl @1.1-1.17 + (header @1.1-1.4 (name "Foo") + (args)) + (ty-tag-union @1.8-1.17 + (tags + (ty @1.9-1.10 (name "X")) + (ty @1.12-1.13 (name "Y")) + (ty @1.15-1.16 (name "Z"))))) + (s-decl @3.1-3.10 + (p-ident @3.1-3.2 (raw "x")) + (e-tag @3.5-3.10 (raw "Foo.X"))))) +~~~ +# FORMATTED +~~~roc +NO CHANGE +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @3.1-3.2 (ident "x")) + (e-nominal @3.5-3.10 (nominal "Foo") + (e-tag @3.5-3.10 (name "X")))) + (s-nominal-decl @1.1-1.17 + (ty-header @1.1-1.4 (name "Foo")) + (ty-tag-union @1.8-1.17 + (ty-tag-name @1.9-1.10 (name "X")) + (ty-tag-name @1.12-1.13 (name "Y")) + (ty-tag-name @1.15-1.16 (name "Z"))))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @3.1-3.2 (type "Foo"))) + (type_decls + (nominal @1.1-1.17 (type "Foo") + (ty-header @1.1-1.4 (name "Foo")))) + (expressions + (expr @3.5-3.10 (type "Foo")))) +~~~ diff --git a/test/snapshots/nominal/nominal_tag_package_import.md b/test/snapshots/nominal/nominal_tag_package_import.md index 88b8c9fb8d..94d9074729 100644 --- a/test/snapshots/nominal/nominal_tag_package_import.md +++ b/test/snapshots/nominal/nominal_tag_package_import.md @@ -1,12 +1,10 @@ # META ~~~ini description=Example of a nominal tag union import from a package -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [blue] - # import the Color module from styles package as CC import styles.Color as CC @@ -15,13 +13,13 @@ blue : CC.Color blue = CC.Color.RGB(0,0,255) ~~~ # EXPECTED -MODULE NOT FOUND - nominal_tag_package_import.md:4:1:4:26 +MODULE NOT FOUND - nominal_tag_package_import.md:2:1:2:26 # PROBLEMS **MODULE NOT FOUND** The module `styles.Color` was not found in this Roc project. You're attempting to use this module here: -**nominal_tag_package_import.md:4:1:4:26:** +**nominal_tag_package_import.md:2:1:2:26:** ```roc import styles.Color as CC ``` @@ -30,35 +28,30 @@ import styles.Color as CC # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:13),CloseSquare(1:13-1:14), -KwImport(4:1-4:7),LowerIdent(4:8-4:14),NoSpaceDotUpperIdent(4:14-4:20),KwAs(4:21-4:23),UpperIdent(4:24-4:26), -LowerIdent(7:1-7:5),OpColon(7:6-7:7),UpperIdent(7:8-7:10),NoSpaceDotUpperIdent(7:10-7:16), -LowerIdent(8:1-8:5),OpAssign(8:6-8:7),UpperIdent(8:8-8:10),NoSpaceDotUpperIdent(8:10-8:16),NoSpaceDotUpperIdent(8:16-8:20),NoSpaceOpenRound(8:20-8:21),Int(8:21-8:22),Comma(8:22-8:23),Int(8:23-8:24),Comma(8:24-8:25),Int(8:25-8:28),CloseRound(8:28-8:29), -EndOfFile(9:1-9:1), +KwImport(2:1-2:7),LowerIdent(2:8-2:14),NoSpaceDotUpperIdent(2:14-2:20),KwAs(2:21-2:23),UpperIdent(2:24-2:26), +LowerIdent(5:1-5:5),OpColon(5:6-5:7),UpperIdent(5:8-5:10),NoSpaceDotUpperIdent(5:10-5:16), +LowerIdent(6:1-6:5),OpAssign(6:6-6:7),UpperIdent(6:8-6:10),NoSpaceDotUpperIdent(6:10-6:16),NoSpaceDotUpperIdent(6:16-6:20),NoSpaceOpenRound(6:20-6:21),Int(6:21-6:22),Comma(6:22-6:23),Int(6:23-6:24),Comma(6:24-6:25),Int(6:25-6:28),CloseRound(6:28-6:29), +EndOfFile(7:1-7:1), ~~~ # PARSE ~~~clojure -(file @1.1-8.29 - (module @1.1-1.14 - (exposes @1.8-1.14 - (exposed-lower-ident @1.9-1.13 - (text "blue")))) +(file @2.1-6.29 + (type-module @2.1-2.7) (statements - (s-import @4.1-4.26 (raw "styles.Color") (alias "CC")) - (s-type-anno @7.1-7.16 (name "blue") - (ty @7.8-7.16 (name "CC.Color"))) - (s-decl @8.1-8.29 - (p-ident @8.1-8.5 (raw "blue")) - (e-apply @8.8-8.29 - (e-tag @8.8-8.20 (raw "CC.Color.RGB")) - (e-int @8.21-8.22 (raw "0")) - (e-int @8.23-8.24 (raw "0")) - (e-int @8.25-8.28 (raw "255")))))) + (s-import @2.1-2.26 (raw "styles.Color") (alias "CC")) + (s-type-anno @5.1-5.16 (name "blue") + (ty @5.8-5.16 (name "CC.Color"))) + (s-decl @6.1-6.29 + (p-ident @6.1-6.5 (raw "blue")) + (e-apply @6.8-6.29 + (e-tag @6.8-6.20 (raw "CC.Color.RGB")) + (e-int @6.21-6.22 (raw "0")) + (e-int @6.23-6.24 (raw "0")) + (e-int @6.25-6.28 (raw "255")))))) ~~~ # FORMATTED ~~~roc -module [blue] - +# import the Color module from styles package as CC # import the Color module from styles package as CC import styles.Color as CC @@ -70,28 +63,26 @@ blue = CC.Color.RGB(0, 0, 255) ~~~clojure (can-ir (d-let - (p-assign @8.1-8.5 (ident "blue")) - (e-nominal-external @8.8-8.29 - (module-idx "0") + (p-assign @6.1-6.5 (ident "blue")) + (e-nominal-external @6.8-6.29 + (module-idx "2") (target-node-idx "0") - (e-tag @8.8-8.29 (name "RGB") + (e-tag @6.8-6.29 (name "RGB") (args - (e-int @8.21-8.22 (value "0")) - (e-int @8.23-8.24 (value "0")) - (e-int @8.25-8.28 (value "255"))))) - (annotation @8.1-8.5 + (e-num @6.21-6.22 (value "0")) + (e-num @6.23-6.24 (value "0")) + (e-num @6.25-6.28 (value "255"))))) + (annotation @6.1-6.5 (declared-type - (ty-lookup-external @7.8-7.16 - (module-idx "0") - (target-node-idx "0"))))) - (s-import @4.1-4.26 (module "styles.Color") (qualifier "styles") (alias "CC") + (ty-lookup @5.8-5.16 (name "Color") (external (module-idx "2") (target-node-idx "0")))))) + (s-import @2.1-2.26 (module "styles.Color") (qualifier "styles") (alias "CC") (exposes))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @8.1-8.5 (type "Error"))) + (patt @6.1-6.5 (type "Error"))) (expressions - (expr @8.8-8.29 (type "Error")))) + (expr @6.8-6.29 (type "Error")))) ~~~ diff --git a/test/snapshots/nominal/nominal_tag_payload.md b/test/snapshots/nominal/nominal_tag_payload.md index 2e966e2881..bee7d853b6 100644 --- a/test/snapshots/nominal/nominal_tag_payload.md +++ b/test/snapshots/nominal/nominal_tag_payload.md @@ -1,12 +1,10 @@ # META ~~~ini description=Example of a nominal tag union with a payload -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [Maybe, some1, none1, some2, none2] - Maybe(a) := [Some(a), None] some1 : a -> Maybe(a) @@ -25,73 +23,62 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:14),Comma(1:14-1:15),LowerIdent(1:16-1:21),Comma(1:21-1:22),LowerIdent(1:23-1:28),Comma(1:28-1:29),LowerIdent(1:30-1:35),Comma(1:35-1:36),LowerIdent(1:37-1:42),CloseSquare(1:42-1:43), -UpperIdent(3:1-3:6),NoSpaceOpenRound(3:6-3:7),LowerIdent(3:7-3:8),CloseRound(3:8-3:9),OpColonEqual(3:10-3:12),OpenSquare(3:13-3:14),UpperIdent(3:14-3:18),NoSpaceOpenRound(3:18-3:19),LowerIdent(3:19-3:20),CloseRound(3:20-3:21),Comma(3:21-3:22),UpperIdent(3:23-3:27),CloseSquare(3:27-3:28), -LowerIdent(5:1-5:6),OpColon(5:7-5:8),LowerIdent(5:9-5:10),OpArrow(5:11-5:13),UpperIdent(5:14-5:19),NoSpaceOpenRound(5:19-5:20),LowerIdent(5:20-5:21),CloseRound(5:21-5:22), -LowerIdent(6:1-6:6),OpAssign(6:7-6:8),OpBar(6:9-6:10),LowerIdent(6:10-6:11),OpBar(6:11-6:12),UpperIdent(6:13-6:18),NoSpaceDotUpperIdent(6:18-6:23),NoSpaceOpenRound(6:23-6:24),LowerIdent(6:24-6:25),CloseRound(6:25-6:26), -LowerIdent(8:1-8:6),OpColon(8:7-8:8),UpperIdent(8:9-8:14),NoSpaceOpenRound(8:14-8:15),NamedUnderscore(8:15-8:17),CloseRound(8:17-8:18), -LowerIdent(9:1-9:6),OpAssign(9:7-9:8),UpperIdent(9:9-9:14),NoSpaceDotUpperIdent(9:14-9:19), -LowerIdent(11:1-11:6),OpAssign(11:7-11:8),OpBar(11:9-11:10),LowerIdent(11:10-11:11),OpBar(11:11-11:12),UpperIdent(11:13-11:18),NoSpaceDotUpperIdent(11:18-11:23),NoSpaceOpenRound(11:23-11:24),LowerIdent(11:24-11:25),CloseRound(11:25-11:26), -LowerIdent(13:1-13:6),OpAssign(13:7-13:8),UpperIdent(13:9-13:14),NoSpaceDotUpperIdent(13:14-13:19), -EndOfFile(14:1-14:1), +UpperIdent(1:1-1:6),NoSpaceOpenRound(1:6-1:7),LowerIdent(1:7-1:8),CloseRound(1:8-1:9),OpColonEqual(1:10-1:12),OpenSquare(1:13-1:14),UpperIdent(1:14-1:18),NoSpaceOpenRound(1:18-1:19),LowerIdent(1:19-1:20),CloseRound(1:20-1:21),Comma(1:21-1:22),UpperIdent(1:23-1:27),CloseSquare(1:27-1:28), +LowerIdent(3:1-3:6),OpColon(3:7-3:8),LowerIdent(3:9-3:10),OpArrow(3:11-3:13),UpperIdent(3:14-3:19),NoSpaceOpenRound(3:19-3:20),LowerIdent(3:20-3:21),CloseRound(3:21-3:22), +LowerIdent(4:1-4:6),OpAssign(4:7-4:8),OpBar(4:9-4:10),LowerIdent(4:10-4:11),OpBar(4:11-4:12),UpperIdent(4:13-4:18),NoSpaceDotUpperIdent(4:18-4:23),NoSpaceOpenRound(4:23-4:24),LowerIdent(4:24-4:25),CloseRound(4:25-4:26), +LowerIdent(6:1-6:6),OpColon(6:7-6:8),UpperIdent(6:9-6:14),NoSpaceOpenRound(6:14-6:15),NamedUnderscore(6:15-6:17),CloseRound(6:17-6:18), +LowerIdent(7:1-7:6),OpAssign(7:7-7:8),UpperIdent(7:9-7:14),NoSpaceDotUpperIdent(7:14-7:19), +LowerIdent(9:1-9:6),OpAssign(9:7-9:8),OpBar(9:9-9:10),LowerIdent(9:10-9:11),OpBar(9:11-9:12),UpperIdent(9:13-9:18),NoSpaceDotUpperIdent(9:18-9:23),NoSpaceOpenRound(9:23-9:24),LowerIdent(9:24-9:25),CloseRound(9:25-9:26), +LowerIdent(11:1-11:6),OpAssign(11:7-11:8),UpperIdent(11:9-11:14),NoSpaceDotUpperIdent(11:14-11:19), +EndOfFile(12:1-12:1), ~~~ # PARSE ~~~clojure -(file @1.1-13.19 - (module @1.1-1.43 - (exposes @1.8-1.43 - (exposed-upper-ident @1.9-1.14 (text "Maybe")) - (exposed-lower-ident @1.16-1.21 - (text "some1")) - (exposed-lower-ident @1.23-1.28 - (text "none1")) - (exposed-lower-ident @1.30-1.35 - (text "some2")) - (exposed-lower-ident @1.37-1.42 - (text "none2")))) +(file @1.1-11.19 + (type-module @1.1-1.6) (statements - (s-type-decl @3.1-3.28 - (header @3.1-3.9 (name "Maybe") + (s-type-decl @1.1-1.28 + (header @1.1-1.9 (name "Maybe") (args - (ty-var @3.7-3.8 (raw "a")))) - (ty-tag-union @3.13-3.28 + (ty-var @1.7-1.8 (raw "a")))) + (ty-tag-union @1.13-1.28 (tags - (ty-apply @3.14-3.21 - (ty @3.14-3.18 (name "Some")) - (ty-var @3.19-3.20 (raw "a"))) - (ty @3.23-3.27 (name "None"))))) - (s-type-anno @5.1-5.22 (name "some1") - (ty-fn @5.9-5.22 - (ty-var @5.9-5.10 (raw "a")) - (ty-apply @5.14-5.22 - (ty @5.14-5.19 (name "Maybe")) - (ty-var @5.20-5.21 (raw "a"))))) - (s-decl @6.1-6.26 - (p-ident @6.1-6.6 (raw "some1")) - (e-lambda @6.9-6.26 + (ty-apply @1.14-1.21 + (ty @1.14-1.18 (name "Some")) + (ty-var @1.19-1.20 (raw "a"))) + (ty @1.23-1.27 (name "None"))))) + (s-type-anno @3.1-3.22 (name "some1") + (ty-fn @3.9-3.22 + (ty-var @3.9-3.10 (raw "a")) + (ty-apply @3.14-3.22 + (ty @3.14-3.19 (name "Maybe")) + (ty-var @3.20-3.21 (raw "a"))))) + (s-decl @4.1-4.26 + (p-ident @4.1-4.6 (raw "some1")) + (e-lambda @4.9-4.26 (args - (p-ident @6.10-6.11 (raw "a"))) - (e-apply @6.13-6.26 - (e-tag @6.13-6.23 (raw "Maybe.Some")) - (e-ident @6.24-6.25 (raw "a"))))) - (s-type-anno @8.1-8.18 (name "none1") - (ty-apply @8.9-8.18 - (ty @8.9-8.14 (name "Maybe")) - (underscore-ty-var @8.15-8.17 (raw "_a")))) - (s-decl @9.1-9.19 - (p-ident @9.1-9.6 (raw "none1")) - (e-tag @9.9-9.19 (raw "Maybe.None"))) - (s-decl @11.1-11.26 - (p-ident @11.1-11.6 (raw "some2")) - (e-lambda @11.9-11.26 + (p-ident @4.10-4.11 (raw "a"))) + (e-apply @4.13-4.26 + (e-tag @4.13-4.23 (raw "Maybe.Some")) + (e-ident @4.24-4.25 (raw "a"))))) + (s-type-anno @6.1-6.18 (name "none1") + (ty-apply @6.9-6.18 + (ty @6.9-6.14 (name "Maybe")) + (underscore-ty-var @6.15-6.17 (raw "_a")))) + (s-decl @7.1-7.19 + (p-ident @7.1-7.6 (raw "none1")) + (e-tag @7.9-7.19 (raw "Maybe.None"))) + (s-decl @9.1-9.26 + (p-ident @9.1-9.6 (raw "some2")) + (e-lambda @9.9-9.26 (args - (p-ident @11.10-11.11 (raw "a"))) - (e-apply @11.13-11.26 - (e-tag @11.13-11.23 (raw "Maybe.Some")) - (e-ident @11.24-11.25 (raw "a"))))) - (s-decl @13.1-13.19 - (p-ident @13.1-13.6 (raw "none2")) - (e-tag @13.9-13.19 (raw "Maybe.None"))))) + (p-ident @9.10-9.11 (raw "a"))) + (e-apply @9.13-9.26 + (e-tag @9.13-9.23 (raw "Maybe.Some")) + (e-ident @9.24-9.25 (raw "a"))))) + (s-decl @11.1-11.19 + (p-ident @11.1-11.6 (raw "none2")) + (e-tag @11.9-11.19 (raw "Maybe.None"))))) ~~~ # FORMATTED ~~~roc @@ -101,68 +88,68 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @6.1-6.6 (ident "some1")) - (e-lambda @6.9-6.26 + (p-assign @4.1-4.6 (ident "some1")) + (e-lambda @4.9-4.26 (args - (p-assign @6.10-6.11 (ident "a"))) - (e-nominal @6.13-6.26 (nominal "Maybe") - (e-tag @6.13-6.26 (name "Some") + (p-assign @4.10-4.11 (ident "a"))) + (e-nominal @4.13-4.26 (nominal "Maybe") + (e-tag @4.13-4.26 (name "Some") (args - (e-lookup-local @6.24-6.25 - (p-assign @6.10-6.11 (ident "a"))))))) - (annotation @6.1-6.6 + (e-lookup-local @4.24-4.25 + (p-assign @4.10-4.11 (ident "a"))))))) + (annotation @4.1-4.6 (declared-type - (ty-fn @5.9-5.22 (effectful false) - (ty-var @5.9-5.10 (name "a")) - (ty-apply @5.14-5.22 (symbol "Maybe") - (ty-var @5.20-5.21 (name "a"))))))) + (ty-fn @3.9-3.22 (effectful false) + (ty-rigid-var @3.9-3.10 (name "a")) + (ty-apply @3.14-3.22 (name "Maybe") (local) + (ty-rigid-var-lookup (ty-rigid-var @3.9-3.10 (name "a")))))))) (d-let - (p-assign @9.1-9.6 (ident "none1")) - (e-nominal @9.9-9.19 (nominal "Maybe") - (e-tag @9.9-9.19 (name "None"))) - (annotation @9.1-9.6 + (p-assign @7.1-7.6 (ident "none1")) + (e-nominal @7.9-7.19 (nominal "Maybe") + (e-tag @7.9-7.19 (name "None"))) + (annotation @7.1-7.6 (declared-type - (ty-apply @8.9-8.18 (symbol "Maybe") - (ty-var @8.15-8.17 (name "_a")))))) + (ty-apply @6.9-6.18 (name "Maybe") (local) + (ty-rigid-var @6.9-6.18 (name "_a")))))) (d-let - (p-assign @11.1-11.6 (ident "some2")) - (e-lambda @11.9-11.26 + (p-assign @9.1-9.6 (ident "some2")) + (e-lambda @9.9-9.26 (args - (p-assign @11.10-11.11 (ident "a"))) - (e-nominal @11.13-11.26 (nominal "Maybe") - (e-tag @11.13-11.26 (name "Some") + (p-assign @9.10-9.11 (ident "a"))) + (e-nominal @9.13-9.26 (nominal "Maybe") + (e-tag @9.13-9.26 (name "Some") (args - (e-lookup-local @11.24-11.25 - (p-assign @11.10-11.11 (ident "a")))))))) + (e-lookup-local @9.24-9.25 + (p-assign @9.10-9.11 (ident "a")))))))) (d-let - (p-assign @13.1-13.6 (ident "none2")) - (e-nominal @13.9-13.19 (nominal "Maybe") - (e-tag @13.9-13.19 (name "None")))) - (s-nominal-decl @3.1-3.28 - (ty-header @3.1-3.9 (name "Maybe") + (p-assign @11.1-11.6 (ident "none2")) + (e-nominal @11.9-11.19 (nominal "Maybe") + (e-tag @11.9-11.19 (name "None")))) + (s-nominal-decl @1.1-1.28 + (ty-header @1.1-1.9 (name "Maybe") (ty-args - (ty-var @3.7-3.8 (name "a")))) - (ty-tag-union @3.13-3.28 - (ty-apply @3.14-3.21 (symbol "Some") - (ty-var @3.19-3.20 (name "a"))) - (ty @3.23-3.27 (name "None"))))) + (ty-rigid-var @1.7-1.8 (name "a")))) + (ty-tag-union @1.13-1.28 + (ty-tag-name @1.14-1.21 (name "Some") + (ty-rigid-var-lookup (ty-rigid-var @1.7-1.8 (name "a")))) + (ty-tag-name @1.23-1.27 (name "None"))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @6.1-6.6 (type "a -> Maybe(a)")) - (patt @9.1-9.6 (type "Maybe(a)")) - (patt @11.1-11.6 (type "a -> Maybe(a)")) - (patt @13.1-13.6 (type "Maybe(a)"))) + (patt @4.1-4.6 (type "a -> Maybe(a)")) + (patt @7.1-7.6 (type "Maybe(_a)")) + (patt @9.1-9.6 (type "a -> Maybe(a)")) + (patt @11.1-11.6 (type "Maybe(a)"))) (type_decls - (nominal @3.1-3.28 (type "Maybe(a)") - (ty-header @3.1-3.9 (name "Maybe") + (nominal @1.1-1.28 (type "Maybe(a)") + (ty-header @1.1-1.9 (name "Maybe") (ty-args - (ty-var @3.7-3.8 (name "a")))))) + (ty-rigid-var @1.7-1.8 (name "a")))))) (expressions - (expr @6.9-6.26 (type "a -> Maybe(a)")) - (expr @9.9-9.19 (type "Maybe(a)")) - (expr @11.9-11.26 (type "a -> Maybe(a)")) - (expr @13.9-13.19 (type "Maybe(a)")))) + (expr @4.9-4.26 (type "a -> Maybe(a)")) + (expr @7.9-7.19 (type "Maybe(_a)")) + (expr @9.9-9.26 (type "a -> Maybe(a)")) + (expr @11.9-11.19 (type "Maybe(a)")))) ~~~ diff --git a/test/snapshots/nominal/nominal_tag_payload_two.md b/test/snapshots/nominal/nominal_tag_payload_two.md index 0cd6c69169..1ab8a9c021 100644 --- a/test/snapshots/nominal/nominal_tag_payload_two.md +++ b/test/snapshots/nominal/nominal_tag_payload_two.md @@ -1,12 +1,10 @@ # META ~~~ini description=Example of a more complex nominal tag union with two payload types -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [MyResult, ok, is_ok] - MyResult(ok, err) := [Ok(ok), Err(err)] ok : ok -> MyResult(ok, _) @@ -24,84 +22,75 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:17),Comma(1:17-1:18),LowerIdent(1:19-1:21),Comma(1:21-1:22),LowerIdent(1:23-1:28),CloseSquare(1:28-1:29), -UpperIdent(3:1-3:9),NoSpaceOpenRound(3:9-3:10),LowerIdent(3:10-3:12),Comma(3:12-3:13),LowerIdent(3:14-3:17),CloseRound(3:17-3:18),OpColonEqual(3:19-3:21),OpenSquare(3:22-3:23),UpperIdent(3:23-3:25),NoSpaceOpenRound(3:25-3:26),LowerIdent(3:26-3:28),CloseRound(3:28-3:29),Comma(3:29-3:30),UpperIdent(3:31-3:34),NoSpaceOpenRound(3:34-3:35),LowerIdent(3:35-3:38),CloseRound(3:38-3:39),CloseSquare(3:39-3:40), -LowerIdent(5:1-5:3),OpColon(5:4-5:5),LowerIdent(5:6-5:8),OpArrow(5:9-5:11),UpperIdent(5:12-5:20),NoSpaceOpenRound(5:20-5:21),LowerIdent(5:21-5:23),Comma(5:23-5:24),Underscore(5:25-5:26),CloseRound(5:26-5:27), -LowerIdent(6:1-6:3),OpAssign(6:4-6:5),OpBar(6:6-6:7),LowerIdent(6:7-6:8),OpBar(6:8-6:9),UpperIdent(6:10-6:18),NoSpaceDotUpperIdent(6:18-6:21),NoSpaceOpenRound(6:21-6:22),LowerIdent(6:22-6:23),CloseRound(6:23-6:24), -LowerIdent(8:1-8:6),OpColon(8:7-8:8),UpperIdent(8:9-8:17),NoSpaceOpenRound(8:17-8:18),NamedUnderscore(8:18-8:21),Comma(8:21-8:22),NamedUnderscore(8:23-8:27),CloseRound(8:27-8:28),OpArrow(8:29-8:31),UpperIdent(8:32-8:36), -LowerIdent(9:1-9:6),OpAssign(9:7-9:8),OpBar(9:9-9:10),LowerIdent(9:10-9:16),OpBar(9:16-9:17),KwMatch(9:18-9:23),LowerIdent(9:24-9:30),OpenCurly(9:31-9:32), -UpperIdent(10:5-10:13),NoSpaceDotUpperIdent(10:13-10:16),NoSpaceOpenRound(10:16-10:17),Underscore(10:17-10:18),CloseRound(10:18-10:19),OpFatArrow(10:20-10:22),UpperIdent(10:23-10:27),NoSpaceDotUpperIdent(10:27-10:32), -UpperIdent(11:5-11:13),NoSpaceDotUpperIdent(11:13-11:17),NoSpaceOpenRound(11:17-11:18),Underscore(11:18-11:19),CloseRound(11:19-11:20),OpFatArrow(11:21-11:23),UpperIdent(11:24-11:28),NoSpaceDotUpperIdent(11:28-11:34), -CloseCurly(12:1-12:2), -EndOfFile(13:1-13:1), +UpperIdent(1:1-1:9),NoSpaceOpenRound(1:9-1:10),LowerIdent(1:10-1:12),Comma(1:12-1:13),LowerIdent(1:14-1:17),CloseRound(1:17-1:18),OpColonEqual(1:19-1:21),OpenSquare(1:22-1:23),UpperIdent(1:23-1:25),NoSpaceOpenRound(1:25-1:26),LowerIdent(1:26-1:28),CloseRound(1:28-1:29),Comma(1:29-1:30),UpperIdent(1:31-1:34),NoSpaceOpenRound(1:34-1:35),LowerIdent(1:35-1:38),CloseRound(1:38-1:39),CloseSquare(1:39-1:40), +LowerIdent(3:1-3:3),OpColon(3:4-3:5),LowerIdent(3:6-3:8),OpArrow(3:9-3:11),UpperIdent(3:12-3:20),NoSpaceOpenRound(3:20-3:21),LowerIdent(3:21-3:23),Comma(3:23-3:24),Underscore(3:25-3:26),CloseRound(3:26-3:27), +LowerIdent(4:1-4:3),OpAssign(4:4-4:5),OpBar(4:6-4:7),LowerIdent(4:7-4:8),OpBar(4:8-4:9),UpperIdent(4:10-4:18),NoSpaceDotUpperIdent(4:18-4:21),NoSpaceOpenRound(4:21-4:22),LowerIdent(4:22-4:23),CloseRound(4:23-4:24), +LowerIdent(6:1-6:6),OpColon(6:7-6:8),UpperIdent(6:9-6:17),NoSpaceOpenRound(6:17-6:18),NamedUnderscore(6:18-6:21),Comma(6:21-6:22),NamedUnderscore(6:23-6:27),CloseRound(6:27-6:28),OpArrow(6:29-6:31),UpperIdent(6:32-6:36), +LowerIdent(7:1-7:6),OpAssign(7:7-7:8),OpBar(7:9-7:10),LowerIdent(7:10-7:16),OpBar(7:16-7:17),KwMatch(7:18-7:23),LowerIdent(7:24-7:30),OpenCurly(7:31-7:32), +UpperIdent(8:5-8:13),NoSpaceDotUpperIdent(8:13-8:16),NoSpaceOpenRound(8:16-8:17),Underscore(8:17-8:18),CloseRound(8:18-8:19),OpFatArrow(8:20-8:22),UpperIdent(8:23-8:27),NoSpaceDotUpperIdent(8:27-8:32), +UpperIdent(9:5-9:13),NoSpaceDotUpperIdent(9:13-9:17),NoSpaceOpenRound(9:17-9:18),Underscore(9:18-9:19),CloseRound(9:19-9:20),OpFatArrow(9:21-9:23),UpperIdent(9:24-9:28),NoSpaceDotUpperIdent(9:28-9:34), +CloseCurly(10:1-10:2), +EndOfFile(11:1-11:1), ~~~ # PARSE ~~~clojure -(file @1.1-12.2 - (module @1.1-1.29 - (exposes @1.8-1.29 - (exposed-upper-ident @1.9-1.17 (text "MyResult")) - (exposed-lower-ident @1.19-1.21 - (text "ok")) - (exposed-lower-ident @1.23-1.28 - (text "is_ok")))) +(file @1.1-10.2 + (type-module @1.1-1.9) (statements - (s-type-decl @3.1-3.40 - (header @3.1-3.18 (name "MyResult") + (s-type-decl @1.1-1.40 + (header @1.1-1.18 (name "MyResult") (args - (ty-var @3.10-3.12 (raw "ok")) - (ty-var @3.14-3.17 (raw "err")))) - (ty-tag-union @3.22-3.40 + (ty-var @1.10-1.12 (raw "ok")) + (ty-var @1.14-1.17 (raw "err")))) + (ty-tag-union @1.22-1.40 (tags - (ty-apply @3.23-3.29 - (ty @3.23-3.25 (name "Ok")) - (ty-var @3.26-3.28 (raw "ok"))) - (ty-apply @3.31-3.39 - (ty @3.31-3.34 (name "Err")) - (ty-var @3.35-3.38 (raw "err")))))) - (s-type-anno @5.1-5.27 (name "ok") - (ty-fn @5.6-5.27 - (ty-var @5.6-5.8 (raw "ok")) - (ty-apply @5.12-5.27 - (ty @5.12-5.20 (name "MyResult")) - (ty-var @5.21-5.23 (raw "ok")) + (ty-apply @1.23-1.29 + (ty @1.23-1.25 (name "Ok")) + (ty-var @1.26-1.28 (raw "ok"))) + (ty-apply @1.31-1.39 + (ty @1.31-1.34 (name "Err")) + (ty-var @1.35-1.38 (raw "err")))))) + (s-type-anno @3.1-3.27 (name "ok") + (ty-fn @3.6-3.27 + (ty-var @3.6-3.8 (raw "ok")) + (ty-apply @3.12-3.27 + (ty @3.12-3.20 (name "MyResult")) + (ty-var @3.21-3.23 (raw "ok")) (_)))) - (s-decl @6.1-6.24 - (p-ident @6.1-6.3 (raw "ok")) - (e-lambda @6.6-6.24 + (s-decl @4.1-4.24 + (p-ident @4.1-4.3 (raw "ok")) + (e-lambda @4.6-4.24 (args - (p-ident @6.7-6.8 (raw "a"))) - (e-apply @6.10-6.24 - (e-tag @6.10-6.21 (raw "MyResult.Ok")) - (e-ident @6.22-6.23 (raw "a"))))) - (s-type-anno @8.1-8.36 (name "is_ok") - (ty-fn @8.9-8.36 - (ty-apply @8.9-8.28 - (ty @8.9-8.17 (name "MyResult")) - (underscore-ty-var @8.18-8.21 (raw "_ok")) - (underscore-ty-var @8.23-8.27 (raw "_err"))) - (ty @8.32-8.36 (name "Bool")))) - (s-decl @9.1-12.2 - (p-ident @9.1-9.6 (raw "is_ok")) - (e-lambda @9.9-12.2 + (p-ident @4.7-4.8 (raw "a"))) + (e-apply @4.10-4.24 + (e-tag @4.10-4.21 (raw "MyResult.Ok")) + (e-ident @4.22-4.23 (raw "a"))))) + (s-type-anno @6.1-6.36 (name "is_ok") + (ty-fn @6.9-6.36 + (ty-apply @6.9-6.28 + (ty @6.9-6.17 (name "MyResult")) + (underscore-ty-var @6.18-6.21 (raw "_ok")) + (underscore-ty-var @6.23-6.27 (raw "_err"))) + (ty @6.32-6.36 (name "Bool")))) + (s-decl @7.1-10.2 + (p-ident @7.1-7.6 (raw "is_ok")) + (e-lambda @7.9-10.2 (args - (p-ident @9.10-9.16 (raw "result"))) + (p-ident @7.10-7.16 (raw "result"))) (e-match - (e-ident @9.24-9.30 (raw "result")) + (e-ident @7.24-7.30 (raw "result")) (branches - (branch @10.5-10.32 - (p-tag @10.5-10.19 (raw ".Ok") + (branch @8.5-8.32 + (p-tag @8.5-8.19 (raw ".Ok") (p-underscore)) - (e-tag @10.23-10.32 (raw "Bool.True"))) - (branch @11.5-11.34 - (p-tag @11.5-11.20 (raw ".Err") + (e-tag @8.23-8.32 (raw "Bool.True"))) + (branch @9.5-9.34 + (p-tag @9.5-9.20 (raw ".Err") (p-underscore)) - (e-tag @11.24-11.34 (raw "Bool.False"))))))))) + (e-tag @9.24-9.34 (raw "Bool.False"))))))))) ~~~ # FORMATTED ~~~roc -module [MyResult, ok, is_ok] - MyResult(ok, err) := [Ok(ok), Err(err)] ok : ok -> MyResult(ok, _) @@ -117,80 +106,80 @@ is_ok = |result| match result { ~~~clojure (can-ir (d-let - (p-assign @6.1-6.3 (ident "ok")) - (e-lambda @6.6-6.24 + (p-assign @4.1-4.3 (ident "ok")) + (e-lambda @4.6-4.24 (args - (p-assign @6.7-6.8 (ident "a"))) - (e-nominal @6.10-6.24 (nominal "MyResult") - (e-tag @6.10-6.24 (name "Ok") + (p-assign @4.7-4.8 (ident "a"))) + (e-nominal @4.10-4.24 (nominal "MyResult") + (e-tag @4.10-4.24 (name "Ok") (args - (e-lookup-local @6.22-6.23 - (p-assign @6.7-6.8 (ident "a"))))))) - (annotation @6.1-6.3 + (e-lookup-local @4.22-4.23 + (p-assign @4.7-4.8 (ident "a"))))))) + (annotation @4.1-4.3 (declared-type - (ty-fn @5.6-5.27 (effectful false) - (ty-var @5.6-5.8 (name "ok")) - (ty-apply @5.12-5.27 (symbol "MyResult") - (ty-var @5.21-5.23 (name "ok")) - (ty-underscore @1.1-1.1)))))) + (ty-fn @3.6-3.27 (effectful false) + (ty-rigid-var @3.6-3.8 (name "ok")) + (ty-apply @3.12-3.27 (name "MyResult") (local) + (ty-rigid-var-lookup (ty-rigid-var @3.6-3.8 (name "ok"))) + (ty-underscore @3.12-3.27)))))) (d-let - (p-assign @9.1-9.6 (ident "is_ok")) - (e-lambda @9.9-12.2 + (p-assign @7.1-7.6 (ident "is_ok")) + (e-lambda @7.9-10.2 (args - (p-assign @9.10-9.16 (ident "result"))) - (e-match @9.18-12.2 - (match @9.18-12.2 + (p-assign @7.10-7.16 (ident "result"))) + (e-match @7.18-10.2 + (match @7.18-10.2 (cond - (e-lookup-local @9.24-9.30 - (p-assign @9.10-9.16 (ident "result")))) + (e-lookup-local @7.24-7.30 + (p-assign @7.10-7.16 (ident "result")))) (branches (branch (patterns (pattern (degenerate false) - (p-nominal @10.5-10.19 - (p-applied-tag @10.5-10.19)))) + (p-nominal @8.5-8.19 + (p-applied-tag @8.5-8.19)))) (value - (e-nominal @10.23-10.32 (nominal "Bool") - (e-tag @10.23-10.32 (name "True"))))) + (e-nominal @8.23-8.32 (nominal "Bool") + (e-tag @8.23-8.32 (name "True"))))) (branch (patterns (pattern (degenerate false) - (p-nominal @11.5-11.20 - (p-applied-tag @11.5-11.20)))) + (p-nominal @9.5-9.20 + (p-applied-tag @9.5-9.20)))) (value - (e-nominal @11.24-11.34 (nominal "Bool") - (e-tag @11.24-11.34 (name "False"))))))))) - (annotation @9.1-9.6 + (e-nominal @9.24-9.34 (nominal "Bool") + (e-tag @9.24-9.34 (name "False"))))))))) + (annotation @7.1-7.6 (declared-type - (ty-fn @8.9-8.36 (effectful false) - (ty-apply @8.9-8.28 (symbol "MyResult") - (ty-var @8.18-8.21 (name "_ok")) - (ty-var @8.23-8.27 (name "_err"))) - (ty @8.32-8.36 (name "Bool")))))) - (s-nominal-decl @3.1-3.40 - (ty-header @3.1-3.18 (name "MyResult") + (ty-fn @6.9-6.36 (effectful false) + (ty-apply @6.9-6.28 (name "MyResult") (local) + (ty-rigid-var @6.9-6.28 (name "_ok")) + (ty-rigid-var @6.9-6.28 (name "_err"))) + (ty-lookup @6.32-6.36 (name "Bool") (local)))))) + (s-nominal-decl @1.1-1.40 + (ty-header @1.1-1.18 (name "MyResult") (ty-args - (ty-var @3.10-3.12 (name "ok")) - (ty-var @3.14-3.17 (name "err")))) - (ty-tag-union @3.22-3.40 - (ty-apply @3.23-3.29 (symbol "Ok") - (ty-var @3.26-3.28 (name "ok"))) - (ty-apply @3.31-3.39 (symbol "Err") - (ty-var @3.35-3.38 (name "err")))))) + (ty-rigid-var @1.10-1.12 (name "ok")) + (ty-rigid-var @1.14-1.17 (name "err")))) + (ty-tag-union @1.22-1.40 + (ty-tag-name @1.23-1.29 (name "Ok") + (ty-rigid-var-lookup (ty-rigid-var @1.10-1.12 (name "ok")))) + (ty-tag-name @1.31-1.39 (name "Err") + (ty-rigid-var-lookup (ty-rigid-var @1.14-1.17 (name "err"))))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @6.1-6.3 (type "ok -> MyResult(ok, err)")) - (patt @9.1-9.6 (type "MyResult(_ok, _err) -> Bool"))) + (patt @4.1-4.3 (type "ok -> MyResult(ok, err)")) + (patt @7.1-7.6 (type "MyResult(_ok, _err) -> Bool"))) (type_decls - (nominal @3.1-3.40 (type "MyResult(ok, err)") - (ty-header @3.1-3.18 (name "MyResult") + (nominal @1.1-1.40 (type "MyResult(ok, err)") + (ty-header @1.1-1.18 (name "MyResult") (ty-args - (ty-var @3.10-3.12 (name "ok")) - (ty-var @3.14-3.17 (name "err")))))) + (ty-rigid-var @1.10-1.12 (name "ok")) + (ty-rigid-var @1.14-1.17 (name "err")))))) (expressions - (expr @6.6-6.24 (type "ok -> MyResult(ok, err)")) - (expr @9.9-12.2 (type "MyResult(_ok, _err) -> Bool")))) + (expr @4.6-4.24 (type "ok -> MyResult(ok, err)")) + (expr @7.9-10.2 (type "MyResult(_ok, _err) -> Bool")))) ~~~ diff --git a/test/snapshots/nominal/nominal_tag_recursive_payload.md b/test/snapshots/nominal/nominal_tag_recursive_payload.md index b009036d1a..962b1393f7 100644 --- a/test/snapshots/nominal/nominal_tag_recursive_payload.md +++ b/test/snapshots/nominal/nominal_tag_recursive_payload.md @@ -1,12 +1,10 @@ # META ~~~ini description=Example of a recursive nominal tag union with payload -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [ConsList, empty] - ConsList(a) := [Nil, Node(ConsList(a))] empty : ConsList(_a) @@ -18,40 +16,35 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:17),Comma(1:17-1:18),LowerIdent(1:19-1:24),CloseSquare(1:24-1:25), -UpperIdent(3:1-3:9),NoSpaceOpenRound(3:9-3:10),LowerIdent(3:10-3:11),CloseRound(3:11-3:12),OpColonEqual(3:13-3:15),OpenSquare(3:16-3:17),UpperIdent(3:17-3:20),Comma(3:20-3:21),UpperIdent(3:22-3:26),NoSpaceOpenRound(3:26-3:27),UpperIdent(3:27-3:35),NoSpaceOpenRound(3:35-3:36),LowerIdent(3:36-3:37),CloseRound(3:37-3:38),CloseRound(3:38-3:39),CloseSquare(3:39-3:40), -LowerIdent(5:1-5:6),OpColon(5:7-5:8),UpperIdent(5:9-5:17),NoSpaceOpenRound(5:17-5:18),NamedUnderscore(5:18-5:20),CloseRound(5:20-5:21), -LowerIdent(6:1-6:6),OpAssign(6:7-6:8),UpperIdent(6:9-6:17),NoSpaceDotUpperIdent(6:17-6:21), -EndOfFile(7:1-7:1), +UpperIdent(1:1-1:9),NoSpaceOpenRound(1:9-1:10),LowerIdent(1:10-1:11),CloseRound(1:11-1:12),OpColonEqual(1:13-1:15),OpenSquare(1:16-1:17),UpperIdent(1:17-1:20),Comma(1:20-1:21),UpperIdent(1:22-1:26),NoSpaceOpenRound(1:26-1:27),UpperIdent(1:27-1:35),NoSpaceOpenRound(1:35-1:36),LowerIdent(1:36-1:37),CloseRound(1:37-1:38),CloseRound(1:38-1:39),CloseSquare(1:39-1:40), +LowerIdent(3:1-3:6),OpColon(3:7-3:8),UpperIdent(3:9-3:17),NoSpaceOpenRound(3:17-3:18),NamedUnderscore(3:18-3:20),CloseRound(3:20-3:21), +LowerIdent(4:1-4:6),OpAssign(4:7-4:8),UpperIdent(4:9-4:17),NoSpaceDotUpperIdent(4:17-4:21), +EndOfFile(5:1-5:1), ~~~ # PARSE ~~~clojure -(file @1.1-6.21 - (module @1.1-1.25 - (exposes @1.8-1.25 - (exposed-upper-ident @1.9-1.17 (text "ConsList")) - (exposed-lower-ident @1.19-1.24 - (text "empty")))) +(file @1.1-4.21 + (type-module @1.1-1.9) (statements - (s-type-decl @3.1-3.40 - (header @3.1-3.12 (name "ConsList") + (s-type-decl @1.1-1.40 + (header @1.1-1.12 (name "ConsList") (args - (ty-var @3.10-3.11 (raw "a")))) - (ty-tag-union @3.16-3.40 + (ty-var @1.10-1.11 (raw "a")))) + (ty-tag-union @1.16-1.40 (tags - (ty @3.17-3.20 (name "Nil")) - (ty-apply @3.22-3.39 - (ty @3.22-3.26 (name "Node")) - (ty-apply @3.27-3.38 - (ty @3.27-3.35 (name "ConsList")) - (ty-var @3.36-3.37 (raw "a"))))))) - (s-type-anno @5.1-5.21 (name "empty") - (ty-apply @5.9-5.21 - (ty @5.9-5.17 (name "ConsList")) - (underscore-ty-var @5.18-5.20 (raw "_a")))) - (s-decl @6.1-6.21 - (p-ident @6.1-6.6 (raw "empty")) - (e-tag @6.9-6.21 (raw "ConsList.Nil"))))) + (ty @1.17-1.20 (name "Nil")) + (ty-apply @1.22-1.39 + (ty @1.22-1.26 (name "Node")) + (ty-apply @1.27-1.38 + (ty @1.27-1.35 (name "ConsList")) + (ty-var @1.36-1.37 (raw "a"))))))) + (s-type-anno @3.1-3.21 (name "empty") + (ty-apply @3.9-3.21 + (ty @3.9-3.17 (name "ConsList")) + (underscore-ty-var @3.18-3.20 (raw "_a")))) + (s-decl @4.1-4.21 + (p-ident @4.1-4.6 (raw "empty")) + (e-tag @4.9-4.21 (raw "ConsList.Nil"))))) ~~~ # FORMATTED ~~~roc @@ -61,33 +54,33 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @6.1-6.6 (ident "empty")) - (e-nominal @6.9-6.21 (nominal "ConsList") - (e-tag @6.9-6.21 (name "Nil"))) - (annotation @6.1-6.6 + (p-assign @4.1-4.6 (ident "empty")) + (e-nominal @4.9-4.21 (nominal "ConsList") + (e-tag @4.9-4.21 (name "Nil"))) + (annotation @4.1-4.6 (declared-type - (ty-apply @5.9-5.21 (symbol "ConsList") - (ty-var @5.18-5.20 (name "_a")))))) - (s-nominal-decl @3.1-3.40 - (ty-header @3.1-3.12 (name "ConsList") + (ty-apply @3.9-3.21 (name "ConsList") (local) + (ty-rigid-var @3.9-3.21 (name "_a")))))) + (s-nominal-decl @1.1-1.40 + (ty-header @1.1-1.12 (name "ConsList") (ty-args - (ty-var @3.10-3.11 (name "a")))) - (ty-tag-union @3.16-3.40 - (ty @3.17-3.20 (name "Nil")) - (ty-apply @3.22-3.39 (symbol "Node") - (ty-apply @3.27-3.38 (symbol "ConsList") - (ty-var @3.36-3.37 (name "a"))))))) + (ty-rigid-var @1.10-1.11 (name "a")))) + (ty-tag-union @1.16-1.40 + (ty-tag-name @1.17-1.20 (name "Nil")) + (ty-tag-name @1.22-1.39 (name "Node") + (ty-apply @1.27-1.38 (name "ConsList") (local) + (ty-rigid-var-lookup (ty-rigid-var @1.10-1.11 (name "a")))))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @6.1-6.6 (type "ConsList(a)"))) + (patt @4.1-4.6 (type "ConsList(_a)"))) (type_decls - (nominal @3.1-3.40 (type "ConsList(a)") - (ty-header @3.1-3.12 (name "ConsList") + (nominal @1.1-1.40 (type "ConsList(a)") + (ty-header @1.1-1.12 (name "ConsList") (ty-args - (ty-var @3.10-3.11 (name "a")))))) + (ty-rigid-var @1.10-1.11 (name "a")))))) (expressions - (expr @6.9-6.21 (type "ConsList(a)")))) + (expr @4.9-4.21 (type "ConsList(_a)")))) ~~~ diff --git a/test/snapshots/nominal/nominal_tag_simple.md b/test/snapshots/nominal/nominal_tag_simple.md index 032be960d8..f9626d7a06 100644 --- a/test/snapshots/nominal/nominal_tag_simple.md +++ b/test/snapshots/nominal/nominal_tag_simple.md @@ -1,12 +1,10 @@ # META ~~~ini description=Example of a simple nominal tag union -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [Color, blue] - Color := [Red, Green, Blue] blue : Color @@ -16,11 +14,11 @@ yellow : Color yellow = Color.Yellow ~~~ # EXPECTED -INVALID NOMINAL TAG - nominal_tag_simple.md:9:10:9:22 +INVALID NOMINAL TAG - nominal_tag_simple.md:7:10:7:22 # PROBLEMS **INVALID NOMINAL TAG** I'm having trouble with this nominal tag: -**nominal_tag_simple.md:9:10:9:22:** +**nominal_tag_simple.md:7:10:7:22:** ```roc yellow = Color.Yellow ``` @@ -29,46 +27,41 @@ yellow = Color.Yellow The tag is: _Yellow_ -But it should be one of: +But the nominal type needs it to one of: _[Blue, Green, Red]_ # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:14),Comma(1:14-1:15),LowerIdent(1:16-1:20),CloseSquare(1:20-1:21), -UpperIdent(3:1-3:6),OpColonEqual(3:7-3:9),OpenSquare(3:10-3:11),UpperIdent(3:11-3:14),Comma(3:14-3:15),UpperIdent(3:16-3:21),Comma(3:21-3:22),UpperIdent(3:23-3:27),CloseSquare(3:27-3:28), -LowerIdent(5:1-5:5),OpColon(5:6-5:7),UpperIdent(5:8-5:13), -LowerIdent(6:1-6:5),OpAssign(6:6-6:7),UpperIdent(6:8-6:13),NoSpaceDotUpperIdent(6:13-6:18), -LowerIdent(8:1-8:7),OpColon(8:8-8:9),UpperIdent(8:10-8:15), -LowerIdent(9:1-9:7),OpAssign(9:8-9:9),UpperIdent(9:10-9:15),NoSpaceDotUpperIdent(9:15-9:22), -EndOfFile(10:1-10:1), +UpperIdent(1:1-1:6),OpColonEqual(1:7-1:9),OpenSquare(1:10-1:11),UpperIdent(1:11-1:14),Comma(1:14-1:15),UpperIdent(1:16-1:21),Comma(1:21-1:22),UpperIdent(1:23-1:27),CloseSquare(1:27-1:28), +LowerIdent(3:1-3:5),OpColon(3:6-3:7),UpperIdent(3:8-3:13), +LowerIdent(4:1-4:5),OpAssign(4:6-4:7),UpperIdent(4:8-4:13),NoSpaceDotUpperIdent(4:13-4:18), +LowerIdent(6:1-6:7),OpColon(6:8-6:9),UpperIdent(6:10-6:15), +LowerIdent(7:1-7:7),OpAssign(7:8-7:9),UpperIdent(7:10-7:15),NoSpaceDotUpperIdent(7:15-7:22), +EndOfFile(8:1-8:1), ~~~ # PARSE ~~~clojure -(file @1.1-9.22 - (module @1.1-1.21 - (exposes @1.8-1.21 - (exposed-upper-ident @1.9-1.14 (text "Color")) - (exposed-lower-ident @1.16-1.20 - (text "blue")))) +(file @1.1-7.22 + (type-module @1.1-1.6) (statements - (s-type-decl @3.1-3.28 - (header @3.1-3.6 (name "Color") + (s-type-decl @1.1-1.28 + (header @1.1-1.6 (name "Color") (args)) - (ty-tag-union @3.10-3.28 + (ty-tag-union @1.10-1.28 (tags - (ty @3.11-3.14 (name "Red")) - (ty @3.16-3.21 (name "Green")) - (ty @3.23-3.27 (name "Blue"))))) - (s-type-anno @5.1-5.13 (name "blue") - (ty @5.8-5.13 (name "Color"))) - (s-decl @6.1-6.18 - (p-ident @6.1-6.5 (raw "blue")) - (e-tag @6.8-6.18 (raw "Color.Blue"))) - (s-type-anno @8.1-8.15 (name "yellow") - (ty @8.10-8.15 (name "Color"))) - (s-decl @9.1-9.22 - (p-ident @9.1-9.7 (raw "yellow")) - (e-tag @9.10-9.22 (raw "Color.Yellow"))))) + (ty @1.11-1.14 (name "Red")) + (ty @1.16-1.21 (name "Green")) + (ty @1.23-1.27 (name "Blue"))))) + (s-type-anno @3.1-3.13 (name "blue") + (ty @3.8-3.13 (name "Color"))) + (s-decl @4.1-4.18 + (p-ident @4.1-4.5 (raw "blue")) + (e-tag @4.8-4.18 (raw "Color.Blue"))) + (s-type-anno @6.1-6.15 (name "yellow") + (ty @6.10-6.15 (name "Color"))) + (s-decl @7.1-7.22 + (p-ident @7.1-7.7 (raw "yellow")) + (e-tag @7.10-7.22 (raw "Color.Yellow"))))) ~~~ # FORMATTED ~~~roc @@ -78,36 +71,36 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @6.1-6.5 (ident "blue")) - (e-nominal @6.8-6.18 (nominal "Color") - (e-tag @6.8-6.18 (name "Blue"))) - (annotation @6.1-6.5 + (p-assign @4.1-4.5 (ident "blue")) + (e-nominal @4.8-4.18 (nominal "Color") + (e-tag @4.8-4.18 (name "Blue"))) + (annotation @4.1-4.5 (declared-type - (ty @5.8-5.13 (name "Color"))))) + (ty-lookup @3.8-3.13 (name "Color") (local))))) (d-let - (p-assign @9.1-9.7 (ident "yellow")) - (e-nominal @9.10-9.22 (nominal "Color") - (e-tag @9.10-9.22 (name "Yellow"))) - (annotation @9.1-9.7 + (p-assign @7.1-7.7 (ident "yellow")) + (e-nominal @7.10-7.22 (nominal "Color") + (e-tag @7.10-7.22 (name "Yellow"))) + (annotation @7.1-7.7 (declared-type - (ty @8.10-8.15 (name "Color"))))) - (s-nominal-decl @3.1-3.28 - (ty-header @3.1-3.6 (name "Color")) - (ty-tag-union @3.10-3.28 - (ty @3.11-3.14 (name "Red")) - (ty @3.16-3.21 (name "Green")) - (ty @3.23-3.27 (name "Blue"))))) + (ty-lookup @6.10-6.15 (name "Color") (local))))) + (s-nominal-decl @1.1-1.28 + (ty-header @1.1-1.6 (name "Color")) + (ty-tag-union @1.10-1.28 + (ty-tag-name @1.11-1.14 (name "Red")) + (ty-tag-name @1.16-1.21 (name "Green")) + (ty-tag-name @1.23-1.27 (name "Blue"))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @6.1-6.5 (type "Error")) - (patt @9.1-9.7 (type "Error"))) + (patt @4.1-4.5 (type "Color")) + (patt @7.1-7.7 (type "Error"))) (type_decls - (nominal @3.1-3.28 (type "Error") - (ty-header @3.1-3.6 (name "Color")))) + (nominal @1.1-1.28 (type "Color") + (ty-header @1.1-1.6 (name "Color")))) (expressions - (expr @6.8-6.18 (type "Error")) - (expr @9.10-9.22 (type "Error")))) + (expr @4.8-4.18 (type "Color")) + (expr @7.10-7.22 (type "Error")))) ~~~ diff --git a/test/snapshots/nominal/nominal_type_with_associated_multi_statement.md b/test/snapshots/nominal/nominal_type_with_associated_multi_statement.md new file mode 100644 index 0000000000..5534844f13 --- /dev/null +++ b/test/snapshots/nominal/nominal_type_with_associated_multi_statement.md @@ -0,0 +1,92 @@ +# META +~~~ini +description=Nominal type with multi-statement associated items +type=file:Foo.roc +~~~ +# SOURCE +~~~roc +Foo := [A, B, C].{ + x = 5 + y = 10 + z = 15 +} +~~~ +# EXPECTED +NIL +# PROBLEMS +NIL +# TOKENS +~~~zig +UpperIdent(1:1-1:4),OpColonEqual(1:5-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:10),Comma(1:10-1:11),UpperIdent(1:12-1:13),Comma(1:13-1:14),UpperIdent(1:15-1:16),CloseSquare(1:16-1:17),Dot(1:17-1:18),OpenCurly(1:18-1:19), +LowerIdent(2:5-2:6),OpAssign(2:7-2:8),Int(2:9-2:10), +LowerIdent(3:5-3:6),OpAssign(3:7-3:8),Int(3:9-3:11), +LowerIdent(4:5-4:6),OpAssign(4:7-4:8),Int(4:9-4:11), +CloseCurly(5:1-5:2), +EndOfFile(6:1-6:1), +~~~ +# PARSE +~~~clojure +(file @1.1-5.2 + (type-module @1.1-1.4) + (statements + (s-type-decl @1.1-5.2 + (header @1.1-1.4 (name "Foo") + (args)) + (ty-tag-union @1.8-1.17 + (tags + (ty @1.9-1.10 (name "A")) + (ty @1.12-1.13 (name "B")) + (ty @1.15-1.16 (name "C")))) + (associated @1.18-5.2 + (s-decl @2.5-2.10 + (p-ident @2.5-2.6 (raw "x")) + (e-int @2.9-2.10 (raw "5"))) + (s-decl @3.5-3.11 + (p-ident @3.5-3.6 (raw "y")) + (e-int @3.9-3.11 (raw "10"))) + (s-decl @4.5-4.11 + (p-ident @4.5-4.6 (raw "z")) + (e-int @4.9-4.11 (raw "15"))))))) +~~~ +# FORMATTED +~~~roc +Foo := [A, B, C].{ + x = 5 + y = 10 + z = 15 +} +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @2.5-2.10 (ident "Foo.x")) + (e-num @2.9-2.10 (value "5"))) + (d-let + (p-assign @3.5-3.11 (ident "Foo.y")) + (e-num @3.9-3.11 (value "10"))) + (d-let + (p-assign @4.5-4.11 (ident "Foo.z")) + (e-num @4.9-4.11 (value "15"))) + (s-nominal-decl @1.1-5.2 + (ty-header @1.1-1.4 (name "Foo")) + (ty-tag-union @1.8-1.17 + (ty-tag-name @1.9-1.10 (name "A")) + (ty-tag-name @1.12-1.13 (name "B")) + (ty-tag-name @1.15-1.16 (name "C"))))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @2.5-2.10 (type "Num(_size)")) + (patt @3.5-3.11 (type "Num(_size)")) + (patt @4.5-4.11 (type "Num(_size)"))) + (type_decls + (nominal @1.1-5.2 (type "Foo") + (ty-header @1.1-1.4 (name "Foo")))) + (expressions + (expr @2.9-2.10 (type "Num(_size)")) + (expr @3.9-3.11 (type "Num(_size)")) + (expr @4.9-4.11 (type "Num(_size)")))) +~~~ diff --git a/test/snapshots/nominal/nominal_type_with_associated_single_statement.md b/test/snapshots/nominal/nominal_type_with_associated_single_statement.md new file mode 100644 index 0000000000..907fe1ee55 --- /dev/null +++ b/test/snapshots/nominal/nominal_type_with_associated_single_statement.md @@ -0,0 +1,66 @@ +# META +~~~ini +description=Nominal type with single statement associated items +type=file:Foo.roc +~~~ +# SOURCE +~~~roc +Foo := [A, B, C].{ x = 5 } +~~~ +# EXPECTED +NIL +# PROBLEMS +NIL +# TOKENS +~~~zig +UpperIdent(1:1-1:4),OpColonEqual(1:5-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:10),Comma(1:10-1:11),UpperIdent(1:12-1:13),Comma(1:13-1:14),UpperIdent(1:15-1:16),CloseSquare(1:16-1:17),Dot(1:17-1:18),OpenCurly(1:18-1:19),LowerIdent(1:20-1:21),OpAssign(1:22-1:23),Int(1:24-1:25),CloseCurly(1:26-1:27), +EndOfFile(2:1-2:1), +~~~ +# PARSE +~~~clojure +(file @1.1-1.27 + (type-module @1.1-1.4) + (statements + (s-type-decl @1.1-1.27 + (header @1.1-1.4 (name "Foo") + (args)) + (ty-tag-union @1.8-1.17 + (tags + (ty @1.9-1.10 (name "A")) + (ty @1.12-1.13 (name "B")) + (ty @1.15-1.16 (name "C")))) + (associated @1.18-1.27 + (s-decl @1.20-1.25 + (p-ident @1.20-1.21 (raw "x")) + (e-int @1.24-1.25 (raw "5"))))))) +~~~ +# FORMATTED +~~~roc +Foo := [A, B, C].{ + x = 5 +} +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @1.20-1.25 (ident "Foo.x")) + (e-num @1.24-1.25 (value "5"))) + (s-nominal-decl @1.1-1.27 + (ty-header @1.1-1.4 (name "Foo")) + (ty-tag-union @1.8-1.17 + (ty-tag-name @1.9-1.10 (name "A")) + (ty-tag-name @1.12-1.13 (name "B")) + (ty-tag-name @1.15-1.16 (name "C"))))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @1.20-1.25 (type "Num(_size)"))) + (type_decls + (nominal @1.1-1.27 (type "Foo") + (ty-header @1.1-1.4 (name "Foo")))) + (expressions + (expr @1.24-1.25 (type "Num(_size)")))) +~~~ diff --git a/test/snapshots/nominal/nominal_type_with_empty_associated.md b/test/snapshots/nominal/nominal_type_with_empty_associated.md new file mode 100644 index 0000000000..1a84d2cba2 --- /dev/null +++ b/test/snapshots/nominal/nominal_type_with_empty_associated.md @@ -0,0 +1,56 @@ +# META +~~~ini +description=Nominal type with empty associated items block +type=snippet +~~~ +# SOURCE +~~~roc +Foo := [A, B, C].{} +~~~ +# EXPECTED +NIL +# PROBLEMS +NIL +# TOKENS +~~~zig +UpperIdent(1:1-1:4),OpColonEqual(1:5-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:10),Comma(1:10-1:11),UpperIdent(1:12-1:13),Comma(1:13-1:14),UpperIdent(1:15-1:16),CloseSquare(1:16-1:17),Dot(1:17-1:18),OpenCurly(1:18-1:19),CloseCurly(1:19-1:20), +EndOfFile(2:1-2:1), +~~~ +# PARSE +~~~clojure +(file @1.1-1.20 + (type-module @1.1-1.4) + (statements + (s-type-decl @1.1-1.20 + (header @1.1-1.4 (name "Foo") + (args)) + (ty-tag-union @1.8-1.17 + (tags + (ty @1.9-1.10 (name "A")) + (ty @1.12-1.13 (name "B")) + (ty @1.15-1.16 (name "C")))) + (associated @1.18-1.20)))) +~~~ +# FORMATTED +~~~roc +NO CHANGE +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (s-nominal-decl @1.1-1.20 + (ty-header @1.1-1.4 (name "Foo")) + (ty-tag-union @1.8-1.17 + (ty-tag-name @1.9-1.10 (name "A")) + (ty-tag-name @1.12-1.13 (name "B")) + (ty-tag-name @1.15-1.16 (name "C"))))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs) + (type_decls + (nominal @1.1-1.20 (type "Foo") + (ty-header @1.1-1.4 (name "Foo")))) + (expressions)) +~~~ diff --git a/test/snapshots/nominal/nominal_undefined_deeply_nested_tag.md b/test/snapshots/nominal/nominal_undefined_deeply_nested_tag.md new file mode 100644 index 0000000000..b6b75f07ae --- /dev/null +++ b/test/snapshots/nominal/nominal_undefined_deeply_nested_tag.md @@ -0,0 +1,78 @@ +# META +~~~ini +description=Error for undefined deeply nested tag (no fallback to module) +type=snippet +~~~ +# SOURCE +~~~roc +Foo := [A, B, C] + +# This should error as "undeclared type Foo.Bar.Baz" +# NOT try to interpret it as a module import +x = Foo.Bar.Baz.X +~~~ +# EXPECTED +UNDECLARED TYPE - nominal_undefined_deeply_nested_tag.md:5:12:5:16 +# PROBLEMS +**UNDECLARED TYPE** +The type _Foo.Bar.Baz_ is not declared in this scope. + +This type is referenced here: +**nominal_undefined_deeply_nested_tag.md:5:12:5:16:** +```roc +x = Foo.Bar.Baz.X +``` + ^^^^ + + +# TOKENS +~~~zig +UpperIdent(1:1-1:4),OpColonEqual(1:5-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:10),Comma(1:10-1:11),UpperIdent(1:12-1:13),Comma(1:13-1:14),UpperIdent(1:15-1:16),CloseSquare(1:16-1:17), +LowerIdent(5:1-5:2),OpAssign(5:3-5:4),UpperIdent(5:5-5:8),NoSpaceDotUpperIdent(5:8-5:12),NoSpaceDotUpperIdent(5:12-5:16),NoSpaceDotUpperIdent(5:16-5:18), +EndOfFile(6:1-6:1), +~~~ +# PARSE +~~~clojure +(file @1.1-5.18 + (type-module @1.1-1.4) + (statements + (s-type-decl @1.1-1.17 + (header @1.1-1.4 (name "Foo") + (args)) + (ty-tag-union @1.8-1.17 + (tags + (ty @1.9-1.10 (name "A")) + (ty @1.12-1.13 (name "B")) + (ty @1.15-1.16 (name "C"))))) + (s-decl @5.1-5.18 + (p-ident @5.1-5.2 (raw "x")) + (e-tag @5.5-5.18 (raw "Foo.Bar.Baz.X"))))) +~~~ +# FORMATTED +~~~roc +NO CHANGE +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @5.1-5.2 (ident "x")) + (e-runtime-error (tag "undeclared_type"))) + (s-nominal-decl @1.1-1.17 + (ty-header @1.1-1.4 (name "Foo")) + (ty-tag-union @1.8-1.17 + (ty-tag-name @1.9-1.10 (name "A")) + (ty-tag-name @1.12-1.13 (name "B")) + (ty-tag-name @1.15-1.16 (name "C"))))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @5.1-5.2 (type "Error"))) + (type_decls + (nominal @1.1-1.17 (type "Foo") + (ty-header @1.1-1.4 (name "Foo")))) + (expressions + (expr @5.12-5.16 (type "Error")))) +~~~ diff --git a/test/snapshots/nominal/type_alias_with_associated.md b/test/snapshots/nominal/type_alias_with_associated.md new file mode 100644 index 0000000000..c77dab88c1 --- /dev/null +++ b/test/snapshots/nominal/type_alias_with_associated.md @@ -0,0 +1,77 @@ +# META +~~~ini +description=Type alias with associated items produces error +type=file:Foo.roc +~~~ +# SOURCE +~~~roc +Foo : [A, B, C].{ x = 5 } +~~~ +# EXPECTED +TYPE ALIAS WITH ASSOCIATED ITEMS - type_alias_with_associated.md:1:16:1:17 +# PROBLEMS +**TYPE ALIAS WITH ASSOCIATED ITEMS** +Type aliases cannot have associated items (such as types or methods). + +Only nominal types (defined with **:=**) can have associated items. Type aliases (defined with **:**) only define names for other types. + +**type_alias_with_associated.md:1:16:1:17:** +```roc +Foo : [A, B, C].{ x = 5 } +``` + ^ + + +# TOKENS +~~~zig +UpperIdent(1:1-1:4),OpColon(1:5-1:6),OpenSquare(1:7-1:8),UpperIdent(1:8-1:9),Comma(1:9-1:10),UpperIdent(1:11-1:12),Comma(1:12-1:13),UpperIdent(1:14-1:15),CloseSquare(1:15-1:16),Dot(1:16-1:17),OpenCurly(1:17-1:18),LowerIdent(1:19-1:20),OpAssign(1:21-1:22),Int(1:23-1:24),CloseCurly(1:25-1:26), +EndOfFile(2:1-2:1), +~~~ +# PARSE +~~~clojure +(file @1.1-1.26 + (type-module @1.1-1.4) + (statements + (s-type-decl @1.1-1.26 + (header @1.1-1.4 (name "Foo") + (args)) + (ty-tag-union @1.7-1.16 + (tags + (ty @1.8-1.9 (name "A")) + (ty @1.11-1.12 (name "B")) + (ty @1.14-1.15 (name "C")))) + (associated @1.17-1.26 + (s-decl @1.19-1.24 + (p-ident @1.19-1.20 (raw "x")) + (e-int @1.23-1.24 (raw "5"))))))) +~~~ +# FORMATTED +~~~roc +Foo : [A, B, C].{ + x = 5 +} +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @1.19-1.24 (ident "Foo.x")) + (e-num @1.23-1.24 (value "5"))) + (s-alias-decl @1.1-1.26 + (ty-header @1.1-1.4 (name "Foo")) + (ty-tag-union @1.7-1.16 + (ty-tag-name @1.8-1.9 (name "A")) + (ty-tag-name @1.11-1.12 (name "B")) + (ty-tag-name @1.14-1.15 (name "C"))))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @1.19-1.24 (type "Num(_size)"))) + (type_decls + (alias @1.1-1.26 (type "Foo") + (ty-header @1.1-1.4 (name "Foo")))) + (expressions + (expr @1.23-1.24 (type "Num(_size)")))) +~~~ diff --git a/test/snapshots/nominal/type_module_associated_items_exposed.md b/test/snapshots/nominal/type_module_associated_items_exposed.md new file mode 100644 index 0000000000..578ecc5efe --- /dev/null +++ b/test/snapshots/nominal/type_module_associated_items_exposed.md @@ -0,0 +1,94 @@ +# META +~~~ini +description=Type module with associated items should not report unused variables +type=file:Foo.roc +~~~ +# SOURCE +~~~roc +Foo := [Blah].{ + Bar := {}.{ + baz = {} + } + + stuff = {} +} +~~~ +# EXPECTED +NIL +# PROBLEMS +NIL +# TOKENS +~~~zig +UpperIdent(1:1-1:4),OpColonEqual(1:5-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:13),CloseSquare(1:13-1:14),Dot(1:14-1:15),OpenCurly(1:15-1:16), +UpperIdent(2:5-2:8),OpColonEqual(2:9-2:11),OpenCurly(2:12-2:13),CloseCurly(2:13-2:14),Dot(2:14-2:15),OpenCurly(2:15-2:16), +LowerIdent(3:9-3:12),OpAssign(3:13-3:14),OpenCurly(3:15-3:16),CloseCurly(3:16-3:17), +CloseCurly(4:5-4:6), +LowerIdent(6:5-6:10),OpAssign(6:11-6:12),OpenCurly(6:13-6:14),CloseCurly(6:14-6:15), +CloseCurly(7:1-7:2), +EndOfFile(8:1-8:1), +~~~ +# PARSE +~~~clojure +(file @1.1-7.2 + (type-module @1.1-1.4) + (statements + (s-type-decl @1.1-7.2 + (header @1.1-1.4 (name "Foo") + (args)) + (ty-tag-union @1.8-1.14 + (tags + (ty @1.9-1.13 (name "Blah")))) + (associated @1.15-7.2 + (s-type-decl @2.5-4.6 + (header @2.5-2.8 (name "Bar") + (args)) + (ty-record @2.12-2.14) + (associated @2.15-4.6 + (s-decl @3.9-3.17 + (p-ident @3.9-3.12 (raw "baz")) + (e-record @3.15-3.17)))) + (s-decl @6.5-6.15 + (p-ident @6.5-6.10 (raw "stuff")) + (e-record @6.13-6.15)))))) +~~~ +# FORMATTED +~~~roc +Foo := [Blah].{ + Bar := {}.{ + baz = {} + } + stuff = {} +} +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @3.9-3.17 (ident "Foo.Bar.baz")) + (e-empty_record @3.15-3.17)) + (d-let + (p-assign @6.5-6.15 (ident "Foo.stuff")) + (e-empty_record @6.13-6.15)) + (s-nominal-decl @1.1-7.2 + (ty-header @1.1-1.4 (name "Foo")) + (ty-tag-union @1.8-1.14 + (ty-tag-name @1.9-1.13 (name "Blah")))) + (s-nominal-decl @2.5-4.6 + (ty-header @2.5-4.6 (name "Foo.Bar")) + (ty-record @2.12-2.14))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @3.9-3.17 (type "{}")) + (patt @6.5-6.15 (type "{}"))) + (type_decls + (nominal @1.1-7.2 (type "Foo") + (ty-header @1.1-1.4 (name "Foo"))) + (nominal @2.5-4.6 (type "Foo.Bar") + (ty-header @2.5-4.6 (name "Foo.Bar")))) + (expressions + (expr @3.15-3.17 (type "{}")) + (expr @6.13-6.15 (type "{}")))) +~~~ diff --git a/test/snapshots/nominal_type_origin_mismatch.md b/test/snapshots/nominal_type_origin_mismatch.md index 906002f6a4..419300294c 100644 --- a/test/snapshots/nominal_type_origin_mismatch.md +++ b/test/snapshots/nominal_type_origin_mismatch.md @@ -1,12 +1,10 @@ # META ~~~ini description=Type mismatch showing nominal type origin from different module -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - import Data exposing [Person] expectsPerson : Person -> Str @@ -17,15 +15,15 @@ main = expectsPerson("not a person") ~~~ # EXPECTED -MODULE NOT FOUND - nominal_type_origin_mismatch.md:3:1:3:30 -UNDECLARED TYPE - nominal_type_origin_mismatch.md:5:17:5:23 -UNUSED VARIABLE - nominal_type_origin_mismatch.md:6:18:6:19 +MODULE NOT FOUND - nominal_type_origin_mismatch.md:1:1:1:30 +UNDECLARED TYPE - nominal_type_origin_mismatch.md:3:17:3:23 +UNUSED VARIABLE - nominal_type_origin_mismatch.md:4:18:4:19 # PROBLEMS **MODULE NOT FOUND** The module `Data` was not found in this Roc project. You're attempting to use this module here: -**nominal_type_origin_mismatch.md:3:1:3:30:** +**nominal_type_origin_mismatch.md:1:1:1:30:** ```roc import Data exposing [Person] ``` @@ -36,7 +34,7 @@ import Data exposing [Person] The type _Person_ is not declared in this scope. This type is referenced here: -**nominal_type_origin_mismatch.md:5:17:5:23:** +**nominal_type_origin_mismatch.md:3:17:3:23:** ```roc expectsPerson : Person -> Str ``` @@ -48,7 +46,7 @@ Variable `p` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_p` to suppress this warning. The unused variable is declared here: -**nominal_type_origin_mismatch.md:6:18:6:19:** +**nominal_type_origin_mismatch.md:4:18:4:19:** ```roc expectsPerson = |p| "Got a person" ``` @@ -57,45 +55,41 @@ expectsPerson = |p| "Got a person" # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -KwImport(3:1-3:7),UpperIdent(3:8-3:12),KwExposing(3:13-3:21),OpenSquare(3:22-3:23),UpperIdent(3:23-3:29),CloseSquare(3:29-3:30), -LowerIdent(5:1-5:14),OpColon(5:15-5:16),UpperIdent(5:17-5:23),OpArrow(5:24-5:26),UpperIdent(5:27-5:30), -LowerIdent(6:1-6:14),OpAssign(6:15-6:16),OpBar(6:17-6:18),LowerIdent(6:18-6:19),OpBar(6:19-6:20),StringStart(6:21-6:22),StringPart(6:22-6:34),StringEnd(6:34-6:35), -LowerIdent(8:1-8:5),OpAssign(8:6-8:7), -LowerIdent(10:5-10:18),NoSpaceOpenRound(10:18-10:19),StringStart(10:19-10:20),StringPart(10:20-10:32),StringEnd(10:32-10:33),CloseRound(10:33-10:34), -EndOfFile(11:1-11:1), +KwImport(1:1-1:7),UpperIdent(1:8-1:12),KwExposing(1:13-1:21),OpenSquare(1:22-1:23),UpperIdent(1:23-1:29),CloseSquare(1:29-1:30), +LowerIdent(3:1-3:14),OpColon(3:15-3:16),UpperIdent(3:17-3:23),OpArrow(3:24-3:26),UpperIdent(3:27-3:30), +LowerIdent(4:1-4:14),OpAssign(4:15-4:16),OpBar(4:17-4:18),LowerIdent(4:18-4:19),OpBar(4:19-4:20),StringStart(4:21-4:22),StringPart(4:22-4:34),StringEnd(4:34-4:35), +LowerIdent(6:1-6:5),OpAssign(6:6-6:7), +LowerIdent(8:5-8:18),NoSpaceOpenRound(8:18-8:19),StringStart(8:19-8:20),StringPart(8:20-8:32),StringEnd(8:32-8:33),CloseRound(8:33-8:34), +EndOfFile(9:1-9:1), ~~~ # PARSE ~~~clojure -(file @1.1-10.34 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-8.34 + (type-module @1.1-1.7) (statements - (s-import @3.1-3.30 (raw "Data") + (s-import @1.1-1.30 (raw "Data") (exposing - (exposed-upper-ident @3.23-3.29 (text "Person")))) - (s-type-anno @5.1-5.30 (name "expectsPerson") - (ty-fn @5.17-5.30 - (ty @5.17-5.23 (name "Person")) - (ty @5.27-5.30 (name "Str")))) - (s-decl @6.1-6.35 - (p-ident @6.1-6.14 (raw "expectsPerson")) - (e-lambda @6.17-6.35 + (exposed-upper-ident @1.23-1.29 (text "Person")))) + (s-type-anno @3.1-3.30 (name "expectsPerson") + (ty-fn @3.17-3.30 + (ty @3.17-3.23 (name "Person")) + (ty @3.27-3.30 (name "Str")))) + (s-decl @4.1-4.35 + (p-ident @4.1-4.14 (raw "expectsPerson")) + (e-lambda @4.17-4.35 (args - (p-ident @6.18-6.19 (raw "p"))) - (e-string @6.21-6.35 - (e-string-part @6.22-6.34 (raw "Got a person"))))) - (s-decl @8.1-10.34 - (p-ident @8.1-8.5 (raw "main")) - (e-apply @10.5-10.34 - (e-ident @10.5-10.18 (raw "expectsPerson")) - (e-string @10.19-10.33 - (e-string-part @10.20-10.32 (raw "not a person"))))))) + (p-ident @4.18-4.19 (raw "p"))) + (e-string @4.21-4.35 + (e-string-part @4.22-4.34 (raw "Got a person"))))) + (s-decl @6.1-8.34 + (p-ident @6.1-6.5 (raw "main")) + (e-apply @8.5-8.34 + (e-ident @8.5-8.18 (raw "expectsPerson")) + (e-string @8.19-8.33 + (e-string-part @8.20-8.32 (raw "not a person"))))))) ~~~ # FORMATTED ~~~roc -module [] - import Data exposing [Person] expectsPerson : Person -> Str @@ -109,25 +103,25 @@ main = ~~~clojure (can-ir (d-let - (p-assign @6.1-6.14 (ident "expectsPerson")) - (e-lambda @6.17-6.35 + (p-assign @4.1-4.14 (ident "expectsPerson")) + (e-lambda @4.17-4.35 (args - (p-assign @6.18-6.19 (ident "p"))) - (e-string @6.21-6.35 - (e-literal @6.22-6.34 (string "Got a person")))) - (annotation @6.1-6.14 + (p-assign @4.18-4.19 (ident "p"))) + (e-string @4.21-4.35 + (e-literal @4.22-4.34 (string "Got a person")))) + (annotation @4.1-4.14 (declared-type - (ty-fn @5.17-5.30 (effectful false) - (ty @5.17-5.23 (name "Person")) - (ty @5.27-5.30 (name "Str")))))) + (ty-fn @3.17-3.30 (effectful false) + (ty-malformed @3.17-3.23) + (ty-lookup @3.27-3.30 (name "Str") (builtin)))))) (d-let - (p-assign @8.1-8.5 (ident "main")) - (e-call @10.5-10.34 - (e-lookup-local @10.5-10.18 - (p-assign @6.1-6.14 (ident "expectsPerson"))) - (e-string @10.19-10.33 - (e-literal @10.20-10.32 (string "not a person"))))) - (s-import @3.1-3.30 (module "Data") + (p-assign @6.1-6.5 (ident "main")) + (e-call @8.5-8.34 + (e-lookup-local @8.5-8.18 + (p-assign @4.1-4.14 (ident "expectsPerson"))) + (e-string @8.19-8.33 + (e-literal @8.20-8.32 (string "not a person"))))) + (s-import @1.1-1.30 (module "Data") (exposes (exposed (name "Person") (wildcard false))))) ~~~ @@ -135,9 +129,9 @@ main = ~~~clojure (inferred-types (defs - (patt @6.1-6.14 (type "Error -> Str")) - (patt @8.1-8.5 (type "Str"))) + (patt @4.1-4.14 (type "Error -> Str")) + (patt @6.1-6.5 (type "Str"))) (expressions - (expr @6.17-6.35 (type "Error -> Str")) - (expr @10.5-10.34 (type "Str")))) + (expr @4.17-4.35 (type "Error -> Str")) + (expr @8.5-8.34 (type "Str")))) ~~~ diff --git a/test/snapshots/numbers.md b/test/snapshots/numbers.md index 1a8332da99..b0d6269d99 100644 --- a/test/snapshots/numbers.md +++ b/test/snapshots/numbers.md @@ -91,19 +91,19 @@ EndOfFile(14:1-14:1), ~~~clojure (e-tuple @1.1-13.2 (elems - (e-int @2.5-2.9 (value "66")) - (e-int @3.5-3.9 (value "66")) - (e-int @4.5-4.9 (value "1")) - (e-int @5.5-5.9 (value "1")) - (e-int @6.5-6.9 (value "34")) - (e-int @7.5-7.9 (value "34")) + (e-num @2.5-2.9 (value "66")) + (e-num @3.5-3.9 (value "66")) + (e-num @4.5-4.9 (value "1")) + (e-num @5.5-5.9 (value "1")) + (e-num @6.5-6.9 (value "34")) + (e-num @7.5-7.9 (value "34")) (e-frac-f64 @8.5-8.11 (value "1e41")) (e-frac-f64 @9.5-9.11 (value "1e41")) - (e-int @10.5-10.15 (value "3735928559")) - (e-int @11.5-11.15 (value "3735928559")) - (e-int @12.5-12.15 (value "3735928559")))) + (e-num @10.5-10.15 (value "3735928559")) + (e-num @11.5-11.15 (value "3735928559")) + (e-num @12.5-12.15 (value "3735928559")))) ~~~ # TYPES ~~~clojure -(expr @1.1-13.2 (type "(Int(_size), Int(_size2), Int(_size3), Int(_size4), Int(_size5), Int(_size6), Frac(_size7), Frac(_size8), Int(_size9), Int(_size10), Int(_size11))")) +(expr @1.1-13.2 (type "(Num(Int(_size)), Num(Int(_size2)), Num(Int(_size3)), Num(Int(_size4)), Num(Int(_size5)), Num(Int(_size6)), Num(Frac(_size7)), Num(Frac(_size8)), Num(Int(_size9)), Num(Int(_size10)), Num(Int(_size11)))")) ~~~ diff --git a/test/snapshots/numeric_edge_cases/dec_above_small_limit.md b/test/snapshots/numeric_edge_cases/dec_above_small_limit.md index 2936a6ce41..02e181a36b 100644 --- a/test/snapshots/numeric_edge_cases/dec_above_small_limit.md +++ b/test/snapshots/numeric_edge_cases/dec_above_small_limit.md @@ -30,5 +30,5 @@ NO CHANGE ~~~ # TYPES ~~~clojure -(expr @1.1-1.8 (type "Frac(_size)")) +(expr @1.1-1.8 (type "Num(Frac(_size))")) ~~~ diff --git a/test/snapshots/numeric_edge_cases/dec_eight_decimals.md b/test/snapshots/numeric_edge_cases/dec_eight_decimals.md index 31b4393453..1875ceed14 100644 --- a/test/snapshots/numeric_edge_cases/dec_eight_decimals.md +++ b/test/snapshots/numeric_edge_cases/dec_eight_decimals.md @@ -30,5 +30,5 @@ NO CHANGE ~~~ # TYPES ~~~clojure -(expr @1.1-1.11 (type "Frac(_size)")) +(expr @1.1-1.11 (type "Num(Frac(_size))")) ~~~ diff --git a/test/snapshots/numeric_edge_cases/dec_exact_power_of_ten.md b/test/snapshots/numeric_edge_cases/dec_exact_power_of_ten.md index 3d83f48068..a9a555fd42 100644 --- a/test/snapshots/numeric_edge_cases/dec_exact_power_of_ten.md +++ b/test/snapshots/numeric_edge_cases/dec_exact_power_of_ten.md @@ -30,5 +30,5 @@ NO CHANGE ~~~ # TYPES ~~~clojure -(expr @1.1-1.6 (type "Frac(_size)")) +(expr @1.1-1.6 (type "Num(Frac(_size))")) ~~~ diff --git a/test/snapshots/numeric_edge_cases/dec_negative_zero.md b/test/snapshots/numeric_edge_cases/dec_negative_zero.md index fde782d3d4..9861304ee0 100644 --- a/test/snapshots/numeric_edge_cases/dec_negative_zero.md +++ b/test/snapshots/numeric_edge_cases/dec_negative_zero.md @@ -30,5 +30,5 @@ NO CHANGE ~~~ # TYPES ~~~clojure -(expr @1.1-1.5 (type "Frac(_size)")) +(expr @1.1-1.5 (type "Num(Frac(_size))")) ~~~ diff --git a/test/snapshots/numeric_edge_cases/dec_scientific_large.md b/test/snapshots/numeric_edge_cases/dec_scientific_large.md index 4901e9c4c4..c4f9bf3694 100644 --- a/test/snapshots/numeric_edge_cases/dec_scientific_large.md +++ b/test/snapshots/numeric_edge_cases/dec_scientific_large.md @@ -30,5 +30,5 @@ NO CHANGE ~~~ # TYPES ~~~clojure -(expr @1.1-1.7 (type "Frac(_size)")) +(expr @1.1-1.7 (type "Num(Frac(_size))")) ~~~ diff --git a/test/snapshots/numeric_edge_cases/dec_scientific_negative_exp.md b/test/snapshots/numeric_edge_cases/dec_scientific_negative_exp.md index b0f08dce6a..925e34d09b 100644 --- a/test/snapshots/numeric_edge_cases/dec_scientific_negative_exp.md +++ b/test/snapshots/numeric_edge_cases/dec_scientific_negative_exp.md @@ -30,5 +30,5 @@ NO CHANGE ~~~ # TYPES ~~~clojure -(expr @1.1-1.24 (type "Frac(_size)")) +(expr @1.1-1.24 (type "Num(Frac(_size))")) ~~~ diff --git a/test/snapshots/numeric_edge_cases/dec_scientific_notation.md b/test/snapshots/numeric_edge_cases/dec_scientific_notation.md index f7984b9976..737fad7166 100644 --- a/test/snapshots/numeric_edge_cases/dec_scientific_notation.md +++ b/test/snapshots/numeric_edge_cases/dec_scientific_notation.md @@ -30,5 +30,5 @@ NO CHANGE ~~~ # TYPES ~~~clojure -(expr @1.1-1.23 (type "Frac(_size)")) +(expr @1.1-1.23 (type "Num(Frac(_size))")) ~~~ diff --git a/test/snapshots/numeric_edge_cases/dec_small_max_value.md b/test/snapshots/numeric_edge_cases/dec_small_max_value.md index 22ba4cd4f0..7250859648 100644 --- a/test/snapshots/numeric_edge_cases/dec_small_max_value.md +++ b/test/snapshots/numeric_edge_cases/dec_small_max_value.md @@ -30,5 +30,5 @@ NO CHANGE ~~~ # TYPES ~~~clojure -(expr @1.1-1.7 (type "Frac(_size)")) +(expr @1.1-1.7 (type "Num(Frac(_size))")) ~~~ diff --git a/test/snapshots/numeric_edge_cases/dec_small_min_value.md b/test/snapshots/numeric_edge_cases/dec_small_min_value.md index a645a27608..b401056082 100644 --- a/test/snapshots/numeric_edge_cases/dec_small_min_value.md +++ b/test/snapshots/numeric_edge_cases/dec_small_min_value.md @@ -30,5 +30,5 @@ NO CHANGE ~~~ # TYPES ~~~clojure -(expr @1.1-1.8 (type "Frac(_size)")) +(expr @1.1-1.8 (type "Num(Frac(_size))")) ~~~ diff --git a/test/snapshots/numeric_edge_cases/dec_small_negative.md b/test/snapshots/numeric_edge_cases/dec_small_negative.md index af5a9bf56c..a8bc29f3c0 100644 --- a/test/snapshots/numeric_edge_cases/dec_small_negative.md +++ b/test/snapshots/numeric_edge_cases/dec_small_negative.md @@ -30,5 +30,5 @@ NO CHANGE ~~~ # TYPES ~~~clojure -(expr @1.1-1.9 (type "Frac(_size)")) +(expr @1.1-1.9 (type "Num(Frac(_size))")) ~~~ diff --git a/test/snapshots/numeric_edge_cases/dec_small_positive_tiny.md b/test/snapshots/numeric_edge_cases/dec_small_positive_tiny.md index 7aaa26b5bc..259f8514f2 100644 --- a/test/snapshots/numeric_edge_cases/dec_small_positive_tiny.md +++ b/test/snapshots/numeric_edge_cases/dec_small_positive_tiny.md @@ -30,5 +30,5 @@ NO CHANGE ~~~ # TYPES ~~~clojure -(expr @1.1-1.7 (type "Frac(_size)")) +(expr @1.1-1.7 (type "Num(Frac(_size))")) ~~~ diff --git a/test/snapshots/numeric_edge_cases/dec_trailing_zeros.md b/test/snapshots/numeric_edge_cases/dec_trailing_zeros.md index 7392700fa2..88f4c83431 100644 --- a/test/snapshots/numeric_edge_cases/dec_trailing_zeros.md +++ b/test/snapshots/numeric_edge_cases/dec_trailing_zeros.md @@ -30,5 +30,5 @@ NO CHANGE ~~~ # TYPES ~~~clojure -(expr @1.1-1.7 (type "Frac(_size)")) +(expr @1.1-1.7 (type "Num(Frac(_size))")) ~~~ diff --git a/test/snapshots/numeric_edge_cases/dec_vs_f64_decimal.md b/test/snapshots/numeric_edge_cases/dec_vs_f64_decimal.md index 49cee776e3..dcbd711eda 100644 --- a/test/snapshots/numeric_edge_cases/dec_vs_f64_decimal.md +++ b/test/snapshots/numeric_edge_cases/dec_vs_f64_decimal.md @@ -30,5 +30,5 @@ NO CHANGE ~~~ # TYPES ~~~clojure -(expr @1.1-1.6 (type "Frac(_size)")) +(expr @1.1-1.6 (type "Num(Frac(_size))")) ~~~ diff --git a/test/snapshots/numeric_edge_cases/dec_vs_f64_scientific.md b/test/snapshots/numeric_edge_cases/dec_vs_f64_scientific.md index c0eba244fe..c727287643 100644 --- a/test/snapshots/numeric_edge_cases/dec_vs_f64_scientific.md +++ b/test/snapshots/numeric_edge_cases/dec_vs_f64_scientific.md @@ -30,5 +30,5 @@ NO CHANGE ~~~ # TYPES ~~~clojure -(expr @1.1-1.6 (type "Frac(_size)")) +(expr @1.1-1.6 (type "Num(Frac(_size))")) ~~~ diff --git a/test/snapshots/numeric_edge_cases/dec_zero.md b/test/snapshots/numeric_edge_cases/dec_zero.md index 13aa999b20..e47a8b13c7 100644 --- a/test/snapshots/numeric_edge_cases/dec_zero.md +++ b/test/snapshots/numeric_edge_cases/dec_zero.md @@ -30,5 +30,5 @@ NO CHANGE ~~~ # TYPES ~~~clojure -(expr @1.1-1.4 (type "Frac(_size)")) +(expr @1.1-1.4 (type "Num(Frac(_size))")) ~~~ diff --git a/test/snapshots/numeric_edge_cases/frac_huge_scientific.md b/test/snapshots/numeric_edge_cases/frac_huge_scientific.md index 3cdaa932bb..03a7a4fcd5 100644 --- a/test/snapshots/numeric_edge_cases/frac_huge_scientific.md +++ b/test/snapshots/numeric_edge_cases/frac_huge_scientific.md @@ -30,5 +30,5 @@ NO CHANGE ~~~ # TYPES ~~~clojure -(expr @1.1-1.8 (type "Frac(_size)")) +(expr @1.1-1.8 (type "Num(Frac(_size))")) ~~~ diff --git a/test/snapshots/numeric_edge_cases/frac_tiny_scientific.md b/test/snapshots/numeric_edge_cases/frac_tiny_scientific.md index 64ed883cf4..2d4cddc9af 100644 --- a/test/snapshots/numeric_edge_cases/frac_tiny_scientific.md +++ b/test/snapshots/numeric_edge_cases/frac_tiny_scientific.md @@ -30,5 +30,5 @@ NO CHANGE ~~~ # TYPES ~~~clojure -(expr @1.1-1.9 (type "Frac(_size)")) +(expr @1.1-1.9 (type "Num(Frac(_size))")) ~~~ diff --git a/test/snapshots/numeric_edge_cases/int_i128_max.md b/test/snapshots/numeric_edge_cases/int_i128_max.md index eecf57fc2a..35f5dde054 100644 --- a/test/snapshots/numeric_edge_cases/int_i128_max.md +++ b/test/snapshots/numeric_edge_cases/int_i128_max.md @@ -26,7 +26,7 @@ NO CHANGE ~~~ # CANONICALIZE ~~~clojure -(e-int @1.1-1.40 (value "170141183460469231731687303715884105727")) +(e-num @1.1-1.40 (value "170141183460469231731687303715884105727")) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/numeric_edge_cases/int_i16_max.md b/test/snapshots/numeric_edge_cases/int_i16_max.md index c75199bbb3..d589020c64 100644 --- a/test/snapshots/numeric_edge_cases/int_i16_max.md +++ b/test/snapshots/numeric_edge_cases/int_i16_max.md @@ -26,7 +26,7 @@ NO CHANGE ~~~ # CANONICALIZE ~~~clojure -(e-int @1.1-1.6 (value "32767")) +(e-num @1.1-1.6 (value "32767")) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/numeric_edge_cases/int_i32_max.md b/test/snapshots/numeric_edge_cases/int_i32_max.md index d882e90a57..d417b8b914 100644 --- a/test/snapshots/numeric_edge_cases/int_i32_max.md +++ b/test/snapshots/numeric_edge_cases/int_i32_max.md @@ -26,7 +26,7 @@ NO CHANGE ~~~ # CANONICALIZE ~~~clojure -(e-int @1.1-1.11 (value "2147483647")) +(e-num @1.1-1.11 (value "2147483647")) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/numeric_edge_cases/int_i32_min.md b/test/snapshots/numeric_edge_cases/int_i32_min.md index 81e0f14e27..1b1ea9e6fa 100644 --- a/test/snapshots/numeric_edge_cases/int_i32_min.md +++ b/test/snapshots/numeric_edge_cases/int_i32_min.md @@ -26,7 +26,7 @@ NO CHANGE ~~~ # CANONICALIZE ~~~clojure -(e-int @1.1-1.12 (value "-2147483648")) +(e-num @1.1-1.12 (value "-2147483648")) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/numeric_edge_cases/int_i64_max.md b/test/snapshots/numeric_edge_cases/int_i64_max.md index 19b2b0f8f5..ceffae1bca 100644 --- a/test/snapshots/numeric_edge_cases/int_i64_max.md +++ b/test/snapshots/numeric_edge_cases/int_i64_max.md @@ -26,7 +26,7 @@ NO CHANGE ~~~ # CANONICALIZE ~~~clojure -(e-int @1.1-1.20 (value "9223372036854775807")) +(e-num @1.1-1.20 (value "9223372036854775807")) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/numeric_edge_cases/int_i8_max.md b/test/snapshots/numeric_edge_cases/int_i8_max.md index feb69d0e8e..11fa05cb7d 100644 --- a/test/snapshots/numeric_edge_cases/int_i8_max.md +++ b/test/snapshots/numeric_edge_cases/int_i8_max.md @@ -26,7 +26,7 @@ NO CHANGE ~~~ # CANONICALIZE ~~~clojure -(e-int @1.1-1.4 (value "127")) +(e-num @1.1-1.4 (value "127")) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/numeric_edge_cases/int_i8_min.md b/test/snapshots/numeric_edge_cases/int_i8_min.md index bf850f17be..80a94dd7bf 100644 --- a/test/snapshots/numeric_edge_cases/int_i8_min.md +++ b/test/snapshots/numeric_edge_cases/int_i8_min.md @@ -26,7 +26,7 @@ NO CHANGE ~~~ # CANONICALIZE ~~~clojure -(e-int @1.1-1.5 (value "-128")) +(e-num @1.1-1.5 (value "-128")) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/numeric_edge_cases/int_negative_zero.md b/test/snapshots/numeric_edge_cases/int_negative_zero.md index d6ba30a38c..829f44cacb 100644 --- a/test/snapshots/numeric_edge_cases/int_negative_zero.md +++ b/test/snapshots/numeric_edge_cases/int_negative_zero.md @@ -26,7 +26,7 @@ NO CHANGE ~~~ # CANONICALIZE ~~~clojure -(e-int @1.1-1.3 (value "0")) +(e-num @1.1-1.3 (value "0")) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/numeric_edge_cases/int_u8_max.md b/test/snapshots/numeric_edge_cases/int_u8_max.md index de914fc2b1..656f4191c6 100644 --- a/test/snapshots/numeric_edge_cases/int_u8_max.md +++ b/test/snapshots/numeric_edge_cases/int_u8_max.md @@ -26,7 +26,7 @@ NO CHANGE ~~~ # CANONICALIZE ~~~clojure -(e-int @1.1-1.4 (value "255")) +(e-num @1.1-1.4 (value "255")) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/numeric_edge_cases/int_zero.md b/test/snapshots/numeric_edge_cases/int_zero.md index ac665f2279..c8a40a3f90 100644 --- a/test/snapshots/numeric_edge_cases/int_zero.md +++ b/test/snapshots/numeric_edge_cases/int_zero.md @@ -26,7 +26,7 @@ NO CHANGE ~~~ # CANONICALIZE ~~~clojure -(e-int @1.1-1.2 (value "0")) +(e-num @1.1-1.2 (value "0")) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/pass/exposed_not_impl.md b/test/snapshots/pass/exposed_not_impl.md index 6db1416cd3..87b99b4ebe 100644 --- a/test/snapshots/pass/exposed_not_impl.md +++ b/test/snapshots/pass/exposed_not_impl.md @@ -1,12 +1,10 @@ # META ~~~ini description=Module exposes values that are not implemented -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [foo, bar, MyType, OtherType, foo, MyType] - # This module exposes foo, bar, MyType, and OtherType # but only implements foo and MyType # This should generate "exposed but not implemented" errors for bar and OtherType @@ -17,110 +15,69 @@ foo = 42 MyType : [A, B, C] ~~~ # EXPECTED -REDUNDANT EXPOSED - exposed_not_impl.md:1:38:1:41 -REDUNDANT EXPOSED - exposed_not_impl.md:1:43:1:49 -EXPOSED BUT NOT DEFINED - exposed_not_impl.md:1:14:1:17 -EXPOSED BUT NOT DEFINED - exposed_not_impl.md:1:27:1:36 +NIL # PROBLEMS -**REDUNDANT EXPOSED** -The identifier `foo` is exposed multiple times in the module header. - -**exposed_not_impl.md:1:38:1:41:** -```roc -module [foo, bar, MyType, OtherType, foo, MyType] -``` - ^^^ -You can remove the duplicate entry to fix this warning. - -**REDUNDANT EXPOSED** -The identifier `MyType` is exposed multiple times in the module header. - -**exposed_not_impl.md:1:43:1:49:** -```roc -module [foo, bar, MyType, OtherType, foo, MyType] -``` - ^^^^^^ -You can remove the duplicate entry to fix this warning. - -**EXPOSED BUT NOT DEFINED** -The module header says that `bar` is exposed, but it is not defined anywhere in this module. - -**exposed_not_impl.md:1:14:1:17:** -```roc -module [foo, bar, MyType, OtherType, foo, MyType] -``` - ^^^ -You can fix this by either defining `bar` in this module, or by removing it from the list of exposed values. - -**EXPOSED BUT NOT DEFINED** -The module header says that `OtherType` is exposed, but it is not defined anywhere in this module. - -**exposed_not_impl.md:1:27:1:36:** -```roc -module [foo, bar, MyType, OtherType, foo, MyType] -``` - ^^^^^^^^^ -You can fix this by either defining `OtherType` in this module, or by removing it from the list of exposed values. - +NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:12),Comma(1:12-1:13),LowerIdent(1:14-1:17),Comma(1:17-1:18),UpperIdent(1:19-1:25),Comma(1:25-1:26),UpperIdent(1:27-1:36),Comma(1:36-1:37),LowerIdent(1:38-1:41),Comma(1:41-1:42),UpperIdent(1:43-1:49),CloseSquare(1:49-1:50), -LowerIdent(8:1-8:4),OpAssign(8:5-8:6),Int(8:7-8:9), -UpperIdent(10:1-10:7),OpColon(10:8-10:9),OpenSquare(10:10-10:11),UpperIdent(10:11-10:12),Comma(10:12-10:13),UpperIdent(10:14-10:15),Comma(10:15-10:16),UpperIdent(10:17-10:18),CloseSquare(10:18-10:19), -EndOfFile(11:1-11:1), +LowerIdent(6:1-6:4),OpAssign(6:5-6:6),Int(6:7-6:9), +UpperIdent(8:1-8:7),OpColon(8:8-8:9),OpenSquare(8:10-8:11),UpperIdent(8:11-8:12),Comma(8:12-8:13),UpperIdent(8:14-8:15),Comma(8:15-8:16),UpperIdent(8:17-8:18),CloseSquare(8:18-8:19), +EndOfFile(9:1-9:1), ~~~ # PARSE ~~~clojure -(file @1.1-10.19 - (module @1.1-1.50 - (exposes @1.8-1.50 - (exposed-lower-ident @1.9-1.12 - (text "foo")) - (exposed-lower-ident @1.14-1.17 - (text "bar")) - (exposed-upper-ident @1.19-1.25 (text "MyType")) - (exposed-upper-ident @1.27-1.36 (text "OtherType")) - (exposed-lower-ident @1.38-1.41 - (text "foo")) - (exposed-upper-ident @1.43-1.49 (text "MyType")))) +(file @6.1-8.19 + (type-module @6.1-6.4) (statements - (s-decl @8.1-8.9 - (p-ident @8.1-8.4 (raw "foo")) - (e-int @8.7-8.9 (raw "42"))) - (s-type-decl @10.1-10.19 - (header @10.1-10.7 (name "MyType") + (s-decl @6.1-6.9 + (p-ident @6.1-6.4 (raw "foo")) + (e-int @6.7-6.9 (raw "42"))) + (s-type-decl @8.1-8.19 + (header @8.1-8.7 (name "MyType") (args)) - (ty-tag-union @10.10-10.19 + (ty-tag-union @8.10-8.19 (tags - (ty @10.11-10.12 (name "A")) - (ty @10.14-10.15 (name "B")) - (ty @10.17-10.18 (name "C"))))))) + (ty @8.11-8.12 (name "A")) + (ty @8.14-8.15 (name "B")) + (ty @8.17-8.18 (name "C"))))))) ~~~ # FORMATTED ~~~roc -NO CHANGE +# This module exposes foo, bar, MyType, and OtherType +# but only implements foo and MyType +# This should generate "exposed but not implemented" errors for bar and OtherType +# Also tests redundant exposed entries for foo and MyType + +# This module exposes foo, bar, MyType, and OtherType +# but only implements foo and MyType +# This should generate "exposed but not implemented" errors for bar and OtherType +# Also tests redundant exposed entries for foo and MyType + +foo = 42 + +MyType : [A, B, C] ~~~ # CANONICALIZE ~~~clojure (can-ir (d-let - (p-assign @8.1-8.4 (ident "foo")) - (e-int @8.7-8.9 (value "42"))) - (s-alias-decl @10.1-10.19 - (ty-header @10.1-10.7 (name "MyType")) - (ty-tag-union @10.10-10.19 - (ty @10.11-10.12 (name "A")) - (ty @10.14-10.15 (name "B")) - (ty @10.17-10.18 (name "C"))))) + (p-assign @6.1-6.4 (ident "foo")) + (e-num @6.7-6.9 (value "42"))) + (s-alias-decl @8.1-8.19 + (ty-header @8.1-8.7 (name "MyType")) + (ty-tag-union @8.10-8.19 + (ty-tag-name @8.11-8.12 (name "A")) + (ty-tag-name @8.14-8.15 (name "B")) + (ty-tag-name @8.17-8.18 (name "C"))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @8.1-8.4 (type "Num(_size)"))) + (patt @6.1-6.4 (type "Num(_size)"))) (type_decls - (alias @10.1-10.19 (type "MyType") - (ty-header @10.1-10.7 (name "MyType")))) + (alias @8.1-8.19 (type "MyType") + (ty-header @8.1-8.7 (name "MyType")))) (expressions - (expr @8.7-8.9 (type "Num(_size)")))) + (expr @6.7-6.9 (type "Num(_size)")))) ~~~ diff --git a/test/snapshots/pass/underscore_in_regular_annotations.md b/test/snapshots/pass/underscore_in_regular_annotations.md index d04c9b2123..ac5ce10b7d 100644 --- a/test/snapshots/pass/underscore_in_regular_annotations.md +++ b/test/snapshots/pass/underscore_in_regular_annotations.md @@ -1,12 +1,10 @@ # META ~~~ini description=Underscores are allowed in regular type annotations (not in type declarations) -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - main : _ -> _ main = |x| x @@ -38,9 +36,9 @@ transform : _a -> _b -> _b transform = |_, b| b ~~~ # EXPECTED -PARSE ERROR - underscore_in_regular_annotations.md:30:22:30:24 -PARSE ERROR - underscore_in_regular_annotations.md:30:25:30:27 -UNUSED VARIABLE - underscore_in_regular_annotations.md:11:12:11:16 +PARSE ERROR - underscore_in_regular_annotations.md:28:22:28:24 +PARSE ERROR - underscore_in_regular_annotations.md:28:25:28:27 +UNUSED VARIABLE - underscore_in_regular_annotations.md:9:12:9:16 # PROBLEMS **PARSE ERROR** Function types with multiple arrows need parentheses. @@ -49,7 +47,7 @@ Instead of writing **a -> b -> c**, use parentheses to clarify which you mean: a -> (b -> c) for a **curried** function (a function that **returns** another function) (a -> b) -> c for a **higher-order** function (a function that **takes** another function) -**underscore_in_regular_annotations.md:30:22:30:24:** +**underscore_in_regular_annotations.md:28:22:28:24:** ```roc transform : _a -> _b -> _b ``` @@ -60,7 +58,7 @@ transform : _a -> _b -> _b A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**underscore_in_regular_annotations.md:30:25:30:27:** +**underscore_in_regular_annotations.md:28:25:28:27:** ```roc transform : _a -> _b -> _b ``` @@ -72,7 +70,7 @@ Variable `list` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_list` to suppress this warning. The unused variable is declared here: -**underscore_in_regular_annotations.md:11:12:11:16:** +**underscore_in_regular_annotations.md:9:12:9:16:** ```roc process = |list| "processed" ``` @@ -81,142 +79,138 @@ process = |list| "processed" # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -LowerIdent(3:1-3:5),OpColon(3:6-3:7),Underscore(3:8-3:9),OpArrow(3:10-3:12),Underscore(3:13-3:14), -LowerIdent(4:1-4:5),OpAssign(4:6-4:7),OpBar(4:8-4:9),LowerIdent(4:9-4:10),OpBar(4:10-4:11),LowerIdent(4:12-4:13), -LowerIdent(6:1-6:9),OpColon(6:10-6:11),LowerIdent(6:12-6:13),OpArrow(6:14-6:16),LowerIdent(6:17-6:18), -LowerIdent(7:1-7:9),OpAssign(7:10-7:11),OpBar(7:12-7:13),LowerIdent(7:13-7:14),OpBar(7:14-7:15),LowerIdent(7:16-7:17), -LowerIdent(10:1-10:8),OpColon(10:9-10:10),UpperIdent(10:11-10:15),NoSpaceOpenRound(10:15-10:16),Underscore(10:16-10:17),CloseRound(10:17-10:18),OpArrow(10:19-10:21),UpperIdent(10:22-10:25), -LowerIdent(11:1-11:8),OpAssign(11:9-11:10),OpBar(11:11-11:12),LowerIdent(11:12-11:16),OpBar(11:16-11:17),StringStart(11:18-11:19),StringPart(11:19-11:28),StringEnd(11:28-11:29), -LowerIdent(14:1-14:9),OpColon(14:10-14:11),OpenCurly(14:12-14:13),LowerIdent(14:14-14:19),OpColon(14:19-14:20),Underscore(14:21-14:22),Comma(14:22-14:23),LowerIdent(14:24-14:29),OpColon(14:29-14:30),UpperIdent(14:31-14:34),CloseCurly(14:35-14:36),OpArrow(14:37-14:39),UpperIdent(14:40-14:43), -LowerIdent(15:1-15:9),OpAssign(15:10-15:11),OpBar(15:12-15:13),LowerIdent(15:13-15:19),OpBar(15:19-15:20),LowerIdent(15:21-15:27),NoSpaceDotLowerIdent(15:27-15:33), -LowerIdent(18:1-18:14),OpColon(18:15-18:16),UpperIdent(18:17-18:23),NoSpaceOpenRound(18:23-18:24),Underscore(18:24-18:25),Comma(18:25-18:26),UpperIdent(18:27-18:30),CloseRound(18:30-18:31),OpArrow(18:32-18:34),UpperIdent(18:35-18:38), -LowerIdent(19:1-19:14),OpAssign(19:15-19:16),OpBar(19:17-19:18),LowerIdent(19:18-19:24),OpBar(19:24-19:25), -KwMatch(20:5-20:10),LowerIdent(20:11-20:17),OpenCurly(20:18-20:19), -UpperIdent(21:9-21:11),NoSpaceOpenRound(21:11-21:12),Underscore(21:12-21:13),CloseRound(21:13-21:14),OpFatArrow(21:15-21:17),StringStart(21:18-21:19),StringPart(21:19-21:26),StringEnd(21:26-21:27),Comma(21:27-21:28), -UpperIdent(22:9-22:12),NoSpaceOpenRound(22:12-22:13),LowerIdent(22:13-22:16),CloseRound(22:16-22:17),OpFatArrow(22:18-22:20),LowerIdent(22:21-22:24),Comma(22:24-22:25), -CloseCurly(23:5-23:6), -LowerIdent(26:1-26:4),OpColon(26:5-26:6),OpenRound(26:7-26:8),LowerIdent(26:8-26:9),OpArrow(26:10-26:12),LowerIdent(26:13-26:14),CloseRound(26:14-26:15),Comma(26:15-26:16),UpperIdent(26:17-26:21),NoSpaceOpenRound(26:21-26:22),LowerIdent(26:22-26:23),CloseRound(26:23-26:24),OpArrow(26:25-26:27),UpperIdent(26:28-26:32),NoSpaceOpenRound(26:32-26:33),LowerIdent(26:33-26:34),CloseRound(26:34-26:35), -LowerIdent(27:1-27:4),OpAssign(27:5-27:6),OpBar(27:7-27:8),Underscore(27:8-27:9),Comma(27:9-27:10),Underscore(27:11-27:12),OpBar(27:12-27:13),OpenSquare(27:14-27:15),CloseSquare(27:15-27:16), -LowerIdent(30:1-30:10),OpColon(30:11-30:12),NamedUnderscore(30:13-30:15),OpArrow(30:16-30:18),NamedUnderscore(30:19-30:21),OpArrow(30:22-30:24),NamedUnderscore(30:25-30:27), -LowerIdent(31:1-31:10),OpAssign(31:11-31:12),OpBar(31:13-31:14),Underscore(31:14-31:15),Comma(31:15-31:16),LowerIdent(31:17-31:18),OpBar(31:18-31:19),LowerIdent(31:20-31:21), -EndOfFile(32:1-32:1), +LowerIdent(1:1-1:5),OpColon(1:6-1:7),Underscore(1:8-1:9),OpArrow(1:10-1:12),Underscore(1:13-1:14), +LowerIdent(2:1-2:5),OpAssign(2:6-2:7),OpBar(2:8-2:9),LowerIdent(2:9-2:10),OpBar(2:10-2:11),LowerIdent(2:12-2:13), +LowerIdent(4:1-4:9),OpColon(4:10-4:11),LowerIdent(4:12-4:13),OpArrow(4:14-4:16),LowerIdent(4:17-4:18), +LowerIdent(5:1-5:9),OpAssign(5:10-5:11),OpBar(5:12-5:13),LowerIdent(5:13-5:14),OpBar(5:14-5:15),LowerIdent(5:16-5:17), +LowerIdent(8:1-8:8),OpColon(8:9-8:10),UpperIdent(8:11-8:15),NoSpaceOpenRound(8:15-8:16),Underscore(8:16-8:17),CloseRound(8:17-8:18),OpArrow(8:19-8:21),UpperIdent(8:22-8:25), +LowerIdent(9:1-9:8),OpAssign(9:9-9:10),OpBar(9:11-9:12),LowerIdent(9:12-9:16),OpBar(9:16-9:17),StringStart(9:18-9:19),StringPart(9:19-9:28),StringEnd(9:28-9:29), +LowerIdent(12:1-12:9),OpColon(12:10-12:11),OpenCurly(12:12-12:13),LowerIdent(12:14-12:19),OpColon(12:19-12:20),Underscore(12:21-12:22),Comma(12:22-12:23),LowerIdent(12:24-12:29),OpColon(12:29-12:30),UpperIdent(12:31-12:34),CloseCurly(12:35-12:36),OpArrow(12:37-12:39),UpperIdent(12:40-12:43), +LowerIdent(13:1-13:9),OpAssign(13:10-13:11),OpBar(13:12-13:13),LowerIdent(13:13-13:19),OpBar(13:19-13:20),LowerIdent(13:21-13:27),NoSpaceDotLowerIdent(13:27-13:33), +LowerIdent(16:1-16:14),OpColon(16:15-16:16),UpperIdent(16:17-16:23),NoSpaceOpenRound(16:23-16:24),Underscore(16:24-16:25),Comma(16:25-16:26),UpperIdent(16:27-16:30),CloseRound(16:30-16:31),OpArrow(16:32-16:34),UpperIdent(16:35-16:38), +LowerIdent(17:1-17:14),OpAssign(17:15-17:16),OpBar(17:17-17:18),LowerIdent(17:18-17:24),OpBar(17:24-17:25), +KwMatch(18:5-18:10),LowerIdent(18:11-18:17),OpenCurly(18:18-18:19), +UpperIdent(19:9-19:11),NoSpaceOpenRound(19:11-19:12),Underscore(19:12-19:13),CloseRound(19:13-19:14),OpFatArrow(19:15-19:17),StringStart(19:18-19:19),StringPart(19:19-19:26),StringEnd(19:26-19:27),Comma(19:27-19:28), +UpperIdent(20:9-20:12),NoSpaceOpenRound(20:12-20:13),LowerIdent(20:13-20:16),CloseRound(20:16-20:17),OpFatArrow(20:18-20:20),LowerIdent(20:21-20:24),Comma(20:24-20:25), +CloseCurly(21:5-21:6), +LowerIdent(24:1-24:4),OpColon(24:5-24:6),OpenRound(24:7-24:8),LowerIdent(24:8-24:9),OpArrow(24:10-24:12),LowerIdent(24:13-24:14),CloseRound(24:14-24:15),Comma(24:15-24:16),UpperIdent(24:17-24:21),NoSpaceOpenRound(24:21-24:22),LowerIdent(24:22-24:23),CloseRound(24:23-24:24),OpArrow(24:25-24:27),UpperIdent(24:28-24:32),NoSpaceOpenRound(24:32-24:33),LowerIdent(24:33-24:34),CloseRound(24:34-24:35), +LowerIdent(25:1-25:4),OpAssign(25:5-25:6),OpBar(25:7-25:8),Underscore(25:8-25:9),Comma(25:9-25:10),Underscore(25:11-25:12),OpBar(25:12-25:13),OpenSquare(25:14-25:15),CloseSquare(25:15-25:16), +LowerIdent(28:1-28:10),OpColon(28:11-28:12),NamedUnderscore(28:13-28:15),OpArrow(28:16-28:18),NamedUnderscore(28:19-28:21),OpArrow(28:22-28:24),NamedUnderscore(28:25-28:27), +LowerIdent(29:1-29:10),OpAssign(29:11-29:12),OpBar(29:13-29:14),Underscore(29:14-29:15),Comma(29:15-29:16),LowerIdent(29:17-29:18),OpBar(29:18-29:19),LowerIdent(29:20-29:21), +EndOfFile(30:1-30:1), ~~~ # PARSE ~~~clojure -(file @1.1-31.21 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-29.21 + (type-module @1.1-1.5) (statements - (s-type-anno @3.1-3.14 (name "main") - (ty-fn @3.8-3.14 + (s-type-anno @1.1-1.14 (name "main") + (ty-fn @1.8-1.14 (_) (_))) - (s-decl @4.1-4.13 - (p-ident @4.1-4.5 (raw "main")) - (e-lambda @4.8-4.13 + (s-decl @2.1-2.13 + (p-ident @2.1-2.5 (raw "main")) + (e-lambda @2.8-2.13 (args - (p-ident @4.9-4.10 (raw "x"))) - (e-ident @4.12-4.13 (raw "x")))) - (s-type-anno @6.1-6.18 (name "identity") - (ty-fn @6.12-6.18 - (ty-var @6.12-6.13 (raw "a")) - (ty-var @6.17-6.18 (raw "a")))) - (s-decl @7.1-7.17 - (p-ident @7.1-7.9 (raw "identity")) - (e-lambda @7.12-7.17 + (p-ident @2.9-2.10 (raw "x"))) + (e-ident @2.12-2.13 (raw "x")))) + (s-type-anno @4.1-4.18 (name "identity") + (ty-fn @4.12-4.18 + (ty-var @4.12-4.13 (raw "a")) + (ty-var @4.17-4.18 (raw "a")))) + (s-decl @5.1-5.17 + (p-ident @5.1-5.9 (raw "identity")) + (e-lambda @5.12-5.17 (args - (p-ident @7.13-7.14 (raw "x"))) - (e-ident @7.16-7.17 (raw "x")))) - (s-type-anno @10.1-10.25 (name "process") - (ty-fn @10.11-10.25 - (ty-apply @10.11-10.18 - (ty @10.11-10.15 (name "List")) + (p-ident @5.13-5.14 (raw "x"))) + (e-ident @5.16-5.17 (raw "x")))) + (s-type-anno @8.1-8.25 (name "process") + (ty-fn @8.11-8.25 + (ty-apply @8.11-8.18 + (ty @8.11-8.15 (name "List")) (_)) - (ty @10.22-10.25 (name "Str")))) - (s-decl @11.1-11.29 - (p-ident @11.1-11.8 (raw "process")) - (e-lambda @11.11-11.29 + (ty @8.22-8.25 (name "Str")))) + (s-decl @9.1-9.29 + (p-ident @9.1-9.8 (raw "process")) + (e-lambda @9.11-9.29 (args - (p-ident @11.12-11.16 (raw "list"))) - (e-string @11.18-11.29 - (e-string-part @11.19-11.28 (raw "processed"))))) - (s-type-anno @14.1-14.43 (name "get_data") - (ty-fn @14.12-14.43 - (ty-record @14.12-14.36 - (anno-record-field @14.14-14.22 (name "field") + (p-ident @9.12-9.16 (raw "list"))) + (e-string @9.18-9.29 + (e-string-part @9.19-9.28 (raw "processed"))))) + (s-type-anno @12.1-12.43 (name "get_data") + (ty-fn @12.12-12.43 + (ty-record @12.12-12.36 + (anno-record-field @12.14-12.22 (name "field") (_)) - (anno-record-field @14.24-14.34 (name "other") - (ty @14.31-14.34 (name "U32")))) - (ty @14.40-14.43 (name "U32")))) - (s-decl @15.1-15.33 - (p-ident @15.1-15.9 (raw "get_data")) - (e-lambda @15.12-15.33 + (anno-record-field @12.24-12.34 (name "other") + (ty @12.31-12.34 (name "U32")))) + (ty @12.40-12.43 (name "U32")))) + (s-decl @13.1-13.33 + (p-ident @13.1-13.9 (raw "get_data")) + (e-lambda @13.12-13.33 (args - (p-ident @15.13-15.19 (raw "record"))) - (e-field-access @15.21-15.33 - (e-ident @15.21-15.27 (raw "record")) - (e-ident @15.27-15.33 (raw "other"))))) - (s-type-anno @18.1-18.38 (name "handle_result") - (ty-fn @18.17-18.38 - (ty-apply @18.17-18.31 - (ty @18.17-18.23 (name "Result")) + (p-ident @13.13-13.19 (raw "record"))) + (e-field-access @13.21-13.33 + (e-ident @13.21-13.27 (raw "record")) + (e-ident @13.27-13.33 (raw "other"))))) + (s-type-anno @16.1-16.38 (name "handle_result") + (ty-fn @16.17-16.38 + (ty-apply @16.17-16.31 + (ty @16.17-16.23 (name "Result")) (_) - (ty @18.27-18.30 (name "Str"))) - (ty @18.35-18.38 (name "Str")))) - (s-decl @19.1-23.6 - (p-ident @19.1-19.14 (raw "handle_result")) - (e-lambda @19.17-23.6 + (ty @16.27-16.30 (name "Str"))) + (ty @16.35-16.38 (name "Str")))) + (s-decl @17.1-21.6 + (p-ident @17.1-17.14 (raw "handle_result")) + (e-lambda @17.17-21.6 (args - (p-ident @19.18-19.24 (raw "result"))) + (p-ident @17.18-17.24 (raw "result"))) (e-match - (e-ident @20.11-20.17 (raw "result")) + (e-ident @18.11-18.17 (raw "result")) (branches - (branch @21.9-21.27 - (p-tag @21.9-21.14 (raw "Ok") + (branch @19.9-19.27 + (p-tag @19.9-19.14 (raw "Ok") (p-underscore)) - (e-string @21.18-21.27 - (e-string-part @21.19-21.26 (raw "success")))) - (branch @22.9-22.24 - (p-tag @22.9-22.17 (raw "Err") - (p-ident @22.13-22.16 (raw "msg"))) - (e-ident @22.21-22.24 (raw "msg"))))))) - (s-type-anno @26.1-26.35 (name "map") - (ty-fn @26.7-26.35 - (ty-fn @26.8-26.14 - (ty-var @26.8-26.9 (raw "a")) - (ty-var @26.13-26.14 (raw "b"))) - (ty-apply @26.17-26.24 - (ty @26.17-26.21 (name "List")) - (ty-var @26.22-26.23 (raw "a"))) - (ty-apply @26.28-26.35 - (ty @26.28-26.32 (name "List")) - (ty-var @26.33-26.34 (raw "b"))))) - (s-decl @27.1-27.16 - (p-ident @27.1-27.4 (raw "map")) - (e-lambda @27.7-27.16 + (e-string @19.18-19.27 + (e-string-part @19.19-19.26 (raw "success")))) + (branch @20.9-20.24 + (p-tag @20.9-20.17 (raw "Err") + (p-ident @20.13-20.16 (raw "msg"))) + (e-ident @20.21-20.24 (raw "msg"))))))) + (s-type-anno @24.1-24.35 (name "map") + (ty-fn @24.7-24.35 + (ty-fn @24.8-24.14 + (ty-var @24.8-24.9 (raw "a")) + (ty-var @24.13-24.14 (raw "b"))) + (ty-apply @24.17-24.24 + (ty @24.17-24.21 (name "List")) + (ty-var @24.22-24.23 (raw "a"))) + (ty-apply @24.28-24.35 + (ty @24.28-24.32 (name "List")) + (ty-var @24.33-24.34 (raw "b"))))) + (s-decl @25.1-25.16 + (p-ident @25.1-25.4 (raw "map")) + (e-lambda @25.7-25.16 (args (p-underscore) (p-underscore)) - (e-list @27.14-27.16))) - (s-type-anno @30.1-30.21 (name "transform") - (ty-fn @30.13-30.21 - (underscore-ty-var @30.13-30.15 (raw "_a")) - (underscore-ty-var @30.19-30.21 (raw "_b")))) - (s-malformed @30.22-30.24 (tag "multi_arrow_needs_parens")) - (s-malformed @30.25-30.27 (tag "statement_unexpected_token")) - (s-decl @31.1-31.21 - (p-ident @31.1-31.10 (raw "transform")) - (e-lambda @31.13-31.21 + (e-list @25.14-25.16))) + (s-type-anno @28.1-28.21 (name "transform") + (ty-fn @28.13-28.21 + (underscore-ty-var @28.13-28.15 (raw "_a")) + (underscore-ty-var @28.19-28.21 (raw "_b")))) + (s-malformed @28.22-28.24 (tag "multi_arrow_needs_parens")) + (s-malformed @28.25-28.27 (tag "statement_unexpected_token")) + (s-decl @29.1-29.21 + (p-ident @29.1-29.10 (raw "transform")) + (e-lambda @29.13-29.21 (args (p-underscore) - (p-ident @31.17-31.18 (raw "b"))) - (e-ident @31.20-31.21 (raw "b")))))) + (p-ident @29.17-29.18 (raw "b"))) + (e-ident @29.20-29.21 (raw "b")))))) ~~~ # FORMATTED ~~~roc -module [] - main : _ -> _ main = |x| x @@ -252,141 +246,141 @@ transform = |_, b| b ~~~clojure (can-ir (d-let - (p-assign @4.1-4.5 (ident "main")) - (e-lambda @4.8-4.13 + (p-assign @2.1-2.5 (ident "main")) + (e-lambda @2.8-2.13 (args - (p-assign @4.9-4.10 (ident "x"))) - (e-lookup-local @4.12-4.13 - (p-assign @4.9-4.10 (ident "x")))) - (annotation @4.1-4.5 + (p-assign @2.9-2.10 (ident "x"))) + (e-lookup-local @2.12-2.13 + (p-assign @2.9-2.10 (ident "x")))) + (annotation @2.1-2.5 (declared-type - (ty-fn @3.8-3.14 (effectful false) + (ty-fn @1.8-1.14 (effectful false) (ty-underscore @1.1-1.1) (ty-underscore @1.1-1.1))))) (d-let - (p-assign @7.1-7.9 (ident "identity")) - (e-lambda @7.12-7.17 + (p-assign @5.1-5.9 (ident "identity")) + (e-lambda @5.12-5.17 (args - (p-assign @7.13-7.14 (ident "x"))) - (e-lookup-local @7.16-7.17 - (p-assign @7.13-7.14 (ident "x")))) - (annotation @7.1-7.9 + (p-assign @5.13-5.14 (ident "x"))) + (e-lookup-local @5.16-5.17 + (p-assign @5.13-5.14 (ident "x")))) + (annotation @5.1-5.9 (declared-type - (ty-fn @6.12-6.18 (effectful false) - (ty-var @6.12-6.13 (name "a")) - (ty-var @6.17-6.18 (name "a")))))) + (ty-fn @4.12-4.18 (effectful false) + (ty-rigid-var @4.12-4.13 (name "a")) + (ty-rigid-var-lookup (ty-rigid-var @4.12-4.13 (name "a"))))))) (d-let - (p-assign @11.1-11.8 (ident "process")) - (e-lambda @11.11-11.29 + (p-assign @9.1-9.8 (ident "process")) + (e-lambda @9.11-9.29 (args - (p-assign @11.12-11.16 (ident "list"))) - (e-string @11.18-11.29 - (e-literal @11.19-11.28 (string "processed")))) - (annotation @11.1-11.8 + (p-assign @9.12-9.16 (ident "list"))) + (e-string @9.18-9.29 + (e-literal @9.19-9.28 (string "processed")))) + (annotation @9.1-9.8 (declared-type - (ty-fn @10.11-10.25 (effectful false) - (ty-apply @10.11-10.18 (symbol "List") - (ty-underscore @10.16-10.16)) - (ty @10.22-10.25 (name "Str")))))) + (ty-fn @8.11-8.25 (effectful false) + (ty-apply @8.11-8.18 (name "List") (builtin) + (ty-underscore @8.16-8.16)) + (ty-lookup @8.22-8.25 (name "Str") (builtin)))))) (d-let - (p-assign @15.1-15.9 (ident "get_data")) - (e-lambda @15.12-15.33 + (p-assign @13.1-13.9 (ident "get_data")) + (e-lambda @13.12-13.33 (args - (p-assign @15.13-15.19 (ident "record"))) - (e-dot-access @15.21-15.33 (field "other") + (p-assign @13.13-13.19 (ident "record"))) + (e-dot-access @13.21-13.33 (field "other") (receiver - (e-lookup-local @15.21-15.27 - (p-assign @15.13-15.19 (ident "record")))))) - (annotation @15.1-15.9 + (e-lookup-local @13.21-13.27 + (p-assign @13.13-13.19 (ident "record")))))) + (annotation @13.1-13.9 (declared-type - (ty-fn @14.12-14.43 (effectful false) - (ty-record @14.12-14.36 + (ty-fn @12.12-12.43 (effectful false) + (ty-record @12.12-12.36 (field (field "field") (ty-underscore @1.1-1.1)) (field (field "other") - (ty @14.31-14.34 (name "U32")))) - (ty @14.40-14.43 (name "U32")))))) + (ty-lookup @12.31-12.34 (name "U32") (builtin)))) + (ty-lookup @12.40-12.43 (name "U32") (builtin)))))) (d-let - (p-assign @19.1-19.14 (ident "handle_result")) - (e-closure @19.17-23.6 + (p-assign @17.1-17.14 (ident "handle_result")) + (e-closure @17.17-21.6 (captures - (capture @22.13-22.16 (ident "msg"))) - (e-lambda @19.17-23.6 + (capture @20.13-20.16 (ident "msg"))) + (e-lambda @17.17-21.6 (args - (p-assign @19.18-19.24 (ident "result"))) - (e-match @20.5-23.6 - (match @20.5-23.6 + (p-assign @17.18-17.24 (ident "result"))) + (e-match @18.5-21.6 + (match @18.5-21.6 (cond - (e-lookup-local @20.11-20.17 - (p-assign @19.18-19.24 (ident "result")))) + (e-lookup-local @18.11-18.17 + (p-assign @17.18-17.24 (ident "result")))) (branches (branch (patterns (pattern (degenerate false) - (p-nominal @21.9-21.14 - (p-applied-tag @21.9-21.14)))) + (p-nominal @19.9-19.14 + (p-applied-tag @19.9-19.14)))) (value - (e-string @21.18-21.27 - (e-literal @21.19-21.26 (string "success"))))) + (e-string @19.18-19.27 + (e-literal @19.19-19.26 (string "success"))))) (branch (patterns (pattern (degenerate false) - (p-nominal @22.9-22.17 - (p-applied-tag @22.9-22.17)))) + (p-nominal @20.9-20.17 + (p-applied-tag @20.9-20.17)))) (value - (e-lookup-local @22.21-22.24 - (p-assign @22.13-22.16 (ident "msg")))))))))) - (annotation @19.1-19.14 + (e-lookup-local @20.21-20.24 + (p-assign @20.13-20.16 (ident "msg")))))))))) + (annotation @17.1-17.14 (declared-type - (ty-fn @18.17-18.38 (effectful false) - (ty-apply @18.17-18.31 (symbol "Result") - (ty-underscore @18.24-18.24) - (ty @18.27-18.30 (name "Str"))) - (ty @18.35-18.38 (name "Str")))))) + (ty-fn @16.17-16.38 (effectful false) + (ty-apply @16.17-16.31 (name "Result") (local) + (ty-underscore @16.17-16.31) + (ty-lookup @16.17-16.31 (name "Str") (builtin))) + (ty-lookup @16.35-16.38 (name "Str") (builtin)))))) (d-let - (p-assign @27.1-27.4 (ident "map")) - (e-lambda @27.7-27.16 + (p-assign @25.1-25.4 (ident "map")) + (e-lambda @25.7-25.16 (args - (p-underscore @27.8-27.9) - (p-underscore @27.11-27.12)) - (e-empty_list @27.14-27.16)) - (annotation @27.1-27.4 + (p-underscore @25.8-25.9) + (p-underscore @25.11-25.12)) + (e-empty_list @25.14-25.16)) + (annotation @25.1-25.4 (declared-type - (ty-fn @26.7-26.35 (effectful false) - (ty-parens @26.7-26.15 - (ty-fn @26.8-26.14 (effectful false) - (ty-var @26.8-26.9 (name "a")) - (ty-var @26.13-26.14 (name "b")))) - (ty-apply @26.17-26.24 (symbol "List") - (ty-var @26.22-26.23 (name "a"))) - (ty-apply @26.28-26.35 (symbol "List") - (ty-var @26.33-26.34 (name "b"))))))) + (ty-fn @24.7-24.35 (effectful false) + (ty-parens @24.7-24.15 + (ty-fn @24.8-24.14 (effectful false) + (ty-rigid-var @24.8-24.9 (name "a")) + (ty-rigid-var @24.13-24.14 (name "b")))) + (ty-apply @24.17-24.24 (name "List") (builtin) + (ty-rigid-var-lookup (ty-rigid-var @24.8-24.9 (name "a")))) + (ty-apply @24.28-24.35 (name "List") (builtin) + (ty-rigid-var-lookup (ty-rigid-var @24.13-24.14 (name "b")))))))) (d-let - (p-assign @31.1-31.10 (ident "transform")) - (e-lambda @31.13-31.21 + (p-assign @29.1-29.10 (ident "transform")) + (e-lambda @29.13-29.21 (args - (p-underscore @31.14-31.15) - (p-assign @31.17-31.18 (ident "b"))) - (e-lookup-local @31.20-31.21 - (p-assign @31.17-31.18 (ident "b")))))) + (p-underscore @29.14-29.15) + (p-assign @29.17-29.18 (ident "b"))) + (e-lookup-local @29.20-29.21 + (p-assign @29.17-29.18 (ident "b")))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @4.1-4.5 (type "_arg -> _ret")) - (patt @7.1-7.9 (type "a -> a")) - (patt @11.1-11.8 (type "List(_c) -> Str")) - (patt @15.1-15.9 (type "{ field: _field2, other: U32 } -> U32")) - (patt @19.1-19.14 (type "Result(ok, Str) -> Str")) - (patt @27.1-27.4 (type "a -> b, List(a) -> List(b)")) - (patt @31.1-31.10 (type "_arg, _arg2 -> _ret"))) + (patt @2.1-2.5 (type "_arg -> _ret")) + (patt @5.1-5.9 (type "a -> a")) + (patt @9.1-9.8 (type "List(_elem) -> Str")) + (patt @13.1-13.9 (type "{ field: _field2, other: Num(Int(Unsigned32)) } -> Num(Int(Unsigned32))")) + (patt @17.1-17.14 (type "Result(_c, Str) -> Str")) + (patt @25.1-25.4 (type "a -> b, List(a) -> List(b)")) + (patt @29.1-29.10 (type "_arg, c -> c"))) (expressions - (expr @4.8-4.13 (type "_arg -> _ret")) - (expr @7.12-7.17 (type "a -> a")) - (expr @11.11-11.29 (type "List(_c) -> Str")) - (expr @15.12-15.33 (type "{ field: _field2, other: U32 } -> U32")) - (expr @19.17-23.6 (type "Result(ok, Str) -> Str")) - (expr @27.7-27.16 (type "a -> b, List(a) -> List(b)")) - (expr @31.13-31.21 (type "_arg, _arg2 -> _ret")))) + (expr @2.8-2.13 (type "_arg -> _ret")) + (expr @5.12-5.17 (type "a -> a")) + (expr @9.11-9.29 (type "List(_elem) -> Str")) + (expr @13.12-13.33 (type "{ field: _field2, other: Num(Int(Unsigned32)) } -> Num(Int(Unsigned32))")) + (expr @17.17-21.6 (type "Result(_c, Str) -> Str")) + (expr @25.7-25.16 (type "a -> b, List(a) -> List(b)")) + (expr @29.13-29.21 (type "_arg, c -> c")))) ~~~ diff --git a/test/snapshots/pass/underscore_in_type_alias.md b/test/snapshots/pass/underscore_in_type_alias.md index adf8a78c7d..e2b928d20c 100644 --- a/test/snapshots/pass/underscore_in_type_alias.md +++ b/test/snapshots/pass/underscore_in_type_alias.md @@ -1,12 +1,10 @@ # META ~~~ini description=Type aliases should not contain underscores (_) as they represent 'I don't care' types, which doesn't make sense when declaring a type. -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - MyType : _ OtherType := _ @@ -24,20 +22,21 @@ TagType := [Some(_), None] # EXPECTED UNDERSCORE IN TYPE ALIAS - underscore_in_type_alias.md:1:1:1:1 UNDERSCORE IN TYPE ALIAS - underscore_in_type_alias.md:1:1:1:1 -UNDERSCORE IN TYPE ALIAS - underscore_in_type_alias.md:7:21:7:21 +UNDERSCORE IN TYPE ALIAS - underscore_in_type_alias.md:5:21:5:21 +UNDERSCORE IN TYPE ALIAS - underscore_in_type_alias.md:5:16:5:20 UNDERSCORE IN TYPE ALIAS - underscore_in_type_alias.md:1:1:1:1 UNDERSCORE IN TYPE ALIAS - underscore_in_type_alias.md:1:1:1:1 UNDERSCORE IN TYPE ALIAS - underscore_in_type_alias.md:1:1:1:1 -UNDERSCORE IN TYPE ALIAS - underscore_in_type_alias.md:13:15:13:15 +UNDERSCORE IN TYPE ALIAS - underscore_in_type_alias.md:11:15:11:15 UNDERSCORE IN TYPE ALIAS - underscore_in_type_alias.md:1:1:1:1 -UNDERSCORE IN TYPE ALIAS - underscore_in_type_alias.md:15:18:15:18 +UNDERSCORE IN TYPE ALIAS - underscore_in_type_alias.md:13:18:13:18 # PROBLEMS **UNDERSCORE IN TYPE ALIAS** Underscores are not allowed in type alias declarations. **underscore_in_type_alias.md:1:1:1:1:** ```roc -module [] +MyType : _ ``` ^ @@ -48,7 +47,7 @@ Underscores are not allowed in type alias declarations. **underscore_in_type_alias.md:1:1:1:1:** ```roc -module [] +MyType : _ ``` ^ @@ -57,7 +56,7 @@ Underscores in type annotations mean "I don't care about this type", which doesn **UNDERSCORE IN TYPE ALIAS** Underscores are not allowed in type alias declarations. -**underscore_in_type_alias.md:7:21:7:21:** +**underscore_in_type_alias.md:5:21:5:21:** ```roc ComplexType := List(_) ``` @@ -68,9 +67,20 @@ Underscores in type annotations mean "I don't care about this type", which doesn **UNDERSCORE IN TYPE ALIAS** Underscores are not allowed in type alias declarations. +**underscore_in_type_alias.md:5:16:5:20:** +```roc +ComplexType := List(_) +``` + ^^^^ + +Underscores in type annotations mean "I don't care about this type", which doesn't make sense when declaring a type. If you need a placeholder type variable, use a named type variable like `a` instead. + +**UNDERSCORE IN TYPE ALIAS** +Underscores are not allowed in type alias declarations. + **underscore_in_type_alias.md:1:1:1:1:** ```roc -module [] +MyType : _ ``` ^ @@ -81,7 +91,7 @@ Underscores are not allowed in type alias declarations. **underscore_in_type_alias.md:1:1:1:1:** ```roc -module [] +MyType : _ ``` ^ @@ -92,7 +102,7 @@ Underscores are not allowed in type alias declarations. **underscore_in_type_alias.md:1:1:1:1:** ```roc -module [] +MyType : _ ``` ^ @@ -101,7 +111,7 @@ Underscores in type annotations mean "I don't care about this type", which doesn **UNDERSCORE IN TYPE ALIAS** Underscores are not allowed in type alias declarations. -**underscore_in_type_alias.md:13:15:13:15:** +**underscore_in_type_alias.md:11:15:11:15:** ```roc TupleType := (_, U32, _) ``` @@ -114,7 +124,7 @@ Underscores are not allowed in type alias declarations. **underscore_in_type_alias.md:1:1:1:1:** ```roc -module [] +MyType : _ ``` ^ @@ -123,7 +133,7 @@ Underscores in type annotations mean "I don't care about this type", which doesn **UNDERSCORE IN TYPE ALIAS** Underscores are not allowed in type alias declarations. -**underscore_in_type_alias.md:15:18:15:18:** +**underscore_in_type_alias.md:13:18:13:18:** ```roc TagType := [Some(_), None] ``` @@ -133,71 +143,67 @@ Underscores in type annotations mean "I don't care about this type", which doesn # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -UpperIdent(3:1-3:7),OpColon(3:8-3:9),Underscore(3:10-3:11), -UpperIdent(5:1-5:10),OpColonEqual(5:11-5:13),Underscore(5:14-5:15), -UpperIdent(7:1-7:12),OpColonEqual(7:13-7:15),UpperIdent(7:16-7:20),NoSpaceOpenRound(7:20-7:21),Underscore(7:21-7:22),CloseRound(7:22-7:23), -UpperIdent(9:1-9:11),OpColonEqual(9:12-9:14),OpenCurly(9:15-9:16),LowerIdent(9:17-9:22),OpColon(9:22-9:23),Underscore(9:24-9:25),Comma(9:25-9:26),LowerIdent(9:27-9:32),OpColon(9:32-9:33),UpperIdent(9:34-9:37),CloseCurly(9:38-9:39), -UpperIdent(11:1-11:13),OpColonEqual(11:14-11:16),Underscore(11:17-11:18),OpArrow(11:19-11:21),Underscore(11:22-11:23), -UpperIdent(13:1-13:10),OpColonEqual(13:11-13:13),OpenRound(13:14-13:15),Underscore(13:15-13:16),Comma(13:16-13:17),UpperIdent(13:18-13:21),Comma(13:21-13:22),Underscore(13:23-13:24),CloseRound(13:24-13:25), -UpperIdent(15:1-15:8),OpColonEqual(15:9-15:11),OpenSquare(15:12-15:13),UpperIdent(15:13-15:17),NoSpaceOpenRound(15:17-15:18),Underscore(15:18-15:19),CloseRound(15:19-15:20),Comma(15:20-15:21),UpperIdent(15:22-15:26),CloseSquare(15:26-15:27), -EndOfFile(16:1-16:1), +UpperIdent(1:1-1:7),OpColon(1:8-1:9),Underscore(1:10-1:11), +UpperIdent(3:1-3:10),OpColonEqual(3:11-3:13),Underscore(3:14-3:15), +UpperIdent(5:1-5:12),OpColonEqual(5:13-5:15),UpperIdent(5:16-5:20),NoSpaceOpenRound(5:20-5:21),Underscore(5:21-5:22),CloseRound(5:22-5:23), +UpperIdent(7:1-7:11),OpColonEqual(7:12-7:14),OpenCurly(7:15-7:16),LowerIdent(7:17-7:22),OpColon(7:22-7:23),Underscore(7:24-7:25),Comma(7:25-7:26),LowerIdent(7:27-7:32),OpColon(7:32-7:33),UpperIdent(7:34-7:37),CloseCurly(7:38-7:39), +UpperIdent(9:1-9:13),OpColonEqual(9:14-9:16),Underscore(9:17-9:18),OpArrow(9:19-9:21),Underscore(9:22-9:23), +UpperIdent(11:1-11:10),OpColonEqual(11:11-11:13),OpenRound(11:14-11:15),Underscore(11:15-11:16),Comma(11:16-11:17),UpperIdent(11:18-11:21),Comma(11:21-11:22),Underscore(11:23-11:24),CloseRound(11:24-11:25), +UpperIdent(13:1-13:8),OpColonEqual(13:9-13:11),OpenSquare(13:12-13:13),UpperIdent(13:13-13:17),NoSpaceOpenRound(13:17-13:18),Underscore(13:18-13:19),CloseRound(13:19-13:20),Comma(13:20-13:21),UpperIdent(13:22-13:26),CloseSquare(13:26-13:27), +EndOfFile(14:1-14:1), ~~~ # PARSE ~~~clojure -(file @1.1-15.27 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-13.27 + (type-module @1.1-1.7) (statements - (s-type-decl @3.1-3.11 - (header @3.1-3.7 (name "MyType") + (s-type-decl @1.1-1.11 + (header @1.1-1.7 (name "MyType") (args)) (_)) - (s-type-decl @5.1-5.15 - (header @5.1-5.10 (name "OtherType") + (s-type-decl @3.1-3.15 + (header @3.1-3.10 (name "OtherType") (args)) (_)) - (s-type-decl @7.1-7.23 - (header @7.1-7.12 (name "ComplexType") + (s-type-decl @5.1-5.23 + (header @5.1-5.12 (name "ComplexType") (args)) - (ty-apply @7.16-7.23 - (ty @7.16-7.20 (name "List")) + (ty-apply @5.16-5.23 + (ty @5.16-5.20 (name "List")) (_))) - (s-type-decl @9.1-9.39 - (header @9.1-9.11 (name "RecordType") + (s-type-decl @7.1-7.39 + (header @7.1-7.11 (name "RecordType") (args)) - (ty-record @9.15-9.39 - (anno-record-field @9.17-9.25 (name "field") + (ty-record @7.15-7.39 + (anno-record-field @7.17-7.25 (name "field") (_)) - (anno-record-field @9.27-9.37 (name "other") - (ty @9.34-9.37 (name "U32"))))) - (s-type-decl @11.1-11.23 - (header @11.1-11.13 (name "FunctionType") + (anno-record-field @7.27-7.37 (name "other") + (ty @7.34-7.37 (name "U32"))))) + (s-type-decl @9.1-9.23 + (header @9.1-9.13 (name "FunctionType") (args)) - (ty-fn @11.17-11.23 + (ty-fn @9.17-9.23 (_) (_))) - (s-type-decl @13.1-13.25 - (header @13.1-13.10 (name "TupleType") + (s-type-decl @11.1-11.25 + (header @11.1-11.10 (name "TupleType") (args)) - (ty-tuple @13.14-13.25 + (ty-tuple @11.14-11.25 (_) - (ty @13.18-13.21 (name "U32")) + (ty @11.18-11.21 (name "U32")) (_))) - (s-type-decl @15.1-15.27 - (header @15.1-15.8 (name "TagType") + (s-type-decl @13.1-13.27 + (header @13.1-13.8 (name "TagType") (args)) - (ty-tag-union @15.12-15.27 + (ty-tag-union @13.12-13.27 (tags - (ty-apply @15.13-15.20 - (ty @15.13-15.17 (name "Some")) + (ty-apply @13.13-13.20 + (ty @13.13-13.17 (name "Some")) (_)) - (ty @15.22-15.26 (name "None"))))))) + (ty @13.22-13.26 (name "None"))))))) ~~~ # FORMATTED ~~~roc -module [] - MyType : _ OtherType := _ @@ -215,59 +221,59 @@ TagType := [Some(_), None] # CANONICALIZE ~~~clojure (can-ir - (s-alias-decl @3.1-3.11 - (ty-header @3.1-3.7 (name "MyType")) + (s-alias-decl @1.1-1.11 + (ty-header @1.1-1.7 (name "MyType")) (ty-underscore @1.1-1.1)) - (s-nominal-decl @5.1-5.15 - (ty-header @5.1-5.10 (name "OtherType")) + (s-nominal-decl @3.1-3.15 + (ty-header @3.1-3.10 (name "OtherType")) (ty-underscore @1.1-1.1)) - (s-nominal-decl @7.1-7.23 - (ty-header @7.1-7.12 (name "ComplexType")) - (ty-apply @7.16-7.23 (symbol "List") - (ty-underscore @7.21-7.21))) - (s-nominal-decl @9.1-9.39 - (ty-header @9.1-9.11 (name "RecordType")) - (ty-record @9.15-9.39 + (s-nominal-decl @5.1-5.23 + (ty-header @5.1-5.12 (name "ComplexType")) + (ty-apply @5.16-5.23 (name "List") (builtin) + (ty-underscore @5.21-5.21))) + (s-nominal-decl @7.1-7.39 + (ty-header @7.1-7.11 (name "RecordType")) + (ty-record @7.15-7.39 (field (field "field") (ty-underscore @1.1-1.1)) (field (field "other") - (ty @9.34-9.37 (name "U32"))))) - (s-nominal-decl @11.1-11.23 - (ty-header @11.1-11.13 (name "FunctionType")) - (ty-fn @11.17-11.23 (effectful false) + (ty-lookup @7.34-7.37 (name "U32") (builtin))))) + (s-nominal-decl @9.1-9.23 + (ty-header @9.1-9.13 (name "FunctionType")) + (ty-fn @9.17-9.23 (effectful false) (ty-underscore @1.1-1.1) (ty-underscore @1.1-1.1))) - (s-nominal-decl @13.1-13.25 - (ty-header @13.1-13.10 (name "TupleType")) - (ty-tuple @13.14-13.25 - (ty-underscore @13.15-13.15) - (ty @13.18-13.21 (name "U32")) + (s-nominal-decl @11.1-11.25 + (ty-header @11.1-11.10 (name "TupleType")) + (ty-tuple @11.14-11.25 + (ty-underscore @11.15-11.15) + (ty-lookup @11.18-11.21 (name "U32") (builtin)) (ty-underscore @1.1-1.1))) - (s-nominal-decl @15.1-15.27 - (ty-header @15.1-15.8 (name "TagType")) - (ty-tag-union @15.12-15.27 - (ty-apply @15.13-15.20 (symbol "Some") - (ty-underscore @15.18-15.18)) - (ty @15.22-15.26 (name "None"))))) + (s-nominal-decl @13.1-13.27 + (ty-header @13.1-13.8 (name "TagType")) + (ty-tag-union @13.12-13.27 + (ty-tag-name @13.13-13.20 (name "Some") + (ty-underscore @13.18-13.18)) + (ty-tag-name @13.22-13.26 (name "None"))))) ~~~ # TYPES ~~~clojure (inferred-types (defs) (type_decls - (alias @3.1-3.11 (type "Error") - (ty-header @3.1-3.7 (name "MyType"))) - (nominal @5.1-5.15 (type "Error") - (ty-header @5.1-5.10 (name "OtherType"))) - (nominal @7.1-7.23 (type "Error") - (ty-header @7.1-7.12 (name "ComplexType"))) - (nominal @9.1-9.39 (type "Error") - (ty-header @9.1-9.11 (name "RecordType"))) - (nominal @11.1-11.23 (type "Error") - (ty-header @11.1-11.13 (name "FunctionType"))) - (nominal @13.1-13.25 (type "Error") - (ty-header @13.1-13.10 (name "TupleType"))) - (nominal @15.1-15.27 (type "Error") - (ty-header @15.1-15.8 (name "TagType")))) + (alias @1.1-1.11 (type "MyType") + (ty-header @1.1-1.7 (name "MyType"))) + (nominal @3.1-3.15 (type "OtherType") + (ty-header @3.1-3.10 (name "OtherType"))) + (nominal @5.1-5.23 (type "ComplexType") + (ty-header @5.1-5.12 (name "ComplexType"))) + (nominal @7.1-7.39 (type "RecordType") + (ty-header @7.1-7.11 (name "RecordType"))) + (nominal @9.1-9.23 (type "FunctionType") + (ty-header @9.1-9.13 (name "FunctionType"))) + (nominal @11.1-11.25 (type "TupleType") + (ty-header @11.1-11.10 (name "TupleType"))) + (nominal @13.1-13.27 (type "TagType") + (ty-header @13.1-13.8 (name "TagType")))) (expressions)) ~~~ diff --git a/test/snapshots/pass/underscore_in_type_parameters.md b/test/snapshots/pass/underscore_in_type_parameters.md index 20263edeeb..d6c1108a70 100644 --- a/test/snapshots/pass/underscore_in_type_parameters.md +++ b/test/snapshots/pass/underscore_in_type_parameters.md @@ -1,12 +1,10 @@ # META ~~~ini description=Type parameters should not contain underscores (_) as they represent 'I don't care' types, which doesn't make sense when declaring a type. -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - # Type with underscore in parameter position MyType(_) : Str @@ -23,17 +21,17 @@ ComplexType(_, b) : { field: b } MultiType(_, _, c) : c ~~~ # EXPECTED -UNDERSCORE IN TYPE ALIAS - underscore_in_type_parameters.md:4:8:4:9 -UNDERSCORE IN TYPE ALIAS - underscore_in_type_parameters.md:7:9:7:10 -UNDERSCORE IN TYPE ALIAS - underscore_in_type_parameters.md:10:12:10:13 -UNDERSCORE IN TYPE ALIAS - underscore_in_type_parameters.md:13:13:13:14 -UNDERSCORE IN TYPE ALIAS - underscore_in_type_parameters.md:16:11:16:12 -UNDERSCORE IN TYPE ALIAS - underscore_in_type_parameters.md:16:14:16:15 +UNDERSCORE IN TYPE ALIAS - underscore_in_type_parameters.md:2:8:2:9 +UNDERSCORE IN TYPE ALIAS - underscore_in_type_parameters.md:5:9:5:10 +UNDERSCORE IN TYPE ALIAS - underscore_in_type_parameters.md:8:12:8:13 +UNDERSCORE IN TYPE ALIAS - underscore_in_type_parameters.md:11:13:11:14 +UNDERSCORE IN TYPE ALIAS - underscore_in_type_parameters.md:14:11:14:12 +UNDERSCORE IN TYPE ALIAS - underscore_in_type_parameters.md:14:14:14:15 # PROBLEMS **UNDERSCORE IN TYPE ALIAS** Underscores are not allowed in type alias declarations. -**underscore_in_type_parameters.md:4:8:4:9:** +**underscore_in_type_parameters.md:2:8:2:9:** ```roc MyType(_) : Str ``` @@ -44,7 +42,7 @@ Underscores in type annotations mean "I don't care about this type", which doesn **UNDERSCORE IN TYPE ALIAS** Underscores are not allowed in type alias declarations. -**underscore_in_type_parameters.md:7:9:7:10:** +**underscore_in_type_parameters.md:5:9:5:10:** ```roc MyType2(_, b) : b ``` @@ -55,7 +53,7 @@ Underscores in type annotations mean "I don't care about this type", which doesn **UNDERSCORE IN TYPE ALIAS** Underscores are not allowed in type alias declarations. -**underscore_in_type_parameters.md:10:12:10:13:** +**underscore_in_type_parameters.md:8:12:8:13:** ```roc MyType3(a, _) : a ``` @@ -66,7 +64,7 @@ Underscores in type annotations mean "I don't care about this type", which doesn **UNDERSCORE IN TYPE ALIAS** Underscores are not allowed in type alias declarations. -**underscore_in_type_parameters.md:13:13:13:14:** +**underscore_in_type_parameters.md:11:13:11:14:** ```roc ComplexType(_, b) : { field: b } ``` @@ -77,7 +75,7 @@ Underscores in type annotations mean "I don't care about this type", which doesn **UNDERSCORE IN TYPE ALIAS** Underscores are not allowed in type alias declarations. -**underscore_in_type_parameters.md:16:11:16:12:** +**underscore_in_type_parameters.md:14:11:14:12:** ```roc MultiType(_, _, c) : c ``` @@ -88,7 +86,7 @@ Underscores in type annotations mean "I don't care about this type", which doesn **UNDERSCORE IN TYPE ALIAS** Underscores are not allowed in type alias declarations. -**underscore_in_type_parameters.md:16:14:16:15:** +**underscore_in_type_parameters.md:14:14:14:15:** ```roc MultiType(_, _, c) : c ``` @@ -98,57 +96,54 @@ Underscores in type annotations mean "I don't care about this type", which doesn # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -UpperIdent(4:1-4:7),NoSpaceOpenRound(4:7-4:8),Underscore(4:8-4:9),CloseRound(4:9-4:10),OpColon(4:11-4:12),UpperIdent(4:13-4:16), -UpperIdent(7:1-7:8),NoSpaceOpenRound(7:8-7:9),Underscore(7:9-7:10),Comma(7:10-7:11),LowerIdent(7:12-7:13),CloseRound(7:13-7:14),OpColon(7:15-7:16),LowerIdent(7:17-7:18), -UpperIdent(10:1-10:8),NoSpaceOpenRound(10:8-10:9),LowerIdent(10:9-10:10),Comma(10:10-10:11),Underscore(10:12-10:13),CloseRound(10:13-10:14),OpColon(10:15-10:16),LowerIdent(10:17-10:18), -UpperIdent(13:1-13:12),NoSpaceOpenRound(13:12-13:13),Underscore(13:13-13:14),Comma(13:14-13:15),LowerIdent(13:16-13:17),CloseRound(13:17-13:18),OpColon(13:19-13:20),OpenCurly(13:21-13:22),LowerIdent(13:23-13:28),OpColon(13:28-13:29),LowerIdent(13:30-13:31),CloseCurly(13:32-13:33), -UpperIdent(16:1-16:10),NoSpaceOpenRound(16:10-16:11),Underscore(16:11-16:12),Comma(16:12-16:13),Underscore(16:14-16:15),Comma(16:15-16:16),LowerIdent(16:17-16:18),CloseRound(16:18-16:19),OpColon(16:20-16:21),LowerIdent(16:22-16:23), -EndOfFile(17:1-17:1), +UpperIdent(2:1-2:7),NoSpaceOpenRound(2:7-2:8),Underscore(2:8-2:9),CloseRound(2:9-2:10),OpColon(2:11-2:12),UpperIdent(2:13-2:16), +UpperIdent(5:1-5:8),NoSpaceOpenRound(5:8-5:9),Underscore(5:9-5:10),Comma(5:10-5:11),LowerIdent(5:12-5:13),CloseRound(5:13-5:14),OpColon(5:15-5:16),LowerIdent(5:17-5:18), +UpperIdent(8:1-8:8),NoSpaceOpenRound(8:8-8:9),LowerIdent(8:9-8:10),Comma(8:10-8:11),Underscore(8:12-8:13),CloseRound(8:13-8:14),OpColon(8:15-8:16),LowerIdent(8:17-8:18), +UpperIdent(11:1-11:12),NoSpaceOpenRound(11:12-11:13),Underscore(11:13-11:14),Comma(11:14-11:15),LowerIdent(11:16-11:17),CloseRound(11:17-11:18),OpColon(11:19-11:20),OpenCurly(11:21-11:22),LowerIdent(11:23-11:28),OpColon(11:28-11:29),LowerIdent(11:30-11:31),CloseCurly(11:32-11:33), +UpperIdent(14:1-14:10),NoSpaceOpenRound(14:10-14:11),Underscore(14:11-14:12),Comma(14:12-14:13),Underscore(14:14-14:15),Comma(14:15-14:16),LowerIdent(14:17-14:18),CloseRound(14:18-14:19),OpColon(14:20-14:21),LowerIdent(14:22-14:23), +EndOfFile(15:1-15:1), ~~~ # PARSE ~~~clojure -(file @1.1-16.23 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @2.1-14.23 + (type-module @2.1-2.7) (statements - (s-type-decl @4.1-4.16 - (header @4.1-4.10 (name "MyType") + (s-type-decl @2.1-2.16 + (header @2.1-2.10 (name "MyType") (args (_))) - (ty @4.13-4.16 (name "Str"))) - (s-type-decl @7.1-7.18 - (header @7.1-7.14 (name "MyType2") + (ty @2.13-2.16 (name "Str"))) + (s-type-decl @5.1-5.18 + (header @5.1-5.14 (name "MyType2") (args (_) - (ty-var @7.12-7.13 (raw "b")))) - (ty-var @7.17-7.18 (raw "b"))) - (s-type-decl @10.1-10.18 - (header @10.1-10.14 (name "MyType3") + (ty-var @5.12-5.13 (raw "b")))) + (ty-var @5.17-5.18 (raw "b"))) + (s-type-decl @8.1-8.18 + (header @8.1-8.14 (name "MyType3") (args - (ty-var @10.9-10.10 (raw "a")) + (ty-var @8.9-8.10 (raw "a")) (_))) - (ty-var @10.17-10.18 (raw "a"))) - (s-type-decl @13.1-13.33 - (header @13.1-13.18 (name "ComplexType") + (ty-var @8.17-8.18 (raw "a"))) + (s-type-decl @11.1-11.33 + (header @11.1-11.18 (name "ComplexType") (args (_) - (ty-var @13.16-13.17 (raw "b")))) - (ty-record @13.21-13.33 - (anno-record-field @13.23-13.31 (name "field") - (ty-var @13.30-13.31 (raw "b"))))) - (s-type-decl @16.1-16.23 - (header @16.1-16.19 (name "MultiType") + (ty-var @11.16-11.17 (raw "b")))) + (ty-record @11.21-11.33 + (anno-record-field @11.23-11.31 (name "field") + (ty-var @11.30-11.31 (raw "b"))))) + (s-type-decl @14.1-14.23 + (header @14.1-14.19 (name "MultiType") (args (_) (_) - (ty-var @16.17-16.18 (raw "c")))) - (ty-var @16.22-16.23 (raw "c"))))) + (ty-var @14.17-14.18 (raw "c")))) + (ty-var @14.22-14.23 (raw "c"))))) ~~~ # FORMATTED ~~~roc -module [] - +# Type with underscore in parameter position # Type with underscore in parameter position MyType(_) : Str @@ -167,68 +162,68 @@ MultiType(_, _, c) : c # CANONICALIZE ~~~clojure (can-ir - (s-alias-decl @4.1-4.16 - (ty-header @4.1-4.10 (name "MyType") + (s-alias-decl @2.1-2.16 + (ty-header @2.1-2.10 (name "MyType") (ty-args - (ty-underscore @4.8-4.9))) - (ty @4.13-4.16 (name "Str"))) - (s-alias-decl @7.1-7.18 - (ty-header @7.1-7.14 (name "MyType2") + (ty-underscore @2.8-2.9))) + (ty-lookup @2.13-2.16 (name "Str") (builtin))) + (s-alias-decl @5.1-5.18 + (ty-header @5.1-5.14 (name "MyType2") (ty-args - (ty-underscore @7.9-7.10) - (ty-var @7.12-7.13 (name "b")))) - (ty-var @7.17-7.18 (name "b"))) - (s-alias-decl @10.1-10.18 - (ty-header @10.1-10.14 (name "MyType3") + (ty-underscore @5.9-5.10) + (ty-rigid-var @5.12-5.13 (name "b")))) + (ty-rigid-var-lookup (ty-rigid-var @5.12-5.13 (name "b")))) + (s-alias-decl @8.1-8.18 + (ty-header @8.1-8.14 (name "MyType3") (ty-args - (ty-var @10.9-10.10 (name "a")) - (ty-underscore @10.12-10.13))) - (ty-var @10.17-10.18 (name "a"))) - (s-alias-decl @13.1-13.33 - (ty-header @13.1-13.18 (name "ComplexType") + (ty-rigid-var @8.9-8.10 (name "a")) + (ty-underscore @8.12-8.13))) + (ty-rigid-var-lookup (ty-rigid-var @8.9-8.10 (name "a")))) + (s-alias-decl @11.1-11.33 + (ty-header @11.1-11.18 (name "ComplexType") (ty-args - (ty-underscore @13.13-13.14) - (ty-var @13.16-13.17 (name "b")))) - (ty-record @13.21-13.33 + (ty-underscore @11.13-11.14) + (ty-rigid-var @11.16-11.17 (name "b")))) + (ty-record @11.21-11.33 (field (field "field") - (ty-var @13.30-13.31 (name "b"))))) - (s-alias-decl @16.1-16.23 - (ty-header @16.1-16.19 (name "MultiType") + (ty-rigid-var-lookup (ty-rigid-var @11.16-11.17 (name "b")))))) + (s-alias-decl @14.1-14.23 + (ty-header @14.1-14.19 (name "MultiType") (ty-args - (ty-underscore @16.11-16.12) - (ty-underscore @16.14-16.15) - (ty-var @16.17-16.18 (name "c")))) - (ty-var @16.22-16.23 (name "c")))) + (ty-underscore @14.11-14.12) + (ty-underscore @14.14-14.15) + (ty-rigid-var @14.17-14.18 (name "c")))) + (ty-rigid-var-lookup (ty-rigid-var @14.17-14.18 (name "c"))))) ~~~ # TYPES ~~~clojure (inferred-types (defs) (type_decls - (alias @4.1-4.16 (type "MyType(Error)") - (ty-header @4.1-4.10 (name "MyType") + (alias @2.1-2.16 (type "MyType(Error)") + (ty-header @2.1-2.10 (name "MyType") (ty-args - (ty-underscore @4.8-4.9)))) - (alias @7.1-7.18 (type "MyType2(Error, b)") - (ty-header @7.1-7.14 (name "MyType2") + (ty-underscore @2.8-2.9)))) + (alias @5.1-5.18 (type "MyType2(Error, b)") + (ty-header @5.1-5.14 (name "MyType2") (ty-args - (ty-underscore @7.9-7.10) - (ty-var @7.12-7.13 (name "b"))))) - (alias @10.1-10.18 (type "MyType3(a, Error)") - (ty-header @10.1-10.14 (name "MyType3") + (ty-underscore @5.9-5.10) + (ty-rigid-var @5.12-5.13 (name "b"))))) + (alias @8.1-8.18 (type "MyType3(a, Error)") + (ty-header @8.1-8.14 (name "MyType3") (ty-args - (ty-var @10.9-10.10 (name "a")) - (ty-underscore @10.12-10.13)))) - (alias @13.1-13.33 (type "ComplexType(Error, b)") - (ty-header @13.1-13.18 (name "ComplexType") + (ty-rigid-var @8.9-8.10 (name "a")) + (ty-underscore @8.12-8.13)))) + (alias @11.1-11.33 (type "ComplexType(Error, b)") + (ty-header @11.1-11.18 (name "ComplexType") (ty-args - (ty-underscore @13.13-13.14) - (ty-var @13.16-13.17 (name "b"))))) - (alias @16.1-16.23 (type "MultiType(Error, Error, c)") - (ty-header @16.1-16.19 (name "MultiType") + (ty-underscore @11.13-11.14) + (ty-rigid-var @11.16-11.17 (name "b"))))) + (alias @14.1-14.23 (type "MultiType(Error, Error, c)") + (ty-header @14.1-14.19 (name "MultiType") (ty-args - (ty-underscore @16.11-16.12) - (ty-underscore @16.14-16.15) - (ty-var @16.17-16.18 (name "c")))))) + (ty-underscore @14.11-14.12) + (ty-underscore @14.14-14.15) + (ty-rigid-var @14.17-14.18 (name "c")))))) (expressions)) ~~~ diff --git a/test/snapshots/platform/platform_header_str_simple.md b/test/snapshots/platform/platform_header_str_simple.md index 9d1b3afca3..8045eafb5f 100644 --- a/test/snapshots/platform/platform_header_str_simple.md +++ b/test/snapshots/platform/platform_header_str_simple.md @@ -77,8 +77,8 @@ NO CHANGE (annotation @8.1-8.11 (declared-type (ty-fn @7.14-7.24 (effectful false) - (ty @7.14-7.17 (name "Str")) - (ty @7.21-7.24 (name "Str"))))))) + (ty-lookup @7.14-7.17 (name "Str") (builtin)) + (ty-lookup @7.21-7.24 (name "Str") (builtin))))))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/plume_package/Color.md b/test/snapshots/plume_package/Color.md index c983cce9f2..bebbf6da71 100644 --- a/test/snapshots/plume_package/Color.md +++ b/test/snapshots/plume_package/Color.md @@ -78,10 +78,30 @@ is_named_color = |str|{ } ~~~ # EXPECTED +MODULE HEADER DEPRECATED - Color.md:1:1:8:2 UNUSED VARIABLE - Color.md:30:5:30:25 UNDEFINED VARIABLE - Color.md:68:14:68:27 -INVALID NOMINAL TAG - Color.md:23:5:23:33 +TYPE MISMATCH - Color.md:51:104:51:105 # PROBLEMS +**MODULE HEADER DEPRECATED** +The `module` header is deprecated. + +Type modules (headerless files with a top-level type matching the filename) are now the preferred way to define modules. + +Remove the `module` header and ensure your file defines a type that matches the filename. +**Color.md:1:1:8:2:** +```roc +module [ + Color, + to_str, + rgb, + rgba, + hex, + named, +] +``` + + **UNUSED VARIABLE** Variable `is_char_in_hex_range` is not used anywhere in your code. @@ -105,23 +125,19 @@ Is there an `import` or `exposing` missing up-top? ^^^^^^^^^^^^^ -**INVALID NOMINAL TAG** -I'm having trouble with this nominal tag: -**Color.md:23:5:23:33:** +**TYPE MISMATCH** +The first argument being passed to this function has the wrong type: +**Color.md:51:104:51:105:** ```roc - Color.RGBA(r, g, b, rounded) + Color.RGBA(r, g, b, a) => "rgba(${Num.to_str(r)}, ${Num.to_str(g)}, ${Num.to_str(b)}, ${Num.to_str(a)})" ``` - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + ^ -The tag is: - _RGBA(U8, U8, U8, Num(_size))_ +This argument has the type: + _Num(Frac(Decimal))_ -But it should be one of: - _[Hex(Str), Named(Str), RGB(U8, U8, U8), RGBA(U8, U8, U8, Dec)]_ - -**Hint:** The nominal type has a tag with the same name, but different args: - - _RGBA(U8, U8, U8, Dec)_ +But `to_str` needs the first argument to be: + _Num(Int(Unsigned8))_ # TOKENS ~~~zig @@ -655,10 +671,10 @@ is_named_color = |str| { (annotation @18.1-18.4 (declared-type (ty-fn @17.7-17.26 (effectful false) - (ty @17.7-17.9 (name "U8")) - (ty @17.11-17.13 (name "U8")) - (ty @17.15-17.17 (name "U8")) - (ty @17.21-17.26 (name "Color")))))) + (ty-lookup @17.7-17.9 (name "U8") (builtin)) + (ty-lookup @17.11-17.13 (name "U8") (builtin)) + (ty-lookup @17.15-17.17 (name "U8") (builtin)) + (ty-lookup @17.21-17.26 (name "Color") (local)))))) (d-let (p-assign @21.1-21.5 (ident "rgba")) (e-lambda @21.8-24.2 @@ -691,22 +707,22 @@ is_named_color = |str| { (annotation @21.1-21.5 (declared-type (ty-fn @20.8-20.31 (effectful false) - (ty @20.8-20.10 (name "U8")) - (ty @20.12-20.14 (name "U8")) - (ty @20.16-20.18 (name "U8")) - (ty @20.20-20.22 (name "U8")) - (ty @20.26-20.31 (name "Color")))))) + (ty-lookup @20.8-20.10 (name "U8") (builtin)) + (ty-lookup @20.12-20.14 (name "U8") (builtin)) + (ty-lookup @20.16-20.18 (name "U8") (builtin)) + (ty-lookup @20.20-20.22 (name "U8") (builtin)) + (ty-lookup @20.26-20.31 (name "Color") (local)))))) (d-let (p-assign @27.1-27.4 (ident "hex")) (e-closure @27.7-46.2 (captures - (capture @33.21-33.22 (ident "c")) + (capture @34.13-34.21 (ident "is_valid")) + (capture @33.24-33.25 (ident "d")) (capture @33.30-33.31 (ident "f")) (capture @33.15-33.16 (ident "a")) (capture @33.18-33.19 (ident "b")) - (capture @33.27-33.28 (ident "e")) - (capture @33.24-33.25 (ident "d")) - (capture @34.13-34.21 (ident "is_valid"))) + (capture @33.21-33.22 (ident "c")) + (capture @33.27-33.28 (ident "e"))) (e-lambda @27.7-46.2 (args (p-assign @27.8-27.11 (ident "str"))) @@ -728,30 +744,30 @@ is_named_color = |str| { (e-binop @30.33-30.41 (op "ge") (e-lookup-local @30.33-30.34 (p-assign @30.29-30.30 (ident "b"))) - (e-int @30.38-30.41 (value "48"))) + (e-num @30.38-30.41 (value "48"))) (e-binop @30.46-30.54 (op "le") (e-lookup-local @30.46-30.47 (p-assign @30.29-30.30 (ident "b"))) - (e-int @30.51-30.54 (value "57")))) + (e-num @30.51-30.54 (value "57")))) (e-binop @30.59-30.109 (op "or") (e-binop @30.60-30.81 (op "and") (e-binop @30.60-30.68 (op "ge") (e-lookup-local @30.60-30.61 (p-assign @30.29-30.30 (ident "b"))) - (e-int @30.65-30.68 (value "97"))) + (e-num @30.65-30.68 (value "97"))) (e-binop @30.73-30.81 (op "le") (e-lookup-local @30.73-30.74 (p-assign @30.29-30.30 (ident "b"))) - (e-int @30.78-30.81 (value "102")))) + (e-num @30.78-30.81 (value "102")))) (e-binop @30.87-30.108 (op "and") (e-binop @30.87-30.95 (op "ge") (e-lookup-local @30.87-30.88 (p-assign @30.29-30.30 (ident "b"))) - (e-int @30.92-30.95 (value "65"))) + (e-num @30.92-30.95 (value "65"))) (e-binop @30.100-30.108 (op "le") (e-lookup-local @30.100-30.101 (p-assign @30.29-30.30 (ident "b"))) - (e-int @30.105-30.108 (value "70")))))))) + (e-num @30.105-30.108 (value "70")))))))) (e-match @32.5-45.6 (match @32.5-45.6 (cond @@ -763,7 +779,7 @@ is_named_color = |str| { (pattern (degenerate false) (p-list @33.9-33.32 (patterns - (p-int @33.10-33.13 (value "35")) + (p-num @33.10-33.13 (value "35")) (p-assign @33.15-33.16 (ident "a")) (p-assign @33.18-33.19 (ident "b")) (p-assign @33.21-33.22 (ident "c")) @@ -851,26 +867,26 @@ is_named_color = |str| { (annotation @27.1-27.4 (declared-type (ty-fn @26.7-26.46 (effectful false) - (ty @26.7-26.10 (name "Str")) - (ty-apply @26.14-26.46 (symbol "Result") - (ty @26.21-26.26 (name "Color")) - (ty-tag-union @26.28-26.45 - (ty-apply @26.29-26.44 (symbol "InvalidHex") - (ty @26.40-26.43 (name "Str"))))))))) + (ty-lookup @26.7-26.10 (name "Str") (builtin)) + (ty-apply @26.14-26.46 (name "Result") (local) + (ty-lookup @26.14-26.46 (name "Color") (local)) + (ty-tag-union @26.14-26.46 + (ty-tag-name @26.29-26.44 (name "InvalidHex") + (ty-lookup @26.40-26.43 (name "Str") (builtin))))))))) (d-let (p-assign @49.1-49.7 (ident "to_str")) (e-closure @49.10-54.2 (captures (capture @51.22-51.23 (ident "b")) (capture @51.25-51.26 (ident "a")) - (capture @49.1-49.7 (ident "to_str")) - (capture @52.17-52.22 (ident "inner")) - (capture @50.15-50.16 (ident "r")) - (capture @50.18-50.19 (ident "g")) (capture @53.15-53.20 (ident "inner")) + (capture @50.18-50.19 (ident "g")) + (capture @50.21-50.22 (ident "b")) + (capture @49.1-49.7 (ident "to_str")) + (capture @50.15-50.16 (ident "r")) (capture @51.19-51.20 (ident "g")) - (capture @51.16-51.17 (ident "r")) - (capture @50.21-50.22 (ident "b"))) + (capture @52.17-52.22 (ident "inner")) + (capture @51.16-51.17 (ident "r"))) (e-lambda @49.10-54.2 (args (p-assign @49.11-49.16 (ident "color"))) @@ -957,8 +973,8 @@ is_named_color = |str| { (annotation @49.1-49.7 (declared-type (ty-fn @48.10-48.22 (effectful false) - (ty @48.10-48.15 (name "Color")) - (ty @48.19-48.22 (name "Str")))))) + (ty-lookup @48.10-48.15 (name "Color") (local)) + (ty-lookup @48.19-48.22 (name "Str") (builtin)))))) (d-let (p-assign @61.1-61.6 (ident "named")) (e-lambda @61.9-65.50 @@ -994,12 +1010,12 @@ is_named_color = |str| { (annotation @61.1-61.6 (declared-type (ty-fn @60.9-60.50 (effectful false) - (ty @60.9-60.12 (name "Str")) - (ty-apply @60.16-60.50 (symbol "Result") - (ty @60.23-60.28 (name "Color")) - (ty-tag-union @60.30-60.49 - (ty-apply @60.31-60.48 (symbol "UnknownColor") - (ty @60.44-60.47 (name "Str"))))))))) + (ty-lookup @60.9-60.12 (name "Str") (builtin)) + (ty-apply @60.16-60.50 (name "Result") (local) + (ty-lookup @60.16-60.50 (name "Color") (local)) + (ty-tag-union @60.16-60.50 + (ty-tag-name @60.31-60.48 (name "UnknownColor") + (ty-lookup @60.44-60.47 (name "Str") (builtin))))))))) (d-let (p-assign @67.1-67.15 (ident "is_named_color")) (e-lambda @67.18-71.2 @@ -1028,19 +1044,19 @@ is_named_color = |str| { (s-nominal-decl @10.1-15.2 (ty-header @10.1-10.6 (name "Color")) (ty-tag-union @10.10-15.2 - (ty-apply @11.5-11.20 (symbol "RGB") - (ty @11.9-11.11 (name "U8")) - (ty @11.13-11.15 (name "U8")) - (ty @11.17-11.19 (name "U8"))) - (ty-apply @12.5-12.26 (symbol "RGBA") - (ty @12.10-12.12 (name "U8")) - (ty @12.14-12.16 (name "U8")) - (ty @12.18-12.20 (name "U8")) - (ty @12.22-12.25 (name "Dec"))) - (ty-apply @13.5-13.15 (symbol "Named") - (ty @13.11-13.14 (name "Str"))) - (ty-apply @14.5-14.13 (symbol "Hex") - (ty @14.9-14.12 (name "Str"))))) + (ty-tag-name @11.5-11.20 (name "RGB") + (ty-lookup @11.9-11.11 (name "U8") (builtin)) + (ty-lookup @11.13-11.15 (name "U8") (builtin)) + (ty-lookup @11.17-11.19 (name "U8") (builtin))) + (ty-tag-name @12.5-12.26 (name "RGBA") + (ty-lookup @12.10-12.12 (name "U8") (builtin)) + (ty-lookup @12.14-12.16 (name "U8") (builtin)) + (ty-lookup @12.18-12.20 (name "U8") (builtin)) + (ty-lookup @12.22-12.25 (name "Dec") (builtin))) + (ty-tag-name @13.5-13.15 (name "Named") + (ty-lookup @13.11-13.14 (name "Str") (builtin))) + (ty-tag-name @14.5-14.13 (name "Hex") + (ty-lookup @14.9-14.12 (name "Str") (builtin))))) (s-expect @56.1-56.57 (e-binop @56.8-56.57 (op "eq") (e-dot-access @56.8-56.34 (field "to_str") @@ -1048,9 +1064,9 @@ is_named_color = |str| { (e-call @56.8-56.25 (e-lookup-local @56.8-56.11 (p-assign @18.1-18.4 (ident "rgb"))) - (e-int @56.12-56.15 (value "124")) - (e-int @56.17-56.19 (value "56")) - (e-int @56.21-56.24 (value "245")))) + (e-num @56.12-56.15 (value "124")) + (e-num @56.17-56.19 (value "56")) + (e-num @56.21-56.24 (value "245")))) (args)) (e-string @56.38-56.57 (e-literal @56.39-56.56 (string "rgb(124, 56, 245)"))))) @@ -1061,10 +1077,10 @@ is_named_color = |str| { (e-call @57.8-57.31 (e-lookup-local @57.8-57.12 (p-assign @21.1-21.5 (ident "rgba"))) - (e-int @57.13-57.16 (value "124")) - (e-int @57.18-57.20 (value "56")) - (e-int @57.22-57.25 (value "245")) - (e-int @57.27-57.30 (value "255")))) + (e-num @57.13-57.16 (value "124")) + (e-num @57.18-57.20 (value "56")) + (e-num @57.22-57.25 (value "245")) + (e-num @57.27-57.30 (value "255")))) (args)) (e-string @57.44-57.69 (e-literal @57.45-57.68 (string "rgba(124, 56, 245, 1.0)"))))) @@ -1090,20 +1106,20 @@ is_named_color = |str| { ~~~clojure (inferred-types (defs - (patt @18.1-18.4 (type "U8, U8, U8 -> Error")) - (patt @21.1-21.5 (type "U8, U8, U8, U8 -> Error")) - (patt @27.1-27.4 (type "Str -> Result(Error, [InvalidHex(Str)])")) - (patt @49.1-49.7 (type "Error -> Str")) - (patt @61.1-61.6 (type "Str -> Result(Error, [UnknownColor(Str)])")) + (patt @18.1-18.4 (type "Num(Int(Unsigned8)), Num(Int(Unsigned8)), Num(Int(Unsigned8)) -> Color")) + (patt @21.1-21.5 (type "Num(Int(Unsigned8)), Num(Int(Unsigned8)), Num(Int(Unsigned8)), Num(Int(Unsigned8)) -> Color")) + (patt @27.1-27.4 (type "Str -> Result(Color, [InvalidHex(Str)])")) + (patt @49.1-49.7 (type "Error -> Error")) + (patt @61.1-61.6 (type "Str -> Result(Color, [UnknownColor(Str)])")) (patt @67.1-67.15 (type "_arg -> _ret"))) (type_decls - (nominal @10.1-15.2 (type "Error") + (nominal @10.1-15.2 (type "Color") (ty-header @10.1-10.6 (name "Color")))) (expressions - (expr @18.7-18.35 (type "U8, U8, U8 -> Error")) - (expr @21.8-24.2 (type "U8, U8, U8, U8 -> Error")) - (expr @27.7-46.2 (type "Str -> Result(Error, [InvalidHex(Str)])")) - (expr @49.10-54.2 (type "Error -> Str")) - (expr @61.9-65.50 (type "Str -> Result(Error, [UnknownColor(Str)])")) + (expr @18.7-18.35 (type "Num(Int(Unsigned8)), Num(Int(Unsigned8)), Num(Int(Unsigned8)) -> Color")) + (expr @21.8-24.2 (type "Num(Int(Unsigned8)), Num(Int(Unsigned8)), Num(Int(Unsigned8)), Num(Int(Unsigned8)) -> Color")) + (expr @27.7-46.2 (type "Str -> Result(Color, [InvalidHex(Str)])")) + (expr @49.10-54.2 (type "Error -> Error")) + (expr @61.9-65.50 (type "Str -> Result(Color, [UnknownColor(Str)])")) (expr @67.18-71.2 (type "_arg -> _ret")))) ~~~ diff --git a/test/snapshots/primitive/expr_float.md b/test/snapshots/primitive/expr_float.md index c949a51533..1aaf7ea78c 100644 --- a/test/snapshots/primitive/expr_float.md +++ b/test/snapshots/primitive/expr_float.md @@ -1,11 +1,10 @@ # META ~~~ini description=A primitive -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [foo] foo = 12.34 ~~~ # EXPECTED @@ -14,21 +13,17 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:12),CloseSquare(1:12-1:13), -LowerIdent(2:1-2:4),OpAssign(2:5-2:6),Float(2:7-2:12), -EndOfFile(3:1-3:1), +LowerIdent(1:1-1:4),OpAssign(1:5-1:6),Float(1:7-1:12), +EndOfFile(2:1-2:1), ~~~ # PARSE ~~~clojure -(file @1.1-2.12 - (module @1.1-1.13 - (exposes @1.8-1.13 - (exposed-lower-ident @1.9-1.12 - (text "foo")))) +(file @1.1-1.12 + (type-module @1.1-1.4) (statements - (s-decl @2.1-2.12 - (p-ident @2.1-2.4 (raw "foo")) - (e-frac @2.7-2.12 (raw "12.34"))))) + (s-decl @1.1-1.12 + (p-ident @1.1-1.4 (raw "foo")) + (e-frac @1.7-1.12 (raw "12.34"))))) ~~~ # FORMATTED ~~~roc @@ -38,14 +33,14 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @2.1-2.4 (ident "foo")) - (e-dec-small @2.7-2.12 (numerator "1234") (denominator-power-of-ten "2") (value "12.34")))) + (p-assign @1.1-1.4 (ident "foo")) + (e-dec-small @1.7-1.12 (numerator "1234") (denominator-power-of-ten "2") (value "12.34")))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @2.1-2.4 (type "Frac(_size)"))) + (patt @1.1-1.4 (type "Num(Frac(_size))"))) (expressions - (expr @2.7-2.12 (type "Frac(_size)")))) + (expr @1.7-1.12 (type "Num(Frac(_size))")))) ~~~ diff --git a/test/snapshots/primitive/expr_int.md b/test/snapshots/primitive/expr_int.md index 6da60c6b64..3b80d21f1c 100644 --- a/test/snapshots/primitive/expr_int.md +++ b/test/snapshots/primitive/expr_int.md @@ -1,11 +1,10 @@ # META ~~~ini description=A primitive -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [foo] foo = 42 ~~~ # EXPECTED @@ -14,21 +13,17 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:12),CloseSquare(1:12-1:13), -LowerIdent(2:1-2:4),OpAssign(2:5-2:6),Int(2:7-2:9), -EndOfFile(3:1-3:1), +LowerIdent(1:1-1:4),OpAssign(1:5-1:6),Int(1:7-1:9), +EndOfFile(2:1-2:1), ~~~ # PARSE ~~~clojure -(file @1.1-2.9 - (module @1.1-1.13 - (exposes @1.8-1.13 - (exposed-lower-ident @1.9-1.12 - (text "foo")))) +(file @1.1-1.9 + (type-module @1.1-1.4) (statements - (s-decl @2.1-2.9 - (p-ident @2.1-2.4 (raw "foo")) - (e-int @2.7-2.9 (raw "42"))))) + (s-decl @1.1-1.9 + (p-ident @1.1-1.4 (raw "foo")) + (e-int @1.7-1.9 (raw "42"))))) ~~~ # FORMATTED ~~~roc @@ -38,14 +33,14 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @2.1-2.4 (ident "foo")) - (e-int @2.7-2.9 (value "42")))) + (p-assign @1.1-1.4 (ident "foo")) + (e-num @1.7-1.9 (value "42")))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @2.1-2.4 (type "Num(_size)"))) + (patt @1.1-1.4 (type "Num(_size)"))) (expressions - (expr @2.7-2.9 (type "Num(_size)")))) + (expr @1.7-1.9 (type "Num(_size)")))) ~~~ diff --git a/test/snapshots/primitive/expr_string.md b/test/snapshots/primitive/expr_string.md index fabedafb87..247682efee 100644 --- a/test/snapshots/primitive/expr_string.md +++ b/test/snapshots/primitive/expr_string.md @@ -1,11 +1,10 @@ # META ~~~ini description=A primitive -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [foo] name = "luc" foo = "hello ${name}" ~~~ @@ -15,29 +14,25 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:12),CloseSquare(1:12-1:13), -LowerIdent(2:1-2:5),OpAssign(2:6-2:7),StringStart(2:8-2:9),StringPart(2:9-2:12),StringEnd(2:12-2:13), -LowerIdent(3:1-3:4),OpAssign(3:5-3:6),StringStart(3:7-3:8),StringPart(3:8-3:14),OpenStringInterpolation(3:14-3:16),LowerIdent(3:16-3:20),CloseStringInterpolation(3:20-3:21),StringPart(3:21-3:21),StringEnd(3:21-3:22), -EndOfFile(4:1-4:1), +LowerIdent(1:1-1:5),OpAssign(1:6-1:7),StringStart(1:8-1:9),StringPart(1:9-1:12),StringEnd(1:12-1:13), +LowerIdent(2:1-2:4),OpAssign(2:5-2:6),StringStart(2:7-2:8),StringPart(2:8-2:14),OpenStringInterpolation(2:14-2:16),LowerIdent(2:16-2:20),CloseStringInterpolation(2:20-2:21),StringPart(2:21-2:21),StringEnd(2:21-2:22), +EndOfFile(3:1-3:1), ~~~ # PARSE ~~~clojure -(file @1.1-3.22 - (module @1.1-1.13 - (exposes @1.8-1.13 - (exposed-lower-ident @1.9-1.12 - (text "foo")))) +(file @1.1-2.22 + (type-module @1.1-1.5) (statements - (s-decl @2.1-2.13 - (p-ident @2.1-2.5 (raw "name")) - (e-string @2.8-2.13 - (e-string-part @2.9-2.12 (raw "luc")))) - (s-decl @3.1-3.22 - (p-ident @3.1-3.4 (raw "foo")) - (e-string @3.7-3.22 - (e-string-part @3.8-3.14 (raw "hello ")) - (e-ident @3.16-3.20 (raw "name")) - (e-string-part @3.21-3.21 (raw "")))))) + (s-decl @1.1-1.13 + (p-ident @1.1-1.5 (raw "name")) + (e-string @1.8-1.13 + (e-string-part @1.9-1.12 (raw "luc")))) + (s-decl @2.1-2.22 + (p-ident @2.1-2.4 (raw "foo")) + (e-string @2.7-2.22 + (e-string-part @2.8-2.14 (raw "hello ")) + (e-ident @2.16-2.20 (raw "name")) + (e-string-part @2.21-2.21 (raw "")))))) ~~~ # FORMATTED ~~~roc @@ -47,24 +42,24 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @2.1-2.5 (ident "name")) - (e-string @2.8-2.13 - (e-literal @2.9-2.12 (string "luc")))) + (p-assign @1.1-1.5 (ident "name")) + (e-string @1.8-1.13 + (e-literal @1.9-1.12 (string "luc")))) (d-let - (p-assign @3.1-3.4 (ident "foo")) - (e-string @3.7-3.22 - (e-literal @3.8-3.14 (string "hello ")) - (e-lookup-local @3.16-3.20 - (p-assign @2.1-2.5 (ident "name"))) - (e-literal @3.21-3.21 (string ""))))) + (p-assign @2.1-2.4 (ident "foo")) + (e-string @2.7-2.22 + (e-literal @2.8-2.14 (string "hello ")) + (e-lookup-local @2.16-2.20 + (p-assign @1.1-1.5 (ident "name"))) + (e-literal @2.21-2.21 (string ""))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @2.1-2.5 (type "Str")) - (patt @3.1-3.4 (type "Str"))) + (patt @1.1-1.5 (type "Str")) + (patt @2.1-2.4 (type "Str"))) (expressions - (expr @2.8-2.13 (type "Str")) - (expr @3.7-3.22 (type "Str")))) + (expr @1.8-1.13 (type "Str")) + (expr @2.7-2.22 (type "Str")))) ~~~ diff --git a/test/snapshots/primitive/expr_tag.md b/test/snapshots/primitive/expr_tag.md index 96c2c32faa..8dab92d185 100644 --- a/test/snapshots/primitive/expr_tag.md +++ b/test/snapshots/primitive/expr_tag.md @@ -1,11 +1,10 @@ # META ~~~ini description=A primitive -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [foo] foo = FortyTwo ~~~ # EXPECTED @@ -14,21 +13,17 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:12),CloseSquare(1:12-1:13), -LowerIdent(2:1-2:4),OpAssign(2:5-2:6),UpperIdent(2:7-2:15), -EndOfFile(3:1-3:1), +LowerIdent(1:1-1:4),OpAssign(1:5-1:6),UpperIdent(1:7-1:15), +EndOfFile(2:1-2:1), ~~~ # PARSE ~~~clojure -(file @1.1-2.15 - (module @1.1-1.13 - (exposes @1.8-1.13 - (exposed-lower-ident @1.9-1.12 - (text "foo")))) +(file @1.1-1.15 + (type-module @1.1-1.4) (statements - (s-decl @2.1-2.15 - (p-ident @2.1-2.4 (raw "foo")) - (e-tag @2.7-2.15 (raw "FortyTwo"))))) + (s-decl @1.1-1.15 + (p-ident @1.1-1.4 (raw "foo")) + (e-tag @1.7-1.15 (raw "FortyTwo"))))) ~~~ # FORMATTED ~~~roc @@ -38,14 +33,14 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @2.1-2.4 (ident "foo")) - (e-tag @2.7-2.15 (name "FortyTwo")))) + (p-assign @1.1-1.4 (ident "foo")) + (e-tag @1.7-1.15 (name "FortyTwo")))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @2.1-2.4 (type "[FortyTwo]_others"))) + (patt @1.1-1.4 (type "[FortyTwo]_others"))) (expressions - (expr @2.7-2.15 (type "[FortyTwo]_others")))) + (expr @1.7-1.15 (type "[FortyTwo]_others")))) ~~~ diff --git a/test/snapshots/primitive/stmt_import.md b/test/snapshots/primitive/stmt_import.md index 134e0c787b..1b21ba6f2b 100644 --- a/test/snapshots/primitive/stmt_import.md +++ b/test/snapshots/primitive/stmt_import.md @@ -1,26 +1,24 @@ # META ~~~ini description=A primitive -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - import json.Json [foo, BAR] ~~~ # EXPECTED -PARSE ERROR - stmt_import.md:3:18:3:19 -PARSE ERROR - stmt_import.md:3:19:3:22 -PARSE ERROR - stmt_import.md:3:22:3:23 -PARSE ERROR - stmt_import.md:3:27:3:28 -MODULE NOT FOUND - stmt_import.md:3:1:3:17 +PARSE ERROR - stmt_import.md:1:18:1:19 +PARSE ERROR - stmt_import.md:1:19:1:22 +PARSE ERROR - stmt_import.md:1:22:1:23 +PARSE ERROR - stmt_import.md:1:27:1:28 +MODULE NOT FOUND - stmt_import.md:1:1:1:17 # PROBLEMS **PARSE ERROR** A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**stmt_import.md:3:18:3:19:** +**stmt_import.md:1:18:1:19:** ```roc import json.Json [foo, BAR] ``` @@ -31,7 +29,7 @@ import json.Json [foo, BAR] A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**stmt_import.md:3:19:3:22:** +**stmt_import.md:1:19:1:22:** ```roc import json.Json [foo, BAR] ``` @@ -42,7 +40,7 @@ import json.Json [foo, BAR] A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**stmt_import.md:3:22:3:23:** +**stmt_import.md:1:22:1:23:** ```roc import json.Json [foo, BAR] ``` @@ -65,7 +63,7 @@ Other valid examples: `Result(a, Str)` `Maybe(List(U64))` -**stmt_import.md:3:27:3:28:** +**stmt_import.md:1:27:1:28:** ```roc import json.Json [foo, BAR] ``` @@ -76,7 +74,7 @@ import json.Json [foo, BAR] The module `json.Json` was not found in this Roc project. You're attempting to use this module here: -**stmt_import.md:3:1:3:17:** +**stmt_import.md:1:1:1:17:** ```roc import json.Json [foo, BAR] ``` @@ -85,32 +83,28 @@ import json.Json [foo, BAR] # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -KwImport(3:1-3:7),LowerIdent(3:8-3:12),NoSpaceDotUpperIdent(3:12-3:17),OpenSquare(3:18-3:19),LowerIdent(3:19-3:22),Comma(3:22-3:23),UpperIdent(3:24-3:27),CloseSquare(3:27-3:28), -EndOfFile(4:1-4:1), +KwImport(1:1-1:7),LowerIdent(1:8-1:12),NoSpaceDotUpperIdent(1:12-1:17),OpenSquare(1:18-1:19),LowerIdent(1:19-1:22),Comma(1:22-1:23),UpperIdent(1:24-1:27),CloseSquare(1:27-1:28), +EndOfFile(2:1-2:1), ~~~ # PARSE ~~~clojure -(file @1.1-3.28 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-1.28 + (type-module @1.1-1.7) (statements - (s-import @3.1-3.17 (raw "json.Json")) - (s-malformed @3.18-3.19 (tag "statement_unexpected_token")) - (s-malformed @3.19-3.22 (tag "statement_unexpected_token")) - (s-malformed @3.22-3.23 (tag "statement_unexpected_token")) - (s-malformed @3.27-3.28 (tag "expected_colon_after_type_annotation")))) + (s-import @1.1-1.17 (raw "json.Json")) + (s-malformed @1.18-1.19 (tag "statement_unexpected_token")) + (s-malformed @1.19-1.22 (tag "statement_unexpected_token")) + (s-malformed @1.22-1.23 (tag "statement_unexpected_token")) + (s-malformed @1.27-1.28 (tag "expected_colon_after_type_annotation")))) ~~~ # FORMATTED ~~~roc -module [] - import json.Json ~~~ # CANONICALIZE ~~~clojure (can-ir - (s-import @3.1-3.17 (module "json.Json") (qualifier "json") + (s-import @1.1-1.17 (module "json.Json") (qualifier "json") (exposes))) ~~~ # TYPES diff --git a/test/snapshots/primitive/stmt_type_decl.md b/test/snapshots/primitive/stmt_type_decl.md index 2f4513e8bb..48527ba422 100644 --- a/test/snapshots/primitive/stmt_type_decl.md +++ b/test/snapshots/primitive/stmt_type_decl.md @@ -1,12 +1,10 @@ # META ~~~ini description=A primitive -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [Foo] - Foo(a,b) : (a,b,Str,U64) ~~~ # EXPECTED @@ -15,57 +13,52 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:12),CloseSquare(1:12-1:13), -UpperIdent(3:1-3:4),NoSpaceOpenRound(3:4-3:5),LowerIdent(3:5-3:6),Comma(3:6-3:7),LowerIdent(3:7-3:8),CloseRound(3:8-3:9),OpColon(3:10-3:11),OpenRound(3:12-3:13),LowerIdent(3:13-3:14),Comma(3:14-3:15),LowerIdent(3:15-3:16),Comma(3:16-3:17),UpperIdent(3:17-3:20),Comma(3:20-3:21),UpperIdent(3:21-3:24),CloseRound(3:24-3:25), -EndOfFile(4:1-4:1), +UpperIdent(1:1-1:4),NoSpaceOpenRound(1:4-1:5),LowerIdent(1:5-1:6),Comma(1:6-1:7),LowerIdent(1:7-1:8),CloseRound(1:8-1:9),OpColon(1:10-1:11),OpenRound(1:12-1:13),LowerIdent(1:13-1:14),Comma(1:14-1:15),LowerIdent(1:15-1:16),Comma(1:16-1:17),UpperIdent(1:17-1:20),Comma(1:20-1:21),UpperIdent(1:21-1:24),CloseRound(1:24-1:25), +EndOfFile(2:1-2:1), ~~~ # PARSE ~~~clojure -(file @1.1-3.25 - (module @1.1-1.13 - (exposes @1.8-1.13 - (exposed-upper-ident @1.9-1.12 (text "Foo")))) +(file @1.1-1.25 + (type-module @1.1-1.4) (statements - (s-type-decl @3.1-3.25 - (header @3.1-3.9 (name "Foo") + (s-type-decl @1.1-1.25 + (header @1.1-1.9 (name "Foo") (args - (ty-var @3.5-3.6 (raw "a")) - (ty-var @3.7-3.8 (raw "b")))) - (ty-tuple @3.12-3.25 - (ty-var @3.13-3.14 (raw "a")) - (ty-var @3.15-3.16 (raw "b")) - (ty @3.17-3.20 (name "Str")) - (ty @3.21-3.24 (name "U64")))))) + (ty-var @1.5-1.6 (raw "a")) + (ty-var @1.7-1.8 (raw "b")))) + (ty-tuple @1.12-1.25 + (ty-var @1.13-1.14 (raw "a")) + (ty-var @1.15-1.16 (raw "b")) + (ty @1.17-1.20 (name "Str")) + (ty @1.21-1.24 (name "U64")))))) ~~~ # FORMATTED ~~~roc -module [Foo] - Foo(a, b) : (a, b, Str, U64) ~~~ # CANONICALIZE ~~~clojure (can-ir - (s-alias-decl @3.1-3.25 - (ty-header @3.1-3.9 (name "Foo") + (s-alias-decl @1.1-1.25 + (ty-header @1.1-1.9 (name "Foo") (ty-args - (ty-var @3.5-3.6 (name "a")) - (ty-var @3.7-3.8 (name "b")))) - (ty-tuple @3.12-3.25 - (ty-var @3.13-3.14 (name "a")) - (ty-var @3.15-3.16 (name "b")) - (ty @3.17-3.20 (name "Str")) - (ty @3.21-3.24 (name "U64"))))) + (ty-rigid-var @1.5-1.6 (name "a")) + (ty-rigid-var @1.7-1.8 (name "b")))) + (ty-tuple @1.12-1.25 + (ty-rigid-var-lookup (ty-rigid-var @1.5-1.6 (name "a"))) + (ty-rigid-var-lookup (ty-rigid-var @1.7-1.8 (name "b"))) + (ty-lookup @1.17-1.20 (name "Str") (builtin)) + (ty-lookup @1.21-1.24 (name "U64") (builtin))))) ~~~ # TYPES ~~~clojure (inferred-types (defs) (type_decls - (alias @3.1-3.25 (type "Foo(a, b)") - (ty-header @3.1-3.9 (name "Foo") + (alias @1.1-1.25 (type "Foo(a, b)") + (ty-header @1.1-1.9 (name "Foo") (ty-args - (ty-var @3.5-3.6 (name "a")) - (ty-var @3.7-3.8 (name "b")))))) + (ty-rigid-var @1.5-1.6 (name "a")) + (ty-rigid-var @1.7-1.8 (name "b")))))) (expressions)) ~~~ diff --git a/test/snapshots/pure_annotation_effectful_body_error.md b/test/snapshots/pure_annotation_effectful_body_error.md index 84653b1b84..82e31cf762 100644 --- a/test/snapshots/pure_annotation_effectful_body_error.md +++ b/test/snapshots/pure_annotation_effectful_body_error.md @@ -87,14 +87,14 @@ NO CHANGE (p-assign @7.17-7.20 (ident "msg"))) (e-call @7.22-7.39 (e-lookup-external @7.22-7.34 - (module-idx "0") + (module-idx "2") (target-node-idx "0")) (e-lookup-local @7.35-7.38 (p-assign @7.17-7.20 (ident "msg"))))) (annotation @7.1-7.13 (declared-type (ty-fn @6.16-6.25 (effectful false) - (ty @6.16-6.19 (name "Str")) + (ty-lookup @6.16-6.19 (name "Str") (builtin)) (ty-record @6.23-6.25))))) (d-let (p-assign @9.1-9.6 (ident "main!")) diff --git a/test/snapshots/pure_with_pure_annotation.md b/test/snapshots/pure_with_pure_annotation.md index 13d1163419..d3959b5d09 100644 --- a/test/snapshots/pure_with_pure_annotation.md +++ b/test/snapshots/pure_with_pure_annotation.md @@ -110,9 +110,9 @@ NO CHANGE (annotation @5.1-5.4 (declared-type (ty-fn @4.7-4.22 (effectful false) - (ty @4.7-4.10 (name "I32")) - (ty @4.12-4.15 (name "I32")) - (ty @4.19-4.22 (name "I32")))))) + (ty-lookup @4.7-4.10 (name "I32") (builtin)) + (ty-lookup @4.12-4.15 (name "I32") (builtin)) + (ty-lookup @4.19-4.22 (name "I32") (builtin)))))) (d-let (p-assign @9.1-9.7 (ident "double")) (e-closure @9.10-9.23 @@ -131,25 +131,25 @@ NO CHANGE (annotation @9.1-9.7 (declared-type (ty-fn @8.10-8.20 (effectful false) - (ty @8.10-8.13 (name "I32")) - (ty @8.17-8.20 (name "I32")))))) + (ty-lookup @8.10-8.13 (name "I32") (builtin)) + (ty-lookup @8.17-8.20 (name "I32") (builtin)))))) (d-let (p-assign @11.1-11.6 (ident "main!")) (e-call @11.9-11.18 (e-lookup-local @11.9-11.12 (p-assign @5.1-5.4 (ident "add"))) - (e-int @11.13-11.14 (value "1")) - (e-int @11.16-11.17 (value "2"))))) + (e-num @11.13-11.14 (value "1")) + (e-num @11.16-11.17 (value "2"))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @5.1-5.4 (type "I32, I32 -> I32")) - (patt @9.1-9.7 (type "I32 -> I32")) - (patt @11.1-11.6 (type "I32"))) + (patt @5.1-5.4 (type "Num(Int(Signed32)), Num(Int(Signed32)) -> Num(Int(Signed32))")) + (patt @9.1-9.7 (type "Num(Int(Signed32)) -> Num(Int(Signed32))")) + (patt @11.1-11.6 (type "Num(Int(Signed32))"))) (expressions - (expr @5.7-5.30 (type "I32, I32 -> I32")) - (expr @9.10-9.23 (type "I32 -> I32")) - (expr @11.9-11.18 (type "I32")))) + (expr @5.7-5.30 (type "Num(Int(Signed32)), Num(Int(Signed32)) -> Num(Int(Signed32))")) + (expr @9.10-9.23 (type "Num(Int(Signed32)) -> Num(Int(Signed32))")) + (expr @11.9-11.18 (type "Num(Int(Signed32))")))) ~~~ diff --git a/test/snapshots/qualified_tag.md b/test/snapshots/qualified_tag.md index 3cc9cc2405..a7864979c6 100644 --- a/test/snapshots/qualified_tag.md +++ b/test/snapshots/qualified_tag.md @@ -1,12 +1,10 @@ # META ~~~ini description=Simple qualified tag test -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [Color] - Color := [Red, Blue] test = Color.Red @@ -17,28 +15,25 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:14),CloseSquare(1:14-1:15), -UpperIdent(3:1-3:6),OpColonEqual(3:7-3:9),OpenSquare(3:10-3:11),UpperIdent(3:11-3:14),Comma(3:14-3:15),UpperIdent(3:16-3:20),CloseSquare(3:20-3:21), -LowerIdent(5:1-5:5),OpAssign(5:6-5:7),UpperIdent(5:8-5:13),NoSpaceDotUpperIdent(5:13-5:17), -EndOfFile(6:1-6:1), +UpperIdent(1:1-1:6),OpColonEqual(1:7-1:9),OpenSquare(1:10-1:11),UpperIdent(1:11-1:14),Comma(1:14-1:15),UpperIdent(1:16-1:20),CloseSquare(1:20-1:21), +LowerIdent(3:1-3:5),OpAssign(3:6-3:7),UpperIdent(3:8-3:13),NoSpaceDotUpperIdent(3:13-3:17), +EndOfFile(4:1-4:1), ~~~ # PARSE ~~~clojure -(file @1.1-5.17 - (module @1.1-1.15 - (exposes @1.8-1.15 - (exposed-upper-ident @1.9-1.14 (text "Color")))) +(file @1.1-3.17 + (type-module @1.1-1.6) (statements - (s-type-decl @3.1-3.21 - (header @3.1-3.6 (name "Color") + (s-type-decl @1.1-1.21 + (header @1.1-1.6 (name "Color") (args)) - (ty-tag-union @3.10-3.21 + (ty-tag-union @1.10-1.21 (tags - (ty @3.11-3.14 (name "Red")) - (ty @3.16-3.20 (name "Blue"))))) - (s-decl @5.1-5.17 - (p-ident @5.1-5.5 (raw "test")) - (e-tag @5.8-5.17 (raw "Color.Red"))))) + (ty @1.11-1.14 (name "Red")) + (ty @1.16-1.20 (name "Blue"))))) + (s-decl @3.1-3.17 + (p-ident @3.1-3.5 (raw "test")) + (e-tag @3.8-3.17 (raw "Color.Red"))))) ~~~ # FORMATTED ~~~roc @@ -48,23 +43,23 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @5.1-5.5 (ident "test")) - (e-nominal @5.8-5.17 (nominal "Color") - (e-tag @5.8-5.17 (name "Red")))) - (s-nominal-decl @3.1-3.21 - (ty-header @3.1-3.6 (name "Color")) - (ty-tag-union @3.10-3.21 - (ty @3.11-3.14 (name "Red")) - (ty @3.16-3.20 (name "Blue"))))) + (p-assign @3.1-3.5 (ident "test")) + (e-nominal @3.8-3.17 (nominal "Color") + (e-tag @3.8-3.17 (name "Red")))) + (s-nominal-decl @1.1-1.21 + (ty-header @1.1-1.6 (name "Color")) + (ty-tag-union @1.10-1.21 + (ty-tag-name @1.11-1.14 (name "Red")) + (ty-tag-name @1.16-1.20 (name "Blue"))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @5.1-5.5 (type "Color"))) + (patt @3.1-3.5 (type "Color"))) (type_decls - (nominal @3.1-3.21 (type "Color") - (ty-header @3.1-3.6 (name "Color")))) + (nominal @1.1-1.21 (type "Color") + (ty-header @1.1-1.6 (name "Color")))) (expressions - (expr @5.8-5.17 (type "Color")))) + (expr @3.8-3.17 (type "Color")))) ~~~ diff --git a/test/snapshots/qualified_type_canonicalization.md b/test/snapshots/qualified_type_canonicalization.md index 516888f5c7..47ea61461a 100644 --- a/test/snapshots/qualified_type_canonicalization.md +++ b/test/snapshots/qualified_type_canonicalization.md @@ -207,28 +207,7 @@ simpleQualified = Color.RGB({ r: 255, g: 0, b: 0 }) **MODULE NOT IMPORTED** -There is no module with the name `module [ - Color, - ModuleA.ModuleB.TypeC, - Result, - ExternalModule, -] - -import Basics.Result -import Color -import ModuleA.ModuleB exposing [TypeC] -import ExternalModule as ExtMod - -# Simple qualified type -simpleQualified : Color.RGB -simpleQualified = Color.RGB({ r: 255, g: 0, b: 0 }) - -# Aliased qualified type -aliasedQualified : ExtMod.DataType -aliasedQualified = ExtMod.DataType.Default - -# Multi-level qualified type -multiLevelQualified : ModuleA.ModuleB` imported into this Roc file. +There is no module with the name `ModuleA.ModuleB` imported into this Roc file. You're attempting to use this module here: **qualified_type_canonicalization.md:22:23:22:44:** @@ -295,45 +274,7 @@ transform : Result.Result(Color.RGB, ExtMod.Error) -> ModuleA.ModuleB.TypeC **MODULE NOT IMPORTED** -There is no module with the name `module [ - Color, - ModuleA.ModuleB.TypeC, - Result, - ExternalModule, -] - -import Basics.Result -import Color -import ModuleA.ModuleB exposing [TypeC] -import ExternalModule as ExtMod - -# Simple qualified type -simpleQualified : Color.RGB -simpleQualified = Color.RGB({ r: 255, g: 0, b: 0 }) - -# Aliased qualified type -aliasedQualified : ExtMod.DataType -aliasedQualified = ExtMod.DataType.Default - -# Multi-level qualified type -multiLevelQualified : ModuleA.ModuleB.TypeC -multiLevelQualified = TypeC.new - -# Using qualified type with generics -resultType : Result.Result(I32, Str) -resultType = Result.Ok(42) - -# Function returning qualified type -getColor : {} -> Color.RGB -getColor = |_| Color.RGB({ r: 0, g: 255, b: 0 }) - -# Function accepting qualified type -processColor : Color.RGB -> Str -processColor = |color| - "Color processed" - -# Multiple qualified types in a function signature -transform : Result.Result(Color.RGB, ExtMod.Error) -> ModuleA.ModuleB` imported into this Roc file. +There is no module with the name `ModuleA.ModuleB` imported into this Roc file. You're attempting to use this module here: **qualified_type_canonicalization.md:39:55:39:76:** @@ -562,20 +503,16 @@ transform = |result| (e-runtime-error (tag "undeclared_type")) (annotation @15.1-15.16 (declared-type - (ty-lookup-external @14.19-14.28 - (module-idx "0") - (target-node-idx "0"))))) + (ty-lookup @14.19-14.28 (name "RGB") (external (module-idx "2") (target-node-idx "0")))))) (d-let (p-assign @19.1-19.17 (ident "aliasedQualified")) (e-nominal-external @19.20-19.43 - (module-idx "2") + (module-idx "4") (target-node-idx "0") (e-tag @19.20-19.43 (name "Default"))) (annotation @19.1-19.17 (declared-type - (ty-lookup-external @18.20-18.35 - (module-idx "2") - (target-node-idx "0"))))) + (ty-lookup @18.20-18.35 (name "DataType") (external (module-idx "4") (target-node-idx "0")))))) (d-let (p-assign @23.1-23.20 (ident "multiLevelQualified")) (e-runtime-error (tag "ident_not_in_scope")) @@ -587,7 +524,7 @@ transform = |result| (e-nominal @27.14-27.27 (nominal "Result") (e-tag @27.14-27.27 (name "Ok") (args - (e-int @27.24-27.26 (value "42"))))) + (e-num @27.24-27.26 (value "42"))))) (annotation @27.1-27.11 (declared-type (ty-malformed @26.14-26.27)))) @@ -601,9 +538,7 @@ transform = |result| (declared-type (ty-fn @30.12-30.27 (effectful false) (ty-record @30.12-30.14) - (ty-lookup-external @30.18-30.27 - (module-idx "0") - (target-node-idx "0")))))) + (ty-lookup @30.18-30.27 (name "RGB") (external (module-idx "2") (target-node-idx "0"))))))) (d-let (p-assign @35.1-35.13 (ident "processColor")) (e-lambda @35.16-36.22 @@ -614,10 +549,8 @@ transform = |result| (annotation @35.1-35.13 (declared-type (ty-fn @34.16-34.32 (effectful false) - (ty-lookup-external @34.16-34.25 - (module-idx "0") - (target-node-idx "0")) - (ty @34.29-34.32 (name "Str")))))) + (ty-lookup @34.16-34.25 (name "RGB") (external (module-idx "2") (target-node-idx "0"))) + (ty-lookup @34.29-34.32 (name "Str") (builtin)))))) (d-let (p-assign @40.1-40.10 (ident "transform")) (e-closure @40.13-44.6 diff --git a/test/snapshots/qualified_with_anno.md b/test/snapshots/qualified_with_anno.md index c29ec4031e..8b3cb6e260 100644 --- a/test/snapshots/qualified_with_anno.md +++ b/test/snapshots/qualified_with_anno.md @@ -1,12 +1,10 @@ # META ~~~ini description=Test qualified tag with type annotation -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [value] - MyType := [TagA, TagB] value : MyType @@ -18,32 +16,28 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:14),CloseSquare(1:14-1:15), -UpperIdent(3:1-3:7),OpColonEqual(3:8-3:10),OpenSquare(3:11-3:12),UpperIdent(3:12-3:16),Comma(3:16-3:17),UpperIdent(3:18-3:22),CloseSquare(3:22-3:23), -LowerIdent(5:1-5:6),OpColon(5:7-5:8),UpperIdent(5:9-5:15), -LowerIdent(6:1-6:6),OpAssign(6:7-6:8),UpperIdent(6:9-6:15),NoSpaceDotUpperIdent(6:15-6:20), -EndOfFile(7:1-7:1), +UpperIdent(1:1-1:7),OpColonEqual(1:8-1:10),OpenSquare(1:11-1:12),UpperIdent(1:12-1:16),Comma(1:16-1:17),UpperIdent(1:18-1:22),CloseSquare(1:22-1:23), +LowerIdent(3:1-3:6),OpColon(3:7-3:8),UpperIdent(3:9-3:15), +LowerIdent(4:1-4:6),OpAssign(4:7-4:8),UpperIdent(4:9-4:15),NoSpaceDotUpperIdent(4:15-4:20), +EndOfFile(5:1-5:1), ~~~ # PARSE ~~~clojure -(file @1.1-6.20 - (module @1.1-1.15 - (exposes @1.8-1.15 - (exposed-lower-ident @1.9-1.14 - (text "value")))) +(file @1.1-4.20 + (type-module @1.1-1.7) (statements - (s-type-decl @3.1-3.23 - (header @3.1-3.7 (name "MyType") + (s-type-decl @1.1-1.23 + (header @1.1-1.7 (name "MyType") (args)) - (ty-tag-union @3.11-3.23 + (ty-tag-union @1.11-1.23 (tags - (ty @3.12-3.16 (name "TagA")) - (ty @3.18-3.22 (name "TagB"))))) - (s-type-anno @5.1-5.15 (name "value") - (ty @5.9-5.15 (name "MyType"))) - (s-decl @6.1-6.20 - (p-ident @6.1-6.6 (raw "value")) - (e-tag @6.9-6.20 (raw "MyType.TagA"))))) + (ty @1.12-1.16 (name "TagA")) + (ty @1.18-1.22 (name "TagB"))))) + (s-type-anno @3.1-3.15 (name "value") + (ty @3.9-3.15 (name "MyType"))) + (s-decl @4.1-4.20 + (p-ident @4.1-4.6 (raw "value")) + (e-tag @4.9-4.20 (raw "MyType.TagA"))))) ~~~ # FORMATTED ~~~roc @@ -53,26 +47,26 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @6.1-6.6 (ident "value")) - (e-nominal @6.9-6.20 (nominal "MyType") - (e-tag @6.9-6.20 (name "TagA"))) - (annotation @6.1-6.6 + (p-assign @4.1-4.6 (ident "value")) + (e-nominal @4.9-4.20 (nominal "MyType") + (e-tag @4.9-4.20 (name "TagA"))) + (annotation @4.1-4.6 (declared-type - (ty @5.9-5.15 (name "MyType"))))) - (s-nominal-decl @3.1-3.23 - (ty-header @3.1-3.7 (name "MyType")) - (ty-tag-union @3.11-3.23 - (ty @3.12-3.16 (name "TagA")) - (ty @3.18-3.22 (name "TagB"))))) + (ty-lookup @3.9-3.15 (name "MyType") (local))))) + (s-nominal-decl @1.1-1.23 + (ty-header @1.1-1.7 (name "MyType")) + (ty-tag-union @1.11-1.23 + (ty-tag-name @1.12-1.16 (name "TagA")) + (ty-tag-name @1.18-1.22 (name "TagB"))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @6.1-6.6 (type "MyType"))) + (patt @4.1-4.6 (type "MyType"))) (type_decls - (nominal @3.1-3.23 (type "MyType") - (ty-header @3.1-3.7 (name "MyType")))) + (nominal @1.1-1.23 (type "MyType") + (ty-header @1.1-1.7 (name "MyType")))) (expressions - (expr @6.9-6.20 (type "MyType")))) + (expr @4.9-4.20 (type "MyType")))) ~~~ diff --git a/test/snapshots/records/error_duplicate_fields.md b/test/snapshots/records/error_duplicate_fields.md index 36adab3be1..bf256e28a6 100644 --- a/test/snapshots/records/error_duplicate_fields.md +++ b/test/snapshots/records/error_duplicate_fields.md @@ -83,12 +83,12 @@ NO CHANGE (e-string @1.9-1.16 (e-literal @1.10-1.15 (string "Alice")))) (field (name "age") - (e-int @1.23-1.25 (value "30"))) + (e-num @1.23-1.25 (value "30"))) (field (name "email") (e-string @1.47-1.66 (e-literal @1.48-1.65 (string "alice@example.com")))))) ~~~ # TYPES ~~~clojure -(expr @1.1-1.77 (type "{ name: Str, age: Num(_size), email: Str }")) +(expr @1.1-1.77 (type "{ age: Num(_size), email: Str, name: Str }")) ~~~ diff --git a/test/snapshots/records/error_malformed_syntax_2.md b/test/snapshots/records/error_malformed_syntax_2.md index 9b1870bc2e..931e7f4421 100644 --- a/test/snapshots/records/error_malformed_syntax_2.md +++ b/test/snapshots/records/error_malformed_syntax_2.md @@ -96,8 +96,6 @@ EndOfFile(2:1-2:1), # CANONICALIZE ~~~clojure (e-block @1.1-1.28 - (s-type-anno @1.3-1.10 (name "age") - (ty-malformed @1.8-1.10)) (s-expr @1.10-1.11 (e-runtime-error (tag "expr_not_canonicalized"))) (s-let @1.12-1.26 diff --git a/test/snapshots/records/function_record_parameter.md b/test/snapshots/records/function_record_parameter.md index eaec656ea0..ba1f791ff6 100644 --- a/test/snapshots/records/function_record_parameter.md +++ b/test/snapshots/records/function_record_parameter.md @@ -63,5 +63,5 @@ NO CHANGE ~~~ # TYPES ~~~clojure -(expr @1.1-1.67 (type "_arg -> Str")) +(expr @1.1-1.67 (type "{ age: _field, name: _field2 } -> Str")) ~~~ diff --git a/test/snapshots/records/function_record_parameter_capture.md b/test/snapshots/records/function_record_parameter_capture.md index 2b75476c54..eedc6c95a5 100644 --- a/test/snapshots/records/function_record_parameter_capture.md +++ b/test/snapshots/records/function_record_parameter_capture.md @@ -95,9 +95,9 @@ NO CHANGE (e-binop @1.92-1.101 (op "ge") (e-lookup-local @1.92-1.95 (p-assign @1.10-1.13 (ident "age"))) - (e-int @1.99-1.101 (value "18"))))))) + (e-num @1.99-1.101 (value "18"))))))) ~~~ # TYPES ~~~clojure -(expr @1.1-1.103 (type "_arg -> { greeting: Str, full_record: _field, is_adult: Bool }")) +(expr @1.1-1.103 (type "Error -> { full_record: Error, greeting: Str, is_adult: Bool }")) ~~~ diff --git a/test/snapshots/records/function_record_parameter_rest.md b/test/snapshots/records/function_record_parameter_rest.md index 1f788c7528..0ae4cf5f74 100644 --- a/test/snapshots/records/function_record_parameter_rest.md +++ b/test/snapshots/records/function_record_parameter_rest.md @@ -61,5 +61,5 @@ NO CHANGE ~~~ # TYPES ~~~clojure -(expr @1.1-1.65 (type "_arg -> Str")) +(expr @1.1-1.65 (type "{ first_name: _field, rest: { last_name: _field2 } } -> Str")) ~~~ diff --git a/test/snapshots/records/module_record_destructure.md b/test/snapshots/records/module_record_destructure.md index 71f6905347..fd78ac2545 100644 --- a/test/snapshots/records/module_record_destructure.md +++ b/test/snapshots/records/module_record_destructure.md @@ -1,12 +1,10 @@ # META ~~~ini description=Record destructuring in assignment statement -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [extract_age] - extract_age : { age : U64 } -> U64 extract_age = |person| { { age } = person @@ -20,57 +18,51 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:20),CloseSquare(1:20-1:21), -LowerIdent(3:1-3:12),OpColon(3:13-3:14),OpenCurly(3:15-3:16),LowerIdent(3:17-3:20),OpColon(3:21-3:22),UpperIdent(3:23-3:26),CloseCurly(3:27-3:28),OpArrow(3:29-3:31),UpperIdent(3:32-3:35), -LowerIdent(4:1-4:12),OpAssign(4:13-4:14),OpBar(4:15-4:16),LowerIdent(4:16-4:22),OpBar(4:22-4:23),OpenCurly(4:24-4:25), -OpenCurly(5:5-5:6),LowerIdent(5:7-5:10),CloseCurly(5:11-5:12),OpAssign(5:13-5:14),LowerIdent(5:15-5:21), -OpenCurly(7:2-7:3),LowerIdent(7:4-7:5),OpColon(7:5-7:6),Int(7:7-7:8),CloseCurly(7:9-7:10),NoSpaceDotLowerIdent(7:10-7:12),OpPlus(7:13-7:14),LowerIdent(7:15-7:18),OpBinaryMinus(7:19-7:20),OpenCurly(7:21-7:22),LowerIdent(7:23-7:24),OpColon(7:24-7:25),Int(7:26-7:27),CloseCurly(7:28-7:29),NoSpaceDotLowerIdent(7:29-7:31), -CloseCurly(8:1-8:2), -EndOfFile(9:1-9:1), +LowerIdent(1:1-1:12),OpColon(1:13-1:14),OpenCurly(1:15-1:16),LowerIdent(1:17-1:20),OpColon(1:21-1:22),UpperIdent(1:23-1:26),CloseCurly(1:27-1:28),OpArrow(1:29-1:31),UpperIdent(1:32-1:35), +LowerIdent(2:1-2:12),OpAssign(2:13-2:14),OpBar(2:15-2:16),LowerIdent(2:16-2:22),OpBar(2:22-2:23),OpenCurly(2:24-2:25), +OpenCurly(3:5-3:6),LowerIdent(3:7-3:10),CloseCurly(3:11-3:12),OpAssign(3:13-3:14),LowerIdent(3:15-3:21), +OpenCurly(5:2-5:3),LowerIdent(5:4-5:5),OpColon(5:5-5:6),Int(5:7-5:8),CloseCurly(5:9-5:10),NoSpaceDotLowerIdent(5:10-5:12),OpPlus(5:13-5:14),LowerIdent(5:15-5:18),OpBinaryMinus(5:19-5:20),OpenCurly(5:21-5:22),LowerIdent(5:23-5:24),OpColon(5:24-5:25),Int(5:26-5:27),CloseCurly(5:28-5:29),NoSpaceDotLowerIdent(5:29-5:31), +CloseCurly(6:1-6:2), +EndOfFile(7:1-7:1), ~~~ # PARSE ~~~clojure -(file @1.1-8.2 - (module @1.1-1.21 - (exposes @1.8-1.21 - (exposed-lower-ident @1.9-1.20 - (text "extract_age")))) +(file @1.1-6.2 + (type-module @1.1-1.12) (statements - (s-type-anno @3.1-3.35 (name "extract_age") - (ty-fn @3.15-3.35 - (ty-record @3.15-3.28 - (anno-record-field @3.17-3.26 (name "age") - (ty @3.23-3.26 (name "U64")))) - (ty @3.32-3.35 (name "U64")))) - (s-decl @4.1-8.2 - (p-ident @4.1-4.12 (raw "extract_age")) - (e-lambda @4.15-8.2 + (s-type-anno @1.1-1.35 (name "extract_age") + (ty-fn @1.15-1.35 + (ty-record @1.15-1.28 + (anno-record-field @1.17-1.26 (name "age") + (ty @1.23-1.26 (name "U64")))) + (ty @1.32-1.35 (name "U64")))) + (s-decl @2.1-6.2 + (p-ident @2.1-2.12 (raw "extract_age")) + (e-lambda @2.15-6.2 (args - (p-ident @4.16-4.22 (raw "person"))) - (e-block @4.24-8.2 + (p-ident @2.16-2.22 (raw "person"))) + (e-block @2.24-6.2 (statements - (s-decl @5.5-5.21 - (p-record @5.5-5.12 - (field @5.7-5.10 (name "age") (rest false))) - (e-ident @5.15-5.21 (raw "person"))) - (e-binop @7.2-7.31 (op "-") - (e-binop @7.2-7.18 (op "+") - (e-field-access @7.2-7.12 - (e-record @7.2-7.10 + (s-decl @3.5-3.21 + (p-record @3.5-3.12 + (field @3.7-3.10 (name "age") (rest false))) + (e-ident @3.15-3.21 (raw "person"))) + (e-binop @5.2-5.31 (op "-") + (e-binop @5.2-5.18 (op "+") + (e-field-access @5.2-5.12 + (e-record @5.2-5.10 (field (field "a") - (e-int @7.7-7.8 (raw "0")))) - (e-ident @7.10-7.12 (raw "a"))) - (e-ident @7.15-7.18 (raw "age"))) - (e-field-access @7.21-7.31 - (e-record @7.21-7.29 + (e-int @5.7-5.8 (raw "0")))) + (e-ident @5.10-5.12 (raw "a"))) + (e-ident @5.15-5.18 (raw "age"))) + (e-field-access @5.21-5.31 + (e-record @5.21-5.29 (field (field "a") - (e-int @7.26-7.27 (raw "0")))) - (e-ident @7.29-7.31 (raw "a")))))))))) + (e-int @5.26-5.27 (raw "0")))) + (e-ident @5.29-5.31 (raw "a")))))))))) ~~~ # FORMATTED ~~~roc -module [extract_age] - extract_age : { age : U64 } -> U64 extract_age = |person| { { age } = person @@ -82,48 +74,48 @@ extract_age = |person| { ~~~clojure (can-ir (d-let - (p-assign @4.1-4.12 (ident "extract_age")) - (e-lambda @4.15-8.2 + (p-assign @2.1-2.12 (ident "extract_age")) + (e-lambda @2.15-6.2 (args - (p-assign @4.16-4.22 (ident "person"))) - (e-block @4.24-8.2 - (s-let @5.5-5.21 - (p-record-destructure @5.5-5.12 + (p-assign @2.16-2.22 (ident "person"))) + (e-block @2.24-6.2 + (s-let @3.5-3.21 + (p-record-destructure @3.5-3.12 (destructs - (record-destruct @5.7-5.10 (label "age") (ident "age") + (record-destruct @3.7-3.10 (label "age") (ident "age") (required - (p-assign @5.7-5.10 (ident "age")))))) - (e-lookup-local @5.15-5.21 - (p-assign @4.16-4.22 (ident "person")))) - (e-binop @7.2-7.31 (op "sub") - (e-binop @7.2-7.18 (op "add") - (e-dot-access @7.2-7.12 (field "a") + (p-assign @3.7-3.10 (ident "age")))))) + (e-lookup-local @3.15-3.21 + (p-assign @2.16-2.22 (ident "person")))) + (e-binop @5.2-5.31 (op "sub") + (e-binop @5.2-5.18 (op "add") + (e-dot-access @5.2-5.12 (field "a") (receiver - (e-record @7.2-7.10 + (e-record @5.2-5.10 (fields (field (name "a") - (e-int @7.7-7.8 (value "0"))))))) - (e-lookup-local @7.15-7.18 - (p-assign @5.7-5.10 (ident "age")))) - (e-dot-access @7.21-7.31 (field "a") + (e-num @5.7-5.8 (value "0"))))))) + (e-lookup-local @5.15-5.18 + (p-assign @3.7-3.10 (ident "age")))) + (e-dot-access @5.21-5.31 (field "a") (receiver - (e-record @7.21-7.29 + (e-record @5.21-5.29 (fields (field (name "a") - (e-int @7.26-7.27 (value "0")))))))))) - (annotation @4.1-4.12 + (e-num @5.26-5.27 (value "0")))))))))) + (annotation @2.1-2.12 (declared-type - (ty-fn @3.15-3.35 (effectful false) - (ty-record @3.15-3.28 + (ty-fn @1.15-1.35 (effectful false) + (ty-record @1.15-1.28 (field (field "age") - (ty @3.23-3.26 (name "U64")))) - (ty @3.32-3.35 (name "U64"))))))) + (ty-lookup @1.23-1.26 (name "U64") (builtin)))) + (ty-lookup @1.32-1.35 (name "U64") (builtin))))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @4.1-4.12 (type "{ age: U64 } -> U64"))) + (patt @2.1-2.12 (type "{ age: Num(Int(Unsigned64)) } -> Num(Int(Unsigned64))"))) (expressions - (expr @4.15-8.2 (type "{ age: U64 } -> U64")))) + (expr @2.15-6.2 (type "{ age: Num(Int(Unsigned64)) } -> Num(Int(Unsigned64))")))) ~~~ diff --git a/test/snapshots/records/record_access_function_call.md b/test/snapshots/records/record_access_function_call.md index f052a52e3f..b0d9979516 100644 --- a/test/snapshots/records/record_access_function_call.md +++ b/test/snapshots/records/record_access_function_call.md @@ -45,7 +45,7 @@ NO CHANGE (e-dot-access @1.2-1.18 (field "transform") (receiver (e-runtime-error (tag "ident_not_in_scope")))) - (e-int @1.20-1.22 (value "42"))) + (e-num @1.20-1.22 (value "42"))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/records/record_access_in_expression.md b/test/snapshots/records/record_access_in_expression.md index 100fdcf27d..2c82c8ebe4 100644 --- a/test/snapshots/records/record_access_in_expression.md +++ b/test/snapshots/records/record_access_in_expression.md @@ -44,7 +44,7 @@ NO CHANGE (e-dot-access @1.1-1.11 (field "age") (receiver (e-runtime-error (tag "ident_not_in_scope")))) - (e-int @1.14-1.15 (value "5"))) + (e-num @1.14-1.15 (value "5"))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/records/record_different_fields_error.md b/test/snapshots/records/record_different_fields_error.md index 7f69598c3f..1d6335c151 100644 --- a/test/snapshots/records/record_different_fields_error.md +++ b/test/snapshots/records/record_different_fields_error.md @@ -618,16 +618,12 @@ EndOfFile(9:1-9:1), # CANONICALIZE ~~~clojure (e-block @1.1-8.2 - (s-type-anno @2.5-2.21 (name "_privateField") - (ty-malformed @2.20-2.21)) (s-expr @2.21-2.39 (e-runtime-error (tag "expr_not_canonicalized"))) (s-expr @2.39-2.40 (e-runtime-error (tag "expr_not_canonicalized"))) (s-expr @2.40-2.41 (e-runtime-error (tag "expr_not_canonicalized"))) - (s-type-anno @3.5-3.14 (name "field_") - (ty-malformed @3.13-3.14)) (s-expr @3.14-3.33 (e-runtime-error (tag "expr_not_canonicalized"))) (s-expr @3.33-3.34 @@ -659,8 +655,6 @@ EndOfFile(9:1-9:1), (e-runtime-error (tag "ident_not_in_scope"))) (s-expr @6.10-6.11 (e-runtime-error (tag "expr_not_canonicalized"))) - (s-type-anno @6.11-6.21 (name "special") - (ty-malformed @6.20-6.21)) (s-expr @6.21-6.27 (e-runtime-error (tag "expr_not_canonicalized"))) (s-expr @6.27-6.28 diff --git a/test/snapshots/records/record_different_fields_ok.md b/test/snapshots/records/record_different_fields_ok.md index 4fe37dfb4e..963ec6602e 100644 --- a/test/snapshots/records/record_different_fields_ok.md +++ b/test/snapshots/records/record_different_fields_ok.md @@ -61,5 +61,5 @@ EndOfFile(6:1-6:1), ~~~ # TYPES ~~~clojure -(expr @1.1-5.2 (type "{ field_with_underscores: Str, field123: Str, camelCase: Str }")) +(expr @1.1-5.2 (type "{ camelCase: Str, field123: Str, field_with_underscores: Str }")) ~~~ diff --git a/test/snapshots/records/record_different_fields_reserved_error.md b/test/snapshots/records/record_different_fields_reserved_error.md index 83c6a6337d..ec12c2472e 100644 --- a/test/snapshots/records/record_different_fields_reserved_error.md +++ b/test/snapshots/records/record_different_fields_reserved_error.md @@ -493,8 +493,6 @@ EndOfFile(9:1-9:1), (e-block @1.1-8.2 (s-expr @2.5-2.23 (e-runtime-error (tag "expr_not_canonicalized"))) - (s-type-anno @3.5-3.12 (name "when") - (ty-malformed @3.11-3.12)) (s-expr @3.12-3.25 (e-runtime-error (tag "expr_not_canonicalized"))) (s-expr @3.25-3.26 diff --git a/test/snapshots/records/record_extension_update.md b/test/snapshots/records/record_extension_update.md index c6f644a049..917038780e 100644 --- a/test/snapshots/records/record_extension_update.md +++ b/test/snapshots/records/record_extension_update.md @@ -47,12 +47,12 @@ NO CHANGE (e-runtime-error (tag "ident_not_in_scope"))) (fields (field (name "age") - (e-int @1.18-1.20 (value "31"))) + (e-num @1.18-1.20 (value "31"))) (field (name "active") (e-nominal @1.30-1.34 (nominal "Bool") (e-tag @1.30-1.34 (name "True")))))) ~~~ # TYPES ~~~clojure -(expr @1.1-1.36 (type "{ age: Num(_size), active: Bool }")) +(expr @1.1-1.36 (type "{ active: Bool, age: Num(_size), Error }")) ~~~ diff --git a/test/snapshots/records/record_mixed_field_syntax.md b/test/snapshots/records/record_mixed_field_syntax.md index 283db601ee..5b27c2b6ef 100644 --- a/test/snapshots/records/record_mixed_field_syntax.md +++ b/test/snapshots/records/record_mixed_field_syntax.md @@ -73,7 +73,7 @@ NO CHANGE (field (name "name") (e-runtime-error (tag "ident_not_in_scope"))) (field (name "age") - (e-int @1.14-1.16 (value "30"))) + (e-num @1.14-1.16 (value "30"))) (field (name "email") (e-runtime-error (tag "ident_not_in_scope"))) (field (name "status") @@ -84,5 +84,5 @@ NO CHANGE ~~~ # TYPES ~~~clojure -(expr @1.1-1.52 (type "{ name: Error, age: Num(_size), email: Error, status: Str, balance: Error }")) +(expr @1.1-1.52 (type "{ age: Num(_size), balance: Error, email: Error, name: Error, status: Str }")) ~~~ diff --git a/test/snapshots/records/record_mixed_types.md b/test/snapshots/records/record_mixed_types.md index 8d38256429..373766df3e 100644 --- a/test/snapshots/records/record_mixed_types.md +++ b/test/snapshots/records/record_mixed_types.md @@ -56,19 +56,19 @@ NO CHANGE (e-string @1.9-1.16 (e-literal @1.10-1.15 (string "Alice")))) (field (name "age") - (e-int @1.23-1.25 (value "30"))) + (e-num @1.23-1.25 (value "30"))) (field (name "active") (e-runtime-error (tag "ident_not_in_scope"))) (field (name "scores") (e-list @1.54-1.66 (elems - (e-int @1.55-1.57 (value "95")) - (e-int @1.59-1.61 (value "87")) - (e-int @1.63-1.65 (value "92"))))) + (e-num @1.55-1.57 (value "95")) + (e-num @1.59-1.61 (value "87")) + (e-num @1.63-1.65 (value "92"))))) (field (name "balance") (e-frac-dec @1.77-1.84 (value "1250.75"))))) ~~~ # TYPES ~~~clojure -(expr @1.1-1.86 (type "{ name: Str, age: Num(_size), active: Error, scores: List(Num(_size2)), balance: Frac(_size3) }")) +(expr @1.1-1.86 (type "{ active: Error, age: Num(_size), balance: Num(Frac(_size2)), name: Str, scores: List(Num(_size3)) }")) ~~~ diff --git a/test/snapshots/records/record_nested.md b/test/snapshots/records/record_nested.md index df97d96259..dc7ad326ac 100644 --- a/test/snapshots/records/record_nested.md +++ b/test/snapshots/records/record_nested.md @@ -102,7 +102,7 @@ EndOfFile(13:1-13:1), (e-string @2.21-2.28 (e-literal @2.22-2.27 (string "Alice")))) (field (name "age") - (e-int @2.35-2.37 (value "30")))))) + (e-num @2.35-2.37 (value "30")))))) (field (name "address") (e-record @3.14-7.6 (fields @@ -137,5 +137,5 @@ EndOfFile(13:1-13:1), ~~~ # TYPES ~~~clojure -(expr @1.1-12.2 (type "{ person: { name: Str, age: Num(_size) }, address: { street: Str, city: Str, coordinates: { lat: Frac(_size2), lng: Frac(_size3) } }, contact: { email: Str, phone: { home: Str, work: Str } } }")) +(expr @1.1-12.2 (type "{ address: { city: Str, coordinates: { lat: Num(Frac(_size)), lng: Num(Frac(_size2)) }, street: Str }, contact: { email: Str, phone: { home: Str, work: Str } }, person: { age: Num(_size3), name: Str } }")) ~~~ diff --git a/test/snapshots/records/record_shorthand_fields.md b/test/snapshots/records/record_shorthand_fields.md index 113f50ad70..3c1c61d9f9 100644 --- a/test/snapshots/records/record_shorthand_fields.md +++ b/test/snapshots/records/record_shorthand_fields.md @@ -89,5 +89,5 @@ NO CHANGE ~~~ # TYPES ~~~clojure -(expr @1.1-1.29 (type "{ name: Error, age: Error, email: Error, active: Error }")) +(expr @1.1-1.29 (type "{ active: Error, age: Error, email: Error, name: Error }")) ~~~ diff --git a/test/snapshots/records/record_with_comments.md b/test/snapshots/records/record_with_comments.md index 76c84d7988..27154a0a0f 100644 --- a/test/snapshots/records/record_with_comments.md +++ b/test/snapshots/records/record_with_comments.md @@ -117,7 +117,7 @@ NO CHANGE (e-string @7.18-7.25 (e-literal @7.19-7.24 (string "Alice")))) (field (name "age") - (e-int @7.32-7.34 (value "30")))))) + (e-num @7.32-7.34 (value "30")))))) (field (name "address") (e-record @8.11-15.3 (fields @@ -152,5 +152,5 @@ NO CHANGE ~~~ # TYPES ~~~clojure -(expr @1.1-23.2 (type "{ person: { name: Str, age: Num(_size) }, address: { street: Str, city: Str, coordinates: { lat: Frac(_size2), lng: Frac(_size3) } }, contact: { email: Str, phone: { home: Str, work: Str } } }")) +(expr @1.1-23.2 (type "{ address: { city: Str, coordinates: { lat: Num(Frac(_size)), lng: Num(Frac(_size2)) }, street: Str }, contact: { email: Str, phone: { home: Str, work: Str } }, person: { age: Num(_size3), name: Str }, Error }")) ~~~ diff --git a/test/snapshots/records/record_with_complex_types.md b/test/snapshots/records/record_with_complex_types.md index 4c9bc4b969..f4a9d3dcef 100644 --- a/test/snapshots/records/record_with_complex_types.md +++ b/test/snapshots/records/record_with_complex_types.md @@ -152,10 +152,10 @@ EndOfFile(16:1-16:1), (field (name "scores") (e-list @3.13-3.29 (elems - (e-int @3.14-3.16 (value "95")) - (e-int @3.18-3.20 (value "87")) - (e-int @3.22-3.24 (value "92")) - (e-int @3.26-3.28 (value "78"))))) + (e-num @3.14-3.16 (value "95")) + (e-num @3.18-3.20 (value "87")) + (e-num @3.22-3.24 (value "92")) + (e-num @3.26-3.28 (value "78"))))) (field (name "status") (e-tag @4.13-4.44 (name "Active") (args @@ -202,7 +202,7 @@ EndOfFile(16:1-16:1), (e-binop @10.19-10.24 (op "add") (e-lookup-local @10.19-10.20 (p-assign @10.16-10.17 (ident "x"))) - (e-int @10.23-10.24 (value "1"))))) + (e-num @10.23-10.24 (value "1"))))) (field (name "nested") (e-record @11.13-14.6 (fields @@ -226,14 +226,14 @@ EndOfFile(16:1-16:1), (field (name "data") (e-list @13.33-13.42 (elems - (e-int @13.34-13.35 (value "1")) - (e-int @13.37-13.38 (value "2")) - (e-int @13.40-13.41 (value "3"))))) + (e-num @13.34-13.35 (value "1")) + (e-num @13.37-13.38 (value "2")) + (e-num @13.40-13.41 (value "3"))))) (field (name "timestamp") (e-string @13.55-13.67 (e-literal @13.56-13.66 (string "2024-01-01")))))))))))))) ~~~ # TYPES ~~~clojure -(expr @1.1-15.2 (type "{ name: Str, scores: List(Num(_size)), status: [Active({ since: Str })]_others, preferences: { theme: [Dark]_others2, notifications: [Email(Str)]_others3 }, metadata: Result({ tags: List(Str), permissions: List([Read]_others4) }, err), callback: Num(_size2) -> Num(_size3), nested: { items: List([Some(Str)][None]_others5), result: [Success({ data: List(Num(_size4)), timestamp: Str })]_others6 } }")) +(expr @1.1-15.2 (type "{ callback: Num(_size) -> Num(_size2), metadata: Result({ permissions: List([Read, Write, Admin]_others), tags: List(Str) }, err), name: Str, nested: { items: List([Some(Str)][None]_others2), result: [Success({ data: List(Num(_size3)), timestamp: Str })]_others3 }, preferences: { notifications: [Email(Str)]_others4, theme: [Dark]_others5 }, scores: List(Num(_size4)), status: [Active({ since: Str })]_others6 }")) ~~~ diff --git a/test/snapshots/records/statement_record_binding.md b/test/snapshots/records/statement_record_binding.md index 2052eafe95..0e136e8df2 100644 --- a/test/snapshots/records/statement_record_binding.md +++ b/test/snapshots/records/statement_record_binding.md @@ -45,7 +45,7 @@ NO CHANGE (e-string @1.18-1.25 (e-literal @1.19-1.24 (string "Alice")))) (field (name "age") - (e-int @1.32-1.34 (value "30"))) + (e-num @1.32-1.34 (value "30"))) (field (name "email") (e-string @1.43-1.62 (e-literal @1.44-1.61 (string "alice@example.com")))))))) diff --git a/test/snapshots/records/statement_record_destructure.md b/test/snapshots/records/statement_record_destructure.md index ec2fbd8cba..6f8c9693f3 100644 --- a/test/snapshots/records/statement_record_destructure.md +++ b/test/snapshots/records/statement_record_destructure.md @@ -1,22 +1,20 @@ # META ~~~ini description=Record destructuring in assignment statement -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - { name, age, email } = person ~~~ # EXPECTED -UNDEFINED VARIABLE - statement_record_destructure.md:3:24:3:30 +UNDEFINED VARIABLE - statement_record_destructure.md:1:24:1:30 # PROBLEMS **UNDEFINED VARIABLE** Nothing is named `person` in this scope. Is there an `import` or `exposing` missing up-top? -**statement_record_destructure.md:3:24:3:30:** +**statement_record_destructure.md:1:24:1:30:** ```roc { name, age, email } = person ``` @@ -25,22 +23,20 @@ Is there an `import` or `exposing` missing up-top? # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -OpenCurly(3:1-3:2),LowerIdent(3:3-3:7),Comma(3:7-3:8),LowerIdent(3:9-3:12),Comma(3:12-3:13),LowerIdent(3:14-3:19),CloseCurly(3:20-3:21),OpAssign(3:22-3:23),LowerIdent(3:24-3:30), -EndOfFile(4:1-4:1), +OpenCurly(1:1-1:2),LowerIdent(1:3-1:7),Comma(1:7-1:8),LowerIdent(1:9-1:12),Comma(1:12-1:13),LowerIdent(1:14-1:19),CloseCurly(1:20-1:21),OpAssign(1:22-1:23),LowerIdent(1:24-1:30), +EndOfFile(2:1-2:1), ~~~ # PARSE ~~~clojure -(file @1.1-3.30 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-1.30 + (type-module @1.1-1.2) (statements - (s-decl @3.1-3.30 - (p-record @3.1-3.21 - (field @3.3-3.7 (name "name") (rest false)) - (field @3.9-3.12 (name "age") (rest false)) - (field @3.14-3.19 (name "email") (rest false))) - (e-ident @3.24-3.30 (raw "person"))))) + (s-decl @1.1-1.30 + (p-record @1.1-1.21 + (field @1.3-1.7 (name "name") (rest false)) + (field @1.9-1.12 (name "age") (rest false)) + (field @1.14-1.19 (name "email") (rest false))) + (e-ident @1.24-1.30 (raw "person"))))) ~~~ # FORMATTED ~~~roc @@ -50,17 +46,17 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-record-destructure @3.1-3.21 + (p-record-destructure @1.1-1.21 (destructs - (record-destruct @3.3-3.7 (label "name") (ident "name") + (record-destruct @1.3-1.7 (label "name") (ident "name") (required - (p-assign @3.3-3.7 (ident "name")))) - (record-destruct @3.9-3.12 (label "age") (ident "age") + (p-assign @1.3-1.7 (ident "name")))) + (record-destruct @1.9-1.12 (label "age") (ident "age") (required - (p-assign @3.9-3.12 (ident "age")))) - (record-destruct @3.14-3.19 (label "email") (ident "email") + (p-assign @1.9-1.12 (ident "age")))) + (record-destruct @1.14-1.19 (label "email") (ident "email") (required - (p-assign @3.14-3.19 (ident "email")))))) + (p-assign @1.14-1.19 (ident "email")))))) (e-runtime-error (tag "ident_not_in_scope")))) ~~~ # TYPES @@ -68,5 +64,5 @@ NO CHANGE (inferred-types (defs) (expressions - (expr @3.24-3.30 (type "Error")))) + (expr @1.24-1.30 (type "Error")))) ~~~ diff --git a/test/snapshots/records/type_constrained_record.md b/test/snapshots/records/type_constrained_record.md index 8c8d6eb202..9e9584ed36 100644 --- a/test/snapshots/records/type_constrained_record.md +++ b/test/snapshots/records/type_constrained_record.md @@ -66,15 +66,7 @@ process_user! : { name : Str, age : } => Str ~~~ # CANONICALIZE ~~~clojure -(can-ir - (s-type-anno @1.1-1.54 (name "process_user!") - (ty-fn @1.17-1.54 (effectful true) - (ty-record @1.17-1.47 - (field (field "name") - (ty @1.26-1.29 (name "Str"))) - (field (field "age") - (ty-malformed @1.37-1.45))) - (ty @1.51-1.54 (name "Str"))))) +(can-ir (empty true)) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/records/type_function_return_record.md b/test/snapshots/records/type_function_return_record.md index 17b3574bc1..de0c415475 100644 --- a/test/snapshots/records/type_function_return_record.md +++ b/test/snapshots/records/type_function_return_record.md @@ -38,20 +38,7 @@ NO CHANGE ~~~ # CANONICALIZE ~~~clojure -(can-ir - (s-type-anno @1.1-1.78 (name "create_user!") - (ty-fn @1.16-1.78 (effectful true) - (ty @1.16-1.19 (name "Str")) - (ty @1.21-1.24 (name "U32")) - (ty-record @1.28-1.78 - (field (field "name") - (ty @1.37-1.40 (name "Str"))) - (field (field "age") - (ty @1.48-1.51 (name "U32"))) - (field (field "id") - (ty @1.58-1.61 (name "U64"))) - (field (field "active") - (ty @1.72-1.76 (name "Bool"))))))) +(can-ir (empty true)) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/records/type_open_record.md b/test/snapshots/records/type_open_record.md index 645f3c2946..7a50c45776 100644 --- a/test/snapshots/records/type_open_record.md +++ b/test/snapshots/records/type_open_record.md @@ -72,9 +72,7 @@ process_user! : ~~~ # CANONICALIZE ~~~clojure -(can-ir - (s-type-anno @1.1-1.49 (name "process_user!") - (ty-malformed @1.47-1.49))) +(can-ir (empty true)) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/records/type_record_parameter.md b/test/snapshots/records/type_record_parameter.md index 3b4fc4d299..03fec02412 100644 --- a/test/snapshots/records/type_record_parameter.md +++ b/test/snapshots/records/type_record_parameter.md @@ -38,21 +38,7 @@ process_things : { name : Str, age : U32, thing : a }, (a -> Str) -> Str ~~~ # CANONICALIZE ~~~clojure -(can-ir - (s-type-anno @1.1-1.72 (name "process_things") - (ty-fn @1.18-1.72 (effectful false) - (ty-record @1.18-1.53 - (field (field "name") - (ty @1.27-1.30 (name "Str"))) - (field (field "age") - (ty @1.38-1.41 (name "U32"))) - (field (field "thing") - (ty-var @1.50-1.51 (name "a")))) - (ty-parens @1.55-1.65 - (ty-fn @1.56-1.64 (effectful false) - (ty-var @1.56-1.57 (name "a")) - (ty @1.61-1.64 (name "Str")))) - (ty @1.69-1.72 (name "Str"))))) +(can-ir (empty true)) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/repl/repl_record_field_access.md b/test/snapshots/repl/repl_record_field_access.md index 542d369e4b..c43ebe2a76 100644 --- a/test/snapshots/repl/repl_record_field_access.md +++ b/test/snapshots/repl/repl_record_field_access.md @@ -10,7 +10,7 @@ type=repl » {foo: "Hello", bar: "World"}.bar ~~~ # OUTPUT -Evaluation error: error.ZeroSizedType +Evaluation error: error.TypeMismatch --- "Hello" --- diff --git a/test/snapshots/rigid_var_instantiation.md b/test/snapshots/rigid_var_instantiation.md index f123d036b3..3134a33d10 100644 --- a/test/snapshots/rigid_var_instantiation.md +++ b/test/snapshots/rigid_var_instantiation.md @@ -167,8 +167,8 @@ main! = |_| { (annotation @5.1-5.9 (declared-type (ty-fn @4.12-4.18 (effectful false) - (ty-var @4.12-4.13 (name "a")) - (ty-var @4.17-4.18 (name "a")))))) + (ty-rigid-var @4.12-4.13 (name "a")) + (ty-rigid-var-lookup (ty-rigid-var @4.12-4.13 (name "a"))))))) (d-let (p-assign @8.1-8.6 (ident "main!")) (e-closure @8.9-19.2 @@ -183,7 +183,7 @@ main! = |_| { (e-call @10.11-10.23 (e-lookup-local @10.11-10.19 (p-assign @5.1-5.9 (ident "identity"))) - (e-int @10.20-10.22 (value "42")))) + (e-num @10.20-10.22 (value "42")))) (s-let @13.5-13.28 (p-assign @13.5-13.8 (ident "str")) (e-call @13.11-13.28 @@ -198,9 +198,9 @@ main! = |_| { (p-assign @5.1-5.9 (ident "identity"))) (e-list @16.20-16.29 (elems - (e-int @16.21-16.22 (value "1")) - (e-int @16.24-16.25 (value "2")) - (e-int @16.27-16.28 (value "3")))))) + (e-num @16.21-16.22 (value "1")) + (e-num @16.24-16.25 (value "2")) + (e-num @16.27-16.28 (value "3")))))) (e-empty_record @18.5-18.7)))))) ~~~ # TYPES diff --git a/test/snapshots/rigid_var_no_instantiation_error.md b/test/snapshots/rigid_var_no_instantiation_error.md index b494204950..a7a516be82 100644 --- a/test/snapshots/rigid_var_no_instantiation_error.md +++ b/test/snapshots/rigid_var_no_instantiation_error.md @@ -226,11 +226,11 @@ main! = |_| { (declared-type (ty-fn @4.8-4.24 (effectful false) (ty-tuple @4.8-4.14 - (ty-var @4.9-4.10 (name "a")) - (ty-var @4.12-4.13 (name "b"))) + (ty-rigid-var @4.9-4.10 (name "a")) + (ty-rigid-var @4.12-4.13 (name "b"))) (ty-tuple @4.18-4.24 - (ty-var @4.19-4.20 (name "b")) - (ty-var @4.22-4.23 (name "a"))))))) + (ty-rigid-var-lookup (ty-rigid-var @4.12-4.13 (name "b"))) + (ty-rigid-var-lookup (ty-rigid-var @4.9-4.10 (name "a")))))))) (d-let (p-assign @11.1-11.6 (ident "main!")) (e-closure @11.9-24.2 @@ -247,7 +247,7 @@ main! = |_| { (p-assign @5.1-5.5 (ident "swap"))) (e-tuple @13.20-13.33 (elems - (e-int @13.21-13.23 (value "42")) + (e-num @13.21-13.23 (value "42")) (e-string @13.25-13.32 (e-literal @13.26-13.31 (string "hello"))))))) (s-let @17.5-17.43 @@ -260,9 +260,9 @@ main! = |_| { (e-runtime-error (tag "ident_not_in_scope")) (e-list @17.32-17.41 (elems - (e-int @17.33-17.34 (value "1")) - (e-int @17.36-17.37 (value "2")) - (e-int @17.39-17.40 (value "3")))))))) + (e-num @17.33-17.34 (value "1")) + (e-num @17.36-17.37 (value "2")) + (e-num @17.39-17.40 (value "3")))))))) (s-let @21.5-21.35 (p-assign @21.5-21.12 (ident "result3")) (e-call @21.15-21.35 diff --git a/test/snapshots/simple_lambda_constraint_success.md b/test/snapshots/simple_lambda_constraint_success.md index 590d24c895..172b1432cb 100644 --- a/test/snapshots/simple_lambda_constraint_success.md +++ b/test/snapshots/simple_lambda_constraint_success.md @@ -1,12 +1,10 @@ # META ~~~ini description=Simple lambda constraint success test - verifies bidirectional type checking works correctly -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [addTwo, addTwoF64] - # Should successfully constrain literal 2 to I64 addTwo : I64 -> I64 addTwo = |x| x + 2 @@ -21,91 +19,92 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:15),Comma(1:15-1:16),LowerIdent(1:17-1:26),CloseSquare(1:26-1:27), -LowerIdent(4:1-4:7),OpColon(4:8-4:9),UpperIdent(4:10-4:13),OpArrow(4:14-4:16),UpperIdent(4:17-4:20), -LowerIdent(5:1-5:7),OpAssign(5:8-5:9),OpBar(5:10-5:11),LowerIdent(5:11-5:12),OpBar(5:12-5:13),LowerIdent(5:14-5:15),OpPlus(5:16-5:17),Int(5:18-5:19), -LowerIdent(8:1-8:10),OpColon(8:11-8:12),UpperIdent(8:13-8:16),OpArrow(8:17-8:19),UpperIdent(8:20-8:23), -LowerIdent(9:1-9:10),OpAssign(9:11-9:12),OpBar(9:13-9:14),LowerIdent(9:14-9:15),OpBar(9:15-9:16),LowerIdent(9:17-9:18),OpPlus(9:19-9:20),Float(9:21-9:24), -EndOfFile(10:1-10:1), +LowerIdent(2:1-2:7),OpColon(2:8-2:9),UpperIdent(2:10-2:13),OpArrow(2:14-2:16),UpperIdent(2:17-2:20), +LowerIdent(3:1-3:7),OpAssign(3:8-3:9),OpBar(3:10-3:11),LowerIdent(3:11-3:12),OpBar(3:12-3:13),LowerIdent(3:14-3:15),OpPlus(3:16-3:17),Int(3:18-3:19), +LowerIdent(6:1-6:10),OpColon(6:11-6:12),UpperIdent(6:13-6:16),OpArrow(6:17-6:19),UpperIdent(6:20-6:23), +LowerIdent(7:1-7:10),OpAssign(7:11-7:12),OpBar(7:13-7:14),LowerIdent(7:14-7:15),OpBar(7:15-7:16),LowerIdent(7:17-7:18),OpPlus(7:19-7:20),Float(7:21-7:24), +EndOfFile(8:1-8:1), ~~~ # PARSE ~~~clojure -(file @1.1-9.24 - (module @1.1-1.27 - (exposes @1.8-1.27 - (exposed-lower-ident @1.9-1.15 - (text "addTwo")) - (exposed-lower-ident @1.17-1.26 - (text "addTwoF64")))) +(file @2.1-7.24 + (type-module @2.1-2.7) (statements - (s-type-anno @4.1-4.20 (name "addTwo") - (ty-fn @4.10-4.20 - (ty @4.10-4.13 (name "I64")) - (ty @4.17-4.20 (name "I64")))) - (s-decl @5.1-5.19 - (p-ident @5.1-5.7 (raw "addTwo")) - (e-lambda @5.10-5.19 + (s-type-anno @2.1-2.20 (name "addTwo") + (ty-fn @2.10-2.20 + (ty @2.10-2.13 (name "I64")) + (ty @2.17-2.20 (name "I64")))) + (s-decl @3.1-3.19 + (p-ident @3.1-3.7 (raw "addTwo")) + (e-lambda @3.10-3.19 (args - (p-ident @5.11-5.12 (raw "x"))) - (e-binop @5.14-5.19 (op "+") - (e-ident @5.14-5.15 (raw "x")) - (e-int @5.18-5.19 (raw "2"))))) - (s-type-anno @8.1-8.23 (name "addTwoF64") - (ty-fn @8.13-8.23 - (ty @8.13-8.16 (name "F64")) - (ty @8.20-8.23 (name "F64")))) - (s-decl @9.1-9.24 - (p-ident @9.1-9.10 (raw "addTwoF64")) - (e-lambda @9.13-9.24 + (p-ident @3.11-3.12 (raw "x"))) + (e-binop @3.14-3.19 (op "+") + (e-ident @3.14-3.15 (raw "x")) + (e-int @3.18-3.19 (raw "2"))))) + (s-type-anno @6.1-6.23 (name "addTwoF64") + (ty-fn @6.13-6.23 + (ty @6.13-6.16 (name "F64")) + (ty @6.20-6.23 (name "F64")))) + (s-decl @7.1-7.24 + (p-ident @7.1-7.10 (raw "addTwoF64")) + (e-lambda @7.13-7.24 (args - (p-ident @9.14-9.15 (raw "x"))) - (e-binop @9.17-9.24 (op "+") - (e-ident @9.17-9.18 (raw "x")) - (e-frac @9.21-9.24 (raw "2.0"))))))) + (p-ident @7.14-7.15 (raw "x"))) + (e-binop @7.17-7.24 (op "+") + (e-ident @7.17-7.18 (raw "x")) + (e-frac @7.21-7.24 (raw "2.0"))))))) ~~~ # FORMATTED ~~~roc -NO CHANGE +# Should successfully constrain literal 2 to I64 +# Should successfully constrain literal 2 to I64 +addTwo : I64 -> I64 +addTwo = |x| x + 2 + +# Should successfully constrain literal 2.0 to F64 +addTwoF64 : F64 -> F64 +addTwoF64 = |x| x + 2.0 ~~~ # CANONICALIZE ~~~clojure (can-ir (d-let - (p-assign @5.1-5.7 (ident "addTwo")) - (e-lambda @5.10-5.19 + (p-assign @3.1-3.7 (ident "addTwo")) + (e-lambda @3.10-3.19 (args - (p-assign @5.11-5.12 (ident "x"))) - (e-binop @5.14-5.19 (op "add") - (e-lookup-local @5.14-5.15 - (p-assign @5.11-5.12 (ident "x"))) - (e-int @5.18-5.19 (value "2")))) - (annotation @5.1-5.7 + (p-assign @3.11-3.12 (ident "x"))) + (e-binop @3.14-3.19 (op "add") + (e-lookup-local @3.14-3.15 + (p-assign @3.11-3.12 (ident "x"))) + (e-num @3.18-3.19 (value "2")))) + (annotation @3.1-3.7 (declared-type - (ty-fn @4.10-4.20 (effectful false) - (ty @4.10-4.13 (name "I64")) - (ty @4.17-4.20 (name "I64")))))) + (ty-fn @2.10-2.20 (effectful false) + (ty-lookup @2.10-2.13 (name "I64") (builtin)) + (ty-lookup @2.17-2.20 (name "I64") (builtin)))))) (d-let - (p-assign @9.1-9.10 (ident "addTwoF64")) - (e-lambda @9.13-9.24 + (p-assign @7.1-7.10 (ident "addTwoF64")) + (e-lambda @7.13-7.24 (args - (p-assign @9.14-9.15 (ident "x"))) - (e-binop @9.17-9.24 (op "add") - (e-lookup-local @9.17-9.18 - (p-assign @9.14-9.15 (ident "x"))) - (e-dec-small @9.21-9.24 (numerator "20") (denominator-power-of-ten "1") (value "2")))) - (annotation @9.1-9.10 + (p-assign @7.14-7.15 (ident "x"))) + (e-binop @7.17-7.24 (op "add") + (e-lookup-local @7.17-7.18 + (p-assign @7.14-7.15 (ident "x"))) + (e-dec-small @7.21-7.24 (numerator "20") (denominator-power-of-ten "1") (value "2")))) + (annotation @7.1-7.10 (declared-type - (ty-fn @8.13-8.23 (effectful false) - (ty @8.13-8.16 (name "F64")) - (ty @8.20-8.23 (name "F64"))))))) + (ty-fn @6.13-6.23 (effectful false) + (ty-lookup @6.13-6.16 (name "F64") (builtin)) + (ty-lookup @6.20-6.23 (name "F64") (builtin))))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @5.1-5.7 (type "I64 -> I64")) - (patt @9.1-9.10 (type "F64 -> F64"))) + (patt @3.1-3.7 (type "Num(Int(Signed64)) -> Num(Int(Signed64))")) + (patt @7.1-7.10 (type "Num(Frac(Float64)) -> Num(Frac(Float64))"))) (expressions - (expr @5.10-5.19 (type "I64 -> I64")) - (expr @9.13-9.24 (type "F64 -> F64")))) + (expr @3.10-3.19 (type "Num(Int(Signed64)) -> Num(Int(Signed64))")) + (expr @7.13-7.24 (type "Num(Frac(Float64)) -> Num(Frac(Float64))")))) ~~~ diff --git a/test/snapshots/simple_module_no_blanks.md b/test/snapshots/simple_module_no_blanks.md index 164204d210..ebae9caaaf 100644 --- a/test/snapshots/simple_module_no_blanks.md +++ b/test/snapshots/simple_module_no_blanks.md @@ -1,23 +1,22 @@ # META ~~~ini description=A simple module with no blanks -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [hello!, world] import pf.Stdout hello! = Stdout.line!("Hello") world = "World" ~~~ # EXPECTED -MODULE NOT FOUND - simple_module_no_blanks.md:2:1:2:17 +MODULE NOT FOUND - simple_module_no_blanks.md:1:1:1:17 # PROBLEMS **MODULE NOT FOUND** The module `pf.Stdout` was not found in this Roc project. You're attempting to use this module here: -**simple_module_no_blanks.md:2:1:2:17:** +**simple_module_no_blanks.md:1:1:1:17:** ```roc import pf.Stdout ``` @@ -26,33 +25,27 @@ import pf.Stdout # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:15),Comma(1:15-1:16),LowerIdent(1:17-1:22),CloseSquare(1:22-1:23), -KwImport(2:1-2:7),LowerIdent(2:8-2:10),NoSpaceDotUpperIdent(2:10-2:17), -LowerIdent(3:1-3:7),OpAssign(3:8-3:9),UpperIdent(3:10-3:16),NoSpaceDotLowerIdent(3:16-3:22),NoSpaceOpenRound(3:22-3:23),StringStart(3:23-3:24),StringPart(3:24-3:29),StringEnd(3:29-3:30),CloseRound(3:30-3:31), -LowerIdent(4:1-4:6),OpAssign(4:7-4:8),StringStart(4:9-4:10),StringPart(4:10-4:15),StringEnd(4:15-4:16), -EndOfFile(5:1-5:1), +KwImport(1:1-1:7),LowerIdent(1:8-1:10),NoSpaceDotUpperIdent(1:10-1:17), +LowerIdent(2:1-2:7),OpAssign(2:8-2:9),UpperIdent(2:10-2:16),NoSpaceDotLowerIdent(2:16-2:22),NoSpaceOpenRound(2:22-2:23),StringStart(2:23-2:24),StringPart(2:24-2:29),StringEnd(2:29-2:30),CloseRound(2:30-2:31), +LowerIdent(3:1-3:6),OpAssign(3:7-3:8),StringStart(3:9-3:10),StringPart(3:10-3:15),StringEnd(3:15-3:16), +EndOfFile(4:1-4:1), ~~~ # PARSE ~~~clojure -(file @1.1-4.16 - (module @1.1-1.23 - (exposes @1.8-1.23 - (exposed-lower-ident @1.9-1.15 - (text "hello!")) - (exposed-lower-ident @1.17-1.22 - (text "world")))) +(file @1.1-3.16 + (type-module @1.1-1.7) (statements - (s-import @2.1-2.17 (raw "pf.Stdout")) - (s-decl @3.1-3.31 - (p-ident @3.1-3.7 (raw "hello!")) - (e-apply @3.10-3.31 - (e-ident @3.10-3.22 (raw "Stdout.line!")) - (e-string @3.23-3.30 - (e-string-part @3.24-3.29 (raw "Hello"))))) - (s-decl @4.1-4.16 - (p-ident @4.1-4.6 (raw "world")) - (e-string @4.9-4.16 - (e-string-part @4.10-4.15 (raw "World")))))) + (s-import @1.1-1.17 (raw "pf.Stdout")) + (s-decl @2.1-2.31 + (p-ident @2.1-2.7 (raw "hello!")) + (e-apply @2.10-2.31 + (e-ident @2.10-2.22 (raw "Stdout.line!")) + (e-string @2.23-2.30 + (e-string-part @2.24-2.29 (raw "Hello"))))) + (s-decl @3.1-3.16 + (p-ident @3.1-3.6 (raw "world")) + (e-string @3.9-3.16 + (e-string-part @3.10-3.15 (raw "World")))))) ~~~ # FORMATTED ~~~roc @@ -62,27 +55,27 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @3.1-3.7 (ident "hello!")) - (e-call @3.10-3.31 - (e-lookup-external @3.10-3.22 - (module-idx "0") + (p-assign @2.1-2.7 (ident "hello!")) + (e-call @2.10-2.31 + (e-lookup-external @2.10-2.22 + (module-idx "2") (target-node-idx "0")) - (e-string @3.23-3.30 - (e-literal @3.24-3.29 (string "Hello"))))) + (e-string @2.23-2.30 + (e-literal @2.24-2.29 (string "Hello"))))) (d-let - (p-assign @4.1-4.6 (ident "world")) - (e-string @4.9-4.16 - (e-literal @4.10-4.15 (string "World")))) - (s-import @2.1-2.17 (module "pf.Stdout") (qualifier "pf") + (p-assign @3.1-3.6 (ident "world")) + (e-string @3.9-3.16 + (e-literal @3.10-3.15 (string "World")))) + (s-import @1.1-1.17 (module "pf.Stdout") (qualifier "pf") (exposes))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @3.1-3.7 (type "_a")) - (patt @4.1-4.6 (type "Str"))) + (patt @2.1-2.7 (type "_a")) + (patt @3.1-3.6 (type "Str"))) (expressions - (expr @3.10-3.31 (type "_a")) - (expr @4.9-4.16 (type "Str")))) + (expr @2.10-2.31 (type "_a")) + (expr @3.9-3.16 (type "Str")))) ~~~ diff --git a/test/snapshots/some_folder/002.md b/test/snapshots/some_folder/002.md index 7948ffb167..ac047c89e5 100644 --- a/test/snapshots/some_folder/002.md +++ b/test/snapshots/some_folder/002.md @@ -1,23 +1,87 @@ # META ~~~ini description=Basic example to develop the snapshot methodology -type=file +type=file:002.roc ~~~ # SOURCE ~~~roc -module [foo, bar] +@2 := {} foo = "one" bar = "two" ~~~ # EXPECTED -NIL +PARSE ERROR - 002.md:1:1:1:3 +PARSE ERROR - 002.md:1:4:1:6 +PARSE ERROR - 002.md:1:7:1:8 +PARSE ERROR - 002.md:1:8:1:9 +MISSING MAIN! FUNCTION - 002.md:1:1:5:12 # PROBLEMS -NIL +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**002.md:1:1:1:3:** +```roc +@2 := {} +``` +^^ + + +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**002.md:1:4:1:6:** +```roc +@2 := {} +``` + ^^ + + +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**002.md:1:7:1:8:** +```roc +@2 := {} +``` + ^ + + +**PARSE ERROR** +A parsing error occurred: `statement_unexpected_token` +This is an unexpected parsing error. Please check your syntax. + +**002.md:1:8:1:9:** +```roc +@2 := {} +``` + ^ + + +**MISSING MAIN! FUNCTION** +Default app modules must have a `main!` function. + +No `main!` function was found. + +Add a main! function like: +`main! = |arg| { ... }` +**002.md:1:1:5:12:** +```roc +@2 := {} + +foo = "one" + +bar = "two" +``` + + # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:12),Comma(1:12-1:13),LowerIdent(1:14-1:17),CloseSquare(1:17-1:18), +OpaqueName(1:1-1:3),OpColonEqual(1:4-1:6),OpenCurly(1:7-1:8),CloseCurly(1:8-1:9), LowerIdent(3:1-3:4),OpAssign(3:5-3:6),StringStart(3:7-3:8),StringPart(3:8-3:11),StringEnd(3:11-3:12), LowerIdent(5:1-5:4),OpAssign(5:5-5:6),StringStart(5:7-5:8),StringPart(5:8-5:11),StringEnd(5:11-5:12), EndOfFile(6:1-6:1), @@ -25,13 +89,12 @@ EndOfFile(6:1-6:1), # PARSE ~~~clojure (file @1.1-5.12 - (module @1.1-1.18 - (exposes @1.8-1.18 - (exposed-lower-ident @1.9-1.12 - (text "foo")) - (exposed-lower-ident @1.14-1.17 - (text "bar")))) + (type-module @1.1-1.3) (statements + (s-malformed @1.1-1.3 (tag "statement_unexpected_token")) + (s-malformed @1.4-1.6 (tag "statement_unexpected_token")) + (s-malformed @1.7-1.8 (tag "statement_unexpected_token")) + (s-malformed @1.8-1.9 (tag "statement_unexpected_token")) (s-decl @3.1-3.12 (p-ident @3.1-3.4 (raw "foo")) (e-string @3.7-3.12 @@ -43,7 +106,11 @@ EndOfFile(6:1-6:1), ~~~ # FORMATTED ~~~roc -NO CHANGE + + +foo = "one" + +bar = "two" ~~~ # CANONICALIZE ~~~clojure diff --git a/test/snapshots/statement/dbg_simple_test.md b/test/snapshots/statement/dbg_simple_test.md index a8140bd684..cd0761f346 100644 --- a/test/snapshots/statement/dbg_simple_test.md +++ b/test/snapshots/statement/dbg_simple_test.md @@ -1,12 +1,10 @@ # META ~~~ini description=Simple debug test to understand parsing behavior -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [test] - test = { x = 42 dbg(x) @@ -18,36 +16,30 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:13),CloseSquare(1:13-1:14), -LowerIdent(3:1-3:5),OpAssign(3:6-3:7),OpenCurly(3:8-3:9), -LowerIdent(4:5-4:6),OpAssign(4:7-4:8),Int(4:9-4:11), -KwDbg(5:5-5:8),NoSpaceOpenRound(5:8-5:9),LowerIdent(5:9-5:10),CloseRound(5:10-5:11), -CloseCurly(6:1-6:2), -EndOfFile(7:1-7:1), +LowerIdent(1:1-1:5),OpAssign(1:6-1:7),OpenCurly(1:8-1:9), +LowerIdent(2:5-2:6),OpAssign(2:7-2:8),Int(2:9-2:11), +KwDbg(3:5-3:8),NoSpaceOpenRound(3:8-3:9),LowerIdent(3:9-3:10),CloseRound(3:10-3:11), +CloseCurly(4:1-4:2), +EndOfFile(5:1-5:1), ~~~ # PARSE ~~~clojure -(file @1.1-6.2 - (module @1.1-1.14 - (exposes @1.8-1.14 - (exposed-lower-ident @1.9-1.13 - (text "test")))) +(file @1.1-4.2 + (type-module @1.1-1.5) (statements - (s-decl @3.1-6.2 - (p-ident @3.1-3.5 (raw "test")) - (e-block @3.8-6.2 + (s-decl @1.1-4.2 + (p-ident @1.1-1.5 (raw "test")) + (e-block @1.8-4.2 (statements - (s-decl @4.5-4.11 - (p-ident @4.5-4.6 (raw "x")) - (e-int @4.9-4.11 (raw "42"))) - (s-dbg @5.5-5.11 - (e-tuple @5.8-5.11 - (e-ident @5.9-5.10 (raw "x"))))))))) + (s-decl @2.5-2.11 + (p-ident @2.5-2.6 (raw "x")) + (e-int @2.9-2.11 (raw "42"))) + (s-dbg @3.5-3.11 + (e-tuple @3.8-3.11 + (e-ident @3.9-3.10 (raw "x"))))))))) ~~~ # FORMATTED ~~~roc -module [test] - test = { x = 42 dbg (x) @@ -57,20 +49,20 @@ test = { ~~~clojure (can-ir (d-let - (p-assign @3.1-3.5 (ident "test")) - (e-block @3.8-6.2 - (s-let @4.5-4.11 - (p-assign @4.5-4.6 (ident "x")) - (e-int @4.9-4.11 (value "42"))) - (e-dbg @5.5-5.11 - (e-lookup-local @5.9-5.10 - (p-assign @4.5-4.6 (ident "x"))))))) + (p-assign @1.1-1.5 (ident "test")) + (e-block @1.8-4.2 + (s-let @2.5-2.11 + (p-assign @2.5-2.6 (ident "x")) + (e-num @2.9-2.11 (value "42"))) + (e-dbg @3.5-3.11 + (e-lookup-local @3.9-3.10 + (p-assign @2.5-2.6 (ident "x"))))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @3.1-3.5 (type "Num(_size)"))) + (patt @1.1-1.5 (type "Num(_size)"))) (expressions - (expr @3.8-6.2 (type "Num(_size)")))) + (expr @1.8-4.2 (type "Num(_size)")))) ~~~ diff --git a/test/snapshots/statement/dbg_stmt_block_example.md b/test/snapshots/statement/dbg_stmt_block_example.md index 2a935e9e54..8652c80db3 100644 --- a/test/snapshots/statement/dbg_stmt_block_example.md +++ b/test/snapshots/statement/dbg_stmt_block_example.md @@ -1,12 +1,10 @@ # META ~~~ini description=Debug expression in a block context both statement and expression versions -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [foo] - foo = |num| { # statement - prints out the value of num convertert to a string dbg num.to_str() @@ -21,41 +19,35 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:12),CloseSquare(1:12-1:13), -LowerIdent(3:1-3:4),OpAssign(3:5-3:6),OpBar(3:7-3:8),LowerIdent(3:8-3:11),OpBar(3:11-3:12),OpenCurly(3:13-3:14), -KwDbg(5:5-5:8),LowerIdent(5:9-5:12),NoSpaceDotLowerIdent(5:12-5:19),NoSpaceOpenRound(5:19-5:20),CloseRound(5:20-5:21), -KwDbg(8:5-8:8),NoSpaceOpenRound(8:8-8:9),LowerIdent(8:9-8:12),CloseRound(8:12-8:13), -CloseCurly(9:1-9:2), -EndOfFile(10:1-10:1), +LowerIdent(1:1-1:4),OpAssign(1:5-1:6),OpBar(1:7-1:8),LowerIdent(1:8-1:11),OpBar(1:11-1:12),OpenCurly(1:13-1:14), +KwDbg(3:5-3:8),LowerIdent(3:9-3:12),NoSpaceDotLowerIdent(3:12-3:19),NoSpaceOpenRound(3:19-3:20),CloseRound(3:20-3:21), +KwDbg(6:5-6:8),NoSpaceOpenRound(6:8-6:9),LowerIdent(6:9-6:12),CloseRound(6:12-6:13), +CloseCurly(7:1-7:2), +EndOfFile(8:1-8:1), ~~~ # PARSE ~~~clojure -(file @1.1-9.2 - (module @1.1-1.13 - (exposes @1.8-1.13 - (exposed-lower-ident @1.9-1.12 - (text "foo")))) +(file @1.1-7.2 + (type-module @1.1-1.4) (statements - (s-decl @3.1-9.2 - (p-ident @3.1-3.4 (raw "foo")) - (e-lambda @3.7-9.2 + (s-decl @1.1-7.2 + (p-ident @1.1-1.4 (raw "foo")) + (e-lambda @1.7-7.2 (args - (p-ident @3.8-3.11 (raw "num"))) - (e-block @3.13-9.2 + (p-ident @1.8-1.11 (raw "num"))) + (e-block @1.13-7.2 (statements - (s-dbg @5.5-5.21 - (e-field-access @5.9-5.21 - (e-ident @5.9-5.12 (raw "num")) - (e-apply @5.12-5.21 - (e-ident @5.12-5.19 (raw "to_str"))))) - (s-dbg @8.5-8.13 - (e-tuple @8.8-8.13 - (e-ident @8.9-8.12 (raw "num")))))))))) + (s-dbg @3.5-3.21 + (e-field-access @3.9-3.21 + (e-ident @3.9-3.12 (raw "num")) + (e-apply @3.12-3.21 + (e-ident @3.12-3.19 (raw "to_str"))))) + (s-dbg @6.5-6.13 + (e-tuple @6.8-6.13 + (e-ident @6.9-6.12 (raw "num")))))))))) ~~~ # FORMATTED ~~~roc -module [foo] - foo = |num| { # statement - prints out the value of num convertert to a string dbg num.to_str() @@ -68,26 +60,26 @@ foo = |num| { ~~~clojure (can-ir (d-let - (p-assign @3.1-3.4 (ident "foo")) - (e-lambda @3.7-9.2 + (p-assign @1.1-1.4 (ident "foo")) + (e-lambda @1.7-7.2 (args - (p-assign @3.8-3.11 (ident "num"))) - (e-block @3.13-9.2 - (s-dbg @5.5-5.21 - (e-dot-access @5.9-5.21 (field "to_str") + (p-assign @1.8-1.11 (ident "num"))) + (e-block @1.13-7.2 + (s-dbg @3.5-3.21 + (e-dot-access @3.9-3.21 (field "to_str") (receiver - (e-lookup-local @5.9-5.12 - (p-assign @3.8-3.11 (ident "num")))) + (e-lookup-local @3.9-3.12 + (p-assign @1.8-1.11 (ident "num")))) (args))) - (e-dbg @8.5-8.13 - (e-lookup-local @8.9-8.12 - (p-assign @3.8-3.11 (ident "num")))))))) + (e-dbg @6.5-6.13 + (e-lookup-local @6.9-6.12 + (p-assign @1.8-1.11 (ident "num")))))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @3.1-3.4 (type "_arg -> _ret"))) + (patt @1.1-1.4 (type "a -> a"))) (expressions - (expr @3.7-9.2 (type "_arg -> _ret")))) + (expr @1.7-7.2 (type "a -> a")))) ~~~ diff --git a/test/snapshots/statement/dbg_stmt_in_body.md b/test/snapshots/statement/dbg_stmt_in_body.md index 54b195faea..9d23795555 100644 --- a/test/snapshots/statement/dbg_stmt_in_body.md +++ b/test/snapshots/statement/dbg_stmt_in_body.md @@ -1,12 +1,10 @@ # META ~~~ini description=Debug statement in body context -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [main] - main = { x = 42 dbg x @@ -19,39 +17,33 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:13),CloseSquare(1:13-1:14), -LowerIdent(3:1-3:5),OpAssign(3:6-3:7),OpenCurly(3:8-3:9), -LowerIdent(4:5-4:6),OpAssign(4:7-4:8),Int(4:9-4:11), -KwDbg(5:5-5:8),LowerIdent(5:9-5:10), -LowerIdent(6:5-6:6),OpPlus(6:7-6:8),Int(6:9-6:10), -CloseCurly(7:1-7:2), -EndOfFile(8:1-8:1), +LowerIdent(1:1-1:5),OpAssign(1:6-1:7),OpenCurly(1:8-1:9), +LowerIdent(2:5-2:6),OpAssign(2:7-2:8),Int(2:9-2:11), +KwDbg(3:5-3:8),LowerIdent(3:9-3:10), +LowerIdent(4:5-4:6),OpPlus(4:7-4:8),Int(4:9-4:10), +CloseCurly(5:1-5:2), +EndOfFile(6:1-6:1), ~~~ # PARSE ~~~clojure -(file @1.1-7.2 - (module @1.1-1.14 - (exposes @1.8-1.14 - (exposed-lower-ident @1.9-1.13 - (text "main")))) +(file @1.1-5.2 + (type-module @1.1-1.5) (statements - (s-decl @3.1-7.2 - (p-ident @3.1-3.5 (raw "main")) - (e-block @3.8-7.2 + (s-decl @1.1-5.2 + (p-ident @1.1-1.5 (raw "main")) + (e-block @1.8-5.2 (statements - (s-decl @4.5-4.11 - (p-ident @4.5-4.6 (raw "x")) - (e-int @4.9-4.11 (raw "42"))) - (s-dbg @5.5-5.10 - (e-ident @5.9-5.10 (raw "x"))) - (e-binop @6.5-6.10 (op "+") - (e-ident @6.5-6.6 (raw "x")) - (e-int @6.9-6.10 (raw "1")))))))) + (s-decl @2.5-2.11 + (p-ident @2.5-2.6 (raw "x")) + (e-int @2.9-2.11 (raw "42"))) + (s-dbg @3.5-3.10 + (e-ident @3.9-3.10 (raw "x"))) + (e-binop @4.5-4.10 (op "+") + (e-ident @4.5-4.6 (raw "x")) + (e-int @4.9-4.10 (raw "1")))))))) ~~~ # FORMATTED ~~~roc -module [main] - main = { x = 42 dbg x @@ -62,24 +54,24 @@ main = { ~~~clojure (can-ir (d-let - (p-assign @3.1-3.5 (ident "main")) - (e-block @3.8-7.2 - (s-let @4.5-4.11 - (p-assign @4.5-4.6 (ident "x")) - (e-int @4.9-4.11 (value "42"))) - (s-dbg @5.5-5.10 - (e-lookup-local @5.9-5.10 - (p-assign @4.5-4.6 (ident "x")))) - (e-binop @6.5-6.10 (op "add") - (e-lookup-local @6.5-6.6 - (p-assign @4.5-4.6 (ident "x"))) - (e-int @6.9-6.10 (value "1")))))) + (p-assign @1.1-1.5 (ident "main")) + (e-block @1.8-5.2 + (s-let @2.5-2.11 + (p-assign @2.5-2.6 (ident "x")) + (e-num @2.9-2.11 (value "42"))) + (s-dbg @3.5-3.10 + (e-lookup-local @3.9-3.10 + (p-assign @2.5-2.6 (ident "x")))) + (e-binop @4.5-4.10 (op "add") + (e-lookup-local @4.5-4.6 + (p-assign @2.5-2.6 (ident "x"))) + (e-num @4.9-4.10 (value "1")))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @3.1-3.5 (type "Num(_size)"))) + (patt @1.1-1.5 (type "Num(_size)"))) (expressions - (expr @3.8-7.2 (type "Num(_size)")))) + (expr @1.8-5.2 (type "Num(_size)")))) ~~~ diff --git a/test/snapshots/statement/dbg_stmt_not_permitted_top_level.md b/test/snapshots/statement/dbg_stmt_not_permitted_top_level.md index 55675cb365..b46b99fe10 100644 --- a/test/snapshots/statement/dbg_stmt_not_permitted_top_level.md +++ b/test/snapshots/statement/dbg_stmt_not_permitted_top_level.md @@ -1,25 +1,23 @@ # META ~~~ini description=Debug expression not permitted at the top level -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [foo] - # not permitted dbg "foo" foo = ... ~~~ # EXPECTED -INVALID STATEMENT - dbg_stmt_not_permitted_top_level.md:4:1:4:10 +INVALID STATEMENT - dbg_stmt_not_permitted_top_level.md:2:1:2:10 # PROBLEMS **INVALID STATEMENT** The statement `dbg` is not allowed at the top level. Only definitions, type annotations, and imports are allowed at the top level. -**dbg_stmt_not_permitted_top_level.md:4:1:4:10:** +**dbg_stmt_not_permitted_top_level.md:2:1:2:10:** ```roc dbg "foo" ``` @@ -28,42 +26,42 @@ dbg "foo" # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:12),CloseSquare(1:12-1:13), -KwDbg(4:1-4:4),StringStart(4:5-4:6),StringPart(4:6-4:9),StringEnd(4:9-4:10), -LowerIdent(6:1-6:4),OpAssign(6:5-6:6),TripleDot(6:7-6:10), -EndOfFile(7:1-7:1), +KwDbg(2:1-2:4),StringStart(2:5-2:6),StringPart(2:6-2:9),StringEnd(2:9-2:10), +LowerIdent(4:1-4:4),OpAssign(4:5-4:6),TripleDot(4:7-4:10), +EndOfFile(5:1-5:1), ~~~ # PARSE ~~~clojure -(file @1.1-6.10 - (module @1.1-1.13 - (exposes @1.8-1.13 - (exposed-lower-ident @1.9-1.12 - (text "foo")))) +(file @2.1-4.10 + (type-module @2.1-2.4) (statements - (s-dbg @4.1-4.10 - (e-string @4.5-4.10 - (e-string-part @4.6-4.9 (raw "foo")))) - (s-decl @6.1-6.10 - (p-ident @6.1-6.4 (raw "foo")) + (s-dbg @2.1-2.10 + (e-string @2.5-2.10 + (e-string-part @2.6-2.9 (raw "foo")))) + (s-decl @4.1-4.10 + (p-ident @4.1-4.4 (raw "foo")) (e-ellipsis)))) ~~~ # FORMATTED ~~~roc -NO CHANGE +# not permitted +# not permitted +dbg "foo" + +foo = ... ~~~ # CANONICALIZE ~~~clojure (can-ir (d-let - (p-assign @6.1-6.4 (ident "foo")) + (p-assign @4.1-4.4 (ident "foo")) (e-not-implemented @1.1-1.1))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @6.1-6.4 (type "_a"))) + (patt @4.1-4.4 (type "_a"))) (expressions (expr @1.1-1.1 (type "_a")))) ~~~ diff --git a/test/snapshots/statement/expect_stmt_block_assertion.md b/test/snapshots/statement/expect_stmt_block_assertion.md index 7e868334fc..03f1d1f23a 100644 --- a/test/snapshots/statement/expect_stmt_block_assertion.md +++ b/test/snapshots/statement/expect_stmt_block_assertion.md @@ -1,12 +1,10 @@ # META ~~~ini description=Debug expression stmt -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [foo] - foo : Bool -> Bool foo = |a| { expect a == Bool.True @@ -19,43 +17,37 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:12),CloseSquare(1:12-1:13), -LowerIdent(3:1-3:4),OpColon(3:5-3:6),UpperIdent(3:7-3:11),OpArrow(3:12-3:14),UpperIdent(3:15-3:19), -LowerIdent(4:1-4:4),OpAssign(4:5-4:6),OpBar(4:7-4:8),LowerIdent(4:8-4:9),OpBar(4:9-4:10),OpenCurly(4:11-4:12), -KwExpect(5:5-5:11),LowerIdent(5:12-5:13),OpEquals(5:14-5:16),UpperIdent(5:17-5:21),NoSpaceDotUpperIdent(5:21-5:26), -LowerIdent(6:5-6:6), -CloseCurly(7:1-7:2), -EndOfFile(8:1-8:1), +LowerIdent(1:1-1:4),OpColon(1:5-1:6),UpperIdent(1:7-1:11),OpArrow(1:12-1:14),UpperIdent(1:15-1:19), +LowerIdent(2:1-2:4),OpAssign(2:5-2:6),OpBar(2:7-2:8),LowerIdent(2:8-2:9),OpBar(2:9-2:10),OpenCurly(2:11-2:12), +KwExpect(3:5-3:11),LowerIdent(3:12-3:13),OpEquals(3:14-3:16),UpperIdent(3:17-3:21),NoSpaceDotUpperIdent(3:21-3:26), +LowerIdent(4:5-4:6), +CloseCurly(5:1-5:2), +EndOfFile(6:1-6:1), ~~~ # PARSE ~~~clojure -(file @1.1-7.2 - (module @1.1-1.13 - (exposes @1.8-1.13 - (exposed-lower-ident @1.9-1.12 - (text "foo")))) +(file @1.1-5.2 + (type-module @1.1-1.4) (statements - (s-type-anno @3.1-3.19 (name "foo") - (ty-fn @3.7-3.19 - (ty @3.7-3.11 (name "Bool")) - (ty @3.15-3.19 (name "Bool")))) - (s-decl @4.1-7.2 - (p-ident @4.1-4.4 (raw "foo")) - (e-lambda @4.7-7.2 + (s-type-anno @1.1-1.19 (name "foo") + (ty-fn @1.7-1.19 + (ty @1.7-1.11 (name "Bool")) + (ty @1.15-1.19 (name "Bool")))) + (s-decl @2.1-5.2 + (p-ident @2.1-2.4 (raw "foo")) + (e-lambda @2.7-5.2 (args - (p-ident @4.8-4.9 (raw "a"))) - (e-block @4.11-7.2 + (p-ident @2.8-2.9 (raw "a"))) + (e-block @2.11-5.2 (statements - (s-expect @5.5-5.26 - (e-binop @5.12-5.26 (op "==") - (e-ident @5.12-5.13 (raw "a")) - (e-tag @5.17-5.26 (raw "Bool.True")))) - (e-ident @6.5-6.6 (raw "a")))))))) + (s-expect @3.5-3.26 + (e-binop @3.12-3.26 (op "==") + (e-ident @3.12-3.13 (raw "a")) + (e-tag @3.17-3.26 (raw "Bool.True")))) + (e-ident @4.5-4.6 (raw "a")))))))) ~~~ # FORMATTED ~~~roc -module [foo] - foo : Bool -> Bool foo = |a| { expect a == Bool.True @@ -66,30 +58,30 @@ foo = |a| { ~~~clojure (can-ir (d-let - (p-assign @4.1-4.4 (ident "foo")) - (e-lambda @4.7-7.2 + (p-assign @2.1-2.4 (ident "foo")) + (e-lambda @2.7-5.2 (args - (p-assign @4.8-4.9 (ident "a"))) - (e-block @4.11-7.2 - (s-expect @5.5-5.26 - (e-binop @5.12-5.26 (op "eq") - (e-lookup-local @5.12-5.13 - (p-assign @4.8-4.9 (ident "a"))) - (e-nominal @5.17-5.26 (nominal "Bool") - (e-tag @5.17-5.26 (name "True"))))) - (e-lookup-local @6.5-6.6 - (p-assign @4.8-4.9 (ident "a"))))) - (annotation @4.1-4.4 + (p-assign @2.8-2.9 (ident "a"))) + (e-block @2.11-5.2 + (s-expect @3.5-3.26 + (e-binop @3.12-3.26 (op "eq") + (e-lookup-local @3.12-3.13 + (p-assign @2.8-2.9 (ident "a"))) + (e-nominal @3.17-3.26 (nominal "Bool") + (e-tag @3.17-3.26 (name "True"))))) + (e-lookup-local @4.5-4.6 + (p-assign @2.8-2.9 (ident "a"))))) + (annotation @2.1-2.4 (declared-type - (ty-fn @3.7-3.19 (effectful false) - (ty @3.7-3.11 (name "Bool")) - (ty @3.15-3.19 (name "Bool"))))))) + (ty-fn @1.7-1.19 (effectful false) + (ty-lookup @1.7-1.11 (name "Bool") (local)) + (ty-lookup @1.15-1.19 (name "Bool") (local))))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @4.1-4.4 (type "Bool -> Bool"))) + (patt @2.1-2.4 (type "Bool -> Bool"))) (expressions - (expr @4.7-7.2 (type "Bool -> Bool")))) + (expr @2.7-5.2 (type "Bool -> Bool")))) ~~~ diff --git a/test/snapshots/statement/expect_stmt_top_level.md b/test/snapshots/statement/expect_stmt_top_level.md index b4f6701d2f..027e46f7f7 100644 --- a/test/snapshots/statement/expect_stmt_top_level.md +++ b/test/snapshots/statement/expect_stmt_top_level.md @@ -1,12 +1,10 @@ # META ~~~ini description=Debug expression stmt -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [foo] - foo = Bool.True expect foo != Bool.False @@ -17,26 +15,22 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:12),CloseSquare(1:12-1:13), -LowerIdent(3:1-3:4),OpAssign(3:5-3:6),UpperIdent(3:7-3:11),NoSpaceDotUpperIdent(3:11-3:16), -KwExpect(5:1-5:7),LowerIdent(5:8-5:11),OpNotEquals(5:12-5:14),UpperIdent(5:15-5:19),NoSpaceDotUpperIdent(5:19-5:25), -EndOfFile(6:1-6:1), +LowerIdent(1:1-1:4),OpAssign(1:5-1:6),UpperIdent(1:7-1:11),NoSpaceDotUpperIdent(1:11-1:16), +KwExpect(3:1-3:7),LowerIdent(3:8-3:11),OpNotEquals(3:12-3:14),UpperIdent(3:15-3:19),NoSpaceDotUpperIdent(3:19-3:25), +EndOfFile(4:1-4:1), ~~~ # PARSE ~~~clojure -(file @1.1-5.25 - (module @1.1-1.13 - (exposes @1.8-1.13 - (exposed-lower-ident @1.9-1.12 - (text "foo")))) +(file @1.1-3.25 + (type-module @1.1-1.4) (statements - (s-decl @3.1-3.16 - (p-ident @3.1-3.4 (raw "foo")) - (e-tag @3.7-3.16 (raw "Bool.True"))) - (s-expect @5.1-5.25 - (e-binop @5.8-5.25 (op "!=") - (e-ident @5.8-5.11 (raw "foo")) - (e-tag @5.15-5.25 (raw "Bool.False")))))) + (s-decl @1.1-1.16 + (p-ident @1.1-1.4 (raw "foo")) + (e-tag @1.7-1.16 (raw "Bool.True"))) + (s-expect @3.1-3.25 + (e-binop @3.8-3.25 (op "!=") + (e-ident @3.8-3.11 (raw "foo")) + (e-tag @3.15-3.25 (raw "Bool.False")))))) ~~~ # FORMATTED ~~~roc @@ -46,21 +40,21 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @3.1-3.4 (ident "foo")) - (e-nominal @3.7-3.16 (nominal "Bool") - (e-tag @3.7-3.16 (name "True")))) - (s-expect @5.1-5.25 - (e-binop @5.8-5.25 (op "ne") - (e-lookup-local @5.8-5.11 - (p-assign @3.1-3.4 (ident "foo"))) - (e-nominal @5.15-5.25 (nominal "Bool") - (e-tag @5.15-5.25 (name "False")))))) + (p-assign @1.1-1.4 (ident "foo")) + (e-nominal @1.7-1.16 (nominal "Bool") + (e-tag @1.7-1.16 (name "True")))) + (s-expect @3.1-3.25 + (e-binop @3.8-3.25 (op "ne") + (e-lookup-local @3.8-3.11 + (p-assign @1.1-1.4 (ident "foo"))) + (e-nominal @3.15-3.25 (nominal "Bool") + (e-tag @3.15-3.25 (name "False")))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @3.1-3.4 (type "Bool"))) + (patt @1.1-1.4 (type "Bool"))) (expressions - (expr @3.7-3.16 (type "Bool")))) + (expr @1.7-1.16 (type "Bool")))) ~~~ diff --git a/test/snapshots/statement/return_stmt_block_example.md b/test/snapshots/statement/return_stmt_block_example.md index 2b188d1f96..c06f791205 100644 --- a/test/snapshots/statement/return_stmt_block_example.md +++ b/test/snapshots/statement/return_stmt_block_example.md @@ -1,12 +1,10 @@ # META ~~~ini description=Return statement in a block context -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [foo] - foo : U64 -> Result(Str, [TooBig]) foo = |num| { str = if (num > 10) { @@ -18,11 +16,11 @@ foo = |num| { } ~~~ # EXPECTED -INCOMPATIBLE IF BRANCHES - return_stmt_block_example.md:5:11:5:11 +INCOMPATIBLE IF BRANCHES - return_stmt_block_example.md:3:11:3:11 # PROBLEMS **INCOMPATIBLE IF BRANCHES** This `if` has an `else` branch with a different type from it's `then` branch: -**return_stmt_block_example.md:5:11:** +**return_stmt_block_example.md:3:11:** ```roc str = if (num > 10) { return Err(TooBig) @@ -45,67 +43,61 @@ To learn about tags, see # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:12),CloseSquare(1:12-1:13), -LowerIdent(3:1-3:4),OpColon(3:5-3:6),UpperIdent(3:7-3:10),OpArrow(3:11-3:13),UpperIdent(3:14-3:20),NoSpaceOpenRound(3:20-3:21),UpperIdent(3:21-3:24),Comma(3:24-3:25),OpenSquare(3:26-3:27),UpperIdent(3:27-3:33),CloseSquare(3:33-3:34),CloseRound(3:34-3:35), -LowerIdent(4:1-4:4),OpAssign(4:5-4:6),OpBar(4:7-4:8),LowerIdent(4:8-4:11),OpBar(4:11-4:12),OpenCurly(4:13-4:14), -LowerIdent(5:5-5:8),OpAssign(5:9-5:10),KwIf(5:11-5:13),OpenRound(5:14-5:15),LowerIdent(5:15-5:18),OpGreaterThan(5:19-5:20),Int(5:21-5:23),CloseRound(5:23-5:24),OpenCurly(5:25-5:26), -KwReturn(6:9-6:15),UpperIdent(6:16-6:19),NoSpaceOpenRound(6:19-6:20),UpperIdent(6:20-6:26),CloseRound(6:26-6:27), -CloseCurly(7:5-7:6),KwElse(7:7-7:11),OpenCurly(7:12-7:13), -StringStart(8:9-8:10),StringPart(8:10-8:15),StringEnd(8:15-8:16), -CloseCurly(9:5-9:6), -UpperIdent(10:5-10:7),NoSpaceOpenRound(10:7-10:8),LowerIdent(10:8-10:11),CloseRound(10:11-10:12), -CloseCurly(11:1-11:2), -EndOfFile(12:1-12:1), +LowerIdent(1:1-1:4),OpColon(1:5-1:6),UpperIdent(1:7-1:10),OpArrow(1:11-1:13),UpperIdent(1:14-1:20),NoSpaceOpenRound(1:20-1:21),UpperIdent(1:21-1:24),Comma(1:24-1:25),OpenSquare(1:26-1:27),UpperIdent(1:27-1:33),CloseSquare(1:33-1:34),CloseRound(1:34-1:35), +LowerIdent(2:1-2:4),OpAssign(2:5-2:6),OpBar(2:7-2:8),LowerIdent(2:8-2:11),OpBar(2:11-2:12),OpenCurly(2:13-2:14), +LowerIdent(3:5-3:8),OpAssign(3:9-3:10),KwIf(3:11-3:13),OpenRound(3:14-3:15),LowerIdent(3:15-3:18),OpGreaterThan(3:19-3:20),Int(3:21-3:23),CloseRound(3:23-3:24),OpenCurly(3:25-3:26), +KwReturn(4:9-4:15),UpperIdent(4:16-4:19),NoSpaceOpenRound(4:19-4:20),UpperIdent(4:20-4:26),CloseRound(4:26-4:27), +CloseCurly(5:5-5:6),KwElse(5:7-5:11),OpenCurly(5:12-5:13), +StringStart(6:9-6:10),StringPart(6:10-6:15),StringEnd(6:15-6:16), +CloseCurly(7:5-7:6), +UpperIdent(8:5-8:7),NoSpaceOpenRound(8:7-8:8),LowerIdent(8:8-8:11),CloseRound(8:11-8:12), +CloseCurly(9:1-9:2), +EndOfFile(10:1-10:1), ~~~ # PARSE ~~~clojure -(file @1.1-11.2 - (module @1.1-1.13 - (exposes @1.8-1.13 - (exposed-lower-ident @1.9-1.12 - (text "foo")))) +(file @1.1-9.2 + (type-module @1.1-1.4) (statements - (s-type-anno @3.1-3.35 (name "foo") - (ty-fn @3.7-3.35 - (ty @3.7-3.10 (name "U64")) - (ty-apply @3.14-3.35 - (ty @3.14-3.20 (name "Result")) - (ty @3.21-3.24 (name "Str")) - (ty-tag-union @3.26-3.34 + (s-type-anno @1.1-1.35 (name "foo") + (ty-fn @1.7-1.35 + (ty @1.7-1.10 (name "U64")) + (ty-apply @1.14-1.35 + (ty @1.14-1.20 (name "Result")) + (ty @1.21-1.24 (name "Str")) + (ty-tag-union @1.26-1.34 (tags - (ty @3.27-3.33 (name "TooBig"))))))) - (s-decl @4.1-11.2 - (p-ident @4.1-4.4 (raw "foo")) - (e-lambda @4.7-11.2 + (ty @1.27-1.33 (name "TooBig"))))))) + (s-decl @2.1-9.2 + (p-ident @2.1-2.4 (raw "foo")) + (e-lambda @2.7-9.2 (args - (p-ident @4.8-4.11 (raw "num"))) - (e-block @4.13-11.2 + (p-ident @2.8-2.11 (raw "num"))) + (e-block @2.13-9.2 (statements - (s-decl @5.5-9.6 - (p-ident @5.5-5.8 (raw "str")) - (e-if-then-else @5.11-9.6 - (e-tuple @5.14-5.24 - (e-binop @5.15-5.23 (op ">") - (e-ident @5.15-5.18 (raw "num")) - (e-int @5.21-5.23 (raw "10")))) - (e-block @5.25-7.6 + (s-decl @3.5-7.6 + (p-ident @3.5-3.8 (raw "str")) + (e-if-then-else @3.11-7.6 + (e-tuple @3.14-3.24 + (e-binop @3.15-3.23 (op ">") + (e-ident @3.15-3.18 (raw "num")) + (e-int @3.21-3.23 (raw "10")))) + (e-block @3.25-5.6 (statements - (s-return @6.9-6.27 - (e-apply @6.16-6.27 - (e-tag @6.16-6.19 (raw "Err")) - (e-tag @6.20-6.26 (raw "TooBig")))))) - (e-block @7.12-9.6 + (s-return @4.9-4.27 + (e-apply @4.16-4.27 + (e-tag @4.16-4.19 (raw "Err")) + (e-tag @4.20-4.26 (raw "TooBig")))))) + (e-block @5.12-7.6 (statements - (e-string @8.9-8.16 - (e-string-part @8.10-8.15 (raw "SMALL"))))))) - (e-apply @10.5-10.12 - (e-tag @10.5-10.7 (raw "Ok")) - (e-ident @10.8-10.11 (raw "str"))))))))) + (e-string @6.9-6.16 + (e-string-part @6.10-6.15 (raw "SMALL"))))))) + (e-apply @8.5-8.12 + (e-tag @8.5-8.7 (raw "Ok")) + (e-ident @8.8-8.11 (raw "str"))))))))) ~~~ # FORMATTED ~~~roc -module [foo] - foo : U64 -> Result(Str, [TooBig]) foo = |num| { str = if (num > 10) { @@ -120,48 +112,48 @@ foo = |num| { ~~~clojure (can-ir (d-let - (p-assign @4.1-4.4 (ident "foo")) - (e-lambda @4.7-11.2 + (p-assign @2.1-2.4 (ident "foo")) + (e-lambda @2.7-9.2 (args - (p-assign @4.8-4.11 (ident "num"))) - (e-block @4.13-11.2 - (s-let @5.5-9.6 - (p-assign @5.5-5.8 (ident "str")) - (e-if @5.11-9.6 + (p-assign @2.8-2.11 (ident "num"))) + (e-block @2.13-9.2 + (s-let @3.5-7.6 + (p-assign @3.5-3.8 (ident "str")) + (e-if @3.11-7.6 (if-branches (if-branch - (e-binop @5.15-5.23 (op "gt") - (e-lookup-local @5.15-5.18 - (p-assign @4.8-4.11 (ident "num"))) - (e-int @5.21-5.23 (value "10"))) - (e-block @5.25-7.6 - (e-nominal @6.16-6.27 (nominal "Result") - (e-tag @6.16-6.27 (name "Err") + (e-binop @3.15-3.23 (op "gt") + (e-lookup-local @3.15-3.18 + (p-assign @2.8-2.11 (ident "num"))) + (e-num @3.21-3.23 (value "10"))) + (e-block @3.25-5.6 + (e-nominal @4.16-4.27 (nominal "Result") + (e-tag @4.16-4.27 (name "Err") (args - (e-tag @6.20-6.26 (name "TooBig")))))))) + (e-tag @4.20-4.26 (name "TooBig")))))))) (if-else - (e-block @7.12-9.6 - (e-string @8.9-8.16 - (e-literal @8.10-8.15 (string "SMALL"))))))) - (e-nominal @10.5-10.12 (nominal "Result") - (e-tag @10.5-10.12 (name "Ok") + (e-block @5.12-7.6 + (e-string @6.9-6.16 + (e-literal @6.10-6.15 (string "SMALL"))))))) + (e-nominal @8.5-8.12 (nominal "Result") + (e-tag @8.5-8.12 (name "Ok") (args - (e-lookup-local @10.8-10.11 - (p-assign @5.5-5.8 (ident "str")))))))) - (annotation @4.1-4.4 + (e-lookup-local @8.8-8.11 + (p-assign @3.5-3.8 (ident "str")))))))) + (annotation @2.1-2.4 (declared-type - (ty-fn @3.7-3.35 (effectful false) - (ty @3.7-3.10 (name "U64")) - (ty-apply @3.14-3.35 (symbol "Result") - (ty @3.21-3.24 (name "Str")) - (ty-tag-union @3.26-3.34 - (ty @3.27-3.33 (name "TooBig"))))))))) + (ty-fn @1.7-1.35 (effectful false) + (ty-lookup @1.7-1.10 (name "U64") (builtin)) + (ty-apply @1.14-1.35 (name "Result") (local) + (ty-lookup @1.14-1.35 (name "Str") (builtin)) + (ty-tag-union @1.14-1.35 + (ty-tag-name @1.27-1.33 (name "TooBig"))))))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @4.1-4.4 (type "U64 -> Result(Error, [TooBig])"))) + (patt @2.1-2.4 (type "Num(Int(Unsigned64)) -> Result(Error, [TooBig])"))) (expressions - (expr @4.7-11.2 (type "U64 -> Result(Error, [TooBig])")))) + (expr @2.7-9.2 (type "Num(Int(Unsigned64)) -> Result(Error, [TooBig])")))) ~~~ diff --git a/test/snapshots/statement_annotations.md b/test/snapshots/statement_annotations.md index 2eb7e20f19..2e282ab16d 100644 --- a/test/snapshots/statement_annotations.md +++ b/test/snapshots/statement_annotations.md @@ -1,164 +1,119 @@ # META ~~~ini description=Inline annotation for statements -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] +scopedTypeVarInternal : val -> val +scopedTypeVarInternal = |a| { + b : other_val -> other_val + b = |c| { + d : other_val + d = c -addOneU64 = |x| { - y : U64 - y = x + 1 + d + } - y -} - -func : val -> val -func = |x| { - y : val - y = x - - y + b(a) } ~~~ # EXPECTED -TYPE MISMATCH - statement_annotations.md:13:7:13:8 +NIL # PROBLEMS -**TYPE MISMATCH** -This expression is used in an unexpected way: -**statement_annotations.md:13:7:13:8:** -```roc - y = x -``` - ^ - -The type annotation says it should have the type: - _val_ - -But here it's being used as: - _val_ - +NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -LowerIdent(3:1-3:10),OpAssign(3:11-3:12),OpBar(3:13-3:14),LowerIdent(3:14-3:15),OpBar(3:15-3:16),OpenCurly(3:17-3:18), -LowerIdent(4:3-4:4),OpColon(4:5-4:6),UpperIdent(4:7-4:10), -LowerIdent(5:3-5:4),OpAssign(5:5-5:6),LowerIdent(5:7-5:8),OpPlus(5:9-5:10),Int(5:11-5:12), -LowerIdent(7:3-7:4), -CloseCurly(8:1-8:2), -LowerIdent(10:1-10:5),OpColon(10:6-10:7),LowerIdent(10:8-10:11),OpArrow(10:12-10:14),LowerIdent(10:15-10:18), -LowerIdent(11:1-11:5),OpAssign(11:6-11:7),OpBar(11:8-11:9),LowerIdent(11:9-11:10),OpBar(11:10-11:11),OpenCurly(11:12-11:13), -LowerIdent(12:3-12:4),OpColon(12:5-12:6),LowerIdent(12:7-12:10), -LowerIdent(13:3-13:4),OpAssign(13:5-13:6),LowerIdent(13:7-13:8), -LowerIdent(15:3-15:4), -CloseCurly(16:1-16:2), -EndOfFile(17:1-17:1), +LowerIdent(1:1-1:22),OpColon(1:23-1:24),LowerIdent(1:25-1:28),OpArrow(1:29-1:31),LowerIdent(1:32-1:35), +LowerIdent(2:1-2:22),OpAssign(2:23-2:24),OpBar(2:25-2:26),LowerIdent(2:26-2:27),OpBar(2:27-2:28),OpenCurly(2:29-2:30), +LowerIdent(3:2-3:3),OpColon(3:4-3:5),LowerIdent(3:6-3:15),OpArrow(3:16-3:18),LowerIdent(3:19-3:28), +LowerIdent(4:2-4:3),OpAssign(4:4-4:5),OpBar(4:6-4:7),LowerIdent(4:7-4:8),OpBar(4:8-4:9),OpenCurly(4:10-4:11), +LowerIdent(5:3-5:4),OpColon(5:5-5:6),LowerIdent(5:7-5:16), +LowerIdent(6:3-6:4),OpAssign(6:5-6:6),LowerIdent(6:7-6:8), +LowerIdent(8:3-8:4), +CloseCurly(9:2-9:3), +LowerIdent(11:2-11:3),NoSpaceOpenRound(11:3-11:4),LowerIdent(11:4-11:5),CloseRound(11:5-11:6), +CloseCurly(12:1-12:2), +EndOfFile(13:1-13:1), ~~~ # PARSE ~~~clojure -(file @1.1-16.2 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-12.2 + (type-module @1.1-1.22) (statements - (s-decl @3.1-8.2 - (p-ident @3.1-3.10 (raw "addOneU64")) - (e-lambda @3.13-8.2 + (s-type-anno @1.1-1.35 (name "scopedTypeVarInternal") + (ty-fn @1.25-1.35 + (ty-var @1.25-1.28 (raw "val")) + (ty-var @1.32-1.35 (raw "val")))) + (s-decl @2.1-12.2 + (p-ident @2.1-2.22 (raw "scopedTypeVarInternal")) + (e-lambda @2.25-12.2 (args - (p-ident @3.14-3.15 (raw "x"))) - (e-block @3.17-8.2 + (p-ident @2.26-2.27 (raw "a"))) + (e-block @2.29-12.2 (statements - (s-type-anno @4.3-4.10 (name "y") - (ty @4.7-4.10 (name "U64"))) - (s-decl @5.3-5.12 - (p-ident @5.3-5.4 (raw "y")) - (e-binop @5.7-5.12 (op "+") - (e-ident @5.7-5.8 (raw "x")) - (e-int @5.11-5.12 (raw "1")))) - (e-ident @7.3-7.4 (raw "y")))))) - (s-type-anno @10.1-10.18 (name "func") - (ty-fn @10.8-10.18 - (ty-var @10.8-10.11 (raw "val")) - (ty-var @10.15-10.18 (raw "val")))) - (s-decl @11.1-16.2 - (p-ident @11.1-11.5 (raw "func")) - (e-lambda @11.8-16.2 - (args - (p-ident @11.9-11.10 (raw "x"))) - (e-block @11.12-16.2 - (statements - (s-type-anno @12.3-12.10 (name "y") - (ty-var @12.7-12.10 (raw "val"))) - (s-decl @13.3-13.8 - (p-ident @13.3-13.4 (raw "y")) - (e-ident @13.7-13.8 (raw "x"))) - (e-ident @15.3-15.4 (raw "y")))))))) + (s-type-anno @3.2-3.28 (name "b") + (ty-fn @3.6-3.28 + (ty-var @3.6-3.15 (raw "other_val")) + (ty-var @3.19-3.28 (raw "other_val")))) + (s-decl @4.2-9.3 + (p-ident @4.2-4.3 (raw "b")) + (e-lambda @4.6-9.3 + (args + (p-ident @4.7-4.8 (raw "c"))) + (e-block @4.10-9.3 + (statements + (s-type-anno @5.3-5.16 (name "d") + (ty-var @5.7-5.16 (raw "other_val"))) + (s-decl @6.3-6.8 + (p-ident @6.3-6.4 (raw "d")) + (e-ident @6.7-6.8 (raw "c"))) + (e-ident @8.3-8.4 (raw "d")))))) + (e-apply @11.2-11.6 + (e-ident @11.2-11.3 (raw "b")) + (e-ident @11.4-11.5 (raw "a"))))))))) ~~~ # FORMATTED ~~~roc -module [] - -addOneU64 = |x| { - y : U64 - y = x + 1 - - y -} - -func : val -> val -func = |x| { - y : val - y = x - - y -} +NO CHANGE ~~~ # CANONICALIZE ~~~clojure (can-ir (d-let - (p-assign @3.1-3.10 (ident "addOneU64")) - (e-lambda @3.13-8.2 + (p-assign @2.1-2.22 (ident "scopedTypeVarInternal")) + (e-lambda @2.25-12.2 (args - (p-assign @3.14-3.15 (ident "x"))) - (e-block @3.17-8.2 - (s-type-anno @4.3-4.10 (name "y") - (ty @4.7-4.10 (name "U64"))) - (s-let @5.3-5.12 - (p-assign @5.3-5.4 (ident "y")) - (e-binop @5.7-5.12 (op "add") - (e-lookup-local @5.7-5.8 - (p-assign @3.14-3.15 (ident "x"))) - (e-int @5.11-5.12 (value "1")))) - (e-lookup-local @7.3-7.4 - (p-assign @5.3-5.4 (ident "y")))))) - (d-let - (p-assign @11.1-11.5 (ident "func")) - (e-lambda @11.8-16.2 - (args - (p-assign @11.9-11.10 (ident "x"))) - (e-block @11.12-16.2 - (s-type-anno @12.3-12.10 (name "y") - (ty-var @12.7-12.10 (name "val"))) - (s-let @13.3-13.8 - (p-assign @13.3-13.4 (ident "y")) - (e-lookup-local @13.7-13.8 - (p-assign @11.9-11.10 (ident "x")))) - (e-lookup-local @15.3-15.4 - (p-assign @13.3-13.4 (ident "y"))))) - (annotation @11.1-11.5 + (p-assign @2.26-2.27 (ident "a"))) + (e-block @2.29-12.2 + (s-let @4.2-9.3 + (p-assign @4.2-4.3 (ident "b")) + (e-lambda @4.6-9.3 + (args + (p-assign @4.7-4.8 (ident "c"))) + (e-block @4.10-9.3 + (s-let @6.3-6.8 + (p-assign @6.3-6.4 (ident "d")) + (e-lookup-local @6.7-6.8 + (p-assign @4.7-4.8 (ident "c")))) + (e-lookup-local @8.3-8.4 + (p-assign @6.3-6.4 (ident "d")))))) + (e-call @11.2-11.6 + (e-lookup-local @11.2-11.3 + (p-assign @4.2-4.3 (ident "b"))) + (e-lookup-local @11.4-11.5 + (p-assign @2.26-2.27 (ident "a")))))) + (annotation @2.1-2.22 (declared-type - (ty-fn @10.8-10.18 (effectful false) - (ty-var @10.8-10.11 (name "val")) - (ty-var @10.15-10.18 (name "val"))))))) + (ty-fn @1.25-1.35 (effectful false) + (ty-rigid-var @1.25-1.28 (name "val")) + (ty-rigid-var-lookup (ty-rigid-var @1.25-1.28 (name "val")))))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @3.1-3.10 (type "U64 -> U64")) - (patt @11.1-11.5 (type "Error -> Error"))) + (patt @2.1-2.22 (type "val -> val"))) (expressions - (expr @3.13-8.2 (type "U64 -> U64")) - (expr @11.8-16.2 (type "Error -> Error")))) + (expr @2.25-12.2 (type "val -> val")))) ~~~ diff --git a/test/snapshots/string.md b/test/snapshots/string.md index 1ce05c1168..c4c438b58b 100644 --- a/test/snapshots/string.md +++ b/test/snapshots/string.md @@ -1,12 +1,10 @@ # META ~~~ini description=two strings -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - x = ( "one", "two", @@ -29,9 +27,9 @@ INVALID UNICODE ESCAPE SEQUENCE - :0:0:0:0 INVALID UNICODE ESCAPE SEQUENCE - :0:0:0:0 INVALID ESCAPE SEQUENCE - :0:0:0:0 UNCLOSED STRING - :0:0:0:0 -PARSE ERROR - string.md:15:1:15:2 -PARSE ERROR - string.md:15:2:15:3 -PARSE ERROR - string.md:15:3:15:3 +PARSE ERROR - string.md:13:1:13:2 +PARSE ERROR - string.md:13:2:13:3 +PARSE ERROR - string.md:13:3:13:3 # PROBLEMS **INVALID UNICODE ESCAPE SEQUENCE** This Unicode escape sequence is not valid. @@ -100,7 +98,7 @@ This string is missing a closing quote. A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**string.md:15:1:15:2:** +**string.md:13:1:13:2:** ```roc "\ ``` @@ -111,7 +109,7 @@ This is an unexpected parsing error. Please check your syntax. A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**string.md:15:2:15:3:** +**string.md:13:2:13:3:** ```roc "\ ``` @@ -122,7 +120,7 @@ This is an unexpected parsing error. Please check your syntax. A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**string.md:15:3:15:3:** +**string.md:13:3:13:3:** ```roc "\ ``` @@ -131,48 +129,44 @@ This is an unexpected parsing error. Please check your syntax. # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -LowerIdent(3:1-3:2),OpAssign(3:3-3:4),OpenRound(3:5-3:6), -StringStart(4:2-4:3),StringPart(4:3-4:6),StringEnd(4:6-4:7),Comma(4:7-4:8), -StringStart(5:2-5:3),StringPart(5:3-5:6),StringEnd(5:6-5:7),Comma(5:7-5:8), -StringStart(6:2-6:3),MalformedStringPart(6:3-6:5),StringEnd(6:5-6:6),Comma(6:6-6:7), -StringStart(7:2-7:3),MalformedStringPart(7:3-7:6),StringEnd(7:6-7:7),Comma(7:7-7:8), -StringStart(8:2-8:3),MalformedStringPart(8:3-8:6),StringEnd(8:6-8:7),Comma(8:7-8:8), -StringStart(9:2-9:3),MalformedStringPart(9:3-9:7),StringEnd(9:7-9:8),Comma(9:8-9:9), -StringStart(10:2-10:3),MalformedStringPart(10:3-10:8),StringEnd(10:8-10:9),Comma(10:9-10:10), -StringStart(11:2-11:3),StringPart(11:3-11:12),StringEnd(11:12-11:13),Comma(11:13-11:14), -CloseRound(12:1-12:2), -StringStart(15:1-15:2),MalformedStringPart(15:2-15:3),StringEnd(15:3-15:3), -EndOfFile(16:1-16:1), +LowerIdent(1:1-1:2),OpAssign(1:3-1:4),OpenRound(1:5-1:6), +StringStart(2:2-2:3),StringPart(2:3-2:6),StringEnd(2:6-2:7),Comma(2:7-2:8), +StringStart(3:2-3:3),StringPart(3:3-3:6),StringEnd(3:6-3:7),Comma(3:7-3:8), +StringStart(4:2-4:3),MalformedStringPart(4:3-4:5),StringEnd(4:5-4:6),Comma(4:6-4:7), +StringStart(5:2-5:3),MalformedStringPart(5:3-5:6),StringEnd(5:6-5:7),Comma(5:7-5:8), +StringStart(6:2-6:3),MalformedStringPart(6:3-6:6),StringEnd(6:6-6:7),Comma(6:7-6:8), +StringStart(7:2-7:3),MalformedStringPart(7:3-7:7),StringEnd(7:7-7:8),Comma(7:8-7:9), +StringStart(8:2-8:3),MalformedStringPart(8:3-8:8),StringEnd(8:8-8:9),Comma(8:9-8:10), +StringStart(9:2-9:3),StringPart(9:3-9:12),StringEnd(9:12-9:13),Comma(9:13-9:14), +CloseRound(10:1-10:2), +StringStart(13:1-13:2),MalformedStringPart(13:2-13:3),StringEnd(13:3-13:3), +EndOfFile(14:1-14:1), ~~~ # PARSE ~~~clojure -(file @1.1-15.3 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-13.3 + (type-module @1.1-1.2) (statements - (s-decl @3.1-12.2 - (p-ident @3.1-3.2 (raw "x")) - (e-tuple @3.5-12.2 - (e-string @4.2-4.7 - (e-string-part @4.3-4.6 (raw "one"))) - (e-string @5.2-5.7 - (e-string-part @5.3-5.6 (raw "two"))) - (e-string @6.2-6.6) - (e-string @7.2-7.7) - (e-string @8.2-8.7) - (e-string @9.2-9.8) - (e-string @10.2-10.9) - (e-string @11.2-11.13 - (e-string-part @11.3-11.12 (raw "\u(1F680)"))))) - (s-malformed @15.1-15.2 (tag "statement_unexpected_token")) - (s-malformed @15.2-15.3 (tag "statement_unexpected_token")) - (s-malformed @15.3-15.3 (tag "statement_unexpected_token")))) + (s-decl @1.1-10.2 + (p-ident @1.1-1.2 (raw "x")) + (e-tuple @1.5-10.2 + (e-string @2.2-2.7 + (e-string-part @2.3-2.6 (raw "one"))) + (e-string @3.2-3.7 + (e-string-part @3.3-3.6 (raw "two"))) + (e-string @4.2-4.6) + (e-string @5.2-5.7) + (e-string @6.2-6.7) + (e-string @7.2-7.8) + (e-string @8.2-8.9) + (e-string @9.2-9.13 + (e-string-part @9.3-9.12 (raw "\u(1F680)"))))) + (s-malformed @13.1-13.2 (tag "statement_unexpected_token")) + (s-malformed @13.2-13.3 (tag "statement_unexpected_token")) + (s-malformed @13.3-13.3 (tag "statement_unexpected_token")))) ~~~ # FORMATTED ~~~roc -module [] - x = ( "one", "two", @@ -190,26 +184,26 @@ x = ( ~~~clojure (can-ir (d-let - (p-assign @3.1-3.2 (ident "x")) - (e-tuple @3.5-12.2 + (p-assign @1.1-1.2 (ident "x")) + (e-tuple @1.5-10.2 (elems - (e-string @4.2-4.7 - (e-literal @4.3-4.6 (string "one"))) - (e-string @5.2-5.7 - (e-literal @5.3-5.6 (string "two"))) - (e-string @6.2-6.6) - (e-string @7.2-7.7) - (e-string @8.2-8.7) - (e-string @9.2-9.8) - (e-string @10.2-10.9) - (e-string @11.2-11.13 - (e-literal @11.3-11.12 (string "\u(1F680)"))))))) + (e-string @2.2-2.7 + (e-literal @2.3-2.6 (string "one"))) + (e-string @3.2-3.7 + (e-literal @3.3-3.6 (string "two"))) + (e-string @4.2-4.6) + (e-string @5.2-5.7) + (e-string @6.2-6.7) + (e-string @7.2-7.8) + (e-string @8.2-8.9) + (e-string @9.2-9.13 + (e-literal @9.3-9.12 (string "\u(1F680)"))))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @3.1-3.2 (type "(Str, Str, Str, Str, Str, Str, Str, Str)"))) + (patt @1.1-1.2 (type "(Str, Str, Str, Str, Str, Str, Str, Str)"))) (expressions - (expr @3.5-12.2 (type "(Str, Str, Str, Str, Str, Str, Str, Str)")))) + (expr @1.5-10.2 (type "(Str, Str, Str, Str, Str, Str, Str, Str)")))) ~~~ diff --git a/test/snapshots/string_unicode_emoji.md b/test/snapshots/string_unicode_emoji.md index fdb979c327..cfb515e038 100644 --- a/test/snapshots/string_unicode_emoji.md +++ b/test/snapshots/string_unicode_emoji.md @@ -1,12 +1,10 @@ # META ~~~ini description=Ensure string literals handle Unicode emojis and characters properly. -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [message, greet] - # Test that Unicode emojis are properly handled in string literals message = "Hello! Here are some emojis: 👻 🎉 🚀" @@ -19,53 +17,52 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:16),Comma(1:16-1:17),LowerIdent(1:18-1:23),CloseSquare(1:23-1:24), -LowerIdent(4:1-4:8),OpAssign(4:9-4:10),StringStart(4:11-4:12),StringPart(4:12-4:55),StringEnd(4:55-4:56), -LowerIdent(7:1-7:6),OpAssign(7:7-7:8),StringStart(7:9-7:10),StringPart(7:10-7:84),StringEnd(7:84-7:85), -EndOfFile(8:1-8:1), +LowerIdent(2:1-2:8),OpAssign(2:9-2:10),StringStart(2:11-2:12),StringPart(2:12-2:55),StringEnd(2:55-2:56), +LowerIdent(5:1-5:6),OpAssign(5:7-5:8),StringStart(5:9-5:10),StringPart(5:10-5:84),StringEnd(5:84-5:85), +EndOfFile(6:1-6:1), ~~~ # PARSE ~~~clojure -(file @1.1-7.85 - (module @1.1-1.24 - (exposes @1.8-1.24 - (exposed-lower-ident @1.9-1.16 - (text "message")) - (exposed-lower-ident @1.18-1.23 - (text "greet")))) +(file @2.1-5.85 + (type-module @2.1-2.8) (statements - (s-decl @4.1-4.56 - (p-ident @4.1-4.8 (raw "message")) - (e-string @4.11-4.56 - (e-string-part @4.12-4.55 (raw "Hello! Here are some emojis: 👻 🎉 🚀")))) - (s-decl @7.1-7.85 - (p-ident @7.1-7.6 (raw "greet")) - (e-string @7.9-7.85 - (e-string-part @7.10-7.84 (raw "Welcome! café résumé naïve 你好 こんにちは α β γ ∑ ∫ ∞")))))) + (s-decl @2.1-2.56 + (p-ident @2.1-2.8 (raw "message")) + (e-string @2.11-2.56 + (e-string-part @2.12-2.55 (raw "Hello! Here are some emojis: 👻 🎉 🚀")))) + (s-decl @5.1-5.85 + (p-ident @5.1-5.6 (raw "greet")) + (e-string @5.9-5.85 + (e-string-part @5.10-5.84 (raw "Welcome! café résumé naïve 你好 こんにちは α β γ ∑ ∫ ∞")))))) ~~~ # FORMATTED ~~~roc -NO CHANGE +# Test that Unicode emojis are properly handled in string literals +# Test that Unicode emojis are properly handled in string literals +message = "Hello! Here are some emojis: 👻 🎉 🚀" + +# Test other Unicode characters +greet = "Welcome! café résumé naïve 你好 こんにちは α β γ ∑ ∫ ∞" ~~~ # CANONICALIZE ~~~clojure (can-ir (d-let - (p-assign @4.1-4.8 (ident "message")) - (e-string @4.11-4.56 - (e-literal @4.12-4.55 (string "Hello! Here are some emojis: 👻 🎉 🚀")))) + (p-assign @2.1-2.8 (ident "message")) + (e-string @2.11-2.56 + (e-literal @2.12-2.55 (string "Hello! Here are some emojis: 👻 🎉 🚀")))) (d-let - (p-assign @7.1-7.6 (ident "greet")) - (e-string @7.9-7.85 - (e-literal @7.10-7.84 (string "Welcome! café résumé naïve 你好 こんにちは α β γ ∑ ∫ ∞"))))) + (p-assign @5.1-5.6 (ident "greet")) + (e-string @5.9-5.85 + (e-literal @5.10-5.84 (string "Welcome! café résumé naïve 你好 こんにちは α β γ ∑ ∫ ∞"))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @4.1-4.8 (type "Str")) - (patt @7.1-7.6 (type "Str"))) + (patt @2.1-2.8 (type "Str")) + (patt @5.1-5.6 (type "Str"))) (expressions - (expr @4.11-4.56 (type "Str")) - (expr @7.9-7.85 (type "Str")))) + (expr @2.11-2.56 (type "Str")) + (expr @5.9-5.85 (type "Str")))) ~~~ diff --git a/test/snapshots/syntax_grab_bag.md b/test/snapshots/syntax_grab_bag.md index cc03704658..be4928c33f 100644 --- a/test/snapshots/syntax_grab_bag.md +++ b/test/snapshots/syntax_grab_bag.md @@ -226,8 +226,6 @@ UNDECLARED TYPE - syntax_grab_bag.md:52:4:52:6 UNDECLARED TYPE - syntax_grab_bag.md:53:8:53:17 MODULE NOT FOUND - syntax_grab_bag.md:4:1:4:42 NOT IMPLEMENTED - :0:0:0:0 -NOT IMPLEMENTED - :0:0:0:0 -NOT IMPLEMENTED - :0:0:0:0 MODULE NOT FOUND - syntax_grab_bag.md:6:1:12:4 MODULE NOT FOUND - syntax_grab_bag.md:14:1:14:82 MODULE NOT FOUND - syntax_grab_bag.md:16:1:16:27 @@ -397,16 +395,6 @@ This feature is not yet implemented: malformed import module name contains inval This error doesn't have a proper diagnostic report yet. Let us know if you want to help improve Roc's error messages! -**NOT IMPLEMENTED** -This feature is not yet implemented: Exposed item 'line!' already imported from module 'pf.Stdout', cannot import again from module 'MALFORMED_IMPORT' - -This error doesn't have a proper diagnostic report yet. Let us know if you want to help improve Roc's error messages! - -**NOT IMPLEMENTED** -This feature is not yet implemented: Exposed item 'write!' already imported from module 'pf.Stdout', cannot import again from module 'MALFORMED_IMPORT' - -This error doesn't have a proper diagnostic report yet. Let us know if you want to help improve Roc's error messages! - **MODULE NOT FOUND** The module `MALFORMED_IMPORT` was not found in this Roc project. @@ -812,7 +800,7 @@ This `if` condition needs to be a _Bool_: ^^^ Right now, it has the type: - _U64_ + _Num(Int(Unsigned64))_ Every `if` condition must evaluate to a _Bool_–either `True` or `False`. @@ -900,8 +888,8 @@ This expression is used in an unexpected way: It has the type: __arg -> _ret_ -But here it's being used as: - _[Red][Blue, Green]_others, _arg2 -> Error_ +But I expected it to be: + _[Red][Blue, Green]_others, _arg -> Error_ # TOKENS ~~~zig @@ -1846,9 +1834,9 @@ expect { (if-branch (e-lookup-local @65.28-65.31 (p-assign @65.20-65.23 (ident "num"))) - (e-int @65.32-65.33 (value "2")))) + (e-num @65.32-65.33 (value "2")))) (if-else - (e-int @65.39-65.40 (value "5")))))) + (e-num @65.39-65.40 (value "5")))))) (d-let (p-assign @68.1-68.8 (ident "add_one")) (e-lambda @68.11-78.2 @@ -1857,7 +1845,7 @@ expect { (e-block @68.17-78.2 (s-let @69.2-69.11 (p-assign @69.2-69.7 (ident "other")) - (e-int @69.10-69.11 (value "1"))) + (e-num @69.10-69.11 (value "1"))) (e-if @70.2-77.3 (if-branches (if-branch @@ -1867,18 +1855,18 @@ expect { (s-dbg @71.3-72.15 (e-call @72.4-72.15 (e-runtime-error (tag "ident_not_in_scope")))) - (e-int @73.3-73.4 (value "0"))))) + (e-num @73.3-73.4 (value "0"))))) (if-else (e-block @74.9-77.3 (s-dbg @75.3-75.10 - (e-int @75.7-75.10 (value "123"))) + (e-num @75.7-75.10 (value "123"))) (e-lookup-local @76.3-76.8 (p-assign @69.2-69.7 (ident "other")))))))) (annotation @68.1-68.8 (declared-type (ty-fn @67.11-67.21 (effectful false) - (ty @67.11-67.14 (name "U64")) - (ty @67.18-67.21 (name "U64")))))) + (ty-lookup @67.11-67.14 (name "U64") (builtin)) + (ty-lookup @67.18-67.21 (name "U64") (builtin)))))) (d-let (p-assign @80.1-80.11 (ident "match_time")) (e-closure @80.14-138.3 @@ -1908,7 +1896,7 @@ expect { (e-block @85.25-88.4 (s-let @86.4-86.10 (p-assign @86.4-86.5 (ident "x")) - (e-int @86.8-86.10 (value "12"))) + (e-num @86.8-86.10 (value "12"))) (e-lookup-local @87.4-87.5 (p-assign @86.4-86.5 (ident "x")))))) (branch @@ -1923,7 +1911,7 @@ expect { (e-block @93.7-96.5 (s-let @94.5-94.11 (p-assign @94.5-94.6 (ident "x")) - (e-int @94.9-94.11 (value "12"))) + (e-num @94.9-94.11 (value "12"))) (e-lookup-local @95.5-95.6 (p-assign @94.5-94.6 (ident "x")))))) (branch @@ -1931,13 +1919,13 @@ expect { (pattern (degenerate false) (p-assign @97.3-97.8 (ident "lower")))) (value - (e-int @98.7-98.8 (value "1")))) + (e-num @98.7-98.8 (value "1")))) (branch (patterns (pattern (degenerate false) (p-str @99.3-99.8 (text """)))) (value - (e-int @100.4-100.7 (value "100")))) + (e-num @100.4-100.7 (value "100")))) (branch (patterns (pattern (degenerate false) @@ -1945,49 +1933,49 @@ expect { (pattern (degenerate false) (p-str @101.11-101.16 (text """)))) (value - (e-int @101.20-101.23 (value "200")))) + (e-num @101.20-101.23 (value "200")))) (branch (patterns (pattern (degenerate false) (p-list @102.3-102.24 (patterns - (p-int @102.4-102.5 (value "1")) - (p-int @102.7-102.8 (value "2")) - (p-int @102.10-102.11 (value "3"))) + (p-num @102.4-102.5 (value "1")) + (p-num @102.7-102.8 (value "2")) + (p-num @102.10-102.11 (value "3"))) (rest-at (index 3) (p-assign @1.1-1.1 (ident "rest")))))) (value - (e-int @104.5-104.8 (value "123")))) + (e-num @104.5-104.8 (value "123")))) (branch (patterns (pattern (degenerate false) (p-list @108.3-108.28 (patterns - (p-int @108.4-108.5 (value "1")) + (p-num @108.4-108.5 (value "1")) (p-runtime-error @1.1-1.1 (tag "not_implemented")) - (p-int @108.14-108.15 (value "3"))) + (p-num @108.14-108.15 (value "3"))) (rest-at (index 3) (p-assign @1.1-1.1 (ident "rest")))))) (value - (e-int @108.32-108.35 (value "123")))) + (e-num @108.32-108.35 (value "123")))) (branch (patterns (pattern (degenerate false) (p-list @109.3-116.4 (patterns - (p-int @110.4-110.5 (value "1")) + (p-num @110.4-110.5 (value "1")) (p-runtime-error @1.1-1.1 (tag "not_implemented")) - (p-int @112.4-112.5 (value "3"))) + (p-num @112.4-112.5 (value "3"))) (rest-at (index 3) (p-assign @1.1-1.1 (ident "rest")))))) (value - (e-int @116.8-116.11 (value "123")))) + (e-num @116.8-116.11 (value "123")))) (branch (patterns (pattern (degenerate false) (p-small-dec @117.3-117.7))) (value - (e-int @117.11-117.14 (value "314")))) + (e-num @117.11-117.14 (value "314")))) (branch (patterns (pattern (degenerate false) @@ -1995,27 +1983,27 @@ expect { (pattern (degenerate false) (p-small-dec @118.10-118.14))) (value - (e-int @118.18-118.21 (value "314")))) + (e-num @118.18-118.21 (value "314")))) (branch (patterns (pattern (degenerate false) (p-tuple @119.3-119.12 (patterns - (p-int @119.4-119.5 (value "1")) - (p-int @119.7-119.8 (value "2")) - (p-int @119.10-119.11 (value "3")))))) + (p-num @119.4-119.5 (value "1")) + (p-num @119.7-119.8 (value "2")) + (p-num @119.10-119.11 (value "3")))))) (value - (e-int @119.16-119.19 (value "123")))) + (e-num @119.16-119.19 (value "123")))) (branch (patterns (pattern (degenerate false) (p-tuple @120.3-120.16 (patterns - (p-int @120.4-120.5 (value "1")) + (p-num @120.4-120.5 (value "1")) (p-runtime-error @1.1-1.1 (tag "not_implemented")) - (p-int @120.14-120.15 (value "3")))))) + (p-num @120.14-120.15 (value "3")))))) (value - (e-int @120.20-120.23 (value "123")))) + (e-num @120.20-120.23 (value "123")))) (branch (patterns (pattern (degenerate false) @@ -2023,10 +2011,10 @@ expect { (destructs (record-destruct @121.5-121.11 (label "foo") (ident "foo") (sub-pattern - (p-int @121.10-121.11 (value "1")))) + (p-num @121.10-121.11 (value "1")))) (record-destruct @121.13-121.19 (label "bar") (ident "bar") (sub-pattern - (p-int @121.18-121.19 (value "2")))) + (p-num @121.18-121.19 (value "2")))) (record-destruct @121.21-121.27 (label "rest") (ident "rest") (required (p-assign @121.21-121.27 (ident "rest")))))))) @@ -2039,15 +2027,15 @@ expect { (destructs (record-destruct @123.4-125.7 (label "foo") (ident "foo") (sub-pattern - (p-int @125.6-125.7 (value "1")))) + (p-num @125.6-125.7 (value "1")))) (record-destruct @126.4-126.10 (label "bar") (ident "bar") (sub-pattern - (p-int @126.9-126.10 (value "2")))) + (p-num @126.9-126.10 (value "2")))) (record-destruct @127.4-128.9 (label "rest") (ident "rest") (required (p-assign @127.4-128.9 (ident "rest")))))))) (value - (e-int @129.8-129.10 (value "12")))) + (e-num @129.8-129.10 (value "12")))) (branch (patterns (pattern (degenerate false) @@ -2055,12 +2043,12 @@ expect { (destructs (record-destruct @130.5-130.11 (label "foo") (ident "foo") (sub-pattern - (p-int @130.10-130.11 (value "1")))) + (p-num @130.10-130.11 (value "1")))) (record-destruct @130.13-130.23 (label "bar") (ident "bar") (sub-pattern (p-runtime-error @1.1-1.1 (tag "not_implemented")))))))) (value - (e-int @130.29-130.31 (value "12")))) + (e-num @130.29-130.31 (value "12")))) (branch (patterns (pattern (degenerate false) @@ -2068,19 +2056,19 @@ expect { (destructs (record-destruct @132.4-132.10 (label "foo") (ident "foo") (sub-pattern - (p-int @132.9-132.10 (value "1")))) + (p-num @132.9-132.10 (value "1")))) (record-destruct @133.4-133.14 (label "bar") (ident "bar") (sub-pattern (p-runtime-error @1.1-1.1 (tag "not_implemented")))))))) (value - (e-int @134.8-134.10 (value "12")))) + (e-num @134.8-134.10 (value "12")))) (branch (patterns (pattern (degenerate false) (p-nominal @135.3-135.10 (p-applied-tag @135.3-135.10)))) (value - (e-int @135.14-135.17 (value "123")))) + (e-num @135.14-135.17 (value "123")))) (branch (patterns (pattern (degenerate false) @@ -2094,13 +2082,13 @@ expect { (pattern (degenerate false) (p-applied-tag @137.3-137.34))) (value - (e-int @137.38-137.42 (value "1000")))))))))) + (e-num @137.38-137.42 (value "1000")))))))))) (d-let (p-assign @144.1-144.6 (ident "main!")) (e-closure @144.9-196.2 (captures - (capture @68.1-68.8 (ident "add_one")) - (capture @80.1-80.11 (ident "match_time"))) + (capture @80.1-80.11 (ident "match_time")) + (capture @68.1-68.8 (ident "add_one"))) (e-lambda @144.9-196.2 (args (p-underscore @144.10-144.11)) @@ -2111,11 +2099,11 @@ expect { (e-literal @145.11-145.16 (string "World")))) (s-var @146.2-146.18 (p-assign @146.2-146.18 (ident "number")) - (e-int @146.15-146.18 (value "123"))) + (e-num @146.15-146.18 (value "123"))) (s-expect @147.2-147.18 (e-binop @147.9-147.18 (op "eq") (e-runtime-error (tag "ident_not_in_scope")) - (e-int @147.17-147.18 (value "1")))) + (e-num @147.17-147.18 (value "1")))) (s-let @148.2-148.12 (p-assign @148.2-148.5 (ident "tag")) (e-tag @148.8-148.12 (name "Blue"))) @@ -2133,7 +2121,7 @@ expect { (e-call @158.2-161.3 (e-runtime-error (tag "ident_not_in_scope")) (e-dbg @159.3-160.6 - (e-int @160.4-160.6 (value "42"))))) + (e-num @160.4-160.6 (value "42"))))) (s-crash @162.2-163.17 (msg "Unreachable!")) (s-let @164.2-164.31 (p-assign @164.2-164.18 (ident "tag_with_payload")) @@ -2159,15 +2147,15 @@ expect { (e-dbg @168.4-169.11 (e-lookup-local @169.5-169.11 (p-assign @146.2-146.18 (ident "number"))))) - (e-int @171.3-171.6 (value "456")) - (e-int @172.3-172.6 (value "789"))))) + (e-num @171.3-171.6 (value "456")) + (e-num @172.3-172.6 (value "789"))))) (s-runtime-error (tag "not_implemented")) (s-let @178.2-178.71 (p-assign @178.2-178.8 (ident "record")) (e-record @178.11-178.71 (fields (field (name "foo") - (e-int @178.18-178.21 (value "123"))) + (e-num @178.18-178.21 (value "123"))) (field (name "bar") (e-string @178.28-178.35 (e-literal @178.29-178.34 (string "Hello")))) @@ -2186,7 +2174,7 @@ expect { (p-assign @179.2-179.7 (ident "tuple")) (e-tuple @179.10-179.68 (elems - (e-int @179.11-179.14 (value "123")) + (e-num @179.11-179.14 (value "123")) (e-string @179.16-179.23 (e-literal @179.17-179.22 (string "World"))) (e-lookup-local @179.25-179.28 @@ -2203,14 +2191,14 @@ expect { (p-assign @179.2-179.7 (ident "tuple"))))) (e-list @179.58-179.67 (elems - (e-int @179.59-179.60 (value "1")) - (e-int @179.62-179.63 (value "2")) - (e-int @179.65-179.66 (value "3"))))))) + (e-num @179.59-179.60 (value "1")) + (e-num @179.62-179.63 (value "2")) + (e-num @179.65-179.66 (value "3"))))))) (s-let @180.2-187.3 (p-assign @180.2-180.17 (ident "multiline_tuple")) (e-tuple @180.20-187.3 (elems - (e-int @181.3-181.6 (value "123")) + (e-num @181.3-181.6 (value "123")) (e-string @182.3-182.10 (e-literal @182.4-182.9 (string "World"))) (e-runtime-error (tag "ident_not_in_scope")) @@ -2226,9 +2214,9 @@ expect { (p-assign @179.2-179.7 (ident "tuple"))))) (e-list @186.3-186.12 (elems - (e-int @186.4-186.5 (value "1")) - (e-int @186.7-186.8 (value "2")) - (e-int @186.10-186.11 (value "3"))))))) + (e-num @186.4-186.5 (value "1")) + (e-num @186.7-186.8 (value "2")) + (e-num @186.10-186.11 (value "3"))))))) (s-let @188.2-188.86 (p-assign @188.2-188.15 (ident "bin_op_result")) (e-binop @188.18-188.86 (op "or") @@ -2238,27 +2226,27 @@ expect { (e-tag @188.18-188.26 (name "Err") (args (e-runtime-error (tag "ident_not_in_scope"))))) - (e-int @188.30-188.32 (value "12"))) + (e-num @188.30-188.32 (value "12"))) (e-binop @188.35-188.40 (op "mul") - (e-int @188.35-188.36 (value "5")) - (e-int @188.39-188.40 (value "5")))) + (e-num @188.35-188.36 (value "5")) + (e-num @188.39-188.40 (value "5")))) (e-binop @188.44-188.86 (op "or") (e-binop @188.44-188.71 (op "and") (e-binop @188.44-188.54 (op "lt") (e-binop @188.44-188.50 (op "add") - (e-int @188.44-188.46 (value "13")) - (e-int @188.49-188.50 (value "2"))) - (e-int @188.53-188.54 (value "5"))) + (e-num @188.44-188.46 (value "13")) + (e-num @188.49-188.50 (value "2"))) + (e-num @188.53-188.54 (value "5"))) (e-binop @188.59-188.71 (op "ge") (e-binop @188.59-188.65 (op "sub") - (e-int @188.59-188.61 (value "10")) - (e-int @188.64-188.65 (value "1"))) - (e-int @188.69-188.71 (value "16")))) + (e-num @188.59-188.61 (value "10")) + (e-num @188.64-188.65 (value "1"))) + (e-num @188.69-188.71 (value "16")))) (e-binop @188.75-188.86 (op "le") - (e-int @188.75-188.77 (value "12")) + (e-num @188.75-188.77 (value "12")) (e-binop @188.81-188.86 (op "div") - (e-int @188.81-188.82 (value "3")) - (e-int @188.85-188.86 (value "5"))))))) + (e-num @188.81-188.82 (value "3")) + (e-num @188.85-188.86 (value "5"))))))) (s-let @189.2-189.111 (p-assign @189.2-189.23 (ident "static_dispatch_style")) (e-dot-access @189.26-189.111 (field "unknown") @@ -2272,7 +2260,7 @@ expect { (e-runtime-error (tag "not_implemented"))) (e-call @191.2-195.3 (e-lookup-external @191.2-191.14 - (module-idx "0") + (module-idx "2") (target-node-idx "0")) (e-string @192.3-194.18 (e-literal @192.4-192.14 (string "How about ")) @@ -2284,11 +2272,11 @@ expect { (annotation @144.1-144.6 (declared-type (ty-fn @143.9-143.38 (effectful false) - (ty-apply @143.9-143.21 (symbol "List") - (ty @143.14-143.20 (name "String"))) - (ty-apply @143.25-143.38 (symbol "Result") - (ty-record @143.32-143.34) - (ty-underscore @1.1-1.1)))))) + (ty-apply @143.9-143.21 (name "List") (builtin) + (ty-malformed @143.14-143.20)) + (ty-apply @143.25-143.38 (name "Result") (local) + (ty-record @143.25-143.38) + (ty-underscore @143.25-143.38)))))) (d-let (p-assign @199.1-199.6 (ident "empty")) (e-empty_record @199.9-199.11) @@ -2298,97 +2286,94 @@ expect { (s-alias-decl @22.1-22.41 (ty-header @22.1-22.10 (name "Map") (ty-args - (ty-var @22.5-22.6 (name "a")) - (ty-var @22.8-22.9 (name "b")))) + (ty-rigid-var @22.5-22.6 (name "a")) + (ty-rigid-var @22.8-22.9 (name "b")))) (ty-fn @22.13-22.41 (effectful false) - (ty-apply @22.13-22.20 (symbol "List") - (ty-var @22.18-22.19 (name "a"))) + (ty-apply @22.13-22.20 (name "List") (builtin) + (ty-rigid-var-lookup (ty-rigid-var @22.5-22.6 (name "a")))) (ty-parens @22.22-22.30 (ty-fn @22.23-22.29 (effectful false) - (ty-var @22.23-22.24 (name "a")) - (ty-var @22.28-22.29 (name "b")))) - (ty-apply @22.34-22.41 (symbol "List") - (ty-var @22.39-22.40 (name "b"))))) + (ty-rigid-var-lookup (ty-rigid-var @22.5-22.6 (name "a"))) + (ty-rigid-var-lookup (ty-rigid-var @22.8-22.9 (name "b"))))) + (ty-apply @22.34-22.41 (name "List") (builtin) + (ty-rigid-var-lookup (ty-rigid-var @22.8-22.9 (name "b")))))) (s-alias-decl @23.1-34.5 (ty-header @23.1-26.2 (name "MapML") (ty-args - (ty-var @24.2-24.3 (name "a")) - (ty-var @25.2-25.3 (name "b")))) + (ty-rigid-var @24.2-24.3 (name "a")) + (ty-rigid-var @25.2-25.3 (name "b")))) (ty-fn @28.3-34.5 (effectful false) - (ty-apply @28.3-30.4 (symbol "List") - (ty-var @29.4-29.5 (name "a"))) + (ty-apply @28.3-30.4 (name "List") (builtin) + (ty-rigid-var-lookup (ty-rigid-var @24.2-24.3 (name "a")))) (ty-parens @31.3-31.11 (ty-fn @31.4-31.10 (effectful false) - (ty-var @31.4-31.5 (name "a")) - (ty-var @31.9-31.10 (name "b")))) - (ty-apply @32.4-34.5 (symbol "List") - (ty-var @33.5-33.6 (name "b"))))) + (ty-rigid-var-lookup (ty-rigid-var @24.2-24.3 (name "a"))) + (ty-rigid-var-lookup (ty-rigid-var @25.2-25.3 (name "b"))))) + (ty-apply @32.4-34.5 (name "List") (builtin) + (ty-rigid-var-lookup (ty-rigid-var @25.2-25.3 (name "b")))))) (s-alias-decl @36.1-36.17 (ty-header @36.1-36.4 (name "Foo")) (ty-tuple @36.7-36.17 - (ty @36.8-36.11 (name "Bar")) - (ty @36.13-36.16 (name "Baz")))) + (ty-malformed @36.8-36.11) + (ty-malformed @36.13-36.16))) (s-alias-decl @38.1-41.2 (ty-header @38.1-38.13 (name "FooMultiline")) (ty-tuple @38.16-41.2 - (ty @39.2-39.5 (name "Bar")) - (ty @40.2-40.5 (name "Baz")))) + (ty-malformed @39.2-39.5) + (ty-malformed @40.2-40.5))) (s-alias-decl @43.1-43.43 (ty-header @43.1-43.8 (name "Some") (ty-args - (ty-var @43.6-43.7 (name "a")))) + (ty-rigid-var @43.6-43.7 (name "a")))) (ty-record @43.11-43.43 (field (field "foo") - (ty-apply @43.19-43.24 (symbol "Ok") - (ty-var @43.22-43.23 (name "a")))) + (ty-malformed @43.19-43.21)) (field (field "bar") - (ty @43.32-43.41 (name "Something"))))) + (ty-malformed @43.32-43.41)))) (s-alias-decl @44.1-47.2 (ty-header @44.1-44.10 (name "SomeMl") (ty-args - (ty-var @44.8-44.9 (name "a")))) + (ty-rigid-var @44.8-44.9 (name "a")))) (ty-record @44.13-47.2 (field (field "foo") - (ty-apply @45.8-45.13 (symbol "Ok") - (ty-var @45.11-45.12 (name "a")))) + (ty-malformed @45.8-45.10)) (field (field "bar") - (ty @46.8-46.17 (name "Something"))))) + (ty-malformed @46.8-46.17)))) (s-alias-decl @49.1-54.2 (ty-header @49.1-49.17 (name "SomeMultiline") (ty-args - (ty-var @49.15-49.16 (name "a")))) + (ty-rigid-var @49.15-49.16 (name "a")))) (ty-record @49.20-54.2 (field (field "foo") - (ty-apply @52.4-52.9 (symbol "Ok") - (ty-var @52.7-52.8 (name "a")))) + (ty-malformed @52.4-52.6)) (field (field "bar") - (ty @53.8-53.17 (name "Something"))))) + (ty-malformed @53.8-53.17)))) (s-alias-decl @56.1-56.27 (ty-header @56.1-56.9 (name "Maybe") (ty-args - (ty-var @56.7-56.8 (name "a")))) + (ty-rigid-var @56.7-56.8 (name "a")))) (ty-tag-union @56.12-56.27 - (ty-apply @56.13-56.20 (symbol "Some") - (ty-var @56.18-56.19 (name "a"))) - (ty @56.22-56.26 (name "None")))) + (ty-tag-name @56.13-56.20 (name "Some") + (ty-rigid-var-lookup (ty-rigid-var @56.7-56.8 (name "a")))) + (ty-tag-name @56.22-56.26 (name "None")))) (s-alias-decl @58.1-61.2 (ty-header @58.1-58.18 (name "MaybeMultiline") (ty-args - (ty-var @58.16-58.17 (name "a")))) + (ty-rigid-var @58.16-58.17 (name "a")))) (ty-tag-union @58.21-61.2 - (ty-apply @59.2-59.9 (symbol "Some") - (ty-var @59.7-59.8 (name "a"))) - (ty @60.2-60.6 (name "None")))) + (ty-tag-name @59.2-59.9 (name "Some") + (ty-rigid-var-lookup (ty-rigid-var @58.16-58.17 (name "a")))) + (ty-tag-name @60.2-60.6 (name "None")))) (s-alias-decl @63.1-63.38 (ty-header @63.1-63.12 (name "SomeFunc") (ty-args - (ty-var @63.10-63.11 (name "a")))) + (ty-rigid-var @63.10-63.11 (name "a")))) (ty-fn @63.15-63.38 (effectful false) - (ty-apply @63.15-63.23 (symbol "Maybe") - (ty-var @63.21-63.22 (name "a"))) - (ty-var @63.25-63.26 (name "a")) - (ty-apply @63.30-63.38 (symbol "Maybe") - (ty-var @63.36-63.37 (name "a"))))) + (ty-apply @63.15-63.23 (name "Maybe") (local) + (ty-rigid-var-lookup (ty-rigid-var @63.10-63.11 (name "a")))) + (ty-rigid-var-lookup (ty-rigid-var @63.10-63.11 (name "a"))) + (ty-apply @63.30-63.38 (name "Maybe") (local) + (ty-rigid-var-lookup (ty-rigid-var @63.10-63.11 (name "a")))))) (s-import @4.1-4.42 (module "pf.Stdout") (qualifier "pf") (exposes (exposed (name "line!") (wildcard false)) @@ -2409,15 +2394,15 @@ expect { (s-expect @140.1-141.11 (e-binop @141.2-141.11 (op "eq") (e-runtime-error (tag "ident_not_in_scope")) - (e-int @141.10-141.11 (value "1")))) + (e-num @141.10-141.11 (value "1")))) (s-expect @203.1-207.2 (e-block @203.8-207.2 (s-let @204.2-204.9 (p-assign @204.2-204.5 (ident "foo")) - (e-int @204.8-204.9 (value "1"))) + (e-num @204.8-204.9 (value "1"))) (s-let @205.2-205.10 (p-assign @205.2-205.6 (ident "blah")) - (e-int @205.9-205.10 (value "1"))) + (e-num @205.9-205.10 (value "1"))) (e-binop @206.2-206.13 (op "eq") (e-lookup-local @206.2-206.6 (p-assign @205.2-205.6 (ident "blah"))) @@ -2429,7 +2414,7 @@ expect { (inferred-types (defs (patt @65.1-65.16 (type "Bool -> Num(_size)")) - (patt @68.1-68.8 (type "Error -> Error")) + (patt @68.1-68.8 (type "Num(Int(Unsigned64)) -> Num(Int(Unsigned64))")) (patt @80.1-80.11 (type "[Red][Blue, Green]_others, _arg -> Error")) (patt @144.1-144.6 (type "List(Error) -> Result({ }, _d)")) (patt @199.1-199.6 (type "{}"))) @@ -2437,13 +2422,13 @@ expect { (alias @22.1-22.41 (type "Map(a, b)") (ty-header @22.1-22.10 (name "Map") (ty-args - (ty-var @22.5-22.6 (name "a")) - (ty-var @22.8-22.9 (name "b"))))) + (ty-rigid-var @22.5-22.6 (name "a")) + (ty-rigid-var @22.8-22.9 (name "b"))))) (alias @23.1-34.5 (type "MapML(a, b)") (ty-header @23.1-26.2 (name "MapML") (ty-args - (ty-var @24.2-24.3 (name "a")) - (ty-var @25.2-25.3 (name "b"))))) + (ty-rigid-var @24.2-24.3 (name "a")) + (ty-rigid-var @25.2-25.3 (name "b"))))) (alias @36.1-36.17 (type "Foo") (ty-header @36.1-36.4 (name "Foo"))) (alias @38.1-41.2 (type "FooMultiline") @@ -2451,30 +2436,30 @@ expect { (alias @43.1-43.43 (type "Some(a)") (ty-header @43.1-43.8 (name "Some") (ty-args - (ty-var @43.6-43.7 (name "a"))))) + (ty-rigid-var @43.6-43.7 (name "a"))))) (alias @44.1-47.2 (type "SomeMl(a)") (ty-header @44.1-44.10 (name "SomeMl") (ty-args - (ty-var @44.8-44.9 (name "a"))))) + (ty-rigid-var @44.8-44.9 (name "a"))))) (alias @49.1-54.2 (type "SomeMultiline(a)") (ty-header @49.1-49.17 (name "SomeMultiline") (ty-args - (ty-var @49.15-49.16 (name "a"))))) + (ty-rigid-var @49.15-49.16 (name "a"))))) (alias @56.1-56.27 (type "Maybe(a)") (ty-header @56.1-56.9 (name "Maybe") (ty-args - (ty-var @56.7-56.8 (name "a"))))) + (ty-rigid-var @56.7-56.8 (name "a"))))) (alias @58.1-61.2 (type "MaybeMultiline(a)") (ty-header @58.1-58.18 (name "MaybeMultiline") (ty-args - (ty-var @58.16-58.17 (name "a"))))) + (ty-rigid-var @58.16-58.17 (name "a"))))) (alias @63.1-63.38 (type "SomeFunc(a)") (ty-header @63.1-63.12 (name "SomeFunc") (ty-args - (ty-var @63.10-63.11 (name "a")))))) + (ty-rigid-var @63.10-63.11 (name "a")))))) (expressions (expr @65.19-65.40 (type "Bool -> Num(_size)")) - (expr @68.11-78.2 (type "Error -> Error")) + (expr @68.11-78.2 (type "Num(Int(Unsigned64)) -> Num(Int(Unsigned64))")) (expr @80.14-138.3 (type "[Red][Blue, Green]_others, _arg -> Error")) (expr @144.9-196.2 (type "List(Error) -> Result({ }, _d)")) (expr @199.9-199.11 (type "{}")))) diff --git a/test/snapshots/test_exact_pattern_crash.md b/test/snapshots/test_exact_pattern_crash.md index 359964e3d3..85cc553206 100644 --- a/test/snapshots/test_exact_pattern_crash.md +++ b/test/snapshots/test_exact_pattern_crash.md @@ -34,7 +34,7 @@ main = { ~~~ # EXPECTED UNUSED VARIABLE - test_exact_pattern_crash.md:19:5:19:7 -TYPE MISMATCH - test_exact_pattern_crash.md:23:10:23:18 +TYPE MISMATCH - test_exact_pattern_crash.md:23:10:23:50 # PROBLEMS **UNUSED VARIABLE** Variable `p1` is not used anywhere in your code. @@ -50,16 +50,16 @@ The unused variable is declared here: **TYPE MISMATCH** This expression is used in an unexpected way: -**test_exact_pattern_crash.md:23:10:23:18:** +**test_exact_pattern_crash.md:23:10:23:50:** ```roc p2 = map_pair(3, 4, (|x| x + 1), (|y| y * 2)) ``` - ^^^^^^^^ + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ It has the type: _Num(_size), Num(_size2), Num(_size3) -> Num(_size4), Num(_size5) -> Num(_size6) -> _ret_ -But here it's being used as: +But I expected it to be: _Pair(a, b), a -> c, b -> d -> Pair(c, d)_ # TOKENS @@ -234,12 +234,12 @@ main = { (annotation @8.1-8.10 (declared-type (ty-fn @7.13-7.37 (effectful false) - (ty-apply @7.13-7.23 (symbol "Pair") - (ty-var @7.18-7.19 (name "a")) - (ty-var @7.21-7.22 (name "b"))) - (ty-apply @7.27-7.37 (symbol "Pair") - (ty-var @7.32-7.33 (name "b")) - (ty-var @7.35-7.36 (name "a"))))))) + (ty-apply @7.13-7.23 (name "Pair") (local) + (ty-rigid-var @7.13-7.23 (name "a")) + (ty-rigid-var @7.13-7.23 (name "b"))) + (ty-apply @7.27-7.37 (name "Pair") (local) + (ty-rigid-var-lookup (ty-rigid-var @7.13-7.23 (name "b"))) + (ty-rigid-var-lookup (ty-rigid-var @7.13-7.23 (name "a")))))))) (d-let (p-assign @12.1-12.9 (ident "map_pair")) (e-lambda @12.12-12.39 @@ -265,20 +265,20 @@ main = { (annotation @12.1-12.9 (declared-type (ty-fn @11.12-11.56 (effectful false) - (ty-apply @11.12-11.22 (symbol "Pair") - (ty-var @11.17-11.18 (name "a")) - (ty-var @11.20-11.21 (name "b"))) + (ty-apply @11.12-11.22 (name "Pair") (local) + (ty-rigid-var @11.12-11.22 (name "a")) + (ty-rigid-var @11.12-11.22 (name "b"))) (ty-parens @11.24-11.32 (ty-fn @11.25-11.31 (effectful false) - (ty-var @11.25-11.26 (name "a")) - (ty-var @11.30-11.31 (name "c")))) + (ty-rigid-var-lookup (ty-rigid-var @11.12-11.22 (name "a"))) + (ty-rigid-var @11.30-11.31 (name "c")))) (ty-parens @11.34-11.42 (ty-fn @11.35-11.41 (effectful false) - (ty-var @11.35-11.36 (name "b")) - (ty-var @11.40-11.41 (name "d")))) - (ty-apply @11.46-11.56 (symbol "Pair") - (ty-var @11.51-11.52 (name "c")) - (ty-var @11.54-11.55 (name "d"))))))) + (ty-rigid-var-lookup (ty-rigid-var @11.12-11.22 (name "b"))) + (ty-rigid-var @11.40-11.41 (name "d")))) + (ty-apply @11.46-11.56 (name "Pair") (local) + (ty-rigid-var-lookup (ty-rigid-var @11.30-11.31 (name "c"))) + (ty-rigid-var-lookup (ty-rigid-var @11.40-11.41 (name "d")))))))) (d-let (p-assign @17.1-17.5 (ident "main")) (e-block @17.8-26.2 @@ -289,55 +289,55 @@ main = { (p-assign @8.1-8.10 (ident "swap_pair"))) (e-tuple @19.20-19.26 (elems - (e-int @19.21-19.22 (value "1")) - (e-int @19.24-19.25 (value "2")))))) + (e-num @19.21-19.22 (value "1")) + (e-num @19.24-19.25 (value "2")))))) (s-let @23.5-23.50 (p-assign @23.5-23.7 (ident "p2")) (e-call @23.10-23.50 (e-lookup-local @23.10-23.18 (p-assign @12.1-12.9 (ident "map_pair"))) - (e-int @23.19-23.20 (value "3")) - (e-int @23.22-23.23 (value "4")) + (e-num @23.19-23.20 (value "3")) + (e-num @23.22-23.23 (value "4")) (e-lambda @23.26-23.35 (args (p-assign @23.27-23.28 (ident "x"))) (e-binop @23.30-23.35 (op "add") (e-lookup-local @23.30-23.31 (p-assign @23.27-23.28 (ident "x"))) - (e-int @23.34-23.35 (value "1")))) + (e-num @23.34-23.35 (value "1")))) (e-lambda @23.39-23.48 (args (p-assign @23.40-23.41 (ident "y"))) (e-binop @23.43-23.48 (op "mul") (e-lookup-local @23.43-23.44 (p-assign @23.40-23.41 (ident "y"))) - (e-int @23.47-23.48 (value "2")))))) + (e-num @23.47-23.48 (value "2")))))) (e-lookup-local @25.5-25.7 (p-assign @23.5-23.7 (ident "p2"))))) (s-alias-decl @4.1-4.20 (ty-header @4.1-4.11 (name "Pair") (ty-args - (ty-var @4.6-4.7 (name "a")) - (ty-var @4.9-4.10 (name "b")))) + (ty-rigid-var @4.6-4.7 (name "a")) + (ty-rigid-var @4.9-4.10 (name "b")))) (ty-tuple @4.14-4.20 - (ty-var @4.15-4.16 (name "a")) - (ty-var @4.18-4.19 (name "b"))))) + (ty-rigid-var-lookup (ty-rigid-var @4.6-4.7 (name "a"))) + (ty-rigid-var-lookup (ty-rigid-var @4.9-4.10 (name "b")))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @8.1-8.10 (type "Pair(a, a) -> Pair(a, a)")) + (patt @8.1-8.10 (type "Pair(a, b) -> Pair(b, a)")) (patt @12.1-12.9 (type "Pair(a, b), a -> c, b -> d -> Pair(c, d)")) (patt @17.1-17.5 (type "_e"))) (type_decls (alias @4.1-4.20 (type "Pair(a, b)") (ty-header @4.1-4.11 (name "Pair") (ty-args - (ty-var @4.6-4.7 (name "a")) - (ty-var @4.9-4.10 (name "b")))))) + (ty-rigid-var @4.6-4.7 (name "a")) + (ty-rigid-var @4.9-4.10 (name "b")))))) (expressions - (expr @8.13-8.28 (type "Pair(a, a) -> Pair(a, a)")) + (expr @8.13-8.28 (type "Pair(a, b) -> Pair(b, a)")) (expr @12.12-12.39 (type "Pair(a, b), a -> c, b -> d -> Pair(c, d)")) (expr @17.8-26.2 (type "_e")))) ~~~ diff --git a/test/snapshots/test_headerless_main.md b/test/snapshots/test_headerless_main.md new file mode 100644 index 0000000000..a3ef2b8c04 --- /dev/null +++ b/test/snapshots/test_headerless_main.md @@ -0,0 +1,66 @@ +# META +~~~ini +description=Headerless file with main function +type=file +~~~ +# SOURCE +~~~roc +x = 5 +main! = |_| x +~~~ +# EXPECTED +NIL +# PROBLEMS +NIL +# TOKENS +~~~zig +LowerIdent(1:1-1:2),OpAssign(1:3-1:4),Int(1:5-1:6), +LowerIdent(2:1-2:6),OpAssign(2:7-2:8),OpBar(2:9-2:10),Underscore(2:10-2:11),OpBar(2:11-2:12),LowerIdent(2:13-2:14), +EndOfFile(3:1-3:1), +~~~ +# PARSE +~~~clojure +(file @1.1-2.14 + (type-module @1.1-1.2) + (statements + (s-decl @1.1-1.6 + (p-ident @1.1-1.2 (raw "x")) + (e-int @1.5-1.6 (raw "5"))) + (s-decl @2.1-2.14 + (p-ident @2.1-2.6 (raw "main!")) + (e-lambda @2.9-2.14 + (args + (p-underscore)) + (e-ident @2.13-2.14 (raw "x")))))) +~~~ +# FORMATTED +~~~roc +NO CHANGE +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @1.1-1.2 (ident "x")) + (e-num @1.5-1.6 (value "5"))) + (d-let + (p-assign @2.1-2.6 (ident "main!")) + (e-closure @2.9-2.14 + (captures + (capture @1.1-1.2 (ident "x"))) + (e-lambda @2.9-2.14 + (args + (p-underscore @2.10-2.11)) + (e-lookup-local @2.13-2.14 + (p-assign @1.1-1.2 (ident "x"))))))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @1.1-1.2 (type "Num(_size)")) + (patt @2.1-2.6 (type "_arg -> Num(_size)"))) + (expressions + (expr @1.5-1.6 (type "Num(_size)")) + (expr @2.9-2.14 (type "_arg -> Num(_size)")))) +~~~ diff --git a/test/snapshots/test_instantiated_arg_mismatch.md b/test/snapshots/test_instantiated_arg_mismatch.md index 48c85a5a81..7e04468681 100644 --- a/test/snapshots/test_instantiated_arg_mismatch.md +++ b/test/snapshots/test_instantiated_arg_mismatch.md @@ -78,13 +78,6 @@ EndOfFile(7:1-7:1), # CANONICALIZE ~~~clojure (e-block @1.1-6.2 - (s-type-anno @2.5-2.26 (name "pair") - (ty-fn @2.12-2.26 (effectful false) - (ty-var @2.12-2.13 (name "a")) - (ty-var @2.15-2.16 (name "a")) - (ty-tuple @2.20-2.26 - (ty-var @2.21-2.22 (name "a")) - (ty-var @2.24-2.25 (name "a"))))) (s-let @3.5-3.25 (p-assign @3.5-3.9 (ident "pair")) (e-lambda @3.12-3.25 @@ -100,11 +93,11 @@ EndOfFile(7:1-7:1), (e-call @5.5-5.22 (e-lookup-local @5.5-5.9 (p-assign @3.5-3.9 (ident "pair"))) - (e-int @5.10-5.12 (value "42")) + (e-num @5.10-5.12 (value "42")) (e-string @5.14-5.21 (e-literal @5.15-5.20 (string "hello"))))) ~~~ # TYPES ~~~clojure -(expr @1.1-6.2 (type "_b")) +(expr @1.1-6.2 (type "Error")) ~~~ diff --git a/test/snapshots/test_instantiated_return_crash.md b/test/snapshots/test_instantiated_return_crash.md index 293eb6f4ee..c0d77b8659 100644 --- a/test/snapshots/test_instantiated_return_crash.md +++ b/test/snapshots/test_instantiated_return_crash.md @@ -29,7 +29,7 @@ The first argument being passed to this function has the wrong type: This argument has the type: _List(Str)_ -But the function needs the first argument to be: +But `f` needs the first argument to be: _Str_ # TOKENS @@ -92,10 +92,6 @@ EndOfFile(10:1-10:1), # CANONICALIZE ~~~clojure (e-block @1.1-9.2 - (s-type-anno @2.5-2.22 (name "identity") - (ty-fn @2.16-2.22 (effectful false) - (ty-var @2.16-2.17 (name "a")) - (ty-var @2.21-2.22 (name "a")))) (s-let @3.5-3.21 (p-assign @3.5-3.13 (ident "identity")) (e-lambda @3.16-3.21 @@ -103,14 +99,6 @@ EndOfFile(10:1-10:1), (p-assign @3.17-3.18 (ident "x"))) (e-lookup-local @3.20-3.21 (p-assign @3.17-3.18 (ident "x"))))) - (s-type-anno @5.5-5.41 (name "needs_string") - (ty-parens @5.20-5.41 - (ty-fn @5.21-5.40 (effectful false) - (ty-parens @5.21-5.33 - (ty-fn @5.22-5.32 (effectful false) - (ty @5.22-5.25 (name "Str")) - (ty @5.29-5.32 (name "Str")))) - (ty @5.37-5.40 (name "Str"))))) (s-let @6.5-6.36 (p-assign @6.5-6.17 (ident "needs_string")) (e-lambda @6.20-6.36 diff --git a/test/snapshots/test_instantiation_arity_mismatch.md b/test/snapshots/test_instantiation_arity_mismatch.md index 483858dc24..e825f3349b 100644 --- a/test/snapshots/test_instantiation_arity_mismatch.md +++ b/test/snapshots/test_instantiation_arity_mismatch.md @@ -13,20 +13,20 @@ type=expr } ~~~ # EXPECTED -TYPE MISMATCH - test_instantiation_arity_mismatch.md:5:5:5:13 +TYPE MISMATCH - test_instantiation_arity_mismatch.md:5:5:5:19 # PROBLEMS **TYPE MISMATCH** This expression is used in an unexpected way: -**test_instantiation_arity_mismatch.md:5:5:5:13:** +**test_instantiation_arity_mismatch.md:5:5:5:19:** ```roc identity(1, 2) ``` - ^^^^^^^^ + ^^^^^^^^^^^^^^ It has the type: _Num(_size), Num(_size2) -> _ret_ -But here it's being used as: +But I expected it to be: _(a, b) -> (a, b)_ # TOKENS @@ -73,14 +73,6 @@ EndOfFile(7:1-7:1), # CANONICALIZE ~~~clojure (e-block @1.1-6.2 - (s-type-anno @2.5-2.32 (name "identity") - (ty-fn @2.16-2.32 (effectful false) - (ty-tuple @2.16-2.22 - (ty-var @2.17-2.18 (name "a")) - (ty-var @2.20-2.21 (name "b"))) - (ty-tuple @2.26-2.32 - (ty-var @2.27-2.28 (name "a")) - (ty-var @2.30-2.31 (name "b"))))) (s-let @3.5-3.27 (p-assign @3.5-3.13 (ident "identity")) (e-lambda @3.16-3.27 @@ -91,8 +83,8 @@ EndOfFile(7:1-7:1), (e-call @5.5-5.19 (e-lookup-local @5.5-5.13 (p-assign @3.5-3.13 (ident "identity"))) - (e-int @5.14-5.15 (value "1")) - (e-int @5.17-5.18 (value "2")))) + (e-num @5.14-5.15 (value "1")) + (e-num @5.17-5.18 (value "2")))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/test_nested_instantiation_crash.md b/test/snapshots/test_nested_instantiation_crash.md index 1e9201a002..96e464c05b 100644 --- a/test/snapshots/test_nested_instantiation_crash.md +++ b/test/snapshots/test_nested_instantiation_crash.md @@ -31,12 +31,12 @@ composed = |n| get_value(make_record(n)) ``` ^^^^^^^^^^^^^^^^^^^^^^^^^ -The type annotation says it should have the type: - _Str_ - -But here it's being used as: +It has the type: _List(a)_ +But the type annotation says it should have the type: + _Str_ + # TOKENS ~~~zig KwApp(1:1-1:4),OpenSquare(1:5-1:6),CloseSquare(1:6-1:7),OpenCurly(1:8-1:9),LowerIdent(1:10-1:12),OpColon(1:12-1:13),KwPlatform(1:14-1:22),StringStart(1:23-1:24),StringPart(1:24-1:49),StringEnd(1:49-1:50),CloseCurly(1:51-1:52), @@ -156,12 +156,12 @@ answer = composed([42]) (annotation @6.1-6.12 (declared-type (ty-fn @5.15-5.42 (effectful false) - (ty-var @5.15-5.16 (name "a")) + (ty-rigid-var @5.15-5.16 (name "a")) (ty-record @5.20-5.42 (field (field "value") - (ty-var @5.29-5.30 (name "a"))) + (ty-rigid-var-lookup (ty-rigid-var @5.15-5.16 (name "a")))) (field (field "tag") - (ty @5.37-5.40 (name "Str")))))))) + (ty-lookup @5.37-5.40 (name "Str") (builtin)))))))) (d-let (p-assign @9.1-9.10 (ident "get_value")) (e-lambda @9.13-9.24 @@ -176,16 +176,16 @@ answer = composed([42]) (ty-fn @8.13-8.40 (effectful false) (ty-record @8.13-8.35 (field (field "value") - (ty-var @8.22-8.23 (name "a"))) + (ty-rigid-var @8.22-8.23 (name "a"))) (field (field "tag") - (ty @8.30-8.33 (name "Str")))) - (ty-var @8.39-8.40 (name "a")))))) + (ty-lookup @8.30-8.33 (name "Str") (builtin)))) + (ty-rigid-var-lookup (ty-rigid-var @8.22-8.23 (name "a"))))))) (d-let (p-assign @12.1-12.9 (ident "composed")) (e-closure @12.12-12.41 (captures - (capture @6.1-6.12 (ident "make_record")) - (capture @9.1-9.10 (ident "get_value"))) + (capture @9.1-9.10 (ident "get_value")) + (capture @6.1-6.12 (ident "make_record"))) (e-lambda @12.12-12.41 (args (p-assign @12.13-12.14 (ident "n"))) @@ -200,9 +200,9 @@ answer = composed([42]) (annotation @12.1-12.9 (declared-type (ty-fn @11.12-11.26 (effectful false) - (ty-apply @11.12-11.19 (symbol "List") - (ty-var @11.17-11.18 (name "a"))) - (ty @11.23-11.26 (name "Str")))))) + (ty-apply @11.12-11.19 (name "List") (builtin) + (ty-rigid-var @11.17-11.18 (name "a"))) + (ty-lookup @11.23-11.26 (name "Str") (builtin)))))) (d-let (p-assign @14.1-14.7 (ident "answer")) (e-call @14.10-14.24 @@ -210,19 +210,19 @@ answer = composed([42]) (p-assign @12.1-12.9 (ident "composed"))) (e-list @14.19-14.23 (elems - (e-int @14.20-14.22 (value "42"))))))) + (e-num @14.20-14.22 (value "42"))))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @6.1-6.12 (type "a -> { tag: Error, value: a }")) - (patt @9.1-9.10 (type "{ tag: Error, value: a } -> a")) + (patt @6.1-6.12 (type "a -> { tag: Str, value: a }")) + (patt @9.1-9.10 (type "{ tag: Str, value: a } -> a")) (patt @12.1-12.9 (type "List(a) -> Error")) (patt @14.1-14.7 (type "Error"))) (expressions - (expr @6.15-6.44 (type "a -> { tag: Error, value: a }")) - (expr @9.13-9.24 (type "{ tag: Error, value: a } -> a")) + (expr @6.15-6.44 (type "a -> { tag: Str, value: a }")) + (expr @9.13-9.24 (type "{ tag: Str, value: a } -> a")) (expr @12.12-12.41 (type "List(a) -> Error")) (expr @14.10-14.24 (type "Error")))) ~~~ diff --git a/test/snapshots/test_tuple_instantiation_crash.md b/test/snapshots/test_tuple_instantiation_crash.md index e70039a8a9..47d465b36c 100644 --- a/test/snapshots/test_tuple_instantiation_crash.md +++ b/test/snapshots/test_tuple_instantiation_crash.md @@ -16,20 +16,20 @@ swap = |(x, y)| (y, x) main = swap(1, 2) ~~~ # EXPECTED -TYPE MISMATCH - test_tuple_instantiation_crash.md:9:8:9:12 +TYPE MISMATCH - test_tuple_instantiation_crash.md:9:8:9:18 # PROBLEMS **TYPE MISMATCH** This expression is used in an unexpected way: -**test_tuple_instantiation_crash.md:9:8:9:12:** +**test_tuple_instantiation_crash.md:9:8:9:18:** ```roc main = swap(1, 2) ``` - ^^^^ + ^^^^^^^^^^ It has the type: _Num(_size), Num(_size2) -> _ret_ -But here it's being used as: +But I expected it to be: _(a, b) -> (b, a)_ # TOKENS @@ -105,18 +105,18 @@ NO CHANGE (declared-type (ty-fn @4.8-4.24 (effectful false) (ty-tuple @4.8-4.14 - (ty-var @4.9-4.10 (name "a")) - (ty-var @4.12-4.13 (name "b"))) + (ty-rigid-var @4.9-4.10 (name "a")) + (ty-rigid-var @4.12-4.13 (name "b"))) (ty-tuple @4.18-4.24 - (ty-var @4.19-4.20 (name "b")) - (ty-var @4.22-4.23 (name "a"))))))) + (ty-rigid-var-lookup (ty-rigid-var @4.12-4.13 (name "b"))) + (ty-rigid-var-lookup (ty-rigid-var @4.9-4.10 (name "a")))))))) (d-let (p-assign @9.1-9.5 (ident "main")) (e-call @9.8-9.18 (e-lookup-local @9.8-9.12 (p-assign @5.1-5.5 (ident "swap"))) - (e-int @9.13-9.14 (value "1")) - (e-int @9.16-9.17 (value "2"))))) + (e-num @9.13-9.14 (value "1")) + (e-num @9.16-9.17 (value "2"))))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/type_alias_decl.md b/test/snapshots/type_alias_decl.md index bfe249964a..c5c55eb451 100644 --- a/test/snapshots/type_alias_decl.md +++ b/test/snapshots/type_alias_decl.md @@ -280,13 +280,9 @@ main! = |_| { (args (p-underscore @27.10-27.11)) (e-block @27.13-39.2 - (s-type-anno @29.5-29.20 (name "userId") - (ty @29.14-29.20 (name "UserId"))) (s-let @30.5-30.17 (p-assign @30.5-30.11 (ident "userId")) - (e-int @30.14-30.17 (value "123"))) - (s-type-anno @32.5-32.20 (name "person") - (ty @32.14-32.20 (name "Person"))) + (e-num @30.14-30.17 (value "123"))) (s-let @33.5-33.40 (p-assign @33.5-33.11 (ident "person")) (e-record @33.14-33.40 @@ -295,9 +291,7 @@ main! = |_| { (e-string @33.22-33.29 (e-literal @33.23-33.28 (string "Alice")))) (field (name "age") - (e-int @33.36-33.38 (value "30")))))) - (s-type-anno @35.5-35.18 (name "color") - (ty @35.13-35.18 (name "Color"))) + (e-num @33.36-33.38 (value "30")))))) (s-let @36.5-36.16 (p-assign @36.5-36.10 (ident "color")) (e-tag @36.13-36.16 (name "Red"))) @@ -305,94 +299,94 @@ main! = |_| { (p-assign @30.5-30.11 (ident "userId")))))) (s-alias-decl @4.1-4.13 (ty-header @4.1-4.7 (name "UserId")) - (ty @4.10-4.13 (name "U64"))) + (ty-lookup @4.10-4.13 (name "U64") (builtin))) (s-alias-decl @7.1-7.37 (ty-header @7.1-7.16 (name "Result") (ty-args - (ty-var @7.8-7.10 (name "ok")) - (ty-var @7.12-7.15 (name "err")))) + (ty-rigid-var @7.8-7.10 (name "ok")) + (ty-rigid-var @7.12-7.15 (name "err")))) (ty-tag-union @7.19-7.37 - (ty-apply @7.20-7.26 (symbol "Ok") - (ty-var @7.23-7.25 (name "ok"))) - (ty-apply @7.28-7.36 (symbol "Err") - (ty-var @7.32-7.35 (name "err"))))) + (ty-tag-name @7.20-7.26 (name "Ok") + (ty-rigid-var-lookup (ty-rigid-var @7.8-7.10 (name "ok")))) + (ty-tag-name @7.28-7.36 (name "Err") + (ty-rigid-var-lookup (ty-rigid-var @7.12-7.15 (name "err")))))) (s-alias-decl @10.1-10.35 (ty-header @10.1-10.7 (name "Person")) (ty-record @10.10-10.35 (field (field "name") - (ty @10.19-10.22 (name "Str"))) + (ty-lookup @10.19-10.22 (name "Str") (builtin))) (field (field "age") - (ty @10.30-10.33 (name "U64"))))) + (ty-lookup @10.30-10.33 (name "U64") (builtin))))) (s-alias-decl @13.1-13.21 (ty-header @13.1-13.12 (name "MapFn") (ty-args - (ty-var @13.7-13.8 (name "a")) - (ty-var @13.10-13.11 (name "b")))) + (ty-rigid-var @13.7-13.8 (name "a")) + (ty-rigid-var @13.10-13.11 (name "b")))) (ty-fn @13.15-13.21 (effectful false) - (ty-var @13.15-13.16 (name "a")) - (ty-var @13.20-13.21 (name "b")))) + (ty-rigid-var-lookup (ty-rigid-var @13.7-13.8 (name "a"))) + (ty-rigid-var-lookup (ty-rigid-var @13.10-13.11 (name "b"))))) (s-alias-decl @16.1-16.38 (ty-header @16.1-16.18 (name "ApiResponse") (ty-args - (ty-var @16.13-16.17 (name "data")))) - (ty-apply @16.21-16.38 (symbol "Result") - (ty-var @16.28-16.32 (name "data")) - (ty @16.34-16.37 (name "Str")))) + (ty-rigid-var @16.13-16.17 (name "data")))) + (ty-apply @16.21-16.38 (name "Result") (local) + (ty-rigid-var-lookup (ty-rigid-var @16.13-16.17 (name "data"))) + (ty-lookup @16.21-16.38 (name "Str") (builtin)))) (s-alias-decl @19.1-19.47 (ty-header @19.1-19.6 (name "Color")) (ty-tag-union @19.9-19.47 - (ty @19.10-19.13 (name "Red")) - (ty @19.15-19.20 (name "Green")) - (ty @19.22-19.26 (name "Blue")) - (ty-apply @19.28-19.46 (symbol "Custom") - (ty @19.35-19.37 (name "U8")) - (ty @19.39-19.41 (name "U8")) - (ty @19.43-19.45 (name "U8"))))) + (ty-tag-name @19.10-19.13 (name "Red")) + (ty-tag-name @19.15-19.20 (name "Green")) + (ty-tag-name @19.22-19.26 (name "Blue")) + (ty-tag-name @19.28-19.46 (name "Custom") + (ty-lookup @19.35-19.37 (name "U8") (builtin)) + (ty-lookup @19.39-19.41 (name "U8") (builtin)) + (ty-lookup @19.43-19.45 (name "U8") (builtin))))) (s-alias-decl @22.1-25.2 (ty-header @22.1-22.16 (name "Container") (ty-args - (ty-var @22.11-22.15 (name "item")))) + (ty-rigid-var @22.11-22.15 (name "item")))) (ty-record @22.19-25.2 (field (field "contents") - (ty-apply @23.16-23.26 (symbol "List") - (ty-var @23.21-23.25 (name "item")))) + (ty-apply @23.16-23.26 (name "List") (builtin) + (ty-rigid-var-lookup (ty-rigid-var @22.11-22.15 (name "item"))))) (field (field "metadata") (ty-record @24.16-24.45 (field (field "size") - (ty @24.25-24.28 (name "U64"))) + (ty-lookup @24.25-24.28 (name "U64") (builtin))) (field (field "created") - (ty @24.40-24.43 (name "Str")))))))) + (ty-lookup @24.40-24.43 (name "Str") (builtin)))))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @27.1-27.6 (type "_arg -> U64"))) + (patt @27.1-27.6 (type "_arg -> UserId"))) (type_decls (alias @4.1-4.13 (type "UserId") (ty-header @4.1-4.7 (name "UserId"))) (alias @7.1-7.37 (type "Result(ok, err)") (ty-header @7.1-7.16 (name "Result") (ty-args - (ty-var @7.8-7.10 (name "ok")) - (ty-var @7.12-7.15 (name "err"))))) + (ty-rigid-var @7.8-7.10 (name "ok")) + (ty-rigid-var @7.12-7.15 (name "err"))))) (alias @10.1-10.35 (type "Person") (ty-header @10.1-10.7 (name "Person"))) (alias @13.1-13.21 (type "MapFn(a, b)") (ty-header @13.1-13.12 (name "MapFn") (ty-args - (ty-var @13.7-13.8 (name "a")) - (ty-var @13.10-13.11 (name "b"))))) + (ty-rigid-var @13.7-13.8 (name "a")) + (ty-rigid-var @13.10-13.11 (name "b"))))) (alias @16.1-16.38 (type "ApiResponse(data)") (ty-header @16.1-16.18 (name "ApiResponse") (ty-args - (ty-var @16.13-16.17 (name "data"))))) + (ty-rigid-var @16.13-16.17 (name "data"))))) (alias @19.1-19.47 (type "Color") (ty-header @19.1-19.6 (name "Color"))) (alias @22.1-25.2 (type "Container(item)") (ty-header @22.1-22.16 (name "Container") (ty-args - (ty-var @22.11-22.15 (name "item")))))) + (ty-rigid-var @22.11-22.15 (name "item")))))) (expressions - (expr @27.9-39.2 (type "_arg -> U64")))) + (expr @27.9-39.2 (type "_arg -> UserId")))) ~~~ diff --git a/test/snapshots/type_alias_parameterized.md b/test/snapshots/type_alias_parameterized.md index 80cebfce54..463f3de75f 100644 --- a/test/snapshots/type_alias_parameterized.md +++ b/test/snapshots/type_alias_parameterized.md @@ -15,21 +15,21 @@ swapPair = |(x, y)| (y, x) main! = |_| swapPair(1, 2) ~~~ # EXPECTED -TYPE MISMATCH - type_alias_parameterized.md:8:13:8:21 +TYPE MISMATCH - type_alias_parameterized.md:8:13:8:27 # PROBLEMS **TYPE MISMATCH** This expression is used in an unexpected way: -**type_alias_parameterized.md:8:13:8:21:** +**type_alias_parameterized.md:8:13:8:27:** ```roc main! = |_| swapPair(1, 2) ``` - ^^^^^^^^ + ^^^^^^^^^^^^^^ It has the type: _Num(_size), Num(_size2) -> _ret_ -But here it's being used as: - _Pair(a, a) -> Pair(a, a)_ +But I expected it to be: + _Pair(a, b) -> Pair(b, a)_ # TOKENS ~~~zig @@ -117,12 +117,12 @@ NO CHANGE (annotation @6.1-6.9 (declared-type (ty-fn @5.12-5.36 (effectful false) - (ty-apply @5.12-5.22 (symbol "Pair") - (ty-var @5.17-5.18 (name "a")) - (ty-var @5.20-5.21 (name "b"))) - (ty-apply @5.26-5.36 (symbol "Pair") - (ty-var @5.31-5.32 (name "b")) - (ty-var @5.34-5.35 (name "a"))))))) + (ty-apply @5.12-5.22 (name "Pair") (local) + (ty-rigid-var @5.12-5.22 (name "a")) + (ty-rigid-var @5.12-5.22 (name "b"))) + (ty-apply @5.26-5.36 (name "Pair") (local) + (ty-rigid-var-lookup (ty-rigid-var @5.12-5.22 (name "b"))) + (ty-rigid-var-lookup (ty-rigid-var @5.12-5.22 (name "a")))))))) (d-let (p-assign @8.1-8.6 (ident "main!")) (e-closure @8.9-8.27 @@ -134,30 +134,30 @@ NO CHANGE (e-call @8.13-8.27 (e-lookup-local @8.13-8.21 (p-assign @6.1-6.9 (ident "swapPair"))) - (e-int @8.22-8.23 (value "1")) - (e-int @8.25-8.26 (value "2")))))) + (e-num @8.22-8.23 (value "1")) + (e-num @8.25-8.26 (value "2")))))) (s-alias-decl @3.1-3.20 (ty-header @3.1-3.11 (name "Pair") (ty-args - (ty-var @3.6-3.7 (name "a")) - (ty-var @3.9-3.10 (name "b")))) + (ty-rigid-var @3.6-3.7 (name "a")) + (ty-rigid-var @3.9-3.10 (name "b")))) (ty-tuple @3.14-3.20 - (ty-var @3.15-3.16 (name "a")) - (ty-var @3.18-3.19 (name "b"))))) + (ty-rigid-var-lookup (ty-rigid-var @3.6-3.7 (name "a"))) + (ty-rigid-var-lookup (ty-rigid-var @3.9-3.10 (name "b")))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @6.1-6.9 (type "Pair(a, a) -> Pair(a, a)")) + (patt @6.1-6.9 (type "Pair(a, b) -> Pair(b, a)")) (patt @8.1-8.6 (type "_arg -> _ret"))) (type_decls (alias @3.1-3.20 (type "Pair(a, b)") (ty-header @3.1-3.11 (name "Pair") (ty-args - (ty-var @3.6-3.7 (name "a")) - (ty-var @3.9-3.10 (name "b")))))) + (ty-rigid-var @3.6-3.7 (name "a")) + (ty-rigid-var @3.9-3.10 (name "b")))))) (expressions - (expr @6.12-6.27 (type "Pair(a, a) -> Pair(a, a)")) + (expr @6.12-6.27 (type "Pair(a, b) -> Pair(b, a)")) (expr @8.9-8.27 (type "_arg -> _ret")))) ~~~ diff --git a/test/snapshots/type_alias_simple.md b/test/snapshots/type_alias_simple.md index f19b1480ea..eba2270059 100644 --- a/test/snapshots/type_alias_simple.md +++ b/test/snapshots/type_alias_simple.md @@ -91,7 +91,7 @@ NO CHANGE (e-binop @6.20-6.27 (op "gt") (e-lookup-local @6.20-6.22 (p-assign @6.12-6.14 (ident "id"))) - (e-int @6.25-6.27 (value "10"))) + (e-num @6.25-6.27 (value "10"))) (e-string @6.29-6.34 (e-literal @6.30-6.33 (string "big"))))) (if-else @@ -100,8 +100,8 @@ NO CHANGE (annotation @6.1-6.8 (declared-type (ty-fn @5.11-5.24 (effectful false) - (ty @5.11-5.17 (name "UserId")) - (ty @5.21-5.24 (name "Str")))))) + (ty-lookup @5.11-5.17 (name "UserId") (local)) + (ty-lookup @5.21-5.24 (name "Str") (builtin)))))) (d-let (p-assign @8.1-8.6 (ident "main!")) (e-closure @8.9-8.25 @@ -113,10 +113,10 @@ NO CHANGE (e-call @8.13-8.25 (e-lookup-local @8.13-8.20 (p-assign @6.1-6.8 (ident "getUser"))) - (e-int @8.21-8.24 (value "100")))))) + (e-num @8.21-8.24 (value "100")))))) (s-alias-decl @3.1-3.13 (ty-header @3.1-3.7 (name "UserId")) - (ty @3.10-3.13 (name "U64")))) + (ty-lookup @3.10-3.13 (name "U64") (builtin)))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/type_alias_tag_union.md b/test/snapshots/type_alias_tag_union.md index 36823a86ab..33b5778b2d 100644 --- a/test/snapshots/type_alias_tag_union.md +++ b/test/snapshots/type_alias_tag_union.md @@ -145,10 +145,10 @@ NO CHANGE (annotation @8.1-8.8 (declared-type (ty-fn @7.11-7.36 (effectful false) - (ty-apply @7.11-7.29 (symbol "MyResult") - (ty @7.20-7.23 (name "Str")) - (ty @7.25-7.28 (name "I32"))) - (ty @7.33-7.36 (name "Str")))))) + (ty-apply @7.11-7.29 (name "MyResult") (local) + (ty-lookup @7.11-7.29 (name "Str") (builtin)) + (ty-lookup @7.11-7.29 (name "I32") (builtin))) + (ty-lookup @7.33-7.36 (name "Str") (builtin)))))) (d-let (p-assign @15.1-15.10 (ident "getString")) (e-lambda @15.13-15.29 @@ -159,21 +159,21 @@ NO CHANGE (annotation @15.1-15.10 (declared-type (ty-fn @14.13-14.31 (effectful false) - (ty-apply @14.13-14.24 (symbol "Option") - (ty @14.20-14.23 (name "Str"))) - (ty @14.28-14.31 (name "Str")))))) + (ty-apply @14.13-14.24 (name "Option") (local) + (ty-lookup @14.13-14.24 (name "Str") (builtin))) + (ty-lookup @14.28-14.31 (name "Str") (builtin)))))) (d-let (p-assign @18.1-18.10 (ident "getNumber")) (e-lambda @18.13-18.21 (args (p-assign @18.14-18.18 (ident "_opt"))) - (e-int @18.20-18.21 (value "0"))) + (e-num @18.20-18.21 (value "0"))) (annotation @18.1-18.10 (declared-type (ty-fn @17.13-17.31 (effectful false) - (ty-apply @17.13-17.24 (symbol "Option") - (ty @17.20-17.23 (name "I32"))) - (ty @17.28-17.31 (name "I32")))))) + (ty-apply @17.13-17.24 (name "Option") (local) + (ty-lookup @17.13-17.24 (name "I32") (builtin))) + (ty-lookup @17.28-17.31 (name "I32") (builtin)))))) (d-let (p-assign @20.1-20.6 (ident "main!")) (e-lambda @20.9-20.15 @@ -183,43 +183,43 @@ NO CHANGE (s-alias-decl @4.1-4.41 (ty-header @4.1-4.18 (name "MyResult") (ty-args - (ty-var @4.10-4.12 (name "ok")) - (ty-var @4.14-4.17 (name "err")))) + (ty-rigid-var @4.10-4.12 (name "ok")) + (ty-rigid-var @4.14-4.17 (name "err")))) (ty-tag-union @4.21-4.41 - (ty-apply @4.22-4.30 (symbol "Good") - (ty-var @4.27-4.29 (name "ok"))) - (ty-apply @4.32-4.40 (symbol "Bad") - (ty-var @4.36-4.39 (name "err"))))) + (ty-tag-name @4.22-4.30 (name "Good") + (ty-rigid-var-lookup (ty-rigid-var @4.10-4.12 (name "ok")))) + (ty-tag-name @4.32-4.40 (name "Bad") + (ty-rigid-var-lookup (ty-rigid-var @4.14-4.17 (name "err")))))) (s-alias-decl @11.1-11.28 (ty-header @11.1-11.10 (name "Option") (ty-args - (ty-var @11.8-11.9 (name "a")))) + (ty-rigid-var @11.8-11.9 (name "a")))) (ty-tag-union @11.13-11.28 - (ty-apply @11.14-11.21 (symbol "Some") - (ty-var @11.19-11.20 (name "a"))) - (ty @11.23-11.27 (name "None"))))) + (ty-tag-name @11.14-11.21 (name "Some") + (ty-rigid-var-lookup (ty-rigid-var @11.8-11.9 (name "a")))) + (ty-tag-name @11.23-11.27 (name "None"))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @8.1-8.8 (type "MyResult(Str, I32) -> Str")) + (patt @8.1-8.8 (type "MyResult(Str, Num(Int(Signed32))) -> Str")) (patt @15.1-15.10 (type "Option(Str) -> Str")) - (patt @18.1-18.10 (type "Option(I32) -> I32")) + (patt @18.1-18.10 (type "Option(Num(Int(Signed32))) -> Num(Int(Signed32))")) (patt @20.1-20.6 (type "_arg -> {}"))) (type_decls (alias @4.1-4.41 (type "MyResult(ok, err)") (ty-header @4.1-4.18 (name "MyResult") (ty-args - (ty-var @4.10-4.12 (name "ok")) - (ty-var @4.14-4.17 (name "err"))))) + (ty-rigid-var @4.10-4.12 (name "ok")) + (ty-rigid-var @4.14-4.17 (name "err"))))) (alias @11.1-11.28 (type "Option(a)") (ty-header @11.1-11.10 (name "Option") (ty-args - (ty-var @11.8-11.9 (name "a")))))) + (ty-rigid-var @11.8-11.9 (name "a")))))) (expressions - (expr @8.11-8.32 (type "MyResult(Str, I32) -> Str")) + (expr @8.11-8.32 (type "MyResult(Str, Num(Int(Signed32))) -> Str")) (expr @15.13-15.29 (type "Option(Str) -> Str")) - (expr @18.13-18.21 (type "Option(I32) -> I32")) + (expr @18.13-18.21 (type "Option(Num(Int(Signed32))) -> Num(Int(Signed32))")) (expr @20.9-20.15 (type "_arg -> {}")))) ~~~ diff --git a/test/snapshots/type_anno_connection.md b/test/snapshots/type_anno_connection.md index 8cfe5b4ef5..1c27c27325 100644 --- a/test/snapshots/type_anno_connection.md +++ b/test/snapshots/type_anno_connection.md @@ -1,12 +1,10 @@ # META ~~~ini description=Type annotation connection to definitions -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [add_one, my_number] - add_one : U64 -> U64 add_one = |x| x + 1 @@ -19,42 +17,36 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:16),Comma(1:16-1:17),LowerIdent(1:18-1:27),CloseSquare(1:27-1:28), -LowerIdent(3:1-3:8),OpColon(3:9-3:10),UpperIdent(3:11-3:14),OpArrow(3:15-3:17),UpperIdent(3:18-3:21), -LowerIdent(4:1-4:8),OpAssign(4:9-4:10),OpBar(4:11-4:12),LowerIdent(4:12-4:13),OpBar(4:13-4:14),LowerIdent(4:15-4:16),OpPlus(4:17-4:18),Int(4:19-4:20), -LowerIdent(6:1-6:10),OpColon(6:11-6:12),UpperIdent(6:13-6:16), -LowerIdent(7:1-7:10),OpAssign(7:11-7:12),LowerIdent(7:13-7:20),NoSpaceOpenRound(7:20-7:21),Int(7:21-7:23),CloseRound(7:23-7:24), -EndOfFile(8:1-8:1), +LowerIdent(1:1-1:8),OpColon(1:9-1:10),UpperIdent(1:11-1:14),OpArrow(1:15-1:17),UpperIdent(1:18-1:21), +LowerIdent(2:1-2:8),OpAssign(2:9-2:10),OpBar(2:11-2:12),LowerIdent(2:12-2:13),OpBar(2:13-2:14),LowerIdent(2:15-2:16),OpPlus(2:17-2:18),Int(2:19-2:20), +LowerIdent(4:1-4:10),OpColon(4:11-4:12),UpperIdent(4:13-4:16), +LowerIdent(5:1-5:10),OpAssign(5:11-5:12),LowerIdent(5:13-5:20),NoSpaceOpenRound(5:20-5:21),Int(5:21-5:23),CloseRound(5:23-5:24), +EndOfFile(6:1-6:1), ~~~ # PARSE ~~~clojure -(file @1.1-7.24 - (module @1.1-1.28 - (exposes @1.8-1.28 - (exposed-lower-ident @1.9-1.16 - (text "add_one")) - (exposed-lower-ident @1.18-1.27 - (text "my_number")))) +(file @1.1-5.24 + (type-module @1.1-1.8) (statements - (s-type-anno @3.1-3.21 (name "add_one") - (ty-fn @3.11-3.21 - (ty @3.11-3.14 (name "U64")) - (ty @3.18-3.21 (name "U64")))) - (s-decl @4.1-4.20 - (p-ident @4.1-4.8 (raw "add_one")) - (e-lambda @4.11-4.20 + (s-type-anno @1.1-1.21 (name "add_one") + (ty-fn @1.11-1.21 + (ty @1.11-1.14 (name "U64")) + (ty @1.18-1.21 (name "U64")))) + (s-decl @2.1-2.20 + (p-ident @2.1-2.8 (raw "add_one")) + (e-lambda @2.11-2.20 (args - (p-ident @4.12-4.13 (raw "x"))) - (e-binop @4.15-4.20 (op "+") - (e-ident @4.15-4.16 (raw "x")) - (e-int @4.19-4.20 (raw "1"))))) - (s-type-anno @6.1-6.16 (name "my_number") - (ty @6.13-6.16 (name "U64"))) - (s-decl @7.1-7.24 - (p-ident @7.1-7.10 (raw "my_number")) - (e-apply @7.13-7.24 - (e-ident @7.13-7.20 (raw "add_one")) - (e-int @7.21-7.23 (raw "42")))))) + (p-ident @2.12-2.13 (raw "x"))) + (e-binop @2.15-2.20 (op "+") + (e-ident @2.15-2.16 (raw "x")) + (e-int @2.19-2.20 (raw "1"))))) + (s-type-anno @4.1-4.16 (name "my_number") + (ty @4.13-4.16 (name "U64"))) + (s-decl @5.1-5.24 + (p-ident @5.1-5.10 (raw "my_number")) + (e-apply @5.13-5.24 + (e-ident @5.13-5.20 (raw "add_one")) + (e-int @5.21-5.23 (raw "42")))))) ~~~ # FORMATTED ~~~roc @@ -64,36 +56,36 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @4.1-4.8 (ident "add_one")) - (e-lambda @4.11-4.20 + (p-assign @2.1-2.8 (ident "add_one")) + (e-lambda @2.11-2.20 (args - (p-assign @4.12-4.13 (ident "x"))) - (e-binop @4.15-4.20 (op "add") - (e-lookup-local @4.15-4.16 - (p-assign @4.12-4.13 (ident "x"))) - (e-int @4.19-4.20 (value "1")))) - (annotation @4.1-4.8 + (p-assign @2.12-2.13 (ident "x"))) + (e-binop @2.15-2.20 (op "add") + (e-lookup-local @2.15-2.16 + (p-assign @2.12-2.13 (ident "x"))) + (e-num @2.19-2.20 (value "1")))) + (annotation @2.1-2.8 (declared-type - (ty-fn @3.11-3.21 (effectful false) - (ty @3.11-3.14 (name "U64")) - (ty @3.18-3.21 (name "U64")))))) + (ty-fn @1.11-1.21 (effectful false) + (ty-lookup @1.11-1.14 (name "U64") (builtin)) + (ty-lookup @1.18-1.21 (name "U64") (builtin)))))) (d-let - (p-assign @7.1-7.10 (ident "my_number")) - (e-call @7.13-7.24 - (e-lookup-local @7.13-7.20 - (p-assign @4.1-4.8 (ident "add_one"))) - (e-int @7.21-7.23 (value "42"))) - (annotation @7.1-7.10 + (p-assign @5.1-5.10 (ident "my_number")) + (e-call @5.13-5.24 + (e-lookup-local @5.13-5.20 + (p-assign @2.1-2.8 (ident "add_one"))) + (e-num @5.21-5.23 (value "42"))) + (annotation @5.1-5.10 (declared-type - (ty @6.13-6.16 (name "U64")))))) + (ty-lookup @4.13-4.16 (name "U64") (builtin)))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @4.1-4.8 (type "U64 -> U64")) - (patt @7.1-7.10 (type "U64"))) + (patt @2.1-2.8 (type "Num(Int(Unsigned64)) -> Num(Int(Unsigned64))")) + (patt @5.1-5.10 (type "Num(Int(Unsigned64))"))) (expressions - (expr @4.11-4.20 (type "U64 -> U64")) - (expr @7.13-7.24 (type "U64")))) + (expr @2.11-2.20 (type "Num(Int(Unsigned64)) -> Num(Int(Unsigned64))")) + (expr @5.13-5.24 (type "Num(Int(Unsigned64))")))) ~~~ diff --git a/test/snapshots/type_annotation_basic.md b/test/snapshots/type_annotation_basic.md index ce03c93448..cba3ca2e1b 100644 --- a/test/snapshots/type_annotation_basic.md +++ b/test/snapshots/type_annotation_basic.md @@ -193,8 +193,8 @@ main! = |_| { (annotation @5.1-5.9 (declared-type (ty-fn @4.12-4.18 (effectful false) - (ty-var @4.12-4.13 (name "a")) - (ty-var @4.17-4.18 (name "a")))))) + (ty-rigid-var @4.12-4.13 (name "a")) + (ty-rigid-var-lookup (ty-rigid-var @4.12-4.13 (name "a"))))))) (d-let (p-assign @9.1-9.8 (ident "combine")) (e-lambda @9.11-9.42 @@ -210,11 +210,11 @@ main! = |_| { (annotation @9.1-9.8 (declared-type (ty-fn @8.11-8.25 (effectful false) - (ty-var @8.11-8.12 (name "a")) - (ty-var @8.14-8.15 (name "b")) + (ty-rigid-var @8.11-8.12 (name "a")) + (ty-rigid-var @8.14-8.15 (name "b")) (ty-tuple @8.19-8.25 - (ty-var @8.20-8.21 (name "a")) - (ty-var @8.23-8.24 (name "b"))))))) + (ty-rigid-var-lookup (ty-rigid-var @8.11-8.12 (name "a"))) + (ty-rigid-var-lookup (ty-rigid-var @8.14-8.15 (name "b")))))))) (d-let (p-assign @13.1-13.7 (ident "addOne")) (e-lambda @13.10-13.19 @@ -223,19 +223,19 @@ main! = |_| { (e-binop @13.14-13.19 (op "add") (e-lookup-local @13.14-13.15 (p-assign @13.11-13.12 (ident "n"))) - (e-int @13.18-13.19 (value "1")))) + (e-num @13.18-13.19 (value "1")))) (annotation @13.1-13.7 (declared-type (ty-fn @12.10-12.20 (effectful false) - (ty @12.10-12.13 (name "U64")) - (ty @12.17-12.20 (name "U64")))))) + (ty-lookup @12.10-12.13 (name "U64") (builtin)) + (ty-lookup @12.17-12.20 (name "U64") (builtin)))))) (d-let (p-assign @15.1-15.6 (ident "main!")) (e-closure @15.9-27.2 (captures - (capture @13.1-13.7 (ident "addOne")) + (capture @9.1-9.8 (ident "combine")) (capture @5.1-5.9 (ident "identity")) - (capture @9.1-9.8 (ident "combine"))) + (capture @13.1-13.7 (ident "addOne"))) (e-lambda @15.9-27.2 (args (p-underscore @15.10-15.11)) @@ -245,7 +245,7 @@ main! = |_| { (e-call @17.11-17.23 (e-lookup-local @17.11-17.19 (p-assign @5.1-5.9 (ident "identity"))) - (e-int @17.20-17.22 (value "42")))) + (e-num @17.20-17.22 (value "42")))) (s-let @18.5-18.29 (p-assign @18.5-18.9 (ident "text")) (e-call @18.12-18.29 @@ -267,7 +267,7 @@ main! = |_| { (e-call @24.14-24.23 (e-lookup-local @24.14-24.20 (p-assign @13.1-13.7 (ident "addOne"))) - (e-int @24.21-24.22 (value "5")))) + (e-num @24.21-24.22 (value "5")))) (e-lookup-local @26.5-26.11 (p-assign @24.5-24.11 (ident "result")))))))) ~~~ @@ -277,11 +277,11 @@ main! = |_| { (defs (patt @5.1-5.9 (type "a -> a")) (patt @9.1-9.8 (type "a, b -> (a, b)")) - (patt @13.1-13.7 (type "U64 -> U64")) - (patt @15.1-15.6 (type "_arg -> U64"))) + (patt @13.1-13.7 (type "Num(Int(Unsigned64)) -> Num(Int(Unsigned64))")) + (patt @15.1-15.6 (type "_arg -> Num(Int(Unsigned64))"))) (expressions (expr @5.12-5.17 (type "a -> a")) (expr @9.11-9.42 (type "a, b -> (a, b)")) - (expr @13.10-13.19 (type "U64 -> U64")) - (expr @15.9-27.2 (type "_arg -> U64")))) + (expr @13.10-13.19 (type "Num(Int(Unsigned64)) -> Num(Int(Unsigned64))")) + (expr @15.9-27.2 (type "_arg -> Num(Int(Unsigned64))")))) ~~~ diff --git a/test/snapshots/type_annotation_missing_parens.md b/test/snapshots/type_annotation_missing_parens.md index 9dcb9027f0..357cf162c1 100644 --- a/test/snapshots/type_annotation_missing_parens.md +++ b/test/snapshots/type_annotation_missing_parens.md @@ -1,17 +1,14 @@ # META ~~~ini description=Type annotation missing parentheses for type application -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [nums] - nums : List U8 ~~~ # EXPECTED -PARSE ERROR - type_annotation_missing_parens.md:4:1:4:1 -EXPOSED BUT NOT DEFINED - type_annotation_missing_parens.md:1:9:1:13 +PARSE ERROR - type_annotation_missing_parens.md:2:1:2:1 # PROBLEMS **PARSE ERROR** Type applications require parentheses around their type arguments. @@ -29,45 +26,29 @@ Other valid examples: `Result(a, Str)` `Maybe(List(U64))` -**type_annotation_missing_parens.md:4:1:4:1:** +**type_annotation_missing_parens.md:2:1:2:1:** ```roc ``` ^ -**EXPOSED BUT NOT DEFINED** -The module header says that `nums` is exposed, but it is not defined anywhere in this module. - -**type_annotation_missing_parens.md:1:9:1:13:** -```roc -module [nums] -``` - ^^^^ -You can fix this by either defining `nums` in this module, or by removing it from the list of exposed values. - # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:13),CloseSquare(1:13-1:14), -LowerIdent(3:1-3:5),OpColon(3:6-3:7),UpperIdent(3:8-3:12),UpperIdent(3:13-3:15), -EndOfFile(4:1-4:1), +LowerIdent(1:1-1:5),OpColon(1:6-1:7),UpperIdent(1:8-1:12),UpperIdent(1:13-1:15), +EndOfFile(2:1-2:1), ~~~ # PARSE ~~~clojure -(file @1.1-3.15 - (module @1.1-1.14 - (exposes @1.8-1.14 - (exposed-lower-ident @1.9-1.13 - (text "nums")))) +(file @1.1-1.15 + (type-module @1.1-1.5) (statements - (s-type-anno @3.1-3.12 (name "nums") - (ty @3.8-3.12 (name "List"))) + (s-type-anno @1.1-1.12 (name "nums") + (ty @1.8-1.12 (name "List"))) (s-malformed @1.1-1.1 (tag "expected_colon_after_type_annotation")))) ~~~ # FORMATTED ~~~roc -module [nums] - nums : List ~~~ # CANONICALIZE diff --git a/test/snapshots/type_annotations.md b/test/snapshots/type_annotations.md index 8538796130..950172c7f9 100644 --- a/test/snapshots/type_annotations.md +++ b/test/snapshots/type_annotations.md @@ -1,12 +1,10 @@ # META ~~~ini description=Various type annotations -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - foo : U64 bar : Thing(_a, _b, _) baz : (_a, _b, _c) @@ -15,15 +13,15 @@ main! : List(String) -> Result({}, _) tag_tuple : Value((_a, _b, _c)) ~~~ # EXPECTED -UNDECLARED TYPE - type_annotations.md:4:7:4:12 -UNDECLARED TYPE - type_annotations.md:7:14:7:20 -UNDECLARED TYPE - type_annotations.md:8:13:8:18 +UNDECLARED TYPE - type_annotations.md:2:7:2:12 +UNDECLARED TYPE - type_annotations.md:5:14:5:20 +UNDECLARED TYPE - type_annotations.md:6:13:6:18 # PROBLEMS **UNDECLARED TYPE** The type _Thing_ is not declared in this scope. This type is referenced here: -**type_annotations.md:4:7:4:12:** +**type_annotations.md:2:7:2:12:** ```roc bar : Thing(_a, _b, _) ``` @@ -34,7 +32,7 @@ bar : Thing(_a, _b, _) The type _String_ is not declared in this scope. This type is referenced here: -**type_annotations.md:7:14:7:20:** +**type_annotations.md:5:14:5:20:** ```roc main! : List(String) -> Result({}, _) ``` @@ -45,7 +43,7 @@ main! : List(String) -> Result({}, _) The type _Value_ is not declared in this scope. This type is referenced here: -**type_annotations.md:8:13:8:18:** +**type_annotations.md:6:13:6:18:** ```roc tag_tuple : Value((_a, _b, _c)) ``` @@ -54,55 +52,53 @@ tag_tuple : Value((_a, _b, _c)) # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -LowerIdent(3:1-3:4),OpColon(3:5-3:6),UpperIdent(3:7-3:10), -LowerIdent(4:1-4:4),OpColon(4:5-4:6),UpperIdent(4:7-4:12),NoSpaceOpenRound(4:12-4:13),NamedUnderscore(4:13-4:15),Comma(4:15-4:16),NamedUnderscore(4:17-4:19),Comma(4:19-4:20),Underscore(4:21-4:22),CloseRound(4:22-4:23), -LowerIdent(5:1-5:4),OpColon(5:5-5:6),OpenRound(5:7-5:8),NamedUnderscore(5:8-5:10),Comma(5:10-5:11),NamedUnderscore(5:12-5:14),Comma(5:14-5:15),NamedUnderscore(5:16-5:18),CloseRound(5:18-5:19), -LowerIdent(6:1-6:8),OpColon(6:9-6:10),OpenRound(6:11-6:12),UpperIdent(6:12-6:14),Comma(6:14-6:15),UpperIdent(6:16-6:19),OpArrow(6:20-6:22),UpperIdent(6:23-6:26),CloseRound(6:26-6:27), -LowerIdent(7:1-7:6),OpColon(7:7-7:8),UpperIdent(7:9-7:13),NoSpaceOpenRound(7:13-7:14),UpperIdent(7:14-7:20),CloseRound(7:20-7:21),OpArrow(7:22-7:24),UpperIdent(7:25-7:31),NoSpaceOpenRound(7:31-7:32),OpenCurly(7:32-7:33),CloseCurly(7:33-7:34),Comma(7:34-7:35),Underscore(7:36-7:37),CloseRound(7:37-7:38), -LowerIdent(8:1-8:10),OpColon(8:11-8:12),UpperIdent(8:13-8:18),NoSpaceOpenRound(8:18-8:19),NoSpaceOpenRound(8:19-8:20),NamedUnderscore(8:20-8:22),Comma(8:22-8:23),NamedUnderscore(8:24-8:26),Comma(8:26-8:27),NamedUnderscore(8:28-8:30),CloseRound(8:30-8:31),CloseRound(8:31-8:32), -EndOfFile(9:1-9:1), +LowerIdent(1:1-1:4),OpColon(1:5-1:6),UpperIdent(1:7-1:10), +LowerIdent(2:1-2:4),OpColon(2:5-2:6),UpperIdent(2:7-2:12),NoSpaceOpenRound(2:12-2:13),NamedUnderscore(2:13-2:15),Comma(2:15-2:16),NamedUnderscore(2:17-2:19),Comma(2:19-2:20),Underscore(2:21-2:22),CloseRound(2:22-2:23), +LowerIdent(3:1-3:4),OpColon(3:5-3:6),OpenRound(3:7-3:8),NamedUnderscore(3:8-3:10),Comma(3:10-3:11),NamedUnderscore(3:12-3:14),Comma(3:14-3:15),NamedUnderscore(3:16-3:18),CloseRound(3:18-3:19), +LowerIdent(4:1-4:8),OpColon(4:9-4:10),OpenRound(4:11-4:12),UpperIdent(4:12-4:14),Comma(4:14-4:15),UpperIdent(4:16-4:19),OpArrow(4:20-4:22),UpperIdent(4:23-4:26),CloseRound(4:26-4:27), +LowerIdent(5:1-5:6),OpColon(5:7-5:8),UpperIdent(5:9-5:13),NoSpaceOpenRound(5:13-5:14),UpperIdent(5:14-5:20),CloseRound(5:20-5:21),OpArrow(5:22-5:24),UpperIdent(5:25-5:31),NoSpaceOpenRound(5:31-5:32),OpenCurly(5:32-5:33),CloseCurly(5:33-5:34),Comma(5:34-5:35),Underscore(5:36-5:37),CloseRound(5:37-5:38), +LowerIdent(6:1-6:10),OpColon(6:11-6:12),UpperIdent(6:13-6:18),NoSpaceOpenRound(6:18-6:19),NoSpaceOpenRound(6:19-6:20),NamedUnderscore(6:20-6:22),Comma(6:22-6:23),NamedUnderscore(6:24-6:26),Comma(6:26-6:27),NamedUnderscore(6:28-6:30),CloseRound(6:30-6:31),CloseRound(6:31-6:32), +EndOfFile(7:1-7:1), ~~~ # PARSE ~~~clojure -(file @1.1-8.32 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-6.32 + (type-module @1.1-1.4) (statements - (s-type-anno @3.1-3.10 (name "foo") - (ty @3.7-3.10 (name "U64"))) - (s-type-anno @4.1-4.23 (name "bar") - (ty-apply @4.7-4.23 - (ty @4.7-4.12 (name "Thing")) - (underscore-ty-var @4.13-4.15 (raw "_a")) - (underscore-ty-var @4.17-4.19 (raw "_b")) + (s-type-anno @1.1-1.10 (name "foo") + (ty @1.7-1.10 (name "U64"))) + (s-type-anno @2.1-2.23 (name "bar") + (ty-apply @2.7-2.23 + (ty @2.7-2.12 (name "Thing")) + (underscore-ty-var @2.13-2.15 (raw "_a")) + (underscore-ty-var @2.17-2.19 (raw "_b")) (_))) - (s-type-anno @5.1-5.19 (name "baz") - (ty-tuple @5.7-5.19 - (underscore-ty-var @5.8-5.10 (raw "_a")) - (underscore-ty-var @5.12-5.14 (raw "_b")) - (underscore-ty-var @5.16-5.18 (raw "_c")))) - (s-type-anno @6.1-6.27 (name "add_one") - (ty-fn @6.12-6.26 - (ty @6.12-6.14 (name "U8")) - (ty @6.16-6.19 (name "U16")) - (ty @6.23-6.26 (name "U32")))) - (s-type-anno @7.1-7.38 (name "main!") - (ty-fn @7.9-7.38 - (ty-apply @7.9-7.21 - (ty @7.9-7.13 (name "List")) - (ty @7.14-7.20 (name "String"))) - (ty-apply @7.25-7.38 - (ty @7.25-7.31 (name "Result")) - (ty-record @7.32-7.34) + (s-type-anno @3.1-3.19 (name "baz") + (ty-tuple @3.7-3.19 + (underscore-ty-var @3.8-3.10 (raw "_a")) + (underscore-ty-var @3.12-3.14 (raw "_b")) + (underscore-ty-var @3.16-3.18 (raw "_c")))) + (s-type-anno @4.1-4.27 (name "add_one") + (ty-fn @4.12-4.26 + (ty @4.12-4.14 (name "U8")) + (ty @4.16-4.19 (name "U16")) + (ty @4.23-4.26 (name "U32")))) + (s-type-anno @5.1-5.38 (name "main!") + (ty-fn @5.9-5.38 + (ty-apply @5.9-5.21 + (ty @5.9-5.13 (name "List")) + (ty @5.14-5.20 (name "String"))) + (ty-apply @5.25-5.38 + (ty @5.25-5.31 (name "Result")) + (ty-record @5.32-5.34) (_)))) - (s-type-anno @8.1-8.32 (name "tag_tuple") - (ty-apply @8.13-8.32 - (ty @8.13-8.18 (name "Value")) - (ty-tuple @8.19-8.31 - (underscore-ty-var @8.20-8.22 (raw "_a")) - (underscore-ty-var @8.24-8.26 (raw "_b")) - (underscore-ty-var @8.28-8.30 (raw "_c"))))))) + (s-type-anno @6.1-6.32 (name "tag_tuple") + (ty-apply @6.13-6.32 + (ty @6.13-6.18 (name "Value")) + (ty-tuple @6.19-6.31 + (underscore-ty-var @6.20-6.22 (raw "_a")) + (underscore-ty-var @6.24-6.26 (raw "_b")) + (underscore-ty-var @6.28-6.30 (raw "_c"))))))) ~~~ # FORMATTED ~~~roc diff --git a/test/snapshots/type_app_complex_nested.md b/test/snapshots/type_app_complex_nested.md index f6b8b340a6..55c39672ec 100644 --- a/test/snapshots/type_app_complex_nested.md +++ b/test/snapshots/type_app_complex_nested.md @@ -28,11 +28,14 @@ main! = |_| processComplex(Ok([Some(42), None])) ~~~ # EXPECTED UNDECLARED TYPE - type_app_complex_nested.md:18:33:18:38 +UNDECLARED TYPE - type_app_complex_nested.md:18:44:18:48 UNDECLARED TYPE - type_app_complex_nested.md:18:54:18:59 UNDECLARED TYPE - type_app_complex_nested.md:4:30:4:35 +UNDECLARED TYPE - type_app_complex_nested.md:4:41:4:45 UNDECLARED TYPE - type_app_complex_nested.md:4:51:4:56 UNUSED VARIABLE - type_app_complex_nested.md:7:12:7:21 UNDECLARED TYPE - type_app_complex_nested.md:12:14:12:19 +UNDECLARED TYPE - type_app_complex_nested.md:12:32:12:36 # PROBLEMS **UNDECLARED TYPE** The type _Maybe_ is not declared in this scope. @@ -45,6 +48,17 @@ ComplexType(a, b) : Result(List(Maybe(a)), Dict(Str, Error(b))) ^^^^^ +**UNDECLARED TYPE** +The type _Dict_ is not declared in this scope. + +This type is referenced here: +**type_app_complex_nested.md:18:44:18:48:** +```roc +ComplexType(a, b) : Result(List(Maybe(a)), Dict(Str, Error(b))) +``` + ^^^^ + + **UNDECLARED TYPE** The type _Error_ is not declared in this scope. @@ -67,6 +81,17 @@ processComplex : Result(List(Maybe(a)), Dict(Str, Error(_b))) -> List(a) ^^^^^ +**UNDECLARED TYPE** +The type _Dict_ is not declared in this scope. + +This type is referenced here: +**type_app_complex_nested.md:4:41:4:45:** +```roc +processComplex : Result(List(Maybe(a)), Dict(Str, Error(_b))) -> List(a) +``` + ^^^^ + + **UNDECLARED TYPE** The type _Error_ is not declared in this scope. @@ -101,6 +126,17 @@ deepNested : Maybe(Result(List(Dict(Str, a)), _b)) -> a ^^^^^ +**UNDECLARED TYPE** +The type _Dict_ is not declared in this scope. + +This type is referenced here: +**type_app_complex_nested.md:12:32:12:36:** +```roc +deepNested : Maybe(Result(List(Dict(Str, a)), _b)) -> a +``` + ^^^^ + + # TOKENS ~~~zig KwApp(1:1-1:4),OpenSquare(1:5-1:6),LowerIdent(1:6-1:11),CloseSquare(1:11-1:12),OpenCurly(1:13-1:14),LowerIdent(1:15-1:17),OpColon(1:17-1:18),KwPlatform(1:19-1:27),StringStart(1:28-1:29),StringPart(1:29-1:50),StringEnd(1:50-1:51),CloseCurly(1:52-1:53), @@ -278,16 +314,12 @@ main! = |_| processComplex(Ok([Some(42), None])) (annotation @5.1-5.15 (declared-type (ty-fn @4.18-4.73 (effectful false) - (ty-apply @4.18-4.62 (symbol "Result") - (ty-apply @4.25-4.39 (symbol "List") - (ty-apply @4.30-4.38 (symbol "Maybe") - (ty-var @4.36-4.37 (name "a")))) - (ty-apply @4.41-4.61 (symbol "Dict") - (ty @4.46-4.49 (name "Str")) - (ty-apply @4.51-4.60 (symbol "Error") - (ty-var @4.57-4.59 (name "_b"))))) - (ty-apply @4.66-4.73 (symbol "List") - (ty-var @4.71-4.72 (name "a"))))))) + (ty-apply @4.18-4.62 (name "Result") (local) + (ty-apply @4.18-4.62 (name "List") (builtin) + (ty-malformed @4.30-4.35)) + (ty-malformed @4.18-4.62)) + (ty-apply @4.66-4.73 (name "List") (builtin) + (ty-rigid-var-lookup (ty-rigid-var @4.36-4.37 (name "a")))))))) (d-let (p-assign @13.1-13.11 (ident "deepNested")) (e-lambda @13.14-15.2 @@ -298,14 +330,8 @@ main! = |_| processComplex(Ok([Some(42), None])) (annotation @13.1-13.11 (declared-type (ty-fn @12.14-12.56 (effectful false) - (ty-apply @12.14-12.51 (symbol "Maybe") - (ty-apply @12.20-12.50 (symbol "Result") - (ty-apply @12.27-12.45 (symbol "List") - (ty-apply @12.32-12.44 (symbol "Dict") - (ty @12.37-12.40 (name "Str")) - (ty-var @12.42-12.43 (name "a")))) - (ty-var @12.47-12.49 (name "_b")))) - (ty-var @12.55-12.56 (name "a")))))) + (ty-malformed @12.14-12.19) + (ty-rigid-var-lookup (ty-rigid-var @12.42-12.43 (name "a"))))))) (d-let (p-assign @20.1-20.6 (ident "main!")) (e-closure @20.9-20.49 @@ -324,37 +350,33 @@ main! = |_| processComplex(Ok([Some(42), None])) (elems (e-tag @20.32-20.40 (name "Some") (args - (e-int @20.37-20.39 (value "42")))) + (e-num @20.37-20.39 (value "42")))) (e-tag @20.42-20.46 (name "None"))))))))))) (s-alias-decl @18.1-18.64 (ty-header @18.1-18.18 (name "ComplexType") (ty-args - (ty-var @18.13-18.14 (name "a")) - (ty-var @18.16-18.17 (name "b")))) - (ty-apply @18.21-18.64 (symbol "Result") - (ty-apply @18.28-18.42 (symbol "List") - (ty-apply @18.33-18.41 (symbol "Maybe") - (ty-var @18.39-18.40 (name "a")))) - (ty-apply @18.44-18.63 (symbol "Dict") - (ty @18.49-18.52 (name "Str")) - (ty-apply @18.54-18.62 (symbol "Error") - (ty-var @18.60-18.61 (name "b"))))))) + (ty-rigid-var @18.13-18.14 (name "a")) + (ty-rigid-var @18.16-18.17 (name "b")))) + (ty-apply @18.21-18.64 (name "Result") (local) + (ty-apply @18.21-18.64 (name "List") (builtin) + (ty-malformed @18.33-18.38)) + (ty-malformed @18.21-18.64)))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @5.1-5.15 (type "Result(List(item), Dict) -> List(a)")) + (patt @5.1-5.15 (type "Result(List(Error), Error) -> List(a)")) (patt @13.1-13.11 (type "Error -> a")) (patt @20.1-20.6 (type "_arg -> List(a)"))) (type_decls (alias @18.1-18.64 (type "ComplexType(a, b)") (ty-header @18.1-18.18 (name "ComplexType") (ty-args - (ty-var @18.13-18.14 (name "a")) - (ty-var @18.16-18.17 (name "b")))))) + (ty-rigid-var @18.13-18.14 (name "a")) + (ty-rigid-var @18.16-18.17 (name "b")))))) (expressions - (expr @5.18-9.6 (type "Result(List(item), Dict) -> List(a)")) + (expr @5.18-9.6 (type "Result(List(Error), Error) -> List(a)")) (expr @13.14-15.2 (type "Error -> a")) (expr @20.9-20.49 (type "_arg -> List(a)")))) ~~~ diff --git a/test/snapshots/type_app_multiple_args.md b/test/snapshots/type_app_multiple_args.md index de4306aa9f..4bd764c562 100644 --- a/test/snapshots/type_app_multiple_args.md +++ b/test/snapshots/type_app_multiple_args.md @@ -13,9 +13,20 @@ processDict = |_dict| [] main! = |_| processDict(Dict.empty().insert("one", 1)) ~~~ # EXPECTED +UNDECLARED TYPE - type_app_multiple_args.md:3:15:3:19 UNDEFINED VARIABLE - type_app_multiple_args.md:6:25:6:35 -TOO MANY ARGS - type_app_multiple_args.md:3:15:3:29 # PROBLEMS +**UNDECLARED TYPE** +The type _Dict_ is not declared in this scope. + +This type is referenced here: +**type_app_multiple_args.md:3:15:3:19:** +```roc +processDict : Dict(Str, U64) -> List(Str) +``` + ^^^^ + + **UNDEFINED VARIABLE** Nothing is named `empty` in this scope. Is there an `import` or `exposing` missing up-top? @@ -27,16 +38,6 @@ main! = |_| processDict(Dict.empty().insert("one", 1)) ^^^^^^^^^^ -**TOO MANY ARGS** -The type _Dict_ expects 0 argument, but got 2 instead. -**type_app_multiple_args.md:3:15:3:29:** -```roc -processDict : Dict(Str, U64) -> List(Str) -``` - ^^^^^^^^^^^^^^ - - - # TOKENS ~~~zig KwApp(1:1-1:4),OpenSquare(1:5-1:6),LowerIdent(1:6-1:11),CloseSquare(1:11-1:12),OpenCurly(1:13-1:14),LowerIdent(1:15-1:17),OpColon(1:17-1:18),KwPlatform(1:19-1:27),StringStart(1:28-1:29),StringPart(1:29-1:50),StringEnd(1:50-1:51),CloseCurly(1:52-1:53), @@ -107,11 +108,9 @@ NO CHANGE (annotation @4.1-4.12 (declared-type (ty-fn @3.15-3.42 (effectful false) - (ty-apply @3.15-3.29 (symbol "Dict") - (ty @3.20-3.23 (name "Str")) - (ty @3.25-3.28 (name "U64"))) - (ty-apply @3.33-3.42 (symbol "List") - (ty @3.38-3.41 (name "Str"))))))) + (ty-malformed @3.15-3.19) + (ty-apply @3.33-3.42 (name "List") (builtin) + (ty-lookup @3.38-3.41 (name "Str") (builtin))))))) (d-let (p-assign @6.1-6.6 (ident "main!")) (e-closure @6.9-6.55 @@ -130,7 +129,7 @@ NO CHANGE (args (e-string @6.45-6.50 (e-literal @6.46-6.49 (string "one"))) - (e-int @6.52-6.53 (value "1"))))))))) + (e-num @6.52-6.53 (value "1"))))))))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/type_app_nested.md b/test/snapshots/type_app_nested.md index 5925231217..c9f8775e2b 100644 --- a/test/snapshots/type_app_nested.md +++ b/test/snapshots/type_app_nested.md @@ -105,12 +105,12 @@ main! = |_| processNested([]) (annotation @4.1-4.14 (declared-type (ty-fn @3.17-3.52 (effectful false) - (ty-apply @3.17-3.39 (symbol "List") - (ty-apply @3.22-3.38 (symbol "Result") - (ty @3.29-3.32 (name "Str")) - (ty @3.34-3.37 (name "Err")))) - (ty-apply @3.43-3.52 (symbol "List") - (ty @3.48-3.51 (name "Str"))))))) + (ty-apply @3.17-3.39 (name "List") (builtin) + (ty-apply @3.22-3.38 (name "Result") (local) + (ty-lookup @3.22-3.38 (name "Str") (builtin)) + (ty-malformed @3.22-3.38))) + (ty-apply @3.43-3.52 (name "List") (builtin) + (ty-lookup @3.48-3.51 (name "Str") (builtin))))))) (d-let (p-assign @6.1-6.6 (ident "main!")) (e-closure @6.9-6.30 @@ -128,9 +128,9 @@ main! = |_| processNested([]) ~~~clojure (inferred-types (defs - (patt @4.1-4.14 (type "List(Result(ok, err)) -> List(Str)")) + (patt @4.1-4.14 (type "List(Result(Str, Error)) -> List(Str)")) (patt @6.1-6.6 (type "_arg -> List(Str)"))) (expressions - (expr @4.17-4.38 (type "List(Result(ok, err)) -> List(Str)")) + (expr @4.17-4.38 (type "List(Result(Str, Error)) -> List(Str)")) (expr @6.9-6.30 (type "_arg -> List(Str)")))) ~~~ diff --git a/test/snapshots/type_app_single_arg.md b/test/snapshots/type_app_single_arg.md index 7e2aae2248..bd5a862bf1 100644 --- a/test/snapshots/type_app_single_arg.md +++ b/test/snapshots/type_app_single_arg.md @@ -92,9 +92,9 @@ main! = |_| processList(["one", "two"]) (annotation @4.1-4.12 (declared-type (ty-fn @3.15-3.31 (effectful false) - (ty-apply @3.15-3.24 (symbol "List") - (ty @3.20-3.23 (name "Str"))) - (ty @3.28-3.31 (name "U64")))))) + (ty-apply @3.15-3.24 (name "List") (builtin) + (ty-lookup @3.20-3.23 (name "Str") (builtin))) + (ty-lookup @3.28-3.31 (name "U64") (builtin)))))) (d-let (p-assign @6.1-6.6 (ident "main!")) (e-closure @6.9-6.39 @@ -117,9 +117,9 @@ main! = |_| processList(["one", "two"]) ~~~clojure (inferred-types (defs - (patt @4.1-4.12 (type "List(Str) -> U64")) - (patt @6.1-6.6 (type "_arg -> U64"))) + (patt @4.1-4.12 (type "List(Str) -> Num(Int(Unsigned64))")) + (patt @6.1-6.6 (type "_arg -> Num(Int(Unsigned64))"))) (expressions - (expr @4.15-4.32 (type "List(Str) -> U64")) - (expr @6.9-6.39 (type "_arg -> U64")))) + (expr @4.15-4.32 (type "List(Str) -> Num(Int(Unsigned64))")) + (expr @6.9-6.39 (type "_arg -> Num(Int(Unsigned64))")))) ~~~ diff --git a/test/snapshots/type_app_with_vars.md b/test/snapshots/type_app_with_vars.md index 12dcf6ccd2..4f905263ac 100644 --- a/test/snapshots/type_app_with_vars.md +++ b/test/snapshots/type_app_with_vars.md @@ -13,20 +13,20 @@ mapList = |list, fn| list.map(fn) main! = |_| mapList([1,2,3,4,5]) ~~~ # EXPECTED -TYPE MISMATCH - type_app_with_vars.md:6:13:6:20 +TYPE MISMATCH - type_app_with_vars.md:6:13:6:33 # PROBLEMS **TYPE MISMATCH** This expression is used in an unexpected way: -**type_app_with_vars.md:6:13:6:20:** +**type_app_with_vars.md:6:13:6:33:** ```roc main! = |_| mapList([1,2,3,4,5]) ``` - ^^^^^^^ + ^^^^^^^^^^^^^^^^^^^^ It has the type: _List(Num(_size)) -> _ret_ -But here it's being used as: +But I expected it to be: _List(a), a -> b -> List(b)_ # TOKENS @@ -116,14 +116,14 @@ main! = |_| mapList([1, 2, 3, 4, 5]) (annotation @4.1-4.8 (declared-type (ty-fn @3.11-3.39 (effectful false) - (ty-apply @3.11-3.18 (symbol "List") - (ty-var @3.16-3.17 (name "a"))) + (ty-apply @3.11-3.18 (name "List") (builtin) + (ty-rigid-var @3.16-3.17 (name "a"))) (ty-parens @3.20-3.28 (ty-fn @3.21-3.27 (effectful false) - (ty-var @3.21-3.22 (name "a")) - (ty-var @3.26-3.27 (name "b")))) - (ty-apply @3.32-3.39 (symbol "List") - (ty-var @3.37-3.38 (name "b"))))))) + (ty-rigid-var-lookup (ty-rigid-var @3.16-3.17 (name "a"))) + (ty-rigid-var @3.26-3.27 (name "b")))) + (ty-apply @3.32-3.39 (name "List") (builtin) + (ty-rigid-var-lookup (ty-rigid-var @3.26-3.27 (name "b")))))))) (d-let (p-assign @6.1-6.6 (ident "main!")) (e-closure @6.9-6.33 @@ -137,11 +137,11 @@ main! = |_| mapList([1, 2, 3, 4, 5]) (p-assign @4.1-4.8 (ident "mapList"))) (e-list @6.21-6.32 (elems - (e-int @6.22-6.23 (value "1")) - (e-int @6.24-6.25 (value "2")) - (e-int @6.26-6.27 (value "3")) - (e-int @6.28-6.29 (value "4")) - (e-int @6.30-6.31 (value "5"))))))))) + (e-num @6.22-6.23 (value "1")) + (e-num @6.24-6.25 (value "2")) + (e-num @6.26-6.27 (value "3")) + (e-num @6.28-6.29 (value "4")) + (e-num @6.30-6.31 (value "5"))))))))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/type_application_basic.md b/test/snapshots/type_application_basic.md index 4013b41bb2..142c6b4c57 100644 --- a/test/snapshots/type_application_basic.md +++ b/test/snapshots/type_application_basic.md @@ -94,9 +94,9 @@ main! = |_| processList(["one", "two", "three"]) (annotation @4.1-4.12 (declared-type (ty-fn @3.15-3.31 (effectful false) - (ty-apply @3.15-3.24 (symbol "List") - (ty @3.20-3.23 (name "Str"))) - (ty @3.28-3.31 (name "U64")))))) + (ty-apply @3.15-3.24 (name "List") (builtin) + (ty-lookup @3.20-3.23 (name "Str") (builtin))) + (ty-lookup @3.28-3.31 (name "U64") (builtin)))))) (d-let (p-assign @6.1-6.6 (ident "main!")) (e-closure @6.9-6.47 @@ -121,9 +121,9 @@ main! = |_| processList(["one", "two", "three"]) ~~~clojure (inferred-types (defs - (patt @4.1-4.12 (type "List(Str) -> U64")) - (patt @6.1-6.6 (type "_arg -> U64"))) + (patt @4.1-4.12 (type "List(Str) -> Num(Int(Unsigned64))")) + (patt @6.1-6.6 (type "_arg -> Num(Int(Unsigned64))"))) (expressions - (expr @4.15-4.32 (type "List(Str) -> U64")) - (expr @6.9-6.47 (type "_arg -> U64")))) + (expr @4.15-4.32 (type "List(Str) -> Num(Int(Unsigned64))")) + (expr @6.9-6.47 (type "_arg -> Num(Int(Unsigned64))")))) ~~~ diff --git a/test/snapshots/type_builtin.md b/test/snapshots/type_builtin.md index 523ad464d9..b4ed04fd3b 100644 --- a/test/snapshots/type_builtin.md +++ b/test/snapshots/type_builtin.md @@ -1,12 +1,10 @@ # META ~~~ini description=Simple test for built-in types in scope -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [MyNumber, MyString] - MyNumber : U64 MyString : Str ~~~ @@ -16,27 +14,23 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:17),Comma(1:17-1:18),UpperIdent(1:19-1:27),CloseSquare(1:27-1:28), -UpperIdent(3:1-3:9),OpColon(3:10-3:11),UpperIdent(3:12-3:15), -UpperIdent(4:1-4:9),OpColon(4:10-4:11),UpperIdent(4:12-4:15), -EndOfFile(5:1-5:1), +UpperIdent(1:1-1:9),OpColon(1:10-1:11),UpperIdent(1:12-1:15), +UpperIdent(2:1-2:9),OpColon(2:10-2:11),UpperIdent(2:12-2:15), +EndOfFile(3:1-3:1), ~~~ # PARSE ~~~clojure -(file @1.1-4.15 - (module @1.1-1.28 - (exposes @1.8-1.28 - (exposed-upper-ident @1.9-1.17 (text "MyNumber")) - (exposed-upper-ident @1.19-1.27 (text "MyString")))) +(file @1.1-2.15 + (type-module @1.1-1.9) (statements - (s-type-decl @3.1-3.15 - (header @3.1-3.9 (name "MyNumber") + (s-type-decl @1.1-1.15 + (header @1.1-1.9 (name "MyNumber") (args)) - (ty @3.12-3.15 (name "U64"))) - (s-type-decl @4.1-4.15 - (header @4.1-4.9 (name "MyString") + (ty @1.12-1.15 (name "U64"))) + (s-type-decl @2.1-2.15 + (header @2.1-2.9 (name "MyString") (args)) - (ty @4.12-4.15 (name "Str"))))) + (ty @2.12-2.15 (name "Str"))))) ~~~ # FORMATTED ~~~roc @@ -45,21 +39,21 @@ NO CHANGE # CANONICALIZE ~~~clojure (can-ir - (s-alias-decl @3.1-3.15 - (ty-header @3.1-3.9 (name "MyNumber")) - (ty @3.12-3.15 (name "U64"))) - (s-alias-decl @4.1-4.15 - (ty-header @4.1-4.9 (name "MyString")) - (ty @4.12-4.15 (name "Str")))) + (s-alias-decl @1.1-1.15 + (ty-header @1.1-1.9 (name "MyNumber")) + (ty-lookup @1.12-1.15 (name "U64") (builtin))) + (s-alias-decl @2.1-2.15 + (ty-header @2.1-2.9 (name "MyString")) + (ty-lookup @2.12-2.15 (name "Str") (builtin)))) ~~~ # TYPES ~~~clojure (inferred-types (defs) (type_decls - (alias @3.1-3.15 (type "MyNumber") - (ty-header @3.1-3.9 (name "MyNumber"))) - (alias @4.1-4.15 (type "MyString") - (ty-header @4.1-4.9 (name "MyString")))) + (alias @1.1-1.15 (type "MyNumber") + (ty-header @1.1-1.9 (name "MyNumber"))) + (alias @2.1-2.15 (type "MyString") + (ty-header @2.1-2.9 (name "MyString")))) (expressions)) ~~~ diff --git a/test/snapshots/type_checking/all_frac_types.md b/test/snapshots/type_checking/all_frac_types.md index 6c8b891298..af3c7df8e6 100644 --- a/test/snapshots/type_checking/all_frac_types.md +++ b/test/snapshots/type_checking/all_frac_types.md @@ -1,12 +1,10 @@ # META ~~~ini description=All fractional type annotations -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - a : F32 a = 3.14 @@ -22,36 +20,34 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -LowerIdent(3:1-3:2),OpColon(3:3-3:4),UpperIdent(3:5-3:8), -LowerIdent(4:1-4:2),OpAssign(4:3-4:4),Float(4:5-4:9), -LowerIdent(6:1-6:2),OpColon(6:3-6:4),UpperIdent(6:5-6:8), -LowerIdent(7:1-7:2),OpAssign(7:3-7:4),Float(7:5-7:12), -LowerIdent(9:1-9:2),OpColon(9:3-9:4),UpperIdent(9:5-9:8), -LowerIdent(10:1-10:2),OpAssign(10:3-10:4),Float(10:5-10:12), -EndOfFile(11:1-11:1), +LowerIdent(1:1-1:2),OpColon(1:3-1:4),UpperIdent(1:5-1:8), +LowerIdent(2:1-2:2),OpAssign(2:3-2:4),Float(2:5-2:9), +LowerIdent(4:1-4:2),OpColon(4:3-4:4),UpperIdent(4:5-4:8), +LowerIdent(5:1-5:2),OpAssign(5:3-5:4),Float(5:5-5:12), +LowerIdent(7:1-7:2),OpColon(7:3-7:4),UpperIdent(7:5-7:8), +LowerIdent(8:1-8:2),OpAssign(8:3-8:4),Float(8:5-8:12), +EndOfFile(9:1-9:1), ~~~ # PARSE ~~~clojure -(file @1.1-10.12 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-8.12 + (type-module @1.1-1.2) (statements - (s-type-anno @3.1-3.8 (name "a") - (ty @3.5-3.8 (name "F32"))) - (s-decl @4.1-4.9 - (p-ident @4.1-4.2 (raw "a")) - (e-frac @4.5-4.9 (raw "3.14"))) - (s-type-anno @6.1-6.8 (name "b") - (ty @6.5-6.8 (name "F64"))) - (s-decl @7.1-7.12 - (p-ident @7.1-7.2 (raw "b")) - (e-frac @7.5-7.12 (raw "2.71828"))) - (s-type-anno @9.1-9.8 (name "c") - (ty @9.5-9.8 (name "Dec"))) - (s-decl @10.1-10.12 - (p-ident @10.1-10.2 (raw "c")) - (e-frac @10.5-10.12 (raw "123.456"))))) + (s-type-anno @1.1-1.8 (name "a") + (ty @1.5-1.8 (name "F32"))) + (s-decl @2.1-2.9 + (p-ident @2.1-2.2 (raw "a")) + (e-frac @2.5-2.9 (raw "3.14"))) + (s-type-anno @4.1-4.8 (name "b") + (ty @4.5-4.8 (name "F64"))) + (s-decl @5.1-5.12 + (p-ident @5.1-5.2 (raw "b")) + (e-frac @5.5-5.12 (raw "2.71828"))) + (s-type-anno @7.1-7.8 (name "c") + (ty @7.5-7.8 (name "Dec"))) + (s-decl @8.1-8.12 + (p-ident @8.1-8.2 (raw "c")) + (e-frac @8.5-8.12 (raw "123.456"))))) ~~~ # FORMATTED ~~~roc @@ -61,33 +57,33 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @4.1-4.2 (ident "a")) - (e-dec-small @4.5-4.9 (numerator "314") (denominator-power-of-ten "2") (value "3.14")) - (annotation @4.1-4.2 + (p-assign @2.1-2.2 (ident "a")) + (e-dec-small @2.5-2.9 (numerator "314") (denominator-power-of-ten "2") (value "3.14")) + (annotation @2.1-2.2 (declared-type - (ty @3.5-3.8 (name "F32"))))) + (ty-lookup @1.5-1.8 (name "F32") (builtin))))) (d-let - (p-assign @7.1-7.2 (ident "b")) - (e-frac-dec @7.5-7.12 (value "2.71828")) - (annotation @7.1-7.2 + (p-assign @5.1-5.2 (ident "b")) + (e-frac-dec @5.5-5.12 (value "2.71828")) + (annotation @5.1-5.2 (declared-type - (ty @6.5-6.8 (name "F64"))))) + (ty-lookup @4.5-4.8 (name "F64") (builtin))))) (d-let - (p-assign @10.1-10.2 (ident "c")) - (e-frac-dec @10.5-10.12 (value "123.456")) - (annotation @10.1-10.2 + (p-assign @8.1-8.2 (ident "c")) + (e-frac-dec @8.5-8.12 (value "123.456")) + (annotation @8.1-8.2 (declared-type - (ty @9.5-9.8 (name "Dec")))))) + (ty-lookup @7.5-7.8 (name "Dec") (builtin)))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @4.1-4.2 (type "F32")) - (patt @7.1-7.2 (type "F64")) - (patt @10.1-10.2 (type "Dec"))) + (patt @2.1-2.2 (type "Num(Frac(Float32))")) + (patt @5.1-5.2 (type "Num(Frac(Float64))")) + (patt @8.1-8.2 (type "Num(Frac(Decimal))"))) (expressions - (expr @4.5-4.9 (type "F32")) - (expr @7.5-7.12 (type "F64")) - (expr @10.5-10.12 (type "Dec")))) + (expr @2.5-2.9 (type "Num(Frac(Float32))")) + (expr @5.5-5.12 (type "Num(Frac(Float64))")) + (expr @8.5-8.12 (type "Num(Frac(Decimal))")))) ~~~ diff --git a/test/snapshots/type_checking/all_int_types.md b/test/snapshots/type_checking/all_int_types.md index d612f95667..bda058dcdf 100644 --- a/test/snapshots/type_checking/all_int_types.md +++ b/test/snapshots/type_checking/all_int_types.md @@ -1,12 +1,10 @@ # META ~~~ini description=All integer type annotations -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - a : U8 a = 255 @@ -43,85 +41,83 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -LowerIdent(3:1-3:2),OpColon(3:3-3:4),UpperIdent(3:5-3:7), -LowerIdent(4:1-4:2),OpAssign(4:3-4:4),Int(4:5-4:8), -LowerIdent(6:1-6:2),OpColon(6:3-6:4),UpperIdent(6:5-6:8), -LowerIdent(7:1-7:2),OpAssign(7:3-7:4),Int(7:5-7:10), -LowerIdent(9:1-9:2),OpColon(9:3-9:4),UpperIdent(9:5-9:8), -LowerIdent(10:1-10:2),OpAssign(10:3-10:4),Int(10:5-10:15), -LowerIdent(12:1-12:2),OpColon(12:3-12:4),UpperIdent(12:5-12:8), -LowerIdent(13:1-13:2),OpAssign(13:3-13:4),Int(13:5-13:25), -LowerIdent(15:1-15:2),OpColon(15:3-15:4),UpperIdent(15:5-15:9), -LowerIdent(16:1-16:2),OpAssign(16:3-16:4),Int(16:5-16:44), -LowerIdent(18:1-18:2),OpColon(18:3-18:4),UpperIdent(18:5-18:7), -LowerIdent(19:1-19:2),OpAssign(19:3-19:4),Int(19:5-19:9), -LowerIdent(21:1-21:2),OpColon(21:3-21:4),UpperIdent(21:5-21:8), -LowerIdent(22:1-22:2),OpAssign(22:3-22:4),Int(22:5-22:11), -LowerIdent(24:1-24:2),OpColon(24:3-24:4),UpperIdent(24:5-24:8), -LowerIdent(25:1-25:2),OpAssign(25:3-25:4),Int(25:5-25:16), -LowerIdent(27:1-27:2),OpColon(27:3-27:4),UpperIdent(27:5-27:8), -LowerIdent(28:1-28:2),OpAssign(28:3-28:4),Int(28:5-28:25), -LowerIdent(30:1-30:2),OpColon(30:3-30:4),UpperIdent(30:5-30:9), -LowerIdent(31:1-31:2),OpAssign(31:3-31:4),Int(31:5-31:45), -EndOfFile(32:1-32:1), +LowerIdent(1:1-1:2),OpColon(1:3-1:4),UpperIdent(1:5-1:7), +LowerIdent(2:1-2:2),OpAssign(2:3-2:4),Int(2:5-2:8), +LowerIdent(4:1-4:2),OpColon(4:3-4:4),UpperIdent(4:5-4:8), +LowerIdent(5:1-5:2),OpAssign(5:3-5:4),Int(5:5-5:10), +LowerIdent(7:1-7:2),OpColon(7:3-7:4),UpperIdent(7:5-7:8), +LowerIdent(8:1-8:2),OpAssign(8:3-8:4),Int(8:5-8:15), +LowerIdent(10:1-10:2),OpColon(10:3-10:4),UpperIdent(10:5-10:8), +LowerIdent(11:1-11:2),OpAssign(11:3-11:4),Int(11:5-11:25), +LowerIdent(13:1-13:2),OpColon(13:3-13:4),UpperIdent(13:5-13:9), +LowerIdent(14:1-14:2),OpAssign(14:3-14:4),Int(14:5-14:44), +LowerIdent(16:1-16:2),OpColon(16:3-16:4),UpperIdent(16:5-16:7), +LowerIdent(17:1-17:2),OpAssign(17:3-17:4),Int(17:5-17:9), +LowerIdent(19:1-19:2),OpColon(19:3-19:4),UpperIdent(19:5-19:8), +LowerIdent(20:1-20:2),OpAssign(20:3-20:4),Int(20:5-20:11), +LowerIdent(22:1-22:2),OpColon(22:3-22:4),UpperIdent(22:5-22:8), +LowerIdent(23:1-23:2),OpAssign(23:3-23:4),Int(23:5-23:16), +LowerIdent(25:1-25:2),OpColon(25:3-25:4),UpperIdent(25:5-25:8), +LowerIdent(26:1-26:2),OpAssign(26:3-26:4),Int(26:5-26:25), +LowerIdent(28:1-28:2),OpColon(28:3-28:4),UpperIdent(28:5-28:9), +LowerIdent(29:1-29:2),OpAssign(29:3-29:4),Int(29:5-29:45), +EndOfFile(30:1-30:1), ~~~ # PARSE ~~~clojure -(file @1.1-31.45 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-29.45 + (type-module @1.1-1.2) (statements - (s-type-anno @3.1-3.7 (name "a") - (ty @3.5-3.7 (name "U8"))) - (s-decl @4.1-4.8 - (p-ident @4.1-4.2 (raw "a")) - (e-int @4.5-4.8 (raw "255"))) - (s-type-anno @6.1-6.8 (name "b") - (ty @6.5-6.8 (name "U16"))) - (s-decl @7.1-7.10 - (p-ident @7.1-7.2 (raw "b")) - (e-int @7.5-7.10 (raw "65535"))) - (s-type-anno @9.1-9.8 (name "c") - (ty @9.5-9.8 (name "U32"))) - (s-decl @10.1-10.15 - (p-ident @10.1-10.2 (raw "c")) - (e-int @10.5-10.15 (raw "4294967295"))) - (s-type-anno @12.1-12.8 (name "d") - (ty @12.5-12.8 (name "U64"))) - (s-decl @13.1-13.25 - (p-ident @13.1-13.2 (raw "d")) - (e-int @13.5-13.25 (raw "18446744073709551615"))) - (s-type-anno @15.1-15.9 (name "e") - (ty @15.5-15.9 (name "U128"))) - (s-decl @16.1-16.44 - (p-ident @16.1-16.2 (raw "e")) - (e-int @16.5-16.44 (raw "340282366920938463463374607431768211455"))) - (s-type-anno @18.1-18.7 (name "f") - (ty @18.5-18.7 (name "I8"))) - (s-decl @19.1-19.9 - (p-ident @19.1-19.2 (raw "f")) - (e-int @19.5-19.9 (raw "-128"))) - (s-type-anno @21.1-21.8 (name "g") - (ty @21.5-21.8 (name "I16"))) - (s-decl @22.1-22.11 - (p-ident @22.1-22.2 (raw "g")) - (e-int @22.5-22.11 (raw "-32768"))) - (s-type-anno @24.1-24.8 (name "h") - (ty @24.5-24.8 (name "I32"))) - (s-decl @25.1-25.16 - (p-ident @25.1-25.2 (raw "h")) - (e-int @25.5-25.16 (raw "-2147483648"))) - (s-type-anno @27.1-27.8 (name "i") - (ty @27.5-27.8 (name "I64"))) - (s-decl @28.1-28.25 - (p-ident @28.1-28.2 (raw "i")) - (e-int @28.5-28.25 (raw "-9223372036854775808"))) - (s-type-anno @30.1-30.9 (name "j") - (ty @30.5-30.9 (name "I128"))) - (s-decl @31.1-31.45 - (p-ident @31.1-31.2 (raw "j")) - (e-int @31.5-31.45 (raw "-170141183460469231731687303715884105728"))))) + (s-type-anno @1.1-1.7 (name "a") + (ty @1.5-1.7 (name "U8"))) + (s-decl @2.1-2.8 + (p-ident @2.1-2.2 (raw "a")) + (e-int @2.5-2.8 (raw "255"))) + (s-type-anno @4.1-4.8 (name "b") + (ty @4.5-4.8 (name "U16"))) + (s-decl @5.1-5.10 + (p-ident @5.1-5.2 (raw "b")) + (e-int @5.5-5.10 (raw "65535"))) + (s-type-anno @7.1-7.8 (name "c") + (ty @7.5-7.8 (name "U32"))) + (s-decl @8.1-8.15 + (p-ident @8.1-8.2 (raw "c")) + (e-int @8.5-8.15 (raw "4294967295"))) + (s-type-anno @10.1-10.8 (name "d") + (ty @10.5-10.8 (name "U64"))) + (s-decl @11.1-11.25 + (p-ident @11.1-11.2 (raw "d")) + (e-int @11.5-11.25 (raw "18446744073709551615"))) + (s-type-anno @13.1-13.9 (name "e") + (ty @13.5-13.9 (name "U128"))) + (s-decl @14.1-14.44 + (p-ident @14.1-14.2 (raw "e")) + (e-int @14.5-14.44 (raw "340282366920938463463374607431768211455"))) + (s-type-anno @16.1-16.7 (name "f") + (ty @16.5-16.7 (name "I8"))) + (s-decl @17.1-17.9 + (p-ident @17.1-17.2 (raw "f")) + (e-int @17.5-17.9 (raw "-128"))) + (s-type-anno @19.1-19.8 (name "g") + (ty @19.5-19.8 (name "I16"))) + (s-decl @20.1-20.11 + (p-ident @20.1-20.2 (raw "g")) + (e-int @20.5-20.11 (raw "-32768"))) + (s-type-anno @22.1-22.8 (name "h") + (ty @22.5-22.8 (name "I32"))) + (s-decl @23.1-23.16 + (p-ident @23.1-23.2 (raw "h")) + (e-int @23.5-23.16 (raw "-2147483648"))) + (s-type-anno @25.1-25.8 (name "i") + (ty @25.5-25.8 (name "I64"))) + (s-decl @26.1-26.25 + (p-ident @26.1-26.2 (raw "i")) + (e-int @26.5-26.25 (raw "-9223372036854775808"))) + (s-type-anno @28.1-28.9 (name "j") + (ty @28.5-28.9 (name "I128"))) + (s-decl @29.1-29.45 + (p-ident @29.1-29.2 (raw "j")) + (e-int @29.5-29.45 (raw "-170141183460469231731687303715884105728"))))) ~~~ # FORMATTED ~~~roc @@ -131,89 +127,89 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @4.1-4.2 (ident "a")) - (e-int @4.5-4.8 (value "255")) - (annotation @4.1-4.2 + (p-assign @2.1-2.2 (ident "a")) + (e-num @2.5-2.8 (value "255")) + (annotation @2.1-2.2 (declared-type - (ty @3.5-3.7 (name "U8"))))) + (ty-lookup @1.5-1.7 (name "U8") (builtin))))) (d-let - (p-assign @7.1-7.2 (ident "b")) - (e-int @7.5-7.10 (value "65535")) - (annotation @7.1-7.2 + (p-assign @5.1-5.2 (ident "b")) + (e-num @5.5-5.10 (value "65535")) + (annotation @5.1-5.2 (declared-type - (ty @6.5-6.8 (name "U16"))))) + (ty-lookup @4.5-4.8 (name "U16") (builtin))))) (d-let - (p-assign @10.1-10.2 (ident "c")) - (e-int @10.5-10.15 (value "4294967295")) - (annotation @10.1-10.2 + (p-assign @8.1-8.2 (ident "c")) + (e-num @8.5-8.15 (value "4294967295")) + (annotation @8.1-8.2 (declared-type - (ty @9.5-9.8 (name "U32"))))) + (ty-lookup @7.5-7.8 (name "U32") (builtin))))) (d-let - (p-assign @13.1-13.2 (ident "d")) - (e-int @13.5-13.25 (value "18446744073709551615")) - (annotation @13.1-13.2 + (p-assign @11.1-11.2 (ident "d")) + (e-num @11.5-11.25 (value "18446744073709551615")) + (annotation @11.1-11.2 (declared-type - (ty @12.5-12.8 (name "U64"))))) + (ty-lookup @10.5-10.8 (name "U64") (builtin))))) (d-let - (p-assign @16.1-16.2 (ident "e")) - (e-int @16.5-16.44 (value "-1")) - (annotation @16.1-16.2 + (p-assign @14.1-14.2 (ident "e")) + (e-num @14.5-14.44 (value "340282366920938463463374607431768211455")) + (annotation @14.1-14.2 (declared-type - (ty @15.5-15.9 (name "U128"))))) + (ty-lookup @13.5-13.9 (name "U128") (builtin))))) (d-let - (p-assign @19.1-19.2 (ident "f")) - (e-int @19.5-19.9 (value "-128")) - (annotation @19.1-19.2 + (p-assign @17.1-17.2 (ident "f")) + (e-num @17.5-17.9 (value "-128")) + (annotation @17.1-17.2 (declared-type - (ty @18.5-18.7 (name "I8"))))) + (ty-lookup @16.5-16.7 (name "I8") (builtin))))) (d-let - (p-assign @22.1-22.2 (ident "g")) - (e-int @22.5-22.11 (value "-32768")) - (annotation @22.1-22.2 + (p-assign @20.1-20.2 (ident "g")) + (e-num @20.5-20.11 (value "-32768")) + (annotation @20.1-20.2 (declared-type - (ty @21.5-21.8 (name "I16"))))) + (ty-lookup @19.5-19.8 (name "I16") (builtin))))) (d-let - (p-assign @25.1-25.2 (ident "h")) - (e-int @25.5-25.16 (value "-2147483648")) - (annotation @25.1-25.2 + (p-assign @23.1-23.2 (ident "h")) + (e-num @23.5-23.16 (value "-2147483648")) + (annotation @23.1-23.2 (declared-type - (ty @24.5-24.8 (name "I32"))))) + (ty-lookup @22.5-22.8 (name "I32") (builtin))))) (d-let - (p-assign @28.1-28.2 (ident "i")) - (e-int @28.5-28.25 (value "-9223372036854775808")) - (annotation @28.1-28.2 + (p-assign @26.1-26.2 (ident "i")) + (e-num @26.5-26.25 (value "-9223372036854775808")) + (annotation @26.1-26.2 (declared-type - (ty @27.5-27.8 (name "I64"))))) + (ty-lookup @25.5-25.8 (name "I64") (builtin))))) (d-let - (p-assign @31.1-31.2 (ident "j")) - (e-int @31.5-31.45 (value "-170141183460469231731687303715884105728")) - (annotation @31.1-31.2 + (p-assign @29.1-29.2 (ident "j")) + (e-num @29.5-29.45 (value "-170141183460469231731687303715884105728")) + (annotation @29.1-29.2 (declared-type - (ty @30.5-30.9 (name "I128")))))) + (ty-lookup @28.5-28.9 (name "I128") (builtin)))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @4.1-4.2 (type "U8")) - (patt @7.1-7.2 (type "U16")) - (patt @10.1-10.2 (type "U32")) - (patt @13.1-13.2 (type "U64")) - (patt @16.1-16.2 (type "U128")) - (patt @19.1-19.2 (type "I8")) - (patt @22.1-22.2 (type "I16")) - (patt @25.1-25.2 (type "I32")) - (patt @28.1-28.2 (type "I64")) - (patt @31.1-31.2 (type "I128"))) + (patt @2.1-2.2 (type "Num(Int(Unsigned8))")) + (patt @5.1-5.2 (type "Num(Int(Unsigned16))")) + (patt @8.1-8.2 (type "Num(Int(Unsigned32))")) + (patt @11.1-11.2 (type "Num(Int(Unsigned64))")) + (patt @14.1-14.2 (type "Num(Int(Unsigned128))")) + (patt @17.1-17.2 (type "Num(Int(Signed8))")) + (patt @20.1-20.2 (type "Num(Int(Signed16))")) + (patt @23.1-23.2 (type "Num(Int(Signed32))")) + (patt @26.1-26.2 (type "Num(Int(Signed64))")) + (patt @29.1-29.2 (type "Num(Int(Signed128))"))) (expressions - (expr @4.5-4.8 (type "U8")) - (expr @7.5-7.10 (type "U16")) - (expr @10.5-10.15 (type "U32")) - (expr @13.5-13.25 (type "U64")) - (expr @16.5-16.44 (type "U128")) - (expr @19.5-19.9 (type "I8")) - (expr @22.5-22.11 (type "I16")) - (expr @25.5-25.16 (type "I32")) - (expr @28.5-28.25 (type "I64")) - (expr @31.5-31.45 (type "I128")))) + (expr @2.5-2.8 (type "Num(Int(Unsigned8))")) + (expr @5.5-5.10 (type "Num(Int(Unsigned16))")) + (expr @8.5-8.15 (type "Num(Int(Unsigned32))")) + (expr @11.5-11.25 (type "Num(Int(Unsigned64))")) + (expr @14.5-14.44 (type "Num(Int(Unsigned128))")) + (expr @17.5-17.9 (type "Num(Int(Signed8))")) + (expr @20.5-20.11 (type "Num(Int(Signed16))")) + (expr @23.5-23.16 (type "Num(Int(Signed32))")) + (expr @26.5-26.25 (type "Num(Int(Signed64))")) + (expr @29.5-29.45 (type "Num(Int(Signed128))")))) ~~~ diff --git a/test/snapshots/type_checking/dec_annotation.md b/test/snapshots/type_checking/dec_annotation.md index 5178252163..35162f2e3d 100644 --- a/test/snapshots/type_checking/dec_annotation.md +++ b/test/snapshots/type_checking/dec_annotation.md @@ -1,12 +1,10 @@ # META ~~~ini description=Dec type annotation -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - x : Dec x = 123.456 ~~~ @@ -16,22 +14,20 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -LowerIdent(3:1-3:2),OpColon(3:3-3:4),UpperIdent(3:5-3:8), -LowerIdent(4:1-4:2),OpAssign(4:3-4:4),Float(4:5-4:12), -EndOfFile(5:1-5:1), +LowerIdent(1:1-1:2),OpColon(1:3-1:4),UpperIdent(1:5-1:8), +LowerIdent(2:1-2:2),OpAssign(2:3-2:4),Float(2:5-2:12), +EndOfFile(3:1-3:1), ~~~ # PARSE ~~~clojure -(file @1.1-4.12 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-2.12 + (type-module @1.1-1.2) (statements - (s-type-anno @3.1-3.8 (name "x") - (ty @3.5-3.8 (name "Dec"))) - (s-decl @4.1-4.12 - (p-ident @4.1-4.2 (raw "x")) - (e-frac @4.5-4.12 (raw "123.456"))))) + (s-type-anno @1.1-1.8 (name "x") + (ty @1.5-1.8 (name "Dec"))) + (s-decl @2.1-2.12 + (p-ident @2.1-2.2 (raw "x")) + (e-frac @2.5-2.12 (raw "123.456"))))) ~~~ # FORMATTED ~~~roc @@ -41,17 +37,17 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @4.1-4.2 (ident "x")) - (e-frac-dec @4.5-4.12 (value "123.456")) - (annotation @4.1-4.2 + (p-assign @2.1-2.2 (ident "x")) + (e-frac-dec @2.5-2.12 (value "123.456")) + (annotation @2.1-2.2 (declared-type - (ty @3.5-3.8 (name "Dec")))))) + (ty-lookup @1.5-1.8 (name "Dec") (builtin)))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @4.1-4.2 (type "Dec"))) + (patt @2.1-2.2 (type "Num(Frac(Decimal))"))) (expressions - (expr @4.5-4.12 (type "Dec")))) + (expr @2.5-2.12 (type "Num(Frac(Decimal))")))) ~~~ diff --git a/test/snapshots/type_checking/str_annotation_simple.md b/test/snapshots/type_checking/str_annotation_simple.md index e7dbde3305..a8d92e6ce0 100644 --- a/test/snapshots/type_checking/str_annotation_simple.md +++ b/test/snapshots/type_checking/str_annotation_simple.md @@ -1,12 +1,10 @@ # META ~~~ini description=Simple Str type annotation -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - x : Str x = "hello" ~~~ @@ -16,23 +14,21 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -LowerIdent(3:1-3:2),OpColon(3:3-3:4),UpperIdent(3:5-3:8), -LowerIdent(4:1-4:2),OpAssign(4:3-4:4),StringStart(4:5-4:6),StringPart(4:6-4:11),StringEnd(4:11-4:12), -EndOfFile(5:1-5:1), +LowerIdent(1:1-1:2),OpColon(1:3-1:4),UpperIdent(1:5-1:8), +LowerIdent(2:1-2:2),OpAssign(2:3-2:4),StringStart(2:5-2:6),StringPart(2:6-2:11),StringEnd(2:11-2:12), +EndOfFile(3:1-3:1), ~~~ # PARSE ~~~clojure -(file @1.1-4.12 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-2.12 + (type-module @1.1-1.2) (statements - (s-type-anno @3.1-3.8 (name "x") - (ty @3.5-3.8 (name "Str"))) - (s-decl @4.1-4.12 - (p-ident @4.1-4.2 (raw "x")) - (e-string @4.5-4.12 - (e-string-part @4.6-4.11 (raw "hello")))))) + (s-type-anno @1.1-1.8 (name "x") + (ty @1.5-1.8 (name "Str"))) + (s-decl @2.1-2.12 + (p-ident @2.1-2.2 (raw "x")) + (e-string @2.5-2.12 + (e-string-part @2.6-2.11 (raw "hello")))))) ~~~ # FORMATTED ~~~roc @@ -42,18 +38,18 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @4.1-4.2 (ident "x")) - (e-string @4.5-4.12 - (e-literal @4.6-4.11 (string "hello"))) - (annotation @4.1-4.2 + (p-assign @2.1-2.2 (ident "x")) + (e-string @2.5-2.12 + (e-literal @2.6-2.11 (string "hello"))) + (annotation @2.1-2.2 (declared-type - (ty @3.5-3.8 (name "Str")))))) + (ty-lookup @1.5-1.8 (name "Str") (builtin)))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @4.1-4.2 (type "Str"))) + (patt @2.1-2.2 (type "Str"))) (expressions - (expr @4.5-4.12 (type "Str")))) + (expr @2.5-2.12 (type "Str")))) ~~~ diff --git a/test/snapshots/type_checking/u8_annotation_large_value.md b/test/snapshots/type_checking/u8_annotation_large_value.md index cdd55a01df..aa8c66af35 100644 --- a/test/snapshots/type_checking/u8_annotation_large_value.md +++ b/test/snapshots/type_checking/u8_annotation_large_value.md @@ -1,47 +1,43 @@ # META ~~~ini description=U8 type annotation with value exceeding U8 range -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - x : U8 x = 500 ~~~ # EXPECTED -NUMBER DOES NOT FIT IN TYPE - u8_annotation_large_value.md:4:5:4:8 +NUMBER DOES NOT FIT IN TYPE - u8_annotation_large_value.md:2:5:2:8 # PROBLEMS **NUMBER DOES NOT FIT IN TYPE** The number **500** does not fit in its inferred type: -**u8_annotation_large_value.md:4:5:4:8:** +**u8_annotation_large_value.md:2:5:2:8:** ```roc x = 500 ``` ^^^ Its inferred type is: - _U8_ + _Num(Int(Unsigned8))_ # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -LowerIdent(3:1-3:2),OpColon(3:3-3:4),UpperIdent(3:5-3:7), -LowerIdent(4:1-4:2),OpAssign(4:3-4:4),Int(4:5-4:8), -EndOfFile(5:1-5:1), +LowerIdent(1:1-1:2),OpColon(1:3-1:4),UpperIdent(1:5-1:7), +LowerIdent(2:1-2:2),OpAssign(2:3-2:4),Int(2:5-2:8), +EndOfFile(3:1-3:1), ~~~ # PARSE ~~~clojure -(file @1.1-4.8 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-2.8 + (type-module @1.1-1.2) (statements - (s-type-anno @3.1-3.7 (name "x") - (ty @3.5-3.7 (name "U8"))) - (s-decl @4.1-4.8 - (p-ident @4.1-4.2 (raw "x")) - (e-int @4.5-4.8 (raw "500"))))) + (s-type-anno @1.1-1.7 (name "x") + (ty @1.5-1.7 (name "U8"))) + (s-decl @2.1-2.8 + (p-ident @2.1-2.2 (raw "x")) + (e-int @2.5-2.8 (raw "500"))))) ~~~ # FORMATTED ~~~roc @@ -51,17 +47,17 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @4.1-4.2 (ident "x")) - (e-int @4.5-4.8 (value "500")) - (annotation @4.1-4.2 + (p-assign @2.1-2.2 (ident "x")) + (e-num @2.5-2.8 (value "500")) + (annotation @2.1-2.2 (declared-type - (ty @3.5-3.7 (name "U8")))))) + (ty-lookup @1.5-1.7 (name "U8") (builtin)))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @4.1-4.2 (type "Error"))) + (patt @2.1-2.2 (type "Error"))) (expressions - (expr @4.5-4.8 (type "Error")))) + (expr @2.5-2.8 (type "Error")))) ~~~ diff --git a/test/snapshots/type_checking/u8_negative_value.md b/test/snapshots/type_checking/u8_negative_value.md index 6f2b5c7e8f..ed37bf5257 100644 --- a/test/snapshots/type_checking/u8_negative_value.md +++ b/test/snapshots/type_checking/u8_negative_value.md @@ -1,47 +1,43 @@ # META ~~~ini description=U8 type annotation with negative value -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - x : U8 x = -1 ~~~ # EXPECTED -NEGATIVE UNSIGNED INTEGER - u8_negative_value.md:4:5:4:7 +NEGATIVE UNSIGNED INTEGER - u8_negative_value.md:2:5:2:7 # PROBLEMS **NEGATIVE UNSIGNED INTEGER** The number **-1** is **signed** because it is negative: -**u8_negative_value.md:4:5:4:7:** +**u8_negative_value.md:2:5:2:7:** ```roc x = -1 ``` ^^ However, its inferred type is **unsigned**: - _U8_ + _Num(Int(Unsigned8))_ # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -LowerIdent(3:1-3:2),OpColon(3:3-3:4),UpperIdent(3:5-3:7), -LowerIdent(4:1-4:2),OpAssign(4:3-4:4),Int(4:5-4:7), -EndOfFile(5:1-5:1), +LowerIdent(1:1-1:2),OpColon(1:3-1:4),UpperIdent(1:5-1:7), +LowerIdent(2:1-2:2),OpAssign(2:3-2:4),Int(2:5-2:7), +EndOfFile(3:1-3:1), ~~~ # PARSE ~~~clojure -(file @1.1-4.7 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-2.7 + (type-module @1.1-1.2) (statements - (s-type-anno @3.1-3.7 (name "x") - (ty @3.5-3.7 (name "U8"))) - (s-decl @4.1-4.7 - (p-ident @4.1-4.2 (raw "x")) - (e-int @4.5-4.7 (raw "-1"))))) + (s-type-anno @1.1-1.7 (name "x") + (ty @1.5-1.7 (name "U8"))) + (s-decl @2.1-2.7 + (p-ident @2.1-2.2 (raw "x")) + (e-int @2.5-2.7 (raw "-1"))))) ~~~ # FORMATTED ~~~roc @@ -51,17 +47,17 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @4.1-4.2 (ident "x")) - (e-int @4.5-4.7 (value "-1")) - (annotation @4.1-4.2 + (p-assign @2.1-2.2 (ident "x")) + (e-num @2.5-2.7 (value "-1")) + (annotation @2.1-2.2 (declared-type - (ty @3.5-3.7 (name "U8")))))) + (ty-lookup @1.5-1.7 (name "U8") (builtin)))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @4.1-4.2 (type "Error"))) + (patt @2.1-2.2 (type "Error"))) (expressions - (expr @4.5-4.7 (type "Error")))) + (expr @2.5-2.7 (type "Error")))) ~~~ diff --git a/test/snapshots/type_comprehensive_scope.md b/test/snapshots/type_comprehensive_scope.md index faf7a2665d..fd1ad46b1c 100644 --- a/test/snapshots/type_comprehensive_scope.md +++ b/test/snapshots/type_comprehensive_scope.md @@ -1,12 +1,10 @@ # META ~~~ini description=Comprehensive type scope validation - built-ins, user types, redeclaration, forward refs -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [MyU64, Person, Result, Tree, Node] - # Built-in types should work MyU64 : U64 MyString : Str @@ -45,16 +43,17 @@ Complex : { } ~~~ # EXPECTED -TYPE REDECLARED - type_comprehensive_scope.md:12:1:12:37 -UNDECLARED TYPE - type_comprehensive_scope.md:15:19:15:23 -TYPE REDECLARED - type_comprehensive_scope.md:24:1:24:13 -UNDECLARED TYPE - type_comprehensive_scope.md:27:11:27:29 +TYPE REDECLARED - type_comprehensive_scope.md:10:1:10:37 +UNDECLARED TYPE - type_comprehensive_scope.md:13:19:13:23 +TYPE REDECLARED - type_comprehensive_scope.md:22:1:22:13 +UNDECLARED TYPE - type_comprehensive_scope.md:25:11:25:29 +UNDECLARED TYPE - type_comprehensive_scope.md:29:10:29:14 # PROBLEMS **TYPE REDECLARED** The type _Result_ is being redeclared. The redeclaration is here: -**type_comprehensive_scope.md:12:1:12:37:** +**type_comprehensive_scope.md:10:1:10:37:** ```roc Result(ok, err) : [Ok(ok), Err(err)] ``` @@ -63,7 +62,7 @@ Result(ok, err) : [Ok(ok), Err(err)] But _Result_ was already declared here: **type_comprehensive_scope.md:1:1:1:1:** ```roc -module [MyU64, Person, Result, Tree, Node] +# Built-in types should work ``` ^ @@ -72,7 +71,7 @@ module [MyU64, Person, Result, Tree, Node] The type _Node_ is not declared in this scope. This type is referenced here: -**type_comprehensive_scope.md:15:19:15:23:** +**type_comprehensive_scope.md:13:19:13:23:** ```roc Tree(a) : [Branch(Node(a)), Leaf(a)] ``` @@ -83,14 +82,14 @@ Tree(a) : [Branch(Node(a)), Leaf(a)] The type _Person_ is being redeclared. The redeclaration is here: -**type_comprehensive_scope.md:24:1:24:13:** +**type_comprehensive_scope.md:22:1:22:13:** ```roc Person : U64 ``` ^^^^^^^^^^^^ But _Person_ was already declared here: -**type_comprehensive_scope.md:9:1:9:33:** +**type_comprehensive_scope.md:7:1:7:33:** ```roc Person : { name: Str, age: U64 } ``` @@ -101,154 +100,157 @@ Person : { name: Str, age: U64 } The type _SomeUndeclaredType_ is not declared in this scope. This type is referenced here: -**type_comprehensive_scope.md:27:11:27:29:** +**type_comprehensive_scope.md:25:11:25:29:** ```roc BadType : SomeUndeclaredType ``` ^^^^^^^^^^^^^^^^^^ +**UNDECLARED TYPE** +The type _Dict_ is not declared in this scope. + +This type is referenced here: +**type_comprehensive_scope.md:29:10:29:14:** +```roc +MyDict : Dict(Str, U64) +``` + ^^^^ + + # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:14),Comma(1:14-1:15),UpperIdent(1:16-1:22),Comma(1:22-1:23),UpperIdent(1:24-1:30),Comma(1:30-1:31),UpperIdent(1:32-1:36),Comma(1:36-1:37),UpperIdent(1:38-1:42),CloseSquare(1:42-1:43), -UpperIdent(4:1-4:6),OpColon(4:7-4:8),UpperIdent(4:9-4:12), -UpperIdent(5:1-5:9),OpColon(5:10-5:11),UpperIdent(5:12-5:15), -UpperIdent(6:1-6:7),OpColon(6:8-6:9),UpperIdent(6:10-6:14), -UpperIdent(9:1-9:7),OpColon(9:8-9:9),OpenCurly(9:10-9:11),LowerIdent(9:12-9:16),OpColon(9:16-9:17),UpperIdent(9:18-9:21),Comma(9:21-9:22),LowerIdent(9:23-9:26),OpColon(9:26-9:27),UpperIdent(9:28-9:31),CloseCurly(9:32-9:33), -UpperIdent(12:1-12:7),NoSpaceOpenRound(12:7-12:8),LowerIdent(12:8-12:10),Comma(12:10-12:11),LowerIdent(12:12-12:15),CloseRound(12:15-12:16),OpColon(12:17-12:18),OpenSquare(12:19-12:20),UpperIdent(12:20-12:22),NoSpaceOpenRound(12:22-12:23),LowerIdent(12:23-12:25),CloseRound(12:25-12:26),Comma(12:26-12:27),UpperIdent(12:28-12:31),NoSpaceOpenRound(12:31-12:32),LowerIdent(12:32-12:35),CloseRound(12:35-12:36),CloseSquare(12:36-12:37), -UpperIdent(15:1-15:5),NoSpaceOpenRound(15:5-15:6),LowerIdent(15:6-15:7),CloseRound(15:7-15:8),OpColon(15:9-15:10),OpenSquare(15:11-15:12),UpperIdent(15:12-15:18),NoSpaceOpenRound(15:18-15:19),UpperIdent(15:19-15:23),NoSpaceOpenRound(15:23-15:24),LowerIdent(15:24-15:25),CloseRound(15:25-15:26),CloseRound(15:26-15:27),Comma(15:27-15:28),UpperIdent(15:29-15:33),NoSpaceOpenRound(15:33-15:34),LowerIdent(15:34-15:35),CloseRound(15:35-15:36),CloseSquare(15:36-15:37), -UpperIdent(18:1-18:5),NoSpaceOpenRound(18:5-18:6),LowerIdent(18:6-18:7),CloseRound(18:7-18:8),OpColon(18:9-18:10),OpenCurly(18:11-18:12),LowerIdent(18:13-18:18),OpColon(18:18-18:19),LowerIdent(18:20-18:21),Comma(18:21-18:22),LowerIdent(18:23-18:31),OpColon(18:31-18:32),UpperIdent(18:33-18:37),NoSpaceOpenRound(18:37-18:38),UpperIdent(18:38-18:42),NoSpaceOpenRound(18:42-18:43),LowerIdent(18:43-18:44),CloseRound(18:44-18:45),CloseRound(18:45-18:46),CloseCurly(18:47-18:48), -UpperIdent(21:1-21:9),OpColon(21:10-21:11),UpperIdent(21:12-21:18),NoSpaceOpenRound(21:18-21:19),UpperIdent(21:19-21:22),Comma(21:22-21:23),UpperIdent(21:24-21:27),CloseRound(21:27-21:28), -UpperIdent(24:1-24:7),OpColon(24:8-24:9),UpperIdent(24:10-24:13), -UpperIdent(27:1-27:8),OpColon(27:9-27:10),UpperIdent(27:11-27:29), -UpperIdent(30:1-30:7),OpColon(30:8-30:9),UpperIdent(30:10-30:14),NoSpaceOpenRound(30:14-30:15),UpperIdent(30:15-30:18),CloseRound(30:18-30:19), -UpperIdent(31:1-31:7),OpColon(31:8-31:9),UpperIdent(31:10-31:14),NoSpaceOpenRound(31:14-31:15),UpperIdent(31:15-31:18),Comma(31:18-31:19),UpperIdent(31:20-31:23),CloseRound(31:23-31:24), -UpperIdent(34:1-34:8),OpColon(34:9-34:10),OpenCurly(34:11-34:12), -LowerIdent(35:5-35:11),OpColon(35:11-35:12),UpperIdent(35:13-35:19),Comma(35:19-35:20), -LowerIdent(36:5-36:11),OpColon(36:11-36:12),UpperIdent(36:13-36:19),NoSpaceOpenRound(36:19-36:20),UpperIdent(36:20-36:24),Comma(36:24-36:25),UpperIdent(36:26-36:29),CloseRound(36:29-36:30),Comma(36:30-36:31), -LowerIdent(37:5-37:9),OpColon(37:9-37:10),UpperIdent(37:11-37:15),NoSpaceOpenRound(37:15-37:16),UpperIdent(37:16-37:19),CloseRound(37:19-37:20), -CloseCurly(38:1-38:2), -EndOfFile(39:1-39:1), +UpperIdent(2:1-2:6),OpColon(2:7-2:8),UpperIdent(2:9-2:12), +UpperIdent(3:1-3:9),OpColon(3:10-3:11),UpperIdent(3:12-3:15), +UpperIdent(4:1-4:7),OpColon(4:8-4:9),UpperIdent(4:10-4:14), +UpperIdent(7:1-7:7),OpColon(7:8-7:9),OpenCurly(7:10-7:11),LowerIdent(7:12-7:16),OpColon(7:16-7:17),UpperIdent(7:18-7:21),Comma(7:21-7:22),LowerIdent(7:23-7:26),OpColon(7:26-7:27),UpperIdent(7:28-7:31),CloseCurly(7:32-7:33), +UpperIdent(10:1-10:7),NoSpaceOpenRound(10:7-10:8),LowerIdent(10:8-10:10),Comma(10:10-10:11),LowerIdent(10:12-10:15),CloseRound(10:15-10:16),OpColon(10:17-10:18),OpenSquare(10:19-10:20),UpperIdent(10:20-10:22),NoSpaceOpenRound(10:22-10:23),LowerIdent(10:23-10:25),CloseRound(10:25-10:26),Comma(10:26-10:27),UpperIdent(10:28-10:31),NoSpaceOpenRound(10:31-10:32),LowerIdent(10:32-10:35),CloseRound(10:35-10:36),CloseSquare(10:36-10:37), +UpperIdent(13:1-13:5),NoSpaceOpenRound(13:5-13:6),LowerIdent(13:6-13:7),CloseRound(13:7-13:8),OpColon(13:9-13:10),OpenSquare(13:11-13:12),UpperIdent(13:12-13:18),NoSpaceOpenRound(13:18-13:19),UpperIdent(13:19-13:23),NoSpaceOpenRound(13:23-13:24),LowerIdent(13:24-13:25),CloseRound(13:25-13:26),CloseRound(13:26-13:27),Comma(13:27-13:28),UpperIdent(13:29-13:33),NoSpaceOpenRound(13:33-13:34),LowerIdent(13:34-13:35),CloseRound(13:35-13:36),CloseSquare(13:36-13:37), +UpperIdent(16:1-16:5),NoSpaceOpenRound(16:5-16:6),LowerIdent(16:6-16:7),CloseRound(16:7-16:8),OpColon(16:9-16:10),OpenCurly(16:11-16:12),LowerIdent(16:13-16:18),OpColon(16:18-16:19),LowerIdent(16:20-16:21),Comma(16:21-16:22),LowerIdent(16:23-16:31),OpColon(16:31-16:32),UpperIdent(16:33-16:37),NoSpaceOpenRound(16:37-16:38),UpperIdent(16:38-16:42),NoSpaceOpenRound(16:42-16:43),LowerIdent(16:43-16:44),CloseRound(16:44-16:45),CloseRound(16:45-16:46),CloseCurly(16:47-16:48), +UpperIdent(19:1-19:9),OpColon(19:10-19:11),UpperIdent(19:12-19:18),NoSpaceOpenRound(19:18-19:19),UpperIdent(19:19-19:22),Comma(19:22-19:23),UpperIdent(19:24-19:27),CloseRound(19:27-19:28), +UpperIdent(22:1-22:7),OpColon(22:8-22:9),UpperIdent(22:10-22:13), +UpperIdent(25:1-25:8),OpColon(25:9-25:10),UpperIdent(25:11-25:29), +UpperIdent(28:1-28:7),OpColon(28:8-28:9),UpperIdent(28:10-28:14),NoSpaceOpenRound(28:14-28:15),UpperIdent(28:15-28:18),CloseRound(28:18-28:19), +UpperIdent(29:1-29:7),OpColon(29:8-29:9),UpperIdent(29:10-29:14),NoSpaceOpenRound(29:14-29:15),UpperIdent(29:15-29:18),Comma(29:18-29:19),UpperIdent(29:20-29:23),CloseRound(29:23-29:24), +UpperIdent(32:1-32:8),OpColon(32:9-32:10),OpenCurly(32:11-32:12), +LowerIdent(33:5-33:11),OpColon(33:11-33:12),UpperIdent(33:13-33:19),Comma(33:19-33:20), +LowerIdent(34:5-34:11),OpColon(34:11-34:12),UpperIdent(34:13-34:19),NoSpaceOpenRound(34:19-34:20),UpperIdent(34:20-34:24),Comma(34:24-34:25),UpperIdent(34:26-34:29),CloseRound(34:29-34:30),Comma(34:30-34:31), +LowerIdent(35:5-35:9),OpColon(35:9-35:10),UpperIdent(35:11-35:15),NoSpaceOpenRound(35:15-35:16),UpperIdent(35:16-35:19),CloseRound(35:19-35:20), +CloseCurly(36:1-36:2), +EndOfFile(37:1-37:1), ~~~ # PARSE ~~~clojure -(file @1.1-38.2 - (module @1.1-1.43 - (exposes @1.8-1.43 - (exposed-upper-ident @1.9-1.14 (text "MyU64")) - (exposed-upper-ident @1.16-1.22 (text "Person")) - (exposed-upper-ident @1.24-1.30 (text "Result")) - (exposed-upper-ident @1.32-1.36 (text "Tree")) - (exposed-upper-ident @1.38-1.42 (text "Node")))) +(file @2.1-36.2 + (type-module @2.1-2.6) (statements - (s-type-decl @4.1-4.12 - (header @4.1-4.6 (name "MyU64") + (s-type-decl @2.1-2.12 + (header @2.1-2.6 (name "MyU64") (args)) - (ty @4.9-4.12 (name "U64"))) - (s-type-decl @5.1-5.15 - (header @5.1-5.9 (name "MyString") + (ty @2.9-2.12 (name "U64"))) + (s-type-decl @3.1-3.15 + (header @3.1-3.9 (name "MyString") (args)) - (ty @5.12-5.15 (name "Str"))) - (s-type-decl @6.1-6.14 - (header @6.1-6.7 (name "MyBool") + (ty @3.12-3.15 (name "Str"))) + (s-type-decl @4.1-4.14 + (header @4.1-4.7 (name "MyBool") (args)) - (ty @6.10-6.14 (name "Bool"))) - (s-type-decl @9.1-9.33 - (header @9.1-9.7 (name "Person") + (ty @4.10-4.14 (name "Bool"))) + (s-type-decl @7.1-7.33 + (header @7.1-7.7 (name "Person") (args)) - (ty-record @9.10-9.33 - (anno-record-field @9.12-9.21 (name "name") - (ty @9.18-9.21 (name "Str"))) - (anno-record-field @9.23-9.31 (name "age") - (ty @9.28-9.31 (name "U64"))))) - (s-type-decl @12.1-12.37 - (header @12.1-12.16 (name "Result") + (ty-record @7.10-7.33 + (anno-record-field @7.12-7.21 (name "name") + (ty @7.18-7.21 (name "Str"))) + (anno-record-field @7.23-7.31 (name "age") + (ty @7.28-7.31 (name "U64"))))) + (s-type-decl @10.1-10.37 + (header @10.1-10.16 (name "Result") (args - (ty-var @12.8-12.10 (raw "ok")) - (ty-var @12.12-12.15 (raw "err")))) - (ty-tag-union @12.19-12.37 + (ty-var @10.8-10.10 (raw "ok")) + (ty-var @10.12-10.15 (raw "err")))) + (ty-tag-union @10.19-10.37 (tags - (ty-apply @12.20-12.26 - (ty @12.20-12.22 (name "Ok")) - (ty-var @12.23-12.25 (raw "ok"))) - (ty-apply @12.28-12.36 - (ty @12.28-12.31 (name "Err")) - (ty-var @12.32-12.35 (raw "err")))))) - (s-type-decl @15.1-15.37 - (header @15.1-15.8 (name "Tree") + (ty-apply @10.20-10.26 + (ty @10.20-10.22 (name "Ok")) + (ty-var @10.23-10.25 (raw "ok"))) + (ty-apply @10.28-10.36 + (ty @10.28-10.31 (name "Err")) + (ty-var @10.32-10.35 (raw "err")))))) + (s-type-decl @13.1-13.37 + (header @13.1-13.8 (name "Tree") (args - (ty-var @15.6-15.7 (raw "a")))) - (ty-tag-union @15.11-15.37 + (ty-var @13.6-13.7 (raw "a")))) + (ty-tag-union @13.11-13.37 (tags - (ty-apply @15.12-15.27 - (ty @15.12-15.18 (name "Branch")) - (ty-apply @15.19-15.26 - (ty @15.19-15.23 (name "Node")) - (ty-var @15.24-15.25 (raw "a")))) - (ty-apply @15.29-15.36 - (ty @15.29-15.33 (name "Leaf")) - (ty-var @15.34-15.35 (raw "a")))))) - (s-type-decl @18.1-18.48 - (header @18.1-18.8 (name "Node") + (ty-apply @13.12-13.27 + (ty @13.12-13.18 (name "Branch")) + (ty-apply @13.19-13.26 + (ty @13.19-13.23 (name "Node")) + (ty-var @13.24-13.25 (raw "a")))) + (ty-apply @13.29-13.36 + (ty @13.29-13.33 (name "Leaf")) + (ty-var @13.34-13.35 (raw "a")))))) + (s-type-decl @16.1-16.48 + (header @16.1-16.8 (name "Node") (args - (ty-var @18.6-18.7 (raw "a")))) - (ty-record @18.11-18.48 - (anno-record-field @18.13-18.21 (name "value") - (ty-var @18.20-18.21 (raw "a"))) - (anno-record-field @18.23-18.46 (name "children") - (ty-apply @18.33-18.46 - (ty @18.33-18.37 (name "List")) - (ty-apply @18.38-18.45 - (ty @18.38-18.42 (name "Tree")) - (ty-var @18.43-18.44 (raw "a"))))))) - (s-type-decl @21.1-21.28 - (header @21.1-21.9 (name "MyResult") + (ty-var @16.6-16.7 (raw "a")))) + (ty-record @16.11-16.48 + (anno-record-field @16.13-16.21 (name "value") + (ty-var @16.20-16.21 (raw "a"))) + (anno-record-field @16.23-16.46 (name "children") + (ty-apply @16.33-16.46 + (ty @16.33-16.37 (name "List")) + (ty-apply @16.38-16.45 + (ty @16.38-16.42 (name "Tree")) + (ty-var @16.43-16.44 (raw "a"))))))) + (s-type-decl @19.1-19.28 + (header @19.1-19.9 (name "MyResult") (args)) - (ty-apply @21.12-21.28 - (ty @21.12-21.18 (name "Result")) - (ty @21.19-21.22 (name "Str")) - (ty @21.24-21.27 (name "U64")))) - (s-type-decl @24.1-24.13 - (header @24.1-24.7 (name "Person") + (ty-apply @19.12-19.28 + (ty @19.12-19.18 (name "Result")) + (ty @19.19-19.22 (name "Str")) + (ty @19.24-19.27 (name "U64")))) + (s-type-decl @22.1-22.13 + (header @22.1-22.7 (name "Person") (args)) - (ty @24.10-24.13 (name "U64"))) - (s-type-decl @27.1-27.29 - (header @27.1-27.8 (name "BadType") + (ty @22.10-22.13 (name "U64"))) + (s-type-decl @25.1-25.29 + (header @25.1-25.8 (name "BadType") (args)) - (ty @27.11-27.29 (name "SomeUndeclaredType"))) - (s-type-decl @30.1-30.19 - (header @30.1-30.7 (name "MyList") + (ty @25.11-25.29 (name "SomeUndeclaredType"))) + (s-type-decl @28.1-28.19 + (header @28.1-28.7 (name "MyList") (args)) - (ty-apply @30.10-30.19 - (ty @30.10-30.14 (name "List")) - (ty @30.15-30.18 (name "Str")))) - (s-type-decl @31.1-31.24 - (header @31.1-31.7 (name "MyDict") + (ty-apply @28.10-28.19 + (ty @28.10-28.14 (name "List")) + (ty @28.15-28.18 (name "Str")))) + (s-type-decl @29.1-29.24 + (header @29.1-29.7 (name "MyDict") (args)) - (ty-apply @31.10-31.24 - (ty @31.10-31.14 (name "Dict")) - (ty @31.15-31.18 (name "Str")) - (ty @31.20-31.23 (name "U64")))) - (s-type-decl @34.1-38.2 - (header @34.1-34.8 (name "Complex") + (ty-apply @29.10-29.24 + (ty @29.10-29.14 (name "Dict")) + (ty @29.15-29.18 (name "Str")) + (ty @29.20-29.23 (name "U64")))) + (s-type-decl @32.1-36.2 + (header @32.1-32.8 (name "Complex") (args)) - (ty-record @34.11-38.2 - (anno-record-field @35.5-35.19 (name "person") - (ty @35.13-35.19 (name "Person"))) - (anno-record-field @36.5-36.30 (name "result") - (ty-apply @36.13-36.30 - (ty @36.13-36.19 (name "Result")) - (ty @36.20-36.24 (name "Bool")) - (ty @36.26-36.29 (name "Str")))) - (anno-record-field @37.5-37.20 (name "tree") - (ty-apply @37.11-37.20 - (ty @37.11-37.15 (name "Tree")) - (ty @37.16-37.19 (name "U64")))))))) + (ty-record @32.11-36.2 + (anno-record-field @33.5-33.19 (name "person") + (ty @33.13-33.19 (name "Person"))) + (anno-record-field @34.5-34.30 (name "result") + (ty-apply @34.13-34.30 + (ty @34.13-34.19 (name "Result")) + (ty @34.20-34.24 (name "Bool")) + (ty @34.26-34.29 (name "Str")))) + (anno-record-field @35.5-35.20 (name "tree") + (ty-apply @35.11-35.20 + (ty @35.11-35.15 (name "Tree")) + (ty @35.16-35.19 (name "U64")))))))) ~~~ # FORMATTED ~~~roc -module [MyU64, Person, Result, Tree, Node] - +# Built-in types should work # Built-in types should work MyU64 : U64 MyString : Str @@ -289,123 +291,120 @@ Complex : { # CANONICALIZE ~~~clojure (can-ir - (s-alias-decl @4.1-4.12 - (ty-header @4.1-4.6 (name "MyU64")) - (ty @4.9-4.12 (name "U64"))) - (s-alias-decl @5.1-5.15 - (ty-header @5.1-5.9 (name "MyString")) - (ty @5.12-5.15 (name "Str"))) - (s-alias-decl @6.1-6.14 - (ty-header @6.1-6.7 (name "MyBool")) - (ty @6.10-6.14 (name "Bool"))) - (s-alias-decl @9.1-9.33 - (ty-header @9.1-9.7 (name "Person")) - (ty-record @9.10-9.33 + (s-alias-decl @2.1-2.12 + (ty-header @2.1-2.6 (name "MyU64")) + (ty-lookup @2.9-2.12 (name "U64") (builtin))) + (s-alias-decl @3.1-3.15 + (ty-header @3.1-3.9 (name "MyString")) + (ty-lookup @3.12-3.15 (name "Str") (builtin))) + (s-alias-decl @4.1-4.14 + (ty-header @4.1-4.7 (name "MyBool")) + (ty-lookup @4.10-4.14 (name "Bool") (local))) + (s-alias-decl @7.1-7.33 + (ty-header @7.1-7.7 (name "Person")) + (ty-record @7.10-7.33 (field (field "name") - (ty @9.18-9.21 (name "Str"))) + (ty-lookup @7.18-7.21 (name "Str") (builtin))) (field (field "age") - (ty @9.28-9.31 (name "U64"))))) - (s-alias-decl @12.1-12.37 - (ty-header @12.1-12.16 (name "Result") + (ty-lookup @7.28-7.31 (name "U64") (builtin))))) + (s-alias-decl @10.1-10.37 + (ty-header @10.1-10.16 (name "Result") (ty-args - (ty-var @12.8-12.10 (name "ok")) - (ty-var @12.12-12.15 (name "err")))) - (ty-tag-union @12.19-12.37 - (ty-apply @12.20-12.26 (symbol "Ok") - (ty-var @12.23-12.25 (name "ok"))) - (ty-apply @12.28-12.36 (symbol "Err") - (ty-var @12.32-12.35 (name "err"))))) - (s-alias-decl @15.1-15.37 - (ty-header @15.1-15.8 (name "Tree") + (ty-rigid-var @10.8-10.10 (name "ok")) + (ty-rigid-var @10.12-10.15 (name "err")))) + (ty-tag-union @10.19-10.37 + (ty-tag-name @10.20-10.26 (name "Ok") + (ty-rigid-var-lookup (ty-rigid-var @10.8-10.10 (name "ok")))) + (ty-tag-name @10.28-10.36 (name "Err") + (ty-rigid-var-lookup (ty-rigid-var @10.12-10.15 (name "err")))))) + (s-alias-decl @13.1-13.37 + (ty-header @13.1-13.8 (name "Tree") (ty-args - (ty-var @15.6-15.7 (name "a")))) - (ty-tag-union @15.11-15.37 - (ty-apply @15.12-15.27 (symbol "Branch") - (ty-apply @15.19-15.26 (symbol "Node") - (ty-var @15.24-15.25 (name "a")))) - (ty-apply @15.29-15.36 (symbol "Leaf") - (ty-var @15.34-15.35 (name "a"))))) - (s-alias-decl @18.1-18.48 - (ty-header @18.1-18.8 (name "Node") + (ty-rigid-var @13.6-13.7 (name "a")))) + (ty-tag-union @13.11-13.37 + (ty-tag-name @13.12-13.27 (name "Branch") + (ty-malformed @13.19-13.23)) + (ty-tag-name @13.29-13.36 (name "Leaf") + (ty-rigid-var-lookup (ty-rigid-var @13.6-13.7 (name "a")))))) + (s-alias-decl @16.1-16.48 + (ty-header @16.1-16.8 (name "Node") (ty-args - (ty-var @18.6-18.7 (name "a")))) - (ty-record @18.11-18.48 + (ty-rigid-var @16.6-16.7 (name "a")))) + (ty-record @16.11-16.48 (field (field "value") - (ty-var @18.20-18.21 (name "a"))) + (ty-rigid-var-lookup (ty-rigid-var @16.6-16.7 (name "a")))) (field (field "children") - (ty-apply @18.33-18.46 (symbol "List") - (ty-apply @18.38-18.45 (symbol "Tree") - (ty-var @18.43-18.44 (name "a"))))))) - (s-alias-decl @21.1-21.28 - (ty-header @21.1-21.9 (name "MyResult")) - (ty-apply @21.12-21.28 (symbol "Result") - (ty @21.19-21.22 (name "Str")) - (ty @21.24-21.27 (name "U64")))) - (s-alias-decl @24.1-24.13 - (ty-header @24.1-24.7 (name "Person")) - (ty @24.10-24.13 (name "U64"))) - (s-alias-decl @27.1-27.29 - (ty-header @27.1-27.8 (name "BadType")) - (ty @27.11-27.29 (name "SomeUndeclaredType"))) - (s-alias-decl @30.1-30.19 - (ty-header @30.1-30.7 (name "MyList")) - (ty-apply @30.10-30.19 (symbol "List") - (ty @30.15-30.18 (name "Str")))) - (s-alias-decl @31.1-31.24 - (ty-header @31.1-31.7 (name "MyDict")) - (ty-apply @31.10-31.24 (symbol "Dict") - (ty @31.15-31.18 (name "Str")) - (ty @31.20-31.23 (name "U64")))) - (s-alias-decl @34.1-38.2 - (ty-header @34.1-34.8 (name "Complex")) - (ty-record @34.11-38.2 + (ty-apply @16.33-16.46 (name "List") (builtin) + (ty-apply @16.38-16.45 (name "Tree") (local) + (ty-rigid-var-lookup (ty-rigid-var @16.6-16.7 (name "a")))))))) + (s-alias-decl @19.1-19.28 + (ty-header @19.1-19.9 (name "MyResult")) + (ty-apply @19.12-19.28 (name "Result") (local) + (ty-lookup @19.12-19.28 (name "Str") (builtin)) + (ty-lookup @19.12-19.28 (name "U64") (builtin)))) + (s-alias-decl @22.1-22.13 + (ty-header @22.1-22.7 (name "Person")) + (ty-lookup @22.10-22.13 (name "U64") (builtin))) + (s-alias-decl @25.1-25.29 + (ty-header @25.1-25.8 (name "BadType")) + (ty-malformed @25.11-25.29)) + (s-alias-decl @28.1-28.19 + (ty-header @28.1-28.7 (name "MyList")) + (ty-apply @28.10-28.19 (name "List") (builtin) + (ty-lookup @28.15-28.18 (name "Str") (builtin)))) + (s-alias-decl @29.1-29.24 + (ty-header @29.1-29.7 (name "MyDict")) + (ty-malformed @29.10-29.14)) + (s-alias-decl @32.1-36.2 + (ty-header @32.1-32.8 (name "Complex")) + (ty-record @32.11-36.2 (field (field "person") - (ty @35.13-35.19 (name "Person"))) + (ty-lookup @33.13-33.19 (name "Person") (local))) (field (field "result") - (ty-apply @36.13-36.30 (symbol "Result") - (ty @36.20-36.24 (name "Bool")) - (ty @36.26-36.29 (name "Str")))) + (ty-apply @34.13-34.30 (name "Result") (local) + (ty-lookup @34.13-34.30 (name "Bool") (local)) + (ty-lookup @34.13-34.30 (name "Str") (builtin)))) (field (field "tree") - (ty-apply @37.11-37.20 (symbol "Tree") - (ty @37.16-37.19 (name "U64"))))))) + (ty-apply @35.11-35.20 (name "Tree") (local) + (ty-lookup @35.11-35.20 (name "U64") (builtin))))))) ~~~ # TYPES ~~~clojure (inferred-types (defs) (type_decls - (alias @4.1-4.12 (type "MyU64") - (ty-header @4.1-4.6 (name "MyU64"))) - (alias @5.1-5.15 (type "MyString") - (ty-header @5.1-5.9 (name "MyString"))) - (alias @6.1-6.14 (type "MyBool") - (ty-header @6.1-6.7 (name "MyBool"))) - (alias @9.1-9.33 (type "Person") - (ty-header @9.1-9.7 (name "Person"))) - (alias @12.1-12.37 (type "Result(ok, err)") - (ty-header @12.1-12.16 (name "Result") + (alias @2.1-2.12 (type "MyU64") + (ty-header @2.1-2.6 (name "MyU64"))) + (alias @3.1-3.15 (type "MyString") + (ty-header @3.1-3.9 (name "MyString"))) + (alias @4.1-4.14 (type "MyBool") + (ty-header @4.1-4.7 (name "MyBool"))) + (alias @7.1-7.33 (type "Person") + (ty-header @7.1-7.7 (name "Person"))) + (alias @10.1-10.37 (type "Result(ok, err)") + (ty-header @10.1-10.16 (name "Result") (ty-args - (ty-var @12.8-12.10 (name "ok")) - (ty-var @12.12-12.15 (name "err"))))) - (alias @15.1-15.37 (type "Tree(a)") - (ty-header @15.1-15.8 (name "Tree") + (ty-rigid-var @10.8-10.10 (name "ok")) + (ty-rigid-var @10.12-10.15 (name "err"))))) + (alias @13.1-13.37 (type "Tree(a)") + (ty-header @13.1-13.8 (name "Tree") (ty-args - (ty-var @15.6-15.7 (name "a"))))) - (alias @18.1-18.48 (type "Node(a)") - (ty-header @18.1-18.8 (name "Node") + (ty-rigid-var @13.6-13.7 (name "a"))))) + (alias @16.1-16.48 (type "Node(a)") + (ty-header @16.1-16.8 (name "Node") (ty-args - (ty-var @18.6-18.7 (name "a"))))) - (alias @21.1-21.28 (type "MyResult") - (ty-header @21.1-21.9 (name "MyResult"))) - (alias @24.1-24.13 (type "Person") - (ty-header @24.1-24.7 (name "Person"))) - (alias @27.1-27.29 (type "Error") - (ty-header @27.1-27.8 (name "BadType"))) - (alias @30.1-30.19 (type "MyList") - (ty-header @30.1-30.7 (name "MyList"))) - (alias @31.1-31.24 (type "MyDict") - (ty-header @31.1-31.7 (name "MyDict"))) - (alias @34.1-38.2 (type "Complex") - (ty-header @34.1-34.8 (name "Complex")))) + (ty-rigid-var @16.6-16.7 (name "a"))))) + (alias @19.1-19.28 (type "MyResult") + (ty-header @19.1-19.9 (name "MyResult"))) + (alias @22.1-22.13 (type "Person") + (ty-header @22.1-22.7 (name "Person"))) + (alias @25.1-25.29 (type "BadType") + (ty-header @25.1-25.8 (name "BadType"))) + (alias @28.1-28.19 (type "MyList") + (ty-header @28.1-28.7 (name "MyList"))) + (alias @29.1-29.24 (type "MyDict") + (ty-header @29.1-29.7 (name "MyDict"))) + (alias @32.1-36.2 (type "Complex") + (ty-header @32.1-32.8 (name "Complex")))) (expressions)) ~~~ diff --git a/test/snapshots/type_declarations.md b/test/snapshots/type_declarations.md index 2096bcc9a5..a207574105 100644 --- a/test/snapshots/type_declarations.md +++ b/test/snapshots/type_declarations.md @@ -1,12 +1,10 @@ # META ~~~ini description=Various type declarations -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [Map, Foo, Some, Maybe, SomeFunc, add_one, main!] - Map(a, b) : List(a), (a -> b) -> List(b) Foo : (Bar, Baz) @@ -22,19 +20,17 @@ MyType : U64 MyType2 : Module.Thingy ~~~ # EXPECTED -UNDECLARED TYPE - type_declarations.md:5:8:5:11 -UNDECLARED TYPE - type_declarations.md:5:13:5:16 -UNDECLARED TYPE - type_declarations.md:7:19:7:21 -UNDECLARED TYPE - type_declarations.md:7:32:7:41 -MODULE NOT IMPORTED - type_declarations.md:15:11:15:24 -EXPOSED BUT NOT DEFINED - type_declarations.md:1:51:1:56 -EXPOSED BUT NOT DEFINED - type_declarations.md:1:42:1:49 +UNDECLARED TYPE - type_declarations.md:3:8:3:11 +UNDECLARED TYPE - type_declarations.md:3:13:3:16 +UNDECLARED TYPE - type_declarations.md:5:19:5:21 +UNDECLARED TYPE - type_declarations.md:5:32:5:41 +MODULE NOT IMPORTED - type_declarations.md:13:11:13:24 # PROBLEMS **UNDECLARED TYPE** The type _Bar_ is not declared in this scope. This type is referenced here: -**type_declarations.md:5:8:5:11:** +**type_declarations.md:3:8:3:11:** ```roc Foo : (Bar, Baz) ``` @@ -45,7 +41,7 @@ Foo : (Bar, Baz) The type _Baz_ is not declared in this scope. This type is referenced here: -**type_declarations.md:5:13:5:16:** +**type_declarations.md:3:13:3:16:** ```roc Foo : (Bar, Baz) ``` @@ -56,7 +52,7 @@ Foo : (Bar, Baz) The type _Ok_ is not declared in this scope. This type is referenced here: -**type_declarations.md:7:19:7:21:** +**type_declarations.md:5:19:5:21:** ```roc Some(a) : { foo : Ok(a), bar : Something } ``` @@ -67,7 +63,7 @@ Some(a) : { foo : Ok(a), bar : Something } The type _Something_ is not declared in this scope. This type is referenced here: -**type_declarations.md:7:32:7:41:** +**type_declarations.md:5:32:5:41:** ```roc Some(a) : { foo : Ok(a), bar : Something } ``` @@ -78,122 +74,91 @@ Some(a) : { foo : Ok(a), bar : Something } There is no module with the name `Module` imported into this Roc file. You're attempting to use this module here: -**type_declarations.md:15:11:15:24:** +**type_declarations.md:13:11:13:24:** ```roc MyType2 : Module.Thingy ``` ^^^^^^^^^^^^^ -**EXPOSED BUT NOT DEFINED** -The module header says that `main!` is exposed, but it is not defined anywhere in this module. - -**type_declarations.md:1:51:1:56:** -```roc -module [Map, Foo, Some, Maybe, SomeFunc, add_one, main!] -``` - ^^^^^ -You can fix this by either defining `main!` in this module, or by removing it from the list of exposed values. - -**EXPOSED BUT NOT DEFINED** -The module header says that `add_one` is exposed, but it is not defined anywhere in this module. - -**type_declarations.md:1:42:1:49:** -```roc -module [Map, Foo, Some, Maybe, SomeFunc, add_one, main!] -``` - ^^^^^^^ -You can fix this by either defining `add_one` in this module, or by removing it from the list of exposed values. - # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:12),Comma(1:12-1:13),UpperIdent(1:14-1:17),Comma(1:17-1:18),UpperIdent(1:19-1:23),Comma(1:23-1:24),UpperIdent(1:25-1:30),Comma(1:30-1:31),UpperIdent(1:32-1:40),Comma(1:40-1:41),LowerIdent(1:42-1:49),Comma(1:49-1:50),LowerIdent(1:51-1:56),CloseSquare(1:56-1:57), -UpperIdent(3:1-3:4),NoSpaceOpenRound(3:4-3:5),LowerIdent(3:5-3:6),Comma(3:6-3:7),LowerIdent(3:8-3:9),CloseRound(3:9-3:10),OpColon(3:11-3:12),UpperIdent(3:13-3:17),NoSpaceOpenRound(3:17-3:18),LowerIdent(3:18-3:19),CloseRound(3:19-3:20),Comma(3:20-3:21),OpenRound(3:22-3:23),LowerIdent(3:23-3:24),OpArrow(3:25-3:27),LowerIdent(3:28-3:29),CloseRound(3:29-3:30),OpArrow(3:31-3:33),UpperIdent(3:34-3:38),NoSpaceOpenRound(3:38-3:39),LowerIdent(3:39-3:40),CloseRound(3:40-3:41), -UpperIdent(5:1-5:4),OpColon(5:5-5:6),OpenRound(5:7-5:8),UpperIdent(5:8-5:11),Comma(5:11-5:12),UpperIdent(5:13-5:16),CloseRound(5:16-5:17), -UpperIdent(7:1-7:5),NoSpaceOpenRound(7:5-7:6),LowerIdent(7:6-7:7),CloseRound(7:7-7:8),OpColon(7:9-7:10),OpenCurly(7:11-7:12),LowerIdent(7:13-7:16),OpColon(7:17-7:18),UpperIdent(7:19-7:21),NoSpaceOpenRound(7:21-7:22),LowerIdent(7:22-7:23),CloseRound(7:23-7:24),Comma(7:24-7:25),LowerIdent(7:26-7:29),OpColon(7:30-7:31),UpperIdent(7:32-7:41),CloseCurly(7:42-7:43), -UpperIdent(9:1-9:6),NoSpaceOpenRound(9:6-9:7),LowerIdent(9:7-9:8),CloseRound(9:8-9:9),OpColon(9:10-9:11),OpenSquare(9:12-9:13),UpperIdent(9:13-9:17),NoSpaceOpenRound(9:17-9:18),LowerIdent(9:18-9:19),CloseRound(9:19-9:20),Comma(9:20-9:21),UpperIdent(9:22-9:26),CloseSquare(9:26-9:27), -UpperIdent(11:1-11:9),NoSpaceOpenRound(11:9-11:10),LowerIdent(11:10-11:11),CloseRound(11:11-11:12),OpColon(11:13-11:14),UpperIdent(11:15-11:20),NoSpaceOpenRound(11:20-11:21),LowerIdent(11:21-11:22),CloseRound(11:22-11:23),Comma(11:23-11:24),LowerIdent(11:25-11:26),OpArrow(11:27-11:29),UpperIdent(11:30-11:35),NoSpaceOpenRound(11:35-11:36),LowerIdent(11:36-11:37),CloseRound(11:37-11:38), -UpperIdent(13:1-13:7),OpColon(13:8-13:9),UpperIdent(13:10-13:13), -UpperIdent(15:1-15:8),OpColon(15:9-15:10),UpperIdent(15:11-15:17),NoSpaceDotUpperIdent(15:17-15:24), -EndOfFile(16:1-16:1), +UpperIdent(1:1-1:4),NoSpaceOpenRound(1:4-1:5),LowerIdent(1:5-1:6),Comma(1:6-1:7),LowerIdent(1:8-1:9),CloseRound(1:9-1:10),OpColon(1:11-1:12),UpperIdent(1:13-1:17),NoSpaceOpenRound(1:17-1:18),LowerIdent(1:18-1:19),CloseRound(1:19-1:20),Comma(1:20-1:21),OpenRound(1:22-1:23),LowerIdent(1:23-1:24),OpArrow(1:25-1:27),LowerIdent(1:28-1:29),CloseRound(1:29-1:30),OpArrow(1:31-1:33),UpperIdent(1:34-1:38),NoSpaceOpenRound(1:38-1:39),LowerIdent(1:39-1:40),CloseRound(1:40-1:41), +UpperIdent(3:1-3:4),OpColon(3:5-3:6),OpenRound(3:7-3:8),UpperIdent(3:8-3:11),Comma(3:11-3:12),UpperIdent(3:13-3:16),CloseRound(3:16-3:17), +UpperIdent(5:1-5:5),NoSpaceOpenRound(5:5-5:6),LowerIdent(5:6-5:7),CloseRound(5:7-5:8),OpColon(5:9-5:10),OpenCurly(5:11-5:12),LowerIdent(5:13-5:16),OpColon(5:17-5:18),UpperIdent(5:19-5:21),NoSpaceOpenRound(5:21-5:22),LowerIdent(5:22-5:23),CloseRound(5:23-5:24),Comma(5:24-5:25),LowerIdent(5:26-5:29),OpColon(5:30-5:31),UpperIdent(5:32-5:41),CloseCurly(5:42-5:43), +UpperIdent(7:1-7:6),NoSpaceOpenRound(7:6-7:7),LowerIdent(7:7-7:8),CloseRound(7:8-7:9),OpColon(7:10-7:11),OpenSquare(7:12-7:13),UpperIdent(7:13-7:17),NoSpaceOpenRound(7:17-7:18),LowerIdent(7:18-7:19),CloseRound(7:19-7:20),Comma(7:20-7:21),UpperIdent(7:22-7:26),CloseSquare(7:26-7:27), +UpperIdent(9:1-9:9),NoSpaceOpenRound(9:9-9:10),LowerIdent(9:10-9:11),CloseRound(9:11-9:12),OpColon(9:13-9:14),UpperIdent(9:15-9:20),NoSpaceOpenRound(9:20-9:21),LowerIdent(9:21-9:22),CloseRound(9:22-9:23),Comma(9:23-9:24),LowerIdent(9:25-9:26),OpArrow(9:27-9:29),UpperIdent(9:30-9:35),NoSpaceOpenRound(9:35-9:36),LowerIdent(9:36-9:37),CloseRound(9:37-9:38), +UpperIdent(11:1-11:7),OpColon(11:8-11:9),UpperIdent(11:10-11:13), +UpperIdent(13:1-13:8),OpColon(13:9-13:10),UpperIdent(13:11-13:17),NoSpaceDotUpperIdent(13:17-13:24), +EndOfFile(14:1-14:1), ~~~ # PARSE ~~~clojure -(file @1.1-15.24 - (module @1.1-1.57 - (exposes @1.8-1.57 - (exposed-upper-ident @1.9-1.12 (text "Map")) - (exposed-upper-ident @1.14-1.17 (text "Foo")) - (exposed-upper-ident @1.19-1.23 (text "Some")) - (exposed-upper-ident @1.25-1.30 (text "Maybe")) - (exposed-upper-ident @1.32-1.40 (text "SomeFunc")) - (exposed-lower-ident @1.42-1.49 - (text "add_one")) - (exposed-lower-ident @1.51-1.56 - (text "main!")))) +(file @1.1-13.24 + (type-module @1.1-1.4) (statements - (s-type-decl @3.1-3.41 - (header @3.1-3.10 (name "Map") + (s-type-decl @1.1-1.41 + (header @1.1-1.10 (name "Map") (args - (ty-var @3.5-3.6 (raw "a")) - (ty-var @3.8-3.9 (raw "b")))) - (ty-fn @3.13-3.41 - (ty-apply @3.13-3.20 - (ty @3.13-3.17 (name "List")) - (ty-var @3.18-3.19 (raw "a"))) - (ty-fn @3.23-3.29 - (ty-var @3.23-3.24 (raw "a")) - (ty-var @3.28-3.29 (raw "b"))) - (ty-apply @3.34-3.41 - (ty @3.34-3.38 (name "List")) - (ty-var @3.39-3.40 (raw "b"))))) - (s-type-decl @5.1-5.17 - (header @5.1-5.4 (name "Foo") + (ty-var @1.5-1.6 (raw "a")) + (ty-var @1.8-1.9 (raw "b")))) + (ty-fn @1.13-1.41 + (ty-apply @1.13-1.20 + (ty @1.13-1.17 (name "List")) + (ty-var @1.18-1.19 (raw "a"))) + (ty-fn @1.23-1.29 + (ty-var @1.23-1.24 (raw "a")) + (ty-var @1.28-1.29 (raw "b"))) + (ty-apply @1.34-1.41 + (ty @1.34-1.38 (name "List")) + (ty-var @1.39-1.40 (raw "b"))))) + (s-type-decl @3.1-3.17 + (header @3.1-3.4 (name "Foo") (args)) - (ty-tuple @5.7-5.17 - (ty @5.8-5.11 (name "Bar")) - (ty @5.13-5.16 (name "Baz")))) - (s-type-decl @7.1-7.43 - (header @7.1-7.8 (name "Some") + (ty-tuple @3.7-3.17 + (ty @3.8-3.11 (name "Bar")) + (ty @3.13-3.16 (name "Baz")))) + (s-type-decl @5.1-5.43 + (header @5.1-5.8 (name "Some") (args - (ty-var @7.6-7.7 (raw "a")))) - (ty-record @7.11-7.43 - (anno-record-field @7.13-7.24 (name "foo") - (ty-apply @7.19-7.24 - (ty @7.19-7.21 (name "Ok")) - (ty-var @7.22-7.23 (raw "a")))) - (anno-record-field @7.26-7.41 (name "bar") - (ty @7.32-7.41 (name "Something"))))) - (s-type-decl @9.1-9.27 - (header @9.1-9.9 (name "Maybe") + (ty-var @5.6-5.7 (raw "a")))) + (ty-record @5.11-5.43 + (anno-record-field @5.13-5.24 (name "foo") + (ty-apply @5.19-5.24 + (ty @5.19-5.21 (name "Ok")) + (ty-var @5.22-5.23 (raw "a")))) + (anno-record-field @5.26-5.41 (name "bar") + (ty @5.32-5.41 (name "Something"))))) + (s-type-decl @7.1-7.27 + (header @7.1-7.9 (name "Maybe") (args - (ty-var @9.7-9.8 (raw "a")))) - (ty-tag-union @9.12-9.27 + (ty-var @7.7-7.8 (raw "a")))) + (ty-tag-union @7.12-7.27 (tags - (ty-apply @9.13-9.20 - (ty @9.13-9.17 (name "Some")) - (ty-var @9.18-9.19 (raw "a"))) - (ty @9.22-9.26 (name "None"))))) - (s-type-decl @11.1-11.38 - (header @11.1-11.12 (name "SomeFunc") + (ty-apply @7.13-7.20 + (ty @7.13-7.17 (name "Some")) + (ty-var @7.18-7.19 (raw "a"))) + (ty @7.22-7.26 (name "None"))))) + (s-type-decl @9.1-9.38 + (header @9.1-9.12 (name "SomeFunc") (args - (ty-var @11.10-11.11 (raw "a")))) - (ty-fn @11.15-11.38 - (ty-apply @11.15-11.23 - (ty @11.15-11.20 (name "Maybe")) - (ty-var @11.21-11.22 (raw "a"))) - (ty-var @11.25-11.26 (raw "a")) - (ty-apply @11.30-11.38 - (ty @11.30-11.35 (name "Maybe")) - (ty-var @11.36-11.37 (raw "a"))))) - (s-type-decl @13.1-13.13 - (header @13.1-13.7 (name "MyType") + (ty-var @9.10-9.11 (raw "a")))) + (ty-fn @9.15-9.38 + (ty-apply @9.15-9.23 + (ty @9.15-9.20 (name "Maybe")) + (ty-var @9.21-9.22 (raw "a"))) + (ty-var @9.25-9.26 (raw "a")) + (ty-apply @9.30-9.38 + (ty @9.30-9.35 (name "Maybe")) + (ty-var @9.36-9.37 (raw "a"))))) + (s-type-decl @11.1-11.13 + (header @11.1-11.7 (name "MyType") (args)) - (ty @13.10-13.13 (name "U64"))) - (s-type-decl @15.1-15.24 - (header @15.1-15.8 (name "MyType2") + (ty @11.10-11.13 (name "U64"))) + (s-type-decl @13.1-13.24 + (header @13.1-13.8 (name "MyType2") (args)) - (ty @15.11-15.24 (name "Module.Thingy"))))) + (ty @13.11-13.24 (name "Module.Thingy"))))) ~~~ # FORMATTED ~~~roc @@ -202,87 +167,86 @@ NO CHANGE # CANONICALIZE ~~~clojure (can-ir - (s-alias-decl @3.1-3.41 - (ty-header @3.1-3.10 (name "Map") + (s-alias-decl @1.1-1.41 + (ty-header @1.1-1.10 (name "Map") (ty-args - (ty-var @3.5-3.6 (name "a")) - (ty-var @3.8-3.9 (name "b")))) - (ty-fn @3.13-3.41 (effectful false) - (ty-apply @3.13-3.20 (symbol "List") - (ty-var @3.18-3.19 (name "a"))) - (ty-parens @3.22-3.30 - (ty-fn @3.23-3.29 (effectful false) - (ty-var @3.23-3.24 (name "a")) - (ty-var @3.28-3.29 (name "b")))) - (ty-apply @3.34-3.41 (symbol "List") - (ty-var @3.39-3.40 (name "b"))))) - (s-alias-decl @5.1-5.17 - (ty-header @5.1-5.4 (name "Foo")) - (ty-tuple @5.7-5.17 - (ty @5.8-5.11 (name "Bar")) - (ty @5.13-5.16 (name "Baz")))) - (s-alias-decl @7.1-7.43 - (ty-header @7.1-7.8 (name "Some") + (ty-rigid-var @1.5-1.6 (name "a")) + (ty-rigid-var @1.8-1.9 (name "b")))) + (ty-fn @1.13-1.41 (effectful false) + (ty-apply @1.13-1.20 (name "List") (builtin) + (ty-rigid-var-lookup (ty-rigid-var @1.5-1.6 (name "a")))) + (ty-parens @1.22-1.30 + (ty-fn @1.23-1.29 (effectful false) + (ty-rigid-var-lookup (ty-rigid-var @1.5-1.6 (name "a"))) + (ty-rigid-var-lookup (ty-rigid-var @1.8-1.9 (name "b"))))) + (ty-apply @1.34-1.41 (name "List") (builtin) + (ty-rigid-var-lookup (ty-rigid-var @1.8-1.9 (name "b")))))) + (s-alias-decl @3.1-3.17 + (ty-header @3.1-3.4 (name "Foo")) + (ty-tuple @3.7-3.17 + (ty-malformed @3.8-3.11) + (ty-malformed @3.13-3.16))) + (s-alias-decl @5.1-5.43 + (ty-header @5.1-5.8 (name "Some") (ty-args - (ty-var @7.6-7.7 (name "a")))) - (ty-record @7.11-7.43 + (ty-rigid-var @5.6-5.7 (name "a")))) + (ty-record @5.11-5.43 (field (field "foo") - (ty-apply @7.19-7.24 (symbol "Ok") - (ty-var @7.22-7.23 (name "a")))) + (ty-malformed @5.19-5.21)) (field (field "bar") - (ty @7.32-7.41 (name "Something"))))) - (s-alias-decl @9.1-9.27 - (ty-header @9.1-9.9 (name "Maybe") + (ty-malformed @5.32-5.41)))) + (s-alias-decl @7.1-7.27 + (ty-header @7.1-7.9 (name "Maybe") (ty-args - (ty-var @9.7-9.8 (name "a")))) - (ty-tag-union @9.12-9.27 - (ty-apply @9.13-9.20 (symbol "Some") - (ty-var @9.18-9.19 (name "a"))) - (ty @9.22-9.26 (name "None")))) - (s-alias-decl @11.1-11.38 - (ty-header @11.1-11.12 (name "SomeFunc") + (ty-rigid-var @7.7-7.8 (name "a")))) + (ty-tag-union @7.12-7.27 + (ty-tag-name @7.13-7.20 (name "Some") + (ty-rigid-var-lookup (ty-rigid-var @7.7-7.8 (name "a")))) + (ty-tag-name @7.22-7.26 (name "None")))) + (s-alias-decl @9.1-9.38 + (ty-header @9.1-9.12 (name "SomeFunc") (ty-args - (ty-var @11.10-11.11 (name "a")))) - (ty-fn @11.15-11.38 (effectful false) - (ty-apply @11.15-11.23 (symbol "Maybe") - (ty-var @11.21-11.22 (name "a"))) - (ty-var @11.25-11.26 (name "a")) - (ty-apply @11.30-11.38 (symbol "Maybe") - (ty-var @11.36-11.37 (name "a"))))) - (s-alias-decl @13.1-13.13 - (ty-header @13.1-13.7 (name "MyType")) - (ty @13.10-13.13 (name "U64"))) - (s-alias-decl @15.1-15.24 - (ty-header @15.1-15.8 (name "MyType2")) - (ty-malformed @15.11-15.24))) + (ty-rigid-var @9.10-9.11 (name "a")))) + (ty-fn @9.15-9.38 (effectful false) + (ty-apply @9.15-9.23 (name "Maybe") (local) + (ty-rigid-var-lookup (ty-rigid-var @9.10-9.11 (name "a")))) + (ty-rigid-var-lookup (ty-rigid-var @9.10-9.11 (name "a"))) + (ty-apply @9.30-9.38 (name "Maybe") (local) + (ty-rigid-var-lookup (ty-rigid-var @9.10-9.11 (name "a")))))) + (s-alias-decl @11.1-11.13 + (ty-header @11.1-11.7 (name "MyType")) + (ty-lookup @11.10-11.13 (name "U64") (builtin))) + (s-alias-decl @13.1-13.24 + (ty-header @13.1-13.8 (name "MyType2")) + (ty-malformed @13.11-13.24))) ~~~ # TYPES ~~~clojure (inferred-types (defs) (type_decls - (alias @3.1-3.41 (type "Map(a, b)") - (ty-header @3.1-3.10 (name "Map") + (alias @1.1-1.41 (type "Map(a, b)") + (ty-header @1.1-1.10 (name "Map") (ty-args - (ty-var @3.5-3.6 (name "a")) - (ty-var @3.8-3.9 (name "b"))))) - (alias @5.1-5.17 (type "Foo") - (ty-header @5.1-5.4 (name "Foo"))) - (alias @7.1-7.43 (type "Some(a)") - (ty-header @7.1-7.8 (name "Some") + (ty-rigid-var @1.5-1.6 (name "a")) + (ty-rigid-var @1.8-1.9 (name "b"))))) + (alias @3.1-3.17 (type "Foo") + (ty-header @3.1-3.4 (name "Foo"))) + (alias @5.1-5.43 (type "Some(a)") + (ty-header @5.1-5.8 (name "Some") (ty-args - (ty-var @7.6-7.7 (name "a"))))) - (alias @9.1-9.27 (type "Maybe(a)") - (ty-header @9.1-9.9 (name "Maybe") + (ty-rigid-var @5.6-5.7 (name "a"))))) + (alias @7.1-7.27 (type "Maybe(a)") + (ty-header @7.1-7.9 (name "Maybe") (ty-args - (ty-var @9.7-9.8 (name "a"))))) - (alias @11.1-11.38 (type "SomeFunc(a)") - (ty-header @11.1-11.12 (name "SomeFunc") + (ty-rigid-var @7.7-7.8 (name "a"))))) + (alias @9.1-9.38 (type "SomeFunc(a)") + (ty-header @9.1-9.12 (name "SomeFunc") (ty-args - (ty-var @11.10-11.11 (name "a"))))) - (alias @13.1-13.13 (type "MyType") - (ty-header @13.1-13.7 (name "MyType"))) - (alias @15.1-15.24 (type "Error") - (ty-header @15.1-15.8 (name "MyType2")))) + (ty-rigid-var @9.10-9.11 (name "a"))))) + (alias @11.1-11.13 (type "MyType") + (ty-header @11.1-11.7 (name "MyType"))) + (alias @13.1-13.24 (type "MyType2") + (ty-header @13.1-13.8 (name "MyType2")))) (expressions)) ~~~ diff --git a/test/snapshots/type_function_basic.md b/test/snapshots/type_function_basic.md index a6850b8b51..12444a7f2b 100644 --- a/test/snapshots/type_function_basic.md +++ b/test/snapshots/type_function_basic.md @@ -123,9 +123,9 @@ main! = |_| {} ~~~clojure (inferred-types (defs - (patt @4.1-4.6 (type "_arg -> ret, _arg2 -> ret2")) + (patt @4.1-4.6 (type "a -> b, a -> b")) (patt @6.1-6.6 (type "_arg -> {}"))) (expressions - (expr @4.9-4.22 (type "_arg -> ret, _arg2 -> ret2")) + (expr @4.9-4.22 (type "a -> b, a -> b")) (expr @6.9-6.15 (type "_arg -> {}")))) ~~~ diff --git a/test/snapshots/type_function_effectful.md b/test/snapshots/type_function_effectful.md index c9241154c8..01c6d33f83 100644 --- a/test/snapshots/type_function_effectful.md +++ b/test/snapshots/type_function_effectful.md @@ -123,9 +123,9 @@ main! = |_| {} ~~~clojure (inferred-types (defs - (patt @4.1-4.11 (type "_arg -> ret, _arg2 -> ret2")) + (patt @4.1-4.11 (type "a -> b, a -> b")) (patt @6.1-6.6 (type "_arg -> {}"))) (expressions - (expr @4.14-4.29 (type "_arg -> ret, _arg2 -> ret2")) + (expr @4.14-4.29 (type "a -> b, a -> b")) (expr @6.9-6.15 (type "_arg -> {}")))) ~~~ diff --git a/test/snapshots/type_function_multi_arg.md b/test/snapshots/type_function_multi_arg.md index 2fd14c6c54..ebcdb94353 100644 --- a/test/snapshots/type_function_multi_arg.md +++ b/test/snapshots/type_function_multi_arg.md @@ -141,8 +141,8 @@ main! = |_| {} (p-assign @4.15-4.16 (ident "x"))) (e-closure @4.18-4.30 (captures - (capture @4.10-4.12 (ident "fn")) - (capture @4.15-4.16 (ident "x"))) + (capture @4.15-4.16 (ident "x")) + (capture @4.10-4.12 (ident "fn"))) (e-lambda @4.18-4.30 (args (p-assign @4.19-4.20 (ident "y"))) @@ -164,9 +164,9 @@ main! = |_| {} ~~~clojure (inferred-types (defs - (patt @4.1-4.6 (type "_arg, _arg2 -> ret -> _arg3 -> _arg4 -> ret2")) + (patt @4.1-4.6 (type "a, b -> c -> a -> b -> c")) (patt @6.1-6.6 (type "_arg -> {}"))) (expressions - (expr @4.9-4.30 (type "_arg, _arg2 -> ret -> _arg3 -> _arg4 -> ret2")) + (expr @4.9-4.30 (type "a, b -> c -> a -> b -> c")) (expr @6.9-6.15 (type "_arg -> {}")))) ~~~ diff --git a/test/snapshots/type_function_simple.md b/test/snapshots/type_function_simple.md index a52b9fd948..5c9260d31e 100644 --- a/test/snapshots/type_function_simple.md +++ b/test/snapshots/type_function_simple.md @@ -123,9 +123,9 @@ main! = |_| {} ~~~clojure (inferred-types (defs - (patt @4.1-4.6 (type "_arg -> ret, _arg2 -> ret2")) + (patt @4.1-4.6 (type "a -> b, a -> b")) (patt @6.1-6.6 (type "_arg -> {}"))) (expressions - (expr @4.9-4.22 (type "_arg -> ret, _arg2 -> ret2")) + (expr @4.9-4.22 (type "a -> b, a -> b")) (expr @6.9-6.15 (type "_arg -> {}")))) ~~~ diff --git a/test/snapshots/type_higher_order_multiple_vars.md b/test/snapshots/type_higher_order_multiple_vars.md index de26fed29f..c6a64eb271 100644 --- a/test/snapshots/type_higher_order_multiple_vars.md +++ b/test/snapshots/type_higher_order_multiple_vars.md @@ -171,8 +171,8 @@ main! = |_| {} (p-assign @4.15-4.16 (ident "g"))) (e-closure @4.18-4.29 (captures - (capture @4.15-4.16 (ident "g")) - (capture @4.12-4.13 (ident "f"))) + (capture @4.12-4.13 (ident "f")) + (capture @4.15-4.16 (ident "g"))) (e-lambda @4.18-4.29 (args (p-assign @4.19-4.20 (ident "x"))) @@ -195,9 +195,9 @@ main! = |_| {} ~~~clojure (inferred-types (defs - (patt @4.1-4.8 (type "arg -> ret, _arg2 -> ret2 -> _arg3 -> ret3")) + (patt @4.1-4.8 (type "a -> b, c -> a -> c -> b")) (patt @6.1-6.6 (type "_arg -> {}"))) (expressions - (expr @4.11-4.29 (type "arg -> ret, _arg2 -> ret2 -> _arg3 -> ret3")) + (expr @4.11-4.29 (type "a -> b, c -> a -> c -> b")) (expr @6.9-6.15 (type "_arg -> {}")))) ~~~ diff --git a/test/snapshots/type_local_scope_vars.md b/test/snapshots/type_local_scope_vars.md index 8c2506e993..6c5650237d 100644 --- a/test/snapshots/type_local_scope_vars.md +++ b/test/snapshots/type_local_scope_vars.md @@ -102,10 +102,6 @@ main! = |_| {} (args (p-assign @4.10-4.11 (ident "x"))) (e-block @4.13-9.2 - (s-type-anno @5.5-5.19 (name "inner") - (ty-fn @5.13-5.19 (effectful false) - (ty-var @5.13-5.14 (name "b")) - (ty-var @5.18-5.19 (name "b")))) (s-let @6.5-6.18 (p-assign @6.5-6.10 (ident "inner")) (e-lambda @6.13-6.18 @@ -121,8 +117,8 @@ main! = |_| {} (annotation @4.1-4.6 (declared-type (ty-fn @3.9-3.15 (effectful false) - (ty-var @3.9-3.10 (name "a")) - (ty-var @3.14-3.15 (name "a")))))) + (ty-rigid-var @3.9-3.10 (name "a")) + (ty-rigid-var-lookup (ty-rigid-var @3.9-3.10 (name "a"))))))) (d-let (p-assign @11.1-11.6 (ident "main!")) (e-lambda @11.9-11.15 diff --git a/test/snapshots/type_module/WrongName.md b/test/snapshots/type_module/WrongName.md new file mode 100644 index 0000000000..95feeadf23 --- /dev/null +++ b/test/snapshots/type_module/WrongName.md @@ -0,0 +1,68 @@ +# META +~~~ini +description=Invalid type module - type name doesn't match module name +type=file +~~~ +# SOURCE +~~~roc +SomeOtherName := [A, B] +~~~ +# EXPECTED +TYPE MODULE MISSING MATCHING TYPE - WrongName.md:1:1:1:24 +# PROBLEMS +**TYPE MODULE MISSING MATCHING TYPE** +Type modules must have a type declaration matching the module name. + +This file is named `WrongName`.roc, but no top-level type declaration named `WrongName` was found. + +Add either: +`WrongName := ...` (nominal type) +or: +`WrongName : ...` (type alias) +**WrongName.md:1:1:1:24:** +```roc +SomeOtherName := [A, B] +``` +^^^^^^^^^^^^^^^^^^^^^^^ + + +# TOKENS +~~~zig +UpperIdent(1:1-1:14),OpColonEqual(1:15-1:17),OpenSquare(1:18-1:19),UpperIdent(1:19-1:20),Comma(1:20-1:21),UpperIdent(1:22-1:23),CloseSquare(1:23-1:24), +EndOfFile(2:1-2:1), +~~~ +# PARSE +~~~clojure +(file @1.1-1.24 + (type-module @1.1-1.14) + (statements + (s-type-decl @1.1-1.24 + (header @1.1-1.14 (name "SomeOtherName") + (args)) + (ty-tag-union @1.18-1.24 + (tags + (ty @1.19-1.20 (name "A")) + (ty @1.22-1.23 (name "B"))))))) +~~~ +# FORMATTED +~~~roc +NO CHANGE +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (s-nominal-decl @1.1-1.24 + (ty-header @1.1-1.14 (name "SomeOtherName")) + (ty-tag-union @1.18-1.24 + (ty-tag-name @1.19-1.20 (name "A")) + (ty-tag-name @1.22-1.23 (name "B"))))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs) + (type_decls + (nominal @1.1-1.24 (type "SomeOtherName") + (ty-header @1.1-1.14 (name "SomeOtherName")))) + (expressions)) +~~~ diff --git a/test/snapshots/type_module/no_type_no_main.md b/test/snapshots/type_module/no_type_no_main.md new file mode 100644 index 0000000000..ddf28e201d --- /dev/null +++ b/test/snapshots/type_module/no_type_no_main.md @@ -0,0 +1,59 @@ +# META +~~~ini +description=Headerless module with no type and no main! reports invalid type module +type=file +~~~ +# SOURCE +~~~roc +x = 5 +~~~ +# EXPECTED +MISSING MAIN! FUNCTION - no_type_no_main.md:1:1:1:6 +# PROBLEMS +**MISSING MAIN! FUNCTION** +Default app modules must have a `main!` function. + +No `main!` function was found. + +Add a main! function like: +`main! = |arg| { ... }` +**no_type_no_main.md:1:1:1:6:** +```roc +x = 5 +``` +^^^^^ + + +# TOKENS +~~~zig +LowerIdent(1:1-1:2),OpAssign(1:3-1:4),Int(1:5-1:6), +EndOfFile(2:1-2:1), +~~~ +# PARSE +~~~clojure +(file @1.1-1.6 + (type-module @1.1-1.2) + (statements + (s-decl @1.1-1.6 + (p-ident @1.1-1.2 (raw "x")) + (e-int @1.5-1.6 (raw "5"))))) +~~~ +# FORMATTED +~~~roc +NO CHANGE +~~~ +# CANONICALIZE +~~~clojure +(can-ir + (d-let + (p-assign @1.1-1.2 (ident "x")) + (e-num @1.5-1.6 (value "5")))) +~~~ +# TYPES +~~~clojure +(inferred-types + (defs + (patt @1.1-1.2 (type "Num(_size)"))) + (expressions + (expr @1.5-1.6 (type "Num(_size)")))) +~~~ diff --git a/test/snapshots/type_multiple_aliases.md b/test/snapshots/type_multiple_aliases.md index 7f192aa3f4..0c80787095 100644 --- a/test/snapshots/type_multiple_aliases.md +++ b/test/snapshots/type_multiple_aliases.md @@ -157,10 +157,10 @@ NO CHANGE (annotation @9.1-9.12 (declared-type (ty-fn @8.15-8.48 (effectful false) - (ty @8.15-8.21 (name "UserId")) - (ty @8.23-8.31 (name "UserName")) - (ty @8.33-8.40 (name "UserAge")) - (ty @8.44-8.48 (name "User")))))) + (ty-lookup @8.15-8.21 (name "UserId") (local)) + (ty-lookup @8.23-8.31 (name "UserName") (local)) + (ty-lookup @8.33-8.40 (name "UserAge") (local)) + (ty-lookup @8.44-8.48 (name "User") (local)))))) (d-let (p-assign @12.1-12.14 (ident "get_user_name")) (e-lambda @12.17-12.33 @@ -173,8 +173,8 @@ NO CHANGE (annotation @12.1-12.14 (declared-type (ty-fn @11.17-11.33 (effectful false) - (ty @11.17-11.21 (name "User")) - (ty @11.25-11.33 (name "UserName")))))) + (ty-lookup @11.17-11.21 (name "User") (local)) + (ty-lookup @11.25-11.33 (name "UserName") (local)))))) (d-let (p-assign @14.1-14.6 (ident "main!")) (e-closure @14.9-17.2 @@ -190,10 +190,10 @@ NO CHANGE (e-call @15.9-15.38 (e-lookup-local @15.9-15.20 (p-assign @9.1-9.12 (ident "create_user"))) - (e-int @15.21-15.24 (value "123")) + (e-num @15.21-15.24 (value "123")) (e-string @15.26-15.33 (e-literal @15.27-15.32 (string "Alice"))) - (e-int @15.35-15.37 (value "25")))) + (e-num @15.35-15.37 (value "25")))) (e-call @16.2-16.21 (e-lookup-local @16.2-16.15 (p-assign @12.1-12.14 (ident "get_user_name"))) @@ -201,22 +201,22 @@ NO CHANGE (p-assign @15.2-15.6 (ident "user")))))))) (s-alias-decl @3.1-3.13 (ty-header @3.1-3.7 (name "UserId")) - (ty @3.10-3.13 (name "U64"))) + (ty-lookup @3.10-3.13 (name "U64") (builtin))) (s-alias-decl @4.1-4.15 (ty-header @4.1-4.9 (name "UserName")) - (ty @4.12-4.15 (name "Str"))) + (ty-lookup @4.12-4.15 (name "Str") (builtin))) (s-alias-decl @5.1-5.13 (ty-header @5.1-5.8 (name "UserAge")) - (ty @5.11-5.13 (name "U8"))) + (ty-lookup @5.11-5.13 (name "U8") (builtin))) (s-alias-decl @6.1-6.55 (ty-header @6.1-6.5 (name "User")) (ty-record @6.8-6.55 (field (field "id") - (ty @6.15-6.21 (name "UserId"))) + (ty-lookup @6.15-6.21 (name "UserId") (local))) (field (field "name") - (ty @6.30-6.38 (name "UserName"))) + (ty-lookup @6.30-6.38 (name "UserName") (local))) (field (field "age") - (ty @6.46-6.53 (name "UserAge")))))) + (ty-lookup @6.46-6.53 (name "UserAge") (local)))))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/type_record_basic.md b/test/snapshots/type_record_basic.md index 6889d7c614..d6c29c554f 100644 --- a/test/snapshots/type_record_basic.md +++ b/test/snapshots/type_record_basic.md @@ -10,23 +10,36 @@ app [main!] { pf: platform "../basic-cli/main.roc" } getName : { name: Str, age: U64 } -> Str getName = |_person| "hello" -main! = |_| getName({name: "luke", age:21}) +main! = |_| getName({namee: "luke", age:21}) ~~~ # EXPECTED -NIL +TYPE MISMATCH - type_record_basic.md:6:21:6:44 # PROBLEMS -NIL +**TYPE MISMATCH** +The first argument being passed to this function has the wrong type: +**type_record_basic.md:6:21:6:44:** +```roc +main! = |_| getName({namee: "luke", age:21}) +``` + ^^^^^^^^^^^^^^^^^^^^^^^ + +This argument has the type: + _{ age: Num(_size), namee: Str }_ + +But `getName` needs the first argument to be: + _{ age: Num(Int(Unsigned64)), name: Str }_ + # TOKENS ~~~zig KwApp(1:1-1:4),OpenSquare(1:5-1:6),LowerIdent(1:6-1:11),CloseSquare(1:11-1:12),OpenCurly(1:13-1:14),LowerIdent(1:15-1:17),OpColon(1:17-1:18),KwPlatform(1:19-1:27),StringStart(1:28-1:29),StringPart(1:29-1:50),StringEnd(1:50-1:51),CloseCurly(1:52-1:53), LowerIdent(3:1-3:8),OpColon(3:9-3:10),OpenCurly(3:11-3:12),LowerIdent(3:13-3:17),OpColon(3:17-3:18),UpperIdent(3:19-3:22),Comma(3:22-3:23),LowerIdent(3:24-3:27),OpColon(3:27-3:28),UpperIdent(3:29-3:32),CloseCurly(3:33-3:34),OpArrow(3:35-3:37),UpperIdent(3:38-3:41), LowerIdent(4:1-4:8),OpAssign(4:9-4:10),OpBar(4:11-4:12),NamedUnderscore(4:12-4:19),OpBar(4:19-4:20),StringStart(4:21-4:22),StringPart(4:22-4:27),StringEnd(4:27-4:28), -LowerIdent(6:1-6:6),OpAssign(6:7-6:8),OpBar(6:9-6:10),Underscore(6:10-6:11),OpBar(6:11-6:12),LowerIdent(6:13-6:20),NoSpaceOpenRound(6:20-6:21),OpenCurly(6:21-6:22),LowerIdent(6:22-6:26),OpColon(6:26-6:27),StringStart(6:28-6:29),StringPart(6:29-6:33),StringEnd(6:33-6:34),Comma(6:34-6:35),LowerIdent(6:36-6:39),OpColon(6:39-6:40),Int(6:40-6:42),CloseCurly(6:42-6:43),CloseRound(6:43-6:44), +LowerIdent(6:1-6:6),OpAssign(6:7-6:8),OpBar(6:9-6:10),Underscore(6:10-6:11),OpBar(6:11-6:12),LowerIdent(6:13-6:20),NoSpaceOpenRound(6:20-6:21),OpenCurly(6:21-6:22),LowerIdent(6:22-6:27),OpColon(6:27-6:28),StringStart(6:29-6:30),StringPart(6:30-6:34),StringEnd(6:34-6:35),Comma(6:35-6:36),LowerIdent(6:37-6:40),OpColon(6:40-6:41),Int(6:41-6:43),CloseCurly(6:43-6:44),CloseRound(6:44-6:45), EndOfFile(7:1-7:1), ~~~ # PARSE ~~~clojure -(file @1.1-6.44 +(file @1.1-6.45 (app @1.1-1.53 (provides @1.5-1.12 (exposed-lower-ident @1.6-1.11 @@ -54,19 +67,19 @@ EndOfFile(7:1-7:1), (p-ident @4.12-4.19 (raw "_person"))) (e-string @4.21-4.28 (e-string-part @4.22-4.27 (raw "hello"))))) - (s-decl @6.1-6.44 + (s-decl @6.1-6.45 (p-ident @6.1-6.6 (raw "main!")) - (e-lambda @6.9-6.44 + (e-lambda @6.9-6.45 (args (p-underscore)) - (e-apply @6.13-6.44 + (e-apply @6.13-6.45 (e-ident @6.13-6.20 (raw "getName")) - (e-record @6.21-6.43 - (field (field "name") - (e-string @6.28-6.34 - (e-string-part @6.29-6.33 (raw "luke")))) + (e-record @6.21-6.44 + (field (field "namee") + (e-string @6.29-6.35 + (e-string-part @6.30-6.34 (raw "luke")))) (field (field "age") - (e-int @6.40-6.42 (raw "21"))))))))) + (e-int @6.41-6.43 (raw "21"))))))))) ~~~ # FORMATTED ~~~roc @@ -75,7 +88,7 @@ app [main!] { pf: platform "../basic-cli/main.roc" } getName : { name : Str, age : U64 } -> Str getName = |_person| "hello" -main! = |_| getName({ name: "luke", age: 21 }) +main! = |_| getName({ namee: "luke", age: 21 }) ~~~ # CANONICALIZE ~~~clojure @@ -92,36 +105,36 @@ main! = |_| getName({ name: "luke", age: 21 }) (ty-fn @3.11-3.41 (effectful false) (ty-record @3.11-3.34 (field (field "name") - (ty @3.19-3.22 (name "Str"))) + (ty-lookup @3.19-3.22 (name "Str") (builtin))) (field (field "age") - (ty @3.29-3.32 (name "U64")))) - (ty @3.38-3.41 (name "Str")))))) + (ty-lookup @3.29-3.32 (name "U64") (builtin)))) + (ty-lookup @3.38-3.41 (name "Str") (builtin)))))) (d-let (p-assign @6.1-6.6 (ident "main!")) - (e-closure @6.9-6.44 + (e-closure @6.9-6.45 (captures (capture @4.1-4.8 (ident "getName"))) - (e-lambda @6.9-6.44 + (e-lambda @6.9-6.45 (args (p-underscore @6.10-6.11)) - (e-call @6.13-6.44 + (e-call @6.13-6.45 (e-lookup-local @6.13-6.20 (p-assign @4.1-4.8 (ident "getName"))) - (e-record @6.21-6.43 + (e-record @6.21-6.44 (fields - (field (name "name") - (e-string @6.28-6.34 - (e-literal @6.29-6.33 (string "luke")))) + (field (name "namee") + (e-string @6.29-6.35 + (e-literal @6.30-6.34 (string "luke")))) (field (name "age") - (e-int @6.40-6.42 (value "21")))))))))) + (e-num @6.41-6.43 (value "21")))))))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @4.1-4.8 (type "{ age: U64, name: Str } -> Str")) - (patt @6.1-6.6 (type "_arg -> Str"))) + (patt @4.1-4.8 (type "{ age: Num(Int(Unsigned64)), name: Str } -> Str")) + (patt @6.1-6.6 (type "_arg -> Error"))) (expressions - (expr @4.11-4.28 (type "{ age: U64, name: Str } -> Str")) - (expr @6.9-6.44 (type "_arg -> Str")))) + (expr @4.11-4.28 (type "{ age: Num(Int(Unsigned64)), name: Str } -> Str")) + (expr @6.9-6.45 (type "_arg -> Error")))) ~~~ diff --git a/test/snapshots/type_record_effectful.md b/test/snapshots/type_record_effectful.md index 83d9eab9f7..ca262762f4 100644 --- a/test/snapshots/type_record_effectful.md +++ b/test/snapshots/type_record_effectful.md @@ -113,7 +113,7 @@ main! = |_| {} (s-expr @7.5-7.30 (e-call @7.5-7.30 (e-lookup-external @7.5-7.17 - (module-idx "0") + (module-idx "2") (target-node-idx "0")) (e-dot-access @7.18-7.29 (field "name") (receiver @@ -128,10 +128,10 @@ main! = |_| {} (ty-fn @5.13-5.43 (effectful true) (ty-record @5.13-5.36 (field (field "name") - (ty @5.21-5.24 (name "Str"))) + (ty-lookup @5.21-5.24 (name "Str") (builtin))) (field (field "age") - (ty @5.31-5.34 (name "U64")))) - (ty @5.40-5.43 (name "Str")))))) + (ty-lookup @5.31-5.34 (name "U64") (builtin)))) + (ty-lookup @5.40-5.43 (name "Str") (builtin)))))) (d-let (p-assign @10.1-10.6 (ident "main!")) (e-lambda @10.9-10.15 @@ -145,9 +145,9 @@ main! = |_| {} ~~~clojure (inferred-types (defs - (patt @6.1-6.10 (type "{ age: U64, name: Str } => Str")) + (patt @6.1-6.10 (type "{ age: Num(Int(Unsigned64)), name: Str } => Str")) (patt @10.1-10.6 (type "_arg -> {}"))) (expressions - (expr @6.13-9.2 (type "{ age: U64, name: Str } => Str")) + (expr @6.13-9.2 (type "{ age: Num(Int(Unsigned64)), name: Str } => Str")) (expr @10.9-10.15 (type "_arg -> {}")))) ~~~ diff --git a/test/snapshots/type_record_simple.md b/test/snapshots/type_record_simple.md index 67f142ed63..c1224d43ec 100644 --- a/test/snapshots/type_record_simple.md +++ b/test/snapshots/type_record_simple.md @@ -88,10 +88,10 @@ main! = |_| {} (ty-fn @3.12-3.42 (effectful false) (ty-record @3.12-3.35 (field (field "name") - (ty @3.20-3.23 (name "Str"))) + (ty-lookup @3.20-3.23 (name "Str") (builtin))) (field (field "age") - (ty @3.30-3.33 (name "U64")))) - (ty @3.39-3.42 (name "Str")))))) + (ty-lookup @3.30-3.33 (name "U64") (builtin)))) + (ty-lookup @3.39-3.42 (name "Str") (builtin)))))) (d-let (p-assign @6.1-6.6 (ident "main!")) (e-lambda @6.9-6.15 @@ -103,9 +103,9 @@ main! = |_| {} ~~~clojure (inferred-types (defs - (patt @4.1-4.9 (type "{ age: U64, name: Str } -> Str")) + (patt @4.1-4.9 (type "{ age: Num(Int(Unsigned64)), name: Str } -> Str")) (patt @6.1-6.6 (type "_arg -> {}"))) (expressions - (expr @4.12-4.32 (type "{ age: U64, name: Str } -> Str")) + (expr @4.12-4.32 (type "{ age: Num(Int(Unsigned64)), name: Str } -> Str")) (expr @6.9-6.15 (type "_arg -> {}")))) ~~~ diff --git a/test/snapshots/type_record_with_vars.md b/test/snapshots/type_record_with_vars.md index d113835eed..1c697c12f9 100644 --- a/test/snapshots/type_record_with_vars.md +++ b/test/snapshots/type_record_with_vars.md @@ -88,10 +88,10 @@ main! = |_| {} (ty-fn @3.12-3.40 (effectful false) (ty-record @3.12-3.35 (field (field "field") - (ty-var @3.21-3.22 (name "a"))) + (ty-rigid-var @3.21-3.22 (name "a"))) (field (field "other") - (ty-var @3.31-3.33 (name "_b")))) - (ty-var @3.39-3.40 (name "a")))))) + (ty-rigid-var @3.31-3.33 (name "_b")))) + (ty-rigid-var-lookup (ty-rigid-var @3.21-3.22 (name "a"))))))) (d-let (p-assign @6.1-6.6 (ident "main!")) (e-lambda @6.9-6.15 diff --git a/test/snapshots/type_redeclaration_same_scope.md b/test/snapshots/type_redeclaration_same_scope.md index 4e685122d7..3896ebf98d 100644 --- a/test/snapshots/type_redeclaration_same_scope.md +++ b/test/snapshots/type_redeclaration_same_scope.md @@ -1,30 +1,28 @@ # META ~~~ini description=Type redeclaration in same scope should produce error -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [Maybe] - Maybe(a) : [Some(a), None] Maybe(a) : [Ok(a), Err] ~~~ # EXPECTED -TYPE REDECLARED - type_redeclaration_same_scope.md:4:1:4:24 +TYPE REDECLARED - type_redeclaration_same_scope.md:2:1:2:24 # PROBLEMS **TYPE REDECLARED** The type _Maybe_ is being redeclared. The redeclaration is here: -**type_redeclaration_same_scope.md:4:1:4:24:** +**type_redeclaration_same_scope.md:2:1:2:24:** ```roc Maybe(a) : [Ok(a), Err] ``` ^^^^^^^^^^^^^^^^^^^^^^^ But _Maybe_ was already declared here: -**type_redeclaration_same_scope.md:3:1:3:27:** +**type_redeclaration_same_scope.md:1:1:1:27:** ```roc Maybe(a) : [Some(a), None] ``` @@ -33,38 +31,35 @@ Maybe(a) : [Some(a), None] # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:14),CloseSquare(1:14-1:15), -UpperIdent(3:1-3:6),NoSpaceOpenRound(3:6-3:7),LowerIdent(3:7-3:8),CloseRound(3:8-3:9),OpColon(3:10-3:11),OpenSquare(3:12-3:13),UpperIdent(3:13-3:17),NoSpaceOpenRound(3:17-3:18),LowerIdent(3:18-3:19),CloseRound(3:19-3:20),Comma(3:20-3:21),UpperIdent(3:22-3:26),CloseSquare(3:26-3:27), -UpperIdent(4:1-4:6),NoSpaceOpenRound(4:6-4:7),LowerIdent(4:7-4:8),CloseRound(4:8-4:9),OpColon(4:10-4:11),OpenSquare(4:12-4:13),UpperIdent(4:13-4:15),NoSpaceOpenRound(4:15-4:16),LowerIdent(4:16-4:17),CloseRound(4:17-4:18),Comma(4:18-4:19),UpperIdent(4:20-4:23),CloseSquare(4:23-4:24), -EndOfFile(5:1-5:1), +UpperIdent(1:1-1:6),NoSpaceOpenRound(1:6-1:7),LowerIdent(1:7-1:8),CloseRound(1:8-1:9),OpColon(1:10-1:11),OpenSquare(1:12-1:13),UpperIdent(1:13-1:17),NoSpaceOpenRound(1:17-1:18),LowerIdent(1:18-1:19),CloseRound(1:19-1:20),Comma(1:20-1:21),UpperIdent(1:22-1:26),CloseSquare(1:26-1:27), +UpperIdent(2:1-2:6),NoSpaceOpenRound(2:6-2:7),LowerIdent(2:7-2:8),CloseRound(2:8-2:9),OpColon(2:10-2:11),OpenSquare(2:12-2:13),UpperIdent(2:13-2:15),NoSpaceOpenRound(2:15-2:16),LowerIdent(2:16-2:17),CloseRound(2:17-2:18),Comma(2:18-2:19),UpperIdent(2:20-2:23),CloseSquare(2:23-2:24), +EndOfFile(3:1-3:1), ~~~ # PARSE ~~~clojure -(file @1.1-4.24 - (module @1.1-1.15 - (exposes @1.8-1.15 - (exposed-upper-ident @1.9-1.14 (text "Maybe")))) +(file @1.1-2.24 + (type-module @1.1-1.6) (statements - (s-type-decl @3.1-3.27 - (header @3.1-3.9 (name "Maybe") + (s-type-decl @1.1-1.27 + (header @1.1-1.9 (name "Maybe") (args - (ty-var @3.7-3.8 (raw "a")))) - (ty-tag-union @3.12-3.27 + (ty-var @1.7-1.8 (raw "a")))) + (ty-tag-union @1.12-1.27 (tags - (ty-apply @3.13-3.20 - (ty @3.13-3.17 (name "Some")) - (ty-var @3.18-3.19 (raw "a"))) - (ty @3.22-3.26 (name "None"))))) - (s-type-decl @4.1-4.24 - (header @4.1-4.9 (name "Maybe") + (ty-apply @1.13-1.20 + (ty @1.13-1.17 (name "Some")) + (ty-var @1.18-1.19 (raw "a"))) + (ty @1.22-1.26 (name "None"))))) + (s-type-decl @2.1-2.24 + (header @2.1-2.9 (name "Maybe") (args - (ty-var @4.7-4.8 (raw "a")))) - (ty-tag-union @4.12-4.24 + (ty-var @2.7-2.8 (raw "a")))) + (ty-tag-union @2.12-2.24 (tags - (ty-apply @4.13-4.18 - (ty @4.13-4.15 (name "Ok")) - (ty-var @4.16-4.17 (raw "a"))) - (ty @4.20-4.23 (name "Err"))))))) + (ty-apply @2.13-2.18 + (ty @2.13-2.15 (name "Ok")) + (ty-var @2.16-2.17 (raw "a"))) + (ty @2.20-2.23 (name "Err"))))))) ~~~ # FORMATTED ~~~roc @@ -73,35 +68,35 @@ NO CHANGE # CANONICALIZE ~~~clojure (can-ir - (s-alias-decl @3.1-3.27 - (ty-header @3.1-3.9 (name "Maybe") + (s-alias-decl @1.1-1.27 + (ty-header @1.1-1.9 (name "Maybe") (ty-args - (ty-var @3.7-3.8 (name "a")))) - (ty-tag-union @3.12-3.27 - (ty-apply @3.13-3.20 (symbol "Some") - (ty-var @3.18-3.19 (name "a"))) - (ty @3.22-3.26 (name "None")))) - (s-alias-decl @4.1-4.24 - (ty-header @4.1-4.9 (name "Maybe") + (ty-rigid-var @1.7-1.8 (name "a")))) + (ty-tag-union @1.12-1.27 + (ty-tag-name @1.13-1.20 (name "Some") + (ty-rigid-var-lookup (ty-rigid-var @1.7-1.8 (name "a")))) + (ty-tag-name @1.22-1.26 (name "None")))) + (s-alias-decl @2.1-2.24 + (ty-header @2.1-2.9 (name "Maybe") (ty-args - (ty-var @4.7-4.8 (name "a")))) - (ty-tag-union @4.12-4.24 - (ty-apply @4.13-4.18 (symbol "Ok") - (ty-var @4.16-4.17 (name "a"))) - (ty @4.20-4.23 (name "Err"))))) + (ty-rigid-var @2.7-2.8 (name "a")))) + (ty-tag-union @2.12-2.24 + (ty-tag-name @2.13-2.18 (name "Ok") + (ty-rigid-var-lookup (ty-rigid-var @2.7-2.8 (name "a")))) + (ty-tag-name @2.20-2.23 (name "Err"))))) ~~~ # TYPES ~~~clojure (inferred-types (defs) (type_decls - (alias @3.1-3.27 (type "Maybe(a)") - (ty-header @3.1-3.9 (name "Maybe") + (alias @1.1-1.27 (type "Maybe(a)") + (ty-header @1.1-1.9 (name "Maybe") (ty-args - (ty-var @3.7-3.8 (name "a"))))) - (alias @4.1-4.24 (type "Maybe(a)") - (ty-header @4.1-4.9 (name "Maybe") + (ty-rigid-var @1.7-1.8 (name "a"))))) + (alias @2.1-2.24 (type "Maybe(a)") + (ty-header @2.1-2.9 (name "Maybe") (ty-args - (ty-var @4.7-4.8 (name "a")))))) + (ty-rigid-var @2.7-2.8 (name "a")))))) (expressions)) ~~~ diff --git a/test/snapshots/type_same_var_multiple_uses.md b/test/snapshots/type_same_var_multiple_uses.md index f4e0ba7059..3d14f5e707 100644 --- a/test/snapshots/type_same_var_multiple_uses.md +++ b/test/snapshots/type_same_var_multiple_uses.md @@ -81,10 +81,10 @@ NO CHANGE (annotation @4.1-4.5 (declared-type (ty-fn @3.8-3.19 (effectful false) - (ty-var @3.8-3.9 (name "a")) + (ty-rigid-var @3.8-3.9 (name "a")) (ty-tuple @3.13-3.19 - (ty-var @3.14-3.15 (name "a")) - (ty-var @3.17-3.18 (name "a"))))))) + (ty-rigid-var-lookup (ty-rigid-var @3.8-3.9 (name "a"))) + (ty-rigid-var-lookup (ty-rigid-var @3.8-3.9 (name "a")))))))) (d-let (p-assign @6.1-6.6 (ident "main!")) (e-lambda @6.9-6.15 diff --git a/test/snapshots/type_scope_integration.md b/test/snapshots/type_scope_integration.md index c561be816a..b62e30ace2 100644 --- a/test/snapshots/type_scope_integration.md +++ b/test/snapshots/type_scope_integration.md @@ -1,12 +1,10 @@ # META ~~~ini description=Type declaration scope integration - redeclaration and undeclared type errors -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [Foo, Bar] - # First declare a type Foo : U64 @@ -20,21 +18,21 @@ Bar : SomeUndeclaredType Baz : Foo ~~~ # EXPECTED -TYPE REDECLARED - type_scope_integration.md:7:1:7:10 -UNDECLARED TYPE - type_scope_integration.md:10:7:10:25 +TYPE REDECLARED - type_scope_integration.md:5:1:5:10 +UNDECLARED TYPE - type_scope_integration.md:8:7:8:25 # PROBLEMS **TYPE REDECLARED** The type _Foo_ is being redeclared. The redeclaration is here: -**type_scope_integration.md:7:1:7:10:** +**type_scope_integration.md:5:1:5:10:** ```roc Foo : Str ``` ^^^^^^^^^ But _Foo_ was already declared here: -**type_scope_integration.md:4:1:4:10:** +**type_scope_integration.md:2:1:2:10:** ```roc Foo : U64 ``` @@ -45,7 +43,7 @@ Foo : U64 The type _SomeUndeclaredType_ is not declared in this scope. This type is referenced here: -**type_scope_integration.md:10:7:10:25:** +**type_scope_integration.md:8:7:8:25:** ```roc Bar : SomeUndeclaredType ``` @@ -54,70 +52,77 @@ Bar : SomeUndeclaredType # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:12),Comma(1:12-1:13),UpperIdent(1:14-1:17),CloseSquare(1:17-1:18), -UpperIdent(4:1-4:4),OpColon(4:5-4:6),UpperIdent(4:7-4:10), -UpperIdent(7:1-7:4),OpColon(7:5-7:6),UpperIdent(7:7-7:10), -UpperIdent(10:1-10:4),OpColon(10:5-10:6),UpperIdent(10:7-10:25), -UpperIdent(13:1-13:4),OpColon(13:5-13:6),UpperIdent(13:7-13:10), -EndOfFile(14:1-14:1), +UpperIdent(2:1-2:4),OpColon(2:5-2:6),UpperIdent(2:7-2:10), +UpperIdent(5:1-5:4),OpColon(5:5-5:6),UpperIdent(5:7-5:10), +UpperIdent(8:1-8:4),OpColon(8:5-8:6),UpperIdent(8:7-8:25), +UpperIdent(11:1-11:4),OpColon(11:5-11:6),UpperIdent(11:7-11:10), +EndOfFile(12:1-12:1), ~~~ # PARSE ~~~clojure -(file @1.1-13.10 - (module @1.1-1.18 - (exposes @1.8-1.18 - (exposed-upper-ident @1.9-1.12 (text "Foo")) - (exposed-upper-ident @1.14-1.17 (text "Bar")))) +(file @2.1-11.10 + (type-module @2.1-2.4) (statements - (s-type-decl @4.1-4.10 - (header @4.1-4.4 (name "Foo") + (s-type-decl @2.1-2.10 + (header @2.1-2.4 (name "Foo") (args)) - (ty @4.7-4.10 (name "U64"))) - (s-type-decl @7.1-7.10 - (header @7.1-7.4 (name "Foo") + (ty @2.7-2.10 (name "U64"))) + (s-type-decl @5.1-5.10 + (header @5.1-5.4 (name "Foo") (args)) - (ty @7.7-7.10 (name "Str"))) - (s-type-decl @10.1-10.25 - (header @10.1-10.4 (name "Bar") + (ty @5.7-5.10 (name "Str"))) + (s-type-decl @8.1-8.25 + (header @8.1-8.4 (name "Bar") (args)) - (ty @10.7-10.25 (name "SomeUndeclaredType"))) - (s-type-decl @13.1-13.10 - (header @13.1-13.4 (name "Baz") + (ty @8.7-8.25 (name "SomeUndeclaredType"))) + (s-type-decl @11.1-11.10 + (header @11.1-11.4 (name "Baz") (args)) - (ty @13.7-13.10 (name "Foo"))))) + (ty @11.7-11.10 (name "Foo"))))) ~~~ # FORMATTED ~~~roc -NO CHANGE +# First declare a type +# First declare a type +Foo : U64 + +# Try to redeclare the same type (should error) +Foo : Str + +# Declare another type that uses an undeclared type +Bar : SomeUndeclaredType + +# Declare a type that properly uses a declared type +Baz : Foo ~~~ # CANONICALIZE ~~~clojure (can-ir - (s-alias-decl @4.1-4.10 - (ty-header @4.1-4.4 (name "Foo")) - (ty @4.7-4.10 (name "U64"))) - (s-alias-decl @7.1-7.10 - (ty-header @7.1-7.4 (name "Foo")) - (ty @7.7-7.10 (name "Str"))) - (s-alias-decl @10.1-10.25 - (ty-header @10.1-10.4 (name "Bar")) - (ty @10.7-10.25 (name "SomeUndeclaredType"))) - (s-alias-decl @13.1-13.10 - (ty-header @13.1-13.4 (name "Baz")) - (ty @13.7-13.10 (name "Foo")))) + (s-alias-decl @2.1-2.10 + (ty-header @2.1-2.4 (name "Foo")) + (ty-lookup @2.7-2.10 (name "U64") (builtin))) + (s-alias-decl @5.1-5.10 + (ty-header @5.1-5.4 (name "Foo")) + (ty-lookup @5.7-5.10 (name "Str") (builtin))) + (s-alias-decl @8.1-8.25 + (ty-header @8.1-8.4 (name "Bar")) + (ty-malformed @8.7-8.25)) + (s-alias-decl @11.1-11.10 + (ty-header @11.1-11.4 (name "Baz")) + (ty-lookup @11.7-11.10 (name "Foo") (local)))) ~~~ # TYPES ~~~clojure (inferred-types (defs) (type_decls - (alias @4.1-4.10 (type "Foo") - (ty-header @4.1-4.4 (name "Foo"))) - (alias @7.1-7.10 (type "Foo") - (ty-header @7.1-7.4 (name "Foo"))) - (alias @10.1-10.25 (type "Error") - (ty-header @10.1-10.4 (name "Bar"))) - (alias @13.1-13.10 (type "Baz") - (ty-header @13.1-13.4 (name "Baz")))) + (alias @2.1-2.10 (type "Foo") + (ty-header @2.1-2.4 (name "Foo"))) + (alias @5.1-5.10 (type "Foo") + (ty-header @5.1-5.4 (name "Foo"))) + (alias @8.1-8.25 (type "Bar") + (ty-header @8.1-8.4 (name "Bar"))) + (alias @11.1-11.10 (type "Baz") + (ty-header @11.1-11.4 (name "Baz")))) (expressions)) ~~~ diff --git a/test/snapshots/type_shadowing_across_scopes.md b/test/snapshots/type_shadowing_across_scopes.md index 9f076fc42a..6be61f0e52 100644 --- a/test/snapshots/type_shadowing_across_scopes.md +++ b/test/snapshots/type_shadowing_across_scopes.md @@ -1,12 +1,10 @@ # META ~~~ini description=Type shadowing across scopes should produce warning -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [Result, processData] - Result(a, b) : [Ok(a), Err(b)] processData : Str -> Str @@ -19,19 +17,19 @@ InnerModule : { } ~~~ # EXPECTED -PARSE ERROR - type_shadowing_across_scopes.md:11:5:11:11 -PARSE ERROR - type_shadowing_across_scopes.md:11:24:11:31 -PARSE ERROR - type_shadowing_across_scopes.md:11:31:11:32 -PARSE ERROR - type_shadowing_across_scopes.md:12:1:12:2 -TYPE REDECLARED - type_shadowing_across_scopes.md:3:1:3:31 -MALFORMED TYPE - type_shadowing_across_scopes.md:11:24:11:31 -UNUSED VARIABLE - type_shadowing_across_scopes.md:6:16:6:20 +PARSE ERROR - type_shadowing_across_scopes.md:9:5:9:11 +PARSE ERROR - type_shadowing_across_scopes.md:9:24:9:31 +PARSE ERROR - type_shadowing_across_scopes.md:9:31:9:32 +PARSE ERROR - type_shadowing_across_scopes.md:10:1:10:2 +TYPE REDECLARED - type_shadowing_across_scopes.md:1:1:1:31 +MALFORMED TYPE - type_shadowing_across_scopes.md:9:24:9:31 +UNUSED VARIABLE - type_shadowing_across_scopes.md:4:16:4:20 # PROBLEMS **PARSE ERROR** A parsing error occurred: `expected_type_field_name` This is an unexpected parsing error. Please check your syntax. -**type_shadowing_across_scopes.md:11:5:11:11:** +**type_shadowing_across_scopes.md:9:5:9:11:** ```roc Result : [Success, Failure] ``` @@ -42,7 +40,7 @@ This is an unexpected parsing error. Please check your syntax. A parsing error occurred: `expected_ty_close_curly_or_comma` This is an unexpected parsing error. Please check your syntax. -**type_shadowing_across_scopes.md:11:24:11:31:** +**type_shadowing_across_scopes.md:9:24:9:31:** ```roc Result : [Success, Failure] ``` @@ -53,7 +51,7 @@ This is an unexpected parsing error. Please check your syntax. A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**type_shadowing_across_scopes.md:11:31:11:32:** +**type_shadowing_across_scopes.md:9:31:9:32:** ```roc Result : [Success, Failure] ``` @@ -64,7 +62,7 @@ This is an unexpected parsing error. Please check your syntax. A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**type_shadowing_across_scopes.md:12:1:12:2:** +**type_shadowing_across_scopes.md:10:1:10:2:** ```roc } ``` @@ -75,7 +73,7 @@ This is an unexpected parsing error. Please check your syntax. The type _Result_ is being redeclared. The redeclaration is here: -**type_shadowing_across_scopes.md:3:1:3:31:** +**type_shadowing_across_scopes.md:1:1:1:31:** ```roc Result(a, b) : [Ok(a), Err(b)] ``` @@ -84,7 +82,7 @@ Result(a, b) : [Ok(a), Err(b)] But _Result_ was already declared here: **type_shadowing_across_scopes.md:1:1:1:1:** ```roc -module [Result, processData] +Result(a, b) : [Ok(a), Err(b)] ``` ^ @@ -92,7 +90,7 @@ module [Result, processData] **MALFORMED TYPE** This type annotation is malformed or contains invalid syntax. -**type_shadowing_across_scopes.md:11:24:11:31:** +**type_shadowing_across_scopes.md:9:24:9:31:** ```roc Result : [Success, Failure] ``` @@ -104,7 +102,7 @@ Variable `data` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_data` to suppress this warning. The unused variable is declared here: -**type_shadowing_across_scopes.md:6:16:6:20:** +**type_shadowing_across_scopes.md:4:16:4:20:** ```roc processData = |data| ``` @@ -113,60 +111,53 @@ processData = |data| # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:15),Comma(1:15-1:16),LowerIdent(1:17-1:28),CloseSquare(1:28-1:29), -UpperIdent(3:1-3:7),NoSpaceOpenRound(3:7-3:8),LowerIdent(3:8-3:9),Comma(3:9-3:10),LowerIdent(3:11-3:12),CloseRound(3:12-3:13),OpColon(3:14-3:15),OpenSquare(3:16-3:17),UpperIdent(3:17-3:19),NoSpaceOpenRound(3:19-3:20),LowerIdent(3:20-3:21),CloseRound(3:21-3:22),Comma(3:22-3:23),UpperIdent(3:24-3:27),NoSpaceOpenRound(3:27-3:28),LowerIdent(3:28-3:29),CloseRound(3:29-3:30),CloseSquare(3:30-3:31), -LowerIdent(5:1-5:12),OpColon(5:13-5:14),UpperIdent(5:15-5:18),OpArrow(5:19-5:21),UpperIdent(5:22-5:25), -LowerIdent(6:1-6:12),OpAssign(6:13-6:14),OpBar(6:15-6:16),LowerIdent(6:16-6:20),OpBar(6:20-6:21), -StringStart(7:5-7:6),StringPart(7:6-7:15),StringEnd(7:15-7:16), -UpperIdent(10:1-10:12),OpColon(10:13-10:14),OpenCurly(10:15-10:16), -UpperIdent(11:5-11:11),OpColon(11:12-11:13),OpenSquare(11:14-11:15),UpperIdent(11:15-11:22),Comma(11:22-11:23),UpperIdent(11:24-11:31),CloseSquare(11:31-11:32), -CloseCurly(12:1-12:2), -EndOfFile(13:1-13:1), +UpperIdent(1:1-1:7),NoSpaceOpenRound(1:7-1:8),LowerIdent(1:8-1:9),Comma(1:9-1:10),LowerIdent(1:11-1:12),CloseRound(1:12-1:13),OpColon(1:14-1:15),OpenSquare(1:16-1:17),UpperIdent(1:17-1:19),NoSpaceOpenRound(1:19-1:20),LowerIdent(1:20-1:21),CloseRound(1:21-1:22),Comma(1:22-1:23),UpperIdent(1:24-1:27),NoSpaceOpenRound(1:27-1:28),LowerIdent(1:28-1:29),CloseRound(1:29-1:30),CloseSquare(1:30-1:31), +LowerIdent(3:1-3:12),OpColon(3:13-3:14),UpperIdent(3:15-3:18),OpArrow(3:19-3:21),UpperIdent(3:22-3:25), +LowerIdent(4:1-4:12),OpAssign(4:13-4:14),OpBar(4:15-4:16),LowerIdent(4:16-4:20),OpBar(4:20-4:21), +StringStart(5:5-5:6),StringPart(5:6-5:15),StringEnd(5:15-5:16), +UpperIdent(8:1-8:12),OpColon(8:13-8:14),OpenCurly(8:15-8:16), +UpperIdent(9:5-9:11),OpColon(9:12-9:13),OpenSquare(9:14-9:15),UpperIdent(9:15-9:22),Comma(9:22-9:23),UpperIdent(9:24-9:31),CloseSquare(9:31-9:32), +CloseCurly(10:1-10:2), +EndOfFile(11:1-11:1), ~~~ # PARSE ~~~clojure -(file @1.1-12.2 - (module @1.1-1.29 - (exposes @1.8-1.29 - (exposed-upper-ident @1.9-1.15 (text "Result")) - (exposed-lower-ident @1.17-1.28 - (text "processData")))) +(file @1.1-10.2 + (type-module @1.1-1.7) (statements - (s-type-decl @3.1-3.31 - (header @3.1-3.13 (name "Result") + (s-type-decl @1.1-1.31 + (header @1.1-1.13 (name "Result") (args - (ty-var @3.8-3.9 (raw "a")) - (ty-var @3.11-3.12 (raw "b")))) - (ty-tag-union @3.16-3.31 + (ty-var @1.8-1.9 (raw "a")) + (ty-var @1.11-1.12 (raw "b")))) + (ty-tag-union @1.16-1.31 (tags - (ty-apply @3.17-3.22 - (ty @3.17-3.19 (name "Ok")) - (ty-var @3.20-3.21 (raw "a"))) - (ty-apply @3.24-3.30 - (ty @3.24-3.27 (name "Err")) - (ty-var @3.28-3.29 (raw "b")))))) - (s-type-anno @5.1-5.25 (name "processData") - (ty-fn @5.15-5.25 - (ty @5.15-5.18 (name "Str")) - (ty @5.22-5.25 (name "Str")))) - (s-decl @6.1-7.16 - (p-ident @6.1-6.12 (raw "processData")) - (e-lambda @6.15-7.16 + (ty-apply @1.17-1.22 + (ty @1.17-1.19 (name "Ok")) + (ty-var @1.20-1.21 (raw "a"))) + (ty-apply @1.24-1.30 + (ty @1.24-1.27 (name "Err")) + (ty-var @1.28-1.29 (raw "b")))))) + (s-type-anno @3.1-3.25 (name "processData") + (ty-fn @3.15-3.25 + (ty @3.15-3.18 (name "Str")) + (ty @3.22-3.25 (name "Str")))) + (s-decl @4.1-5.16 + (p-ident @4.1-4.12 (raw "processData")) + (e-lambda @4.15-5.16 (args - (p-ident @6.16-6.20 (raw "data"))) - (e-string @7.5-7.16 - (e-string-part @7.6-7.15 (raw "processed"))))) - (s-type-decl @10.1-11.31 - (header @10.1-10.12 (name "InnerModule") + (p-ident @4.16-4.20 (raw "data"))) + (e-string @5.5-5.16 + (e-string-part @5.6-5.15 (raw "processed"))))) + (s-type-decl @8.1-9.31 + (header @8.1-8.12 (name "InnerModule") (args)) - (ty-malformed @11.24-11.31 (tag "expected_ty_close_curly_or_comma"))) - (s-malformed @11.31-11.32 (tag "statement_unexpected_token")) - (s-malformed @12.1-12.2 (tag "statement_unexpected_token")))) + (ty-malformed @9.24-9.31 (tag "expected_ty_close_curly_or_comma"))) + (s-malformed @9.31-9.32 (tag "statement_unexpected_token")) + (s-malformed @10.1-10.2 (tag "statement_unexpected_token")))) ~~~ # FORMATTED ~~~roc -module [Result, processData] - Result(a, b) : [Ok(a), Err(b)] processData : Str -> Str @@ -181,44 +172,44 @@ InnerModule : ~~~clojure (can-ir (d-let - (p-assign @6.1-6.12 (ident "processData")) - (e-lambda @6.15-7.16 + (p-assign @4.1-4.12 (ident "processData")) + (e-lambda @4.15-5.16 (args - (p-assign @6.16-6.20 (ident "data"))) - (e-string @7.5-7.16 - (e-literal @7.6-7.15 (string "processed")))) - (annotation @6.1-6.12 + (p-assign @4.16-4.20 (ident "data"))) + (e-string @5.5-5.16 + (e-literal @5.6-5.15 (string "processed")))) + (annotation @4.1-4.12 (declared-type - (ty-fn @5.15-5.25 (effectful false) - (ty @5.15-5.18 (name "Str")) - (ty @5.22-5.25 (name "Str")))))) - (s-alias-decl @3.1-3.31 - (ty-header @3.1-3.13 (name "Result") + (ty-fn @3.15-3.25 (effectful false) + (ty-lookup @3.15-3.18 (name "Str") (builtin)) + (ty-lookup @3.22-3.25 (name "Str") (builtin)))))) + (s-alias-decl @1.1-1.31 + (ty-header @1.1-1.13 (name "Result") (ty-args - (ty-var @3.8-3.9 (name "a")) - (ty-var @3.11-3.12 (name "b")))) - (ty-tag-union @3.16-3.31 - (ty-apply @3.17-3.22 (symbol "Ok") - (ty-var @3.20-3.21 (name "a"))) - (ty-apply @3.24-3.30 (symbol "Err") - (ty-var @3.28-3.29 (name "b"))))) - (s-alias-decl @10.1-11.31 - (ty-header @10.1-10.12 (name "InnerModule")) - (ty-malformed @11.24-11.31))) + (ty-rigid-var @1.8-1.9 (name "a")) + (ty-rigid-var @1.11-1.12 (name "b")))) + (ty-tag-union @1.16-1.31 + (ty-tag-name @1.17-1.22 (name "Ok") + (ty-rigid-var-lookup (ty-rigid-var @1.8-1.9 (name "a")))) + (ty-tag-name @1.24-1.30 (name "Err") + (ty-rigid-var-lookup (ty-rigid-var @1.11-1.12 (name "b")))))) + (s-alias-decl @8.1-9.31 + (ty-header @8.1-8.12 (name "InnerModule")) + (ty-malformed @9.24-9.31))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @6.1-6.12 (type "Str -> Str"))) + (patt @4.1-4.12 (type "Str -> Str"))) (type_decls - (alias @3.1-3.31 (type "Result(a, b)") - (ty-header @3.1-3.13 (name "Result") + (alias @1.1-1.31 (type "Result(a, b)") + (ty-header @1.1-1.13 (name "Result") (ty-args - (ty-var @3.8-3.9 (name "a")) - (ty-var @3.11-3.12 (name "b"))))) - (alias @10.1-11.31 (type "Error") - (ty-header @10.1-10.12 (name "InnerModule")))) + (ty-rigid-var @1.8-1.9 (name "a")) + (ty-rigid-var @1.11-1.12 (name "b"))))) + (alias @8.1-9.31 (type "InnerModule") + (ty-header @8.1-8.12 (name "InnerModule")))) (expressions - (expr @6.15-7.16 (type "Str -> Str")))) + (expr @4.15-5.16 (type "Str -> Str")))) ~~~ diff --git a/test/snapshots/type_simple_pure.md b/test/snapshots/type_simple_pure.md index d4cfaf338d..7ad8d7c19a 100644 --- a/test/snapshots/type_simple_pure.md +++ b/test/snapshots/type_simple_pure.md @@ -73,8 +73,8 @@ NO CHANGE (annotation @4.1-4.9 (declared-type (ty-fn @3.12-3.22 (effectful false) - (ty @3.12-3.15 (name "Str")) - (ty @3.19-3.22 (name "Str")))))) + (ty-lookup @3.12-3.15 (name "Str") (builtin)) + (ty-lookup @3.19-3.22 (name "Str") (builtin)))))) (d-let (p-assign @6.1-6.6 (ident "main!")) (e-lambda @6.9-6.15 diff --git a/test/snapshots/type_simple_type_var.md b/test/snapshots/type_simple_type_var.md index 3a6632997c..98b08d5c89 100644 --- a/test/snapshots/type_simple_type_var.md +++ b/test/snapshots/type_simple_type_var.md @@ -73,8 +73,8 @@ NO CHANGE (annotation @4.1-4.9 (declared-type (ty-fn @3.12-3.18 (effectful false) - (ty-var @3.12-3.13 (name "a")) - (ty-var @3.17-3.18 (name "a")))))) + (ty-rigid-var @3.12-3.13 (name "a")) + (ty-rigid-var-lookup (ty-rigid-var @3.12-3.13 (name "a"))))))) (d-let (p-assign @6.1-6.6 (ident "main!")) (e-lambda @6.9-6.15 diff --git a/test/snapshots/type_tag_union_basic.md b/test/snapshots/type_tag_union_basic.md index 256982a13e..076037023d 100644 --- a/test/snapshots/type_tag_union_basic.md +++ b/test/snapshots/type_tag_union_basic.md @@ -8,95 +8,40 @@ type=file app [main!] { pf: platform "../basic-cli/main.roc" } process : [Some(Str), None] -> Str -process = |maybe| "result" +process = |_maybe| "result" -is_ok_ret_unqualified_bool : [Ok(_ok), Err(_err)] -> Bool +is_ok_ret_unqualified_bool : [Ok2(_ok), Err2(_err)] -> Bool is_ok_ret_unqualified_bool = |result| match result { - Ok(_) => True - Err(_) => False + Ok2(_) => True + Err2(_) => False } -is_ok_ret_bool : [Ok(_ok2), Err(_err2)] -> Bool +is_ok_ret_bool : [Ok2(_ok2), Err2(_err2)] -> Bool is_ok_ret_bool = |result| match result { - Ok(_) => Bool.True - Err(_) => Bool.False + Ok2(_) => Bool.True + Err2(_) => Bool.False } main! = |_| {} ~~~ # EXPECTED -UNUSED VARIABLE - type_tag_union_basic.md:4:12:4:17 -INCOMPATIBLE MATCH PATTERNS - type_tag_union_basic.md:7:39:7:39 -INCOMPATIBLE MATCH PATTERNS - type_tag_union_basic.md:13:27:13:27 +NIL # PROBLEMS -**UNUSED VARIABLE** -Variable `maybe` is not used anywhere in your code. - -If you don't need this variable, prefix it with an underscore like `_maybe` to suppress this warning. -The unused variable is declared here: -**type_tag_union_basic.md:4:12:4:17:** -```roc -process = |maybe| "result" -``` - ^^^^^ - - -**INCOMPATIBLE MATCH PATTERNS** -The pattern in the first branch of this `match` differs from previous ones: -**type_tag_union_basic.md:7:39:** -```roc -is_ok_ret_unqualified_bool = |result| match result { - Ok(_) => True - Err(_) => False -} -``` - ^^^^^ - -The first pattern has this type: - _Result(ok, err)_ - -But the other pattern has this type: - _[Err(_err), Ok(_ok)]_ - -All patterns in an `match` must have compatible types. - - - -**INCOMPATIBLE MATCH PATTERNS** -The pattern in the first branch of this `match` differs from previous ones: -**type_tag_union_basic.md:13:27:** -```roc -is_ok_ret_bool = |result| match result { - Ok(_) => Bool.True - Err(_) => Bool.False -} -``` - ^^^^^ - -The first pattern has this type: - _Result(ok, err)_ - -But the other pattern has this type: - _[Err(_err2), Ok(_ok2)]_ - -All patterns in an `match` must have compatible types. - - - +NIL # TOKENS ~~~zig KwApp(1:1-1:4),OpenSquare(1:5-1:6),LowerIdent(1:6-1:11),CloseSquare(1:11-1:12),OpenCurly(1:13-1:14),LowerIdent(1:15-1:17),OpColon(1:17-1:18),KwPlatform(1:19-1:27),StringStart(1:28-1:29),StringPart(1:29-1:50),StringEnd(1:50-1:51),CloseCurly(1:52-1:53), LowerIdent(3:1-3:8),OpColon(3:9-3:10),OpenSquare(3:11-3:12),UpperIdent(3:12-3:16),NoSpaceOpenRound(3:16-3:17),UpperIdent(3:17-3:20),CloseRound(3:20-3:21),Comma(3:21-3:22),UpperIdent(3:23-3:27),CloseSquare(3:27-3:28),OpArrow(3:29-3:31),UpperIdent(3:32-3:35), -LowerIdent(4:1-4:8),OpAssign(4:9-4:10),OpBar(4:11-4:12),LowerIdent(4:12-4:17),OpBar(4:17-4:18),StringStart(4:19-4:20),StringPart(4:20-4:26),StringEnd(4:26-4:27), -LowerIdent(6:1-6:27),OpColon(6:28-6:29),OpenSquare(6:30-6:31),UpperIdent(6:31-6:33),NoSpaceOpenRound(6:33-6:34),NamedUnderscore(6:34-6:37),CloseRound(6:37-6:38),Comma(6:38-6:39),UpperIdent(6:40-6:43),NoSpaceOpenRound(6:43-6:44),NamedUnderscore(6:44-6:48),CloseRound(6:48-6:49),CloseSquare(6:49-6:50),OpArrow(6:51-6:53),UpperIdent(6:54-6:58), +LowerIdent(4:1-4:8),OpAssign(4:9-4:10),OpBar(4:11-4:12),NamedUnderscore(4:12-4:18),OpBar(4:18-4:19),StringStart(4:20-4:21),StringPart(4:21-4:27),StringEnd(4:27-4:28), +LowerIdent(6:1-6:27),OpColon(6:28-6:29),OpenSquare(6:30-6:31),UpperIdent(6:31-6:34),NoSpaceOpenRound(6:34-6:35),NamedUnderscore(6:35-6:38),CloseRound(6:38-6:39),Comma(6:39-6:40),UpperIdent(6:41-6:45),NoSpaceOpenRound(6:45-6:46),NamedUnderscore(6:46-6:50),CloseRound(6:50-6:51),CloseSquare(6:51-6:52),OpArrow(6:53-6:55),UpperIdent(6:56-6:60), LowerIdent(7:1-7:27),OpAssign(7:28-7:29),OpBar(7:30-7:31),LowerIdent(7:31-7:37),OpBar(7:37-7:38),KwMatch(7:39-7:44),LowerIdent(7:45-7:51),OpenCurly(7:52-7:53), -UpperIdent(8:5-8:7),NoSpaceOpenRound(8:7-8:8),Underscore(8:8-8:9),CloseRound(8:9-8:10),OpFatArrow(8:11-8:13),UpperIdent(8:14-8:18), -UpperIdent(9:5-9:8),NoSpaceOpenRound(9:8-9:9),Underscore(9:9-9:10),CloseRound(9:10-9:11),OpFatArrow(9:12-9:14),UpperIdent(9:15-9:20), +UpperIdent(8:5-8:8),NoSpaceOpenRound(8:8-8:9),Underscore(8:9-8:10),CloseRound(8:10-8:11),OpFatArrow(8:12-8:14),UpperIdent(8:15-8:19), +UpperIdent(9:5-9:9),NoSpaceOpenRound(9:9-9:10),Underscore(9:10-9:11),CloseRound(9:11-9:12),OpFatArrow(9:13-9:15),UpperIdent(9:16-9:21), CloseCurly(10:1-10:2), -LowerIdent(12:1-12:15),OpColon(12:16-12:17),OpenSquare(12:18-12:19),UpperIdent(12:19-12:21),NoSpaceOpenRound(12:21-12:22),NamedUnderscore(12:22-12:26),CloseRound(12:26-12:27),Comma(12:27-12:28),UpperIdent(12:29-12:32),NoSpaceOpenRound(12:32-12:33),NamedUnderscore(12:33-12:38),CloseRound(12:38-12:39),CloseSquare(12:39-12:40),OpArrow(12:41-12:43),UpperIdent(12:44-12:48), +LowerIdent(12:1-12:15),OpColon(12:16-12:17),OpenSquare(12:18-12:19),UpperIdent(12:19-12:22),NoSpaceOpenRound(12:22-12:23),NamedUnderscore(12:23-12:27),CloseRound(12:27-12:28),Comma(12:28-12:29),UpperIdent(12:30-12:34),NoSpaceOpenRound(12:34-12:35),NamedUnderscore(12:35-12:40),CloseRound(12:40-12:41),CloseSquare(12:41-12:42),OpArrow(12:43-12:45),UpperIdent(12:46-12:50), LowerIdent(13:1-13:15),OpAssign(13:16-13:17),OpBar(13:18-13:19),LowerIdent(13:19-13:25),OpBar(13:25-13:26),KwMatch(13:27-13:32),LowerIdent(13:33-13:39),OpenCurly(13:40-13:41), -UpperIdent(14:5-14:7),NoSpaceOpenRound(14:7-14:8),Underscore(14:8-14:9),CloseRound(14:9-14:10),OpFatArrow(14:11-14:13),UpperIdent(14:14-14:18),NoSpaceDotUpperIdent(14:18-14:23), -UpperIdent(15:5-15:8),NoSpaceOpenRound(15:8-15:9),Underscore(15:9-15:10),CloseRound(15:10-15:11),OpFatArrow(15:12-15:14),UpperIdent(15:15-15:19),NoSpaceDotUpperIdent(15:19-15:25), +UpperIdent(14:5-14:8),NoSpaceOpenRound(14:8-14:9),Underscore(14:9-14:10),CloseRound(14:10-14:11),OpFatArrow(14:12-14:14),UpperIdent(14:15-14:19),NoSpaceDotUpperIdent(14:19-14:24), +UpperIdent(15:5-15:9),NoSpaceOpenRound(15:9-15:10),Underscore(15:10-15:11),CloseRound(15:11-15:12),OpFatArrow(15:13-15:15),UpperIdent(15:16-15:20),NoSpaceDotUpperIdent(15:20-15:26), CloseCurly(16:1-16:2), LowerIdent(18:1-18:6),OpAssign(18:7-18:8),OpBar(18:9-18:10),Underscore(18:10-18:11),OpBar(18:11-18:12),OpenCurly(18:13-18:14),CloseCurly(18:14-18:15), EndOfFile(19:1-19:1), @@ -125,24 +70,24 @@ EndOfFile(19:1-19:1), (ty @3.17-3.20 (name "Str"))) (ty @3.23-3.27 (name "None")))) (ty @3.32-3.35 (name "Str")))) - (s-decl @4.1-4.27 + (s-decl @4.1-4.28 (p-ident @4.1-4.8 (raw "process")) - (e-lambda @4.11-4.27 + (e-lambda @4.11-4.28 (args - (p-ident @4.12-4.17 (raw "maybe"))) - (e-string @4.19-4.27 - (e-string-part @4.20-4.26 (raw "result"))))) - (s-type-anno @6.1-6.58 (name "is_ok_ret_unqualified_bool") - (ty-fn @6.30-6.58 - (ty-tag-union @6.30-6.50 + (p-ident @4.12-4.18 (raw "_maybe"))) + (e-string @4.20-4.28 + (e-string-part @4.21-4.27 (raw "result"))))) + (s-type-anno @6.1-6.60 (name "is_ok_ret_unqualified_bool") + (ty-fn @6.30-6.60 + (ty-tag-union @6.30-6.52 (tags - (ty-apply @6.31-6.38 - (ty @6.31-6.33 (name "Ok")) - (underscore-ty-var @6.34-6.37 (raw "_ok"))) - (ty-apply @6.40-6.49 - (ty @6.40-6.43 (name "Err")) - (underscore-ty-var @6.44-6.48 (raw "_err"))))) - (ty @6.54-6.58 (name "Bool")))) + (ty-apply @6.31-6.39 + (ty @6.31-6.34 (name "Ok2")) + (underscore-ty-var @6.35-6.38 (raw "_ok"))) + (ty-apply @6.41-6.51 + (ty @6.41-6.45 (name "Err2")) + (underscore-ty-var @6.46-6.50 (raw "_err"))))) + (ty @6.56-6.60 (name "Bool")))) (s-decl @7.1-10.2 (p-ident @7.1-7.27 (raw "is_ok_ret_unqualified_bool")) (e-lambda @7.30-10.2 @@ -151,25 +96,25 @@ EndOfFile(19:1-19:1), (e-match (e-ident @7.45-7.51 (raw "result")) (branches - (branch @8.5-8.18 - (p-tag @8.5-8.10 (raw "Ok") + (branch @8.5-8.19 + (p-tag @8.5-8.11 (raw "Ok2") (p-underscore)) - (e-tag @8.14-8.18 (raw "True"))) - (branch @9.5-9.20 - (p-tag @9.5-9.11 (raw "Err") + (e-tag @8.15-8.19 (raw "True"))) + (branch @9.5-9.21 + (p-tag @9.5-9.12 (raw "Err2") (p-underscore)) - (e-tag @9.15-9.20 (raw "False"))))))) - (s-type-anno @12.1-12.48 (name "is_ok_ret_bool") - (ty-fn @12.18-12.48 - (ty-tag-union @12.18-12.40 + (e-tag @9.16-9.21 (raw "False"))))))) + (s-type-anno @12.1-12.50 (name "is_ok_ret_bool") + (ty-fn @12.18-12.50 + (ty-tag-union @12.18-12.42 (tags - (ty-apply @12.19-12.27 - (ty @12.19-12.21 (name "Ok")) - (underscore-ty-var @12.22-12.26 (raw "_ok2"))) - (ty-apply @12.29-12.39 - (ty @12.29-12.32 (name "Err")) - (underscore-ty-var @12.33-12.38 (raw "_err2"))))) - (ty @12.44-12.48 (name "Bool")))) + (ty-apply @12.19-12.28 + (ty @12.19-12.22 (name "Ok2")) + (underscore-ty-var @12.23-12.27 (raw "_ok2"))) + (ty-apply @12.30-12.41 + (ty @12.30-12.34 (name "Err2")) + (underscore-ty-var @12.35-12.40 (raw "_err2"))))) + (ty @12.46-12.50 (name "Bool")))) (s-decl @13.1-16.2 (p-ident @13.1-13.15 (raw "is_ok_ret_bool")) (e-lambda @13.18-16.2 @@ -178,14 +123,14 @@ EndOfFile(19:1-19:1), (e-match (e-ident @13.33-13.39 (raw "result")) (branches - (branch @14.5-14.23 - (p-tag @14.5-14.10 (raw "Ok") + (branch @14.5-14.24 + (p-tag @14.5-14.11 (raw "Ok2") (p-underscore)) - (e-tag @14.14-14.23 (raw "Bool.True"))) - (branch @15.5-15.25 - (p-tag @15.5-15.11 (raw "Err") + (e-tag @14.15-14.24 (raw "Bool.True"))) + (branch @15.5-15.26 + (p-tag @15.5-15.12 (raw "Err2") (p-underscore)) - (e-tag @15.15-15.25 (raw "Bool.False"))))))) + (e-tag @15.16-15.26 (raw "Bool.False"))))))) (s-decl @18.1-18.15 (p-ident @18.1-18.6 (raw "main!")) (e-lambda @18.9-18.15 @@ -198,18 +143,18 @@ EndOfFile(19:1-19:1), app [main!] { pf: platform "../basic-cli/main.roc" } process : [Some(Str), None] -> Str -process = |maybe| "result" +process = |_maybe| "result" -is_ok_ret_unqualified_bool : [Ok(_ok), Err(_err)] -> Bool +is_ok_ret_unqualified_bool : [Ok2(_ok), Err2(_err)] -> Bool is_ok_ret_unqualified_bool = |result| match result { - Ok(_) => True - Err(_) => False + Ok2(_) => True + Err2(_) => False } -is_ok_ret_bool : [Ok(_ok2), Err(_err2)] -> Bool +is_ok_ret_bool : [Ok2(_ok2), Err2(_err2)] -> Bool is_ok_ret_bool = |result| match result { - Ok(_) => Bool.True - Err(_) => Bool.False + Ok2(_) => Bool.True + Err2(_) => Bool.False } main! = |_| {} @@ -219,19 +164,19 @@ main! = |_| {} (can-ir (d-let (p-assign @4.1-4.8 (ident "process")) - (e-lambda @4.11-4.27 + (e-lambda @4.11-4.28 (args - (p-assign @4.12-4.17 (ident "maybe"))) - (e-string @4.19-4.27 - (e-literal @4.20-4.26 (string "result")))) + (p-assign @4.12-4.18 (ident "_maybe"))) + (e-string @4.20-4.28 + (e-literal @4.21-4.27 (string "result")))) (annotation @4.1-4.8 (declared-type (ty-fn @3.11-3.35 (effectful false) (ty-tag-union @3.11-3.28 - (ty-apply @3.12-3.21 (symbol "Some") - (ty @3.17-3.20 (name "Str"))) - (ty @3.23-3.27 (name "None"))) - (ty @3.32-3.35 (name "Str")))))) + (ty-tag-name @3.12-3.21 (name "Some") + (ty-lookup @3.17-3.20 (name "Str") (builtin))) + (ty-tag-name @3.23-3.27 (name "None"))) + (ty-lookup @3.32-3.35 (name "Str") (builtin)))))) (d-let (p-assign @7.1-7.27 (ident "is_ok_ret_unqualified_bool")) (e-lambda @7.30-10.2 @@ -246,28 +191,26 @@ main! = |_| {} (branch (patterns (pattern (degenerate false) - (p-nominal @8.5-8.10 - (p-applied-tag @8.5-8.10)))) + (p-applied-tag @8.5-8.11))) (value - (e-nominal @8.14-8.18 (nominal "Bool") - (e-tag @8.14-8.18 (name "True"))))) + (e-nominal @8.15-8.19 (nominal "Bool") + (e-tag @8.15-8.19 (name "True"))))) (branch (patterns (pattern (degenerate false) - (p-nominal @9.5-9.11 - (p-applied-tag @9.5-9.11)))) + (p-applied-tag @9.5-9.12))) (value - (e-nominal @9.15-9.20 (nominal "Bool") - (e-tag @9.15-9.20 (name "False"))))))))) + (e-nominal @9.16-9.21 (nominal "Bool") + (e-tag @9.16-9.21 (name "False"))))))))) (annotation @7.1-7.27 (declared-type - (ty-fn @6.30-6.58 (effectful false) - (ty-tag-union @6.30-6.50 - (ty-apply @6.31-6.38 (symbol "Ok") - (ty-var @6.34-6.37 (name "_ok"))) - (ty-apply @6.40-6.49 (symbol "Err") - (ty-var @6.44-6.48 (name "_err")))) - (ty @6.54-6.58 (name "Bool")))))) + (ty-fn @6.30-6.60 (effectful false) + (ty-tag-union @6.30-6.52 + (ty-tag-name @6.31-6.39 (name "Ok2") + (ty-rigid-var @6.35-6.38 (name "_ok"))) + (ty-tag-name @6.41-6.51 (name "Err2") + (ty-rigid-var @6.46-6.50 (name "_err")))) + (ty-lookup @6.56-6.60 (name "Bool") (local)))))) (d-let (p-assign @13.1-13.15 (ident "is_ok_ret_bool")) (e-lambda @13.18-16.2 @@ -282,28 +225,26 @@ main! = |_| {} (branch (patterns (pattern (degenerate false) - (p-nominal @14.5-14.10 - (p-applied-tag @14.5-14.10)))) + (p-applied-tag @14.5-14.11))) (value - (e-nominal @14.14-14.23 (nominal "Bool") - (e-tag @14.14-14.23 (name "True"))))) + (e-nominal @14.15-14.24 (nominal "Bool") + (e-tag @14.15-14.24 (name "True"))))) (branch (patterns (pattern (degenerate false) - (p-nominal @15.5-15.11 - (p-applied-tag @15.5-15.11)))) + (p-applied-tag @15.5-15.12))) (value - (e-nominal @15.15-15.25 (nominal "Bool") - (e-tag @15.15-15.25 (name "False"))))))))) + (e-nominal @15.16-15.26 (nominal "Bool") + (e-tag @15.16-15.26 (name "False"))))))))) (annotation @13.1-13.15 (declared-type - (ty-fn @12.18-12.48 (effectful false) - (ty-tag-union @12.18-12.40 - (ty-apply @12.19-12.27 (symbol "Ok") - (ty-var @12.22-12.26 (name "_ok2"))) - (ty-apply @12.29-12.39 (symbol "Err") - (ty-var @12.33-12.38 (name "_err2")))) - (ty @12.44-12.48 (name "Bool")))))) + (ty-fn @12.18-12.50 (effectful false) + (ty-tag-union @12.18-12.42 + (ty-tag-name @12.19-12.28 (name "Ok2") + (ty-rigid-var @12.23-12.27 (name "_ok2"))) + (ty-tag-name @12.30-12.41 (name "Err2") + (ty-rigid-var @12.35-12.40 (name "_err2")))) + (ty-lookup @12.46-12.50 (name "Bool") (local)))))) (d-let (p-assign @18.1-18.6 (ident "main!")) (e-lambda @18.9-18.15 @@ -316,12 +257,12 @@ main! = |_| {} (inferred-types (defs (patt @4.1-4.8 (type "[None, Some(Str)] -> Str")) - (patt @7.1-7.27 (type "[Err(_err), Ok(_ok)] -> Bool")) - (patt @13.1-13.15 (type "[Err(_err2), Ok(_ok2)] -> Bool")) + (patt @7.1-7.27 (type "[Err2(_err), Ok2(_ok)] -> Bool")) + (patt @13.1-13.15 (type "[Err2(_err2), Ok2(_ok2)] -> Bool")) (patt @18.1-18.6 (type "_arg -> {}"))) (expressions - (expr @4.11-4.27 (type "[None, Some(Str)] -> Str")) - (expr @7.30-10.2 (type "[Err(_err), Ok(_ok)] -> Bool")) - (expr @13.18-16.2 (type "[Err(_err2), Ok(_ok2)] -> Bool")) + (expr @4.11-4.28 (type "[None, Some(Str)] -> Str")) + (expr @7.30-10.2 (type "[Err2(_err), Ok2(_ok)] -> Bool")) + (expr @13.18-16.2 (type "[Err2(_err2), Ok2(_ok2)] -> Bool")) (expr @18.9-18.15 (type "_arg -> {}")))) ~~~ diff --git a/test/snapshots/type_tag_union_complex.md b/test/snapshots/type_tag_union_complex.md index 6d81d4ce39..daa8834c35 100644 --- a/test/snapshots/type_tag_union_complex.md +++ b/test/snapshots/type_tag_union_complex.md @@ -182,8 +182,8 @@ NO CHANGE (annotation @18.1-18.14 (declared-type (ty-fn @17.17-17.30 (effectful false) - (ty @17.17-17.23 (name "Result")) - (ty @17.27-17.30 (name "Str")))))) + (ty-lookup @17.17-17.23 (name "Result") (local)) + (ty-lookup @17.27-17.30 (name "Str") (builtin)))))) (d-let (p-assign @22.1-22.15 (ident "handleResponse")) (e-lambda @22.18-22.39 @@ -194,8 +194,8 @@ NO CHANGE (annotation @22.1-22.15 (declared-type (ty-fn @21.18-21.33 (effectful false) - (ty @21.18-21.26 (name "Response")) - (ty @21.30-21.33 (name "Str")))))) + (ty-lookup @21.18-21.26 (name "Response") (local)) + (ty-lookup @21.30-21.33 (name "Str") (builtin)))))) (d-let (p-assign @24.1-24.6 (ident "main!")) (e-lambda @24.9-24.15 @@ -205,47 +205,47 @@ NO CHANGE (s-alias-decl @4.1-4.37 (ty-header @4.1-4.7 (name "Status")) (ty-tag-union @4.10-4.37 - (ty @4.11-4.18 (name "Loading")) - (ty @4.20-4.28 (name "Complete")) - (ty @4.30-4.36 (name "Failed")))) + (ty-tag-name @4.11-4.18 (name "Loading")) + (ty-tag-name @4.20-4.28 (name "Complete")) + (ty-tag-name @4.30-4.36 (name "Failed")))) (s-alias-decl @7.1-7.55 (ty-header @7.1-7.7 (name "Result")) (ty-tag-union @7.10-7.55 - (ty-apply @7.11-7.23 (symbol "Success") - (ty @7.19-7.22 (name "Str"))) - (ty-apply @7.25-7.35 (symbol "Error") - (ty @7.31-7.34 (name "Str"))) - (ty-apply @7.37-7.54 (symbol "Warning") - (ty @7.45-7.48 (name "Str")) - (ty @7.50-7.53 (name "I32"))))) + (ty-tag-name @7.11-7.23 (name "Success") + (ty-lookup @7.19-7.22 (name "Str") (builtin))) + (ty-tag-name @7.25-7.35 (name "Error") + (ty-lookup @7.31-7.34 (name "Str") (builtin))) + (ty-tag-name @7.37-7.54 (name "Warning") + (ty-lookup @7.45-7.48 (name "Str") (builtin)) + (ty-lookup @7.50-7.53 (name "I32") (builtin))))) (s-alias-decl @10.1-10.50 (ty-header @10.1-10.9 (name "Response")) (ty-tag-union @10.12-10.50 - (ty-apply @10.13-10.23 (symbol "Ok") - (ty @10.16-10.22 (name "Result"))) - (ty @10.25-10.37 (name "NetworkError")) - (ty @10.39-10.49 (name "ParseError")))) + (ty-tag-name @10.13-10.23 (name "Ok") + (ty-lookup @10.16-10.22 (name "Result") (local))) + (ty-tag-name @10.25-10.37 (name "NetworkError")) + (ty-tag-name @10.39-10.49 (name "ParseError")))) (s-alias-decl @13.1-13.52 (ty-header @13.1-13.10 (name "UserState")) (ty-tag-union @13.13-13.52 - (ty-apply @13.14-13.25 (symbol "Active") - (ty @13.21-13.24 (name "Str"))) - (ty @13.27-13.35 (name "Inactive")) - (ty-apply @13.37-13.51 (symbol "Suspended") - (ty @13.47-13.50 (name "Str"))))) + (ty-tag-name @13.14-13.25 (name "Active") + (ty-lookup @13.21-13.24 (name "Str") (builtin))) + (ty-tag-name @13.27-13.35 (name "Inactive")) + (ty-tag-name @13.37-13.51 (name "Suspended") + (ty-lookup @13.47-13.50 (name "Str") (builtin))))) (s-alias-decl @14.1-14.58 (ty-header @14.1-14.16 (name "ConnectionState")) (ty-tag-union @14.19-14.58 - (ty @14.20-14.26 (name "Active")) - (ty @14.28-14.40 (name "Disconnected")) - (ty-apply @14.42-14.57 (symbol "Connecting") - (ty @14.53-14.56 (name "Str")))))) + (ty-tag-name @14.20-14.26 (name "Active")) + (ty-tag-name @14.28-14.40 (name "Disconnected")) + (ty-tag-name @14.42-14.57 (name "Connecting") + (ty-lookup @14.53-14.56 (name "Str") (builtin)))))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @18.1-18.14 (type "Result -> Str")) + (patt @18.1-18.14 (type "Result(ok, err) -> Str")) (patt @22.1-22.15 (type "Response -> Str")) (patt @24.1-24.6 (type "_arg -> {}"))) (type_decls @@ -260,7 +260,7 @@ NO CHANGE (alias @14.1-14.58 (type "ConnectionState") (ty-header @14.1-14.16 (name "ConnectionState")))) (expressions - (expr @18.17-18.38 (type "Result -> Str")) + (expr @18.17-18.38 (type "Result(ok, err) -> Str")) (expr @22.18-22.39 (type "Response -> Str")) (expr @24.9-24.15 (type "_arg -> {}")))) ~~~ diff --git a/test/snapshots/type_two_variables.md b/test/snapshots/type_two_variables.md index fceebe6b0f..256eff3a7e 100644 --- a/test/snapshots/type_two_variables.md +++ b/test/snapshots/type_two_variables.md @@ -89,11 +89,11 @@ NO CHANGE (declared-type (ty-fn @3.8-3.24 (effectful false) (ty-tuple @3.8-3.14 - (ty-var @3.9-3.10 (name "a")) - (ty-var @3.12-3.13 (name "b"))) + (ty-rigid-var @3.9-3.10 (name "a")) + (ty-rigid-var @3.12-3.13 (name "b"))) (ty-tuple @3.18-3.24 - (ty-var @3.19-3.20 (name "b")) - (ty-var @3.22-3.23 (name "a"))))))) + (ty-rigid-var-lookup (ty-rigid-var @3.12-3.13 (name "b"))) + (ty-rigid-var-lookup (ty-rigid-var @3.9-3.10 (name "a")))))))) (d-let (p-assign @6.1-6.6 (ident "main!")) (e-lambda @6.9-6.15 diff --git a/test/snapshots/type_undeclared_usage.md b/test/snapshots/type_undeclared_usage.md index 316d9b6bb3..46c5e5b113 100644 --- a/test/snapshots/type_undeclared_usage.md +++ b/test/snapshots/type_undeclared_usage.md @@ -1,12 +1,10 @@ # META ~~~ini description=Undeclared type usage should produce error -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [MyType, processValue] - MyType : UnknownType processValue : UndeclaredResult -> Str @@ -17,16 +15,16 @@ processValue = |value| { AnotherType : SomeModule.MissingType ~~~ # EXPECTED -UNDECLARED TYPE - type_undeclared_usage.md:3:10:3:21 -MODULE NOT IMPORTED - type_undeclared_usage.md:10:15:10:37 -UNDECLARED TYPE - type_undeclared_usage.md:5:16:5:32 -UNUSED VARIABLE - type_undeclared_usage.md:6:17:6:22 +UNDECLARED TYPE - type_undeclared_usage.md:1:10:1:21 +MODULE NOT IMPORTED - type_undeclared_usage.md:8:15:8:37 +UNDECLARED TYPE - type_undeclared_usage.md:3:16:3:32 +UNUSED VARIABLE - type_undeclared_usage.md:4:17:4:22 # PROBLEMS **UNDECLARED TYPE** The type _UnknownType_ is not declared in this scope. This type is referenced here: -**type_undeclared_usage.md:3:10:3:21:** +**type_undeclared_usage.md:1:10:1:21:** ```roc MyType : UnknownType ``` @@ -37,7 +35,7 @@ MyType : UnknownType There is no module with the name `SomeModule` imported into this Roc file. You're attempting to use this module here: -**type_undeclared_usage.md:10:15:10:37:** +**type_undeclared_usage.md:8:15:8:37:** ```roc AnotherType : SomeModule.MissingType ``` @@ -48,7 +46,7 @@ AnotherType : SomeModule.MissingType The type _UndeclaredResult_ is not declared in this scope. This type is referenced here: -**type_undeclared_usage.md:5:16:5:32:** +**type_undeclared_usage.md:3:16:3:32:** ```roc processValue : UndeclaredResult -> Str ``` @@ -60,7 +58,7 @@ Variable `value` is not used anywhere in your code. If you don't need this variable, prefix it with an underscore like `_value` to suppress this warning. The unused variable is declared here: -**type_undeclared_usage.md:6:17:6:22:** +**type_undeclared_usage.md:4:17:4:22:** ```roc processValue = |value| { ``` @@ -69,50 +67,43 @@ processValue = |value| { # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:15),Comma(1:15-1:16),LowerIdent(1:17-1:29),CloseSquare(1:29-1:30), -UpperIdent(3:1-3:7),OpColon(3:8-3:9),UpperIdent(3:10-3:21), -LowerIdent(5:1-5:13),OpColon(5:14-5:15),UpperIdent(5:16-5:32),OpArrow(5:33-5:35),UpperIdent(5:36-5:39), -LowerIdent(6:1-6:13),OpAssign(6:14-6:15),OpBar(6:16-6:17),LowerIdent(6:17-6:22),OpBar(6:22-6:23),OpenCurly(6:24-6:25), -StringStart(7:5-7:6),StringPart(7:6-7:15),StringEnd(7:15-7:16), -CloseCurly(8:1-8:2), -UpperIdent(10:1-10:12),OpColon(10:13-10:14),UpperIdent(10:15-10:25),NoSpaceDotUpperIdent(10:25-10:37), -EndOfFile(11:1-11:1), +UpperIdent(1:1-1:7),OpColon(1:8-1:9),UpperIdent(1:10-1:21), +LowerIdent(3:1-3:13),OpColon(3:14-3:15),UpperIdent(3:16-3:32),OpArrow(3:33-3:35),UpperIdent(3:36-3:39), +LowerIdent(4:1-4:13),OpAssign(4:14-4:15),OpBar(4:16-4:17),LowerIdent(4:17-4:22),OpBar(4:22-4:23),OpenCurly(4:24-4:25), +StringStart(5:5-5:6),StringPart(5:6-5:15),StringEnd(5:15-5:16), +CloseCurly(6:1-6:2), +UpperIdent(8:1-8:12),OpColon(8:13-8:14),UpperIdent(8:15-8:25),NoSpaceDotUpperIdent(8:25-8:37), +EndOfFile(9:1-9:1), ~~~ # PARSE ~~~clojure -(file @1.1-10.37 - (module @1.1-1.30 - (exposes @1.8-1.30 - (exposed-upper-ident @1.9-1.15 (text "MyType")) - (exposed-lower-ident @1.17-1.29 - (text "processValue")))) +(file @1.1-8.37 + (type-module @1.1-1.7) (statements - (s-type-decl @3.1-3.21 - (header @3.1-3.7 (name "MyType") + (s-type-decl @1.1-1.21 + (header @1.1-1.7 (name "MyType") (args)) - (ty @3.10-3.21 (name "UnknownType"))) - (s-type-anno @5.1-5.39 (name "processValue") - (ty-fn @5.16-5.39 - (ty @5.16-5.32 (name "UndeclaredResult")) - (ty @5.36-5.39 (name "Str")))) - (s-decl @6.1-8.2 - (p-ident @6.1-6.13 (raw "processValue")) - (e-lambda @6.16-8.2 + (ty @1.10-1.21 (name "UnknownType"))) + (s-type-anno @3.1-3.39 (name "processValue") + (ty-fn @3.16-3.39 + (ty @3.16-3.32 (name "UndeclaredResult")) + (ty @3.36-3.39 (name "Str")))) + (s-decl @4.1-6.2 + (p-ident @4.1-4.13 (raw "processValue")) + (e-lambda @4.16-6.2 (args - (p-ident @6.17-6.22 (raw "value"))) - (e-block @6.24-8.2 + (p-ident @4.17-4.22 (raw "value"))) + (e-block @4.24-6.2 (statements - (e-string @7.5-7.16 - (e-string-part @7.6-7.15 (raw "processed"))))))) - (s-type-decl @10.1-10.37 - (header @10.1-10.12 (name "AnotherType") + (e-string @5.5-5.16 + (e-string-part @5.6-5.15 (raw "processed"))))))) + (s-type-decl @8.1-8.37 + (header @8.1-8.12 (name "AnotherType") (args)) - (ty @10.15-10.37 (name "SomeModule.MissingType"))))) + (ty @8.15-8.37 (name "SomeModule.MissingType"))))) ~~~ # FORMATTED ~~~roc -module [MyType, processValue] - MyType : UnknownType processValue : UndeclaredResult -> Str @@ -126,35 +117,35 @@ AnotherType : SomeModule.MissingType ~~~clojure (can-ir (d-let - (p-assign @6.1-6.13 (ident "processValue")) - (e-lambda @6.16-8.2 + (p-assign @4.1-4.13 (ident "processValue")) + (e-lambda @4.16-6.2 (args - (p-assign @6.17-6.22 (ident "value"))) - (e-block @6.24-8.2 - (e-string @7.5-7.16 - (e-literal @7.6-7.15 (string "processed"))))) - (annotation @6.1-6.13 + (p-assign @4.17-4.22 (ident "value"))) + (e-block @4.24-6.2 + (e-string @5.5-5.16 + (e-literal @5.6-5.15 (string "processed"))))) + (annotation @4.1-4.13 (declared-type - (ty-fn @5.16-5.39 (effectful false) - (ty @5.16-5.32 (name "UndeclaredResult")) - (ty @5.36-5.39 (name "Str")))))) - (s-alias-decl @3.1-3.21 - (ty-header @3.1-3.7 (name "MyType")) - (ty @3.10-3.21 (name "UnknownType"))) - (s-alias-decl @10.1-10.37 - (ty-header @10.1-10.12 (name "AnotherType")) - (ty-malformed @10.15-10.37))) + (ty-fn @3.16-3.39 (effectful false) + (ty-malformed @3.16-3.32) + (ty-lookup @3.36-3.39 (name "Str") (builtin)))))) + (s-alias-decl @1.1-1.21 + (ty-header @1.1-1.7 (name "MyType")) + (ty-malformed @1.10-1.21)) + (s-alias-decl @8.1-8.37 + (ty-header @8.1-8.12 (name "AnotherType")) + (ty-malformed @8.15-8.37))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @6.1-6.13 (type "Error -> Str"))) + (patt @4.1-4.13 (type "Error -> Str"))) (type_decls - (alias @3.1-3.21 (type "Error") - (ty-header @3.1-3.7 (name "MyType"))) - (alias @10.1-10.37 (type "Error") - (ty-header @10.1-10.12 (name "AnotherType")))) + (alias @1.1-1.21 (type "MyType") + (ty-header @1.1-1.7 (name "MyType"))) + (alias @8.1-8.37 (type "AnotherType") + (ty-header @8.1-8.12 (name "AnotherType")))) (expressions - (expr @6.16-8.2 (type "Error -> Str")))) + (expr @4.16-6.2 (type "Error -> Str")))) ~~~ diff --git a/test/snapshots/type_var_annotation_body_connection.md b/test/snapshots/type_var_annotation_body_connection.md index 4671982e8e..b8176e3246 100644 --- a/test/snapshots/type_var_annotation_body_connection.md +++ b/test/snapshots/type_var_annotation_body_connection.md @@ -17,22 +17,9 @@ identity = |x| { main! = |_| {} ~~~ # EXPECTED -TYPE MISMATCH - type_var_annotation_body_connection.md:6:13:6:14 +NIL # PROBLEMS -**TYPE MISMATCH** -This expression is used in an unexpected way: -**type_var_annotation_body_connection.md:6:13:6:14:** -```roc - thing = x # refers to the value from the function parameter -``` - ^ - -The type annotation says it should have the type: - _a_ - -But here it's being used as: - _a_ - +NIL # TOKENS ~~~zig KwApp(1:1-1:4),OpenSquare(1:5-1:6),LowerIdent(1:6-1:11),CloseSquare(1:11-1:12),OpenCurly(1:13-1:14),LowerIdent(1:15-1:17),OpColon(1:17-1:18),KwPlatform(1:19-1:27),StringStart(1:28-1:29),StringPart(1:29-1:50),StringEnd(1:50-1:51),CloseCurly(1:52-1:53), @@ -106,8 +93,6 @@ main! = |_| {} (args (p-assign @4.13-4.14 (ident "x"))) (e-block @4.16-8.2 - (s-type-anno @5.5-5.14 (name "thing") - (ty-var @5.13-5.14 (name "a"))) (s-let @6.5-6.14 (p-assign @6.5-6.10 (ident "thing")) (e-lookup-local @6.13-6.14 @@ -117,8 +102,8 @@ main! = |_| {} (annotation @4.1-4.9 (declared-type (ty-fn @3.12-3.18 (effectful false) - (ty-var @3.12-3.13 (name "a")) - (ty-var @3.17-3.18 (name "a")))))) + (ty-rigid-var @3.12-3.13 (name "a")) + (ty-rigid-var-lookup (ty-rigid-var @3.12-3.13 (name "a"))))))) (d-let (p-assign @10.1-10.6 (ident "main!")) (e-lambda @10.9-10.15 @@ -130,9 +115,9 @@ main! = |_| {} ~~~clojure (inferred-types (defs - (patt @4.1-4.9 (type "Error -> Error")) + (patt @4.1-4.9 (type "a -> a")) (patt @10.1-10.6 (type "_arg -> {}"))) (expressions - (expr @4.12-8.2 (type "Error -> Error")) + (expr @4.12-8.2 (type "a -> a")) (expr @10.9-10.15 (type "_arg -> {}")))) ~~~ diff --git a/test/snapshots/type_var_basic.md b/test/snapshots/type_var_basic.md index c2eadcba1e..215c6fa48d 100644 --- a/test/snapshots/type_var_basic.md +++ b/test/snapshots/type_var_basic.md @@ -74,8 +74,8 @@ NO CHANGE (annotation @5.1-5.9 (declared-type (ty-fn @4.12-4.18 (effectful false) - (ty-var @4.12-4.13 (name "a")) - (ty-var @4.17-4.18 (name "a")))))) + (ty-rigid-var @4.12-4.13 (name "a")) + (ty-rigid-var-lookup (ty-rigid-var @4.12-4.13 (name "a"))))))) (d-let (p-assign @7.1-7.6 (ident "main!")) (e-lambda @7.9-7.15 diff --git a/test/snapshots/type_var_collision_simple.md b/test/snapshots/type_var_collision_simple.md index f40b33a0a6..d265ac6ec3 100644 --- a/test/snapshots/type_var_collision_simple.md +++ b/test/snapshots/type_var_collision_simple.md @@ -167,13 +167,13 @@ main! = |_| { (can-ir (d-let (p-assign @4.1-4.2 (ident "a")) - (e-int @4.5-4.6 (value "1"))) + (e-num @4.5-4.6 (value "1"))) (d-let (p-assign @5.1-5.2 (ident "b")) - (e-int @5.5-5.6 (value "2"))) + (e-num @5.5-5.6 (value "2"))) (d-let (p-assign @6.1-6.2 (ident "c")) - (e-int @6.5-6.6 (value "3"))) + (e-num @6.5-6.6 (value "3"))) (d-let (p-assign @9.1-9.9 (ident "identity")) (e-lambda @9.12-9.17 @@ -205,10 +205,10 @@ main! = |_| { (e-closure @17.9-23.2 (captures (capture @9.1-9.9 (ident "identity")) - (capture @4.1-4.2 (ident "a")) - (capture @5.1-5.2 (ident "b")) (capture @12.1-12.10 (ident "identity2")) (capture @15.1-15.5 (ident "pair")) + (capture @5.1-5.2 (ident "b")) + (capture @4.1-4.2 (ident "a")) (capture @6.1-6.2 (ident "c"))) (e-lambda @17.9-23.2 (args @@ -219,7 +219,7 @@ main! = |_| { (e-call @18.15-18.27 (e-lookup-local @18.15-18.23 (p-assign @9.1-9.9 (ident "identity"))) - (e-int @18.24-18.26 (value "42")))) + (e-num @18.24-18.26 (value "42")))) (s-let @19.5-19.33 (p-assign @19.5-19.12 (ident "result2")) (e-call @19.15-19.33 @@ -252,16 +252,16 @@ main! = |_| { (patt @4.1-4.2 (type "Num(_size)")) (patt @5.1-5.2 (type "Num(_size)")) (patt @6.1-6.2 (type "Num(_size)")) - (patt @9.1-9.9 (type "_arg -> _ret")) - (patt @12.1-12.10 (type "_arg -> _ret")) - (patt @15.1-15.5 (type "_arg, _arg2 -> (_field, _field2)")) + (patt @9.1-9.9 (type "d -> d")) + (patt @12.1-12.10 (type "d -> d")) + (patt @15.1-15.5 (type "d, e -> (d, e)")) (patt @17.1-17.6 (type "_arg -> Num(_size)"))) (expressions (expr @4.5-4.6 (type "Num(_size)")) (expr @5.5-5.6 (type "Num(_size)")) (expr @6.5-6.6 (type "Num(_size)")) - (expr @9.12-9.17 (type "_arg -> _ret")) - (expr @12.13-12.18 (type "_arg -> _ret")) - (expr @15.8-15.39 (type "_arg, _arg2 -> (_field, _field2)")) + (expr @9.12-9.17 (type "d -> d")) + (expr @12.13-12.18 (type "d -> d")) + (expr @15.8-15.39 (type "d, e -> (d, e)")) (expr @17.9-23.2 (type "_arg -> Num(_size)")))) ~~~ diff --git a/test/snapshots/type_var_multiple.md b/test/snapshots/type_var_multiple.md index a9e5040be5..552c65c75d 100644 --- a/test/snapshots/type_var_multiple.md +++ b/test/snapshots/type_var_multiple.md @@ -115,11 +115,11 @@ main! = |_| {} (declared-type (ty-fn @4.8-4.24 (effectful false) (ty-tuple @4.8-4.14 - (ty-var @4.9-4.10 (name "a")) - (ty-var @4.12-4.13 (name "b"))) + (ty-rigid-var @4.9-4.10 (name "a")) + (ty-rigid-var @4.12-4.13 (name "b"))) (ty-tuple @4.18-4.24 - (ty-var @4.19-4.20 (name "b")) - (ty-var @4.22-4.23 (name "a"))))))) + (ty-rigid-var-lookup (ty-rigid-var @4.12-4.13 (name "b"))) + (ty-rigid-var-lookup (ty-rigid-var @4.9-4.10 (name "a")))))))) (d-let (p-assign @10.1-10.6 (ident "main!")) (e-lambda @10.9-10.15 diff --git a/test/snapshots/type_var_name_avoids_collision.md b/test/snapshots/type_var_name_avoids_collision.md index 0ade149544..9e04e18b5a 100644 --- a/test/snapshots/type_var_name_avoids_collision.md +++ b/test/snapshots/type_var_name_avoids_collision.md @@ -402,7 +402,7 @@ main! = |_| { (can-ir (d-let (p-assign @4.1-4.2 (ident "a")) - (e-int @4.5-4.7 (value "42"))) + (e-num @4.5-4.7 (value "42"))) (d-let (p-assign @7.1-7.9 (ident "identity")) (e-lambda @7.12-7.17 @@ -446,67 +446,67 @@ main! = |_| { (p-assign @20.19-20.25 (ident "second"))))))) (d-let (p-assign @23.1-23.2 (ident "f")) - (e-int @23.5-23.6 (value "1"))) + (e-num @23.5-23.6 (value "1"))) (d-let (p-assign @24.1-24.2 (ident "g")) - (e-int @24.5-24.6 (value "2"))) + (e-num @24.5-24.6 (value "2"))) (d-let (p-assign @25.1-25.2 (ident "h")) - (e-int @25.5-25.6 (value "3"))) + (e-num @25.5-25.6 (value "3"))) (d-let (p-assign @26.1-26.2 (ident "i")) - (e-int @26.5-26.6 (value "4"))) + (e-num @26.5-26.6 (value "4"))) (d-let (p-assign @27.1-27.2 (ident "j")) - (e-int @27.5-27.6 (value "5"))) + (e-num @27.5-27.6 (value "5"))) (d-let (p-assign @28.1-28.2 (ident "k")) - (e-int @28.5-28.6 (value "6"))) + (e-num @28.5-28.6 (value "6"))) (d-let (p-assign @29.1-29.2 (ident "l")) - (e-int @29.5-29.6 (value "7"))) + (e-num @29.5-29.6 (value "7"))) (d-let (p-assign @30.1-30.2 (ident "m")) - (e-int @30.5-30.6 (value "8"))) + (e-num @30.5-30.6 (value "8"))) (d-let (p-assign @31.1-31.2 (ident "n")) - (e-int @31.5-31.6 (value "9"))) + (e-num @31.5-31.6 (value "9"))) (d-let (p-assign @32.1-32.2 (ident "o")) - (e-int @32.5-32.7 (value "10"))) + (e-num @32.5-32.7 (value "10"))) (d-let (p-assign @33.1-33.2 (ident "p")) - (e-int @33.5-33.7 (value "11"))) + (e-num @33.5-33.7 (value "11"))) (d-let (p-assign @34.1-34.2 (ident "q")) - (e-int @34.5-34.7 (value "12"))) + (e-num @34.5-34.7 (value "12"))) (d-let (p-assign @35.1-35.2 (ident "r")) - (e-int @35.5-35.7 (value "13"))) + (e-num @35.5-35.7 (value "13"))) (d-let (p-assign @36.1-36.2 (ident "s")) - (e-int @36.5-36.7 (value "14"))) + (e-num @36.5-36.7 (value "14"))) (d-let (p-assign @37.1-37.2 (ident "t")) - (e-int @37.5-37.7 (value "15"))) + (e-num @37.5-37.7 (value "15"))) (d-let (p-assign @38.1-38.2 (ident "u")) - (e-int @38.5-38.7 (value "16"))) + (e-num @38.5-38.7 (value "16"))) (d-let (p-assign @39.1-39.2 (ident "v")) - (e-int @39.5-39.7 (value "17"))) + (e-num @39.5-39.7 (value "17"))) (d-let (p-assign @40.1-40.2 (ident "w")) - (e-int @40.5-40.7 (value "18"))) + (e-num @40.5-40.7 (value "18"))) (d-let (p-assign @41.1-41.2 (ident "x")) - (e-int @41.5-41.7 (value "19"))) + (e-num @41.5-41.7 (value "19"))) (d-let (p-assign @42.1-42.2 (ident "y")) - (e-int @42.5-42.7 (value "20"))) + (e-num @42.5-42.7 (value "20"))) (d-let (p-assign @43.1-43.2 (ident "z")) - (e-int @43.5-43.7 (value "21"))) + (e-num @43.5-43.7 (value "21"))) (d-let (p-assign @46.1-46.19 (ident "yetAnotherIdentity")) (e-lambda @46.22-46.31 @@ -516,10 +516,10 @@ main! = |_| { (p-assign @46.23-46.26 (ident "arg"))))) (d-let (p-assign @49.1-49.3 (ident "aa")) - (e-int @49.6-49.9 (value "100"))) + (e-num @49.6-49.9 (value "100"))) (d-let (p-assign @50.1-50.3 (ident "ab")) - (e-int @50.6-50.9 (value "200"))) + (e-num @50.6-50.9 (value "200"))) (d-let (p-assign @53.1-53.14 (ident "finalIdentity")) (e-lambda @53.17-53.30 @@ -532,12 +532,12 @@ main! = |_| { (e-closure @55.9-65.2 (captures (capture @16.1-16.16 (ident "anotherIdentity")) + (capture @23.1-23.2 (ident "f")) + (capture @4.1-4.2 (ident "a")) (capture @53.1-53.14 (ident "finalIdentity")) - (capture @46.1-46.19 (ident "yetAnotherIdentity")) (capture @7.1-7.9 (ident "identity")) (capture @20.1-20.8 (ident "combine")) - (capture @4.1-4.2 (ident "a")) - (capture @23.1-23.2 (ident "f"))) + (capture @46.1-46.19 (ident "yetAnotherIdentity"))) (e-lambda @55.9-65.2 (args (p-underscore @55.10-55.11)) @@ -547,7 +547,7 @@ main! = |_| { (e-call @57.15-57.28 (e-lookup-local @57.15-57.23 (p-assign @7.1-7.9 (ident "identity"))) - (e-int @57.24-57.27 (value "123")))) + (e-num @57.24-57.27 (value "123")))) (s-let @58.5-58.38 (p-assign @58.5-58.12 (ident "result2")) (e-call @58.15-58.38 @@ -588,13 +588,13 @@ main! = |_| { (inferred-types (defs (patt @4.1-4.2 (type "Num(_size)")) - (patt @7.1-7.9 (type "_arg2 -> _ret")) + (patt @7.1-7.9 (type "ac -> ac")) (patt @10.1-10.2 (type "Str")) - (patt @11.1-11.2 (type "Frac(_size)")) + (patt @11.1-11.2 (type "Num(Frac(_size))")) (patt @12.1-12.2 (type "Bool")) (patt @13.1-13.2 (type "Bool")) - (patt @16.1-16.16 (type "_arg2 -> _ret")) - (patt @20.1-20.8 (type "_arg2, _arg3 -> (_field, _field2)")) + (patt @16.1-16.16 (type "ac -> ac")) + (patt @20.1-20.8 (type "ac, ad -> (ac, ad)")) (patt @23.1-23.2 (type "Num(_size)")) (patt @24.1-24.2 (type "Num(_size)")) (patt @25.1-25.2 (type "Num(_size)")) @@ -616,20 +616,20 @@ main! = |_| { (patt @41.1-41.2 (type "Num(_size)")) (patt @42.1-42.2 (type "Num(_size)")) (patt @43.1-43.2 (type "Num(_size)")) - (patt @46.1-46.19 (type "_arg2 -> _ret")) + (patt @46.1-46.19 (type "ac -> ac")) (patt @49.1-49.3 (type "Num(_size)")) (patt @50.1-50.3 (type "Num(_size)")) - (patt @53.1-53.14 (type "_arg2 -> _ret")) + (patt @53.1-53.14 (type "ac -> ac")) (patt @55.1-55.6 (type "_arg2 -> Num(_size)"))) (expressions (expr @4.5-4.7 (type "Num(_size)")) - (expr @7.12-7.17 (type "_arg2 -> _ret")) + (expr @7.12-7.17 (type "ac -> ac")) (expr @10.5-10.12 (type "Str")) - (expr @11.5-11.9 (type "Frac(_size)")) + (expr @11.5-11.9 (type "Num(Frac(_size))")) (expr @12.5-12.9 (type "Bool")) (expr @13.5-13.10 (type "Bool")) - (expr @16.19-16.24 (type "_arg2 -> _ret")) - (expr @20.11-20.42 (type "_arg2, _arg3 -> (_field, _field2)")) + (expr @16.19-16.24 (type "ac -> ac")) + (expr @20.11-20.42 (type "ac, ad -> (ac, ad)")) (expr @23.5-23.6 (type "Num(_size)")) (expr @24.5-24.6 (type "Num(_size)")) (expr @25.5-25.6 (type "Num(_size)")) @@ -651,9 +651,9 @@ main! = |_| { (expr @41.5-41.7 (type "Num(_size)")) (expr @42.5-42.7 (type "Num(_size)")) (expr @43.5-43.7 (type "Num(_size)")) - (expr @46.22-46.31 (type "_arg2 -> _ret")) + (expr @46.22-46.31 (type "ac -> ac")) (expr @49.6-49.9 (type "Num(_size)")) (expr @50.6-50.9 (type "Num(_size)")) - (expr @53.17-53.30 (type "_arg2 -> _ret")) + (expr @53.17-53.30 (type "ac -> ac")) (expr @55.9-65.2 (type "_arg2 -> Num(_size)")))) ~~~ diff --git a/test/snapshots/type_var_namespace.md b/test/snapshots/type_var_namespace.md index 1063fc12f7..3ff9ef6666 100644 --- a/test/snapshots/type_var_namespace.md +++ b/test/snapshots/type_var_namespace.md @@ -27,7 +27,6 @@ UNEXPECTED TOKEN IN EXPRESSION - type_var_namespace.md:11:31:11:33 UNDEFINED VARIABLE - type_var_namespace.md:11:14:11:24 UNRECOGNIZED SYNTAX - type_var_namespace.md:11:31:11:33 UNDEFINED VARIABLE - type_var_namespace.md:11:34:11:52 -TYPE MISMATCH - type_var_namespace.md:5:18:14:2 # PROBLEMS **UNEXPECTED TOKEN IN EXPRESSION** The token **|>** is not expected in an expression. @@ -73,28 +72,6 @@ Is there an `import` or `exposing` missing up-top? ^^^^^^^^^^^^^^^^^^ -**TYPE MISMATCH** -This expression is used in an unexpected way: -**type_var_namespace.md:5:18:14:2:** -```roc -process = |list| { - # value identifier named 'elem' is allowed - different namespace from type variable - elem = 42 - - # type variable 'elem' still refers to the function annotation's type parameter - result : elem - result = List.first(list) |> Result.withDefault(elem) - - result -} -``` - -The type annotation says it should have the type: - _elem_ - -But here it's being used as: - _elem_ - # TOKENS ~~~zig KwApp(1:1-1:4),OpenSquare(1:5-1:6),LowerIdent(1:6-1:11),CloseSquare(1:11-1:12),OpenCurly(1:13-1:14),LowerIdent(1:15-1:17),OpColon(1:17-1:18),KwPlatform(1:19-1:27),StringStart(1:28-1:29),StringPart(1:29-1:54),StringEnd(1:54-1:55),CloseCurly(1:56-1:57), @@ -189,9 +166,7 @@ main! = |_| {} (e-block @5.18-14.2 (s-let @7.5-7.14 (p-assign @7.5-7.9 (ident "elem")) - (e-int @7.12-7.14 (value "42"))) - (s-type-anno @10.5-10.18 (name "result") - (ty-var @10.14-10.18 (name "elem"))) + (e-num @7.12-7.14 (value "42"))) (s-let @11.5-11.30 (p-assign @11.5-11.11 (ident "result")) (e-call @11.14-11.30 @@ -210,9 +185,9 @@ main! = |_| {} (annotation @5.1-5.8 (declared-type (ty-fn @4.11-4.29 (effectful false) - (ty-apply @4.11-4.21 (symbol "List") - (ty-var @4.16-4.20 (name "elem"))) - (ty-var @4.25-4.29 (name "elem")))))) + (ty-apply @4.11-4.21 (name "List") (builtin) + (ty-rigid-var @4.16-4.20 (name "elem"))) + (ty-rigid-var-lookup (ty-rigid-var @4.16-4.20 (name "elem"))))))) (d-let (p-assign @16.1-16.6 (ident "main!")) (e-lambda @16.9-16.15 @@ -224,9 +199,9 @@ main! = |_| {} ~~~clojure (inferred-types (defs - (patt @5.1-5.8 (type "List(elem) -> Error")) + (patt @5.1-5.8 (type "List(elem) -> elem")) (patt @16.1-16.6 (type "_arg -> {}"))) (expressions - (expr @5.11-14.2 (type "List(elem) -> Error")) + (expr @5.11-14.2 (type "List(elem) -> elem")) (expr @16.9-16.15 (type "_arg -> {}")))) ~~~ diff --git a/test/snapshots/type_var_nested.md b/test/snapshots/type_var_nested.md index e2cd81adf1..e53ad83bd3 100644 --- a/test/snapshots/type_var_nested.md +++ b/test/snapshots/type_var_nested.md @@ -220,8 +220,8 @@ main = |_| "done" (p-assign @5.1-5.11 (ident "map_result")) (e-closure @5.14-10.2 (captures - (capture @8.13-8.18 (ident "error")) - (capture @7.12-7.17 (ident "value"))) + (capture @7.12-7.17 (ident "value")) + (capture @8.13-8.18 (ident "error"))) (e-lambda @5.14-10.2 (args (p-assign @5.15-5.21 (ident "result")) @@ -261,16 +261,16 @@ main = |_| "done" (annotation @5.1-5.11 (declared-type (ty-fn @4.14-4.52 (effectful false) - (ty-apply @4.14-4.26 (symbol "Result") - (ty-var @4.21-4.22 (name "a")) - (ty-var @4.24-4.25 (name "e"))) + (ty-apply @4.14-4.26 (name "Result") (local) + (ty-rigid-var @4.14-4.26 (name "a")) + (ty-rigid-var @4.14-4.26 (name "e"))) (ty-parens @4.28-4.36 (ty-fn @4.29-4.35 (effectful false) - (ty-var @4.29-4.30 (name "a")) - (ty-var @4.34-4.35 (name "b")))) - (ty-apply @4.40-4.52 (symbol "Result") - (ty-var @4.47-4.48 (name "b")) - (ty-var @4.50-4.51 (name "e"))))))) + (ty-rigid-var-lookup (ty-rigid-var @4.14-4.26 (name "a"))) + (ty-rigid-var @4.34-4.35 (name "b")))) + (ty-apply @4.40-4.52 (name "Result") (local) + (ty-rigid-var-lookup (ty-rigid-var @4.34-4.35 (name "b"))) + (ty-rigid-var-lookup (ty-rigid-var @4.14-4.26 (name "e")))))))) (d-let (p-assign @14.1-14.9 (ident "identity")) (e-lambda @14.12-14.17 @@ -281,8 +281,8 @@ main = |_| "done" (annotation @14.1-14.9 (declared-type (ty-fn @13.12-13.18 (effectful false) - (ty-var @13.12-13.13 (name "a")) - (ty-var @13.17-13.18 (name "a")))))) + (ty-rigid-var @13.12-13.13 (name "a")) + (ty-rigid-var-lookup (ty-rigid-var @13.12-13.13 (name "a"))))))) (d-let (p-assign @18.1-18.10 (ident "make_pair")) (e-lambda @18.13-18.43 @@ -300,25 +300,25 @@ main = |_| "done" (annotation @18.1-18.10 (declared-type (ty-fn @17.13-17.44 (effectful false) - (ty-var @17.13-17.14 (name "a")) - (ty-var @17.16-17.17 (name "b")) + (ty-rigid-var @17.13-17.14 (name "a")) + (ty-rigid-var @17.16-17.17 (name "b")) (ty-record @17.21-17.44 (field (field "first") - (ty-var @17.30-17.31 (name "a"))) + (ty-rigid-var-lookup (ty-rigid-var @17.13-17.14 (name "a")))) (field (field "second") - (ty-var @17.41-17.42 (name "b")))))))) + (ty-rigid-var-lookup (ty-rigid-var @17.16-17.17 (name "b"))))))))) (d-let (p-assign @22.1-22.12 (ident "list_length")) (e-lambda @22.15-22.24 (args (p-assign @22.16-22.20 (ident "_lst"))) - (e-int @22.22-22.24 (value "42"))) + (e-num @22.22-22.24 (value "42"))) (annotation @22.1-22.12 (declared-type (ty-fn @21.15-21.30 (effectful false) - (ty-apply @21.15-21.23 (symbol "List") - (ty-var @21.20-21.22 (name "_a"))) - (ty @21.27-21.30 (name "U64")))))) + (ty-apply @21.15-21.23 (name "List") (builtin) + (ty-rigid-var @21.20-21.22 (name "_a"))) + (ty-lookup @21.27-21.30 (name "U64") (builtin)))))) (d-let (p-assign @26.1-26.15 (ident "wrap_in_result")) (e-lambda @26.18-26.39 @@ -335,12 +335,12 @@ main = |_| "done" (annotation @26.1-26.15 (declared-type (ty-fn @25.18-25.50 (effectful false) - (ty-var @25.18-25.19 (name "a")) - (ty-apply @25.23-25.50 (symbol "Result") - (ty-apply @25.30-25.44 (symbol "Result") - (ty-var @25.37-25.38 (name "a")) - (ty @25.40-25.43 (name "Str"))) - (ty @25.46-25.49 (name "Str"))))))) + (ty-rigid-var @25.18-25.19 (name "a")) + (ty-apply @25.23-25.50 (name "Result") (local) + (ty-apply @25.23-25.50 (name "Result") (local) + (ty-rigid-var-lookup (ty-rigid-var @25.18-25.19 (name "a"))) + (ty-lookup @25.30-25.44 (name "Str") (builtin))) + (ty-lookup @25.23-25.50 (name "Str") (builtin))))))) (d-let (p-assign @28.1-28.5 (ident "main")) (e-lambda @28.8-28.18 @@ -353,17 +353,17 @@ main = |_| "done" ~~~clojure (inferred-types (defs - (patt @5.1-5.11 (type "Result(a, err), a -> b -> Result(ok, err)")) + (patt @5.1-5.11 (type "Result(a, e), a -> b -> Result(b, e)")) (patt @14.1-14.9 (type "a -> a")) (patt @18.1-18.10 (type "a, b -> { first: a, second: b }")) - (patt @22.1-22.12 (type "List(_a) -> U64")) - (patt @26.1-26.15 (type "a -> Result(Error, err)")) + (patt @22.1-22.12 (type "List(_a) -> Num(Int(Unsigned64))")) + (patt @26.1-26.15 (type "a -> Result(Result(a, Str), Str)")) (patt @28.1-28.5 (type "_arg -> Str"))) (expressions - (expr @5.14-10.2 (type "Result(a, err), a -> b -> Result(ok, err)")) + (expr @5.14-10.2 (type "Result(a, e), a -> b -> Result(b, e)")) (expr @14.12-14.17 (type "a -> a")) (expr @18.13-18.43 (type "a, b -> { first: a, second: b }")) - (expr @22.15-22.24 (type "List(_a) -> U64")) - (expr @26.18-26.39 (type "a -> Result(Error, err)")) + (expr @22.15-22.24 (type "List(_a) -> Num(Int(Unsigned64))")) + (expr @26.18-26.39 (type "a -> Result(Result(a, Str), Str)")) (expr @28.8-28.18 (type "_arg -> Str")))) ~~~ diff --git a/test/snapshots/type_var_shadowing.md b/test/snapshots/type_var_shadowing.md index 8ab93ddff7..ac966f2b71 100644 --- a/test/snapshots/type_var_shadowing.md +++ b/test/snapshots/type_var_shadowing.md @@ -106,10 +106,6 @@ main! = |_| {} (args (p-assign @5.10-5.11 (ident "x"))) (e-block @5.13-11.2 - (s-type-anno @7.5-7.19 (name "inner") - (ty-fn @7.13-7.19 (effectful false) - (ty-var @7.13-7.14 (name "a")) - (ty-var @7.18-7.19 (name "a")))) (s-let @8.5-8.18 (p-assign @8.5-8.10 (ident "inner")) (e-lambda @8.13-8.18 @@ -125,8 +121,8 @@ main! = |_| {} (annotation @5.1-5.6 (declared-type (ty-fn @4.9-4.15 (effectful false) - (ty-var @4.9-4.10 (name "a")) - (ty-var @4.14-4.15 (name "a")))))) + (ty-rigid-var @4.9-4.10 (name "a")) + (ty-rigid-var-lookup (ty-rigid-var @4.9-4.10 (name "a"))))))) (d-let (p-assign @13.1-13.6 (ident "main!")) (e-lambda @13.9-13.15 diff --git a/test/snapshots/type_var_shadowing_inner.md b/test/snapshots/type_var_shadowing_inner.md index 7def4e2d36..1c47912a73 100644 --- a/test/snapshots/type_var_shadowing_inner.md +++ b/test/snapshots/type_var_shadowing_inner.md @@ -102,10 +102,6 @@ main! = |_| {} (args (p-assign @4.10-4.11 (ident "x"))) (e-block @4.13-9.2 - (s-type-anno @5.5-5.19 (name "inner") - (ty-fn @5.13-5.19 (effectful false) - (ty-var @5.13-5.14 (name "a")) - (ty-var @5.18-5.19 (name "a")))) (s-let @6.5-6.18 (p-assign @6.5-6.10 (ident "inner")) (e-lambda @6.13-6.18 @@ -121,8 +117,8 @@ main! = |_| {} (annotation @4.1-4.6 (declared-type (ty-fn @3.9-3.15 (effectful false) - (ty-var @3.9-3.10 (name "a")) - (ty-var @3.14-3.15 (name "a")))))) + (ty-rigid-var @3.9-3.10 (name "a")) + (ty-rigid-var-lookup (ty-rigid-var @3.9-3.10 (name "a"))))))) (d-let (p-assign @11.1-11.6 (ident "main!")) (e-lambda @11.9-11.15 diff --git a/test/snapshots/type_var_underscore_conventions.md b/test/snapshots/type_var_underscore_conventions.md index 7aa8adf9bb..32d67a4c6f 100644 --- a/test/snapshots/type_var_underscore_conventions.md +++ b/test/snapshots/type_var_underscore_conventions.md @@ -104,12 +104,12 @@ ending_underscore = |list| "default" ``` ^^^^^^^^^ -The type annotation says it should have the type: - _elem__ - -But here it's being used as: +It has the type: _Str_ +But the type annotation says it should have the type: + _elem__ + # TOKENS ~~~zig KwApp(1:1-1:4),OpenSquare(1:5-1:6),LowerIdent(1:6-1:10),CloseSquare(1:10-1:11),OpenCurly(1:12-1:13),LowerIdent(1:14-1:16),OpColon(1:16-1:17),KwPlatform(1:18-1:26),StringStart(1:27-1:28),StringPart(1:28-1:53),StringEnd(1:53-1:54),CloseCurly(1:55-1:56), @@ -231,9 +231,9 @@ NO CHANGE (annotation @5.1-5.11 (declared-type (ty-fn @4.14-4.31 (effectful false) - (ty-apply @4.14-4.24 (symbol "List") - (ty-var @4.19-4.23 (name "elem"))) - (ty @4.28-4.31 (name "Str")))))) + (ty-apply @4.14-4.24 (name "List") (builtin) + (ty-rigid-var @4.19-4.23 (name "elem"))) + (ty-lookup @4.28-4.31 (name "Str") (builtin)))))) (d-let (p-assign @9.1-9.18 (ident "ending_underscore")) (e-lambda @9.21-9.37 @@ -244,9 +244,9 @@ NO CHANGE (annotation @9.1-9.18 (declared-type (ty-fn @8.21-8.41 (effectful false) - (ty-apply @8.21-8.32 (symbol "List") - (ty-var @8.26-8.31 (name "elem_"))) - (ty-var @8.36-8.41 (name "elem_")))))) + (ty-apply @8.21-8.32 (name "List") (builtin) + (ty-rigid-var @8.26-8.31 (name "elem_"))) + (ty-rigid-var-lookup (ty-rigid-var @8.26-8.31 (name "elem_"))))))) (d-let (p-assign @13.1-13.13 (ident "combo_single")) (e-lambda @13.16-13.27 @@ -257,9 +257,9 @@ NO CHANGE (annotation @13.1-13.13 (declared-type (ty-fn @12.16-12.33 (effectful false) - (ty-apply @12.16-12.26 (symbol "List") - (ty-var @12.21-12.25 (name "bad_"))) - (ty @12.30-12.33 (name "Str")))))) + (ty-apply @12.16-12.26 (name "List") (builtin) + (ty-rigid-var @12.21-12.25 (name "bad_"))) + (ty-lookup @12.30-12.33 (name "Str") (builtin)))))) (d-let (p-assign @17.1-17.13 (ident "valid_single")) (e-lambda @17.16-17.27 @@ -270,9 +270,9 @@ NO CHANGE (annotation @17.1-17.13 (declared-type (ty-fn @16.16-16.34 (effectful false) - (ty-apply @16.16-16.27 (symbol "List") - (ty-var @16.21-16.26 (name "_elem"))) - (ty @16.31-16.34 (name "Str")))))) + (ty-apply @16.16-16.27 (name "List") (builtin) + (ty-rigid-var @16.21-16.26 (name "_elem"))) + (ty-lookup @16.31-16.34 (name "Str") (builtin)))))) (d-let (p-assign @20.1-20.12 (ident "valid_multi")) (e-lambda @20.15-20.22 @@ -285,9 +285,9 @@ NO CHANGE (annotation @20.1-20.12 (declared-type (ty-fn @19.15-19.33 (effectful false) - (ty-var @19.15-19.19 (name "elem")) - (ty-apply @19.23-19.33 (symbol "List") - (ty-var @19.28-19.32 (name "elem"))))))) + (ty-rigid-var @19.15-19.19 (name "elem")) + (ty-apply @19.23-19.33 (name "List") (builtin) + (ty-rigid-var-lookup (ty-rigid-var @19.15-19.19 (name "elem")))))))) (d-let (p-assign @22.1-22.5 (ident "main")) (e-lambda @22.8-22.18 diff --git a/test/snapshots/unary_minus_double_negative.md b/test/snapshots/unary_minus_double_negative.md index bc789a92a7..fa0b38f329 100644 --- a/test/snapshots/unary_minus_double_negative.md +++ b/test/snapshots/unary_minus_double_negative.md @@ -43,7 +43,7 @@ NO CHANGE (e-unary-minus @1.8-1.10 (e-lookup-local @1.9-1.10 (p-assign @1.3-1.4 (ident "x")))))) - (e-int @1.13-1.14 (value "5"))) + (e-num @1.13-1.14 (value "5"))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/unary_minus_lambda_parameter.md b/test/snapshots/unary_minus_lambda_parameter.md index 6dfca7d2e8..dd15252255 100644 --- a/test/snapshots/unary_minus_lambda_parameter.md +++ b/test/snapshots/unary_minus_lambda_parameter.md @@ -40,7 +40,7 @@ NO CHANGE (e-unary-minus @1.6-1.8 (e-lookup-local @1.7-1.8 (p-assign @1.3-1.4 (ident "x"))))) - (e-int @1.10-1.11 (value "5"))) + (e-num @1.10-1.11 (value "5"))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/unicode_single_quotes.md b/test/snapshots/unicode_single_quotes.md index 2bd85dd2bf..9876c25291 100644 --- a/test/snapshots/unicode_single_quotes.md +++ b/test/snapshots/unicode_single_quotes.md @@ -1,12 +1,10 @@ # META ~~~ini description=Unicode single quotes -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [] - x = ( 'a', 'é', @@ -36,16 +34,16 @@ INVALID UNICODE ESCAPE SEQUENCE - :0:0:0:0 INVALID UNICODE ESCAPE SEQUENCE - :0:0:0:0 INVALID UNICODE ESCAPE SEQUENCE - :0:0:0:0 INVALID ESCAPE SEQUENCE - :0:0:0:0 -UNEXPECTED TOKEN IN EXPRESSION - unicode_single_quotes.md:7:5:7:9 -UNEXPECTED TOKEN IN EXPRESSION - unicode_single_quotes.md:8:5:8:10 -UNEXPECTED TOKEN IN EXPRESSION - unicode_single_quotes.md:9:5:9:10 -UNEXPECTED TOKEN IN EXPRESSION - unicode_single_quotes.md:10:5:10:11 -UNEXPECTED TOKEN IN EXPRESSION - unicode_single_quotes.md:12:5:12:12 -UNEXPECTED TOKEN IN EXPRESSION - unicode_single_quotes.md:15:5:15:7 -UNEXPECTED TOKEN IN EXPRESSION - unicode_single_quotes.md:16:5:16:11 -UNEXPECTED TOKEN IN EXPRESSION - unicode_single_quotes.md:17:5:17:9 -UNEXPECTED TOKEN IN EXPRESSION - unicode_single_quotes.md:20:5:20:7 -PARSE ERROR - unicode_single_quotes.md:23:1:23:3 +UNEXPECTED TOKEN IN EXPRESSION - unicode_single_quotes.md:5:5:5:9 +UNEXPECTED TOKEN IN EXPRESSION - unicode_single_quotes.md:6:5:6:10 +UNEXPECTED TOKEN IN EXPRESSION - unicode_single_quotes.md:7:5:7:10 +UNEXPECTED TOKEN IN EXPRESSION - unicode_single_quotes.md:8:5:8:11 +UNEXPECTED TOKEN IN EXPRESSION - unicode_single_quotes.md:10:5:10:12 +UNEXPECTED TOKEN IN EXPRESSION - unicode_single_quotes.md:13:5:13:7 +UNEXPECTED TOKEN IN EXPRESSION - unicode_single_quotes.md:14:5:14:11 +UNEXPECTED TOKEN IN EXPRESSION - unicode_single_quotes.md:15:5:15:9 +UNEXPECTED TOKEN IN EXPRESSION - unicode_single_quotes.md:18:5:18:7 +PARSE ERROR - unicode_single_quotes.md:21:1:21:3 INVALID TUPLE ELEMENT - :0:0:0:0 INVALID TUPLE ELEMENT - :0:0:0:0 INVALID TUPLE ELEMENT - :0:0:0:0 @@ -54,7 +52,7 @@ INVALID TUPLE ELEMENT - :0:0:0:0 INVALID TUPLE ELEMENT - :0:0:0:0 INVALID TUPLE ELEMENT - :0:0:0:0 INVALID TUPLE ELEMENT - :0:0:0:0 -UNRECOGNIZED SYNTAX - unicode_single_quotes.md:20:5:20:7 +UNRECOGNIZED SYNTAX - unicode_single_quotes.md:18:5:18:7 # PROBLEMS **INVALID UNICODE ESCAPE SEQUENCE** This Unicode escape sequence is not valid. @@ -114,7 +112,7 @@ This escape sequence is not recognized. The token **'\u'** is not expected in an expression. Expressions can be identifiers, literals, function calls, or operators. -**unicode_single_quotes.md:7:5:7:9:** +**unicode_single_quotes.md:5:5:5:9:** ```roc '\u', ``` @@ -125,7 +123,7 @@ Expressions can be identifiers, literals, function calls, or operators. The token **'\u)'** is not expected in an expression. Expressions can be identifiers, literals, function calls, or operators. -**unicode_single_quotes.md:8:5:8:10:** +**unicode_single_quotes.md:6:5:6:10:** ```roc '\u)', ``` @@ -136,7 +134,7 @@ Expressions can be identifiers, literals, function calls, or operators. The token **'\u('** is not expected in an expression. Expressions can be identifiers, literals, function calls, or operators. -**unicode_single_quotes.md:9:5:9:10:** +**unicode_single_quotes.md:7:5:7:10:** ```roc '\u(', ``` @@ -147,7 +145,7 @@ Expressions can be identifiers, literals, function calls, or operators. The token **'\u()'** is not expected in an expression. Expressions can be identifiers, literals, function calls, or operators. -**unicode_single_quotes.md:10:5:10:11:** +**unicode_single_quotes.md:8:5:8:11:** ```roc '\u()', ``` @@ -158,7 +156,7 @@ Expressions can be identifiers, literals, function calls, or operators. The token **'\u(K)'** is not expected in an expression. Expressions can be identifiers, literals, function calls, or operators. -**unicode_single_quotes.md:12:5:12:12:** +**unicode_single_quotes.md:10:5:10:12:** ```roc '\u(K)', ``` @@ -169,7 +167,7 @@ Expressions can be identifiers, literals, function calls, or operators. The token **''** is not expected in an expression. Expressions can be identifiers, literals, function calls, or operators. -**unicode_single_quotes.md:15:5:15:7:** +**unicode_single_quotes.md:13:5:13:7:** ```roc '', ``` @@ -180,7 +178,7 @@ Expressions can be identifiers, literals, function calls, or operators. The token **'long'** is not expected in an expression. Expressions can be identifiers, literals, function calls, or operators. -**unicode_single_quotes.md:16:5:16:11:** +**unicode_single_quotes.md:14:5:14:11:** ```roc 'long', ``` @@ -191,7 +189,7 @@ Expressions can be identifiers, literals, function calls, or operators. The token **'\',** is not expected in an expression. Expressions can be identifiers, literals, function calls, or operators. -**unicode_single_quotes.md:17:5:17:9:** +**unicode_single_quotes.md:15:5:15:9:** ```roc '\', ``` @@ -202,7 +200,7 @@ Expressions can be identifiers, literals, function calls, or operators. The token **'u** is not expected in an expression. Expressions can be identifiers, literals, function calls, or operators. -**unicode_single_quotes.md:20:5:20:7:** +**unicode_single_quotes.md:18:5:18:7:** ```roc y = 'u ``` @@ -213,7 +211,7 @@ y = 'u A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**unicode_single_quotes.md:23:1:23:3:** +**unicode_single_quotes.md:21:1:21:3:** ```roc '\ ``` @@ -247,7 +245,7 @@ This tuple element is malformed or contains invalid syntax. **UNRECOGNIZED SYNTAX** I don't recognize this syntax. -**unicode_single_quotes.md:20:5:20:7:** +**unicode_single_quotes.md:18:5:18:7:** ```roc y = 'u ``` @@ -257,59 +255,55 @@ This might be a syntax error, an unsupported language feature, or a typo. # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),CloseSquare(1:9-1:10), -LowerIdent(3:1-3:2),OpAssign(3:3-3:4),OpenRound(3:5-3:6), -SingleQuote(4:5-4:8),Comma(4:8-4:9), -SingleQuote(5:5-5:9),Comma(5:9-5:10), -SingleQuote(6:5-6:11),Comma(6:11-6:12), -MalformedSingleQuoteInvalidEscapeSequence(7:5-7:9),Comma(7:9-7:10), -MalformedSingleQuoteInvalidEscapeSequence(8:5-8:10),Comma(8:10-8:11), -MalformedSingleQuoteInvalidEscapeSequence(9:5-9:10),Comma(9:10-9:11), -MalformedSingleQuoteInvalidEscapeSequence(10:5-10:11),Comma(10:11-10:12), -SingleQuote(11:5-11:16),Comma(11:16-11:17), -MalformedSingleQuoteInvalidEscapeSequence(12:5-12:12),Comma(12:12-12:13), -SingleQuote(13:5-13:9),Comma(13:9-13:10), -SingleQuote(14:5-14:9),Comma(14:9-14:10), -MalformedSingleQuoteEmpty(15:5-15:7),Comma(15:7-15:8), -MalformedSingleQuoteTooLong(16:5-16:11),Comma(16:11-16:12), -MalformedSingleQuoteUnclosed(17:5-17:9), -CloseRound(18:1-18:2), -LowerIdent(20:1-20:2),OpAssign(20:3-20:4),MalformedSingleQuoteUnclosed(20:5-20:7), -MalformedSingleQuoteUnclosed(23:1-23:3), -EndOfFile(24:1-24:1), +LowerIdent(1:1-1:2),OpAssign(1:3-1:4),OpenRound(1:5-1:6), +SingleQuote(2:5-2:8),Comma(2:8-2:9), +SingleQuote(3:5-3:9),Comma(3:9-3:10), +SingleQuote(4:5-4:11),Comma(4:11-4:12), +MalformedSingleQuoteInvalidEscapeSequence(5:5-5:9),Comma(5:9-5:10), +MalformedSingleQuoteInvalidEscapeSequence(6:5-6:10),Comma(6:10-6:11), +MalformedSingleQuoteInvalidEscapeSequence(7:5-7:10),Comma(7:10-7:11), +MalformedSingleQuoteInvalidEscapeSequence(8:5-8:11),Comma(8:11-8:12), +SingleQuote(9:5-9:16),Comma(9:16-9:17), +MalformedSingleQuoteInvalidEscapeSequence(10:5-10:12),Comma(10:12-10:13), +SingleQuote(11:5-11:9),Comma(11:9-11:10), +SingleQuote(12:5-12:9),Comma(12:9-12:10), +MalformedSingleQuoteEmpty(13:5-13:7),Comma(13:7-13:8), +MalformedSingleQuoteTooLong(14:5-14:11),Comma(14:11-14:12), +MalformedSingleQuoteUnclosed(15:5-15:9), +CloseRound(16:1-16:2), +LowerIdent(18:1-18:2),OpAssign(18:3-18:4),MalformedSingleQuoteUnclosed(18:5-18:7), +MalformedSingleQuoteUnclosed(21:1-21:3), +EndOfFile(22:1-22:1), ~~~ # PARSE ~~~clojure -(file @1.1-23.3 - (module @1.1-1.10 - (exposes @1.8-1.10)) +(file @1.1-21.3 + (type-module @1.1-1.2) (statements - (s-decl @3.1-18.2 - (p-ident @3.1-3.2 (raw "x")) - (e-tuple @3.5-18.2 - (e-single-quote @4.5-4.8 (raw "'a'")) - (e-single-quote @5.5-5.9 (raw "'é'")) - (e-single-quote @6.5-6.11 (raw "'🚀'")) - (e-malformed @7.5-7.9 (reason "expr_unexpected_token")) - (e-malformed @8.5-8.10 (reason "expr_unexpected_token")) - (e-malformed @9.5-9.10 (reason "expr_unexpected_token")) - (e-malformed @10.5-10.11 (reason "expr_unexpected_token")) - (e-single-quote @11.5-11.16 (raw "'\u(1F680)'")) - (e-malformed @12.5-12.12 (reason "expr_unexpected_token")) - (e-single-quote @13.5-13.9 (raw "'\\'")) - (e-single-quote @14.5-14.9 (raw "'\''")) - (e-malformed @15.5-15.7 (reason "expr_unexpected_token")) - (e-malformed @16.5-16.11 (reason "expr_unexpected_token")) - (e-malformed @17.5-17.9 (reason "expr_unexpected_token")))) - (s-decl @20.1-20.7 - (p-ident @20.1-20.2 (raw "y")) - (e-malformed @20.5-20.7 (reason "expr_unexpected_token"))) - (s-malformed @23.1-23.3 (tag "statement_unexpected_token")))) + (s-decl @1.1-16.2 + (p-ident @1.1-1.2 (raw "x")) + (e-tuple @1.5-16.2 + (e-single-quote @2.5-2.8 (raw "'a'")) + (e-single-quote @3.5-3.9 (raw "'é'")) + (e-single-quote @4.5-4.11 (raw "'🚀'")) + (e-malformed @5.5-5.9 (reason "expr_unexpected_token")) + (e-malformed @6.5-6.10 (reason "expr_unexpected_token")) + (e-malformed @7.5-7.10 (reason "expr_unexpected_token")) + (e-malformed @8.5-8.11 (reason "expr_unexpected_token")) + (e-single-quote @9.5-9.16 (raw "'\u(1F680)'")) + (e-malformed @10.5-10.12 (reason "expr_unexpected_token")) + (e-single-quote @11.5-11.9 (raw "'\\'")) + (e-single-quote @12.5-12.9 (raw "'\''")) + (e-malformed @13.5-13.7 (reason "expr_unexpected_token")) + (e-malformed @14.5-14.11 (reason "expr_unexpected_token")) + (e-malformed @15.5-15.9 (reason "expr_unexpected_token")))) + (s-decl @18.1-18.7 + (p-ident @18.1-18.2 (raw "y")) + (e-malformed @18.5-18.7 (reason "expr_unexpected_token"))) + (s-malformed @21.1-21.3 (tag "statement_unexpected_token")))) ~~~ # FORMATTED ~~~roc -module [] - x = ( 'a', 'é', @@ -335,34 +329,34 @@ y = ~~~clojure (can-ir (d-let - (p-assign @3.1-3.2 (ident "x")) - (e-tuple @3.5-18.2 + (p-assign @1.1-1.2 (ident "x")) + (e-tuple @1.5-16.2 (elems - (e-int @4.5-4.8 (value "97")) - (e-int @5.5-5.9 (value "233")) - (e-int @6.5-6.11 (value "128640")) + (e-num @2.5-2.8 (value "97")) + (e-num @3.5-3.9 (value "233")) + (e-num @4.5-4.11 (value "128640")) (e-runtime-error (tag "tuple_elem_not_canonicalized")) (e-runtime-error (tag "tuple_elem_not_canonicalized")) (e-runtime-error (tag "tuple_elem_not_canonicalized")) (e-runtime-error (tag "tuple_elem_not_canonicalized")) - (e-int @11.5-11.16 (value "128640")) + (e-num @9.5-9.16 (value "128640")) (e-runtime-error (tag "tuple_elem_not_canonicalized")) - (e-int @13.5-13.9 (value "92")) - (e-int @14.5-14.9 (value "39")) + (e-num @11.5-11.9 (value "92")) + (e-num @12.5-12.9 (value "39")) (e-runtime-error (tag "tuple_elem_not_canonicalized")) (e-runtime-error (tag "tuple_elem_not_canonicalized")) (e-runtime-error (tag "tuple_elem_not_canonicalized"))))) (d-let - (p-assign @20.1-20.2 (ident "y")) + (p-assign @18.1-18.2 (ident "y")) (e-runtime-error (tag "expr_not_canonicalized")))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @3.1-3.2 (type "(Num(_size), Num(_size2), Num(_size3), Error, Error, Error, Error, Num(_size4), Error, Num(_size5), Num(_size6), Error, Error, Error)")) - (patt @20.1-20.2 (type "Error"))) + (patt @1.1-1.2 (type "(Num(Int(_size)), Num(Int(_size2)), Num(Int(_size3)), Error, Error, Error, Error, Num(Int(_size4)), Error, Num(Int(_size5)), Num(Int(_size6)), Error, Error, Error)")) + (patt @18.1-18.2 (type "Error"))) (expressions - (expr @3.5-18.2 (type "(Num(_size), Num(_size2), Num(_size3), Error, Error, Error, Error, Num(_size4), Error, Num(_size5), Num(_size6), Error, Error, Error)")) - (expr @20.5-20.7 (type "Error")))) + (expr @1.5-16.2 (type "(Num(Int(_size)), Num(Int(_size2)), Num(Int(_size3)), Error, Error, Error, Error, Num(Int(_size4)), Error, Num(Int(_size5)), Num(Int(_size6)), Error, Error, Error)")) + (expr @18.5-18.7 (type "Error")))) ~~~ diff --git a/test/snapshots/unused_vars_block.md b/test/snapshots/unused_vars_block.md index bc9eea50a9..daa79aed40 100644 --- a/test/snapshots/unused_vars_block.md +++ b/test/snapshots/unused_vars_block.md @@ -147,23 +147,23 @@ main! = |_| { (e-block @3.13-21.2 (s-let @5.5-5.20 (p-assign @5.5-5.15 (ident "unused_var")) - (e-int @5.18-5.20 (value "42"))) + (e-num @5.18-5.20 (value "42"))) (s-let @8.5-8.19 (p-assign @8.5-8.13 (ident "used_var")) - (e-int @8.16-8.19 (value "100"))) + (e-num @8.16-8.19 (value "100"))) (s-let @11.5-11.29 (p-assign @11.5-11.19 (ident "another_unused")) (e-string @11.22-11.29 (e-literal @11.23-11.28 (string "hello")))) (s-let @14.5-16.10 (p-assign @14.5-14.13 (ident "_ignored")) - (e-int @16.7-16.10 (value "999"))) + (e-num @16.7-16.10 (value "999"))) (s-let @19.5-19.27 (p-assign @19.5-19.11 (ident "result")) (e-binop @19.14-19.27 (op "add") (e-lookup-local @19.14-19.22 (p-assign @8.5-8.13 (ident "used_var"))) - (e-int @19.25-19.27 (value "10")))) + (e-num @19.25-19.27 (value "10")))) (e-lookup-local @20.5-20.11 (p-assign @19.5-19.11 (ident "result"))))))) ~~~ diff --git a/test/snapshots/unused_vars_simple.md b/test/snapshots/unused_vars_simple.md index b021b02bd3..7332113cd5 100644 --- a/test/snapshots/unused_vars_simple.md +++ b/test/snapshots/unused_vars_simple.md @@ -179,7 +179,7 @@ main! = |_| { (e-lambda @4.18-4.24 (args (p-assign @4.19-4.20 (ident "x"))) - (e-int @4.22-4.24 (value "42")))) + (e-num @4.22-4.24 (value "42")))) (d-let (p-assign @7.1-7.16 (ident "used_underscore")) (e-lambda @7.19-7.34 @@ -192,7 +192,7 @@ main! = |_| { (e-lambda @10.21-10.35 (args (p-assign @10.22-10.30 (ident "_ignored"))) - (e-int @10.32-10.35 (value "100")))) + (e-num @10.32-10.35 (value "100")))) (d-let (p-assign @13.1-13.13 (ident "used_regular")) (e-lambda @13.16-13.35 @@ -201,7 +201,7 @@ main! = |_| { (e-binop @13.25-13.35 (op "add") (e-lookup-local @13.25-13.31 (p-assign @13.17-13.23 (ident "number"))) - (e-int @13.34-13.35 (value "1"))))) + (e-num @13.34-13.35 (value "1"))))) (d-let (p-assign @15.1-15.6 (ident "main!")) (e-closure @15.9-21.2 @@ -219,25 +219,25 @@ main! = |_| { (e-call @16.9-16.26 (e-lookup-local @16.9-16.23 (p-assign @4.1-4.15 (ident "unused_regular"))) - (e-int @16.24-16.25 (value "5")))) + (e-num @16.24-16.25 (value "5")))) (s-let @17.5-17.28 (p-assign @17.5-17.6 (ident "b")) (e-call @17.9-17.28 (e-lookup-local @17.9-17.24 (p-assign @7.1-7.16 (ident "used_underscore"))) - (e-int @17.25-17.27 (value "10")))) + (e-num @17.25-17.27 (value "10")))) (s-let @18.5-18.30 (p-assign @18.5-18.6 (ident "c")) (e-call @18.9-18.30 (e-lookup-local @18.9-18.26 (p-assign @10.1-10.18 (ident "unused_underscore"))) - (e-int @18.27-18.29 (value "15")))) + (e-num @18.27-18.29 (value "15")))) (s-let @19.5-19.25 (p-assign @19.5-19.6 (ident "d")) (e-call @19.9-19.25 (e-lookup-local @19.9-19.21 (p-assign @13.1-13.13 (ident "used_regular"))) - (e-int @19.22-19.24 (value "20")))) + (e-num @19.22-19.24 (value "20")))) (e-binop @20.5-20.18 (op "add") (e-binop @20.5-20.14 (op "add") (e-binop @20.5-20.10 (op "add") @@ -255,13 +255,13 @@ main! = |_| { (inferred-types (defs (patt @4.1-4.15 (type "_arg -> Num(_size)")) - (patt @7.1-7.16 (type "_arg -> _ret")) + (patt @7.1-7.16 (type "e -> e")) (patt @10.1-10.18 (type "_arg -> Num(_size)")) (patt @13.1-13.13 (type "Num(_size) -> Num(_size2)")) (patt @15.1-15.6 (type "_arg -> Num(_size)"))) (expressions (expr @4.18-4.24 (type "_arg -> Num(_size)")) - (expr @7.19-7.34 (type "_arg -> _ret")) + (expr @7.19-7.34 (type "e -> e")) (expr @10.21-10.35 (type "_arg -> Num(_size)")) (expr @13.16-13.35 (type "Num(_size) -> Num(_size2)")) (expr @15.9-21.2 (type "_arg -> Num(_size)")))) diff --git a/test/snapshots/where_clause/where_clauses_1.md b/test/snapshots/where_clause/where_clauses_1.md index 6282055a1e..33e7e9e186 100644 --- a/test/snapshots/where_clause/where_clauses_1.md +++ b/test/snapshots/where_clause/where_clauses_1.md @@ -1,12 +1,10 @@ # META ~~~ini description=where_clauses (1) -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [Hash, Decode] - Hash(a, hasher) : a where module(a).hash : hasher -> hasher, @@ -15,14 +13,14 @@ Hash(a, hasher) : a Decode(a) : a where module(a).decode : List(U8) -> a ~~~ # EXPECTED -WHERE CLAUSE NOT ALLOWED IN TYPE DECLARATION - where_clauses_1.md:3:1:6:24 -WHERE CLAUSE NOT ALLOWED IN TYPE DECLARATION - where_clauses_1.md:8:1:8:53 +WHERE CLAUSE NOT ALLOWED IN TYPE DECLARATION - where_clauses_1.md:1:1:4:24 +WHERE CLAUSE NOT ALLOWED IN TYPE DECLARATION - where_clauses_1.md:6:1:6:53 # PROBLEMS **WHERE CLAUSE NOT ALLOWED IN TYPE DECLARATION** You cannot define a `where` clause inside a type declaration. You're attempting do this here: -**where_clauses_1.md:3:1:6:24:** +**where_clauses_1.md:1:1:4:24:** ```roc Hash(a, hasher) : a where @@ -35,7 +33,7 @@ Hash(a, hasher) : a You cannot define a `where` clause inside a type declaration. You're attempting do this here: -**where_clauses_1.md:8:1:8:53:** +**where_clauses_1.md:6:1:6:53:** ```roc Decode(a) : a where module(a).decode : List(U8) -> a ``` @@ -44,46 +42,29 @@ Decode(a) : a where module(a).decode : List(U8) -> a # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:13),Comma(1:13-1:14),UpperIdent(1:15-1:21),CloseSquare(1:21-1:22), -UpperIdent(3:1-3:5),NoSpaceOpenRound(3:5-3:6),LowerIdent(3:6-3:7),Comma(3:7-3:8),LowerIdent(3:9-3:15),CloseRound(3:15-3:16),OpColon(3:17-3:18),LowerIdent(3:19-3:20), -KwWhere(4:2-4:7), -KwModule(5:3-5:9),NoSpaceOpenRound(5:9-5:10),LowerIdent(5:10-5:11),CloseRound(5:11-5:12),NoSpaceDotLowerIdent(5:12-5:17),OpColon(5:18-5:19),LowerIdent(5:20-5:26),OpArrow(5:27-5:29),LowerIdent(5:30-5:36),Comma(5:36-5:37), -KwModule(6:3-6:9),NoSpaceOpenRound(6:9-6:10),LowerIdent(6:10-6:16),CloseRound(6:16-6:17),NoSpaceDotUpperIdent(6:17-6:24), -UpperIdent(8:1-8:7),NoSpaceOpenRound(8:7-8:8),LowerIdent(8:8-8:9),CloseRound(8:9-8:10),OpColon(8:11-8:12),LowerIdent(8:13-8:14),KwWhere(8:15-8:20),KwModule(8:21-8:27),NoSpaceOpenRound(8:27-8:28),LowerIdent(8:28-8:29),CloseRound(8:29-8:30),NoSpaceDotLowerIdent(8:30-8:37),OpColon(8:38-8:39),UpperIdent(8:40-8:44),NoSpaceOpenRound(8:44-8:45),UpperIdent(8:45-8:47),CloseRound(8:47-8:48),OpArrow(8:49-8:51),LowerIdent(8:52-8:53), -EndOfFile(9:1-9:1), +UpperIdent(1:1-1:5),NoSpaceOpenRound(1:5-1:6),LowerIdent(1:6-1:7),Comma(1:7-1:8),LowerIdent(1:9-1:15),CloseRound(1:15-1:16),OpColon(1:17-1:18),LowerIdent(1:19-1:20), +KwWhere(2:2-2:7), +KwModule(3:3-3:9),NoSpaceOpenRound(3:9-3:10),LowerIdent(3:10-3:11),CloseRound(3:11-3:12),NoSpaceDotLowerIdent(3:12-3:17),OpColon(3:18-3:19),LowerIdent(3:20-3:26),OpArrow(3:27-3:29),LowerIdent(3:30-3:36),Comma(3:36-3:37), +KwModule(4:3-4:9),NoSpaceOpenRound(4:9-4:10),LowerIdent(4:10-4:16),CloseRound(4:16-4:17),NoSpaceDotUpperIdent(4:17-4:24), +UpperIdent(6:1-6:7),NoSpaceOpenRound(6:7-6:8),LowerIdent(6:8-6:9),CloseRound(6:9-6:10),OpColon(6:11-6:12),LowerIdent(6:13-6:14),KwWhere(6:15-6:20),KwModule(6:21-6:27),NoSpaceOpenRound(6:27-6:28),LowerIdent(6:28-6:29),CloseRound(6:29-6:30),NoSpaceDotLowerIdent(6:30-6:37),OpColon(6:38-6:39),UpperIdent(6:40-6:44),NoSpaceOpenRound(6:44-6:45),UpperIdent(6:45-6:47),CloseRound(6:47-6:48),OpArrow(6:49-6:51),LowerIdent(6:52-6:53), +EndOfFile(7:1-7:1), ~~~ # PARSE ~~~clojure -(file @1.1-8.53 - (module @1.1-1.22 - (exposes @1.8-1.22 - (exposed-upper-ident @1.9-1.13 (text "Hash")) - (exposed-upper-ident @1.15-1.21 (text "Decode")))) +(file @1.1-6.53 + (type-module @1.1-1.5) (statements - (s-type-decl @3.1-6.24 - (header @3.1-3.16 (name "Hash") + (s-type-decl @1.1-4.24 + (header @1.1-1.16 (name "Hash") (args - (ty-var @3.6-3.7 (raw "a")) - (ty-var @3.9-3.15 (raw "hasher")))) - (ty-var @3.19-3.20 (raw "a")) - (where - (method @5.3-5.36 (module-of "a") (name "hash") - (args - (ty-var @5.20-5.26 (raw "hasher"))) - (ty-var @5.30-5.36 (raw "hasher"))) - (alias @6.3-6.24 (module-of "hasher") (name "Hasher")))) - (s-type-decl @8.1-8.53 - (header @8.1-8.10 (name "Decode") + (ty-var @1.6-1.7 (raw "a")) + (ty-var @1.9-1.15 (raw "hasher")))) + (ty-var @1.19-1.20 (raw "a"))) + (s-type-decl @6.1-6.53 + (header @6.1-6.10 (name "Decode") (args - (ty-var @8.8-8.9 (raw "a")))) - (ty-var @8.13-8.14 (raw "a")) - (where - (method @8.21-8.53 (module-of "a") (name "decode") - (args - (ty-apply @8.40-8.48 - (ty @8.40-8.44 (name "List")) - (ty @8.45-8.47 (name "U8")))) - (ty-var @8.52-8.53 (raw "a"))))))) + (ty-var @6.8-6.9 (raw "a")))) + (ty-var @6.13-6.14 (raw "a"))))) ~~~ # FORMATTED ~~~roc @@ -92,31 +73,31 @@ NO CHANGE # CANONICALIZE ~~~clojure (can-ir - (s-alias-decl @3.1-6.24 - (ty-header @3.1-3.16 (name "Hash") + (s-alias-decl @1.1-4.24 + (ty-header @1.1-1.16 (name "Hash") (ty-args - (ty-var @3.6-3.7 (name "a")) - (ty-var @3.9-3.15 (name "hasher")))) - (ty-var @3.19-3.20 (name "a"))) - (s-alias-decl @8.1-8.53 - (ty-header @8.1-8.10 (name "Decode") + (ty-rigid-var @1.6-1.7 (name "a")) + (ty-rigid-var @1.9-1.15 (name "hasher")))) + (ty-rigid-var-lookup (ty-rigid-var @1.6-1.7 (name "a")))) + (s-alias-decl @6.1-6.53 + (ty-header @6.1-6.10 (name "Decode") (ty-args - (ty-var @8.8-8.9 (name "a")))) - (ty-var @8.13-8.14 (name "a")))) + (ty-rigid-var @6.8-6.9 (name "a")))) + (ty-rigid-var-lookup (ty-rigid-var @6.8-6.9 (name "a"))))) ~~~ # TYPES ~~~clojure (inferred-types (defs) (type_decls - (alias @3.1-6.24 (type "Hash(a, hasher)") - (ty-header @3.1-3.16 (name "Hash") + (alias @1.1-4.24 (type "Hash(a, hasher)") + (ty-header @1.1-1.16 (name "Hash") (ty-args - (ty-var @3.6-3.7 (name "a")) - (ty-var @3.9-3.15 (name "hasher"))))) - (alias @8.1-8.53 (type "Decode(a)") - (ty-header @8.1-8.10 (name "Decode") + (ty-rigid-var @1.6-1.7 (name "a")) + (ty-rigid-var @1.9-1.15 (name "hasher"))))) + (alias @6.1-6.53 (type "Decode(a)") + (ty-header @6.1-6.10 (name "Decode") (ty-args - (ty-var @8.8-8.9 (name "a")))))) + (ty-rigid-var @6.8-6.9 (name "a")))))) (expressions)) ~~~ diff --git a/test/snapshots/where_clause/where_clauses_10.md b/test/snapshots/where_clause/where_clauses_10.md index 8a897b04b2..ee0e542839 100644 --- a/test/snapshots/where_clause/where_clauses_10.md +++ b/test/snapshots/where_clause/where_clauses_10.md @@ -1,12 +1,10 @@ # META ~~~ini description=where_clauses (10) -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [decode] - import Decode exposing [Decode] decodeThings # After member name @@ -16,64 +14,49 @@ decodeThings # After member name module(a).Decode ~~~ # EXPECTED -MODULE NOT FOUND - where_clauses_10.md:3:1:3:32 -EXPOSED BUT NOT DEFINED - where_clauses_10.md:1:9:1:15 +MODULE NOT FOUND - where_clauses_10.md:1:1:1:32 # PROBLEMS **MODULE NOT FOUND** The module `Decode` was not found in this Roc project. You're attempting to use this module here: -**where_clauses_10.md:3:1:3:32:** +**where_clauses_10.md:1:1:1:32:** ```roc import Decode exposing [Decode] ``` ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -**EXPOSED BUT NOT DEFINED** -The module header says that `decode` is exposed, but it is not defined anywhere in this module. - -**where_clauses_10.md:1:9:1:15:** -```roc -module [decode] -``` - ^^^^^^ -You can fix this by either defining `decode` in this module, or by removing it from the list of exposed values. - # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:15),CloseSquare(1:15-1:16), -KwImport(3:1-3:7),UpperIdent(3:8-3:14),KwExposing(3:15-3:23),OpenSquare(3:24-3:25),UpperIdent(3:25-3:31),CloseSquare(3:31-3:32), -LowerIdent(5:1-5:13), -OpColon(6:2-6:3), -UpperIdent(7:3-7:7),NoSpaceOpenRound(7:7-7:8),UpperIdent(7:8-7:12),NoSpaceOpenRound(7:12-7:13),UpperIdent(7:13-7:15),CloseRound(7:15-7:16),CloseRound(7:16-7:17),OpArrow(7:18-7:20),UpperIdent(7:21-7:25),NoSpaceOpenRound(7:25-7:26),LowerIdent(7:26-7:27),CloseRound(7:27-7:28), -KwWhere(8:4-8:9), -KwModule(9:5-9:11),NoSpaceOpenRound(9:11-9:12),LowerIdent(9:12-9:13),CloseRound(9:13-9:14),NoSpaceDotUpperIdent(9:14-9:21), -EndOfFile(10:1-10:1), +KwImport(1:1-1:7),UpperIdent(1:8-1:14),KwExposing(1:15-1:23),OpenSquare(1:24-1:25),UpperIdent(1:25-1:31),CloseSquare(1:31-1:32), +LowerIdent(3:1-3:13), +OpColon(4:2-4:3), +UpperIdent(5:3-5:7),NoSpaceOpenRound(5:7-5:8),UpperIdent(5:8-5:12),NoSpaceOpenRound(5:12-5:13),UpperIdent(5:13-5:15),CloseRound(5:15-5:16),CloseRound(5:16-5:17),OpArrow(5:18-5:20),UpperIdent(5:21-5:25),NoSpaceOpenRound(5:25-5:26),LowerIdent(5:26-5:27),CloseRound(5:27-5:28), +KwWhere(6:4-6:9), +KwModule(7:5-7:11),NoSpaceOpenRound(7:11-7:12),LowerIdent(7:12-7:13),CloseRound(7:13-7:14),NoSpaceDotUpperIdent(7:14-7:21), +EndOfFile(8:1-8:1), ~~~ # PARSE ~~~clojure -(file @1.1-9.21 - (module @1.1-1.16 - (exposes @1.8-1.16 - (exposed-lower-ident @1.9-1.15 - (text "decode")))) +(file @1.1-7.21 + (type-module @1.1-1.7) (statements - (s-import @3.1-3.32 (raw "Decode") + (s-import @1.1-1.32 (raw "Decode") (exposing - (exposed-upper-ident @3.25-3.31 (text "Decode")))) - (s-type-anno @5.1-9.21 (name "decodeThings") - (ty-fn @7.3-7.28 - (ty-apply @7.3-7.17 - (ty @7.3-7.7 (name "List")) - (ty-apply @7.8-7.16 - (ty @7.8-7.12 (name "List")) - (ty @7.13-7.15 (name "U8")))) - (ty-apply @7.21-7.28 - (ty @7.21-7.25 (name "List")) - (ty-var @7.26-7.27 (raw "a")))) + (exposed-upper-ident @1.25-1.31 (text "Decode")))) + (s-type-anno @3.1-7.21 (name "decodeThings") + (ty-fn @5.3-5.28 + (ty-apply @5.3-5.17 + (ty @5.3-5.7 (name "List")) + (ty-apply @5.8-5.16 + (ty @5.8-5.12 (name "List")) + (ty @5.13-5.15 (name "U8")))) + (ty-apply @5.21-5.28 + (ty @5.21-5.25 (name "List")) + (ty-var @5.26-5.27 (raw "a")))) (where - (alias @9.5-9.21 (module-of "a") (name "Decode")))))) + (alias @7.5-7.21 (module-of "a") (name "Decode")))))) ~~~ # FORMATTED ~~~roc @@ -82,19 +65,19 @@ NO CHANGE # CANONICALIZE ~~~clojure (can-ir - (s-import @3.1-3.32 (module "Decode") + (s-import @1.1-1.32 (module "Decode") (exposes (exposed (name "Decode") (wildcard false)))) - (s-type-anno @5.1-9.21 (name "decodeThings") - (ty-fn @7.3-7.28 (effectful false) - (ty-apply @7.3-7.17 (symbol "List") - (ty-apply @7.8-7.16 (symbol "List") - (ty @7.13-7.15 (name "U8")))) - (ty-apply @7.21-7.28 (symbol "List") - (ty-var @7.26-7.27 (name "a")))) + (s-type-anno @3.1-7.21 (name "decodeThings") + (ty-fn @5.3-5.28 (effectful false) + (ty-apply @5.3-5.17 (name "List") (builtin) + (ty-apply @5.8-5.16 (name "List") (builtin) + (ty-lookup @5.13-5.15 (name "U8") (builtin)))) + (ty-apply @5.21-5.28 (name "List") (builtin) + (ty-rigid-var @5.26-5.27 (name "a")))) (where - (alias @9.5-9.21 (module-of "a") (ident "Decode")))) - (ext-decl @9.5-9.21 (ident "module(a).Decode") (kind "type"))) + (alias @7.5-7.21 (module-of "a") (ident "Decode")))) + (ext-decl @7.5-7.21 (ident "module(a).Decode") (kind "type"))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/where_clause/where_clauses_4.md b/test/snapshots/where_clause/where_clauses_4.md index 4af67ba84e..db3e367331 100644 --- a/test/snapshots/where_clause/where_clauses_4.md +++ b/test/snapshots/where_clause/where_clauses_4.md @@ -1,12 +1,10 @@ # META ~~~ini description=where_clauses (4) -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [decodeThings] - import Decode exposing [Decode] decodeThings : List(List(U8)) -> List(a) @@ -14,13 +12,13 @@ decodeThings : List(List(U8)) -> List(a) decodeThings = ... ~~~ # EXPECTED -MODULE NOT FOUND - where_clauses_4.md:3:1:3:32 +MODULE NOT FOUND - where_clauses_4.md:1:1:1:32 # PROBLEMS **MODULE NOT FOUND** The module `Decode` was not found in this Roc project. You're attempting to use this module here: -**where_clauses_4.md:3:1:3:32:** +**where_clauses_4.md:1:1:1:32:** ```roc import Decode exposing [Decode] ``` @@ -29,38 +27,34 @@ import Decode exposing [Decode] # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:21),CloseSquare(1:21-1:22), -KwImport(3:1-3:7),UpperIdent(3:8-3:14),KwExposing(3:15-3:23),OpenSquare(3:24-3:25),UpperIdent(3:25-3:31),CloseSquare(3:31-3:32), -LowerIdent(5:1-5:13),OpColon(5:14-5:15),UpperIdent(5:16-5:20),NoSpaceOpenRound(5:20-5:21),UpperIdent(5:21-5:25),NoSpaceOpenRound(5:25-5:26),UpperIdent(5:26-5:28),CloseRound(5:28-5:29),CloseRound(5:29-5:30),OpArrow(5:31-5:33),UpperIdent(5:34-5:38),NoSpaceOpenRound(5:38-5:39),LowerIdent(5:39-5:40),CloseRound(5:40-5:41), -KwWhere(6:2-6:7),KwModule(6:8-6:14),NoSpaceOpenRound(6:14-6:15),LowerIdent(6:15-6:16),CloseRound(6:16-6:17),NoSpaceDotUpperIdent(6:17-6:24), -LowerIdent(7:1-7:13),OpAssign(7:14-7:15),TripleDot(7:16-7:19), -EndOfFile(8:1-8:1), +KwImport(1:1-1:7),UpperIdent(1:8-1:14),KwExposing(1:15-1:23),OpenSquare(1:24-1:25),UpperIdent(1:25-1:31),CloseSquare(1:31-1:32), +LowerIdent(3:1-3:13),OpColon(3:14-3:15),UpperIdent(3:16-3:20),NoSpaceOpenRound(3:20-3:21),UpperIdent(3:21-3:25),NoSpaceOpenRound(3:25-3:26),UpperIdent(3:26-3:28),CloseRound(3:28-3:29),CloseRound(3:29-3:30),OpArrow(3:31-3:33),UpperIdent(3:34-3:38),NoSpaceOpenRound(3:38-3:39),LowerIdent(3:39-3:40),CloseRound(3:40-3:41), +KwWhere(4:2-4:7),KwModule(4:8-4:14),NoSpaceOpenRound(4:14-4:15),LowerIdent(4:15-4:16),CloseRound(4:16-4:17),NoSpaceDotUpperIdent(4:17-4:24), +LowerIdent(5:1-5:13),OpAssign(5:14-5:15),TripleDot(5:16-5:19), +EndOfFile(6:1-6:1), ~~~ # PARSE ~~~clojure -(file @1.1-7.19 - (module @1.1-1.22 - (exposes @1.8-1.22 - (exposed-lower-ident @1.9-1.21 - (text "decodeThings")))) +(file @1.1-5.19 + (type-module @1.1-1.7) (statements - (s-import @3.1-3.32 (raw "Decode") + (s-import @1.1-1.32 (raw "Decode") (exposing - (exposed-upper-ident @3.25-3.31 (text "Decode")))) - (s-type-anno @5.1-6.24 (name "decodeThings") - (ty-fn @5.16-5.41 - (ty-apply @5.16-5.30 - (ty @5.16-5.20 (name "List")) - (ty-apply @5.21-5.29 - (ty @5.21-5.25 (name "List")) - (ty @5.26-5.28 (name "U8")))) - (ty-apply @5.34-5.41 - (ty @5.34-5.38 (name "List")) - (ty-var @5.39-5.40 (raw "a")))) + (exposed-upper-ident @1.25-1.31 (text "Decode")))) + (s-type-anno @3.1-4.24 (name "decodeThings") + (ty-fn @3.16-3.41 + (ty-apply @3.16-3.30 + (ty @3.16-3.20 (name "List")) + (ty-apply @3.21-3.29 + (ty @3.21-3.25 (name "List")) + (ty @3.26-3.28 (name "U8")))) + (ty-apply @3.34-3.41 + (ty @3.34-3.38 (name "List")) + (ty-var @3.39-3.40 (raw "a")))) (where - (alias @6.8-6.24 (module-of "a") (name "Decode")))) - (s-decl @7.1-7.19 - (p-ident @7.1-7.13 (raw "decodeThings")) + (alias @4.8-4.24 (module-of "a") (name "Decode")))) + (s-decl @5.1-5.19 + (p-ident @5.1-5.13 (raw "decodeThings")) (e-ellipsis)))) ~~~ # FORMATTED @@ -71,35 +65,35 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @7.1-7.13 (ident "decodeThings")) + (p-assign @5.1-5.13 (ident "decodeThings")) (e-not-implemented @1.1-1.1) - (annotation @7.1-7.13 + (annotation @5.1-5.13 (declared-type - (ty-fn @5.16-5.41 (effectful false) - (ty-apply @5.16-5.30 (symbol "List") - (ty-apply @5.21-5.29 (symbol "List") - (ty @5.26-5.28 (name "U8")))) - (ty-apply @5.34-5.41 (symbol "List") - (ty-var @5.39-5.40 (name "a"))))))) - (s-import @3.1-3.32 (module "Decode") + (ty-fn @3.16-3.41 (effectful false) + (ty-apply @3.16-3.30 (name "List") (builtin) + (ty-apply @3.21-3.29 (name "List") (builtin) + (ty-lookup @3.26-3.28 (name "U8") (builtin)))) + (ty-apply @3.34-3.41 (name "List") (builtin) + (ty-rigid-var @3.39-3.40 (name "a"))))))) + (s-import @1.1-1.32 (module "Decode") (exposes (exposed (name "Decode") (wildcard false)))) - (s-type-anno @5.1-6.24 (name "decodeThings") - (ty-fn @5.16-5.41 (effectful false) - (ty-apply @5.16-5.30 (symbol "List") - (ty-apply @5.21-5.29 (symbol "List") - (ty @5.26-5.28 (name "U8")))) - (ty-apply @5.34-5.41 (symbol "List") - (ty-var @5.39-5.40 (name "a")))) + (s-type-anno @3.1-4.24 (name "decodeThings") + (ty-fn @3.16-3.41 (effectful false) + (ty-apply @3.16-3.30 (name "List") (builtin) + (ty-apply @3.21-3.29 (name "List") (builtin) + (ty-lookup @3.26-3.28 (name "U8") (builtin)))) + (ty-apply @3.34-3.41 (name "List") (builtin) + (ty-rigid-var @3.39-3.40 (name "a")))) (where - (alias @6.8-6.24 (module-of "a") (ident "Decode")))) - (ext-decl @6.8-6.24 (ident "module(a).Decode") (kind "type"))) + (alias @4.8-4.24 (module-of "a") (ident "Decode")))) + (ext-decl @4.8-4.24 (ident "module(a).Decode") (kind "type"))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @7.1-7.13 (type "List(item) -> List(a)"))) + (patt @5.1-5.13 (type "List(List(Num(Int(Unsigned8)))) -> List(a)"))) (expressions - (expr @1.1-1.1 (type "List(item) -> List(a)")))) + (expr @1.1-1.1 (type "List(List(Num(Int(Unsigned8)))) -> List(a)")))) ~~~ diff --git a/test/snapshots/where_clause/where_clauses_7.md b/test/snapshots/where_clause/where_clauses_7.md index 0064c18786..5183622cb2 100644 --- a/test/snapshots/where_clause/where_clauses_7.md +++ b/test/snapshots/where_clause/where_clauses_7.md @@ -1,12 +1,10 @@ # META ~~~ini description=where_clauses (7) -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [Hash] - Hash(a, hasher) # After header : # After colon a # After var @@ -23,14 +21,14 @@ Decode(a) : a ) -> a ~~~ # EXPECTED -WHERE CLAUSE NOT ALLOWED IN TYPE DECLARATION - where_clauses_7.md:3:1:10:26 -WHERE CLAUSE NOT ALLOWED IN TYPE DECLARATION - where_clauses_7.md:12:1:16:9 +WHERE CLAUSE NOT ALLOWED IN TYPE DECLARATION - where_clauses_7.md:1:1:8:26 +WHERE CLAUSE NOT ALLOWED IN TYPE DECLARATION - where_clauses_7.md:10:1:14:9 # PROBLEMS **WHERE CLAUSE NOT ALLOWED IN TYPE DECLARATION** You cannot define a `where` clause inside a type declaration. You're attempting do this here: -**where_clauses_7.md:3:1:10:26:** +**where_clauses_7.md:1:1:8:26:** ```roc Hash(a, hasher) # After header : # After colon @@ -47,7 +45,7 @@ Hash(a, hasher) # After header You cannot define a `where` clause inside a type declaration. You're attempting do this here: -**where_clauses_7.md:12:1:16:9:** +**where_clauses_7.md:10:1:14:9:** ```roc Decode(a) : a where @@ -59,58 +57,40 @@ Decode(a) : a # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),UpperIdent(1:9-1:13),CloseSquare(1:13-1:14), -UpperIdent(3:1-3:5),NoSpaceOpenRound(3:5-3:6),LowerIdent(3:6-3:7),Comma(3:7-3:8),LowerIdent(3:9-3:15),CloseRound(3:15-3:16), -OpColon(4:2-4:3), -LowerIdent(5:3-5:4), -KwWhere(6:4-6:9), -KwModule(7:5-7:11),NoSpaceOpenRound(7:11-7:12),LowerIdent(7:12-7:13),CloseRound(7:13-7:14),NoSpaceDotLowerIdent(7:14-7:19),OpColon(7:20-7:21),LowerIdent(7:22-7:28), -OpArrow(8:6-8:8), -LowerIdent(9:7-9:13),Comma(9:13-9:14), -KwModule(10:5-10:11),NoSpaceOpenRound(10:11-10:12),LowerIdent(10:12-10:18),CloseRound(10:18-10:19),NoSpaceDotUpperIdent(10:19-10:26), -UpperIdent(12:1-12:7),NoSpaceOpenRound(12:7-12:8),LowerIdent(12:8-12:9),CloseRound(12:9-12:10),OpColon(12:11-12:12),LowerIdent(12:13-12:14), -KwWhere(13:2-13:7), -KwModule(14:3-14:9),NoSpaceOpenRound(14:9-14:10),LowerIdent(14:10-14:11),CloseRound(14:11-14:12),NoSpaceDotLowerIdent(14:12-14:19),NoSpaceOpenRound(14:19-14:20), -UpperIdent(15:4-15:8),NoSpaceOpenRound(15:8-15:9),UpperIdent(15:9-15:11),CloseRound(15:11-15:12),Comma(15:12-15:13), -CloseRound(16:3-16:4),OpArrow(16:5-16:7),LowerIdent(16:8-16:9), -EndOfFile(17:1-17:1), +UpperIdent(1:1-1:5),NoSpaceOpenRound(1:5-1:6),LowerIdent(1:6-1:7),Comma(1:7-1:8),LowerIdent(1:9-1:15),CloseRound(1:15-1:16), +OpColon(2:2-2:3), +LowerIdent(3:3-3:4), +KwWhere(4:4-4:9), +KwModule(5:5-5:11),NoSpaceOpenRound(5:11-5:12),LowerIdent(5:12-5:13),CloseRound(5:13-5:14),NoSpaceDotLowerIdent(5:14-5:19),OpColon(5:20-5:21),LowerIdent(5:22-5:28), +OpArrow(6:6-6:8), +LowerIdent(7:7-7:13),Comma(7:13-7:14), +KwModule(8:5-8:11),NoSpaceOpenRound(8:11-8:12),LowerIdent(8:12-8:18),CloseRound(8:18-8:19),NoSpaceDotUpperIdent(8:19-8:26), +UpperIdent(10:1-10:7),NoSpaceOpenRound(10:7-10:8),LowerIdent(10:8-10:9),CloseRound(10:9-10:10),OpColon(10:11-10:12),LowerIdent(10:13-10:14), +KwWhere(11:2-11:7), +KwModule(12:3-12:9),NoSpaceOpenRound(12:9-12:10),LowerIdent(12:10-12:11),CloseRound(12:11-12:12),NoSpaceDotLowerIdent(12:12-12:19),NoSpaceOpenRound(12:19-12:20), +UpperIdent(13:4-13:8),NoSpaceOpenRound(13:8-13:9),UpperIdent(13:9-13:11),CloseRound(13:11-13:12),Comma(13:12-13:13), +CloseRound(14:3-14:4),OpArrow(14:5-14:7),LowerIdent(14:8-14:9), +EndOfFile(15:1-15:1), ~~~ # PARSE ~~~clojure -(file @1.1-16.9 - (module @1.1-1.14 - (exposes @1.8-1.14 - (exposed-upper-ident @1.9-1.13 (text "Hash")))) +(file @1.1-14.9 + (type-module @1.1-1.5) (statements - (s-type-decl @3.1-10.26 - (header @3.1-3.16 (name "Hash") + (s-type-decl @1.1-8.26 + (header @1.1-1.16 (name "Hash") (args - (ty-var @3.6-3.7 (raw "a")) - (ty-var @3.9-3.15 (raw "hasher")))) - (ty-var @5.3-5.4 (raw "a")) - (where - (method @7.5-9.13 (module-of "a") (name "hash") - (args - (ty-var @7.22-7.28 (raw "hasher"))) - (ty-var @9.7-9.13 (raw "hasher"))) - (alias @10.5-10.26 (module-of "hasher") (name "Hasher")))) - (s-type-decl @12.1-16.9 - (header @12.1-12.10 (name "Decode") + (ty-var @1.6-1.7 (raw "a")) + (ty-var @1.9-1.15 (raw "hasher")))) + (ty-var @3.3-3.4 (raw "a"))) + (s-type-decl @10.1-14.9 + (header @10.1-10.10 (name "Decode") (args - (ty-var @12.8-12.9 (raw "a")))) - (ty-var @12.13-12.14 (raw "a")) - (where - (method @14.3-16.9 (module-of "a") (name "decode") - (args - (ty-apply @15.4-15.12 - (ty @15.4-15.8 (name "List")) - (ty @15.9-15.11 (name "U8")))) - (ty-var @16.8-16.9 (raw "a"))))))) + (ty-var @10.8-10.9 (raw "a")))) + (ty-var @10.13-10.14 (raw "a"))))) ~~~ # FORMATTED ~~~roc -module [Hash] - Hash(a, hasher) # After header : # After colon a # After var @@ -127,31 +107,31 @@ Decode(a) : a # CANONICALIZE ~~~clojure (can-ir - (s-alias-decl @3.1-10.26 - (ty-header @3.1-3.16 (name "Hash") + (s-alias-decl @1.1-8.26 + (ty-header @1.1-1.16 (name "Hash") (ty-args - (ty-var @3.6-3.7 (name "a")) - (ty-var @3.9-3.15 (name "hasher")))) - (ty-var @5.3-5.4 (name "a"))) - (s-alias-decl @12.1-16.9 - (ty-header @12.1-12.10 (name "Decode") + (ty-rigid-var @1.6-1.7 (name "a")) + (ty-rigid-var @1.9-1.15 (name "hasher")))) + (ty-rigid-var-lookup (ty-rigid-var @1.6-1.7 (name "a")))) + (s-alias-decl @10.1-14.9 + (ty-header @10.1-10.10 (name "Decode") (ty-args - (ty-var @12.8-12.9 (name "a")))) - (ty-var @12.13-12.14 (name "a")))) + (ty-rigid-var @10.8-10.9 (name "a")))) + (ty-rigid-var-lookup (ty-rigid-var @10.8-10.9 (name "a"))))) ~~~ # TYPES ~~~clojure (inferred-types (defs) (type_decls - (alias @3.1-10.26 (type "Hash(a, hasher)") - (ty-header @3.1-3.16 (name "Hash") + (alias @1.1-8.26 (type "Hash(a, hasher)") + (ty-header @1.1-1.16 (name "Hash") (ty-args - (ty-var @3.6-3.7 (name "a")) - (ty-var @3.9-3.15 (name "hasher"))))) - (alias @12.1-16.9 (type "Decode(a)") - (ty-header @12.1-12.10 (name "Decode") + (ty-rigid-var @1.6-1.7 (name "a")) + (ty-rigid-var @1.9-1.15 (name "hasher"))))) + (alias @10.1-14.9 (type "Decode(a)") + (ty-header @10.1-10.10 (name "Decode") (ty-args - (ty-var @12.8-12.9 (name "a")))))) + (ty-rigid-var @10.8-10.9 (name "a")))))) (expressions)) ~~~ diff --git a/test/snapshots/where_clause/where_clauses_error_cases.md b/test/snapshots/where_clause/where_clauses_error_cases.md index 2df33f0c8c..af5fa91f1e 100644 --- a/test/snapshots/where_clause/where_clauses_error_cases.md +++ b/test/snapshots/where_clause/where_clauses_error_cases.md @@ -1,12 +1,10 @@ # META ~~~ini description=Error cases for where clauses -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [broken_fn1, broken_fn2, broken_fn3] - # Missing colon in constraint broken_fn1 : a -> b where @@ -22,21 +20,18 @@ broken_fn3 : a -> b module(c).method : c -> d ~~~ # EXPECTED -WHERE CLAUSE ERROR - where_clauses_error_cases.md:6:5:6:11 -PARSE ERROR - where_clauses_error_cases.md:6:25:6:26 -WHERE CLAUSE ERROR - where_clauses_error_cases.md:10:3:10:8 -MALFORMED WHERE CLAUSE - where_clauses_error_cases.md:6:5:6:24 -MALFORMED WHERE CLAUSE - where_clauses_error_cases.md:10:3:10:8 -EXPOSED BUT NOT DEFINED - where_clauses_error_cases.md:1:9:1:19 -EXPOSED BUT NOT DEFINED - where_clauses_error_cases.md:1:21:1:31 -EXPOSED BUT NOT DEFINED - where_clauses_error_cases.md:1:33:1:43 +WHERE CLAUSE ERROR - where_clauses_error_cases.md:4:5:4:11 +PARSE ERROR - where_clauses_error_cases.md:4:25:4:26 +WHERE CLAUSE ERROR - where_clauses_error_cases.md:8:3:8:8 +MALFORMED WHERE CLAUSE - where_clauses_error_cases.md:4:5:4:24 +MALFORMED WHERE CLAUSE - where_clauses_error_cases.md:8:3:8:8 # PROBLEMS **WHERE CLAUSE ERROR** Expected a colon **:** after the method name in this where clause constraint. Method constraints require a colon to separate the method name from its type. For example: module(a).method : a -> b -**where_clauses_error_cases.md:6:5:6:11:** +**where_clauses_error_cases.md:4:5:4:11:** ```roc module(a).method -> b ``` @@ -47,7 +42,7 @@ For example: module(a).method : a -> b A parsing error occurred: `statement_unexpected_token` This is an unexpected parsing error. Please check your syntax. -**where_clauses_error_cases.md:6:25:6:26:** +**where_clauses_error_cases.md:4:25:4:26:** ```roc module(a).method -> b ``` @@ -60,7 +55,7 @@ Where clauses must contain at least one constraint. For example: module(a).method : a -> b -**where_clauses_error_cases.md:10:3:10:8:** +**where_clauses_error_cases.md:8:3:8:8:** ```roc where ``` @@ -70,7 +65,7 @@ For example: **MALFORMED WHERE CLAUSE** This where clause could not be parsed correctly. -**where_clauses_error_cases.md:6:5:6:24:** +**where_clauses_error_cases.md:4:5:4:24:** ```roc module(a).method -> b ``` @@ -81,7 +76,7 @@ Check the syntax of your where clause. **MALFORMED WHERE CLAUSE** This where clause could not be parsed correctly. -**where_clauses_error_cases.md:10:3:10:8:** +**where_clauses_error_cases.md:8:3:8:8:** ```roc where ``` @@ -89,88 +84,49 @@ This where clause could not be parsed correctly. Check the syntax of your where clause. -**EXPOSED BUT NOT DEFINED** -The module header says that `broken_fn1` is exposed, but it is not defined anywhere in this module. - -**where_clauses_error_cases.md:1:9:1:19:** -```roc -module [broken_fn1, broken_fn2, broken_fn3] -``` - ^^^^^^^^^^ -You can fix this by either defining `broken_fn1` in this module, or by removing it from the list of exposed values. - -**EXPOSED BUT NOT DEFINED** -The module header says that `broken_fn2` is exposed, but it is not defined anywhere in this module. - -**where_clauses_error_cases.md:1:21:1:31:** -```roc -module [broken_fn1, broken_fn2, broken_fn3] -``` - ^^^^^^^^^^ -You can fix this by either defining `broken_fn2` in this module, or by removing it from the list of exposed values. - -**EXPOSED BUT NOT DEFINED** -The module header says that `broken_fn3` is exposed, but it is not defined anywhere in this module. - -**where_clauses_error_cases.md:1:33:1:43:** -```roc -module [broken_fn1, broken_fn2, broken_fn3] -``` - ^^^^^^^^^^ -You can fix this by either defining `broken_fn3` in this module, or by removing it from the list of exposed values. - # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:19),Comma(1:19-1:20),LowerIdent(1:21-1:31),Comma(1:31-1:32),LowerIdent(1:33-1:43),CloseSquare(1:43-1:44), -LowerIdent(4:1-4:11),OpColon(4:12-4:13),LowerIdent(4:14-4:15),OpArrow(4:16-4:18),LowerIdent(4:19-4:20), -KwWhere(5:3-5:8), -KwModule(6:5-6:11),NoSpaceOpenRound(6:11-6:12),LowerIdent(6:12-6:13),CloseRound(6:13-6:14),NoSpaceDotLowerIdent(6:14-6:21),OpArrow(6:22-6:24),LowerIdent(6:25-6:26), -LowerIdent(9:1-9:11),OpColon(9:12-9:13),LowerIdent(9:14-9:15),OpArrow(9:16-9:18),LowerIdent(9:19-9:20), -KwWhere(10:3-10:8), -LowerIdent(13:1-13:11),OpColon(13:12-13:13),LowerIdent(13:14-13:15),OpArrow(13:16-13:18),LowerIdent(13:19-13:20), -KwWhere(14:3-14:8), -KwModule(15:5-15:11),NoSpaceOpenRound(15:11-15:12),LowerIdent(15:12-15:13),CloseRound(15:13-15:14),NoSpaceDotLowerIdent(15:14-15:21),OpColon(15:22-15:23),LowerIdent(15:24-15:25),OpArrow(15:26-15:28),LowerIdent(15:29-15:30), -EndOfFile(16:1-16:1), +LowerIdent(2:1-2:11),OpColon(2:12-2:13),LowerIdent(2:14-2:15),OpArrow(2:16-2:18),LowerIdent(2:19-2:20), +KwWhere(3:3-3:8), +KwModule(4:5-4:11),NoSpaceOpenRound(4:11-4:12),LowerIdent(4:12-4:13),CloseRound(4:13-4:14),NoSpaceDotLowerIdent(4:14-4:21),OpArrow(4:22-4:24),LowerIdent(4:25-4:26), +LowerIdent(7:1-7:11),OpColon(7:12-7:13),LowerIdent(7:14-7:15),OpArrow(7:16-7:18),LowerIdent(7:19-7:20), +KwWhere(8:3-8:8), +LowerIdent(11:1-11:11),OpColon(11:12-11:13),LowerIdent(11:14-11:15),OpArrow(11:16-11:18),LowerIdent(11:19-11:20), +KwWhere(12:3-12:8), +KwModule(13:5-13:11),NoSpaceOpenRound(13:11-13:12),LowerIdent(13:12-13:13),CloseRound(13:13-13:14),NoSpaceDotLowerIdent(13:14-13:21),OpColon(13:22-13:23),LowerIdent(13:24-13:25),OpArrow(13:26-13:28),LowerIdent(13:29-13:30), +EndOfFile(14:1-14:1), ~~~ # PARSE ~~~clojure -(file @1.1-15.30 - (module @1.1-1.44 - (exposes @1.8-1.44 - (exposed-lower-ident @1.9-1.19 - (text "broken_fn1")) - (exposed-lower-ident @1.21-1.31 - (text "broken_fn2")) - (exposed-lower-ident @1.33-1.43 - (text "broken_fn3")))) +(file @2.1-13.30 + (type-module @2.1-2.11) (statements - (s-type-anno @4.1-6.24 (name "broken_fn1") - (ty-fn @4.14-4.20 - (ty-var @4.14-4.15 (raw "a")) - (ty-var @4.19-4.20 (raw "b"))) + (s-type-anno @2.1-4.24 (name "broken_fn1") + (ty-fn @2.14-2.20 + (ty-var @2.14-2.15 (raw "a")) + (ty-var @2.19-2.20 (raw "b"))) (where - (malformed @6.5-6.24 (reason "where_expected_colon")))) - (s-malformed @6.25-6.26 (tag "statement_unexpected_token")) - (s-type-anno @9.1-10.8 (name "broken_fn2") - (ty-fn @9.14-9.20 - (ty-var @9.14-9.15 (raw "a")) - (ty-var @9.19-9.20 (raw "b"))) + (malformed @4.5-4.24 (reason "where_expected_colon")))) + (s-malformed @4.25-4.26 (tag "statement_unexpected_token")) + (s-type-anno @7.1-8.8 (name "broken_fn2") + (ty-fn @7.14-7.20 + (ty-var @7.14-7.15 (raw "a")) + (ty-var @7.19-7.20 (raw "b"))) (where - (malformed @10.3-10.8 (reason "where_expected_constraints")))) - (s-type-anno @13.1-15.30 (name "broken_fn3") - (ty-fn @13.14-13.20 - (ty-var @13.14-13.15 (raw "a")) - (ty-var @13.19-13.20 (raw "b"))) + (malformed @8.3-8.8 (reason "where_expected_constraints")))) + (s-type-anno @11.1-13.30 (name "broken_fn3") + (ty-fn @11.14-11.20 + (ty-var @11.14-11.15 (raw "a")) + (ty-var @11.19-11.20 (raw "b"))) (where - (method @15.5-15.30 (module-of "c") (name "method") + (method @13.5-13.30 (module-of "c") (name "method") (args - (ty-var @15.24-15.25 (raw "c"))) - (ty-var @15.29-15.30 (raw "d"))))))) + (ty-var @13.24-13.25 (raw "c"))) + (ty-var @13.29-13.30 (raw "d"))))))) ~~~ # FORMATTED ~~~roc -module [broken_fn1, broken_fn2, broken_fn3] - +# Missing colon in constraint # Missing colon in constraint broken_fn1 : a -> b where @@ -188,28 +144,28 @@ broken_fn3 : a -> b # CANONICALIZE ~~~clojure (can-ir - (s-type-anno @4.1-6.24 (name "broken_fn1") - (ty-fn @4.14-4.20 (effectful false) - (ty-var @4.14-4.15 (name "a")) - (ty-var @4.19-4.20 (name "b"))) + (s-type-anno @2.1-4.24 (name "broken_fn1") + (ty-fn @2.14-2.20 (effectful false) + (ty-rigid-var @2.14-2.15 (name "a")) + (ty-rigid-var @2.19-2.20 (name "b"))) (where - (malformed @6.5-6.24))) - (s-type-anno @9.1-10.8 (name "broken_fn2") - (ty-fn @9.14-9.20 (effectful false) - (ty-var @9.14-9.15 (name "a")) - (ty-var @9.19-9.20 (name "b"))) + (malformed @4.5-4.24))) + (s-type-anno @7.1-8.8 (name "broken_fn2") + (ty-fn @7.14-7.20 (effectful false) + (ty-rigid-var @7.14-7.15 (name "a")) + (ty-rigid-var @7.19-7.20 (name "b"))) (where - (malformed @10.3-10.8))) - (s-type-anno @13.1-15.30 (name "broken_fn3") - (ty-fn @13.14-13.20 (effectful false) - (ty-var @13.14-13.15 (name "a")) - (ty-var @13.19-13.20 (name "b"))) + (malformed @8.3-8.8))) + (s-type-anno @11.1-13.30 (name "broken_fn3") + (ty-fn @11.14-11.20 (effectful false) + (ty-rigid-var @11.14-11.15 (name "a")) + (ty-rigid-var @11.19-11.20 (name "b"))) (where - (method @15.5-15.30 (module-of "c") (ident "method") + (method @13.5-13.30 (module-of "c") (ident "method") (args - (ty-var @15.24-15.25 (name "c"))) - (ty-var @15.29-15.30 (name "d"))))) - (ext-decl @15.5-15.30 (ident "module(c).method") (kind "value"))) + (ty-rigid-var @13.24-13.25 (name "c"))) + (ty-rigid-var @13.29-13.30 (name "d"))))) + (ext-decl @13.5-13.30 (ident "module(c).method") (kind "value"))) ~~~ # TYPES ~~~clojure diff --git a/test/snapshots/where_clause/where_clauses_minimal.md b/test/snapshots/where_clause/where_clauses_minimal.md index 11237d456d..0e05282116 100644 --- a/test/snapshots/where_clause/where_clauses_minimal.md +++ b/test/snapshots/where_clause/where_clauses_minimal.md @@ -1,12 +1,10 @@ # META ~~~ini description=Minimal where clause test -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [convert_me] - convert_me : a -> b where module(a).convert : a -> b @@ -18,32 +16,28 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:19),CloseSquare(1:19-1:20), -LowerIdent(3:1-3:11),OpColon(3:12-3:13),LowerIdent(3:14-3:15),OpArrow(3:16-3:18),LowerIdent(3:19-3:20), -KwWhere(4:2-4:7), -KwModule(5:3-5:9),NoSpaceOpenRound(5:9-5:10),LowerIdent(5:10-5:11),CloseRound(5:11-5:12),NoSpaceDotLowerIdent(5:12-5:20),OpColon(5:21-5:22),LowerIdent(5:23-5:24),OpArrow(5:25-5:27),LowerIdent(5:28-5:29), -LowerIdent(6:1-6:11),OpAssign(6:12-6:13),TripleDot(6:14-6:17), -EndOfFile(7:1-7:1), +LowerIdent(1:1-1:11),OpColon(1:12-1:13),LowerIdent(1:14-1:15),OpArrow(1:16-1:18),LowerIdent(1:19-1:20), +KwWhere(2:2-2:7), +KwModule(3:3-3:9),NoSpaceOpenRound(3:9-3:10),LowerIdent(3:10-3:11),CloseRound(3:11-3:12),NoSpaceDotLowerIdent(3:12-3:20),OpColon(3:21-3:22),LowerIdent(3:23-3:24),OpArrow(3:25-3:27),LowerIdent(3:28-3:29), +LowerIdent(4:1-4:11),OpAssign(4:12-4:13),TripleDot(4:14-4:17), +EndOfFile(5:1-5:1), ~~~ # PARSE ~~~clojure -(file @1.1-6.17 - (module @1.1-1.20 - (exposes @1.8-1.20 - (exposed-lower-ident @1.9-1.19 - (text "convert_me")))) +(file @1.1-4.17 + (type-module @1.1-1.11) (statements - (s-type-anno @3.1-5.29 (name "convert_me") - (ty-fn @3.14-3.20 - (ty-var @3.14-3.15 (raw "a")) - (ty-var @3.19-3.20 (raw "b"))) + (s-type-anno @1.1-3.29 (name "convert_me") + (ty-fn @1.14-1.20 + (ty-var @1.14-1.15 (raw "a")) + (ty-var @1.19-1.20 (raw "b"))) (where - (method @5.3-5.29 (module-of "a") (name "convert") + (method @3.3-3.29 (module-of "a") (name "convert") (args - (ty-var @5.23-5.24 (raw "a"))) - (ty-var @5.28-5.29 (raw "b"))))) - (s-decl @6.1-6.17 - (p-ident @6.1-6.11 (raw "convert_me")) + (ty-var @3.23-3.24 (raw "a"))) + (ty-var @3.28-3.29 (raw "b"))))) + (s-decl @4.1-4.17 + (p-ident @4.1-4.11 (raw "convert_me")) (e-ellipsis)))) ~~~ # FORMATTED @@ -54,29 +48,29 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @6.1-6.11 (ident "convert_me")) + (p-assign @4.1-4.11 (ident "convert_me")) (e-not-implemented @1.1-1.1) - (annotation @6.1-6.11 + (annotation @4.1-4.11 (declared-type - (ty-fn @3.14-3.20 (effectful false) - (ty-var @3.14-3.15 (name "a")) - (ty-var @3.19-3.20 (name "b")))))) - (s-type-anno @3.1-5.29 (name "convert_me") - (ty-fn @3.14-3.20 (effectful false) - (ty-var @3.14-3.15 (name "a")) - (ty-var @3.19-3.20 (name "b"))) + (ty-fn @1.14-1.20 (effectful false) + (ty-rigid-var @1.14-1.15 (name "a")) + (ty-rigid-var @1.19-1.20 (name "b")))))) + (s-type-anno @1.1-3.29 (name "convert_me") + (ty-fn @1.14-1.20 (effectful false) + (ty-rigid-var @1.14-1.15 (name "a")) + (ty-rigid-var @1.19-1.20 (name "b"))) (where - (method @5.3-5.29 (module-of "a") (ident "convert") + (method @3.3-3.29 (module-of "a") (ident "convert") (args - (ty-var @5.23-5.24 (name "a"))) - (ty-var @5.28-5.29 (name "b"))))) - (ext-decl @5.3-5.29 (ident "module(a).convert") (kind "value"))) + (ty-rigid-var-lookup (ty-rigid-var @1.14-1.15 (name "a")))) + (ty-rigid-var-lookup (ty-rigid-var @1.19-1.20 (name "b")))))) + (ext-decl @3.3-3.29 (ident "module(a).convert") (kind "value"))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @6.1-6.11 (type "a -> b"))) + (patt @4.1-4.11 (type "a -> b"))) (expressions (expr @1.1-1.1 (type "a -> b")))) ~~~ diff --git a/test/snapshots/where_clause/where_clauses_multi_type_vars.md b/test/snapshots/where_clause/where_clauses_multi_type_vars.md index 6be440a4bd..3e1e211788 100644 --- a/test/snapshots/where_clause/where_clauses_multi_type_vars.md +++ b/test/snapshots/where_clause/where_clauses_multi_type_vars.md @@ -1,12 +1,10 @@ # META ~~~ini description=Multiple where constraints on different type variables -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [process] - process : a, b -> c where module(a).convert : a -> c, module(b).transform : b -> c process = |_, _| ... ~~~ @@ -16,36 +14,32 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:16),CloseSquare(1:16-1:17), -LowerIdent(3:1-3:8),OpColon(3:9-3:10),LowerIdent(3:11-3:12),Comma(3:12-3:13),LowerIdent(3:14-3:15),OpArrow(3:16-3:18),LowerIdent(3:19-3:20),KwWhere(3:21-3:26),KwModule(3:27-3:33),NoSpaceOpenRound(3:33-3:34),LowerIdent(3:34-3:35),CloseRound(3:35-3:36),NoSpaceDotLowerIdent(3:36-3:44),OpColon(3:45-3:46),LowerIdent(3:47-3:48),OpArrow(3:49-3:51),LowerIdent(3:52-3:53),Comma(3:53-3:54),KwModule(3:55-3:61),NoSpaceOpenRound(3:61-3:62),LowerIdent(3:62-3:63),CloseRound(3:63-3:64),NoSpaceDotLowerIdent(3:64-3:74),OpColon(3:75-3:76),LowerIdent(3:77-3:78),OpArrow(3:79-3:81),LowerIdent(3:82-3:83), -LowerIdent(4:1-4:8),OpAssign(4:9-4:10),OpBar(4:11-4:12),Underscore(4:12-4:13),Comma(4:13-4:14),Underscore(4:15-4:16),OpBar(4:16-4:17),TripleDot(4:18-4:21), -EndOfFile(5:1-5:1), +LowerIdent(1:1-1:8),OpColon(1:9-1:10),LowerIdent(1:11-1:12),Comma(1:12-1:13),LowerIdent(1:14-1:15),OpArrow(1:16-1:18),LowerIdent(1:19-1:20),KwWhere(1:21-1:26),KwModule(1:27-1:33),NoSpaceOpenRound(1:33-1:34),LowerIdent(1:34-1:35),CloseRound(1:35-1:36),NoSpaceDotLowerIdent(1:36-1:44),OpColon(1:45-1:46),LowerIdent(1:47-1:48),OpArrow(1:49-1:51),LowerIdent(1:52-1:53),Comma(1:53-1:54),KwModule(1:55-1:61),NoSpaceOpenRound(1:61-1:62),LowerIdent(1:62-1:63),CloseRound(1:63-1:64),NoSpaceDotLowerIdent(1:64-1:74),OpColon(1:75-1:76),LowerIdent(1:77-1:78),OpArrow(1:79-1:81),LowerIdent(1:82-1:83), +LowerIdent(2:1-2:8),OpAssign(2:9-2:10),OpBar(2:11-2:12),Underscore(2:12-2:13),Comma(2:13-2:14),Underscore(2:15-2:16),OpBar(2:16-2:17),TripleDot(2:18-2:21), +EndOfFile(3:1-3:1), ~~~ # PARSE ~~~clojure -(file @1.1-4.21 - (module @1.1-1.17 - (exposes @1.8-1.17 - (exposed-lower-ident @1.9-1.16 - (text "process")))) +(file @1.1-2.21 + (type-module @1.1-1.8) (statements - (s-type-anno @3.1-3.83 (name "process") - (ty-fn @3.11-3.20 - (ty-var @3.11-3.12 (raw "a")) - (ty-var @3.14-3.15 (raw "b")) - (ty-var @3.19-3.20 (raw "c"))) + (s-type-anno @1.1-1.83 (name "process") + (ty-fn @1.11-1.20 + (ty-var @1.11-1.12 (raw "a")) + (ty-var @1.14-1.15 (raw "b")) + (ty-var @1.19-1.20 (raw "c"))) (where - (method @3.27-3.53 (module-of "a") (name "convert") + (method @1.27-1.53 (module-of "a") (name "convert") (args - (ty-var @3.47-3.48 (raw "a"))) - (ty-var @3.52-3.53 (raw "c"))) - (method @3.55-3.83 (module-of "b") (name "transform") + (ty-var @1.47-1.48 (raw "a"))) + (ty-var @1.52-1.53 (raw "c"))) + (method @1.55-1.83 (module-of "b") (name "transform") (args - (ty-var @3.77-3.78 (raw "b"))) - (ty-var @3.82-3.83 (raw "c"))))) - (s-decl @4.1-4.21 - (p-ident @4.1-4.8 (raw "process")) - (e-lambda @4.11-4.21 + (ty-var @1.77-1.78 (raw "b"))) + (ty-var @1.82-1.83 (raw "c"))))) + (s-decl @2.1-2.21 + (p-ident @2.1-2.8 (raw "process")) + (e-lambda @2.11-2.21 (args (p-underscore) (p-underscore)) @@ -59,40 +53,40 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @4.1-4.8 (ident "process")) - (e-lambda @4.11-4.21 + (p-assign @2.1-2.8 (ident "process")) + (e-lambda @2.11-2.21 (args - (p-underscore @4.12-4.13) - (p-underscore @4.15-4.16)) + (p-underscore @2.12-2.13) + (p-underscore @2.15-2.16)) (e-not-implemented @1.1-1.1)) - (annotation @4.1-4.8 + (annotation @2.1-2.8 (declared-type - (ty-fn @3.11-3.20 (effectful false) - (ty-var @3.11-3.12 (name "a")) - (ty-var @3.14-3.15 (name "b")) - (ty-var @3.19-3.20 (name "c")))))) - (s-type-anno @3.1-3.83 (name "process") - (ty-fn @3.11-3.20 (effectful false) - (ty-var @3.11-3.12 (name "a")) - (ty-var @3.14-3.15 (name "b")) - (ty-var @3.19-3.20 (name "c"))) + (ty-fn @1.11-1.20 (effectful false) + (ty-rigid-var @1.11-1.12 (name "a")) + (ty-rigid-var @1.14-1.15 (name "b")) + (ty-rigid-var @1.19-1.20 (name "c")))))) + (s-type-anno @1.1-1.83 (name "process") + (ty-fn @1.11-1.20 (effectful false) + (ty-rigid-var @1.11-1.12 (name "a")) + (ty-rigid-var @1.14-1.15 (name "b")) + (ty-rigid-var @1.19-1.20 (name "c"))) (where - (method @3.27-3.53 (module-of "a") (ident "convert") + (method @1.27-1.53 (module-of "a") (ident "convert") (args - (ty-var @3.47-3.48 (name "a"))) - (ty-var @3.52-3.53 (name "c"))) - (method @3.55-3.83 (module-of "b") (ident "transform") + (ty-rigid-var-lookup (ty-rigid-var @1.11-1.12 (name "a")))) + (ty-rigid-var-lookup (ty-rigid-var @1.19-1.20 (name "c")))) + (method @1.55-1.83 (module-of "b") (ident "transform") (args - (ty-var @3.77-3.78 (name "b"))) - (ty-var @3.82-3.83 (name "c"))))) - (ext-decl @3.27-3.53 (ident "module(a).convert") (kind "value")) - (ext-decl @3.55-3.83 (ident "module(b).transform") (kind "value"))) + (ty-rigid-var-lookup (ty-rigid-var @1.14-1.15 (name "b")))) + (ty-rigid-var-lookup (ty-rigid-var @1.19-1.20 (name "c")))))) + (ext-decl @1.27-1.53 (ident "module(a).convert") (kind "value")) + (ext-decl @1.55-1.83 (ident "module(b).transform") (kind "value"))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @4.1-4.8 (type "a, b -> c"))) + (patt @2.1-2.8 (type "a, b -> c"))) (expressions - (expr @4.11-4.21 (type "a, b -> c")))) + (expr @2.11-2.21 (type "a, b -> c")))) ~~~ diff --git a/test/snapshots/where_clause/where_clauses_multiline.md b/test/snapshots/where_clause/where_clauses_multiline.md index 8d175f6196..c50ead9785 100644 --- a/test/snapshots/where_clause/where_clauses_multiline.md +++ b/test/snapshots/where_clause/where_clauses_multiline.md @@ -1,12 +1,10 @@ # META ~~~ini description=Where clause with multiline constraints -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [process] - process : a, b -> c where module(a).convert : a -> c, @@ -19,38 +17,34 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:16),CloseSquare(1:16-1:17), -LowerIdent(3:1-3:8),OpColon(3:9-3:10),LowerIdent(3:11-3:12),Comma(3:12-3:13),LowerIdent(3:14-3:15),OpArrow(3:16-3:18),LowerIdent(3:19-3:20), -KwWhere(4:2-4:7), -KwModule(5:3-5:9),NoSpaceOpenRound(5:9-5:10),LowerIdent(5:10-5:11),CloseRound(5:11-5:12),NoSpaceDotLowerIdent(5:12-5:20),OpColon(5:21-5:22),LowerIdent(5:23-5:24),OpArrow(5:25-5:27),LowerIdent(5:28-5:29),Comma(5:29-5:30), -KwModule(6:3-6:9),NoSpaceOpenRound(6:9-6:10),LowerIdent(6:10-6:11),CloseRound(6:11-6:12),NoSpaceDotLowerIdent(6:12-6:22),OpColon(6:23-6:24),LowerIdent(6:25-6:26),OpArrow(6:27-6:29),LowerIdent(6:30-6:31), -LowerIdent(7:1-7:8),OpAssign(7:9-7:10),TripleDot(7:11-7:14), -EndOfFile(8:1-8:1), +LowerIdent(1:1-1:8),OpColon(1:9-1:10),LowerIdent(1:11-1:12),Comma(1:12-1:13),LowerIdent(1:14-1:15),OpArrow(1:16-1:18),LowerIdent(1:19-1:20), +KwWhere(2:2-2:7), +KwModule(3:3-3:9),NoSpaceOpenRound(3:9-3:10),LowerIdent(3:10-3:11),CloseRound(3:11-3:12),NoSpaceDotLowerIdent(3:12-3:20),OpColon(3:21-3:22),LowerIdent(3:23-3:24),OpArrow(3:25-3:27),LowerIdent(3:28-3:29),Comma(3:29-3:30), +KwModule(4:3-4:9),NoSpaceOpenRound(4:9-4:10),LowerIdent(4:10-4:11),CloseRound(4:11-4:12),NoSpaceDotLowerIdent(4:12-4:22),OpColon(4:23-4:24),LowerIdent(4:25-4:26),OpArrow(4:27-4:29),LowerIdent(4:30-4:31), +LowerIdent(5:1-5:8),OpAssign(5:9-5:10),TripleDot(5:11-5:14), +EndOfFile(6:1-6:1), ~~~ # PARSE ~~~clojure -(file @1.1-7.14 - (module @1.1-1.17 - (exposes @1.8-1.17 - (exposed-lower-ident @1.9-1.16 - (text "process")))) +(file @1.1-5.14 + (type-module @1.1-1.8) (statements - (s-type-anno @3.1-6.31 (name "process") - (ty-fn @3.11-3.20 - (ty-var @3.11-3.12 (raw "a")) - (ty-var @3.14-3.15 (raw "b")) - (ty-var @3.19-3.20 (raw "c"))) + (s-type-anno @1.1-4.31 (name "process") + (ty-fn @1.11-1.20 + (ty-var @1.11-1.12 (raw "a")) + (ty-var @1.14-1.15 (raw "b")) + (ty-var @1.19-1.20 (raw "c"))) (where - (method @5.3-5.29 (module-of "a") (name "convert") + (method @3.3-3.29 (module-of "a") (name "convert") (args - (ty-var @5.23-5.24 (raw "a"))) - (ty-var @5.28-5.29 (raw "c"))) - (method @6.3-6.31 (module-of "b") (name "transform") + (ty-var @3.23-3.24 (raw "a"))) + (ty-var @3.28-3.29 (raw "c"))) + (method @4.3-4.31 (module-of "b") (name "transform") (args - (ty-var @6.25-6.26 (raw "b"))) - (ty-var @6.30-6.31 (raw "c"))))) - (s-decl @7.1-7.14 - (p-ident @7.1-7.8 (raw "process")) + (ty-var @4.25-4.26 (raw "b"))) + (ty-var @4.30-4.31 (raw "c"))))) + (s-decl @5.1-5.14 + (p-ident @5.1-5.8 (raw "process")) (e-ellipsis)))) ~~~ # FORMATTED @@ -61,36 +55,36 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @7.1-7.8 (ident "process")) + (p-assign @5.1-5.8 (ident "process")) (e-not-implemented @1.1-1.1) - (annotation @7.1-7.8 + (annotation @5.1-5.8 (declared-type - (ty-fn @3.11-3.20 (effectful false) - (ty-var @3.11-3.12 (name "a")) - (ty-var @3.14-3.15 (name "b")) - (ty-var @3.19-3.20 (name "c")))))) - (s-type-anno @3.1-6.31 (name "process") - (ty-fn @3.11-3.20 (effectful false) - (ty-var @3.11-3.12 (name "a")) - (ty-var @3.14-3.15 (name "b")) - (ty-var @3.19-3.20 (name "c"))) + (ty-fn @1.11-1.20 (effectful false) + (ty-rigid-var @1.11-1.12 (name "a")) + (ty-rigid-var @1.14-1.15 (name "b")) + (ty-rigid-var @1.19-1.20 (name "c")))))) + (s-type-anno @1.1-4.31 (name "process") + (ty-fn @1.11-1.20 (effectful false) + (ty-rigid-var @1.11-1.12 (name "a")) + (ty-rigid-var @1.14-1.15 (name "b")) + (ty-rigid-var @1.19-1.20 (name "c"))) (where - (method @5.3-5.29 (module-of "a") (ident "convert") + (method @3.3-3.29 (module-of "a") (ident "convert") (args - (ty-var @5.23-5.24 (name "a"))) - (ty-var @5.28-5.29 (name "c"))) - (method @6.3-6.31 (module-of "b") (ident "transform") + (ty-rigid-var-lookup (ty-rigid-var @1.11-1.12 (name "a")))) + (ty-rigid-var-lookup (ty-rigid-var @1.19-1.20 (name "c")))) + (method @4.3-4.31 (module-of "b") (ident "transform") (args - (ty-var @6.25-6.26 (name "b"))) - (ty-var @6.30-6.31 (name "c"))))) - (ext-decl @5.3-5.29 (ident "module(a).convert") (kind "value")) - (ext-decl @6.3-6.31 (ident "module(b).transform") (kind "value"))) + (ty-rigid-var-lookup (ty-rigid-var @1.14-1.15 (name "b")))) + (ty-rigid-var-lookup (ty-rigid-var @1.19-1.20 (name "c")))))) + (ext-decl @3.3-3.29 (ident "module(a).convert") (kind "value")) + (ext-decl @4.3-4.31 (ident "module(b).transform") (kind "value"))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @7.1-7.8 (type "a, b -> c"))) + (patt @5.1-5.8 (type "a, b -> c"))) (expressions (expr @1.1-1.1 (type "a, b -> c")))) ~~~ diff --git a/test/snapshots/where_clause/where_clauses_serde_example.md b/test/snapshots/where_clause/where_clauses_serde_example.md index e0d3b27b62..14db0000d0 100644 --- a/test/snapshots/where_clause/where_clauses_serde_example.md +++ b/test/snapshots/where_clause/where_clauses_serde_example.md @@ -1,12 +1,10 @@ # META ~~~ini description=Module dispatch in where clause -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [deserialize] - deserialize : List(U8) -> Result(a, [DecodeErr]) where module(a).decode : List(U8) -> Result(a, [DecodeErr]) deserialize = |_| ... @@ -17,46 +15,42 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:20),CloseSquare(1:20-1:21), -LowerIdent(3:1-3:12),OpColon(3:13-3:14),UpperIdent(3:15-3:19),NoSpaceOpenRound(3:19-3:20),UpperIdent(3:20-3:22),CloseRound(3:22-3:23),OpArrow(3:24-3:26),UpperIdent(3:27-3:33),NoSpaceOpenRound(3:33-3:34),LowerIdent(3:34-3:35),Comma(3:35-3:36),OpenSquare(3:37-3:38),UpperIdent(3:38-3:47),CloseSquare(3:47-3:48),CloseRound(3:48-3:49), -KwWhere(4:2-4:7),KwModule(4:8-4:14),NoSpaceOpenRound(4:14-4:15),LowerIdent(4:15-4:16),CloseRound(4:16-4:17),NoSpaceDotLowerIdent(4:17-4:24),OpColon(4:25-4:26),UpperIdent(4:27-4:31),NoSpaceOpenRound(4:31-4:32),UpperIdent(4:32-4:34),CloseRound(4:34-4:35),OpArrow(4:36-4:38),UpperIdent(4:39-4:45),NoSpaceOpenRound(4:45-4:46),LowerIdent(4:46-4:47),Comma(4:47-4:48),OpenSquare(4:49-4:50),UpperIdent(4:50-4:59),CloseSquare(4:59-4:60),CloseRound(4:60-4:61), -LowerIdent(5:1-5:12),OpAssign(5:13-5:14),OpBar(5:15-5:16),Underscore(5:16-5:17),OpBar(5:17-5:18),TripleDot(5:19-5:22), -EndOfFile(6:1-6:1), +LowerIdent(1:1-1:12),OpColon(1:13-1:14),UpperIdent(1:15-1:19),NoSpaceOpenRound(1:19-1:20),UpperIdent(1:20-1:22),CloseRound(1:22-1:23),OpArrow(1:24-1:26),UpperIdent(1:27-1:33),NoSpaceOpenRound(1:33-1:34),LowerIdent(1:34-1:35),Comma(1:35-1:36),OpenSquare(1:37-1:38),UpperIdent(1:38-1:47),CloseSquare(1:47-1:48),CloseRound(1:48-1:49), +KwWhere(2:2-2:7),KwModule(2:8-2:14),NoSpaceOpenRound(2:14-2:15),LowerIdent(2:15-2:16),CloseRound(2:16-2:17),NoSpaceDotLowerIdent(2:17-2:24),OpColon(2:25-2:26),UpperIdent(2:27-2:31),NoSpaceOpenRound(2:31-2:32),UpperIdent(2:32-2:34),CloseRound(2:34-2:35),OpArrow(2:36-2:38),UpperIdent(2:39-2:45),NoSpaceOpenRound(2:45-2:46),LowerIdent(2:46-2:47),Comma(2:47-2:48),OpenSquare(2:49-2:50),UpperIdent(2:50-2:59),CloseSquare(2:59-2:60),CloseRound(2:60-2:61), +LowerIdent(3:1-3:12),OpAssign(3:13-3:14),OpBar(3:15-3:16),Underscore(3:16-3:17),OpBar(3:17-3:18),TripleDot(3:19-3:22), +EndOfFile(4:1-4:1), ~~~ # PARSE ~~~clojure -(file @1.1-5.22 - (module @1.1-1.21 - (exposes @1.8-1.21 - (exposed-lower-ident @1.9-1.20 - (text "deserialize")))) +(file @1.1-3.22 + (type-module @1.1-1.12) (statements - (s-type-anno @3.1-4.61 (name "deserialize") - (ty-fn @3.15-3.49 - (ty-apply @3.15-3.23 - (ty @3.15-3.19 (name "List")) - (ty @3.20-3.22 (name "U8"))) - (ty-apply @3.27-3.49 - (ty @3.27-3.33 (name "Result")) - (ty-var @3.34-3.35 (raw "a")) - (ty-tag-union @3.37-3.48 + (s-type-anno @1.1-2.61 (name "deserialize") + (ty-fn @1.15-1.49 + (ty-apply @1.15-1.23 + (ty @1.15-1.19 (name "List")) + (ty @1.20-1.22 (name "U8"))) + (ty-apply @1.27-1.49 + (ty @1.27-1.33 (name "Result")) + (ty-var @1.34-1.35 (raw "a")) + (ty-tag-union @1.37-1.48 (tags - (ty @3.38-3.47 (name "DecodeErr")))))) + (ty @1.38-1.47 (name "DecodeErr")))))) (where - (method @4.8-4.61 (module-of "a") (name "decode") + (method @2.8-2.61 (module-of "a") (name "decode") (args - (ty-apply @4.27-4.35 - (ty @4.27-4.31 (name "List")) - (ty @4.32-4.34 (name "U8")))) - (ty-apply @4.39-4.61 - (ty @4.39-4.45 (name "Result")) - (ty-var @4.46-4.47 (raw "a")) - (ty-tag-union @4.49-4.60 + (ty-apply @2.27-2.35 + (ty @2.27-2.31 (name "List")) + (ty @2.32-2.34 (name "U8")))) + (ty-apply @2.39-2.61 + (ty @2.39-2.45 (name "Result")) + (ty-var @2.46-2.47 (raw "a")) + (ty-tag-union @2.49-2.60 (tags - (ty @4.50-4.59 (name "DecodeErr")))))))) - (s-decl @5.1-5.22 - (p-ident @5.1-5.12 (raw "deserialize")) - (e-lambda @5.15-5.22 + (ty @2.50-2.59 (name "DecodeErr")))))))) + (s-decl @3.1-3.22 + (p-ident @3.1-3.12 (raw "deserialize")) + (e-lambda @3.15-3.22 (args (p-underscore)) (e-ellipsis))))) @@ -69,44 +63,44 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @5.1-5.12 (ident "deserialize")) - (e-lambda @5.15-5.22 + (p-assign @3.1-3.12 (ident "deserialize")) + (e-lambda @3.15-3.22 (args - (p-underscore @5.16-5.17)) + (p-underscore @3.16-3.17)) (e-not-implemented @1.1-1.1)) - (annotation @5.1-5.12 + (annotation @3.1-3.12 (declared-type - (ty-fn @3.15-3.49 (effectful false) - (ty-apply @3.15-3.23 (symbol "List") - (ty @3.20-3.22 (name "U8"))) - (ty-apply @3.27-3.49 (symbol "Result") - (ty-var @3.34-3.35 (name "a")) - (ty-tag-union @3.37-3.48 - (ty @3.38-3.47 (name "DecodeErr")))))))) - (s-type-anno @3.1-4.61 (name "deserialize") - (ty-fn @3.15-3.49 (effectful false) - (ty-apply @3.15-3.23 (symbol "List") - (ty @3.20-3.22 (name "U8"))) - (ty-apply @3.27-3.49 (symbol "Result") - (ty-var @3.34-3.35 (name "a")) - (ty-tag-union @3.37-3.48 - (ty @3.38-3.47 (name "DecodeErr"))))) + (ty-fn @1.15-1.49 (effectful false) + (ty-apply @1.15-1.23 (name "List") (builtin) + (ty-lookup @1.20-1.22 (name "U8") (builtin))) + (ty-apply @1.27-1.49 (name "Result") (local) + (ty-rigid-var @1.27-1.49 (name "a")) + (ty-tag-union @1.27-1.49 + (ty-tag-name @1.38-1.47 (name "DecodeErr")))))))) + (s-type-anno @1.1-2.61 (name "deserialize") + (ty-fn @1.15-1.49 (effectful false) + (ty-apply @1.15-1.23 (name "List") (builtin) + (ty-lookup @1.20-1.22 (name "U8") (builtin))) + (ty-apply @1.27-1.49 (name "Result") (local) + (ty-rigid-var @1.27-1.49 (name "a")) + (ty-tag-union @1.27-1.49 + (ty-tag-name @1.38-1.47 (name "DecodeErr"))))) (where - (method @4.8-4.61 (module-of "a") (ident "decode") + (method @2.8-2.61 (module-of "a") (ident "decode") (args - (ty-apply @4.27-4.35 (symbol "List") - (ty @4.32-4.34 (name "U8")))) - (ty-apply @4.39-4.61 (symbol "Result") - (ty-var @4.46-4.47 (name "a")) - (ty-tag-union @4.49-4.60 - (ty @4.50-4.59 (name "DecodeErr"))))))) - (ext-decl @4.8-4.61 (ident "module(a).decode") (kind "value"))) + (ty-apply @2.27-2.35 (name "List") (builtin) + (ty-lookup @2.32-2.34 (name "U8") (builtin)))) + (ty-apply @2.39-2.61 (name "Result") (local) + (ty-rigid-var-lookup (ty-rigid-var @1.27-1.49 (name "a"))) + (ty-tag-union @2.49-2.60 + (ty-tag-name @2.50-2.59 (name "DecodeErr"))))))) + (ext-decl @2.8-2.61 (ident "module(a).decode") (kind "value"))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @5.1-5.12 (type "List(U8) -> Result(a, [DecodeErr])"))) + (patt @3.1-3.12 (type "List(Num(Int(Unsigned8))) -> Result(a, [DecodeErr])"))) (expressions - (expr @5.15-5.22 (type "List(U8) -> Result(a, [DecodeErr])")))) + (expr @3.15-3.22 (type "List(Num(Int(Unsigned8))) -> Result(a, [DecodeErr])")))) ~~~ diff --git a/test/snapshots/where_clause/where_clauses_simple_dispatch.md b/test/snapshots/where_clause/where_clauses_simple_dispatch.md index 5f48d186ea..027df148c9 100644 --- a/test/snapshots/where_clause/where_clauses_simple_dispatch.md +++ b/test/snapshots/where_clause/where_clauses_simple_dispatch.md @@ -1,12 +1,10 @@ # META ~~~ini description=Simple where clause with single constraint -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [stringify] - stringify : a -> Str where module(a).to_str : a -> Str stringify = |value| value.to_str() ~~~ @@ -16,37 +14,33 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:18),CloseSquare(1:18-1:19), -LowerIdent(3:1-3:10),OpColon(3:11-3:12),LowerIdent(3:13-3:14),OpArrow(3:15-3:17),UpperIdent(3:18-3:21),KwWhere(3:22-3:27),KwModule(3:28-3:34),NoSpaceOpenRound(3:34-3:35),LowerIdent(3:35-3:36),CloseRound(3:36-3:37),NoSpaceDotLowerIdent(3:37-3:44),OpColon(3:45-3:46),LowerIdent(3:47-3:48),OpArrow(3:49-3:51),UpperIdent(3:52-3:55), -LowerIdent(4:1-4:10),OpAssign(4:11-4:12),OpBar(4:13-4:14),LowerIdent(4:14-4:19),OpBar(4:19-4:20),LowerIdent(4:21-4:26),NoSpaceDotLowerIdent(4:26-4:33),NoSpaceOpenRound(4:33-4:34),CloseRound(4:34-4:35), -EndOfFile(5:1-5:1), +LowerIdent(1:1-1:10),OpColon(1:11-1:12),LowerIdent(1:13-1:14),OpArrow(1:15-1:17),UpperIdent(1:18-1:21),KwWhere(1:22-1:27),KwModule(1:28-1:34),NoSpaceOpenRound(1:34-1:35),LowerIdent(1:35-1:36),CloseRound(1:36-1:37),NoSpaceDotLowerIdent(1:37-1:44),OpColon(1:45-1:46),LowerIdent(1:47-1:48),OpArrow(1:49-1:51),UpperIdent(1:52-1:55), +LowerIdent(2:1-2:10),OpAssign(2:11-2:12),OpBar(2:13-2:14),LowerIdent(2:14-2:19),OpBar(2:19-2:20),LowerIdent(2:21-2:26),NoSpaceDotLowerIdent(2:26-2:33),NoSpaceOpenRound(2:33-2:34),CloseRound(2:34-2:35), +EndOfFile(3:1-3:1), ~~~ # PARSE ~~~clojure -(file @1.1-4.35 - (module @1.1-1.19 - (exposes @1.8-1.19 - (exposed-lower-ident @1.9-1.18 - (text "stringify")))) +(file @1.1-2.35 + (type-module @1.1-1.10) (statements - (s-type-anno @3.1-3.55 (name "stringify") - (ty-fn @3.13-3.21 - (ty-var @3.13-3.14 (raw "a")) - (ty @3.18-3.21 (name "Str"))) + (s-type-anno @1.1-1.55 (name "stringify") + (ty-fn @1.13-1.21 + (ty-var @1.13-1.14 (raw "a")) + (ty @1.18-1.21 (name "Str"))) (where - (method @3.28-3.55 (module-of "a") (name "to_str") + (method @1.28-1.55 (module-of "a") (name "to_str") (args - (ty-var @3.47-3.48 (raw "a"))) - (ty @3.52-3.55 (name "Str"))))) - (s-decl @4.1-4.35 - (p-ident @4.1-4.10 (raw "stringify")) - (e-lambda @4.13-4.35 + (ty-var @1.47-1.48 (raw "a"))) + (ty @1.52-1.55 (name "Str"))))) + (s-decl @2.1-2.35 + (p-ident @2.1-2.10 (raw "stringify")) + (e-lambda @2.13-2.35 (args - (p-ident @4.14-4.19 (raw "value"))) - (e-field-access @4.21-4.35 - (e-ident @4.21-4.26 (raw "value")) - (e-apply @4.26-4.35 - (e-ident @4.26-4.33 (raw "to_str")))))))) + (p-ident @2.14-2.19 (raw "value"))) + (e-field-access @2.21-2.35 + (e-ident @2.21-2.26 (raw "value")) + (e-apply @2.26-2.35 + (e-ident @2.26-2.33 (raw "to_str")))))))) ~~~ # FORMATTED ~~~roc @@ -56,36 +50,36 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @4.1-4.10 (ident "stringify")) - (e-lambda @4.13-4.35 + (p-assign @2.1-2.10 (ident "stringify")) + (e-lambda @2.13-2.35 (args - (p-assign @4.14-4.19 (ident "value"))) - (e-dot-access @4.21-4.35 (field "to_str") + (p-assign @2.14-2.19 (ident "value"))) + (e-dot-access @2.21-2.35 (field "to_str") (receiver - (e-lookup-local @4.21-4.26 - (p-assign @4.14-4.19 (ident "value")))) + (e-lookup-local @2.21-2.26 + (p-assign @2.14-2.19 (ident "value")))) (args))) - (annotation @4.1-4.10 + (annotation @2.1-2.10 (declared-type - (ty-fn @3.13-3.21 (effectful false) - (ty-var @3.13-3.14 (name "a")) - (ty @3.18-3.21 (name "Str")))))) - (s-type-anno @3.1-3.55 (name "stringify") - (ty-fn @3.13-3.21 (effectful false) - (ty-var @3.13-3.14 (name "a")) - (ty @3.18-3.21 (name "Str"))) + (ty-fn @1.13-1.21 (effectful false) + (ty-rigid-var @1.13-1.14 (name "a")) + (ty-lookup @1.18-1.21 (name "Str") (builtin)))))) + (s-type-anno @1.1-1.55 (name "stringify") + (ty-fn @1.13-1.21 (effectful false) + (ty-rigid-var @1.13-1.14 (name "a")) + (ty-lookup @1.18-1.21 (name "Str") (builtin))) (where - (method @3.28-3.55 (module-of "a") (ident "to_str") + (method @1.28-1.55 (module-of "a") (ident "to_str") (args - (ty-var @3.47-3.48 (name "a"))) - (ty @3.52-3.55 (name "Str"))))) - (ext-decl @3.28-3.55 (ident "module(a).to_str") (kind "value"))) + (ty-rigid-var-lookup (ty-rigid-var @1.13-1.14 (name "a")))) + (ty-lookup @1.52-1.55 (name "Str") (builtin))))) + (ext-decl @1.28-1.55 (ident "module(a).to_str") (kind "value"))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @4.1-4.10 (type "a -> Str"))) + (patt @2.1-2.10 (type "a -> Str"))) (expressions - (expr @4.13-4.35 (type "a -> Str")))) + (expr @2.13-2.35 (type "a -> Str")))) ~~~ diff --git a/test/snapshots/where_clause/where_clauses_type_annotation.md b/test/snapshots/where_clause/where_clauses_type_annotation.md index a3a1027f05..d9ec7d411f 100644 --- a/test/snapshots/where_clause/where_clauses_type_annotation.md +++ b/test/snapshots/where_clause/where_clauses_type_annotation.md @@ -1,12 +1,10 @@ # META ~~~ini description=Simple type annotation with where clause -type=file +type=snippet ~~~ # SOURCE ~~~roc -module [convert] - convert : a -> b where module(a).to_b : a -> b convert = |a| a.to_b() ~~~ @@ -16,37 +14,33 @@ NIL NIL # TOKENS ~~~zig -KwModule(1:1-1:7),OpenSquare(1:8-1:9),LowerIdent(1:9-1:16),CloseSquare(1:16-1:17), -LowerIdent(3:1-3:8),OpColon(3:9-3:10),LowerIdent(3:11-3:12),OpArrow(3:13-3:15),LowerIdent(3:16-3:17),KwWhere(3:18-3:23),KwModule(3:24-3:30),NoSpaceOpenRound(3:30-3:31),LowerIdent(3:31-3:32),CloseRound(3:32-3:33),NoSpaceDotLowerIdent(3:33-3:38),OpColon(3:39-3:40),LowerIdent(3:41-3:42),OpArrow(3:43-3:45),LowerIdent(3:46-3:47), -LowerIdent(4:1-4:8),OpAssign(4:9-4:10),OpBar(4:11-4:12),LowerIdent(4:12-4:13),OpBar(4:13-4:14),LowerIdent(4:15-4:16),NoSpaceDotLowerIdent(4:16-4:21),NoSpaceOpenRound(4:21-4:22),CloseRound(4:22-4:23), -EndOfFile(5:1-5:1), +LowerIdent(1:1-1:8),OpColon(1:9-1:10),LowerIdent(1:11-1:12),OpArrow(1:13-1:15),LowerIdent(1:16-1:17),KwWhere(1:18-1:23),KwModule(1:24-1:30),NoSpaceOpenRound(1:30-1:31),LowerIdent(1:31-1:32),CloseRound(1:32-1:33),NoSpaceDotLowerIdent(1:33-1:38),OpColon(1:39-1:40),LowerIdent(1:41-1:42),OpArrow(1:43-1:45),LowerIdent(1:46-1:47), +LowerIdent(2:1-2:8),OpAssign(2:9-2:10),OpBar(2:11-2:12),LowerIdent(2:12-2:13),OpBar(2:13-2:14),LowerIdent(2:15-2:16),NoSpaceDotLowerIdent(2:16-2:21),NoSpaceOpenRound(2:21-2:22),CloseRound(2:22-2:23), +EndOfFile(3:1-3:1), ~~~ # PARSE ~~~clojure -(file @1.1-4.23 - (module @1.1-1.17 - (exposes @1.8-1.17 - (exposed-lower-ident @1.9-1.16 - (text "convert")))) +(file @1.1-2.23 + (type-module @1.1-1.8) (statements - (s-type-anno @3.1-3.47 (name "convert") - (ty-fn @3.11-3.17 - (ty-var @3.11-3.12 (raw "a")) - (ty-var @3.16-3.17 (raw "b"))) + (s-type-anno @1.1-1.47 (name "convert") + (ty-fn @1.11-1.17 + (ty-var @1.11-1.12 (raw "a")) + (ty-var @1.16-1.17 (raw "b"))) (where - (method @3.24-3.47 (module-of "a") (name "to_b") + (method @1.24-1.47 (module-of "a") (name "to_b") (args - (ty-var @3.41-3.42 (raw "a"))) - (ty-var @3.46-3.47 (raw "b"))))) - (s-decl @4.1-4.23 - (p-ident @4.1-4.8 (raw "convert")) - (e-lambda @4.11-4.23 + (ty-var @1.41-1.42 (raw "a"))) + (ty-var @1.46-1.47 (raw "b"))))) + (s-decl @2.1-2.23 + (p-ident @2.1-2.8 (raw "convert")) + (e-lambda @2.11-2.23 (args - (p-ident @4.12-4.13 (raw "a"))) - (e-field-access @4.15-4.23 - (e-ident @4.15-4.16 (raw "a")) - (e-apply @4.16-4.23 - (e-ident @4.16-4.21 (raw "to_b")))))))) + (p-ident @2.12-2.13 (raw "a"))) + (e-field-access @2.15-2.23 + (e-ident @2.15-2.16 (raw "a")) + (e-apply @2.16-2.23 + (e-ident @2.16-2.21 (raw "to_b")))))))) ~~~ # FORMATTED ~~~roc @@ -56,36 +50,36 @@ NO CHANGE ~~~clojure (can-ir (d-let - (p-assign @4.1-4.8 (ident "convert")) - (e-lambda @4.11-4.23 + (p-assign @2.1-2.8 (ident "convert")) + (e-lambda @2.11-2.23 (args - (p-assign @4.12-4.13 (ident "a"))) - (e-dot-access @4.15-4.23 (field "to_b") + (p-assign @2.12-2.13 (ident "a"))) + (e-dot-access @2.15-2.23 (field "to_b") (receiver - (e-lookup-local @4.15-4.16 - (p-assign @4.12-4.13 (ident "a")))) + (e-lookup-local @2.15-2.16 + (p-assign @2.12-2.13 (ident "a")))) (args))) - (annotation @4.1-4.8 + (annotation @2.1-2.8 (declared-type - (ty-fn @3.11-3.17 (effectful false) - (ty-var @3.11-3.12 (name "a")) - (ty-var @3.16-3.17 (name "b")))))) - (s-type-anno @3.1-3.47 (name "convert") - (ty-fn @3.11-3.17 (effectful false) - (ty-var @3.11-3.12 (name "a")) - (ty-var @3.16-3.17 (name "b"))) + (ty-fn @1.11-1.17 (effectful false) + (ty-rigid-var @1.11-1.12 (name "a")) + (ty-rigid-var @1.16-1.17 (name "b")))))) + (s-type-anno @1.1-1.47 (name "convert") + (ty-fn @1.11-1.17 (effectful false) + (ty-rigid-var @1.11-1.12 (name "a")) + (ty-rigid-var @1.16-1.17 (name "b"))) (where - (method @3.24-3.47 (module-of "a") (ident "to_b") + (method @1.24-1.47 (module-of "a") (ident "to_b") (args - (ty-var @3.41-3.42 (name "a"))) - (ty-var @3.46-3.47 (name "b"))))) - (ext-decl @3.24-3.47 (ident "module(a).to_b") (kind "value"))) + (ty-rigid-var-lookup (ty-rigid-var @1.11-1.12 (name "a")))) + (ty-rigid-var-lookup (ty-rigid-var @1.16-1.17 (name "b")))))) + (ext-decl @1.24-1.47 (ident "module(a).to_b") (kind "value"))) ~~~ # TYPES ~~~clojure (inferred-types (defs - (patt @4.1-4.8 (type "a -> b"))) + (patt @2.1-2.8 (type "a -> b"))) (expressions - (expr @4.11-4.23 (type "a -> b")))) + (expr @2.11-2.23 (type "a -> b")))) ~~~ diff --git a/typos.toml b/typos.toml index 28824fe5bc..e27c97fe9f 100644 --- a/typos.toml +++ b/typos.toml @@ -10,6 +10,7 @@ extend-exclude = [ "crates/compiler/checkmate/www/package-lock.json", "src/build/zig_llvm.h", "test/snapshots/", + "build.zig.zon", ] [default]