From 965724dd7e08bbe2b94af47efdadf88c470ccb49 Mon Sep 17 00:00:00 2001 From: Alexandros Naskos Date: Sun, 28 Jun 2020 13:58:51 +0300 Subject: [PATCH] Fixed build and crashes with zig master branch: --- src/document_store.zig | 31 ++++++--- src/main.zig | 12 ++-- src/semantic_tokens.zig | 146 ++++++++++++++++++++-------------------- 3 files changed, 99 insertions(+), 90 deletions(-) diff --git a/src/document_store.zig b/src/document_store.zig index 1742af5..2a5d518 100644 --- a/src/document_store.zig +++ b/src/document_store.zig @@ -138,16 +138,20 @@ fn loadPackages(context: LoadPackagesContext) !void { try std.fs.copyFileAbsolute(build_runner_path, target_path, .{}); defer std.fs.deleteFileAbsolute(target_path) catch {}; + // TODO Using the page allocator directly here causes a segfault + var arena = std.heap.ArenaAllocator.init(allocator); + defer arena.deinit(); const zig_run_result = try std.ChildProcess.exec(.{ - .allocator = allocator, + .allocator = &arena.allocator, .argv = &[_][]const u8{ zig_exe_path, "run", "build_runner.zig" }, .cwd = directory_path, }); - defer { - allocator.free(zig_run_result.stdout); - allocator.free(zig_run_result.stderr); - } + // TODO Add those back in when we stop using the arena + // defer { + // allocator.free(zig_run_result.stdout); + // allocator.free(zig_run_result.stderr); + // } switch (zig_run_result.term) { .Exited => |exit_code| { @@ -263,14 +267,19 @@ fn newDocument(self: *DocumentStore, uri: []const u8, text: []u8) anyerror!*Hand if (std.mem.lastIndexOfScalar(u8, curr_path[0 .. curr_path.len - 1], std.fs.path.sep)) |idx| { // This includes the last separator curr_path = curr_path[0 .. idx + 1]; + + var folder = try std.fs.cwd().openDir(curr_path, .{}); + defer folder.close(); + + // Try to open the file, read it and add the new document if we find it. + const build_file_text = folder.readFileAlloc(self.allocator, "build.zig", std.math.maxInt(usize)) catch |err| switch (err) { + error.FileNotFound, error.AccessDenied => continue, + else => return err, + }; + errdefer self.allocator.free(build_file_text); + var candidate_path = try std.mem.concat(self.allocator, u8, &[_][]const u8{ curr_path, "build.zig" }); defer self.allocator.free(candidate_path); - // Try to open the file, read it and add the new document if we find it. - var file = std.fs.cwd().openFile(candidate_path, .{ .read = true, .write = false }) catch continue; - defer file.close(); - - const build_file_text = try file.inStream().readAllAlloc(self.allocator, std.math.maxInt(usize)); - errdefer self.allocator.free(build_file_text); const build_file_uri = try URI.fromPath(self.allocator, candidate_path); errdefer self.allocator.free(build_file_uri); diff --git a/src/main.zig b/src/main.zig index 40c3670..bce110a 100644 --- a/src/main.zig +++ b/src/main.zig @@ -954,16 +954,16 @@ fn loadConfig(folder_path: []const u8) ?Config { var folder = std.fs.cwd().openDir(folder_path, .{}) catch return null; defer folder.close(); - const conf_file = folder.openFile("zls.json", .{}) catch return null; - defer conf_file.close(); - - // Max 1MB - const file_buf = conf_file.reader().readAllAlloc(allocator, 0x1000000) catch return null; + const file_buf = folder.readFileAlloc(allocator, "zls.json", 0x1000000) catch |err| { + if (err != error.FileNotFound) + std.log.debug(.main, "Error while reading configuration file: {}\n", .{err}); + return null; + }; defer allocator.free(file_buf); // TODO: Better errors? Doesn't seem like std.json can provide us positions or context. var config = std.json.parse(Config, &std.json.TokenStream.init(file_buf), std.json.ParseOptions{ .allocator = allocator }) catch |err| { - std.log.debug(.main, "Error while parsing configuration file: {}\nUsing default config.\n", .{err}); + std.log.debug(.main, "Error while parsing configuration file: {}\n", .{err}); return null; }; diff --git a/src/semantic_tokens.zig b/src/semantic_tokens.zig index 1f68f41..d408a26 100644 --- a/src/semantic_tokens.zig +++ b/src/semantic_tokens.zig @@ -202,10 +202,10 @@ fn writeContainerField( if (container_field.doc_comments) |docs| try writeDocComments(builder, builder.handle.tree, docs); try writeToken(builder, container_field.comptime_token, .keyword); if (field_token_type) |tok_type| try writeToken(builder, container_field.name_token, tok_type); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, container_field.type_expr); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, container_field.type_expr}); if (container_field.align_expr) |n| { try writeToken(builder, n.firstToken() - 2, .keyword); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, n); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, n}); } if (container_field.value_expr) |value_expr| block: { @@ -217,7 +217,7 @@ fn writeContainerField( break :block; // Check this, I believe it is correct. try writeToken(builder, eq_tok, .operator); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, value_expr); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, value_expr}); } } @@ -245,7 +245,7 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D if (child.cast(ast.Node.ContainerField)) |container_field| { try writeContainerField(builder, arena, store, container_field, .field, child_frame); } else { - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, child); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, child}); } } try gap_highlighter.end(node.lastToken()); @@ -263,24 +263,24 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D } else { try writeTokenMod(builder, var_decl.name_token, .variable, .{ .definition = true }); } - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, var_decl.type_node); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, var_decl.align_node); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, var_decl.section_node); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, var_decl.type_node}); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, var_decl.align_node}); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, var_decl.section_node}); try writeToken(builder, var_decl.eq_token, .operator); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, var_decl.init_node); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, var_decl.init_node}); }, .Use => { const use = node.cast(ast.Node.Use).?; if (use.doc_comments) |docs| try writeDocComments(builder, builder.handle.tree, docs); try writeToken(builder, use.visib_token, .keyword); try writeToken(builder, use.use_token, .keyword); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, use.expr); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, use.expr}); }, .ErrorSetDecl => { const error_set = node.cast(ast.Node.ErrorSetDecl).?; try writeToken(builder, error_set.error_token, .keyword); for (error_set.declsConst()) |decl| - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, decl); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, decl}); }, .ContainerDecl => { const container_decl = node.cast(ast.Node.ContainerDecl).?; @@ -289,10 +289,10 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D switch (container_decl.init_arg_expr) { .None => {}, .Enum => |enum_expr| if (enum_expr) |expr| - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, expr) + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, expr}) else try writeToken(builder, container_decl.kind_token + 2, .keyword), - .Type => |type_node| try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, type_node), + .Type => |type_node| try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, type_node}), } var gap_highlighter = GapHighlighter.init(builder, container_decl.lbrace_token + 1); @@ -302,7 +302,7 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D if (child.cast(ast.Node.ContainerField)) |container_field| { try writeContainerField(builder, arena, store, container_field, field_token_type, child_frame); } else { - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, child); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, child}); } } try gap_highlighter.end(node.lastToken()); @@ -334,7 +334,7 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D if (fn_proto.doc_comments) |docs| try writeDocComments(builder, handle.tree, docs); try writeToken(builder, fn_proto.visib_token, .keyword); try writeToken(builder, fn_proto.extern_export_inline_token, .keyword); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, fn_proto.lib_name); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, fn_proto.lib_name}); try writeToken(builder, fn_proto.fn_token, .keyword); const func_name_tok_type: TokenType = if (analysis.isTypeFunction(handle.tree, fn_proto)) @@ -357,47 +357,47 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D switch (param_decl.param_type) { .var_type => |var_node| try writeToken(builder, var_node.firstToken(), .type), .var_args => |var_args_tok| try writeToken(builder, var_args_tok, .operator), - .type_expr => |type_expr| try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, type_expr), + .type_expr => |type_expr| try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, type_expr}), } } - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, fn_proto.align_expr); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, fn_proto.section_expr); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, fn_proto.callconv_expr); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, fn_proto.align_expr}); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, fn_proto.section_expr}); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, fn_proto.callconv_expr}); switch (fn_proto.return_type) { - .Explicit => |type_expr| try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, type_expr), + .Explicit => |type_expr| try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, type_expr}), .InferErrorSet => |type_expr| { try writeToken(builder, type_expr.firstToken() - 1, .operator); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, type_expr); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, type_expr}); }, .Invalid => {}, } - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, fn_proto.body_node); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, fn_proto.body_node}); }, .AnyFrameType => { const any_frame_type = node.cast(ast.Node.AnyFrameType).?; try writeToken(builder, any_frame_type.anyframe_token, .type); if (any_frame_type.result) |any_frame_result| { try writeToken(builder, any_frame_result.arrow_token, .type); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, any_frame_result.return_type); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, any_frame_result.return_type}); } }, .Defer => { const defer_node = node.cast(ast.Node.Defer).?; try writeToken(builder, defer_node.defer_token, .keyword); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, defer_node.payload); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, defer_node.expr); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, defer_node.payload}); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, defer_node.expr}); }, .Comptime => { const comptime_node = node.cast(ast.Node.Comptime).?; if (comptime_node.doc_comments) |docs| try writeDocComments(builder, handle.tree, docs); try writeToken(builder, comptime_node.comptime_token, .keyword); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, comptime_node.expr); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, comptime_node.expr}); }, .Nosuspend => { const nosuspend_node = node.cast(ast.Node.Nosuspend).?; try writeToken(builder, nosuspend_node.nosuspend_token, .keyword); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, nosuspend_node.expr); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, nosuspend_node.expr}); }, .Payload => { const payload = node.cast(ast.Node.Payload).?; @@ -423,27 +423,27 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D .Else => { const else_node = node.cast(ast.Node.Else).?; try writeToken(builder, else_node.else_token, .keyword); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, else_node.payload); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, else_node.body); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, else_node.payload}); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, else_node.body}); }, .Switch => { const switch_node = node.cast(ast.Node.Switch).?; try writeToken(builder, switch_node.switch_token, .keyword); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, switch_node.expr); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, switch_node.expr}); var gap_highlighter = GapHighlighter.init(builder, switch_node.expr.lastToken() + 3); for (switch_node.casesConst()) |case_node| { try gap_highlighter.next(case_node); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, case_node); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, case_node}); } try gap_highlighter.end(node.lastToken()); }, .SwitchCase => { const switch_case = node.cast(ast.Node.SwitchCase).?; - for (switch_case.itemsConst()) |item_node| try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, item_node); + for (switch_case.itemsConst()) |item_node| try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, item_node}); try writeToken(builder, switch_case.arrow_token, .operator); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, switch_case.payload); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, switch_case.expr); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, switch_case.payload}); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, switch_case.expr}); }, .SwitchElse => { const switch_else = node.cast(ast.Node.SwitchElse).?; @@ -454,36 +454,36 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D try writeToken(builder, while_node.label, .label); try writeToken(builder, while_node.inline_token, .keyword); try writeToken(builder, while_node.while_token, .keyword); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, while_node.condition); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, while_node.payload); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, while_node.continue_expr); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, while_node.body); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, while_node.condition}); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, while_node.payload}); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, while_node.continue_expr}); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, while_node.body}); if (while_node.@"else") |else_node| - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, &else_node.base); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, &else_node.base}); }, .For => { const for_node = node.cast(ast.Node.For).?; try writeToken(builder, for_node.label, .label); try writeToken(builder, for_node.inline_token, .keyword); try writeToken(builder, for_node.for_token, .keyword); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, for_node.array_expr); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, for_node.payload); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, for_node.body); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, for_node.array_expr}); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, for_node.payload}); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, for_node.body}); if (for_node.@"else") |else_node| - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, &else_node.base); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, &else_node.base}); }, .If => { const if_node = node.cast(ast.Node.If).?; try writeToken(builder, if_node.if_token, .keyword); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, if_node.condition); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, if_node.payload); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, if_node.body); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, if_node.condition}); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, if_node.payload}); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, if_node.body}); if (if_node.@"else") |else_node| - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, &else_node.base); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, &else_node.base}); }, .InfixOp => { const infix_op = node.cast(ast.Node.InfixOp).?; - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, infix_op.lhs); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, infix_op.lhs}); if (infix_op.op != .Period and infix_op.op != .Catch) { const token_type: TokenType = switch (infix_op.op) { .BoolAnd, .BoolOr, .UnwrapOptional => .keyword, @@ -491,13 +491,13 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D }; try writeToken(builder, infix_op.op_token, token_type); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, infix_op.rhs); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, infix_op.rhs}); } switch (infix_op.op) { .Catch => |n| { try writeToken(builder, infix_op.op_token, .keyword); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, n); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, infix_op.rhs); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, n}); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, infix_op.rhs}); }, .Period => { const rhs_str = handle.tree.tokenSlice(infix_op.rhs.firstToken()); @@ -556,7 +556,7 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D switch (prefix_op.op) { .ArrayType => |info| { - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, info.len_expr); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, info.len_expr}); }, .SliceType, .PtrType => |info| { if (prefix_op.op == .PtrType) try writeToken(builder, prefix_op.op_token, tok_type); @@ -567,7 +567,7 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D } else { try writeToken(builder, prefix_op.op_token + 2, .keyword); } - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, align_info.node); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, align_info.node}); } try writeToken(builder, info.const_token, .keyword); try writeToken(builder, info.volatile_token, .keyword); @@ -576,20 +576,20 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D else => try writeToken(builder, prefix_op.op_token, tok_type), } - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, prefix_op.rhs); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, prefix_op.rhs}); }, .ArrayInitializer => { const array_initializer = node.cast(ast.Node.ArrayInitializer).?; - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, array_initializer.lhs); - for (array_initializer.listConst()) |elem| try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, elem); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, array_initializer.lhs}); + for (array_initializer.listConst()) |elem| try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, elem}); }, .ArrayInitializerDot => { const array_initializer = node.cast(ast.Node.ArrayInitializerDot).?; - for (array_initializer.listConst()) |elem| try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, elem); + for (array_initializer.listConst()) |elem| try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, elem}); }, .StructInitializer => { const struct_initializer = node.cast(ast.Node.StructInitializer).?; - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, struct_initializer.lhs); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, struct_initializer.lhs}); const field_token_type = if (try analysis.resolveTypeOfNode(store, arena, .{ .node = struct_initializer.lhs, .handle = handle })) |struct_type| switch (struct_type.type.data) { .other => |type_node| if (type_node.cast(ast.Node.ContainerDecl)) |container_decl| fieldTokenType(container_decl, handle) @@ -608,7 +608,7 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D try writeToken(builder, field_init.name_token, tok_type); } try writeToken(builder, field_init.name_token + 1, .operator); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, field_init.expr); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, field_init.expr}); } try gap_highlighter.end(struct_initializer.rtoken); }, @@ -623,40 +623,40 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D try writeToken(builder, field_init.period_token, .field); try writeToken(builder, field_init.name_token, .field); try writeToken(builder, field_init.name_token + 1, .operator); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, field_init.expr); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, field_init.expr}); } try gap_highlighter.end(struct_initializer.rtoken); }, .Call => { const call = node.cast(ast.Node.Call).?; try writeToken(builder, call.async_token, .keyword); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, call.lhs); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, call.lhs}); if (builder.current_token) |curr_tok| { if (curr_tok != call.lhs.lastToken() and handle.tree.token_ids[call.lhs.lastToken()] == .Identifier) { try writeToken(builder, call.lhs.lastToken(), .function); } } - for (call.paramsConst()) |param| try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, param); + for (call.paramsConst()) |param| try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, param}); }, .SuffixOp => { const suffix_op = node.cast(ast.Node.SuffixOp).?; - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, suffix_op.lhs); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, suffix_op.lhs}); switch (suffix_op.op) { .ArrayAccess => |n| { - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, n); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, n}); }, .Slice => |s| { - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, s.start); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, s.start}); try writeToken(builder, s.start.lastToken() + 1, .operator); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, s.end); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, s.sentinel); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, s.end}); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, s.sentinel}); }, else => try writeToken(builder, suffix_op.rtoken, .operator), } }, .GroupedExpression => { const grouped_expr = node.cast(ast.Node.GroupedExpression).?; - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, grouped_expr.expr); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, grouped_expr.expr}); }, .ControlFlowExpression => { const cfe = node.cast(ast.Node.ControlFlowExpression).?; @@ -666,12 +666,12 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D .Continue => |label| if (label) |n| try writeToken(builder, n.firstToken(), .label), else => {}, } - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, cfe.rhs); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, cfe.rhs}); }, .Suspend => { const suspend_node = node.cast(ast.Node.Suspend).?; try writeToken(builder, suspend_node.suspend_token, .keyword); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, suspend_node.body); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, suspend_node.body}); }, .IntegerLiteral => { try writeToken(builder, node.firstToken(), .number); @@ -688,7 +688,7 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D const builtin_call = node.cast(ast.Node.BuiltinCall).?; try writeToken(builder, builtin_call.builtin_token, .builtin); for (builtin_call.paramsConst()) |param| - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, param); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, param}); }, .StringLiteral, .CharLiteral => { try writeToken(builder, node.firstToken(), .string); @@ -704,7 +704,7 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D const asm_expr = node.cast(ast.Node.Asm).?; try writeToken(builder, asm_expr.asm_token, .keyword); try writeToken(builder, asm_expr.volatile_token, .keyword); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, asm_expr.template); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, asm_expr.template}); // TODO Inputs, outputs. }, .VarType => { @@ -714,8 +714,8 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D const test_decl = node.cast(ast.Node.TestDecl).?; if (test_decl.doc_comments) |doc| try writeDocComments(builder, handle.tree, doc); try writeToken(builder, test_decl.test_token, .keyword); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, test_decl.name); - try await @asyncCall(child_frame, {}, writeNodeTokens, builder, arena, store, test_decl.body_node); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, test_decl.name}); + try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, test_decl.body_node}); }, else => {}, }