From ddcf6c677bcbb182e85aaa07281a47ae5ff6f102 Mon Sep 17 00:00:00 2001 From: Alexandros Naskos Date: Tue, 30 Jun 2020 01:34:21 +0300 Subject: [PATCH] Start working on a better proccess JSON RPC --- src/main.zig | 816 ++++++++++++++++++++-------------------- src/requests.zig | 188 +++++++++ src/semantic_tokens.zig | 9 +- src/types.zig | 16 +- 4 files changed, 608 insertions(+), 421 deletions(-) create mode 100644 src/requests.zig diff --git a/src/main.zig b/src/main.zig index bce110a..b728f92 100644 --- a/src/main.zig +++ b/src/main.zig @@ -6,6 +6,7 @@ const DocumentStore = @import("document_store.zig"); const DebugAllocator = @import("debug_allocator.zig"); const readRequestHeader = @import("header.zig").readRequestHeader; const data = @import("data/" ++ build_options.data_version ++ ".zig"); +const requests = @import("requests.zig"); const types = @import("types.zig"); const analysis = @import("analysis.zig"); const URI = @import("uri.zig"); @@ -25,7 +26,10 @@ pub fn log( comptime format: []const u8, args: var, ) void { - var message = std.fmt.allocPrint(allocator, "[{}-{}] " ++ format, .{ @tagName(message_level), @tagName(scope) } ++ args) catch |err| { + var arena = std.heap.ArenaAllocator.init(allocator); + defer arena.deinit(); + + var message = std.fmt.allocPrint(&arena.allocator, "[{}-{}] " ++ format, .{ @tagName(message_level), @tagName(scope) } ++ args) catch |err| { std.debug.print("Failed to allocPrint message.", .{}); return; }; @@ -37,7 +41,7 @@ pub fn log( .err => .Error, else => .Error, }; - send(types.Notification{ + send(&arena, types.Notification{ .method = "window/showMessage", .params = types.NotificationParams{ .ShowMessageParams = .{ @@ -54,7 +58,7 @@ pub fn log( else .Info; - send(types.Notification{ + send(&arena, types.Notification{ .method = "window/logMessage", .params = types.NotificationParams{ .LogMessageParams = .{ @@ -113,14 +117,11 @@ const no_semantic_tokens_response = ; /// Sends a request or response -fn send(reqOrRes: var) !void { - var arena = std.heap.ArenaAllocator.init(allocator); - defer arena.deinit(); - +fn send(arena: *std.heap.ArenaAllocator, reqOrRes: var) !void { var arr = std.ArrayList(u8).init(&arena.allocator); try std.json.stringify(reqOrRes, .{}, arr.writer()); - const stdout_stream = stdout.outStream(); + const stdout_stream = stdout.writer(); try stdout_stream.print("Content-Length: {}\r\n\r\n", .{arr.items.len}); try stdout_stream.writeAll(arr.items); try stdout.flush(); @@ -182,13 +183,9 @@ fn astLocationToRange(loc: std.zig.ast.Tree.Location) types.Range { }; } -fn publishDiagnostics(handle: DocumentStore.Handle, config: Config) !void { +fn publishDiagnostics(arena: *std.heap.ArenaAllocator, handle: DocumentStore.Handle, config: Config) !void { const tree = handle.tree; - // Use an arena for our local memory allocations. - var arena = std.heap.ArenaAllocator.init(allocator); - defer arena.deinit(); - var diagnostics = std.ArrayList(types.Diagnostic).init(&arena.allocator); for (tree.errors) |*err| { @@ -249,7 +246,7 @@ fn publishDiagnostics(handle: DocumentStore.Handle, config: Config) !void { } } - try send(types.Notification{ + try send(arena, types.Notification{ .method = "textDocument/publishDiagnostics", .params = .{ .PublishDiagnosticsParams = .{ @@ -1001,9 +998,127 @@ fn configFromUriOr(uri: []const u8, default: Config) Config { return default; } -// TODO Rewrite this, use a ComptimeStringMap that points to a fn pointer + Param type to decode into and pass to the function -// Split into multiple files? -fn processJsonRpc(parser: *std.json.Parser, json: []const u8, config: Config, keep_running: *bool) !void { +fn initializeHandler(arena: *std.heap.ArenaAllocator, id: types.RequestId, req: requests.Initialize, config: Config) !void { + if (req.params.capabilities.workspace) |workspace| { + client_capabilities.supports_workspace_folders = workspace.workspaceFolders.value; + } + + if (req.params.capabilities.textDocument) |textDocument| { + client_capabilities.supports_semantic_tokens = textDocument.semanticTokens.exists; + if (textDocument.hover) |hover| { + for (hover.contentFormat.value) |format| { + if (std.mem.eql(u8, "markdown", format)) { + client_capabilities.hover_supports_md = true; + } + } + } + if (textDocument.completion) |completion| { + if (completion.completionItem) |completionItem| { + client_capabilities.supports_snippets = completionItem.snippetSupport.value; + for (completionItem.documentationFormat.value) |documentationFormat| { + if (std.mem.eql(u8, "markdown", documentationFormat)) { + client_capabilities.completion_doc_supports_md = true; + } + } + } + } + } + + if (req.params.workspaceFolders) |workspaceFolders| { + if (workspaceFolders.len != 0) { + std.log.debug(.main, "Got workspace folders in initialization.\n", .{}); + } + for (workspaceFolders) |workspace_folder| { + std.log.debug(.main, "Loaded folder {}\n", .{workspace_folder.uri}); + const duped_uri = try std.mem.dupe(allocator, u8, workspace_folder.uri); + try workspace_folder_configs.putNoClobber(duped_uri, null); + } + try loadWorkspaceConfigs(); + } + + std.log.debug(.main, "{}\n", .{client_capabilities}); + try respondGeneric(id, initialize_response); + std.log.notice(.main, "zls initialized", .{}); +} + +var keep_running = true; +fn shutdownHandler(arena: *std.heap.ArenaAllocator, id: types.RequestId, config: Config) !void { + keep_running = false; + // Technically we should deinitialize first and send possible errors to the client + try respondGeneric(id, null_result_response); +} + +fn workspaceFoldersChangeHandler(arena: *std.heap.ArenaAllocator, id: types.RequestId, req: requests.WorkspaceFoldersChange, config: Config) !void { + for (req.params.event.removed) |rem| { + if (workspace_folder_configs.remove(rem.uri)) |entry| { + allocator.free(entry.key); + if (entry.value) |c| { + std.json.parseFree(Config, c, std.json.ParseOptions{ .allocator = allocator }); + } + } + } + + for (req.params.event.added) |add| { + const duped_uri = try std.mem.dupe(allocator, u8, add.uri); + if (try workspace_folder_configs.put(duped_uri, null)) |old| { + allocator.free(old.key); + if (old.value) |c| { + std.json.parseFree(Config, c, std.json.ParseOptions{ .allocator = allocator }); + } + } + } + + try loadWorkspaceConfigs(); +} + +fn openDocumentHandler(arena: *std.heap.ArenaAllocator, id: types.RequestId, req: requests.OpenDocument, config: Config) !void { + const handle = try document_store.openDocument(req.params.textDocument.uri, req.params.textDocument.text); + try publishDiagnostics(arena, handle.*, configFromUriOr(req.params.textDocument.uri, config)); +} + +fn changeDocumentHandler(arena: *std.heap.ArenaAllocator, id: types.RequestId, req: requests.ChangeDocument, config: Config) !void { + const handle = document_store.getHandle(req.params.textDocument.uri) orelse { + std.log.debug(.main, "Trying to change non existent document {}", .{req.params.textDocument.uri}); + return; + }; + + const local_config = configFromUriOr(req.params.textDocument.uri, config); + try document_store.applyChanges(handle, req.params.contentChanges.Array, local_config.zig_lib_path); + try publishDiagnostics(arena, handle.*, local_config); +} + +fn saveDocumentHandler(arena: *std.heap.ArenaAllocator, id: types.RequestId, req: requests.SaveDocument, config: Config) !void { + const handle = document_store.getHandle(req.params.textDocument.uri) orelse { + std.log.debug(.main, "Trying to save non existent document {}", .{req.params.textDocument.uri}); + return; + }; + try document_store.applySave(handle); +} + +fn closeDocumentHandler(arena: *std.heap.ArenaAllocator, id: types.RequestId, req: requests.CloseDocument, config: Config) !void { + document_store.closeDocument(req.params.textDocument.uri); +} + +fn semanticTokensHandler(arena: *std.heap.ArenaAllocator, id: types.RequestId, req: requests.SemanticTokens, config: Config) !void { + const this_config = configFromUriOr(req.params.textDocument.uri, config); + if (this_config.enable_semantic_tokens) { + const handle = document_store.getHandle(req.params.textDocument.uri) orelse { + std.log.debug(.main, "Trying to complete in non existent document {}", .{req.params.textDocument.uri}); + return try respondGeneric(id, no_semantic_tokens_response); + }; + + const semantic_tokens = @import("semantic_tokens.zig"); + const token_array = try semantic_tokens.writeAllSemanticTokens(arena, &document_store, handle); + + return try send(arena, types.Response{ + .id = id, + .result = .{ .SemanticTokens = .{ .data = token_array } }, + }); + } else + return try respondGeneric(id, no_semantic_tokens_response); +} + +fn processJsonRpc(arena: *std.heap.ArenaAllocator, parser: *std.json.Parser, json: []const u8, config: Config) !void { var tree = try parser.parse(json); defer tree.deinit(); @@ -1024,401 +1139,272 @@ fn processJsonRpc(parser: *std.json.Parser, json: []const u8, config: Config, ke std.log.debug(.main, "Took {}ms to process method {}\n", .{ end_time - start_time, method }); } - // Core - if (std.mem.eql(u8, method, "initialize")) { - const params = root.Object.getValue("params").?.Object; - const client_capabs = params.getValue("capabilities").?.Object; - if (client_capabs.getValue("workspace")) |workspace_capabs| { - if (workspace_capabs.Object.getValue("workspaceFolders")) |folders_capab| { - client_capabilities.supports_workspace_folders = folders_capab.Bool; - } - } + const method_map = .{ + .{ "initialize", .{ requests.Initialize, initializeHandler } }, + .{ "shutdown", .{ void, shutdownHandler } }, + .{ "initialized", .{} }, + .{ "$/cancelRequest", .{} }, + .{ "workspace/didChangeWorkspaceFolders", .{ requests.WorkspaceFoldersChange, workspaceFoldersChangeHandler } }, + .{ "textDocument/didOpen", .{ requests.OpenDocument, openDocumentHandler } }, + .{ "textDocument/didChange", .{ requests.ChangeDocument, changeDocumentHandler } }, + .{ "textDocument/didSave", .{ requests.SaveDocument, saveDocumentHandler } }, + .{ "textDocument/willSave", .{} }, + .{ "textDocument/didClose", .{ requests.CloseDocument, closeDocumentHandler } }, + .{ "textDocument/semanticTokens", .{ requests.SemanticTokens, semanticTokensHandler } }, + }; - if (client_capabs.getValue("textDocument")) |text_doc_capabs| { - if (text_doc_capabs.Object.getValue("semanticTokens")) |_| { - client_capabilities.supports_semantic_tokens = true; - } - - if (text_doc_capabs.Object.getValue("hover")) |hover_capabs| { - if (hover_capabs.Object.getValue("contentFormat")) |content_formats| { - for (content_formats.Array.items) |format| { - if (std.mem.eql(u8, "markdown", format.String)) { - client_capabilities.hover_supports_md = true; - } - } - } - } - - if (text_doc_capabs.Object.getValue("completion")) |completion_capabs| { - if (completion_capabs.Object.getValue("completionItem")) |item_capabs| { - const maybe_support_snippet = item_capabs.Object.getValue("snippetSupport"); - client_capabilities.supports_snippets = maybe_support_snippet != null and maybe_support_snippet.?.Bool; - - if (item_capabs.Object.getValue("documentationFormat")) |content_formats| { - for (content_formats.Array.items) |format| { - if (std.mem.eql(u8, "markdown", format.String)) { - client_capabilities.completion_doc_supports_md = true; - } - } - } - } - } - } - - if (params.getValue("workspaceFolders")) |workspace_folders| { - switch (workspace_folders) { - .Array => |folders| { - std.log.debug(.main, "Got workspace folders in initialization.\n", .{}); - - for (folders.items) |workspace_folder| { - const folder_uri = workspace_folder.Object.getValue("uri").?.String; - std.log.debug(.main, "Loaded folder {}\n", .{folder_uri}); - const duped_uri = try std.mem.dupe(allocator, u8, folder_uri); - try workspace_folder_configs.putNoClobber(duped_uri, null); - } - try loadWorkspaceConfigs(); - }, - else => {}, - } - } - - std.log.debug(.main, "{}\n", .{client_capabilities}); - try respondGeneric(id, initialize_response); - std.log.notice(.main, "zls initialized", .{}); - } else if (std.mem.eql(u8, method, "shutdown")) { - keep_running.* = false; - // Technically we shoudl deinitialize first and send possible errors to the client - try respondGeneric(id, null_result_response); - } else if (std.mem.eql(u8, method, "initialized")) { - // All gucci - } else if (std.mem.eql(u8, method, "$/cancelRequest")) { - // noop - } - // Workspace folder changes - else if (std.mem.eql(u8, method, "workspace/didChangeWorkspaceFolders")) { - const params = root.Object.getValue("params").?.Object; - const event = params.getValue("event").?.Object; - const added = event.getValue("added").?.Array; - const removed = event.getValue("removed").?.Array; - - for (removed.items) |rem| { - const uri = rem.Object.getValue("uri").?.String; - if (workspace_folder_configs.remove(uri)) |entry| { - allocator.free(entry.key); - if (entry.value) |c| { - std.json.parseFree(Config, c, std.json.ParseOptions{ .allocator = allocator }); - } - } - } - - for (added.items) |add| { - const duped_uri = try std.mem.dupe(allocator, u8, add.Object.getValue("uri").?.String); - if (try workspace_folder_configs.put(duped_uri, null)) |old| { - allocator.free(old.key); - if (old.value) |c| { - std.json.parseFree(Config, c, std.json.ParseOptions{ .allocator = allocator }); - } - } - } - - try loadWorkspaceConfigs(); - } - // File changes - else if (std.mem.eql(u8, method, "textDocument/didOpen")) { - const params = root.Object.getValue("params").?.Object; - const document = params.getValue("textDocument").?.Object; - const uri = document.getValue("uri").?.String; - const text = document.getValue("text").?.String; - - const handle = try document_store.openDocument(uri, text); - try publishDiagnostics(handle.*, configFromUriOr(uri, config)); - } else if (std.mem.eql(u8, method, "textDocument/didChange")) { - const params = root.Object.getValue("params").?.Object; - const text_document = params.getValue("textDocument").?.Object; - const uri = text_document.getValue("uri").?.String; - const content_changes = params.getValue("contentChanges").?.Array; - - const handle = document_store.getHandle(uri) orelse { - std.log.debug(.main, "Trying to change non existent document {}", .{uri}); - return; - }; - - const local_config = configFromUriOr(uri, config); - try document_store.applyChanges(handle, content_changes, local_config.zig_lib_path); - try publishDiagnostics(handle.*, local_config); - } else if (std.mem.eql(u8, method, "textDocument/didSave")) { - const params = root.Object.getValue("params").?.Object; - const text_document = params.getValue("textDocument").?.Object; - const uri = text_document.getValue("uri").?.String; - const handle = document_store.getHandle(uri) orelse { - std.log.debug(.main, "Trying to save non existent document {}", .{uri}); - return; - }; - - try document_store.applySave(handle); - } else if (std.mem.eql(u8, method, "textDocument/willSave")) { - // noop - } else if (std.mem.eql(u8, method, "textDocument/didClose")) { - const params = root.Object.getValue("params").?.Object; - const document = params.getValue("textDocument").?.Object; - const uri = document.getValue("uri").?.String; - - document_store.closeDocument(uri); - } - // Semantic highlighting - else if (std.mem.eql(u8, method, "textDocument/semanticTokens")) { - const params = root.Object.getValue("params").?.Object; - const document = params.getValue("textDocument").?.Object; - const uri = document.getValue("uri").?.String; - - const this_config = configFromUriOr(uri, config); - if (this_config.enable_semantic_tokens) { - const handle = document_store.getHandle(uri) orelse { - std.log.debug(.main, "Trying to complete in non existent document {}", .{uri}); - return try respondGeneric(id, no_semantic_tokens_response); - }; - - const semantic_tokens = @import("semantic_tokens.zig"); - const token_array = try semantic_tokens.writeAllSemanticTokens(allocator, &document_store, handle); - defer allocator.free(token_array); - - return try send(types.Response{ - .id = id, - .result = .{ .SemanticTokens = .{ .data = token_array } }, - }); - } else - return try respondGeneric(id, no_semantic_tokens_response); - } - // Autocomplete / Signatures - else if (std.mem.eql(u8, method, "textDocument/completion")) { - const params = root.Object.getValue("params").?.Object; - const text_document = params.getValue("textDocument").?.Object; - const uri = text_document.getValue("uri").?.String; - const position = params.getValue("position").?.Object; - - const handle = document_store.getHandle(uri) orelse { - std.log.debug(.main, "Trying to complete in non existent document {}", .{uri}); - return try respondGeneric(id, no_completions_response); - }; - - const pos = types.Position{ - .line = position.getValue("line").?.Integer, - .character = position.getValue("character").?.Integer, - }; - if (pos.character >= 0) { - const pos_index = try handle.document.positionToIndex(pos); - const pos_context = try analysis.documentPositionContext(allocator, handle.document, pos); - - const this_config = configFromUriOr(uri, config); - const use_snippets = this_config.enable_snippets and client_capabilities.supports_snippets; - switch (pos_context) { - .builtin => try send(types.Response{ - .id = id, - .result = .{ - .CompletionList = .{ - .isIncomplete = false, - .items = builtin_completions[@boolToInt(use_snippets)][0..], - }, - }, - }), - .var_access, .empty => try completeGlobal(id, pos_index, handle, this_config), - .field_access => |range| try completeFieldAccess(id, handle, pos, range, this_config), - .global_error_set => try send(types.Response{ - .id = id, - .result = .{ - .CompletionList = .{ - .isIncomplete = false, - .items = document_store.error_completions.completions.items, - }, - }, - }), - .enum_literal => try send(types.Response{ - .id = id, - .result = .{ - .CompletionList = .{ - .isIncomplete = false, - .items = document_store.enum_completions.completions.items, - }, - }, - }), - .label => try completeLabel(id, pos_index, handle, this_config), - else => try respondGeneric(id, no_completions_response), - } - } else { - try respondGeneric(id, no_completions_response); - } - } else if (std.mem.eql(u8, method, "textDocument/signatureHelp")) { - // TODO: Implement this - try respondGeneric(id, - \\,"result":{"signatures":[]}} - ); - } else if (std.mem.eql(u8, method, "textDocument/definition") or - std.mem.eql(u8, method, "textDocument/declaration") or - std.mem.eql(u8, method, "textDocument/typeDefinition") or - std.mem.eql(u8, method, "textDocument/implementation")) - { - const params = root.Object.getValue("params").?.Object; - const document = params.getValue("textDocument").?.Object; - const uri = document.getValue("uri").?.String; - const position = params.getValue("position").?.Object; - - const handle = document_store.getHandle(uri) orelse { - std.log.debug(.main, "Trying to got to definition in non existent document {}", .{uri}); - return try respondGeneric(id, null_result_response); - }; - - const pos = types.Position{ - .line = position.getValue("line").?.Integer, - .character = position.getValue("character").?.Integer, - }; - if (pos.character >= 0) { - const resolve_alias = !std.mem.eql(u8, method, "textDocument/declaration"); - const pos_index = try handle.document.positionToIndex(pos); - const pos_context = try analysis.documentPositionContext(allocator, handle.document, pos); - - switch (pos_context) { - .var_access => try gotoDefinitionGlobal(id, pos_index, handle, configFromUriOr(uri, config), resolve_alias), - .field_access => |range| try gotoDefinitionFieldAccess(id, handle, pos, range, configFromUriOr(uri, config), resolve_alias), - .string_literal => try gotoDefinitionString(id, pos_index, handle, config), - .label => try gotoDefinitionLabel(id, pos_index, handle, configFromUriOr(uri, config)), - else => try respondGeneric(id, null_result_response), - } - } else { - try respondGeneric(id, null_result_response); - } - } else if (std.mem.eql(u8, method, "textDocument/hover")) { - const params = root.Object.getValue("params").?.Object; - const document = params.getValue("textDocument").?.Object; - const uri = document.getValue("uri").?.String; - const position = params.getValue("position").?.Object; - - const handle = document_store.getHandle(uri) orelse { - std.log.debug(.main, "Trying to got to definition in non existent document {}", .{uri}); - return try respondGeneric(id, null_result_response); - }; - - const pos = types.Position{ - .line = position.getValue("line").?.Integer, - .character = position.getValue("character").?.Integer, - }; - if (pos.character >= 0) { - const pos_index = try handle.document.positionToIndex(pos); - const pos_context = try analysis.documentPositionContext(allocator, handle.document, pos); - - switch (pos_context) { - .var_access => try hoverDefinitionGlobal(id, pos_index, handle, configFromUriOr(uri, config)), - .field_access => |range| try hoverDefinitionFieldAccess(id, handle, pos, range, configFromUriOr(uri, config)), - .label => try hoverDefinitionLabel(id, pos_index, handle, configFromUriOr(uri, config)), - else => try respondGeneric(id, null_result_response), - } - } else { - try respondGeneric(id, null_result_response); - } - } else if (std.mem.eql(u8, method, "textDocument/documentSymbol")) { - const params = root.Object.getValue("params").?.Object; - const document = params.getValue("textDocument").?.Object; - const uri = document.getValue("uri").?.String; - - const handle = document_store.getHandle(uri) orelse { - std.log.debug(.main, "Trying to got to definition in non existent document {}", .{uri}); - return try respondGeneric(id, null_result_response); - }; - - try documentSymbol(id, handle); - } else if (std.mem.eql(u8, method, "textDocument/formatting")) { - if (config.zig_exe_path) |zig_exe_path| { - const params = root.Object.getValue("params").?.Object; - const document = params.getValue("textDocument").?.Object; - const uri = document.getValue("uri").?.String; - - const handle = document_store.getHandle(uri) orelse { - std.log.debug(.main, "Trying to got to definition in non existent document {}", .{uri}); - return try respondGeneric(id, null_result_response); - }; - - var process = try std.ChildProcess.init(&[_][]const u8{ zig_exe_path, "fmt", "--stdin" }, allocator); - defer process.deinit(); - process.stdin_behavior = .Pipe; - process.stdout_behavior = .Pipe; - - process.spawn() catch |err| { - std.log.debug(.main, "Failed to spawn zig fmt process, error: {}\n", .{err}); - return try respondGeneric(id, null_result_response); - }; - try process.stdin.?.writeAll(handle.document.text); - process.stdin.?.close(); - process.stdin = null; - - const stdout_bytes = try process.stdout.?.reader().readAllAlloc(allocator, std.math.maxInt(usize)); - defer allocator.free(stdout_bytes); - - switch (try process.wait()) { - .Exited => |code| if (code == 0) { - try send(types.Response{ - .id = id, - .result = .{ - .TextEdits = &[1]types.TextEdit{ - .{ - .range = handle.document.range(), - .newText = stdout_bytes, - }, + inline for (method_map) |method_info| { + if (std.mem.eql(u8, method_info[0], method)) { + if (method_info[1].len != 0) { + const info = method_info[1]; + if (info[0] != void) { + const request_obj = requests.fromDynamicTree(arena, info[0], tree.root) catch |err| { + switch (err) { + error.MalformedJson => { + std.log.debug(.main, "Could not create request type {} from JSON {}\n", .{ @typeName(info[0]), json }); + // @TODO What should we return to the client in this case? + return; }, - }, - }); - }, - else => {}, + error.OutOfMemory => return err, + } + }; + return try info[1](arena, id, request_obj, config); + } else { + return try info[1](arena, id, config); + } } } - return try respondGeneric(id, null_result_response); - } else if (std.mem.eql(u8, method, "textDocument/rename")) { - const params = root.Object.getValue("params").?.Object; - const document = params.getValue("textDocument").?.Object; - const uri = document.getValue("uri").?.String; - const position = params.getValue("position").?.Object; - - const handle = document_store.getHandle(uri) orelse { - std.log.debug(.main, "Trying to got to definition in non existent document {}", .{uri}); - return try respondGeneric(id, null_result_response); - }; - - const pos = types.Position{ - .line = position.getValue("line").?.Integer, - .character = position.getValue("character").?.Integer, - }; - if (pos.character >= 0) { - const new_name = params.getValue("newName").?.String; - const pos_index = try handle.document.positionToIndex(pos); - const pos_context = try analysis.documentPositionContext(allocator, handle.document, pos); - - const this_config = configFromUriOr(uri, config); - switch (pos_context) { - .var_access => try renameDefinitionGlobal(id, handle, pos_index, new_name), - .field_access => |range| try renameDefinitionFieldAccess(id, handle, pos, range, new_name, this_config), - .label => try renameDefinitionLabel(id, handle, pos_index, new_name), - else => try respondGeneric(id, null_result_response), - } - } else { - try respondGeneric(id, null_result_response); - } - } else if (std.mem.eql(u8, method, "textDocument/references") or - std.mem.eql(u8, method, "textDocument/documentHighlight") or - std.mem.eql(u8, method, "textDocument/codeAction") or - std.mem.eql(u8, method, "textDocument/codeLens") or - std.mem.eql(u8, method, "textDocument/documentLink") or - std.mem.eql(u8, method, "textDocument/rangeFormatting") or - std.mem.eql(u8, method, "textDocument/onTypeFormatting") or - std.mem.eql(u8, method, "textDocument/prepareRename") or - std.mem.eql(u8, method, "textDocument/foldingRange") or - std.mem.eql(u8, method, "textDocument/selectionRange")) - { - // TODO: Unimplemented methods, implement them and add them to server capabilities. - try respondGeneric(id, null_result_response); - } else if (root.Object.getValue("id")) |_| { - std.log.debug(.main, "Method with return value not implemented: {}", .{method}); - try respondGeneric(id, not_implemented_response); - } else { - std.log.debug(.main, "Method without return value not implemented: {}", .{method}); } + + // if (std.mem.eql(u8, method, "textDocument/completion")) { + // const params = root.Object.getValue("params").?.Object; + // const text_document = params.getValue("textDocument").?.Object; + // const uri = text_document.getValue("uri").?.String; + // const position = params.getValue("position").?.Object; + + // const handle = document_store.getHandle(uri) orelse { + // std.log.debug(.main, "Trying to complete in non existent document {}", .{uri}); + // return try respondGeneric(id, no_completions_response); + // }; + + // const pos = types.Position{ + // .line = position.getValue("line").?.Integer, + // .character = position.getValue("character").?.Integer, + // }; + // if (pos.character >= 0) { + // const pos_index = try handle.document.positionToIndex(pos); + // const pos_context = try analysis.documentPositionContext(allocator, handle.document, pos); + + // const this_config = configFromUriOr(uri, config); + // const use_snippets = this_config.enable_snippets and client_capabilities.supports_snippets; + // switch (pos_context) { + // .builtin => try send(types.Response{ + // .id = id, + // .result = .{ + // .CompletionList = .{ + // .isIncomplete = false, + // .items = builtin_completions[@boolToInt(use_snippets)][0..], + // }, + // }, + // }), + // .var_access, .empty => try completeGlobal(id, pos_index, handle, this_config), + // .field_access => |range| try completeFieldAccess(id, handle, pos, range, this_config), + // .global_error_set => try send(types.Response{ + // .id = id, + // .result = .{ + // .CompletionList = .{ + // .isIncomplete = false, + // .items = document_store.error_completions.completions.items, + // }, + // }, + // }), + // .enum_literal => try send(types.Response{ + // .id = id, + // .result = .{ + // .CompletionList = .{ + // .isIncomplete = false, + // .items = document_store.enum_completions.completions.items, + // }, + // }, + // }), + // .label => try completeLabel(id, pos_index, handle, this_config), + // else => try respondGeneric(id, no_completions_response), + // } + // } else { + // try respondGeneric(id, no_completions_response); + // } + // } else if (std.mem.eql(u8, method, "textDocument/signatureHelp")) { + // // TODO: Implement this + // try respondGeneric(id, + // \\,"result":{"signatures":[]}} + // ); + // } else if (std.mem.eql(u8, method, "textDocument/definition") or + // std.mem.eql(u8, method, "textDocument/declaration") or + // std.mem.eql(u8, method, "textDocument/typeDefinition") or + // std.mem.eql(u8, method, "textDocument/implementation")) + // { + // const params = root.Object.getValue("params").?.Object; + // const document = params.getValue("textDocument").?.Object; + // const uri = document.getValue("uri").?.String; + // const position = params.getValue("position").?.Object; + + // const handle = document_store.getHandle(uri) orelse { + // std.log.debug(.main, "Trying to got to definition in non existent document {}", .{uri}); + // return try respondGeneric(id, null_result_response); + // }; + + // const pos = types.Position{ + // .line = position.getValue("line").?.Integer, + // .character = position.getValue("character").?.Integer, + // }; + // if (pos.character >= 0) { + // const resolve_alias = !std.mem.eql(u8, method, "textDocument/declaration"); + // const pos_index = try handle.document.positionToIndex(pos); + // const pos_context = try analysis.documentPositionContext(allocator, handle.document, pos); + + // switch (pos_context) { + // .var_access => try gotoDefinitionGlobal(id, pos_index, handle, configFromUriOr(uri, config), resolve_alias), + // .field_access => |range| try gotoDefinitionFieldAccess(id, handle, pos, range, configFromUriOr(uri, config), resolve_alias), + // .string_literal => try gotoDefinitionString(id, pos_index, handle, config), + // .label => try gotoDefinitionLabel(id, pos_index, handle, configFromUriOr(uri, config)), + // else => try respondGeneric(id, null_result_response), + // } + // } else { + // try respondGeneric(id, null_result_response); + // } + // } else if (std.mem.eql(u8, method, "textDocument/hover")) { + // const params = root.Object.getValue("params").?.Object; + // const document = params.getValue("textDocument").?.Object; + // const uri = document.getValue("uri").?.String; + // const position = params.getValue("position").?.Object; + + // const handle = document_store.getHandle(uri) orelse { + // std.log.debug(.main, "Trying to got to definition in non existent document {}", .{uri}); + // return try respondGeneric(id, null_result_response); + // }; + + // const pos = types.Position{ + // .line = position.getValue("line").?.Integer, + // .character = position.getValue("character").?.Integer, + // }; + // if (pos.character >= 0) { + // const pos_index = try handle.document.positionToIndex(pos); + // const pos_context = try analysis.documentPositionContext(allocator, handle.document, pos); + + // switch (pos_context) { + // .var_access => try hoverDefinitionGlobal(id, pos_index, handle, configFromUriOr(uri, config)), + // .field_access => |range| try hoverDefinitionFieldAccess(id, handle, pos, range, configFromUriOr(uri, config)), + // .label => try hoverDefinitionLabel(id, pos_index, handle, configFromUriOr(uri, config)), + // else => try respondGeneric(id, null_result_response), + // } + // } else { + // try respondGeneric(id, null_result_response); + // } + // } else if (std.mem.eql(u8, method, "textDocument/documentSymbol")) { + // const params = root.Object.getValue("params").?.Object; + // const document = params.getValue("textDocument").?.Object; + // const uri = document.getValue("uri").?.String; + + // const handle = document_store.getHandle(uri) orelse { + // std.log.debug(.main, "Trying to got to definition in non existent document {}", .{uri}); + // return try respondGeneric(id, null_result_response); + // }; + + // try documentSymbol(id, handle); + // } else if (std.mem.eql(u8, method, "textDocument/formatting")) { + // if (config.zig_exe_path) |zig_exe_path| { + // const params = root.Object.getValue("params").?.Object; + // const document = params.getValue("textDocument").?.Object; + // const uri = document.getValue("uri").?.String; + + // const handle = document_store.getHandle(uri) orelse { + // std.log.debug(.main, "Trying to got to definition in non existent document {}", .{uri}); + // return try respondGeneric(id, null_result_response); + // }; + + // var process = try std.ChildProcess.init(&[_][]const u8{ zig_exe_path, "fmt", "--stdin" }, allocator); + // defer process.deinit(); + // process.stdin_behavior = .Pipe; + // process.stdout_behavior = .Pipe; + + // process.spawn() catch |err| { + // std.log.debug(.main, "Failed to spawn zig fmt process, error: {}\n", .{err}); + // return try respondGeneric(id, null_result_response); + // }; + // try process.stdin.?.writeAll(handle.document.text); + // process.stdin.?.close(); + // process.stdin = null; + + // const stdout_bytes = try process.stdout.?.reader().readAllAlloc(allocator, std.math.maxInt(usize)); + // defer allocator.free(stdout_bytes); + + // switch (try process.wait()) { + // .Exited => |code| if (code == 0) { + // try send(types.Response{ + // .id = id, + // .result = .{ + // .TextEdits = &[1]types.TextEdit{ + // .{ + // .range = handle.document.range(), + // .newText = stdout_bytes, + // }, + // }, + // }, + // }); + // }, + // else => {}, + // } + // } + // return try respondGeneric(id, null_result_response); + // } else if (std.mem.eql(u8, method, "textDocument/rename")) { + // const params = root.Object.getValue("params").?.Object; + // const document = params.getValue("textDocument").?.Object; + // const uri = document.getValue("uri").?.String; + // const position = params.getValue("position").?.Object; + + // const handle = document_store.getHandle(uri) orelse { + // std.log.debug(.main, "Trying to got to definition in non existent document {}", .{uri}); + // return try respondGeneric(id, null_result_response); + // }; + + // const pos = types.Position{ + // .line = position.getValue("line").?.Integer, + // .character = position.getValue("character").?.Integer, + // }; + // if (pos.character >= 0) { + // const new_name = params.getValue("newName").?.String; + // const pos_index = try handle.document.positionToIndex(pos); + // const pos_context = try analysis.documentPositionContext(allocator, handle.document, pos); + + // const this_config = configFromUriOr(uri, config); + // switch (pos_context) { + // .var_access => try renameDefinitionGlobal(id, handle, pos_index, new_name), + // .field_access => |range| try renameDefinitionFieldAccess(id, handle, pos, range, new_name, this_config), + // .label => try renameDefinitionLabel(id, handle, pos_index, new_name), + // else => try respondGeneric(id, null_result_response), + // } + // } else { + // try respondGeneric(id, null_result_response); + // } + // } else if (std.mem.eql(u8, method, "textDocument/references") or + // std.mem.eql(u8, method, "textDocument/documentHighlight") or + // std.mem.eql(u8, method, "textDocument/codeAction") or + // std.mem.eql(u8, method, "textDocument/codeLens") or + // std.mem.eql(u8, method, "textDocument/documentLink") or + // std.mem.eql(u8, method, "textDocument/rangeFormatting") or + // std.mem.eql(u8, method, "textDocument/onTypeFormatting") or + // std.mem.eql(u8, method, "textDocument/prepareRename") or + // std.mem.eql(u8, method, "textDocument/foldingRange") or + // std.mem.eql(u8, method, "textDocument/selectionRange")) + // { + // // TODO: Unimplemented methods, implement them and add them to server capabilities. + // try respondGeneric(id, null_result_response); + // } else if (root.Object.getValue("id")) |_| { + // std.log.debug(.main, "Method with return value not implemented: {}", .{method}); + // try respondGeneric(id, not_implemented_response); + // } else { + // std.log.debug(.main, "Method without return value not implemented: {}", .{method}); + // } } var debug_alloc_state: DebugAllocator = undefined; @@ -1545,18 +1531,22 @@ pub fn main() anyerror!void { var json_parser = std.json.Parser.init(allocator, false); defer json_parser.deinit(); - var keep_running = true; + // Arena used for temporary allocations while handlign a request + var arena = std.heap.ArenaAllocator.init(allocator); + defer arena.deinit(); + while (keep_running) { - const headers = readRequestHeader(allocator, reader) catch |err| { + const headers = readRequestHeader(&arena.allocator, reader) catch |err| { std.log.debug(.main, "{}; exiting!", .{@errorName(err)}); return; }; - defer headers.deinit(allocator); - const buf = try allocator.alloc(u8, headers.content_length); - defer allocator.free(buf); + const buf = try arena.allocator.alloc(u8, headers.content_length); try reader.readNoEof(buf); - try processJsonRpc(&json_parser, buf, config, &keep_running); + + try processJsonRpc(&arena, &json_parser, buf, config); json_parser.reset(); + arena.deinit(); + arena.state.buffer_list = .{}; if (debug_alloc) |dbg| { std.log.debug(.main, "{}\n", .{dbg.info}); diff --git a/src/requests.zig b/src/requests.zig new file mode 100644 index 0000000..efd4f06 --- /dev/null +++ b/src/requests.zig @@ -0,0 +1,188 @@ +const std = @import("std"); +const types = @import("types.zig"); + +/// Only check for the field's existence. +const Exists = struct { + exists: bool, +}; + +fn Default(comptime T: type, comptime default_value: T) type { + return struct { + pub const value_type = T; + pub const default = default_value; + value: T, + }; +} + +fn Transform(comptime Original: type, comptime transform_fn: var) type { + return struct { + pub const original_type = Original; + pub const transform = transform_fn; + + value: @TypeOf(transform(@as(Original, undefined))), + }; +} + +inline fn fromDynamicTreeInternal(arena: *std.heap.ArenaAllocator, value: std.json.Value, out: var) error{ MalformedJson, OutOfMemory }!void { + const T = comptime std.meta.Child(@TypeOf(out)); + + if (comptime std.meta.trait.is(.Struct)(T)) { + if (value != .Object) return error.MalformedJson; + + var err = false; + inline for (std.meta.fields(T)) |field| { + const is_exists = field.field_type == Exists; + + const is_optional = comptime std.meta.trait.is(.Optional)(field.field_type); + const actual_type = if (is_optional) std.meta.Child(field.field_type) else field.field_type; + + const is_struct = comptime std.meta.trait.is(.Struct)(actual_type); + const is_default = comptime if (is_struct) std.meta.trait.hasDecls(actual_type, .{ "default", "value_type" }) else false; + const is_transform = comptime if (is_struct) std.meta.trait.hasDecls(actual_type, .{ "original_type", "transform" }) else false; + + if (value.Object.getValue(field.name)) |json_field| { + if (is_exists) { + @field(out, field.name) = Exists{ .exists = true }; + } else if (is_transform) { + var original_value: actual_type.original_type = undefined; + try fromDynamicTreeInternal(arena, json_field, &original_value); + @field(out, field.name) = actual_type{ .value = actual_type.transform(original_value) catch return error.MalformedJson }; + } else if (is_default) { + try fromDynamicTreeInternal(arena, json_field, &@field(out, field.name).value); + } else if (is_optional) { + if (json_field == .Null) { + @field(out, field.name) = null; + } else { + var actual_value: actual_type = undefined; + try fromDynamicTreeInternal(arena, json_field, &actual_value); + @field(out, field.name) = actual_value; + } + } else { + try fromDynamicTreeInternal(arena, json_field, &@field(out, field.name)); + } + } else { + if (is_exists) { + @field(out, field.name) = Exists{ .exists = false }; + } else if (is_optional) { + @field(out, field.name) = null; + } else if (is_default) { + @field(out, field.name) = actual_type{ .value = actual_type.default }; + } else { + err = true; + } + } + } + if (err) return error.MalformedJson; + } else if (comptime (std.meta.trait.isSlice(T) and T != []const u8)) { + if (value != .Array) return error.MalformedJson; + const Child = std.meta.Child(T); + + if (value.Array.items.len == 0) { + out.* = &[0]Child{}; + } else { + var slice = try arena.allocator.alloc(Child, value.Array.items.len); + for (value.Array.items) |arr_item, idx| { + try fromDynamicTreeInternal(arena, arr_item, &slice[idx]); + } + out.* = slice; + } + } else if (T == std.json.Value) { + out.* = value; + } else { + switch (T) { + bool => { + if (value != .Bool) return error.MalformedJson; + out.* = value.Bool; + }, + i64 => { + if (value != .Integer) return error.MalformedJson; + out.* = value.Integer; + }, + f64 => { + if (value != .Float) return error.MalformedJson; + out.* = value.Float; + }, + []const u8 => { + if (value != .String) return error.MalformedJson; + out.* = value.String; + }, + else => @compileError("Invalid type " ++ @typeName(T)), + } + } +} + +pub fn fromDynamicTree(arena: *std.heap.ArenaAllocator, comptime T: type, value: std.json.Value) error{ MalformedJson, OutOfMemory }!T { + var out: T = undefined; + try fromDynamicTreeInternal(arena, value, &out); + return out; +} + +//! This file contains request types zls handles. +//! Note that the parameter types may be incomplete. +//! We only define what we actually use. + +const MaybeStringArray = Default([]const types.String, &[0]types.String{}); + +pub const Initialize = struct { + pub const ClientCapabilities = struct { + workspace: ?struct { + workspaceFolders: Default(bool, false), + }, + textDocument: ?struct { + semanticTokens: Exists, + hover: ?struct { + contentFormat: MaybeStringArray, + }, + completion: ?struct { + completionItem: ?struct { + snippetSupport: Default(bool, false), + documentationFormat: MaybeStringArray, + }, + }, + }, + }; + + params: struct { + capabilities: ClientCapabilities, + workspaceFolders: ?[]const types.WorkspaceFolder, + }, +}; + +pub const WorkspaceFoldersChange = struct { + params: struct { + event: struct { + added: []const types.WorkspaceFolder, + removed: []const types.WorkspaceFolder, + }, + }, +}; + +pub const OpenDocument = struct { + params: struct { + textDocument: struct { + uri: types.String, + text: types.String, + }, + }, +}; + +const TextDocumentIdentifier = struct { + uri: types.String, +}; + +pub const ChangeDocument = struct { + params: struct { + textDocument: TextDocumentIdentifier, + contentChanges: std.json.Value, + }, +}; + +const TextDocumentIdentifierRequest = struct { + params: struct { + textDocument: TextDocumentIdentifier, + }, +}; + +pub const SaveDocument = TextDocumentIdentifierRequest; +pub const CloseDocument = TextDocumentIdentifierRequest; +pub const SemanticTokens = TextDocumentIdentifierRequest; diff --git a/src/semantic_tokens.zig b/src/semantic_tokens.zig index d408a26..92a493d 100644 --- a/src/semantic_tokens.zig +++ b/src/semantic_tokens.zig @@ -722,11 +722,8 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D } // TODO Range version, edit version. -pub fn writeAllSemanticTokens(allocator: *std.mem.Allocator, store: *DocumentStore, handle: *DocumentStore.Handle) ![]u32 { - var arena = std.heap.ArenaAllocator.init(allocator); - defer arena.deinit(); - - var builder = Builder.init(allocator, handle); - try writeNodeTokens(&builder, &arena, store, &handle.tree.root_node.base); +pub fn writeAllSemanticTokens(arena: *std.heap.ArenaAllocator, store: *DocumentStore, handle: *DocumentStore.Handle) ![]u32 { + var builder = Builder.init(arena.child_allocator, handle); + try writeNodeTokens(&builder, arena, store, &handle.tree.root_node.base); return builder.toOwnedSlice(); } diff --git a/src/types.zig b/src/types.zig index c8d3bc1..8cbd937 100644 --- a/src/types.zig +++ b/src/types.zig @@ -358,9 +358,21 @@ const SymbolKind = enum { }; pub const DocumentSymbol = struct { - name: String, detail: ?String = null, kind: SymbolKind, deprecated: bool = false, range: Range, selectionRange: Range, children: []DocumentSymbol = &[_]DocumentSymbol{} + name: String, + detail: ?String = null, + kind: SymbolKind, + deprecated: bool = false, + range: Range, + selectionRange: Range, + children: []DocumentSymbol = &[_]DocumentSymbol{}, }; pub const ShowMessageParams = struct { - type: MessageType, message: String + type: MessageType, + message: String, +}; + +pub const WorkspaceFolder = struct { + uri: DocumentUri, + name: String, };