Merge remote-tracking branch 'origin/main' into import-syntax

Author: rtfeldman

.github/workflows/ci_zig.yml

@@ -144,13 +144,20 @@ jobs:
       - name: zig snapshot tests
         run: zig build snapshot -- --debug
 
-      - name: build tests and repro executables
+      - name: build and execute tests, 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: Build and execute tests, build repro executables. All in release mode.
+        uses: ./.github/actions/flaky-retry
+        with:
+          command: 'zig build test -Doptimize=ReleaseFast -Dfuzz -Dsystem-afl=false'
+          error_string_contains: 'double roundtrip bundle'
+          retry_count: 3
+
       - name: Check for snapshot changes
         run: |
           git diff --exit-code test/snapshots || {

.github/workflows/nightly_new_compiler_all_os.yml

@@ -77,20 +77,58 @@ jobs:
           SHA: ${{ env.SHA }}
         run: echo "RELEASE_FOLDER_NAME=new_roc_nightly-${{ matrix.artifact_name }}-$DATE-$SHA" >> $GITHUB_ENV
 
-      - name: Package release (Unix)
+      - name: Package release
         run: |
           mkdir -p ${{ env.RELEASE_FOLDER_NAME }}
           cp ./zig-out/bin/roc ${{ env.RELEASE_FOLDER_NAME }}/
           cp LICENSE legal_details ${{ env.RELEASE_FOLDER_NAME }}/
-          tar -czvf "${{ env.RELEASE_FOLDER_NAME }}.tar.gz" ${{ env.RELEASE_FOLDER_NAME }}
 
-      - name: Calculate archive hash for security purposes
-        shell: bash
+      - name: Compress release (Unix)
+        if: runner.os != 'Windows'
+        run: tar -czvf "${{ env.RELEASE_FOLDER_NAME }}.tar.gz" ${{ env.RELEASE_FOLDER_NAME }}
+
+      - name: Compress release (Windows)
+        if: runner.os == 'Windows'
+        run: 7z a -tzip "${{ env.RELEASE_FOLDER_NAME }}.zip" ${{ env.RELEASE_FOLDER_NAME }}
+
+      - name: Calculate archive hash for security purposes (Unix)
+        if: runner.os != 'Windows'
         run: sha256sum ${{ env.RELEASE_FOLDER_NAME }}.tar.gz
 
-      - name: Upload roc nightly tar
+      - name: Calculate archive hash for security purposes (Windows)
+        if: runner.os == 'Windows'
+        run: sha256sum ${{ env.RELEASE_FOLDER_NAME }}.zip
+
+      - name: Upload roc nightly archive (Unix)
+        if: runner.os != 'Windows'
         uses: actions/upload-artifact@v4
         with:
           name: ${{ env.RELEASE_FOLDER_NAME }}.tar.gz
           path: ${{ env.RELEASE_FOLDER_NAME }}.tar.gz
           retention-days: 4
+
+      - name: Upload roc nightly archive (Windows)
+        if: runner.os == 'Windows'
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ env.RELEASE_FOLDER_NAME }}.zip
+          path: ${{ env.RELEASE_FOLDER_NAME }}.zip
+          retention-days: 4
+
+      - name: Clean workspace for test
+        run: |
+          find . -mindepth 1 -maxdepth 1 ! -name "${{ env.RELEASE_FOLDER_NAME }}.tar.gz" ! -name "${{ env.RELEASE_FOLDER_NAME }}.zip" ! -name "src" -exec rm -rf {} +
+          find src -mindepth 1 ! -path "src/PROFILING*" -exec rm -rf {} +
+          find src/PROFILING -mindepth 1 ! -name "bench_repeated_check.roc" -exec rm -rf {} +
+
+      - name: Test archive (Unix)
+        if: runner.os != 'Windows'
+        run: |
+          tar -xzf "${{ env.RELEASE_FOLDER_NAME }}.tar.gz"
+          ./${{ env.RELEASE_FOLDER_NAME }}/roc check src/PROFILING/bench_repeated_check.roc
+
+      - name: Test archive (Windows)
+        if: runner.os == 'Windows'
+        run: |
+          7z x "${{ env.RELEASE_FOLDER_NAME }}.zip"
+          ./${{ env.RELEASE_FOLDER_NAME }}/roc check src/PROFILING/bench_repeated_check.roc

