Dynamically get platform entrypoints

build.zig

@@ -627,6 +627,43 @@ pub fn build(b: *std.Build) void {
     const is_native = target.query.isNativeCpu() and target.query.isNativeOs() and (target.query.isNativeAbi() or target.result.abi.isMusl());
     const is_windows = target.result.os.tag == .windows;
 
+    // fx platform effectful functions test - only run when not cross-compiling
+    if (target.query.isNativeCpu() and target.query.isNativeOs() and target.query.isNativeAbi()) {
+        // Create fx test platform host static library
+        const test_platform_fx_host_lib = createTestPlatformHostLib(
+            b,
+            "test_platform_fx_host",
+            "test/fx/platform/host.zig",
+            target,
+            optimize,
+            roc_modules,
+        );
+
+        // Copy the fx test platform host library to the source directory
+        const copy_test_fx_host = b.addUpdateSourceFiles();
+        const test_fx_host_filename = if (target.result.os.tag == .windows) "host.lib" else "libhost.a";
+        copy_test_fx_host.addCopyFileToSource(test_platform_fx_host_lib.getEmittedBin(), b.pathJoin(&.{ "test/fx/platform", test_fx_host_filename }));
+        b.getInstallStep().dependOn(&copy_test_fx_host.step);
+
+        const fx_platform_test = b.addTest(.{
+            .name = "fx_platform_test",
+            .root_module = b.createModule(.{
+                .root_source_file = b.path("src/cli/test/fx_platform_test.zig"),
+                .target = target,
+                .optimize = optimize,
+            }),
+            .filters = test_filters,
+        });
+
+        const run_fx_platform_test = b.addRunArtifact(fx_platform_test);
+        if (run_args.len != 0) {
+            run_fx_platform_test.addArgs(run_args);
+        }
+        // Ensure host library is copied before running the test
+        run_fx_platform_test.step.dependOn(&copy_test_fx_host.step);
+        tests_summary.addRun(&run_fx_platform_test.step);
+    }
+
     var build_afl = false;
     if (!is_native) {
         std.log.warn("Cross compilation does not support fuzzing (Only building repro executables)", .{});
@@ -864,6 +901,21 @@ fn addMainExe(
         copy_cross_int_host.addCopyFileToSource(cross_int_host_lib.getEmittedBin(), b.pathJoin(&.{ "test/int/platform/targets", cross_target.name, "libhost.a" }));
         b.getInstallStep().dependOn(&copy_cross_int_host.step);
 
+        // Create cross-compiled str host library
+        const cross_str_host_lib = createTestPlatformHostLib(
+            b,
+            b.fmt("test_platform_str_host_{s}", .{cross_target.name}),
+            "test/str/platform/host.zig",
+            cross_resolved_target,
+            optimize,
+            roc_modules,
+        );
+
+        // Copy to target-specific directory
+        const copy_cross_str_host = b.addUpdateSourceFiles();
+        copy_cross_str_host.addCopyFileToSource(cross_str_host_lib.getEmittedBin(), b.pathJoin(&.{ "test/str/platform/targets", cross_target.name, "libhost.a" }));
+        b.getInstallStep().dependOn(&copy_cross_str_host.step);
+
         // Generate glibc stubs for gnu targets
         if (cross_target.query.abi == .gnu) {
             const glibc_stub = generateGlibcStub(b, cross_resolved_target, cross_target.name);

src/build/builtin_compiler/main.zig

@@ -701,7 +701,7 @@ fn compileModule(
     }
 
     // When compiling Builtin itself, pass null for module_envs so setupAutoImportedBuiltinTypes doesn't run
-    can_result.* = try Can.init(module_env, parse_ast, null);
+    can_result.* = try Can.init(module_env, parse_ast, null, false);
 
     try can_result.canonicalizeFile();
     try can_result.validateForChecking();

src/builtins/host_abi.zig

@@ -32,6 +32,19 @@ pub const RocCall = fn (
 ///
 /// This is used in both calls from actual hosts as well as evaluation of constants
 /// inside the Roc compiler itself.
+/// Function pointer type for hosted functions provided by the platform.
+/// All hosted functions follow the RocCall ABI: (ops, ret_ptr, args_ptr).
+pub const HostedFn = *const fn (*RocOps, *anyopaque, *anyopaque) callconv(.c) void;
+
+/// Array of hosted function pointers provided by the platform.
+/// These are sorted alphabetically by function name during canonicalization.
+pub const HostedFunctions = extern struct {
+    count: u32,
+    fns: [*]HostedFn,
+};
+
+/// Operations that the host provides to Roc code, including memory management,
+/// panic handling, and platform-specific effects.
 pub const RocOps = extern struct {
     /// The host provides this pointer, and Roc passes it to each of the following
     /// function pointers as a second argument. This lets the host do things like use
@@ -51,10 +64,9 @@ pub const RocOps = extern struct {
     /// Called when the Roc program crashes, e.g. due to integer overflow.
     /// The host should handle this gracefully and stop execution of the Roc program.
     roc_crashed: *const fn (*const RocCrashed, *anyopaque) callconv(.c) void,
-    /// At the end of this struct, the host must include all the functions
-    /// it wants to provide to the Roc program for the Roc program to call
-    /// (e.g. I/O operations and such).
-    host_fns: *anyopaque,
+    /// Hosted functions provided by the platform (sorted alphabetically by name).
+    /// These are effectful operations like I/O that the platform provides to Type Modules.
+    hosted_fns: HostedFunctions,
 
     /// Helper function to crash the Roc program, returns control to the host.
     pub fn crash(self: *RocOps, msg: []const u8) void {

src/builtins/utils.zig

@@ -50,7 +50,7 @@ pub const TestEnv = struct {
                 .roc_dbg = rocDbgFn,
                 .roc_expect_failed = rocExpectFailedFn,
                 .roc_crashed = rocCrashedFn,
-                .host_fns = undefined, // No host functions in tests
+                .hosted_fns = .{ .count = 0, .fns = undefined }, // No host functions in tests
             };
         }
         return &self.ops.?;