Now compiles on the new parser branch
This commit is contained in:
Alexandros Naskos
parent
30cb9e06e4
commit
11b5da3a91
179
src/analysis.zig
179
src/analysis.zig
@ -51,24 +51,31 @@ pub fn getDocComments(allocator: *std.mem.Allocator, tree: *ast.Tree, node: *ast
|
||||
return try collectDocComments(allocator, tree, doc_comments);
|
||||
}
|
||||
},
|
||||
.ParamDecl => {
|
||||
const param = node.cast(ast.Node.ParamDecl).?;
|
||||
if (param.doc_comments) |doc_comments| {
|
||||
return try collectDocComments(allocator, tree, doc_comments);
|
||||
}
|
||||
},
|
||||
// @TODO: ParamDecl is no longer a node.
|
||||
// .ParamDecl => {
|
||||
// const param = node.cast(ast.Node.ParamDecl).?;
|
||||
// if (param.doc_comments) |doc_comments| {
|
||||
// return try collectDocComments(allocator, tree, doc_comments);
|
||||
// }
|
||||
// },
|
||||
else => {},
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
fn collectDocComments(allocator: *std.mem.Allocator, tree: *ast.Tree, doc_comments: *ast.Node.DocComment) ![]const u8 {
|
||||
var doc_it = doc_comments.lines.iterator(0);
|
||||
var lines = std.ArrayList([]const u8).init(allocator);
|
||||
defer lines.deinit();
|
||||
|
||||
while (doc_it.next()) |doc_comment| {
|
||||
_ = try lines.append(std.fmt.trim(tree.tokenSlice(doc_comment.*)[3..]));
|
||||
var curr_line_tok = doc_comments.first_line;
|
||||
while (true) : (curr_line_tok += 1) {
|
||||
switch (tree.token_ids[curr_line_tok]) {
|
||||
.LineComment => continue,
|
||||
.DocComment, .ContainerDocComment => {
|
||||
try lines.append(std.fmt.trim(tree.tokenSlice(curr_line_tok)[3..]));
|
||||
},
|
||||
else => break,
|
||||
}
|
||||
}
|
||||
|
||||
return try std.mem.join(allocator, "\n", lines.items);
|
||||
@ -76,11 +83,11 @@ fn collectDocComments(allocator: *std.mem.Allocator, tree: *ast.Tree, doc_commen
|
||||
|
||||
/// Gets a function signature (keywords, name, return value)
|
||||
pub fn getFunctionSignature(tree: *ast.Tree, func: *ast.Node.FnProto) []const u8 {
|
||||
const start = tree.tokens.at(func.firstToken()).start;
|
||||
const end = tree.tokens.at(switch (func.return_type) {
|
||||
const start = tree.token_locs[func.firstToken()].start;
|
||||
const end = tree.token_locs[switch (func.return_type) {
|
||||
.Explicit, .InferErrorSet => |node| node.lastToken(),
|
||||
.Invalid => |r_paren| r_paren,
|
||||
}).end;
|
||||
}].end;
|
||||
return tree.source[start..end];
|
||||
}
|
||||
|
||||
@ -96,38 +103,33 @@ pub fn getFunctionSnippet(allocator: *std.mem.Allocator, tree: *ast.Tree, func:
|
||||
|
||||
var buf_stream = buffer.outStream();
|
||||
|
||||
var param_num = @as(usize, 1);
|
||||
var param_it = func.params.iterator(0);
|
||||
while (param_it.next()) |param_ptr| : (param_num += 1) {
|
||||
const param = param_ptr.*;
|
||||
const param_decl = param.cast(ast.Node.ParamDecl).?;
|
||||
for (func.paramsConst()) |param, param_num| {
|
||||
if (param_num != 0) try buffer.appendSlice(", ${") else try buffer.appendSlice("${");
|
||||
|
||||
if (param_num != 1) try buffer.appendSlice(", ${") else try buffer.appendSlice("${");
|
||||
try buf_stream.print("{}:", .{param_num + 1});
|
||||
|
||||
try buf_stream.print("{}:", .{param_num});
|
||||
|
||||
if (param_decl.comptime_token) |_| {
|
||||
if (param.comptime_token) |_| {
|
||||
try buffer.appendSlice("comptime ");
|
||||
}
|
||||
|
||||
if (param_decl.noalias_token) |_| {
|
||||
if (param.noalias_token) |_| {
|
||||
try buffer.appendSlice("noalias ");
|
||||
}
|
||||
|
||||
if (param_decl.name_token) |name_token| {
|
||||
if (param.name_token) |name_token| {
|
||||
try buffer.appendSlice(tree.tokenSlice(name_token));
|
||||
try buffer.appendSlice(": ");
|
||||
}
|
||||
|
||||
switch (param_decl.param_type) {
|
||||
switch (param.param_type) {
|
||||
.var_args => try buffer.appendSlice("..."),
|
||||
.var_type => try buffer.appendSlice("var"),
|
||||
.type_expr => |type_expr| {
|
||||
var curr_tok = type_expr.firstToken();
|
||||
var end_tok = type_expr.lastToken();
|
||||
while (curr_tok <= end_tok) : (curr_tok += 1) {
|
||||
const id = tree.tokens.at(curr_tok).id;
|
||||
const is_comma = tree.tokens.at(curr_tok).id == .Comma;
|
||||
const id = tree.token_ids[curr_tok];
|
||||
const is_comma = id == .Comma;
|
||||
|
||||
if (curr_tok == end_tok and is_comma) continue;
|
||||
|
||||
@ -146,8 +148,8 @@ pub fn getFunctionSnippet(allocator: *std.mem.Allocator, tree: *ast.Tree, func:
|
||||
|
||||
/// Gets a function signature (keywords, name, return value)
|
||||
pub fn getVariableSignature(tree: *ast.Tree, var_decl: *ast.Node.VarDecl) []const u8 {
|
||||
const start = tree.tokens.at(var_decl.firstToken()).start;
|
||||
const end = tree.tokens.at(var_decl.semicolon_token).start;
|
||||
const start = tree.token_locs[var_decl.firstToken()].start;
|
||||
const end = tree.token_locs[var_decl.semicolon_token].start;
|
||||
return tree.source[start..end];
|
||||
}
|
||||
|
||||
@ -186,11 +188,12 @@ pub fn getDeclNameToken(tree: *ast.Tree, node: *ast.Node) ?ast.TokenIndex {
|
||||
const vari = node.cast(ast.Node.VarDecl).?;
|
||||
return vari.name_token;
|
||||
},
|
||||
.ParamDecl => {
|
||||
const decl = node.cast(ast.Node.ParamDecl).?;
|
||||
if (decl.name_token == null) return null;
|
||||
return decl.name_token.?;
|
||||
},
|
||||
// @TODO Param decl is no longer a node
|
||||
// .ParamDecl => {
|
||||
// const decl = node.cast(ast.Node.ParamDecl).?;
|
||||
// if (decl.name_token == null) return null;
|
||||
// return decl.name_token.?;
|
||||
// },
|
||||
.FnProto => {
|
||||
const func = node.cast(ast.Node.FnProto).?;
|
||||
if (func.name_token == null) return null;
|
||||
@ -217,8 +220,8 @@ fn getDeclName(tree: *ast.Tree, node: *ast.Node) ?[]const u8 {
|
||||
|
||||
/// Gets the child of node
|
||||
pub fn getChild(tree: *ast.Tree, node: *ast.Node, name: []const u8) ?*ast.Node {
|
||||
var index: usize = 0;
|
||||
while (node.iterate(index)) |child| : (index += 1) {
|
||||
var child_it = node.iterate();
|
||||
while (child_it.next()) |child| {
|
||||
const child_name = getDeclName(tree, child) orelse continue;
|
||||
if (std.mem.eql(u8, child_name, name)) return child;
|
||||
}
|
||||
@ -236,8 +239,8 @@ pub fn getChildOfSlice(tree: *ast.Tree, nodes: []*ast.Node, name: []const u8) ?*
|
||||
|
||||
fn findReturnStatementInternal(base_node: *ast.Node, already_found: *bool) ?*ast.Node.ControlFlowExpression {
|
||||
var result: ?*ast.Node.ControlFlowExpression = null;
|
||||
var idx: usize = 0;
|
||||
while (base_node.iterate(idx)) |child_node| : (idx += 1) {
|
||||
var child_it = base_node.iterate();
|
||||
while (child_it.next()) |child_node| {
|
||||
switch (child_node.id) {
|
||||
.ControlFlowExpression => {
|
||||
const cfe = child_node.cast(ast.Node.ControlFlowExpression).?;
|
||||
@ -293,15 +296,16 @@ pub fn resolveTypeOfNode(analysis_ctx: *AnalysisContext, node: *ast.Node) ?*ast.
|
||||
|
||||
return resolveTypeOfNode(analysis_ctx, vari.type_node orelse vari.init_node.?) orelse null;
|
||||
},
|
||||
.ParamDecl => {
|
||||
const decl = node.cast(ast.Node.ParamDecl).?;
|
||||
switch (decl.param_type) {
|
||||
.var_type, .type_expr => |var_type| {
|
||||
return resolveTypeOfNode(analysis_ctx, var_type) orelse null;
|
||||
},
|
||||
else => {},
|
||||
}
|
||||
},
|
||||
// @TODO Param decl is no longer a node type.
|
||||
// .ParamDecl => {
|
||||
// const decl = node.cast(ast.Node.ParamDecl).?;
|
||||
// switch (decl.param_type) {
|
||||
// .var_type, .type_expr => |var_type| {
|
||||
// return resolveTypeOfNode(analysis_ctx, var_type) orelse null;
|
||||
// },
|
||||
// else => {},
|
||||
// }
|
||||
// },
|
||||
.Identifier => {
|
||||
if (getChildOfSlice(analysis_ctx.tree, analysis_ctx.scope_nodes, analysis_ctx.tree.getNodeSource(node))) |child| {
|
||||
return resolveTypeOfNode(analysis_ctx, child);
|
||||
@ -311,18 +315,21 @@ pub fn resolveTypeOfNode(analysis_ctx: *AnalysisContext, node: *ast.Node) ?*ast.
|
||||
const field = node.cast(ast.Node.ContainerField).?;
|
||||
return resolveTypeOfNode(analysis_ctx, field.type_expr orelse return null);
|
||||
},
|
||||
.SuffixOp => {
|
||||
const suffix_op = node.cast(ast.Node.SuffixOp).?;
|
||||
switch (suffix_op.op) {
|
||||
.Call, .StructInitializer => {
|
||||
const decl = resolveTypeOfNode(analysis_ctx, suffix_op.lhs.node) orelse return null;
|
||||
.Call => {
|
||||
const call = node.cast(ast.Node.Call).?;
|
||||
const decl = resolveTypeOfNode(analysis_ctx, call.lhs) orelse return null;
|
||||
return switch (decl.id) {
|
||||
.FnProto => resolveReturnType(analysis_ctx, decl.cast(ast.Node.FnProto).?),
|
||||
else => decl,
|
||||
};
|
||||
},
|
||||
else => {},
|
||||
}
|
||||
.StructInitializer => {
|
||||
const struct_init = node.cast(ast.Node.StructInitializer).?;
|
||||
const decl = resolveTypeOfNode(analysis_ctx, struct_init.lhs) orelse return null;
|
||||
return switch (decl.id) {
|
||||
.FnProto => resolveReturnType(analysis_ctx, decl.cast(ast.Node.FnProto).?),
|
||||
else => decl,
|
||||
};
|
||||
},
|
||||
.InfixOp => {
|
||||
const infix_op = node.cast(ast.Node.InfixOp).?;
|
||||
@ -344,8 +351,8 @@ pub fn resolveTypeOfNode(analysis_ctx: *AnalysisContext, node: *ast.Node) ?*ast.
|
||||
switch (prefix_op.op) {
|
||||
.SliceType, .ArrayType => return node,
|
||||
.PtrType => {
|
||||
const op_token = analysis_ctx.tree.tokens.at(prefix_op.op_token);
|
||||
switch (op_token.id) {
|
||||
const op_token_id = analysis_ctx.tree.token_ids[prefix_op.op_token];
|
||||
switch (op_token_id) {
|
||||
.Asterisk => return resolveTypeOfNode(analysis_ctx, prefix_op.rhs),
|
||||
.LBracket, .AsteriskAsterisk => return null,
|
||||
else => unreachable,
|
||||
@ -369,14 +376,14 @@ pub fn resolveTypeOfNode(analysis_ctx: *AnalysisContext, node: *ast.Node) ?*ast.
|
||||
const builtin_call = node.cast(ast.Node.BuiltinCall).?;
|
||||
const call_name = analysis_ctx.tree.tokenSlice(builtin_call.builtin_token);
|
||||
if (std.mem.eql(u8, call_name, "@This")) {
|
||||
if (builtin_call.params.len != 0) return null;
|
||||
if (builtin_call.params_len != 0) return null;
|
||||
return analysis_ctx.last_this_node;
|
||||
}
|
||||
|
||||
if (!std.mem.eql(u8, call_name, "@import")) return null;
|
||||
if (builtin_call.params.len > 1) return null;
|
||||
if (builtin_call.params_len > 1) return null;
|
||||
|
||||
const import_param = builtin_call.params.at(0).*;
|
||||
const import_param = builtin_call.paramsConst()[0];
|
||||
if (import_param.id != .StringLiteral) return null;
|
||||
|
||||
const import_str = analysis_ctx.tree.tokenSlice(import_param.cast(ast.Node.StringLiteral).?.token);
|
||||
@ -397,9 +404,9 @@ pub fn resolveTypeOfNode(analysis_ctx: *AnalysisContext, node: *ast.Node) ?*ast.
|
||||
|
||||
fn maybeCollectImport(tree: *ast.Tree, builtin_call: *ast.Node.BuiltinCall, arr: *std.ArrayList([]const u8)) !void {
|
||||
if (!std.mem.eql(u8, tree.tokenSlice(builtin_call.builtin_token), "@import")) return;
|
||||
if (builtin_call.params.len > 1) return;
|
||||
if (builtin_call.params_len > 1) return;
|
||||
|
||||
const import_param = builtin_call.params.at(0).*;
|
||||
const import_param = builtin_call.paramsConst()[0];
|
||||
if (import_param.id != .StringLiteral) return;
|
||||
|
||||
const import_str = tree.tokenSlice(import_param.cast(ast.Node.StringLiteral).?.token);
|
||||
@ -410,8 +417,7 @@ fn maybeCollectImport(tree: *ast.Tree, builtin_call: *ast.Node.BuiltinCall, arr:
|
||||
/// The import paths are valid as long as the tree is.
|
||||
pub fn collectImports(import_arr: *std.ArrayList([]const u8), tree: *ast.Tree) !void {
|
||||
// TODO: Currently only detects `const smth = @import("string literal")<.SomeThing>;`
|
||||
var idx: usize = 0;
|
||||
while (tree.root_node.iterate(idx)) |decl| : (idx += 1) {
|
||||
for (tree.root_node.decls()) |decl| {
|
||||
if (decl.id != .VarDecl) continue;
|
||||
const var_decl = decl.cast(ast.Node.VarDecl).?;
|
||||
if (var_decl.init_node == null) continue;
|
||||
@ -448,7 +454,7 @@ pub fn getFieldAccessTypeNode(
|
||||
switch (next.id) {
|
||||
.Eof => return current_node,
|
||||
.Identifier => {
|
||||
if (getChildOfSlice(analysis_ctx.tree, analysis_ctx.scope_nodes, tokenizer.buffer[next.start..next.end])) |child| {
|
||||
if (getChildOfSlice(analysis_ctx.tree, analysis_ctx.scope_nodes, tokenizer.buffer[next.loc.start..next.loc.end])) |child| {
|
||||
if (resolveTypeOfNode(analysis_ctx, child)) |node_type| {
|
||||
current_node = node_type;
|
||||
} else return null;
|
||||
@ -460,9 +466,9 @@ pub fn getFieldAccessTypeNode(
|
||||
return current_node;
|
||||
} else if (after_period.id == .Identifier) {
|
||||
// TODO: This works for now, maybe we should filter based on the partial identifier ourselves?
|
||||
if (after_period.end == line_length) return current_node;
|
||||
if (after_period.loc.end == line_length) return current_node;
|
||||
|
||||
if (getChild(analysis_ctx.tree, current_node, tokenizer.buffer[after_period.start..after_period.end])) |child| {
|
||||
if (getChild(analysis_ctx.tree, current_node, tokenizer.buffer[after_period.loc.start..after_period.loc.end])) |child| {
|
||||
if (resolveTypeOfNode(analysis_ctx, child)) |child_type| {
|
||||
current_node = child_type;
|
||||
} else return null;
|
||||
@ -521,8 +527,8 @@ pub fn nodeToString(tree: *ast.Tree, node: *ast.Node) ?[]const u8 {
|
||||
pub fn declsFromIndexInternal(decls: *std.ArrayList(*ast.Node), tree: *ast.Tree, node: *ast.Node, source_index: usize) error{OutOfMemory}!void {
|
||||
switch (node.id) {
|
||||
.Root, .ContainerDecl => {
|
||||
var node_index: usize = 0;
|
||||
while (node.iterate(node_index)) |child_node| : (node_index += 1) {
|
||||
var node_it = node.iterate();
|
||||
while (node_it.next()) |child_node| {
|
||||
// Skip over container fields, we can only dot access those.
|
||||
if (child_node.id == .ContainerField) continue;
|
||||
|
||||
@ -537,9 +543,10 @@ pub fn declsFromIndexInternal(decls: *std.ArrayList(*ast.Node), tree: *ast.Tree,
|
||||
.FnProto => {
|
||||
const func = node.cast(ast.Node.FnProto).?;
|
||||
|
||||
var param_index: usize = 0;
|
||||
while (param_index < func.params.len) : (param_index += 1)
|
||||
try declsFromIndexInternal(decls, tree, func.params.at(param_index).*, source_index);
|
||||
for (func.paramsConst()) |param| {
|
||||
// try decls.append(node)
|
||||
// @TODO We need to store something else than nodes from now on.
|
||||
}
|
||||
|
||||
if (func.body_node) |body_node| {
|
||||
if (!nodeContainsSourceIndex(tree, body_node, source_index)) return;
|
||||
@ -552,8 +559,8 @@ pub fn declsFromIndexInternal(decls: *std.ArrayList(*ast.Node), tree: *ast.Tree,
|
||||
try declsFromIndexInternal(decls, tree, test_decl.body_node, source_index);
|
||||
},
|
||||
.Block => {
|
||||
var index: usize = 0;
|
||||
while (node.iterate(index)) |inode| : (index += 1) {
|
||||
var node_it = node.iterate();
|
||||
while (node_it.next()) |inode| {
|
||||
if (nodeComesAfterSourceIndex(tree, inode, source_index)) return;
|
||||
try declsFromIndexInternal(decls, tree, inode, source_index);
|
||||
}
|
||||
@ -617,8 +624,7 @@ pub fn declsFromIndexInternal(decls: *std.ArrayList(*ast.Node), tree: *ast.Tree,
|
||||
},
|
||||
.Switch => {
|
||||
const switch_node = node.cast(ast.Node.Switch).?;
|
||||
var case_it = switch_node.cases.iterator(0);
|
||||
while (case_it.next()) |case| {
|
||||
for (switch_node.casesConst()) |case| {
|
||||
const case_node = case.*.cast(ast.Node.SwitchCase).?;
|
||||
if (nodeContainsSourceIndex(tree, case_node.expr, source_index)) {
|
||||
if (case_node.payload) |payload| {
|
||||
@ -646,14 +652,13 @@ pub fn declsFromIndexInternal(decls: *std.ArrayList(*ast.Node), tree: *ast.Tree,
|
||||
}
|
||||
}
|
||||
},
|
||||
.ParamDecl => try decls.append(node),
|
||||
else => {},
|
||||
}
|
||||
}
|
||||
|
||||
pub fn addChildrenNodes(decls: *std.ArrayList(*ast.Node), tree: *ast.Tree, node: *ast.Node) !void {
|
||||
var index: usize = 0;
|
||||
while (node.iterate(index)) |child_node| : (index += 1) {
|
||||
var node_it = node.iterate();
|
||||
while (node_it.next()) |child_node| {
|
||||
try decls.append(child_node);
|
||||
}
|
||||
}
|
||||
@ -664,38 +669,38 @@ pub fn declsFromIndex(decls: *std.ArrayList(*ast.Node), tree: *ast.Tree, source_
|
||||
}
|
||||
|
||||
fn nodeContainsSourceIndex(tree: *ast.Tree, node: *ast.Node, source_index: usize) bool {
|
||||
const first_token = tree.tokens.at(node.firstToken());
|
||||
const last_token = tree.tokens.at(node.lastToken());
|
||||
const first_token = tree.token_locs[node.firstToken()];
|
||||
const last_token = tree.token_locs[node.lastToken()];
|
||||
return source_index >= first_token.start and source_index <= last_token.end;
|
||||
}
|
||||
|
||||
fn nodeComesAfterSourceIndex(tree: *ast.Tree, node: *ast.Node, source_index: usize) bool {
|
||||
const first_token = tree.tokens.at(node.firstToken());
|
||||
const last_token = tree.tokens.at(node.lastToken());
|
||||
const first_token = tree.token_locs[node.firstToken()];
|
||||
const last_token = tree.token_locs[node.lastToken()];
|
||||
return source_index < first_token.start;
|
||||
}
|
||||
|
||||
pub fn getImportStr(tree: *ast.Tree, source_index: usize) ?[]const u8 {
|
||||
var node = &tree.root_node.base;
|
||||
var index: usize = 0;
|
||||
while (node.iterate(index)) |child| {
|
||||
|
||||
var child_it = node.iterate();
|
||||
while (child_it.next()) |child| {
|
||||
if (!nodeContainsSourceIndex(tree, child, source_index)) {
|
||||
index += 1;
|
||||
continue;
|
||||
}
|
||||
if (child.cast(ast.Node.BuiltinCall)) |builtin_call| blk: {
|
||||
const call_name = tree.tokenSlice(builtin_call.builtin_token);
|
||||
|
||||
if (!std.mem.eql(u8, call_name, "@import")) break :blk;
|
||||
if (builtin_call.params.len != 1) break :blk;
|
||||
if (builtin_call.params_len != 1) break :blk;
|
||||
|
||||
const import_param = builtin_call.params.at(0).*;
|
||||
const import_param = builtin_call.paramsConst()[0];
|
||||
const import_str_node = import_param.cast(ast.Node.StringLiteral) orelse break :blk;
|
||||
const import_str = tree.tokenSlice(import_str_node.token);
|
||||
return import_str[1 .. import_str.len - 1];
|
||||
}
|
||||
node = child;
|
||||
index = 0;
|
||||
child_it = node.iterate();
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
34
src/main.zig
34
src/main.zig
@ -100,8 +100,7 @@ fn publishDiagnostics(handle: DocumentStore.Handle, config: Config) !void {
|
||||
|
||||
var diagnostics = std.ArrayList(types.Diagnostic).init(&arena.allocator);
|
||||
|
||||
var error_it = tree.errors.iterator(0);
|
||||
while (error_it.next()) |err| {
|
||||
for (tree.errors) |*err| {
|
||||
const loc = tree.tokenLocation(0, err.loc());
|
||||
|
||||
var mem_buffer: [256]u8 = undefined;
|
||||
@ -119,9 +118,7 @@ fn publishDiagnostics(handle: DocumentStore.Handle, config: Config) !void {
|
||||
}
|
||||
|
||||
if (tree.errors.len == 0) {
|
||||
var decls = tree.root_node.decls.iterator(0);
|
||||
while (decls.next()) |decl_ptr| {
|
||||
var decl = decl_ptr.*;
|
||||
for (tree.root_node.decls()) |decl| {
|
||||
switch (decl.id) {
|
||||
.FnProto => blk: {
|
||||
const func = decl.cast(std.zig.ast.Node.FnProto).?;
|
||||
@ -179,8 +176,8 @@ fn containerToCompletion(
|
||||
container: *std.zig.ast.Node,
|
||||
config: Config,
|
||||
) !void {
|
||||
var index: usize = 0;
|
||||
while (container.iterate(index)) |child_node| : (index += 1) {
|
||||
var child_it = container.iterate();
|
||||
while (child_it.next()) |child_node| {
|
||||
// Declarations in the same file do not need to be public.
|
||||
if (orig_handle == analysis_ctx.handle or analysis.isNodePublic(analysis_ctx.tree, child_node)) {
|
||||
try nodeToCompletion(list, analysis_ctx, orig_handle, child_node, config);
|
||||
@ -229,7 +226,7 @@ fn nodeToCompletion(
|
||||
},
|
||||
.VarDecl => {
|
||||
const var_decl = node.cast(std.zig.ast.Node.VarDecl).?;
|
||||
const is_const = analysis_ctx.tree.tokens.at(var_decl.mut_token).id == .Keyword_const;
|
||||
const is_const = analysis_ctx.tree.token_ids[var_decl.mut_token] == .Keyword_const;
|
||||
|
||||
var child_analysis_context = try analysis_ctx.clone();
|
||||
defer child_analysis_context.deinit();
|
||||
@ -259,16 +256,17 @@ fn nodeToCompletion(
|
||||
.detail = analysis.getVariableSignature(analysis_ctx.tree, var_decl),
|
||||
});
|
||||
},
|
||||
.ParamDecl => {
|
||||
const param = node.cast(std.zig.ast.Node.ParamDecl).?;
|
||||
if (param.name_token) |name_token|
|
||||
try list.append(.{
|
||||
.label = analysis_ctx.tree.tokenSlice(name_token),
|
||||
.kind = .Constant,
|
||||
.documentation = doc,
|
||||
.detail = analysis.getParamSignature(analysis_ctx.tree, param),
|
||||
});
|
||||
},
|
||||
// @TODO: No more ParamDecl node.
|
||||
// .ParamDecl => {
|
||||
// const param = node.cast(std.zig.ast.Node.ParamDecl).?;
|
||||
// if (param.name_token) |name_token|
|
||||
// try list.append(.{
|
||||
// .label = analysis_ctx.tree.tokenSlice(name_token),
|
||||
// .kind = .Constant,
|
||||
// .documentation = doc,
|
||||
// .detail = analysis.getParamSignature(analysis_ctx.tree, param),
|
||||
// });
|
||||
// },
|
||||
.PrefixOp => {
|
||||
try list.append(.{
|
||||
.label = "len",
|
||||
|
||||
Loading…
Reference in New Issue
Block a user