build.zig

@@ -614,27 +614,28 @@ 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 });
+    const builtin_roc_path = try b.build_root.join(b.allocator, &.{ "src", "build", "roc" });
+    var builtin_roc_dir = try std.fs.openDirAbsolute(builtin_roc_path, .{ .iterate = true });
     defer builtin_roc_dir.close();
 
-    var roc_files = std.array_list.Managed([]const u8).init(b.allocator);
-    errdefer roc_files.deinit();
+    var roc_files = std.ArrayList([]const u8).empty;
+    errdefer roc_files.deinit(b.allocator);
 
     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);
+            try roc_files.append(b.allocator, full_path);
         }
     }
 
-    return roc_files.toOwnedSlice();
+    return roc_files.toOwnedSlice(b.allocator);
 }
 
 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();
+    var builtins_source = std.ArrayList(u8).empty;
+    errdefer builtins_source.deinit(b.allocator);
+    const writer = builtins_source.writer(b.allocator);
 
     for (roc_files) |roc_path| {
         const roc_basename = std.fs.path.basename(roc_path);
@@ -651,7 +652,7 @@ fn generateCompiledBuiltinsSource(b: *std.Build, roc_files: []const []const u8)
     // Also embed builtin_indices.bin
     try writer.writeAll("pub const builtin_indices_bin = @embedFile(\"builtin_indices.bin\");\n");
 
-    return builtins_source.toOwnedSlice();
+    return builtins_source.toOwnedSlice(b.allocator);
 }
 
 fn add_fuzz_target(
@@ -748,7 +749,7 @@ fn addMainExe(
             .root_source_file = b.path("test/str/platform/host.zig"),
             .target = target,
             .optimize = optimize,
-            .strip = true,
+            .strip = optimize != .Debug,
             .pic = true, // Enable Position Independent Code for PIE compatibility
         }),
     });
@@ -772,7 +773,7 @@ fn addMainExe(
             .root_source_file = b.path("test/int/platform/host.zig"),
             .target = target,
             .optimize = optimize,
-            .strip = true,
+            .strip = optimize != .Debug,
             .pic = true, // Enable Position Independent Code for PIE compatibility
         }),
     });
@@ -805,7 +806,7 @@ fn addMainExe(
                 .root_source_file = b.path("test/int/platform/host.zig"),
                 .target = cross_resolved_target,
                 .optimize = optimize,
-                .strip = true,
+                .strip = optimize != .Debug,
                 .pic = true,
             }),
             .linkage = .static,
@@ -850,7 +851,7 @@ fn addMainExe(
             .root_source_file = b.path("src/interpreter_shim/main.zig"),
             .target = target,
             .optimize = optimize,
-            .strip = true,
+            .strip = optimize != .Debug,
             .pic = true, // Enable Position Independent Code for PIE compatibility
         }),
         .linkage = .static,
