Merge branch 'main' into platform-fixes

Author: Anton-4

.github/workflows/ci_zig.yml

@@ -268,4 +268,4 @@ jobs:
 
   # Test cross-compilation with Roc's cross-compilation system (musl + glibc)
   roc-cross-compile:
-    uses: ./.github/workflows/ci_cross_compile.yml
+    uses: ./.github/workflows/ci_cross_compile.yml

build.zig

@@ -20,8 +20,9 @@ fn configureBackend(step: *Step.Compile, target: ResolvedTarget) void {
     }
 }
 
-fn isNativeOrMusl(target: ResolvedTarget) bool {
-    return target.query.isNativeCpu() and target.query.isNativeOs() and
+fn isNativeishOrMusl(target: ResolvedTarget) bool {
+    return target.result.cpu.arch == builtin.target.cpu.arch and
+        target.query.isNativeOs() and
         (target.query.isNativeAbi() or target.result.abi.isMusl());
 }
 
@@ -1081,13 +1082,25 @@ pub fn build(b: *std.Build) void {
     const is_windows = target.result.os.tag == .windows;
 
     // fx platform effectful functions test - only run when not cross-compiling
-    if (isNativeOrMusl(target)) {
+    if (isNativeishOrMusl(target)) {
+        // Determine the appropriate target for the fx platform host library.
+        // On Linux, we need to use musl explicitly because the CLI's findHostLibrary
+        // looks for targets/x64musl/libhost.a first, and musl produces proper static binaries.
+        const fx_host_target, const fx_host_target_dir: ?[]const u8 = switch (target.result.os.tag) {
+            .linux => switch (target.result.cpu.arch) {
+                .x86_64 => .{ b.resolveTargetQuery(.{ .cpu_arch = .x86_64, .os_tag = .linux, .abi = .musl }), "x64musl" },
+                .aarch64 => .{ b.resolveTargetQuery(.{ .cpu_arch = .aarch64, .os_tag = .linux, .abi = .musl }), "arm64musl" },
+                else => .{ target, null },
+            },
+            else => .{ target, null },
+        };
+
         // 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,
+            fx_host_target,
             optimize,
             roc_modules,
         );
@@ -1098,6 +1111,14 @@ pub fn build(b: *std.Build) void {
         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);
 
+        // On Linux, also copy to the target-specific directory so findHostLibrary finds it
+        if (fx_host_target_dir) |target_dir| {
+            copy_test_fx_host.addCopyFileToSource(
+                test_platform_fx_host_lib.getEmittedBin(),
+                b.pathJoin(&.{ "test/fx/platform/targets", target_dir, "libhost.a" }),
+            );
+        }
+
         const fx_platform_test = b.addTest(.{
             .name = "fx_platform_test",
             .root_module = b.createModule(.{
@@ -1118,7 +1139,7 @@ pub fn build(b: *std.Build) void {
     }
 
     var build_afl = false;
-    if (!isNativeOrMusl(target)) {
+    if (!isNativeishOrMusl(target)) {
         std.log.warn("Cross compilation does not support fuzzing (Only building repro executables)", .{});
     } else if (is_windows) {
         // Windows does not support fuzzing - only build repro executables

src/canonicalize/Can.zig

@@ -4894,13 +4894,128 @@ pub fn canonicalizeExpr(
                 .free_vars = null,
             };
         },
-        .local_dispatch => |_| {
-            const feature = try self.env.insertString("canonicalize local_dispatch expression");
-            const expr_idx = try self.env.pushMalformed(Expr.Idx, Diagnostic{ .not_implemented = .{
-                .feature = feature,
-                .region = Region.zero(),
-            } });
-            return CanonicalizedExpr{ .idx = expr_idx, .free_vars = null };
+        .local_dispatch => |local_dispatch| {
+            // Desugar `arg1->fn(arg2, arg3)` to `fn(arg1, arg2, arg3)`
+            // and `arg1->fn` to `fn(arg1)`
+            const region = self.parse_ir.tokenizedRegionToRegion(local_dispatch.region);
+            const free_vars_start = self.scratch_free_vars.top();
+
+            // Canonicalize the left expression (first argument)
+            const can_first_arg = try self.canonicalizeExpr(local_dispatch.left) orelse return null;
+
+            // Get the right expression to determine the function and additional args
+            const right_expr = self.parse_ir.store.getExpr(local_dispatch.right);
+
+            switch (right_expr) {
+                .apply => |apply| {
+                    // Case: `arg1->fn(arg2, arg3)` - function call with additional args
+                    // Check if this is a tag application
+                    const ast_fn = self.parse_ir.store.getExpr(apply.@"fn");
+                    if (ast_fn == .tag) {
+                        // Tag application: `arg1->Tag(arg2)` becomes `Tag(arg1, arg2)`
+                        const tag_expr = ast_fn.tag;
+                        const tag_name = self.parse_ir.tokens.resolveIdentifier(tag_expr.token) orelse @panic("tag token is not an ident");
+
+                        // Build args: first_arg followed by apply.args
+                        const scratch_top = self.env.store.scratchExprTop();
+                        try self.env.store.addScratchExpr(can_first_arg.idx);
+
+                        const additional_args = self.parse_ir.store.exprSlice(apply.args);
+                        for (additional_args) |arg| {
+                            if (try self.canonicalizeExpr(arg)) |can_arg| {
+                                try self.env.store.addScratchExpr(can_arg.idx);
+                            }
+                        }
+
+                        const args_span = try self.env.store.exprSpanFrom(scratch_top);
+
+                        const expr_idx = try self.env.addExpr(CIR.Expr{
+                            .e_tag = .{
+                                .name = tag_name,
+                                .args = args_span,
+                            },
+                        }, region);
+
+                        const free_vars_span = self.scratch_free_vars.spanFrom(free_vars_start);
+                        return CanonicalizedExpr{ .idx = expr_idx, .free_vars = if (free_vars_span.len > 0) free_vars_span else null };
+                    }
+
+                    // Normal function call
+                    const can_fn_expr = try self.canonicalizeExpr(apply.@"fn") orelse return null;
+
+                    // Build args: first_arg followed by apply.args
+                    const scratch_top = self.env.store.scratchExprTop();
+                    try self.env.store.addScratchExpr(can_first_arg.idx);
+
+                    const additional_args = self.parse_ir.store.exprSlice(apply.args);
+                    for (additional_args) |arg| {
+                        if (try self.canonicalizeExpr(arg)) |can_arg| {
+                            try self.env.store.addScratchExpr(can_arg.idx);
+                        }
+                    }
+
+                    const args_span = try self.env.store.exprSpanFrom(scratch_top);
+
+                    const expr_idx = try self.env.addExpr(CIR.Expr{
+                        .e_call = .{
+                            .func = can_fn_expr.idx,
+                            .args = args_span,
+                            .called_via = CalledVia.apply,
+                        },
+                    }, region);
+
+                    const free_vars_span = self.scratch_free_vars.spanFrom(free_vars_start);
+                    return CanonicalizedExpr{ .idx = expr_idx, .free_vars = if (free_vars_span.len > 0) free_vars_span else null };
+                },
+                .ident, .tag => {
+                    // Case: `arg1->fn` or `arg1->Tag` - simple function/tag call with single arg
+                    if (right_expr == .tag) {
+                        const tag_expr = right_expr.tag;
+                        const tag_name = self.parse_ir.tokens.resolveIdentifier(tag_expr.token) orelse @panic("tag token is not an ident");
+
+                        const scratch_top = self.env.store.scratchExprTop();
+                        try self.env.store.addScratchExpr(can_first_arg.idx);
+                        const args_span = try self.env.store.exprSpanFrom(scratch_top);
+
+                        const expr_idx = try self.env.addExpr(CIR.Expr{
+                            .e_tag = .{
+                                .name = tag_name,
+                                .args = args_span,
+                            },
+                        }, region);
+
+                        const free_vars_span = self.scratch_free_vars.spanFrom(free_vars_start);
+                        return CanonicalizedExpr{ .idx = expr_idx, .free_vars = if (free_vars_span.len > 0) free_vars_span else null };
+                    }
+
+                    // It's an ident
+                    const can_fn_expr = try self.canonicalizeExpr(local_dispatch.right) orelse return null;
+
+                    const scratch_top = self.env.store.scratchExprTop();
+                    try self.env.store.addScratchExpr(can_first_arg.idx);
+                    const args_span = try self.env.store.exprSpanFrom(scratch_top);
+
+                    const expr_idx = try self.env.addExpr(CIR.Expr{
+                        .e_call = .{
+                            .func = can_fn_expr.idx,
+                            .args = args_span,
+                            .called_via = CalledVia.apply,
+                        },
+                    }, region);
+
+                    const free_vars_span = self.scratch_free_vars.spanFrom(free_vars_start);
+                    return CanonicalizedExpr{ .idx = expr_idx, .free_vars = if (free_vars_span.len > 0) free_vars_span else null };
+                },
+                else => {
+                    // Unexpected expression type on right side of arrow
+                    const feature = try self.env.insertString("arrow with complex expression");
+                    const expr_idx = try self.env.pushMalformed(Expr.Idx, Diagnostic{ .not_implemented = .{
+                        .feature = feature,
+                        .region = region,
+                    } });
+                    return CanonicalizedExpr{ .idx = expr_idx, .free_vars = null };
+                },
+            }
         },
         .bin_op => |e| {
             const region = self.parse_ir.tokenizedRegionToRegion(e.region);

src/lsp/README.md

@@ -4,23 +4,48 @@ written in Zig as part of the Rust to Zig rewrite.
 
 ## Current state
 The experimental LSP currently only holds the scaffolding for the incoming implementation.
-It doesn't implement any LSP capabilities yet except `initialized` and `exit` which allows it
-to be connected to an editor and verify it's actually running.
+It doesn't provide any features yet, but it does connect to your editor, detect file change
+and store the buffer in memory. 
+The following request have been handled :
+- `initialize`
+- `shutdown`
+The following notifications have been handled :
+- `initialized`
+- `exit`
+- `didOpen` (stores the buffer into a `StringHashMap`, but doesn't do any action on it)
+- `didChange` (same as `didOpen`, but also supports incremental changes)
+
 
 ## How to implement new LSP capabilities
 The core functionalities of the LSP have been implemented in a way so that `transport.zig` and
 `protocol.zig` shouldn't have to be modified as more capabilities are added. When handling a new
 LSP method, like `textDocument/completion` for example, the handler should be added in the `handlers`
-directory and its call should be added in `server.zig` like this :
+directory and its call should be added either in `request` (if it expects a response) or `notification`
+(if it doesn't expect a response). `textDocument/completion` for example would go here :
 ```zig
 const request_handlers = std.StaticStringMap(HandlerPtr).initComptime(.{
     .{ "initialize", &InitializeHandler.call },
     .{ "shutdown", &ShutdownHandler.call },
     .{ "textDocument/completion", &CompletionHandler.call },
 });
 ```
-The `Server` holds the state so it will be responsible of knowing the project and how different parts
-interact. This is then accessible by every handler.
+When adding a new capability, if the server is ready to support it, you need to add the capabilities to
+the `capabilities.zig` file for the `initialize` response to tell the client the capabilities is available :
+```zig
+pub fn buildCapabilities() ServerCapabilities {
+    return .{
+        .textDocumentSync = .{
+            .openClose = true,
+            .change = @intFromEnum(ServerCapabilities.TextDocumentSyncKind.incremental),
+        },
+    };
+}
+```
+Here we tell the client that `textDocumentSync` is available in accordance to the LSP specifications data
+structure. The `Server` struct holds the state, meaning in has the knowledge of the project files, the
+documentation, the type inference, the syntax, etc. Every handler has access to it. These points of knowledge
+are ideally separated in different fields of the server. For example, the opened buffer and other desired files
+are stored in a `DocumentStore` which is a struct containing a `StringHashMap`, accessible through the `Server`.
 
 ## Starting the server
 Build the Roc toolchain and run:
@@ -37,7 +62,7 @@ roc experimental-lsp --debug-transport
 
 Passing the `--debug-transport` flag will create a log file in your OS tmp folder (`/tmp` on Unix
 systems). A mirror of the raw JSON-RPC traffic will be appended to the log file. Watching the file 
-will allow an user to see incoming and outgoing message between the server and the editor
+will allow a user to see incoming and outgoing message between the server and the editor
 ```bash
 tail -f /tmp/roc-lsp-debug.log 
 ---

src/lsp/capabilities.zig

@@ -0,0 +1,28 @@
+const std = @import("std");
+
+/// Aggregates all server capabilities supported by the Roc LSP.
+pub const ServerCapabilities = struct {
+    positionEncoding: []const u8 = "utf-16",
+    textDocumentSync: ?TextDocumentSyncOptions = null,
+
+    pub const TextDocumentSyncOptions = struct {
+        openClose: bool = false,
+        change: u32 = @intFromEnum(TextDocumentSyncKind.none),
+    };
+
+    pub const TextDocumentSyncKind = enum(u32) {
+        none = 0,
+        full = 1,
+        incremental = 2,
+    };
+};
+
+/// Returns the server capabilities currently implemented.
+pub fn buildCapabilities() ServerCapabilities {
+    return .{
+        .textDocumentSync = .{
+            .openClose = true,
+            .change = @intFromEnum(ServerCapabilities.TextDocumentSyncKind.incremental),
+        },
+    };
+}