zls/src/main.zig

1225 lines
48 KiB
Zig
Raw Normal View History

2020-04-24 23:19:03 +01:00
const std = @import("std");
2020-05-07 16:29:40 +01:00
const build_options = @import("build_options");
const Config = @import("config.zig");
const DocumentStore = @import("document_store.zig");
2020-05-17 12:40:32 +01:00
const DebugAllocator = @import("debug_allocator.zig");
2020-05-17 15:50:13 +01:00
const readRequestHeader = @import("header.zig").readRequestHeader;
2020-05-07 16:29:40 +01:00
const data = @import("data/" ++ build_options.data_version ++ ".zig");
const types = @import("types.zig");
const analysis = @import("analysis.zig");
const URI = @import("uri.zig");
2020-04-24 23:19:03 +01:00
// Code is largely based off of https://github.com/andersfr/zig-lsp/blob/master/server.zig
var stdout: std.io.BufferedOutStream(4096, std.fs.File.OutStream) = undefined;
2020-04-24 23:19:03 +01:00
var allocator: *std.mem.Allocator = undefined;
var document_store: DocumentStore = undefined;
var workspace_folder_configs: std.StringHashMap(?Config) = undefined;
const ClientCapabilities = struct {
supports_snippets: bool = false,
};
var client_capabilities = ClientCapabilities{};
const initialize_response =
\\,"result":{"capabilities":{"signatureHelpProvider":{"triggerCharacters":["(",","]},"textDocumentSync":1,"completionProvider":{"resolveProvider":false,"triggerCharacters":[".",":","@"]},"documentHighlightProvider":false,"hoverProvider":true,"codeActionProvider":false,"declarationProvider":true,"definitionProvider":true,"typeDefinitionProvider":true,"implementationProvider":false,"referencesProvider":false,"documentSymbolProvider":true,"colorProvider":false,"documentFormattingProvider":false,"documentRangeFormattingProvider":false,"foldingRangeProvider":false,"selectionRangeProvider":false,"workspaceSymbolProvider":false,"semanticTokensProvider":{"legend":{"tokenTypes":["type","struct","enum","parameter","variable","enumMember","function","member","keyword","modifier","comment","string","number","operator"],"tokenModifiers":["definition","async","documentation"]},"rangeProvider":false,"documentProvider":true},"workspace":{"workspaceFolders":{"supported":true,"changeNotifications":true}}}}}
2020-04-24 23:19:03 +01:00
;
const not_implemented_response =
\\,"error":{"code":-32601,"message":"NotImplemented"}}
2020-04-24 23:19:03 +01:00
;
const null_result_response =
\\,"result":null}
2020-04-24 23:19:03 +01:00
;
const empty_result_response =
\\,"result":{}}
2020-04-24 23:19:03 +01:00
;
const empty_array_response =
\\,"result":[]}
2020-04-24 23:19:03 +01:00
;
const edit_not_applied_response =
\\,"result":{"applied":false,"failureReason":"feature not implemented"}}
2020-04-24 23:19:03 +01:00
;
const no_completions_response =
\\,"result":{"isIncomplete":false,"items":[]}}
2020-04-24 23:19:03 +01:00
;
/// Sends a request or response
2020-05-08 03:27:42 +01:00
fn send(reqOrRes: var) !void {
var arena = std.heap.ArenaAllocator.init(allocator);
defer arena.deinit();
var arr = std.ArrayList(u8).init(&arena.allocator);
try std.json.stringify(reqOrRes, std.json.StringifyOptions{}, arr.outStream());
const stdout_stream = stdout.outStream();
try stdout_stream.print("Content-Length: {}\r\n\r\n", .{arr.items.len});
try stdout_stream.writeAll(arr.items);
try stdout.flush();
2020-04-24 23:19:03 +01:00
}
2020-06-06 13:40:33 +01:00
fn respondGeneric(id: types.RequestId, response: []const u8) !void {
const id_len = switch (id) {
.Integer => |id_val| blk: {
if (id_val == 0) break :blk 1;
var digits: usize = 1;
var value = @divTrunc(id_val, 10);
while (value != 0) : (value = @divTrunc(value, 10)) {
digits += 1;
}
break :blk digits;
},
.String => |str_val| str_val.len + 2,
else => unreachable,
2020-04-24 23:19:03 +01:00
};
2020-06-06 13:40:33 +01:00
// Numbers of character that will be printed from this string: len - 1 brackets
const json_fmt = "{{\"jsonrpc\":\"2.0\",\"id\":";
const stdout_stream = stdout.outStream();
2020-06-10 18:48:40 +01:00
try stdout_stream.print("Content-Length: {}\r\n\r\n" ++ json_fmt, .{response.len + id_len + json_fmt.len - 1});
2020-06-06 13:40:33 +01:00
switch (id) {
.Integer => |int| try stdout_stream.print("{}", .{int}),
.String => |str| try stdout_stream.print("\"{}\"", .{str}),
else => unreachable,
}
try stdout_stream.writeAll(response);
try stdout.flush();
}
2020-06-09 04:21:55 +01:00
fn showMessage(@"type": types.MessageType, message: []const u8) !void {
try send(types.Notification{
.method = "window/showMessage",
.params = .{
.ShowMessageParams = .{
.@"type" = @"type",
2020-06-10 18:48:40 +01:00
.message = message,
2020-06-09 04:21:55 +01:00
},
},
});
}
// TODO: Is this correct or can we get a better end?
fn astLocationToRange(loc: std.zig.ast.Tree.Location) types.Range {
return .{
.start = .{
.line = @intCast(i64, loc.line),
.character = @intCast(i64, loc.column),
},
.end = .{
.line = @intCast(i64, loc.line),
.character = @intCast(i64, loc.column),
},
};
}
fn publishDiagnostics(handle: DocumentStore.Handle, config: Config) !void {
2020-05-24 17:00:21 +01:00
const tree = handle.tree;
2020-04-24 23:19:03 +01:00
// 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);
2020-04-24 23:19:03 +01:00
2020-05-23 23:21:02 +01:00
for (tree.errors) |*err| {
const loc = tree.tokenLocation(0, err.loc());
var mem_buffer: [256]u8 = undefined;
var fbs = std.io.fixedBufferStream(&mem_buffer);
try tree.renderError(err, fbs.outStream());
try diagnostics.append(.{
.range = astLocationToRange(loc),
.severity = .Error,
.code = @tagName(err.*),
.source = "zls",
.message = try std.mem.dupe(&arena.allocator, u8, fbs.getWritten()),
// .relatedInformation = undefined
});
}
if (tree.errors.len == 0) {
2020-05-23 23:21:02 +01:00
for (tree.root_node.decls()) |decl| {
2020-05-04 03:17:19 +01:00
switch (decl.id) {
2020-05-08 18:02:46 +01:00
.FnProto => blk: {
2020-05-04 03:17:19 +01:00
const func = decl.cast(std.zig.ast.Node.FnProto).?;
const is_extern = func.extern_export_inline_token != null;
if (is_extern)
2020-05-08 18:02:46 +01:00
break :blk;
2020-05-15 20:10:53 +01:00
if (config.warn_style) {
if (func.name_token) |name_token| {
const loc = tree.tokenLocation(0, name_token);
2020-05-17 15:23:04 +01:00
const is_type_function = analysis.isTypeFunction(tree, func);
2020-05-15 20:10:53 +01:00
const func_name = tree.tokenSlice(name_token);
if (!is_type_function and !analysis.isCamelCase(func_name)) {
try diagnostics.append(.{
.range = astLocationToRange(loc),
.severity = .Information,
.code = "BadStyle",
.source = "zls",
.message = "Functions should be camelCase",
});
} else if (is_type_function and !analysis.isPascalCase(func_name)) {
try diagnostics.append(.{
.range = astLocationToRange(loc),
.severity = .Information,
.code = "BadStyle",
.source = "zls",
.message = "Type functions should be PascalCase",
});
}
2020-05-04 03:17:19 +01:00
}
}
},
else => {},
2020-05-04 03:17:19 +01:00
}
}
2020-04-24 23:19:03 +01:00
}
try send(types.Notification{
.method = "textDocument/publishDiagnostics",
.params = .{
.PublishDiagnosticsParams = .{
.uri = handle.uri(),
2020-05-07 11:56:08 +01:00
.diagnostics = diagnostics.items,
},
2020-05-07 14:23:13 +01:00
},
});
}
2020-04-24 23:19:03 +01:00
fn containerToCompletion(
2020-06-10 19:24:17 +01:00
arena: *std.heap.ArenaAllocator,
list: *std.ArrayList(types.CompletionItem),
2020-06-10 18:48:40 +01:00
container_handle: analysis.NodeWithHandle,
orig_handle: *DocumentStore.Handle,
config: Config,
) !void {
2020-06-10 18:48:40 +01:00
// @TODO Something like iterateSymbolsGlobal but for container to support uses.
const container = container_handle.node;
const handle = container_handle.handle;
2020-05-24 15:07:48 +01:00
var child_idx: usize = 0;
while (container.iterate(child_idx)) |child_node| : (child_idx += 1) {
// Declarations in the same file do not need to be public.
2020-06-10 18:48:40 +01:00
if (orig_handle == handle or analysis.isNodePublic(handle.tree, child_node)) {
2020-06-10 19:24:17 +01:00
try nodeToCompletion(arena, list, .{ .node = child_node, .handle = handle }, orig_handle, config);
2020-05-17 15:23:04 +01:00
}
}
}
2020-06-10 18:48:40 +01:00
fn resolveVarDeclFnAlias(arena: *std.heap.ArenaAllocator, decl_handle: analysis.NodeWithHandle) !analysis.NodeWithHandle {
const decl = decl_handle.node;
const handle = decl_handle.handle;
if (decl.cast(std.zig.ast.Node.VarDecl)) |var_decl| {
const child_node = block: {
if (var_decl.type_node) |type_node| {
2020-06-10 18:48:40 +01:00
if (std.mem.eql(u8, "type", handle.tree.tokenSlice(type_node.firstToken()))) {
break :block var_decl.init_node orelse type_node;
}
break :block type_node;
}
break :block var_decl.init_node.?;
};
2020-06-10 18:48:40 +01:00
if (try analysis.resolveTypeOfNode(&document_store, arena, .{ .node = child_node, .handle = handle })) |resolved_node| {
// TODO Just return it anyway?
// This would allow deep goto definition etc.
// Try it out.
if (resolved_node.node.id == .FnProto) {
return resolved_node;
}
}
}
2020-06-10 18:48:40 +01:00
return decl_handle;
}
fn nodeToCompletion(
2020-06-10 19:24:17 +01:00
arena: *std.heap.ArenaAllocator,
list: *std.ArrayList(types.CompletionItem),
2020-06-10 17:54:01 +01:00
node_handle: analysis.NodeWithHandle,
2020-06-10 18:48:40 +01:00
orig_handle: *DocumentStore.Handle,
config: Config,
) error{OutOfMemory}!void {
2020-06-10 18:48:40 +01:00
const node = node_handle.node;
const handle = node_handle.handle;
const doc = if (try analysis.getDocComments(list.allocator, handle.tree, node)) |doc_comments|
types.MarkupContent{
.kind = .Markdown,
.value = doc_comments,
}
else
null;
2020-05-17 15:23:04 +01:00
switch (node.id) {
.ErrorSetDecl, .Root, .ContainerDecl => {
2020-06-10 19:24:17 +01:00
try containerToCompletion(arena, list, node_handle, orig_handle, config);
2020-05-17 15:23:04 +01:00
},
.FnProto => {
2020-05-17 15:23:04 +01:00
const func = node.cast(std.zig.ast.Node.FnProto).?;
if (func.name_token) |name_token| {
const use_snippets = config.enable_snippets and client_capabilities.supports_snippets;
const insert_text = if (use_snippets) blk: {
const skip_self_param = if (func.params_len > 0) param_check: {
const in_container = analysis.innermostContainer(handle, handle.tree.token_locs[func.firstToken()].start);
switch (func.paramsConst()[0].param_type) {
.type_expr => |type_node| {
if (try analysis.resolveTypeOfNode(&document_store, arena, .{
.node = type_node,
.handle = handle,
})) |resolved_type| {
if (in_container.node == resolved_type.node)
break :param_check true;
}
if (type_node.cast(std.zig.ast.Node.PrefixOp)) |prefix_op| {
if (prefix_op.op == .PtrType) {
if (try analysis.resolveTypeOfNode(&document_store, arena, .{
.node = prefix_op.rhs,
.handle = handle,
})) |resolved_prefix_op| {
if (in_container.node == resolved_prefix_op.node)
break :param_check true;
}
}
}
break :param_check false;
},
else => break :param_check false,
}
} else
false;
2020-06-10 19:24:17 +01:00
break :blk try analysis.getFunctionSnippet(&arena.allocator, handle.tree, func, skip_self_param);
} else
null;
2020-06-10 19:24:17 +01:00
const is_type_function = analysis.isTypeFunction(handle.tree, func);
2020-05-17 15:23:04 +01:00
try list.append(.{
2020-06-10 19:24:17 +01:00
.label = handle.tree.tokenSlice(name_token),
2020-05-17 15:23:04 +01:00
.kind = if (is_type_function) .Struct else .Function,
.documentation = doc,
2020-06-10 19:24:17 +01:00
.detail = analysis.getFunctionSignature(handle.tree, func),
.insertText = insert_text,
.insertTextFormat = if (use_snippets) .Snippet else .PlainText,
2020-05-17 15:23:04 +01:00
});
}
},
.VarDecl => {
2020-05-17 15:23:04 +01:00
const var_decl = node.cast(std.zig.ast.Node.VarDecl).?;
2020-06-10 19:24:17 +01:00
const is_const = handle.tree.token_ids[var_decl.mut_token] == .Keyword_const;
2020-06-10 19:24:17 +01:00
const result = try resolveVarDeclFnAlias(arena, node_handle);
if (result.node != node) {
return try nodeToCompletion(arena, list, result, orig_handle, config);
}
2020-05-17 15:23:04 +01:00
try list.append(.{
2020-06-10 19:24:17 +01:00
.label = handle.tree.tokenSlice(var_decl.name_token),
2020-05-17 15:23:04 +01:00
.kind = if (is_const) .Constant else .Variable,
.documentation = doc,
2020-06-10 19:24:17 +01:00
.detail = analysis.getVariableSignature(handle.tree, var_decl),
2020-05-17 15:23:04 +01:00
});
},
2020-05-17 15:23:04 +01:00
.PrefixOp => {
2020-05-27 16:49:11 +01:00
const prefix_op = node.cast(std.zig.ast.Node.PrefixOp).?;
switch (prefix_op.op) {
.ArrayType, .SliceType => {},
.PtrType => {
if (prefix_op.rhs.cast(std.zig.ast.Node.PrefixOp)) |child_pop| {
switch (child_pop.op) {
.ArrayType => {},
else => return,
}
} else return;
},
else => return,
}
2020-05-17 15:23:04 +01:00
try list.append(.{
.label = "len",
.kind = .Field,
});
try list.append(.{
.label = "ptr",
.kind = .Field,
});
},
2020-05-17 15:23:04 +01:00
.StringLiteral => {
try list.append(.{
.label = "len",
.kind = .Field,
});
},
2020-06-10 18:48:40 +01:00
else => if (analysis.nodeToString(handle.tree, node)) |string| {
2020-05-17 15:23:04 +01:00
try list.append(.{
.label = string,
.kind = .Field,
.documentation = doc,
2020-06-10 18:48:40 +01:00
.detail = handle.tree.getNodeSource(node),
2020-05-17 15:23:04 +01:00
});
},
}
}
2020-05-18 21:19:23 +01:00
fn identifierFromPosition(pos_index: usize, handle: DocumentStore.Handle) []const u8 {
2020-05-22 23:03:41 +01:00
const text = handle.document.text;
if (pos_index + 1 >= text.len) return &[0]u8{};
2020-05-18 21:19:23 +01:00
var start_idx = pos_index;
2020-05-18 21:19:23 +01:00
while (start_idx > 0 and
2020-05-22 23:03:41 +01:00
(std.ascii.isAlNum(text[start_idx]) or text[start_idx] == '_')) : (start_idx -= 1)
2020-05-18 21:19:23 +01:00
{}
var end_idx = pos_index;
while (end_idx < handle.document.text.len and
2020-05-22 23:03:41 +01:00
(std.ascii.isAlNum(text[end_idx]) or text[end_idx] == '_')) : (end_idx += 1)
2020-05-18 21:19:23 +01:00
{}
if (end_idx <= start_idx) return &[0]u8{};
2020-05-22 23:58:47 +01:00
return text[start_idx + 1 .. end_idx];
2020-05-18 21:19:23 +01:00
}
2020-06-10 18:48:40 +01:00
fn gotoDefinitionSymbol(id: types.RequestId, arena: *std.heap.ArenaAllocator, decl_handle: analysis.DeclWithHandle) !void {
var handle = decl_handle.handle;
const location = switch (decl_handle.decl.*) {
.ast_node => |node| block: {
2020-06-10 18:48:40 +01:00
const result = try resolveVarDeclFnAlias(arena, .{ .node = node, .handle = handle });
handle = result.handle;
const name_token = analysis.getDeclNameToken(result.handle.tree, result.node) orelse
return try respondGeneric(id, null_result_response);
2020-06-10 18:48:40 +01:00
break :block result.handle.tree.tokenLocation(0, name_token);
},
else => decl_handle.location(),
};
try send(types.Response{
2020-06-06 13:40:33 +01:00
.id = id,
.result = .{
.Location = .{
.uri = handle.document.uri,
.range = astLocationToRange(location),
},
},
});
}
2020-06-10 18:48:40 +01:00
fn hoverSymbol(id: types.RequestId, arena: *std.heap.ArenaAllocator, decl_handle: analysis.DeclWithHandle) !void {
const handle = decl_handle.handle;
const md_string = switch (decl_handle.decl.*) {
.ast_node => |node| ast_node: {
const result = try resolveVarDeclFnAlias(arena, .{ .node = node, .handle = handle });
2020-06-03 09:23:14 +01:00
2020-06-10 18:48:40 +01:00
const doc_str = if (try analysis.getDocComments(&arena.allocator, result.handle.tree, result.node)) |str|
str
else
"";
2020-06-10 18:48:40 +01:00
const signature_str = switch (result.node.id) {
.VarDecl => blk: {
const var_decl = result.node.cast(std.zig.ast.Node.VarDecl).?;
break :blk analysis.getVariableSignature(result.handle.tree, var_decl);
},
.FnProto => blk: {
const fn_decl = result.node.cast(std.zig.ast.Node.FnProto).?;
break :blk analysis.getFunctionSignature(result.handle.tree, fn_decl);
},
else => analysis.nodeToString(result.handle.tree, result.node) orelse return try respondGeneric(id, null_result_response),
};
break :ast_node try std.fmt.allocPrint(&arena.allocator, "```zig\n{}\n```\n{}", .{ signature_str, doc_str });
},
.param_decl => |param| param_decl: {
const doc_str = if (param.doc_comments) |doc_comments|
try analysis.collectDocComments(&arena.allocator, handle.tree, doc_comments)
else
"";
break :param_decl try std.fmt.allocPrint(
&arena.allocator,
"```zig\n{}\n```\n{}",
.{
handle.tree.source[handle.tree.token_locs[param.firstToken()].start..handle.tree.token_locs[param.lastToken()].end],
doc_str,
2020-06-10 18:48:40 +01:00
},
);
},
.pointer_payload => |payload| try std.fmt.allocPrint(
&arena.allocator,
"```zig\n{}\n```",
.{handle.tree.tokenSlice(payload.node.value_symbol.firstToken())},
),
.array_payload => |payload| try std.fmt.allocPrint(
&arena.allocator,
"```zig\n{}\n```",
.{handle.tree.tokenSlice(payload.identifier.firstToken())},
),
.switch_payload => |payload| try std.fmt.allocPrint(
&arena.allocator,
"```zig\n{}\n```",
.{handle.tree.tokenSlice(payload.node.value_symbol.firstToken())},
),
};
try send(types.Response{
.id = id,
.result = .{
.Hover = .{
.contents = .{ .value = md_string },
},
},
});
}
fn getSymbolGlobal(arena: *std.heap.ArenaAllocator, pos_index: usize, handle: *DocumentStore.Handle) !?analysis.DeclWithHandle {
const name = identifierFromPosition(pos_index, handle.*);
if (name.len == 0) return null;
return try analysis.lookupSymbolGlobal(&document_store, handle, name, pos_index);
}
2020-06-06 13:40:33 +01:00
fn gotoDefinitionGlobal(id: types.RequestId, pos_index: usize, handle: *DocumentStore.Handle, config: Config) !void {
2020-05-18 21:19:23 +01:00
var arena = std.heap.ArenaAllocator.init(allocator);
defer arena.deinit();
const decl = (try getSymbolGlobal(&arena, pos_index, handle)) orelse return try respondGeneric(id, null_result_response);
2020-06-10 18:48:40 +01:00
return try gotoDefinitionSymbol(id, &arena, decl);
}
2020-05-18 21:19:23 +01:00
2020-06-06 13:40:33 +01:00
fn hoverDefinitionGlobal(id: types.RequestId, pos_index: usize, handle: *DocumentStore.Handle, config: Config) !void {
var arena = std.heap.ArenaAllocator.init(allocator);
defer arena.deinit();
2020-06-10 18:48:40 +01:00
const decl = (try getSymbolGlobal(&arena, pos_index, handle)) orelse return try respondGeneric(id, null_result_response);
return try hoverSymbol(id, &arena, decl);
2020-05-18 21:19:23 +01:00
}
fn getSymbolFieldAccess(
2020-06-10 18:48:40 +01:00
handle: *DocumentStore.Handle,
arena: *std.heap.ArenaAllocator,
position: types.Position,
range: analysis.SourceRange,
config: Config,
2020-06-10 18:48:40 +01:00
) !?analysis.DeclWithHandle {
const pos_index = try handle.document.positionToIndex(position);
const name = identifierFromPosition(pos_index, handle.*);
if (name.len == 0) return null;
2020-06-10 18:48:40 +01:00
const line = try handle.document.getLine(@intCast(usize, position.line));
var tokenizer = std.zig.Tokenizer.init(line[range.start..range.end]);
2020-06-10 18:48:40 +01:00
if (try analysis.getFieldAccessTypeNode(&document_store, arena, handle, &tokenizer)) |container_handle| {
return try analysis.lookupSymbolContainer(&document_store, container_handle, name, true);
}
return null;
}
fn gotoDefinitionFieldAccess(
2020-06-06 13:40:33 +01:00
id: types.RequestId,
handle: *DocumentStore.Handle,
position: types.Position,
range: analysis.SourceRange,
config: Config,
) !void {
2020-05-18 21:19:23 +01:00
var arena = std.heap.ArenaAllocator.init(allocator);
defer arena.deinit();
2020-06-10 18:48:40 +01:00
const decl = (try getSymbolFieldAccess(handle, &arena, position, range, config)) orelse return try respondGeneric(id, null_result_response);
return try gotoDefinitionSymbol(id, &arena, decl);
}
2020-05-18 21:19:23 +01:00
fn hoverDefinitionFieldAccess(
2020-06-06 13:40:33 +01:00
id: types.RequestId,
handle: *DocumentStore.Handle,
position: types.Position,
range: analysis.SourceRange,
config: Config,
) !void {
var arena = std.heap.ArenaAllocator.init(allocator);
defer arena.deinit();
2020-06-10 18:48:40 +01:00
const decl = (try getSymbolFieldAccess(handle, &arena, position, range, config)) orelse return try respondGeneric(id, null_result_response);
return try hoverSymbol(id, &arena, decl);
2020-05-18 21:19:23 +01:00
}
2020-06-06 13:40:33 +01:00
fn gotoDefinitionString(id: types.RequestId, pos_index: usize, handle: *DocumentStore.Handle, config: Config) !void {
2020-05-24 17:00:21 +01:00
const tree = handle.tree;
var arena = std.heap.ArenaAllocator.init(allocator);
defer arena.deinit();
const import_str = analysis.getImportStr(tree, pos_index) orelse return try respondGeneric(id, null_result_response);
const uri = (try document_store.uriFromImportStr(
&arena.allocator,
handle.*,
import_str,
)) orelse return try respondGeneric(id, null_result_response);
try send(types.Response{
2020-06-06 13:40:33 +01:00
.id = id,
.result = .{
.Location = .{
.uri = uri,
.range = .{
.start = .{ .line = 0, .character = 0 },
.end = .{ .line = 0, .character = 0 },
},
},
},
});
}
const DeclToCompletionContext = struct {
completions: *std.ArrayList(types.CompletionItem),
config: *const Config,
arena: *std.heap.ArenaAllocator,
2020-06-10 18:48:40 +01:00
orig_handle: *DocumentStore.Handle,
};
fn decltoCompletion(context: DeclToCompletionContext, decl_handle: analysis.DeclWithHandle) !void {
const tree = decl_handle.handle.tree;
switch (decl_handle.decl.*) {
.ast_node => |node| try nodeToCompletion(context.arena, context.completions, .{ .node = node, .handle = decl_handle.handle }, context.orig_handle, context.config.*),
.param_decl => |param| {
const doc = if (param.doc_comments) |doc_comments|
types.MarkupContent{
.kind = .Markdown,
.value = try analysis.collectDocComments(&context.arena.allocator, tree, doc_comments),
}
else
null;
try context.completions.append(.{
.label = tree.tokenSlice(param.name_token.?),
.kind = .Constant,
.documentation = doc,
.detail = tree.source[tree.token_locs[param.firstToken()].start..tree.token_locs[param.lastToken()].end],
});
},
.pointer_payload => |payload| {
try context.completions.append(.{
.label = tree.tokenSlice(payload.node.value_symbol.firstToken()),
.kind = .Variable,
});
},
.array_payload => |payload| {
try context.completions.append(.{
.label = tree.tokenSlice(payload.identifier.firstToken()),
.kind = .Variable,
});
},
.switch_payload => |payload| {
try context.completions.append(.{
.label = tree.tokenSlice(payload.node.value_symbol.firstToken()),
.kind = .Variable,
});
},
}
}
2020-06-06 13:40:33 +01:00
fn completeGlobal(id: types.RequestId, pos_index: usize, handle: *DocumentStore.Handle, config: Config) !void {
// We use a local arena allocator to deallocate all temporary data without iterating
var arena = std.heap.ArenaAllocator.init(allocator);
var completions = std.ArrayList(types.CompletionItem).init(&arena.allocator);
// Deallocate all temporary data.
defer arena.deinit();
2020-05-07 11:56:08 +01:00
const context = DeclToCompletionContext{
.completions = &completions,
.config = &config,
.arena = &arena,
2020-06-10 18:48:40 +01:00
.orig_handle = handle,
};
try analysis.iterateSymbolsGlobal(&document_store, handle, pos_index, decltoCompletion, context);
2020-06-09 04:21:55 +01:00
try send(types.Response{
2020-06-06 13:40:33 +01:00
.id = id,
.result = .{
.CompletionList = .{
.isIncomplete = false,
2020-05-07 11:56:08 +01:00
.items = completions.items,
},
},
});
2020-04-24 23:19:03 +01:00
}
2020-06-06 13:40:33 +01:00
fn completeFieldAccess(id: types.RequestId, handle: *DocumentStore.Handle, position: types.Position, range: analysis.SourceRange, config: Config) !void {
var arena = std.heap.ArenaAllocator.init(allocator);
defer arena.deinit();
2020-05-11 13:28:08 +01:00
var completions = std.ArrayList(types.CompletionItem).init(&arena.allocator);
2020-05-17 15:39:04 +01:00
const line = try handle.document.getLine(@intCast(usize, position.line));
var tokenizer = std.zig.Tokenizer.init(line[range.start..range.end]);
2020-06-10 18:48:40 +01:00
if (try analysis.getFieldAccessTypeNode(&document_store, &arena, handle, &tokenizer)) |node| {
2020-06-10 19:24:17 +01:00
try nodeToCompletion(&arena, &completions, node, handle, config);
}
2020-06-10 18:48:40 +01:00
try send(types.Response{
2020-06-06 13:40:33 +01:00
.id = id,
.result = .{
.CompletionList = .{
.isIncomplete = false,
.items = completions.items,
},
},
});
2020-05-11 13:28:08 +01:00
}
2020-06-06 13:40:33 +01:00
fn documentSymbol(id: types.RequestId, handle: *DocumentStore.Handle) !void {
var arena = std.heap.ArenaAllocator.init(allocator);
defer arena.deinit();
try send(types.Response{
2020-06-06 13:40:33 +01:00
.id = id,
.result = .{ .DocumentSymbols = try analysis.getDocumentSymbols(&arena.allocator, handle.tree) },
});
}
// Compute builtin completions at comptime.
const builtin_completions = block: {
@setEvalBranchQuota(3_500);
const CompletionList = [data.builtins.len]types.CompletionItem;
var with_snippets: CompletionList = undefined;
var without_snippets: CompletionList = undefined;
for (data.builtins) |builtin, i| {
const cutoff = std.mem.indexOf(u8, builtin, "(") orelse builtin.len;
const base_completion = types.CompletionItem{
.label = builtin[0..cutoff],
.kind = .Function,
.filterText = builtin[1..cutoff],
.detail = data.builtin_details[i],
.documentation = .{
.kind = .Markdown,
.value = data.builtin_docs[i],
},
};
with_snippets[i] = base_completion;
with_snippets[i].insertText = builtin[1..];
with_snippets[i].insertTextFormat = .Snippet;
without_snippets[i] = base_completion;
without_snippets[i].insertText = builtin[1..cutoff];
}
break :block [2]CompletionList{
without_snippets, with_snippets,
};
};
fn loadConfig(folder_path: []const u8) ?Config {
var folder = std.fs.cwd().openDir(folder_path, .{}) catch return null;
defer folder.close();
const conf_file = folder.openFile("zls.json", .{}) catch return null;
defer conf_file.close();
// Max 1MB
const file_buf = conf_file.inStream().readAllAlloc(allocator, 0x1000000) catch return null;
defer allocator.free(file_buf);
// TODO: Better errors? Doesn't seem like std.json can provide us positions or context.
var config = std.json.parse(Config, &std.json.TokenStream.init(file_buf), std.json.ParseOptions{ .allocator = allocator }) catch |err| {
std.debug.warn("Error while parsing configuration file: {}\nUsing default config.\n", .{err});
return null;
};
if (config.zig_lib_path) |zig_lib_path| {
if (!std.fs.path.isAbsolute(zig_lib_path)) {
std.debug.warn("zig library path is not absolute, defaulting to null.\n", .{});
allocator.free(zig_lib_path);
config.zig_lib_path = null;
}
}
return config;
}
fn loadWorkspaceConfigs() !void {
var folder_config_it = workspace_folder_configs.iterator();
while (folder_config_it.next()) |entry| {
if (entry.value) |_| continue;
const folder_path = try URI.parse(allocator, entry.key);
defer allocator.free(folder_path);
entry.value = loadConfig(folder_path);
}
}
fn configFromUriOr(uri: []const u8, default: Config) Config {
var folder_config_it = workspace_folder_configs.iterator();
while (folder_config_it.next()) |entry| {
if (std.mem.startsWith(u8, uri, entry.key)) {
return entry.value orelse default;
}
}
return default;
}
fn processJsonRpc(parser: *std.json.Parser, json: []const u8, config: Config) !void {
2020-04-24 23:19:03 +01:00
var tree = try parser.parse(json);
defer tree.deinit();
const root = tree.root;
2020-06-06 13:40:33 +01:00
const id = if (root.Object.getValue("id")) |id| switch (id) {
.Integer => |int| types.RequestId{ .Integer = int },
.String => |str| types.RequestId{ .String = str },
else => types.RequestId{ .Integer = 0 },
} else types.RequestId{ .Integer = 0 };
if (id == .Integer and id.Integer == 1337 and (root.Object.getValue("method") == null or std.mem.eql(u8, root.Object.getValue("method").?.String, ""))) {
2020-05-19 21:24:24 +01:00
if (root.Object.getValue("result")) |result_obj| {
if (result_obj == .Array) {
const result = result_obj.Array;
2020-05-19 21:24:24 +01:00
for (result.items) |workspace_folder| {
const duped_uri = try std.mem.dupe(allocator, u8, workspace_folder.Object.getValue("uri").?.String);
try workspace_folder_configs.putNoClobber(duped_uri, null);
}
}
}
try loadWorkspaceConfigs();
return;
}
std.debug.assert(root.Object.getValue("method") != null);
const method = root.Object.getValue("method").?.String;
2020-04-24 23:19:03 +01:00
const params = root.Object.getValue("params").?.Object;
2020-05-24 13:39:40 +01:00
const start_time = std.time.milliTimestamp();
defer {
const end_time = std.time.milliTimestamp();
2020-05-25 17:33:08 +01:00
std.debug.warn("Took {}ms to process method {}\n", .{ end_time - start_time, method });
2020-05-24 13:39:40 +01:00
}
2020-04-24 23:19:03 +01:00
// Core
if (std.mem.eql(u8, method, "initialize")) {
const client_capabs = params.getValue("capabilities").?.Object;
if (client_capabs.getValue("textDocument")) |text_doc_capabs| {
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;
}
}
}
2020-04-24 23:19:03 +01:00
try respondGeneric(id, initialize_response);
} else if (std.mem.eql(u8, method, "initialized")) {
// Send the workspaceFolders request
try send(types.Request{
.id = .{ .Integer = 1337 },
.method = "workspace/workspaceFolders",
.params = {},
});
2020-04-24 23:19:03 +01:00
} else if (std.mem.eql(u8, method, "$/cancelRequest")) {
// noop
}
// Workspace folder changes
else if (std.mem.eql(u8, method, "workspace/didChangeWorkspaceFolders")) {
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();
}
2020-04-24 23:19:03 +01:00
// File changes
else if (std.mem.eql(u8, method, "textDocument/didOpen")) {
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));
2020-04-24 23:19:03 +01:00
} else if (std.mem.eql(u8, method, "textDocument/didChange")) {
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 {
2020-05-18 16:36:47 +01:00
std.debug.warn("Trying to change non existent document {}", .{uri});
return;
};
2020-04-24 23:19:03 +01:00
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 text_document = params.getValue("textDocument").?.Object;
const uri = text_document.getValue("uri").?.String;
const handle = document_store.getHandle(uri) orelse {
std.debug.warn("Trying to save non existent document {}", .{uri});
return;
};
try document_store.applySave(handle);
} else if (std.mem.eql(u8, method, "textDocument/willSave")) {
2020-04-24 23:19:03 +01:00
// noop
} else if (std.mem.eql(u8, method, "textDocument/didClose")) {
const document = params.getValue("textDocument").?.Object;
const uri = document.getValue("uri").?.String;
document_store.closeDocument(uri);
2020-04-24 23:19:03 +01:00
}
// Semantic highlighting
else if (std.mem.eql(u8, method, "textDocument/semanticTokens")) {
2020-06-10 19:24:17 +01:00
// TODO Implement this (we dont get here from vscode atm even when we get the client capab.)
return try respondGeneric(id, empty_array_response);
}
2020-04-24 23:19:03 +01:00
// Autocomplete / Signatures
else if (std.mem.eql(u8, method, "textDocument/completion")) {
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 {
2020-05-18 16:36:47 +01:00
std.debug.warn("Trying to complete in non existent document {}", .{uri});
2020-05-18 21:19:23 +01:00
return try respondGeneric(id, no_completions_response);
};
const pos = types.Position{
.line = position.getValue("line").?.Integer,
.character = position.getValue("character").?.Integer - 1,
};
if (pos.character >= 0) {
const pos_index = try handle.document.positionToIndex(pos);
const pos_context = try analysis.documentPositionContext(allocator, handle.document, pos);
2020-05-08 04:05:17 +01:00
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{
2020-06-06 13:40:33 +01:00
.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{
2020-06-06 13:40:33 +01:00
.id = id,
2020-05-16 17:04:07 +01:00
.result = .{
.CompletionList = .{
.isIncomplete = false,
.items = document_store.error_completions.completions.items,
},
},
}),
.enum_literal => try send(types.Response{
2020-06-06 13:40:33 +01:00
.id = id,
2020-05-28 16:18:48 +01:00
.result = .{
.CompletionList = .{
.isIncomplete = false,
.items = document_store.enum_completions.completions.items,
},
},
}),
else => try respondGeneric(id, no_completions_response),
}
} else {
try respondGeneric(id, no_completions_response);
}
2020-04-24 23:19:03 +01:00
} else if (std.mem.eql(u8, method, "textDocument/signatureHelp")) {
// TODO: Implement this
try respondGeneric(id,
\\,"result":{"signatures":[]}}
2020-05-14 00:36:51 +01:00
);
2020-05-18 21:19:23 +01:00
} 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"))
2020-05-18 21:19:23 +01:00
{
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.debug.warn("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 - 1,
};
if (pos.character >= 0) {
const pos_index = try handle.document.positionToIndex(pos);
const pos_context = try analysis.documentPositionContext(allocator, handle.document, pos);
2020-05-18 21:19:23 +01:00
switch (pos_context) {
.var_access => try gotoDefinitionGlobal(
id,
pos_index,
handle,
configFromUriOr(uri, config),
),
.field_access => |range| try gotoDefinitionFieldAccess(
id,
handle,
pos,
range,
configFromUriOr(uri, config),
),
.string_literal => try gotoDefinitionString(id, pos_index, handle, config),
2020-05-18 21:19:23 +01:00
else => try respondGeneric(id, null_result_response),
}
} else {
try respondGeneric(id, null_result_response);
2020-05-18 21:19:23 +01:00
}
} else if (std.mem.eql(u8, method, "textDocument/hover")) {
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.debug.warn("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 - 1,
};
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),
),
else => try respondGeneric(id, null_result_response),
}
} else {
try respondGeneric(id, null_result_response);
}
} else if (std.mem.eql(u8, method, "textDocument/documentSymbol")) {
const document = params.getValue("textDocument").?.Object;
const uri = document.getValue("uri").?.String;
const handle = document_store.getHandle(uri) orelse {
std.debug.warn("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/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/formatting") or
std.mem.eql(u8, method, "textDocument/rangeFormatting") or
std.mem.eql(u8, method, "textDocument/onTypeFormatting") or
std.mem.eql(u8, method, "textDocument/rename") 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);
2020-04-24 23:19:03 +01:00
} else if (root.Object.getValue("id")) |_| {
2020-05-18 16:36:47 +01:00
std.debug.warn("Method with return value not implemented: {}", .{method});
2020-04-24 23:19:03 +01:00
try respondGeneric(id, not_implemented_response);
} else {
2020-05-18 16:36:47 +01:00
std.debug.warn("Method without return value not implemented: {}", .{method});
2020-04-24 23:19:03 +01:00
}
}
2020-05-17 12:40:32 +01:00
var debug_alloc_state: DebugAllocator = undefined;
2020-05-07 10:58:35 +01:00
// We can now use if(leak_count_alloc) |alloc| { ... } as a comptime check.
2020-05-17 12:40:32 +01:00
const debug_alloc: ?*DebugAllocator = if (build_options.allocation_info) &debug_alloc_state else null;
2020-04-24 23:19:03 +01:00
pub fn main() anyerror!void {
// TODO: Use a better purpose general allocator once std has one.
// Probably after the generic composable allocators PR?
2020-05-14 15:22:15 +01:00
// This is not too bad for now since most allocations happen in local arenas.
allocator = std.heap.page_allocator;
2020-04-24 23:19:03 +01:00
if (build_options.allocation_info) {
// TODO: Use a better debugging allocator, track size in bytes, memory reserved etc..
// Initialize the leak counting allocator.
debug_alloc_state = DebugAllocator.init(allocator, build_options.max_bytes_allocated);
allocator = &debug_alloc_state.allocator;
}
// Init global vars
const in_stream = std.io.getStdIn().inStream();
stdout = std.io.bufferedOutStream(std.io.getStdOut().outStream());
2020-04-24 23:19:03 +01:00
2020-05-17 15:39:04 +01:00
// Read the configuration, if any.
const config_parse_options = std.json.ParseOptions{ .allocator = allocator };
2020-05-17 15:39:04 +01:00
var config = Config{};
defer std.json.parseFree(Config, config, config_parse_options);
config_read: {
const known_folders = @import("known-folders");
const res = try known_folders.getPath(allocator, .local_configuration);
if (res) |local_config_path| {
defer allocator.free(local_config_path);
if (loadConfig(local_config_path)) |conf| {
config = conf;
break :config_read;
}
}
2020-05-25 17:33:08 +01:00
var exe_dir_bytes: [std.fs.MAX_PATH_BYTES]u8 = undefined;
const exe_dir_path = std.fs.selfExeDirPath(&exe_dir_bytes) catch break :config_read;
2020-05-25 17:33:08 +01:00
if (loadConfig(exe_dir_path)) |conf| {
config = conf;
2020-05-17 15:39:04 +01:00
}
}
// Find the zig executable in PATH
var zig_exe_path: ?[]const u8 = null;
defer if (zig_exe_path) |exe_path| allocator.free(exe_path);
find_zig: {
if (config.zig_exe_path) |exe_path| {
if (std.fs.path.isAbsolute(exe_path)) {
zig_exe_path = try std.mem.dupe(allocator, u8, exe_path);
break :find_zig;
}
std.debug.warn("zig path `{}` is not absolute, will look in path\n", .{exe_path});
}
const env_path = std.process.getEnvVarOwned(allocator, "PATH") catch |err| switch (err) {
error.EnvironmentVariableNotFound => {
std.debug.warn("Could not get PATH.\n", .{});
break :find_zig;
},
else => return err,
};
defer allocator.free(env_path);
const exe_extension = @as(std.zig.CrossTarget, .{}).exeFileExt();
const zig_exe = try std.fmt.allocPrint(allocator, "zig{}", .{exe_extension});
defer allocator.free(zig_exe);
2020-05-25 17:33:08 +01:00
var it = std.mem.tokenize(env_path, &[_]u8{std.fs.path.delimiter});
while (it.next()) |path| {
const full_path = try std.fs.path.join(allocator, &[_][]const u8{
path,
zig_exe,
});
2020-05-25 15:24:44 +01:00
defer allocator.free(full_path);
var buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
zig_exe_path = std.os.realpath(full_path, &buf) catch continue;
std.debug.warn("Found zig in PATH: {}\n", .{zig_exe_path});
break :find_zig;
}
}
if (zig_exe_path) |exe_path| {
std.debug.warn("Using zig executable {}\n", .{exe_path});
if (config.zig_lib_path == null) {
// Set the lib path relative to the executable path.
config.zig_lib_path = try std.fs.path.resolve(allocator, &[_][]const u8{
std.fs.path.dirname(exe_path).?, "./lib/zig",
});
std.debug.warn("Resolved standard library from executable: {}\n", .{config.zig_lib_path});
}
}
if (config.build_runner_path) |build_runner_path| {
2020-06-10 17:54:01 +01:00
try document_store.init(allocator, zig_exe_path, try std.mem.dupe(allocator, u8, build_runner_path), config.zig_lib_path);
} else {
2020-05-25 17:33:08 +01:00
var exe_dir_bytes: [std.fs.MAX_PATH_BYTES]u8 = undefined;
const exe_dir_path = try std.fs.selfExeDirPath(&exe_dir_bytes);
const build_runner_path = try std.fs.path.resolve(allocator, &[_][]const u8{ exe_dir_path, "build_runner.zig" });
2020-06-10 17:54:01 +01:00
try document_store.init(allocator, zig_exe_path, build_runner_path, config.zig_lib_path);
2020-05-25 17:33:08 +01:00
}
defer document_store.deinit();
workspace_folder_configs = std.StringHashMap(?Config).init(allocator);
defer workspace_folder_configs.deinit();
// This JSON parser is passed to processJsonRpc and reset.
var json_parser = std.json.Parser.init(allocator, false);
defer json_parser.deinit();
2020-05-17 15:50:13 +01:00
while (true) {
2020-05-17 16:26:00 +01:00
const headers = readRequestHeader(allocator, in_stream) catch |err| {
2020-05-18 16:36:47 +01:00
std.debug.warn("{}; exiting!", .{@errorName(err)});
2020-04-24 23:19:03 +01:00
return;
2020-05-17 15:50:13 +01:00
};
defer headers.deinit(allocator);
const buf = try allocator.alloc(u8, headers.content_length);
defer allocator.free(buf);
2020-05-17 16:26:00 +01:00
try in_stream.readNoEof(buf);
2020-05-17 15:50:13 +01:00
try processJsonRpc(&json_parser, buf, config);
json_parser.reset();
2020-04-24 23:19:03 +01:00
if (debug_alloc) |dbg| {
2020-05-18 17:37:56 +01:00
std.debug.warn("{}\n", .{dbg.info});
}
2020-04-24 23:19:03 +01:00
}
}