@@ -928,13 +929,13 @@ const ParsedBuildArgs = struct {
 };
 
 fn appendFilter(
-    list: *std.array_list.Managed([]const u8),
+    list: *std.ArrayList([]const u8),
     b: *std.Build,
     value: []const u8,
 ) void {
     const trimmed = std.mem.trim(u8, value, " \t\n\r");
     if (trimmed.len == 0) return;
-    list.append(b.dupe(trimmed)) catch @panic("OOM while parsing --test-filter value");
+    list.append(b.allocator, b.dupe(trimmed)) catch @panic("OOM while parsing --test-filter value");
 }
 
 fn parseBuildArgs(b: *std.Build) ParsedBuildArgs {
@@ -943,8 +944,8 @@ fn parseBuildArgs(b: *std.Build) ParsedBuildArgs {
         .test_filters = &.{},
     };
 
-    var run_args_list = std.array_list.Managed([]const u8).init(b.allocator);
-    var filter_list = std.array_list.Managed([]const u8).init(b.allocator);
+    var run_args_list = std.ArrayList([]const u8).empty;
+    var filter_list = std.ArrayList([]const u8).empty;
 
     var i: usize = 0;
     while (i < raw_args.len) {
@@ -969,12 +970,12 @@ fn parseBuildArgs(b: *std.Build) ParsedBuildArgs {
             continue;
         }
 
-        run_args_list.append(arg) catch @panic("OOM while recording build arguments");
+        run_args_list.append(b.allocator, arg) catch @panic("OOM while recording build arguments");
         i += 1;
     }
 
-    const run_args = run_args_list.toOwnedSlice() catch @panic("OOM while finalizing build arguments");
-    const test_filters = filter_list.toOwnedSlice() catch @panic("OOM while finalizing test filters");
+    const run_args = run_args_list.toOwnedSlice(b.allocator) catch @panic("OOM while finalizing build arguments");
+    const test_filters = filter_list.toOwnedSlice(b.allocator) catch @panic("OOM while finalizing test filters");
 
     return .{ .run_args = run_args, .test_filters = test_filters };
 }
