From 6a5ad5799817646579fca2fbafc213a021fe1297 Mon Sep 17 00:00:00 2001 From: Techatrix <19954306+Techatrix@users.noreply.github.com> Date: Wed, 27 Mar 2024 01:05:53 +0100 Subject: [PATCH 1/2] add Message type --- src/base.zig | 719 ++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 705 insertions(+), 14 deletions(-) diff --git a/src/base.zig b/src/base.zig index a3759a5..34dbd2e 100644 --- a/src/base.zig +++ b/src/base.zig @@ -2,7 +2,7 @@ const std = @import("std"); -const URI = []const u8; +pub const URI = []const u8; /// The URI of a document pub const DocumentUri = []const u8; /// A JavaScript regular expression; never used @@ -12,21 +12,712 @@ pub const LSPAny = std.json.Value; pub const LSPArray = []LSPAny; pub const LSPObject = std.json.ObjectMap; -pub const RequestId = union(enum) { - integer: i64, - string: []const u8, - pub usingnamespace UnionParser(@This()); -}; +pub const Message = union(enum) { + request: Request, + notification: Notification, + response: Response, + + pub fn method(message: Message) ?[]const u8 { + return switch (message) { + .request => |request| request.method, + .notification => |notification| notification.method, + .response => null, + }; + } + + pub fn params(message: Message) ?std.json.Value { + return switch (message) { + .request => |request| request.params, + .notification => |notification| notification.params, + .response => null, + }; + } + + pub fn id(message: Message) ?ID { + return switch (message) { + .request => |request| request.id, + .notification => null, + .response => |response| response.id, + }; + } + + /// Method names that begin with the word rpc followed by a period character (U+002E or ASCII 46) are reserved for rpc-internal methods and extensions and MUST NOT be used for anything else. + pub fn is_reserved_method_name(name: []const u8) bool { + return std.mem.startsWith(u8, name, "rpc."); + } + + pub const ID = union(enum) { + number: i64, + string: []const u8, + + pub fn jsonParse(allocator: std.mem.Allocator, source: anytype, options: std.json.ParseOptions) std.json.ParseError(@TypeOf(source.*))!ID { + switch (try source.peekNextTokenType()) { + .number => return try std.json.innerParse(i64, allocator, source, options), + .string => return try std.json.innerParse([]const u8, allocator, source, options), + else => return error.SyntaxError, + } + } + + pub fn jsonParseFromValue(allocator: std.mem.Allocator, source: std.json.Value, options: std.json.ParseOptions) std.json.ParseFromValueError!ID { + _ = allocator; + _ = options; + switch (source) { + .integer => |number| return .{ .number = number }, + .string => |string| return .{ .string = string }, + else => return error.UnexpectedToken, + } + } + + pub fn jsonStringify(self: ID, stream: anytype) @TypeOf(stream.*).Error!void { + switch (self) { + inline else => |value| try stream.write(value), + } + } + }; + + pub const Request = struct { + comptime jsonrpc: []const u8 = "2.0", + /// The request id. + id: ID, + /// The method to be invoked. + method: []const u8, + /// The method's params. Can only be `.array` or `.object`. + params: ?std.json.Value, + }; + + pub const Notification = struct { + comptime jsonrpc: []const u8 = "2.0", + /// The method to be invoked. + method: []const u8, + /// The notification's params. Can only be `.array` or `.object`. + params: ?std.json.Value, + }; + + pub const Response = struct { + comptime jsonrpc: []const u8 = "2.0", + /// The request id. + id: ?ID, + /// The result of a request. This member is REQUIRED on success. + /// This member MUST NOT exist if there was an error invoking the m + result: ?std.json.Value, + /// The error object in case a request fails. + @"error": ?Error, + + pub const Error = struct { + /// A number indicating the error type that occurred. + code: Code, + /// A string providing a short description of the error. + message: []const u8, + /// A primitive or structured value that contains additional + /// information about the error. Can be omitted. + data: std.json.Value = .null, + + /// The error codes from and including -32768 to -32000 are reserved for pre-defined errors. Any code within this range, but not defined explicitly below is reserved for future use. + /// The remainder of the space is available for application defined errors. + pub const Code = enum(i64) { + /// Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text. + parse_error = -32700, + /// The JSON sent is not a valid Request object. + invalid_request = -32600, + /// The method does not exist / is not available. + method_not_found = -32601, + /// Invalid method parameter(s). + invalid_params = -32602, + /// Internal JSON-RPC error. + internal_error = -32603, + + /// -32000 to -32099 are reserved for implementation-defined server-errors. + _, + + pub fn jsonStringify(code: Code, stream: anytype) @TypeOf(stream.*).Error!void { + try stream.write(@intFromEnum(code)); + } + }; + }; + }; + + pub fn jsonParse( + allocator: std.mem.Allocator, + source: anytype, + options: std.json.ParseOptions, + ) std.json.ParseError(@TypeOf(source.*))!Message { + if (try source.next() != .object_begin) return error.UnexpectedToken; + + var fields: Fields = .{}; + + while (true) { + const field_name = blk: { + const name_token = try source.nextAllocMax(allocator, .alloc_if_needed, options.max_value_len.?); + const maybe_field_name = switch (name_token) { + inline .string, .allocated_string => |slice| std.meta.stringToEnum(std.meta.FieldEnum(Fields), slice), + .object_end => break, // No more fields. + else => return error.UnexpectedToken, + }; + + switch (name_token) { + .string => {}, + .allocated_string => |slice| allocator.free(slice), + else => unreachable, + } + + break :blk maybe_field_name orelse { + if (options.ignore_unknown_fields) { + try source.skipValue(); + continue; + } else { + return error.UnexpectedToken; + } + }; + }; + + // check for contradicting fields + switch (field_name) { + .jsonrpc => {}, + .id => {}, + .method, .params => { + const is_result_set = if (fields.result) |result| result != .null else false; + if (is_result_set or fields.@"error" != null) { + return error.UnexpectedToken; + } + }, + .result => { + if (fields.@"error" != null) { + return error.UnexpectedToken; + } + }, + .@"error" => { + const is_result_set = if (fields.result) |result| result != .null else false; + if (is_result_set) { + return error.UnexpectedToken; + } + }, + } + + switch (field_name) { + inline else => |comptime_field_name| { + if (comptime_field_name == field_name) { + if (@field(fields, @tagName(comptime_field_name))) |_| { + switch (options.duplicate_field_behavior) { + .use_first => { + _ = try Fields.parse(comptime_field_name, allocator, source, options); + break; + }, + .@"error" => return error.DuplicateField, + .use_last => {}, + } + } + @field(fields, @tagName(comptime_field_name)) = try Fields.parse(comptime_field_name, allocator, source, options); + } + }, + } + } + + return try fields.toMessage(); + } + + pub fn jsonParseFromValue( + allocator: std.mem.Allocator, + source: std.json.Value, + options: std.json.ParseOptions, + ) std.json.ParseFromValueError!Message { + if (source != .object) return error.UnexpectedToken; + + var fields: Fields = .{}; + + for (source.object.keys(), source.object.values()) |field_name, field_source| { + inline for (std.meta.fields(Fields)) |field| { + const field_enum = comptime std.meta.stringToEnum(std.meta.FieldEnum(Fields), field.name).?; + if (std.mem.eql(u8, field.name, field_name)) { + @field(fields, field.name) = try Fields.parseFromValue(field_enum, allocator, field_source, options); + break; + } + } else { + // Didn't match anything. + if (!options.ignore_unknown_fields) return error.UnknownField; + } + } + + return try fields.toMessage(); + } -pub const ResponseError = struct { - /// A number indicating the error type that occurred. - code: i64, - /// A string providing a short description of the error. - message: []const u8, + pub fn jsonStringify(message: Message, stream: anytype) @TypeOf(stream.*).Error!void { + try stream.beginObject(); + try stream.objectField("jsonrpc"); + try stream.write("2.0"); - /// A primitive or structured value that contains additional - /// information about the error. Can be omitted. - data: std.json.Value = .null, + switch (message) { + .request => |request| { + try stream.objectField("id"); + switch (request.id) { + .number => |number| try stream.write(number), + .string => |string| try stream.write(string), + } + try stream.objectField("method"); + try stream.write(request.method); + + if (request.params) |params_val| { + try stream.objectField("params"); + try stream.write(params_val); + } else if (stream.options.emit_null_optional_fields) { + try stream.objectField("params"); + try stream.write(null); + } + }, + .notification => |notification| { + try stream.objectField("method"); + try stream.write(notification.method); + + if (notification.params) |params_val| { + try stream.objectField("params"); + try stream.write(params_val); + } else if (stream.options.emit_null_optional_fields) { + try stream.objectField("params"); + try stream.write(null); + } + }, + .response => |response| { + if (response.id) |id_val| { + try stream.objectField("id"); + switch (id_val) { + .number => |number| try stream.write(number), + .string => |string| try stream.write(string), + } + } else if (stream.options.emit_null_optional_fields) { + try stream.objectField("id"); + try stream.write(null); + } + + try stream.objectField(if (response.result != null) "result" else "error"); + if (response.result) |result_val| { + try stream.write(result_val); + } else if (response.@"error") |error_val| { + try stream.write(error_val); + } else unreachable; + }, + } + try stream.endObject(); + } + + const Fields = struct { + jsonrpc: ?[]const u8 = null, + method: ?[]const u8 = null, + id: ?ID = null, + params: ?std.json.Value = null, + result: ?std.json.Value = null, + @"error": ?Response.Error = null, + + fn parse( + comptime field: std.meta.FieldEnum(@This()), + allocator: std.mem.Allocator, + source: anytype, + options: std.json.ParseOptions, + ) std.json.ParseError(@TypeOf(source.*))!std.meta.FieldType(@This(), field) { + return switch (field) { + .jsonrpc, .method => try std.json.innerParse([]const u8, allocator, source, options), + .id => switch (try source.peekNextTokenType()) { + .null => { + std.debug.assert(try source.next() == .null); + return null; + }, + .number => ID{ .number = try std.json.innerParse(i64, allocator, source, options) }, + .string => ID{ .string = try std.json.innerParse([]const u8, allocator, source, options) }, + else => error.UnexpectedToken, // "id" field must be null/integer/string + }, + .params => switch (try source.peekNextTokenType()) { + .null => { + std.debug.assert(try source.next() == .null); + return .null; + }, + .object_begin, .array_begin => try std.json.Value.jsonParse(allocator, source, options), + else => error.UnexpectedToken, // "params" field must be null/object/array + }, + .result => try std.json.Value.jsonParse(allocator, source, options), + .@"error" => try std.json.innerParse(Response.Error, allocator, source, options), + }; + } + + fn parseFromValue( + comptime field: std.meta.FieldEnum(@This()), + allocator: std.mem.Allocator, + source: std.json.Value, + options: std.json.ParseOptions, + ) std.json.ParseFromValueError!std.meta.FieldType(@This(), field) { + return switch (field) { + .jsonrpc, .method => try std.json.innerParseFromValue([]const u8, allocator, source, options), + .id => switch (source) { + .null => null, + .integer => |number| ID{ .number = number }, + .string => |string| ID{ .string = string }, + else => error.UnexpectedToken, // "id" field must be null/integer/string + }, + .params => switch (source) { + .null, .object, .array => source, + else => error.UnexpectedToken, // "params" field must be null/object/array + }, + .result => source, + .@"error" => try std.json.innerParseFromValue(Response.Error, allocator, source, options), + }; + } + + fn toMessage(self: Fields) !Message { + const jsonrpc = self.jsonrpc orelse + return error.MissingField; + if (!std.mem.eql(u8, jsonrpc, "2.0")) + return error.UnexpectedToken; // the "jsonrpc" field must be "2.0" + + if (self.method) |method_val| { + if (self.result != null or self.@"error" != null) { + return error.UnexpectedToken; // the "method" field indicates a request or notification which can't have the "result" or "error" field + } + if (self.params) |params_val| { + switch (params_val) { + .null, .object, .array => {}, + else => unreachable, + } + } + + if (self.id) |id_val| { + return Message{ + .request = Request{ + .method = method_val, + .params = self.params, + .id = id_val, + }, + }; + } else { + return Message{ + .notification = Notification{ + .method = method_val, + .params = self.params, + }, + }; + } + } else { + if (self.@"error" != null) { + const is_result_set = if (self.result) |result| result != .null else false; + if (is_result_set) return error.UnexpectedToken; // the "result" and "error" fields can't both be set + } else { + const is_result_set = self.result != null; + if (!is_result_set) return error.MissingField; + } + + return Message{ + .response = Response{ + .result = self.result, + .@"error" = self.@"error", + .id = self.id, + }, + }; + } + } + }; + + test Request { + try testParse( + \\{"jsonrpc": "2.0", "id": 1, "method": "Die", "params": null} + , .{ + .request = .{ + .id = .{ .number = 1 }, + .method = "Die", + .params = .null, + }, + }, .{}); + try testParse( + \\{"id": "Würde", "method": "des", "params": null, "jsonrpc": "2.0"} + , .{ + .request = .{ + .id = .{ .string = "Würde" }, + .method = "des", + .params = .null, + }, + }, .{}); + try testParse( + \\{"method": "ist", "params": {}, "jsonrpc": "2.0", "id": "Menschen"} + , .{ + .request = .{ + .id = .{ .string = "Menschen" }, + .method = "ist", + .params = .{ .object = undefined }, + }, + }, .{}); + try testParse( + \\{"method": ".", "jsonrpc": "2.0", "id": "unantastbar"} + , .{ + .request = .{ + .id = .{ .string = "unantastbar" }, + .method = ".", + .params = null, + }, + }, .{}); + } + + test Notification { + try testParse( + \\{"jsonrpc": "2.0", "method": "foo", "params": null} + , .{ + .notification = .{ + .method = "foo", + .params = .null, + }, + }, .{}); + try testParse( + \\{"method": "bar", "params": null, "jsonrpc": "2.0"} + , .{ + .notification = .{ + .method = "bar", + .params = .null, + }, + }, .{}); + try testParse( + \\{"params": [], "method": "baz", "jsonrpc": "2.0"} + , .{ + .notification = .{ + .method = "baz", + .params = .{ .array = undefined }, + }, + }, .{}); + try testParse( + \\{"method": "booze?", "jsonrpc": "2.0"} + , .{ + .notification = .{ + .method = "booze?", + .params = null, + }, + }, .{}); + } + + test "Notification allow setting the 'id' field to null" { + try testParse( + \\{"jsonrpc": "2.0", "id": null, "method": "foo", "params": null} + , .{ + .notification = .{ + .method = "foo", + .params = .null, + }, + }, .{}); + } + + test Response { + try testParse( + \\{"jsonrpc": "2.0", "id": 1, "result": null} + , .{ .response = .{ + .id = .{ .number = 1 }, + .result = .null, + .@"error" = null, + } }, .{}); + + try testParseExpectedError( + \\{"jsonrpc": "2.0", "id": 1} + , + error.MissingField, + error.MissingField, + .{}, + ); + + try testParse( + \\{"id": "id", "jsonrpc": "2.0", "result": null, "error": {"code": 3, "message": "foo", "data": null}} + , .{ .response = .{ + .id = .{ .string = "id" }, + .result = .null, + .@"error" = .{ .code = @enumFromInt(3), .message = "foo", .data = .null }, + } }, .{}); + try testParse( + \\{"id": "id", "jsonrpc": "2.0", "error": {"code": 42, "message": "bar"}} + , .{ .response = .{ + .id = .{ .string = "id" }, + .result = null, + .@"error" = .{ .code = @enumFromInt(42), .message = "bar", .data = .null }, + } }, .{}); + } + + test "validate that the 'params' is null/array/object" { + // null + try testParse( + \\{"jsonrpc": "2.0", "id": 1, "method": "foo", "params": null} + , .{ .request = .{ + .id = .{ .number = 1 }, + .method = "foo", + .params = .null, + } }, .{}); + try testParse( + \\{"jsonrpc": "2.0", "id": 1, "method": "foo"} + , .{ .request = .{ + .id = .{ .number = 1 }, + .method = "foo", + .params = null, + } }, .{}); + + // bool + try testParseExpectedError( + \\{"jsonrpc": "2.0", "id": 1, "method": "foo", "params": true} + , + error.UnexpectedToken, + error.UnexpectedToken, + .{}, + ); + + // integer + try testParseExpectedError( + \\{"jsonrpc": "2.0", "id": 1, "method": "foo", "params": 5} + , + error.UnexpectedToken, + error.UnexpectedToken, + .{}, + ); + + // float + try testParseExpectedError( + \\{"jsonrpc": "2.0", "id": 1, "method": "foo", "params": 4.2} + , + error.UnexpectedToken, + error.UnexpectedToken, + .{}, + ); + + // string + try testParseExpectedError( + \\{"jsonrpc": "2.0", "id": 1, "method": "foo", "params": "bar"} + , + error.UnexpectedToken, + error.UnexpectedToken, + .{}, + ); + + // array + try testParse( + \\{"jsonrpc": "2.0", "id": 1, "method": "foo", "params": []} + , .{ .request = .{ + .id = .{ .number = 1 }, + .method = "foo", + .params = .{ .array = undefined }, + } }, .{}); + + // object + try testParse( + \\{"jsonrpc": "2.0", "id": 1, "method": "foo", "params": {}} + , .{ .request = .{ + .id = .{ .number = 1 }, + .method = "foo", + .params = .{ .object = undefined }, + } }, .{}); + } + + test "ignore_unknown_fields" { + try testParse( + \\{"jsonrpc": "2.0", "id": 1, "other": null, "method": "foo", "params": null, "extra": "."} + , .{ + .request = .{ + .id = .{ .number = 1 }, + .method = "foo", + .params = .null, + }, + }, .{ .ignore_unknown_fields = true }); + try testParse( + \\{"other": "", "jsonrpc": "2.0", "extra": {}, "method": "bar"} + , .{ + .notification = .{ + .method = "bar", + .params = null, + }, + }, .{ .ignore_unknown_fields = true }); + try testParseExpectedError( + \\{"jsonrpc": "2.0", "id": 1, "other": null, ".": "Sie", "params": {}, "extra": {}} + , + error.UnexpectedToken, + error.UnknownField, + .{ .ignore_unknown_fields = false }, + ); + } + + fn testParse(message: []const u8, expected: Message, parse_options: std.json.ParseOptions) !void { + const allocator = std.testing.allocator; + + const parsed_from_slice = try std.json.parseFromSlice(Message, allocator, message, parse_options); + defer parsed_from_slice.deinit(); + + const parsed_value = try std.json.parseFromSlice(std.json.Value, allocator, message, parse_options); + defer parsed_value.deinit(); + + const parsed_from_value = try std.json.parseFromValue(Message, allocator, parsed_value.value, parse_options); + defer parsed_from_value.deinit(); + + const from_slice_stringified = try std.json.stringifyAlloc(allocator, parsed_from_slice.value, .{ .whitespace = .indent_2 }); + defer allocator.free(from_slice_stringified); + + const from_value_stringified = try std.json.stringifyAlloc(allocator, parsed_from_value.value, .{ .whitespace = .indent_2 }); + defer allocator.free(from_value_stringified); + + if (!std.mem.eql(u8, from_slice_stringified, from_value_stringified)) { + std.debug.print( + \\ + \\====== std.json.parseFromSlice: ====== + \\{s} + \\====== std.json.parseFromValue: ====== + \\{s} + \\======================================\ + \\ + , .{ from_slice_stringified, from_value_stringified }); + return error.TestExpectedEqual; + } + + try expectEqual(parsed_from_slice.value, parsed_from_value.value); + try expectEqual(parsed_from_slice.value, expected); + try expectEqual(parsed_from_value.value, expected); + } + + fn testParseExpectedError( + message: []const u8, + expected_parse_error: std.json.ParseError(std.json.Scanner), + expected_parse_from_error: std.json.ParseFromValueError, + parse_options: std.json.ParseOptions, + ) !void { + const allocator = std.testing.allocator; + + try std.testing.expectError(expected_parse_error, std.json.parseFromSlice(Message, allocator, message, parse_options)); + + const parsed_value = std.json.parseFromSlice(std.json.Value, allocator, message, parse_options) catch |err| { + try std.testing.expectEqual(expected_parse_from_error, err); + return; + }; + defer parsed_value.deinit(); + + try std.testing.expectError(expected_parse_from_error, std.json.parseFromValue(Message, allocator, parsed_value.value, parse_options)); + } + + fn expectEqual(a: Message, b: Message) !void { + try std.testing.expectEqual(std.meta.activeTag(a), std.meta.activeTag(b)); + switch (a) { + .request => { + try std.testing.expectEqualDeep(a.request.id, b.request.id); + try std.testing.expectEqualStrings(a.request.method, b.request.method); + + // this only a shallow equality check + try std.testing.expectEqual(a.request.params == null, b.request.params == null); + if (a.request.params != null) { + try std.testing.expectEqual(std.meta.activeTag(a.request.params.?), std.meta.activeTag(b.request.params.?)); + } + }, + .notification => { + try std.testing.expectEqualStrings(a.notification.method, b.notification.method); + + // this only a shallow equality check + try std.testing.expectEqual(a.notification.params == null, b.notification.params == null); + if (a.notification.params != null) { + try std.testing.expectEqual(std.meta.activeTag(a.notification.params.?), std.meta.activeTag(b.notification.params.?)); + } + }, + .response => { + try std.testing.expectEqualDeep(a.response.id, b.response.id); + try std.testing.expectEqualDeep(a.response.@"error", b.response.@"error"); + + // this only a shallow equality check + try std.testing.expectEqual(a.response.result == null, b.response.result == null); + if (a.response.result != null) { + try std.testing.expectEqual(std.meta.activeTag(a.response.result.?), std.meta.activeTag(b.response.result.?)); + } + }, + } + } }; /// Indicates in which direction a message is sent in the protocol. From a6323aa8d4f2b7ee4c48abad39f299b75036bdf0 Mon Sep 17 00:00:00 2001 From: Techatrix <19954306+Techatrix@users.noreply.github.com> Date: Wed, 27 Mar 2024 00:59:45 +0100 Subject: [PATCH 2/2] revive tests --- .github/workflows/main.yml | 10 ++- README.md | 4 +- build.zig | 20 +++--- src/base.zig | 4 +- tests/tests.zig | 128 +++++++++++++++++++++++-------------- 5 files changed, 101 insertions(+), 65 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index b107ee2..0d50610 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -20,18 +20,16 @@ jobs: - run: zig env - - run: zig build - - - name: Build artifacts + - name: zig build test run: | wget https://raw.githubusercontent.com/microsoft/vscode-languageserver-node/main/protocol/metaModel.json - zig build run -- metaModel.json artifacts/lsp.zig + zig build test - - run: zig fmt --ast-check --check artifacts/lsp.zig + - run: zig fmt --ast-check --check zig-out/artifacts/lsp.zig - name: Upload artifacts if: ${{ matrix.os == 'ubuntu-latest' }} uses: actions/upload-artifact@v2 with: name: builds - path: artifacts/* + path: zig-out/artifacts/* diff --git a/README.md b/README.md index bfeae3a..358f1f9 100644 --- a/README.md +++ b/README.md @@ -6,5 +6,5 @@ Zig LSP codegen from the newly released, official metamodel! This actually good 1. `git clone` 2. Plop `metaModel.json` in this cloned repo. A copy can be found [here](https://github.com/microsoft/vscode-languageserver-node/blob/main/protocol/metaModel.json). -3. `zig build run -- metaModel.json lsp.zig` -4. Tada! You should now have a `lsp.zig` file that can be used to your heart's content! Enjoy :) +3. `zig build` +4. Tada! You should now have a `zig-out/artifacts/lsp.zig` file that can be used to your heart's content! Enjoy :) diff --git a/build.zig b/build.zig index b3edd9d..e9b8144 100644 --- a/build.zig +++ b/build.zig @@ -4,6 +4,8 @@ pub fn build(b: *std.Build) void { const target = b.standardTargetOptions(.{}); const optimize = b.standardOptimizeOption(.{}); + const meta_model_path = b.option([]const u8, "meta-model", "Specify path to the metaMode.json") orelse "metaModel.json"; + const exe = b.addExecutable(.{ .name = "zig-lsp-codegen", .root_source_file = .{ .path = "src/main.zig" }, @@ -12,15 +14,16 @@ pub fn build(b: *std.Build) void { }); b.installArtifact(exe); - const run_cmd = b.addRunArtifact(exe); - run_cmd.step.dependOn(b.getInstallStep()); - - if (b.args) |args| { - run_cmd.addArgs(args); - } + const run_codegen = b.addRunArtifact(exe); + run_codegen.addFileArg(.{ .cwd_relative = meta_model_path }); + const lsp_output_path = run_codegen.addOutputFileArg("lsp.zig"); - const run_step = b.step("run", "Run the app"); - run_step.dependOn(&run_cmd.step); + const lsp_module = b.addModule("lsp", .{ + .root_source_file = lsp_output_path, + .target = target, + .optimize = optimize, + }); + b.getInstallStep().dependOn(&b.addInstallFile(lsp_output_path, "artifacts/lsp.zig").step); const test_step = b.step("test", "Run all the tests"); test_step.dependOn(b.getInstallStep()); @@ -30,6 +33,7 @@ pub fn build(b: *std.Build) void { .target = target, .optimize = optimize, }); + tests.root_module.addImport("lsp", lsp_module); test_step.dependOn(&b.addRunArtifact(tests).step); } diff --git a/src/base.zig b/src/base.zig index 34dbd2e..6f75afc 100644 --- a/src/base.zig +++ b/src/base.zig @@ -10,7 +10,7 @@ pub const RegExp = []const u8; pub const LSPAny = std.json.Value; pub const LSPArray = []LSPAny; -pub const LSPObject = std.json.ObjectMap; +pub const LSPObject = std.json.ArrayHashMap(std.json.Value); pub const Message = union(enum) { request: Request, @@ -808,7 +808,7 @@ pub fn EnumCustomStringValues(comptime T: type, comptime contains_empty_enum: bo } pub fn jsonParse(allocator: std.mem.Allocator, source: anytype, options: std.json.ParseOptions) std.json.ParseError(@TypeOf(source.*))!T { - const slice = try std.json.Value.jsonParse(allocator, source, options); + const slice = try std.json.innerParse([]const u8, allocator, source, options); if (contains_empty_enum and slice.len == 0) return .empty; return map.get(slice) orelse return .{ .custom_value = slice }; } diff --git a/tests/tests.zig b/tests/tests.zig index c2ba087..b03af04 100644 --- a/tests/tests.zig +++ b/tests/tests.zig @@ -3,34 +3,34 @@ const Server = @This(); const lsp = @import("lsp"); const std = @import("std"); -const SampleDirection = enum { - client_to_server, - server_to_client, -}; +const SampleEntry = struct { + isLSPMessage: bool, + type: Kind, + message: std.json.Value, + timestamp: u64, -const SampleEntryKind = enum { - @"send-request", - @"receive-request", + const Kind = enum { + @"send-request", + @"receive-request", - @"send-response", - @"receive-response", + @"send-notification", + @"receive-notification", - @"send-notification", - @"receive-notification", + @"send-response", + @"receive-response", - fn getDirection(self: SampleEntryKind) SampleDirection { - return switch (self) { - .@"send-request", .@"send-response", .@"send-notification" => .client_to_server, - else => .server_to_client, - }; - } -}; + fn getDirection(self: Kind) Direction { + switch (self) { + .@"send-request", .@"send-response", .@"send-notification" => return .client_to_server, + .@"receive-request", .@"receive-notification", .@"receive-response" => return .server_to_client, + } + } + }; -// TODO: Handle responses -const SampleEntry = struct { - isLSPMessage: bool, - type: SampleEntryKind, - message: std.json.Value, + const Direction = enum { + client_to_server, + server_to_client, + }; }; test { @@ -43,38 +43,72 @@ test { defer read_buffer.deinit(); while (true) { - try reader.readUntilDelimiterArrayList(&read_buffer, '\n', std.math.maxInt(u32)) catch |err| switch (err) { + read_buffer.clearRetainingCapacity(); + reader.readUntilDelimiterArrayList(&read_buffer, '\n', std.math.maxInt(u32)) catch |err| switch (err) { error.EndOfStream => break, else => |e| return e, }; const parsed_sample_entry = try std.json.parseFromSlice(SampleEntry, std.testing.allocator, read_buffer.items, .{}); + defer parsed_sample_entry.deinit(); const sample_entry = parsed_sample_entry.value; if (sample_entry.isLSPMessage) { - switch (sample_entry.type) { - .@"send-notification", - .@"receive-notification", - => a: { - _ = tres.parse(lsp.Notification, sample_entry.message, std.testing.allocator) catch |err| { - // Ignore unknown methods such as custom VSCode LSP methods - if (err == error.UnknownMethod) break :a; - std.log.err("Cannot handle Request or Notification of method \"{s}\"", .{entry.message.Object.get("method").?.String}); - break :a; - }; - }, - .@"send-request", - .@"receive-request", - => a: { - _ = tres.parse(lsp.Request, entry.message, std.testing.allocator) catch |err| { - // Ignore unknown methods such as custom VSCode LSP methods - if (err == error.UnknownMethod) break :a; - std.log.err("Cannot handle Request or Notification of method \"{s}\"", .{entry.message.Object.get("method").?.String}); - break :a; - }; - }, - else => {}, - } + const message = try std.json.parseFromValue(lsp.Message, std.testing.allocator, sample_entry.message, .{}); + defer message.deinit(); + + const MessageTag = std.meta.Tag(lsp.Message); + const expected_tag: MessageTag = switch (sample_entry.type) { + .@"send-request", .@"receive-request" => .request, + .@"send-notification", .@"receive-notification" => .notification, + .@"send-response", .@"receive-response" => .response, + }; + try std.testing.expectEqual(expected_tag, std.meta.activeTag(message.value)); + } else { + @panic("TODO"); } } } + +comptime { + for (lsp.notification_metadata) |metadata| { + if (metadata.Params) |Params| { + testType(Params); + } + } + for (lsp.request_metadata) |metadata| { + if (std.mem.eql(u8, metadata.method, "textDocument/selectionRange")) continue; // TODO + if (metadata.Params) |Params| { + testType(Params); + } + testType(metadata.Result); + if (metadata.PartialResult) |PartialResult| { + testType(PartialResult); + } + if (metadata.ErrorData) |ErrorData| { + testType(ErrorData); + } + } +} + +fn testType(comptime T: type) void { + if (T == void) return; + if (T == ?void) return; + + const S = struct { + fn parseFromValue() void { + _ = std.json.parseFromValue(T, undefined, undefined, undefined) catch unreachable; + } + fn innerParse() void { + var source: std.json.Scanner = undefined; + _ = std.json.innerParse(T, undefined, &source, undefined) catch unreachable; + } + fn stringify() void { + const value: T = undefined; + _ = std.json.stringify(value, undefined, std.io.null_writer) catch unreachable; + } + }; + _ = &S.parseFromValue; + _ = &S.innerParse; + _ = &S.stringify; +}