zls/src/signature_help.zig
Alexandros Naskos 7f432d8715
Implemented the signature help request.
Refreshes builtin data, added 0.7.1 builtins
2021-04-02 20:49:01 +03:00

327 lines
13 KiB
Zig

const std = @import("std");
const analysis = @import("analysis.zig");
const offsets = @import("offsets.zig");
const DocumentStore = @import("document_store.zig");
const types = @import("types.zig");
const ast = std.zig.ast;
const Token = std.zig.Token;
const identifierFromPosition = @import("main.zig").identifierFromPosition;
usingnamespace @import("ast.zig");
fn fnProtoToSignatureHelp(
arena: *std.heap.ArenaAllocator,
is_self_call: bool,
commas: u32,
tree: ast.Tree,
proto: ast.full.FnProto,
) !types.SignatureInformation {
const ParameterInformation = types.SignatureInformation.ParameterInformation;
const token_starts = tree.tokens.items(.start);
const alloc = &arena.allocator;
const arg_idx = commas + @boolToInt(is_self_call);
const label = analysis.getFunctionSignature(tree, proto);
const proto_comments = types.MarkupContent{ .value = if (try analysis.getDocComments(
alloc,
tree,
proto.ast.fn_token,
.Markdown,
)) |dc|
dc
else
"" };
var params = std.ArrayListUnmanaged(ParameterInformation){};
var param_it = proto.iterate(tree);
while (param_it.next()) |param| {
const param_comments = if (param.first_doc_comment) |dc|
types.MarkupContent{ .value = try analysis.collectDocComments(
alloc,
tree,
dc,
.Markdown,
) }
else
null;
var param_label_start: usize = 0;
var param_label_end: usize = 0;
if (param.comptime_noalias) |cn| {
param_label_start = token_starts[cn];
param_label_end = param_label_start + tree.tokenSlice(cn).len;
}
if (param.name_token) |nt| {
if (param_label_start == 0)
param_label_start = token_starts[nt];
param_label_end = token_starts[nt] + tree.tokenSlice(nt).len;
}
if (param.anytype_ellipsis3) |ae| {
if (param_label_start == 0)
param_label_start = token_starts[ae];
param_label_end = token_starts[ae] + tree.tokenSlice(ae).len;
}
if (param.type_expr != 0) {
if (param_label_start == 0)
param_label_start = token_starts[tree.firstToken(param.type_expr)];
const last_param_tok = lastToken(tree, param.type_expr);
param_label_end = token_starts[last_param_tok] + tree.tokenSlice(last_param_tok).len;
}
const param_label = tree.source[param_label_start..param_label_end];
try params.append(alloc, .{
.label = param_label,
.documentation = param_comments,
});
}
return types.SignatureInformation{
.label = label,
.documentation = proto_comments,
.parameters = params.items,
.activeParameter = arg_idx,
};
}
pub fn getSignatureInfo(
document_store: *DocumentStore,
arena: *std.heap.ArenaAllocator,
handle: *DocumentStore.Handle,
absolute_index: usize,
comptime data: type,
) !?types.SignatureInformation {
const innermost_block = analysis.innermostScope(handle.*, absolute_index);
const tree = handle.tree;
const token_tags = tree.tokens.items(.tag);
const token_starts = tree.tokens.items(.start);
const first_token = tree.firstToken(innermost_block);
const last_token = blk: {
if (token_starts[0] >= absolute_index)
return null;
var i: u32 = 1;
while (i < token_tags.len) : (i += 1) {
if (token_starts[i] >= absolute_index) {
break :blk i - 1;
}
}
break :blk @truncate(u32, token_tags.len - 1);
};
const StackSymbol = enum {
l_paren,
r_paren,
l_brace,
r_brace,
l_bracket,
r_bracket,
fn from(tag: Token.Tag) @This() {
return switch (tag) {
.l_paren => .l_paren,
.r_paren => .r_paren,
.l_brace => .l_brace,
.r_brace => .r_brace,
.l_bracket => .l_bracket,
.r_bracket => .r_bracket,
else => unreachable,
};
}
};
const alloc = &arena.allocator;
var symbol_stack = try std.ArrayListUnmanaged(StackSymbol).initCapacity(alloc, 8);
var curr_commas: u32 = 0;
var comma_stack = try std.ArrayListUnmanaged(u32).initCapacity(alloc, 4);
var curr_token = last_token;
while (curr_token >= first_token) : (curr_token -= 1) {
switch (token_tags[curr_token]) {
.comma => curr_commas += 1,
.l_brace => {
curr_commas = comma_stack.popOrNull() orelse 0;
if (symbol_stack.items.len != 0) {
const peek_sym = symbol_stack.items[symbol_stack.items.len - 1];
switch (peek_sym) {
.r_brace => {
_ = symbol_stack.pop();
continue;
},
.r_bracket, .r_paren => {
return null;
},
else => {},
}
}
try symbol_stack.append(alloc, .l_brace);
},
.l_bracket => {
curr_commas = comma_stack.popOrNull() orelse 0;
if (symbol_stack.items.len != 0) {
const peek_sym = symbol_stack.items[symbol_stack.items.len - 1];
switch (peek_sym) {
.r_bracket => {
_ = symbol_stack.pop();
continue;
},
.r_brace, .r_paren => {
return null;
},
else => {},
}
}
try symbol_stack.append(alloc, .l_bracket);
},
.l_paren => {
const paren_commas = curr_commas;
curr_commas = comma_stack.popOrNull() orelse 0;
if (symbol_stack.items.len != 0) {
const peek_sym = symbol_stack.items[symbol_stack.items.len - 1];
switch (peek_sym) {
.r_paren => {
_ = symbol_stack.pop();
continue;
},
.r_brace, .r_bracket => {
return null;
},
else => {},
}
}
// Try to find a function expression or a builtin identifier
// and send a response if found
if (curr_token == first_token)
return null;
const expr_last_token = curr_token - 1;
if (token_tags[expr_last_token] == .builtin) {
for (data.builtins) |builtin| {
if (std.mem.eql(u8, builtin.name, tree.tokenSlice(expr_last_token))) {
const param_infos = try alloc.alloc(
types.SignatureInformation.ParameterInformation,
builtin.arguments.len,
);
for (param_infos) |*info, i| {
info.* = .{
.label = builtin.arguments[i],
.documentation = null,
};
}
return types.SignatureInformation{
.label = builtin.signature,
.documentation = .{
.value = builtin.documentation,
},
.parameters = param_infos,
.activeParameter = paren_commas,
};
}
}
return null;
}
var state: union(enum) {
any,
in_bracket: u32,
in_paren: u32,
} = .any;
var i = expr_last_token;
const expr_first_token = while (i > first_token) : (i -= 1) {
switch (state) {
.in_bracket => |*count| if (token_tags[i] == .r_bracket) {
count.* += 1;
} else if (token_tags[i] == .l_bracket) {
count.* -= 1;
if (count.* == 0)
state = .any;
},
.in_paren => |*count| if (token_tags[i] == .r_paren) {
count.* += 1;
} else if (token_tags[i] == .l_paren) {
count.* -= 1;
if (count.* == 0)
state = .any;
},
.any => switch (token_tags[i]) {
.r_bracket => state = .{ .in_bracket = 1 },
.r_paren => state = .{ .in_paren = 1 },
.identifier,
.period,
.period_asterisk,
=> {},
else => break i + 1,
},
}
} else first_token + 1;
if (state != .any or expr_first_token > expr_last_token) {
try symbol_stack.append(alloc, .l_paren);
continue;
}
const expr_start = token_starts[expr_first_token];
const last_token_slice = tree.tokenSlice(expr_last_token);
const expr_end = token_starts[expr_last_token] + last_token_slice.len;
const expr_source = tree.source[expr_start..expr_end];
var tokenizer = std.zig.Tokenizer.init(expr_source);
if (try analysis.getFieldAccessType(
document_store,
arena,
handle,
expr_start,
&tokenizer,
)) |result| {
const type_handle = result.unwrapped orelse result.original;
var node = switch (type_handle.type.data) {
.other => |n| n,
else => return null,
};
// @@@ TODO Resolve alias
// TODO Better detection
var is_self_call = expr_last_token > expr_first_token and
token_tags[expr_last_token] == .identifier and
token_tags[expr_last_token - 1] == .period;
var buf: [1]ast.Node.Index = undefined;
if (fnProto(type_handle.handle.tree, node, &buf)) |proto| {
return try fnProtoToSignatureHelp(
arena,
is_self_call,
paren_commas,
type_handle.handle.tree,
proto,
);
}
const name = identifierFromPosition(expr_end - 1, handle.*);
if (name.len == 0) return null;
const decl_handle = (try analysis.lookupSymbolContainer(
document_store,
arena,
.{ .node = node, .handle = type_handle.handle },
name,
true,
)) orelse return null;
node = switch (decl_handle.decl.*) {
.ast_node => |n| n,
else => return null,
};
if (fnProto(type_handle.handle.tree, node, &buf)) |proto| {
return try fnProtoToSignatureHelp(
arena,
is_self_call,
paren_commas,
type_handle.handle.tree,
proto,
);
}
}
},
.r_brace, .r_paren, .r_bracket => |tag| {
try comma_stack.append(alloc, curr_commas);
curr_commas = 0;
try symbol_stack.append(alloc, StackSymbol.from(tag));
},
else => {},
}
}
return null;
}