From 6e8165804f7661bf84f091dc423b7af2ab2c6690 Mon Sep 17 00:00:00 2001 From: Vexu Date: Sun, 17 May 2020 17:23:04 +0300 Subject: [PATCH] add completion for arrays and slices --- src/analysis.zig | 77 ++++++++++++++++++++++----------------- src/main.zig | 93 +++++++++++++++++++++++++++--------------------- 2 files changed, 97 insertions(+), 73 deletions(-) diff --git a/src/analysis.zig b/src/analysis.zig index e6aaadb..91a2f00 100644 --- a/src/analysis.zig +++ b/src/analysis.zig @@ -12,7 +12,7 @@ pub fn getFunctionByName(tree: *ast.Tree, name: []const u8) ?*ast.Node.FnProto { const func = decl.cast(ast.Node.FnProto).?; if (std.mem.eql(u8, tree.tokenSlice(func.name_token.?), name)) return func; }, - else => {} + else => {}, } } @@ -55,9 +55,9 @@ pub fn getDocComments(allocator: *std.mem.Allocator, tree: *ast.Tree, node: *ast const param = node.cast(ast.Node.ParamDecl).?; if (param.doc_comments) |doc_comments| { return try collectDocComments(allocator, tree, doc_comments); - } + } }, - else => {} + else => {}, } return null; } @@ -102,8 +102,7 @@ pub fn getFunctionSnippet(allocator: *std.mem.Allocator, tree: *ast.Tree, func: const param = param_ptr.*; const param_decl = param.cast(ast.Node.ParamDecl).?; - if (param_num != 1) try buffer.appendSlice(", ${") - else try buffer.appendSlice("${"); + if (param_num != 1) try buffer.appendSlice(", ${") else try buffer.appendSlice("${"); try buf_stream.print("{}:", .{param_num}); @@ -135,7 +134,7 @@ pub fn getFunctionSnippet(allocator: *std.mem.Allocator, tree: *ast.Tree, func: try buffer.appendSlice(tree.tokenSlice(curr_tok)); if (is_comma or id == .Keyword_const) try buffer.append(' '); } - } + }, } try buffer.append('}'); @@ -159,6 +158,16 @@ pub fn getParamSignature(tree: *ast.Tree, param: *ast.Node.ParamDecl) []const u8 return tree.source[start..end]; } +pub fn isTypeFunction(tree: *ast.Tree, func: *ast.Node.FnProto) bool { + switch (func.return_type) { + .Explicit => |node| return if (node.cast(std.zig.ast.Node.Identifier)) |ident| + std.mem.eql(u8, tree.tokenSlice(ident.token), "type") + else + false, + .InferErrorSet, .Invalid => return false, + } +} + // STYLE pub fn isCamelCase(name: []const u8) bool { @@ -188,7 +197,7 @@ pub fn getChild(tree: *ast.Tree, node: *ast.Node, name: []const u8) ?*ast.Node { const field = child.cast(ast.Node.ContainerField).?; if (std.mem.eql(u8, tree.tokenSlice(field.name_token), name)) return child; }, - else => {} + else => {}, } index += 1; } @@ -216,7 +225,7 @@ pub fn getChildOfSlice(tree: *ast.Tree, nodes: []*ast.Node, name: []const u8) ?* const field = child.cast(ast.Node.ContainerField).?; if (std.mem.eql(u8, tree.tokenSlice(field.name_token), name)) return child; }, - else => {} + else => {}, } // index += 1; } @@ -237,7 +246,7 @@ pub fn resolveTypeOfNode(analysis_ctx: *AnalysisContext, node: *ast.Node) ?*ast. .var_type, .type_expr => |var_type| { return resolveTypeOfNode(analysis_ctx, var_type) orelse null; }, - else => {} + else => {}, } }, .FnProto => { @@ -270,7 +279,7 @@ pub fn resolveTypeOfNode(analysis_ctx: *AnalysisContext, node: *ast.Node) ?*ast. .Call, .StructInitializer => { return resolveTypeOfNode(analysis_ctx, suffix_op.lhs.node); }, - else => {} + else => {}, } }, .InfixOp => { @@ -285,16 +294,22 @@ pub fn resolveTypeOfNode(analysis_ctx: *AnalysisContext, node: *ast.Node) ?*ast. const left = resolveTypeOfNode(analysis_ctx, infix_op.lhs) orelse return null; return resolveTypeOfNode(analysis_ctx, getChild(analysis_ctx.tree, left, rhs_str) orelse return null); }, - else => {} + else => {}, } }, .PrefixOp => { const prefix_op = node.cast(ast.Node.PrefixOp).?; switch (prefix_op.op) { + .SliceType, .ArrayType => return node, .PtrType => { - return resolveTypeOfNode(analysis_ctx, prefix_op.rhs); + const op_token = analysis_ctx.tree.tokens.at(prefix_op.op_token); + switch (op_token.id) { + .Asterisk => return resolveTypeOfNode(analysis_ctx, prefix_op.rhs), + .LBracket, .AsteriskAsterisk => return null, + else => unreachable, + } }, - else => {} + else => {}, } }, .BuiltinCall => { @@ -307,13 +322,16 @@ pub fn resolveTypeOfNode(analysis_ctx: *AnalysisContext, node: *ast.Node) ?*ast. const import_str = analysis_ctx.tree.tokenSlice(import_param.cast(ast.Node.StringLiteral).?.token); return analysis_ctx.onImport(import_str[1 .. import_str.len - 1]) catch |err| block: { - std.debug.warn("Error {} while processing import {}\n", .{err, import_str}); + std.debug.warn("Error {} while processing import {}\n", .{ err, import_str }); break :block null; }; }, + .MultilineStringLiteral, .StringLiteral => { + return node; + }, else => { std.debug.warn("Type resolution case not implemented; {}\n", .{node.id}); - } + }, } return null; } @@ -340,16 +358,16 @@ pub fn collectImports(allocator: *std.mem.Allocator, tree: *ast.Tree) ![][]const if (decl.id != .VarDecl) continue; const var_decl = decl.cast(ast.Node.VarDecl).?; if (var_decl.init_node == null) continue; - - switch(var_decl.init_node.?.id) { + + switch (var_decl.init_node.?.id) { .BuiltinCall => { const builtin_call = var_decl.init_node.?.cast(ast.Node.BuiltinCall).?; try maybeCollectImport(tree, builtin_call, &arr); }, .InfixOp => { const infix_op = var_decl.init_node.?.cast(ast.Node.InfixOp).?; - - switch(infix_op.op) { + + switch (infix_op.op) { .Period => {}, else => continue, } @@ -395,7 +413,7 @@ pub fn getFieldAccessTypeNode(analysis_ctx: *AnalysisContext, tokenizer: *std.zi }, else => { std.debug.warn("Not implemented; {}\n", .{next.id}); - } + }, } } @@ -412,15 +430,8 @@ pub fn isNodePublic(tree: *ast.Tree, node: *ast.Node) bool { const func = node.cast(ast.Node.FnProto).?; return func.visib_token != null; }, - .ContainerField, .ErrorTag => { - return true; - }, - else => { - return false; - } + else => return true, } - - return false; } pub fn nodeToString(tree: *ast.Tree, node: *ast.Node) ?[]const u8 { @@ -445,9 +456,9 @@ pub fn nodeToString(tree: *ast.Tree, node: *ast.Node) ?[]const u8 { }, else => { std.debug.warn("INVALID: {}\n", .{node.id}); - } + }, } - + return null; } @@ -461,7 +472,7 @@ pub fn declsFromIndexInternal(allocator: *std.mem.Allocator, tree: *ast.Tree, no try declsFromIndexInternal(allocator, tree, func.params.at(param_index).*, nodes); if (func.body_node) |body_node| - try declsFromIndexInternal(allocator, tree, body_node, nodes); + try declsFromIndexInternal(allocator, tree, body_node, nodes); }, .Block => { var index: usize = 0; @@ -479,7 +490,7 @@ pub fn declsFromIndexInternal(allocator: *std.mem.Allocator, tree: *ast.Tree, no }, else => { try nodes.appendSlice(try getCompletionsFromNode(allocator, tree, node)); - } + }, } } @@ -489,7 +500,7 @@ pub fn getCompletionsFromNode(allocator: *std.mem.Allocator, tree: *ast.Tree, no var index: usize = 0; while (node.iterate(index)) |child_node| { try nodes.append(child_node); - + index += 1; } diff --git a/src/main.zig b/src/main.zig index 380f7e5..739b06a 100644 --- a/src/main.zig +++ b/src/main.zig @@ -142,13 +142,7 @@ fn publishDiagnostics(handle: DocumentStore.Handle, config: Config) !void { if (func.name_token) |name_token| { const loc = tree.tokenLocation(0, name_token); - const is_type_function = switch (func.return_type) { - .Explicit => |node| if (node.cast(std.zig.ast.Node.Identifier)) |ident| - std.mem.eql(u8, tree.tokenSlice(ident.token), "type") - else - false, - .InferErrorSet, .Invalid => false, - }; + const is_type_function = analysis.isTypeFunction(tree, func); const func_name = tree.tokenSlice(name_token); if (!is_type_function and !analysis.isCamelCase(func_name)) { @@ -187,8 +181,17 @@ fn publishDiagnostics(handle: DocumentStore.Handle, config: Config) !void { }); } -fn nodeToCompletion(alloc: *std.mem.Allocator, tree: *std.zig.ast.Tree, decl: *std.zig.ast.Node, config: Config) !?types.CompletionItem { - var doc = if (try analysis.getDocComments(alloc, tree, decl)) |doc_comments| +fn containerToCompletion(list: *std.ArrayList(types.CompletionItem), tree: *std.zig.ast.Tree, container: *std.zig.ast.Node, config: Config) !void { + var index: usize = 0; + while (container.iterate(index)) |child_node| : (index+=1) { + if (analysis.isNodePublic(tree, child_node)) { + try nodeToCompletion(list, tree, child_node, config); + } + } +} + +fn nodeToCompletion(list: *std.ArrayList(types.CompletionItem), tree: *std.zig.ast.Tree, node: *std.zig.ast.Node, config: Config) error{OutOfMemory}!void { + var doc = if (try analysis.getDocComments(list.allocator, tree, node)) |doc_comments| types.MarkupContent{ .kind = .Markdown, .value = doc_comments, @@ -196,54 +199,74 @@ fn nodeToCompletion(alloc: *std.mem.Allocator, tree: *std.zig.ast.Tree, decl: *s else null; - switch (decl.id) { + switch (node.id) { + .ErrorSetDecl, .Root, .ContainerDecl => { + try containerToCompletion(list, tree, node, config); + }, .FnProto => { - const func = decl.cast(std.zig.ast.Node.FnProto).?; + const func = node.cast(std.zig.ast.Node.FnProto).?; if (func.name_token) |name_token| { const insert_text = if (config.enable_snippets) - try analysis.getFunctionSnippet(alloc, tree, func) + try analysis.getFunctionSnippet(list.allocator, tree, func) else null; - return types.CompletionItem{ + const is_type_function = analysis.isTypeFunction(tree, func); + + try list.append(.{ .label = tree.tokenSlice(name_token), - .kind = .Function, + .kind = if (is_type_function) .Struct else .Function, .documentation = doc, .detail = analysis.getFunctionSignature(tree, func), .insertText = insert_text, .insertTextFormat = if (config.enable_snippets) .Snippet else .PlainText, - }; + }); } }, .VarDecl => { - const var_decl = decl.cast(std.zig.ast.Node.VarDecl).?; - return types.CompletionItem{ + const var_decl = node.cast(std.zig.ast.Node.VarDecl).?; + const is_const = tree.tokens.at(var_decl.mut_token).id == .Keyword_const; + try list.append(.{ .label = tree.tokenSlice(var_decl.name_token), - .kind = .Variable, + .kind = if (is_const) .Constant else .Variable, .documentation = doc, .detail = analysis.getVariableSignature(tree, var_decl), - }; + }); }, .ParamDecl => { - const param = decl.cast(std.zig.ast.Node.ParamDecl).?; + const param = node.cast(std.zig.ast.Node.ParamDecl).?; if (param.name_token) |name_token| - return types.CompletionItem{ + try list.append(.{ .label = tree.tokenSlice(name_token), - .kind = .Variable, + .kind = .Constant, .documentation = doc, .detail = analysis.getParamSignature(tree, param), - }; + }); }, - else => if (analysis.nodeToString(tree, decl)) |string| { - return types.CompletionItem{ + .PrefixOp => { + try list.append(.{ + .label = "len", + .kind = .Field, + }); + try list.append(.{ + .label = "ptr", + .kind = .Field, + }); + }, + .StringLiteral => { + try list.append(.{ + .label = "len", + .kind = .Field, + }); + }, + else => if (analysis.nodeToString(tree, node)) |string| { + try list.append(.{ .label = string, .kind = .Field, .documentation = doc, - }; + }); }, } - - return null; } fn completeGlobal(id: i64, pos_index: usize, handle: DocumentStore.Handle, config: Config) !void { @@ -260,9 +283,7 @@ fn completeGlobal(id: i64, pos_index: usize, handle: DocumentStore.Handle, confi var decls = try analysis.declsFromIndex(&arena.allocator, tree, pos_index); for (decls) |decl_ptr| { var decl = decl_ptr.*; - if (try nodeToCompletion(&arena.allocator, tree, decl_ptr, config)) |completion| { - try completions.append(completion); - } + try nodeToCompletion(&completions, tree, decl_ptr, config); } try send(types.Response{ @@ -290,15 +311,7 @@ fn completeFieldAccess(id: i64, handle: *DocumentStore.Handle, position: types.P // var decls = try analysis.declsFromIndex(&arena.allocator, analysis_ctx.tree, try handle.document.positionToIndex(position)); if (analysis.getFieldAccessTypeNode(&analysis_ctx, &tokenizer)) |node| { - var index: usize = 0; - while (node.iterate(index)) |child_node| { - if (analysis.isNodePublic(analysis_ctx.tree, child_node)) { - if (try nodeToCompletion(&arena.allocator, analysis_ctx.tree, child_node, config)) |completion| { - try completions.append(completion); - } - } - index += 1; - } + try nodeToCompletion(&completions, analysis_ctx.tree, node, config); } try send(types.Response{