andr3/zls
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

zig fmt pass, correctly return after sending formatting result

Browse Source
This commit is contained in:
Alexandros Naskos 2020-07-03 12:24:24 +03:00
parent f6df9d4c0a
commit 28b3cafc3f
3 changed files with 79 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/main.zig
View File

@ -1009,9 +1009,8 @@ fn initializeHandler(arena: *std.heap.ArenaAllocator, id: types.RequestId, req:
try respondGeneric(id, initialize_response); try respondGeneric(id, initialize_response);
} else { } else {
const response_str = try std.fmt.allocPrint(&arena.allocator, ",\"result\": {{\"offsetEncoding\":\"{}\",{}", .{ const response_str = try std.fmt.allocPrint(&arena.allocator, ",\"result\": {{\"offsetEncoding\":\"{}\",{}", .{
if (offset_encoding == .utf8) @as([]const u8, "utf-8") if (offset_encoding == .utf8) @as([]const u8, "utf-8") else @as([]const u8, "utf-16"),
else @as([]const u8, "utf-16"), initialize_capabilities,
initialize_capabilities
}); });
try respondGeneric(id, response_str); try respondGeneric(id, response_str);
} }
@ -1241,7 +1240,7 @@ fn formattingHandler(arena: *std.heap.ArenaAllocator, id: types.RequestId, req:
switch (try process.wait()) { switch (try process.wait()) {
.Exited => |code| if (code == 0) { .Exited => |code| if (code == 0) {
try send(arena, types.Response{ return try send(arena, types.Response{
.id = id, .id = id,
.result = .{ .result = .{
.TextEdits = &[1]types.TextEdit{ .TextEdits = &[1]types.TextEdit{

4
src/offsets.zig
View File

@ -77,7 +77,7 @@ pub fn tokenRelativeLocation(tree: *std.zig.ast.Tree, start_index: usize, token:
} else { } else {
if (encoding == .utf16) { if (encoding == .utf16) {
const n = try std.unicode.utf8ByteSequenceLength(c); const n = try std.unicode.utf8ByteSequenceLength(c);
const codepoint = try std.unicode.utf8Decode(source[i..i + n]); const codepoint = try std.unicode.utf8Decode(source[i .. i + n]);
if (codepoint < 0x10000) { if (codepoint < 0x10000) {
loc.column += 1; loc.column += 1;
} else { } else {
@ -103,7 +103,7 @@ pub fn tokenLength(tree: *std.zig.ast.Tree, token: std.zig.ast.TokenIndex, encod
var utf16_len: usize = 0; var utf16_len: usize = 0;
while (i < token_loc.end) { while (i < token_loc.end) {
const n = std.unicode.utf8ByteSequenceLength(tree.source[i]) catch unreachable; const n = std.unicode.utf8ByteSequenceLength(tree.source[i]) catch unreachable;
const codepoint = std.unicode.utf8Decode(tree.source[i..i + n]) catch unreachable; const codepoint = std.unicode.utf8Decode(tree.source[i .. i + n]) catch unreachable;
if (codepoint < 0x10000) { if (codepoint < 0x10000) {
utf16_len += 1; utf16_len += 1;
} else { } else {

148
src/semantic_tokens.zig
View File

@ -203,10 +203,10 @@ fn writeContainerField(
if (container_field.doc_comments) |docs| try writeDocComments(builder, builder.handle.tree, docs); if (container_field.doc_comments) |docs| try writeDocComments(builder, builder.handle.tree, docs);
try writeToken(builder, container_field.comptime_token, .keyword); try writeToken(builder, container_field.comptime_token, .keyword);
if (field_token_type) |tok_type| try writeToken(builder, container_field.name_token, tok_type); 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| { if (container_field.align_expr) |n| {
try writeToken(builder, n.firstToken() - 2, .keyword); 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: { if (container_field.value_expr) |value_expr| block: {
@ -218,7 +218,7 @@ fn writeContainerField(
break :block; // Check this, I believe it is correct. break :block; // Check this, I believe it is correct.
try writeToken(builder, eq_tok, .operator); 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 });
} }
} }
@ -246,7 +246,7 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
if (child.cast(ast.Node.ContainerField)) |container_field| { if (child.cast(ast.Node.ContainerField)) |container_field| {
try writeContainerField(builder, arena, store, container_field, .field, child_frame); try writeContainerField(builder, arena, store, container_field, .field, child_frame);
} else { } 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()); try gap_highlighter.end(node.lastToken());
@ -264,24 +264,24 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
} else { } else {
try writeTokenMod(builder, var_decl.name_token, .variable, .{ .definition = true }); 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.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.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.section_node });
try writeToken(builder, var_decl.eq_token, .operator); 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 => { .Use => {
const use = node.cast(ast.Node.Use).?; const use = node.cast(ast.Node.Use).?;
if (use.doc_comments) |docs| try writeDocComments(builder, builder.handle.tree, docs); if (use.doc_comments) |docs| try writeDocComments(builder, builder.handle.tree, docs);
try writeToken(builder, use.visib_token, .keyword); try writeToken(builder, use.visib_token, .keyword);
try writeToken(builder, use.use_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 => { .ErrorSetDecl => {
const error_set = node.cast(ast.Node.ErrorSetDecl).?; const error_set = node.cast(ast.Node.ErrorSetDecl).?;
try writeToken(builder, error_set.error_token, .keyword); try writeToken(builder, error_set.error_token, .keyword);
for (error_set.declsConst()) |decl| 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 => { .ContainerDecl => {
const container_decl = node.cast(ast.Node.ContainerDecl).?; const container_decl = node.cast(ast.Node.ContainerDecl).?;
@ -290,10 +290,10 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
switch (container_decl.init_arg_expr) { switch (container_decl.init_arg_expr) {
.None => {}, .None => {},
.Enum => |enum_expr| if (enum_expr) |expr| .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 else
try writeToken(builder, container_decl.kind_token + 2, .keyword), 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); var gap_highlighter = GapHighlighter.init(builder, container_decl.lbrace_token + 1);
@ -303,7 +303,7 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
if (child.cast(ast.Node.ContainerField)) |container_field| { if (child.cast(ast.Node.ContainerField)) |container_field| {
try writeContainerField(builder, arena, store, container_field, field_token_type, child_frame); try writeContainerField(builder, arena, store, container_field, field_token_type, child_frame);
} else { } 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()); try gap_highlighter.end(node.lastToken());
@ -335,7 +335,7 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
if (fn_proto.doc_comments) |docs| try writeDocComments(builder, handle.tree, docs); 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.visib_token, .keyword);
try writeToken(builder, fn_proto.extern_export_inline_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); try writeToken(builder, fn_proto.fn_token, .keyword);
const func_name_tok_type: TokenType = if (analysis.isTypeFunction(handle.tree, fn_proto)) const func_name_tok_type: TokenType = if (analysis.isTypeFunction(handle.tree, fn_proto))
@ -358,47 +358,47 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
switch (param_decl.param_type) { switch (param_decl.param_type) {
.var_type => |var_node| try writeToken(builder, var_node.firstToken(), .type), .var_type => |var_node| try writeToken(builder, var_node.firstToken(), .type),
.var_args => |var_args_tok| try writeToken(builder, var_args_tok, .operator), .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.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.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.callconv_expr });
switch (fn_proto.return_type) { 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| { .InferErrorSet => |type_expr| {
try writeToken(builder, type_expr.firstToken() - 1, .operator); 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 => {}, .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 => { .AnyFrameType => {
const any_frame_type = node.cast(ast.Node.AnyFrameType).?; const any_frame_type = node.cast(ast.Node.AnyFrameType).?;
try writeToken(builder, any_frame_type.anyframe_token, .type); try writeToken(builder, any_frame_type.anyframe_token, .type);
if (any_frame_type.result) |any_frame_result| { if (any_frame_type.result) |any_frame_result| {
try writeToken(builder, any_frame_result.arrow_token, .type); 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 => { .Defer => {
const defer_node = node.cast(ast.Node.Defer).?; const defer_node = node.cast(ast.Node.Defer).?;
try writeToken(builder, defer_node.defer_token, .keyword); 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.payload });
try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, defer_node.expr}); try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, defer_node.expr });
}, },
.Comptime => { .Comptime => {
const comptime_node = node.cast(ast.Node.Comptime).?; const comptime_node = node.cast(ast.Node.Comptime).?;
if (comptime_node.doc_comments) |docs| try writeDocComments(builder, handle.tree, docs); if (comptime_node.doc_comments) |docs| try writeDocComments(builder, handle.tree, docs);
try writeToken(builder, comptime_node.comptime_token, .keyword); 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 => { .Nosuspend => {
const nosuspend_node = node.cast(ast.Node.Nosuspend).?; const nosuspend_node = node.cast(ast.Node.Nosuspend).?;
try writeToken(builder, nosuspend_node.nosuspend_token, .keyword); 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 => { .Payload => {
const payload = node.cast(ast.Node.Payload).?; const payload = node.cast(ast.Node.Payload).?;
@ -424,27 +424,27 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
.Else => { .Else => {
const else_node = node.cast(ast.Node.Else).?; const else_node = node.cast(ast.Node.Else).?;
try writeToken(builder, else_node.else_token, .keyword); 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.payload });
try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, else_node.body}); try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, else_node.body });
}, },
.Switch => { .Switch => {
const switch_node = node.cast(ast.Node.Switch).?; const switch_node = node.cast(ast.Node.Switch).?;
try writeToken(builder, switch_node.switch_token, .keyword); 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); var gap_highlighter = GapHighlighter.init(builder, switch_node.expr.lastToken() + 3);
for (switch_node.casesConst()) |case_node| { for (switch_node.casesConst()) |case_node| {
try gap_highlighter.next(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()); try gap_highlighter.end(node.lastToken());
}, },
.SwitchCase => { .SwitchCase => {
const switch_case = node.cast(ast.Node.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 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.payload });
try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, switch_case.expr}); try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, switch_case.expr });
}, },
.SwitchElse => { .SwitchElse => {
const switch_else = node.cast(ast.Node.SwitchElse).?; const switch_else = node.cast(ast.Node.SwitchElse).?;
@ -455,36 +455,36 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
try writeToken(builder, while_node.label, .label); try writeToken(builder, while_node.label, .label);
try writeToken(builder, while_node.inline_token, .keyword); try writeToken(builder, while_node.inline_token, .keyword);
try writeToken(builder, while_node.while_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.condition });
try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, while_node.payload}); 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.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.body });
if (while_node.@"else") |else_node| 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 => { .For => {
const for_node = node.cast(ast.Node.For).?; const for_node = node.cast(ast.Node.For).?;
try writeToken(builder, for_node.label, .label); try writeToken(builder, for_node.label, .label);
try writeToken(builder, for_node.inline_token, .keyword); try writeToken(builder, for_node.inline_token, .keyword);
try writeToken(builder, for_node.for_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.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.payload });
try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, for_node.body}); try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, for_node.body });
if (for_node.@"else") |else_node| 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 => { .If => {
const if_node = node.cast(ast.Node.If).?; const if_node = node.cast(ast.Node.If).?;
try writeToken(builder, if_node.if_token, .keyword); 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.condition });
try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, if_node.payload}); 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.body });
if (if_node.@"else") |else_node| 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 => { .InfixOp => {
const infix_op = node.cast(ast.Node.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) { if (infix_op.op != .Period and infix_op.op != .Catch) {
const token_type: TokenType = switch (infix_op.op) { const token_type: TokenType = switch (infix_op.op) {
.BoolAnd, .BoolOr, .UnwrapOptional => .keyword, .BoolAnd, .BoolOr, .UnwrapOptional => .keyword,
@ -492,13 +492,13 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
}; };
try writeToken(builder, infix_op.op_token, token_type); 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) { switch (infix_op.op) {
.Catch => |n| { .Catch => |n| {
try writeToken(builder, infix_op.op_token, .keyword); 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, n });
try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, infix_op.rhs}); try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, infix_op.rhs });
}, },
.Period => { .Period => {
const rhs_str = handle.tree.tokenSlice(infix_op.rhs.firstToken()); const rhs_str = handle.tree.tokenSlice(infix_op.rhs.firstToken());
@ -557,7 +557,7 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
switch (prefix_op.op) { switch (prefix_op.op) {
.ArrayType => |info| { .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| { .SliceType, .PtrType => |info| {
if (prefix_op.op == .PtrType) try writeToken(builder, prefix_op.op_token, tok_type); if (prefix_op.op == .PtrType) try writeToken(builder, prefix_op.op_token, tok_type);
@ -568,7 +568,7 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
} else { } else {
try writeToken(builder, prefix_op.op_token + 2, .keyword); 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.const_token, .keyword);
try writeToken(builder, info.volatile_token, .keyword); try writeToken(builder, info.volatile_token, .keyword);
@ -577,20 +577,20 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
else => try writeToken(builder, prefix_op.op_token, tok_type), 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 => { .ArrayInitializer => {
const array_initializer = node.cast(ast.Node.ArrayInitializer).?; const array_initializer = node.cast(ast.Node.ArrayInitializer).?;
try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, array_initializer.lhs}); 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}); for (array_initializer.listConst()) |elem| try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, elem });
}, },
.ArrayInitializerDot => { .ArrayInitializerDot => {
const array_initializer = node.cast(ast.Node.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 => { .StructInitializer => {
const struct_initializer = node.cast(ast.Node.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) { 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| .other => |type_node| if (type_node.cast(ast.Node.ContainerDecl)) |container_decl|
fieldTokenType(container_decl, handle) fieldTokenType(container_decl, handle)
@ -609,7 +609,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, tok_type);
} }
try writeToken(builder, field_init.name_token + 1, .operator); 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); try gap_highlighter.end(struct_initializer.rtoken);
}, },
@ -624,40 +624,40 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
try writeToken(builder, field_init.period_token, .field); try writeToken(builder, field_init.period_token, .field);
try writeToken(builder, field_init.name_token, .field); try writeToken(builder, field_init.name_token, .field);
try writeToken(builder, field_init.name_token + 1, .operator); 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); try gap_highlighter.end(struct_initializer.rtoken);
}, },
.Call => { .Call => {
const call = node.cast(ast.Node.Call).?; const call = node.cast(ast.Node.Call).?;
try writeToken(builder, call.async_token, .keyword); 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 (builder.current_token) |curr_tok| {
if (curr_tok != call.lhs.lastToken() and handle.tree.token_ids[call.lhs.lastToken()] == .Identifier) { if (curr_tok != call.lhs.lastToken() and handle.tree.token_ids[call.lhs.lastToken()] == .Identifier) {
try writeToken(builder, call.lhs.lastToken(), .function); 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 => { .SuffixOp => {
const suffix_op = node.cast(ast.Node.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) { switch (suffix_op.op) {
.ArrayAccess => |n| { .ArrayAccess => |n| {
try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, n}); try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, n });
}, },
.Slice => |s| { .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 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.end });
try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, s.sentinel}); try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, s.sentinel });
}, },
else => try writeToken(builder, suffix_op.rtoken, .operator), else => try writeToken(builder, suffix_op.rtoken, .operator),
} }
}, },
.GroupedExpression => { .GroupedExpression => {
const grouped_expr = node.cast(ast.Node.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 => { .ControlFlowExpression => {
const cfe = node.cast(ast.Node.ControlFlowExpression).?; const cfe = node.cast(ast.Node.ControlFlowExpression).?;
@ -667,12 +667,12 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
.Continue => |label| if (label) |n| try writeToken(builder, n.firstToken(), .label), .Continue => |label| if (label) |n| try writeToken(builder, n.firstToken(), .label),
else => {}, else => {},
} }
try await @asyncCall(child_frame, {}, writeNodeTokens, .{builder, arena, store, cfe.rhs}); try await @asyncCall(child_frame, {}, writeNodeTokens, .{ builder, arena, store, cfe.rhs });
}, },
.Suspend => { .Suspend => {
const suspend_node = node.cast(ast.Node.Suspend).?; const suspend_node = node.cast(ast.Node.Suspend).?;
try writeToken(builder, suspend_node.suspend_token, .keyword); 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 => { .IntegerLiteral => {
try writeToken(builder, node.firstToken(), .number); try writeToken(builder, node.firstToken(), .number);
@ -689,7 +689,7 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
const builtin_call = node.cast(ast.Node.BuiltinCall).?; const builtin_call = node.cast(ast.Node.BuiltinCall).?;
try writeToken(builder, builtin_call.builtin_token, .builtin); try writeToken(builder, builtin_call.builtin_token, .builtin);
for (builtin_call.paramsConst()) |param| 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 => { .StringLiteral, .CharLiteral => {
try writeToken(builder, node.firstToken(), .string); try writeToken(builder, node.firstToken(), .string);
@ -705,7 +705,7 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
const asm_expr = node.cast(ast.Node.Asm).?; const asm_expr = node.cast(ast.Node.Asm).?;
try writeToken(builder, asm_expr.asm_token, .keyword); try writeToken(builder, asm_expr.asm_token, .keyword);
try writeToken(builder, asm_expr.volatile_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. // TODO Inputs, outputs.
}, },
.VarType => { .VarType => {
@ -715,8 +715,8 @@ fn writeNodeTokens(builder: *Builder, arena: *std.heap.ArenaAllocator, store: *D
const test_decl = node.cast(ast.Node.TestDecl).?; const test_decl = node.cast(ast.Node.TestDecl).?;
if (test_decl.doc_comments) |doc| try writeDocComments(builder, handle.tree, doc); if (test_decl.doc_comments) |doc| try writeDocComments(builder, handle.tree, doc);
try writeToken(builder, test_decl.test_token, .keyword); 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.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.body_node });
}, },
else => {}, else => {},
} }