Introduce .e_hosted_lambda

rtfeldman · rtfeldman · commit f880f6488578 · 2025-11-06T15:57:39.000-05:00
diff --git a/src/canonicalize/Can.zig b/src/canonicalize/Can.zig
@@ -23,6 +23,7 @@ const Token = tokenize.Token;
 const DataSpan = base.DataSpan;
 const ModuleEnv = @import("ModuleEnv.zig");
 const Node = @import("Node.zig");
+const HostedCompiler = @import("HostedCompiler.zig");
 
 /// Information about an auto-imported module type
 pub const AutoImportedType = struct {
@@ -1255,6 +1256,31 @@ pub fn canonicalizeFile(
     self.env.all_defs = try self.env.store.defSpanFrom(scratch_defs_start);
     self.env.all_statements = try self.env.store.statementSpanFrom(scratch_statements_start);
 
+    // For Type Modules, transform annotation-only defs into hosted lambdas
+    // This allows platforms to import these modules and use the hosted functions
+    if (self.env.module_kind == .type_module) {
+        var new_def_indices = try HostedCompiler.replaceAnnoOnlyWithHosted(self.env);
+        defer new_def_indices.deinit(self.env.gpa);
+
+        if (new_def_indices.items.len > 0) {
+            // Rebuild all_defs span to include both old and new defs
+            const old_defs = self.env.store.sliceDefs(self.env.all_defs);
+            const defs_start = self.env.store.scratchTop("defs");
+
+            // Add all old defs
+            for (old_defs) |def_idx| {
+                try self.env.store.scratch.?.defs.append(def_idx);
+            }
+
+            // Add all new defs
+            for (new_def_indices.items) |def_idx| {
+                try self.env.store.scratch.?.defs.append(def_idx);
+            }
+
+            self.env.all_defs = try self.env.store.defSpanFrom(defs_start);
+        }
+    }
+
     // Create the span of exported defs by finding definitions that correspond to exposed items
     try self.populateExports();
 
diff --git a/src/canonicalize/DependencyGraph.zig b/src/canonicalize/DependencyGraph.zig
@@ -245,6 +245,10 @@ fn collectExprDependencies(
             try collectExprDependencies(cir, ll.body, dependencies, allocator);
         },
 
+        .e_hosted_lambda => |hosted| {
+            try collectExprDependencies(cir, hosted.body, dependencies, allocator);
+        },
+
         // External lookups reference other modules - skip for now
         .e_lookup_external => {},
 
diff --git a/src/canonicalize/Expression.zig b/src/canonicalize/Expression.zig
@@ -382,6 +382,17 @@ pub const Expr = union(enum) {
         body: Expr.Idx,
     },
 
+    /// A hosted lambda that will be provided by the host application at runtime.
+    /// ```roc
+    /// # In a hosted module:
+    /// putStdout! : Str => {}
+    /// ```
+    e_hosted_lambda: struct {
+        symbol_name: base.Ident.Idx,
+        args: CIR.Pattern.Span,
+        body: Expr.Idx,
+    },
+
     /// Low-level builtin operations that are implemented by the compiler backend.
     pub const LowLevel = enum {
         str_is_empty,
@@ -1053,6 +1064,27 @@ pub const Expr = union(enum) {
 
                 try tree.endNode(begin, attrs);
             },
+            .e_hosted_lambda => |hosted| {
+                const begin = tree.beginNode();
+                try tree.pushStaticAtom("e-hosted-lambda");
+                const symbol_name = ir.common.getIdent(hosted.symbol_name);
+                try tree.pushStringPair("symbol", symbol_name);
+                const region = ir.store.getExprRegion(expr_idx);
+                try ir.appendRegionInfoToSExprTreeFromRegion(tree, region);
+                const attrs = tree.beginNode();
+
+                const args_begin = tree.beginNode();
+                try tree.pushStaticAtom("args");
+                const args_attrs = tree.beginNode();
+                for (ir.store.slicePatterns(hosted.args)) |arg_idx| {
+                    try ir.store.getPattern(arg_idx).pushToSExprTree(ir, tree, arg_idx);
+                }
+                try tree.endNode(args_begin, args_attrs);
+
+                try ir.store.getExpr(hosted.body).pushToSExprTree(ir, tree, hosted.body);
+
+                try tree.endNode(begin, attrs);
+            },
             .e_crash => |e| {
                 const begin = tree.beginNode();
                 try tree.pushStaticAtom("e-crash");
diff --git a/src/canonicalize/HostedCompiler.zig b/src/canonicalize/HostedCompiler.zig
@@ -0,0 +1,79 @@
+const std = @import("std");
+const base = @import("base");
+const ModuleEnv = @import("ModuleEnv.zig");
+const CIR = @import("CIR.zig");
+
+/// Replace all e_anno_only expressions in a hosted module with e_hosted_lambda operations.
+/// This transforms standalone annotations into hosted lambda operations that will be
+/// provided by the host application at runtime.
+/// Returns a list of new def indices created.
+pub fn replaceAnnoOnlyWithHosted(env: *ModuleEnv) !std.ArrayList(CIR.Def.Idx) {
+    const gpa = env.gpa;
+    var new_def_indices = std.ArrayList(CIR.Def.Idx).empty;
+
+    // Ensure types array has entries for all existing nodes
+    // This is necessary because varFrom(node_idx) assumes type_var index == node index
+    const current_nodes = env.store.nodes.len();
+    const current_types = env.types.len();
+    if (current_types < current_nodes) {
+        // Fill the gap with fresh type variables
+        var i: u64 = current_types;
+        while (i < current_nodes) : (i += 1) {
+            _ = env.types.fresh() catch unreachable;
+        }
+    }
+
+    // Iterate through all defs and replace ALL anno-only defs with hosted implementations
+    const all_defs = env.store.sliceDefs(env.all_defs);
+    for (all_defs) |def_idx| {
+        const def = env.store.getDef(def_idx);
+        const expr = env.store.getExpr(def.expr);
+
+        // Check if this is an anno-only def (e_anno_only expression)
+        if (expr == .e_anno_only and def.annotation != null) {
+            // Get the identifier from the pattern
+            const pattern = env.store.getPattern(def.pattern);
+            if (pattern == .assign) {
+                const ident = pattern.assign.ident;
+
+                // Create a dummy parameter pattern for the lambda
+                // Use the identifier "_arg" for the parameter
+                const arg_ident = env.common.findIdent("_arg") orelse try env.common.insertIdent(gpa, base.Ident.for_text("_arg"));
+                const arg_pattern_idx = try env.addPattern(.{ .assign = .{ .ident = arg_ident } }, base.Region.zero());
+
+                // Create a pattern span containing just this one parameter
+                const patterns_start = env.store.scratchTop("patterns");
+                try env.store.scratch.?.patterns.append(arg_pattern_idx);
+                const args_span = CIR.Pattern.Span{ .span = .{ .start = @intCast(patterns_start), .len = 1 } };
+
+                // Create an e_runtime_error body that crashes when the function is called in the interpreter
+                const error_msg_lit = try env.insertString("Hosted functions cannot be called in the interpreter");
+                const diagnostic_idx = try env.addDiagnostic(.{ .not_implemented = .{
+                    .feature = error_msg_lit,
+                    .region = base.Region.zero(),
+                } });
+                const body_idx = try env.addExpr(.{ .e_runtime_error = .{ .diagnostic = diagnostic_idx } }, base.Region.zero());
+
+                // Create e_hosted_lambda expression
+                const expr_idx = try env.addExpr(.{ .e_hosted_lambda = .{
+                    .symbol_name = ident,
+                    .args = args_span,
+                    .body = body_idx,
+                } }, base.Region.zero());
+
+                // Now replace the e_anno_only expression with the e_hosted_lambda
+                // We need to modify the def's expr field to point to our new expression
+                // CIR.Def.Idx and Node.Idx have the same underlying representation
+                const def_node_idx = @as(@TypeOf(env.store.nodes).Idx, @enumFromInt(@intFromEnum(def_idx)));
+                var def_node = env.store.nodes.get(def_node_idx);
+                def_node.data_2 = @intFromEnum(expr_idx);
+                env.store.nodes.set(def_node_idx, def_node);
+
+                // Track this replaced def index
+                try new_def_indices.append(gpa, def_idx);
+            }
+        }
+    }
+
+    return new_def_indices;
+}
diff --git a/src/canonicalize/Node.zig b/src/canonicalize/Node.zig
@@ -79,6 +79,7 @@ pub const Tag = enum {
     expr_ellipsis,
     expr_anno_only,
     expr_low_level,
+    expr_hosted,
     expr_expect,
     expr_record_builder,
     match_branch,
diff --git a/src/canonicalize/NodeStore.zig b/src/canonicalize/NodeStore.zig
@@ -130,7 +130,7 @@ pub fn deinit(store: *NodeStore) void {
 /// Count of the diagnostic nodes in the ModuleEnv
 pub const MODULEENV_DIAGNOSTIC_NODE_COUNT = 59;
 /// Count of the expression nodes in the ModuleEnv
-pub const MODULEENV_EXPR_NODE_COUNT = 35;
+pub const MODULEENV_EXPR_NODE_COUNT = 36;
 /// Count of the statement nodes in the ModuleEnv
 pub const MODULEENV_STATEMENT_NODE_COUNT = 14;
 /// Count of the type annotation nodes in the ModuleEnv
@@ -647,6 +647,22 @@ pub fn getExpr(store: *const NodeStore, expr: CIR.Expr.Idx) CIR.Expr {
                 .body = @enumFromInt(body_idx),
             } };
         },
+        .expr_hosted => {
+            // Retrieve hosted lambda data from extra_data
+            const symbol_name: base.Ident.Idx = @bitCast(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];
+            const args_len = extra_data[1];
+            const body_idx = extra_data[2];
+
+            return CIR.Expr{ .e_hosted_lambda = .{
+                .symbol_name = symbol_name,
+                .args = .{ .span = .{ .start = args_start, .len = args_len } },
+                .body = @enumFromInt(body_idx),
+            } };
+        },
         .expr_expect => {
             return CIR.Expr{ .e_expect = .{
                 .body = @enumFromInt(node.data_1),
@@ -1517,6 +1533,22 @@ pub fn addExpr(store: *NodeStore, expr: CIR.Expr, region: base.Region) Allocator
 
             node.data_2 = @intCast(extra_data_start);
         },
+        .e_hosted_lambda => |hosted| {
+            node.tag = .expr_hosted;
+            node.data_1 = @bitCast(hosted.symbol_name);
+
+            // Store hosted lambda data in extra_data
+            const extra_data_start = store.extra_data.len();
+
+            // Store args span start
+            _ = try store.extra_data.append(store.gpa, hosted.args.span.start);
+            // Store args span length
+            _ = try store.extra_data.append(store.gpa, hosted.args.span.len);
+            // Store body index
+            _ = try store.extra_data.append(store.gpa, @intFromEnum(hosted.body));
+
+            node.data_2 = @intCast(extra_data_start);
+        },
         .e_match => |e| {
             node.tag = .expr_match;
 
diff --git a/src/check/Check.zig b/src/check/Check.zig
@@ -3005,6 +3005,21 @@ fn checkExpr(self: *Self, expr_idx: CIR.Expr.Idx, rank: types_mod.Rank, expected
                 },
             }
         },
+        .e_hosted_lambda => |hosted| {
+            // For hosted lambda expressions, treat like a lambda with a crash body.
+            // Check the body (which will be e_runtime_error or similar)
+            does_fx = try self.checkExpr(hosted.body, rank, .no_expectation) or does_fx;
+
+            // The lambda's type comes from the annotation.
+            // Like e_anno_only and e_low_level_lambda, this should always have an annotation.
+            // The type will be unified with the expected type in the code below.
+            switch (expected) {
+                .no_expectation => unreachable,
+                .expected => {
+                    // The expr_var will be unified with the annotation var below
+                },
+            }
+        },
         .e_runtime_error => {
             try self.updateVar(expr_var, .err, rank);
         },
diff --git a/test/HostedIO.roc b/test/HostedIO.roc
@@ -0,0 +1,10 @@
+HostedIO := [].{
+    ## Print a string to stdout
+    put_line! : Str => {}
+
+    ## Read a line from stdin
+    get_line! : {} => Str
+
+    ## Write to a file
+    write_file! : Str, Str => Try({}, [FileWriteError])
+}
diff --git a/test/fx/app.roc b/test/fx/app.roc
@@ -1,22 +1,5 @@
-app [main!, putStdout!, putStderr!] { pf: platform "./platform/main.roc" }
+app [main!] { pf: platform "./platform/main.roc" }
 
-main! : () => {}
-main! = ||
-    putStdout!("Hello from stdout!")
-    putStderr!("Error from stderr!")
-    putStdout!("Line 1 to stdout")
-    putStderr!("Line 2 to stderr")
-    putStdout!("Line 3 to stdout")
-    {}
+import pf.Stdout
 
-putStdout! : Str => {}
-putStdout! = |_msg|
-    # In a full implementation, this would call a host-provided function
-    # For now, the host will intercept these calls and perform the actual I/O
-    {}
-
-putStderr! : Str => {}
-putStderr! = |_msg|
-    # In a full implementation, this would call a host-provided function
-    # For now, the host will intercept these calls and perform the actual I/O
-    {}
+main! = |_| Stdout.line!("Hello from stdout!")
diff --git a/test/fx/platform/Host.roc b/test/fx/platform/Host.roc
@@ -0,0 +1,4 @@
+Host := [].{
+    put_stdout! : Str => {}
+    put_stderr! : Str => {}
+}
diff --git a/test/fx/platform/Stderr.roc b/test/fx/platform/Stderr.roc
@@ -0,0 +1,6 @@
+import pf.Host
+
+Stderr := [].{
+    line! : Str => {}
+    line! = |text| Host.put_stderr!(text)
+}
diff --git a/test/fx/platform/Stdout.roc b/test/fx/platform/Stdout.roc
@@ -0,0 +1,6 @@
+import pf.Host
+
+Stdout := [].{
+    line! : Str => {}
+    line! = |text| Host.put_stdout!(text)
+}
diff --git a/test/fx/platform/host.zig b/test/fx/platform/host.zig
@@ -61,8 +61,6 @@ fn rocCrashedFn(roc_crashed: *const builtins.host_abi.RocCrashed, env: *anyopaqu
 // External symbols provided by the Roc runtime object file
 // Follows RocCall ABI: ops, ret_ptr, then argument pointers
 extern fn roc__main_for_host(ops: *builtins.host_abi.RocOps, ret_ptr: *anyopaque, arg_ptr: ?*anyopaque) callconv(.c) void;
-extern fn roc__putStdout(ops: *builtins.host_abi.RocOps, ret_ptr: *anyopaque, arg_ptr: ?*anyopaque) callconv(.c) void;
-extern fn roc__putStderr(ops: *builtins.host_abi.RocOps, ret_ptr: *anyopaque, arg_ptr: ?*anyopaque) callconv(.c) void;
 
 // OS-specific entry point handling
 comptime {
@@ -170,14 +168,6 @@ fn platform_main() !void {
     };
     defer host_env.arena.deinit();
 
-    var stdout_buffer: [4096]u8 = undefined;
-    var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
-    const stdout = &stdout_writer.interface;
-
-    var stderr_buffer: [4096]u8 = undefined;
-    var stderr_writer = std.fs.File.stderr().writer(&stderr_buffer);
-    const stderr = &stderr_writer.interface;
-
     // Create the RocOps struct
     var roc_ops = builtins.host_abi.RocOps{
         .env = @as(*anyopaque, @ptrCast(&host_env)),
@@ -191,42 +181,7 @@ fn platform_main() !void {
     };
 
     // Call the app's main! entrypoint
-    // This demonstrates platform-app integration: the platform requires and calls main!
-    // The app implements main! which calls other effectful functions
-    // Those functions are also provided by the app (as stubs), demonstrating composition
     var unit_result: [0]u8 = undefined; // Result is {} which is zero-sized
     var unit_arg: [0]u8 = undefined; // Argument is () which is zero-sized
     roc__main_for_host(&roc_ops, @as(*anyopaque, @ptrCast(&unit_result)), @as(*anyopaque, @ptrCast(&unit_arg)));
-
-    // Verify the app's effectful functions work by calling them directly
-    // This tests that the calling convention and type signatures are correct
-    const messages = [_]struct {
-        text: []const u8,
-        func: *const fn (*builtins.host_abi.RocOps, *anyopaque, ?*anyopaque) callconv(.c) void,
-        stream: enum { stdout, stderr },
-    }{
-        .{ .text = "Hello from stdout!", .func = roc__putStdout, .stream = .stdout },
-        .{ .text = "Error from stderr!", .func = roc__putStderr, .stream = .stderr },
-        .{ .text = "Line 1 to stdout", .func = roc__putStdout, .stream = .stdout },
-        .{ .text = "Line 2 to stderr", .func = roc__putStderr, .stream = .stderr },
-        .{ .text = "Line 3 to stdout", .func = roc__putStdout, .stream = .stdout },
-    };
-
-    for (messages) |msg| {
-        var roc_str = RocStr.fromSlice(msg.text, &roc_ops);
-        var result: [0]u8 = undefined;
-        msg.func(&roc_ops, @as(*anyopaque, @ptrCast(&result)), @as(*anyopaque, @ptrCast(&roc_str)));
-
-        // The Roc function returned successfully, now perform the actual I/O
-        // In a full implementation with platform modules, the Roc code would call
-        // host-provided functions (via import pf.Stdout) to perform I/O directly
-        switch (msg.stream) {
-            .stdout => try stdout.print("{s}\n", .{msg.text}),
-            .stderr => try stderr.print("{s}\n", .{msg.text}),
-        }
-    }
-
-    // Flush the output buffers
-    try stdout.flush();
-    try stderr.flush();
 }
diff --git a/test/fx/platform/main.roc b/test/fx/platform/main.roc
diff --git a/test/hosted_test.roc b/test/hosted_test.roc
