zls/src/analysis.zig

2807 lines
106 KiB
Zig
Raw Normal View History

2020-05-03 22:27:08 +01:00
const std = @import("std");
2020-06-10 17:54:01 +01:00
const DocumentStore = @import("document_store.zig");
const ast = std.zig.ast;
const types = @import("types.zig");
2020-07-07 09:57:02 +01:00
const offsets = @import("offsets.zig");
2020-08-14 11:41:34 +01:00
const log = std.log.scoped(.analysis);
2021-02-27 15:38:06 +00:00
/// Get a declaration's doc comment token index
pub fn getDocCommentTokenIndex(tree: ast.Tree, node: ast.Node.Index) ?ast.TokenIndex {
const tags = tree.nodes.items(.tag);
const tokens = tree.tokens.items(.tag);
const current = tree.nodes.items(.main_token)[node];
2021-03-02 14:32:38 +00:00
var idx = current;
2021-03-02 21:01:13 +00:00
if (idx == 0) return null;
2021-02-27 15:38:06 +00:00
switch (tags[node]) {
2021-03-02 14:32:38 +00:00
.fn_proto, .fn_proto_one, .fn_proto_simple, .fn_proto_multi, .fn_decl => {
idx -= 1;
2021-03-02 21:01:13 +00:00
if (tokens[idx] == .keyword_extern and idx > 0)
idx -= 1;
if (tokens[idx] == .keyword_pub and idx < 0)
idx -= 1;
2021-02-27 15:38:06 +00:00
},
.local_var_decl, .global_var_decl, .aligned_var_decl, .simple_var_decl => {
2021-03-02 14:32:38 +00:00
idx -= 1;
2021-03-02 21:01:13 +00:00
if (tokens[idx] == .keyword_pub and idx > 0)
idx -= 1;
2021-02-27 15:38:06 +00:00
},
.container_field, .container_field_init, .container_field_align => {
2021-03-02 21:01:13 +00:00
idx -= 2; // skip '.' token
2021-02-27 15:38:06 +00:00
},
2021-03-02 14:32:38 +00:00
else => {
2021-03-03 15:34:24 +00:00
// if (isContainer(tags[node])) {
// idx -= 1; // go to '='
// idx -= 1; // mutability
// idx -= 1; // possible 'pub'
// if (tokens[idx] == .keyword_pub and idx > 0)
// idx -= 1;
// }
2021-03-02 14:32:38 +00:00
},
}
// Find first doc comment token
if (tokens[idx] == .doc_comment or tokens[idx] == .container_doc_comment) {
2021-03-02 21:01:13 +00:00
while ((tokens[idx] == .doc_comment or tokens[idx] == .container_doc_comment) and idx > 0) : (idx -= 1) {}
2021-03-02 14:32:38 +00:00
return idx + 1;
2020-06-03 09:23:14 +01:00
}
2021-02-27 15:38:06 +00:00
// @TODO: Implement doc comments for tags
// } else if (node.castTag(.ErrorTag)) |tag| {
// return tag.doc_comments;
// }
2020-06-03 09:23:14 +01:00
return null;
}
/// Gets a declaration's doc comments, caller must free memory when a value is returned
2020-05-03 22:27:08 +01:00
/// Like:
///```zig
///var comments = getFunctionDocComments(allocator, tree, func);
///defer if (comments) |comments_pointer| allocator.free(comments_pointer);
///```
pub fn getDocComments(
allocator: *std.mem.Allocator,
tree: ast.Tree,
2021-02-27 15:38:06 +00:00
node: ast.Node.Index,
format: types.MarkupContent.Kind,
) !?[]const u8 {
2021-02-27 15:38:06 +00:00
if (getDocCommentTokenIndex(tree, node)) |doc_comment_index| {
return try collectDocComments(allocator, tree, doc_comment_index, format);
2020-05-03 22:27:08 +01:00
}
return null;
}
pub fn collectDocComments(
allocator: *std.mem.Allocator,
tree: ast.Tree,
2021-02-27 15:38:06 +00:00
doc_comments: ast.TokenIndex,
format: types.MarkupContent.Kind,
) ![]const u8 {
var lines = std.ArrayList([]const u8).init(allocator);
defer lines.deinit();
2021-02-27 15:38:06 +00:00
const token_tags = tree.tokens.items(.tag);
var curr_line_tok = doc_comments;
2020-05-23 23:21:02 +01:00
while (true) : (curr_line_tok += 1) {
2021-02-27 15:38:06 +00:00
switch (token_tags[curr_line_tok]) {
.doc_comment, .container_doc_comment => {
try lines.append(std.mem.trim(u8, tree.tokenSlice(curr_line_tok)[3..], &std.ascii.spaces));
2020-05-23 23:21:02 +01:00
},
else => break,
}
}
return try std.mem.join(allocator, if (format == .Markdown) " \n" else "\n", lines.items);
2020-05-03 22:27:08 +01:00
}
2020-05-03 22:27:37 +01:00
/// Gets a function signature (keywords, name, return value)
2021-03-01 15:02:24 +00:00
pub fn getFunctionSignature(tree: ast.Tree, func: ast.full.FnProto) []const u8 {
2021-03-01 15:30:43 +00:00
const start = tree.tokenLocation(0, func.ast.fn_token).line_start;
2021-03-02 14:32:38 +00:00
const end = tree.tokenLocation(0, tree.nodes.items(.main_token)[func.ast.return_type]).line_end;
return tree.source[start .. end - 1];
2020-05-03 22:27:08 +01:00
}
2020-05-04 03:17:19 +01:00
/// Gets a function snippet insert text
2021-03-01 15:02:24 +00:00
pub fn getFunctionSnippet(allocator: *std.mem.Allocator, tree: ast.Tree, func: ast.full.FnProto, skip_self_param: bool) ![]const u8 {
2021-02-27 15:38:06 +00:00
const name_index = func.name_token orelse unreachable;
var buffer = std.ArrayList(u8).init(allocator);
try buffer.ensureCapacity(128);
2021-03-01 15:30:43 +00:00
try buffer.appendSlice(tree.tokenSlice(name_index));
try buffer.append('(');
2021-01-10 07:12:11 +00:00
var buf_stream = buffer.writer();
2021-02-27 15:38:06 +00:00
const token_tags = tree.tokens.items(.tag);
2021-02-27 15:38:06 +00:00
var it = func.iterate(tree);
while (it.next()) |param| {
if (skip_self_param and it.param_i == 0) continue;
if (it.param_i != @boolToInt(skip_self_param)) try buffer.appendSlice(", ${") else try buffer.appendSlice("${");
2021-02-27 15:38:06 +00:00
try buf_stream.print("{d}", .{it.param_i + 1});
2021-02-27 15:38:06 +00:00
if (param.comptime_noalias) |token_index| {
if (token_tags[token_index] == .keyword_comptime)
try buffer.appendSlice("comptime ")
else
try buffer.appendSlice("noalias ");
}
2020-05-23 23:21:02 +01:00
if (param.name_token) |name_token| {
try buffer.appendSlice(tree.tokenSlice(name_token));
try buffer.appendSlice(": ");
}
2021-02-27 15:38:06 +00:00
if (param.anytype_ellipsis3) |token_index| {
if (token_tags[token_index] == .keyword_anytype)
try buffer.appendSlice("anytype")
else
try buffer.appendSlice("...");
} else {
var curr_token = param.type_expr;
var end_token = tree.lastToken(func.ast.params[it.param_i]);
while (curr_token <= end_token) : (curr_token += 1) {
const tag = token_tags[curr_token];
const is_comma = tag == .comma;
if (curr_token == end_token and is_comma) continue;
try buffer.appendSlice(tree.tokenSlice(curr_token));
2021-02-28 20:57:15 +00:00
if (is_comma or tag == .keyword_const) try buffer.append(' ');
2021-02-27 15:38:06 +00:00
}
}
try buffer.append('}');
}
try buffer.append(')');
return buffer.toOwnedSlice();
}
2020-05-04 03:17:19 +01:00
/// Gets a function signature (keywords, name, return value)
2021-03-01 15:02:24 +00:00
pub fn getVariableSignature(tree: ast.Tree, var_decl: ast.full.VarDecl) []const u8 {
2021-02-27 15:38:06 +00:00
const start = tree.tokenLocation(0, var_decl.ast.mut_token).line_start;
const end = tree.tokenLocation(@truncate(u32, start), tree.lastToken(var_decl.ast.init_node)).line_end;
2020-05-04 03:17:19 +01:00
return tree.source[start..end];
}
2020-06-10 23:00:13 +01:00
// analysis.getContainerFieldSignature(handle.tree, field)
2021-03-01 15:02:24 +00:00
pub fn getContainerFieldSignature(tree: ast.Tree, field: ast.full.ContainerField) []const u8 {
2021-02-27 15:38:06 +00:00
const start = tree.tokenLocation(0, field.ast.name_token).line_start;
2021-03-02 21:01:13 +00:00
const end_node = if (field.ast.value_expr != 0) field.ast.value_expr else field.ast.type_expr;
const end = tree.tokenLocation(@truncate(u32, start), tree.lastToken(end_node)).line_end;
return tree.source[start .. end - 1];
2020-06-10 23:00:13 +01:00
}
2020-06-12 12:56:46 +01:00
/// The type node is "type"
fn typeIsType(tree: ast.Tree, node: ast.Node.Index) bool {
if (tree.nodes.items(.tag)[node] == .identifier) {
2021-03-02 21:01:13 +00:00
return std.mem.eql(u8, tree.tokenSlice(tree.nodes.items(.main_token)[node]), "type");
2020-06-12 12:56:46 +01:00
}
return false;
}
pub fn isTypeFunction(tree: ast.Tree, func: ast.full.FnProto) bool {
2021-02-27 15:38:06 +00:00
return typeIsType(tree, func.ast.return_type);
2020-05-17 15:23:04 +01:00
}
pub fn isGenericFunction(tree: ast.Tree, func: *ast.full.FnProto) bool {
var it = func.iterate();
while (it.next()) |param| {
if (param.anytype_ellipsis3 != null or param.comptime_noalias != null) {
2020-06-27 18:45:58 +01:00
return true;
}
}
return false;
}
2020-05-04 03:17:19 +01:00
// STYLE
pub fn isCamelCase(name: []const u8) bool {
return !std.ascii.isUpper(name[0]) and std.mem.indexOf(u8, name[0..(name.len - 1)], "_") == null;
2020-05-04 03:17:19 +01:00
}
pub fn isPascalCase(name: []const u8) bool {
return std.ascii.isUpper(name[0]) and std.mem.indexOf(u8, name[0..(name.len - 1)], "_") == null;
}
2020-05-11 13:28:08 +01:00
// ANALYSIS ENGINE
pub fn getDeclNameToken(tree: ast.Tree, node: ast.Node.Index) ?ast.TokenIndex {
const tags = tree.nodes.items(.tag);
2021-03-02 21:01:13 +00:00
const main_token = tree.nodes.items(.main_token)[node];
return switch (tags[node]) {
// regular declaration names. + 1 to mut token because name comes after 'const'/'var'
2021-03-02 21:01:13 +00:00
.local_var_decl => tree.localVarDecl(node).ast.mut_token + 1,
.global_var_decl => tree.globalVarDecl(node).ast.mut_token + 1,
.simple_var_decl => tree.simpleVarDecl(node).ast.mut_token + 1,
.aligned_var_decl => tree.alignedVarDecl(node).ast.mut_token + 1,
// function declaration names
2021-03-02 14:32:38 +00:00
.fn_proto,
.fn_proto_multi,
.fn_proto_one,
.fn_proto_simple,
.fn_decl,
2021-03-02 21:01:13 +00:00
=> blk: {
var params: [1]ast.Node.Index = undefined;
2021-03-02 21:01:13 +00:00
break :blk fnProto(tree, node, &params).?.name_token;
2020-05-28 13:41:40 +01:00
},
// containers
2021-03-02 21:01:13 +00:00
.container_field => tree.containerField(node).ast.name_token,
.container_field_init => tree.containerFieldInit(node).ast.name_token,
.container_field_align => tree.containerFieldAlign(node).ast.name_token,
.identifier => main_token,
// @TODO: Errors
// .error_=> {
// const tag = node.castTag(.ErrorTag).?;
// return tag.name_token;
// },
// lhs of main token is name token, so use `node` - 1
2021-03-02 21:01:13 +00:00
.test_decl => if (tree.tokens.items(.tag)[main_token + 1] == .string_literal)
return main_token + 1
else
null,
else => null,
};
2020-05-18 21:19:23 +01:00
}
fn getDeclName(tree: ast.Tree, node: ast.Node.Index) ?[]const u8 {
2020-05-28 13:41:40 +01:00
const name = tree.tokenSlice(getDeclNameToken(tree, node) orelse return null);
return switch (tree.nodes.items(.tag)[node]) {
.test_decl => name[1 .. name.len - 1],
else => name,
2020-05-28 13:41:40 +01:00
};
2020-05-18 21:19:23 +01:00
}
fn isContainerDecl(decl_handle: DeclWithHandle) bool {
return switch (decl_handle.decl.*) {
2021-03-02 21:01:13 +00:00
.ast_node => |inner_node| isContainer(decl_handle.handle.tree.nodes.items(.tag)[inner_node]),
else => false,
};
}
fn resolveVarDeclAliasInternal(
store: *DocumentStore,
arena: *std.heap.ArenaAllocator,
node_handle: NodeWithHandle,
root: bool,
) error{OutOfMemory}!?DeclWithHandle {
const handle = node_handle.handle;
2021-03-01 13:32:19 +00:00
const tree = handle.tree;
const node_tags = tree.nodes.items(.tag);
const main_tokens = tree.nodes.items(.main_token);
const datas = tree.nodes.items(.data);
if (node_tags[node_handle.node] == .identifier) {
const token = main_tokens[node_handle.node];
return try lookupSymbolGlobal(
store,
arena,
handle,
tree.tokenSlice(token),
2021-03-03 15:34:24 +00:00
tree.tokens.items(.start)[token],
2021-03-01 13:32:19 +00:00
);
}
2021-03-01 13:32:19 +00:00
if (node_tags[node_handle.node] == .field_access) {
const lhs = datas[node_handle.node].lhs;
2021-03-01 13:32:19 +00:00
const container_node = if (isBuiltinCall(tree, lhs)) block: {
2021-03-02 14:32:38 +00:00
const data = datas[lhs];
const builtin = switch (node_tags[lhs]) {
.builtin_call, .builtin_call_comma => tree.extra_data[data.lhs..data.rhs],
.builtin_call_two, .builtin_call_two_comma => if (data.lhs == 0)
&[_]ast.Node.Index{}
else if (data.rhs == 0)
&[_]ast.Node.Index{data.lhs}
else
&[_]ast.Node.Index{ data.lhs, data.rhs },
else => unreachable,
};
2021-03-01 13:32:19 +00:00
if (!std.mem.eql(u8, tree.tokenSlice(main_tokens[lhs]), "@import"))
return null;
2021-03-01 13:32:19 +00:00
const inner_node = (try resolveTypeOfNode(store, arena, .{ .node = lhs, .handle = handle })) orelse return null;
// assert root node
std.debug.assert(inner_node.type.data.other == 0);
break :block NodeWithHandle{ .node = inner_node.type.data.other, .handle = inner_node.handle };
2021-03-01 13:32:19 +00:00
} else if (try resolveVarDeclAliasInternal(store, arena, .{ .node = lhs, .handle = handle }, false)) |decl_handle| block: {
if (decl_handle.decl.* != .ast_node) return null;
const resolved = (try resolveTypeOfNode(store, arena, .{ .node = decl_handle.decl.ast_node, .handle = decl_handle.handle })) orelse return null;
const resolved_node = switch (resolved.type.data) {
.other => |n| n,
else => return null,
};
2021-03-01 13:32:19 +00:00
if (!isContainer(node_tags[resolved_node])) return null;
break :block NodeWithHandle{ .node = resolved_node, .handle = resolved.handle };
} else return null;
2021-03-03 15:34:24 +00:00
if (try lookupSymbolContainer(store, arena, container_node, tree.tokenSlice(datas[node_handle.node].rhs), false)) |inner_decl| {
return inner_decl;
}
}
return null;
}
/// Resolves variable declarations consisting of chains of imports and field accesses of containers, ending with the same name as the variable decl's name
/// Examples:
///```zig
/// const decl = @import("decl-file.zig").decl;
/// const other = decl.middle.other;
///```
2020-06-14 23:19:21 +01:00
pub fn resolveVarDeclAlias(store: *DocumentStore, arena: *std.heap.ArenaAllocator, decl_handle: NodeWithHandle) !?DeclWithHandle {
const decl = decl_handle.node;
const handle = decl_handle.handle;
2021-03-01 13:32:19 +00:00
const tree = handle.tree;
const token_tags = tree.tokens.items(.tag);
const main_tokes = tree.nodes.items(.main_token);
const node_tags = tree.nodes.items(.tag);
2020-06-14 23:19:21 +01:00
2021-03-01 13:32:19 +00:00
if (varDecl(handle.tree, decl)) |var_decl| {
if (var_decl.ast.init_node == 0) return null;
const base_exp = var_decl.ast.init_node;
2021-03-03 15:34:24 +00:00
if (token_tags[var_decl.ast.mut_token] != .keyword_const) return null;
2020-06-14 23:19:21 +01:00
2021-03-01 13:32:19 +00:00
if (node_tags[base_exp] == .field_access) {
2021-03-03 15:34:24 +00:00
const name = tree.tokenSlice(tree.nodes.items(.data)[base_exp].rhs);
2021-03-01 13:32:19 +00:00
if (!std.mem.eql(u8, tree.tokenSlice(var_decl.ast.mut_token + 1), name))
return null;
2020-06-14 23:19:21 +01:00
2021-03-01 13:32:19 +00:00
return try resolveVarDeclAliasInternal(store, arena, .{ .node = base_exp, .handle = handle }, true);
2020-06-14 23:19:21 +01:00
}
}
return null;
}
2020-05-24 13:24:18 +01:00
fn findReturnStatementInternal(
tree: ast.Tree,
2020-05-24 13:24:18 +01:00
fn_decl: *ast.Node.FnProto,
base_node: *ast.Node,
already_found: *bool,
) ?*ast.Node.ControlFlowExpression {
2020-05-19 14:42:36 +01:00
var result: ?*ast.Node.ControlFlowExpression = null;
2020-05-24 15:07:48 +01:00
var child_idx: usize = 0;
2021-03-01 13:32:19 +00:00
while (base_node.iterate(child_idx)) |child_node| : (child_idx += 1) {
2020-07-24 08:33:13 +01:00
if (child_node.castTag(.Return)) |cfe| {
// If we are calling ourselves recursively, ignore this return.
if (cfe.getRHS()) |rhs| {
if (rhs.castTag(.Call)) |call_node| {
if (call_node.lhs.tag == .Identifier) {
if (std.mem.eql(u8, getDeclName(tree, call_node.lhs).?, getDeclName(tree, &fn_decl.base).?)) {
continue;
2020-05-24 13:24:18 +01:00
}
}
2020-05-19 14:42:36 +01:00
}
2020-07-24 08:33:13 +01:00
}
2020-06-14 21:43:29 +01:00
2020-07-24 08:33:13 +01:00
if (already_found.*) return null;
already_found.* = true;
result = cfe;
continue;
2020-05-19 14:42:36 +01:00
}
2020-05-24 13:24:18 +01:00
result = findReturnStatementInternal(tree, fn_decl, child_node, already_found);
2020-05-19 14:42:36 +01:00
}
return result;
}
fn findReturnStatement(tree: ast.Tree, fn_decl: *ast.Node.FnProto) ?*ast.Node.ControlFlowExpression {
2020-05-19 14:42:36 +01:00
var already_found = false;
2020-09-01 06:53:52 +01:00
return findReturnStatementInternal(tree, fn_decl, fn_decl.getBodyNode().?, &already_found);
2020-05-19 14:42:36 +01:00
}
/// Resolves the return type of a function
pub fn resolveReturnType(
2020-06-12 12:56:46 +01:00
store: *DocumentStore,
arena: *std.heap.ArenaAllocator,
2021-02-28 16:42:34 +00:00
fn_decl: ast.full.FnProto,
2020-06-12 12:56:46 +01:00
handle: *DocumentStore.Handle,
bound_type_params: *BoundTypeParams,
2021-03-03 15:34:24 +00:00
fn_body: ?ast.Node.Index,
) !?TypeWithHandle {
2021-03-03 15:34:24 +00:00
const tree = handle.tree;
if (isTypeFunction(tree, fn_decl) and fn_body != null) {
// @TODO: find return statement inside fn body of `type` (generic) functions
}
if (fn_decl.ast.return_type == 0) return null;
2021-02-28 16:42:34 +00:00
return resolveTypeOfNodeInternal(store, arena, .{
.node = fn_decl.ast.return_type,
.handle = handle,
}, bound_type_params);
2020-05-19 14:42:36 +01:00
}
2020-05-27 16:49:11 +01:00
/// Resolves the child type of an optional type
2020-06-12 12:56:46 +01:00
fn resolveUnwrapOptionalType(
store: *DocumentStore,
arena: *std.heap.ArenaAllocator,
opt: TypeWithHandle,
2020-06-12 12:56:46 +01:00
bound_type_params: *BoundTypeParams,
) !?TypeWithHandle {
const opt_node = switch (opt.type.data) {
.other => |n| n,
else => return null,
};
2021-02-28 20:57:15 +00:00
if (opt.handle.tree.nodes.items(.tag)[opt_node] == .optional_type) {
return ((try resolveTypeOfNodeInternal(store, arena, .{
.node = opt.handle.tree.nodes.items(.data)[opt_node].lhs,
.handle = opt.handle,
}, bound_type_params)) orelse return null).instanceTypeVal();
2020-05-27 16:49:11 +01:00
}
return null;
}
2020-06-12 12:56:46 +01:00
fn resolveUnwrapErrorType(
store: *DocumentStore,
arena: *std.heap.ArenaAllocator,
rhs: TypeWithHandle,
2020-06-12 12:56:46 +01:00
bound_type_params: *BoundTypeParams,
) !?TypeWithHandle {
const rhs_node = switch (rhs.type.data) {
.other => |n| n,
.error_union => |n| return TypeWithHandle{
2020-06-17 13:07:21 +01:00
.type = .{ .data = .{ .other = n }, .is_type_val = rhs.type.is_type_val },
.handle = rhs.handle,
},
.primitive, .slice, .pointer => return null,
};
2021-02-28 20:57:15 +00:00
if (rhs.handle.tree.nodes.items(.tag)[rhs_node] == .error_union) {
return ((try resolveTypeOfNodeInternal(store, arena, .{
.node = rhs.handle.tree.nodes.items(.data)[rhs_node].rhs,
.handle = rhs.handle,
}, bound_type_params)) orelse return null).instanceTypeVal();
2020-06-11 00:40:11 +01:00
}
return null;
}
2021-03-01 15:02:24 +00:00
pub fn isPtrType(tree: ast.Tree, node: ast.Node.Index) bool {
2021-02-28 16:42:34 +00:00
return switch (tree.nodes.items(.tag)[node]) {
.ptr_type,
.ptr_type_aligned,
.ptr_type_bit_range,
.ptr_type_sentinel,
=> true,
else => false,
};
}
/// Resolves the child type of a deref type
2020-06-12 12:56:46 +01:00
fn resolveDerefType(
store: *DocumentStore,
arena: *std.heap.ArenaAllocator,
deref: TypeWithHandle,
2020-06-12 12:56:46 +01:00
bound_type_params: *BoundTypeParams,
) !?TypeWithHandle {
const deref_node = switch (deref.type.data) {
.other => |n| n,
else => return null,
};
2021-02-28 16:42:34 +00:00
const tree = deref.handle.tree;
const main_token = tree.nodes.items(.main_token)[deref_node];
const token_tag = tree.tokens.items(.tag)[main_token];
2021-02-28 19:37:21 +00:00
if (isPtrType(tree, deref_node)) {
2021-03-03 15:34:24 +00:00
const ptr_type = ptrType(tree, deref_node).?;
2021-02-28 16:42:34 +00:00
switch (token_tag) {
.asterisk => {
2020-07-23 18:30:03 +01:00
return ((try resolveTypeOfNodeInternal(store, arena, .{
2021-03-03 15:34:24 +00:00
.node = ptr_type.ast.child_type,
2020-07-23 18:30:03 +01:00
.handle = deref.handle,
}, bound_type_params)) orelse return null).instanceTypeVal();
},
2021-02-28 16:42:34 +00:00
.l_bracket, .asterisk_asterisk => return null,
2020-07-23 18:30:03 +01:00
else => unreachable,
2020-05-27 16:49:11 +01:00
}
}
return null;
}
/// Resolves bracket access type (both slicing and array access)
fn resolveBracketAccessType(
2020-06-10 17:54:01 +01:00
store: *DocumentStore,
arena: *std.heap.ArenaAllocator,
lhs: TypeWithHandle,
2020-05-27 16:49:11 +01:00
rhs: enum { Single, Range },
2020-06-12 12:56:46 +01:00
bound_type_params: *BoundTypeParams,
) !?TypeWithHandle {
const lhs_node = switch (lhs.type.data) {
.other => |n| n,
else => return null,
};
2021-03-01 13:32:19 +00:00
const tree = lhs.handle.tree;
const tags = tree.nodes.items(.tag);
2021-02-28 20:57:15 +00:00
const tag = tags[lhs_node];
2021-03-01 13:32:19 +00:00
const data = tree.nodes.items(.data)[lhs_node];
2021-02-28 20:57:15 +00:00
if (tag == .array_type or tag == .array_type_sentinel) {
2020-07-23 19:33:43 +01:00
if (rhs == .Single)
return ((try resolveTypeOfNodeInternal(store, arena, .{
2021-02-28 20:57:15 +00:00
.node = data.rhs,
2020-07-23 19:33:43 +01:00
.handle = lhs.handle,
}, bound_type_params)) orelse return null).instanceTypeVal();
return TypeWithHandle{
2021-02-28 20:57:15 +00:00
.type = .{ .data = .{ .slice = data.rhs }, .is_type_val = false },
2020-07-23 19:33:43 +01:00
.handle = lhs.handle,
};
2021-02-28 20:57:15 +00:00
} else if (isPtrType(tree, lhs_node)) {
if (tags[data.rhs] == .array_type or tags[data.rhs] == .array_type_sentinel) {
2020-07-23 19:33:43 +01:00
if (rhs == .Single) {
return ((try resolveTypeOfNodeInternal(store, arena, .{
2021-03-01 13:32:19 +00:00
.node = tree.nodes.items(.data)[data.rhs].rhs,
.handle = lhs.handle,
2020-07-23 19:33:43 +01:00
}, bound_type_params)) orelse return null).instanceTypeVal();
}
2021-03-03 15:34:24 +00:00
return lhs;
2020-05-27 16:49:11 +01:00
}
}
2020-07-23 19:33:43 +01:00
2020-05-27 16:49:11 +01:00
return null;
}
/// Called to remove one level of pointerness before a field access
2020-06-18 13:12:09 +01:00
pub fn resolveFieldAccessLhsType(
2020-06-12 12:56:46 +01:00
store: *DocumentStore,
arena: *std.heap.ArenaAllocator,
lhs: TypeWithHandle,
2020-06-12 12:56:46 +01:00
bound_type_params: *BoundTypeParams,
) !TypeWithHandle {
2020-06-12 12:56:46 +01:00
return (try resolveDerefType(store, arena, lhs, bound_type_params)) orelse lhs;
2020-05-27 16:49:11 +01:00
}
2021-03-03 15:34:24 +00:00
pub const BoundTypeParams = std.AutoHashMap(ast.full.FnProto.Param, TypeWithHandle);
fn allDigits(str: []const u8) bool {
for (str) |c| {
if (!std.ascii.isDigit(c)) return false;
}
return true;
}
pub fn isTypeIdent(tree: ast.Tree, token_idx: ast.TokenIndex) bool {
const PrimitiveTypes = std.ComptimeStringMap(void, .{
.{"isize"}, .{"usize"},
.{"c_short"}, .{"c_ushort"},
.{"c_int"}, .{"c_uint"},
.{"c_long"}, .{"c_ulong"},
.{"c_longlong"}, .{"c_ulonglong"},
.{"c_longdouble"}, .{"c_void"},
.{"f16"}, .{"f32"},
.{"f64"}, .{"f128"},
.{"bool"}, .{"void"},
.{"noreturn"}, .{"type"},
.{"anyerror"}, .{"comptime_int"},
.{"comptime_float"}, .{"anyframe"},
});
const text = tree.tokenSlice(token_idx);
if (PrimitiveTypes.has(text)) return true;
if (text.len > 1 and (text[0] == 'u' or text[0] == 'i') and allDigits(text[1..]))
return true;
return false;
}
2020-06-12 12:56:46 +01:00
2020-05-13 14:03:33 +01:00
/// Resolves the type of a node
2020-06-18 13:12:09 +01:00
pub fn resolveTypeOfNodeInternal(
2020-06-12 12:56:46 +01:00
store: *DocumentStore,
arena: *std.heap.ArenaAllocator,
node_handle: NodeWithHandle,
bound_type_params: *BoundTypeParams,
) error{OutOfMemory}!?TypeWithHandle {
2020-06-10 18:48:40 +01:00
const node = node_handle.node;
const handle = node_handle.handle;
2021-02-28 16:42:34 +00:00
const tree = handle.tree;
const main_tokens = tree.nodes.items(.main_token);
const node_tags = tree.nodes.items(.tag);
const datas = tree.nodes.items(.data);
const token_tags = tree.tokens.items(.tag);
const starts = tree.tokens.items(.start);
2020-06-10 18:48:40 +01:00
2021-02-28 16:42:34 +00:00
switch (node_tags[node]) {
.global_var_decl, .local_var_decl, .simple_var_decl, .aligned_var_decl => {
const var_decl = varDecl(tree, node).?;
if (var_decl.ast.type_node != 0) block: {
return ((try resolveTypeOfNodeInternal(
store,
arena,
2021-02-28 16:42:34 +00:00
.{ .node = var_decl.ast.type_node, .handle = handle },
bound_type_params,
)) orelse break :block).instanceTypeVal();
}
2021-02-28 16:42:34 +00:00
return if (var_decl.ast.init_node != 0)
try resolveTypeOfNodeInternal(store, arena, .{ .node = var_decl.ast.init_node, .handle = handle }, bound_type_params)
else
null;
2020-05-11 13:28:08 +01:00
},
2021-02-28 16:42:34 +00:00
.identifier => {
2021-03-03 15:34:24 +00:00
if (isTypeIdent(handle.tree, main_tokens[node])) {
return TypeWithHandle{
.type = .{ .data = .primitive, .is_type_val = true },
.handle = handle,
};
}
2021-03-03 15:34:24 +00:00
if (try lookupSymbolGlobal(store, arena, handle, tree.getNodeSource(node), starts[main_tokens[node]])) |child| {
2020-06-18 13:12:09 +01:00
switch (child.decl.*) {
.ast_node => |n| {
if (n == node) return null;
2021-02-28 16:42:34 +00:00
if (varDecl(tree, n)) |var_decl| {
2021-03-03 16:45:42 +00:00
if (var_decl.ast.init_node != 0 and var_decl.ast.init_node == node) return null;
}
},
2020-06-18 01:23:56 +01:00
else => {},
}
2020-06-12 12:56:46 +01:00
return try child.resolveType(store, arena, bound_type_params);
2020-06-10 18:48:40 +01:00
}
return null;
2020-05-11 13:28:08 +01:00
},
2021-02-28 16:42:34 +00:00
.container_field, .container_field_init, .container_field_align => |c| {
const field: ast.full.ContainerField = switch (c) {
.container_field => tree.containerField(node),
.container_field_align => tree.containerFieldAlign(node),
.container_field_init => tree.containerFieldInit(node),
else => unreachable,
};
if (field.ast.type_expr == 0) return null;
return ((try resolveTypeOfNodeInternal(
store,
arena,
2021-02-28 16:42:34 +00:00
.{ .node = field.ast.type_expr, .handle = handle },
bound_type_params,
)) orelse return null).instanceTypeVal();
2020-05-11 13:28:08 +01:00
},
2021-02-28 16:42:34 +00:00
.call,
.call_comma,
.async_call,
.async_call_comma,
.call_one,
.call_one_comma,
.async_call_one,
.async_call_one_comma,
=> |c| {
var params: [1]ast.Node.Index = undefined;
const call: ast.full.Call = switch (c) {
.call, .call_comma, .async_call, .async_call_comma => tree.callFull(node),
.call_one, .call_one_comma, .async_call_one, .async_call_one_comma => tree.callOne(&params, node),
else => unreachable,
};
2020-06-17 13:07:21 +01:00
const decl = (try resolveTypeOfNodeInternal(
store,
arena,
2021-02-28 16:42:34 +00:00
.{ .node = call.ast.fn_expr, .handle = handle },
2020-06-17 13:07:21 +01:00
bound_type_params,
)) orelse return null;
2020-06-17 13:07:21 +01:00
if (decl.type.is_type_val) return null;
const decl_node = switch (decl.type.data) {
.other => |n| n,
else => return null,
};
2021-02-28 16:42:34 +00:00
var buf: [1]ast.Node.Index = undefined;
2021-03-03 16:45:42 +00:00
const func_maybe = fnProto(decl.handle.tree, decl_node, &buf);
2021-02-28 16:42:34 +00:00
if (func_maybe) |fn_decl| {
// check for x.y(..). if '.' is found, it means first param should be skipped
const has_self_param = token_tags[call.ast.lparen - 2] == .period;
2021-03-03 16:45:42 +00:00
var it = fn_decl.iterate(decl.handle.tree);
2020-06-12 12:56:46 +01:00
2021-02-28 16:42:34 +00:00
// Bind type params to the expressions passed in the calls.
const param_len = std.math.min(call.ast.params.len + @boolToInt(has_self_param), fn_decl.ast.params.len);
while (it.next()) |decl_param| {
if (it.param_i == 0 and has_self_param) continue;
if (it.param_i >= param_len) break;
2021-03-03 16:45:42 +00:00
if (!typeIsType(decl.handle.tree, decl_param.type_expr)) continue;
2020-06-12 12:56:46 +01:00
const call_param_type = (try resolveTypeOfNodeInternal(store, arena, .{
2021-02-28 16:42:34 +00:00
.node = call.ast.params[it.param_i - @boolToInt(has_self_param)],
2021-03-03 16:45:42 +00:00
.handle = decl.handle,
2020-06-12 12:56:46 +01:00
}, bound_type_params)) orelse continue;
if (!call_param_type.type.is_type_val) continue;
2020-06-12 12:56:46 +01:00
2021-03-03 15:34:24 +00:00
_ = try bound_type_params.put(decl_param, call_param_type);
2020-06-12 12:56:46 +01:00
}
2021-03-03 16:45:42 +00:00
const has_body = decl.handle.tree.nodes.items(.tag)[decl_node] == .fn_decl;
const body = decl.handle.tree.nodes.items(.data)[decl_node].rhs;
2021-03-03 15:34:24 +00:00
return try resolveReturnType(store, arena, fn_decl, decl.handle, bound_type_params, if (has_body) body else null);
}
2020-06-17 13:07:21 +01:00
return null;
2020-05-23 23:21:02 +01:00
},
2021-03-03 16:45:42 +00:00
.@"comptime", .@"nosuspend", .grouped_expression => {
2021-02-28 19:37:21 +00:00
return try resolveTypeOfNodeInternal(store, arena, .{ .node = datas[node].lhs, .handle = handle }, bound_type_params);
},
2021-02-28 19:37:21 +00:00
.struct_init, .struct_init_comma, .struct_init_one, .struct_init_one_comma => {
return ((try resolveTypeOfNodeInternal(
store,
arena,
2021-02-28 19:37:21 +00:00
.{ .node = datas[node].lhs, .handle = handle },
bound_type_params,
)) orelse return null).instanceTypeVal();
2020-05-11 13:28:08 +01:00
},
2021-02-28 19:37:21 +00:00
.error_set_decl => {
return TypeWithHandle.typeVal(node_handle);
2020-05-16 17:04:07 +01:00
},
2021-02-28 19:37:21 +00:00
.slice, .slice_sentinel, .slice_open => {
2020-06-12 12:56:46 +01:00
const left_type = (try resolveTypeOfNodeInternal(store, arena, .{
2021-03-01 13:32:19 +00:00
.node = datas[node].lhs,
2020-06-12 12:56:46 +01:00
.handle = handle,
}, bound_type_params)) orelse return null;
2020-07-24 08:33:13 +01:00
return try resolveBracketAccessType(store, arena, left_type, .Range, bound_type_params);
2020-07-23 17:06:39 +01:00
},
2021-02-28 19:37:21 +00:00
.deref, .unwrap_optional => {
2020-07-23 17:06:39 +01:00
const left_type = (try resolveTypeOfNodeInternal(store, arena, .{
2021-03-01 13:32:19 +00:00
.node = datas[node].lhs,
2020-07-23 17:06:39 +01:00
.handle = handle,
}, bound_type_params)) orelse return null;
2021-02-28 19:37:21 +00:00
return switch (node_tags[node]) {
.unwrap_optional => try resolveUnwrapOptionalType(store, arena, left_type, bound_type_params),
.deref => try resolveDerefType(store, arena, left_type, bound_type_params),
2020-07-23 17:06:39 +01:00
else => unreachable,
2020-07-24 08:33:13 +01:00
};
2020-07-23 17:06:39 +01:00
},
2021-02-28 19:37:21 +00:00
.array_access => {
2020-07-23 17:06:39 +01:00
const left_type = (try resolveTypeOfNodeInternal(store, arena, .{
2021-02-28 19:37:21 +00:00
.node = datas[node].lhs,
2020-07-23 17:06:39 +01:00
.handle = handle,
}, bound_type_params)) orelse return null;
return try resolveBracketAccessType(store, arena, left_type, .Single, bound_type_params);
2020-05-27 16:49:11 +01:00
},
2021-02-28 19:37:21 +00:00
.field_access => {
2021-03-02 14:32:38 +00:00
const field_access = datas[node];
2021-03-02 21:01:13 +00:00
2021-03-03 16:45:42 +00:00
if (datas[node].rhs == 0) return null;
const rhs_str = tree.tokenSlice(datas[node].rhs);
2020-07-16 20:19:08 +01:00
// If we are accessing a pointer type, remove one pointerness level :)
const left_type = try resolveFieldAccessLhsType(
store,
arena,
(try resolveTypeOfNodeInternal(store, arena, .{
2021-03-02 14:32:38 +00:00
.node = field_access.lhs,
2020-07-16 20:19:08 +01:00
.handle = handle,
}, bound_type_params)) orelse return null,
bound_type_params,
);
2020-07-16 20:19:08 +01:00
const left_type_node = switch (left_type.type.data) {
.other => |n| n,
else => return null,
};
if (try lookupSymbolContainer(
store,
arena,
.{ .node = left_type_node, .handle = left_type.handle },
rhs_str,
2021-03-03 15:34:24 +00:00
left_type.type.is_type_val,
2020-07-16 20:19:08 +01:00
)) |child| {
return try child.resolveType(store, arena, bound_type_params);
} else return null;
},
2021-02-28 19:37:21 +00:00
.@"orelse" => {
2020-07-16 20:19:08 +01:00
const left_type = (try resolveTypeOfNodeInternal(store, arena, .{
2021-02-28 19:37:21 +00:00
.node = datas[node].lhs,
2020-07-16 20:19:08 +01:00
.handle = handle,
}, bound_type_params)) orelse return null;
return try resolveUnwrapOptionalType(store, arena, left_type, bound_type_params);
},
2021-02-28 19:37:21 +00:00
.@"catch" => {
2020-07-16 20:19:08 +01:00
const left_type = (try resolveTypeOfNodeInternal(store, arena, .{
2021-02-28 19:37:21 +00:00
.node = datas[node].lhs,
2020-07-16 20:19:08 +01:00
.handle = handle,
}, bound_type_params)) orelse return null;
return try resolveUnwrapErrorType(store, arena, left_type, bound_type_params);
},
2021-02-28 19:37:21 +00:00
.error_union => return TypeWithHandle.typeVal(node_handle),
.array_type,
.array_type_sentinel,
.optional_type,
.ptr_type_aligned,
.ptr_type,
.ptr_type_bit_range,
2020-07-16 20:19:08 +01:00
=> return TypeWithHandle.typeVal(node_handle),
2021-02-28 19:37:21 +00:00
.@"try" => {
2020-07-16 20:19:08 +01:00
const rhs_type = (try resolveTypeOfNodeInternal(store, arena, .{
2021-02-28 19:37:21 +00:00
.node = datas[node].lhs,
2020-07-16 20:19:08 +01:00
.handle = handle,
}, bound_type_params)) orelse return null;
return try resolveUnwrapErrorType(store, arena, rhs_type, bound_type_params);
},
2021-02-28 19:37:21 +00:00
.address_of => {
const rhs_type = (try resolveTypeOfNodeInternal(store, arena, .{
2021-02-28 19:37:21 +00:00
.node = datas[node].lhs,
.handle = handle,
}, bound_type_params)) orelse return null;
const rhs_node = switch (rhs_type.type.data) {
.other => |n| n,
else => return null,
};
return TypeWithHandle{
.type = .{ .data = .{ .pointer = rhs_node }, .is_type_val = false },
.handle = rhs_type.handle,
};
},
2021-02-28 19:37:21 +00:00
.builtin_call, .builtin_call_comma, .builtin_call_two, .builtin_call_two_comma => {
2021-03-02 14:32:38 +00:00
const data = datas[node];
const params = switch (node_tags[node]) {
.builtin_call, .builtin_call_comma => tree.extra_data[data.lhs..data.rhs],
.builtin_call_two, .builtin_call_two_comma => if (data.lhs == 0)
&[_]ast.Node.Index{}
else if (data.rhs == 0)
&[_]ast.Node.Index{data.lhs}
else
&[_]ast.Node.Index{ data.lhs, data.rhs },
else => unreachable,
};
2021-02-28 19:37:21 +00:00
const call_name = tree.tokenSlice(main_tokens[node]);
2020-05-19 16:53:01 +01:00
if (std.mem.eql(u8, call_name, "@This")) {
2021-02-28 19:37:21 +00:00
if (params.len != 0) return null;
return innermostContainer(handle, starts[tree.firstToken(node)]);
2020-05-19 16:53:01 +01:00
}
const cast_map = std.ComptimeStringMap(void, .{
2020-06-16 13:49:57 +01:00
.{"@as"},
.{"@bitCast"},
.{"@fieldParentPtr"},
.{"@floatCast"},
.{"@floatToInt"},
.{"@intCast"},
.{"@intToEnum"},
.{"@intToFloat"},
.{"@intToPtr"},
.{"@truncate"},
.{"@ptrCast"},
});
if (cast_map.has(call_name)) {
2021-02-28 19:37:21 +00:00
if (params.len < 1) return null;
return ((try resolveTypeOfNodeInternal(store, arena, .{
2021-02-28 19:37:21 +00:00
.node = params[0],
2020-06-12 12:56:46 +01:00
.handle = handle,
}, bound_type_params)) orelse return null).instanceTypeVal();
}
// Almost the same as the above, return a type value though.
2020-06-17 13:07:21 +01:00
// TODO Do peer type resolution, we just keep the first for now.
if (std.mem.eql(u8, call_name, "@TypeOf")) {
2021-02-28 19:37:21 +00:00
if (params.len < 1) return null;
var resolved_type = (try resolveTypeOfNodeInternal(store, arena, .{
2021-02-28 19:37:21 +00:00
.node = params[0],
.handle = handle,
}, bound_type_params)) orelse return null;
if (resolved_type.type.is_type_val) return null;
resolved_type.type.is_type_val = true;
return resolved_type;
}
2020-05-19 16:53:01 +01:00
if (!std.mem.eql(u8, call_name, "@import")) return null;
2021-03-02 14:32:38 +00:00
if (params.len == 0) return null;
2021-02-28 19:37:21 +00:00
const import_param = params[0];
if (node_tags[import_param] != .string_literal) return null;
2021-02-28 19:37:21 +00:00
const import_str = tree.tokenSlice(main_tokens[import_param]);
2020-08-14 11:27:10 +01:00
const new_handle = (store.resolveImport(handle, import_str[1 .. import_str.len - 1]) catch |err| {
log.debug("Error {} while processing import {s}", .{ err, import_str });
2020-06-10 19:24:17 +01:00
return null;
}) orelse return null;
2021-02-28 19:37:21 +00:00
// reference to node '0' which is root
return TypeWithHandle.typeVal(.{ .node = 0, .handle = new_handle });
},
2021-02-28 19:37:21 +00:00
.container_decl,
.container_decl_arg,
.container_decl_arg_trailing,
.container_decl_trailing,
.container_decl_two,
.container_decl_two_trailing,
=> {
return TypeWithHandle.typeVal(node_handle);
},
2021-03-02 14:32:38 +00:00
.fn_proto, .fn_proto_multi, .fn_proto_one, .fn_proto_simple, .fn_decl => {
2021-02-28 19:37:21 +00:00
var buf: [1]ast.Node.Index = undefined;
2021-03-01 13:32:19 +00:00
const fn_proto = fnProto(tree, node, &buf).?;
2021-02-28 19:37:21 +00:00
2020-06-17 13:07:21 +01:00
// This is a function type
2021-02-28 19:37:21 +00:00
if (fn_proto.name_token == null) {
2020-06-17 13:07:21 +01:00
return TypeWithHandle.typeVal(node_handle);
}
2021-02-28 19:37:21 +00:00
2020-06-17 13:07:21 +01:00
return TypeWithHandle{
.type = .{ .data = .{ .other = node }, .is_type_val = false },
.handle = handle,
};
},
2021-02-28 19:37:21 +00:00
.multiline_string_literal, .string_literal => return TypeWithHandle{
.type = .{ .data = .{ .other = node }, .is_type_val = false },
.handle = handle,
2020-05-24 13:24:18 +01:00
},
2021-03-03 16:45:42 +00:00
.root => return TypeWithHandle.typeVal(node_handle),
2021-03-02 21:01:13 +00:00
else => {
2021-03-03 16:45:42 +00:00
// log.debug("TODO: implement type resolving for ast tag: {s}", .{node_tags[node]});
2021-03-02 21:01:13 +00:00
},
2020-05-13 14:03:33 +01:00
}
return null;
}
2020-05-11 13:28:08 +01:00
// TODO Reorganize this file, perhaps split into a couple as well
// TODO Make this better, nested levels of type vals
pub const Type = struct {
data: union(enum) {
2021-02-28 16:42:34 +00:00
pointer: ast.Node.Index,
slice: ast.Node.Index,
error_union: ast.Node.Index,
other: ast.Node.Index,
primitive,
},
/// If true, the type `type`, the attached data is the value of the type value.
is_type_val: bool,
};
pub const TypeWithHandle = struct {
type: Type,
handle: *DocumentStore.Handle,
pub fn typeVal(node_handle: NodeWithHandle) TypeWithHandle {
return .{
.type = .{
.data = .{ .other = node_handle.node },
.is_type_val = true,
},
.handle = node_handle.handle,
};
}
fn instanceTypeVal(self: TypeWithHandle) ?TypeWithHandle {
if (!self.type.is_type_val) return null;
return TypeWithHandle{
.type = .{ .data = self.type.data, .is_type_val = false },
.handle = self.handle,
};
}
fn isRoot(self: TypeWithHandle) bool {
switch (self.type.data) {
2021-02-28 20:57:15 +00:00
// root is always index 0
.other => |n| return n == 0,
else => return false,
}
}
2021-02-28 20:57:15 +00:00
fn isContainer(self: TypeWithHandle, container_kind_tok: std.zig.Token.Tag, tree: ast.Tree) bool {
const main_tokens = tree.nodes.items(.main_token);
const tags = tree.tokens.items(.tag);
switch (self.type.data) {
2021-02-28 20:57:15 +00:00
.other => |n| return tags[main_tokens[n]] == container_kind_tok,
else => return false,
}
}
2021-02-28 20:57:15 +00:00
pub fn isStructType(self: TypeWithHandle, tree: ast.Tree) bool {
return self.isContainer(.keyword_struct, tree) or self.isRoot();
}
2021-02-28 20:57:15 +00:00
pub fn isNamespace(self: TypeWithHandle, tree: ast.Tree) bool {
2020-06-27 18:45:58 +01:00
if (!self.isStructType()) return false;
var idx: usize = 0;
2021-03-03 15:34:24 +00:00
// @TODO: FIX ME
2020-06-27 18:45:58 +01:00
while (self.type.data.other.iterate(idx)) |child| : (idx += 1) {
2020-07-16 15:56:22 +01:00
if (child.tag == .ContainerField)
2020-06-27 18:45:58 +01:00
return false;
}
return true;
}
2021-02-28 20:57:15 +00:00
pub fn isEnumType(self: TypeWithHandle, tree: ast.Tree) bool {
return self.isContainer(.keyword_enum, tree);
}
2021-02-28 20:57:15 +00:00
pub fn isUnionType(self: TypeWithHandle, tree: ast.Tree) bool {
return self.isContainer(.keyword_union, tree);
}
2020-06-18 13:12:09 +01:00
2021-02-28 20:57:15 +00:00
pub fn isOpaqueType(self: TypeWithHandle, tree: ast.Tree) bool {
return self.isContainer(.keyword_opaque, tree);
2020-10-10 10:25:50 +01:00
}
2021-02-28 20:57:15 +00:00
pub fn isTypeFunc(self: TypeWithHandle, tree: ast.Tree) bool {
var buf: [1]ast.Node.Index = undefined;
2021-03-03 15:34:24 +00:00
return switch (self.type.data) {
.other => |n| if (fnProto(tree, n, &buf)) |fn_proto| blk: {
break :blk isTypeFunction(tree, fn_proto);
} else false,
else => false,
};
2020-06-27 18:45:58 +01:00
}
2021-02-28 20:57:15 +00:00
pub fn isGenericFunc(self: TypeWithHandle, tree: ast.Tree) bool {
var buf: [1]ast.Node.Index = undefined;
2021-03-03 15:34:24 +00:00
return switch (self.type.data) {
.other => |n| if (fnProto(tree, n, &buf)) |fn_proto| blk: {
break :blk isGenericFunction(tree, fn_proto);
} else false,
else => false,
};
2020-06-18 13:12:09 +01:00
}
2021-02-28 20:57:15 +00:00
pub fn isFunc(self: TypeWithHandle, tree: ast.Tree) bool {
const tags = tree.nodes.items(.tag);
2021-03-03 15:34:24 +00:00
return switch (self.type.data) {
.other => |n| switch (tags[n]) {
2021-02-28 20:57:15 +00:00
.fn_proto,
.fn_proto_multi,
.fn_proto_one,
.fn_proto_simple,
2021-03-02 14:32:38 +00:00
.fn_decl,
2021-02-28 20:57:15 +00:00
=> true,
else => false,
2020-06-18 13:12:09 +01:00
},
2021-03-03 15:34:24 +00:00
else => false,
};
2020-06-18 13:12:09 +01:00
}
};
pub fn resolveTypeOfNode(store: *DocumentStore, arena: *std.heap.ArenaAllocator, node_handle: NodeWithHandle) error{OutOfMemory}!?TypeWithHandle {
2020-06-12 12:56:46 +01:00
var bound_type_params = BoundTypeParams.init(&arena.allocator);
return resolveTypeOfNodeInternal(store, arena, node_handle, &bound_type_params);
}
fn maybeCollectImport(tree: ast.Tree, builtin_call: ast.Node.Index, arr: *std.ArrayList([]const u8)) !void {
const tags = tree.nodes.items(.tag);
const datas = tree.nodes.items(.data);
const builtin_tag = tags[builtin_call];
2021-03-02 14:32:38 +00:00
const data = datas[builtin_call];
2021-03-02 14:32:38 +00:00
std.debug.assert(isBuiltinCall(tree, builtin_call));
if (!std.mem.eql(u8, tree.tokenSlice(builtin_call), "@import")) return;
2021-03-02 14:32:38 +00:00
const params = switch (builtin_tag) {
.builtin_call, .builtin_call_comma => tree.extra_data[data.lhs..data.rhs],
.builtin_call_two, .builtin_call_two_comma => if (data.lhs == 0)
&[_]ast.Node.Index{}
else if (data.rhs == 0)
&[_]ast.Node.Index{data.lhs}
else
&[_]ast.Node.Index{ data.lhs, data.rhs },
else => unreachable,
};
if (params.len > 1) return;
if (tags[params[0]] != .string_literal) return;
2021-03-02 14:32:38 +00:00
const import_str = tree.tokenSlice(tree.nodes.items(.main_token)[params[0]]);
try arr.append(import_str[1 .. import_str.len - 1]);
}
/// Collects all imports we can find into a slice of import paths (without quotes).
/// The import paths are valid as long as the tree is.
pub fn collectImports(import_arr: *std.ArrayList([]const u8), tree: ast.Tree) !void {
2020-05-18 13:46:17 +01:00
// TODO: Currently only detects `const smth = @import("string literal")<.SomeThing>;`
const tags = tree.nodes.items(.tag);
for (tree.rootDecls()) |decl_idx| {
const var_decl_maybe: ?ast.full.VarDecl = switch (tags[decl_idx]) {
.global_var_decl => tree.globalVarDecl(decl_idx),
.local_var_decl => tree.localVarDecl(decl_idx),
.simple_var_decl => tree.simpleVarDecl(decl_idx),
else => null,
};
const var_decl = var_decl_maybe orelse continue;
2021-03-03 15:34:24 +00:00
if (var_decl.ast.init_node == 0) continue;
const init_node = var_decl.ast.init_node;
const init_node_tag = tags[init_node];
switch (init_node_tag) {
2021-03-03 15:34:24 +00:00
.builtin_call,
.builtin_call_comma,
.builtin_call_two,
.builtin_call_two_comma,
=> try maybeCollectImport(tree, init_node, import_arr),
.field_access => {
const lhs = tree.nodes.items(.data)[init_node].lhs;
if (isBuiltinCall(tree, lhs)) {
try maybeCollectImport(tree, lhs, import_arr);
}
},
else => {},
}
}
}
2020-06-10 17:54:01 +01:00
pub const NodeWithHandle = struct {
2021-02-28 16:42:34 +00:00
node: ast.Node.Index,
2020-06-10 17:54:01 +01:00
handle: *DocumentStore.Handle,
};
pub const FieldAccessReturn = struct {
original: TypeWithHandle,
unwrapped: ?TypeWithHandle = null,
};
pub fn getFieldAccessType(
2020-06-10 17:54:01 +01:00
store: *DocumentStore,
arena: *std.heap.ArenaAllocator,
handle: *DocumentStore.Handle,
2020-06-10 22:24:57 +01:00
source_index: usize,
tokenizer: *std.zig.Tokenizer,
) !?FieldAccessReturn {
var current_type = TypeWithHandle.typeVal(.{
2020-07-23 18:30:03 +01:00
.node = undefined,
2020-06-10 17:54:01 +01:00
.handle = handle,
});
2020-05-11 13:28:08 +01:00
2020-06-12 12:56:46 +01:00
// TODO Actually bind params here when calling functions instead of just skipping args.
var bound_type_params = BoundTypeParams.init(&arena.allocator);
2021-03-01 13:32:19 +00:00
const tree = handle.tree;
2020-06-12 12:56:46 +01:00
2020-05-13 14:03:33 +01:00
while (true) {
const tok = tokenizer.next();
2021-02-28 16:42:34 +00:00
switch (tok.tag) {
.eof => return FieldAccessReturn{
.original = current_type,
.unwrapped = try resolveDerefType(store, arena, current_type, &bound_type_params),
},
2021-02-28 16:42:34 +00:00
.identifier => {
if (try lookupSymbolGlobal(store, arena, current_type.handle, tokenizer.buffer[tok.loc.start..tok.loc.end], source_index)) |child| {
current_type = (try child.resolveType(store, arena, &bound_type_params)) orelse return null;
2020-05-13 14:03:33 +01:00
} else return null;
},
2021-02-28 16:42:34 +00:00
.period => {
const after_period = tokenizer.next();
2021-02-28 20:57:15 +00:00
switch (after_period.tag) {
2021-03-01 13:32:19 +00:00
.eof => return FieldAccessReturn{
.original = current_type,
.unwrapped = try resolveDerefType(store, arena, current_type, &bound_type_params),
},
2021-03-01 13:32:19 +00:00
.identifier => {
if (after_period.loc.end == tokenizer.buffer.len) {
return FieldAccessReturn{
.original = current_type,
.unwrapped = try resolveDerefType(store, arena, current_type, &bound_type_params),
};
}
current_type = try resolveFieldAccessLhsType(store, arena, current_type, &bound_type_params);
const current_type_node = switch (current_type.type.data) {
.other => |n| n,
else => return null,
};
if (try lookupSymbolContainer(
store,
arena,
.{ .node = current_type_node, .handle = current_type.handle },
tokenizer.buffer[after_period.loc.start..after_period.loc.end],
!current_type.type.is_type_val,
)) |child| {
current_type = (try child.resolveType(store, arena, &bound_type_params)) orelse return null;
2020-05-13 16:43:28 +01:00
} else return null;
},
2021-03-01 13:32:19 +00:00
.question_mark => {
current_type = (try resolveUnwrapOptionalType(store, arena, current_type, &bound_type_params)) orelse return null;
},
else => {
2021-02-28 20:57:15 +00:00
log.debug("Unrecognized token {} after period.", .{after_period.tag});
return null;
},
2020-05-13 14:03:33 +01:00
}
},
2021-02-28 16:42:34 +00:00
.period_asterisk => {
current_type = (try resolveDerefType(store, arena, current_type, &bound_type_params)) orelse return null;
},
2021-02-28 16:42:34 +00:00
.l_paren => {
const current_type_node = switch (current_type.type.data) {
.other => |n| n,
else => return null,
};
2020-06-17 13:07:21 +01:00
// Can't call a function type, we need a function type instance.
if (current_type.type.is_type_val) return null;
2021-03-01 13:32:19 +00:00
var buf: [1]ast.Node.Index = undefined;
if (fnProto(tree, current_type_node, &buf)) |func| {
2021-03-03 15:34:24 +00:00
const has_body = tree.nodes.items(.tag)[current_type_node] == .fn_decl;
const body = tree.nodes.items(.data)[current_type_node].rhs;
if (try resolveReturnType(store, arena, func, current_type.handle, &bound_type_params, if (has_body) body else null)) |ret| {
current_type = ret;
// Skip to the right paren
var paren_count: usize = 1;
var next = tokenizer.next();
2021-03-01 13:32:19 +00:00
while (next.tag != .eof) : (next = tokenizer.next()) {
if (next.tag == .r_paren) {
paren_count -= 1;
if (paren_count == 0) break;
2021-03-01 13:32:19 +00:00
} else if (next.tag == .l_paren) {
paren_count += 1;
}
} else return null;
} else return null;
} else return null;
2020-05-24 13:24:18 +01:00
},
2021-02-28 16:42:34 +00:00
.l_bracket => {
2020-05-27 16:49:11 +01:00
var brack_count: usize = 1;
var next = tokenizer.next();
var is_range = false;
2021-03-01 13:32:19 +00:00
while (next.tag != .eof) : (next = tokenizer.next()) {
if (next.tag == .r_bracket) {
2020-05-27 16:49:11 +01:00
brack_count -= 1;
if (brack_count == 0) break;
2021-03-01 13:32:19 +00:00
} else if (next.tag == .l_bracket) {
2020-05-27 16:49:11 +01:00
brack_count += 1;
2021-03-01 13:32:19 +00:00
} else if (next.tag == .ellipsis2 and brack_count == 1) {
2020-05-27 16:49:11 +01:00
is_range = true;
}
} else return null;
current_type = (try resolveBracketAccessType(store, arena, current_type, if (is_range) .Range else .Single, &bound_type_params)) orelse return null;
2020-05-24 03:07:09 +01:00
},
else => {
2021-02-28 16:42:34 +00:00
log.debug("Unimplemented token: {}", .{tok.tag});
return null;
2020-05-27 16:49:11 +01:00
},
2020-05-13 14:03:33 +01:00
}
}
return FieldAccessReturn{
.original = current_type,
.unwrapped = try resolveDerefType(store, arena, current_type, &bound_type_params),
};
2020-05-13 14:03:33 +01:00
}
2021-02-28 16:42:34 +00:00
pub fn isNodePublic(tree: ast.Tree, node: ast.Node.Index) bool {
2021-03-01 15:30:43 +00:00
var buf: [1]ast.Node.Index = undefined;
return switch (tree.nodes.items(.tag)[node]) {
2021-03-03 15:34:24 +00:00
.global_var_decl,
.local_var_decl,
.simple_var_decl,
.aligned_var_decl,
=> varDecl(tree, node).?.visib_token != null,
.fn_proto,
.fn_proto_multi,
.fn_proto_one,
.fn_proto_simple,
.fn_decl,
=> fnProto(tree, node, &buf).?.visib_token != null,
2021-03-01 15:30:43 +00:00
else => true,
};
2020-05-14 17:14:35 +01:00
}
2021-02-28 16:42:34 +00:00
pub fn nodeToString(tree: ast.Tree, node: ast.Node.Index) ?[]const u8 {
2021-03-02 14:32:38 +00:00
const data = tree.nodes.items(.data);
2021-03-02 21:01:13 +00:00
const main_token = tree.nodes.items(.main_token)[node];
2021-03-01 15:30:43 +00:00
var buf: [1]ast.Node.Index = undefined;
2021-02-28 16:42:34 +00:00
switch (tree.nodes.items(.tag)[node]) {
.container_field => return tree.tokenSlice(tree.containerField(node).ast.name_token),
.container_field_init => return tree.tokenSlice(tree.containerFieldInit(node).ast.name_token),
.container_field_align => return tree.tokenSlice(tree.containerFieldAlign(node).ast.name_token),
// @TODO: Error tag name
// .ErrorTag => {
// const tag = node.castTag(.ErrorTag).?;
// return tree.tokenSlice(tag.name_token);
// },
2021-03-03 15:34:24 +00:00
.identifier => return tree.tokenSlice(main_token),
.fn_proto,
.fn_proto_multi,
.fn_proto_one,
.fn_proto_simple,
.fn_decl,
=> if (fnProto(tree, node, &buf).?.name_token) |name|
return tree.tokenSlice(name),
2021-03-02 21:01:13 +00:00
.field_access => return tree.tokenSlice(data[node].rhs),
2021-03-03 16:45:42 +00:00
.call,
.call_comma,
.async_call,
.async_call_comma,
=> return tree.tokenSlice(tree.callFull(node).ast.lparen - 1),
.call_one,
.call_one_comma,
.async_call_one,
.async_call_one_comma,
=> return tree.tokenSlice(tree.callOne(&buf, node).ast.lparen - 1),
2021-03-03 15:34:24 +00:00
else => |tag| log.debug("INVALID: {}", .{tag}),
2020-05-11 13:28:08 +01:00
}
2020-05-16 16:30:16 +01:00
return null;
2020-05-13 14:03:33 +01:00
}
2020-05-16 19:06:48 +01:00
2021-02-28 16:42:34 +00:00
fn nodeContainsSourceIndex(tree: ast.Tree, node: ast.Node.Index, source_index: usize) bool {
const first_token = tree.tokenLocation(0, tree.firstToken(node)).line_start;
const last_token = tree.tokenLocation(@truncate(u32, first_token), tree.lastToken(node)).line_end;
return source_index >= first_token and source_index <= last_token;
}
fn isBuiltinCall(tree: ast.Tree, node: ast.Node.Index) bool {
return switch (tree.nodes.items(.tag)[node]) {
.builtin_call,
.builtin_call_comma,
.builtin_call_two,
.builtin_call_two_comma,
=> true,
else => false,
};
}
2021-03-01 13:32:19 +00:00
pub fn fnProto(tree: ast.Tree, node: ast.Node.Index, buf: *[1]ast.Node.Index) ?ast.full.FnProto {
return switch (tree.nodes.items(.tag)[node]) {
.fn_proto => tree.fnProto(node),
.fn_proto_multi => tree.fnProtoMulti(node),
.fn_proto_one => tree.fnProtoOne(buf, node),
.fn_proto_simple => tree.fnProtoSimple(buf, node),
2021-03-02 14:32:38 +00:00
.fn_decl => fnProto(tree, tree.nodes.items(.data)[node].lhs, buf),
2021-03-01 13:32:19 +00:00
else => null,
};
}
2021-02-28 16:42:34 +00:00
pub fn getImportStr(tree: ast.Tree, node: ast.Node.Index, source_index: usize) ?[]const u8 {
const node_tags = tree.nodes.items(.tag);
var buf: [2]ast.Node.Index = undefined;
2021-03-03 15:34:24 +00:00
const decls = declMembers(tree, node_tags[node], node, &buf);
2021-02-28 16:42:34 +00:00
for (decls) |decl_idx| {
if (!nodeContainsSourceIndex(tree, decl_idx, source_index)) {
continue;
}
2021-02-28 16:42:34 +00:00
if (isBuiltinCall(tree, decl_idx)) {
const builtin_token = tree.nodes.items(.main_token)[decl_idx];
const call_name = tree.tokenSlice(builtin_token);
2021-02-28 16:42:34 +00:00
if (!std.mem.eql(u8, call_name, "@import")) continue;
2021-03-02 14:32:38 +00:00
const data = tree.nodes.items(.data)[decl_idx];
const params = switch (node_tags[decl_idx]) {
.builtin_call, .builtin_call_comma => tree.extra_data[data.lhs..data.rhs],
.builtin_call_two, .builtin_call_two_comma => if (data.lhs == 0)
&[_]ast.Node.Index{}
else if (data.rhs == 0)
&[_]ast.Node.Index{data.lhs}
else
&[_]ast.Node.Index{ data.lhs, data.rhs },
else => unreachable,
};
2021-02-28 16:42:34 +00:00
if (params.len != 1) continue;
2021-03-02 14:32:38 +00:00
const import_str = tree.tokenSlice(tree.nodes.items(.main_token)[params[0]]);
return import_str[1 .. import_str.len - 1];
}
2021-02-28 16:42:34 +00:00
if (getImportStr(tree, decl_idx, source_index)) |name| {
return name;
}
}
2021-02-28 16:42:34 +00:00
return null;
}
pub const SourceRange = std.zig.Token.Loc;
2020-05-27 19:58:35 +01:00
pub const PositionContext = union(enum) {
builtin: SourceRange,
comment,
string_literal: SourceRange,
field_access: SourceRange,
var_access: SourceRange,
2020-05-16 17:04:07 +01:00
global_error_set,
enum_literal,
pre_label,
2020-06-18 13:12:09 +01:00
label: bool,
other,
empty,
2020-05-27 19:58:35 +01:00
pub fn range(self: PositionContext) ?SourceRange {
return switch (self) {
.builtin => |r| r,
.comment => null,
.string_literal => |r| r,
.field_access => |r| r,
.var_access => |r| r,
.enum_literal => null,
.pre_label => null,
2020-06-14 20:24:18 +01:00
.label => null,
.other => null,
.empty => null,
2020-05-16 17:04:07 +01:00
.global_error_set => null,
};
}
};
const StackState = struct {
ctx: PositionContext,
stack_id: enum { Paren, Bracket, Global },
};
fn peek(arr: *std.ArrayList(StackState)) !*StackState {
if (arr.items.len == 0) {
try arr.append(.{ .ctx = .empty, .stack_id = .Global });
}
return &arr.items[arr.items.len - 1];
}
fn tokenRangeAppend(prev: SourceRange, token: std.zig.Token) SourceRange {
return .{
.start = prev.start,
.end = token.loc.end,
};
}
2020-07-03 00:31:28 +01:00
const DocumentPosition = @import("offsets.zig").DocumentPosition;
pub fn documentPositionContext(arena: *std.heap.ArenaAllocator, document: types.TextDocument, doc_position: DocumentPosition) !PositionContext {
const line = doc_position.line;
var tokenizer = std.zig.Tokenizer.init(line[0..doc_position.line_index]);
var stack = try std.ArrayList(StackState).initCapacity(&arena.allocator, 8);
while (true) {
const tok = tokenizer.next();
// Early exits.
switch (tok.tag) {
.invalid, .invalid_ampersands => {
// Single '@' do not return a builtin token so we check this on our own.
2020-07-03 00:31:28 +01:00
if (line[doc_position.line_index - 1] == '@') {
return PositionContext{
.builtin = .{
2020-07-03 00:31:28 +01:00
.start = doc_position.line_index - 1,
.end = doc_position.line_index,
},
};
}
return .other;
},
2021-02-28 16:42:34 +00:00
.doc_comment, .container_doc_comment => return .comment,
.eof => break,
else => {},
}
// State changes
var curr_ctx = try peek(&stack);
switch (tok.tag) {
.string_literal, .multiline_string_literal_line => curr_ctx.ctx = .{ .string_literal = tok.loc },
.identifier => switch (curr_ctx.ctx) {
.empty, .pre_label => curr_ctx.ctx = .{ .var_access = tok.loc },
2020-06-18 13:12:09 +01:00
.label => |filled| if (!filled) {
curr_ctx.ctx = .{ .label = true };
} else {
curr_ctx.ctx = .{ .var_access = tok.loc };
},
else => {},
},
.builtin => switch (curr_ctx.ctx) {
.empty, .pre_label => curr_ctx.ctx = .{ .builtin = tok.loc },
else => {},
},
.period, .period_asterisk => switch (curr_ctx.ctx) {
.empty, .pre_label => curr_ctx.ctx = .enum_literal,
.enum_literal => curr_ctx.ctx = .empty,
.field_access => {},
.other => {},
2020-05-16 17:04:07 +01:00
.global_error_set => {},
else => curr_ctx.ctx = .{
.field_access = tokenRangeAppend(curr_ctx.ctx.range().?, tok),
},
},
.keyword_break, .keyword_continue => curr_ctx.ctx = .pre_label,
.colon => if (curr_ctx.ctx == .pre_label) {
2020-06-18 13:12:09 +01:00
curr_ctx.ctx = .{ .label = false };
2020-06-17 13:07:21 +01:00
} else {
curr_ctx.ctx = .empty;
2020-06-16 13:49:57 +01:00
},
.question_mark => switch (curr_ctx.ctx) {
.field_access => {},
else => curr_ctx.ctx = .empty,
},
.l_paren => try stack.append(.{ .ctx = .empty, .stack_id = .Paren }),
.l_bracket => try stack.append(.{ .ctx = .empty, .stack_id = .Bracket }),
.r_paren => {
_ = stack.pop();
if (curr_ctx.stack_id != .Paren) {
(try peek(&stack)).ctx = .empty;
}
},
.r_bracket => {
_ = stack.pop();
if (curr_ctx.stack_id != .Bracket) {
(try peek(&stack)).ctx = .empty;
}
},
.keyword_error => curr_ctx.ctx = .global_error_set,
else => curr_ctx.ctx = .empty,
}
switch (curr_ctx.ctx) {
.field_access => |r| curr_ctx.ctx = .{
.field_access = tokenRangeAppend(r, tok),
},
else => {},
}
}
return block: {
if (stack.popOrNull()) |state| break :block state.ctx;
break :block .empty;
};
}
fn addOutlineNodes(allocator: *std.mem.Allocator, tree: ast.Tree, child: ast.Node.Index, context: *GetDocumentSymbolsContext) anyerror!void {
switch (tree.nodes.items(.tag)[child]) {
.string_literal,
.integer_literal,
.builtin_call,
.builtin_call_comma,
.builtin_call_two,
.builtin_call_two_comma,
.call,
.call_comma,
.call_one,
.call_one_comma,
.async_call,
.async_call_comma,
.async_call_one,
.async_call_one_comma,
.identifier,
.add,
.add_wrap,
.array_cat,
.array_mult,
.assign,
.assign_bit_and,
.assign_bit_or,
.assign_bit_shift_left,
.assign_bit_shift_right,
.assign_bit_xor,
.assign_div,
.assign_sub,
.assign_sub_wrap,
.assign_mod,
.assign_add,
.assign_add_wrap,
.assign_mul,
.assign_mul_wrap,
.bang_equal,
.bit_and,
.bit_or,
.bit_shift_left,
.bit_shift_right,
.bit_xor,
.bool_and,
.bool_or,
.div,
.equal_equal,
.error_union,
.greater_or_equal,
.greater_than,
.less_or_equal,
.less_than,
.merge_error_sets,
.mod,
.mul,
.mul_wrap,
.field_access,
.switch_range,
.sub,
.sub_wrap,
.@"orelse",
.address_of,
.@"await",
.bit_not,
.bool_not,
.optional_type,
.negation,
.negation_wrap,
.@"resume",
.@"try",
.array_type,
.array_type_sentinel,
.ptr_type,
.ptr_type_aligned,
.ptr_type_bit_range,
.ptr_type_sentinel,
.slice_open,
.slice_sentinel,
.deref,
.unwrap_optional,
.array_access,
.@"return",
.@"break",
.@"continue",
.array_init,
.array_init_comma,
.array_init_dot,
.array_init_dot_comma,
.array_init_dot_two,
.array_init_dot_two_comma,
.array_init_one,
.array_init_one_comma,
.@"switch",
.switch_comma,
.switch_case,
.switch_case_one,
.@"for",
.for_simple,
.enum_literal,
.struct_init,
.struct_init_comma,
.struct_init_dot,
.struct_init_dot_comma,
.struct_init_dot_two,
.struct_init_dot_two_comma,
.struct_init_one,
.struct_init_one_comma,
.@"while",
.while_simple,
.while_cont,
.true_literal,
.false_literal,
.null_literal,
.@"defer",
.@"if",
.if_simple,
.multiline_string_literal,
.undefined_literal,
.@"anytype",
.block,
.block_semicolon,
.block_two,
.block_two_semicolon,
.error_set_decl,
2020-07-24 08:33:13 +01:00
=> return,
.container_decl,
.container_decl_arg,
.container_decl_arg_trailing,
.container_decl_two,
.container_decl_two_trailing,
.tagged_union,
.tagged_union_trailing,
.tagged_union_enum_tag,
.tagged_union_enum_tag_trailing,
.tagged_union_two,
.tagged_union_two_trailing,
=> {
var buf: [2]ast.Node.Index = undefined;
for (declMembers(tree, tree.nodes.items(.tag)[child], child, &buf)) |member|
try addOutlineNodes(allocator, tree, member, context);
return;
},
else => |t| {},
}
2020-07-07 09:57:02 +01:00
try getDocumentSymbolsInternal(allocator, tree, child, context);
}
2020-07-07 09:57:02 +01:00
const GetDocumentSymbolsContext = struct {
prev_loc: offsets.TokenLocation = .{
.line = 0,
.column = 0,
.offset = 0,
},
symbols: *std.ArrayList(types.DocumentSymbol),
encoding: offsets.Encoding,
};
fn getDocumentSymbolsInternal(allocator: *std.mem.Allocator, tree: ast.Tree, node: ast.Node.Index, context: *GetDocumentSymbolsContext) anyerror!void {
2020-07-24 11:04:01 +01:00
const name = getDeclName(tree, node) orelse return;
2020-07-07 09:57:02 +01:00
if (name.len == 0)
return;
const start_loc = context.prev_loc.add(try offsets.tokenRelativeLocation(tree, context.prev_loc.offset, tree.firstToken(node), context.encoding));
const end_loc = start_loc.add(try offsets.tokenRelativeLocation(tree, start_loc.offset, tree.lastToken(node), context.encoding));
2020-07-07 09:57:02 +01:00
context.prev_loc = end_loc;
const range = types.Range{
.start = .{
.line = @intCast(i64, start_loc.line),
.character = @intCast(i64, start_loc.column),
},
.end = .{
.line = @intCast(i64, end_loc.line),
.character = @intCast(i64, end_loc.column),
2020-05-28 16:18:48 +01:00
},
};
const tags = tree.nodes.items(.tag);
2020-07-07 09:57:02 +01:00
(try context.symbols.addOne()).* = .{
.name = name,
.kind = switch (tags[node]) {
.fn_proto,
.fn_proto_simple,
.fn_proto_multi,
.fn_proto_one,
.fn_decl,
=> .Function,
.local_var_decl,
.global_var_decl,
.aligned_var_decl,
.simple_var_decl,
=> .Variable,
.container_field,
.container_field_align,
.container_field_init,
2021-02-27 20:55:39 +00:00
.tagged_union_enum_tag,
.tagged_union_enum_tag_trailing,
.tagged_union,
.tagged_union_trailing,
.tagged_union_two,
.tagged_union_two_trailing,
=> .Field,
2020-05-28 16:18:48 +01:00
else => .Variable,
},
.range = range,
.selectionRange = range,
2020-07-07 09:57:02 +01:00
.detail = "",
.children = ch: {
var children = std.ArrayList(types.DocumentSymbol).init(allocator);
2020-07-07 09:57:02 +01:00
var child_context = GetDocumentSymbolsContext{
.prev_loc = start_loc,
.symbols = &children,
.encoding = context.encoding,
};
if (isContainer(tags[node])) {
var buf: [2]ast.Node.Index = undefined;
for (declMembers(tree, tags[node], node, &buf)) |child|
try addOutlineNodes(allocator, tree, child, &child_context);
}
if (varDecl(tree, node)) |var_decl| {
if (var_decl.ast.init_node != 0)
try addOutlineNodes(allocator, tree, var_decl.ast.init_node, &child_context);
}
break :ch children.items;
},
};
}
pub fn getDocumentSymbols(allocator: *std.mem.Allocator, tree: ast.Tree, encoding: offsets.Encoding) ![]types.DocumentSymbol {
var symbols = try std.ArrayList(types.DocumentSymbol).initCapacity(allocator, tree.rootDecls().len);
2020-07-07 09:57:02 +01:00
var context = GetDocumentSymbolsContext{
2020-07-07 09:57:02 +01:00
.symbols = &symbols,
.encoding = encoding,
};
for (tree.rootDecls()) |idx| {
try getDocumentSymbolsInternal(allocator, tree, idx, &context);
}
return symbols.items;
}
2020-06-10 14:12:00 +01:00
pub const Declaration = union(enum) {
2021-02-27 15:38:06 +00:00
/// Index of the ast node
ast_node: ast.Node.Index,
/// Function parameter
param_decl: ast.full.FnProto.Param,
2020-06-10 14:12:00 +01:00
pointer_payload: struct {
2021-02-27 20:55:39 +00:00
name: ast.TokenIndex,
condition: ast.Node.Index,
2020-06-10 14:12:00 +01:00
},
2021-02-28 20:57:15 +00:00
// array_payload: struct {
// identifier: *ast.Node,
// array_expr: ast.full.ArrayType,
// },
2020-06-10 14:12:00 +01:00
switch_payload: struct {
2021-02-28 12:09:10 +00:00
node: ast.TokenIndex,
switch_expr: ast.Node.Index,
items: []const ast.Node.Index,
2020-06-10 14:12:00 +01:00
},
2021-02-27 20:55:39 +00:00
label_decl: ast.TokenIndex, // .id is While, For or Block (firstToken will be the label)
2020-06-10 14:12:00 +01:00
};
pub const DeclWithHandle = struct {
decl: *Declaration,
handle: *DocumentStore.Handle,
2020-06-27 13:29:45 +01:00
pub fn nameToken(self: DeclWithHandle) ast.TokenIndex {
const tree = self.handle.tree;
2021-03-01 13:32:19 +00:00
const token_tags = tree.tokens.items(.tag);
return switch (self.decl.*) {
2020-06-27 13:29:45 +01:00
.ast_node => |n| getDeclNameToken(tree, n).?,
.param_decl => |p| p.name_token.?,
2021-03-01 13:32:19 +00:00
.pointer_payload => |pp| pp.name,
2021-02-28 20:57:15 +00:00
// .array_payload => |ap| ap.identifier.firstToken(),
2021-03-01 13:32:19 +00:00
.switch_payload => |sp| sp.node + @boolToInt(token_tags[sp.node] == .asterisk),
.label_decl => |ld| ld,
};
}
2020-06-10 17:54:01 +01:00
2020-07-07 09:57:02 +01:00
pub fn location(self: DeclWithHandle, encoding: offsets.Encoding) !offsets.TokenLocation {
2020-06-27 13:29:45 +01:00
const tree = self.handle.tree;
2020-07-07 09:57:02 +01:00
return try offsets.tokenRelativeLocation(tree, 0, self.nameToken(), encoding);
2020-06-27 13:29:45 +01:00
}
2020-06-11 00:40:11 +01:00
fn isPublic(self: DeclWithHandle) bool {
return switch (self.decl.*) {
.ast_node => |node| isNodePublic(self.handle.tree, node),
else => true,
};
}
pub fn resolveType(self: DeclWithHandle, store: *DocumentStore, arena: *std.heap.ArenaAllocator, bound_type_params: *BoundTypeParams) !?TypeWithHandle {
2021-02-28 20:57:15 +00:00
const tree = self.handle.tree;
const node_tags = tree.nodes.items(.tag);
const main_tokens = tree.nodes.items(.main_token);
2021-03-02 21:01:13 +00:00
2020-06-10 18:48:40 +01:00
return switch (self.decl.*) {
2020-06-12 12:56:46 +01:00
.ast_node => |node| try resolveTypeOfNodeInternal(store, arena, .{ .node = node, .handle = self.handle }, bound_type_params),
2021-03-03 15:34:24 +00:00
.param_decl => |param_decl| {
2021-02-28 20:57:15 +00:00
if (typeIsType(self.handle.tree, param_decl.type_expr)) {
var bound_param_it = bound_type_params.iterator();
while (bound_param_it.next()) |entry| {
2021-03-03 15:34:24 +00:00
if (std.meta.eql(entry.key, param_decl)) return entry.value;
2020-06-12 12:56:46 +01:00
}
2021-02-28 20:57:15 +00:00
return null;
} else if (node_tags[param_decl.type_expr] == .identifier) {
if (param_decl.name_token) |name_tok| {
2021-03-03 15:34:24 +00:00
if (std.mem.eql(u8, tree.tokenSlice(main_tokens[param_decl.type_expr]), tree.tokenSlice(name_tok)))
2021-02-28 20:57:15 +00:00
return null;
}
}
return ((try resolveTypeOfNodeInternal(
store,
arena,
.{ .node = param_decl.type_expr, .handle = self.handle },
bound_type_params,
)) orelse return null).instanceTypeVal();
2020-06-10 17:54:01 +01:00
},
.pointer_payload => |pay| try resolveUnwrapOptionalType(
store,
2020-06-10 18:48:40 +01:00
arena,
2020-06-12 12:56:46 +01:00
(try resolveTypeOfNodeInternal(store, arena, .{
2020-06-10 17:54:01 +01:00
.node = pay.condition,
.handle = self.handle,
2020-06-12 12:56:46 +01:00
}, bound_type_params)) orelse return null,
bound_type_params,
2020-06-10 17:54:01 +01:00
),
2021-02-28 20:57:15 +00:00
// .array_payload => |pay| try resolveBracketAccessType(
// store,
// arena,
// (try resolveTypeOfNodeInternal(store, arena, .{
// .node = pay.array_expr,
// .handle = self.handle,
// }, bound_type_params)) orelse return null,
// .Single,
// bound_type_params,
// ),
2020-06-14 20:24:18 +01:00
.label_decl => return null,
2020-06-23 11:32:37 +01:00
.switch_payload => |pay| {
if (pay.items.len == 0) return null;
// TODO Peer type resolution, we just use the first item for now.
const switch_expr_type = (try resolveTypeOfNodeInternal(store, arena, .{
.node = pay.switch_expr,
.handle = self.handle,
}, bound_type_params)) orelse return null;
2021-02-28 20:57:15 +00:00
if (!switch_expr_type.isUnionType(tree))
2020-06-23 11:32:37 +01:00
return null;
2021-02-28 20:57:15 +00:00
if (node_tags[pay.items[0]] == .enum_literal) {
2020-06-23 11:32:37 +01:00
const scope = findContainerScope(.{ .node = switch_expr_type.type.data.other, .handle = switch_expr_type.handle }) orelse return null;
2021-03-03 15:34:24 +00:00
if (scope.decls.getEntry(tree.tokenSlice(main_tokens[pay.items[0]]))) |candidate| {
2020-06-23 11:32:37 +01:00
switch (candidate.value) {
.ast_node => |node| {
2021-02-28 20:57:15 +00:00
if (containerField(tree, node)) |container_field| {
if (container_field.ast.type_expr != 0) {
2020-06-23 11:32:37 +01:00
return ((try resolveTypeOfNodeInternal(
store,
arena,
2021-02-28 20:57:15 +00:00
.{ .node = container_field.ast.type_expr, .handle = switch_expr_type.handle },
2020-06-23 11:32:37 +01:00
bound_type_params,
)) orelse return null).instanceTypeVal();
}
}
},
else => {},
}
return null;
}
}
return null;
},
2020-06-10 17:54:01 +01:00
};
}
};
2021-03-01 15:02:24 +00:00
pub fn containerField(tree: ast.Tree, node: ast.Node.Index) ?ast.full.ContainerField {
2021-02-28 20:57:15 +00:00
return switch (tree.nodes.items(.tag)[node]) {
.container_field => tree.containerField(node),
.container_field_init => tree.containerFieldInit(node),
.container_field_align => tree.containerFieldAlign(node),
else => null,
};
}
2021-03-01 15:02:24 +00:00
pub fn ptrType(tree: ast.Tree, node: ast.Node.Index) ?ast.full.PtrType {
return switch (tree.nodes.items(.tag)[node]) {
.ptr_type => tree.ptrType(node),
.ptr_type_aligned => tree.ptrTypeAligned(node),
.ptr_type_bit_range => tree.ptrTypeBitRange(node),
.ptr_type_sentinel => tree.ptrTypeSentinel(node),
else => null,
};
}
2020-06-11 00:40:11 +01:00
fn findContainerScope(container_handle: NodeWithHandle) ?*Scope {
const container = container_handle.node;
const handle = container_handle.handle;
2021-03-01 13:32:19 +00:00
if (!isContainer(handle.tree.nodes.items(.tag)[container])) return null;
2020-06-11 00:40:11 +01:00
// Find the container scope.
2021-03-01 13:32:19 +00:00
return for (handle.document_scope.scopes) |*scope| {
2021-03-02 21:01:13 +00:00
switch (scope.data) {
2020-06-11 00:40:11 +01:00
.container => |node| if (node == container) {
2021-03-02 21:01:13 +00:00
break scope;
2020-06-11 00:40:11 +01:00
},
else => {},
}
2021-03-01 13:32:19 +00:00
} else null;
2020-06-11 00:40:11 +01:00
}
fn iterateSymbolsContainerInternal(
2020-06-11 00:40:11 +01:00
store: *DocumentStore,
arena: *std.heap.ArenaAllocator,
container_handle: NodeWithHandle,
orig_handle: *DocumentStore.Handle,
2020-07-12 20:12:09 +01:00
comptime callback: anytype,
context: anytype,
2020-06-18 13:43:03 +01:00
instance_access: bool,
2021-03-01 15:30:43 +00:00
use_trail: *std.ArrayList(ast.Node.Index),
2020-06-11 00:40:11 +01:00
) error{OutOfMemory}!void {
const container = container_handle.node;
const handle = container_handle.handle;
2021-03-01 15:30:43 +00:00
const tree = handle.tree;
const node_tags = tree.nodes.items(.tag);
const token_tags = tree.tokens.items(.tag);
const main_token = tree.nodes.items(.main_token)[container];
2021-03-03 15:34:24 +00:00
const is_enum = if (isContainer(node_tags[container]) and node_tags[container] != .root)
2021-03-01 15:30:43 +00:00
token_tags[main_token] == .keyword_enum
2020-06-18 13:43:03 +01:00
else
false;
2020-06-11 00:40:11 +01:00
if (findContainerScope(container_handle)) |container_scope| {
var decl_it = container_scope.decls.iterator();
while (decl_it.next()) |entry| {
2020-06-18 13:43:03 +01:00
switch (entry.value) {
.ast_node => |node| {
2021-03-01 15:30:43 +00:00
if (node_tags[node].isContainerField()) {
2020-06-18 13:43:03 +01:00
if (!instance_access and !is_enum) continue;
if (instance_access and is_enum) continue;
}
},
.label_decl => continue,
else => {},
}
2020-06-11 00:40:11 +01:00
const decl = DeclWithHandle{ .decl = &entry.value, .handle = handle };
if (handle != orig_handle and !decl.isPublic()) continue;
try callback(context, decl);
}
// for (container_scope.uses) |use| {
// if (handle != orig_handle and use.visib_token == null) continue;
// if (std.mem.indexOfScalar(*ast.Node.Use, use_trail.items, use) != null) continue;
// try use_trail.append(use);
// const use_expr = (try resolveTypeOfNode(store, arena, .{ .node = use.expr, .handle = handle })) orelse continue;
// const use_expr_node = switch (use_expr.type.data) {
// .other => |n| n,
// else => continue,
// };
// try iterateSymbolsContainerInternal(store, arena, .{ .node = use_expr_node, .handle = use_expr.handle }, orig_handle, callback, context, false, use_trail);
// }
2020-06-11 00:40:11 +01:00
}
}
2020-06-11 00:40:11 +01:00
pub fn iterateSymbolsContainer(
store: *DocumentStore,
arena: *std.heap.ArenaAllocator,
container_handle: NodeWithHandle,
orig_handle: *DocumentStore.Handle,
2020-07-12 20:12:09 +01:00
comptime callback: anytype,
context: anytype,
instance_access: bool,
) error{OutOfMemory}!void {
2021-03-01 15:30:43 +00:00
var use_trail = std.ArrayList(ast.Node.Index).init(&arena.allocator);
return try iterateSymbolsContainerInternal(store, arena, container_handle, orig_handle, callback, context, instance_access, &use_trail);
2020-06-11 00:40:11 +01:00
}
2020-06-14 20:24:18 +01:00
pub fn iterateLabels(
handle: *DocumentStore.Handle,
source_index: usize,
2020-07-12 20:12:09 +01:00
comptime callback: anytype,
context: anytype,
2020-06-14 20:24:18 +01:00
) error{OutOfMemory}!void {
for (handle.document_scope.scopes) |scope| {
if (source_index >= scope.range.start and source_index < scope.range.end) {
var decl_it = scope.decls.iterator();
while (decl_it.next()) |entry| {
switch (entry.value) {
.label_decl => {},
else => continue,
}
try callback(context, DeclWithHandle{ .decl = &entry.value, .handle = handle });
}
}
if (scope.range.start >= source_index) return;
}
}
fn iterateSymbolsGlobalInternal(
store: *DocumentStore,
2020-06-11 00:40:11 +01:00
arena: *std.heap.ArenaAllocator,
handle: *DocumentStore.Handle,
source_index: usize,
2020-07-12 20:12:09 +01:00
comptime callback: anytype,
context: anytype,
2021-03-01 13:32:19 +00:00
use_trail: *std.ArrayList(ast.Node.Index),
2020-06-11 00:40:11 +01:00
) error{OutOfMemory}!void {
for (handle.document_scope.scopes) |scope| {
if (source_index >= scope.range.start and source_index < scope.range.end) {
var decl_it = scope.decls.iterator();
while (decl_it.next()) |entry| {
2021-03-01 15:30:43 +00:00
if (entry.value == .ast_node and handle.tree.nodes.items(.tag)[entry.value.ast_node].isContainerField()) continue;
2020-06-14 20:24:18 +01:00
if (entry.value == .label_decl) continue;
try callback(context, DeclWithHandle{ .decl = &entry.value, .handle = handle });
}
2020-06-10 14:12:00 +01:00
// for (scope.uses) |use| {
// if (std.mem.indexOfScalar(*ast.Node.Use, use_trail.items, use) != null) continue;
// try use_trail.append(use);
// const use_expr = (try resolveTypeOfNode(store, arena, .{ .node = use.expr, .handle = handle })) orelse continue;
// const use_expr_node = switch (use_expr.type.data) {
// .other => |n| n,
// else => continue,
// };
// try iterateSymbolsContainerInternal(store, arena, .{ .node = use_expr_node, .handle = use_expr.handle }, handle, callback, context, false, use_trail);
// }
}
2020-06-10 14:12:00 +01:00
if (scope.range.start >= source_index) return;
}
}
pub fn iterateSymbolsGlobal(
store: *DocumentStore,
arena: *std.heap.ArenaAllocator,
handle: *DocumentStore.Handle,
source_index: usize,
2020-07-12 20:12:09 +01:00
comptime callback: anytype,
context: anytype,
) error{OutOfMemory}!void {
2021-03-01 13:32:19 +00:00
var use_trail = std.ArrayList(ast.Node.Index).init(&arena.allocator);
return try iterateSymbolsGlobalInternal(store, arena, handle, source_index, callback, context, &use_trail);
}
pub fn innermostContainer(handle: *DocumentStore.Handle, source_index: usize) TypeWithHandle {
2020-06-10 19:24:17 +01:00
var current = handle.document_scope.scopes[0].data.container;
if (handle.document_scope.scopes.len == 1) return TypeWithHandle.typeVal(.{ .node = current, .handle = handle });
2020-06-10 19:24:17 +01:00
for (handle.document_scope.scopes[1..]) |scope| {
if (source_index >= scope.range.start and source_index < scope.range.end) {
switch (scope.data) {
.container => |node| current = node,
else => {},
}
}
if (scope.range.start > source_index) break;
}
return TypeWithHandle.typeVal(.{ .node = current, .handle = handle });
2020-06-10 19:24:17 +01:00
}
2020-06-11 00:40:11 +01:00
fn resolveUse(
store: *DocumentStore,
arena: *std.heap.ArenaAllocator,
// uses: []const *ast.Node.Use,
2020-06-11 00:40:11 +01:00
symbol: []const u8,
handle: *DocumentStore.Handle,
use_trail: *std.ArrayList(*ast.Node.Use),
2020-06-11 00:40:11 +01:00
) error{OutOfMemory}!?DeclWithHandle {
// for (uses) |use| {
// if (std.mem.indexOfScalar(*ast.Node.Use, use_trail.items, use) != null) continue;
// try use_trail.append(use);
// const use_expr = (try resolveTypeOfNode(store, arena, .{ .node = use.expr, .handle = handle })) orelse continue;
// const use_expr_node = switch (use_expr.type.data) {
// .other => |n| n,
// else => continue,
// };
// if (try lookupSymbolContainerInternal(store, arena, .{ .node = use_expr_node, .handle = use_expr.handle }, symbol, false, use_trail)) |candidate| {
// if (candidate.handle != handle and !candidate.isPublic()) {
// continue;
// }
// return candidate;
// }
// }
2020-06-11 00:40:11 +01:00
return null;
}
2020-06-14 20:24:18 +01:00
pub fn lookupLabel(
handle: *DocumentStore.Handle,
symbol: []const u8,
source_index: usize,
) error{OutOfMemory}!?DeclWithHandle {
for (handle.document_scope.scopes) |scope| {
if (source_index >= scope.range.start and source_index < scope.range.end) {
2020-07-05 22:56:41 +01:00
if (scope.decls.getEntry(symbol)) |candidate| {
2020-06-14 20:24:18 +01:00
switch (candidate.value) {
.label_decl => {},
else => continue,
}
return DeclWithHandle{
.decl = &candidate.value,
.handle = handle,
};
}
}
if (scope.range.start > source_index) return null;
}
return null;
}
fn lookupSymbolGlobalInternal(
2020-06-11 00:40:11 +01:00
store: *DocumentStore,
arena: *std.heap.ArenaAllocator,
handle: *DocumentStore.Handle,
symbol: []const u8,
source_index: usize,
2021-03-01 13:32:19 +00:00
use_trail: *std.ArrayList(ast.Node.Index),
2020-06-11 00:40:11 +01:00
) error{OutOfMemory}!?DeclWithHandle {
2021-03-03 15:34:24 +00:00
for (handle.document_scope.scopes) |scope| {
2021-03-02 21:01:13 +00:00
// @TODO: Fix scope positions
2021-03-03 15:34:24 +00:00
if (source_index >= scope.range.start and source_index < scope.range.end) {
if (scope.decls.getEntry(symbol)) |candidate| {
switch (candidate.value) {
.ast_node => |node| {
if (handle.tree.nodes.items(.tag)[node].isContainerField()) continue;
},
.label_decl => continue,
else => {},
}
return DeclWithHandle{
.decl = &candidate.value,
.handle = handle,
};
}
2021-03-03 15:34:24 +00:00
// if (try resolveUse(store, arena, scope.uses, symbol, handle, use_trail)) |result| return result;
}
2021-03-02 14:32:38 +00:00
2020-06-10 19:24:17 +01:00
if (scope.range.start > source_index) return null;
}
return null;
}
pub fn lookupSymbolGlobal(
store: *DocumentStore,
arena: *std.heap.ArenaAllocator,
handle: *DocumentStore.Handle,
symbol: []const u8,
source_index: usize,
) error{OutOfMemory}!?DeclWithHandle {
2021-03-01 13:32:19 +00:00
var use_trail = std.ArrayList(ast.Node.Index).init(&arena.allocator);
return try lookupSymbolGlobalInternal(store, arena, handle, symbol, source_index, &use_trail);
}
fn lookupSymbolContainerInternal(
2020-06-11 00:40:11 +01:00
store: *DocumentStore,
arena: *std.heap.ArenaAllocator,
container_handle: NodeWithHandle,
symbol: []const u8,
2020-06-18 13:43:03 +01:00
/// If true, we are looking up the symbol like we are accessing through a field access
/// of an instance of the type, otherwise as a field access of the type value itself.
instance_access: bool,
2021-03-01 13:32:19 +00:00
use_trail: *std.ArrayList(ast.Node.Index),
2020-06-11 00:40:11 +01:00
) error{OutOfMemory}!?DeclWithHandle {
2020-06-10 17:54:01 +01:00
const container = container_handle.node;
const handle = container_handle.handle;
2021-03-01 15:30:43 +00:00
const tree = handle.tree;
const node_tags = tree.nodes.items(.tag);
const token_tags = tree.tokens.items(.tag);
const main_token = tree.nodes.items(.main_token)[container];
2020-06-10 23:00:13 +01:00
2021-03-03 15:34:24 +00:00
const is_enum = if (isContainer(node_tags[container]) and node_tags[container] != .root)
2021-03-01 15:30:43 +00:00
token_tags[main_token] == .keyword_enum
2020-06-18 13:43:03 +01:00
else
false;
2020-06-11 00:40:11 +01:00
if (findContainerScope(container_handle)) |container_scope| {
2020-07-05 22:56:41 +01:00
if (container_scope.decls.getEntry(symbol)) |candidate| {
switch (candidate.value) {
.ast_node => |node| {
2021-03-01 15:30:43 +00:00
if (node_tags[node].isContainerField()) {
2020-06-18 13:43:03 +01:00
if (!instance_access and !is_enum) return null;
if (instance_access and is_enum) return null;
}
},
2020-06-14 20:24:18 +01:00
.label_decl => unreachable,
else => {},
}
2020-06-10 18:48:40 +01:00
return DeclWithHandle{ .decl = &candidate.value, .handle = handle };
}
// if (try resolveUse(store, arena, container_scope.uses, symbol, handle, use_trail)) |result| return result;
return null;
}
2020-06-10 23:00:13 +01:00
return null;
}
pub fn lookupSymbolContainer(
store: *DocumentStore,
arena: *std.heap.ArenaAllocator,
container_handle: NodeWithHandle,
symbol: []const u8,
/// If true, we are looking up the symbol like we are accessing through a field access
/// of an instance of the type, otherwise as a field access of the type value itself.
instance_access: bool,
) error{OutOfMemory}!?DeclWithHandle {
2021-03-01 13:32:19 +00:00
var use_trail = std.ArrayList(ast.Node.Index).init(&arena.allocator);
return try lookupSymbolContainerInternal(store, arena, container_handle, symbol, instance_access, &use_trail);
}
pub const DocumentScope = struct {
2020-06-10 18:48:40 +01:00
scopes: []Scope,
2020-07-08 02:05:44 +01:00
error_completions: []types.CompletionItem,
enum_completions: []types.CompletionItem,
2020-06-10 14:12:00 +01:00
pub fn debugPrint(self: DocumentScope) void {
for (self.scopes) |scope| {
2020-08-14 11:41:34 +01:00
log.debug(
2020-06-10 14:12:00 +01:00
\\--------------------------
\\Scope {}, range: [{}, {})
\\ {} usingnamespaces
\\Decls:
, .{
scope.data,
scope.range.start,
scope.range.end,
{},
// scope.uses.len,
2020-06-10 14:12:00 +01:00
});
var decl_it = scope.decls.iterator();
var idx: usize = 0;
while (decl_it.next()) |name_decl| : (idx += 1) {
2020-08-14 11:41:34 +01:00
if (idx != 0) log.debug(", ", .{});
2020-06-10 14:12:00 +01:00
}
2021-01-10 07:12:11 +00:00
log.debug("{s}", .{name_decl.key});
2020-08-14 11:41:34 +01:00
log.debug("\n--------------------------\n", .{});
2020-06-10 14:12:00 +01:00
}
}
pub fn deinit(self: DocumentScope, allocator: *std.mem.Allocator) void {
2020-07-05 22:56:41 +01:00
for (self.scopes) |*scope| {
2020-06-10 14:12:00 +01:00
scope.decls.deinit();
// allocator.free(scope.uses);
2020-06-16 22:26:45 +01:00
allocator.free(scope.tests);
2020-06-10 14:12:00 +01:00
}
allocator.free(self.scopes);
2020-07-08 02:05:44 +01:00
for (self.error_completions) |item| if (item.documentation) |doc| allocator.free(doc.value);
allocator.free(self.error_completions);
for (self.enum_completions) |item| if (item.documentation) |doc| allocator.free(doc.value);
allocator.free(self.enum_completions);
2020-06-10 14:12:00 +01:00
}
};
pub const Scope = struct {
pub const Data = union(enum) {
2021-02-27 15:38:06 +00:00
container: ast.Node.Index, // .tag is ContainerDecl or Root or ErrorSetDecl
function: ast.Node.Index, // .tag is FnProto
block: ast.Node.Index, // .tag is Block
2020-06-10 14:12:00 +01:00
other,
};
range: SourceRange,
decls: std.StringHashMap(Declaration),
2021-02-27 15:38:06 +00:00
tests: []const ast.Node.Index,
// uses: []const *ast.Node.Data,
2020-06-10 14:12:00 +01:00
data: Data,
};
pub fn makeDocumentScope(allocator: *std.mem.Allocator, tree: ast.Tree) !DocumentScope {
2020-07-08 02:05:44 +01:00
var scopes = std.ArrayListUnmanaged(Scope){};
var error_completions = std.ArrayListUnmanaged(types.CompletionItem){};
var enum_completions = std.ArrayListUnmanaged(types.CompletionItem){};
errdefer {
scopes.deinit(allocator);
for (error_completions.items) |item| if (item.documentation) |doc| allocator.free(doc.value);
error_completions.deinit(allocator);
for (enum_completions.items) |item| if (item.documentation) |doc| allocator.free(doc.value);
enum_completions.deinit(allocator);
}
2021-02-27 15:38:06 +00:00
// pass root node index ('0')
try makeScopeInternal(allocator, &scopes, &error_completions, &enum_completions, tree, 0);
2020-06-10 14:12:00 +01:00
return DocumentScope{
2020-07-08 02:05:44 +01:00
.scopes = scopes.toOwnedSlice(allocator),
.error_completions = error_completions.toOwnedSlice(allocator),
.enum_completions = enum_completions.toOwnedSlice(allocator),
2020-06-10 14:12:00 +01:00
};
}
fn nodeSourceRange(tree: ast.Tree, node: ast.Node.Index) SourceRange {
2021-03-03 15:34:24 +00:00
const loc_start = tree.tokenLocation(0, tree.firstToken(node));
const loc_end = tree.tokenLocation(@truncate(u32, loc_start.line_start), tree.lastToken(node));
2020-06-10 14:12:00 +01:00
return SourceRange{
2021-03-03 15:34:24 +00:00
.start = loc_start.line_start,
.end = loc_end.line_end,
2020-06-10 14:12:00 +01:00
};
}
2021-03-01 15:02:24 +00:00
pub fn isContainer(tag: ast.Node.Tag) bool {
2021-02-27 15:38:06 +00:00
return switch (tag) {
.container_decl,
.container_decl_trailing,
.container_decl_arg,
.container_decl_arg_trailing,
.container_decl_two,
.container_decl_two_trailing,
.tagged_union,
.tagged_union_trailing,
.tagged_union_two,
.tagged_union_two_trailing,
.tagged_union_enum_tag,
.tagged_union_enum_tag_trailing,
.root,
.error_set_decl,
=> true,
else => false,
};
}
/// Returns the member indices of a given declaration container.
/// Asserts given `tag` is a container node
2021-03-01 18:34:28 +00:00
pub fn declMembers(tree: ast.Tree, tag: ast.Node.Tag, node_idx: ast.Node.Index, buffer: *[2]ast.Node.Index) []const ast.Node.Index {
2021-02-27 15:38:06 +00:00
std.debug.assert(isContainer(tag));
return switch (tag) {
.container_decl, .container_decl_trailing => tree.containerDecl(node_idx).ast.members,
.container_decl_arg, .container_decl_arg_trailing => tree.containerDeclArg(node_idx).ast.members,
.container_decl_two, .container_decl_two_trailing => tree.containerDeclTwo(buffer, node_idx).ast.members,
2021-02-27 15:38:06 +00:00
.tagged_union, .tagged_union_trailing => tree.taggedUnion(node_idx).ast.members,
.tagged_union_enum_tag, .tagged_union_enum_tag_trailing => tree.taggedUnionEnumTag(node_idx).ast.members,
.tagged_union_two, .tagged_union_two_trailing => tree.taggedUnionTwo(buffer, node_idx).ast.members,
2021-02-27 15:38:06 +00:00
.root => tree.rootDecls(),
// @TODO: Fix error set declarations
.error_set_decl => &[_]ast.Node.Index{},
else => unreachable,
};
}
2021-02-27 20:55:39 +00:00
/// Returns an `ast.full.VarDecl` for a given node index.
/// Returns null if the tag doesn't match
2021-03-01 15:02:24 +00:00
pub fn varDecl(tree: ast.Tree, node_idx: ast.Node.Index) ?ast.full.VarDecl {
2021-02-27 20:55:39 +00:00
return switch (tree.nodes.items(.tag)[node_idx]) {
.global_var_decl => tree.globalVarDecl(node_idx),
.local_var_decl => tree.localVarDecl(node_idx),
.aligned_var_decl => tree.alignedVarDecl(node_idx),
.simple_var_decl => tree.simpleVarDecl(node_idx),
else => null,
};
}
// TODO Possibly collect all imports to diff them on changes
// as well
2020-06-10 14:12:00 +01:00
fn makeScopeInternal(
allocator: *std.mem.Allocator,
2020-07-08 02:05:44 +01:00
scopes: *std.ArrayListUnmanaged(Scope),
error_completions: *std.ArrayListUnmanaged(types.CompletionItem),
enum_completions: *std.ArrayListUnmanaged(types.CompletionItem),
tree: ast.Tree,
node_idx: ast.Node.Index,
2020-06-10 14:12:00 +01:00
) error{OutOfMemory}!void {
2021-02-27 15:38:06 +00:00
const tags = tree.nodes.items(.tag);
const token_tags = tree.tokens.items(.tag);
2021-02-27 20:55:39 +00:00
const data = tree.nodes.items(.data);
const main_tokens = tree.nodes.items(.main_token);
2021-02-27 15:38:06 +00:00
const node = tags[node_idx];
if (isContainer(node)) {
2021-03-01 18:34:28 +00:00
var buf: [2]ast.Node.Index = undefined;
const ast_decls = declMembers(tree, node, node_idx, &buf);
2020-06-10 14:12:00 +01:00
2020-07-08 02:05:44 +01:00
(try scopes.addOne(allocator)).* = .{
2021-02-27 15:38:06 +00:00
.range = nodeSourceRange(tree, node_idx),
2020-06-10 14:12:00 +01:00
.decls = std.StringHashMap(Declaration).init(allocator),
// .uses = &[0]*ast.Node.Use{},
2021-02-27 20:55:39 +00:00
.tests = &.{},
2021-02-27 15:38:06 +00:00
.data = .{ .container = node_idx },
2020-06-10 14:12:00 +01:00
};
2020-06-11 09:21:08 +01:00
const scope_idx = scopes.items.len - 1;
// var uses = std.ArrayList(*ast.Node.Use).init(allocator);
2021-02-27 15:38:06 +00:00
var tests = std.ArrayList(ast.Node.Index).init(allocator);
2020-06-10 14:12:00 +01:00
errdefer {
scopes.items[scope_idx].decls.deinit();
// uses.deinit();
tests.deinit();
2020-06-10 14:12:00 +01:00
}
for (ast_decls) |decl| {
2021-02-27 15:38:06 +00:00
// @TODO: Implement using namespace
// if (decl.castTag(.Use)) |use| {
// try uses.append(use);
// continue;
// }
2020-06-10 14:12:00 +01:00
2020-07-08 02:05:44 +01:00
try makeScopeInternal(allocator, scopes, error_completions, enum_completions, tree, decl);
2020-06-10 14:12:00 +01:00
const name = getDeclName(tree, decl) orelse continue;
2021-02-27 15:38:06 +00:00
// @TODO: implement tests
// if (decl.tag == .TestDecl) {
// try tests.append(decl);
// continue;
// }
2021-02-27 15:38:06 +00:00
if (tags[decl] == .error_set_decl) {
2020-07-08 02:05:44 +01:00
(try error_completions.addOne(allocator)).* = .{
.label = name,
.kind = .Constant,
.documentation = if (try getDocComments(allocator, tree, decl, .Markdown)) |docs|
.{ .kind = .Markdown, .value = docs }
else
null,
};
}
2021-02-27 20:55:39 +00:00
const container_field: ?ast.full.ContainerField = switch (tags[decl]) {
2021-02-27 15:38:06 +00:00
.container_field => tree.containerField(decl),
.container_field_align => tree.containerFieldAlign(decl),
.container_field_init => tree.containerFieldInit(decl),
else => null,
};
if (container_field) |field| {
2021-02-27 20:55:39 +00:00
const empty_field = field.ast.type_expr == 0 and field.ast.value_expr == 0;
2021-02-27 15:38:06 +00:00
if (empty_field and node == .root) {
2020-07-08 02:05:44 +01:00
continue;
}
2021-02-27 15:38:06 +00:00
// @TODO: We can probably just use node_idx directly instead of first transforming to container
const container_decl: ?ast.full.ContainerDecl = switch (node) {
.container_decl, .container_decl_trailing => tree.containerDecl(node_idx),
.container_decl_arg, .container_decl_arg_trailing => tree.containerDeclArg(node_idx),
.container_decl_two, .container_decl_two_trailing => blk: {
var buffer: [2]ast.Node.Index = undefined;
break :blk tree.containerDeclTwo(&buffer, node_idx);
},
.tagged_union, .tagged_union_trailing => tree.taggedUnion(node_idx),
.tagged_union_enum_tag, .tagged_union_enum_tag_trailing => tree.taggedUnionEnumTag(node_idx),
2021-02-27 20:55:39 +00:00
.tagged_union_two, .tagged_union_two_trailing => blk: {
2021-02-27 15:38:06 +00:00
var buffer: [2]ast.Node.Index = undefined;
break :blk tree.taggedUnionTwo(&buffer, node_idx);
},
else => null,
};
if (container_decl) |container| {
const kind = token_tags[container.ast.main_token];
if (empty_field and (kind == .keyword_struct or (kind == .keyword_union and container.ast.arg == 0))) {
2020-07-08 02:05:44 +01:00
continue;
}
2020-07-08 02:05:44 +01:00
2020-07-08 02:11:52 +01:00
if (!std.mem.eql(u8, name, "_")) {
(try enum_completions.addOne(allocator)).* = .{
.label = name,
.kind = .Constant,
2021-03-03 15:34:24 +00:00
.documentation = if (try getDocComments(allocator, tree, decl, .Markdown)) |docs|
2020-07-08 02:11:52 +01:00
.{ .kind = .Markdown, .value = docs }
else
null,
};
}
}
}
2020-07-05 22:56:41 +01:00
if (try scopes.items[scope_idx].decls.fetchPut(name, .{ .ast_node = decl })) |existing| {
2020-06-10 14:12:00 +01:00
// TODO Record a redefinition error.
}
}
scopes.items[scope_idx].tests = tests.toOwnedSlice();
// scopes.items[scope_idx].uses = uses.toOwnedSlice();
2020-06-10 14:12:00 +01:00
return;
}
2021-02-27 15:38:06 +00:00
switch (node) {
2021-03-02 14:32:38 +00:00
.fn_proto, .fn_proto_one, .fn_proto_simple, .fn_proto_multi, .fn_decl => |fn_tag| {
2021-02-27 20:55:39 +00:00
var buf: [1]ast.Node.Index = undefined;
2021-03-01 13:32:19 +00:00
const func = fnProto(tree, node_idx, &buf).?;
2020-06-10 14:12:00 +01:00
2020-07-08 02:05:44 +01:00
(try scopes.addOne(allocator)).* = .{
2021-02-27 20:55:39 +00:00
.range = nodeSourceRange(tree, node_idx),
2020-06-10 14:12:00 +01:00
.decls = std.StringHashMap(Declaration).init(allocator),
// .uses = &[0]*ast.Node.Use{},
2021-02-27 20:55:39 +00:00
.tests = &.{},
2021-02-28 12:09:10 +00:00
.data = .{ .function = node_idx },
2020-06-10 14:12:00 +01:00
};
var scope_idx = scopes.items.len - 1;
errdefer scopes.items[scope_idx].decls.deinit();
2021-02-27 20:55:39 +00:00
var it = func.iterate(tree);
while (it.next()) |param| {
if (param.name_token) |name_token| {
if (try scopes.items[scope_idx].decls.fetchPut(tree.tokenSlice(name_token), .{ .param_decl = param })) |existing| {
// TODO record a redefinition error
2020-06-10 14:12:00 +01:00
}
}
}
2021-03-02 14:32:38 +00:00
if (fn_tag == .fn_decl) {
try makeScopeInternal(allocator, scopes, error_completions, enum_completions, tree, data[node_idx].rhs);
}
2020-06-10 14:12:00 +01:00
return;
},
2021-02-27 20:55:39 +00:00
.test_decl => {
return try makeScopeInternal(allocator, scopes, error_completions, enum_completions, tree, data[node_idx].rhs);
2020-06-10 14:12:00 +01:00
},
2021-02-27 20:55:39 +00:00
.block, .block_semicolon, .block_two, .block_two_semicolon => {
const first_token = tree.firstToken(node_idx);
const last_token = tree.lastToken(node_idx);
2021-02-27 20:55:39 +00:00
// if labeled block
if (token_tags[first_token] == .identifier) {
const scope = try scopes.addOne(allocator);
scope.* = .{
.range = .{
2021-02-28 12:09:10 +00:00
.start = tree.tokenLocation(0, main_tokens[node_idx]).line_start,
.end = tree.tokenLocation(0, last_token).line_start,
2021-02-27 20:55:39 +00:00
},
.decls = std.StringHashMap(Declaration).init(allocator),
// .uses = &[0]*ast.Node.Use{},
2021-02-28 12:09:10 +00:00
.tests = &.{},
2021-02-27 20:55:39 +00:00
.data = .other,
};
errdefer scope.decls.deinit();
2021-02-28 12:09:10 +00:00
try scope.decls.putNoClobber(tree.tokenSlice(first_token), .{ .label_decl = first_token });
2021-02-27 20:55:39 +00:00
}
2020-06-14 20:24:18 +01:00
(try scopes.addOne(allocator)).* = .{
2021-02-27 20:55:39 +00:00
.range = nodeSourceRange(tree, node_idx),
.decls = std.StringHashMap(Declaration).init(allocator),
// .uses = &[0]*ast.Node.Use{},
2021-02-27 20:55:39 +00:00
.tests = &.{},
.data = .{ .block = node_idx },
};
var scope_idx = scopes.items.len - 1;
// var uses = std.ArrayList(*ast.Node.Use).init(allocator);
errdefer {
scopes.items[scope_idx].decls.deinit();
// uses.deinit();
2020-06-14 20:24:18 +01:00
}
2021-02-27 20:55:39 +00:00
const statements: []const ast.Node.Index = switch (node) {
.block, .block_semicolon => tree.extra_data[data[node_idx].lhs..data[node_idx].rhs],
.block_two, .block_two_semicolon => blk: {
2021-02-28 12:09:10 +00:00
const statements = &[_]ast.Node.Index{ data[node_idx].lhs, data[node_idx].rhs };
const len: usize = if (data[node_idx].lhs == 0)
@as(usize, 0)
else if (data[node_idx].rhs == 0)
@as(usize, 1)
else
@as(usize, 2);
2021-02-27 20:55:39 +00:00
break :blk statements[0..len];
},
else => unreachable,
2020-06-10 14:12:00 +01:00
};
2021-02-28 12:09:10 +00:00
for (statements) |idx| {
2021-02-27 20:55:39 +00:00
try makeScopeInternal(allocator, scopes, error_completions, enum_completions, tree, idx);
2021-02-28 12:09:10 +00:00
if (varDecl(tree, idx)) |var_decl| {
2021-02-27 20:55:39 +00:00
const name = tree.tokenSlice(var_decl.ast.mut_token + 1);
if (try scopes.items[scope_idx].decls.fetchPut(name, .{ .ast_node = idx })) |existing| {
// TODO record a redefinition error.
2020-06-10 14:12:00 +01:00
}
}
}
// scopes.items[scope_idx].uses = uses.toOwnedSlice();
2020-06-10 14:12:00 +01:00
return;
},
2021-02-27 20:55:39 +00:00
.@"comptime", .@"nosuspend" => {
return try makeScopeInternal(allocator, scopes, error_completions, enum_completions, tree, data[node_idx].lhs);
2020-06-10 14:12:00 +01:00
},
2021-02-27 20:55:39 +00:00
.@"if", .if_simple => {
const if_node: ast.full.If = if (node == .@"if")
tree.ifFull(node_idx)
else
tree.ifSimple(node_idx);
2020-06-10 14:12:00 +01:00
2021-02-27 20:55:39 +00:00
if (if_node.payload_token) |payload| {
2020-07-08 02:05:44 +01:00
var scope = try scopes.addOne(allocator);
2020-06-10 14:12:00 +01:00
scope.* = .{
.range = .{
2021-02-27 20:55:39 +00:00
.start = tree.tokenLocation(0, payload).line_start,
2021-02-28 12:09:10 +00:00
.end = tree.tokenLocation(0, tree.lastToken(if_node.ast.then_expr)).line_end,
2020-06-10 14:12:00 +01:00
},
.decls = std.StringHashMap(Declaration).init(allocator),
// .uses = &[0]*ast.Node.Use{},
2021-02-27 20:55:39 +00:00
.tests = &.{},
2020-06-10 14:12:00 +01:00
.data = .other,
};
errdefer scope.decls.deinit();
2021-02-27 20:55:39 +00:00
const name_token = payload + @boolToInt(token_tags[payload] == .asterisk);
std.debug.assert(token_tags[name_token] == .identifier);
const name = tree.tokenSlice(name_token);
2020-06-10 14:12:00 +01:00
try scope.decls.putNoClobber(name, .{
.pointer_payload = .{
2021-02-27 20:55:39 +00:00
.name = name_token,
.condition = if_node.ast.cond_expr,
2020-06-10 14:12:00 +01:00
},
});
}
2021-02-27 20:55:39 +00:00
try makeScopeInternal(allocator, scopes, error_completions, enum_completions, tree, if_node.ast.then_expr);
if (if_node.ast.else_expr != 0) {
if (if_node.error_token) |err_token| {
std.debug.assert(token_tags[err_token] == .identifier);
2020-07-08 02:05:44 +01:00
var scope = try scopes.addOne(allocator);
2020-06-10 14:12:00 +01:00
scope.* = .{
.range = .{
2021-02-27 20:55:39 +00:00
.start = tree.tokenLocation(0, err_token).line_start,
2021-02-28 12:09:10 +00:00
.end = tree.tokenLocation(0, tree.lastToken(if_node.ast.else_expr)).line_end,
2020-06-10 14:12:00 +01:00
},
.decls = std.StringHashMap(Declaration).init(allocator),
// .uses = &[0]*ast.Node.Use{},
2021-02-27 20:55:39 +00:00
.tests = &.{},
2020-06-10 14:12:00 +01:00
.data = .other,
};
errdefer scope.decls.deinit();
2021-02-27 20:55:39 +00:00
const name = tree.tokenSlice(err_token);
try scope.decls.putNoClobber(name, .{ .ast_node = if_node.ast.else_expr });
2020-06-10 14:12:00 +01:00
}
2021-02-27 20:55:39 +00:00
try makeScopeInternal(allocator, scopes, error_completions, enum_completions, tree, if_node.ast.else_expr);
2020-06-10 14:12:00 +01:00
}
},
2021-02-27 20:55:39 +00:00
.@"while", .while_simple, .while_cont, .@"for", .for_simple => {
const while_node: ast.full.While = switch (node) {
.@"while" => tree.whileFull(node_idx),
.while_simple => tree.whileSimple(node_idx),
.while_cont => tree.whileCont(node_idx),
.@"for" => tree.forFull(node_idx),
.for_simple => tree.forSimple(node_idx),
else => unreachable,
};
if (while_node.label_token) |label| {
2021-03-02 14:32:38 +00:00
std.debug.assert(token_tags[label] == .identifier);
2020-07-08 02:05:44 +01:00
var scope = try scopes.addOne(allocator);
2020-06-14 20:24:18 +01:00
scope.* = .{
.range = .{
2021-03-03 15:34:24 +00:00
.start = tree.tokenLocation(0, while_node.ast.while_token).line_start,
.end = tree.tokenLocation(0, tree.lastToken(node_idx)).line_end,
2020-06-14 20:24:18 +01:00
},
.decls = std.StringHashMap(Declaration).init(allocator),
// .uses = &[0]*ast.Node.Use{},
2021-02-27 20:55:39 +00:00
.tests = &.{},
2020-06-14 20:24:18 +01:00
.data = .other,
};
errdefer scope.decls.deinit();
2021-02-27 20:55:39 +00:00
try scope.decls.putNoClobber(tree.tokenSlice(label), .{ .label_decl = label });
2020-06-14 20:24:18 +01:00
}
2021-02-27 20:55:39 +00:00
if (while_node.payload_token) |payload| {
2020-07-08 02:05:44 +01:00
var scope = try scopes.addOne(allocator);
2020-06-10 14:12:00 +01:00
scope.* = .{
.range = .{
2021-02-27 20:55:39 +00:00
.start = tree.tokenLocation(0, payload).line_start,
2021-02-28 12:09:10 +00:00
.end = tree.tokenLocation(0, tree.lastToken(while_node.ast.then_expr)).line_end,
2020-06-10 14:12:00 +01:00
},
.decls = std.StringHashMap(Declaration).init(allocator),
// .uses = &[0]*ast.Node.Use{},
2021-02-27 20:55:39 +00:00
.tests = &.{},
2020-06-10 14:12:00 +01:00
.data = .other,
};
errdefer scope.decls.deinit();
2021-02-27 20:55:39 +00:00
const name_token = payload + @boolToInt(token_tags[payload] == .asterisk);
std.debug.assert(token_tags[name_token] == .identifier);
const name = tree.tokenSlice(name_token);
2020-06-10 14:12:00 +01:00
try scope.decls.putNoClobber(name, .{
.pointer_payload = .{
2021-02-27 20:55:39 +00:00
.name = name_token,
.condition = while_node.ast.cond_expr,
2020-06-10 14:12:00 +01:00
},
});
}
2021-02-27 20:55:39 +00:00
try makeScopeInternal(allocator, scopes, error_completions, enum_completions, tree, while_node.ast.then_expr);
2020-06-10 14:12:00 +01:00
2021-02-27 20:55:39 +00:00
if (while_node.ast.else_expr != 0) {
if (while_node.error_token) |err_token| {
std.debug.assert(token_tags[err_token] == .identifier);
2020-07-08 02:05:44 +01:00
var scope = try scopes.addOne(allocator);
2020-06-10 14:12:00 +01:00
scope.* = .{
.range = .{
2021-02-27 20:55:39 +00:00
.start = tree.tokenLocation(0, err_token).line_start,
2021-02-28 12:09:10 +00:00
.end = tree.tokenLocation(0, tree.lastToken(while_node.ast.else_expr)).line_end,
2020-06-10 14:12:00 +01:00
},
.decls = std.StringHashMap(Declaration).init(allocator),
// .uses = &[0]*ast.Node.Use{},
2021-02-27 20:55:39 +00:00
.tests = &.{},
2020-06-10 14:12:00 +01:00
.data = .other,
};
errdefer scope.decls.deinit();
2021-02-27 20:55:39 +00:00
const name = tree.tokenSlice(err_token);
2021-02-28 12:09:10 +00:00
try scope.decls.putNoClobber(name, .{ .ast_node = while_node.ast.else_expr });
2020-06-10 14:12:00 +01:00
}
2021-02-27 20:55:39 +00:00
try makeScopeInternal(allocator, scopes, error_completions, enum_completions, tree, while_node.ast.else_expr);
2020-06-10 14:12:00 +01:00
}
},
2021-02-28 12:09:10 +00:00
.switch_case, .switch_case_one => {
const switch_case: ast.full.SwitchCase = switch (node) {
.switch_case => tree.switchCase(node_idx),
.switch_case_one => tree.switchCaseOne(node_idx),
else => unreachable,
};
if (switch_case.payload_token) |payload| {
2020-07-08 02:05:44 +01:00
var scope = try scopes.addOne(allocator);
2020-06-14 20:24:18 +01:00
scope.* = .{
.range = .{
2021-02-28 12:09:10 +00:00
.start = tree.tokenLocation(0, payload).line_start,
.end = tree.tokenLocation(0, tree.lastToken(switch_case.ast.target_expr)).line_end,
2020-06-14 20:24:18 +01:00
},
.decls = std.StringHashMap(Declaration).init(allocator),
// .uses = &[0]*ast.Node.Use{},
2021-02-28 12:09:10 +00:00
.tests = &.{},
2020-06-14 20:24:18 +01:00
.data = .other,
};
errdefer scope.decls.deinit();
2021-02-28 12:09:10 +00:00
// if payload is *name than get next token
const name_token = payload + @boolToInt(token_tags[payload] == .asterisk);
const name = tree.tokenSlice(name_token);
2020-06-10 14:12:00 +01:00
2021-02-28 12:09:10 +00:00
try scope.decls.putNoClobber(name, .{
.switch_payload = .{
.node = payload,
.switch_expr = switch_case.ast.target_expr,
.items = switch_case.ast.values,
},
});
2020-06-10 14:12:00 +01:00
}
2021-02-28 12:09:10 +00:00
try makeScopeInternal(allocator, scopes, error_completions, enum_completions, tree, switch_case.ast.target_expr);
2020-06-10 14:12:00 +01:00
},
2021-02-28 12:09:10 +00:00
.global_var_decl, .local_var_decl, .aligned_var_decl, .simple_var_decl => {
const var_decl = varDecl(tree, node_idx).?;
if (var_decl.ast.type_node != 0) {
try makeScopeInternal(allocator, scopes, error_completions, enum_completions, tree, var_decl.ast.type_node);
2020-06-10 14:12:00 +01:00
}
2021-02-28 12:09:10 +00:00
if (var_decl.ast.init_node != 0) {
try makeScopeInternal(allocator, scopes, error_completions, enum_completions, tree, var_decl.ast.init_node);
2020-06-10 14:12:00 +01:00
}
},
else => {
2021-03-03 15:34:24 +00:00
// log.debug("Implement makeScopeInternal for node type: '{s}'", .{node});
2021-02-28 12:09:10 +00:00
// @TODO: Could we just do node_idx + 1 here?
// var child_idx: usize = 0;
// while (node.iterate(child_idx)) |child_node| : (child_idx += 1) {
// try makeScopeInternal(allocator, scopes, error_completions, enum_completions, tree, child_node);
// }
2020-06-10 14:12:00 +01:00
},
}
}