@@ -1398,10 +1399,10 @@ fn getCompilerVersion(b: *std.Build, optimize: OptimizeMode) []const u8 {
 fn generateGlibcStub(b: *std.Build, target: ResolvedTarget, target_name: []const u8) ?*Step.UpdateSourceFiles {
 
     // Generate assembly stub with comprehensive symbols using the new build module
-    var assembly_buf = std.array_list.Managed(u8).init(b.allocator);
-    defer assembly_buf.deinit();
+    var assembly_buf = std.ArrayList(u8).empty;
+    defer assembly_buf.deinit(b.allocator);
 
-    const writer = assembly_buf.writer();
+    const writer = assembly_buf.writer(b.allocator);
     const target_arch = target.result.cpu.arch;
     const target_abi = target.result.abi;
 

crates/compiler/builtins/roc/Str.roc

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

src/base/Ident.zig

@@ -602,13 +602,13 @@ test "Ident.Store comprehensive CompactWriter roundtrip" {
         .{ .text = "hello", .expected_idx = 1 }, // duplicate, should reuse
     };
 
-    var indices = std.array_list.Managed(Ident.Idx).init(gpa);
-    defer indices.deinit();
+    var indices = std.ArrayList(Ident.Idx).empty;
+    defer indices.deinit(gpa);
 
     for (test_idents) |test_ident| {
         const ident = Ident.for_text(test_ident.text);
         const idx = try original.insert(gpa, ident);
-        try indices.append(idx);
+        try indices.append(gpa, idx);
         // Verify the index matches expectation
         try std.testing.expectEqual(test_ident.expected_idx, idx.idx);
     }

src/base/Scratch.zig

@@ -24,10 +24,20 @@ pub fn Scratch(comptime T: type) type {
         }
 
         /// Returns the start position for a new Span of indexes in scratch
-        pub fn top(self: *Self) u32 {
+        pub fn top(self: *const Self) u32 {
             return @as(u32, @intCast(self.items.items.len));
         }
 
+        /// Check if a value is in the array
+        pub fn contains(self: *const Self, val: T) bool {
+            for (self.items.items) |item| {
+                if (item == val) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
         /// Places a new index of type `T` in the scratch
         pub fn append(self: *Self, idx: T) std.mem.Allocator.Error!void {
             try self.items.append(idx);
@@ -48,6 +58,25 @@ pub fn Scratch(comptime T: type) type {
             return self.items.items[@intCast(start)..];
         }
 
+        /// Creates slice from the provided start index
+        pub fn sliceFromSpan(self: *Self, span: DataSpan) []T {
+            const start: usize = @intCast(span.start);
+            const end: usize = @intCast(span.start + span.len);
+
+            std.debug.assert(start <= end);
+            std.debug.assert(end <= self.items.items.len);
+
+            return self.items.items[start..end];
+        }
+
+        /// Creates span from the provided start index to the end of the list
+        pub fn spanFrom(self: *Self, start: u32) DataSpan {
+            return DataSpan{
+                .start = start,
+                .len = @as(u32, @intCast(self.items.items.len)) - start,
+            };
+        }
+
         /// Creates a new span starting at start.  Moves the items from scratch
         /// to extra_data as appropriate.
         pub fn spanFromStart(self: *Self, start: u32, data: *std.array_list.Managed(u32)) std.mem.Allocator.Error!DataSpan {

src/base/SmallStringInterner.zig

@@ -305,12 +305,12 @@ test "SmallStringInterner basic CompactWriter roundtrip" {
         "duplicate", // Should reuse the same index
     };
 
-    var indices = std.array_list.Managed(SmallStringInterner.Idx).init(gpa);
-    defer indices.deinit();
+    var indices = std.ArrayList(SmallStringInterner.Idx).empty;
+    defer indices.deinit(gpa);
 
     for (test_strings) |str| {
         const idx = try original.insert(gpa, str);
-        try indices.append(idx);
+        try indices.append(gpa, idx);
     }
 
     // Verify duplicate detection worked
@@ -507,12 +507,12 @@ test "SmallStringInterner edge cases CompactWriter roundtrip" {
         " start_with_space",
     };
 
-    var indices = std.array_list.Managed(SmallStringInterner.Idx).init(gpa);
-    defer indices.deinit();
+    var indices = std.ArrayList(SmallStringInterner.Idx).empty;
+    defer indices.deinit(gpa);
 
     for (edge_cases) |str| {
         const idx = try original.insert(gpa, str);
-        try indices.append(idx);
+        try indices.append(gpa, idx);
     }
 
     // Create a temp file

src/base/StringLiteral.zig

@@ -257,12 +257,12 @@ test "Store comprehensive CompactWriter roundtrip" {
         "very long string " ** 50, // long string
     };
 
-    var indices = std.array_list.Managed(Idx).init(gpa);
-    defer indices.deinit();
+    var indices = std.ArrayList(Idx).empty;
+    defer indices.deinit(gpa);
 
     for (test_strings) |str| {
         const idx = try original.insert(gpa, str);
-        try indices.append(idx);
+        try indices.append(gpa, idx);
     }
 
     // Create a temp file

src/build/builtin_compiler/main.zig

@@ -236,12 +236,12 @@ fn compileModule(
 
     // 6. Type check
     // Build the list of other modules for type checking
-    var imported_envs = std.array_list.Managed(*const ModuleEnv).init(gpa);
-    defer imported_envs.deinit();
+    var imported_envs = std.ArrayList(*const ModuleEnv).empty;
+    defer imported_envs.deinit(gpa);
 
     // Add dependencies
     for (deps) |dep| {
-        try imported_envs.append(dep.env);
+        try imported_envs.append(gpa, dep.env);
     }
 
     var checker = try Check.init(

src/build/modules.zig

@@ -41,16 +41,16 @@ fn extendWithAggregatorFilters(
     const extras = aggregatorFilters(module_type);
     if (extras.len == 0) return base;
 
-    var list = std.array_list.Managed([]const u8).init(b.allocator);
-    list.ensureTotalCapacity(base.len + extras.len) catch @panic("OOM while extending module test filters");
-    list.appendSlice(base) catch @panic("OOM while extending module test filters");
+    var list = std.ArrayList([]const u8).empty;
+    list.ensureTotalCapacity(b.allocator, base.len + extras.len) catch @panic("OOM while extending module test filters");
+    list.appendSlice(b.allocator, base) catch @panic("OOM while extending module test filters");
 
     for (extras) |extra| {
         if (filtersContain(base, extra)) continue;
-        list.append(b.dupe(extra)) catch @panic("OOM while extending module test filters");
+        list.append(b.allocator, b.dupe(extra)) catch @panic("OOM while extending module test filters");
     }
 
-    return list.toOwnedSlice() catch @panic("OOM while finalizing module test filters");
+    return list.toOwnedSlice(b.allocator) catch @panic("OOM while finalizing module test filters");
 }
 
 /// Represents a test module with its compilation and execution steps.