fix compile errors in transport usage

Author: Techatrix

examples/hello_client.zig

@@ -71,7 +71,7 @@ pub fn main(init: std.process.Init) !void {
     //
     // The `lsp.Transport.Stdio` implements the necessary logic to read and write messages over stdio.
     var read_buffer: [256]u8 = undefined;
-    var stdio_transport: lsp.Transport.Stdio = .init(io, &read_buffer, .{ .handle = child_process.stdout.?.handle }, child_process.stdin.?);
+    var stdio_transport: lsp.Transport.Stdio = .init(&read_buffer, .{ .handle = child_process.stdout.?.handle }, child_process.stdin.?);
     const transport: *lsp.Transport = &stdio_transport.transport;
 
     // The order of exchanged messages will look similar to this:
@@ -84,6 +84,7 @@ pub fn main(init: std.process.Init) !void {
 
     std.log.debug("sending 'initialize' request to server", .{});
     try transport.writeRequest(
+        io,
         gpa,
         .{ .number = 0 },
         "initialize", // https://microsoft.github.io/language-server-protocol/specifications/specification-current/#initialize
@@ -95,7 +96,7 @@ pub fn main(init: std.process.Init) !void {
     // Wait for the response from the server
     // For the sake of simplicity, we will block here and read messages until the response to our request has been found. All other messages will be ignored.
     // A more sophisticated client implementation will need to handle messages asynchronously.
-    const initialize_response = try readAndIgnoreUntilResponse(gpa, transport, .{ .number = 0 }, "initialize");
+    const initialize_response = try readAndIgnoreUntilResponse(io, gpa, transport, .{ .number = 0 }, "initialize");
     defer initialize_response.deinit();
 
     const initialize_result: lsp.types.InitializeResult = initialize_response.value;
@@ -120,6 +121,7 @@ pub fn main(init: std.process.Init) !void {
 
     std.log.debug("sending 'initialized' notification to server", .{});
     try transport.writeNotification(
+        io,
         gpa,
         "initialized", // https://microsoft.github.io/language-server-protocol/specifications/specification-current/#initialized
         lsp.types.InitializedParams,
@@ -132,6 +134,7 @@ pub fn main(init: std.process.Init) !void {
     std.log.info("This document recently came in by the CLI.", .{});
     std.log.debug("sending 'textDocument/didOpen' notification to server", .{});
     try transport.writeNotification(
+        io,
         gpa,
         "textDocument/didOpen", // https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_didOpen
         lsp.types.TextDocument.DidOpenParams,
@@ -149,6 +152,7 @@ pub fn main(init: std.process.Init) !void {
     std.log.info("Just to double check, could you verify that it is formatted correctly?", .{});
     std.log.debug("sending 'textDocument/formatting' request to server", .{});
     try transport.writeRequest(
+        io,
         gpa,
         .{ .number = 1 },
         "textDocument/formatting", // https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_formatting
@@ -160,7 +164,7 @@ pub fn main(init: std.process.Init) !void {
         .{ .emit_null_optional_fields = false },
     );
 
-    const formatting_response = try readAndIgnoreUntilResponse(gpa, transport, .{ .number = 1 }, "textDocument/formatting");
+    const formatting_response = try readAndIgnoreUntilResponse(io, gpa, transport, .{ .number = 1 }, "textDocument/formatting");
     defer formatting_response.deinit();
 
     const text_edits = formatting_response.value orelse &.{};
@@ -177,6 +181,7 @@ pub fn main(init: std.process.Init) !void {
     // Even though this is a request, we do not wait for a response because we are going to close the server anyway.
     std.log.debug("sending 'shutdown' request to server", .{});
     try transport.writeRequest(
+        io,
         gpa,
         .{ .number = 2 },
         "shutdown", // https://microsoft.github.io/language-server-protocol/specifications/specification-current/#shutdown
@@ -187,6 +192,7 @@ pub fn main(init: std.process.Init) !void {
 
     std.log.debug("sending 'exit' notification to server", .{});
     try transport.writeNotification(
+        io,
         gpa,
         "exit", // https://microsoft.github.io/language-server-protocol/specifications/specification-current/#exit
         void,
@@ -215,14 +221,15 @@ fn fatal(comptime format: []const u8, args: anytype) noreturn {
 
 /// Do not use such a function in an actual implementation.
 fn readAndIgnoreUntilResponse(
+    io: std.Io,
     allocator: std.mem.Allocator,
     transport: *lsp.Transport,
     id: lsp.JsonRPCMessage.ID,
     comptime method: []const u8,
 ) !std.json.Parsed(lsp.ResultType(method)) {
     while (true) {
         // read the unparsed JSON-RPC message
-        const json_message = try transport.readJsonMessage(allocator);
+        const json_message = try transport.readJsonMessage(io, allocator);
         defer allocator.free(json_message);
         std.log.debug("received message from server: {s}", .{json_message});
 

examples/hello_server.zig

@@ -38,7 +38,7 @@ pub fn main(init: std.process.Init) !void {
     //
     // The `lsp.Transport.Stdio` implements the necessary logic to read and write messages over stdio.
     var read_buffer: [256]u8 = undefined;
-    var stdio_transport: lsp.Transport.Stdio = .init(io, &read_buffer, .stdin(), .stdout());
+    var stdio_transport: lsp.Transport.Stdio = .init(&read_buffer, .stdin(), .stdout());
     const transport: *lsp.Transport = &stdio_transport.transport;
 
     // keep track of opened documents
@@ -51,7 +51,7 @@ pub fn main(init: std.process.Init) !void {
 
     while (true) {
         // read the unparsed JSON-RPC message
-        const json_message = try transport.readJsonMessage(gpa);
+        const json_message = try transport.readJsonMessage(io, gpa);
         defer gpa.free(json_message);
         // std.log.debug("received message from client: {s}", .{json_message});
 
@@ -90,6 +90,7 @@ pub fn main(init: std.process.Init) !void {
                 .initialize => |params| {
                     _ = params.capabilities; // the client capabilities tell the server what "features" the client supports
                     try transport.writeResponse(
+                        io,
                         gpa,
                         request.id,
                         lsp.types.InitializeResult,
@@ -105,11 +106,11 @@ pub fn main(init: std.process.Init) !void {
                         .{ .emit_null_optional_fields = false },
                     );
                 },
-                .shutdown => try transport.writeResponse(gpa, request.id, void, {}, .{}),
+                .shutdown => try transport.writeResponse(io, gpa, request.id, void, {}, .{}),
                 .@"textDocument/formatting" => |params| {
                     const source = documents.get(params.textDocument.uri) orelse {
                         // We should read the document from the file system
-                        try transport.writeResponse(gpa, request.id, void, {}, .{});
+                        try transport.writeResponse(io, gpa, request.id, void, {}, .{});
                         continue;
                     };
                     const source_z = try gpa.dupeZ(u8, source);
@@ -119,15 +120,15 @@ pub fn main(init: std.process.Init) !void {
                     defer tree.deinit(gpa);
 
                     if (tree.errors.len != 0) {
-                        try transport.writeResponse(gpa, request.id, void, {}, .{});
+                        try transport.writeResponse(io, gpa, request.id, void, {}, .{});
                         continue;
                     }
 
                     const formatte_source = try tree.renderAlloc(gpa);
                     defer gpa.free(formatte_source);
 
                     if (std.mem.eql(u8, source, formatte_source)) {
-                        try transport.writeResponse(gpa, request.id, void, {}, .{});
+                        try transport.writeResponse(io, gpa, request.id, void, {}, .{});
                         continue;
                     }
 
@@ -139,9 +140,9 @@ pub fn main(init: std.process.Init) !void {
                         .newText = formatte_source,
                     }};
 
-                    try transport.writeResponse(gpa, request.id, []const lsp.types.TextEdit, result, .{});
+                    try transport.writeResponse(io, gpa, request.id, []const lsp.types.TextEdit, result, .{});
                 },
-                .other => try transport.writeResponse(gpa, request.id, void, {}, .{}),
+                .other => try transport.writeResponse(io, gpa, request.id, void, {}, .{}),
             },
             .notification => |notification| switch (notification.params) {
                 .initialized => {},

examples/my_first_server.zig

@@ -7,7 +7,7 @@ const lsp = @import("lsp");
 pub fn main(init: std.process.Init) !void {
     // LSP implementations typically communicate over stdio (stdin and stdout)
     var read_buffer: [256]u8 = undefined;
-    var stdio_transport: lsp.Transport.Stdio = .init(init.io, &read_buffer, .stdin(), .stdout());
+    var stdio_transport: lsp.Transport.Stdio = .init(&read_buffer, .stdin(), .stdout());
     const transport: *lsp.Transport = &stdio_transport.transport;
 
     // The handler is a user provided type that stores the state of the
@@ -16,6 +16,7 @@ pub fn main(init: std.process.Init) !void {
     defer handler.deinit();
 
     try lsp.basic_server.run(
+        init.io,
         init.gpa,
         transport,
         &handler,

src/basic_server.zig

@@ -14,6 +14,7 @@ const offsets = lsp.offsets;
 const types = lsp.types;
 
 pub fn run(
+    io: std.Io,
     allocator: std.mem.Allocator,
     transport: *lsp.Transport,
     /// Must be a pointer to a container type (e.g. `struct`) that implements
@@ -59,7 +60,7 @@ pub fn run(
     comptime std.debug.assert(@hasDecl(Handler, "initialize") or @hasField(Handler, "initialize")); // The 'initialize' function cannot be omitted.
 
     while (true) {
-        const json_message = try transport.readJsonMessage(allocator);
+        const json_message = try transport.readJsonMessage(io, allocator);
         defer allocator.free(json_message);
 
         var arena_allocator: std.heap.ArenaAllocator = .init(allocator);
@@ -74,6 +75,7 @@ pub fn run(
         ) catch |err| {
             if (logErr) |log| log("Failed to handle message: {}", .{err});
             try transport.writeErrorResponse(
+                io,
                 allocator,
                 null,
                 .{ .code = .parse_error, .message = @errorName(err) },
@@ -96,6 +98,7 @@ pub fn run(
                             , .{ Handler, std.zig.fmtId(method), lsp.ResultType(method), @TypeOf(result) }));
                         }
                         try transport.writeResponse(
+                            io,
                             allocator,
                             request.id,
                             lsp.ResultType(method),
@@ -138,6 +141,7 @@ pub fn run(
                         }
 
                         try transport.writeErrorResponse(
+                            io,
                             allocator,
                             request.id,
                             .{ .code = code, .message = @errorName(err) },
@@ -147,6 +151,7 @@ pub fn run(
                 },
                 .other => {
                     try transport.writeResponse(
+                        io,
                         allocator,
                         request.id,
                         ?void,

src/lsp.zig

@@ -1167,6 +1167,7 @@ pub const Transport = struct {
 
     pub fn writeRequest(
         transport: *Transport,
+        io: std.Io,
         allocator: std.mem.Allocator,
         id: JsonRPCMessage.ID,
         method: []const u8,
@@ -1181,11 +1182,12 @@ pub const Transport = struct {
         };
         const json_message = try std.json.Stringify.valueAlloc(allocator, request, options);
         defer allocator.free(json_message);
-        try transport.writeJsonMessage(json_message);
+        try transport.writeJsonMessage(io, json_message);
     }
 
     pub fn writeNotification(
         transport: *Transport,
+        io: std.Io,
         allocator: std.mem.Allocator,
         method: []const u8,
         comptime Params: type,
@@ -1198,11 +1200,12 @@ pub const Transport = struct {
         };
         const json_message = try std.json.Stringify.valueAlloc(allocator, request, options);
         defer allocator.free(json_message);
-        try transport.writeJsonMessage(json_message);
+        try transport.writeJsonMessage(io, json_message);
     }
 
     pub fn writeResponse(
         transport: *Transport,
+        io: std.Io,
         allocator: std.mem.Allocator,
         id: ?JsonRPCMessage.ID,
         comptime Result: type,
@@ -1215,11 +1218,12 @@ pub const Transport = struct {
         };
         const json_message = try std.json.Stringify.valueAlloc(allocator, request, options);
         defer allocator.free(json_message);
-        try transport.writeJsonMessage(json_message);
+        try transport.writeJsonMessage(io, json_message);
     }
 
     pub fn writeErrorResponse(
         transport: *Transport,
+        io: std.Io,
         allocator: std.mem.Allocator,
         id: ?JsonRPCMessage.ID,
         err: JsonRPCMessage.Response.Error,
@@ -1231,7 +1235,7 @@ pub const Transport = struct {
         };
         const json_message = try std.json.Stringify.valueAlloc(allocator, request, options);
         defer allocator.free(json_message);
-        try transport.writeJsonMessage(json_message);
+        try transport.writeJsonMessage(io, json_message);
     }
 };