Dynamically get entrypoints

Author: rtfeldman

build.zig

@@ -547,6 +547,25 @@ pub fn build(b: *std.Build) void {
         tests_summary.addRun(&run_roc_subcommands_test.step);
     }
 
+    // fx platform effectful functions test
+    {
+        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);
+        }
+        tests_summary.addRun(&run_fx_platform_test.step);
+    }
+
     // Add watch tests
     const enable_watch_tests = b.option(bool, "watch-tests", "Enable watch tests") orelse true;
     if (enable_watch_tests) {
@@ -809,6 +828,22 @@ fn addMainExe(
     copy_test_int_host.addCopyFileToSource(test_platform_int_host_lib.getEmittedBin(), b.pathJoin(&.{ "test/int/platform", test_int_host_filename }));
     b.getInstallStep().dependOn(&copy_test_int_host.step);
 
+    // Create test platform host static library (fx) - native target
+    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);
+
     // Cross-compile int platform host libraries for musl and glibc targets
     const cross_compile_targets = [_]struct { name: []const u8, query: std.Target.Query }{
         .{ .name = "x64musl", .query = .{ .cpu_arch = .x86_64, .os_tag = .linux, .abi = .musl } },

src/cli/app_stub.zig

@@ -176,22 +176,6 @@ fn addRocCallAbiStub(
     try wip.finish();
 }
 
-/// Get the expected app entrypoints for known test platforms based on host.zig files
-pub fn getTestPlatformEntrypoints(allocator: Allocator, platform_type: []const u8) ![]PlatformEntrypoint {
-    if (std.mem.eql(u8, platform_type, "int")) {
-        // Based on test/int/platform/host.zig:
-        // extern fn roc__addInts(ops: *builtins.host_abi.RocOps, ret_ptr: *anyopaque, arg_ptr: ?*anyopaque) callconv(.c) void;
-        // extern fn roc__multiplyInts(ops: *builtins.host_abi.RocOps, ret_ptr: *anyopaque, arg_ptr: ?*anyopaque) callconv(.c) void;
-        const entrypoints = try allocator.alloc(PlatformEntrypoint, 2);
-        entrypoints[0] = PlatformEntrypoint{ .name = "addInts" };
-        entrypoints[1] = PlatformEntrypoint{ .name = "multiplyInts" };
-        return entrypoints;
-    }
-
-    // Only int platform supported for cross-compilation
-    return error.PlatformNotSupported;
-}
-
 /// Detect platform type from file path
 pub fn detectPlatformType(platform_path: []const u8) []const u8 {
     // Use cross-platform path checking

src/cli/main.zig

@@ -2166,35 +2166,15 @@ fn rocBuild(allocs: *Allocators, args: cli_args.BuildArgs) !void {
         },
     }
 
-    // Only support int test platform for cross-compilation
-    // Check if path contains "int" directory using cross-platform path handling
-    const path_contains_int = blk: {
-        var iter = std.fs.path.componentIterator(args.path) catch break :blk false;
-        while (iter.next()) |component| {
-            if (std.mem.eql(u8, component.name, "int")) {
-                break :blk true;
-            }
-        }
-        break :blk false;
-    };
-
-    const platform_type = if (path_contains_int)
-        "int"
-    else {
-        std.log.err("roc build cross-compilation currently only supports the int test platform", .{});
-        std.log.err("Your app path: {s}", .{args.path});
-        std.log.err("For str platform and other platforms, please use regular 'roc' command", .{});
-        return error.UnsupportedPlatform;
+    // Detect platform directory from app path (e.g., test/int/app.roc -> test/int/platform)
+    const platform_dir = blk: {
+        const app_dir = std.fs.path.dirname(args.path) orelse {
+            std.log.err("Could not determine directory from app path: {s}", .{args.path});
+            return error.InvalidAppPath;
+        };
+        break :blk try std.fs.path.join(allocs.arena, &.{ app_dir, "platform" });
     };
 
-    std.log.info("Detected platform type: {s}", .{platform_type});
-
-    // Get platform directory path
-    const platform_dir = if (std.mem.eql(u8, platform_type, "int"))
-        try std.fs.path.join(allocs.arena, &.{ "test", "int", "platform" })
-    else
-        try std.fs.path.join(allocs.arena, &.{ "test", "str", "platform" });
-
     // Check that platform exists
     std.fs.cwd().access(platform_dir, .{}) catch |err| {
         std.log.err("Platform directory not found: {s} ({})", .{ platform_dir, err });
@@ -2220,9 +2200,18 @@ fn rocBuild(allocs: *Allocators, args: cli_args.BuildArgs) !void {
         return err;
     };
 
-    // Get expected entrypoints for this platform
-    const entrypoints = try app_stub.getTestPlatformEntrypoints(allocs.gpa, platform_type);
-    defer allocs.gpa.free(entrypoints);
+    // Get expected entrypoints by parsing the platform's main.roc file
+    const platform_source_path = try std.fs.path.join(allocs.arena, &.{ platform_dir, "main.roc" });
+    var entrypoints_list = std.array_list.Managed([]const u8).init(allocs.arena);
+    defer entrypoints_list.deinit();
+
+    try extractEntrypointsFromPlatform(allocs, platform_source_path, &entrypoints_list);
+
+    // Convert to PlatformEntrypoint array for generateAppStubObject
+    const entrypoints = try allocs.arena.alloc(app_stub.PlatformEntrypoint, entrypoints_list.items.len);
+    for (entrypoints_list.items, 0..) |name, i| {
+        entrypoints[i] = app_stub.PlatformEntrypoint{ .name = name };
+    }
 
     std.log.info("Expected entrypoints: {}", .{entrypoints.len});
     for (entrypoints, 0..) |ep, i| {

src/cli/test/fx_platform_test.zig

@@ -0,0 +1,81 @@
+const std = @import("std");
+const testing = std.testing;
+
+test "fx platform effectful functions" {
+    const allocator = testing.allocator;
+
+    // Build the fx app
+    const build_result = try std.process.Child.run(.{
+        .allocator = allocator,
+        .argv = &[_][]const u8{
+            "./zig-out/bin/roc",
+            "build",
+            "test/fx/app.roc",
+        },
+    });
+    defer allocator.free(build_result.stdout);
+    defer allocator.free(build_result.stderr);
+
+    switch (build_result.term) {
+        .Exited => |code| {
+            if (code != 0) {
+                std.debug.print("Build failed with exit code {}\n", .{code});
+                std.debug.print("STDOUT: {s}\n", .{build_result.stdout});
+                std.debug.print("STDERR: {s}\n", .{build_result.stderr});
+                return error.BuildFailed;
+            }
+        },
+        else => {
+            std.debug.print("Build terminated abnormally: {}\n", .{build_result.term});
+            std.debug.print("STDOUT: {s}\n", .{build_result.stdout});
+            std.debug.print("STDERR: {s}\n", .{build_result.stderr});
+            return error.BuildFailed;
+        },
+    }
+
+    // Run the app and capture stdout/stderr separately
+    const run_result = try std.process.Child.run(.{
+        .allocator = allocator,
+        .argv = &[_][]const u8{"./app"},
+    });
+    defer allocator.free(run_result.stdout);
+    defer allocator.free(run_result.stderr);
+
+    // Clean up the app binary
+    std.fs.cwd().deleteFile("./app") catch {};
+
+    switch (run_result.term) {
+        .Exited => |code| {
+            if (code != 0) {
+                std.debug.print("Run failed with exit code {}\n", .{code});
+                std.debug.print("STDOUT: {s}\n", .{run_result.stdout});
+                std.debug.print("STDERR: {s}\n", .{run_result.stderr});
+                return error.RunFailed;
+            }
+        },
+        else => {
+            std.debug.print("Run terminated abnormally: {}\n", .{run_result.term});
+            std.debug.print("STDOUT: {s}\n", .{run_result.stdout});
+            std.debug.print("STDERR: {s}\n", .{run_result.stderr});
+            return error.RunFailed;
+        },
+    }
+
+    // Verify stdout contains expected messages
+    try testing.expect(std.mem.indexOf(u8, run_result.stdout, "Hello from stdout!") != null);
+    try testing.expect(std.mem.indexOf(u8, run_result.stdout, "Line 1 to stdout") != null);
+    try testing.expect(std.mem.indexOf(u8, run_result.stdout, "Line 3 to stdout") != null);
+    try testing.expect(std.mem.indexOf(u8, run_result.stdout, "ALL TESTS COMPLETED") != null);
+
+    // Verify stderr contains expected messages
+    try testing.expect(std.mem.indexOf(u8, run_result.stderr, "Error from stderr!") != null);
+    try testing.expect(std.mem.indexOf(u8, run_result.stderr, "Line 2 to stderr") != null);
+
+    // Verify stderr messages are NOT in stdout
+    try testing.expect(std.mem.indexOf(u8, run_result.stdout, "Error from stderr!") == null);
+    try testing.expect(std.mem.indexOf(u8, run_result.stdout, "Line 2 to stderr") == null);
+
+    // Verify stdout messages are NOT in stderr (except the ones we intentionally put there for display)
+    // Note: The host.zig writes "STDOUT: ..." to stdout and "STDERR: ..." to stderr
+    // so we check that the actual content is separated correctly
+}

test/fx/app.roc

@@ -0,0 +1,13 @@
+app [writeToStdout, writeToStderr] { pf: platform "./platform/main.roc" }
+
+writeToStdout : Str => {}
+writeToStdout = |_msg|
+    # This is an effectful function that will write to stdout
+    # The host will actually handle the IO
+    {}
+
+writeToStderr : Str => {}
+writeToStderr = |_msg|
+    # This is an effectful function that will write to stderr
+    # The host will actually handle the IO
+    {}